feat(event): proper code page conversion

src/client/Client.cpp

@@ -376,18 +376,17 @@ int32_t InitializeGlobal() {
     CheckAvailableLocales(existingLocale);
     locale->Set(existingLocale, true, false, false, true);
 
+    char path[STORM_MAX_PATH];
+    SStrPrintf(path, sizeof(path), "%s%s", "Data\\", locale->GetString());
+    SFile::SetDataPathAlternate(path);
+    SFile::RebuildHash();
+
 
     OpenArchives();
 
     // TODO: This method should be placed inside OpenArchives
     ClientServices::InitLoginServerCVars(1, locale->GetString());
 
-    // SStrPrintf(dest, 260, "%s%s", *(_DWORD *)off_AB6158, v2->m_stringValue.m_str);
-
-    // sub_421B50(dest);
-
-    // sub_423D70();
-
     // sub_405DD0();
 
     // CVar* v3 = CVar::Register(

src/client/Client.hpp

@@ -14,6 +14,8 @@ namespace Client {
 
 void ClientPostClose(int32_t a1);
 
+const char* UpdateInstallLocation();
+
 void CommonMain();
 
 void StormInitialize();

src/client/Patch.cpp

@@ -0,0 +1,65 @@
+#include "client/Patch.hpp"
+
+#include <storm/String.hpp>
+
+#include "client/Client.hpp"
+
+
+PatchFiles::PatchFiles() {
+    this->path = nullptr;
+}
+
+void PatchFiles::SearchArchives(const char* locale, int32_t a3) {
+    char fullPath[256] = {};
+    char pattern[256] = {};
+    char path[256] = {};
+
+    const size_t listSize = 12;
+
+    ListEntry list[listSize] = {
+        { 0, 0, false, "Data\\",         "patch-?.MPQ"    },
+        { 0, 0, false, "Data\\%s\\",     "patch-%s-?.MPQ" },
+        { 1, 0, false, "Data\\",         "patch.MPQ"      },
+        { 1, 0, false, "Data\\%s\\",     "patch-%s.MPQ"   },
+        { 1, 1, false, "Data\\",         "patch-4.MPQ"    },
+        { 1, 1, false, "Data\\%s\\",     "patch-%s-4.MPQ" },
+        { 1, 1, false, "Data\\",         "patch-3.MPQ"    },
+        { 1, 1, false, "Data\\%s\\",     "patch-%s-3.MPQ" },
+        { 1, 1, false, "..\\Data\\",     "patch-2.MPQ"    },
+        { 1, 1, false, "..\\Data\\%s\\", "patch-%s-2.MPQ" },
+        { 1, 1, false, "..\\Data\\",     "patch.MPQ"      },
+        { 1, 1, false, "..\\Data\\%s\\", "patch-%s.MPQ"   },
+    };
+
+    const char* installRoot = UpdateInstallLocation();
+
+    // Warning: assigning pointer to a temporary variable
+    // Need this for OsFileList's callback
+    this->path = path;
+
+    for (size_t i = 0; i <= 2; ++i) {
+        for (size_t j = 0; j < listSize; ++j) {
+            auto entry = &list[j];
+            if (entry->num1 != i || entry->num2 != (a3 != 0)) {
+                continue;
+            }
+
+            SStrPrintf(path, sizeof(path), entry->dataDir, locale);
+            SStrPrintf(pattern, sizeof(pattern), entry->pattern, locale);
+            if (entry->absolute && installRoot && installRoot[0]) {
+                SStrPrintf(fullPath, sizeof(fullPath), "%s%s", installRoot, path);
+                SStrCopy(path, fullPath, sizeof(path));
+                
+            }
+            // TODO: OsFileList(this->path, pattern, PatchFiles::EnumPatchArchives, this, 0);
+        }
+
+        if (i == 0) {
+            std::qsort(this->files.Ptr(), this->files.Count(), sizeof(char*), &PatchFiles::qsortpatchfiles);
+        }
+    }
+}
+
+int PatchFiles::qsortpatchfiles(const void* a1, const void* a2) {
+    return -SStrCmpI(*((const char**) a1), *((const char**) a2), STORM_MAX_STR);
+}

src/client/Patch.hpp

@@ -0,0 +1,33 @@
+#ifndef CLIENT_PATCH_HPP
+#define CLIENT_PATCH_HPP
+
+
+#include <storm/Array.hpp>
+
+
+class PatchFiles {
+    public:
+        PatchFiles();
+
+        void SearchArchives(const char* locale, int32_t a3);
+
+    public:
+        char* path;
+        TSGrowableArray<char*> files;
+
+    private:
+        static int qsortpatchfiles(const void* a1, const void* a2);
+
+    private:
+        struct ListEntry {
+            uint32_t num1;
+            uint32_t num2;
+            bool absolute;
+            const char* dataDir;
+            const char* pattern;
+        };
+};
+
+
+
+#endif

src/console/Handlers.cpp

@@ -12,14 +12,15 @@ static int32_t s_historyIndex = 0;
 namespace {
 
 int32_t OnChar(const EVENT_DATA_CHAR* data, void* param) {
-    char character[8] = {};
+    char character[2] = {};
 
     if (ConsoleAccessGetEnabled() && EventIsKeyDown(ConsoleGetHotKey())) {
         return 0;
     }
 
     if (ConsoleGetActive()) {
-        SUniSPutUTF8(data->ch, character);
+        character[0] = char(data->ch);
+        character[1] = 0;
 
         PasteInInputLine(character);
         ResetHighlight();

src/event/win/Input.cpp

@@ -8,6 +8,142 @@
 #include "event/sdl/Input.hpp"
 #endif
 
+static const uint32_t s_latin5lookup[256] = {
+    0x00,   0x01,   0x02,   0x03,   0x04,   0x05,   0x06,   0x07,   0x08,
+    0x09,   0x0A,   0x0B,   0x0C,   0x0D,   0x0E,   0x0F,   0x10,   0x11,
+    0x12,   0x13,   0x14,   0x15,   0x16,   0x17,   0x18,   0x19,   0x1A,
+    0x1B,   0x1C,   0x1D,   0x1E,   0x1F,   0x20,   0x21,   0x22,   0x23,
+    0x24,   0x25,   0x26,   0x27,   0x28,   0x29,   0x2A,   0x2B,   0x2C,
+    0x2D,   0x2E,   0x2F,   0x30,   0x31,   0x32,   0x33,   0x34,   0x35,
+    0x36,   0x37,   0x38,   0x39,   0x3A,   0x3B,   0x3C,   0x3D,   0x3E,
+    0x3F,   0x40,   0x41,   0x42,   0x43,   0x44,   0x45,   0x46,   0x47,
+    0x48,   0x49,   0x4A,   0x4B,   0x4C,   0x4D,   0x4E,   0x4F,   0x50,
+    0x51,   0x52,   0x53,   0x54,   0x55,   0x56,   0x57,   0x58,   0x59,
+    0x5A,   0x5B,   0x5C,   0x5D,   0x5E,   0x5F,   0x60,   0x61,   0x62,
+    0x63,   0x64,   0x65,   0x66,   0x67,   0x68,   0x69,   0x6A,   0x6B,
+    0x6C,   0x6D,   0x6E,   0x6F,   0x70,   0x71,   0x72,   0x73,   0x74,
+    0x75,   0x76,   0x77,   0x78,   0x79,   0x7A,   0x7B,   0x7C,   0x7D,
+    0x7E,   0x7F,   0x20AC, 0x20,   0x201A, 0x192,  0x201E, 0x2026, 0x2020,
+    0x2021, 0x2C6,  0x2030, 0x160,  0x2039, 0x152,  0x20,   0x20,   0x20,
+    0x20,   0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x2DC,
+    0x2122, 0x161,  0x203A, 0x153,  0x20,   0x20,   0x178,  0x0A0,  0x0A1,
+    0x0A2,  0x0A3,  0x0A4,  0x0A5,  0x0A6,  0x0A7,  0x0A8,  0x0A9,  0x0AA,
+    0x0AB,  0x0AC,  0x0AD,  0x0AE,  0x0AF,  0x0B0,  0x0B1,  0x0B2,  0x0B3,
+    0x0B4,  0x0B5,  0x0B6,  0x0B7,  0x0B8,  0x0B9,  0x0BA,  0x0BB,  0x0BC,
+    0x0BD,  0x0BE,  0x0BF,  0x0C0,  0x0C1,  0x0C2,  0x0C3,  0x0C4,  0x0C5,
+    0x0C6,  0x0C7,  0x0C8,  0x0C9,  0x0CA,  0x0CB,  0x0CC,  0x0CD,  0x0CE,
+    0x0CF,  0x11E,  0x0D1,  0x0D2,  0x0D3,  0x0D4,  0x0D5,  0x0D6,  0x0D7,
+    0x0D8,  0x0D9,  0x0DA,  0x0DB,  0x0DC,  0x130,  0x15E,  0x0DF,  0x0E0,
+    0x0E1,  0x0E2,  0x0E3,  0x0E4,  0x0E5,  0x0E6,  0x0E7,  0x0E8,  0x0E9,
+    0x0EA,  0x0EB,  0x0EC,  0x0ED,  0x0EE,  0x0EF,  0x11F,  0x0F1,  0x0F2,
+    0x0F3,  0x0F4,  0x0F5,  0x0F6,  0x0F7,  0x0F8,  0x0F9,  0x0FA,  0x0FB,
+    0x0FC,  0x131,  0x15F,  0x0FF
+};
+
+static const uint32_t s_latin1lookup[32] = {
+    0x0FFFE, 0x0FFFE, 0x201A, 0x192,  0x201E, 0x2026,  0x2020,  0x2021,
+    0x2C6,   0x2030,  0x160,  0x2039, 0x152,  0x0FFFE, 0x0FFFE, 0x0FFFE,
+    0x0FFFE, 0x2018,  0x2019, 0x201C, 0x201D, 0x2022,  0x2013,  0x2014,
+    0x2DC,   0x2122,  0x161,  0x203A, 0x153,  0x0FFFE, 0x0FFFE, 0x178
+};
+
+static const uint32_t s_cyrilliclookup[256] = {
+    0x00,   0x01,   0x02,   0x03,   0x04,   0x05,   0x06,   0x07,   0x08,
+    0x09,   0x0A,   0x0B,   0x0C,   0x0D,   0x0E,   0x0F,   0x10,   0x11,
+    0x12,   0x13,   0x14,   0x15,   0x16,   0x17,   0x18,   0x19,   0x1A,
+    0x1B,   0x1C,   0x1D,   0x1E,   0x1F,   0x20,   0x21,   0x22,   0x23,
+    0x24,   0x25,   0x26,   0x27,   0x28,   0x29,   0x2A,   0x2B,   0x2C,
+    0x2D,   0x2E,   0x2F,   0x30,   0x31,   0x32,   0x33,   0x34,   0x35,
+    0x36,   0x37,   0x38,   0x39,   0x3A,   0x3B,   0x3C,   0x3D,   0x3E,
+    0x3F,   0x40,   0x41,   0x42,   0x43,   0x44,   0x45,   0x46,   0x47,
+    0x48,   0x49,   0x4A,   0x4B,   0x4C,   0x4D,   0x4E,   0x4F,   0x50,
+    0x51,   0x52,   0x53,   0x54,   0x55,   0x56,   0x57,   0x58,   0x59,
+    0x5A,   0x5B,   0x5C,   0x5D,   0x5E,   0x5F,   0x60,   0x61,   0x62,
+    0x63,   0x64,   0x65,   0x66,   0x67,   0x68,   0x69,   0x6A,   0x6B,
+    0x6C,   0x6D,   0x6E,   0x6F,   0x70,   0x71,   0x72,   0x73,   0x74,
+    0x75,   0x76,   0x77,   0x78,   0x79,   0x7A,   0x7B,   0x7C,   0x7D,
+    0x7E,   0x7F,   0x402,  0x403,  0x201A, 0x453,  0x201E, 0x2026, 0x2020,
+    0x2021, 0x20AC, 0x2030, 0x409,  0x2039, 0x40A,  0x40C,  0x40B,  0x40F,
+    0x452,  0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x20,
+    0x2122, 0x459,  0x203A, 0x45A,  0x45C,  0x45B,  0x45F,  0x0A0,  0x40E,
+    0x45E,  0x408,  0x0A4,  0x490,  0x0A6,  0x0A7,  0x401,  0x0A9,  0x404,
+    0x0AB,  0x0AC,  0x0AD,  0x0AE,  0x407,  0x0B0,  0x0B1,  0x406,  0x456,
+    0x491,  0x0B5,  0x0B6,  0x0B7,  0x451,  0x2116, 0x454,  0x0BB,  0x458,
+    0x405,  0x455,  0x457,  0x410,  0x411,  0x412,  0x413,  0x414,  0x415,
+    0x416,  0x417,  0x418,  0x419,  0x41A,  0x41B,  0x41C,  0x41D,  0x41E,
+    0x41F,  0x420,  0x421,  0x422,  0x423,  0x424,  0x425,  0x426,  0x427,
+    0x428,  0x429,  0x42A,  0x42B,  0x42C,  0x42D,  0x42E,  0x42F,  0x430,
+    0x431,  0x432,  0x433,  0x434,  0x435,  0x436,  0x437,  0x438,  0x439,
+    0x43A,  0x43B,  0x43C,  0x43D,  0x43E,  0x43F,  0x440,  0x441,  0x442,
+    0x443,  0x444,  0x445,  0x446,  0x447,  0x448,  0x449,  0x44A,  0x44B,
+    0x44C,  0x44D,  0x44E,  0x44F
+};
+
+static const uint32_t s_latin2lookup[256] = {
+    0x00,    0x01,    0x02,   0x03,    0x04,   0x05,    0x06,   0x07,   0x08,
+    0x09,    0x0A,    0x0B,   0x0C,    0x0D,   0x0E,    0x0F,   0x10,   0x11,
+    0x12,    0x13,    0x14,   0x15,    0x16,   0x17,    0x18,   0x19,   0x1A,
+    0x1B,    0x1C,    0x1D,   0x1E,    0x1F,   0x20,    0x21,   0x22,   0x23,
+    0x24,    0x25,    0x26,   0x27,    0x28,   0x29,    0x2A,   0x2B,   0x2C,
+    0x2D,    0x2E,    0x2F,   0x30,    0x31,   0x32,    0x33,   0x34,   0x35,
+    0x36,    0x37,    0x38,   0x39,    0x3A,   0x3B,    0x3C,   0x3D,   0x3E,
+    0x3F,    0x40,    0x41,   0x42,    0x43,   0x44,    0x45,   0x46,   0x47,
+    0x48,    0x49,    0x4A,   0x4B,    0x4C,   0x4D,    0x4E,   0x4F,   0x50,
+    0x51,    0x52,    0x53,   0x54,    0x55,   0x56,    0x57,   0x58,   0x59,
+    0x5A,    0x5B,    0x5C,   0x5D,    0x5E,   0x5F,    0x60,   0x61,   0x62,
+    0x63,    0x64,    0x65,   0x66,    0x67,   0x68,    0x69,   0x6A,   0x6B,
+    0x6C,    0x6D,    0x6E,   0x6F,    0x70,   0x71,    0x72,   0x73,   0x74,
+    0x75,    0x76,    0x77,   0x78,    0x79,   0x7A,    0x7B,   0x7C,   0x7D,
+    0x7E,    0x7F,    0x20AC, 0x0FFFE, 0x201A, 0x0FFFE, 0x201E, 0x2026, 0x2020,
+    0x2021,  0x0FFFE, 0x2030, 0x160,   0x2039, 0x15A,   0x164,  0x17D,  0x179,
+    0x0FFFE, 0x2018,  0x2019, 0x201C,  0x201D, 0x2022,  0x2013, 0x2014, 0x0FFFE,
+    0x2122,  0x161,   0x203A, 0x15B,   0x165,  0x17E,   0x17A,  0x0A0,  0x2C7,
+    0x2D8,   0x141,   0x0A4,  0x104,   0x0A6,  0x0A7,   0x0A8,  0x0A9,  0x15E,
+    0x0AB,   0x0AC,   0x0AD,  0x0AE,   0x17B,  0x0B0,   0x0B1,  0x2DB,  0x142,
+    0x0B4,   0x0B5,   0x0B6,  0x0B7,   0x0B8,  0x105,   0x15F,  0x0BB,  0x13D,
+    0x2DD,   0x13E,   0x17C,  0x154,   0x0C1,  0x0C2,   0x102,  0x0C4,  0x139,
+    0x106,   0x0C7,   0x10C,  0x0C9,   0x118,  0x0CB,   0x11A,  0x0CD,  0x0CE,
+    0x10E,   0x110,   0x143,  0x147,   0x0D3,  0x0D4,   0x150,  0x0D6,  0x0D7,
+    0x158,   0x16E,   0x0DA,  0x170,   0x0DC,  0x0DD,   0x162,  0x0DF,  0x155,
+    0x0E1,   0x0E2,   0x103,  0x0E4,   0x13A,  0x107,   0x0E7,  0x10D,  0x0E9,
+    0x119,   0x0EB,   0x11B,  0x0ED,   0x0EE,  0x10F,   0x111,  0x144,  0x148,
+    0x0F3,   0x0F4,   0x151,  0x0F6,   0x0F7,  0x159,   0x16F,  0x0FA,  0x171,
+    0x0FC,   0x0FD,   0x163,  0x2D9
+};
+
+static const uint32_t s_thailookup[256] = {
+    0x00,   0x01,   0x02,   0x03,   0x04,   0x05,   0x06,   0x07,   0x08,
+    0x09,   0x0A,   0x0B,   0x0C,   0x0D,   0x0E,   0x0F,   0x10,   0x11,
+    0x12,   0x13,   0x14,   0x15,   0x16,   0x17,   0x18,   0x19,   0x1A,
+    0x1B,   0x1C,   0x1D,   0x1E,   0x1F,   0x20,   0x21,   0x22,   0x23,
+    0x24,   0x25,   0x26,   0x27,   0x28,   0x29,   0x2A,   0x2B,   0x2C,
+    0x2D,   0x2E,   0x2F,   0x30,   0x31,   0x32,   0x33,   0x34,   0x35,
+    0x36,   0x37,   0x38,   0x39,   0x3A,   0x3B,   0x3C,   0x3D,   0x3E,
+    0x3F,   0x40,   0x41,   0x42,   0x43,   0x44,   0x45,   0x46,   0x47,
+    0x48,   0x49,   0x4A,   0x4B,   0x4C,   0x4D,   0x4E,   0x4F,   0x50,
+    0x51,   0x52,   0x53,   0x54,   0x55,   0x56,   0x57,   0x58,   0x59,
+    0x5A,   0x5B,   0x5C,   0x5D,   0x5E,   0x5F,   0x60,   0x61,   0x62,
+    0x63,   0x64,   0x65,   0x66,   0x67,   0x68,   0x69,   0x6A,   0x6B,
+    0x6C,   0x6D,   0x6E,   0x6F,   0x70,   0x71,   0x72,   0x73,   0x74,
+    0x75,   0x76,   0x77,   0x78,   0x79,   0x7A,   0x7B,   0x7C,   0x7D,
+    0x7E,   0x7F,   0x20AC, 0x20,   0x20,   0x20,   0x20,   0x2026, 0x20,
+    0x20,   0x20,   0x20,   0x20,   0x20,   0x20,   0x20,   0x20,   0x20,
+    0x20,   0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x20,
+    0x20,   0x20,   0x20,   0x20,   0x20,   0x20,   0x20,   0x0A0,  0x0E01,
+    0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07, 0x0E08, 0x0E09, 0x0E0A,
+    0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F, 0x0E10, 0x0E11, 0x0E12, 0x0E13,
+    0x0E14, 0x0E15, 0x0E16, 0x0E17, 0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C,
+    0x0E1D, 0x0E1E, 0x0E1F, 0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25,
+    0x0E26, 0x0E27, 0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E,
+    0x0E2F, 0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
+    0x0E38, 0x0E39, 0x0E3A, 0x20,   0x20,   0x20,   0x20,   0x0E3F, 0x0E40,
+    0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47, 0x0E48, 0x0E49,
+    0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F, 0x0E50, 0x0E51, 0x0E52,
+    0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57, 0x0E58, 0x0E59, 0x0E5A, 0x0E5B,
+    0x20,   0x20,   0x20,   0x20
+};
+
+
 static RECT s_defaultWindowRect;
 static int32_t s_savedResize;
 
@@ -469,7 +605,13 @@ void OsInputGetMousePosition(int32_t* x, int32_t* y) {
     }
 }
 
+uint32_t OsInputGetCodePage() {
+    return ::GetACP();
+}
+
 int32_t OsWindowProc(void* window, uint32_t message, uintptr_t wparam, intptr_t lparam) {
+    static uint32_t s_codepage = 0;
+
     auto hwnd = static_cast<HWND>(window);
 
     // TODO
@@ -539,14 +681,28 @@ int32_t OsWindowProc(void* window, uint32_t message, uintptr_t wparam, intptr_t
         uint32_t character = wparam;
 
         if (wparam >= 128) {
-            // Workaround
-            wchar_t u16_character = 0;
-            ::MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, reinterpret_cast<char*>(&wparam), 1, &u16_character, 1);
-            character = u16_character;
+            if (s_codepage == 0) {
+                s_codepage = OsInputGetCodePage();
+            }
+            if (s_codepage == 1254) {
+                // ANSI Turkish; Turkish (Windows)
+                character = s_latin5lookup[wparam % 256];
+            } else if (s_codepage == 1252 && wparam < 0xA0) {
+                // ANSI Latin 1; Western European (Windows)
+                character = s_latin1lookup[wparam % 32];
+            } else if (s_codepage == 1251) {
+                // ANSI Cyrillic; Cyrillic (Windows)
+                character = s_cyrilliclookup[wparam % 256];
+            } else if (s_codepage == 1250) {
+                // ANSI Central European; Central European (Windows)
+                character = s_latin2lookup[wparam % 256];
+            } else if (s_codepage == 874) {
+                // Thai (Windows)
+                character = s_thailookup[wparam % 256];
+            }
         }
 
         OsQueuePut(OS_INPUT_CHAR, character, LOWORD(lparam), 0, 0);
-
         return 0;
     }
 

src/util/SFile.cpp

@@ -8,8 +8,9 @@
 #include <bc/file/File.hpp>
 #include "util/Filesystem.hpp"
 
-static char s_basepath[STORM_MAX_PATH] = {0};
-static char s_datapath[STORM_MAX_PATH] = {0};
+static char s_basepath[STORM_MAX_PATH] = { 0 };
+static char s_datapath[STORM_MAX_PATH] = { 0 };
+static char s_datapath2[STORM_MAX_PATH] = { 0 };
 
 // TODO Proper implementation
 int32_t SFile::Close(SFile* file) {
@@ -279,3 +280,17 @@ int32_t SFile::GetDataPath(char* buffer, size_t bufferchars) {
     SStrCopy(buffer, s_datapath, bufferchars);
     return 1;
 }
+
+int32_t SFile::SetDataPathAlternate(const char* path) {
+    SStrCopy(s_datapath2, path, STORM_MAX_PATH);
+    size_t length = SStrLen(s_datapath2);
+    if (length && s_datapath2[length - 1] != '\\' && s_datapath2[length - 1] != '/') {
+        SStrPack(s_datapath2, "\\", STORM_MAX_PATH);
+    }
+    return 1;
+}
+
+int32_t SFile::RebuildHash() {
+    // TODO
+    return 1;
+}

src/util/SFile.hpp

@@ -39,6 +39,8 @@ class SFile {
         static int32_t SetDataPath(const char* path);
         static int32_t GetBasePath(char* path, size_t capacity);
         static int32_t GetDataPath(char* path, size_t capacity);
+        static int32_t SetDataPathAlternate(const char* path);
+        static int32_t RebuildHash();
 
         // Member variables
         SFILE_TYPE m_type;