#include "stdafx.h"
#include "Tetris.h"
#include <string>
#include <shellapi.h>

#define MAX_LOADSTRING 100
#define GAME_TIMER_ID 1
#define EFFECT_TIMER_ID 2
#define CREDIT_TIMER_ID 3
#define WM_CREDIT_TICK (WM_APP + 1)
#define GAME_TIMER_INTERVAL 500
#define EFFECT_TIMER_INTERVAL 16
#define CREDIT_TIMER_INTERVAL 5

HINSTANCE hInst;
TCHAR szTitle[MAX_LOADSTRING];
TCHAR szWindowClass[MAX_LOADSTRING];
bool bgmEnabled = true;

static bool bgmPlaying = false;
static bool bgmUsingMci = false;
static MMRESULT creditTimerHandle = 0;
static constexpr const wchar_t* kBgmAlias = L"TereisBgm";
static constexpr const wchar_t* kReviveVideoAlias = L"TereisReviveVideo";

ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
static std::wstring BuildAssetPath(const wchar_t* relativePath);
static std::wstring BuildWorkingDirAssetPath(const wchar_t* relativePath);
static bool FileExists(const std::wstring& path);
static void StopBackgroundMusic();
static void StartBackgroundMusic();

/**
 * @brief 多媒体定时器回调，用于高频率请求致谢页动画刷新。
 */
static void CALLBACK CreditTimerCallback(UINT, UINT, DWORD_PTR userData, DWORD_PTR, DWORD_PTR)
{
    HWND hWnd = reinterpret_cast<HWND>(userData);
    if (hWnd != nullptr)
    {
        PostMessage(hWnd, WM_CREDIT_TICK, 0, 0);
    }
}

/**
 * @brief 将指定滚动偏移按步长调整，并限制在非负范围内。
 */
static void AdjustScrollOffset(int& scrollOffset, int delta)
{
    scrollOffset += delta;
    if (scrollOffset < 0)
    {
        scrollOffset = 0;
    }
    if (scrollOffset > 2400)
    {
        scrollOffset = 2400;
    }
}

/**
 * @brief 按当前窗口缩放返回一次滚动操作的像素距离。
 */
static int GetScrollStep(HWND hWnd, int baseStep)
{
    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;
    }

    return MulDiv(baseStep, scale, 1000);
}

struct LayoutMetrics
{
    int scale;
    int offsetX;
    int offsetY;
    int layoutWidth;
    int layoutHeight;
    int grid;
};

static LayoutMetrics GetLayoutMetrics(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;
    }

    LayoutMetrics metrics = {};
    metrics.scale = scale;
    metrics.layoutWidth = MulDiv(WINDOW_CLIENT_WIDTH, scale, 1000);
    metrics.layoutHeight = MulDiv(WINDOW_CLIENT_HEIGHT, scale, 1000);
    metrics.offsetX = (clientWidth - metrics.layoutWidth) / 2;
    metrics.offsetY = 0;
    metrics.grid = MulDiv(GRID, scale, 1000);
    return metrics;
}

static int ScaleValue(const LayoutMetrics& metrics, int value)
{
    return MulDiv(value, metrics.scale, 1000);
}

static int ScaleXValue(const LayoutMetrics& metrics, int value)
{
    return metrics.offsetX + MulDiv(value, metrics.scale, 1000);
}

static int ScaleYValue(const LayoutMetrics& metrics, int value)
{
    return metrics.offsetY + MulDiv(value, metrics.scale, 1000);
}

static RECT GetMenuCardRect(HWND hWnd)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT rect =
    {
        ScaleXValue(metrics, 110),
        ScaleYValue(metrics, 70),
        ScaleXValue(metrics, WINDOW_CLIENT_WIDTH - 110),
        ScaleYValue(metrics, WINDOW_CLIENT_HEIGHT - 70)
    };
    return rect;
}

static RECT GetMenuOptionRect(HWND hWnd, int index)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT menuCard = GetMenuCardRect(hWnd);
    int top = menuCard.top + ScaleValue(metrics, 140) + index * ScaleValue(metrics, 130);
    RECT rect =
    {
        menuCard.left + ScaleValue(metrics, 36),
        top,
        menuCard.right - ScaleValue(metrics, 36),
        top + ScaleValue(metrics, 104)
    };
    return rect;
}

static RECT GetRulesCardRect(HWND hWnd)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT rect =
    {
        ScaleXValue(metrics, 76),
        ScaleYValue(metrics, 54),
        ScaleXValue(metrics, WINDOW_CLIENT_WIDTH - 76),
        ScaleYValue(metrics, WINDOW_CLIENT_HEIGHT - 54)
    };
    return rect;
}

static RECT GetHelpOptionRect(HWND hWnd, int index)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT rulesCard = GetRulesCardRect(hWnd);
    RECT contentRect =
    {
        rulesCard.left + ScaleValue(metrics, 36),
        rulesCard.top + ScaleValue(metrics, 126),
        rulesCard.right - ScaleValue(metrics, 36),
        rulesCard.bottom - ScaleValue(metrics, 86)
    };
    int optionHeight = ScaleValue(metrics, 100);
    int optionGap = ScaleValue(metrics, 22);
    int optionTop = contentRect.top + ScaleValue(metrics, 18);
    RECT rect =
    {
        contentRect.left,
        optionTop + index * (optionHeight + optionGap),
        contentRect.right,
        optionTop + index * (optionHeight + optionGap) + optionHeight
    };
    return rect;
}

static RECT GetHelpSkillDemoItemRect(HWND hWnd, int index)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT rulesCard = GetRulesCardRect(hWnd);
    RECT contentRect =
    {
        rulesCard.left + ScaleValue(metrics, 36),
        rulesCard.top + ScaleValue(metrics, 126),
        rulesCard.right - ScaleValue(metrics, 36),
        rulesCard.bottom - ScaleValue(metrics, 86)
    };
    int itemHeight = ScaleValue(metrics, 58);
    int itemGap = ScaleValue(metrics, 10);
    int itemTop = contentRect.top + ScaleValue(metrics, 8) - helpScrollOffset;
    RECT rect =
    {
        contentRect.left,
        itemTop + index * (itemHeight + itemGap),
        contentRect.right,
        itemTop + index * (itemHeight + itemGap) + itemHeight
    };
    return rect;
}

static RECT GetHelpBackHintRect(HWND hWnd)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT rulesCard = GetRulesCardRect(hWnd);
    RECT rect =
    {
        rulesCard.left + ScaleValue(metrics, 36),
        rulesCard.bottom - ScaleValue(metrics, 58),
        rulesCard.right - ScaleValue(metrics, 36),
        rulesCard.bottom - ScaleValue(metrics, 24)
    };
    return rect;
}

/**
 * @brief 获取致谢页左右切换按钮的绘制和点击区域。
 */
static RECT GetCreditArrowRect(HWND hWnd, int direction)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT rulesCard = GetRulesCardRect(hWnd);
    int size = ScaleValue(metrics, 54);
    int centerY = (rulesCard.top + rulesCard.bottom) / 2;
    int left = direction < 0
        ? rulesCard.left + ScaleValue(metrics, 52)
        : rulesCard.right - ScaleValue(metrics, 52) - size;

    RECT rect =
    {
        left,
        centerY - size / 2,
        left + size,
        centerY + size / 2
    };
    return rect;
}

static RECT GetUpgradeOverlayRect(HWND hWnd)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT rect =
    {
        ScaleXValue(metrics, 60),
        ScaleYValue(metrics, 80),
        ScaleXValue(metrics, WINDOW_CLIENT_WIDTH - 60),
        ScaleYValue(metrics, WINDOW_CLIENT_HEIGHT - 80)
    };
    return rect;
}

static RECT GetUpgradeCardRect(HWND hWnd, int index)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT overlayRect = GetUpgradeOverlayRect(hWnd);
    int gap = ScaleValue(metrics, 18);
    int horizontalPadding = ScaleValue(metrics, 36);
    int verticalTop = overlayRect.top + ScaleValue(metrics, 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 - ScaleValue(metrics, 72) - (rowCount - 1) * gap;
    int cardHeight = availableHeight / rowCount;
    int column = index % columnCount;
    int row = index / columnCount;
    int left = overlayRect.left + horizontalPadding + column * (cardWidth + gap);
    int top = verticalTop + row * (cardHeight + gap);
    RECT rect = { left, top, left + cardWidth, top + cardHeight };
    return rect;
}

static RECT GetGameOverlayRect(HWND hWnd)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    int panelGap = ScaleValue(metrics, SIDE_PANEL_GAP);
    int panelWidth = ScaleValue(metrics, SIDE_PANEL_WIDTH);
    int boardLeft = ScaleXValue(metrics, WINDOW_PADDING) + panelWidth + panelGap;
    int boardTop = ScaleYValue(metrics, WINDOW_PADDING);
    int boardWidth = nGameWidth * metrics.grid;
    RECT rect =
    {
        boardLeft + ScaleValue(metrics, 28),
        boardTop + metrics.grid * 6 + ScaleValue(metrics, 10),
        boardLeft + boardWidth - ScaleValue(metrics, 28),
        boardTop + metrics.grid * 10 + ScaleValue(metrics, 30)
    };
    return rect;
}

static RECT GetOverlayButtonRect(HWND hWnd, int index, int buttonCount)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT overlayRect = GetGameOverlayRect(hWnd);
    int gap = buttonCount == 3 ? ScaleValue(metrics, 8) : ScaleValue(metrics, 18);
    int sidePadding = buttonCount == 3 ? ScaleValue(metrics, 14) : ScaleValue(metrics, 34);
    int width = (overlayRect.right - overlayRect.left - sidePadding * 2 - gap * (buttonCount - 1)) / buttonCount;
    int height = ScaleValue(metrics, 44);
    int left = overlayRect.left + sidePadding + index * (width + gap);
    int top = overlayRect.top + ScaleValue(metrics, 94);
    RECT rect = { left, top, left + width, top + height };
    return rect;
}

static RECT GetBackButtonRect(HWND hWnd)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    RECT rect =
    {
        ScaleXValue(metrics, 6),
        ScaleYValue(metrics, 6),
        ScaleXValue(metrics, 34),
        ScaleYValue(metrics, 34)
    };
    return rect;
}

static void ResetGameTimer(HWND hWnd)
{
    KillTimer(hWnd, GAME_TIMER_ID);
    SetTimer(hWnd, GAME_TIMER_ID, currentFallInterval > 0 ? currentFallInterval : GAME_TIMER_INTERVAL, nullptr);
}

static bool PlayReviveVideo(HWND hWnd)
{
    std::wstring videoPath = BuildAssetPath(L"assets\\video\\video.avi");
    if (!FileExists(videoPath))
    {
        videoPath = BuildWorkingDirAssetPath(L"assets\\video\\video.avi");
    }
    if (!FileExists(videoPath))
    {
        videoPath = BuildAssetPath(L"assets\\video\\video.mp4");
    }
    if (!FileExists(videoPath))
    {
        videoPath = BuildWorkingDirAssetPath(L"assets\\video\\video.mp4");
    }
    if (!FileExists(videoPath))
    {
        return false;
    }

    bool shouldResumeBgm = bgmEnabled;
    if (bgmPlaying)
    {
        StopBackgroundMusic();
    }

    auto tryPlayWithMci = [&](bool forceMpegVideo) -> bool
    {
        mciSendStringW((std::wstring(L"close ") + kReviveVideoAlias).c_str(), nullptr, 0, nullptr);

        std::wstring openCommand = L"open \"" + videoPath + L"\" ";
        if (forceMpegVideo)
        {
            openCommand += L"type mpegvideo ";
        }
        openCommand += L"alias ";
        openCommand += kReviveVideoAlias;

        if (mciSendStringW(openCommand.c_str(), nullptr, 0, hWnd) != 0)
        {
            return false;
        }

        std::wstring playCommand = std::wstring(L"play ") + kReviveVideoAlias + L" fullscreen wait";
        MCIERROR playResult = mciSendStringW(playCommand.c_str(), nullptr, 0, hWnd);
        mciSendStringW((std::wstring(L"close ") + kReviveVideoAlias).c_str(), nullptr, 0, nullptr);
        return playResult == 0;
    };

    bool played = tryPlayWithMci(true);
    if (!played)
    {
        played = tryPlayWithMci(false);
    }

    if (!played)
    {
        SHELLEXECUTEINFOW shellInfo = {};
        shellInfo.cbSize = sizeof(shellInfo);
        shellInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
        shellInfo.hwnd = hWnd;
        shellInfo.lpVerb = L"open";
        shellInfo.lpFile = videoPath.c_str();
        shellInfo.nShow = SW_SHOWNORMAL;

        if (ShellExecuteExW(&shellInfo))
        {
            if (shellInfo.hProcess != nullptr)
            {
                WaitForSingleObject(shellInfo.hProcess, INFINITE);
                CloseHandle(shellInfo.hProcess);
            }
            played = true;
        }
    }

    if (shouldResumeBgm)
    {
        StartBackgroundMusic();
    }

    return played;
}

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 bool FileExists(const std::wstring& path)
{
    DWORD attributes = GetFileAttributesW(path.c_str());
    return attributes != INVALID_FILE_ATTRIBUTES && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
}

static RECT GetMusicButtonRect(HWND hWnd)
{
    LayoutMetrics metrics = GetLayoutMetrics(hWnd);
    int size = ScaleValue(metrics, 28);
    if (size < 22)
    {
        size = 22;
    }
    int marginRight = ScaleValue(metrics, 12);
    if (marginRight < 6)
    {
        marginRight = 6;
    }
    int marginBottom = ScaleValue(metrics, 12);
    if (marginBottom < 6)
    {
        marginBottom = 6;
    }

    RECT buttonRect =
    {
        metrics.offsetX + metrics.layoutWidth - marginRight - size,
        metrics.offsetY + metrics.layoutHeight - marginBottom - size,
        metrics.offsetX + metrics.layoutWidth - marginRight,
        metrics.offsetY + metrics.layoutHeight - marginBottom
    };
    return buttonRect;
}

static bool IsPointInRect(const RECT& rect, int x, int y)
{
    return x >= rect.left && x < rect.right && y >= rect.top && y < rect.bottom;
}

static bool TryPlayMciLoop(const std::wstring& path, bool forceMpegVideo)
{
    if (!FileExists(path))
    {
        return false;
    }

    mciSendStringW((std::wstring(L"close ") + kBgmAlias).c_str(), nullptr, 0, nullptr);

    std::wstring openCommand = L"open \"" + path + L"\" ";
    if (forceMpegVideo)
    {
        openCommand += L"type mpegvideo ";
    }
    openCommand += L"alias ";
    openCommand += kBgmAlias;

    if (mciSendStringW(openCommand.c_str(), nullptr, 0, nullptr) != 0)
    {
        return false;
    }

    std::wstring playCommand = std::wstring(L"play ") + kBgmAlias + L" repeat";
    if (mciSendStringW(playCommand.c_str(), nullptr, 0, nullptr) != 0)
    {
        mciSendStringW((std::wstring(L"close ") + kBgmAlias).c_str(), nullptr, 0, nullptr);
        return false;
    }

    bgmPlaying = true;
    bgmUsingMci = true;
    return true;
}

static void StopBackgroundMusic()
{
    if (bgmUsingMci)
    {
        mciSendStringW((std::wstring(L"stop ") + kBgmAlias).c_str(), nullptr, 0, nullptr);
        mciSendStringW((std::wstring(L"close ") + kBgmAlias).c_str(), nullptr, 0, nullptr);
    }
    else
    {
        PlaySoundW(nullptr, nullptr, 0);
    }

    bgmPlaying = false;
    bgmUsingMci = false;
}

static void StartBackgroundMusic()
{
    if (!bgmEnabled || bgmPlaying)
    {
        return;
    }

    const wchar_t* bgmWavRelativePath = L"assets\\audio\\bgm.wav";
    const std::wstring bgmWavCandidates[] =
    {
        BuildAssetPath(bgmWavRelativePath),
        BuildWorkingDirAssetPath(bgmWavRelativePath)
    };

    for (const std::wstring& candidate : bgmWavCandidates)
    {
        if (FileExists(candidate) &&
            PlaySoundW(candidate.c_str(), nullptr, SND_FILENAME | SND_ASYNC | SND_LOOP))
        {
            bgmPlaying = true;
            bgmUsingMci = false;
            return;
        }
    }

    const wchar_t* oggRelativePath = L"assets\\audio\\bgm.ogg";
    const std::wstring oggCandidates[] =
    {
        BuildAssetPath(oggRelativePath),
        BuildWorkingDirAssetPath(oggRelativePath)
    };

    for (const std::wstring& candidate : oggCandidates)
    {
        if (TryPlayMciLoop(candidate, false) || TryPlayMciLoop(candidate, true))
        {
            return;
        }
    }

    const wchar_t* fallbackWavRelativePath = L"assets\\audio\\background.wav";
    const std::wstring fallbackWavCandidates[] =
    {
        BuildAssetPath(fallbackWavRelativePath),
        BuildWorkingDirAssetPath(fallbackWavRelativePath)
    };

    for (const std::wstring& candidate : fallbackWavCandidates)
    {
        if (FileExists(candidate) &&
            PlaySoundW(candidate.c_str(), nullptr, SND_FILENAME | SND_ASYNC | SND_LOOP))
        {
            bgmPlaying = true;
            bgmUsingMci = false;
            return;
        }
    }

    bgmEnabled = false;
}

static void ToggleBackgroundMusic(HWND hWnd)
{
    bgmEnabled = !bgmEnabled;
    if (bgmEnabled)
    {
        StartBackgroundMusic();
    }
    else
    {
        StopBackgroundMusic();
    }
    InvalidateRect(hWnd, nullptr, FALSE);
}

int APIENTRY _tWinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPTSTR lpCmdLine,
    int nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

    HMODULE user32Module = GetModuleHandle(_T("user32.dll"));
    if (user32Module != nullptr)
    {
        typedef BOOL(WINAPI* SetProcessDPIAwareFunc)();
        SetProcessDPIAwareFunc setProcessDPIAware =
            (SetProcessDPIAwareFunc)GetProcAddress(user32Module, "SetProcessDPIAware");

        if (setProcessDPIAware != nullptr)
        {
            setProcessDPIAware();
        }
    }

    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_TETRIS, szWindowClass, MAX_LOADSTRING);
    lstrcpy(szTitle, _T("\u4fc4\u7f57\u65af\u65b9\u5757"));
    MyRegisterClass(hInstance);

    if (!InitInstance(hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_TETRIS));
    MSG msg;

    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int)msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_TETRIS));
    wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = nullptr;
    wcex.lpszClassName = szWindowClass;
    wcex.hIconSm = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    RECT rect = { 0, 0, WINDOW_CLIENT_WIDTH, WINDOW_CLIENT_HEIGHT };
    AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE);

    hInst = hInstance;

    HWND hWnd = CreateWindow(
        szWindowClass,
        szTitle,
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT,
        0,
        rect.right - rect.left,
        rect.bottom - rect.top,
        nullptr,
        nullptr,
        hInstance,
        nullptr);

    if (!hWnd)
    {
        return FALSE;
    }

    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);

    return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
        timeBeginPeriod(1);
        srand((unsigned int)time(nullptr));
        ReturnToMainMenu();
        StartBackgroundMusic();
        ResetGameTimer(hWnd);
        SetTimer(hWnd, EFFECT_TIMER_ID, EFFECT_TIMER_INTERVAL, nullptr);
        creditTimerHandle = timeSetEvent(
            CREDIT_TIMER_INTERVAL,
            1,
            CreditTimerCallback,
            reinterpret_cast<DWORD_PTR>(hWnd),
            TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
        if (creditTimerHandle == 0)
        {
            SetTimer(hWnd, CREDIT_TIMER_ID, CREDIT_TIMER_INTERVAL, nullptr);
        }
        InvalidateRect(hWnd, nullptr, FALSE);
        break;
    case WM_COMMAND:
    {
        int wmId = LOWORD(wParam);

        switch (wmId)
        {
        case IDM_SKILL_DEMO:
            OpenSkillDemoScreen();
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
    }
    break;
    case WM_CREDIT_TICK:
        if (currentScreen == SCREEN_RULES && helpState.currentPage == 4 && TickCreditAnimation())
        {
            InvalidateRect(hWnd, nullptr, FALSE);
        }
        break;
    case WM_TIMER:
        if (wParam == EFFECT_TIMER_ID)
        {
            if (TickVisualEffects())
            {
                InvalidateRect(hWnd, nullptr, FALSE);
            }
            break;
        }
        if (wParam == CREDIT_TIMER_ID && creditTimerHandle == 0)
        {
            if (currentScreen == SCREEN_RULES && helpState.currentPage == 4 && TickCreditAnimation())
            {
                InvalidateRect(hWnd, nullptr, FALSE);
            }
            break;
        }

        if (wParam == GAME_TIMER_ID)
        {
            bool shouldRefresh = false;

            if (feedbackState.visibleTicks > 0)
            {
                feedbackState.visibleTicks--;
                shouldRefresh = true;
            }

            if (IsRogueSkillDemoMode())
            {
                if (TickRogueSkillDemo())
                {
                    shouldRefresh = true;
                }
            }

            if (currentMode == MODE_ROGUE && !IsRogueSkillDemoMode() && rogueStats.feverTicks > 0)
            {
                rogueStats.feverTicks--;
                currentFallInterval = GetRogueFallInterval();
                ResetGameTimer(hWnd);
                shouldRefresh = true;
            }

            if (currentMode == MODE_ROGUE &&
                !IsRogueSkillDemoMode() &&
                rogueStats.timeDilationTicks > 0 &&
                currentScreen == SCREEN_PLAYING &&
                !suspendFlag &&
                !gameOverFlag)
            {
                rogueStats.timeDilationTicks--;
                currentFallInterval = GetRogueFallInterval();
                ResetGameTimer(hWnd);
                shouldRefresh = true;
            }

            if (currentMode == MODE_ROGUE && !IsRogueSkillDemoMode() && rogueStats.extremeSlowTicks > 0)
            {
                rogueStats.extremeSlowTicks--;
                currentFallInterval = GetRogueFallInterval();
                ResetGameTimer(hWnd);
                shouldRefresh = true;
            }

            if (currentMode == MODE_ROGUE &&
                !IsRogueSkillDemoMode() &&
                rogueStats.extremePlayerLevel > 0 &&
                currentScreen == SCREEN_PLAYING &&
                !suspendFlag &&
                !gameOverFlag)
            {
                if (rogueStats.extremeDangerTicks > 0)
                {
                    rogueStats.extremeDangerTicks--;
                }
                else
                {
                    rogueStats.extremeDangerTicks = 30;
                    if (rogueStats.extremeDangerLevel < 5)
                    {
                        rogueStats.extremeDangerLevel++;
                    }
                    currentFallInterval = GetRogueFallInterval();
                    ResetGameTimer(hWnd);
                    feedbackState.visibleTicks = 10;
                    lstrcpyn(feedbackState.title, _T("极限压力升高"), sizeof(feedbackState.title) / sizeof(TCHAR));
                    lstrcpyn(feedbackState.detail, _T("30 秒内没有完成四消，危险等级提升，下落速度进一步加快。"), sizeof(feedbackState.detail) / sizeof(TCHAR));
                    shouldRefresh = true;
                }
            }

            if (currentMode == MODE_ROGUE && !IsRogueSkillDemoMode() && rogueStats.holdSlowTicks > 0)
            {
                rogueStats.holdSlowTicks--;
                currentFallInterval = GetRogueFallInterval();
                ResetGameTimer(hWnd);
                shouldRefresh = true;
            }

            if (currentScreen == SCREEN_PLAYING &&
                !suspendFlag &&
                !gameOverFlag)
            {
                if (currentMode == MODE_ROGUE && !IsRogueSkillDemoMode())
                {
                    int previousFallInterval = currentFallInterval;
                    AdvanceRogueDifficulty(currentFallInterval > 0 ? currentFallInterval : GAME_TIMER_INTERVAL);
                    if (currentFallInterval != previousFallInterval)
                    {
                        ResetGameTimer(hWnd);
                    }
                }

                if (currentMode == MODE_ROGUE && !IsRogueSkillDemoMode() && rogueStats.timeDilationLevel > 0 && rogueStats.timeDilationTicks <= 0)
                {
                    int occupiedHeight = 0;
                    int playableHeight = GetRoguePlayableHeight();
                    for (int y = 0; y < playableHeight; y++)
                    {
                        bool hasCell = false;
                        for (int x = 0; x < nGameWidth; x++)
                        {
                            if (workRegion[y][x] != 0)
                            {
                                hasCell = true;
                                break;
                            }
                        }
                        if (hasCell)
                        {
                            occupiedHeight = playableHeight - y;
                            break;
                        }
                    }

                    if (occupiedHeight > 15)
                    {
                        rogueStats.timeDilationTicks = 8;
                        currentFallInterval = GetRogueFallInterval();
                        ResetGameTimer(hWnd);
                        feedbackState.visibleTicks = 10;
                        lstrcpyn(feedbackState.title, _T("\u65f6\u95f4\u7f13\u6d41"), sizeof(feedbackState.title) / sizeof(TCHAR));
                        lstrcpyn(feedbackState.detail, _T("堆叠高度超过 15 行，接下来 8 秒下落速度降低 30%。"), sizeof(feedbackState.detail) / sizeof(TCHAR));
                        shouldRefresh = true;
                    }
                }

                if (CanMoveDown())
                {
                    MoveDown();
                }
                else
                {
                    Fixing();
                    if (!gameOverFlag)
                    {
                        DeleteLines();
                        CheckRogueLevelProgress();
                    }
                }

                if (!gameOverFlag)
                {
                    ComputeTarget();
                }

                shouldRefresh = true;
            }

            if (shouldRefresh)
            {
                InvalidateRect(hWnd, nullptr, FALSE);
            }
        }
        break;
    case WM_SIZE:
        InvalidateRect(hWnd, nullptr, FALSE);
        break;
    case WM_LBUTTONUP:
    {
        int mouseX = static_cast<short>(LOWORD(lParam));
        int mouseY = static_cast<short>(HIWORD(lParam));
        RECT musicButtonRect = GetMusicButtonRect(hWnd);
        if (IsPointInRect(musicButtonRect, mouseX, mouseY))
        {
            ToggleBackgroundMusic(hWnd);
            break;
        }

        if (currentScreen != SCREEN_MENU && IsPointInRect(GetBackButtonRect(hWnd), mouseX, mouseY))
        {
            ReturnToMainMenu();
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }

        if (currentScreen == SCREEN_MENU)
        {
            for (int i = 0; i < menuState.optionCount; i++)
            {
                if (!IsPointInRect(GetMenuOptionRect(hWnd, i), mouseX, mouseY))
                {
                    continue;
                }

                menuState.selectedIndex = i;
                if (i == 0)
                {
                    StartGameWithMode(MODE_CLASSIC);
                }
                else if (i == 1)
                {
                    StartGameWithMode(MODE_ROGUE);
                }
                else if (i == 2)
                {
                    OpenRulesScreen();
                }
                else
                {
                    OpenCreditScreen();
                }
                ResetGameTimer(hWnd);
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            }
            break;
        }

        if (currentScreen == SCREEN_RULES)
        {
            if (helpState.currentPage == 0)
            {
                for (int i = 0; i < helpState.optionCount; i++)
                {
                    if (IsPointInRect(GetHelpOptionRect(hWnd, i), mouseX, mouseY))
                    {
                        helpState.selectedIndex = i;
                        if (i == 3)
                        {
                            helpState.currentPage = 5;
                            helpState.selectedIndex = 0;
                            helpScrollOffset = 0;
                        }
                        else
                        {
                            helpState.currentPage = i + 1;
                            helpScrollOffset = 0;
                        }
                        InvalidateRect(hWnd, nullptr, FALSE);
                        break;
                    }
                }
                if (IsPointInRect(GetHelpBackHintRect(hWnd), mouseX, mouseY))
                {
                    ReturnToMainMenu();
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
            }
            else if (helpState.currentPage == 5)
            {
                if (IsPointInRect(GetHelpBackHintRect(hWnd), mouseX, mouseY))
                {
                    helpState.currentPage = 0;
                    helpState.selectedIndex = 3;
                    helpScrollOffset = 0;
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                else
                {
                    int demoCount = GetRogueSkillDemoCount();
                    for (int i = 0; i < demoCount; i++)
                    {
                        if (IsPointInRect(GetHelpSkillDemoItemRect(hWnd, i), mouseX, mouseY))
                        {
                            helpState.selectedIndex = i;
                            StartRogueSkillDemoAt(i);
                            ResetGameTimer(hWnd);
                            InvalidateRect(hWnd, nullptr, FALSE);
                            break;
                        }
                    }
                }
            }
            else if (IsPointInRect(GetHelpBackHintRect(hWnd), mouseX, mouseY))
            {
                if (helpState.currentPage == 4)
                {
                    ReturnToMainMenu();
                }
                else
                {
                    helpState.currentPage = 0;
                    helpScrollOffset = 0;
                }
                InvalidateRect(hWnd, nullptr, FALSE);
            }
            else if (helpState.currentPage == 4 && IsPointInRect(GetCreditArrowRect(hWnd, -1), mouseX, mouseY))
            {
                ChangeCreditPage(-1);
                InvalidateRect(hWnd, nullptr, FALSE);
            }
            else if (helpState.currentPage == 4 && IsPointInRect(GetCreditArrowRect(hWnd, 1), mouseX, mouseY))
            {
                ChangeCreditPage(1);
                InvalidateRect(hWnd, nullptr, FALSE);
            }
            break;
        }

        if (currentScreen == SCREEN_UPGRADE)
        {
            for (int i = 0; i < upgradeUiState.optionCount; i++)
            {
                if (!IsPointInRect(GetUpgradeCardRect(hWnd, i), mouseX, mouseY))
                {
                    continue;
                }

                upgradeUiState.selectedIndex = i;
                if (upgradeUiState.picksRemaining > 1)
                {
                    bool currentlyMarked = upgradeUiState.marked[i];
                    if (currentlyMarked)
                    {
                        upgradeUiState.marked[i] = false;
                        if (upgradeUiState.markedCount > 0)
                        {
                            upgradeUiState.markedCount--;
                        }
                    }
                    else if (upgradeUiState.markedCount < upgradeUiState.picksRemaining)
                    {
                        upgradeUiState.marked[i] = true;
                        upgradeUiState.markedCount++;
                    }

                    if (upgradeUiState.markedCount == upgradeUiState.picksRemaining)
                    {
                        ConfirmUpgradeSelection();
                        ResetGameTimer(hWnd);
                    }
                }
                else
                {
                    ConfirmUpgradeSelection();
                    ResetGameTimer(hWnd);
                }

                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            }
            break;
        }

        if (currentScreen == SCREEN_PLAYING && suspendFlag)
        {
            if (IsPointInRect(GetOverlayButtonRect(hWnd, 0, 2), mouseX, mouseY))
            {
                suspendFlag = false;
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            }
            if (IsPointInRect(GetOverlayButtonRect(hWnd, 1, 2), mouseX, mouseY))
            {
                ReturnToMainMenu();
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            }
        }

        if (currentScreen == SCREEN_PLAYING && gameOverFlag)
        {
            if (reviveAvailable)
            {
                if (IsPointInRect(GetOverlayButtonRect(hWnd, 0, 3), mouseX, mouseY))
                {
                    if (PlayReviveVideo(hWnd))
                    {
                        ReviveAfterVideo();
                        ResetGameTimer(hWnd);
                    }
                    InvalidateRect(hWnd, nullptr, FALSE);
                    break;
                }
                if (IsPointInRect(GetOverlayButtonRect(hWnd, 1, 3), mouseX, mouseY))
                {
                    StartGameWithMode(currentMode);
                    ResetGameTimer(hWnd);
                    InvalidateRect(hWnd, nullptr, FALSE);
                    break;
                }
                if (IsPointInRect(GetOverlayButtonRect(hWnd, 2, 3), mouseX, mouseY))
                {
                    ReturnToMainMenu();
                    InvalidateRect(hWnd, nullptr, FALSE);
                    break;
                }
            }
            else
            {
                if (IsPointInRect(GetOverlayButtonRect(hWnd, 0, 2), mouseX, mouseY))
                {
                    StartGameWithMode(currentMode);
                    ResetGameTimer(hWnd);
                    InvalidateRect(hWnd, nullptr, FALSE);
                    break;
                }
                if (IsPointInRect(GetOverlayButtonRect(hWnd, 1, 2), mouseX, mouseY))
                {
                    ReturnToMainMenu();
                    InvalidateRect(hWnd, nullptr, FALSE);
                    break;
                }
            }
        }

        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    case WM_MOUSEWHEEL:
    {
        int wheelDelta = GET_WHEEL_DELTA_WPARAM(wParam);
        int direction = (wheelDelta > 0) ? -1 : 1;
        int scrollStep = GetScrollStep(hWnd, 64);
        if (currentScreen == SCREEN_RULES && helpState.currentPage != 0)
        {
            AdjustScrollOffset(helpScrollOffset, direction * scrollStep);
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }
        if (currentScreen == SCREEN_PLAYING && currentMode == MODE_ROGUE)
        {
            AdjustScrollOffset(upgradeListScrollOffset, direction * scrollStep);
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }
        break;
    }
    case WM_KEYDOWN:
        if (currentScreen == SCREEN_MENU)
        {
            switch (wParam)
            {
            case VK_UP:
            case VK_LEFT:
            case 'W':
            case 'A':
                menuState.selectedIndex--;
                if (menuState.selectedIndex < 0)
                {
                    menuState.selectedIndex = menuState.optionCount - 1;
                }
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            case VK_DOWN:
            case VK_RIGHT:
            case 'S':
            case 'D':
                menuState.selectedIndex++;
                if (menuState.selectedIndex >= menuState.optionCount)
                {
                    menuState.selectedIndex = 0;
                }
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            case VK_RETURN:
            case VK_SPACE:
                if (menuState.selectedIndex == 0)
                {
                    StartGameWithMode(MODE_CLASSIC);
                }
                else if (menuState.selectedIndex == 1)
                {
                    StartGameWithMode(MODE_ROGUE);
                }
                else if (menuState.selectedIndex == 2)
                {
                    OpenRulesScreen();
                }
                else
                {
                    OpenCreditScreen();
                }
                ResetGameTimer(hWnd);
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            case VK_ESCAPE:
                DestroyWindow(hWnd);
                break;
            default:
                break;
            }
            break;
        }

        if (currentScreen == SCREEN_RULES)
        {
            switch (wParam)
            {
            case VK_UP:
            case VK_LEFT:
            case 'W':
            case 'A':
                if (helpState.currentPage == 0)
                {
                    helpState.selectedIndex--;
                    if (helpState.selectedIndex < 0)
                    {
                        helpState.selectedIndex = helpState.optionCount - 1;
                    }
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                else if (helpState.currentPage == 4)
                {
                    ChangeCreditPage(-1);
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                else if (helpState.currentPage == 5)
                {
                    helpState.selectedIndex--;
                    if (helpState.selectedIndex < 0)
                    {
                        helpState.selectedIndex = GetRogueSkillDemoCount() - 1;
                    }
                    if (helpState.selectedIndex * 68 < helpScrollOffset)
                    {
                        helpScrollOffset = helpState.selectedIndex * 68;
                    }
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                break;
            case VK_DOWN:
            case VK_RIGHT:
            case 'S':
            case 'D':
                if (helpState.currentPage == 0)
                {
                    helpState.selectedIndex++;
                    if (helpState.selectedIndex >= helpState.optionCount)
                    {
                        helpState.selectedIndex = 0;
                    }
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                else if (helpState.currentPage == 4)
                {
                    ChangeCreditPage(1);
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                else if (helpState.currentPage == 5)
                {
                    helpState.selectedIndex++;
                    if (helpState.selectedIndex >= GetRogueSkillDemoCount())
                    {
                        helpState.selectedIndex = 0;
                        helpScrollOffset = 0;
                    }
                    else if (helpState.selectedIndex * 68 > helpScrollOffset + 360)
                    {
                        helpScrollOffset = helpState.selectedIndex * 68 - 360;
                    }
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                break;
            case VK_RETURN:
            case VK_SPACE:
                if (helpState.currentPage == 0)
                {
                    if (helpState.selectedIndex == 3)
                    {
                        helpState.currentPage = 5;
                        helpState.selectedIndex = 0;
                        helpScrollOffset = 0;
                    }
                    else
                    {
                        helpState.currentPage = helpState.selectedIndex + 1;
                        helpScrollOffset = 0;
                    }
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                else if (helpState.currentPage == 5)
                {
                    StartRogueSkillDemoAt(helpState.selectedIndex);
                    ResetGameTimer(hWnd);
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                break;
            case VK_ESCAPE:
            case VK_BACK:
            case 'M':
                if (helpState.currentPage == 0)
                {
                    ReturnToMainMenu();
                }
                else if (helpState.currentPage == 4)
                {
                    ReturnToMainMenu();
                }
                else if (helpState.currentPage == 5)
                {
                    helpState.currentPage = 0;
                    helpState.selectedIndex = 3;
                    helpScrollOffset = 0;
                }
                else
                {
                    helpState.currentPage = 0;
                    helpScrollOffset = 0;
                }
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            default:
                break;
            }
            break;
        }

        if (currentScreen == SCREEN_UPGRADE)
        {
            int upgradeColumnCount = upgradeUiState.optionCount <= 3 ? upgradeUiState.optionCount : 3;
            if (upgradeColumnCount < 1)
            {
                upgradeColumnCount = 1;
            }

            switch (wParam)
            {
            case VK_LEFT:
            case 'A':
                if (upgradeUiState.optionCount > 1)
                {
                    int rowStart = upgradeUiState.selectedIndex - (upgradeUiState.selectedIndex % upgradeColumnCount);
                    if (upgradeUiState.selectedIndex > rowStart)
                    {
                        upgradeUiState.selectedIndex--;
                    }
                    else
                    {
                        int rowEnd = rowStart + upgradeColumnCount - 1;
                        if (rowEnd >= upgradeUiState.optionCount)
                        {
                            rowEnd = upgradeUiState.optionCount - 1;
                        }
                        upgradeUiState.selectedIndex = rowEnd;
                    }
                }
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            case VK_RIGHT:
            case 'D':
                if (upgradeUiState.optionCount > 1)
                {
                    int rowStart = upgradeUiState.selectedIndex - (upgradeUiState.selectedIndex % upgradeColumnCount);
                    int rowEnd = rowStart + upgradeColumnCount - 1;
                    if (rowEnd >= upgradeUiState.optionCount)
                    {
                        rowEnd = upgradeUiState.optionCount - 1;
                    }

                    if (upgradeUiState.selectedIndex < rowEnd)
                    {
                        upgradeUiState.selectedIndex++;
                    }
                    else
                    {
                        upgradeUiState.selectedIndex = rowStart;
                    }
                }
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            case VK_UP:
            case 'W':
                if (upgradeUiState.selectedIndex >= upgradeColumnCount)
                {
                    upgradeUiState.selectedIndex -= upgradeColumnCount;
                }
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            case VK_DOWN:
            case 'S':
                if (upgradeUiState.selectedIndex + upgradeColumnCount < upgradeUiState.optionCount)
                {
                    upgradeUiState.selectedIndex += upgradeColumnCount;
                }
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            case VK_RETURN:
                ConfirmUpgradeSelection();
                ResetGameTimer(hWnd);
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            case VK_SPACE:
                if (upgradeUiState.picksRemaining > 1 && upgradeUiState.optionCount > 0)
                {
                    bool currentlyMarked = upgradeUiState.marked[upgradeUiState.selectedIndex];
                    if (currentlyMarked)
                    {
                        upgradeUiState.marked[upgradeUiState.selectedIndex] = false;
                        if (upgradeUiState.markedCount > 0)
                        {
                            upgradeUiState.markedCount--;
                        }
                    }
                    else if (upgradeUiState.markedCount < upgradeUiState.picksRemaining)
                    {
                        upgradeUiState.marked[upgradeUiState.selectedIndex] = true;
                        upgradeUiState.markedCount++;
                    }
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                else
                {
                    ConfirmUpgradeSelection();
                    ResetGameTimer(hWnd);
                    InvalidateRect(hWnd, nullptr, FALSE);
                }
                break;
            case 'M':
                ReturnToMainMenu();
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            default:
                break;
            }
            break;
        }

        if (IsRogueSkillDemoMode())
        {
            if (wParam == 'N')
            {
                AdvanceRogueSkillDemo();
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            }
            else if (wParam == 'R')
            {
                RestartCurrentRogueSkillDemo();
                ResetGameTimer(hWnd);
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            }
            else if (wParam == VK_ESCAPE || wParam == VK_BACK || wParam == 'M')
            {
                ReturnToMainMenu();
                InvalidateRect(hWnd, nullptr, FALSE);
                break;
            }
        }

        if (!IsRogueSkillDemoMode() && wParam == 'M')
        {
            ReturnToMainMenu();
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }

        if (!IsRogueSkillDemoMode() && wParam == 'R')
        {
            StartGameWithMode(currentMode);
            ResetGameTimer(hWnd);
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }

        if (!IsRogueSkillDemoMode() && wParam == 'P')
        {
            suspendFlag = !suspendFlag;
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }

        if (wParam == 'G')
        {
            targetFlag = !targetFlag;
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }

        if (gameOverFlag && reviveAvailable && wParam == 'V')
        {
            if (PlayReviveVideo(hWnd))
            {
                ReviveAfterVideo();
                ResetGameTimer(hWnd);
            }
            else
            {
                SetFeedbackMessage(_T("视频播放失败"), _T("无法打开复活视频，复活机会未消耗。"), 14);
            }
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }

        if (gameOverFlag || suspendFlag)
        {
            break;
        }

        if (currentMode == MODE_ROGUE && (wParam == 'J' || wParam == 'K'))
        {
            int direction = (wParam == 'J') ? 1 : -1;
            AdjustScrollOffset(upgradeListScrollOffset, direction * GetScrollStep(hWnd, 52));
            InvalidateRect(hWnd, nullptr, FALSE);
            break;
        }

        switch (wParam)
        {
        case VK_LEFT:
        case 'A':
            if (CanMoveLeft())
            {
                MoveLeft();
            }
            break;
        case VK_RIGHT:
        case 'D':
            if (CanMoveRight())
            {
                MoveRight();
            }
            break;
        case VK_DOWN:
        case 'S':
            if (CanMoveDown())
            {
                MoveDown();
            }
            else
            {
                Fixing();
                if (!gameOverFlag)
                {
                    DeleteLines();
                    CheckRogueLevelProgress();
                }
            }
            break;
        case VK_UP:
        case 'W':
            Rotate();
            break;
        case VK_SPACE:
            DropDown();
            Fixing();
            if (!gameOverFlag)
            {
                DeleteLines();
                CheckRogueLevelProgress();
            }
            break;
        case 'C':
        case VK_SHIFT:
        case VK_LSHIFT:
        case VK_RSHIFT:
            HoldCurrentPiece();
            break;
        case 'Z':
            UseBlackHole();
            break;
        case 'X':
            UseScreenBomb();
            break;
        case 'V':
            UseAirReshape();
            break;
        default:
            break;
        }

        if (!gameOverFlag)
        {
            ComputeTarget();
        }

        InvalidateRect(hWnd, nullptr, FALSE);
        break;
    case WM_ERASEBKGND:
        return 1;
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        RECT clientRect;
        GetClientRect(hWnd, &clientRect);

        HDC memDC = CreateCompatibleDC(hdc);
        HBITMAP memBitmap = CreateCompatibleBitmap(
            hdc,
            clientRect.right - clientRect.left,
            clientRect.bottom - clientRect.top);
        HBITMAP oldBitmap = (HBITMAP)SelectObject(memDC, memBitmap);

        TDrawScreen(memDC, hWnd);
        BitBlt(
            hdc,
            0, 0,
            clientRect.right - clientRect.left,
            clientRect.bottom - clientRect.top,
            memDC,
            0, 0,
            SRCCOPY);

        SelectObject(memDC, oldBitmap);
        DeleteObject(memBitmap);
        DeleteDC(memDC);
        EndPaint(hWnd, &ps);
    }
    break;
    case WM_DESTROY:
        KillTimer(hWnd, GAME_TIMER_ID);
        KillTimer(hWnd, EFFECT_TIMER_ID);
        if (creditTimerHandle != 0)
        {
            timeKillEvent(creditTimerHandle);
            creditTimerHandle = 0;
        }
        else
        {
            KillTimer(hWnd, CREDIT_TIMER_ID);
        }
        StopBackgroundMusic();
        timeEndPeriod(1);
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }

    return 0;
}

INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);

    switch (message)
    {
    case WM_INITDIALOG:
        SetWindowText(hDlg, _T("\u5173\u4e8e\u4fc4\u7f57\u65af\u65b9\u5757"));
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }

    return (INT_PTR)FALSE;
}