apps/plugins/blackjack.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id: $
   9  *
  10  * Copyright (C) 2006 Tom Ross
  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 #include "card_deck.h"
  22 #include "card_back.h"
  23
  24 PLUGIN_HEADER
  25
  26 /* save files */
  27 #define SCORE_FILE PLUGIN_GAMES_DIR "/blackjack.score"
  28 #define SAVE_FILE  PLUGIN_GAMES_DIR "/blackjack.save"
  29
  30 #define NUM_SCORES LCD_HEIGHT/8-2
  31
  32 /* final game return status */
  33 #define BJ_END  3
  34 #define BJ_USB  2
  35 #define BJ_QUIT 1
  36 #define BJ_LOSE 0
  37
  38 #if CONFIG_KEYPAD == RECORDER_PAD
  39 #define BJACK_START      BUTTON_ON
  40 #define BJACK_QUIT       BUTTON_OFF
  41 #define BJACK_MAX        (BUTTON_ON|BUTTON_UP)
  42 #define BJACK_MIN        (BUTTON_ON|BUTTON_DOWN)
  43 #define BJACK_HIT        BUTTON_F1
  44 #define BJACK_STAY       BUTTON_F2
  45 #define BJACK_DOUBLEDOWN BUTTON_F3
  46 #define BJACK_SCORES     BUTTON_RIGHT
  47 #define BJACK_RESUME     BUTTON_PLAY
  48 #define BJACK_UP         BUTTON_UP
  49 #define BJACK_DOWN       BUTTON_DOWN
  50 #define BJACK_RIGHT      BUTTON_RIGHT
  51 #define BJACK_LEFT       BUTTON_LEFT
  52
  53 #elif CONFIG_KEYPAD == ONDIO_PAD
  54 #define BJACK_START      BUTTON_MENU
  55 #define BJACK_QUIT       BUTTON_OFF
  56 #define BJACK_MAX        (BUTTON_MENU|BUTTON_UP)
  57 #define BJACK_MIN        (BUTTON_MENU|BUTTON_DOWN)
  58 #define BJACK_HIT        BUTTON_LEFT
  59 #define BJACK_STAY       BUTTON_RIGHT
  60 #define BJACK_DOUBLEDOWN BUTTON_UP
  61 #define BJACK_SCORES     BUTTON_UP
  62 #define BJACK_RESUME     BUTTON_DOWN
  63 #define BJACK_UP         BUTTON_UP
  64 #define BJACK_DOWN       BUTTON_DOWN
  65 #define BJACK_RIGHT      BUTTON_RIGHT
  66 #define BJACK_LEFT       BUTTON_LEFT
  67
  68 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
  69 #define BJACK_START      BUTTON_PLAY
  70 #define BJACK_QUIT       BUTTON_POWER
  71 #define BJACK_MAX        (BUTTON_PLAY|BUTTON_SCROLL_UP)
  72 #define BJACK_MIN        (BUTTON_PLAY|BUTTON_SCROLL_DOWN)
  73 #define BJACK_HIT        BUTTON_PLAY
  74 #define BJACK_STAY       BUTTON_FF
  75 #define BJACK_DOUBLEDOWN BUTTON_REW
  76 #define BJACK_SCORES     BUTTON_LEFT
  77 #define BJACK_RESUME     BUTTON_RIGHT
  78 #define BJACK_UP         BUTTON_SCROLL_UP
  79 #define BJACK_DOWN       BUTTON_SCROLL_DOWN
  80 #define BJACK_RIGHT      BUTTON_RIGHT
  81 #define BJACK_LEFT       BUTTON_LEFT
  82
  83 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
  84       (CONFIG_KEYPAD == IRIVER_H300_PAD)
  85 #define BJACK_START      BUTTON_ON
  86 #define BJACK_QUIT       BUTTON_OFF
  87 #define BJACK_MAX        (BUTTON_ON|BUTTON_UP)
  88 #define BJACK_MIN        (BUTTON_ON|BUTTON_DOWN)
  89 #define BJACK_HIT        BUTTON_ON
  90 #define BJACK_STAY       BUTTON_REC
  91 #define BJACK_DOUBLEDOWN BUTTON_SELECT
  92 #define BJACK_SCORES     BUTTON_SELECT
  93 #define BJACK_RESUME     BUTTON_MODE
  94 #define BJACK_UP         BUTTON_UP
  95 #define BJACK_DOWN       BUTTON_DOWN
  96 #define BJACK_RIGHT      BUTTON_RIGHT
  97 #define BJACK_LEFT       BUTTON_LEFT
  98
  99 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
 100       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
 101       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
 102 #define BJACK_START      BUTTON_SELECT
 103 #define BJACK_QUIT       BUTTON_MENU
 104 #define BJACK_MAX        (BUTTON_SELECT|BUTTON_SCROLL_FWD)
 105 #define BJACK_MIN        (BUTTON_SELECT|BUTTON_SCROLL_BACK)
 106 #define BJACK_HIT        BUTTON_SELECT
 107 #define BJACK_STAY       BUTTON_RIGHT
 108 #define BJACK_DOUBLEDOWN BUTTON_LEFT
 109 #define BJACK_SCORES     BUTTON_RIGHT
 110 #define BJACK_RESUME     BUTTON_PLAY
 111 #define BJACK_UP         BUTTON_SCROLL_FWD
 112 #define BJACK_DOWN       BUTTON_SCROLL_BACK
 113 #define BJACK_RIGHT      BUTTON_RIGHT
 114 #define BJACK_LEFT       BUTTON_LEFT
 115
 116 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
 117 #define BJACK_START      BUTTON_PLAY
 118 #define BJACK_QUIT       BUTTON_POWER
 119 #define BJACK_MAX        (BUTTON_PLAY|BUTTON_UP)
 120 #define BJACK_MIN        (BUTTON_PLAY|BUTTON_DOWN)
 121 #define BJACK_HIT        BUTTON_SELECT
 122 #define BJACK_STAY       BUTTON_REC
 123 #define BJACK_DOUBLEDOWN BUTTON_PLAY
 124 #define BJACK_SCORES     BUTTON_RIGHT
 125 #define BJACK_RESUME     BUTTON_DOWN
 126 #define BJACK_UP         BUTTON_UP
 127 #define BJACK_DOWN       BUTTON_DOWN
 128 #define BJACK_RIGHT      BUTTON_RIGHT
 129 #define BJACK_LEFT       BUTTON_LEFT
 130
 131 #elif CONFIG_KEYPAD == IRIVER_IFP7XX_PAD
 132 #define BJACK_START      BUTTON_MODE
 133 #define BJACK_QUIT       BUTTON_PLAY
 134 #define BJACK_MAX        (BUTTON_EQ|BUTTON_UP)
 135 #define BJACK_MIN        (BUTTON_EQ|BUTTON_DOWN)
 136 #define BJACK_HIT        BUTTON_EQ
 137 #define BJACK_STAY       BUTTON_MODE
 138 #define BJACK_DOUBLEDOWN BUTTON_SELECT
 139 #define BJACK_SCORES     BUTTON_SELECT
 140 #define BJACK_RESUME     (BUTTON_EQ|BUTTON_MODE)
 141 #define BJACK_UP         BUTTON_UP
 142 #define BJACK_DOWN       BUTTON_DOWN
 143 #define BJACK_RIGHT      BUTTON_RIGHT
 144 #define BJACK_LEFT       BUTTON_LEFT
 145
 146 #elif CONFIG_KEYPAD == GIGABEAT_PAD
 147 #define BJACK_START      BUTTON_POWER
 148 #define BJACK_QUIT       BUTTON_A
 149 #define BJACK_MAX        BUTTON_VOL_UP
 150 #define BJACK_MIN        BUTTON_VOL_DOWN
 151 #define BJACK_HIT        BUTTON_VOL_UP
 152 #define BJACK_STAY       BUTTON_VOL_DOWN
 153 #define BJACK_DOUBLEDOWN BUTTON_SELECT
 154 #define BJACK_SCORES     BUTTON_RIGHT
 155 #define BJACK_RESUME     BUTTON_MENU
 156 #define BJACK_UP         BUTTON_UP
 157 #define BJACK_DOWN       BUTTON_DOWN
 158 #define BJACK_RIGHT      BUTTON_RIGHT
 159 #define BJACK_LEFT       BUTTON_LEFT
 160
 161 #elif CONFIG_KEYPAD == SANSA_E200_PAD
 162 #define BJACK_START      BUTTON_SELECT
 163 #define BJACK_QUIT       BUTTON_POWER
 164 #define BJACK_MAX        (BUTTON_REC|BUTTON_UP)
 165 #define BJACK_MIN        (BUTTON_REC|BUTTON_DOWN)
 166 #define BJACK_HIT        BUTTON_SELECT
 167 #define BJACK_STAY       BUTTON_RIGHT
 168 #define BJACK_DOUBLEDOWN BUTTON_LEFT
 169 #define BJACK_SCORES     BUTTON_UP
 170 #define BJACK_RESUME     BUTTON_REC
 171 #define BJACK_UP         BUTTON_SCROLL_FWD
 172 #define BJACK_DOWN       BUTTON_SCROLL_BACK
 173 #define BJACK_RIGHT      BUTTON_RIGHT
 174 #define BJACK_LEFT       BUTTON_LEFT
 175
 176 #elif CONFIG_KEYPAD == SANSA_C200_PAD
 177 #define BJACK_START      BUTTON_SELECT
 178 #define BJACK_QUIT       BUTTON_POWER
 179 #define BJACK_MAX        BUTTON_VOL_UP
 180 #define BJACK_MIN        BUTTON_VOL_DOWN
 181 #define BJACK_HIT        BUTTON_SELECT
 182 #define BJACK_STAY       BUTTON_RIGHT
 183 #define BJACK_DOUBLEDOWN BUTTON_LEFT
 184 #define BJACK_SCORES     BUTTON_REC
 185 #define BJACK_RESUME     BUTTON_DOWN
 186 #define BJACK_UP         BUTTON_UP
 187 #define BJACK_DOWN       BUTTON_DOWN
 188 #define BJACK_RIGHT      BUTTON_RIGHT
 189 #define BJACK_LEFT       BUTTON_LEFT
 190
 191 #elif CONFIG_KEYPAD == ELIO_TPJ1022_PAD
 192 #define BJACK_START      BUTTON_MAIN
 193 #define BJACK_QUIT       BUTTON_POWER
 194 #define BJACK_MAX        (BUTTON_REC|BUTTON_UP)
 195 #define BJACK_MIN        (BUTTON_REC|BUTTON_DOWN)
 196 #define BJACK_HIT        BUTTON_MAIN
 197 #define BJACK_STAY       BUTTON_MENU
 198 #define BJACK_DOUBLEDOWN BUTTON_DOWN
 199 #define BJACK_SCORES     BUTTON_UP
 200 #define BJACK_RESUME     BUTTON_FF
 201 #define BJACK_UP         BUTTON_UP
 202 #define BJACK_DOWN       BUTTON_DOWN
 203 #define BJACK_RIGHT      BUTTON_RIGHT
 204 #define BJACK_LEFT       BUTTON_LEFT
 205
 206 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
 207 #define BJACK_START      BUTTON_PLAY
 208 #define BJACK_QUIT       BUTTON_BACK
 209 #define BJACK_MAX        BUTTON_VOL_UP
 210 #define BJACK_MIN        BUTTON_VOL_DOWN
 211 #define BJACK_HIT        BUTTON_VOL_UP
 212 #define BJACK_STAY       BUTTON_VOL_DOWN
 213 #define BJACK_DOUBLEDOWN BUTTON_SELECT
 214 #define BJACK_SCORES     BUTTON_RIGHT
 215 #define BJACK_RESUME     BUTTON_MENU
 216 #define BJACK_UP         BUTTON_UP
 217 #define BJACK_DOWN       BUTTON_DOWN
 218 #define BJACK_RIGHT      BUTTON_RIGHT
 219 #define BJACK_LEFT       BUTTON_LEFT
 220
 221 #else
 222     #error BLACKJACK: Unsupported keypad
 223 #endif
 224
 225 #ifdef HAVE_LCD_COLOR
 226 #define BG_COLOR LCD_RGBPACK(0,157,0)
 227 #define FG_COLOR LCD_WHITE
 228 #elif LCD_DEPTH > 1
 229 #define BG_COLOR LCD_WHITE
 230 #define FG_COLOR LCD_BLACK
 231 #endif
 232
 233 #define CARD_WIDTH  BMPWIDTH_card_back
 234 #define CARD_HEIGHT BMPHEIGHT_card_back
 235
 236 /* This is the max amount of cards onscreen before condensing */
 237 #define MAX_CARDS LCD_WIDTH/(CARD_WIDTH+4)
 238
 239 extern const fb_data card_deck[];
 240 extern const fb_data card_back[];
 241
 242 #define NEXT_CARD bj->player_cards[done][bj->num_player_cards[done]]
 243
 244 /* global rockbox api */
 245 static struct plugin_api* rb;
 246
 247 MEM_FUNCTION_WRAPPERS(rb);
 248
 249 /* dealer and player card positions */
 250 unsigned int dealer_x, dealer_y, player_x, player_y;
 251
 252 typedef struct card {
 253     unsigned int value; /* Card's value in Blackjack */
 254     unsigned int num;        /* Value on card face 0-12 (0=Ace, 1=2, 11=Q) */
 255     unsigned int suit;       /* 0:Spades, 1:Hearts, 2: Clubs; 3: Diamonds */
 256     bool is_soft_ace;
 257 } card;
 258
 259 typedef struct game_context {
 260     struct card player_cards[2][22]; /* 22 Cards means the deal was all aces */
 261     struct card dealer_cards[22];    /* That is the worst-case scenario */
 262     unsigned int player_total;
 263     unsigned int dealer_total;
 264     signed int player_money;
 265     unsigned int num_player_cards[2];
 266     unsigned int num_dealer_cards;
 267     unsigned int current_bet;
 268     unsigned int split_status; /* 0 = split hasn't been asked,         *
 269                                 * 1 = split did not occur              *
 270                                 * 2 = split occurred                   *
 271                                 * 3 = split occurred and 1st hand done */
 272     bool is_blackjack;
 273     bool end_hand;
 274     bool asked_insurance;
 275     signed short highscores[NUM_SCORES];
 276     bool resume;
 277     bool dirty;
 278 } game_context;
 279
 280 /*****************************************************************************
 281 * blackjack_init() initializes blackjack data structures.
 282 ******************************************************************************/
 283 static void blackjack_init(struct game_context* bj) {
 284     /* seed the rand generator */
 285     rb->srand(*rb->current_tick);
 286
 287     /* reset card positions */
 288     dealer_x = 4;
 289     dealer_y = LCD_HEIGHT/4 - CARD_HEIGHT/2;
 290     player_x = 4;
 291     player_y = LCD_HEIGHT - LCD_HEIGHT/4 - CARD_HEIGHT/2;
 292
 293     /* check for resumed game */
 294     if(bj->resume) return;
 295
 296     /* reset scoring */
 297     bj->player_total = 0;
 298     bj->dealer_total = 0;
 299     bj->num_player_cards[0] = 2;
 300     bj->num_player_cards[1] = 0;
 301     bj->num_dealer_cards = 2;
 302     bj->end_hand = false;
 303     bj->split_status = 0;
 304     bj->is_blackjack = false;
 305     bj->asked_insurance = false;
 306 }
 307
 308 /*****************************************************************************
 309 * blackjack_drawtable() draws the table and some text.
 310 ******************************************************************************/
 311 static void blackjack_drawtable(struct game_context* bj) {
 312     unsigned int w, h, y_loc;
 313     char str[10];
 314
 315 #if LCD_HEIGHT <= 64
 316     rb->lcd_getstringsize("Bet", &w, &h);
 317     rb->lcd_putsxy(LCD_WIDTH - w, 2*h + 1, "Bet");
 318     rb->snprintf(str, 9, "$%d", bj->current_bet);
 319     rb->lcd_getstringsize(str, &w, &h);
 320     rb->lcd_putsxy(LCD_WIDTH - w, 3*h + 1, str);
 321     y_loc = LCD_HEIGHT/2;
 322 #else
 323     rb->lcd_getstringsize("Bet", &w, &h);
 324     rb->lcd_putsxy(LCD_WIDTH - w, 5*h / 2, "Bet");
 325     rb->snprintf(str, 9, "$%d", bj->current_bet);
 326     rb->lcd_getstringsize(str, &w, &h);
 327     rb->lcd_putsxy(LCD_WIDTH - w, 7*h / 2, str);
 328     rb->lcd_hline(0, LCD_WIDTH, LCD_HEIGHT/2);
 329     y_loc = LCD_HEIGHT/2 + h;
 330 #endif
 331
 332     rb->lcd_putsxy(0,0, "Dealer");
 333     rb->lcd_getstringsize("Player", &w, &h);
 334     rb->lcd_putsxy(0, y_loc, "Player");
 335     rb->lcd_getstringsize("Total", &w, &h);
 336     rb->lcd_putsxy(LCD_WIDTH - w, y_loc, "Total");
 337     rb->lcd_getstringsize("Money", &w, &h);
 338     rb->lcd_putsxy(LCD_WIDTH - w, 0, "Money");
 339     rb->snprintf(str, 9, "$%d", bj->player_money - bj->current_bet);
 340     rb->lcd_getstringsize(str, &w, &h);
 341     rb->lcd_putsxy(LCD_WIDTH - w, h + 1, str);
 342     rb->snprintf(str, 3, "%d", bj->player_total);
 343     rb->lcd_getstringsize(str, &w, &h);
 344     rb->lcd_putsxy(LCD_WIDTH - w, y_loc + h, str);
 345 }
 346
 347 /*****************************************************************************
 348 * find_value() is passed a card and returns its blackjack value.
 349 ******************************************************************************/
 350 static unsigned int find_value(unsigned int number) {
 351     unsigned int thisValue;
 352     if (number == 0)
 353         thisValue = 11;   /* Aces get a value of 11 at first */
 354     else if (number < 10)
 355         thisValue = number + 1;
 356     else
 357         thisValue = 10;   /* Anything 10 or higher gets a value of 10 */
 358
 359     return thisValue;
 360 }
 361
 362 /*****************************************************************************
 363 * draw_card() draws a card to the screen.
 364 ******************************************************************************/
 365 static void draw_card(struct card temp_card, bool shown, unsigned int x,
 366                       unsigned int y) {
 367     if(shown)
 368         rb->lcd_bitmap_part(card_deck, CARD_WIDTH*temp_card.num,
 369                             CARD_HEIGHT*temp_card.suit, BMPWIDTH_card_deck,
 370                             x+1, y+1, CARD_WIDTH, CARD_HEIGHT);
 371     else
 372         rb->lcd_bitmap(card_back, x+1, y+1,CARD_WIDTH, CARD_HEIGHT);
 373 #if LCD_DEPTH > 1
 374     rb->lcd_set_foreground(LCD_BLACK);
 375 #endif
 376
 377     /* Print outlines */
 378 #if CARD_WIDTH >= 26
 379     rb->lcd_hline(x+2, x+CARD_WIDTH-1, y);
 380     rb->lcd_hline(x+2, x+CARD_WIDTH-1, y+CARD_HEIGHT+1);
 381     rb->lcd_vline(x, y+2, y+CARD_HEIGHT-3);
 382     rb->lcd_vline(x+CARD_WIDTH+1, y+2, y+CARD_HEIGHT-1);
 383     rb->lcd_drawpixel(x+1, y+1);
 384     rb->lcd_drawpixel(x+1, y+CARD_HEIGHT);
 385     rb->lcd_drawpixel(x+CARD_WIDTH, y+1);
 386     rb->lcd_drawpixel(x+CARD_WIDTH, y+CARD_HEIGHT);
 387 #else
 388     rb->lcd_hline(x+1, x+CARD_WIDTH, y);
 389     rb->lcd_hline(x+1, x+CARD_WIDTH, y+CARD_HEIGHT+1);
 390     rb->lcd_vline(x, y+1, y+CARD_HEIGHT);
 391     rb->lcd_vline(x+CARD_WIDTH+1, y+1, y+CARD_HEIGHT);
 392 #endif
 393
 394 #if LCD_DEPTH > 1
 395     rb->lcd_set_foreground(FG_COLOR);
 396 #endif
 397 }
 398
 399 /*****************************************************************************
 400 * new_card() initializes a new card and gives it values.
 401 ******************************************************************************/
 402 static struct card new_card(void) {
 403     struct card new_card;
 404     new_card.suit = rb->rand()%4; /* Random number 0-3 */
 405     new_card.num = rb->rand()%13; /* Random number 0-12 */
 406     new_card.value = find_value(new_card.num);
 407     new_card.is_soft_ace = new_card.num == 0 ? true : false;
 408     return new_card;
 409 }
 410
 411 /*****************************************************************************
 412 * deal_init_card() deals and draws to the screen the player's and dealer's
 413 * initial cards.
 414 ******************************************************************************/
 415 static void deal_init_cards(struct game_context* bj) {
 416     bj->dealer_cards[0] = new_card();
 417     bj->dealer_total += bj->dealer_cards[0].value;
 418
 419     draw_card(bj->dealer_cards[0], false, dealer_x, dealer_y);
 420
 421     bj->dealer_cards[1] = new_card();
 422     bj->dealer_total += bj->dealer_cards[1].value;
 423     draw_card(bj->dealer_cards[1], true, dealer_x + CARD_WIDTH + 4, dealer_y);
 424
 425     bj->player_cards[0][0] = new_card();
 426     bj->player_total += bj->player_cards[0][0].value;
 427     draw_card(bj->player_cards[0][0], true, player_x, player_y);
 428     player_x += CARD_WIDTH + 4;
 429
 430     bj->player_cards[0][1] = new_card();
 431     bj->player_total += bj->player_cards[0][1].value;
 432     draw_card(bj->player_cards[0][1], true, player_x, player_y);
 433     player_x += CARD_WIDTH + 4;
 434 }
 435
 436 /*****************************************************************************
 437 * redraw_board() redraws all the cards and the board
 438 ******************************************************************************/
 439 static void redraw_board(struct game_context* bj) {
 440     unsigned int i, n, upper_bound;
 441     rb->lcd_clear_display();
 442
 443     blackjack_drawtable(bj);
 444     player_x = 4;
 445     dealer_x = 4;
 446     upper_bound = bj->split_status > 1 ? 2 : 1;
 447
 448     for (i = 0; i < bj->num_dealer_cards; i++) {
 449         if (!bj->end_hand) {
 450             draw_card(bj->dealer_cards[0], false, dealer_x, dealer_y);
 451
 452             /* increment i so the dealer's first card isn't displayed */
 453             i++;
 454             dealer_x += CARD_WIDTH + 4;
 455         }
 456         draw_card(bj->dealer_cards[i], true, dealer_x, dealer_y);
 457
 458         if (bj->num_dealer_cards > MAX_CARDS-1)
 459             dealer_x += 10;
 460         else
 461             dealer_x += CARD_WIDTH + 4;
 462     }
 463
 464     for (n = 0; n < upper_bound; n++) {
 465         for (i = 0; i < bj->num_player_cards[n]; i++) {
 466             draw_card(bj->player_cards[n][i], true, player_x, player_y);
 467             if (bj->split_status>1 || bj->num_player_cards[n]>MAX_CARDS)
 468                 player_x += 10;
 469             else
 470                 player_x += CARD_WIDTH + 4;
 471         }
 472         if (bj->split_status > 1)
 473             player_x = LCD_WIDTH/2 + 4;
 474     }
 475 }
 476
 477 /*****************************************************************************
 478 * update_total updates the player's total
 479 ******************************************************************************/
 480 static void update_total(struct game_context* bj) {
 481     char total[3];
 482     unsigned int w, h;
 483     rb->snprintf(total, 3, "%d", bj->player_total);
 484     rb->lcd_getstringsize(total, &w, &h);
 485 #if LCD_HEIGHT > 64
 486     h *= 2;
 487 #endif
 488     rb->lcd_putsxy(LCD_WIDTH - w, LCD_HEIGHT/2 + h, total);
 489     rb->lcd_update_rect(LCD_WIDTH - w, LCD_HEIGHT/2 + h, w, h);
 490 }
 491
 492
 493 /*****************************************************************************
 494 * check_for_aces() is passed an array of cards and returns where an ace is
 495 * located. Otherwise, returns -1.
 496 ******************************************************************************/
 497 static signed int check_for_aces(struct card temp_cards[],
 498                                  unsigned int size) {
 499     unsigned int i;
 500     for(i = 0; i < size; i++) {
 501         if (temp_cards[i].is_soft_ace == true)
 502           return i;
 503     }
 504     return -1;
 505 }
 506
 507 /*****************************************************************************
 508 * check_totals() compares player and dealer totals.
 509 * 0: bust 1: loss, 2: push, 3: win, 4: blackjack, 5: something's not right...
 510 ******************************************************************************/
 511 static unsigned int check_totals(struct game_context* bj)
 512 {
 513     unsigned int temp;
 514     if (bj->player_total > 21)
 515       temp = 0;
 516     else if (bj->player_total == 21 && bj->is_blackjack)
 517       if (bj->dealer_total == 21 && bj->num_dealer_cards == 2)
 518         temp = 2;
 519       else
 520         temp = 4;
 521     else if (bj->player_total == bj->dealer_total)
 522       temp = 2;
 523     else if (bj->dealer_total > 21 && bj->player_total < 22)
 524       temp = 3;
 525     else if (bj->dealer_total > bj->player_total)
 526       temp = 1;
 527     else if (bj->player_total > bj->dealer_total)
 528       temp = 3;
 529     else
 530       temp = 5;
 531
 532     return temp;
 533 }
 534
 535 /*****************************************************************************
 536 * finish_dealer() draws cards for the dealer until he has 17 or more.
 537 ******************************************************************************/
 538 static void finish_dealer(struct game_context* bj) {
 539     signed int temp = 0;
 540
 541     if (bj->dealer_total > 16 && bj->dealer_total < 22)
 542         return;
 543
 544     while (bj->dealer_total < 17) {
 545       bj->dealer_cards[bj->num_dealer_cards] = new_card();
 546       bj->dealer_total += bj->dealer_cards[bj->num_dealer_cards].value;
 547       bj->num_dealer_cards++;
 548     }
 549
 550     while (bj->dealer_total > 21) {
 551       temp = check_for_aces(bj->dealer_cards, bj->num_dealer_cards);
 552       if(temp != -1) {
 553         bj->dealer_cards[temp].is_soft_ace = false;
 554         bj->dealer_total -= 10;
 555       }
 556       else
 557         return;
 558     }
 559 }
 560
 561 /*****************************************************************************
 562 * finish_game() completes the game once player's turn is over.
 563 ******************************************************************************/
 564 static void finish_game(struct game_context* bj) {
 565     unsigned int rValue, w, h;
 566     char str[19];
 567
 568     do {
 569         finish_dealer(bj);
 570     } while (bj->dealer_total < 17);
 571
 572     redraw_board(bj);
 573     rValue = check_totals(bj);
 574
 575     if (rValue == 0) {
 576       rb->snprintf(str, sizeof(str), " Bust! ");
 577       bj->player_money -= bj->current_bet;
 578     }
 579     else if (rValue == 1) {
 580       rb->snprintf(str, sizeof(str), " Sorry, you lost. ");
 581       bj->player_money -= bj->current_bet;
 582     }
 583     else if (rValue == 2) {
 584       rb->snprintf(str, sizeof(str), " Push ");
 585     }
 586     else if (rValue == 3) {
 587       rb->snprintf(str, sizeof(str), " You won! ");
 588       bj->player_money+= bj->current_bet;
 589     }
 590     else {
 591       rb->snprintf(str, sizeof(str), " Blackjack! ");
 592       bj->player_money += bj->current_bet * 3 / 2;
 593     }
 594     rb->lcd_getstringsize(str, &w, &h);
 595
 596 #if LCD_HEIGHT <= 64
 597     rb->lcd_set_drawmode(DRMODE_BG+DRMODE_INVERSEVID);
 598     rb->lcd_fillrect(0, LCD_HEIGHT/2, LCD_WIDTH, LCD_HEIGHT/2);
 599     rb->lcd_set_drawmode(DRMODE_SOLID);
 600     rb->lcd_putsxy(LCD_WIDTH/2 - w/2, LCD_HEIGHT/2 + h, str);
 601     rb->snprintf(str, 12, "You have %d", bj->player_total);
 602     rb->lcd_getstringsize(str, &w, &h);
 603     rb->lcd_putsxy(LCD_WIDTH/2 - w/2, LCD_HEIGHT/2, str);
 604 #else
 605     rb->lcd_putsxy(LCD_WIDTH/2 - w/2, LCD_HEIGHT/2 - h/2, str);
 606 #endif
 607     rb->lcd_update();
 608 }
 609
 610 /*****************************************************************************
 611 * blackjack_recordscore() inserts a high score into the high scores list and
 612 *     returns the high score position.
 613 ******************************************************************************/
 614 static unsigned int blackjack_recordscore(struct game_context* bj) {
 615     unsigned int i;
 616     unsigned int position = 0;
 617     signed short current, temp;
 618
 619     /* calculate total score */
 620     current = bj->player_money;
 621     if(current <= 10) return 0;
 622
 623     /* insert the current score into the high scores */
 624     for(i=0; i<NUM_SCORES; i++) {
 625         if(current >= bj->highscores[i]) {
 626             if(!position) {
 627                 position = i+1;
 628                 bj->dirty = true;
 629             }
 630             temp = bj->highscores[i];
 631             bj->highscores[i] = current;
 632             current = temp;
 633         }
 634     }
 635
 636     return position;
 637 }
 638
 639 /*****************************************************************************
 640 * blackjack_loadscores() loads the high scores saved file.
 641 ******************************************************************************/
 642 static void blackjack_loadscores(struct game_context* bj) {
 643     signed int fd;
 644
 645     bj->dirty = false;
 646
 647     /* clear high scores */
 648     rb->memset(bj->highscores, 0, sizeof(bj->highscores));
 649
 650     /* open scores file */
 651     fd = rb->open(SCORE_FILE, O_RDONLY);
 652     if(fd < 0) return;
 653
 654     /* read in high scores */
 655     if(rb->read(fd, bj->highscores, sizeof(bj->highscores)) <= 0) {
 656         /* scores are bad, reset */
 657         rb->memset(bj->highscores, 0, sizeof(bj->highscores));
 658     }
 659
 660     rb->close(fd);
 661 }
 662
 663 /*****************************************************************************
 664 * blackjack_savescores() saves the high scores saved file.
 665 ******************************************************************************/
 666 static void blackjack_savescores(struct game_context* bj) {
 667     unsigned int fd;
 668
 669     /* write out the high scores to the save file */
 670     fd = rb->open(SCORE_FILE, O_WRONLY|O_CREAT);
 671     rb->write(fd, bj->highscores, sizeof(bj->highscores));
 672     rb->close(fd);
 673     bj->dirty = false;
 674 }
 675
 676 /*****************************************************************************
 677 * blackjack_loadgame() loads the saved game and returns load success.
 678 ******************************************************************************/
 679 static bool blackjack_loadgame(struct game_context* bj) {
 680     signed int fd;
 681     bool loaded = false;
 682
 683     /* open game file */
 684     fd = rb->open(SAVE_FILE, O_RDONLY);
 685     if(fd < 0) return loaded;
 686
 687     /* read in saved game */
 688     while(true) {
 689         if(rb->read(fd, &bj->player_money, sizeof(bj->player_money)) <= 0) break;
 690         if(rb->read(fd, &bj->player_total, sizeof(bj->player_total)) <= 0) break;
 691         if(rb->read(fd, &bj->dealer_total, sizeof(bj->dealer_total)) <= 0) break;
 692         if(rb->read(fd, &bj->num_player_cards, sizeof(bj->num_player_cards))<=0)
 693             break;
 694         if(rb->read(fd, &bj->num_dealer_cards, sizeof(bj->num_dealer_cards))<=0)
 695             break;
 696         if(rb->read(fd, &bj->current_bet, sizeof(bj->current_bet)) <= 0) break;
 697         if(rb->read(fd, &bj->is_blackjack, sizeof(bj->is_blackjack)) <= 0) break;
 698         if(rb->read(fd, &bj->split_status, sizeof(bj->split_status)) <= 0) break;
 699         if(rb->read(fd, &bj->asked_insurance, sizeof(bj->asked_insurance)) <= 0)
 700             break;
 701         if(rb->read(fd, &bj->end_hand, sizeof(bj->end_hand)) <= 0) break;
 702         if(rb->read(fd, &bj->player_cards, sizeof(bj->player_cards)) <= 0) break;
 703         if(rb->read(fd, &bj->dealer_cards, sizeof(bj->dealer_cards)) <= 0) break;
 704         bj->resume = true;
 705         loaded = true;
 706         break;
 707     }
 708
 709     rb->close(fd);
 710
 711     /* delete saved file */
 712     rb->remove(SAVE_FILE);
 713     return loaded;
 714 }
 715
 716 /*****************************************************************************
 717 * blackjack_savegame() saves the current game state.
 718 ******************************************************************************/
 719 static void blackjack_savegame(struct game_context* bj) {
 720     unsigned int fd;
 721
 722     /* write out the game state to the save file */
 723     fd = rb->open(SAVE_FILE, O_WRONLY|O_CREAT);
 724     rb->write(fd, &bj->player_money, sizeof(bj->player_money));
 725     rb->write(fd, &bj->player_total, sizeof(bj->player_total));
 726     rb->write(fd, &bj->dealer_total, sizeof(bj->dealer_total));
 727     rb->write(fd, &bj->num_player_cards, sizeof(bj->num_player_cards));
 728     rb->write(fd, &bj->num_dealer_cards, sizeof(bj->num_dealer_cards));
 729     rb->write(fd, &bj->current_bet, sizeof(bj->current_bet));
 730     rb->write(fd, &bj->is_blackjack, sizeof(bj->is_blackjack));
 731     rb->write(fd, &bj->split_status, sizeof(bj->split_status));
 732     rb->write(fd, &bj->asked_insurance, sizeof(bj->asked_insurance));
 733     rb->write(fd, &bj->end_hand, sizeof(bj->end_hand));
 734     rb->write(fd, &bj->player_cards, sizeof(bj->player_cards));
 735     rb->write(fd, &bj->dealer_cards, sizeof(bj->dealer_cards));
 736     rb->close(fd);
 737
 738     bj->resume = true;
 739 }
 740
 741 /*****************************************************************************
 742 * blackjack_callback() is the default event handler callback which is called
 743 *     on usb connect and shutdown.
 744 ******************************************************************************/
 745 static void blackjack_callback(void* param) {
 746     struct game_context* bj = (struct game_context*) param;
 747     if(bj->dirty) {
 748         rb->splash(HZ, "Saving high scores...");
 749         blackjack_savescores(bj);
 750     }
 751 }
 752
 753 /*****************************************************************************
 754 * blackjack_get_yes_no() gets a yes/no answer from the user
 755 ******************************************************************************/
 756 static unsigned int blackjack_get_yes_no(char message[20]) {
 757     int button;
 758     unsigned int w, h, b, choice = 0;
 759     bool breakout = false;
 760     char message_yes[24], message_no[24];
 761
 762     rb->strcpy(message_yes, message);
 763     rb->strcpy(message_no, message);
 764     rb->strcat(message_yes, " Yes");
 765     rb->strcat(message_no, "  No");
 766     rb->lcd_getstringsize(message_yes, &w, &h);
 767     const char *stg[] = {message_yes, message_no};
 768
 769 #if LCD_HEIGHT <= 64
 770     b = 2*h+1;
 771 #else
 772     b = h-1;
 773 #endif
 774
 775 #ifdef HAVE_LCD_COLOR
 776     rb->lcd_fillrect(LCD_WIDTH/2 - w/2, LCD_HEIGHT/2 + b, w+1, h+3);
 777     rb->lcd_set_foreground(LCD_BLACK);
 778     rb->lcd_set_background(LCD_WHITE);
 779 #else
 780     rb->lcd_set_drawmode(DRMODE_BG+DRMODE_INVERSEVID);
 781     rb->lcd_fillrect(LCD_WIDTH/2 - w/2, LCD_HEIGHT/2 + b, w+1, h+3);
 782     rb->lcd_set_drawmode(DRMODE_SOLID);
 783 #endif
 784     rb->lcd_drawrect(LCD_WIDTH/2 - w/2 - 1, LCD_HEIGHT/2 + b - 1, w+3, h+4);
 785
 786     while(!breakout) {
 787         rb->lcd_putsxy(LCD_WIDTH/2 - w/2, LCD_HEIGHT/2 + b +1, stg[choice]);
 788         rb->lcd_update_rect(LCD_WIDTH/2 - w/2 - 1, LCD_HEIGHT/2 + b -1,
 789                             w+3, h+4);
 790         button = rb->button_get(true);
 791
 792         switch(button) {
 793             case BJACK_LEFT:
 794             case (BJACK_LEFT|BUTTON_REPEAT):
 795             case BJACK_RIGHT:
 796             case (BJACK_RIGHT|BUTTON_REPEAT):
 797                 choice ^= 1;
 798                 break;
 799             case BJACK_START: breakout = true;
 800                 break;
 801             case BJACK_QUIT: breakout = true;
 802                 choice = BJ_QUIT;
 803                 break;
 804         }
 805     }
 806
 807 #if LCD_DEPTH > 1
 808     rb->lcd_set_foreground(FG_COLOR);
 809     rb->lcd_set_background(BG_COLOR);
 810 #endif
 811     return choice;
 812 }
 813
 814 /*****************************************************************************
 815 * blackjack_get_amount() gets an amount from the player to be used
 816 ******************************************************************************/
 817 static signed int blackjack_get_amount(char message[20], signed int lower_limit,
 818                                        signed int upper_limit,
 819                                        signed int start) {
 820     int button;
 821     char str[6];
 822     bool changed = false;
 823     unsigned int w, h;
 824     signed int amount;
 825
 826     rb->lcd_getstringsize("A", &w, &h); /* find the size of one character */
 827
 828     if (start > upper_limit)
 829         amount = upper_limit;
 830     else if (start < lower_limit)
 831         amount = lower_limit;
 832     else
 833         amount = start;
 834
 835 #if LCD_DEPTH > 1
 836     rb->lcd_set_background(LCD_WHITE);
 837     rb->lcd_set_foreground(LCD_BLACK);
 838 #endif
 839
 840 #if LCD_HEIGHT <= 64
 841     rb->lcd_clear_display();
 842     rb->lcd_puts(0, 1, message);
 843     rb->snprintf(str, 9, "$%d", amount);
 844     rb->lcd_puts(0, 2, str);
 845     rb->lcd_puts(0, 3, "RIGHT: +1");
 846     rb->lcd_puts(0, 4, "LEFT:  -1");
 847     rb->lcd_puts(0, 5, "UP:   +10");
 848     rb->lcd_puts(0, 6, "DOWN: -10");
 849     rb->lcd_update();
 850 #else
 851     rb->lcd_set_drawmode(DRMODE_BG+DRMODE_INVERSEVID);
 852     rb->lcd_fillrect(LCD_WIDTH/2 - 9*w - 1, LCD_HEIGHT/2 - 4*h - 3, 37*w / 2,
 853                      8*h -3);
 854     rb->lcd_set_drawmode(DRMODE_SOLID);
 855     rb->lcd_drawrect(LCD_WIDTH/2 - 9*w - 1, LCD_HEIGHT/2 - 4*h - 3, 37*w / 2,
 856                      8*h -3);
 857     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 4*h - 1, message);
 858     rb->snprintf(str, 9, "$%d", amount);
 859     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 3*h, str);
 860 #if (CONFIG_KEYPAD == IPOD_4G_PAD) || \
 861       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
 862       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
 863     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - h-2, " >>|:     +1");
 864     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 1, " |<<:     -1");
 865     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + h, "SCROLL+: +10");
 866     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + 2*h + 1, "SCROLL-: -10");
 867 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
 868     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - h-2, "RIGHT:    +1");
 869     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 1, "LEFT:     -1");
 870     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + h, "SCROLL+: +10");
 871     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + 2*h + 1, "SCROLL-: -10");
 872 #else
 873     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - h-2, "RIGHT: +1");
 874     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 1, "LEFT:  -1");
 875     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + h, "UP:   +10");
 876     rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 + 2*h + 1, "DOWN: -10");
 877 #endif
 878     rb->lcd_update_rect(LCD_WIDTH/2 - 9*w - 2, LCD_HEIGHT/2 - 9*h/2, 37*w/2 + 1,
 879                         8*h-2);
 880 #endif
 881
 882     while(true) {
 883         button = rb->button_get(true);
 884
 885         switch(button) {
 886             case BJACK_UP:
 887             case (BJACK_UP|BUTTON_REPEAT):
 888             if (amount + 10 < upper_limit + 1) {
 889                     amount += 10;
 890                     changed = true;
 891             }
 892             break;
 893             case BJACK_DOWN:
 894             case (BJACK_DOWN|BUTTON_REPEAT):
 895                 if (amount - 10 > lower_limit - 1) {
 896                     amount -= 10;
 897                     changed = true;
 898                 }
 899                 break;
 900             case BJACK_RIGHT:
 901             case (BJACK_RIGHT|BUTTON_REPEAT):
 902                 if (amount + 1 < upper_limit + 1) {
 903                     amount++;
 904                     changed = true;
 905                 }
 906                 break;
 907             case BJACK_LEFT:
 908             case (BJACK_LEFT|BUTTON_REPEAT):
 909                 if (amount - 1 > lower_limit - 1) {
 910                     amount--;
 911                     changed = true;
 912                 }
 913                 break;
 914             case BJACK_MAX :
 915                 amount = upper_limit;
 916                 changed = true;
 917                 break;
 918             case BJACK_MIN :
 919                 amount = lower_limit;
 920                 changed = true;
 921                 break;
 922             case BJACK_QUIT:
 923                 return 0;
 924             case BJACK_START:
 925 #if LCD_DEPTH > 1
 926                 rb->lcd_set_foreground(FG_COLOR);
 927                 rb->lcd_set_background(BG_COLOR);
 928 #endif
 929                 rb->lcd_clear_display();
 930                 return amount;
 931        }
 932
 933        if(changed) {
 934             rb->snprintf(str, 9, "$%d", amount);
 935 #if LCD_HEIGHT <= 64
 936             rb->lcd_puts(0, 2, str);
 937             rb->lcd_update();
 938 #else
 939             rb->lcd_set_drawmode(DRMODE_BG+DRMODE_INVERSEVID);
 940             rb->lcd_fillrect(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 3*h, 5*w, h);
 941             rb->lcd_set_drawmode(DRMODE_SOLID);
 942             rb->lcd_putsxy(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 3*h, str);
 943             rb->lcd_update_rect(LCD_WIDTH/2 - 9*w, LCD_HEIGHT/2 - 3*h, 5*w, h);
 944 #endif
 945             changed = false;
 946         }
 947     }
 948 }
 949
 950 /*****************************************************************************
 951 * blackjack_get_bet() gets the player's bet.
 952 ******************************************************************************/
 953 static void blackjack_get_bet(struct game_context* bj) {
 954     bj->current_bet = blackjack_get_amount("Please enter a bet", 10,
 955                                            bj->player_money, bj->current_bet);
 956 }
 957
 958 /*****************************************************************************
 959 * double_down() returns one final card then finishes the game
 960 ******************************************************************************/
 961 static void double_down(struct game_context* bj) {
 962     bj->current_bet *= 2;
 963     bj->player_cards[0][bj->num_player_cards[0]] = new_card();
 964     bj->player_total += bj->player_cards[0][bj->num_player_cards[0]].value;
 965     bj->num_player_cards[0]++;
 966 }
 967
 968 /*****************************************************************************
 969 * split() checks if the player wants to split and acts accordingly.
 970 * When bj->split_status is 1, no split occurred. 2 means the player split and 3
 971 * means a split has already occurred and the first hand is done.
 972 ******************************************************************************/
 973 static void split(struct game_context* bj) {
 974     if (blackjack_get_yes_no("Split?") == 1)
 975         bj->split_status = 1;
 976     else {
 977         bj->split_status = 2;
 978         bj->current_bet *= 2;
 979         bj->num_player_cards[0] = 1;
 980         bj->num_player_cards[1] = 1;
 981         bj->player_cards[1][0] = bj->player_cards[0][1];
 982         bj->player_total = bj->player_cards[0][0].value;
 983     }
 984 }
 985
 986 /*****************************************************************************
 987 * insurance() see if the player wants to buy insurance and how much.
 988 ******************************************************************************/
 989 static unsigned int insurance(struct game_context* bj) {
 990     unsigned int insurance, max_amount;
 991
 992     insurance = blackjack_get_yes_no("Buy Insurance?");
 993     bj->asked_insurance = true;
 994     max_amount = bj->current_bet < (unsigned int)bj->player_money ?
 995                             bj->current_bet/2 : (unsigned int)bj->player_money;
 996     if (insurance == 1) return 0;
 997
 998     insurance = blackjack_get_amount("How much?", 0, max_amount, 0);
 999     redraw_board(bj);
1000     return insurance;
1001 }
1002
1003 /*****************************************************************************
1004 * play_again() checks to see if the player wants to keep playing.
1005 ******************************************************************************/
1006 static unsigned int play_again(void) {
1007     return blackjack_get_yes_no("Play Again?");
1008 }
1009
1010 /*****************************************************************************
1011 * blackjack_menu() is the initial menu at the start of the game.
1012 ******************************************************************************/
1013 static unsigned int blackjack_menu(struct game_context* bj) {
1014     int button;
1015     char *title = "Blackjack";
1016     char str[18];
1017     unsigned int i, w, h;
1018     bool breakout = false;
1019     bool showscores = false;
1020
1021     while(true){
1022 #if LCD_DEPTH > 1
1023         rb->lcd_set_background(BG_COLOR);
1024         rb->lcd_set_foreground(FG_COLOR);
1025 #endif
1026         rb->lcd_clear_display();
1027
1028         if(!showscores) {
1029              /* welcome screen to display key bindings */
1030             rb->lcd_getstringsize(title, &w, &h);
1031             rb->lcd_putsxy((LCD_WIDTH-w)/2, 0, title);
1032
1033 #if CONFIG_KEYPAD == RECORDER_PAD
1034             rb->lcd_puts(0, 1, "ON: start");
1035             rb->lcd_puts(0, 2, "OFF: exit");
1036             rb->lcd_puts(0, 3, "F1: hit");
1037             rb->lcd_puts(0, 4, "F2: stay");
1038             rb->lcd_puts(0, 5, "F3: double down");
1039             rb->lcd_puts(0, 6, "PLAY: save/resume");
1040             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1041             rb->lcd_puts(0, 7, str);
1042 #elif CONFIG_KEYPAD == ONDIO_PAD
1043             rb->lcd_puts(0, 1, "MENU: start");
1044             rb->lcd_puts(0, 2, "OFF: exit");
1045             rb->lcd_puts(0, 3, "LEFT: hit");
1046             rb->lcd_puts(0, 4, "RIGHT: stay");
1047             rb->lcd_puts(0, 5, "UP: double down");
1048             rb->lcd_puts(0, 6, "DOWN: save/resume");
1049             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1050             rb->lcd_puts(0, 7, str);
1051 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
1052             rb->lcd_puts(0, 2, "PLAY to start & to hit");
1053             rb->lcd_puts(0, 3, "STOP to exit");
1054             rb->lcd_puts(0, 4, "REC to stay");
1055             rb->lcd_puts(0, 5, "NAVI to double down ");
1056             rb->lcd_puts(0, 6, "  & to view highscores");
1057             rb->lcd_puts(0, 7, "AB to save/resume");
1058             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1059             rb->lcd_puts(0, 8, str);
1060 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
1061             rb->lcd_puts(0, 2, "PLAY to start & hit");
1062             rb->lcd_puts(0, 3, "POWER to exit");
1063             rb->lcd_puts(0, 4, ">>| to stay");
1064             rb->lcd_puts(0, 5, "|<< to double down");
1065             rb->lcd_puts(0, 6, "LEFT to view scores");
1066             rb->lcd_puts(0, 7, "RIGHT to save/resume");
1067             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1068             rb->lcd_puts(0, 8, str);
1069
1070 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
1071       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
1072       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
1073 #if LCD_WIDTH >=176
1074             rb->lcd_puts(0, 2, "SELECT to start & to hit");
1075             rb->lcd_puts(0, 3, "MENU to exit");
1076             rb->lcd_puts(0, 4, ">>| to stay & to view highscores");
1077             rb->lcd_puts(0, 5, "|<< to double down");
1078             rb->lcd_puts(0, 6, "PLAY to save/resume");
1079             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1080             rb->lcd_puts(0, 7, str);
1081 #else
1082             rb->lcd_puts(0, 2, "SELECT to start & to ");
1083             rb->lcd_puts(0, 3, "  hit");
1084             rb->lcd_puts(0, 4, "MENU to exit");
1085             rb->lcd_puts(0, 5, ">>| to stay & to view ");
1086             rb->lcd_puts(0, 6, "  highscores");
1087             rb->lcd_puts(0, 7, "|<< to double down");
1088             rb->lcd_puts(0, 8, "PLAY to save/resume");
1089             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1090             rb->lcd_puts(0, 9, str);
1091 #endif
1092 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
1093             rb->lcd_puts(0, 2, "PLAY to start to hit");
1094             rb->lcd_puts(0, 3, "POWER to exit");
1095             rb->lcd_puts(0, 4, "SELECT to hit");
1096             rb->lcd_puts(0, 5, "REC to stay");
1097             rb->lcd_puts(0, 6, "PLAY to double down");
1098             rb->lcd_puts(0, 7, "RIGHT to view highscores ");
1099             rb->lcd_puts(0, 8, "DOWN to save/resume");
1100             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1101             rb->lcd_puts(0, 9, str);
1102 #elif CONFIG_KEYPAD == IRIVER_IFP7XX_PAD
1103             rb->lcd_puts(0, 2, "AB to start & to");
1104             rb->lcd_puts(0, 3, "  stay");
1105             rb->lcd_puts(0, 4, "EQ to hit");
1106             rb->lcd_puts(0, 5, "PLAY to exit");
1107             rb->lcd_puts(0, 6, "CLICK to double down");
1108             rb->lcd_puts(0, 7, "& to view highscores");
1109             rb->lcd_puts(0, 8, "AB+EQ to save/resume");
1110             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1111             rb->lcd_puts(0, 9, str);
1112 #elif CONFIG_KEYPAD == GIGABEAT_PAD
1113             rb->lcd_puts(0, 2, "POWER to start");
1114             rb->lcd_puts(0, 3, "A to exit");
1115             rb->lcd_puts(0, 4, "VOL+ to hit");
1116             rb->lcd_puts(0, 5, "VOL- to stay");
1117             rb->lcd_puts(0, 6, "CENTER to double down");
1118             rb->lcd_puts(0, 6, "RIGHT to view highscores ");
1119             rb->lcd_puts(0, 8, "MENU to save/resume");
1120             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1121             rb->lcd_puts(0, 9, str);
1122 #elif (CONFIG_KEYPAD == SANSA_E200_PAD)
1123             rb->lcd_puts(0, 2, "SELECT to start & to hit");
1124             rb->lcd_puts(0, 3, "POWER to exit");
1125             rb->lcd_puts(0, 4, "RIGHT to stay");
1126             rb->lcd_puts(0, 5, "LEFT to double down");
1127             rb->lcd_puts(0, 6, "REC to save/resume");
1128             rb->lcd_puts(0, 7, "UP to view scores");
1129             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1130             rb->lcd_puts(0, 8, str);
1131 #elif (CONFIG_KEYPAD == SANSA_C200_PAD)
1132             rb->lcd_puts(0, 2, "SELECT to start & to hit");
1133             rb->lcd_puts(0, 3, "POWER to exit");
1134             rb->lcd_puts(0, 4, "RIGHT to stay");
1135             rb->lcd_puts(0, 5, "LEFT to double down");
1136             rb->lcd_puts(0, 6, "DOWN to save/resume");
1137             rb->lcd_puts(0, 7, "REC to view scores");
1138             rb->snprintf(str, 21, "High Score: $%d", bj->highscores[0]);
1139             rb->lcd_puts(0, 9, str);
1140 #endif
1141         } else {
1142             rb->snprintf(str, 12, "%s", "High Scores");
1143             rb->lcd_getstringsize(str, &w, &h);
1144             rb->lcd_putsxy((LCD_WIDTH-w)/2, 0, str);
1145
1146             /* print high scores */
1147             for(i=0; i<NUM_SCORES; i++) {
1148                 rb->snprintf(str, 14, "#%02d: $%d", i+1, bj->highscores[i]);
1149                 rb->lcd_puts(0, i+1, str);
1150             }
1151         }
1152
1153         rb->lcd_update();
1154
1155         /* handle menu button presses */
1156         button = rb->button_get(true);
1157
1158         switch(button) {
1159             case BJACK_START: /* start playing */
1160                 breakout = true;
1161                 break;
1162
1163             case BJACK_QUIT:  /* quit program */
1164                 if(showscores) {
1165                     showscores = 0;
1166                     break;
1167                 }
1168                 return BJ_QUIT;
1169
1170             case BJACK_RESUME:/* resume game */
1171                 if(!blackjack_loadgame(bj)) {
1172                     rb->splash(HZ*2, "Nothing to resume");
1173                 } else {
1174                     rb->splash(HZ*2, "Loading...");
1175                     breakout = true;
1176                 }
1177                 break;
1178
1179             case BJACK_SCORES:/* toggle high scores */
1180                 showscores = !showscores;
1181                 break;
1182
1183             default:
1184                 if(rb->default_event_handler_ex(button, blackjack_callback,
1185                    (void*) bj) == SYS_USB_CONNECTED)
1186                     return BJ_USB;
1187                 break;
1188         }
1189
1190         if(breakout) break;
1191     }
1192
1193     return(0);
1194 }
1195
1196 /*****************************************************************************
1197 * blackjack() is the main game subroutine, it returns the final game status.
1198 ******************************************************************************/
1199 static int blackjack(struct game_context* bj) {
1200     int button;
1201     unsigned int w, h, temp_var, done = 0, todo = 1;
1202     signed int temp;
1203     bool breakout = false;
1204     bool dbl_down = false;
1205
1206     /* don't resume by default */
1207     bj->resume = false;
1208
1209     /********************
1210     *       menu        *
1211     ********************/
1212     temp_var = blackjack_menu(bj);
1213     if (temp_var == BJ_QUIT || temp_var == BJ_USB)
1214         return temp_var;
1215
1216
1217     /********************
1218     *       init        *
1219     ********************/
1220     blackjack_init(bj);
1221     bj->current_bet=10;
1222
1223     /********************
1224     *       play        *
1225     ********************/
1226
1227     /* check for resumed game */
1228     if(bj->resume) {
1229         bj->resume = false;
1230         redraw_board(bj);
1231         if (bj->split_status == 2) {
1232           todo=2;
1233           player_x = bj->num_player_cards[0] * 10 + 4;
1234         }
1235         else if (bj->split_status == 3) {
1236           player_x = bj->num_player_cards[1] * 10 + LCD_WIDTH/2 + 4;
1237           todo=2;
1238           done=1;
1239         }
1240
1241     }
1242     else {
1243         bj->player_money = 1000;
1244         blackjack_get_bet(bj);
1245         if (bj->current_bet == 0)
1246             return BJ_QUIT;
1247         rb->lcd_clear_display();
1248         deal_init_cards(bj);
1249         blackjack_drawtable(bj);
1250     }
1251
1252     rb->lcd_update();
1253
1254     breakout = false;
1255
1256     while(true){
1257         if(bj->player_total == 21 && bj->num_player_cards[0] == 2) {
1258             bj->is_blackjack = true;
1259             bj->end_hand = true;
1260             finish_game(bj);
1261         }
1262         else if(bj->dealer_cards[1].is_soft_ace && !breakout &&
1263                 !bj->asked_insurance) {
1264             temp_var = insurance(bj);
1265             if (bj->dealer_total == 21) {
1266                 rb->splash(HZ, "Dealer has blackjack");
1267                 bj->player_money += temp_var;
1268                 bj->end_hand = true;
1269                 breakout = true;
1270                 redraw_board(bj);
1271                 finish_game(bj);
1272             }
1273             else {
1274                 rb->splash(HZ, "Dealer does not have blackjack");
1275                 bj->player_money -= temp_var;
1276                 breakout = true;
1277                 redraw_board(bj);
1278                 rb->lcd_update();
1279             }
1280         }
1281         if(bj->split_status == 0 &&
1282            bj->player_cards[0][0].num == bj->player_cards[0][1].num) {
1283             split(bj);
1284             redraw_board(bj);
1285             rb->lcd_update_rect(0, LCD_HEIGHT/2, LCD_WIDTH, LCD_HEIGHT/2);
1286             if (bj->split_status == 2) {
1287                 todo++;
1288                 player_x = bj->num_player_cards[0] * 10 + 4;
1289             }
1290         }
1291
1292         while(done < todo) {
1293             button = rb->button_get(true);
1294
1295             switch(button) {
1296                 case BJACK_HIT:
1297                     NEXT_CARD = new_card();
1298                     bj->player_total += NEXT_CARD.value;
1299                     draw_card(NEXT_CARD, true, player_x, player_y);
1300                     bj->num_player_cards[done]++;
1301                     if (bj->num_player_cards[done] == MAX_CARDS + 1) {
1302                         redraw_board(bj);
1303                         rb->lcd_update_rect(0, LCD_HEIGHT/2, LCD_WIDTH,
1304                                             LCD_HEIGHT/2);
1305                     }
1306                     else if (bj->num_player_cards[done]>MAX_CARDS || todo > 1) {
1307                         rb->lcd_update_rect(player_x, player_y, CARD_WIDTH+2,
1308                                             CARD_HEIGHT+2);
1309                         player_x += 10;
1310                     }
1311                     else {
1312                         rb->lcd_update_rect(player_x, player_y, CARD_WIDTH+2,
1313                                             CARD_HEIGHT+2);
1314                         player_x += CARD_WIDTH + 4;
1315                     }
1316                     update_total(bj);
1317
1318                     break;
1319                 case BJACK_STAY:
1320                     bj->end_hand = true;
1321                     break;
1322                 case BJACK_DOUBLEDOWN:
1323                     if ((signed int)bj->current_bet * 2 < bj->player_money + 1 &&
1324                          bj->num_player_cards[0]==2 && todo==1) {
1325                         double_down(bj);
1326                         dbl_down = true;
1327                         if (bj->player_total < 22) {
1328                             bj->end_hand = true;
1329                             finish_game(bj);
1330                         }
1331                     }
1332                     else if((signed int)bj->current_bet * 2 > bj->player_money) {
1333                         rb->splash(HZ, "Not enough money to double down.");
1334                         redraw_board(bj);
1335                         rb->lcd_update();
1336                     }
1337                     break;
1338                 case BJACK_RESUME:           /* save and end game */
1339                     rb->splash(HZ, "Saving game...");
1340                     blackjack_savegame(bj);
1341                     /* fall through to BJACK_QUIT */
1342
1343                 case BJACK_QUIT:
1344                     return BJ_END;
1345             }
1346
1347             while (bj->player_total > 21 && !bj->end_hand) {
1348                 temp = check_for_aces(bj->player_cards[done],
1349                                       bj->num_player_cards[done]);
1350                 if(temp != -1) {
1351                     bj->player_cards[done][temp].is_soft_ace = false;
1352                     bj->player_total -= 10;
1353                     update_total(bj);
1354                     if (dbl_down) {
1355                         bj->end_hand = true;
1356                         finish_game(bj);
1357                     }
1358                 }
1359                 else
1360                     bj->end_hand = true;
1361             }
1362
1363             if (bj->end_hand) {
1364                 done++;
1365                 if(todo > 1) {
1366                     if (done == 2) {
1367                         temp = bj->player_total;
1368                         bj->player_total = temp_var;
1369                         temp_var = temp;
1370                         finish_game(bj);
1371                         rb->lcd_getstringsize(" Split 1 ", &w, &h);
1372                         rb->lcd_putsxy(LCD_WIDTH/2-w/2, LCD_HEIGHT/2-3*h/2,
1373                                        " Split 1 ");
1374                         rb->lcd_update_rect(LCD_WIDTH/2-w/2, LCD_HEIGHT/2-3*h/2,
1375                                             w,h);
1376                         bj->current_bet /= 2;
1377                         rb->lcd_update_rect(LCD_WIDTH/2-w/2, LCD_HEIGHT/2-3*h/2,
1378                                             w,h);
1379                         rb->sleep(HZ*2);
1380                         bj->player_total = temp_var;
1381                         finish_game(bj);
1382                         rb->lcd_getstringsize(" Split 2 ", &w, &h);
1383                         rb->lcd_putsxy(LCD_WIDTH/2-w/2, LCD_HEIGHT/2-3*h/2,
1384                                        " Split 2 ");
1385                         rb->lcd_update_rect(LCD_WIDTH/2-w/2, LCD_HEIGHT/2-3*h/2,
1386                                             w,h);
1387                         rb->sleep(HZ*2);
1388                     }
1389                     else {
1390                         bj->end_hand = false;
1391                         bj->split_status = 3;
1392                         temp_var = bj->player_total;
1393                         bj->player_total = bj->player_cards[1][0].value;
1394                         update_total(bj);
1395                         redraw_board(bj);
1396                         player_x += 10;
1397                         rb->lcd_update();
1398                     }
1399                 }
1400                 else
1401                     finish_game(bj);
1402             }
1403         }
1404
1405         if (bj->player_money < 10) {
1406             rb->sleep(HZ);
1407             return BJ_LOSE;
1408         }
1409
1410         if (bj->end_hand) {                     /* If hand is over */
1411             if (play_again() != 0)              /* User wants to quit */
1412                 return BJ_END;
1413             else {                              /* User keeps playing */
1414                 breakout = false;
1415                 redraw_board(bj);
1416                 if(dbl_down) {
1417                     bj->current_bet /= 2;
1418                     dbl_down = false;
1419                 }
1420                 done = 0;
1421                 todo = 1;
1422                 blackjack_init(bj);
1423                 blackjack_get_bet(bj);
1424                 if (bj->current_bet == 0)
1425                     return BJ_END;
1426                 deal_init_cards(bj);
1427                 blackjack_drawtable(bj);
1428                 rb->lcd_update();
1429             }
1430         }
1431     }
1432     /* Never reached */
1433     return PLUGIN_OK;
1434 }
1435
1436 /*****************************************************************************
1437 * plugin entry point.
1438 ******************************************************************************/
1439 enum plugin_status plugin_start(struct plugin_api* api, void* parameter) {
1440     struct game_context bj;
1441     bool exit = false;
1442     unsigned int position;
1443     char str[19];
1444
1445     (void)parameter;
1446     rb = api;
1447
1448 #if LCD_DEPTH > 1
1449     rb->lcd_set_backdrop(NULL);
1450 #endif
1451
1452     /* load high scores */
1453     blackjack_loadscores(&bj);
1454
1455     rb->lcd_setfont(FONT_SYSFIXED);
1456
1457     while(!exit) {
1458         switch(blackjack(&bj)){
1459             case BJ_LOSE:
1460                 rb->splash(HZ, "Not enough money to continue");
1461                 /* fall through to BJ_END */
1462
1463             case BJ_END:
1464                 if(!bj.resume) {
1465                     if((position = blackjack_recordscore(&bj))) {
1466                         rb->snprintf(str, 19, "New high score #%d!", position);
1467                         rb->splash(HZ*2, str);
1468                     }
1469                 }
1470                 break;
1471
1472             case BJ_USB:
1473                 rb->lcd_setfont(FONT_UI);
1474                 return PLUGIN_USB_CONNECTED;
1475
1476             case BJ_QUIT:
1477                 if(bj.dirty) {
1478                     rb->splash(HZ, "Saving high scores...");
1479                     blackjack_savescores(&bj);
1480                 }
1481                 exit = true;
1482                 break;
1483
1484             default:
1485                 break;
1486         }
1487     }
1488
1489     rb->lcd_setfont(FONT_UI);
1490     return PLUGIN_OK;
1491 }