#include "stdafx.h"
#include "Tetris.h"
#include <objidl.h>
#include <gdiplus.h>
#include <string>

#pragma comment(lib, "gdiplus.lib")

using namespace Gdiplus;

static HBRUSH GetCachedParticleBrush(COLORREF color)
{
    static COLORREF cachedColors[16] = {};
    static HBRUSH cachedBrushes[16] = {};

    for (int i = 0; i < 16; i++)
    {
        if (cachedBrushes[i] != nullptr && cachedColors[i] == color)
        {
            return cachedBrushes[i];
        }
    }

    for (int i = 0; i < 16; i++)
    {
        if (cachedBrushes[i] == nullptr)
        {
            cachedColors[i] = color;
            cachedBrushes[i] = CreateSolidBrush(color);
            return cachedBrushes[i];
        }
    }

    return CreateSolidBrush(color);
}

static std::wstring BuildAssetPath(const wchar_t* relativePath)
{
    wchar_t modulePath[MAX_PATH] = {};
    GetModuleFileNameW(nullptr, modulePath, MAX_PATH);

    std::wstring basePath(modulePath);
    size_t lastSlash = basePath.find_last_of(L"\\/");
    if (lastSlash != std::wstring::npos)
    {
        basePath.resize(lastSlash);
    }

    std::wstring projectRelative = basePath + L"\\..\\..\\" + relativePath;
    wchar_t fullPath[MAX_PATH] = {};
    DWORD result = GetFullPathNameW(projectRelative.c_str(), MAX_PATH, fullPath, nullptr);
    if (result > 0 && result < MAX_PATH)
    {
        return fullPath;
    }

    return projectRelative;
}

static std::wstring BuildWorkingDirAssetPath(const wchar_t* relativePath)
{
    wchar_t currentDirectory[MAX_PATH] = {};
    DWORD length = GetCurrentDirectoryW(MAX_PATH, currentDirectory);
    if (length == 0 || length >= MAX_PATH)
    {
        return L"";
    }

    std::wstring candidate = std::wstring(currentDirectory) + L"\\" + relativePath;
    wchar_t fullPath[MAX_PATH] = {};
    DWORD result = GetFullPathNameW(candidate.c_str(), MAX_PATH, fullPath, nullptr);
    if (result > 0 && result < MAX_PATH)
    {
        return fullPath;
    }

    return candidate;
}

static Bitmap* LoadBackgroundImage()
{
    static ULONG_PTR gdiplusToken = 0;
    static Bitmap* backgroundImage = nullptr;
    static bool attempted = false;

    if (!attempted)
    {
        attempted = true;

        GdiplusStartupInput startupInput;
        if (GdiplusStartup(&gdiplusToken, &startupInput, nullptr) == Ok)
        {
            const std::wstring candidates[] =
            {
                BuildAssetPath(L"assets\\images\\background.png"),
                BuildWorkingDirAssetPath(L"assets\\images\\background.png"),
                BuildAssetPath(L"assets\\images\\background.bmp"),
                BuildWorkingDirAssetPath(L"assets\\images\\background.bmp")
            };

            for (const std::wstring& candidate : candidates)
            {
                if (candidate.empty())
                {
                    continue;
                }

                DWORD attributes = GetFileAttributesW(candidate.c_str());
                if (attributes == INVALID_FILE_ATTRIBUTES || (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
                {
                    continue;
                }

                Bitmap* loadedImage = Bitmap::FromFile(candidate.c_str(), FALSE);
                if (loadedImage != nullptr && loadedImage->GetLastStatus() == Ok)
                {
                    backgroundImage = loadedImage;
                    break;
                }

                delete loadedImage;
            }
        }
    }

    return backgroundImage;
}

/**
 * @brief 按序号加载致谢页图片资源。
 */
static Bitmap* LoadCreditImage(int index)
{
    constexpr int creditPageCount = 4;
    static ULONG_PTR gdiplusToken = 0;
    static Bitmap* creditImages[creditPageCount] = {};
    static bool attempted[creditPageCount] = {};

    if (index < 0 || index >= creditPageCount)
    {
        return nullptr;
    }

    if (!attempted[index])
    {
        attempted[index] = true;

        GdiplusStartupInput startupInput;
        if (GdiplusStartup(&gdiplusToken, &startupInput, nullptr) == Ok)
        {
            const wchar_t* imageNames[creditPageCount] =
            {
                L"assets\\images\\qls.jpg",
                L"assets\\images\\wyk.jpg",
                L"assets\\images\\swj.jpg",
                L"assets\\images\\qhy.jpg"
            };
            const std::wstring creditExtraCandidates[] =
            {
                BuildAssetPath(imageNames[index]),
                BuildWorkingDirAssetPath(imageNames[index]),
                BuildAssetPath(L"assets\\images\\qhy.png"),
                BuildWorkingDirAssetPath(L"assets\\images\\qhy.png"),
                BuildAssetPath(L"assets\\images\\qhy.jpeg"),
                BuildWorkingDirAssetPath(L"assets\\images\\qhy.jpeg"),
                BuildAssetPath(L"assets\\images\\qhy.bmp"),
                BuildWorkingDirAssetPath(L"assets\\images\\qhy.bmp")
            };
            int candidateCount = (index == 3) ? 8 : 2;

            for (int i = 0; i < candidateCount; i++)
            {
                const std::wstring& candidate = creditExtraCandidates[i];
                if (candidate.empty())
                {
                    continue;
                }

                DWORD attributes = GetFileAttributesW(candidate.c_str());
                if (attributes == INVALID_FILE_ATTRIBUTES || (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
                {
                    continue;
                }

                Bitmap* loadedImage = Bitmap::FromFile(candidate.c_str(), FALSE);
                if (loadedImage != nullptr && loadedImage->GetLastStatus() == Ok)
                {
                    creditImages[index] = loadedImage;
                    break;
                }

                delete loadedImage;
            }
        }
    }

    return creditImages[index];
}

void TDrawScreen(HDC hdc, HWND hWnd)
{
    RECT clientRect;
    GetClientRect(hWnd, &clientRect);

    int clientWidth = clientRect.right - clientRect.left;
    int clientHeight = clientRect.bottom - clientRect.top;
    int scaleX = MulDiv(clientWidth, 1000, WINDOW_CLIENT_WIDTH);
    int scaleY = MulDiv(clientHeight, 1000, WINDOW_CLIENT_HEIGHT);
    int scale = (scaleX < scaleY) ? scaleX : scaleY;

    if (scale < 500)
    {
        scale = 500;
    }

    int layoutWidth = MulDiv(WINDOW_CLIENT_WIDTH, scale, 1000);
    int layoutHeight = MulDiv(WINDOW_CLIENT_HEIGHT, scale, 1000);
    int offsetX = (clientWidth - layoutWidth) / 2;
    int offsetY = 0;

    auto SX = [offsetX, scale](int value) -> int
    {
        return offsetX + MulDiv(value, scale, 1000);
    };

    auto SY = [offsetY, scale](int value) -> int
    {
        return offsetY + MulDiv(value, scale, 1000);
    };

    auto SS = [scale](int value) -> int
    {
        int result = MulDiv(value, scale, 1000);
        return result < 1 ? 1 : result;
    };

    int grid = SS(GRID);
    int previewMiniCell = SS(16);
    int panelGap = SS(SIDE_PANEL_GAP);
    int panelWidth = SS(SIDE_PANEL_WIDTH);
    int panelHeight = SS(SIDE_PANEL_HEIGHT - WINDOW_PADDING * 2);
    int boardWidth = grid * nGameWidth;
    int boardHeight = grid * nGameHeight;

    const RECT leftPanelRect =
    {
        SX(WINDOW_PADDING),
        SY(WINDOW_PADDING),
        SX(WINDOW_PADDING) + panelWidth,
        SY(WINDOW_PADDING) + panelHeight
    };

    const RECT gameRect =
    {
        leftPanelRect.right + panelGap,
        SY(WINDOW_PADDING),
        leftPanelRect.right + panelGap + boardWidth,
        SY(WINDOW_PADDING) + boardHeight
    };

    const RECT rightPanelRect =
    {
        gameRect.right + panelGap,
        SY(WINDOW_PADDING),
        gameRect.right + panelGap + panelWidth,
        SY(WINDOW_PADDING) + panelHeight
    };

    const COLORREF pageColor = RGB(255, 244, 248);
    const COLORREF blobColorA = RGB(255, 230, 238);
    const COLORREF blobColorB = RGB(250, 221, 233);
    const COLORREF cardColor = RGB(255, 252, 253);
    const COLORREF boardColor = RGB(70, 57, 78);
    const COLORREF boardInnerColor = RGB(54, 44, 62);
    const COLORREF lineColor = RGB(104, 90, 116);
    const COLORREF frameColor = RGB(212, 168, 188);
    const COLORREF titleColor = RGB(104, 62, 84);
    const COLORREF textColor = RGB(92, 73, 88);
    const COLORREF accentColor = RGB(228, 145, 182);
    const BYTE shellAlpha = 142;
    const BYTE panelAlpha = 150;
    const BYTE panelNestedAlpha = 128;
    const BYTE panelStrongAlpha = 168;

    Bitmap* backgroundImage = LoadBackgroundImage();
    if (backgroundImage != nullptr)
    {
        Graphics graphics(hdc);
        graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
        graphics.DrawImage(
            backgroundImage,
            Rect(0, 0, clientRect.right - clientRect.left, clientRect.bottom - clientRect.top));
        SolidBrush washBrush(Color(76, 255, 250, 252));
        graphics.FillRectangle(&washBrush, 0, 0, clientRect.right - clientRect.left, clientRect.bottom - clientRect.top);
    }
    else
    {
        HBRUSH pageBrush = CreateSolidBrush(pageColor);
        FillRect(hdc, &clientRect, pageBrush);
        DeleteObject(pageBrush);
    }

    HBRUSH oldBrush = nullptr;
    HPEN oldPen = nullptr;
    if (backgroundImage == nullptr)
    {
        HBRUSH blobBrushA = CreateSolidBrush(blobColorA);
        HBRUSH blobBrushB = CreateSolidBrush(blobColorB);
        oldBrush = (HBRUSH)SelectObject(hdc, blobBrushA);
        oldPen = (HPEN)SelectObject(hdc, GetStockObject(NULL_PEN));
        Ellipse(hdc, clientRect.right - 260, -20, clientRect.right + 80, 260);
        Ellipse(hdc, -80, clientRect.bottom - 200, 220, clientRect.bottom + 70);
        SelectObject(hdc, blobBrushB);
        Ellipse(hdc, clientRect.right - 180, clientRect.bottom - 220, clientRect.right + 120, clientRect.bottom + 40);
        SelectObject(hdc, oldBrush);
        SelectObject(hdc, oldPen);
        DeleteObject(blobBrushA);
        DeleteObject(blobBrushB);
    }

    HFONT titleFont = CreateFont(
        -SS(36), 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE,
        DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_NATURAL_QUALITY,
        VARIABLE_PITCH, _T("Microsoft YaHei UI"));

    HFONT sectionFont = CreateFont(
        -SS(22), 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE,
        DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_NATURAL_QUALITY,
        VARIABLE_PITCH, _T("Microsoft YaHei UI"));

    HFONT bodyFont = CreateFont(
        -SS(18), 0, 0, 0, FW_SEMIBOLD, FALSE, FALSE, FALSE,
        DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_NATURAL_QUALITY,
        VARIABLE_PITCH, _T("Microsoft YaHei UI"));

    HFONT smallFont = CreateFont(
        -SS(15), 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
        DEFAULT_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_NATURAL_QUALITY,
        VARIABLE_PITCH, _T("Microsoft YaHei UI"));

    SetBkMode(hdc, TRANSPARENT);
    SetTextColor(hdc, textColor);

    auto DrawPanelCard = [&](const RECT& rect, COLORREF fillColor, COLORREF borderColor, int radius)
    {
        HBRUSH cardBrush = CreateSolidBrush(fillColor);
        HPEN cardPen = CreatePen(PS_SOLID, 1, borderColor);
        HGDIOBJ savedPen = SelectObject(hdc, cardPen);
        HGDIOBJ savedBrush = SelectObject(hdc, cardBrush);
        RoundRect(hdc, rect.left, rect.top, rect.right, rect.bottom, SS(radius), SS(radius));
        SelectObject(hdc, savedBrush);
        SelectObject(hdc, savedPen);
        DeleteObject(cardBrush);
        DeleteObject(cardPen);
    };

    auto DrawPanelCardAlpha = [&](const RECT& rect, COLORREF fillColor, COLORREF borderColor, int radius, BYTE alpha)
    {
        Graphics graphics(hdc);
        graphics.SetSmoothingMode(SmoothingModeAntiAlias);

        GraphicsPath path;
        INT left = static_cast<INT>(rect.left);
        INT top = static_cast<INT>(rect.top);
        INT width = static_cast<INT>(rect.right - rect.left);
        INT height = static_cast<INT>(rect.bottom - rect.top);
        INT corner = static_cast<INT>(SS(radius));

        path.AddArc(left, top, corner, corner, 180.0f, 90.0f);
        path.AddArc(left + width - corner, top, corner, corner, 270.0f, 90.0f);
        path.AddArc(left + width - corner, top + height - corner, corner, corner, 0.0f, 90.0f);
        path.AddArc(left, top + height - corner, corner, corner, 90.0f, 90.0f);
        path.CloseFigure();

        SolidBrush brush(Color(alpha, GetRValue(fillColor), GetGValue(fillColor), GetBValue(fillColor)));
        Pen pen(Color(232, GetRValue(borderColor), GetGValue(borderColor), GetBValue(borderColor)), 1.0f);
        graphics.FillPath(&brush, &path);
        graphics.DrawPath(&pen, &path);
    };

    auto DrawPanelHeader = [&](const RECT& panelRect, const TCHAR* title, int lineWidth)
    {
        SelectObject(hdc, titleFont);
        SetTextColor(hdc, titleColor);
        RECT titleRect =
        {
            panelRect.left + SS(24),
            panelRect.top + SS(20),
            panelRect.right - SS(24),
            panelRect.top + SS(62)
        };
        DrawText(hdc, title, -1, &titleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

        HPEN localAccentPen = CreatePen(PS_SOLID, SS(3), accentColor);
        HPEN savedPen = (HPEN)SelectObject(hdc, localAccentPen);
        MoveToEx(hdc, panelRect.left + SS(24), panelRect.top + SS(78), nullptr);
        LineTo(hdc, panelRect.left + SS(24) + SS(lineWidth), panelRect.top + SS(78));
        SelectObject(hdc, savedPen);
        DeleteObject(localAccentPen);
    };

    auto DrawMusicButton = [&]()
    {
        RECT musicButtonRect =
        {
            SX(WINDOW_CLIENT_WIDTH - 40),
            SY(WINDOW_CLIENT_HEIGHT - 40),
            SX(WINDOW_CLIENT_WIDTH - 12),
            SY(WINDOW_CLIENT_HEIGHT - 12)
        };
        DrawPanelCardAlpha(
            musicButtonRect,
            bgmEnabled ? RGB(255, 238, 246) : RGB(244, 236, 240),
            bgmEnabled ? RGB(222, 130, 166) : RGB(170, 148, 158),
            12,
            bgmEnabled ? 218 : 190);

        HPEN musicPen = CreatePen(PS_SOLID, SS(3), bgmEnabled ? RGB(128, 70, 100) : RGB(128, 112, 120));
        HPEN oldMusicPen = (HPEN)SelectObject(hdc, musicPen);
        HBRUSH oldMusicBrush = (HBRUSH)SelectObject(hdc, GetStockObject(NULL_BRUSH));

        int noteStemX = musicButtonRect.left + SS(17);
        int noteTop = musicButtonRect.top + SS(7);
        int noteBottom = musicButtonRect.bottom - SS(9);
        MoveToEx(hdc, noteStemX, noteTop, nullptr);
        LineTo(hdc, noteStemX, noteBottom);
        MoveToEx(hdc, noteStemX, noteTop, nullptr);
        LineTo(hdc, musicButtonRect.right - SS(7), noteTop + SS(4));
        LineTo(hdc, musicButtonRect.right - SS(7), noteTop + SS(10));
        Ellipse(
            hdc,
            musicButtonRect.left + SS(7),
            musicButtonRect.bottom - SS(13),
            musicButtonRect.left + SS(19),
            musicButtonRect.bottom - SS(4));

        if (!bgmEnabled)
        {
            MoveToEx(hdc, musicButtonRect.left + SS(7), musicButtonRect.bottom - SS(7), nullptr);
            LineTo(hdc, musicButtonRect.right - SS(6), musicButtonRect.top + SS(6));
        }

        SelectObject(hdc, oldMusicBrush);
        SelectObject(hdc, oldMusicPen);
        DeleteObject(musicPen);
    };

    auto DrawBackButton = [&]()
    {
        RECT backButtonRect =
        {
            SX(6),
            SY(6),
            SX(34),
            SY(34)
        };
        HBRUSH backBrush = CreateSolidBrush(RGB(255, 242, 247));
        HPEN backFramePen = CreatePen(PS_SOLID, 1, RGB(222, 130, 166));
        HBRUSH oldBackBrush = (HBRUSH)SelectObject(hdc, backBrush);
        HPEN oldBackFramePen = (HPEN)SelectObject(hdc, backFramePen);
        RoundRect(hdc, backButtonRect.left, backButtonRect.top, backButtonRect.right, backButtonRect.bottom, SS(12), SS(12));
        SelectObject(hdc, oldBackBrush);
        SelectObject(hdc, oldBackFramePen);
        DeleteObject(backFramePen);
        DeleteObject(backBrush);

        HPEN backPen = CreatePen(PS_SOLID, SS(3), RGB(128, 70, 100));
        HPEN oldBackPen = (HPEN)SelectObject(hdc, backPen);
        MoveToEx(hdc, backButtonRect.left + SS(20), backButtonRect.top + SS(8), nullptr);
        LineTo(hdc, backButtonRect.left + SS(10), backButtonRect.top + SS(14));
        LineTo(hdc, backButtonRect.left + SS(20), backButtonRect.top + SS(20));
        MoveToEx(hdc, backButtonRect.left + SS(10), backButtonRect.top + SS(14), nullptr);
        LineTo(hdc, backButtonRect.right - SS(8), backButtonRect.top + SS(14));
        SelectObject(hdc, oldBackPen);
        DeleteObject(backPen);
    };

    if (currentScreen == SCREEN_MENU)
    {
        RECT menuCard =
        {
            SX(110),
            SY(70),
            SX(WINDOW_CLIENT_WIDTH - 110),
            SY(WINDOW_CLIENT_HEIGHT - 70)
        };

        DrawPanelCardAlpha(menuCard, cardColor, frameColor, 34, 214);

        HFONT oldFont = (HFONT)SelectObject(hdc, titleFont);
        SetTextColor(hdc, titleColor);

        RECT titleRect =
        {
            menuCard.left,
            menuCard.top + SS(24),
            menuCard.right,
            menuCard.top + SS(70)
        };
        DrawText(hdc, _T("Rogue Tetris"), -1, &titleRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

        RECT subtitleRect =
        {
            menuCard.left,
            menuCard.top + SS(72),
            menuCard.right,
            menuCard.top + SS(110)
        };
        SelectObject(hdc, bodyFont);
        SetTextColor(hdc, textColor);
        DrawText(hdc, _T("选择你的战局"), -1, &subtitleRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

        const TCHAR* modeNames[4] =
        {
            _T("\u7ecf\u5178\u6a21\u5f0f"),
            _T("Rogue \u6a21\u5f0f"),
            _T("\u5e2e\u52a9"),
            _T("\u81f4\u8c22")
        };

        const TCHAR* modeDescriptions[4] =
        {
            _T("纯粹方块挑战，专注消行、堆叠与生存。"),
            _T("在不断升级的棋盘中收集强化，构筑本局专属流派。"),
            _T("查看操作、模式规则与全部强化效果。"),
            _T("感谢程序测试者与代码贡献者。")
        };

        for (int i = 0; i < menuState.optionCount; i++)
        {
            bool isSelected = (i == menuState.selectedIndex);
            int top = menuCard.top + SS(140) + i * SS(130);

            RECT optionRect =
            {
                menuCard.left + SS(36),
                top,
                menuCard.right - SS(36),
                top + SS(104)
            };

            DrawPanelCardAlpha(
                optionRect,
                isSelected ? RGB(255, 232, 240) : RGB(255, 247, 250),
                isSelected ? accentColor : RGB(226, 198, 210),
                24,
                isSelected ? 208 : 172);
            if (isSelected)
            {
                HPEN optionPen = CreatePen(PS_SOLID, SS(3), accentColor);
                oldPen = (HPEN)SelectObject(hdc, optionPen);
                oldBrush = (HBRUSH)SelectObject(hdc, GetStockObject(NULL_BRUSH));
                RoundRect(hdc, optionRect.left, optionRect.top, optionRect.right, optionRect.bottom, SS(24), SS(24));
                SelectObject(hdc, oldBrush);
                SelectObject(hdc, oldPen);
                DeleteObject(optionPen);
            }

            RECT modeNameRect =
            {
                optionRect.left + SS(24),
                optionRect.top + SS(14),
                optionRect.right - SS(24),
                optionRect.top + SS(44)
            };

            RECT modeDescriptionRect =
            {
                optionRect.left + SS(24),
                optionRect.top + SS(46),
                optionRect.right - SS(24),
                optionRect.bottom - SS(14)
            };

            SelectObject(hdc, sectionFont);
            SetTextColor(hdc, isSelected ? titleColor : textColor);
            DrawText(hdc, modeNames[i], -1, &modeNameRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

            SelectObject(hdc, smallFont);
            SetTextColor(hdc, RGB(118, 96, 110));
            DrawText(hdc, modeDescriptions[i], -1, &modeDescriptionRect, DT_LEFT | DT_WORDBREAK);
        }

        RECT hintRect =
        {
            menuCard.left + SS(36),
            menuCard.bottom - SS(92),
            menuCard.right - SS(36),
            menuCard.bottom - SS(36)
        };

        SelectObject(hdc, smallFont);
        SetTextColor(hdc, RGB(128, 104, 118));
        DrawText(hdc, _T("\u65b9\u5411\u952e / WASD \u5207\u6362\uff0cEnter \u6216 Space \u786e\u8ba4\uff0cEsc \u9000\u51fa"), -1, &hintRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

        DrawMusicButton();
        SelectObject(hdc, oldFont);
        DeleteObject(titleFont);
        DeleteObject(sectionFont);
        DeleteObject(bodyFont);
        DeleteObject(smallFont);
        return;
    }

    if (currentScreen == SCREEN_RULES)
    {
        RECT rulesCard =
        {
            SX(76),
            SY(54),
            SX(WINDOW_CLIENT_WIDTH - 76),
            SY(WINDOW_CLIENT_HEIGHT - 54)
        };

        HPEN rulesPen = CreatePen(PS_SOLID, 1, frameColor);
        HBRUSH rulesBrush = CreateSolidBrush(cardColor);
        HFONT oldFont = (HFONT)SelectObject(hdc, titleFont);
        oldPen = (HPEN)SelectObject(hdc, rulesPen);
        oldBrush = (HBRUSH)SelectObject(hdc, rulesBrush);
        RoundRect(hdc, rulesCard.left, rulesCard.top, rulesCard.right, rulesCard.bottom, SS(34), SS(34));
        SelectObject(hdc, oldBrush);
        SelectObject(hdc, oldPen);
        DeleteObject(rulesBrush);
        DeleteObject(rulesPen);

        SetTextColor(hdc, titleColor);
        RECT rulesTitleRect =
        {
            rulesCard.left + SS(36),
            rulesCard.top + SS(26),
            rulesCard.right - SS(36),
            rulesCard.top + SS(78)
        };
        const TCHAR* helpTitle = _T("\u5e2e\u52a9");
        if (helpState.currentPage == 1)
        {
            helpTitle = _T("\u6e38\u620f\u4ecb\u7ecd");
        }
        else if (helpState.currentPage == 2)
        {
            helpTitle = _T("\u64cd\u4f5c\u8bf4\u660e");
        }
        else if (helpState.currentPage == 3)
        {
            helpTitle = _T("\u5f3a\u5316\u56fe\u9274");
        }
        else if (helpState.currentPage == 4)
        {
            helpTitle = _T("\u81f4\u8c22");
        }
        else if (helpState.currentPage == 5)
        {
            helpTitle = _T("\u6280\u80fd\u6f14\u793a");
        }
        DrawText(hdc, helpTitle, -1, &rulesTitleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

        HPEN rulesAccentPen = CreatePen(PS_SOLID, SS(3), accentColor);
        oldPen = (HPEN)SelectObject(hdc, rulesAccentPen);
        MoveToEx(hdc, rulesCard.left + SS(38), rulesCard.top + SS(92), nullptr);
        LineTo(hdc, rulesCard.left + SS(186), rulesCard.top + SS(92));
        SelectObject(hdc, oldPen);
        DeleteObject(rulesAccentPen);

        RECT contentRect =
        {
            rulesCard.left + SS(36),
            rulesCard.top + SS(126),
            rulesCard.right - SS(36),
            rulesCard.bottom - SS(86)
        };

        if (helpState.currentPage == 0)
        {
            const TCHAR* optionTitles[4] =
            {
                _T("\u6e38\u620f\u4ecb\u7ecd"),
                _T("\u64cd\u4f5c\u8bf4\u660e"),
                _T("\u5f3a\u5316\u56fe\u9274"),
                _T("\u6280\u80fd\u6f14\u793a")
            };
            const TCHAR* optionDetails[4] =
            {
                _T("\u7ecf\u5178\u6a21\u5f0f\u3001Rogue \u6a21\u5f0f\u548c\u590d\u6d3b\u89c4\u5219\u6982\u89c8\u3002"),
                _T("\u79fb\u52a8\u3001\u65cb\u8f6c\u3001\u786c\u964d\u3001Hold \u4e0e\u6280\u80fd\u5feb\u6377\u952e\u3002"),
                _T("\u67e5\u770b Rogue \u6a21\u5f0f\u5168\u90e8\u5f3a\u5316\u7684\u7b80\u8981\u6548\u679c\u3002"),
                _T("\u8fdb\u5165\u81ea\u52a8\u8f6e\u64ad\u6f14\u793a\uff0c\u4f9d\u6b21\u5c55\u793a Rogue \u4e3b\u8981\u6280\u80fd\u548c\u68cb\u76d8\u6548\u679c\u3002")
            };

            int optionHeight = SS(100);
            int optionGap = SS(22);
            int optionTop = contentRect.top + SS(18);
            for (int i = 0; i < helpState.optionCount; ++i)
            {
                RECT optionRect =
                {
                    contentRect.left,
                    optionTop + i * (optionHeight + optionGap),
                    contentRect.right,
                    optionTop + i * (optionHeight + optionGap) + optionHeight
                };
                bool selected = (i == helpState.selectedIndex);
                COLORREF optionFill = selected ? RGB(255, 245, 249) : RGB(255, 252, 250);
                COLORREF optionFrame = selected ? accentColor : frameColor;
                HPEN optionPen = CreatePen(PS_SOLID, selected ? SS(2) : SS(1), optionFrame);
                HBRUSH optionBrush = CreateSolidBrush(optionFill);
                oldPen = (HPEN)SelectObject(hdc, optionPen);
                oldBrush = (HBRUSH)SelectObject(hdc, optionBrush);
                RoundRect(hdc, optionRect.left, optionRect.top, optionRect.right, optionRect.bottom, SS(24), SS(24));
                SelectObject(hdc, oldBrush);
                SelectObject(hdc, oldPen);
                DeleteObject(optionBrush);
                DeleteObject(optionPen);

                SetTextColor(hdc, selected ? titleColor : textColor);
                SelectObject(hdc, sectionFont);
                RECT optionTitleRect =
                {
                    optionRect.left + SS(28),
                    optionRect.top + SS(16),
                    optionRect.right - SS(28),
                    optionRect.top + SS(48)
                };
                DrawText(hdc, optionTitles[i], -1, &optionTitleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

                SetTextColor(hdc, RGB(112, 91, 104));
                SelectObject(hdc, bodyFont);
                RECT optionDetailRect =
                {
                    optionRect.left + SS(28),
                    optionRect.top + SS(52),
                    optionRect.right - SS(28),
                    optionRect.bottom - SS(14)
                };
                DrawText(hdc, optionDetails[i], -1, &optionDetailRect, DT_LEFT | DT_TOP | DT_WORDBREAK);
            }
        }
        else
        {
            SetTextColor(hdc, textColor);
            SelectObject(hdc, bodyFont);
            const TCHAR* pageText = _T("");
            UINT pageFlags = DT_LEFT | DT_TOP | DT_WORDBREAK;
            if (helpState.currentPage == 1)
            {
                pageText =
                    _T("经典模式：考验堆叠、消行和生存。消行后悬空方块会继续受重力下落。\r\n\r\n")
                    _T("Rogue：消行得分和 EXP，升级后选择强化，构筑会改变方块、清场、得分和保命方式。\r\n\r\n")
                    _T("特殊方块用粗色边框提示：橙红=爆破，青色=激光，绿色=十字，紫色=彩虹。\r\n\r\n")
                    _T("战斗越久危险越高，底部封锁区会压缩空间。\r\n\r\n")
                    _T("死亡后可以按 V 看视频复活一次，经典模式和 Rogue 模式都支持。");
            }
            else if (helpState.currentPage == 2)
            {
                pageText =
                    _T("\u2190 / A\uff1a\u5411\u5de6\u79fb\u52a8\r\n")
                    _T("\u2192 / D\uff1a\u5411\u53f3\u79fb\u52a8\r\n")
                    _T("\u2191 / W\uff1a\u65cb\u8f6c\u65b9\u5757\r\n")
                    _T("\u2193 / S\uff1a\u8f6f\u964d\r\n")
                    _T("Space\uff1a\u786c\u964d\r\n")
                    _T("C / Shift\uff1a备用仓\uff08获得后\uff09\r\n")
                    _T("Z\uff1a黑洞奇点\uff08获得后\uff09\r\n")
                    _T("X\uff1a清屏炸弹\uff08获得后\uff09\r\n")
                    _T("V\uff1a空中换形\uff08获得后\uff09\r\n")
                    _T("P\uff1a\u6682\u505c / \u7ee7\u7eed\r\n")
                    _T("R\uff1a\u91cd\u5f00\u5f53\u524d\u5bf9\u5c40\r\n")
                    _T("M\uff1a\u8fd4\u56de\u4e3b\u83dc\u5355\r\n")
                    _T("死亡后 V：看视频复活一次");
            }
            else if (helpState.currentPage == 3)
            {
                const TCHAR* categoryNames[8] =
                {
                    _T("基础"),
                    _T("保命 / 操作"),
                    _T("清场"),
                    _T("特殊方块"),
                    _T("进阶"),
                    _T("狂热 / 风险"),
                    _T("升级系"),
                    _T("构筑")
                };
                const TCHAR* categoryTexts[8] =
                {
                    _T("赏金纹章：所有得分收益提高 20%，可重复叠加，是最直接的分数成长。\r\n成长印记：所有 EXP 收益提高 25%，可重复叠加，用来更快进入后续构筑。\r\n缓坠羽翼：降低自然下落速度，最多叠加 4 次。\r\n连击律动：连续消行时追加得分和 EXP，断连后重新累计。\r\n先见之眼：额外显示 1 个后续方块；第三个预览由操控大师解锁。"),
                    _T("最后一搏：首次濒死时自动清理底部 3 行，并保留本局继续机会。\r\n备用仓：解锁 C / Shift，将当前方块放入 Hold 仓或取出备用方块。\r\n完美旋转：旋转被阻挡时尝试左右修正，提高贴墙和缝隙旋转成功率。\r\n时间缓流：堆叠过高时自动减速，给危险局面留出处理时间。\r\n空中换形：可重复补充次数，按 V 将当前下落方块变成 I 块。"),
                    _T("卸压清场：获得时立刻清除最高的一条占用行，直接降低顶部压力。\r\n底线清道夫：通过消行充能自动清底；每级降低需求，最多 4 级。\r\n清屏炸弹：可重复补充数量，按 X 主动清理底部 5 行，消行也会继续充能。\r\n黑洞奇点：可重复补充次数，按 Z 吞噬当前场上数量最多的一种颜色方块。"),
                    _T("爆破核心：一次性解锁橙红边框方块，落地后以落点为中心清除 3x3 区域。\r\n棱镜激光：一次性解锁青色边框方块，按落地中心列清除整列固定方块。\r\n十字方块：一次性解锁绿色边框方块，按落地中心同时清除一行一列。\r\n彩虹方块：一次性解锁紫色边框方块，清中心行主色并把覆盖行染成场上主色。\r\n方块改造：提高指定方块出现概率，目前主要强化 I 块生成。"),
                    _T("连锁火花：完成消行后追加随机破坏，适合配合稳定堆叠扩大收益。\r\n连环炸弹：强化爆破核心，将爆破范围从 3x3 扩大为 5x5。\r\n雷霆四消：三消或四消后追加雷击，额外清除局部方块。\r\n雷霆棱镜：三消或四消后追加激光清列，强化四消后的清场能力。"),
                    _T("狂热节拍：累计清除 12 行进入狂热，狂热期间收益更高。\r\n怒火连段：连击越高倍率越高，适合连续小消和稳定节奏。\r\n无尽狂热：狂热期间继续消行会延长狂热时间。\r\n高压悬赏：游戏速度更快，但高压下收益也更高。\r\n豪赌四消：四消收益更高，但非四消表现更不稳定。\r\n极限玩家：危险高度下获得更高收益，同时承担更高操作压力。\r\n赌徒契约：后续强化有概率翻倍或落空，每级提高概率，最多 4 级。"),
                    _T("双重抉择：升级时可额外选择 1 个强化，加快构筑成型。\r\n命运轮盘：升级变为 6 选 2，但选项中可能混入诅咒。\r\n升级冲击波：每次升级后清理底部 2 行。\r\n进化冲击：升级后清理底部 3 行，是升级冲击波的进阶路线。\r\n成长核心：永久提高得分和 EXP 收益 15%。"),
                    _T("操控大师：使用 Hold 后短暂减速，并额外增加预览能力。\r\n方块风暴：接下来 5 个方块都变为 I 块，适合冲四消或紧急清场。\r\n稳定结构：落地后概率填补局部小洞，让场地更平整。\r\n虚空核心：黑洞生效后生成彩虹方块，彩虹生效时会追加小型黑洞。")
                };

                int sectionGap = SS(18);
                int titleHeight = SS(34);
                int bodyPadding = SS(16);
                int contentHeight = contentRect.bottom - contentRect.top;
                int virtualHeight = 0;
                SelectObject(hdc, bodyFont);
                for (int i = 0; i < 8; ++i)
                {
                    RECT calculateBodyRect =
                    {
                        contentRect.left + bodyPadding,
                        0,
                        contentRect.right - bodyPadding,
                        0
                    };
                    DrawText(hdc, categoryTexts[i], -1, &calculateBodyRect, DT_LEFT | DT_TOP | DT_WORDBREAK | DT_CALCRECT);
                    virtualHeight += titleHeight + (calculateBodyRect.bottom - calculateBodyRect.top) + sectionGap;
                }
                int maxHelpScroll = virtualHeight - contentHeight;
                if (maxHelpScroll < 0)
                {
                    maxHelpScroll = 0;
                }
                if (helpScrollOffset > maxHelpScroll)
                {
                    helpScrollOffset = maxHelpScroll;
                }

                HRGN oldClipRegion = CreateRectRgn(0, 0, 0, 0);
                int hasOldClipRegion = GetClipRgn(hdc, oldClipRegion);
                HRGN contentClipRegion = CreateRectRgn(contentRect.left, contentRect.top, contentRect.right, contentRect.bottom);
                SelectClipRgn(hdc, contentClipRegion);

                int sectionTop = contentRect.top - helpScrollOffset;
                for (int i = 0; i < 8; ++i)
                {
                    RECT bodyCalculateRect =
                    {
                        contentRect.left + bodyPadding,
                        0,
                        contentRect.right - bodyPadding,
                        0
                    };
                    SelectObject(hdc, bodyFont);
                    DrawText(hdc, categoryTexts[i], -1, &bodyCalculateRect, DT_LEFT | DT_TOP | DT_WORDBREAK | DT_CALCRECT);
                    int bodyHeight = bodyCalculateRect.bottom - bodyCalculateRect.top;
                    RECT categoryRect =
                    {
                        contentRect.left,
                        sectionTop,
                        contentRect.right,
                        sectionTop + titleHeight + bodyHeight + SS(12)
                    };

                    if (categoryRect.bottom < contentRect.top || categoryRect.top > contentRect.bottom)
                    {
                        sectionTop += titleHeight + bodyHeight + sectionGap;
                        continue;
                    }

                    SetTextColor(hdc, titleColor);
                    SelectObject(hdc, sectionFont);
                    RECT categoryTitleRect =
                    {
                        categoryRect.left,
                        categoryRect.top,
                        categoryRect.right,
                        categoryRect.top + titleHeight
                    };
                    DrawText(hdc, categoryNames[i], -1, &categoryTitleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

                    HPEN categoryLinePen = CreatePen(PS_SOLID, 1, RGB(232, 202, 215));
                    oldPen = (HPEN)SelectObject(hdc, categoryLinePen);
                    MoveToEx(hdc, categoryRect.left, categoryTitleRect.bottom, nullptr);
                    LineTo(hdc, categoryRect.right, categoryTitleRect.bottom);
                    SelectObject(hdc, oldPen);
                    DeleteObject(categoryLinePen);

                    SetTextColor(hdc, RGB(86, 66, 80));
                    SelectObject(hdc, bodyFont);
                    RECT categoryBodyRect =
                    {
                        categoryRect.left + bodyPadding,
                        categoryTitleRect.bottom + SS(10),
                        categoryRect.right - bodyPadding,
                        categoryTitleRect.bottom + SS(10) + bodyHeight
                    };
                    DrawText(hdc, categoryTexts[i], -1, &categoryBodyRect, DT_LEFT | DT_TOP | DT_WORDBREAK);
                    sectionTop += titleHeight + bodyHeight + sectionGap;
                }

                if (hasOldClipRegion == 1)
                {
                    SelectClipRgn(hdc, oldClipRegion);
                }
                else
                {
                    SelectClipRgn(hdc, nullptr);
                }
                DeleteObject(contentClipRegion);
                DeleteObject(oldClipRegion);
            }
            else if (helpState.currentPage == 5)
            {
                int demoCount = GetRogueSkillDemoCount();
                int itemHeight = SS(58);
                int itemGap = SS(10);
                int contentHeight = contentRect.bottom - contentRect.top;
                int virtualHeight = SS(8) + demoCount * (itemHeight + itemGap);
                int maxHelpScroll = virtualHeight - contentHeight;
                if (maxHelpScroll < 0)
                {
                    maxHelpScroll = 0;
                }
                if (helpScrollOffset > maxHelpScroll)
                {
                    helpScrollOffset = maxHelpScroll;
                }

                HRGN oldClipRegion = CreateRectRgn(0, 0, 0, 0);
                int hasOldClipRegion = GetClipRgn(hdc, oldClipRegion);
                HRGN contentClipRegion = CreateRectRgn(contentRect.left, contentRect.top, contentRect.right, contentRect.bottom);
                SelectClipRgn(hdc, contentClipRegion);

                int itemTop = contentRect.top + SS(8) - helpScrollOffset;
                for (int i = 0; i < demoCount; i++)
                {
                    RECT itemRect =
                    {
                        contentRect.left,
                        itemTop + i * (itemHeight + itemGap),
                        contentRect.right,
                        itemTop + i * (itemHeight + itemGap) + itemHeight
                    };

                    if (itemRect.bottom < contentRect.top || itemRect.top > contentRect.bottom)
                    {
                        continue;
                    }

                    bool selected = (i == helpState.selectedIndex);
                    COLORREF itemFill = selected ? RGB(255, 245, 249) : RGB(255, 252, 250);
                    COLORREF itemFrame = selected ? accentColor : frameColor;
                    HPEN itemPen = CreatePen(PS_SOLID, selected ? SS(2) : SS(1), itemFrame);
                    HBRUSH itemBrush = CreateSolidBrush(itemFill);
                    oldPen = (HPEN)SelectObject(hdc, itemPen);
                    oldBrush = (HBRUSH)SelectObject(hdc, itemBrush);
                    RoundRect(hdc, itemRect.left, itemRect.top, itemRect.right, itemRect.bottom, SS(18), SS(18));
                    SelectObject(hdc, oldBrush);
                    SelectObject(hdc, oldPen);
                    DeleteObject(itemBrush);
                    DeleteObject(itemPen);

                    SetTextColor(hdc, selected ? titleColor : textColor);
                    SelectObject(hdc, sectionFont);
                    RECT nameRect =
                    {
                        itemRect.left + SS(22),
                        itemRect.top + SS(8),
                        itemRect.left + SS(210),
                        itemRect.bottom - SS(8)
                    };
                    DrawText(hdc, GetRogueSkillDemoName(i), -1, &nameRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

                    SetTextColor(hdc, RGB(112, 91, 104));
                    SelectObject(hdc, bodyFont);
                    RECT detailRect =
                    {
                        itemRect.left + SS(220),
                        itemRect.top + SS(8),
                        itemRect.right - SS(22),
                        itemRect.bottom - SS(8)
                    };
                    DrawText(hdc, GetRogueSkillDemoDetail(i), -1, &detailRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
                }

                if (hasOldClipRegion == 1)
                {
                    SelectClipRgn(hdc, oldClipRegion);
                }
                else
                {
                    SelectClipRgn(hdc, nullptr);
                }
                DeleteObject(contentClipRegion);
                DeleteObject(oldClipRegion);
            }
            else if (helpState.currentPage == 4)
            {
                const int creditAnimationTotalTicks = 60;
                constexpr int creditPageCount = 4;
                const TCHAR* creditNames[creditPageCount] =
                {
                    _T("qls"),
                    _T("wyk"),
                    _T("juju"),
                    _T("qhy")
                };
                const TCHAR* creditTexts[creditPageCount] =
                {
                    _T("\u611f\u8c22\u6fc0\u60c5\u6295\u8eab\u4e8e\u6d4b\u8bd5\u4e4b\u4e2d\u7684Lisa"),
                    _T("\u611f\u8c22\u70ed\u5ff1coding\u7684\u5c0f\u86cb\u7cd5"),
                    _T("\u611f\u8c22\u8bfe\u524d\u95f2\u91cc\u5077\u5fd9\u7684juju"),
                    _T("\u611f\u8c22qhy\u7684\u5929\u624d\u6784\u60f3")
                };

                int currentCredit = creditPageIndex;
                if (currentCredit < 0)
                {
                    currentCredit = 0;
                }
                if (currentCredit >= creditPageCount)
                {
                    currentCredit = creditPageCount - 1;
                }

                int previousCredit = currentCredit - creditAnimationDirection;
                if (previousCredit < 0)
                {
                    previousCredit = creditPageCount - 1;
                }
                if (previousCredit >= creditPageCount)
                {
                    previousCredit = 0;
                }

                RECT imageArea =
                {
                    contentRect.left + SS(92),
                    contentRect.top + SS(10),
                    contentRect.right - SS(92),
                    contentRect.bottom - SS(112)
                };
                RECT textArea =
                {
                    contentRect.left + SS(72),
                    contentRect.bottom - SS(94),
                    contentRect.right - SS(72),
                    contentRect.bottom - SS(18)
                };

                HRGN oldClipRegion = CreateRectRgn(0, 0, 0, 0);
                int hasOldClipRegion = GetClipRgn(hdc, oldClipRegion);
                HRGN contentClipRegion = CreateRectRgn(contentRect.left, contentRect.top, contentRect.right, contentRect.bottom);
                SelectClipRgn(hdc, contentClipRegion);

                int slideDistance = contentRect.right - contentRect.left;
                int currentOffset = 0;
                int previousOffset = 0;
                if (creditAnimationTicks > 0 && creditAnimationDirection != 0)
                {
                    currentOffset = creditAnimationDirection * slideDistance * creditAnimationTicks / creditAnimationTotalTicks;
                    previousOffset = currentOffset - creditAnimationDirection * slideDistance;
                }

                Bitmap* preloadedCreditImages[creditPageCount] = {};
                for (int i = 0; i < creditPageCount; i++)
                {
                    preloadedCreditImages[i] = LoadCreditImage(i);
                }
                Graphics creditGraphics(hdc);
                creditGraphics.SetInterpolationMode(InterpolationModeHighQualityBilinear);

                auto DrawCreditCard = [&](int cardIndex, int offset)
                {
                    RECT shiftedImageArea = imageArea;
                    RECT shiftedTextArea = textArea;
                    OffsetRect(&shiftedImageArea, offset, 0);
                    OffsetRect(&shiftedTextArea, offset, 0);

                    Bitmap* creditImage = nullptr;
                    if (cardIndex >= 0 && cardIndex < creditPageCount)
                    {
                        creditImage = preloadedCreditImages[cardIndex];
                    }
                    if (creditImage != nullptr)
                    {
                        int imageWidth = static_cast<int>(creditImage->GetWidth());
                        int imageHeight = static_cast<int>(creditImage->GetHeight());
                        int areaWidth = shiftedImageArea.right - shiftedImageArea.left;
                        int areaHeight = shiftedImageArea.bottom - shiftedImageArea.top;
                        int drawWidth = areaWidth;
                        int drawHeight = imageHeight * drawWidth / imageWidth;
                        if (drawHeight > areaHeight)
                        {
                            drawHeight = areaHeight;
                            drawWidth = imageWidth * drawHeight / imageHeight;
                        }

                        int drawLeft = shiftedImageArea.left + (areaWidth - drawWidth) / 2;
                        int drawTop = shiftedImageArea.top + (areaHeight - drawHeight) / 2;
                        creditGraphics.DrawImage(creditImage, Rect(drawLeft, drawTop, drawWidth, drawHeight));
                    }
                    else
                    {
                        HBRUSH missingBrush = CreateSolidBrush(RGB(255, 245, 249));
                        HPEN missingPen = CreatePen(PS_DASH, SS(2), frameColor);
                        oldBrush = (HBRUSH)SelectObject(hdc, missingBrush);
                        oldPen = (HPEN)SelectObject(hdc, missingPen);
                        RoundRect(hdc, shiftedImageArea.left, shiftedImageArea.top, shiftedImageArea.right, shiftedImageArea.bottom, SS(24), SS(24));
                        SelectObject(hdc, oldBrush);
                        SelectObject(hdc, oldPen);
                        DeleteObject(missingPen);
                        DeleteObject(missingBrush);

                        SetTextColor(hdc, RGB(128, 104, 118));
                        SelectObject(hdc, bodyFont);
                        DrawText(hdc, _T("\u56fe\u7247\u8d44\u6e90\u672a\u627e\u5230"), -1, &shiftedImageArea, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
                    }

                    if (creditAnimationTicks <= 0)
                    {
                        SetTextColor(hdc, titleColor);
                        SelectObject(hdc, sectionFont);
                        RECT nameRect =
                        {
                            shiftedTextArea.left,
                            shiftedTextArea.top,
                            shiftedTextArea.right,
                            shiftedTextArea.top + SS(30)
                        };
                        DrawText(hdc, creditNames[cardIndex], -1, &nameRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

                        SetTextColor(hdc, textColor);
                        SelectObject(hdc, bodyFont);
                        RECT detailRect =
                        {
                            shiftedTextArea.left,
                            shiftedTextArea.top + SS(34),
                            shiftedTextArea.right,
                            shiftedTextArea.bottom
                        };
                        DrawText(hdc, creditTexts[cardIndex], -1, &detailRect, DT_CENTER | DT_TOP | DT_WORDBREAK);
                    }
                };

                if (creditAnimationTicks > 0 && creditAnimationDirection != 0)
                {
                    DrawCreditCard(previousCredit, previousOffset);
                }
                DrawCreditCard(currentCredit, currentOffset);

                if (hasOldClipRegion == 1)
                {
                    SelectClipRgn(hdc, oldClipRegion);
                }
                else
                {
                    SelectClipRgn(hdc, nullptr);
                }
                DeleteObject(contentClipRegion);
                DeleteObject(oldClipRegion);

                RECT leftArrow =
                {
                    rulesCard.left + SS(52),
                    (rulesCard.top + rulesCard.bottom) / 2 - SS(27),
                    rulesCard.left + SS(106),
                    (rulesCard.top + rulesCard.bottom) / 2 + SS(27)
                };
                RECT rightArrow =
                {
                    rulesCard.right - SS(106),
                    (rulesCard.top + rulesCard.bottom) / 2 - SS(27),
                    rulesCard.right - SS(52),
                    (rulesCard.top + rulesCard.bottom) / 2 + SS(27)
                };

                HBRUSH arrowBrush = CreateSolidBrush(RGB(255, 245, 249));
                HPEN arrowPen = CreatePen(PS_SOLID, SS(2), accentColor);
                oldBrush = (HBRUSH)SelectObject(hdc, arrowBrush);
                oldPen = (HPEN)SelectObject(hdc, arrowPen);
                RoundRect(hdc, leftArrow.left, leftArrow.top, leftArrow.right, leftArrow.bottom, SS(18), SS(18));
                RoundRect(hdc, rightArrow.left, rightArrow.top, rightArrow.right, rightArrow.bottom, SS(18), SS(18));
                SelectObject(hdc, oldBrush);
                SelectObject(hdc, oldPen);
                DeleteObject(arrowPen);
                DeleteObject(arrowBrush);

                HPEN chevronPen = CreatePen(PS_SOLID, SS(4), titleColor);
                oldPen = (HPEN)SelectObject(hdc, chevronPen);
                MoveToEx(hdc, leftArrow.left + SS(32), leftArrow.top + SS(16), nullptr);
                LineTo(hdc, leftArrow.left + SS(22), leftArrow.top + SS(27));
                LineTo(hdc, leftArrow.left + SS(32), leftArrow.bottom - SS(16));
                MoveToEx(hdc, rightArrow.right - SS(32), rightArrow.top + SS(16), nullptr);
                LineTo(hdc, rightArrow.right - SS(22), rightArrow.top + SS(27));
                LineTo(hdc, rightArrow.right - SS(32), rightArrow.bottom - SS(16));
                SelectObject(hdc, oldPen);
                DeleteObject(chevronPen);
            }
            if (helpState.currentPage != 3 && helpState.currentPage != 4 && helpState.currentPage != 5)
            {
                RECT calculateRect = { contentRect.left, contentRect.top, contentRect.right, contentRect.top };
                DrawText(hdc, pageText, -1, &calculateRect, pageFlags | DT_CALCRECT);
                int maxHelpScroll = (calculateRect.bottom - calculateRect.top) - (contentRect.bottom - contentRect.top);
                if (maxHelpScroll < 0)
                {
                    maxHelpScroll = 0;
                }
                if (helpScrollOffset > maxHelpScroll)
                {
                    helpScrollOffset = maxHelpScroll;
                }

                HRGN oldClipRegion = CreateRectRgn(0, 0, 0, 0);
                int hasOldClipRegion = GetClipRgn(hdc, oldClipRegion);
                HRGN contentClipRegion = CreateRectRgn(contentRect.left, contentRect.top, contentRect.right, contentRect.bottom);
                SelectClipRgn(hdc, contentClipRegion);

                RECT scrolledContentRect = contentRect;
                scrolledContentRect.top -= helpScrollOffset;
                scrolledContentRect.bottom += maxHelpScroll;
                DrawText(hdc, pageText, -1, &scrolledContentRect, pageFlags);

                if (hasOldClipRegion == 1)
                {
                    SelectClipRgn(hdc, oldClipRegion);
                }
                else
                {
                    SelectClipRgn(hdc, nullptr);
                }
                DeleteObject(contentClipRegion);
                DeleteObject(oldClipRegion);
            }
        }

        SelectObject(hdc, smallFont);
        SetTextColor(hdc, RGB(128, 104, 118));
        RECT backHintRect =
        {
            rulesCard.left + SS(36),
            rulesCard.bottom - SS(58),
            rulesCard.right - SS(36),
            rulesCard.bottom - SS(24)
        };
        const TCHAR* helpHint = helpState.currentPage == 0
            ? _T("\u65b9\u5411\u952e / WASD \u5207\u6362\uff0cEnter / Space \u786e\u8ba4\uff0cEsc / M \u8fd4\u56de\u4e3b\u83dc\u5355")
            : (helpState.currentPage == 4
                ? _T("\u5de6\u53f3\u65b9\u5411\u952e / A D \u5207\u6362\uff0cEsc / Backspace / M \u8fd4\u56de\u4e3b\u83dc\u5355")
                : (helpState.currentPage == 5
                    ? _T("\u70b9\u51fb\u6280\u80fd\u540d\u79f0\u6216 Enter \u6f14\u793a\uff0c\u6eda\u8f6e\u7ffb\u52a8\uff0cEsc / Backspace / M \u8fd4\u56de\u5e2e\u52a9")
                    : _T("\u9f20\u6807\u6eda\u8f6e\u4e0a\u4e0b\u7ffb\u52a8\uff0cEsc / Backspace / M \u8fd4\u56de\u5e2e\u52a9")));
        DrawText(hdc, helpHint, -1, &backHintRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

        SelectClipRgn(hdc, nullptr);
        DrawBackButton();
        DrawMusicButton();
        SelectObject(hdc, oldFont);
        DeleteObject(titleFont);
        DeleteObject(sectionFont);
        DeleteObject(bodyFont);
        DeleteObject(smallFont);
        return;
    }

    DrawPanelCardAlpha(
        { gameRect.left - SS(10), gameRect.top - SS(10), gameRect.right + SS(10), gameRect.bottom + SS(10) },
        cardColor,
        frameColor,
        28,
        shellAlpha);
    DrawPanelCardAlpha(leftPanelRect, cardColor, frameColor, 30, shellAlpha);
    DrawPanelCardAlpha(rightPanelRect, cardColor, frameColor, 30, shellAlpha);

    RECT innerRect =
    {
        gameRect.left + SS(6),
        gameRect.top + SS(6),
        gameRect.right - SS(6),
        gameRect.bottom - SS(6)
    };

    {
        Graphics boardGraphics(hdc);
        SolidBrush boardBrush(Color(164, GetRValue(boardColor), GetGValue(boardColor), GetBValue(boardColor)));
        SolidBrush innerBrush(Color(176, GetRValue(boardInnerColor), GetGValue(boardInnerColor), GetBValue(boardInnerColor)));
        boardGraphics.FillRectangle(
            &boardBrush,
            static_cast<INT>(gameRect.left),
            static_cast<INT>(gameRect.top),
            static_cast<INT>(gameRect.right - gameRect.left),
            static_cast<INT>(gameRect.bottom - gameRect.top));
        boardGraphics.FillRectangle(
            &innerBrush,
            static_cast<INT>(innerRect.left),
            static_cast<INT>(innerRect.top),
            static_cast<INT>(innerRect.right - innerRect.left),
            static_cast<INT>(innerRect.bottom - innerRect.top));
    }

    HPEN borderPen = CreatePen(PS_SOLID, SS(2), RGB(132, 108, 146));
    oldPen = (HPEN)SelectObject(hdc, borderPen);
    oldBrush = (HBRUSH)SelectObject(hdc, GetStockObject(NULL_BRUSH));
    RoundRect(hdc, gameRect.left, gameRect.top, gameRect.right, gameRect.bottom, SS(18), SS(18));
    SelectObject(hdc, oldBrush);
    SelectObject(hdc, oldPen);
    DeleteObject(borderPen);

    HPEN gridPen = CreatePen(PS_SOLID, 1, lineColor);
    oldPen = (HPEN)SelectObject(hdc, gridPen);

    for (int i = 1; i < nGameWidth; i++)
    {
        int x = gameRect.left + i * grid;
        MoveToEx(hdc, x, gameRect.top, nullptr);
        LineTo(hdc, x, gameRect.bottom);
    }

    for (int i = 1; i < nGameHeight; i++)
    {
        int y = gameRect.top + i * grid;
        MoveToEx(hdc, gameRect.left, y, nullptr);
        LineTo(hdc, gameRect.right, y);
    }

    SelectObject(hdc, oldPen);
    DeleteObject(gridPen);

    int lockedRows = GetRogueLockedRows();
    if (lockedRows > 0)
    {
        RECT lockedRect =
        {
            gameRect.left,
            gameRect.top + (nGameHeight - lockedRows) * grid,
            gameRect.right,
            gameRect.bottom
        };

        Graphics lockedGraphics(hdc);
        SolidBrush lockedBrush(Color(150, 58, 48, 68));
        Pen lockedPen(Color(210, 232, 170, 194), 1.0f);
        lockedGraphics.FillRectangle(
            &lockedBrush,
            static_cast<INT>(lockedRect.left),
            static_cast<INT>(lockedRect.top),
            static_cast<INT>(lockedRect.right - lockedRect.left),
            static_cast<INT>(lockedRect.bottom - lockedRect.top));
        lockedGraphics.DrawRectangle(
            &lockedPen,
            static_cast<INT>(lockedRect.left),
            static_cast<INT>(lockedRect.top),
            static_cast<INT>(lockedRect.right - lockedRect.left),
            static_cast<INT>(lockedRect.bottom - lockedRect.top));

        SelectObject(hdc, smallFont);
        SetTextColor(hdc, RGB(238, 204, 216));
        RECT lockedTextRect =
        {
            lockedRect.left + SS(12),
            lockedRect.top + SS(8),
            lockedRect.right - SS(12),
            lockedRect.bottom - SS(8)
        };
        DrawText(hdc, _T("封锁区"), -1, &lockedTextRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
    }

    for (int i = 0; i < nGameHeight; i++)
    {
        for (int j = 0; j < nGameWidth; j++)
        {
            if (workRegion[i][j] != 0)
            {
                int cellValue = workRegion[i][j];
                bool isRainbowCell = (cellValue == 8);
                int colorIndex = isRainbowCell ? 0 : (cellValue - 1);
                RECT brickRect =
                {
                    gameRect.left + j * grid + SS(2),
                    gameRect.top + i * grid + SS(2),
                    gameRect.left + (j + 1) * grid - SS(2),
                    gameRect.top + (i + 1) * grid - SS(2)
                };

                COLORREF fillColor = isRainbowCell ? RGB(186, 154, 255) : BrickColor[colorIndex];
                COLORREF borderColor = isRainbowCell ? RGB(250, 238, 255) : RGB(255, 248, 250);
                HBRUSH brickBrush = CreateSolidBrush(fillColor);
                HPEN brickPen = CreatePen(PS_SOLID, isRainbowCell ? SS(2) : 1, borderColor);
                oldPen = (HPEN)SelectObject(hdc, brickPen);
                oldBrush = (HBRUSH)SelectObject(hdc, brickBrush);
                RoundRect(hdc, brickRect.left, brickRect.top, brickRect.right, brickRect.bottom, SS(10), SS(10));
                SelectObject(hdc, oldBrush);
                SelectObject(hdc, oldPen);
                DeleteObject(brickBrush);
                DeleteObject(brickPen);
            }
        }
    }

    if (targetFlag && !gameOverFlag)
    {
        HPEN targetPen = CreatePen(PS_DOT, SS(2), RGB(255, 240, 245));
        oldPen = (HPEN)SelectObject(hdc, targetPen);
        oldBrush = (HBRUSH)SelectObject(hdc, GetStockObject(NULL_BRUSH));

        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                if (bricks[type][state][i][j] != 0)
                {
                    int drawY = target.y + i;
                    int drawX = target.x + j;

                    if (drawY >= 0 && drawY < nGameHeight && drawX >= 0 && drawX < nGameWidth)
                    {
                        RoundRect(
                            hdc,
                            gameRect.left + drawX * grid + SS(5),
                            gameRect.top + drawY * grid + SS(5),
                            gameRect.left + (drawX + 1) * grid - SS(5),
                            gameRect.top + (drawY + 1) * grid - SS(5),
                            SS(8), SS(8));
                    }
                }
            }
        }

        SelectObject(hdc, oldBrush);
        SelectObject(hdc, oldPen);
        DeleteObject(targetPen);
    }

    if (!gameOverFlag)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                if (bricks[type][state][i][j] != 0)
                {
                    int drawY = point.y + i;
                    int drawX = point.x + j;

                    if (drawY >= 0 && drawY < nGameHeight && drawX >= 0 && drawX < nGameWidth)
                    {
                        RECT brickRect =
                        {
                            gameRect.left + drawX * grid + SS(2),
                            gameRect.top + drawY * grid + SS(2),
                            gameRect.left + (drawX + 1) * grid - SS(2),
                            gameRect.top + (drawY + 1) * grid - SS(2)
                        };

                        HBRUSH brickBrush = CreateSolidBrush(BrickColor[type]);
                        COLORREF activeOutlineColor = RGB(255, 250, 252);
                        int activeOutlineWidth = 1;
                        if (currentPieceIsExplosive)
                        {
                            activeOutlineColor = RGB(255, 116, 78);
                            activeOutlineWidth = SS(3);
                        }
                        else if (currentPieceIsLaser)
                        {
                            activeOutlineColor = RGB(120, 232, 255);
                            activeOutlineWidth = SS(3);
                        }
                        else if (currentPieceIsCross)
                        {
                            activeOutlineColor = RGB(196, 255, 132);
                            activeOutlineWidth = SS(3);
                        }
                        else if (currentPieceIsRainbow)
                        {
                            activeOutlineColor = RGB(186, 126, 255);
                            activeOutlineWidth = SS(3);
                        }
                        HPEN brickPen = CreatePen(PS_SOLID, activeOutlineWidth, activeOutlineColor);
                        oldPen = (HPEN)SelectObject(hdc, brickPen);
                        oldBrush = (HBRUSH)SelectObject(hdc, brickBrush);
                        RoundRect(hdc, brickRect.left, brickRect.top, brickRect.right, brickRect.bottom, SS(12), SS(12));
                        SelectObject(hdc, oldBrush);
                        SelectObject(hdc, oldPen);
                        DeleteObject(brickBrush);
                        DeleteObject(brickPen);
                    }
                }
            }
        }
    }

    for (int i = 0; i < 80; i++)
    {
        if (gravityFallEffects[i].ticks <= 0 || gravityFallEffects[i].totalTicks <= 0)
        {
            continue;
        }

        if (gravityFallEffects[i].x < 0 || gravityFallEffects[i].x >= nGameWidth ||
            gravityFallEffects[i].fromY < 0 || gravityFallEffects[i].fromY >= nGameHeight ||
            gravityFallEffects[i].toY < 0 || gravityFallEffects[i].toY >= nGameHeight)
        {
            continue;
        }

        int elapsed = gravityFallEffects[i].totalTicks - gravityFallEffects[i].ticks;
        int travel = gravityFallEffects[i].toY - gravityFallEffects[i].fromY;
        int offsetY = travel * grid * elapsed / gravityFallEffects[i].totalTicks;
        int drawX = gameRect.left + gravityFallEffects[i].x * grid;
        int fromPixelY = gameRect.top + gravityFallEffects[i].fromY * grid;
        int toPixelY = gameRect.top + gravityFallEffects[i].toY * grid;
        int currentPixelY = fromPixelY + offsetY;
        int colorIndex = gravityFallEffects[i].cellValue - 1;
        if (colorIndex < 0 || colorIndex >= 7)
        {
            colorIndex = (gravityFallEffects[i].x + gravityFallEffects[i].toY) % 7;
        }
        COLORREF fallColor = BrickColor[colorIndex];

        int alpha = 56 + gravityFallEffects[i].ticks * 150 / gravityFallEffects[i].totalTicks;
        int trailTop = fromPixelY + grid / 2;
        int trailBottom = currentPixelY + grid / 2;
        if (trailBottom < trailTop + SS(8))
        {
            trailBottom = trailTop + SS(8);
        }
        if (trailBottom > toPixelY + grid / 2)
        {
            trailBottom = toPixelY + grid / 2;
        }

        Graphics fallGraphics(hdc);
        fallGraphics.SetSmoothingMode(SmoothingModeAntiAlias);
        SolidBrush trailBrush(Color(alpha / 2, GetRValue(fallColor), GetGValue(fallColor), GetBValue(fallColor)));
        fallGraphics.FillRectangle(
            &trailBrush,
            static_cast<INT>(drawX + SS(12)),
            static_cast<INT>(trailTop),
            static_cast<INT>(grid - SS(24)),
            static_cast<INT>(trailBottom - trailTop));

        SolidBrush ghostBrush(Color(alpha, GetRValue(fallColor), GetGValue(fallColor), GetBValue(fallColor)));
        Pen ghostPen(Color(230, 255, 255, 255), static_cast<REAL>(SS(2)));
        fallGraphics.FillRectangle(
            &ghostBrush,
            static_cast<INT>(drawX + SS(3)),
            static_cast<INT>(currentPixelY + SS(3)),
            static_cast<INT>(grid - SS(6)),
            static_cast<INT>(grid - SS(6)));
        fallGraphics.DrawRectangle(
            &ghostPen,
            static_cast<INT>(drawX + SS(3)),
            static_cast<INT>(currentPixelY + SS(3)),
            static_cast<INT>(grid - SS(6)),
            static_cast<INT>(grid - SS(6)));
    }

    if (clearEffectState.ticks > 0 && clearEffectState.totalTicks > 0)
    {
        int elapsed = clearEffectState.totalTicks - clearEffectState.ticks;
        int alpha = 42 + clearEffectState.ticks * 150 / clearEffectState.totalTicks;
        int inset = SS(elapsed * 2);
        Graphics flashGraphics(hdc);

        for (int i = 0; i < clearEffectState.rowCount; i++)
        {
            int row = clearEffectState.rows[i];
            if (row < 0 || row >= nGameHeight)
            {
                continue;
            }

            int top = gameRect.top + row * grid + inset;
            int height = grid - inset * 2;
            if (height < SS(4))
            {
                height = SS(4);
            }

            SolidBrush flashBrush(Color(alpha, 255, 248, 174));
            flashGraphics.FillRectangle(
                &flashBrush,
                static_cast<INT>(gameRect.left + SS(2)),
                static_cast<INT>(top),
                static_cast<INT>(gameRect.right - gameRect.left - SS(4)),
                static_cast<INT>(height));
        }
    }

    for (int i = 0; i < 64; i++)
    {
        if (cellFlashEffects[i].ticks <= 0 || cellFlashEffects[i].totalTicks <= 0)
        {
            continue;
        }

        if (cellFlashEffects[i].x < 0 || cellFlashEffects[i].x >= nGameWidth ||
            cellFlashEffects[i].y < 0 || cellFlashEffects[i].y >= nGameHeight)
        {
            continue;
        }

        int alpha = 48 + cellFlashEffects[i].ticks * 168 / cellFlashEffects[i].totalTicks;
        int pulseInset = SS(2 + (cellFlashEffects[i].totalTicks - cellFlashEffects[i].ticks) % 3);
        RECT flashRect =
        {
            gameRect.left + cellFlashEffects[i].x * grid + pulseInset,
            gameRect.top + cellFlashEffects[i].y * grid + pulseInset,
            gameRect.left + (cellFlashEffects[i].x + 1) * grid - pulseInset,
            gameRect.top + (cellFlashEffects[i].y + 1) * grid - pulseInset
        };

        Graphics cellGraphics(hdc);
        cellGraphics.SetSmoothingMode(SmoothingModeAntiAlias);
        SolidBrush cellBrush(Color(alpha, GetRValue(cellFlashEffects[i].color), GetGValue(cellFlashEffects[i].color), GetBValue(cellFlashEffects[i].color)));
        Pen cellPen(Color(230, GetRValue(cellFlashEffects[i].color), GetGValue(cellFlashEffects[i].color), GetBValue(cellFlashEffects[i].color)), static_cast<REAL>(SS(2)));
        cellGraphics.FillRectangle(
            &cellBrush,
            static_cast<INT>(flashRect.left),
            static_cast<INT>(flashRect.top),
            static_cast<INT>(flashRect.right - flashRect.left),
            static_cast<INT>(flashRect.bottom - flashRect.top));
        cellGraphics.DrawRectangle(
            &cellPen,
            static_cast<INT>(flashRect.left),
            static_cast<INT>(flashRect.top),
            static_cast<INT>(flashRect.right - flashRect.left),
            static_cast<INT>(flashRect.bottom - flashRect.top));
    }

    for (int i = 0; i < 96; i++)
    {
        if (particleEffects[i].ticks <= 0 || particleEffects[i].totalTicks <= 0)
        {
            continue;
        }

        int elapsed = particleEffects[i].totalTicks - particleEffects[i].ticks;
        int particleX = gameRect.left + particleEffects[i].boardX * grid / 100 + SS(particleEffects[i].velocityX * elapsed);
        int particleY = gameRect.top + particleEffects[i].boardY * grid / 100 + SS(particleEffects[i].velocityY * elapsed + elapsed * elapsed / 4);
        int particleSize = particleEffects[i].size * particleEffects[i].ticks / particleEffects[i].totalTicks;
        if (particleSize < 2)
        {
            particleSize = 2;
        }
        if (particleSize > 6)
        {
            particleSize = 6;
        }

        RECT particleRect =
        {
            particleX - particleSize,
            particleY - particleSize,
            particleX + particleSize,
            particleY + particleSize
        };

        HBRUSH particleBrush = GetCachedParticleBrush(particleEffects[i].color);
        FillRect(hdc, &particleRect, particleBrush);
    }

    for (int i = 0; i < 8; i++)
    {
        if (floatingTextEffects[i].ticks <= 0 || floatingTextEffects[i].totalTicks <= 0)
        {
            continue;
        }

        int elapsed = floatingTextEffects[i].totalTicks - floatingTextEffects[i].ticks;
        int textX = gameRect.left + floatingTextEffects[i].boardX * grid / 100;
        int textY = gameRect.top + floatingTextEffects[i].boardY * grid / 100 - SS(elapsed * 4);

        HFONT oldFloatFont = (HFONT)SelectObject(hdc, sectionFont);
        SetTextColor(hdc, floatingTextEffects[i].color);
        RECT floatRect =
        {
            textX - SS(160),
            textY - SS(24),
            textX + SS(160),
            textY + SS(28)
        };
        DrawText(hdc, floatingTextEffects[i].text, -1, &floatRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        SelectObject(hdc, oldFloatFont);
    }

    HFONT oldFont = (HFONT)SelectObject(hdc, titleFont);
    DrawPanelHeader(leftPanelRect, _T("战局信息"), 120);
    DrawPanelHeader(rightPanelRect, _T("预览与战术"), 148);

    SelectObject(hdc, sectionFont);
    SetTextColor(hdc, textColor);

    RECT overviewRect =
    {
        leftPanelRect.left + SS(20),
        leftPanelRect.top + SS(98),
        leftPanelRect.right - SS(20),
        leftPanelRect.top + SS(252)
    };
    DrawPanelCardAlpha(overviewRect, RGB(255, 247, 250), RGB(233, 191, 208), 24, panelAlpha);

    SelectObject(hdc, sectionFont);
    SetTextColor(hdc, textColor);
    RECT overviewTitleRect =
    {
        overviewRect.left + SS(18),
        overviewRect.top + SS(12),
        overviewRect.right - SS(18),
        overviewRect.top + SS(42)
    };
    DrawText(hdc, _T("战场状态"), -1, &overviewTitleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

    SelectObject(hdc, bodyFont);
    TCHAR overviewText[160];
    int totalLines = (currentMode == MODE_CLASSIC) ? classicStats.totalLinesCleared : rogueStats.totalLinesCleared;
    if (currentMode == MODE_ROGUE)
    {
        _stprintf_s(
            overviewText,
            _T("得分  %d\r\n模式  Rogue\r\n消行  %d\r\n危险 Lv.%d  封锁 %d"),
            tScore,
            totalLines,
            rogueStats.difficultyLevel,
            GetRogueLockedRows());
    }
    else
    {
        _stprintf_s(
            overviewText,
            _T("得分  %d\r\n模式  经典\r\n消行  %d"),
            tScore,
            totalLines);
    }
    RECT overviewBodyRect =
    {
        overviewRect.left + SS(22),
        overviewRect.top + SS(62),
        overviewRect.right - SS(22),
        overviewRect.bottom - SS(22)
    };
    DrawText(hdc, overviewText, -1, &overviewBodyRect, DT_LEFT | DT_TOP | DT_WORDBREAK);

    if (currentMode == MODE_ROGUE)
    {
        int progressTop = IsRogueSkillDemoMode() ? 350 : 270;
        int progressBottom = IsRogueSkillDemoMode() ? 568 : 488;
        int upgradeTop = IsRogueSkillDemoMode() ? 590 : 510;

        if (IsRogueSkillDemoMode())
        {
            RECT demoSkillRect =
            {
                leftPanelRect.left + SS(20),
                leftPanelRect.top + SS(270),
                leftPanelRect.right - SS(20),
                leftPanelRect.top + SS(332)
            };
            DrawPanelCardAlpha(demoSkillRect, RGB(255, 244, 248), RGB(232, 184, 202), 20, panelNestedAlpha);

            SelectObject(hdc, smallFont);
            SetTextColor(hdc, RGB(132, 102, 118));
            RECT demoSkillLabelRect =
            {
                demoSkillRect.left + SS(18),
                demoSkillRect.top + SS(8),
                demoSkillRect.right - SS(18),
                demoSkillRect.top + SS(26)
            };
            DrawText(hdc, _T("\u5f53\u524d\u6280\u80fd"), -1, &demoSkillLabelRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

            SelectObject(hdc, sectionFont);
            SetTextColor(hdc, titleColor);
            RECT demoSkillNameRect =
            {
                demoSkillRect.left + SS(18),
                demoSkillRect.top + SS(26),
                demoSkillRect.right - SS(18),
                demoSkillRect.bottom - SS(8)
            };
            DrawText(hdc, GetCurrentRogueSkillDemoName(), -1, &demoSkillNameRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
        }

        RECT progressRect =
        {
            leftPanelRect.left + SS(20),
            leftPanelRect.top + SS(progressTop),
            leftPanelRect.right - SS(20),
            leftPanelRect.top + SS(progressBottom)
        };
        DrawPanelCardAlpha(progressRect, RGB(255, 248, 251), RGB(233, 191, 208), 24, panelAlpha);

        SelectObject(hdc, sectionFont);
        SetTextColor(hdc, textColor);
        RECT progressTitleRect =
        {
            progressRect.left + SS(18),
            progressRect.top + SS(12),
            progressRect.right - SS(18),
            progressRect.top + SS(42)
        };
        DrawText(hdc, _T("成长进度"), -1, &progressTitleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

        SelectObject(hdc, bodyFont);
        TCHAR progressText[96];
        _stprintf_s(progressText, _T("等级  %d\r\nEXP  %d / %d"), rogueStats.level, rogueStats.exp, rogueStats.requiredExp);
        RECT progressTextRect =
        {
            progressRect.left + SS(22),
            progressRect.top + SS(56),
            progressRect.right - SS(22),
            progressRect.top + SS(120)
        };
        DrawText(hdc, progressText, -1, &progressTextRect, DT_LEFT | DT_TOP | DT_WORDBREAK);

        RECT expBarRect =
        {
            progressRect.left + SS(22),
            progressRect.top + SS(122),
            progressRect.right - SS(22),
            progressRect.top + SS(148)
        };
        HBRUSH expTrackBrush = CreateSolidBrush(RGB(240, 220, 229));
        FillRect(hdc, &expBarRect, expTrackBrush);
        DeleteObject(expTrackBrush);

        RECT expFillRect = expBarRect;
        int expWidth = expBarRect.right - expBarRect.left;
        if (rogueStats.requiredExp > 0)
        {
            expFillRect.right = expBarRect.left + expWidth * rogueStats.exp / rogueStats.requiredExp;
        }
        if (expFillRect.right < expFillRect.left)
        {
            expFillRect.right = expFillRect.left;
        }
        if (expFillRect.right > expBarRect.right)
        {
            expFillRect.right = expBarRect.right;
        }
        HBRUSH expFillBrush = CreateSolidBrush(accentColor);
        FillRect(hdc, &expFillRect, expFillBrush);
        DeleteObject(expFillBrush);

        const TCHAR* statLabels[2] =
        {
            _T("\u5f97\u5206\u500d\u7387"),
            _T("EXP \u500d\u7387")
        };
        TCHAR statValues[2][32];
        _stprintf_s(statValues[0], _T("%d%%"), rogueStats.scoreMultiplierPercent);
        _stprintf_s(statValues[1], _T("%d%%"), rogueStats.expMultiplierPercent);

        int statGap = SS(8);
        int statWidth = (progressRect.right - progressRect.left - SS(44) - statGap) / 2;
        for (int statIndex = 0; statIndex < 2; statIndex++)
        {
            RECT statRect =
            {
                progressRect.left + SS(22) + statIndex * (statWidth + statGap),
                progressRect.top + SS(154),
                progressRect.left + SS(22) + statIndex * (statWidth + statGap) + statWidth,
                progressRect.top + SS(204)
            };
            DrawPanelCardAlpha(statRect, RGB(255, 239, 245), RGB(232, 184, 202), 16, panelNestedAlpha);

            RECT statLabelRect =
            {
                statRect.left + SS(8),
                statRect.top + SS(4),
                statRect.right - SS(8),
                statRect.top + SS(22)
            };
            RECT statValueRect =
            {
                statRect.left + SS(8),
                statRect.top + SS(21),
                statRect.right - SS(8),
                statRect.bottom - SS(2)
            };

            SelectObject(hdc, smallFont);
            SetTextColor(hdc, RGB(132, 102, 118));
            DrawText(hdc, statLabels[statIndex], -1, &statLabelRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
            SelectObject(hdc, bodyFont);
            SetTextColor(hdc, titleColor);
            DrawText(hdc, statValues[statIndex], -1, &statValueRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        }

        RECT upgradeListRect =
        {
            leftPanelRect.left + SS(20),
            leftPanelRect.top + SS(upgradeTop),
            leftPanelRect.right - SS(20),
            leftPanelRect.bottom - SS(20)
        };
        DrawPanelCardAlpha(upgradeListRect, RGB(255, 248, 251), RGB(233, 191, 208), 24, panelAlpha);

        SelectObject(hdc, sectionFont);
        SetTextColor(hdc, textColor);
        TextOut(hdc, upgradeListRect.left + SS(18), upgradeListRect.top + SS(16), _T("已掌握强化"), lstrlen(_T("已掌握强化")));

        SelectObject(hdc, smallFont);
        SetTextColor(hdc, RGB(148, 118, 132));
        RECT upgradeScrollHintRect =
        {
            upgradeListRect.left + SS(116),
            upgradeListRect.top + SS(17),
            upgradeListRect.right - SS(18),
            upgradeListRect.top + SS(42)
        };
        DrawText(hdc, _T("J/K / 滚轮"), -1, &upgradeScrollHintRect, DT_RIGHT | DT_VCENTER | DT_SINGLELINE);

        SelectObject(hdc, smallFont);
        SetTextColor(hdc, RGB(128, 104, 118));
        RECT upgradeBodyRect =
        {
            upgradeListRect.left + SS(22),
            upgradeListRect.top + SS(56),
            upgradeListRect.right - SS(22),
            upgradeListRect.bottom - SS(20)
        };

        TCHAR upgradeSummary[512];
        upgradeSummary[0] = _T('\0');

        if (rogueStats.scoreUpgradeLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u5206\u6570\u500d\u7387 Lv.%d\r\n"), rogueStats.scoreUpgradeLevel);
        }
        if (rogueStats.expUpgradeLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("EXP \u5f3a\u5316 Lv.%d\r\n"), rogueStats.expUpgradeLevel);
        }
        if (rogueStats.slowFallStacks > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u6162\u901f\u4e0b\u843d Lv.%d\r\n"), rogueStats.slowFallStacks);
        }
        if (rogueStats.comboBonusStacks > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u8fde\u51fb\u52a0\u6210 Lv.%d\r\n"), rogueStats.comboBonusStacks);
        }
        if (rogueStats.previewUpgradeLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u989d\u5916\u9884\u89c8 Lv.%d\r\n"), rogueStats.previewUpgradeLevel);
        }
        if (rogueStats.lastChanceUpgradeLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u6700\u540e\u4e00\u640f Lv.1  \u5269\u4f59 %d \u6b21\r\n"), rogueStats.lastChanceCount);
        }
        if (rogueStats.pressureReliefLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u51cf\u538b Lv.%d\r\n"), rogueStats.pressureReliefLevel);
        }
        if (rogueStats.sweeperLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u6e05\u626b\u8005 Lv.%d\r\n"), rogueStats.sweeperLevel);
        }
        if (rogueStats.explosiveLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u7206\u7834\u65b9\u5757 Lv.%d\r\n"), rogueStats.explosiveLevel);
        }
        if (rogueStats.chainBlastLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u8fde\u9501\u7206\u7834 Lv.1\r\n"));
        }
        if (rogueStats.chainBombLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u8fde\u73af\u70b8\u5f39 Lv.1\r\n"));
        }
        if (rogueStats.laserLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u6fc0\u5149\u65b9\u5757 Lv.%d\r\n"), rogueStats.laserLevel);
        }
        if (rogueStats.thunderTetrisLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u96f7\u9706\u56db\u6d88 Lv.1\r\n"));
        }
        if (rogueStats.thunderLaserLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u96f7\u9706\u6fc0\u5149 Lv.1\r\n"));
        }
        if (rogueStats.feverLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u72c2\u70ed\u6a21\u5f0f Lv.1\r\n"));
        }
        if (rogueStats.rageStackLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u66b4\u8d70\u5806\u53e0 Lv.1\r\n"));
        }
        if (rogueStats.infiniteFeverLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u65e0\u9650\u72c2\u70ed Lv.1\r\n"));
        }
        if (rogueStats.screenBombLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u6e05\u5c4f\u70b8\u5f39 Lv.%d  \u5269\u4f59 %d \u679a\r\n"), rogueStats.screenBombLevel, rogueStats.screenBombCount);
        }
        if (rogueStats.terminalClearLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u7ec8\u672b\u6e05\u573a Lv.1\r\n"));
        }
        if (rogueStats.perfectRotateLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u5b8c\u7f8e\u65cb\u8f6c Lv.1\r\n"));
        }
        if (rogueStats.timeDilationLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u65f6\u95f4\u7f13\u6d41 Lv.1\r\n"));
        }
        if (rogueStats.highPressureLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u9ad8\u538b\u5956\u52b1 Lv.1\r\n"));
        }
        if (rogueStats.tetrisGambleLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u8d4c\u547d\u56db\u6d88 Lv.1\r\n"));
        }
        if (rogueStats.extremePlayerLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u6781\u9650\u73a9\u5bb6 Lv.1\r\n"));
        }
        if (rogueStats.upgradeShockwaveLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u5347\u7ea7\u51b2\u51fb\u6ce2 Lv.1\r\n"));
        }
        if (rogueStats.evolutionImpactLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u8fdb\u5316\u51b2\u51fb Lv.1\r\n"));
        }
        if (rogueStats.controlMasterLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u64cd\u63a7\u5927\u5e08 Lv.1\r\n"));
        }
        if (rogueStats.blockStormLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u65b9\u5757\u98ce\u66b4 Lv.1\r\n"));
        }
        if (rogueStats.crossPieceLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u5341\u5b57\u65b9\u5757 Lv.%d\r\n"), rogueStats.crossPieceLevel);
        }
        if (rogueStats.blackHoleLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u9ed1\u6d1e Lv.%d  \u5269\u4f59 %d \u6b21\r\n"), rogueStats.blackHoleLevel, rogueStats.blackHoleCharges);
        }
        if (rogueStats.reshapeLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u7a7a\u4e2d\u6362\u5f62 Lv.%d  \u5269\u4f59 %d \u6b21\r\n"), rogueStats.reshapeLevel, rogueStats.reshapeCharges);
        }
        if (rogueStats.rainbowPieceLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u5f69\u8679\u65b9\u5757 Lv.1\r\n"));
        }
        if (rogueStats.voidCoreLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u865a\u7a7a\u6838\u5fc3 Lv.1\r\n"));
        }
        if (rogueStats.stableStructureLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u7a33\u5b9a\u7ed3\u6784 Lv.%d\r\n"), rogueStats.stableStructureLevel);
        }
        if (rogueStats.doubleGrowthLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u6210\u957f\u6838\u5fc3 Lv.1\r\n"));
        }
        if (rogueStats.pieceTuningLevels[0] > 0)
        {
            _stprintf_s(
                upgradeSummary + lstrlen(upgradeSummary),
                512 - lstrlen(upgradeSummary),
                _T("I \u65b9\u5757\u6539\u9020 Lv.%d\r\n"),
                rogueStats.pieceTuningLevels[0]);
        }
        if (rogueStats.gamblerLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u8d4c\u5f92 Lv.%d\r\n"), rogueStats.gamblerLevel);
        }
        if (rogueStats.dualChoiceLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u53cc\u91cd\u9009\u62e9 Lv.1\r\n"));
        }
        if (rogueStats.destinyWheelLevel > 0)
        {
            _stprintf_s(upgradeSummary + lstrlen(upgradeSummary), 512 - lstrlen(upgradeSummary), _T("\u547d\u8fd0\u8f6e\u76d8 Lv.1\r\n"));
        }
        if (lstrlen(upgradeSummary) == 0)
        {
            _stprintf_s(upgradeSummary, _T("尚未掌握强化。\r\n下一次升级将开启构筑。"));
        }

        RECT upgradeCalculateRect =
        {
            upgradeBodyRect.left,
            upgradeBodyRect.top,
            upgradeBodyRect.right,
            upgradeBodyRect.top
        };
        DrawText(hdc, upgradeSummary, -1, &upgradeCalculateRect, DT_LEFT | DT_TOP | DT_WORDBREAK | DT_CALCRECT);
        int maxUpgradeScroll = (upgradeCalculateRect.bottom - upgradeCalculateRect.top) - (upgradeBodyRect.bottom - upgradeBodyRect.top);
        if (maxUpgradeScroll < 0)
        {
            maxUpgradeScroll = 0;
        }
        if (upgradeListScrollOffset > maxUpgradeScroll)
        {
            upgradeListScrollOffset = maxUpgradeScroll;
        }

        HRGN oldUpgradeClipRegion = CreateRectRgn(0, 0, 0, 0);
        int hasOldUpgradeClipRegion = GetClipRgn(hdc, oldUpgradeClipRegion);
        HRGN upgradeClipRegion = CreateRectRgn(upgradeBodyRect.left, upgradeBodyRect.top, upgradeBodyRect.right, upgradeBodyRect.bottom);
        SelectClipRgn(hdc, upgradeClipRegion);

        RECT scrolledUpgradeBodyRect = upgradeBodyRect;
        scrolledUpgradeBodyRect.top -= upgradeListScrollOffset;
        scrolledUpgradeBodyRect.bottom += maxUpgradeScroll;
        DrawText(hdc, upgradeSummary, -1, &scrolledUpgradeBodyRect, DT_LEFT | DT_TOP | DT_WORDBREAK);

        if (hasOldUpgradeClipRegion == 1)
        {
            SelectClipRgn(hdc, oldUpgradeClipRegion);
        }
        else
        {
            SelectClipRgn(hdc, nullptr);
        }
        DeleteObject(upgradeClipRegion);
        DeleteObject(oldUpgradeClipRegion);
        SelectObject(hdc, sectionFont);
        SetTextColor(hdc, textColor);
    }
    else
    {
        RECT classicInfoRect =
        {
            leftPanelRect.left + SS(20),
            leftPanelRect.top + SS(270),
            leftPanelRect.right - SS(20),
            leftPanelRect.top + SS(458)
        };
        DrawPanelCardAlpha(classicInfoRect, RGB(255, 248, 251), RGB(233, 191, 208), 24, panelAlpha);
        SelectObject(hdc, smallFont);
        SetTextColor(hdc, RGB(128, 104, 118));
        RECT classicBodyRect =
        {
            classicInfoRect.left + SS(22),
            classicInfoRect.top + SS(24),
            classicInfoRect.right - SS(22),
            classicInfoRect.bottom - SS(24)
        };
        DrawText(hdc, _T("经典模式：没有成长、EXP 和强化，只保留纯粹的消行挑战。\r\n\r\n在有限空间中保持阵型，尽可能活得更久。"), -1, &classicBodyRect, DT_LEFT | DT_TOP | DT_WORDBREAK);
    }
    RECT holdNextRect =
    {
        rightPanelRect.left + SS(20),
        rightPanelRect.top + SS(98),
        rightPanelRect.right - SS(20),
        rightPanelRect.top + SS(326)
    };
    DrawPanelCardAlpha(holdNextRect, RGB(255, 247, 250), RGB(233, 191, 208), 24, panelAlpha);

    RECT holdCard =
    {
        holdNextRect.left + SS(88),
        holdNextRect.top + SS(24),
        holdNextRect.left + SS(150),
        holdNextRect.top + SS(86)
    };

    RECT nextSectionRect =
    {
        holdNextRect.left + SS(18),
        holdNextRect.top + SS(146),
        holdNextRect.right - SS(18),
        holdNextRect.bottom - SS(22)
    };

    SelectObject(hdc, sectionFont);
    SetTextColor(hdc, textColor);
    RECT holdTitleRect =
    {
        holdNextRect.left + SS(18),
        holdNextRect.top + SS(34),
        holdNextRect.left + SS(80),
        holdNextRect.top + SS(70)
    };
    DrawText(hdc, _T("Hold"), -1, &holdTitleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

    RECT nextTitleRect =
    {
        nextSectionRect.left,
        holdNextRect.top + SS(102),
        holdNextRect.right - SS(18),
        holdNextRect.top + SS(136)
    };
    DrawText(hdc, _T("\u4e0b\u4e00\u4e2a"), -1, &nextTitleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

    DrawPanelCardAlpha(holdCard, RGB(255, 238, 244), RGB(233, 191, 208), 22, panelNestedAlpha);

    SelectObject(hdc, smallFont);
    SetTextColor(hdc, RGB(128, 104, 118));
    RECT holdHintRect =
    {
        holdCard.right + SS(14),
        holdCard.top + SS(2),
        holdNextRect.right - SS(18),
        holdCard.bottom - SS(2)
    };
    DrawText(
        hdc,
        currentMode == MODE_ROGUE && rogueStats.holdUnlocked > 0
            ? (holdUsedThisTurn ? _T("已使用\r\n落地后恢复") : _T("C / Shift\r\n暂存一次"))
            : _T("未开启\r\n需备用仓"),
        -1,
        &holdHintRect,
        DT_LEFT | DT_VCENTER | DT_WORDBREAK);

    if (currentMode == MODE_ROGUE)
    {
        if (rogueStats.holdUnlocked == 0)
        {
            SelectObject(hdc, smallFont);
            SetTextColor(hdc, RGB(128, 104, 118));
            RECT holdLockedRect =
            {
                holdCard.left + SS(10),
                holdCard.top + SS(10),
                holdCard.right - SS(10),
                holdCard.bottom - SS(10)
            };
            DrawText(hdc, _T("封存"), -1, &holdLockedRect, DT_CENTER | DT_VCENTER | DT_WORDBREAK);
        }
        else if (holdType >= 0)
        {
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    if (bricks[holdType][0][i][j] != 0)
                    {
                        int holdAvailableWidth = holdCard.right - holdCard.left - SS(16);
                        int holdAvailableHeight = holdCard.bottom - holdCard.top - SS(16);
                        int holdMiniCell = holdAvailableWidth < holdAvailableHeight ? holdAvailableWidth / 4 : holdAvailableHeight / 4;
                        if (holdMiniCell < SS(7))
                        {
                            holdMiniCell = SS(7);
                        }
                        int holdOffsetX = holdCard.left + (holdCard.right - holdCard.left - holdMiniCell * 4) / 2;
                        int holdOffsetY = holdCard.top + (holdCard.bottom - holdCard.top - holdMiniCell * 4) / 2;
                        RECT brickRect =
                        {
                            holdOffsetX + j * holdMiniCell,
                            holdOffsetY + i * holdMiniCell,
                            holdOffsetX + (j + 1) * holdMiniCell - SS(1),
                            holdOffsetY + (i + 1) * holdMiniCell - SS(1)
                        };

                        HBRUSH brickBrush = CreateSolidBrush(BrickColor[holdType]);
                        HPEN brickPen = CreatePen(PS_SOLID, 1, RGB(255, 248, 250));
                        oldPen = (HPEN)SelectObject(hdc, brickPen);
                        oldBrush = (HBRUSH)SelectObject(hdc, brickBrush);
                        RoundRect(hdc, brickRect.left, brickRect.top, brickRect.right, brickRect.bottom, SS(8), SS(8));
                        SelectObject(hdc, oldBrush);
                        SelectObject(hdc, oldPen);
                        DeleteObject(brickBrush);
                        DeleteObject(brickPen);
                    }
                }
            }
        }
        else
        {
            SelectObject(hdc, smallFont);
            SetTextColor(hdc, RGB(128, 104, 118));
            RECT emptyHoldRect =
            {
                holdCard.left + SS(10),
                holdCard.top + SS(10),
                holdCard.right - SS(10),
                holdCard.bottom - SS(10)
            };
            DrawText(hdc, _T("\u7a7a"), -1, &emptyHoldRect, DT_CENTER | DT_VCENTER | DT_WORDBREAK);
        }
    }
    else
    {
        SelectObject(hdc, smallFont);
        SetTextColor(hdc, RGB(128, 104, 118));
        RECT classicHoldRect =
        {
            holdCard.left + SS(10),
            holdCard.top + SS(10),
            holdCard.right - SS(10),
            holdCard.bottom - SS(10)
        };
        DrawText(hdc, _T("\u5173"), -1, &classicHoldRect, DT_CENTER | DT_VCENTER | DT_WORDBREAK);
    }

    int previewCount = 1;
    if (currentMode == MODE_ROGUE)
    {
        previewCount = rogueStats.previewCount;
        if (previewCount < 1)
        {
            previewCount = 1;
        }
        if (previewCount > 3)
        {
            previewCount = 3;
        }
    }

    for (int previewIndex = 0; previewIndex < previewCount; previewIndex++)
    {
        int nextCardGap = SS(8);
        int nextCardWidth = (nextSectionRect.right - nextSectionRect.left - nextCardGap * 2) / 3;
        RECT nextCard =
        {
            nextSectionRect.left + previewIndex * (nextCardWidth + nextCardGap),
            nextSectionRect.top,
            nextSectionRect.left + previewIndex * (nextCardWidth + nextCardGap) + nextCardWidth,
            nextSectionRect.bottom
        };

        DrawPanelCardAlpha(nextCard, RGB(255, 247, 250), RGB(233, 191, 208), 18, panelStrongAlpha);

        int previewType = nextTypes[previewIndex];

        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                if (bricks[previewType][0][i][j] != 0)
                {
                    int nextAvailableWidth = nextCard.right - nextCard.left - SS(14);
                    int nextAvailableHeight = nextCard.bottom - nextCard.top - SS(14);
                    int nextMiniCell = nextAvailableWidth < nextAvailableHeight ? nextAvailableWidth / 4 : nextAvailableHeight / 4;
                    if (nextMiniCell < SS(7))
                    {
                        nextMiniCell = SS(7);
                    }
                    int previewOffsetX = nextCard.left + (nextCard.right - nextCard.left - nextMiniCell * 4) / 2;
                    int previewOffsetY = nextCard.top + (nextCard.bottom - nextCard.top - nextMiniCell * 4) / 2;
                    RECT brickRect =
                    {
                        previewOffsetX + j * nextMiniCell,
                        previewOffsetY + i * nextMiniCell,
                        previewOffsetX + (j + 1) * nextMiniCell - SS(1),
                        previewOffsetY + (i + 1) * nextMiniCell - SS(1)
                    };

                    HBRUSH brickBrush = CreateSolidBrush(BrickColor[previewType]);
                    HPEN brickPen = CreatePen(PS_SOLID, 1, RGB(255, 248, 250));
                    oldPen = (HPEN)SelectObject(hdc, brickPen);
                    oldBrush = (HBRUSH)SelectObject(hdc, brickBrush);
                    RoundRect(hdc, brickRect.left, brickRect.top, brickRect.right, brickRect.bottom, SS(8), SS(8));
                    SelectObject(hdc, oldBrush);
                    SelectObject(hdc, oldPen);
                    DeleteObject(brickBrush);
                    DeleteObject(brickPen);
                }
            }
        }
    }

    RECT controlRect =
    {
        rightPanelRect.left + SS(20),
        rightPanelRect.top + SS(346),
        rightPanelRect.right - SS(20),
        rightPanelRect.bottom - SS(20)
    };
    DrawPanelCardAlpha(controlRect, RGB(255, 248, 251), RGB(233, 191, 208), 24, panelAlpha);

    SelectObject(hdc, sectionFont);
    SetTextColor(hdc, textColor);
    TextOut(hdc, controlRect.left + SS(18), controlRect.top + SS(16), _T("战斗日志"), lstrlen(_T("战斗日志")));

    RECT feedbackPanelRect =
    {
        controlRect.left + SS(18),
        controlRect.top + SS(56),
        controlRect.right - SS(18),
        controlRect.top + SS(172)
    };
    DrawPanelCardAlpha(feedbackPanelRect, RGB(255, 244, 248), RGB(232, 184, 202), 20, panelNestedAlpha);

    SelectObject(hdc, bodyFont);
    SetTextColor(hdc, titleColor);
    RECT feedbackTitleRect =
    {
        feedbackPanelRect.left + SS(16),
        feedbackPanelRect.top + SS(14),
        feedbackPanelRect.right - SS(16),
        feedbackPanelRect.top + SS(42)
    };
    DrawText(
        hdc,
        feedbackState.visibleTicks > 0 ? feedbackState.title : _T("局势平稳"),
        -1,
        &feedbackTitleRect,
        DT_LEFT | DT_VCENTER | DT_SINGLELINE);

    SelectObject(hdc, smallFont);
    SetTextColor(hdc, RGB(116, 90, 104));
    RECT feedbackBodyRect =
    {
        feedbackPanelRect.left + SS(16),
        feedbackPanelRect.top + SS(46),
        feedbackPanelRect.right - SS(16),
        feedbackPanelRect.bottom - SS(14)
    };
    DrawText(
        hdc,
        feedbackState.visibleTicks > 0
            ? feedbackState.detail
            : _T("连消、主动技能和特殊方块的战斗记录会出现在这里。"),
        -1,
        &feedbackBodyRect,
        DT_LEFT | DT_TOP | DT_WORDBREAK);

    SelectObject(hdc, sectionFont);
    SetTextColor(hdc, textColor);
    RECT tipsTitleRect =
    {
        controlRect.left + SS(22),
        controlRect.top + SS(192),
        controlRect.right - SS(22),
        controlRect.top + SS(224)
    };
    DrawText(hdc, _T("操作指令"), -1, &tipsTitleRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

    SelectObject(hdc, bodyFont);
    SetTextColor(hdc, RGB(128, 104, 118));
    RECT controlBodyRect =
    {
        controlRect.left + SS(22),
        controlRect.top + SS(232),
        controlRect.right - SS(22),
        controlRect.bottom - SS(22)
    };
    if (currentMode == MODE_ROGUE)
    {
        DrawText(
            hdc,
            _T("\u79fb\u52a8\uff1a\u2190/\u2192 \u6216 A/D\r\n")
            _T("\u65cb\u8f6c/\u4e0b\u843d\uff1a\u2191/W\u3001\u2193/S\u3001Space\r\n")
            _T("战局：P 暂停   R 重开   M 菜单\r\n")
            _T("技能：C 备用仓   Z 黑洞   X 炸弹   V 换形"),
            -1,
            &controlBodyRect,
            DT_LEFT | DT_TOP | DT_WORDBREAK);
    }
    else
    {
        DrawText(
            hdc,
            _T("\u79fb\u52a8\uff1a\u2190/\u2192 \u6216 A/D\r\n")
            _T("\u65cb\u8f6c/\u4e0b\u843d\uff1a\u2191/W\u3001\u2193/S\u3001Space\r\n")
            _T("战局：P 暂停   R 重开   M 菜单"),
            -1,
            &controlBodyRect,
            DT_LEFT | DT_TOP | DT_WORDBREAK);
    }

    if (suspendFlag || gameOverFlag)
    {
        RECT overlayRect =
        {
            gameRect.left + SS(28),
            gameRect.top + grid * 6 + SS(10),
            gameRect.right - SS(28),
            gameRect.top + grid * 10 + SS(30)
        };

        HBRUSH overlayBrush = CreateSolidBrush(RGB(255, 241, 246));
        HPEN overlayPen = CreatePen(PS_SOLID, 2, RGB(232, 170, 194));
        oldPen = (HPEN)SelectObject(hdc, overlayPen);
        oldBrush = (HBRUSH)SelectObject(hdc, overlayBrush);
        RoundRect(hdc, overlayRect.left, overlayRect.top, overlayRect.right, overlayRect.bottom, SS(26), SS(26));
        SelectObject(hdc, oldBrush);
        SelectObject(hdc, oldPen);
        DeleteObject(overlayBrush);
        DeleteObject(overlayPen);

        RECT titleRect =
        {
            overlayRect.left + SS(24),
            overlayRect.top + SS(18),
            overlayRect.right - SS(24),
            overlayRect.top + SS(78)
        };

        RECT tipRect =
        {
            overlayRect.left + SS(28),
            overlayRect.top + SS(86),
            overlayRect.right - SS(28),
            overlayRect.bottom - SS(20)
        };

        SetTextColor(hdc, RGB(121, 76, 99));
        SelectObject(hdc, titleFont);

        if (suspendFlag)
        {
            DrawText(hdc, _T("时间静止"), -1, &titleRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
            int buttonGap = SS(18);
            int buttonWidth = (overlayRect.right - overlayRect.left - SS(68) - buttonGap) / 2;
            RECT continueRect =
            {
                overlayRect.left + SS(34),
                overlayRect.top + SS(94),
                overlayRect.left + SS(34) + buttonWidth,
                overlayRect.top + SS(138)
            };
            RECT menuRect =
            {
                continueRect.right + buttonGap,
                continueRect.top,
                overlayRect.right - SS(34),
                continueRect.bottom
            };
            DrawPanelCardAlpha(continueRect, RGB(255, 232, 240), RGB(222, 130, 166), 18, 224);
            DrawPanelCardAlpha(menuRect, RGB(255, 247, 250), RGB(210, 182, 194), 18, 210);
            SelectObject(hdc, bodyFont);
            DrawText(hdc, _T("继续 (P)"), -1, &continueRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
            DrawText(hdc, _T("主菜单 (M)"), -1, &menuRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        }
        else
        {
            DrawText(hdc, _T("战局崩塌"), -1, &titleRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
            if (reviveAvailable)
            {
                int buttonGap = SS(8);
                int buttonWidth = (overlayRect.right - overlayRect.left - SS(28) - buttonGap * 2) / 3;
                RECT reviveRect =
                {
                    overlayRect.left + SS(14),
                    overlayRect.top + SS(94),
                    overlayRect.left + SS(14) + buttonWidth,
                    overlayRect.top + SS(138)
                };
                RECT restartRect =
                {
                    reviveRect.right + buttonGap,
                    reviveRect.top,
                    reviveRect.right + buttonGap + buttonWidth,
                    reviveRect.bottom
                };
                RECT menuRect =
                {
                    restartRect.right + buttonGap,
                    reviveRect.top,
                    overlayRect.right - SS(14),
                    reviveRect.bottom
                };
                DrawPanelCardAlpha(reviveRect, RGB(255, 232, 240), RGB(222, 130, 166), 18, 224);
                DrawPanelCardAlpha(restartRect, RGB(255, 247, 250), RGB(210, 182, 194), 18, 210);
                DrawPanelCardAlpha(menuRect, RGB(255, 247, 250), RGB(210, 182, 194), 18, 210);
                SelectObject(hdc, bodyFont);
                DrawText(hdc, _T("复活 (V)"), -1, &reviveRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
                DrawText(hdc, _T("重开 (R)"), -1, &restartRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
                DrawText(hdc, _T("主菜单 (M)"), -1, &menuRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
            }
            else
            {
                int buttonGap = SS(18);
                int buttonWidth = (overlayRect.right - overlayRect.left - SS(68) - buttonGap) / 2;
                RECT restartRect =
                {
                    overlayRect.left + SS(34),
                    overlayRect.top + SS(94),
                    overlayRect.left + SS(34) + buttonWidth,
                    overlayRect.top + SS(138)
                };
                RECT menuRect =
                {
                    restartRect.right + buttonGap,
                    restartRect.top,
                    overlayRect.right - SS(34),
                    restartRect.bottom
                };
                DrawPanelCardAlpha(restartRect, RGB(255, 232, 240), RGB(222, 130, 166), 18, 224);
                DrawPanelCardAlpha(menuRect, RGB(255, 247, 250), RGB(210, 182, 194), 18, 210);
                SelectObject(hdc, bodyFont);
                DrawText(hdc, _T("重开 (R)"), -1, &restartRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
                DrawText(hdc, _T("主菜单 (M)"), -1, &menuRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
            }
        }
    }

    if (currentScreen == SCREEN_UPGRADE)
    {
        RECT dimRect =
        {
            SX(20),
            SY(20),
            SX(WINDOW_CLIENT_WIDTH - 20),
            SY(WINDOW_CLIENT_HEIGHT - 20)
        };
        Graphics dimGraphics(hdc);
        SolidBrush dimBrush(Color(214, 246, 232, 238));
        dimGraphics.FillRectangle(
            &dimBrush,
            static_cast<INT>(dimRect.left),
            static_cast<INT>(dimRect.top),
            static_cast<INT>(dimRect.right - dimRect.left),
            static_cast<INT>(dimRect.bottom - dimRect.top));

        RECT overlayRect =
        {
            SX(60),
            SY(80),
            SX(WINDOW_CLIENT_WIDTH - 60),
            SY(WINDOW_CLIENT_HEIGHT - 80)
        };

        DrawPanelCardAlpha(overlayRect, RGB(255, 250, 252), RGB(232, 170, 194), 30, 238);

        SetTextColor(hdc, titleColor);
        SelectObject(hdc, titleFont);

        RECT overlayTitleRect =
        {
            overlayRect.left,
            overlayRect.top + SS(24),
            overlayRect.right,
            overlayRect.top + SS(68)
        };
        DrawText(hdc, _T("选择强化"), -1, &overlayTitleRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

        SelectObject(hdc, bodyFont);
        SetTextColor(hdc, textColor);
        RECT overlaySubtitleRect =
        {
            overlayRect.left,
            overlayRect.top + SS(70),
            overlayRect.right,
            overlayRect.top + SS(106)
        };
        TCHAR overlaySubtitle[128];
        if (upgradeUiState.picksRemaining > 1)
        {
            _stprintf_s(
                overlaySubtitle,
                _T("出现 %d 个强化，请标记 %d 个（已选 %d 个）"),
                upgradeUiState.optionCount,
                upgradeUiState.picksRemaining,
                upgradeUiState.markedCount);
        }
        else
        {
            _stprintf_s(
                overlaySubtitle,
                _T("出现 %d 个强化，还可选择 %d 个"),
                upgradeUiState.optionCount,
                upgradeUiState.picksRemaining);
        }
        DrawText(hdc, overlaySubtitle, -1, &overlaySubtitleRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

        int gap = SS(18);
        int horizontalPadding = SS(36);
        int verticalTop = overlayRect.top + SS(138);
        int columnCount = upgradeUiState.optionCount <= 3 ? upgradeUiState.optionCount : 3;
        if (columnCount < 1)
        {
            columnCount = 1;
        }
        int rowCount = (upgradeUiState.optionCount + columnCount - 1) / columnCount;
        if (rowCount < 1)
        {
            rowCount = 1;
        }
        int cardWidth = (overlayRect.right - overlayRect.left - horizontalPadding * 2 - gap * (columnCount - 1)) / columnCount;
        int availableHeight = overlayRect.bottom - verticalTop - SS(72) - (rowCount - 1) * gap;
        int cardHeight = availableHeight / rowCount;

        for (int i = 0; i < upgradeUiState.optionCount; i++)
        {
            bool isSelected = (i == upgradeUiState.selectedIndex);
            bool isMarked = upgradeUiState.marked[i];
            int column = i % columnCount;
            int row = i / columnCount;
            int left = overlayRect.left + horizontalPadding + column * (cardWidth + gap);
            int top = verticalTop + row * (cardHeight + gap);
            int right = left + cardWidth;

            RECT cardRect =
            {
                left,
                top,
                right,
                top + cardHeight
            };

            COLORREF cardFill = RGB(255, 247, 250);
            COLORREF cardBorder = RGB(221, 197, 208);
            COLORREF descColor = RGB(108, 86, 99);
            COLORREF footerColor = RGB(128, 104, 118);
            const TCHAR* synthesisPath = GetUpgradeSynthesisPath(upgradeUiState.options[i].id);
            bool hasSynthesisPath = synthesisPath != nullptr && lstrlen(synthesisPath) > 0;
            const TCHAR* rarityText = _T("\u7a00\u6709\u5ea6\uff1a\u666e\u901a");

            if (upgradeUiState.options[i].cursed)
            {
                cardFill = isSelected ? RGB(238, 232, 238) : RGB(250, 245, 248);
                cardBorder = RGB(38, 34, 42);
                descColor = RGB(72, 62, 72);
                footerColor = RGB(48, 42, 50);
                rarityText = _T("\u8bc5\u5492\uff1a\u4e0b\u6b21\u5347\u7ea7\u6240\u9700 EXP +25%");
            }
            else if (hasSynthesisPath)
            {
                cardBorder = RGB(208, 74, 78);
                footerColor = RGB(164, 58, 64);
                rarityText = _T("\u7a00\u6709\u5ea6\uff1a\u8fdb\u9636");
            }
            else if (upgradeUiState.options[i].rarity == UPGRADE_RARITY_RARE)
            {
                cardBorder = RGB(218, 172, 72);
                footerColor = RGB(150, 111, 40);
                rarityText = _T("\u7a00\u6709\u5ea6\uff1a\u73cd\u7a00");
            }
            else if (upgradeUiState.options[i].rarity == UPGRADE_RARITY_UNCOMMON)
            {
                cardBorder = RGB(92, 152, 218);
                footerColor = RGB(68, 112, 166);
                rarityText = _T("\u7a00\u6709\u5ea6\uff1a\u7f55\u89c1");
            }

            if (isMarked && !upgradeUiState.options[i].cursed)
            {
                cardFill = RGB(255, 226, 236);
            }

            if (isSelected && !upgradeUiState.options[i].cursed)
            {
                cardFill = RGB(255, 235, 242);
            }

            DrawPanelCardAlpha(cardRect, cardFill, cardBorder, 24, isSelected ? 238 : 226);
            if (isSelected)
            {
                HPEN selectedPen = CreatePen(PS_SOLID, SS(3), cardBorder);
                oldPen = (HPEN)SelectObject(hdc, selectedPen);
                oldBrush = (HBRUSH)SelectObject(hdc, GetStockObject(NULL_BRUSH));
                RoundRect(hdc, cardRect.left, cardRect.top, cardRect.right, cardRect.bottom, SS(24), SS(24));
                SelectObject(hdc, oldBrush);
                SelectObject(hdc, oldPen);
                DeleteObject(selectedPen);
            }

            TCHAR levelText[32];
            _stprintf_s(levelText, _T("Lv.%d"), upgradeUiState.options[i].currentLevel + 1);
            RECT levelRect =
            {
                cardRect.right - SS(88),
                cardRect.top + SS(20),
                cardRect.right - SS(20),
                cardRect.top + SS(48)
            };
            SelectObject(hdc, smallFont);
            SetTextColor(hdc, footerColor);
            if (isMarked)
            {
                DrawText(hdc, _T("[已选]"), -1, &levelRect, DT_RIGHT | DT_VCENTER | DT_SINGLELINE);
            }
            else
            {
                DrawText(hdc, levelText, -1, &levelRect, DT_RIGHT | DT_VCENTER | DT_SINGLELINE);
            }

            if (hasSynthesisPath)
            {
                SelectObject(hdc, smallFont);
                SetTextColor(hdc, upgradeUiState.options[i].cursed ? RGB(142, 78, 78) : RGB(116, 82, 104));
                RECT synthesisRect =
                {
                    cardRect.left + SS(20),
                    cardRect.top + SS(18),
                    cardRect.right - SS(116),
                    cardRect.top + SS(40)
                };
                DrawText(hdc, synthesisPath, -1, &synthesisRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
            }

            SelectObject(hdc, sectionFont);
            SetTextColor(hdc, upgradeUiState.options[i].cursed ? RGB(130, 54, 54) : (isSelected ? titleColor : textColor));
            RECT nameRect =
            {
                cardRect.left + SS(20),
                cardRect.top + (hasSynthesisPath ? SS(44) : SS(38)),
                cardRect.right - SS(20),
                cardRect.top + (hasSynthesisPath ? SS(76) : SS(70))
            };
            DrawText(hdc, upgradeUiState.options[i].name, -1, &nameRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

            SelectObject(hdc, bodyFont);
            SetTextColor(hdc, descColor);
            RECT descRect =
            {
                cardRect.left + SS(20),
                cardRect.top + (hasSynthesisPath ? SS(84) : SS(78)),
                cardRect.right - SS(20),
                cardRect.bottom - SS(48)
            };
            DrawText(hdc, upgradeUiState.options[i].description, -1, &descRect, DT_LEFT | DT_TOP | DT_WORDBREAK | DT_END_ELLIPSIS);

            SelectObject(hdc, smallFont);
            RECT footerRect =
            {
                cardRect.left + SS(20),
                cardRect.bottom - SS(34),
                cardRect.right - SS(20),
                cardRect.bottom - SS(10)
            };
            SetTextColor(hdc, footerColor);
            DrawText(
                hdc,
                rarityText,
                -1,
                &footerRect,
                DT_LEFT | DT_VCENTER | DT_SINGLELINE);
        }

        SelectObject(hdc, smallFont);
        SetTextColor(hdc, RGB(128, 104, 118));
        RECT hintRect =
        {
            overlayRect.left + SS(30),
            overlayRect.bottom - SS(52),
            overlayRect.right - SS(30),
            overlayRect.bottom - SS(18)
        };
        DrawText(
            hdc,
            upgradeUiState.picksRemaining > 1
                ? _T("W/A/S/D 或方向键切换，Space 标记，Enter 确认已选强化")
                : _T("W/A/S/D 或方向键切换，Enter 或 Space 确认"),
            -1,
            &hintRect,
            DT_CENTER | DT_VCENTER | DT_SINGLELINE);
    }

    if (currentScreen != SCREEN_MENU)
    {
        DrawBackButton();
    }
    DrawMusicButton();

    SelectObject(hdc, oldFont);
    DeleteObject(titleFont);
    DeleteObject(sectionFont);
    DeleteObject(bodyFont);
    DeleteObject(smallFont);
}