We have a 3.9 release, update builds.pm
[maemo-rb.git] / apps / plugins / xobox.c
blob157f3c5d87d07fb8ccec694c4d31f84e2aa90ef1
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2006 Eli Sherer
11 * 2007 Antoine Cellerier
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.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 ****************************************************************************/
23 #include "plugin.h"
24 #include "lib/helper.h"
25 #include "lib/playback_control.h"
29 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
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
38 #define RC_QUIT BUTTON_RC_STOP
40 #elif (CONFIG_KEYPAD == ARCHOS_AV300_PAD)
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
49 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
50 (CONFIG_KEYPAD == IPOD_3G_PAD) || \
51 (CONFIG_KEYPAD == IPOD_1G2G_PAD)
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
62 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
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
71 #elif (CONFIG_KEYPAD == GIGABEAT_PAD)
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
80 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || \
81 (CONFIG_KEYPAD == SANSA_C200_PAD)
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
90 #elif (CONFIG_KEYPAD == SANSA_CLIP_PAD)
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
99 #elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
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
108 #elif (CONFIG_KEYPAD == SANSA_M200_PAD)
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
117 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
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
126 #elif CONFIG_KEYPAD == RECORDER_PAD
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
135 #elif CONFIG_KEYPAD == ONDIO_PAD
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
144 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD)
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
153 #elif (CONFIG_KEYPAD == MROBE100_PAD)
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
162 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
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
171 #elif CONFIG_KEYPAD == COWON_D2_PAD
173 #define QUIT BUTTON_POWER
175 #elif CONFIG_KEYPAD == IAUDIO67_PAD
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
184 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
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
193 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
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
202 #elif CONFIG_KEYPAD == PHILIPS_HDD6330_PAD
204 #define QUIT BUTTON_POWER
205 #define LEFT BUTTON_PREV
206 #define RIGHT BUTTON_NEXT
207 #define UP BUTTON_UP
208 #define DOWN BUTTON_DOWN
209 #define PAUSE BUTTON_MENU
211 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
213 #define QUIT BUTTON_POWER
214 #define LEFT BUTTON_PREV
215 #define RIGHT BUTTON_NEXT
216 #define UP BUTTON_UP
217 #define DOWN BUTTON_DOWN
218 #define PAUSE BUTTON_MENU
220 #elif CONFIG_KEYPAD == ONDAVX747_PAD || \
221 CONFIG_KEYPAD == ONDAVX777_PAD || \
222 CONFIG_KEYPAD == MROBE500_PAD
224 #define QUIT BUTTON_POWER
226 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
228 #define QUIT BUTTON_PLAY
229 #define LEFT BUTTON_LEFT
230 #define RIGHT BUTTON_RIGHT
231 #define UP BUTTON_UP
232 #define DOWN BUTTON_DOWN
233 #define PAUSE BUTTON_FFWD
235 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
237 #define QUIT BUTTON_REC
238 #define LEFT BUTTON_PREV
239 #define RIGHT BUTTON_NEXT
240 #define UP BUTTON_UP
241 #define DOWN BUTTON_DOWN
242 #define PAUSE BUTTON_PLAY
244 #elif CONFIG_KEYPAD == MPIO_HD200_PAD
246 #define QUIT (BUTTON_REC|BUTTON_PLAY)
247 #define LEFT BUTTON_VOL_DOWN
248 #define RIGHT BUTTON_VOL_UP
249 #define UP BUTTON_REW
250 #define DOWN BUTTON_FF
251 #define PAUSE BUTTON_PLAY
253 #elif CONFIG_KEYPAD == MPIO_HD300_PAD
255 #define QUIT BUTTON_REC
256 #define LEFT BUTTON_MENU
257 #define RIGHT BUTTON_ENTER
258 #define UP BUTTON_UP
259 #define DOWN BUTTON_DOWN
260 #define PAUSE BUTTON_PLAY
262 #else
263 #error No keymap defined!
264 #endif
266 #ifdef HAVE_TOUCHSCREEN
267 #ifndef QUIT
268 #define QUIT BUTTON_TOPLEFT
269 #endif
270 #ifndef LEFT
271 #define LEFT BUTTON_MIDLEFT
272 #endif
273 #ifndef RIGHT
274 #define RIGHT BUTTON_MIDRIGHT
275 #endif
276 #ifndef UP
277 #define UP BUTTON_TOPMIDDLE
278 #endif
279 #ifndef DOWN
280 #define DOWN BUTTON_BOTTOMMIDDLE
281 #endif
282 #ifndef PAUSE
283 #define PAUSE BUTTON_CENTER
284 #endif
285 #endif
287 #define MOVE_NO 0 /* player movement */
288 #define MOVE_UP 1 /* 1 */
289 #define MOVE_DN 2 /* 3 0 4 */
290 #define MOVE_LT 3 /* 2 */
291 #define MOVE_RT 4
293 /* ball movement (12 ways) */
294 /* UUL UR */
295 /* UL UR */
296 /* ULL . URR */
297 /* DLL DRR */
298 /* DL DR */
299 /* DDL DDR */
301 #define DIR_UU (1<<7)
302 #define DIR_U (1<<6)
303 #define DIR_RR (1<<5)
304 #define DIR_R (1<<4)
305 #define DIR_DD (1<<3)
306 #define DIR_D (1<<2)
307 #define DIR_LL (1<<1)
308 #define DIR_L (1<<0)
310 #define MOVE_UUR ( DIR_UU | DIR_R )
311 #define MOVE_UR ( DIR_U | DIR_R )
312 #define MOVE_URR ( DIR_U | DIR_RR )
313 #define MOVE_DRR ( DIR_D | DIR_RR )
314 #define MOVE_DR ( DIR_D | DIR_R )
315 #define MOVE_DDR ( DIR_DD | DIR_R )
316 #define MOVE_DDL ( DIR_DD | DIR_L )
317 #define MOVE_DL ( DIR_D | DIR_L )
318 #define MOVE_DLL ( DIR_D | DIR_LL )
319 #define MOVE_ULL ( DIR_U | DIR_LL )
320 #define MOVE_UL ( DIR_U | DIR_L )
321 #define MOVE_UUL ( DIR_UU | DIR_L )
323 #if (LCD_WIDTH>112) && (LCD_HEIGHT>64)
324 # define CUBE_SIZE 8 /* 8x22=176 */
325 # define pos(a) ((a)>>3)
326 #else
327 # define CUBE_SIZE 4
328 # define pos(a) ((a)>>2)
329 #endif
331 #define STARTING_QIXES 2
332 #define MAX_LEVEL 10
333 #define MAX_QIXES MAX_LEVEL+STARTING_QIXES
334 #define BOARD_W ((int)(LCD_WIDTH/CUBE_SIZE))
335 #define BOARD_H ((int)(LCD_HEIGHT/CUBE_SIZE))
336 #define BOARD_X (LCD_WIDTH-BOARD_W*CUBE_SIZE)/2
337 #define BOARD_Y (LCD_HEIGHT-BOARD_H*CUBE_SIZE)/2
339 #ifdef HAVE_LCD_COLOR
340 #define CLR_RED LCD_RGBPACK(255,0,0) /* used to imply danger */
341 #define CLR_LTBLUE LCD_RGBPACK(125, 145, 180) /* used for frame and filling */
342 #define PLR_COL LCD_WHITE /* color used for the player */
343 #elif LCD_DEPTH>=2
344 #define CLR_RED LCD_DARKGRAY /* used to imply danger */
345 #define CLR_LTBLUE LCD_LIGHTGRAY /* used for frame and filling */
346 #define PLR_COL LCD_BLACK /* color used for the player */
347 #endif
349 #if LCD_DEPTH>=2
350 #define EMPTIED LCD_BLACK /* empty spot */
351 #define FILLED CLR_LTBLUE /* filled spot */
352 #define TRAIL CLR_RED /* the red trail of the player */
353 #define QIX LCD_WHITE
354 #else
355 #define EMPTIED 0
356 #define FILLED 1
357 #define TRAIL 2
358 #define QIX 3
359 #endif
360 #define UNCHECKED 0
361 #define CHECKED 1
362 #define PAINTED -1
363 #define PIC_QIX 0
364 #define PIC_PLAYER 1
366 /* The time (in ms) for one iteration through the game loop - decrease this
367 to speed up the game - note that current_tick is (currently) only accurate
368 to 10ms.
370 static int speed = 6; /* CYCLETIME = (11-speed)*10 ms */
371 static int difficulty = 75; /* Percentage of screen that needs to be filled
372 * in order to win the game */
374 static bool quit = false;
376 static unsigned int board[BOARD_H][BOARD_W];
377 static int testboard[BOARD_H][BOARD_W];
379 #if CUBE_SIZE == 8
381 00011000 0x18 - 11100111 0xe7
382 00111100 0x3c - 11100111 0xe7
383 01111110 0x7e - 11000011 0xc3
384 11111111 0xff - 00000000 0x00
385 11111111 0xff - 00000000 0x00
386 01111110 0x7e - 11000011 0xc3
387 00111100 0x3c - 11100111 0xe7
388 00011000 0x18 - 11100111 0xe7
390 const unsigned char pics[2][8] = {
391 {0x18, 0x3c, 0x7e, 0xff, 0xff, 0x7e, 0x3c, 0x18}, /* Alien (QIX) */
392 {0xe7, 0xe7, 0xc3, 0x00, 0x00, 0xc3, 0xe7, 0xe7} /* Player (XONIX) */
394 #elif CUBE_SIZE == 4
396 0110 0x6 - 1001 0x9
397 1111 0xf - 0110 0x6
398 1111 0xf - 0110 0x6
399 0110 0x6 - 1001 0x9
401 const unsigned char pics[2][4] = {
402 {0x6, 0xf, 0xf, 0x6}, /* Alien (QIX) */
403 {0x9, 0x6, 0x6, 0x9} /* Player (XONIX) */
405 #else
406 #error Incorrect CUBE_SIZE value.
407 #endif
409 static struct qix
411 int velocity; /* velocity */
412 int x, y; /* position on screen */
413 int angle; /* angle */
414 } qixes[MAX_QIXES]; /* black_qix */
416 static struct splayer
418 int i, j; /* position on board */
419 int move, score, level, lives;
420 bool drawing;
421 bool gameover;
422 } player;
424 static int percentage_cache;
426 /*************************** STACK STUFF **********************/
428 /* the stack */
429 #define STACK_SIZE (2*BOARD_W*BOARD_H)
430 static struct pos
432 int x, y; /* position on board */
433 } stack[STACK_SIZE];
434 static int stackPointer;
436 static inline bool pop (struct pos *p)
438 if (stackPointer > 0) {
439 p->x = stack[stackPointer].x;
440 p->y = stack[stackPointer].y;
441 stackPointer--;
442 return true;
443 } else
444 return false; /* SE */
447 static inline bool push (struct pos *p)
449 if (stackPointer < STACK_SIZE - 1) {
450 stackPointer++;
451 stack[stackPointer].x = p->x;
452 stack[stackPointer].y = p->y;
453 return true;
454 } else
455 return false; /* SOF */
458 static inline void emptyStack (void)
460 stackPointer = 0;
463 /*********************** END OF STACK STUFF *********************/
465 /* calculate the new x coordinate of the ball according to angle and speed */
466 static inline int get_newx (int x, int len, int deg)
468 if (deg & DIR_R)
469 return x + len;
470 else if (deg & DIR_L)
471 return x - len;
472 else if (deg & DIR_RR)
473 return x + len * 2;
474 else /* (def & DIR_LL) */
475 return x - len * 2;
478 /* calculate the new y coordinate of the ball according to angle and speed */
479 static inline int get_newy (int y, int len, int deg)
481 if (deg & DIR_D)
482 return y + len;
483 else if (deg & DIR_U)
484 return y - len;
485 else if (deg & DIR_DD)
486 return y + len * 2;
487 else /* (deg & DIR_UU) */
488 return y - len * 2;
491 /* make random function get it's value from the device ticker */
492 static inline void randomize (void)
494 rb->srand (*rb->current_tick);
497 /* get a random number between 0 and range-1 */
498 static int t_rand (int range)
500 return rb->rand () % range;
503 /* initializes the test help board */
504 static void init_testboard (void)
506 int j; /* testboard */
507 for (j = 0; j < BOARD_H; j++)
508 /* UNCHEKED == (int)0 */
509 rb->memset( testboard[j], 0, BOARD_W * sizeof( int ) );
512 /* initializes the game board on with the player,qix's and black qix */
513 static void init_board (void)
515 int i, j;
516 for (j = 0; j < BOARD_H; j++)
517 for (i = 0; i < BOARD_W; i++) { /* make a nice cyan frame */
518 if ((i == 0) || (j <= 1) || (i == BOARD_W - 1)
519 || (j >= BOARD_H - 2))
520 board[j][i] = FILLED;
521 else
522 board[j][i] = EMPTIED;
525 /* (level+2) is the number of qixes */
526 for (j = 0; j < player.level + STARTING_QIXES; j++) {
527 qixes[j].velocity = t_rand (2) + 1; /* 1 or 2 pix-per-sec */
529 /* not on frame */
530 qixes[j].x = CUBE_SIZE*2 + 2*t_rand (((BOARD_W-4)*CUBE_SIZE)/2);
531 qixes[j].y = CUBE_SIZE*2 + 2*t_rand (((BOARD_H-4)*CUBE_SIZE)/2);
533 const int angle_table[] = {
534 MOVE_UUR, MOVE_UR, MOVE_URR, MOVE_DRR, MOVE_DR, MOVE_DDR,
535 MOVE_UUL, MOVE_UL, MOVE_ULL, MOVE_DLL, MOVE_DL, MOVE_DDL };
536 qixes[j].angle = angle_table[t_rand (12)];
537 #if CUBE_SIZE == 4
538 /* Work arround a nasty bug. FIXME */
539 if( qixes[j].angle & (DIR_LL|DIR_RR|DIR_UU|DIR_DD) )
540 qixes[j].velocity = 1;
541 #endif
543 /*black_qix.velocity=1;
544 black_qix.x=BOARD_X+(BOARD_W*CUBE_SIZE)/2-CUBE_SIZE/2;
545 black_qix.y=BOARD_Y+(BOARD_H*CUBE_SIZE)-CUBE_SIZE-CUBE_SIZE/2;
546 black_qix.angle=MOVE_UR; */
547 player.move = MOVE_NO;
548 player.drawing = false;
549 player.i = BOARD_W / 2;
550 player.j = 1;
552 percentage_cache = 0;
555 /* calculates the percentage of the screen filling */
556 static int percentage (void)
558 int i, j, filled = 0;
559 for (j = 2; j < BOARD_H - 2; j++)
560 for (i = 1; i < BOARD_W - 1; i++)
561 if (board[j][i] == FILLED)
562 filled++;
563 return (filled * 100) / ((BOARD_W - 2) * (BOARD_H - 4));
566 /* draw the board on with all the game figures */
567 static void refresh_board (void)
569 int i, j;
570 int x;
572 #if LCD_DEPTH>=2
573 rb->lcd_set_background (LCD_BLACK);
574 #endif
575 rb->lcd_clear_display ();
576 for (j = 0; j < BOARD_H; j++)
578 unsigned last_color = board[j][0];
579 int last_i = 0;
580 for (i = 1; i < BOARD_W; i++) {
581 if( last_color != board[j][i] )
583 #if LCD_DEPTH>=2
584 rb->lcd_set_foreground (last_color);
585 #else
586 if (last_color != EMPTIED)
587 #endif
588 rb->lcd_fillrect (BOARD_X + CUBE_SIZE * (last_i),
589 BOARD_Y + CUBE_SIZE * j,
590 CUBE_SIZE * (i - last_i), CUBE_SIZE );
591 last_color = board[j][i];
592 last_i = i;
595 #if LCD_DEPTH>=2
596 rb->lcd_set_foreground (last_color);
597 #else
598 if (last_color != EMPTIED)
599 #endif
600 rb->lcd_fillrect (BOARD_X + CUBE_SIZE * (last_i),
601 BOARD_Y + CUBE_SIZE * j,
602 CUBE_SIZE * (i - last_i), CUBE_SIZE);
605 #if LCD_DEPTH>=2
606 rb->lcd_set_foreground (LCD_BLACK);
607 rb->lcd_set_background (CLR_LTBLUE);
608 #else
609 rb->lcd_set_drawmode (DRMODE_COMPLEMENT);
610 #endif
611 rb->lcd_putsxyf (BOARD_X, BOARD_Y, "Level %d", player.level + 1);
612 rb->lcd_putsxyf (BOARD_X + CUBE_SIZE * BOARD_W - 24, BOARD_Y, "%d%%",
613 percentage_cache);
614 rb->lcd_putsxyf (BOARD_X, BOARD_Y + CUBE_SIZE * BOARD_H - 8, "Score: %d",
615 player.score);
616 #if LCD_DEPTH>=2
617 x = BOARD_X + CUBE_SIZE * BOARD_W - 60;
618 #else
619 x = BOARD_X + CUBE_SIZE * BOARD_W - 40;
620 #endif
621 rb->lcd_putsxyf (x, BOARD_Y + CUBE_SIZE * BOARD_H - 8,
622 (player.lives != 1) ? "%d Lives" : "%d Life", player.lives);
624 #if LCD_DEPTH>=2
625 rb->lcd_set_foreground (PLR_COL);
626 rb->lcd_set_background (board[player.j][player.i]);
627 #endif
628 rb->lcd_mono_bitmap (pics[PIC_PLAYER], player.i * CUBE_SIZE + BOARD_X,
629 player.j * CUBE_SIZE + BOARD_Y, CUBE_SIZE, CUBE_SIZE);
631 #if LCD_DEPTH>=2
632 rb->lcd_set_background (EMPTIED);
633 rb->lcd_set_foreground (LCD_WHITE);
634 rb->lcd_set_drawmode (DRMODE_FG);
635 #else
636 rb->lcd_set_drawmode (DRMODE_FG);
637 #endif
638 for (j = 0; j < player.level + STARTING_QIXES; j++)
639 rb->lcd_mono_bitmap (pics[PIC_QIX], qixes[j].x + BOARD_X,
640 qixes[j].y + BOARD_Y, CUBE_SIZE, CUBE_SIZE);
641 #if LCD_DEPTH>=2
642 rb->lcd_set_foreground (LCD_BLACK);
643 #endif
644 rb->lcd_set_drawmode (DRMODE_SOLID);
646 rb->lcd_update ();
649 static inline int infested_area (int i, int j, int v)
651 struct pos p;
652 p.x = i;
653 p.y = j;
654 emptyStack ();
655 if (!push (&p))
656 return -1;
657 while (pop (&p)) {
658 if (testboard[p.y][p.x] == v) continue;
659 if (testboard[p.y][p.x] > UNCHECKED)
660 return 1; /* This area was previously flagged as infested */
661 testboard[p.y][p.x] = v;
662 if (board[p.y][p.x] == QIX)
663 return 1; /* Infested area */
665 struct pos p1 = { p.x+1, p.y };
666 if ((p1.x < BOARD_W)
667 && (board[p1.y][p1.x] != FILLED)
668 && (!push (&p1)))
669 return -1;
672 struct pos p1 = { p.x-1, p.y };
673 if ((p1.x >= 0)
674 && (board[p1.y][p1.x] != FILLED)
675 && (!push (&p1)))
676 return -1;
679 struct pos p1 = { p.x, p.y+1 };
680 if ((p1.y < BOARD_H)
681 && (board[p1.y][p1.x] != FILLED)
682 && (!push (&p1)))
683 return -1;
686 struct pos p1 = { p.x, p.y-1 };
687 if ((p1.y >= 0)
688 && (board[p1.y][p1.x] != FILLED)
689 && (!push (&p1)))
690 return -1;
693 return 0;
696 static inline int fill_area (int i, int j)
698 struct pos p;
699 p.x = i;
700 p.y = j;
701 int v = testboard[p.y][p.x];
702 emptyStack ();
703 if (!push (&p))
704 return -1;
705 while (pop (&p)) {
706 board[p.y][p.x] = FILLED;
707 testboard[p.y][p.x] = PAINTED;
709 struct pos p1 = { p.x+1, p.y };
710 if ((p1.x < BOARD_W)
711 && (testboard[p1.y][p1.x] == v)
712 && (!push (&p1)))
713 return -1;
716 struct pos p1 = { p.x-1, p.y };
717 if ((p1.x >= 0)
718 && (testboard[p1.y][p1.x] == v)
719 && (!push (&p1)))
720 return -1;
723 struct pos p1 = { p.x, p.y+1 };
724 if ((p1.y < BOARD_H)
725 && (testboard[p1.y][p1.x] == v)
726 && (!push (&p1)))
727 return -1;
730 struct pos p1 = { p.x, p.y-1 };
731 if ((p1.y >= 0)
732 && (testboard[p1.y][p1.x] == v)
733 && (!push (&p1)))
734 return -1;
737 return 0;
741 /* take care of stuff after xonix has landed on a filled spot */
742 static void complete_trail (int fill)
744 int i, j, ret;
745 for (j = 0; j < BOARD_H; j++) {
746 for (i = 0; i < BOARD_W; i++) {
747 if (board[j][i] == TRAIL) {
748 if (fill)
749 board[j][i] = FILLED;
750 else
751 board[j][i] = EMPTIED;
756 if (fill) {
757 int v = CHECKED;
758 for (i = 0; i < player.level + STARTING_QIXES; i++) /* add qixes to board */
759 board[pos(qixes[i].y - BOARD_Y)]
760 [pos(qixes[i].x - BOARD_X)] = QIX;
762 init_testboard();
763 for (j = 1; j < BOARD_H - 1; j++) {
764 for (i = 0; i < BOARD_W - 0; i++) {
765 if (board[j][i] != FILLED) {
766 ret = infested_area (i, j, v);
767 if (ret < 0 || ( ret == 0 && fill_area (i, j) ) )
768 quit = true;
769 v++;
774 for (i = 0; i < player.level + STARTING_QIXES; i++) /* add qixes to board */
775 board[pos(qixes[i].y - BOARD_Y)]
776 [pos(qixes[i].x - BOARD_X)] = EMPTIED;
777 percentage_cache = percentage();
780 rb->button_clear_queue();
783 /* returns the color the real pixel(x,y) on the lcd is pointing at */
784 static inline unsigned int getpixel (int x, int y)
786 const int a = pos (x - BOARD_X), b = pos (y - BOARD_Y);
787 if ((a > 0) && (a < BOARD_W) && (b > 0) && (b < BOARD_H)) /* if inside board */
788 return board[b][a];
789 else
790 return FILLED;
793 /* returns the color the ball on (newx,newy) is heading at *----*
794 checks the four edge points of the square if 1st of all | |
795 are a trail (cause it's a lose life situation) and 2nd | |
796 if it's filled so it needs to bounce. *____*
798 static inline unsigned int next_hit (int newx, int newy)
800 if ((getpixel (newx, newy) == TRAIL)
801 || (getpixel (newx, newy + CUBE_SIZE - 1) == TRAIL)
802 || (getpixel (newx + CUBE_SIZE - 1, newy) == TRAIL)
803 || (getpixel (newx + CUBE_SIZE - 1, newy + CUBE_SIZE - 1) == TRAIL))
804 return TRAIL;
805 else if ((getpixel (newx, newy) == FILLED)
806 || (getpixel (newx, newy + CUBE_SIZE - 1) == FILLED)
807 || (getpixel (newx + CUBE_SIZE - 1, newy) == FILLED)
808 || (getpixel (newx + CUBE_SIZE - 1, newy + CUBE_SIZE - 1) ==
809 FILLED))
810 return FILLED;
811 else
812 return EMPTIED;
815 static void die (void)
817 player.lives--;
818 if (player.lives == 0)
819 player.gameover = true;
820 else {
821 refresh_board ();
822 rb->splash (HZ, "Crash!");
823 complete_trail (false);
824 player.move = MOVE_NO;
825 player.drawing = false;
826 player.i = BOARD_W / 2;
827 player.j = 1;
831 /* returns true if the (side) of the block -***-
832 starting from (newx,newy) has any filled pixels * *
833 -***-
835 static inline bool line_check_lt (int newx, int newy)
837 return getpixel (newx, newy + CUBE_SIZE/2-1) == FILLED
838 && getpixel (newx, newy + CUBE_SIZE/2 ) == FILLED;
840 static inline bool line_check_rt (int newx, int newy)
842 return getpixel (newx + CUBE_SIZE-1, newy + CUBE_SIZE/2-1) == FILLED
843 && getpixel (newx + CUBE_SIZE-1, newy + CUBE_SIZE/2 ) == FILLED;
845 static inline bool line_check_up (int newx, int newy)
847 return getpixel (newx + CUBE_SIZE/2-1, newy) == FILLED
848 && getpixel (newx + CUBE_SIZE/2 , newy) == FILLED;
850 static inline bool line_check_dn (int newx, int newy)
852 return getpixel (newx + CUBE_SIZE/2-1, newy + CUBE_SIZE-1) == FILLED
853 && getpixel (newx + CUBE_SIZE/2 , newy + CUBE_SIZE-1) == FILLED;
856 static inline void move_qix (struct qix *q)
858 int newx, newy;
859 newx = get_newx (q->x, q->velocity, q->angle);
860 newy = get_newy (q->y, q->velocity, q->angle);
861 switch (next_hit (newx, newy))
863 case EMPTIED:
864 q->x = newx;
865 q->y = newy;
866 break;
867 case FILLED:
869 const int a = q->angle;
870 q->angle =
871 ((a&(DIR_UU|DIR_U))
872 ? (line_check_up (newx, newy) ? ((a&(DIR_UU|DIR_U))>>4)
873 : (a&(DIR_UU|DIR_U)))
874 : 0)
876 ((a&(DIR_RR|DIR_R))
877 ? (line_check_rt (newx, newy) ? ((a&(DIR_RR|DIR_R))>>4)
878 : (a&(DIR_RR|DIR_R)))
879 : 0)
881 ((a&(DIR_DD|DIR_D))
882 ? (line_check_dn (newx, newy) ? ((a&(DIR_DD|DIR_D))<<4)
883 : (a&(DIR_DD|DIR_D)))
884 : 0)
886 ((a&(DIR_LL|DIR_L))
887 ? (line_check_lt (newx, newy) ? ((a&(DIR_LL|DIR_L))<<4)
888 : (a&(DIR_LL|DIR_L)))
889 : 0);
890 q->x = get_newx (q->x, q->velocity, q->angle);
891 q->y = get_newy (q->y, q->velocity, q->angle);
892 break;
894 case TRAIL:
895 die();
896 break;
900 /* move the board forward timewise */
901 static inline void move_board (void)
903 int j, newi, newj;
905 for (j = 0; j < player.level + STARTING_QIXES; j++)
906 move_qix (&qixes[j]);
907 /* move_qix(&black_qix,true); */
908 if (player.move) {
909 newi = player.i;
910 newj = player.j;
911 switch (player.move) {
912 case MOVE_UP:
913 if (player.j > 1)
914 newj--;
915 break;
916 case MOVE_DN:
917 if (player.j < BOARD_H - 2)
918 newj++;
919 break;
920 case MOVE_LT:
921 if (player.i > 0)
922 newi--;
923 break;
924 case MOVE_RT:
925 if (player.i < BOARD_W - 1)
926 newi++;
927 break;
928 default:
929 break;
932 if ((player.drawing) && (board[newj][newi] == EMPTIED)) /* continue drawing */
933 board[newj][newi] = TRAIL;
934 else if ((player.drawing) && (board[newj][newi] == FILLED)) { /* finish drawing */
935 player.move = MOVE_NO; /* stop moving */
936 player.drawing = false;
937 complete_trail (true);
938 } else if ((board[player.j][player.i] == FILLED)
939 && (board[newj][newi] == EMPTIED)) {
940 /* start drawing */
941 player.drawing = true;
942 board[newj][newi] = TRAIL;
943 /* if the block after next is empty and we're moving onto filled, stop */
944 } else if ((board[newj][newi] == FILLED)
945 && (board[newj + newj-player.j][newi + newi-player.i] == EMPTIED)) {
946 player.move = MOVE_NO;
948 player.i = newi;
949 player.j = newj;
951 if (percentage_cache >= difficulty) { /* finished level */
952 refresh_board ();
953 rb->splashf (HZ * 2, "Level %d finished", player.level+1);
954 player.score += percentage_cache;
955 if (player.level < MAX_LEVEL)
956 player.level++;
957 init_board ();
958 refresh_board ();
959 rb->button_clear_queue();
960 rb->splash (HZ * 2, "Ready?");
964 /* init game's variables */
965 static void init_game (void)
967 player.level = 0;
968 player.score = 0;
969 player.lives = 3;
970 player.gameover = false;
971 player.drawing = false;
972 init_board ();
973 refresh_board ();
974 rb->splash (HZ * 2, "Ready?");
977 /* the main menu */
978 static bool _ingame;
979 static int xobox_menu_cb(int action, const struct menu_item_ex *this_item)
981 if(action == ACTION_REQUEST_MENUITEM
982 && !_ingame && ((intptr_t)this_item)==0)
983 return ACTION_EXIT_MENUITEM;
984 return action;
987 static int xobox_menu(bool ingame)
989 rb->button_clear_queue();
991 int selection = 0;
992 MENUITEM_STRINGLIST(main_menu, "Xobox Menu", xobox_menu_cb,
993 "Resume Game", "Start New Game",
994 "Speed", "Difficulty",
995 "Playback Control", "Quit");
996 _ingame = ingame;
998 while (true) {
999 switch (rb->do_menu(&main_menu, &selection, NULL, false)) {
1000 case 0:
1001 return 0;
1002 case 1:
1003 init_game ();
1004 return 0;
1005 case 2:
1006 rb->set_int ("Speed", "", UNIT_INT, &speed, NULL, 1, 1, 10, NULL);
1007 break;
1008 case 3:
1009 rb->set_int ("Difficulty", "", UNIT_INT, &difficulty, NULL,
1010 5, 50, 95, NULL);
1011 break;
1012 case 4:
1013 playback_control(NULL);
1014 break;
1015 case 5:
1016 return 1;
1017 case MENU_ATTACHED_USB:
1018 return 1;
1019 default:
1020 break;
1025 /* general keypad handler loop */
1026 static int xobox_loop (void)
1028 int button = 0;
1029 bool pause = false;
1030 int end;
1032 if (xobox_menu(false)) {
1033 return PLUGIN_OK;
1036 while (!quit) {
1037 end = *rb->current_tick + ((11-speed)*HZ)/100;
1039 #ifdef HAS_BUTTON_HOLD
1040 if (rb->button_hold()) {
1041 pause = true;
1042 rb->splash (HZ, "Paused");
1044 #endif
1046 button = rb->button_get_w_tmo (1);
1047 switch (button) {
1048 case UP:
1049 case UP|BUTTON_REPEAT:
1050 player.move = MOVE_UP;
1051 break;
1052 case DOWN:
1053 case DOWN|BUTTON_REPEAT:
1054 player.move = MOVE_DN;
1055 break;
1056 case LEFT:
1057 case LEFT|BUTTON_REPEAT:
1058 player.move = MOVE_LT;
1059 break;
1060 case RIGHT:
1061 case RIGHT|BUTTON_REPEAT:
1062 player.move = MOVE_RT;
1063 break;
1064 case PAUSE:
1065 pause = !pause;
1066 if (pause)
1067 rb->splash (HZ, "Paused");
1068 break;
1069 case QUIT:
1070 if (!pause) {
1071 if (xobox_menu(true)) {
1072 quit = true;
1075 break;
1076 default:
1077 if (rb->default_event_handler (button) == SYS_USB_CONNECTED)
1078 return PLUGIN_USB_CONNECTED;
1079 break;
1081 if (!pause) {
1082 move_board ();
1083 refresh_board ();
1085 if (player.gameover) {
1086 rb->splash (HZ, "Game Over!");
1087 if (xobox_menu(false)) {
1088 quit = true;
1092 if (TIME_BEFORE(*rb->current_tick, end))
1093 rb->sleep (end - *rb->current_tick);
1094 else
1095 rb->yield ();
1097 } /* end while */
1098 return PLUGIN_OK; /* for no warnings on compiling */
1101 /* plugin main procedure */
1102 enum plugin_status plugin_start (const void *parameter)
1104 int ret = PLUGIN_OK;
1106 (void) parameter;
1108 rb->lcd_setfont (FONT_SYSFIXED);
1109 #if LCD_DEPTH>=2
1110 rb->lcd_set_backdrop(NULL);
1111 #endif
1113 /* Turn off backlight timeout */
1114 backlight_ignore_timeout();
1116 randomize ();
1117 ret = xobox_loop ();
1119 /* Turn on backlight timeout (revert to settings) */
1120 backlight_use_settings();
1121 rb->lcd_setfont (FONT_UI);
1123 return ret;