main.c

根据从ReactOS提取的扫雷代码修改的比较完美的扫雷程序

        for( i = 0; i < 3; i++ )
            uLED[i] = 11;*/

    hOldObj = SelectObject (hMemDC, pBoard->hLedsBMP);

    for( i = 0; i < 3; i++ )
    {
        BitBlt( hDC,
            i * LED_WIDTH + x,
            y,
            LED_WIDTH,
            LED_HEIGHT,
            hMemDC,
            0,
            uLED[i] * LED_HEIGHT,
            SRCCOPY);
    }

    SelectObject( hMemDC, hOldObj );
}

void DrawFace( HDC hDC, HDC hMemDC, BOARD *pBoard )
{
    HGDIOBJ hOldObj;

    hOldObj = SelectObject (hMemDC, pBoard->hFacesBMP);

    BitBlt( hDC,
        pBoard->FaceRect.left,
        pBoard->FaceRect.top,
        FACE_WIDTH,
        FACE_HEIGHT,
        hMemDC, 0, pBoard->FaceBmp * FACE_HEIGHT, SRCCOPY);

    SelectObject( hMemDC, hOldObj );
}

void DrawBoard( HDC hDC, HDC hMemDC, PAINTSTRUCT *ps, BOARD *pBoard )
{
    RECT TempRect;

    if( IntersectRect( &TempRect, &ps->rcPaint, &pBoard->CounterRect) )
        DrawLeds( hDC, hMemDC, pBoard, pBoard->uMines - pBoard->uNumFlags,
                  pBoard->CounterRect.left,
                  pBoard->CounterRect.top );

    if( IntersectRect( &TempRect, &ps->rcPaint, &pBoard->TimerRect ) )
        DrawLeds( hDC, hMemDC, pBoard, pBoard->uTime,
                  pBoard->TimerRect.left,
                  pBoard->TimerRect.top);

    if( IntersectRect( &TempRect, &ps->rcPaint, &pBoard->FaceRect ) )
        DrawFace( hDC, hMemDC, pBoard );

    if( IntersectRect( &TempRect, &ps->rcPaint, &pBoard->MinesRect ) )
        DrawMines( hDC, hMemDC, pBoard );
}


void TestBoard( HWND hWnd, BOARD *pBoard, LONG x, LONG y, int msg )
{
    POINT pt;
    ULONG uCol, uRow;

    pt.x = x;
    pt.y = y;

    if( PtInRect( &pBoard->MinesRect, pt ) && pBoard->Status != GAMEOVER && pBoard->Status != WON )
        TestMines( pBoard, pt, msg );
    else
    {
        UnpressBoxes( pBoard, pBoard->Press.x, pBoard->Press.y );
        pBoard->Press.x = 0;
        pBoard->Press.y = 0;
    }

    if( pBoard->uBoxesLeft == 0 )
    {
        // MG - 2006-02-21
        // mimic MS minesweeper behaviour - when autocompleting a board, flag mines 
        pBoard->Status = WON;

        for( uCol = 0; uCol <= pBoard->uCols + 1; uCol++ )
        {
            for( uRow = 0; uRow <= pBoard->uRows + 1; uRow++ )
            {
                if(pBoard->Box[uCol][uRow].bIsMine)
                {
                    pBoard->Box[uCol][uRow].uFlagType = FLAG;
                }
            }
        }

        pBoard->uNumFlags = pBoard->uMines;
        RedrawWindow( pBoard->hWnd, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW );
        
        if( pBoard->Difficulty != CUSTOM && pBoard->uTime < pBoard->uBestTime[pBoard->Difficulty] )
        {
            pBoard->uBestTime[pBoard->Difficulty] = pBoard->uTime;

            DialogBoxParam( pBoard->hInst, MAKEINTRESOURCE(IDD_CONGRATS), hWnd, CongratsDlgProc, (LPARAM) pBoard);
            DialogBoxParam( pBoard->hInst, MAKEINTRESOURCE(IDD_TIMES), hWnd, TimesDlgProc, (LPARAM) pBoard);
        }
    }

    TestFace( pBoard, pt, msg );
}

void TestMines( BOARD *pBoard, POINT pt, int msg )
{
    BOOL bDraw = TRUE;
    ULONG uCol, uRow;

    uCol = (pt.x - pBoard->MinesRect.left) / MINE_WIDTH + 1;
    uRow = (pt.y - pBoard->MinesRect.top ) / MINE_HEIGHT + 1;

    switch (msg)
    {
        case WM_LBUTTONDOWN:
            if( pBoard->Press.x != uCol || pBoard->Press.y != uRow )
            {
                UnpressBox( pBoard, pBoard->Press.x, pBoard->Press.y );
                pBoard->Press.x = uCol;
                pBoard->Press.y = uRow;
                PressBox( pBoard, uCol, uRow );
            }

            bDraw = FALSE;
            break;

        case WM_LBUTTONUP:
            if( pBoard->Press.x != uCol || pBoard->Press.y != uRow )
                UnpressBox( pBoard, pBoard->Press.x, pBoard->Press.y );

            pBoard->Press.x = 0;
            pBoard->Press.y = 0;

            if( pBoard->Box[uCol][uRow].uFlagType != FLAG )
                pBoard->Status = PLAYING;

            CompleteBox( pBoard, uCol, uRow );
            break;

        case WM_MBUTTONDOWN:
            PressBoxes( pBoard, uCol, uRow );
            bDraw = FALSE;
            break;

        case WM_MBUTTONUP:
            if( pBoard->Press.x != uCol || pBoard->Press.y != uRow )
                UnpressBoxes( pBoard, pBoard->Press.x, pBoard->Press.y );

            pBoard->Press.x = 0;
            pBoard->Press.y = 0;
            CompleteBoxes( pBoard, uCol, uRow );
            break;

        case WM_RBUTTONDOWN:
            AddFlag( pBoard, uCol, uRow );
            pBoard->Status = PLAYING;
            break;

        default:
            DEBUG("Unknown message type received in TestMines\n");
            break;
    }

    if(bDraw)
        RedrawWindow( pBoard->hWnd, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW );
}

void TestFace( BOARD *pBoard, POINT pt, int msg )
{
    if( pBoard->Status == PLAYING || pBoard->Status == WAITING )
    {
        if( msg == WM_LBUTTONDOWN || msg == WM_MBUTTONDOWN )
            pBoard->FaceBmp = OOH_BMP;
        else pBoard->FaceBmp = SMILE_BMP;
    }
    else if( pBoard->Status == GAMEOVER )
        pBoard->FaceBmp = DEAD_BMP;
    else if( pBoard->Status == WON )
            pBoard->FaceBmp = COOL_BMP;

    if( PtInRect( &pBoard->FaceRect, pt ) )
    {
        if( msg == WM_LBUTTONDOWN )
            pBoard->FaceBmp = SPRESS_BMP;

        if( msg == WM_LBUTTONUP )
            CreateBoard( pBoard );
    }

    RedrawWindow( pBoard->hWnd, &pBoard->FaceRect, NULL, RDW_INVALIDATE | RDW_UPDATENOW );
}

void CompleteBox( BOARD *pBoard, ULONG uCol, ULONG uRow )
{
    CHAR i, j;

    if( pBoard->Box[uCol][uRow].uFlagType != COMPLETE &&
            pBoard->Box[uCol][uRow].uFlagType != FLAG &&
            uCol > 0 && uCol < pBoard->uCols + 1 &&
            uRow > 0 && uRow < pBoard->uRows + 1 )
    {
        pBoard->Box[uCol][uRow].uFlagType = COMPLETE;

        if( pBoard->Box[uCol][uRow].bIsMine )
        {
            pBoard->FaceBmp = DEAD_BMP;
            pBoard->Status = GAMEOVER;
        }
        else if( pBoard->Status != GAMEOVER )
            pBoard->uBoxesLeft--;

        if( pBoard->Box[uCol][uRow].uNumMines == 0 )
        {
            for( i = -1; i <= 1; i++ )
                for( j = -1; j <= 1; j++ )
                    CompleteBox( pBoard, uCol + i, uRow + j );
        }
    }
}

void CompleteBoxes( BOARD *pBoard, ULONG uCol, ULONG uRow )
{
    CHAR i, j;
    ULONG uNumFlags = 0;

    if( pBoard->Box[uCol][uRow].uFlagType == COMPLETE )
    {
        for( i = -1; i <= 1; i++ )
        {
            for( j = -1; j <= 1; j++ )
            {
                if( pBoard->Box[uCol + i][uRow + j].uFlagType == FLAG )
                    uNumFlags++;
            }
        }

        if( uNumFlags == pBoard->Box[uCol][uRow].uNumMines )
        {
            for( i = -1; i <= 1; i++ )
            {
                for( j = -1; j <= 1; j++ )
                {
                    if( pBoard->Box[uCol + i][uRow + j].uFlagType != FLAG )
                        CompleteBox( pBoard, uCol + i, uRow + j );
                }
            }
        }
    }
}

void AddFlag( BOARD *pBoard, ULONG uCol, ULONG uRow )
{
    if( pBoard->Box[uCol][uRow].uFlagType != COMPLETE )
    {
        switch( pBoard->Box[uCol][uRow].uFlagType )
        {
            case FLAG:
                if( pBoard->bMark )
                    pBoard->Box[uCol][uRow].uFlagType = QUESTION;
                else
                    pBoard->Box[uCol][uRow].uFlagType = NORMAL;

                pBoard->uNumFlags--;
                break;

            case QUESTION:
                pBoard->Box[uCol][uRow].uFlagType = NORMAL;
                break;

            default:
                pBoard->Box[uCol][uRow].uFlagType = FLAG;
                pBoard->uNumFlags++;
        }
    }
}

void PressBox( BOARD *pBoard, ULONG uCol, ULONG uRow )
{
    HDC hDC;
    HGDIOBJ hOldObj;
    HDC hMemDC;

    hDC = GetDC( pBoard->hWnd );
    hMemDC = CreateCompatibleDC(hDC);
    hOldObj = SelectObject (hMemDC, pBoard->hMinesBMP);

    DrawMine( hDC, hMemDC, pBoard, uCol, uRow, TRUE );

    SelectObject( hMemDC, hOldObj );
    DeleteDC( hMemDC );
    ReleaseDC( pBoard->hWnd, hDC );
}

void PressBoxes( BOARD *pBoard, ULONG uCol, ULONG uRow )
{
    CHAR i, j;

    for( i = -1; i <= 1; i++ )
    {
        for( j = -1; j <= 1; j++ )
        {
            pBoard->Box[uCol + i][uRow + j].bIsPressed = TRUE;
            PressBox( pBoard, uCol + i, uRow + j );
        }
    }

    for( i = -1; i <= 1; i++ )
    {
        for( j = -1; j <= 1; j++ )
        {
            if( !pBoard->Box[pBoard->Press.x + i][pBoard->Press.y + j].bIsPressed )
                UnpressBox( pBoard, pBoard->Press.x + i, pBoard->Press.y + j );
        }
    }

    for( i = -1; i <= 1; i++ )
    {
        for( j = -1; j <= 1; j++ )
        {
            pBoard->Box[uCol + i][uRow + j].bIsPressed = FALSE;
            PressBox( pBoard, uCol + i, uRow + j );
        }
    }

    pBoard->Press.x = uCol;
    pBoard->Press.y = uRow;
}

void UnpressBox( BOARD *pBoard, ULONG uCol, ULONG uRow )
{
    HDC hDC;
    HGDIOBJ hOldObj;
    HDC hMemDC;

    hDC = GetDC( pBoard->hWnd );
    hMemDC = CreateCompatibleDC( hDC );
    hOldObj = SelectObject( hMemDC, pBoard->hMinesBMP );

    DrawMine( hDC, hMemDC, pBoard, uCol, uRow, FALSE );

    SelectObject( hMemDC, hOldObj );
    DeleteDC( hMemDC );
    ReleaseDC( pBoard->hWnd, hDC );
}

void UnpressBoxes( BOARD *pBoard, ULONG uCol, ULONG uRow )
{
    CHAR i, j;

    for( i = -1; i <= 1; i++ )
    {
        for( j = -1; j <= 1; j++ )
        {
            UnpressBox( pBoard, uCol + i, uRow + j );
        }
    }
}