main.c

从rectos源码中提取的rectos版本的扫雷。是Win32 Application类型的C++源码。全面模仿了Windows扫雷

/*
 * WineMine (main.c)
 *
 * Copyright 2000 Joshua Thielen <[e-mail]>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <windows.h>
#include <tchar.h>
#include "main.h"
#include "dialog.h"
#include "resource.h"

#ifdef DUMB_DEBUG
#include <stdio.h>
#define DEBUG(x) fprintf(stderr,x)
#else
#define DEBUG(x)
#endif

static const TCHAR szAppName[] = TEXT("WineMine");


int WINAPI _tWinMain( HINSTANCE hInst, HINSTANCE hPrevInst, LPTSTR cmdline, int cmdshow )
{
    MSG msg;
    WNDCLASS wc;
    HWND hWnd;
    HACCEL haccel;

    wc.style = 0;
    wc.lpfnWndProc = MainProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInst;
    wc.hIcon = LoadIcon( hInst, MAKEINTRESOURCE(IDI_WINEMINE) );
    wc.hCursor = LoadCursor( NULL, (LPCTSTR)IDI_APPLICATION );
    wc.hbrBackground = (HBRUSH) GetStockObject( LTGRAY_BRUSH );
    wc.lpszMenuName = MAKEINTRESOURCE(IDM_WINEMINE);
    wc.lpszClassName = szAppName;

    if ( !RegisterClass(&wc) )
        return 1;

    hWnd = CreateWindow( szAppName, szAppName,
        WS_OVERLAPPEDWINDOW & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, hInst, NULL );

    if (!hWnd)
        return 1;

    ShowWindow( hWnd, cmdshow );
    UpdateWindow( hWnd );

    haccel = LoadAccelerators( hInst, MAKEINTRESOURCE(IDA_WINEMINE) );
    SetTimer( hWnd, ID_TIMER, 1000, NULL );

    while( GetMessage(&msg, NULL, 0, 0) )
    {
        if ( !TranslateAccelerator(hWnd, haccel, &msg) )
            TranslateMessage(&msg);

        DispatchMessage(&msg);
    }

    return msg.wParam;
}

LRESULT WINAPI MainProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static BOARD board;

    switch(msg)
    {
        case WM_CREATE:
            board.hInst = ((LPCREATESTRUCT) lParam)->hInstance;
            board.hWnd = hWnd;
            InitBoard( &board );
            CreateBoard( &board );
            return 0;

        case WM_PAINT:
        {
            HDC hDC;
            HDC hMemDC;
            PAINTSTRUCT ps;

            DEBUG("WM_PAINT\n");
            hDC = BeginPaint( hWnd, &ps );
            hMemDC = CreateCompatibleDC(hDC);

            DrawBoard( hDC, hMemDC, &ps, &board );

            DeleteDC( hMemDC );
            EndPaint( hWnd, &ps );

            return 0;
        }

        case WM_MOVE:
            DEBUG("WM_MOVE\n");
            board.Pos.x = (LONG) LOWORD(lParam);
            board.Pos.y = (LONG) HIWORD(lParam);
            return 0;

        case WM_DESTROY:
            SaveBoard( &board );
            DestroyBoard( &board );
            PostQuitMessage( 0 );
            return 0;

        case WM_TIMER:
            if( board.Status == PLAYING )
            {
                board.uTime++;
                RedrawWindow( hWnd, &board.TimerRect, NULL, RDW_INVALIDATE | RDW_UPDATENOW );
            }
            return 0;

        case WM_LBUTTONDOWN:
            DEBUG("WM_LBUTTONDOWN\n");

            if( wParam & MK_RBUTTON )
                msg = WM_MBUTTONDOWN;

            TestBoard( hWnd, &board, LOWORD(lParam), HIWORD(lParam), msg );
            SetCapture( hWnd );
            return 0;

        case WM_LBUTTONUP:
            DEBUG("WM_LBUTTONUP\n");

            if( wParam & MK_RBUTTON )
                msg = WM_MBUTTONUP;

            TestBoard( hWnd, &board, LOWORD(lParam), HIWORD(lParam), msg );
            ReleaseCapture();
            return 0;

        case WM_RBUTTONDOWN:
            DEBUG("WM_RBUTTONDOWN\n");

            if( wParam & MK_LBUTTON )
            {
                board.Press.x = 0;
                board.Press.y = 0;
                msg = WM_MBUTTONDOWN;
            }

            TestBoard( hWnd, &board, LOWORD(lParam), HIWORD(lParam), msg );
            return 0;

        case WM_RBUTTONUP:
            DEBUG("WM_RBUTTONUP\n");
            if( wParam & MK_LBUTTON )
                msg = WM_MBUTTONUP;
            TestBoard( hWnd, &board, LOWORD(lParam), HIWORD(lParam), msg );
            return 0;

        case WM_MBUTTONDOWN:
            DEBUG("WM_MBUTTONDOWN\n");
            TestBoard( hWnd, &board, LOWORD(lParam), HIWORD(lParam), msg );
            return 0;

        case WM_MBUTTONUP:
            DEBUG("WM_MBUTTONUP\n");
            TestBoard( hWnd, &board, LOWORD(lParam), HIWORD(lParam), msg );
            return 0;

        case WM_MOUSEMOVE:
        {
            if( (wParam & MK_LBUTTON) && (wParam & MK_RBUTTON) )
                msg = WM_MBUTTONDOWN;
            else if( wParam & MK_LBUTTON )
                msg = WM_LBUTTONDOWN;
            else
                return 0;

            TestBoard( hWnd, &board, LOWORD(lParam), HIWORD(lParam),  msg );

            return 0;
        }

        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDM_NEW:
                    CreateBoard( &board );
                    return 0;

                case IDM_MARKQ:
                {
                    HMENU hMenu;

                    hMenu = GetMenu( hWnd );
                    board.bMark = !board.bMark;

                    if( board.bMark )
                        CheckMenuItem( hMenu, IDM_MARKQ, MF_CHECKED );
                    else
                        CheckMenuItem( hMenu, IDM_MARKQ, MF_UNCHECKED );

                    return 0;
                }

                case IDM_BEGINNER:
                    SetDifficulty( &board, BEGINNER );
                    CreateBoard( &board );
                    return 0;

                case IDM_ADVANCED:
                    SetDifficulty( &board, ADVANCED );
                    CreateBoard( &board );
                    return 0;

                case IDM_EXPERT:
                    SetDifficulty( &board, EXPERT );
                    CreateBoard( &board );
                    return 0;

                case IDM_CUSTOM:
                    SetDifficulty( &board, CUSTOM );
                    CreateBoard( &board );
                    return 0;

                case IDM_EXIT:
                    SendMessage( hWnd, WM_CLOSE, 0, 0);
                    return 0;

                case IDM_TIMES:
                    DialogBoxParam( board.hInst, MAKEINTRESOURCE(IDD_TIMES), hWnd, TimesDlgProc, (LPARAM) &board);
                    return 0;

                case IDM_ABOUT:
                {
                    TCHAR szOtherStuff[255];

                    LoadString( board.hInst, IDS_ABOUT, szOtherStuff, sizeof(szOtherStuff) / sizeof(TCHAR) );

                    ShellAbout( hWnd, szAppName, szOtherStuff, (HICON)SendMessage(hWnd, WM_GETICON, ICON_BIG, 0) );
                    return 0;
                }

                default:
                    DEBUG("Unknown WM_COMMAND command message received\n");
                    break;
            }
    }

    return( DefWindowProc( hWnd, msg, wParam, lParam ));
}

void InitBoard( BOARD *pBoard )
{
    HMENU hMenu;

    pBoard->hMinesBMP = LoadBitmap( pBoard->hInst, (LPCTSTR) IDB_MINES);
    pBoard->hFacesBMP = LoadBitmap( pBoard->hInst, (LPCTSTR) IDB_FACES);
    pBoard->hLedsBMP = LoadBitmap( pBoard->hInst, (LPCTSTR) IDB_LEDS);

    LoadBoard( pBoard );

    if( pBoard->Pos.x < GetSystemMetrics( SM_CXFIXEDFRAME ) )
        pBoard->Pos.x = GetSystemMetrics( SM_CXFIXEDFRAME );

    if( pBoard->Pos.x > (GetSystemMetrics( SM_CXSCREEN )  - GetSystemMetrics( SM_CXFIXEDFRAME )))
    {
        pBoard->Pos.x = GetSystemMetrics( SM_CXSCREEN )
        - GetSystemMetrics( SM_CXFIXEDFRAME );
    }

    if( pBoard->Pos.y < (GetSystemMetrics( SM_CYMENU ) + GetSystemMetrics( SM_CYCAPTION ) + GetSystemMetrics( SM_CYFIXEDFRAME )))
    {
        pBoard->Pos.y = GetSystemMetrics( SM_CYMENU ) +
        GetSystemMetrics( SM_CYCAPTION ) +
        GetSystemMetrics( SM_CYFIXEDFRAME );
    }

    if( pBoard->Pos.y > (GetSystemMetrics( SM_CYSCREEN ) - GetSystemMetrics( SM_CYFIXEDFRAME )))
    {
        pBoard->Pos.y = GetSystemMetrics( SM_CYSCREEN )
        - GetSystemMetrics( SM_CYFIXEDFRAME );
    }

    hMenu = GetMenu( pBoard->hWnd );
    CheckMenuItem( hMenu, IDM_BEGINNER + pBoard->Difficulty, MF_CHECKED );

    if( pBoard->bMark )
        CheckMenuItem( hMenu, IDM_MARKQ, MF_CHECKED );
    else
        CheckMenuItem( hMenu, IDM_MARKQ, MF_UNCHECKED );
    CheckLevel( pBoard );
}

static DWORD LoadDWord(HKEY hKey, TCHAR *szKeyName, DWORD dwDefaultValue)
{
    DWORD dwSize;
    DWORD dwValue;

    dwSize = sizeof(DWORD);

    if( RegQueryValueEx( hKey, szKeyName, NULL, NULL, (LPBYTE) &dwValue, &dwSize ) == ERROR_SUCCESS )
        return dwValue;

    return dwDefaultValue;
}

void LoadBoard( BOARD *pBoard )
{
    DWORD dwSize;
    HKEY hKey;
    TCHAR szData[16];
    TCHAR szKeyName[8];
    TCHAR szNobody[15];
    UCHAR i;

    RegOpenKeyEx( HKEY_CURRENT_USER, szWineMineRegKey, 0, KEY_QUERY_VALUE, &hKey );

    pBoard->Pos.x =      (LONG)       LoadDWord( hKey, TEXT("Xpos"), GetSystemMetrics(SM_CXFIXEDFRAME) );
    pBoard->Pos.y =      (LONG)       LoadDWord( hKey, TEXT("Ypos"), GetSystemMetrics(SM_CYMENU) + GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFIXEDFRAME) );
    pBoard->uRows =      (ULONG)      LoadDWord( hKey, TEXT("Height"), BEGINNER_ROWS );
    pBoard->uCols =      (ULONG)      LoadDWord( hKey, TEXT("Width"), BEGINNER_COLS );
    pBoard->uMines =     (ULONG)      LoadDWord( hKey, TEXT("Mines"), BEGINNER_MINES );
    pBoard->Difficulty = (DIFFICULTY) LoadDWord( hKey, TEXT("Difficulty"), BEGINNER );
    pBoard->bMark =      (BOOL)       LoadDWord( hKey, TEXT("Mark"), TRUE );

    LoadString( pBoard->hInst, IDS_NOBODY, szNobody, sizeof(szNobody) / sizeof(TCHAR) );

    for( i = 0; i < 3; i++ )
    {
        // As we write to the same registry key as MS WinMine does, we have to start at 1 for the registry keys
        wsprintf( szKeyName, TEXT("Name%d"), i + 1 );
        dwSize = sizeof(szData);

        if( RegQueryValueEx( hKey, szKeyName, NULL, NULL, (LPBYTE)szData, (LPDWORD) &dwSize ) == ERROR_SUCCESS )
            _tcsncpy( pBoard->szBestName[i], szData, sizeof(szData) / sizeof(TCHAR) );
        else
            _tcscpy( pBoard->szBestName[i], szNobody);
    }

    for( i = 0; i < 3; i++ )
    {
        wsprintf( szKeyName, TEXT("Time%d"), i + 1 );
        pBoard->uBestTime[i] = LoadDWord( hKey, szKeyName, 999 );
    }