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