diff --git a/Source/UI/AdventureGuide/UIAdventureGuide.cpp b/Source/UI/AdventureGuide/UIAdventureGuide.cpp index 17a349c9..0f531bc4 100644 --- a/Source/UI/AdventureGuide/UIAdventureGuide.cpp +++ b/Source/UI/AdventureGuide/UIAdventureGuide.cpp @@ -30,7 +30,8 @@ namespace { template class EncryptedName { public: - explicit EncryptedName(const std::uint8_t (&source)[Length]) : m_encrypted(true) { + // INLINED + explicit EncryptedName(const char (&source)[Length]) : m_encrypted(true) { for (std::uint64_t index = 0; index < Length; ++index) { this->m_text[index] = source[index]; } @@ -64,6 +65,10 @@ template void CUIListBox::UpdateScrollBar(); template <> __declspec(noinline) void CUIListBox::SelectItem(CUIListItem* item); template <> AdventureGuide::CUISubTab* CUIListBox::CreateItem(); template <> AdventureGuide::CUITab* CUIListBox::CreateItem(); +template <> void CUIListBoxEx::AddNewItem(); +template <> void CUIListBoxEx::AddNewItem(); +template <> void CUIListBoxEx::AddNewItem(); +template <> void CUIListBoxEx::AddNewItem(); // OFFSET: 0x009C28B0 // FUNCTION: fn_13993 @@ -166,9 +171,10 @@ void CUIAdventureGuide::Slot15(int width, int height) { this->background->Move(0, 0); { CUIStaticImage* background = this->background; - const std::uint8_t backgroundImageSource[] = { - 0x49, 0x74, 0xA3, 0x83, 0x2B, 0x55, 0x0A, 0x7E, 0x4F, 0x3F, 0xA3, 0xB5, 0x56, 0x21, 0x93, 0xF2, 0xED, 0xAD, 0x06, 0x17, 0x9F, 0xEE, 0xBD, 0xD6, - 0xCE, 0xAE, 0x0A, 0x1D, 0x8E, 0xC7, 0xAD, 0xD4, 0xD6, 0xBC, 0x16, 0x10, 0x8F, 0xFE, 0xE1, 0xD1, 0xE4, 0xAB, 0x63}; + const char backgroundImageSource[] = { + '\x49', '\x74', '\xA3', '\x83', '\x2B', '\x55', '\x0A', '\x7E', '\x4F', '\x3F', '\xA3', '\xB5', '\x56', '\x21', '\x93', '\xF2', '\xED', '\xAD', '\x06', + '\x17', '\x9F', '\xEE', '\xBD', '\xD6', '\xCE', '\xAE', '\x0A', '\x1D', '\x8E', '\xC7', '\xAD', '\xD4', '\xD6', '\xBC', '\x16', '\x10', '\x8F', '\xFE', + '\xE1', '\xD1', '\xE4', '\xAB', '\x63'}; thread_local EncryptedName backgroundImageName(backgroundImageSource); const std::string backgroundImage(backgroundImageName.Text()); background->SetImage(backgroundImage); @@ -180,21 +186,22 @@ void CUIAdventureGuide::Slot15(int width, int height) { this->titleBar->Move(0, 0); { CUITitleBar* titleBar = this->titleBar; - const std::uint8_t titleRightSource[] = { - 0x5F, 0x56, 0x81, 0x37, 0x39, 0xA5, 0x62, 0x7A, 0x59, 0x1D, 0x81, 0x01, 0x44, 0xD1, 0xFB, 0xD5, 0xFE, 0x8A, 0x28, 0xAE, 0xA6, 0x02, 0xC9, 0xC3, - 0xFA, 0x8B, 0x27, 0xAC, 0x9A, 0x0E, 0xFB, 0xC3, 0xF6, 0x8D, 0x2D, 0xA8, 0x9B, 0x0A, 0xD5, 0xE8, 0xED, 0x90, 0x26, 0xA5, 0x8D, 0x45, 0xC5, 0xDA, - 0xEF, 0xF9}; + const char titleRightSource[] = { + '\x5F', '\x56', '\x81', '\x37', '\x39', '\xA5', '\x62', '\x7A', '\x59', '\x1D', '\x81', '\x01', '\x44', '\xD1', '\xFB', '\xD5', '\xFE', '\x8A', '\x28', + '\xAE', '\xA6', '\x02', '\xC9', '\xC3', '\xFA', '\x8B', '\x27', '\xAC', '\x9A', '\x0E', '\xFB', '\xC3', '\xF6', '\x8D', '\x2D', '\xA8', '\x9B', '\x0A', + '\xD5', '\xE8', '\xED', '\x90', '\x26', '\xA5', '\x8D', '\x45', '\xC5', '\xDA', '\xEF', '\xF9'}; thread_local EncryptedName titleRightName(titleRightSource); const std::string titleRight(titleRightName.Text()); - const std::uint8_t titleMiddleSource[] = { - 0x7F, 0x2A, 0xE7, 0x87, 0x93, 0xED, 0x3E, 0x2E, 0x79, 0x61, 0xE7, 0xB1, 0xEE, 0x99, 0xA7, 0x81, 0xDE, 0xF6, 0x4E, 0x1E, 0x0C, 0x4A, 0x95, 0x97, - 0xDA, 0xF7, 0x41, 0x1C, 0x30, 0x46, 0xA7, 0x97, 0xD6, 0xF1, 0x4B, 0x18, 0x31, 0x42, 0x89, 0xBC, 0xD2, 0xEC, 0x43, 0x53, 0x31, 0x4E, 0x8B, 0xE3}; + const char titleMiddleSource[] = { + '\x7F', '\x2A', '\xE7', '\x87', '\x93', '\xED', '\x3E', '\x2E', '\x79', '\x61', '\xE7', '\xB1', '\xEE', '\x99', '\xA7', '\x81', '\xDE', '\xF6', '\x4E', + '\x1E', '\x0C', '\x4A', '\x95', '\x97', '\xDA', '\xF7', '\x41', '\x1C', '\x30', '\x46', '\xA7', '\x97', '\xD6', '\xF1', '\x4B', '\x18', '\x31', '\x42', + '\x89', '\xBC', '\xD2', '\xEC', '\x43', '\x53', '\x31', '\x4E', '\x8B', '\xE3'}; thread_local EncryptedName titleMiddleName(titleMiddleSource); const std::string titleMiddle(titleMiddleName.Text()); - const std::uint8_t titleLeftSource[] = { - 0x23, 0xF8, 0xD5, 0xA7, 0xD7, 0x4F, 0x1E, 0xD2, 0x25, 0xB3, 0xD5, 0x91, 0xAA, 0x3B, 0x87, 0x7D, 0x82, 0x24, 0x7C, 0x3E, 0x48, 0xE8, 0xB5, 0x6B, - 0x86, 0x25, 0x73, 0x3C, 0x74, 0xE4, 0x87, 0x6B, 0x8A, 0x23, 0x79, 0x38, 0x75, 0xE0, 0xA9, 0x40, 0x8F, 0x32, 0x73, 0x29, 0x39, 0xE3, 0xB6, 0x6F, - 0xE3}; + const char titleLeftSource[] = { + '\x23', '\xF8', '\xD5', '\xA7', '\xD7', '\x4F', '\x1E', '\xD2', '\x25', '\xB3', '\xD5', '\x91', '\xAA', '\x3B', '\x87', '\x7D', '\x82', '\x24', '\x7C', + '\x3E', '\x48', '\xE8', '\xB5', '\x6B', '\x86', '\x25', '\x73', '\x3C', '\x74', '\xE4', '\x87', '\x6B', '\x8A', '\x23', '\x79', '\x38', '\x75', '\xE0', + '\xA9', '\x40', '\x8F', '\x32', '\x73', '\x29', '\x39', '\xE3', '\xB6', '\x6F', '\xE3'}; thread_local EncryptedName titleLeftName(titleLeftSource); const std::string titleLeft(titleLeftName.Text()); titleBar->SetImages(titleLeft, titleMiddle, titleRight); @@ -208,8 +215,7 @@ void CUIAdventureGuide::Slot15(int width, int height) { title->SetFitText(0); title->SetAlign(0, 6); { - const std::uint8_t titleFontSource[] = { - 0x90, 0x32, 0x91, 0x0A, 0x60, 0x39}; + const char titleFontSource[] = {'\x90', '\x32', '\x91', '\x0A', '\x60', '\x39'}; thread_local EncryptedName titleFontName(titleFontSource); const std::string titleFont(titleFontName.Text()); title->SetFont(titleFont); @@ -229,24 +235,28 @@ void CUIAdventureGuide::Slot15(int width, int height) { menuButton->disabled = 0; menuButton->Invalidate(); { - const std::uint8_t menuDisabledSource[] = { - 0x49, 0xC4, 0x29, 0x65, 0x8B, 0x91, 0x5C, 0x08, 0x4F, 0x8F, 0x29, 0x53, 0xF6, 0xE5, 0xC5, 0xA7, 0xE8, 0x18, 0x80, 0xFC, 0x14, 0x36, 0xF7, 0xB1, - 0xEC, 0x19, 0x8F, 0xFE, 0x28, 0x3A, 0xC5, 0xB6, 0xF0, 0x18, 0xB6, 0xFD, 0x2A, 0x2C, 0xFC, 0x9A, 0xE6, 0x0D, 0x8F, 0xB1, 0x29, 0x32, 0xE9, 0xC5}; + const char menuDisabledSource[] = { + '\x49', '\xC4', '\x29', '\x65', '\x8B', '\x91', '\x5C', '\x08', '\x4F', '\x8F', '\x29', '\x53', '\xF6', '\xE5', '\xC5', '\xA7', '\xE8', '\x18', '\x80', + '\xFC', '\x14', '\x36', '\xF7', '\xB1', '\xEC', '\x19', '\x8F', '\xFE', '\x28', '\x3A', '\xC5', '\xB6', '\xF0', '\x18', '\xB6', '\xFD', '\x2A', '\x2C', + '\xFC', '\x9A', '\xE6', '\x0D', '\x8F', '\xB1', '\x29', '\x32', '\xE9', '\xC5'}; thread_local EncryptedName menuDisabledName(menuDisabledSource); const std::string menuDisabled(menuDisabledName.Text()); - const std::uint8_t menuPressedSource[] = { - 0xDB, 0x66, 0x01, 0x15, 0x11, 0xB3, 0xCA, 0xAC, 0xDD, 0x2D, 0x01, 0x23, 0x6C, 0xC7, 0x53, 0x03, 0x7A, 0xBA, 0xA8, 0x8C, 0x8E, 0x14, 0x61, 0x15, - 0x7E, 0xBB, 0xA7, 0x8E, 0xB2, 0x18, 0x53, 0x12, 0x62, 0xBA, 0x9E, 0x8D, 0xB0, 0x0E, 0x6A, 0x3E, 0x74, 0xA7, 0xEF, 0x8D, 0xBC, 0x0D, 0x0F}; + const char menuPressedSource[] = { + '\xDB', '\x66', '\x01', '\x15', '\x11', '\xB3', '\xCA', '\xAC', '\xDD', '\x2D', '\x01', '\x23', '\x6C', '\xC7', '\x53', '\x03', '\x7A', '\xBA', '\xA8', + '\x8C', '\x8E', '\x14', '\x61', '\x15', '\x7E', '\xBB', '\xA7', '\x8E', '\xB2', '\x18', '\x53', '\x12', '\x62', '\xBA', '\x9E', '\x8D', '\xB0', '\x0E', + '\x6A', '\x3E', '\x74', '\xA7', '\xEF', '\x8D', '\xBC', '\x0D', '\x0F'}; thread_local EncryptedName menuPressedName(menuPressedSource); const std::string menuPressed(menuPressedName.Text()); - const std::uint8_t menuHoverSource[] = { - 0xF7, 0xDA, 0x6D, 0x5D, 0x03, 0x6F, 0x56, 0x92, 0xF1, 0x91, 0x6D, 0x6B, 0x7E, 0x1B, 0xCF, 0x3D, 0x56, 0x06, 0xC4, 0xC4, 0x9C, 0xC8, 0xFD, 0x2B, - 0x52, 0x07, 0xCB, 0xC6, 0xA0, 0xC4, 0xCF, 0x2C, 0x4E, 0x06, 0xF2, 0xC5, 0xA2, 0xD2, 0xF6, 0x00, 0x58, 0x1B, 0x83, 0xC5, 0xAE, 0xD1, 0x93}; + const char menuHoverSource[] = { + '\xF7', '\xDA', '\x6D', '\x5D', '\x03', '\x6F', '\x56', '\x92', '\xF1', '\x91', '\x6D', '\x6B', '\x7E', '\x1B', '\xCF', '\x3D', '\x56', '\x06', '\xC4', + '\xC4', '\x9C', '\xC8', '\xFD', '\x2B', '\x52', '\x07', '\xCB', '\xC6', '\xA0', '\xC4', '\xCF', '\x2C', '\x4E', '\x06', '\xF2', '\xC5', '\xA2', '\xD2', + '\xF6', '\x00', '\x58', '\x1B', '\x83', '\xC5', '\xAE', '\xD1', '\x93'}; thread_local EncryptedName menuHoverName(menuHoverSource); const std::string menuHover(menuHoverName.Text()); - const std::uint8_t menuNormalSource[] = { - 0x47, 0x08, 0x85, 0x89, 0xD5, 0x47, 0xB6, 0xC4, 0x41, 0x43, 0x85, 0xBF, 0xA8, 0x33, 0x2F, 0x6B, 0xE6, 0xD4, 0x2C, 0x10, 0x4A, 0xE0, 0x1D, 0x7D, - 0xE2, 0xD5, 0x23, 0x12, 0x76, 0xEC, 0x2F, 0x7A, 0xFE, 0xD4, 0x1A, 0x11, 0x74, 0xFA, 0x16, 0x56, 0xE8, 0xC1, 0x23, 0x5D, 0x77, 0xE4, 0x03, 0x09}; + const char menuNormalSource[] = { + '\x47', '\x08', '\x85', '\x89', '\xD5', '\x47', '\xB6', '\xC4', '\x41', '\x43', '\x85', '\xBF', '\xA8', '\x33', '\x2F', '\x6B', '\xE6', '\xD4', '\x2C', + '\x10', '\x4A', '\xE0', '\x1D', '\x7D', '\xE2', '\xD5', '\x23', '\x12', '\x76', '\xEC', '\x2F', '\x7A', '\xFE', '\xD4', '\x1A', '\x11', '\x74', '\xFA', + '\x16', '\x56', '\xE8', '\xC1', '\x23', '\x5D', '\x77', '\xE4', '\x03', '\x09'}; thread_local EncryptedName menuNormalName(menuNormalSource); const std::string menuNormal(menuNormalName.Text()); menuButton->SetImages(menuNormal, menuHover, menuPressed, menuDisabled); @@ -260,26 +270,28 @@ void CUIAdventureGuide::Slot15(int width, int height) { closeButton->disabled = 0; closeButton->Invalidate(); { - const std::uint8_t closeDisabledSource[] = { - 0x53, 0x34, 0xE5, 0x23, 0xE5, 0xE3, 0x68, 0x90, 0x55, 0x7F, 0xE5, 0x15, 0x98, 0x97, 0xF1, 0x3F, 0xF2, 0xE8, 0x4C, 0xBA, 0x7A, 0x44, 0xC3, 0x29, - 0xF6, 0xE9, 0x43, 0xB8, 0x46, 0x48, 0xF1, 0x2E, 0xEA, 0xE8, 0x7A, 0xBA, 0x49, 0x42, 0xDE, 0x38, 0xCC, 0xF4, 0x43, 0xBF, 0x0B, 0x4F, 0xC0, 0x2D, - 0x93}; + const char closeDisabledSource[] = { + '\x53', '\x34', '\xE5', '\x23', '\xE5', '\xE3', '\x68', '\x90', '\x55', '\x7F', '\xE5', '\x15', '\x98', '\x97', '\xF1', '\x3F', '\xF2', '\xE8', '\x4C', + '\xBA', '\x7A', '\x44', '\xC3', '\x29', '\xF6', '\xE9', '\x43', '\xB8', '\x46', '\x48', '\xF1', '\x2E', '\xEA', '\xE8', '\x7A', '\xBA', '\x49', '\x42', + '\xDE', '\x38', '\xCC', '\xF4', '\x43', '\xBF', '\x0B', '\x4F', '\xC0', '\x2D', '\x93'}; thread_local EncryptedName closeDisabledName(closeDisabledSource); const std::string closeDisabled(closeDisabledName.Text()); - const std::uint8_t closePressedSource[] = { - 0x3D, 0x6E, 0xB3, 0xB9, 0xE7, 0x9F, 0xD8, 0xD2, 0x3B, 0x25, 0xB3, 0x8F, 0x9A, 0xEB, 0x41, 0x7D, 0x9C, 0xB2, 0x1A, 0x20, 0x78, 0x38, 0x73, 0x6B, - 0x98, 0xB3, 0x15, 0x22, 0x44, 0x34, 0x41, 0x6C, 0x84, 0xB2, 0x2C, 0x20, 0x4B, 0x3E, 0x6E, 0x7A, 0xA2, 0xAE, 0x1D, 0x6D, 0x45, 0x3C, 0x6D, 0x1F}; + const char closePressedSource[] = { + '\x3D', '\x6E', '\xB3', '\xB9', '\xE7', '\x9F', '\xD8', '\xD2', '\x3B', '\x25', '\xB3', '\x8F', '\x9A', '\xEB', '\x41', '\x7D', '\x9C', '\xB2', '\x1A', + '\x20', '\x78', '\x38', '\x73', '\x6B', '\x98', '\xB3', '\x15', '\x22', '\x44', '\x34', '\x41', '\x6C', '\x84', '\xB2', '\x2C', '\x20', '\x4B', '\x3E', + '\x6E', '\x7A', '\xA2', '\xAE', '\x1D', '\x6D', '\x45', '\x3C', '\x6D', '\x1F'}; thread_local EncryptedName closePressedName(closePressedSource); const std::string closePressed(closePressedName.Text()); - const std::uint8_t closeHoverSource[] = { - 0xE7, 0x3C, 0xBF, 0xF5, 0x9B, 0xD1, 0xF2, 0xF0, 0xE1, 0x77, 0xBF, 0xC3, 0xE6, 0xA5, 0x6B, 0x5F, 0x46, 0xE0, 0x16, 0x6C, 0x04, 0x76, 0x59, 0x49, - 0x42, 0xE1, 0x19, 0x6E, 0x38, 0x7A, 0x6B, 0x4E, 0x5E, 0xE0, 0x20, 0x6C, 0x37, 0x70, 0x44, 0x58, 0x78, 0xFC, 0x11, 0x21, 0x39, 0x72, 0x47, 0x3D}; + const char closeHoverSource[] = { + '\xE7', '\x3C', '\xBF', '\xF5', '\x9B', '\xD1', '\xF2', '\xF0', '\xE1', '\x77', '\xBF', '\xC3', '\xE6', '\xA5', '\x6B', '\x5F', '\x46', '\xE0', '\x16', + '\x6C', '\x04', '\x76', '\x59', '\x49', '\x42', '\xE1', '\x19', '\x6E', '\x38', '\x7A', '\x6B', '\x4E', '\x5E', '\xE0', '\x20', '\x6C', '\x37', '\x70', + '\x44', '\x58', '\x78', '\xFC', '\x11', '\x21', '\x39', '\x72', '\x47', '\x3D'}; thread_local EncryptedName closeHoverName(closeHoverSource); const std::string closeHover(closeHoverName.Text()); - const std::uint8_t closeNormalSource[] = { - 0xE9, 0x60, 0xE9, 0xFD, 0x23, 0xE7, 0x32, 0xA6, 0xEF, 0x2B, 0xE9, 0xCB, 0x5E, 0x93, 0xAB, 0x09, 0x48, 0xBC, 0x40, 0x64, 0xBC, 0x40, 0x99, 0x1F, - 0x4C, 0xBD, 0x4F, 0x66, 0x80, 0x4C, 0xAB, 0x18, 0x50, 0xBC, 0x76, 0x64, 0x8F, 0x46, 0x84, 0x0E, 0x76, 0xA0, 0x4F, 0x61, 0xCD, 0x4B, 0x9A, 0x1B, - 0x29}; + const char closeNormalSource[] = { + '\xE9', '\x60', '\xE9', '\xFD', '\x23', '\xE7', '\x32', '\xA6', '\xEF', '\x2B', '\xE9', '\xCB', '\x5E', '\x93', '\xAB', '\x09', '\x48', '\xBC', '\x40', + '\x64', '\xBC', '\x40', '\x99', '\x1F', '\x4C', '\xBD', '\x4F', '\x66', '\x80', '\x4C', '\xAB', '\x18', '\x50', '\xBC', '\x76', '\x64', '\x8F', '\x46', + '\x84', '\x0E', '\x76', '\xA0', '\x4F', '\x61', '\xCD', '\x4B', '\x9A', '\x1B', '\x29'}; thread_local EncryptedName closeNormalName(closeNormalSource); const std::string closeNormal(closeNormalName.Text()); closeButton->SetImages(closeNormal, closeHover, closePressed, closeDisabled); @@ -299,8 +311,7 @@ void CUIAdventureGuide::Slot15(int width, int height) { this->titleText->SetAlign(6, 6); { CUIStaticText* titleText = this->titleText; - const std::uint8_t stageFontSource[] = { - 0xF0, 0x14, 0x91, 0xD6, 0x5A, 0x2D}; + const char stageFontSource[] = {'\xF0', '\x14', '\x91', '\xD6', '\x5A', '\x2D'}; thread_local EncryptedName stageFontName(stageFontSource); const std::string stageFont(stageFontName.Text()); titleText->SetFont(stageFont); @@ -338,26 +349,28 @@ void CUIAdventureGuide::Slot15(int width, int height) { this->tabs->SetOnSelect([this](AdventureGuide::CUITab* tab) { this->OnSelectTab(tab); }); { CUIListBox* tabs = this->tabs; - const std::uint8_t tabDisabledSource[] = { - 0xB9, 0x02, 0x47, 0x89, 0xB3, 0x21, 0x26, 0x56, 0xBF, 0x49, 0x47, 0xBF, 0xCE, 0x55, 0xBF, 0xDA, 0x1D, 0xDB, 0xE2, 0x1D, 0x07, 0x9A, 0x91, 0xFE, - 0x3E, 0xD8, 0xEE, 0x17, 0x16, 0xB3, 0x97, 0xFA, 0x1B, 0xF2, 0xE5, 0x07, 0x1D, 0xB0, 0x8D, 0xF4, 0x0B, 0xC0, 0xE6, 0x1F, 0x5D, 0x8D, 0x8E, 0xEB, - 0x79}; + const char tabDisabledSource[] = { + '\xB9', '\x02', '\x47', '\x89', '\xB3', '\x21', '\x26', '\x56', '\xBF', '\x49', '\x47', '\xBF', '\xCE', '\x55', '\xBF', '\xDA', '\x1D', '\xDB', '\xE2', + '\x1D', '\x07', '\x9A', '\x91', '\xFE', '\x3E', '\xD8', '\xEE', '\x17', '\x16', '\xB3', '\x97', '\xFA', '\x1B', '\xF2', '\xE5', '\x07', '\x1D', '\xB0', + '\x8D', '\xF4', '\x0B', '\xC0', '\xE6', '\x1F', '\x5D', '\x8D', '\x8E', '\xEB', '\x79'}; thread_local EncryptedName tabDisabledName(tabDisabledSource); const std::string tabDisabled(tabDisabledName.Text()); - const std::uint8_t tabPressedSource[] = { - 0xF7, 0x52, 0xB5, 0xAF, 0xF5, 0x0F, 0x90, 0x8A, 0xF1, 0x19, 0xB5, 0x99, 0x88, 0x7B, 0x09, 0x06, 0x53, 0x8B, 0x10, 0x3B, 0x41, 0xB4, 0x27, 0x22, - 0x70, 0x88, 0x1C, 0x31, 0x50, 0x9D, 0x21, 0x26, 0x55, 0xA2, 0x17, 0x21, 0x5B, 0x9E, 0x3A, 0x31, 0x52, 0x8F, 0x5B, 0x37, 0x58, 0xB1, 0x55}; + const char tabPressedSource[] = { + '\xF7', '\x52', '\xB5', '\xAF', '\xF5', '\x0F', '\x90', '\x8A', '\xF1', '\x19', '\xB5', '\x99', '\x88', '\x7B', '\x09', '\x06', '\x53', '\x8B', '\x10', + '\x3B', '\x41', '\xB4', '\x27', '\x22', '\x70', '\x88', '\x1C', '\x31', '\x50', '\x9D', '\x21', '\x26', '\x55', '\xA2', '\x17', '\x21', '\x5B', '\x9E', + '\x3A', '\x31', '\x52', '\x8F', '\x5B', '\x37', '\x58', '\xB1', '\x55'}; thread_local EncryptedName tabPressedName(tabPressedSource); const std::string tabPressed(tabPressedName.Text()); - const std::uint8_t tabHoverSource[] = { - 0xC7, 0x72, 0xB7, 0x99, 0xA3, 0xFB, 0x0E, 0xDC, 0xC1, 0x39, 0xB7, 0xAF, 0xDE, 0x8F, 0x97, 0x50, 0x63, 0xAB, 0x12, 0x0D, 0x17, 0x40, 0xB9, 0x74, - 0x40, 0xA8, 0x1E, 0x07, 0x06, 0x69, 0xBF, 0x70, 0x65, 0x82, 0x15, 0x17, 0x0D, 0x6A, 0xBB, 0x63, 0x62, 0xAE, 0x04, 0x4D, 0x01, 0x58, 0xBB, 0x11}; + const char tabHoverSource[] = { + '\xC7', '\x72', '\xB7', '\x99', '\xA3', '\xFB', '\x0E', '\xDC', '\xC1', '\x39', '\xB7', '\xAF', '\xDE', '\x8F', '\x97', '\x50', '\x63', '\xAB', '\x12', + '\x0D', '\x17', '\x40', '\xB9', '\x74', '\x40', '\xA8', '\x1E', '\x07', '\x06', '\x69', '\xBF', '\x70', '\x65', '\x82', '\x15', '\x17', '\x0D', '\x6A', + '\xBB', '\x63', '\x62', '\xAE', '\x04', '\x4D', '\x01', '\x58', '\xBB', '\x11'}; thread_local EncryptedName tabHoverName(tabHoverSource); const std::string tabHover(tabHoverName.Text()); - const std::uint8_t tabNormalSource[] = { - 0xB5, 0xCA, 0xA1, 0x23, 0x8D, 0xC7, 0x1A, 0xB4, 0xB3, 0x81, 0xA1, 0x15, 0xF0, 0xB3, 0x83, 0x38, 0x11, 0x13, 0x04, 0xB7, 0x39, 0x7C, 0xAD, 0x1C, - 0x32, 0x10, 0x08, 0xBD, 0x28, 0x55, 0xAB, 0x18, 0x17, 0x3A, 0x03, 0xAD, 0x23, 0x56, 0xB1, 0x16, 0x07, 0x08, 0x00, 0xB5, 0x63, 0x6B, 0xB2, 0x09, - 0x75}; + const char tabNormalSource[] = { + '\xB5', '\xCA', '\xA1', '\x23', '\x8D', '\xC7', '\x1A', '\xB4', '\xB3', '\x81', '\xA1', '\x15', '\xF0', '\xB3', '\x83', '\x38', '\x11', '\x13', '\x04', + '\xB7', '\x39', '\x7C', '\xAD', '\x1C', '\x32', '\x10', '\x08', '\xBD', '\x28', '\x55', '\xAB', '\x18', '\x17', '\x3A', '\x03', '\xAD', '\x23', '\x56', + '\xB1', '\x16', '\x07', '\x08', '\x00', '\xB5', '\x63', '\x6B', '\xB2', '\x09', '\x75'}; thread_local EncryptedName tabNormalName(tabNormalSource); const std::string tabNormal(tabNormalName.Text()); tabs->SetImages(tabNormal, tabHover, tabPressed, tabDisabled); @@ -372,47 +385,48 @@ void CUIAdventureGuide::Slot15(int width, int height) { this->tabs->scrollBar->step = 20; { CUIListBox* tabs = this->tabs; - const std::uint8_t downImageSource[] = { - 0x9F, 0xD6, 0x61, 0x1D, 0x31, 0x03, 0x9A, 0x4A, 0x99, 0x9D, 0x61, 0x2B, 0x4C, 0x77, 0x03, 0xC6, 0x3B, 0x0F, 0xC4, 0x89, 0x85, 0xB8, 0x2D, 0xE2, - 0x18, 0x0C, 0xC8, 0x83, 0x94, 0x91, 0x2C, 0xE4, 0x2D, 0x16, 0xCD, 0x8B, 0xAE, 0xAC, 0x2D, 0xF5, 0x30, 0x0E, 0xFE, 0x83, 0x9E, 0xBA, 0x31, 0xA9, - 0x3D, 0x14, 0xD1, 0xE7}; + const char downImageSource[] = { + '\x9F', '\xD6', '\x61', '\x1D', '\x31', '\x03', '\x9A', '\x4A', '\x99', '\x9D', '\x61', '\x2B', '\x4C', '\x77', '\x03', '\xC6', '\x3B', '\x0F', '\xC4', + '\x89', '\x85', '\xB8', '\x2D', '\xE2', '\x18', '\x0C', '\xC8', '\x83', '\x94', '\x91', '\x2C', '\xE4', '\x2D', '\x16', '\xCD', '\x8B', '\xAE', '\xAC', + '\x2D', '\xF5', '\x30', '\x0E', '\xFE', '\x83', '\x9E', '\xBA', '\x31', '\xA9', '\x3D', '\x14', '\xD1', '\xE7'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0xA9, 0x2A, 0x9F, 0xDF, 0x77, 0xB9, 0xAE, 0x74, 0xAF, 0x61, 0x9F, 0xE9, 0x0A, 0xCD, 0x37, 0xF8, 0x0D, 0xF3, 0x3A, 0x4B, 0xC3, 0x02, 0x19, 0xDC, - 0x2E, 0xF0, 0x36, 0x41, 0xD2, 0x2B, 0x18, 0xDA, 0x1B, 0xEA, 0x33, 0x49, 0xE8, 0x16, 0x19, 0xCB, 0x06, 0xF2, 0x00, 0x50, 0xC7, 0x59, 0x09, 0xD4, - 0x19, 0x85}; + const char upImageSource[] = { + '\xA9', '\x2A', '\x9F', '\xDF', '\x77', '\xB9', '\xAE', '\x74', '\xAF', '\x61', '\x9F', '\xE9', '\x0A', '\xCD', '\x37', '\xF8', '\x0D', '\xF3', '\x3A', + '\x4B', '\xC3', '\x02', '\x19', '\xDC', '\x2E', '\xF0', '\x36', '\x41', '\xD2', '\x2B', '\x18', '\xDA', '\x1B', '\xEA', '\x33', '\x49', '\xE8', '\x16', + '\x19', '\xCB', '\x06', '\xF2', '\x00', '\x50', '\xC7', '\x59', '\x09', '\xD4', '\x19', '\x85'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); tabs->scrollBar->SetButtonImages(upImage, downImage); } { CUIListBox* tabs = this->tabs; - const std::uint8_t scrollBackgroundSource[] = { - 0x9B, 0x32, 0xE5, 0xD7, 0x47, 0xE3, 0xE8, 0xCA, 0x9D, 0x79, 0xE5, 0xE1, 0x3A, 0x97, 0x71, 0x46, 0x3F, 0xEB, 0x40, 0x43, 0xF3, 0x58, 0x5F, 0x62, - 0x1C, 0xE8, 0x4C, 0x49, 0xE2, 0x71, 0x5E, 0x64, 0x29, 0xF2, 0x49, 0x41, 0xD8, 0x4F, 0x4A, 0x58, 0x36, 0xF4, 0x41, 0x03, 0xE5, 0x40, 0x5D, 0x07}; + const char scrollBackgroundSource[] = { + '\x9B', '\x32', '\xE5', '\xD7', '\x47', '\xE3', '\xE8', '\xCA', '\x9D', '\x79', '\xE5', '\xE1', '\x3A', '\x97', '\x71', '\x46', '\x3F', '\xEB', '\x40', + '\x43', '\xF3', '\x58', '\x5F', '\x62', '\x1C', '\xE8', '\x4C', '\x49', '\xE2', '\x71', '\x5E', '\x64', '\x29', '\xF2', '\x49', '\x41', '\xD8', '\x4F', + '\x4A', '\x58', '\x36', '\xF4', '\x41', '\x03', '\xE5', '\x40', '\x5D', '\x07'}; thread_local EncryptedName scrollBackgroundName(scrollBackgroundSource); const std::string scrollBackground(scrollBackgroundName.Text()); tabs->scrollBar->SetBackground(scrollBackground); } { CUIListBox* tabs = this->tabs; - const std::uint8_t thumbBottomSource[] = { - 0x97, 0x40, 0x11, 0x4F, 0x6B, 0xB1, 0x38, 0x92, 0x91, 0x0B, 0x11, 0x79, 0x16, 0xC5, 0xA1, 0x1E, 0x33, 0x99, 0xB4, 0xDB, 0xDF, 0x0A, 0x8F, 0x3A, - 0x10, 0x9A, 0xB8, 0xD1, 0xCE, 0x23, 0x8E, 0x3C, 0x25, 0x80, 0xBD, 0xD9, 0xF4, 0x0B, 0x95, 0x2A, 0x3A, 0x8D, 0x8E, 0xD1, 0xC4, 0x08, 0x93, 0x71, - 0x35, 0x82, 0xA1, 0xB5}; + const char thumbBottomSource[] = { + '\x97', '\x40', '\x11', '\x4F', '\x6B', '\xB1', '\x38', '\x92', '\x91', '\x0B', '\x11', '\x79', '\x16', '\xC5', '\xA1', '\x1E', '\x33', '\x99', '\xB4', + '\xDB', '\xDF', '\x0A', '\x8F', '\x3A', '\x10', '\x9A', '\xB8', '\xD1', '\xCE', '\x23', '\x8E', '\x3C', '\x25', '\x80', '\xBD', '\xD9', '\xF4', '\x0B', + '\x95', '\x2A', '\x3A', '\x8D', '\x8E', '\xD1', '\xC4', '\x08', '\x93', '\x71', '\x35', '\x82', '\xA1', '\xB5'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0x11, 0xCE, 0x31, 0x73, 0xAF, 0x9F, 0x20, 0x1E, 0x17, 0x85, 0x31, 0x45, 0xD2, 0xEB, 0xB9, 0x92, 0xB5, 0x17, 0x94, 0xE7, 0x1B, 0x24, 0x97, 0xB6, - 0x96, 0x14, 0x98, 0xED, 0x0A, 0x0D, 0x96, 0xB0, 0xA3, 0x0E, 0x9D, 0xE5, 0x30, 0x25, 0x8D, 0xA6, 0xBC, 0x03, 0xAE, 0xE4, 0x06, 0x35, 0xCB, 0xB1, - 0xBC, 0x11, 0xF1}; + const char thumbMiddleSource[] = { + '\x11', '\xCE', '\x31', '\x73', '\xAF', '\x9F', '\x20', '\x1E', '\x17', '\x85', '\x31', '\x45', '\xD2', '\xEB', '\xB9', '\x92', '\xB5', '\x17', '\x94', + '\xE7', '\x1B', '\x24', '\x97', '\xB6', '\x96', '\x14', '\x98', '\xED', '\x0A', '\x0D', '\x96', '\xB0', '\xA3', '\x0E', '\x9D', '\xE5', '\x30', '\x25', + '\x8D', '\xA6', '\xBC', '\x03', '\xAE', '\xE4', '\x06', '\x35', '\xCB', '\xB1', '\xBC', '\x11', '\xF1'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x4D, 0xBC, 0xBF, 0xE9, 0xA1, 0x2B, 0xF0, 0x38, 0x4B, 0xF7, 0xBF, 0xDF, 0xDC, 0x5F, 0x69, 0xB4, 0xE9, 0x65, 0x1A, 0x7D, 0x15, 0x90, 0x47, 0x90, - 0xCA, 0x66, 0x16, 0x77, 0x04, 0xB9, 0x46, 0x96, 0xFF, 0x7C, 0x13, 0x7F, 0x3E, 0x91, 0x5D, 0x80, 0xE0, 0x71, 0x20, 0x66, 0x11, 0xCB, 0x57, 0x98, - 0xFD, 0x13}; + const char thumbTopSource[] = { + '\x4D', '\xBC', '\xBF', '\xE9', '\xA1', '\x2B', '\xF0', '\x38', '\x4B', '\xF7', '\xBF', '\xDF', '\xDC', '\x5F', '\x69', '\xB4', '\xE9', '\x65', '\x1A', + '\x7D', '\x15', '\x90', '\x47', '\x90', '\xCA', '\x66', '\x16', '\x77', '\x04', '\xB9', '\x46', '\x96', '\xFF', '\x7C', '\x13', '\x7F', '\x3E', '\x91', + '\x5D', '\x80', '\xE0', '\x71', '\x20', '\x66', '\x11', '\xCB', '\x57', '\x98', '\xFD', '\x13'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); tabs->scrollBar->SetThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -1090,7 +1104,7 @@ void CUICharacterInfo::Slot15(int width, int height) { this->level->SetText("", 0); this->level->SetFitText(0); this->level->SetAlign(0, 0); - const std::uint8_t levelFontSource[] = {0xFE, 0x70, 0x1B, 0x26, 0x66, 0x1D}; + const char levelFontSource[] = {'\xFE', '\x70', '\x1B', '\x26', '\x66', '\x1D'}; // GLOBAL: gl_25126 thread_local EncryptedName levelFont(levelFontSource); this->level->SetFont(std::string(levelFont.Text())); @@ -1107,7 +1121,7 @@ void CUICharacterInfo::Slot15(int width, int height) { this->jobLevel->SetText("", 0); this->jobLevel->SetFitText(0); this->jobLevel->SetAlign(0, 0); - const std::uint8_t jobLevelFontSource[] = {0x70, 0x32, 0xC1, 0x50, 0xD2, 0xE5}; + const char jobLevelFontSource[] = {'\x70', '\x32', '\xC1', '\x50', '\xD2', '\xE5'}; // GLOBAL: gl_25127 thread_local EncryptedName jobLevelFont(jobLevelFontSource); this->jobLevel->SetFont(std::string(jobLevelFont.Text())); @@ -1124,7 +1138,7 @@ void CUICharacterInfo::Slot15(int width, int height) { this->name->SetText("", 0); this->name->SetFitText(1); this->name->SetAlign(0, 0); - const std::uint8_t nameFontSource[] = {0x20, 0xDE, 0xFD, 0xCC, 0xCC, 0x3F}; + const char nameFontSource[] = {'\x20', '\xDE', '\xFD', '\xCC', '\xCC', '\x3F'}; // GLOBAL: gl_25128 thread_local EncryptedName nameFont(nameFontSource); this->name->SetFont(std::string(nameFont.Text())); @@ -1153,8 +1167,7 @@ void CUIItemInfo::Slot15(int width, int height) { this->nameText->SetAlign(0, 0); { CUIStaticText* name = this->nameText; - const std::uint8_t nameFontSource[] = { - 0xA2, 0x0E, 0x5F, 0x40, 0x20, 0x65}; + const char nameFontSource[] = {'\xA2', '\x0E', '\x5F', '\x40', '\x20', '\x65'}; thread_local EncryptedName nameFontName(nameFontSource); const std::string nameFont(nameFontName.Text()); name->SetFont(nameFont); @@ -1172,8 +1185,7 @@ void CUIItemInfo::Slot15(int width, int height) { description->Move(165, 26); description->SetTextOffset(0, 6); { - const std::uint8_t descriptionFontSource[] = { - 0xA4, 0xA0, 0x3F, 0x9E, 0xC8, 0x07}; + const char descriptionFontSource[] = {'\xA4', '\xA0', '\x3F', '\x9E', '\xC8', '\x07'}; thread_local EncryptedName descriptionFontName(descriptionFontSource); const std::string descriptionFont(descriptionFontName.Text()); description->SetFont(descriptionFont); @@ -1188,45 +1200,46 @@ void CUIItemInfo::Slot15(int width, int height) { description->SetScrollBarSize(8, 97); description->SetScrollStep(20); { - const std::uint8_t downImageSource[] = { - 0x3F, 0x4C, 0x9D, 0xF9, 0x67, 0x61, 0x66, 0xF2, 0x39, 0x07, 0x9D, 0xCF, 0x1A, 0x15, 0xFF, 0x7E, 0x9B, 0x95, 0x38, 0x6D, 0xD3, 0xDA, 0xD1, 0x5A, - 0xB8, 0x96, 0x34, 0x67, 0xC2, 0xF3, 0xD0, 0x5C, 0x8D, 0x8C, 0x31, 0x6F, 0xF8, 0xCE, 0xD1, 0x4D, 0x90, 0x94, 0x02, 0x67, 0xC8, 0xD8, 0xCD, 0x11, - 0x9D, 0x8E, 0x2D, 0x03}; + const char downImageSource[] = { + '\x3F', '\x4C', '\x9D', '\xF9', '\x67', '\x61', '\x66', '\xF2', '\x39', '\x07', '\x9D', '\xCF', '\x1A', '\x15', '\xFF', '\x7E', '\x9B', '\x95', '\x38', + '\x6D', '\xD3', '\xDA', '\xD1', '\x5A', '\xB8', '\x96', '\x34', '\x67', '\xC2', '\xF3', '\xD0', '\x5C', '\x8D', '\x8C', '\x31', '\x6F', '\xF8', '\xCE', + '\xD1', '\x4D', '\x90', '\x94', '\x02', '\x67', '\xC8', '\xD8', '\xCD', '\x11', '\x9D', '\x8E', '\x2D', '\x03'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0x99, 0x28, 0xC3, 0x87, 0x95, 0x05, 0xE2, 0x16, 0x9F, 0x63, 0xC3, 0xB1, 0xE8, 0x71, 0x7B, 0x9A, 0x3D, 0xF1, 0x66, 0x13, 0x21, 0xBE, 0x55, 0xBE, - 0x1E, 0xF2, 0x6A, 0x19, 0x30, 0x97, 0x54, 0xB8, 0x2B, 0xE8, 0x6F, 0x11, 0x0A, 0xAA, 0x55, 0xA9, 0x36, 0xF0, 0x5C, 0x08, 0x25, 0xE5, 0x45, 0xB6, - 0x29, 0x87}; + const char upImageSource[] = { + '\x99', '\x28', '\xC3', '\x87', '\x95', '\x05', '\xE2', '\x16', '\x9F', '\x63', '\xC3', '\xB1', '\xE8', '\x71', '\x7B', '\x9A', '\x3D', '\xF1', '\x66', + '\x13', '\x21', '\xBE', '\x55', '\xBE', '\x1E', '\xF2', '\x6A', '\x19', '\x30', '\x97', '\x54', '\xB8', '\x2B', '\xE8', '\x6F', '\x11', '\x0A', '\xAA', + '\x55', '\xA9', '\x36', '\xF0', '\x5C', '\x08', '\x25', '\xE5', '\x45', '\xB6', '\x29', '\x87'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); description->SetScrollBarButtonImages(upImage, downImage); } { - const std::uint8_t scrollBackgroundSource[] = { - 0x2F, 0x82, 0x97, 0xF7, 0x05, 0x1F, 0x26, 0x4A, 0x29, 0xC9, 0x97, 0xC1, 0x78, 0x6B, 0xBF, 0xC6, 0x8B, 0x5B, 0x32, 0x63, 0xB1, 0xA4, 0x91, 0xE2, - 0xA8, 0x58, 0x3E, 0x69, 0xA0, 0x8D, 0x90, 0xE4, 0x9D, 0x42, 0x3B, 0x61, 0x9A, 0xB3, 0x84, 0xD8, 0x82, 0x44, 0x33, 0x23, 0xA7, 0xBC, 0x93, 0x87}; + const char scrollBackgroundSource[] = { + '\x2F', '\x82', '\x97', '\xF7', '\x05', '\x1F', '\x26', '\x4A', '\x29', '\xC9', '\x97', '\xC1', '\x78', '\x6B', '\xBF', '\xC6', '\x8B', '\x5B', '\x32', + '\x63', '\xB1', '\xA4', '\x91', '\xE2', '\xA8', '\x58', '\x3E', '\x69', '\xA0', '\x8D', '\x90', '\xE4', '\x9D', '\x42', '\x3B', '\x61', '\x9A', '\xB3', + '\x84', '\xD8', '\x82', '\x44', '\x33', '\x23', '\xA7', '\xBC', '\x93', '\x87'}; thread_local EncryptedName scrollBackgroundName(scrollBackgroundSource); const std::string scrollBackground(scrollBackgroundName.Text()); description->SetScrollBarBackground(scrollBackground); } { - const std::uint8_t thumbBottomSource[] = { - 0x91, 0x5A, 0x0F, 0xB3, 0x3F, 0xD9, 0x44, 0x12, 0x97, 0x11, 0x0F, 0x85, 0x42, 0xAD, 0xDD, 0x9E, 0x35, 0x83, 0xAA, 0x27, 0x8B, 0x62, 0xF3, 0xBA, - 0x16, 0x80, 0xA6, 0x2D, 0x9A, 0x4B, 0xF2, 0xBC, 0x23, 0x9A, 0xA3, 0x25, 0xA0, 0x63, 0xE9, 0xAA, 0x3C, 0x97, 0x90, 0x2D, 0x90, 0x60, 0xEF, 0xF1, - 0x33, 0x98, 0xBF, 0x49}; + const char thumbBottomSource[] = { + '\x91', '\x5A', '\x0F', '\xB3', '\x3F', '\xD9', '\x44', '\x12', '\x97', '\x11', '\x0F', '\x85', '\x42', '\xAD', '\xDD', '\x9E', '\x35', '\x83', '\xAA', + '\x27', '\x8B', '\x62', '\xF3', '\xBA', '\x16', '\x80', '\xA6', '\x2D', '\x9A', '\x4B', '\xF2', '\xBC', '\x23', '\x9A', '\xA3', '\x25', '\xA0', '\x63', + '\xE9', '\xAA', '\x3C', '\x97', '\x90', '\x2D', '\x90', '\x60', '\xEF', '\xF1', '\x33', '\x98', '\xBF', '\x49'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xFD, 0xEE, 0x4B, 0x33, 0x39, 0xD5, 0x00, 0x60, 0xFB, 0xA5, 0x4B, 0x05, 0x44, 0xA1, 0x99, 0xEC, 0x59, 0x37, 0xEE, 0xA7, 0x8D, 0x6E, 0xB7, 0xC8, - 0x7A, 0x34, 0xE2, 0xAD, 0x9C, 0x47, 0xB6, 0xCE, 0x4F, 0x2E, 0xE7, 0xA5, 0xA6, 0x6F, 0xAD, 0xD8, 0x50, 0x23, 0xD4, 0xA4, 0x90, 0x7F, 0xEB, 0xCF, - 0x50, 0x31, 0x8B}; + const char thumbMiddleSource[] = { + '\xFD', '\xEE', '\x4B', '\x33', '\x39', '\xD5', '\x00', '\x60', '\xFB', '\xA5', '\x4B', '\x05', '\x44', '\xA1', '\x99', '\xEC', '\x59', '\x37', '\xEE', + '\xA7', '\x8D', '\x6E', '\xB7', '\xC8', '\x7A', '\x34', '\xE2', '\xAD', '\x9C', '\x47', '\xB6', '\xCE', '\x4F', '\x2E', '\xE7', '\xA5', '\xA6', '\x6F', + '\xAD', '\xD8', '\x50', '\x23', '\xD4', '\xA4', '\x90', '\x7F', '\xEB', '\xCF', '\x50', '\x31', '\x8B'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x4D, 0x12, 0x7B, 0x99, 0x77, 0xF7, 0x7E, 0x9C, 0x4B, 0x59, 0x7B, 0xAF, 0x0A, 0x83, 0xE7, 0x10, 0xE9, 0xCB, 0xDE, 0x0D, 0xC3, 0x4C, 0xC9, 0x34, - 0xCA, 0xC8, 0xD2, 0x07, 0xD2, 0x65, 0xC8, 0x32, 0xFF, 0xD2, 0xD7, 0x0F, 0xE8, 0x4D, 0xD3, 0x24, 0xE0, 0xDF, 0xE4, 0x16, 0xC7, 0x17, 0xD9, 0x3C, - 0xFD, 0xBD}; + const char thumbTopSource[] = { + '\x4D', '\x12', '\x7B', '\x99', '\x77', '\xF7', '\x7E', '\x9C', '\x4B', '\x59', '\x7B', '\xAF', '\x0A', '\x83', '\xE7', '\x10', '\xE9', '\xCB', '\xDE', + '\x0D', '\xC3', '\x4C', '\xC9', '\x34', '\xCA', '\xC8', '\xD2', '\x07', '\xD2', '\x65', '\xC8', '\x32', '\xFF', '\xD2', '\xD7', '\x0F', '\xE8', '\x4D', + '\xD3', '\x24', '\xE0', '\xDF', '\xE4', '\x16', '\xC7', '\x17', '\xD9', '\x3C', '\xFD', '\xBD'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); description->SetScrollBarThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -1239,8 +1252,7 @@ void CUIItemInfo::Slot15(int width, int height) { options->Move(338, 26); options->SetTextOffset(0, 8); { - const std::uint8_t optionFontSource[] = { - 0x0E, 0x18, 0x13, 0x8A, 0xAA, 0x01}; + const char optionFontSource[] = {'\x0E', '\x18', '\x13', '\x8A', '\xAA', '\x01'}; thread_local EncryptedName optionFontName(optionFontSource); const std::string optionFont(optionFontName.Text()); options->SetFont(optionFont); @@ -1255,45 +1267,46 @@ void CUIItemInfo::Slot15(int width, int height) { options->SetScrollBarSize(8, 90); options->SetScrollStep(20); { - const std::uint8_t downImageSource[] = { - 0x9B, 0x18, 0xA1, 0xA3, 0x8F, 0x9F, 0xD0, 0x3A, 0x9D, 0x53, 0xA1, 0x95, 0xF2, 0xEB, 0x49, 0xB6, 0x3F, 0xC1, 0x04, 0x37, 0x3B, 0x24, 0x67, 0x92, - 0x1C, 0xC2, 0x08, 0x3D, 0x2A, 0x0D, 0x66, 0x94, 0x29, 0xD8, 0x0D, 0x35, 0x10, 0x30, 0x67, 0x85, 0x34, 0xC0, 0x3E, 0x3D, 0x20, 0x26, 0x7B, 0xD9, - 0x39, 0xDA, 0x11, 0x59}; + const char downImageSource[] = { + '\x9B', '\x18', '\xA1', '\xA3', '\x8F', '\x9F', '\xD0', '\x3A', '\x9D', '\x53', '\xA1', '\x95', '\xF2', '\xEB', '\x49', '\xB6', '\x3F', '\xC1', '\x04', + '\x37', '\x3B', '\x24', '\x67', '\x92', '\x1C', '\xC2', '\x08', '\x3D', '\x2A', '\x0D', '\x66', '\x94', '\x29', '\xD8', '\x0D', '\x35', '\x10', '\x30', + '\x67', '\x85', '\x34', '\xC0', '\x3E', '\x3D', '\x20', '\x26', '\x7B', '\xD9', '\x39', '\xDA', '\x11', '\x59'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0xB1, 0x2C, 0xAB, 0xF1, 0xD1, 0xC1, 0x98, 0xB0, 0xB7, 0x67, 0xAB, 0xC7, 0xAC, 0xB5, 0x01, 0x3C, 0x15, 0xF5, 0x0E, 0x65, 0x65, 0x7A, 0x2F, 0x18, - 0x36, 0xF6, 0x02, 0x6F, 0x74, 0x53, 0x2E, 0x1E, 0x03, 0xEC, 0x07, 0x67, 0x4E, 0x6E, 0x2F, 0x0F, 0x1E, 0xF4, 0x34, 0x7E, 0x61, 0x21, 0x3F, 0x10, - 0x01, 0x83}; + const char upImageSource[] = { + '\xB1', '\x2C', '\xAB', '\xF1', '\xD1', '\xC1', '\x98', '\xB0', '\xB7', '\x67', '\xAB', '\xC7', '\xAC', '\xB5', '\x01', '\x3C', '\x15', '\xF5', '\x0E', + '\x65', '\x65', '\x7A', '\x2F', '\x18', '\x36', '\xF6', '\x02', '\x6F', '\x74', '\x53', '\x2E', '\x1E', '\x03', '\xEC', '\x07', '\x67', '\x4E', '\x6E', + '\x2F', '\x0F', '\x1E', '\xF4', '\x34', '\x7E', '\x61', '\x21', '\x3F', '\x10', '\x01', '\x83'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); options->SetScrollBarButtonImages(upImage, downImage); } { - const std::uint8_t scrollBackgroundSource[] = { - 0x59, 0x96, 0x3D, 0xCB, 0x95, 0x75, 0x54, 0x8C, 0x5F, 0xDD, 0x3D, 0xFD, 0xE8, 0x01, 0xCD, 0x00, 0xFD, 0x4F, 0x98, 0x5F, 0x21, 0xCE, 0xE3, 0x24, - 0xDE, 0x4C, 0x94, 0x55, 0x30, 0xE7, 0xE2, 0x22, 0xEB, 0x56, 0x91, 0x5D, 0x0A, 0xD9, 0xF6, 0x1E, 0xF4, 0x50, 0x99, 0x1F, 0x37, 0xD6, 0xE1, 0x41}; + const char scrollBackgroundSource[] = { + '\x59', '\x96', '\x3D', '\xCB', '\x95', '\x75', '\x54', '\x8C', '\x5F', '\xDD', '\x3D', '\xFD', '\xE8', '\x01', '\xCD', '\x00', '\xFD', '\x4F', '\x98', + '\x5F', '\x21', '\xCE', '\xE3', '\x24', '\xDE', '\x4C', '\x94', '\x55', '\x30', '\xE7', '\xE2', '\x22', '\xEB', '\x56', '\x91', '\x5D', '\x0A', '\xD9', + '\xF6', '\x1E', '\xF4', '\x50', '\x99', '\x1F', '\x37', '\xD6', '\xE1', '\x41'}; thread_local EncryptedName scrollBackgroundName(scrollBackgroundSource); const std::string scrollBackground(scrollBackgroundName.Text()); options->SetScrollBarBackground(scrollBackground); } { - const std::uint8_t thumbBottomSource[] = { - 0xAD, 0x10, 0x15, 0xDD, 0x2B, 0x87, 0x62, 0x1A, 0xAB, 0x5B, 0x15, 0xEB, 0x56, 0xF3, 0xFB, 0x96, 0x09, 0xC9, 0xB0, 0x49, 0x9F, 0x3C, 0xD5, 0xB2, - 0x2A, 0xCA, 0xBC, 0x43, 0x8E, 0x15, 0xD4, 0xB4, 0x1F, 0xD0, 0xB9, 0x4B, 0xB4, 0x3D, 0xCF, 0xA2, 0x00, 0xDD, 0x8A, 0x43, 0x84, 0x3E, 0xC9, 0xF9, - 0x0F, 0xD2, 0xA5, 0x27}; + const char thumbBottomSource[] = { + '\xAD', '\x10', '\x15', '\xDD', '\x2B', '\x87', '\x62', '\x1A', '\xAB', '\x5B', '\x15', '\xEB', '\x56', '\xF3', '\xFB', '\x96', '\x09', '\xC9', '\xB0', + '\x49', '\x9F', '\x3C', '\xD5', '\xB2', '\x2A', '\xCA', '\xBC', '\x43', '\x8E', '\x15', '\xD4', '\xB4', '\x1F', '\xD0', '\xB9', '\x4B', '\xB4', '\x3D', + '\xCF', '\xA2', '\x00', '\xDD', '\x8A', '\x43', '\x84', '\x3E', '\xC9', '\xF9', '\x0F', '\xD2', '\xA5', '\x27'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0x6F, 0xA6, 0xC9, 0x1D, 0x07, 0x07, 0xAC, 0x58, 0x69, 0xED, 0xC9, 0x2B, 0x7A, 0x73, 0x35, 0xD4, 0xCB, 0x7F, 0x6C, 0x89, 0xB3, 0xBC, 0x1B, 0xF0, - 0xE8, 0x7C, 0x60, 0x83, 0xA2, 0x95, 0x1A, 0xF6, 0xDD, 0x66, 0x65, 0x8B, 0x98, 0xBD, 0x01, 0xE0, 0xC2, 0x6B, 0x56, 0x8A, 0xAE, 0xAD, 0x47, 0xF7, - 0xC2, 0x79, 0x09}; + const char thumbMiddleSource[] = { + '\x6F', '\xA6', '\xC9', '\x1D', '\x07', '\x07', '\xAC', '\x58', '\x69', '\xED', '\xC9', '\x2B', '\x7A', '\x73', '\x35', '\xD4', '\xCB', '\x7F', '\x6C', + '\x89', '\xB3', '\xBC', '\x1B', '\xF0', '\xE8', '\x7C', '\x60', '\x83', '\xA2', '\x95', '\x1A', '\xF6', '\xDD', '\x66', '\x65', '\x8B', '\x98', '\xBD', + '\x01', '\xE0', '\xC2', '\x6B', '\x56', '\x8A', '\xAE', '\xAD', '\x47', '\xF7', '\xC2', '\x79', '\x09'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x13, 0x96, 0xAF, 0xEB, 0x69, 0xD1, 0x58, 0x7C, 0x15, 0xDD, 0xAF, 0xDD, 0x14, 0xA5, 0xC1, 0xF0, 0xB7, 0x4F, 0x0A, 0x7F, 0xDD, 0x6A, 0xEF, 0xD4, - 0x94, 0x4C, 0x06, 0x75, 0xCC, 0x43, 0xEE, 0xD2, 0xA1, 0x56, 0x03, 0x7D, 0xF6, 0x6B, 0xF5, 0xC4, 0xBE, 0x5B, 0x30, 0x64, 0xD9, 0x31, 0xFF, 0xDC, - 0xA3, 0x39}; + const char thumbTopSource[] = { + '\x13', '\x96', '\xAF', '\xEB', '\x69', '\xD1', '\x58', '\x7C', '\x15', '\xDD', '\xAF', '\xDD', '\x14', '\xA5', '\xC1', '\xF0', '\xB7', '\x4F', '\x0A', + '\x7F', '\xDD', '\x6A', '\xEF', '\xD4', '\x94', '\x4C', '\x06', '\x75', '\xCC', '\x43', '\xEE', '\xD2', '\xA1', '\x56', '\x03', '\x7D', '\xF6', '\x6B', + '\xF5', '\xC4', '\xBE', '\x5B', '\x30', '\x64', '\xD9', '\x31', '\xFF', '\xDC', '\xA3', '\x39'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); options->SetScrollBarThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -1306,8 +1319,7 @@ void CUIItemInfo::Slot15(int width, int height) { sources->Move(480, 5); sources->SetTextOffset(0, 6); { - const std::uint8_t sourceFontSource[] = { - 0x1E, 0x78, 0xA7, 0xC6, 0x10, 0x63}; + const char sourceFontSource[] = {'\x1E', '\x78', '\xA7', '\xC6', '\x10', '\x63'}; thread_local EncryptedName sourceFontName(sourceFontSource); const std::string sourceFont(sourceFontName.Text()); sources->SetFont(sourceFont); @@ -1322,45 +1334,46 @@ void CUIItemInfo::Slot15(int width, int height) { sources->SetScrollBarSize(8, 118); sources->SetScrollStep(20); { - const std::uint8_t downImageSource[] = { - 0x01, 0x36, 0x0D, 0x1F, 0x41, 0xE3, 0x80, 0x14, 0x07, 0x7D, 0x0D, 0x29, 0x3C, 0x97, 0x19, 0x98, 0xA5, 0xEF, 0xA8, 0x8B, 0xF5, 0x58, 0x37, 0xBC, - 0x86, 0xEC, 0xA4, 0x81, 0xE4, 0x71, 0x36, 0xBA, 0xB3, 0xF6, 0xA1, 0x89, 0xDE, 0x4C, 0x37, 0xAB, 0xAE, 0xEE, 0x92, 0x81, 0xEE, 0x5A, 0x2B, 0xF7, - 0xA3, 0xF4, 0xBD, 0xE5}; + const char downImageSource[] = { + '\x01', '\x36', '\x0D', '\x1F', '\x41', '\xE3', '\x80', '\x14', '\x07', '\x7D', '\x0D', '\x29', '\x3C', '\x97', '\x19', '\x98', '\xA5', '\xEF', '\xA8', + '\x8B', '\xF5', '\x58', '\x37', '\xBC', '\x86', '\xEC', '\xA4', '\x81', '\xE4', '\x71', '\x36', '\xBA', '\xB3', '\xF6', '\xA1', '\x89', '\xDE', '\x4C', + '\x37', '\xAB', '\xAE', '\xEE', '\x92', '\x81', '\xEE', '\x5A', '\x2B', '\xF7', '\xA3', '\xF4', '\xBD', '\xE5'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0x95, 0x94, 0x41, 0x0D, 0x8D, 0x25, 0x68, 0x60, 0x93, 0xDF, 0x41, 0x3B, 0xF0, 0x51, 0xF1, 0xEC, 0x31, 0x4D, 0xE4, 0x99, 0x39, 0x9E, 0xDF, 0xC8, - 0x12, 0x4E, 0xE8, 0x93, 0x28, 0xB7, 0xDE, 0xCE, 0x27, 0x54, 0xED, 0x9B, 0x12, 0x8A, 0xDF, 0xDF, 0x3A, 0x4C, 0xDE, 0x82, 0x3D, 0xC5, 0xCF, 0xC0, - 0x25, 0x3B}; + const char upImageSource[] = { + '\x95', '\x94', '\x41', '\x0D', '\x8D', '\x25', '\x68', '\x60', '\x93', '\xDF', '\x41', '\x3B', '\xF0', '\x51', '\xF1', '\xEC', '\x31', '\x4D', '\xE4', + '\x99', '\x39', '\x9E', '\xDF', '\xC8', '\x12', '\x4E', '\xE8', '\x93', '\x28', '\xB7', '\xDE', '\xCE', '\x27', '\x54', '\xED', '\x9B', '\x12', '\x8A', + '\xDF', '\xDF', '\x3A', '\x4C', '\xDE', '\x82', '\x3D', '\xC5', '\xCF', '\xC0', '\x25', '\x3B'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); sources->SetScrollBarButtonImages(upImage, downImage); } { - const std::uint8_t scrollBackgroundSource[] = { - 0x4D, 0x2E, 0xD1, 0x09, 0x73, 0x67, 0xAC, 0x30, 0x4B, 0x65, 0xD1, 0x3F, 0x0E, 0x13, 0x35, 0xBC, 0xE9, 0xF7, 0x74, 0x9D, 0xC7, 0xDC, 0x1B, 0x98, - 0xCA, 0xF4, 0x78, 0x97, 0xD6, 0xF5, 0x1A, 0x9E, 0xFF, 0xEE, 0x7D, 0x9F, 0xEC, 0xCB, 0x0E, 0xA2, 0xE0, 0xE8, 0x75, 0xDD, 0xD1, 0xC4, 0x19, 0xFD}; + const char scrollBackgroundSource[] = { + '\x4D', '\x2E', '\xD1', '\x09', '\x73', '\x67', '\xAC', '\x30', '\x4B', '\x65', '\xD1', '\x3F', '\x0E', '\x13', '\x35', '\xBC', '\xE9', '\xF7', '\x74', + '\x9D', '\xC7', '\xDC', '\x1B', '\x98', '\xCA', '\xF4', '\x78', '\x97', '\xD6', '\xF5', '\x1A', '\x9E', '\xFF', '\xEE', '\x7D', '\x9F', '\xEC', '\xCB', + '\x0E', '\xA2', '\xE0', '\xE8', '\x75', '\xDD', '\xD1', '\xC4', '\x19', '\xFD'}; thread_local EncryptedName scrollBackgroundName(scrollBackgroundSource); const std::string scrollBackground(scrollBackgroundName.Text()); sources->SetScrollBarBackground(scrollBackground); } { - const std::uint8_t thumbBottomSource[] = { - 0x53, 0xDA, 0x1F, 0x15, 0x8D, 0xED, 0xCA, 0x56, 0x55, 0x91, 0x1F, 0x23, 0xF0, 0x99, 0x53, 0xDA, 0xF7, 0x03, 0xBA, 0x81, 0x39, 0x56, 0x7D, 0xFE, - 0xD4, 0x00, 0xB6, 0x8B, 0x28, 0x7F, 0x7C, 0xF8, 0xE1, 0x1A, 0xB3, 0x83, 0x12, 0x57, 0x67, 0xEE, 0xFE, 0x17, 0x80, 0x8B, 0x22, 0x54, 0x61, 0xB5, - 0xF1, 0x18, 0xAF, 0xEF}; + const char thumbBottomSource[] = { + '\x53', '\xDA', '\x1F', '\x15', '\x8D', '\xED', '\xCA', '\x56', '\x55', '\x91', '\x1F', '\x23', '\xF0', '\x99', '\x53', '\xDA', '\xF7', '\x03', '\xBA', + '\x81', '\x39', '\x56', '\x7D', '\xFE', '\xD4', '\x00', '\xB6', '\x8B', '\x28', '\x7F', '\x7C', '\xF8', '\xE1', '\x1A', '\xB3', '\x83', '\x12', '\x57', + '\x67', '\xEE', '\xFE', '\x17', '\x80', '\x8B', '\x22', '\x54', '\x61', '\xB5', '\xF1', '\x18', '\xAF', '\xEF'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xCD, 0xCC, 0x4D, 0xF3, 0x85, 0x9D, 0x4A, 0x14, 0xCB, 0x87, 0x4D, 0xC5, 0xF8, 0xE9, 0xD3, 0x98, 0x69, 0x15, 0xE8, 0x67, 0x31, 0x26, 0xFD, 0xBC, - 0x4A, 0x16, 0xE4, 0x6D, 0x20, 0x0F, 0xFC, 0xBA, 0x7F, 0x0C, 0xE1, 0x65, 0x1A, 0x27, 0xE7, 0xAC, 0x60, 0x01, 0xD2, 0x64, 0x2C, 0x37, 0xA1, 0xBB, - 0x60, 0x13, 0x8D}; + const char thumbMiddleSource[] = { + '\xCD', '\xCC', '\x4D', '\xF3', '\x85', '\x9D', '\x4A', '\x14', '\xCB', '\x87', '\x4D', '\xC5', '\xF8', '\xE9', '\xD3', '\x98', '\x69', '\x15', '\xE8', + '\x67', '\x31', '\x26', '\xFD', '\xBC', '\x4A', '\x16', '\xE4', '\x6D', '\x20', '\x0F', '\xFC', '\xBA', '\x7F', '\x0C', '\xE1', '\x65', '\x1A', '\x27', + '\xE7', '\xAC', '\x60', '\x01', '\xD2', '\x64', '\x2C', '\x37', '\xA1', '\xBB', '\x60', '\x13', '\x8D'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0xEB, 0xB0, 0x29, 0x51, 0x01, 0x31, 0xE8, 0xB2, 0xED, 0xFB, 0x29, 0x67, 0x7C, 0x45, 0x71, 0x3E, 0x4F, 0x69, 0x8C, 0xC5, 0xB5, 0x8A, 0x5F, 0x1A, - 0x6C, 0x6A, 0x80, 0xCF, 0xA4, 0xA3, 0x5E, 0x1C, 0x59, 0x70, 0x85, 0xC7, 0x9E, 0x8B, 0x45, 0x0A, 0x46, 0x7D, 0xB6, 0xDE, 0xB1, 0xD1, 0x4F, 0x12, - 0x5B, 0x1F}; + const char thumbTopSource[] = { + '\xEB', '\xB0', '\x29', '\x51', '\x01', '\x31', '\xE8', '\xB2', '\xED', '\xFB', '\x29', '\x67', '\x7C', '\x45', '\x71', '\x3E', '\x4F', '\x69', '\x8C', + '\xC5', '\xB5', '\x8A', '\x5F', '\x1A', '\x6C', '\x6A', '\x80', '\xCF', '\xA4', '\xA3', '\x5E', '\x1C', '\x59', '\x70', '\x85', '\xC7', '\x9E', '\x8B', + '\x45', '\x0A', '\x46', '\x7D', '\xB6', '\xDE', '\xB1', '\xD1', '\x4F', '\x12', '\x5B', '\x1F'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); sources->SetScrollBarThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -1379,8 +1392,7 @@ void CUIMonsterInfo::Slot15(int width, int height) { this->unknown_00E8->SetAlign(0, 0); { CUIStaticText* name = this->unknown_00E8; - const std::uint8_t nameFontSource[] = { - 0x82, 0x58, 0x47, 0x56, 0xE4, 0x1D}; + const char nameFontSource[] = {'\x82', '\x58', '\x47', '\x56', '\xE4', '\x1D'}; thread_local EncryptedName nameFontName(nameFontSource); const std::string nameFont(nameFontName.Text()); name->SetFont(nameFont); @@ -1398,8 +1410,7 @@ void CUIMonsterInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00EC)->SetTextOffset(0, 6); { CUITextViewer* details = reinterpret_cast(this->unknown_00EC); - const std::uint8_t detailsFontSource[] = { - 0x1C, 0x26, 0x33, 0xB4, 0xEA, 0x9F}; + const char detailsFontSource[] = {'\x1C', '\x26', '\x33', '\xB4', '\xEA', '\x9F'}; thread_local EncryptedName detailsFontName(detailsFontSource); const std::string detailsFont(detailsFontName.Text()); details->SetFont(detailsFont); @@ -1415,47 +1426,48 @@ void CUIMonsterInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00EC)->SetScrollStep(20); { CUITextViewer* details = reinterpret_cast(this->unknown_00EC); - const std::uint8_t downImageSource[] = { - 0x0D, 0xAC, 0x0D, 0x81, 0x57, 0xF5, 0xD6, 0xFE, 0x0B, 0xE7, 0x0D, 0xB7, 0x2A, 0x81, 0x4F, 0x72, 0xA9, 0x75, 0xA8, 0x15, 0xE3, 0x4E, 0x61, 0x56, - 0x8A, 0x76, 0xA4, 0x1F, 0xF2, 0x67, 0x60, 0x50, 0xBF, 0x6C, 0xA1, 0x17, 0xC8, 0x5A, 0x61, 0x41, 0xA2, 0x74, 0x92, 0x1F, 0xF8, 0x4C, 0x7D, 0x1D, - 0xAF, 0x6E, 0xBD, 0x7B}; + const char downImageSource[] = { + '\x0D', '\xAC', '\x0D', '\x81', '\x57', '\xF5', '\xD6', '\xFE', '\x0B', '\xE7', '\x0D', '\xB7', '\x2A', '\x81', '\x4F', '\x72', '\xA9', '\x75', '\xA8', + '\x15', '\xE3', '\x4E', '\x61', '\x56', '\x8A', '\x76', '\xA4', '\x1F', '\xF2', '\x67', '\x60', '\x50', '\xBF', '\x6C', '\xA1', '\x17', '\xC8', '\x5A', + '\x61', '\x41', '\xA2', '\x74', '\x92', '\x1F', '\xF8', '\x4C', '\x7D', '\x1D', '\xAF', '\x6E', '\xBD', '\x7B'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0xB7, 0x38, 0x47, 0xE7, 0xE3, 0x9D, 0x24, 0xA2, 0xB1, 0x73, 0x47, 0xD1, 0x9E, 0xE9, 0xBD, 0x2E, 0x13, 0xE1, 0xE2, 0x73, 0x57, 0x26, 0x93, 0x0A, - 0x30, 0xE2, 0xEE, 0x79, 0x46, 0x0F, 0x92, 0x0C, 0x05, 0xF8, 0xEB, 0x71, 0x7C, 0x32, 0x93, 0x1D, 0x18, 0xE0, 0xD8, 0x68, 0x53, 0x7D, 0x83, 0x02, - 0x07, 0x97}; + const char upImageSource[] = { + '\xB7', '\x38', '\x47', '\xE7', '\xE3', '\x9D', '\x24', '\xA2', '\xB1', '\x73', '\x47', '\xD1', '\x9E', '\xE9', '\xBD', '\x2E', '\x13', '\xE1', '\xE2', + '\x73', '\x57', '\x26', '\x93', '\x0A', '\x30', '\xE2', '\xEE', '\x79', '\x46', '\x0F', '\x92', '\x0C', '\x05', '\xF8', '\xEB', '\x71', '\x7C', '\x32', + '\x93', '\x1D', '\x18', '\xE0', '\xD8', '\x68', '\x53', '\x7D', '\x83', '\x02', '\x07', '\x97'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); details->SetScrollBarButtonImages(upImage, downImage); } { CUITextViewer* details = reinterpret_cast(this->unknown_00EC); - const std::uint8_t scrollBackgroundSource[] = { - 0x11, 0xF4, 0x57, 0x1F, 0xF9, 0x49, 0x2E, 0xE2, 0x17, 0xBF, 0x57, 0x29, 0x84, 0x3D, 0xB7, 0x6E, 0xB5, 0x2D, 0xF2, 0x8B, 0x4D, 0xF2, 0x99, 0x4A, - 0x96, 0x2E, 0xFE, 0x81, 0x5C, 0xDB, 0x98, 0x4C, 0xA3, 0x34, 0xFB, 0x89, 0x66, 0xE5, 0x8C, 0x70, 0xBC, 0x32, 0xF3, 0xCB, 0x5B, 0xEA, 0x9B, 0x2F}; + const char scrollBackgroundSource[] = { + '\x11', '\xF4', '\x57', '\x1F', '\xF9', '\x49', '\x2E', '\xE2', '\x17', '\xBF', '\x57', '\x29', '\x84', '\x3D', '\xB7', '\x6E', '\xB5', '\x2D', '\xF2', + '\x8B', '\x4D', '\xF2', '\x99', '\x4A', '\x96', '\x2E', '\xFE', '\x81', '\x5C', '\xDB', '\x98', '\x4C', '\xA3', '\x34', '\xFB', '\x89', '\x66', '\xE5', + '\x8C', '\x70', '\xBC', '\x32', '\xF3', '\xCB', '\x5B', '\xEA', '\x9B', '\x2F'}; thread_local EncryptedName scrollBackgroundName(scrollBackgroundSource); const std::string scrollBackground(scrollBackgroundName.Text()); details->SetScrollBarBackground(scrollBackground); } { CUITextViewer* details = reinterpret_cast(this->unknown_00EC); - const std::uint8_t thumbBottomSource[] = { - 0xD7, 0xFE, 0x21, 0xBB, 0xF9, 0x0D, 0x46, 0x4A, 0xD1, 0xB5, 0x21, 0x8D, 0x84, 0x79, 0xDF, 0xC6, 0x73, 0x27, 0x84, 0x2F, 0x4D, 0xB6, 0xF1, 0xE2, - 0x50, 0x24, 0x88, 0x25, 0x5C, 0x9F, 0xF0, 0xE4, 0x65, 0x3E, 0x8D, 0x2D, 0x66, 0xB7, 0xEB, 0xF2, 0x7A, 0x33, 0xBE, 0x25, 0x56, 0xB4, 0xED, 0xA9, - 0x75, 0x3C, 0x91, 0x41}; + const char thumbBottomSource[] = { + '\xD7', '\xFE', '\x21', '\xBB', '\xF9', '\x0D', '\x46', '\x4A', '\xD1', '\xB5', '\x21', '\x8D', '\x84', '\x79', '\xDF', '\xC6', '\x73', '\x27', '\x84', + '\x2F', '\x4D', '\xB6', '\xF1', '\xE2', '\x50', '\x24', '\x88', '\x25', '\x5C', '\x9F', '\xF0', '\xE4', '\x65', '\x3E', '\x8D', '\x2D', '\x66', '\xB7', + '\xEB', '\xF2', '\x7A', '\x33', '\xBE', '\x25', '\x56', '\xB4', '\xED', '\xA9', '\x75', '\x3C', '\x91', '\x41'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xEF, 0x78, 0x85, 0xDF, 0xF9, 0x65, 0xE8, 0x6C, 0xE9, 0x33, 0x85, 0xE9, 0x84, 0x11, 0x71, 0xE0, 0x4B, 0xA1, 0x20, 0x4B, 0x4D, 0xDE, 0x5F, 0xC4, - 0x68, 0xA2, 0x2C, 0x41, 0x5C, 0xF7, 0x5E, 0xC2, 0x5D, 0xB8, 0x29, 0x49, 0x66, 0xDF, 0x45, 0xD4, 0x42, 0xB5, 0x1A, 0x48, 0x50, 0xCF, 0x03, 0xC3, - 0x42, 0xA7, 0x45}; + const char thumbMiddleSource[] = { + '\xEF', '\x78', '\x85', '\xDF', '\xF9', '\x65', '\xE8', '\x6C', '\xE9', '\x33', '\x85', '\xE9', '\x84', '\x11', '\x71', '\xE0', '\x4B', '\xA1', '\x20', + '\x4B', '\x4D', '\xDE', '\x5F', '\xC4', '\x68', '\xA2', '\x2C', '\x41', '\x5C', '\xF7', '\x5E', '\xC2', '\x5D', '\xB8', '\x29', '\x49', '\x66', '\xDF', + '\x45', '\xD4', '\x42', '\xB5', '\x1A', '\x48', '\x50', '\xCF', '\x03', '\xC3', '\x42', '\xA7', '\x45'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0xB5, 0x94, 0xC3, 0xD5, 0xD3, 0x0F, 0x64, 0xA6, 0xB3, 0xDF, 0xC3, 0xE3, 0xAE, 0x7B, 0xFD, 0x2A, 0x11, 0x4D, 0x66, 0x41, 0x67, 0xB4, 0xD3, 0x0E, - 0x32, 0x4E, 0x6A, 0x4B, 0x76, 0x9D, 0xD2, 0x08, 0x07, 0x54, 0x6F, 0x43, 0x4C, 0xB5, 0xC9, 0x1E, 0x18, 0x59, 0x5C, 0x5A, 0x63, 0xEF, 0xC3, 0x06, - 0x05, 0x3B}; + const char thumbTopSource[] = { + '\xB5', '\x94', '\xC3', '\xD5', '\xD3', '\x0F', '\x64', '\xA6', '\xB3', '\xDF', '\xC3', '\xE3', '\xAE', '\x7B', '\xFD', '\x2A', '\x11', '\x4D', '\x66', + '\x41', '\x67', '\xB4', '\xD3', '\x0E', '\x32', '\x4E', '\x6A', '\x4B', '\x76', '\x9D', '\xD2', '\x08', '\x07', '\x54', '\x6F', '\x43', '\x4C', '\xB5', + '\xC9', '\x1E', '\x18', '\x59', '\x5C', '\x5A', '\x63', '\xEF', '\xC3', '\x06', '\x05', '\x3B'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); details->SetScrollBarThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -1468,8 +1480,7 @@ void CUIMonsterInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00F0)->SetTextOffset(0, 6); { CUITextViewer* values = reinterpret_cast(this->unknown_00F0); - const std::uint8_t valuesFontSource[] = { - 0xD8, 0xA8, 0xEF, 0x76, 0x1A, 0x45}; + const char valuesFontSource[] = {'\xD8', '\xA8', '\xEF', '\x76', '\x1A', '\x45'}; thread_local EncryptedName valuesFontName(valuesFontSource); const std::string valuesFont(valuesFontName.Text()); values->SetFont(valuesFont); @@ -1485,47 +1496,48 @@ void CUIMonsterInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00F0)->SetScrollStep(20); { CUITextViewer* values = reinterpret_cast(this->unknown_00F0); - const std::uint8_t downImageSource[] = { - 0x17, 0x3A, 0xDF, 0x61, 0x91, 0x8B, 0x42, 0xC6, 0x11, 0x71, 0xDF, 0x57, 0xEC, 0xFF, 0xDB, 0x4A, 0xB3, 0xE3, 0x7A, 0xF5, 0x25, 0x30, 0xF5, 0x6E, - 0x90, 0xE0, 0x76, 0xFF, 0x34, 0x19, 0xF4, 0x68, 0xA5, 0xFA, 0x73, 0xF7, 0x0E, 0x24, 0xF5, 0x79, 0xB8, 0xE2, 0x40, 0xFF, 0x3E, 0x32, 0xE9, 0x25, - 0xB5, 0xF8, 0x6F, 0x9B}; + const char downImageSource[] = { + '\x17', '\x3A', '\xDF', '\x61', '\x91', '\x8B', '\x42', '\xC6', '\x11', '\x71', '\xDF', '\x57', '\xEC', '\xFF', '\xDB', '\x4A', '\xB3', '\xE3', '\x7A', + '\xF5', '\x25', '\x30', '\xF5', '\x6E', '\x90', '\xE0', '\x76', '\xFF', '\x34', '\x19', '\xF4', '\x68', '\xA5', '\xFA', '\x73', '\xF7', '\x0E', '\x24', + '\xF5', '\x79', '\xB8', '\xE2', '\x40', '\xFF', '\x3E', '\x32', '\xE9', '\x25', '\xB5', '\xF8', '\x6F', '\x9B'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0x4F, 0xF6, 0xA1, 0x11, 0x75, 0xD7, 0xC6, 0x0A, 0x49, 0xBD, 0xA1, 0x27, 0x08, 0xA3, 0x5F, 0x86, 0xEB, 0x2F, 0x04, 0x85, 0xC1, 0x6C, 0x71, 0xA2, - 0xC8, 0x2C, 0x08, 0x8F, 0xD0, 0x45, 0x70, 0xA4, 0xFD, 0x36, 0x0D, 0x87, 0xEA, 0x78, 0x71, 0xB5, 0xE0, 0x2E, 0x3E, 0x9E, 0xC5, 0x37, 0x61, 0xAA, - 0xFF, 0x59}; + const char upImageSource[] = { + '\x4F', '\xF6', '\xA1', '\x11', '\x75', '\xD7', '\xC6', '\x0A', '\x49', '\xBD', '\xA1', '\x27', '\x08', '\xA3', '\x5F', '\x86', '\xEB', '\x2F', '\x04', + '\x85', '\xC1', '\x6C', '\x71', '\xA2', '\xC8', '\x2C', '\x08', '\x8F', '\xD0', '\x45', '\x70', '\xA4', '\xFD', '\x36', '\x0D', '\x87', '\xEA', '\x78', + '\x71', '\xB5', '\xE0', '\x2E', '\x3E', '\x9E', '\xC5', '\x37', '\x61', '\xAA', '\xFF', '\x59'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); values->SetScrollBarButtonImages(upImage, downImage); } { CUITextViewer* values = reinterpret_cast(this->unknown_00F0); - const std::uint8_t scrollBackgroundSource[] = { - 0x15, 0x96, 0xEB, 0xB3, 0x27, 0x69, 0x52, 0x68, 0x13, 0xDD, 0xEB, 0x85, 0x5A, 0x1D, 0xCB, 0xE4, 0xB1, 0x4F, 0x4E, 0x27, 0x93, 0xD2, 0xE5, 0xC0, - 0x92, 0x4C, 0x42, 0x2D, 0x82, 0xFB, 0xE4, 0xC6, 0xA7, 0x56, 0x47, 0x25, 0xB8, 0xC5, 0xF0, 0xFA, 0xB8, 0x50, 0x4F, 0x67, 0x85, 0xCA, 0xE7, 0xA5}; + const char scrollBackgroundSource[] = { + '\x15', '\x96', '\xEB', '\xB3', '\x27', '\x69', '\x52', '\x68', '\x13', '\xDD', '\xEB', '\x85', '\x5A', '\x1D', '\xCB', '\xE4', '\xB1', '\x4F', '\x4E', + '\x27', '\x93', '\xD2', '\xE5', '\xC0', '\x92', '\x4C', '\x42', '\x2D', '\x82', '\xFB', '\xE4', '\xC6', '\xA7', '\x56', '\x47', '\x25', '\xB8', '\xC5', + '\xF0', '\xFA', '\xB8', '\x50', '\x4F', '\x67', '\x85', '\xCA', '\xE7', '\xA5'}; thread_local EncryptedName scrollBackgroundName(scrollBackgroundSource); const std::string scrollBackground(scrollBackgroundName.Text()); values->SetScrollBarBackground(scrollBackground); } { CUITextViewer* values = reinterpret_cast(this->unknown_00F0); - const std::uint8_t thumbBottomSource[] = { - 0x6B, 0x00, 0x4D, 0x77, 0x73, 0x43, 0x62, 0x18, 0x6D, 0x4B, 0x4D, 0x41, 0x0E, 0x37, 0xFB, 0x94, 0xCF, 0xD9, 0xE8, 0xE3, 0xC7, 0xF8, 0xD5, 0xB0, - 0xEC, 0xDA, 0xE4, 0xE9, 0xD6, 0xD1, 0xD4, 0xB6, 0xD9, 0xC0, 0xE1, 0xE1, 0xEC, 0xF9, 0xCF, 0xA0, 0xC6, 0xCD, 0xD2, 0xE9, 0xDC, 0xFA, 0xC9, 0xFB, - 0xC9, 0xC2, 0xFD, 0x8D}; + const char thumbBottomSource[] = { + '\x6B', '\x00', '\x4D', '\x77', '\x73', '\x43', '\x62', '\x18', '\x6D', '\x4B', '\x4D', '\x41', '\x0E', '\x37', '\xFB', '\x94', '\xCF', '\xD9', '\xE8', + '\xE3', '\xC7', '\xF8', '\xD5', '\xB0', '\xEC', '\xDA', '\xE4', '\xE9', '\xD6', '\xD1', '\xD4', '\xB6', '\xD9', '\xC0', '\xE1', '\xE1', '\xEC', '\xF9', + '\xCF', '\xA0', '\xC6', '\xCD', '\xD2', '\xE9', '\xDC', '\xFA', '\xC9', '\xFB', '\xC9', '\xC2', '\xFD', '\x8D'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xCF, 0xE0, 0x85, 0x55, 0x5D, 0x8B, 0x5C, 0xCE, 0xC9, 0xAB, 0x85, 0x63, 0x20, 0xFF, 0xC5, 0x42, 0x6B, 0x39, 0x20, 0xC1, 0xE9, 0x30, 0xEB, 0x66, - 0x48, 0x3A, 0x2C, 0xCB, 0xF8, 0x19, 0xEA, 0x60, 0x7D, 0x20, 0x29, 0xC3, 0xC2, 0x31, 0xF1, 0x76, 0x62, 0x2D, 0x1A, 0xC2, 0xF4, 0x21, 0xB7, 0x61, - 0x62, 0x3F, 0x45}; + const char thumbMiddleSource[] = { + '\xCF', '\xE0', '\x85', '\x55', '\x5D', '\x8B', '\x5C', '\xCE', '\xC9', '\xAB', '\x85', '\x63', '\x20', '\xFF', '\xC5', '\x42', '\x6B', '\x39', '\x20', + '\xC1', '\xE9', '\x30', '\xEB', '\x66', '\x48', '\x3A', '\x2C', '\xCB', '\xF8', '\x19', '\xEA', '\x60', '\x7D', '\x20', '\x29', '\xC3', '\xC2', '\x31', + '\xF1', '\x76', '\x62', '\x2D', '\x1A', '\xC2', '\xF4', '\x21', '\xB7', '\x61', '\x62', '\x3F', '\x45'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0xB3, 0x40, 0x7B, 0x2B, 0x15, 0x2D, 0x6E, 0x32, 0xB5, 0x0B, 0x7B, 0x1D, 0x68, 0x59, 0xF7, 0xBE, 0x17, 0x99, 0xDE, 0xBF, 0xA1, 0x96, 0xD9, 0x9A, - 0x34, 0x9A, 0xD2, 0xB5, 0xB0, 0xBF, 0xD8, 0x9C, 0x01, 0x80, 0xD7, 0xBD, 0x8A, 0x97, 0xC3, 0x8A, 0x1E, 0x8D, 0xE4, 0xA4, 0xA5, 0xCD, 0xC9, 0x92, - 0x03, 0xEF}; + const char thumbTopSource[] = { + '\xB3', '\x40', '\x7B', '\x2B', '\x15', '\x2D', '\x6E', '\x32', '\xB5', '\x0B', '\x7B', '\x1D', '\x68', '\x59', '\xF7', '\xBE', '\x17', '\x99', '\xDE', + '\xBF', '\xA1', '\x96', '\xD9', '\x9A', '\x34', '\x9A', '\xD2', '\xB5', '\xB0', '\xBF', '\xD8', '\x9C', '\x01', '\x80', '\xD7', '\xBD', '\x8A', '\x97', + '\xC3', '\x8A', '\x1E', '\x8D', '\xE4', '\xA4', '\xA5', '\xCD', '\xC9', '\x92', '\x03', '\xEF'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); values->SetScrollBarThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -1541,10 +1553,10 @@ void CUIQuestInfo::Slot15(int width, int height) { this->unknown_00E8->Move(250, 10); { CUIStaticImage* stamp = static_cast(this->unknown_00E8); - const std::uint8_t stampImageSource[] = { - 0x31, 0x68, 0xF9, 0xF3, 0xD7, 0xB7, 0x8A, 0x3C, 0x37, 0x23, 0xF9, 0xC5, 0xAA, 0xC3, 0x13, 0xB0, 0x95, 0xB1, 0x5C, 0x67, 0x63, 0x0C, 0x3D, 0x94, - 0xB6, 0xB2, 0x50, 0x6D, 0x72, 0x25, 0x3C, 0x85, 0x90, 0xAA, 0x49, 0x56, 0x74, 0x16, 0x22, 0x81, 0x9D, 0xA2, 0x4D, 0x6C, 0x73, 0x57, 0x2D, 0x9C, - 0x81, 0xC7}; + const char stampImageSource[] = { + '\x31', '\x68', '\xF9', '\xF3', '\xD7', '\xB7', '\x8A', '\x3C', '\x37', '\x23', '\xF9', '\xC5', '\xAA', '\xC3', '\x13', '\xB0', '\x95', '\xB1', '\x5C', + '\x67', '\x63', '\x0C', '\x3D', '\x94', '\xB6', '\xB2', '\x50', '\x6D', '\x72', '\x25', '\x3C', '\x85', '\x90', '\xAA', '\x49', '\x56', '\x74', '\x16', + '\x22', '\x81', '\x9D', '\xA2', '\x4D', '\x6C', '\x73', '\x57', '\x2D', '\x9C', '\x81', '\xC7'}; thread_local EncryptedName stampImageName(stampImageSource); const std::string stampImage(stampImageName.Text()); stamp->SetImage(stampImage); @@ -1557,8 +1569,7 @@ void CUIQuestInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00EC)->SetTextOffset(0, 0); { CUITextViewer* title = reinterpret_cast(this->unknown_00EC); - const std::uint8_t titleFontSource[] = { - 0x32, 0xB8, 0x81, 0x34, 0x06, 0x65}; + const char titleFontSource[] = {'\x32', '\xB8', '\x81', '\x34', '\x06', '\x65'}; thread_local EncryptedName titleFontName(titleFontSource); const std::string titleFont(titleFontName.Text()); title->SetFont(titleFont); @@ -1574,47 +1585,48 @@ void CUIQuestInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00EC)->SetScrollStep(20); { CUITextViewer* title = reinterpret_cast(this->unknown_00EC); - const std::uint8_t downImageSource[] = { - 0x3D, 0x78, 0x8D, 0x53, 0x75, 0x41, 0x52, 0x2A, 0x3B, 0x33, 0x8D, 0x65, 0x08, 0x35, 0xCB, 0xA6, 0x99, 0xA1, 0x28, 0xC7, 0xC1, 0xFA, 0xE5, 0x82, - 0xBA, 0xA2, 0x24, 0xCD, 0xD0, 0xD3, 0xE4, 0x84, 0x8F, 0xB8, 0x21, 0xC5, 0xEA, 0xEE, 0xE5, 0x95, 0x92, 0xA0, 0x12, 0xCD, 0xDA, 0xF8, 0xF9, 0xC9, - 0x9F, 0xBA, 0x3D, 0xA9}; + const char downImageSource[] = { + '\x3D', '\x78', '\x8D', '\x53', '\x75', '\x41', '\x52', '\x2A', '\x3B', '\x33', '\x8D', '\x65', '\x08', '\x35', '\xCB', '\xA6', '\x99', '\xA1', '\x28', + '\xC7', '\xC1', '\xFA', '\xE5', '\x82', '\xBA', '\xA2', '\x24', '\xCD', '\xD0', '\xD3', '\xE4', '\x84', '\x8F', '\xB8', '\x21', '\xC5', '\xEA', '\xEE', + '\xE5', '\x95', '\x92', '\xA0', '\x12', '\xCD', '\xDA', '\xF8', '\xF9', '\xC9', '\x9F', '\xBA', '\x3D', '\xA9'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0x3D, 0x16, 0x7B, 0xDB, 0x5F, 0x33, 0x84, 0x84, 0x3B, 0x5D, 0x7B, 0xED, 0x22, 0x47, 0x1D, 0x08, 0x99, 0xCF, 0xDE, 0x4F, 0xEB, 0x88, 0x33, 0x2C, - 0xBA, 0xCC, 0xD2, 0x45, 0xFA, 0xA1, 0x32, 0x2A, 0x8F, 0xD6, 0xD7, 0x4D, 0xC0, 0x9C, 0x33, 0x3B, 0x92, 0xCE, 0xE4, 0x54, 0xEF, 0xD3, 0x23, 0x24, - 0x8D, 0xB9}; + const char upImageSource[] = { + '\x3D', '\x16', '\x7B', '\xDB', '\x5F', '\x33', '\x84', '\x84', '\x3B', '\x5D', '\x7B', '\xED', '\x22', '\x47', '\x1D', '\x08', '\x99', '\xCF', '\xDE', + '\x4F', '\xEB', '\x88', '\x33', '\x2C', '\xBA', '\xCC', '\xD2', '\x45', '\xFA', '\xA1', '\x32', '\x2A', '\x8F', '\xD6', '\xD7', '\x4D', '\xC0', '\x9C', + '\x33', '\x3B', '\x92', '\xCE', '\xE4', '\x54', '\xEF', '\xD3', '\x23', '\x24', '\x8D', '\xB9'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); title->SetScrollBarButtonImages(upImage, downImage); } { CUITextViewer* title = reinterpret_cast(this->unknown_00EC); - const std::uint8_t scrollBackgroundSource[] = { - 0xAB, 0x16, 0x07, 0xF5, 0xA7, 0x41, 0x38, 0x7A, 0xAD, 0x5D, 0x07, 0xC3, 0xDA, 0x35, 0xA1, 0xF6, 0x0F, 0xCF, 0xA2, 0x61, 0x13, 0xFA, 0x8F, 0xD2, - 0x2C, 0xCC, 0xAE, 0x6B, 0x02, 0xD3, 0x8E, 0xD4, 0x19, 0xD6, 0xAB, 0x63, 0x38, 0xED, 0x9A, 0xE8, 0x06, 0xD0, 0xA3, 0x21, 0x05, 0xE2, 0x8D, 0xB7}; + const char scrollBackgroundSource[] = { + '\xAB', '\x16', '\x07', '\xF5', '\xA7', '\x41', '\x38', '\x7A', '\xAD', '\x5D', '\x07', '\xC3', '\xDA', '\x35', '\xA1', '\xF6', '\x0F', '\xCF', '\xA2', + '\x61', '\x13', '\xFA', '\x8F', '\xD2', '\x2C', '\xCC', '\xAE', '\x6B', '\x02', '\xD3', '\x8E', '\xD4', '\x19', '\xD6', '\xAB', '\x63', '\x38', '\xED', + '\x9A', '\xE8', '\x06', '\xD0', '\xA3', '\x21', '\x05', '\xE2', '\x8D', '\xB7'}; thread_local EncryptedName scrollBackgroundName(scrollBackgroundSource); const std::string scrollBackground(scrollBackgroundName.Text()); title->SetScrollBarBackground(scrollBackground); } { CUITextViewer* title = reinterpret_cast(this->unknown_00EC); - const std::uint8_t thumbBottomSource[] = { - 0x0D, 0x5E, 0x59, 0x4F, 0x4D, 0x95, 0xC2, 0x60, 0x0B, 0x15, 0x59, 0x79, 0x30, 0xE1, 0x5B, 0xEC, 0xA9, 0x87, 0xFC, 0xDB, 0xF9, 0x2E, 0x75, 0xC8, - 0x8A, 0x84, 0xF0, 0xD1, 0xE8, 0x07, 0x74, 0xCE, 0xBF, 0x9E, 0xF5, 0xD9, 0xD2, 0x2F, 0x6F, 0xD8, 0xA0, 0x93, 0xC6, 0xD1, 0xE2, 0x2C, 0x69, 0x83, - 0xAF, 0x9C, 0xE9, 0xB5}; + const char thumbBottomSource[] = { + '\x0D', '\x5E', '\x59', '\x4F', '\x4D', '\x95', '\xC2', '\x60', '\x0B', '\x15', '\x59', '\x79', '\x30', '\xE1', '\x5B', '\xEC', '\xA9', '\x87', '\xFC', + '\xDB', '\xF9', '\x2E', '\x75', '\xC8', '\x8A', '\x84', '\xF0', '\xD1', '\xE8', '\x07', '\x74', '\xCE', '\xBF', '\x9E', '\xF5', '\xD9', '\xD2', '\x2F', + '\x6F', '\xD8', '\xA0', '\x93', '\xC6', '\xD1', '\xE2', '\x2C', '\x69', '\x83', '\xAF', '\x9C', '\xE9', '\xB5'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0x57, 0x5E, 0x21, 0x27, 0x11, 0x5D, 0x2C, 0xE2, 0x51, 0x15, 0x21, 0x11, 0x6C, 0x29, 0xB5, 0x6E, 0xF3, 0x87, 0x84, 0xB3, 0xA5, 0xE6, 0x9B, 0x4A, - 0xD0, 0x84, 0x88, 0xB9, 0xB4, 0xCF, 0x9A, 0x4C, 0xE5, 0x9E, 0x8D, 0xB1, 0x8E, 0xE7, 0x81, 0x5A, 0xFA, 0x93, 0xBE, 0xB0, 0xB8, 0xF7, 0xC7, 0x4D, - 0xFA, 0x81, 0xE1}; + const char thumbMiddleSource[] = { + '\x57', '\x5E', '\x21', '\x27', '\x11', '\x5D', '\x2C', '\xE2', '\x51', '\x15', '\x21', '\x11', '\x6C', '\x29', '\xB5', '\x6E', '\xF3', '\x87', '\x84', + '\xB3', '\xA5', '\xE6', '\x9B', '\x4A', '\xD0', '\x84', '\x88', '\xB9', '\xB4', '\xCF', '\x9A', '\x4C', '\xE5', '\x9E', '\x8D', '\xB1', '\x8E', '\xE7', + '\x81', '\x5A', '\xFA', '\x93', '\xBE', '\xB0', '\xB8', '\xF7', '\xC7', '\x4D', '\xFA', '\x81', '\xE1'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x4F, 0x36, 0x2B, 0xF7, 0x75, 0xB1, 0x3A, 0xF4, 0x49, 0x7D, 0x2B, 0xC1, 0x08, 0xC5, 0xA3, 0x78, 0xEB, 0xEF, 0x8E, 0x63, 0xC1, 0x0A, 0x8D, 0x5C, - 0xC8, 0xEC, 0x82, 0x69, 0xD0, 0x23, 0x8C, 0x5A, 0xFD, 0xF6, 0x87, 0x61, 0xEA, 0x0B, 0x97, 0x4C, 0xE2, 0xFB, 0xB4, 0x78, 0xC5, 0x51, 0x9D, 0x54, - 0xFF, 0x99}; + const char thumbTopSource[] = { + '\x4F', '\x36', '\x2B', '\xF7', '\x75', '\xB1', '\x3A', '\xF4', '\x49', '\x7D', '\x2B', '\xC1', '\x08', '\xC5', '\xA3', '\x78', '\xEB', '\xEF', '\x8E', + '\x63', '\xC1', '\x0A', '\x8D', '\x5C', '\xC8', '\xEC', '\x82', '\x69', '\xD0', '\x23', '\x8C', '\x5A', '\xFD', '\xF6', '\x87', '\x61', '\xEA', '\x0B', + '\x97', '\x4C', '\xE2', '\xFB', '\xB4', '\x78', '\xC5', '\x51', '\x9D', '\x54', '\xFF', '\x99'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); title->SetScrollBarThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -1627,8 +1639,7 @@ void CUIQuestInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00F0)->SetTextOffset(0, 6); { CUITextViewer* lines = reinterpret_cast(this->unknown_00F0); - const std::uint8_t linesFontSource[] = { - 0x38, 0x60, 0xE1, 0x78, 0x5A, 0x0F}; + const char linesFontSource[] = {'\x38', '\x60', '\xE1', '\x78', '\x5A', '\x0F'}; thread_local EncryptedName linesFontName(linesFontSource); const std::string linesFont(linesFontName.Text()); lines->SetFont(linesFont); @@ -1644,47 +1655,48 @@ void CUIQuestInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00F0)->SetScrollStep(20); { CUITextViewer* lines = reinterpret_cast(this->unknown_00F0); - const std::uint8_t downImageSource[] = { - 0xE3, 0x5E, 0x17, 0xED, 0x17, 0x87, 0x26, 0xB0, 0xE5, 0x15, 0x17, 0xDB, 0x6A, 0xF3, 0xBF, 0x3C, 0x47, 0x87, 0xB2, 0x79, 0xA3, 0x3C, 0x91, 0x18, - 0x64, 0x84, 0xBE, 0x73, 0xB2, 0x15, 0x90, 0x1E, 0x51, 0x9E, 0xBB, 0x7B, 0x88, 0x28, 0x91, 0x0F, 0x4C, 0x86, 0x88, 0x73, 0xB8, 0x3E, 0x8D, 0x53, - 0x41, 0x9C, 0xA7, 0x17}; + const char downImageSource[] = { + '\xE3', '\x5E', '\x17', '\xED', '\x17', '\x87', '\x26', '\xB0', '\xE5', '\x15', '\x17', '\xDB', '\x6A', '\xF3', '\xBF', '\x3C', '\x47', '\x87', '\xB2', + '\x79', '\xA3', '\x3C', '\x91', '\x18', '\x64', '\x84', '\xBE', '\x73', '\xB2', '\x15', '\x90', '\x1E', '\x51', '\x9E', '\xBB', '\x7B', '\x88', '\x28', + '\x91', '\x0F', '\x4C', '\x86', '\x88', '\x73', '\xB8', '\x3E', '\x8D', '\x53', '\x41', '\x9C', '\xA7', '\x17'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0xBF, 0x7A, 0x6F, 0xA1, 0xAB, 0x7F, 0xD0, 0xC2, 0xB9, 0x31, 0x6F, 0x97, 0xD6, 0x0B, 0x49, 0x4E, 0x1B, 0xA3, 0xCA, 0x35, 0x1F, 0xC4, 0x67, 0x6A, - 0x38, 0xA0, 0xC6, 0x3F, 0x0E, 0xED, 0x66, 0x6C, 0x0D, 0xBA, 0xC3, 0x37, 0x34, 0xD0, 0x67, 0x7D, 0x10, 0xA2, 0xF0, 0x2E, 0x1B, 0x9F, 0x77, 0x62, - 0x0F, 0xD5}; + const char upImageSource[] = { + '\xBF', '\x7A', '\x6F', '\xA1', '\xAB', '\x7F', '\xD0', '\xC2', '\xB9', '\x31', '\x6F', '\x97', '\xD6', '\x0B', '\x49', '\x4E', '\x1B', '\xA3', '\xCA', + '\x35', '\x1F', '\xC4', '\x67', '\x6A', '\x38', '\xA0', '\xC6', '\x3F', '\x0E', '\xED', '\x66', '\x6C', '\x0D', '\xBA', '\xC3', '\x37', '\x34', '\xD0', + '\x67', '\x7D', '\x10', '\xA2', '\xF0', '\x2E', '\x1B', '\x9F', '\x77', '\x62', '\x0F', '\xD5'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); lines->SetScrollBarButtonImages(upImage, downImage); } { CUITextViewer* lines = reinterpret_cast(this->unknown_00F0); - const std::uint8_t scrollBackgroundSource[] = { - 0x21, 0x36, 0x47, 0xB5, 0x41, 0x0D, 0xE4, 0xBE, 0x27, 0x7D, 0x47, 0x83, 0x3C, 0x79, 0x7D, 0x32, 0x85, 0xEF, 0xE2, 0x21, 0xF5, 0xB6, 0x53, 0x16, - 0xA6, 0xEC, 0xEE, 0x2B, 0xE4, 0x9F, 0x52, 0x10, 0x93, 0xF6, 0xEB, 0x23, 0xDE, 0xA1, 0x46, 0x2C, 0x8C, 0xF0, 0xE3, 0x61, 0xE3, 0xAE, 0x51, 0x73}; + const char scrollBackgroundSource[] = { + '\x21', '\x36', '\x47', '\xB5', '\x41', '\x0D', '\xE4', '\xBE', '\x27', '\x7D', '\x47', '\x83', '\x3C', '\x79', '\x7D', '\x32', '\x85', '\xEF', '\xE2', + '\x21', '\xF5', '\xB6', '\x53', '\x16', '\xA6', '\xEC', '\xEE', '\x2B', '\xE4', '\x9F', '\x52', '\x10', '\x93', '\xF6', '\xEB', '\x23', '\xDE', '\xA1', + '\x46', '\x2C', '\x8C', '\xF0', '\xE3', '\x61', '\xE3', '\xAE', '\x51', '\x73'}; thread_local EncryptedName scrollBackgroundName(scrollBackgroundSource); const std::string scrollBackground(scrollBackgroundName.Text()); lines->SetScrollBarBackground(scrollBackground); } { CUITextViewer* lines = reinterpret_cast(this->unknown_00F0); - const std::uint8_t thumbBottomSource[] = { - 0x09, 0xBC, 0x39, 0x89, 0x39, 0x17, 0xD0, 0xBC, 0x0F, 0xF7, 0x39, 0xBF, 0x44, 0x63, 0x49, 0x30, 0xAD, 0x65, 0x9C, 0x1D, 0x8D, 0xAC, 0x67, 0x14, - 0x8E, 0x66, 0x90, 0x17, 0x9C, 0x85, 0x66, 0x12, 0xBB, 0x7C, 0x95, 0x1F, 0xA6, 0xAD, 0x7D, 0x04, 0xA4, 0x71, 0xA6, 0x17, 0x96, 0xAE, 0x7B, 0x5F, - 0xAB, 0x7E, 0x89, 0x73}; + const char thumbBottomSource[] = { + '\x09', '\xBC', '\x39', '\x89', '\x39', '\x17', '\xD0', '\xBC', '\x0F', '\xF7', '\x39', '\xBF', '\x44', '\x63', '\x49', '\x30', '\xAD', '\x65', '\x9C', + '\x1D', '\x8D', '\xAC', '\x67', '\x14', '\x8E', '\x66', '\x90', '\x17', '\x9C', '\x85', '\x66', '\x12', '\xBB', '\x7C', '\x95', '\x1F', '\xA6', '\xAD', + '\x7D', '\x04', '\xA4', '\x71', '\xA6', '\x17', '\x96', '\xAE', '\x7B', '\x5F', '\xAB', '\x7E', '\x89', '\x73'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xA3, 0x5A, 0x21, 0x85, 0xFB, 0xEB, 0xD8, 0x06, 0xA5, 0x11, 0x21, 0xB3, 0x86, 0x9F, 0x41, 0x8A, 0x07, 0x83, 0x84, 0x11, 0x4F, 0x50, 0x6F, 0xAE, - 0x24, 0x80, 0x88, 0x1B, 0x5E, 0x79, 0x6E, 0xA8, 0x11, 0x9A, 0x8D, 0x13, 0x64, 0x51, 0x75, 0xBE, 0x0E, 0x97, 0xBE, 0x12, 0x52, 0x41, 0x33, 0xA9, - 0x0E, 0x85, 0xE1}; + const char thumbMiddleSource[] = { + '\xA3', '\x5A', '\x21', '\x85', '\xFB', '\xEB', '\xD8', '\x06', '\xA5', '\x11', '\x21', '\xB3', '\x86', '\x9F', '\x41', '\x8A', '\x07', '\x83', '\x84', + '\x11', '\x4F', '\x50', '\x6F', '\xAE', '\x24', '\x80', '\x88', '\x1B', '\x5E', '\x79', '\x6E', '\xA8', '\x11', '\x9A', '\x8D', '\x13', '\x64', '\x51', + '\x75', '\xBE', '\x0E', '\x97', '\xBE', '\x12', '\x52', '\x41', '\x33', '\xA9', '\x0E', '\x85', '\xE1'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x8F, 0x0E, 0x0F, 0xCF, 0xA3, 0x19, 0x84, 0xB4, 0x89, 0x45, 0x0F, 0xF9, 0xDE, 0x6D, 0x1D, 0x38, 0x2B, 0xD7, 0xAA, 0x5B, 0x17, 0xA2, 0x33, 0x1C, - 0x08, 0xD4, 0xA6, 0x51, 0x06, 0x8B, 0x32, 0x1A, 0x3D, 0xCE, 0xA3, 0x59, 0x3C, 0xA3, 0x29, 0x0C, 0x22, 0xC3, 0x90, 0x40, 0x13, 0xF9, 0x23, 0x14, - 0x3F, 0xA1}; + const char thumbTopSource[] = { + '\x8F', '\x0E', '\x0F', '\xCF', '\xA3', '\x19', '\x84', '\xB4', '\x89', '\x45', '\x0F', '\xF9', '\xDE', '\x6D', '\x1D', '\x38', '\x2B', '\xD7', '\xAA', + '\x5B', '\x17', '\xA2', '\x33', '\x1C', '\x08', '\xD4', '\xA6', '\x51', '\x06', '\x8B', '\x32', '\x1A', '\x3D', '\xCE', '\xA3', '\x59', '\x3C', '\xA3', + '\x29', '\x0C', '\x22', '\xC3', '\x90', '\x40', '\x13', '\xF9', '\x23', '\x14', '\x3F', '\xA1'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); lines->SetScrollBarThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -1697,8 +1709,7 @@ void CUIQuestInfo::Slot15(int width, int height) { reinterpret_cast(this->unknown_00F4)->SetTextOffset(0, 0); { CUITextViewer* status = reinterpret_cast(this->unknown_00F4); - const std::uint8_t statusFontSource[] = { - 0x5A, 0x70, 0xFF, 0x40, 0x1C, 0x23}; + const char statusFontSource[] = {'\x5A', '\x70', '\xFF', '\x40', '\x1C', '\x23'}; thread_local EncryptedName statusFontName(statusFontSource); const std::string statusFont(statusFontName.Text()); status->SetFont(statusFont); @@ -1895,28 +1906,28 @@ CUIListBox* CUITab::CreateSubTabList() { CUIListBox* list = this->subTabs; { - const std::uint8_t disabledImageSource[] = { - 0x97, 0x50, 0x2D, 0xB5, 0x6F, 0x7B, 0x12, 0x78, 0x91, 0x1B, 0x2D, 0x83, 0x12, 0x0F, 0x8B, 0xF4, 0x33, 0x89, 0x88, 0x21, 0xDB, 0xC0, 0xA5, 0xD0, - 0x10, 0x8A, 0x84, 0x2B, 0xCA, 0xE9, 0xA3, 0xD4, 0x35, 0xA0, 0x8F, 0x3B, 0xC1, 0xEA, 0xA4, 0xC0, 0x35, 0xA0, 0x83, 0x20, 0xDD, 0xD8, 0xB6, 0xD9, - 0x79, 0x9D, 0x80, 0x3F, 0xAF}; + const char disabledImageSource[] = { + '\x97', '\x50', '\x2D', '\xB5', '\x6F', '\x7B', '\x12', '\x78', '\x91', '\x1B', '\x2D', '\x83', '\x12', '\x0F', '\x8B', '\xF4', '\x33', '\x89', '\x88', + '\x21', '\xDB', '\xC0', '\xA5', '\xD0', '\x10', '\x8A', '\x84', '\x2B', '\xCA', '\xE9', '\xA3', '\xD4', '\x35', '\xA0', '\x8F', '\x3B', '\xC1', '\xEA', + '\xA4', '\xC0', '\x35', '\xA0', '\x83', '\x20', '\xDD', '\xD8', '\xB6', '\xD9', '\x79', '\x9D', '\x80', '\x3F', '\xAF'}; thread_local EncryptedName disabledImageName(disabledImageSource); const std::string disabledImage(disabledImageName.Text()); - const std::uint8_t pressedImageSource[] = { - 0x11, 0x76, 0xD9, 0xE3, 0x6B, 0x95, 0x18, 0xAA, 0x17, 0x3D, 0xD9, 0xD5, 0x16, 0xE1, 0x81, 0x26, 0xB5, 0xAF, 0x7C, 0x77, 0xDF, 0x2E, 0xAF, 0x02, - 0x96, 0xAC, 0x70, 0x7D, 0xCE, 0x07, 0xA9, 0x06, 0xB3, 0x86, 0x7B, 0x6D, 0xC5, 0x04, 0xAE, 0x12, 0xB3, 0x86, 0x76, 0x6F, 0xCE, 0x29, 0xF3, 0x05, - 0xBC, 0xA9, 0x19}; + const char pressedImageSource[] = { + '\x11', '\x76', '\xD9', '\xE3', '\x6B', '\x95', '\x18', '\xAA', '\x17', '\x3D', '\xD9', '\xD5', '\x16', '\xE1', '\x81', '\x26', '\xB5', '\xAF', '\x7C', + '\x77', '\xDF', '\x2E', '\xAF', '\x02', '\x96', '\xAC', '\x70', '\x7D', '\xCE', '\x07', '\xA9', '\x06', '\xB3', '\x86', '\x7B', '\x6D', '\xC5', '\x04', + '\xAE', '\x12', '\xB3', '\x86', '\x76', '\x6F', '\xCE', '\x29', '\xF3', '\x05', '\xBC', '\xA9', '\x19'}; thread_local EncryptedName pressedImageName(pressedImageSource); const std::string pressedImage(pressedImageName.Text()); - const std::uint8_t hoverImageSource[] = { - 0x33, 0xBA, 0xB3, 0xD9, 0xB9, 0x39, 0x36, 0x78, 0x35, 0xF1, 0xB3, 0xEF, 0xC4, 0x4D, 0xAF, 0xF4, 0x97, 0x63, 0x16, 0x4D, 0x0D, 0x82, 0x81, 0xD0, - 0xB4, 0x60, 0x1A, 0x47, 0x1C, 0xAB, 0x87, 0xD4, 0x91, 0x4A, 0x11, 0x57, 0x17, 0xA8, 0x80, 0xC0, 0x91, 0x4A, 0x03, 0x51, 0x1C, 0x84, 0x80, 0x9B, - 0x91, 0x78, 0x03, 0x23}; + const char hoverImageSource[] = { + '\x33', '\xBA', '\xB3', '\xD9', '\xB9', '\x39', '\x36', '\x78', '\x35', '\xF1', '\xB3', '\xEF', '\xC4', '\x4D', '\xAF', '\xF4', '\x97', '\x63', '\x16', + '\x4D', '\x0D', '\x82', '\x81', '\xD0', '\xB4', '\x60', '\x1A', '\x47', '\x1C', '\xAB', '\x87', '\xD4', '\x91', '\x4A', '\x11', '\x57', '\x17', '\xA8', + '\x80', '\xC0', '\x91', '\x4A', '\x03', '\x51', '\x1C', '\x84', '\x80', '\x9B', '\x91', '\x78', '\x03', '\x23'}; thread_local EncryptedName hoverImageName(hoverImageSource); const std::string hoverImage(hoverImageName.Text()); - const std::uint8_t normalImageSource[] = { - 0xC3, 0x9A, 0x59, 0x4F, 0x73, 0xB9, 0x0C, 0xA6, 0xC5, 0xD1, 0x59, 0x79, 0x0E, 0xCD, 0x95, 0x2A, 0x67, 0x43, 0xFC, 0xDB, 0xC7, 0x02, 0xBB, 0x0E, - 0x44, 0x40, 0xF0, 0xD1, 0xD6, 0x2B, 0xBD, 0x0A, 0x61, 0x6A, 0xFB, 0xC1, 0xDD, 0x28, 0xBA, 0x1E, 0x61, 0x6A, 0xF7, 0xDA, 0xC1, 0x1A, 0xA8, 0x07, - 0x2D, 0x57, 0xF4, 0xC5, 0xB3}; + const char normalImageSource[] = { + '\xC3', '\x9A', '\x59', '\x4F', '\x73', '\xB9', '\x0C', '\xA6', '\xC5', '\xD1', '\x59', '\x79', '\x0E', '\xCD', '\x95', '\x2A', '\x67', '\x43', '\xFC', + '\xDB', '\xC7', '\x02', '\xBB', '\x0E', '\x44', '\x40', '\xF0', '\xD1', '\xD6', '\x2B', '\xBD', '\x0A', '\x61', '\x6A', '\xFB', '\xC1', '\xDD', '\x28', + '\xBA', '\x1E', '\x61', '\x6A', '\xF7', '\xDA', '\xC1', '\x1A', '\xA8', '\x07', '\x2D', '\x57', '\xF4', '\xC5', '\xB3'}; thread_local EncryptedName normalImageName(normalImageSource); const std::string normalImage(normalImageName.Text()); list->SetImages(normalImage, hoverImage, pressedImage, disabledImage); @@ -1930,45 +1941,46 @@ CUIListBox* CUITab::CreateSubTabList() { this->subTabs->scrollBar->Move(89, 0); this->subTabs->scrollBar->step = 20; { - const std::uint8_t downImageSource[] = { - 0x77, 0x9C, 0xE5, 0xF3, 0x7B, 0xFB, 0x40, 0xCE, 0x71, 0xD7, 0xE5, 0xC5, 0x06, 0x8F, 0xD9, 0x42, 0xD3, 0x45, 0x40, 0x67, 0xCF, 0x40, 0xF7, 0x66, - 0xF0, 0x46, 0x4C, 0x6D, 0xDE, 0x69, 0xF6, 0x60, 0xC5, 0x5C, 0x49, 0x65, 0xE4, 0x54, 0xF7, 0x71, 0xD8, 0x44, 0x7A, 0x6D, 0xD4, 0x42, 0xEB, 0x2D, - 0xD5, 0x5E, 0x55, 0x09}; + const char downImageSource[] = { + '\x77', '\x9C', '\xE5', '\xF3', '\x7B', '\xFB', '\x40', '\xCE', '\x71', '\xD7', '\xE5', '\xC5', '\x06', '\x8F', '\xD9', '\x42', '\xD3', '\x45', '\x40', + '\x67', '\xCF', '\x40', '\xF7', '\x66', '\xF0', '\x46', '\x4C', '\x6D', '\xDE', '\x69', '\xF6', '\x60', '\xC5', '\x5C', '\x49', '\x65', '\xE4', '\x54', + '\xF7', '\x71', '\xD8', '\x44', '\x7A', '\x6D', '\xD4', '\x42', '\xEB', '\x2D', '\xD5', '\x5E', '\x55', '\x09'}; thread_local EncryptedName downImageName(downImageSource); const std::string downImage(downImageName.Text()); - const std::uint8_t upImageSource[] = { - 0xB9, 0x58, 0xD5, 0xCF, 0x6D, 0x9F, 0x58, 0x56, 0xBF, 0x13, 0xD5, 0xF9, 0x10, 0xEB, 0xC1, 0xDA, 0x1D, 0x81, 0x70, 0x5B, 0xD9, 0x24, 0xEF, 0xFE, - 0x3E, 0x82, 0x7C, 0x51, 0xC8, 0x0D, 0xEE, 0xF8, 0x0B, 0x98, 0x79, 0x59, 0xF2, 0x30, 0xEF, 0xE9, 0x16, 0x80, 0x4A, 0x40, 0xDD, 0x7F, 0xFF, 0xF6, - 0x09, 0xF7}; + const char upImageSource[] = { + '\xB9', '\x58', '\xD5', '\xCF', '\x6D', '\x9F', '\x58', '\x56', '\xBF', '\x13', '\xD5', '\xF9', '\x10', '\xEB', '\xC1', '\xDA', '\x1D', '\x81', '\x70', + '\x5B', '\xD9', '\x24', '\xEF', '\xFE', '\x3E', '\x82', '\x7C', '\x51', '\xC8', '\x0D', '\xEE', '\xF8', '\x0B', '\x98', '\x79', '\x59', '\xF2', '\x30', + '\xEF', '\xE9', '\x16', '\x80', '\x4A', '\x40', '\xDD', '\x7F', '\xFF', '\xF6', '\x09', '\xF7'}; thread_local EncryptedName upImageName(upImageSource); const std::string upImage(upImageName.Text()); this->subTabs->scrollBar->SetButtonImages(upImage, downImage); } { - const std::uint8_t backgroundImageSource[] = { - 0x13, 0xD8, 0x27, 0x93, 0x97, 0x09, 0xEE, 0x36, 0x15, 0x93, 0x27, 0xA5, 0xEA, 0x7D, 0x77, 0xBA, 0xB7, 0x01, 0x82, 0x07, 0x23, 0xB2, 0x59, 0x9E, - 0x94, 0x02, 0x8E, 0x0D, 0x32, 0x9B, 0x58, 0x98, 0xA1, 0x18, 0x8B, 0x05, 0x08, 0xA5, 0x4C, 0xA4, 0xBE, 0x1E, 0x83, 0x47, 0x35, 0xAA, 0x5B, 0xFB}; + const char backgroundImageSource[] = { + '\x13', '\xD8', '\x27', '\x93', '\x97', '\x09', '\xEE', '\x36', '\x15', '\x93', '\x27', '\xA5', '\xEA', '\x7D', '\x77', '\xBA', '\xB7', '\x01', '\x82', + '\x07', '\x23', '\xB2', '\x59', '\x9E', '\x94', '\x02', '\x8E', '\x0D', '\x32', '\x9B', '\x58', '\x98', '\xA1', '\x18', '\x8B', '\x05', '\x08', '\xA5', + '\x4C', '\xA4', '\xBE', '\x1E', '\x83', '\x47', '\x35', '\xAA', '\x5B', '\xFB'}; thread_local EncryptedName backgroundImageName(backgroundImageSource); const std::string backgroundImage(backgroundImageName.Text()); this->subTabs->scrollBar->SetBackground(backgroundImage); } { - const std::uint8_t thumbBottomSource[] = { - 0xB3, 0x8E, 0x27, 0xBD, 0xEB, 0xB7, 0x7A, 0x46, 0xB5, 0xC5, 0x27, 0x8B, 0x96, 0xC3, 0xE3, 0xCA, 0x17, 0x57, 0x82, 0x29, 0x5F, 0x0C, 0xCD, 0xEE, - 0x34, 0x54, 0x8E, 0x23, 0x4E, 0x25, 0xCC, 0xE8, 0x01, 0x4E, 0x8B, 0x2B, 0x74, 0x0D, 0xD7, 0xFE, 0x1E, 0x43, 0xB8, 0x23, 0x44, 0x0E, 0xD1, 0xA5, - 0x11, 0x4C, 0x97, 0x47}; + const char thumbBottomSource[] = { + '\xB3', '\x8E', '\x27', '\xBD', '\xEB', '\xB7', '\x7A', '\x46', '\xB5', '\xC5', '\x27', '\x8B', '\x96', '\xC3', '\xE3', '\xCA', '\x17', '\x57', '\x82', + '\x29', '\x5F', '\x0C', '\xCD', '\xEE', '\x34', '\x54', '\x8E', '\x23', '\x4E', '\x25', '\xCC', '\xE8', '\x01', '\x4E', '\x8B', '\x2B', '\x74', '\x0D', + '\xD7', '\xFE', '\x1E', '\x43', '\xB8', '\x23', '\x44', '\x0E', '\xD1', '\xA5', '\x11', '\x4C', '\x97', '\x47'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xBD, 0xFC, 0x4F, 0x5B, 0x3F, 0x23, 0xAC, 0x10, 0xBB, 0xB7, 0x4F, 0x6D, 0x42, 0x57, 0x35, 0x9C, 0x19, 0x25, 0xEA, 0xCF, 0x8B, 0x98, 0x1B, 0xB8, - 0x3A, 0x26, 0xE6, 0xC5, 0x9A, 0xB1, 0x1A, 0xBE, 0x0F, 0x3C, 0xE3, 0xCD, 0xA0, 0x99, 0x01, 0xA8, 0x10, 0x31, 0xD0, 0xCC, 0x96, 0x89, 0x47, 0xBF, - 0x10, 0x23, 0x8F}; + const char thumbMiddleSource[] = { + '\xBD', '\xFC', '\x4F', '\x5B', '\x3F', '\x23', '\xAC', '\x10', '\xBB', '\xB7', '\x4F', '\x6D', '\x42', '\x57', '\x35', '\x9C', '\x19', '\x25', '\xEA', + '\xCF', '\x8B', '\x98', '\x1B', '\xB8', '\x3A', '\x26', '\xE6', '\xC5', '\x9A', '\xB1', '\x1A', '\xBE', '\x0F', '\x3C', '\xE3', '\xCD', '\xA0', '\x99', + '\x01', '\xA8', '\x10', '\x31', '\xD0', '\xCC', '\x96', '\x89', '\x47', '\xBF', '\x10', '\x23', '\x8F'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x51, 0x86, 0xB9, 0xB9, 0x1B, 0xC7, 0x60, 0xBC, 0x57, 0xCD, 0xB9, 0x8F, 0x66, 0xB3, 0xF9, 0x30, 0xF5, 0x5F, 0x1C, 0x2D, 0xAF, 0x7C, 0xD7, 0x14, - 0xD6, 0x5C, 0x10, 0x27, 0xBE, 0x55, 0xD6, 0x12, 0xE3, 0x46, 0x15, 0x2F, 0x84, 0x7D, 0xCD, 0x04, 0xFC, 0x4B, 0x26, 0x36, 0xAB, 0x27, 0xC7, 0x1C, - 0xE1, 0x29}; + const char thumbTopSource[] = { + '\x51', '\x86', '\xB9', '\xB9', '\x1B', '\xC7', '\x60', '\xBC', '\x57', '\xCD', '\xB9', '\x8F', '\x66', '\xB3', '\xF9', '\x30', '\xF5', '\x5F', '\x1C', + '\x2D', '\xAF', '\x7C', '\xD7', '\x14', '\xD6', '\x5C', '\x10', '\x27', '\xBE', '\x55', '\xD6', '\x12', '\xE3', '\x46', '\x15', '\x2F', '\x84', '\x7D', + '\xCD', '\x04', '\xFC', '\x4B', '\x26', '\x36', '\xAB', '\x27', '\xC7', '\x1C', '\xE1', '\x29'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); this->subTabs->scrollBar->SetThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -2136,9 +2148,10 @@ void CUIIntro::Slot15(int width, int height) { this->banner->SetSize(630, 216); this->banner->Move(0, 0); { - const std::uint8_t bannerSource[] = { - 0xAD, 0x14, 0x55, 0xD7, 0x53, 0x35, 0xD2, 0x08, 0xAB, 0x5F, 0x55, 0xE1, 0x2E, 0x41, 0x4B, 0x84, 0x09, 0xCD, 0xF0, 0x43, 0xE7, 0x8E, 0x65, 0xA0, - 0x2A, 0xCE, 0xFC, 0x49, 0xF6, 0xA7, 0x75, 0xA2, 0x32, 0xD9, 0xF4, 0x43, 0xFD, 0x9E, 0x65, 0xEB, 0x0F, 0xD6, 0xE5, 0x2D}; + const char bannerSource[] = { + '\xAD', '\x14', '\x55', '\xD7', '\x53', '\x35', '\xD2', '\x08', '\xAB', '\x5F', '\x55', '\xE1', '\x2E', '\x41', '\x4B', '\x84', '\x09', '\xCD', '\xF0', + '\x43', '\xE7', '\x8E', '\x65', '\xA0', '\x2A', '\xCE', '\xFC', '\x49', '\xF6', '\xA7', '\x75', '\xA2', '\x32', '\xD9', '\xF4', '\x43', '\xFD', '\x9E', + '\x65', '\xEB', '\x0F', '\xD6', '\xE5', '\x2D'}; thread_local EncryptedName bannerName(bannerSource); const std::string banner(bannerName.Text()); this->banner->SetImage(banner); @@ -2159,24 +2172,28 @@ void CUIIntro::Slot15(int width, int height) { this->contents->onSelect = [this](CUITabInfo* item, const Guide_Intro::Contents& contents) { this->OnSelectContents(item, contents); }; this->contents->binder = [this](CUITabInfo* item, const Guide_Intro::Contents& contents) { this->BindContents(item, contents); }; { - const std::uint8_t disabledSource[] = { - 0x5B, 0xF8, 0xC3, 0x63, 0xA7, 0xCB, 0xC0, 0xC8, 0x5D, 0xB3, 0xC3, 0x55, 0xDA, 0xBF, 0x59, 0x44, 0xFF, 0x21, 0x66, 0xF7, 0x13, 0x70, 0x77, 0x60, - 0xDC, 0x22, 0x6A, 0xFD, 0x02, 0x59, 0x69, 0x6C, 0xE8, 0x23, 0x5C, 0xA8, 0x49, 0x67, 0x68, 0x75, 0x9B}; + const char disabledSource[] = { + '\x5B', '\xF8', '\xC3', '\x63', '\xA7', '\xCB', '\xC0', '\xC8', '\x5D', '\xB3', '\xC3', '\x55', '\xDA', '\xBF', '\x59', '\x44', '\xFF', '\x21', '\x66', + '\xF7', '\x13', '\x70', '\x77', '\x60', '\xDC', '\x22', '\x6A', '\xFD', '\x02', '\x59', '\x69', '\x6C', '\xE8', '\x23', '\x5C', '\xA8', '\x49', '\x67', + '\x68', '\x75', '\x9B'}; thread_local EncryptedName disabledName(disabledSource); const std::string disabled(disabledName.Text()); - const std::uint8_t pressedSource[] = { - 0x65, 0x32, 0xAD, 0x03, 0xA3, 0xE9, 0xB2, 0xCE, 0x63, 0x79, 0xAD, 0x35, 0xDE, 0x9D, 0x2B, 0x42, 0xC1, 0xEB, 0x08, 0x97, 0x17, 0x52, 0x05, 0x66, - 0xE2, 0xE8, 0x04, 0x9D, 0x06, 0x7B, 0x1B, 0x6A, 0xD6, 0xE9, 0x32, 0xC8, 0x4D, 0x45, 0x1A, 0x73, 0xA5}; + const char pressedSource[] = { + '\x65', '\x32', '\xAD', '\x03', '\xA3', '\xE9', '\xB2', '\xCE', '\x63', '\x79', '\xAD', '\x35', '\xDE', '\x9D', '\x2B', '\x42', '\xC1', '\xEB', '\x08', + '\x97', '\x17', '\x52', '\x05', '\x66', '\xE2', '\xE8', '\x04', '\x9D', '\x06', '\x7B', '\x1B', '\x6A', '\xD6', '\xE9', '\x32', '\xC8', '\x4D', '\x45', + '\x1A', '\x73', '\xA5'}; thread_local EncryptedName pressedName(pressedSource); const std::string pressed(pressedName.Text()); - const std::uint8_t hoverSource[] = { - 0x47, 0xBC, 0xAB, 0x85, 0xF9, 0xC7, 0xB4, 0xC6, 0x41, 0xF7, 0xAB, 0xB3, 0x84, 0xB3, 0x2D, 0x4A, 0xE3, 0x65, 0x0E, 0x11, 0x4D, 0x7C, 0x03, 0x6E, - 0xC0, 0x66, 0x02, 0x1B, 0x5C, 0x55, 0x1D, 0x62, 0xF4, 0x67, 0x34, 0x4E, 0x17, 0x6B, 0x1C, 0x7B, 0x87}; + const char hoverSource[] = { + '\x47', '\xBC', '\xAB', '\x85', '\xF9', '\xC7', '\xB4', '\xC6', '\x41', '\xF7', '\xAB', '\xB3', '\x84', '\xB3', '\x2D', '\x4A', '\xE3', '\x65', '\x0E', + '\x11', '\x4D', '\x7C', '\x03', '\x6E', '\xC0', '\x66', '\x02', '\x1B', '\x5C', '\x55', '\x1D', '\x62', '\xF4', '\x67', '\x34', '\x4E', '\x17', '\x6B', + '\x1C', '\x7B', '\x87'}; thread_local EncryptedName hoverName(hoverSource); const std::string hover(hoverName.Text()); - const std::uint8_t normalSource[] = { - 0x09, 0x5A, 0x9F, 0x71, 0x4F, 0x1B, 0x7E, 0xEE, 0x0F, 0x11, 0x9F, 0x47, 0x32, 0x6F, 0xE7, 0x62, 0xAD, 0x83, 0x3A, 0xE5, 0xFB, 0xA0, 0xC9, 0x46, - 0x8E, 0x80, 0x36, 0xEF, 0xEA, 0x89, 0xD7, 0x4A, 0xBA, 0x81, 0x00, 0xBA, 0xA1, 0xB7, 0xD6, 0x53, 0xC9}; + const char normalSource[] = { + '\x09', '\x5A', '\x9F', '\x71', '\x4F', '\x1B', '\x7E', '\xEE', '\x0F', '\x11', '\x9F', '\x47', '\x32', '\x6F', '\xE7', '\x62', '\xAD', '\x83', '\x3A', + '\xE5', '\xFB', '\xA0', '\xC9', '\x46', '\x8E', '\x80', '\x36', '\xEF', '\xEA', '\x89', '\xD7', '\x4A', '\xBA', '\x81', '\x00', '\xBA', '\xA1', '\xB7', + '\xD6', '\x53', '\xC9'}; thread_local EncryptedName normalName(normalSource); const std::string normal(normalName.Text()); this->contents->SetImages(normal, hover, pressed, disabled); @@ -2187,45 +2204,46 @@ void CUIIntro::Slot15(int width, int height) { this->contents->scrollBar->Move(595, 0); this->contents->scrollBar->step = 44; { - const std::uint8_t downSource[] = { - 0x67, 0x5A, 0xBF, 0xC3, 0xF1, 0x85, 0xEE, 0x72, 0x61, 0x11, 0xBF, 0xF5, 0x8C, 0xF1, 0x77, 0xFE, 0xC3, 0x83, 0x1A, 0x57, 0x45, 0x3E, 0x59, 0xDA, - 0xE0, 0x80, 0x16, 0x5D, 0x54, 0x17, 0x58, 0xDC, 0xD5, 0x9A, 0x13, 0x55, 0x6E, 0x2A, 0x59, 0xCD, 0xC8, 0x82, 0x20, 0x5D, 0x5E, 0x3C, 0x45, 0x91, - 0xC5, 0x98, 0x0F, 0x39}; + const char downSource[] = { + '\x67', '\x5A', '\xBF', '\xC3', '\xF1', '\x85', '\xEE', '\x72', '\x61', '\x11', '\xBF', '\xF5', '\x8C', '\xF1', '\x77', '\xFE', '\xC3', '\x83', '\x1A', + '\x57', '\x45', '\x3E', '\x59', '\xDA', '\xE0', '\x80', '\x16', '\x5D', '\x54', '\x17', '\x58', '\xDC', '\xD5', '\x9A', '\x13', '\x55', '\x6E', '\x2A', + '\x59', '\xCD', '\xC8', '\x82', '\x20', '\x5D', '\x5E', '\x3C', '\x45', '\x91', '\xC5', '\x98', '\x0F', '\x39'}; thread_local EncryptedName downName(downSource); const std::string down(downName.Text()); - const std::uint8_t upSource[] = { - 0x21, 0xD4, 0x39, 0x2D, 0x15, 0xDD, 0xFC, 0x10, 0x27, 0x9F, 0x39, 0x1B, 0x68, 0xA9, 0x65, 0x9C, 0x85, 0x0D, 0x9C, 0xB9, 0xA1, 0x66, 0x4B, 0xB8, - 0xA6, 0x0E, 0x90, 0xB3, 0xB0, 0x4F, 0x4A, 0xBE, 0x93, 0x14, 0x95, 0xBB, 0x8A, 0x72, 0x4B, 0xAF, 0x8E, 0x0C, 0xA6, 0xA2, 0xA5, 0x3D, 0x5B, 0xB0, - 0x91, 0x7B}; + const char upSource[] = { + '\x21', '\xD4', '\x39', '\x2D', '\x15', '\xDD', '\xFC', '\x10', '\x27', '\x9F', '\x39', '\x1B', '\x68', '\xA9', '\x65', '\x9C', '\x85', '\x0D', '\x9C', + '\xB9', '\xA1', '\x66', '\x4B', '\xB8', '\xA6', '\x0E', '\x90', '\xB3', '\xB0', '\x4F', '\x4A', '\xBE', '\x93', '\x14', '\x95', '\xBB', '\x8A', '\x72', + '\x4B', '\xAF', '\x8E', '\x0C', '\xA6', '\xA2', '\xA5', '\x3D', '\x5B', '\xB0', '\x91', '\x7B'}; thread_local EncryptedName upName(upSource); const std::string up(upName.Text()); this->contents->scrollBar->SetButtonImages(up, down); } { - const std::uint8_t backgroundSource[] = { - 0x7D, 0x12, 0x2D, 0xCD, 0x7B, 0x71, 0x2A, 0x4E, 0x7B, 0x59, 0x2D, 0xFB, 0x06, 0x05, 0xB3, 0xC2, 0xD9, 0xCB, 0x88, 0x59, 0xCF, 0xCA, 0x9D, 0xE6, - 0xFA, 0xC8, 0x84, 0x53, 0xDE, 0xE3, 0x9C, 0xE0, 0xCF, 0xD2, 0x81, 0x5B, 0xE4, 0xDD, 0x88, 0xDC, 0xD0, 0xD4, 0x89, 0x19, 0xD9, 0xD2, 0x9F, 0x83}; + const char backgroundSource[] = { + '\x7D', '\x12', '\x2D', '\xCD', '\x7B', '\x71', '\x2A', '\x4E', '\x7B', '\x59', '\x2D', '\xFB', '\x06', '\x05', '\xB3', '\xC2', '\xD9', '\xCB', '\x88', + '\x59', '\xCF', '\xCA', '\x9D', '\xE6', '\xFA', '\xC8', '\x84', '\x53', '\xDE', '\xE3', '\x9C', '\xE0', '\xCF', '\xD2', '\x81', '\x5B', '\xE4', '\xDD', + '\x88', '\xDC', '\xD0', '\xD4', '\x89', '\x19', '\xD9', '\xD2', '\x9F', '\x83'}; thread_local EncryptedName backgroundName(backgroundSource); const std::string background(backgroundName.Text()); this->contents->scrollBar->SetBackground(background); } { - const std::uint8_t thumbBottomSource[] = { - 0x5F, 0x6A, 0xAD, 0x51, 0x17, 0xE7, 0x38, 0x68, 0x59, 0x21, 0xAD, 0x67, 0x6A, 0x93, 0xA1, 0xE4, 0xFB, 0xB3, 0x08, 0xC5, 0xA3, 0x5C, 0x8F, 0xC0, - 0xD8, 0xB0, 0x04, 0xCF, 0xB2, 0x75, 0x8E, 0xC6, 0xED, 0xAA, 0x01, 0xC7, 0x88, 0x5D, 0x95, 0xD0, 0xF2, 0xA7, 0x32, 0xCF, 0xB8, 0x5E, 0x93, 0x8B, - 0xFD, 0xA8, 0x1D, 0xAB}; + const char thumbBottomSource[] = { + '\x5F', '\x6A', '\xAD', '\x51', '\x17', '\xE7', '\x38', '\x68', '\x59', '\x21', '\xAD', '\x67', '\x6A', '\x93', '\xA1', '\xE4', '\xFB', '\xB3', '\x08', + '\xC5', '\xA3', '\x5C', '\x8F', '\xC0', '\xD8', '\xB0', '\x04', '\xCF', '\xB2', '\x75', '\x8E', '\xC6', '\xED', '\xAA', '\x01', '\xC7', '\x88', '\x5D', + '\x95', '\xD0', '\xF2', '\xA7', '\x32', '\xCF', '\xB8', '\x5E', '\x93', '\x8B', '\xFD', '\xA8', '\x1D', '\xAB'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xC9, 0x88, 0xEF, 0x41, 0x7D, 0x93, 0xB8, 0x14, 0xCF, 0xC3, 0xEF, 0x77, 0x00, 0xE7, 0x21, 0x98, 0x6D, 0x51, 0x4A, 0xD5, 0xC9, 0x28, 0x0F, 0xBC, - 0x4E, 0x52, 0x46, 0xDF, 0xD8, 0x01, 0x0E, 0xBA, 0x7B, 0x48, 0x43, 0xD7, 0xE2, 0x29, 0x15, 0xAC, 0x64, 0x45, 0x70, 0xD6, 0xD4, 0x39, 0x53, 0xBB, - 0x64, 0x57, 0x2F}; + const char thumbMiddleSource[] = { + '\xC9', '\x88', '\xEF', '\x41', '\x7D', '\x93', '\xB8', '\x14', '\xCF', '\xC3', '\xEF', '\x77', '\x00', '\xE7', '\x21', '\x98', '\x6D', '\x51', '\x4A', + '\xD5', '\xC9', '\x28', '\x0F', '\xBC', '\x4E', '\x52', '\x46', '\xDF', '\xD8', '\x01', '\x0E', '\xBA', '\x7B', '\x48', '\x43', '\xD7', '\xE2', '\x29', + '\x15', '\xAC', '\x64', '\x45', '\x70', '\xD6', '\xD4', '\x39', '\x53', '\xBB', '\x64', '\x57', '\x2F'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0xBF, 0xBC, 0x1F, 0x2B, 0x45, 0xA9, 0xBC, 0x20, 0xB9, 0xF7, 0x1F, 0x1D, 0x38, 0xDD, 0x25, 0xAC, 0x1B, 0x65, 0xBA, 0xBF, 0xF1, 0x12, 0x0B, 0x88, - 0x38, 0x66, 0xB6, 0xB5, 0xE0, 0x3B, 0x0A, 0x8E, 0x0D, 0x7C, 0xB3, 0xBD, 0xDA, 0x13, 0x11, 0x98, 0x12, 0x71, 0x80, 0xA4, 0xF5, 0x49, 0x1B, 0x80, - 0x0F, 0x13}; + const char thumbTopSource[] = { + '\xBF', '\xBC', '\x1F', '\x2B', '\x45', '\xA9', '\xBC', '\x20', '\xB9', '\xF7', '\x1F', '\x1D', '\x38', '\xDD', '\x25', '\xAC', '\x1B', '\x65', '\xBA', + '\xBF', '\xF1', '\x12', '\x0B', '\x88', '\x38', '\x66', '\xB6', '\xB5', '\xE0', '\x3B', '\x0A', '\x8E', '\x0D', '\x7C', '\xB3', '\xBD', '\xDA', '\x13', + '\x11', '\x98', '\x12', '\x71', '\x80', '\xA4', '\xF5', '\x49', '\x1B', '\x80', '\x0F', '\x13'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); this->contents->scrollBar->SetThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -2246,24 +2264,28 @@ void CUIItem::Slot15(int width, int height) { this->itemList->onSelect = [this](CUIItemInfo* item, const CItemData& data) { this->OnSelectItem(item, data); }; this->itemList->binder = [this](CUIItemInfo* item, const CItemData& data) { this->BindItem(item, data); }; { - const std::uint8_t listDisabledSource[] = { - 0xD1, 0x4C, 0x93, 0x63, 0x71, 0x93, 0xB0, 0x86, 0xD7, 0x07, 0x93, 0x55, 0x0C, 0xE7, 0x29, 0x0A, 0x75, 0x95, 0x36, 0xF7, 0xC5, 0x28, 0x07, 0x2E, - 0x56, 0x96, 0x3A, 0xFD, 0xD4, 0x01, 0x19, 0x22, 0x62, 0x97, 0x0C, 0xAA, 0xEE, 0x33, 0x1A, 0x39, 0x7C, 0x82, 0x3F, 0xB7, 0xD3, 0x30, 0x05, 0x4B}; + const char listDisabledSource[] = { + '\xD1', '\x4C', '\x93', '\x63', '\x71', '\x93', '\xB0', '\x86', '\xD7', '\x07', '\x93', '\x55', '\x0C', '\xE7', '\x29', '\x0A', '\x75', '\x95', '\x36', + '\xF7', '\xC5', '\x28', '\x07', '\x2E', '\x56', '\x96', '\x3A', '\xFD', '\xD4', '\x01', '\x19', '\x22', '\x62', '\x97', '\x0C', '\xAA', '\xEE', '\x33', + '\x1A', '\x39', '\x7C', '\x82', '\x3F', '\xB7', '\xD3', '\x30', '\x05', '\x4B'}; thread_local EncryptedName listDisabledName(listDisabledSource); const std::string listDisabled(listDisabledName.Text()); - const std::uint8_t listOverSource[] = { - 0xFB, 0x48, 0xC1, 0xE1, 0x01, 0x6F, 0xEE, 0x70, 0xFD, 0x03, 0xC1, 0xD7, 0x7C, 0x1B, 0x77, 0xFC, 0x5F, 0x91, 0x64, 0x75, 0xB5, 0xD4, 0x59, 0xD8, - 0x7C, 0x92, 0x68, 0x7F, 0xA4, 0xFD, 0x47, 0xD4, 0x48, 0x93, 0x5E, 0x28, 0x9E, 0xCE, 0x5D, 0xD8, 0x49, 0xC9, 0x63, 0x76, 0xB1, 0xA1}; + const char listOverSource[] = { + '\xFB', '\x48', '\xC1', '\xE1', '\x01', '\x6F', '\xEE', '\x70', '\xFD', '\x03', '\xC1', '\xD7', '\x7C', '\x1B', '\x77', '\xFC', '\x5F', '\x91', '\x64', + '\x75', '\xB5', '\xD4', '\x59', '\xD8', '\x7C', '\x92', '\x68', '\x7F', '\xA4', '\xFD', '\x47', '\xD4', '\x48', '\x93', '\x5E', '\x28', '\x9E', '\xCE', + '\x5D', '\xD8', '\x49', '\xC9', '\x63', '\x76', '\xB1', '\xA1'}; thread_local EncryptedName listOverName(listOverSource); const std::string listOver(listOverName.Text()); - const std::uint8_t listPressSource[] = { - 0x79, 0x82, 0xFD, 0xC9, 0x4D, 0x5D, 0xD0, 0x20, 0x7F, 0xC9, 0xFD, 0xFF, 0x30, 0x29, 0x49, 0xAC, 0xDD, 0x5B, 0x58, 0x5D, 0xF9, 0xE6, 0x67, 0x88, - 0xFE, 0x58, 0x54, 0x57, 0xE8, 0xCF, 0x79, 0x84, 0xCA, 0x59, 0x62, 0x00, 0xD2, 0xE3, 0x67, 0x88, 0xCA, 0x5E, 0x13, 0x51, 0xE0, 0xE3, 0x15}; + const char listPressSource[] = { + '\x79', '\x82', '\xFD', '\xC9', '\x4D', '\x5D', '\xD0', '\x20', '\x7F', '\xC9', '\xFD', '\xFF', '\x30', '\x29', '\x49', '\xAC', '\xDD', '\x5B', '\x58', + '\x5D', '\xF9', '\xE6', '\x67', '\x88', '\xFE', '\x58', '\x54', '\x57', '\xE8', '\xCF', '\x79', '\x84', '\xCA', '\x59', '\x62', '\x00', '\xD2', '\xE3', + '\x67', '\x88', '\xCA', '\x5E', '\x13', '\x51', '\xE0', '\xE3', '\x15'}; thread_local EncryptedName listPressName(listPressSource); const std::string listPress(listPressName.Text()); - const std::uint8_t listNormalSource[] = { - 0x83, 0x96, 0x9B, 0x91, 0xA7, 0xE3, 0xB4, 0x04, 0x85, 0xDD, 0x9B, 0xA7, 0xDA, 0x97, 0x2D, 0x88, 0x27, 0x4F, 0x3E, 0x05, 0x13, 0x58, 0x03, 0xAC, - 0x04, 0x4C, 0x32, 0x0F, 0x02, 0x71, 0x1D, 0xA0, 0x30, 0x4D, 0x04, 0x58, 0x38, 0x43, 0x1E, 0xBB, 0x2E, 0x58, 0x37, 0x45, 0x05, 0x40, 0x01, 0xC9}; + const char listNormalSource[] = { + '\x83', '\x96', '\x9B', '\x91', '\xA7', '\xE3', '\xB4', '\x04', '\x85', '\xDD', '\x9B', '\xA7', '\xDA', '\x97', '\x2D', '\x88', '\x27', '\x4F', '\x3E', + '\x05', '\x13', '\x58', '\x03', '\xAC', '\x04', '\x4C', '\x32', '\x0F', '\x02', '\x71', '\x1D', '\xA0', '\x30', '\x4D', '\x04', '\x58', '\x38', '\x43', + '\x1E', '\xBB', '\x2E', '\x58', '\x37', '\x45', '\x05', '\x40', '\x01', '\xC9'}; thread_local EncryptedName listNormalName(listNormalSource); const std::string listNormal(listNormalName.Text()); this->itemList->SetImages(listNormal, listPress, listOver, listDisabled); @@ -2274,45 +2296,46 @@ void CUIItem::Slot15(int width, int height) { this->itemList->scrollBar->Move(619, 0); this->itemList->scrollBar->step = 20; { - const std::uint8_t downSource[] = { - 0xB3, 0x88, 0x8D, 0xB7, 0x39, 0xA1, 0xC0, 0x1C, 0xB5, 0xC3, 0x8D, 0x81, 0x44, 0xD5, 0x59, 0x90, 0x17, 0x51, 0x28, 0x23, 0x8D, 0x1A, 0x77, 0xB4, - 0x34, 0x52, 0x24, 0x29, 0x9C, 0x33, 0x76, 0xB2, 0x01, 0x48, 0x21, 0x21, 0xA6, 0x0E, 0x77, 0xA3, 0x1C, 0x50, 0x12, 0x29, 0x96, 0x18, 0x6B, 0xFF, - 0x11, 0x4A, 0x3D, 0x4D}; + const char downSource[] = { + '\xB3', '\x88', '\x8D', '\xB7', '\x39', '\xA1', '\xC0', '\x1C', '\xB5', '\xC3', '\x8D', '\x81', '\x44', '\xD5', '\x59', '\x90', '\x17', '\x51', '\x28', + '\x23', '\x8D', '\x1A', '\x77', '\xB4', '\x34', '\x52', '\x24', '\x29', '\x9C', '\x33', '\x76', '\xB2', '\x01', '\x48', '\x21', '\x21', '\xA6', '\x0E', + '\x77', '\xA3', '\x1C', '\x50', '\x12', '\x29', '\x96', '\x18', '\x6B', '\xFF', '\x11', '\x4A', '\x3D', '\x4D'}; thread_local EncryptedName downName(downSource); const std::string down(downName.Text()); - const std::uint8_t upSource[] = { - 0x2B, 0xF0, 0xC9, 0xC9, 0xBF, 0x6F, 0xF4, 0x8E, 0x2D, 0xBB, 0xC9, 0xFF, 0xC2, 0x1B, 0x6D, 0x02, 0x8F, 0x29, 0x6C, 0x5D, 0x0B, 0xD4, 0x43, 0x26, - 0xAC, 0x2A, 0x60, 0x57, 0x1A, 0xFD, 0x42, 0x20, 0x99, 0x30, 0x65, 0x5F, 0x20, 0xC0, 0x43, 0x31, 0x84, 0x28, 0x56, 0x46, 0x0F, 0x8F, 0x53, 0x2E, - 0x9B, 0x5F}; + const char upSource[] = { + '\x2B', '\xF0', '\xC9', '\xC9', '\xBF', '\x6F', '\xF4', '\x8E', '\x2D', '\xBB', '\xC9', '\xFF', '\xC2', '\x1B', '\x6D', '\x02', '\x8F', '\x29', '\x6C', + '\x5D', '\x0B', '\xD4', '\x43', '\x26', '\xAC', '\x2A', '\x60', '\x57', '\x1A', '\xFD', '\x42', '\x20', '\x99', '\x30', '\x65', '\x5F', '\x20', '\xC0', + '\x43', '\x31', '\x84', '\x28', '\x56', '\x46', '\x0F', '\x8F', '\x53', '\x2E', '\x9B', '\x5F'}; thread_local EncryptedName upName(upSource); const std::string up(upName.Text()); this->itemList->scrollBar->SetButtonImages(up, down); } { - const std::uint8_t backgroundSource[] = { - 0xD7, 0x76, 0xF3, 0x53, 0xB9, 0x29, 0x52, 0xC2, 0xD1, 0x3D, 0xF3, 0x65, 0xC4, 0x5D, 0xCB, 0x4E, 0x73, 0xAF, 0x56, 0xC7, 0x0D, 0x92, 0xE5, 0x6A, - 0x50, 0xAC, 0x5A, 0xCD, 0x1C, 0xBB, 0xE4, 0x6C, 0x65, 0xB6, 0x5F, 0xC5, 0x26, 0x85, 0xF0, 0x50, 0x7A, 0xB0, 0x57, 0x87, 0x1B, 0x8A, 0xE7, 0x0F}; + const char backgroundSource[] = { + '\xD7', '\x76', '\xF3', '\x53', '\xB9', '\x29', '\x52', '\xC2', '\xD1', '\x3D', '\xF3', '\x65', '\xC4', '\x5D', '\xCB', '\x4E', '\x73', '\xAF', '\x56', + '\xC7', '\x0D', '\x92', '\xE5', '\x6A', '\x50', '\xAC', '\x5A', '\xCD', '\x1C', '\xBB', '\xE4', '\x6C', '\x65', '\xB6', '\x5F', '\xC5', '\x26', '\x85', + '\xF0', '\x50', '\x7A', '\xB0', '\x57', '\x87', '\x1B', '\x8A', '\xE7', '\x0F'}; thread_local EncryptedName backgroundName(backgroundSource); const std::string background(backgroundName.Text()); this->itemList->scrollBar->SetBackground(background); } { - const std::uint8_t thumbBottomSource[] = { - 0xB5, 0x90, 0xA1, 0x51, 0xEF, 0xBF, 0x22, 0x90, 0xB3, 0xDB, 0xA1, 0x67, 0x92, 0xCB, 0xBB, 0x1C, 0x11, 0x49, 0x04, 0xC5, 0x5B, 0x04, 0x95, 0x38, - 0x32, 0x4A, 0x08, 0xCF, 0x4A, 0x2D, 0x94, 0x3E, 0x07, 0x50, 0x0D, 0xC7, 0x70, 0x05, 0x8F, 0x28, 0x18, 0x5D, 0x3E, 0xCF, 0x40, 0x06, 0x89, 0x73, - 0x17, 0x52, 0x11, 0xAB}; + const char thumbBottomSource[] = { + '\xB5', '\x90', '\xA1', '\x51', '\xEF', '\xBF', '\x22', '\x90', '\xB3', '\xDB', '\xA1', '\x67', '\x92', '\xCB', '\xBB', '\x1C', '\x11', '\x49', '\x04', + '\xC5', '\x5B', '\x04', '\x95', '\x38', '\x32', '\x4A', '\x08', '\xCF', '\x4A', '\x2D', '\x94', '\x3E', '\x07', '\x50', '\x0D', '\xC7', '\x70', '\x05', + '\x8F', '\x28', '\x18', '\x5D', '\x3E', '\xCF', '\x40', '\x06', '\x89', '\x73', '\x17', '\x52', '\x11', '\xAB'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0x51, 0xC4, 0xAB, 0xE5, 0x43, 0x05, 0x0A, 0x8C, 0x57, 0x8F, 0xAB, 0xD3, 0x3E, 0x71, 0x93, 0x00, 0xF5, 0x1D, 0x0E, 0x71, 0xF7, 0xBE, 0xBD, 0x24, - 0xD6, 0x1E, 0x02, 0x7B, 0xE6, 0x97, 0xBC, 0x22, 0xE3, 0x04, 0x07, 0x73, 0xDC, 0xBF, 0xA7, 0x34, 0xFC, 0x09, 0x34, 0x72, 0xEA, 0xAF, 0xE1, 0x23, - 0xFC, 0x1B, 0x6B}; + const char thumbMiddleSource[] = { + '\x51', '\xC4', '\xAB', '\xE5', '\x43', '\x05', '\x0A', '\x8C', '\x57', '\x8F', '\xAB', '\xD3', '\x3E', '\x71', '\x93', '\x00', '\xF5', '\x1D', '\x0E', + '\x71', '\xF7', '\xBE', '\xBD', '\x24', '\xD6', '\x1E', '\x02', '\x7B', '\xE6', '\x97', '\xBC', '\x22', '\xE3', '\x04', '\x07', '\x73', '\xDC', '\xBF', + '\xA7', '\x34', '\xFC', '\x09', '\x34', '\x72', '\xEA', '\xAF', '\xE1', '\x23', '\xFC', '\x1B', '\x6B'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x81, 0x7E, 0x21, 0x19, 0xAB, 0x87, 0x4C, 0xFA, 0x87, 0x35, 0x21, 0x2F, 0xD6, 0xF3, 0xD5, 0x76, 0x25, 0xA7, 0x84, 0x8D, 0x1F, 0x3C, 0xFB, 0x52, - 0x06, 0xA4, 0x88, 0x87, 0x0E, 0x15, 0xFA, 0x54, 0x33, 0xBE, 0x8D, 0x8F, 0x34, 0x3D, 0xE1, 0x42, 0x2C, 0xB3, 0xBE, 0x96, 0x1B, 0x67, 0xEB, 0x5A, - 0x31, 0xD1}; + const char thumbTopSource[] = { + '\x81', '\x7E', '\x21', '\x19', '\xAB', '\x87', '\x4C', '\xFA', '\x87', '\x35', '\x21', '\x2F', '\xD6', '\xF3', '\xD5', '\x76', '\x25', '\xA7', '\x84', + '\x8D', '\x1F', '\x3C', '\xFB', '\x52', '\x06', '\xA4', '\x88', '\x87', '\x0E', '\x15', '\xFA', '\x54', '\x33', '\xBE', '\x8D', '\x8F', '\x34', '\x3D', + '\xE1', '\x42', '\x2C', '\xB3', '\xBE', '\x96', '\x1B', '\x67', '\xEB', '\x5A', '\x31', '\xD1'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); this->itemList->scrollBar->SetThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -2327,27 +2350,28 @@ void CUIItem::Slot15(int width, int height) { this->unknown_0084->disabled = 0; this->unknown_0084->Invalidate(); { - const std::uint8_t findDisableSource[] = { - 0xE7, 0x0A, 0x53, 0x65, 0xC1, 0x9D, 0xA4, 0x60, 0xE1, 0x41, 0x53, 0x53, 0xBC, 0xE9, 0x3D, 0xEC, 0x43, 0xD3, 0xF6, 0xF1, 0x75, 0x26, 0x13, 0xC8, - 0x60, 0xD0, 0xFA, 0xFB, 0x64, 0x0F, 0x03, 0xD9, 0x49, 0xFA, 0xF5, 0xF6, 0x6F, 0x37, 0x3E, 0xC9, 0x4E, 0xD6, 0xF2, 0xFD, 0x6D, 0x36, 0x4F, 0xCF, - 0x4A, 0xD5, 0x93}; + const char findDisableSource[] = { + '\xE7', '\x0A', '\x53', '\x65', '\xC1', '\x9D', '\xA4', '\x60', '\xE1', '\x41', '\x53', '\x53', '\xBC', '\xE9', '\x3D', '\xEC', '\x43', '\xD3', '\xF6', + '\xF1', '\x75', '\x26', '\x13', '\xC8', '\x60', '\xD0', '\xFA', '\xFB', '\x64', '\x0F', '\x03', '\xD9', '\x49', '\xFA', '\xF5', '\xF6', '\x6F', '\x37', + '\x3E', '\xC9', '\x4E', '\xD6', '\xF2', '\xFD', '\x6D', '\x36', '\x4F', '\xCF', '\x4A', '\xD5', '\x93'}; thread_local EncryptedName findDisableName(findDisableSource); const std::string findDisable(findDisableName.Text()); - const std::uint8_t findOverSource[] = { - 0xBF, 0xF4, 0xB5, 0x5F, 0x67, 0x3B, 0x24, 0x48, 0xB9, 0xBF, 0xB5, 0x69, 0x1A, 0x4F, 0xBD, 0xC4, 0x1B, 0x2D, 0x10, 0xCB, 0xD3, 0x80, 0x93, 0xE0, - 0x38, 0x2E, 0x1C, 0xC1, 0xC2, 0xA9, 0x83, 0xF1, 0x11, 0x04, 0x13, 0xCC, 0xC9, 0x91, 0xBE, 0xEA, 0x09, 0x3E, 0x07, 0x8B, 0xC5, 0x98, 0x91, 0x85}; + const char findOverSource[] = { + '\xBF', '\xF4', '\xB5', '\x5F', '\x67', '\x3B', '\x24', '\x48', '\xB9', '\xBF', '\xB5', '\x69', '\x1A', '\x4F', '\xBD', '\xC4', '\x1B', '\x2D', '\x10', + '\xCB', '\xD3', '\x80', '\x93', '\xE0', '\x38', '\x2E', '\x1C', '\xC1', '\xC2', '\xA9', '\x83', '\xF1', '\x11', '\x04', '\x13', '\xCC', '\xC9', '\x91', + '\xBE', '\xEA', '\x09', '\x3E', '\x07', '\x8B', '\xC5', '\x98', '\x91', '\x85'}; thread_local EncryptedName findOverName(findOverSource); const std::string findOver(findOverName.Text()); - const std::uint8_t findPressSource[] = { - 0x0B, 0x42, 0x73, 0xD1, 0x47, 0xFF, 0x88, 0x88, 0x0D, 0x09, 0x73, 0xE7, 0x3A, 0x8B, 0x11, 0x04, 0xAF, 0x9B, 0xD6, 0x45, 0xF3, 0x44, 0x3F, 0x20, - 0x8C, 0x98, 0xDA, 0x4F, 0xE2, 0x6D, 0x2F, 0x31, 0xA5, 0xB2, 0xD5, 0x42, 0xE9, 0x55, 0x12, 0x35, 0xB9, 0x88, 0xC0, 0x58, 0xA9, 0x53, 0x20, 0x35, - 0xCB}; + const char findPressSource[] = { + '\x0B', '\x42', '\x73', '\xD1', '\x47', '\xFF', '\x88', '\x88', '\x0D', '\x09', '\x73', '\xE7', '\x3A', '\x8B', '\x11', '\x04', '\xAF', '\x9B', '\xD6', + '\x45', '\xF3', '\x44', '\x3F', '\x20', '\x8C', '\x98', '\xDA', '\x4F', '\xE2', '\x6D', '\x2F', '\x31', '\xA5', '\xB2', '\xD5', '\x42', '\xE9', '\x55', + '\x12', '\x35', '\xB9', '\x88', '\xC0', '\x58', '\xA9', '\x53', '\x20', '\x35', '\xCB'}; thread_local EncryptedName findPressName(findPressSource); const std::string findPress(findPressName.Text()); - const std::uint8_t findNormalSource[] = { - 0xC1, 0xA2, 0x87, 0xA7, 0x2D, 0x43, 0x30, 0x4C, 0xC7, 0xE9, 0x87, 0x91, 0x50, 0x37, 0xA9, 0xC0, 0x65, 0x7B, 0x22, 0x33, 0x99, 0xF8, 0x87, 0xE4, - 0x46, 0x78, 0x2E, 0x39, 0x88, 0xD1, 0x97, 0xF5, 0x6F, 0x52, 0x21, 0x34, 0x83, 0xE9, 0xAA, 0xEF, 0x6E, 0x7F, 0x2A, 0x3C, 0x81, 0xA3, 0x97, 0xEC, - 0x71, 0x0D}; + const char findNormalSource[] = { + '\xC1', '\xA2', '\x87', '\xA7', '\x2D', '\x43', '\x30', '\x4C', '\xC7', '\xE9', '\x87', '\x91', '\x50', '\x37', '\xA9', '\xC0', '\x65', '\x7B', '\x22', + '\x33', '\x99', '\xF8', '\x87', '\xE4', '\x46', '\x78', '\x2E', '\x39', '\x88', '\xD1', '\x97', '\xF5', '\x6F', '\x52', '\x21', '\x34', '\x83', '\xE9', + '\xAA', '\xEF', '\x6E', '\x7F', '\x2A', '\x3C', '\x81', '\xA3', '\x97', '\xEC', '\x71', '\x0D'}; thread_local EncryptedName findNormalName(findNormalSource); const std::string findNormal(findNormalName.Text()); this->unknown_0084->SetImages(findNormal, findPress, findOver, findDisable); @@ -2361,27 +2385,28 @@ void CUIItem::Slot15(int width, int height) { this->unknown_0088->disabled = 0; this->unknown_0088->Invalidate(); { - const std::uint8_t moveDisableSource[] = { - 0x09, 0xAE, 0x2D, 0x15, 0x27, 0xA7, 0xDA, 0x6E, 0x0F, 0xE5, 0x2D, 0x23, 0x5A, 0xD3, 0x43, 0xE2, 0xAD, 0x77, 0x88, 0x81, 0x93, 0x1C, 0x6D, 0xC6, - 0x8E, 0x74, 0x84, 0x8B, 0x82, 0x35, 0x7D, 0xD7, 0xA7, 0x5E, 0x80, 0x80, 0x91, 0x0C, 0x40, 0xC7, 0xA0, 0x72, 0x8C, 0x8D, 0x8B, 0x0C, 0x31, 0xC1, - 0xA4, 0x71, 0xED}; + const char moveDisableSource[] = { + '\x09', '\xAE', '\x2D', '\x15', '\x27', '\xA7', '\xDA', '\x6E', '\x0F', '\xE5', '\x2D', '\x23', '\x5A', '\xD3', '\x43', '\xE2', '\xAD', '\x77', '\x88', + '\x81', '\x93', '\x1C', '\x6D', '\xC6', '\x8E', '\x74', '\x84', '\x8B', '\x82', '\x35', '\x7D', '\xD7', '\xA7', '\x5E', '\x80', '\x80', '\x91', '\x0C', + '\x40', '\xC7', '\xA0', '\x72', '\x8C', '\x8D', '\x8B', '\x0C', '\x31', '\xC1', '\xA4', '\x71', '\xED'}; thread_local EncryptedName moveDisableName(moveDisableSource); const std::string moveDisable(moveDisableName.Text()); - const std::uint8_t moveOverSource[] = { - 0xAB, 0xE4, 0x7B, 0xFB, 0x47, 0xA1, 0x6C, 0x7A, 0xAD, 0xAF, 0x7B, 0xCD, 0x3A, 0xD5, 0xF5, 0xF6, 0x0F, 0x3D, 0xDE, 0x6F, 0xF3, 0x1A, 0xDB, 0xD2, - 0x2C, 0x3E, 0xD2, 0x65, 0xE2, 0x33, 0xCB, 0xC3, 0x05, 0x14, 0xD6, 0x6E, 0xF1, 0x0A, 0xF6, 0xD8, 0x1D, 0x2E, 0xC9, 0x2F, 0xE5, 0x02, 0xD9, 0xB7}; + const char moveOverSource[] = { + '\xAB', '\xE4', '\x7B', '\xFB', '\x47', '\xA1', '\x6C', '\x7A', '\xAD', '\xAF', '\x7B', '\xCD', '\x3A', '\xD5', '\xF5', '\xF6', '\x0F', '\x3D', '\xDE', + '\x6F', '\xF3', '\x1A', '\xDB', '\xD2', '\x2C', '\x3E', '\xD2', '\x65', '\xE2', '\x33', '\xCB', '\xC3', '\x05', '\x14', '\xD6', '\x6E', '\xF1', '\x0A', + '\xF6', '\xD8', '\x1D', '\x2E', '\xC9', '\x2F', '\xE5', '\x02', '\xD9', '\xB7'}; thread_local EncryptedName moveOverName(moveOverSource); const std::string moveOver(moveOverName.Text()); - const std::uint8_t movePressSource[] = { - 0xFD, 0xD2, 0x95, 0xDB, 0x01, 0xBB, 0x5C, 0xA8, 0xFB, 0x99, 0x95, 0xED, 0x7C, 0xCF, 0xC5, 0x24, 0x59, 0x0B, 0x30, 0x4F, 0xB5, 0x00, 0xEB, 0x00, - 0x7A, 0x08, 0x3C, 0x45, 0xA4, 0x29, 0xFB, 0x11, 0x53, 0x22, 0x38, 0x4E, 0xB7, 0x10, 0xC6, 0x15, 0x4F, 0x18, 0x26, 0x52, 0xEF, 0x17, 0xF4, 0x15, - 0x3D}; + const char movePressSource[] = { + '\xFD', '\xD2', '\x95', '\xDB', '\x01', '\xBB', '\x5C', '\xA8', '\xFB', '\x99', '\x95', '\xED', '\x7C', '\xCF', '\xC5', '\x24', '\x59', '\x0B', '\x30', + '\x4F', '\xB5', '\x00', '\xEB', '\x00', '\x7A', '\x08', '\x3C', '\x45', '\xA4', '\x29', '\xFB', '\x11', '\x53', '\x22', '\x38', '\x4E', '\xB7', '\x10', + '\xC6', '\x15', '\x4F', '\x18', '\x26', '\x52', '\xEF', '\x17', '\xF4', '\x15', '\x3D'}; thread_local EncryptedName movePressName(movePressSource); const std::string movePress(movePressName.Text()); - const std::uint8_t moveNormalSource[] = { - 0x99, 0xD0, 0x67, 0x5B, 0xD7, 0x0B, 0x30, 0x72, 0x9F, 0x9B, 0x67, 0x6D, 0xAA, 0x7F, 0xA9, 0xFE, 0x3D, 0x09, 0xC2, 0xCF, 0x63, 0xB0, 0x87, 0xDA, - 0x1E, 0x0A, 0xCE, 0xC5, 0x72, 0x99, 0x97, 0xCB, 0x37, 0x20, 0xCA, 0xCE, 0x61, 0xA0, 0xAA, 0xD1, 0x36, 0x0D, 0xCA, 0xC0, 0x7B, 0xEB, 0x97, 0xD2, - 0x29, 0x7F}; + const char moveNormalSource[] = { + '\x99', '\xD0', '\x67', '\x5B', '\xD7', '\x0B', '\x30', '\x72', '\x9F', '\x9B', '\x67', '\x6D', '\xAA', '\x7F', '\xA9', '\xFE', '\x3D', '\x09', '\xC2', + '\xCF', '\x63', '\xB0', '\x87', '\xDA', '\x1E', '\x0A', '\xCE', '\xC5', '\x72', '\x99', '\x97', '\xCB', '\x37', '\x20', '\xCA', '\xCE', '\x61', '\xA0', + '\xAA', '\xD1', '\x36', '\x0D', '\xCA', '\xC0', '\x7B', '\xEB', '\x97', '\xD2', '\x29', '\x7F'}; thread_local EncryptedName moveNormalName(moveNormalSource); const std::string moveNormal(moveNormalName.Text()); this->unknown_0088->SetImages(moveNormal, movePress, moveOver, moveDisable); @@ -2401,24 +2426,28 @@ void CUIQuest::Slot15(int width, int height) { this->questList->onSelect = [this](CUIQuestInfo* item, const CQuestInfo& data) { this->OnSelectQuest(item, data); }; this->questList->binder = [this](CUIQuestInfo* item, const CQuestInfo& data) { BindQuestInfo(item, data); }; { - const std::uint8_t listDisabledSource[] = { - 0xD7, 0xB4, 0xED, 0x59, 0x7D, 0x25, 0x84, 0xC2, 0xD1, 0xFF, 0xED, 0x6F, 0x00, 0x51, 0x1D, 0x4E, 0x73, 0x6D, 0x48, 0xCD, 0xC9, 0x9E, 0x33, 0x6A, - 0x50, 0x6E, 0x44, 0xC7, 0xD8, 0xB7, 0x2D, 0x66, 0x64, 0x6F, 0x72, 0x91, 0xE2, 0x85, 0x2E, 0x7D, 0x7A, 0x7A, 0x41, 0x8D, 0xDF, 0x86, 0x31, 0x0F}; + const char listDisabledSource[] = { + '\xD7', '\xB4', '\xED', '\x59', '\x7D', '\x25', '\x84', '\xC2', '\xD1', '\xFF', '\xED', '\x6F', '\x00', '\x51', '\x1D', '\x4E', '\x73', '\x6D', '\x48', + '\xCD', '\xC9', '\x9E', '\x33', '\x6A', '\x50', '\x6E', '\x44', '\xC7', '\xD8', '\xB7', '\x2D', '\x66', '\x64', '\x6F', '\x72', '\x91', '\xE2', '\x85', + '\x2E', '\x7D', '\x7A', '\x7A', '\x41', '\x8D', '\xDF', '\x86', '\x31', '\x0F'}; thread_local EncryptedName listDisabledName(listDisabledSource); const std::string listDisabled(listDisabledName.Text()); - const std::uint8_t listOverSource[] = { - 0x01, 0xE8, 0x05, 0xED, 0x21, 0x57, 0x10, 0x36, 0x07, 0xA3, 0x05, 0xDB, 0x5C, 0x23, 0x89, 0xBA, 0xA5, 0x31, 0xA0, 0x79, 0x95, 0xEC, 0xA7, 0x9E, - 0x86, 0x32, 0xAC, 0x73, 0x84, 0xC5, 0xB9, 0x92, 0xB2, 0x33, 0x9A, 0x25, 0xBE, 0xF6, 0xA3, 0x9E, 0xB3, 0x69, 0xA7, 0x7A, 0x91, 0x99}; + const char listOverSource[] = { + '\x01', '\xE8', '\x05', '\xED', '\x21', '\x57', '\x10', '\x36', '\x07', '\xA3', '\x05', '\xDB', '\x5C', '\x23', '\x89', '\xBA', '\xA5', '\x31', '\xA0', + '\x79', '\x95', '\xEC', '\xA7', '\x9E', '\x86', '\x32', '\xAC', '\x73', '\x84', '\xC5', '\xB9', '\x92', '\xB2', '\x33', '\x9A', '\x25', '\xBE', '\xF6', + '\xA3', '\x9E', '\xB3', '\x69', '\xA7', '\x7A', '\x91', '\x99'}; thread_local EncryptedName listOverName(listOverSource); const std::string listOver(listOverName.Text()); - const std::uint8_t listPressSource[] = { - 0xA5, 0x5C, 0x17, 0xA7, 0x4D, 0xDD, 0xAA, 0xDA, 0xA3, 0x17, 0x17, 0x91, 0x30, 0xA9, 0x33, 0x56, 0x01, 0x85, 0xB2, 0x33, 0xF9, 0x66, 0x1D, 0x72, - 0x22, 0x86, 0xBE, 0x39, 0xE8, 0x4F, 0x03, 0x7E, 0x16, 0x87, 0x88, 0x6F, 0xD2, 0x63, 0x1D, 0x72, 0x16, 0x80, 0xF9, 0x3F, 0xE0, 0x63, 0x6F}; + const char listPressSource[] = { + '\xA5', '\x5C', '\x17', '\xA7', '\x4D', '\xDD', '\xAA', '\xDA', '\xA3', '\x17', '\x17', '\x91', '\x30', '\xA9', '\x33', '\x56', '\x01', '\x85', '\xB2', + '\x33', '\xF9', '\x66', '\x1D', '\x72', '\x22', '\x86', '\xBE', '\x39', '\xE8', '\x4F', '\x03', '\x7E', '\x16', '\x87', '\x88', '\x6F', '\xD2', '\x63', + '\x1D', '\x72', '\x16', '\x80', '\xF9', '\x3F', '\xE0', '\x63', '\x6F'}; thread_local EncryptedName listPressName(listPressSource); const std::string listPress(listPressName.Text()); - const std::uint8_t listNormalSource[] = { - 0x8F, 0xC8, 0x2D, 0x7F, 0xC9, 0xF9, 0xFA, 0xB4, 0x89, 0x83, 0x2D, 0x49, 0xB4, 0x8D, 0x63, 0x38, 0x2B, 0x11, 0x88, 0xEB, 0x7D, 0x42, 0x4D, 0x1C, - 0x08, 0x12, 0x84, 0xE1, 0x6C, 0x6B, 0x53, 0x10, 0x3C, 0x13, 0xB2, 0xB7, 0x56, 0x59, 0x50, 0x0B, 0x22, 0x06, 0x81, 0xAB, 0x6B, 0x5A, 0x4F, 0x79}; + const char listNormalSource[] = { + '\x8F', '\xC8', '\x2D', '\x7F', '\xC9', '\xF9', '\xFA', '\xB4', '\x89', '\x83', '\x2D', '\x49', '\xB4', '\x8D', '\x63', '\x38', '\x2B', '\x11', '\x88', + '\xEB', '\x7D', '\x42', '\x4D', '\x1C', '\x08', '\x12', '\x84', '\xE1', '\x6C', '\x6B', '\x53', '\x10', '\x3C', '\x13', '\xB2', '\xB7', '\x56', '\x59', + '\x50', '\x0B', '\x22', '\x06', '\x81', '\xAB', '\x6B', '\x5A', '\x4F', '\x79'}; thread_local EncryptedName listNormalName(listNormalSource); const std::string listNormal(listNormalName.Text()); this->questList->SetImages(listNormal, listPress, listOver, listDisabled); @@ -2429,45 +2458,46 @@ void CUIQuest::Slot15(int width, int height) { this->questList->scrollBar->Move(619, 0); this->questList->scrollBar->step = 20; { - const std::uint8_t downSource[] = { - 0xAD, 0xB4, 0x67, 0xEB, 0xB7, 0xA1, 0x0E, 0x3E, 0xAB, 0xFF, 0x67, 0xDD, 0xCA, 0xD5, 0x97, 0xB2, 0x09, 0x6D, 0xC2, 0x7F, 0x03, 0x1A, 0xB9, 0x96, - 0x2A, 0x6E, 0xCE, 0x75, 0x12, 0x33, 0xB8, 0x90, 0x1F, 0x74, 0xCB, 0x7D, 0x28, 0x0E, 0xB9, 0x81, 0x02, 0x6C, 0xF8, 0x75, 0x18, 0x18, 0xA5, 0xDD, - 0x0F, 0x76, 0xD7, 0x11}; + const char downSource[] = { + '\xAD', '\xB4', '\x67', '\xEB', '\xB7', '\xA1', '\x0E', '\x3E', '\xAB', '\xFF', '\x67', '\xDD', '\xCA', '\xD5', '\x97', '\xB2', '\x09', '\x6D', '\xC2', + '\x7F', '\x03', '\x1A', '\xB9', '\x96', '\x2A', '\x6E', '\xCE', '\x75', '\x12', '\x33', '\xB8', '\x90', '\x1F', '\x74', '\xCB', '\x7D', '\x28', '\x0E', + '\xB9', '\x81', '\x02', '\x6C', '\xF8', '\x75', '\x18', '\x18', '\xA5', '\xDD', '\x0F', '\x76', '\xD7', '\x11'}; thread_local EncryptedName downName(downSource); const std::string down(downName.Text()); - const std::uint8_t upSource[] = { - 0x2D, 0xDA, 0xA1, 0xD9, 0x77, 0x2D, 0x94, 0xE0, 0x2B, 0x91, 0xA1, 0xEF, 0x0A, 0x59, 0x0D, 0x6C, 0x89, 0x03, 0x04, 0x4D, 0xC3, 0x96, 0x23, 0x48, - 0xAA, 0x00, 0x08, 0x47, 0xD2, 0xBF, 0x22, 0x4E, 0x9F, 0x1A, 0x0D, 0x4F, 0xE8, 0x82, 0x23, 0x5F, 0x82, 0x02, 0x3E, 0x56, 0xC7, 0xCD, 0x33, 0x40, - 0x9D, 0x75}; + const char upSource[] = { + '\x2D', '\xDA', '\xA1', '\xD9', '\x77', '\x2D', '\x94', '\xE0', '\x2B', '\x91', '\xA1', '\xEF', '\x0A', '\x59', '\x0D', '\x6C', '\x89', '\x03', '\x04', + '\x4D', '\xC3', '\x96', '\x23', '\x48', '\xAA', '\x00', '\x08', '\x47', '\xD2', '\xBF', '\x22', '\x4E', '\x9F', '\x1A', '\x0D', '\x4F', '\xE8', '\x82', + '\x23', '\x5F', '\x82', '\x02', '\x3E', '\x56', '\xC7', '\xCD', '\x33', '\x40', '\x9D', '\x75'}; thread_local EncryptedName upName(upSource); const std::string up(upName.Text()); this->questList->scrollBar->SetButtonImages(up, down); } { - const std::uint8_t backgroundSource[] = { - 0x73, 0xC8, 0x99, 0x75, 0x1F, 0xE9, 0x5E, 0x4E, 0x75, 0x83, 0x99, 0x43, 0x62, 0x9D, 0xC7, 0xC2, 0xD7, 0x11, 0x3C, 0xE1, 0xAB, 0x52, 0xE9, 0xE6, - 0xF4, 0x12, 0x30, 0xEB, 0xBA, 0x7B, 0xE8, 0xE0, 0xC1, 0x08, 0x35, 0xE3, 0x80, 0x45, 0xFC, 0xDC, 0xDE, 0x0E, 0x3D, 0xA1, 0xBD, 0x4A, 0xEB, 0x83}; + const char backgroundSource[] = { + '\x73', '\xC8', '\x99', '\x75', '\x1F', '\xE9', '\x5E', '\x4E', '\x75', '\x83', '\x99', '\x43', '\x62', '\x9D', '\xC7', '\xC2', '\xD7', '\x11', '\x3C', + '\xE1', '\xAB', '\x52', '\xE9', '\xE6', '\xF4', '\x12', '\x30', '\xEB', '\xBA', '\x7B', '\xE8', '\xE0', '\xC1', '\x08', '\x35', '\xE3', '\x80', '\x45', + '\xFC', '\xDC', '\xDE', '\x0E', '\x3D', '\xA1', '\xBD', '\x4A', '\xEB', '\x83'}; thread_local EncryptedName backgroundName(backgroundSource); const std::string background(backgroundName.Text()); this->questList->scrollBar->SetBackground(background); } { - const std::uint8_t thumbBottomSource[] = { - 0x99, 0x18, 0xC7, 0xE9, 0x05, 0xB3, 0xA6, 0x82, 0x9F, 0x53, 0xC7, 0xDF, 0x78, 0xC7, 0x3F, 0x0E, 0x3D, 0xC1, 0x62, 0x7D, 0xB1, 0x08, 0x11, 0x2A, - 0x1E, 0xC2, 0x6E, 0x77, 0xA0, 0x21, 0x10, 0x2C, 0x2B, 0xD8, 0x6B, 0x7F, 0x9A, 0x09, 0x0B, 0x3A, 0x34, 0xD5, 0x58, 0x77, 0xAA, 0x0A, 0x0D, 0x61, - 0x3B, 0xDA, 0x77, 0x13}; + const char thumbBottomSource[] = { + '\x99', '\x18', '\xC7', '\xE9', '\x05', '\xB3', '\xA6', '\x82', '\x9F', '\x53', '\xC7', '\xDF', '\x78', '\xC7', '\x3F', '\x0E', '\x3D', '\xC1', '\x62', + '\x7D', '\xB1', '\x08', '\x11', '\x2A', '\x1E', '\xC2', '\x6E', '\x77', '\xA0', '\x21', '\x10', '\x2C', '\x2B', '\xD8', '\x6B', '\x7F', '\x9A', '\x09', + '\x0B', '\x3A', '\x34', '\xD5', '\x58', '\x77', '\xAA', '\x0A', '\x0D', '\x61', '\x3B', '\xDA', '\x77', '\x13'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xA5, 0xFA, 0x09, 0x85, 0xCD, 0x21, 0xEA, 0x88, 0xA3, 0xB1, 0x09, 0xB3, 0xB0, 0x55, 0x73, 0x04, 0x01, 0x23, 0xAC, 0x11, 0x79, 0x9A, 0x5D, 0x20, - 0x22, 0x20, 0xA0, 0x1B, 0x68, 0xB3, 0x5C, 0x26, 0x17, 0x3A, 0xA5, 0x13, 0x52, 0x9B, 0x47, 0x30, 0x08, 0x37, 0x96, 0x12, 0x64, 0x8B, 0x01, 0x27, - 0x08, 0x25, 0xC9}; + const char thumbMiddleSource[] = { + '\xA5', '\xFA', '\x09', '\x85', '\xCD', '\x21', '\xEA', '\x88', '\xA3', '\xB1', '\x09', '\xB3', '\xB0', '\x55', '\x73', '\x04', '\x01', '\x23', '\xAC', + '\x11', '\x79', '\x9A', '\x5D', '\x20', '\x22', '\x20', '\xA0', '\x1B', '\x68', '\xB3', '\x5C', '\x26', '\x17', '\x3A', '\xA5', '\x13', '\x52', '\x9B', + '\x47', '\x30', '\x08', '\x37', '\x96', '\x12', '\x64', '\x8B', '\x01', '\x27', '\x08', '\x25', '\xC9'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x9D, 0xA2, 0x89, 0x73, 0x61, 0xB3, 0x28, 0x52, 0x9B, 0xE9, 0x89, 0x45, 0x1C, 0xC7, 0xB1, 0xDE, 0x39, 0x7B, 0x2C, 0xE7, 0xD5, 0x08, 0x9F, 0xFA, - 0x1A, 0x78, 0x20, 0xED, 0xC4, 0x21, 0x9E, 0xFC, 0x2F, 0x62, 0x25, 0xE5, 0xFE, 0x09, 0x85, 0xEA, 0x30, 0x6F, 0x16, 0xFC, 0xD1, 0x53, 0x8F, 0xF2, - 0x2D, 0x0D}; + const char thumbTopSource[] = { + '\x9D', '\xA2', '\x89', '\x73', '\x61', '\xB3', '\x28', '\x52', '\x9B', '\xE9', '\x89', '\x45', '\x1C', '\xC7', '\xB1', '\xDE', '\x39', '\x7B', '\x2C', + '\xE7', '\xD5', '\x08', '\x9F', '\xFA', '\x1A', '\x78', '\x20', '\xED', '\xC4', '\x21', '\x9E', '\xFC', '\x2F', '\x62', '\x25', '\xE5', '\xFE', '\x09', + '\x85', '\xEA', '\x30', '\x6F', '\x16', '\xFC', '\xD1', '\x53', '\x8F', '\xF2', '\x2D', '\x0D'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); this->questList->scrollBar->SetThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -2482,27 +2512,28 @@ void CUIQuest::Slot15(int width, int height) { this->unknown_0084->disabled = 0; this->unknown_0084->Invalidate(); { - const std::uint8_t findDisableSource[] = { - 0x77, 0x9E, 0x2F, 0x39, 0xC3, 0x11, 0x5C, 0x82, 0x71, 0xD5, 0x2F, 0x0F, 0xBE, 0x65, 0xC5, 0x0E, 0xD3, 0x47, 0x8A, 0xAD, 0x77, 0xAA, 0xEB, 0x2A, - 0xF0, 0x44, 0x86, 0xA7, 0x66, 0x83, 0xFB, 0x3B, 0xD9, 0x6E, 0x89, 0xAA, 0x6D, 0xBB, 0xC6, 0x2B, 0xDE, 0x42, 0x8E, 0xA1, 0x6F, 0xBA, 0xB7, 0x2D, - 0xDA, 0x41, 0xEF}; + const char findDisableSource[] = { + '\x77', '\x9E', '\x2F', '\x39', '\xC3', '\x11', '\x5C', '\x82', '\x71', '\xD5', '\x2F', '\x0F', '\xBE', '\x65', '\xC5', '\x0E', '\xD3', '\x47', '\x8A', + '\xAD', '\x77', '\xAA', '\xEB', '\x2A', '\xF0', '\x44', '\x86', '\xA7', '\x66', '\x83', '\xFB', '\x3B', '\xD9', '\x6E', '\x89', '\xAA', '\x6D', '\xBB', + '\xC6', '\x2B', '\xDE', '\x42', '\x8E', '\xA1', '\x6F', '\xBA', '\xB7', '\x2D', '\xDA', '\x41', '\xEF'}; thread_local EncryptedName findDisableName(findDisableSource); const std::string findDisable(findDisableName.Text()); - const std::uint8_t findOverSource[] = { - 0x37, 0xBC, 0xEB, 0x55, 0x31, 0xC1, 0xD8, 0x40, 0x31, 0xF7, 0xEB, 0x63, 0x4C, 0xB5, 0x41, 0xCC, 0x93, 0x65, 0x4E, 0xC1, 0x85, 0x7A, 0x6F, 0xE8, - 0xB0, 0x66, 0x42, 0xCB, 0x94, 0x53, 0x7F, 0xF9, 0x99, 0x4C, 0x4D, 0xC6, 0x9F, 0x6B, 0x42, 0xE2, 0x81, 0x76, 0x59, 0x81, 0x93, 0x62, 0x6D, 0x8D}; + const char findOverSource[] = { + '\x37', '\xBC', '\xEB', '\x55', '\x31', '\xC1', '\xD8', '\x40', '\x31', '\xF7', '\xEB', '\x63', '\x4C', '\xB5', '\x41', '\xCC', '\x93', '\x65', '\x4E', + '\xC1', '\x85', '\x7A', '\x6F', '\xE8', '\xB0', '\x66', '\x42', '\xCB', '\x94', '\x53', '\x7F', '\xF9', '\x99', '\x4C', '\x4D', '\xC6', '\x9F', '\x6B', + '\x42', '\xE2', '\x81', '\x76', '\x59', '\x81', '\x93', '\x62', '\x6D', '\x8D'}; thread_local EncryptedName findOverName(findOverSource); const std::string findOver(findOverName.Text()); - const std::uint8_t findPressSource[] = { - 0x4D, 0x14, 0x0F, 0x81, 0x51, 0x69, 0x5A, 0x7E, 0x4B, 0x5F, 0x0F, 0xB7, 0x2C, 0x1D, 0xC3, 0xF2, 0xE9, 0xCD, 0xAA, 0x15, 0xE5, 0xD2, 0xED, 0xD6, - 0xCA, 0xCE, 0xA6, 0x1F, 0xF4, 0xFB, 0xFD, 0xC7, 0xE3, 0xE4, 0xA9, 0x12, 0xFF, 0xC3, 0xC0, 0xC3, 0xFF, 0xDE, 0xBC, 0x08, 0xBF, 0xC5, 0xF2, 0xC3, - 0x8D}; + const char findPressSource[] = { + '\x4D', '\x14', '\x0F', '\x81', '\x51', '\x69', '\x5A', '\x7E', '\x4B', '\x5F', '\x0F', '\xB7', '\x2C', '\x1D', '\xC3', '\xF2', '\xE9', '\xCD', '\xAA', + '\x15', '\xE5', '\xD2', '\xED', '\xD6', '\xCA', '\xCE', '\xA6', '\x1F', '\xF4', '\xFB', '\xFD', '\xC7', '\xE3', '\xE4', '\xA9', '\x12', '\xFF', '\xC3', + '\xC0', '\xC3', '\xFF', '\xDE', '\xBC', '\x08', '\xBF', '\xC5', '\xF2', '\xC3', '\x8D'}; thread_local EncryptedName findPressName(findPressSource); const std::string findPress(findPressName.Text()); - const std::uint8_t findNormalSource[] = { - 0x6B, 0x6E, 0x8D, 0xC3, 0xA7, 0xBB, 0x0E, 0xE0, 0x6D, 0x25, 0x8D, 0xF5, 0xDA, 0xCF, 0x97, 0x6C, 0xCF, 0xB7, 0x28, 0x57, 0x13, 0x00, 0xB9, 0x48, - 0xEC, 0xB4, 0x24, 0x5D, 0x02, 0x29, 0xA9, 0x59, 0xC5, 0x9E, 0x2B, 0x50, 0x09, 0x11, 0x94, 0x43, 0xC4, 0xB3, 0x20, 0x58, 0x0B, 0x5B, 0xA9, 0x40, - 0xDB, 0xC1}; + const char findNormalSource[] = { + '\x6B', '\x6E', '\x8D', '\xC3', '\xA7', '\xBB', '\x0E', '\xE0', '\x6D', '\x25', '\x8D', '\xF5', '\xDA', '\xCF', '\x97', '\x6C', '\xCF', '\xB7', '\x28', + '\x57', '\x13', '\x00', '\xB9', '\x48', '\xEC', '\xB4', '\x24', '\x5D', '\x02', '\x29', '\xA9', '\x59', '\xC5', '\x9E', '\x2B', '\x50', '\x09', '\x11', + '\x94', '\x43', '\xC4', '\xB3', '\x20', '\x58', '\x0B', '\x5B', '\xA9', '\x40', '\xDB', '\xC1'}; thread_local EncryptedName findNormalName(findNormalSource); const std::string findNormal(findNormalName.Text()); this->unknown_0084->SetImages(findNormal, findPress, findOver, findDisable); @@ -2516,27 +2547,28 @@ void CUIQuest::Slot15(int width, int height) { this->unknown_0088->disabled = 0; this->unknown_0088->Invalidate(); { - const std::uint8_t moveDisableSource[] = { - 0xDD, 0x68, 0x8B, 0x4F, 0x1D, 0xB9, 0x8C, 0xEE, 0xDB, 0x23, 0x8B, 0x79, 0x60, 0xCD, 0x15, 0x62, 0x79, 0xB1, 0x2E, 0xDB, 0xA9, 0x02, 0x3B, 0x46, - 0x5A, 0xB2, 0x22, 0xD1, 0xB8, 0x2B, 0x2B, 0x57, 0x73, 0x98, 0x26, 0xDA, 0xAB, 0x12, 0x16, 0x47, 0x74, 0xB4, 0x2A, 0xD7, 0xB1, 0x12, 0x67, 0x41, - 0x70, 0xB7, 0x4B}; + const char moveDisableSource[] = { + '\xDD', '\x68', '\x8B', '\x4F', '\x1D', '\xB9', '\x8C', '\xEE', '\xDB', '\x23', '\x8B', '\x79', '\x60', '\xCD', '\x15', '\x62', '\x79', '\xB1', '\x2E', + '\xDB', '\xA9', '\x02', '\x3B', '\x46', '\x5A', '\xB2', '\x22', '\xD1', '\xB8', '\x2B', '\x2B', '\x57', '\x73', '\x98', '\x26', '\xDA', '\xAB', '\x12', + '\x16', '\x47', '\x74', '\xB4', '\x2A', '\xD7', '\xB1', '\x12', '\x67', '\x41', '\x70', '\xB7', '\x4B'}; thread_local EncryptedName moveDisableName(moveDisableSource); const std::string moveDisable(moveDisableName.Text()); - const std::uint8_t moveOverSource[] = { - 0xE5, 0xDE, 0x6F, 0x31, 0xCD, 0x3D, 0xE8, 0x28, 0xE3, 0x95, 0x6F, 0x07, 0xB0, 0x49, 0x71, 0xA4, 0x41, 0x07, 0xCA, 0xA5, 0x79, 0x86, 0x5F, 0x80, - 0x62, 0x04, 0xC6, 0xAF, 0x68, 0xAF, 0x4F, 0x91, 0x4B, 0x2E, 0xC2, 0xA4, 0x7B, 0x96, 0x72, 0x8A, 0x53, 0x14, 0xDD, 0xE5, 0x6F, 0x9E, 0x5D, 0xE5}; + const char moveOverSource[] = { + '\xE5', '\xDE', '\x6F', '\x31', '\xCD', '\x3D', '\xE8', '\x28', '\xE3', '\x95', '\x6F', '\x07', '\xB0', '\x49', '\x71', '\xA4', '\x41', '\x07', '\xCA', + '\xA5', '\x79', '\x86', '\x5F', '\x80', '\x62', '\x04', '\xC6', '\xAF', '\x68', '\xAF', '\x4F', '\x91', '\x4B', '\x2E', '\xC2', '\xA4', '\x7B', '\x96', + '\x72', '\x8A', '\x53', '\x14', '\xDD', '\xE5', '\x6F', '\x9E', '\x5D', '\xE5'}; thread_local EncryptedName moveOverName(moveOverSource); const std::string moveOver(moveOverName.Text()); - const std::uint8_t movePressSource[] = { - 0x9F, 0x9A, 0x6F, 0x6F, 0x5D, 0x47, 0x36, 0x02, 0x99, 0xD1, 0x6F, 0x59, 0x20, 0x33, 0xAF, 0x8E, 0x3B, 0x43, 0xCA, 0xFB, 0xE9, 0xFC, 0x81, 0xAA, - 0x18, 0x40, 0xC6, 0xF1, 0xF8, 0xD5, 0x91, 0xBB, 0x31, 0x6A, 0xC2, 0xFA, 0xEB, 0xEC, 0xAC, 0xBF, 0x2D, 0x50, 0xDC, 0xE6, 0xB3, 0xEB, 0x9E, 0xBF, - 0x5F}; + const char movePressSource[] = { + '\x9F', '\x9A', '\x6F', '\x6F', '\x5D', '\x47', '\x36', '\x02', '\x99', '\xD1', '\x6F', '\x59', '\x20', '\x33', '\xAF', '\x8E', '\x3B', '\x43', '\xCA', + '\xFB', '\xE9', '\xFC', '\x81', '\xAA', '\x18', '\x40', '\xC6', '\xF1', '\xF8', '\xD5', '\x91', '\xBB', '\x31', '\x6A', '\xC2', '\xFA', '\xEB', '\xEC', + '\xAC', '\xBF', '\x2D', '\x50', '\xDC', '\xE6', '\xB3', '\xEB', '\x9E', '\xBF', '\x5F'}; thread_local EncryptedName movePressName(movePressSource); const std::string movePress(movePressName.Text()); - const std::uint8_t moveNormalSource[] = { - 0x37, 0x66, 0xA3, 0x93, 0xBD, 0x57, 0xB4, 0x5C, 0x31, 0x2D, 0xA3, 0xA5, 0xC0, 0x23, 0x2D, 0xD0, 0x93, 0xBF, 0x06, 0x07, 0x09, 0xEC, 0x03, 0xF4, - 0xB0, 0xBC, 0x0A, 0x0D, 0x18, 0xC5, 0x13, 0xE5, 0x99, 0x96, 0x0E, 0x06, 0x0B, 0xFC, 0x2E, 0xFF, 0x98, 0xBB, 0x0E, 0x08, 0x11, 0xB7, 0x13, 0xFC, - 0x87, 0xC9}; + const char moveNormalSource[] = { + '\x37', '\x66', '\xA3', '\x93', '\xBD', '\x57', '\xB4', '\x5C', '\x31', '\x2D', '\xA3', '\xA5', '\xC0', '\x23', '\x2D', '\xD0', '\x93', '\xBF', '\x06', + '\x07', '\x09', '\xEC', '\x03', '\xF4', '\xB0', '\xBC', '\x0A', '\x0D', '\x18', '\xC5', '\x13', '\xE5', '\x99', '\x96', '\x0E', '\x06', '\x0B', '\xFC', + '\x2E', '\xFF', '\x98', '\xBB', '\x0E', '\x08', '\x11', '\xB7', '\x13', '\xFC', '\x87', '\xC9'}; thread_local EncryptedName moveNormalName(moveNormalSource); const std::string moveNormal(moveNormalName.Text()); this->unknown_0088->SetImages(moveNormal, movePress, moveOver, moveDisable); @@ -2556,24 +2588,28 @@ void CUIMonster::Slot15(int width, int height) { this->monsterList->onSelect = [this](CUIMonsterInfo* item, const CMonsterData& data) { this->OnSelectMonster(item, data); }; this->monsterList->binder = [this](CUIMonsterInfo* item, const CMonsterData& data) { this->BindMonster(item, data); }; { - const std::uint8_t listDisabledSource[] = { - 0xF3, 0xCC, 0x95, 0x0B, 0xE9, 0xFB, 0x16, 0x84, 0xF5, 0x87, 0x95, 0x3D, 0x94, 0x8F, 0x8F, 0x08, 0x57, 0x15, 0x30, 0x9F, 0x5D, 0x40, 0xA1, 0x2C, - 0x74, 0x16, 0x3C, 0x95, 0x4C, 0x69, 0xBF, 0x20, 0x40, 0x17, 0x0A, 0xC2, 0x76, 0x5B, 0xBC, 0x3B, 0x5E, 0x02, 0x39, 0xDF, 0x4B, 0x58, 0xA3, 0x49}; + const char listDisabledSource[] = { + '\xF3', '\xCC', '\x95', '\x0B', '\xE9', '\xFB', '\x16', '\x84', '\xF5', '\x87', '\x95', '\x3D', '\x94', '\x8F', '\x8F', '\x08', '\x57', '\x15', '\x30', + '\x9F', '\x5D', '\x40', '\xA1', '\x2C', '\x74', '\x16', '\x3C', '\x95', '\x4C', '\x69', '\xBF', '\x20', '\x40', '\x17', '\x0A', '\xC2', '\x76', '\x5B', + '\xBC', '\x3B', '\x5E', '\x02', '\x39', '\xDF', '\x4B', '\x58', '\xA3', '\x49'}; thread_local EncryptedName listDisabledName(listDisabledSource); const std::string listDisabled(listDisabledName.Text()); - const std::uint8_t listOverSource[] = { - 0x75, 0x20, 0x81, 0xDF, 0xD3, 0x33, 0xEA, 0xB4, 0x73, 0x6B, 0x81, 0xE9, 0xAE, 0x47, 0x73, 0x38, 0xD1, 0xF9, 0x24, 0x4B, 0x67, 0x88, 0x5D, 0x1C, - 0xF2, 0xFA, 0x28, 0x41, 0x76, 0xA1, 0x43, 0x10, 0xC6, 0xFB, 0x1E, 0x16, 0x4C, 0x92, 0x59, 0x1C, 0xC7, 0xA1, 0x23, 0x48, 0x63, 0xFD}; + const char listOverSource[] = { + '\x75', '\x20', '\x81', '\xDF', '\xD3', '\x33', '\xEA', '\xB4', '\x73', '\x6B', '\x81', '\xE9', '\xAE', '\x47', '\x73', '\x38', '\xD1', '\xF9', '\x24', + '\x4B', '\x67', '\x88', '\x5D', '\x1C', '\xF2', '\xFA', '\x28', '\x41', '\x76', '\xA1', '\x43', '\x10', '\xC6', '\xFB', '\x1E', '\x16', '\x4C', '\x92', + '\x59', '\x1C', '\xC7', '\xA1', '\x23', '\x48', '\x63', '\xFD'}; thread_local EncryptedName listOverName(listOverSource); const std::string listOver(listOverName.Text()); - const std::uint8_t listPressSource[] = { - 0x7F, 0xC6, 0x23, 0x37, 0x45, 0x49, 0x9A, 0x3C, 0x79, 0x8D, 0x23, 0x01, 0x38, 0x3D, 0x03, 0xB0, 0xDB, 0x1F, 0x86, 0xA3, 0xF1, 0xF2, 0x2D, 0x94, - 0xF8, 0x1C, 0x8A, 0xA9, 0xE0, 0xDB, 0x33, 0x98, 0xCC, 0x1D, 0xBC, 0xFE, 0xDA, 0xF7, 0x2D, 0x94, 0xCC, 0x1A, 0xCD, 0xAF, 0xE8, 0xF7, 0x5F}; + const char listPressSource[] = { + '\x7F', '\xC6', '\x23', '\x37', '\x45', '\x49', '\x9A', '\x3C', '\x79', '\x8D', '\x23', '\x01', '\x38', '\x3D', '\x03', '\xB0', '\xDB', '\x1F', '\x86', + '\xA3', '\xF1', '\xF2', '\x2D', '\x94', '\xF8', '\x1C', '\x8A', '\xA9', '\xE0', '\xDB', '\x33', '\x98', '\xCC', '\x1D', '\xBC', '\xFE', '\xDA', '\xF7', + '\x2D', '\x94', '\xCC', '\x1A', '\xCD', '\xAF', '\xE8', '\xF7', '\x5F'}; thread_local EncryptedName listPressName(listPressSource); const std::string listPress(listPressName.Text()); - const std::uint8_t listNormalSource[] = { - 0x99, 0x2A, 0x47, 0x83, 0x37, 0xE1, 0xFA, 0x2E, 0x9F, 0x61, 0x47, 0xB5, 0x4A, 0x95, 0x63, 0xA2, 0x3D, 0xF3, 0xE2, 0x17, 0x83, 0x5A, 0x4D, 0x86, - 0x1E, 0xF0, 0xEE, 0x1D, 0x92, 0x73, 0x53, 0x8A, 0x2A, 0xF1, 0xD8, 0x4A, 0xA8, 0x41, 0x50, 0x91, 0x34, 0xE4, 0xEB, 0x57, 0x95, 0x42, 0x4F, 0xE3}; + const char listNormalSource[] = { + '\x99', '\x2A', '\x47', '\x83', '\x37', '\xE1', '\xFA', '\x2E', '\x9F', '\x61', '\x47', '\xB5', '\x4A', '\x95', '\x63', '\xA2', '\x3D', '\xF3', '\xE2', + '\x17', '\x83', '\x5A', '\x4D', '\x86', '\x1E', '\xF0', '\xEE', '\x1D', '\x92', '\x73', '\x53', '\x8A', '\x2A', '\xF1', '\xD8', '\x4A', '\xA8', '\x41', + '\x50', '\x91', '\x34', '\xE4', '\xEB', '\x57', '\x95', '\x42', '\x4F', '\xE3'}; thread_local EncryptedName listNormalName(listNormalSource); const std::string listNormal(listNormalName.Text()); this->monsterList->SetImages(listNormal, listPress, listOver, listDisabled); @@ -2584,45 +2620,46 @@ void CUIMonster::Slot15(int width, int height) { this->monsterList->scrollBar->Move(619, 0); this->monsterList->scrollBar->step = 20; { - const std::uint8_t downSource[] = { - 0x57, 0x66, 0x09, 0x61, 0x0D, 0x75, 0x74, 0x08, 0x51, 0x2D, 0x09, 0x57, 0x70, 0x01, 0xED, 0x84, 0xF3, 0xBF, 0xAC, 0xF5, 0xB9, 0xCE, 0xC3, 0xA0, - 0xD0, 0xBC, 0xA0, 0xFF, 0xA8, 0xE7, 0xC2, 0xA6, 0xE5, 0xA6, 0xA5, 0xF7, 0x92, 0xDA, 0xC3, 0xB7, 0xF8, 0xBE, 0x96, 0xFF, 0xA2, 0xCC, 0xDF, 0xEB, - 0xF5, 0xA4, 0xB9, 0x9B}; + const char downSource[] = { + '\x57', '\x66', '\x09', '\x61', '\x0D', '\x75', '\x74', '\x08', '\x51', '\x2D', '\x09', '\x57', '\x70', '\x01', '\xED', '\x84', '\xF3', '\xBF', '\xAC', + '\xF5', '\xB9', '\xCE', '\xC3', '\xA0', '\xD0', '\xBC', '\xA0', '\xFF', '\xA8', '\xE7', '\xC2', '\xA6', '\xE5', '\xA6', '\xA5', '\xF7', '\x92', '\xDA', + '\xC3', '\xB7', '\xF8', '\xBE', '\x96', '\xFF', '\xA2', '\xCC', '\xDF', '\xEB', '\xF5', '\xA4', '\xB9', '\x9B'}; thread_local EncryptedName downName(downSource); const std::string down(downName.Text()); - const std::uint8_t upSource[] = { - 0xF1, 0x56, 0x13, 0x03, 0xDD, 0x81, 0x0E, 0xCC, 0xF7, 0x1D, 0x13, 0x35, 0xA0, 0xF5, 0x97, 0x40, 0x55, 0x8F, 0xB6, 0x97, 0x69, 0x3A, 0xB9, 0x64, - 0x76, 0x8C, 0xBA, 0x9D, 0x78, 0x13, 0xB8, 0x62, 0x43, 0x96, 0xBF, 0x95, 0x42, 0x2E, 0xB9, 0x73, 0x5E, 0x8E, 0x8C, 0x8C, 0x6D, 0x61, 0xA9, 0x6C, - 0x41, 0xF9}; + const char upSource[] = { + '\xF1', '\x56', '\x13', '\x03', '\xDD', '\x81', '\x0E', '\xCC', '\xF7', '\x1D', '\x13', '\x35', '\xA0', '\xF5', '\x97', '\x40', '\x55', '\x8F', '\xB6', + '\x97', '\x69', '\x3A', '\xB9', '\x64', '\x76', '\x8C', '\xBA', '\x9D', '\x78', '\x13', '\xB8', '\x62', '\x43', '\x96', '\xBF', '\x95', '\x42', '\x2E', + '\xB9', '\x73', '\x5E', '\x8E', '\x8C', '\x8C', '\x6D', '\x61', '\xA9', '\x6C', '\x41', '\xF9'}; thread_local EncryptedName upName(upSource); const std::string up(upName.Text()); this->monsterList->scrollBar->SetButtonImages(up, down); } { - const std::uint8_t backgroundSource[] = { - 0x21, 0x2C, 0x11, 0x17, 0xD1, 0x4F, 0x7E, 0x0C, 0x27, 0x67, 0x11, 0x21, 0xAC, 0x3B, 0xE7, 0x80, 0x85, 0xF5, 0xB4, 0x83, 0x65, 0xF4, 0xC9, 0xA4, - 0xA6, 0xF6, 0xB8, 0x89, 0x74, 0xDD, 0xC8, 0xA2, 0x93, 0xEC, 0xBD, 0x81, 0x4E, 0xE3, 0xDC, 0x9E, 0x8C, 0xEA, 0xB5, 0xC3, 0x73, 0xEC, 0xCB, 0xC1}; + const char backgroundSource[] = { + '\x21', '\x2C', '\x11', '\x17', '\xD1', '\x4F', '\x7E', '\x0C', '\x27', '\x67', '\x11', '\x21', '\xAC', '\x3B', '\xE7', '\x80', '\x85', '\xF5', '\xB4', + '\x83', '\x65', '\xF4', '\xC9', '\xA4', '\xA6', '\xF6', '\xB8', '\x89', '\x74', '\xDD', '\xC8', '\xA2', '\x93', '\xEC', '\xBD', '\x81', '\x4E', '\xE3', + '\xDC', '\x9E', '\x8C', '\xEA', '\xB5', '\xC3', '\x73', '\xEC', '\xCB', '\xC1'}; thread_local EncryptedName backgroundName(backgroundSource); const std::string background(backgroundName.Text()); this->monsterList->scrollBar->SetBackground(background); } { - const std::uint8_t thumbBottomSource[] = { - 0x0F, 0x74, 0x11, 0xEF, 0x59, 0xE1, 0xAA, 0xDE, 0x09, 0x3F, 0x11, 0xD9, 0x24, 0x95, 0x33, 0x52, 0xAB, 0xAD, 0xB4, 0x7B, 0xED, 0x5A, 0x1D, 0x76, - 0x88, 0xAE, 0xB8, 0x71, 0xFC, 0x73, 0x1C, 0x70, 0xBD, 0xB4, 0xBD, 0x79, 0xC6, 0x5B, 0x07, 0x66, 0xA2, 0xB9, 0x8E, 0x71, 0xF6, 0x58, 0x01, 0x3D, - 0xAD, 0xB6, 0xA1, 0x15}; + const char thumbBottomSource[] = { + '\x0F', '\x74', '\x11', '\xEF', '\x59', '\xE1', '\xAA', '\xDE', '\x09', '\x3F', '\x11', '\xD9', '\x24', '\x95', '\x33', '\x52', '\xAB', '\xAD', '\xB4', + '\x7B', '\xED', '\x5A', '\x1D', '\x76', '\x88', '\xAE', '\xB8', '\x71', '\xFC', '\x73', '\x1C', '\x70', '\xBD', '\xB4', '\xBD', '\x79', '\xC6', '\x5B', + '\x07', '\x66', '\xA2', '\xB9', '\x8E', '\x71', '\xF6', '\x58', '\x01', '\x3D', '\xAD', '\xB6', '\xA1', '\x15'}; thread_local EncryptedName thumbBottomName(thumbBottomSource); const std::string thumbBottom(thumbBottomName.Text()); - const std::uint8_t thumbMiddleSource[] = { - 0xEB, 0x78, 0x89, 0xD5, 0xCF, 0x1F, 0xE6, 0xC6, 0xED, 0x33, 0x89, 0xE3, 0xB2, 0x6B, 0x7F, 0x4A, 0x4F, 0xA1, 0x2C, 0x41, 0x7B, 0xA4, 0x51, 0x6E, - 0x6C, 0xA2, 0x20, 0x4B, 0x6A, 0x8D, 0x50, 0x68, 0x59, 0xB8, 0x25, 0x43, 0x50, 0xA5, 0x4B, 0x7E, 0x46, 0xB5, 0x16, 0x42, 0x66, 0xB5, 0x0D, 0x69, - 0x46, 0xA7, 0x49}; + const char thumbMiddleSource[] = { + '\xEB', '\x78', '\x89', '\xD5', '\xCF', '\x1F', '\xE6', '\xC6', '\xED', '\x33', '\x89', '\xE3', '\xB2', '\x6B', '\x7F', '\x4A', '\x4F', '\xA1', '\x2C', + '\x41', '\x7B', '\xA4', '\x51', '\x6E', '\x6C', '\xA2', '\x20', '\x4B', '\x6A', '\x8D', '\x50', '\x68', '\x59', '\xB8', '\x25', '\x43', '\x50', '\xA5', + '\x4B', '\x7E', '\x46', '\xB5', '\x16', '\x42', '\x66', '\xB5', '\x0D', '\x69', '\x46', '\xA7', '\x49'}; thread_local EncryptedName thumbMiddleName(thumbMiddleSource); const std::string thumbMiddle(thumbMiddleName.Text()); - const std::uint8_t thumbTopSource[] = { - 0x4B, 0x32, 0xB7, 0x77, 0x21, 0x13, 0xA2, 0xDA, 0x4D, 0x79, 0xB7, 0x41, 0x5C, 0x67, 0x3B, 0x56, 0xEF, 0xEB, 0x12, 0xE3, 0x95, 0xA8, 0x15, 0x72, - 0xCC, 0xE8, 0x1E, 0xE9, 0x84, 0x81, 0x14, 0x74, 0xF9, 0xF2, 0x1B, 0xE1, 0xBE, 0xA9, 0x0F, 0x62, 0xE6, 0xFF, 0x28, 0xF8, 0x91, 0xF3, 0x05, 0x7A, - 0xFB, 0x9D}; + const char thumbTopSource[] = { + '\x4B', '\x32', '\xB7', '\x77', '\x21', '\x13', '\xA2', '\xDA', '\x4D', '\x79', '\xB7', '\x41', '\x5C', '\x67', '\x3B', '\x56', '\xEF', '\xEB', '\x12', + '\xE3', '\x95', '\xA8', '\x15', '\x72', '\xCC', '\xE8', '\x1E', '\xE9', '\x84', '\x81', '\x14', '\x74', '\xF9', '\xF2', '\x1B', '\xE1', '\xBE', '\xA9', + '\x0F', '\x62', '\xE6', '\xFF', '\x28', '\xF8', '\x91', '\xF3', '\x05', '\x7A', '\xFB', '\x9D'}; thread_local EncryptedName thumbTopName(thumbTopSource); const std::string thumbTop(thumbTopName.Text()); this->monsterList->scrollBar->SetThumbImages(thumbTop, thumbMiddle, thumbBottom); @@ -2637,27 +2674,28 @@ void CUIMonster::Slot15(int width, int height) { this->unknown_0084->disabled = 0; this->unknown_0084->Invalidate(); { - const std::uint8_t naviDisableSource[] = { - 0xC1, 0xDA, 0x3D, 0x23, 0xEF, 0x73, 0x6A, 0x7A, 0xC7, 0x91, 0x3D, 0x15, 0x92, 0x07, 0xF3, 0xF6, 0x65, 0x03, 0x98, 0xB7, 0x5B, 0xC8, 0xDD, 0xD2, - 0x46, 0x00, 0x94, 0xBD, 0x4A, 0xE1, 0xCD, 0xC3, 0x6F, 0x2A, 0x93, 0xB8, 0x59, 0xD4, 0xF0, 0xD3, 0x68, 0x06, 0x9F, 0xB8, 0x43, 0xD8, 0x81, 0xD5, - 0x6C, 0x05, 0xFD}; + const char naviDisableSource[] = { + '\xC1', '\xDA', '\x3D', '\x23', '\xEF', '\x73', '\x6A', '\x7A', '\xC7', '\x91', '\x3D', '\x15', '\x92', '\x07', '\xF3', '\xF6', '\x65', '\x03', '\x98', + '\xB7', '\x5B', '\xC8', '\xDD', '\xD2', '\x46', '\x00', '\x94', '\xBD', '\x4A', '\xE1', '\xCD', '\xC3', '\x6F', '\x2A', '\x93', '\xB8', '\x59', '\xD4', + '\xF0', '\xD3', '\x68', '\x06', '\x9F', '\xB8', '\x43', '\xD8', '\x81', '\xD5', '\x6C', '\x05', '\xFD'}; thread_local EncryptedName naviDisableName(naviDisableSource); const std::string naviDisable(naviDisableName.Text()); - const std::uint8_t naviOverSource[] = { - 0x1D, 0xFA, 0xAF, 0x55, 0x29, 0xDB, 0x2C, 0xB4, 0x1B, 0xB1, 0xAF, 0x63, 0x54, 0xAF, 0xB5, 0x38, 0xB9, 0x23, 0x0A, 0xC1, 0x9D, 0x60, 0x9B, 0x1C, - 0x9A, 0x20, 0x06, 0xCB, 0x8C, 0x49, 0x8B, 0x0D, 0xB3, 0x0A, 0x01, 0xCE, 0x9F, 0x7C, 0xB6, 0x16, 0xAB, 0x30, 0x1D, 0x81, 0x8B, 0x78, 0x99, 0x79}; + const char naviOverSource[] = { + '\x1D', '\xFA', '\xAF', '\x55', '\x29', '\xDB', '\x2C', '\xB4', '\x1B', '\xB1', '\xAF', '\x63', '\x54', '\xAF', '\xB5', '\x38', '\xB9', '\x23', '\x0A', + '\xC1', '\x9D', '\x60', '\x9B', '\x1C', '\x9A', '\x20', '\x06', '\xCB', '\x8C', '\x49', '\x8B', '\x0D', '\xB3', '\x0A', '\x01', '\xCE', '\x9F', '\x7C', + '\xB6', '\x16', '\xAB', '\x30', '\x1D', '\x81', '\x8B', '\x78', '\x99', '\x79'}; thread_local EncryptedName naviOverName(naviOverSource); const std::string naviOver(naviOverName.Text()); - const std::uint8_t naviPressSource[] = { - 0x81, 0x92, 0x97, 0x8F, 0xF9, 0x51, 0x88, 0xAA, 0x87, 0xD9, 0x97, 0xB9, 0x84, 0x25, 0x11, 0x26, 0x25, 0x4B, 0x32, 0x1B, 0x4D, 0xEA, 0x3F, 0x02, - 0x06, 0x48, 0x3E, 0x11, 0x5C, 0xC3, 0x2F, 0x13, 0x2F, 0x62, 0x39, 0x14, 0x4F, 0xF6, 0x12, 0x17, 0x33, 0x58, 0x24, 0x06, 0x17, 0xFD, 0x20, 0x17, - 0x41}; + const char naviPressSource[] = { + '\x81', '\x92', '\x97', '\x8F', '\xF9', '\x51', '\x88', '\xAA', '\x87', '\xD9', '\x97', '\xB9', '\x84', '\x25', '\x11', '\x26', '\x25', '\x4B', '\x32', + '\x1B', '\x4D', '\xEA', '\x3F', '\x02', '\x06', '\x48', '\x3E', '\x11', '\x5C', '\xC3', '\x2F', '\x13', '\x2F', '\x62', '\x39', '\x14', '\x4F', '\xF6', + '\x12', '\x17', '\x33', '\x58', '\x24', '\x06', '\x17', '\xFD', '\x20', '\x17', '\x41'}; thread_local EncryptedName naviPressName(naviPressSource); const std::string naviPress(naviPressName.Text()); - const std::uint8_t naviNormalSource[] = { - 0x91, 0x02, 0x3D, 0xD1, 0x8F, 0xFD, 0x1A, 0xA6, 0x97, 0x49, 0x3D, 0xE7, 0xF2, 0x89, 0x83, 0x2A, 0x35, 0xDB, 0x98, 0x45, 0x3B, 0x46, 0xAD, 0x0E, - 0x16, 0xD8, 0x94, 0x4F, 0x2A, 0x6F, 0xBD, 0x1F, 0x3F, 0xF2, 0x93, 0x4A, 0x39, 0x5A, 0x80, 0x05, 0x3E, 0xDF, 0x90, 0x4A, 0x23, 0x1D, 0xBD, 0x06, - 0x21, 0xAD}; + const char naviNormalSource[] = { + '\x91', '\x02', '\x3D', '\xD1', '\x8F', '\xFD', '\x1A', '\xA6', '\x97', '\x49', '\x3D', '\xE7', '\xF2', '\x89', '\x83', '\x2A', '\x35', '\xDB', '\x98', + '\x45', '\x3B', '\x46', '\xAD', '\x0E', '\x16', '\xD8', '\x94', '\x4F', '\x2A', '\x6F', '\xBD', '\x1F', '\x3F', '\xF2', '\x93', '\x4A', '\x39', '\x5A', + '\x80', '\x05', '\x3E', '\xDF', '\x90', '\x4A', '\x23', '\x1D', '\xBD', '\x06', '\x21', '\xAD'}; thread_local EncryptedName naviNormalName(naviNormalSource); const std::string naviNormal(naviNormalName.Text()); this->unknown_0084->SetImages(naviNormal, naviPress, naviOver, naviDisable); diff --git a/Source/UI/AdventureGuide/UIAdventureGuide.h b/Source/UI/AdventureGuide/UIAdventureGuide.h index a5add99d..14a6bb4a 100644 --- a/Source/UI/AdventureGuide/UIAdventureGuide.h +++ b/Source/UI/AdventureGuide/UIAdventureGuide.h @@ -54,7 +54,7 @@ class CUICharacterInfo : public CUIControl { public: // OFFSET: 0x009D8F50 // FUNCTION: fn_14273 - explicit CUICharacterInfo() : CUIControl(), jobIcon(nullptr), level(nullptr), jobLevel(nullptr), name(nullptr) { + __declspec(noinline) explicit CUICharacterInfo() : CUIControl(), jobIcon(nullptr), level(nullptr), jobLevel(nullptr), name(nullptr) { } void Slot15(int width, int height) override; @@ -70,7 +70,7 @@ class CUIIntro : public CUIPage { public: // OFFSET: 0x009D8FE0 // FUNCTION: fn_14274 - explicit CUIIntro() : CUIPage(), banner(nullptr), image(nullptr), contents(nullptr) { + __declspec(noinline) explicit CUIIntro() : CUIPage(), banner(nullptr), image(nullptr), contents(nullptr) { } void Slot15(int width, int height) override; @@ -90,7 +90,7 @@ class CUIItem : public CUIPage { public: // OFFSET: 0x009D9080 // FUNCTION: fn_14275 - explicit CUIItem() + __declspec(noinline) explicit CUIItem() : CUIPage(), itemList(nullptr), unknown_0084(nullptr), unknown_0088(nullptr), unknown_008C(), location(-1) { } @@ -114,7 +114,7 @@ class CUIMonster : public CUIPage { public: // OFFSET: 0x009D9220 // FUNCTION: fn_14277 - explicit CUIMonster() : CUIPage(), monsterList(nullptr), unknown_0084(nullptr), unknown_0088() { + __declspec(noinline) explicit CUIMonster() : CUIPage(), monsterList(nullptr), unknown_0084(nullptr), unknown_0088() { } void Slot15(int width, int height) override; @@ -135,7 +135,7 @@ class CUIQuest : public CUIPage { public: // OFFSET: 0x009D9360 // FUNCTION: fn_14279 - explicit CUIQuest() : CUIPage(), questList(nullptr), unknown_0084(nullptr), unknown_0088(nullptr), unknown_008C() { + __declspec(noinline) explicit CUIQuest() : CUIPage(), questList(nullptr), unknown_0084(nullptr), unknown_0088(nullptr), unknown_008C() { } void Slot15(int width, int height) override;