apps/plugins/chopper.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Originally by Joshua Oreman, improved by Prashant Varanasi
  11  * Ported to Rockbox by Ben Basha (Paprica)
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22
  23 #include "plugin.h"
  24 #include "lib/xlcd.h"
  25 #include "lib/configfile.h"
  26 #include "lib/helper.h"
  27 #include "lib/playback_control.h"
  28
  29
  30
  31 /*
  32 Still To do:
  33  - Make original speed and further increases in speed depend more on screen size
  34  - attempt to make the tunnels get narrower as the game goes on
  35  - make the chopper look better, maybe a picture, and scale according
  36    to screen size
  37  - use textures for the color screens for background and terrain,
  38    eg stars on background
  39  - allow choice of different levels [later: different screen themes]
  40  - better high score handling, improved screen etc.
  41 */
  42
  43 #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || (CONFIG_KEYPAD == IRIVER_H300_PAD)
  44
  45 #define QUIT BUTTON_OFF
  46 #define ACTION BUTTON_UP
  47 #define ACTION2 BUTTON_SELECT
  48 #define ACTIONTEXT "SELECT"
  49
  50 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
  51       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
  52       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
  53
  54 #define QUIT BUTTON_MENU
  55 #define ACTION BUTTON_SELECT
  56 #define ACTIONTEXT "SELECT"
  57
  58 #elif CONFIG_KEYPAD == IAUDIO_X5M5_PAD /* grayscale at the moment */
  59
  60 #define QUIT BUTTON_POWER
  61 #define ACTION BUTTON_UP
  62 #define ACTION2 BUTTON_SELECT
  63 #define ACTIONTEXT "SELECT"
  64
  65 #elif CONFIG_KEYPAD == IRIVER_H10_PAD
  66 #define QUIT BUTTON_POWER
  67 #define ACTION BUTTON_RIGHT
  68 #define ACTIONTEXT "RIGHT"
  69
  70 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || \
  71       (CONFIG_KEYPAD == SANSA_C200_PAD) || \
  72       (CONFIG_KEYPAD == SANSA_CLIP_PAD) || \
  73       (CONFIG_KEYPAD == SANSA_M200_PAD)
  74 #define QUIT BUTTON_POWER
  75 #define ACTION BUTTON_SELECT
  76 #define ACTIONTEXT "SELECT"
  77
  78 #elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
  79 #define QUIT        BUTTON_HOME
  80 #define ACTION      BUTTON_SELECT
  81 #define ACTIONTEXT  "SELECT"
  82
  83 #elif CONFIG_KEYPAD == GIGABEAT_PAD
  84 #define QUIT BUTTON_MENU
  85 #define ACTION BUTTON_SELECT
  86 #define ACTIONTEXT "SELECT"
  87
  88 #elif CONFIG_KEYPAD == RECORDER_PAD
  89 #define QUIT BUTTON_OFF
  90 #define ACTION BUTTON_PLAY
  91 #define ACTIONTEXT "PLAY"
  92
  93 #elif CONFIG_KEYPAD == ONDIO_PAD
  94 #define QUIT BUTTON_OFF
  95 #define ACTION BUTTON_UP
  96 #define ACTION2 BUTTON_MENU
  97 #define ACTIONTEXT "UP"
  98
  99 #elif CONFIG_KEYPAD == GIGABEAT_S_PAD
 100 #define QUIT BUTTON_BACK
 101 #define ACTION BUTTON_SELECT
 102 #define ACTION2 BUTTON_MENU
 103 #define ACTIONTEXT "SELECT"
 104
 105 #elif CONFIG_KEYPAD == MROBE100_PAD
 106 #define QUIT BUTTON_POWER
 107 #define ACTION BUTTON_SELECT
 108 #define ACTIONTEXT "SELECT"
 109
 110 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
 111 #define QUIT BUTTON_RC_REC
 112 #define ACTION BUTTON_RC_PLAY
 113 #define ACTION2 BUTTON_RC_MODE
 114 #define ACTIONTEXT "PLAY"
 115
 116 #elif CONFIG_KEYPAD == COWON_D2_PAD
 117 #define QUIT BUTTON_POWER
 118 #define ACTION2 BUTTON_PLUS
 119
 120 #elif CONFIG_KEYPAD == IAUDIO67_PAD
 121 #define QUIT BUTTON_POWER
 122 #define ACTION BUTTON_PLAY
 123 #define ACTION2 BUTTON_STOP
 124 #define ACTIONTEXT "PLAY"
 125
 126 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
 127 #define QUIT BUTTON_BACK
 128 #define ACTION BUTTON_UP
 129 #define ACTION2 BUTTON_MENU
 130 #define ACTIONTEXT "UP"
 131
 132 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
 133 #define QUIT BUTTON_POWER
 134 #define ACTION BUTTON_MENU
 135 #define ACTION2 BUTTON_SELECT
 136 #define ACTIONTEXT "MENU"
 137
 138 #elif CONFIG_KEYPAD == PHILIPS_HDD6330_PAD
 139 #define QUIT BUTTON_POWER
 140 #define ACTION BUTTON_MENU
 141 #define ACTION2 BUTTON_PLAY
 142 #define ACTIONTEXT "MENU"
 143
 144 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
 145 #define QUIT BUTTON_POWER
 146 #define ACTION BUTTON_MENU
 147 #define ACTION2 BUTTON_PLAY
 148 #define ACTIONTEXT "MENU"
 149
 150 #elif CONFIG_KEYPAD == ONDAVX747_PAD || \
 151 CONFIG_KEYPAD == ONDAVX777_PAD || \
 152 CONFIG_KEYPAD == MROBE500_PAD
 153 #define QUIT BUTTON_POWER
 154
 155 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
 156 #define QUIT        BUTTON_LEFT
 157 #define ACTION      BUTTON_RIGHT
 158 #define ACTIONTEXT "RIGHT"
 159
 160 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
 161 #define QUIT BUTTON_REC
 162 #define ACTION BUTTON_PLAY
 163 #define ACTION2 BUTTON_UP
 164 #define ACTIONTEXT "PLAY"
 165
 166 #elif CONFIG_KEYPAD == MPIO_HD200_PAD
 167 #define QUIT (BUTTON_REC|BUTTON_PLAY)
 168 #define ACTION BUTTON_FUNC
 169 #define ACTIONTEXT "FUNC"
 170
 171 #elif CONFIG_KEYPAD == MPIO_HD300_PAD
 172 #define QUIT BUTTON_REC
 173 #define ACTION BUTTON_ENTER
 174 #define ACTIONTEXT "ENTER"
 175
 176 #else
 177 #elif !defined(HAVE_TOUCHSCREEN)
 178 #error No keymap defined!
 179 #endif
 180
 181 #ifdef HAVE_TOUCHSCREEN
 182 #ifndef QUIT
 183 #define QUIT        BUTTON_TOPLEFT
 184 #endif
 185 #ifndef ACTION
 186 #define ACTION      BUTTON_BOTTOMLEFT
 187 #endif
 188 #ifndef ACTION2
 189 #define ACTION2     BUTTON_BOTTOMRIGHT
 190 #endif
 191 #ifndef ACTIONTEXT
 192 #define ACTIONTEXT "BOTTOMRIGHT"
 193 #endif
 194 #endif
 195
 196 #define NUMBER_OF_BLOCKS 8
 197 #define NUMBER_OF_PARTICLES 3
 198 #define MAX_TERRAIN_NODES 15
 199
 200 #define LEVEL_MODE_NORMAL 0
 201 #define LEVEL_MODE_STEEP 1
 202
 203 #if LCD_HEIGHT <= 64
 204 #define CYCLES 100
 205 static inline int SCALE(int x)
 206 {
 207     return x == 1 ? x : x >> 1;
 208 }
 209 #define SIZE 2
 210 #else
 211 #define CYCLES 60
 212 #define SCALE(x) (x)
 213 #define SIZE 1
 214 #endif
 215
 216 /* in 10 milisecond (ticks) */
 217 #define CYCLETIME ((CYCLES*HZ)/1000)
 218
 219 /*Chopper's local variables to track the terrain position etc*/
 220 static int chopCounter;
 221 static int iRotorOffset;
 222 static int iScreenX;
 223 static int iScreenY;
 224 static int iPlayerPosX;
 225 static int iPlayerPosY;
 226 static int iCameraPosX;
 227 static int iPlayerSpeedX;
 228 static int iPlayerSpeedY;
 229 static int iLastBlockPlacedPosX;
 230 static int iGravityTimerCountdown;
 231 static int iPlayerAlive;
 232 static int iLevelMode, iCurrLevelMode;
 233 static int blockh,blockw;
 234 static int highscore;
 235 static int score;
 236
 237 #define CFG_FILE "chopper.cfg"
 238 #define MAX_POINTS 50000
 239 static struct configdata config[] =
 240 {
 241    {TYPE_INT, 0, MAX_POINTS, { .int_p = &highscore }, "highscore", NULL}
 242 };
 243
 244 struct CBlock
 245 {
 246     int iWorldX;
 247     int iWorldY;
 248
 249     int iSizeX;
 250     int iSizeY;
 251
 252     int bIsActive;
 253 };
 254
 255 struct CParticle
 256 {
 257     int iWorldX;
 258     int iWorldY;
 259
 260     int iSpeedX;
 261     int iSpeedY;
 262
 263     int bIsActive;
 264 };
 265
 266 struct CTerrainNode
 267 {
 268     int x;
 269     int y;
 270 };
 271
 272 struct CTerrain
 273 {
 274     struct CTerrainNode mNodes[MAX_TERRAIN_NODES];
 275     int iNodesCount;
 276     int iLastNodePlacedPosX;
 277 };
 278
 279 struct CBlock mBlocks[NUMBER_OF_BLOCKS];
 280 struct CParticle mParticles[NUMBER_OF_PARTICLES];
 281
 282 struct CTerrain mGround;
 283 struct CTerrain mRoof;
 284
 285 /*Function declarations*/
 286 static void chopDrawParticle(struct CParticle *mParticle);
 287 static void chopDrawBlock(struct CBlock *mBlock);
 288 static void chopRenderTerrain(struct CTerrain *ter, bool isground);
 289 void chopper_load(bool newgame);
 290 void cleanup_chopper(void);
 291
 292 static void chopDrawPlayer(int x,int y) /* These are SCREEN coords, not world!*/
 293 {
 294
 295 #if LCD_DEPTH > 2
 296     rb->lcd_set_foreground(LCD_RGBPACK(50,50,200));
 297 #elif LCD_DEPTH == 2
 298     rb->lcd_set_foreground(LCD_DARKGRAY);
 299 #endif
 300     rb->lcd_fillrect(SCALE(x+6), SCALE(y+2), SCALE(12), SCALE(9));
 301     rb->lcd_fillrect(SCALE(x-3), SCALE(y+6), SCALE(20), SCALE(3));
 302
 303 #if LCD_DEPTH > 2
 304     rb->lcd_set_foreground(LCD_RGBPACK(50,50,50));
 305 #elif LCD_DEPTH == 2
 306     rb->lcd_set_foreground(LCD_DARKGRAY);
 307 #endif
 308     rb->lcd_fillrect(SCALE(x+10), SCALE(y), SCALE(2), SCALE(3));
 309     rb->lcd_fillrect(SCALE(x+10), SCALE(y), SCALE(1), SCALE(3));
 310
 311 #if LCD_DEPTH > 2
 312     rb->lcd_set_foreground(LCD_RGBPACK(40,40,100));
 313 #elif LCD_DEPTH == 2
 314     rb->lcd_set_foreground(LCD_BLACK);
 315 #endif
 316     rb->lcd_drawline(SCALE(x), SCALE(y+iRotorOffset), SCALE(x+20),
 317                      SCALE(y-iRotorOffset));
 318
 319 #if LCD_DEPTH > 2
 320     rb->lcd_set_foreground(LCD_RGBPACK(20,20,50));
 321 #elif LCD_DEPTH == 2
 322     rb->lcd_set_foreground(LCD_BLACK);
 323 #endif
 324     rb->lcd_fillrect(SCALE(x - 2), SCALE(y + 5), SCALE(2), SCALE(5));
 325
 326 }
 327
 328 static void chopClearTerrain(struct CTerrain *ter)
 329 {
 330     ter->iNodesCount = 0;
 331 }
 332
 333
 334 int iR(int low,int high)
 335 {
 336     return low+rb->rand()%(high-low+1);
 337 }
 338
 339 static void chopCopyTerrain(struct CTerrain *src, struct CTerrain *dest,
 340                             int xOffset,int yOffset)
 341 {
 342     int i=0;
 343
 344     while(i < src->iNodesCount)
 345     {
 346         dest->mNodes[i].x = src->mNodes[i].x + xOffset;
 347         dest->mNodes[i].y = src->mNodes[i].y + yOffset;
 348
 349         i++;
 350     }
 351
 352     dest->iNodesCount = src->iNodesCount;
 353     dest->iLastNodePlacedPosX = src->iLastNodePlacedPosX;
 354
 355 }
 356
 357 static void chopAddTerrainNode(struct CTerrain *ter, int x, int y)
 358 {
 359     int i=0;
 360
 361     if(ter->iNodesCount + 1 >= MAX_TERRAIN_NODES)
 362     {
 363         /* DEBUGF("ERROR: Not enough nodes!\n"); */
 364         return;
 365     }
 366
 367     ter->iNodesCount++;
 368
 369     i = ter->iNodesCount - 1;
 370
 371     ter->mNodes[i].x = x;
 372     ter->mNodes[i].y= y;
 373
 374     ter->iLastNodePlacedPosX = x;
 375
 376 }
 377
 378 static void chopTerrainNodeDeleteAndShift(struct CTerrain *ter,int nodeIndex)
 379 {
 380     int i=nodeIndex;
 381
 382     while( i < ter->iNodesCount )
 383     {
 384         ter->mNodes[i - 1] = ter->mNodes[i];
 385         i++;
 386     }
 387
 388     ter->iNodesCount--;
 389
 390
 391 }
 392
 393 int chopUpdateTerrainRecycling(struct CTerrain *ter)
 394 {
 395     int i=1;
 396     int ret = 0;
 397     int iNewNodePos,g,v;
 398     while(i < ter->iNodesCount)
 399     {
 400
 401         if( iCameraPosX > ter->mNodes[i].x)
 402         {
 403
 404             chopTerrainNodeDeleteAndShift(ter,i);
 405
 406             iNewNodePos = ter->iLastNodePlacedPosX + 50;
 407             g = iScreenY - 10;
 408
 409             v = 3*iPlayerSpeedX;
 410             if(v>50)
 411                 v=50;
 412             if(iCurrLevelMode == LEVEL_MODE_STEEP)
 413                 v*=5;
 414
 415             chopAddTerrainNode(ter,iNewNodePos,g - iR(-v,v));
 416             ret=1;
 417
 418         }
 419
 420         i++;
 421
 422     }
 423
 424     return 1;
 425 }
 426
 427 int chopTerrainHeightAtPoint(struct CTerrain *ter, int pX)
 428 {
 429
 430     int iNodeIndexOne=0,iNodeIndexTwo=0, h, terY1, terY2, terX1, terX2, a, b;
 431     float c,d;
 432
 433     int i=0;
 434     for(i=1;i<MAX_TERRAIN_NODES;i++)
 435     {
 436         if(ter->mNodes[i].x > pX)
 437         {
 438             iNodeIndexOne = i - 1;
 439             break;
 440         }
 441
 442     }
 443
 444     iNodeIndexTwo = iNodeIndexOne + 1;
 445     terY1 = ter->mNodes[iNodeIndexOne].y;
 446     terY2 = ter->mNodes[iNodeIndexTwo].y;
 447
 448     terX1 = 0;
 449     terX2 = ter->mNodes[iNodeIndexTwo].x - ter->mNodes[iNodeIndexOne].x;
 450
 451     pX-= ter->mNodes[iNodeIndexOne].x;
 452
 453     a = terY2 - terY1;
 454     b = terX2;
 455     c = pX;
 456     d = (c/b) * a;
 457
 458     h = d + terY1;
 459
 460     return h;
 461
 462 }
 463
 464 int chopPointInTerrain(struct CTerrain *ter, int pX, int pY, int iTestType)
 465 {
 466     int h = chopTerrainHeightAtPoint(ter, pX);
 467
 468     if(iTestType == 0)
 469         return (pY > h);
 470     else
 471         return (pY < h);
 472 }
 473
 474 static void chopAddBlock(int x,int y,int sx,int sy, int indexOverride)
 475 {
 476     int i=0;
 477
 478     if(indexOverride < 0)
 479     {
 480         while(mBlocks[i].bIsActive && i < NUMBER_OF_BLOCKS)
 481             i++;
 482         if(i==NUMBER_OF_BLOCKS)
 483         {
 484             DEBUGF("No blocks!\n");
 485             return;
 486         }
 487     }
 488     else
 489         i = indexOverride;
 490
 491     mBlocks[i].bIsActive = 1;
 492     mBlocks[i].iWorldX = x;
 493     mBlocks[i].iWorldY = y;
 494     mBlocks[i].iSizeX = sx;
 495     mBlocks[i].iSizeY = sy;
 496
 497     iLastBlockPlacedPosX = x;
 498 }
 499
 500 static void chopAddParticle(int x,int y,int sx,int sy)
 501 {
 502     int i=0;
 503
 504     while(mParticles[i].bIsActive && i < NUMBER_OF_PARTICLES)
 505         i++;
 506
 507     if(i==NUMBER_OF_PARTICLES)
 508         return;
 509
 510     mParticles[i].bIsActive = 1;
 511     mParticles[i].iWorldX = x;
 512     mParticles[i].iWorldY = y;
 513     mParticles[i].iSpeedX = sx;
 514     mParticles[i].iSpeedY = sy;
 515 }
 516
 517 static void chopGenerateBlockIfNeeded(void)
 518 {
 519     int i=0;
 520     int DistSpeedX = iPlayerSpeedX * 5;
 521     if(DistSpeedX<200) DistSpeedX = 200;
 522
 523     while(i < NUMBER_OF_BLOCKS)
 524     {
 525         if(!mBlocks[i].bIsActive)
 526         {
 527             int iX,iY,sX,sY;
 528
 529             iX = iLastBlockPlacedPosX + (350-DistSpeedX);
 530             sX = blockw;
 531
 532             iY = iR(0,iScreenY);
 533             sY = blockh + iR(1,blockh/3);
 534
 535             chopAddBlock(iX,iY,sX,sY,i);
 536         }
 537
 538         i++;
 539     }
 540
 541 }
 542
 543 static int chopBlockCollideWithPlayer(struct CBlock *mBlock)
 544 {
 545     int px = iPlayerPosX;
 546     int py = iPlayerPosY;
 547
 548     int x = mBlock->iWorldX-17;
 549     int y = mBlock->iWorldY-11;
 550
 551     int x2 = x + mBlock->iSizeX+17;
 552     int y2 = y + mBlock->iSizeY+11;
 553
 554     if(px>x && px<x2)
 555     {
 556         if(py>y && py<y2)
 557         {
 558             return 1;
 559         }
 560     }
 561
 562     return 0;
 563 }
 564
 565 static int chopBlockOffscreen(struct CBlock *mBlock)
 566 {
 567     if(mBlock->iWorldX + mBlock->iSizeX < iCameraPosX)
 568         return 1;
 569     else
 570         return 0;
 571 }
 572
 573 static int chopParticleOffscreen(struct CParticle *mParticle)
 574 {
 575     if (mParticle->iWorldX < iCameraPosX || mParticle->iWorldY < 0 ||
 576         mParticle->iWorldY > iScreenY || mParticle->iWorldX > iCameraPosX +
 577         iScreenX)
 578     {
 579         return 1;
 580     }
 581     else
 582         return 0;
 583 }
 584
 585 static void chopKillPlayer(void)
 586 {
 587     int i;
 588
 589     for (i = 0; i < NUMBER_OF_PARTICLES; i++) {
 590         mParticles[i].bIsActive = 0;
 591         chopAddParticle(iPlayerPosX + iR(0,20), iPlayerPosY + iR(0,20),
 592                         iR(-2,2), iR(-2,2));
 593     }
 594
 595     iPlayerAlive--;
 596
 597     if (iPlayerAlive == 0) {
 598         rb->splash(HZ, "Game Over");
 599
 600         if (score > highscore) {
 601             char scoretext[30];
 602             highscore = score;
 603             rb->snprintf(scoretext, sizeof(scoretext), "New High Score: %d",
 604                          highscore);
 605             rb->splash(HZ*2, scoretext);
 606         }
 607     } else
 608         chopper_load(false);
 609 }
 610
 611 static void chopDrawTheWorld(void)
 612 {
 613     int i=0;
 614
 615     while(i < NUMBER_OF_BLOCKS)
 616     {
 617         if(mBlocks[i].bIsActive)
 618         {
 619             if(chopBlockOffscreen(&mBlocks[i]) == 1)
 620                 mBlocks[i].bIsActive = 0;
 621             else
 622                 chopDrawBlock(&mBlocks[i]);
 623         }
 624
 625         i++;
 626     }
 627
 628     i=0;
 629
 630     while(i < NUMBER_OF_PARTICLES)
 631     {
 632         if(mParticles[i].bIsActive)
 633         {
 634             if(chopParticleOffscreen(&mParticles[i]) == 1)
 635                 mParticles[i].bIsActive = 0;
 636             else
 637                 chopDrawParticle(&mParticles[i]);
 638         }
 639
 640         i++;
 641     }
 642
 643     chopRenderTerrain(&mGround, true);
 644     chopRenderTerrain(&mRoof, false);
 645
 646 }
 647
 648 static void chopDrawParticle(struct CParticle *mParticle)
 649 {
 650
 651     int iPosX = (mParticle->iWorldX - iCameraPosX);
 652     int iPosY = (mParticle->iWorldY);
 653 #if LCD_DEPTH > 2
 654     rb->lcd_set_foreground(LCD_RGBPACK(192,192,192));
 655 #elif LCD_DEPTH == 2
 656     rb->lcd_set_foreground(LCD_LIGHTGRAY);
 657 #endif
 658     rb->lcd_fillrect(SCALE(iPosX), SCALE(iPosY), SCALE(3), SCALE(3));
 659
 660 }
 661
 662 static void chopDrawScene(void)
 663 {
 664     char s[30];
 665     int w;
 666 #if LCD_DEPTH > 2
 667     rb->lcd_set_background(LCD_BLACK);
 668 #elif LCD_DEPTH == 2
 669     rb->lcd_set_background(LCD_WHITE);
 670 #endif
 671     rb->lcd_clear_display();
 672     chopDrawTheWorld();
 673     chopDrawPlayer(iPlayerPosX - iCameraPosX, iPlayerPosY);
 674
 675     score = -20 + iPlayerPosX/3;
 676
 677 #if LCD_DEPTH == 1
 678     rb->lcd_set_drawmode(DRMODE_COMPLEMENT);
 679 #else
 680     rb->lcd_set_drawmode(DRMODE_FG);
 681 #endif
 682
 683 #if LCD_DEPTH > 2
 684     rb->lcd_set_foreground(LCD_BLACK);
 685 #elif LCD_DEPTH == 2
 686     rb->lcd_set_foreground(LCD_WHITE);
 687 #endif
 688
 689 #if LCD_WIDTH <= 128
 690     rb->snprintf(s, sizeof(s), "Dist: %d", score);
 691 #else
 692     rb->snprintf(s, sizeof(s), "Distance: %d", score);
 693 #endif
 694     rb->lcd_getstringsize(s, &w, NULL);
 695     rb->lcd_putsxy(2, 2, s);
 696     if (score < highscore)
 697     {
 698         int w2;
 699 #if LCD_WIDTH <= 128
 700         rb->snprintf(s, sizeof(s), "Hi: %d", highscore);
 701 #else
 702         rb->snprintf(s, sizeof(s), "Best: %d", highscore);
 703 #endif
 704         rb->lcd_getstringsize(s, &w2, NULL);
 705         if (LCD_WIDTH - 2 - w2 > w + 2)
 706             rb->lcd_putsxy(LCD_WIDTH - 2 - w2, 2, s);
 707     }
 708     rb->lcd_set_drawmode(DRMODE_SOLID);
 709
 710     rb->lcd_update();
 711 }
 712
 713 static bool _ingame;
 714 static int chopMenuCb(int action, const struct menu_item_ex *this_item)
 715 {
 716     if(action == ACTION_REQUEST_MENUITEM
 717        && !_ingame && ((intptr_t)this_item)==0)
 718         return ACTION_EXIT_MENUITEM;
 719     return action;
 720 }
 721 static int chopMenu(int menunum)
 722 {
 723     int result = 0;
 724     int res = 0;
 725     bool menu_quit = false;
 726
 727     static const struct opt_items levels[2] = {
 728         { "Normal", -1 },
 729         { "Steep", -1 },
 730     };
 731
 732     MENUITEM_STRINGLIST(menu,"Chopper Menu",chopMenuCb,
 733                         "Resume Game","Start New Game",
 734                         "Level","Playback Control","Quit");
 735     _ingame = (menunum!=0);
 736
 737 #ifdef HAVE_LCD_COLOR
 738     rb->lcd_set_foreground(LCD_WHITE);
 739     rb->lcd_set_background(LCD_BLACK);
 740 #elif LCD_DEPTH == 2
 741     rb->lcd_set_foreground(LCD_BLACK);
 742     rb->lcd_set_background(LCD_WHITE);
 743 #endif
 744
 745     rb->lcd_clear_display();
 746     rb->button_clear_queue();
 747
 748     while (!menu_quit) {
 749         switch(rb->do_menu(&menu, &result, NULL, false))
 750         {
 751             case 0:     /* Resume Game */
 752                 menu_quit=true;
 753                 res = -1;
 754                 break;
 755             case 1:     /* Start New Game */
 756                 menu_quit=true;
 757                 chopper_load(true);
 758                 res = -1;
 759                 break;
 760             case 2:
 761                 rb->set_option("Level", &iLevelMode, INT, levels, 2, NULL);
 762                 break;
 763             case 3:
 764                 playback_control(NULL);
 765                 break;
 766             case 4:
 767                 menu_quit=true;
 768                 res = PLUGIN_OK;
 769                 break;
 770             case MENU_ATTACHED_USB:
 771                 menu_quit=true;
 772                 res = PLUGIN_USB_CONNECTED;
 773                 break;
 774         }
 775     }
 776     rb->lcd_clear_display();
 777     return res;
 778 }
 779
 780 static int chopGameLoop(void)
 781 {
 782     int move_button, ret;
 783     bool exit=false;
 784     int end, i=0, bdelay=0, last_button=BUTTON_NONE;
 785
 786     if (chopUpdateTerrainRecycling(&mGround) == 1)
 787         /* mirror the sky if we've changed the ground */
 788         chopCopyTerrain(&mGround, &mRoof, 0, - ( (iScreenY * 3) / 4));
 789
 790     ret = chopMenu(0);
 791     if (ret != -1)
 792         return PLUGIN_OK;
 793
 794     chopDrawScene();
 795
 796     while (!exit) {
 797
 798         end = *rb->current_tick + CYCLETIME;
 799
 800         if(chopUpdateTerrainRecycling(&mGround) == 1)
 801             /* mirror the sky if we've changed the ground */
 802             chopCopyTerrain(&mGround, &mRoof, 0, - ( (iScreenY * 3) / 4));
 803
 804         iRotorOffset = iR(-1,1);
 805
 806         /* We need to have this here so particles move when we're dead */
 807
 808         for (i=0; i < NUMBER_OF_PARTICLES; i++)
 809             if(mParticles[i].bIsActive == 1)
 810             {
 811                 mParticles[i].iWorldX += mParticles[i].iSpeedX;
 812                 mParticles[i].iWorldY += mParticles[i].iSpeedY;
 813             }
 814
 815         /* Redraw the main window: */
 816         chopDrawScene();
 817
 818
 819         iGravityTimerCountdown--;
 820
 821         if(iGravityTimerCountdown <= 0)
 822         {
 823             iGravityTimerCountdown = 3;
 824             chopAddParticle(iPlayerPosX, iPlayerPosY+5, 0, 0);
 825         }
 826
 827         if(iCurrLevelMode == LEVEL_MODE_NORMAL)
 828             chopGenerateBlockIfNeeded();
 829
 830
 831         move_button=rb->button_status();
 832         if (rb->button_get(false) == QUIT) {
 833             ret = chopMenu(1);
 834             if (ret != -1)
 835                 return PLUGIN_OK;
 836             bdelay = 0;
 837             last_button = BUTTON_NONE;
 838             move_button = BUTTON_NONE;
 839         }
 840
 841         switch (move_button) {
 842             case ACTION:
 843 #ifdef ACTION2
 844             case ACTION2:
 845 #endif
 846                 if (last_button != ACTION
 847 #ifdef ACTION2
 848                     && last_button != ACTION2
 849 #endif
 850                    )
 851                     bdelay = -2;
 852                 if (bdelay == 0)
 853                     iPlayerSpeedY = -3;
 854                 break;
 855
 856             default:
 857                 if (last_button == ACTION
 858 #ifdef ACTION2
 859                     || last_button == ACTION2
 860 #endif
 861                    )
 862                     bdelay = 3;
 863                 if (bdelay == 0)
 864                     iPlayerSpeedY = 4;
 865
 866                 if (rb->default_event_handler(move_button) == SYS_USB_CONNECTED)
 867                     return PLUGIN_USB_CONNECTED;
 868                 break;
 869         }
 870         last_button = move_button;
 871
 872         if (bdelay < 0) {
 873             iPlayerSpeedY = bdelay;
 874             bdelay++;
 875         } else if (bdelay > 0) {
 876             iPlayerSpeedY = bdelay;
 877             bdelay--;
 878         }
 879
 880         iCameraPosX = iPlayerPosX - 25;
 881         iPlayerPosX += iPlayerSpeedX;
 882         iPlayerPosY += iPlayerSpeedY;
 883
 884         chopCounter++;
 885         /* increase speed as we go along */
 886         if (chopCounter == 100){
 887             iPlayerSpeedX++;
 888             chopCounter=0;
 889         }
 890
 891         if (iPlayerPosY > iScreenY-10 || iPlayerPosY < -5 ||
 892            chopPointInTerrain(&mGround, iPlayerPosX, iPlayerPosY + 10, 0) ||
 893            chopPointInTerrain(&mRoof, iPlayerPosX ,iPlayerPosY, 1))
 894         {
 895            chopKillPlayer();
 896            chopDrawScene();
 897            ret = chopMenu(0);
 898            if (ret != -1)
 899                return ret;
 900         }
 901
 902         for (i=0; i < NUMBER_OF_BLOCKS; i++)
 903             if(mBlocks[i].bIsActive == 1)
 904                 if(chopBlockCollideWithPlayer(&mBlocks[i])) {
 905                     chopKillPlayer();
 906                     chopDrawScene();
 907                     ret = chopMenu(0);
 908                     if (ret != -1)
 909                         return ret;
 910                 }
 911
 912         if (TIME_BEFORE(*rb->current_tick, end))
 913             rb->sleep(end - *rb->current_tick); /* wait until time is over */
 914         else
 915             rb->yield();
 916
 917     }
 918     return PLUGIN_OK;
 919 }
 920
 921 static void chopDrawBlock(struct CBlock *mBlock)
 922 {
 923     int iPosX = (mBlock->iWorldX - iCameraPosX);
 924     int iPosY = (mBlock->iWorldY);
 925 #if LCD_DEPTH > 2
 926     rb->lcd_set_foreground(LCD_RGBPACK(100,255,100));
 927 #elif LCD_DEPTH == 2
 928     rb->lcd_set_foreground(LCD_BLACK);
 929 #endif
 930     rb->lcd_fillrect(SCALE(iPosX), SCALE(iPosY), SCALE(mBlock->iSizeX),
 931                      SCALE(mBlock->iSizeY));
 932 }
 933
 934
 935 static void chopRenderTerrain(struct CTerrain *ter, bool isground)
 936 {
 937
 938     int i = 1;
 939
 940     int oldx = 0;
 941
 942     while(i < ter->iNodesCount && oldx < iScreenX)
 943     {
 944
 945         int x = ter->mNodes[i-1].x - iCameraPosX;
 946         int y = ter->mNodes[i-1].y;
 947
 948         int x2 = ter->mNodes[i].x - iCameraPosX;
 949         int y2 = ter->mNodes[i].y;
 950
 951         int ax, ay;
 952
 953         if ((y < y2) != isground)
 954         {
 955             ax = x2;
 956             ay = y;
 957         }
 958         else
 959         {
 960             ax = x;
 961             ay = y2;
 962         }
 963 #if LCD_DEPTH > 2
 964         rb->lcd_set_foreground(LCD_RGBPACK(100,255,100));
 965 #elif LCD_DEPTH == 2
 966         rb->lcd_set_foreground(LCD_DARKGRAY);
 967 #endif
 968
 969         rb->lcd_drawline(SCALE(x), SCALE(y), SCALE(x2), SCALE(y2));
 970
 971         xlcd_filltriangle(SCALE(x), SCALE(y), SCALE(x2), SCALE(y2),
 972                           SCALE(ax), SCALE(ay));
 973
 974         if (isground)
 975         {
 976             y = ay;
 977             y2 = (LCD_HEIGHT*SIZE);
 978         }
 979         else
 980         {
 981             y = 0;
 982             y2 = ay;
 983         }
 984         if (y2-y > 0)
 985             rb->lcd_fillrect(SCALE(x), SCALE(y), SCALE(x2-x)+1, SCALE(y2-y)+1);
 986
 987         oldx = x;
 988         i++;
 989     }
 990 }
 991
 992 void chopper_load(bool newgame)
 993 {
 994
 995     int i;
 996     int g;
 997
 998     if (newgame) {
 999         iScreenX = LCD_WIDTH * SIZE;
1000         iScreenY = LCD_HEIGHT * SIZE;
1001         blockh = iScreenY / 5;
1002         blockw = iScreenX / 20;
1003         iPlayerAlive = 1;
1004         iCurrLevelMode = iLevelMode;
1005         score = 0;
1006     }
1007     iRotorOffset = 0;
1008     iPlayerPosX = 60;
1009     iPlayerPosY = (iScreenY * 4) / 10;
1010     iLastBlockPlacedPosX = 0;
1011     iGravityTimerCountdown = 2;
1012     chopCounter = 0;
1013     iPlayerSpeedX = 3;
1014     iPlayerSpeedY = 0;
1015     iCameraPosX = 30;
1016
1017     for (i=0; i < NUMBER_OF_PARTICLES; i++)
1018         mParticles[i].bIsActive = 0;
1019
1020     for (i=0; i < NUMBER_OF_BLOCKS; i++)
1021         mBlocks[i].bIsActive = 0;
1022
1023     g = iScreenY - 10;
1024     chopClearTerrain(&mGround);
1025
1026     for (i=0; i < MAX_TERRAIN_NODES; i++)
1027         chopAddTerrainNode(&mGround,i * 30,g - iR(0,20));
1028
1029     if (chopUpdateTerrainRecycling(&mGround) == 1)
1030         /* mirror the sky if we've changed the ground */
1031         chopCopyTerrain(&mGround, &mRoof, 0, - ( (iScreenY * 3) / 4));
1032
1033     if (iCurrLevelMode == LEVEL_MODE_NORMAL)
1034         /* make it a bit more exciting, cause it's easy terrain... */
1035         iPlayerSpeedX *= 2;
1036 }
1037
1038 /* this is the plugin entry point */
1039 enum plugin_status plugin_start(const void* parameter)
1040 {
1041     (void)parameter;
1042     int ret;
1043
1044     rb->lcd_setfont(FONT_SYSFIXED);
1045 #if LCD_DEPTH > 1
1046     rb->lcd_set_backdrop(NULL);
1047 #endif
1048 #ifdef HAVE_LCD_COLOR
1049     rb->lcd_set_background(LCD_BLACK);
1050     rb->lcd_set_foreground(LCD_WHITE);
1051 #endif
1052
1053     /* Turn off backlight timeout */
1054     backlight_force_on(); /* backlight control in lib/helper.c */
1055
1056     rb->srand( *rb->current_tick );
1057
1058     configfile_load(CFG_FILE, config, 1, 0);
1059
1060     chopper_load(true);
1061     ret = chopGameLoop();
1062
1063     configfile_save(CFG_FILE, config, 1, 0);
1064
1065     rb->lcd_setfont(FONT_UI);
1066     /* Turn on backlight timeout (revert to settings) */
1067     backlight_use_settings(); /* backlight control in lib/helper.c */
1068
1069     return ret;
1070 }