apps/plugins/minesweeper.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2004-2006 Antoine Cellerier <dionoea -at- videolan -dot- org>
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include "plugin.h"
  21
  22 #ifdef HAVE_LCD_BITMAP
  23
  24 PLUGIN_HEADER
  25
  26 /* what the minesweeper() function can return */
  27 enum minesweeper_status {
  28     MINESWEEPER_WIN,
  29     MINESWEEPER_LOSE,
  30     MINESWEEPER_QUIT,
  31     MINESWEEPER_USB
  32 };
  33
  34 /* variable button definitions */
  35 #if CONFIG_KEYPAD == RECORDER_PAD
  36 #   define MINESWP_UP       BUTTON_UP
  37 #   define MINESWP_DOWN     BUTTON_DOWN
  38 #   define MINESWP_QUIT     BUTTON_OFF
  39 #   define MINESWP_TOGGLE   BUTTON_ON
  40 #   define MINESWP_TOGGLE2  BUTTON_F1
  41 #   define MINESWP_DISCOVER BUTTON_PLAY
  42 #   define MINESWP_DISCOVER2 BUTTON_F2
  43 #   define MINESWP_INFO     BUTTON_F3
  44
  45 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
  46 #   define MINESWP_UP       BUTTON_UP
  47 #   define MINESWP_DOWN     BUTTON_DOWN
  48 #   define MINESWP_QUIT     BUTTON_OFF
  49 #   define MINESWP_TOGGLE   BUTTON_ON
  50 #   define MINESWP_TOGGLE2  BUTTON_F1
  51 #   define MINESWP_DISCOVER BUTTON_SELECT
  52 #   define MINESWP_DISCOVER2 BUTTON_F2
  53 #   define MINESWP_INFO     BUTTON_F3
  54
  55 #elif CONFIG_KEYPAD == ONDIO_PAD
  56 #   define MINESWP_UP       BUTTON_UP
  57 #   define MINESWP_DOWN     BUTTON_DOWN
  58 #   define MINESWP_QUIT     BUTTON_OFF
  59 #   define MINESWP_TOGGLE_PRE BUTTON_MENU
  60 #   define MINESWP_TOGGLE   (BUTTON_MENU | BUTTON_REL)
  61 #   define MINESWP_DISCOVER (BUTTON_MENU | BUTTON_REPEAT)
  62 #   define MINESWP_INFO     (BUTTON_MENU | BUTTON_OFF)
  63
  64 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
  65       (CONFIG_KEYPAD == IRIVER_H300_PAD)
  66 #   define MINESWP_UP       BUTTON_UP
  67 #   define MINESWP_DOWN     BUTTON_DOWN
  68 #   define MINESWP_QUIT     BUTTON_OFF
  69 #   define MINESWP_TOGGLE   BUTTON_ON
  70 #   define MINESWP_TOGGLE2  BUTTON_REC
  71 #   define MINESWP_DISCOVER BUTTON_SELECT
  72 #   define MINESWP_INFO     BUTTON_MODE
  73
  74 #   define MINESWP_RC_QUIT  BUTTON_RC_STOP
  75
  76 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
  77       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
  78       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
  79 #   define MINESWP_SCROLLWHEEL
  80 #   define MINESWP_UP         BUTTON_MENU
  81 #   define MINESWP_DOWN       BUTTON_PLAY
  82 #   define MINESWP_NEXT       BUTTON_SCROLL_FWD
  83 #   define MINESWP_PREV       BUTTON_SCROLL_BACK
  84 #   define MINESWP_QUIT       (BUTTON_SELECT | BUTTON_MENU)
  85 #   define MINESWP_TOGGLE_PRE BUTTON_SELECT
  86 #   define MINESWP_TOGGLE     (BUTTON_SELECT | BUTTON_REL)
  87 #   define MINESWP_DISCOVER   (BUTTON_SELECT | BUTTON_REPEAT)
  88 #   define MINESWP_INFO       (BUTTON_SELECT | BUTTON_PLAY)
  89
  90 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
  91 #   define MINESWP_UP         BUTTON_UP
  92 #   define MINESWP_DOWN       BUTTON_DOWN
  93 #   define MINESWP_QUIT       BUTTON_POWER
  94 #   define MINESWP_TOGGLE     BUTTON_PLAY
  95 #   define MINESWP_DISCOVER   BUTTON_SELECT
  96 #   define MINESWP_INFO       BUTTON_REC
  97
  98 #elif (CONFIG_KEYPAD == GIGABEAT_PAD)
  99 #   define MINESWP_UP       BUTTON_UP
 100 #   define MINESWP_DOWN     BUTTON_DOWN
 101 #   define MINESWP_QUIT     BUTTON_POWER
 102 #   define MINESWP_TOGGLE   BUTTON_A
 103 #   define MINESWP_DISCOVER BUTTON_SELECT
 104 #   define MINESWP_INFO     BUTTON_MENU
 105
 106 #elif (CONFIG_KEYPAD == SANSA_E200_PAD)
 107 #   define MINESWP_SCROLLWHEEL
 108 #   define MINESWP_UP       BUTTON_UP
 109 #   define MINESWP_DOWN     BUTTON_DOWN
 110 #   define MINESWP_QUIT     BUTTON_POWER
 111 #   define MINESWP_NEXT     BUTTON_SCROLL_FWD
 112 #   define MINESWP_PREV     BUTTON_SCROLL_BACK
 113 #   define MINESWP_TOGGLE   BUTTON_REC
 114 #   define MINESWP_DISCOVER BUTTON_SELECT
 115 #   define MINESWP_INFO     (BUTTON_REC|BUTTON_REPEAT)
 116
 117 #elif (CONFIG_KEYPAD == SANSA_C200_PAD)
 118 #   define MINESWP_UP         BUTTON_UP
 119 #   define MINESWP_DOWN       BUTTON_DOWN
 120 #   define MINESWP_QUIT       BUTTON_POWER
 121 #   define MINESWP_TOGGLE_PRE BUTTON_SELECT
 122 #   define MINESWP_TOGGLE     (BUTTON_SELECT | BUTTON_REL)
 123 #   define MINESWP_TOGGLE2    BUTTON_VOL_DOWN
 124 #   define MINESWP_DISCOVER   (BUTTON_SELECT | BUTTON_REPEAT)
 125 #   define MINESWP_DISCOVER2  BUTTON_VOL_UP
 126 #   define MINESWP_INFO       BUTTON_REC
 127
 128 #elif (CONFIG_KEYPAD == IRIVER_H10_PAD)
 129 #   define MINESWP_UP       BUTTON_SCROLL_UP
 130 #   define MINESWP_DOWN     BUTTON_SCROLL_DOWN
 131 #   define MINESWP_QUIT     BUTTON_POWER
 132 #   define MINESWP_TOGGLE   BUTTON_PLAY
 133 #   define MINESWP_DISCOVER BUTTON_REW
 134 #   define MINESWP_INFO     (BUTTON_REW | BUTTON_PLAY)
 135
 136 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD)
 137 #   define MINESWP_UP       BUTTON_UP
 138 #   define MINESWP_DOWN     BUTTON_DOWN
 139 #   define MINESWP_QUIT     BUTTON_BACK
 140 #   define MINESWP_TOGGLE   BUTTON_PLAY
 141 #   define MINESWP_DISCOVER BUTTON_SELECT
 142 #   define MINESWP_INFO     BUTTON_MENU
 143
 144 #elif (CONFIG_KEYPAD == MROBE100_PAD)
 145 #   define MINESWP_UP       BUTTON_UP
 146 #   define MINESWP_DOWN     BUTTON_DOWN
 147 #   define MINESWP_QUIT     BUTTON_POWER
 148 #   define MINESWP_TOGGLE   BUTTON_DISPLAY
 149 #   define MINESWP_DISCOVER BUTTON_SELECT
 150 #   define MINESWP_INFO     BUTTON_MENU
 151
 152 #else
 153 #error No keymap defined!
 154 #endif
 155
 156 /* here is a global api struct pointer. while not strictly necessary,
 157  * it's nice not to have to pass the api pointer in all function calls
 158  * in the plugin
 159  */
 160 static struct plugin_api *rb;
 161
 162 extern const fb_data minesweeper_tiles[];
 163
 164 #ifdef HAVE_LCD_COLOR
 165 #   if ( LCD_HEIGHT * LCD_WIDTH ) / ( 16 * 16 ) >= 130
 166         /* We want to have at least 130 tiles on the screen */
 167 #       define TileSize 16
 168 #   elif ( LCD_HEIGHT * LCD_WIDTH ) / ( 12 * 12 ) >= 130
 169 #       define TileSize 12
 170 #   else
 171 #       define TileSize 10
 172 #   endif
 173 #   define BackgroundColor LCD_RGBPACK( 128, 128, 128 )
 174 #elif LCD_DEPTH > 1
 175 #   define TileSize 12
 176 #else
 177 #   define TileSize 8
 178 #endif
 179
 180 #define Mine         9
 181 #define Flag         10
 182 #define Unknown      11
 183 #define ExplodedMine 12
 184
 185 #define draw_tile( num, x, y ) \
 186     rb->lcd_bitmap_part( minesweeper_tiles, 0, num * TileSize, \
 187                          TileSize, left+x*TileSize, top+y*TileSize, \
 188                          TileSize, TileSize )
 189
 190 #define invert_tile( x, y ) \
 191     rb->lcd_set_drawmode(DRMODE_COMPLEMENT); \
 192     rb->lcd_fillrect( left+x*TileSize, top+y*TileSize, TileSize, TileSize ); \
 193     rb->lcd_set_drawmode(DRMODE_SOLID);
 194
 195
 196 /* the tile struct
 197  * if there is a mine, mine is true
 198  * if tile is known by player, known is true
 199  * if tile has a flag, flag is true
 200  * neighbors is the total number of mines arround tile
 201  */
 202 typedef struct tile
 203 {
 204     unsigned char mine : 1;
 205     unsigned char known : 1;
 206     unsigned char flag : 1;
 207     unsigned char neighbors : 4;
 208 } tile;
 209
 210 /* the height and width of the field */
 211 #define MAX_HEIGHT (LCD_HEIGHT/TileSize)
 212 #define MAX_WIDTH  (LCD_WIDTH/TileSize)
 213 int height = MAX_HEIGHT;
 214 int width = MAX_WIDTH;
 215 int top;
 216 int left;
 217
 218 /* The Minefield. Caution it is defined as Y, X! Not the opposite. */
 219 tile minefield[MAX_HEIGHT][MAX_WIDTH];
 220
 221 /* total number of mines on the game */
 222 int mine_num = 0;
 223
 224 /* percentage of mines on minefield used during generation */
 225 int p = 16;
 226
 227 /* number of tiles left on the game */
 228 int tiles_left;
 229
 230 /* number of used flags on the game */
 231 int flags_used;
 232
 233 /* Because mines are set after the first move... */
 234 bool no_mines = true;
 235
 236 /* We need a stack (created on discover()) for the cascade algorithm. */
 237 int stack_pos = 0;
 238
 239 /* a usefull string for snprintf */
 240 char str[30];
 241
 242
 243 void push( int *stack, int y, int x )
 244 {
 245     if( stack_pos <= height*width )
 246     {
 247         stack[++stack_pos] = y;
 248         stack[++stack_pos] = x;
 249     }
 250 }
 251
 252 /* Unveil tiles and push them to stack if they are empty. */
 253 void unveil( int *stack, int y, int x )
 254 {
 255     if( x < 0 || y < 0 || x > width - 1 || y > height - 1
 256        || minefield[y][x].known
 257        || minefield[y][x].mine || minefield[y][x].flag ) return;
 258
 259     minefield[y][x].known = 1;
 260
 261     if( minefield[y][x].neighbors == 0 )
 262         push( stack, y, x );
 263 }
 264
 265 void discover( int y, int x )
 266 {
 267     int stack[height*width];
 268
 269     /* Selected tile. */
 270     if( x < 0 || y < 0 || x > width - 1 || y > height - 1
 271        || minefield[y][x].known
 272        || minefield[y][x].mine || minefield[y][x].flag ) return;
 273
 274     minefield[y][x].known = 1;
 275     /* Exit if the tile is not empty. (no mines nearby) */
 276     if( minefield[y][x].neighbors ) return;
 277
 278     push( stack, y, x );
 279
 280     /* Scan all nearby tiles. If we meet a tile with a number we just unveil
 281      * it. If we meet an empty tile, we push the location in stack. For each
 282      * location in stack we do the same thing. (scan again all nearby tiles)
 283      */
 284     while( stack_pos )
 285     {
 286         /* Pop x, y from stack. */
 287         x = stack[stack_pos--];
 288         y = stack[stack_pos--];
 289
 290         unveil( stack, y-1, x-1 );
 291         unveil( stack, y-1, x   );
 292         unveil( stack, y-1, x+1 );
 293         unveil( stack, y,   x+1 );
 294         unveil( stack, y+1, x+1 );
 295         unveil( stack, y+1, x   );
 296         unveil( stack, y+1, x-1 );
 297         unveil( stack, y,   x-1 );
 298     }
 299 }
 300
 301 /* Reset the whole board for a new game. */
 302 void minesweeper_init( void )
 303 {
 304     int i,j;
 305
 306     for( i = 0; i < MAX_HEIGHT; i++ )
 307     {
 308         for( j = 0; j < MAX_WIDTH; j++ )
 309         {
 310             minefield[i][j].known = 0;
 311             minefield[i][j].flag = 0;
 312             minefield[i][j].mine = 0;
 313             minefield[i][j].neighbors = 0;
 314         }
 315     }
 316     no_mines = true;
 317     tiles_left = width*height;
 318 }
 319
 320
 321 /* put mines on the mine field */
 322 /* there is p% chance that a tile is a mine */
 323 /* if the tile has coordinates (x,y), then it can't be a mine */
 324 void minesweeper_putmines( int p, int x, int y )
 325 {
 326     int i,j;
 327
 328     mine_num = 0;
 329     for( i = 0; i < height; i++ )
 330     {
 331         for( j = 0; j < width; j++ )
 332         {
 333             if( rb->rand()%100 < p && !( y==i && x==j ) )
 334             {
 335                 minefield[i][j].mine = 1;
 336                 mine_num++;
 337             }
 338             else
 339             {
 340                 minefield[i][j].mine = 0;
 341             }
 342             minefield[i][j].neighbors = 0;
 343         }
 344     }
 345
 346     /* we need to compute the neighbor element for each tile */
 347     for( i = 0; i < height; i++ )
 348     {
 349         for( j = 0; j < width; j++ )
 350         {
 351             if( i > 0 )
 352             {
 353                 if( j > 0 )
 354                     minefield[i][j].neighbors += minefield[i-1][j-1].mine;
 355                 minefield[i][j].neighbors += minefield[i-1][j].mine;
 356                 if( j < width - 1 )
 357                     minefield[i][j].neighbors += minefield[i-1][j+1].mine;
 358             }
 359             if( j > 0 )
 360                 minefield[i][j].neighbors += minefield[i][j-1].mine;
 361             if( j < width - 1 )
 362                 minefield[i][j].neighbors += minefield[i][j+1].mine;
 363             if( i < height - 1 )
 364             {
 365                 if( j > 0 )
 366                     minefield[i][j].neighbors += minefield[i+1][j-1].mine;
 367                 minefield[i][j].neighbors += minefield[i+1][j].mine;
 368                 if( j < width - 1 )
 369                     minefield[i][j].neighbors += minefield[i+1][j+1].mine;
 370             }
 371         }
 372     }
 373
 374     no_mines = false;
 375
 376     /* In case the user is lucky and there are no mines positioned. */
 377     if( !mine_num && height*width != 1 )
 378     {
 379         minesweeper_putmines(p, x, y);
 380     }
 381 }
 382
 383 /* A function that will uncover all the board, when the user wins or loses.
 384    can easily be expanded, (just a call assigned to a button) as a solver. */
 385 void mine_show( void )
 386 {
 387     int i, j, button;
 388
 389     for( i = 0; i < height; i++ )
 390     {
 391         for( j = 0; j < width; j++ )
 392         {
 393             if( minefield[i][j].mine )
 394             {
 395                 if( minefield[i][j].known )
 396                 {
 397                     draw_tile( ExplodedMine, j, i );
 398                 }
 399                 else
 400                 {
 401                     draw_tile( Mine, j, i );
 402                 }
 403             }
 404             else
 405             {
 406                 draw_tile( minefield[i][j].neighbors, j, i );
 407             }
 408         }
 409     }
 410     rb->lcd_update();
 411
 412     do
 413         button = rb->button_get(true);
 414     while( ( button == BUTTON_NONE )
 415            || ( button & (BUTTON_REL|BUTTON_REPEAT) ) );
 416 }
 417
 418 int count_tiles_left( void )
 419 {
 420     int tiles_left = 0;
 421     int i, j;
 422     for( i = 0; i < height; i++ )
 423         for( j = 0; j < width; j++ )
 424              if( minefield[i][j].known == 0 )
 425                 tiles_left++;
 426     return tiles_left;
 427 }
 428
 429 int count_flags( void )
 430 {
 431     int flags_used = 0;
 432     int i, j;
 433     for( i = 0; i < height; i++ )
 434         for( j = 0; j < width; j++ )
 435              if( minefield[i][j].flag == 1 )
 436                 flags_used++;
 437     return flags_used;
 438 }
 439
 440 /* welcome screen where player can chose mine percentage */
 441 enum minesweeper_status menu( void )
 442 {
 443     int selection, result = MINESWEEPER_QUIT;
 444     bool menu_quit = false;
 445
 446     MENUITEM_STRINGLIST( menu, "Minesweeper Menu", NULL, "Play Minesweeper",
 447                          "Mine Percentage", "Number of Rows",
 448                          "Number of Columns", "Quit" );
 449
 450 #ifdef HAVE_LCD_COLOR
 451     rb->lcd_set_foreground( rb->global_settings->fg_color );
 452     rb->lcd_set_background( rb->global_settings->bg_color );
 453 #endif
 454
 455     while( !menu_quit )
 456     {
 457         switch( rb->do_menu( &menu, &selection ) )
 458         {
 459             case 0:
 460                 result = MINESWEEPER_WIN; /* start playing */
 461                 menu_quit = true;
 462                 break;
 463
 464             case 1:
 465                 rb->set_int( "Mine Percentage", "%", UNIT_INT, &p, NULL,
 466                              1, 2, 98, NULL );
 467                 break;
 468
 469             case 2:
 470                 rb->set_int( "Number of Rows", "", UNIT_INT, &height, NULL,
 471                              1, 1, MAX_HEIGHT, NULL );
 472                 break;
 473
 474             case 3:
 475                 rb->set_int( "Number of Columns", "", UNIT_INT, &width, NULL,
 476                              1, 1, MAX_WIDTH, NULL );
 477                 break;
 478
 479             default:
 480                 result = MINESWEEPER_QUIT; /* quit program */
 481                 menu_quit = true;
 482                 break;
 483         }
 484     }
 485
 486     return result;
 487 }
 488
 489 /* the big and ugly game function */
 490 enum minesweeper_status minesweeper( void )
 491 {
 492     int i, j;
 493     int button;
 494     int lastbutton = BUTTON_NONE;
 495
 496     /* the cursor coordinates */
 497     int x=0, y=0;
 498
 499     /**
 500      * Show the menu
 501      */
 502     if( ( i = menu() ) != MINESWEEPER_WIN ) return i;
 503
 504     /**
 505      * Init game
 506      */
 507     top = (LCD_HEIGHT-height*TileSize)/2;
 508     left = (LCD_WIDTH-width*TileSize)/2;
 509
 510     rb->srand( *rb->current_tick );
 511     minesweeper_init();
 512     x = 0;
 513     y = 0;
 514
 515     /**
 516      * Play
 517      */
 518     while( true )
 519     {
 520
 521         /* clear the screen buffer */
 522 #ifdef HAVE_LCD_COLOR
 523         rb->lcd_set_background( BackgroundColor );
 524 #endif
 525         rb->lcd_clear_display();
 526
 527         /* display the mine field */
 528         for( i = 0; i < height; i++ )
 529         {
 530             for( j = 0; j < width; j++ )
 531             {
 532                 if( minefield[i][j].known )
 533                 {
 534                     draw_tile( minefield[i][j].neighbors, j, i );
 535                 }
 536                 else if(minefield[i][j].flag)
 537                 {
 538                     draw_tile( Flag, j, i );
 539                 }
 540                 else
 541                 {
 542                     draw_tile( Unknown, j, i );
 543                 }
 544             }
 545         }
 546
 547         /* display the cursor */
 548         invert_tile( x, y );
 549
 550         /* update the screen */
 551         rb->lcd_update();
 552
 553         switch( button = rb->button_get( true ) )
 554         {
 555             /* quit minesweeper (you really shouldn't use this button ...) */
 556 #ifdef MINESWP_RC_QUIT
 557             case MINESWP_RC_QUIT:
 558 #endif
 559             case MINESWP_QUIT:
 560                 return MINESWEEPER_QUIT;
 561
 562             /* move cursor left */
 563             case BUTTON_LEFT:
 564             case BUTTON_LEFT|BUTTON_REPEAT:
 565                 x = ( x + width - 1 )%width;
 566                 break;
 567
 568             /* move cursor right */
 569             case BUTTON_RIGHT:
 570             case BUTTON_RIGHT|BUTTON_REPEAT:
 571                 x = ( x + 1 )%width;
 572                 break;
 573
 574             /* move cursor down */
 575             case MINESWP_DOWN:
 576             case MINESWP_DOWN|BUTTON_REPEAT:
 577                 y = ( y + 1 )%height;
 578                 break;
 579
 580             /* move cursor up */
 581             case MINESWP_UP:
 582             case MINESWP_UP|BUTTON_REPEAT:
 583                 y = ( y + height - 1 )%height;
 584                 break;
 585
 586             /*move cursor though the entire field*/
 587 #ifdef MINESWP_SCROLLWHEEL
 588             case MINESWP_NEXT:
 589             case MINESWP_NEXT|BUTTON_REPEAT:
 590                 if (x == width -1 ) {
 591                     y = ( y + 1 )%height;
 592                 }
 593                 x = ( x + 1 )%width;
 594                 break;
 595
 596             case MINESWP_PREV:
 597             case MINESWP_PREV|BUTTON_REPEAT:
 598                 if (x == 0) {
 599                     y = ( y + height - 1 )%height;
 600                 }
 601                 x = ( x + width - 1 )%width;
 602                 break;
 603 #endif
 604             /* discover a tile (and it's neighbors if .neighbors == 0) */
 605             case MINESWP_DISCOVER:
 606 #ifdef MINESWP_DISCOVER2
 607             case MINESWP_DISCOVER2:
 608 #endif
 609                 if( minefield[y][x].flag ) break;
 610                 /* we put the mines on the first "click" so that you don't
 611                  * lose on the first "click" */
 612                 if( tiles_left == width*height && no_mines )
 613                     minesweeper_putmines(p,x,y);
 614
 615                 discover(y, x);
 616
 617                 if( minefield[y][x].mine )
 618                 {
 619                     minefield[y][x].known = 1;
 620                     return MINESWEEPER_LOSE;
 621                 }
 622                 tiles_left = count_tiles_left();
 623                 if( tiles_left == mine_num )
 624                 {
 625                     return MINESWEEPER_WIN;
 626                 }
 627                 break;
 628
 629             /* toggle flag under cursor */
 630             case MINESWP_TOGGLE:
 631 #ifdef MINESWP_TOGGLE_PRE
 632                 if( lastbutton != MINESWP_TOGGLE_PRE )
 633                     break;
 634 #endif
 635 #ifdef MINESWP_TOGGLE2
 636             case MINESWP_TOGGLE2:
 637 #endif
 638                 minefield[y][x].flag = ( minefield[y][x].flag + 1 )%2;
 639                 break;
 640
 641             /* show how many mines you think you have found and how many
 642              * there really are on the game */
 643             case MINESWP_INFO:
 644                 if( no_mines )
 645                     break;
 646                 flags_used = count_flags();
 647                 if (flags_used == 1) {
 648                     rb->splash( HZ*2, "You marked 1 field. There are %d mines.",
 649                                 mine_num );
 650                 }
 651                 else
 652                 {
 653                     rb->splash( HZ*2, "You marked %d fields. There are %d mines.",
 654                                 flags_used, mine_num );
 655                 }
 656                 break;
 657
 658             default:
 659                 if( rb->default_event_handler( button ) == SYS_USB_CONNECTED )
 660                     return MINESWEEPER_USB;
 661                 break;
 662         }
 663         if( button != BUTTON_NONE )
 664             lastbutton = button;
 665     }
 666
 667 }
 668
 669 /* plugin entry point */
 670 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
 671 {
 672     bool exit = false;
 673
 674     (void)parameter;
 675     rb = api;
 676 #if LCD_DEPTH > 1
 677     rb->lcd_set_backdrop(NULL);
 678 #endif
 679
 680     while( !exit )
 681     {
 682         switch( minesweeper() )
 683         {
 684             case MINESWEEPER_WIN:
 685                 rb->splash( HZ, "You Win!" );
 686                 rb->lcd_clear_display();
 687                 mine_show();
 688                 break;
 689
 690             case MINESWEEPER_LOSE:
 691                 rb->splash( HZ, "You Lose!" );
 692                 rb->lcd_clear_display();
 693                 mine_show();
 694                 break;
 695
 696             case MINESWEEPER_USB:
 697                 return PLUGIN_USB_CONNECTED;
 698
 699             case MINESWEEPER_QUIT:
 700                 exit = true;
 701                 break;
 702
 703             default:
 704                 break;
 705         }
 706     }
 707
 708     return PLUGIN_OK;
 709 }
 710
 711 #endif