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