?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Accept FS#8341 - rename BUTTON_SCROLL_UP/DOWN to FWD/BACK on the e200 to make it...
[Rockbox.git] / apps / plugins / spacerocks.c
blob2ea1dc84e55191a91c1017e17626e50d44078186
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2006 by Mat Holton
11 *
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
14 *
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
17 *
18 ****************************************************************************/
19
20 #include "plugin.h"
21 #include "math.h"
22 #include "stdio.h"
23 #include "helper.h"
24
25 PLUGIN_HEADER
26
27 /******************************* Globals ***********************************/
28 static struct plugin_api* rb; /* global api struct pointer */
29 /* variable button definitions */
30 #if CONFIG_KEYPAD == RECORDER_PAD
31 #define AST_PAUSE BUTTON_ON
32 #define AST_QUIT BUTTON_OFF
33 #define AST_THRUST_REP BUTTON_UP | BUTTON_REPEAT
34 #define AST_THRUST BUTTON_UP
35 #define AST_HYPERSPACE BUTTON_DOWN
36 #define AST_LEFT BUTTON_LEFT
37 #define AST_LEFT_REP BUTTON_LEFT | BUTTON_REPEAT
38 #define AST_RIGHT BUTTON_RIGHT
39 #define AST_RIGHT_REP (BUTTON_RIGHT | BUTTON_REPEAT)
40 #define AST_FIRE BUTTON_PLAY
41 #define AST_FIRE_REP BUTTON_PLAY | BUTTON_REPEAT
42
43 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
44 #define AST_PAUSE BUTTON_ON
45 #define AST_QUIT BUTTON_OFF
46 #define AST_THRUST_REP BUTTON_UP | BUTTON_REPEAT
47 #define AST_THRUST BUTTON_UP
48 #define AST_HYPERSPACE BUTTON_DOWN
49 #define AST_LEFT BUTTON_LEFT
50 #define AST_LEFT_REP BUTTON_LEFT | BUTTON_REPEAT
51 #define AST_RIGHT BUTTON_RIGHT
52 #define AST_RIGHT_REP (BUTTON_RIGHT | BUTTON_REPEAT)
53 #define AST_FIRE BUTTON_SELECT
54 #define AST_FIRE_REP BUTTON_SELECT | BUTTON_REPEAT
55
56 #elif CONFIG_KEYPAD == ONDIO_PAD
57 #define AST_PAUSE (BUTTON_MENU | BUTTON_OFF)
58 #define AST_QUIT BUTTON_OFF
59 #define AST_THRUST BUTTON_UP
60 #define AST_THRUST_REP BUTTON_UP | BUTTON_REPEAT
61 #define AST_HYPERSPACE BUTTON_DOWN
62 #define AST_LEFT BUTTON_LEFT
63 #define AST_LEFT_REP BUTTON_LEFT | BUTTON_REPEAT
64 #define AST_RIGHT BUTTON_RIGHT
65 #define AST_RIGHT_REP (BUTTON_RIGHT | BUTTON_REPEAT)
66 #define AST_FIRE BUTTON_MENU
67 #define AST_FIRE_REP BUTTON_MENU | BUTTON_REPEAT
68
69 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
70 (CONFIG_KEYPAD == IRIVER_H300_PAD)
71 #define AST_PAUSE BUTTON_REC
72 #define AST_QUIT BUTTON_OFF
73 #define AST_THRUST_REP BUTTON_UP | BUTTON_REPEAT
74 #define AST_THRUST BUTTON_UP
75 #define AST_HYPERSPACE BUTTON_DOWN
76 #define AST_LEFT BUTTON_LEFT
77 #define AST_LEFT_REP BUTTON_LEFT | BUTTON_REPEAT
78 #define AST_RIGHT BUTTON_RIGHT
79 #define AST_RIGHT_REP (BUTTON_RIGHT | BUTTON_REPEAT)
80 #define AST_FIRE BUTTON_SELECT
81 #define AST_FIRE_REP BUTTON_SELECT | BUTTON_REPEAT
82
83 #define AST_RC_QUIT BUTTON_RC_STOP
84
85 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
86 #define AST_PAUSE BUTTON_PLAY
87 #define AST_QUIT BUTTON_POWER
88 #define AST_THRUST_REP BUTTON_UP | BUTTON_REPEAT
89 #define AST_THRUST BUTTON_UP
90 #define AST_HYPERSPACE BUTTON_DOWN
91 #define AST_LEFT BUTTON_LEFT
92 #define AST_LEFT_REP BUTTON_LEFT | BUTTON_REPEAT
93 #define AST_RIGHT BUTTON_RIGHT
94 #define AST_RIGHT_REP (BUTTON_RIGHT | BUTTON_REPEAT)
95 #define AST_FIRE BUTTON_SELECT
96 #define AST_FIRE_REP BUTTON_SELECT | BUTTON_REPEAT
97
98 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || (CONFIG_KEYPAD == IPOD_3G_PAD) || \
99 (CONFIG_KEYPAD == IPOD_1G2G_PAD)
100 #define AST_PAUSE (BUTTON_SELECT | BUTTON_PLAY)
101 #define AST_QUIT (BUTTON_SELECT | BUTTON_MENU)
102 #define AST_THRUST BUTTON_MENU
103 #define AST_THRUST_REP (BUTTON_MENU | BUTTON_REPEAT)
104 #define AST_HYPERSPACE BUTTON_PLAY
105 #define AST_LEFT BUTTON_SCROLL_BACK
106 #define AST_LEFT_REP (BUTTON_SCROLL_BACK | BUTTON_REPEAT)
107 #define AST_RIGHT BUTTON_SCROLL_FWD
108 #define AST_RIGHT_REP (BUTTON_SCROLL_FWD | BUTTON_REPEAT)
109 #define AST_FIRE BUTTON_SELECT
110 #define AST_FIRE_REP (BUTTON_SELECT | BUTTON_REPEAT)
111
112 #elif (CONFIG_KEYPAD == GIGABEAT_PAD)
113 #define AST_PAUSE BUTTON_A
114 #define AST_QUIT BUTTON_POWER
115 #define AST_THRUST_REP BUTTON_UP | BUTTON_REPEAT
116 #define AST_THRUST BUTTON_UP
117 #define AST_HYPERSPACE BUTTON_DOWN
118 #define AST_LEFT BUTTON_LEFT
119 #define AST_LEFT_REP BUTTON_LEFT | BUTTON_REPEAT
120 #define AST_RIGHT BUTTON_RIGHT
121 #define AST_RIGHT_REP (BUTTON_RIGHT | BUTTON_REPEAT)
122 #define AST_FIRE BUTTON_SELECT
123 #define AST_FIRE_REP BUTTON_SELECT | BUTTON_REPEAT
124
125 #elif (CONFIG_KEYPAD == SANSA_E200_PAD)
126 #define AST_PAUSE BUTTON_REC
127 #define AST_QUIT BUTTON_POWER
128 #define AST_THRUST_REP (BUTTON_UP | BUTTON_REPEAT)
129 #define AST_THRUST BUTTON_UP
130 #define AST_HYPERSPACE BUTTON_DOWN
131 #define AST_LEFT BUTTON_SCROLL_BACK
132 #define AST_LEFT_REP (BUTTON_SCROLL_BACK | BUTTON_REPEAT)
133 #define AST_RIGHT BUTTON_SCROLL_FWD
134 #define AST_RIGHT_REP (BUTTON_SCROLL_FWD | BUTTON_REPEAT)
135 #define AST_FIRE BUTTON_SELECT
136 #define AST_FIRE_REP (BUTTON_SELECT | BUTTON_REPEAT)
137
138 #elif (CONFIG_KEYPAD == SANSA_C200_PAD)
139 #define AST_PAUSE BUTTON_REC
140 #define AST_QUIT BUTTON_POWER
141 #define AST_THRUST_REP (BUTTON_UP | BUTTON_REPEAT)
142 #define AST_THRUST BUTTON_UP
143 #define AST_HYPERSPACE BUTTON_DOWN
144 #define AST_LEFT BUTTON_LEFT
145 #define AST_LEFT_REP (BUTTON_LEFT | BUTTON_REPEAT)
146 #define AST_RIGHT BUTTON_RIGHT
147 #define AST_RIGHT_REP (BUTTON_RIGHT | BUTTON_REPEAT)
148 #define AST_FIRE BUTTON_SELECT
149 #define AST_FIRE_REP (BUTTON_SELECT | BUTTON_REPEAT)
150
151 #elif (CONFIG_KEYPAD == IRIVER_H10_PAD)
152 #define AST_PAUSE BUTTON_PLAY
153 #define AST_QUIT BUTTON_POWER
154 #define AST_THRUST_REP BUTTON_SCROLL_UP | BUTTON_REPEAT
155 #define AST_THRUST BUTTON_SCROLL_UP
156 #define AST_HYPERSPACE BUTTON_SCROLL_DOWN
157 #define AST_LEFT BUTTON_LEFT
158 #define AST_LEFT_REP BUTTON_LEFT | BUTTON_REPEAT
159 #define AST_RIGHT BUTTON_RIGHT
160 #define AST_RIGHT_REP (BUTTON_RIGHT | BUTTON_REPEAT)
161 #define AST_FIRE BUTTON_REW
162 #define AST_FIRE_REP BUTTON_REW | BUTTON_REPEAT
163
164 #endif
165
166 #define ABS(x) ((x)>0?(x):-(x))
167
168 #define RES MAX(LCD_WIDTH, LCD_HEIGHT)
169 #define LARGE_LCD RES >= 200
170 #define ENEMY_MISSILE_SURVIVAL_LENGTH RES/2
171 #define ASTEROID_SPEED RES/20
172 #define MISSILE_SURVIVAL_LENGTH 40
173
174 #define EXTRA_LIFE 250
175 #define SCALE 5000
176 #define MISSILE_SCALE 5000
177 #define WRAP_GAP 12
178 #define EXPLOSION_LENGTH 20
179 #define SHOW_COL 0
180 #define HISCORE_FILE PLUGIN_GAMES_DIR "/astrorocks.hs"
181 #define POINT_SIZE 2
182 #define MAX_NUM_ASTEROIDS 25
183 #define MAX_NUM_MISSILES 6
184 #define ENEMY_BIG_PROBABILITY_START 10
185 #define ENEMY_APPEAR_PROBABILITY_START 35
186 #define ENEMY_APPEAR_TIMING_START 1800
187 #define LITTLE_SHIP 2
188 #define BIG_SHIP 1
189 #define SHOW_GAME_OVER_TIME 100
190 #define SHOW_LEVEL_TIME 50
191 #define START_LIVES 3
192 #define START_LEVEL 1
193 #define NUM_ASTEROID_VERTICES 10
194 #define NUM_SHIP_VERTICES 4
195 #define NUM_ENEMY_VERTICES 6
196 #define MAX_LEVEL MAX_NUM_ASTEROIDS
197 #define ENEMY_SPEED 4
198 #define ENEMY_START_X 0
199 #define ENEMY_START_Y 0
200 #define SIZE_ENEMY_COLLISION 5*SCALE
201 #define ATTRACT_FLIP_TIME 100
202 #define NUM_STARS 50
203 #define NUM_TRAIL_POINTS 70
204 #define NUM_ROTATIONS 16
205
206 #define SIN_COS_SCALE 10000
207
208 #define FAST_ROT_CW_SIN 873
209 #define FAST_ROT_CW_COS 9963
210 #define FAST_ROT_ACW_SIN -873
211 #define FAST_ROT_ACW_COS 9963
212
213 #define MEDIUM_ROT_CW_SIN 350
214 #define MEDIUM_ROT_CW_COS 9994
215 #define MEDIUM_ROT_ACW_SIN -350
216 #define MEDIUM_ROT_ACW_COS 9994
217
218 #define SLOW_ROT_CW_SIN 350
219 #define SLOW_ROT_CW_COS 9994
220 #define SLOW_ROT_ACW_SIN - 350
221 #define SLOW_ROT_ACW_COS 9994
222
223 #ifdef HAVE_LCD_COLOR
224 #define SHIP_ROT_CW_SIN 2419
225 #define SHIP_ROT_CW_COS 9702
226 #define SHIP_ROT_ACW_SIN -2419
227 #define SHIP_ROT_ACW_COS 9702
228 #else
229 #define SHIP_ROT_CW_SIN 3827
230 #define SHIP_ROT_CW_COS 9239
231 #define SHIP_ROT_ACW_SIN -3827
232 #define SHIP_ROT_ACW_COS 9239
233 #endif
234
235
236 #define SCALED_WIDTH (LCD_WIDTH*SCALE)
237 #define SCALED_HEIGHT (LCD_HEIGHT*SCALE)
238 #define CENTER_LCD_X (LCD_WIDTH/2)
239 #define CENTER_LCD_Y (LCD_HEIGHT/2)
240
241 #define SHIP_EXPLOSION_COLOUR 1
242 #define ASTEROID_EXPLOSION_COLOUR 2
243 #define ENEMY_EXPLOSION_COLOUR 3
244 #define THRUST_COLOUR 4
245
246 #define ASTEROID_R 230
247 #define ASTEROID_G 200
248 #define ASTEROID_B 100
249 #define SHIP_R 255
250 #define SHIP_G 255
251 #define SHIP_B 255
252 #define ENEMY_R 50
253 #define ENEMY_G 220
254 #define ENEMY_B 50
255 #define THRUST_R 200
256 #define THRUST_G 200
257 #define THRUST_B 0
258
259 #ifdef HAVE_LCD_COLOR
260 #define COL_MISSILE LCD_RGBPACK(200,0,0)
261 #define COL_PLAYER LCD_RGBPACK(200,200,200)
262 #define COL_STARS LCD_WHITE
263 #define COL_ASTEROID LCD_RGBPACK(ASTEROID_R,ASTEROID_G,ASTEROID_B)
264 #define COL_TEXT LCD_RGBPACK(200,200,255)
265 #define COL_ENEMY LCD_RGBPACK(ENEMY_R,ENEMY_G,ENEMY_B)
266 #define SET_FG rb->lcd_set_foreground
267 #define SET_BG rb->lcd_set_background
268 #else
269 #define SET_FG(x)
270 #define SET_BG(x)
271 #endif
272
273 /* The array of points that make up an asteroid */
274 static const short asteroid_one[NUM_ASTEROID_VERTICES*2] =
275 {
276 -2, -12,
277 4, -8,
278 8, -14,
279 16, -5,
280 14, 0,
281 20, 2,
282 12, 14,
283 -4, 14,
284 -10, 6,
285 -10, -8
286 };
287
288 /* The array of points that make up an asteroid */
289 static const short asteroid_two[NUM_ASTEROID_VERTICES*2] =
290 {
291 -2, -12,
292 4, -16,
293 6, -14,
294 16, -8,
295 14, 0,
296 20, 2,
297 12, 14,
298 -4, 14,
299 -10, 6,
300 -10, -8
301 };
302
303 /* The array of points that make up an asteroid */
304 static const short asteroid_three[NUM_ASTEROID_VERTICES*2] =
305 {
306 -2, -12,
307 4, -16,
308 6, -14,
309 2, -8,
310 14, 0,
311 20, 2,
312 12, 14,
313 -4, 14,
314 -16, 6,
315 -10, -8
316 };
317
318 /* The array od points the make up the ship */
319 static const short ship_vertices[NUM_SHIP_VERTICES*2] =
320 {
321 #if(LARGE_LCD)
322 0,-6,
323 4, 6,
324 0, 2,
325 -4, 6
326 #else
327 0,-4,
328 3, 4,
329 0, 1,
330 -3, 4
331 #endif
332 };
333
334 /* The array of points the make up the bad spaceship */
335 static const short enemy_vertices[NUM_ENEMY_VERTICES*2] =
336 {
337 #if(LARGE_LCD)
338 -8, 0,
339 -4, 4,
340 4, 4,
341 8, 0,
342 4, -4,
343 -4, -4
344 #else
345 -5, 0,
346 -2, 2,
347 2, 2,
348 5, 0,
349 2, -2,
350 -2, -2
351 #endif
352
353 };
354
355 enum asteroid_type
356 {
357 #if(LARGE_LCD)
358 SMALL = 2,
359 MEDIUM = 4,
360 LARGE = 6,
361 #else
362 SMALL = 1,
363 MEDIUM = 2,
364 LARGE = 3,
365 #endif
366
367 };
368
369 enum game_state
370 {
371 GAME_OVER,
372 ATTRACT_MODE,
373 SHOW_LEVEL,
374 PLAY_MODE,
375 PAUSE_MODE
376 };
377
378 struct Point
379 {
380 int x;
381 int y;
382 int dx;
383 int dy;
384 };
385
386 struct TrailPoint
387 {
388 int alive;
389 struct Point position;
390 short r;
391 short g;
392 short b;
393 short dec;
394 };
395
396 /* Asteroid structure, contains an array of points */
397 struct Asteroid
398 {
399 enum asteroid_type type;
400 bool exists;
401 struct Point position;
402 struct Point vertices[NUM_ASTEROID_VERTICES];
403 int radius;
404 long speed_cos;
405 long speed_sin;
406 int explode_countdown;
407 };
408
409 struct Ship
410 {
411 struct Point vertices[NUM_SHIP_VERTICES];
412 struct Point position;
413 bool waiting_for_space;
414 int explode_countdown;
415 };
416
417 struct Enemy
418 {
419 struct Point vertices[NUM_ENEMY_VERTICES];
420 struct Point position;
421 int explode_countdown;
422 long last_time_appeared;
423 short size_probability;
424 short appear_probability;
425 short appear_timing;
426 };
427
428 struct Missile
429 {
430 struct Point position;
431 struct Point oldpoint;
432 int survived;
433 };
434
435 static enum game_state game_state;
436 static int asteroid_count;
437 static int next_missile_count;
438 static int next_thrust_count;
439 static int num_lives;
440 static int extra_life;
441 static int show_level_timeout;
442 static int attract_flip_timeout;
443 static int show_game_over;
444 static int current_level;
445 static int current_score;
446 static int high_score;
447 static int space_check_size = 30*SCALE;
448
449 static bool enemy_on_screen;
450 static char phscore[30];
451 static struct Ship ship;
452 static struct Point stars[NUM_STARS];
453 static struct Asteroid asteroids_array[MAX_NUM_ASTEROIDS];
454 static struct Missile missiles_array[MAX_NUM_MISSILES];
455 static struct Missile enemy_missile;
456 static struct Enemy enemy;
457 static struct Point lives_points[NUM_SHIP_VERTICES];
458 static struct TrailPoint trailPoints[NUM_TRAIL_POINTS];
459
460 void draw_and_move_asteroids(void);
461 void initialise_game(int nStartNum);
462
463 bool is_asteroid_near_ship(struct Asteroid* asteroid);
464 bool is_point_within_asteroid(struct Asteroid* asteroid, struct Point* point);
465
466 void initialise_asteroid(struct Asteroid* asteroid, enum asteroid_type eType);
467 void draw_polygon(struct Point* vertices, int px, int py, int num_vertices);
468 void rotate_asteroid(struct Asteroid* asteroid);
469 void create_asteroid(enum asteroid_type type, int x, int y);
470 void create_stars(void);
471
472 void initialise_ship(void);
473 void draw_and_move_ship(void);
474 void rotate_ship(int s, int c);
475 void thrust_ship(void);
476
477 void initialise_missile(struct Missile* missile);
478 void draw_and_move_missiles(void);
479 void fire_missile(void);
480
481 void animate_and_draw_explosion(struct Point* point, int num_points, int xoffset, int yoffset);
482 void initialise_explosion(struct Point* point, int num_points);
483
484 void move_point(struct Point* point);
485 void hyperspace(void);
486 void check_collisions(void);
487 void initialise_enemy(void);
488 void draw_and_move_enemy(void);
489 void draw_lives(void);
490 void drawstars(void);
491 bool is_ship_within_asteroid(struct Asteroid* asteroid);
492
493
494
495 /*Hi-Score reading and writing to file - this needs moving to the hi-score plugin lib as
496 a 3rd function */
497 void iohiscore(void)
498 {
499 int fd;
500 int compare;
501
502 /* clear the buffer we're about to load the highscore data into */
503 rb->memset(phscore, 0, sizeof(phscore));
504
505 fd = rb->open(HISCORE_FILE,O_RDWR | O_CREAT);
506 if(fd < 0)
507 {
508 rb->splash(HZ, "Highscore file read error");
509 return;
510 }
511
512 /* highscore used to %d, is now %d\n
513 Deal with no file or bad file */
514 rb->read(fd,phscore, sizeof(phscore));
515
516 compare = rb->atoi(phscore);
517
518 if(high_score > compare)
519 {
520 rb->lseek(fd,0,SEEK_SET);
521 rb->fdprintf(fd, "%d\n", high_score);
522 }
523 else
524 high_score = compare;
525
526 rb->close(fd);
527 }
528
529 bool point_in_poly(struct Point* _point, int num_vertices, int x, int y)
530 {
531 struct Point* pi;
532 struct Point* pj;
533 int n;
534 bool c = false;
535
536 pi = _point;
537 pj = _point;
538 pj += num_vertices-1;
539
540 n = num_vertices;
541 while(n--)
542 {
543 if((((pi->y <= y) && (y < pj->y)) || ((pj->y <= y) && (y < pi->y))) &&
544 (x < (pj->x - pi->x) * (y - pi->y) / (pj->y - pi->y) + pi->x))
545 c = !c;
546
547 if(n == num_vertices - 1)
548 pj = _point;
549 else
550 pj++;
551
552 pi++;
553 }
554
555 return c;
556 }
557
558 void move_point(struct Point* point)
559 {
560 point->x += point->dx;
561 point->y += point->dy;
562
563 /*check bounds on the x-axis:*/
564 if(point->x >= SCALED_WIDTH)
565 point->x = 0;
566 else if(point->x <= 0)
567 point->x = SCALED_WIDTH;
568
569 /*Check bounds on the y-axis:*/
570 if(point->y >= SCALED_HEIGHT)
571 point->y = 0;
572 else if(point->y <= 0)
573 point->y = SCALED_HEIGHT;
574 }
575
576 void create_trail(struct TrailPoint* tpoint)
577 {
578 tpoint->position.dx = -( ship.vertices[0].x - ship.vertices[2].x )/10;
579 tpoint->position.dy = -( ship.vertices[0].y - ship.vertices[2].y )/10;
580 }
581
582 void create_explosion_trail(struct TrailPoint* tpoint)
583 {
584 tpoint->position.dx = (rb->rand()%5050)-2500;
585 tpoint->position.dy = (rb->rand()%5050)-2500;
586 }
587
588 void create_trail_blaze(int colour, struct Point* position)
589 {
590 int numtoadd;
591 struct TrailPoint* tpoint;
592 int n;
593 int xadd,yadd;
594 if(colour != SHIP_EXPLOSION_COLOUR)
595 {
596 numtoadd = NUM_TRAIL_POINTS/5;
597 xadd = position->x;
598 yadd = position->y;
599 }
600 else
601 {
602 numtoadd = NUM_TRAIL_POINTS/8;
603 xadd = ship.position.x;
604 yadd = ship.position.y;
605 }
606
607 /* give the point a random countdown timer, so they dissapears at different times */
608 tpoint = trailPoints;
609 n = NUM_TRAIL_POINTS;
610 while(--n)
611 {
612 if(tpoint->alive <= 0 && numtoadd)
613 {
614 numtoadd--;
615 /* take a random x point anywhere between bottom two points of ship. */
616 /* ship.position.x; */
617 tpoint->position.x = (ship.vertices[2].x + (rb->rand()%18000)-9000) + position->x;
618 tpoint->position.y = (ship.vertices[2].y + (rb->rand()%18000)-9000) + position->y;
619
620 switch(colour)
621 {
622 case SHIP_EXPLOSION_COLOUR:
623 tpoint->r = 255;
624 tpoint->g = 255;
625 tpoint->b = 255;
626 create_explosion_trail(tpoint);
627 tpoint->alive = 510;
628 tpoint->dec = 2;
629 break;
630 case ASTEROID_EXPLOSION_COLOUR:
631 tpoint->r = ASTEROID_R;
632 tpoint->g = ASTEROID_G;
633 tpoint->b = ASTEROID_B;
634 create_explosion_trail(tpoint);
635 tpoint->alive = 510;
636 tpoint->dec = 2;
637 break;
638 case ENEMY_EXPLOSION_COLOUR:
639 tpoint->r = ENEMY_R;
640 tpoint->g = ENEMY_G;
641 tpoint->b = ENEMY_B;
642 create_explosion_trail(tpoint);
643 tpoint->alive = 510;
644 tpoint->dec = 2;
645 break;
646 case THRUST_COLOUR:
647 tpoint->r = THRUST_R;
648 tpoint->g = THRUST_G;
649 tpoint->b = THRUST_B;
650 create_trail(tpoint);
651 tpoint->alive = 175;
652 tpoint->dec = 4;
653 break;
654 }
655 /* add a proportional bit to the x and y based on dx and dy */
656
657 /* give the points a speed based on direction of travel - i.e. opposite */
658 tpoint->position.dx += position->dx;
659 tpoint->position.dy += position->dy;
660
661
662 }
663 tpoint++;
664 }
665 /* find a space in the array of trail_points that is NULL or DEAD or whatever.
666 and place this one here. */
667
668 }
669
670 void draw_trail_blaze(void)
671 {
672 struct TrailPoint* tpoint;
673 /* loop through, if alive then move and draw.
674 when drawn, countdown it's timer.
675 if zero kill it! */
676 tpoint = trailPoints;
677 int n = NUM_TRAIL_POINTS;
678
679 while(--n)
680 {
681 if(tpoint->alive)
682 {
683 if(game_state != PAUSE_MODE)
684 {
685 tpoint->alive-=10;
686 move_point(&(tpoint->position));
687 }
688 #ifdef HAVE_LCD_COLOR
689 /* intensity = tpoint->alive/2; */
690 if(tpoint->r>0)tpoint->r-=tpoint->dec;
691 if(tpoint->g>0)tpoint->g-=tpoint->dec;
692 if(tpoint->b>0)tpoint->b-=tpoint->dec;
693 SET_FG(LCD_RGBPACK(tpoint->r, tpoint->g, tpoint->b));
694 #endif
695 rb->lcd_drawpixel(tpoint->position.x/SCALE , tpoint->position.y/SCALE);
696 }
697 tpoint++;
698 }
699 }
700
701 /*Check if point is within a rectangle*/
702 bool is_point_within_rectangle(struct Point* rect, struct Point* p, int size)
703 {
704 #if SHOW_COL
705 int aTLx = rect->x - size;
706 int aTLy = rect->y - size;
707 int aBRx = rect->x + size;
708 int aBRy = rect->y + size;
709 rb->lcd_drawline( aTLx/SCALE, aTLy/SCALE, aBRx/SCALE, aTLy/SCALE);
710 rb->lcd_drawline( aTLx/SCALE, aTLy/SCALE, aTLx/SCALE, aBRy/SCALE);
711 rb->lcd_drawline( aTLx/SCALE, aBRy/SCALE, aBRx/SCALE, aBRy/SCALE);
712 rb->lcd_drawline( aBRx/SCALE, aBRy/SCALE, aBRx/SCALE, aTLy/SCALE);
713 return (p->x > aTLx && p->x < aBRx && p->y > aTLy && p->y < aBRy);
714 #else
715 return (p->x > rect->x - size && p->x < rect->x + size &&
716 p->y > rect->y - size && p->y < rect->y + size);
717 #endif
718 }
719
720 /* Draw polygon */
721 void draw_polygon(struct Point* vertices, int px, int py, int num_vertices)
722 {
723 int n, t1, t2, oldX, oldY;
724 struct Point *p;
725 bool bDrawAll = px < WRAP_GAP || LCD_WIDTH - px < WRAP_GAP ||
726 py < WRAP_GAP || LCD_HEIGHT - py < WRAP_GAP;
727
728 p = vertices;
729 p += num_vertices-1;
730 oldX = p->x/SCALE + px;
731 oldY = p->y/SCALE + py;
732 p = vertices;
733 for(n = num_vertices+1; --n;)
734 {
735 t1 = p->x/SCALE + px;
736 t2 = p->y/SCALE + py;
737
738 rb->lcd_drawline(oldX, oldY, t1, t2);
739
740 if(bDrawAll)
741 {
742 rb->lcd_drawline(oldX - LCD_WIDTH, oldY, t1 - LCD_WIDTH, t2);
743 rb->lcd_drawline(oldX + LCD_WIDTH, oldY, t1 + LCD_WIDTH, t2);
744 rb->lcd_drawline(oldX - LCD_WIDTH, oldY + LCD_HEIGHT,
745 t1 - LCD_WIDTH, t2 + LCD_HEIGHT);
746 rb->lcd_drawline(oldX + LCD_WIDTH, oldY + LCD_HEIGHT,
747 t1 + LCD_WIDTH, t2 + LCD_HEIGHT);
748
749 rb->lcd_drawline(oldX, oldY - LCD_HEIGHT, t1, t2 - LCD_HEIGHT);
750 rb->lcd_drawline(oldX, oldY + LCD_HEIGHT, t1, t2 + LCD_HEIGHT);
751 rb->lcd_drawline(oldX - LCD_WIDTH, oldY - LCD_HEIGHT,
752 t1 - LCD_WIDTH, t2 - LCD_HEIGHT);
753 rb->lcd_drawline(oldX + LCD_WIDTH, oldY - LCD_HEIGHT,
754 t1 + LCD_WIDTH, t2 - LCD_HEIGHT);
755 }
756 oldX = t1;
757 oldY = t2;
758 p++;
759 }
760 }
761
762 void animate_and_draw_explosion(struct Point* point, int num_points,
763 int xoffset, int yoffset)
764 {
765 int n;
766 for(n = num_points; --n;)
767 {
768 if(game_state != PAUSE_MODE)
769 {
770 point->x += point->dx;
771 point->y += point->dy;
772 }
773 rb->lcd_fillrect( point->x/SCALE + xoffset, point->y/SCALE + yoffset,
774 POINT_SIZE, POINT_SIZE);
775 point++;
776 }
777 }
778
779 /*stop movement of ship, 'cos that's what happens when you go into hyperspace.*/
780 void hyperspace(void)
781 {
782 ship.position.dx = ship.position.dy = 0;
783 ship.position.x = (rb->rand()%SCALED_WIDTH);
784 ship.position.y = (rb->rand()%SCALED_HEIGHT);
785 }
786
787 void initialise_enemy(void)
788 {
789 struct Point* point;
790 int n;
791 int size;
792
793 if(rb->rand()%100 > enemy.size_probability)
794 {
795 size = BIG_SHIP;
796 enemy.size_probability++;
797 if(enemy.size_probability < 90)
798 {
799 enemy.size_probability = ENEMY_BIG_PROBABILITY_START;
800 }
801 }
802 else
803 {
804 size = LITTLE_SHIP;
805 }
806
807 enemy_missile.survived = 0;
808 enemy_on_screen = true;
809 enemy.explode_countdown = 0;
810 enemy.last_time_appeared = *rb->current_tick;
811 point = enemy.vertices;
812 for(n = 0; n < NUM_ENEMY_VERTICES+NUM_ENEMY_VERTICES; n+=2)
813 {
814 point->x = enemy_vertices[n];
815 point->y = enemy_vertices[n+1];
816 point->x *= SCALE/size;
817 point->y *= SCALE/size;
818 point++;
819 }
820
821 if(ship.position.x >= SCALED_WIDTH/2)
822 {
823 enemy.position.dx = ENEMY_SPEED;
824 enemy.position.x = 0;
825 }
826 else
827 {
828 enemy.position.dx = -ENEMY_SPEED;
829 enemy.position.x = SCALED_WIDTH;
830 }
831
832 if(ship.position.y >= SCALED_HEIGHT/2)
833 {
834 enemy.position.dy = ENEMY_SPEED;
835 enemy.position.y = 0;
836 }
837 else
838 {
839 enemy.position.dy = -ENEMY_SPEED;
840 enemy.position.y = SCALED_HEIGHT;
841 }
842
843 enemy.position.dx *= SCALE/10;
844 enemy.position.dy *= SCALE/10;
845 }
846
847 void draw_and_move_enemy(void)
848 {
849 int enemy_x, enemy_y;
850 struct Point *point;
851
852 SET_FG(COL_ENEMY);
853
854 if(enemy_on_screen)
855 {
856 enemy_x = enemy.position.x/SCALE;
857 enemy_y = enemy.position.y/SCALE;
858 if(!enemy.explode_countdown)
859 {
860 point = enemy.vertices;
861 draw_polygon(enemy.vertices, enemy_x, enemy_y, NUM_ENEMY_VERTICES);
862 rb->lcd_drawline(enemy.vertices[0].x/SCALE + enemy_x,
863 enemy.vertices[0].y/SCALE + enemy_y,
864 enemy.vertices[3].x/SCALE + enemy_x,
865 enemy.vertices[3].y/SCALE + enemy_y);
866
867 if(game_state != PAUSE_MODE)
868 {
869 enemy.position.x += enemy.position.dx;
870 enemy.position.y += enemy.position.dy;
871 }
872
873 if(enemy.position.x > SCALED_WIDTH || enemy.position.x < 0)
874 enemy_on_screen = false;
875
876 if(enemy.position.y > SCALED_HEIGHT)
877 enemy.position.y = 0;
878 else if(enemy.position.y < 0)
879 enemy.position.y = SCALED_HEIGHT;
880
881 if( (rb->rand()%1000) < 10)
882 enemy.position.dy = -enemy.position.dy;
883 }
884 else
885 {
886
887 /* animate_and_draw_explosion(enemy.vertices, NUM_ENEMY_VERTICES,
888 enemy_x, enemy.position.y/SCALE); */
889 if(game_state != PAUSE_MODE)
890 {
891 enemy.explode_countdown--;
892 if(!enemy.explode_countdown)
893 enemy_on_screen = false;
894 }
895 }
896 }
897 else
898 {
899 if( (*rb->current_tick - enemy.last_time_appeared) > enemy.appear_timing)
900 if(rb->rand()%100 > enemy.appear_probability) initialise_enemy();
901 }
902
903 if(!enemy_missile.survived && game_state != GAME_OVER)
904 {
905 /*if no missile and the enemy is here and not exploding..then shoot baby!*/
906 if( !enemy.explode_countdown && enemy_on_screen &&
907 !ship.waiting_for_space && (rb->rand()%10) > 5 )
908 {
909 enemy_missile.position.x = enemy.position.x;
910 enemy_missile.position.y = enemy.position.y;
911
912 /*lame, needs to be sorted - it's trying to shoot at the ship*/
913 if(ABS(enemy.position.y - ship.position.y) <= 5*SCALE)
914 {
915 enemy_missile.position.dy = 0;
916 }
917 else
918 {
919 if( enemy.position.y < ship.position.y)
920 enemy_missile.position.dy = 1;
921 else
922 enemy_missile.position.dy = -1;
923 }
924
925 if(ABS(enemy.position.x - ship.position.x) <= 5*SCALE)
926 enemy_missile.position.dx = 0;
927 else
928 {
929 if( enemy.position.x < ship.position.x)
930 enemy_missile.position.dx = 1;
931 else
932 enemy_missile.position.dx = -1;
933 }
934
935 if(enemy_missile.position.dx == 0 &&
936 enemy_missile.position.dy == 0)
937 enemy_missile.position.dx = enemy_missile.position.dy = -1;
938
939 enemy_missile.position.dx *= SCALE;
940 enemy_missile.position.dy *= SCALE;
941 enemy_missile.survived = ENEMY_MISSILE_SURVIVAL_LENGTH;
942
943 }
944 }
945 else
946 {
947 rb->lcd_fillrect( enemy_missile.position.x/SCALE,
948 enemy_missile.position.y/SCALE,
949 POINT_SIZE, POINT_SIZE);
950 if(game_state != PAUSE_MODE)
951 {
952 move_point(&enemy_missile.position);
953 enemy_missile.survived--;
954 }
955 }
956 }
957
958 /******************
959 * Lame method of collision
960 * detection. It's checking for collision
961 * between point and a big rectangle around the asteroid...
962 *******************/
963 bool is_point_within_asteroid(struct Asteroid* asteroid, struct Point* point)
964 {
965 if( !is_point_within_rectangle(&asteroid->position, point,
966 asteroid->radius+4*SCALE) )
967 return false;
968
969 if(point_in_poly(asteroid->vertices, NUM_ASTEROID_VERTICES,
970 point->x - asteroid->position.x,
971 point->y - asteroid->position.y))
972 {
973 switch(asteroid->type)
974 {
975 case(SMALL):
976 asteroid->explode_countdown = EXPLOSION_LENGTH;
977 create_trail_blaze(ASTEROID_EXPLOSION_COLOUR, &asteroid->position);
978 break;
979
980 case(LARGE):
981 create_asteroid(MEDIUM, asteroid->position.x,
982 asteroid->position.y);
983 create_asteroid(MEDIUM, asteroid->position.x,
984 asteroid->position.y);
985 break;
986
987 case(MEDIUM):
988 create_asteroid(SMALL, asteroid->position.x, asteroid->position.y);
989 create_asteroid(SMALL, asteroid->position.x, asteroid->position.y);
990 break;
991 }
992
993 current_score++;
994 if(current_score > extra_life)
995 {
996 num_lives++;
997 extra_life = current_score+EXTRA_LIFE;
998 }
999 asteroid_count--;
1000 asteroid->exists = false;
1001 return true;
1002 }
1003 else
1004 return false;
1005 }
1006
1007 bool is_point_within_enemy(struct Point* point)
1008 {
1009 if( is_point_within_rectangle(&enemy.position, point, 7*SCALE) )
1010 {
1011 current_score += 5;
1012 /*enemy_missile.survived = 0;*/
1013 enemy.explode_countdown = EXPLOSION_LENGTH;
1014 /* initialise_explosion(enemy.vertices, NUM_ENEMY_VERTICES); */
1015 create_trail_blaze(ENEMY_EXPLOSION_COLOUR, &enemy.position);
1016 return true;
1017 }
1018 else
1019 return false;
1020 }
1021
1022 bool is_ship_within_asteroid(struct Asteroid* asteroid)
1023 {
1024 bool hit = false;
1025 struct Point p;
1026
1027 p.x = ship.position.x + ship.vertices[0].x;
1028 p.y = ship.position.y + ship.vertices[0].y;
1029 hit |= is_point_within_asteroid(asteroid, &p);
1030
1031 if(!hit)
1032 {
1033 p.x = ship.position.x + ship.vertices[1].x;
1034 p.y = ship.position.y + ship.vertices[1].y;
1035 hit |= is_point_within_asteroid(asteroid, &p);
1036 if(!hit)
1037 {
1038 p.x = ship.position.x + ship.vertices[3].x;
1039 p.y = ship.position.y + ship.vertices[3].y;
1040 hit |= is_point_within_asteroid(asteroid, &p);
1041 }
1042 }
1043
1044 return hit;
1045 }
1046
1047 void initialise_explosion(struct Point* point, int num_points)
1048 {
1049 int n;
1050
1051 point->x += point->dx;
1052 point->y += point->dy;
1053 for(n = num_points; --n;)
1054 {
1055 point->dx = point->x;
1056 point->dy = point->y;
1057 point++;
1058 }
1059
1060 }
1061
1062 /* Check for collsions between the missiles and the asteroids and the ship */
1063 void check_collisions(void)
1064 {
1065 int m, n;
1066 bool asteroids_onscreen = false;
1067 struct Missile* missile;
1068 struct Asteroid* asteroid;
1069 bool ship_cant_be_placed = false;
1070
1071 asteroid = asteroids_array;
1072 m = MAX_NUM_ASTEROIDS;
1073 while(--m)
1074 {
1075 /*if the asteroids exists then test missile collision:*/
1076 if(asteroid->exists)
1077 {
1078 missile = missiles_array;
1079 n = MAX_NUM_MISSILES;
1080 while(--n)
1081 {
1082 /*if the missiles exists:*/
1083 if(missile->survived > 0)
1084 {
1085 /*has the missile hit the asteroid?*/
1086 if(is_point_within_asteroid(asteroid, &missile->position)
1087 || is_point_within_asteroid(asteroid,
1088 &missile->oldpoint))
1089 {
1090 missile->survived = 0;
1091 break;
1092 }
1093 }
1094 missile++;
1095 }
1096
1097 /*now check collision with ship:*/
1098 if(asteroid->exists && !ship.waiting_for_space && !ship.explode_countdown)
1099 {
1100 if(is_ship_within_asteroid(asteroid))
1101 {
1102 /*blow up ship*/
1103 ship.explode_countdown = EXPLOSION_LENGTH;
1104 /* initialise_explosion(ship.vertices, NUM_SHIP_VERTICES); */
1105 create_trail_blaze(SHIP_EXPLOSION_COLOUR, &ship.position);
1106 }
1107
1108 /*has the enemy missile blown something up?*/
1109 if(asteroid->exists && enemy_missile.survived)
1110 {
1111 if(is_point_within_asteroid(asteroid, &enemy_missile.position))
1112 {
1113 /*take that score back then:*/
1114 if(current_score > 0) current_score--;
1115 enemy_missile.survived = 0;
1116 }
1117
1118 /*if it still exists, check if ship is waiting for space:*/
1119 if(asteroid->exists && ship.waiting_for_space)
1120 ship_cant_be_placed |=
1121 is_point_within_rectangle(&ship.position,
1122 &asteroid->position,
1123 space_check_size);
1124 }
1125 }
1126 }
1127 /*is an asteroid still exploding?*/
1128 if(asteroid->explode_countdown)
1129 asteroids_onscreen = true;
1130
1131 asteroid++;
1132 }
1133
1134 /*now check collision between ship and enemy*/
1135 if(enemy_on_screen && !ship.waiting_for_space &&
1136 !ship.explode_countdown && !enemy.explode_countdown)
1137 {
1138 /*has the enemy collided with the ship?*/
1139 if(is_point_within_enemy(&ship.position))
1140 {
1141 ship.explode_countdown = EXPLOSION_LENGTH;
1142 /* initialise_explosion(ship.vertices, NUM_SHIP_VERTICES); */
1143 create_trail_blaze(SHIP_EXPLOSION_COLOUR, &ship.position);
1144 create_trail_blaze(ENEMY_EXPLOSION_COLOUR, &enemy.position);
1145 }
1146
1147 /*Now see if the enemy has been shot at by the ships missiles:*/
1148 missile = missiles_array;
1149 n = MAX_NUM_MISSILES;
1150 while(--n)
1151 {
1152 if(missile->survived > 0 &&
1153 is_point_within_enemy(&missile->position))
1154 {
1155 missile->survived = 0;
1156 break;
1157 }
1158 missile++;
1159 }
1160 }
1161
1162 /*test collision with enemy missile and ship:*/
1163 if(!ship_cant_be_placed && enemy_missile.survived > 0 &&
1164 point_in_poly(ship.vertices, NUM_SHIP_VERTICES,
1165 enemy_missile.position.x - ship.position.x,
1166 enemy_missile.position.y - ship.position.y))
1167 {
1168 ship.explode_countdown = EXPLOSION_LENGTH;
1169 /* initialise_explosion(ship.vertices, NUM_SHIP_VERTICES); */
1170 create_trail_blaze(SHIP_EXPLOSION_COLOUR, &ship.position);
1171 enemy_missile.survived = 0;
1172 enemy_missile.position.x = enemy_missile.position.y = 0;
1173 }
1174
1175 if(!ship_cant_be_placed)
1176 ship.waiting_for_space = false;
1177
1178 /*if all asteroids cleared then start again:*/
1179 if(asteroid_count == 0 && !enemy_on_screen && !asteroids_onscreen)
1180 {
1181 current_level++;
1182 game_state = SHOW_LEVEL;
1183 enemy.appear_probability += 5;
1184 enemy.appear_timing -= 200;
1185 if( enemy.appear_probability > 100)
1186 enemy.appear_probability = ENEMY_APPEAR_PROBABILITY_START;
1187 show_level_timeout = SHOW_LEVEL_TIME;
1188 }
1189 }
1190
1191 /*************************************************
1192 ** Creates a new asteroid of the given 4type (size)
1193 ** and at the given location.
1194 *************************************************/
1195 void create_asteroid(enum asteroid_type type, int x, int y)
1196 {
1197 struct Asteroid* asteroid;
1198 int n;
1199
1200 asteroid = asteroids_array;
1201 n = MAX_NUM_ASTEROIDS;
1202 while(--n)
1203 {
1204 if(!asteroid->exists && !asteroid->explode_countdown)
1205 {
1206 initialise_asteroid(asteroid, type);
1207 asteroid->position.x = x;
1208 asteroid->position.y = y;
1209 break;
1210 }
1211 asteroid++;
1212 }
1213 }
1214
1215 /* Initialise a missile */
1216 void initialise_missile(struct Missile* missile)
1217 {
1218 missile->position.x = ship.position.x + ship.vertices[0].x;
1219 missile->position.y = ship.position.y + ship.vertices[0].y;
1220 missile->position.dx = (ship.vertices[0].x - ship.vertices[2].x)/2;
1221 missile->position.dy = (ship.vertices[0].y - ship.vertices[2].y)/2;
1222 missile->survived = MISSILE_SURVIVAL_LENGTH;
1223 missile->oldpoint.x = missile->position.x;
1224 missile->oldpoint.y = missile->position.y;
1225 }
1226
1227 /* Draw and Move all the missiles */
1228 void draw_and_move_missiles(void)
1229 {
1230 int n;
1231 int p1x, p1y;
1232 int p2x, p2y;
1233
1234 struct Missile* missile;
1235 missile = missiles_array;
1236
1237 SET_FG(COL_MISSILE);
1238
1239 n = MAX_NUM_MISSILES;
1240 while(--n)
1241 {
1242 if(missile->survived)
1243 {
1244 if(missile->position.dx > 0)
1245 {
1246 if(missile->position.x >= missile->oldpoint.x)
1247 {
1248 p1x = missile->oldpoint.x;
1249 p2x = missile->position.x;
1250 }
1251 else
1252 {
1253 p1x = 0;
1254 p2x = missile->position.x;
1255 }
1256 }
1257 else
1258 {
1259 if(missile->oldpoint.x >= missile->position.x)
1260 {
1261 p1x = missile->oldpoint.x;
1262 p2x = missile->position.x;
1263 }
1264 else
1265 {
1266 p1x = missile->oldpoint.x;
1267 p2x = LCD_WIDTH;
1268 }
1269 }
1270
1271 if(missile->position.dy > 0)
1272 {
1273 if(missile->position.y >= missile->oldpoint.y)
1274 {
1275 p1y = missile->oldpoint.y;
1276 p2y = missile->position.y;
1277 }
1278 else
1279 {
1280 p1y = 0;
1281 p2y = missile->position.y;
1282 }
1283 }
1284 else
1285 {
1286 if(missile->oldpoint.y >= missile->position.y)
1287 {
1288 p1y = missile->oldpoint.y;
1289 p2y = missile->position.y;
1290 }
1291 else
1292 {
1293 p1y = missile->oldpoint.y;
1294 p2y = LCD_HEIGHT;
1295 }
1296 }
1297
1298 rb->lcd_drawline( p1x/SCALE, p1y/SCALE, p2x/SCALE, p2y/SCALE);
1299
1300 if(game_state != PAUSE_MODE)
1301 {
1302 missile->oldpoint.x = missile->position.x;
1303 missile->oldpoint.y = missile->position.y;
1304 move_point(&missile->position);
1305 missile->survived--;
1306 }
1307 }
1308 missile++;
1309 }
1310 }
1311
1312 void draw_lives(void)
1313 {
1314 int n;
1315 int px = (LCD_WIDTH - num_lives*4 - 1);
1316 #if(LARGE_LCD)
1317 int py = (LCD_HEIGHT-6);
1318 #else
1319 int py = (LCD_HEIGHT-4);
1320 #endif
1321
1322 SET_FG(COL_PLAYER);
1323
1324 n = num_lives;
1325 while(--n)
1326 {
1327 draw_polygon(lives_points, px, py, NUM_SHIP_VERTICES);
1328 #if(LARGE_LCD)
1329 px += 8;
1330 #else
1331 px += 6;
1332 #endif
1333 }
1334 }
1335
1336 /*Fire the next missile*/
1337 void fire_missile(void)
1338 {
1339 int n;
1340 struct Missile* missile;
1341
1342 if(!ship.explode_countdown && !ship.waiting_for_space)
1343 {
1344 missile = missiles_array;
1345 n = MAX_NUM_MISSILES;
1346 while(--n)
1347 {
1348 if(!missile->survived)
1349 {
1350 initialise_missile(missile);
1351 break;
1352 }
1353 missile++;
1354 }
1355 }
1356 }
1357
1358 /* Initialise the passed Asteroid */
1359 void initialise_asteroid(struct Asteroid* asteroid, enum asteroid_type type)
1360 {
1361 int n;
1362 bool b,b2;
1363 struct Point* point;
1364 asteroid->exists = true;
1365 asteroid->type = type;
1366 asteroid->explode_countdown = 0;
1367
1368 /*Set the radius of the asteroid:*/
1369 asteroid->radius = (int)type*SCALE;
1370
1371 /*shall we move Clockwise and Fast*/
1372 if((rb->rand()%100)>75)
1373 {
1374 asteroid->speed_cos = FAST_ROT_CW_COS;
1375 asteroid->speed_sin = FAST_ROT_CW_SIN;
1376 }
1377 else if((rb->rand()%100)>75)
1378 {
1379 asteroid->speed_cos = FAST_ROT_ACW_COS;
1380 asteroid->speed_sin = FAST_ROT_ACW_SIN;
1381 }
1382 else if((rb->rand()%100)>75)
1383 {
1384 asteroid->speed_cos = SLOW_ROT_ACW_COS;
1385 asteroid->speed_sin = SLOW_ROT_ACW_SIN;
1386 }
1387 else
1388 {
1389 asteroid->speed_cos = SLOW_ROT_CW_COS;
1390 asteroid->speed_sin = SLOW_ROT_CW_SIN;
1391 }
1392
1393 b = (rb->rand()%100)>66;
1394 b2 = (rb->rand()%100)>66;
1395 point = asteroid->vertices;
1396 for(n = 0; n < NUM_ASTEROID_VERTICES*2; n+=2)
1397 {
1398 if(b)
1399 {
1400 point->x = asteroid_one[n];
1401 point->y = asteroid_one[n+1];
1402 }
1403 else if( b2 )
1404 {
1405 point->x = asteroid_two[n];
1406 point->y = asteroid_two[n+1];
1407 }
1408 else
1409 {
1410 point->x = asteroid_three[n];
1411 point->y = asteroid_three[n+1];
1412 }
1413
1414 point->x *= asteroid->radius/6;
1415 point->y *= asteroid->radius/6;
1416 point++;
1417 }
1418
1419
1420 asteroid->radius += 6*SCALE;
1421 if(asteroid->type == SMALL)
1422 asteroid->radius /= 3;/*2*/
1423 else if(asteroid->type == LARGE)
1424 asteroid->radius += 3*SCALE;/*2*/
1425 b = true;
1426 while(b)
1427 {
1428 /*Set the position randomly:*/
1429 asteroid->position.x = (rb->rand()%SCALED_WIDTH);
1430 asteroid->position.y = (rb->rand()%SCALED_HEIGHT);
1431
1432 asteroid->position.dx = 0;
1433 while(asteroid->position.dx == 0)
1434 asteroid->position.dx = (rb->rand()%ASTEROID_SPEED)-ASTEROID_SPEED/2;
1435
1436 asteroid->position.dy = 0;
1437 while(asteroid->position.dy == 0)
1438 asteroid->position.dy = (rb->rand()%ASTEROID_SPEED)-ASTEROID_SPEED/2;
1439
1440 asteroid->position.dx *= SCALE/10;
1441 asteroid->position.dy *= SCALE/10;
1442
1443 b = is_point_within_rectangle(&ship.position, &asteroid->position,
1444 space_check_size);
1445 }
1446
1447 /*Now rotate the asteroid a bit, so they all look a bit different*/
1448 for(n=(rb->rand()%30) + 2;--n;)
1449 rotate_asteroid(asteroid);
1450
1451 /*great, we've created an asteroid, don't forget to increment the total:*/
1452 asteroid_count++;
1453 }
1454
1455 /*Initialise the ship*/
1456 void initialise_ship(void)
1457 {
1458 struct Point* point;
1459 struct Point* lives_point;
1460 int n;
1461
1462 ship.position.x = CENTER_LCD_X;
1463 ship.position.y = CENTER_LCD_Y;
1464 ship.position.x *= SCALE;
1465 ship.position.y *= SCALE;
1466 ship.position.dx = ship.position.dy = 0;
1467
1468 point = ship.vertices;
1469 lives_point = lives_points;
1470 for(n = 0; n < NUM_SHIP_VERTICES*2; n+=2)
1471 {
1472 point->x = ship_vertices[n];
1473 point->y = ship_vertices[n+1];
1474 point->x *= SCALE;
1475 point->y *= SCALE;
1476 point++;
1477 lives_point++;
1478 }
1479
1480 ship.position.dx = 0;
1481 ship.position.dy = 0;
1482 ship.explode_countdown = 0;
1483
1484 /*grab a copy of the ships points for the lives display:*/
1485 point = ship.vertices;
1486 lives_point = lives_points;
1487 for(n = 0; n < NUM_SHIP_VERTICES*2; n+=2)
1488 {
1489 lives_point->x = point->x;
1490 lives_point->y = point->y;
1491 lives_point++;
1492 point++;
1493 }
1494 }
1495
1496 void rotate_asteroid(struct Asteroid* asteroid)
1497 {
1498 struct Point* point;
1499 int n;
1500 long xtemp;
1501
1502 point = asteroid->vertices;
1503 for(n = NUM_ASTEROID_VERTICES+1; --n;)
1504 {
1505 xtemp = point->x;
1506 point->x = xtemp*asteroid->speed_cos/SIN_COS_SCALE -
1507 point->y*asteroid->speed_sin/SIN_COS_SCALE;
1508 point->y = point->y*asteroid->speed_cos/SIN_COS_SCALE +
1509 xtemp*asteroid->speed_sin/SIN_COS_SCALE;
1510 point++;
1511 }
1512 }
1513
1514 /*************************************************
1515 ** Draws the ship, moves the ship and creates a new
1516 ** one if it's finished exploding.
1517 **************************************************/
1518 void draw_and_move_ship(void)
1519 {
1520 int nxoffset = ship.position.x/SCALE;
1521 int nyoffset = ship.position.y/SCALE;
1522 SET_FG(COL_PLAYER);
1523 if(!ship.explode_countdown)
1524 {
1525 if(!ship.waiting_for_space)
1526 {
1527 draw_polygon(ship.vertices, nxoffset, nyoffset, NUM_SHIP_VERTICES);
1528 if(game_state != PAUSE_MODE && game_state != GAME_OVER)
1529 {
1530 move_point(&ship.position);
1531 }
1532 }
1533 }
1534 else
1535 {
1536 /* animate_and_draw_explosion(ship.vertices, NUM_SHIP_VERTICES,
1537 ship.position.x/SCALE,
1538 ship.position.y/SCALE); */
1539 if(game_state != PAUSE_MODE)
1540 {
1541 ship.explode_countdown--;
1542 if(!ship.explode_countdown)
1543 {
1544 num_lives--;
1545 if(!num_lives)
1546 {
1547 show_game_over = SHOW_GAME_OVER_TIME;
1548 game_state = GAME_OVER;
1549 }
1550 else
1551 {
1552 initialise_ship();
1553 ship.waiting_for_space = true;
1554 }
1555 }
1556 }
1557 }
1558 }
1559
1560 void thrust_ship(void)
1561 {
1562 if(!ship.waiting_for_space)
1563 {
1564 ship.position.dx += ( ship.vertices[0].x - ship.vertices[2].x )/20;
1565 ship.position.dy += ( ship.vertices[0].y - ship.vertices[2].y )/20;
1566 /*if dx and dy are below a certain threshold, then set 'em to 0
1567 but to do this we need to ascertain if the spacehip as moved on screen
1568 for more than a certain amount. */
1569
1570 create_trail_blaze(THRUST_COLOUR, &ship.position);
1571 }
1572 }
1573
1574 /**************************************************
1575 ** Rotate the ship using the passed sin & cos values
1576 ***************************************************/
1577 void rotate_ship(int c, int s)
1578 {
1579 struct Point* point;
1580 int n;
1581 double xtemp;
1582
1583 if(!ship.waiting_for_space && !ship.explode_countdown)
1584 {
1585 point = ship.vertices;
1586 for(n=NUM_SHIP_VERTICES+1;--n;)
1587 {
1588 xtemp = point->x;
1589 point->x = xtemp*c/SIN_COS_SCALE - point->y*s/SIN_COS_SCALE;
1590 point->y = point->y*c/SIN_COS_SCALE + xtemp*s/SIN_COS_SCALE;
1591 point++;
1592 }
1593 }
1594 }
1595
1596 void drawstars()
1597 {
1598 struct Point* p;
1599 int n = NUM_STARS;
1600
1601 p = stars;
1602 SET_FG(COL_STARS);
1603
1604 while(--n)
1605 {
1606 rb->lcd_drawpixel(p->x , p->y);
1607 p++;
1608 }
1609 }
1610
1611 /*************************************************
1612 ** Draw And Move all Asteroids
1613 *************************************************/
1614 void draw_and_move_asteroids(void)
1615 {
1616 int n;
1617 struct Asteroid* asteroid;
1618
1619 asteroid = asteroids_array;
1620 SET_FG(COL_ASTEROID);
1621
1622 n = MAX_NUM_ASTEROIDS;
1623 while(--n)
1624 {
1625 if(game_state != PAUSE_MODE)
1626 {
1627 if(asteroid->exists)
1628 {
1629 move_point(&asteroid->position);
1630 rotate_asteroid(asteroid);
1631 draw_polygon(asteroid->vertices, asteroid->position.x/SCALE,
1632 asteroid->position.y/SCALE,
1633 NUM_ASTEROID_VERTICES);
1634 }
1635 else if(asteroid->explode_countdown)
1636 {
1637 /* animate_and_draw_explosion(asteroid->vertices,
1638 NUM_ASTEROID_VERTICES,
1639 asteroid->position.x/SCALE,
1640 asteroid->position.y/SCALE); */
1641 asteroid->explode_countdown--;
1642 }
1643 }
1644 else
1645 {
1646 if(asteroid->exists)
1647 draw_polygon(asteroid->vertices,
1648 asteroid->position.x/SCALE,
1649 asteroid->position.y/SCALE,
1650 NUM_ASTEROID_VERTICES);
1651 }
1652 asteroid++;
1653 }
1654 }
1655
1656 void create_stars(void)
1657 {
1658 struct TrailPoint* tpoint;
1659 struct Point* p;
1660 int n;
1661
1662 p = stars;
1663 n = NUM_STARS;
1664 while(--n)
1665 {
1666 p->x = (rb->rand()%LCD_WIDTH);
1667 p->y = (rb->rand()%LCD_HEIGHT);
1668 p++;
1669 }
1670
1671
1672 /* give the point a random countdown timer, so they dissapears at different
1673 times */
1674 tpoint = trailPoints;
1675 n = NUM_TRAIL_POINTS;
1676 while(--n)
1677 {
1678 tpoint->alive = 0;
1679 tpoint++;
1680 }
1681 }
1682
1683 /*************************************************
1684 ** Creates start_num number of new asteroids of
1685 ** full size.
1686 **************************************************/
1687 void initialise_game(int start_num)
1688 {
1689 int n;
1690 asteroid_count = next_missile_count = next_thrust_count = 0;
1691 struct Asteroid* asteroid;
1692 struct Missile* missile;
1693 extra_life = EXTRA_LIFE;
1694
1695 /*no enemy*/
1696 enemy_on_screen = 0;
1697 enemy_missile.survived = 0;
1698
1699 /*clear asteroids*/
1700 asteroid = asteroids_array;
1701 n = MAX_NUM_ASTEROIDS;
1702 while(--n)
1703 {
1704 asteroid->exists = false;
1705 asteroid++;
1706 }
1707
1708 /*make some LARGE asteroids*/
1709 for(n = 0; n < start_num; n++)
1710 initialise_asteroid(&asteroids_array[n], LARGE);
1711
1712 /*ensure all missiles are out of action: */
1713 missile = missiles_array;
1714 n = MAX_NUM_MISSILES;
1715 while(--n)
1716 {
1717 missile->survived=0;
1718 missile++;
1719 }
1720 }
1721
1722 void start_attract_mode(void)
1723 {
1724 enemy.appear_probability = ENEMY_APPEAR_PROBABILITY_START;
1725 enemy.appear_timing = ENEMY_APPEAR_TIMING_START;
1726 current_level = 5;
1727 num_lives = START_LIVES;
1728 current_score = 0;
1729 attract_flip_timeout = ATTRACT_FLIP_TIME;
1730 game_state = ATTRACT_MODE;
1731 if(asteroid_count < 3)
1732 initialise_game(current_level);
1733 }
1734
1735 enum plugin_status start_game(void)
1736 {
1737 char s[20];
1738 char level[10];
1739 int button;
1740 int end;
1741 int CYCLETIME = 30;
1742
1743 /*create stars once, and once only:*/
1744 create_stars();
1745
1746 SET_BG(LCD_BLACK);
1747
1748 while(true)
1749 {
1750 /*game starts with at level 1
1751 with 1 asteroid.*/
1752 start_attract_mode();
1753
1754 /*Main loop*/
1755 while(true)
1756 {
1757 end = *rb->current_tick + (CYCLETIME * HZ) / 1000;
1758 rb->lcd_clear_display();
1759 SET_FG(COL_TEXT);
1760 switch(game_state)
1761 {
1762 case(ATTRACT_MODE):
1763 if(attract_flip_timeout < ATTRACT_FLIP_TIME/2)
1764 {
1765 rb->lcd_putsxy(CENTER_LCD_X - 39,
1766 CENTER_LCD_Y + CENTER_LCD_Y/2 - 4,
1767 "Fire to Start");
1768 if(!attract_flip_timeout)
1769 attract_flip_timeout = ATTRACT_FLIP_TIME;
1770 }
1771 else
1772 {
1773 rb->snprintf(s, sizeof(s), "Hi Score %d ", high_score);
1774 rb->lcd_putsxy(CENTER_LCD_X - 30,
1775 CENTER_LCD_Y + CENTER_LCD_Y/2 - 4, s);
1776 }
1777 attract_flip_timeout--;
1778 break;
1779
1780 case(GAME_OVER):
1781 rb->lcd_putsxy(CENTER_LCD_X - 25,
1782 CENTER_LCD_Y + CENTER_LCD_Y/2 - 4, "Game Over");
1783 rb->snprintf(s, sizeof(s), "score %d ", current_score);
1784 rb->lcd_putsxy(1,LCD_HEIGHT-8, s);
1785 show_game_over--;
1786 if(!show_game_over)
1787 start_attract_mode();
1788 break;
1789
1790 case(PAUSE_MODE):
1791 rb->snprintf(s, sizeof(s), "score %d ", current_score);
1792 rb->lcd_putsxy(1,LCD_HEIGHT-8, s);
1793 rb->lcd_putsxy(CENTER_LCD_X - 15,
1794 CENTER_LCD_Y + CENTER_LCD_Y/2 - 4, "pause");
1795 draw_and_move_missiles();
1796 draw_lives();
1797 draw_and_move_ship();
1798 break;
1799
1800 case(PLAY_MODE):
1801 rb->snprintf(s, sizeof(s), "score %d ", current_score);
1802 rb->lcd_putsxy(1,LCD_HEIGHT-8, s);
1803 draw_and_move_missiles();
1804 draw_lives();
1805 check_collisions();
1806 draw_and_move_ship();
1807 break;
1808
1809 case(SHOW_LEVEL):
1810 show_level_timeout--;
1811 rb->snprintf(s, sizeof(s), "score %d ", current_score);
1812 rb->lcd_putsxy(1,LCD_HEIGHT-8, s);
1813 rb->snprintf(level, sizeof(level), "stage %d ", current_level);
1814 rb->lcd_putsxy(CENTER_LCD_X - 20,
1815 CENTER_LCD_Y + CENTER_LCD_Y/2 - 4, level);
1816 draw_and_move_ship();
1817 draw_lives();
1818 if(!show_level_timeout)
1819 {
1820 initialise_game(current_level);
1821 game_state = PLAY_MODE;
1822 draw_lives();
1823 }
1824 break;
1825 }
1826 draw_trail_blaze();
1827 drawstars();
1828 draw_and_move_asteroids();
1829 draw_and_move_enemy();
1830
1831 rb->lcd_update();
1832 button = rb->button_get(false);
1833
1834 #ifdef HAS_BUTTON_HOLD
1835 if (rb->button_hold())
1836 game_state = PAUSE_MODE;
1837 #endif
1838
1839 switch(button)
1840 {
1841 case(AST_PAUSE):
1842 if(game_state == PLAY_MODE)
1843 game_state = PAUSE_MODE;
1844 else if(game_state == PAUSE_MODE)
1845 game_state = PLAY_MODE;
1846 break;
1847
1848 #ifdef AST_RC_QUIT
1849 case AST_RC_QUIT:
1850 #endif
1851 case(AST_QUIT):
1852 if(game_state == ATTRACT_MODE)
1853 return PLUGIN_OK;
1854 else if(game_state == GAME_OVER)
1855 {
1856 start_attract_mode();
1857 }
1858 else
1859 {
1860 show_game_over = SHOW_GAME_OVER_TIME;
1861 game_state = GAME_OVER;
1862 }
1863 break;
1864
1865 case (AST_LEFT_REP):
1866 case (AST_LEFT):
1867 if(game_state == PLAY_MODE || game_state == SHOW_LEVEL)
1868 rotate_ship(SHIP_ROT_ACW_COS, SHIP_ROT_ACW_SIN);
1869 break;
1870
1871 case (AST_RIGHT_REP):
1872 case (AST_RIGHT):
1873 if(game_state == PLAY_MODE || game_state == SHOW_LEVEL)
1874 rotate_ship(SHIP_ROT_CW_COS, SHIP_ROT_CW_SIN);
1875 break;
1876
1877 case (AST_THRUST_REP):
1878 case (AST_THRUST):
1879 if((game_state == PLAY_MODE || game_state == SHOW_LEVEL) && !next_thrust_count)
1880 {
1881 thrust_ship();
1882 next_thrust_count = 5;
1883 }
1884 break;
1885
1886 case (AST_HYPERSPACE):
1887 if(game_state == PLAY_MODE)
1888 hyperspace();
1889 /*maybe shield if it gets too hard */
1890 break;
1891
1892 case (AST_FIRE_REP):
1893 case (AST_FIRE):
1894 if(game_state == ATTRACT_MODE)
1895 {
1896 current_level = START_LEVEL;
1897 initialise_ship();
1898 initialise_game(current_level);
1899 show_level_timeout = SHOW_LEVEL_TIME;
1900 game_state = PLAY_MODE;
1901 }
1902 else if(game_state == PLAY_MODE)
1903 {
1904 if(!next_missile_count)
1905 {
1906 fire_missile();
1907 next_missile_count = 10;
1908 }
1909 }
1910 else if(game_state == PAUSE_MODE)
1911 {
1912 game_state = PLAY_MODE;
1913 }
1914 break;
1915
1916 default:
1917 if (rb->default_event_handler(button)==SYS_USB_CONNECTED)
1918 return PLUGIN_USB_CONNECTED;
1919 break;
1920 }
1921
1922 if(!num_lives)
1923 {
1924 if(high_score < current_score)
1925 high_score = current_score;
1926 if(!show_game_over)
1927 break;
1928 }
1929
1930 if(next_missile_count)
1931 next_missile_count--;
1932
1933 if(next_thrust_count)
1934 next_thrust_count--;
1935
1936 if (end > *rb->current_tick)
1937 rb->sleep(end-*rb->current_tick);
1938 else
1939 rb->yield();
1940 }
1941
1942 }
1943 }
1944
1945 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
1946 {
1947 enum plugin_status retval;
1948 (void)(parameter);
1949 rb = api;
1950
1951 game_state = ATTRACT_MODE;
1952
1953 #if LCD_DEPTH > 1
1954 rb->lcd_set_backdrop(NULL);
1955 #endif
1956 /* universal font */
1957 rb->lcd_setfont(FONT_SYSFIXED);
1958 /* Turn off backlight timeout */
1959 backlight_force_on(rb); /* backlight control in lib/helper.c */
1960 iohiscore();
1961 retval = start_game();
1962 iohiscore();
1963 rb->lcd_setfont(FONT_UI);
1964 /* Turn on backlight timeout (revert to settings) */
1965 backlight_use_settings(rb); /* backlight control in lib/helper.c */
1966 return retval;
1967 }
Open Source Jukebox Firmware