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