Tools/Extractors: Use FileDataID whenever possible

11 files changed, 179 insertions, 55 deletions

diff --git a/src/tools/vmap4_extractor/adtfile.cpp b/src/tools/vmap4_extractor/adtfile.cpp
index abd8ba5413f..43dddb8a414 100644
--- a/src/tools/vmap4_extractor/adtfile.cpp
+++ b/src/tools/vmap4_extractor/adtfile.cpp
@@ -77,9 +77,14 @@ char* GetExtension(char* FileName)
 
 extern CASC::StorageHandle CascStorage;
 
-ADTFile::ADTFile(char* filename, bool cache) : _file(CascStorage, filename, false)
+ADTFile::ADTFile(std::string const& filename, bool cache) : _file(CascStorage, filename.c_str(), false)
+{
+    cacheable = cache;
+    dirfileCache = nullptr;
+}
+
+ADTFile::ADTFile(uint32 fileDataId, std::string const& description, bool cache) : _file(CascStorage, fileDataId, description, false)
 {
-    Adtfilename.append(filename);
     cacheable = cache;
     dirfileCache = nullptr;
 }
@@ -114,13 +119,7 @@ bool ADTFile::init(uint32 map_num, uint32 originalMapId)
 
         size_t nextpos = _file.getPos() + size;
 
-        if (!strcmp(fourcc,"MCIN"))
-        {
-        }
-        else if (!strcmp(fourcc,"MTEX"))
-        {
-        }
-        else if (!strcmp(fourcc,"MMDX"))
+        if (!strcmp(fourcc,"MMDX"))
         {
             if (size)
             {
diff --git a/src/tools/vmap4_extractor/adtfile.h b/src/tools/vmap4_extractor/adtfile.h
index 0dddb5b0f4b..053800490f4 100644
--- a/src/tools/vmap4_extractor/adtfile.h
+++ b/src/tools/vmap4_extractor/adtfile.h
@@ -61,11 +61,11 @@ class ADTFile
 {
 private:
     CASCFile _file;
-    std::string Adtfilename;
     bool cacheable;
     std::vector<ADTOutputCache>* dirfileCache;
 public:
-    ADTFile(char* filename, bool cache);
+    ADTFile(std::string const& filename, bool cache);
+    ADTFile(uint32 fileDataId, std::string const& description, bool cache);
     ~ADTFile();
     std::vector<std::string> WmoInstanceNames;
     std::vector<std::string> ModelInstanceNames;
diff --git a/src/tools/vmap4_extractor/cascfile.cpp b/src/tools/vmap4_extractor/cascfile.cpp
index f05db213c19..1702ddb5230 100644
--- a/src/tools/vmap4_extractor/cascfile.cpp
+++ b/src/tools/vmap4_extractor/cascfile.cpp
@@ -21,7 +21,7 @@
 
 CASCFile::CASCFile(CASC::StorageHandle const& casc, const char* filename, bool warnNoExist /*= true*/) :
     eof(false),
-    buffer(0),
+    buffer(nullptr),
     pointer(0),
     size(0)
 {
@@ -34,18 +34,41 @@ CASCFile::CASCFile(CASC::StorageHandle const& casc, const char* filename, bool w
         return;
     }
 
+    init(file, filename);
+}
+
+CASCFile::CASCFile(CASC::StorageHandle const& casc, uint32 fileDataId, std::string const& description, bool warnNoExist /*= true*/) :
+    eof(false),
+    buffer(nullptr),
+    pointer(0),
+    size(0)
+{
+    CASC::FileHandle file = CASC::OpenFile(casc, fileDataId, CASC_LOCALE_ALL, false);
+    if (!file)
+    {
+        if (warnNoExist || GetLastError() != ERROR_FILE_NOT_FOUND)
+            fprintf(stderr, "Can't open %s: %s\n", description.c_str(), CASC::HumanReadableCASCError(GetLastError()));
+        eof = true;
+        return;
+    }
+
+    init(file, description.c_str());
+}
+
+void CASCFile::init(CASC::FileHandle const& file, const char* description)
+{
     DWORD fileSizeHigh = 0;
     DWORD fileSize = CASC::GetFileSize(file, &fileSizeHigh);
     if (fileSize == CASC_INVALID_SIZE)
     {
-        fprintf(stderr, "Can't open %s, failed to get size: %s!\n", filename, CASC::HumanReadableCASCError(GetLastError()));
+        fprintf(stderr, "Can't open %s, failed to get size: %s!\n", description, CASC::HumanReadableCASCError(GetLastError()));
         eof = true;
         return;
     }
 
     if (fileSizeHigh)
     {
-        fprintf(stderr, "Can't open %s, file larger than 2GB", filename);
+        fprintf(stderr, "Can't open %s, file larger than 2GB", description);
         eof = true;
         return;
     }
@@ -56,7 +79,7 @@ CASCFile::CASCFile(CASC::StorageHandle const& casc, const char* filename, bool w
     buffer = new char[size];
     if (!CASC::ReadFile(file, buffer, size, &read) || size != read)
     {
-        fprintf(stderr, "Can't read %s, size=%u read=%u: %s\n", filename, uint32(size), uint32(read), CASC::HumanReadableCASCError(GetLastError()));
+        fprintf(stderr, "Can't read %s, size=%u read=%u: %s\n", description, uint32(size), uint32(read), CASC::HumanReadableCASCError(GetLastError()));
         eof = true;
         return;
     }
diff --git a/src/tools/vmap4_extractor/cascfile.h b/src/tools/vmap4_extractor/cascfile.h
index de1baa3a5d4..5ebb0bb5bfb 100644
--- a/src/tools/vmap4_extractor/cascfile.h
+++ b/src/tools/vmap4_extractor/cascfile.h
@@ -25,6 +25,7 @@
 
 #include "Define.h"
 #include "CascHandles.h"
+#include <string>
 #include <utility>
 
 class CASCFile
@@ -39,7 +40,9 @@ class CASCFile
 
 public:
     CASCFile(CASC::StorageHandle const& casc, const char* filename, bool warnNoExist = true);    // filenames are not case sensitive
+    CASCFile(CASC::StorageHandle const& casc, uint32 fileDataId, std::string const& description, bool warnNoExist = true);
     ~CASCFile() { close(); }
+    void init(CASC::FileHandle const& file, const char* description);
     size_t read(void* dest, size_t bytes);
     size_t getSize() { return size; }
     size_t getPos() { return pointer; }
diff --git a/src/tools/vmap4_extractor/gameobject_extract.cpp b/src/tools/vmap4_extractor/gameobject_extract.cpp
index bf9cf73e678..85dd992e6f1 100644
--- a/src/tools/vmap4_extractor/gameobject_extract.cpp
+++ b/src/tools/vmap4_extractor/gameobject_extract.cpp
@@ -43,7 +43,8 @@ bool ExtractSingleModel(std::string& fname)
     std::string originalName = fname;
 
     char* name = GetPlainName((char*)fname.c_str());
-    FixNameCase(name, strlen(name));
+    if (fname.substr(0, 4) != "FILE")
+        FixNameCase(name, strlen(name));
     FixNameSpaces(name, strlen(name));
 
     std::string output(szWorkDirWmo);
diff --git a/src/tools/vmap4_extractor/model.cpp b/src/tools/vmap4_extractor/model.cpp
index 2b01d4e1225..aeaebe28833 100644
--- a/src/tools/vmap4_extractor/model.cpp
+++ b/src/tools/vmap4_extractor/model.cpp
@@ -243,7 +243,13 @@ void Doodad::ExtractSet(WMODoodadData const& doodadData, ADT::MODF const& wmo, b
         WMO::MODD const& doodad = doodadData.Spawns[doodadIndex];
 
         char ModelInstName[1024];
-        sprintf(ModelInstName, "%s", GetPlainName(&doodadData.Paths[doodad.NameIndex]));
+        if (doodadData.Paths)
+            sprintf(ModelInstName, "%s", GetPlainName(&doodadData.Paths[doodad.NameIndex]));
+        else if (doodadData.FileDataIds)
+            sprintf(ModelInstName, "FILE%08X.xxx", doodadData.FileDataIds[doodad.NameIndex]);
+        else
+            ASSERT(false);
+
         uint32 nlen = strlen(ModelInstName);
         FixNameCase(ModelInstName, nlen);
         FixNameSpaces(ModelInstName, nlen);
diff --git a/src/tools/vmap4_extractor/vmapexport.cpp b/src/tools/vmap4_extractor/vmapexport.cpp
index babdb7a99c0..25b42e8ed07 100644
--- a/src/tools/vmap4_extractor/vmapexport.cpp
+++ b/src/tools/vmap4_extractor/vmapexport.cpp
@@ -55,13 +55,15 @@
 
 CASC::StorageHandle CascStorage;
 
-struct map_info
+struct MapEntry
 {
-    char name[64];
-    int32 parent_id;
+    int32 WdtFileDataId = 0;
+    int16 ParentMapID = 0;
+    std::string Name;
+    std::string Directory;
 };
 
-std::map<uint32, map_info> map_ids;
+std::map<uint32, MapEntry> map_ids;
 std::unordered_set<uint32> maps_that_are_parents;
 boost::filesystem::path input_path;
 bool preciseVectorData = false;
@@ -166,7 +168,8 @@ bool ExtractSingleWmo(std::string& fname)
 
     char szLocalFile[1024];
     char* plain_name = GetPlainName(&fname[0]);
-    FixNameCase(plain_name, strlen(plain_name));
+    if (fname.substr(0, 4) != "FILE")
+        FixNameCase(plain_name, strlen(plain_name));
     FixNameSpaces(plain_name, strlen(plain_name));
     sprintf(szLocalFile, "%s/%s", szWorkDirWmo, plain_name);
 
@@ -192,7 +195,6 @@ bool ExtractSingleWmo(std::string& fname)
         return true;
 
     bool file_ok = true;
-    printf("Extracting %s\n", originalName.c_str());
     WMORoot froot(originalName);
     if (!froot.open())
     {
@@ -253,10 +255,13 @@ void ParsMapFiles()
         auto itr = wdts.find(mapId);
         if (itr == wdts.end())
         {
-            char fn[512];
-            char* name = map_ids[mapId].name;
-            sprintf(fn, "World\\Maps\\%s\\%s.wdt", name, name);
-            itr = wdts.emplace(std::piecewise_construct, std::forward_as_tuple(mapId), std::forward_as_tuple(fn, name, maps_that_are_parents.count(mapId) > 0)).first;
+            uint32 fileDataId = map_ids[mapId].WdtFileDataId;
+            if (!fileDataId)
+                return nullptr;
+
+            std::string description = Trinity::StringFormat("WDT for map %u - %s (FileDataID %u)", mapId, map_ids[mapId].Name.c_str(), fileDataId);
+            std::string directory = map_ids[mapId].Directory;
+            itr = wdts.emplace(std::piecewise_construct, std::forward_as_tuple(mapId), std::forward_as_tuple(fileDataId, description, std::move(directory), maps_that_are_parents.count(mapId) > 0)).first;
             if (!itr->second.init(mapId))
             {
                 wdts.erase(itr);
@@ -271,7 +276,7 @@ void ParsMapFiles()
     {
         if (WDTFile* WDT = getWDT(itr->first))
         {
-            WDTFile* parentWDT = itr->second.parent_id >= 0 ? getWDT(itr->second.parent_id) : nullptr;
+            WDTFile* parentWDT = itr->second.ParentMapID >= 0 ? getWDT(itr->second.ParentMapID) : nullptr;
             printf("Processing Map %u\n[", itr->first);
             for (int32 x = 0; x < 64; ++x)
             {
@@ -287,7 +292,7 @@ void ParsMapFiles()
                     {
                         if (ADTFile* ADT = parentWDT->GetMap(x, y))
                         {
-                            ADT->init(itr->first, itr->second.parent_id);
+                            ADT->init(itr->first, itr->second.ParentMapID);
                             parentWDT->FreeADT(ADT);
                         }
                     }
@@ -479,21 +484,16 @@ int main(int argc, char ** argv)
         for (uint32 x = 0; x < db2.GetRecordCount(); ++x)
         {
             DB2Record record = db2.GetRecord(x);
-            map_info& m = map_ids[record.GetId()];
-
-            const char* map_name = record.GetString("Directory");
-            size_t max_map_name_length = sizeof(m.name);
-            if (strlen(map_name) >= max_map_name_length)
-            {
-                printf("Fatal error: Map name too long!\n");
-                exit(1);
-            }
+            if (!record)
+                continue;
 
-            strncpy(m.name, map_name, max_map_name_length);
-            m.name[max_map_name_length - 1] = '\0';
-            m.parent_id = int16(record.GetUInt16("ParentMapID"));
-            if (m.parent_id >= 0)
-                maps_that_are_parents.insert(m.parent_id);
+            MapEntry& m = map_ids[record.GetId()];
+            m.WdtFileDataId = record.GetInt32("WdtFileDataID");
+            m.ParentMapID = int16(record.GetUInt16("ParentMapID"));
+            m.Name = record.GetString("MapName");
+            m.Directory = record.GetString("Directory");
+            if (m.ParentMapID >= 0)
+                maps_that_are_parents.insert(m.ParentMapID);
         }
 
         for (uint32 x = 0; x < db2.GetRecordCopyCount(); ++x)
@@ -502,9 +502,11 @@ int main(int argc, char ** argv)
             auto itr = map_ids.find(copy.SourceRowId);
             if (itr != map_ids.end())
             {
-                map_info& id = map_ids[copy.NewRowId];
-                strcpy(id.name, itr->second.name);
-                id.parent_id = itr->second.parent_id;
+                MapEntry& id = map_ids[copy.NewRowId];
+                id.WdtFileDataId = itr->second.WdtFileDataId;
+                id.ParentMapID = itr->second.ParentMapID;
+                id.Name = itr->second.Name;
+                id.Directory = itr->second.Directory;
             }
         }
 
diff --git a/src/tools/vmap4_extractor/wdtfile.cpp b/src/tools/vmap4_extractor/wdtfile.cpp
index acbc1e5c6f0..e757dd9a398 100644
--- a/src/tools/vmap4_extractor/wdtfile.cpp
+++ b/src/tools/vmap4_extractor/wdtfile.cpp
@@ -20,6 +20,7 @@
 #include "wdtfile.h"
 #include "adtfile.h"
 #include "Common.h"
+#include "Errors.h"
 #include "StringFormat.h"
 #include <cstdio>
 
@@ -34,9 +35,11 @@ char * wdtGetPlainName(char * FileName)
 
 extern CASC::StorageHandle CascStorage;
 
-WDTFile::WDTFile(char const* storagePath, std::string mapName, bool cache)
-    : _file(CascStorage, storagePath), _mapName(std::move(mapName))
+WDTFile::WDTFile(uint32 fileDataId, std::string const& description, std::string mapName, bool cache)
+    : _file(CascStorage, fileDataId, description), _mapName(std::move(mapName))
 {
+    memset(&_header, 0, sizeof(WDT::MPHD));
+    memset(&_adtInfo, 0, sizeof(WDT::MAIN));
     if (cache)
     {
         _adtCache = Trinity::make_unique<ADTCache>();
@@ -74,10 +77,23 @@ bool WDTFile::init(uint32 mapId)
 
         size_t nextpos = _file.getPos() + size;
 
-        if (!strcmp(fourcc,"MAIN"))
+        if (!strcmp(fourcc, "MPHD"))
         {
+            ASSERT(size == sizeof(WDT::MPHD));
+            _file.read(&_header, sizeof(WDT::MPHD));
         }
-        if (!strcmp(fourcc,"MWMO"))
+        else if (!strcmp(fourcc,"MAIN"))
+        {
+            ASSERT(size == sizeof(WDT::MAIN));
+            _file.read(&_adtInfo, sizeof(WDT::MAIN));
+        }
+        else if (!strcmp(fourcc, "MAID"))
+        {
+            ASSERT(size == sizeof(WDT::MAID));
+            _adtFileDataIds = Trinity::make_unique<WDT::MAID>();
+            _file.read(_adtFileDataIds.get(), sizeof(WDT::MAID));
+        }
+        else if (!strcmp(fourcc,"MWMO"))
         {
             // global map objects
             if (size)
@@ -141,12 +157,19 @@ ADTFile* WDTFile::GetMap(int32 x, int32 y)
     if (_adtCache && _adtCache->file[x][y])
         return _adtCache->file[x][y].get();
 
-    char name[512];
+    if (!(_adtInfo.Data[x][y].Flag & 1))
+        return nullptr;
+
+    ADTFile* adt;
+    std::string name = Trinity::StringFormat("World\\Maps\\%s\\%s_%d_%d_obj0.adt", _mapName.c_str(), _mapName.c_str(), x, y);
+    if (_header.Flags & 0x200)
+        adt = new ADTFile(_adtFileDataIds->Data[x][y].Obj0ADT, name, _adtCache != nullptr);
+    else
+        adt = new ADTFile(name, _adtCache != nullptr);
 
-    sprintf(name, "World\\Maps\\%s\\%s_%d_%d_obj0.adt", _mapName.c_str(), _mapName.c_str(), x, y);
-    ADTFile* adt =  new ADTFile(name, _adtCache != nullptr);
     if (_adtCache)
         _adtCache->file[x][y].reset(adt);
+
     return adt;
 }
 
diff --git a/src/tools/vmap4_extractor/wdtfile.h b/src/tools/vmap4_extractor/wdtfile.h
index 785f046ad7b..cf3e30a7eab 100644
--- a/src/tools/vmap4_extractor/wdtfile.h
+++ b/src/tools/vmap4_extractor/wdtfile.h
@@ -27,10 +27,51 @@
 
 class ADTFile;
 
+#pragma pack(push, 1)
+namespace WDT
+{
+    struct MPHD
+    {
+        uint32 Flags;
+        uint32 LgtFileDataID;
+        uint32 OccFileDataID;
+        uint32 FogsFileDataID;
+        uint32 MpvFileDataID;
+        uint32 TexFileDataID;
+        uint32 WdlFileDataID;
+        uint32 Pd4FileDataID;
+    };
+
+    struct MAIN
+    {
+        struct SMAreaInfo
+        {
+            uint32 Flag;
+            uint32 AsyncId;
+        } Data[64][64];
+    };
+
+    struct MAID
+    {
+        struct SMAreaFileIDs
+        {
+            uint32 RootADT;         // FileDataID of mapname_xx_yy.adt
+            uint32 Obj0ADT;         // FileDataID of mapname_xx_yy_obj0.adt
+            uint32 Obj1ADT;         // FileDataID of mapname_xx_yy_obj1.adt
+            uint32 Tex0ADT;         // FileDataID of mapname_xx_yy_tex0.adt
+            uint32 LodADT;          // FileDataID of mapname_xx_yy_lod.adt
+            uint32 MapTexture;      // FileDataID of mapname_xx_yy.blp
+            uint32 MapTextureN;     // FileDataID of mapname_xx_yy_n.blp
+            uint32 MinimapTexture;  // FileDataID of mapxx_yy.blp
+        } Data[64][64];
+    };
+}
+#pragma pack(pop)
+
 class WDTFile
 {
 public:
-    WDTFile(char const* storagePath, std::string mapName, bool cache);
+    WDTFile(uint32 fileDataId, std::string const& description, std::string mapName, bool cache);
     ~WDTFile();
     bool init(uint32 mapId);
 
@@ -38,6 +79,9 @@ public:
     void FreeADT(ADTFile* adt);
 private:
     CASCFile _file;
+    WDT::MPHD _header;
+    WDT::MAIN _adtInfo;
+    std::unique_ptr<WDT::MAID> _adtFileDataIds;
     std::string _mapName;
     std::vector<std::string> _wmoNames;
     struct ADTCache
diff --git a/src/tools/vmap4_extractor/wmo.cpp b/src/tools/vmap4_extractor/wmo.cpp
index 749e14d1d05..56e3fa6faec 100644
--- a/src/tools/vmap4_extractor/wmo.cpp
+++ b/src/tools/vmap4_extractor/wmo.cpp
@@ -19,6 +19,8 @@
 #include "vmapexport.h"
 #include "adtfile.h"
 #include "cascfile.h"
+#include "Errors.h"
+#include "StringFormat.h"
 #include "vec3d.h"
 #include "VMapDefinitions.h"
 #include "wmo.h"
@@ -26,7 +28,6 @@
 #include <map>
 #include <cstdio>
 #include <cstdlib>
-#include "Errors.h"
 
 WMORoot::WMORoot(std::string const& filename)
     : filename(filename), color(0), nTextures(0), nGroups(0), nPortals(0), nLights(0),
@@ -83,6 +84,8 @@ bool WMORoot::open()
         }
         else if (!strcmp(fourcc,"MODN"))
         {
+            ASSERT(!DoodadData.FileDataIds);
+
             char* ptr = f.getPointer();
             char* end = ptr + size;
             DoodadData.Paths = std::make_unique<char[]>(size);
@@ -102,6 +105,25 @@ bool WMORoot::open()
                     ValidDoodadNames.insert(doodadNameIndex);
             }
         }
+        else if (!strcmp(fourcc, "MODI"))
+        {
+            ASSERT(!DoodadData.Paths);
+
+            char* ptr = f.getPointer();
+            char* end = ptr + size;
+            uint32 fileDataIdCount = size / sizeof(uint32);
+            DoodadData.FileDataIds = std::make_unique<uint32[]>(fileDataIdCount);
+            memcpy(DoodadData.FileDataIds.get(), ptr, size);
+            for (uint32 i = 0; i < fileDataIdCount; ++i)
+            {
+                if (!DoodadData.FileDataIds[i])
+                    continue;
+
+                std::string path = Trinity::StringFormat("FILE%08X.xxx", DoodadData.FileDataIds[i]);
+                if (ExtractSingleModel(path))
+                    ValidDoodadNames.insert(i);
+            }
+        }
         else if (!strcmp(fourcc,"MODD"))
         {
             DoodadData.Spawns.resize(size / sizeof(WMO::MODD));
diff --git a/src/tools/vmap4_extractor/wmo.h b/src/tools/vmap4_extractor/wmo.h
index fd9e8f589b4..7505fc4f077 100644
--- a/src/tools/vmap4_extractor/wmo.h
+++ b/src/tools/vmap4_extractor/wmo.h
@@ -71,6 +71,7 @@ struct WMODoodadData
 {
     std::vector<WMO::MODS> Sets;
     std::unique_ptr<char[]> Paths;
+    std::unique_ptr<uint32[]> FileDataIds;
     std::vector<WMO::MODD> Spawns;
     std::unordered_set<uint16> References;
 };