| blob | f932e4563a051bfa931bbabbef4dd6e80e1a2fd3 |
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2005, 2006 Ben Basha (Paprica)
11 * Copyright (C) 2009 Karl Kurbjun
12 * check_lines is based off an explanation and expanded math presented by Paul
13 * Bourke: http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
19 *
20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
21 * KIND, either express or implied.
22 *
23 ****************************************************************************/
42 #endif
44 PLUGIN_HEADER
47 /*
48 *
49 * Keymaps
50 *
51 */
53 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
54 (CONFIG_KEYPAD == IRIVER_H300_PAD)
56 #define QUIT BUTTON_OFF
57 #define LEFT BUTTON_LEFT
58 #define RIGHT BUTTON_RIGHT
59 #define SELECT BUTTON_SELECT
60 #define UP BUTTON_UP
61 #define DOWN BUTTON_DOWN
62 #define RC_QUIT BUTTON_RC_STOP
64 #elif CONFIG_KEYPAD == ONDIO_PAD
66 #define QUIT BUTTON_OFF
67 #define LEFT BUTTON_LEFT
68 #define RIGHT BUTTON_RIGHT
69 #define SELECT BUTTON_MENU
70 #define UP BUTTON_UP
71 #define DOWN BUTTON_DOWN
73 #elif CONFIG_KEYPAD == RECORDER_PAD
74 #define QUIT BUTTON_OFF
75 #define LEFT BUTTON_LEFT
76 #define RIGHT BUTTON_RIGHT
77 #define SELECT BUTTON_PLAY
78 #define UP BUTTON_UP
79 #define DOWN BUTTON_DOWN
81 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
82 #define QUIT BUTTON_OFF
83 #define LEFT BUTTON_LEFT
84 #define RIGHT BUTTON_RIGHT
85 #define SELECT BUTTON_SELECT
86 #define UP BUTTON_UP
87 #define DOWN BUTTON_DOWN
89 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
90 (CONFIG_KEYPAD == IPOD_3G_PAD) || \
91 (CONFIG_KEYPAD == IPOD_1G2G_PAD)
92 #define QUIT BUTTON_MENU
93 #define LEFT BUTTON_LEFT
94 #define RIGHT BUTTON_RIGHT
95 #define SELECT BUTTON_SELECT
96 #define UP BUTTON_SCROLL_BACK
97 #define DOWN BUTTON_SCROLL_FWD
98 #define SCROLL_FWD(x) ((x) & BUTTON_SCROLL_FWD)
99 #define SCROLL_BACK(x) ((x) & BUTTON_SCROLL_BACK)
101 #elif (CONFIG_KEYPAD == GIGABEAT_PAD)
102 #define QUIT BUTTON_POWER
103 #define LEFT BUTTON_LEFT
104 #define RIGHT BUTTON_RIGHT
105 #define SELECT BUTTON_SELECT
106 #define UP BUTTON_UP
107 #define DOWN BUTTON_DOWN
109 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
110 #define QUIT BUTTON_POWER
111 #define LEFT BUTTON_LEFT
112 #define RIGHT BUTTON_RIGHT
113 #define SELECT BUTTON_PLAY
114 #define UP BUTTON_UP
115 #define DOWN BUTTON_DOWN
117 #elif (CONFIG_KEYPAD == SANSA_E200_PAD)
118 #define QUIT BUTTON_POWER
119 #define LEFT BUTTON_LEFT
120 #define RIGHT BUTTON_RIGHT
121 #define SELECT BUTTON_SELECT
122 #define UP BUTTON_UP
123 #define DOWN BUTTON_DOWN
124 #define SCROLL_FWD(x) ((x) & BUTTON_SCROLL_FWD)
125 #define SCROLL_BACK(x) ((x) & BUTTON_SCROLL_BACK)
128 #elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
129 #define QUIT (BUTTON_HOME|BUTTON_REPEAT)
130 #define LEFT BUTTON_LEFT
131 #define RIGHT BUTTON_RIGHT
132 #define SELECT BUTTON_SELECT
133 #define UP BUTTON_UP
134 #define DOWN BUTTON_DOWN
136 #define SCROLL_FWD(x) ((x) & BUTTON_SCROLL_FWD)
137 #define SCROLL_BACK(x) ((x) & BUTTON_SCROLL_BACK)
140 #elif CONFIG_KEYPAD == SANSA_C200_PAD || \
141 CONFIG_KEYPAD == SANSA_CLIP_PAD || \
142 CONFIG_KEYPAD == SANSA_M200_PAD
143 #define QUIT BUTTON_POWER
144 #define LEFT BUTTON_LEFT
145 #define RIGHT BUTTON_RIGHT
146 #define ALTLEFT BUTTON_VOL_DOWN
147 #define ALTRIGHT BUTTON_VOL_UP
148 #define SELECT BUTTON_SELECT
149 #define UP BUTTON_UP
150 #define DOWN BUTTON_DOWN
152 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
153 #define QUIT BUTTON_POWER
154 #define LEFT BUTTON_LEFT
155 #define RIGHT BUTTON_RIGHT
156 #define SELECT BUTTON_PLAY
157 #define UP BUTTON_SCROLL_UP
158 #define DOWN BUTTON_SCROLL_DOWN
160 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
161 #define QUIT BUTTON_BACK
162 #define LEFT BUTTON_LEFT
163 #define RIGHT BUTTON_RIGHT
164 #define SELECT BUTTON_SELECT
165 #define UP BUTTON_UP
166 #define DOWN BUTTON_DOWN
168 #elif (CONFIG_KEYPAD == MROBE100_PAD)
169 #define QUIT BUTTON_POWER
170 #define LEFT BUTTON_LEFT
171 #define RIGHT BUTTON_RIGHT
172 #define SELECT BUTTON_SELECT
173 #define UP BUTTON_UP
174 #define DOWN BUTTON_DOWN
176 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
178 #define QUIT BUTTON_RC_REC
179 #define LEFT BUTTON_RC_REW
180 #define RIGHT BUTTON_RC_FF
181 #define SELECT BUTTON_RC_PLAY
182 #define UP BUTTON_RC_VOL_UP
183 #define DOWN BUTTON_RC_VOL_DOWN
184 #define RC_QUIT BUTTON_REC
186 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
187 #define QUIT BUTTON_BACK
188 #define LEFT BUTTON_LEFT
189 #define RIGHT BUTTON_RIGHT
190 #define SELECT BUTTON_SELECT
191 #define UP BUTTON_UP
192 #define DOWN BUTTON_DOWN
194 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
195 #define QUIT BUTTON_POWER
196 #define LEFT BUTTON_LEFT
197 #define RIGHT BUTTON_RIGHT
198 #define SELECT BUTTON_SELECT
199 #define UP BUTTON_UP
200 #define DOWN BUTTON_DOWN
202 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
203 #define QUIT BUTTON_POWER
204 #define LEFT BUTTON_PREV
205 #define RIGHT BUTTON_NEXT
206 #define SELECT BUTTON_PLAY
207 #define UP BUTTON_UP
208 #define DOWN BUTTON_DOWN
210 #elif CONFIG_KEYPAD == COWON_D2_PAD
212 #define QUIT BUTTON_POWER
213 #define LEFT BUTTON_MINUS
214 #define RIGHT BUTTON_PLUS
215 #define SELECT BUTTON_MENU
217 #elif CONFIG_KEYPAD == ONDAVX747_PAD
218 #define QUIT BUTTON_POWER
219 #define LEFT BUTTON_VOL_DOWN
220 #define RIGHT BUTTON_VOL_UP
221 #define SELECT BUTTON_MENU
222 #elif CONFIG_KEYPAD == ONDAVX777_PAD
223 #define QUIT BUTTON_POWER
225 #elif CONFIG_KEYPAD == MROBE500_PAD
226 #define QUIT BUTTON_POWER
228 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
229 #define QUIT BUTTON_FFWD
230 #define SELECT BUTTON_PLAY
231 #define LEFT BUTTON_LEFT
232 #define RIGHT BUTTON_RIGHT
233 #define UP BUTTON_UP
234 #define DOWN BUTTON_DOWN
236 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
237 #define QUIT BUTTON_REC
238 #define LEFT BUTTON_PREV
239 #define RIGHT BUTTON_NEXT
240 #define ALTLEFT BUTTON_MENU
241 #define ALTRIGHT BUTTON_PLAY
242 #define SELECT BUTTON_OK
243 #define UP BUTTON_UP
244 #define DOWN BUTTON_DOWN
246 #else
247 #error No keymap defined!
248 #endif
250 #ifdef HAVE_TOUCHSCREEN
251 #ifdef LEFT
252 #define ALTLEFT BUTTON_BOTTOMLEFT
253 #else
254 #define LEFT BUTTON_BOTTOMLEFT
255 #endif
256 #ifdef RIGHT
257 #define ALTRIGHT BUTTON_BOTTOMRIGHT
258 #else
259 #define RIGHT BUTTON_BOTTOMRIGHT
260 #endif
261 #ifdef SELECT
262 #define ALTSELECT BUTTON_CENTER
263 #else
264 #define SELECT BUTTON_CENTER
265 #endif
266 #ifndef UP
267 #define UP BUTTON_TOPMIDDLE
268 #endif
269 #ifndef DOWN
270 #define DOWN BUTTON_BOTTOMMIDDLE
271 #endif
272 #endif
274 /* Continue text is used as a string later when the game is paused. This allows
275 * targets to specify their own text if needed.
276 */
277 #if !defined(CONTINUE_TEXT)
279 #endif
282 #define SCROLL_FWD(x) (0)
283 #define SCROLL_BACK(x) (0)
284 #endif
287 /*
288 *
289 * Geometric dimensions
290 *
291 */
293 /* If there are three fractional bits, the smallest screen size that will scale
294 * properly is 28x22. If you have a smaller screen increase the fractional
295 * precision. If you have a precision of 4 the smallest screen size would be
296 * 14x11. Note though that this will decrease the maximum resolution due to
297 * the line intersection tests. These defines are used for all of the fixed
298 * point calculations/conversions.
299 */
300 #define FIXED3(x) ((x)<<3)
301 #define FIXED3_MUL(x, y) ((long long)((x)*(y))>>3)
302 #define FIXED3_DIV(x, y) (((x)<<3)/(y))
303 #define INT3(x) ((x)>>3)
305 #define GAMESCREEN_WIDTH FIXED3(LCD_WIDTH)
306 #define GAMESCREEN_HEIGHT FIXED3(LCD_HEIGHT)
308 #define PAD_WIDTH FIXED3(BMPWIDTH_brickmania_pads)
309 #define PAD_HEIGHT FIXED3(BMPHEIGHT_brickmania_pads/3)
310 #define SHORT_PAD_WIDTH FIXED3(BMPWIDTH_brickmania_short_pads)
311 #define LONG_PAD_WIDTH FIXED3(BMPWIDTH_brickmania_long_pads)
312 #define BRICK_HEIGHT FIXED3(BMPHEIGHT_brickmania_bricks/7)
313 #define BRICK_WIDTH FIXED3(BMPWIDTH_brickmania_bricks)
314 #define LEFTMARGIN ((GAMESCREEN_WIDTH-10*BRICK_WIDTH)/2)
315 #define POWERUP_WIDTH FIXED3(BMPWIDTH_brickmania_powerups)
316 #define BALL FIXED3(BMPHEIGHT_brickmania_ball)
317 #define HALFBALL (BALL / 2)
318 #define PAD_POS_Y (GAMESCREEN_HEIGHT - PAD_HEIGHT - 1)
319 #define ON_PAD_POS_Y (PAD_POS_Y - HALFBALL)
321 #define GAMEOVER_WIDTH FIXED3(BMPWIDTH_brickmania_gameover)
322 #define GAMEOVER_HEIGHT FIXED3(BMPHEIGHT_brickmania_gameover)
324 #define TOPMARGIN MAX(BRICK_HEIGHT, FIXED3(8))
326 #define STRINGPOS_FINISH (GAMESCREEN_HEIGHT - (GAMESCREEN_HEIGHT / 6))
327 #define STRINGPOS_CONGRATS (STRINGPOS_FINISH - 20)
328 #define STRINGPOS_NAVI (STRINGPOS_FINISH - 10)
329 #define STRINGPOS_FLIP (STRINGPOS_FINISH - 10)
332 /*
333 *
334 * Speeds
335 *
336 */
338 /* Brickmania was originally designed for the H300, other targets should scale
339 * the speed up/down as needed based on the screen height.
340 */
341 #define SPEED_SCALE_H(y) FIXED3_DIV(GAMESCREEN_HEIGHT, FIXED3(176)/(y) )
342 #define SPEED_SCALE_W(x) FIXED3_DIV(GAMESCREEN_WIDTH, FIXED3(220)/(x) )
344 /* These are all used as ball speeds depending on where the ball hit the
345 * paddle.
346 *
347 * Note that all of these speeds (including pad, power, and fire)
348 * could be made variable and could be raised to be much higher to add
349 * additional difficulty to the game. The line intersection tests allow this
350 * to be drastically increased without the collision detection failing
351 * (ideally).
352 */
353 #define SPEED_1Q_X SPEED_SCALE_W( 6)
354 #define SPEED_1Q_Y SPEED_SCALE_H(-2)
356 #define SPEED_2Q_X SPEED_SCALE_W( 4)
357 #define SPEED_2Q_Y SPEED_SCALE_H(-3)
359 #define SPEED_3Q_X SPEED_SCALE_W( 3)
360 #define SPEED_3Q_Y SPEED_SCALE_H(-4)
362 #define SPEED_4Q_X SPEED_SCALE_W( 2)
363 #define SPEED_4Q_Y SPEED_SCALE_H(-4)
365 /* This is used to determine the speed of the paddle */
366 #define SPEED_PAD SPEED_SCALE_W( 8)
368 /* This defines the speed that the powerups drop */
369 #define SPEED_POWER SPEED_SCALE_H( 2)
371 /* This defines the speed that the shot moves */
372 #define SPEED_FIRE SPEED_SCALE_H( 4)
373 #define FIRE_LENGTH SPEED_SCALE_H( 7)
376 /*
377 *
378 * Timings
379 *
380 */
382 /* The time ms for one iteration through the game loop - decrease this to speed
383 * up the game - note that current_tick is (currently) only accurate to 10ms.
384 */
390 /*
391 *
392 * Scores
393 *
394 */
396 #define SCORE_BALL_HIT_BRICK 2
397 #define SCORE_BALL_DEMOLISHED_BRICK 8
398 #define SCORE_FIRE_HIT_BRICK 13
399 #define SCORE_LEVEL_COMPLETED 100
400 #define SCORE_POWER_LIFE_GAIN 50
401 #define SCORE_POWER_PADDLE_STICKY 34
402 #define SCORE_POWER_PADDLE_SHOOTER 47
403 #define SCORE_POWER_PADDLE_NORMAL 23
404 #define SCORE_POWER_FLIP 23
405 #define SCORE_POWER_EXTRA_BALL 23
406 #define SCORE_POWER_LONG_PADDLE 23
409 /*
410 *
411 * Limits
412 *
413 */
415 #define MAX_BALLS 10
416 #define MAX_FIRES 30
417 #define MAX_POWERS 10
420 /*
421 *
422 * Files
423 *
424 */
429 #define NUM_SCORES 5
432 /*
433 *
434 * Game levels
435 *
436 */
438 #define NUM_BRICKS_ROWS 8
439 #define NUM_BRICKS_COLS 10
441 /* change to however many levels there are, i.e. how many arrays there are total */
442 #define NUM_LEVELS 40
444 /* change the first number in [ ] to however many levels there are */
446 /* You can set up new levels with the level editor
447 ( http://plugbox.rockbox-lounge.com/brickmania.htm ).
448 With 0x1, it refers to the first brick in the bitmap, 0x2 would refer to the
449 second, ect., 0x0 leaves a empty space. If you add a 2 before the 2nd number,
450 it will take two hits to break, and 3 hits if you add a 3. That is 0x24, will
451 result with the fourth brick being displayed and having take 2 hits to break.
452 You could do the same with the 3, just replace the 2 with a 3 for it to take
453 three hits to break it apart. */
454 {
464 },
474 },
484 },
494 },
504 },
514 },
524 },
534 },
544 },
554 },
564 },
574 },
584 },
594 },
604 },
614 },
624 },
634 },
644 },
654 },
664 },
674 },
684 },
694 },
704 },
714 },
724 },
734 },
744 },
754 },
764 },
774 },
784 },
794 },
804 },
814 },
824 },
834 },
844 },
854 }
855 };
858 /*
859 *
860 * Enums and structs
861 *
862 */
864 enum power_types
865 {
867 POWER_TYPE_LIFE_LOSS,
868 POWER_TYPE_PADDLE_STICKY,
869 POWER_TYPE_PADDLE_SHOOTER,
870 POWER_TYPE_PADDLE_NORMAL,
871 POWER_TYPE_PADDLE_FLIP,
872 POWER_TYPE_EXTRA_BALL,
873 POWER_TYPE_PADDLE_LONG,
874 POWER_TYPE_PADDLE_SHORT,
875 NUMBER_OF_POWERUPS,
876 };
878 #define POWERUP_HEIGHT FIXED3(BMPHEIGHT_brickmania_powerups/NUMBER_OF_POWERUPS)
879 /* Increasing this value makes the game with less powerups */
880 #define POWER_RAND (NUMBER_OF_POWERUPS + 15)
882 enum difficulty_options
883 {
884 EASY,
885 NORMAL
886 };
888 enum game_state
889 {
890 ST_READY,
891 ST_START,
892 ST_PAUSE
893 };
895 enum paddle_type
896 {
898 PADDLE_TYPE_STICKY,
899 PADDLE_TYPE_SHOOTER,
900 };
902 struct brick
903 {
908 };
910 struct ball
911 {
912 /* pos_x and y store the current center position of the ball */
915 /* tempx and tempy store an absolute position the ball should be in. If
916 * they are equal to 0, they are not used when positioning the ball.
917 */
920 /* speedx and speedy store the current speed of the ball */
924 };
926 struct fire
927 {
930 };
932 struct power
933 {
937 };
939 struct point
940 {
943 };
945 struct line
946 {
949 };
952 /*
953 *
954 * Globals
955 *
956 */
980 {
982 };
987 /*
988 *
989 * Functions
990 *
991 */
993 /*
994 * check_lines:
995 * This is based off an explanation and expanded math presented by Paul Bourke:
996 * http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
997 *
998 * It takes two lines as inputs and returns 1 if they intersect, 0 if they do
999 * not. hitp returns the point where the two lines intersected.
1000 *
1001 * This function expects fixed point inputs with a precision of 3. When a
1002 * collision occurs hitp is updated with a fixed point location (precision 3)
1003 * where the collision happened. The internal calculations are fixed
1004 * point with a 7 bit fractional precision.
1005 *
1006 * If you choose 10 bits of precision a screen size of about 640x480 is the
1007 * largest this can go. 7 bits allows for an accurate intersection calculation
1008 * with a line length of about 64 and a rougher line lenght of 128 which is
1009 * larger than any target currently needs (the pad is the longest line and it
1010 * only needs an accuracy of 2^4 at most to figure out which section of the pad
1011 * the ball hit). A precision of 7 gives breathing room for larger screens.
1012 * Longer line sizes that need accurate intersection points will need more
1013 * precision, but will decrease the maximum screen resolution.
1014 */
1016 #define LINE_PREC 7
1019 {
1020 /* Introduction:
1021 * This code is based on the solution of these two input equations:
1022 * Pa = P1 + ua (P2-P1)
1023 * Pb = P3 + ub (P4-P3)
1024 *
1025 * Where line one is composed of points P1 and P2 and line two is composed
1026 * of points P3 and P4.
1027 *
1028 * ua/b is the fractional value you can multiply the x and y legs of the
1029 * triangle formed by each line to find a point on the line.
1030 *
1031 * The two equations can be expanded to their x/y components:
1032 * Pa.x = p1.x + ua(p2.x - p1.x)
1033 * Pa.y = p1.y + ua(p2.y - p1.y)
1034 *
1035 * Pb.x = p3.x + ub(p4.x - p3.x)
1036 * Pb.y = p3.y + ub(p4.y - p3.y)
1037 *
1038 * When Pa.x == Pb.x and Pa.y == Pb.y the lines intersect so you can come
1039 * up with two equations (one for x and one for y):
1040 *
1041 * p1.x + ua(p2.x - p1.x) = p3.x + ub(p4.x - p3.x)
1042 * p1.y + ua(p2.y - p1.y) = p3.y + ub(p4.y - p3.y)
1043 *
1044 * ua and ub can then be individually solved for. This results in the
1045 * equations used in the following code.
1046 */
1048 /* Denominator for ua and ub are the same so store this calculation */
1052 /* n_a and n_b are calculated as seperate values for readability */
1059 /* Make sure there is not a division by zero - this also indicates that
1060 * the lines are parallel.
1061 *
1062 * If n_a and n_b were both equal to zero the lines would be on top of each
1063 * other (coincidental). This check is not done because it is not
1064 * necessary for this implementation (the parallel check accounts for this).
1065 */
1069 /* Calculate the intermediate fractional point that the lines potentially
1070 * intersect.
1071 */
1075 /* The fractional point will be between 0 and 1 inclusive if the lines
1076 * intersect. If the fractional calculation is larger than 1 or smaller
1077 * than 0 the lines would need to be longer to intersect.
1078 */
1080 {
1084 }
1086 }
1089 {
1095 {
1103 }
1116 /* add one life per achieved level */
1119 life++;
1120 }
1121 }
1134 brick_on_board++;
1135 }
1136 }
1137 }
1138 }
1141 {
1146 /* open game file */
1150 /* read in saved game */
1168 {
1170 }
1171 else
1172 {
1175 }
1180 }
1183 {
1186 /* write out the game state to the save file */
1207 {
1212 }
1215 }
1217 /* brickmania_sleep timer counting the score */
1219 {
1226 {
1233 {
1235 vscore++;
1237 vscore--;
1242 }
1244 }
1245 }
1248 {
1254 #if CONFIG_KEYPAD == COWON_D2_PAD
1256 #else
1258 #endif
1260 #if CONFIG_KEYPAD == ONDIO_PAD
1262 #elif (CONFIG_KEYPAD == RECORDER_PAD) || (CONFIG_KEYPAD == IAUDIO_M3_PAD)
1264 #elif CONFIG_KEYPAD == IRIVER_H300_PAD
1266 #elif CONFIG_KEYPAD == COWON_D2_PAD
1268 #else
1270 #endif
1272 #if CONFIG_KEYPAD == IAUDIO_M3_PAD
1274 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD) || \
1275 (CONFIG_KEYPAD == CREATIVEZVM_PAD)
1277 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
1278 (CONFIG_KEYPAD == IPOD_3G_PAD) || \
1279 (CONFIG_KEYPAD == IPOD_1G2G_PAD) || \
1280 (CONFIG_KEYPAD == SANSA_FUZE_PAD)
1282 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
1283 (CONFIG_KEYPAD == IRIVER_H300_PAD) || \
1284 (CONFIG_KEYPAD == ONDIO_PAD) || \
1285 (CONFIG_KEYPAD == RECORDER_PAD) || \
1286 (CONFIG_KEYPAD == ARCHOS_AV300_PAD)
1288 #else
1290 #endif
1302 };
1315 LAST_STYLE_ITEM
1316 };
1319 #ifdef HAVE_LCD_COLOR
1322 #endif
1328 }
1331 {
1337 }
1340 {
1346 };
1348 #ifdef HAVE_TOUCHSCREEN
1349 /* Entering Menu, set the touchscreen to the global setting */
1351 #endif
1396 }
1402 }
1403 }
1404 #ifdef HAVE_TOUCHSCREEN
1406 #endif
1407 }
1410 {
1414 /* if this is a crackable brick hits starts as
1415 * greater than 0.
1416 */
1421 }
1425 {
1429 {
1434 used_powers++;
1435 }
1436 }
1437 brick_on_board--;
1439 }
1440 }
1443 {
1450 /* pad_line used for powerup/ball checks */
1452 /* This is used for various lines that are checked (ball and powerup) */
1455 /* This stores the point that the two lines intersected in a test */
1460 }
1464 #ifdef HAVE_LCD_COLOR
1469 #endif
1472 /* Convert CYCLETIME (in ms) to HZ */
1479 {
1481 {
1484 flip_sides_delay--;
1485 else
1487 }
1491 }
1493 /* write life num */
1494 #if (LCD_WIDTH == 112) && (LCD_HEIGHT == 64)
1496 #else
1498 #endif
1501 #if (LCD_WIDTH == 112) && (LCD_HEIGHT == 64)
1503 #else
1505 #endif
1515 /* continue game */
1517 {
1523 }
1525 /* draw the ball */
1533 brick_on_board--;
1535 /* Setup the pad line-later used in intersection test */
1543 {
1544 /* move the fires */
1546 {
1549 {
1550 used_fires--;
1553 k--;
1554 }
1557 {
1560 {
1563 {
1566 used_fires--;
1569 k--;
1571 }
1574 }
1575 }
1576 }
1578 /* move and handle the powerups */
1580 {
1586 {
1587 /* power hit bottom */
1589 }
1590 else
1591 {
1592 /* Use misc_line to check if the center of the powerup
1593 * hit the paddle.
1594 */
1601 /* Check if the powerup will hit the paddle */
1603 {
1605 /* power hit paddle */
1608 {
1610 life++;
1614 life--;
1616 {
1619 }
1649 {
1650 /* Set the speed */
1653 else
1656 /* Ball is not glued */
1658 used_balls++;
1659 }
1664 {
1668 }
1670 {
1674 }
1678 GAMESCREEN_WIDTH)
1683 {
1687 }
1689 {
1692 }
1696 }
1697 }
1700 {
1701 used_powers--;
1703 {
1707 }
1708 k--;
1709 }
1710 }
1711 }
1712 }
1714 /* draw the fires */
1716 {
1719 }
1721 /* draw the powerups */
1723 {
1727 BMPHEIGHT_brickmania_powerups),
1731 }
1733 /* handle all of the bricks */
1735 {
1737 {
1740 /* The brick is a brick, but it may or may not be in use */
1742 {
1743 /* these lines are used to describe the brick */
1748 /* Describe the brick for later collision checks */
1749 /* Setup the bottom of the brick */
1756 /* Setup the top of the brick */
1763 /* Setup the left of the brick */
1770 /* Setup the right of the brick */
1777 /* Draw the brick */
1781 BMPWIDTH_brickmania_bricks,
1782 BMPHEIGHT_brickmania_bricks),
1792 BMPWIDTH_brickmania_break,
1793 BMPHEIGHT_brickmania_break),
1797 #endif
1799 /* Check if any balls collided with the brick */
1801 {
1802 /* Setup the ball path to describe the current ball
1803 * position and the line it makes to its next
1804 * position.
1805 */
1812 /* Check to see if the ball and the bottom hit. If
1813 * the ball is moving down we don't want to
1814 * include the bottom line intersection.
1815 *
1816 * The order that the sides are checked matters.
1817 *
1818 * Note that tempx/tempy store the next position
1819 * that the ball should be drawn.
1820 */
1823 {
1828 }
1829 /* Check the top, if the ball is moving up dont
1830 * count it as a hit.
1831 */
1834 {
1839 }
1840 /* Check the left side of the brick */
1843 {
1848 }
1849 /* Check the right side of the brick */
1852 {
1857 }
1864 /* draw the paddle according to the PAD_WIDTH */
1866 {
1868 brickmania_pads,
1871 BMPHEIGHT_brickmania_pads),
1874 }
1876 {
1878 brickmania_long_pads,
1881 BMPHEIGHT_brickmania_long_pads),
1884 }
1886 {
1888 brickmania_short_pads,
1891 BMPHEIGHT_brickmania_short_pads),
1894 }
1896 /* If the game is not paused continue */
1898 {
1899 /* Loop through all of the balls in play */
1901 {
1904 /* Describe the ball movement for the edge collision detection */
1911 /* Did the Ball hit the top of the screen? */
1917 /* the test for pos_y prevents the ball from bouncing back
1918 * from _over_ the top to infinity on some rare cases */
1921 {
1924 /* Reverse the direction */
1926 }
1928 /* Player missed the ball and hit bottom of screen */
1930 {
1931 /* Player had balls to spare, so handle the removal */
1933 {
1934 /* decrease number of balls in play */
1935 used_balls--;
1936 /* Replace removed ball with the last ball */
1945 /* Reset the last ball that was removed */
1953 k--;
1955 }
1956 else
1957 {
1958 /* Player lost a life */
1959 life--;
1961 {
1962 /* No lives left reset game */
1966 }
1967 }
1968 }
1971 {
1972 /* Check if the ball hit the left side */
1979 {
1980 /* Reverse direction */
1983 /* Re-position ball in gameboard */
1986 }
1988 /* Check if the ball hit the right side */
1995 {
1996 /* Reverse direction */
1999 /* Re-position ball in gameboard */
2002 }
2004 /* Did the ball hit the paddle? Depending on where the ball
2005 * Hit set the x/y speed appropriately.
2006 */
2008 {
2009 /* Re-position ball based on collision */
2013 /* Calculate the ball position relative to the paddle width */
2015 /* If the ball hits the right half of paddle, x speed
2016 * should be positive, if it hits the left half it
2017 * should be negative.
2018 */
2021 /* Comparisons are done with respect to 1/2 pad_width */
2023 {
2024 /* flip the relative position */
2026 /* Ball hit the right half so X speed calculations
2027 * should be positive.
2028 */
2030 }
2032 /* Figure out where the ball hit relative to 1/2 pad
2033 * and in divisions of 4.
2034 */
2038 {
2039 /* Ball hit the outer edge of the paddle */
2044 /* Ball hit the next fourth of the paddle */
2049 /* Ball hit the third fourth of the paddle */
2054 /* Ball hit the fourth fourth of the paddle or dead
2055 * center.
2056 */
2060 /* Since this is the middle we don't want to
2061 * force the ball in a different direction.
2062 * Just keep it going in the same direction
2063 * with a specific speed.
2064 */
2066 {
2068 }
2069 else
2070 {
2072 }
2078 }
2081 {
2085 /* X location should not be forced since that is moved with the paddle. The Y
2086 * position should be forced to keep the ball at the paddle.
2087 */
2090 }
2091 }
2092 }
2094 /* Update the ball position */
2096 {
2099 else
2104 else
2109 }
2111 }
2116 {
2118 {
2119 level++;
2125 }
2126 else
2127 {
2131 #if (LCD_WIDTH == 112) && (LCD_HEIGHT == 64)
2135 #else
2140 #endif
2145 }
2146 }
2151 #if defined(HAS_BUTTON_HOLD) && !defined(HAVE_REMOTE_LCD_AS_MAIN)
2152 /* FIXME: Should probably check remote hold here */
2155 #endif
2157 #ifdef HAVE_TOUCHSCREEN
2159 {
2167 {
2169 }
2170 else
2171 {
2173 }
2182 }
2183 else
2184 #endif
2185 {
2187 #ifdef ALTRIGHT
2190 #else
2193 #endif
2198 {
2200 {
2204 pad_width;
2206 }
2212 }
2213 }
2216 {
2218 {
2223 }
2224 else
2225 {
2230 }
2231 }
2232 }
2235 {
2236 #if defined(HAVE_TOUCHSCREEN)
2238 #endif
2241 #ifdef ALTSELECT
2243 #endif
2245 {
2246 /* Initialize used balls starting speed */
2248 {
2251 {
2253 }
2254 else
2255 {
2257 }
2258 }
2260 }
2262 {
2264 }
2266 {
2268 {
2270 {
2273 }
2274 }
2275 }
2277 {
2279 {
2282 used_fires++;
2283 }
2285 {
2288 used_fires++;
2289 }
2290 }
2292 #ifdef RC_QUIT
2294 #endif
2304 }
2305 }
2306 else
2307 {
2308 #ifdef HAVE_LCD_COLOR
2318 #endif
2322 }
2324 /* Game always needs to yield for other threads */
2327 /* Sleep for a bit if there is time to spare */
2330 }
2332 }
2334 /* this is the plugin entry point */
2336 {
2344 #ifdef HAVE_TOUCHSCREEN
2346 #endif
2349 #if LCD_DEPTH > 1
2351 #endif
2352 /* Turn off backlight timeout */
2355 /* now go ahead and have fun! */
2360 {
2362 {
2366 {
2370 }
2371 else
2372 {
2374 }
2375 }
2376 }
2381 /* Restore user's original backlight setting */
2383 /* Turn on backlight timeout (revert to settings) */
2387 }