Maintenance: Last CRYPT_* sites and every unit-local decrypt helper replaced by OBFUSCATE_SOURCE* / OBFUSCATE_DECRYPT* (Utility/Ciphe
Batch #18622 by ragnarok-clanker: forced by an admin (0 lower score(s), 24 changed function(s)); checked with 18 compiled unit(s).
This commit is contained in:
ragnarok-clanker
parent
a30e4fefdd
commit
27d2b63b4a
18 changed files with 387 additions and 453 deletions
|
|
@ -119,13 +119,6 @@ HINSTANCE g_instance;
|
|||
// GLOBAL: gl_24584
|
||||
char g_applicationDirectory[0x80];
|
||||
|
||||
// INLINED
|
||||
template <std::uint64_t Key, typename Source, std::size_t Length>
|
||||
EncryptedName<Length, Key>& ThreadLocalName(const std::array<Source, Length>& source) {
|
||||
thread_local EncryptedName<Length, Key> name(source);
|
||||
return name;
|
||||
}
|
||||
|
||||
struct AdtestexeProcessName {
|
||||
EncryptedName<14, 0xD98F03A52D35636DULL>& operator()() const;
|
||||
};
|
||||
|
|
@ -664,13 +657,13 @@ int RemovePath(std::string path, int depth, bool file) {
|
|||
// FUNCTION: fn_24363
|
||||
bool RestartFromCommandLine() {
|
||||
const std::array markerSource = {'\x2E', '\xDF', '\x58', '\x2E', '\xF5', '\x1C', '\x2F', '\x4E', '\x73', '\xE1', '\x7C', '\x08', '\xCF', '\x3E', '\x15', '\x7F', '\x3B', '\xB3'};
|
||||
EncryptedName<sizeof(markerSource), 0x2B477F9B5B39B301ULL>& markerName = ThreadLocalName<0x2B477F9B5B39B301ULL>(markerSource);
|
||||
EncryptedName<sizeof(markerSource), 0x2B477F9B5B39B301ULL>& markerName = OBFUSCATE_DECRYPT_NAME(0x2B477F9B5B39B301ULL, markerSource);
|
||||
char* marker = std::strstr(g_commandLine, markerName.Text());
|
||||
if (!marker) {
|
||||
return false;
|
||||
}
|
||||
const std::array prefixSource = {'\xB8', '\x1D', '\xC6', '\xC8', '\x0F', '\x40', '\xEB', '\x3E', '\xE5', '\x23', '\xE2', '\xEE', '\x35', '\x62', '\xD1', '\x0F', '\xAD', '\x71'};
|
||||
EncryptedName<sizeof(prefixSource), 0x5B832361BDA77197ULL>& prefixName = ThreadLocalName<0x5B832361BDA77197ULL>(prefixSource);
|
||||
EncryptedName<sizeof(prefixSource), 0x5B832361BDA77197ULL>& prefixName = OBFUSCATE_DECRYPT_NAME(0x5B832361BDA77197ULL, prefixSource);
|
||||
char* commandLine = marker + std::strlen(prefixName.Text());
|
||||
STARTUPINFOA startup = {};
|
||||
startup.cb = sizeof(startup);
|
||||
|
|
@ -695,9 +688,9 @@ void ApplyAiPatch() {
|
|||
}
|
||||
|
||||
if (_access(OBFUSCATE_BYTES_TEXT("AI_backup", 0x49C3759B77DBD3C1ULL), 0) == 0) {
|
||||
constexpr std::array<std::uint8_t, 10> deleteSource = CRYPT_NAME("AI_backup", 0x6DED3DD1CF75AD9BULL);
|
||||
constexpr std::array<std::uint8_t, 10> deleteSource = OBFUSCATE_SOURCE("AI_backup", 0x6DED3DD1CF75AD9BULL);
|
||||
char path[16] = {};
|
||||
EncryptedName<sizeof(deleteSource), 0x6DED3DD1CF75AD9BULL>& deleteName = ThreadLocalName<0x6DED3DD1CF75AD9BULL>(deleteSource);
|
||||
EncryptedName<sizeof(deleteSource), 0x6DED3DD1CF75AD9BULL>& deleteName = OBFUSCATE_DECRYPT_NAME(0x6DED3DD1CF75AD9BULL, deleteSource);
|
||||
std::strcpy(path, deleteName.Text());
|
||||
|
||||
SHFILEOPSTRUCTA operation = {};
|
||||
|
|
@ -796,12 +789,12 @@ bool ReplaceClientExecutable(char* executable, const char* update) {
|
|||
const std::array messageSource = {'\xBA', '\xB0', '\x67', '\xDB', '\x84', '\x2E', '\xC1', '\xFC', '\xF0', '\xA7', '\x2E', '\xDB', '\x82', '\x24', '\x80', '\xF5',
|
||||
'\xFE', '\xED', '\x67', '\xFE', '\x87', '\x2E', '\x90', '\xE4', '\xFA', '\xE3', '\x22', '\xD0', '\xCB', '\x08', '\x8A', '\xB1',
|
||||
'\xEF', '\xA2', '\x35', '\xDC', '\xCB', '\x24', '\x8E', '\xFF', '\xEB', '\xAA', '\x29', '\xC8', '\x8A', '\x35', '\xCF', '\x91'};
|
||||
EncryptedName<sizeof(messageSource), 0x91E147EBBD47C39FULL>& message = ThreadLocalName<0x91E147EBBD47C39FULL>(messageSource);
|
||||
EncryptedName<sizeof(messageSource), 0x91E147EBBD47C39FULL>& message = OBFUSCATE_DECRYPT_NAME(0x91E147EBBD47C39FULL, messageSource);
|
||||
format = message.Text();
|
||||
} else {
|
||||
const std::array messageSource = {'\x24', '\x24', '\xB7', '\xB6', '\x60', '\xA5', '\x30', '\xB9', '\x60', '\x39', '\xF0', '\xBA', '\x77', '\xAB', '\x73', '\x81', '\x73', '\x32',
|
||||
'\xE4', '\xAC', '\x33', '\xEA', '\x38', '\xF1', '\x75', '\x38', '\xB7', '\xAD', '\x76', '\xF6', '\x27', '\xB0', '\x73', '\x23', '\x97'};
|
||||
EncryptedName<sizeof(messageSource), 0xD1538513DF975701ULL>& message = ThreadLocalName<0xD1538513DF975701ULL>(messageSource);
|
||||
EncryptedName<sizeof(messageSource), 0xD1538513DF975701ULL>& message = OBFUSCATE_DECRYPT_NAME(0xD1538513DF975701ULL, messageSource);
|
||||
format = message.Text();
|
||||
}
|
||||
|
||||
|
|
@ -809,7 +802,7 @@ bool ReplaceClientExecutable(char* executable, const char* update) {
|
|||
std::sprintf(text, format, executable);
|
||||
|
||||
const std::array titleSource = {'\x0C', '\x49', '\xFC', '\x3B', '\x27', '\x43'};
|
||||
EncryptedName<sizeof(titleSource), 0x078143534999254DULL>& title = ThreadLocalName<0x078143534999254DULL>(titleSource);
|
||||
EncryptedName<sizeof(titleSource), 0x078143534999254DULL>& title = OBFUSCATE_DECRYPT_NAME(0x078143534999254DULL, titleSource);
|
||||
if (MessageBoxA(nullptr, text, title.Text(), MB_OKCANCEL | MB_ICONINFORMATION) != IDOK) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1037,7 +1030,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
if (!CConfigMgr::Create()) {
|
||||
const std::array nameSource = {'\xC6', '\x22', '\xE4', '\x79', '\x19', '\x08', '\xC2', '\xE2', '\xE2', '\x13', '\xB1', '\x2D', '\x3C', '\x13', '\xC0', '\xCE',
|
||||
'\xF1', '\x04', '\xC2', '\x79', '\x0C', '\x15', '\xC4', '\xC1', '\xE6', '\x04', '\xA3', '\x3E', '\x7F'};
|
||||
EncryptedName<sizeof(nameSource), 0xAFA5617F178B6185ULL>& name = ThreadLocalName<0xAFA5617F178B6185ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xAFA5617F178B6185ULL>& name = OBFUSCATE_DECRYPT_NAME(0xAFA5617F178B6185ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1047,7 +1040,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
if (!g_stoveMgr->m_initialized) {
|
||||
const std::array nameSource = {'\x70', '\xC0', '\x39', '\xFA', '\xED', '\xF0', '\x16', '\xFC', '\x41', '\xA9', '\x77', '\xD6', '\xE9', '\xF0', '\x3A', '\xEF',
|
||||
'\x56', '\xDA', '\x23', '\xE6', '\xEF', '\xF4', '\x35', '\xF8', '\x56', '\xBB', '\x64', '\x95'};
|
||||
EncryptedName<sizeof(nameSource), 0x9B5B959B954D9333ULL>& name = ThreadLocalName<0x9B5B959B954D9333ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x9B5B959B954D9333ULL>& name = OBFUSCATE_DECRYPT_NAME(0x9B5B959B954D9333ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
}
|
||||
|
|
@ -1055,7 +1048,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
if (!CThemidaMgr::Create()) {
|
||||
const std::array nameSource = {'\x22', '\xFB', '\xE7', '\x5C', '\xE6', '\xA0', '\x9B', '\x76', '\x2C', '\xC8', '\xFD', '\x03', '\xB1', '\x8A', '\x8D', '\x72',
|
||||
'\x00', '\xDB', '\xEA', '\x70', '\xE5', '\xBA', '\x8B', '\x76', '\x0F', '\xCC', '\xEA', '\x11', '\xA2', '\xC9'};
|
||||
EncryptedName<sizeof(nameSource), 0x17FFC98B398FAF61ULL>& name = ThreadLocalName<0x17FFC98B398FAF61ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x17FFC98B398FAF61ULL>& name = OBFUSCATE_DECRYPT_NAME(0x17FFC98B398FAF61ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1063,7 +1056,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xFC', '\xEF', '\xBA', '\x5E', '\x3E', '\x5E', '\xE6', '\x5E', '\xDD', '\xD1', '\xA6', '\x6F', '\x2C', '\x4E', '\xE8', '\x56',
|
||||
'\xCB', '\xF0', '\xB8', '\x4D', '\x77', '\x17', '\xC0', '\x41', '\xDA', '\xDC', '\xAB', '\x5A', '\x04', '\x43', '\xF0', '\x47',
|
||||
'\xDE', '\xD3', '\xBC', '\x5A', '\x65', '\x04', '\x83'};
|
||||
EncryptedName<sizeof(nameSource), 0x33832D4D3FDFBDBFULL>& name = ThreadLocalName<0x33832D4D3FDFBDBFULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x33832D4D3FDFBDBFULL>& name = OBFUSCATE_DECRYPT_NAME(0x33832D4D3FDFBDBFULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1071,7 +1064,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
if (!CreateEffectMgr()) {
|
||||
const std::array nameSource = {'\xB2', '\x86', '\x8F', '\xDB', '\xC8', '\x6E', '\x01', '\x30', '\x96', '\xB1', '\xD3', '\x87', '\xEE', '\x7F', '\x10', '\x1C',
|
||||
'\x85', '\xA6', '\xA0', '\xD3', '\xDE', '\x79', '\x14', '\x13', '\x92', '\xA6', '\xC1', '\x94', '\xAD'};
|
||||
EncryptedName<sizeof(nameSource), 0x7D750DADBDE9C3F1ULL>& name = ThreadLocalName<0x7D750DADBDE9C3F1ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x7D750DADBDE9C3F1ULL>& name = OBFUSCATE_DECRYPT_NAME(0x7D750DADBDE9C3F1ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1079,7 +1072,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xAA', '\x96', '\x5B', '\x61', '\x50', '\x4A', '\x7F', '\xA8', '\x8C', '\xBE', '\x52', '\x75', '\x4C', '\x64', '\x6C', '\x97',
|
||||
'\xD3', '\xE9', '\x7E', '\x75', '\x50', '\x48', '\x7F', '\x80', '\xA0', '\xBD', '\x4E', '\x73', '\x54', '\x47', '\x68', '\x80',
|
||||
'\xC1', '\xFA', '\x3D'};
|
||||
EncryptedName<sizeof(nameSource), 0xE50B2935073DD3E9ULL>& name = ThreadLocalName<0xE50B2935073DD3E9ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xE50B2935073DD3E9ULL>& name = OBFUSCATE_DECRYPT_NAME(0xE50B2935073DD3E9ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1087,7 +1080,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xEC', '\x0A', '\x45', '\x97', '\xAD', '\x6C', '\x02', '\x4A', '\xCA', '\x3A', '\x4E', '\xAE', '\xB8', '\x67', '\x69', '\x05',
|
||||
'\xEC', '\x3D', '\x4E', '\x82', '\xAB', '\x70', '\x1A', '\x51', '\xDC', '\x3B', '\x4A', '\x8D', '\xBC', '\x70', '\x7B', '\x16',
|
||||
'\xAF'};
|
||||
EncryptedName<sizeof(nameSource), 0x3F5315DFE32B4FAFULL>& name = ThreadLocalName<0x3F5315DFE32B4FAFULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x3F5315DFE32B4FAFULL>& name = OBFUSCATE_DECRYPT_NAME(0x3F5315DFE32B4FAFULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1095,7 +1088,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xD6', '\xA9', '\x78', '\xDE', '\x34', '\x36', '\xF6', '\x59', '\xF0', '\x99', '\x64', '\xDF', '\x34', '\x17', '\xAF', '\x0B',
|
||||
'\xD6', '\x8F', '\x74', '\xD2', '\x25', '\x00', '\xDC', '\x5F', '\xE6', '\x89', '\x70', '\xDD', '\x32', '\x00', '\xBD', '\x18',
|
||||
'\x95'};
|
||||
EncryptedName<sizeof(nameSource), 0x31956551B311FD95ULL>& name = ThreadLocalName<0x31956551B311FD95ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x31956551B311FD95ULL>& name = OBFUSCATE_DECRYPT_NAME(0x31956551B311FD95ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1103,25 +1096,25 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xD2', '\x96', '\xF4', '\x33', '\x00', '\xE2', '\x52', '\x4C', '\xE3', '\xA0', '\xD8', '\x2C', '\x02', '\xE3', '\x07', '\x03',
|
||||
'\xD2', '\xB1', '\xD8', '\x00', '\x11', '\xF4', '\x74', '\x57', '\xE2', '\xB7', '\xDC', '\x0F', '\x06', '\xF4', '\x15', '\x10',
|
||||
'\x91'};
|
||||
EncryptedName<sizeof(nameSource), 0x393D916561BDC391ULL>& name = ThreadLocalName<0x393D916561BDC391ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x393D916561BDC391ULL>& name = OBFUSCATE_DECRYPT_NAME(0x393D916561BDC391ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
CTownInfoMgr::Create();
|
||||
if (!g_townInfoMgr->LoadScript()) {
|
||||
const std::array titleSource = {'\x9C', '\x4B', '\x61', '\x16', '\xB9', '\x83'};
|
||||
EncryptedName<sizeof(titleSource), 0xFF7D83CB791339D9ULL>& title = ThreadLocalName<0xFF7D83CB791339D9ULL>(titleSource);
|
||||
EncryptedName<sizeof(titleSource), 0xFF7D83CB791339D9ULL>& title = OBFUSCATE_DECRYPT_NAME(0xFF7D83CB791339D9ULL, titleSource);
|
||||
const char* caption = title.Text();
|
||||
const std::array textSource = {'\x41', '\xFC', '\xC4', '\xAF', '\xAE', '\x2D', '\x37', '\x82', '\x35', '\xF5', '\xDA', '\xAD', '\x82', '\x63', '\x18', '\x83',
|
||||
'\x7C', '\xE7', '\xB3'};
|
||||
EncryptedName<sizeof(textSource), 0xED5143E7C1B39315ULL>& text = ThreadLocalName<0xED5143E7C1B39315ULL>(textSource);
|
||||
EncryptedName<sizeof(textSource), 0xED5143E7C1B39315ULL>& text = OBFUSCATE_DECRYPT_NAME(0xED5143E7C1B39315ULL, textSource);
|
||||
MessageBoxA(nullptr, text.Text(), caption, MB_OK);
|
||||
}
|
||||
|
||||
if (!CreateCooldownOwner()) {
|
||||
const std::array nameSource = {'\x2C', '\xEE', '\x4E', '\x86', '\x53', '\x73', '\x50', '\xDA', '\x0A', '\xDF', '\x6C', '\x8E', '\x4D', '\x3D', '\x03', '\xF4',
|
||||
'\x1D', '\xC8', '\x40', '\x9D', '\x5A', '\x4E', '\x57', '\xC4', '\x1B', '\xCC', '\x4F', '\x8A', '\x5A', '\x2F', '\x10', '\xB7'};
|
||||
EncryptedName<sizeof(nameSource), 0xB739073FE921AD6FULL>& name = ThreadLocalName<0xB739073FE921AD6FULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xB739073FE921AD6FULL>& name = OBFUSCATE_DECRYPT_NAME(0xB739073FE921AD6FULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1129,7 +1122,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\x48', '\xE7', '\xEC', '\x7B', '\x6C', '\xC0', '\xC8', '\xB6', '\x6E', '\xC6', '\xFD', '\x58', '\x6E', '\xC5', '\xA3', '\xF9',
|
||||
'\x48', '\xC7', '\xEC', '\x74', '\x7D', '\xD2', '\xD0', '\xAD', '\x78', '\xC1', '\xE8', '\x7B', '\x6A', '\xD2', '\xB1', '\xEA',
|
||||
'\x0B'};
|
||||
EncryptedName<sizeof(nameSource), 0xC399B7091589B50BULL>& name = ThreadLocalName<0xC399B7091589B50BULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xC399B7091589B50BULL>& name = OBFUSCATE_DECRYPT_NAME(0xC399B7091589B50BULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1137,18 +1130,18 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
if (!CClanInfo::Create()) {
|
||||
const std::array nameSource = {'\x44', '\xF8', '\x85', '\x2C', '\x97', '\x04', '\x33', '\xF3', '\x68', '\xF6', '\x8E', '\x3F', '\xC3', '\x77', '\x1E', '\xE7',
|
||||
'\x62', '\xDA', '\x9D', '\x28', '\xB0', '\x23', '\x2E', '\xE1', '\x66', '\xD5', '\x8A', '\x28', '\xD1', '\x64', '\x5D'};
|
||||
EncryptedName<sizeof(nameSource), 0x955D4DF94DE9BB07ULL>& name = ThreadLocalName<0x955D4DF94DE9BB07ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x955D4DF94DE9BB07ULL>& name = OBFUSCATE_DECRYPT_NAME(0x955D4DF94DE9BB07ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
CChampionMonsterMgr::Create();
|
||||
if (!g_championMonsterMgr->Load()) {
|
||||
const std::array titleSource = {'\xB0', '\xF5', '\x8F', '\x92', '\x5D', '\x3D'};
|
||||
EncryptedName<sizeof(titleSource), 0x936F3D2FFDFD87F5ULL>& title = ThreadLocalName<0x936F3D2FFDFD87F5ULL>(titleSource);
|
||||
EncryptedName<sizeof(titleSource), 0x936F3D2FFDFD87F5ULL>& title = OBFUSCATE_DECRYPT_NAME(0x936F3D2FFDFD87F5ULL, titleSource);
|
||||
const char* caption = title.Text();
|
||||
const std::array textSource = {'\x0C', '\x23', '\xD2', '\xE2', '\x5D', '\x7C', '\x2E', '\xE9', '\x02', '\x24', '\xDD', '\xFC', '\x59', '\x70', '\x33', '\xA7',
|
||||
'\x29', '\x22', '\xDF', '\xEA', '\x0D', '\x5C', '\x2F', '\xEE', '\x3B', '\x4B'};
|
||||
EncryptedName<sizeof(textSource), 0x8741152D8FB34B4FULL>& text = ThreadLocalName<0x8741152D8FB34B4FULL>(textSource);
|
||||
EncryptedName<sizeof(textSource), 0x8741152D8FB34B4FULL>& text = OBFUSCATE_DECRYPT_NAME(0x8741152D8FB34B4FULL, textSource);
|
||||
MessageBoxA(nullptr, text.Text(), caption, MB_OK);
|
||||
}
|
||||
|
||||
|
|
@ -1156,7 +1149,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\x9C', '\x0A', '\xCC', '\x17', '\x4F', '\x0B', '\x5C', '\x5D', '\xBA', '\x35', '\xD9', '\x1E', '\x52', '\x1E', '\x41', '\x17',
|
||||
'\xE5', '\x04', '\xDF', '\x02', '\x7E', '\x0D', '\x56', '\x64', '\xB1', '\x34', '\xD9', '\x06', '\x71', '\x1A', '\x56', '\x05',
|
||||
'\xF6', '\x47'};
|
||||
EncryptedName<sizeof(nameSource), 0x2D33791F67AD47DFULL>& name = ThreadLocalName<0x2D33791F67AD47DFULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x2D33791F67AD47DFULL>& name = OBFUSCATE_DECRYPT_NAME(0x2D33791F67AD47DFULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1165,21 +1158,21 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xE8', '\x1D', '\xF0', '\xC7', '\xE0', '\x57', '\x42', '\x7E', '\xD8', '\x3B', '\xFA', '\xCE', '\xC8', '\x48', '\x63', '\x3D',
|
||||
'\x91', '\x0C', '\xED', '\xC6', '\xE4', '\x5B', '\x74', '\x4E', '\xC5', '\x3C', '\xEB', '\xC2', '\xEB', '\x4C', '\x74', '\x2F',
|
||||
'\x82', '\x4F'};
|
||||
EncryptedName<sizeof(nameSource), 0x07112F85A39F4FABULL>& name = ThreadLocalName<0x07112F85A39F4FABULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x07112F85A39F4FABULL>& name = OBFUSCATE_DECRYPT_NAME(0x07112F85A39F4FABULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
if (!RouletteMgr::Create()) {
|
||||
const std::array nameSource = {'\x14', '\xA3', '\xDA', '\xBE', '\x6F', '\x9D', '\x86', '\x31', '\x23', '\x94', '\xF8', '\xAC', '\x71', '\xCB', '\xD9', '\x06',
|
||||
'\x25', '\x94', '\xD4', '\xBF', '\x66', '\xB8', '\x8D', '\x36', '\x23', '\x90', '\xDB', '\xA8', '\x66', '\xD9', '\xCA', '\x45'};
|
||||
EncryptedName<sizeof(nameSource), 0x45E3F103CBB5F157ULL>& name = ThreadLocalName<0x45E3F103CBB5F157ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x45E3F103CBB5F157ULL>& name = OBFUSCATE_DECRYPT_NAME(0x45E3F103CBB5F157ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
if (!CCURLMgr::Initialize()) {
|
||||
const std::array nameSource = {'\x20', '\x7A', '\x28', '\xF3', '\x15', '\xF8', '\xF8', '\xB1', '\x59', '\x03', '\x3E', '\xD3', '\x3C', '\xD4', '\xEB', '\xA6',
|
||||
'\x2A', '\x57', '\x0E', '\xD5', '\x38', '\xDB', '\xFC', '\xA6', '\x4B', '\x10', '\x7D'};
|
||||
EncryptedName<sizeof(nameSource), 0xC39FB559A17D3963ULL>& name = ThreadLocalName<0xC39FB559A17D3963ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xC39FB559A17D3963ULL>& name = OBFUSCATE_DECRYPT_NAME(0xC39FB559A17D3963ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1187,7 +1180,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xEC', '\xE0', '\xA6', '\x54', '\x78', '\x1C', '\xD9', '\x05', '\xE3', '\xC8', '\xAB', '\x5C', '\x72', '\x0D', '\xE2', '\x02',
|
||||
'\xCA', '\xD3', '\x81', '\x56', '\x63', '\x08', '\xFA', '\x16', '\xDD', '\x9B', '\xFF', '\x74', '\x65', '\x0C', '\xD6', '\x05',
|
||||
'\xCA', '\xE8', '\xAB', '\x44', '\x63', '\x08', '\xD9', '\x12', '\xCA', '\x89', '\xEC', '\x37'};
|
||||
EncryptedName<sizeof(nameSource), 0x71B7691737C5A1AFULL>& name = ThreadLocalName<0x71B7691737C5A1AFULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x71B7691737C5A1AFULL>& name = OBFUSCATE_DECRYPT_NAME(0x71B7691737C5A1AFULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1195,21 +1188,21 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\x66', '\xD2', '\x6F', '\xC2', '\x93', '\x60', '\x50', '\x1F', '\x40', '\xE3', '\x4B', '\xCA', '\x8F', '\x6A', '\x56', '\x0F',
|
||||
'\x70', '\xE2', '\x62', '\xD1', '\xA5', '\x60', '\x47', '\x0A', '\x68', '\xF6', '\x75', '\x99', '\xDB', '\x42', '\x41', '\x0E',
|
||||
'\x44', '\xE5', '\x62', '\xEA', '\x8F', '\x72', '\x47', '\x0A', '\x4B', '\xF2', '\x62', '\x8B', '\xC8', '\x01'};
|
||||
EncryptedName<sizeof(nameSource), 0x6B3301E1A3079125ULL>& name = ThreadLocalName<0x6B3301E1A3079125ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x6B3301E1A3079125ULL>& name = OBFUSCATE_DECRYPT_NAME(0x6B3301E1A3079125ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
if (!NMessageMgr::Initialize()) {
|
||||
const std::array nameSource = {'\xC7', '\x70', '\x08', '\x96', '\xD4', '\x60', '\x40', '\x4A', '\xC4', '\x5A', '\x1F', '\xDF', '\x9D', '\x42', '\x55', '\x4A',
|
||||
'\xE8', '\x49', '\x08', '\xAC', '\xC9', '\x72', '\x53', '\x4E', '\xE7', '\x5E', '\x08', '\xCD', '\x8E', '\x01'};
|
||||
EncryptedName<sizeof(nameSource), 0x2F2701A7E56D3D89ULL>& name = ThreadLocalName<0x2F2701A7E56D3D89ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x2F2701A7E56D3D89ULL>& name = OBFUSCATE_DECRYPT_NAME(0x2F2701A7E56D3D89ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
if (!CAsyncWorkMgr::Initialize(2)) {
|
||||
const std::array nameSource = {'\xFE', '\xDC', '\x48', '\x9E', '\x63', '\xE0', '\xDE', '\x16', '\xCF', '\xF6', '\x76', '\x80', '\x7F', '\xB9', '\xB3', '\x3A',
|
||||
'\xCF', '\xF8', '\x5A', '\x93', '\x68', '\xCA', '\xE7', '\x0A', '\xC9', '\xFC', '\x55', '\x84', '\x68', '\xAB', '\xA0', '\x79'};
|
||||
EncryptedName<sizeof(nameSource), 0x7989830DE73B9DBDULL>& name = ThreadLocalName<0x7989830DE73B9DBDULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x7989830DE73B9DBDULL>& name = OBFUSCATE_DECRYPT_NAME(0x7989830DE73B9DBDULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1217,7 +1210,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\x22', '\x65', '\xD6', '\xB1', '\xE6', '\xB3', '\xCE', '\xD8', '\x28', '\x4A', '\xD6', '\xBC', '\xE9', '\xBE', '\xFA', '\xD2',
|
||||
'\x19', '\x60', '\xE8', '\xA2', '\xF5', '\xF5', '\x84', '\x90', '\x55', '\x58', '\xD1', '\xA4', '\xF5', '\xA9', '\x85', '\x94',
|
||||
'\x6B'};
|
||||
EncryptedName<sizeof(nameSource), 0xBDADDD87C5A50B6BULL>& name = ThreadLocalName<0xBDADDD87C5A50B6BULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xBDADDD87C5A50B6BULL>& name = OBFUSCATE_DECRYPT_NAME(0xBDADDD87C5A50B6BULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1225,7 +1218,7 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\x4E', '\x0C', '\x01', '\xEA', '\xC8', '\x61', '\xF8', '\xFB', '\x4F', '\x37', '\x06', '\xE0', '\xD0', '\x5C', '\xFA', '\xFB',
|
||||
'\x37', '\x61', '\x2A', '\xF1', '\xDE', '\x70', '\xE9', '\xEC', '\x44', '\x35', '\x1A', '\xF7', '\xDA', '\x7F', '\xFE', '\xEC',
|
||||
'\x25', '\x72', '\x69'};
|
||||
EncryptedName<sizeof(nameSource), 0x899D11BB83695B0DULL>& name = ThreadLocalName<0x899D11BB83695B0DULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x899D11BB83695B0DULL>& name = OBFUSCATE_DECRYPT_NAME(0x899D11BB83695B0DULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1233,14 +1226,14 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xB6', '\x75', '\x3F', '\x88', '\xAE', '\x40', '\xF5', '\x65', '\x94', '\x48', '\x36', '\xAD', '\xBE', '\x46', '\xF3', '\x42',
|
||||
'\x9A', '\x4B', '\x32', '\x9B', '\xAE', '\x1F', '\xBD', '\x68', '\x87', '\x40', '\x32', '\x9D', '\xB2', '\x6C', '\xE9', '\x58',
|
||||
'\x81', '\x44', '\x3D', '\x8A', '\xB2', '\x0D', '\xAE', '\x2B'};
|
||||
EncryptedName<sizeof(nameSource), 0x2B8725D7E95325F5ULL>& name = ThreadLocalName<0x2B8725D7E95325F5ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x2B8725D7E95325F5ULL>& name = OBFUSCATE_DECRYPT_NAME(0x2B8725D7E95325F5ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
if (!CGuildMgr::Create()) {
|
||||
const std::array nameSource = {'\x92', '\x26', '\x84', '\xE0', '\x03', '\x35', '\xA8', '\xB4', '\xA3', '\x5B', '\xCB', '\xCA', '\x1D', '\x34', '\x84', '\xA7',
|
||||
'\xB4', '\x28', '\x9F', '\xFA', '\x1B', '\x30', '\x8B', '\xB0', '\xB4', '\x49', '\xD8', '\x89'};
|
||||
EncryptedName<sizeof(nameSource), 0xD3E5516F89F161D1ULL>& name = ThreadLocalName<0xD3E5516F89F161D1ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xD3E5516F89F161D1ULL>& name = OBFUSCATE_DECRYPT_NAME(0xD3E5516F89F161D1ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1248,21 +1241,21 @@ std::pair<bool, std::string> InitializeManagers() {
|
|||
const std::array nameSource = {'\xCE', '\x56', '\x12', '\x71', '\x0D', '\x80', '\x58', '\xB1', '\xEC', '\x67', '\x1E', '\x5E', '\x06', '\x97', '\x0F', '\xCF',
|
||||
'\xCE', '\x61', '\x1A', '\x72', '\x15', '\x80', '\x7C', '\x9B', '\xFE', '\x67', '\x1E', '\x7D', '\x02', '\x80', '\x1D', '\xDC',
|
||||
'\x8D'};
|
||||
EncryptedName<sizeof(nameSource), 0xF535E561137F138DULL>& name = ThreadLocalName<0xF535E561137F138DULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xF535E561137F138DULL>& name = OBFUSCATE_DECRYPT_NAME(0xF535E561137F138DULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
if (!CreateNavigationLinkParser()) {
|
||||
const std::array nameSource = {'\x9C', '\xCF', '\x5E', '\x9E', '\xC8', '\x7E', '\x35', '\x9D', '\xE5', '\xD8', '\x4D', '\x9C', '\xE4', '\x6D', '\x22', '\xEE',
|
||||
'\xB1', '\xE8', '\x4B', '\x98', '\xEB', '\x7A', '\x22', '\x8F', '\xF6', '\x9B'};
|
||||
EncryptedName<sizeof(nameSource), 0xA7471985F93F9BDFULL>& name = ThreadLocalName<0xA7471985F93F9BDFULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0xA7471985F93F9BDFULL>& name = OBFUSCATE_DECRYPT_NAME(0xA7471985F93F9BDFULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
if (!CreateSignBoardMgr()) {
|
||||
const std::array nameSource = {'\x14', '\xBC', '\xB8', '\xD2', '\xC5', '\x3D', '\x92', '\x3E', '\x25', '\x8B', '\x9C', '\xD2', '\xD9', '\x45', '\xC7', '\x1C',
|
||||
'\x25', '\x8A', '\xB0', '\xC1', '\xCE', '\x36', '\x93', '\x2C', '\x23', '\x8E', '\xBF', '\xD6', '\xCE', '\x57', '\xD4', '\x5F'};
|
||||
EncryptedName<sizeof(nameSource), 0x5FFD7FABB5D1EF57ULL>& name = ThreadLocalName<0x5FFD7FABB5D1EF57ULL>(nameSource);
|
||||
EncryptedName<sizeof(nameSource), 0x5FFD7FABB5D1EF57ULL>& name = OBFUSCATE_DECRYPT_NAME(0x5FFD7FABB5D1EF57ULL, nameSource);
|
||||
return std::pair<bool, std::string>(false, std::string(name.Text()));
|
||||
}
|
||||
|
||||
|
|
@ -1322,29 +1315,29 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
if (!InitUnhandledExceptionHandler(reinterpret_cast<int (*)()>(&IgnoreNull))) {
|
||||
const std::array failureSource = {'\xB6', '\xEA', '\xAF', '\x66', '\xCF', '\x3A', '\x50', '\x9B', '\xFB', '\xEA', '\xAF', '\x7C', '\xDF', '\x2E', '\x51', '\x87',
|
||||
'\xFB', '\xE5', '\xA0', '\x66', '\xC7', '\x4F'};
|
||||
EncryptedName<sizeof(failureSource), 0xEB3D4FAB0FC183DBULL>& failure = ThreadLocalName<0xEB3D4FAB0FC183DBULL>(failureSource);
|
||||
EncryptedName<sizeof(failureSource), 0xEB3D4FAB0FC183DBULL>& failure = OBFUSCATE_DECRYPT_NAME(0xEB3D4FAB0FC183DBULL, failureSource);
|
||||
ShowErrorDialog(failure.Text(), MB_OK);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const std::array replaySource = {'\x1B', '\x9A', '\xA5', '\x93', '\xB0', '\x3A', '\xBF'};
|
||||
EncryptedName<sizeof(replaySource), 0xFFBF43D1FFD5FF49ULL>& replay = ThreadLocalName<0xFFBF43D1FFD5FF49ULL>(replaySource);
|
||||
EncryptedName<sizeof(replaySource), 0xFFBF43D1FFD5FF49ULL>& replay = OBFUSCATE_DECRYPT_NAME(0xFFBF43D1FFD5FF49ULL, replaySource);
|
||||
g_replayMode = std::strstr(commandLine, replay.Text()) != nullptr;
|
||||
Replay::Instance().SetState(1);
|
||||
|
||||
const std::array qmSource = {'\xD6', '\x3C', '\x6E', '\x48', '\x07'};
|
||||
EncryptedName<sizeof(qmSource), 0x7DB1050779034DE7ULL>& qm = ThreadLocalName<0x7DB1050779034DE7ULL>(qmSource);
|
||||
EncryptedName<sizeof(qmSource), 0x7DB1050779034DE7ULL>& qm = OBFUSCATE_DECRYPT_NAME(0x7DB1050779034DE7ULL, qmSource);
|
||||
if (std::strstr(commandLine, qm.Text())) {
|
||||
const char* server;
|
||||
const std::array sakSource = {'\x80', '\xE4', '\x42', '\x80', '\x2C', '\x3B'};
|
||||
EncryptedName<sizeof(sakSource), 0x5D6B3B1DEB2397B1ULL>& sak = ThreadLocalName<0x5D6B3B1DEB2397B1ULL>(sakSource);
|
||||
EncryptedName<sizeof(sakSource), 0x5D6B3B1DEB2397B1ULL>& sak = OBFUSCATE_DECRYPT_NAME(0x5D6B3B1DEB2397B1ULL, sakSource);
|
||||
if (std::strstr(commandLine, sak.Text())) {
|
||||
const std::array sakraySource = {'\x74', '\x94', '\xE4', '\x5E', '\xD6', '\x11', '\x84', '\x06', '\x25'};
|
||||
EncryptedName<sizeof(sakraySource), 0x7FE563BD3FB7F925ULL>& sakray = ThreadLocalName<0x7FE563BD3FB7F925ULL>(sakraySource);
|
||||
EncryptedName<sizeof(sakraySource), 0x7FE563BD3FB7F925ULL>& sakray = OBFUSCATE_DECRYPT_NAME(0x7FE563BD3FB7F925ULL, sakraySource);
|
||||
server = sakray.Text();
|
||||
} else {
|
||||
const std::array devSource = {'\xCD', '\xBA', '\xAB', '\x5B'};
|
||||
EncryptedName<sizeof(devSource), 0x8B3FA35B5BDDDF89ULL>& dev = ThreadLocalName<0x8B3FA35B5BDDDF89ULL>(devSource);
|
||||
EncryptedName<sizeof(devSource), 0x8B3FA35B5BDDDF89ULL>& dev = OBFUSCATE_DECRYPT_NAME(0x8B3FA35B5BDDDF89ULL, devSource);
|
||||
server = dev.Text();
|
||||
}
|
||||
|
||||
|
|
@ -1352,16 +1345,16 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
}
|
||||
|
||||
const std::array rocSource = {'\x8E', '\xF7', '\x48', '\x1E', '\x62', '\x23'};
|
||||
EncryptedName<sizeof(rocSource), 0xE3FB23537D2785BFULL>& roc = ThreadLocalName<0xE3FB23537D2785BFULL>(rocSource);
|
||||
EncryptedName<sizeof(rocSource), 0xE3FB23537D2785BFULL>& roc = OBFUSCATE_DECRYPT_NAME(0xE3FB23537D2785BFULL, rocSource);
|
||||
g_session.SetOption(18, std::strstr(commandLine, roc.Text()) != nullptr, 0);
|
||||
|
||||
const std::array stoveSandboxSource = {'\xCC', '\x24', '\x61', '\x32', '\x61', '\xE4', '\x84', '\x6C', '\x82', '\x39', '\x71', '\x3F', '\x78', '\xF9', '\xDB'};
|
||||
EncryptedName<sizeof(stoveSandboxSource), 0x1FDB81175D1557E3ULL>& stoveSandbox = ThreadLocalName<0x1FDB81175D1557E3ULL>(stoveSandboxSource);
|
||||
EncryptedName<sizeof(stoveSandboxSource), 0x1FDB81175D1557E3ULL>& stoveSandbox = OBFUSCATE_DECRYPT_NAME(0x1FDB81175D1557E3ULL, stoveSandboxSource);
|
||||
if (std::strstr(commandLine, stoveSandbox.Text())) {
|
||||
g_launchPassCommandLine = true;
|
||||
} else {
|
||||
const std::array stoveLiveSource = {'\xF8', '\x34', '\x89', '\x0C', '\x7B', '\x5C', '\x74', '\x1F', '\xBE', '\x31', '\x98', '\x63'};
|
||||
EncryptedName<sizeof(stoveLiveSource), 0x732B390D63FD47D7ULL>& stoveLive = ThreadLocalName<0x732B390D63FD47D7ULL>(stoveLiveSource);
|
||||
EncryptedName<sizeof(stoveLiveSource), 0x732B390D63FD47D7ULL>& stoveLive = OBFUSCATE_DECRYPT_NAME(0x732B390D63FD47D7ULL, stoveLiveSource);
|
||||
if (std::strstr(commandLine, stoveLive.Text())) {
|
||||
g_launchPassCommandLine = true;
|
||||
}
|
||||
|
|
@ -1369,18 +1362,18 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
|
||||
const std::array manifestSource = {'\xFC', '\x96', '\x2C', '\xAF', '\x90', '\x05', '\xC2', '\xD3', '\xFE', '\x8D', '\x20', '\x92', '\x94', '\x0A', '\xC9', '\xDE',
|
||||
'\xF9', '\x9C', '\x32', '\xB9', '\xF9'};
|
||||
EncryptedName<sizeof(manifestSource), 0xB7A76BF9CD41F99FULL>& manifest = ThreadLocalName<0xB7A76BF9CD41F99FULL>(manifestSource);
|
||||
EncryptedName<sizeof(manifestSource), 0xB7A76BF9CD41F99FULL>& manifest = OBFUSCATE_DECRYPT_NAME(0xB7A76BF9CD41F99FULL, manifestSource);
|
||||
WIN32_FIND_DATAA manifestData;
|
||||
HANDLE manifestFind = FindFirstFileA(manifest.Text(), &manifestData);
|
||||
if ((g_launchPassCommandLine && manifestFind == INVALID_HANDLE_VALUE) || (!g_launchPassCommandLine && manifestFind != INVALID_HANDLE_VALUE)) {
|
||||
FindClose(manifestFind);
|
||||
const std::array captionSource = {'\xE2', '\x5D', '\x16', '\x35', '\xBE', '\x29', '\xC0', '\x03', '\xE3', '\x46', '\x0B', '\x43'};
|
||||
EncryptedName<sizeof(captionSource), 0x71A509DB43792991ULL>& caption = ThreadLocalName<0x71A509DB43792991ULL>(captionSource);
|
||||
EncryptedName<sizeof(captionSource), 0x71A509DB43792991ULL>& caption = OBFUSCATE_DECRYPT_NAME(0x71A509DB43792991ULL, captionSource);
|
||||
const char* title = caption.Text();
|
||||
const std::array messageSource = {'\x2E', '\x27', '\xE0', '\xD7', '\x9A', '\xCD', '\xAC', '\x71', '\xCB', '\xA0', '\x4F', '\x6D', '\x41', '\x1D', '\xAF', '\x73',
|
||||
'\xC5', '\xF5', '\xAF', '\x64', '\x14', '\x2A', '\xB1', '\xFD', '\xC0', '\x94', '\x48', '\x41', '\x38', '\x35', '\x49', '\x1C',
|
||||
'\xAB', '\xEF', '\x33', '\x1E', '\x1B', '\xED'};
|
||||
EncryptedName<sizeof(messageSource), 0xDD69EDFFA18F537DULL>& message = ThreadLocalName<0xDD69EDFFA18F537DULL>(messageSource);
|
||||
EncryptedName<sizeof(messageSource), 0xDD69EDFFA18F537DULL>& message = OBFUSCATE_DECRYPT_NAME(0xDD69EDFFA18F537DULL, messageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(message.Text()).c_str(), title, MB_OK);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1388,7 +1381,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
FindClose(manifestFind);
|
||||
if (!g_launchPassCommandLine) {
|
||||
const std::array accountMarkerSource = {'\xA4', '\xAF', '\x59', '\x79'};
|
||||
EncryptedName<sizeof(accountMarkerSource), 0xB3CF9BEB7963DB89ULL>& accountMarker = ThreadLocalName<0xB3CF9BEB7963DB89ULL>(accountMarkerSource);
|
||||
EncryptedName<sizeof(accountMarkerSource), 0xB3CF9BEB7963DB89ULL>& accountMarker = OBFUSCATE_DECRYPT_NAME(0xB3CF9BEB7963DB89ULL, accountMarkerSource);
|
||||
if (std::strstr(commandLine, accountMarker.Text()) && !g_replayMode) {
|
||||
g_session.m_launchAccountEnabled = true;
|
||||
char* marker = std::strstr(commandLine, "-t:");
|
||||
|
|
@ -1415,12 +1408,12 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
g_launchServerName[length > 23 ? 23 : length] = 0;
|
||||
|
||||
const std::array nonPaySource = {'\x3D', '\x4E', '\x89', '\x17', '\x4A', '\x00', '\xED', '\xEA', '\x14', '\x21'};
|
||||
EncryptedName<sizeof(nonPaySource), 0x8BBF792B47E72173ULL>& nonPay = ThreadLocalName<0x8BBF792B47E72173ULL>(nonPaySource);
|
||||
EncryptedName<sizeof(nonPaySource), 0x8BBF792B47E72173ULL>& nonPay = OBFUSCATE_DECRYPT_NAME(0x8BBF792B47E72173ULL, nonPaySource);
|
||||
if (std::strstr(g_launchServerName, nonPay.Text())) {
|
||||
g_launchServerKind = 2;
|
||||
} else {
|
||||
const std::array eventSource = {'\x3C', '\x81', '\x70', '\x5B', '\xD9', '\x51'};
|
||||
EncryptedName<sizeof(eventSource), 0x9B9D51AD3515F779ULL>& event = ThreadLocalName<0x9B9D51AD3515F779ULL>(eventSource);
|
||||
EncryptedName<sizeof(eventSource), 0x9B9D51AD3515F779ULL>& event = OBFUSCATE_DECRYPT_NAME(0x9B9D51AD3515F779ULL, eventSource);
|
||||
if (std::strstr(g_launchServerName, event.Text())) {
|
||||
g_launchServerKind = 2;
|
||||
}
|
||||
|
|
@ -1428,18 +1421,18 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
} else {
|
||||
const std::array secondManifestSource = {'\x34', '\x90', '\x80', '\x2D', '\xC6', '\xDB', '\xB2', '\xD1', '\x36', '\x8B', '\x8C', '\x10', '\xC2', '\xD4', '\xB9', '\xDC',
|
||||
'\x31', '\x9A', '\x9E', '\x3B', '\xAF'};
|
||||
EncryptedName<sizeof(secondManifestSource), 0xB5D7B5AF4FEDFF57ULL>& secondManifest = ThreadLocalName<0xB5D7B5AF4FEDFF57ULL>(secondManifestSource);
|
||||
EncryptedName<sizeof(secondManifestSource), 0xB5D7B5AF4FEDFF57ULL>& secondManifest = OBFUSCATE_DECRYPT_NAME(0xB5D7B5AF4FEDFF57ULL, secondManifestSource);
|
||||
WIN32_FIND_DATAA secondManifestData;
|
||||
HANDLE secondManifestFind = FindFirstFileA(secondManifest.Text(), &secondManifestData);
|
||||
if (secondManifestFind != INVALID_HANDLE_VALUE) {
|
||||
FindClose(secondManifestFind);
|
||||
const std::array secondCaptionSource = {'\xC4', '\x47', '\x4A', '\x7F', '\xDE', '\x15', '\xE0', '\x71', '\xC5', '\x5C', '\x57', '\x09'};
|
||||
EncryptedName<sizeof(secondCaptionSource), 0x038535BB092533B7ULL>& secondCaption = ThreadLocalName<0x038535BB092533B7ULL>(secondCaptionSource);
|
||||
EncryptedName<sizeof(secondCaptionSource), 0x038535BB092533B7ULL>& secondCaption = OBFUSCATE_DECRYPT_NAME(0x038535BB092533B7ULL, secondCaptionSource);
|
||||
const char* title = secondCaption.Text();
|
||||
const std::array secondMessageSource = {'\x80', '\x03', '\x88', '\x1F', '\x32', '\xE7', '\xEE', '\x57', '\x65', '\x84', '\x27', '\xA5', '\xE9', '\x37', '\xED', '\x55',
|
||||
'\x6B', '\xD1', '\xC7', '\xAC', '\xBC', '\x00', '\xF3', '\xDB', '\x6E', '\xB0', '\x20', '\x89', '\x90', '\x1F', '\x0B', '\x3A',
|
||||
'\x05', '\xCB', '\x5B', '\xD6', '\xB3', '\xC7'};
|
||||
EncryptedName<sizeof(secondMessageSource), 0xFB2BC75769E777D3ULL>& secondMessage = ThreadLocalName<0xFB2BC75769E777D3ULL>(secondMessageSource);
|
||||
EncryptedName<sizeof(secondMessageSource), 0xFB2BC75769E777D3ULL>& secondMessage = OBFUSCATE_DECRYPT_NAME(0xFB2BC75769E777D3ULL, secondMessageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(secondMessage.Text()).c_str(), title, MB_OK);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1456,7 +1449,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
}
|
||||
|
||||
const std::array ragSource = {'\x32', '\x47', '\xF8', '\xD2', '\x82', '\x77'};
|
||||
EncryptedName<sizeof(ragSource), 0x6BC977B3B5993503ULL>& rag = ThreadLocalName<0x6BC977B3B5993503ULL>(ragSource);
|
||||
EncryptedName<sizeof(ragSource), 0x6BC977B3B5993503ULL>& rag = OBFUSCATE_DECRYPT_NAME(0x6BC977B3B5993503ULL, ragSource);
|
||||
std::strstr(commandLine, rag.Text());
|
||||
|
||||
{
|
||||
|
|
@ -1469,14 +1462,14 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
}
|
||||
|
||||
const std::array accountSource = {'\x74', '\xFC', '\x46', '\x4E', '\xE8', '\x58', '\x43', '\x73', '\x61', '\x9D'};
|
||||
EncryptedName<sizeof(accountSource), 0x072D2D872D259D5BULL>& account = ThreadLocalName<0x072D2D872D259D5BULL>(accountSource);
|
||||
EncryptedName<sizeof(accountSource), 0x072D2D872D259D5BULL>& account = OBFUSCATE_DECRYPT_NAME(0x072D2D872D259D5BULL, accountSource);
|
||||
account.Text();
|
||||
g_launchFromPc = std::strstr(commandLine, "pc") != nullptr;
|
||||
|
||||
char protection[64];
|
||||
std::memset(protection, 0, sizeof(protection));
|
||||
const std::array dataGrfSource = {'\x3B', '\x18', '\xD5', '\x86', '\xDF', '\xAA', '\x2D', '\xE1', '\x5F'};
|
||||
EncryptedName<sizeof(dataGrfSource), 0x875FCDF1E7A1795FULL>& dataGrf = ThreadLocalName<0x875FCDF1E7A1795FULL>(dataGrfSource);
|
||||
EncryptedName<sizeof(dataGrfSource), 0x875FCDF1E7A1795FULL>& dataGrf = OBFUSCATE_DECRYPT_NAME(0x875FCDF1E7A1795FULL, dataGrfSource);
|
||||
dataGrf.Text();
|
||||
HMODULE kernel = GetModuleHandleA("kernel32.dll");
|
||||
if (kernel) {
|
||||
|
|
@ -1511,10 +1504,10 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
LoadClientInfo(protection);
|
||||
|
||||
const std::array patchSandboxSource = {'\x5A', '\x16', '\x15', '\xB6', '\x3B', '\x6C', '\x80', '\x0A', '\x14', '\x0B', '\x05', '\xBB', '\x22', '\x71', '\xDF'};
|
||||
EncryptedName<sizeof(patchSandboxSource), 0x79DF094DD9616575ULL>& patchSandbox = ThreadLocalName<0x79DF094DD9616575ULL>(patchSandboxSource);
|
||||
EncryptedName<sizeof(patchSandboxSource), 0x79DF094DD9616575ULL>& patchSandbox = OBFUSCATE_DECRYPT_NAME(0x79DF094DD9616575ULL, patchSandboxSource);
|
||||
if (!std::strstr(g_commandLine, patchSandbox.Text())) {
|
||||
const std::array patchLiveSource = {'\x98', '\x12', '\x89', '\xD0', '\x41', '\x48', '\xD0', '\xF1', '\xDE', '\x17', '\x98', '\xBF'};
|
||||
EncryptedName<sizeof(patchLiveSource), 0x9D8F2D37BFFD61B7ULL>& patchLive = ThreadLocalName<0x9D8F2D37BFFD61B7ULL>(patchLiveSource);
|
||||
EncryptedName<sizeof(patchLiveSource), 0x9D8F2D37BFFD61B7ULL>& patchLive = OBFUSCATE_DECRYPT_NAME(0x9D8F2D37BFFD61B7ULL, patchLiveSource);
|
||||
if (!std::strstr(g_commandLine, patchLive.Text()) &&
|
||||
ReplaceClientExecutable(const_cast<char*>(g_clientExeName), g_patcherExeName)) {
|
||||
return 0;
|
||||
|
|
@ -1524,7 +1517,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
g_session.Init();
|
||||
|
||||
const std::array setupSource = {'\x64', '\x98', '\x01', '\x20', '\x45', '\xEF', '\x30', '\x3F', '\x52', '\xFD'};
|
||||
EncryptedName<sizeof(setupSource), 0x4755C1355575FD37ULL>& setup = ThreadLocalName<0x4755C1355575FD37ULL>(setupSource);
|
||||
EncryptedName<sizeof(setupSource), 0x4755C1355575FD37ULL>& setup = OBFUSCATE_DECRYPT_NAME(0x4755C1355575FD37ULL, setupSource);
|
||||
while (ReadSetup() == 0) {
|
||||
if (_access(setup.Text(), 0) == 0) {
|
||||
WaitForSingleObject(StartClientProcess(const_cast<char*>(setup.Text())), INFINITE);
|
||||
|
|
@ -1532,12 +1525,12 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
}
|
||||
|
||||
const std::array saveDataSource = {'\x74', '\xBC', '\x01', '\x06', '\x07', '\x54', '\xBF', '\x70', '\x07'};
|
||||
EncryptedName<sizeof(saveDataSource), 0x11CB35636377DD07ULL>& saveData = ThreadLocalName<0x11CB35636377DD07ULL>(saveDataSource);
|
||||
EncryptedName<sizeof(saveDataSource), 0x11CB35636377DD07ULL>& saveData = OBFUSCATE_DECRYPT_NAME(0x11CB35636377DD07ULL, saveDataSource);
|
||||
WIN32_FIND_DATAA saveDataData;
|
||||
HANDLE saveDataFind = FindFirstFileA(saveData.Text(), &saveDataData);
|
||||
if (saveDataFind == INVALID_HANDLE_VALUE) {
|
||||
const std::array saveDataDirectorySource = {'\x54', '\xF2', '\x09', '\x6A', '\x3F', '\x7E', '\x43', '\x5C', '\x27'};
|
||||
EncryptedName<sizeof(saveDataDirectorySource), 0x3D371F5B0F7F9327ULL>& saveDataDirectory = ThreadLocalName<0x3D371F5B0F7F9327ULL>(saveDataDirectorySource);
|
||||
EncryptedName<sizeof(saveDataDirectorySource), 0x3D371F5B0F7F9327ULL>& saveDataDirectory = OBFUSCATE_DECRYPT_NAME(0x3D371F5B0F7F9327ULL, saveDataDirectorySource);
|
||||
CreateDirectoryA(saveDataDirectory.Text(), nullptr);
|
||||
} else {
|
||||
FindClose(saveDataFind);
|
||||
|
|
@ -1562,7 +1555,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
if (!CSoundMgr::Create()) {
|
||||
const std::array audioFailureSource = {'\x68', '\xBA', '\x4D', '\x6E', '\x8C', '\x09', '\xA4', '\x12', '\x5A', '\xBB', '\x4C', '\x6A', '\xC3', '\x60', '\x99', '\x02',
|
||||
'\x5D', '\xEF', '\x6F', '\x66', '\x8A', '\x45', '\x92', '\x0F', '\x29'};
|
||||
EncryptedName<sizeof(audioFailureSource), 0x6BF729E30729CF29ULL>& audioFailure = ThreadLocalName<0x6BF729E30729CF29ULL>(audioFailureSource);
|
||||
EncryptedName<sizeof(audioFailureSource), 0x6BF729E30729CF29ULL>& audioFailure = OBFUSCATE_DECRYPT_NAME(0x6BF729E30729CF29ULL, audioFailureSource);
|
||||
if (audioFailure.Encrypted()) {
|
||||
audioFailure.Text();
|
||||
} else {
|
||||
|
|
@ -1576,7 +1569,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
ResourceMgr& resources = ResourceMgr::Instance();
|
||||
const std::array resourceNamesSource = {'\x8F', '\xA4', '\x00', '\x0D', '\x46', '\x3C', '\x78', '\x4B', '\x9C', '\xA3', '\x1F', '\x26', '\x09', '\x25', '\x65', '\x6B',
|
||||
'\xFD'};
|
||||
EncryptedName<sizeof(resourceNamesSource), 0x1F1D51274373C1FDULL>& resourceNames = ThreadLocalName<0x1F1D51274373C1FDULL>(resourceNamesSource);
|
||||
EncryptedName<sizeof(resourceNamesSource), 0x1F1D51274373C1FDULL>& resourceNames = OBFUSCATE_DECRYPT_NAME(0x1F1D51274373C1FDULL, resourceNamesSource);
|
||||
resources.LoadAliases(reinterpret_cast<int>(resourceNames.Text()));
|
||||
|
||||
if (!InitApp(instance, showCommand)) {
|
||||
|
|
@ -1586,7 +1579,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
std::pair<bool, std::string> managers = InitializeManagers();
|
||||
if (!managers.first) {
|
||||
const std::array errorSource = {'\x72', '\x27', '\xFF', '\xE8', '\x91', '\xA1'};
|
||||
EncryptedName<sizeof(errorSource), 0x5F93A1C3A7AD7537ULL>& error = ThreadLocalName<0x5F93A1C3A7AD7537ULL>(errorSource);
|
||||
EncryptedName<sizeof(errorSource), 0x5F93A1C3A7AD7537ULL>& error = OBFUSCATE_DECRYPT_NAME(0x5F93A1C3A7AD7537ULL, errorSource);
|
||||
MessageBoxA(nullptr, managers.second.c_str(), error.Text(), MB_OK);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1595,7 +1588,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
const std::array deviceFailureSource = {'\x14', '\xE2', '\x87', '\xBB', '\xEE', '\xB1', '\x6D', '\x2E', '\x39', '\xEA', '\x9D', '\xF5', '\xE5', '\xF6', '\x29', '\x67',
|
||||
'\x18', '\xD1', '\xC9', '\xB2', '\xF3', '\xA3', '\x6D', '\x21', '\x3E', '\xEF', '\x8C', '\xF5', '\xE9', '\xA4', '\x3E', '\x67',
|
||||
'\x27', '\xF1', '\x86', '\xB7', '\xED', '\xA0', '\x20', '\x69', '\x57'};
|
||||
EncryptedName<sizeof(deviceFailureSource), 0x474DC581D5E98357ULL>& deviceFailure = ThreadLocalName<0x474DC581D5E98357ULL>(deviceFailureSource);
|
||||
EncryptedName<sizeof(deviceFailureSource), 0x474DC581D5E98357ULL>& deviceFailure = OBFUSCATE_DECRYPT_NAME(0x474DC581D5E98357ULL, deviceFailureSource);
|
||||
ShowErrorDialog(deviceFailure.Text(), MB_OK);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -1617,7 +1610,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
g_grannyAnimationLibrary.Initialize();
|
||||
const std::array guildFlagSource = {'\xEA', '\xC8', '\x21', '\x16', '\x79', '\xD5', '\x40', '\x6D', '\xEA', '\xC8', '\x27', '\x2F', '\x72', '\xFC', '\x1A', '\x65',
|
||||
'\xE3', '\xC1', '\x29', '\x12', '\x72', '\xB0', '\x43', '\x56', '\xB6', '\x89', '\x22', '\x01', '\x27', '\x89'};
|
||||
EncryptedName<sizeof(guildFlagSource), 0x097389157345A787ULL>& guildFlag = ThreadLocalName<0x097389157345A787ULL>(guildFlagSource);
|
||||
EncryptedName<sizeof(guildFlagSource), 0x097389157345A787ULL>& guildFlag = OBFUSCATE_DECRYPT_NAME(0x097389157345A787ULL, guildFlagSource);
|
||||
g_grannyAnimationLibrary.Load(guildFlag.Text(), 1, 0);
|
||||
g_skinInfo.Refresh();
|
||||
CreateTrigonometricTable();
|
||||
|
|
@ -1632,7 +1625,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
}
|
||||
|
||||
const std::array memoSource = {'\xE4', '\x0E', '\x84', '\xF0', '\x4B'};
|
||||
EncryptedName<sizeof(memoSource), 0xC5995F4B9FE96B89ULL>& memo = ThreadLocalName<0xC5995F4B9FE96B89ULL>(memoSource);
|
||||
EncryptedName<sizeof(memoSource), 0xC5995F4B9FE96B89ULL>& memo = OBFUSCATE_DECRYPT_NAME(0xC5995F4B9FE96B89ULL, memoSource);
|
||||
WIN32_FIND_DATAA memoData;
|
||||
HANDLE memoFind = FindFirstFileA(memo.Text(), &memoData);
|
||||
if (memoFind == INVALID_HANDLE_VALUE) {
|
||||
|
|
@ -1644,12 +1637,12 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
g_navigationManager.LoadSettings();
|
||||
|
||||
const std::array replayFolderSource = {'\x49', '\xAC', '\xB1', '\x83', '\xB0', '\x04', '\x0F'};
|
||||
EncryptedName<sizeof(replayFolderSource), 0x610F7DD1EFC1C91BULL>& replayFolder = ThreadLocalName<0x610F7DD1EFC1C91BULL>(replayFolderSource);
|
||||
EncryptedName<sizeof(replayFolderSource), 0x610F7DD1EFC1C91BULL>& replayFolder = OBFUSCATE_DECRYPT_NAME(0x610F7DD1EFC1C91BULL, replayFolderSource);
|
||||
WIN32_FIND_DATAA replayData;
|
||||
HANDLE replayFind = FindFirstFileA(replayFolder.Text(), &replayData);
|
||||
if (replayFind == INVALID_HANDLE_VALUE) {
|
||||
const std::array replayDirectorySource = {'\xEB', '\x48', '\x4D', '\x5F', '\xEC', '\xEA', '\x15'};
|
||||
EncryptedName<sizeof(replayDirectorySource), 0xED15938D333D2DB9ULL>& replayDirectory = ThreadLocalName<0xED15938D333D2DB9ULL>(replayDirectorySource);
|
||||
EncryptedName<sizeof(replayDirectorySource), 0xED15938D333D2DB9ULL>& replayDirectory = OBFUSCATE_DECRYPT_NAME(0xED15938D333D2DB9ULL, replayDirectorySource);
|
||||
CreateDirectoryA(replayDirectory.Text(), nullptr);
|
||||
} else {
|
||||
FindClose(replayFind);
|
||||
|
|
@ -1659,7 +1652,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
HANDLE navigationFind = FindFirstFileA("", &navigationData);
|
||||
if (replayFind == INVALID_HANDLE_VALUE) {
|
||||
const std::array navigationDirectorySource = {'\x0D', '\x58', '\x2D', '\x02', '\x00', '\x4C', '\x05', '\xA0', '\x2C', '\x57', '\x3F', '\x0A', '\x13', '\x4C', '\x71'};
|
||||
EncryptedName<sizeof(navigationDirectorySource), 0xC9712D676B5B3943ULL>& navigationDirectory = ThreadLocalName<0xC9712D676B5B3943ULL>(navigationDirectorySource);
|
||||
EncryptedName<sizeof(navigationDirectorySource), 0xC9712D676B5B3943ULL>& navigationDirectory = OBFUSCATE_DECRYPT_NAME(0xC9712D676B5B3943ULL, navigationDirectorySource);
|
||||
CreateDirectoryA(navigationDirectory.Text(), nullptr);
|
||||
} else {
|
||||
FindClose(navigationFind);
|
||||
|
|
@ -1728,44 +1721,44 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
|
|||
|
||||
if (g_restartClient) {
|
||||
const std::array devServerSource = {'\x55', '\x86', '\x25', '\x99'};
|
||||
EncryptedName<sizeof(devServerSource), 0x4B755DB19953E311ULL>& devServer = ThreadLocalName<0x4B755DB19953E311ULL>(devServerSource);
|
||||
EncryptedName<sizeof(devServerSource), 0x4B755DB19953E311ULL>& devServer = OBFUSCATE_DECRYPT_NAME(0x4B755DB19953E311ULL, devServerSource);
|
||||
if (!std::strstr(g_launchServerName, devServer.Text())) {
|
||||
const char* parameters = LookupMessage(MSI_FRIEND_ALREADY_FRIEND);
|
||||
const char* file = LookupMessage(MSI_FRIEND_ALREADY_FRIEND);
|
||||
const std::array openSource = {'\x22', '\xEF', '\x90', '\x69', '\xEB'};
|
||||
EncryptedName<sizeof(openSource), 0xD7A749EB27D5BF6DULL>& open = ThreadLocalName<0xD7A749EB27D5BF6DULL>(openSource);
|
||||
EncryptedName<sizeof(openSource), 0xD7A749EB27D5BF6DULL>& open = OBFUSCATE_DECRYPT_NAME(0xD7A749EB27D5BF6DULL, openSource);
|
||||
ShellExecuteA(nullptr, open.Text(), file, parameters, nullptr, SW_SHOWNORMAL);
|
||||
} else if (g_serviceMode == 0) {
|
||||
const std::array parametersSource = {'\xE5', '\xF5', '\x65', '\x83', '\x89', '\x86', '\x46', '\x9C', '\xE9', '\xEC', '\x65', '\x9C', '\xDC', '\xC5', '\x1A', '\xD3',
|
||||
'\xEA', '\xEF', '\x7B', '\x9C', '\xCA', '\x87', '\x0A', '\x92', '\xE0', '\xAE', '\x76', '\x92', '\xDE', '\xCC', '\x1A', '\x89',
|
||||
'\xEC', '\xF3', '\x65', '\x96', '\xC1', '\x86', '\x0D', '\x98', '\xFB', '\xF3', '\x7E', '\xDD', '\xD2', '\xDA', '\x19', '\xC2',
|
||||
'\xCA', '\xE0', '\x7C', '\x96', '\xF0', '\xC6', '\x0D', '\x98', '\xB0', '\xB5', '\x21', '\xC2', '\x82', '\xA9'};
|
||||
EncryptedName<sizeof(parametersSource), 0xFD69A9B3F311818DULL>& parameters = ThreadLocalName<0xFD69A9B3F311818DULL>(parametersSource);
|
||||
EncryptedName<sizeof(parametersSource), 0xFD69A9B3F311818DULL>& parameters = OBFUSCATE_DECRYPT_NAME(0xFD69A9B3F311818DULL, parametersSource);
|
||||
const char* arguments = parameters.Text();
|
||||
const std::array fileSource = {'\x43', '\x6B', '\x9D', '\xDB', '\xFB', '\xD0', '\x02', '\x1E', '\x4F', '\x72', '\x9D', '\xC4', '\xAE', '\x93', '\x5E', '\x51',
|
||||
'\x4C', '\x71', '\x83', '\xC4', '\xB8', '\xD1', '\x4E', '\x10', '\x46', '\x30', '\x8E', '\xCA', '\xAC', '\x9A', '\x5E', '\x0B',
|
||||
'\x4A', '\x6D', '\x9D', '\xCE', '\xB3', '\xD0', '\x49', '\x1A', '\x5D', '\x6D', '\x86', '\x85', '\xA0', '\x8C', '\x5D', '\x40',
|
||||
'\x6C', '\x7E', '\x84', '\xCE', '\x82', '\x90', '\x49', '\x1A', '\x16', '\x2B', '\xD9', '\x9A', '\xF0', '\xFF'};
|
||||
EncryptedName<sizeof(fileSource), 0x7F2DFFC1ABE91F2BULL>& file = ThreadLocalName<0x7F2DFFC1ABE91F2BULL>(fileSource);
|
||||
EncryptedName<sizeof(fileSource), 0x7F2DFFC1ABE91F2BULL>& file = OBFUSCATE_DECRYPT_NAME(0x7F2DFFC1ABE91F2BULL, fileSource);
|
||||
const char* target = file.Text();
|
||||
const std::array openSource = {'\x74', '\xB7', '\x44', '\x55', '\xC1'};
|
||||
EncryptedName<sizeof(openSource), 0xBD2BA1C11B01E73BULL>& open = ThreadLocalName<0xBD2BA1C11B01E73BULL>(openSource);
|
||||
EncryptedName<sizeof(openSource), 0xBD2BA1C11B01E73BULL>& open = OBFUSCATE_DECRYPT_NAME(0xBD2BA1C11B01E73BULL, openSource);
|
||||
ShellExecuteA(nullptr, open.Text(), target, arguments, nullptr, SW_SHOWNORMAL);
|
||||
} else {
|
||||
const std::array parametersSource = {'\x31', '\x79', '\xBF', '\xDF', '\x47', '\x4C', '\xBA', '\xD0', '\x3D', '\x60', '\xBF', '\xC0', '\x12', '\x0F', '\xE6', '\x9F',
|
||||
'\x3E', '\x63', '\xA1', '\xC0', '\x04', '\x4D', '\xF6', '\xDE', '\x34', '\x22', '\xAC', '\xCE', '\x10', '\x06', '\xE6', '\xC5',
|
||||
'\x38', '\x7F', '\xBF', '\xCA', '\x0F', '\x4C', '\xF1', '\xD4', '\x2F', '\x7F', '\xA4', '\x81', '\x1C', '\x10', '\xE5', '\x8E',
|
||||
'\x1E', '\x6C', '\xA6', '\xCA', '\x3E', '\x0C', '\xF1', '\xD4', '\x64', '\x3B', '\xFB', '\x9E', '\x4C', '\x63'};
|
||||
EncryptedName<sizeof(parametersSource), 0xB195637DAFCB0D59ULL>& parameters = ThreadLocalName<0xB195637DAFCB0D59ULL>(parametersSource);
|
||||
EncryptedName<sizeof(parametersSource), 0xB195637DAFCB0D59ULL>& parameters = OBFUSCATE_DECRYPT_NAME(0xB195637DAFCB0D59ULL, parametersSource);
|
||||
const char* arguments = parameters.Text();
|
||||
const std::array fileSource = {'\x65', '\x17', '\xF9', '\x79', '\x7F', '\x7C', '\xA0', '\xB8', '\x69', '\x0E', '\xF9', '\x66', '\x2A', '\x3F', '\xFC', '\xF7',
|
||||
'\x6A', '\x0D', '\xE7', '\x66', '\x3C', '\x7D', '\xEC', '\xB6', '\x60', '\x4C', '\xEA', '\x68', '\x28', '\x36', '\xFC', '\xAD',
|
||||
'\x6C', '\x11', '\xF9', '\x6C', '\x37', '\x7C', '\xEB', '\xBC', '\x7B', '\x11', '\xE2', '\x27', '\x24', '\x20', '\xFF', '\xE6',
|
||||
'\x4A', '\x02', '\xE0', '\x6C', '\x06', '\x3C', '\xEB', '\xBC', '\x30', '\x55', '\xBD', '\x38', '\x74', '\x53'};
|
||||
EncryptedName<sizeof(fileSource), 0xD98F5345098D630DULL>& file = ThreadLocalName<0xD98F5345098D630DULL>(fileSource);
|
||||
EncryptedName<sizeof(fileSource), 0xD98F5345098D630DULL>& file = OBFUSCATE_DECRYPT_NAME(0xD98F5345098D630DULL, fileSource);
|
||||
const char* target = file.Text();
|
||||
const std::array openSource = {'\xDC', '\x25', '\x9A', '\xA1', '\x4D'};
|
||||
EncryptedName<sizeof(openSource), 0x9B0F234DEFDF7593ULL>& open = ThreadLocalName<0x9B0F234DEFDF7593ULL>(openSource);
|
||||
EncryptedName<sizeof(openSource), 0x9B0F234DEFDF7593ULL>& open = OBFUSCATE_DECRYPT_NAME(0x9B0F234DEFDF7593ULL, openSource);
|
||||
ShellExecuteA(nullptr, open.Text(), target, arguments, nullptr, SW_SHOWNORMAL);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@
|
|||
#include "Utility/Text/FormatString.h"
|
||||
#include "Utility/Cipher/LocalEncryptedName.h"
|
||||
#include "Utility/Cipher/CryptName.h"
|
||||
#include "Utility/Cipher/Obfuscate.h"
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
|
|
@ -39,7 +40,7 @@ namespace {
|
|||
|
||||
// INLINED
|
||||
__forceinline const char* TimeFontActionName() {
|
||||
constexpr auto sourceText = CRYPT_NAME("이팩트\\TimeFont.act", 0x7D5D0F110B6B8371ULL);
|
||||
constexpr auto sourceText = OBFUSCATE_SOURCE("이팩트\\TimeFont.act", 0x7D5D0F110B6B8371ULL);
|
||||
const auto& source = sourceText.data;
|
||||
// GLOBAL: gl_25508
|
||||
thread_local EncryptedName<sizeof(source), 0x7D5D0F110B6B8371ULL> name(source);
|
||||
|
|
@ -48,7 +49,7 @@ __forceinline const char* TimeFontActionName() {
|
|||
|
||||
// INLINED
|
||||
__forceinline const char* TimeFontSpriteName() {
|
||||
const char source[] = CRYPT_CHARS(20, "이팩트\\TimeFont.spr", 0x114901C7E37F6D49ULL);
|
||||
const char source[] = OBFUSCATE_SOURCE_CHARS(20, "이팩트\\TimeFont.spr", 0x114901C7E37F6D49ULL);
|
||||
// GLOBAL: gl_25509
|
||||
thread_local EncryptedName<sizeof(source), 0x114901C7E37F6D49ULL> name(source);
|
||||
return name.Text();
|
||||
|
|
|
|||
|
|
@ -353,13 +353,6 @@ static_assert(sizeof(AcceptEnterNeoUnionPacket) == 0x18 + sizeof(CharacterInfo))
|
|||
static_assert(offsetof(CharacterSlotCountsPacket, extension) == 0xA);
|
||||
static_assert(sizeof(BlockedCharacter) == 0x18);
|
||||
static_assert(offsetof(AcceptEnterPacket, characters) == 0x1B);
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptName(const std::array<char, Length>& source) {
|
||||
thread_local EncryptedName<Length, Key> name(source);
|
||||
return name.Text();
|
||||
}
|
||||
|
||||
|
||||
struct CharacterInfo2SizeErrorFormat {
|
||||
__declspec(noinline) EncryptedName<75, 0xED15938D333D2DB9ULL>& operator()() const;
|
||||
|
|
@ -929,9 +922,9 @@ void CLoginMode::ReceiveDeleteReservation(const CharacterDeletePacket* packet) {
|
|||
void CLoginMode::ReceiveMapStates(const MapStatePacket* packet) {
|
||||
const unsigned int count = (packet->length - 4) / sizeof(MapStateInfo);
|
||||
if ((packet->length - 4) % sizeof(MapStateInfo) != 0) {
|
||||
constexpr std::array<char, 34> source = CRYPT_NAME("mismatch MapState size(size = %d)", 0x792FFD1325418FB5ULL);
|
||||
constexpr std::array<char, 34> source = OBFUSCATE_SOURCE("mismatch MapState size(size = %d)", 0x792FFD1325418FB5ULL);
|
||||
char text[256];
|
||||
sprintf(text, DecryptName<0x792FFD1325418FB5ULL>(source), sizeof(MapStateInfo));
|
||||
sprintf(text, OBFUSCATE_DECRYPT(0x792FFD1325418FB5ULL, source), sizeof(MapStateInfo));
|
||||
g_windowMgr.Confirm(text, 0, true, false, 0, "Message", 280, 120, 0);
|
||||
this->pendingCursorType = 7;
|
||||
return;
|
||||
|
|
@ -1194,34 +1187,34 @@ void CLoginMode::OpenAccountRegistration() {
|
|||
case ServiceKorea:
|
||||
if (*reinterpret_cast<const int*>(&g_session.mouseAndChannelOptions[0x198]) == 1) {
|
||||
const char* url = LookupMessage(MSI_SETTLE_WEB_URL_HANGAME);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0xCFF3899D95AF355FULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0xCFF3899D95AF355FULL>(source), url, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0xCFF3899D95AF355FULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0xCFF3899D95AF355FULL, source), url, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
} else {
|
||||
const char* url = LookupMessage(MSI_SETTLE_WEB_URL);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0xE52DF30DCBAF7125ULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0xE52DF30DCBAF7125ULL>(source), url, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0xE52DF30DCBAF7125ULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0xE52DF30DCBAF7125ULL, source), url, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
}
|
||||
break;
|
||||
case 1: {
|
||||
constexpr std::array<char, 61> urlSource = CRYPT_NAME("https://iro.ragnarokonline.com/member/memberjoin1.asp?mNum=1", 0x13E33FA1A591AB67ULL);
|
||||
const char* file = DecryptName<0x13E33FA1A591AB67ULL>(urlSource);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0x17A9E5BF39AD4737ULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0x17A9E5BF39AD4737ULL>(source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 61> urlSource = OBFUSCATE_SOURCE("https://iro.ragnarokonline.com/member/memberjoin1.asp?mNum=1", 0x13E33FA1A591AB67ULL);
|
||||
const char* file = OBFUSCATE_DECRYPT(0x13E33FA1A591AB67ULL, urlSource);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0x17A9E5BF39AD4737ULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0x17A9E5BF39AD4737ULL, source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
break;
|
||||
}
|
||||
case ServiceJapan:
|
||||
break;
|
||||
case ServiceChina: {
|
||||
constexpr std::array<char, 54> urlSource = CRYPT_NAME("http://t.kunlun.com/?act=voucher.main&cid=1000&pid=61", 0x9949BFD527532943ULL);
|
||||
const char* file = DecryptName<0x9949BFD527532943ULL>(urlSource);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0xCD8F077123FB7D6FULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0xCD8F077123FB7D6FULL>(source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 54> urlSource = OBFUSCATE_SOURCE("http://t.kunlun.com/?act=voucher.main&cid=1000&pid=61", 0x9949BFD527532943ULL);
|
||||
const char* file = OBFUSCATE_DECRYPT(0x9949BFD527532943ULL, urlSource);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0xCD8F077123FB7D6FULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0xCD8F077123FB7D6FULL, source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
const char* url = LookupMessage(MSI_SETTLE_WEB_URL);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0xC517FB932D95BB6DULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0xC517FB932D95BB6DULL>(source), url, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0xC517FB932D95BB6DULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0xC517FB932D95BB6DULL, source), url, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1245,65 +1238,65 @@ void CLoginMode::ReceiveRefuseLogin(const RefuseLoginPacket* packet) {
|
|||
memset(text, 0, sizeof(text));
|
||||
{
|
||||
const char* message = LookupMessage(MSI_NAVIGATION_ROADLISTVIEW);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0x891B232D09451965ULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0x891B232D09451965ULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0x891B232D09451965ULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0x891B232D09451965ULL, source), message);
|
||||
}
|
||||
|
||||
switch (packet->result) {
|
||||
case 1: {
|
||||
const char* message = LookupMessage(MSI_TAREN_LOGINREFUSE_FAIL_PERSONALNUMBER);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0x758F1D0B4F7705B9ULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0x758F1D0B4F7705B9ULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0x758F1D0B4F7705B9ULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0x758F1D0B4F7705B9ULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
const char* message = LookupMessage(MSI_TAREN_LOGINREFUSE_FAIL_ACCOUNT_BLOCK);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0x35E5656B5DEDCD75ULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0x35E5656B5DEDCD75ULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0x35E5656B5DEDCD75ULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0x35E5656B5DEDCD75ULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
const char* message = LookupMessage(MSI_TAREN_LOGINREFUSE_FAIL_SYSTEM);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0x4941FD9F21BBB9FDULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0x4941FD9F21BBB9FDULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0x4941FD9F21BBB9FDULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0x4941FD9F21BBB9FDULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 4: {
|
||||
const char* message = LookupMessage(MSI_TAREN_LOGINREFUSE_FAIL_UNKNOWN);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0xE7978FB5A94DD7FDULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0xE7978FB5A94DD7FDULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0xE7978FB5A94DD7FDULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0xE7978FB5A94DD7FDULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 5: {
|
||||
const char* message = LookupMessage(MSI_NAVIGATION_ICONTITEL);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0xB7FD8F670FC7B96BULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0xB7FD8F670FC7B96BULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0xB7FD8F670FC7B96BULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0xB7FD8F670FC7B96BULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 6: {
|
||||
const char* message = LookupMessage(MSI_NAVIGATION_RUITELISTTITEL);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0x39FF7FB50DEB998FULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0x39FF7FB50DEB998FULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0x39FF7FB50DEB998FULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0x39FF7FB50DEB998FULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 7: {
|
||||
const char* message = LookupMessage(MSI_NAVIGATION_V4_HELP02);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0x2FE993D1DDE1F197ULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0x2FE993D1DDE1F197ULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0x2FE993D1DDE1F197ULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0x2FE993D1DDE1F197ULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 8:
|
||||
case 100:
|
||||
case 102: {
|
||||
const char* message = LookupMessage(MSI_NAVIGATION_ROADLISTVIEW);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0xAD075B8DB599F1CDULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0xAD075B8DB599F1CDULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0xAD075B8DB599F1CDULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0xAD075B8DB599F1CDULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 9: {
|
||||
const char* message = LookupMessage(MSI_ZEROQUEST_SIMPLEUI_ON);
|
||||
constexpr std::array<char, 3> source = CRYPT_NAME("%s", 0x2F8B0F37118D157FULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), DecryptName<0x2F8B0F37118D157FULL>(source), message);
|
||||
constexpr std::array<char, 3> source = OBFUSCATE_SOURCE("%s", 0x2F8B0F37118D157FULL);
|
||||
StringFormat(text, sizeof(text), static_cast<std::size_t>(-1), OBFUSCATE_DECRYPT(0x2F8B0F37118D157FULL, source), message);
|
||||
break;
|
||||
}
|
||||
case 101: {
|
||||
|
|
@ -1318,8 +1311,8 @@ void CLoginMode::ReceiveRefuseLogin(const RefuseLoginPacket* packet) {
|
|||
|
||||
GetRagConnection().Close();
|
||||
const int result = packet->result;
|
||||
constexpr std::array<char, 7> source = CRYPT_NAME("%s(%d)", 0x050505679903579BULL);
|
||||
g_windowMgr.Confirm(FormatString(DecryptName<0x050505679903579BULL>(source), text, result), 0, true, false, 0, "Message", 280, 120, 0);
|
||||
constexpr std::array<char, 7> source = OBFUSCATE_SOURCE("%s(%d)", 0x050505679903579BULL);
|
||||
g_windowMgr.Confirm(FormatString(OBFUSCATE_DECRYPT(0x050505679903579BULL, source), text, result), 0, true, false, 0, "Message", 280, 120, 0);
|
||||
g_charServerAccountIdPending = 0;
|
||||
this->pendingCursorType = 3;
|
||||
}
|
||||
|
|
@ -1519,8 +1512,8 @@ int CLoginMode::Run() {
|
|||
g_modeMgr.Quit();
|
||||
std::string message = g_nProtectGameGuardMgr->ErrorMessage();
|
||||
if (!message.empty()) {
|
||||
constexpr std::array<char, 19> source = CRYPT_NAME("nProtect GameGuard", 0x2D51E3B7236175EDULL);
|
||||
MessageBoxA(hWnd, message.c_str(), DecryptName<0x2D51E3B7236175EDULL>(source), 0);
|
||||
constexpr std::array<char, 19> source = OBFUSCATE_SOURCE("nProtect GameGuard", 0x2D51E3B7236175EDULL);
|
||||
MessageBoxA(hWnd, message.c_str(), OBFUSCATE_DECRYPT(0x2D51E3B7236175EDULL, source), 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1661,22 +1654,22 @@ void CLoginMode::SubD90C90(const PasswordModePacket* packet) {
|
|||
break;
|
||||
case 9: {
|
||||
const char* text = LookupMessage(MSI_NAVIGATION_RUITELISTTITEL);
|
||||
constexpr std::array<char, 7> source = CRYPT_NAME("%s(%d)", 0x0B8745519B1F95D7ULL);
|
||||
g_windowMgr.Confirm(FormatString(DecryptName<0x0B8745519B1F95D7ULL>(source), text, 9), 0, true, false, 0, "Message",
|
||||
constexpr std::array<char, 7> source = OBFUSCATE_SOURCE("%s(%d)", 0x0B8745519B1F95D7ULL);
|
||||
g_windowMgr.Confirm(FormatString(OBFUSCATE_DECRYPT(0x0B8745519B1F95D7ULL, source), text, 9), 0, true, false, 0, "Message",
|
||||
280, 120, 0);
|
||||
break;
|
||||
}
|
||||
case 10: {
|
||||
const char* text = LookupMessage(MSI_NAVIGATION_RUITELISTTITEL);
|
||||
constexpr std::array<char, 7> source = CRYPT_NAME("%s(%d)", 0xA597A7E7492B39D5ULL);
|
||||
g_windowMgr.Confirm(FormatString(DecryptName<0xA597A7E7492B39D5ULL>(source), text, 10), 0, true, false, 0, "Message",
|
||||
constexpr std::array<char, 7> source = OBFUSCATE_SOURCE("%s(%d)", 0xA597A7E7492B39D5ULL);
|
||||
g_windowMgr.Confirm(FormatString(OBFUSCATE_DECRYPT(0xA597A7E7492B39D5ULL, source), text, 10), 0, true, false, 0, "Message",
|
||||
280, 120, 0);
|
||||
break;
|
||||
}
|
||||
case 11: {
|
||||
const char* text = LookupMessage(MSI_NAVIGATION_RUITELISTTITEL);
|
||||
constexpr std::array<char, 7> source = CRYPT_NAME("%s(%d)", 0xFFABE3D5D1BBEF73ULL);
|
||||
g_windowMgr.Confirm(FormatString(DecryptName<0xFFABE3D5D1BBEF73ULL>(source), text, 11), 0, true, false, 0, "Message",
|
||||
constexpr std::array<char, 7> source = OBFUSCATE_SOURCE("%s(%d)", 0xFFABE3D5D1BBEF73ULL);
|
||||
g_windowMgr.Confirm(FormatString(OBFUSCATE_DECRYPT(0xFFABE3D5D1BBEF73ULL, source), text, 11), 0, true, false, 0, "Message",
|
||||
280, 120, 0);
|
||||
break;
|
||||
}
|
||||
|
|
@ -1743,22 +1736,22 @@ void CLoginMode::SubD911C0(const PasswordModePacket* packet) {
|
|||
break;
|
||||
case 9: {
|
||||
const char* text = LookupMessage(MSI_NAVIGATION_RUITELISTTITEL);
|
||||
constexpr std::array<char, 7> source = CRYPT_NAME("%s(%d)", 0x49D33529F1556333ULL);
|
||||
g_windowMgr.Confirm(FormatString(DecryptName<0x49D33529F1556333ULL>(source), text, 9), 0, true, false, 0, "Message",
|
||||
constexpr std::array<char, 7> source = OBFUSCATE_SOURCE("%s(%d)", 0x49D33529F1556333ULL);
|
||||
g_windowMgr.Confirm(FormatString(OBFUSCATE_DECRYPT(0x49D33529F1556333ULL, source), text, 9), 0, true, false, 0, "Message",
|
||||
280, 120, 0);
|
||||
break;
|
||||
}
|
||||
case 10: {
|
||||
const char* text = LookupMessage(MSI_NAVIGATION_RUITELISTTITEL);
|
||||
constexpr std::array<char, 7> source = CRYPT_NAME("%s(%d)", 0x01CB4F1DF9D3F931ULL);
|
||||
g_windowMgr.Confirm(FormatString(DecryptName<0x01CB4F1DF9D3F931ULL>(source), text, 10), 0, true, false, 0, "Message",
|
||||
constexpr std::array<char, 7> source = OBFUSCATE_SOURCE("%s(%d)", 0x01CB4F1DF9D3F931ULL);
|
||||
g_windowMgr.Confirm(FormatString(OBFUSCATE_DECRYPT(0x01CB4F1DF9D3F931ULL, source), text, 10), 0, true, false, 0, "Message",
|
||||
280, 120, 0);
|
||||
break;
|
||||
}
|
||||
case 11: {
|
||||
const char* text = LookupMessage(MSI_NAVIGATION_RUITELISTTITEL);
|
||||
constexpr std::array<char, 7> source = CRYPT_NAME("%s(%d)", 0xC5B1BBCD9BC9C997ULL);
|
||||
g_windowMgr.Confirm(FormatString(DecryptName<0xC5B1BBCD9BC9C997ULL>(source), text, 11), 0, true, false, 0, "Message",
|
||||
constexpr std::array<char, 7> source = OBFUSCATE_SOURCE("%s(%d)", 0xC5B1BBCD9BC9C997ULL);
|
||||
g_windowMgr.Confirm(FormatString(OBFUSCATE_DECRYPT(0xC5B1BBCD9BC9C997ULL, source), text, 11), 0, true, false, 0, "Message",
|
||||
280, 120, 0);
|
||||
break;
|
||||
}
|
||||
|
|
@ -1942,8 +1935,8 @@ void CLoginMode::ShowLoginError(int code, int argument) {
|
|||
url = "https://member.onstove.com/auth/login/by_game?redirect_url=https://ro.game.onstove.com/account/ingamepopup/&access_token=";
|
||||
}
|
||||
url += g_stoveMgr->GetAccessToken();
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("OPEN", 0xD98F5345098D630DULL);
|
||||
ShellExecuteA(nullptr, DecryptName<0xD98F5345098D630DULL>(source), url.c_str(), url.c_str(), nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("OPEN", 0xD98F5345098D630DULL);
|
||||
ShellExecuteA(nullptr, OBFUSCATE_DECRYPT(0xD98F5345098D630DULL, source), url.c_str(), url.c_str(), nullptr, SW_SHOWNORMAL);
|
||||
message = "";
|
||||
g_modeMgr.Quit();
|
||||
return;
|
||||
|
|
@ -1997,15 +1990,15 @@ void CLoginMode::ShowLoginError(int code, int argument) {
|
|||
message = std::string(PasswordRetryExceededMessage{}().Text());
|
||||
if (g_windowMgr.Confirm(message.c_str(), 0, true, true, 0, "Message", 280, 120, 0) == 0xB8) {
|
||||
if (g_session.m_channelCopId == 1) {
|
||||
constexpr std::array<char, 23> urlSource = CRYPT_NAME("http://www.hangame.com", 0xED796785D1DF137FULL);
|
||||
const char* file = DecryptName<0xED796785D1DF137FULL>(urlSource);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0x83EFBFBB37EDBDBDULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0x83EFBFBB37EDBDBDULL>(source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 23> urlSource = OBFUSCATE_SOURCE("http://www.hangame.com", 0xED796785D1DF137FULL);
|
||||
const char* file = OBFUSCATE_DECRYPT(0xED796785D1DF137FULL, urlSource);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0x83EFBFBB37EDBDBDULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0x83EFBFBB37EDBDBDULL, source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
} else {
|
||||
constexpr std::array<char, 22> urlSource = CRYPT_NAME("http://ragnarok.co.kr", 0xA5FD29D7AB6DC59FULL);
|
||||
const char* file = DecryptName<0xA5FD29D7AB6DC59FULL>(urlSource);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0xD97D5DBDBB2F2709ULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0xD97D5DBDBB2F2709ULL>(source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 22> urlSource = OBFUSCATE_SOURCE("http://ragnarok.co.kr", 0xA5FD29D7AB6DC59FULL);
|
||||
const char* file = OBFUSCATE_DECRYPT(0xA5FD29D7AB6DC59FULL, urlSource);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0xD97D5DBDBB2F2709ULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0xD97D5DBDBB2F2709ULL, source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
}
|
||||
g_modeMgr.Quit();
|
||||
}
|
||||
|
|
@ -2077,13 +2070,13 @@ void CLoginMode::ShowLoginError(int code, int argument) {
|
|||
}
|
||||
case 16:
|
||||
if (g_serviceType == 0) {
|
||||
constexpr std::array<char, 48> textSource = CRYPT_NAME("비밀 번호 변경 후, 다시 접속 해주시기 바랍니다.", 0xF14F79170939C7F1ULL);
|
||||
message = std::string(DecryptName<0xF14F79170939C7F1ULL>(textSource));
|
||||
constexpr std::array<char, 48> textSource = OBFUSCATE_SOURCE("비밀 번호 변경 후, 다시 접속 해주시기 바랍니다.", 0xF14F79170939C7F1ULL);
|
||||
message = std::string(OBFUSCATE_DECRYPT(0xF14F79170939C7F1ULL, textSource));
|
||||
if (g_windowMgr.Confirm(message.c_str(), 0, true, true, 0, "Message", 280, 120, 0) == 0xB8) {
|
||||
constexpr std::array<char, 65> urlSource = CRYPT_NAME("http://www.ragnarok.co.kr/setNewPW/password_change_agreement.asp", 0x7F2DFFC1ABE91F2BULL);
|
||||
const char* file = DecryptName<0x7F2DFFC1ABE91F2BULL>(urlSource);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0xFD69A9B3F311818DULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0xFD69A9B3F311818DULL>(source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 65> urlSource = OBFUSCATE_SOURCE("http://www.ragnarok.co.kr/setNewPW/password_change_agreement.asp", 0x7F2DFFC1ABE91F2BULL);
|
||||
const char* file = OBFUSCATE_DECRYPT(0x7F2DFFC1ABE91F2BULL, urlSource);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0xFD69A9B3F311818DULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0xFD69A9B3F311818DULL, source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
g_modeMgr.Quit();
|
||||
}
|
||||
message.clear();
|
||||
|
|
@ -2140,8 +2133,8 @@ void CLoginMode::ShowLoginError(int code, int argument) {
|
|||
case 110:
|
||||
if (g_windowMgr.Confirm(LookupMessage(MSI_SHOUTDOWN_TIME), 0, true, true, 0, "Message", 280, 120, 0) == 0xB8) {
|
||||
const char* file = LookupMessage(MSI_PARTIAL_SHOUTDOWN_TIME);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("open", 0x9B0F234DEFDF7593ULL);
|
||||
ShellExecuteA(hWnd, DecryptName<0x9B0F234DEFDF7593ULL>(source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("open", 0x9B0F234DEFDF7593ULL);
|
||||
ShellExecuteA(hWnd, OBFUSCATE_DECRYPT(0x9B0F234DEFDF7593ULL, source), file, nullptr, nullptr, SW_SHOWNORMAL);
|
||||
g_modeMgr.Quit();
|
||||
}
|
||||
message = "";
|
||||
|
|
@ -2165,8 +2158,8 @@ void CLoginMode::ShowLoginError(int code, int argument) {
|
|||
break;
|
||||
default: {
|
||||
message = LookupMessage(MSI_ACCESS_DENIED);
|
||||
constexpr std::array<char, 5> source = CRYPT_NAME("(%d)", 0xC9712D676B5B3943ULL);
|
||||
message += FormatOwnedString(DecryptName<0xC9712D676B5B3943ULL>(source), code);
|
||||
constexpr std::array<char, 5> source = OBFUSCATE_SOURCE("(%d)", 0xC9712D676B5B3943ULL);
|
||||
message += FormatOwnedString(OBFUSCATE_DECRYPT(0xC9712D676B5B3943ULL, source), code);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -2353,7 +2346,7 @@ void CLoginMode::ReceiveAcceptLogin(const AcceptLoginPacket* packet, int version
|
|||
|
||||
CNProtectGameGuardMgr* gameGuard = g_nProtectGameGuardMgr;
|
||||
const std::uint32_t aid = packet->aid;
|
||||
constexpr std::array<std::uint8_t, 3> source = CRYPT_NAME("%d", 0x637B959D55771F69ULL);
|
||||
constexpr std::array<std::uint8_t, 3> source = OBFUSCATE_SOURCE("%d", 0x637B959D55771F69ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x637B959D55771F69ULL> format(source);
|
||||
gameGuard->Send(FormatString(format.Text(), aid));
|
||||
GetRagConnection().Close();
|
||||
|
|
@ -3610,12 +3603,12 @@ void CLoginMode::OnChangeState(int value) {
|
|||
std::memset(&endpoint, 0, sizeof(endpoint));
|
||||
if (!std::strstr(g_session.clientVersion, "Dev")) {
|
||||
const int port = rand() % 3 + 6951;
|
||||
const std::array<std::uint8_t, 26> hostSource = CRYPT_BYTES(26, "kro-agency.ragnarok.co.kr", 0x7941D76335CFA14FULL);
|
||||
const std::array<std::uint8_t, 26> hostSource = OBFUSCATE_SOURCE_BYTES(26, "kro-agency.ragnarok.co.kr", 0x7941D76335CFA14FULL);
|
||||
thread_local EncryptedName<sizeof(hostSource), 0x7941D76335CFA14FULL> host(hostSource);
|
||||
const char* hostText = host.Text();
|
||||
StringFormat(endpoint.host, sizeof(endpoint.host), static_cast<std::size_t>(-1), OBFUSCATE_BYTES_TEXT("%s:%d", 0x7321C3814F8799E1ULL), hostText, port);
|
||||
} else {
|
||||
const std::array<std::uint8_t, 34> hostSource = CRYPT_BYTES(34, "kro-qm-agency.ragnarok.co.kr:6951", 0x7115D9F973F913C9ULL);
|
||||
const std::array<std::uint8_t, 34> hostSource = OBFUSCATE_SOURCE_BYTES(34, "kro-qm-agency.ragnarok.co.kr:6951", 0x7115D9F973F913C9ULL);
|
||||
thread_local EncryptedName<sizeof(hostSource), 0x7115D9F973F913C9ULL> host(hostSource);
|
||||
const char* hostText = host.Text();
|
||||
StringFormat(endpoint.host, sizeof(endpoint.host), static_cast<std::size_t>(-1), OBFUSCATE_BYTES_TEXT("%s", 0xCB1D253B7FE1F563ULL), hostText);
|
||||
|
|
@ -3633,7 +3626,7 @@ void CLoginMode::OnChangeState(int value) {
|
|||
ZoneLoginPacket packet;
|
||||
std::memset(&packet, 0, sizeof(packet));
|
||||
packet.id = ID_CT_AUTH;
|
||||
const std::array<std::uint8_t, 5> codeSource = CRYPT_BYTES(5, "0011", 0x793F370985ED674FULL);
|
||||
const std::array<std::uint8_t, 5> codeSource = OBFUSCATE_SOURCE_BYTES(5, "0011", 0x793F370985ED674FULL);
|
||||
thread_local EncryptedName<sizeof(codeSource), 0x793F370985ED674FULL> code(codeSource);
|
||||
std::memcpy(packet.code, code.Text(), sizeof(packet.code));
|
||||
StringFormat(packet.name, sizeof(packet.name), static_cast<std::size_t>(-1), OBFUSCATE_BYTES_TEXT("%s", 0x234977DDB54BC71DULL), reinterpret_cast<const char*>(&this->loginCredentials[0x40]));
|
||||
|
|
|
|||
|
|
@ -4087,7 +4087,7 @@ void CSession::LoadLuaDataFiles() {
|
|||
this->m_hotkeyScript->Load("Lua Files\\DataInfo\\jobName_F", true, false);
|
||||
this->m_hotkeyScript->Load("Lua Files\\DataInfo\\jobName", true, false);
|
||||
{
|
||||
const std::array<char, 27> source = CRYPT_CHARS(27, "Lua Files\\DataInfo\\PetInfo", 0x35E5656B5DEDCD75ULL);
|
||||
const std::array<char, 27> source = OBFUSCATE_SOURCE_CHARS(27, "Lua Files\\DataInfo\\PetInfo", 0x35E5656B5DEDCD75ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x35E5656B5DEDCD75ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
|
|
@ -4106,12 +4106,12 @@ void CSession::LoadLuaDataFiles() {
|
|||
this->m_hotkeyScript->Load("Lua Files\\SkillInfoz\\jobinheritlist", true, false);
|
||||
this->m_hotkeyScript->Load("Lua Files\\SkillInfoz\\SkillID", true, false);
|
||||
{
|
||||
const std::array<char, 35> source = CRYPT_CHARS(35, "Lua Files\\SkillInfoz\\SkillInfoList", 0x4941FD9F21BBB9FDULL);
|
||||
const std::array<char, 35> source = OBFUSCATE_SOURCE_CHARS(35, "Lua Files\\SkillInfoz\\SkillInfoList", 0x4941FD9F21BBB9FDULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x4941FD9F21BBB9FDULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
{
|
||||
const std::array<char, 35> source = CRYPT_CHARS(35, "Lua Files\\SkillInfoz\\SkillDescript", 0x891B232D09451965ULL);
|
||||
const std::array<char, 35> source = OBFUSCATE_SOURCE_CHARS(35, "Lua Files\\SkillInfoz\\SkillDescript", 0x891B232D09451965ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x891B232D09451965ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
|
|
@ -4120,7 +4120,7 @@ void CSession::LoadLuaDataFiles() {
|
|||
this->m_hotkeyScript->Load("Lua Files\\SkillInfoz\\skilltreeview", true, false);
|
||||
this->m_hotkeyScript->Load("Lua Files\\StateIcon\\EFSTIDs", true, false);
|
||||
{
|
||||
const std::array<char, 34> source = CRYPT_CHARS(34, "Lua Files\\StateIcon\\StateIconInfo", 0x758F1D0B4F7705B9ULL);
|
||||
const std::array<char, 34> source = OBFUSCATE_SOURCE_CHARS(34, "Lua Files\\StateIcon\\StateIconInfo", 0x758F1D0B4F7705B9ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x758F1D0B4F7705B9ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
|
|
@ -4166,7 +4166,7 @@ void CSession::LoadLuaDataFiles() {
|
|||
this->LoadNavigationScripts();
|
||||
this->m_hotkeyScript->Load("Lua Files\\DataInfo\\HelpMsgStr", true, false);
|
||||
{
|
||||
const std::array<char, 36> source = CRYPT_CHARS(36, "Lua Files\\EntryQueue\\EntryQueueList", 0xD1413DBB01CD8B51ULL);
|
||||
const std::array<char, 36> source = OBFUSCATE_SOURCE_CHARS(36, "Lua Files\\EntryQueue\\EntryQueueList", 0xD1413DBB01CD8B51ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0xD1413DBB01CD8B51ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
|
|
@ -4200,7 +4200,7 @@ void CSession::LoadLuaDataFiles() {
|
|||
|
||||
this->m_hotkeyScript->Load("Lua Files\\SignBoardList_F", true, false);
|
||||
{
|
||||
const std::array<char, 24> source = CRYPT_CHARS(24, "Lua Files\\SignBoardList", 0x637B959D55771F69ULL);
|
||||
const std::array<char, 24> source = OBFUSCATE_SOURCE_CHARS(24, "Lua Files\\SignBoardList", 0x637B959D55771F69ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x637B959D55771F69ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
|
|
@ -4210,12 +4210,12 @@ void CSession::LoadLuaDataFiles() {
|
|||
this->m_hotkeyScript->Load("Lua Files\\OffsetItemPos\\OffsetItemPos_F", true, false);
|
||||
this->m_hotkeyScript->Load("Lua Files\\OffsetItemPos\\OffsetItemPos", true, false);
|
||||
{
|
||||
const std::array<char, 37> source = CRYPT_CHARS(37, "Lua Files\\datainfo\\LapineDdukDDakBox", 0x2BAD156DE3E1F9D9ULL);
|
||||
const std::array<char, 37> source = OBFUSCATE_SOURCE_CHARS(37, "Lua Files\\datainfo\\LapineDdukDDakBox", 0x2BAD156DE3E1F9D9ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x2BAD156DE3E1F9D9ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
{
|
||||
const std::array<char, 36> source = CRYPT_CHARS(36, "Lua Files\\datainfo\\LapineUpgradeBox", 0x75ADC57D87EFBD8FULL);
|
||||
const std::array<char, 36> source = OBFUSCATE_SOURCE_CHARS(36, "Lua Files\\datainfo\\LapineUpgradeBox", 0x75ADC57D87EFBD8FULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x75ADC57D87EFBD8FULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
|
|
@ -4227,28 +4227,28 @@ void CSession::LoadLuaDataFiles() {
|
|||
this->m_hotkeyScript->Load("Lua Files\\datainfo\\tb_cashshop_banner", true, false);
|
||||
this->m_hotkeyScript->Load("Lua Files\\datainfo\\tb_stoveshop_banner", true, false);
|
||||
{
|
||||
const std::array<char, 26> source = CRYPT_CHARS(26, "Lua Files\\Agit\\AgitConfig", 0xEDC74F6D13DF71EFULL);
|
||||
const std::array<char, 26> source = OBFUSCATE_SOURCE_CHARS(26, "Lua Files\\Agit\\AgitConfig", 0xEDC74F6D13DF71EFULL);
|
||||
thread_local EncryptedName<sizeof(source), 0xEDC74F6D13DF71EFULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
{
|
||||
const std::array<char, 28> source = CRYPT_CHARS(28, "Lua Files\\Agit\\AgitConfig_F", 0xF161095D0DE18F95ULL);
|
||||
const std::array<char, 28> source = OBFUSCATE_SOURCE_CHARS(28, "Lua Files\\Agit\\AgitConfig_F", 0xF161095D0DE18F95ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0xF161095D0DE18F95ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
this->m_hotkeyScript->Load("Lua Files\\datainfo\\tb_checkAttendance_banner", true, false);
|
||||
{
|
||||
const std::array<char, 36> source = CRYPT_CHARS(36, "Lua Files\\DamageSkin\\DamageSkinList", 0x0B7109397F6B1387ULL);
|
||||
const std::array<char, 36> source = OBFUSCATE_SOURCE_CHARS(36, "Lua Files\\DamageSkin\\DamageSkinList", 0x0B7109397F6B1387ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x0B7109397F6B1387ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
{
|
||||
const std::array<char, 36> source = CRYPT_CHARS(36, "Lua Files\\DamageSkin\\DamageSkinInfo", 0x03772763F96D9DA5ULL);
|
||||
const std::array<char, 36> source = OBFUSCATE_SOURCE_CHARS(36, "Lua Files\\DamageSkin\\DamageSkinInfo", 0x03772763F96D9DA5ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x03772763F96D9DA5ULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
{
|
||||
const std::array<char, 38> source = CRYPT_CHARS(38, "Lua Files\\DamageSkin\\DamageSkinInfo_F", 0xC517FB932D95BB6DULL);
|
||||
const std::array<char, 38> source = OBFUSCATE_SOURCE_CHARS(38, "Lua Files\\DamageSkin\\DamageSkinInfo_F", 0xC517FB932D95BB6DULL);
|
||||
thread_local EncryptedName<sizeof(source), 0xC517FB932D95BB6DULL> name(source);
|
||||
this->m_hotkeyScript->Load(name.Text(), true, false);
|
||||
}
|
||||
|
|
@ -5930,7 +5930,7 @@ void CSession::LoadSessionTables() {
|
|||
Sub7739F0();
|
||||
g_simpleStringMgr->Init();
|
||||
|
||||
constexpr std::array<char, 15> source = CRYPT_NAME("Ragnarok Setup", 0x9171997D6963C9F7ULL);
|
||||
constexpr std::array<char, 15> source = OBFUSCATE_SOURCE("Ragnarok Setup", 0x9171997D6963C9F7ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x9171997D6963C9F7ULL> setupName(source);
|
||||
if (HWND window = FindWindowA(nullptr, setupName.Text())) {
|
||||
ShowErrorDialog(LookupMessage(MSI_TAREN_LOGINREFUSE_FAIL_PASSWORD), 0);
|
||||
|
|
|
|||
|
|
@ -78,20 +78,6 @@ void CStoveMgr::FetchAllProducts() {
|
|||
Sleep(200);
|
||||
} while (g_stoveWaitingCallback);
|
||||
}
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptName(const std::array<char, Length>& source) {
|
||||
thread_local EncryptedName<Length, Key> name(source);
|
||||
return name.Text();
|
||||
}
|
||||
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptName(const char (&source)[Length]) {
|
||||
thread_local EncryptedName<Length, Key> name(source);
|
||||
return name.Text();
|
||||
}
|
||||
|
||||
|
||||
// OFFSET: 0x0063F030
|
||||
// FUNCTION: fn_04801
|
||||
|
|
@ -237,9 +223,9 @@ void ShutdownCallback::operator()(Stove::PCSDK::CallbackResult callbackResult, S
|
|||
std::string message =
|
||||
EncodeText(CP_ACP, std::wstring(reinterpret_cast<const Stove::PCSDK::Base::StovePCLogEvent&>(shutdown).GetCategory1()));
|
||||
if (reinterpret_cast<const Stove::PCSDK::Base::StovePCToken&>(shutdown).GetAccessToken() == nullptr) {
|
||||
constexpr auto captionSourceText = CRYPT_NAME("메시지", 0x91E147EBBD47C39FULL);
|
||||
constexpr auto captionSourceText = OBFUSCATE_SOURCE("메시지", 0x91E147EBBD47C39FULL);
|
||||
const auto& captionSource = captionSourceText.data;
|
||||
const char* caption = DecryptName<0x91E147EBBD47C39FULL>(captionSource);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0x91E147EBBD47C39FULL, captionSource);
|
||||
MessageBoxA(hWnd, message.c_str(), caption, MB_OK);
|
||||
g_modeMgr.gameMode->SendMsg(MM_QUIT, 0, 0, 0, 0);
|
||||
} else if (g_modeMgr.state == 0) {
|
||||
|
|
@ -256,9 +242,9 @@ void ShutdownCallback::operator()(Stove::PCSDK::CallbackResult callbackResult, S
|
|||
g_windowMgr.SendNotice(UIM_PUSHINTOCHATHISTORY2, reinterpret_cast<std::intptr_t>(message.c_str()), 0x62B0FF, 0, 0, 0);
|
||||
}
|
||||
} else {
|
||||
constexpr auto captionSourceText = CRYPT_NAME("메시지", 0xA1A55B4D1597EDD3ULL);
|
||||
constexpr auto captionSourceText = OBFUSCATE_SOURCE("메시지", 0xA1A55B4D1597EDD3ULL);
|
||||
const auto& captionSource = captionSourceText.data;
|
||||
const char* caption = DecryptName<0xA1A55B4D1597EDD3ULL>(captionSource);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0xA1A55B4D1597EDD3ULL, captionSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(TokenCallbackFailureMessage()().Text()).c_str(), caption, MB_OK);
|
||||
PostQuitMessage(0);
|
||||
}
|
||||
|
|
@ -300,11 +286,11 @@ void FetchProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackResu
|
|||
}
|
||||
}
|
||||
} else {
|
||||
constexpr auto captionSourceText = CRYPT_NAME("메시지", 0x8B3FEB5B8BD5C3C3ULL);
|
||||
constexpr auto captionSourceText = OBFUSCATE_SOURCE("메시지", 0x8B3FEB5B8BD5C3C3ULL);
|
||||
const auto& captionSource = captionSourceText.data;
|
||||
const char* caption = DecryptName<0x8B3FEB5B8BD5C3C3ULL>(captionSource);
|
||||
constexpr std::array<char, 56> messageSource = CRYPT_NAME("장애가 발생 하였습니다. STOVE 고객센터로 문의 바랍니다.", 0xF7530137154D8FE5ULL);
|
||||
const char* message = DecryptName<0xF7530137154D8FE5ULL>(messageSource);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0x8B3FEB5B8BD5C3C3ULL, captionSource);
|
||||
constexpr std::array<char, 56> messageSource = OBFUSCATE_SOURCE("장애가 발생 하였습니다. STOVE 고객센터로 문의 바랍니다.", 0xF7530137154D8FE5ULL);
|
||||
const char* message = OBFUSCATE_DECRYPT(0xF7530137154D8FE5ULL, messageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(message).c_str(), caption, MB_OK);
|
||||
}
|
||||
}
|
||||
|
|
@ -361,10 +347,10 @@ void CategoryProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackR
|
|||
} else if (std::strcmp(categoryId.c_str(), "44C71118750747D") == 0) {
|
||||
list = 8;
|
||||
} else {
|
||||
const char captionSource[] = CRYPT_CHARS(7, "메시지", 0xC52FB5FBB94FF917ULL);
|
||||
const char* caption = DecryptName<0xC52FB5FBB94FF917ULL>(captionSource);
|
||||
constexpr std::array<char, 34> messageSource = CRYPT_NAME("등록되지 않은 카테고리입니다 (%s)", 0x17359BF953C367B3ULL);
|
||||
const char* message = DecryptName<0x17359BF953C367B3ULL>(messageSource);
|
||||
const char captionSource[] = OBFUSCATE_SOURCE_CHARS(7, "메시지", 0xC52FB5FBB94FF917ULL);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0xC52FB5FBB94FF917ULL, captionSource);
|
||||
constexpr std::array<char, 34> messageSource = OBFUSCATE_SOURCE("등록되지 않은 카테고리입니다 (%s)", 0x17359BF953C367B3ULL);
|
||||
const char* message = OBFUSCATE_DECRYPT(0x17359BF953C367B3ULL, messageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(message, categoryId.c_str()).c_str(), caption, MB_OK);
|
||||
continue;
|
||||
}
|
||||
|
|
@ -388,11 +374,11 @@ void CategoryProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackR
|
|||
} else if (std::strcmp(categoryId.c_str(), "14A6891F90E24D7") == 0) {
|
||||
list = 8;
|
||||
} else {
|
||||
constexpr auto captionSourceText = CRYPT_NAME("메시지", 0x69FD1D9733D3CFC1ULL);
|
||||
constexpr auto captionSourceText = OBFUSCATE_SOURCE("메시지", 0x69FD1D9733D3CFC1ULL);
|
||||
const auto& captionSource = captionSourceText.data;
|
||||
const char* caption = DecryptName<0x69FD1D9733D3CFC1ULL>(captionSource);
|
||||
constexpr std::array<char, 34> messageSource = CRYPT_NAME("등록되지 않은 카테고리입니다 (%s)", 0x93E7A3A1F587CDC5ULL);
|
||||
const char* message = DecryptName<0x93E7A3A1F587CDC5ULL>(messageSource);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0x69FD1D9733D3CFC1ULL, captionSource);
|
||||
constexpr std::array<char, 34> messageSource = OBFUSCATE_SOURCE("등록되지 않은 카테고리입니다 (%s)", 0x93E7A3A1F587CDC5ULL);
|
||||
const char* message = OBFUSCATE_DECRYPT(0x93E7A3A1F587CDC5ULL, messageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(message, categoryId.c_str()).c_str(), caption, MB_OK);
|
||||
continue;
|
||||
}
|
||||
|
|
@ -431,10 +417,10 @@ void CategoryProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackR
|
|||
}
|
||||
}
|
||||
} else {
|
||||
const char captionSource[] = CRYPT_CHARS(7, "메시지", 0x8B65CD61012B5931ULL);
|
||||
const char* caption = DecryptName<0x8B65CD61012B5931ULL>(captionSource);
|
||||
constexpr std::array<char, 56> messageSource = CRYPT_NAME("장애가 발생 하였습니다. STOVE 고객센터로 문의 바랍니다.", 0xF5657D1F3DE5CDC7ULL);
|
||||
const char* message = DecryptName<0xF5657D1F3DE5CDC7ULL>(messageSource);
|
||||
const char captionSource[] = OBFUSCATE_SOURCE_CHARS(7, "메시지", 0x8B65CD61012B5931ULL);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0x8B65CD61012B5931ULL, captionSource);
|
||||
constexpr std::array<char, 56> messageSource = OBFUSCATE_SOURCE("장애가 발생 하였습니다. STOVE 고객센터로 문의 바랍니다.", 0xF5657D1F3DE5CDC7ULL);
|
||||
const char* message = OBFUSCATE_DECRYPT(0xF5657D1F3DE5CDC7ULL, messageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(message).c_str(), caption, MB_OK);
|
||||
}
|
||||
}
|
||||
|
|
@ -462,10 +448,10 @@ EncryptedName<100, 0x4F1791FB1503C713ULL>& TokenCallbackFailureMessage::operator
|
|||
void InitializeCallback::operator()(Stove::PCSDK::CallbackResult callbackResult) const {
|
||||
g_stoveWaitingCallback = false;
|
||||
if (!callbackResult.GetResult().IsSuccessful()) {
|
||||
const char captionSource[] = CRYPT_CHARS(7, "메시지", 0x31D7C1EDA345E36DULL);
|
||||
const char* caption = DecryptName<0x31D7C1EDA345E36DULL>(captionSource);
|
||||
const char messageSource[] = CRYPT_CHARS(45, "필수 사전 작업이 실패하여 게임을 종료합니다.", 0xD3755DD95F47A909ULL);
|
||||
const char* message = DecryptName<0xD3755DD95F47A909ULL>(messageSource);
|
||||
const char captionSource[] = OBFUSCATE_SOURCE_CHARS(7, "메시지", 0x31D7C1EDA345E36DULL);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0x31D7C1EDA345E36DULL, captionSource);
|
||||
const char messageSource[] = OBFUSCATE_SOURCE_CHARS(45, "필수 사전 작업이 실패하여 게임을 종료합니다.", 0xD3755DD95F47A909ULL);
|
||||
const char* message = OBFUSCATE_DECRYPT(0xD3755DD95F47A909ULL, messageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(message).c_str(), caption, MB_OK);
|
||||
PostQuitMessage(0);
|
||||
}
|
||||
|
|
@ -519,9 +505,9 @@ bool CStoveMgr::Initialize() {
|
|||
}
|
||||
|
||||
Stove::PCSDK::Base::StovePCInitializeParam param;
|
||||
constexpr auto sandboxSourceText = CRYPT_NAME("/stove_sandbox", 0x490FFB43A12F0DB9ULL);
|
||||
constexpr auto sandboxSourceText = OBFUSCATE_SOURCE("/stove_sandbox", 0x490FFB43A12F0DB9ULL);
|
||||
const auto& sandboxSource = sandboxSourceText.data;
|
||||
const char* sandbox = DecryptName<0x490FFB43A12F0DB9ULL>(sandboxSource);
|
||||
const char* sandbox = OBFUSCATE_DECRYPT(0x490FFB43A12F0DB9ULL, sandboxSource);
|
||||
if (std::strstr(g_commandLine, sandbox) != nullptr) {
|
||||
this->m_environment = 1;
|
||||
param.SetEnvironment(L"SANDBOX");
|
||||
|
|
@ -529,9 +515,9 @@ bool CStoveMgr::Initialize() {
|
|||
param.SetApplicationKey(L"6b57af29764992a85cf793b01d4af15be6047715fd5f4687b23d0a1ba02337f5");
|
||||
this->m_applicationId = L"SB__SH_IPJVFX";
|
||||
} else {
|
||||
constexpr auto liveSourceText = CRYPT_NAME("/stove_live", 0x91651D81F559F971ULL);
|
||||
constexpr auto liveSourceText = OBFUSCATE_SOURCE("/stove_live", 0x91651D81F559F971ULL);
|
||||
const auto& liveSource = liveSourceText.data;
|
||||
const char* live = DecryptName<0x91651D81F559F971ULL>(liveSource);
|
||||
const char* live = OBFUSCATE_DECRYPT(0x91651D81F559F971ULL, liveSource);
|
||||
if (std::strstr(g_commandLine, live) != nullptr) {
|
||||
this->m_environment = 2;
|
||||
param.SetEnvironment(L"LIVE");
|
||||
|
|
@ -541,15 +527,15 @@ bool CStoveMgr::Initialize() {
|
|||
}
|
||||
}
|
||||
|
||||
constexpr auto skipRestartSourceText = CRYPT_NAME("/stove_cag_tool", 0x73D1674B61DF7B0BULL);
|
||||
constexpr auto skipRestartSourceText = OBFUSCATE_SOURCE("/stove_cag_tool", 0x73D1674B61DF7B0BULL);
|
||||
const auto& skipRestartSource = skipRestartSourceText.data;
|
||||
const char* skipRestart = DecryptName<0x73D1674B61DF7B0BULL>(skipRestartSource);
|
||||
const char* skipRestart = OBFUSCATE_DECRYPT(0x73D1674B61DF7B0BULL, skipRestartSource);
|
||||
if (std::strstr(g_commandLine, skipRestart) == nullptr && Base_RestartAppIfNecessary(¶m) == true) {
|
||||
constexpr auto captionSourceText = CRYPT_NAME("메시지", 0x0F0F8B6B8F9D19D1ULL);
|
||||
constexpr auto captionSourceText = OBFUSCATE_SOURCE("메시지", 0x0F0F8B6B8F9D19D1ULL);
|
||||
const auto& captionSource = captionSourceText.data;
|
||||
const char* caption = DecryptName<0x0F0F8B6B8F9D19D1ULL>(captionSource);
|
||||
constexpr std::array<char, 38> messageSource = CRYPT_NAME("Stove 클라이언트를 통해 실행해 주세요", 0xD98F03A52D35636DULL);
|
||||
const char* message = DecryptName<0xD98F03A52D35636DULL>(messageSource);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0x0F0F8B6B8F9D19D1ULL, captionSource);
|
||||
constexpr std::array<char, 38> messageSource = OBFUSCATE_SOURCE("Stove 클라이언트를 통해 실행해 주세요", 0xD98F03A52D35636DULL);
|
||||
const char* message = OBFUSCATE_DECRYPT(0xD98F03A52D35636DULL, messageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(message).c_str(), caption, MB_OK);
|
||||
return false;
|
||||
}
|
||||
|
|
@ -564,11 +550,11 @@ bool CStoveMgr::Initialize() {
|
|||
return true;
|
||||
}
|
||||
|
||||
constexpr auto captionSourceText = CRYPT_NAME("메시지", 0x812BE72BCD5707B7ULL);
|
||||
constexpr auto captionSourceText = OBFUSCATE_SOURCE("메시지", 0x812BE72BCD5707B7ULL);
|
||||
const auto& captionSource = captionSourceText.data;
|
||||
const char* caption = DecryptName<0x812BE72BCD5707B7ULL>(captionSource);
|
||||
constexpr std::array<char, 45> messageSource = CRYPT_NAME("필수 사전 작업이 실패하여 게임을 종료합니다.", 0x59278F63D79F3DA1ULL);
|
||||
const char* message = DecryptName<0x59278F63D79F3DA1ULL>(messageSource);
|
||||
const char* caption = OBFUSCATE_DECRYPT(0x812BE72BCD5707B7ULL, captionSource);
|
||||
constexpr std::array<char, 45> messageSource = OBFUSCATE_SOURCE("필수 사전 작업이 실패하여 게임을 종료합니다.", 0x59278F63D79F3DA1ULL);
|
||||
const char* message = OBFUSCATE_DECRYPT(0x59278F63D79F3DA1ULL, messageSource);
|
||||
MessageBoxA(hWnd, FormatOwnedString(message).c_str(), caption, MB_OK);
|
||||
return false;
|
||||
}
|
||||
|
|
@ -585,7 +571,7 @@ const char* CStoveMgr::GetAccessToken() {
|
|||
return this->m_accessToken;
|
||||
}
|
||||
|
||||
constexpr std::array<char, 7> source = CRYPT_NAME("메시지", 0x1D6D75EDE7CD311FULL);
|
||||
constexpr std::array<char, 7> source = OBFUSCATE_SOURCE("메시지", 0x1D6D75EDE7CD311FULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x1D6D75EDE7CD311FULL> caption(source);
|
||||
MessageBoxA(hWnd, FormatOwnedString(AccessTokenFailureMessage()().Text()).c_str(), caption.Text(), MB_OK);
|
||||
PostQuitMessage(0);
|
||||
|
|
@ -601,7 +587,7 @@ void CStoveMgr::FetchUser() {
|
|||
StringFormat(this->m_memberNumber, sizeof(this->m_memberNumber), _TRUNCATE, "%llu", user.GetMemberNumber());
|
||||
StringFormat(this->m_gameUserId, sizeof(this->m_gameUserId), _TRUNCATE, "%llu", user.GetGameUserId());
|
||||
} else {
|
||||
constexpr auto sourceText = CRYPT_NAME("메시지", 0xD1538513DF975701ULL);
|
||||
constexpr auto sourceText = OBFUSCATE_SOURCE("메시지", 0xD1538513DF975701ULL);
|
||||
const auto& source = sourceText.data;
|
||||
thread_local EncryptedName<sizeof(source), 0xD1538513DF975701ULL> caption(source);
|
||||
MessageBoxA(hWnd, FormatOwnedString(UserFailureMessage()().Text()).c_str(), caption.Text(), MB_OK);
|
||||
|
|
@ -635,21 +621,21 @@ void CStoveMgr::StartPurchase(const std::vector<ITEM_INFO>& items) {
|
|||
} while (g_stoveWaitingCallback);
|
||||
|
||||
if (this->m_purchaseUrl.size() == 0) {
|
||||
constexpr auto parametersSourceText = CRYPT_NAME("https://cs.onstove.com/service/RAGNAROK_IND", 0x69D345DB950F336DULL);
|
||||
constexpr auto parametersSourceText = OBFUSCATE_SOURCE("https://cs.onstove.com/service/RAGNAROK_IND", 0x69D345DB950F336DULL);
|
||||
const auto& parametersSource = parametersSourceText.data;
|
||||
const char* parameters = DecryptName<0x69D345DB950F336DULL>(parametersSource);
|
||||
constexpr auto fileSourceText = CRYPT_NAME("https://cs.onstove.com/service/RAGNAROK_IND", 0xC7912587FFF31B71ULL);
|
||||
const char* parameters = OBFUSCATE_DECRYPT(0x69D345DB950F336DULL, parametersSource);
|
||||
constexpr auto fileSourceText = OBFUSCATE_SOURCE("https://cs.onstove.com/service/RAGNAROK_IND", 0xC7912587FFF31B71ULL);
|
||||
const auto& fileSource = fileSourceText.data;
|
||||
const char* file = DecryptName<0xC7912587FFF31B71ULL>(fileSource);
|
||||
constexpr auto verbSourceText = CRYPT_NAME("OPEN", 0x8F1B5BFD5F6175B5ULL);
|
||||
const char* file = OBFUSCATE_DECRYPT(0xC7912587FFF31B71ULL, fileSource);
|
||||
constexpr auto verbSourceText = OBFUSCATE_SOURCE("OPEN", 0x8F1B5BFD5F6175B5ULL);
|
||||
const auto& verbSource = verbSourceText.data;
|
||||
const char* verb = DecryptName<0x8F1B5BFD5F6175B5ULL>(verbSource);
|
||||
const char* verb = OBFUSCATE_DECRYPT(0x8F1B5BFD5F6175B5ULL, verbSource);
|
||||
ShellExecuteA(nullptr, verb, file, parameters, nullptr, SW_SHOWNORMAL);
|
||||
} else {
|
||||
const char* url = this->m_purchaseUrl.c_str();
|
||||
constexpr auto verbSourceText = CRYPT_NAME("OPEN", 0x9B17C9EFDBB39F2FULL);
|
||||
constexpr auto verbSourceText = OBFUSCATE_SOURCE("OPEN", 0x9B17C9EFDBB39F2FULL);
|
||||
const auto& verbSource = verbSourceText.data;
|
||||
const char* verb = DecryptName<0x9B17C9EFDBB39F2FULL>(verbSource);
|
||||
const char* verb = OBFUSCATE_DECRYPT(0x9B17C9EFDBB39F2FULL, verbSource);
|
||||
ShellExecuteA(nullptr, verb, url, url, nullptr, SW_SHOWNORMAL);
|
||||
if (g_windowMgr.Confirm(PurchaseCheckingMessage()().Text(), 2, true, false, 0, "Message", 250, 170, 0) == 187) {
|
||||
IAP_ConfirmPurchase((static_cast<std::int64_t>(this->m_purchaseIdHigh) << 32) | static_cast<std::uint32_t>(this->m_purchaseIdLow), OnStovePurchaseConfirmed);
|
||||
|
|
|
|||
|
|
@ -123,13 +123,6 @@ const int s_monsterJobIds[48] = {
|
|||
9100786, 9100787, 9100788, 9100789, 9100790, 9100791, 9100792, 9100793
|
||||
};
|
||||
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptText(const std::uint8_t (&source)[Length]) {
|
||||
thread_local EncryptedName<Length, Key> text(source);
|
||||
return text.Text();
|
||||
}
|
||||
|
||||
// OFFSET: 0x00ACFCF0
|
||||
// FUNCTION: fn_17807
|
||||
const char* GetLicenceText() {
|
||||
|
|
@ -438,8 +431,8 @@ void InitializeLanguage() {
|
|||
// OFFSET: 0x00AD1C90
|
||||
// FUNCTION: fn_17817
|
||||
void InitializeServiceConfiguration() {
|
||||
const std::uint8_t portSource[] = CRYPT_BYTES(5, "6900", 0xEB3D4FAB0FC183DBULL);
|
||||
g_servicePort = DecryptText<0xEB3D4FAB0FC183DBULL>(portSource);
|
||||
const std::uint8_t portSource[] = OBFUSCATE_SOURCE_BYTES(5, "6900", 0xEB3D4FAB0FC183DBULL);
|
||||
g_servicePort = OBFUSCATE_DECRYPT(0xEB3D4FAB0FC183DBULL, portSource);
|
||||
|
||||
g_webPageUrl = OBFUSCATE_TEXT("http://www.ragnarok.co.kr", 0xFFBF43D1FFD5FF49ULL);
|
||||
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
#include "Client/Session/Session.h"
|
||||
#include "Network/Connection/Connection.h"
|
||||
#include "Utility/Cipher/CryptName.h"
|
||||
#include "Utility/Cipher/Obfuscate.h"
|
||||
|
||||
#include "Utility/Cipher/EncryptedName.h"
|
||||
|
||||
|
|
@ -59,13 +60,13 @@ void CEmblemDataMgr::RefreshUrls(LuaScript& settings, LuaScript& tables, const c
|
|||
|
||||
if (!base.empty()) {
|
||||
{
|
||||
constexpr std::array<std::uint8_t, 15> sourceArray = CRYPT_NAME("/emblem/upload", 0x2FF3C5036D070127ULL);
|
||||
constexpr std::array<std::uint8_t, 15> sourceArray = OBFUSCATE_SOURCE("/emblem/upload", 0x2FF3C5036D070127ULL);
|
||||
const std::uint8_t (&source)[15] = sourceArray._Elems;
|
||||
thread_local EncryptedName<sizeof(source), 0x2FF3C5036D070127ULL> name(source);
|
||||
this->m_uploadUrl = base + name.Text();
|
||||
}
|
||||
{
|
||||
const std::uint8_t source[] = CRYPT_BYTES(17, "/emblem/download", 0x93E7A3A1F587CDC5ULL);
|
||||
const std::uint8_t source[] = OBFUSCATE_SOURCE_BYTES(17, "/emblem/download", 0x93E7A3A1F587CDC5ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x93E7A3A1F587CDC5ULL> name(source);
|
||||
this->m_downloadUrl = base + name.Text();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
#include "Utility/Async/AsyncDiagnostic.h"
|
||||
#include "Utility/Cipher/XorBytes.h"
|
||||
#include "Utility/Cipher/LocalEncryptedName.h"
|
||||
#include "Utility/Cipher/Obfuscate.h"
|
||||
|
||||
#include "Resource/MSGSTRINGID.h"
|
||||
#include <json/reader.h>
|
||||
|
|
@ -21,12 +22,6 @@ namespace {
|
|||
#pragma pack(pop)
|
||||
static_assert(sizeof(EmblemVersionPacket) == 10);
|
||||
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptName(const std::uint8_t (&source)[Length]) {
|
||||
thread_local EncryptedName<Length, Key> name(source);
|
||||
return name.Text();
|
||||
}
|
||||
}
|
||||
|
||||
// OFFSET: 0x005EBAD0
|
||||
|
|
@ -43,9 +38,9 @@ void CEmblemDataMgr::CompleteUpload(AsyncDiagnostic diagnostic, std::string resp
|
|||
return;
|
||||
}
|
||||
|
||||
switch (root[DecryptName<0xC52FB5FBB94FF917ULL>({0x43, 0x80, 0x3F, 0xDC, 0xFB})].asInt()) {
|
||||
switch (root[(OBFUSCATE_DECRYPT_BYTES(0xC52FB5FBB94FF917ULL, 5, {0x43, 0x80, 0x3F, 0xDC, 0xFB}))].asInt()) {
|
||||
case 1: {
|
||||
EmblemVersionPacket packet{0x0B46, guildId, root[DecryptName<0x812BE72BCD5707B7ULL>({0xC1, 0x62, 0x25, 0xBE, 0x42, 0x88, 0x45, 0x81})].asInt()};
|
||||
EmblemVersionPacket packet{0x0B46, guildId, root[(OBFUSCATE_DECRYPT_BYTES(0x812BE72BCD5707B7ULL, 8, {0xC1, 0x62, 0x25, 0xBE, 0x42, 0x88, 0x45, 0x81}))].asInt()};
|
||||
GetRagConnection().Send(reinterpret_cast<PacketLengths&>(GetRagConnection()).FixedLength(packet.id), &packet);
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,13 +21,6 @@ namespace {
|
|||
std::string message = text;
|
||||
return AsyncDiagnostic(&success, &message, sourceFile, &line);
|
||||
}
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptName(const std::uint8_t (&source)[Length]) {
|
||||
thread_local EncryptedName<Length, Key> name(source);
|
||||
return name.Text();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// GLOBAL: gl_25604
|
||||
|
|
@ -77,82 +70,82 @@ bool CLoadPartyListAsyncWork::Execute() {
|
|||
StringFormat(page, sizeof(page), _TRUNCATE, "%d", this->m_page);
|
||||
const std::string world = CCURLMgr::GetInstance()->ToUtf8(this->m_world);
|
||||
CCURLPostHander handler(this->m_url);
|
||||
constexpr std::array<std::uint8_t, 4> gidArray = CRYPT_NAME("GID", 0x2F2701A7E56D3D89ULL);
|
||||
constexpr std::array<std::uint8_t, 4> gidArray = OBFUSCATE_SOURCE("GID", 0x2F2701A7E56D3D89ULL);
|
||||
const std::uint8_t (&gid)[4] = gidArray._Elems;
|
||||
handler.AddField(DecryptName<0x2F2701A7E56D3D89ULL>(gid), character, 4);
|
||||
constexpr std::array<std::uint8_t, 4> aidArray = CRYPT_NAME("AID", 0x6B3301E1A3079125ULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0x2F2701A7E56D3D89ULL, gid), character, 4);
|
||||
constexpr std::array<std::uint8_t, 4> aidArray = OBFUSCATE_SOURCE("AID", 0x6B3301E1A3079125ULL);
|
||||
const std::uint8_t (&aid)[4] = aidArray._Elems;
|
||||
handler.AddField(DecryptName<0x6B3301E1A3079125ULL>(aid), account, 4);
|
||||
constexpr std::array<std::uint8_t, 10> worldNameArray = CRYPT_NAME("WorldName", 0x71B7691737C5A1AFULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0x6B3301E1A3079125ULL, aid), account, 4);
|
||||
constexpr std::array<std::uint8_t, 10> worldNameArray = OBFUSCATE_SOURCE("WorldName", 0x71B7691737C5A1AFULL);
|
||||
const std::uint8_t (&worldName)[10] = worldNameArray._Elems;
|
||||
handler.AddField(DecryptName<0x71B7691737C5A1AFULL>(worldName), world, 4);
|
||||
const std::uint8_t authToken[] = CRYPT_BYTES(10, "AuthToken", 0xC39FB559A17D3963ULL);
|
||||
handler.AddField(DecryptName<0xC39FB559A17D3963ULL>(authToken), this->m_token, 4);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0x71B7691737C5A1AFULL, worldName), world, 4);
|
||||
const std::uint8_t authToken[] = OBFUSCATE_SOURCE_BYTES(10, "AuthToken", 0xC39FB559A17D3963ULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0xC39FB559A17D3963ULL, authToken), this->m_token, 4);
|
||||
|
||||
switch (this->m_search) {
|
||||
case 0: {
|
||||
constexpr std::array<std::uint8_t, 5> pageNameArray = CRYPT_NAME("page", 0x2B8725D7E95325F5ULL);
|
||||
constexpr std::array<std::uint8_t, 5> pageNameArray = OBFUSCATE_SOURCE("page", 0x2B8725D7E95325F5ULL);
|
||||
const std::uint8_t (&pageName)[5] = pageNameArray._Elems;
|
||||
handler.AddField(DecryptName<0x2B8725D7E95325F5ULL>(pageName), page, 4);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0x2B8725D7E95325F5ULL, pageName), page, 4);
|
||||
break;
|
||||
}
|
||||
case 1: {
|
||||
char minimum[10] = {};
|
||||
StringFormat(minimum, sizeof(minimum), _TRUNCATE, "%d", this->m_filter.minimumLevel);
|
||||
const std::uint8_t minLevel[] = CRYPT_BYTES(6, "MinLV", 0x899D11BB83695B0DULL);
|
||||
handler.AddField(DecryptName<0x899D11BB83695B0DULL>(minLevel), minimum, 4);
|
||||
const std::uint8_t minLevel[] = OBFUSCATE_SOURCE_BYTES(6, "MinLV", 0x899D11BB83695B0DULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0x899D11BB83695B0DULL, minLevel), minimum, 4);
|
||||
char maximum[10] = {};
|
||||
StringFormat(maximum, sizeof(maximum), _TRUNCATE, "%d", this->m_filter.maximumLevel);
|
||||
const std::uint8_t maxLevel[] = CRYPT_BYTES(6, "MaxLV", 0xBDADDD87C5A50B6BULL);
|
||||
handler.AddField(DecryptName<0xBDADDD87C5A50B6BULL>(maxLevel), maximum, 4);
|
||||
const std::uint8_t maxLevel[] = OBFUSCATE_SOURCE_BYTES(6, "MaxLV", 0xBDADDD87C5A50B6BULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0xBDADDD87C5A50B6BULL, maxLevel), maximum, 4);
|
||||
|
||||
if (this->m_filter.tanker) {
|
||||
const std::uint8_t tankerOn[] = CRYPT_BYTES(2, "1", 0x5FFD7FABB5D1EF57ULL);
|
||||
const std::uint8_t tanker[] = CRYPT_BYTES(7, "Tanker", 0x7989830DE73B9DBDULL);
|
||||
handler.AddField(DecryptName<0x7989830DE73B9DBDULL>(tanker), DecryptName<0x5FFD7FABB5D1EF57ULL>(tankerOn), 4);
|
||||
const std::uint8_t tankerOn[] = OBFUSCATE_SOURCE_BYTES(2, "1", 0x5FFD7FABB5D1EF57ULL);
|
||||
const std::uint8_t tanker[] = OBFUSCATE_SOURCE_BYTES(7, "Tanker", 0x7989830DE73B9DBDULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0x7989830DE73B9DBDULL, tanker), OBFUSCATE_DECRYPT(0x5FFD7FABB5D1EF57ULL, tankerOn), 4);
|
||||
}
|
||||
|
||||
if (this->m_filter.dealer) {
|
||||
const std::uint8_t dealerOn[] = CRYPT_BYTES(2, "1", 0xF535E561137F138DULL);
|
||||
const std::uint8_t dealer[] = CRYPT_BYTES(7, "Dealer", 0xA7471985F93F9BDFULL);
|
||||
handler.AddField(DecryptName<0xA7471985F93F9BDFULL>(dealer), DecryptName<0xF535E561137F138DULL>(dealerOn), 4);
|
||||
const std::uint8_t dealerOn[] = OBFUSCATE_SOURCE_BYTES(2, "1", 0xF535E561137F138DULL);
|
||||
const std::uint8_t dealer[] = OBFUSCATE_SOURCE_BYTES(7, "Dealer", 0xA7471985F93F9BDFULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0xA7471985F93F9BDFULL, dealer), OBFUSCATE_DECRYPT(0xF535E561137F138DULL, dealerOn), 4);
|
||||
}
|
||||
|
||||
if (this->m_filter.healer) {
|
||||
const std::uint8_t healerOn[] = CRYPT_BYTES(2, "1", 0x01E7898D9D235DDFULL);
|
||||
const std::uint8_t healer[] = CRYPT_BYTES(7, "Healer", 0xD3E5516F89F161D1ULL);
|
||||
handler.AddField(DecryptName<0xD3E5516F89F161D1ULL>(healer), DecryptName<0x01E7898D9D235DDFULL>(healerOn), 4);
|
||||
const std::uint8_t healerOn[] = OBFUSCATE_SOURCE_BYTES(2, "1", 0x01E7898D9D235DDFULL);
|
||||
const std::uint8_t healer[] = OBFUSCATE_SOURCE_BYTES(7, "Healer", 0xD3E5516F89F161D1ULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0xD3E5516F89F161D1ULL, healer), OBFUSCATE_DECRYPT(0x01E7898D9D235DDFULL, healerOn), 4);
|
||||
}
|
||||
|
||||
if (this->m_filter.assist) {
|
||||
const std::uint8_t assistOn[] = CRYPT_BYTES(2, "1", 0x9DEFC105A1EB2F71ULL);
|
||||
const std::uint8_t assist[] = CRYPT_BYTES(7, "Assist", 0x0DF5B33D9F21EB79ULL);
|
||||
handler.AddField(DecryptName<0x0DF5B33D9F21EB79ULL>(assist), DecryptName<0x9DEFC105A1EB2F71ULL>(assistOn), 4);
|
||||
const std::uint8_t assistOn[] = OBFUSCATE_SOURCE_BYTES(2, "1", 0x9DEFC105A1EB2F71ULL);
|
||||
const std::uint8_t assist[] = OBFUSCATE_SOURCE_BYTES(7, "Assist", 0x0DF5B33D9F21EB79ULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0x0DF5B33D9F21EB79ULL, assist), OBFUSCATE_DECRYPT(0x9DEFC105A1EB2F71ULL, assistOn), 4);
|
||||
}
|
||||
|
||||
if (this->m_filter.type != 0) {
|
||||
char type[10] = {};
|
||||
StringFormat(type, sizeof(type), _TRUNCATE, "%d", this->m_filter.type);
|
||||
const std::uint8_t typeName[] = CRYPT_BYTES(5, "Type", 0x6961FF056999A303ULL);
|
||||
handler.AddField(DecryptName<0x6961FF056999A303ULL>(typeName), type, 4);
|
||||
const std::uint8_t typeName[] = OBFUSCATE_SOURCE_BYTES(5, "Type", 0x6961FF056999A303ULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0x6961FF056999A303ULL, typeName), type, 4);
|
||||
}
|
||||
|
||||
if (!this->m_filter.memo.empty()) {
|
||||
std::string memo = CCURLMgr::GetInstance()->ToUtf8(this->m_filter.memo);
|
||||
const std::uint8_t memoName[] = CRYPT_BYTES(5, "Memo", 0xBD3F430159B551FDULL);
|
||||
handler.AddField(DecryptName<0xBD3F430159B551FDULL>(memoName), memo, 4);
|
||||
const std::uint8_t memoName[] = OBFUSCATE_SOURCE_BYTES(5, "Memo", 0xBD3F430159B551FDULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0xBD3F430159B551FDULL, memoName), memo, 4);
|
||||
}
|
||||
|
||||
const std::uint8_t pageName[] = CRYPT_BYTES(5, "page", 0xC7FB6DF18577D34BULL);
|
||||
handler.AddField(DecryptName<0xC7FB6DF18577D34BULL>(pageName), page, 4);
|
||||
const std::uint8_t pageName[] = OBFUSCATE_SOURCE_BYTES(5, "page", 0xC7FB6DF18577D34BULL);
|
||||
handler.AddField(OBFUSCATE_DECRYPT(0xC7FB6DF18577D34BULL, pageName), page, 4);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (handler.Perform() == 0) {
|
||||
this->m_response = CCURLMgr::GetInstance()->FromUtf8(handler.Response());
|
||||
const std::uint8_t success[] = CRYPT_BYTES(8, "success", 0x5B832361BDA77197ULL);
|
||||
AsyncDiagnostic diagnostic = Diagnostic(true, DecryptName<0x5B832361BDA77197ULL>(success), 138);
|
||||
const std::uint8_t success[] = OBFUSCATE_SOURCE_BYTES(8, "success", 0x5B832361BDA77197ULL);
|
||||
AsyncDiagnostic diagnostic = Diagnostic(true, OBFUSCATE_DECRYPT(0x5B832361BDA77197ULL, success), 138);
|
||||
this->m_diagnostic = std::move(diagnostic);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -344,7 +344,7 @@ void CSkillAction_DR_WERERAPTOR::OnSkillEffect(int level, CGameActor* source, CG
|
|||
}
|
||||
|
||||
g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto effectSourceText = CRYPT_NAME("wereraptor", 0xD3755DD95F47A909ULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("wereraptor", 0xD3755DD95F47A909ULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0xD3755DD95F47A909ULL> effectName(effectSource);
|
||||
return effectName.Text();
|
||||
|
|
@ -448,7 +448,7 @@ void CSkillAction_DR_HUNGER::OnSkillEffect(int level, CGameActor* source, CGameA
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("hunger_target", 0x3375B1C7DBB5FD55ULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("hunger_target", 0x3375B1C7DBB5FD55ULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x3375B1C7DBB5FD55ULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -463,7 +463,7 @@ void CSkillAction_DR_HUNGER::OnSkillHit(int caster, CGameActor* target, CGameAct
|
|||
return;
|
||||
}
|
||||
|
||||
constexpr auto effectSourceText = CRYPT_NAME("hunger", 0x1D6D75EDE7CD311FULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("hunger", 0x1D6D75EDE7CD311FULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0x1D6D75EDE7CD311FULL> effectName(effectSource);
|
||||
g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
|
||||
|
|
@ -591,12 +591,12 @@ void CSkillAction_DR_LOW_FLIGHT::OnSkillEffect(int level, CGameActor* source, CG
|
|||
|
||||
const std::string effectName(
|
||||
(direction & 1) != 0 ? std::string([] {
|
||||
constexpr auto horizonSourceText = CRYPT_NAME("low_flight_horizon", 0x8B65CD61012B5931ULL);
|
||||
constexpr auto horizonSourceText = OBFUSCATE_SOURCE("low_flight_horizon", 0x8B65CD61012B5931ULL);
|
||||
const auto& horizonSource = horizonSourceText.data;
|
||||
thread_local EncryptedName<sizeof(horizonSource), 0x8B65CD61012B5931ULL> horizonName(horizonSource);
|
||||
return horizonName.Text();
|
||||
}()) : std::string([] {
|
||||
constexpr auto verticalSourceText = CRYPT_NAME("low_flight_vertical", 0xF7530137154D8FE5ULL);
|
||||
constexpr auto verticalSourceText = OBFUSCATE_SOURCE("low_flight_vertical", 0xF7530137154D8FE5ULL);
|
||||
const auto& verticalSource = verticalSourceText.data;
|
||||
thread_local EncryptedName<sizeof(verticalSource), 0xF7530137154D8FE5ULL> verticalName(verticalSource);
|
||||
return verticalName.Text();
|
||||
|
|
@ -625,7 +625,7 @@ void CSkillAction_DR_LOW_FLIGHT::OnSkillEffect(int level, CGameActor* source, CG
|
|||
|
||||
effects = g_effectMgr;
|
||||
if (CEffect* effect = effects->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bottomSourceText = CRYPT_NAME("low_flight_bottom", 0x69FD1D9733D3CFC1ULL);
|
||||
constexpr auto bottomSourceText = OBFUSCATE_SOURCE("low_flight_bottom", 0x69FD1D9733D3CFC1ULL);
|
||||
const auto& bottomSource = bottomSourceText.data;
|
||||
thread_local EncryptedName<sizeof(bottomSource), 0x69FD1D9733D3CFC1ULL> bottomName(bottomSource);
|
||||
return bottomName.Text();
|
||||
|
|
@ -658,7 +658,7 @@ void CSkillAction_DR_NATURE_SHIELD::OnSkillCast(int level, CGameActor* source) {
|
|||
// FUNCTION: fn_04504
|
||||
void CSkillAction_DR_NATURE_SHIELD::OnSkillEffect(int level, CGameActor* source, CGameActor* target) {
|
||||
g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("nature_shield", 0xF5657D1F3DE5CDC7ULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("nature_shield", 0xF5657D1F3DE5CDC7ULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0xF5657D1F3DE5CDC7ULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -754,7 +754,7 @@ int CEfstAction_THUNDERING_ROD::GetEffectId(int efstId, int argument4) {
|
|||
if (static_cast<unsigned int>(step) <= 5) {
|
||||
std::string suffix = std::format("{:02}", step);
|
||||
return CEZ2STREffectMgr::GetInstance()->EffectId(std::string([] {
|
||||
constexpr std::array<char, 16> prefixSource = CRYPT_NAME("thundering_rod_", 0x0BEB63A5C905B3A7ULL);
|
||||
constexpr std::array<char, 16> prefixSource = OBFUSCATE_SOURCE("thundering_rod_", 0x0BEB63A5C905B3A7ULL);
|
||||
thread_local EncryptedName<sizeof(prefixSource), 0x0BEB63A5C905B3A7ULL> prefixName(prefixSource);
|
||||
return prefixName.Text();
|
||||
}()) + suffix);
|
||||
|
|
@ -810,7 +810,7 @@ void CSkillAction_DR_TRUTH_OF_EARTH::OnSkillEffect(int level, CGameActor* source
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("truth_of_earth", 0xC7912587FFF31B71ULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("truth_of_earth", 0xC7912587FFF31B71ULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0xC7912587FFF31B71ULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -818,7 +818,7 @@ void CSkillAction_DR_TRUTH_OF_EARTH::OnSkillEffect(int level, CGameActor* source
|
|||
|
||||
effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("truth_of_earth_bottom", 0x69D345DB950F336DULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("truth_of_earth_bottom", 0x69D345DB950F336DULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x69D345DB950F336DULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -866,14 +866,14 @@ void CSkillAction_DR_TRUTH_OF_ICE::OnSkillEffect(int level, CGameActor* source,
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr std::array<char, 13> bytes = CRYPT_NAME("truth_of_ice", 0x2D394DBD0F332733ULL);
|
||||
constexpr std::array<char, 13> bytes = OBFUSCATE_SOURCE("truth_of_ice", 0x2D394DBD0F332733ULL);
|
||||
thread_local EncryptedName<sizeof(bytes), 0x2D394DBD0F332733ULL> name(bytes);
|
||||
return name.Text();
|
||||
}()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0);
|
||||
|
||||
effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr std::array<char, 20> bytes = CRYPT_NAME("truth_of_ice_bottom", 0x151F77EBEBBB2147ULL);
|
||||
constexpr std::array<char, 20> bytes = OBFUSCATE_SOURCE("truth_of_ice_bottom", 0x151F77EBEBBB2147ULL);
|
||||
thread_local EncryptedName<sizeof(bytes), 0x151F77EBEBBB2147ULL> name(bytes);
|
||||
return name.Text();
|
||||
}()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0);
|
||||
|
|
@ -920,14 +920,14 @@ void CSkillAction_DR_TRUTH_OF_WIND::OnSkillEffect(int level, CGameActor* source,
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr std::array<char, 14> bytes = CRYPT_NAME("truth_of_wind", 0x61FF87ED7BF39BE1ULL);
|
||||
constexpr std::array<char, 14> bytes = OBFUSCATE_SOURCE("truth_of_wind", 0x61FF87ED7BF39BE1ULL);
|
||||
thread_local EncryptedName<sizeof(bytes), 0x61FF87ED7BF39BE1ULL> name(bytes);
|
||||
return name.Text();
|
||||
}()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
|
||||
|
||||
effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr std::array<char, 21> bytes = CRYPT_NAME("truth_of_wind_bottom", 0x7D993F650D2785FFULL);
|
||||
constexpr std::array<char, 21> bytes = OBFUSCATE_SOURCE("truth_of_wind_bottom", 0x7D993F650D2785FFULL);
|
||||
thread_local EncryptedName<sizeof(bytes), 0x7D993F650D2785FFULL> name(bytes);
|
||||
return name.Text();
|
||||
}()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
|
||||
|
|
@ -974,7 +974,7 @@ void CSkillAction_DR_CUTTING_WIND::OnSkillEffect(int level, CGameActor* source,
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
if (CEffect* effect = effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("cutting_wind", 0x4F1791FB1503C713ULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("cutting_wind", 0x4F1791FB1503C713ULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x4F1791FB1503C713ULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -991,7 +991,7 @@ void CSkillAction_DR_CUTTING_WIND::OnSkillDamage(int level, CGameActor* source,
|
|||
}
|
||||
|
||||
g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr std::array<std::uint8_t, 17> effectSourceArray = CRYPT_NAME("cutting_wind_hit", 0xA1A55B4D1597EDD3ULL);
|
||||
constexpr std::array<std::uint8_t, 17> effectSourceArray = OBFUSCATE_SOURCE("cutting_wind_hit", 0xA1A55B4D1597EDD3ULL);
|
||||
const std::uint8_t (&effectSource)[17] = effectSourceArray._Elems;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0xA1A55B4D1597EDD3ULL> effectName(effectSource);
|
||||
return effectName.Text();
|
||||
|
|
@ -1029,7 +1029,7 @@ void CSkillAction_DR_WIND_BOMB::OnSkillEffect(int level, CGameActor* source, CGa
|
|||
static_cast<CBezierArcThrowEffect*>(effect)->SetTarget(target->render.position);
|
||||
}
|
||||
|
||||
constexpr auto effectSourceText = CRYPT_NAME("wind_bomb_main", 0xD1538513DF975701ULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("wind_bomb_main", 0xD1538513DF975701ULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0xD1538513DF975701ULL> effectName(effectSource);
|
||||
EffectLists* effects = g_effectMgr;
|
||||
|
|
@ -1047,7 +1047,7 @@ void CSkillAction_DR_WIND_BOMB::OnSkillDamage(int level, CGameActor* source, CGa
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("wind_bomb_hit", 0x91E147EBBD47C39FULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("wind_bomb_hit", 0x91E147EBBD47C39FULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x91E147EBBD47C39FULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -1063,7 +1063,7 @@ void CSkillAction_DR_AROUND_FLOWER::OnSkillEffect(int level, CGameActor* source,
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("around_flower", 0x6DED3DD1CF75AD9BULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("around_flower", 0x6DED3DD1CF75AD9BULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x6DED3DD1CF75AD9BULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -1071,7 +1071,7 @@ void CSkillAction_DR_AROUND_FLOWER::OnSkillEffect(int level, CGameActor* source,
|
|||
|
||||
effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("around_flower_bottom", 0x49C3759B77DBD3C1ULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("around_flower_bottom", 0x49C3759B77DBD3C1ULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x49C3759B77DBD3C1ULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -1087,14 +1087,14 @@ void CSkillAction_DR_EARTH_FLOWER::OnSkillEffect(int level, CGameActor* source,
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr std::array<char, 13> bytes = CRYPT_NAME("earth_flower", 0x1BF915E1F37DFDFDULL);
|
||||
constexpr std::array<char, 13> bytes = OBFUSCATE_SOURCE("earth_flower", 0x1BF915E1F37DFDFDULL);
|
||||
thread_local EncryptedName<sizeof(bytes), 0x1BF915E1F37DFDFDULL> name(bytes);
|
||||
return name.Text();
|
||||
}()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0);
|
||||
|
||||
effects = g_effectMgr;
|
||||
effects->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr std::array<char, 20> bytes = CRYPT_NAME("earth_flower_bottom", 0x01FF9313695DD9DFULL);
|
||||
constexpr std::array<char, 20> bytes = OBFUSCATE_SOURCE("earth_flower_bottom", 0x01FF9313695DD9DFULL);
|
||||
thread_local EncryptedName<sizeof(bytes), 0x01FF9313695DD9DFULL> name(bytes);
|
||||
return name.Text();
|
||||
}()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0);
|
||||
|
|
@ -1108,7 +1108,7 @@ void CSkillAction_DR_ICE_CLOUD::OnSkillEffect(int level, CGameActor* source, CGa
|
|||
}
|
||||
|
||||
g_effectMgr->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto effectSourceText = CRYPT_NAME("ice_cloud", 0x474DC581D5E98357ULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("ice_cloud", 0x474DC581D5E98357ULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0x474DC581D5E98357ULL> effectName(effectSource);
|
||||
return effectName.Text();
|
||||
|
|
@ -1123,7 +1123,7 @@ void CSkillAction_DR_ICE_TOTEM::OnSkillEffect(int level, CGameActor* source, CGa
|
|||
}
|
||||
|
||||
g_effectMgr->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto effectSourceText = CRYPT_NAME("ice_totem", 0x3F557BE333F95F6DULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("ice_totem", 0x3F557BE333F95F6DULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0x3F557BE333F95F6DULL> effectName(effectSource);
|
||||
return effectName.Text();
|
||||
|
|
@ -1146,7 +1146,7 @@ void CSkillAction_DR_WEREWOLF::OnSkillEffect(int level, CGameActor* source, CGam
|
|||
return;
|
||||
}
|
||||
|
||||
constexpr auto effectSourceText = CRYPT_NAME("werewolf", 0x490FFB43A12F0DB9ULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("werewolf", 0x490FFB43A12F0DB9ULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0x490FFB43A12F0DB9ULL> effectName(effectSource);
|
||||
g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
|
||||
|
|
@ -1173,7 +1173,7 @@ void CSkillAction_DR_ENRAGE_WOLF::OnSkillEffect(int level, CGameActor* source, C
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("enrage_wolf", 0x31D7C1EDA345E36DULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("enrage_wolf", 0x31D7C1EDA345E36DULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x31D7C1EDA345E36DULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -1187,7 +1187,7 @@ void CSkillAction_DR_BLOOD_HOWLING::OnSkillEffect(int level, CGameActor* source,
|
|||
return;
|
||||
}
|
||||
|
||||
constexpr auto effectSourceText = CRYPT_NAME("blood_howling", 0xD98F03A52D35636DULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("blood_howling", 0xD98F03A52D35636DULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0xD98F03A52D35636DULL> effectName(effectSource);
|
||||
EffectLists* effects = g_effectMgr;
|
||||
|
|
@ -1201,7 +1201,7 @@ void CSkillAction_DR_NOMERCY_CLAW::OnSkillEffect(int level, CGameActor* source,
|
|||
return;
|
||||
}
|
||||
|
||||
constexpr auto effectSourceText = CRYPT_NAME("nomercy_claw", 0x0F0F8B6B8F9D19D1ULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("nomercy_claw", 0x0F0F8B6B8F9D19D1ULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0x0F0F8B6B8F9D19D1ULL> effectName(effectSource);
|
||||
EffectLists* effects = g_effectMgr;
|
||||
|
|
@ -1215,7 +1215,7 @@ void CSkillAction_DR_ENRAGE_RAPTOR::OnSkillEffect(int level, CGameActor* source,
|
|||
return;
|
||||
}
|
||||
|
||||
constexpr auto effectSourceText = CRYPT_NAME("enrage_raptor", 0x812BE72BCD5707B7ULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("enrage_raptor", 0x812BE72BCD5707B7ULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0x812BE72BCD5707B7ULL> effectName(effectSource);
|
||||
EffectLists* effects = g_effectMgr;
|
||||
|
|
@ -1230,7 +1230,7 @@ void CSkillAction_DR_PREENING::OnSkillEffect(int level, CGameActor* source, CGam
|
|||
}
|
||||
|
||||
g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto effectSourceText = CRYPT_NAME("preening", 0xC52FB5FBB94FF917ULL);
|
||||
constexpr auto effectSourceText = OBFUSCATE_SOURCE("preening", 0xC52FB5FBB94FF917ULL);
|
||||
const auto& effectSource = effectSourceText.data;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0xC52FB5FBB94FF917ULL> effectName(effectSource);
|
||||
return effectName.Text();
|
||||
|
|
@ -1250,7 +1250,7 @@ void CSkillAction_DR_CRUEL_BITE::OnSkillEffect(int level, CGameActor* source, CG
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
effects->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("cruel_bite", 0x59278F63D79F3DA1ULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("cruel_bite", 0x59278F63D79F3DA1ULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x59278F63D79F3DA1ULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
@ -1266,7 +1266,7 @@ void CSkillAction_DR_SHOOTING_FEATHER::OnSkillEffect(int level, CGameActor* sour
|
|||
|
||||
EffectLists* effects = g_effectMgr;
|
||||
if (CEffect* effect = effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
|
||||
constexpr auto bytesText = CRYPT_NAME("shooting_feather", 0x93E7A3A1F587CDC5ULL);
|
||||
constexpr auto bytesText = OBFUSCATE_SOURCE("shooting_feather", 0x93E7A3A1F587CDC5ULL);
|
||||
const auto& bytes = bytesText.data;
|
||||
thread_local EncryptedName<sizeof(bytes), 0x93E7A3A1F587CDC5ULL> name(bytes);
|
||||
return name.Text();
|
||||
|
|
|
|||
|
|
@ -908,7 +908,7 @@ void CSkillAction_KR_NASTY_SLASH::OnSkillEffect(int level, CGameActor* source, C
|
|||
}
|
||||
|
||||
const float angle = ScreenAngle(&source->render.position.x, &target->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values);
|
||||
constexpr std::array<std::uint8_t, 12> effectSourceArray = CRYPT_NAME("nasty_slash", 0x2FF3C5036D070127ULL);
|
||||
constexpr std::array<std::uint8_t, 12> effectSourceArray = OBFUSCATE_SOURCE("nasty_slash", 0x2FF3C5036D070127ULL);
|
||||
const std::uint8_t (&effectSource)[12] = effectSourceArray._Elems;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0x2FF3C5036D070127ULL> effectName(effectSource);
|
||||
if (CEffect* effect = g_effectMgr->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0)) {
|
||||
|
|
@ -959,7 +959,7 @@ void CSkillAction_KR_IRON_HOWLING::OnSkillEffect(int level, CGameActor* source,
|
|||
return;
|
||||
}
|
||||
|
||||
constexpr std::array<std::uint8_t, 13> effectSourceArray = CRYPT_NAME("iron_howling", 0x91E147EBBD47C39FULL);
|
||||
constexpr std::array<std::uint8_t, 13> effectSourceArray = OBFUSCATE_SOURCE("iron_howling", 0x91E147EBBD47C39FULL);
|
||||
const std::uint8_t (&effectSource)[13] = effectSourceArray._Elems;
|
||||
thread_local EncryptedName<sizeof(effectSource), 0x91E147EBBD47C39FULL> effectName(effectSource);
|
||||
EffectLists* effects = g_effectMgr;
|
||||
|
|
|
|||
|
|
@ -19,13 +19,6 @@
|
|||
#include <new>
|
||||
|
||||
namespace {
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptText(const std::uint8_t (&source)[Length]) {
|
||||
thread_local EncryptedName<Length, Key> text(source);
|
||||
return text.Text();
|
||||
}
|
||||
|
||||
// INLINED
|
||||
const char* DefaultAccountName() {
|
||||
return OBFUSCATE_BYTES_TEXT("unknown", 0x1D6D75EDE7CD311FULL);
|
||||
|
|
@ -96,19 +89,19 @@ void CAccountLinkedUserDataMgr::CompleteLoad(
|
|||
Json::Value root;
|
||||
Json::Reader reader;
|
||||
if (reader.parse(response, root, true)) {
|
||||
constexpr std::array<std::uint8_t, 5> typeSourceArray = CRYPT_NAME("Type", 0xC52FB5FBB94FF917ULL);
|
||||
constexpr std::array<std::uint8_t, 5> typeSourceArray = OBFUSCATE_SOURCE("Type", 0xC52FB5FBB94FF917ULL);
|
||||
const std::uint8_t (&typeSource)[5] = typeSourceArray._Elems;
|
||||
switch (root[DecryptText<0xC52FB5FBB94FF917ULL>(typeSource)].asInt()) {
|
||||
switch (root[(OBFUSCATE_DECRYPT(0xC52FB5FBB94FF917ULL, typeSource))].asInt()) {
|
||||
case 1: {
|
||||
constexpr std::array<std::uint8_t, 5> whisperSourceArray = CRYPT_NAME("data", 0x93E7A3A1F587CDC5ULL);
|
||||
constexpr std::array<std::uint8_t, 5> whisperSourceArray = OBFUSCATE_SOURCE("data", 0x93E7A3A1F587CDC5ULL);
|
||||
const std::uint8_t (&whisperSource)[5] = whisperSourceArray._Elems;
|
||||
LoadWhisperBlockList(root[DecryptText<0x93E7A3A1F587CDC5ULL>(whisperSource)]);
|
||||
constexpr std::array<std::uint8_t, 5> emotionSourceArray = CRYPT_NAME("data", 0x2FF3C5036D070127ULL);
|
||||
LoadWhisperBlockList(root[(OBFUSCATE_DECRYPT(0x93E7A3A1F587CDC5ULL, whisperSource))]);
|
||||
constexpr std::array<std::uint8_t, 5> emotionSourceArray = OBFUSCATE_SOURCE("data", 0x2FF3C5036D070127ULL);
|
||||
const std::uint8_t (&emotionSource)[5] = emotionSourceArray._Elems;
|
||||
g_session.m_emotionHotkeys.Load(root[DecryptText<0x2FF3C5036D070127ULL>(emotionSource)]);
|
||||
constexpr std::array<std::uint8_t, 5> hotkeySourceArray = CRYPT_NAME("data", 0x17359BF953C367B3ULL);
|
||||
g_session.m_emotionHotkeys.Load(root[(OBFUSCATE_DECRYPT(0x2FF3C5036D070127ULL, emotionSource))]);
|
||||
constexpr std::array<std::uint8_t, 5> hotkeySourceArray = OBFUSCATE_SOURCE("data", 0x17359BF953C367B3ULL);
|
||||
const std::uint8_t (&hotkeySource)[5] = hotkeySourceArray._Elems;
|
||||
g_userHotkeyMgr->LoadV2(root[DecryptText<0x17359BF953C367B3ULL>(hotkeySource)]);
|
||||
g_userHotkeyMgr->LoadV2(root[(OBFUSCATE_DECRYPT(0x17359BF953C367B3ULL, hotkeySource))]);
|
||||
}
|
||||
[[fallthrough]];
|
||||
case 2:
|
||||
|
|
@ -129,12 +122,12 @@ void CAccountLinkedUserDataMgr::CompleteLoad(
|
|||
void CAccountLinkedUserDataMgr::RefreshUrls(LuaScript& settings, LuaScript& tables, const char* host, const char* port, const char* overrideKey) {
|
||||
const std::string base = g_session.ResolveAccountServiceBase();
|
||||
if (!base.empty()) {
|
||||
constexpr std::array<std::uint8_t, 17> saveSourceArray = CRYPT_NAME("/userconfig/save", 0x59278F63D79F3DA1ULL);
|
||||
constexpr std::array<std::uint8_t, 17> saveSourceArray = OBFUSCATE_SOURCE("/userconfig/save", 0x59278F63D79F3DA1ULL);
|
||||
const std::uint8_t (&saveSource)[17] = saveSourceArray._Elems;
|
||||
this->m_saveUrl = base + DecryptText<0x59278F63D79F3DA1ULL>(saveSource);
|
||||
constexpr std::array<std::uint8_t, 17> loadSourceArray = CRYPT_NAME("/userconfig/load", 0x812BE72BCD5707B7ULL);
|
||||
this->m_saveUrl = base + OBFUSCATE_DECRYPT(0x59278F63D79F3DA1ULL, saveSource);
|
||||
constexpr std::array<std::uint8_t, 17> loadSourceArray = OBFUSCATE_SOURCE("/userconfig/load", 0x812BE72BCD5707B7ULL);
|
||||
const std::uint8_t (&loadSource)[17] = loadSourceArray._Elems;
|
||||
this->m_loadUrl = base + DecryptText<0x812BE72BCD5707B7ULL>(loadSource);
|
||||
this->m_loadUrl = base + OBFUSCATE_DECRYPT(0x812BE72BCD5707B7ULL, loadSource);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -446,12 +446,12 @@ void UICashShopWnd::Paint() {
|
|||
|
||||
if (g_session.characterRenameEnabled) {
|
||||
this->DrawCenteredText(0x21A, 0x1B, []() {
|
||||
const auto source = CRYPT_NAME("스토브 구입 리스트", 0x474DC581D5E98357ULL);
|
||||
const auto source = OBFUSCATE_SOURCE("스토브 구입 리스트", 0x474DC581D5E98357ULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x474DC581D5E98357ULL> title(source.data);
|
||||
return title.Text();
|
||||
}(), 0xB9, 0, 0xE, 0, 1);
|
||||
this->DrawCenteredText(0x219, 0x1A, []() {
|
||||
const char source[] = CRYPT_CHARS(19, "스토브 구입 리스트", 0x3F557BE333F95F6DULL);
|
||||
const char source[] = OBFUSCATE_SOURCE_CHARS(19, "스토브 구입 리스트", 0x3F557BE333F95F6DULL);
|
||||
thread_local EncryptedName<sizeof(source), 0x3F557BE333F95F6DULL> title(source);
|
||||
return title.Text();
|
||||
}(), 0xB9, 0, 0xE, 0xFFFFFF, 1);
|
||||
|
|
|
|||
|
|
@ -1023,7 +1023,7 @@ void UIReplayRECControlWnd::AnimateLoading() {
|
|||
// OFFSET: 0x008AE8A0
|
||||
// FUNCTION: fn_11741
|
||||
void UILoginOTPWnd::OnCreate(int, int) {
|
||||
const auto prefixSource = CRYPT_NAME("유저인터페이스\\", 0x793F370985ED674FULL);
|
||||
const auto prefixSource = OBFUSCATE_SOURCE("유저인터페이스\\", 0x793F370985ED674FULL);
|
||||
thread_local EncryptedName<sizeof(prefixSource), 0x793F370985ED674FULL> prefixName(prefixSource.data);
|
||||
const std::string prefix(prefixName.Text());
|
||||
|
||||
|
|
@ -3283,7 +3283,7 @@ UIPetInfoWnd::~UIPetInfoWnd() {
|
|||
// OFFSET: 0x008A5CC0
|
||||
// FUNCTION: fn_11686
|
||||
EncryptedName<80, 0xF3CB6F7711A71B6DULL>& HangameJoinUrl::operator()() const {
|
||||
constexpr auto sourceText = CRYPT_NAME("http://ro.hangame.com/login/loginstep.asp?prevURL=/NHNCommon/NHN/Memberjoin.asp", 0xF3CB6F7711A71B6DULL);
|
||||
constexpr auto sourceText = OBFUSCATE_SOURCE("http://ro.hangame.com/login/loginstep.asp?prevURL=/NHNCommon/NHN/Memberjoin.asp", 0xF3CB6F7711A71B6DULL);
|
||||
const auto& source = sourceText.data;
|
||||
thread_local EncryptedName<sizeof(source), 0xF3CB6F7711A71B6DULL> name(source);
|
||||
return name;
|
||||
|
|
@ -3419,7 +3419,7 @@ int UILoginOTPWnd::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::
|
|||
|
||||
case 382: {
|
||||
CSoundMgr* const soundMgr = g_soundMgr;
|
||||
constexpr auto soundSourceText = CRYPT_NAME("버튼소리.wav", 0x7321C3814F8799E1ULL);
|
||||
constexpr auto soundSourceText = OBFUSCATE_SOURCE("버튼소리.wav", 0x7321C3814F8799E1ULL);
|
||||
const auto& soundSource = soundSourceText.data;
|
||||
thread_local EncryptedName<sizeof(soundSource), 0x7321C3814F8799E1ULL> soundName(soundSource);
|
||||
soundMgr->PlayWave(soundName.Text(), 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
|
||||
|
|
|
|||
|
|
@ -622,7 +622,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
|
|||
this->titleBar->Move(0, 0);
|
||||
{
|
||||
CUITitleBar* titleBar = this->titleBar;
|
||||
const auto titleRightSource = CRYPT_NAME("유저인터페이스\\basic_interface\\titlebar_right.bmp", 0x17A9E5BF39AD4737ULL);
|
||||
const auto titleRightSource = OBFUSCATE_SOURCE("유저인터페이스\\basic_interface\\titlebar_right.bmp", 0x17A9E5BF39AD4737ULL);
|
||||
// GLOBAL: gl_25394
|
||||
thread_local EncryptedName<sizeof(titleRightSource), 0x17A9E5BF39AD4737ULL> titleRightName(titleRightSource.data);
|
||||
const std::string titleRight(titleRightName.Text());
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ namespace {
|
|||
|
||||
// INLINED
|
||||
__forceinline const char* WaitSpriteName() {
|
||||
constexpr auto spriteSourceText = CRYPT_NAME("WaitDBSave\\NowLoading.spr", 0x078143534999254DULL);
|
||||
constexpr auto spriteSourceText = OBFUSCATE_SOURCE("WaitDBSave\\NowLoading.spr", 0x078143534999254DULL);
|
||||
const auto& spriteSource = spriteSourceText.data;
|
||||
thread_local EncryptedName<sizeof(spriteSource), 0x078143534999254DULL> spriteName(spriteSource);
|
||||
return spriteName.Text();
|
||||
|
|
@ -32,7 +32,7 @@ __forceinline const char* WaitSpriteName() {
|
|||
|
||||
// INLINED
|
||||
__forceinline const char* WaitActionName() {
|
||||
constexpr auto actionSourceText = CRYPT_NAME("WaitDBSave\\NowLoading.act", 0x17FFC98B398FAF61ULL);
|
||||
constexpr auto actionSourceText = OBFUSCATE_SOURCE("WaitDBSave\\NowLoading.act", 0x17FFC98B398FAF61ULL);
|
||||
const auto& actionSource = actionSourceText.data;
|
||||
thread_local EncryptedName<sizeof(actionSource), 0x17FFC98B398FAF61ULL> actionName(actionSource);
|
||||
return actionName.Text();
|
||||
|
|
|
|||
|
|
@ -32,13 +32,6 @@ static const std::string g_probabilityHighlightBegin = "^FF0000<B>";
|
|||
static const std::string g_probabilityHighlightEnd = "^000000</B>";
|
||||
|
||||
namespace {
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptName(const char (&source)[Length]) {
|
||||
thread_local EncryptedName<Length, Key> name(source);
|
||||
return name.Text();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -523,16 +516,16 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
this->m_titleBar = new CUITitleBar();
|
||||
this->m_titleBar->SetSize(345, 17);
|
||||
this->m_titleBar->Move(0, 0);
|
||||
this->m_titleBar->SetImages(std::string(DecryptName<0x0B7109397F6B1387ULL>({
|
||||
this->m_titleBar->SetImages(std::string(OBFUSCATE_DECRYPT_CHARS(0x0B7109397F6B1387ULL, 49, {
|
||||
'\x47', '\xBC', '\xAB', '\x85', '\xF9', '\xC7', '\xB4', '\xC6', '\x41', '\xF7', '\xAB', '\xB3', '\x84', '\xB3', '\x2D', '\x69',
|
||||
'\xE6', '\x60', '\x02', '\x1C', '\x66', '\x60', '\x1F', '\x7F', '\xE2', '\x61', '\x0D', '\x1E', '\x5A', '\x6C', '\x2D', '\x7F',
|
||||
'\xEE', '\x67', '\x07', '\x1A', '\x5B', '\x68', '\x03', '\x54', '\xEB', '\x76', '\x0D', '\x0B', '\x17', '\x6B', '\x1C', '\x7B',
|
||||
'\x87'
|
||||
})), std::string(DecryptName<0x23BBD58F8B5FF5C9ULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0x23BBD58F8B5FF5C9ULL, 48, {
|
||||
'\x09', '\x5A', '\x9F', '\x71', '\x4F', '\x1B', '\x7E', '\xEE', '\x0F', '\x11', '\x9F', '\x47', '\x32', '\x6F', '\xE7', '\x41',
|
||||
'\xA8', '\x86', '\x36', '\xE8', '\xD0', '\xBC', '\xD5', '\x57', '\xAC', '\x87', '\x39', '\xEA', '\xEC', '\xB0', '\xE7', '\x57',
|
||||
'\xA0', '\x81', '\x33', '\xEE', '\xED', '\xB4', '\xC9', '\x7C', '\xA4', '\x9C', '\x3B', '\xA5', '\xED', '\xB8', '\xCB', '\x23'
|
||||
})), std::string(DecryptName<0xC517FB932D95BB6DULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0xC517FB932D95BB6DULL, 50, {
|
||||
'\xAD', '\x14', '\x55', '\xD7', '\x53', '\x35', '\xD2', '\x08', '\xAB', '\x5F', '\x55', '\xE1', '\x2E', '\x41', '\x4B', '\xA7',
|
||||
'\x0C', '\xC8', '\xFC', '\x4E', '\xCC', '\x92', '\x79', '\xB1', '\x08', '\xC9', '\xF3', '\x4C', '\xF0', '\x9E', '\x4B', '\xB1',
|
||||
'\x04', '\xCF', '\xF9', '\x48', '\xF1', '\x9A', '\x65', '\x9A', '\x1F', '\xD2', '\xF2', '\x45', '\xE7', '\xD5', '\x75', '\xA8',
|
||||
|
|
@ -543,10 +536,10 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
CUIStaticText* title = new CUIStaticText();
|
||||
title->SetSize(310, 17);
|
||||
title->Move(18, 0);
|
||||
title->SetText(DecryptName<0x9949BFD527532943ULL>({'\x8B', '\x87', '\xE4', '\xDB', '\xF5', '\x0F', '\xB1', '\x29', '\xF0', '\x29'}));
|
||||
title->SetText(OBFUSCATE_DECRYPT_CHARS(0x9949BFD527532943ULL, 10, {'\x8B', '\x87', '\xE4', '\xDB', '\xF5', '\x0F', '\xB1', '\x29', '\xF0', '\x29'}));
|
||||
title->SetFitText(0);
|
||||
title->SetAlign(0, 6);
|
||||
title->SetFont(std::string(DecryptName<0xCD8F077123FB7D6FULL>({'\x28', '\x08', '\x97', '\x4A', '\x1C', '\x07'})));
|
||||
title->SetFont(std::string(OBFUSCATE_DECRYPT_CHARS(0xCD8F077123FB7D6FULL, 6, {'\x28', '\x08', '\x97', '\x4A', '\x1C', '\x07'})));
|
||||
title->SetFontHeight(12);
|
||||
title->SetBold(0);
|
||||
title->SetColor(0);
|
||||
|
|
@ -563,20 +556,20 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
systemButton->disabled = 0;
|
||||
systemButton->Invalidate();
|
||||
systemButton->SetImages(
|
||||
std::string(DecryptName<0x13E33FA1A591AB67ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x13E33FA1A591AB67ULL, 48, {
|
||||
'\xA7', '\x04', '\x51', '\x5F', '\x61', '\xF1', '\x26', '\xDE', '\xA1', '\x4F', '\x51', '\x69', '\x1C', '\x85', '\xBF', '\x71',
|
||||
'\x06', '\xD8', '\xF8', '\xC6', '\xFE', '\x56', '\x8D', '\x67', '\x02', '\xD9', '\xF7', '\xC4', '\xC2', '\x5A', '\xBF', '\x60',
|
||||
'\x1E', '\xD8', '\xCE', '\xC7', '\xC0', '\x4C', '\x86', '\x4C', '\x08', '\xCD', '\xF7', '\x8B', '\xC3', '\x52', '\x93', '\x13'
|
||||
})), std::string(DecryptName<0x17A9E5BF39AD4737ULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0x17A9E5BF39AD4737ULL, 47, {
|
||||
'\xF7', '\xE8', '\x6D', '\xC3', '\x7F', '\x2B', '\x6C', '\xDA', '\xF1', '\xA3', '\x6D', '\xF5', '\x02', '\x5F', '\xF5', '\x75',
|
||||
'\x56', '\x34', '\xC4', '\x5A', '\xE0', '\x8C', '\xC7', '\x63', '\x52', '\x35', '\xCB', '\x58', '\xDC', '\x80', '\xF5', '\x64',
|
||||
'\x4E', '\x34', '\xF2', '\x5B', '\xDE', '\x96', '\xCC', '\x48', '\x58', '\x29', '\x83', '\x5B', '\xD2', '\x95', '\xA9'
|
||||
})),
|
||||
std::string(DecryptName<0xF14F79170939C7F1ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xF14F79170939C7F1ULL, 47, {
|
||||
'\x31', '\x68', '\xF9', '\xF3', '\xD7', '\xB7', '\x8A', '\x3C', '\x37', '\x23', '\xF9', '\xC5', '\xAA', '\xC3', '\x13', '\x93',
|
||||
'\x90', '\xB4', '\x50', '\x6A', '\x48', '\x10', '\x21', '\x85', '\x94', '\xB5', '\x5F', '\x68', '\x74', '\x1C', '\x13', '\x82',
|
||||
'\x88', '\xB4', '\x66', '\x6B', '\x76', '\x0A', '\x2A', '\xAE', '\x9E', '\xA9', '\x17', '\x6B', '\x7A', '\x09', '\x4F'
|
||||
})), std::string(DecryptName<0xA5FD29D7AB6DC59FULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0xA5FD29D7AB6DC59FULL, 48, {
|
||||
'\x5F', '\x6A', '\xAD', '\x51', '\x17', '\xE7', '\x38', '\x68', '\x59', '\x21', '\xAD', '\x67', '\x6A', '\x93', '\xA1', '\xC7',
|
||||
'\xFE', '\xB6', '\x04', '\xC8', '\x88', '\x40', '\x93', '\xD1', '\xFA', '\xB7', '\x0B', '\xCA', '\xB4', '\x4C', '\xA1', '\xD6',
|
||||
'\xE6', '\xB6', '\x32', '\xC9', '\xB6', '\x5A', '\x98', '\xFA', '\xF0', '\xA3', '\x0B', '\x85', '\xB5', '\x44', '\x8D', '\xA5'
|
||||
|
|
@ -591,21 +584,21 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
closeButton->disabled = 0;
|
||||
closeButton->Invalidate();
|
||||
closeButton->SetImages(
|
||||
std::string(DecryptName<0xD97D5DBDBB2F2709ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xD97D5DBDBB2F2709ULL, 49, {
|
||||
'\xC9', '\x88', '\xEF', '\x41', '\x7D', '\x93', '\xB8', '\x14', '\xCF', '\xC3', '\xEF', '\x77', '\x00', '\xE7', '\x21', '\xBB',
|
||||
'\x68', '\x54', '\x46', '\xD8', '\xE2', '\x34', '\x13', '\xAD', '\x6C', '\x55', '\x49', '\xDA', '\xDE', '\x38', '\x21', '\xAA',
|
||||
'\x70', '\x54', '\x70', '\xD8', '\xD1', '\x32', '\x0E', '\xBC', '\x56', '\x48', '\x49', '\xDD', '\x93', '\x3F', '\x10', '\xA9',
|
||||
'\x09'
|
||||
})), std::string(DecryptName<0xED796785D1DF137FULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0xED796785D1DF137FULL, 48, {
|
||||
'\xBF', '\xBC', '\x1F', '\x2B', '\x45', '\xA9', '\xBC', '\x20', '\xB9', '\xF7', '\x1F', '\x1D', '\x38', '\xDD', '\x25', '\x8F',
|
||||
'\x1E', '\x60', '\xB6', '\xB2', '\xDA', '\x0E', '\x17', '\x99', '\x1A', '\x61', '\xB9', '\xB0', '\xE6', '\x02', '\x25', '\x9E',
|
||||
'\x06', '\x60', '\x80', '\xB2', '\xE9', '\x08', '\x0A', '\x88', '\x20', '\x7C', '\xB1', '\xFF', '\xE7', '\x0A', '\x09', '\xED'
|
||||
})),
|
||||
std::string(DecryptName<0x83EFBFBB37EDBDBDULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x83EFBFBB37EDBDBDULL, 48, {
|
||||
'\x7D', '\x12', '\x2D', '\xCD', '\x7B', '\x71', '\x2A', '\x4E', '\x7B', '\x59', '\x2D', '\xFB', '\x06', '\x05', '\xB3', '\xE1',
|
||||
'\xDC', '\xCE', '\x84', '\x54', '\xE4', '\xD6', '\x81', '\xF7', '\xD8', '\xCF', '\x8B', '\x56', '\xD8', '\xDA', '\xB3', '\xF0',
|
||||
'\xC4', '\xCE', '\xB2', '\x54', '\xD7', '\xD0', '\x9C', '\xE6', '\xE2', '\xD2', '\x83', '\x19', '\xD9', '\xD2', '\x9F', '\x83'
|
||||
})), std::string(DecryptName<0xBF2B4B31397FF5A7ULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0xBF2B4B31397FF5A7ULL, 49, {
|
||||
'\x67', '\x5A', '\xBF', '\xC3', '\xF1', '\x85', '\xEE', '\x72', '\x61', '\x11', '\xBF', '\xF5', '\x8C', '\xF1', '\x77', '\xDD',
|
||||
'\xC6', '\x86', '\x16', '\x5A', '\x6E', '\x22', '\x45', '\xCB', '\xC2', '\x87', '\x19', '\x58', '\x52', '\x2E', '\x77', '\xCC',
|
||||
'\xDE', '\x86', '\x20', '\x5A', '\x5D', '\x24', '\x58', '\xDA', '\xF8', '\x9A', '\x19', '\x5F', '\x1F', '\x29', '\x46', '\xCF',
|
||||
|
|
@ -617,10 +610,10 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
this->m_nameHeader = new CUIStaticText();
|
||||
this->m_nameHeader->SetSize(160, 18);
|
||||
this->m_nameHeader->Move(10, 30);
|
||||
this->m_nameHeader->SetText(DecryptName<0xDD3913D5D7F97BE1ULL>({'\x50', '\xC3', '\x45', '\x6D', '\x12', '\xA3', '\x19', '\x6D', '\x2A', '\xC0', '\x0F', '\xD7'}));
|
||||
this->m_nameHeader->SetText(OBFUSCATE_DECRYPT_CHARS(0xDD3913D5D7F97BE1ULL, 12, {'\x50', '\xC3', '\x45', '\x6D', '\x12', '\xA3', '\x19', '\x6D', '\x2A', '\xC0', '\x0F', '\xD7'}));
|
||||
this->m_nameHeader->SetFitText(0);
|
||||
this->m_nameHeader->SetAlign(2, 6);
|
||||
this->m_nameHeader->SetFont(std::string(DecryptName<0x050505679903579BULL>({'\xDC', '\x22', '\x6F', '\xF0', '\x0A', '\x05'})));
|
||||
this->m_nameHeader->SetFont(std::string(OBFUSCATE_DECRYPT_CHARS(0x050505679903579BULL, 6, {'\xDC', '\x22', '\x6F', '\xF0', '\x0A', '\x05'})));
|
||||
this->m_nameHeader->SetFontHeight(12);
|
||||
this->m_nameHeader->SetBold(0);
|
||||
this->m_nameHeader->SetColor(0);
|
||||
|
|
@ -650,23 +643,23 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
this->m_searchButton->disabled = 0;
|
||||
this->m_searchButton->Invalidate();
|
||||
this->m_searchButton->SetImages(
|
||||
std::string(DecryptName<0x2F8B0F37118D157FULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x2F8B0F37118D157FULL, 62, {
|
||||
'\xBF', '\xBA', '\x4D', '\xEB', '\xF7', '\xC1', '\x4E', '\xE2', '\xB9', '\xF1', '\x4D', '\xDD', '\x8A', '\xB5', '\xD7', '\x41',
|
||||
'\x1E', '\x63', '\xE4', '\x76', '\x56', '\x7B', '\xE2', '\x40', '\x11', '\x4A', '\xE4', '\x7F', '\x43', '\x6A', '\xF9', '\x49',
|
||||
'\x1E', '\x76', '\xE8', '\x22', '\x6B', '\x6D', '\xFF', '\x41', '\x20', '\x66', '\xE8', '\x70', '\x45', '\x6C', '\xE3', '\x4D',
|
||||
'\x1E', '\x67', '\xD2', '\x7F', '\x58', '\x7D', '\xE6', '\x4E', '\x13', '\x3B', '\xEF', '\x7C', '\x47', '\x0F'
|
||||
})), std::string(DecryptName<0xAD075B8DB599F1CDULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0xAD075B8DB599F1CDULL, 61, {
|
||||
'\x0D', '\x5E', '\x59', '\x4F', '\x4D', '\x95', '\xC2', '\x60', '\x0B', '\x15', '\x59', '\x79', '\x30', '\xE1', '\x5B', '\xC3',
|
||||
'\xAC', '\x87', '\xF0', '\xD2', '\xEC', '\x2F', '\x6E', '\xC2', '\xA3', '\xAE', '\xF0', '\xDB', '\xF9', '\x3E', '\x75', '\xCB',
|
||||
'\xAC', '\x92', '\xFC', '\x86', '\xD1', '\x39', '\x73', '\xC3', '\x92', '\x82', '\xFC', '\xD4', '\xFF', '\x38', '\x6F', '\xCF',
|
||||
'\xAC', '\x83', '\xC6', '\xC5', '\xFF', '\x3E', '\x74', '\xDE', '\xE3', '\x93', '\xF4', '\xC5', '\x8D'
|
||||
})),
|
||||
std::string(DecryptName<0x2FE993D1DDE1F197ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x2FE993D1DDE1F197ULL, 60, {
|
||||
'\x57', '\x5E', '\x21', '\x27', '\x11', '\x5D', '\x2C', '\xE2', '\x51', '\x15', '\x21', '\x11', '\x6C', '\x29', '\xB5', '\x41',
|
||||
'\xF6', '\x87', '\x88', '\xBA', '\xB0', '\xE7', '\x80', '\x40', '\xF9', '\xAE', '\x88', '\xB3', '\xA5', '\xF6', '\x9B', '\x49',
|
||||
'\xF6', '\x92', '\x84', '\xEE', '\x8D', '\xF1', '\x9D', '\x41', '\xC8', '\x82', '\x84', '\xBC', '\xA3', '\xF0', '\x81', '\x4D',
|
||||
'\xF6', '\x83', '\xBE', '\xB2', '\xA7', '\xF6', '\x9B', '\x01', '\xF5', '\x9C', '\x91', '\xDD'
|
||||
})), std::string(DecryptName<0x39FF7FB50DEB998FULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0x39FF7FB50DEB998FULL, 62, {
|
||||
'\x4F', '\x36', '\x2B', '\xF7', '\x75', '\xB1', '\x3A', '\xF4', '\x49', '\x7D', '\x2B', '\xC1', '\x08', '\xC5', '\xA3', '\x57',
|
||||
'\xEE', '\xEF', '\x82', '\x6A', '\xD4', '\x0B', '\x96', '\x56', '\xE1', '\xC6', '\x82', '\x63', '\xC1', '\x1A', '\x8D', '\x5F',
|
||||
'\xEE', '\xFA', '\x8E', '\x3E', '\xE9', '\x1D', '\x8B', '\x57', '\xD0', '\xEA', '\x8E', '\x6C', '\xC7', '\x1C', '\x97', '\x5B',
|
||||
|
|
@ -681,7 +674,7 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
this->m_itemName->SetText("");
|
||||
this->m_itemName->SetFitText(1);
|
||||
this->m_itemName->SetAlign(6, 6);
|
||||
this->m_itemName->SetFont(std::string(DecryptName<0xB7FD8F670FC7B96BULL>({'\x2C', '\xCC', '\xAB', '\x66', '\x0A', '\x8F'})));
|
||||
this->m_itemName->SetFont(std::string(OBFUSCATE_DECRYPT_CHARS(0xB7FD8F670FC7B96BULL, 6, {'\x2C', '\xCC', '\xAB', '\x66', '\x0A', '\x8F'})));
|
||||
this->m_itemName->SetFontHeight(12);
|
||||
this->m_itemName->SetBold(1);
|
||||
this->m_itemName->SetColor(0);
|
||||
|
|
@ -692,10 +685,10 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
this->m_probabilityHeader = new CUIStaticText();
|
||||
this->m_probabilityHeader->SetSize(68, 24);
|
||||
this->m_probabilityHeader->Move(248, 61);
|
||||
this->m_probabilityHeader->SetText(DecryptName<0xE7978FB5A94DD7FDULL>({'\x35', '\x79', '\xFA', '\x55', '\xB5'}));
|
||||
this->m_probabilityHeader->SetText(OBFUSCATE_DECRYPT_CHARS(0xE7978FB5A94DD7FDULL, 5, {'\x35', '\x79', '\xFA', '\x55', '\xB5'}));
|
||||
this->m_probabilityHeader->SetFitText(1);
|
||||
this->m_probabilityHeader->SetAlign(6, 6);
|
||||
this->m_probabilityHeader->SetFont(std::string(DecryptName<0x4941FD9F21BBB9FDULL>({'\xBA', '\xCC', '\xD7', '\x48', '\xF2', '\xFD'})));
|
||||
this->m_probabilityHeader->SetFont(std::string(OBFUSCATE_DECRYPT_CHARS(0x4941FD9F21BBB9FDULL, 6, {'\xBA', '\xCC', '\xD7', '\x48', '\xF2', '\xFD'})));
|
||||
this->m_probabilityHeader->SetFontHeight(12);
|
||||
this->m_probabilityHeader->SetBold(0);
|
||||
this->m_probabilityHeader->SetColor(0);
|
||||
|
|
@ -717,27 +710,27 @@ void CUIProbabilityTable::OnCreate(int width, int height) {
|
|||
this->m_list->scrollBar->SetSize(13, 360);
|
||||
this->m_list->scrollBar->Move(312, 0);
|
||||
this->m_list->scrollBar->step = 30;
|
||||
this->m_list->SetScrollBarButtonImages(std::string(DecryptName<0x35E5656B5DEDCD75ULL>({
|
||||
this->m_list->SetScrollBarButtonImages(std::string(OBFUSCATE_DECRYPT_CHARS(0x35E5656B5DEDCD75ULL, 29, {
|
||||
'\xB5', '\x62', '\x2D', '\xA7', '\xAB', '\xAB', '\x20', '\xF8', '\xB3', '\x29', '\x2D', '\x91', '\xD6', '\xDF', '\xB9', '\x46',
|
||||
'\x16', '\xBF', '\x82', '\x31', '\x07', '\x55', '\x90', '\x45', '\x5B', '\xAF', '\x80', '\x2D', '\x6B'
|
||||
})), std::string(DecryptName<0x793F370985ED674FULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0x793F370985ED674FULL, 31, {
|
||||
'\x8F', '\xC8', '\x2D', '\x7F', '\xC9', '\xF9', '\xFA', '\xB4', '\x89', '\x83', '\x2D', '\x49', '\xB4', '\x8D', '\x63', '\x0A',
|
||||
'\x2C', '\x15', '\x82', '\xE9', '\x65', '\x07', '\x5B', '\x16', '\x38', '\x09', '\xC3', '\xE7', '\x64', '\x47', '\x3F'
|
||||
})));
|
||||
this->m_list->SetScrollBarBackground(std::string(DecryptName<0xE55723712993051DULL>({
|
||||
this->m_list->SetScrollBarBackground(std::string(OBFUSCATE_DECRYPT_CHARS(0xE55723712993051DULL, 30, {
|
||||
'\xDD', '\xAA', '\x53', '\xD3', '\xB1', '\xED', '\x92', '\x28', '\xDB', '\xE1', '\x53', '\xE5', '\xCC', '\x99', '\x0B', '\x96',
|
||||
'\x7E', '\x77', '\xFC', '\x45', '\x1D', '\x13', '\x3A', '\x8C', '\x79', '\x2B', '\xF1', '\x44', '\x01', '\x23'
|
||||
})));
|
||||
this->m_list->SetScrollBarThumbImages(
|
||||
std::string(DecryptName<0x7115D9F973F913C9ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x7115D9F973F913C9ULL, 33, {
|
||||
'\x09', '\xBC', '\x39', '\x89', '\x39', '\x17', '\xD0', '\xBC', '\x0F', '\xF7', '\x39', '\xBF', '\x44', '\x63', '\x49', '\x02',
|
||||
'\xAA', '\x61', '\x96', '\x1F', '\x95', '\xE9', '\x77', '\x10', '\xBB', '\x4C', '\x8C', '\x03', '\xD7', '\xBB', '\x78', '\x01',
|
||||
'\xC9'
|
||||
})), std::string(DecryptName<0xCB1D253B7FE1F563ULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0xCB1D253B7FE1F563ULL, 34, {
|
||||
'\xA3', '\x5A', '\x21', '\x85', '\xFB', '\xEB', '\xD8', '\x06', '\xA5', '\x11', '\x21', '\xB3', '\x86', '\x9F', '\x41', '\xB8',
|
||||
'\x00', '\x87', '\x8E', '\x13', '\x57', '\x15', '\x7F', '\xAA', '\x11', '\xAA', '\x8C', '\x16', '\x5F', '\x0B', '\x7F', '\xA6',
|
||||
'\x13', '\xF5'
|
||||
})), std::string(DecryptName<0x7941D76335CFA14FULL>({
|
||||
})), std::string(OBFUSCATE_DECRYPT_CHARS(0x7941D76335CFA14FULL, 35, {
|
||||
'\x8F', '\x0E', '\x0F', '\xCF', '\xA3', '\x19', '\x84', '\xB4', '\x89', '\x45', '\x0F', '\xF9', '\xDE', '\x6D', '\x1D', '\x0A',
|
||||
'\x2C', '\xD3', '\xA0', '\x59', '\x0F', '\xE7', '\x23', '\x18', '\x3D', '\xFE', '\xAB', '\x5A', '\x14', '\xB9', '\x6F', '\x1B',
|
||||
'\x22', '\xD1', '\xCF'
|
||||
|
|
|
|||
|
|
@ -26,13 +26,6 @@
|
|||
|
||||
namespace {
|
||||
|
||||
// INLINED
|
||||
template <std::uint64_t Key, std::size_t Length>
|
||||
const char* DecryptName(const char (&source)[Length]) {
|
||||
thread_local EncryptedName<Length, Key> name(source);
|
||||
return name.Text();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
struct SkillDelayInfoFreezeCallback {
|
||||
|
|
@ -587,14 +580,14 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->titleBar->SetSize(345, 17);
|
||||
this->titleBar->Move(0, 0);
|
||||
this->titleBar->SetImages(
|
||||
std::string(DecryptName<0xF15F8785CDE369BFULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xF15F8785CDE369BFULL, 49, {
|
||||
'\x7F', '\xC6', '\x23', '\x37', '\x45', '\x49', '\x9A', '\x3C', '\x79', '\x8D', '\x23', '\x01', '\x38', '\x3D', '\x03', '\x93', '\xDE', '\x1A', '\x8A', '\xAE', '\xDA', '\xEE', '\x31', '\x85',
|
||||
'\xDA', '\x1B', '\x85', '\xAC', '\xE6', '\xE2', '\x03', '\x85', '\xD6', '\x1D', '\x8F', '\xA8', '\xE7', '\xE6', '\x2D', '\xAE', '\xD3', '\x0C', '\x85', '\xB9', '\xAB', '\xE5', '\x32', '\x81',
|
||||
'\xBF'})),
|
||||
std::string(DecryptName<0x792FFD1325418FB5ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x792FFD1325418FB5ULL, 48, {
|
||||
'\x75', '\x20', '\x81', '\xDF', '\xD3', '\x33', '\xEA', '\xB4', '\x73', '\x6B', '\x81', '\xE9', '\xAE', '\x47', '\x73', '\x1B', '\xD4', '\xFC', '\x28', '\x46', '\x4C', '\x94', '\x41', '\x0D',
|
||||
'\xD0', '\xFD', '\x27', '\x44', '\x70', '\x98', '\x73', '\x0D', '\xDC', '\xFB', '\x2D', '\x40', '\x71', '\x9C', '\x5D', '\x26', '\xD8', '\xE6', '\x25', '\x0B', '\x71', '\x90', '\x5F', '\x79'})),
|
||||
std::string(DecryptName<0x49D33529F1556333ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x49D33529F1556333ULL, 50, {
|
||||
'\xF3', '\xCC', '\x95', '\x0B', '\xE9', '\xFB', '\x16', '\x84', '\xF5', '\x87', '\x95', '\x3D', '\x94', '\x8F', '\x8F', '\x2B', '\x52', '\x10', '\x3C', '\x92', '\x76', '\x5C', '\xBD', '\x3D',
|
||||
'\x56', '\x11', '\x33', '\x90', '\x4A', '\x50', '\x8F', '\x3D', '\x5A', '\x17', '\x39', '\x94', '\x4B', '\x54', '\xA1', '\x16', '\x41', '\x0A', '\x32', '\x99', '\x5D', '\x1B', '\xB1', '\x24',
|
||||
'\x43', '\x63'}))
|
||||
|
|
@ -604,11 +597,11 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
CUIStaticText* title = new CUIStaticText();
|
||||
title->SetSize(100, 17);
|
||||
title->Move(18, 0);
|
||||
title->SetText(DecryptName<0x01CB4F1DF9D3F931ULL>({
|
||||
title->SetText(OBFUSCATE_DECRYPT_CHARS(0x01CB4F1DF9D3F931ULL, 12, {
|
||||
'\xF5', '\x4A', '\x6E', '\x43', '\xDB', '\x8C', '\xEB', '\xC0', '\x95', '\x43', '\x6B', '\xF9'}));
|
||||
title->SetFitText(0);
|
||||
title->SetAlign(0, 6);
|
||||
title->SetFont(DecryptName<0xC5B1BBCD9BC9C997ULL>({
|
||||
title->SetFont(OBFUSCATE_DECRYPT_CHARS(0xC5B1BBCD9BC9C997ULL, 6, {
|
||||
'\xD0', '\xBC', '\xA5', '\xF2', '\xA0', '\xBB'}));
|
||||
title->SetFontHeight(12);
|
||||
title->SetBold(0);
|
||||
|
|
@ -626,16 +619,16 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
menuButton->disabled = 0;
|
||||
menuButton->Invalidate();
|
||||
menuButton->SetImages(
|
||||
std::string(DecryptName<0xC1BB8111EDD183E1ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xC1BB8111EDD183E1ULL, 48, {
|
||||
'\x21', '\x2C', '\x11', '\x17', '\xD1', '\x4F', '\x7E', '\x0C', '\x27', '\x67', '\x11', '\x21', '\xAC', '\x3B', '\xE7', '\xA3', '\x80', '\xF0', '\xB8', '\x8E', '\x4E', '\xE8', '\xD5', '\xB5',
|
||||
'\x84', '\xF1', '\xB7', '\x8C', '\x72', '\xE4', '\xE7', '\xB2', '\x98', '\xF0', '\x8E', '\x8F', '\x70', '\xF2', '\xDE', '\x9E', '\x8E', '\xE5', '\xB7', '\xC3', '\x73', '\xEC', '\xCB', '\xC1'})),
|
||||
std::string(DecryptName<0x1767DDE18D779D8BULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x1767DDE18D779D8BULL, 47, {
|
||||
'\x4B', '\x32', '\xB7', '\x77', '\x21', '\x13', '\xA2', '\xDA', '\x4D', '\x79', '\xB7', '\x41', '\x5C', '\x67', '\x3B', '\x75', '\xEA', '\xEE', '\x1E', '\xEE', '\xBE', '\xB4', '\x09', '\x63',
|
||||
'\xEE', '\xEF', '\x11', '\xEC', '\x82', '\xB8', '\x3B', '\x64', '\xF2', '\xEE', '\x28', '\xEF', '\x80', '\xAE', '\x02', '\x48', '\xE4', '\xF3', '\x59', '\xEF', '\x8C', '\xAD', '\x67'})),
|
||||
std::string(DecryptName<0x0B23D10F2F49D72BULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x0B23D10F2F49D72BULL, 47, {
|
||||
'\xEB', '\x78', '\x89', '\xD5', '\xCF', '\x1F', '\xE6', '\xC6', '\xED', '\x33', '\x89', '\xE3', '\xB2', '\x6B', '\x7F', '\x69', '\x4A', '\xA4', '\x20', '\x4C', '\x50', '\xB8', '\x4D', '\x7F',
|
||||
'\x4E', '\xA5', '\x2F', '\x4E', '\x6C', '\xB4', '\x7F', '\x78', '\x52', '\xA4', '\x16', '\x4D', '\x6E', '\xA2', '\x46', '\x54', '\x44', '\xB9', '\x67', '\x4D', '\x62', '\xA1', '\x23'})),
|
||||
std::string(DecryptName<0x136F2F9915D1DBCFULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x136F2F9915D1DBCFULL, 48, {
|
||||
'\x0F', '\x74', '\x11', '\xEF', '\x59', '\xE1', '\xAA', '\xDE', '\x09', '\x3F', '\x11', '\xD9', '\x24', '\x95', '\x33', '\x71', '\xAE', '\xA8', '\xB8', '\x76', '\xC6', '\x46', '\x01', '\x67',
|
||||
'\xAA', '\xA9', '\xB7', '\x74', '\xFA', '\x4A', '\x33', '\x60', '\xB6', '\xA8', '\x8E', '\x77', '\xF8', '\x5C', '\x0A', '\x4C', '\xA0', '\xBD', '\xB7', '\x3B', '\xFB', '\x42', '\x1F', '\x13'}))
|
||||
);
|
||||
|
|
@ -648,17 +641,17 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
closeButton->disabled = 0;
|
||||
closeButton->Invalidate();
|
||||
closeButton->SetImages(
|
||||
std::string(DecryptName<0x6BDF334F2BFDAD51ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x6BDF334F2BFDAD51ULL, 49, {
|
||||
'\x91', '\x02', '\x3D', '\xD1', '\x8F', '\xFD', '\x1A', '\xA6', '\x97', '\x49', '\x3D', '\xE7', '\xF2', '\x89', '\x83', '\x09', '\x30', '\xDE', '\x94', '\x48', '\x10', '\x5A', '\xB1', '\x1F',
|
||||
'\x34', '\xDF', '\x9B', '\x4A', '\x2C', '\x56', '\x83', '\x18', '\x28', '\xDE', '\xA2', '\x48', '\x23', '\x5C', '\xAC', '\x0E', '\x0E', '\xC2', '\x9B', '\x4D', '\x61', '\x51', '\xB2', '\x1B',
|
||||
'\x51'})),
|
||||
std::string(DecryptName<0x674D9F3975573D41ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x674D9F3975573D41ULL, 48, {
|
||||
'\x81', '\x92', '\x97', '\x8F', '\xF9', '\x51', '\x88', '\xAA', '\x87', '\xD9', '\x97', '\xB9', '\x84', '\x25', '\x11', '\x05', '\x20', '\x4E', '\x3E', '\x16', '\x66', '\xF6', '\x23', '\x13',
|
||||
'\x24', '\x4F', '\x31', '\x14', '\x5A', '\xFA', '\x11', '\x14', '\x38', '\x4E', '\x08', '\x16', '\x55', '\xF0', '\x3E', '\x02', '\x1E', '\x52', '\x39', '\x5B', '\x5B', '\xF2', '\x3D', '\x67'})),
|
||||
std::string(DecryptName<0x79E915E9AF6F55DDULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x79E915E9AF6F55DDULL, 48, {
|
||||
'\x1D', '\xFA', '\xAF', '\x55', '\x29', '\xDB', '\x2C', '\xB4', '\x1B', '\xB1', '\xAF', '\x63', '\x54', '\xAF', '\xB5', '\x1B', '\xBC', '\x26', '\x06', '\xCC', '\xB6', '\x7C', '\x87', '\x0D',
|
||||
'\xB8', '\x27', '\x09', '\xCE', '\x8A', '\x70', '\xB5', '\x0A', '\xA4', '\x26', '\x30', '\xCC', '\x85', '\x7A', '\x9A', '\x1C', '\x82', '\x3A', '\x01', '\x81', '\x8B', '\x78', '\x99', '\x79'})),
|
||||
std::string(DecryptName<0xB7AFBD2FD9FD7501ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xB7AFBD2FD9FD7501ULL, 49, {
|
||||
'\xC1', '\xDA', '\x3D', '\x23', '\xEF', '\x73', '\x6A', '\x7A', '\xC7', '\x91', '\x3D', '\x15', '\x92', '\x07', '\xF3', '\xD5', '\x60', '\x06', '\x94', '\xBA', '\x70', '\xD4', '\xC1', '\xC3',
|
||||
'\x64', '\x07', '\x9B', '\xB8', '\x4C', '\xD8', '\xF3', '\xC4', '\x78', '\x06', '\xA2', '\xBA', '\x43', '\xD2', '\xDC', '\xD2', '\x5E', '\x1A', '\x9B', '\xBF', '\x01', '\xDF', '\xC2', '\xC7',
|
||||
'\x01'}))
|
||||
|
|
@ -671,7 +664,7 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->skillNameText->SetText("");
|
||||
this->skillNameText->SetFitText(1);
|
||||
this->skillNameText->SetAlign(6, 6);
|
||||
this->skillNameText->SetFont(DecryptName<0x192D654D29337BE5ULL>({
|
||||
this->skillNameText->SetFont(OBFUSCATE_DECRYPT_CHARS(0x192D654D29337BE5ULL, 6, {
|
||||
'\xA2', '\x0E', '\x5F', '\x40', '\x20', '\x65'}));
|
||||
this->skillNameText->SetFontHeight(13);
|
||||
this->skillNameText->SetBold(1);
|
||||
|
|
@ -683,11 +676,11 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->labels[0] = new CUIStaticText();
|
||||
this->labels[0]->SetSize(140, 22);
|
||||
this->labels[0]->Move(54, 58);
|
||||
this->labels[0]->SetText(DecryptName<0xB3E307A5F753D5E3ULL>({
|
||||
this->labels[0]->SetText(OBFUSCATE_DECRYPT_CHARS(0xB3E307A5F753D5E3ULL, 7, {
|
||||
'\x27', '\x66', '\xEE', '\x4D', '\x63', '\xC4', '\xE3'}));
|
||||
this->labels[0]->SetFitText(0);
|
||||
this->labels[0]->SetAlign(6, 6);
|
||||
this->labels[0]->SetFont(DecryptName<0xDB27CB557D038759ULL>({
|
||||
this->labels[0]->SetFont(OBFUSCATE_DECRYPT_CHARS(0xDB27CB557D038759ULL, 6, {
|
||||
'\x1E', '\xF2', '\x6F', '\x14', '\x38', '\xCB'}));
|
||||
this->labels[0]->SetFontHeight(13);
|
||||
this->labels[0]->SetBold(1);
|
||||
|
|
@ -699,11 +692,11 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->labels[1] = new CUIStaticText();
|
||||
this->labels[1]->SetSize(140, 22);
|
||||
this->labels[1]->Move(194, 58);
|
||||
this->labels[1]->SetText(DecryptName<0x3FA3AFA7035DE3FFULL>({
|
||||
this->labels[1]->SetText(OBFUSCATE_DECRYPT_CHARS(0x3FA3AFA7035DE3FFULL, 7, {
|
||||
'\x3B', '\x13', '\x98', '\xBB', '\x67', '\x7C', '\xA3'}));
|
||||
this->labels[1]->SetFitText(0);
|
||||
this->labels[1]->SetAlign(6, 6);
|
||||
this->labels[1]->SetFont(DecryptName<0x87E3D1C50D572DEFULL>({
|
||||
this->labels[1]->SetFont(OBFUSCATE_DECRYPT_CHARS(0x87E3D1C50D572DEFULL, 6, {
|
||||
'\xA8', '\x58', '\x3B', '\x64', '\xA8', '\xD1'}));
|
||||
this->labels[1]->SetFontHeight(13);
|
||||
this->labels[1]->SetBold(1);
|
||||
|
|
@ -715,11 +708,11 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->labels[2] = new CUIStaticText();
|
||||
this->labels[2]->SetSize(44, 22);
|
||||
this->labels[2]->Move(10, 82);
|
||||
this->labels[2]->SetText(DecryptName<0x51BB39B763BBBD8DULL>({
|
||||
this->labels[2]->SetText(OBFUSCATE_DECRYPT_CHARS(0x51BB39B763BBBD8DULL, 5, {
|
||||
'\x3A', '\x04', '\x01', '\xC4', '\xB7'}));
|
||||
this->labels[2]->SetFitText(1);
|
||||
this->labels[2]->SetAlign(6, 6);
|
||||
this->labels[2]->SetFont(DecryptName<0xADC51BF9C98B413DULL>({
|
||||
this->labels[2]->SetFont(OBFUSCATE_DECRYPT_CHARS(0xADC51BF9C98B413DULL, 6, {
|
||||
'\x7A', '\x34', '\xE7', '\xA0', '\x94', '\x1B'}));
|
||||
this->labels[2]->SetFontHeight(12);
|
||||
this->labels[2]->SetBold(1);
|
||||
|
|
@ -731,11 +724,11 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->columns[0] = new CUIStaticText();
|
||||
this->columns[0]->SetSize(70, 22);
|
||||
this->columns[0]->Move(54, 82);
|
||||
this->columns[0]->SetText(DecryptName<0xDF8117FF49CFF551ULL>({
|
||||
this->columns[0]->SetText(OBFUSCATE_DECRYPT_CHARS(0xDF8117FF49CFF551ULL, 5, {
|
||||
'\xE1', '\x18', '\x0E', '\xED', '\xFF'}));
|
||||
this->columns[0]->SetFitText(1);
|
||||
this->columns[0]->SetAlign(6, 6);
|
||||
this->columns[0]->SetFont(DecryptName<0x114901C7E37F6D49ULL>({
|
||||
this->columns[0]->SetFont(OBFUSCATE_DECRYPT_CHARS(0x114901C7E37F6D49ULL, 6, {
|
||||
'\x0E', '\x18', '\x13', '\x8A', '\xAA', '\x01'}));
|
||||
this->columns[0]->SetFontHeight(12);
|
||||
this->columns[0]->SetBold(1);
|
||||
|
|
@ -747,11 +740,11 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->columns[1] = new CUIStaticText();
|
||||
this->columns[1]->SetSize(70, 22);
|
||||
this->columns[1]->Move(124, 82);
|
||||
this->columns[1]->SetText(DecryptName<0x7D5D0F110B6B8371ULL>({
|
||||
this->columns[1]->SetText(OBFUSCATE_DECRYPT_CHARS(0x7D5D0F110B6B8371ULL, 5, {
|
||||
'\xCB', '\x2C', '\xDE', '\xB4', '\x11'}));
|
||||
this->columns[1]->SetFitText(1);
|
||||
this->columns[1]->SetAlign(6, 6);
|
||||
this->columns[1]->SetFont(DecryptName<0xF715514F5961B75BULL>({
|
||||
this->columns[1]->SetFont(OBFUSCATE_DECRYPT_CHARS(0xF715514F5961B75BULL, 6, {
|
||||
'\x1C', '\xC2', '\x0D', '\x30', '\x22', '\x51'}));
|
||||
this->columns[1]->SetFontHeight(12);
|
||||
this->columns[1]->SetBold(1);
|
||||
|
|
@ -763,11 +756,11 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->columns[2] = new CUIStaticText();
|
||||
this->columns[2]->SetSize(70, 22);
|
||||
this->columns[2]->Move(194, 82);
|
||||
this->columns[2]->SetText(DecryptName<0x4191BB5531FD3999ULL>({
|
||||
this->columns[2]->SetText(OBFUSCATE_DECRYPT_CHARS(0x4191BB5531FD3999ULL, 7, {
|
||||
'\x28', '\xE2', '\x4A', '\xFF', '\xEC', '\x41', '\x91'}));
|
||||
this->columns[2]->SetFitText(1);
|
||||
this->columns[2]->SetAlign(6, 6);
|
||||
this->columns[2]->SetFont(DecryptName<0xB19D1FA9116F39D3ULL>({
|
||||
this->columns[2]->SetFont(OBFUSCATE_DECRYPT_CHARS(0xB19D1FA9116F39D3ULL, 6, {
|
||||
'\x94', '\x4C', '\x03', '\x78', '\xC4', '\x1F'}));
|
||||
this->columns[2]->SetFontHeight(12);
|
||||
this->columns[2]->SetBold(1);
|
||||
|
|
@ -779,11 +772,11 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->columns[3] = new CUIStaticText();
|
||||
this->columns[3]->SetSize(70, 22);
|
||||
this->columns[3]->Move(264, 82);
|
||||
this->columns[3]->SetText(DecryptName<0x9569C9C7E70909AFULL>({
|
||||
this->columns[3]->SetText(OBFUSCATE_DECRYPT_CHARS(0x9569C9C7E70909AFULL, 5, {
|
||||
'\x12', '\xB3', '\xCC', '\x54', '\xC7'}));
|
||||
this->columns[3]->SetFitText(1);
|
||||
this->columns[3]->SetAlign(6, 6);
|
||||
this->columns[3]->SetFont(DecryptName<0xD7A749EB27D5BF6DULL>({
|
||||
this->columns[3]->SetFont(OBFUSCATE_DECRYPT_CHARS(0xD7A749EB27D5BF6DULL, 6, {
|
||||
'\x2A', '\xCA', '\xB9', '\x4E', '\x86', '\x49'}));
|
||||
this->columns[3]->SetFontHeight(12);
|
||||
this->columns[3]->SetBold(1);
|
||||
|
|
@ -807,24 +800,24 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->delayList->scrollBar->Move(422, 0);
|
||||
this->delayList->scrollBar->step = 10;
|
||||
this->delayList->scrollBar->SetButtonImages(
|
||||
std::string(DecryptName<0xB195637DAFCB0D59ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xB195637DAFCB0D59ULL, 29, {
|
||||
'\x99', '\xA2', '\x0B', '\x55', '\xBD', '\xAD', '\x50', '\x7C', '\x9F', '\xE9', '\x0B', '\x63', '\xC0', '\xD9', '\xC9', '\xC2', '\x3A', '\x7F', '\xA4', '\xC3', '\x11', '\x53', '\xE0', '\xC1',
|
||||
'\x77', '\x6F', '\xA6', '\xDF', '\x7D'})),
|
||||
std::string(DecryptName<0xADADEB4DF7813B55ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xADADEB4DF7813B55ULL, 31, {
|
||||
'\x95', '\x94', '\x41', '\x0D', '\x8D', '\x25', '\x68', '\x60', '\x93', '\xDF', '\x41', '\x3B', '\xF0', '\x51', '\xF1', '\xDE', '\x36', '\x49', '\xEE', '\x9B', '\x21', '\xDB', '\xC9', '\xC2',
|
||||
'\x22', '\x55', '\xAF', '\x95', '\x20', '\x9B', '\xAD'}))
|
||||
);
|
||||
this->delayList->scrollBar->SetBackground(std::string(DecryptName<0xD9452D81E5CD99C1ULL>({
|
||||
this->delayList->scrollBar->SetBackground(std::string(OBFUSCATE_DECRYPT_CHARS(0xD9452D81E5CD99C1ULL, 30, {
|
||||
'\x01', '\x36', '\x0D', '\x1F', '\x41', '\xE3', '\x80', '\x14', '\x07', '\x7D', '\x0D', '\x29', '\x3C', '\x97', '\x19', '\xAA', '\xA2', '\xEB', '\xA2', '\x89', '\xED', '\x1D', '\x28', '\xB0',
|
||||
'\xA5', '\xB7', '\xAF', '\x88', '\xF1', '\x2D'})));
|
||||
this->delayList->scrollBar->SetThumbImages(
|
||||
std::string(DecryptName<0xFD69A9B3F311818DULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xFD69A9B3F311818DULL, 33, {
|
||||
'\x4D', '\x2E', '\xD1', '\x09', '\x73', '\x67', '\xAC', '\x30', '\x4B', '\x65', '\xD1', '\x3F', '\x0E', '\x13', '\x35', '\x8E', '\xEE', '\xF3', '\x7E', '\x9F', '\xDF', '\x99', '\x0B', '\x9C',
|
||||
'\xFF', '\xDE', '\x64', '\x83', '\x9D', '\xCB', '\x04', '\x8D', '\x8D'})),
|
||||
std::string(DecryptName<0x7F2DFFC1ABE91F2BULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x7F2DFFC1ABE91F2BULL, 34, {
|
||||
'\xEB', '\xB0', '\x29', '\x51', '\x01', '\x31', '\xE8', '\xB2', '\xED', '\xFB', '\x29', '\x67', '\x7C', '\x45', '\x71', '\x0C', '\x48', '\x6D', '\x86', '\xC7', '\xAD', '\xCF', '\x4F', '\x1E',
|
||||
'\x59', '\x40', '\x84', '\xC2', '\xA5', '\xD1', '\x4F', '\x12', '\x5B', '\x1F'})),
|
||||
std::string(DecryptName<0xD98F5345098D630DULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xD98F5345098D630DULL, 35, {
|
||||
'\xCD', '\xCC', '\x4D', '\xF3', '\x85', '\x9D', '\x4A', '\x14', '\xCB', '\x87', '\x4D', '\xC5', '\xF8', '\xE9', '\xD3', '\xAA', '\x6E', '\x11', '\xE2', '\x65', '\x29', '\x63', '\xED', '\xB8',
|
||||
'\x7F', '\x3C', '\xE9', '\x66', '\x32', '\x3D', '\xA1', '\xBB', '\x60', '\x13', '\x8D'}))
|
||||
);
|
||||
|
|
@ -835,7 +828,7 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->description->SetSize(330, 35);
|
||||
this->description->Move(11, 334);
|
||||
this->description->SetTextOffset(0, 0);
|
||||
this->description->SetFont(DecryptName<0x9B0F234DEFDF7593ULL>({
|
||||
this->description->SetFont(OBFUSCATE_DECRYPT_CHARS(0x9B0F234DEFDF7593ULL, 6, {
|
||||
'\xD4', '\x00', '\xB3', '\x86', '\x20', '\x23'}));
|
||||
this->description->SetFontHeight(11);
|
||||
this->description->SetBold(false);
|
||||
|
|
@ -847,24 +840,24 @@ void CUISkillDelayInfo::OnCreate(int width, int height) {
|
|||
this->description->SetScrollBarSize(13, 35);
|
||||
this->description->SetScrollStep(1);
|
||||
this->description->SetScrollBarButtonImages(
|
||||
std::string(DecryptName<0xC9712D676B5B3943ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xC9712D676B5B3943ULL, 29, {
|
||||
'\x83', '\x96', '\x9B', '\x91', '\xA7', '\xE3', '\xB4', '\x04', '\x85', '\xDD', '\x9B', '\xA7', '\xDA', '\x97', '\x2D', '\xBA', '\x20', '\x4B', '\x34', '\x07', '\x0B', '\x1D', '\x04', '\xB9',
|
||||
'\x6D', '\x5B', '\x36', '\x1B', '\x67'})),
|
||||
std::string(DecryptName<0xED15938D333D2DB9ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xED15938D333D2DB9ULL, 31, {
|
||||
'\x79', '\x82', '\xFD', '\xC9', '\x4D', '\x5D', '\xD0', '\x20', '\x7F', '\xC9', '\xFD', '\xFF', '\x30', '\x29', '\x49', '\x9E', '\xDA', '\x5F', '\x52', '\x5F', '\xE1', '\xA3', '\x71', '\x82',
|
||||
'\xCE', '\x43', '\x13', '\x51', '\xE0', '\xE3', '\x15'}))
|
||||
);
|
||||
this->description->SetScrollBarBackground(std::string(DecryptName<0xBD2BA1C11B01E73BULL>({
|
||||
this->description->SetScrollBarBackground(std::string(OBFUSCATE_DECRYPT_CHARS(0xBD2BA1C11B01E73BULL, 30, {
|
||||
'\xFB', '\x48', '\xC1', '\xE1', '\x01', '\x6F', '\xEE', '\x70', '\xFD', '\x03', '\xC1', '\xD7', '\x7C', '\x1B', '\x77', '\xCE', '\x58', '\x95', '\x6E', '\x77', '\xAD', '\x91', '\x46', '\xD4',
|
||||
'\x5F', '\xC9', '\x63', '\x76', '\xB1', '\xA1'})));
|
||||
this->description->SetScrollBarThumbImages(
|
||||
std::string(DecryptName<0x4B755DB19953E311ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x4B755DB19953E311ULL, 33, {
|
||||
'\xD1', '\x4C', '\x93', '\x63', '\x71', '\x93', '\xB0', '\x86', '\xD7', '\x07', '\x93', '\x55', '\x0C', '\xE7', '\x29', '\x38', '\x72', '\x91', '\x3C', '\xF5', '\xDD', '\x6D', '\x17', '\x2A',
|
||||
'\x63', '\xBC', '\x26', '\xE9', '\x9F', '\x3F', '\x18', '\x3B', '\x11'})),
|
||||
std::string(DecryptName<0x4331A17F33095FEBULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0x4331A17F33095FEBULL, 34, {
|
||||
'\x2B', '\xF0', '\xC9', '\xC9', '\xBF', '\x6F', '\xF4', '\x8E', '\x2D', '\xBB', '\xC9', '\xFF', '\xC2', '\x1B', '\x6D', '\x30', '\x88', '\x2D', '\x66', '\x5F', '\x13', '\x91', '\x53', '\x22',
|
||||
'\x99', '\x00', '\x64', '\x5A', '\x1B', '\x8F', '\x53', '\x2E', '\x9B', '\x5F'})),
|
||||
std::string(DecryptName<0xD1056FF94D4D2773ULL>({
|
||||
std::string(OBFUSCATE_DECRYPT_CHARS(0xD1056FF94D4D2773ULL, 35, {
|
||||
'\xB3', '\x88', '\x8D', '\xB7', '\x39', '\xA1', '\xC0', '\x1C', '\xB5', '\xC3', '\x8D', '\x81', '\x44', '\xD5', '\x59', '\xA2', '\x10', '\x55', '\x22', '\x21', '\x95', '\x5F', '\x67', '\xB0',
|
||||
'\x01', '\x78', '\x29', '\x22', '\x8E', '\x01', '\x2B', '\xB3', '\x1E', '\x57', '\x4D'}))
|
||||
);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue