diff --git a/Source/UI/ProbabilityTable/UIProbabilityTable.cpp b/Source/UI/ProbabilityTable/UIProbabilityTable.cpp index 8b19b653..4c319b74 100644 --- a/Source/UI/ProbabilityTable/UIProbabilityTable.cpp +++ b/Source/UI/ProbabilityTable/UIProbabilityTable.cpp @@ -31,7 +31,9 @@ namespace { template class EncryptedName { public: - explicit EncryptedName(const std::uint8_t (&source)[Length]) : m_encrypted(true) { + // INLINED + template + explicit EncryptedName(const Byte (&source)[Length]) : m_encrypted(true) { for (std::uint64_t index = 0; index < Length; ++index) { this->m_text[index] = source[index]; } @@ -59,7 +61,7 @@ private: // INLINED template -const char* DecryptName(const std::uint8_t (&source)[Length]) { +const char* DecryptName(const char (&source)[Length]) { thread_local EncryptedName name(source); return name.Text(); } @@ -552,22 +554,22 @@ void CUIProbabilityTable::Slot15(int width, int height) { this->m_titleBar = new CUITitleBar(); this->m_titleBar->SetSize(345, 17); this->m_titleBar->Move(0, 0); - const std::uint8_t titleRight[] = { - 0xAD, 0x14, 0x55, 0xD7, 0x53, 0x35, 0xD2, 0x08, 0xAB, 0x5F, 0x55, 0xE1, 0x2E, 0x41, 0x4B, 0xA7, - 0x0C, 0xC8, 0xFC, 0x4E, 0xCC, 0x92, 0x79, 0xB1, 0x08, 0xC9, 0xF3, 0x4C, 0xF0, 0x9E, 0x4B, 0xB1, - 0x04, 0xCF, 0xF9, 0x48, 0xF1, 0x9A, 0x65, 0x9A, 0x1F, 0xD2, 0xF2, 0x45, 0xE7, 0xD5, 0x75, 0xA8, - 0x1D, 0xBB + const char titleRight[] = { + '\xAD', '\x14', '\x55', '\xD7', '\x53', '\x35', '\xD2', '\x08', '\xAB', '\x5F', '\x55', '\xE1', '\x2E', '\x41', '\x4B', '\xA7', + '\x0C', '\xC8', '\xFC', '\x4E', '\xCC', '\x92', '\x79', '\xB1', '\x08', '\xC9', '\xF3', '\x4C', '\xF0', '\x9E', '\x4B', '\xB1', + '\x04', '\xCF', '\xF9', '\x48', '\xF1', '\x9A', '\x65', '\x9A', '\x1F', '\xD2', '\xF2', '\x45', '\xE7', '\xD5', '\x75', '\xA8', + '\x1D', '\xBB' }; - const std::uint8_t titleMiddle[] = { - 0x09, 0x5A, 0x9F, 0x71, 0x4F, 0x1B, 0x7E, 0xEE, 0x0F, 0x11, 0x9F, 0x47, 0x32, 0x6F, 0xE7, 0x41, - 0xA8, 0x86, 0x36, 0xE8, 0xD0, 0xBC, 0xD5, 0x57, 0xAC, 0x87, 0x39, 0xEA, 0xEC, 0xB0, 0xE7, 0x57, - 0xA0, 0x81, 0x33, 0xEE, 0xED, 0xB4, 0xC9, 0x7C, 0xA4, 0x9C, 0x3B, 0xA5, 0xED, 0xB8, 0xCB, 0x23 + const char titleMiddle[] = { + '\x09', '\x5A', '\x9F', '\x71', '\x4F', '\x1B', '\x7E', '\xEE', '\x0F', '\x11', '\x9F', '\x47', '\x32', '\x6F', '\xE7', '\x41', + '\xA8', '\x86', '\x36', '\xE8', '\xD0', '\xBC', '\xD5', '\x57', '\xAC', '\x87', '\x39', '\xEA', '\xEC', '\xB0', '\xE7', '\x57', + '\xA0', '\x81', '\x33', '\xEE', '\xED', '\xB4', '\xC9', '\x7C', '\xA4', '\x9C', '\x3B', '\xA5', '\xED', '\xB8', '\xCB', '\x23' }; - const std::uint8_t titleLeft[] = { - 0x47, 0xBC, 0xAB, 0x85, 0xF9, 0xC7, 0xB4, 0xC6, 0x41, 0xF7, 0xAB, 0xB3, 0x84, 0xB3, 0x2D, 0x69, - 0xE6, 0x60, 0x02, 0x1C, 0x66, 0x60, 0x1F, 0x7F, 0xE2, 0x61, 0x0D, 0x1E, 0x5A, 0x6C, 0x2D, 0x7F, - 0xEE, 0x67, 0x07, 0x1A, 0x5B, 0x68, 0x03, 0x54, 0xEB, 0x76, 0x0D, 0x0B, 0x17, 0x6B, 0x1C, 0x7B, - 0x87 + const char titleLeft[] = { + '\x47', '\xBC', '\xAB', '\x85', '\xF9', '\xC7', '\xB4', '\xC6', '\x41', '\xF7', '\xAB', '\xB3', '\x84', '\xB3', '\x2D', '\x69', + '\xE6', '\x60', '\x02', '\x1C', '\x66', '\x60', '\x1F', '\x7F', '\xE2', '\x61', '\x0D', '\x1E', '\x5A', '\x6C', '\x2D', '\x7F', + '\xEE', '\x67', '\x07', '\x1A', '\x5B', '\x68', '\x03', '\x54', '\xEB', '\x76', '\x0D', '\x0B', '\x17', '\x6B', '\x1C', '\x7B', + '\x87' }; this->m_titleBar->SetImages(std::string(DecryptName<0x0B7109397F6B1387ULL>(titleLeft)), std::string(DecryptName<0x23BBD58F8B5FF5C9ULL>(titleMiddle)), std::string(DecryptName<0xC517FB932D95BB6DULL>(titleRight))); this->AddChild(this->m_titleBar); @@ -575,12 +577,12 @@ void CUIProbabilityTable::Slot15(int width, int height) { CUIStaticText* title = new CUIStaticText(); title->SetSize(310, 17); title->Move(18, 0); - const std::uint8_t titleTextSource[] = {0x8B, 0x87, 0xE4, 0xDB, 0xF5, 0x0F, 0xB1, 0x29, 0xF0, 0x29}; + const char titleTextSource[] = {'\x8B', '\x87', '\xE4', '\xDB', '\xF5', '\x0F', '\xB1', '\x29', '\xF0', '\x29'}; const char* titleText = DecryptName<0x9949BFD527532943ULL>(titleTextSource); title->SetText(titleText, std::strlen(titleText)); title->SetFitText(0); title->SetAlign(0, 6); - const std::uint8_t titleFont[] = {0x28, 0x08, 0x97, 0x4A, 0x1C, 0x07}; + const char titleFont[] = {'\x28', '\x08', '\x97', '\x4A', '\x1C', '\x07'}; title->SetFont(std::string(DecryptName<0xCD8F077123FB7D6FULL>(titleFont))); title->SetFontHeight(12); title->SetBold(0); @@ -596,25 +598,25 @@ void CUIProbabilityTable::Slot15(int width, int height) { systemButton->SetOnClick([this]() { this->OnButtonClick(); }); systemButton->disabled = 0; systemButton->Invalidate(); - const std::uint8_t systemInactive[] = { - 0x5F, 0x6A, 0xAD, 0x51, 0x17, 0xE7, 0x38, 0x68, 0x59, 0x21, 0xAD, 0x67, 0x6A, 0x93, 0xA1, 0xC7, - 0xFE, 0xB6, 0x04, 0xC8, 0x88, 0x40, 0x93, 0xD1, 0xFA, 0xB7, 0x0B, 0xCA, 0xB4, 0x4C, 0xA1, 0xD6, - 0xE6, 0xB6, 0x32, 0xC9, 0xB6, 0x5A, 0x98, 0xFA, 0xF0, 0xA3, 0x0B, 0x85, 0xB5, 0x44, 0x8D, 0xA5 + const char systemInactive[] = { + '\x5F', '\x6A', '\xAD', '\x51', '\x17', '\xE7', '\x38', '\x68', '\x59', '\x21', '\xAD', '\x67', '\x6A', '\x93', '\xA1', '\xC7', + '\xFE', '\xB6', '\x04', '\xC8', '\x88', '\x40', '\x93', '\xD1', '\xFA', '\xB7', '\x0B', '\xCA', '\xB4', '\x4C', '\xA1', '\xD6', + '\xE6', '\xB6', '\x32', '\xC9', '\xB6', '\x5A', '\x98', '\xFA', '\xF0', '\xA3', '\x0B', '\x85', '\xB5', '\x44', '\x8D', '\xA5' }; - const std::uint8_t systemPressed[] = { - 0x31, 0x68, 0xF9, 0xF3, 0xD7, 0xB7, 0x8A, 0x3C, 0x37, 0x23, 0xF9, 0xC5, 0xAA, 0xC3, 0x13, 0x93, - 0x90, 0xB4, 0x50, 0x6A, 0x48, 0x10, 0x21, 0x85, 0x94, 0xB5, 0x5F, 0x68, 0x74, 0x1C, 0x13, 0x82, - 0x88, 0xB4, 0x66, 0x6B, 0x76, 0x0A, 0x2A, 0xAE, 0x9E, 0xA9, 0x17, 0x6B, 0x7A, 0x09, 0x4F + const char systemPressed[] = { + '\x31', '\x68', '\xF9', '\xF3', '\xD7', '\xB7', '\x8A', '\x3C', '\x37', '\x23', '\xF9', '\xC5', '\xAA', '\xC3', '\x13', '\x93', + '\x90', '\xB4', '\x50', '\x6A', '\x48', '\x10', '\x21', '\x85', '\x94', '\xB5', '\x5F', '\x68', '\x74', '\x1C', '\x13', '\x82', + '\x88', '\xB4', '\x66', '\x6B', '\x76', '\x0A', '\x2A', '\xAE', '\x9E', '\xA9', '\x17', '\x6B', '\x7A', '\x09', '\x4F' }; - const std::uint8_t systemHover[] = { - 0xF7, 0xE8, 0x6D, 0xC3, 0x7F, 0x2B, 0x6C, 0xDA, 0xF1, 0xA3, 0x6D, 0xF5, 0x02, 0x5F, 0xF5, 0x75, - 0x56, 0x34, 0xC4, 0x5A, 0xE0, 0x8C, 0xC7, 0x63, 0x52, 0x35, 0xCB, 0x58, 0xDC, 0x80, 0xF5, 0x64, - 0x4E, 0x34, 0xF2, 0x5B, 0xDE, 0x96, 0xCC, 0x48, 0x58, 0x29, 0x83, 0x5B, 0xD2, 0x95, 0xA9 + const char systemHover[] = { + '\xF7', '\xE8', '\x6D', '\xC3', '\x7F', '\x2B', '\x6C', '\xDA', '\xF1', '\xA3', '\x6D', '\xF5', '\x02', '\x5F', '\xF5', '\x75', + '\x56', '\x34', '\xC4', '\x5A', '\xE0', '\x8C', '\xC7', '\x63', '\x52', '\x35', '\xCB', '\x58', '\xDC', '\x80', '\xF5', '\x64', + '\x4E', '\x34', '\xF2', '\x5B', '\xDE', '\x96', '\xCC', '\x48', '\x58', '\x29', '\x83', '\x5B', '\xD2', '\x95', '\xA9' }; - const std::uint8_t systemNormal[] = { - 0xA7, 0x04, 0x51, 0x5F, 0x61, 0xF1, 0x26, 0xDE, 0xA1, 0x4F, 0x51, 0x69, 0x1C, 0x85, 0xBF, 0x71, - 0x06, 0xD8, 0xF8, 0xC6, 0xFE, 0x56, 0x8D, 0x67, 0x02, 0xD9, 0xF7, 0xC4, 0xC2, 0x5A, 0xBF, 0x60, - 0x1E, 0xD8, 0xCE, 0xC7, 0xC0, 0x4C, 0x86, 0x4C, 0x08, 0xCD, 0xF7, 0x8B, 0xC3, 0x52, 0x93, 0x13 + const char systemNormal[] = { + '\xA7', '\x04', '\x51', '\x5F', '\x61', '\xF1', '\x26', '\xDE', '\xA1', '\x4F', '\x51', '\x69', '\x1C', '\x85', '\xBF', '\x71', + '\x06', '\xD8', '\xF8', '\xC6', '\xFE', '\x56', '\x8D', '\x67', '\x02', '\xD9', '\xF7', '\xC4', '\xC2', '\x5A', '\xBF', '\x60', + '\x1E', '\xD8', '\xCE', '\xC7', '\xC0', '\x4C', '\x86', '\x4C', '\x08', '\xCD', '\xF7', '\x8B', '\xC3', '\x52', '\x93', '\x13' }; systemButton->SetImages( std::string(DecryptName<0x13E33FA1A591AB67ULL>(systemNormal)), std::string(DecryptName<0x17A9E5BF39AD4737ULL>(systemHover)), @@ -628,27 +630,27 @@ void CUIProbabilityTable::Slot15(int width, int height) { closeButton->SetOnClick([this]() { this->OnClose(); }); closeButton->disabled = 0; closeButton->Invalidate(); - const std::uint8_t closeInactive[] = { - 0x67, 0x5A, 0xBF, 0xC3, 0xF1, 0x85, 0xEE, 0x72, 0x61, 0x11, 0xBF, 0xF5, 0x8C, 0xF1, 0x77, 0xDD, - 0xC6, 0x86, 0x16, 0x5A, 0x6E, 0x22, 0x45, 0xCB, 0xC2, 0x87, 0x19, 0x58, 0x52, 0x2E, 0x77, 0xCC, - 0xDE, 0x86, 0x20, 0x5A, 0x5D, 0x24, 0x58, 0xDA, 0xF8, 0x9A, 0x19, 0x5F, 0x1F, 0x29, 0x46, 0xCF, - 0xA7 + const char closeInactive[] = { + '\x67', '\x5A', '\xBF', '\xC3', '\xF1', '\x85', '\xEE', '\x72', '\x61', '\x11', '\xBF', '\xF5', '\x8C', '\xF1', '\x77', '\xDD', + '\xC6', '\x86', '\x16', '\x5A', '\x6E', '\x22', '\x45', '\xCB', '\xC2', '\x87', '\x19', '\x58', '\x52', '\x2E', '\x77', '\xCC', + '\xDE', '\x86', '\x20', '\x5A', '\x5D', '\x24', '\x58', '\xDA', '\xF8', '\x9A', '\x19', '\x5F', '\x1F', '\x29', '\x46', '\xCF', + '\xA7' }; - const std::uint8_t closePressed[] = { - 0x7D, 0x12, 0x2D, 0xCD, 0x7B, 0x71, 0x2A, 0x4E, 0x7B, 0x59, 0x2D, 0xFB, 0x06, 0x05, 0xB3, 0xE1, - 0xDC, 0xCE, 0x84, 0x54, 0xE4, 0xD6, 0x81, 0xF7, 0xD8, 0xCF, 0x8B, 0x56, 0xD8, 0xDA, 0xB3, 0xF0, - 0xC4, 0xCE, 0xB2, 0x54, 0xD7, 0xD0, 0x9C, 0xE6, 0xE2, 0xD2, 0x83, 0x19, 0xD9, 0xD2, 0x9F, 0x83 + const char closePressed[] = { + '\x7D', '\x12', '\x2D', '\xCD', '\x7B', '\x71', '\x2A', '\x4E', '\x7B', '\x59', '\x2D', '\xFB', '\x06', '\x05', '\xB3', '\xE1', + '\xDC', '\xCE', '\x84', '\x54', '\xE4', '\xD6', '\x81', '\xF7', '\xD8', '\xCF', '\x8B', '\x56', '\xD8', '\xDA', '\xB3', '\xF0', + '\xC4', '\xCE', '\xB2', '\x54', '\xD7', '\xD0', '\x9C', '\xE6', '\xE2', '\xD2', '\x83', '\x19', '\xD9', '\xD2', '\x9F', '\x83' }; - const std::uint8_t closeHover[] = { - 0xBF, 0xBC, 0x1F, 0x2B, 0x45, 0xA9, 0xBC, 0x20, 0xB9, 0xF7, 0x1F, 0x1D, 0x38, 0xDD, 0x25, 0x8F, - 0x1E, 0x60, 0xB6, 0xB2, 0xDA, 0x0E, 0x17, 0x99, 0x1A, 0x61, 0xB9, 0xB0, 0xE6, 0x02, 0x25, 0x9E, - 0x06, 0x60, 0x80, 0xB2, 0xE9, 0x08, 0x0A, 0x88, 0x20, 0x7C, 0xB1, 0xFF, 0xE7, 0x0A, 0x09, 0xED + const char closeHover[] = { + '\xBF', '\xBC', '\x1F', '\x2B', '\x45', '\xA9', '\xBC', '\x20', '\xB9', '\xF7', '\x1F', '\x1D', '\x38', '\xDD', '\x25', '\x8F', + '\x1E', '\x60', '\xB6', '\xB2', '\xDA', '\x0E', '\x17', '\x99', '\x1A', '\x61', '\xB9', '\xB0', '\xE6', '\x02', '\x25', '\x9E', + '\x06', '\x60', '\x80', '\xB2', '\xE9', '\x08', '\x0A', '\x88', '\x20', '\x7C', '\xB1', '\xFF', '\xE7', '\x0A', '\x09', '\xED' }; - const std::uint8_t closeNormal[] = { - 0xC9, 0x88, 0xEF, 0x41, 0x7D, 0x93, 0xB8, 0x14, 0xCF, 0xC3, 0xEF, 0x77, 0x00, 0xE7, 0x21, 0xBB, - 0x68, 0x54, 0x46, 0xD8, 0xE2, 0x34, 0x13, 0xAD, 0x6C, 0x55, 0x49, 0xDA, 0xDE, 0x38, 0x21, 0xAA, - 0x70, 0x54, 0x70, 0xD8, 0xD1, 0x32, 0x0E, 0xBC, 0x56, 0x48, 0x49, 0xDD, 0x93, 0x3F, 0x10, 0xA9, - 0x09 + const char closeNormal[] = { + '\xC9', '\x88', '\xEF', '\x41', '\x7D', '\x93', '\xB8', '\x14', '\xCF', '\xC3', '\xEF', '\x77', '\x00', '\xE7', '\x21', '\xBB', + '\x68', '\x54', '\x46', '\xD8', '\xE2', '\x34', '\x13', '\xAD', '\x6C', '\x55', '\x49', '\xDA', '\xDE', '\x38', '\x21', '\xAA', + '\x70', '\x54', '\x70', '\xD8', '\xD1', '\x32', '\x0E', '\xBC', '\x56', '\x48', '\x49', '\xDD', '\x93', '\x3F', '\x10', '\xA9', + '\x09' }; closeButton->SetImages( std::string(DecryptName<0xD97D5DBDBB2F2709ULL>(closeNormal)), std::string(DecryptName<0xED796785D1DF137FULL>(closeHover)), @@ -659,12 +661,12 @@ void CUIProbabilityTable::Slot15(int width, int height) { this->m_nameHeader = new CUIStaticText(); this->m_nameHeader->SetSize(160, 18); this->m_nameHeader->Move(10, 30); - const std::uint8_t nameHeaderSource[] = {0x50, 0xC3, 0x45, 0x6D, 0x12, 0xA3, 0x19, 0x6D, 0x2A, 0xC0, 0x0F, 0xD7}; + const char nameHeaderSource[] = {'\x50', '\xC3', '\x45', '\x6D', '\x12', '\xA3', '\x19', '\x6D', '\x2A', '\xC0', '\x0F', '\xD7'}; const char* nameHeaderText = DecryptName<0xDD3913D5D7F97BE1ULL>(nameHeaderSource); this->m_nameHeader->SetText(nameHeaderText, std::strlen(nameHeaderText)); this->m_nameHeader->SetFitText(0); this->m_nameHeader->SetAlign(2, 6); - const std::uint8_t nameHeaderFont[] = {0xDC, 0x22, 0x6F, 0xF0, 0x0A, 0x05}; + const char nameHeaderFont[] = {'\xDC', '\x22', '\x6F', '\xF0', '\x0A', '\x05'}; this->m_nameHeader->SetFont(std::string(DecryptName<0x050505679903579BULL>(nameHeaderFont))); this->m_nameHeader->SetFontHeight(12); this->m_nameHeader->SetBold(0); @@ -694,29 +696,29 @@ void CUIProbabilityTable::Slot15(int width, int height) { this->m_searchButton->SetOnClick([this]() { this->Search(); }); this->m_searchButton->disabled = 0; this->m_searchButton->Invalidate(); - const std::uint8_t searchInactive[] = { - 0x4F, 0x36, 0x2B, 0xF7, 0x75, 0xB1, 0x3A, 0xF4, 0x49, 0x7D, 0x2B, 0xC1, 0x08, 0xC5, 0xA3, 0x57, - 0xEE, 0xEF, 0x82, 0x6A, 0xD4, 0x0B, 0x96, 0x56, 0xE1, 0xC6, 0x82, 0x63, 0xC1, 0x1A, 0x8D, 0x5F, - 0xEE, 0xFA, 0x8E, 0x3E, 0xE9, 0x1D, 0x8B, 0x57, 0xD0, 0xEA, 0x8E, 0x6C, 0xC7, 0x1C, 0x97, 0x5B, - 0xEE, 0xEB, 0xB4, 0x63, 0xDA, 0x0D, 0x92, 0x58, 0xE3, 0xB7, 0x89, 0x60, 0xC5, 0x7F + const char searchInactive[] = { + '\x4F', '\x36', '\x2B', '\xF7', '\x75', '\xB1', '\x3A', '\xF4', '\x49', '\x7D', '\x2B', '\xC1', '\x08', '\xC5', '\xA3', '\x57', + '\xEE', '\xEF', '\x82', '\x6A', '\xD4', '\x0B', '\x96', '\x56', '\xE1', '\xC6', '\x82', '\x63', '\xC1', '\x1A', '\x8D', '\x5F', + '\xEE', '\xFA', '\x8E', '\x3E', '\xE9', '\x1D', '\x8B', '\x57', '\xD0', '\xEA', '\x8E', '\x6C', '\xC7', '\x1C', '\x97', '\x5B', + '\xEE', '\xEB', '\xB4', '\x63', '\xDA', '\x0D', '\x92', '\x58', '\xE3', '\xB7', '\x89', '\x60', '\xC5', '\x7F' }; - const std::uint8_t searchPressed[] = { - 0x57, 0x5E, 0x21, 0x27, 0x11, 0x5D, 0x2C, 0xE2, 0x51, 0x15, 0x21, 0x11, 0x6C, 0x29, 0xB5, 0x41, - 0xF6, 0x87, 0x88, 0xBA, 0xB0, 0xE7, 0x80, 0x40, 0xF9, 0xAE, 0x88, 0xB3, 0xA5, 0xF6, 0x9B, 0x49, - 0xF6, 0x92, 0x84, 0xEE, 0x8D, 0xF1, 0x9D, 0x41, 0xC8, 0x82, 0x84, 0xBC, 0xA3, 0xF0, 0x81, 0x4D, - 0xF6, 0x83, 0xBE, 0xB2, 0xA7, 0xF6, 0x9B, 0x01, 0xF5, 0x9C, 0x91, 0xDD + const char searchPressed[] = { + '\x57', '\x5E', '\x21', '\x27', '\x11', '\x5D', '\x2C', '\xE2', '\x51', '\x15', '\x21', '\x11', '\x6C', '\x29', '\xB5', '\x41', + '\xF6', '\x87', '\x88', '\xBA', '\xB0', '\xE7', '\x80', '\x40', '\xF9', '\xAE', '\x88', '\xB3', '\xA5', '\xF6', '\x9B', '\x49', + '\xF6', '\x92', '\x84', '\xEE', '\x8D', '\xF1', '\x9D', '\x41', '\xC8', '\x82', '\x84', '\xBC', '\xA3', '\xF0', '\x81', '\x4D', + '\xF6', '\x83', '\xBE', '\xB2', '\xA7', '\xF6', '\x9B', '\x01', '\xF5', '\x9C', '\x91', '\xDD' }; - const std::uint8_t searchHover[] = { - 0x0D, 0x5E, 0x59, 0x4F, 0x4D, 0x95, 0xC2, 0x60, 0x0B, 0x15, 0x59, 0x79, 0x30, 0xE1, 0x5B, 0xC3, - 0xAC, 0x87, 0xF0, 0xD2, 0xEC, 0x2F, 0x6E, 0xC2, 0xA3, 0xAE, 0xF0, 0xDB, 0xF9, 0x3E, 0x75, 0xCB, - 0xAC, 0x92, 0xFC, 0x86, 0xD1, 0x39, 0x73, 0xC3, 0x92, 0x82, 0xFC, 0xD4, 0xFF, 0x38, 0x6F, 0xCF, - 0xAC, 0x83, 0xC6, 0xC5, 0xFF, 0x3E, 0x74, 0xDE, 0xE3, 0x93, 0xF4, 0xC5, 0x8D + const char searchHover[] = { + '\x0D', '\x5E', '\x59', '\x4F', '\x4D', '\x95', '\xC2', '\x60', '\x0B', '\x15', '\x59', '\x79', '\x30', '\xE1', '\x5B', '\xC3', + '\xAC', '\x87', '\xF0', '\xD2', '\xEC', '\x2F', '\x6E', '\xC2', '\xA3', '\xAE', '\xF0', '\xDB', '\xF9', '\x3E', '\x75', '\xCB', + '\xAC', '\x92', '\xFC', '\x86', '\xD1', '\x39', '\x73', '\xC3', '\x92', '\x82', '\xFC', '\xD4', '\xFF', '\x38', '\x6F', '\xCF', + '\xAC', '\x83', '\xC6', '\xC5', '\xFF', '\x3E', '\x74', '\xDE', '\xE3', '\x93', '\xF4', '\xC5', '\x8D' }; - const std::uint8_t searchNormal[] = { - 0xBF, 0xBA, 0x4D, 0xEB, 0xF7, 0xC1, 0x4E, 0xE2, 0xB9, 0xF1, 0x4D, 0xDD, 0x8A, 0xB5, 0xD7, 0x41, - 0x1E, 0x63, 0xE4, 0x76, 0x56, 0x7B, 0xE2, 0x40, 0x11, 0x4A, 0xE4, 0x7F, 0x43, 0x6A, 0xF9, 0x49, - 0x1E, 0x76, 0xE8, 0x22, 0x6B, 0x6D, 0xFF, 0x41, 0x20, 0x66, 0xE8, 0x70, 0x45, 0x6C, 0xE3, 0x4D, - 0x1E, 0x67, 0xD2, 0x7F, 0x58, 0x7D, 0xE6, 0x4E, 0x13, 0x3B, 0xEF, 0x7C, 0x47, 0x0F + const char searchNormal[] = { + '\xBF', '\xBA', '\x4D', '\xEB', '\xF7', '\xC1', '\x4E', '\xE2', '\xB9', '\xF1', '\x4D', '\xDD', '\x8A', '\xB5', '\xD7', '\x41', + '\x1E', '\x63', '\xE4', '\x76', '\x56', '\x7B', '\xE2', '\x40', '\x11', '\x4A', '\xE4', '\x7F', '\x43', '\x6A', '\xF9', '\x49', + '\x1E', '\x76', '\xE8', '\x22', '\x6B', '\x6D', '\xFF', '\x41', '\x20', '\x66', '\xE8', '\x70', '\x45', '\x6C', '\xE3', '\x4D', + '\x1E', '\x67', '\xD2', '\x7F', '\x58', '\x7D', '\xE6', '\x4E', '\x13', '\x3B', '\xEF', '\x7C', '\x47', '\x0F' }; this->m_searchButton->SetImages( std::string(DecryptName<0x2F8B0F37118D157FULL>(searchNormal)), std::string(DecryptName<0xAD075B8DB599F1CDULL>(searchHover)), @@ -730,7 +732,7 @@ void CUIProbabilityTable::Slot15(int width, int height) { this->m_itemName->SetText("", 0); this->m_itemName->SetFitText(1); this->m_itemName->SetAlign(6, 6); - const std::uint8_t itemNameFont[] = {0x2C, 0xCC, 0xAB, 0x66, 0x0A, 0x8F}; + const char itemNameFont[] = {'\x2C', '\xCC', '\xAB', '\x66', '\x0A', '\x8F'}; this->m_itemName->SetFont(std::string(DecryptName<0xB7FD8F670FC7B96BULL>(itemNameFont))); this->m_itemName->SetFontHeight(12); this->m_itemName->SetBold(1); @@ -742,12 +744,12 @@ void CUIProbabilityTable::Slot15(int width, int height) { this->m_probabilityHeader = new CUIStaticText(); this->m_probabilityHeader->SetSize(68, 24); this->m_probabilityHeader->Move(248, 61); - const std::uint8_t probabilityHeaderSource[] = {0x35, 0x79, 0xFA, 0x55, 0xB5}; + const char probabilityHeaderSource[] = {'\x35', '\x79', '\xFA', '\x55', '\xB5'}; const char* probabilityHeaderText = DecryptName<0xE7978FB5A94DD7FDULL>(probabilityHeaderSource); this->m_probabilityHeader->SetText(probabilityHeaderText, std::strlen(probabilityHeaderText)); this->m_probabilityHeader->SetFitText(1); this->m_probabilityHeader->SetAlign(6, 6); - const std::uint8_t probabilityHeaderFont[] = {0xBA, 0xCC, 0xD7, 0x48, 0xF2, 0xFD}; + const char probabilityHeaderFont[] = {'\xBA', '\xCC', '\xD7', '\x48', '\xF2', '\xFD'}; this->m_probabilityHeader->SetFont(std::string(DecryptName<0x4941FD9F21BBB9FDULL>(probabilityHeaderFont))); this->m_probabilityHeader->SetFontHeight(12); this->m_probabilityHeader->SetBold(0); @@ -769,34 +771,34 @@ void CUIProbabilityTable::Slot15(int width, int height) { this->m_list->scrollBar->SetSize(13, 360); this->m_list->scrollBar->Move(312, 0); this->m_list->scrollBar->step = 30; - const std::uint8_t scrollDown[] = { - 0x8F, 0xC8, 0x2D, 0x7F, 0xC9, 0xF9, 0xFA, 0xB4, 0x89, 0x83, 0x2D, 0x49, 0xB4, 0x8D, 0x63, 0x0A, - 0x2C, 0x15, 0x82, 0xE9, 0x65, 0x07, 0x5B, 0x16, 0x38, 0x09, 0xC3, 0xE7, 0x64, 0x47, 0x3F + const char scrollDown[] = { + '\x8F', '\xC8', '\x2D', '\x7F', '\xC9', '\xF9', '\xFA', '\xB4', '\x89', '\x83', '\x2D', '\x49', '\xB4', '\x8D', '\x63', '\x0A', + '\x2C', '\x15', '\x82', '\xE9', '\x65', '\x07', '\x5B', '\x16', '\x38', '\x09', '\xC3', '\xE7', '\x64', '\x47', '\x3F' }; - const std::uint8_t scrollUp[] = { - 0xB5, 0x62, 0x2D, 0xA7, 0xAB, 0xAB, 0x20, 0xF8, 0xB3, 0x29, 0x2D, 0x91, 0xD6, 0xDF, 0xB9, 0x46, - 0x16, 0xBF, 0x82, 0x31, 0x07, 0x55, 0x90, 0x45, 0x5B, 0xAF, 0x80, 0x2D, 0x6B + const char scrollUp[] = { + '\xB5', '\x62', '\x2D', '\xA7', '\xAB', '\xAB', '\x20', '\xF8', '\xB3', '\x29', '\x2D', '\x91', '\xD6', '\xDF', '\xB9', '\x46', + '\x16', '\xBF', '\x82', '\x31', '\x07', '\x55', '\x90', '\x45', '\x5B', '\xAF', '\x80', '\x2D', '\x6B' }; this->m_list->scrollBar->SetButtonImages(std::string(DecryptName<0x35E5656B5DEDCD75ULL>(scrollUp)), std::string(DecryptName<0x793F370985ED674FULL>(scrollDown))); - const std::uint8_t scrollMiddle[] = { - 0xDD, 0xAA, 0x53, 0xD3, 0xB1, 0xED, 0x92, 0x28, 0xDB, 0xE1, 0x53, 0xE5, 0xCC, 0x99, 0x0B, 0x96, - 0x7E, 0x77, 0xFC, 0x45, 0x1D, 0x13, 0x3A, 0x8C, 0x79, 0x2B, 0xF1, 0x44, 0x01, 0x23 + const char scrollMiddle[] = { + '\xDD', '\xAA', '\x53', '\xD3', '\xB1', '\xED', '\x92', '\x28', '\xDB', '\xE1', '\x53', '\xE5', '\xCC', '\x99', '\x0B', '\x96', + '\x7E', '\x77', '\xFC', '\x45', '\x1D', '\x13', '\x3A', '\x8C', '\x79', '\x2B', '\xF1', '\x44', '\x01', '\x23' }; this->m_list->scrollBar->SetBackground(std::string(DecryptName<0xE55723712993051DULL>(scrollMiddle))); - const std::uint8_t thumbBottom[] = { - 0x8F, 0x0E, 0x0F, 0xCF, 0xA3, 0x19, 0x84, 0xB4, 0x89, 0x45, 0x0F, 0xF9, 0xDE, 0x6D, 0x1D, 0x0A, - 0x2C, 0xD3, 0xA0, 0x59, 0x0F, 0xE7, 0x23, 0x18, 0x3D, 0xFE, 0xAB, 0x5A, 0x14, 0xB9, 0x6F, 0x1B, - 0x22, 0xD1, 0xCF + const char thumbBottom[] = { + '\x8F', '\x0E', '\x0F', '\xCF', '\xA3', '\x19', '\x84', '\xB4', '\x89', '\x45', '\x0F', '\xF9', '\xDE', '\x6D', '\x1D', '\x0A', + '\x2C', '\xD3', '\xA0', '\x59', '\x0F', '\xE7', '\x23', '\x18', '\x3D', '\xFE', '\xAB', '\x5A', '\x14', '\xB9', '\x6F', '\x1B', + '\x22', '\xD1', '\xCF' }; - const std::uint8_t thumbMiddle[] = { - 0xA3, 0x5A, 0x21, 0x85, 0xFB, 0xEB, 0xD8, 0x06, 0xA5, 0x11, 0x21, 0xB3, 0x86, 0x9F, 0x41, 0xB8, - 0x00, 0x87, 0x8E, 0x13, 0x57, 0x15, 0x7F, 0xAA, 0x11, 0xAA, 0x8C, 0x16, 0x5F, 0x0B, 0x7F, 0xA6, - 0x13, 0xF5 + const char thumbMiddle[] = { + '\xA3', '\x5A', '\x21', '\x85', '\xFB', '\xEB', '\xD8', '\x06', '\xA5', '\x11', '\x21', '\xB3', '\x86', '\x9F', '\x41', '\xB8', + '\x00', '\x87', '\x8E', '\x13', '\x57', '\x15', '\x7F', '\xAA', '\x11', '\xAA', '\x8C', '\x16', '\x5F', '\x0B', '\x7F', '\xA6', + '\x13', '\xF5' }; - const std::uint8_t thumbTop[] = { - 0x09, 0xBC, 0x39, 0x89, 0x39, 0x17, 0xD0, 0xBC, 0x0F, 0xF7, 0x39, 0xBF, 0x44, 0x63, 0x49, 0x02, - 0xAA, 0x61, 0x96, 0x1F, 0x95, 0xE9, 0x77, 0x10, 0xBB, 0x4C, 0x8C, 0x03, 0xD7, 0xBB, 0x78, 0x01, - 0xC9 + const char thumbTop[] = { + '\x09', '\xBC', '\x39', '\x89', '\x39', '\x17', '\xD0', '\xBC', '\x0F', '\xF7', '\x39', '\xBF', '\x44', '\x63', '\x49', '\x02', + '\xAA', '\x61', '\x96', '\x1F', '\x95', '\xE9', '\x77', '\x10', '\xBB', '\x4C', '\x8C', '\x03', '\xD7', '\xBB', '\x78', '\x01', + '\xC9' }; this->m_list->scrollBar->SetThumbImages( std::string(DecryptName<0x7115D9F973F913C9ULL>(thumbTop)), std::string(DecryptName<0xCB1D253B7FE1F563ULL>(thumbMiddle)), std::string(DecryptName<0x7941D76335CFA14FULL>(thumbBottom)) diff --git a/Source/UI/Quest/UIRenewQuestUI.cpp b/Source/UI/Quest/UIRenewQuestUI.cpp index f445f3fe..87b08a0f 100644 --- a/Source/UI/Quest/UIRenewQuestUI.cpp +++ b/Source/UI/Quest/UIRenewQuestUI.cpp @@ -28,7 +28,9 @@ static bool s_recommendedTabFirstSelect = true; template class EncryptedName { public: - explicit EncryptedName(const std::uint8_t (&source)[Length]) : m_encrypted(true) { + // INLINED + template + explicit EncryptedName(const Byte (&source)[Length]) : m_encrypted(true) { for (std::uint64_t index = 0; index < Length; ++index) { this->m_text[index] = source[index]; } @@ -56,7 +58,7 @@ private: // INLINED template -const char* DecryptName(const std::uint8_t (&source)[Length]) { +const char* DecryptName(const char (&source)[Length]) { thread_local EncryptedName name(source); return name.Text(); } @@ -420,7 +422,7 @@ EncryptedName<6, 0x114901C7E37F6D49ULL>& GulimFontName1() { // OFFSET: 0x00A5A620 // FUNCTION: fn_16401 EncryptedName<48, 0x136F2F9915D1DBCFULL>& NormalOffButtonName1() { - const std::uint8_t source[] = {0x0F, 0x74, 0x11, 0xEF, 0x59, 0xE1, 0xAA, 0xDE, 0x09, 0x3F, 0x11, 0xD9, 0x24, 0x95, 0x33, 0x41, 0xAA, 0xB5, 0xB4, 0x62, 0xC6, 0x7E, 0x1A, 0x76, 0xBC, 0xAF, 0x84, 0x5C, 0xC5, 0x4D, 0x1B, 0x7D, 0x90, 0xB5, 0xBE, 0x67, 0xF4, 0x4E, 0x03, 0x4C, 0xA0, 0xBD, 0xB7, 0x3B, 0xFB, 0x42, 0x1F, 0x13}; + const char source[] = {'\x0F', '\x74', '\x11', '\xEF', '\x59', '\xE1', '\xAA', '\xDE', '\x09', '\x3F', '\x11', '\xD9', '\x24', '\x95', '\x33', '\x41', '\xAA', '\xB5', '\xB4', '\x62', '\xC6', '\x7E', '\x1A', '\x76', '\xBC', '\xAF', '\x84', '\x5C', '\xC5', '\x4D', '\x1B', '\x7D', '\x90', '\xB5', '\xBE', '\x67', '\xF4', '\x4E', '\x03', '\x4C', '\xA0', '\xBD', '\xB7', '\x3B', '\xFB', '\x42', '\x1F', '\x13'}; thread_local EncryptedName name(source); return name; } @@ -428,7 +430,7 @@ EncryptedName<48, 0x136F2F9915D1DBCFULL>& NormalOffButtonName1() { // OFFSET: 0x00A5A700 // FUNCTION: fn_16402 EncryptedName<47, 0x0B23D10F2F49D72BULL>& NormalOnButtonName() { - const std::uint8_t source[] = {0xEB, 0x78, 0x89, 0xD5, 0xCF, 0x1F, 0xE6, 0xC6, 0xED, 0x33, 0x89, 0xE3, 0xB2, 0x6B, 0x7F, 0x59, 0x4E, 0xB9, 0x2C, 0x58, 0x50, 0x80, 0x56, 0x6E, 0x58, 0xA3, 0x1C, 0x66, 0x53, 0xB3, 0x57, 0x65, 0x74, 0xB9, 0x26, 0x5D, 0x62, 0xB0, 0x4F, 0x54, 0x44, 0xB9, 0x67, 0x4D, 0x62, 0xA1, 0x23}; + const char source[] = {'\xEB', '\x78', '\x89', '\xD5', '\xCF', '\x1F', '\xE6', '\xC6', '\xED', '\x33', '\x89', '\xE3', '\xB2', '\x6B', '\x7F', '\x59', '\x4E', '\xB9', '\x2C', '\x58', '\x50', '\x80', '\x56', '\x6E', '\x58', '\xA3', '\x1C', '\x66', '\x53', '\xB3', '\x57', '\x65', '\x74', '\xB9', '\x26', '\x5D', '\x62', '\xB0', '\x4F', '\x54', '\x44', '\xB9', '\x67', '\x4D', '\x62', '\xA1', '\x23'}; thread_local EncryptedName name(source); return name; } @@ -436,7 +438,7 @@ EncryptedName<47, 0x0B23D10F2F49D72BULL>& NormalOnButtonName() { // OFFSET: 0x00A5A7F0 // FUNCTION: fn_16403 EncryptedName<48, 0x674D9F3975573D41ULL>& NormalOffButtonName2() { - const std::uint8_t source[] = {0x81, 0x92, 0x97, 0x8F, 0xF9, 0x51, 0x88, 0xAA, 0x87, 0xD9, 0x97, 0xB9, 0x84, 0x25, 0x11, 0x35, 0x24, 0x53, 0x32, 0x02, 0x66, 0xCE, 0x38, 0x02, 0x32, 0x49, 0x02, 0x3C, 0x65, 0xFD, 0x39, 0x09, 0x1E, 0x53, 0x38, 0x07, 0x54, 0xFE, 0x21, 0x38, 0x2E, 0x5B, 0x31, 0x5B, 0x5B, 0xF2, 0x3D, 0x67}; + const char source[] = {'\x81', '\x92', '\x97', '\x8F', '\xF9', '\x51', '\x88', '\xAA', '\x87', '\xD9', '\x97', '\xB9', '\x84', '\x25', '\x11', '\x35', '\x24', '\x53', '\x32', '\x02', '\x66', '\xCE', '\x38', '\x02', '\x32', '\x49', '\x02', '\x3C', '\x65', '\xFD', '\x39', '\x09', '\x1E', '\x53', '\x38', '\x07', '\x54', '\xFE', '\x21', '\x38', '\x2E', '\x5B', '\x31', '\x5B', '\x5B', '\xF2', '\x3D', '\x67'}; thread_local EncryptedName name(source); return name; } @@ -444,7 +446,7 @@ EncryptedName<48, 0x674D9F3975573D41ULL>& NormalOffButtonName2() { // OFFSET: 0x00A5A8D0 // FUNCTION: fn_16404 EncryptedName<48, 0x6BDF334F2BFDAD51ULL>& NormalOffButtonName3() { - const std::uint8_t source[] = {0x91, 0x02, 0x3D, 0xD1, 0x8F, 0xFD, 0x1A, 0xA6, 0x97, 0x49, 0x3D, 0xE7, 0xF2, 0x89, 0x83, 0x39, 0x34, 0xC3, 0x98, 0x5C, 0x10, 0x62, 0xAA, 0x0E, 0x22, 0xD9, 0xA8, 0x62, 0x13, 0x51, 0xAB, 0x05, 0x0E, 0xC3, 0x92, 0x59, 0x22, 0x52, 0xB3, 0x34, 0x3E, 0xCB, 0x9B, 0x05, 0x2D, 0x5E, 0xAF, 0x6B}; + const char source[] = {'\x91', '\x02', '\x3D', '\xD1', '\x8F', '\xFD', '\x1A', '\xA6', '\x97', '\x49', '\x3D', '\xE7', '\xF2', '\x89', '\x83', '\x39', '\x34', '\xC3', '\x98', '\x5C', '\x10', '\x62', '\xAA', '\x0E', '\x22', '\xD9', '\xA8', '\x62', '\x13', '\x51', '\xAB', '\x05', '\x0E', '\xC3', '\x92', '\x59', '\x22', '\x52', '\xB3', '\x34', '\x3E', '\xCB', '\x9B', '\x05', '\x2D', '\x5E', '\xAF', '\x6B'}; thread_local EncryptedName name(source); return name; } @@ -460,7 +462,7 @@ EncryptedName<6, 0xB7AFBD2FD9FD7501ULL>& GulimFontName2() { // OFFSET: 0x00A5AA80 // FUNCTION: fn_16406 EncryptedName<45, 0x79E915E9AF6F55DDULL>& SubOffButtonName1() { - const std::uint8_t source[] = {0x1D, 0xFA, 0xAF, 0x55, 0x29, 0xDB, 0x2C, 0xB4, 0x1B, 0xB1, 0xAF, 0x63, 0x54, 0xAF, 0xB5, 0x2B, 0xB8, 0x3B, 0x0A, 0xD8, 0xB6, 0x44, 0x9C, 0x1C, 0xAE, 0x21, 0x3A, 0xE6, 0xB5, 0x77, 0x9D, 0x17, 0x82, 0x26, 0x1A, 0xCD, 0xB6, 0x7A, 0x8F, 0x1F, 0xF3, 0x37, 0x02, 0xDF, 0xE9}; + const char source[] = {'\x1D', '\xFA', '\xAF', '\x55', '\x29', '\xDB', '\x2C', '\xB4', '\x1B', '\xB1', '\xAF', '\x63', '\x54', '\xAF', '\xB5', '\x2B', '\xB8', '\x3B', '\x0A', '\xD8', '\xB6', '\x44', '\x9C', '\x1C', '\xAE', '\x21', '\x3A', '\xE6', '\xB5', '\x77', '\x9D', '\x17', '\x82', '\x26', '\x1A', '\xCD', '\xB6', '\x7A', '\x8F', '\x1F', '\xF3', '\x37', '\x02', '\xDF', '\xE9'}; thread_local EncryptedName name(source); return name; } @@ -468,7 +470,7 @@ EncryptedName<45, 0x79E915E9AF6F55DDULL>& SubOffButtonName1() { // OFFSET: 0x00A5AB70 // FUNCTION: fn_16407 EncryptedName<44, 0xB3E307A5F753D5E3ULL>& SubOnButtonName() { - const std::uint8_t source[] = {0x23, 0x7A, 0x93, 0x0D, 0x65, 0xC9, 0x26, 0x7E, 0x25, 0x31, 0x93, 0x3B, 0x18, 0xBD, 0xBF, 0xE1, 0x86, 0xBB, 0x36, 0x80, 0xFA, 0x56, 0x96, 0xD6, 0x90, 0xA1, 0x06, 0xBE, 0xF9, 0x65, 0x97, 0xDD, 0xBC, 0xA6, 0x26, 0x95, 0xFA, 0x68, 0x8D, 0x9D, 0x81, 0xB8, 0x23, 0xF7}; + const char source[] = {'\x23', '\x7A', '\x93', '\x0D', '\x65', '\xC9', '\x26', '\x7E', '\x25', '\x31', '\x93', '\x3B', '\x18', '\xBD', '\xBF', '\xE1', '\x86', '\xBB', '\x36', '\x80', '\xFA', '\x56', '\x96', '\xD6', '\x90', '\xA1', '\x06', '\xBE', '\xF9', '\x65', '\x97', '\xDD', '\xBC', '\xA6', '\x26', '\x95', '\xFA', '\x68', '\x8D', '\x9D', '\x81', '\xB8', '\x23', '\xF7'}; thread_local EncryptedName name(source); return name; } @@ -476,7 +478,7 @@ EncryptedName<44, 0xB3E307A5F753D5E3ULL>& SubOnButtonName() { // OFFSET: 0x00A5AC50 // FUNCTION: fn_16408 EncryptedName<45, 0x192D654D29337BE5ULL>& SubOffButtonName2() { - const std::uint8_t source[] = {0x25, 0xD4, 0xF3, 0xD3, 0x8D, 0xAB, 0xE8, 0xD4, 0x23, 0x9F, 0xF3, 0xE5, 0xF0, 0xDF, 0x71, 0x4B, 0x80, 0x15, 0x56, 0x5E, 0x12, 0x34, 0x58, 0x7C, 0x96, 0x0F, 0x66, 0x60, 0x11, 0x07, 0x59, 0x77, 0xBA, 0x08, 0x46, 0x4B, 0x12, 0x0A, 0x4B, 0x7F, 0xCB, 0x19, 0x5E, 0x59, 0x4D}; + const char source[] = {'\x25', '\xD4', '\xF3', '\xD3', '\x8D', '\xAB', '\xE8', '\xD4', '\x23', '\x9F', '\xF3', '\xE5', '\xF0', '\xDF', '\x71', '\x4B', '\x80', '\x15', '\x56', '\x5E', '\x12', '\x34', '\x58', '\x7C', '\x96', '\x0F', '\x66', '\x60', '\x11', '\x07', '\x59', '\x77', '\xBA', '\x08', '\x46', '\x4B', '\x12', '\x0A', '\x4B', '\x7F', '\xCB', '\x19', '\x5E', '\x59', '\x4D'}; thread_local EncryptedName name(source); return name; } @@ -484,7 +486,7 @@ EncryptedName<45, 0x192D654D29337BE5ULL>& SubOffButtonName2() { // OFFSET: 0x00A5AD40 // FUNCTION: fn_16409 EncryptedName<45, 0xF15F8785CDE369BFULL>& SubOffButtonName3() { - const std::uint8_t source[] = {0x7F, 0xC6, 0x23, 0x37, 0x45, 0x49, 0x9A, 0x3C, 0x79, 0x8D, 0x23, 0x01, 0x38, 0x3D, 0x03, 0xA3, 0xDA, 0x07, 0x86, 0xBA, 0xDA, 0xD6, 0x2A, 0x94, 0xCC, 0x1D, 0xB6, 0x84, 0xD9, 0xE5, 0x2B, 0x9F, 0xE0, 0x1A, 0x96, 0xAF, 0xDA, 0xE8, 0x39, 0x97, 0x91, 0x0B, 0x8E, 0xBD, 0x85}; + const char source[] = {'\x7F', '\xC6', '\x23', '\x37', '\x45', '\x49', '\x9A', '\x3C', '\x79', '\x8D', '\x23', '\x01', '\x38', '\x3D', '\x03', '\xA3', '\xDA', '\x07', '\x86', '\xBA', '\xDA', '\xD6', '\x2A', '\x94', '\xCC', '\x1D', '\xB6', '\x84', '\xD9', '\xE5', '\x2B', '\x9F', '\xE0', '\x1A', '\x96', '\xAF', '\xDA', '\xE8', '\x39', '\x97', '\x91', '\x0B', '\x8E', '\xBD', '\x85'}; thread_local EncryptedName name(source); return name; } @@ -500,7 +502,7 @@ EncryptedName<6, 0xE33F2FF779878559ULL>& GulimFontName3() { // OFFSET: 0x00A5AF00 // FUNCTION: fn_16411 EncryptedName<47, 0x49D33529F1556333ULL>& DailyOffButtonName1() { - const std::uint8_t source[] = {0xF3, 0xCC, 0x95, 0x0B, 0xE9, 0xFB, 0x16, 0x84, 0xF5, 0x87, 0x95, 0x3D, 0x94, 0x8F, 0x8F, 0x1B, 0x56, 0x0D, 0x30, 0x86, 0x76, 0x64, 0xA6, 0x2C, 0x40, 0x17, 0x00, 0xB8, 0x75, 0x57, 0xA7, 0x27, 0x6C, 0x07, 0x34, 0x98, 0x45, 0x4C, 0x8C, 0x26, 0x55, 0x05, 0x7B, 0x93, 0x44, 0x45, 0xD3}; + const char source[] = {'\xF3', '\xCC', '\x95', '\x0B', '\xE9', '\xFB', '\x16', '\x84', '\xF5', '\x87', '\x95', '\x3D', '\x94', '\x8F', '\x8F', '\x1B', '\x56', '\x0D', '\x30', '\x86', '\x76', '\x64', '\xA6', '\x2C', '\x40', '\x17', '\x00', '\xB8', '\x75', '\x57', '\xA7', '\x27', '\x6C', '\x07', '\x34', '\x98', '\x45', '\x4C', '\x8C', '\x26', '\x55', '\x05', '\x7B', '\x93', '\x44', '\x45', '\xD3'}; thread_local EncryptedName name(source); return name; } @@ -508,7 +510,7 @@ EncryptedName<47, 0x49D33529F1556333ULL>& DailyOffButtonName1() { // OFFSET: 0x00A5AFF0 // FUNCTION: fn_16412 EncryptedName<46, 0x792FFD1325418FB5ULL>& DailyOnButtonName() { - const std::uint8_t source[] = {0x75, 0x20, 0x81, 0xDF, 0xD3, 0x33, 0xEA, 0xB4, 0x73, 0x6B, 0x81, 0xE9, 0xAE, 0x47, 0x73, 0x2B, 0xD0, 0xE1, 0x24, 0x52, 0x4C, 0xAC, 0x5A, 0x1C, 0xC6, 0xFB, 0x14, 0x6C, 0x4F, 0x9F, 0x5B, 0x17, 0xEA, 0xEB, 0x20, 0x4C, 0x7F, 0x84, 0x70, 0x16, 0xDB, 0xA1, 0x23, 0x48, 0x63, 0xFD}; + const char source[] = {'\x75', '\x20', '\x81', '\xDF', '\xD3', '\x33', '\xEA', '\xB4', '\x73', '\x6B', '\x81', '\xE9', '\xAE', '\x47', '\x73', '\x2B', '\xD0', '\xE1', '\x24', '\x52', '\x4C', '\xAC', '\x5A', '\x1C', '\xC6', '\xFB', '\x14', '\x6C', '\x4F', '\x9F', '\x5B', '\x17', '\xEA', '\xEB', '\x20', '\x4C', '\x7F', '\x84', '\x70', '\x16', '\xDB', '\xA1', '\x23', '\x48', '\x63', '\xFD'}; thread_local EncryptedName name(source); return name; } @@ -516,7 +518,7 @@ EncryptedName<46, 0x792FFD1325418FB5ULL>& DailyOnButtonName() { // OFFSET: 0x00A5B0E0 // FUNCTION: fn_16413 EncryptedName<47, 0xC5B1BBCD9BC9C997ULL>& DailyOffButtonName2() { - const std::uint8_t source[] = {0x57, 0x66, 0x09, 0x61, 0x0D, 0x75, 0x74, 0x08, 0x51, 0x2D, 0x09, 0x57, 0x70, 0x01, 0xED, 0x97, 0xF2, 0xA7, 0xAC, 0xEC, 0x92, 0xEA, 0xC4, 0xA0, 0xE4, 0xBD, 0x9C, 0xD2, 0x91, 0xD9, 0xC5, 0xAB, 0xC8, 0xAD, 0xA8, 0xF2, 0xA1, 0xC2, 0xEE, 0xAA, 0xF1, 0xAF, 0xE7, 0xF9, 0xA0, 0xCB, 0xB1}; + const char source[] = {'\x57', '\x66', '\x09', '\x61', '\x0D', '\x75', '\x74', '\x08', '\x51', '\x2D', '\x09', '\x57', '\x70', '\x01', '\xED', '\x97', '\xF2', '\xA7', '\xAC', '\xEC', '\x92', '\xEA', '\xC4', '\xA0', '\xE4', '\xBD', '\x9C', '\xD2', '\x91', '\xD9', '\xC5', '\xAB', '\xC8', '\xAD', '\xA8', '\xF2', '\xA1', '\xC2', '\xEE', '\xAA', '\xF1', '\xAF', '\xE7', '\xF9', '\xA0', '\xCB', '\xB1'}; thread_local EncryptedName name(source); return name; } @@ -524,7 +526,7 @@ EncryptedName<47, 0xC5B1BBCD9BC9C997ULL>& DailyOffButtonName2() { // OFFSET: 0x00A5B1D0 // FUNCTION: fn_16414 EncryptedName<47, 0x01CB4F1DF9D3F931ULL>& DailyOffButtonName3() { - const std::uint8_t source[] = {0xF1, 0x56, 0x13, 0x03, 0xDD, 0x81, 0x0E, 0xCC, 0xF7, 0x1D, 0x13, 0x35, 0xA0, 0xF5, 0x97, 0x53, 0x54, 0x97, 0xB6, 0x8E, 0x42, 0x1E, 0xBE, 0x64, 0x42, 0x8D, 0x86, 0xB0, 0x41, 0x2D, 0xBF, 0x6F, 0x6E, 0x9D, 0xB2, 0x90, 0x71, 0x36, 0x94, 0x6E, 0x57, 0x9F, 0xFD, 0x9B, 0x70, 0x3F, 0xCB}; + const char source[] = {'\xF1', '\x56', '\x13', '\x03', '\xDD', '\x81', '\x0E', '\xCC', '\xF7', '\x1D', '\x13', '\x35', '\xA0', '\xF5', '\x97', '\x53', '\x54', '\x97', '\xB6', '\x8E', '\x42', '\x1E', '\xBE', '\x64', '\x42', '\x8D', '\x86', '\xB0', '\x41', '\x2D', '\xBF', '\x6F', '\x6E', '\x9D', '\xB2', '\x90', '\x71', '\x36', '\x94', '\x6E', '\x57', '\x9F', '\xFD', '\x9B', '\x70', '\x3F', '\xCB'}; thread_local EncryptedName name(source); return name; } @@ -540,7 +542,7 @@ EncryptedName<6, 0x1767DDE18D779D8BULL>& GulimFontName4() { // OFFSET: 0x00A5B390 // FUNCTION: fn_16416 EncryptedName<47, 0xC1BB8111EDD183E1ULL>& EventOffButtonName1() { - const std::uint8_t source[] = {0x21, 0x2C, 0x11, 0x17, 0xD1, 0x4F, 0x7E, 0x0C, 0x27, 0x67, 0x11, 0x21, 0xAC, 0x3B, 0xE7, 0x93, 0x84, 0xED, 0xB4, 0x9A, 0x4E, 0xD0, 0xCE, 0xA4, 0x92, 0xF7, 0x84, 0xA4, 0x4D, 0xE3, 0xCF, 0xAF, 0xBE, 0xE6, 0xA7, 0x88, 0x7F, 0xF5, 0xE4, 0xAE, 0x87, 0xE5, 0xFF, 0x8F, 0x7C, 0xF1, 0xBB}; + const char source[] = {'\x21', '\x2C', '\x11', '\x17', '\xD1', '\x4F', '\x7E', '\x0C', '\x27', '\x67', '\x11', '\x21', '\xAC', '\x3B', '\xE7', '\x93', '\x84', '\xED', '\xB4', '\x9A', '\x4E', '\xD0', '\xCE', '\xA4', '\x92', '\xF7', '\x84', '\xA4', '\x4D', '\xE3', '\xCF', '\xAF', '\xBE', '\xE6', '\xA7', '\x88', '\x7F', '\xF5', '\xE4', '\xAE', '\x87', '\xE5', '\xFF', '\x8F', '\x7C', '\xF1', '\xBB'}; thread_local EncryptedName name(source); return name; } @@ -548,7 +550,7 @@ EncryptedName<47, 0xC1BB8111EDD183E1ULL>& EventOffButtonName1() { // OFFSET: 0x00A5B480 // FUNCTION: fn_16417 EncryptedName<46, 0x271B45771F83DD9FULL>& EventOnButtonName() { - const std::uint8_t source[] = {0x5F, 0x72, 0x43, 0xE5, 0xB7, 0x8B, 0xDE, 0xEA, 0x59, 0x39, 0x43, 0xD3, 0xCA, 0xFF, 0x47, 0x75, 0xFA, 0xB3, 0xE6, 0x68, 0x28, 0x14, 0x6E, 0x42, 0xEC, 0xA9, 0xD6, 0x56, 0x2B, 0x27, 0x6F, 0x49, 0xC0, 0xB8, 0xF5, 0x7A, 0x19, 0x31, 0x44, 0x48, 0xF1, 0xF3, 0xE1, 0x72, 0x07, 0x45}; + const char source[] = {'\x5F', '\x72', '\x43', '\xE5', '\xB7', '\x8B', '\xDE', '\xEA', '\x59', '\x39', '\x43', '\xD3', '\xCA', '\xFF', '\x47', '\x75', '\xFA', '\xB3', '\xE6', '\x68', '\x28', '\x14', '\x6E', '\x42', '\xEC', '\xA9', '\xD6', '\x56', '\x2B', '\x27', '\x6F', '\x49', '\xC0', '\xB8', '\xF5', '\x7A', '\x19', '\x31', '\x44', '\x48', '\xF1', '\xF3', '\xE1', '\x72', '\x07', '\x45'}; thread_local EncryptedName name(source); return name; } @@ -556,7 +558,7 @@ EncryptedName<46, 0x271B45771F83DD9FULL>& EventOnButtonName() { // OFFSET: 0x00A5B570 // FUNCTION: fn_16418 EncryptedName<47, 0x8783C33941E15117ULL>& EventOffButtonName2() { - const std::uint8_t source[] = {0xD7, 0xFE, 0x21, 0xBB, 0xF9, 0x0D, 0x46, 0x4A, 0xD1, 0xB5, 0x21, 0x8D, 0x84, 0x79, 0xDF, 0xD5, 0x72, 0x3F, 0x84, 0x36, 0x66, 0x92, 0xF6, 0xE2, 0x64, 0x25, 0xB4, 0x08, 0x65, 0xA1, 0xF7, 0xE9, 0x48, 0x34, 0x97, 0x24, 0x57, 0xB7, 0xDC, 0xE8, 0x71, 0x37, 0xCF, 0x23, 0x54, 0xB3, 0x83}; + const char source[] = {'\xD7', '\xFE', '\x21', '\xBB', '\xF9', '\x0D', '\x46', '\x4A', '\xD1', '\xB5', '\x21', '\x8D', '\x84', '\x79', '\xDF', '\xD5', '\x72', '\x3F', '\x84', '\x36', '\x66', '\x92', '\xF6', '\xE2', '\x64', '\x25', '\xB4', '\x08', '\x65', '\xA1', '\xF7', '\xE9', '\x48', '\x34', '\x97', '\x24', '\x57', '\xB7', '\xDC', '\xE8', '\x71', '\x37', '\xCF', '\x23', '\x54', '\xB3', '\x83'}; thread_local EncryptedName name(source); return name; } @@ -564,7 +566,7 @@ EncryptedName<47, 0x8783C33941E15117ULL>& EventOffButtonName2() { // OFFSET: 0x00A5B660 // FUNCTION: fn_16419 EncryptedName<47, 0x0B8745519B1F95D7ULL>& EventOffButtonName3() { - const std::uint8_t source[] = {0x17, 0x3A, 0xDF, 0x61, 0x91, 0x8B, 0x42, 0xC6, 0x11, 0x71, 0xDF, 0x57, 0xEC, 0xFF, 0xDB, 0x59, 0xB2, 0xFB, 0x7A, 0xEC, 0x0E, 0x14, 0xF2, 0x6E, 0xA4, 0xE1, 0x4A, 0xD2, 0x0D, 0x27, 0xF3, 0x65, 0x88, 0xF0, 0x69, 0xFE, 0x3F, 0x31, 0xD8, 0x64, 0xB1, 0xF3, 0x31, 0xF9, 0x3C, 0x35, 0x87}; + const char source[] = {'\x17', '\x3A', '\xDF', '\x61', '\x91', '\x8B', '\x42', '\xC6', '\x11', '\x71', '\xDF', '\x57', '\xEC', '\xFF', '\xDB', '\x59', '\xB2', '\xFB', '\x7A', '\xEC', '\x0E', '\x14', '\xF2', '\x6E', '\xA4', '\xE1', '\x4A', '\xD2', '\x0D', '\x27', '\xF3', '\x65', '\x88', '\xF0', '\x69', '\xFE', '\x3F', '\x31', '\xD8', '\x64', '\xB1', '\xF3', '\x31', '\xF9', '\x3C', '\x35', '\x87'}; thread_local EncryptedName name(source); return name; } @@ -580,7 +582,7 @@ EncryptedName<6, 0xC70319B5EB61598FULL>& GulimFontName5() { // OFFSET: 0x00A5B820 // FUNCTION: fn_16421 EncryptedName<45, 0xFFABE3D5D1BBEF73ULL>& EtcOffButtonName1() { - const std::uint8_t source[] = {0xB3, 0x40, 0x7B, 0x2B, 0x15, 0x2D, 0x6E, 0x32, 0xB5, 0x0B, 0x7B, 0x1D, 0x68, 0x59, 0xF7, 0xAD, 0x16, 0x81, 0xDE, 0xA6, 0x8A, 0xB2, 0xDE, 0x9A, 0x00, 0x9B, 0xEE, 0x98, 0x89, 0x81, 0xDF, 0x91, 0x2C, 0x8A, 0xCF, 0xB2, 0x8A, 0x8C, 0xCD, 0x99, 0x5D, 0x8D, 0xD6, 0xA1, 0xD5}; + const char source[] = {'\xB3', '\x40', '\x7B', '\x2B', '\x15', '\x2D', '\x6E', '\x32', '\xB5', '\x0B', '\x7B', '\x1D', '\x68', '\x59', '\xF7', '\xAD', '\x16', '\x81', '\xDE', '\xA6', '\x8A', '\xB2', '\xDE', '\x9A', '\x00', '\x9B', '\xEE', '\x98', '\x89', '\x81', '\xDF', '\x91', '\x2C', '\x8A', '\xCF', '\xB2', '\x8A', '\x8C', '\xCD', '\x99', '\x5D', '\x8D', '\xD6', '\xA1', '\xD5'}; thread_local EncryptedName name(source); return name; } @@ -588,7 +590,7 @@ EncryptedName<45, 0xFFABE3D5D1BBEF73ULL>& EtcOffButtonName1() { // OFFSET: 0x00A5B910 // FUNCTION: fn_16422 EncryptedName<44, 0xA597A7E7492B39D5ULL>& EtcOnButtonName() { - const std::uint8_t source[] = {0x15, 0x96, 0xEB, 0xB3, 0x27, 0x69, 0x52, 0x68, 0x13, 0xDD, 0xEB, 0x85, 0x5A, 0x1D, 0xCB, 0xF7, 0xB0, 0x57, 0x4E, 0x3E, 0xB8, 0xF6, 0xE2, 0xC0, 0xA6, 0x4D, 0x7E, 0x00, 0xBB, 0xC5, 0xE3, 0xCB, 0x8A, 0x5C, 0x5F, 0x2A, 0xB8, 0xC8, 0xF9, 0x8B, 0xB7, 0x54, 0x5B, 0x49}; + const char source[] = {'\x15', '\x96', '\xEB', '\xB3', '\x27', '\x69', '\x52', '\x68', '\x13', '\xDD', '\xEB', '\x85', '\x5A', '\x1D', '\xCB', '\xF7', '\xB0', '\x57', '\x4E', '\x3E', '\xB8', '\xF6', '\xE2', '\xC0', '\xA6', '\x4D', '\x7E', '\x00', '\xBB', '\xC5', '\xE3', '\xCB', '\x8A', '\x5C', '\x5F', '\x2A', '\xB8', '\xC8', '\xF9', '\x8B', '\xB7', '\x54', '\x5B', '\x49'}; thread_local EncryptedName name(source); return name; } @@ -596,7 +598,7 @@ EncryptedName<44, 0xA597A7E7492B39D5ULL>& EtcOnButtonName() { // OFFSET: 0x00A5B9F0 // FUNCTION: fn_16423 EncryptedName<45, 0xD5A78DB38D8DAFABULL>& EtcOffButtonName2() { - const std::uint8_t source[] = {0x6B, 0x00, 0x4D, 0x77, 0x73, 0x43, 0x62, 0x18, 0x6D, 0x4B, 0x4D, 0x41, 0x0E, 0x37, 0xFB, 0x87, 0xCE, 0xC1, 0xE8, 0xFA, 0xEC, 0xDC, 0xD2, 0xB0, 0xD8, 0xDB, 0xD8, 0xC4, 0xEF, 0xEF, 0xD3, 0xBB, 0xF4, 0xCA, 0xF9, 0xEE, 0xEC, 0xE2, 0xC1, 0xB3, 0x85, 0xCD, 0xE0, 0xFD, 0xB3}; + const char source[] = {'\x6B', '\x00', '\x4D', '\x77', '\x73', '\x43', '\x62', '\x18', '\x6D', '\x4B', '\x4D', '\x41', '\x0E', '\x37', '\xFB', '\x87', '\xCE', '\xC1', '\xE8', '\xFA', '\xEC', '\xDC', '\xD2', '\xB0', '\xD8', '\xDB', '\xD8', '\xC4', '\xEF', '\xEF', '\xD3', '\xBB', '\xF4', '\xCA', '\xF9', '\xEE', '\xEC', '\xE2', '\xC1', '\xB3', '\x85', '\xCD', '\xE0', '\xFD', '\xB3'}; thread_local EncryptedName name(source); return name; } @@ -604,7 +606,7 @@ EncryptedName<45, 0xD5A78DB38D8DAFABULL>& EtcOffButtonName2() { // OFFSET: 0x00A5BAE0 // FUNCTION: fn_16424 EncryptedName<45, 0x0399459DAF454F0FULL>& EtcOffButtonName3() { - const std::uint8_t source[] = {0xCF, 0xE0, 0x85, 0x55, 0x5D, 0x8B, 0x5C, 0xCE, 0xC9, 0xAB, 0x85, 0x63, 0x20, 0xFF, 0xC5, 0x51, 0x6A, 0x21, 0x20, 0xD8, 0xC2, 0x14, 0xEC, 0x66, 0x7C, 0x3B, 0x10, 0xE6, 0xC1, 0x27, 0xED, 0x6D, 0x50, 0x2A, 0x31, 0xCC, 0xC2, 0x2A, 0xFF, 0x65, 0x21, 0x2D, 0x28, 0xDF, 0x9D}; + const char source[] = {'\xCF', '\xE0', '\x85', '\x55', '\x5D', '\x8B', '\x5C', '\xCE', '\xC9', '\xAB', '\x85', '\x63', '\x20', '\xFF', '\xC5', '\x51', '\x6A', '\x21', '\x20', '\xD8', '\xC2', '\x14', '\xEC', '\x66', '\x7C', '\x3B', '\x10', '\xE6', '\xC1', '\x27', '\xED', '\x6D', '\x50', '\x2A', '\x31', '\xCC', '\xC2', '\x2A', '\xFF', '\x65', '\x21', '\x2D', '\x28', '\xDF', '\x9D'}; thread_local EncryptedName name(source); return name; } @@ -612,7 +614,7 @@ EncryptedName<45, 0x0399459DAF454F0FULL>& EtcOffButtonName3() { // OFFSET: 0x00A5BBD0 // FUNCTION: fn_16425 EncryptedName<51, 0xAD6153019F93A527ULL>& SearchNormalButtonName() { - const std::uint8_t source[] = {0xE7, 0x0A, 0x53, 0x65, 0xC1, 0x9D, 0xA4, 0x60, 0xE1, 0x41, 0x53, 0x53, 0xBC, 0xE9, 0x3D, 0xFF, 0x42, 0xCB, 0xF6, 0xE8, 0x5E, 0x02, 0x14, 0xC8, 0x54, 0xD1, 0xC6, 0xD6, 0x5D, 0x31, 0x15, 0xC3, 0x78, 0xD6, 0xF6, 0xFE, 0x73, 0x30, 0x09, 0xF2, 0x49, 0xCA, 0xE1, 0xF2, 0x60, 0x3F, 0x4F, 0xCF, 0x4A, 0xD5, 0x93}; + const char source[] = {'\xE7', '\x0A', '\x53', '\x65', '\xC1', '\x9D', '\xA4', '\x60', '\xE1', '\x41', '\x53', '\x53', '\xBC', '\xE9', '\x3D', '\xFF', '\x42', '\xCB', '\xF6', '\xE8', '\x5E', '\x02', '\x14', '\xC8', '\x54', '\xD1', '\xC6', '\xD6', '\x5D', '\x31', '\x15', '\xC3', '\x78', '\xD6', '\xF6', '\xFE', '\x73', '\x30', '\x09', '\xF2', '\x49', '\xCA', '\xE1', '\xF2', '\x60', '\x3F', '\x4F', '\xCF', '\x4A', '\xD5', '\x93'}; thread_local EncryptedName name(source); return name; } @@ -620,7 +622,7 @@ EncryptedName<51, 0xAD6153019F93A527ULL>& SearchNormalButtonName() { // OFFSET: 0x00A5BCB0 // FUNCTION: fn_16426 EncryptedName<50, 0x85E1F5A7A5755B7FULL>& SearchPressButtonName() { - const std::uint8_t source[] = {0xBF, 0xF4, 0xB5, 0x5F, 0x67, 0x3B, 0x24, 0x48, 0xB9, 0xBF, 0xB5, 0x69, 0x1A, 0x4F, 0xBD, 0xD7, 0x1A, 0x35, 0x10, 0xD2, 0xF8, 0xA4, 0x94, 0xE0, 0x0C, 0x2F, 0x20, 0xEC, 0xFB, 0x97, 0x95, 0xEB, 0x20, 0x28, 0x10, 0xC4, 0xD5, 0x96, 0x89, 0xDA, 0x0F, 0x29, 0x10, 0xD6, 0xD4, 0xDB, 0x83, 0xE8, 0x0F, 0x5B}; + const char source[] = {'\xBF', '\xF4', '\xB5', '\x5F', '\x67', '\x3B', '\x24', '\x48', '\xB9', '\xBF', '\xB5', '\x69', '\x1A', '\x4F', '\xBD', '\xD7', '\x1A', '\x35', '\x10', '\xD2', '\xF8', '\xA4', '\x94', '\xE0', '\x0C', '\x2F', '\x20', '\xEC', '\xFB', '\x97', '\x95', '\xEB', '\x20', '\x28', '\x10', '\xC4', '\xD5', '\x96', '\x89', '\xDA', '\x0F', '\x29', '\x10', '\xD6', '\xD4', '\xDB', '\x83', '\xE8', '\x0F', '\x5B'}; thread_local EncryptedName name(source); return name; } @@ -628,7 +630,7 @@ EncryptedName<50, 0x85E1F5A7A5755B7FULL>& SearchPressButtonName() { // OFFSET: 0x00A5BD90 // FUNCTION: fn_16427 EncryptedName<49, 0x659975C121557D3DULL>& SearchOverButtonName() { - const std::uint8_t source[] = {0xFD, 0xD2, 0x95, 0xDB, 0x01, 0xBB, 0x5C, 0xA8, 0xFB, 0x99, 0x95, 0xED, 0x7C, 0xCF, 0xC5, 0x37, 0x58, 0x13, 0x30, 0x56, 0x9E, 0x24, 0xEC, 0x00, 0x4E, 0x09, 0x00, 0x68, 0x9D, 0x17, 0xED, 0x0B, 0x62, 0x0E, 0x30, 0x40, 0xB3, 0x16, 0xF1, 0x3A, 0x52, 0x0B, 0x30, 0x53, 0xEF, 0x17, 0xF4, 0x15, 0x3D}; + const char source[] = {'\xFD', '\xD2', '\x95', '\xDB', '\x01', '\xBB', '\x5C', '\xA8', '\xFB', '\x99', '\x95', '\xED', '\x7C', '\xCF', '\xC5', '\x37', '\x58', '\x13', '\x30', '\x56', '\x9E', '\x24', '\xEC', '\x00', '\x4E', '\x09', '\x00', '\x68', '\x9D', '\x17', '\xED', '\x0B', '\x62', '\x0E', '\x30', '\x40', '\xB3', '\x16', '\xF1', '\x3A', '\x52', '\x0B', '\x30', '\x53', '\xEF', '\x17', '\xF4', '\x15', '\x3D'}; thread_local EncryptedName name(source); return name; } @@ -636,7 +638,7 @@ EncryptedName<49, 0x659975C121557D3DULL>& SearchOverButtonName() { // OFFSET: 0x00A5BE70 // FUNCTION: fn_16428 EncryptedName<52, 0xBFF5C517A1A77F59ULL>& SearchDisableButtonName() { - const std::uint8_t source[] = {0x99, 0xD0, 0x67, 0x5B, 0xD7, 0x0B, 0x30, 0x72, 0x9F, 0x9B, 0x67, 0x6D, 0xAA, 0x7F, 0xA9, 0xED, 0x3C, 0x11, 0xC2, 0xD6, 0x48, 0x94, 0x80, 0xDA, 0x2A, 0x0B, 0xF2, 0xE8, 0x4B, 0xA7, 0x81, 0xD1, 0x06, 0x0C, 0xC2, 0xC0, 0x65, 0xA6, 0x9D, 0xE0, 0x3D, 0x16, 0xD4, 0xC0, 0x75, 0xA9, 0x90, 0x91, 0x3B, 0x12, 0xD7, 0xA1}; + const char source[] = {'\x99', '\xD0', '\x67', '\x5B', '\xD7', '\x0B', '\x30', '\x72', '\x9F', '\x9B', '\x67', '\x6D', '\xAA', '\x7F', '\xA9', '\xED', '\x3C', '\x11', '\xC2', '\xD6', '\x48', '\x94', '\x80', '\xDA', '\x2A', '\x0B', '\xF2', '\xE8', '\x4B', '\xA7', '\x81', '\xD1', '\x06', '\x0C', '\xC2', '\xC0', '\x65', '\xA6', '\x9D', '\xE0', '\x3D', '\x16', '\xD4', '\xC0', '\x75', '\xA9', '\x90', '\x91', '\x3B', '\x12', '\xD7', '\xA1'}; thread_local EncryptedName name(source); return name; } @@ -1335,7 +1337,7 @@ void RenewQuestUI::CUIQuestItem::Slot15(int width, int height) { this->unknown_00EC->SetText("", 0); this->unknown_00EC->SetFitText(1); this->unknown_00EC->SetAlign(0, 0); - this->unknown_00EC->SetFont(std::string(DecryptName<0xAD075B8DB599F1CDULL>({0x8A, 0x84, 0xF5, 0xDC, 0xE0, 0x5B}))); + this->unknown_00EC->SetFont(std::string(DecryptName<0xAD075B8DB599F1CDULL>({'\x8A', '\x84', '\xF5', '\xDC', '\xE0', '\x5B'}))); this->unknown_00EC->SetFontHeight(12); this->unknown_00EC->SetBold(1); this->unknown_00EC->SetColor(0x955322); @@ -1349,7 +1351,7 @@ void RenewQuestUI::CUIQuestItem::Slot15(int width, int height) { this->unknown_00F0->SetText("", 0); this->unknown_00F0->SetFitText(1); this->unknown_00F0->SetAlign(0, 0); - this->unknown_00F0->SetFont(std::string(DecryptName<0xDD3913D5D7F97BE1ULL>({0xA6, 0x0E, 0x95, 0xBE, 0xB8, 0x13}))); + this->unknown_00F0->SetFont(std::string(DecryptName<0xDD3913D5D7F97BE1ULL>({'\xA6', '\x0E', '\x95', '\xBE', '\xB8', '\x13'}))); this->unknown_00F0->SetFontHeight(12); this->unknown_00F0->SetBold(0); this->unknown_00F0->SetColor(0x38302E); @@ -1365,24 +1367,24 @@ void RenewQuestUI::CUIQuestItem::Slot15(int width, int height) { this->unknown_00F4->Invalidate(); this->unknown_00F4->SetImages( std::string(DecryptName<0x050505679903579BULL>({ - 0x5B, 0xF8, 0xC3, 0x63, 0xA7, 0xCB, 0xC0, 0xC8, 0x5D, 0xB3, 0xC3, 0x55, 0xDA, 0xBF, 0x59, 0x57, - 0xFE, 0x39, 0x66, 0xEE, 0x38, 0x54, 0x70, 0x60, 0xE8, 0x23, 0x56, 0xD0, 0x3B, 0x67, 0x71, 0x5A, - 0xF8, 0x3F, 0x66, 0xFA, 0x0C, 0x5A, 0x6A, 0x63, 0xFD, 0x79, 0x61, 0xF4, 0x17, 0x05 + '\x5B', '\xF8', '\xC3', '\x63', '\xA7', '\xCB', '\xC0', '\xC8', '\x5D', '\xB3', '\xC3', '\x55', '\xDA', '\xBF', '\x59', '\x57', + '\xFE', '\x39', '\x66', '\xEE', '\x38', '\x54', '\x70', '\x60', '\xE8', '\x23', '\x56', '\xD0', '\x3B', '\x67', '\x71', '\x5A', + '\xF8', '\x3F', '\x66', '\xFA', '\x0C', '\x5A', '\x6A', '\x63', '\xFD', '\x79', '\x61', '\xF4', '\x17', '\x05' })), std::string(DecryptName<0x83EFBFBB37EDBDBDULL>({ - 0x7D, 0x12, 0x2D, 0xCD, 0x7B, 0x71, 0x2A, 0x4E, 0x7B, 0x59, 0x2D, 0xFB, 0x06, 0x05, 0xB3, 0xD1, - 0xD8, 0xD3, 0x88, 0x40, 0xE4, 0xEE, 0x9A, 0xE6, 0xCE, 0xC9, 0xB8, 0x7E, 0xE7, 0xDD, 0x9B, 0xDC, - 0xDE, 0xD5, 0x88, 0x54, 0xD0, 0xE0, 0x80, 0xED, 0x93, 0xDF, 0x80, 0x47, 0xBB + '\x7D', '\x12', '\x2D', '\xCD', '\x7B', '\x71', '\x2A', '\x4E', '\x7B', '\x59', '\x2D', '\xFB', '\x06', '\x05', '\xB3', '\xD1', + '\xD8', '\xD3', '\x88', '\x40', '\xE4', '\xEE', '\x9A', '\xE6', '\xCE', '\xC9', '\xB8', '\x7E', '\xE7', '\xDD', '\x9B', '\xDC', + '\xDE', '\xD5', '\x88', '\x54', '\xD0', '\xE0', '\x80', '\xED', '\x93', '\xDF', '\x80', '\x47', '\xBB' })), std::string(DecryptName<0xBF2B4B31397FF5A7ULL>({ - 0x67, 0x5A, 0xBF, 0xC3, 0xF1, 0x85, 0xEE, 0x72, 0x61, 0x11, 0xBF, 0xF5, 0x8C, 0xF1, 0x77, 0xED, - 0xC2, 0x9B, 0x1A, 0x4E, 0x6E, 0x1A, 0x5E, 0xDA, 0xD4, 0x81, 0x2A, 0x70, 0x6D, 0x29, 0x5F, 0xE0, - 0xC4, 0x9D, 0x1A, 0x5A, 0x5A, 0x14, 0x44, 0xD9, 0xC1, 0xDB, 0x1D, 0x54, 0x41, 0x4B + '\x67', '\x5A', '\xBF', '\xC3', '\xF1', '\x85', '\xEE', '\x72', '\x61', '\x11', '\xBF', '\xF5', '\x8C', '\xF1', '\x77', '\xED', + '\xC2', '\x9B', '\x1A', '\x4E', '\x6E', '\x1A', '\x5E', '\xDA', '\xD4', '\x81', '\x2A', '\x70', '\x6D', '\x29', '\x5F', '\xE0', + '\xC4', '\x9D', '\x1A', '\x5A', '\x5A', '\x14', '\x44', '\xD9', '\xC1', '\xDB', '\x1D', '\x54', '\x41', '\x4B' })), std::string(DecryptName<0xD97D5DBDBB2F2709ULL>({ - 0xC9, 0x88, 0xEF, 0x41, 0x7D, 0x93, 0xB8, 0x14, 0xCF, 0xC3, 0xEF, 0x77, 0x00, 0xE7, 0x21, 0x8B, - 0x6C, 0x49, 0x4A, 0xCC, 0xE2, 0x0C, 0x08, 0xBC, 0x7A, 0x53, 0x7A, 0xF2, 0xE1, 0x3F, 0x09, 0x86, - 0x6A, 0x4F, 0x4A, 0xD8, 0xD6, 0x02, 0x12, 0xBF, 0x6F, 0x09, 0x4D, 0xD6, 0xCD, 0x5D + '\xC9', '\x88', '\xEF', '\x41', '\x7D', '\x93', '\xB8', '\x14', '\xCF', '\xC3', '\xEF', '\x77', '\x00', '\xE7', '\x21', '\x8B', + '\x6C', '\x49', '\x4A', '\xCC', '\xE2', '\x0C', '\x08', '\xBC', '\x7A', '\x53', '\x7A', '\xF2', '\xE1', '\x3F', '\x09', '\x86', + '\x6A', '\x4F', '\x4A', '\xD8', '\xD6', '\x02', '\x12', '\xBF', '\x6F', '\x09', '\x4D', '\xD6', '\xCD', '\x5D' })) ); this->unknown_00F4->checked = false; @@ -1397,24 +1399,24 @@ void RenewQuestUI::CUIQuestItem::Slot15(int width, int height) { this->unknown_00F8->Invalidate(); this->unknown_00F8->SetImages( std::string(DecryptName<0xED796785D1DF137FULL>({ - 0xBF, 0xBC, 0x1F, 0x2B, 0x45, 0xA9, 0xBC, 0x20, 0xB9, 0xF7, 0x1F, 0x1D, 0x38, 0xDD, 0x25, 0xBF, - 0x1A, 0x7D, 0xBA, 0xA6, 0xDA, 0x36, 0x0C, 0x88, 0x0C, 0x67, 0x8A, 0x98, 0xD9, 0x05, 0x0D, 0xB2, - 0x13, 0x7C, 0xBC, 0xBA, 0xAB, 0x05, 0x14, 0x9D, 0x7F + '\xBF', '\xBC', '\x1F', '\x2B', '\x45', '\xA9', '\xBC', '\x20', '\xB9', '\xF7', '\x1F', '\x1D', '\x38', '\xDD', '\x25', '\xBF', + '\x1A', '\x7D', '\xBA', '\xA6', '\xDA', '\x36', '\x0C', '\x88', '\x0C', '\x67', '\x8A', '\x98', '\xD9', '\x05', '\x0D', '\xB2', + '\x13', '\x7C', '\xBC', '\xBA', '\xAB', '\x05', '\x14', '\x9D', '\x7F' })), std::string(DecryptName<0xF14F79170939C7F1ULL>({ - 0x31, 0x68, 0xF9, 0xF3, 0xD7, 0xB7, 0x8A, 0x3C, 0x37, 0x23, 0xF9, 0xC5, 0xAA, 0xC3, 0x13, 0xA3, - 0x94, 0xA9, 0x5C, 0x7E, 0x48, 0x28, 0x3A, 0x94, 0x82, 0xB3, 0x6C, 0x40, 0x4B, 0x1B, 0x3B, 0xAE, - 0x9D, 0xA8, 0x5A, 0x62, 0x48, 0x16, 0x3F, 0x94, 0x9F, 0xE9, 0x5B, 0x64, 0x67, 0x79 + '\x31', '\x68', '\xF9', '\xF3', '\xD7', '\xB7', '\x8A', '\x3C', '\x37', '\x23', '\xF9', '\xC5', '\xAA', '\xC3', '\x13', '\xA3', + '\x94', '\xA9', '\x5C', '\x7E', '\x48', '\x28', '\x3A', '\x94', '\x82', '\xB3', '\x6C', '\x40', '\x4B', '\x1B', '\x3B', '\xAE', + '\x9D', '\xA8', '\x5A', '\x62', '\x48', '\x16', '\x3F', '\x94', '\x9F', '\xE9', '\x5B', '\x64', '\x67', '\x79' })), std::string(DecryptName<0xA5FD29D7AB6DC59FULL>({ - 0x5F, 0x6A, 0xAD, 0x51, 0x17, 0xE7, 0x38, 0x68, 0x59, 0x21, 0xAD, 0x67, 0x6A, 0x93, 0xA1, 0xF7, - 0xFA, 0xAB, 0x08, 0xDC, 0x88, 0x78, 0x88, 0xC0, 0xEC, 0xB1, 0x38, 0xE2, 0x8B, 0x4B, 0x89, 0xFA, - 0xF3, 0xAA, 0x0E, 0xC0, 0xF9, 0x4B, 0x90, 0xD5, 0x9F + '\x5F', '\x6A', '\xAD', '\x51', '\x17', '\xE7', '\x38', '\x68', '\x59', '\x21', '\xAD', '\x67', '\x6A', '\x93', '\xA1', '\xF7', + '\xFA', '\xAB', '\x08', '\xDC', '\x88', '\x78', '\x88', '\xC0', '\xEC', '\xB1', '\x38', '\xE2', '\x8B', '\x4B', '\x89', '\xFA', + '\xF3', '\xAA', '\x0E', '\xC0', '\xF9', '\x4B', '\x90', '\xD5', '\x9F' })), std::string(DecryptName<0x13E33FA1A591AB67ULL>({ - 0xA7, 0x04, 0x51, 0x5F, 0x61, 0xF1, 0x26, 0xDE, 0xA1, 0x4F, 0x51, 0x69, 0x1C, 0x85, 0xBF, 0x41, - 0x02, 0xC5, 0xF4, 0xD2, 0xFE, 0x6E, 0x96, 0x76, 0x14, 0xDF, 0xC4, 0xEC, 0xFD, 0x5D, 0x97, 0x4C, - 0x0B, 0xC4, 0xF2, 0xCE, 0x8F, 0x5D, 0x8E, 0x63, 0x67 + '\xA7', '\x04', '\x51', '\x5F', '\x61', '\xF1', '\x26', '\xDE', '\xA1', '\x4F', '\x51', '\x69', '\x1C', '\x85', '\xBF', '\x41', + '\x02', '\xC5', '\xF4', '\xD2', '\xFE', '\x6E', '\x96', '\x76', '\x14', '\xDF', '\xC4', '\xEC', '\xFD', '\x5D', '\x97', '\x4C', + '\x0B', '\xC4', '\xF2', '\xCE', '\x8F', '\x5D', '\x8E', '\x63', '\x67' })) ); this->unknown_00F8->checked = false; @@ -1434,29 +1436,29 @@ void RenewQuestUI::CUIQuestList::Slot15(int width, int height) { this->list->SetBinder([this](CUIQuestItem* item, const unsigned long& questId) { this->BindItem(item, questId); }); { CUIListBoxEx* list = this->list; - const std::uint8_t disabledSource[] = { - 0x09, 0x5A, 0x9F, 0x71, 0x4F, 0x1B, 0x7E, 0xEE, 0x0F, 0x11, 0x9F, 0x47, 0x32, 0x6F, 0xE7, 0x71, - 0xAC, 0x9B, 0x3A, 0xFC, 0xD0, 0x84, 0xCE, 0x46, 0xBA, 0x81, 0x0A, 0xC2, 0xD3, 0xB7, 0xDC, 0x7C, - 0xB8, 0x80, 0x3A, 0xF8, 0xFB, 0x99, 0xD2, 0x50, 0xBD, 0xDB, 0x3D, 0xE6, 0xFF, 0xD5 + const char disabledSource[] = { + '\x09', '\x5A', '\x9F', '\x71', '\x4F', '\x1B', '\x7E', '\xEE', '\x0F', '\x11', '\x9F', '\x47', '\x32', '\x6F', '\xE7', '\x71', + '\xAC', '\x9B', '\x3A', '\xFC', '\xD0', '\x84', '\xCE', '\x46', '\xBA', '\x81', '\x0A', '\xC2', '\xD3', '\xB7', '\xDC', '\x7C', + '\xB8', '\x80', '\x3A', '\xF8', '\xFB', '\x99', '\xD2', '\x50', '\xBD', '\xDB', '\x3D', '\xE6', '\xFF', '\xD5' }; const std::string disabled(DecryptName<0x23BBD58F8B5FF5C9ULL>(disabledSource)); - const std::uint8_t pressedSource[] = { - 0xAF, 0xD2, 0x3B, 0xD9, 0xB1, 0xC9, 0x4A, 0x00, 0xA9, 0x99, 0x3B, 0xEF, 0xCC, 0xBD, 0xD3, 0x9F, - 0x0A, 0x13, 0x9E, 0x54, 0x2E, 0x56, 0xFA, 0xA8, 0x1C, 0x09, 0xAE, 0x6A, 0x2D, 0x65, 0xE8, 0x92, - 0x1E, 0x08, 0x9E, 0x50, 0x05, 0x4B, 0xE6, 0xBE, 0x1B, 0x53, 0x99, 0x4E, 0x01, 0x07 + const char pressedSource[] = { + '\xAF', '\xD2', '\x3B', '\xD9', '\xB1', '\xC9', '\x4A', '\x00', '\xA9', '\x99', '\x3B', '\xEF', '\xCC', '\xBD', '\xD3', '\x9F', + '\x0A', '\x13', '\x9E', '\x54', '\x2E', '\x56', '\xFA', '\xA8', '\x1C', '\x09', '\xAE', '\x6A', '\x2D', '\x65', '\xE8', '\x92', + '\x1E', '\x08', '\x9E', '\x50', '\x05', '\x4B', '\xE6', '\xBE', '\x1B', '\x53', '\x99', '\x4E', '\x01', '\x07' }; const std::string pressed(DecryptName<0xCD8F077123FB7D6FULL>(pressedSource)); - const std::uint8_t hoverSource[] = { - 0x83, 0x86, 0x93, 0xDD, 0x15, 0x71, 0x8C, 0x54, 0x85, 0xCD, 0x93, 0xEB, 0x68, 0x05, 0x15, 0xCB, - 0x26, 0x47, 0x36, 0x50, 0x8A, 0xEE, 0x3C, 0xFC, 0x30, 0x5D, 0x06, 0x6E, 0x89, 0xDD, 0x2E, 0xC6, - 0x32, 0x5C, 0x36, 0x54, 0xA1, 0xF3, 0x20, 0xEA, 0x37, 0x76, 0x30, 0x4F, 0xB0, 0xDC, 0x22, 0xB7, - 0x21, 0x44, 0x23, 0x27 + const char hoverSource[] = { + '\x83', '\x86', '\x93', '\xDD', '\x15', '\x71', '\x8C', '\x54', '\x85', '\xCD', '\x93', '\xEB', '\x68', '\x05', '\x15', '\xCB', + '\x26', '\x47', '\x36', '\x50', '\x8A', '\xEE', '\x3C', '\xFC', '\x30', '\x5D', '\x06', '\x6E', '\x89', '\xDD', '\x2E', '\xC6', + '\x32', '\x5C', '\x36', '\x54', '\xA1', '\xF3', '\x20', '\xEA', '\x37', '\x76', '\x30', '\x4F', '\xB0', '\xDC', '\x22', '\xB7', + '\x21', '\x44', '\x23', '\x27' }; const std::string hover(DecryptName<0x9949BFD527532943ULL>(hoverSource)); - const std::uint8_t normalSource[] = { - 0xF7, 0xE8, 0x6D, 0xC3, 0x7F, 0x2B, 0x6C, 0xDA, 0xF1, 0xA3, 0x6D, 0xF5, 0x02, 0x5F, 0xF5, 0x45, - 0x52, 0x29, 0xC8, 0x4E, 0xE0, 0xB4, 0xDC, 0x72, 0x44, 0x33, 0xF8, 0x70, 0xE3, 0x87, 0xCE, 0x48, - 0x46, 0x32, 0xC8, 0x4A, 0xCB, 0xA9, 0xC0, 0x64, 0x43, 0x69, 0xCF, 0x54, 0xCF, 0xE5 + const char normalSource[] = { + '\xF7', '\xE8', '\x6D', '\xC3', '\x7F', '\x2B', '\x6C', '\xDA', '\xF1', '\xA3', '\x6D', '\xF5', '\x02', '\x5F', '\xF5', '\x45', + '\x52', '\x29', '\xC8', '\x4E', '\xE0', '\xB4', '\xDC', '\x72', '\x44', '\x33', '\xF8', '\x70', '\xE3', '\x87', '\xCE', '\x48', + '\x46', '\x32', '\xC8', '\x4A', '\xCB', '\xA9', '\xC0', '\x64', '\x43', '\x69', '\xCF', '\x54', '\xCF', '\xE5' }; const std::string normal(DecryptName<0x17A9E5BF39AD4737ULL>(normalSource)); list->SetImages(normal, hover, pressed, disabled); @@ -1468,18 +1470,18 @@ void RenewQuestUI::CUIQuestList::Slot15(int width, int height) { this->list->scrollBar->step = 138; { CUIListBoxEx* list = this->list; - const std::uint8_t downSource[] = { - 0x65, 0x32, 0xAD, 0x03, 0xA3, 0xE9, 0xB2, 0xCE, 0x63, 0x79, 0xAD, 0x35, 0xDE, 0x9D, 0x2B, 0x51, - 0xC0, 0xF3, 0x08, 0x8E, 0x3C, 0x76, 0x02, 0x66, 0xD6, 0xE9, 0x38, 0xB0, 0x3F, 0x45, 0x03, 0x5C, - 0xD6, 0xFE, 0x1F, 0x96, 0x0F, 0x4B, 0x15, 0x62, 0xD7, 0xC2, 0x0C, 0x8B, 0x11, 0x48, 0x00, 0x5C, - 0xC1, 0xF2, 0x1A, 0x97, 0x4D, 0x45, 0x1A, 0x73, 0xA5 + const char downSource[] = { + '\x65', '\x32', '\xAD', '\x03', '\xA3', '\xE9', '\xB2', '\xCE', '\x63', '\x79', '\xAD', '\x35', '\xDE', '\x9D', '\x2B', '\x51', + '\xC0', '\xF3', '\x08', '\x8E', '\x3C', '\x76', '\x02', '\x66', '\xD6', '\xE9', '\x38', '\xB0', '\x3F', '\x45', '\x03', '\x5C', + '\xD6', '\xFE', '\x1F', '\x96', '\x0F', '\x4B', '\x15', '\x62', '\xD7', '\xC2', '\x0C', '\x8B', '\x11', '\x48', '\x00', '\x5C', + '\xC1', '\xF2', '\x1A', '\x97', '\x4D', '\x45', '\x1A', '\x73', '\xA5' }; const std::string down(DecryptName<0x03772763F96D9DA5ULL>(downSource)); - const std::uint8_t upSource[] = { - 0xAD, 0x14, 0x55, 0xD7, 0x53, 0x35, 0xD2, 0x08, 0xAB, 0x5F, 0x55, 0xE1, 0x2E, 0x41, 0x4B, 0x97, - 0x08, 0xD5, 0xF0, 0x5A, 0xCC, 0xAA, 0x62, 0xA0, 0x1E, 0xCF, 0xC0, 0x64, 0xCF, 0x99, 0x63, 0x9A, - 0x1E, 0xD8, 0xE7, 0x42, 0xFF, 0x97, 0x75, 0xA4, 0x1F, 0xE4, 0xF4, 0x5F, 0xE1, 0x94, 0x60, 0x9A, - 0x18, 0xCB, 0xE5, 0x48, 0xE1, 0xD5, 0x75, 0xA8, 0x1D, 0xBB + const char upSource[] = { + '\xAD', '\x14', '\x55', '\xD7', '\x53', '\x35', '\xD2', '\x08', '\xAB', '\x5F', '\x55', '\xE1', '\x2E', '\x41', '\x4B', '\x97', + '\x08', '\xD5', '\xF0', '\x5A', '\xCC', '\xAA', '\x62', '\xA0', '\x1E', '\xCF', '\xC0', '\x64', '\xCF', '\x99', '\x63', '\x9A', + '\x1E', '\xD8', '\xE7', '\x42', '\xFF', '\x97', '\x75', '\xA4', '\x1F', '\xE4', '\xF4', '\x5F', '\xE1', '\x94', '\x60', '\x9A', + '\x18', '\xCB', '\xE5', '\x48', '\xE1', '\xD5', '\x75', '\xA8', '\x1D', '\xBB' }; const std::string up(DecryptName<0xC517FB932D95BB6DULL>(upSource)); list->scrollBar->SetButtonImages(up, down); @@ -1487,25 +1489,25 @@ void RenewQuestUI::CUIQuestList::Slot15(int width, int height) { this->list->scrollBar->SetBackground(std::string()); { CUIListBoxEx* list = this->list; - const std::uint8_t bottomSource[] = { - 0x2F, 0xDE, 0x1F, 0xE9, 0xAD, 0x81, 0x02, 0x20, 0x29, 0x95, 0x1F, 0xDF, 0xD0, 0xF5, 0x9B, 0xBF, - 0x8A, 0x1F, 0xBA, 0x64, 0x32, 0x1E, 0xB2, 0x88, 0x9C, 0x05, 0x8A, 0x5A, 0x31, 0x2D, 0xB3, 0xB2, - 0x9C, 0x12, 0xAD, 0x7C, 0x01, 0x23, 0x85, 0x8C, 0x9D, 0x2E, 0xBB, 0x7C, 0x1A, 0x21, 0xE9, 0x8F, - 0x82, 0x01, 0xDF + const char bottomSource[] = { + '\x2F', '\xDE', '\x1F', '\xE9', '\xAD', '\x81', '\x02', '\x20', '\x29', '\x95', '\x1F', '\xDF', '\xD0', '\xF5', '\x9B', '\xBF', + '\x8A', '\x1F', '\xBA', '\x64', '\x32', '\x1E', '\xB2', '\x88', '\x9C', '\x05', '\x8A', '\x5A', '\x31', '\x2D', '\xB3', '\xB2', + '\x9C', '\x12', '\xAD', '\x7C', '\x01', '\x23', '\x85', '\x8C', '\x9D', '\x2E', '\xBB', '\x7C', '\x1A', '\x21', '\xE9', '\x8F', + '\x82', '\x01', '\xDF' }; const std::string bottom(DecryptName<0xEDC74F6D13DF71EFULL>(bottomSource)); - const std::uint8_t middleSource[] = { - 0x55, 0x20, 0x21, 0xF7, 0x9D, 0xC7, 0xA4, 0x3C, 0x53, 0x6B, 0x21, 0xC1, 0xE0, 0xB3, 0x3D, 0xA3, - 0xF0, 0xE1, 0x84, 0x7A, 0x02, 0x58, 0x14, 0x94, 0xE6, 0xFB, 0xB4, 0x44, 0x01, 0x6B, 0x15, 0xAE, - 0xE6, 0xEC, 0x93, 0x62, 0x31, 0x65, 0x23, 0x90, 0xE7, 0xD0, 0x8C, 0x64, 0x39, 0x27, 0x03, 0x9C, - 0xE5, 0x8F + const char middleSource[] = { + '\x55', '\x20', '\x21', '\xF7', '\x9D', '\xC7', '\xA4', '\x3C', '\x53', '\x6B', '\x21', '\xC1', '\xE0', '\xB3', '\x3D', '\xA3', + '\xF0', '\xE1', '\x84', '\x7A', '\x02', '\x58', '\x14', '\x94', '\xE6', '\xFB', '\xB4', '\x44', '\x01', '\x6B', '\x15', '\xAE', + '\xE6', '\xEC', '\x93', '\x62', '\x31', '\x65', '\x23', '\x90', '\xE7', '\xD0', '\x8C', '\x64', '\x39', '\x27', '\x03', '\x9C', + '\xE5', '\x8F' }; const std::string middle(DecryptName<0xF161095D0DE18F95ULL>(middleSource)); - const std::uint8_t topSource[] = { - 0x47, 0xBC, 0xAB, 0x85, 0xF9, 0xC7, 0xB4, 0xC6, 0x41, 0xF7, 0xAB, 0xB3, 0x84, 0xB3, 0x2D, 0x59, - 0xE2, 0x7D, 0x0E, 0x08, 0x66, 0x58, 0x04, 0x6E, 0xF4, 0x67, 0x3E, 0x36, 0x65, 0x6B, 0x05, 0x54, - 0xF4, 0x70, 0x19, 0x10, 0x55, 0x65, 0x33, 0x6A, 0xF5, 0x4C, 0x1E, 0x0F, 0x17, 0x6B, 0x1C, 0x7B, - 0x87 + const char topSource[] = { + '\x47', '\xBC', '\xAB', '\x85', '\xF9', '\xC7', '\xB4', '\xC6', '\x41', '\xF7', '\xAB', '\xB3', '\x84', '\xB3', '\x2D', '\x59', + '\xE2', '\x7D', '\x0E', '\x08', '\x66', '\x58', '\x04', '\x6E', '\xF4', '\x67', '\x3E', '\x36', '\x65', '\x6B', '\x05', '\x54', + '\xF4', '\x70', '\x19', '\x10', '\x55', '\x65', '\x33', '\x6A', '\xF5', '\x4C', '\x1E', '\x0F', '\x17', '\x6B', '\x1C', '\x7B', + '\x87' }; const std::string top(DecryptName<0x0B7109397F6B1387ULL>(topSource)); list->scrollBar->SetThumbImages(top, middle, bottom); @@ -1521,32 +1523,32 @@ void CUIRenewQuestUI::Slot15(int width, int height) { this->titleBar->SetSize(352, 17); this->titleBar->Move(29, 0); this->titleBar->SetImages(std::string(DecryptName<0x75ADC57D87EFBD8FULL>({ - 0x4F, 0x12, 0x2F, 0x7D, 0xBD, 0x0B, 0x68, 0xB8, 0x49, 0x59, 0x2F, 0x4B, 0xC0, 0x7F, 0xF1, 0x17, - 0xEE, 0xCE, 0x86, 0xE4, 0x22, 0xAC, 0xC3, 0x01, 0xEA, 0xCF, 0x89, 0xE6, 0x1E, 0xA0, 0xF1, 0x01, - 0xE6, 0xC9, 0x83, 0xE2, 0x1F, 0xA4, 0xDF, 0x2A, 0xE3, 0xD8, 0x89, 0xF3, 0x53, 0xA7, 0xC0, 0x05, - 0x8F + '\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', '\x01', + '\xE6', '\xC9', '\x83', '\xE2', '\x1F', '\xA4', '\xDF', '\x2A', '\xE3', '\xD8', '\x89', '\xF3', '\x53', '\xA7', '\xC0', '\x05', + '\x8F' })), std::string(DecryptName<0x2BAD156DE3E1F9D9ULL>({ - 0x19, 0x56, 0x21, 0x19, 0xAD, 0xDB, 0x68, 0xE6, 0x1F, 0x1D, 0x21, 0x2F, 0xD0, 0xAF, 0xF1, 0x49, - 0xB8, 0x8A, 0x88, 0x80, 0x32, 0x7C, 0xC3, 0x5F, 0xBC, 0x8B, 0x87, 0x82, 0x0E, 0x70, 0xF1, 0x5F, - 0xB0, 0x8D, 0x8D, 0x86, 0x0F, 0x74, 0xDF, 0x74, 0xB4, 0x90, 0x85, 0xCD, 0x0F, 0x78, 0xDD, 0x2B + '\x19', '\x56', '\x21', '\x19', '\xAD', '\xDB', '\x68', '\xE6', '\x1F', '\x1D', '\x21', '\x2F', '\xD0', '\xAF', '\xF1', '\x49', + '\xB8', '\x8A', '\x88', '\x80', '\x32', '\x7C', '\xC3', '\x5F', '\xBC', '\x8B', '\x87', '\x82', '\x0E', '\x70', '\xF1', '\x5F', + '\xB0', '\x8D', '\x8D', '\x86', '\x0F', '\x74', '\xDF', '\x74', '\xB4', '\x90', '\x85', '\xCD', '\x0F', '\x78', '\xDD', '\x2B' })), std::string(DecryptName<0x637B959D55771F69ULL>({ - 0xA9, 0xB0, 0xB7, 0xAF, 0x5D, 0x5B, 0xBE, 0xAE, 0xAF, 0xFB, 0xB7, 0x99, 0x20, 0x2F, 0x27, 0x01, - 0x08, 0x6C, 0x1E, 0x36, 0xC2, 0xFC, 0x15, 0x17, 0x0C, 0x6D, 0x11, 0x34, 0xFE, 0xF0, 0x27, 0x17, - 0x00, 0x6B, 0x1B, 0x30, 0xFF, 0xF4, 0x09, 0x3C, 0x1B, 0x76, 0x10, 0x3D, 0xE9, 0xBB, 0x19, 0x0E, - 0x19, 0x1F + '\xA9', '\xB0', '\xB7', '\xAF', '\x5D', '\x5B', '\xBE', '\xAE', '\xAF', '\xFB', '\xB7', '\x99', '\x20', '\x2F', '\x27', '\x01', + '\x08', '\x6C', '\x1E', '\x36', '\xC2', '\xFC', '\x15', '\x17', '\x0C', '\x6D', '\x11', '\x34', '\xFE', '\xF0', '\x27', '\x17', + '\x00', '\x6B', '\x1B', '\x30', '\xFF', '\xF4', '\x09', '\x3C', '\x1B', '\x76', '\x10', '\x3D', '\xE9', '\xBB', '\x19', '\x0E', + '\x19', '\x1F' }))); this->AddChild(this->titleBar); CUIStaticText* title = new CUIStaticText(); title->SetSize(100, 17); title->Move(18, 0); - const char* questText = DecryptName<0xD1413DBB01CD8B51ULL>({0x00, 0xDE, 0x88, 0x52, 0xEF, 0x3D}); + const char* questText = DecryptName<0xD1413DBB01CD8B51ULL>({'\x00', '\xDE', '\x88', '\x52', '\xEF', '\x3D'}); title->SetText(questText, std::strlen(questText)); title->SetFitText(0); title->SetAlign(0, 6); - title->SetFont(std::string(DecryptName<0x758F1D0B4F7705B9ULL>({0xFE, 0x70, 0x1B, 0x26, 0x66, 0x1D}))); + title->SetFont(std::string(DecryptName<0x758F1D0B4F7705B9ULL>({'\xFE', '\x70', '\x1B', '\x26', '\x66', '\x1D'}))); title->SetFontHeight(13); title->SetBold(0); title->SetColor(0); @@ -1563,24 +1565,24 @@ void CUIRenewQuestUI::Slot15(int width, int height) { systemButton->Invalidate(); systemButton->SetImages( std::string(DecryptName<0x891B232D09451965ULL>({ - 0xA5, 0xB6, 0x85, 0xF3, 0xED, 0xED, 0xDE, 0x44, 0xA3, 0xFD, 0x85, 0xC5, 0x90, 0x99, 0x47, 0xEB, - 0x04, 0x6A, 0x2C, 0x6A, 0x72, 0x4A, 0x75, 0xFD, 0x00, 0x6B, 0x23, 0x68, 0x4E, 0x46, 0x47, 0xFA, - 0x1C, 0x6A, 0x1A, 0x6B, 0x4C, 0x50, 0x7E, 0xD6, 0x0A, 0x7F, 0x23, 0x27, 0x4F, 0x4E, 0x6B, 0x89 + '\xA5', '\xB6', '\x85', '\xF3', '\xED', '\xED', '\xDE', '\x44', '\xA3', '\xFD', '\x85', '\xC5', '\x90', '\x99', '\x47', '\xEB', + '\x04', '\x6A', '\x2C', '\x6A', '\x72', '\x4A', '\x75', '\xFD', '\x00', '\x6B', '\x23', '\x68', '\x4E', '\x46', '\x47', '\xFA', + '\x1C', '\x6A', '\x1A', '\x6B', '\x4C', '\x50', '\x7E', '\xD6', '\x0A', '\x7F', '\x23', '\x27', '\x4F', '\x4E', '\x6B', '\x89' })), std::string(DecryptName<0xEF6D1D893F2B2DC5ULL>({ - 0x05, 0x82, 0xEB, 0xC5, 0x49, 0xD3, 0xA8, 0x22, 0x03, 0xC9, 0xEB, 0xF3, 0x34, 0xA7, 0x31, 0x8D, - 0xA4, 0x5E, 0x42, 0x5C, 0xD6, 0x74, 0x03, 0x9B, 0xA0, 0x5F, 0x4D, 0x5E, 0xEA, 0x78, 0x31, 0x9C, - 0xBC, 0x5E, 0x74, 0x5D, 0xE8, 0x6E, 0x08, 0xB0, 0xAA, 0x43, 0x05, 0x5D, 0xE4, 0x6D, 0x6D + '\x05', '\x82', '\xEB', '\xC5', '\x49', '\xD3', '\xA8', '\x22', '\x03', '\xC9', '\xEB', '\xF3', '\x34', '\xA7', '\x31', '\x8D', + '\xA4', '\x5E', '\x42', '\x5C', '\xD6', '\x74', '\x03', '\x9B', '\xA0', '\x5F', '\x4D', '\x5E', '\xEA', '\x78', '\x31', '\x9C', + '\xBC', '\x5E', '\x74', '\x5D', '\xE8', '\x6E', '\x08', '\xB0', '\xAA', '\x43', '\x05', '\x5D', '\xE4', '\x6D', '\x6D' })), std::string(DecryptName<0x234977DDB54BC71DULL>({ - 0xDD, 0x68, 0x8B, 0x4F, 0x1D, 0xB9, 0x8C, 0xEE, 0xDB, 0x23, 0x8B, 0x79, 0x60, 0xCD, 0x15, 0x41, - 0x7C, 0xB4, 0x22, 0xD6, 0x82, 0x1E, 0x27, 0x57, 0x78, 0xB5, 0x2D, 0xD4, 0xBE, 0x12, 0x15, 0x50, - 0x64, 0xB4, 0x14, 0xD7, 0xBC, 0x04, 0x2C, 0x7C, 0x72, 0xA9, 0x65, 0xD7, 0xB0, 0x07, 0x49 + '\xDD', '\x68', '\x8B', '\x4F', '\x1D', '\xB9', '\x8C', '\xEE', '\xDB', '\x23', '\x8B', '\x79', '\x60', '\xCD', '\x15', '\x41', + '\x7C', '\xB4', '\x22', '\xD6', '\x82', '\x1E', '\x27', '\x57', '\x78', '\xB5', '\x2D', '\xD4', '\xBE', '\x12', '\x15', '\x50', + '\x64', '\xB4', '\x14', '\xD7', '\xBC', '\x04', '\x2C', '\x7C', '\x72', '\xA9', '\x65', '\xD7', '\xB0', '\x07', '\x49' })), std::string(DecryptName<0x6FE153231D879777ULL>({ - 0xB7, 0x38, 0x47, 0xE7, 0xE3, 0x9D, 0x24, 0xA2, 0xB1, 0x73, 0x47, 0xD1, 0x9E, 0xE9, 0xBD, 0x0D, - 0x16, 0xE4, 0xEE, 0x7E, 0x7C, 0x3A, 0x8F, 0x1B, 0x12, 0xE5, 0xE1, 0x7C, 0x40, 0x36, 0xBD, 0x1C, - 0x0E, 0xE4, 0xD8, 0x7F, 0x42, 0x20, 0x84, 0x30, 0x18, 0xF1, 0xE1, 0x33, 0x41, 0x3E, 0x91, 0x6F + '\xB7', '\x38', '\x47', '\xE7', '\xE3', '\x9D', '\x24', '\xA2', '\xB1', '\x73', '\x47', '\xD1', '\x9E', '\xE9', '\xBD', '\x0D', + '\x16', '\xE4', '\xEE', '\x7E', '\x7C', '\x3A', '\x8F', '\x1B', '\x12', '\xE5', '\xE1', '\x7C', '\x40', '\x36', '\xBD', '\x1C', + '\x0E', '\xE4', '\xD8', '\x7F', '\x42', '\x20', '\x84', '\x30', '\x18', '\xF1', '\xE1', '\x33', '\x41', '\x3E', '\x91', '\x6F' })) ); this->titleBar->AddChild(systemButton); @@ -1589,9 +1591,9 @@ void CUIRenewQuestUI::Slot15(int width, int height) { this->background->SetSize(352, 449); this->background->Move(29, 17); this->background->SetImage(std::string(DecryptName<0x39A39F87DD5F535BULL>({ - 0x9B, 0xFC, 0x9F, 0x27, 0x47, 0x51, 0x66, 0xF4, 0x9D, 0xB7, 0x9F, 0x11, 0x3A, 0x25, 0xFF, 0x6B, - 0x3E, 0x3D, 0x3A, 0xAA, 0xD8, 0xCE, 0xD6, 0x5C, 0x28, 0x27, 0x0A, 0x94, 0xDB, 0xFD, 0xC4, 0x66, - 0x2A, 0x26, 0x3A, 0xAE, 0xF3, 0xB1, 0xC1, 0x54, 0x2B, 0x53 + '\x9B', '\xFC', '\x9F', '\x27', '\x47', '\x51', '\x66', '\xF4', '\x9D', '\xB7', '\x9F', '\x11', '\x3A', '\x25', '\xFF', '\x6B', + '\x3E', '\x3D', '\x3A', '\xAA', '\xD8', '\xCE', '\xD6', '\x5C', '\x28', '\x27', '\x0A', '\x94', '\xDB', '\xFD', '\xC4', '\x66', + '\x2A', '\x26', '\x3A', '\xAE', '\xF3', '\xB1', '\xC1', '\x54', '\x2B', '\x53' }))); this->AddChild(this->background); @@ -1610,7 +1612,7 @@ void CUIRenewQuestUI::Slot15(int width, int height) { processButton->SetText(std::string("")); processButton->SetFitText(0); processButton->SetAlign(0, 0); - processButton->SetFont(std::string(DecryptName<0x2FEB8739E5975BD1ULL>({0x96, 0x2E, 0xFB, 0x8C, 0x54, 0x87}))); + processButton->SetFont(std::string(DecryptName<0x2FEB8739E5975BD1ULL>({'\x96', '\x2E', '\xFB', '\x8C', '\x54', '\x87'}))); processButton->SetFontHeight(12); processButton->SetBold(0); processButton->SetTextColors(0, 0, 0, 0); @@ -1618,27 +1620,27 @@ void CUIRenewQuestUI::Slot15(int width, int height) { processButton->SetOutline(0, 0); processButton->SetImages( std::string(DecryptName<0x33133B977BCD03CDULL>({ - 0x0D, 0xAC, 0x0D, 0x81, 0x57, 0xF5, 0xD6, 0xFE, 0x0B, 0xE7, 0x0D, 0xB7, 0x2A, 0x81, 0x4F, 0x61, - 0xA8, 0x6D, 0xA8, 0x0C, 0xC8, 0x6A, 0x66, 0x56, 0xBE, 0x77, 0x98, 0x32, 0xCB, 0x4F, 0x72, 0x51, - 0x92, 0x73, 0xBF, 0x14, 0xF4, 0x5E, 0x60, 0x40, 0x92, 0x6C, 0xAB, 0x1D, 0xB9, 0x59, 0x7E, 0x43, - 0xCD + '\x0D', '\xAC', '\x0D', '\x81', '\x57', '\xF5', '\xD6', '\xFE', '\x0B', '\xE7', '\x0D', '\xB7', '\x2A', '\x81', '\x4F', '\x61', + '\xA8', '\x6D', '\xA8', '\x0C', '\xC8', '\x6A', '\x66', '\x56', '\xBE', '\x77', '\x98', '\x32', '\xCB', '\x4F', '\x72', '\x51', + '\x92', '\x73', '\xBF', '\x14', '\xF4', '\x5E', '\x60', '\x40', '\x92', '\x6C', '\xAB', '\x1D', '\xB9', '\x59', '\x7E', '\x43', + '\xCD' })), std::string(DecryptName<0xA12DAB392545D72FULL>({ - 0xEF, 0x78, 0x85, 0xDF, 0xF9, 0x65, 0xE8, 0x6C, 0xE9, 0x33, 0x85, 0xE9, 0x84, 0x11, 0x71, 0xF3, - 0x4A, 0xB9, 0x20, 0x52, 0x66, 0xFA, 0x58, 0xC4, 0x5C, 0xA3, 0x10, 0x6C, 0x65, 0xDF, 0x4C, 0xC3, - 0x70, 0xA7, 0x37, 0x4A, 0x5A, 0xCE, 0x5E, 0xD2, 0x70, 0xB8, 0x2B, 0x0B, 0x5B, 0xC6, 0x5D, 0xA1 + '\xEF', '\x78', '\x85', '\xDF', '\xF9', '\x65', '\xE8', '\x6C', '\xE9', '\x33', '\x85', '\xE9', '\x84', '\x11', '\x71', '\xF3', + '\x4A', '\xB9', '\x20', '\x52', '\x66', '\xFA', '\x58', '\xC4', '\x5C', '\xA3', '\x10', '\x6C', '\x65', '\xDF', '\x4C', '\xC3', + '\x70', '\xA7', '\x37', '\x4A', '\x5A', '\xCE', '\x5E', '\xD2', '\x70', '\xB8', '\x2B', '\x0B', '\x5B', '\xC6', '\x5D', '\xA1' })), std::string(DecryptName<0x6BA1C1132F033B75ULL>({ - 0xB5, 0x94, 0xC3, 0xD5, 0xD3, 0x0F, 0x64, 0xA6, 0xB3, 0xDF, 0xC3, 0xE3, 0xAE, 0x7B, 0xFD, 0x39, - 0x10, 0x55, 0x66, 0x58, 0x4C, 0x90, 0xD4, 0x0E, 0x06, 0x4F, 0x56, 0x66, 0x4F, 0xB5, 0xC0, 0x09, - 0x2A, 0x4B, 0x71, 0x40, 0x70, 0xA4, 0xD2, 0x18, 0x2A, 0x54, 0x65, 0x49, 0x3D, 0xA3, 0xCC, 0x1B, - 0x75 + '\xB5', '\x94', '\xC3', '\xD5', '\xD3', '\x0F', '\x64', '\xA6', '\xB3', '\xDF', '\xC3', '\xE3', '\xAE', '\x7B', '\xFD', '\x39', + '\x10', '\x55', '\x66', '\x58', '\x4C', '\x90', '\xD4', '\x0E', '\x06', '\x4F', '\x56', '\x66', '\x4F', '\xB5', '\xC0', '\x09', + '\x2A', '\x4B', '\x71', '\x40', '\x70', '\xA4', '\xD2', '\x18', '\x2A', '\x54', '\x65', '\x49', '\x3D', '\xA3', '\xCC', '\x1B', + '\x75' })), std::string(DecryptName<0x2DCB7567394DC1ABULL>({ - 0x6B, 0x6E, 0x8D, 0xC3, 0xA7, 0xBB, 0x0E, 0xE0, 0x6D, 0x25, 0x8D, 0xF5, 0xDA, 0xCF, 0x97, 0x7F, - 0xCE, 0xAF, 0x28, 0x4E, 0x38, 0x24, 0xBE, 0x48, 0xD8, 0xB5, 0x18, 0x70, 0x3B, 0x01, 0xAA, 0x4F, - 0xF4, 0xB1, 0x3F, 0x56, 0x04, 0x10, 0xB8, 0x5E, 0xF4, 0xAE, 0x2B, 0x5F, 0x49, 0x17, 0xA6, 0x5D, - 0xAB + '\x6B', '\x6E', '\x8D', '\xC3', '\xA7', '\xBB', '\x0E', '\xE0', '\x6D', '\x25', '\x8D', '\xF5', '\xDA', '\xCF', '\x97', '\x7F', + '\xCE', '\xAF', '\x28', '\x4E', '\x38', '\x24', '\xBE', '\x48', '\xD8', '\xB5', '\x18', '\x70', '\x3B', '\x01', '\xAA', '\x4F', + '\xF4', '\xB1', '\x3F', '\x56', '\x04', '\x10', '\xB8', '\x5E', '\xF4', '\xAE', '\x2B', '\x5F', '\x49', '\x17', '\xA6', '\x5D', + '\xAB' })) ); this->tab->AddChild(processButton); @@ -1652,7 +1654,7 @@ void CUIRenewQuestUI::Slot15(int width, int height) { recommendedButton->SetText(std::string("")); recommendedButton->SetFitText(0); recommendedButton->SetAlign(0, 0); - recommendedButton->SetFont(std::string(DecryptName<0x4F637DC51307B759ULL>({0x1E, 0xC2, 0x6B, 0x7A, 0xA8, 0x7D}))); + recommendedButton->SetFont(std::string(DecryptName<0x4F637DC51307B759ULL>({'\x1E', '\xC2', '\x6B', '\x7A', '\xA8', '\x7D'}))); recommendedButton->SetFontHeight(12); recommendedButton->SetBold(0); recommendedButton->SetTextColors(0, 0, 0, 0); @@ -1660,28 +1662,28 @@ void CUIRenewQuestUI::Slot15(int width, int height) { recommendedButton->SetOutline(0, 0); recommendedButton->SetImages( std::string(DecryptName<0x8D1D0FF1AF2B13F7ULL>({ - 0x37, 0xBC, 0xEB, 0x55, 0x31, 0xC1, 0xD8, 0x40, 0x31, 0xF7, 0xEB, 0x63, 0x4C, 0xB5, 0x41, 0xDF, - 0x92, 0x7D, 0x4E, 0xD8, 0xAE, 0x5E, 0x68, 0xE8, 0x84, 0x67, 0x7E, 0xE6, 0xAD, 0x7B, 0x7C, 0xEF, - 0xA8, 0x61, 0x4E, 0xCC, 0x9E, 0x62, 0x70, 0xE8, 0x99, 0x77, 0x4E, 0xCB, 0xAE, 0x60, 0x7B, 0xEB, - 0xD9, 0x71, 0x46, 0xDF, 0xF1 + '\x37', '\xBC', '\xEB', '\x55', '\x31', '\xC1', '\xD8', '\x40', '\x31', '\xF7', '\xEB', '\x63', '\x4C', '\xB5', '\x41', '\xDF', + '\x92', '\x7D', '\x4E', '\xD8', '\xAE', '\x5E', '\x68', '\xE8', '\x84', '\x67', '\x7E', '\xE6', '\xAD', '\x7B', '\x7C', '\xEF', + '\xA8', '\x61', '\x4E', '\xCC', '\x9E', '\x62', '\x70', '\xE8', '\x99', '\x77', '\x4E', '\xCB', '\xAE', '\x60', '\x7B', '\xEB', + '\xD9', '\x71', '\x46', '\xDF', '\xF1' })), std::string(DecryptName<0xB39FA7917BCFBB8DULL>({ - 0x4D, 0x14, 0x0F, 0x81, 0x51, 0x69, 0x5A, 0x7E, 0x4B, 0x5F, 0x0F, 0xB7, 0x2C, 0x1D, 0xC3, 0xE1, - 0xE8, 0xD5, 0xAA, 0x0C, 0xCE, 0xF6, 0xEA, 0xD6, 0xFE, 0xCF, 0x9A, 0x32, 0xCD, 0xD3, 0xFE, 0xD1, - 0xD2, 0xC9, 0xAA, 0x18, 0xFE, 0xCA, 0xF2, 0xD6, 0xE3, 0xDF, 0xAA, 0x1F, 0xCE, 0xC8, 0xF1, 0x9D, - 0xEF, 0xD6, 0xBF, 0x7B + '\x4D', '\x14', '\x0F', '\x81', '\x51', '\x69', '\x5A', '\x7E', '\x4B', '\x5F', '\x0F', '\xB7', '\x2C', '\x1D', '\xC3', '\xE1', + '\xE8', '\xD5', '\xAA', '\x0C', '\xCE', '\xF6', '\xEA', '\xD6', '\xFE', '\xCF', '\x9A', '\x32', '\xCD', '\xD3', '\xFE', '\xD1', + '\xD2', '\xC9', '\xAA', '\x18', '\xFE', '\xCA', '\xF2', '\xD6', '\xE3', '\xDF', '\xAA', '\x1F', '\xCE', '\xC8', '\xF1', '\x9D', + '\xEF', '\xD6', '\xBF', '\x7B' })), std::string(DecryptName<0x9171997D6963C9F7ULL>({ - 0x37, 0x66, 0xA3, 0x93, 0xBD, 0x57, 0xB4, 0x5C, 0x31, 0x2D, 0xA3, 0xA5, 0xC0, 0x23, 0x2D, 0xC3, - 0x92, 0xA7, 0x06, 0x1E, 0x22, 0xC8, 0x04, 0xF4, 0x84, 0xBD, 0x36, 0x20, 0x21, 0xED, 0x10, 0xF3, - 0xA8, 0xBB, 0x06, 0x0A, 0x12, 0xF4, 0x1C, 0xF4, 0x99, 0xAD, 0x06, 0x0D, 0x22, 0xF6, 0x17, 0xF7, - 0xD9, 0xAB, 0x0E, 0x19, 0x7D + '\x37', '\x66', '\xA3', '\x93', '\xBD', '\x57', '\xB4', '\x5C', '\x31', '\x2D', '\xA3', '\xA5', '\xC0', '\x23', '\x2D', '\xC3', + '\x92', '\xA7', '\x06', '\x1E', '\x22', '\xC8', '\x04', '\xF4', '\x84', '\xBD', '\x36', '\x20', '\x21', '\xED', '\x10', '\xF3', + '\xA8', '\xBB', '\x06', '\x0A', '\x12', '\xF4', '\x1C', '\xF4', '\x99', '\xAD', '\x06', '\x0D', '\x22', '\xF6', '\x17', '\xF7', + '\xD9', '\xAB', '\x0E', '\x19', '\x7D' })), std::string(DecryptName<0x4F99DF03C3EF31B7ULL>({ - 0x77, 0x9E, 0x2F, 0x39, 0xC3, 0x11, 0x5C, 0x82, 0x71, 0xD5, 0x2F, 0x0F, 0xBE, 0x65, 0xC5, 0x1D, - 0xD2, 0x5F, 0x8A, 0xB4, 0x5C, 0x8E, 0xEC, 0x2A, 0xC4, 0x45, 0xBA, 0x8A, 0x5F, 0xAB, 0xF8, 0x2D, - 0xE8, 0x43, 0x8A, 0xA0, 0x6C, 0xB2, 0xF4, 0x2A, 0xD9, 0x55, 0x8A, 0xA7, 0x5C, 0xB0, 0xFF, 0x29, - 0x99, 0x53, 0x82, 0xB3, 0x03 + '\x77', '\x9E', '\x2F', '\x39', '\xC3', '\x11', '\x5C', '\x82', '\x71', '\xD5', '\x2F', '\x0F', '\xBE', '\x65', '\xC5', '\x1D', + '\xD2', '\x5F', '\x8A', '\xB4', '\x5C', '\x8E', '\xEC', '\x2A', '\xC4', '\x45', '\xBA', '\x8A', '\x5F', '\xAB', '\xF8', '\x2D', + '\xE8', '\x43', '\x8A', '\xA0', '\x6C', '\xB2', '\xF4', '\x2A', '\xD9', '\x55', '\x8A', '\xA7', '\x5C', '\xB0', '\xFF', '\x29', + '\x99', '\x53', '\x82', '\xB3', '\x03' })) ); this->tab->AddChild(recommendedButton); @@ -1695,7 +1697,7 @@ void CUIRenewQuestUI::Slot15(int width, int height) { holdButton->SetText(std::string("")); holdButton->SetFitText(0); holdButton->SetAlign(0, 0); - holdButton->SetFont(std::string(DecryptName<0xE52DF30DCBAF7125ULL>({0x62, 0x04, 0xC3, 0xA2, 0x60, 0xF3}))); + holdButton->SetFont(std::string(DecryptName<0xE52DF30DCBAF7125ULL>({'\x62', '\x04', '\xC3', '\xA2', '\x60', '\xF3'}))); holdButton->SetFontHeight(12); holdButton->SetBold(0); holdButton->SetTextColors(0, 0, 0, 0); @@ -1703,24 +1705,24 @@ void CUIRenewQuestUI::Slot15(int width, int height) { holdButton->SetOutline(0, 0); holdButton->SetImages( std::string(DecryptName<0xCFF3899D95AF355FULL>({ - 0x9F, 0x9A, 0x6F, 0x6F, 0x5D, 0x47, 0x36, 0x02, 0x99, 0xD1, 0x6F, 0x59, 0x20, 0x33, 0xAF, 0x9D, - 0x3A, 0x5B, 0xCA, 0xE2, 0xC2, 0xD8, 0x86, 0xAA, 0x2C, 0x41, 0xFA, 0xDC, 0xC1, 0xFD, 0x92, 0xAD, - 0x00, 0x5D, 0xC0, 0xF9, 0xF9, 0xD6, 0x9C, 0xA9, 0x39, 0x1B, 0xCD, 0xF8, 0xED, 0x89 + '\x9F', '\x9A', '\x6F', '\x6F', '\x5D', '\x47', '\x36', '\x02', '\x99', '\xD1', '\x6F', '\x59', '\x20', '\x33', '\xAF', '\x9D', + '\x3A', '\x5B', '\xCA', '\xE2', '\xC2', '\xD8', '\x86', '\xAA', '\x2C', '\x41', '\xFA', '\xDC', '\xC1', '\xFD', '\x92', '\xAD', + '\x00', '\x5D', '\xC0', '\xF9', '\xF9', '\xD6', '\x9C', '\xA9', '\x39', '\x1B', '\xCD', '\xF8', '\xED', '\x89' })), std::string(DecryptName<0xFBD599E117C547C1ULL>({ - 0x01, 0xE8, 0x05, 0xED, 0x21, 0x57, 0x10, 0x36, 0x07, 0xA3, 0x05, 0xDB, 0x5C, 0x23, 0x89, 0xA9, - 0xA4, 0x29, 0xA0, 0x60, 0xBE, 0xC8, 0xA0, 0x9E, 0xB2, 0x33, 0x90, 0x5E, 0xBD, 0xED, 0xB4, 0x99, - 0x9E, 0x2F, 0xAA, 0x7B, 0x85, 0xC6, 0xBA, 0x95, 0xEF, 0x25, 0xA8, 0x67, 0xE1 + '\x01', '\xE8', '\x05', '\xED', '\x21', '\x57', '\x10', '\x36', '\x07', '\xA3', '\x05', '\xDB', '\x5C', '\x23', '\x89', '\xA9', + '\xA4', '\x29', '\xA0', '\x60', '\xBE', '\xC8', '\xA0', '\x9E', '\xB2', '\x33', '\x90', '\x5E', '\xBD', '\xED', '\xB4', '\x99', + '\x9E', '\x2F', '\xAA', '\x7B', '\x85', '\xC6', '\xBA', '\x95', '\xEF', '\x25', '\xA8', '\x67', '\xE1' })), std::string(DecryptName<0x176F138D5DD7F365ULL>({ - 0xA5, 0x5C, 0x17, 0xA7, 0x4D, 0xDD, 0xAA, 0xDA, 0xA3, 0x17, 0x17, 0x91, 0x30, 0xA9, 0x33, 0x45, - 0x00, 0x9D, 0xB2, 0x2A, 0xD2, 0x42, 0x1A, 0x72, 0x16, 0x87, 0x82, 0x14, 0xD1, 0x67, 0x0E, 0x75, - 0x3A, 0x9B, 0xB8, 0x31, 0xE9, 0x4C, 0x00, 0x71, 0x03, 0xDD, 0xB5, 0x30, 0xFD, 0x13 + '\xA5', '\x5C', '\x17', '\xA7', '\x4D', '\xDD', '\xAA', '\xDA', '\xA3', '\x17', '\x17', '\x91', '\x30', '\xA9', '\x33', '\x45', + '\x00', '\x9D', '\xB2', '\x2A', '\xD2', '\x42', '\x1A', '\x72', '\x16', '\x87', '\x82', '\x14', '\xD1', '\x67', '\x0E', '\x75', + '\x3A', '\x9B', '\xB8', '\x31', '\xE9', '\x4C', '\x00', '\x71', '\x03', '\xDD', '\xB5', '\x30', '\xFD', '\x13' })), std::string(DecryptName<0x2D51E3B7236175EDULL>({ - 0x2D, 0xDA, 0xA1, 0xD9, 0x77, 0x2D, 0x94, 0xE0, 0x2B, 0x91, 0xA1, 0xEF, 0x0A, 0x59, 0x0D, 0x7F, - 0x88, 0x1B, 0x04, 0x54, 0xE8, 0xB2, 0x24, 0x48, 0x9E, 0x01, 0x34, 0x6A, 0xEB, 0x97, 0x30, 0x4F, - 0xB2, 0x1D, 0x0E, 0x4F, 0xD3, 0xBC, 0x3E, 0x4B, 0x8B, 0x5B, 0x03, 0x4E, 0xC7, 0xE3 + '\x2D', '\xDA', '\xA1', '\xD9', '\x77', '\x2D', '\x94', '\xE0', '\x2B', '\x91', '\xA1', '\xEF', '\x0A', '\x59', '\x0D', '\x7F', + '\x88', '\x1B', '\x04', '\x54', '\xE8', '\xB2', '\x24', '\x48', '\x9E', '\x01', '\x34', '\x6A', '\xEB', '\x97', '\x30', '\x4F', + '\xB2', '\x1D', '\x0E', '\x4F', '\xD3', '\xBC', '\x3E', '\x4B', '\x8B', '\x5B', '\x03', '\x4E', '\xC7', '\xE3' })) ); this->tab->AddChild(holdButton); @@ -1734,7 +1736,7 @@ void CUIRenewQuestUI::Slot15(int width, int height) { waitButton->SetText(std::string("")); waitButton->SetFitText(0); waitButton->SetAlign(0, 0); - waitButton->SetFont(std::string(DecryptName<0x0F41EBBDA32D1B17ULL>({0x50, 0x6E, 0x41, 0xCA, 0xD0, 0xEB}))); + waitButton->SetFont(std::string(DecryptName<0x0F41EBBDA32D1B17ULL>({'\x50', '\x6E', '\x41', '\xCA', '\xD0', '\xEB'}))); waitButton->SetFontHeight(12); waitButton->SetBold(0); waitButton->SetTextColors(0, 0, 0, 0); @@ -1742,24 +1744,24 @@ void CUIRenewQuestUI::Slot15(int width, int height) { waitButton->SetOutline(0, 0); waitButton->SetImages( std::string(DecryptName<0x839B27DF8F5967B3ULL>({ - 0x73, 0xC8, 0x99, 0x75, 0x1F, 0xE9, 0x5E, 0x4E, 0x75, 0x83, 0x99, 0x43, 0x62, 0x9D, 0xC7, 0xD1, - 0xD6, 0x09, 0x3C, 0xF8, 0x80, 0x76, 0xEE, 0xE6, 0xC0, 0x13, 0x0C, 0xC6, 0x83, 0x53, 0xFA, 0xE1, - 0xEC, 0x10, 0x38, 0xE6, 0xAB, 0x78, 0xF4, 0xE5, 0xD5, 0x49, 0x3B, 0xE2, 0xAF, 0x27 + '\x73', '\xC8', '\x99', '\x75', '\x1F', '\xE9', '\x5E', '\x4E', '\x75', '\x83', '\x99', '\x43', '\x62', '\x9D', '\xC7', '\xD1', + '\xD6', '\x09', '\x3C', '\xF8', '\x80', '\x76', '\xEE', '\xE6', '\xC0', '\x13', '\x0C', '\xC6', '\x83', '\x53', '\xFA', '\xE1', + '\xEC', '\x10', '\x38', '\xE6', '\xAB', '\x78', '\xF4', '\xE5', '\xD5', '\x49', '\x3B', '\xE2', '\xAF', '\x27' })), std::string(DecryptName<0xF3CB6F7711A71B6DULL>({ - 0xAD, 0xB4, 0x67, 0xEB, 0xB7, 0xA1, 0x0E, 0x3E, 0xAB, 0xFF, 0x67, 0xDD, 0xCA, 0xD5, 0x97, 0xA1, - 0x08, 0x75, 0xC2, 0x66, 0x28, 0x3E, 0xBE, 0x96, 0x1E, 0x6F, 0xF2, 0x58, 0x2B, 0x1B, 0xAA, 0x91, - 0x32, 0x6C, 0xC6, 0x78, 0x03, 0x30, 0xA4, 0x9D, 0x43, 0x79, 0xCA, 0x61, 0x77 + '\xAD', '\xB4', '\x67', '\xEB', '\xB7', '\xA1', '\x0E', '\x3E', '\xAB', '\xFF', '\x67', '\xDD', '\xCA', '\xD5', '\x97', '\xA1', + '\x08', '\x75', '\xC2', '\x66', '\x28', '\x3E', '\xBE', '\x96', '\x1E', '\x6F', '\xF2', '\x58', '\x2B', '\x1B', '\xAA', '\x91', + '\x32', '\x6C', '\xC6', '\x78', '\x03', '\x30', '\xA4', '\x9D', '\x43', '\x79', '\xCA', '\x61', '\x77' })), std::string(DecryptName<0x452FEF0D7FC95565ULL>({ - 0xA5, 0xFA, 0x09, 0x85, 0xCD, 0x21, 0xEA, 0x88, 0xA3, 0xB1, 0x09, 0xB3, 0xB0, 0x55, 0x73, 0x17, - 0x00, 0x3B, 0xAC, 0x08, 0x52, 0xBE, 0x5A, 0x20, 0x16, 0x21, 0x9C, 0x36, 0x51, 0x9B, 0x4E, 0x27, - 0x3A, 0x22, 0xA8, 0x16, 0x79, 0xB0, 0x40, 0x23, 0x03, 0x7B, 0xAB, 0x12, 0x7D, 0xEF + '\xA5', '\xFA', '\x09', '\x85', '\xCD', '\x21', '\xEA', '\x88', '\xA3', '\xB1', '\x09', '\xB3', '\xB0', '\x55', '\x73', '\x17', + '\x00', '\x3B', '\xAC', '\x08', '\x52', '\xBE', '\x5A', '\x20', '\x16', '\x21', '\x9C', '\x36', '\x51', '\x9B', '\x4E', '\x27', + '\x3A', '\x22', '\xA8', '\x16', '\x79', '\xB0', '\x40', '\x23', '\x03', '\x7B', '\xAB', '\x12', '\x7D', '\xEF' })), std::string(DecryptName<0x9FED7DA189490D5DULL>({ - 0x9D, 0xA2, 0x89, 0x73, 0x61, 0xB3, 0x28, 0x52, 0x9B, 0xE9, 0x89, 0x45, 0x1C, 0xC7, 0xB1, 0xCD, - 0x38, 0x63, 0x2C, 0xFE, 0xFE, 0x2C, 0x98, 0xFA, 0x2E, 0x79, 0x1C, 0xC0, 0xFD, 0x09, 0x8C, 0xFD, - 0x02, 0x7A, 0x28, 0xE0, 0xD5, 0x22, 0x82, 0xF9, 0x3B, 0x23, 0x2B, 0xE4, 0xD1, 0x7D + '\x9D', '\xA2', '\x89', '\x73', '\x61', '\xB3', '\x28', '\x52', '\x9B', '\xE9', '\x89', '\x45', '\x1C', '\xC7', '\xB1', '\xCD', + '\x38', '\x63', '\x2C', '\xFE', '\xFE', '\x2C', '\x98', '\xFA', '\x2E', '\x79', '\x1C', '\xC0', '\xFD', '\x09', '\x8C', '\xFD', + '\x02', '\x7A', '\x28', '\xE0', '\xD5', '\x22', '\x82', '\xF9', '\x3B', '\x23', '\x2B', '\xE4', '\xD1', '\x7D' })) ); this->tab->AddChild(waitButton); @@ -1772,24 +1774,24 @@ void CUIRenewQuestUI::Slot15(int width, int height) { this->checkBox->Invalidate(); this->checkBox->SetImages( std::string(DecryptName<0x7DE349D717D7F123ULL>({ - 0xE3, 0x5E, 0x17, 0xED, 0x17, 0x87, 0x26, 0xB0, 0xE5, 0x15, 0x17, 0xDB, 0x6A, 0xF3, 0xBF, 0x2F, - 0x46, 0x9F, 0xB2, 0x60, 0x88, 0x18, 0x96, 0x18, 0x50, 0x85, 0x82, 0x5E, 0x8B, 0x2A, 0x8B, 0x18, - 0x40, 0x9A, 0xB5, 0x78, 0xAF, 0x16, 0x8C, 0x1B, 0x45, 0xDF, 0xB5, 0x7A, 0xA7, 0x49 + '\xE3', '\x5E', '\x17', '\xED', '\x17', '\x87', '\x26', '\xB0', '\xE5', '\x15', '\x17', '\xDB', '\x6A', '\xF3', '\xBF', '\x2F', + '\x46', '\x9F', '\xB2', '\x60', '\x88', '\x18', '\x96', '\x18', '\x50', '\x85', '\x82', '\x5E', '\x8B', '\x2A', '\x8B', '\x18', + '\x40', '\x9A', '\xB5', '\x78', '\xAF', '\x16', '\x8C', '\x1B', '\x45', '\xDF', '\xB5', '\x7A', '\xA7', '\x49' })), std::string(DecryptName<0x0F15B16B5BAFD57FULL>({ - 0xBF, 0x7A, 0x6F, 0xA1, 0xAB, 0x7F, 0xD0, 0xC2, 0xB9, 0x31, 0x6F, 0x97, 0xD6, 0x0B, 0x49, 0x5D, - 0x1A, 0xBB, 0xCA, 0x2C, 0x34, 0xE0, 0x60, 0x6A, 0x0C, 0xA1, 0xFA, 0x12, 0x37, 0xD2, 0x7D, 0x6A, - 0x1C, 0xBE, 0xCD, 0x34, 0x13, 0xEE, 0x7A, 0x61, 0x51, 0xB7, 0xC2, 0x2B, 0x6B + '\xBF', '\x7A', '\x6F', '\xA1', '\xAB', '\x7F', '\xD0', '\xC2', '\xB9', '\x31', '\x6F', '\x97', '\xD6', '\x0B', '\x49', '\x5D', + '\x1A', '\xBB', '\xCA', '\x2C', '\x34', '\xE0', '\x60', '\x6A', '\x0C', '\xA1', '\xFA', '\x12', '\x37', '\xD2', '\x7D', '\x6A', + '\x1C', '\xBE', '\xCD', '\x34', '\x13', '\xEE', '\x7A', '\x61', '\x51', '\xB7', '\xC2', '\x2B', '\x6B' })), std::string(DecryptName<0x7941D76335CFA14FULL>({ - 0x8F, 0x0E, 0x0F, 0xCF, 0xA3, 0x19, 0x84, 0xB4, 0x89, 0x45, 0x0F, 0xF9, 0xDE, 0x6D, 0x1D, 0x2B, - 0x2A, 0xCF, 0xAA, 0x42, 0x3C, 0x86, 0x34, 0x1C, 0x3C, 0xD5, 0x9A, 0x7C, 0x3F, 0xB4, 0x29, 0x1C, - 0x2C, 0xCA, 0xAD, 0x5A, 0x1B, 0x88, 0x2E, 0x1F, 0x29, 0x8F, 0xAD, 0x58, 0x13, 0xD7 + '\x8F', '\x0E', '\x0F', '\xCF', '\xA3', '\x19', '\x84', '\xB4', '\x89', '\x45', '\x0F', '\xF9', '\xDE', '\x6D', '\x1D', '\x2B', + '\x2A', '\xCF', '\xAA', '\x42', '\x3C', '\x86', '\x34', '\x1C', '\x3C', '\xD5', '\x9A', '\x7C', '\x3F', '\xB4', '\x29', '\x1C', + '\x2C', '\xCA', '\xAD', '\x5A', '\x1B', '\x88', '\x2E', '\x1F', '\x29', '\x8F', '\xAD', '\x58', '\x13', '\xD7' })), std::string(DecryptName<0x7321C3814F8799E1ULL>({ - 0x21, 0x36, 0x47, 0xB5, 0x41, 0x0D, 0xE4, 0xBE, 0x27, 0x7D, 0x47, 0x83, 0x3C, 0x79, 0x7D, 0x21, - 0x84, 0xF7, 0xE2, 0x38, 0xDE, 0x92, 0x54, 0x16, 0x92, 0xED, 0xD2, 0x06, 0xDD, 0xA0, 0x49, 0x16, - 0x82, 0xF2, 0xE5, 0x20, 0xF9, 0x9C, 0x4E, 0x15, 0x87, 0xB7, 0xE5, 0x22, 0xF1, 0xC3 + '\x21', '\x36', '\x47', '\xB5', '\x41', '\x0D', '\xE4', '\xBE', '\x27', '\x7D', '\x47', '\x83', '\x3C', '\x79', '\x7D', '\x21', + '\x84', '\xF7', '\xE2', '\x38', '\xDE', '\x92', '\x54', '\x16', '\x92', '\xED', '\xD2', '\x06', '\xDD', '\xA0', '\x49', '\x16', + '\x82', '\xF2', '\xE5', '\x20', '\xF9', '\x9C', '\x4E', '\x15', '\x87', '\xB7', '\xE5', '\x22', '\xF1', '\xC3' })) ); this->checkBox->checked = false; @@ -1802,7 +1804,7 @@ void CUIRenewQuestUI::Slot15(int width, int height) { this->filterLabel->SetText("", 0); this->filterLabel->SetFitText(0); this->filterLabel->SetAlign(0, 0); - this->filterLabel->SetFont(std::string(DecryptName<0x7115D9F973F913C9ULL>({0x8E, 0x66, 0x95, 0x1A, 0x94, 0xD9}))); + this->filterLabel->SetFont(std::string(DecryptName<0x7115D9F973F913C9ULL>({'\x8E', '\x66', '\x95', '\x1A', '\x94', '\xD9'}))); this->filterLabel->SetFontHeight(12); this->filterLabel->SetBold(0); this->filterLabel->SetColor(0); @@ -1818,24 +1820,24 @@ void CUIRenewQuestUI::Slot15(int width, int height) { this->closeButton->Invalidate(); this->closeButton->SetImages( std::string(DecryptName<0xCB1D253B7FE1F563ULL>({ - 0xA3, 0x5A, 0x21, 0x85, 0xFB, 0xEB, 0xD8, 0x06, 0xA5, 0x11, 0x21, 0xB3, 0x86, 0x9F, 0x41, 0xA9, - 0x02, 0x86, 0x88, 0x1C, 0x64, 0x4C, 0x73, 0xBF, 0x06, 0x87, 0x87, 0x1E, 0x58, 0x40, 0x41, 0xA9, - 0x17, 0x9B, 0xBE, 0x1C, 0x57, 0x4A, 0x6E, 0xAE, 0x4D, 0x97, 0x8C, 0x0F, 0x3B + '\xA3', '\x5A', '\x21', '\x85', '\xFB', '\xEB', '\xD8', '\x06', '\xA5', '\x11', '\x21', '\xB3', '\x86', '\x9F', '\x41', '\xA9', + '\x02', '\x86', '\x88', '\x1C', '\x64', '\x4C', '\x73', '\xBF', '\x06', '\x87', '\x87', '\x1E', '\x58', '\x40', '\x41', '\xA9', + '\x17', '\x9B', '\xBE', '\x1C', '\x57', '\x4A', '\x6E', '\xAE', '\x4D', '\x97', '\x8C', '\x0F', '\x3B' })), std::string(DecryptName<0x793F370985ED674FULL>({ - 0x8F, 0xC8, 0x2D, 0x7F, 0xC9, 0xF9, 0xFA, 0xB4, 0x89, 0x83, 0x2D, 0x49, 0xB4, 0x8D, 0x63, 0x1B, - 0x2E, 0x14, 0x84, 0xE6, 0x56, 0x5E, 0x51, 0x0D, 0x2A, 0x15, 0x8B, 0xE4, 0x6A, 0x52, 0x63, 0x1B, - 0x3B, 0x09, 0xB2, 0xE6, 0x65, 0x58, 0x4C, 0x1C, 0x10, 0x05, 0xC3, 0xE7, 0x64, 0x47, 0x3F + '\x8F', '\xC8', '\x2D', '\x7F', '\xC9', '\xF9', '\xFA', '\xB4', '\x89', '\x83', '\x2D', '\x49', '\xB4', '\x8D', '\x63', '\x1B', + '\x2E', '\x14', '\x84', '\xE6', '\x56', '\x5E', '\x51', '\x0D', '\x2A', '\x15', '\x8B', '\xE4', '\x6A', '\x52', '\x63', '\x1B', + '\x3B', '\x09', '\xB2', '\xE6', '\x65', '\x58', '\x4C', '\x1C', '\x10', '\x05', '\xC3', '\xE7', '\x64', '\x47', '\x3F' })), std::string(DecryptName<0xE55723712993051DULL>({ - 0xDD, 0xAA, 0x53, 0xD3, 0xB1, 0xED, 0x92, 0x28, 0xDB, 0xE1, 0x53, 0xE5, 0xCC, 0x99, 0x0B, 0x87, - 0x7C, 0x76, 0xFA, 0x4A, 0x2E, 0x4A, 0x39, 0x91, 0x78, 0x77, 0xF5, 0x48, 0x12, 0x46, 0x0B, 0x87, - 0x69, 0x6B, 0xCC, 0x4A, 0x1D, 0x4C, 0x24, 0x80, 0x42, 0x64, 0xBD, 0x4B, 0x1C, 0x53, 0x57 + '\xDD', '\xAA', '\x53', '\xD3', '\xB1', '\xED', '\x92', '\x28', '\xDB', '\xE1', '\x53', '\xE5', '\xCC', '\x99', '\x0B', '\x87', + '\x7C', '\x76', '\xFA', '\x4A', '\x2E', '\x4A', '\x39', '\x91', '\x78', '\x77', '\xF5', '\x48', '\x12', '\x46', '\x0B', '\x87', + '\x69', '\x6B', '\xCC', '\x4A', '\x1D', '\x4C', '\x24', '\x80', '\x42', '\x64', '\xBD', '\x4B', '\x1C', '\x53', '\x57' })), std::string(DecryptName<0x3FA3AFA7035DE3FFULL>({ - 0x3F, 0x4C, 0x9D, 0xF9, 0x67, 0x61, 0x66, 0xF2, 0x39, 0x07, 0x9D, 0xCF, 0x1A, 0x15, 0xFF, 0x5D, - 0x9E, 0x90, 0x34, 0x60, 0xF8, 0xC6, 0xCD, 0x4B, 0x9A, 0x91, 0x3B, 0x62, 0xC4, 0xCA, 0xFF, 0x5D, - 0x8B, 0x8D, 0x02, 0x60, 0xCB, 0xC0, 0xD0, 0x5A, 0xD1, 0x81, 0x30, 0x73, 0xA7 + '\x3F', '\x4C', '\x9D', '\xF9', '\x67', '\x61', '\x66', '\xF2', '\x39', '\x07', '\x9D', '\xCF', '\x1A', '\x15', '\xFF', '\x5D', + '\x9E', '\x90', '\x34', '\x60', '\xF8', '\xC6', '\xCD', '\x4B', '\x9A', '\x91', '\x3B', '\x62', '\xC4', '\xCA', '\xFF', '\x5D', + '\x8B', '\x8D', '\x02', '\x60', '\xCB', '\xC0', '\xD0', '\x5A', '\xD1', '\x81', '\x30', '\x73', '\xA7' })) ); this->AddChild(this->closeButton); @@ -1855,9 +1857,9 @@ void CUIRenewQuestUI::Slot15(int width, int height) { this->searchBackground->SetSize(352, 28); this->searchBackground->Move(29, 411); this->searchBackground->SetImage(std::string(DecryptName<0xDB27CB557D038759ULL>({ - 0x99, 0x28, 0xC3, 0x87, 0x95, 0x05, 0xE2, 0x16, 0x9F, 0x63, 0xC3, 0xB1, 0xE8, 0x71, 0x7B, 0x89, - 0x3C, 0xE9, 0x66, 0x0A, 0x0A, 0x9A, 0x52, 0xBE, 0x2A, 0xF3, 0x56, 0x34, 0x09, 0xA9, 0x40, 0x84, - 0x2A, 0xE2, 0x62, 0x0F, 0x36, 0xA3, 0x09, 0xB9, 0x34, 0xF7, 0x03 + '\x99', '\x28', '\xC3', '\x87', '\x95', '\x05', '\xE2', '\x16', '\x9F', '\x63', '\xC3', '\xB1', '\xE8', '\x71', '\x7B', '\x89', + '\x3C', '\xE9', '\x66', '\x0A', '\x0A', '\x9A', '\x52', '\xBE', '\x2A', '\xF3', '\x56', '\x34', '\x09', '\xA9', '\x40', '\x84', + '\x2A', '\xE2', '\x62', '\x0F', '\x36', '\xA3', '\x09', '\xB9', '\x34', '\xF7', '\x03' }))); this->AddChild(this->searchBackground); @@ -1877,7 +1879,7 @@ void CUIRenewQuestUI::Slot15(int width, int height) { allButton->SetText(std::string("")); allButton->SetFitText(0); allButton->SetAlign(0, 0); - allButton->SetFont(std::string(DecryptName<0x51BB39B763BBBD8DULL>({0xCA, 0xC8, 0xD7, 0x0A, 0xDA, 0x39}))); + allButton->SetFont(std::string(DecryptName<0x51BB39B763BBBD8DULL>({'\xCA', '\xC8', '\xD7', '\x0A', '\xDA', '\x39'}))); allButton->SetFontHeight(12); allButton->SetBold(0); allButton->SetTextColors(0, 0, 0, 0); @@ -1885,24 +1887,24 @@ void CUIRenewQuestUI::Slot15(int width, int height) { allButton->SetOutline(0, 0); allButton->SetImages( std::string(DecryptName<0x87E3D1C50D572DEFULL>({ - 0x2F, 0x82, 0x97, 0xF7, 0x05, 0x1F, 0x26, 0x4A, 0x29, 0xC9, 0x97, 0xC1, 0x78, 0x6B, 0xBF, 0xD5, - 0x8A, 0x43, 0x32, 0x7A, 0x9A, 0x80, 0x96, 0xE2, 0x9C, 0x59, 0x02, 0x44, 0x99, 0xB3, 0x97, 0xE9, - 0xB0, 0x4C, 0x3B, 0x61, 0x9A, 0xBE, 0x85, 0xE1, 0xC1, 0x4F, 0x3A, 0x7D, 0xC5 + '\x2F', '\x82', '\x97', '\xF7', '\x05', '\x1F', '\x26', '\x4A', '\x29', '\xC9', '\x97', '\xC1', '\x78', '\x6B', '\xBF', '\xD5', + '\x8A', '\x43', '\x32', '\x7A', '\x9A', '\x80', '\x96', '\xE2', '\x9C', '\x59', '\x02', '\x44', '\x99', '\xB3', '\x97', '\xE9', + '\xB0', '\x4C', '\x3B', '\x61', '\x9A', '\xBE', '\x85', '\xE1', '\xC1', '\x4F', '\x3A', '\x7D', '\xC5' })), std::string(DecryptName<0xDF8117FF49CFF551ULL>({ - 0x91, 0x5A, 0x0F, 0xB3, 0x3F, 0xD9, 0x44, 0x12, 0x97, 0x11, 0x0F, 0x85, 0x42, 0xAD, 0xDD, 0x8D, - 0x34, 0x9B, 0xAA, 0x3E, 0xA0, 0x46, 0xF4, 0xBA, 0x22, 0x81, 0x9A, 0x00, 0xA3, 0x75, 0xF5, 0xB1, - 0x0E, 0x94, 0xA3, 0x25, 0xA0, 0x78, 0xEF, 0xF1, 0x33, 0x98, 0xBF, 0x49 + '\x91', '\x5A', '\x0F', '\xB3', '\x3F', '\xD9', '\x44', '\x12', '\x97', '\x11', '\x0F', '\x85', '\x42', '\xAD', '\xDD', '\x8D', + '\x34', '\x9B', '\xAA', '\x3E', '\xA0', '\x46', '\xF4', '\xBA', '\x22', '\x81', '\x9A', '\x00', '\xA3', '\x75', '\xF5', '\xB1', + '\x0E', '\x94', '\xA3', '\x25', '\xA0', '\x78', '\xEF', '\xF1', '\x33', '\x98', '\xBF', '\x49' })), std::string(DecryptName<0xADC51BF9C98B413DULL>({ - 0xFD, 0xEE, 0x4B, 0x33, 0x39, 0xD5, 0x00, 0x60, 0xFB, 0xA5, 0x4B, 0x05, 0x44, 0xA1, 0x99, 0xFF, - 0x58, 0x2F, 0xEE, 0xBE, 0xA6, 0x4A, 0xB0, 0xC8, 0x4E, 0x35, 0xDE, 0x80, 0xA5, 0x79, 0xB1, 0xC3, - 0x62, 0x20, 0xE7, 0xA5, 0xA6, 0x74, 0xA3, 0xCB, 0x13, 0x23, 0xE6, 0xB9, 0xF9 + '\xFD', '\xEE', '\x4B', '\x33', '\x39', '\xD5', '\x00', '\x60', '\xFB', '\xA5', '\x4B', '\x05', '\x44', '\xA1', '\x99', '\xFF', + '\x58', '\x2F', '\xEE', '\xBE', '\xA6', '\x4A', '\xB0', '\xC8', '\x4E', '\x35', '\xDE', '\x80', '\xA5', '\x79', '\xB1', '\xC3', + '\x62', '\x20', '\xE7', '\xA5', '\xA6', '\x74', '\xA3', '\xCB', '\x13', '\x23', '\xE6', '\xB9', '\xF9' })), std::string(DecryptName<0x7D5D0F110B6B8371ULL>({ - 0xB1, 0x2C, 0xAB, 0xF1, 0xD1, 0xC1, 0x98, 0xB0, 0xB7, 0x67, 0xAB, 0xC7, 0xAC, 0xB5, 0x01, 0x2F, - 0x14, 0xED, 0x0E, 0x7C, 0x4E, 0x5E, 0x28, 0x18, 0x02, 0xF7, 0x3E, 0x42, 0x4D, 0x6D, 0x29, 0x13, - 0x2E, 0xE2, 0x07, 0x67, 0x4E, 0x60, 0x3B, 0x1B, 0x5F, 0xE1, 0x06, 0x7B, 0x11 + '\xB1', '\x2C', '\xAB', '\xF1', '\xD1', '\xC1', '\x98', '\xB0', '\xB7', '\x67', '\xAB', '\xC7', '\xAC', '\xB5', '\x01', '\x2F', + '\x14', '\xED', '\x0E', '\x7C', '\x4E', '\x5E', '\x28', '\x18', '\x02', '\xF7', '\x3E', '\x42', '\x4D', '\x6D', '\x29', '\x13', + '\x2E', '\xE2', '\x07', '\x67', '\x4E', '\x60', '\x3B', '\x1B', '\x5F', '\xE1', '\x06', '\x7B', '\x11' })) ); this->filterPanel->AddChild(allButton); diff --git a/Source/UI/SkillDelayInfo/UISkillDelayInfo.cpp b/Source/UI/SkillDelayInfo/UISkillDelayInfo.cpp index 73a88510..3ee5dac3 100644 --- a/Source/UI/SkillDelayInfo/UISkillDelayInfo.cpp +++ b/Source/UI/SkillDelayInfo/UISkillDelayInfo.cpp @@ -35,7 +35,9 @@ namespace { template class EncryptedName { public: - explicit EncryptedName(const std::uint8_t (&source)[Length]) : m_encrypted(true) { + // INLINED + template + explicit EncryptedName(const Byte (&source)[Length]) : m_encrypted(true) { for (std::uint64_t index = 0; index < Length; ++index) { this->m_text[index] = source[index]; } @@ -617,21 +619,21 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->titleBar->Move(0, 0); { CUITitleBar* titleBar = this->titleBar; - const std::uint8_t titleRightSource[] = { - 0xF3, 0xCC, 0x95, 0x0B, 0xE9, 0xFB, 0x16, 0x84, 0xF5, 0x87, 0x95, 0x3D, 0x94, 0x8F, 0x8F, 0x2B, 0x52, 0x10, 0x3C, 0x92, 0x76, 0x5C, 0xBD, 0x3D, - 0x56, 0x11, 0x33, 0x90, 0x4A, 0x50, 0x8F, 0x3D, 0x5A, 0x17, 0x39, 0x94, 0x4B, 0x54, 0xA1, 0x16, 0x41, 0x0A, 0x32, 0x99, 0x5D, 0x1B, 0xB1, 0x24, - 0x43, 0x63}; + const char titleRightSource[] = { + '\xF3', '\xCC', '\x95', '\x0B', '\xE9', '\xFB', '\x16', '\x84', '\xF5', '\x87', '\x95', '\x3D', '\x94', '\x8F', '\x8F', '\x2B', '\x52', '\x10', '\x3C', '\x92', '\x76', '\x5C', '\xBD', '\x3D', + '\x56', '\x11', '\x33', '\x90', '\x4A', '\x50', '\x8F', '\x3D', '\x5A', '\x17', '\x39', '\x94', '\x4B', '\x54', '\xA1', '\x16', '\x41', '\x0A', '\x32', '\x99', '\x5D', '\x1B', '\xB1', '\x24', + '\x43', '\x63'}; thread_local EncryptedName titleRightName(titleRightSource); const std::string titleRight(titleRightName.Text()); - const std::uint8_t titleMiddleSource[] = { - 0x75, 0x20, 0x81, 0xDF, 0xD3, 0x33, 0xEA, 0xB4, 0x73, 0x6B, 0x81, 0xE9, 0xAE, 0x47, 0x73, 0x1B, 0xD4, 0xFC, 0x28, 0x46, 0x4C, 0x94, 0x41, 0x0D, - 0xD0, 0xFD, 0x27, 0x44, 0x70, 0x98, 0x73, 0x0D, 0xDC, 0xFB, 0x2D, 0x40, 0x71, 0x9C, 0x5D, 0x26, 0xD8, 0xE6, 0x25, 0x0B, 0x71, 0x90, 0x5F, 0x79}; + const char titleMiddleSource[] = { + '\x75', '\x20', '\x81', '\xDF', '\xD3', '\x33', '\xEA', '\xB4', '\x73', '\x6B', '\x81', '\xE9', '\xAE', '\x47', '\x73', '\x1B', '\xD4', '\xFC', '\x28', '\x46', '\x4C', '\x94', '\x41', '\x0D', + '\xD0', '\xFD', '\x27', '\x44', '\x70', '\x98', '\x73', '\x0D', '\xDC', '\xFB', '\x2D', '\x40', '\x71', '\x9C', '\x5D', '\x26', '\xD8', '\xE6', '\x25', '\x0B', '\x71', '\x90', '\x5F', '\x79'}; thread_local EncryptedName titleMiddleName(titleMiddleSource); const std::string titleMiddle(titleMiddleName.Text()); - const std::uint8_t titleLeftSource[] = { - 0x7F, 0xC6, 0x23, 0x37, 0x45, 0x49, 0x9A, 0x3C, 0x79, 0x8D, 0x23, 0x01, 0x38, 0x3D, 0x03, 0x93, 0xDE, 0x1A, 0x8A, 0xAE, 0xDA, 0xEE, 0x31, 0x85, - 0xDA, 0x1B, 0x85, 0xAC, 0xE6, 0xE2, 0x03, 0x85, 0xD6, 0x1D, 0x8F, 0xA8, 0xE7, 0xE6, 0x2D, 0xAE, 0xD3, 0x0C, 0x85, 0xB9, 0xAB, 0xE5, 0x32, 0x81, - 0xBF}; + const char titleLeftSource[] = { + '\x7F', '\xC6', '\x23', '\x37', '\x45', '\x49', '\x9A', '\x3C', '\x79', '\x8D', '\x23', '\x01', '\x38', '\x3D', '\x03', '\x93', '\xDE', '\x1A', '\x8A', '\xAE', '\xDA', '\xEE', '\x31', '\x85', + '\xDA', '\x1B', '\x85', '\xAC', '\xE6', '\xE2', '\x03', '\x85', '\xD6', '\x1D', '\x8F', '\xA8', '\xE7', '\xE6', '\x2D', '\xAE', '\xD3', '\x0C', '\x85', '\xB9', '\xAB', '\xE5', '\x32', '\x81', + '\xBF'}; thread_local EncryptedName titleLeftName(titleLeftSource); const std::string titleLeft(titleLeftName.Text()); titleBar->SetImages(titleLeft, titleMiddle, titleRight); @@ -642,8 +644,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { title->SetSize(100, 17); title->Move(18, 0); { - const std::uint8_t titleTextSource[] = { - 0xF5, 0x4A, 0x6E, 0x43, 0xDB, 0x8C, 0xEB, 0xC0, 0x95, 0x43, 0x6B, 0xF9}; + const char titleTextSource[] = { + '\xF5', '\x4A', '\x6E', '\x43', '\xDB', '\x8C', '\xEB', '\xC0', '\x95', '\x43', '\x6B', '\xF9'}; thread_local EncryptedName titleTextName(titleTextSource); const char* titleText = titleTextName.Text(); title->SetText(titleText, std::strlen(titleText)); @@ -651,8 +653,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { title->SetFitText(0); title->SetAlign(0, 6); { - const std::uint8_t titleFontSource[] = { - 0xD0, 0xBC, 0xA5, 0xF2, 0xA0, 0xBB}; + const char titleFontSource[] = { + '\xD0', '\xBC', '\xA5', '\xF2', '\xA0', '\xBB'}; thread_local EncryptedName titleFontName(titleFontSource); const std::string titleFont(titleFontName.Text()); title->SetFont(titleFont); @@ -672,24 +674,24 @@ void CUISkillDelayInfo::Slot15(int width, int height) { menuButton->disabled = 0; menuButton->Invalidate(); { - const std::uint8_t menuDisabledSource[] = { - 0x0F, 0x74, 0x11, 0xEF, 0x59, 0xE1, 0xAA, 0xDE, 0x09, 0x3F, 0x11, 0xD9, 0x24, 0x95, 0x33, 0x71, 0xAE, 0xA8, 0xB8, 0x76, 0xC6, 0x46, 0x01, 0x67, - 0xAA, 0xA9, 0xB7, 0x74, 0xFA, 0x4A, 0x33, 0x60, 0xB6, 0xA8, 0x8E, 0x77, 0xF8, 0x5C, 0x0A, 0x4C, 0xA0, 0xBD, 0xB7, 0x3B, 0xFB, 0x42, 0x1F, 0x13}; + const char menuDisabledSource[] = { + '\x0F', '\x74', '\x11', '\xEF', '\x59', '\xE1', '\xAA', '\xDE', '\x09', '\x3F', '\x11', '\xD9', '\x24', '\x95', '\x33', '\x71', '\xAE', '\xA8', '\xB8', '\x76', '\xC6', '\x46', '\x01', '\x67', + '\xAA', '\xA9', '\xB7', '\x74', '\xFA', '\x4A', '\x33', '\x60', '\xB6', '\xA8', '\x8E', '\x77', '\xF8', '\x5C', '\x0A', '\x4C', '\xA0', '\xBD', '\xB7', '\x3B', '\xFB', '\x42', '\x1F', '\x13'}; thread_local EncryptedName menuDisabledName(menuDisabledSource); const std::string menuDisabled(menuDisabledName.Text()); - const std::uint8_t menuPressedSource[] = { - 0xEB, 0x78, 0x89, 0xD5, 0xCF, 0x1F, 0xE6, 0xC6, 0xED, 0x33, 0x89, 0xE3, 0xB2, 0x6B, 0x7F, 0x69, 0x4A, 0xA4, 0x20, 0x4C, 0x50, 0xB8, 0x4D, 0x7F, - 0x4E, 0xA5, 0x2F, 0x4E, 0x6C, 0xB4, 0x7F, 0x78, 0x52, 0xA4, 0x16, 0x4D, 0x6E, 0xA2, 0x46, 0x54, 0x44, 0xB9, 0x67, 0x4D, 0x62, 0xA1, 0x23}; + const char menuPressedSource[] = { + '\xEB', '\x78', '\x89', '\xD5', '\xCF', '\x1F', '\xE6', '\xC6', '\xED', '\x33', '\x89', '\xE3', '\xB2', '\x6B', '\x7F', '\x69', '\x4A', '\xA4', '\x20', '\x4C', '\x50', '\xB8', '\x4D', '\x7F', + '\x4E', '\xA5', '\x2F', '\x4E', '\x6C', '\xB4', '\x7F', '\x78', '\x52', '\xA4', '\x16', '\x4D', '\x6E', '\xA2', '\x46', '\x54', '\x44', '\xB9', '\x67', '\x4D', '\x62', '\xA1', '\x23'}; thread_local EncryptedName menuPressedName(menuPressedSource); const std::string menuPressed(menuPressedName.Text()); - const std::uint8_t menuHoverSource[] = { - 0x4B, 0x32, 0xB7, 0x77, 0x21, 0x13, 0xA2, 0xDA, 0x4D, 0x79, 0xB7, 0x41, 0x5C, 0x67, 0x3B, 0x75, 0xEA, 0xEE, 0x1E, 0xEE, 0xBE, 0xB4, 0x09, 0x63, - 0xEE, 0xEF, 0x11, 0xEC, 0x82, 0xB8, 0x3B, 0x64, 0xF2, 0xEE, 0x28, 0xEF, 0x80, 0xAE, 0x02, 0x48, 0xE4, 0xF3, 0x59, 0xEF, 0x8C, 0xAD, 0x67}; + const char menuHoverSource[] = { + '\x4B', '\x32', '\xB7', '\x77', '\x21', '\x13', '\xA2', '\xDA', '\x4D', '\x79', '\xB7', '\x41', '\x5C', '\x67', '\x3B', '\x75', '\xEA', '\xEE', '\x1E', '\xEE', '\xBE', '\xB4', '\x09', '\x63', + '\xEE', '\xEF', '\x11', '\xEC', '\x82', '\xB8', '\x3B', '\x64', '\xF2', '\xEE', '\x28', '\xEF', '\x80', '\xAE', '\x02', '\x48', '\xE4', '\xF3', '\x59', '\xEF', '\x8C', '\xAD', '\x67'}; thread_local EncryptedName menuHoverName(menuHoverSource); const std::string menuHover(menuHoverName.Text()); - const std::uint8_t menuNormalSource[] = { - 0x21, 0x2C, 0x11, 0x17, 0xD1, 0x4F, 0x7E, 0x0C, 0x27, 0x67, 0x11, 0x21, 0xAC, 0x3B, 0xE7, 0xA3, 0x80, 0xF0, 0xB8, 0x8E, 0x4E, 0xE8, 0xD5, 0xB5, - 0x84, 0xF1, 0xB7, 0x8C, 0x72, 0xE4, 0xE7, 0xB2, 0x98, 0xF0, 0x8E, 0x8F, 0x70, 0xF2, 0xDE, 0x9E, 0x8E, 0xE5, 0xB7, 0xC3, 0x73, 0xEC, 0xCB, 0xC1}; + const char menuNormalSource[] = { + '\x21', '\x2C', '\x11', '\x17', '\xD1', '\x4F', '\x7E', '\x0C', '\x27', '\x67', '\x11', '\x21', '\xAC', '\x3B', '\xE7', '\xA3', '\x80', '\xF0', '\xB8', '\x8E', '\x4E', '\xE8', '\xD5', '\xB5', + '\x84', '\xF1', '\xB7', '\x8C', '\x72', '\xE4', '\xE7', '\xB2', '\x98', '\xF0', '\x8E', '\x8F', '\x70', '\xF2', '\xDE', '\x9E', '\x8E', '\xE5', '\xB7', '\xC3', '\x73', '\xEC', '\xCB', '\xC1'}; thread_local EncryptedName menuNormalName(menuNormalSource); const std::string menuNormal(menuNormalName.Text()); menuButton->SetImages(menuNormal, menuHover, menuPressed, menuDisabled); @@ -703,26 +705,26 @@ void CUISkillDelayInfo::Slot15(int width, int height) { closeButton->disabled = 0; closeButton->Invalidate(); { - const std::uint8_t closeDisabledSource[] = { - 0xC1, 0xDA, 0x3D, 0x23, 0xEF, 0x73, 0x6A, 0x7A, 0xC7, 0x91, 0x3D, 0x15, 0x92, 0x07, 0xF3, 0xD5, 0x60, 0x06, 0x94, 0xBA, 0x70, 0xD4, 0xC1, 0xC3, - 0x64, 0x07, 0x9B, 0xB8, 0x4C, 0xD8, 0xF3, 0xC4, 0x78, 0x06, 0xA2, 0xBA, 0x43, 0xD2, 0xDC, 0xD2, 0x5E, 0x1A, 0x9B, 0xBF, 0x01, 0xDF, 0xC2, 0xC7, - 0x01}; + const char closeDisabledSource[] = { + '\xC1', '\xDA', '\x3D', '\x23', '\xEF', '\x73', '\x6A', '\x7A', '\xC7', '\x91', '\x3D', '\x15', '\x92', '\x07', '\xF3', '\xD5', '\x60', '\x06', '\x94', '\xBA', '\x70', '\xD4', '\xC1', '\xC3', + '\x64', '\x07', '\x9B', '\xB8', '\x4C', '\xD8', '\xF3', '\xC4', '\x78', '\x06', '\xA2', '\xBA', '\x43', '\xD2', '\xDC', '\xD2', '\x5E', '\x1A', '\x9B', '\xBF', '\x01', '\xDF', '\xC2', '\xC7', + '\x01'}; thread_local EncryptedName closeDisabledName(closeDisabledSource); const std::string closeDisabled(closeDisabledName.Text()); - const std::uint8_t closePressedSource[] = { - 0x1D, 0xFA, 0xAF, 0x55, 0x29, 0xDB, 0x2C, 0xB4, 0x1B, 0xB1, 0xAF, 0x63, 0x54, 0xAF, 0xB5, 0x1B, 0xBC, 0x26, 0x06, 0xCC, 0xB6, 0x7C, 0x87, 0x0D, - 0xB8, 0x27, 0x09, 0xCE, 0x8A, 0x70, 0xB5, 0x0A, 0xA4, 0x26, 0x30, 0xCC, 0x85, 0x7A, 0x9A, 0x1C, 0x82, 0x3A, 0x01, 0x81, 0x8B, 0x78, 0x99, 0x79}; + const char closePressedSource[] = { + '\x1D', '\xFA', '\xAF', '\x55', '\x29', '\xDB', '\x2C', '\xB4', '\x1B', '\xB1', '\xAF', '\x63', '\x54', '\xAF', '\xB5', '\x1B', '\xBC', '\x26', '\x06', '\xCC', '\xB6', '\x7C', '\x87', '\x0D', + '\xB8', '\x27', '\x09', '\xCE', '\x8A', '\x70', '\xB5', '\x0A', '\xA4', '\x26', '\x30', '\xCC', '\x85', '\x7A', '\x9A', '\x1C', '\x82', '\x3A', '\x01', '\x81', '\x8B', '\x78', '\x99', '\x79'}; thread_local EncryptedName closePressedName(closePressedSource); const std::string closePressed(closePressedName.Text()); - const std::uint8_t closeHoverSource[] = { - 0x81, 0x92, 0x97, 0x8F, 0xF9, 0x51, 0x88, 0xAA, 0x87, 0xD9, 0x97, 0xB9, 0x84, 0x25, 0x11, 0x05, 0x20, 0x4E, 0x3E, 0x16, 0x66, 0xF6, 0x23, 0x13, - 0x24, 0x4F, 0x31, 0x14, 0x5A, 0xFA, 0x11, 0x14, 0x38, 0x4E, 0x08, 0x16, 0x55, 0xF0, 0x3E, 0x02, 0x1E, 0x52, 0x39, 0x5B, 0x5B, 0xF2, 0x3D, 0x67}; + const char closeHoverSource[] = { + '\x81', '\x92', '\x97', '\x8F', '\xF9', '\x51', '\x88', '\xAA', '\x87', '\xD9', '\x97', '\xB9', '\x84', '\x25', '\x11', '\x05', '\x20', '\x4E', '\x3E', '\x16', '\x66', '\xF6', '\x23', '\x13', + '\x24', '\x4F', '\x31', '\x14', '\x5A', '\xFA', '\x11', '\x14', '\x38', '\x4E', '\x08', '\x16', '\x55', '\xF0', '\x3E', '\x02', '\x1E', '\x52', '\x39', '\x5B', '\x5B', '\xF2', '\x3D', '\x67'}; thread_local EncryptedName closeHoverName(closeHoverSource); const std::string closeHover(closeHoverName.Text()); - const std::uint8_t closeNormalSource[] = { - 0x91, 0x02, 0x3D, 0xD1, 0x8F, 0xFD, 0x1A, 0xA6, 0x97, 0x49, 0x3D, 0xE7, 0xF2, 0x89, 0x83, 0x09, 0x30, 0xDE, 0x94, 0x48, 0x10, 0x5A, 0xB1, 0x1F, - 0x34, 0xDF, 0x9B, 0x4A, 0x2C, 0x56, 0x83, 0x18, 0x28, 0xDE, 0xA2, 0x48, 0x23, 0x5C, 0xAC, 0x0E, 0x0E, 0xC2, 0x9B, 0x4D, 0x61, 0x51, 0xB2, 0x1B, - 0x51}; + const char closeNormalSource[] = { + '\x91', '\x02', '\x3D', '\xD1', '\x8F', '\xFD', '\x1A', '\xA6', '\x97', '\x49', '\x3D', '\xE7', '\xF2', '\x89', '\x83', '\x09', '\x30', '\xDE', '\x94', '\x48', '\x10', '\x5A', '\xB1', '\x1F', + '\x34', '\xDF', '\x9B', '\x4A', '\x2C', '\x56', '\x83', '\x18', '\x28', '\xDE', '\xA2', '\x48', '\x23', '\x5C', '\xAC', '\x0E', '\x0E', '\xC2', '\x9B', '\x4D', '\x61', '\x51', '\xB2', '\x1B', + '\x51'}; thread_local EncryptedName closeNormalName(closeNormalSource); const std::string closeNormal(closeNormalName.Text()); closeButton->SetImages(closeNormal, closeHover, closePressed, closeDisabled); @@ -736,8 +738,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->unknown_00DC->SetFitText(1); this->unknown_00DC->SetAlign(6, 6); { - const std::uint8_t noticeFontSource[] = { - 0xA2, 0x0E, 0x5F, 0x40, 0x20, 0x65}; + const char noticeFontSource[] = { + '\xA2', '\x0E', '\x5F', '\x40', '\x20', '\x65'}; thread_local EncryptedName noticeFontName(noticeFontSource); const std::string noticeFont(noticeFontName.Text()); this->unknown_00DC->SetFont(noticeFont); @@ -753,8 +755,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->labels[0]->SetSize(140, 22); this->labels[0]->Move(54, 58); { - const std::uint8_t castingTextSource[] = { - 0x27, 0x66, 0xEE, 0x4D, 0x63, 0xC4, 0xE3}; + const char castingTextSource[] = { + '\x27', '\x66', '\xEE', '\x4D', '\x63', '\xC4', '\xE3'}; thread_local EncryptedName castingTextName(castingTextSource); const char* castingText = castingTextName.Text(); this->labels[0]->SetText(castingText, std::strlen(castingText)); @@ -762,8 +764,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->labels[0]->SetFitText(0); this->labels[0]->SetAlign(6, 6); { - const std::uint8_t castingFontSource[] = { - 0x1E, 0xF2, 0x6F, 0x14, 0x38, 0xCB}; + const char castingFontSource[] = { + '\x1E', '\xF2', '\x6F', '\x14', '\x38', '\xCB'}; thread_local EncryptedName castingFontName(castingFontSource); const std::string castingFont(castingFontName.Text()); this->labels[0]->SetFont(castingFont); @@ -779,8 +781,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->labels[1]->SetSize(140, 22); this->labels[1]->Move(194, 58); { - const std::uint8_t cooldownTextSource[] = { - 0x3B, 0x13, 0x98, 0xBB, 0x67, 0x7C, 0xA3}; + const char cooldownTextSource[] = { + '\x3B', '\x13', '\x98', '\xBB', '\x67', '\x7C', '\xA3'}; thread_local EncryptedName cooldownTextName(cooldownTextSource); const char* cooldownText = cooldownTextName.Text(); this->labels[1]->SetText(cooldownText, std::strlen(cooldownText)); @@ -788,8 +790,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->labels[1]->SetFitText(0); this->labels[1]->SetAlign(6, 6); { - const std::uint8_t cooldownFontSource[] = { - 0xA8, 0x58, 0x3B, 0x64, 0xA8, 0xD1}; + const char cooldownFontSource[] = { + '\xA8', '\x58', '\x3B', '\x64', '\xA8', '\xD1'}; thread_local EncryptedName cooldownFontName(cooldownFontSource); const char* cooldownFont = cooldownFontName.Text(); this->labels[1]->SetFont(std::string(cooldownFont)); @@ -805,8 +807,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->labels[2]->SetSize(44, 22); this->labels[2]->Move(10, 82); { - const std::uint8_t levelTextSource[] = { - 0x3A, 0x04, 0x01, 0xC4, 0xB7}; + const char levelTextSource[] = { + '\x3A', '\x04', '\x01', '\xC4', '\xB7'}; thread_local EncryptedName levelTextName(levelTextSource); const char* levelText = levelTextName.Text(); this->labels[2]->SetText(levelText, std::strlen(levelText)); @@ -814,8 +816,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->labels[2]->SetFitText(1); this->labels[2]->SetAlign(6, 6); { - const std::uint8_t levelFontSource[] = { - 0x7A, 0x34, 0xE7, 0xA0, 0x94, 0x1B}; + const char levelFontSource[] = { + '\x7A', '\x34', '\xE7', '\xA0', '\x94', '\x1B'}; thread_local EncryptedName levelFontName(levelFontSource); const char* levelFont = levelFontName.Text(); this->labels[2]->SetFont(std::string(levelFont)); @@ -831,8 +833,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->columns[0]->SetSize(70, 22); this->columns[0]->Move(54, 82); { - const std::uint8_t fixedTextSource[] = { - 0xE1, 0x18, 0x0E, 0xED, 0xFF}; + const char fixedTextSource[] = { + '\xE1', '\x18', '\x0E', '\xED', '\xFF'}; thread_local EncryptedName fixedTextName(fixedTextSource); const char* fixedText = fixedTextName.Text(); this->columns[0]->SetText(fixedText, std::strlen(fixedText)); @@ -840,8 +842,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->columns[0]->SetFitText(1); this->columns[0]->SetAlign(6, 6); { - const std::uint8_t fixedFontSource[] = { - 0x0E, 0x18, 0x13, 0x8A, 0xAA, 0x01}; + const char fixedFontSource[] = { + '\x0E', '\x18', '\x13', '\x8A', '\xAA', '\x01'}; thread_local EncryptedName fixedFontName(fixedFontSource); const char* fixedFont = fixedFontName.Text(); this->columns[0]->SetFont(std::string(fixedFont)); @@ -857,8 +859,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->columns[1]->SetSize(70, 22); this->columns[1]->Move(124, 82); { - const std::uint8_t variableTextSource[] = { - 0xCB, 0x2C, 0xDE, 0xB4, 0x11}; + const char variableTextSource[] = { + '\xCB', '\x2C', '\xDE', '\xB4', '\x11'}; thread_local EncryptedName variableTextName(variableTextSource); const char* variableText = variableTextName.Text(); this->columns[1]->SetText(variableText, std::strlen(variableText)); @@ -866,8 +868,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->columns[1]->SetFitText(1); this->columns[1]->SetAlign(6, 6); { - const std::uint8_t variableFontSource[] = { - 0x1C, 0xC2, 0x0D, 0x30, 0x22, 0x51}; + const char variableFontSource[] = { + '\x1C', '\xC2', '\x0D', '\x30', '\x22', '\x51'}; thread_local EncryptedName variableFontName(variableFontSource); const char* variableFont = variableFontName.Text(); this->columns[1]->SetFont(std::string(variableFont)); @@ -883,8 +885,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->columns[2]->SetSize(70, 22); this->columns[2]->Move(194, 82); { - const std::uint8_t globalTextSource[] = { - 0x28, 0xE2, 0x4A, 0xFF, 0xEC, 0x41, 0x91}; + const char globalTextSource[] = { + '\x28', '\xE2', '\x4A', '\xFF', '\xEC', '\x41', '\x91'}; thread_local EncryptedName globalTextName(globalTextSource); const char* globalText = globalTextName.Text(); this->columns[2]->SetText(globalText, std::strlen(globalText)); @@ -892,8 +894,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->columns[2]->SetFitText(1); this->columns[2]->SetAlign(6, 6); { - const std::uint8_t globalFontSource[] = { - 0x94, 0x4C, 0x03, 0x78, 0xC4, 0x1F}; + const char globalFontSource[] = { + '\x94', '\x4C', '\x03', '\x78', '\xC4', '\x1F'}; thread_local EncryptedName globalFontName(globalFontSource); const char* globalFont = globalFontName.Text(); this->columns[2]->SetFont(std::string(globalFont)); @@ -909,8 +911,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->columns[3]->SetSize(70, 22); this->columns[3]->Move(264, 82); { - const std::uint8_t skillTextSource[] = { - 0x12, 0xB3, 0xCC, 0x54, 0xC7}; + const char skillTextSource[] = { + '\x12', '\xB3', '\xCC', '\x54', '\xC7'}; thread_local EncryptedName skillTextName(skillTextSource); const char* skillText = skillTextName.Text(); this->columns[3]->SetText(skillText, std::strlen(skillText)); @@ -918,8 +920,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->columns[3]->SetFitText(1); this->columns[3]->SetAlign(6, 6); { - const std::uint8_t skillFontSource[] = { - 0x2A, 0xCA, 0xB9, 0x4E, 0x86, 0x49}; + const char skillFontSource[] = { + '\x2A', '\xCA', '\xB9', '\x4E', '\x86', '\x49'}; thread_local EncryptedName skillFontName(skillFontSource); const char* skillFont = skillFontName.Text(); this->columns[3]->SetFont(std::string(skillFont)); @@ -946,45 +948,45 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->delayList->scrollBar->step = 10; { CUIListBoxEx* delayList = this->delayList; - const std::uint8_t listDownSource[] = { - 0x95, 0x94, 0x41, 0x0D, 0x8D, 0x25, 0x68, 0x60, 0x93, 0xDF, 0x41, 0x3B, 0xF0, 0x51, 0xF1, 0xDE, 0x36, 0x49, 0xEE, 0x9B, 0x21, 0xDB, 0xC9, 0xC2, - 0x22, 0x55, 0xAF, 0x95, 0x20, 0x9B, 0xAD}; + const char listDownSource[] = { + '\x95', '\x94', '\x41', '\x0D', '\x8D', '\x25', '\x68', '\x60', '\x93', '\xDF', '\x41', '\x3B', '\xF0', '\x51', '\xF1', '\xDE', '\x36', '\x49', '\xEE', '\x9B', '\x21', '\xDB', '\xC9', '\xC2', + '\x22', '\x55', '\xAF', '\x95', '\x20', '\x9B', '\xAD'}; thread_local EncryptedName listDownName(listDownSource); const char* listDown = listDownName.Text(); const std::string down(listDown); - const std::uint8_t listUpSource[] = { - 0x99, 0xA2, 0x0B, 0x55, 0xBD, 0xAD, 0x50, 0x7C, 0x9F, 0xE9, 0x0B, 0x63, 0xC0, 0xD9, 0xC9, 0xC2, 0x3A, 0x7F, 0xA4, 0xC3, 0x11, 0x53, 0xE0, 0xC1, - 0x77, 0x6F, 0xA6, 0xDF, 0x7D}; + const char listUpSource[] = { + '\x99', '\xA2', '\x0B', '\x55', '\xBD', '\xAD', '\x50', '\x7C', '\x9F', '\xE9', '\x0B', '\x63', '\xC0', '\xD9', '\xC9', '\xC2', '\x3A', '\x7F', '\xA4', '\xC3', '\x11', '\x53', '\xE0', '\xC1', + '\x77', '\x6F', '\xA6', '\xDF', '\x7D'}; thread_local EncryptedName listUpName(listUpSource); const char* listUp = listUpName.Text(); const std::string up(listUp); delayList->scrollBar->SetButtonImages(up, down); } { - const std::uint8_t listBackgroundSource[] = { - 0x01, 0x36, 0x0D, 0x1F, 0x41, 0xE3, 0x80, 0x14, 0x07, 0x7D, 0x0D, 0x29, 0x3C, 0x97, 0x19, 0xAA, 0xA2, 0xEB, 0xA2, 0x89, 0xED, 0x1D, 0x28, 0xB0, - 0xA5, 0xB7, 0xAF, 0x88, 0xF1, 0x2D}; + const char listBackgroundSource[] = { + '\x01', '\x36', '\x0D', '\x1F', '\x41', '\xE3', '\x80', '\x14', '\x07', '\x7D', '\x0D', '\x29', '\x3C', '\x97', '\x19', '\xAA', '\xA2', '\xEB', '\xA2', '\x89', '\xED', '\x1D', '\x28', '\xB0', + '\xA5', '\xB7', '\xAF', '\x88', '\xF1', '\x2D'}; thread_local EncryptedName listBackgroundName(listBackgroundSource); const char* listBackground = listBackgroundName.Text(); this->delayList->scrollBar->SetBackground(std::string(listBackground)); } { CUIListBoxEx* delayList = this->delayList; - const std::uint8_t listThumbBottomSource[] = { - 0xCD, 0xCC, 0x4D, 0xF3, 0x85, 0x9D, 0x4A, 0x14, 0xCB, 0x87, 0x4D, 0xC5, 0xF8, 0xE9, 0xD3, 0xAA, 0x6E, 0x11, 0xE2, 0x65, 0x29, 0x63, 0xED, 0xB8, - 0x7F, 0x3C, 0xE9, 0x66, 0x32, 0x3D, 0xA1, 0xBB, 0x60, 0x13, 0x8D}; + const char listThumbBottomSource[] = { + '\xCD', '\xCC', '\x4D', '\xF3', '\x85', '\x9D', '\x4A', '\x14', '\xCB', '\x87', '\x4D', '\xC5', '\xF8', '\xE9', '\xD3', '\xAA', '\x6E', '\x11', '\xE2', '\x65', '\x29', '\x63', '\xED', '\xB8', + '\x7F', '\x3C', '\xE9', '\x66', '\x32', '\x3D', '\xA1', '\xBB', '\x60', '\x13', '\x8D'}; thread_local EncryptedName listThumbBottomName(listThumbBottomSource); const char* listThumbBottom = listThumbBottomName.Text(); const std::string bottom(listThumbBottom); - const std::uint8_t listThumbMiddleSource[] = { - 0xEB, 0xB0, 0x29, 0x51, 0x01, 0x31, 0xE8, 0xB2, 0xED, 0xFB, 0x29, 0x67, 0x7C, 0x45, 0x71, 0x0C, 0x48, 0x6D, 0x86, 0xC7, 0xAD, 0xCF, 0x4F, 0x1E, - 0x59, 0x40, 0x84, 0xC2, 0xA5, 0xD1, 0x4F, 0x12, 0x5B, 0x1F}; + const char listThumbMiddleSource[] = { + '\xEB', '\xB0', '\x29', '\x51', '\x01', '\x31', '\xE8', '\xB2', '\xED', '\xFB', '\x29', '\x67', '\x7C', '\x45', '\x71', '\x0C', '\x48', '\x6D', '\x86', '\xC7', '\xAD', '\xCF', '\x4F', '\x1E', + '\x59', '\x40', '\x84', '\xC2', '\xA5', '\xD1', '\x4F', '\x12', '\x5B', '\x1F'}; thread_local EncryptedName listThumbMiddleName(listThumbMiddleSource); const char* listThumbMiddle = listThumbMiddleName.Text(); const std::string middle(listThumbMiddle); - const std::uint8_t listThumbTopSource[] = { - 0x4D, 0x2E, 0xD1, 0x09, 0x73, 0x67, 0xAC, 0x30, 0x4B, 0x65, 0xD1, 0x3F, 0x0E, 0x13, 0x35, 0x8E, 0xEE, 0xF3, 0x7E, 0x9F, 0xDF, 0x99, 0x0B, 0x9C, - 0xFF, 0xDE, 0x64, 0x83, 0x9D, 0xCB, 0x04, 0x8D, 0x8D}; + const char listThumbTopSource[] = { + '\x4D', '\x2E', '\xD1', '\x09', '\x73', '\x67', '\xAC', '\x30', '\x4B', '\x65', '\xD1', '\x3F', '\x0E', '\x13', '\x35', '\x8E', '\xEE', '\xF3', '\x7E', '\x9F', '\xDF', '\x99', '\x0B', '\x9C', + '\xFF', '\xDE', '\x64', '\x83', '\x9D', '\xCB', '\x04', '\x8D', '\x8D'}; thread_local EncryptedName listThumbTopName(listThumbTopSource); const char* listThumbTop = listThumbTopName.Text(); const std::string top(listThumbTop); @@ -998,8 +1000,8 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->description->Move(11, 334); this->description->SetTextOffset(0, 0); { - const std::uint8_t descriptionFontSource[] = { - 0xD4, 0x00, 0xB3, 0x86, 0x20, 0x23}; + const char descriptionFontSource[] = { + '\xD4', '\x00', '\xB3', '\x86', '\x20', '\x23'}; thread_local EncryptedName descriptionFontName(descriptionFontSource); const char* descriptionFont = descriptionFontName.Text(); this->description->SetFont(std::string(descriptionFont)); @@ -1014,44 +1016,44 @@ void CUISkillDelayInfo::Slot15(int width, int height) { this->description->SetScrollBarSize(13, 35); this->description->SetScrollStep(1); { - const std::uint8_t descriptionDownSource[] = { - 0x79, 0x82, 0xFD, 0xC9, 0x4D, 0x5D, 0xD0, 0x20, 0x7F, 0xC9, 0xFD, 0xFF, 0x30, 0x29, 0x49, 0x9E, 0xDA, 0x5F, 0x52, 0x5F, 0xE1, 0xA3, 0x71, 0x82, - 0xCE, 0x43, 0x13, 0x51, 0xE0, 0xE3, 0x15}; + const char descriptionDownSource[] = { + '\x79', '\x82', '\xFD', '\xC9', '\x4D', '\x5D', '\xD0', '\x20', '\x7F', '\xC9', '\xFD', '\xFF', '\x30', '\x29', '\x49', '\x9E', '\xDA', '\x5F', '\x52', '\x5F', '\xE1', '\xA3', '\x71', '\x82', + '\xCE', '\x43', '\x13', '\x51', '\xE0', '\xE3', '\x15'}; thread_local EncryptedName descriptionDownName(descriptionDownSource); const char* descriptionDown = descriptionDownName.Text(); const std::string down(descriptionDown); - const std::uint8_t descriptionUpSource[] = { - 0x83, 0x96, 0x9B, 0x91, 0xA7, 0xE3, 0xB4, 0x04, 0x85, 0xDD, 0x9B, 0xA7, 0xDA, 0x97, 0x2D, 0xBA, 0x20, 0x4B, 0x34, 0x07, 0x0B, 0x1D, 0x04, 0xB9, - 0x6D, 0x5B, 0x36, 0x1B, 0x67}; + const char descriptionUpSource[] = { + '\x83', '\x96', '\x9B', '\x91', '\xA7', '\xE3', '\xB4', '\x04', '\x85', '\xDD', '\x9B', '\xA7', '\xDA', '\x97', '\x2D', '\xBA', '\x20', '\x4B', '\x34', '\x07', '\x0B', '\x1D', '\x04', '\xB9', + '\x6D', '\x5B', '\x36', '\x1B', '\x67'}; thread_local EncryptedName descriptionUpName(descriptionUpSource); const char* descriptionUp = descriptionUpName.Text(); const std::string up(descriptionUp); this->description->SetScrollBarButtonImages(up, down); } { - const std::uint8_t descriptionBackgroundSource[] = { - 0xFB, 0x48, 0xC1, 0xE1, 0x01, 0x6F, 0xEE, 0x70, 0xFD, 0x03, 0xC1, 0xD7, 0x7C, 0x1B, 0x77, 0xCE, 0x58, 0x95, 0x6E, 0x77, 0xAD, 0x91, 0x46, 0xD4, - 0x5F, 0xC9, 0x63, 0x76, 0xB1, 0xA1}; + const char descriptionBackgroundSource[] = { + '\xFB', '\x48', '\xC1', '\xE1', '\x01', '\x6F', '\xEE', '\x70', '\xFD', '\x03', '\xC1', '\xD7', '\x7C', '\x1B', '\x77', '\xCE', '\x58', '\x95', '\x6E', '\x77', '\xAD', '\x91', '\x46', '\xD4', + '\x5F', '\xC9', '\x63', '\x76', '\xB1', '\xA1'}; thread_local EncryptedName descriptionBackgroundName(descriptionBackgroundSource); const char* descriptionBackground = descriptionBackgroundName.Text(); this->description->SetScrollBarBackground(std::string(descriptionBackground)); } { - const std::uint8_t descriptionThumbBottomSource[] = { - 0xB3, 0x88, 0x8D, 0xB7, 0x39, 0xA1, 0xC0, 0x1C, 0xB5, 0xC3, 0x8D, 0x81, 0x44, 0xD5, 0x59, 0xA2, 0x10, 0x55, 0x22, 0x21, 0x95, 0x5F, 0x67, 0xB0, - 0x01, 0x78, 0x29, 0x22, 0x8E, 0x01, 0x2B, 0xB3, 0x1E, 0x57, 0x4D}; + const char descriptionThumbBottomSource[] = { + '\xB3', '\x88', '\x8D', '\xB7', '\x39', '\xA1', '\xC0', '\x1C', '\xB5', '\xC3', '\x8D', '\x81', '\x44', '\xD5', '\x59', '\xA2', '\x10', '\x55', '\x22', '\x21', '\x95', '\x5F', '\x67', '\xB0', + '\x01', '\x78', '\x29', '\x22', '\x8E', '\x01', '\x2B', '\xB3', '\x1E', '\x57', '\x4D'}; thread_local EncryptedName descriptionThumbBottomName(descriptionThumbBottomSource); const char* descriptionThumbBottom = descriptionThumbBottomName.Text(); const std::string bottom(descriptionThumbBottom); - const std::uint8_t descriptionThumbMiddleSource[] = { - 0x2B, 0xF0, 0xC9, 0xC9, 0xBF, 0x6F, 0xF4, 0x8E, 0x2D, 0xBB, 0xC9, 0xFF, 0xC2, 0x1B, 0x6D, 0x30, 0x88, 0x2D, 0x66, 0x5F, 0x13, 0x91, 0x53, 0x22, - 0x99, 0x00, 0x64, 0x5A, 0x1B, 0x8F, 0x53, 0x2E, 0x9B, 0x5F}; + const char descriptionThumbMiddleSource[] = { + '\x2B', '\xF0', '\xC9', '\xC9', '\xBF', '\x6F', '\xF4', '\x8E', '\x2D', '\xBB', '\xC9', '\xFF', '\xC2', '\x1B', '\x6D', '\x30', '\x88', '\x2D', '\x66', '\x5F', '\x13', '\x91', '\x53', '\x22', + '\x99', '\x00', '\x64', '\x5A', '\x1B', '\x8F', '\x53', '\x2E', '\x9B', '\x5F'}; thread_local EncryptedName descriptionThumbMiddleName(descriptionThumbMiddleSource); const char* descriptionThumbMiddle = descriptionThumbMiddleName.Text(); const std::string middle(descriptionThumbMiddle); - const std::uint8_t descriptionThumbTopSource[] = { - 0xD1, 0x4C, 0x93, 0x63, 0x71, 0x93, 0xB0, 0x86, 0xD7, 0x07, 0x93, 0x55, 0x0C, 0xE7, 0x29, 0x38, 0x72, 0x91, 0x3C, 0xF5, 0xDD, 0x6D, 0x17, 0x2A, - 0x63, 0xBC, 0x26, 0xE9, 0x9F, 0x3F, 0x18, 0x3B, 0x11}; + const char descriptionThumbTopSource[] = { + '\xD1', '\x4C', '\x93', '\x63', '\x71', '\x93', '\xB0', '\x86', '\xD7', '\x07', '\x93', '\x55', '\x0C', '\xE7', '\x29', '\x38', '\x72', '\x91', '\x3C', '\xF5', '\xDD', '\x6D', '\x17', '\x2A', + '\x63', '\xBC', '\x26', '\xE9', '\x9F', '\x3F', '\x18', '\x3B', '\x11'}; thread_local EncryptedName descriptionThumbTopName(descriptionThumbTopSource); const char* descriptionThumbTop = descriptionThumbTopName.Text(); const std::string top(descriptionThumbTop); diff --git a/Source/UI/UIMacroReport.cpp b/Source/UI/UIMacroReport.cpp index 541ea0e0..162b9b5a 100644 --- a/Source/UI/UIMacroReport.cpp +++ b/Source/UI/UIMacroReport.cpp @@ -24,7 +24,9 @@ namespace { template class EncryptedName { public: - explicit EncryptedName(const std::uint8_t (&source)[Length]) : m_encrypted(true) { + // INLINED + template + explicit EncryptedName(const Byte (&source)[Length]) : m_encrypted(true) { for (std::uint64_t index = 0; index < Length; ++index) { this->m_text[index] = source[index]; } @@ -50,6 +52,13 @@ private: bool m_encrypted; }; +// INLINED +template +const char* DecryptName(const char (&source)[Length]) { + thread_local EncryptedName name(source); + return name.Text(); +} + } #pragma pack(push, 1) @@ -148,11 +157,10 @@ void CUIMacroReport::Slot15(int width, int height) { this->m_background->Move(0, 17); { CUIStaticImage* background = this->m_background; - const std::uint8_t backgroundImageSource[] = { - 0x19, 0x56, 0x21, 0x19, 0xAD, 0xDB, 0x68, 0xE6, 0x1F, 0x1D, 0x21, 0x2F, 0xD0, 0xAF, 0xF1, 0x66, 0xB8, 0x9A, 0x93, 0x8C, 0x3F, 0x70, 0xDD, 0x44, - 0xAB, 0x8D, 0xBD, 0x81, 0x0A, 0x4A, 0xC0, 0x4A, 0xBA, 0x8B, 0x8E, 0x91, 0x08, 0x65, 0xC2, 0x59, 0xAD, 0xD7, 0x83, 0x8E, 0x1D, 0x15}; - thread_local EncryptedName backgroundImageName(backgroundImageSource); - const std::string backgroundImage(backgroundImageName.Text()); + 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)); background->SetImage(backgroundImage); } this->AddChild(this->m_background); @@ -162,23 +170,20 @@ void CUIMacroReport::Slot15(int width, int height) { this->m_titleBar->Move(0, 0); { CUITitleBar* titleBar = this->m_titleBar; - const std::uint8_t titleRightSource[] = { - 0x65, 0x32, 0xAD, 0x03, 0xA3, 0xE9, 0xB2, 0xCE, 0x63, 0x79, 0xAD, 0x35, 0xDE, 0x9D, 0x2B, 0x61, 0xC4, 0xEE, 0x04, 0x9A, 0x3C, 0x4E, 0x19, 0x77, - 0xC0, 0xEF, 0x0B, 0x98, 0x00, 0x42, 0x2B, 0x77, 0xCC, 0xE9, 0x01, 0x9C, 0x01, 0x46, 0x05, 0x5C, 0xD7, 0xF4, 0x0A, 0x91, 0x17, 0x09, 0x15, 0x6E, - 0xD5, 0x9D}; - thread_local EncryptedName titleRightName(titleRightSource); - const std::string titleRight(titleRightName.Text()); - const std::uint8_t titleMiddleSource[] = { - 0xAD, 0x14, 0x55, 0xD7, 0x53, 0x35, 0xD2, 0x08, 0xAB, 0x5F, 0x55, 0xE1, 0x2E, 0x41, 0x4B, 0xA7, 0x0C, 0xC8, 0xFC, 0x4E, 0xCC, 0x92, 0x79, 0xB1, - 0x08, 0xC9, 0xF3, 0x4C, 0xF0, 0x9E, 0x4B, 0xB1, 0x04, 0xCF, 0xF9, 0x48, 0xF1, 0x9A, 0x65, 0x9A, 0x00, 0xD2, 0xF1, 0x03, 0xF1, 0x96, 0x67, 0xC5}; - thread_local EncryptedName titleMiddleName(titleMiddleSource); - const std::string titleMiddle(titleMiddleName.Text()); - const std::uint8_t titleLeftSource[] = { - 0x09, 0x5A, 0x9F, 0x71, 0x4F, 0x1B, 0x7E, 0xEE, 0x0F, 0x11, 0x9F, 0x47, 0x32, 0x6F, 0xE7, 0x41, 0xA8, 0x86, 0x36, 0xE8, 0xD0, 0xBC, 0xD5, 0x57, - 0xAC, 0x87, 0x39, 0xEA, 0xEC, 0xB0, 0xE7, 0x57, 0xA0, 0x81, 0x33, 0xEE, 0xED, 0xB4, 0xC9, 0x7C, 0xA5, 0x90, 0x39, 0xFF, 0xA1, 0xB7, 0xD6, 0x53, - 0xC9}; - thread_local EncryptedName titleLeftName(titleLeftSource); - const std::string titleLeft(titleLeftName.Text()); + 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)); titleBar->SetImages(titleLeft, titleMiddle, titleRight); } this->AddChild(this->m_titleBar); @@ -187,19 +192,17 @@ void CUIMacroReport::Slot15(int width, int height) { title->SetSize(100, 17); title->Move(18, 0); { - const std::uint8_t titleTextSource[] = { - 0x47, 0xBC, 0xAB, 0x85, 0x19, 0xB4, 0xB4, 0xBB, 0x6A, 0x13}; - thread_local EncryptedName titleTextName(titleTextSource); - const char* value = titleTextName.Text(); + const char titleTextSource[] = { + '\x47', '\xBC', '\xAB', '\x85', '\x19', '\xB4', '\xB4', '\xBB', '\x6A', '\x13'}; + const char* value = DecryptName<0x0B7109397F6B1387ULL>(titleTextSource); title->SetText(value, std::strlen(value)); } title->SetFitText(0); title->SetAlign(0, 6); { - const std::uint8_t titleFontSource[] = { - 0x20, 0xDE, 0xFD, 0xCC, 0xCC, 0x3F}; - thread_local EncryptedName titleFontName(titleFontSource); - title->SetFont(std::string(titleFontName.Text())); + const char titleFontSource[] = { + '\x20', '\xDE', '\xFD', '\xCC', '\xCC', '\x3F'}; + title->SetFont(std::string(DecryptName<0x13E33FA1A591AB67ULL>(titleFontSource))); } title->SetFontHeight(12); title->SetBold(0); @@ -216,26 +219,22 @@ void CUIMacroReport::Slot15(int width, int height) { menuButton->disabled = 0; menuButton->Invalidate(); { - const std::uint8_t menuDisabledSource[] = { - 0xC9, 0x88, 0xEF, 0x41, 0x7D, 0x93, 0xB8, 0x14, 0xCF, 0xC3, 0xEF, 0x77, 0x00, 0xE7, 0x21, 0xBB, 0x68, 0x54, 0x46, 0xD8, 0xE2, 0x34, 0x13, 0xAD, - 0x6C, 0x55, 0x49, 0xDA, 0xDE, 0x38, 0x21, 0xAA, 0x70, 0x54, 0x70, 0xD9, 0xDC, 0x2E, 0x18, 0x86, 0x66, 0x41, 0x49, 0x95, 0xDF, 0x30, 0x0D, 0xD9}; - thread_local EncryptedName menuDisabledName(menuDisabledSource); - const std::string menuDisabled(menuDisabledName.Text()); - const std::uint8_t menuPressedSource[] = { - 0xAF, 0xD2, 0x3B, 0xD9, 0xB1, 0xC9, 0x4A, 0x00, 0xA9, 0x99, 0x3B, 0xEF, 0xCC, 0xBD, 0xD3, 0xAF, 0x0E, 0x0E, 0x92, 0x40, 0x2E, 0x6E, 0xE1, 0xB9, - 0x0A, 0x0F, 0x9D, 0x42, 0x12, 0x62, 0xD3, 0xBE, 0x16, 0x0E, 0xA4, 0x41, 0x10, 0x74, 0xEA, 0x92, 0x00, 0x13, 0xD5, 0x41, 0x1C, 0x77, 0x8F}; - thread_local EncryptedName menuPressedName(menuPressedSource); - const std::string menuPressed(menuPressedName.Text()); - const std::uint8_t menuHoverSource[] = { - 0x83, 0x86, 0x93, 0xDD, 0x15, 0x71, 0x8C, 0x54, 0x85, 0xCD, 0x93, 0xEB, 0x68, 0x05, 0x15, 0xFB, 0x22, 0x5A, 0x3A, 0x44, 0x8A, 0xD6, 0x27, 0xED, - 0x26, 0x5B, 0x35, 0x46, 0xB6, 0xDA, 0x15, 0xEA, 0x3A, 0x5A, 0x0C, 0x45, 0xB4, 0xCC, 0x2C, 0xC6, 0x2C, 0x47, 0x7D, 0x45, 0xB8, 0xCF, 0x49}; - thread_local EncryptedName menuHoverName(menuHoverSource); - const std::string menuHover(menuHoverName.Text()); - const std::uint8_t menuNormalSource[] = { - 0xF7, 0xE8, 0x6D, 0xC3, 0x7F, 0x2B, 0x6C, 0xDA, 0xF1, 0xA3, 0x6D, 0xF5, 0x02, 0x5F, 0xF5, 0x75, 0x56, 0x34, 0xC4, 0x5A, 0xE0, 0x8C, 0xC7, 0x63, - 0x52, 0x35, 0xCB, 0x58, 0xDC, 0x80, 0xF5, 0x64, 0x4E, 0x34, 0xF2, 0x5B, 0xDE, 0x96, 0xCC, 0x48, 0x58, 0x21, 0xCB, 0x17, 0xDD, 0x88, 0xD9, 0x17}; - thread_local EncryptedName menuNormalName(menuNormalSource); - const std::string menuNormal(menuNormalName.Text()); + 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)); menuButton->SetImages(menuNormal, menuHover, menuPressed, menuDisabled); } this->m_titleBar->AddChild(menuButton); @@ -247,28 +246,24 @@ void CUIMacroReport::Slot15(int width, int height) { closeButton->disabled = 0; closeButton->Invalidate(); { - const std::uint8_t closeDisabledSource[] = { - 0x21, 0xD4, 0x39, 0x2D, 0x15, 0xDD, 0xFC, 0x10, 0x27, 0x9F, 0x39, 0x1B, 0x68, 0xA9, 0x65, 0xBF, 0x80, 0x08, 0x90, 0xB4, 0x8A, 0x7A, 0x57, 0xA9, - 0x84, 0x09, 0x9F, 0xB6, 0xB6, 0x76, 0x65, 0xAE, 0x98, 0x08, 0xA6, 0xB4, 0xB9, 0x7C, 0x4A, 0xB8, 0xBE, 0x14, 0x9F, 0xB1, 0xFB, 0x71, 0x54, 0xAD, - 0xE1}; - thread_local EncryptedName closeDisabledName(closeDisabledSource); - const std::string closeDisabled(closeDisabledName.Text()); - const std::uint8_t closePressedSource[] = { - 0x5F, 0x6A, 0xAD, 0x51, 0x17, 0xE7, 0x38, 0x68, 0x59, 0x21, 0xAD, 0x67, 0x6A, 0x93, 0xA1, 0xC7, 0xFE, 0xB6, 0x04, 0xC8, 0x88, 0x40, 0x93, 0xD1, - 0xFA, 0xB7, 0x0B, 0xCA, 0xB4, 0x4C, 0xA1, 0xD6, 0xE6, 0xB6, 0x32, 0xC8, 0xBB, 0x46, 0x8E, 0xC0, 0xC0, 0xAA, 0x03, 0x85, 0xB5, 0x44, 0x8D, 0xA5}; - thread_local EncryptedName closePressedName(closePressedSource); - const std::string closePressed(closePressedName.Text()); - const std::uint8_t closeHoverSource[] = { - 0x31, 0x68, 0xF9, 0xF3, 0xD7, 0xB7, 0x8A, 0x3C, 0x37, 0x23, 0xF9, 0xC5, 0xAA, 0xC3, 0x13, 0x93, 0x90, 0xB4, 0x50, 0x6A, 0x48, 0x10, 0x21, 0x85, - 0x94, 0xB5, 0x5F, 0x68, 0x74, 0x1C, 0x13, 0x82, 0x88, 0xB4, 0x66, 0x6A, 0x7B, 0x16, 0x3C, 0x94, 0xAE, 0xA8, 0x57, 0x27, 0x75, 0x14, 0x3F, 0xF1}; - thread_local EncryptedName closeHoverName(closeHoverSource); - const std::string closeHover(closeHoverName.Text()); - const std::uint8_t closeNormalSource[] = { - 0xBF, 0xBC, 0x1F, 0x2B, 0x45, 0xA9, 0xBC, 0x20, 0xB9, 0xF7, 0x1F, 0x1D, 0x38, 0xDD, 0x25, 0x8F, 0x1E, 0x60, 0xB6, 0xB2, 0xDA, 0x0E, 0x17, 0x99, - 0x1A, 0x61, 0xB9, 0xB0, 0xE6, 0x02, 0x25, 0x9E, 0x06, 0x60, 0x80, 0xB2, 0xE9, 0x08, 0x0A, 0x88, 0x20, 0x7C, 0xB9, 0xB7, 0xAB, 0x05, 0x14, 0x9D, - 0x7F}; - thread_local EncryptedName closeNormalName(closeNormalSource); - const std::string closeNormal(closeNormalName.Text()); + 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)); closeButton->SetImages(closeNormal, closeHover, closePressed, closeDisabled); } this->m_titleBar->SetSecondButton(closeButton); @@ -278,10 +273,9 @@ void CUIMacroReport::Slot15(int width, int height) { this->m_messageEdit->Move(8, 80); { CUIEditBox* edit = this->m_messageEdit; - const std::uint8_t placeholderSource[] = { - 0x26, 0x92, 0xB3, 0x74, 0x47, 0xB6, 0xBE, 0xBA, 0x70, 0x97, 0xB8, 0xB9, 0xA7, 0xD1, 0xB2, 0xC7, 0x5C, 0x98, 0xBF, 0x25, 0xD8, 0xE1, 0x2B, 0x05}; - thread_local EncryptedName placeholderName(placeholderSource); - edit->SetText(std::string(placeholderName.Text())); + 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))); } this->m_messageEdit->SetTextColor(0x808080); this->m_messageEdit->SetBackgroundColor(0xFFF3EE); @@ -300,20 +294,18 @@ void CUIMacroReport::Slot15(int width, int height) { this->unknown_00E4->Move(28, 25); { CUIStaticText* text = this->unknown_00E4; - const std::uint8_t firstTypeSource[] = { - 0x07, 0x6F, 0x54, 0xCA, 0x9B, 0x78, 0x2E, 0x34, 0x73, 0x0C, 0x3A, 0x80, 0x1E, 0x9F, 0x2F, 0x44, 0x00, 0x74, 0xCD, 0x8A, 0x7E, 0x0F, 0x02, 0x83}; - thread_local EncryptedName firstTypeName(firstTypeSource); - const char* value = firstTypeName.Text(); + 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'}; + const char* value = DecryptName<0x83EFBFBB37EDBDBDULL>(firstTypeSource); text->SetText(value, std::strlen(value)); } this->unknown_00E4->SetFitText(0); this->unknown_00E4->SetAlign(0, 0); { CUIStaticText* text = this->unknown_00E4; - const std::uint8_t firstTypeFontSource[] = { - 0xE0, 0x80, 0x13, 0x50, 0x5C, 0x4B}; - thread_local EncryptedName firstTypeFontName(firstTypeFontSource); - text->SetFont(std::string(firstTypeFontName.Text())); + const char firstTypeFontSource[] = { + '\xE0', '\x80', '\x13', '\x50', '\x5C', '\x4B'}; + text->SetFont(std::string(DecryptName<0xBF2B4B31397FF5A7ULL>(firstTypeFontSource))); } this->unknown_00E4->SetFontHeight(12); this->unknown_00E4->SetBold(0); @@ -327,20 +319,18 @@ void CUIMacroReport::Slot15(int width, int height) { this->unknown_00E8->Move(28, 43); { CUIStaticText* text = this->unknown_00E8; - const std::uint8_t secondTypeSource[] = { - 0x2E, 0x07, 0x50, 0x0A, 0xF1, 0x2A, 0x3E, 0x0F, 0x2A, 0x32, 0x5C, 0x67, 0x14, 0x48, 0xC9, 0x91, 0x50, 0x4E, 0x0A, 0xDD}; - thread_local EncryptedName secondTypeName(secondTypeSource); - const char* value = secondTypeName.Text(); + const char secondTypeSource[] = { + '\x2E', '\x07', '\x50', '\x0A', '\xF1', '\x2A', '\x3E', '\x0F', '\x2A', '\x32', '\x5C', '\x67', '\x14', '\x48', '\xC9', '\x91', '\x50', '\x4E', '\x0A', '\xDD'}; + const char* value = DecryptName<0x2FE993D1DDE1F197ULL>(secondTypeSource); text->SetText(value, std::strlen(value)); } this->unknown_00E8->SetFitText(0); this->unknown_00E8->SetAlign(0, 0); { CUIStaticText* text = this->unknown_00E8; - const std::uint8_t secondTypeFontSource[] = { - 0xC8, 0xEC, 0x87, 0x64, 0xD8, 0x7F}; - thread_local EncryptedName secondTypeFontName(secondTypeFontSource); - text->SetFont(std::string(secondTypeFontName.Text())); + const char secondTypeFontSource[] = { + '\xC8', '\xEC', '\x87', '\x64', '\xD8', '\x7F'}; + text->SetFont(std::string(DecryptName<0x39FF7FB50DEB998FULL>(secondTypeFontSource))); } this->unknown_00E8->SetFontHeight(12); this->unknown_00E8->SetBold(0); @@ -357,26 +347,22 @@ void CUIMacroReport::Slot15(int width, int height) { this->unknown_00EC->Invalidate(); { CUIImageButton* button = this->unknown_00EC; - const std::uint8_t cancelDisabledSource[] = { - 0xB5, 0x62, 0x2D, 0xA7, 0xAB, 0xAB, 0x20, 0xF8, 0xB3, 0x29, 0x2D, 0x91, 0xD6, 0xDF, 0xB9, 0x57, 0x01, 0xA3, 0xB2, 0x3E, 0x0A, 0x0B, 0x86, 0x50, - 0x19, 0xFF, 0xB2, 0x39, 0x02, 0x16, 0x84, 0x57, 0x19, 0xA8, 0xC3, 0x3F, 0x06, 0x15, 0xE5}; - thread_local EncryptedName cancelDisabledName(cancelDisabledSource); - const std::string cancelDisabled(cancelDisabledName.Text()); - const std::uint8_t cancelHoverSource[] = { - 0x3D, 0x16, 0x7B, 0xDB, 0x5F, 0x33, 0x84, 0x84, 0x3B, 0x5D, 0x7B, 0xED, 0x22, 0x47, 0x1D, 0x2B, 0x89, 0xD7, 0xE4, 0x42, 0xFE, 0x93, 0x22, 0x2C, - 0x91, 0x8B, 0xE4, 0x4E, 0xE9, 0x98, 0x33, 0x67, 0x9F, 0xD4, 0xCB, 0x21}; - thread_local EncryptedName cancelHoverName(cancelHoverSource); - const std::string cancelHover(cancelHoverName.Text()); - const std::uint8_t cancelPressedSource[] = { - 0x0D, 0x5E, 0x59, 0x4F, 0x4D, 0x95, 0xC2, 0x60, 0x0B, 0x15, 0x59, 0x79, 0x30, 0xE1, 0x5B, 0xCF, 0xB9, 0x9F, 0xC6, 0xD6, 0xEC, 0x35, 0x64, 0xC8, - 0xA1, 0xC3, 0xC6, 0xC5, 0xFF, 0x3E, 0x74, 0xDE, 0xE3, 0x93, 0xF4, 0xC5, 0x8D}; - thread_local EncryptedName cancelPressedName(cancelPressedSource); - const std::string cancelPressed(cancelPressedName.Text()); - const std::uint8_t cancelNormalSource[] = { - 0xBF, 0xBA, 0x4D, 0xEB, 0xF7, 0xC1, 0x4E, 0xE2, 0xB9, 0xF1, 0x4D, 0xDD, 0x8A, 0xB5, 0xD7, 0x4D, 0x0B, 0x7B, 0xD2, 0x72, 0x56, 0x61, 0xE8, 0x4A, - 0x13, 0x27, 0xD2, 0x7F, 0x58, 0x7D, 0xE6, 0x4E, 0x13, 0x3B, 0xEF, 0x7C, 0x47, 0x0F}; - thread_local EncryptedName cancelNormalName(cancelNormalSource); - const std::string cancelNormal(cancelNormalName.Text()); + 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)); button->SetImages(cancelNormal, cancelPressed, cancelHover, cancelDisabled); } this->AddChild(this->unknown_00EC); @@ -389,26 +375,22 @@ void CUIMacroReport::Slot15(int width, int height) { this->unknown_00F0->Invalidate(); { CUIImageButton* button = this->unknown_00F0; - const std::uint8_t reportDisabledSource[] = { - 0xA3, 0x5A, 0x21, 0x85, 0xFB, 0xEB, 0xD8, 0x06, 0xA5, 0x11, 0x21, 0xB3, 0x86, 0x9F, 0x41, 0xA9, 0x17, 0x9B, 0xBE, 0x0D, 0x5E, 0x55, 0x72, 0xB9, - 0x17, 0xAA, 0x85, 0x16, 0x48, 0x44, 0x7F, 0xA7, 0x06, 0xDB, 0x83, 0x12, 0x4B, 0x25}; - thread_local EncryptedName reportDisabledName(reportDisabledSource); - const std::string reportDisabled(reportDisabledName.Text()); - const std::uint8_t reportHoverSource[] = { - 0x09, 0xBC, 0x39, 0x89, 0x39, 0x17, 0xD0, 0xBC, 0x0F, 0xF7, 0x39, 0xBF, 0x44, 0x63, 0x49, 0x13, 0xBD, 0x7D, 0xA6, 0x01, 0x9C, 0xA9, 0x7A, 0x03, - 0xBD, 0x4C, 0x96, 0x05, 0x9C, 0xAB, 0x3B, 0x13, 0xA4, 0x63, 0xF9}; - thread_local EncryptedName reportHoverName(reportHoverSource); - const std::string reportHover(reportHoverName.Text()); - const std::uint8_t reportPressedSource[] = { - 0x3D, 0x78, 0x8D, 0x53, 0x75, 0x41, 0x52, 0x2A, 0x3B, 0x33, 0x8D, 0x65, 0x08, 0x35, 0xCB, 0x85, 0x89, 0xB9, 0x12, 0xDB, 0xD0, 0xFF, 0xF8, 0x95, - 0x89, 0x88, 0x3D, 0xDB, 0xD0, 0xFC, 0xE4, 0xC9, 0x9F, 0xBA, 0x3D, 0xA9}; - thread_local EncryptedName reportPressedName(reportPressedSource); - const std::string reportPressed(reportPressedName.Text()); - const std::uint8_t reportNormalSource[] = { - 0xAB, 0x16, 0x07, 0xF5, 0xA7, 0x41, 0x38, 0x7A, 0xAD, 0x5D, 0x07, 0xC3, 0xDA, 0x35, 0xA1, 0xD5, 0x1F, 0xD7, 0x98, 0x7D, 0x02, 0xFF, 0x92, 0xC5, - 0x1F, 0xE6, 0xA9, 0x60, 0x15, 0xE2, 0x9C, 0xDB, 0x45, 0xDB, 0xAA, 0x7F, 0x67}; - thread_local EncryptedName reportNormalName(reportNormalSource); - const std::string reportNormal(reportNormalName.Text()); + 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)); button->SetImages(reportNormal, reportPressed, reportHover, reportDisabled); } this->AddChild(this->unknown_00F0); @@ -421,26 +403,22 @@ void CUIMacroReport::Slot15(int width, int height) { this->m_firstTypeButton->Invalidate(); { CUIRadioButton* button = this->m_firstTypeButton; - const std::uint8_t firstRadioDisabledSource[] = { - 0xBF, 0x7A, 0x6F, 0xA1, 0xAB, 0x7F, 0xD0, 0xC2, 0xB9, 0x31, 0x6F, 0x97, 0xD6, 0x0B, 0x49, 0x7D, 0x1E, 0xB1, 0xC6, 0x34, 0x09, 0xC5, 0x7B, 0x50, - 0x10, 0xB3, 0xC9, 0x75, 0x09, 0xDC, 0x65, 0x0F}; - thread_local EncryptedName firstRadioDisabledName(firstRadioDisabledSource); - const std::string firstRadioDisabled(firstRadioDisabledName.Text()); - const std::uint8_t firstRadioHoverSource[] = { - 0xE3, 0x5E, 0x17, 0xED, 0x17, 0x87, 0x26, 0xB0, 0xE5, 0x15, 0x17, 0xDB, 0x6A, 0xF3, 0xBF, 0x0F, 0x42, 0x95, 0xBE, 0x78, 0xB5, 0x3D, 0x8D, 0x22, - 0x4C, 0x97, 0xB1, 0x39, 0xB5, 0x24, 0x93, 0x7D}; - thread_local EncryptedName firstRadioHoverName(firstRadioHoverSource); - const std::string firstRadioHover(firstRadioHoverName.Text()); - const std::uint8_t firstRadioPressedSource[] = { - 0xDD, 0xAA, 0x53, 0xD3, 0xB1, 0xED, 0x92, 0x28, 0xDB, 0xE1, 0x53, 0xE5, 0xCC, 0x99, 0x0B, 0x97, 0x7C, 0x61, 0xFA, 0x46, 0x13, 0x57, 0x39, 0xBA, - 0x72, 0x6B, 0xBD, 0x4B, 0x1C, 0x53, 0x57}; - thread_local EncryptedName firstRadioPressedName(firstRadioPressedSource); - const std::string firstRadioPressed(firstRadioPressedName.Text()); - const std::uint8_t firstRadioNormalSource[] = { - 0x8F, 0xC8, 0x2D, 0x7F, 0xC9, 0xF9, 0xFA, 0xB4, 0x89, 0x83, 0x2D, 0x49, 0xB4, 0x8D, 0x63, 0x0B, 0x2E, 0x03, 0x84, 0xEA, 0x6B, 0x43, 0x51, 0x26, - 0x20, 0x01, 0x8B, 0xAB, 0x6B, 0x5A, 0x4F, 0x79}; - thread_local EncryptedName firstRadioNormalName(firstRadioNormalSource); - const std::string firstRadioNormal(firstRadioNormalName.Text()); + 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)); button->SetImages(firstRadioNormal, firstRadioPressed, firstRadioHover, firstRadioDisabled); } this->m_firstTypeButton->checked = true; @@ -455,26 +433,22 @@ void CUIMacroReport::Slot15(int width, int height) { this->m_secondTypeButton->Invalidate(); { CUIRadioButton* button = this->m_secondTypeButton; - const std::uint8_t secondRadioDisabledSource[] = { - 0xAD, 0xB4, 0x67, 0xEB, 0xB7, 0xA1, 0x0E, 0x3E, 0xAB, 0xFF, 0x67, 0xDD, 0xCA, 0xD5, 0x97, 0x81, 0x0C, 0x7F, 0xCE, 0x7E, 0x15, 0x1B, 0xA5, 0xAC, - 0x02, 0x7D, 0xC1, 0x3F, 0x15, 0x02, 0xBB, 0xF3}; - thread_local EncryptedName secondRadioDisabledName(secondRadioDisabledSource); - const std::string secondRadioDisabled(secondRadioDisabledName.Text()); - const std::uint8_t secondRadioHoverSource[] = { - 0x73, 0xC8, 0x99, 0x75, 0x1F, 0xE9, 0x5E, 0x4E, 0x75, 0x83, 0x99, 0x43, 0x62, 0x9D, 0xC7, 0xF1, 0xD2, 0x03, 0x30, 0xE0, 0xBD, 0x53, 0xF5, 0xDC, - 0xDC, 0x01, 0x3F, 0xA1, 0xBD, 0x4A, 0xEB, 0x83}; - thread_local EncryptedName secondRadioHoverName(secondRadioHoverSource); - const std::string secondRadioHover(secondRadioHoverName.Text()); - const std::uint8_t secondRadioPressedSource[] = { - 0x21, 0x36, 0x47, 0xB5, 0x41, 0x0D, 0xE4, 0xBE, 0x27, 0x7D, 0x47, 0x83, 0x3C, 0x79, 0x7D, 0x01, 0x80, 0xFD, 0xEE, 0x20, 0xE3, 0xB7, 0x4F, 0x2C, - 0x8E, 0xF7, 0xA9, 0x2D, 0xEC, 0xB3, 0x21}; - thread_local EncryptedName secondRadioPressedName(secondRadioPressedSource); - const std::string secondRadioPressed(secondRadioPressedName.Text()); - const std::uint8_t secondRadioNormalSource[] = { - 0x8F, 0x0E, 0x0F, 0xCF, 0xA3, 0x19, 0x84, 0xB4, 0x89, 0x45, 0x0F, 0xF9, 0xDE, 0x6D, 0x1D, 0x0B, 0x2E, 0xC5, 0xA6, 0x5A, 0x01, 0xA3, 0x2F, 0x26, - 0x20, 0xC7, 0xA9, 0x1B, 0x01, 0xBA, 0x31, 0x79}; - thread_local EncryptedName secondRadioNormalName(secondRadioNormalSource); - const std::string secondRadioNormal(secondRadioNormalName.Text()); + 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)); button->SetImages(secondRadioNormal, secondRadioPressed, secondRadioHover, secondRadioDisabled); } this->m_secondTypeButton->checked = false; @@ -486,21 +460,19 @@ void CUIMacroReport::Slot15(int width, int height) { this->unknown_00FC->Move(9, 142); { CUIStaticText* text = this->unknown_00FC; - const std::uint8_t warningSource[] = { - 0xD4, 0xB7, 0x7D, 0xB6, 0x2D, 0x51, 0xE8, 0xFA, 0x8E, 0x75, 0x74, 0xBC, 0x2D, 0x2E, 0x89, 0x85, 0x82, 0xED, 0x6F, 0x5F, 0xB4, 0x31, 0xEF, 0xFE, - 0x45, 0xE9, 0x3F, 0x5F, 0xCD, 0x39, 0x92, 0x85, 0xD1, 0x9A, 0x7D, 0xA6, 0x23, 0xEF}; - thread_local EncryptedName warningName(warningSource); - const char* value = warningName.Text(); + 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'}; + const char* value = DecryptName<0x452FEF0D7FC95565ULL>(warningSource); text->SetText(value, std::strlen(value)); } this->unknown_00FC->SetFitText(0); this->unknown_00FC->SetAlign(0, 0); { CUIStaticText* text = this->unknown_00FC; - const std::uint8_t warningFontSource[] = { - 0x1A, 0x78, 0x25, 0xE0, 0xCC, 0x7D}; - thread_local EncryptedName warningFontName(warningFontSource); - text->SetFont(std::string(warningFontName.Text())); + const char warningFontSource[] = { + '\x1A', '\x78', '\x25', '\xE0', '\xCC', '\x7D'}; + text->SetFont(std::string(DecryptName<0x9FED7DA189490D5DULL>(warningFontSource))); } this->unknown_00FC->SetFontHeight(12); this->unknown_00FC->SetBold(0);