?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Move c/h files implementing/defining standard library stuff into a new libc directory...
[kugel-rb.git] / apps / plugins / invadrox.c
blob851487cf9a4fc14d3d1d0271b2fa2a8f903bf12b
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2006 Albert Veli
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 *
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
19 *
20 ****************************************************************************/
21
22 /* Improvised creds goes to:
23 *
24 * - Anders Clausen for ingeniously inventing the name Invadrox.
25 * - Linus Nielsen-Feltzing for patiently answering n00b questions.
26 */
27
28 #include "plugin.h"
29 #include "lib/highscore.h"
30 #include "lib/helper.h"
31
32 /* bitmaps */
33 #include "pluginbitmaps/invadrox_background.h"
34
35 /* get dimensions for later use from the bitmaps */
36 #include "pluginbitmaps/invadrox_aliens.h"
37 #include "pluginbitmaps/invadrox_ships.h"
38 #include "pluginbitmaps/invadrox_bombs.h"
39 #include "pluginbitmaps/invadrox_alien_explode.h"
40 #include "pluginbitmaps/invadrox_shield.h"
41 #include "pluginbitmaps/invadrox_ufo.h"
42 #include "pluginbitmaps/invadrox_ufo_explode.h"
43 #include "pluginbitmaps/invadrox_numbers.h"
44 #include "pluginbitmaps/invadrox_fire.h"
45 #define ALIEN_WIDTH (BMPWIDTH_invadrox_aliens/2)
46 #define ALIEN_HEIGHT (BMPHEIGHT_invadrox_aliens/3)
47 #define SHIP_WIDTH BMPWIDTH_invadrox_ships
48 #define SHIP_HEIGHT (BMPHEIGHT_invadrox_ships/3)
49 #define BOMB_WIDTH (BMPWIDTH_invadrox_bombs/3)
50 #define BOMB_HEIGHT (BMPHEIGHT_invadrox_bombs/6)
51 #define ALIEN_EXPLODE_WIDTH BMPWIDTH_invadrox_alien_explode
52 #define ALIEN_EXPLODE_HEIGHT BMPHEIGHT_invadrox_alien_explode
53 #define SHIELD_WIDTH BMPWIDTH_invadrox_shield
54 #define SHIELD_HEIGHT BMPHEIGHT_invadrox_shield
55 #define UFO_WIDTH BMPWIDTH_invadrox_ufo
56 #define UFO_HEIGHT BMPHEIGHT_invadrox_ufo
57 #define UFO_EXPLODE_WIDTH BMPWIDTH_invadrox_ufo_explode
58 #define UFO_EXPLODE_HEIGHT BMPHEIGHT_invadrox_ufo_explode
59 #define NUMBERS_WIDTH (BMPWIDTH_invadrox_numbers/10)
60 #define FONT_HEIGHT BMPHEIGHT_invadrox_numbers
61 #define FIRE_WIDTH BMPWIDTH_invadrox_fire
62 #define FIRE_HEIGHT BMPHEIGHT_invadrox_fire
63
64 PLUGIN_HEADER
65
66 /* Original graphics is only 1bpp so it should be portable
67 * to most targets. But for now, only support the simple ones.
68 */
69 #ifndef HAVE_LCD_BITMAP
70 #error INVADROX: Unsupported LCD
71 #endif
72
73 #if (LCD_DEPTH < 2)
74 #error INVADROX: Unsupported LCD
75 #endif
76
77 /* #define DEBUG */
78 #ifdef DEBUG
79 #define DBG(format, arg...) { DEBUGF("%s: " format, __FUNCTION__, ## arg); }
80 #else
81 #define DBG(format, arg...) {}
82 #endif
83
84 #ifndef ABS
85 #define ABS(a) (((a) < 0) ? -(a) : (a))
86 #endif
87
88 #if CONFIG_KEYPAD == IRIVER_H100_PAD
89
90 #define QUIT BUTTON_OFF
91 #define LEFT BUTTON_LEFT
92 #define RIGHT BUTTON_RIGHT
93 #define FIRE BUTTON_ON
94
95 #elif CONFIG_KEYPAD == IRIVER_H300_PAD
96
97 #define QUIT BUTTON_OFF
98 #define LEFT BUTTON_LEFT
99 #define RIGHT BUTTON_RIGHT
100 #define FIRE BUTTON_SELECT
101
102 #elif (CONFIG_KEYPAD == IRIVER_H10_PAD)
103
104 #define QUIT BUTTON_POWER
105 #define LEFT BUTTON_LEFT
106 #define RIGHT BUTTON_RIGHT
107 #define FIRE BUTTON_PLAY
108
109 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
110 (CONFIG_KEYPAD == IPOD_3G_PAD) || \
111 (CONFIG_KEYPAD == IPOD_1G2G_PAD)
112
113 #define QUIT BUTTON_MENU
114 #define LEFT BUTTON_LEFT
115 #define RIGHT BUTTON_RIGHT
116 #define FIRE BUTTON_SELECT
117
118 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD
119
120 #define QUIT BUTTON_POWER
121 #define LEFT BUTTON_LEFT
122 #define RIGHT BUTTON_RIGHT
123 #define FIRE BUTTON_SELECT
124
125 #elif CONFIG_KEYPAD == GIGABEAT_PAD
126
127 #define QUIT BUTTON_POWER
128 #define LEFT BUTTON_LEFT
129 #define RIGHT BUTTON_RIGHT
130 #define FIRE BUTTON_SELECT
131
132 #elif CONFIG_KEYPAD == SANSA_E200_PAD
133
134 #define QUIT BUTTON_POWER
135 #define LEFT BUTTON_LEFT
136 #define RIGHT BUTTON_RIGHT
137 #define FIRE BUTTON_SELECT
138
139 #elif CONFIG_KEYPAD == SANSA_FUZE_PAD
140
141 #define QUIT (BUTTON_HOME|BUTTON_REPEAT)
142 #define LEFT BUTTON_LEFT
143 #define RIGHT BUTTON_RIGHT
144 #define FIRE BUTTON_SELECT
145
146 #elif CONFIG_KEYPAD == TATUNG_TPJ1022_PAD
147
148 /* TODO: Figure out which buttons to use for Tatung Elio TPJ-1022 */
149 #define QUIT BUTTON_AB
150 #define LEFT BUTTON_LEFT
151 #define RIGHT BUTTON_RIGHT
152 #define FIRE BUTTON_MENU
153
154 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
155
156 #define QUIT BUTTON_BACK
157 #define LEFT BUTTON_LEFT
158 #define RIGHT BUTTON_RIGHT
159 #define FIRE BUTTON_SELECT
160
161 #elif CONFIG_KEYPAD == COWON_D2_PAD
162
163 #define QUIT BUTTON_POWER
164 #define LEFT BUTTON_MINUS
165 #define RIGHT BUTTON_PLUS
166 #define FIRE BUTTON_MENU
167
168 #elif CONFIG_KEYPAD == IAUDIO67_PAD
169
170 #define QUIT BUTTON_POWER
171 #define LEFT BUTTON_LEFT
172 #define RIGHT BUTTON_RIGHT
173 #define FIRE BUTTON_PLAY
174
175 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
176
177 #define QUIT BUTTON_BACK
178 #define LEFT BUTTON_LEFT
179 #define RIGHT BUTTON_RIGHT
180 #define FIRE BUTTON_SELECT
181
182 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
183
184 #define QUIT BUTTON_POWER
185 #define LEFT BUTTON_PREV
186 #define RIGHT BUTTON_NEXT
187 #define FIRE BUTTON_PLAY
188
189 #elif CONFIG_KEYPAD == ONDAVX747_PAD || \
190 CONFIG_KEYPAD == ONDAVX777_PAD || \
191 CONFIG_KEYPAD == MROBE500_PAD
192
193 #define QUIT BUTTON_POWER
194
195 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
196
197 #define QUIT BUTTON_REC
198 #define LEFT BUTTON_LEFT
199 #define RIGHT BUTTON_RIGHT
200 #define FIRE BUTTON_PLAY
201
202 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
203
204 #define QUIT BUTTON_REC
205 #define LEFT BUTTON_PREV
206 #define RIGHT BUTTON_NEXT
207 #define FIRE BUTTON_OK
208
209 #else
210 #error INVADROX: Unsupported keypad
211 #endif
212
213 #ifndef RC_QUIT
214 #define RC_QUIT 0
215 #endif
216
217 #ifdef HAVE_TOUCHSCREEN
218
219 #ifndef QUIT
220 #define QUIT 0
221 #endif
222 #ifndef LEFT
223 #define LEFT 0
224 #endif
225 #ifndef RIGHT
226 #define RIGHT 0
227 #endif
228 #ifndef FIRE
229 #define FIRE 0
230 #endif
231
232 #define TOUCHSCREEN_QUIT BUTTON_TOPLEFT
233 #define TOUCHSCREEN_LEFT (BUTTON_MIDLEFT | BUTTON_BOTTOMLEFT)
234 #define TOUCHSCREEN_RIGHT (BUTTON_MIDRIGHT | BUTTON_BOTTOMRIGHT)
235 #define TOUCHSCREEN_FIRE (BUTTON_CENTER | BUTTON_BOTTOMMIDDLE)
236
237 #define ACTION_QUIT (QUIT | TOUCHSCREEN_QUIT | RC_QUIT)
238 #define ACTION_LEFT (LEFT | TOUCHSCREEN_LEFT)
239 #define ACTION_RIGHT (RIGHT | TOUCHSCREEN_RIGHT)
240 #define ACTION_FIRE (FIRE | TOUCHSCREEN_FIRE)
241
242 #else /* HAVE_TOUCHSCREEN */
243
244 #define ACTION_QUIT (QUIT | RC_QUIT)
245 #define ACTION_LEFT LEFT
246 #define ACTION_RIGHT RIGHT
247 #define ACTION_FIRE FIRE
248
249 #endif
250
251 #ifndef UNUSED
252 #define UNUSED __attribute__ ((unused))
253 #endif
254
255 /* Defines common to all models */
256 #define UFO_Y (SCORENUM_Y + FONT_HEIGHT + ALIEN_HEIGHT)
257 #define PLAYFIELD_Y (LCD_HEIGHT - SHIP_HEIGHT - 2)
258 #define PLAYFIELD_WIDTH (LCD_WIDTH - 2 * PLAYFIELD_X)
259 #define LEVEL_X (LCD_WIDTH - PLAYFIELD_X - LIVES_X - 2 * NUMBERS_WIDTH - 3 * NUM_SPACING)
260 #define SHIP_MIN_X (PLAYFIELD_X + PLAYFIELD_WIDTH / 5 - SHIELD_WIDTH / 2 - SHIP_WIDTH)
261 #define SHIP_MAX_X (PLAYFIELD_X + 4 * PLAYFIELD_WIDTH / 5 + SHIELD_WIDTH / 2)
262 /* SCORE_Y = 0 for most targets. Gigabeat redefines it later. */
263 #define SCORE_Y 0
264 #define MAX_LIVES 8
265
266
267 /* m:robe 500 defines */
268 #if ((LCD_WIDTH == 640) && (LCD_HEIGHT == 480)) || \
269 ((LCD_WIDTH == 480) && (LCD_HEIGHT == 640))
270
271 /* Original arcade game size 224x240, 1bpp with
272 * red overlay at top and green overlay at bottom.
273 *
274 * M:Robe 500: 640x480x16
275 * ======================
276 */
277
278 #define ARCADISH_GRAPHICS
279 #define PLAYFIELD_X 48
280 #define SHIP_Y (PLAYFIELD_Y - 2 * SHIP_HEIGHT)
281 #define ALIEN_START_Y (UFO_Y + ALIEN_HEIGHT)
282 #define SCORENUM_X (PLAYFIELD_X + NUMBERS_WIDTH)
283 #define SCORENUM_Y (SCORE_Y + FONT_HEIGHT + 2)
284 #define HISCORENUM_X (LCD_WIDTH - PLAYFIELD_X - 1 - 6 * NUMBERS_WIDTH - 5 * NUM_SPACING)
285 #define SHIELD_Y (PLAYFIELD_Y - 5 * SHIP_HEIGHT)
286 #define LIVES_X 10
287 #define MAX_Y 18
288
289 /* iPod Video defines */
290 #elif (LCD_WIDTH == 320) && (LCD_HEIGHT == 240)
291
292 /* Original arcade game size 224x240, 1bpp with
293 * red overlay at top and green overlay at bottom.
294 *
295 * iPod Video: 320x240x16
296 * ======================
297 * X: 48p padding at left/right gives 224p playfield in middle.
298 * 10p "border" gives 204p actual playfield. UFO use full 224p.
299 * Y: Use full 240p.
300 *
301 * MAX_X = (204 - 12) / 2 - 1 = 95
302 *
303 * Y: Score text 7 0
304 * Space 10 7
305 * Score 7 17
306 * Space 8 24
307 * 3 Ufo 7 32
308 * 2 Space Aliens start at 32 + 3 * 8 = 56
309 * 0 aliens 9*8 56 -
310 * space ~7*8 128 | 18.75 aliens space between
311 * shield 2*8 182 | first alien and ship.
312 * space 8 198 | MAX_Y = 18
313 * ship 8 206 -
314 * space 2*8 214
315 * hline 1 230 - PLAYFIELD_Y
316 * bottom border 10 240
317 * Lives and Level goes inside bottom border
318 */
319
320 #define ARCADISH_GRAPHICS
321 #define PLAYFIELD_X 48
322 #define SHIP_Y (PLAYFIELD_Y - 3 * SHIP_HEIGHT)
323 #define ALIEN_START_Y (UFO_Y + 3 * ALIEN_HEIGHT)
324 #define SCORENUM_X (PLAYFIELD_X + NUMBERS_WIDTH)
325 #define SCORENUM_Y SCORE_Y + (2 * (FONT_HEIGHT + 1) + 1)
326 #define HISCORENUM_X (LCD_WIDTH - PLAYFIELD_X - 1 - 6 * NUMBERS_WIDTH - 5 * NUM_SPACING)
327 #define SHIELD_Y (PLAYFIELD_Y - 6 * SHIP_HEIGHT)
328 #define LIVES_X 10
329 #define MAX_Y 18
330
331 #elif (LCD_WIDTH == 176) && (LCD_HEIGHT == 220)
332
333 /* Sandisk Sansa e200: 176x220x16
334 * ==============================
335 * X: No padding. 8p border -> 160p playfield.
336 *
337 * 8p Aliens with 3p spacing -> 88 + 30 = 118p aliens block.
338 * (160 - 118) / 2 = 21 rounds for whole block (more than original)
339 * MAX_X = (160 - 8) / 2 - 1 = 75 rounds for single alien (less than original)
340 *
341 * LOGO 70 0
342 * Score text 5 70
343 * Space 5 75
344 * Y Score 5 80
345 * Space 10 85
346 * 2 Ufo 5 95
347 * 2 Space 10 100
348 * 0 aliens 9*5 110 -
349 * space ~7*5 155 | 18.6 aliens space between
350 * shield 2*5 188 | first alien and ship.
351 * space 5 198 | MAX_Y = 18
352 * ship 5 203 -
353 * space 5 208
354 * hline 1 213 PLAYFIELD_Y
355 * bottom border 6
356 * LCD_HEIGHT 220
357 * Lives and Level goes inside bottom border
358 */
359
360 #define SMALL_GRAPHICS
361 #define PLAYFIELD_X 0
362 #define SHIP_Y (PLAYFIELD_Y - 2 * SHIP_HEIGHT)
363 #define SHIELD_Y (SHIP_Y - SHIP_HEIGHT - SHIELD_HEIGHT)
364 #define ALIEN_START_Y (UFO_Y + 3 * SHIP_HEIGHT)
365 /* Redefine SCORE_Y */
366 #undef SCORE_Y
367 #define SCORE_Y 70
368 #define SCORENUM_X (PLAYFIELD_X + NUMBERS_WIDTH)
369 #define SCORENUM_Y (SCORE_Y + 2 * FONT_HEIGHT)
370 #define HISCORENUM_X (LCD_WIDTH - PLAYFIELD_X - 1 - 6 * NUMBERS_WIDTH - 5 * NUM_SPACING)
371 #define LIVES_X 8
372 #define MAX_Y 18
373
374
375 #elif (LCD_WIDTH == 176) && (LCD_HEIGHT == 132)
376
377 /* iPod Nano: 176x132x16
378 * ======================
379 * X: No padding. 8p border -> 160p playfield.
380 *
381 * LIVES_X 8
382 * ALIEN_WIDTH 8
383 * ALIEN_HEIGHT 5
384 * ALIEN_SPACING 3
385 * SHIP_WIDTH 10
386 * SHIP_HEIGHT 5
387 * FONT_HEIGHT 5
388 * UFO_WIDTH 10
389 * UFO_HEIGHT 5
390 * SHIELD_WIDTH 15
391 * SHIELD_HEIGHT 10
392 * MAX_X 75
393 * MAX_Y = 18
394 * ALIEN_START_Y (UFO_Y + 12)
395 *
396 * 8p Aliens with 3p spacing -> 88 + 30 = 118p aliens block.
397 * (160 - 118) / 2 = 21 rounds for whole block (more than original)
398 * MAX_X = (160 - 8) / 2 - 1 = 75 rounds for single alien (less than original)
399 *
400 * Y: Scoreline 5 0 (combine scoretext and numbers on same line)
401 * Space 5 5
402 * 1 Ufo 5 10
403 * 3 Space 7 15
404 * 2 aliens 9*5 22 -
405 * space ~7*5 67 | Just above 18 aliens space between
406 * shield 2*5 100 | first alien and ship.
407 * space 5 110 | MAX_Y = 18
408 * ship 5 115 -
409 * space 5 120
410 * hline 1 125 PLAYFIELD_Y
411 * bottom border 6 126
412 * LCD_HEIGHT 131
413 * Lives and Level goes inside bottom border
414 */
415
416 #define SMALL_GRAPHICS
417 #define PLAYFIELD_X 0
418 #define SHIP_Y (PLAYFIELD_Y - 2 * SHIP_HEIGHT)
419 #define ALIEN_START_Y (UFO_Y + 12)
420 #define SCORENUM_X (PLAYFIELD_X + 6 * NUMBERS_WIDTH + 5 * NUM_SPACING)
421 #define SCORENUM_Y SCORE_Y
422 #define HISCORENUM_X (LCD_WIDTH - PLAYFIELD_X - 4 * NUMBERS_WIDTH - 3 * NUM_SPACING)
423 #define SHIELD_Y (SHIP_Y - SHIP_HEIGHT - SHIELD_HEIGHT)
424 #define LIVES_X 8
425 #define MAX_Y 18
426
427 #elif (LCD_WIDTH == 160) && (LCD_HEIGHT == 128)
428
429 /* iAudio X5, iRiver H10 20Gb, iPod 3g/4g, H100, M5: 160x128
430 * =========================================================
431 * X: No padding. No border -> 160p playfield.
432 *
433 * LIVES_X 0
434 * ALIEN_WIDTH 8
435 * ALIEN_HEIGHT 5
436 * ALIEN_SPACING 3
437 * SHIP_WIDTH 10
438 * SHIP_HEIGHT 5
439 * FONT_HEIGHT 5
440 * UFO_WIDTH 10
441 * UFO_HEIGHT 5
442 * SHIELD_WIDTH 15
443 * SHIELD_HEIGHT 10
444 * MAX_X 75
445 * MAX_Y = 18
446 * ALIEN_START_Y (UFO_Y + 10)
447 *
448 * 8p Aliens with 3p spacing -> 88 + 30 = 118p aliens block.
449 * (160 - 118) / 2 = 21 rounds for whole block (more than original)
450 * MAX_X = (160 - 8) / 2 - 1 = 75 rounds for single alien (less than original)
451 *
452 * Y: Scoreline 5 0 (combine scoretext and numbers on same line)
453 * Space 5 5
454 * 1 Ufo 5 10
455 * 2 Space 5 15
456 * 8 aliens 9*5 20 -
457 * space ~6*5 65 | Just above 18 aliens space between
458 * shield 2*5 96 | first alien and ship.
459 * space 5 106 | MAX_Y = 18
460 * ship 5 111 -
461 * space 5 116
462 * hline 1 121 PLAYFIELD_Y
463 * bottom border 6 122
464 * LCD_HEIGHT 128
465 * Lives and Level goes inside bottom border
466 */
467
468 #define SMALL_GRAPHICS
469 #define PLAYFIELD_X 0
470 #define SHIP_Y (PLAYFIELD_Y - 2 * SHIP_HEIGHT)
471 #define ALIEN_START_Y (UFO_Y + 10)
472 #define SCORENUM_X (PLAYFIELD_X + 6 * NUMBERS_WIDTH + 5 * NUM_SPACING)
473 #define SCORENUM_Y SCORE_Y
474 #define HISCORENUM_X (LCD_WIDTH - PLAYFIELD_X - 4 * NUMBERS_WIDTH - 3 * NUM_SPACING)
475 #define SHIELD_Y (SHIP_Y - SHIP_HEIGHT - SHIELD_HEIGHT)
476 #define LIVES_X 0
477 #define MAX_Y 18
478
479
480 #elif (LCD_WIDTH == 240) && ((LCD_HEIGHT == 320) || (LCD_HEIGHT == 400))
481
482 /* Gigabeat: 240x320x16
483 * ======================
484 * X: 8p padding at left/right gives 224p playfield in middle.
485 * 10p "border" gives 204p actual playfield. UFO use full 224p.
486 * Y: Use bottom 240p for playfield and top 80 pixels for logo.
487 *
488 * MAX_X = (204 - 12) / 2 - 1 = 95
489 *
490 * Y: Score text 7 0 + 80
491 * Space 10 7 + 80
492 * Score 7 17 + 80
493 * Space 8 24 + 80
494 * 3 Ufo 7 32 + 80
495 * 2 Space Aliens start at 32 + 3 * 8 = 56
496 * 0 aliens 9*8 56 -
497 * space ~7*8 128 | 18.75 aliens space between
498 * shield 2*8 182 | first alien and ship.
499 * space 8 198 | MAX_Y = 18
500 * ship 8 206 -
501 * space 2*8 214
502 * hline 1 230 310 - PLAYFIELD_Y
503 * bottom border 10 240 320
504 * Lives and Level goes inside bottom border
505 */
506
507 #define ARCADISH_GRAPHICS
508 #define PLAYFIELD_X 8
509 #define SHIP_Y (PLAYFIELD_Y - 3 * SHIP_HEIGHT)
510 #define ALIEN_START_Y (UFO_Y + 3 * ALIEN_HEIGHT)
511 /* Redefine SCORE_Y */
512 #undef SCORE_Y
513 #define SCORE_Y 80
514 #define SCORENUM_X (PLAYFIELD_X + NUMBERS_WIDTH)
515 #define SCORENUM_Y SCORE_Y + (2 * (FONT_HEIGHT + 1) + 1)
516 #define HISCORENUM_X (LCD_WIDTH - PLAYFIELD_X - 1 - 6 * NUMBERS_WIDTH - 5 * NUM_SPACING)
517 #define SHIELD_Y (PLAYFIELD_Y - 6 * SHIP_HEIGHT)
518 #define LIVES_X 10
519 #define MAX_Y 18
520
521 #elif (LCD_WIDTH == 220) && (LCD_HEIGHT == 176)
522
523 /* TPJ1022, H300, iPod Color: 220x176x16
524 * ============================
525 * X: 0p padding at left/right gives 220p playfield in middle.
526 * 8p "border" gives 204p actual playfield. UFO use full 220p.
527 * Y: Use full 176p for playfield.
528 *
529 * MAX_X = (204 - 12) / 2 - 1 = 95
530 *
531 * Y: Score text 7 0
532 * Space 8 7
533 * 1 Ufo 7 15
534 * 7 Space Aliens start at 15 + 3 * 8 = 56
535 * 6 aliens 9*8 25 -
536 * space ~7*8 103 | 15.6 aliens space between
537 * shield 2*8 126 | first alien and ship.
538 * space 8 142 | MAX_Y = 15
539 * ship 8 150 -
540 * space 8 158
541 * hline 1 166 - PLAYFIELD_Y
542 * bottom border 10 176
543 * Lives and Level goes inside bottom border
544 */
545
546 #define ARCADISH_GRAPHICS
547 #define PLAYFIELD_X 0
548 #define SHIP_Y (PLAYFIELD_Y - 2 * SHIP_HEIGHT)
549 #define ALIEN_START_Y (UFO_Y + 10)
550 #define SCORENUM_Y SCORE_Y
551 #define SCORENUM_X (PLAYFIELD_X + 6 * NUMBERS_WIDTH + 6 * NUM_SPACING)
552 #define HISCORENUM_X (LCD_WIDTH - PLAYFIELD_X - 4 * NUMBERS_WIDTH - 3 * NUM_SPACING)
553 #define SHIELD_Y (PLAYFIELD_Y - 5 * SHIP_HEIGHT)
554 #define LIVES_X 8
555 #define MAX_Y 15
556
557
558 #else
559 #error INVADROX: Unsupported LCD type
560 #endif
561
562 #define MAX_X ((LCD_WIDTH-LIVES_X*2-PLAYFIELD_X*2 - ALIEN_WIDTH)/2 - 1)
563
564 /* Defines common to each "graphic type" */
565 #ifdef ARCADISH_GRAPHICS
566
567 #define SHOT_HEIGHT 5
568 #define ALIEN_SPACING 4
569 #define ALIEN_SPEED 2
570 #define UFO_SPEED 1
571 #define NUM_SPACING 3
572 #define FIRE_SPEED 8
573 #define BOMB_SPEED 3
574 #define ALIENS 11
575
576 #elif defined SMALL_GRAPHICS
577
578 #define SHOT_HEIGHT 4
579 #define ALIEN_SPACING 3
580 #define ALIEN_SPEED 2
581 #define UFO_SPEED 1
582 #define NUM_SPACING 2
583 #define FIRE_SPEED 6
584 #define BOMB_SPEED 2
585 #define ALIENS 11
586
587 #else
588 #error Graphic type not defined
589 #endif
590
591
592 /* Colors */
593 #if (LCD_DEPTH >= 8)
594 #define SLIME_GREEN LCD_RGBPACK(31, 254, 31)
595 #define UFO_RED LCD_RGBPACK(254, 31, 31)
596 #elif (LCD_DEPTH == 2)
597 #define SLIME_GREEN LCD_LIGHTGRAY
598 #define UFO_RED LCD_LIGHTGRAY
599 #else
600 #error LCD type not implemented yet
601 #endif
602
603 /* Alien states */
604 #define DEAD 0
605 #define ALIVE 1
606 #define BOMBER 2
607
608 /* Fire/bomb/ufo states */
609 #define S_IDLE 0
610 #define S_ACTIVE 1
611 #define S_SHOWSCORE 2
612 #define S_EXPLODE -9
613
614 /* Fire/bomb targets */
615 #define TARGET_TOP 0
616 #define TARGET_SHIELD 1
617 #define TARGET_SHIP 2
618 #define TARGET_BOTTOM 3
619 #define TARGET_UFO 4
620
621 #define HISCOREFILE PLUGIN_GAMES_DIR "/invadrox.high"
622
623
624 /* The time (in ms) for one iteration through the game loop - decrease this
625 * to speed up the game - note that current_tick is (currently) only accurate
626 * to 10ms.
627 */
628 #define CYCLETIME 40
629
630
631 /* Physical x is at PLAYFIELD_X + LIVES_X + x * ALIEN_SPEED
632 * Physical y is at y * ALIEN_HEIGHT
633 */
634 struct alien {
635 int x; /* x-coordinate (0 - 95) */
636 int y; /* y-coordinate (0 - 18) */
637 unsigned char type; /* 0 (Kang), 1 (Kodos), 2 (Serak) */
638 unsigned char state; /* Dead, alive or bomber */
639 };
640
641 /* Aliens box 5 rows * ALIENS aliens in each row */
642 struct alien aliens[5 * ALIENS];
643
644 #define MAX_BOMBS 4
645 struct bomb {
646 int x, y;
647 unsigned char type;
648 unsigned char frame; /* Current animation frame */
649 unsigned char frames; /* Number of frames in animation */
650 unsigned char target; /* Remember target during explosion frames */
651 int state; /* 0 (IDLE) = inactive, 1 (FIRE) or negative, exploding */
652 };
653 struct bomb bombs[MAX_BOMBS];
654 /* Increase max_bombs at higher levels */
655 int max_bombs;
656
657 /* Raw framebuffer value of shield/ship green color */
658 fb_data screen_green, screen_white;
659
660 /* For optimization, precalculate startoffset of each scanline */
661 unsigned int ytab[LCD_HEIGHT];
662
663 int lives = 2;
664 int score = 0;
665 int scores[3] = { 30, 20, 10 };
666 int level = 0;
667 struct highscore hiscore;
668 bool game_over = false;
669 int ship_x, old_ship_x, ship_dir, ship_acc, max_ship_speed;
670 int ship_frame, ship_frame_counter;
671 bool ship_hit;
672 int fire, fire_target, fire_x, fire_y;
673 int curr_alien, aliens_paralyzed, gamespeed;
674 int ufo_state, ufo_x;
675 bool level_finished;
676 bool aliens_down, aliens_right, hit_left_border, hit_right_border;
677
678
679 /* No standard get_pixel function yet, use this hack instead */
680 #if (LCD_DEPTH >= 8)
681
682 #if defined(LCD_STRIDEFORMAT) && LCD_STRIDEFORMAT == VERTICAL_STRIDE
683 inline fb_data get_pixel(int x, int y)
684 {
685 return rb->lcd_framebuffer[x*LCD_HEIGHT+y];
686 }
687 #else
688 inline fb_data get_pixel(int x, int y)
689 {
690 return rb->lcd_framebuffer[ytab[y] + x];
691 }
692 #endif
693
694 #elif (LCD_DEPTH == 2)
695
696 #if (LCD_PIXELFORMAT == HORIZONTAL_PACKING)
697 static const unsigned char shifts[4] = {
698 6, 4, 2, 0
699 };
700 /* Horizontal packing */
701 inline fb_data get_pixel(int x, int y)
702 {
703 return (rb->lcd_framebuffer[ytab[y] + (x >> 2)] >> shifts[x & 3]) & 3;
704 }
705 #else
706 /* Vertical packing */
707 static const unsigned char shifts[4] = {
708 0, 2, 4, 6
709 };
710 inline fb_data get_pixel(int x, int y)
711 {
712 return (rb->lcd_framebuffer[ytab[y] + x] >> shifts[y & 3]) & 3;
713 }
714 #endif /* Horizontal/Vertical packing */
715
716 #else
717 #error get_pixel: pixelformat not implemented yet
718 #endif
719
720
721 /* Draw "digits" least significant digits of num at (x,y) */
722 void draw_number(int x, int y, int num, int digits)
723 {
724 int i;
725 int d;
726
727 for (i = digits - 1; i >= 0; i--) {
728 d = num % 10;
729 num = num / 10;
730 rb->lcd_bitmap_part(invadrox_numbers, d * NUMBERS_WIDTH, 0,
731 STRIDE( SCREEN_MAIN,
732 BMPWIDTH_invadrox_numbers,
733 BMPHEIGHT_invadrox_numbers),
734 x + i * (NUMBERS_WIDTH + NUM_SPACING), y,
735 NUMBERS_WIDTH, FONT_HEIGHT);
736 }
737 /* Update lcd */
738 rb->lcd_update_rect(x, y, 4 * NUMBERS_WIDTH + 3 * NUM_SPACING, FONT_HEIGHT);
739 }
740
741
742 inline void draw_score(void)
743 {
744 draw_number(SCORENUM_X, SCORENUM_Y, score, 4);
745 if (score > hiscore.score) {
746 /* Draw new hiscore (same as score) */
747 draw_number(HISCORENUM_X, SCORENUM_Y, score, 4);
748 }
749 }
750
751
752 void draw_level(void)
753 {
754 draw_number(LEVEL_X + 2 * NUM_SPACING, PLAYFIELD_Y + 2, level, 2);
755 }
756
757
758 void draw_lives(void)
759 {
760 int i;
761 /* Lives num */
762 rb->lcd_bitmap_part(invadrox_numbers, lives * NUMBERS_WIDTH, 0,
763 STRIDE( SCREEN_MAIN,
764 BMPWIDTH_invadrox_numbers,
765 BMPHEIGHT_invadrox_numbers),
766 PLAYFIELD_X + LIVES_X, PLAYFIELD_Y + 2,
767 NUMBERS_WIDTH, FONT_HEIGHT);
768
769 /* Ships */
770 for (i = 0; i < (lives - 1); i++) {
771 rb->lcd_bitmap_part(invadrox_ships, 0, 0,
772 STRIDE( SCREEN_MAIN,
773 BMPWIDTH_invadrox_ships,
774 BMPHEIGHT_invadrox_ships),
775 PLAYFIELD_X + LIVES_X + SHIP_WIDTH + i * (SHIP_WIDTH + NUM_SPACING),
776 PLAYFIELD_Y + 1, SHIP_WIDTH, SHIP_HEIGHT);
777 }
778
779 /* Erase ship to the right (if less than MAX_LIVES) */
780 if (lives < MAX_LIVES) {
781 rb->lcd_fillrect(PLAYFIELD_X + LIVES_X + SHIP_WIDTH + i * (SHIP_WIDTH + NUM_SPACING),
782 PLAYFIELD_Y + 1, SHIP_WIDTH, SHIP_HEIGHT);
783 }
784 /* Update lives (and level) part of screen */
785 rb->lcd_update_rect(PLAYFIELD_X + LIVES_X, PLAYFIELD_Y + 1,
786 PLAYFIELD_WIDTH - 2 * LIVES_X, MAX(FONT_HEIGHT + 1, SHIP_HEIGHT + 1));
787 }
788
789
790 inline void draw_aliens(void)
791 {
792 int i;
793
794 for (i = 0; i < 5 * ALIENS; i++) {
795 rb->lcd_bitmap_part(invadrox_aliens, aliens[i].x & 1 ? ALIEN_WIDTH : 0,
796 aliens[i].type * ALIEN_HEIGHT,
797 STRIDE( SCREEN_MAIN,
798 BMPWIDTH_invadrox_aliens,
799 BMPHEIGHT_invadrox_aliens),
800 PLAYFIELD_X + LIVES_X + aliens[i].x * ALIEN_SPEED,
801 ALIEN_START_Y + aliens[i].y * ALIEN_HEIGHT,
802 ALIEN_WIDTH, ALIEN_HEIGHT);
803 }
804 }
805
806
807 /* Return false if there is no next alive alien (round is over) */
808 inline bool next_alien(void)
809 {
810 bool ret = true;
811
812 do {
813 curr_alien++;
814 if (curr_alien % ALIENS == 0) {
815 /* End of this row. Move up one row. */
816 curr_alien -= 2 * ALIENS;
817 if (curr_alien < 0) {
818 /* No more aliens in this round. */
819 curr_alien = 4 * ALIENS;
820 ret = false;
821 }
822 }
823 } while (aliens[curr_alien].state == DEAD && ret);
824
825 if (!ret) {
826 /* No more alive aliens. Round finished. */
827 if (hit_right_border) {
828 if (hit_left_border) {
829 DBG("ERROR: both left and right borders are set (%d)\n", curr_alien);
830 }
831 /* Move down-left next round */
832 aliens_right = false;
833 aliens_down = true;
834 hit_right_border = false;
835 } else if (hit_left_border) {
836 /* Move down-right next round */
837 aliens_right = true;
838 aliens_down = true;
839 hit_left_border = false;
840 } else {
841 /* Not left nor right. Set down to false. */
842 aliens_down = false;
843 }
844 }
845
846 return ret;
847 }
848
849
850 /* All aliens have been moved.
851 * Set curr_alien to first alive.
852 * Return false if no-one is left alive.
853 */
854 bool first_alien(void)
855 {
856 int i, y;
857
858 for (y = 4; y >= 0; y--) {
859 for (i = y * ALIENS; i < (y + 1) * ALIENS; i++) {
860 if (aliens[i].state != DEAD) {
861 curr_alien = i;
862 return true;
863 }
864 }
865 }
866
867 /* All aliens dead. */
868 level_finished = true;
869
870 return false;
871 }
872
873
874 bool move_aliens(void)
875 {
876 int x, y, old_x, old_y;
877
878 /* Move current alien (curr_alien is pointing to a living alien) */
879
880 old_x = aliens[curr_alien].x;
881 old_y = aliens[curr_alien].y;
882
883 if (aliens_down) {
884 aliens[curr_alien].y++;
885 if (aliens[curr_alien].y == MAX_Y) {
886 /* Alien is at bottom. Game Over. */
887 DBG("Alien %d is at bottom. Game Over.\n", curr_alien);
888 game_over = true;
889 return false;
890 }
891 }
892
893 if (aliens_right) {
894 /* Moving right */
895 if (aliens[curr_alien].x < MAX_X) {
896 aliens[curr_alien].x++;
897 }
898
899 /* Now, after move, check if we hit the right border. */
900 if (aliens[curr_alien].x == MAX_X) {
901 hit_right_border = true;
902 }
903
904 } else {
905 /* Moving left */
906 if (aliens[curr_alien].x > 0) {
907 aliens[curr_alien].x--;
908 }
909
910 /* Now, after move, check if we hit the left border. */
911 if (aliens[curr_alien].x == 0) {
912 hit_left_border = true;
913 }
914 }
915
916 /* Erase old position */
917 x = PLAYFIELD_X + LIVES_X + old_x * ALIEN_SPEED;
918 y = ALIEN_START_Y + old_y * ALIEN_HEIGHT;
919 if (aliens[curr_alien].y != old_y) {
920 /* Moved in y-dir. Erase whole alien. */
921 rb->lcd_fillrect(x, y, ALIEN_WIDTH, ALIEN_HEIGHT);
922 } else {
923 if (aliens_right) {
924 /* Erase left edge */
925 rb->lcd_fillrect(x, y, ALIEN_SPEED, ALIEN_HEIGHT);
926 } else {
927 /* Erase right edge */
928 x += ALIEN_WIDTH - ALIEN_SPEED;
929 rb->lcd_fillrect(x, y, ALIEN_SPEED, ALIEN_HEIGHT);
930 }
931 }
932
933 /* Draw alien at new pos */
934 x = PLAYFIELD_X + LIVES_X + aliens[curr_alien].x * ALIEN_SPEED;
935 y = ALIEN_START_Y + aliens[curr_alien].y * ALIEN_HEIGHT;
936 rb->lcd_bitmap_part(invadrox_aliens,
937 aliens[curr_alien].x & 1 ? ALIEN_WIDTH : 0,
938 aliens[curr_alien].type * ALIEN_HEIGHT,
939 STRIDE( SCREEN_MAIN,
940 BMPWIDTH_invadrox_aliens,
941 BMPHEIGHT_invadrox_aliens),
942 x, y, ALIEN_WIDTH, ALIEN_HEIGHT);
943
944 if (!next_alien()) {
945 /* Round finished. Set curr_alien to first alive from bottom. */
946 if (!first_alien()) {
947 /* Should never happen. Taken care of in move_fire(). */
948 return false;
949 }
950 /* TODO: Play next background sound */
951 }
952
953 return true;
954 }
955
956
957 inline void draw_ship(void)
958 {
959 /* Erase old ship */
960 if (old_ship_x < ship_x) {
961 /* Move right. Erase leftmost part of ship. */
962 rb->lcd_fillrect(old_ship_x, SHIP_Y, ship_x - old_ship_x, SHIP_HEIGHT);
963 } else if (old_ship_x > ship_x) {
964 /* Move left. Erase rightmost part of ship. */
965 rb->lcd_fillrect(ship_x + SHIP_WIDTH, SHIP_Y, old_ship_x - ship_x, SHIP_HEIGHT);
966 }
967
968 /* Draw ship */
969 rb->lcd_bitmap_part(invadrox_ships, 0, ship_frame * SHIP_HEIGHT,
970 STRIDE( SCREEN_MAIN,
971 BMPWIDTH_invadrox_ships,
972 BMPHEIGHT_invadrox_ships),
973 ship_x, SHIP_Y, SHIP_WIDTH, SHIP_HEIGHT);
974 if (ship_hit) {
975 /* Alternate between frame 1 and 2 during hit */
976 ship_frame_counter++;
977 if (ship_frame_counter > 2) {
978 ship_frame_counter = 0;
979 ship_frame++;
980 if (ship_frame > 2) {
981 ship_frame = 1;
982 }
983 }
984 }
985
986 /* Save ship_x for next time */
987 old_ship_x = ship_x;
988 }
989
990
991 inline void fire_alpha(int xc, int yc, fb_data color)
992 {
993 int oldmode = rb->lcd_get_drawmode();
994
995 rb->lcd_set_foreground(color);
996 rb->lcd_set_drawmode(DRMODE_FG);
997
998 rb->lcd_mono_bitmap(invadrox_fire, xc - (FIRE_WIDTH/2), yc, FIRE_WIDTH, FIRE_HEIGHT);
999
1000 rb->lcd_set_foreground(LCD_BLACK);
1001 rb->lcd_set_drawmode(oldmode);
1002 }
1003
1004
1005 void move_fire(void)
1006 {
1007 bool hit_green = false;
1008 bool hit_white = false;
1009 int i, j;
1010 static int exploding_alien = -1;
1011 fb_data pix;
1012
1013 if (fire == S_IDLE) {
1014 return;
1015 }
1016
1017 /* Alien hit. Wait until explosion is finished. */
1018 if (aliens_paralyzed < 0) {
1019 aliens_paralyzed++;
1020 if (aliens_paralyzed == 0) {
1021 /* Erase exploding_alien */
1022 rb->lcd_fillrect(PLAYFIELD_X + LIVES_X + aliens[exploding_alien].x * ALIEN_SPEED,
1023 ALIEN_START_Y + aliens[exploding_alien].y * ALIEN_HEIGHT,
1024 ALIEN_EXPLODE_WIDTH, ALIEN_HEIGHT);
1025 fire = S_IDLE;
1026 /* Special case. We killed curr_alien. */
1027 if (exploding_alien == curr_alien) {
1028 if (!next_alien()) {
1029 /* Round finished. Set curr_alien to first alive from bottom. */
1030 first_alien();
1031 }
1032 }
1033 }
1034 return;
1035 }
1036
1037 if (fire == S_ACTIVE) {
1038
1039 /* Erase */
1040 rb->lcd_vline(fire_x, fire_y, fire_y + SHOT_HEIGHT);
1041
1042 /* Check top */
1043 if (fire_y <= SCORENUM_Y + FONT_HEIGHT + 4) {
1044
1045 /* TODO: Play explode sound */
1046
1047 fire = S_EXPLODE;
1048 fire_target = TARGET_TOP;
1049 fire_alpha(fire_x, fire_y, UFO_RED);
1050 return;
1051 }
1052
1053 /* Move */
1054 fire_y -= FIRE_SPEED;
1055
1056 /* Hit UFO? */
1057 if (ufo_state == S_ACTIVE) {
1058 if ((ABS(ufo_x + UFO_WIDTH / 2 - fire_x) <= UFO_WIDTH / 2) &&
1059 (fire_y <= UFO_Y + UFO_HEIGHT)) {
1060 ufo_state = S_EXPLODE;
1061 fire = S_EXPLODE;
1062 fire_target = TARGET_UFO;
1063 /* Center explosion */
1064 ufo_x -= (UFO_EXPLODE_WIDTH - UFO_WIDTH) / 2;
1065 rb->lcd_bitmap(invadrox_ufo_explode, ufo_x, UFO_Y - 1,
1066 UFO_EXPLODE_WIDTH, UFO_EXPLODE_HEIGHT);
1067 return;
1068 }
1069 }
1070
1071 /* Hit bomb? (check position, not pixel value) */
1072 for (i = 0; i < max_bombs; i++) {
1073 if (bombs[i].state == S_ACTIVE) {
1074 /* Count as hit if within BOMB_WIDTH pixels */
1075 if ((ABS(bombs[i].x - fire_x) < BOMB_WIDTH) &&
1076 (fire_y - bombs[i].y < BOMB_HEIGHT)) {
1077 /* Erase bomb */
1078 rb->lcd_fillrect(bombs[i].x, bombs[i].y, BOMB_WIDTH, BOMB_HEIGHT);
1079 bombs[i].state = S_IDLE;
1080 /* Explode ship fire */
1081 fire = S_EXPLODE;
1082 fire_target = TARGET_SHIELD;
1083 fire_alpha(fire_x, fire_y, LCD_WHITE);
1084 return;
1085 }
1086 }
1087 }
1088
1089 /* Check for hit*/
1090 for (i = FIRE_SPEED; i >= 0; i--) {
1091 pix = get_pixel(fire_x, fire_y + i);
1092 if(pix == screen_white) {
1093 hit_white = true;
1094 fire_y += i;
1095 break;
1096 }
1097 if(pix == screen_green) {
1098 hit_green = true;
1099 fire_y += i;
1100 break;
1101 }
1102 }
1103
1104 if (hit_green) {
1105 /* Hit shield */
1106
1107 /* TODO: Play explode sound */
1108
1109 fire = S_EXPLODE;
1110 fire_target = TARGET_SHIELD;
1111 /* Center explosion around hit pixel */
1112 fire_y -= FIRE_HEIGHT / 2;
1113 fire_alpha(fire_x, fire_y, SLIME_GREEN);
1114 return;
1115 }
1116
1117 if (hit_white) {
1118
1119 /* Hit alien? */
1120 for (i = 0; i < 5 * ALIENS; i++) {
1121 if (aliens[i].state != DEAD &&
1122 (ABS(fire_x - (PLAYFIELD_X + LIVES_X + aliens[i].x * ALIEN_SPEED +
1123 ALIEN_WIDTH / 2)) <= ALIEN_WIDTH / 2) &&
1124 (ABS(fire_y - (ALIEN_START_Y + aliens[i].y * ALIEN_HEIGHT +
1125 ALIEN_HEIGHT / 2)) <= ALIEN_HEIGHT / 2)) {
1126
1127 /* TODO: play alien hit sound */
1128
1129 if (aliens[i].state == BOMBER) {
1130 /* Set (possible) alien above to bomber */
1131 for (j = i - ALIENS; j >= 0; j -= ALIENS) {
1132 if (aliens[j].state != DEAD) {
1133 /* printf("New bomber (%d, %d)\n", j % ALIENS, j / ALIENS); */
1134 aliens[j].state = BOMBER;
1135 break;
1136 }
1137 }
1138 }
1139 aliens[i].state = DEAD;
1140 exploding_alien = i;
1141 score += scores[aliens[i].type];
1142 draw_score();
1143 /* Update score part of screen */
1144 rb->lcd_update_rect(SCORENUM_X, SCORENUM_Y,
1145 PLAYFIELD_WIDTH - 2 * NUMBERS_WIDTH, FONT_HEIGHT);
1146
1147 /* Paralyze aliens S_EXPLODE frames */
1148 aliens_paralyzed = S_EXPLODE;
1149 rb->lcd_bitmap(invadrox_alien_explode,
1150 PLAYFIELD_X + LIVES_X + aliens[i].x * ALIEN_SPEED,
1151 ALIEN_START_Y + aliens[i].y * ALIEN_HEIGHT,
1152 ALIEN_EXPLODE_WIDTH, ALIEN_EXPLODE_HEIGHT);
1153 /* Since alien is 1 pixel taller than explosion sprite, erase bottom line */
1154 rb->lcd_hline(PLAYFIELD_X + LIVES_X + aliens[i].x * ALIEN_SPEED,
1155 PLAYFIELD_X + LIVES_X + aliens[i].x * ALIEN_SPEED + ALIEN_WIDTH,
1156 ALIEN_START_Y + (aliens[i].y + 1) * ALIEN_HEIGHT - 1);
1157 return;
1158 }
1159 }
1160 }
1161
1162 /* Draw shot */
1163 rb->lcd_set_foreground(LCD_WHITE);
1164 rb->lcd_vline(fire_x, fire_y, fire_y + SHOT_HEIGHT);
1165 rb->lcd_set_foreground(LCD_BLACK);
1166 } else if (fire < S_IDLE) {
1167 /* Count up towards S_IDLE, then erase explosion */
1168 fire++;
1169 if (fire == S_IDLE) {
1170 /* Erase explosion */
1171 if (fire_target == TARGET_TOP) {
1172 rb->lcd_fillrect(fire_x - (FIRE_WIDTH / 2), fire_y, FIRE_WIDTH, FIRE_HEIGHT);
1173 } else if (fire_target == TARGET_SHIELD) {
1174 /* Draw explosion with black pixels */
1175 fire_alpha(fire_x, fire_y, LCD_BLACK);
1176 }
1177 }
1178 }
1179 }
1180
1181
1182 /* Return a BOMBER alien */
1183 inline int random_bomber(void)
1184 {
1185 int i, col;
1186
1187 /* TODO: Weigh higher probability near ship */
1188 col = rb->rand() % ALIENS;
1189 for (i = col + 4 * ALIENS; i >= 0; i -= ALIENS) {
1190 if (aliens[i].state == BOMBER) {
1191 return i;
1192 }
1193 }
1194
1195 /* No BOMBER found in this col */
1196
1197 for (i = 0; i < 5 * ALIENS; i++) {
1198 if (aliens[i].state == BOMBER) {
1199 return i;
1200 }
1201 }
1202
1203 /* No BOMBER found at all (error?) */
1204
1205 return -1;
1206 }
1207
1208
1209 inline void draw_bomb(int i)
1210 {
1211 rb->lcd_bitmap_part(invadrox_bombs, bombs[i].type * BOMB_WIDTH,
1212 bombs[i].frame * BOMB_HEIGHT,
1213 STRIDE( SCREEN_MAIN,
1214 BMPWIDTH_invadrox_bombs,
1215 BMPHEIGHT_invadrox_bombs),
1216 bombs[i].x, bombs[i].y,
1217 BOMB_WIDTH, BOMB_HEIGHT);
1218 /* Advance frame */
1219 bombs[i].frame++;
1220 if (bombs[i].frame == bombs[i].frames) {
1221 bombs[i].frame = 0;
1222 }
1223 }
1224
1225
1226 void move_bombs(void)
1227 {
1228 int i, j, bomber;
1229 bool abort;
1230
1231 for (i = 0; i < max_bombs; i++) {
1232
1233 switch (bombs[i].state) {
1234
1235 case S_IDLE:
1236 if (ship_hit) {
1237 continue;
1238 }
1239 bomber = random_bomber();
1240 if (bomber < 0) {
1241 DBG("ERROR: No bomber available\n");
1242 continue;
1243 }
1244 /* x, y */
1245 bombs[i].x = PLAYFIELD_X + LIVES_X + aliens[bomber].x * ALIEN_SPEED + ALIEN_WIDTH / 2;
1246 bombs[i].y = ALIEN_START_Y + (aliens[bomber].y + 1) * ALIEN_HEIGHT;
1247
1248 /* Check for duplets in x and y direction */
1249 abort = false;
1250 for (j = i - 1; j >= 0; j--) {
1251 if ((bombs[j].state == S_ACTIVE) &&
1252 ((bombs[i].x == bombs[j].x) || (bombs[i].y == bombs[j].y))) {
1253 abort = true;
1254 break;
1255 }
1256 }
1257 if (abort) {
1258 /* Skip this one, continue with next bomb */
1259 /* printf("Bomb %d duplet of %d\n", i, j); */
1260 continue;
1261 }
1262
1263 /* Passed, set type */
1264 bombs[i].type = rb->rand() % 3;
1265 bombs[i].frame = 0;
1266 if (bombs[i].type == 0) {
1267 bombs[i].frames = 3;
1268 } else if (bombs[i].type == 1) {
1269 bombs[i].frames = 4;
1270 } else {
1271 bombs[i].frames = 6;
1272 }
1273
1274 /* Bombs away */
1275 bombs[i].state = S_ACTIVE;
1276 draw_bomb(i);
1277 continue;
1278
1279 break;
1280
1281 case S_ACTIVE:
1282 /* Erase old position */
1283 rb->lcd_fillrect(bombs[i].x, bombs[i].y, BOMB_WIDTH, BOMB_HEIGHT);
1284
1285 /* Move */
1286 bombs[i].y += BOMB_SPEED;
1287
1288 /* Check if bottom hit */
1289 if (bombs[i].y + BOMB_HEIGHT >= PLAYFIELD_Y) {
1290 bombs[i].y = PLAYFIELD_Y - FIRE_HEIGHT + 1;
1291 fire_alpha(bombs[i].x, bombs[i].y, LCD_WHITE);
1292 bombs[i].state = S_EXPLODE;
1293 bombs[i].target = TARGET_BOTTOM;
1294 break;
1295 }
1296
1297 /* Check for green (ship or shield) */
1298 for (j = BOMB_HEIGHT; j >= BOMB_HEIGHT - BOMB_SPEED; j--) {
1299 bombs[i].target = 0;
1300 if(get_pixel(bombs[i].x + BOMB_WIDTH / 2, bombs[i].y + j) == screen_green) {
1301 /* Move to hit pixel */
1302 bombs[i].x += BOMB_WIDTH / 2;
1303 bombs[i].y += j;
1304
1305 /* Check if ship is hit */
1306 if (bombs[i].y > SHIELD_Y + SHIELD_HEIGHT && bombs[i].y < PLAYFIELD_Y) {
1307
1308 /* TODO: play ship hit sound */
1309
1310 ship_hit = true;
1311 ship_frame = 1;
1312 ship_frame_counter = 0;
1313 bombs[i].state = S_EXPLODE * 4;
1314 bombs[i].target = TARGET_SHIP;
1315 rb->lcd_bitmap_part(invadrox_ships, 0, 1 * SHIP_HEIGHT,
1316 STRIDE( SCREEN_MAIN,
1317 BMPWIDTH_invadrox_ships,
1318 BMPHEIGHT_invadrox_ships),
1319 ship_x, SHIP_Y,
1320 SHIP_WIDTH, SHIP_HEIGHT);
1321 break;
1322 }
1323 /* Shield hit */
1324 bombs[i].state = S_EXPLODE;
1325 bombs[i].target = TARGET_SHIELD;
1326 /* Center explosion around hit pixel in shield */
1327 bombs[i].y -= FIRE_HEIGHT / 2;
1328 fire_alpha(bombs[i].x, bombs[i].y, SLIME_GREEN);
1329 break;
1330 }
1331 }
1332
1333 if (bombs[i].target != 0) {
1334 /* Hit ship or shield, continue */
1335 continue;
1336 }
1337
1338 draw_bomb(i);
1339 break;
1340
1341 default:
1342 /* If we get here state should be < 0, exploding */
1343 bombs[i].state++;
1344 if (bombs[i].state == S_IDLE) {
1345 if (ship_hit) {
1346 /* Erase explosion */
1347 rb->lcd_fillrect(ship_x, SHIP_Y, SHIP_WIDTH, SHIP_HEIGHT);
1348 rb->lcd_update_rect(ship_x, SHIP_Y, SHIP_WIDTH, SHIP_HEIGHT);
1349 ship_hit = false;
1350 ship_frame = 0;
1351 ship_x = PLAYFIELD_X + 2 * LIVES_X;
1352 lives--;
1353 if (lives == 0) {
1354 game_over = true;
1355 return;
1356 }
1357 draw_lives();
1358 /* Sleep 1s to give player time to examine lives left */
1359 rb->sleep(HZ);
1360 }
1361 /* Erase explosion (even if ship hit, might be another bomb) */
1362 fire_alpha(bombs[i].x, bombs[i].y, LCD_BLACK);
1363 }
1364 break;
1365 }
1366 }
1367 }
1368
1369
1370 inline void move_ship(void)
1371 {
1372 ship_dir += ship_acc;
1373 if (ship_dir > max_ship_speed) {
1374 ship_dir = max_ship_speed;
1375 }
1376 if (ship_dir < -max_ship_speed) {
1377 ship_dir = -max_ship_speed;
1378 }
1379 ship_x += ship_dir;
1380 if (ship_x < SHIP_MIN_X) {
1381 ship_x = SHIP_MIN_X;
1382 }
1383 if (ship_x > SHIP_MAX_X) {
1384 ship_x = SHIP_MAX_X;
1385 }
1386
1387 draw_ship();
1388 }
1389
1390
1391 /* Unidentified Flying Object */
1392 void move_ufo(void)
1393 {
1394 static int ufo_speed;
1395 static int counter;
1396 int mystery_score;
1397
1398 switch (ufo_state) {
1399
1400 case S_IDLE:
1401
1402 if (rb->rand() % 500 == 0) {
1403 /* Uh-oh, it's time to launch a mystery UFO */
1404
1405 /* TODO: Play UFO sound */
1406
1407 if (rb->rand() % 2) {
1408 ufo_speed = UFO_SPEED;
1409 ufo_x = PLAYFIELD_X;
1410 } else {
1411 ufo_speed = -UFO_SPEED;
1412 ufo_x = LCD_WIDTH - PLAYFIELD_X - UFO_WIDTH;
1413 }
1414 ufo_state = S_ACTIVE;
1415 /* UFO will be drawn next frame */
1416 }
1417 break;
1418
1419 case S_ACTIVE:
1420 /* Erase old pos */
1421 rb->lcd_fillrect(ufo_x, UFO_Y, UFO_WIDTH, UFO_HEIGHT);
1422 /* Move */
1423 ufo_x += ufo_speed;
1424 /* Check bounds */
1425 if (ufo_x < PLAYFIELD_X || ufo_x > LCD_WIDTH - PLAYFIELD_X - UFO_WIDTH) {
1426 ufo_state = S_IDLE;
1427 break;
1428 }
1429 /* Draw new pos */
1430 rb->lcd_bitmap(invadrox_ufo, ufo_x, UFO_Y, UFO_WIDTH, UFO_HEIGHT);
1431 break;
1432
1433 case S_SHOWSCORE:
1434 counter++;
1435 if (counter == S_IDLE) {
1436 /* Erase mystery number */
1437 rb->lcd_fillrect(ufo_x, UFO_Y, 3 * NUMBERS_WIDTH + 2 * NUM_SPACING, FONT_HEIGHT);
1438 ufo_state = S_IDLE;
1439 }
1440 break;
1441
1442 default:
1443 /* Exploding */
1444 ufo_state++;
1445 if (ufo_state == S_IDLE) {
1446 /* Erase explosion */
1447 rb->lcd_fillrect(ufo_x, UFO_Y - 1, UFO_EXPLODE_WIDTH, UFO_EXPLODE_HEIGHT);
1448 ufo_state = S_SHOWSCORE;
1449 counter = S_EXPLODE * 4;
1450 /* Draw mystery_score, sleep, increase score and continue */
1451 mystery_score = 50 + (rb->rand() % 6) * 50;
1452 if (mystery_score < 100) {
1453 draw_number(ufo_x, UFO_Y, mystery_score, 2);
1454 } else {
1455 draw_number(ufo_x, UFO_Y, mystery_score, 3);
1456 }
1457 score += mystery_score;
1458 draw_score();
1459 }
1460 break;
1461 }
1462 }
1463
1464
1465 void draw_background(void)
1466 {
1467
1468 rb->lcd_bitmap(invadrox_background, 0, 0, LCD_WIDTH, LCD_HEIGHT);
1469 rb->lcd_update();
1470 }
1471
1472
1473 void new_level(void)
1474 {
1475 int i;
1476
1477 draw_background();
1478 /* Give an extra life for each new level */
1479 if (lives < MAX_LIVES) {
1480 lives++;
1481 }
1482 draw_lives();
1483
1484 /* Score */
1485 draw_score();
1486 draw_number(HISCORENUM_X, SCORENUM_Y, hiscore.score, 4);
1487
1488 level++;
1489 draw_level();
1490 level_finished = false;
1491
1492 ufo_state = S_IDLE;
1493
1494 /* Init alien positions and states */
1495 for (i = 0; i < 4 * ALIENS; i++) {
1496 aliens[i].x = 0 + (i % ALIENS) * ((ALIEN_WIDTH + ALIEN_SPACING) / ALIEN_SPEED);
1497 aliens[i].y = 2 * (i / ALIENS);
1498 aliens[i].state = ALIVE;
1499 }
1500 /* Last row, bombers */
1501 for (i = 4 * ALIENS; i < 5 * ALIENS; i++) {
1502 aliens[i].x = 0 + (i % ALIENS) * ((ALIEN_WIDTH + ALIEN_SPACING) / ALIEN_SPEED);
1503 aliens[i].y = 2 * (i / ALIENS);
1504 aliens[i].state = BOMBER;
1505 }
1506
1507 /* Init bombs to inactive (S_IDLE) */
1508 for (i = 0; i < MAX_BOMBS; i++) {
1509 bombs[i].state = S_IDLE;
1510 }
1511
1512 /* Start aliens closer to earth from level 2 */
1513 for (i = 0; i < 5 * ALIENS; i++) {
1514 if (level < 6) {
1515 aliens[i].y += level - 1;
1516 } else {
1517 aliens[i].y += 5;
1518 }
1519 }
1520
1521 /* Max concurrent bombs */
1522 max_bombs = 1;
1523
1524 gamespeed = 2;
1525
1526 if (level > 1) {
1527 max_bombs++;
1528 }
1529
1530 /* Increase speed */
1531 if (level > 2) {
1532 gamespeed++;
1533 }
1534
1535 if (level > 3) {
1536 max_bombs++;
1537 }
1538
1539 /* Increase speed more */
1540 if (level > 4) {
1541 gamespeed++;
1542 }
1543
1544 if (level > 5) {
1545 max_bombs++;
1546 }
1547
1548 /* 4 shields */
1549 for (i = 1; i <= 4; i++) {
1550 rb->lcd_bitmap(invadrox_shield,
1551 PLAYFIELD_X + i * PLAYFIELD_WIDTH / 5 - SHIELD_WIDTH / 2,
1552 SHIELD_Y, SHIELD_WIDTH, SHIELD_HEIGHT);
1553 }
1554
1555 /* Bottom line */
1556 rb->lcd_set_foreground(SLIME_GREEN);
1557 rb->lcd_hline(PLAYFIELD_X, LCD_WIDTH - PLAYFIELD_X, PLAYFIELD_Y);
1558 /* Restore foreground to black (for fast erase later). */
1559 rb->lcd_set_foreground(LCD_BLACK);
1560
1561 ship_x = PLAYFIELD_X + 2 * LIVES_X;
1562 if (level == 1) {
1563 old_ship_x = ship_x;
1564 }
1565 ship_dir = 0;
1566 ship_acc = 0;
1567 ship_frame = 0;
1568 ship_hit = false;
1569 fire = S_IDLE;
1570 /* Start moving the bottom row left to right */
1571 curr_alien = 4 * ALIENS;
1572 aliens_paralyzed = 0;
1573 aliens_right = true;
1574 aliens_down = false;
1575 hit_left_border = false;
1576 hit_right_border = false;
1577 /* TODO: Change max_ship_speed to 3 at higher levels */
1578 max_ship_speed = 2;
1579
1580 draw_aliens();
1581
1582 rb->lcd_update();
1583 }
1584
1585
1586 void init_invadrox(void)
1587 {
1588 int i;
1589
1590 /* Seed random number generator with a "random" number */
1591 rb->srand(rb->get_time()->tm_sec + rb->get_time()->tm_min * 60);
1592
1593 /* Precalculate start of each scanline */
1594 for (i = 0; i < LCD_HEIGHT; i++) {
1595 #if (LCD_DEPTH >= 8)
1596 ytab[i] = i * LCD_WIDTH;
1597 #elif (LCD_DEPTH == 2) && (LCD_PIXELFORMAT == HORIZONTAL_PACKING)
1598 ytab[i] = i * (LCD_WIDTH / 4);
1599 #elif (LCD_DEPTH == 2) && (LCD_PIXELFORMAT == VERTICAL_PACKING)
1600 ytab[i] = (i / 4) * LCD_WIDTH;
1601 #else
1602 #error pixelformat not implemented yet
1603 #endif
1604 }
1605
1606 rb->lcd_set_background(LCD_BLACK);
1607 rb->lcd_set_foreground(LCD_BLACK);
1608
1609 if (highscore_load(HISCOREFILE, &hiscore, 1) < 0) {
1610 /* Init hiscore to 0 */
1611 rb->strlcpy(hiscore.name, "Invader", sizeof(hiscore.name));
1612 hiscore.score = 0;
1613 hiscore.level = 1;
1614 }
1615
1616 /* Init alien types in aliens array */
1617 for (i = 0; i < 1 * ALIENS; i++) {
1618 aliens[i].type = 0; /* Kang */
1619 }
1620 for (; i < 3 * ALIENS; i++) {
1621 aliens[i].type = 1; /* Kodos */
1622 }
1623 for (; i < 5 * ALIENS; i++) {
1624 aliens[i].type = 2; /* Serak */
1625 }
1626
1627
1628 /* Save screen white color */
1629 rb->lcd_set_foreground(LCD_WHITE);
1630 rb->lcd_drawpixel(0, 0);
1631 rb->lcd_update_rect(0, 0, 1, 1);
1632 screen_white = get_pixel(0, 0);
1633
1634 /* Save screen green color */
1635 rb->lcd_set_foreground(SLIME_GREEN);
1636 rb->lcd_drawpixel(0, 0);
1637 rb->lcd_update_rect(0, 0, 1, 1);
1638 screen_green = get_pixel(0, 0);
1639
1640 /* Restore black foreground */
1641 rb->lcd_set_foreground(LCD_BLACK);
1642
1643 new_level();
1644
1645 /* Flash score at start */
1646 for (i = 0; i < 5; i++) {
1647 rb->lcd_fillrect(SCORENUM_X, SCORENUM_Y,
1648 4 * NUMBERS_WIDTH + 3 * NUM_SPACING,
1649 FONT_HEIGHT);
1650 rb->lcd_update_rect(SCORENUM_X, SCORENUM_Y,
1651 4 * NUMBERS_WIDTH + 3 * NUM_SPACING,
1652 FONT_HEIGHT);
1653 rb->sleep(HZ / 10);
1654 draw_number(SCORENUM_X, SCORENUM_Y, score, 4);
1655 rb->sleep(HZ / 10);
1656 }
1657 }
1658
1659
1660 inline bool handle_buttons(void)
1661 {
1662 static unsigned int oldbuttonstate = 0;
1663
1664 unsigned int released, pressed, newbuttonstate;
1665
1666 if (ship_hit) {
1667 /* Don't allow ship movement during explosion */
1668 newbuttonstate = 0;
1669 } else {
1670 newbuttonstate = rb->button_status();
1671 }
1672 if(newbuttonstate == oldbuttonstate) {
1673 if (newbuttonstate == 0) {
1674 /* No button pressed. Stop ship. */
1675 ship_acc = 0;
1676 if (ship_dir > 0) {
1677 ship_dir--;
1678 }
1679 if (ship_dir < 0) {
1680 ship_dir++;
1681 }
1682 }
1683 /* return false; */
1684 goto check_usb;
1685 }
1686 released = ~newbuttonstate & oldbuttonstate;
1687 pressed = newbuttonstate & ~oldbuttonstate;
1688 oldbuttonstate = newbuttonstate;
1689 if (pressed) {
1690 if (pressed & ACTION_LEFT) {
1691 if (ship_acc > -1) {
1692 ship_acc--;
1693 }
1694 }
1695 if (pressed & ACTION_RIGHT) {
1696 if (ship_acc < 1) {
1697 ship_acc++;
1698 }
1699 }
1700 if (pressed & ACTION_FIRE) {
1701 if (fire == S_IDLE) {
1702 /* Fire shot */
1703 fire_x = ship_x + SHIP_WIDTH / 2;
1704 fire_y = SHIP_Y - SHOT_HEIGHT;
1705 fire = S_ACTIVE;
1706 /* TODO: play fire sound */
1707 }
1708 }
1709 if (pressed & ACTION_QUIT) {
1710 rb->splash(HZ * 1, "Quit");
1711 return true;
1712 }
1713 }
1714 if (released) {
1715 if ((released & ACTION_LEFT)) {
1716 if (ship_acc < 1) {
1717 ship_acc++;
1718 }
1719 }
1720 if ((released & ACTION_RIGHT)) {
1721 if (ship_acc > -1) {
1722 ship_acc--;
1723 }
1724 }
1725 }
1726
1727 check_usb:
1728
1729 /* Quit if USB is connected */
1730 if (rb->button_get(false) == SYS_USB_CONNECTED) {
1731 return true;
1732 }
1733
1734 return false;
1735 }
1736
1737
1738 void game_loop(void)
1739 {
1740 int i, end;
1741
1742 /* Print dimensions (just for debugging) */
1743 DBG("%03dx%03dx%02d\n", LCD_WIDTH, LCD_HEIGHT, LCD_DEPTH);
1744
1745 /* Init */
1746 init_invadrox();
1747
1748 while (1) {
1749 /* Convert CYCLETIME (in ms) to HZ */
1750 end = *rb->current_tick + (CYCLETIME * HZ) / 1000;
1751
1752 if (handle_buttons()) {
1753 return;
1754 }
1755
1756 /* Animate */
1757 move_ship();
1758 move_fire();
1759
1760 /* Check if level is finished (marked by move_fire) */
1761 if (level_finished) {
1762 /* TODO: Play level finished sound */
1763 new_level();
1764 }
1765
1766 move_ufo();
1767
1768 /* Move aliens */
1769 if (!aliens_paralyzed && !ship_hit) {
1770 for (i = 0; i < gamespeed; i++) {
1771 if (!move_aliens()) {
1772 if (game_over) {
1773 return;
1774 }
1775 }
1776 }
1777 }
1778
1779 /* Move alien bombs */
1780 move_bombs();
1781 if (game_over) {
1782 return;
1783 }
1784
1785 /* Update "playfield" rect */
1786 rb->lcd_update_rect(PLAYFIELD_X, SCORENUM_Y + FONT_HEIGHT,
1787 PLAYFIELD_WIDTH,
1788 PLAYFIELD_Y + 1 - SCORENUM_Y - FONT_HEIGHT);
1789
1790 /* Wait until next frame */
1791 DBG("%ld (%d)\n", end - *rb->current_tick, (CYCLETIME * HZ) / 1000);
1792 if (TIME_BEFORE(*rb->current_tick, end)) {
1793 rb->sleep(end - *rb->current_tick);
1794 } else {
1795 rb->yield();
1796 }
1797
1798 } /* end while */
1799 }
1800
1801
1802 /* this is the plugin entry point */
1803 enum plugin_status plugin_start(UNUSED const void* parameter)
1804 {
1805 rb->lcd_setfont(FONT_SYSFIXED);
1806 /* Turn off backlight timeout */
1807 backlight_force_on(); /* backlight control in lib/helper.c */
1808
1809 /* now go ahead and have fun! */
1810 game_loop();
1811
1812 /* Game Over. */
1813 /* TODO: Play game over sound */
1814 rb->splash(HZ * 2, "Game Over");
1815 if (score > hiscore.score) {
1816 /* Save new hiscore */
1817 highscore_update(score, level, "Invader", &hiscore, 1);
1818 highscore_save(HISCOREFILE, &hiscore, 1);
1819 }
1820
1821 /* Restore user's original backlight setting */
1822 rb->lcd_setfont(FONT_UI);
1823 /* Turn on backlight timeout (revert to settings) */
1824 backlight_use_settings(); /* backlight control in lib/helper.c */
1825
1826 return PLUGIN_OK;
1827 }
1828
1829
1830
1831 /**
1832 * GNU Emacs settings: Kernighan & Richie coding style with
1833 * 4 spaces indent and no tabs.
1834 * Local Variables:
1835 * c-file-style: "k&r"
1836 * c-basic-offset: 4
1837 * indent-tabs-mode: nil
1838 * End:
1839 */
My public Rockbox git repo