diff --git a/Source/Client/Mode/GameModeMiniMap.cpp b/Source/Client/Mode/GameModeMiniMap.cpp index d2f272719..3a0f2b64e 100644 --- a/Source/Client/Mode/GameModeMiniMap.cpp +++ b/Source/Client/Mode/GameModeMiniMap.cpp @@ -37,7 +37,8 @@ namespace { // INLINED __forceinline const char* TimeFontActionName() { - const char source[] = {'\xB1', '\x4F', '\xAD', '\xDA', '\xD7', '\xA1', '\x01', '\x29', '\x18', '\xEE', '\x0E', '\x4D', '\x7E', '\x61', '\x29', '\x53', '\x10', '\xE0', '\x1F', '\x0B'}; + constexpr auto sourceText = CRYPT_NAME("이팩트\\TimeFont.act", 0x7D5D0F110B6B8371ULL); + const auto& source = sourceText.data; // GLOBAL: gl_25508 thread_local EncryptedName name(source); return name.Text(); diff --git a/Source/Client/Mode/GameModePackets.cpp b/Source/Client/Mode/GameModePackets.cpp index 83dd187fc..cc69e48b6 100644 --- a/Source/Client/Mode/GameModePackets.cpp +++ b/Source/Client/Mode/GameModePackets.cpp @@ -147,6 +147,7 @@ #include "Contents/Actors/GroundScope.h" #include "Contents/Ground/TerrainHeight.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include // OFFSET: 0x00D7AF70 @@ -15636,7 +15637,8 @@ void CGameMode::ReceiveRefineStatusGraded(const char* playerName, int itemId, un item.identified = 1; int job = 0; - const std::uint8_t signatureSource[] = {0x1B, 0x2D, 0xBB, 0xD1}; + constexpr std::array signatureSourceArray = CRYPT_NAME("d>d", 0xED796785D1DF137FULL); + const std::uint8_t (&signatureSource)[4] = signatureSourceArray._Elems; thread_local EncryptedName signature(signatureSource); const char* signatureText = signature.Text(); const std::uint8_t functionSource[] = {0xB6, 0xA2, 0x4D, 0x4C, 0x66, 0x0C, 0x26, 0x81, 0xBB, 0xA8, 0x5B, 0x09}; diff --git a/Source/Client/Mode/LoginMode.cpp b/Source/Client/Mode/LoginMode.cpp index 7bbeae5a8..19df0f84e 100644 --- a/Source/Client/Mode/LoginMode.cpp +++ b/Source/Client/Mode/LoginMode.cpp @@ -2548,8 +2548,7 @@ void CLoginMode::PollNetworkStatus() { } break; case ID_SC_ACK_ENCRYPTION: { - const std::array source = {0x17, 0x62, 0xEB, 0xFF, 0x1C, 0x00, 0xFE, 0xD4, 0x2D, 0x2D, 0x8E, 0xC1, 0x1E, 0x11, 0xEC, 0xC1, - 0x2D, 0x64, 0xA4, 0xC1, 0x5D, 0x42, 0xB4, 0x90, 0x59}; + constexpr std::array source = CRYPT_NAME("No Packet Encryption !!!", 0xB195637DAFCB0D59ULL); thread_local EncryptedName text(source); ShowErrorDialog(GetRenderSystemHolder()->system, text.Text(), 0); break; @@ -3190,7 +3189,7 @@ int CLoginMode::SendMsg(int event, int argument1, int argument2, int argument3, if (argument1 == 1) { g_tipOfTheDayEnglish = true; g_serverLanguage->alternateLanguage = static_cast(argument1); - const std::array prefixSource = {0xBC, 0x94, 0x3A, 0xD7, 0x8F}; + constexpr std::array prefixSource = CRYPT_NAME("uae\\", 0x23BBD58F8B5FF5C9ULL); thread_local EncryptedName prefix(prefixSource); g_serverLanguage->SetServicePrefix(prefix.Text()); const std::array suffixSource = {0xF2, 0x72, 0x0E, 0x23, 0x39}; diff --git a/Source/Client/Mode/LoginModeNotices.cpp b/Source/Client/Mode/LoginModeNotices.cpp index 5b1b10b5b..09060fd76 100644 --- a/Source/Client/Mode/LoginModeNotices.cpp +++ b/Source/Client/Mode/LoginModeNotices.cpp @@ -49,7 +49,8 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) { if (remainingTime == 0xFFFFFFFE && packet->remainingFreeTime == 0xFFFFFFFE) { const char* message = LookupMessage(MSI_BILLING_FREE_USER); const char* format = [] { - const std::uint8_t source[] = {0x34, 0x90, 0x59, 0x99}; + constexpr std::array sourceArray = CRYPT_NAME("%s\x0A", 0x4B755DB19953E311ULL); + const std::uint8_t (&source)[4] = sourceArray._Elems; // GLOBAL: gl_25061 thread_local EncryptedName name(source); return name.Text(); @@ -58,7 +59,8 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) { } else if (remainingTime == 0xFFFFFFFD && packet->remainingFreeTime == 0xFFFFFFFD) { const char* message = LookupMessage(MSI_BILLING_PCB); const char* format = [] { - const std::uint8_t source[] = {0x7E, 0xC4, 0x6B, 0x59}; + constexpr std::array sourceArray = CRYPT_NAME("%s\x0A", 0xF715514F5961B75BULL); + const std::uint8_t (&source)[4] = sourceArray._Elems; // GLOBAL: gl_25062 thread_local EncryptedName name(source); return name.Text(); @@ -67,7 +69,8 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) { } else if (remainingTime == 0xFFFFFFFF && packet->remainingFreeTime == 0xFFFFFFFF) { const char* message = LookupMessage(MSI_BILLING_INTERNET_CAFE); const char* format = [] { - const std::uint8_t source[] = {0xBC, 0x4A, 0xF7, 0x31}; + constexpr std::array sourceArray = CRYPT_NAME("%s\x0A", 0x4191BB5531FD3999ULL); + const std::uint8_t (&source)[4] = sourceArray._Elems; // GLOBAL: gl_25063 thread_local EncryptedName name(source); return name.Text(); @@ -81,7 +84,8 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) { } else { const char* message = LookupMessage(MSI_BILLING_100); const char* format = [] { - const std::uint8_t source[] = {0xF6, 0x4A, 0x65, 0x11}; + constexpr std::array sourceArray = CRYPT_NAME("%s\x0A", 0xB19D1FA9116F39D3ULL); + const std::uint8_t (&source)[4] = sourceArray._Elems; // GLOBAL: gl_25064 thread_local EncryptedName name(source); return name.Text(); @@ -95,7 +99,8 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) { if (packet->remainingFreeTime > 0) { const char* message = LookupMessage(MSI_BILLING_800); const char* format = [] { - const std::uint8_t source[] = {0x8A, 0x7A, 0x03, 0xE7}; + constexpr std::array sourceArray = CRYPT_NAME("%s\x0A", 0x9569C9C7E70909AFULL); + const std::uint8_t (&source)[4] = sourceArray._Elems; // GLOBAL: gl_25065 thread_local EncryptedName name(source); return name.Text(); @@ -106,7 +111,8 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) { sprintf(text + strlen(text), hourFormat, freeTime / 60, freeTime % 60); } else { const char* format = [] { - const std::uint8_t source[] = {0x67, 0xBF}; + constexpr std::array sourceArray = CRYPT_NAME("\x0A", 0xD7A749EB27D5BF6DULL); + const std::uint8_t (&source)[2] = sourceArray._Elems; // GLOBAL: gl_25066 thread_local EncryptedName name(source); return name.Text(); diff --git a/Source/Client/Session/Session.cpp b/Source/Client/Session/Session.cpp index bdcbebe7e..6e8e547b4 100644 --- a/Source/Client/Session/Session.cpp +++ b/Source/Client/Session/Session.cpp @@ -2900,7 +2900,7 @@ void CSession::LoadExternalSettings() { *reinterpret_cast(&this->jobLevelLimits[0x1C]) == -1 || *reinterpret_cast(&this->jobLevelLimits[0x20]) == -1 || *reinterpret_cast(&this->jobLevelLimits[0x24]) == -1) { - const std::array source = {'\x1E', '\x9B', '\xE7', '\x02', '\xF7', '\x9D', '\x18', '\x1D', '\x2F', '\x8C', '\xE7', '\x03', '\xD6', '\xD8', '\x29', '\x11', '\x32', '\x87', '\xF2', '\x1E', '\xA5', '\xEB', '\x3C', '\x09', '\x2E', '\x8C', '\x95'}; + constexpr std::array source = CRYPT_NAME("Error ExternSettings Value", 0x655DBD856D95E95BULL); thread_local EncryptedName name(source); ShowErrorDialog(name.Text(), 0); } diff --git a/Source/Client/Stove/StoveMgr.cpp b/Source/Client/Stove/StoveMgr.cpp index 815a10352..88ec8c3d1 100644 --- a/Source/Client/Stove/StoveMgr.cpp +++ b/Source/Client/Stove/StoveMgr.cpp @@ -363,7 +363,7 @@ void CategoryProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackR } else { const char captionSource[] = {'\xAF', '\x27', '\xF2', '\x7A', '\x3A', '\x43', '\x2F'}; const char* caption = DecryptName<0xC52FB5FBB94FF917ULL>(captionSource); - const std::array messageSource = {'\x06', '\x89', '\x74', '\x9C', '\x4C', '\x5C', '\xF4', '\xE1', '\x93', '\xD9', '\x09', '\x93', '\x43', '\xBB', '\xF1', '\xBC', '\x76', '\xB0', '\x73', '\xBE', '\x41', '\x35', '\xF5', '\xC3', '\x07', '\xA8', '\x77', '\x8A', '\xD9', '\xB3', '\x10', '\x64', '\x9A', '\x67'}; + constexpr std::array messageSource = CRYPT_NAME("등록되지 않은 카테고리입니다 (%s)", 0x17359BF953C367B3ULL); const char* message = DecryptName<0x17359BF953C367B3ULL>(messageSource); MessageBoxA(hWnd, FormatOwnedString(message, categoryId.c_str()).c_str(), caption, MB_OK); continue; @@ -388,9 +388,10 @@ void CategoryProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackR } else if (std::strcmp(categoryId.c_str(), "14A6891F90E24D7") == 0) { list = 8; } else { - const char captionSource[] = {'\x79', '\x11', '\x6E', '\xF0', '\x56', '\xEB', '\xFD'}; + constexpr auto captionSourceText = CRYPT_NAME("메시지", 0x69FD1D9733D3CFC1ULL); + const auto& captionSource = captionSourceText.data; const char* caption = DecryptName<0x69FD1D9733D3CFC1ULL>(captionSource); - const std::array messageSource = {'\x70', '\x23', '\x30', '\x3A', '\x14', '\x64', '\x26', '\x65', '\xE5', '\x73', '\x4D', '\x35', '\x1B', '\x83', '\x23', '\x38', '\x00', '\x1A', '\x37', '\x18', '\x19', '\x0D', '\x27', '\x47', '\x71', '\x02', '\x33', '\x2C', '\x81', '\x8B', '\xC2', '\xE0', '\xEC', '\xCD'}; + constexpr std::array messageSource = CRYPT_NAME("등록되지 않은 카테고리입니다 (%s)", 0x93E7A3A1F587CDC5ULL); const char* message = DecryptName<0x93E7A3A1F587CDC5ULL>(messageSource); MessageBoxA(hWnd, FormatOwnedString(message, categoryId.c_str()).c_str(), caption, MB_OK); continue; @@ -432,7 +433,7 @@ void CategoryProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackR } else { const char captionSource[] = {'\x89', '\x87', '\x96', '\xC2', '\xA0', '\x3B', '\x65'}; const char* caption = DecryptName<0x8B65CD61012B5931ULL>(captionSource); - const std::array messageSource = {'\x07', '\x28', '\x5B', '\xEB', '\xAF', '\xDC', '\x45', '\x4C', '\x18', '\x76', '\x18', '\x1D', '\xD8', '\xB2', '\xDA', '\x41', '\x7A', '\x0D', '\x51', '\xF2', '\xAB', '\xA4', '\x4B', '\xD5', '\x94', '\x99', '\xAA', '\x6B', '\x5A', '\x5D', '\xD5', '\x18', '\x77', '\x79', '\x59', '\x83', '\xDA', '\xB0', '\xD2', '\x3B', '\xE7', '\x74', '\x4B', '\xFD', '\xD8', '\x5D', '\xDC', '\x2C', '\x71', '\x35', '\x51', '\xF2', '\xAB', '\xA4', '\x4B', '\xF5'}; + constexpr std::array messageSource = CRYPT_NAME("장애가 발생 하였습니다. STOVE 고객센터로 문의 바랍니다.", 0xF5657D1F3DE5CDC7ULL); const char* message = DecryptName<0xF5657D1F3DE5CDC7ULL>(messageSource); MessageBoxA(hWnd, FormatOwnedString(message).c_str(), caption, MB_OK); } diff --git a/Source/Contents/Actors/RenderObject.cpp b/Source/Contents/Actors/RenderObject.cpp index a4c8724eb..4ad102c9f 100644 --- a/Source/Contents/Actors/RenderObject.cpp +++ b/Source/Contents/Actors/RenderObject.cpp @@ -73,6 +73,7 @@ #include #include "Contents/Guild/GuildInfo.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" using InstantValueTree = std::_Tree, std::allocator>, false>>; @@ -2998,7 +2999,8 @@ static std::string ShapeShiftName(int form, int job) { switch (job) { case JT_KARNOS: case JT_KARNOS_B: { - const std::uint8_t source[] = {0xC8, 0x80, 0x3F, 0xEE, 0x80, 0x66, 0xB1, 0xE3, 0xAD, 0xC5}; + constexpr std::array sourceArray = CRYPT_NAME("WEREWOLF2", 0xA5FD29D7AB6DC59FULL); + const std::uint8_t (&source)[10] = sourceArray._Elems; thread_local EncryptedName name(source); return name.Text(); } diff --git a/Source/Contents/Configuration/ServiceConfiguration.cpp b/Source/Contents/Configuration/ServiceConfiguration.cpp index 7b3b5c1a9..e6ad98436 100644 --- a/Source/Contents/Configuration/ServiceConfiguration.cpp +++ b/Source/Contents/Configuration/ServiceConfiguration.cpp @@ -186,8 +186,8 @@ void InitializeServiceStrings() { case 20: break; default: { - const char source[] = {'\x5C', '\xC7', '\x2C', '\x31', '\xB6', '\x2A', '\x1B', '\xF3', '\x5A', '\xCC', '\x35', '\x29', - '\xB0', '\x3E', '\x10', '\x87', '\x70', '\xD9', '\x22', '\x7F', '\xF8', '\x7C', '\x54', '\xD3'}; + constexpr auto sourceText = CRYPT_NAME("Unknown ServiceType !!!", 0xD3755DD95F47A909ULL); + const auto& source = sourceText.data; ShowErrorDialog(DecryptString<0xD3755DD95F47A909ULL>(source), 0); break; } @@ -208,31 +208,33 @@ void InitializeServiceStrings() { GetLocalTime(&time); { - const std::uint8_t source[] = {0x63, 0x0B, 0xC5, 0x25, 0x3A, 0x20, 0xE4, 0x69, 0x2E, 0x40, 0xB7, 0x3D, 0x2B, 0x37, 0x81}; + constexpr std::array sourceArray = CRYPT_NAME("..\\licence.txt", 0x078143534999254DULL); + const std::uint8_t (&source)[15] = sourceArray._Elems; g_licenceFileName = DecryptText<0x078143534999254DULL>(source); } g_startupSecondPhase = static_cast(time.wSecond) & 3; { - const char source[] = {'\xD6', '\x0E', '\xED', '\x63', '\x08', '\x00', '\xD7', '\xCA', '\xD9', '\x26', '\xF9', '\x76', '\x09', '\x08', '\xD1', '\xD6', - '\xA5', '\x32', '\xE4', '\x71', '\x0B', '\x3D', '\xF7', '\xCE', '\xE2', '\x0F', '\xEA', '\x65', '\x10', '\x0A', '\xA5'}; + constexpr auto sourceText = CRYPT_NAME("Software\\Gravity Soft\\Ragnarok", 0xAFA5617F178B6185ULL); + const auto& source = sourceText.data; g_subKey = DecryptString<0xAFA5617F178B6185ULL>(source); } { - const std::uint8_t source[] = {0xBB, 0xB2, 0x5A, 0x69, 0x54, 0x5B, 0x64, 0x8E, 0xE9}; + constexpr std::array sourceArray = CRYPT_NAME("Ragnarok", 0xE50B2935073DD3E9ULL); + const std::uint8_t (&source)[9] = sourceArray._Elems; g_windowName = DecryptText<0xE50B2935073DD3E9ULL>(source); } switch (g_serviceMode) { case 2: { - const std::uint8_t client[] = {0x59, 0xD4, 0xEE, 0x5C, 0x67, 0xD3, 0xF6, 0xAC, 0x79, 0x9B, 0xEC, 0x6D, 0x6C, 0xB7}; + constexpr std::array clientArray = CRYPT_NAME("RagIndoor.exe", 0xC399B7091589B50BULL); + const std::uint8_t (&client)[14] = clientArray._Elems; g_clientExeName = DecryptText<0xC399B7091589B50BULL>(client); const std::uint8_t patcher[] = {0x50, 0x03, 0xAB, 0x90, 0x32, 0x73, 0xB4, 0x0F, 0x37, 0x08, 0xB7, 0x9A, 0x5D}; g_patcherExeName = DecryptText<0x7FC1015DFFCF6D19ULL>(patcher); - const char message[] = {'\x69', '\x8D', '\xCC', '\x8E', '\x92', '\xC2', '\x73', '\x75', '\x4C', '\x8F', '\x89', '\xBD', '\x80', - '\xC0', '\x1A', '\x69', '\x5D', '\x8E', '\xC6', '\x9D', '\xCF', '\xC2', '\x2B', '\x62', '\x39'}; - g_runPatcherMessage = DecryptString<0x0753A7E1EFA9E139ULL>(message); + const auto message = CRYPT_NAME("Please run RagIndoor.exe", 0x0753A7E1EFA9E139ULL); + g_runPatcherMessage = DecryptString<0x0753A7E1EFA9E139ULL>(message.data); break; } case 3: { diff --git a/Source/Contents/Configuration/ServiceOptions.cpp b/Source/Contents/Configuration/ServiceOptions.cpp index 397a5e0d9..d43c91782 100644 --- a/Source/Contents/Configuration/ServiceOptions.cpp +++ b/Source/Contents/Configuration/ServiceOptions.cpp @@ -37,6 +37,7 @@ #include "Utility/Cipher/XorBytes.h" #include "Utility/Singleton.h" #include "Utility/Text/StringUtil.h" +#include "Utility/Cipher/CryptName.h" #include "Resource/MSGSTRINGID.h" #include "Network/Packets/PacketId.h" @@ -522,11 +523,7 @@ bool CGameSettingsMgr::LoadSettings() { this->Init_Func(); - const std::array source = { - '\x5B', '\x6E', '\x4C', '\xE5', '\xD4', '\x87', '\x24', '\x7C', '\x22', '\x2A', '\x19', '\xFF', '\xF1', '\x9E', '\x20', '\x2F', - '\x51', '\x72', '\x41', '\xC6', '\xCE', '\xB7', '\x0E', '\x7F', '\x63', '\x72', '\x42', '\xCD', '\xF4', '\x85', '\x27', '\x60', - '\x4B', '\x5C', '\x4C', '\xCE', '\xD8', '\xB8', '\x24', '\x7B', '\x63', '\x72', '\x43', '\xC4', '\xCE', '\xC5', '\x2D', '\x7A', - '\x75', '\x1B'}; + constexpr std::array source = CRYPT_NAME("LuaFiles514\\Lua Files\\OptionInfo\\GameSettings.lub", 0x0F41EBBDA32D1B17ULL); thread_local EncryptedName name(source); if (!this->LoadFile(name.Text())) { return false; diff --git a/Source/Contents/Effects/Particles/CharacterParticleBundle.cpp b/Source/Contents/Effects/Particles/CharacterParticleBundle.cpp index d399ab3af..bd0be7e80 100644 --- a/Source/Contents/Effects/Particles/CharacterParticleBundle.cpp +++ b/Source/Contents/Effects/Particles/CharacterParticleBundle.cpp @@ -142,7 +142,8 @@ const std::vector& CChopChopClawMarks::GetRing(int radius) { // FUNCTION: fn_03135 void CChopChopClawMarks::OnInit() { const int id = CEZ2STREffectMgr::GetInstance()->EffectId([] { - const std::uint8_t bytes[] = {0xC2, 0x55, 0xF0, 0xA7, 0x3C, 0xEC, 0x4F, 0x36, 0xD1, 0x3D}; + constexpr std::array bytesArray = CRYPT_NAME("chop_chop", 0x59278F63D79F3DA1ULL); + const std::uint8_t (&bytes)[10] = bytesArray._Elems; thread_local EncryptedName name(bytes); return name.Text(); }()); diff --git a/Source/Contents/Emblems/EmblemDataMgr.cpp b/Source/Contents/Emblems/EmblemDataMgr.cpp index 8950ed4db..38ffedb17 100644 --- a/Source/Contents/Emblems/EmblemDataMgr.cpp +++ b/Source/Contents/Emblems/EmblemDataMgr.cpp @@ -3,6 +3,7 @@ #include "Contents/Emblems/EmblemDataMgr.h" #include "Client/Session/Session.h" #include "Network/Connection/Connection.h" +#include "Utility/Cipher/CryptName.h" #include "Utility/Cipher/EncryptedName.h" @@ -61,7 +62,8 @@ void CEmblemDataMgr::RefreshUrls(LuaScript& settings, LuaScript& tables, const c if (!base.empty()) { { - const std::uint8_t source[] = {0x08, 0x64, 0x6A, 0x0F, 0x6F, 0xA0, 0x9E, 0x00, 0x52, 0x71, 0x6B, 0x02, 0x62, 0xA1, 0xF3}; + constexpr std::array sourceArray = CRYPT_NAME("/emblem/upload", 0x2FF3C5036D070127ULL); + const std::uint8_t (&source)[15] = sourceArray._Elems; thread_local EncryptedName name(source); this->m_uploadUrl = base + name.Text(); } diff --git a/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp b/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp index c473be6dc..2abc71d50 100644 --- a/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp +++ b/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp @@ -6,6 +6,7 @@ #include "Utility/Cipher/XorBytes.h" #include "Utility/Text/FormatString.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -57,7 +58,8 @@ void CEmblemDataUploadAsyncWork::Bind(std::string url, std::uint32_t accountId, this->m_accountName = accountName; this->m_guildId = guildId; this->m_path = path; - const std::uint8_t diagnosticSource[] = {0x62, 0x97, 0x24, 0xD7, 0x8C, 0xDA, 0x41, 0xC5}; + constexpr std::array diagnosticSourceArray = CRYPT_NAME("unknwon", 0xC52FB5FBB94FF917ULL); + const std::uint8_t (&diagnosticSource)[8] = diagnosticSourceArray._Elems; AsyncDiagnostic diagnostic(false, std::string(DecryptName<0xC52FB5FBB94FF917ULL>(diagnosticSource)), sourceFile, 54); this->m_diagnostic.MoveFrom(diagnostic); } @@ -79,9 +81,11 @@ bool CEmblemDataUploadAsyncWork::Execute() { std::string imageType = g_curlMgr->ToUtf8(extension); CCURLPostHander handler(this->m_url); - const std::uint8_t aid[] = {0xF6, 0x4E, 0x13, 0xCD}; + constexpr std::array aidArray = CRYPT_NAME("AID", 0x812BE72BCD5707B7ULL); + const std::uint8_t (&aid)[4] = aidArray._Elems; handler.AddField(DecryptName<0x812BE72BCD5707B7ULL>(aid), account, 4); - const std::uint8_t authToken[] = {0xE0, 0x48, 0xEB, 0xBF, 0x37, 0xE0, 0x4C, 0x3C, 0xCF, 0x3D}; + constexpr std::array authTokenArray = CRYPT_NAME("AuthToken", 0x59278F63D79F3DA1ULL); + const std::uint8_t (&authToken)[10] = authTokenArray._Elems; handler.AddField(DecryptName<0x59278F63D79F3DA1ULL>(authToken), this->m_token, 4); const std::uint8_t worldName[] = {0x48, 0x5E, 0xBF, 0x8B, 0x89, 0x3B, 0x0C, 0x70, 0x7A, 0x31}; handler.AddField(DecryptName<0x1D6D75EDE7CD311FULL>(worldName), name, 4); diff --git a/Source/Contents/Messenger/ClientMessenger.cpp b/Source/Contents/Messenger/ClientMessenger.cpp index 2f98a2710..1ff6ca16c 100644 --- a/Source/Contents/Messenger/ClientMessenger.cpp +++ b/Source/Contents/Messenger/ClientMessenger.cpp @@ -38,6 +38,7 @@ #include "Contents/Tables/TipBoxTitles.h" #include "Render/Text/EmbedFont.h" #include "Utility/Cipher/XorBytes.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -6341,35 +6342,35 @@ HANDLE g_embedFontFiles; // FUNCTION: fn_23337 void CSession::InitClientData() { if (!g_itemInfoMgr->Load()) { - const char captionSource[] = {'\x2A', '\x0F', '\x89', '\x4C', '\x03', '\x07'}; - const char* caption = DecryptName<0xCD8F077123FB7D6FULL>(captionSource); - const char messageSource[] = {'\x80', '\x81', '\x3A', '\xE6', '\xC6', '\xBB', '\xDD', '\x4C', '\xE9', '\x93', '\x36', '\xE7', '\xEA', '\xF5', '\xF2', '\x4D', '\xA0', '\x81', '\x5F'}; - const char* message = DecryptName<0x23BBD58F8B5FF5C9ULL>(messageSource); + const auto captionSource = CRYPT_NAME("Error", 0xCD8F077123FB7D6FULL); + const char* caption = DecryptName<0xCD8F077123FB7D6FULL>(captionSource.data); + const auto messageSource = CRYPT_NAME("ItemInfo file Init", 0x23BBD58F8B5FF5C9ULL); + const char* message = DecryptName<0x23BBD58F8B5FF5C9ULL>(messageSource.data); MessageBoxA(nullptr, message, caption, 0); } if (!g_specialPopupMgr->Init()) { - const char captionSource[] = {'\x72', '\x35', '\xDF', '\x56', '\xCD', '\xE5'}; - const char* caption = DecryptName<0x17A9E5BF39AD4737ULL>(captionSource); - const char messageSource[] = {'\x10', '\x79', '\x16', '\x64', '\x9C', '\xFE', '\x05', '\xC9', '\x0C', '\x79', '\x06', '\x77', '\xF5', '\xD9', '\x20', '\xF5', '\x26', '\x09', '\x1A', '\x49', '\xBC', '\xCB', '\x49'}; - const char* message = DecryptName<0x9949BFD527532943ULL>(messageSource); + const auto captionSource = CRYPT_NAME("Error", 0x17A9E5BF39AD4737ULL); + const char* caption = DecryptName<0x17A9E5BF39AD4737ULL>(captionSource.data); + const auto messageSource = CRYPT_NAME("SPECIALPOPUP file Init", 0x9949BFD527532943ULL); + const char* message = DecryptName<0x9949BFD527532943ULL>(messageSource.data); MessageBoxA(nullptr, message, caption, 0); } if (!g_runeSystemMgr->LoadScripts()) { - const char captionSource[] = {'\x1A', '\x47', '\xDD', '\xFA', '\xEF', '\x89'}; - const char* caption = DecryptName<0xCFF3899D95AF355FULL>(captionSource); - const char messageSource[] = {'\x24', '\xF9', '\xE4', '\xCB', '\xC4', '\x6C', '\x9A', '\x60', '\x13', '\xCE', '\xFC', '\xE8', '\xC6', '\x4D', '\xC3', '\x75', '\x0E', '\xC7', '\xF4', '\x85', '\xE8', '\x51', '\x8A', '\x67', '\x67'}; - const char* message = DecryptName<0x13E33FA1A591AB67ULL>(messageSource); + const auto captionSource = CRYPT_NAME("Error", 0xCFF3899D95AF355FULL); + const char* caption = DecryptName<0xCFF3899D95AF355FULL>(captionSource.data); + const auto messageSource = CRYPT_NAME("CRuneSystemMgr file Init", 0x13E33FA1A591AB67ULL); + const char* message = DecryptName<0x13E33FA1A591AB67ULL>(messageSource.data); MessageBoxA(nullptr, message, caption, 0); } static_cast(CTipBoxMgr::Create()); if (!g_itemTagOwner->RegisterLuaFunctions()) { - const char captionSource[] = {'\xF2', '\x43', '\x9D', '\xAC', '\x71', '\xDF'}; - const char* caption = DecryptName<0x4F99DF03C3EF31B7ULL>(captionSource); - const char messageSource[] = {'\x71', '\x18', '\xDF', '\x89', '\x62', '\x8B', '\x0D', '\x83', '\x4C', '\x1D', '\xCA', '\xEB', '\x44', '\x9D', '\x44', '\x91', '\x25'}; - const char* message = DecryptName<0xE52DF30DCBAF7125ULL>(messageSource); + const auto captionSource = CRYPT_NAME("Error", 0x4F99DF03C3EF31B7ULL); + const char* caption = DecryptName<0x4F99DF03C3EF31B7ULL>(captionSource.data); + const auto messageSource = CRYPT_NAME("TipBox file Init", 0xE52DF30DCBAF7125ULL); + const char* message = DecryptName<0xE52DF30DCBAF7125ULL>(messageSource.data); MessageBoxA(nullptr, message, caption, 0); } diff --git a/Source/Contents/Party/LoadPartyListAsyncWork.cpp b/Source/Contents/Party/LoadPartyListAsyncWork.cpp index 7598094b7..1f85cdde8 100644 --- a/Source/Contents/Party/LoadPartyListAsyncWork.cpp +++ b/Source/Contents/Party/LoadPartyListAsyncWork.cpp @@ -6,6 +6,7 @@ #include "Utility/Cipher/XorBytes.h" #include "Utility/Text/FormatString.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -61,7 +62,8 @@ void CLoadPartyListAsyncWork::Bind( this->m_filter = filter; this->m_page = page; this->m_search = search; - const std::uint8_t diagnosticSource[] = {0x80, 0xE9, 0x96, 0x93, 0x58, 0x52, 0x01, 0x93}; + constexpr std::array diagnosticSourceArray = CRYPT_NAME("unknwon", 0x936F3D2FFDFD87F5ULL); + const std::uint8_t (&diagnosticSource)[8] = diagnosticSourceArray._Elems; AsyncDiagnostic diagnostic = Diagnostic(false, DecryptName<0x936F3D2FFDFD87F5ULL>(diagnosticSource), 54); this->m_diagnostic.MoveFrom(diagnostic); this->m_windows = &windows; @@ -78,11 +80,14 @@ bool CLoadPartyListAsyncWork::Execute() { StringFormat(page, sizeof(page), _TRUNCATE, "%d", this->m_page); const std::string world = CCURLMgr::GetInstance()->ToUtf8(this->m_world); CCURLPostHander handler(this->m_url); - const std::uint8_t gid[] = {0xCE, 0x74, 0x29, 0xE5}; + constexpr std::array gidArray = CRYPT_NAME("GID", 0x2F2701A7E56D3D89ULL); + const std::uint8_t (&gid)[4] = gidArray._Elems; handler.AddField(DecryptName<0x2F2701A7E56D3D89ULL>(gid), character, 4); - const std::uint8_t aid[] = {0x64, 0xD8, 0x43, 0xA3}; + constexpr std::array aidArray = CRYPT_NAME("AID", 0x6B3301E1A3079125ULL); + const std::uint8_t (&aid)[4] = aidArray._Elems; handler.AddField(DecryptName<0x6B3301E1A3079125ULL>(aid), account, 4); - const std::uint8_t worldName[] = {0xF8, 0xCE, 0xB7, 0x5B, 0x73, 0x27, 0xD6, 0x1C, 0xCA, 0xA1}; + constexpr std::array worldNameArray = CRYPT_NAME("WorldName", 0x71B7691737C5A1AFULL); + const std::uint8_t (&worldName)[10] = worldNameArray._Elems; handler.AddField(DecryptName<0x71B7691737C5A1AFULL>(worldName), world, 4); const std::uint8_t authToken[] = {0x22, 0x4C, 0x09, 0xC9, 0x0D, 0xDA, 0xF4, 0xA6, 0x0D, 0x39}; handler.AddField(DecryptName<0xC39FB559A17D3963ULL>(authToken), this->m_token, 4); diff --git a/Source/Contents/Party/RegisterPartyAsyncWork.cpp b/Source/Contents/Party/RegisterPartyAsyncWork.cpp index 8b2c845e8..30ae0b9f2 100644 --- a/Source/Contents/Party/RegisterPartyAsyncWork.cpp +++ b/Source/Contents/Party/RegisterPartyAsyncWork.cpp @@ -7,6 +7,7 @@ #include "Utility/Cipher/XorBytes.h" #include "Utility/Text/FormatString.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -53,7 +54,8 @@ void CRegisterPartyAsyncWork::Bind( this->m_url = url; this->m_token = token; this->m_info = info; - const std::uint8_t diagnosticSource[] = {0x80, 0xE9, 0x96, 0x93, 0x58, 0x52, 0x01, 0x93}; + constexpr std::array diagnosticSourceArray = CRYPT_NAME("unknwon", 0x936F3D2FFDFD87F5ULL); + const std::uint8_t (&diagnosticSource)[8] = diagnosticSourceArray._Elems; AsyncDiagnostic diagnostic(false, std::string(DecryptName<0x936F3D2FFDFD87F5ULL>(diagnosticSource)), sourceFile, 50); this->m_diagnostic.MoveFrom(diagnostic); } diff --git a/Source/Contents/Pet/PetTalkNames.cpp b/Source/Contents/Pet/PetTalkNames.cpp index 99f50500b..9945995b3 100644 --- a/Source/Contents/Pet/PetTalkNames.cpp +++ b/Source/Contents/Pet/PetTalkNames.cpp @@ -2,6 +2,7 @@ #include "Client/Session/Session.h" #include "Utility/Cipher/XorBytes.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -22,602 +23,602 @@ const char* DecryptName(const char (&source)[Length]) { const char* CSession::GetPetTalkName(int job) { switch (job) { case JT_PORING: { - const char source[] = {'\x67', '\x74', '\x5F', '\xCA', '\xD3', '\x8C', '\x41'}; - return DecryptName<0x0F41EBBDA32D1B17ULL>(source); + const auto source = CRYPT_NAME("poring", 0x0F41EBBDA32D1B17ULL); + return DecryptName<0x0F41EBBDA32D1B17ULL>(source.data); } case JT_ROCKER: { - const char source[] = {'\xB3', '\x28', '\xA6', '\x7C', '\x84', '\xEB', '\xD5'}; - return DecryptName<0xFBD599E117C547C1ULL>(source); + const auto source = CRYPT_NAME("rocker", 0xFBD599E117C547C1ULL); + return DecryptName<0xFBD599E117C547C1ULL>(source.data); } case JT_DROPS: { - const char source[] = {'\x01', '\x81', '\xB8', '\x2D', '\xFE', '\x13'}; - return DecryptName<0x176F138D5DD7F365ULL>(source); + const auto source = CRYPT_NAME("drops", 0x176F138D5DD7F365ULL); + return DecryptName<0x176F138D5DD7F365ULL>(source.data); } case JT_POPORING: { - const char source[] = {'\x15', '\x3A', '\xB9', '\x10', '\x7F', '\x86', '\x41', '\x22', '\x65'}; - return DecryptName<0x452FEF0D7FC95565ULL>(source); + const auto source = CRYPT_NAME("poporing", 0x452FEF0D7FC95565ULL); + return DecryptName<0x452FEF0D7FC95565ULL>(source.data); } case JT_LUNATIC: { - const char source[] = {'\x31', '\x78', '\x27', '\xE8', '\xD5', '\x14', '\x8E', '\x9F'}; - return DecryptName<0x9FED7DA189490D5DULL>(source); + const auto source = CRYPT_NAME("lunatic", 0x9FED7DA189490D5DULL); + return DecryptName<0x9FED7DA189490D5DULL>(source.data); } case JT_PICKY: { - const char source[] = {'\xC3', '\x0E', '\x3A', '\xE4', '\xA6', '\x27'}; - return DecryptName<0x839B27DF8F5967B3ULL>(source); + const auto source = CRYPT_NAME("picky", 0x839B27DF8F5967B3ULL); + return DecryptName<0x839B27DF8F5967B3ULL>(source.data); } case JT_CHONCHON: { - const char source[] = {'\x0E', '\x73', '\xC8', '\x7F', '\x14', '\x07', '\xA4', '\x9D', '\x6D'}; - return DecryptName<0xF3CB6F7711A71B6DULL>(source); + const auto source = CRYPT_NAME("chonchon", 0xF3CB6F7711A71B6DULL); + return DecryptName<0xF3CB6F7711A71B6DULL>(source.data); } case JT_STEEL_CHONCHON: { - const char source[] = {'\x3C', '\xD5', '\xAA', '\x50', '\x0F', '\x88', '\x22', '\x11', '\x20', '\xCF', '\xAC', '\x5D', '\x0C', '\xB9', '\x41'}; - return DecryptName<0x7941D76335CFA14FULL>(source); + const auto source = CRYPT_NAME("steel_chonchon", 0x7941D76335CFA14FULL); + return DecryptName<0x7941D76335CFA14FULL>(source.data); } case JT_HUNTER_FLY: { - const char source[] = {'\x89', '\xEC', '\xE9', '\x3B', '\xE4', '\xB1', '\x7E', '\x15', '\x8D', '\xE0', '\x87'}; - return DecryptName<0x7321C3814F8799E1ULL>(source); + const auto source = CRYPT_NAME("hunter_fly", 0x7321C3814F8799E1ULL); + return DecryptName<0x7321C3814F8799E1ULL>(source.data); } case JT_DESERT_WOLF_B: { - const char source[] = {'\x47', '\x94', '\xA4', '\x72', '\xA5', '\x3D', '\xBC', '\x0A', '\x4C', '\x9D', '\xB1', '\x48', '\xB5', '\x28', '\x81', '\x18', '\x23'}; - return DecryptName<0x7DE349D717D7F123ULL>(source); + const auto source = CRYPT_NAME("desert_wolf_babe", 0x7DE349D717D7F123ULL); + return DecryptName<0x7DE349D717D7F123ULL>(source.data); } case JT_SPORE: { - const char source[] = {'\x0C', '\xA5', '\xC0', '\x29', '\x0E', '\xB1'}; - return DecryptName<0x0F15B16B5BAFD57FULL>(source); + const auto source = CRYPT_NAME("spore", 0x0F15B16B5BAFD57FULL); + return DecryptName<0x0F15B16B5BAFD57FULL>(source.data); } case JT_POISON_SPORE: { - const char source[] = {'\x3F', '\x08', '\x84', '\xF6', '\x66', '\x59', '\x60', '\x0A', '\x3F', '\x08', '\x9F', '\xE0', '\x09'}; - return DecryptName<0x793F370985ED674FULL>(source); + const auto source = CRYPT_NAME("poison_spore", 0x793F370985ED674FULL); + return DecryptName<0x793F370985ED674FULL>(source.data); } case JT_PECOPECO: { - const char source[] = {'\x6D', '\x60', '\xF0', '\x46', '\x01', '\x46', '\x34', '\x8A', '\x1D'}; - return DecryptName<0xE55723712993051DULL>(source); + const auto source = CRYPT_NAME("pecopeco", 0xE55723712993051DULL); + return DecryptName<0xE55723712993051DULL>(source.data); } case JT_SMOKIE: { - const char source[] = {'\xBA', '\x7E', '\x96', '\x18', '\x90', '\xBC', '\x15'}; - return DecryptName<0x7115D9F973F913C9ULL>(source); + const auto source = CRYPT_NAME("smokie", 0x7115D9F973F913C9ULL); + return DecryptName<0x7115D9F973F913C9ULL>(source.data); } case JT_YOYO: { - const char source[] = {'\x1A', '\x9A', '\x98', '\x10', '\x3B'}; - return DecryptName<0xCB1D253B7FE1F563ULL>(source); + const auto source = CRYPT_NAME("yoyo", 0xCB1D253B7FE1F563ULL); + return DecryptName<0xCB1D253B7FE1F563ULL>(source.data); } case JT_ORK_WARRIOR: { - const char source[] = {'\x18', '\xE5', '\xEC', '\x42', '\x54', '\x32', '\x93', '\x1D', '\x1E', '\xF8', '\xF5', '\x1D'}; - return DecryptName<0x6FE153231D879777ULL>(source); + const auto source = CRYPT_NAME("ork_warrior", 0x6FE153231D879777ULL); + return DecryptName<0x6FE153231D879777ULL>(source.data); } case JT_MUNAK: { - const char source[] = {'\x36', '\x26', '\x31', '\xBC', '\xEC', '\x9F'}; - return DecryptName<0x39A39F87DD5F535BULL>(source); + const auto source = CRYPT_NAME("munak", 0x39A39F87DD5F535BULL); + return DecryptName<0x39A39F87DD5F535BULL>(source.data); } case JT_DOKEBI: { - const char source[] = {'\xA1', '\x42', '\x40', '\x5A', '\xEB', '\x74', '\x6D'}; - return DecryptName<0xEF6D1D893F2B2DC5ULL>(source); + const auto source = CRYPT_NAME("dokebi", 0xEF6D1D893F2B2DC5ULL); + return DecryptName<0xEF6D1D893F2B2DC5ULL>(source.data); } case JT_SOHEE: { - const char source[] = {'\x6E', '\xA8', '\x23', '\xD0', '\xB8', '\x77'}; - return DecryptName<0x234977DDB54BC71DULL>(source); + const auto source = CRYPT_NAME("sohee", 0x234977DDB54BC71DULL); + return DecryptName<0x234977DDB54BC71DULL>(source.data); } case JT_ISIS: { - const char source[] = {'\x46', '\xA4', '\x2C', '\x56', '\x39'}; - return DecryptName<0xA12DAB392545D72FULL>(source); + const auto source = CRYPT_NAME("isis", 0xA12DAB392545D72FULL); + return DecryptName<0xA12DAB392545D72FULL>(source.data); } case JT_PETIT: { - const char source[] = {'\x05', '\x5E', '\x77', '\x46', '\x67', '\xC1'}; - return DecryptName<0x6BA1C1132F033B75ULL>(source); + const auto source = CRYPT_NAME("petit", 0x6BA1C1132F033B75ULL); + return DecryptName<0x6BA1C1132F033B75ULL>(source.data); } case JT_DEVIRUCHI: { - const char source[] = {'\xB5', '\x3E', '\xE1', '\x8C', '\x4B', '\xF2', '\x88', '\x47', '\xB8', '\x5B'}; - return DecryptName<0x2FEB8739E5975BD1ULL>(source); + const auto source = CRYPT_NAME("deviruchi", 0x2FEB8739E5975BD1ULL); + return DecryptName<0x2FEB8739E5975BD1ULL>(source.data); } case JT_BAPHOMET_: { - const char source[] = {'\xAF', '\x62', '\xBD', '\x13', '\xF8', '\x56', '\x76', '\x47', '\x92', '\x69', '\xCD'}; - return DecryptName<0x33133B977BCD03CDULL>(source); + const auto source = CRYPT_NAME("baphomet_j", 0x33133B977BCD03CDULL); + return DecryptName<0x33133B977BCD03CDULL>(source.data); } case JT_SAVAGE_BABE: { - const char source[] = {'\x84', '\x72', '\x5D', '\xCE', '\x96', '\x6A', '\x42', '\xEF', '\x96', '\x71', '\x4E', '\xAF'}; - return DecryptName<0x8D1D0FF1AF2B13F7ULL>(source); + const auto source = CRYPT_NAME("savage_babe", 0x8D1D0FF1AF2B13F7ULL); + return DecryptName<0x8D1D0FF1AF2B13F7ULL>(source.data); } case JT_BON_GUN: { - const char source[] = {'\xEF', '\xD4', '\xA1', '\x24', '\xF6', '\xD2', '\xF1', '\xB3'}; - return DecryptName<0xB39FA7917BCFBB8DULL>(source); + const auto source = CRYPT_NAME("bon_gun", 0xB39FA7917BCFBB8DULL); + return DecryptName<0xB39FA7917BCFBB8DULL>(source.data); } case JT_ECLIPSE_P: { - const char source[] = {'\xEE', '\x82', '\x01', '\x70', '\x37', '\x26', '\x8E', '\x72', '\xFB', '\xC1'}; - return DecryptName<0x2DCB7567394DC1ABULL>(source); + const auto source = CRYPT_NAME("ECLIPSE_P", 0x2DCB7567394DC1ABULL); + return DecryptName<0x2DCB7567394DC1ABULL>(source.data); } case JT_ZHERLTHSH: { - const char source[] = {'\x23', '\xDF', '\x62', '\x61', '\xA9', '\x09', '\x0B', '\x3C', '\x31', '\xB7'}; - return DecryptName<0x4F637DC51307B759ULL>(source); + const auto source = CRYPT_NAME("zherlthsh", 0x4F637DC51307B759ULL); + return DecryptName<0x4F637DC51307B759ULL>(source.data); } case JT_ALICE: { - const char source[] = {'\x44', '\x1D', '\xC6', '\xA8', '\x68', '\xF3'}; - return DecryptName<0xE52DF30DCBAF7125ULL>(source); + const auto source = CRYPT_NAME("alice", 0xE52DF30DCBAF7125ULL); + return DecryptName<0xE52DF30DCBAF7125ULL>(source.data); } case JT_EVENT_RICECAKE: { - const char source[] = {'\x3A', '\x43', '\xCA', '\xFB', '\xE9', '\xD6', '\x81', '\xA6', '\x3C', '\x50', '\xCC', '\xF4', '\xF6', '\xEC', '\xF3'}; - return DecryptName<0xCFF3899D95AF355FULL>(source); + const auto source = CRYPT_NAME("event_ricecake", 0xCFF3899D95AF355FULL); + return DecryptName<0xCFF3899D95AF355FULL>(source.data); } case JT_GOBLINE_XMAS: { - const char source[] = {'\x90', '\xA6', '\x01', '\x05', '\x14', '\xF7', '\x14', '\xCE', '\x8F', '\xA4', '\x02', '\x1A', '\x7D'}; - return DecryptName<0x9171997D6963C9F7ULL>(source); + const auto source = CRYPT_NAME("gobline_xmas", 0x9171997D6963C9F7ULL); + return DecryptName<0x9171997D6963C9F7ULL>(source.data); } case JT_CHUNG_E: case JT_CHUNG_E_: { - const char source[] = {'\xF4', '\x79', '\xBA', '\x8D', '\x44', '\x80', '\xDC', '\x4F'}; - return DecryptName<0x4F99DF03C3EF31B7ULL>(source); + const auto source = CRYPT_NAME("CHUNG_E", 0x4F99DF03C3EF31B7ULL); + return DecryptName<0x4F99DF03C3EF31B7ULL>(source.data); } case JT_P_CHUNG_E: { - const char source[] = {'\x13', '\x76', '\x10', '\x6F', '\x80', '\xF1', '\x0E', '\xC6', '\x06', '\x29'}; - return DecryptName<0x9949BFD527532943ULL>(source); + const auto source = CRYPT_NAME("P_CHUNG_E", 0x9949BFD527532943ULL); + return DecryptName<0x9949BFD527532943ULL>(source.data); } case JT_GOBLIN_1: { - const char source[] = {'\x08', '\x12', '\x99', '\x4F', '\x18', '\x69', '\xD0', '\xFC', '\x6F'}; - return DecryptName<0xCD8F077123FB7D6FULL>(source); + const auto source = CRYPT_NAME("goblin_1", 0xCD8F077123FB7D6FULL); + return DecryptName<0xCD8F077123FB7D6FULL>(source.data); } case JT_GOBLIN_2: { - const char source[] = {'\x00', '\xC4', '\xF3', '\xC9', '\xC8', '\x51', '\xBC', '\x21', '\x67'}; - return DecryptName<0x13E33FA1A591AB67ULL>(source); + const auto source = CRYPT_NAME("goblin_2", 0x13E33FA1A591AB67ULL); + return DecryptName<0x13E33FA1A591AB67ULL>(source.data); } case JT_GOBLIN_4: { - const char source[] = {'\x50', '\x28', '\xCF', '\x55', '\xD6', '\x8B', '\xF6', '\x23', '\x37'}; - return DecryptName<0x17A9E5BF39AD4737ULL>(source); + const auto source = CRYPT_NAME("goblin_4", 0x17A9E5BF39AD4737ULL); + return DecryptName<0x17A9E5BF39AD4737ULL>(source.data); } case JT_DELETER_: { - const char source[] = {'\xC1', '\xF8', '\x01', '\x9C', '\x17', '\x42', '\x05', '\x5C', '\xA5'}; - return DecryptName<0x03772763F96D9DA5ULL>(source); + const auto source = CRYPT_NAME("deleter_", 0x03772763F96D9DA5ULL); + return DecryptName<0x03772763F96D9DA5ULL>(source.data); } case JT_DIABOLIC: { - const char source[] = {'\xE3', '\x7A', '\x0A', '\x1D', '\x56', '\x65', '\x18', '\x68', '\x87'}; - return DecryptName<0x0B7109397F6B1387ULL>(source); + const auto source = CRYPT_NAME("diabolic", 0x0B7109397F6B1387ULL); + return DecryptName<0x0B7109397F6B1387ULL>(source.data); } case JT_WANDER_MAN: { - const char source[] = {'\xBE', '\x94', '\x31', '\xEF', '\xEA', '\xA7', '\xE4', '\x4E', '\xA8', '\x9B', '\x5F'}; - return DecryptName<0x23BBD58F8B5FF5C9ULL>(source); + const auto source = CRYPT_NAME("wander_man", 0x23BBD58F8B5FF5C9ULL); + return DecryptName<0x23BBD58F8B5FF5C9ULL>(source.data); } case JT_BACSOJIN_: { - const char source[] = {'\x2F', '\xFA', '\xD6', '\x7E', '\xDC', '\xB1', '\x5E', '\x8B', '\x32', '\xBB'}; - return DecryptName<0xC517FB932D95BB6DULL>(source); + const auto source = CRYPT_NAME("BACSOJIN_", 0xC517FB932D95BB6DULL); + return DecryptName<0xC517FB932D95BB6DULL>(source.data); } case JT_CIVIL_SERVANT: { - const char source[] = {'\xCC', '\xF4', '\xB9', '\xCE', '\x31', '\x9A', '\xFE', '\x30', '\xDD', '\xEB', '\xAE', '\xC9', '\x29', '\xC5'}; - return DecryptName<0x75ADC57D87EFBD8FULL>(source); + const auto source = CRYPT_NAME("CIVIL_SERVANT", 0x75ADC57D87EFBD8FULL); + return DecryptName<0x75ADC57D87EFBD8FULL>(source.data); } case JT_LEAF_CAT: { - const char source[] = {'\x95', '\xBC', '\xA0', '\xA5', '\x32', '\x56', '\xEC', '\x7F', '\xD9'}; - return DecryptName<0x2BAD156DE3E1F9D9ULL>(source); + const auto source = CRYPT_NAME("LEAF_CAT", 0x2BAD156DE3E1F9D9ULL); + return DecryptName<0x2BAD156DE3E1F9D9ULL>(source.data); } case JT_LOLI_RURI: { - const char source[] = {'\xD9', '\xC0', '\xAD', '\x44', '\x02', '\x5B', '\x34', '\xA3', '\xDC', '\x8F'}; - return DecryptName<0xF161095D0DE18F95ULL>(source); + const auto source = CRYPT_NAME("LOLI_RURI", 0xF161095D0DE18F95ULL); + return DecryptName<0xF161095D0DE18F95ULL>(source.data); } case JT_MARIONETTE: { - const char source[] = {'\xA2', '\x30', '\x8D', '\x5A', '\x22', '\x01', '\x82', '\xB9', '\xBB', '\x34', '\xDF'}; - return DecryptName<0xEDC74F6D13DF71EFULL>(source); + const auto source = CRYPT_NAME("MARIONETTE", 0xEDC74F6D13DF71EFULL); + return DecryptName<0xEDC74F6D13DF71EFULL>(source.data); } case JT_SHINOBI: { - const char source[] = {'\xEA', '\x4D', '\x3E', '\x01', '\x44', '\x5F', '\xC6', '\x75'}; - return DecryptName<0x758F1D0B4F7705B9ULL>(source); + const auto source = CRYPT_NAME("SHINOBI", 0x758F1D0B4F7705B9ULL); + return DecryptName<0x758F1D0B4F7705B9ULL>(source.data); } case JT_WHISPER: { - const char source[] = {'\x32', '\x51', '\x0C', '\x5A', '\x7D', '\x66', '\x49', '\x89'}; - return DecryptName<0x891B232D09451965ULL>(source); + const auto source = CRYPT_NAME("WHISPER", 0x891B232D09451965ULL); + return DecryptName<0x891B232D09451965ULL>(source.data); } case JT_DULLAHAN: { - const char source[] = {'\x2D', '\x4A', '\x3B', '\x19', '\xDC', '\xDD', '\x3A', '\x2D', '\x69'}; - return DecryptName<0x637B959D55771F69ULL>(source); + const auto source = CRYPT_NAME("DULLAHAN", 0x637B959D55771F69ULL); + return DecryptName<0x637B959D55771F69ULL>(source.data); } case JT_GOBLIN_LEADER: { - const char source[] = {'\x16', '\xC4', '\x8F', '\x4D', '\xF2', '\x73', '\x1E', '\x9D', '\x14', '\xCA', '\x89', '\x44', '\xE9', '\x3D'}; - return DecryptName<0xD1413DBB01CD8B51ULL>(source); + const auto source = CRYPT_NAME("GOBLIN_LEADER", 0xD1413DBB01CD8B51ULL); + return DecryptName<0xD1413DBB01CD8B51ULL>(source.data); } case JT_GOLEM: { - const char source[] = {'\x2C', '\xF6', '\x8B', '\x4A', '\x2A', '\x8F'}; - return DecryptName<0xB7FD8F670FC7B96BULL>(source); + const auto source = CRYPT_NAME("GOLEM", 0xB7FD8F670FC7B96BULL); + return DecryptName<0xB7FD8F670FC7B96BULL>(source.data); } case JT_IMP: { - const char source[] = {'\xB4', '\x9A', '\x1D', '\xA9'}; - return DecryptName<0xE7978FB5A94DD7FDULL>(source); + const auto source = CRYPT_NAME("IMP", 0xE7978FB5A94DD7FDULL); + return DecryptName<0xE7978FB5A94DD7FDULL>(source.data); } case JT_INCUBUS: { - const char source[] = {'\xB4', '\xF7', '\xF8', '\x74', '\xDD', '\xA8', '\x12', '\x49'}; - return DecryptName<0x4941FD9F21BBB9FDULL>(source); + const auto source = CRYPT_NAME("INCUBUS", 0x4941FD9F21BBB9FDULL); + return DecryptName<0x4941FD9F21BBB9FDULL>(source.data); } case JT_MEDUSA: { - const char source[] = {'\x38', '\x88', '\xA9', '\x08', '\x38', '\x24', '\xE5'}; - return DecryptName<0x35E5656B5DEDCD75ULL>(source); + const auto source = CRYPT_NAME("MEDUSA", 0x35E5656B5DEDCD75ULL); + return DecryptName<0x35E5656B5DEDCD75ULL>(source.data); } case JT_MIYABI_NINGYO: { - const char source[] = {'\x32', '\x5C', '\xD4', '\x50', '\x75', '\x46', '\xD4', '\x61', '\x36', '\x5B', '\xCA', '\x48', '\x78', '\x0F'}; - return DecryptName<0x2F8B0F37118D157FULL>(source); + const auto source = CRYPT_NAME("MIYABI_NINGYO", 0x2F8B0F37118D157FULL); + return DecryptName<0x2F8B0F37118D157FULL>(source.data); } case JT_NIGHTMARE_TERROR: { - const char source[] = {'\x83', '\xB8', '\xDE', '\xFD', '\xD9', '\x16', '\x46', '\xFF', '\x88', '\xAE', '\xCD', '\xF0', '\xDF', '\x09', '\x48', '\xFF', '\xCD'}; - return DecryptName<0xAD075B8DB599F1CDULL>(source); + const auto source = CRYPT_NAME("NIGHTMARE_TERROR", 0xAD075B8DB599F1CDULL); + return DecryptName<0xAD075B8DB599F1CDULL>(source.data); } case JT_STONE_SHOOTER: { - const char source[] = {'\xC4', '\xA5', '\xAE', '\x93', '\x94', '\xCC', '\xBA', '\x67', '\xD8', '\xBE', '\xB5', '\x98', '\x83', '\x93'}; - return DecryptName<0x2FE993D1DDE1F197ULL>(source); + const auto source = CRYPT_NAME("STONE_SHOOTER", 0x2FE993D1DDE1F197ULL); + return DecryptName<0x2FE993D1DDE1F197ULL>(source.data); } case JT_SUCCUBUS: { - const char source[] = {'\xDC', '\xCC', '\xA8', '\x4E', '\xE0', '\x3D', '\xAA', '\x6A', '\x8F'}; - return DecryptName<0x39FF7FB50DEB998FULL>(source); + const auto source = CRYPT_NAME("SUCCUBUS", 0x39FF7FB50DEB998FULL); + return DecryptName<0x39FF7FB50DEB998FULL>(source.data); } case JT_WICKED_NYMPH: { - const char source[] = {'\xEA', '\xF4', '\xAE', '\x7C', '\xFE', '\xFB', '\xB0', '\xCD', '\xE4', '\xF0', '\xBD', '\x7F', '\xBB'}; - return DecryptName<0x83EFBFBB37EDBDBDULL>(source); + const auto source = CRYPT_NAME("WICKED_NYMPH", 0x83EFBFBB37EDBDBDULL); + return DecryptName<0x83EFBFBB37EDBDBDULL>(source.data); } case JT_J_TAINI: { - const char source[] = {'\xED', '\xAA', '\x2B', '\x78', '\x78', '\x05', '\x62', '\xBF'}; - return DecryptName<0xBF2B4B31397FF5A7ULL>(source); + const auto source = CRYPT_NAME("J_TAINI", 0xBF2B4B31397FF5A7ULL); + return DecryptName<0xBF2B4B31397FF5A7ULL>(source.data); } case JT_XMAS_LUNATIC: { - const char source[] = {'\xB9', '\x36', '\xB8', '\x84', '\x8A', '\x5F', '\x6C', '\x93', '\xA0', '\x2F', '\xB0', '\x94', '\xD5'}; - return DecryptName<0xDD3913D5D7F97BE1ULL>(source); + const auto source = CRYPT_NAME("XMAS_LUNATIC", 0xDD3913D5D7F97BE1ULL); + return DecryptName<0xDD3913D5D7F97BE1ULL>(source.data); } case JT_TIKBALANG: { - const char source[] = {'\xCF', '\x1E', '\x48', '\xDB', '\x26', '\x49', '\x44', '\x4B', '\xDC', '\x57'}; - return DecryptName<0x050505679903579BULL>(source); + const auto source = CRYPT_NAME("TIKBALANG", 0x050505679903579BULL); + return DecryptName<0x050505679903579BULL>(source.data); } case JT_MARIN: { - const char source[] = {'\xBC', '\x86', '\x6B', '\x40', '\x59', '\x79'}; - return DecryptName<0xF14F79170939C7F1ULL>(source); + const auto source = CRYPT_NAME("MARIN", 0xF14F79170939C7F1ULL); + return DecryptName<0xF14F79170939C7F1ULL>(source.data); } case JT_DOMOVOI: { - const char source[] = {'\xDB', '\x8A', '\x20', '\xE4', '\x81', '\x66', '\xB4', '\xA5'}; - return DecryptName<0xA5FD29D7AB6DC59FULL>(source); + const auto source = CRYPT_NAME("DOMOVOI", 0xA5FD29D7AB6DC59FULL); + return DecryptName<0xA5FD29D7AB6DC59FULL>(source.data); } case JT_LITTLE_PORING: { - const char source[] = {'\x45', '\x6E', '\x7B', '\xEF', '\xF1', '\x18', '\x22', '\x89', '\x46', '\x75', '\x66', '\xF5', '\xFA', '\x5D'}; - return DecryptName<0xD97D5DBDBB2F2709ULL>(source); + const auto source = CRYPT_NAME("LITTLE_PORING", 0xD97D5DBDBB2F2709ULL); + return DecryptName<0xD97D5DBDBB2F2709ULL>(source.data); } case JT_MALE_PORING: { - const char source[] = {'\x12', '\x72', '\xB3', '\xB4', '\xDA', '\x17', '\x16', '\x9F', '\x16', '\x7D', '\xB8', '\xD1'}; - return DecryptName<0xED796785D1DF137FULL>(source); + const auto source = CRYPT_NAME("male_poring", 0xED796785D1DF137FULL); + return DecryptName<0xED796785D1DF137FULL>(source.data); } case JT_FEMALE_PORING: { - const char source[] = {'\xF5', '\x10', '\xB2', '\x8E', '\x21', '\x46', '\x50', '\xEB', '\xFC', '\x07', '\xB6', '\x81', '\x2A', '\x23'}; - return DecryptName<0x9B0F234DEFDF7593ULL>(source); + const auto source = CRYPT_NAME("female_poring", 0x9B0F234DEFDF7593ULL); + return DecryptName<0x9B0F234DEFDF7593ULL>(source.data); } case JT_BLUE_UNICORN: { - const char source[] = {'\x4F', '\x2F', '\xD8', '\x4C', '\x1A', '\x06', '\xC1', '\x90', '\x4E', '\x2C', '\xDF', '\x47', '\x45'}; - return DecryptName<0xD98F5345098D630DULL>(source); + const auto source = CRYPT_NAME("BLUE_UNICORN", 0xD98F5345098D630DULL); + return DecryptName<0xD98F5345098D630DULL>(source.data); } case JT_MASTERING: { - const char source[] = {'\x46', '\x7E', '\x9A', '\xDF', '\xA4', '\x8D', '\x44', '\x11', '\x4C', '\x1F'}; - return DecryptName<0x7F2DFFC1ABE91F2BULL>(source); + const auto source = CRYPT_NAME("mastering", 0x7F2DFFC1ABE91F2BULL); + return DecryptName<0x7F2DFFC1ABE91F2BULL>(source.data); } case JT_SAVAGE: { - const char source[] = {'\xFE', '\xE0', '\x67', '\x92', '\xD4', '\xCC', '\x69'}; - return DecryptName<0xFD69A9B3F311818DULL>(source); + const auto source = CRYPT_NAME("savage", 0xFD69A9B3F311818DULL); + return DecryptName<0xFD69A9B3F311818DULL>(source.data); } case JT_GRAND_PECO: { - const char source[] = {'\x76', '\x91', '\x32', '\xF7', '\xD5', '\x02', '\x05', '\x2E', '\x72', '\x8C', '\x53'}; - return DecryptName<0x4B755DB19953E311ULL>(source); + const auto source = CRYPT_NAME("grand_peco", 0x4B755DB19953E311ULL); + return DecryptName<0x4B755DB19953E311ULL>(source.data); } case JT_HIGH_ORC: { - const char source[] = {'\x53', '\x8E', '\x66', '\x73', '\x9E', '\xCE', '\x59', '\xDE', '\x3B'}; - return DecryptName<0xBD2BA1C11B01E73BULL>(source); + const auto source = CRYPT_NAME("high_orc", 0xBD2BA1C11B01E73BULL); + return DecryptName<0xBD2BA1C11B01E73BULL>(source.data); } case JT_LITTLE_ISIS: { - const char source[] = {'\xF5', '\x64', '\x69', '\x67', '\xC1', '\xD6', '\x4A', '\xA4', '\xEA', '\x64', '\x6E', '\x33'}; - return DecryptName<0xED15938D333D2DB9ULL>(source); + const auto source = CRYPT_NAME("LITTLE_ISIS", 0xED15938D333D2DB9ULL); + return DecryptName<0xED15938D333D2DB9ULL>(source.data); } case JT_ANGELING: { - const char source[] = {'\x22', '\x57', '\x3C', '\x0E', '\x0B', '\x44', '\x1F', '\xAE', '\x43'}; - return DecryptName<0xC9712D676B5B3943ULL>(source); + const auto source = CRYPT_NAME("angeling", 0xC9712D676B5B3943ULL); + return DecryptName<0xC9712D676B5B3943ULL>(source.data); } case JT_DR_EGGRING: { - const char source[] = {'\xCB', '\x7B', '\x56', '\x82', '\xA0', '\xAE', '\x1B', '\xFC', '\xC1', '\x6E', '\x09'}; - return DecryptName<0x9569C9C7E70909AFULL>(source); + const auto source = CRYPT_NAME("dr_eggring", 0x9569C9C7E70909AFULL); + return DecryptName<0x9569C9C7E70909AFULL>(source.data); } case JT_CHOCO: { - const char source[] = {'\xB0', '\x51', '\x00', '\x72', '\xC6', '\x1F'}; - return DecryptName<0xB19D1FA9116F39D3ULL>(source); + const auto source = CRYPT_NAME("choco", 0xB19D1FA9116F39D3ULL); + return DecryptName<0xB19D1FA9116F39D3ULL>(source.data); } case JT_AM_MUT: { - const char source[] = {'\xF8', '\x54', '\xA2', '\x5C', '\x20', '\xCF', '\x91'}; - return DecryptName<0x4191BB5531FD3999ULL>(source); + const auto source = CRYPT_NAME("am_mut", 0x4191BB5531FD3999ULL); + return DecryptName<0x4191BB5531FD3999ULL>(source.data); } case JT_HYEGUN: { - const char source[] = {'\x33', '\xCE', '\x04', '\x3E', '\x3A', '\x3F', '\x15'}; - return DecryptName<0xF715514F5961B75BULL>(source); + const auto source = CRYPT_NAME("hyegun", 0xF715514F5961B75BULL); + return DecryptName<0xF715514F5961B75BULL>(source.data); } case JT_DR_LUNATIC: { - const char source[] = {'\xA5', '\xEB', '\x92', '\x89', '\xF4', '\x43', '\x24', '\xAD', '\xA8', '\xFA', '\xCD'}; - return DecryptName<0xD9452D81E5CD99C1ULL>(source); + const auto source = CRYPT_NAME("dr_lunatic", 0xD9452D81E5CD99C1ULL); + return DecryptName<0xD9452D81E5CD99C1ULL>(source.data); } case JT_NINE_TAIL: { - const char source[] = {'\x3B', '\x52', '\xEF', '\x92', '\x12', '\x9F', '\xCC', '\xC4', '\x39', '\x3B'}; - return DecryptName<0xADADEB4DF7813B55ULL>(source); + const auto source = CRYPT_NAME("nine_tail", 0xADADEB4DF7813B55ULL); + return DecryptName<0xADADEB4DF7813B55ULL>(source.data); } case JT_CAT_O_NINE_TAIL: { - const char source[] = {'\x3A', '\x6C', '\xBF', '\xF0', '\x12', '\x3C', '\xFB', '\xD8', '\x37', '\x68', '\x94', '\xDB', '\x1C', '\x0A', '\xF9', '\xB1'}; - return DecryptName<0xB195637DAFCB0D59ULL>(source); + const auto source = CRYPT_NAME("cat_o_nine_tail", 0xB195637DAFCB0D59ULL); + return DecryptName<0xB195637DAFCB0D59ULL>(source.data); } case JT_DIABOLIC2: { - const char source[] = {'\x09', '\xD6', '\xB4', '\x45', '\x84', '\x25', '\xCE', '\xB4', '\x5F', '\xBF'}; - return DecryptName<0xD7A749EB27D5BF6DULL>(source); + const auto source = CRYPT_NAME("diabolic2", 0xD7A749EB27D5BF6DULL); + return DecryptName<0xD7A749EB27D5BF6DULL>(source.data); } case JT_DELETER_2: { - const char source[] = {'\x59', '\x18', '\x39', '\x44', '\xB5', '\x10', '\xEB', '\x3A', '\x0F', '\x7D'}; - return DecryptName<0x659975C121557D3DULL>(source); + const auto source = CRYPT_NAME("deleter_2", 0x659975C121557D3DULL); + return DecryptName<0x659975C121557D3DULL>(source.data); } case JT_TEDDY_BEAR: { - const char source[] = {'\x2D', '\x1A', '\xC3', '\xC5', '\x6E', '\x9A', '\x97', '\xDA', '\x38', '\x0D', '\xA7'}; - return DecryptName<0xBFF5C517A1A77F59ULL>(source); + const auto source = CRYPT_NAME("teddy_bear", 0xBFF5C517A1A77F59ULL); + return DecryptName<0xBFF5C517A1A77F59ULL>(source.data); } case JT_GREMLIN: { - const char source[] = {'\x40', '\xD7', '\xF6', '\xF2', '\x6D', '\x3A', '\x0F', '\xAD'}; - return DecryptName<0xAD6153019F93A527ULL>(source); + const auto source = CRYPT_NAME("gremlin", 0xAD6153019F93A527ULL); + return DecryptName<0xAD6153019F93A527ULL>(source.data); } case JT_SCATLETON: { - const char source[] = {'\x0C', '\x38', '\x14', '\xD1', '\xCB', '\x90', '\x95', '\xEA', '\x11', '\x5B'}; - return DecryptName<0x85E1F5A7A5755B7FULL>(source); + const auto source = CRYPT_NAME("scatleton", 0x85E1F5A7A5755B7FULL); + return DecryptName<0x85E1F5A7A5755B7FULL>(source.data); } case JT_MUMMY: { - const char source[] = {'\x30', '\x9E', '\x1E', '\x24', '\xE2', '\x49'}; - return DecryptName<0x0F61499B4973EB5DULL>(source); + const auto source = CRYPT_NAME("mummy", 0x0F61499B4973EB5DULL); + return DecryptName<0x0F61499B4973EB5DULL>(source.data); } case JT_WILOW: { - const char source[] = {'\x26', '\x9E', '\x37', '\x18', '\xEA', '\xA1'}; - return DecryptName<0xB127A19D775BF751ULL>(source); + const auto source = CRYPT_NAME("wilow", 0xB127A19D775BF751ULL); + return DecryptName<0xB127A19D775BF751ULL>(source.data); } case JT_ROWEEN: { - const char source[] = {'\xBB', '\x6E', '\x9A', '\x8A', '\x82', '\x07', '\x1F'}; - return DecryptName<0xA31F69E7EFED01C9ULL>(source); + const auto source = CRYPT_NAME("roween", 0xA31F69E7EFED01C9ULL); + return DecryptName<0xA31F69E7EFED01C9ULL>(source.data); } case JT_HODREMLIN: { - const char source[] = {'\x03', '\x24', '\xDF', '\x73', '\xE2', '\x02', '\xC5', '\xDE', '\x05', '\x4B'}; - return DecryptName<0xB7A96F8701BB4B6BULL>(source); + const auto source = CRYPT_NAME("hodremlin", 0xB7A96F8701BB4B6BULL); + return DecryptName<0xB7A96F8701BB4B6BULL>(source.data); } case JT_METALLER: { - const char source[] = {'\x2C', '\xB4', '\x95', '\x82', '\x07', '\x25', '\xEC', '\x45', '\x41'}; - return DecryptName<0x3789496BE3E1D141ULL>(source); + const auto source = CRYPT_NAME("metaller", 0x3789496BE3E1D141ULL); + return DecryptName<0x3789496BE3E1D141ULL>(source.data); } case JT_ANCIENT_MUMMY: { - const char source[] = {'\x76', '\xB7', '\x50', '\xC0', '\x1C', '\x89', '\xE3', '\x50', '\x7A', '\xAC', '\x5E', '\xC4', '\x00', '\xE7'}; - return DecryptName<0x0F97E779A933D917ULL>(source); + const auto source = CRYPT_NAME("ancient_mummy", 0x0F97E779A933D917ULL); + return DecryptName<0x0F97E779A933D917ULL>(source.data); } case JT_XM_TEDDY_BEAR: { - const char source[] = {'\x0B', '\x4A', '\x12', '\x39', '\x9C', '\x0B', '\x61', '\xA8', '\x2C', '\x45', '\x28', '\x2C', '\x8B', '\x6F'}; - return DecryptName<0xD1056FF94D4D2773ULL>(source); + const auto source = CRYPT_NAME("xm_teddy_bear", 0xD1056FF94D4D2773ULL); + return DecryptName<0xD1056FF94D4D2773ULL>(source.data); } case JT_SWEETS_DROPS: { - const char source[] = {'\x98', '\x28', '\x6C', '\x56', '\x0B', '\xD2', '\x6E', '\x27', '\x99', '\x30', '\x79', '\x40', '\x7F'}; - return DecryptName<0x4331A17F33095FEBULL>(source); + const auto source = CRYPT_NAME("sweets_drops", 0x4331A17F33095FEBULL); + return DecryptName<0x4331A17F33095FEBULL>(source.data); } case JT_MOONLIGHT: { - const char source[] = {'\xA6', '\x82', '\xDC', '\x45', '\xEB', '\x58', '\x2A', '\x2D', '\xBF', '\xED'}; - return DecryptName<0x454D31872BB3EDCBULL>(source); + const auto source = CRYPT_NAME("moonlight", 0x454D31872BB3EDCBULL); + return DecryptName<0x454D31872BB3EDCBULL>(source.data); } case JT_PHREEONI: { - const char source[] = {'\x71', '\x65', '\x35', '\x38', '\x88', '\xE2', '\x9B', '\xE8', '\x01'}; - return DecryptName<0x81F58DED5D470D01ULL>(source); + const auto source = CRYPT_NAME("phreeoni", 0x81F58DED5D470D01ULL); + return DecryptName<0x81F58DED5D470D01ULL>(source.data); } case JT_SKELION: { - const char source[] = {'\x06', '\x54', '\x04', '\xC7', '\x46', '\x1E', '\x89', '\x5D'}; - return DecryptName<0x5DE7712FAB613F75ULL>(source); + const auto source = CRYPT_NAME("skelion", 0x5DE7712FAB613F75ULL); + return DecryptName<0x5DE7712FAB613F75ULL>(source.data); } case JT_POURING: { - const char source[] = {'\xE1', '\x04', '\x1E', '\x6D', '\xEA', '\xA5', '\xA8', '\x41'}; - return DecryptName<0x41CFCB831F6B6B91ULL>(source); + const auto source = CRYPT_NAME("pouring", 0x41CFCB831F6B6B91ULL); + return DecryptName<0x41CFCB831F6B6B91ULL>(source.data); } case JT_MOONLIGHT2: { - const char source[] = {'\x5E', '\x0C', '\x3A', '\x9F', '\x45', '\x5C', '\xB4', '\x21', '\x47', '\x63'}; - return DecryptName<0x49D33529F1556333ULL>(source); + const auto source = CRYPT_NAME("moonlight", 0x49D33529F1556333ULL); + return DecryptName<0x49D33529F1556333ULL>(source.data); } case JT_PHREEONI2: { - const char source[] = {'\xC5', '\xE7', '\x33', '\x40', '\x76', '\x92', '\x41', '\x10', '\xB5'}; - return DecryptName<0x792FFD1325418FB5ULL>(source); + const auto source = CRYPT_NAME("phreeoni", 0x792FFD1325418FB5ULL); + return DecryptName<0x792FFD1325418FB5ULL>(source.data); } case JT_BACSOJIN2: { - const char source[] = {'\xDD', '\x08', '\x80', '\xBE', '\xEA', '\xED', '\x36', '\x9F', '\x8D', '\x69'}; - return DecryptName<0xF15F8785CDE369BFULL>(source); + const auto source = CRYPT_NAME("bacsojin2", 0xF15F8785CDE369BFULL); + return DecryptName<0xF15F8785CDE369BFULL>(source.data); } case JT_ORK_HERO2: { - const char source[] = {'\x16', '\xD7', '\xCC', '\x26', '\xBF', '\x6A', '\x6D', '\xAC', '\x6B', '\x85'}; - return DecryptName<0xE33F2FF779878559ULL>(source); + const auto source = CRYPT_NAME("ORK_HERO2", 0xE33F2FF779878559ULL); + return DecryptName<0xE33F2FF779878559ULL>(source.data); } case JT_ALIZA: { - const char source[] = {'\xCA', '\xD1', '\x3E', '\xD7', '\xA0', '\xDD'}; - return DecryptName<0x1767DDE18D779D8BULL>(source); + const auto source = CRYPT_NAME("ALIZA", 0x1767DDE18D779D8BULL); + return DecryptName<0x1767DDE18D779D8BULL>(source.data); } case JT_ALICEL: { - const char source[] = {'\xA0', '\xCF', '\x98', '\xAE', '\x54', '\xCD', '\xBB'}; - return DecryptName<0xC1BB8111EDD183E1ULL>(source); + const auto source = CRYPT_NAME("ALICEL", 0xC1BB8111EDD183E1ULL); + return DecryptName<0xC1BB8111EDD183E1ULL>(source.data); } case JT_ALIOT: { - const char source[] = {'\xD6', '\x85', '\x80', '\xD4', '\x99', '\xBB'}; - return DecryptName<0xC5B1BBCD9BC9C997ULL>(source); + const auto source = CRYPT_NAME("ALIOT", 0xC5B1BBCD9BC9C997ULL); + return DecryptName<0xC5B1BBCD9BC9C997ULL>(source.data); } case 20338: case JT_NIGHTMARE_TERROR_H: { - const char source[] = {'\x5F', '\x90', '\xB4', '\x91', '\x69', '\x22', '\xAA', '\x73', '\x54', '\xA6', '\xA7', '\x9C', '\x6F', '\x3D', '\xA4', '\x73', '\x6E', '\x94', '\xB9', '\xF9'}; - return DecryptName<0x01CB4F1DF9D3F931ULL>(source); + const auto source = CRYPT_NAME("nightmare_terror_mj", 0x01CB4F1DF9D3F931ULL); + return DecryptName<0x01CB4F1DF9D3F931ULL>(source.data); } case JT_WANDER_MAN_H: { - const char source[] = {'\xA0', '\xF4', '\x71', '\xFF', '\x34', '\x37', '\xD8', '\x66', '\xB6', '\xFB', '\x40', '\xF6', '\x3B', '\x45'}; - return DecryptName<0x0B8745519B1F95D7ULL>(source); + const auto source = CRYPT_NAME("wander_man_mj", 0x0B8745519B1F95D7ULL); + return DecryptName<0x0B8745519B1F95D7ULL>(source.data); } case JT_GLOOMUNDERNIGHT2: { - const char source[] = {'\xE8', '\x35', '\x0E', '\x84', '\xD8', '\x6C', '\x6D', '\xA3', '\xEA', '\x2B', '\x0F', '\x82', '\xD2', '\x71', '\x77', '\xF5', '\x8F'}; - return DecryptName<0xC70319B5EB61598FULL>(source); + const auto source = CRYPT_NAME("gloomundernight2", 0xC70319B5EB61598FULL); + return DecryptName<0xC70319B5EB61598FULL>(source.data); } case JT_EP17_2_CHILD_ADMIN1: { - const char source[] = {'\xFC', '\xB5', '\xEA', '\x73', '\x13', '\x1A', '\x7A', '\x43', '\xF2', '\xB4', '\xED', '\x40', '\x15', '\x45'}; - return DecryptName<0x271B45771F83DD9FULL>(source); + const auto source = CRYPT_NAME("child_admin_b", 0x271B45771F83DD9FULL); + return DecryptName<0x271B45771F83DD9FULL>(source.data); } case JT_EP17_2_CHILD_ADMIN2: { - const char source[] = {'\x74', '\x39', '\x88', '\x2D', '\x5D', '\x9C', '\xE2', '\xE3', '\x7A', '\x38', '\x8F', '\x1E', '\x58', '\xC3'}; - return DecryptName<0x8783C33941E15117ULL>(source); + const auto source = CRYPT_NAME("child_admin_a", 0x8783C33941E15117ULL); + return DecryptName<0x8783C33941E15117ULL>(source.data); } case JT_WANDERING_DUCK: { - const char source[] = {'\xFC', '\xEE', '\xC3', '\xC9', '\xF6', '\xDF', '\xEE', '\x9B', '\xEC', '\xF0', '\xC9', '\xD8', '\xF0', '\xC6', '\xA7'}; - return DecryptName<0xD5A78DB38D8DAFABULL>(source); + const auto source = CRYPT_NAME("WANDERING_DUCK", 0xD5A78DB38D8DAFABULL); + return DecryptName<0xD5A78DB38D8DAFABULL>(source.data); } case JT_KIEL_D_01_2: { - const char source[] = {'\x7F', '\x2A', '\x31', '\xF0', '\xF6', '\x2C', '\xFC', '\x6F', '\x0F'}; - return DecryptName<0x0399459DAF454F0FULL>(source); + const auto source = CRYPT_NAME("pet_kiel", 0x0399459DAF454F0FULL); + return DecryptName<0x0399459DAF454F0FULL>(source.data); } case 21291: { - const char source[] = {'\x10', '\x8E', '\xCB', '\xBE', '\xBA', '\xBC', '\xDF', '\x88', '\x73'}; - return DecryptName<0xFFABE3D5D1BBEF73ULL>(source); + const auto source = CRYPT_NAME("capoo_tw", 0xFFABE3D5D1BBEF73ULL); + return DecryptName<0xFFABE3D5D1BBEF73ULL>(source.data); } case JT_DESERT_WOLF: { - const char source[] = {'\x91', '\x7C', '\x78', '\x0C', '\xB5', '\xF3', '\xC8', '\xF2', '\x9A', '\x75', '\x6D', '\x49'}; - return DecryptName<0xA597A7E7492B39D5ULL>(source); + const auto source = CRYPT_NAME("DESERT_WOLF", 0xA597A7E7492B39D5ULL); + return DecryptName<0xA597A7E7492B39D5ULL>(source.data); } case JT_DARK_PRIEST: { - const char source[] = {'\xC9', '\xFC', '\xE9', '\x28', '\xE8', '\x69', '\xE9', '\x18', '\xC8', '\xEE', '\xEF', '\x63'}; - return DecryptName<0x51BB39B763BBBD8DULL>(source); + const auto source = CRYPT_NAME("DARK_PRIEST", 0x51BB39B763BBBD8DULL); + return DecryptName<0x51BB39B763BBBD8DULL>(source.data); } case JT_FIRE_GOLEM: { - const char source[] = {'\xA9', '\x64', '\x05', '\x48', '\x9A', '\x96', '\xAC', '\xCB', '\xAA', '\x60', '\x57'}; - return DecryptName<0x87E3D1C50D572DEFULL>(source); + const auto source = CRYPT_NAME("FIRE_GOLEM", 0x87E3D1C50D572DEFULL); + return DecryptName<0x87E3D1C50D572DEFULL>(source.data); } case JT_ILL_BAPHOMET_J: { - const char source[] = {'\xB6', '\xAF', '\x11', '\x5C', '\xE5', '\xEE', '\xF3', '\x77', '\xB0', '\xAE', '\x18', '\x57', '\xF8', '\xE5', '\xA3'}; - return DecryptName<0x3FA3AFA7035DE3FFULL>(source); + const auto source = CRYPT_NAME("ILL_BAPHOMET_J", 0x3FA3AFA7035DE3FFULL); + return DecryptName<0x3FA3AFA7035DE3FFULL>(source.data); } case JT_BAPHOMET2: { - const char source[] = {'\x1B', '\xC6', '\x53', '\x35', '\x1A', '\x86', '\x62', '\x8F', '\x6B', '\x87'}; - return DecryptName<0xDB27CB557D038759ULL>(source); + const auto source = CRYPT_NAME("BAPHOMET2", 0xDB27CB557D038759ULL); + return DecryptName<0xDB27CB557D038759ULL>(source.data); } case JT_DARK_ILLUSION2: { - const char source[] = {'\x35', '\xC2', '\x39', '\x40', '\x4E', '\x46', '\x11', '\x31', '\x24', '\xD0', '\x22', '\x44', '\x5F', '\x3D', '\x5D'}; - return DecryptName<0x7D5D0F110B6B8371ULL>(source); + const auto source = CRYPT_NAME("DARK_ILLUSION2", 0x7D5D0F110B6B8371ULL); + return DecryptName<0x7D5D0F110B6B8371ULL>(source.data); } case JT_WILD_ROSE3: { - const char source[] = {'\x1E', '\x24', '\x33', '\xA7', '\x98', '\x53', '\x06', '\x42', '\x0C', '\x5E', '\x7F'}; - return DecryptName<0x114901C7E37F6D49ULL>(source); + const auto source = CRYPT_NAME("WILD_ROSE3", 0x114901C7E37F6D49ULL); + return DecryptName<0x114901C7E37F6D49ULL>(source.data); } case JT_BLUEMOON_LOLI_RURI2: { - const char source[] = {'\x13', '\xB9', '\x9A', '\x0C', '\xB2', '\x58', '\xCE', '\x91', '\x0E', '\xB9', '\x80', '\x05', '\xB6', '\x48', '\xD3', '\x8A', '\x03', '\xBC', '\xFD', '\x49'}; - return DecryptName<0xDF8117FF49CFF551ULL>(source); + const auto source = CRYPT_NAME("BLUEMOON_LOLI_RURI2", 0xDF8117FF49CFF551ULL); + return DecryptName<0xDF8117FF49CFF551ULL>(source.data); } case JT_FARMILIAR2: { - const char source[] = {'\x7B', '\x00', '\xD9', '\x84', '\xB0', '\x57', '\x8C', '\xEC', '\x6F', '\x73', '\x8B'}; - return DecryptName<0xADC51BF9C98B413DULL>(source); + const auto source = CRYPT_NAME("FARMILIAR2", 0xADC51BF9C98B413DULL); + return DecryptName<0xADC51BF9C98B413DULL>(source.data); } case JT_FARMILIAR: { - const char source[] = {'\x07', '\x7C', '\x05', '\x38', '\x70', '\xD3', '\x04', '\x26', '\x13', '\x3D'}; - return DecryptName<0x674D9F3975573D41ULL>(source); + const auto source = CRYPT_NAME("FARMILIAR", 0x674D9F3975573D41ULL); + return DecryptName<0x674D9F3975573D41ULL>(source.data); } case JT_CWHITEKNIGHT: { - const char source[] = {'\x12', '\xFA', '\xB5', '\x62', '\x1B', '\x76', '\x94', '\x25', '\x18', '\xEA', '\xB5', '\x7F', '\x4F'}; - return DecryptName<0x6BDF334F2BFDAD51ULL>(source); + const auto source = CRYPT_NAME("CWHITEKNIGHT", 0x6BDF334F2BFDAD51ULL); + return DecryptName<0x6BDF334F2BFDAD51ULL>(source.data); } case JT_KNIGHT_OF_ABYSS2: { - const char source[] = {'\x84', '\x95', '\x98', '\x52', '\xD1', '\x7B', '\x30', '\x5C', '\x89', '\x84', '\x90', '\x57', '\xC0', '\x7C', '\x3C', '\x21', '\xCF'}; - return DecryptName<0x136F2F9915D1DBCFULL>(source); + const auto source = CRYPT_NAME("KNIGHT_OF_ABYSS2", 0x136F2F9915D1DBCFULL); + return DecryptName<0x136F2F9915D1DBCFULL>(source.data); } case JT_GH_WHITEKNIGHT: { - const char source[] = {'\x6C', '\x9F', '\x16', '\x78', '\x47', '\x98', '\x77', '\x4E', '\x60', '\x99', '\x00', '\x68', '\x47', '\x85', '\x23'}; - return DecryptName<0x0B23D10F2F49D72BULL>(source); + const auto source = CRYPT_NAME("GH_WHITEKNIGHT", 0x0B23D10F2F49D72BULL); + return DecryptName<0x0B23D10F2F49D72BULL>(source.data); } case JT_EDDGA3: { - const char source[] = {'\xA6', '\x91', '\x17', '\xB0', '\xE4', '\x34', '\xE3'}; - return DecryptName<0xB3E307A5F753D5E3ULL>(source); + const auto source = CRYPT_NAME("EDDGA3", 0xB3E307A5F753D5E3ULL); + return DecryptName<0xB3E307A5F753D5E3ULL>(source.data); } case 23009: { - const char source[] = {'\xB5', '\x32', '\x67', '\x68', '\x14', '\x24', '\x72', '\x4B', '\xBA', '\x2B', '\x76', '\x7D', '\x4D'}; - return DecryptName<0x192D654D29337BE5ULL>(source); + const auto source = CRYPT_NAME("PITAYA_R_PET", 0x192D654D29337BE5ULL); + return DecryptName<0x192D654D29337BE5ULL>(source.data); } case JT_LARVA_VIOLET: { - const char source[] = {'\x4D', '\x34', '\xAF', '\x8F', '\x6E', '\xE2', '\xF9', '\xFE', '\x4E', '\x39', '\xB8', '\x8D', '\x2F'}; - return DecryptName<0xB7AFBD2FD9FD7501ULL>(source); + const auto source = CRYPT_NAME("LARVA_VIOLET", 0xB7AFBD2FD9FD7501ULL); + return DecryptName<0xB7AFBD2FD9FD7501ULL>(source.data); } case JT_EP20_COPO: { - const char source[] = {'\xB8', '\x25', '\x5D', '\x9F', '\xB6', '\x76', '\x86', '\x09', '\xB2', '\x55'}; - return DecryptName<0x79E915E9AF6F55DDULL>(source); + const auto source = CRYPT_NAME("ep20_copo", 0x79E915E9AF6F55DDULL); + return DecryptName<0x79E915E9AF6F55DDULL>(source.data); } case JT_EP20_ICEWIND1: { - const char source[] = {'\x40', '\xE1', '\x35', '\x93', '\xBE', '\x68', '\x50', '\x0E', '\x52', '\xF8', '\x69', '\xC7', '\xD0', '\x01'}; - return DecryptName<0x6B3301E1A3079125ULL>(source); + const auto source = CRYPT_NAME("ep20_icewind1", 0x6B3301E1A3079125ULL); + return DecryptName<0x6B3301E1A3079125ULL>(source.data); } case JT_EP20_ICEWIND2: { - const char source[] = {'\xEC', '\x4D', '\x5F', '\xD5', '\xF8', '\x68', '\x44', '\x4A', '\xFE', '\x54', '\x03', '\x81', '\x95', '\x01'}; - return DecryptName<0x2F2701A7E56D3D89ULL>(source); + const auto source = CRYPT_NAME("ep20_icewind2", 0x2F2701A7E56D3D89ULL); + return DecryptName<0x2F2701A7E56D3D89ULL>(source.data); } case JT_DARK_LORD2: { - const char source[] = {'\x27', '\x78', '\x2F', '\xEA', '\x06', '\xF9', '\xD0', '\x91', '\x27', '\x0B', '\x7D'}; - return DecryptName<0xC39FB559A17D3963ULL>(source); + const auto source = CRYPT_NAME("DARK_LORD2", 0xC39FB559A17D3963ULL); + return DecryptName<0xC39FB559A17D3963ULL>(source.data); } case 23215: { - const char source[] = {'\xFF', '\xE8', '\x91', '\x76', '\x4E', '\x28', '\xE8', '\x33', '\xF0', '\xF1', '\x80', '\x63', '\x17'}; - return DecryptName<0x71B7691737C5A1AFULL>(source); + const auto source = CRYPT_NAME("PITAYA_B_PET", 0x71B7691737C5A1AFULL); + return DecryptName<0x71B7691737C5A1AFULL>(source.data); } case 23216: { - const char source[] = {'\xE3', '\x00', '\xCC', '\xE2', '\xCB', '\x68', '\x45', '\x48', '\xF4', '\x1F', '\xDA', '\xF7', '\x85'}; - return DecryptName<0x07112F85A39F4FABULL>(source); + const auto source = CRYPT_NAME("HOSANGTO_PET", 0x07112F85A39F4FABULL); + return DecryptName<0x07112F85A39F4FABULL>(source.data); } case 23233: { - const char source[] = {'\x02', '\x82', '\xD4', '\xAC', '\x6A', '\xAE', '\xB3', '\x00', '\x03', '\xF1'}; - return DecryptName<0x45E3F103CBB5F157ULL>(source); + const auto source = CRYPT_NAME("Usagi_PET", 0x45E3F103CBB5F157ULL); + return DecryptName<0x45E3F103CBB5F157ULL>(source.data); } case 23234: { - const char source[] = {'\xA5', '\xEE', '\x8E', '\x96', '\x4A', '\x62', '\x3F', '\xD6', '\xA1', '\x87'}; - return DecryptName<0x936F3D2FFDFD87F5ULL>(source); + const auto source = CRYPT_NAME("Piske_PET", 0x936F3D2FFDFD87F5ULL); + return DecryptName<0x936F3D2FFDFD87F5ULL>(source.data); } case JT_VR_CHAO: { - const char source[] = {'\x89', '\x15', '\xF2', '\x24', '\x57', '\x38', '\x7C', '\x2D'}; - return DecryptName<0x2D33791F67AD47DFULL>(source); + const auto source = CRYPT_NAME("VR_CHAO", 0x2D33791F67AD47DFULL); + return DecryptName<0x2D33791F67AD47DFULL>(source.data); } case JT_EP21_ICESEAHORSE: { - const char source[] = {'\xBA', '\xEB', '\x0D', '\xC8', '\xDA', '\x70', '\x24', '\xC2', '\xAC', '\xFE', '\x5E', '\x91', '\xEA', '\x6B', '\x34', '\xC2', '\xDF'}; - return DecryptName<0xA7471985F93F9BDFULL>(source); + const auto source = CRYPT_NAME("ep21_iceseahorse", 0xA7471985F93F9BDFULL); + return DecryptName<0xA7471985F93F9BDFULL>(source.data); } case JT_CLB_SS_FC: { - const char source[] = {'\x14', '\xA3', '\x93', '\xEA', '\xF8', '\x2C', '\xA2', '\x19', '\x14', '\xEF'}; - return DecryptName<0x5FFD7FABB5D1EF57ULL>(source); + const auto source = CRYPT_NAME("CLB_SS_FC", 0x5FFD7FABB5D1EF57ULL); + return DecryptName<0x5FFD7FABB5D1EF57ULL>(source.data); } case JT_CLB_SS_TZ: { - const char source[] = {'\x92', '\x2D', '\xB3', '\xD6', '\x3C', '\x02', '\xBA', '\x87', '\x8B', '\x61'}; - return DecryptName<0xD3E5516F89F161D1ULL>(source); + const auto source = CRYPT_NAME("CLB_SS_TZ", 0xD3E5516F89F161D1ULL); + return DecryptName<0xD3E5516F89F161D1ULL>(source.data); } case JT_HORNET: { - const char source[] = {'\xC5', '\x7C', '\x0D', '\x7D', '\x04', '\x91', '\x35'}; - return DecryptName<0xF535E561137F138DULL>(source); + const auto source = CRYPT_NAME("Hornet", 0xF535E561137F138DULL); + return DecryptName<0xF535E561137F138DULL>(source.data); } case JT_GIANT_HONET2: { - const char source[] = {'\x4A', '\x12', '\x28', '\xCD', '\xEF', '\x4E', '\xD5', '\xC6', '\x43', '\x1E', '\x3D', '\x83'}; - return DecryptName<0x899D11BB83695B0DULL>(source); + const auto source = CRYPT_NAME("GIANT_HONET", 0x899D11BB83695B0DULL); + return DecryptName<0x899D11BB83695B0DULL>(source.data); } case JT_MISTRESS3: { - const char source[] = {'\xB8', '\x6C', '\x00', '\xBD', '\x85', '\x60', '\xD4', '\x78', '\xC7', '\x25'}; - return DecryptName<0x2B8725D7E95325F5ULL>(source); + const auto source = CRYPT_NAME("MISTRESS2", 0x2B8725D7E95325F5ULL); + return DecryptName<0x2B8725D7E95325F5ULL>(source.data); } case JT_CLOCK: { - const char source[] = {'\xFE', '\xF1', '\x54', '\x84', '\x66', '\x83'}; - return DecryptName<0x7989830DE73B9DBDULL>(source); + const auto source = CRYPT_NAME("Clock", 0x7989830DE73B9DBDULL); + return DecryptName<0x7989830DE73B9DBDULL>(source.data); } case JT_C_TOWER_MANAGER2: { - const char source[] = {'\x28', '\x54', '\xF1', '\xAA', '\xF0', '\xB8', '\xDF', '\xE2', '\x26', '\x6A', '\xCB', '\xA4', '\xE0', '\xB8', '\xDF', '\xBD'}; - return DecryptName<0xBDADDD87C5A50B6BULL>(source); + const auto source = CRYPT_NAME("C_Tower_Manager", 0xBDADDD87C5A50B6BULL); + return DecryptName<0xBDADDD87C5A50B6BULL>(source.data); } case JT_SKEGGIOLD: { - const char source[] = {'\x18', '\x98', '\x32', '\xC2', '\xB6', '\x24', '\xB4', '\x8B', '\x0F', '\xD3'}; - return DecryptName<0xC7FB6DF18577D34BULL>(source); + const auto source = CRYPT_NAME("SKEGGIOLD", 0xC7FB6DF18577D34BULL); + return DecryptName<0xC7FB6DF18577D34BULL>(source.data); } case JT_ANGELGOLT3: { - const char source[] = {'\xBC', '\x1F', '\xF2', '\x1C', '\x4D', '\x04', '\x70', '\xF1', '\xA9', '\x51'}; - return DecryptName<0xBD3F430159B551FDULL>(source); + const auto source = CRYPT_NAME("ANGELGOLT", 0xBD3F430159B551FDULL); + return DecryptName<0xBD3F430159B551FDULL>(source.data); } case 23434: { - const char source[] = {'\x45', '\xFC', '\x6C', '\x1C', '\xD3', '\x34', '\x12', '\x65', '\x01'}; - return DecryptName<0x2B477F9B5B39B301ULL>(source); + const auto source = CRYPT_NAME("DOUGHKUN", 0x2B477F9B5B39B301ULL); + return DecryptName<0x2B477F9B5B39B301ULL>(source.data); } case 23435: { - const char source[] = {'\xD1', '\x24', '\xEA', '\xF4', '\x3E', '\x6B', '\xC2', '\x0E', '\xC4', '\x24', '\xA7'}; - return DecryptName<0x5B832361BDA77197ULL>(source); + const auto source = CRYPT_NAME("FUMI_HAUSU", 0x5B832361BDA77197ULL); + return DecryptName<0x5B832361BDA77197ULL>(source.data); } case JT_TIMEHOLDER3: { - const char source[] = {'\x2D', '\xA2', '\x6C', '\xDA', '\x75', '\xFC', '\xB9', '\x49', '\x3C', '\xB9', '\x13', '\x9F'}; - return DecryptName<0x0DF5B33D9F21EB79ULL>(source); + const auto source = CRYPT_NAME("TIMEHOLDER2", 0x0DF5B33D9F21EB79ULL); + return DecryptName<0x0DF5B33D9F21EB79ULL>(source.data); } default: { - const char source[] = {'\xAF', '\x32', '\x51', '\xF4', '\xE3', '\xEE', '\xE7'}; - return DecryptName<0x01E7898D9D235DDFULL>(source); + const auto source = CRYPT_NAME("poring", 0x01E7898D9D235DDFULL); + return DecryptName<0x01E7898D9D235DDFULL>(source.data); } } } diff --git a/Source/Contents/Skills/SkillActionAlitea.cpp b/Source/Contents/Skills/SkillActionAlitea.cpp index 92b4cd8d5..48f7aa5ae 100644 --- a/Source/Contents/Skills/SkillActionAlitea.cpp +++ b/Source/Contents/Skills/SkillActionAlitea.cpp @@ -441,8 +441,8 @@ void CSkillAction_ThunderingExpand::PlayThunderEffect(CGameActor* source) { if (source) { EffectLists* effects = g_effectMgr; effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] { - const std::uint8_t bytes[] = {0xCD, 0x65, 0x5A, 0xCF, 0x27, 0x9E, 0x7D, 0x20, 0xD7, 0x6A, 0x70, 0xC0, 0x37, 0x8F, 0x6E, 0x2A, - 0xD2, 0x52, 0x56, 0xA1}; + constexpr std::array bytesArray = CRYPT_NAME("thundering_attack_y", 0x490FFB43A12F0DB9ULL); + const std::uint8_t (&bytes)[20] = bytesArray._Elems; thread_local EncryptedName name(bytes); return name.Text(); }()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0); @@ -743,7 +743,8 @@ void CSkillAction_AT_PULSE_OF_MADNESS::OnSkillEffect(int level, CGameActor* sour } g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] { - const std::uint8_t bytes[] = {0x57, 0x74, 0x6B, 0x1E, 0x66, 0x9A, 0x9C, 0x49, 0x78, 0x6C, 0x66, 0x09, 0x6D, 0xA0, 0x80, 0x5C, 0x27}; + constexpr std::array bytesArray = CRYPT_NAME("pulse_of_madness", 0x2FF3C5036D070127ULL); + const std::uint8_t (&bytes)[17] = bytesArray._Elems; thread_local EncryptedName name(bytes); return name.Text(); }()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0); @@ -1088,9 +1089,8 @@ void CSkillObjectAction_AT_GLACIER_MONOLITH::OnSkillObjectRemove(CRenderObject* EffectLists* effects = g_effectMgr; effects->Retire(object->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] { - const char bytes[] = {'\x48', '\xF3', '\xD2', '\xB8', '\x86', '\xAC', '\x65', '\xC4', '\x42', '\xF0', '\xDD', '\xB4', '\x83', '\xA0', '\x63', '\xF3', - '\x70', '\xF3', '\xDC', '\xB4', '\x9F', '\xC9'}; - thread_local EncryptedName name(bytes); + const auto bytes = CRYPT_NAME("glacier_monolith_loop", 0x9B17C9EFDBB39F2FULL); + thread_local EncryptedName name(bytes.data); return name.Text(); }())); effects = g_effectMgr; @@ -1103,15 +1103,14 @@ void CSkillObjectAction_AT_GLACIER_MONOLITH::OnSkillObjectRemove(CRenderObject* effects = g_effectMgr; effects->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId([] { - const char bytes[] = {'\x86', '\xF7', '\x92', '\x18', '\x84', '\xE2', '\x8D', '\x3E', '\x8C', '\xF4', '\x9D', '\x14', '\x81', '\xEE', '\x8B', '\x09', '\xBE', '\xFE', '\x9D', '\x1F', '\xED'}; - thread_local EncryptedName name(bytes); + const auto bytes = CRYPT_NAME("glacier_monolith_end", 0x61FF87ED7BF39BE1ULL); + thread_local EncryptedName name(bytes.data); return name.Text(); }()), object->render.position, 0, -1, 0, 0); effects = g_effectMgr; effects->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId([] { - const char bytes[] = {'\x98', '\xE9', '\x46', '\x6E', '\x0C', '\x5A', '\xEB', '\x22', '\x92', '\xEA', '\x49', '\x62', '\x09', '\x56', '\xED', '\x15', - '\xA0', '\xE0', '\x49', '\x69', '\x3A', '\x5D', '\xF6', '\x09', '\x8B', '\xEA', '\x4A', '\x0D'}; - thread_local EncryptedName name(bytes); + const auto bytes = CRYPT_NAME("glacier_monolith_end_bottom", 0x7D993F650D2785FFULL); + thread_local EncryptedName name(bytes.data); return name.Text(); }()), object->render.position, 0, -1, 0, 0); } diff --git a/Source/Contents/Skills/SkillActionDruid.cpp b/Source/Contents/Skills/SkillActionDruid.cpp index 13e083e18..f0ea21acb 100644 --- a/Source/Contents/Skills/SkillActionDruid.cpp +++ b/Source/Contents/Skills/SkillActionDruid.cpp @@ -555,7 +555,8 @@ void CSkillAction_DR_FLICKING_TONADO::OnSkillEffect(int level, CGameActor* sourc return; } - const std::uint8_t effectSource[] = {0x41, 0x6D, 0x6E, 0x0E, 0x68, 0xAC, 0x9D, 0x48, 0x78, 0x75, 0x68, 0x03, 0x62, 0xA1, 0x9C, 0x2F}; + constexpr std::array effectSourceArray = CRYPT_NAME("flicking_tonado", 0x2FF3C5036D070127ULL); + const std::uint8_t (&effectSource)[16] = effectSourceArray._Elems; thread_local EncryptedName effectName(effectSource); g_effectMgr->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0); @@ -695,15 +696,15 @@ int CEfstAction_GROUND_GROW::GetEffectId(int efstId, int argument4) { } const auto full = []() { - const char fullSource[] = {'\xAF', '\xC2', '\x49', '\xFB', '\xBB'}; - thread_local EncryptedName fullName(fullSource); + const auto fullSource = CRYPT_NAME("full", 0x078333BB9725B7C9ULL); + thread_local EncryptedName fullName(fullSource.data); return fullName.Text(); }; std::string suffix = step == 11 ? std::string(full()) : std::format("{:02}", step); return CEZ2STREffectMgr::GetInstance()->EffectId(std::string([] { - const char prefixSource[] = {'\xD2', '\x07', '\x0E', '\x2A', '\x93', '\x3F', '\x44', '\xE8', '\xC7', '\x1A', '\x16', '\x00', '\xFD'}; - thread_local EncryptedName prefixName(prefixSource); + const auto prefixSource = CRYPT_NAME("ground_grow_", 0x8F1B5BFD5F6175B5ULL); + thread_local EncryptedName prefixName(prefixSource.data); return prefixName.Text(); }()) + suffix); } @@ -1002,7 +1003,8 @@ void CSkillAction_DR_CUTTING_WIND::OnSkillDamage(int level, CGameActor* source, } g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] { - const std::uint8_t effectSource[] = {0xB0, 0x98, 0xE3, 0x61, 0x24, 0x35, 0xC2, 0xFE, 0xA4, 0x84, 0xF9, 0x71, 0x12, 0x33, 0xCC, 0xD5, 0xD3}; + constexpr std::array effectSourceArray = CRYPT_NAME("cutting_wind_hit", 0xA1A55B4D1597EDD3ULL); + const std::uint8_t (&effectSource)[17] = effectSourceArray._Elems; thread_local EncryptedName effectName(effectSource); return effectName.Text(); }()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0); @@ -1070,8 +1072,8 @@ void CSkillAction_DR_AROUND_FLOWER::OnSkillEffect(int level, CGameActor* source, return; } - const char effectSource[] = {'\xFA', '\xDF', '\x1A', '\xBA', '\xBF', '\x59', '\xB2', '\x0B', '\xF7', '\xC2', '\x02', '\xAA', '\xA3', '\x3D'}; - thread_local EncryptedName effectName(effectSource); + const auto effectSource = CRYPT_NAME("around_flower", 0x6DED3DD1CF75AD9BULL); + thread_local EncryptedName effectName(effectSource.data); EffectLists* effects = g_effectMgr; effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0); diff --git a/Source/Contents/Skills/SkillActionKarnos.cpp b/Source/Contents/Skills/SkillActionKarnos.cpp index 0b32243f4..bf7ec6270 100644 --- a/Source/Contents/Skills/SkillActionKarnos.cpp +++ b/Source/Contents/Skills/SkillActionKarnos.cpp @@ -234,7 +234,8 @@ void CSkillAction_KR_DOUBLE_SLASH::OnSkillEffect(int level, CGameActor* source, return; } - const std::uint8_t effectSource[] = {0x7B, 0x5E, 0xB8, 0x85, 0x81, 0x10, 0x32, 0x6E, 0x73, 0x50, 0xBE, 0x8F, 0xED}; + constexpr std::array effectSourceArray = CRYPT_NAME("double_slash", 0x1D6D75EDE7CD311FULL); + const std::uint8_t (&effectSource)[13] = effectSourceArray._Elems; thread_local EncryptedName effectName(effectSource); EffectLists* effects = g_effectMgr; effects->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0); @@ -269,7 +270,8 @@ void CSkillAction_KR_CLAW_WAVE::OnSkillCast(int level, CGameActor* source) { // OFFSET: 0x005B0CD0 // FUNCTION: fn_03347 void CSkillAction_KR_CLAW_WAVE::OnGroundSkillEffect(vector3d position, int argument2, int argument3) { - const std::uint8_t effectSource[] = {0xD0, 0x0B, 0xA2, 0x24, 0xA6, 0xEC, 0x54, 0x61, 0xD6, 0x67}; + constexpr std::array effectSourceArray = CRYPT_NAME("claw_wave", 0x17359BF953C367B3ULL); + const std::uint8_t (&effectSource)[10] = effectSourceArray._Elems; thread_local EncryptedName effectName(effectSource); g_effectMgr->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), position, 0, -1, 0, 0); } @@ -289,14 +291,16 @@ void CSkillAction_KR_EARTH_DRILL::OnSkillHit(int level, CGameActor* source, CGam EffectLists* effects = g_effectMgr; effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] { - const std::uint8_t effectSource[] = {0x72, 0x98, 0x3D, 0xCD, 0x93, 0xEA, 0x4B, 0xB7, 0x7E, 0x95, 0x23, 0xB9}; + constexpr std::array effectSourceArray = CRYPT_NAME("earth_drill", 0xC52FB5FBB94FF917ULL); + const std::uint8_t (&effectSource)[12] = effectSourceArray._Elems; thread_local EncryptedName effectName(effectSource); return effectName.Text(); }()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0); effects = g_effectMgr; effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] { - const std::uint8_t bottomSource[] = {0xA0, 0xAC, 0xF5, 0x81, 0xC9, 0xFC, 0x83, 0xE1, 0xAC, 0xA1, 0xEB, 0xAA, 0xC3, 0xCC, 0x93, 0xE7, 0xAA, 0xA0, 0x87}; + constexpr std::array bottomSourceArray = CRYPT_NAME("earth_drill_bottom", 0x93E7A3A1F587CDC5ULL); + const std::uint8_t (&bottomSource)[19] = bottomSourceArray._Elems; thread_local EncryptedName bottomName(bottomSource); return bottomName.Text(); }()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0); @@ -311,8 +315,8 @@ int CSkillAction_KR_EARTH_STAMP::GetSkillAttackMotion() { // OFFSET: 0x005B1250 // FUNCTION: fn_03351 void CSkillAction_KR_EARTH_STAMP::OnGroundSkillEffect(vector3d position, int argument2, int argument3) { - const char effectSource[] = {'\xB2', '\x2E', '\x71', '\xE1', '\xB1', '\xDA', '\xDC', '\x4B', '\xB6', '\x22', '\x73', '\x95'}; - thread_local EncryptedName effectName(effectSource); + const auto effectSource = CRYPT_NAME("earth_stamp", 0x3FAF85D995034FD7ULL); + thread_local EncryptedName effectName(effectSource.data); g_effectMgr->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), position, 0, -1, 0, 0); const char bottomSource[] = {'\xDC', '\x6C', '\x5D', '\xD5', '\x2B', '\xA4', '\x7C', '\x3D', '\xD8', '\x60', '\x5F', '\xFE', '\x21', '\x94', '\x7B', '\x3D', '\xD6', '\x60', '\x2F'}; @@ -525,7 +529,8 @@ void CSkillAction_KR_ICE_SPLASH::OnSkillEffect(int level, CGameActor* source, CG return; } - const std::uint8_t effectSource[] = {0x58, 0x3A, 0x4E, 0x5E, 0x12, 0xBD, 0x09, 0xEA, 0x42, 0x31, 0x2B}; + constexpr std::array effectSourceArray = CRYPT_NAME("ice_splash", 0x8B65CD61012B5931ULL); + const std::uint8_t (&effectSource)[11] = effectSourceArray._Elems; thread_local EncryptedName effectName(effectSource); g_effectMgr->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0); } diff --git a/Source/Contents/Sound/SoundConfiguration.cpp b/Source/Contents/Sound/SoundConfiguration.cpp index 3e473ee43..6e743dfd0 100644 --- a/Source/Contents/Sound/SoundConfiguration.cpp +++ b/Source/Contents/Sound/SoundConfiguration.cpp @@ -19,8 +19,8 @@ const char* DecryptText(const Byte (&source)[Length]) { // INLINED static const char* RenewSetupSubKey() { - const std::uint8_t source[] = {0x44, 0x96, 0x29, 0xCD, 0x8C, 0xD4, 0x5D, 0xA0, 0x4B, 0xBE, 0x3D, 0xD8, 0x8D, 0xDC, 0x5B, 0xBC, 0x37, - 0xAA, 0x20, 0xDF, 0x8F, 0xE9, 0x7D, 0xA0, 0x79, 0x9C, 0x38, 0xEA, 0x9E, 0xC1, 0x5A, 0xB5, 0x17}; + constexpr std::array sourceArray = CRYPT_NAME("Software\\Gravity Soft\\RenewSetup", 0xC52FB5FBB94FF917ULL); + const std::uint8_t (&source)[33] = sourceArray._Elems; return DecryptText<0xC52FB5FBB94FF917ULL>(source); } diff --git a/Source/Contents/Store/MCStoreInfoBackupAsyncWork.cpp b/Source/Contents/Store/MCStoreInfoBackupAsyncWork.cpp index aca8cca32..46a212a01 100644 --- a/Source/Contents/Store/MCStoreInfoBackupAsyncWork.cpp +++ b/Source/Contents/Store/MCStoreInfoBackupAsyncWork.cpp @@ -71,7 +71,8 @@ void CMCStoreInfoBackupLoadAsyncWork::Bind( this->m_url = url; this->m_token = token; this->m_response = ""; - const std::uint8_t diagnosticSource[] = {0xA4, 0x0F, 0x9A, 0xE7, 0x18, 0x3E, 0x8B, 0xD3}; + constexpr std::array diagnosticSourceArray = CRYPT_NAME("unknwon", 0xD3E5516F89F161D1ULL); + const std::uint8_t (&diagnosticSource)[8] = diagnosticSourceArray._Elems; AsyncDiagnostic diagnostic(false, std::string(DecryptName<0xD3E5516F89F161D1ULL>(diagnosticSource)), loadSource, 55); this->m_diagnostic.MoveFrom(diagnostic); this->m_type = type; @@ -144,7 +145,8 @@ void CMCStoreInfoBackupSaveAsyncWork::Bind( this->m_url = url; this->m_token = token; this->m_data = data; - const std::uint8_t diagnosticSource[] = {0xCC, 0x63, 0x44, 0xCF, 0x34, 0x94, 0x61, 0x49}; + constexpr std::array diagnosticSourceArray = CRYPT_NAME("unknwon", 0x490FFB43A12F0DB9ULL); + const std::uint8_t (&diagnosticSource)[8] = diagnosticSourceArray._Elems; AsyncDiagnostic diagnostic(false, std::string(DecryptName<0x490FFB43A12F0DB9ULL>(diagnosticSource)), saveSource, 57); this->m_diagnostic.MoveFrom(diagnostic); this->m_type = type; diff --git a/Source/Contents/Time/ClientTiming.cpp b/Source/Contents/Time/ClientTiming.cpp index ef464a408..74f31f9de 100644 --- a/Source/Contents/Time/ClientTiming.cpp +++ b/Source/Contents/Time/ClientTiming.cpp @@ -15,6 +15,7 @@ #include "Utility/Cipher/XorBytes.h" #include "Utility/Text/FormatString.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -720,9 +721,9 @@ void CSession::LoadRobeAlpha() { LuaScript* script = this->m_hotkeyScript; const char signatureSource[] = {'\x15', '\x45', '\xC9', '\x0F', '\x21', '\x81', '\x73'}; - const char functionSource[] = {'\x36', '\x32', '\xDC', '\x11', '\x9E', '\x27', '\x6B', '\xB4', '\x29', '\x34', '\xC9', '\x02', '\x95', '\x36', '\x77', '\xA1', '\x2E', '\x33', '\xDC', '\x0E', '\x8E', '\x3D', '\x7F', '\xBA', '\x47'}; + const auto functionSource = CRYPT_NAME("querytransparentiteminfo", 0xD51953E763B94747ULL); - if (!script->Call(DecryptName<0xD51953E763B94747ULL>(functionSource), DecryptName<0x6373E5456BAD7B71ULL>(signatureSource), index, &robeId, &from, &to, &period)) { + if (!script->Call(DecryptName<0xD51953E763B94747ULL>(functionSource.data), DecryptName<0x6373E5456BAD7B71ULL>(signatureSource), index, &robeId, &from, &to, &period)) { char message[260]; std::memset(message, 0, sizeof(message)); const char formatSource[] = {'\xAA', '\x72', '\x76', '\xA1', '\x8C', '\x37', '\x93', '\x0A', '\xB5', '\x74', '\x63', '\xB2', '\x87', '\x26', '\x8F', '\x1F', '\xB2', '\x73', '\x76', '\xBE', '\x9C', '\x2D', '\x87', '\x04', '\xFB', '\x28', '\x3C', '\xF3', '\xD0', '\x27', '\xC1', '\xAB', '\x0B', '\xB6', '\xF1', '\xF3', '\x48', '\x84', '\x27', '\xBB', '\xDB'}; diff --git a/Source/Contents/UserData/AccountLinkedUserDataLoadAsyncWork.cpp b/Source/Contents/UserData/AccountLinkedUserDataLoadAsyncWork.cpp index 67819ab9e..b67dff8d0 100644 --- a/Source/Contents/UserData/AccountLinkedUserDataLoadAsyncWork.cpp +++ b/Source/Contents/UserData/AccountLinkedUserDataLoadAsyncWork.cpp @@ -66,7 +66,8 @@ void CAccountLinkedUserDataLoadAsyncWork::Bind(std::uint32_t accountId, std::str this->m_url = url; this->m_response = ""; - const std::uint8_t diagnosticSource[] = {0xC2, 0x69, 0x3C, 0xA3, 0x5C, 0x88, 0x45, 0x81}; + constexpr std::array diagnosticSourceArray = CRYPT_NAME("unknwon", 0x812BE72BCD5707B7ULL); + const std::uint8_t (&diagnosticSource)[8] = diagnosticSourceArray._Elems; AsyncDiagnostic diagnostic = Diagnostic(false, DecryptName<0x812BE72BCD5707B7ULL>(diagnosticSource), 50); this->m_diagnostic.MoveFrom(diagnostic); } diff --git a/Source/Contents/UserData/AccountLinkedUserDataMgr.cpp b/Source/Contents/UserData/AccountLinkedUserDataMgr.cpp index 9cac3ee5e..1bf44a599 100644 --- a/Source/Contents/UserData/AccountLinkedUserDataMgr.cpp +++ b/Source/Contents/UserData/AccountLinkedUserDataMgr.cpp @@ -11,6 +11,7 @@ #include "Utility/Async/AsyncDiagnostic.h" #include "Utility/Cipher/XorBytes.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -30,7 +31,8 @@ namespace { // INLINED const char* DefaultAccountName() { - const std::uint8_t source[] = {0x6A, 0x5F, 0xA6, 0x89, 0x82, 0x02, 0x03, 0x1D}; + constexpr std::array sourceArray = CRYPT_NAME("unknown", 0x1D6D75EDE7CD311FULL); + const std::uint8_t (&source)[8] = sourceArray._Elems; return DecryptText<0x1D6D75EDE7CD311FULL>(source); } } @@ -99,14 +101,18 @@ void CAccountLinkedUserDataMgr::CompleteLoad( Json::Value root; Json::Reader reader; if (reader.parse(response, root, true)) { - const std::uint8_t typeSource[] = {0x43, 0x80, 0x3F, 0xDC, 0xFB}; + constexpr std::array typeSourceArray = CRYPT_NAME("Type", 0xC52FB5FBB94FF917ULL); + const std::uint8_t (&typeSource)[5] = typeSourceArray._Elems; switch (root[DecryptText<0xC52FB5FBB94FF917ULL>(typeSource)].asInt()) { case 1: { - const std::uint8_t whisperSource[] = {0xA1, 0xAC, 0xF3, 0x94, 0xA1}; + constexpr std::array whisperSourceArray = CRYPT_NAME("data", 0x93E7A3A1F587CDC5ULL); + const std::uint8_t (&whisperSource)[5] = whisperSourceArray._Elems; LoadWhisperBlockList(root[DecryptText<0x93E7A3A1F587CDC5ULL>(whisperSource)]); - const std::uint8_t emotionSource[] = {0x43, 0x60, 0x73, 0x0C, 0x03}; + constexpr std::array emotionSourceArray = CRYPT_NAME("data", 0x2FF3C5036D070127ULL); + const std::uint8_t (&emotionSource)[5] = emotionSourceArray._Elems; g_session.m_emotionHotkeys.Load(root[DecryptText<0x2FF3C5036D070127ULL>(emotionSource)]); - const std::uint8_t hotkeySource[] = {0xD7, 0x06, 0xB7, 0x32, 0xF9}; + constexpr std::array hotkeySourceArray = CRYPT_NAME("data", 0x17359BF953C367B3ULL); + const std::uint8_t (&hotkeySource)[5] = hotkeySourceArray._Elems; g_userHotkeyMgr->LoadV2(*g_session.m_hotkeyScript, root[DecryptText<0x17359BF953C367B3ULL>(hotkeySource)]); } [[fallthrough]]; @@ -128,9 +134,11 @@ void CAccountLinkedUserDataMgr::CompleteLoad( void CAccountLinkedUserDataMgr::RefreshUrls(LuaScript& settings, LuaScript& tables, const char* host, const char* port, const char* overrideKey) { const std::string base = ResolveAccountServiceBase(settings, tables, host, port, overrideKey); if (!base.empty()) { - const std::uint8_t saveSource[] = {0x8E, 0x48, 0xEC, 0xB2, 0x11, 0xEC, 0x48, 0x37, 0xC7, 0x54, 0xF8, 0xF8, 0x10, 0xEE, 0x51, 0x3C, 0xA1}; + constexpr std::array saveSourceArray = CRYPT_NAME("/userconfig/save", 0x59278F63D79F3DA1ULL); + const std::uint8_t (&saveSource)[17] = saveSourceArray._Elems; this->m_saveUrl = base + DecryptText<0x59278F63D79F3DA1ULL>(saveSource); - const std::uint8_t loadSource[] = {0x98, 0x72, 0x24, 0xA8, 0x59, 0x84, 0x44, 0xEF, 0xD1, 0x6E, 0x30, 0xE2, 0x47, 0x88, 0x4A, 0xE5, 0xB7}; + constexpr std::array loadSourceArray = CRYPT_NAME("/userconfig/load", 0x812BE72BCD5707B7ULL); + const std::uint8_t (&loadSource)[17] = loadSourceArray._Elems; this->m_loadUrl = base + DecryptText<0x812BE72BCD5707B7ULL>(loadSource); } } diff --git a/Source/Contents/UserData/AccountLinkedUserDataSaveAsyncWork.cpp b/Source/Contents/UserData/AccountLinkedUserDataSaveAsyncWork.cpp index cba3836e7..c447030b1 100644 --- a/Source/Contents/UserData/AccountLinkedUserDataSaveAsyncWork.cpp +++ b/Source/Contents/UserData/AccountLinkedUserDataSaveAsyncWork.cpp @@ -6,6 +6,7 @@ #include "Utility/Cipher/XorBytes.h" #include "Utility/Text/FormatString.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -64,7 +65,8 @@ void CAccountLinkedUserDataSaveAsyncWork::Bind(std::uint32_t accountId, std::str this->m_url = url; this->m_token = token; this->m_data = data; - const std::uint8_t diagnosticSource[] = {0xC2, 0x69, 0x3C, 0xA3, 0x5C, 0x88, 0x45, 0x81}; + constexpr std::array diagnosticSourceArray = CRYPT_NAME("unknwon", 0x812BE72BCD5707B7ULL); + const std::uint8_t (&diagnosticSource)[8] = diagnosticSourceArray._Elems; AsyncDiagnostic diagnostic = Diagnostic(false, DecryptName<0x812BE72BCD5707B7ULL>(diagnosticSource), 54); this->m_diagnostic.MoveFrom(diagnostic); } @@ -76,9 +78,11 @@ bool CAccountLinkedUserDataSaveAsyncWork::Execute() { StringFormat(accountId, sizeof(accountId), _TRUNCATE, "%lu", this->m_accountId); std::string name = CCURLMgr::GetInstance()->ToUtf8(this->m_accountName); CCURLPostHander handler(this->m_url); - const std::uint8_t aid[] = {0x56, 0xB0, 0x0B, 0xB9}; + constexpr std::array aidArray = CRYPT_NAME("AID", 0xC52FB5FBB94FF917ULL); + const std::uint8_t (&aid)[4] = aidArray._Elems; handler.AddField(DecryptName<0xC52FB5FBB94FF917ULL>(aid), accountId, 4); - const std::uint8_t token[] = {0x84, 0xB8, 0xF3, 0x9D, 0xF5, 0xCC, 0x8C, 0xF6, 0xAB, 0xCD}; + constexpr std::array tokenArray = CRYPT_NAME("AuthToken", 0x93E7A3A1F587CDC5ULL); + const std::uint8_t (&token)[10] = tokenArray._Elems; handler.AddField(DecryptName<0x93E7A3A1F587CDC5ULL>(token), this->m_token, 4); const std::uint8_t worldName[] = {0x70, 0x6E, 0x75, 0x01, 0x67, 0x8B, 0x92, 0x42, 0x42, 0x01}; handler.AddField(DecryptName<0x2FF3C5036D070127ULL>(worldName), name, 4); @@ -86,7 +90,8 @@ bool CAccountLinkedUserDataSaveAsyncWork::Execute() { handler.AddField(DecryptName<0x17359BF953C367B3ULL>(data), this->m_data, 4); if (handler.Perform() != 0) { - const std::uint8_t error[] = {0x17, 0x98, 0x30, 0x99, 0x81}; + constexpr std::array errorArray = CRYPT_NAME("fail", 0x91651D81F559F971ULL); + const std::uint8_t (&error)[5] = errorArray._Elems; Report(this->m_diagnostic, false, DecryptName<0x91651D81F559F971ULL>(error), 102); } else { const std::uint8_t good[] = {0x6C, 0x14, 0xB0, 0x05, 0x4B}; diff --git a/Source/Contents/UserData/CharacterLinkedUserDataMgr.cpp b/Source/Contents/UserData/CharacterLinkedUserDataMgr.cpp index 0e0957e76..5771d2507 100644 --- a/Source/Contents/UserData/CharacterLinkedUserDataMgr.cpp +++ b/Source/Contents/UserData/CharacterLinkedUserDataMgr.cpp @@ -4,6 +4,7 @@ #include "Contents/UserData/CharacterLinkedUserDataMgr.h" #include "Script/LuaScript.h" #include "Utility/Cipher/EncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include @@ -73,9 +74,8 @@ __declspec(noinline) void CCharacterLinkedUserDataMgr::RefreshUrls() { const std::string base = ResolveAccountServiceBase(*g_session.m_hotkeyScript, *g_session.m_hotkeyScript, g_serviceHost, g_servicePort, g_serviceOverrideKey); if (!base.empty()) { - const char saveSource[] = {'\xFE', '\x02', '\x99', '\xE8', '\x1D', '\x32', '\x8A', '\xBD', '\xB7', - '\x08', '\x96', '\xA6', '\x1C', '\x30', '\x93', '\xB6', '\xD1'}; - thread_local EncryptedName savePath(saveSource); + const auto saveSource = CRYPT_NAME("/charconfig/save", 0xD3E5516F89F161D1ULL); + thread_local EncryptedName savePath(saveSource.data); this->m_saveUrl = base + savePath.Text(); const char loadSource[] = {'\x78', '\x8C', '\xB9', '\xD4', '\xD9', '\x1C', '\x92', '\x31', '\x31', diff --git a/Source/UI/AdventureGuide/UIAdventureGuide.cpp b/Source/UI/AdventureGuide/UIAdventureGuide.cpp index 7b648b615..f297a4374 100644 --- a/Source/UI/AdventureGuide/UIAdventureGuide.cpp +++ b/Source/UI/AdventureGuide/UIAdventureGuide.cpp @@ -24,6 +24,7 @@ #include "UI/Window/UIRegisterMgr.h" #include "Resource/MSGSTRINGID.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include #include @@ -2631,11 +2632,8 @@ void CUIItem::OnCreate(int width, int height) { button->Invalidate(); } { - const char moveDisableSource[] = { - '\x09', '\xAE', '\x2D', '\x15', '\x27', '\xA7', '\xDA', '\x6E', '\x0F', '\xE5', '\x2D', '\x23', '\x5A', '\xD3', '\x43', '\xE2', '\xAD', '\x77', '\x88', - '\x81', '\x93', '\x1C', '\x6D', '\xC6', '\x8E', '\x74', '\x84', '\x8B', '\x82', '\x35', '\x7D', '\xD7', '\xA7', '\x5E', '\x80', '\x80', '\x91', '\x0C', - '\x40', '\xC7', '\xA0', '\x72', '\x8C', '\x8D', '\x8B', '\x0C', '\x31', '\xC1', '\xA4', '\x71', '\xED'}; - thread_local EncryptedName moveDisableName(moveDisableSource); + const auto moveDisableSource = CRYPT_NAME("유저인터페이스\\AdventureGuide\\btn_move_disable.bmp", 0xA31F69E7EFED01C9ULL); + thread_local EncryptedName moveDisableName(moveDisableSource.data); const std::string moveDisable(moveDisableName.Text()); const char moveOverSource[] = { '\xAB', '\xE4', '\x7B', '\xFB', '\x47', '\xA1', '\x6C', '\x7A', '\xAD', '\xAF', '\x7B', '\xCD', '\x3A', '\xD5', '\xF5', '\xF6', '\x0F', '\x3D', '\xDE', diff --git a/Source/UI/CashShop/UICashShopWnd.cpp b/Source/UI/CashShop/UICashShopWnd.cpp index 7ed2192f5..e2a63e902 100644 --- a/Source/UI/CashShop/UICashShopWnd.cpp +++ b/Source/UI/CashShop/UICashShopWnd.cpp @@ -461,8 +461,8 @@ void UICashShopWnd::Paint() { this->DrawRightAlignedText(0x2C4, 0x1D2, FormatOwnedString("%d C", 0).c_str(), 0, 0, 0xC, 0, 0); } else { { - const char source[] = {'\xEA', '\x39', '\x2C', '\x31', '\x3B', '\x2F', '\x6D', '\xF6', '\xEF', '\x43', '\x3D', '\xF5', '\x39', '\x6B', '\xF0', '\xFD', '\x91', '\x2D', '\xE9'}; - thread_local EncryptedName title(source); + const auto source = CRYPT_NAME("스토브 구입 리스트", 0x474DC581D5E98357ULL); + thread_local EncryptedName title(source.data); this->DrawCenteredText(0x21A, 0x1B, title.Text(), 0xB9, 0, 0xE, 0, 1); } { diff --git a/Source/UI/Dialogs/UILocaleTextWnd.cpp b/Source/UI/Dialogs/UILocaleTextWnd.cpp index 65108eeff..6d26f0b92 100644 --- a/Source/UI/Dialogs/UILocaleTextWnd.cpp +++ b/Source/UI/Dialogs/UILocaleTextWnd.cpp @@ -2,6 +2,7 @@ #include "UI/Text/UIStaticTextControl.h" #include "Utility/Cipher/XorBytes.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -21,7 +22,8 @@ void CUISubTab::OnCreate(int width, int height) { this->labelText->SetAlign(6, 6); { CUIStaticText* text = this->labelText; - const std::uint8_t fontSource[] = {0x16, 0x82, 0x37, 0x1E, 0xF0, 0xA1}; + constexpr std::array fontSourceArray = CRYPT_NAME("Gulim", 0xB127A19D775BF751ULL); + const std::uint8_t (&fontSource)[6] = fontSourceArray._Elems; thread_local EncryptedName fontName(fontSource); text->SetFont(fontName.Text()); } @@ -57,7 +59,8 @@ void CUITab::OnCreate(int width, int height) { this->labelText->SetAlign(6, 6); { CUIStaticText* text = this->labelText; - const std::uint8_t fontSource[] = {0xBA, 0xC0, 0x5F, 0x86, 0x3C, 0x37}; + constexpr std::array fontSourceArray = CRYPT_NAME("Gulim", 0x91493751EF33B5FDULL); + const std::uint8_t (&fontSource)[6] = fontSourceArray._Elems; thread_local EncryptedName fontName(fontSource); text->SetFont(fontName.Text()); } @@ -80,7 +83,8 @@ void CUITabInfo::OnCreate(int width, int height) { this->titleText->SetAlign(0, 6); { CUIStaticText* text = this->titleText; - const std::uint8_t fontSource[] = {0x28, 0x08, 0x97, 0x4A, 0x1C, 0x07}; + constexpr std::array fontSourceArray = CRYPT_NAME("Gulim", 0xCD8F077123FB7D6FULL); + const std::uint8_t (&fontSource)[6] = fontSourceArray._Elems; thread_local EncryptedName fontName(fontSource); text->SetFont(fontName.Text()); } diff --git a/Source/UI/Dialogs/UIMessageBox.cpp b/Source/UI/Dialogs/UIMessageBox.cpp index cd1891e77..a88997b5f 100644 --- a/Source/UI/Dialogs/UIMessageBox.cpp +++ b/Source/UI/Dialogs/UIMessageBox.cpp @@ -1021,8 +1021,8 @@ void UIReplayRECControlWnd::AnimateLoading() { // OFFSET: 0x008AE8A0 // FUNCTION: fn_11741 void UILoginOTPWnd::OnCreate(int, int) { - const char prefixSource[] = {'\x8F', '\xC8', '\x2D', '\x7F', '\xC9', '\xF9', '\xFA', '\xB4', '\x89', '\x83', '\x2D', '\x49', '\xB4', '\x8D', '\x63', '\x79'}; - thread_local EncryptedName prefixName(prefixSource); + const auto prefixSource = CRYPT_NAME("유저인터페이스\\", 0x793F370985ED674FULL); + thread_local EncryptedName prefixName(prefixSource.data); const std::string prefix(prefixName.Text()); this->authCodeEdit = new UIEditCtrl(); diff --git a/Source/UI/Exchange/UIExchangeUI.cpp b/Source/UI/Exchange/UIExchangeUI.cpp index 7c52ff151..5754d108d 100644 --- a/Source/UI/Exchange/UIExchangeUI.cpp +++ b/Source/UI/Exchange/UIExchangeUI.cpp @@ -3,6 +3,7 @@ #include "UI/Exchange/UIExchangeUI.h" #include "UI/Window/UIEnums.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include "Client/Session/Session.h" #include "Client/Mode/CGameMode.h" @@ -655,14 +656,9 @@ void CUIExchangeUI::OnCreate(int width, int height) { this->titleBar->Move(0, 0); { CUITitleBar* titleBar = this->titleBar; - const char titleRightSource[] = { - '\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', '\x63', - '\x5E', '\x33', '\xC1', '\x5C', '\xDD', '\x84', '\xDB', '\x48', '\x45', '\x2E', '\xCA', '\x51', '\xCB', '\xCB', '\xCB', '\x7A', - '\x47', '\x47' - }; + const auto titleRightSource = CRYPT_NAME("유저인터페이스\\basic_interface\\titlebar_right.bmp", 0x17A9E5BF39AD4737ULL); // GLOBAL: gl_25394 - thread_local EncryptedName titleRightName(titleRightSource); + thread_local EncryptedName 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', diff --git a/Source/UI/Macro/UIMacroReport.cpp b/Source/UI/Macro/UIMacroReport.cpp index 3265f9b3a..8420f98f0 100644 --- a/Source/UI/Macro/UIMacroReport.cpp +++ b/Source/UI/Macro/UIMacroReport.cpp @@ -15,6 +15,7 @@ #include "Utility/Cipher/XorBytes.h" #include "UI/Window/UIRegisterMgr.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" #include #include @@ -140,10 +141,8 @@ void CUIMacroReport::OnCreate(int width, int height) { this->m_background->Move(0, 17); { CUIStaticImage* background = this->m_background; - const char backgroundImageSource[] = { - '\x19', '\x56', '\x21', '\x19', '\xAD', '\xDB', '\x68', '\xE6', '\x1F', '\x1D', '\x21', '\x2F', '\xD0', '\xAF', '\xF1', '\x66', '\xB8', '\x9A', '\x93', '\x8C', '\x3F', '\x70', '\xDD', '\x44', - '\xAB', '\x8D', '\xBD', '\x81', '\x0A', '\x4A', '\xC0', '\x4A', '\xBA', '\x8B', '\x8E', '\x91', '\x08', '\x65', '\xC2', '\x59', '\xAD', '\xD7', '\x83', '\x8E', '\x1D', '\x15'}; - const std::string backgroundImage(DecryptName<0x2BAD156DE3E1F9D9ULL>(backgroundImageSource)); + const auto backgroundImageSource = CRYPT_NAME("유저인터페이스\\MacroReport\\bg_macroreport.bmp", 0x2BAD156DE3E1F9D9ULL); + const std::string backgroundImage(DecryptName<0x2BAD156DE3E1F9D9ULL>(backgroundImageSource.data)); background->SetImage(backgroundImage); } this->AddChild(this->m_background); @@ -153,20 +152,12 @@ void CUIMacroReport::OnCreate(int width, int height) { this->m_titleBar->Move(0, 0); { CUITitleBar* titleBar = this->m_titleBar; - const char titleRightSource[] = { - '\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', '\xD7', '\xF4', '\x0A', '\x91', '\x17', '\x09', '\x15', '\x6E', - '\xD5', '\x9D'}; - const std::string titleRight(DecryptName<0x03772763F96D9DA5ULL>(titleRightSource)); - const char titleMiddleSource[] = { - '\xAD', '\x14', '\x55', '\xD7', '\x53', '\x35', '\xD2', '\x08', '\xAB', '\x5F', '\x55', '\xE1', '\x2E', '\x41', '\x4B', '\xA7', '\x0C', '\xC8', '\xFC', '\x4E', '\xCC', '\x92', '\x79', '\xB1', - '\x08', '\xC9', '\xF3', '\x4C', '\xF0', '\x9E', '\x4B', '\xB1', '\x04', '\xCF', '\xF9', '\x48', '\xF1', '\x9A', '\x65', '\x9A', '\x00', '\xD2', '\xF1', '\x03', '\xF1', '\x96', '\x67', '\xC5'}; - const std::string titleMiddle(DecryptName<0xC517FB932D95BB6DULL>(titleMiddleSource)); - const char titleLeftSource[] = { - '\x09', '\x5A', '\x9F', '\x71', '\x4F', '\x1B', '\x7E', '\xEE', '\x0F', '\x11', '\x9F', '\x47', '\x32', '\x6F', '\xE7', '\x41', '\xA8', '\x86', '\x36', '\xE8', '\xD0', '\xBC', '\xD5', '\x57', - '\xAC', '\x87', '\x39', '\xEA', '\xEC', '\xB0', '\xE7', '\x57', '\xA0', '\x81', '\x33', '\xEE', '\xED', '\xB4', '\xC9', '\x7C', '\xA5', '\x90', '\x39', '\xFF', '\xA1', '\xB7', '\xD6', '\x53', - '\xC9'}; - const std::string titleLeft(DecryptName<0x23BBD58F8B5FF5C9ULL>(titleLeftSource)); + const auto titleRightSource = CRYPT_NAME("유저인터페이스\\basic_interface\\titlebar_right.bmp", 0x03772763F96D9DA5ULL); + const std::string titleRight(DecryptName<0x03772763F96D9DA5ULL>(titleRightSource.data)); + const auto titleMiddleSource = CRYPT_NAME("유저인터페이스\\basic_interface\\titlebar_mid.bmp", 0xC517FB932D95BB6DULL); + const std::string titleMiddle(DecryptName<0xC517FB932D95BB6DULL>(titleMiddleSource.data)); + const auto titleLeftSource = CRYPT_NAME("유저인터페이스\\basic_interface\\titlebar_left.bmp", 0x23BBD58F8B5FF5C9ULL); + const std::string titleLeft(DecryptName<0x23BBD58F8B5FF5C9ULL>(titleLeftSource.data)); titleBar->SetImages(titleLeft, titleMiddle, titleRight); } this->AddChild(this->m_titleBar); @@ -175,16 +166,14 @@ void CUIMacroReport::OnCreate(int width, int height) { title->SetSize(100, 17); title->Move(18, 0); { - const char titleTextSource[] = { - '\x47', '\xBC', '\xAB', '\x85', '\x19', '\xB4', '\xB4', '\xBB', '\x6A', '\x13'}; - title->SetText(DecryptName<0x0B7109397F6B1387ULL>(titleTextSource)); + const auto titleTextSource = CRYPT_NAME("유저 신고", 0x0B7109397F6B1387ULL); + title->SetText(DecryptName<0x0B7109397F6B1387ULL>(titleTextSource.data)); } title->SetFitText(0); title->SetAlign(0, 6); { - const char titleFontSource[] = { - '\x20', '\xDE', '\xFD', '\xCC', '\xCC', '\x3F'}; - title->SetFont(std::string(DecryptName<0x13E33FA1A591AB67ULL>(titleFontSource))); + const auto titleFontSource = CRYPT_NAME("Gulim", 0x13E33FA1A591AB67ULL); + title->SetFont(std::string(DecryptName<0x13E33FA1A591AB67ULL>(titleFontSource.data))); } title->SetFontHeight(12); title->SetBold(0); @@ -202,22 +191,14 @@ void CUIMacroReport::OnCreate(int width, int height) { menuButton->disabled = 0; menuButton->Invalidate(); { - const char menuDisabledSource[] = { - '\xC9', '\x88', '\xEF', '\x41', '\x7D', '\x93', '\xB8', '\x14', '\xCF', '\xC3', '\xEF', '\x77', '\x00', '\xE7', '\x21', '\xBB', '\x68', '\x54', '\x46', '\xD8', '\xE2', '\x34', '\x13', '\xAD', - '\x6C', '\x55', '\x49', '\xDA', '\xDE', '\x38', '\x21', '\xAA', '\x70', '\x54', '\x70', '\xD9', '\xDC', '\x2E', '\x18', '\x86', '\x66', '\x41', '\x49', '\x95', '\xDF', '\x30', '\x0D', '\xD9'}; - const std::string menuDisabled(DecryptName<0xD97D5DBDBB2F2709ULL>(menuDisabledSource)); - const char menuPressedSource[] = { - '\xAF', '\xD2', '\x3B', '\xD9', '\xB1', '\xC9', '\x4A', '\x00', '\xA9', '\x99', '\x3B', '\xEF', '\xCC', '\xBD', '\xD3', '\xAF', '\x0E', '\x0E', '\x92', '\x40', '\x2E', '\x6E', '\xE1', '\xB9', - '\x0A', '\x0F', '\x9D', '\x42', '\x12', '\x62', '\xD3', '\xBE', '\x16', '\x0E', '\xA4', '\x41', '\x10', '\x74', '\xEA', '\x92', '\x00', '\x13', '\xD5', '\x41', '\x1C', '\x77', '\x8F'}; - const std::string menuPressed(DecryptName<0xCD8F077123FB7D6FULL>(menuPressedSource)); - const char menuHoverSource[] = { - '\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', '\xEA', '\x3A', '\x5A', '\x0C', '\x45', '\xB4', '\xCC', '\x2C', '\xC6', '\x2C', '\x47', '\x7D', '\x45', '\xB8', '\xCF', '\x49'}; - const std::string menuHover(DecryptName<0x9949BFD527532943ULL>(menuHoverSource)); - const char menuNormalSource[] = { - '\xF7', '\xE8', '\x6D', '\xC3', '\x7F', '\x2B', '\x6C', '\xDA', '\xF1', '\xA3', '\x6D', '\xF5', '\x02', '\x5F', '\xF5', '\x75', '\x56', '\x34', '\xC4', '\x5A', '\xE0', '\x8C', '\xC7', '\x63', - '\x52', '\x35', '\xCB', '\x58', '\xDC', '\x80', '\xF5', '\x64', '\x4E', '\x34', '\xF2', '\x5B', '\xDE', '\x96', '\xCC', '\x48', '\x58', '\x21', '\xCB', '\x17', '\xDD', '\x88', '\xD9', '\x17'}; - const std::string menuNormal(DecryptName<0x17A9E5BF39AD4737ULL>(menuNormalSource)); + const auto menuDisabledSource = CRYPT_NAME("유저인터페이스\\basic_interface\\sys_base_off.bmp", 0xD97D5DBDBB2F2709ULL); + const std::string menuDisabled(DecryptName<0xD97D5DBDBB2F2709ULL>(menuDisabledSource.data)); + const auto menuPressedSource = CRYPT_NAME("유저인터페이스\\basic_interface\\sys_base_on.bmp", 0xCD8F077123FB7D6FULL); + const std::string menuPressed(DecryptName<0xCD8F077123FB7D6FULL>(menuPressedSource.data)); + const auto menuHoverSource = CRYPT_NAME("유저인터페이스\\basic_interface\\sys_base_on.bmp", 0x9949BFD527532943ULL); + const std::string menuHover(DecryptName<0x9949BFD527532943ULL>(menuHoverSource.data)); + const auto menuNormalSource = CRYPT_NAME("유저인터페이스\\basic_interface\\sys_base_off.bmp", 0x17A9E5BF39AD4737ULL); + const std::string menuNormal(DecryptName<0x17A9E5BF39AD4737ULL>(menuNormalSource.data)); menuButton->SetImages(menuNormal, menuHover, menuPressed, menuDisabled); } this->m_titleBar->AddChild(menuButton); @@ -229,24 +210,14 @@ void CUIMacroReport::OnCreate(int width, int height) { closeButton->disabled = 0; closeButton->Invalidate(); { - const char closeDisabledSource[] = { - '\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', '\xAE', '\x98', '\x08', '\xA6', '\xB4', '\xB9', '\x7C', '\x4A', '\xB8', '\xBE', '\x14', '\x9F', '\xB1', '\xFB', '\x71', '\x54', '\xAD', - '\xE1'}; - const std::string closeDisabled(DecryptName<0xDD3913D5D7F97BE1ULL>(closeDisabledSource)); - const char closePressedSource[] = { - '\x5F', '\x6A', '\xAD', '\x51', '\x17', '\xE7', '\x38', '\x68', '\x59', '\x21', '\xAD', '\x67', '\x6A', '\x93', '\xA1', '\xC7', '\xFE', '\xB6', '\x04', '\xC8', '\x88', '\x40', '\x93', '\xD1', - '\xFA', '\xB7', '\x0B', '\xCA', '\xB4', '\x4C', '\xA1', '\xD6', '\xE6', '\xB6', '\x32', '\xC8', '\xBB', '\x46', '\x8E', '\xC0', '\xC0', '\xAA', '\x03', '\x85', '\xB5', '\x44', '\x8D', '\xA5'}; - const std::string closePressed(DecryptName<0xA5FD29D7AB6DC59FULL>(closePressedSource)); - const char closeHoverSource[] = { - '\x31', '\x68', '\xF9', '\xF3', '\xD7', '\xB7', '\x8A', '\x3C', '\x37', '\x23', '\xF9', '\xC5', '\xAA', '\xC3', '\x13', '\x93', '\x90', '\xB4', '\x50', '\x6A', '\x48', '\x10', '\x21', '\x85', - '\x94', '\xB5', '\x5F', '\x68', '\x74', '\x1C', '\x13', '\x82', '\x88', '\xB4', '\x66', '\x6A', '\x7B', '\x16', '\x3C', '\x94', '\xAE', '\xA8', '\x57', '\x27', '\x75', '\x14', '\x3F', '\xF1'}; - const std::string closeHover(DecryptName<0xF14F79170939C7F1ULL>(closeHoverSource)); - const char closeNormalSource[] = { - '\xBF', '\xBC', '\x1F', '\x2B', '\x45', '\xA9', '\xBC', '\x20', '\xB9', '\xF7', '\x1F', '\x1D', '\x38', '\xDD', '\x25', '\x8F', '\x1E', '\x60', '\xB6', '\xB2', '\xDA', '\x0E', '\x17', '\x99', - '\x1A', '\x61', '\xB9', '\xB0', '\xE6', '\x02', '\x25', '\x9E', '\x06', '\x60', '\x80', '\xB2', '\xE9', '\x08', '\x0A', '\x88', '\x20', '\x7C', '\xB9', '\xB7', '\xAB', '\x05', '\x14', '\x9D', - '\x7F'}; - const std::string closeNormal(DecryptName<0xED796785D1DF137FULL>(closeNormalSource)); + const auto closeDisabledSource = CRYPT_NAME("유저인터페이스\\basic_interface\\sys_close_off.bmp", 0xDD3913D5D7F97BE1ULL); + const std::string closeDisabled(DecryptName<0xDD3913D5D7F97BE1ULL>(closeDisabledSource.data)); + const auto closePressedSource = CRYPT_NAME("유저인터페이스\\basic_interface\\sys_close_on.bmp", 0xA5FD29D7AB6DC59FULL); + const std::string closePressed(DecryptName<0xA5FD29D7AB6DC59FULL>(closePressedSource.data)); + const auto closeHoverSource = CRYPT_NAME("유저인터페이스\\basic_interface\\sys_close_on.bmp", 0xF14F79170939C7F1ULL); + const std::string closeHover(DecryptName<0xF14F79170939C7F1ULL>(closeHoverSource.data)); + const auto closeNormalSource = CRYPT_NAME("유저인터페이스\\basic_interface\\sys_close_off.bmp", 0xED796785D1DF137FULL); + const std::string closeNormal(DecryptName<0xED796785D1DF137FULL>(closeNormalSource.data)); closeButton->SetImages(closeNormal, closeHover, closePressed, closeDisabled); } this->m_titleBar->SetSecondButton(closeButton); @@ -256,9 +227,8 @@ void CUIMacroReport::OnCreate(int width, int height) { this->m_messageEdit->Move(8, 80); { CUIEditBox* edit = this->m_messageEdit; - const char placeholderSource[] = { - '\x26', '\x92', '\xB3', '\x74', '\x47', '\xB6', '\xBE', '\xBA', '\x70', '\x97', '\xB8', '\xB9', '\xA7', '\xD1', '\xB2', '\xC7', '\x5C', '\x98', '\xBF', '\x25', '\xD8', '\xE1', '\x2B', '\x05'}; - edit->SetText(std::string(DecryptName<0x050505679903579BULL>(placeholderSource))); + const auto placeholderSource = CRYPT_NAME("신고 내용을 입력하세요.", 0x050505679903579BULL); + edit->SetText(std::string(DecryptName<0x050505679903579BULL>(placeholderSource.data))); } this->m_messageEdit->SetTextColor(0x808080); this->m_messageEdit->SetBackgroundColor(0xFFF3EE); @@ -277,17 +247,15 @@ void CUIMacroReport::OnCreate(int width, int height) { this->firstTypeText->Move(28, 25); { CUIStaticText* text = this->firstTypeText; - const char firstTypeSource[] = { - '\x07', '\x6F', '\x54', '\xCA', '\x9B', '\x78', '\x2E', '\x34', '\x73', '\x0C', '\x3A', '\x80', '\x1E', '\x9F', '\x2F', '\x44', '\x00', '\x74', '\xCD', '\x8A', '\x7E', '\x0F', '\x02', '\x83'}; - text->SetText(DecryptName<0x83EFBFBB37EDBDBDULL>(firstTypeSource)); + const auto firstTypeSource = CRYPT_NAME("불법 프로그램 의심 신고", 0x83EFBFBB37EDBDBDULL); + text->SetText(DecryptName<0x83EFBFBB37EDBDBDULL>(firstTypeSource.data)); } this->firstTypeText->SetFitText(0); this->firstTypeText->SetAlign(0, 0); { CUIStaticText* text = this->firstTypeText; - const char firstTypeFontSource[] = { - '\xE0', '\x80', '\x13', '\x50', '\x5C', '\x4B'}; - text->SetFont(std::string(DecryptName<0xBF2B4B31397FF5A7ULL>(firstTypeFontSource))); + const auto firstTypeFontSource = CRYPT_NAME("Gulim", 0xBF2B4B31397FF5A7ULL); + text->SetFont(std::string(DecryptName<0xBF2B4B31397FF5A7ULL>(firstTypeFontSource.data))); } this->firstTypeText->SetFontHeight(12); this->firstTypeText->SetBold(0); @@ -301,17 +269,15 @@ void CUIMacroReport::OnCreate(int width, int height) { this->secondTypeText->Move(28, 43); { CUIStaticText* text = this->secondTypeText; - const char secondTypeSource[] = { - '\x2E', '\x07', '\x50', '\x0A', '\xF1', '\x2A', '\x3E', '\x0F', '\x2A', '\x32', '\x5C', '\x67', '\x14', '\x48', '\xC9', '\x91', '\x50', '\x4E', '\x0A', '\xDD'}; - text->SetText(DecryptName<0x2FE993D1DDE1F197ULL>(secondTypeSource)); + const auto secondTypeSource = CRYPT_NAME("버그 및 시스템 악용", 0x2FE993D1DDE1F197ULL); + text->SetText(DecryptName<0x2FE993D1DDE1F197ULL>(secondTypeSource.data)); } this->secondTypeText->SetFitText(0); this->secondTypeText->SetAlign(0, 0); { CUIStaticText* text = this->secondTypeText; - const char secondTypeFontSource[] = { - '\xC8', '\xEC', '\x87', '\x64', '\xD8', '\x7F'}; - text->SetFont(std::string(DecryptName<0x39FF7FB50DEB998FULL>(secondTypeFontSource))); + const auto secondTypeFontSource = CRYPT_NAME("Gulim", 0x39FF7FB50DEB998FULL); + text->SetFont(std::string(DecryptName<0x39FF7FB50DEB998FULL>(secondTypeFontSource.data))); } this->secondTypeText->SetFontHeight(12); this->secondTypeText->SetBold(0); @@ -328,22 +294,14 @@ void CUIMacroReport::OnCreate(int width, int height) { this->cancelButton->Invalidate(); { CUIImageButton* button = this->cancelButton; - const char cancelDisabledSource[] = { - '\xB5', '\x62', '\x2D', '\xA7', '\xAB', '\xAB', '\x20', '\xF8', '\xB3', '\x29', '\x2D', '\x91', '\xD6', '\xDF', '\xB9', '\x57', '\x01', '\xA3', '\xB2', '\x3E', '\x0A', '\x0B', '\x86', '\x50', - '\x19', '\xFF', '\xB2', '\x39', '\x02', '\x16', '\x84', '\x57', '\x19', '\xA8', '\xC3', '\x3F', '\x06', '\x15', '\xE5'}; - const std::string cancelDisabled(DecryptName<0x35E5656B5DEDCD75ULL>(cancelDisabledSource)); - const char cancelHoverSource[] = { - '\x3D', '\x16', '\x7B', '\xDB', '\x5F', '\x33', '\x84', '\x84', '\x3B', '\x5D', '\x7B', '\xED', '\x22', '\x47', '\x1D', '\x2B', '\x89', '\xD7', '\xE4', '\x42', '\xFE', '\x93', '\x22', '\x2C', - '\x91', '\x8B', '\xE4', '\x4E', '\xE9', '\x98', '\x33', '\x67', '\x9F', '\xD4', '\xCB', '\x21'}; - const std::string cancelHover(DecryptName<0x4941FD9F21BBB9FDULL>(cancelHoverSource)); - const char cancelPressedSource[] = { - '\x0D', '\x5E', '\x59', '\x4F', '\x4D', '\x95', '\xC2', '\x60', '\x0B', '\x15', '\x59', '\x79', '\x30', '\xE1', '\x5B', '\xCF', '\xB9', '\x9F', '\xC6', '\xD6', '\xEC', '\x35', '\x64', '\xC8', - '\xA1', '\xC3', '\xC6', '\xC5', '\xFF', '\x3E', '\x74', '\xDE', '\xE3', '\x93', '\xF4', '\xC5', '\x8D'}; - const std::string cancelPressed(DecryptName<0xAD075B8DB599F1CDULL>(cancelPressedSource)); - const char cancelNormalSource[] = { - '\xBF', '\xBA', '\x4D', '\xEB', '\xF7', '\xC1', '\x4E', '\xE2', '\xB9', '\xF1', '\x4D', '\xDD', '\x8A', '\xB5', '\xD7', '\x4D', '\x0B', '\x7B', '\xD2', '\x72', '\x56', '\x61', '\xE8', '\x4A', - '\x13', '\x27', '\xD2', '\x7F', '\x58', '\x7D', '\xE6', '\x4E', '\x13', '\x3B', '\xEF', '\x7C', '\x47', '\x0F'}; - const std::string cancelNormal(DecryptName<0x2F8B0F37118D157FULL>(cancelNormalSource)); + const auto cancelDisabledSource = CRYPT_NAME("유저인터페이스\\btn_cancel2_disable.bmp", 0x35E5656B5DEDCD75ULL); + const std::string cancelDisabled(DecryptName<0x35E5656B5DEDCD75ULL>(cancelDisabledSource.data)); + const auto cancelHoverSource = CRYPT_NAME("유저인터페이스\\btn_cancel2_over.bmp", 0x4941FD9F21BBB9FDULL); + const std::string cancelHover(DecryptName<0x4941FD9F21BBB9FDULL>(cancelHoverSource.data)); + const auto cancelPressedSource = CRYPT_NAME("유저인터페이스\\btn_cancel2_press.bmp", 0xAD075B8DB599F1CDULL); + const std::string cancelPressed(DecryptName<0xAD075B8DB599F1CDULL>(cancelPressedSource.data)); + const auto cancelNormalSource = CRYPT_NAME("유저인터페이스\\btn_cancel2_normal.bmp", 0x2F8B0F37118D157FULL); + const std::string cancelNormal(DecryptName<0x2F8B0F37118D157FULL>(cancelNormalSource.data)); button->SetImages(cancelNormal, cancelPressed, cancelHover, cancelDisabled); } this->AddChild(this->cancelButton); @@ -356,22 +314,14 @@ void CUIMacroReport::OnCreate(int width, int height) { this->reportButton->Invalidate(); { CUIImageButton* button = this->reportButton; - const char reportDisabledSource[] = { - '\xA3', '\x5A', '\x21', '\x85', '\xFB', '\xEB', '\xD8', '\x06', '\xA5', '\x11', '\x21', '\xB3', '\x86', '\x9F', '\x41', '\xA9', '\x17', '\x9B', '\xBE', '\x0D', '\x5E', '\x55', '\x72', '\xB9', - '\x17', '\xAA', '\x85', '\x16', '\x48', '\x44', '\x7F', '\xA7', '\x06', '\xDB', '\x83', '\x12', '\x4B', '\x25'}; - const std::string reportDisabled(DecryptName<0xCB1D253B7FE1F563ULL>(reportDisabledSource)); - const char reportHoverSource[] = { - '\x09', '\xBC', '\x39', '\x89', '\x39', '\x17', '\xD0', '\xBC', '\x0F', '\xF7', '\x39', '\xBF', '\x44', '\x63', '\x49', '\x13', '\xBD', '\x7D', '\xA6', '\x01', '\x9C', '\xA9', '\x7A', '\x03', - '\xBD', '\x4C', '\x96', '\x05', '\x9C', '\xAB', '\x3B', '\x13', '\xA4', '\x63', '\xF9'}; - const std::string reportHover(DecryptName<0x7115D9F973F913C9ULL>(reportHoverSource)); - const char reportPressedSource[] = { - '\x3D', '\x78', '\x8D', '\x53', '\x75', '\x41', '\x52', '\x2A', '\x3B', '\x33', '\x8D', '\x65', '\x08', '\x35', '\xCB', '\x85', '\x89', '\xB9', '\x12', '\xDB', '\xD0', '\xFF', '\xF8', '\x95', - '\x89', '\x88', '\x3D', '\xDB', '\xD0', '\xFC', '\xE4', '\xC9', '\x9F', '\xBA', '\x3D', '\xA9'}; - const std::string reportPressed(DecryptName<0xE7978FB5A94DD7FDULL>(reportPressedSource)); - const char reportNormalSource[] = { - '\xAB', '\x16', '\x07', '\xF5', '\xA7', '\x41', '\x38', '\x7A', '\xAD', '\x5D', '\x07', '\xC3', '\xDA', '\x35', '\xA1', '\xD5', '\x1F', '\xD7', '\x98', '\x7D', '\x02', '\xFF', '\x92', '\xC5', - '\x1F', '\xE6', '\xA9', '\x60', '\x15', '\xE2', '\x9C', '\xDB', '\x45', '\xDB', '\xAA', '\x7F', '\x67'}; - const std::string reportNormal(DecryptName<0xB7FD8F670FC7B96BULL>(reportNormalSource)); + const auto reportDisabledSource = CRYPT_NAME("유저인터페이스\\btn_report_disable.bmp", 0xCB1D253B7FE1F563ULL); + const std::string reportDisabled(DecryptName<0xCB1D253B7FE1F563ULL>(reportDisabledSource.data)); + const auto reportHoverSource = CRYPT_NAME("유저인터페이스\\btn_report_over.bmp", 0x7115D9F973F913C9ULL); + const std::string reportHover(DecryptName<0x7115D9F973F913C9ULL>(reportHoverSource.data)); + const auto reportPressedSource = CRYPT_NAME("유저인터페이스\\btn_report_press.bmp", 0xE7978FB5A94DD7FDULL); + const std::string reportPressed(DecryptName<0xE7978FB5A94DD7FDULL>(reportPressedSource.data)); + const auto reportNormalSource = CRYPT_NAME("유저인터페이스\\btn_report_normal.bmp", 0xB7FD8F670FC7B96BULL); + const std::string reportNormal(DecryptName<0xB7FD8F670FC7B96BULL>(reportNormalSource.data)); button->SetImages(reportNormal, reportPressed, reportHover, reportDisabled); } this->AddChild(this->reportButton); @@ -384,22 +334,14 @@ void CUIMacroReport::OnCreate(int width, int height) { this->m_firstTypeButton->Invalidate(); { CUIRadioButton* button = this->m_firstTypeButton; - const char firstRadioDisabledSource[] = { - '\xBF', '\x7A', '\x6F', '\xA1', '\xAB', '\x7F', '\xD0', '\xC2', '\xB9', '\x31', '\x6F', '\x97', '\xD6', '\x0B', '\x49', '\x7D', '\x1E', '\xB1', '\xC6', '\x34', '\x09', '\xC5', '\x7B', '\x50', - '\x10', '\xB3', '\xC9', '\x75', '\x09', '\xDC', '\x65', '\x0F'}; - const std::string firstRadioDisabled(DecryptName<0x0F15B16B5BAFD57FULL>(firstRadioDisabledSource)); - const char firstRadioHoverSource[] = { - '\xE3', '\x5E', '\x17', '\xED', '\x17', '\x87', '\x26', '\xB0', '\xE5', '\x15', '\x17', '\xDB', '\x6A', '\xF3', '\xBF', '\x0F', '\x42', '\x95', '\xBE', '\x78', '\xB5', '\x3D', '\x8D', '\x22', - '\x4C', '\x97', '\xB1', '\x39', '\xB5', '\x24', '\x93', '\x7D'}; - const std::string firstRadioHover(DecryptName<0x7DE349D717D7F123ULL>(firstRadioHoverSource)); - const char firstRadioPressedSource[] = { - '\xDD', '\xAA', '\x53', '\xD3', '\xB1', '\xED', '\x92', '\x28', '\xDB', '\xE1', '\x53', '\xE5', '\xCC', '\x99', '\x0B', '\x97', '\x7C', '\x61', '\xFA', '\x46', '\x13', '\x57', '\x39', '\xBA', - '\x72', '\x6B', '\xBD', '\x4B', '\x1C', '\x53', '\x57'}; - const std::string firstRadioPressed(DecryptName<0xE55723712993051DULL>(firstRadioPressedSource)); - const char firstRadioNormalSource[] = { - '\x8F', '\xC8', '\x2D', '\x7F', '\xC9', '\xF9', '\xFA', '\xB4', '\x89', '\x83', '\x2D', '\x49', '\xB4', '\x8D', '\x63', '\x0B', '\x2E', '\x03', '\x84', '\xEA', '\x6B', '\x43', '\x51', '\x26', - '\x20', '\x01', '\x8B', '\xAB', '\x6B', '\x5A', '\x4F', '\x79'}; - const std::string firstRadioNormal(DecryptName<0x793F370985ED674FULL>(firstRadioNormalSource)); + const auto firstRadioDisabledSource = CRYPT_NAME("유저인터페이스\\radiobtn_off.bmp", 0x0F15B16B5BAFD57FULL); + const std::string firstRadioDisabled(DecryptName<0x0F15B16B5BAFD57FULL>(firstRadioDisabledSource.data)); + const auto firstRadioHoverSource = CRYPT_NAME("유저인터페이스\\radiobtn_off.bmp", 0x7DE349D717D7F123ULL); + const std::string firstRadioHover(DecryptName<0x7DE349D717D7F123ULL>(firstRadioHoverSource.data)); + const auto firstRadioPressedSource = CRYPT_NAME("유저인터페이스\\radiobtn_on.bmp", 0xE55723712993051DULL); + const std::string firstRadioPressed(DecryptName<0xE55723712993051DULL>(firstRadioPressedSource.data)); + const auto firstRadioNormalSource = CRYPT_NAME("유저인터페이스\\radiobtn_off.bmp", 0x793F370985ED674FULL); + const std::string firstRadioNormal(DecryptName<0x793F370985ED674FULL>(firstRadioNormalSource.data)); button->SetImages(firstRadioNormal, firstRadioPressed, firstRadioHover, firstRadioDisabled); } this->m_firstTypeButton->checked = true; @@ -414,22 +356,14 @@ void CUIMacroReport::OnCreate(int width, int height) { this->m_secondTypeButton->Invalidate(); { CUIRadioButton* button = this->m_secondTypeButton; - const char secondRadioDisabledSource[] = { - '\xAD', '\xB4', '\x67', '\xEB', '\xB7', '\xA1', '\x0E', '\x3E', '\xAB', '\xFF', '\x67', '\xDD', '\xCA', '\xD5', '\x97', '\x81', '\x0C', '\x7F', '\xCE', '\x7E', '\x15', '\x1B', '\xA5', '\xAC', - '\x02', '\x7D', '\xC1', '\x3F', '\x15', '\x02', '\xBB', '\xF3'}; - const std::string secondRadioDisabled(DecryptName<0xF3CB6F7711A71B6DULL>(secondRadioDisabledSource)); - const char secondRadioHoverSource[] = { - '\x73', '\xC8', '\x99', '\x75', '\x1F', '\xE9', '\x5E', '\x4E', '\x75', '\x83', '\x99', '\x43', '\x62', '\x9D', '\xC7', '\xF1', '\xD2', '\x03', '\x30', '\xE0', '\xBD', '\x53', '\xF5', '\xDC', - '\xDC', '\x01', '\x3F', '\xA1', '\xBD', '\x4A', '\xEB', '\x83'}; - const std::string secondRadioHover(DecryptName<0x839B27DF8F5967B3ULL>(secondRadioHoverSource)); - const char secondRadioPressedSource[] = { - '\x21', '\x36', '\x47', '\xB5', '\x41', '\x0D', '\xE4', '\xBE', '\x27', '\x7D', '\x47', '\x83', '\x3C', '\x79', '\x7D', '\x01', '\x80', '\xFD', '\xEE', '\x20', '\xE3', '\xB7', '\x4F', '\x2C', - '\x8E', '\xF7', '\xA9', '\x2D', '\xEC', '\xB3', '\x21'}; - const std::string secondRadioPressed(DecryptName<0x7321C3814F8799E1ULL>(secondRadioPressedSource)); - const char secondRadioNormalSource[] = { - '\x8F', '\x0E', '\x0F', '\xCF', '\xA3', '\x19', '\x84', '\xB4', '\x89', '\x45', '\x0F', '\xF9', '\xDE', '\x6D', '\x1D', '\x0B', '\x2E', '\xC5', '\xA6', '\x5A', '\x01', '\xA3', '\x2F', '\x26', - '\x20', '\xC7', '\xA9', '\x1B', '\x01', '\xBA', '\x31', '\x79'}; - const std::string secondRadioNormal(DecryptName<0x7941D76335CFA14FULL>(secondRadioNormalSource)); + const auto secondRadioDisabledSource = CRYPT_NAME("유저인터페이스\\radiobtn_off.bmp", 0xF3CB6F7711A71B6DULL); + const std::string secondRadioDisabled(DecryptName<0xF3CB6F7711A71B6DULL>(secondRadioDisabledSource.data)); + const auto secondRadioHoverSource = CRYPT_NAME("유저인터페이스\\radiobtn_off.bmp", 0x839B27DF8F5967B3ULL); + const std::string secondRadioHover(DecryptName<0x839B27DF8F5967B3ULL>(secondRadioHoverSource.data)); + const auto secondRadioPressedSource = CRYPT_NAME("유저인터페이스\\radiobtn_on.bmp", 0x7321C3814F8799E1ULL); + const std::string secondRadioPressed(DecryptName<0x7321C3814F8799E1ULL>(secondRadioPressedSource.data)); + const auto secondRadioNormalSource = CRYPT_NAME("유저인터페이스\\radiobtn_off.bmp", 0x7941D76335CFA14FULL); + const std::string secondRadioNormal(DecryptName<0x7941D76335CFA14FULL>(secondRadioNormalSource.data)); button->SetImages(secondRadioNormal, secondRadioPressed, secondRadioHover, secondRadioDisabled); } this->m_secondTypeButton->checked = false; @@ -441,18 +375,15 @@ void CUIMacroReport::OnCreate(int width, int height) { this->warningText->Move(9, 142); { CUIStaticText* text = this->warningText; - const char warningSource[] = { - '\xD4', '\xB7', '\x7D', '\xB6', '\x2D', '\x51', '\xE8', '\xFA', '\x8E', '\x75', '\x74', '\xBC', '\x2D', '\x2E', '\x89', '\x85', '\x82', '\xED', '\x6F', '\x5F', '\xB4', '\x31', '\xEF', '\xFE', - '\x45', '\xE9', '\x3F', '\x5F', '\xCD', '\x39', '\x92', '\x85', '\xD1', '\x9A', '\x7D', '\xA6', '\x23', '\xEF'}; - text->SetText(DecryptName<0x452FEF0D7FC95565ULL>(warningSource)); + const auto warningSource = CRYPT_NAME("기능 악용 시 제재를 받을 수 있습니다.", 0x452FEF0D7FC95565ULL); + text->SetText(DecryptName<0x452FEF0D7FC95565ULL>(warningSource.data)); } this->warningText->SetFitText(0); this->warningText->SetAlign(0, 0); { CUIStaticText* text = this->warningText; - const char warningFontSource[] = { - '\x1A', '\x78', '\x25', '\xE0', '\xCC', '\x7D'}; - const std::string warningFont(DecryptName<0x9FED7DA189490D5DULL>(warningFontSource)); + const auto warningFontSource = CRYPT_NAME("Gulim", 0x9FED7DA189490D5DULL); + const std::string warningFont(DecryptName<0x9FED7DA189490D5DULL>(warningFontSource.data)); text->SetFont(warningFont); } this->warningText->SetFontHeight(12); diff --git a/Source/UI/Quest/UIRenewQuestUI.cpp b/Source/UI/Quest/UIRenewQuestUI.cpp index 5d757e321..2a113b887 100644 --- a/Source/UI/Quest/UIRenewQuestUI.cpp +++ b/Source/UI/Quest/UIRenewQuestUI.cpp @@ -404,7 +404,8 @@ __declspec(noinline) const char* EncryptedName<52, 0xBFF5C517A1A77F59ULL>::Text( // OFFSET: 0x00A5A550 // FUNCTION: fn_16400 __declspec(noinline) EncryptedName<6, 0x114901C7E37F6D49ULL>& GulimFontName1() { - const std::uint8_t source[] = {0x0E, 0x18, 0x13, 0x8A, 0xAA, 0x01}; + constexpr std::array sourceArray = CRYPT_NAME("Gulim", 0x114901C7E37F6D49ULL); + const std::uint8_t (&source)[6] = sourceArray._Elems; thread_local EncryptedName name(source); return name; } @@ -448,7 +449,8 @@ __declspec(noinline) EncryptedName<48, 0x6BDF334F2BFDAD51ULL>& NormalOffButtonNa // OFFSET: 0x00A5A9B0 // FUNCTION: fn_16405 __declspec(noinline) EncryptedName<6, 0xB7AFBD2FD9FD7501ULL>& GulimFontName2() { - const std::uint8_t source[] = {0x46, 0x00, 0x91, 0xB0, 0x42, 0xBD}; + constexpr std::array sourceArray = CRYPT_NAME("Gulim", 0xB7AFBD2FD9FD7501ULL); + const std::uint8_t (&source)[6] = sourceArray._Elems; thread_local EncryptedName name(source); return name; } @@ -492,7 +494,8 @@ __declspec(noinline) EncryptedName<45, 0xF15F8785CDE369BFULL>& SubOffButtonName3 // OFFSET: 0x00A5AE30 // FUNCTION: fn_16410 __declspec(noinline) EncryptedName<6, 0xE33F2FF779878559ULL>& GulimFontName3() { - const std::uint8_t source[] = {0x1E, 0xF0, 0xEB, 0x10, 0x9A, 0x2F}; + constexpr std::array sourceArray = CRYPT_NAME("Gulim", 0xE33F2FF779878559ULL); + const std::uint8_t (&source)[6] = sourceArray._Elems; thread_local EncryptedName name(source); return name; } @@ -536,7 +539,8 @@ __declspec(noinline) EncryptedName<47, 0x01CB4F1DF9D3F931ULL>& DailyOffButtonNam // OFFSET: 0x00A5B2C0 // FUNCTION: fn_16415 __declspec(noinline) EncryptedName<6, 0x1767DDE18D779D8BULL>& GulimFontName4() { - const std::uint8_t source[] = {0xCC, 0xE8, 0x1B, 0xE4, 0x8C, 0xDD}; + constexpr std::array sourceArray = CRYPT_NAME("Gulim", 0x1767DDE18D779D8BULL); + const std::uint8_t (&source)[6] = sourceArray._Elems; thread_local EncryptedName name(source); return name; } @@ -580,7 +584,8 @@ __declspec(noinline) EncryptedName<47, 0x0B8745519B1F95D7ULL>& EventOffButtonNam // OFFSET: 0x00A5B750 // FUNCTION: fn_16420 __declspec(noinline) EncryptedName<6, 0xC70319B5EB61598FULL>& GulimFontName5() { - const std::uint8_t source[] = {0xC8, 0x2C, 0x0D, 0x82, 0xD8, 0x19}; + constexpr std::array sourceArray = CRYPT_NAME("Gulim", 0xC70319B5EB61598FULL); + const std::uint8_t (&source)[6] = sourceArray._Elems; thread_local EncryptedName name(source); return name; } diff --git a/Source/UI/SkillDelayInfo/UISkillDelayInfo.cpp b/Source/UI/SkillDelayInfo/UISkillDelayInfo.cpp index 0c0bf32a8..6d51b2a33 100644 --- a/Source/UI/SkillDelayInfo/UISkillDelayInfo.cpp +++ b/Source/UI/SkillDelayInfo/UISkillDelayInfo.cpp @@ -21,6 +21,7 @@ #include #include "Resource/MSGSTRINGID.h" #include "Utility/Cipher/LocalEncryptedName.h" +#include "Utility/Cipher/CryptName.h" extern template std::string std::operator+(std::string&&, const char* const); @@ -141,7 +142,8 @@ void CUIDelayItem::OnCreate(int width, int height) { this->level->SetText(""); this->level->SetFitText(0); this->level->SetAlign(6, 6); - const std::uint8_t levelFontSource[] = {0x1E, 0xF0, 0xEB, 0x10, 0x9A, 0x2F}; + constexpr std::array levelFontSourceArray = CRYPT_NAME("Gulim", 0xE33F2FF779878559ULL); + const std::uint8_t (&levelFontSource)[6] = levelFontSourceArray._Elems; // GLOBAL: gl_25165 thread_local EncryptedName levelFont(levelFontSource); this->level->SetFont(std::string(levelFont.Text())); @@ -174,7 +176,8 @@ void CUITime::OnCreate(int width, int height) { this->text->SetText(""); this->text->SetFitText(0); this->text->SetAlign(6, 6); - const std::uint8_t textFontSource[] = {0xEC, 0xDA, 0xE1, 0xE4, 0xDE, 0x8D}; + constexpr std::array textFontSourceArray = CRYPT_NAME("Gulim", 0xD5A78DB38D8DAFABULL); + const std::uint8_t (&textFontSource)[6] = textFontSourceArray._Elems; // GLOBAL: gl_25166 thread_local EncryptedName textFont(textFontSource); this->text->SetFont(std::string(textFont.Text())); diff --git a/Source/Utility/Cipher/CryptName.h b/Source/Utility/Cipher/CryptName.h index 85a9b5139..1b12b074a 100644 --- a/Source/Utility/Cipher/CryptName.h +++ b/Source/Utility/Cipher/CryptName.h @@ -4,6 +4,7 @@ #include #include #include +#include namespace utility { @@ -24,12 +25,20 @@ namespace utility { // INLINED template - constexpr CryptedText CryptText(const char (&text)[Length]) { - CryptedText out{}; - for (std::size_t index = 0; index < Length; ++index) { - out.data[index] = static_cast(static_cast(text[index]) ^ static_cast(Key >> (8 * (index & 7)))); - } - return out; + consteval char CryptChar(const char (&text)[Length], std::size_t index) { + return static_cast(static_cast(text[index]) ^ static_cast(Key >> (8 * (index & 7)))); + } + + // INLINED + template + consteval CryptedText CryptText(const char (&text)[Length], std::index_sequence) { + return CryptedText{{CryptChar(text, Index)...}}; + } + + // INLINED + template + consteval CryptedText CryptText(const char (&text)[Length]) { + return CryptText(text, std::make_index_sequence{}); } }