clank/rodecomp
1
0
Fork 0
Code Issues Wiki Activity

Maintenance: Encrypted strings rewritten as OBFUSCATE_* (Utility/Cipher/Obfuscate.h); unit-local decrypt helpers removed where no cal

Browse source 
Batch #18596 by ragnarok-clanker: forced by an admin (0 lower score(s), 7 changed function(s)); checked with 8 compiled unit(s).
This commit is contained in:
ragnarok-clanker 2026-11-12 16:26:02 +00:00
commit d2e21e3ef0
8 changed files with 36 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -686,21 +686,15 @@ bool RestartFromCommandLine() {
// OFFSET: 0x00E58A60
// FUNCTION: fn_24365
void ApplyAiPatch() {
constexpr std::array<std::uint8_t, 9> patchSource = CRYPT_NAME("AI_patch", 0x3B915119EFD523EFULL);
EncryptedName<sizeof(patchSource), 0x3B915119EFD523EFULL>& patchName = ThreadLocalName<0x3B915119EFD523EFULL>(patchSource);
if (_access(patchName.Text(), 0) != 0) {
if (_access(OBFUSCATE_BYTES_TEXT("AI_patch", 0x3B915119EFD523EFULL), 0) != 0) {
return;
}
constexpr std::array<std::uint8_t, 3> aiSource = CRYPT_NAME("AI", 0x5B8F49AF09390D1BULL);
EncryptedName<sizeof(aiSource), 0x5B8F49AF09390D1BULL>& aiName = ThreadLocalName<0x5B8F49AF09390D1BULL>(aiSource);
if (_access(aiName.Text(), 0) != 0) {
if (_access(OBFUSCATE_BYTES_TEXT("AI", 0x5B8F49AF09390D1BULL), 0) != 0) {
return;
}
constexpr std::array<std::uint8_t, 10> backupSource = CRYPT_NAME("AI_backup", 0x49C3759B77DBD3C1ULL);
EncryptedName<sizeof(backupSource), 0x49C3759B77DBD3C1ULL>& backupName = ThreadLocalName<0x49C3759B77DBD3C1ULL>(backupSource);
if (_access(backupName.Text(), 0) == 0) {
if (_access(OBFUSCATE_BYTES_TEXT("AI_backup", 0x49C3759B77DBD3C1ULL), 0) == 0) {
constexpr std::array<std::uint8_t, 10> deleteSource = CRYPT_NAME("AI_backup", 0x6DED3DD1CF75AD9BULL);
char path[16] = {};
EncryptedName<sizeof(deleteSource), 0x6DED3DD1CF75AD9BULL>& deleteName = ThreadLocalName<0x6DED3DD1CF75AD9BULL>(deleteSource);
@ -715,26 +709,16 @@ void ApplyAiPatch() {
SHFileOperationA(&operation);
}
constexpr std::array<std::uint8_t, 10> backupTargetSource = CRYPT_NAME("AI_backup", 0x1BF915E1F37DFDFDULL);
EncryptedName<sizeof(backupTargetSource), 0x1BF915E1F37DFDFDULL>& backupTarget = ThreadLocalName<0x1BF915E1F37DFDFDULL>(backupTargetSource);
const char* backup = backupTarget.Text();
constexpr std::array<std::uint8_t, 3> currentSource = CRYPT_NAME("AI", 0x01FF9313695DD9DFULL);
EncryptedName<sizeof(currentSource), 0x01FF9313695DD9DFULL>& current = ThreadLocalName<0x01FF9313695DD9DFULL>(currentSource);
std::rename(current.Text(), backup);
const char* backup = OBFUSCATE_BYTES_TEXT("AI_backup", 0x1BF915E1F37DFDFDULL);
std::rename(OBFUSCATE_BYTES_TEXT("AI", 0x01FF9313695DD9DFULL), backup);
constexpr std::array<std::uint8_t, 3> installTargetSource = CRYPT_NAME("AI", 0x4F1791FB1503C713ULL);
EncryptedName<sizeof(installTargetSource), 0x4F1791FB1503C713ULL>& installTarget = ThreadLocalName<0x4F1791FB1503C713ULL>(installTargetSource);
const char* install = installTarget.Text();
constexpr std::array<std::uint8_t, 9> patchedSource = CRYPT_NAME("AI_patch", 0xA1A55B4D1597EDD3ULL);
EncryptedName<sizeof(patchedSource), 0xA1A55B4D1597EDD3ULL>& patched = ThreadLocalName<0xA1A55B4D1597EDD3ULL>(patchedSource);
std::rename(patched.Text(), install);
const char* install = OBFUSCATE_BYTES_TEXT("AI", 0x4F1791FB1503C713ULL);
std::rename(OBFUSCATE_BYTES_TEXT("AI_patch", 0xA1A55B4D1597EDD3ULL), install);
}
// INLINED
void ExitForProtectionCheck(const char* commandLine) {
constexpr std::array<std::uint8_t, 15> checkSource = CRYPT_NAME("/check_themida", 0xC7FB6DF18577D34BULL);
EncryptedName<sizeof(checkSource), 0xC7FB6DF18577D34BULL>& check = ThreadLocalName<0xC7FB6DF18577D34BULL>(checkSource);
if (std::strstr(commandLine, check.Text())) {
if (std::strstr(commandLine, OBFUSCATE_BYTES_TEXT("/check_themida", 0xC7FB6DF18577D34BULL))) {
ExitProcess(0);
}
}
@ -884,14 +868,10 @@ int InitApp(HINSTANCE instance, int showCommand) {
int posY;
if (g_configuredOldWidth == g_viewportWidth && g_configuredOldHeight == g_viewportHeight) {
int defaultX = (GetSystemMetrics(SM_CXSCREEN) - g_viewportWidth) / 2;
constexpr std::array<std::uint8_t, 12> xSource = CRYPT_NAME("Window_XPos", 0x9B17C9EFDBB39F2FULL);
EncryptedName<sizeof(xSource), 0x9B17C9EFDBB39F2FULL>& xName = ThreadLocalName<0x9B17C9EFDBB39F2FULL>(xSource);
posX = g_session.GetOptionInteger(xName.Text(), defaultX);
posX = g_session.GetOptionInteger(OBFUSCATE_BYTES_TEXT("Window_XPos", 0x9B17C9EFDBB39F2FULL), defaultX);
int defaultY = (GetSystemMetrics(SM_CYSCREEN) - g_viewportHeight) / 2;
constexpr std::array<std::uint8_t, 12> ySource = CRYPT_NAME("Window_YPos", 0x69D345DB950F336DULL);
EncryptedName<sizeof(ySource), 0x69D345DB950F336DULL>& yName = ThreadLocalName<0x69D345DB950F336DULL>(ySource);
posY = g_session.GetOptionInteger(yName.Text(), defaultY);
posY = g_session.GetOptionInteger(OBFUSCATE_BYTES_TEXT("Window_YPos", 0x69D345DB950F336DULL), defaultY);
} else {
posX = (GetSystemMetrics(SM_CXSCREEN) - g_viewportWidth) / 2;
posY = (GetSystemMetrics(SM_CYSCREEN) - g_viewportHeight) / 2;
@ -915,10 +895,8 @@ int InitApp(HINSTANCE instance, int showCommand) {
int windowWidth = static_cast<int>(width);
int windowHeight = static_cast<int>(height);
if (!g_configuredFullscreen) {
constexpr std::array<std::uint8_t, 14> traySource = CRYPT_NAME("Shell_TrayWnd", 0xC7912587FFF31B71ULL);
EncryptedName<sizeof(traySource), 0xC7912587FFF31B71ULL>& trayName = ThreadLocalName<0xC7912587FFF31B71ULL>(traySource);
RECT trayRect;
HWND tray = FindWindowA(trayName.Text(), nullptr);
HWND tray = FindWindowA(OBFUSCATE_BYTES_TEXT("Shell_TrayWnd", 0xC7912587FFF31B71ULL), nullptr);
if (tray) {
GetWindowRect(tray, &trayRect);
}
@ -938,12 +916,8 @@ int InitApp(HINSTANCE instance, int showCommand) {
hWnd = CreateApplicationWindow(0, windowClass.lpszClassName, g_windowName, style, x, y, windowWidth, windowHeight, nullptr, nullptr, instance, nullptr);
if (!hWnd) {
constexpr std::array<std::uint8_t, 6> titleSource = CRYPT_NAME("ERROR", 0x078333BB9725B7C9ULL);
EncryptedName<sizeof(titleSource), 0x078333BB9725B7C9ULL>& title = ThreadLocalName<0x078333BB9725B7C9ULL>(titleSource);
const char* caption = title.Text();
constexpr std::array<std::uint8_t, 23> messageSource = CRYPT_NAME("Window Creation Failed", 0x8F1B5BFD5F6175B5ULL);
EncryptedName<sizeof(messageSource), 0x8F1B5BFD5F6175B5ULL>& message = ThreadLocalName<0x8F1B5BFD5F6175B5ULL>(messageSource);
MessageBoxA(nullptr, message.Text(), caption, MB_OK);
const char* caption = OBFUSCATE_BYTES_TEXT("ERROR", 0x078333BB9725B7C9ULL);
MessageBoxA(nullptr, OBFUSCATE_BYTES_TEXT("Window Creation Failed", 0x8F1B5BFD5F6175B5ULL), caption, MB_OK);
return 0;
}

32
Source/Client/Mode/GameMode.cpp
View file

@ -5586,13 +5586,6 @@ void CPingLiveSchedule::Process(const std::uint64_t& now) {
namespace {
// INLINED
template <std::uint64_t Key, std::size_t Length>
const char* DecryptGameModeName(const char (&source)[Length]) {
thread_local EncryptedName<Length, Key> name(source);
return name.Text();
}
}
// OFFSET: 0x00CDEF00
@ -5627,10 +5620,7 @@ int CGameMode::Run() {
g_modeMgr.Quit();
std::string message = g_nProtectGameGuardMgr->ErrorMessage();
if (!message.empty()) {
constexpr auto sourceText = CRYPT_NAME("nProtect GameGuard", 0xADC51BF9C98B413DULL);
const auto& source = sourceText.data;
thread_local EncryptedName<sizeof(source), 0xADC51BF9C98B413DULL> name(source);
MessageBoxA(hWnd, message.c_str(), name.Text(), 0);
MessageBoxA(hWnd, message.c_str(), OBFUSCATE_TEXT("nProtect GameGuard", 0xADC51BF9C98B413DULL), 0);
}
}
@ -6634,25 +6624,15 @@ void CGameMode::UpdateBalloons() {
shownSkill = this->skillId;
std::string text;
if (shownSkill == 10000) {
constexpr auto sourceText = CRYPT_NAME("Capture Monster", 0x3FA3AFA7035DE3FFULL);
const auto& source = sourceText.data;
text.assign(DecryptGameModeName<0x3FA3AFA7035DE3FFULL>(source));
text.assign(OBFUSCATE_TEXT("Capture Monster", 0x3FA3AFA7035DE3FFULL));
} else if (shownSkill == 20000) {
constexpr auto sourceText = CRYPT_NAME("Please Marry Me", 0xDB27CB557D038759ULL);
const auto& source = sourceText.data;
text = DecryptGameModeName<0xDB27CB557D038759ULL>(source);
text = OBFUSCATE_TEXT("Please Marry Me", 0xDB27CB557D038759ULL);
} else if (shownSkill == 20001) {
constexpr auto sourceText = CRYPT_NAME("Be my Baby", 0x51BB39B763BBBD8DULL);
const auto& source = sourceText.data;
text = DecryptGameModeName<0x51BB39B763BBBD8DULL>(source);
text = OBFUSCATE_TEXT("Be my Baby", 0x51BB39B763BBBD8DULL);
} else if (shownSkill == 40000) {
constexpr auto sourceText = CRYPT_NAME("Capture Monster", 0x87E3D1C50D572DEFULL);
const auto& source = sourceText.data;
text = DecryptGameModeName<0x87E3D1C50D572DEFULL>(source);
text = OBFUSCATE_TEXT("Capture Monster", 0x87E3D1C50D572DEFULL);
} else if (g_session.IsState291To303(shownSkill)) {
constexpr auto sourceText = CRYPT_NAME("????", 0xB7AFBD2FD9FD7501ULL);
const auto& source = sourceText.data;
text = DecryptGameModeName<0xB7AFBD2FD9FD7501ULL>(source);
text = OBFUSCATE_TEXT("????", 0xB7AFBD2FD9FD7501ULL);
} else {
text = CSkillInfo::DisplayName(*g_session.m_hotkeyScript, shownSkill);
}

20
Source/Client/Mode/LoginModeNotices.cpp
View file

@ -52,17 +52,17 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) {
if (remainingTime == 0xFFFFFFFE && packet->remainingFreeTime == 0xFFFFFFFE) {
const char* message = LookupMessage(MSI_BILLING_FREE_USER);
// GLOBAL: gl_25061
const char* format = OBFUSCATE_ARRAY_TEXT("%s\x0A", 0x4B755DB19953E311ULL, std::uint8_t);
const char* format = OBFUSCATE_BYTES_TEXT("%s\x0A", 0x4B755DB19953E311ULL);
sprintf(text, format, message);
} else if (remainingTime == 0xFFFFFFFD && packet->remainingFreeTime == 0xFFFFFFFD) {
const char* message = LookupMessage(MSI_BILLING_PCB);
// GLOBAL: gl_25062
const char* format = OBFUSCATE_ARRAY_TEXT("%s\x0A", 0xF715514F5961B75BULL, std::uint8_t);
const char* format = OBFUSCATE_BYTES_TEXT("%s\x0A", 0xF715514F5961B75BULL);
sprintf(text, format, message);
} else if (remainingTime == 0xFFFFFFFF && packet->remainingFreeTime == 0xFFFFFFFF) {
const char* message = LookupMessage(MSI_BILLING_INTERNET_CAFE);
// GLOBAL: gl_25063
const char* format = OBFUSCATE_ARRAY_TEXT("%s\x0A", 0x4191BB5531FD3999ULL, std::uint8_t);
const char* format = OBFUSCATE_BYTES_TEXT("%s\x0A", 0x4191BB5531FD3999ULL);
sprintf(text, format, message);
} else if (remainingTime != 0) {
const std::uint32_t freeTime = packet->remainingFreeTime;
@ -72,7 +72,7 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) {
} else {
const char* message = LookupMessage(MSI_BILLING_100);
// GLOBAL: gl_25064
const char* format = OBFUSCATE_ARRAY_TEXT("%s\x0A", 0xB19D1FA9116F39D3ULL, std::uint8_t);
const char* format = OBFUSCATE_BYTES_TEXT("%s\x0A", 0xB19D1FA9116F39D3ULL);
sprintf(text, format, message);
const std::uint32_t time = packet->remainingTime;
const char* dayFormat = LookupMessage(MSI_BILLING_DAY_HOUR_MINUTES);
@ -82,14 +82,14 @@ void CLoginMode::ReceiveBillingInfo(const unsigned char* data) {
if (packet->remainingFreeTime > 0) {
const char* message = LookupMessage(MSI_BILLING_800);
// GLOBAL: gl_25065
const char* format = OBFUSCATE_ARRAY_TEXT("%s\x0A", 0x9569C9C7E70909AFULL, std::uint8_t);
const char* format = OBFUSCATE_BYTES_TEXT("%s\x0A", 0x9569C9C7E70909AFULL);
sprintf(text, format, message);
const std::uint32_t freeTime = packet->remainingFreeTime;
const char* hourFormat = LookupMessage(MSI_BILLING_HOUR_MINUTES);
sprintf(text + strlen(text), hourFormat, freeTime / minutesPerHour, freeTime % minutesPerHour);
} else {
// GLOBAL: gl_25066
const char* format = OBFUSCATE_ARRAY_TEXT("\x0A", 0xD7A749EB27D5BF6DULL, std::uint8_t);
const char* format = OBFUSCATE_BYTES_TEXT("\x0A", 0xD7A749EB27D5BF6DULL);
sprintf(text, format);
}
}
@ -217,12 +217,8 @@ void CLoginMode::ReceiveNotifyBan(const unsigned char* data) {
if (strlen(text) != 0) {
char message[256];
sprintf(message, []() -> EncryptedName<7, 0xBD2BA1C11B01E73BULL>& {
constexpr std::array<std::uint8_t, 7> source = CRYPT_NAME("%s(%d)", 0xBD2BA1C11B01E73BULL);
// GLOBAL: gl_25060
thread_local EncryptedName<7, 0xBD2BA1C11B01E73BULL> format(source);
return format;
}().Text(), text, packet->errorCode);
// GLOBAL: gl_25060
sprintf(message, OBFUSCATE_ARRAY("%s(%d)", 0xBD2BA1C11B01E73BULL, std::uint8_t).Text(), text, packet->errorCode);
g_windowMgr.Confirm(message, 0, true, true, 0, "Message", 280, 120, 0);
}

5
Source/Contents/Achievement/AchievementMgr.cpp
View file

@ -226,10 +226,7 @@ bool CAchievementMgr::LoadAchievementInfo() {
lua_register(lua.GetState(), "InsertAchieveRewardBuff", CAchievementMgr::L_InsertAchieveRewardBuff);
lua_register(lua.GetState(), "InsertAchieveUIType", CAchievementMgr::L_InsertAchieveUIType);
lua_register(lua.GetState(), "SetAchieveIDByTab", CAchievementMgr::L_SetAchieveIDByTab);
constexpr auto sourceText = CRYPT_NAME("system\\Achievement_list.lub", 0x490FFB43A12F0DB9ULL);
const auto& source = sourceText.data;
thread_local EncryptedName<sizeof(source), 0x490FFB43A12F0DB9ULL> path(source);
if (luaL_loadfile(lua.GetState(), path.Text()) != 0 || lua_pcall(lua.GetState(), 0, 0, 0) != 0) {
if (luaL_loadfile(lua.GetState(), OBFUSCATE_TEXT_NAMED("system\\Achievement_list.lub", 0x490FFB43A12F0DB9ULL, path)) != 0 || lua_pcall(lua.GetState(), 0, 0, 0) != 0) {
MessageBoxA(nullptr, lua_tostring(lua.GetState(), -1), "CAchievementMgr", 0);
} else {
lua_getglobal(lua.GetState(), "main");

15
Source/Contents/Effects/Particles/SpriteEffect.cpp
View file

@ -17,13 +17,6 @@
namespace {
// INLINED
template <std::uint64_t Key, std::size_t Length>
const char* DecryptName(const char (&source)[Length]) {
thread_local EncryptedName<Length, Key> name(source);
return name.Text();
}
}
// OFFSET: 0x00B78840
@ -337,13 +330,9 @@ void CSpriteEffect::SetupParticle(CSpriteParticle* particle) {
particle->frameDelay = 8.0f;
break;
case EF_UNK_2443: {
constexpr auto spriteSourceText = CRYPT_NAME("이팩트\\C_2025RosFesta.spr", 0xDB27CB557D038759ULL);
const auto& spriteSource = spriteSourceText.data;
particle->SetSprite(DecryptName<0xDB27CB557D038759ULL>(spriteSource));
particle->SetSprite(OBFUSCATE_TEXT("이팩트\\C_2025RosFesta.spr", 0xDB27CB557D038759ULL));
constexpr auto actionSourceText = CRYPT_NAME("이팩트\\C_2025RosFesta.act", 0x51BB39B763BBBD8DULL);
const auto& actionSource = actionSourceText.data;
particle->SetAction(DecryptName<0x51BB39B763BBBD8DULL>(actionSource));
particle->SetAction(OBFUSCATE_TEXT("이팩트\\C_2025RosFesta.act", 0x51BB39B763BBBD8DULL));
particle->flags = 1;
particle->depthOffset = 0.0015f;
particle->loopMode = 0;

5
Source/Contents/Map/MapNameTable.cpp
View file

@ -20,10 +20,7 @@
bool CSession::LoadMapNameTable() {
std::vector<char*> tokens;
CCommonObject& storage = reinterpret_cast<CCommonObject&>(this->minimapTokenStorage[0x30]);
constexpr auto sourceText = CRYPT_NAME("mapNameTable.txt", 0x17FB0F6BFF3BE93FULL);
const auto& source = sourceText.data;
thread_local EncryptedName<sizeof(source), 0x17FB0F6BFF3BE93FULL> name(source);
const bool loaded = storage.LoadTokens(tokens, name.Text(), 0);
const bool loaded = storage.LoadTokens(tokens, OBFUSCATE_TEXT("mapNameTable.txt", 0x17FB0F6BFF3BE93FULL), 0);
for (auto token = tokens.begin(); token != tokens.end(); token += 2) {
g_mapInfoMgr->AddMapDisplayName(token[0], token[1], false);

15
Source/Contents/Tables/TipBoxTitles.cpp
View file

@ -30,13 +30,6 @@ CTipBoxMgr* g_itemTagOwner = nullptr;
namespace {
// INLINED
template <std::uint64_t Key, std::size_t Length>
const char* DecryptName(const char (&source)[Length]) {
thread_local EncryptedName<Length, Key> name(source);
return name.Text();
}
// OFFSET: 0x009B45D0
// FUNCTION: fn_13832
__declspec(noinline) void SplitTitle(const char* text, std::vector<std::string>& lines, int width) {
@ -305,14 +298,10 @@ bool CTipBoxMgr::RegisterLuaFunctions() {
lua_register(state.GetState(), "AddPage", AddPage);
lua_register(state.GetState(), "AddIsTag", AddIsTag);
constexpr auto sourceText = CRYPT_NAME("System\\tipbox.lua", 0x0BEB63A5C905B3A7ULL);
const auto& source = sourceText.data;
if (luaL_loadfile(state.GetState(), DecryptName<0x0BEB63A5C905B3A7ULL>(source)) != 0) {
constexpr auto secondSourceText = CRYPT_NAME("System\\tipbox.lub", 0x078333BB9725B7C9ULL);
const auto& secondSource = secondSourceText.data;
if (luaL_loadfile(state.GetState(), OBFUSCATE_TEXT("System\\tipbox.lua", 0x0BEB63A5C905B3A7ULL)) != 0) {
if (luaL_loadfile(state.GetState(), DecryptName<0x078333BB9725B7C9ULL>(secondSource)) != 0) {
if (luaL_loadfile(state.GetState(), OBFUSCATE_TEXT("System\\tipbox.lub", 0x078333BB9725B7C9ULL)) != 0) {
MessageBoxA(nullptr, lua_tostring(state.GetState(), -1), "TipBox", MB_OK);
return false;
}

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

@ -44,13 +44,6 @@ template void CUIListBoxEx<ExchangeUI::CUIItem, ExchangeUI::CItemData>::SetBinde
template void CUIListBoxEx<ExchangeUI::CUIItem, ExchangeUI::CItemData>::SetImages(const std::string&, const std::string&, const std::string&,
const std::string&);
// INLINED
template <std::uint64_t Key, std::size_t Length>
static const char* DecryptName(const char (&source)[Length]) {
thread_local EncryptedName<Length, Key> name(source);
return name.Text();
}
// OFFSET: 0x00A0F840
// FUNCTION: fn_15180
template <>
@ -581,9 +574,7 @@ void ExchangeUI::CUIItem::OnCreate(int width, int height) {
this->slotBackground = new CUIStaticImage();
this->slotBackground->SetSize(32, 32);
this->slotBackground->Move(9, 0);
this->slotBackground->SetImage(std::string(DecryptName<0x75ADC57D87EFBD8FULL>({'\x4F', '\x12', '\x2F', '\x7D', '\xBD', '\x0B', '\x68', '\xB8', '\x49', '\x59', '\x2F', '\x4B', '\xC0', '\x7F', '\xF1', '\x17',
'\xEE', '\xCE', '\x86', '\xE4', '\x22', '\xAC', '\xC3', '\x01', '\xEA', '\xCF', '\x89', '\xE6', '\x1E', '\xA0', '\xF1', '\x1C',
'\xFB', '\xD8', '\x82', '\xF0', '\x14', '\xAB', '\xF2', '\x18', '\xE6', '\xD9', '\xC1', '\xE5', '\x10', '\xB5', '\xAD'})));
this->slotBackground->SetImage(std::string(OBFUSCATE_TEXT("유저인터페이스\\basic_interface\\itemwin_mid.bmp", 0x75ADC57D87EFBD8FULL)));
this->AddChild(this->slotBackground);
this->itemIcon = new CUIGameItem();
@ -600,7 +591,7 @@ void ExchangeUI::CUIItem::OnCreate(int width, int height) {
this->quantityText->SetText("");
this->quantityText->SetFitText(0);
this->quantityText->SetAlign(0, 6);
this->quantityText->SetFont(std::string(DecryptName<0xC517FB932D95BB6DULL>({'\x2A', '\xCE', '\xF9', '\x44', '\xFE', '\xFB'})));
this->quantityText->SetFont(std::string(OBFUSCATE_TEXT("Gulim", 0xC517FB932D95BB6DULL)));
this->quantityText->SetFontHeight(11);
this->quantityText->SetBold(0);
this->quantityText->SetColor(0);
@ -614,7 +605,7 @@ void ExchangeUI::CUIItem::OnCreate(int width, int height) {
this->itemNameText->SetText("");
this->itemNameText->SetFitText(1);
this->itemNameText->SetAlign(0, 6);
this->itemNameText->SetFont(std::string(DecryptName<0x23BBD58F8B5FF5C9ULL>({'\x8E', '\x80', '\x33', '\xE2', '\xE2', '\xD5'})));
this->itemNameText->SetFont(std::string(OBFUSCATE_TEXT("Gulim", 0x23BBD58F8B5FF5C9ULL)));
this->itemNameText->SetFontHeight(12);
this->itemNameText->SetBold(0);
this->itemNameText->SetColor(0);