// This file is part of ClassicAPI. // // ClassicAPI is free software: you can redistribute it and/or modify it under the terms // of the GNU Lesser General Public License as published by the Free Software Foundation, either // version 3 of the License, or (at your option) any later version. // // ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR // PURPOSE. See the GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License along with // ClassicAPI. If not, see . // `ExportInterfaceFiles art|code` — backport of the 4.3.4 developer- // console command of the same name. Registered as a real console // command (the `~` console available when the client is launched with // `-console`), exactly like retail. Dumps Blizzard's UI files out of // the mounted MPQ archives onto disk: // // code → .lua / .xml / .toc / .xsd → BlizzardInterfaceCode\... // art → .blp / .tga → BlizzardInterfaceArt\... // // Files land relative to the client's working directory, mirroring the // retail command's `BlizzardInterface{Code,Art}\` // layout. On completion it writes a "wrote N files" line back to the // console. // // **How it works (vanilla 1.12 / Octo):** // // Like 4.3.4, we enumerate the mounted archives' `(listfile)` — the // flat, full-path file index — rather than walking directories. The // vanilla primitive is `FUN_MPQ_ENUM_FILES` (`0x00401470`, the same // MPQ walk the macro-icon loader uses): it loops the archive handles // and dispatches a callback per listfile entry under a path prefix // (here `"Interface\"`). We collect every matching full path (deduped // across archives), then read each via `FUN_FILE_READ` and write it to // disk with Win32. // // Don't confuse this with `FUN_0042AD10`, the disk-only // `FindFirstFileW` walker — pointing the export at that yields zero // MPQ files. See the `FUN_MPQ_ENUM_FILES` note in Offsets.h. // // We export the full `Interface\` tree, matching 4.3.4 (extension // filter only, no path exclusion). That INCLUDES `Interface\AddOns\` — // the listfile only indexes MPQ-baked files, so those AddOns entries // are Blizzard's own UI addons (Blizzard_AuctionUI, Blizzard_TalentUI, // …), which are part of the stock UI source. The player's loose, // on-disk addons live in no archive's listfile, so they're never // enumerated and never re-exported. #include "Game.h" #include "Offsets.h" #include #include #include #include #include #include namespace Interface::Export { namespace { // Engine's file-content reader (see Offsets::FUN_FILE_READ). __stdcall // (callee cleans 28 bytes via RET 0x1C — NOT __cdecl; getting this // wrong corrupts the caller's stack). Allocates a Storm buffer; free // with SMemFree. using FileRead_t = int(__stdcall *)(int unused, const char *path, void **outBuf, unsigned int *outSize, unsigned int extraBytes, int flag1, int flag2); using SMemFree_t = void(__stdcall *)(void *ptr, const char *file, int line, int flags); // MPQ enumerator (see Offsets::FUN_MPQ_ENUM_FILES). The callback // receives each listfile entry's full path in ecx; returning 0 STOPS // enumeration, so we return 1 to keep going. using MpqEnumCb_t = int(__fastcall *)(const char *fullPath); using MpqEnumFiles_t = void(__fastcall *)(int archiveSelector, const char *pathPrefix, MpqEnumCb_t callback, void *userParam); // The archive-set selector the engine's own macro-icon loader passes to // FUN_00401470 — covers the primary mounted archives plus the selected // extra. We mirror it. constexpr int kArchiveSelector = 6; // Case-insensitive ASCII equality. bool EqualsCI(const char *a, const char *b) { for (;; ++a, ++b) { char ca = *a, cb = *b; if (ca >= 'A' && ca <= 'Z') ca = static_cast(ca + ('a' - 'A')); if (cb >= 'A' && cb <= 'Z') cb = static_cast(cb + ('a' - 'A')); if (ca != cb) return false; if (ca == '\0') return true; } } bool HasExtension(const char *name, const char *const *exts, int count) { const char *dot = nullptr; for (const char *p = name; *p; ++p) { if (*p == '.') dot = p; } if (dot == nullptr) return false; for (int i = 0; i < count; ++i) { if (EqualsCI(dot + 1, exts[i])) return true; } return false; } // Create every parent directory of `relPath` (a backslash-separated // path, e.g. "BlizzardInterfaceCode\FrameXML\Foo.lua"). Each component // is created relative to the working directory; existing dirs are a // no-op. void EnsureParentDirs(const std::string &relPath) { std::string accum; for (size_t i = 0; i < relPath.size(); ++i) { const char c = relPath[i]; if (c == '\\' || c == '/') { if (!accum.empty()) CreateDirectoryA(accum.c_str(), nullptr); accum.push_back('\\'); } else { accum.push_back(c); } } } bool WriteFileToDisk(const std::string &relPath, const void *data, unsigned int size) { EnsureParentDirs(relPath); HANDLE h = CreateFileA(relPath.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); if (h == INVALID_HANDLE_VALUE) return false; bool ok = true; if (size != 0) { DWORD written = 0; ok = WriteFile(h, data, size, &written, nullptr) != 0 && written == size; } CloseHandle(h); return ok; } // Length of the "Interface\" prefix we strip from MPQ paths before // re-rooting under the destination folder. constexpr size_t kRootPrefixLen = 10; // strlen("Interface\\") const char *const kCodeExts[] = {"lua", "xml", "toc", "xsd"}; const char *const kArtExts[] = {"blp", "tga"}; enum Mode { MODE_CODE, MODE_ART }; // Collector for the MPQ enumeration callback. File-static because // FUN_00401470 hands the callback only the path string; enumeration is // synchronous and single-threaded, so a file-static sink is safe. struct Collector { const char *const *exts = nullptr; int extCount = 0; std::vector files; std::unordered_set seen; // dedup across archives }; Collector *g_collector = nullptr; // MPQ enumeration callback — one call per listfile entry under the // "Interface\" prefix. Keep going (return 1) regardless. int __fastcall CollectCb(const char *fullPath) { Collector *c = g_collector; if (c != nullptr && fullPath != nullptr && HasExtension(fullPath, c->exts, c->extCount)) { if (c->seen.insert(fullPath).second) c->files.emplace_back(fullPath); } return 1; // 0 would stop enumeration } // Enumerate every MPQ file under Interface\ whose extension matches // `mode`, read each, and write it under the destination root. Returns // the number of files successfully written. int ExportTree(Mode mode) { auto MpqEnumFiles = reinterpret_cast(Offsets::FUN_MPQ_ENUM_FILES); auto FileRead = reinterpret_cast(Offsets::FUN_FILE_READ); auto SMemFree = reinterpret_cast(Offsets::FUN_STORM_SMEM_FREE); const char *dstRoot = (mode == MODE_ART) ? "BlizzardInterfaceArt" : "BlizzardInterfaceCode"; Collector collector; collector.exts = (mode == MODE_ART) ? kArtExts : kCodeExts; collector.extCount = (mode == MODE_ART) ? 2 : 4; g_collector = &collector; MpqEnumFiles(kArchiveSelector, "Interface\\", &CollectCb, nullptr); g_collector = nullptr; const std::vector &files = collector.files; int written = 0; for (const std::string &src : files) { void *buf = nullptr; unsigned int size = 0; if (FileRead(0, src.c_str(), &buf, &size, 0, 1, 0) == 0 || buf == nullptr) continue; // Re-root: "Interface\FrameXML\Foo.lua" -> "\FrameXML\Foo.lua". std::string dst = dstRoot; dst.push_back('\\'); dst.append(src, kRootPrefixLen, std::string::npos); if (WriteFileToDisk(dst, buf, size)) ++written; SMemFree(buf, __FILE__, __LINE__, 0); } return written; } // Console-command handler ABI: edx = the argument text after the // command name ("" when bare). Mirrors 4.3.4's `art`/`code` dispatch. bool FirstTokenEquals(const char *s, const char *token) { size_t i = 0; for (; token[i] != '\0'; ++i) { char a = s[i]; if (a >= 'A' && a <= 'Z') a = static_cast(a + ('a' - 'A')); if (a != token[i]) return false; } const char end = s[i]; return end == '\0' || end == ' ' || end == '\t'; } int __fastcall Console_ExportInterfaceFiles(void * /*unused*/, const char *args) { const char *p = (args != nullptr) ? args : ""; while (*p == ' ' || *p == '\t') ++p; Mode mode; if (FirstTokenEquals(p, "art")) mode = MODE_ART; else if (FirstTokenEquals(p, "code")) mode = MODE_CODE; else { Game::Console::Write("Usage: ExportInterfaceFiles art|code"); return 1; } const int written = ExportTree(mode); char msg[160]; snprintf(msg, sizeof(msg), "ExportInterfaceFiles: wrote %d %s file(s) to %s\\", written, (mode == MODE_ART) ? "art" : "code", (mode == MODE_ART) ? "BlizzardInterfaceArt" : "BlizzardInterfaceCode"); Game::Console::Write(msg); return 1; } // Register the console command. A console command is process-global // (not Lua-state-bound) and persists for the whole session, so the // single registration at glue boot — the earliest hook, firing at // launch before any console can be opened — covers both the login // console and in-world. The glue hook re-fires on each world→glue // return (logout), but the engine's registrar dedups by name (and we // pass the same string literal, so its pointer-equality fast path // catches the repeat), making a second call a no-op. The command name // and help string are stored by pointer, so they must be static — // string literals satisfy that for the DLL's lifetime. void EnsureRegistered() { Game::Console::RegisterCommand( "ExportInterfaceFiles", &Console_ExportInterfaceFiles, Game::Console::CATEGORY_DEBUG, "Extracts Blizzard's UI files from the MPQs to disk. " "Usage: ExportInterfaceFiles art|code"); } const Game::GlueModuleAutoRegister _autoreg{&EnsureRegistered}; } // namespace } // namespace Interface::Export