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