| blob | 98de3d439f88601627084f5cc2bf71a065fb371c |
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 #elif CONFIG_KEYPAD == MPIO_HD200_PAD
247 #define QUIT (BUTTON_REC|BUTTON_PLAY)
248 #define LEFT BUTTON_VOL_DOWN
249 #define RIGHT BUTTON_VOL_UP
250 #define SELECT BUTTON_SELECT
251 #define UP BUTTON_PREV
252 #define DOWN BUTTON_NEXT
254 #else
255 #error No keymap defined!
256 #endif
258 #ifdef HAVE_TOUCHSCREEN
259 #ifdef LEFT
260 #define ALTLEFT BUTTON_BOTTOMLEFT
261 #else
262 #define LEFT BUTTON_BOTTOMLEFT
263 #endif
264 #ifdef RIGHT
265 #define ALTRIGHT BUTTON_BOTTOMRIGHT
266 #else
267 #define RIGHT BUTTON_BOTTOMRIGHT
268 #endif
269 #ifdef SELECT
270 #define ALTSELECT BUTTON_CENTER
271 #else
272 #define SELECT BUTTON_CENTER
273 #endif
274 #ifndef UP
275 #define UP BUTTON_TOPMIDDLE
276 #endif
277 #ifndef DOWN
278 #define DOWN BUTTON_BOTTOMMIDDLE
279 #endif
280 #endif
282 /* Continue text is used as a string later when the game is paused. This allows
283 * targets to specify their own text if needed.
284 */
285 #if !defined(CONTINUE_TEXT)
287 #endif
290 #define SCROLL_FWD(x) (0)
291 #define SCROLL_BACK(x) (0)
292 #endif
295 #define NUM_BRICKS_ROWS 8
296 #define NUM_BRICKS_COLS 10
298 /*
299 *
300 * Geometric dimensions
301 *
302 */
304 /* If there are three fractional bits, the smallest screen size that will scale
305 * properly is 28x22. If you have a smaller screen increase the fractional
306 * precision. If you have a precision of 4 the smallest screen size would be
307 * 14x11. Note though that this will decrease the maximum resolution due to
308 * the line intersection tests. These defines are used for all of the fixed
309 * point calculations/conversions.
310 */
311 #define FIXED3(x) ((x)<<3)
312 #define FIXED3_MUL(x, y) ((long long)((x)*(y))>>3)
313 #define FIXED3_DIV(x, y) (((x)<<3)/(y))
314 #define INT3(x) ((x)>>3)
316 #define GAMESCREEN_WIDTH FIXED3(LCD_WIDTH)
317 #define GAMESCREEN_HEIGHT FIXED3(LCD_HEIGHT)
319 #define PAD_WIDTH FIXED3(BMPWIDTH_brickmania_pads)
320 #define PAD_HEIGHT FIXED3(BMPHEIGHT_brickmania_pads/3)
321 #define SHORT_PAD_WIDTH FIXED3(BMPWIDTH_brickmania_short_pads)
322 #define LONG_PAD_WIDTH FIXED3(BMPWIDTH_brickmania_long_pads)
323 #define BRICK_HEIGHT FIXED3(BMPHEIGHT_brickmania_bricks/7)
324 #define BRICK_WIDTH FIXED3(BMPWIDTH_brickmania_bricks)
325 #define LEFTMARGIN ((GAMESCREEN_WIDTH-NUM_BRICKS_COLS*BRICK_WIDTH)/2)
326 #define POWERUP_WIDTH FIXED3(BMPWIDTH_brickmania_powerups)
327 #define BALL FIXED3(BMPHEIGHT_brickmania_ball)
328 #define HALFBALL (BALL / 2)
329 #define PAD_POS_Y (GAMESCREEN_HEIGHT - PAD_HEIGHT - 1)
330 #define ON_PAD_POS_Y (PAD_POS_Y - HALFBALL)
332 #define GAMEOVER_WIDTH FIXED3(BMPWIDTH_brickmania_gameover)
333 #define GAMEOVER_HEIGHT FIXED3(BMPHEIGHT_brickmania_gameover)
335 #define TOPMARGIN MAX(BRICK_HEIGHT, FIXED3(8))
337 #define STRINGPOS_FINISH (GAMESCREEN_HEIGHT - (GAMESCREEN_HEIGHT / 6))
338 #define STRINGPOS_NAVI (STRINGPOS_FINISH - 10)
339 #define STRINGPOS_FLIP (STRINGPOS_FINISH - 10)
342 /*
343 *
344 * Speeds
345 *
346 */
348 /* Brickmania was originally designed for the H300, other targets should scale
349 * the speed up/down as needed based on the screen height.
350 */
351 #define SPEED_SCALE_H(y) FIXED3_DIV(GAMESCREEN_HEIGHT, FIXED3(176)/(y) )
352 #define SPEED_SCALE_W(x) FIXED3_DIV(GAMESCREEN_WIDTH, FIXED3(220)/(x) )
354 /* These are all used as ball speeds depending on where the ball hit the
355 * paddle.
356 *
357 * Note that all of these speeds (including pad, power, and fire)
358 * could be made variable and could be raised to be much higher to add
359 * additional difficulty to the game. The line intersection tests allow this
360 * to be drastically increased without the collision detection failing
361 * (ideally).
362 */
363 #define SPEED_1Q_X SPEED_SCALE_W( 6)
364 #define SPEED_1Q_Y SPEED_SCALE_H(-2)
366 #define SPEED_2Q_X SPEED_SCALE_W( 4)
367 #define SPEED_2Q_Y SPEED_SCALE_H(-3)
369 #define SPEED_3Q_X SPEED_SCALE_W( 3)
370 #define SPEED_3Q_Y SPEED_SCALE_H(-4)
372 #define SPEED_4Q_X SPEED_SCALE_W( 2)
373 #define SPEED_4Q_Y SPEED_SCALE_H(-4)
375 /* This is used to determine the speed of the paddle */
376 #define SPEED_PAD SPEED_SCALE_W( 8)
378 /* This defines the speed that the powerups drop */
379 #define SPEED_POWER SPEED_SCALE_H( 2)
381 /* This defines the speed that the shot moves */
382 #define SPEED_FIRE SPEED_SCALE_H( 4)
383 #define FIRE_LENGTH SPEED_SCALE_H( 7)
386 /*
387 *
388 * Timings
389 *
390 */
392 /* The time ms for one iteration through the game loop - decrease this to speed
393 * up the game - note that current_tick is (currently) only accurate to 10ms.
394 */
400 /*
401 *
402 * Scores
403 *
404 */
406 #define SCORE_BALL_HIT_BRICK 2
407 #define SCORE_BALL_DEMOLISHED_BRICK 8
408 #define SCORE_FIRE_HIT_BRICK 13
409 #define SCORE_LEVEL_COMPLETED 100
410 #define SCORE_POWER_LIFE_GAIN 50
411 #define SCORE_POWER_PADDLE_STICKY 34
412 #define SCORE_POWER_PADDLE_SHOOTER 47
413 #define SCORE_POWER_PADDLE_NORMAL 23
414 #define SCORE_POWER_FLIP 23
415 #define SCORE_POWER_EXTRA_BALL 23
416 #define SCORE_POWER_LONG_PADDLE 23
419 /*
420 *
421 * Limits
422 *
423 */
425 #define MAX_BALLS 10
426 #define MAX_FIRES 30
427 #define MAX_POWERS 10
430 /*
431 *
432 * Files
433 *
434 */
439 #define NUM_SCORES 5
442 /*
443 *
444 * Game levels
445 *
446 */
448 /* change to however many levels there are, i.e. how many arrays there are total */
449 #define NUM_LEVELS 40
451 /* change the first number in [ ] to however many levels there are */
453 /* You can set up new levels with the level editor
454 ( http://plugbox.rockbox-lounge.com/brickmania.htm ).
455 With 0x1, it refers to the first brick in the bitmap, 0x2 would refer to the
456 second, ect., 0x0 leaves a empty space. If you add a 2 before the 2nd number,
457 it will take two hits to break, and 3 hits if you add a 3. That is 0x24, will
458 result with the fourth brick being displayed and having take 2 hits to break.
459 You could do the same with the 3, just replace the 2 with a 3 for it to take
460 three hits to break it apart. */
461 {
471 },
481 },
491 },
501 },
511 },
521 },
531 },
541 },
551 },
561 },
571 },
581 },
591 },
601 },
611 },
621 },
631 },
641 },
651 },
661 },
671 },
681 },
691 },
701 },
711 },
721 },
731 },
741 },
751 },
761 },
771 },
781 },
791 },
801 },
811 },
821 },
831 },
841 },
851 },
861 }
862 };
865 /*
866 *
867 * Enums and structs
868 *
869 */
871 enum power_types
872 {
874 POWER_TYPE_LIFE_LOSS,
875 POWER_TYPE_PADDLE_STICKY,
876 POWER_TYPE_PADDLE_SHOOTER,
877 POWER_TYPE_PADDLE_NORMAL,
878 POWER_TYPE_PADDLE_FLIP,
879 POWER_TYPE_EXTRA_BALL,
880 POWER_TYPE_PADDLE_LONG,
881 POWER_TYPE_PADDLE_SHORT,
882 NUMBER_OF_POWERUPS,
883 };
885 #define POWERUP_HEIGHT FIXED3(BMPHEIGHT_brickmania_powerups/NUMBER_OF_POWERUPS)
886 /* Increasing this value makes the game with less powerups */
887 #define POWER_RAND (NUMBER_OF_POWERUPS + 15)
889 enum difficulty_options
890 {
891 EASY,
892 NORMAL
893 };
895 enum game_state
896 {
897 ST_READY,
898 ST_START,
899 ST_PAUSE
900 };
902 enum paddle_type
903 {
905 PADDLE_TYPE_STICKY,
906 PADDLE_TYPE_SHOOTER,
907 };
909 enum intersection
910 {
911 INTERSECTION_TOP,
912 INTERSECTION_BOTTOM,
913 INTERSECTION_LEFT,
914 INTERSECTION_RIGHT,
915 INTERSECTION_ALL,
916 };
918 struct brick
919 {
924 };
926 struct ball
927 {
928 /* pos_x and y store the current center position of the ball */
931 /* tempx and tempy store an absolute position the ball should be in. If
932 * they are equal to 0, they are not used when positioning the ball.
933 */
936 /* speedx and speedy store the current speed of the ball */
940 };
942 struct fire
943 {
946 };
948 struct power
949 {
953 };
955 struct point
956 {
959 };
961 struct line
962 {
965 };
967 struct rect
968 {
971 };
973 /*
974 *
975 * Globals
976 *
977 */
1001 {
1003 };
1008 /*
1009 *
1010 * Functions
1011 *
1012 */
1014 /*
1015 * check_lines:
1016 * This is based off an explanation and expanded math presented by Paul Bourke:
1017 * http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
1018 *
1019 * It takes two lines as inputs and returns 1 if they intersect, 0 if they do
1020 * not. hitp returns the point where the two lines intersected.
1021 *
1022 * This function expects fixed point inputs with a precision of 3. When a
1023 * collision occurs hitp is updated with a fixed point location (precision 3)
1024 * where the collision happened. The internal calculations are fixed
1025 * point with a 7 bit fractional precision.
1026 *
1027 * If you choose 10 bits of precision a screen size of about 640x480 is the
1028 * largest this can go. 7 bits allows for an accurate intersection calculation
1029 * with a line length of about 64 and a rougher line lenght of 128 which is
1030 * larger than any target currently needs (the pad is the longest line and it
1031 * only needs an accuracy of 2^4 at most to figure out which section of the pad
1032 * the ball hit). A precision of 7 gives breathing room for larger screens.
1033 * Longer line sizes that need accurate intersection points will need more
1034 * precision, but will decrease the maximum screen resolution.
1035 */
1037 #define LINE_PREC 7
1040 {
1041 /* Introduction:
1042 * This code is based on the solution of these two input equations:
1043 * Pa = P1 + ua (P2-P1)
1044 * Pb = P3 + ub (P4-P3)
1045 *
1046 * Where line one is composed of points P1 and P2 and line two is composed
1047 * of points P3 and P4.
1048 *
1049 * ua/b is the fractional value you can multiply the x and y legs of the
1050 * triangle formed by each line to find a point on the line.
1051 *
1052 * The two equations can be expanded to their x/y components:
1053 * Pa.x = p1.x + ua(p2.x - p1.x)
1054 * Pa.y = p1.y + ua(p2.y - p1.y)
1055 *
1056 * Pb.x = p3.x + ub(p4.x - p3.x)
1057 * Pb.y = p3.y + ub(p4.y - p3.y)
1058 *
1059 * When Pa.x == Pb.x and Pa.y == Pb.y the lines intersect so you can come
1060 * up with two equations (one for x and one for y):
1061 *
1062 * p1.x + ua(p2.x - p1.x) = p3.x + ub(p4.x - p3.x)
1063 * p1.y + ua(p2.y - p1.y) = p3.y + ub(p4.y - p3.y)
1064 *
1065 * ua and ub can then be individually solved for. This results in the
1066 * equations used in the following code.
1067 */
1069 /* Denominator for ua and ub are the same so store this calculation */
1073 /* n_a and n_b are calculated as seperate values for readability */
1080 /* Make sure there is not a division by zero - this also indicates that
1081 * the lines are parallel.
1082 *
1083 * If n_a and n_b were both equal to zero the lines would be on top of each
1084 * other (coincidental). This check is not done because it is not
1085 * necessary for this implementation (the parallel check accounts for this).
1086 */
1090 /* Calculate the intermediate fractional point that the lines potentially
1091 * intersect.
1092 */
1096 /* The fractional point will be between 0 and 1 inclusive if the lines
1097 * intersect. If the fractional calculation is larger than 1 or smaller
1098 * than 0 the lines would need to be longer to intersect.
1099 */
1101 {
1105 }
1107 }
1112 {
1116 {
1118 {
1126 }
1128 {
1136 }
1138 {
1146 }
1148 {
1156 }
1158 {
1163 }
1164 }
1167 }
1170 {
1176 {
1184 }
1197 /* add one life per achieved level */
1200 life++;
1201 }
1202 }
1215 brick_on_board++;
1216 }
1217 }
1218 }
1219 }
1222 {
1227 /* open game file */
1231 /* read in saved game */
1249 {
1251 }
1252 else
1253 {
1256 }
1261 }
1264 {
1267 /* write out the game state to the save file */
1288 {
1293 }
1296 }
1298 /* brickmania_sleep timer counting the score */
1300 {
1307 {
1314 {
1316 vscore++;
1318 vscore--;
1323 }
1325 }
1326 }
1329 {
1335 #if CONFIG_KEYPAD == COWON_D2_PAD
1337 #else
1339 #endif
1341 #if CONFIG_KEYPAD == ONDIO_PAD
1343 #elif (CONFIG_KEYPAD == RECORDER_PAD) || (CONFIG_KEYPAD == IAUDIO_M3_PAD)
1345 #elif CONFIG_KEYPAD == IRIVER_H300_PAD
1347 #elif CONFIG_KEYPAD == COWON_D2_PAD
1349 #else
1351 #endif
1353 #if CONFIG_KEYPAD == IAUDIO_M3_PAD
1355 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD) || \
1356 (CONFIG_KEYPAD == CREATIVEZVM_PAD)
1358 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
1359 (CONFIG_KEYPAD == IPOD_3G_PAD) || \
1360 (CONFIG_KEYPAD == IPOD_1G2G_PAD) || \
1361 (CONFIG_KEYPAD == SANSA_FUZE_PAD)
1363 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
1364 (CONFIG_KEYPAD == IRIVER_H300_PAD) || \
1365 (CONFIG_KEYPAD == ONDIO_PAD) || \
1366 (CONFIG_KEYPAD == RECORDER_PAD) || \
1367 (CONFIG_KEYPAD == ARCHOS_AV300_PAD)
1369 #else
1371 #endif
1383 };
1396 LAST_STYLE_ITEM
1397 };
1400 #ifdef HAVE_LCD_COLOR
1403 #endif
1409 }
1412 {
1418 }
1421 {
1427 };
1429 #ifdef HAVE_TOUCHSCREEN
1430 /* Entering Menu, set the touchscreen to the global setting */
1432 #endif
1477 }
1483 }
1484 }
1485 #ifdef HAVE_TOUCHSCREEN
1487 #endif
1488 }
1491 {
1495 /* if this is a crackable brick hits starts as
1496 * greater than 0.
1497 */
1502 }
1506 {
1510 {
1515 used_powers++;
1516 }
1517 }
1518 brick_on_board--;
1520 }
1521 }
1524 {
1531 /* pad_rect used for powerup/ball checks */
1533 /* This is used for various lines that are checked (ball and powerup) */
1536 /* This stores the point that the two lines intersected in a test */
1541 }
1545 #ifdef HAVE_LCD_COLOR
1550 #endif
1553 /* Convert CYCLETIME (in ms) to HZ */
1560 {
1562 {
1565 flip_sides_delay--;
1566 else
1568 }
1572 }
1574 /* write life num */
1575 #if (LCD_WIDTH == 112) && (LCD_HEIGHT == 64)
1577 #else
1579 #endif
1582 #if (LCD_WIDTH == 112) && (LCD_HEIGHT == 64)
1584 #else
1586 #endif
1596 /* continue game */
1598 {
1604 }
1606 /* draw the ball */
1614 brick_on_board--;
1616 /* Setup the pad line-later used in intersection test */
1624 {
1625 /* move the fires */
1627 {
1630 {
1631 used_fires--;
1634 k--;
1635 }
1638 {
1641 {
1645 {
1648 used_fires--;
1651 k--;
1653 }
1654 }
1655 }
1656 }
1658 /* move and handle the powerups */
1660 {
1666 {
1667 /* power hit bottom */
1669 }
1670 else
1671 {
1672 /* Use misc_line to check if the center of the powerup
1673 * hit the paddle.
1674 */
1681 /* Check if the powerup will hit the paddle */
1684 {
1686 /* power hit paddle */
1689 {
1691 life++;
1695 life--;
1697 {
1700 }
1730 {
1731 /* Set the speed */
1734 else
1737 /* Ball is not glued */
1739 used_balls++;
1740 }
1745 {
1749 }
1751 {
1755 }
1759 GAMESCREEN_WIDTH)
1764 {
1768 }
1770 {
1773 }
1777 }
1778 }
1781 {
1782 used_powers--;
1784 {
1788 }
1789 k--;
1790 }
1791 }
1792 }
1793 }
1795 /* draw the fires */
1797 {
1800 }
1802 /* draw the powerups */
1804 {
1808 BMPHEIGHT_brickmania_powerups),
1812 }
1814 /* handle all of the bricks */
1816 {
1818 {
1821 /* The brick is a brick, but it may or may not be in use */
1823 {
1835 /* Draw the brick */
1839 BMPWIDTH_brickmania_bricks,
1840 BMPHEIGHT_brickmania_bricks),
1850 BMPWIDTH_brickmania_break,
1851 BMPHEIGHT_brickmania_break),
1855 #endif
1857 /* Check if any balls collided with the brick */
1859 {
1862 /* Setup the ball path to describe the current ball
1863 * position and the line it makes to its next
1864 * position.
1865 */
1872 /* Check to see if the ball and the bottom hit. If
1873 * the ball is moving down we don't want to
1874 * include the bottom line intersection.
1875 *
1876 * The order that the sides are checked matters.
1877 *
1878 * Note that tempx/tempy store the next position
1879 * that the ball should be drawn.
1880 */
1883 {
1886 }
1887 /* Check the top, if the ball is moving up dont
1888 * count it as a hit.
1889 */
1892 {
1895 }
1896 /* Check the left side of the brick */
1899 {
1902 }
1903 /* Check the right side of the brick */
1906 {
1909 }
1912 {
1917 }
1924 /* draw the paddle according to the PAD_WIDTH */
1926 {
1928 brickmania_pads,
1931 BMPHEIGHT_brickmania_pads),
1934 }
1936 {
1938 brickmania_long_pads,
1941 BMPHEIGHT_brickmania_long_pads),
1944 }
1946 {
1948 brickmania_short_pads,
1951 BMPHEIGHT_brickmania_short_pads),
1954 }
1956 /* If the game is not paused continue */
1958 {
1959 /* Loop through all of the balls in play */
1961 {
1964 /* Describe the ball movement for the edge collision detection */
1971 /* Did the Ball hit the top of the screen? */
1977 /* the test for pos_y prevents the ball from bouncing back
1978 * from _over_ the top to infinity on some rare cases */
1981 {
1984 /* Reverse the direction */
1986 }
1988 /* Player missed the ball and hit bottom of screen */
1990 {
1991 /* Player had balls to spare, so handle the removal */
1993 {
1994 /* decrease number of balls in play */
1995 used_balls--;
1996 /* Replace removed ball with the last ball */
2005 /* Reset the last ball that was removed */
2013 k--;
2015 }
2016 else
2017 {
2018 /* Player lost a life */
2019 life--;
2021 {
2022 /* No lives left reset game */
2026 }
2027 }
2028 }
2031 {
2032 /* Check if the ball hit the left side */
2039 {
2040 /* Reverse direction */
2043 /* Re-position ball in gameboard */
2046 }
2048 /* Check if the ball hit the right side */
2055 {
2056 /* Reverse direction */
2059 /* Re-position ball in gameboard */
2062 }
2064 /* Did the ball hit the paddle? Depending on where the ball
2065 * Hit set the x/y speed appropriately.
2066 */
2069 {
2070 /* Re-position ball based on collision */
2074 /* Calculate the ball position relative to the paddle width */
2076 /* If the ball hits the right half of paddle, x speed
2077 * should be positive, if it hits the left half it
2078 * should be negative.
2079 */
2082 /* Comparisons are done with respect to 1/2 pad_width */
2084 {
2085 /* flip the relative position */
2087 /* Ball hit the right half so X speed calculations
2088 * should be positive.
2089 */
2091 }
2093 /* Figure out where the ball hit relative to 1/2 pad
2094 * and in divisions of 4.
2095 */
2099 {
2100 /* Ball hit the outer edge of the paddle */
2105 /* Ball hit the next fourth of the paddle */
2110 /* Ball hit the third fourth of the paddle */
2115 /* Ball hit the fourth fourth of the paddle or dead
2116 * center.
2117 */
2121 /* Since this is the middle we don't want to
2122 * force the ball in a different direction.
2123 * Just keep it going in the same direction
2124 * with a specific speed.
2125 */
2127 {
2129 }
2130 else
2131 {
2133 }
2139 }
2142 {
2146 /* X location should not be forced since that is moved with the paddle. The Y
2147 * position should be forced to keep the ball at the paddle.
2148 */
2151 }
2152 }
2153 }
2155 /* Update the ball position */
2157 {
2160 else
2165 else
2170 }
2172 }
2177 {
2179 {
2180 level++;
2186 }
2187 else
2188 {
2192 #if (LCD_WIDTH == 112) && (LCD_HEIGHT == 64)
2196 #else
2201 #endif
2206 }
2207 }
2212 #if defined(HAS_BUTTON_HOLD) && !defined(HAVE_REMOTE_LCD_AS_MAIN)
2213 /* FIXME: Should probably check remote hold here */
2216 #endif
2218 #ifdef HAVE_TOUCHSCREEN
2220 {
2228 {
2230 }
2231 else
2232 {
2234 }
2243 }
2244 else
2245 #endif
2246 {
2248 #ifdef ALTRIGHT
2251 #else
2254 #endif
2259 {
2264 {
2267 else
2269 }
2272 {
2275 else
2277 }
2281 {
2283 {
2290 }
2291 }
2292 }
2293 }
2296 {
2297 #if defined(HAVE_TOUCHSCREEN)
2299 #endif
2302 #ifdef ALTSELECT
2304 #endif
2306 {
2307 /* Initialize used balls starting speed */
2309 {
2312 {
2314 }
2315 else
2316 {
2318 }
2319 }
2321 }
2323 {
2325 }
2327 {
2329 {
2331 {
2334 }
2335 }
2336 }
2338 {
2340 {
2343 used_fires++;
2344 }
2346 {
2349 used_fires++;
2350 }
2351 }
2353 #ifdef RC_QUIT
2355 #endif
2365 }
2366 }
2367 else
2368 {
2369 #ifdef HAVE_LCD_COLOR
2379 #endif
2383 }
2385 /* Game always needs to yield for other threads */
2388 /* Sleep for a bit if there is time to spare */
2391 }
2393 }
2395 /* this is the plugin entry point */
2397 {
2405 #ifdef HAVE_TOUCHSCREEN
2407 #endif
2410 #if LCD_DEPTH > 1
2412 #endif
2413 /* Turn off backlight timeout */
2416 /* now go ahead and have fun! */
2421 {
2423 {
2427 {
2431 }
2432 else
2433 {
2435 }
2436 }
2437 }
2442 /* Restore user's original backlight setting */
2444 /* Turn on backlight timeout (revert to settings) */
2448 }