apps/plugins/invadrox.c

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