clank/rodecomp
1
0
Fork 0
Code Issues Wiki Activity

Maintenance: Raw encrypted byte arrays written as their cleartext: 159 sites in Launcher (79), UIExchangeUI (46), UISelectPackageItem

Browse source 
Batch #18641 by ragnarok-clanker: no function's compiled code changes; checked with 3 compiled unit(s).
This commit is contained in:
ragnarok-clanker 2026-11-12 17:24:24 +00:00
commit b8676b5f9b
3 changed files with 160 additions and 487 deletions
Download patch file Download diff file Expand all files Collapse all files

228
Source/Client/Application/Launcher.cpp
View file

@ -656,13 +656,13 @@ int RemovePath(std::string path, int depth, bool file) {
// OFFSET: 0x00E58820
// 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'};
const std::array<char, 18> markerSource = OBFUSCATE_SOURCE_ARRAY_CHAR("/launcherRESTART:", 0x2B477F9B5B39B301ULL);
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'};
const std::array<char, 18> prefixSource = OBFUSCATE_SOURCE_ARRAY_CHAR("/launcherRESTART:", 0x5B832361BDA77197ULL);
EncryptedName<sizeof(prefixSource), 0x5B832361BDA77197ULL>& prefixName = OBFUSCATE_DECRYPT_NAME(0x5B832361BDA77197ULL, prefixSource);
char* commandLine = marker + std::strlen(prefixName.Text());
STARTUPINFOA startup = {};
@ -786,14 +786,11 @@ bool ReplaceClientExecutable(char* executable, const char* update) {
const char* format;
if (g_serviceType == 12) {
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'};
const std::array<char, 48> messageSource = OBFUSCATE_SOURCE_ARRAY_CHAR("%s foi modificada. Clique em Ok para continuar.", 0x91E147EBBD47C39FULL);
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'};
const std::array<char, 35> messageSource = OBFUSCATE_SOURCE_ARRAY_CHAR("%s is changed. Press ok to restart", 0xD1538513DF975701ULL);
EncryptedName<sizeof(messageSource), 0xD1538513DF975701ULL>& message = OBFUSCATE_DECRYPT_NAME(0xD1538513DF975701ULL, messageSource);
format = message.Text();
}
@ -801,7 +798,7 @@ bool ReplaceClientExecutable(char* executable, const char* update) {
char text[256];
std::sprintf(text, format, executable);
const std::array titleSource = {'\x0C', '\x49', '\xFC', '\x3B', '\x27', '\x43'};
const std::array<char, 6> titleSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Alert", 0x078143534999254DULL);
EncryptedName<sizeof(titleSource), 0x078143534999254DULL>& title = OBFUSCATE_DECRYPT_NAME(0x078143534999254DULL, titleSource);
if (MessageBoxA(nullptr, text, title.Text(), MB_OKCANCEL | MB_ICONINFORMATION) != IDOK) {
return false;
@ -1028,8 +1025,7 @@ void ShutdownManagers() {
// FUNCTION: fn_24370
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'};
const std::array<char, 29> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CConfigMgr::CreateInstance()", 0xAFA5617F178B6185ULL);
EncryptedName<sizeof(nameSource), 0xAFA5617F178B6185ULL>& name = OBFUSCATE_DECRYPT_NAME(0xAFA5617F178B6185ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
@ -1038,223 +1034,181 @@ std::pair<bool, std::string> InitializeManagers() {
g_launchPassCommandLine = true;
g_stoveMgr = new (std::nothrow) CStoveMgr;
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'};
const std::array<char, 28> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CStoveMgr::CreateInstance()", 0x9B5B959B954D9333ULL);
EncryptedName<sizeof(nameSource), 0x9B5B959B954D9333ULL>& name = OBFUSCATE_DECRYPT_NAME(0x9B5B959B954D9333ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
}
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'};
const std::array<char, 30> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CThemidaMgr::CreateInstance()", 0x17FFC98B398FAF61ULL);
EncryptedName<sizeof(nameSource), 0x17FFC98B398FAF61ULL>& name = OBFUSCATE_DECRYPT_NAME(0x17FFC98B398FAF61ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CReassemblyPacketMgr::CreateInstance()) {
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'};
const std::array<char, 39> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CReassemblyPacketMgr::CreateInstance()", 0x33832D4D3FDFBDBFULL);
EncryptedName<sizeof(nameSource), 0x33832D4D3FDFBDBFULL>& name = OBFUSCATE_DECRYPT_NAME(0x33832D4D3FDFBDBFULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
Singleton<CEZ2STREffectMgr>::GetInstance()->Load();
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'};
const std::array<char, 29> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CEffectMgr::CreateInstance()", 0x7D750DADBDE9C3F1ULL);
EncryptedName<sizeof(nameSource), 0x7D750DADBDE9C3F1ULL>& name = OBFUSCATE_DECRYPT_NAME(0x7D750DADBDE9C3F1ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CreateEffectMemoryMgr()) {
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'};
const std::array<char, 35> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CEffectMemoryMgr::CreateInstance()", 0xE50B2935073DD3E9ULL);
EncryptedName<sizeof(nameSource), 0xE50B2935073DD3E9ULL>& name = OBFUSCATE_DECRYPT_NAME(0xE50B2935073DD3E9ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CreateEntryQueueMgr()) {
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'};
const std::array<char, 33> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CEntryQueueMgr::CreateInstance()", 0x3F5315DFE32B4FAFULL);
EncryptedName<sizeof(nameSource), 0x3F5315DFE32B4FAFULL>& name = OBFUSCATE_DECRYPT_NAME(0x3F5315DFE32B4FAFULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CTimeScheduler::Create()) {
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'};
const std::array<char, 33> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CTimeScheduler::CreateInstance()", 0x31956551B311FD95ULL);
EncryptedName<sizeof(nameSource), 0x31956551B311FD95ULL>& name = OBFUSCATE_DECRYPT_NAME(0x31956551B311FD95ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!EquipmentResourceMgr::Create()) {
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'};
const std::array<char, 33> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CUIResourceMgr::CreateInstance()", 0x393D916561BDC391ULL);
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'};
const std::array<char, 6> titleSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Error", 0xFF7D83CB791339D9ULL);
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'};
const std::array<char, 19> textSource = OBFUSCATE_SOURCE_ARRAY_CHAR("TownInfo file Init", 0xED5143E7C1B39315ULL);
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'};
const std::array<char, 32> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CCooltimerMgr::CreateInstance()", 0xB739073FE921AD6FULL);
EncryptedName<sizeof(nameSource), 0xB739073FE921AD6FULL>& name = OBFUSCATE_DECRYPT_NAME(0xB739073FE921AD6FULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CRenewQuestMgr::Create()) {
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'};
const std::array<char, 33> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CRenewQuestMgr::CreateInstance()", 0xC399B7091589B50BULL);
EncryptedName<sizeof(nameSource), 0xC399B7091589B50BULL>& name = OBFUSCATE_DECRYPT_NAME(0xC399B7091589B50BULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
g_renewQuestMgr->LoadQuestInfo();
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'};
const std::array<char, 31> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CClanInfoMgr::CreateInstance()", 0x955D4DF94DE9BB07ULL);
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'};
const std::array<char, 6> titleSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Error", 0x936F3D2FFDFD87F5ULL);
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'};
const std::array<char, 26> textSource = OBFUSCATE_SOURCE_ARRAY_CHAR("ChampionMonster file Init", 0x8741152D8FB34B4FULL);
EncryptedName<sizeof(textSource), 0x8741152D8FB34B4FULL>& text = OBFUSCATE_DECRYPT_NAME(0x8741152D8FB34B4FULL, textSource);
MessageBoxA(nullptr, text.Text(), caption, MB_OK);
}
if (!CMapPropertyMgr::Create()) {
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'};
const std::array<char, 34> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CMapPropertyMgr::CreateInstance()", 0x2D33791F67AD47DFULL);
EncryptedName<sizeof(nameSource), 0x2D33791F67AD47DFULL>& name = OBFUSCATE_DECRYPT_NAME(0x2D33791F67AD47DFULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
InitMapTypeInfoTable();
if (!RodexMailStore::Create()) {
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'};
const std::array<char, 34> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CRodexSystemMgr::CreateInstance()", 0x07112F85A39F4FABULL);
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'};
const std::array<char, 32> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CRoulletteMgr::CreateInstance()", 0x45E3F103CBB5F157ULL);
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'};
const std::array<char, 27> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CCURLMgr::CreateInstance()", 0xC39FB559A17D3963ULL);
EncryptedName<sizeof(nameSource), 0xC39FB559A17D3963ULL>& name = OBFUSCATE_DECRYPT_NAME(0xC39FB559A17D3963ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CAccountLinkedUserDataMgr::Initialize()) {
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'};
const std::array<char, 44> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CAccountLinkedUserDataMgr::CreateInstance()", 0x71B7691737C5A1AFULL);
EncryptedName<sizeof(nameSource), 0x71B7691737C5A1AFULL>& name = OBFUSCATE_DECRYPT_NAME(0x71B7691737C5A1AFULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CCharacterLinkedUserDataMgr::Initialize()) {
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'};
const std::array<char, 46> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CCharacterLinkedUserDataMgr::CreateInstance()", 0x6B3301E1A3079125ULL);
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'};
const std::array<char, 30> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("NMessageMgr::CreateInstance()", 0x2F2701A7E56D3D89ULL);
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'};
const std::array<char, 32> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CAsyncWorkMgr::CreateInstance()", 0x7989830DE73B9DBDULL);
EncryptedName<sizeof(nameSource), 0x7989830DE73B9DBDULL>& name = OBFUSCATE_DECRYPT_NAME(0x7989830DE73B9DBDULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!g_asyncWorkMgr->Start()) {
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'};
const std::array<char, 33> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("InstanceCAsyncWorkMgr()->Start()", 0xBDADDD87C5A50B6BULL);
EncryptedName<sizeof(nameSource), 0xBDADDD87C5A50B6BULL>& name = OBFUSCATE_DECRYPT_NAME(0xBDADDD87C5A50B6BULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CWhisperBlockMgr::Initialize()) {
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'};
const std::array<char, 35> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CWhisperBlockMgr::CreateInstance()", 0x899D11BB83695B0DULL);
EncryptedName<sizeof(nameSource), 0x899D11BB83695B0DULL>& name = OBFUSCATE_DECRYPT_NAME(0x899D11BB83695B0DULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CreatePlayerNameDictionary()) {
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'};
const std::array<char, 40> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CPlayerNameDictionary::CreateInstance()", 0x2B8725D7E95325F5ULL);
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'};
const std::array<char, 28> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CGuildMgr::CreateInstance()", 0xD3E5516F89F161D1ULL);
EncryptedName<sizeof(nameSource), 0xD3E5516F89F161D1ULL>& name = OBFUSCATE_DECRYPT_NAME(0xD3E5516F89F161D1ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
if (!CEmblemDataMgr::Initialize()) {
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'};
const std::array<char, 33> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CEmblemDataMgr::CreateInstance()", 0xF535E561137F138DULL);
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'};
const std::array<char, 26> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CTagMgr::CreateInstance()", 0xA7471985F93F9BDFULL);
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'};
const std::array<char, 32> nameSource = OBFUSCATE_SOURCE_ARRAY_CHAR("CSignBoardMgr::CreateInstance()", 0x5FFD7FABB5D1EF57ULL);
EncryptedName<sizeof(nameSource), 0x5FFD7FABB5D1EF57ULL>& name = OBFUSCATE_DECRYPT_NAME(0x5FFD7FABB5D1EF57ULL, nameSource);
return std::pair<bool, std::string>(false, std::string(name.Text()));
}
@ -1313,30 +1267,29 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
BinkSetSoundSystem(BinkOpenDirectSound, 0);
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'};
const std::array<char, 22> failureSource = OBFUSCATE_SOURCE_ARRAY_CHAR("minidump install fail", 0xEB3D4FAB0FC183DBULL);
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'};
const std::array<char, 7> replaySource = OBFUSCATE_SOURCE_ARRAY_CHAR("Replay", 0xFFBF43D1FFD5FF49ULL);
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'};
const std::array<char, 5> qmSource = OBFUSCATE_SOURCE_ARRAY_CHAR("1qm1", 0x7DB1050779034DE7ULL);
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'};
const std::array<char, 6> sakSource = OBFUSCATE_SOURCE_ARRAY_CHAR("1sak1", 0x5D6B3B1DEB2397B1ULL);
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'};
const std::array<char, 9> sakraySource = OBFUSCATE_SOURCE_ARRAY_CHAR("QmSakray", 0x7FE563BD3FB7F925ULL);
EncryptedName<sizeof(sakraySource), 0x7FE563BD3FB7F925ULL>& sakray = OBFUSCATE_DECRYPT_NAME(0x7FE563BD3FB7F925ULL, sakraySource);
server = sakray.Text();
} else {
const std::array devSource = {'\xCD', '\xBA', '\xAB', '\x5B'};
const std::array<char, 4> devSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Dev", 0x8B3FA35B5BDDDF89ULL);
EncryptedName<sizeof(devSource), 0x8B3FA35B5BDDDF89ULL>& dev = OBFUSCATE_DECRYPT_NAME(0x8B3FA35B5BDDDF89ULL, devSource);
server = dev.Text();
}
@ -1344,35 +1297,32 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
StringFormat(g_launchServerName, sizeof(g_launchServerName), static_cast<std::size_t>(-1), server);
}
const std::array rocSource = {'\x8E', '\xF7', '\x48', '\x1E', '\x62', '\x23'};
const std::array<char, 6> rocSource = OBFUSCATE_SOURCE_ARRAY_CHAR("1roc1", 0xE3FB23537D2785BFULL);
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'};
const std::array<char, 15> stoveSandboxSource = OBFUSCATE_SOURCE_ARRAY_CHAR("/stove_sandbox", 0x1FDB81175D1557E3ULL);
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'};
const std::array<char, 12> stoveLiveSource = OBFUSCATE_SOURCE_ARRAY_CHAR("/stove_live", 0x732B390D63FD47D7ULL);
EncryptedName<sizeof(stoveLiveSource), 0x732B390D63FD47D7ULL>& stoveLive = OBFUSCATE_DECRYPT_NAME(0x732B390D63FD47D7ULL, stoveLiveSource);
if (std::strstr(commandLine, stoveLive.Text())) {
g_launchPassCommandLine = true;
}
}
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'};
const std::array<char, 21> manifestSource = OBFUSCATE_SOURCE_ARRAY_CHAR("combinedata_manifest", 0xB7A76BF9CD41F99FULL);
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'};
const std::array<char, 12> captionSource = OBFUSCATE_SOURCE_ARRAY_CHAR("stove error", 0x71A509DB43792991ULL);
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'};
const std::array<char, 38> messageSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Stove 클라이언트를 통해 실행해 주세요", 0xDD69EDFFA18F537DULL);
EncryptedName<sizeof(messageSource), 0xDD69EDFFA18F537DULL>& message = OBFUSCATE_DECRYPT_NAME(0xDD69EDFFA18F537DULL, messageSource);
MessageBoxA(hWnd, FormatOwnedString(message.Text()).c_str(), title, MB_OK);
return 0;
@ -1380,7 +1330,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
FindClose(manifestFind);
if (!g_launchPassCommandLine) {
const std::array accountMarkerSource = {'\xA4', '\xAF', '\x59', '\x79'};
const std::array<char, 4> accountMarkerSource = OBFUSCATE_SOURCE_ARRAY_CHAR("-t:", 0xB3CF9BEB7963DB89ULL);
EncryptedName<sizeof(accountMarkerSource), 0xB3CF9BEB7963DB89ULL>& accountMarker = OBFUSCATE_DECRYPT_NAME(0xB3CF9BEB7963DB89ULL, accountMarkerSource);
if (std::strstr(commandLine, accountMarker.Text()) && !g_replayMode) {
g_session.m_launchAccountEnabled = true;
@ -1407,31 +1357,28 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
std::strncpy(g_launchServerName, server, length > 24 ? 24 : length);
g_launchServerName[length > 23 ? 23 : length] = 0;
const std::array nonPaySource = {'\x3D', '\x4E', '\x89', '\x17', '\x4A', '\x00', '\xED', '\xEA', '\x14', '\x21'};
const std::array<char, 10> nonPaySource = OBFUSCATE_SOURCE_ARRAY_CHAR("NonPayRag", 0x8BBF792B47E72173ULL);
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'};
const std::array<char, 6> eventSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Event", 0x9B9D51AD3515F779ULL);
EncryptedName<sizeof(eventSource), 0x9B9D51AD3515F779ULL>& event = OBFUSCATE_DECRYPT_NAME(0x9B9D51AD3515F779ULL, eventSource);
if (std::strstr(g_launchServerName, event.Text())) {
g_launchServerKind = 2;
}
}
} 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'};
const std::array<char, 21> secondManifestSource = OBFUSCATE_SOURCE_ARRAY_CHAR("combinedata_manifest", 0xB5D7B5AF4FEDFF57ULL);
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'};
const std::array<char, 12> secondCaptionSource = OBFUSCATE_SOURCE_ARRAY_CHAR("stove error", 0x038535BB092533B7ULL);
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'};
const std::array<char, 38> secondMessageSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Stove 클라이언트를 통해 실행해 주세요", 0xFB2BC75769E777D3ULL);
EncryptedName<sizeof(secondMessageSource), 0xFB2BC75769E777D3ULL>& secondMessage = OBFUSCATE_DECRYPT_NAME(0xFB2BC75769E777D3ULL, secondMessageSource);
MessageBoxA(hWnd, FormatOwnedString(secondMessage.Text()).c_str(), title, MB_OK);
return 0;
@ -1448,7 +1395,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
}
}
const std::array ragSource = {'\x32', '\x47', '\xF8', '\xD2', '\x82', '\x77'};
const std::array<char, 6> ragSource = OBFUSCATE_SOURCE_ARRAY_CHAR("1rag1", 0x6BC977B3B5993503ULL);
EncryptedName<sizeof(ragSource), 0x6BC977B3B5993503ULL>& rag = OBFUSCATE_DECRYPT_NAME(0x6BC977B3B5993503ULL, ragSource);
std::strstr(commandLine, rag.Text());
@ -1461,14 +1408,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'};
const std::array<char, 10> accountSource = OBFUSCATE_SOURCE_ARRAY_CHAR("/account:", 0x072D2D872D259D5BULL);
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'};
const std::array<char, 9> dataGrfSource = OBFUSCATE_SOURCE_ARRAY_CHAR("data.grf", 0x875FCDF1E7A1795FULL);
EncryptedName<sizeof(dataGrfSource), 0x875FCDF1E7A1795FULL>& dataGrf = OBFUSCATE_DECRYPT_NAME(0x875FCDF1E7A1795FULL, dataGrfSource);
dataGrf.Text();
HMODULE kernel = GetModuleHandleA("kernel32.dll");
@ -1503,10 +1450,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'};
const std::array<char, 15> patchSandboxSource = OBFUSCATE_SOURCE_ARRAY_CHAR("/stove_sandbox", 0x79DF094DD9616575ULL);
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'};
const std::array<char, 12> patchLiveSource = OBFUSCATE_SOURCE_ARRAY_CHAR("/stove_live", 0x9D8F2D37BFFD61B7ULL);
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)) {
@ -1516,7 +1463,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'};
const std::array<char, 10> setupSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Setup.exe", 0x4755C1355575FD37ULL);
EncryptedName<sizeof(setupSource), 0x4755C1355575FD37ULL>& setup = OBFUSCATE_DECRYPT_NAME(0x4755C1355575FD37ULL, setupSource);
while (ReadSetup() == 0) {
if (_access(setup.Text(), 0) == 0) {
@ -1524,12 +1471,12 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
}
}
const std::array saveDataSource = {'\x74', '\xBC', '\x01', '\x06', '\x07', '\x54', '\xBF', '\x70', '\x07'};
const std::array<char, 9> saveDataSource = OBFUSCATE_SOURCE_ARRAY_CHAR("savedata", 0x11CB35636377DD07ULL);
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'};
const std::array<char, 9> saveDataDirectorySource = OBFUSCATE_SOURCE_ARRAY_CHAR("savedata", 0x3D371F5B0F7F9327ULL);
EncryptedName<sizeof(saveDataDirectorySource), 0x3D371F5B0F7F9327ULL>& saveDataDirectory = OBFUSCATE_DECRYPT_NAME(0x3D371F5B0F7F9327ULL, saveDataDirectorySource);
CreateDirectoryA(saveDataDirectory.Text(), nullptr);
} else {
@ -1553,8 +1500,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
CoInitialize(nullptr);
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'};
const std::array<char, 25> audioFailureSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Audio System Init Failed", 0x6BF729E30729CF29ULL);
EncryptedName<sizeof(audioFailureSource), 0x6BF729E30729CF29ULL>& audioFailure = OBFUSCATE_DECRYPT_NAME(0x6BF729E30729CF29ULL, audioFailureSource);
if (audioFailure.Encrypted()) {
audioFailure.Text();
@ -1567,8 +1513,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
g_session.InitClientData();
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'};
const std::array<char, 17> resourceNamesSource = OBFUSCATE_SOURCE_ARRAY_CHAR("resNameTable.txt", 0x1F1D51274373C1FDULL);
EncryptedName<sizeof(resourceNamesSource), 0x1F1D51274373C1FDULL>& resourceNames = OBFUSCATE_DECRYPT_NAME(0x1F1D51274373C1FDULL, resourceNamesSource);
resources.LoadAliases(reinterpret_cast<int>(resourceNames.Text()));
@ -1578,16 +1523,14 @@ 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'};
const std::array<char, 6> errorSource = OBFUSCATE_SOURCE_ARRAY_CHAR("ERROR", 0x5F93A1C3A7AD7537ULL);
EncryptedName<sizeof(errorSource), 0x5F93A1C3A7AD7537ULL>& error = OBFUSCATE_DECRYPT_NAME(0x5F93A1C3A7AD7537ULL, errorSource);
MessageBoxA(nullptr, managers.second.c_str(), error.Text(), MB_OK);
return 1;
}
if (GetRenderSystemHolder()->Initialize(g_configuredRenderBackend, hWnd) < 0) {
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'};
const std::array<char, 41> deviceFailureSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Cannot init d3d OR grf file has problem.", 0x474DC581D5E98357ULL);
EncryptedName<sizeof(deviceFailureSource), 0x474DC581D5E98357ULL>& deviceFailure = OBFUSCATE_DECRYPT_NAME(0x474DC581D5E98357ULL, deviceFailureSource);
ShowErrorDialog(deviceFailure.Text(), MB_OK);
return 1;
@ -1608,8 +1551,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
g_windowMgr.SetScreenSize(g_renderer->viewport.width, g_renderer->viewport.height);
g_windowMgr.LoadUIRectInfo();
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'};
const std::array<char, 30> guildFlagSource = OBFUSCATE_SOURCE_ARRAY_CHAR("model\\3dmob\\guildflag90_1.gr2", 0x097389157345A787ULL);
EncryptedName<sizeof(guildFlagSource), 0x097389157345A787ULL>& guildFlag = OBFUSCATE_DECRYPT_NAME(0x097389157345A787ULL, guildFlagSource);
g_grannyAnimationLibrary.Load(guildFlag.Text(), 1, 0);
g_skinInfo.Refresh();
@ -1624,7 +1566,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
g_loginStartMode = 0;
}
const std::array memoSource = {'\xE4', '\x0E', '\x84', '\xF0', '\x4B'};
const std::array<char, 5> memoSource = OBFUSCATE_SOURCE_ARRAY_CHAR("memo", 0xC5995F4B9FE96B89ULL);
EncryptedName<sizeof(memoSource), 0xC5995F4B9FE96B89ULL>& memo = OBFUSCATE_DECRYPT_NAME(0xC5995F4B9FE96B89ULL, memoSource);
WIN32_FIND_DATAA memoData;
HANDLE memoFind = FindFirstFileA(memo.Text(), &memoData);
@ -1636,12 +1578,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'};
const std::array<char, 7> replayFolderSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Replay", 0x610F7DD1EFC1C91BULL);
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'};
const std::array<char, 7> replayDirectorySource = OBFUSCATE_SOURCE_ARRAY_CHAR("Replay", 0xED15938D333D2DB9ULL);
EncryptedName<sizeof(replayDirectorySource), 0xED15938D333D2DB9ULL>& replayDirectory = OBFUSCATE_DECRYPT_NAME(0xED15938D333D2DB9ULL, replayDirectorySource);
CreateDirectoryA(replayDirectory.Text(), nullptr);
} else {
@ -1651,7 +1593,7 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
WIN32_FIND_DATAA navigationData;
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'};
const std::array<char, 15> navigationDirectorySource = OBFUSCATE_SOURCE_ARRAY_CHAR("Navigationdata", 0xC9712D676B5B3943ULL);
EncryptedName<sizeof(navigationDirectorySource), 0xC9712D676B5B3943ULL>& navigationDirectory = OBFUSCATE_DECRYPT_NAME(0xC9712D676B5B3943ULL, navigationDirectorySource);
CreateDirectoryA(navigationDirectory.Text(), nullptr);
} else {
@ -1720,44 +1662,32 @@ int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, in
CleanupUnhandledExceptionHandler();
if (g_restartClient) {
const std::array devServerSource = {'\x55', '\x86', '\x25', '\x99'};
const std::array<char, 4> devServerSource = OBFUSCATE_SOURCE_ARRAY_CHAR("Dev", 0x4B755DB19953E311ULL);
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'};
const std::array<char, 5> openSource = OBFUSCATE_SOURCE_ARRAY_CHAR("OPEN", 0xD7A749EB27D5BF6DULL);
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'};
const std::array<char, 62> parametersSource = OBFUSCATE_SOURCE_ARRAY_CHAR("http://admtools.gnjoy.com/gamestarter/devro.asp?GameCode=4011", 0xFD69A9B3F311818DULL);
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'};
const std::array<char, 62> fileSource = OBFUSCATE_SOURCE_ARRAY_CHAR("http://admtools.gnjoy.com/gamestarter/devro.asp?GameCode=4011", 0x7F2DFFC1ABE91F2BULL);
EncryptedName<sizeof(fileSource), 0x7F2DFFC1ABE91F2BULL>& file = OBFUSCATE_DECRYPT_NAME(0x7F2DFFC1ABE91F2BULL, fileSource);
const char* target = file.Text();
const std::array openSource = {'\x74', '\xB7', '\x44', '\x55', '\xC1'};
const std::array<char, 5> openSource = OBFUSCATE_SOURCE_ARRAY_CHAR("OPEN", 0xBD2BA1C11B01E73BULL);
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'};
const std::array<char, 62> parametersSource = OBFUSCATE_SOURCE_ARRAY_CHAR("http://admtools.gnjoy.com/gamestarter/devro.asp?GameCode=6011", 0xB195637DAFCB0D59ULL);
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'};
const std::array<char, 62> fileSource = OBFUSCATE_SOURCE_ARRAY_CHAR("http://admtools.gnjoy.com/gamestarter/devro.asp?GameCode=6011", 0xD98F5345098D630DULL);
EncryptedName<sizeof(fileSource), 0xD98F5345098D630DULL>& file = OBFUSCATE_DECRYPT_NAME(0xD98F5345098D630DULL, fileSource);
const char* target = file.Text();
const std::array openSource = {'\xDC', '\x25', '\x9A', '\xA1', '\x4D'};
const std::array<char, 5> openSource = OBFUSCATE_SOURCE_ARRAY_CHAR("OPEN", 0x9B0F234DEFDF7593ULL);
EncryptedName<sizeof(openSource), 0x9B0F234DEFDF7593ULL>& open = OBFUSCATE_DECRYPT_NAME(0x9B0F234DEFDF7593ULL, openSource);
ShellExecuteA(nullptr, open.Text(), target, arguments, nullptr, SW_SHOWNORMAL);
}

228
Source/UI/Exchange/UIExchangeUI.cpp
View file

@ -626,20 +626,11 @@ void CUIExchangeUI::OnCreate(int width, int height) {
// GLOBAL: gl_25394
thread_local EncryptedName<sizeof(titleRightSource), 0x17A9E5BF39AD4737ULL> titleRightName(titleRightSource.data);
const std::string titleRight(titleRightName.Text());
const char titleMiddleSource[] = {
'\x65', '\x32', '\xAD', '\x03', '\xA3', '\xE9', '\xB2', '\xCE', '\x63', '\x79', '\xAD', '\x35', '\xDE', '\x9D', '\x2B', '\x61',
'\xC4', '\xEE', '\x04', '\x9A', '\x3C', '\x4E', '\x19', '\x77', '\xC0', '\xEF', '\x0B', '\x98', '\x00', '\x42', '\x2B', '\x77',
'\xCC', '\xE9', '\x01', '\x9C', '\x01', '\x46', '\x05', '\x5C', '\xC8', '\xF4', '\x09', '\xD7', '\x01', '\x4A', '\x07', '\x03'
};
const char titleMiddleSource[] = OBFUSCATE_SOURCE_CHARS(48, "유저인터페이스\\basic_interface\\titlebar_mid.bmp", 0x03772763F96D9DA5ULL);
// GLOBAL: gl_25395
thread_local EncryptedName<sizeof(titleMiddleSource), 0x03772763F96D9DA5ULL> titleMiddleName(titleMiddleSource);
const std::string titleMiddle(titleMiddleName.Text());
const char titleLeftSource[] = {
'\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'
};
const char titleLeftSource[] = OBFUSCATE_SOURCE_CHARS(49, "유저인터페이스\\basic_interface\\titlebar_left.bmp", 0x0B7109397F6B1387ULL);
// GLOBAL: gl_25396
thread_local EncryptedName<sizeof(titleLeftSource), 0x0B7109397F6B1387ULL> titleLeftName(titleLeftSource);
const std::string titleLeft(titleLeftName.Text());
@ -654,9 +645,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
title->SetFitText(0);
title->SetAlign(0, 6);
{
const char titleFontSource[] = {
'\x20', '\xDE', '\xFD', '\xCC', '\xCC', '\x3F'
};
const char titleFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Gulim", 0x13E33FA1A591AB67ULL);
// GLOBAL: gl_25397
thread_local EncryptedName<sizeof(titleFontSource), 0x13E33FA1A591AB67ULL> titleFontName(titleFontSource);
title->SetFont(std::string(titleFontName.Text()));
@ -677,9 +666,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->partnerText->SetAlign(0, 6);
{
CUIStaticText* partner = this->partnerText;
const char partnerFontSource[] = {
'\x28', '\x08', '\x97', '\x4A', '\x1C', '\x07'
};
const char partnerFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Gulim", 0xCD8F077123FB7D6FULL);
// GLOBAL: gl_25398
thread_local EncryptedName<sizeof(partnerFontSource), 0xCD8F077123FB7D6FULL> partnerFontName(partnerFontSource);
partner->SetFont(std::string(partnerFontName.Text()));
@ -696,11 +683,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->backgroundImage->Move(0, 17);
{
CUIStaticImage* background = this->backgroundImage;
const char backgroundSource[] = {
'\x83', '\x86', '\x93', '\xDD', '\x15', '\x71', '\x8C', '\x54', '\x85', '\xCD', '\x93', '\xEB', '\x68', '\x05', '\x15', '\xFB',
'\x22', '\x5A', '\x3A', '\x44', '\x8A', '\xD6', '\x27', '\xED', '\x26', '\x5B', '\x35', '\x46', '\xB6', '\xDA', '\x15', '\xFC',
'\x3B', '\x4A', '\x3B', '\x46', '\xBB', '\xD8', '\x2C', '\xC6', '\x21', '\x4E', '\x61', '\x09', '\xB7', '\xD2', '\x39', '\x99'
};
const char backgroundSource[] = OBFUSCATE_SOURCE_CHARS(48, "유저인터페이스\\basic_interface\\exchange_bg2.bmp", 0x9949BFD527532943ULL);
// GLOBAL: gl_25399
thread_local EncryptedName<sizeof(backgroundSource), 0x9949BFD527532943ULL> backgroundName(backgroundSource);
background->SetImage(std::string(backgroundName.Text()));
@ -721,53 +704,32 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->firstList->scrollBar->Move(259, 0);
this->firstList->scrollBar->step = 30;
{
const char downSource[] = {
'\xC9', '\x88', '\xEF', '\x41', '\x7D', '\x93', '\xB8', '\x14', '\xCF', '\xC3', '\xEF', '\x77', '\x00', '\xE7', '\x21', '\xAA',
'\x6A', '\x55', '\x40', '\xD7', '\xD1', '\x6D', '\x19', '\xB6', '\x7E', '\x49', '\x01', '\xD9', '\xD0', '\x2D', '\x7D'
};
const char downSource[] = OBFUSCATE_SOURCE_CHARS(31, "유저인터페이스\\scroll0down.bmp", 0xD97D5DBDBB2F2709ULL);
// GLOBAL: gl_25400
thread_local EncryptedName<sizeof(downSource), 0xD97D5DBDBB2F2709ULL> downName(downSource);
const std::string down(downName.Text());
const char upSource[] = {
'\xBF', '\xBC', '\x1F', '\x2B', '\x45', '\xA9', '\xBC', '\x20', '\xB9', '\xF7', '\x1F', '\x1D', '\x38', '\xDD', '\x25', '\x9E',
'\x1C', '\x61', '\xB0', '\xBD', '\xE9', '\x57', '\x0C', '\x9D', '\x51', '\x71', '\xB2', '\xA1', '\x85'
};
const char upSource[] = OBFUSCATE_SOURCE_CHARS(29, "유저인터페이스\\scroll0up.bmp", 0xED796785D1DF137FULL);
// GLOBAL: gl_25401
thread_local EncryptedName<sizeof(upSource), 0xED796785D1DF137FULL> upName(upSource);
const std::string up(upName.Text());
this->firstList->scrollBar->SetButtonImages(up, down);
}
{
const char backgroundSource[] = {
'\x5F', '\x6A', '\xAD', '\x51', '\x17', '\xE7', '\x38', '\x68', '\x59', '\x21', '\xAD', '\x67', '\x6A', '\x93', '\xA1', '\xD6',
'\xFC', '\xB7', '\x02', '\xC7', '\xBB', '\x19', '\x90', '\xCC', '\xFB', '\xEB', '\x0F', '\xC6', '\xA7', '\x29'
};
const char backgroundSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\scroll0mid.bmp", 0xA5FD29D7AB6DC59FULL);
// GLOBAL: gl_25402
thread_local EncryptedName<sizeof(backgroundSource), 0xA5FD29D7AB6DC59FULL> backgroundName(backgroundSource);
this->firstList->scrollBar->SetBackground(std::string(backgroundName.Text()));
}
{
const char thumbBottomSource[] = {
'\x21', '\xD4', '\x39', '\x2D', '\x15', '\xDD', '\xFC', '\x10', '\x27', '\x9F', '\x39', '\x1B', '\x68', '\xA9', '\x65', '\xAE',
'\x82', '\x09', '\x96', '\xBB', '\xB9', '\x23', '\x5B', '\xBC', '\x93', '\x24', '\x9D', '\xB8', '\xA2', '\x7D', '\x17', '\xBF',
'\x8C', '\x0B', '\xF9'
};
const char thumbBottomSource[] = OBFUSCATE_SOURCE_CHARS(35, "유저인터페이스\\scroll0bar_down.bmp", 0xDD3913D5D7F97BE1ULL);
// GLOBAL: gl_25403
thread_local EncryptedName<sizeof(thumbBottomSource), 0xDD3913D5D7F97BE1ULL> thumbBottomName(thumbBottomSource);
const std::string thumbBottom(thumbBottomName.Text());
const char thumbMiddleSource[] = {
'\x5B', '\xF8', '\xC3', '\x63', '\xA7', '\xCB', '\xC0', '\xC8', '\x5D', '\xB3', '\xC3', '\x55', '\xDA', '\xBF', '\x59', '\x76',
'\xF8', '\x25', '\x6C', '\xF5', '\x0B', '\x35', '\x67', '\x64', '\xE9', '\x08', '\x6E', '\xF0', '\x03', '\x2B', '\x67', '\x68',
'\xEB', '\x57'
};
const char thumbMiddleSource[] = OBFUSCATE_SOURCE_CHARS(34, "유저인터페이스\\scroll0bar_mid.bmp", 0x050505679903579BULL);
// GLOBAL: gl_25404
thread_local EncryptedName<sizeof(thumbMiddleSource), 0x050505679903579BULL> thumbMiddleName(thumbMiddleSource);
const std::string thumbMiddle(thumbMiddleName.Text());
const char thumbTopSource[] = {
'\x31', '\x68', '\xF9', '\xF3', '\xD7', '\xB7', '\x8A', '\x3C', '\x37', '\x23', '\xF9', '\xC5', '\xAA', '\xC3', '\x13', '\x82',
'\x92', '\xB5', '\x56', '\x65', '\x7B', '\x49', '\x2D', '\x90', '\x83', '\x98', '\x4C', '\x79', '\x39', '\x1B', '\x22', '\x81',
'\xF1'
};
const char thumbTopSource[] = OBFUSCATE_SOURCE_CHARS(33, "유저인터페이스\\scroll0bar_up.bmp", 0xF14F79170939C7F1ULL);
// GLOBAL: gl_25405
thread_local EncryptedName<sizeof(thumbTopSource), 0xF14F79170939C7F1ULL> thumbTopName(thumbTopSource);
const std::string thumbTop(thumbTopName.Text());
@ -780,9 +742,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->ownZenyHighlight->SetSize(150, 18);
this->ownZenyHighlight->Move(69, 330);
{
const char zenySource[] = {
'\x97', '\xF5'
};
const char zenySource[] = OBFUSCATE_SOURCE_CHARS(2, "0", 0xBF2B4B31397FF5A7ULL);
// GLOBAL: gl_25406
thread_local EncryptedName<sizeof(zenySource), 0xBF2B4B31397FF5A7ULL> zenyName(zenySource);
this->ownZenyHighlight->SetText(zenyName.Text());
@ -791,9 +751,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->ownZenyHighlight->SetAlign(2, 6);
{
CUIStaticText* text = this->ownZenyHighlight;
const char zenyFontSource[] = {
'\xFC', '\xCF', '\x84', '\x56', '\xD7', '\xBF'
};
const char zenyFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Arial", 0x83EFBFBB37EDBDBDULL);
// GLOBAL: gl_25407
thread_local EncryptedName<sizeof(zenyFontSource), 0x83EFBFBB37EDBDBDULL> zenyFontName(zenyFontSource);
text->SetFont(std::string(zenyFontName.Text()));
@ -809,9 +767,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->ownZenyText->SetSize(150, 18);
this->ownZenyText->Move(70, 330);
{
const char zenySource[] = {
'\xBF', '\x99'
};
const char zenySource[] = OBFUSCATE_SOURCE_CHARS(2, "0", 0x39FF7FB50DEB998FULL);
// GLOBAL: gl_25408
thread_local EncryptedName<sizeof(zenySource), 0x39FF7FB50DEB998FULL> zenyName(zenySource);
this->ownZenyText->SetText(zenyName.Text());
@ -820,9 +776,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->ownZenyText->SetAlign(2, 6);
{
CUIStaticText* text = this->ownZenyText;
const char zenyFontSource[] = {
'\xD6', '\x83', '\x88', '\xBC', '\xBD', '\x93'
};
const char zenyFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Arial", 0x2FE993D1DDE1F197ULL);
// GLOBAL: gl_25409
thread_local EncryptedName<sizeof(zenyFontSource), 0x2FE993D1DDE1F197ULL> zenyFontName(zenyFontSource);
text->SetFont(std::string(zenyFontName.Text()));
@ -838,9 +792,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->ownZenyShadow->SetSize(150, 18);
this->ownZenyShadow->Move(70, 331);
{
const char zenySource[] = {
'\xFD', '\xF1'
};
const char zenySource[] = OBFUSCATE_SOURCE_CHARS(2, "0", 0xAD075B8DB599F1CDULL);
// GLOBAL: gl_25410
thread_local EncryptedName<sizeof(zenySource), 0xAD075B8DB599F1CDULL> zenyName(zenySource);
this->ownZenyShadow->SetText(zenyName.Text());
@ -849,9 +801,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->ownZenyShadow->SetAlign(2, 6);
{
CUIStaticText* text = this->ownZenyShadow;
const char zenyFontSource[] = {
'\x3E', '\x67', '\xE4', '\x70', '\x5B', '\x0F'
};
const char zenyFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Arial", 0x2F8B0F37118D157FULL);
// GLOBAL: gl_25411
thread_local EncryptedName<sizeof(zenyFontSource), 0x2F8B0F37118D157FULL> zenyFontName(zenyFontSource);
text->SetFont(std::string(zenyFontName.Text()));
@ -892,53 +842,32 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->secondList->scrollBar->Move(259, 0);
this->secondList->scrollBar->step = 30;
{
const char downSource[] = {
'\x3D', '\x16', '\x7B', '\xDB', '\x5F', '\x33', '\x84', '\x84', '\x3B', '\x5D', '\x7B', '\xED', '\x22', '\x47', '\x1D', '\x3A',
'\x9E', '\xCB', '\xD4', '\x4D', '\xF3', '\xCD', '\x25', '\x26', '\x8A', '\xD7', '\x95', '\x43', '\xF2', '\x8D', '\x41'
};
const char downSource[] = OBFUSCATE_SOURCE_CHARS(31, "유저인터페이스\\scroll0down.bmp", 0x4941FD9F21BBB9FDULL);
// GLOBAL: gl_25412
thread_local EncryptedName<sizeof(downSource), 0x4941FD9F21BBB9FDULL> downName(downSource);
const std::string down(downName.Text());
const char upSource[] = {
'\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'
};
const char upSource[] = OBFUSCATE_SOURCE_CHARS(29, "유저인터페이스\\scroll0up.bmp", 0x35E5656B5DEDCD75ULL);
// GLOBAL: gl_25413
thread_local EncryptedName<sizeof(upSource), 0x35E5656B5DEDCD75ULL> upName(upSource);
const std::string up(upName.Text());
this->secondList->scrollBar->SetButtonImages(up, down);
}
{
const char backgroundSource[] = {
'\x3D', '\x78', '\x8D', '\x53', '\x75', '\x41', '\x52', '\x2A', '\x3B', '\x33', '\x8D', '\x65', '\x08', '\x35', '\xCB', '\x94',
'\x9E', '\xA5', '\x22', '\xC5', '\xD9', '\xBF', '\xFA', '\x8E', '\x99', '\xF9', '\x2F', '\xC4', '\xC5', '\x8F'
};
const char backgroundSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\scroll0mid.bmp", 0xE7978FB5A94DD7FDULL);
// GLOBAL: gl_25414
thread_local EncryptedName<sizeof(backgroundSource), 0xE7978FB5A94DD7FDULL> backgroundName(backgroundSource);
this->secondList->scrollBar->SetBackground(std::string(backgroundName.Text()));
}
{
const char thumbBottomSource[] = {
'\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', '\x9D', '\x1C', '\x8E', '\xB7', '\x3B', '\x13',
'\xA4', '\x63', '\xF9'
};
const char thumbBottomSource[] = OBFUSCATE_SOURCE_CHARS(35, "유저인터페이스\\scroll0bar_down.bmp", 0x7115D9F973F913C9ULL);
// GLOBAL: gl_25415
thread_local EncryptedName<sizeof(thumbBottomSource), 0x7115D9F973F913C9ULL> thumbBottomName(thumbBottomSource);
const std::string thumbBottom(thumbBottomName.Text());
const char thumbMiddleSource[] = {
'\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'
};
const char thumbMiddleSource[] = OBFUSCATE_SOURCE_CHARS(34, "유저인터페이스\\scroll0bar_mid.bmp", 0xCB1D253B7FE1F563ULL);
// GLOBAL: gl_25416
thread_local EncryptedName<sizeof(thumbMiddleSource), 0xCB1D253B7FE1F563ULL> thumbMiddleName(thumbMiddleSource);
const std::string thumbMiddle(thumbMiddleName.Text());
const char thumbTopSource[] = {
'\xAB', '\x16', '\x07', '\xF5', '\xA7', '\x41', '\x38', '\x7A', '\xAD', '\x5D', '\x07', '\xC3', '\xDA', '\x35', '\xA1', '\xC4',
'\x08', '\xCB', '\xA8', '\x63', '\x0B', '\xBF', '\x9F', '\xD6', '\x19', '\xE6', '\xB2', '\x7F', '\x49', '\xED', '\x90', '\xC7',
'\x6B'
};
const char thumbTopSource[] = OBFUSCATE_SOURCE_CHARS(33, "유저인터페이스\\scroll0bar_up.bmp", 0xB7FD8F670FC7B96BULL);
// GLOBAL: gl_25417
thread_local EncryptedName<sizeof(thumbTopSource), 0xB7FD8F670FC7B96BULL> thumbTopName(thumbTopSource);
const std::string thumbTop(thumbTopName.Text());
@ -951,9 +880,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->partnerZenyHighlight->SetSize(150, 18);
this->partnerZenyHighlight->Move(349, 330);
{
const char zenySource[] = {
'\x2D', '\x05'
};
const char zenySource[] = OBFUSCATE_SOURCE_CHARS(2, "0", 0xE55723712993051DULL);
// GLOBAL: gl_25418
thread_local EncryptedName<sizeof(zenySource), 0xE55723712993051DULL> zenyName(zenySource);
this->partnerZenyHighlight->SetText(zenyName.Text());
@ -962,9 +889,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->partnerZenyHighlight->SetAlign(2, 6);
{
CUIStaticText* text = this->partnerZenyHighlight;
const char zenyFontSource[] = {
'\x0E', '\x15', '\x84', '\xE4', '\x65', '\x37'
};
const char zenyFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Arial", 0x793F370985ED674FULL);
// GLOBAL: gl_25419
thread_local EncryptedName<sizeof(zenyFontSource), 0x793F370985ED674FULL> zenyFontName(zenyFontSource);
text->SetFont(std::string(zenyFontName.Text()));
@ -980,9 +905,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->partnerZenyText->SetSize(150, 18);
this->partnerZenyText->Move(350, 330);
{
const char zenySource[] = {
'\x4F', '\xD5'
};
const char zenySource[] = OBFUSCATE_SOURCE_CHARS(2, "0", 0x0F15B16B5BAFD57FULL);
// GLOBAL: gl_25420
thread_local EncryptedName<sizeof(zenySource), 0x0F15B16B5BAFD57FULL> zenyName(zenySource);
this->partnerZenyText->SetText(zenyName.Text());
@ -991,9 +914,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->partnerZenyText->SetAlign(2, 6);
{
CUIStaticText* text = this->partnerZenyText;
const char zenyFontSource[] = {
'\x62', '\x83', '\xBE', '\x76', '\xBB', '\x49'
};
const char zenyFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Arial", 0x7DE349D717D7F123ULL);
// GLOBAL: gl_25421
thread_local EncryptedName<sizeof(zenyFontSource), 0x7DE349D717D7F123ULL> zenyFontName(zenyFontSource);
text->SetFont(std::string(zenyFontName.Text()));
@ -1009,9 +930,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->partnerZenyShadow->SetSize(150, 18);
this->partnerZenyShadow->Move(350, 331);
{
const char zenySource[] = {
'\xD1', '\x99'
};
const char zenySource[] = OBFUSCATE_SOURCE_CHARS(2, "0", 0x7321C3814F8799E1ULL);
// GLOBAL: gl_25422
thread_local EncryptedName<sizeof(zenySource), 0x7321C3814F8799E1ULL> zenyName(zenySource);
this->partnerZenyShadow->SetText(zenyName.Text());
@ -1020,9 +939,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->partnerZenyShadow->SetAlign(2, 6);
{
CUIStaticText* text = this->partnerZenyShadow;
const char zenyFontSource[] = {
'\x0E', '\xD3', '\xA6', '\x54', '\x0F', '\xD7'
};
const char zenyFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Arial", 0x7941D76335CFA14FULL);
// GLOBAL: gl_25423
thread_local EncryptedName<sizeof(zenyFontSource), 0x7941D76335CFA14FULL> zenyFontName(zenyFontSource);
text->SetFont(std::string(zenyFontName.Text()));
@ -1041,31 +958,19 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->logCheckBox->disabled = 0;
this->logCheckBox->Invalidate();
{
const char disabledSource[] = {
'\xA5', '\xFA', '\x09', '\x85', '\xCD', '\x21', '\xEA', '\x88', '\xA3', '\xB1', '\x09', '\xB3', '\xB0', '\x55', '\x73', '\x26',
'\x0D', '\x30', '\xAA', '\x14', '\x6F', '\x80', '\x57', '\x1A', '\x55', '\x7B', '\xAB', '\x12', '\x7D', '\xEF'
};
const char disabledSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\checkbox_0.bmp", 0x452FEF0D7FC95565ULL);
// GLOBAL: gl_25424
thread_local EncryptedName<sizeof(disabledSource), 0x452FEF0D7FC95565ULL> disabledName(disabledSource);
const std::string disabled(disabledName.Text());
const char pressedSource[] = {
'\x9D', '\xA2', '\x89', '\x73', '\x61', '\xB3', '\x28', '\x52', '\x9B', '\xE9', '\x89', '\x45', '\x1C', '\xC7', '\xB1', '\xFC',
'\x35', '\x68', '\x2A', '\xE2', '\xC3', '\x12', '\x95', '\xC0', '\x6D', '\x23', '\x2B', '\xE4', '\xD1', '\x7D'
};
const char pressedSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\checkbox_0.bmp", 0x9FED7DA189490D5DULL);
// GLOBAL: gl_25425
thread_local EncryptedName<sizeof(pressedSource), 0x9FED7DA189490D5DULL> pressedName(pressedSource);
const std::string pressed(pressedName.Text());
const char hoverSource[] = {
'\x73', '\xC8', '\x99', '\x75', '\x1F', '\xE9', '\x5E', '\x4E', '\x75', '\x83', '\x99', '\x43', '\x62', '\x9D', '\xC7', '\xE0',
'\xDB', '\x02', '\x3A', '\xE4', '\xBD', '\x48', '\xE3', '\xDC', '\x82', '\x49', '\x3B', '\xE2', '\xAF', '\x27'
};
const char hoverSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\checkbox_1.bmp", 0x839B27DF8F5967B3ULL);
// GLOBAL: gl_25426
thread_local EncryptedName<sizeof(hoverSource), 0x839B27DF8F5967B3ULL> hoverName(hoverSource);
const std::string hover(hoverName.Text());
const char normalSource[] = {
'\xAD', '\xB4', '\x67', '\xEB', '\xB7', '\xA1', '\x0E', '\x3E', '\xAB', '\xFF', '\x67', '\xDD', '\xCA', '\xD5', '\x97', '\x90',
'\x05', '\x7E', '\xC4', '\x7A', '\x15', '\x00', '\xB3', '\xAC', '\x5D', '\x35', '\xC5', '\x7C', '\x07', '\x6F'
};
const char normalSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\checkbox_0.bmp", 0xF3CB6F7711A71B6DULL);
// GLOBAL: gl_25427
thread_local EncryptedName<sizeof(normalSource), 0xF3CB6F7711A71B6DULL> normalName(normalSource);
const std::string normal(normalName.Text());
@ -1083,9 +988,7 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->screenshotLabel->SetAlign(0, 6);
{
CUIStaticText* label = this->screenshotLabel;
const char labelFontSource[] = {
'\x22', '\x86', '\xBB', '\x34', '\xE0', '\x13'
};
const char labelFontSource[] = OBFUSCATE_SOURCE_CHARS(6, "Gulim", 0x176F138D5DD7F365ULL);
// GLOBAL: gl_25428
thread_local EncryptedName<sizeof(labelFontSource), 0x176F138D5DD7F365ULL> labelFontName(labelFontSource);
label->SetFont(std::string(labelFontName.Text()));
@ -1104,31 +1007,19 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->lockButton->disabled = 0;
this->lockButton->Invalidate();
{
const char disabledSource[] = {
'\x77', '\x9E', '\x2F', '\x39', '\xC3', '\x11', '\x5C', '\x82', '\x71', '\xD5', '\x2F', '\x0F', '\xBE', '\x65', '\xC5', '\x2D',
'\xC3', '\x5F', '\xB0', '\xAC', '\x68', '\x80', '\xFD', '\x26', '\xC4', '\x1F', '\x8D', '\xAE', '\x73', '\xDF'
};
const char disabledSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\btn_ok_dis.bmp", 0x4F99DF03C3EF31B7ULL);
// GLOBAL: gl_25429
thread_local EncryptedName<sizeof(disabledSource), 0x4F99DF03C3EF31B7ULL> disabledName(disabledSource);
const std::string disabled(disabledName.Text());
const char pressedSource[] = {
'\x2D', '\xDA', '\xA1', '\xD9', '\x77', '\x2D', '\x94', '\xE0', '\x2B', '\x91', '\xA1', '\xEF', '\x0A', '\x59', '\x0D', '\x4F',
'\x99', '\x1B', '\x3E', '\x4C', '\xDC', '\xBC', '\x30', '\x03', '\x8F', '\x18', '\x11', '\x23'
};
const char pressedSource[] = OBFUSCATE_SOURCE_CHARS(28, "유저인터페이스\\btn_ok_a.bmp", 0x2D51E3B7236175EDULL);
// GLOBAL: gl_25430
thread_local EncryptedName<sizeof(pressedSource), 0x2D51E3B7236175EDULL> pressedName(pressedSource);
const std::string pressed(pressedName.Text());
const char hoverSource[] = {
'\xD7', '\xB4', '\xED', '\x59', '\x7D', '\x25', '\x84', '\xC2', '\xD1', '\xFF', '\xED', '\x6F', '\x00', '\x51', '\x1D', '\x6D',
'\x63', '\x75', '\x72', '\xCC', '\xD6', '\xB4', '\x23', '\x21', '\x75', '\x76', '\x5D', '\xA3'
};
const char hoverSource[] = OBFUSCATE_SOURCE_CHARS(28, "유저인터페이스\\btn_ok_b.bmp", 0x0F41EBBDA32D1B17ULL);
// GLOBAL: gl_25431
thread_local EncryptedName<sizeof(hoverSource), 0x0F41EBBDA32D1B17ULL> hoverName(hoverSource);
const std::string hover(hoverName.Text());
const char normalSource[] = {
'\x01', '\xE8', '\x05', '\xED', '\x21', '\x57', '\x10', '\x36', '\x07', '\xA3', '\x05', '\xDB', '\x5C', '\x23', '\x89', '\x99',
'\xB5', '\x29', '\x9A', '\x78', '\x8A', '\xB7', '\xB7', '\x96', '\xB1', '\x47'
};
const char normalSource[] = OBFUSCATE_SOURCE_CHARS(26, "유저인터페이스\\btn_ok.bmp", 0xFBD599E117C547C1ULL);
// GLOBAL: gl_25432
thread_local EncryptedName<sizeof(normalSource), 0xFBD599E117C547C1ULL> normalName(normalSource);
const std::string normal(normalName.Text());
@ -1143,34 +1034,19 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->tradeButton->disabled = 0;
this->tradeButton->Invalidate();
{
const char disabledSource[] = {
'\x99', '\x18', '\xC7', '\xE9', '\x05', '\xB3', '\xA6', '\x82', '\x9F', '\x53', '\xC7', '\xDF', '\x78', '\xC7', '\x3F', '\x2D',
'\x2D', '\xD9', '\x58', '\x76', '\xBD', '\x1E', '\x0B', '\x2E', '\x37', '\xD0', '\x62', '\x4C', '\xA1', '\x14', '\x10', '\x61',
'\x3B', '\xDA', '\x77', '\x13'
};
const char disabledSource[] = OBFUSCATE_SOURCE_CHARS(36, "유저인터페이스\\btn_exchange_dis.bmp", 0x4F637DC51307B759ULL);
// GLOBAL: gl_25433
thread_local EncryptedName<sizeof(disabledSource), 0x4F637DC51307B759ULL> disabledName(disabledSource);
const std::string disabled(disabledName.Text());
const char pressedSource[] = {
'\xE5', '\xDE', '\x6F', '\x31', '\xCD', '\x3D', '\xE8', '\x28', '\xE3', '\x95', '\x6F', '\x07', '\xB0', '\x49', '\x71', '\x87',
'\x51', '\x1F', '\xF0', '\xAE', '\x75', '\x90', '\x45', '\x84', '\x4B', '\x16', '\xCA', '\x94', '\x6C', '\xDD', '\x4F', '\x88',
'\x55', '\x71'
};
const char pressedSource[] = OBFUSCATE_SOURCE_CHARS(34, "유저인터페이스\\btn_exchange_a.bmp", 0xE52DF30DCBAF7125ULL);
// GLOBAL: gl_25434
thread_local EncryptedName<sizeof(pressedSource), 0xE52DF30DCBAF7125ULL> pressedName(pressedSource);
const std::string pressed(pressedName.Text());
const char hoverSource[] = {
'\x9F', '\x9A', '\x6F', '\x6F', '\x5D', '\x47', '\x36', '\x02', '\x99', '\xD1', '\x6F', '\x59', '\x20', '\x33', '\xAF', '\xAD',
'\x2B', '\x5B', '\xF0', '\xF0', '\xE5', '\xEA', '\x9B', '\xAE', '\x31', '\x52', '\xCA', '\xCA', '\xFF', '\xA7', '\x91', '\xA2',
'\x2F', '\x35'
};
const char hoverSource[] = OBFUSCATE_SOURCE_CHARS(34, "유저인터페이스\\btn_exchange_b.bmp", 0xCFF3899D95AF355FULL);
// GLOBAL: gl_25435
thread_local EncryptedName<sizeof(hoverSource), 0xCFF3899D95AF355FULL> hoverName(hoverSource);
const std::string hover(hoverName.Text());
const char normalSource[] = {
'\x37', '\x66', '\xA3', '\x93', '\xBD', '\x57', '\xB4', '\x5C', '\x31', '\x2D', '\xA3', '\xA5', '\xC0', '\x23', '\x2D', '\xF3',
'\x83', '\xA7', '\x3C', '\x0C', '\x05', '\xFA', '\x19', '\xF0', '\x99', '\xAE', '\x06', '\x47', '\x1F', '\xF4', '\x01', '\x91'
};
const char normalSource[] = OBFUSCATE_SOURCE_CHARS(32, "유저인터페이스\\btn_exchange.bmp", 0x9171997D6963C9F7ULL);
// GLOBAL: gl_25436
thread_local EncryptedName<sizeof(normalSource), 0x9171997D6963C9F7ULL> normalName(normalSource);
const std::string normal(normalName.Text());
@ -1185,31 +1061,19 @@ void CUIExchangeUI::OnCreate(int width, int height) {
this->cancelButton->disabled = 0;
this->cancelButton->Invalidate();
{
const char disabledSource[] = {
'\x0D', '\xAC', '\x0D', '\x81', '\x57', '\xF5', '\xD6', '\xFE', '\x0B', '\xE7', '\x0D', '\xB7', '\x2A', '\x81', '\x4F', '\x51',
'\xB9', '\x6D', '\x92', '\x18', '\xF6', '\x55', '\x70', '\x56', '\xA1', '\x2D', '\xAF', '\x16', '\xE7', '\x3B'
};
const char disabledSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\btn_cancel.bmp", 0x33133B977BCD03CDULL);
// GLOBAL: gl_25437
thread_local EncryptedName<sizeof(disabledSource), 0x33133B977BCD03CDULL> disabledName(disabledSource);
const std::string disabled(disabledName.Text());
const char pressedSource[] = {
'\x37', '\xBC', '\xEB', '\x55', '\x31', '\xC1', '\xD8', '\x40', '\x31', '\xF7', '\xEB', '\x63', '\x4C', '\xB5', '\x41', '\xEF',
'\x83', '\x7D', '\x74', '\xCC', '\x90', '\x61', '\x7E', '\xE8', '\x9B', '\x4C', '\x4A', '\x81', '\x93', '\x62', '\x6D', '\x8D'
};
const char pressedSource[] = OBFUSCATE_SOURCE_CHARS(32, "유저인터페이스\\btn_cancel_a.bmp", 0x8D1D0FF1AF2B13F7ULL);
// GLOBAL: gl_25438
thread_local EncryptedName<sizeof(pressedSource), 0x8D1D0FF1AF2B13F7ULL> pressedName(pressedSource);
const std::string pressed(pressedName.Text());
const char hoverSource[] = {
'\x4D', '\x14', '\x0F', '\x81', '\x51', '\x69', '\x5A', '\x7E', '\x4B', '\x5F', '\x0F', '\xB7', '\x2C', '\x1D', '\xC3', '\xD1',
'\xF9', '\xD5', '\x90', '\x18', '\xF0', '\xC9', '\xFC', '\xD6', '\xE1', '\xE4', '\xAD', '\x55', '\xF3', '\xCA', '\xEF', '\xB3'
};
const char hoverSource[] = OBFUSCATE_SOURCE_CHARS(32, "유저인터페이스\\btn_cancel_b.bmp", 0xB39FA7917BCFBB8DULL);
// GLOBAL: gl_25439
thread_local EncryptedName<sizeof(hoverSource), 0xB39FA7917BCFBB8DULL> hoverName(hoverSource);
const std::string hover(hoverName.Text());
const char normalSource[] = {
'\x6B', '\x6E', '\x8D', '\xC3', '\xA7', '\xBB', '\x0E', '\xE0', '\x6D', '\x25', '\x8D', '\xF5', '\xDA', '\xCF', '\x97', '\x4F',
'\xDF', '\xAF', '\x12', '\x5A', '\x06', '\x1B', '\xA8', '\x48', '\xC7', '\xEF', '\x2F', '\x54', '\x17', '\x75'
};
const char normalSource[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\btn_cancel.bmp", 0x2DCB7567394DC1ABULL);
// GLOBAL: gl_25440
thread_local EncryptedName<sizeof(normalSource), 0x2DCB7567394DC1ABULL> normalName(normalSource);
const std::string normal(normalName.Text());

191
Source/UI/SelectPackageItemBox/UISelectPackageItemBox.cpp
View file

@ -19,6 +19,7 @@
#include "UI/Window/UIRegisterMgr.h"
#include "Resource/MSGSTRINGID.h"
#include "Utility/Cipher/LocalEncryptedName.h"
#include "Utility/Cipher/CryptName.h"
#include "Utility/Cipher/Obfuscate.h"
#include <algorithm>
#include <cstdint>
@ -720,33 +721,19 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
this->title->Move(0, 0);
this->title->SetImages(
std::string([] {
constexpr char bytes[] = {
'\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', '\x85',
'\x98', '\xB3', '\x55', '\x6C', '\x75', '\x18', '\x3D', '\xAE', '\x9D', '\xA2', '\x5F', '\x7D', '\x39', '\x1B', '\x22', '\x81',
'\xF1'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(49, "유저인터페이스\\basic_interface\\titlebar_left.bmp", 0xF14F79170939C7F1ULL);
constexpr EncryptedSource<49> source(bytes);
thread_local EncryptedName<49, 0xF14F79170939C7F1ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\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', '\xD1',
'\xF6', '\xB1', '\x01', '\xCE', '\xB5', '\x48', '\x8F', '\xFA', '\xF2', '\xAC', '\x09', '\x85', '\xB5', '\x44', '\x8D', '\xA5'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(48, "유저인터페이스\\basic_interface\\titlebar_mid.bmp", 0xA5FD29D7AB6DC59FULL);
constexpr EncryptedSource<48> source(bytes);
thread_local EncryptedName<48, 0xA5FD29D7AB6DC59FULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\x21', '\xD4', '\x39', '\x2D', '\x15', '\xDD', '\xFC', '\x10', '\x27', '\x9F', '\x39', '\x1B', '\x68', '\xA9', '\x65', '\xBF',
'\x80', '\x08', '\x90', '\xB4', '\x8A', '\x7A', '\x57', '\xA9', '\x84', '\x09', '\x9F', '\xB6', '\xB6', '\x76', '\x65', '\xA9',
'\x88', '\x0F', '\x95', '\xB2', '\xB7', '\x72', '\x4B', '\x82', '\x93', '\x12', '\x9E', '\xBF', '\xA1', '\x3D', '\x5B', '\xB0',
'\x91', '\x7B'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(50, "유저인터페이스\\basic_interface\\titlebar_right.bmp", 0xDD3913D5D7F97BE1ULL);
constexpr EncryptedSource<50> source(bytes);
thread_local EncryptedName<50, 0xDD3913D5D7F97BE1ULL> name(source);
return name.Text();
@ -762,7 +749,7 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
titleText->SetAlign(0, 6);
titleText->SetFont(
std::string([] {
constexpr std::uint8_t bytes[] = {0xDC, 0x22, 0x6F, 0xF0, 0x0A, 0x05};
constexpr std::uint8_t bytes[] = OBFUSCATE_SOURCE_BYTES(6, "Gulim", 0x050505679903579BULL);
constexpr EncryptedSource<6> source(bytes);
thread_local EncryptedName<6, 0x050505679903579BULL> name(source);
return name.Text();
@ -784,41 +771,25 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
systemButton->Invalidate();
systemButton->SetImages(
std::string([] {
constexpr char bytes[] = {
'\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', '\x55', '\xDA', '\xCC', '\x8A', '\xDC', '\xD2', '\xDB', '\x8B', '\x19', '\xD9', '\xD2', '\x9F', '\x83'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(48, "유저인터페이스\\basic_interface\\sys_base_off.bmp", 0x83EFBFBB37EDBDBDULL);
constexpr EncryptedSource<48> source(bytes);
thread_local EncryptedName<48, 0x83EFBFBB37EDBDBDULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\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', '\x5B', '\x50', '\x38', '\x4E', '\xE0', '\xC8', '\x9B', '\x51', '\x5B', '\x5C', '\x3B', '\x2B'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(47, "유저인터페이스\\basic_interface\\sys_base_on.bmp", 0xBF2B4B31397FF5A7ULL);
constexpr EncryptedSource<47> source(bytes);
thread_local EncryptedName<47, 0xBF2B4B31397FF5A7ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\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', '\x50',
'\xB0', '\x86', '\x00', '\xE9', '\xEE', '\xA6', '\xDE', '\x7C', '\xA6', '\x9B', '\x71', '\xE9', '\xE2', '\xA5', '\xBB'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(47, "유저인터페이스\\basic_interface\\sys_base_on.bmp", 0x23BBD58F8B5FF5C9ULL);
constexpr EncryptedSource<47> source(bytes);
thread_local EncryptedName<47, 0x23BBD58F8B5FF5C9ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\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', '\xB6',
'\x14', '\xC8', '\xCA', '\x4F', '\xF2', '\x88', '\x72', '\x9A', '\x02', '\xDD', '\xF3', '\x03', '\xF1', '\x96', '\x67', '\xC5'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(48, "유저인터페이스\\basic_interface\\sys_base_off.bmp", 0xC517FB932D95BB6DULL);
constexpr EncryptedSource<48> source(bytes);
thread_local EncryptedName<48, 0xC517FB932D95BB6DULL> name(source);
return name.Text();
@ -834,43 +805,25 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
closeButton->Invalidate();
closeButton->SetImages(
std::string([] {
constexpr char bytes[] = {
'\x65', '\x32', '\xAD', '\x03', '\xA3', '\xE9', '\xB2', '\xCE', '\x63', '\x79', '\xAD', '\x35', '\xDE', '\x9D', '\x2B', '\x61',
'\xC4', '\xEE', '\x04', '\x9A', '\x3C', '\x4E', '\x19', '\x77', '\xC0', '\xEF', '\x0B', '\x98', '\x00', '\x42', '\x2B', '\x70',
'\xDC', '\xEE', '\x32', '\x9A', '\x0F', '\x48', '\x04', '\x66', '\xFA', '\xF2', '\x0B', '\x9F', '\x4D', '\x45', '\x1A', '\x73',
'\xA5'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(49, "유저인터페이스\\basic_interface\\sys_close_off.bmp", 0x03772763F96D9DA5ULL);
constexpr EncryptedSource<49> source(bytes);
thread_local EncryptedName<49, 0x03772763F96D9DA5ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\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', '\x78',
'\xFE', '\x60', '\x34', '\x1C', '\x55', '\x66', '\x02', '\x6E', '\xD8', '\x7C', '\x05', '\x51', '\x5B', '\x64', '\x01', '\x0B'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(48, "유저인터페이스\\basic_interface\\sys_close_on.bmp", 0x0B7109397F6B1387ULL);
constexpr EncryptedSource<48> source(bytes);
thread_local EncryptedName<48, 0x0B7109397F6B1387ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\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', '\xC6', '\xCD', '\x50', '\x90', '\x76', '\x38', '\xC4', '\xFF', '\x8B', '\xC3', '\x52', '\x93', '\x13'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(48, "유저인터페이스\\basic_interface\\sys_close_on.bmp", 0x13E33FA1A591AB67ULL);
constexpr EncryptedSource<48> source(bytes);
thread_local EncryptedName<48, 0x13E33FA1A591AB67ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\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', '\x5A', '\xD3', '\x8A', '\xDA', '\x72', '\x68', '\x28', '\xCB', '\x5F', '\x91', '\x87', '\xC4', '\x67',
'\x37'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(49, "유저인터페이스\\basic_interface\\sys_close_off.bmp", 0x17A9E5BF39AD4737ULL);
constexpr EncryptedSource<49> source(bytes);
thread_local EncryptedName<49, 0x17A9E5BF39AD4737ULL> name(source);
return name.Text();
@ -887,41 +840,25 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
this->tabList->SetBinder([this](SelectPackageItemBox::CUITabInfo* tab, const SelectPackageItemBox::CTabInfoData& data) { this->BindTab(tab, data); });
this->tabList->SetImages(
std::string([] {
constexpr char bytes[] = {
'\x83', '\x86', '\x93', '\xDD', '\x15', '\x71', '\x8C', '\x54', '\x85', '\xCD', '\x93', '\xEB', '\x68', '\x05', '\x15', '\xEA',
'\x26', '\x45', '\x36', '\x44', '\xA1', '\xCF', '\x28', '\xFA', '\x28', '\x48', '\x34', '\x42', '\x89', '\xDD', '\x3D', '\xF7',
'\x1C', '\x5A', '\x36', '\x53', '\x8A', '\xD3', '\x20', '\xEA', '\x37', '\x07', '\x31', '\x4A', '\xA5', '\xBF'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(46, "유저인터페이스\\selectpackage\\btn_set_list.bmp", 0x9949BFD527532943ULL);
constexpr EncryptedSource<46> source(bytes);
thread_local EncryptedName<46, 0x9949BFD527532943ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\xAF', '\xD2', '\x3B', '\xD9', '\xB1', '\xC9', '\x4A', '\x00', '\xA9', '\x99', '\x3B', '\xEF', '\xCC', '\xBD', '\xD3', '\xBE',
'\x0A', '\x11', '\x9E', '\x40', '\x05', '\x77', '\xEE', '\xAE', '\x04', '\x1C', '\x9C', '\x46', '\x2D', '\x65', '\xFB', '\xA3',
'\x30', '\x0E', '\x9E', '\x57', '\x2E', '\x77', '\xFD', '\xA8', '\x1C', '\x0E', '\xD5', '\x41', '\x1C', '\x77', '\x8F'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(47, "유저인터페이스\\selectpackage\\btn_set_press.bmp", 0xCD8F077123FB7D6FULL);
constexpr EncryptedSource<47> source(bytes);
thread_local EncryptedName<47, 0xCD8F077123FB7D6FULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\xA9', '\xB0', '\xB7', '\xAF', '\x5D', '\x5B', '\xBE', '\xAE', '\xAF', '\xFB', '\xB7', '\x99', '\x20', '\x2F', '\x27', '\x10',
'\x0C', '\x73', '\x12', '\x36', '\xE9', '\xE5', '\x1A', '\x00', '\x02', '\x7E', '\x10', '\x30', '\xC1', '\xF7', '\x0F', '\x0D',
'\x36', '\x6C', '\x12', '\x21', '\xC2', '\xF9', '\x12', '\x10', '\x1D', '\x31', '\x15', '\x38', '\xED', '\x95'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(46, "유저인터페이스\\selectpackage\\btn_set_list.bmp", 0x637B959D55771F69ULL);
constexpr EncryptedSource<46> source(bytes);
thread_local EncryptedName<46, 0x637B959D55771F69ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\x91', '\x24', '\x0D', '\xFB', '\x7B', '\xF3', '\x84', '\x1C', '\x97', '\x6F', '\x0D', '\xCD', '\x06', '\x87', '\x1D', '\xA2',
'\x34', '\xE7', '\xA8', '\x62', '\xCF', '\x4D', '\x20', '\xB2', '\x3A', '\xEA', '\xAA', '\x64', '\xE7', '\x5F', '\x35', '\xBF',
'\x0E', '\xF8', '\xA8', '\x75', '\xE4', '\x51', '\x28', '\xA2', '\x25', '\xA5', '\xAF', '\x6C', '\xCB', '\x3D'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(46, "유저인터페이스\\selectpackage\\btn_set_list.bmp", 0xD1413DBB01CD8B51ULL);
constexpr EncryptedSource<46> source(bytes);
thread_local EncryptedName<46, 0xD1413DBB01CD8B51ULL> name(source);
return name.Text();
@ -934,19 +871,13 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
this->tabList->scrollBar->step = 34;
this->tabList->SetScrollBarButtonImages(
std::string([] {
constexpr char bytes[] = {
'\x79', '\xAA', '\xB7', '\xB5', '\xCB', '\xD3', '\x4A', '\xB8', '\x7F', '\xE1', '\xB7', '\x83', '\xB6', '\xA7', '\xD3', '\x06',
'\xDA', '\x77', '\x18', '\x23', '\x67', '\x2D', '\xFA', '\x05', '\x97', '\x67', '\x1A', '\x3F', '\x0B'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(29, "유저인터페이스\\scroll0up.bmp", 0x758F1D0B4F7705B9ULL);
constexpr EncryptedSource<29> source(bytes);
thread_local EncryptedName<29, 0x758F1D0B4F7705B9ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\xA5', '\xB6', '\x85', '\xF3', '\xED', '\xED', '\xDE', '\x44', '\xA3', '\xFD', '\x85', '\xC5', '\x90', '\x99', '\x47', '\xFA',
'\x06', '\x6B', '\x2A', '\x65', '\x41', '\x13', '\x7F', '\xE6', '\x12', '\x77', '\x6B', '\x6B', '\x40', '\x53', '\x1B'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(31, "유저인터페이스\\scroll0down.bmp", 0x891B232D09451965ULL);
constexpr EncryptedSource<31> source(bytes);
thread_local EncryptedName<31, 0x891B232D09451965ULL> name(source);
return name.Text();
@ -954,10 +885,7 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
);
this->tabList->SetScrollBarBackground(
std::string([] {
constexpr char bytes[] = {
'\x55', '\x20', '\x21', '\xF7', '\x9D', '\xC7', '\xA4', '\x3C', '\x53', '\x6B', '\x21', '\xC1', '\xE0', '\xB3', '\x3D', '\x82',
'\xF6', '\xFD', '\x8E', '\x61', '\x31', '\x39', '\x0C', '\x98', '\xF1', '\xA1', '\x83', '\x60', '\x2D', '\x09'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\scroll0mid.bmp", 0xF161095D0DE18F95ULL);
constexpr EncryptedSource<30> source(bytes);
thread_local EncryptedName<30, 0xF161095D0DE18F95ULL> name(source);
return name.Text();
@ -965,31 +893,19 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
);
this->tabList->SetScrollBarThumbImages(
std::string([] {
constexpr char bytes[] = {
'\x2F', '\xDE', '\x1F', '\xE9', '\xAD', '\x81', '\x02', '\x20', '\x29', '\x95', '\x1F', '\xDF', '\xD0', '\xF5', '\x9B', '\x9E',
'\x8C', '\x03', '\xB0', '\x7F', '\x01', '\x7F', '\xA5', '\x8C', '\x9D', '\x2E', '\xAA', '\x63', '\x43', '\x2D', '\xAA', '\x9D',
'\xEF'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(33, "유저인터페이스\\scroll0bar_up.bmp", 0xEDC74F6D13DF71EFULL);
constexpr EncryptedSource<33> source(bytes);
thread_local EncryptedName<33, 0xEDC74F6D13DF71EFULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\x4F', '\x12', '\x2F', '\x7D', '\xBD', '\x0B', '\x68', '\xB8', '\x49', '\x59', '\x2F', '\x4B', '\xC0', '\x7F', '\xF1', '\x06',
'\xEC', '\xCF', '\x80', '\xEB', '\x11', '\xF5', '\xCF', '\x14', '\xFD', '\xE2', '\x82', '\xEE', '\x19', '\xEB', '\xCF', '\x18',
'\xFF', '\xBD'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(34, "유저인터페이스\\scroll0bar_mid.bmp", 0x75ADC57D87EFBD8FULL);
constexpr EncryptedSource<34> source(bytes);
thread_local EncryptedName<34, 0x75ADC57D87EFBD8FULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\x19', '\x56', '\x21', '\x19', '\xAD', '\xDB', '\x68', '\xE6', '\x1F', '\x1D', '\x21', '\x2F', '\xD0', '\xAF', '\xF1', '\x58',
'\xBA', '\x8B', '\x8E', '\x8F', '\x01', '\x25', '\xCF', '\x4A', '\xAB', '\xA6', '\x85', '\x8C', '\x1A', '\x7B', '\x83', '\x49',
'\xB4', '\x89', '\xE1'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(35, "유저인터페이스\\scroll0bar_down.bmp", 0x2BAD156DE3E1F9D9ULL);
constexpr EncryptedSource<35> source(bytes);
thread_local EncryptedName<35, 0x2BAD156DE3E1F9D9ULL> name(source);
return name.Text();
@ -1007,41 +923,25 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
this->itemList->SetBinder([this](SelectPackageItemBox::CUIItemInfo* item, const ITEM_INFO& data) { this->BindItem(item, data); });
this->itemList->SetImages(
std::string([] {
constexpr char bytes[] = {
'\x11', '\xF4', '\x57', '\x1F', '\xF9', '\x49', '\x2E', '\xE2', '\x17', '\xBF', '\x57', '\x29', '\x84', '\x3D', '\xB7', '\x5C',
'\xB4', '\x37', '\xF2', '\x86', '\x4D', '\xF7', '\x8A', '\x4C', '\xBA', '\x3A', '\xF0', '\x80', '\x65', '\xEE', '\x9F', '\x4A',
'\xBC', '\x04', '\xFB', '\x8C', '\x4A', '\xF3', '\xC5', '\x4D', '\xBC', '\x2B', '\x97'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(43, "유저인터페이스\\selectpackage\\item_list.bmp", 0x2FEB8739E5975BD1ULL);
constexpr EncryptedSource<43> source(bytes);
thread_local EncryptedName<43, 0x2FEB8739E5975BD1ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\x0D', '\xAC', '\x0D', '\x81', '\x57', '\xF5', '\xD6', '\xFE', '\x0B', '\xE7', '\x0D', '\xB7', '\x2A', '\x81', '\x4F', '\x40',
'\xA8', '\x6F', '\xA8', '\x18', '\xE3', '\x4B', '\x72', '\x50', '\xA6', '\x62', '\xAA', '\x1E', '\xCB', '\x52', '\x67', '\x56',
'\xA0', '\x5C', '\xA1', '\x12', '\xE4', '\x4F', '\x3D', '\x51', '\xA0', '\x73', '\xCD'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(43, "유저인터페이스\\selectpackage\\item_list.bmp", 0x33133B977BCD03CDULL);
constexpr EncryptedSource<43> source(bytes);
thread_local EncryptedName<43, 0x33133B977BCD03CDULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\xEF', '\x78', '\x85', '\xDF', '\xF9', '\x65', '\xE8', '\x6C', '\xE9', '\x33', '\x85', '\xE9', '\x84', '\x11', '\x71', '\xD2',
'\x4A', '\xBB', '\x20', '\x46', '\x4D', '\xDB', '\x4C', '\xC2', '\x44', '\xB6', '\x22', '\x40', '\x65', '\xC2', '\x59', '\xC4',
'\x42', '\x88', '\x29', '\x4C', '\x4A', '\xDF', '\x03', '\xC3', '\x42', '\xA7', '\x45'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(43, "유저인터페이스\\selectpackage\\item_list.bmp", 0xA12DAB392545D72FULL);
constexpr EncryptedSource<43> source(bytes);
thread_local EncryptedName<43, 0xA12DAB392545D72FULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\xB5', '\x94', '\xC3', '\xD5', '\xD3', '\x0F', '\x64', '\xA6', '\xB3', '\xDF', '\xC3', '\xE3', '\xAE', '\x7B', '\xFD', '\x18',
'\x10', '\x57', '\x66', '\x4C', '\x67', '\xB1', '\xC0', '\x08', '\x1E', '\x5A', '\x64', '\x4A', '\x4F', '\xA8', '\xD5', '\x0E',
'\x18', '\x64', '\x6F', '\x46', '\x60', '\xB5', '\x8F', '\x09', '\x18', '\x4B', '\x03'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(43, "유저인터페이스\\selectpackage\\item_list.bmp", 0x6BA1C1132F033B75ULL);
constexpr EncryptedSource<43> source(bytes);
thread_local EncryptedName<43, 0x6BA1C1132F033B75ULL> name(source);
return name.Text();
@ -1054,19 +954,13 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
this->itemList->scrollBar->step = 34;
this->itemList->SetScrollBarButtonImages(
std::string([] {
constexpr char bytes[] = {
'\x05', '\x82', '\xEB', '\xC5', '\x49', '\xD3', '\xA8', '\x22', '\x03', '\xC9', '\xEB', '\xF3', '\x34', '\xA7', '\x31', '\x9C',
'\xA6', '\x5F', '\x44', '\x53', '\xE5', '\x2D', '\x18', '\x9F', '\xEB', '\x4F', '\x46', '\x4F', '\x89'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(29, "유저인터페이스\\scroll0up.bmp", 0xEF6D1D893F2B2DC5ULL);
constexpr EncryptedSource<29> source(bytes);
thread_local EncryptedName<29, 0xEF6D1D893F2B2DC5ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\xDD', '\x68', '\x8B', '\x4F', '\x1D', '\xB9', '\x8C', '\xEE', '\xDB', '\x23', '\x8B', '\x79', '\x60', '\xCD', '\x15', '\x50',
'\x7E', '\xB5', '\x24', '\xD9', '\xB1', '\x47', '\x2D', '\x4C', '\x6A', '\xA9', '\x65', '\xD7', '\xB0', '\x07', '\x49'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(31, "유저인터페이스\\scroll0down.bmp", 0x234977DDB54BC71DULL);
constexpr EncryptedSource<31> source(bytes);
thread_local EncryptedName<31, 0x234977DDB54BC71DULL> name(source);
return name.Text();
@ -1074,10 +968,7 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
);
this->itemList->SetScrollBarBackground(
std::string([] {
constexpr char bytes[] = {
'\xB7', '\x38', '\x47', '\xE7', '\xE3', '\x9D', '\x24', '\xA2', '\xB1', '\x73', '\x47', '\xD1', '\x9E', '\xE9', '\xBD', '\x1C',
'\x14', '\xE5', '\xE8', '\x71', '\x4F', '\x63', '\x8C', '\x06', '\x13', '\xB9', '\xE5', '\x70', '\x53', '\x53'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(30, "유저인터페이스\\scroll0mid.bmp", 0x6FE153231D879777ULL);
constexpr EncryptedSource<30> source(bytes);
thread_local EncryptedName<30, 0x6FE153231D879777ULL> name(source);
return name.Text();
@ -1085,31 +976,19 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
);
this->itemList->SetScrollBarThumbImages(
std::string([] {
constexpr char bytes[] = {
'\x9B', '\xFC', '\x9F', '\x27', '\x47', '\x51', '\x66', '\xF4', '\x9D', '\xB7', '\x9F', '\x11', '\x3A', '\x25', '\xFF', '\x4A',
'\x38', '\x21', '\x30', '\xB1', '\xEB', '\xAF', '\xC1', '\x58', '\x29', '\x0C', '\x2A', '\xAD', '\xA9', '\xFD', '\xCE', '\x49',
'\x5B'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(33, "유저인터페이스\\scroll0bar_up.bmp", 0x39A39F87DD5F535BULL);
constexpr EncryptedSource<33> source(bytes);
thread_local EncryptedName<33, 0x39A39F87DD5F535BULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\x37', '\x66', '\xA3', '\x93', '\xBD', '\x57', '\xB4', '\x5C', '\x31', '\x2D', '\xA3', '\xA5', '\xC0', '\x23', '\x2D', '\xE2',
'\x94', '\xBB', '\x0C', '\x05', '\x11', '\xA9', '\x13', '\xF0', '\x85', '\x96', '\x0E', '\x00', '\x19', '\xB7', '\x13', '\xFC',
'\x87', '\xC9'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(34, "유저인터페이스\\scroll0bar_mid.bmp", 0x9171997D6963C9F7ULL);
constexpr EncryptedSource<34> source(bytes);
thread_local EncryptedName<34, 0x9171997D6963C9F7ULL> name(source);
return name.Text();
}()),
std::string([] {
constexpr char bytes[] = {
'\x77', '\x9E', '\x2F', '\x39', '\xC3', '\x11', '\x5C', '\x82', '\x71', '\xD5', '\x2F', '\x0F', '\xBE', '\x65', '\xC5', '\x3C',
'\xD4', '\x43', '\x80', '\xAF', '\x6F', '\xEF', '\xFB', '\x2E', '\xC5', '\x6E', '\x8B', '\xAC', '\x74', '\xB1', '\xB7', '\x2D',
'\xDA', '\x41', '\xEF'
};
constexpr char bytes[] = OBFUSCATE_SOURCE_CHARS(35, "유저인터페이스\\scroll0bar_down.bmp", 0x4F99DF03C3EF31B7ULL);
constexpr EncryptedSource<35> source(bytes);
thread_local EncryptedName<35, 0x4F99DF03C3EF31B7ULL> name(source);
return name.Text();
@ -1126,7 +1005,7 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
this->okButton->Invalidate();
this->okButton->SetText(
std::string([] {
constexpr std::uint8_t bytes[] = {0xED, 0xDF, 0x6F, 0x05, 0x0D};
constexpr std::uint8_t bytes[] = OBFUSCATE_SOURCE_BYTES(5, "확인", 0xE52DF30DCBAF7125ULL);
constexpr EncryptedSource<5> source(bytes);
thread_local EncryptedName<5, 0xE52DF30DCBAF7125ULL> name(source);
return name.Text();
@ -1143,7 +1022,7 @@ void CUISelectPackageItemBox::OnCreate(int width, int height) {
this->cancelButton->Invalidate();
this->cancelButton->SetText(
std::string([] {
constexpr std::uint8_t bytes[] = {0xEB, 0xE8, 0x1E, 0x77, 0x9D};
constexpr std::uint8_t bytes[] = OBFUSCATE_SOURCE_BYTES(5, "닫기", 0xCFF3899D95AF355FULL);
constexpr EncryptedSource<5> source(bytes);
thread_local EncryptedName<5, 0xCFF3899D95AF355FULL> name(source);
return name.Text();