apps/plugins/xobox.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 Eli Sherer
  11  *               2007 Antoine Cellerier
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22
  23 #include "plugin.h"
  24 #include "lib/helper.h"
  25 #include "lib/playback_control.h"
  26
  27 PLUGIN_HEADER
  28
  29 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
  30
  31 #define QUIT BUTTON_OFF
  32 #define LEFT BUTTON_LEFT
  33 #define RIGHT BUTTON_RIGHT
  34 #define PAUSE BUTTON_MODE
  35 #define UP BUTTON_UP
  36 #define DOWN BUTTON_DOWN
  37
  38 #define RC_QUIT BUTTON_RC_STOP
  39
  40 #elif (CONFIG_KEYPAD == ARCHOS_AV300_PAD)
  41
  42 #define QUIT BUTTON_OFF
  43 #define LEFT BUTTON_LEFT
  44 #define RIGHT BUTTON_RIGHT
  45 #define PAUSE BUTTON_ON
  46 #define UP BUTTON_UP
  47 #define DOWN BUTTON_DOWN
  48
  49 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
  50       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
  51       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
  52
  53 #define QUIT (BUTTON_SELECT | BUTTON_MENU)
  54 #define LEFT BUTTON_LEFT
  55 #define RIGHT BUTTON_RIGHT
  56 #define PAUSE BUTTON_SELECT
  57 #define MENU_UP BUTTON_SCROLL_FWD
  58 #define MENU_DOWN BUTTON_SCROLL_BACK
  59 #define UP BUTTON_MENU
  60 #define DOWN BUTTON_PLAY
  61
  62 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
  63
  64 #define QUIT BUTTON_POWER
  65 #define LEFT BUTTON_LEFT
  66 #define RIGHT BUTTON_RIGHT
  67 #define UP BUTTON_UP
  68 #define DOWN BUTTON_DOWN
  69 #define PAUSE BUTTON_PLAY
  70
  71 #elif (CONFIG_KEYPAD == GIGABEAT_PAD)
  72
  73 #define QUIT BUTTON_POWER
  74 #define LEFT BUTTON_LEFT
  75 #define RIGHT BUTTON_RIGHT
  76 #define UP BUTTON_UP
  77 #define DOWN BUTTON_DOWN
  78 #define PAUSE BUTTON_A
  79
  80 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || \
  81 (CONFIG_KEYPAD == SANSA_C200_PAD)
  82
  83 #define QUIT BUTTON_POWER
  84 #define LEFT BUTTON_LEFT
  85 #define RIGHT BUTTON_RIGHT
  86 #define UP BUTTON_UP
  87 #define DOWN BUTTON_DOWN
  88 #define PAUSE BUTTON_REC
  89
  90 #elif (CONFIG_KEYPAD == SANSA_CLIP_PAD)
  91
  92 #define QUIT BUTTON_POWER
  93 #define LEFT BUTTON_LEFT
  94 #define RIGHT BUTTON_RIGHT
  95 #define UP BUTTON_UP
  96 #define DOWN BUTTON_DOWN
  97 #define PAUSE BUTTON_HOME
  98
  99 #elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
 100
 101 #define QUIT (BUTTON_HOME|BUTTON_REPEAT)
 102 #define LEFT BUTTON_LEFT
 103 #define RIGHT BUTTON_RIGHT
 104 #define UP BUTTON_UP
 105 #define DOWN BUTTON_DOWN
 106 #define PAUSE BUTTON_SELECT
 107
 108 #elif (CONFIG_KEYPAD == SANSA_M200_PAD)
 109
 110 #define QUIT BUTTON_POWER
 111 #define LEFT BUTTON_LEFT
 112 #define RIGHT BUTTON_RIGHT
 113 #define UP BUTTON_UP
 114 #define DOWN BUTTON_DOWN
 115 #define PAUSE BUTTON_SELECT
 116
 117 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
 118
 119 #define QUIT BUTTON_POWER
 120 #define LEFT BUTTON_LEFT
 121 #define RIGHT BUTTON_RIGHT
 122 #define UP BUTTON_SCROLL_UP
 123 #define DOWN BUTTON_SCROLL_DOWN
 124 #define PAUSE BUTTON_PLAY
 125
 126 #elif CONFIG_KEYPAD == RECORDER_PAD
 127
 128 #define QUIT BUTTON_OFF
 129 #define LEFT BUTTON_LEFT
 130 #define RIGHT BUTTON_RIGHT
 131 #define DOWN BUTTON_DOWN
 132 #define UP BUTTON_UP
 133 #define PAUSE BUTTON_PLAY
 134
 135 #elif CONFIG_KEYPAD == ONDIO_PAD
 136
 137 #define QUIT BUTTON_OFF
 138 #define LEFT BUTTON_LEFT
 139 #define RIGHT BUTTON_RIGHT
 140 #define DOWN BUTTON_DOWN
 141 #define UP BUTTON_UP
 142 #define PAUSE BUTTON_MENU
 143
 144 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD)
 145
 146 #define QUIT BUTTON_BACK
 147 #define LEFT BUTTON_LEFT
 148 #define RIGHT BUTTON_RIGHT
 149 #define UP BUTTON_UP
 150 #define DOWN BUTTON_DOWN
 151 #define PAUSE BUTTON_PLAY
 152
 153 #elif (CONFIG_KEYPAD == MROBE100_PAD)
 154
 155 #define QUIT BUTTON_POWER
 156 #define LEFT BUTTON_LEFT
 157 #define RIGHT BUTTON_RIGHT
 158 #define UP BUTTON_UP
 159 #define DOWN BUTTON_DOWN
 160 #define PAUSE BUTTON_DISPLAY
 161
 162 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
 163
 164 #define QUIT BUTTON_RC_REC
 165 #define LEFT BUTTON_RC_REW
 166 #define RIGHT BUTTON_RC_FF
 167 #define UP BUTTON_RC_VOL_UP
 168 #define DOWN BUTTON_RC_VOL_DOWN
 169 #define PAUSE BUTTON_RC_PLAY
 170
 171 #elif CONFIG_KEYPAD == COWOND2_PAD
 172
 173 #define QUIT BUTTON_POWER
 174
 175 #elif CONFIG_KEYPAD == IAUDIO67_PAD
 176
 177 #define QUIT BUTTON_POWER
 178 #define LEFT BUTTON_LEFT
 179 #define RIGHT BUTTON_RIGHT
 180 #define UP BUTTON_STOP
 181 #define DOWN BUTTON_PLAY
 182 #define PAUSE BUTTON_MENU
 183
 184 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
 185
 186 #define QUIT BUTTON_BACK
 187 #define LEFT BUTTON_LEFT
 188 #define RIGHT BUTTON_RIGHT
 189 #define UP BUTTON_UP
 190 #define DOWN BUTTON_DOWN
 191 #define PAUSE BUTTON_PLAY
 192
 193 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
 194
 195 #define QUIT BUTTON_POWER
 196 #define LEFT BUTTON_LEFT
 197 #define RIGHT BUTTON_RIGHT
 198 #define UP BUTTON_UP
 199 #define DOWN BUTTON_DOWN
 200 #define PAUSE BUTTON_VIEW
 201
 202 #elif CONFIG_KEYPAD == ONDAVX747_PAD || \
 203 CONFIG_KEYPAD == ONDAVX777_PAD || \
 204 CONFIG_KEYPAD == MROBE500_PAD
 205
 206 #define QUIT BUTTON_POWER
 207
 208 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
 209
 210 #define QUIT  BUTTON_PLAY
 211 #define LEFT  BUTTON_LEFT
 212 #define RIGHT BUTTON_RIGHT
 213 #define UP    BUTTON_UP
 214 #define DOWN  BUTTON_DOWN
 215 #define PAUSE BUTTON_FFWD
 216
 217 #else
 218 #error No keymap defined!
 219 #endif
 220
 221 #ifdef HAVE_TOUCHSCREEN
 222 #ifndef QUIT
 223 #define QUIT  BUTTON_TOPLEFT
 224 #endif
 225 #ifndef LEFT
 226 #define LEFT  BUTTON_MIDLEFT
 227 #endif
 228 #ifndef RIGHT
 229 #define RIGHT BUTTON_MIDRIGHT
 230 #endif
 231 #ifndef UP
 232 #define UP    BUTTON_TOPMIDDLE
 233 #endif
 234 #ifndef DOWN
 235 #define DOWN  BUTTON_BOTTOMMIDDLE
 236 #endif
 237 #ifndef PAUSE
 238 #define PAUSE BUTTON_CENTER
 239 #endif
 240 #endif
 241
 242 #define MOVE_NO 0               /* player movement */
 243 #define MOVE_UP 1               /*    1    */
 244 #define MOVE_DN 2               /*  3 0 4  */
 245 #define MOVE_LT 3               /*    2    */
 246 #define MOVE_RT 4
 247
 248 /* ball movement (12 ways) */
 249 /*    UUL   UR    */
 250 /*   UL       UR   */
 251 /* ULL    .    URR */
 252 /* DLL         DRR */
 253 /*   DL       DR   */
 254 /*    DDL   DDR    */
 255
 256 #define DIR_UU (1<<7)
 257 #define DIR_U  (1<<6)
 258 #define DIR_RR (1<<5)
 259 #define DIR_R  (1<<4)
 260 #define DIR_DD (1<<3)
 261 #define DIR_D  (1<<2)
 262 #define DIR_LL (1<<1)
 263 #define DIR_L  (1<<0)
 264
 265 #define MOVE_UUR ( DIR_UU | DIR_R  )
 266 #define MOVE_UR  ( DIR_U  | DIR_R  )
 267 #define MOVE_URR ( DIR_U  | DIR_RR )
 268 #define MOVE_DRR ( DIR_D  | DIR_RR )
 269 #define MOVE_DR  ( DIR_D  | DIR_R  )
 270 #define MOVE_DDR ( DIR_DD | DIR_R  )
 271 #define MOVE_DDL ( DIR_DD | DIR_L  )
 272 #define MOVE_DL  ( DIR_D  | DIR_L  )
 273 #define MOVE_DLL ( DIR_D  | DIR_LL )
 274 #define MOVE_ULL ( DIR_U  | DIR_LL )
 275 #define MOVE_UL  ( DIR_U  | DIR_L  )
 276 #define MOVE_UUL ( DIR_UU | DIR_L  )
 277
 278 #if (LCD_WIDTH>112) && (LCD_HEIGHT>64)
 279 #   define CUBE_SIZE 8             /* 8x22=176 */
 280 #   define pos(a) ((a)>>3)
 281 #else
 282 #   define CUBE_SIZE 4
 283 #   define pos(a) ((a)>>2)
 284 #endif
 285
 286 #define STARTING_QIXES 2
 287 #define MAX_LEVEL 10
 288 #define MAX_QIXES MAX_LEVEL+STARTING_QIXES
 289 #define BOARD_W ((int)(LCD_WIDTH/CUBE_SIZE))
 290 #define BOARD_H ((int)(LCD_HEIGHT/CUBE_SIZE))
 291 #define BOARD_X (LCD_WIDTH-BOARD_W*CUBE_SIZE)/2
 292 #define BOARD_Y (LCD_HEIGHT-BOARD_H*CUBE_SIZE)/2
 293
 294 #ifdef HAVE_LCD_COLOR
 295 #define CLR_RED  LCD_RGBPACK(255,0,0)         /* used to imply danger */
 296 #define CLR_LTBLUE LCD_RGBPACK(125, 145, 180) /* used for frame and filling */
 297 #define PLR_COL  LCD_WHITE                    /* color used for the player */
 298 #elif LCD_DEPTH>=2
 299 #define CLR_RED  LCD_DARKGRAY     /* used to imply danger */
 300 #define CLR_LTBLUE LCD_LIGHTGRAY  /* used for frame and filling */
 301 #define PLR_COL  LCD_BLACK        /* color used for the player */
 302 #endif
 303
 304 #if LCD_DEPTH>=2
 305 #define EMPTIED LCD_BLACK       /* empty spot */
 306 #define FILLED  CLR_LTBLUE      /* filled spot */
 307 #define TRAIL   CLR_RED         /* the red trail of the player */
 308 #define QIX     LCD_WHITE
 309 #else
 310 #define EMPTIED 0
 311 #define FILLED 1
 312 #define TRAIL 2
 313 #define QIX 3
 314 #endif
 315 #define UNCHECKED 0
 316 #define CHECKED 1
 317 #define PAINTED -1
 318 #define PIC_QIX 0
 319 #define PIC_PLAYER 1
 320
 321 /* The time (in ms) for one iteration through the game loop - decrease this
 322    to speed up the game - note that current_tick is (currently) only accurate
 323    to 10ms.
 324 */
 325 static int speed = 6; /* CYCLETIME = (11-speed)*10 ms */
 326 static int difficulty = 75; /* Percentage of screen that needs to be filled
 327                              * in order to win the game */
 328
 329 static bool quit = false;
 330
 331 static unsigned int board[BOARD_H][BOARD_W];
 332 static int testboard[BOARD_H][BOARD_W];
 333
 334 #if CUBE_SIZE == 8
 335 /*
 336    00011000 0x18 - 11100111 0xe7
 337    00111100 0x3c - 11100111 0xe7
 338    01111110 0x7e - 11000011 0xc3
 339    11111111 0xff - 00000000 0x00
 340    11111111 0xff - 00000000 0x00
 341    01111110 0x7e - 11000011 0xc3
 342    00111100 0x3c - 11100111 0xe7
 343    00011000 0x18 - 11100111 0xe7
 344  */
 345 const unsigned char pics[2][8] = {
 346     {0x18, 0x3c, 0x7e, 0xff, 0xff, 0x7e, 0x3c, 0x18},   /* Alien (QIX) */
 347     {0xe7, 0xe7, 0xc3, 0x00, 0x00, 0xc3, 0xe7, 0xe7}    /* Player (XONIX) */
 348 };
 349 #elif CUBE_SIZE == 4
 350 /*
 351    0110 0x6 - 1001 0x9
 352    1111 0xf - 0110 0x6
 353    1111 0xf - 0110 0x6
 354    0110 0x6 - 1001 0x9
 355  */
 356 const unsigned char pics[2][4] = {
 357     {0x6, 0xf, 0xf, 0x6},   /* Alien (QIX) */
 358     {0x9, 0x6, 0x6, 0x9}    /* Player (XONIX) */
 359 };
 360 #else
 361 #error Incorrect CUBE_SIZE value.
 362 #endif
 363
 364 static struct qix
 365 {
 366     int velocity;             /* velocity */
 367     int x, y;                 /* position on screen */
 368     int angle;                /* angle */
 369 } qixes[MAX_QIXES];             /* black_qix */
 370
 371 static struct splayer
 372 {
 373     int i, j;                 /* position on board */
 374     int move, score, level, lives;
 375     bool drawing;
 376     bool gameover;
 377 } player;
 378
 379 static int percentage_cache;
 380
 381 /*************************** STACK STUFF **********************/
 382
 383 /* the stack */
 384 #define STACK_SIZE (2*BOARD_W*BOARD_H)
 385 static struct pos
 386 {
 387     int x, y;                   /* position on board */
 388 } stack[STACK_SIZE];
 389 static int stackPointer;
 390
 391 static inline bool pop (struct pos *p)
 392 {
 393     if (stackPointer > 0) {
 394         p->x = stack[stackPointer].x;
 395         p->y = stack[stackPointer].y;
 396         stackPointer--;
 397         return true;
 398     } else
 399         return false;           /* SE */
 400 }
 401
 402 static inline bool push (struct pos *p)
 403 {
 404     if (stackPointer < STACK_SIZE - 1) {
 405         stackPointer++;
 406         stack[stackPointer].x = p->x;
 407         stack[stackPointer].y = p->y;
 408         return true;
 409     } else
 410         return false;           /* SOF */
 411 }
 412
 413 static inline void emptyStack (void)
 414 {
 415     stackPointer = 0;
 416 }
 417
 418 /*********************** END OF STACK STUFF *********************/
 419
 420 /* calculate the new x coordinate of the ball according to angle and speed */
 421 static inline int get_newx (int x, int len, int deg)
 422 {
 423     if (deg & DIR_R)
 424         return x + len;
 425     else if (deg & DIR_L)
 426         return x - len;
 427     else if (deg & DIR_RR)
 428         return x + len * 2;
 429     else /* (def & DIR_LL) */
 430         return x - len * 2;
 431 }
 432
 433 /* calculate the new y coordinate of the ball according to angle and speed */
 434 static inline int get_newy (int y, int len, int deg)
 435 {
 436     if (deg & DIR_D)
 437         return y + len;
 438     else if (deg & DIR_U)
 439         return y - len;
 440     else if (deg & DIR_DD)
 441         return y + len * 2;
 442     else /* (deg & DIR_UU) */
 443         return y - len * 2;
 444 }
 445
 446 /* make random function get it's value from the device ticker */
 447 static inline void randomize (void)
 448 {
 449     rb->srand (*rb->current_tick);
 450 }
 451
 452 /* get a random number between 0 and range-1 */
 453 static int t_rand (int range)
 454 {
 455     return rb->rand () % range;
 456 }
 457
 458 /* initializes the test help board */
 459 static void init_testboard (void)
 460 {
 461     int j;                   /* testboard */
 462     for (j = 0; j < BOARD_H; j++)
 463         /* UNCHEKED == (int)0 */
 464         rb->memset( testboard[j], 0, BOARD_W * sizeof( int ) );
 465 }
 466
 467 /* initializes the game board on with the player,qix's and black qix */
 468 static void init_board (void)
 469 {
 470     int i, j;
 471     for (j = 0; j < BOARD_H; j++)
 472         for (i = 0; i < BOARD_W; i++) { /* make a nice cyan frame */
 473             if ((i == 0) || (j <= 1) || (i == BOARD_W - 1)
 474                 || (j >= BOARD_H - 2))
 475                 board[j][i] = FILLED;
 476             else
 477                 board[j][i] = EMPTIED;
 478         }
 479
 480     /* (level+2) is the number of qixes */
 481     for (j = 0; j < player.level + STARTING_QIXES; j++) {
 482         qixes[j].velocity = t_rand (2) + 1;     /* 1 or 2 pix-per-sec */
 483
 484         /* not on frame */
 485         qixes[j].x = CUBE_SIZE*2 + 2*t_rand (((BOARD_W-4)*CUBE_SIZE)/2);
 486         qixes[j].y = CUBE_SIZE*2 + 2*t_rand (((BOARD_H-4)*CUBE_SIZE)/2);
 487
 488         const int angle_table[] = {
 489             MOVE_UUR, MOVE_UR, MOVE_URR, MOVE_DRR, MOVE_DR, MOVE_DDR,
 490             MOVE_UUL, MOVE_UL, MOVE_ULL, MOVE_DLL, MOVE_DL, MOVE_DDL };
 491         qixes[j].angle = angle_table[t_rand (12)];
 492 #if CUBE_SIZE == 4
 493         /* Work arround a nasty bug. FIXME */
 494         if( qixes[j].angle & (DIR_LL|DIR_RR|DIR_UU|DIR_DD) )
 495             qixes[j].velocity = 1;
 496 #endif
 497     }
 498     /*black_qix.velocity=1;
 499        black_qix.x=BOARD_X+(BOARD_W*CUBE_SIZE)/2-CUBE_SIZE/2;
 500        black_qix.y=BOARD_Y+(BOARD_H*CUBE_SIZE)-CUBE_SIZE-CUBE_SIZE/2;
 501        black_qix.angle=MOVE_UR; */
 502     player.move = MOVE_NO;
 503     player.drawing = false;
 504     player.i = BOARD_W / 2;
 505     player.j = 1;
 506
 507     percentage_cache = 0;
 508 }
 509
 510 /* calculates the percentage of the screen filling */
 511 static int percentage (void)
 512 {
 513     int i, j, filled = 0;
 514     for (j = 2; j < BOARD_H - 2; j++)
 515         for (i = 1; i < BOARD_W - 1; i++)
 516             if (board[j][i] == FILLED)
 517                 filled++;
 518     return (filled * 100) / ((BOARD_W - 2) * (BOARD_H - 4));
 519 }
 520
 521 /* draw the board on with all the game figures */
 522 static void refresh_board (void)
 523 {
 524     int i, j;
 525     char str[25];
 526
 527 #if LCD_DEPTH>=2
 528     rb->lcd_set_background (LCD_BLACK);
 529 #endif
 530     rb->lcd_clear_display ();
 531     for (j = 0; j < BOARD_H; j++)
 532     {
 533         unsigned last_color = board[j][0];
 534         int last_i = 0;
 535         for (i = 1; i < BOARD_W; i++) {
 536             if( last_color != board[j][i] )
 537             {
 538 #if LCD_DEPTH>=2
 539                 rb->lcd_set_foreground (last_color);
 540 #else
 541                 if (last_color != EMPTIED)
 542 #endif
 543                 rb->lcd_fillrect (BOARD_X + CUBE_SIZE * (last_i),
 544                                   BOARD_Y + CUBE_SIZE * j,
 545                                   CUBE_SIZE  * (i - last_i), CUBE_SIZE );
 546                 last_color = board[j][i];
 547                 last_i = i;
 548             }
 549         }
 550 #if LCD_DEPTH>=2
 551         rb->lcd_set_foreground (last_color);
 552 #else
 553         if (last_color != EMPTIED)
 554 #endif
 555         rb->lcd_fillrect (BOARD_X + CUBE_SIZE * (last_i),
 556                           BOARD_Y + CUBE_SIZE * j,
 557                           CUBE_SIZE * (i - last_i), CUBE_SIZE);
 558     }
 559
 560 #if LCD_DEPTH>=2
 561     rb->lcd_set_foreground (LCD_BLACK);
 562     rb->lcd_set_background (CLR_LTBLUE);
 563 #else
 564     rb->lcd_set_drawmode (DRMODE_COMPLEMENT);
 565 #endif
 566     rb->snprintf (str, sizeof (str), "Level %d", player.level + 1);
 567     rb->lcd_putsxy (BOARD_X, BOARD_Y, str);
 568     rb->snprintf (str, sizeof (str), "%d%%", percentage_cache);
 569     rb->lcd_putsxy (BOARD_X + CUBE_SIZE * BOARD_W - 24, BOARD_Y, str);
 570     rb->snprintf (str, sizeof (str), "Score: %d", player.score);
 571     rb->lcd_putsxy (BOARD_X, BOARD_Y + CUBE_SIZE * BOARD_H - 8, str);
 572     rb->snprintf (str, sizeof (str),
 573                  (player.lives != 1) ? "%d Lives" : "%d Life", player.lives);
 574 #if LCD_DEPTH>=2
 575     rb->lcd_putsxy (BOARD_X + CUBE_SIZE * BOARD_W - 60,
 576                     BOARD_Y + CUBE_SIZE * BOARD_H - 8, str);
 577 #else
 578     rb->lcd_putsxy (BOARD_X + CUBE_SIZE * BOARD_W - 40,
 579                     BOARD_Y + CUBE_SIZE * BOARD_H - 8, str);
 580 #endif
 581
 582 #if LCD_DEPTH>=2
 583     rb->lcd_set_foreground (PLR_COL);
 584     rb->lcd_set_background (board[player.j][player.i]);
 585 #endif
 586     rb->lcd_mono_bitmap (pics[PIC_PLAYER], player.i * CUBE_SIZE + BOARD_X,
 587                          player.j * CUBE_SIZE + BOARD_Y, CUBE_SIZE, CUBE_SIZE);
 588
 589 #if LCD_DEPTH>=2
 590     rb->lcd_set_background (EMPTIED);
 591     rb->lcd_set_foreground (LCD_WHITE);
 592     rb->lcd_set_drawmode (DRMODE_FG);
 593 #else
 594     rb->lcd_set_drawmode (DRMODE_FG);
 595 #endif
 596     for (j = 0; j < player.level + STARTING_QIXES; j++)
 597         rb->lcd_mono_bitmap (pics[PIC_QIX], qixes[j].x + BOARD_X,
 598                              qixes[j].y + BOARD_Y, CUBE_SIZE, CUBE_SIZE);
 599 #if LCD_DEPTH>=2
 600     rb->lcd_set_foreground (LCD_BLACK);
 601 #endif
 602     rb->lcd_set_drawmode (DRMODE_SOLID);
 603
 604     rb->lcd_update ();
 605 }
 606
 607 static inline int infested_area (int i, int j, int v)
 608 {
 609     struct pos p;
 610     p.x = i;
 611     p.y = j;
 612     emptyStack ();
 613     if (!push (&p))
 614         return -1;
 615     while (pop (&p)) {
 616         if (testboard[p.y][p.x] == v) continue;
 617         if (testboard[p.y][p.x] > UNCHECKED)
 618             return 1; /* This area was previously flagged as infested */
 619         testboard[p.y][p.x] = v;
 620         if (board[p.y][p.x] == QIX)
 621             return 1; /* Infested area */
 622         {
 623             struct pos p1 = { p.x+1, p.y };
 624             if ((p1.x < BOARD_W)
 625              && (board[p1.y][p1.x] != FILLED)
 626              && (!push (&p1)))
 627                 return -1;
 628         }
 629         {
 630             struct pos p1 = { p.x-1, p.y };
 631             if ((p1.x >= 0)
 632              && (board[p1.y][p1.x] != FILLED)
 633              && (!push (&p1)))
 634                 return -1;
 635         }
 636         {
 637             struct pos p1 = { p.x, p.y+1 };
 638             if ((p1.y < BOARD_H)
 639              && (board[p1.y][p1.x] != FILLED)
 640              && (!push (&p1)))
 641                 return -1;
 642         }
 643         {
 644             struct pos p1 = { p.x, p.y-1 };
 645             if ((p1.y >= 0)
 646              && (board[p1.y][p1.x] != FILLED)
 647              && (!push (&p1)))
 648                 return -1;
 649         }
 650     }
 651     return 0;
 652 }
 653
 654 static inline int fill_area (int i, int j)
 655 {
 656     struct pos p;
 657     p.x = i;
 658     p.y = j;
 659     int v = testboard[p.y][p.x];
 660     emptyStack ();
 661     if (!push (&p))
 662         return -1;
 663     while (pop (&p)) {
 664         board[p.y][p.x] = FILLED;
 665         testboard[p.y][p.x] = PAINTED;
 666         {
 667             struct pos p1 = { p.x+1, p.y };
 668             if ((p1.x < BOARD_W)
 669              && (testboard[p1.y][p1.x] == v)
 670              && (!push (&p1)))
 671                 return -1;
 672         }
 673         {
 674             struct pos p1 = { p.x-1, p.y };
 675             if ((p1.x >= 0)
 676              && (testboard[p1.y][p1.x] == v)
 677              && (!push (&p1)))
 678                 return -1;
 679         }
 680         {
 681             struct pos p1 = { p.x, p.y+1 };
 682             if ((p1.y < BOARD_H)
 683              && (testboard[p1.y][p1.x] == v)
 684              && (!push (&p1)))
 685                 return -1;
 686         }
 687         {
 688             struct pos p1 = { p.x, p.y-1 };
 689             if ((p1.y >= 0)
 690              && (testboard[p1.y][p1.x] == v)
 691              && (!push (&p1)))
 692                 return -1;
 693         }
 694     }
 695     return 0;
 696 }
 697
 698
 699 /* take care of stuff after xonix has landed on a filled spot */
 700 static void complete_trail (int fill)
 701 {
 702     int i, j, ret;
 703     for (j = 0; j < BOARD_H; j++) {
 704         for (i = 0; i < BOARD_W; i++) {
 705             if (board[j][i] == TRAIL) {
 706                 if (fill)
 707                     board[j][i] = FILLED;
 708                 else
 709                     board[j][i] = EMPTIED;
 710             }
 711         }
 712     }
 713
 714     if (fill) {
 715         int v = CHECKED;
 716         for (i = 0; i < player.level + STARTING_QIXES; i++) /* add qixes to board */
 717             board[pos(qixes[i].y - BOARD_Y)]
 718                  [pos(qixes[i].x - BOARD_X)] = QIX;
 719
 720         init_testboard();
 721         for (j = 1; j < BOARD_H - 1; j++) {
 722             for (i = 0; i < BOARD_W - 0; i++) {
 723                 if (board[j][i] != FILLED) {
 724                     ret = infested_area (i, j, v);
 725                     if (ret < 0 || ( ret == 0 && fill_area (i, j) ) )
 726                         quit = true;
 727                     v++;
 728                 }
 729             }
 730         }
 731
 732         for (i = 0; i < player.level + STARTING_QIXES; i++) /* add qixes to board */
 733             board[pos(qixes[i].y - BOARD_Y)]
 734                  [pos(qixes[i].x - BOARD_X)] = EMPTIED;
 735         percentage_cache = percentage();
 736      }
 737
 738      rb->button_clear_queue();
 739 }
 740
 741 /* returns the color the real pixel(x,y) on the lcd is pointing at */
 742 static inline unsigned int getpixel (int x, int y)
 743 {
 744     const int a = pos (x - BOARD_X), b = pos (y - BOARD_Y);
 745     if ((a > 0) && (a < BOARD_W) && (b > 0) && (b < BOARD_H))   /* if inside board */
 746         return board[b][a];
 747     else
 748         return FILLED;
 749 }
 750
 751 /* returns the color the ball on (newx,newy) is heading at *----*
 752    checks the four edge points of the square if 1st of all |    |
 753    are a trail (cause it's a lose life situation) and 2nd  |    |
 754    if it's filled so it needs to bounce.                   *____*
 755  */
 756 static inline unsigned int next_hit (int newx, int newy)
 757 {
 758     if ((getpixel (newx, newy) == TRAIL)
 759         || (getpixel (newx, newy + CUBE_SIZE - 1) == TRAIL)
 760         || (getpixel (newx + CUBE_SIZE - 1, newy) == TRAIL)
 761         || (getpixel (newx + CUBE_SIZE - 1, newy + CUBE_SIZE - 1) == TRAIL))
 762         return TRAIL;
 763     else if ((getpixel (newx, newy) == FILLED)
 764              || (getpixel (newx, newy + CUBE_SIZE - 1) == FILLED)
 765              || (getpixel (newx + CUBE_SIZE - 1, newy) == FILLED)
 766              || (getpixel (newx + CUBE_SIZE - 1, newy + CUBE_SIZE - 1) ==
 767                  FILLED))
 768         return FILLED;
 769     else
 770         return EMPTIED;
 771 }
 772
 773 static void die (void)
 774 {
 775     player.lives--;
 776     if (player.lives == 0)
 777         player.gameover = true;
 778     else {
 779         refresh_board ();
 780         rb->splash (HZ, "Crash!");
 781         complete_trail (false);
 782         player.move = MOVE_NO;
 783         player.drawing = false;
 784         player.i = BOARD_W / 2;
 785         player.j = 1;
 786     }
 787 }
 788
 789 /* returns true if the (side) of the block          -***-
 790    starting from (newx,newy) has any filled pixels  *   *
 791                                                     -***-
 792  */
 793 static inline bool line_check_lt (int newx, int newy)
 794 {
 795     return    getpixel (newx, newy + CUBE_SIZE/2-1) == FILLED
 796            && getpixel (newx, newy + CUBE_SIZE/2  ) == FILLED;
 797 }
 798 static inline bool line_check_rt (int newx, int newy)
 799 {
 800     return    getpixel (newx + CUBE_SIZE-1, newy + CUBE_SIZE/2-1) == FILLED
 801            && getpixel (newx + CUBE_SIZE-1, newy + CUBE_SIZE/2  ) == FILLED;
 802 }
 803 static inline bool line_check_up (int newx, int newy)
 804 {
 805     return    getpixel (newx + CUBE_SIZE/2-1, newy) == FILLED
 806            && getpixel (newx + CUBE_SIZE/2  , newy) == FILLED;
 807 }
 808 static inline bool line_check_dn (int newx, int newy)
 809 {
 810     return    getpixel (newx + CUBE_SIZE/2-1, newy + CUBE_SIZE-1) == FILLED
 811            && getpixel (newx + CUBE_SIZE/2  , newy + CUBE_SIZE-1) == FILLED;
 812 }
 813
 814 static inline void move_qix (struct qix *q)
 815 {
 816     int newx, newy;
 817     newx = get_newx (q->x, q->velocity, q->angle);
 818     newy = get_newy (q->y, q->velocity, q->angle);
 819     switch (next_hit (newx, newy))
 820     {
 821         case EMPTIED:
 822             q->x = newx;
 823             q->y = newy;
 824             break;
 825         case FILLED:
 826         {
 827             const int a = q->angle;
 828             q->angle =
 829                 ((a&(DIR_UU|DIR_U))
 830                     ? (line_check_up (newx, newy) ? ((a&(DIR_UU|DIR_U))>>4)
 831                                                   : (a&(DIR_UU|DIR_U)))
 832                     : 0)
 833                 |
 834                 ((a&(DIR_RR|DIR_R))
 835                     ? (line_check_rt (newx, newy) ? ((a&(DIR_RR|DIR_R))>>4)
 836                                                   : (a&(DIR_RR|DIR_R)))
 837                     : 0)
 838                 |
 839                 ((a&(DIR_DD|DIR_D))
 840                     ? (line_check_dn (newx, newy) ? ((a&(DIR_DD|DIR_D))<<4)
 841                                                   : (a&(DIR_DD|DIR_D)))
 842                     : 0)
 843                 |
 844                 ((a&(DIR_LL|DIR_L))
 845                     ? (line_check_lt (newx, newy) ? ((a&(DIR_LL|DIR_L))<<4)
 846                                                   : (a&(DIR_LL|DIR_L)))
 847                     : 0);
 848                 q->x = get_newx (q->x, q->velocity, q->angle);
 849                 q->y = get_newy (q->y, q->velocity, q->angle);
 850             break;
 851         }
 852         case TRAIL:
 853             die();
 854             break;
 855     }
 856 }
 857
 858 /* move the board forward timewise */
 859 static inline void move_board (void)
 860 {
 861     int j, newi, newj;
 862
 863     for (j = 0; j < player.level + STARTING_QIXES; j++)
 864         move_qix (&qixes[j]);
 865     /* move_qix(&black_qix,true); */
 866     if (player.move) {
 867         newi = player.i;
 868         newj = player.j;
 869         switch (player.move) {
 870             case MOVE_UP:
 871                 if (player.j > 1)
 872                     newj--;
 873                 break;
 874             case MOVE_DN:
 875                 if (player.j < BOARD_H - 2)
 876                     newj++;
 877                 break;
 878             case MOVE_LT:
 879                 if (player.i > 0)
 880                     newi--;
 881                 break;
 882             case MOVE_RT:
 883                 if (player.i < BOARD_W - 1)
 884                     newi++;
 885                 break;
 886             default:
 887                 break;
 888         }
 889
 890         if ((player.drawing) && (board[newj][newi] == EMPTIED)) /* continue drawing */
 891             board[newj][newi] = TRAIL;
 892         else if ((player.drawing) && (board[newj][newi] == FILLED)) {   /* finish drawing */
 893             player.move = MOVE_NO;      /* stop moving */
 894             player.drawing = false;
 895             complete_trail (true);
 896         } else if ((board[player.j][player.i] == FILLED)
 897                    && (board[newj][newi] == EMPTIED)) {
 898             /* start drawing */
 899             player.drawing = true;
 900             board[newj][newi] = TRAIL;
 901         /* if the block after next is empty and we're moving onto filled, stop */
 902         } else if ((board[newj][newi] == FILLED)
 903                    && (board[newj + newj-player.j][newi + newi-player.i] == EMPTIED)) {
 904             player.move = MOVE_NO;
 905         }
 906         player.i = newi;
 907         player.j = newj;
 908     }
 909     if (percentage_cache >= difficulty) {               /* finished level */
 910         rb->splashf (HZ * 2, "Level %d finished", player.level+1);
 911         player.score += percentage_cache;
 912         if (player.level < MAX_LEVEL)
 913             player.level++;
 914         init_board ();
 915         refresh_board ();
 916         rb->splash (HZ * 2, "Ready?");
 917     }
 918 }
 919
 920 /* init game's variables */
 921 static void init_game (void)
 922 {
 923     player.level = 0;
 924     player.score = 0;
 925     player.lives = 3;
 926     player.gameover = false;
 927     player.drawing = false;
 928     init_board ();
 929     refresh_board ();
 930     rb->splash (HZ * 2, "Ready?");
 931 }
 932
 933 /* the main menu */
 934 static bool _ingame;
 935 static int xobox_menu_cb(int action, const struct menu_item_ex *this_item)
 936 {
 937     if(action == ACTION_REQUEST_MENUITEM
 938        && !_ingame && ((intptr_t)this_item)==0)
 939         return ACTION_EXIT_MENUITEM;
 940     return action;
 941 }
 942
 943 static int xobox_menu(bool ingame)
 944 {
 945     rb->button_clear_queue();
 946
 947     int selection = 0;
 948     MENUITEM_STRINGLIST(main_menu, "Xobox Menu", xobox_menu_cb,
 949                         "Resume Game", "Start New Game",
 950                         "Speed", "Difficulty",
 951                         "Playback Control", "Quit");
 952     _ingame = ingame;
 953
 954     while (true) {
 955         switch (rb->do_menu(&main_menu, &selection, NULL, false)) {
 956             case 0:
 957                 return 0;
 958             case 1:
 959                 init_game ();
 960                 return 0;
 961             case 2:
 962                 rb->set_int ("Speed", "", UNIT_INT, &speed, NULL, 1, 1, 10, NULL);
 963                 break;
 964             case 3:
 965                 rb->set_int ("Difficulty", "", UNIT_INT, &difficulty, NULL,
 966                             5, 50, 95, NULL);
 967                 break;
 968             case 4:
 969                 playback_control(NULL);
 970                 break;
 971             case 5:
 972                 return 1;
 973             case MENU_ATTACHED_USB:
 974                 return 1;
 975             default:
 976                 break;
 977         }
 978     }
 979 }
 980
 981 /* general keypad handler loop */
 982 static int xobox_loop (void)
 983 {
 984     int button = 0;
 985     bool pause = false;
 986     int end;
 987
 988     if (xobox_menu(false)) {
 989         return PLUGIN_OK;
 990     }
 991
 992     while (!quit) {
 993         end = *rb->current_tick + ((11-speed)*HZ)/100;
 994
 995 #ifdef HAS_BUTTON_HOLD
 996         if (rb->button_hold()) {
 997             pause = true;
 998             rb->splash (HZ, "Paused");
 999         }
1000 #endif
1001
1002         button = rb->button_get_w_tmo (1);
1003         switch (button) {
1004             case UP:
1005             case UP|BUTTON_REPEAT:
1006                 player.move = MOVE_UP;
1007                 break;
1008             case DOWN:
1009             case DOWN|BUTTON_REPEAT:
1010                 player.move = MOVE_DN;
1011                 break;
1012             case LEFT:
1013             case LEFT|BUTTON_REPEAT:
1014                 player.move = MOVE_LT;
1015                 break;
1016             case RIGHT:
1017             case RIGHT|BUTTON_REPEAT:
1018                 player.move = MOVE_RT;
1019                 break;
1020             case PAUSE:
1021                 pause = !pause;
1022                 if (pause)
1023                     rb->splash (HZ, "Paused");
1024                 break;
1025             case QUIT:
1026                 if (!pause) {
1027                     if (xobox_menu(true)) {
1028                         quit = true;
1029                     }
1030                 }
1031                 break;
1032             default:
1033                 if (rb->default_event_handler (button) == SYS_USB_CONNECTED)
1034                     return PLUGIN_USB_CONNECTED;
1035                 break;
1036         }
1037         if (!pause) {
1038             move_board ();
1039             refresh_board ();
1040         }
1041         if (player.gameover) {
1042             rb->splash (HZ, "Game Over!");
1043             if (xobox_menu(false)) {
1044                 quit = true;
1045             }
1046         }
1047
1048         if (TIME_BEFORE(*rb->current_tick, end))
1049             rb->sleep (end - *rb->current_tick);
1050         else
1051             rb->yield ();
1052
1053     }                           /* end while */
1054     return PLUGIN_OK;           /* for no warnings on compiling */
1055 }
1056
1057 /* plugin main procedure */
1058 enum plugin_status plugin_start (const void *parameter)
1059 {
1060     int ret = PLUGIN_OK;
1061
1062     (void) parameter;
1063
1064     rb->lcd_setfont (FONT_SYSFIXED);
1065 #if LCD_DEPTH>=2
1066     rb->lcd_set_backdrop(NULL);
1067 #endif
1068
1069     /* Turn off backlight timeout */
1070     backlight_force_on(); /* backlight control in lib/helper.c */
1071
1072     randomize ();
1073     ret = xobox_loop ();
1074
1075     /* Turn on backlight timeout (revert to settings) */
1076     backlight_use_settings(); /* backlight control in lib/helper.c */
1077     rb->lcd_setfont (FONT_UI);
1078
1079     return ret;
1080 }