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