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