Core/Build: Fix linking and sooo many compile warnings

37 files changed, 468 insertions, 303 deletions

diff --git a/src/server/collision/Management/MMapManager.cpp b/src/server/collision/Management/MMapManager.cpp
index c7dea358d92..1b6cf5c0260 100644
--- a/src/server/collision/Management/MMapManager.cpp
+++ b/src/server/collision/Management/MMapManager.cpp
@@ -52,8 +52,14 @@ namespace MMAP
         }
 
         dtNavMeshParams params;
-        fread(&params, sizeof(dtNavMeshParams), 1, file);
+        int count = fread(&params, sizeof(dtNavMeshParams), 1, file);
         fclose(file);
+        if (count != 1)
+        {
+            sLog->outDebug(LOG_FILTER_MAPS, "MMAP:loadMapData: Error: Could not read params from file '%s'", fileName);
+            delete [] fileName;
+            return false;
+        }
 
         dtNavMesh* mesh = dtAllocNavMesh();
         ASSERT(mesh);
@@ -82,7 +88,7 @@ namespace MMAP
         return uint32(x << 16 | y);
     }
 
-    bool MMapManager::loadMap(const std::string& basePath, uint32 mapId, int32 x, int32 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 (!loadMapData(mapId))
@@ -114,9 +120,7 @@ namespace MMAP
 
         // read header
         MmapTileHeader fileHeader;
-        fread(&fileHeader, sizeof(MmapTileHeader), 1, file);
-
-        if (fileHeader.mmapMagic != MMAP_MAGIC)
+        if (fread(&fileHeader, sizeof(MmapTileHeader), 1, file) != 1 || fileHeader.mmapMagic != MMAP_MAGIC)
         {
             sLog->outError(LOG_FILTER_MAPS, "MMAP:loadMap: Bad header in mmap %03u%02i%02i.mmtile", mapId, x, y);
             return false;
diff --git a/src/server/collision/Models/ModelInstance.h b/src/server/collision/Models/ModelInstance.h
index 6d1b7c68bd5..f26089bb46c 100644
--- a/src/server/collision/Models/ModelInstance.h
+++ b/src/server/collision/Models/ModelInstance.h
@@ -75,7 +75,7 @@ namespace VMAP
             float iInvScale;
             WorldModel* iModel;
         public:
-            WorldModel* const getWorldModel();
+            WorldModel* getWorldModel();
     };
 } // namespace VMAP
 
diff --git a/src/tools/map_extractor/adt.cpp b/src/tools/map_extractor/adt.cpp
index fde70681113..505813c4bd0 100644
--- a/src/tools/map_extractor/adt.cpp
+++ b/src/tools/map_extractor/adt.cpp
@@ -6,6 +6,13 @@
 int holetab_h[4] = {0x1111, 0x2222, 0x4444, 0x8888};
 int holetab_v[4] = {0x000F, 0x00F0, 0x0F00, 0xF000};
 
+u_map_fcc MHDRMagic = { {'M','H','D','R'} };
+u_map_fcc MCINMagic = { {'M','C','I','N'} };
+u_map_fcc MH20Magic = { {'M','H','2','0'} };
+u_map_fcc MCNKMagic = { {'M','C','N','K'} };
+u_map_fcc MCVTMagic = { {'M','C','V','T'} };
+u_map_fcc MCLQMagic = { {'M','C','L','Q'} };
+
 bool isHole(int holes, int i, int j)
 {
     int testi = i / 2;
@@ -53,7 +60,7 @@ bool ADT_file::prepareLoadedData()
 
 bool adt_MHDR::prepareLoadedData()
 {
-    if (fcc != 'MHDR')
+    if (fcc != MHDRMagic.fcc)
         return false;
 
     if (size!=sizeof(adt_MHDR)-8)
@@ -72,7 +79,7 @@ bool adt_MHDR::prepareLoadedData()
 
 bool adt_MCIN::prepareLoadedData()
 {
-    if (fcc != 'MCIN')
+    if (fcc != MCINMagic.fcc)
         return false;
 
     // Check cells data
@@ -86,7 +93,7 @@ bool adt_MCIN::prepareLoadedData()
 
 bool adt_MH2O::prepareLoadedData()
 {
-    if (fcc != 'MH2O')
+    if (fcc != MH20Magic.fcc)
         return false;
 
     // Check liquid data
@@ -98,7 +105,7 @@ bool adt_MH2O::prepareLoadedData()
 
 bool adt_MCNK::prepareLoadedData()
 {
-    if (fcc != 'MCNK')
+    if (fcc != MCNKMagic.fcc)
         return false;
 
     // Check height map
@@ -113,7 +120,7 @@ bool adt_MCNK::prepareLoadedData()
 
 bool adt_MCVT::prepareLoadedData()
 {
-    if (fcc != 'MCVT')
+    if (fcc != MCVTMagic.fcc)
         return false;
 
     if (size != sizeof(adt_MCVT)-8)
@@ -124,8 +131,8 @@ bool adt_MCVT::prepareLoadedData()
 
 bool adt_MCLQ::prepareLoadedData()
 {
-    if (fcc != 'MCLQ')
+    if (fcc != MCLQMagic.fcc)
         return false;
 
     return true;
-}
\ No newline at end of file
+}
diff --git a/src/tools/map_extractor/loadlib.cpp b/src/tools/map_extractor/loadlib.cpp
index 465eb04083f..d1ea40110de 100644
--- a/src/tools/map_extractor/loadlib.cpp
+++ b/src/tools/map_extractor/loadlib.cpp
@@ -6,6 +6,8 @@
 
 class MPQFile;
 
+u_map_fcc MverMagic = { {'M','V','E','R'} };
+
 FileLoader::FileLoader()
 {
     data = 0;
@@ -49,7 +51,7 @@ bool FileLoader::prepareLoadedData()
 {
     // Check version
     version = (file_MVER *) data;
-    if (version->fcc != 'MVER')
+    if (version->fcc != MverMagic.fcc)
         return false;
     if (version->ver != FILE_FORMAT_VERSION)
         return false;
diff --git a/src/tools/map_extractor/loadlib/loadlib.h b/src/tools/map_extractor/loadlib/loadlib.h
index bf6c0706d46..f32f46c63b9 100644
--- a/src/tools/map_extractor/loadlib/loadlib.h
+++ b/src/tools/map_extractor/loadlib/loadlib.h
@@ -29,6 +29,12 @@ typedef uint8_t            uint8;
 
 #define FILE_FORMAT_VERSION    18
 
+union u_map_fcc
+{
+    char   fcc_txt[4];
+    uint32 fcc;
+};
+
 //
 // File version chunk
 //
diff --git a/src/tools/map_extractor/wdt.cpp b/src/tools/map_extractor/wdt.cpp
index dedefbb64e5..90a07eafab3 100644
--- a/src/tools/map_extractor/wdt.cpp
+++ b/src/tools/map_extractor/wdt.cpp
@@ -2,23 +2,27 @@
 
 #include "wdt.h"
 
+u_map_fcc MWMOMagic = { {'M', 'W', 'M', 'O'} };
+u_map_fcc MPHDMagic = { {'M', 'P', 'H', 'D'} };
+u_map_fcc MAINMagic = { {'M', 'A', 'I', 'N'} };
+
 bool wdt_MWMO::prepareLoadedData()
 {
-    if (fcc != 'MWMO')
+    if (fcc != MWMOMagic.fcc)
         return false;
     return true;
 }
 
 bool wdt_MPHD::prepareLoadedData()
 {
-    if (fcc != 'MPHD')
+    if (fcc != MPHDMagic.fcc)
         return false;
     return true;
 }
 
 bool wdt_MAIN::prepareLoadedData()
 {
-    if (fcc != 'MAIN')
+    if (fcc != MAINMagic.fcc)
         return false;
     return true;
 }
@@ -59,4 +63,4 @@ bool WDT_file::prepareLoadedData()
     if (!wmo->prepareLoadedData())
         return false;
     return true;
-}
\ No newline at end of file
+}
diff --git a/src/tools/mesh_extractor/ADT.cpp b/src/tools/mesh_extractor/ADT.cpp
index 8d7dce9ae11..c2ac19d5be0 100644
--- a/src/tools/mesh_extractor/ADT.cpp
+++ b/src/tools/mesh_extractor/ADT.cpp
@@ -3,7 +3,8 @@
 #include "LiquidHandler.h"
 #include "WorldModelHandler.h"
 
-ADT::ADT( std::string file ) : ObjectData(NULL), Data(NULL), _DoodadHandler(NULL), _WorldModelHandler(NULL), _LiquidHandler(NULL), HasObjectData(false)
+ADT::ADT( std::string file ) : ObjectData(NULL), Data(NULL), HasObjectData(false),
+    _DoodadHandler(NULL), _WorldModelHandler(NULL), _LiquidHandler(NULL)
 {
     Data = new ChunkedData(file);
     ObjectData = new ChunkedData(Utils::Replace(file, ".adt", "_obj0.adt"));
@@ -31,7 +32,6 @@ void ADT::Read()
 {
     Header.Read(Data->GetChunkByName("MHDR")->GetStream());
     MapChunks.reserve(16 * 16);
-    int mapChunkIndex = 0;
 
     for (std::vector<Chunk*>::iterator itr = Data->Chunks.begin(); itr != Data->Chunks.end(); ++itr)
         if ((*itr)->Name == "MCNK")
diff --git a/src/tools/mesh_extractor/CMakeLists.txt b/src/tools/mesh_extractor/CMakeLists.txt
index 8ef48a90742..29c571d9301 100644
--- a/src/tools/mesh_extractor/CMakeLists.txt
+++ b/src/tools/mesh_extractor/CMakeLists.txt
@@ -26,6 +26,7 @@ if( UNIX )
     ${CMAKE_SOURCE_DIR}/dep/recastnavigation/Detour
     ${CMAKE_SOURCE_DIR}/dep/libmpq
     ${CMAKE_SOURCE_DIR}/dep/g3dlite/include
+    ${ACE_INCLUDE_DIR}
     ${MYSQL_INCLUDE_DIR}
     ${OPENSSL_INCLUDE_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
@@ -77,4 +78,4 @@ if( UNIX )
   install(TARGETS MeshExtractor DESTINATION bin)
 elseif( WIN32 )
   install(TARGETS MeshExtractor DESTINATION "${CMAKE_INSTALL_PREFIX}")
-endif()
\ No newline at end of file
+endif()
diff --git a/src/tools/mesh_extractor/Cache.h b/src/tools/mesh_extractor/Cache.h
index 90e2c138376..34293b14b54 100644
--- a/src/tools/mesh_extractor/Cache.h
+++ b/src/tools/mesh_extractor/Cache.h
@@ -14,7 +14,7 @@ class GenericCache
 public:
     GenericCache() {}
 
-    static const int32 FlushLimit = 1000;
+    static const uint32 FlushLimit = 1000;
 
     void Insert(K key, T* val)
     {
@@ -59,4 +59,4 @@ public:
 };
 
 extern CacheClass* Cache;
-#endif
\ No newline at end of file
+#endif
diff --git a/src/tools/mesh_extractor/Chunk.cpp b/src/tools/mesh_extractor/Chunk.cpp
index 2f521f1badd..9f2898a46e0 100644
--- a/src/tools/mesh_extractor/Chunk.cpp
+++ b/src/tools/mesh_extractor/Chunk.cpp
@@ -12,12 +12,12 @@ int32 Chunk::FindSubChunkOffset(std::string name)
     uint32 matched = 0;
     while (uint32(ftell(stream)) < Utils::Size(stream))
     {
-        char b;
-        fread(&b, sizeof(char), 1, stream);
-        if (b == name[matched])
-            ++matched;
-        else
+        char b = 0;
+        if (fread(&b, sizeof(char), 1, stream) != 1 || b != name[matched])
             matched = 0;
+        else
+            ++matched;
+            
         if (matched == 4)
             return ftell(stream) - 4;
     }
diff --git a/src/tools/mesh_extractor/ChunkedData.cpp b/src/tools/mesh_extractor/ChunkedData.cpp
index 4d609d8f6b2..e0db12a6be7 100644
--- a/src/tools/mesh_extractor/ChunkedData.cpp
+++ b/src/tools/mesh_extractor/ChunkedData.cpp
@@ -36,7 +36,8 @@ void ChunkedData::Load( uint32 maxLength, uint32 chunksHint )
         // Utils::Reverse(nameBytes);
         name = std::string(name.rbegin(), name.rend());
         uint32 length;
-        fread(&length, sizeof(uint32), 1, Stream);
+        if (fread(&length, sizeof(uint32), 1, Stream) != 1)
+            continue;
         calcOffset += 8;
         Chunks.push_back(new Chunk(name.c_str(), length, calcOffset + baseOffset, Stream));
         calcOffset += length;
diff --git a/src/tools/mesh_extractor/ContinentBuilder.cpp b/src/tools/mesh_extractor/ContinentBuilder.cpp
index 013c0ff256a..9b5c9f9c77b 100644
--- a/src/tools/mesh_extractor/ContinentBuilder.cpp
+++ b/src/tools/mesh_extractor/ContinentBuilder.cpp
@@ -16,7 +16,7 @@ private:
     dtNavMeshParams Params;
     ContinentBuilder* cBuilder;
 public:
-    BuilderThread(ContinentBuilder* _cBuilder, bool deb, dtNavMeshParams& params) : Free(true), debug(deb), Params(params), cBuilder(_cBuilder) {}
+    BuilderThread(ContinentBuilder* _cBuilder, bool deb, dtNavMeshParams& params) : debug(deb), Params(params), cBuilder(_cBuilder), Free(true) {}
     void SetData(int x, int y, int map, std::string cont) { X = x; Y = y; MapId = map; Continent = cont; }
 
     int svc()
@@ -113,7 +113,7 @@ void ContinentBuilder::Build(bool debug)
     std::vector<BuilderThread*> Threads;
     for (uint32 i = 0; i < NumberOfThreads; ++i)
         Threads.push_back(new BuilderThread(this, debug, params));
-    printf("Map %s ( %i ) has %i tiles. Building them with %i threads\n", Continent.c_str(), MapId, TileMap->TileTable.size(), NumberOfThreads);
+    printf("Map %s ( %i ) has %u tiles. Building them with %i 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)
     {
         bool next = false;
diff --git a/src/tools/mesh_extractor/ContinentBuilder.h b/src/tools/mesh_extractor/ContinentBuilder.h
index 4c16fa0727e..3d7b879879e 100644
--- a/src/tools/mesh_extractor/ContinentBuilder.h
+++ b/src/tools/mesh_extractor/ContinentBuilder.h
@@ -7,7 +7,11 @@
 class ContinentBuilder
 {
 public:
-    ContinentBuilder(std::string continent, uint32 mapId, WDT* wdt, uint32 tn) : MapId(mapId), Continent(continent), TileMap(wdt), NumberOfThreads(tn), tileXMin(64), tileYMin(64), tileXMax(0), tileYMax(0) {}
+    ContinentBuilder(std::string continent, uint32 mapId, WDT* wdt, uint32 tn) :
+        Continent(continent), TileMap(wdt), MapId(mapId),
+        NumberOfThreads(tn), tileXMin(64), tileYMin(64), tileXMax(0), tileYMax(0)
+        {}
+
     void Build(bool debug);
     void getTileBounds(uint32 tileX, uint32 tileY, float* verts, int vertCount, float* bmin, float* bmax);
     void CalculateTileBounds();
@@ -23,4 +27,4 @@ private:
     int tileXMax;
     int tileYMax;
 };
-#endif
\ No newline at end of file
+#endif
diff --git a/src/tools/mesh_extractor/DBC.cpp b/src/tools/mesh_extractor/DBC.cpp
index c50e02014da..5c54d975487 100644
--- a/src/tools/mesh_extractor/DBC.cpp
+++ b/src/tools/mesh_extractor/DBC.cpp
@@ -2,16 +2,19 @@
 #include "DBC.h"
 #include "Common.h"
 
-DBC::DBC( FILE* stream ) : StringBlock(NULL), IsFaulty(true), StringBlockSize(0)
+DBC::DBC( FILE* stream ) : StringBlock(NULL), StringBlockSize(0), IsFaulty(true)
 {
     char magic[5];
-    fread(&magic, sizeof(char), 4, stream);
+    uint count = 0;
+    count += fread(&magic, sizeof(char), 4, stream);
     magic[4] = '\0';
-    fread(&RecordCount, sizeof(uint32), 1, stream);
+    count += fread(&RecordCount, sizeof(uint32), 1, stream);
     Records.reserve(RecordCount);
-    fread(&Fields, sizeof(uint32), 1, stream);
-    fread(&RecordSize, sizeof(uint32), 1, stream);
-    fread(&StringBlockSize, sizeof(uint32), 1, stream);
+    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++)
     {
@@ -26,13 +29,16 @@ DBC::DBC( FILE* stream ) : StringBlock(NULL), IsFaulty(true), StringBlockSize(0)
                 break;
             }
             uint32 tmp;
-            fread(&tmp, sizeof(uint32), 1, stream);
+            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 = new uint8[StringBlockSize];
-    fread(StringBlock, sizeof(uint8), StringBlockSize, stream);
+    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 )
diff --git a/src/tools/mesh_extractor/DoodadHandler.cpp b/src/tools/mesh_extractor/DoodadHandler.cpp
index 4e8028b3dff..56c2a7986f8 100644
--- a/src/tools/mesh_extractor/DoodadHandler.cpp
+++ b/src/tools/mesh_extractor/DoodadHandler.cpp
@@ -30,7 +30,8 @@ void DoodadHandler::ProcessInternal( ChunkedData* subChunks )
     for (uint32 i = 0; i < refCount; i++)
     {
         int32 index;
-        fread(&index, sizeof(int32), 1, stream);
+        if (int 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];
@@ -81,7 +82,8 @@ void DoodadHandler::ReadDoodadPaths( Chunk* id, Chunk* data )
         FILE* idStream = id->GetStream();
         fseek(idStream, i * 4, SEEK_CUR);
         uint32 offset;
-        fread(&offset, sizeof(uint32), 1, idStream);
+        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));
diff --git a/src/tools/mesh_extractor/DoodadHandler.h b/src/tools/mesh_extractor/DoodadHandler.h
index a212b032d1d..981834ec7ac 100644
--- a/src/tools/mesh_extractor/DoodadHandler.h
+++ b/src/tools/mesh_extractor/DoodadHandler.h
@@ -19,12 +19,16 @@ public:
 
     void Read(FILE* stream)
     {
-        fread(&MmidIndex, sizeof(uint32), 1, stream);
-        fread(&UniqueId, sizeof(uint32), 1, 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);
-        fread(&DecimalScale, sizeof(uint16), 1, stream);
-        fread(&Flags, sizeof(uint16), 1, stream);
+        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);
     }
 };
 
@@ -50,4 +54,4 @@ private:
     std::vector<DoodadDefinition>* _definitions;
     std::vector<std::string>* _paths;
 };
-#endif
\ No newline at end of file
+#endif
diff --git a/src/tools/mesh_extractor/LiquidHandler.cpp b/src/tools/mesh_extractor/LiquidHandler.cpp
index 7844130ab34..285ea1a5b74 100644
--- a/src/tools/mesh_extractor/LiquidHandler.cpp
+++ b/src/tools/mesh_extractor/LiquidHandler.cpp
@@ -50,17 +50,17 @@ void LiquidHandler::HandleNewLiquid()
                 fseek(stream, chunk->Offset + information.OffsetMask2, SEEK_SET);
                 uint32 size = ceil(information.Width * information.Height / 8.0f);
                 uint8* altMask = new uint8[size];
-                fread(altMask, sizeof(uint8), size, stream);
-
-                for (uint32 mi = 0; mi < size; mi++)
-                    renderMask.Mask[mi + information.OffsetY] |= altMask[mi];
+                if (fread(altMask, sizeof(uint8), size, stream) == size)
+                    for (uint32 mi = 0; mi < size; mi++)
+                        renderMask.Mask[mi + information.OffsetY] |= altMask[mi];
                 delete[] altMask;
             }
             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++)
-                    fread(&heights[x][y], sizeof(float), 1, stream);
+                    if (fread(&heights[x][y], sizeof(float), 1, stream) != 1)
+                        return;
         }
         else
         {
diff --git a/src/tools/mesh_extractor/MapChunk.cpp b/src/tools/mesh_extractor/MapChunk.cpp
index 67f4061035e..8fe40773d43 100644
--- a/src/tools/mesh_extractor/MapChunk.cpp
+++ b/src/tools/mesh_extractor/MapChunk.cpp
@@ -58,7 +58,8 @@ void MapChunk::GenerateVertices( FILE* stream )
         for (int i = 0; i < values; i++)
         {
             float tmp;
-            fread(&tmp, sizeof(float), 1, stream);
+            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;
diff --git a/src/tools/mesh_extractor/MeshExtractor.cpp b/src/tools/mesh_extractor/MeshExtractor.cpp
index 7379ba87117..b164ff5861d 100644
--- a/src/tools/mesh_extractor/MeshExtractor.cpp
+++ b/src/tools/mesh_extractor/MeshExtractor.cpp
@@ -59,7 +59,7 @@ void ExtractDBCs()
     {
         printf("Extracting DBCs for locale %s\n", MPQManager::Languages[*itr]);
         std::string path = baseDBCPath;
-        if (*itr != MPQHandler->BaseLocale)
+        if (*itr != uint32(MPQHandler->BaseLocale))
         {
             path += std::string(MPQManager::Languages[*itr]) + "/";
             Utils::CreateDir(path);
@@ -198,7 +198,6 @@ void ExtractGameobjectModels()
             fwrite(&model.Header.CountGroups, sizeof(uint32), 1, output);
             fwrite(&model.Header.WmoId, sizeof(uint32), 1, output);
 
-            uint32 i = 0;
             for (std::vector<WorldModelGroup>::iterator itr2 = model.Groups.begin(); itr2 != model.Groups.end(); ++itr2)
             {
                 fwrite(&itr2->Header.Flags, sizeof(uint32), 1, output);
@@ -261,7 +260,7 @@ bool HandleArgs(int argc, char** argv, uint32& threads, std::set<uint32>& mapLis
             for (Tokenizer::const_iterator itr = tokens.begin(); itr != tokens.end(); ++itr)
                 mapList.insert(atoi(*itr));
 
-            printf("Extracting only provided list of maps (%u).\n", mapList.size());
+            printf("Extracting only provided list of maps (%u).\n", uint32(mapList.size()));
         }
         else if (strcmp(argv[i], "--debug") == 0)
         {
@@ -314,18 +313,27 @@ void LoadTile(dtNavMesh*& navMesh, const char* tile)
 {
     FILE* f = fopen(tile, "rb");
     MmapTileHeader header;
-    fread(&header, sizeof(MmapTileHeader), 1, f);
+
+    if (fread(&header, sizeof(MmapTileHeader), 1, f) != 1)
+        return;
+
     uint8* nav = new uint8[header.size];
-    fread(nav, header.size, 1, f);
+    if (fread(nav, header.size, 1, f) != 1)
+        return;
 
-    dtStatus res = navMesh->addTile(nav, header.size, DT_TILE_FREE_DATA, 0, NULL);
+    navMesh->addTile(nav, header.size, DT_TILE_FREE_DATA, 0, NULL);
 
     fclose(f);
 }
 
 int main(int argc, char* argv[])
 {
-    system("pause");
+    if (!system("pause"))
+    {
+        printf("main: Error in system call to pause\n");
+        return -1;
+    }
+
     uint32 threads = 4, extractFlags = 0;
     std::set<uint32> mapIds;
     bool debug = false;
@@ -383,8 +391,13 @@ int main(int argc, char* argv[])
 
         FILE* mmap = fopen(".mmap", "rb");
         dtNavMeshParams params;
-        fread(&params, sizeof(dtNavMeshParams), 1, mmap);
+        int count = fread(&params, sizeof(dtNavMeshParams), 1, mmap);
         fclose(mmap);
+        if (count != 1)
+        {
+            printf("main: Error reading from .mmap\n");
+            return 0;
+        }
 
         dtNavMesh* navMesh = new dtNavMesh();
         dtNavMeshQuery* navMeshQuery = new dtNavMeshQuery();
@@ -401,10 +414,9 @@ int main(int argc, char* argv[])
 
         float nearestPt[3];
 
-        dtStatus status = navMeshQuery->findNearestPoly(m_spos, m_polyPickExt, &m_filter, &m_startRef, nearestPt);
-        status = navMeshQuery->findNearestPoly(m_epos, m_polyPickExt, &m_filter, &m_endRef, nearestPt);
+        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;
@@ -415,4 +427,4 @@ int main(int argc, char* argv[])
     }
    
     return 0;
-}
\ No newline at end of file
+}
diff --git a/src/tools/mesh_extractor/Model.cpp b/src/tools/mesh_extractor/Model.cpp
index 10fde0ebc2d..77b1adbeaa0 100644
--- a/src/tools/mesh_extractor/Model.cpp
+++ b/src/tools/mesh_extractor/Model.cpp
@@ -47,9 +47,12 @@ void Model::ReadBoundingTriangles( FILE* stream )
     {
         Triangle<uint16> tri;
         tri.Type = Constants::TRIANGLE_TYPE_DOODAD;
-        fread(&tri.V0, sizeof(uint16), 1, stream);
-        fread(&tri.V1, sizeof(uint16), 1, stream);
-        fread(&tri.V2, sizeof(uint16), 1, stream);
+        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);
     }
 }
diff --git a/src/tools/mesh_extractor/TileBuilder.cpp b/src/tools/mesh_extractor/TileBuilder.cpp
index 2a02bc50cd4..4a14cbbd51d 100644
--- a/src/tools/mesh_extractor/TileBuilder.cpp
+++ b/src/tools/mesh_extractor/TileBuilder.cpp
@@ -12,7 +12,8 @@
 
 #include "ace/Synch.h"
 
-TileBuilder::TileBuilder(ContinentBuilder* _cBuilder, std::string world, int x, int y, uint32 mapId) : _Geometry(NULL), World(world), X(x), Y(y), MapId(mapId), DataSize(0), cBuilder(_cBuilder)
+TileBuilder::TileBuilder(ContinentBuilder* _cBuilder, std::string world, int x, int y, uint32 mapId) :
+    World(world), X(x), Y(y), MapId(mapId), _Geometry(NULL), DataSize(0), cBuilder(_cBuilder)
 {
     /*
         Test, non-working values
@@ -62,7 +63,7 @@ TileBuilder::TileBuilder(ContinentBuilder* _cBuilder, std::string world, int x,
     Context = new rcContext;
 }
 
-void TileBuilder::CalculateTileBounds( float*& bmin, float*& bmax, dtNavMeshParams& navMeshParams )
+void TileBuilder::CalculateTileBounds( float*& bmin, float*& bmax, dtNavMeshParams& /*navMeshParams*/ )
 {
     bmin = new float[3];
     bmax = new float[3];
diff --git a/src/tools/mesh_extractor/Utils.cpp b/src/tools/mesh_extractor/Utils.cpp
index 3639cb88acf..119ac94f94f 100644
--- a/src/tools/mesh_extractor/Utils.cpp
+++ b/src/tools/mesh_extractor/Utils.cpp
@@ -53,8 +53,7 @@ std::string Utils::ReadString( FILE* file )
     while (true)
     {
         char b;
-        fread(&b, sizeof(char), 1, file);
-        if (b == 0)
+        if (fread(&b, sizeof(char), 1, file) != 1 || b == 0)
             break;
         ret[i++] = b;
     }
@@ -155,7 +154,7 @@ Vector3 Utils::VectorTransform( Vector3 vec, G3D::Matrix4 matrix )
 
 std::string Utils::GetPathBase( std::string path )
 {
-    int lastIndex = path.find_last_of(".");
+    size_t lastIndex = path.find_last_of(".");
     if (lastIndex != std::string::npos)
         return path.substr(0, lastIndex);
     return path;
@@ -164,11 +163,12 @@ std::string Utils::GetPathBase( std::string path )
 Vector3 Vector3::Read( FILE* file )
 {
     Vector3 ret;
-    fread(&ret, sizeof(Vector3), 1, file);
+    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(G3D::Matrix4 transformation, Vector3 basePosition, float height, int x, int y)
+Vector3 Utils::GetLiquidVert(G3D::Matrix4 transformation, Vector3 basePosition, float height, int /*x*/, int /*y*/)
 {
     if (Utils::Distance(height, 0.0f) > 0.5f)
         basePosition.z = 0.0f;
@@ -208,14 +208,18 @@ void Utils::SaveToDisk( FILE* stream, std::string path )
     FILE* disk = fopen(path.c_str(), "wb");
     if (!disk)
     {
-        printf("Could not save file %s to disk, please verify that you have write permissions on that directory\n", path.c_str());
+        printf("SaveToDisk: Could not save file %s to disk, please verify that you have write permissions on that directory\n", path.c_str());
         return;
     }
 
     uint32 size = Utils::Size(stream);
     uint8* data = new uint8[size];
     // Read the data to an array
-    fread(data, 1, size, stream);
+    if (fread(data, 1, size, stream) != 1)
+    {
+        printf("SaveToDisk: Error reading from Stream while trying to save file %s to disck.\n", path.c_str());
+        return;        
+    }
     // And write it in the file
     fwrite(data, 1, size, disk);
 
@@ -242,136 +246,164 @@ std::string Utils::GetExtension( std::string path )
 
 void MapChunkHeader::Read(FILE* stream)
 {
-    fread(&Flags, sizeof(uint32), 1, stream);
-    fread(&IndexX, sizeof(uint32), 1, stream);
-    fread(&IndexY, sizeof(uint32), 1, stream);
-    fread(&Layers, sizeof(uint32), 1, stream);
-    fread(&DoodadRefs, sizeof(uint32), 1, stream);
-    fread(&OffsetMCVT, sizeof(uint32), 1, stream);
-    fread(&OffsetMCNR, sizeof(uint32), 1, stream);
-    fread(&OffsetMCLY, sizeof(uint32), 1, stream);
-    fread(&OffsetMCRF, sizeof(uint32), 1, stream);
-    fread(&OffsetMCAL, sizeof(uint32), 1, stream);
-    fread(&SizeMCAL, sizeof(uint32), 1, stream);
-    fread(&OffsetMCSH, sizeof(uint32), 1, stream);
-    fread(&SizeMCSH, sizeof(uint32), 1, stream);
-    fread(&AreaId, sizeof(uint32), 1, stream);
-    fread(&MapObjectRefs, sizeof(uint32), 1, stream);
-    fread(&Holes, sizeof(uint32), 1, 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];
-    fread(LowQualityTextureMap, sizeof(uint32), 4, stream);
-    fread(&PredTex, sizeof(uint32), 1, stream);
-    fread(&NumberEffectDoodad, sizeof(uint32), 1, stream);
-    fread(&OffsetMCSE, sizeof(uint32), 1, stream);
-    fread(&SoundEmitters, sizeof(uint32), 1, stream);
-    fread(&OffsetMCLQ, sizeof(uint32), 1, stream);
-    fread(&SizeMCLQ, sizeof(uint32), 1, stream);
+    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);
-    fread(&OffsetMCCV, sizeof(uint32), 1, stream);
+    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(FILE* stream)
 {
-    fread(&Flags, sizeof(uint32), 1, stream);
-    fread(&OffsetMCIN, sizeof(uint32), 1, stream);
-    fread(&OffsetMTEX, sizeof(uint32), 1, stream);
-    fread(&OffsetMMDX, sizeof(uint32), 1, stream);
-    fread(&OffsetMMID, sizeof(uint32), 1, stream);
-    fread(&OffsetMWMO, sizeof(uint32), 1, stream);
-    fread(&OffsetMWID, sizeof(uint32), 1, stream);
-    fread(&OffsetMDDF, sizeof(uint32), 1, stream);
-    fread(&OffsetMODF, sizeof(uint32), 1, stream);
-    fread(&OffsetMFBO, sizeof(uint32), 1, stream);
-    fread(&OffsetMH2O, sizeof(uint32), 1, stream);
-    fread(&OffsetMTFX, sizeof(uint32), 1, stream);
+    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(FILE* stream)
 {
-    fread(&Magic, sizeof(char), 4, stream);
+    int count = 0;
+
+    count += fread(&Magic, sizeof(char), 4, stream);
     Magic[4] = '\0'; // null-terminate it.
-    fread(&Version, sizeof(uint32), 1, stream);
-    fread(&LengthModelName, sizeof(uint32), 1, stream);
-    fread(&OffsetName, sizeof(uint32), 1, stream);
-    fread(&ModelFlags, sizeof(uint32), 1, stream);
-    fread(&CountGlobalSequences, sizeof(uint32), 1, stream);
-    fread(&OffsetGlobalSequences, sizeof(uint32), 1, stream);
-    fread(&CountAnimations, sizeof(uint32), 1, stream);
-    fread(&OffsetAnimations, sizeof(uint32), 1, stream);
-    fread(&CountAnimationLookup, sizeof(uint32), 1, stream);
-    fread(&OffsetAnimationLookup, sizeof(uint32), 1, stream);
-    fread(&CountBones, sizeof(uint32), 1, stream);
-    fread(&OffsetBones, sizeof(uint32), 1, stream);
-    fread(&CountKeyBoneLookup, sizeof(uint32), 1, stream);
-    fread(&OffsetKeyBoneLookup, sizeof(uint32), 1, stream);
-    fread(&CountVertices, sizeof(uint32), 1, stream);
-    fread(&OffsetVertices, sizeof(uint32), 1, stream);
-    fread(&CountViews, sizeof(uint32), 1, stream);
-    fread(&CountColors, sizeof(uint32), 1, stream);
-    fread(&OffsetColors, sizeof(uint32), 1, stream);
-    fread(&CountTextures, sizeof(uint32), 1, stream);
-    fread(&OffsetTextures, sizeof(uint32), 1, stream);
-    fread(&CountTransparency, sizeof(uint32), 1, stream);
-    fread(&OffsetTransparency, sizeof(uint32), 1, stream);
-    fread(&CountUvAnimation, sizeof(uint32), 1, stream);
-    fread(&OffsetUvAnimation, sizeof(uint32), 1, stream);
-    fread(&CountTexReplace, sizeof(uint32), 1, stream);
-    fread(&OffsetTexReplace, sizeof(uint32), 1, stream);
-    fread(&CountRenderFlags, sizeof(uint32), 1, stream);
-    fread(&OffsetRenderFlags, sizeof(uint32), 1, stream);
-    fread(&CountBoneLookup, sizeof(uint32), 1, stream);
-    fread(&OffsetBoneLookup, sizeof(uint32), 1, stream);
-    fread(&CountTexLookup, sizeof(uint32), 1, stream);
-    fread(&OffsetTexLookup, sizeof(uint32), 1, stream);
-    fread(&CountTexUnits, sizeof(uint32), 1, stream);
-    fread(&OffsetTexUnits, sizeof(uint32), 1, stream);
-    fread(&CountTransLookup, sizeof(uint32), 1, stream);
-    fread(&OffsetTransLookup, sizeof(uint32), 1, stream);
-    fread(&CountUvAnimLookup, sizeof(uint32), 1, stream);
-    fread(&OffsetUvAnimLookup, sizeof(uint32), 1, stream);
+    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);
-    fread(&VertexRadius, sizeof(float), 1, stream);
+    count += fread(&VertexRadius, sizeof(float), 1, stream);
     BoundingBox[0] = Vector3::Read(stream);
     BoundingBox[1] = Vector3::Read(stream);
-    fread(&BoundingRadius, sizeof(float), 1, stream);
-    fread(&CountBoundingTriangles, sizeof(uint32), 1, stream);
-    fread(&OffsetBoundingTriangles, sizeof(uint32), 1, stream);
-    fread(&CountBoundingVertices, sizeof(uint32), 1, stream);
-    fread(&OffsetBoundingVertices, sizeof(uint32), 1, stream);
-    fread(&CountBoundingNormals, sizeof(uint32), 1, stream);
-    fread(&OffsetBoundingNormals, sizeof(uint32), 1, stream);
+    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);
+
 }
 
 WorldModelHeader WorldModelHeader::Read(FILE* stream)
 {
     WorldModelHeader ret;
-    fread(&ret.CountMaterials, sizeof(uint32), 1, stream);
-    fread(&ret.CountGroups, sizeof(uint32), 1, stream);
-    fread(&ret.CountPortals, sizeof(uint32), 1, stream);
-    fread(&ret.CountLights, sizeof(uint32), 1, stream);
-    fread(&ret.CountModels, sizeof(uint32), 1, stream);
-    fread(&ret.CountDoodads, sizeof(uint32), 1, stream);
-    fread(&ret.CountSets, sizeof(uint32), 1, stream);
-    fread(&ret.AmbientColorUnk, sizeof(uint32), 1, stream);
-    fread(&ret.WmoId, sizeof(uint32), 1, stream);
+    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);
-    fread(&ret.LiquidTypeRelated, sizeof(uint32), 1, 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;
-    fread(&ret.FileOffset, sizeof(uint32), 1, stream);
+    int count = 0;
+
+    count += fread(&ret.FileOffset, sizeof(uint32), 1, stream);
     ret.Position = Vector3::Read(stream);
-    fread(&ret.QuatW, sizeof(float), 1, stream);
-    fread(&ret.QuatX, sizeof(float), 1, stream);
-    fread(&ret.QuatY, sizeof(float), 1, stream);
-    fread(&ret.QuatZ, sizeof(float), 1, stream);
-    fread(&ret.Scale, sizeof(float), 1, stream);
-    fread(&ret.LightColor, sizeof(uint32), 1, stream);
+    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;
 }
 
@@ -379,24 +411,35 @@ DoodadSet DoodadSet::Read(FILE* stream)
 {
     DoodadSet ret;
     char name[21];
-    fread(&name, sizeof(char), 20, stream);
+    int count = 0;
+
+    count += fread(&name, sizeof(char), 20, stream);
     name[20] = '\0';
     ret.Name = name;
-    fread(&ret.FirstInstanceIndex, sizeof(uint32), 1, stream);
-    fread(&ret.CountInstances, sizeof(uint32), 1, stream);
-    fread(&ret.UnknownZero, sizeof(uint32), 1, stream);
+    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;
 }
 
 LiquidHeader LiquidHeader::Read(FILE* stream)
 {
     LiquidHeader ret;
-    fread(&ret.CountXVertices, sizeof(uint32), 1, stream);
-    fread(&ret.CountYVertices, sizeof(uint32), 1, stream);
-    fread(&ret.Width, sizeof(uint32), 1, stream);
-    fread(&ret.Height, sizeof(uint32), 1, stream);
+    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);
-    fread(&ret.MaterialId, sizeof(uint16), 1, 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;
 }
 
@@ -416,10 +459,12 @@ LiquidData LiquidData::Read(FILE* stream, LiquidHeader& header)
         for (uint32 x = 0; x < header.CountXVertices; x++)
         {
             uint32 discard;
-            fread(&discard, sizeof(uint32), 1, stream);
             float tmp;
-            fread(&tmp, sizeof(float), 1, stream);
-            ret.HeightMap[x][y] = tmp;
+            if (fread(&discard, sizeof(uint32), 1, stream) == 1 &&
+                fread(&tmp, sizeof(float), 1, stream) == 1)
+            {
+                ret.HeightMap[x][y] = tmp;
+            }
         }
     }
 
@@ -427,9 +472,9 @@ LiquidData LiquidData::Read(FILE* stream, LiquidHeader& header)
     {
         for (uint32 x = 0; x < header.Width; x++)
         {
-            uint8 tmp;
-            fread(&tmp, sizeof(uint8), 1, stream);
-            ret.RenderFlags[x][y] = tmp;
+            uint8 tmp = 0;
+            if (fread(&tmp, sizeof(uint8), 1, stream) == 1)
+                ret.RenderFlags[x][y] = tmp;
         }
     }
 
@@ -439,7 +484,8 @@ LiquidData LiquidData::Read(FILE* stream, LiquidHeader& header)
 H2ORenderMask H2ORenderMask::Read(FILE* stream)
 {
     H2ORenderMask ret;
-    fread(&ret.Mask, sizeof(uint8), 8, stream);
+    if (int 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;
 }
 
@@ -458,25 +504,35 @@ bool MCNKLiquidData::IsWater(int x, int y, float height)
 H2OHeader H2OHeader::Read(FILE* stream)
 {
     H2OHeader ret;
-    fread(&ret.OffsetInformation, sizeof(uint32), 1, stream);
-    fread(&ret.LayerCount, sizeof(uint32), 1, stream);
-    fread(&ret.OffsetRender, sizeof(uint32), 1, stream);
+    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);
+
+    if (count != 3)
+        printf("H2OHeader::Read: Failed to read some data expected 3, read %d\n", count);
+
     return ret;
 }
 
 H2OInformation H2OInformation::Read(FILE* stream)
 {
     H2OInformation ret;
-    fread(&ret.LiquidType, sizeof(uint16), 1, stream);
-    fread(&ret.Flags, sizeof(uint16), 1, stream);
-    fread(&ret.HeightLevel1, sizeof(float), 1, stream);
-    fread(&ret.HeightLevel2, sizeof(float), 1, stream);
-    fread(&ret.OffsetX, sizeof(uint8), 1, stream);
-    fread(&ret.OffsetY, sizeof(uint8), 1, stream);
-    fread(&ret.Width, sizeof(uint8), 1, stream);
-    fread(&ret.Height, sizeof(uint8), 1, stream);
-    fread(&ret.OffsetMask2, sizeof(uint32), 1, stream);
-    fread(&ret.OffsetHeightmap, sizeof(uint32), 1, stream);
+    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;
 }
 
@@ -492,17 +548,21 @@ char* Utils::GetPlainName(const char* FileName)
 WMOGroupHeader WMOGroupHeader::Read( FILE* stream )
 {
     WMOGroupHeader ret;
-    fread(&ret.OffsetGroupName, sizeof(uint32), 1, stream);
-    fread(&ret.OffsetDescriptiveName, sizeof(uint32), 1, stream);
-    fread(&ret.Flags, sizeof(uint32), 1, stream);
+    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);
-    fread(&ret.OffsetPortals, sizeof(uint32), 1, stream);
-    fread(&ret.CountPortals, sizeof(uint32), 1, stream);
-    fread(&ret.CountBatches, sizeof(uint16), 4, stream);
-    fread(&ret.Fogs, sizeof(uint8), 4, stream);
-    fread(&ret.LiquidTypeRelated, sizeof(uint32), 1, stream);
-    fread(&ret.WmoId, sizeof(uint32), 1, stream);
-    
+    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);
+
+    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 c5dd04fde06..e7380ed8142 100644
--- a/src/tools/mesh_extractor/Utils.h
+++ b/src/tools/mesh_extractor/Utils.h
@@ -40,7 +40,7 @@ template<typename T>
 struct Triangle
 {
     Triangle() {}
-    Triangle(Constants::TriangleType type, T v0, T v1, T v2) : Type(type), V0(v0), V1(v1), V2(v2) {}
+    Triangle(Constants::TriangleType type, T v0, T v1, T v2) : V0(v0), V1(v1), V2(v2), Type(type) {}
     T V0;
     T V1;
     T V2;
@@ -374,4 +374,4 @@ public:
     static std::string GetExtension( std::string path );
     static char* GetPlainName(const char* FileName);
 };
-#endif
\ No newline at end of file
+#endif
diff --git a/src/tools/mesh_extractor/WDT.cpp b/src/tools/mesh_extractor/WDT.cpp
index f0c3091c04e..70d140e79ed 100644
--- a/src/tools/mesh_extractor/WDT.cpp
+++ b/src/tools/mesh_extractor/WDT.cpp
@@ -4,7 +4,7 @@
 #include "Utils.h"
 #include "WorldModelHandler.h"
 
-WDT::WDT(std::string file) : IsValid(false), IsGlobalModel(false)
+WDT::WDT(std::string file) : IsGlobalModel(false), IsValid(false)
 {
     Data = new ChunkedData(file, 2);
     ReadTileTable();
@@ -37,8 +37,13 @@ void WDT::ReadTileTable()
             const uint32 hasTileFlag = 0x1;
             uint32 flags;
             uint32 discard;
-            fread(&flags, sizeof(uint32), 1, stream);
-            fread(&discard, sizeof(uint32), 1, stream);
+            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));
 
diff --git a/src/tools/mesh_extractor/WorldModelGroup.cpp b/src/tools/mesh_extractor/WorldModelGroup.cpp
index 35a5ba69782..5eeef824b1a 100644
--- a/src/tools/mesh_extractor/WorldModelGroup.cpp
+++ b/src/tools/mesh_extractor/WorldModelGroup.cpp
@@ -3,7 +3,7 @@
 #include "Chunk.h"
 #include "Utils.h"
 
-WorldModelGroup::WorldModelGroup( std::string path, int groupIndex ) : GroupIndex(groupIndex), IsBad(false), MOBA(NULL)
+WorldModelGroup::WorldModelGroup( std::string path, int groupIndex ) : GroupIndex(groupIndex), MOBA(NULL), IsBad(false)
 {
     Data = new ChunkedData(path);
     if (!Data->Stream)
@@ -85,9 +85,13 @@ void WorldModelGroup::ReadTriangles()
         uint16 v0;
         uint16 v1;
         uint16 v2;
-        fread(&v0, sizeof(uint16), 1, stream);
-        fread(&v1, sizeof(uint16), 1, stream);
-        fread(&v2, sizeof(uint16), 1, stream);
+        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));
     }
 }
@@ -105,10 +109,12 @@ void WorldModelGroup::ReadMaterials()
     for (uint32 i = 0; i < triangleCount; i++)
     {
         uint8 tmp;
-        fread(&tmp, sizeof(uint8), 1, stream);
+        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.
-        fread(&tmp, sizeof(uint8), 1, stream);
+        if (fread(&tmp, sizeof(uint8), 1, stream) != 1)
+            printf("WorldModelGroup::ReadMaterials: Error reading data, expected 1, read 0\n");
         TriangleMaterials.push_back(tmp);
     }
 }
@@ -131,5 +137,7 @@ void WorldModelGroup::ReadBatches()
 
     MOBALength = chunk->Length / 2;
     MOBA = new uint16[MOBALength];
-    fread(MOBA, sizeof(uint16), MOBALength, chunk->GetStream());
+    int count = fread(MOBA, sizeof(uint16), MOBALength, chunk->GetStream());
+    if (count != MOBALength)
+        printf("WorldModelGroup::ReadBatches: Error reading data, expected %d, read %d\n", MOBALength, count);
 }
diff --git a/src/tools/mesh_extractor/WorldModelHandler.cpp b/src/tools/mesh_extractor/WorldModelHandler.cpp
index 7b60b9b2151..6ce41807492 100644
--- a/src/tools/mesh_extractor/WorldModelHandler.cpp
+++ b/src/tools/mesh_extractor/WorldModelHandler.cpp
@@ -10,16 +10,20 @@
 WorldModelDefinition WorldModelDefinition::Read( FILE* file )
 {
     WorldModelDefinition ret;
-    fread(&ret.MwidIndex, sizeof(uint32), 1, file);
-    fread(&ret.UniqueId, sizeof(uint32), 1, file);
+    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);
-    fread(&ret.Flags, sizeof(uint16), 1, file);
-    fread(&ret.DoodadSet, sizeof(uint16), 1, file);
+    count += fread(&ret.Flags, sizeof(uint16), 1, file);
+    count += fread(&ret.DoodadSet, sizeof(uint16), 1, file);
     uint32 discard;
-    fread(&discard, sizeof(uint32), 1, file);
+    count += fread(&discard, sizeof(uint32), 1, file);
+
+    if (count != 5)
+         printf("WorldModelDefinition::Read: Error reading data, expected 5, read %d\n", count);
     return ret;
 }
 
@@ -44,7 +48,8 @@ void WorldModelHandler::ProcessInternal( ChunkedData* subChunks )
     for (uint32 i = 0; i < refCount; i++)
     {
         int32 index;
-        fread(&index, sizeof(int32), 1, stream);
+        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;
@@ -184,7 +189,8 @@ void WorldModelHandler::ReadModelPaths()
         FILE* stream = mwid->GetStream();
         fseek(stream, i * 4, SEEK_CUR);
         uint32 offset;
-        fread(&offset, sizeof(uint32), 1, stream);
+        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/mmaps_generator/CMakeLists.txt b/src/tools/mmaps_generator/CMakeLists.txt
index 46bf9d00d43..229a2cd808f 100644
--- a/src/tools/mmaps_generator/CMakeLists.txt
+++ b/src/tools/mmaps_generator/CMakeLists.txt
@@ -22,13 +22,13 @@ include_directories(
   ${CMAKE_SOURCE_DIR}/dep/libmpq
   ${CMAKE_SOURCE_DIR}/dep/zlib
   ${CMAKE_SOURCE_DIR}/dep/bzip2
-  ${CMAKE_SOURCE_DIR}/dep/acelite
   ${CMAKE_SOURCE_DIR}/dep/g3dlite/include
   ${CMAKE_SOURCE_DIR}/dep/recastnavigation/Recast
   ${CMAKE_SOURCE_DIR}/dep/recastnavigation/Detour
   ${CMAKE_SOURCE_DIR}/src/server/shared
   ${CMAKE_SOURCE_DIR}/src/server/shared/Database
   ${CMAKE_SOURCE_DIR}/src/server/shared/Database/Implementation
+  ${CMAKE_SOURCE_DIR}/src/server/shared/Debugging
   ${CMAKE_SOURCE_DIR}/src/server/shared/Threading
   ${CMAKE_SOURCE_DIR}/src/server/shared/Logging
   ${CMAKE_SOURCE_DIR}/src/server/shared/Utilities
diff --git a/src/tools/mmaps_generator/IntermediateValues.h b/src/tools/mmaps_generator/IntermediateValues.h
index a267a0f6412..98042e1b917 100644
--- a/src/tools/mmaps_generator/IntermediateValues.h
+++ b/src/tools/mmaps_generator/IntermediateValues.h
@@ -35,7 +35,7 @@ namespace MMAP
         rcPolyMesh* polyMesh;
         rcPolyMeshDetail* polyMeshDetail;
 
-        IntermediateValues() :  compactHeightfield(NULL), heightfield(NULL),
+        IntermediateValues() :  heightfield(NULL), compactHeightfield(NULL),
                                 contours(NULL), polyMesh(NULL), polyMeshDetail(NULL) {}
         ~IntermediateValues();
 
diff --git a/src/tools/mmaps_generator/MapBuilder.cpp b/src/tools/mmaps_generator/MapBuilder.cpp
index 754bced903c..689ccdc906d 100644
--- a/src/tools/mmaps_generator/MapBuilder.cpp
+++ b/src/tools/mmaps_generator/MapBuilder.cpp
@@ -29,7 +29,7 @@
 
 // These make the linker happy.
 LoginDatabaseWorkerPool LoginDatabase;
-uint32 GetLiquidFlags(uint32 liquidType)
+uint32 GetLiquidFlags(uint32 /*liquidType*/)
 {
     return 0;
 }
@@ -37,7 +37,7 @@ uint32 GetLiquidFlags(uint32 liquidType)
 #include "DisableMgr.h"
 namespace DisableMgr
 {
-    bool IsDisabledFor(DisableType type, uint32 entry, Unit const* unit, uint8 flags)
+    bool IsDisabledFor(DisableType /*type*/, uint32 /*entry*/, Unit const* /*unit*/, uint8 /*flags*/)
     {
         return 0;
     }
@@ -50,15 +50,15 @@ namespace MMAP
     MapBuilder::MapBuilder(float maxWalkableAngle, bool skipLiquid,
         bool skipContinents, bool skipJunkMaps, bool skipBattlegrounds,
         bool debugOutput, bool bigBaseUnit, const char* offMeshFilePath) :
-    m_terrainBuilder(NULL),
+        m_terrainBuilder     (NULL),
         m_debugOutput        (debugOutput),
+        m_offMeshFilePath    (offMeshFilePath),
         m_skipContinents     (skipContinents),
         m_skipJunkMaps       (skipJunkMaps),
         m_skipBattlegrounds  (skipBattlegrounds),
         m_maxWalkableAngle   (maxWalkableAngle),
         m_bigBaseUnit        (bigBaseUnit),
-        m_rcContext          (NULL),
-        m_offMeshFilePath    (offMeshFilePath)
+        m_rcContext          (NULL)
     {
         m_terrainBuilder = new TerrainBuilder(skipLiquid);
 
@@ -250,9 +250,12 @@ namespace MMAP
 
         printf("Building mesh from file\n");
         int tileX, tileY, mapId;
-        fread(&mapId, sizeof(int), 1, file);
-        fread(&tileX, sizeof(int), 1, file);
-        fread(&tileY, sizeof(int), 1, file);
+        if (fread(&mapId, sizeof(int), 1, file) != 1)
+            return;
+        if (fread(&tileX, sizeof(int), 1, file) != 1)
+            return;
+        if (fread(&tileY, sizeof(int), 1, file) != 1)
+            return;
 
         dtNavMesh* navMesh = NULL;
         buildNavMesh(mapId, navMesh);
@@ -263,23 +266,26 @@ namespace MMAP
             return;
         }
 
-
-        int verticesCount, indicesCount;
-        fread(&verticesCount, sizeof(int), 1, file);
-        fread(&indicesCount, sizeof(int), 1, file);
+        uint verticesCount, indicesCount;
+        if (fread(&verticesCount, sizeof(uint), 1, file) != 1)
+            return;
+        if (fread(&indicesCount, sizeof(uint), 1, file) != 1)
+            return;
 
         float* verts = new float[verticesCount];
         int* inds = new int[indicesCount];
 
-        fread(verts, sizeof(float), verticesCount, file);
-        fread(inds, sizeof(int), indicesCount, file);
+        if (fread(verts, sizeof(float), verticesCount, file) != verticesCount)
+            return;
+        if (fread(inds, sizeof(int), indicesCount, file) != indicesCount)
+            return;
 
         MeshData data;
 
-        for (int i = 0; i < verticesCount; ++i)
+        for (uint i = 0; i < verticesCount; ++i)
             data.solidVerts.append(verts[i]);
 
-        for (int i = 0; i < indicesCount; ++i)
+        for (uint i = 0; i < indicesCount; ++i)
             data.solidTris.append(inds[i]);
 
         TerrainBuilder::cleanVertices(data.solidVerts, data.solidTris);
@@ -310,7 +316,7 @@ namespace MMAP
     /**************************************************************************/
     void MapBuilder::buildMap(uint32 mapID)
     {
-        printf("[Thread %i] Building map %03u:\n", ACE_Thread::self(), mapID);
+        printf("[Thread %u] Building map %03u:\n", uint32(ACE_Thread::self()), mapID);
 
         set<uint32>* tiles = getTileList(mapID);
 
@@ -409,7 +415,6 @@ namespace MMAP
         //if (tileBits < 1) tileBits = 1;                                     // need at least one bit!
         //int polyBits = sizeof(dtPolyRef)*8 - SALT_MIN_BITS - tileBits;
 
-        int tileBits = STATIC_TILE_BITS;
         int polyBits = STATIC_POLY_BITS;
 
         int maxTiles = tiles->size();
@@ -955,8 +960,10 @@ namespace MMAP
             return false;
 
         MmapTileHeader header;
-        fread(&header, sizeof(MmapTileHeader), 1, file);
+        int count = fread(&header, sizeof(MmapTileHeader), 1, file);
         fclose(file);
+        if (count != 1)
+            return false;
 
         if (header.mmapMagic != MMAP_MAGIC || header.dtVersion != DT_NAVMESH_VERSION)
             return false;
diff --git a/src/tools/mmaps_generator/PathCommon.h b/src/tools/mmaps_generator/PathCommon.h
index fd02ec02d50..966c12ec19e 100644
--- a/src/tools/mmaps_generator/PathCommon.h
+++ b/src/tools/mmaps_generator/PathCommon.h
@@ -75,7 +75,7 @@ namespace MMAP
         LISTFILE_OK = 1
     };
 
-    inline ListFilesResult getDirContents(vector<string> &fileList, string dirpath = ".", string filter = "*", bool includeSubDirs = false)
+    inline ListFilesResult getDirContents(vector<string> &fileList, string dirpath = ".", string filter = "*")
     {
     #ifdef WIN32
         HANDLE hFind;
diff --git a/src/tools/mmaps_generator/TerrainBuilder.cpp b/src/tools/mmaps_generator/TerrainBuilder.cpp
index 0159219c110..22946df478a 100644
--- a/src/tools/mmaps_generator/TerrainBuilder.cpp
+++ b/src/tools/mmaps_generator/TerrainBuilder.cpp
@@ -27,6 +27,9 @@
 
 namespace MMAP
 {
+
+    char const* MAP_VERSION_MAGIC = "v1.3";
+
     TerrainBuilder::TerrainBuilder(bool skipLiquid) : m_skipLiquid (skipLiquid){ }
     TerrainBuilder::~TerrainBuilder() { }
 
@@ -86,9 +89,8 @@ namespace MMAP
             return false;
 
         map_fileheader fheader;
-        fread(&fheader, sizeof(map_fileheader), 1, mapFile);
-
-        if (fheader.versionMagic != *((uint32 const*)(MAP_VERSION_MAGIC)))
+        if (fread(&fheader, sizeof(map_fileheader), 1, mapFile) != 1 ||
+            fheader.versionMagic != *((uint32 const*)(MAP_VERSION_MAGIC)))
         {
             fclose(mapFile);
             printf("%s is the wrong version, please extract new .map files\n", mapFileName);
@@ -97,10 +99,14 @@ namespace MMAP
 
         map_heightHeader hheader;
         fseek(mapFile, fheader.heightMapOffset, SEEK_SET);
-        fread(&hheader, sizeof(map_heightHeader), 1, mapFile);
 
-        bool haveTerrain = !(hheader.flags & MAP_HEIGHT_NO_HEIGHT);
-        bool haveLiquid = fheader.liquidMapOffset && !m_skipLiquid;
+        bool haveTerrain = false;
+        bool haveLiquid = false;
+        if (fread(&hheader, sizeof(map_heightHeader), 1, mapFile) == 1)
+        {
+            haveTerrain = !(hheader.flags & MAP_HEIGHT_NO_HEIGHT);
+            haveLiquid = fheader.liquidMapOffset && !m_skipLiquid;
+        }
 
         // no data in this map file
         if (!haveTerrain && !haveLiquid)
@@ -120,42 +126,53 @@ namespace MMAP
         // terrain data
         if (haveTerrain)
         {
-            int i;
             float heightMultiplier;
             float V9[V9_SIZE_SQ], V8[V8_SIZE_SQ];
+            int expected = V9_SIZE_SQ + V8_SIZE_SQ;
 
             if (hheader.flags & MAP_HEIGHT_AS_INT8)
             {
                 uint8 v9[V9_SIZE_SQ];
                 uint8 v8[V8_SIZE_SQ];
-                fread(v9, sizeof(uint8), V9_SIZE_SQ, mapFile);
-                fread(v8, sizeof(uint8), V8_SIZE_SQ, mapFile);
+                int count = 0;
+                count += fread(v9, sizeof(uint8), V9_SIZE_SQ, mapFile);
+                count += fread(v8, sizeof(uint8), V8_SIZE_SQ, mapFile);
+                if (count != expected)
+                    printf("TerrainBuilder::loadMap: Failed to read some data expected %d, read %d\n", expected, count);
+                    
                 heightMultiplier = (hheader.gridMaxHeight - hheader.gridHeight) / 255;
 
-                for (i = 0; i < V9_SIZE_SQ; ++i)
+                for (int i = 0; i < V9_SIZE_SQ; ++i)
                     V9[i] = (float)v9[i]*heightMultiplier + hheader.gridHeight;
 
-                for (i = 0; i < V8_SIZE_SQ; ++i)
+                for (int i = 0; i < V8_SIZE_SQ; ++i)
                     V8[i] = (float)v8[i]*heightMultiplier + hheader.gridHeight;
             }
             else if (hheader.flags & MAP_HEIGHT_AS_INT16)
             {
                 uint16 v9[V9_SIZE_SQ];
                 uint16 v8[V8_SIZE_SQ];
-                fread(v9, sizeof(uint16), V9_SIZE_SQ, mapFile);
-                fread(v8, sizeof(uint16), V8_SIZE_SQ, mapFile);
+                int count = 0;
+                count += fread(v9, sizeof(uint16), V9_SIZE_SQ, mapFile);
+                count += fread(v8, sizeof(uint16), V8_SIZE_SQ, mapFile);
+                if (count != expected)
+                    printf("TerrainBuilder::loadMap: Failed to read some data expected %d, read %d\n", expected, count);
+
                 heightMultiplier = (hheader.gridMaxHeight - hheader.gridHeight) / 65535;
 
-                for (i = 0; i < V9_SIZE_SQ; ++i)
+                for (int i = 0; i < V9_SIZE_SQ; ++i)
                     V9[i] = (float)v9[i]*heightMultiplier + hheader.gridHeight;
 
-                for (i = 0; i < V8_SIZE_SQ; ++i)
+                for (int i = 0; i < V8_SIZE_SQ; ++i)
                     V8[i] = (float)v8[i]*heightMultiplier + hheader.gridHeight;
             }
             else
             {
-                fread (V9, sizeof(float), V9_SIZE_SQ, mapFile);
-                fread(V8, sizeof(float), V8_SIZE_SQ, mapFile);
+                int count = 0;
+                count += fread(V9, sizeof(float), V9_SIZE_SQ, mapFile);
+                count += fread(V8, sizeof(float), V8_SIZE_SQ, mapFile);
+                if (count != expected)
+                    printf("TerrainBuilder::loadMap: Failed to read some data expected %d, read %d\n", expected, count);
             }
 
             // hole data
@@ -163,7 +180,8 @@ namespace MMAP
             {
                 memset(holes, 0, fheader.holesSize);
                 fseek(mapFile, fheader.holesOffset, SEEK_SET);
-                fread(holes, fheader.holesSize, 1, mapFile);
+                if (fread(holes, fheader.holesSize, 1, mapFile) != 1)
+                    printf("TerrainBuilder::loadMap: Failed to read some data expected 1, read 0\n");
             }
 
             int count = meshData.solidVerts.size() / 3;
@@ -172,7 +190,7 @@ namespace MMAP
 
             float coord[3];
 
-            for (i = 0; i < V9_SIZE_SQ; ++i)
+            for (int i = 0; i < V9_SIZE_SQ; ++i)
             {
                 getHeightCoord(i, GRID_V9, xoffset, yoffset, coord, V9);
                 meshData.solidVerts.append(coord[0]);
@@ -180,7 +198,7 @@ namespace MMAP
                 meshData.solidVerts.append(coord[1]);
             }
 
-            for (i = 0; i < V8_SIZE_SQ; ++i)
+            for (int i = 0; i < V8_SIZE_SQ; ++i)
             {
                 getHeightCoord(i, GRID_V8, xoffset, yoffset, coord, V8);
                 meshData.solidVerts.append(coord[0]);
@@ -188,10 +206,10 @@ namespace MMAP
                 meshData.solidVerts.append(coord[1]);
             }
 
-            int j, indices[3], loopStart, loopEnd, loopInc;
+            int indices[3], loopStart = 0, loopEnd = 0, loopInc = 0;
             getLoopVars(portion, loopStart, loopEnd, loopInc);
-            for (i = loopStart; i < loopEnd; i+=loopInc)
-                for (j = TOP; j <= BOTTOM; j+=1)
+            for (int i = loopStart; i < loopEnd; i+=loopInc)
+                for (int j = TOP; j <= BOTTOM; j+=1)
                 {
                     getHeightTriangle(i, Spot(j), indices);
                     ttriangles.append(indices[2] + count);
@@ -205,19 +223,25 @@ namespace MMAP
         {
             map_liquidHeader lheader;
             fseek(mapFile, fheader.liquidMapOffset, SEEK_SET);
-            fread(&lheader, sizeof(map_liquidHeader), 1, mapFile);
+            if (fread(&lheader, sizeof(map_liquidHeader), 1, mapFile) != 1)
+                printf("TerrainBuilder::loadMap: Failed to read some data expected 1, read 0\n");
+
 
             float* liquid_map = NULL;
 
             if (!(lheader.flags & MAP_LIQUID_NO_TYPE))
-                fread(liquid_type, sizeof(liquid_type), 1, mapFile);
+                if (fread(liquid_type, sizeof(liquid_type), 1, mapFile) != 1)
+                    printf("TerrainBuilder::loadMap: Failed to read some data expected 1, read 0\n");
 
             if (!(lheader.flags & MAP_LIQUID_NO_HEIGHT))
             {
-                liquid_map = new float [lheader.width*lheader.height];
-                fread(liquid_map, sizeof(float), lheader.width*lheader.height, mapFile);
+                uint toRead = lheader.width*lheader.height;
+                liquid_map = new float [toRead];
+                if (fread(liquid_map, sizeof(float), toRead, mapFile) != toRead)
+                    printf("TerrainBuilder::loadMap: Failed to read some data expected 1, read 0\n");
             }
 
+            // FIXME: "the address of ‘liquid_type’ will always evaluate as ‘true’"
             if (liquid_type && liquid_map)
             {
                 int count = meshData.liquidVerts.size() / 3;
@@ -263,9 +287,8 @@ namespace MMAP
 
                 delete [] liquid_map;
 
-                int indices[3], loopStart, loopEnd, loopInc, triInc;
+                int indices[3], loopStart = 0, loopEnd = 0, loopInc = 0, triInc = BOTTOM-TOP;
                 getLoopVars(portion, loopStart, loopEnd, loopInc);
-                triInc = BOTTOM-TOP;
 
                 // generate triangles
                 for (int i = loopStart; i < loopEnd; i+=loopInc)
@@ -283,7 +306,7 @@ namespace MMAP
 
         // now that we have gathered the data, we can figure out which parts to keep:
         // liquid above ground, ground above liquid
-        int loopStart, loopEnd, loopInc, tTriCount = 4;
+        int loopStart = 0, loopEnd = 0, loopInc = 0, tTriCount = 4;
         bool useTerrain, useLiquid;
 
         float* lverts = meshData.liquidVerts.getCArray();
@@ -313,6 +336,7 @@ namespace MMAP
                 useTerrain = true;
                 useLiquid = true;
                 uint8 liquidType = MAP_LIQUID_TYPE_NO_WATER;
+                // FIXME: "warning: the address of ‘liquid_type’ will always evaluate as ‘true’"
 
                 // if there is no liquid, don't use liquid
                 if (!liquid_type || !meshData.liquidVerts.size() || !ltriangles.size())
@@ -825,13 +849,13 @@ namespace MMAP
         while(fgets(buf, 512, fp))
         {
             float p0[3], p1[3];
-            int mid, tx, ty;
+            uint32 mid, tx, ty;
             float size;
-            if (10 != sscanf(buf, "%d %d,%d (%f %f %f) (%f %f %f) %f", &mid, &tx, &ty,
-                &p0[0], &p0[1], &p0[2], &p1[0], &p1[1], &p1[2], &size))
+            if (sscanf(buf, "%d %d,%d (%f %f %f) (%f %f %f) %f", &mid, &tx, &ty,
+                &p0[0], &p0[1], &p0[2], &p1[0], &p1[1], &p1[2], &size) != 10)
                 continue;
 
-            if (mapID == mid, tileX == tx, tileY == ty)
+            if (mapID == mid && tileX == tx && tileY == ty)
             {
                 meshData.offMeshConnections.append(p0[1]);
                 meshData.offMeshConnections.append(p0[2]);
diff --git a/src/tools/mmaps_generator/TerrainBuilder.h b/src/tools/mmaps_generator/TerrainBuilder.h
index 6d478753279..7a24146946b 100644
--- a/src/tools/mmaps_generator/TerrainBuilder.h
+++ b/src/tools/mmaps_generator/TerrainBuilder.h
@@ -62,7 +62,6 @@ namespace MMAP
     // see following files:
     // contrib/extractor/system.cpp
     // src/game/Map.cpp
-    static char const* MAP_VERSION_MAGIC = "v1.3";
 
     struct MeshData
     {
diff --git a/src/tools/mmaps_generator/VMapExtensions.cpp b/src/tools/mmaps_generator/VMapExtensions.cpp
index 4f203e11c21..2b525fbf353 100644
--- a/src/tools/mmaps_generator/VMapExtensions.cpp
+++ b/src/tools/mmaps_generator/VMapExtensions.cpp
@@ -57,7 +57,7 @@ namespace VMAP
     }
 
     // declared in src/shared/vmap/ModelInstance.h
-    WorldModel* const ModelInstance::getWorldModel()
+    WorldModel* ModelInstance::getWorldModel()
     {
         return iModel;
     }
diff --git a/src/tools/vmap4_extractor/adtfile.cpp b/src/tools/vmap4_extractor/adtfile.cpp
index a605118eead..56e62d474d1 100644
--- a/src/tools/vmap4_extractor/adtfile.cpp
+++ b/src/tools/vmap4_extractor/adtfile.cpp
@@ -69,8 +69,7 @@ void fixname2(char* name, size_t len)
 
 char* GetExtension(char* FileName)
 {
-    char* szTemp;
-    if (szTemp = strrchr(FileName, '.'))
+    if (char* szTemp = strrchr(FileName, '.'))
         return szTemp;
     return NULL;
 }
diff --git a/src/tools/vmap4_extractor/model.cpp b/src/tools/vmap4_extractor/model.cpp
index c642f73ccae..b950db023fe 100644
--- a/src/tools/vmap4_extractor/model.cpp
+++ b/src/tools/vmap4_extractor/model.cpp
@@ -152,10 +152,10 @@ ModelInstance::ModelInstance(MPQFile& f, char const* ModelInstName, uint32 mapID
 
     fseek(input, 8, SEEK_SET); // get the correct no of vertices
     int nVertices;
-    fread(&nVertices, sizeof (int), 1, input);
+    int count = fread(&nVertices, sizeof (int), 1, input);
     fclose(input);
 
-    if(nVertices == 0)
+    if (count != 1 || nVertices == 0)
         return;
 
     uint16 adtId = 0;// not used for models
diff --git a/src/tools/vmap4_extractor/vmapexport.cpp b/src/tools/vmap4_extractor/vmapexport.cpp
index 186f9c8606e..89e4b850dac 100644
--- a/src/tools/vmap4_extractor/vmapexport.cpp
+++ b/src/tools/vmap4_extractor/vmapexport.cpp
@@ -461,8 +461,7 @@ int main(int argc, char ** argv)
             printf("Your output directory seems to be polluted, please use an empty directory!\n");
             printf("<press return to exit>");
             char garbage[2];
-            scanf("%c", garbage);
-            return 1;
+            return scanf("%c", garbage);
         }
     }
 
diff --git a/src/tools/vmap4_extractor/wmo.cpp b/src/tools/vmap4_extractor/wmo.cpp
index 0bc749b9bd5..7c9f23c5a95 100644
--- a/src/tools/vmap4_extractor/wmo.cpp
+++ b/src/tools/vmap4_extractor/wmo.cpp
@@ -521,10 +521,10 @@ WMOInstance::WMOInstance(MPQFile& f, char const* WmoInstName, uint32 mapID, uint
 
     fseek(input, 8, SEEK_SET); // get the correct no of vertices
     int nVertices;
-    fread(&nVertices, sizeof (int), 1, input);
+    int count = fread(&nVertices, sizeof (int), 1, input);
     fclose(input);
 
-    if(nVertices == 0)
+    if (count != 1 || nVertices == 0)
         return;
 
     float x,z;