programs/winemine/main.c

   1 /*
   2  * WineMine (main.c)
   3  *
   4  * Copyright 2000 Joshua Thielen
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_LEAN_AND_MEAN
  22
  23 #include <string.h>
  24 #include <time.h>
  25 #include <windows.h>
  26 #include <commctrl.h>
  27 #include <stdlib.h>
  28 #include <shellapi.h>
  29 #include "main.h"
  30 #include "resource.h"
  31
  32 #include <wine/debug.h>
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(winemine);
  35
  36 static const DWORD wnd_style = WS_OVERLAPPEDWINDOW & ~WS_THICKFRAME & ~WS_MAXIMIZEBOX;
  37
  38 void CheckLevel( BOARD *p_board )
  39 {
  40     if( p_board->rows < BEGINNER_ROWS )
  41         p_board->rows = BEGINNER_ROWS;
  42
  43     if( p_board->rows > MAX_ROWS )
  44         p_board->rows = MAX_ROWS;
  45
  46     if( p_board->cols < BEGINNER_COLS )
  47         p_board->cols = BEGINNER_COLS;
  48
  49     if( p_board->cols > MAX_COLS )
  50         p_board->cols = MAX_COLS;
  51
  52     if( p_board->mines < BEGINNER_MINES )
  53         p_board->mines = BEGINNER_MINES;
  54
  55     if( p_board->mines > ( p_board->cols - 1 ) * ( p_board->rows - 1 ) )
  56         p_board->mines = ( p_board->cols - 1 ) * ( p_board->rows - 1 );
  57 }
  58
  59 static void LoadBoard( BOARD *p_board )
  60 {
  61     DWORD size;
  62     DWORD type;
  63     HKEY hkey;
  64     WCHAR data[MAX_PLAYER_NAME_SIZE+1];
  65     WCHAR key_name[8];
  66     unsigned i;
  67
  68     RegOpenKeyExW( HKEY_CURRENT_USER, L"Software\\Microsoft\\WinMine", 0, KEY_QUERY_VALUE, &hkey );
  69
  70     size = sizeof( p_board->pos.x );
  71     if( RegQueryValueExW( hkey, L"Xpos", NULL, &type, (BYTE*) &p_board->pos.x, &size ) )
  72         p_board->pos.x = 0;
  73
  74     size = sizeof( p_board->pos.y );
  75     if( RegQueryValueExW( hkey, L"Ypos", NULL, &type, (BYTE*) &p_board->pos.y, &size ) )
  76         p_board->pos.y = 0;
  77
  78     size = sizeof( p_board->rows );
  79     if( RegQueryValueExW( hkey, L"Height", NULL, &type, (BYTE*) &p_board->rows, &size ) )
  80         p_board->rows = BEGINNER_ROWS;
  81
  82     size = sizeof( p_board->cols );
  83     if( RegQueryValueExW( hkey, L"Width", NULL, &type, (BYTE*) &p_board->cols, &size ) )
  84         p_board->cols = BEGINNER_COLS;
  85
  86     size = sizeof( p_board->mines );
  87     if( RegQueryValueExW( hkey, L"Mines", NULL, &type, (BYTE*) &p_board->mines, &size ) )
  88         p_board->mines = BEGINNER_MINES;
  89
  90     size = sizeof( p_board->difficulty );
  91     if( RegQueryValueExW( hkey, L"Difficulty", NULL, &type, (BYTE*) &p_board->difficulty, &size ) )
  92         p_board->difficulty = BEGINNER;
  93
  94     size = sizeof( p_board->IsMarkQ );
  95     if( RegQueryValueExW( hkey, L"Mark", NULL, &type, (BYTE*) &p_board->IsMarkQ, &size ) )
  96         p_board->IsMarkQ = TRUE;
  97
  98     for( i = 0; i < 3; i++ ) {
  99         wsprintfW( key_name, L"Name%u", i+1 );
 100         size = sizeof( data );
 101         if( RegQueryValueExW( hkey, key_name, NULL, &type,
 102                 (LPBYTE) data, &size ) == ERROR_SUCCESS )
 103             lstrcpynW( p_board->best_name[i], data, ARRAY_SIZE(p_board->best_name[i]));
 104         else
 105             LoadStringW( p_board->hInst, IDS_NOBODY, p_board->best_name[i], MAX_PLAYER_NAME_SIZE+1 );
 106     }
 107
 108     for( i = 0; i < 3; i++ ) {
 109         wsprintfW( key_name, L"Time%u", i+1 );
 110         size = sizeof( p_board->best_time[i] );
 111         if( RegQueryValueExW( hkey, key_name, NULL, &type, (BYTE*) &p_board->best_time[i], &size ) )
 112             p_board->best_time[i] = 999;
 113     }
 114     RegCloseKey( hkey );
 115 }
 116
 117 static void InitBoard( BOARD *p_board )
 118 {
 119     HMENU hMenu;
 120
 121     p_board->hMinesBMP = LoadBitmapW( p_board->hInst, MAKEINTRESOURCEW(IDI_MINES));
 122     p_board->hFacesBMP = LoadBitmapW( p_board->hInst, MAKEINTRESOURCEW(IDI_FACES));
 123     p_board->hLedsBMP = LoadBitmapW( p_board->hInst, MAKEINTRESOURCEW(IDI_LEDS));
 124
 125     LoadBoard( p_board );
 126
 127     hMenu = GetMenu( p_board->hWnd );
 128     CheckMenuItem( hMenu, IDM_BEGINNER + (unsigned) p_board->difficulty,
 129             MF_CHECKED );
 130     if( p_board->IsMarkQ )
 131         CheckMenuItem( hMenu, IDM_MARKQ, MF_CHECKED );
 132     else
 133         CheckMenuItem( hMenu, IDM_MARKQ, MF_UNCHECKED );
 134     CheckLevel( p_board );
 135 }
 136
 137 void ResetResults( BOARD *p_board )
 138 {
 139     unsigned i;
 140
 141     for( i = 0; i < 3; i++ ) {
 142         LoadStringW( p_board->hInst, IDS_NOBODY, p_board->best_name[i], MAX_PLAYER_NAME_SIZE+1 );
 143         p_board->best_time[i] = 999;
 144     }
 145 }
 146
 147 void SaveBoard( BOARD *p_board )
 148 {
 149     HKEY hkey;
 150     unsigned i;
 151     WCHAR data[MAX_PLAYER_NAME_SIZE+1];
 152     WCHAR key_name[8];
 153
 154     if( RegCreateKeyExW( HKEY_CURRENT_USER, L"Software\\Microsoft\\WinMine",
 155                 0, NULL,
 156                 REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL,
 157                 &hkey, NULL ) != ERROR_SUCCESS)
 158         return;
 159
 160     RegSetValueExW( hkey, L"Xpos", 0, REG_DWORD, (BYTE*) &p_board->pos.x, sizeof(p_board->pos.x) );
 161     RegSetValueExW( hkey, L"Ypos", 0, REG_DWORD, (BYTE*) &p_board->pos.y, sizeof(p_board->pos.y) );
 162     RegSetValueExW( hkey, L"Difficulty", 0, REG_DWORD, (BYTE*) &p_board->difficulty, sizeof(p_board->difficulty) );
 163     RegSetValueExW( hkey, L"Height", 0, REG_DWORD, (BYTE*) &p_board->rows, sizeof(p_board->rows) );
 164     RegSetValueExW( hkey, L"Width", 0, REG_DWORD, (BYTE*) &p_board->cols, sizeof(p_board->cols) );
 165     RegSetValueExW( hkey, L"Mines", 0, REG_DWORD, (BYTE*) &p_board->mines, sizeof(p_board->mines) );
 166     RegSetValueExW( hkey, L"Mark", 0, REG_DWORD, (BYTE*) &p_board->IsMarkQ, sizeof(p_board->IsMarkQ) );
 167
 168     for( i = 0; i < 3; i++ ) {
 169         wsprintfW( key_name, L"Name%u", i+1 );
 170         lstrcpynW( data, p_board->best_name[i], ARRAY_SIZE(data));
 171         RegSetValueExW( hkey, key_name, 0, REG_SZ, (LPBYTE) data, (lstrlenW(data)+1) * sizeof(WCHAR) );
 172     }
 173
 174     for( i = 0; i < 3; i++ ) {
 175         wsprintfW( key_name, L"Time%u", i+1 );
 176         RegSetValueExW( hkey, key_name, 0, REG_DWORD, (LPBYTE) &p_board->best_time[i], sizeof(p_board->best_time[i]) );
 177     }
 178     RegCloseKey( hkey );
 179
 180     WINE_TRACE("Board has been saved.\n");
 181 }
 182
 183 static void DestroyBoard( BOARD *p_board )
 184 {
 185     DeleteObject( p_board->hFacesBMP );
 186     DeleteObject( p_board->hLedsBMP );
 187     DeleteObject( p_board->hMinesBMP );
 188 }
 189
 190 static void SetDifficulty( BOARD *p_board, DIFFICULTY difficulty )
 191 {
 192     HMENU hMenu;
 193
 194     if ( difficulty == CUSTOM )
 195         if (DialogBoxParamW( p_board->hInst, MAKEINTRESOURCEW(DLG_CUSTOM), p_board->hWnd,
 196                     CustomDlgProc, (LPARAM) p_board) != 0)
 197            return;
 198
 199     hMenu = GetMenu( p_board->hWnd );
 200     CheckMenuItem( hMenu, IDM_BEGINNER + p_board->difficulty, MF_UNCHECKED );
 201     p_board->difficulty = difficulty;
 202     CheckMenuItem( hMenu, IDM_BEGINNER + difficulty, MF_CHECKED );
 203
 204     switch( difficulty ) {
 205     case BEGINNER:
 206         p_board->cols = BEGINNER_COLS;
 207         p_board->rows = BEGINNER_ROWS;
 208         p_board->mines = BEGINNER_MINES;
 209         break;
 210
 211     case ADVANCED:
 212         p_board->cols = ADVANCED_COLS;
 213         p_board->rows = ADVANCED_ROWS;
 214         p_board->mines = ADVANCED_MINES;
 215         break;
 216
 217     case EXPERT:
 218         p_board->cols = EXPERT_COLS;
 219         p_board->rows = EXPERT_ROWS;
 220
 221         p_board->mines = EXPERT_MINES;
 222         break;
 223
 224     case CUSTOM:
 225         break;
 226     }
 227 }
 228
 229 static void ShiftBetween(LONG* x, LONG* y, LONG a, LONG b)
 230 {
 231     if (*x < a) {
 232         *y += a - *x;
 233         *x = a;
 234     }
 235     else if (*y > b) {
 236         *x -= *y - b;
 237         *y = b;
 238     }
 239 }
 240
 241 static void MoveOnScreen(RECT* rect)
 242 {
 243     HMONITOR hMonitor;
 244     MONITORINFO mi;
 245
 246     /* find the nearest monitor ... */
 247     hMonitor = MonitorFromRect(rect, MONITOR_DEFAULTTONEAREST);
 248
 249     /* ... and move it into the work area (ie excluding task bar)*/
 250     mi.cbSize = sizeof(mi);
 251     GetMonitorInfoW(hMonitor, &mi);
 252
 253     ShiftBetween(&rect->left, &rect->right, mi.rcWork.left, mi.rcWork.right);
 254     ShiftBetween(&rect->top, &rect->bottom, mi.rcWork.top, mi.rcWork.bottom);
 255 }
 256
 257 static void CreateBoard( BOARD *p_board )
 258 {
 259     int left, top, bottom, right;
 260     unsigned col, row;
 261     RECT wnd_rect;
 262
 263     p_board->mb = MB_NONE;
 264     p_board->boxes_left = p_board->cols * p_board->rows - p_board->mines;
 265     p_board->num_flags = 0;
 266
 267     /* Create the boxes...
 268      * We actually create them with an empty border,
 269      * so special care doesn't have to be taken on the edges
 270      */
 271     for( col = 0; col <= p_board->cols + 1; col++ )
 272       for( row = 0; row <= p_board->rows + 1; row++ ) {
 273         p_board->box[col][row].IsPressed = FALSE;
 274         p_board->box[col][row].IsMine = FALSE;
 275         p_board->box[col][row].FlagType = NORMAL;
 276         p_board->box[col][row].NumMines = 0;
 277       }
 278
 279     p_board->width = p_board->cols * MINE_WIDTH + BOARD_WMARGIN * 2;
 280
 281     p_board->height = p_board->rows * MINE_HEIGHT + LED_HEIGHT
 282         + BOARD_HMARGIN * 3;
 283
 284     /* setting the mines rectangle boundary */
 285     left = BOARD_WMARGIN;
 286     top = BOARD_HMARGIN * 2 + LED_HEIGHT;
 287     right = left + p_board->cols * MINE_WIDTH;
 288     bottom = top + p_board->rows * MINE_HEIGHT;
 289     SetRect( &p_board->mines_rect, left, top, right, bottom );
 290
 291     /* setting the face rectangle boundary */
 292     left = p_board->width / 2 - FACE_WIDTH / 2;
 293     top = BOARD_HMARGIN;
 294     right = left + FACE_WIDTH;
 295     bottom = top + FACE_HEIGHT;
 296     SetRect( &p_board->face_rect, left, top, right, bottom );
 297
 298     /* setting the timer rectangle boundary */
 299     left = BOARD_WMARGIN;
 300     top = BOARD_HMARGIN;
 301     right = left + LED_WIDTH * 3;
 302     bottom = top + LED_HEIGHT;
 303     SetRect( &p_board->timer_rect, left, top, right, bottom );
 304
 305     /* setting the counter rectangle boundary */
 306     left =  p_board->width - BOARD_WMARGIN - LED_WIDTH * 3;
 307     top = BOARD_HMARGIN;
 308     right = p_board->width - BOARD_WMARGIN;
 309     bottom = top + LED_HEIGHT;
 310     SetRect( &p_board->counter_rect, left, top, right, bottom );
 311
 312     p_board->status = WAITING;
 313     p_board->face_bmp = SMILE_BMP;
 314     p_board->time = 0;
 315
 316     SetRect(&wnd_rect, p_board->pos.x, p_board->pos.y, p_board->pos.x + p_board->width,
 317             p_board->pos.y + p_board->height);
 318     AdjustWindowRect(&wnd_rect, wnd_style, TRUE);
 319
 320     /* Make sure the window is completely on the screen */
 321     MoveOnScreen(&wnd_rect);
 322     MoveWindow( p_board->hWnd, wnd_rect.left, wnd_rect.top,
 323                 wnd_rect.right - wnd_rect.left,
 324                 wnd_rect.bottom - wnd_rect.top,
 325                 TRUE );
 326     RedrawWindow( p_board->hWnd, NULL, 0,
 327                   RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE);
 328 }
 329
 330
 331 /* Randomly places mines everywhere except the selected box. */
 332 static void PlaceMines ( BOARD *p_board, int selected_col, int selected_row )
 333 {
 334     int i, j;
 335     unsigned col, row;
 336
 337     srand( (unsigned) time( NULL ) );
 338
 339     /* Temporarily place a mine at the selected box until all the other
 340      * mines are placed, this avoids checking in the mine creation loop. */
 341     p_board->box[selected_col][selected_row].IsMine = TRUE;
 342
 343     /* create mines */
 344     i = 0;
 345     while( (unsigned) i < p_board->mines ) {
 346         col = rand() % p_board->cols + 1;
 347         row = rand() % p_board->rows + 1;
 348
 349         if( !p_board->box[col][row].IsMine ) {
 350             i++;
 351             p_board->box[col][row].IsMine = TRUE;
 352         }
 353     }
 354
 355     /* Remove temporarily placed mine for selected box */
 356     p_board->box[selected_col][selected_row].IsMine = FALSE;
 357
 358     /*
 359      * Now we label the remaining boxes with the
 360      * number of mines surrounding them.
 361      */
 362     for( col = 1; col < p_board->cols + 1; col++ )
 363     for( row = 1; row < p_board->rows + 1; row++ ) {
 364         for( i = -1; i <= 1; i++ )
 365         for( j = -1; j <= 1; j++ ) {
 366             if( p_board->box[col + i][row + j].IsMine ) {
 367                 p_board->box[col][row].NumMines++ ;
 368             }
 369         }
 370     }
 371 }
 372
 373 static void DrawMine( HDC hdc, HDC hMemDC, BOARD *p_board, unsigned col, unsigned row, BOOL IsPressed )
 374 {
 375     MINEBMP_OFFSET offset = BOX_BMP;
 376
 377     if( col == 0 || col > p_board->cols || row == 0 || row > p_board->rows )
 378            return;
 379
 380     if( p_board->status == GAMEOVER ) {
 381         if( p_board->box[col][row].IsMine ) {
 382             switch( p_board->box[col][row].FlagType ) {
 383             case FLAG:
 384                 offset = FLAG_BMP;
 385                 break;
 386             case COMPLETE:
 387                 offset = EXPLODE_BMP;
 388                 break;
 389             case QUESTION:
 390                 /* fall through */
 391             case NORMAL:
 392                 offset = MINE_BMP;
 393             }
 394         } else {
 395             switch( p_board->box[col][row].FlagType ) {
 396             case QUESTION:
 397                 offset = QUESTION_BMP;
 398                 break;
 399             case FLAG:
 400                 offset = WRONG_BMP;
 401                 break;
 402             case NORMAL:
 403                 offset = BOX_BMP;
 404                 break;
 405             case COMPLETE:
 406                 /* Do nothing */
 407                 break;
 408             default:
 409                 WINE_TRACE("Unknown FlagType during game over in DrawMine\n");
 410                 break;
 411             }
 412         }
 413     } else {    /* WAITING or PLAYING */
 414         switch( p_board->box[col][row].FlagType ) {
 415         case QUESTION:
 416             if( !IsPressed )
 417                 offset = QUESTION_BMP;
 418             else
 419                 offset = QPRESS_BMP;
 420             break;
 421         case FLAG:
 422             offset = FLAG_BMP;
 423             break;
 424         case NORMAL:
 425             if( !IsPressed )
 426                 offset = BOX_BMP;
 427             else
 428                 offset = MPRESS_BMP;
 429             break;
 430         case COMPLETE:
 431             /* Do nothing */
 432             break;
 433         default:
 434             WINE_TRACE("Unknown FlagType while playing in DrawMine\n");
 435             break;
 436         }
 437     }
 438
 439     if( p_board->box[col][row].FlagType == COMPLETE
 440         && !p_board->box[col][row].IsMine )
 441           offset = (MINEBMP_OFFSET) p_board->box[col][row].NumMines;
 442
 443     BitBlt( hdc,
 444             (col - 1) * MINE_WIDTH + p_board->mines_rect.left,
 445             (row - 1) * MINE_HEIGHT + p_board->mines_rect.top,
 446             MINE_WIDTH, MINE_HEIGHT,
 447             hMemDC, 0, offset * MINE_HEIGHT, SRCCOPY );
 448 }
 449
 450 static void DrawMines ( HDC hdc, HDC hMemDC, BOARD *p_board )
 451 {
 452     HGDIOBJ hOldObj;
 453     unsigned col, row;
 454     hOldObj = SelectObject (hMemDC, p_board->hMinesBMP);
 455
 456     for( row = 1; row <= p_board->rows; row++ ) {
 457       for( col = 1; col <= p_board->cols; col++ ) {
 458         DrawMine( hdc, hMemDC, p_board, col, row, FALSE );
 459       }
 460     }
 461     SelectObject( hMemDC, hOldObj );
 462 }
 463
 464 static void DrawLeds( HDC hdc, HDC hMemDC, BOARD *p_board, int number, int x, int y )
 465 {
 466     HGDIOBJ hOldObj;
 467     unsigned led[3], i;
 468     int count;
 469
 470     count = number;
 471     if( count < 1000 ) {
 472         if( count >= 0 ) {
 473             led[0] = count / 100 ;
 474             count -= led[0] * 100;
 475         }
 476         else {
 477             led[0] = 10; /* negative sign */
 478             count = -count;
 479         }
 480         led[1] = count / 10;
 481         count -= led[1] * 10;
 482         led[2] = count;
 483     }
 484     else {
 485         for( i = 0; i < 3; i++ )
 486             led[i] = 10;
 487     }
 488
 489     hOldObj = SelectObject (hMemDC, p_board->hLedsBMP);
 490
 491     for( i = 0; i < 3; i++ ) {
 492         BitBlt( hdc,
 493             i * LED_WIDTH + x,
 494             y,
 495             LED_WIDTH,
 496             LED_HEIGHT,
 497             hMemDC,
 498             0,
 499             led[i] * LED_HEIGHT,
 500             SRCCOPY);
 501     }
 502
 503     SelectObject( hMemDC, hOldObj );
 504 }
 505
 506
 507 static void DrawFace( HDC hdc, HDC hMemDC, BOARD *p_board )
 508 {
 509     HGDIOBJ hOldObj;
 510
 511     hOldObj = SelectObject (hMemDC, p_board->hFacesBMP);
 512
 513     BitBlt( hdc,
 514         p_board->face_rect.left,
 515         p_board->face_rect.top,
 516         FACE_WIDTH,
 517         FACE_HEIGHT,
 518         hMemDC, 0, p_board->face_bmp * FACE_HEIGHT, SRCCOPY);
 519
 520     SelectObject( hMemDC, hOldObj );
 521 }
 522
 523
 524 static void DrawBoard( HDC hdc, HDC hMemDC, PAINTSTRUCT *ps, BOARD *p_board )
 525 {
 526     RECT tmp_rect;
 527
 528     if( IntersectRect( &tmp_rect, &ps->rcPaint, &p_board->counter_rect ) )
 529         DrawLeds( hdc, hMemDC, p_board, p_board->mines - p_board->num_flags,
 530                   p_board->counter_rect.left,
 531                   p_board->counter_rect.top );
 532
 533     if( IntersectRect( &tmp_rect, &ps->rcPaint, &p_board->timer_rect ) )
 534         DrawLeds( hdc, hMemDC, p_board, p_board->time,
 535                   p_board->timer_rect.left,
 536                   p_board->timer_rect.top );
 537
 538     if( IntersectRect( &tmp_rect, &ps->rcPaint, &p_board->face_rect ) )
 539         DrawFace( hdc, hMemDC, p_board );
 540
 541     if( IntersectRect( &tmp_rect, &ps->rcPaint, &p_board->mines_rect ) )
 542         DrawMines( hdc, hMemDC, p_board );
 543 }
 544
 545
 546 static void AddFlag( BOARD *p_board, unsigned col, unsigned row )
 547 {
 548     if( p_board->box[col][row].FlagType != COMPLETE ) {
 549         switch( p_board->box[col][row].FlagType ) {
 550         case FLAG:
 551             if( p_board->IsMarkQ )
 552                 p_board->box[col][row].FlagType = QUESTION;
 553             else
 554                 p_board->box[col][row].FlagType = NORMAL;
 555             p_board->num_flags--;
 556             break;
 557
 558         case QUESTION:
 559             p_board->box[col][row].FlagType = NORMAL;
 560             break;
 561
 562         default:
 563             p_board->box[col][row].FlagType = FLAG;
 564             p_board->num_flags++;
 565         }
 566     }
 567 }
 568
 569
 570 static void UnpressBox( BOARD *p_board, unsigned col, unsigned row )
 571 {
 572     HDC hdc;
 573     HGDIOBJ hOldObj;
 574     HDC hMemDC;
 575
 576     hdc = GetDC( p_board->hWnd );
 577     hMemDC = CreateCompatibleDC( hdc );
 578     hOldObj = SelectObject( hMemDC, p_board->hMinesBMP );
 579
 580     DrawMine( hdc, hMemDC, p_board, col, row, FALSE );
 581
 582     SelectObject( hMemDC, hOldObj );
 583     DeleteDC( hMemDC );
 584     ReleaseDC( p_board->hWnd, hdc );
 585 }
 586
 587
 588 static void UnpressBoxes( BOARD *p_board, unsigned col, unsigned row )
 589 {
 590     int i, j;
 591
 592     for( i = -1; i <= 1; i++ )
 593       for( j = -1; j <= 1; j++ ) {
 594         UnpressBox( p_board, col + i, row + j );
 595       }
 596 }
 597
 598
 599 static void PressBox( BOARD *p_board, unsigned col, unsigned row )
 600 {
 601     HDC hdc;
 602     HGDIOBJ hOldObj;
 603     HDC hMemDC;
 604
 605     hdc = GetDC( p_board->hWnd );
 606     hMemDC = CreateCompatibleDC( hdc );
 607     hOldObj = SelectObject (hMemDC, p_board->hMinesBMP);
 608
 609     DrawMine( hdc, hMemDC, p_board, col, row, TRUE );
 610
 611     SelectObject( hMemDC, hOldObj );
 612     DeleteDC( hMemDC );
 613     ReleaseDC( p_board->hWnd, hdc );
 614 }
 615
 616
 617 static void PressBoxes( BOARD *p_board, unsigned col, unsigned row )
 618 {
 619     int i, j;
 620
 621     for( i = -1; i <= 1; i++ )
 622       for( j = -1; j <= 1; j++ ) {
 623         p_board->box[col + i][row + j].IsPressed = TRUE;
 624         PressBox( p_board, col + i, row + j );
 625     }
 626
 627     for( i = -1; i <= 1; i++ )
 628       for( j = -1; j <= 1; j++ ) {
 629         if( !p_board->box[p_board->press.x + i][p_board->press.y + j].IsPressed )
 630             UnpressBox( p_board, p_board->press.x + i, p_board->press.y + j );
 631     }
 632
 633     for( i = -1; i <= 1; i++ )
 634       for( j = -1; j <= 1; j++ ) {
 635         p_board->box[col + i][row + j].IsPressed = FALSE;
 636         PressBox( p_board, col + i, row + j );
 637     }
 638
 639     p_board->press.x = col;
 640     p_board->press.y = row;
 641 }
 642
 643
 644 static void CompleteBox( BOARD *p_board, unsigned col, unsigned row )
 645 {
 646     int i, j;
 647
 648     if( p_board->box[col][row].FlagType != COMPLETE &&
 649             p_board->box[col][row].FlagType != FLAG &&
 650             col > 0 && col < p_board->cols + 1 &&
 651             row > 0 && row < p_board->rows + 1 ) {
 652         p_board->box[col][row].FlagType = COMPLETE;
 653
 654         if( p_board->box[col][row].IsMine ) {
 655             p_board->face_bmp = DEAD_BMP;
 656             p_board->status = GAMEOVER;
 657         }
 658         else if( p_board->status != GAMEOVER )
 659             p_board->boxes_left--;
 660
 661         if( p_board->box[col][row].NumMines == 0 )
 662         {
 663             for( i = -1; i <= 1; i++ )
 664             for( j = -1; j <= 1; j++ )
 665                 CompleteBox( p_board, col + i, row + j  );
 666         }
 667     }
 668 }
 669
 670
 671 static void CompleteBoxes( BOARD *p_board, unsigned col, unsigned row )
 672 {
 673     unsigned numFlags = 0;
 674     int i, j;
 675
 676     if( p_board->box[col][row].FlagType == COMPLETE ) {
 677         for( i = -1; i <= 1; i++ )
 678           for( j = -1; j <= 1; j++ ) {
 679             if( p_board->box[col+i][row+j].FlagType == FLAG )
 680                 numFlags++;
 681           }
 682
 683         if( numFlags == p_board->box[col][row].NumMines ) {
 684             for( i = -1; i <= 1; i++ )
 685               for( j = -1; j <= 1; j++ ) {
 686                 if( p_board->box[col+i][row+j].FlagType != FLAG )
 687                     CompleteBox( p_board, col+i, row+j );
 688               }
 689         }
 690     }
 691 }
 692
 693
 694 static void TestMines( BOARD *p_board, POINT pt, int msg )
 695 {
 696     BOOL draw = TRUE;
 697     int col, row;
 698
 699     col = (pt.x - p_board->mines_rect.left) / MINE_WIDTH + 1;
 700     row = (pt.y - p_board->mines_rect.top ) / MINE_HEIGHT + 1;
 701
 702     switch ( msg ) {
 703     case WM_LBUTTONDOWN:
 704         if( p_board->press.x != col || p_board->press.y != row ) {
 705             UnpressBox( p_board,
 706                     p_board->press.x, p_board->press.y );
 707             p_board->press.x = col;
 708             p_board->press.y = row;
 709             PressBox( p_board, col, row );
 710         }
 711         draw = FALSE;
 712         break;
 713
 714     case WM_LBUTTONUP:
 715         if( p_board->press.x != col || p_board->press.y != row )
 716             UnpressBox( p_board,
 717                     p_board->press.x, p_board->press.y );
 718         p_board->press.x = 0;
 719         p_board->press.y = 0;
 720         if( p_board->box[col][row].FlagType != FLAG
 721             && p_board->status != PLAYING )
 722         {
 723             p_board->status = PLAYING;
 724             PlaceMines( p_board, col, row );
 725         }
 726         CompleteBox( p_board, col, row );
 727         break;
 728
 729     case WM_MBUTTONDOWN:
 730         PressBoxes( p_board, col, row );
 731         draw = FALSE;
 732         break;
 733
 734     case WM_MBUTTONUP:
 735         if( p_board->press.x != col || p_board->press.y != row )
 736             UnpressBoxes( p_board,
 737                     p_board->press.x, p_board->press.y );
 738         p_board->press.x = 0;
 739         p_board->press.y = 0;
 740         CompleteBoxes( p_board, col, row );
 741         break;
 742
 743     case WM_RBUTTONDOWN:
 744         AddFlag( p_board, col, row );
 745         break;
 746
 747     case WM_RBUTTONUP:
 748         return;
 749     }
 750
 751     if( draw )
 752     {
 753         RedrawWindow( p_board->hWnd, NULL, 0,
 754             RDW_INVALIDATE | RDW_UPDATENOW );
 755     }
 756 }
 757
 758
 759 static void TestFace( BOARD *p_board, POINT pt, int msg )
 760 {
 761     if( p_board->status == PLAYING || p_board->status == WAITING ) {
 762         if( msg == WM_LBUTTONDOWN || msg == WM_MBUTTONDOWN )
 763             p_board->face_bmp = OOH_BMP;
 764         else p_board->face_bmp = SMILE_BMP;
 765     }
 766     else if( p_board->status == GAMEOVER )
 767         p_board->face_bmp = DEAD_BMP;
 768     else if( p_board->status == WON )
 769             p_board->face_bmp = COOL_BMP;
 770
 771     if( PtInRect( &p_board->face_rect, pt ) ) {
 772         if( msg == WM_LBUTTONDOWN )
 773             p_board->face_bmp = SPRESS_BMP;
 774
 775         if( msg == WM_LBUTTONUP )
 776             CreateBoard( p_board );
 777     }
 778
 779     RedrawWindow( p_board->hWnd, &p_board->face_rect, 0,
 780         RDW_INVALIDATE | RDW_UPDATENOW );
 781 }
 782
 783
 784 static void TestBoard( HWND hWnd, BOARD *p_board, int x, int y, int msg )
 785 {
 786     POINT pt;
 787     unsigned col,row;
 788
 789     pt.x = x;
 790     pt.y = y;
 791
 792     if( PtInRect( &p_board->mines_rect, pt ) && p_board->status != GAMEOVER
 793     && p_board->status != WON )
 794         TestMines( p_board, pt, msg );
 795     else {
 796         UnpressBoxes( p_board,
 797             p_board->press.x,
 798             p_board->press.y );
 799         p_board->press.x = 0;
 800         p_board->press.y = 0;
 801     }
 802
 803     if( p_board->boxes_left == 0 && p_board->status != WON ) {
 804         p_board->status = WON;
 805
 806         if (p_board->num_flags < p_board->mines) {
 807             for( row = 1; row <= p_board->rows; row++ ) {
 808                 for( col = 1; col <= p_board->cols; col++ ) {
 809                     if (p_board->box[col][row].IsMine && p_board->box[col][row].FlagType != FLAG)
 810                         p_board->box[col][row].FlagType = FLAG;
 811                 }
 812             }
 813
 814             p_board->num_flags = p_board->mines;
 815
 816             RedrawWindow( p_board->hWnd, NULL, 0,
 817                 RDW_INVALIDATE | RDW_UPDATENOW );
 818         }
 819
 820         if( p_board->difficulty != CUSTOM &&
 821                     p_board->time < p_board->best_time[p_board->difficulty] ) {
 822             p_board->best_time[p_board->difficulty] = p_board->time;
 823
 824             DialogBoxParamW( p_board->hInst, MAKEINTRESOURCEW(DLG_CONGRATS), hWnd,
 825                              CongratsDlgProc, (LPARAM) p_board);
 826             SaveBoard( p_board );
 827             DialogBoxParamW( p_board->hInst, MAKEINTRESOURCEW(DLG_TIMES), hWnd,
 828                              TimesDlgProc, (LPARAM) p_board);
 829         }
 830     }
 831     TestFace( p_board, pt, msg );
 832 }
 833
 834
 835 static LRESULT WINAPI MainProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 836 {
 837     HDC hdc;
 838     PAINTSTRUCT ps;
 839     HMENU hMenu;
 840     static BOARD board;
 841
 842     switch( msg ) {
 843     case WM_CREATE:
 844         board.hInst = ((LPCREATESTRUCTW) lParam)->hInstance;
 845         board.hWnd = hWnd;
 846         InitBoard( &board );
 847         CreateBoard( &board );
 848         return 0;
 849
 850     case WM_PAINT:
 851       {
 852         HDC hMemDC;
 853
 854         WINE_TRACE("WM_PAINT\n");
 855         hdc = BeginPaint( hWnd, &ps );
 856         hMemDC = CreateCompatibleDC( hdc );
 857
 858         DrawBoard( hdc, hMemDC, &ps, &board );
 859
 860         DeleteDC( hMemDC );
 861         EndPaint( hWnd, &ps );
 862
 863         return 0;
 864       }
 865
 866     case WM_MOVE:
 867         WINE_TRACE("WM_MOVE\n");
 868         board.pos.x = (short)LOWORD(lParam);
 869         board.pos.y = (short)HIWORD(lParam);
 870         return 0;
 871
 872     case WM_DESTROY:
 873         SaveBoard( &board );
 874         DestroyBoard( &board );
 875         PostQuitMessage( 0 );
 876         return 0;
 877
 878     case WM_TIMER:
 879         if( board.status == PLAYING ) {
 880             board.time++;
 881             RedrawWindow( hWnd, &board.timer_rect, 0,
 882                           RDW_INVALIDATE | RDW_UPDATENOW );
 883         }
 884         return 0;
 885
 886     case WM_LBUTTONDOWN:
 887         WINE_TRACE("WM_LBUTTONDOWN\n");
 888         if( wParam & ( MK_RBUTTON | MK_SHIFT ) )
 889             msg = WM_MBUTTONDOWN;
 890         TestBoard( hWnd, &board, (short)LOWORD(lParam), (short)HIWORD(lParam), msg );
 891         SetCapture( hWnd );
 892         return 0;
 893
 894     case WM_LBUTTONUP:
 895         WINE_TRACE("WM_LBUTTONUP\n");
 896         if( wParam & ( MK_RBUTTON | MK_SHIFT ) )
 897             msg = WM_MBUTTONUP;
 898         TestBoard( hWnd, &board, (short)LOWORD(lParam), (short)HIWORD(lParam), msg );
 899         ReleaseCapture();
 900         return 0;
 901
 902     case WM_RBUTTONDOWN:
 903         WINE_TRACE("WM_RBUTTONDOWN\n");
 904         if( wParam & MK_LBUTTON ) {
 905             board.press.x = 0;
 906             board.press.y = 0;
 907             msg = WM_MBUTTONDOWN;
 908         }
 909         TestBoard( hWnd, &board, (short)LOWORD(lParam), (short)HIWORD(lParam), msg );
 910         return 0;
 911
 912     case WM_RBUTTONUP:
 913         WINE_TRACE("WM_RBUTTONUP\n");
 914         if( wParam & MK_LBUTTON )
 915             msg = WM_MBUTTONUP;
 916         TestBoard( hWnd, &board, (short)LOWORD(lParam), (short)HIWORD(lParam), msg );
 917         return 0;
 918
 919     case WM_MBUTTONDOWN:
 920         WINE_TRACE("WM_MBUTTONDOWN\n");
 921         TestBoard( hWnd, &board, (short)LOWORD(lParam), (short)HIWORD(lParam), msg );
 922         return 0;
 923
 924     case WM_MBUTTONUP:
 925         WINE_TRACE("WM_MBUTTONUP\n");
 926         TestBoard( hWnd, &board, (short)LOWORD(lParam), (short)HIWORD(lParam), msg );
 927         return 0;
 928
 929     case WM_MOUSEMOVE:
 930     {
 931         if( ( wParam & MK_MBUTTON ) ||
 932             ( ( wParam & MK_LBUTTON ) && ( wParam & MK_RBUTTON ) ) ) {
 933             msg = WM_MBUTTONDOWN;
 934         }
 935         else if( wParam & MK_LBUTTON ) {
 936             msg = WM_LBUTTONDOWN;
 937         }
 938         else {
 939             return 0;
 940         }
 941
 942         TestBoard( hWnd, &board, (short)LOWORD(lParam), (short)HIWORD(lParam),  msg );
 943
 944         return 0;
 945     }
 946
 947     case WM_COMMAND:
 948         switch(LOWORD(wParam)) {
 949         case IDM_NEW:
 950             CreateBoard( &board );
 951             return 0;
 952
 953         case IDM_MARKQ:
 954             hMenu = GetMenu( hWnd );
 955             board.IsMarkQ = !board.IsMarkQ;
 956             if( board.IsMarkQ )
 957                 CheckMenuItem( hMenu, IDM_MARKQ, MF_CHECKED );
 958             else
 959                 CheckMenuItem( hMenu, IDM_MARKQ, MF_UNCHECKED );
 960             return 0;
 961
 962         case IDM_BEGINNER:
 963             SetDifficulty( &board, BEGINNER );
 964             CreateBoard( &board );
 965             return 0;
 966
 967         case IDM_ADVANCED:
 968             SetDifficulty( &board, ADVANCED );
 969             CreateBoard( &board );
 970             return 0;
 971
 972         case IDM_EXPERT:
 973             SetDifficulty( &board, EXPERT );
 974             CreateBoard( &board );
 975             return 0;
 976
 977         case IDM_CUSTOM:
 978             SetDifficulty( &board, CUSTOM );
 979             CreateBoard( &board );
 980             return 0;
 981
 982         case IDM_EXIT:
 983             SendMessageW( hWnd, WM_CLOSE, 0, 0);
 984             return 0;
 985
 986         case IDM_TIMES:
 987             DialogBoxParamW( board.hInst, MAKEINTRESOURCEW(DLG_TIMES), hWnd,
 988                              TimesDlgProc, (LPARAM) &board);
 989             return 0;
 990
 991         case IDM_ABOUT:
 992         {
 993             WCHAR appname[256], other[256];
 994             LoadStringW( board.hInst, IDS_APPNAME, appname, ARRAY_SIZE(appname));
 995             LoadStringW( board.hInst, IDS_ABOUT, other, ARRAY_SIZE(other));
 996             ShellAboutW( hWnd, appname, other,
 997                          LoadImageW(board.hInst, MAKEINTRESOURCEW(IDI_WINEMINE), IMAGE_ICON, 48, 48, LR_SHARED));
 998             return 0;
 999         }
1000         default:
1001             WINE_TRACE("Unknown WM_COMMAND command message received\n");
1002             break;
1003         }
1004     }
1005     return DefWindowProcW( hWnd, msg, wParam, lParam );
1006 }
1007
1008 int WINAPI wWinMain( HINSTANCE hInst, HINSTANCE hPrevInst, LPWSTR cmdline, int cmdshow )
1009 {
1010     MSG msg;
1011     WNDCLASSEXW wc;
1012     HWND hWnd;
1013     HACCEL haccel;
1014     WCHAR appname[20];
1015
1016     InitCommonControls();
1017
1018     LoadStringW( hInst, IDS_APPNAME, appname, ARRAY_SIZE(appname));
1019
1020     wc.cbSize = sizeof(wc);
1021     wc.style = 0;
1022     wc.lpfnWndProc = MainProc;
1023     wc.cbClsExtra = 0;
1024     wc.cbWndExtra = 0;
1025     wc.hInstance = hInst;
1026     wc.hIcon = LoadIconW( hInst, MAKEINTRESOURCEW(IDI_WINEMINE) );
1027     wc.hCursor = LoadCursorW( 0, (LPWSTR)IDI_APPLICATION );
1028     wc.hbrBackground = GetStockObject( BLACK_BRUSH );
1029     wc.lpszMenuName = MAKEINTRESOURCEW(IDM_WINEMINE);
1030     wc.lpszClassName = appname;
1031     wc.hIconSm = LoadImageW( hInst, MAKEINTRESOURCEW(IDI_WINEMINE), IMAGE_ICON,
1032                             GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_SHARED );
1033
1034     if (!RegisterClassExW(&wc)) ExitProcess(1);
1035     hWnd = CreateWindowW( appname, appname,
1036         wnd_style,
1037         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1038         0, 0, hInst, NULL );
1039
1040     if (!hWnd) ExitProcess(1);
1041
1042     ShowWindow( hWnd, cmdshow );
1043     UpdateWindow( hWnd );
1044
1045     haccel = LoadAcceleratorsW( hInst, MAKEINTRESOURCEW(IDA_WINEMINE) );
1046     SetTimer( hWnd, ID_TIMER, 1000, NULL );
1047
1048     while( GetMessageW(&msg, 0, 0, 0) ) {
1049         if (!TranslateAcceleratorW( hWnd, haccel, &msg ))
1050             TranslateMessage( &msg );
1051
1052         DispatchMessageW( &msg );
1053     }
1054     return msg.wParam;
1055 }