apps/plugins/pong.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2004 Daniel Stenberg
  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 #include "plugin.h"
  22
  23 #ifdef HAVE_LCD_BITMAP
  24
  25 PLUGIN_HEADER
  26
  27 #define PAD_HEIGHT LCD_HEIGHT / 6    /* Recorder: 10   iRiver: 21 */
  28 #define PAD_WIDTH LCD_WIDTH / 50     /* Recorder: 2    iRiver: 2  */
  29
  30 #define BALL_HEIGHT LCD_HEIGHT / 32  /* Recorder: 2    iRiver: 4  */
  31 #define BALL_WIDTH LCD_HEIGHT / 32   /* We want a square ball */
  32
  33 #define SPEEDX ( LCD_WIDTH * 3 ) / 2 /* Recorder: 168  iRiver: 240 */
  34 #define SPEEDY LCD_HEIGHT * 2        /* Recorder: 128  iRiver: 256 */
  35
  36 #define RES 100
  37
  38 #define MOVE_STEP LCD_HEIGHT / 32 /* move pad this many steps up/down each move */
  39
  40 /* variable button definitions */
  41 #if CONFIG_KEYPAD == RECORDER_PAD
  42 #define PONG_QUIT BUTTON_OFF
  43 #define PONG_PAUSE BUTTON_ON
  44 #define PONG_LEFT_UP BUTTON_F1
  45 #define PONG_LEFT_DOWN BUTTON_LEFT
  46 #define PONG_RIGHT_UP BUTTON_F3
  47 #define PONG_RIGHT_DOWN BUTTON_RIGHT
  48
  49 #elif CONFIG_KEYPAD == ARCHOS_AV300_PAD
  50 #define PONG_QUIT BUTTON_OFF
  51 #define PONG_PAUSE BUTTON_ON
  52 #define PONG_LEFT_UP BUTTON_F1
  53 #define PONG_LEFT_DOWN BUTTON_LEFT
  54 #define PONG_RIGHT_UP BUTTON_F3
  55 #define PONG_RIGHT_DOWN BUTTON_RIGHT
  56
  57 #elif CONFIG_KEYPAD == ONDIO_PAD
  58 #define PONG_QUIT BUTTON_OFF
  59 #define PONG_PAUSE BUTTON_RIGHT
  60 #define PONG_LEFT_UP BUTTON_LEFT
  61 #define PONG_LEFT_DOWN BUTTON_MENU
  62 #define PONG_RIGHT_UP BUTTON_UP
  63 #define PONG_RIGHT_DOWN BUTTON_DOWN
  64
  65 #elif CONFIG_KEYPAD == IRIVER_H100_PAD
  66 #define PONG_QUIT BUTTON_OFF
  67 #define PONG_LEFT_UP BUTTON_UP
  68 #define PONG_LEFT_DOWN BUTTON_DOWN
  69 #define PONG_RIGHT_UP BUTTON_ON
  70 #define PONG_RIGHT_DOWN BUTTON_MODE
  71 #define PONG_RC_QUIT BUTTON_RC_STOP
  72
  73 #elif CONFIG_KEYPAD == IRIVER_H300_PAD
  74 #define PONG_QUIT BUTTON_OFF
  75 #define PONG_LEFT_UP BUTTON_UP
  76 #define PONG_LEFT_DOWN BUTTON_DOWN
  77 #define PONG_RIGHT_UP BUTTON_REC
  78 #define PONG_RIGHT_DOWN BUTTON_MODE
  79 #define PONG_RC_QUIT BUTTON_RC_STOP
  80
  81 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
  82       (CONFIG_KEYPAD == IPOD_3G_PAD) || \
  83       (CONFIG_KEYPAD == IPOD_1G2G_PAD)
  84 #define PONG_QUIT BUTTON_SELECT
  85 #define PONG_LEFT_UP BUTTON_MENU
  86 #define PONG_LEFT_DOWN BUTTON_LEFT
  87 #define PONG_RIGHT_UP BUTTON_RIGHT
  88 #define PONG_RIGHT_DOWN BUTTON_PLAY
  89
  90 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
  91 #define PONG_QUIT BUTTON_POWER
  92 #define PONG_LEFT_UP BUTTON_UP
  93 #define PONG_LEFT_DOWN BUTTON_DOWN
  94 #define PONG_RIGHT_UP BUTTON_REC
  95 #define PONG_RIGHT_DOWN BUTTON_PLAY
  96
  97 #elif (CONFIG_KEYPAD == GIGABEAT_PAD)
  98 #define PONG_QUIT BUTTON_POWER
  99 #define PONG_PAUSE BUTTON_SELECT
 100 #define PONG_LEFT_UP BUTTON_UP
 101 #define PONG_LEFT_DOWN BUTTON_DOWN
 102 #define PONG_RIGHT_UP BUTTON_VOL_UP
 103 #define PONG_RIGHT_DOWN BUTTON_VOL_DOWN
 104
 105 #elif (CONFIG_KEYPAD == SANSA_E200_PAD) || \
 106       (CONFIG_KEYPAD == SANSA_CLIP_PAD) || \
 107       (CONFIG_KEYPAD == SANSA_M200_PAD)
 108 #define PONG_QUIT BUTTON_POWER
 109 #define PONG_PAUSE BUTTON_SELECT
 110 #define PONG_LEFT_UP BUTTON_LEFT
 111 #define PONG_LEFT_DOWN BUTTON_DOWN
 112 #define PONG_RIGHT_UP BUTTON_UP
 113 #define PONG_RIGHT_DOWN BUTTON_RIGHT
 114
 115 #elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
 116 #define PONG_QUIT BUTTON_HOME
 117 #define PONG_PAUSE BUTTON_SELECT
 118 #define PONG_LEFT_UP BUTTON_LEFT
 119 #define PONG_LEFT_DOWN BUTTON_DOWN
 120 #define PONG_RIGHT_UP BUTTON_UP
 121 #define PONG_RIGHT_DOWN BUTTON_RIGHT
 122
 123 #elif (CONFIG_KEYPAD == SANSA_C200_PAD)
 124 #define PONG_QUIT BUTTON_POWER
 125 #define PONG_PAUSE BUTTON_SELECT
 126 #define PONG_LEFT_UP BUTTON_VOL_UP
 127 #define PONG_LEFT_DOWN BUTTON_VOL_DOWN
 128 #define PONG_RIGHT_UP BUTTON_UP
 129 #define PONG_RIGHT_DOWN BUTTON_DOWN
 130
 131 #elif (CONFIG_KEYPAD == IRIVER_H10_PAD)
 132 #define PONG_QUIT BUTTON_POWER
 133 #define PONG_LEFT_UP BUTTON_SCROLL_UP
 134 #define PONG_LEFT_DOWN BUTTON_SCROLL_DOWN
 135 #define PONG_RIGHT_UP BUTTON_REW
 136 #define PONG_RIGHT_DOWN BUTTON_FF
 137
 138 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD)
 139 #define PONG_QUIT BUTTON_BACK
 140 #define PONG_LEFT_UP BUTTON_UP
 141 #define PONG_LEFT_DOWN BUTTON_DOWN
 142 #define PONG_RIGHT_UP BUTTON_VOL_UP
 143 #define PONG_RIGHT_DOWN BUTTON_VOL_DOWN
 144
 145 #elif (CONFIG_KEYPAD == MROBE100_PAD)
 146 #define PONG_QUIT BUTTON_POWER
 147 #define PONG_PAUSE BUTTON_SELECT
 148 #define PONG_LEFT_UP BUTTON_MENU
 149 #define PONG_LEFT_DOWN BUTTON_LEFT
 150 #define PONG_RIGHT_UP BUTTON_PLAY
 151 #define PONG_RIGHT_DOWN BUTTON_RIGHT
 152
 153 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
 154 #define PONG_QUIT BUTTON_RC_REC
 155 #define PONG_PAUSE BUTTON_RC_PLAY
 156 #define PONG_LEFT_UP BUTTON_RC_VOL_UP
 157 #define PONG_LEFT_DOWN BUTTON_RC_VOL_DOWN
 158 #define PONG_RIGHT_UP BUTTON_VOL_UP
 159 #define PONG_RIGHT_DOWN BUTTON_VOL_DOWN
 160
 161 #elif (CONFIG_KEYPAD == COWOND2_PAD)
 162 #define PONG_QUIT BUTTON_POWER
 163
 164 #elif CONFIG_KEYPAD == IAUDIO67_PAD
 165 #define PONG_QUIT BUTTON_POWER
 166 #define PONG_PAUSE BUTTON_MENU
 167 #define PONG_LEFT_UP BUTTON_VOLUP
 168 #define PONG_LEFT_DOWN BUTTON_VOLDOWN
 169 #define PONG_RIGHT_UP BUTTON_RIGHT
 170 #define PONG_RIGHT_DOWN BUTTON_LEFT
 171
 172 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
 173 #define PONG_QUIT BUTTON_BACK
 174 #define PONG_LEFT_UP BUTTON_UP
 175 #define PONG_LEFT_DOWN BUTTON_DOWN
 176 #define PONG_RIGHT_UP BUTTON_PLAY
 177 #define PONG_RIGHT_DOWN BUTTON_MENU
 178
 179 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
 180 #define PONG_QUIT BUTTON_POWER
 181 #define PONG_PAUSE BUTTON_MENU
 182 #define PONG_LEFT_UP BUTTON_UP
 183 #define PONG_LEFT_DOWN BUTTON_DOWN
 184 #define PONG_RIGHT_UP BUTTON_VOL_UP
 185 #define PONG_RIGHT_DOWN BUTTON_VOL_DOWN
 186
 187 #elif (CONFIG_KEYPAD == ONDAVX747_PAD) || CONFIG_KEYPAD == MROBE500_PAD
 188 #define PONG_QUIT BUTTON_POWER
 189
 190 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
 191 #define PONG_QUIT        BUTTON_REC
 192 #define PONG_PAUSE       BUTTON_PLAY
 193 #define PONG_LEFT_UP     BUTTON_UP
 194 #define PONG_LEFT_DOWN   BUTTON_DOWN
 195 #define PONG_RIGHT_UP    BUTTON_FFWD
 196 #define PONG_RIGHT_DOWN  BUTTON_REW
 197
 198 #else
 199 #error No keymap defined!
 200 #endif
 201
 202 #ifdef HAVE_TOUCHSCREEN
 203 #ifndef PONG_QUIT
 204 #define PONG_QUIT       BUTTON_TOPMIDDLE
 205 #endif
 206 #ifndef PONG_LEFT_UP
 207 #define PONG_LEFT_UP    BUTTON_TOPLEFT
 208 #endif
 209 #ifndef PONG_LEFT_DOWN
 210 #define PONG_LEFT_DOWN  BUTTON_BOTTOMLEFT
 211 #endif
 212 #ifndef PONG_RIGHT_UP
 213 #define PONG_RIGHT_UP   BUTTON_TOPRIGHT
 214 #endif
 215 #ifndef PONG_RIGHT_DOWN
 216 #define PONG_RIGHT_DOWN BUTTON_BOTTOMRIGHT
 217 #endif
 218 #ifndef PONG_PAUSE
 219 #define PONG_PAUSE      BUTTON_CENTER
 220 #endif
 221 #endif
 222
 223 struct pong {
 224     int ballx; /* current X*RES position of the ball */
 225     int bally; /* current Y*RES position of the ball */
 226     int w_pad[2]; /* wanted current Y positions of pads */
 227     int e_pad[2]; /* existing current Y positions of pads */
 228     int ballspeedx; /*  */
 229     int ballspeedy; /*  */
 230
 231     int score[2];
 232 };
 233
 234 void singlepad(int x, int y, int set)
 235 {
 236     if(set) {
 237         rb->lcd_fillrect(x, y, PAD_WIDTH, PAD_HEIGHT);
 238     }
 239     else {
 240         rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
 241         rb->lcd_fillrect(x, y, PAD_WIDTH, PAD_HEIGHT);
 242         rb->lcd_set_drawmode(DRMODE_SOLID);
 243     }
 244 }
 245
 246 static int xpos[2]={0, LCD_WIDTH-PAD_WIDTH};
 247 void pad(struct pong *p, int pad)
 248 {
 249     /* clear existing pad */
 250     singlepad(xpos[pad], p->e_pad[pad], 0);
 251
 252     /* draw wanted pad */
 253     singlepad(xpos[pad], p->w_pad[pad], 1);
 254
 255     /* existing is now the wanted */
 256     p->e_pad[pad] = p->w_pad[pad];
 257 }
 258
 259 bool wallcollide(struct pong *p, int pad)
 260 {
 261     /* we have already checked for pad-collision, just check if this hits
 262        the wall */
 263     if(pad) {
 264         /* right-side */
 265         if(p->ballx > LCD_WIDTH*RES)
 266             return true;
 267     }
 268     else {
 269         if(p->ballx < 0)
 270             return true;
 271     }
 272     return false;
 273 }
 274
 275 /* returns true if the ball has hit a pad, and then the info variable
 276    will have extra angle info */
 277
 278 bool padcollide(struct pong *p, int pad, int *info)
 279 {
 280     int x = p->ballx/RES;
 281     int y = p->bally/RES;
 282
 283     if((y < (p->e_pad[pad]+PAD_HEIGHT)) &&
 284        (y + BALL_HEIGHT > p->e_pad[pad])) {
 285         /* Y seems likely right */
 286
 287         /* store the delta between ball-middle MINUS pad-middle, so
 288            it returns:
 289            0 when the ball hits exactly the middle of the pad
 290            positive numbers when the ball is below the middle of the pad
 291            negative numbers when the ball is above the middle of the pad
 292
 293            max number is +- PAD_HEIGHT/2
 294         */
 295
 296         *info = (y+BALL_HEIGHT/2) - (p->e_pad[pad] + PAD_HEIGHT/2);
 297
 298         if(pad) {
 299             /* right-side */
 300             if((x + BALL_WIDTH) >= (LCD_WIDTH - PAD_WIDTH))
 301                 return true; /* phump */
 302         }
 303         else {
 304             if(x <= PAD_WIDTH)
 305                 return true;
 306         }
 307     }
 308     return false; /* nah */
 309 }
 310
 311 void bounce(struct pong *p, int pad, int info)
 312 {
 313     (void)pad; /* not used right now */
 314     p->ballspeedx = -p->ballspeedx;
 315
 316     /* info is the hit-angle into the pad */
 317     if(p->ballspeedy > 0) {
 318         /* downwards */
 319         if(info > 0) {
 320             /* below the middle of the pad */
 321             p->ballspeedy += info * RES/3;
 322         }
 323         else if(info < 0) {
 324             /* above the middle */
 325             p->ballspeedy = info * RES/2;
 326         }
 327     }
 328     else {
 329         /* upwards */
 330         if(info > 0) {
 331             /* below the middle of the pad */
 332             p->ballspeedy = info * RES/2;
 333         }
 334         else if(info < 0) {
 335             /* above the middle */
 336             p->ballspeedy -= info * RES/3;
 337         }
 338     }
 339
 340     p->ballspeedy += rb->rand()%21-10;
 341
 342 #if 0
 343     fprintf(stderr, "INFO: %d YSPEED: %d\n", info, p->ballspeedy);
 344 #endif
 345 }
 346
 347 void score(struct pong *p, int pad)
 348 {
 349     if(pad)
 350         rb->splash(HZ/4, "right scores!");
 351     else
 352         rb->splash(HZ/4, "left scores!");
 353     rb->lcd_clear_display();
 354     p->score[pad]++;
 355
 356     /* then move the X-speed of the ball and give it a random Y position */
 357     p->ballspeedx = -p->ballspeedx;
 358     p->bally = rb->rand()%(LCD_HEIGHT*RES - BALL_HEIGHT);
 359
 360     /* avoid hitting the pad with the new ball */
 361     p->ballx = (p->ballx < 0) ?
 362         (RES * PAD_WIDTH) : (RES * (LCD_WIDTH - PAD_WIDTH - BALL_WIDTH));
 363
 364     /* restore Y-speed to default */
 365     p->ballspeedy = (p->ballspeedy > 0) ? SPEEDY : -SPEEDY;
 366
 367     /* set the existing pad positions to something weird to force pad
 368        updates */
 369     p->e_pad[0] = -1;
 370     p->e_pad[1] = -1;
 371 }
 372
 373 void ball(struct pong *p)
 374 {
 375     int x = p->ballx/RES;
 376     int y = p->bally/RES;
 377
 378     int newx;
 379     int newy;
 380
 381     int info;
 382
 383     /* movement */
 384     p->ballx += p->ballspeedx;
 385     p->bally += p->ballspeedy;
 386
 387     newx = p->ballx/RES;
 388     newy = p->bally/RES;
 389
 390     /* detect if ball hits a wall */
 391     if(newy + BALL_HEIGHT > LCD_HEIGHT) {
 392         /* hit floor, bounce */
 393         p->ballspeedy = -p->ballspeedy;
 394         newy = LCD_HEIGHT - BALL_HEIGHT;
 395         p->bally = newy * RES;
 396     }
 397     else if(newy < 0) {
 398         /* hit ceiling, bounce */
 399         p->ballspeedy = -p->ballspeedy;
 400         p->bally = 0;
 401         newy = 0;
 402     }
 403
 404     /* detect if ball hit pads */
 405     if(padcollide(p, 0, &info))
 406         bounce(p, 0, info);
 407     else if(padcollide(p, 1, &info))
 408         bounce(p, 1, info);
 409     else if(wallcollide(p, 0))
 410         score(p, 1);
 411     else if(wallcollide(p, 1))
 412         score(p, 0);
 413
 414         newx = p->ballx/RES;
 415         newy = p->bally/RES;
 416
 417     /* clear old position */
 418     rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
 419     rb->lcd_fillrect(x, y, BALL_WIDTH, BALL_HEIGHT);
 420     rb->lcd_set_drawmode(DRMODE_SOLID);
 421
 422     /* draw the new ball position */
 423     rb->lcd_fillrect(newx, newy, BALL_WIDTH, BALL_HEIGHT);
 424 }
 425
 426 void padmove(int *pos, int dir)
 427 {
 428     *pos += dir;
 429     if(*pos > (LCD_HEIGHT-PAD_HEIGHT))
 430         *pos = (LCD_HEIGHT-PAD_HEIGHT);
 431     else if(*pos < 0)
 432         *pos = 0;
 433 }
 434
 435 int keys(struct pong *p)
 436 {
 437     int key;
 438 #ifdef PONG_PAUSE
 439     static bool pause = false;
 440 #endif
 441
 442     /* number of ticks this function will loop reading keys */
 443 #ifndef HAVE_TOUCHSCREEN
 444     int time = 4;
 445 #else
 446     int time = 1;
 447 #endif
 448     int start = *rb->current_tick;
 449     int end = start + time;
 450
 451     while(end > *rb->current_tick) {
 452         key = rb->button_get_w_tmo(end - *rb->current_tick);
 453
 454 #ifdef HAVE_TOUCHSCREEN
 455     short touch_x, touch_y;
 456     if(key & BUTTON_TOUCHSCREEN)
 457     {
 458         touch_x = rb->button_get_data() >> 16;
 459         touch_y = rb->button_get_data() & 0xFFFF;
 460         if(touch_x >= xpos[0] && touch_x <= xpos[0]+(PAD_WIDTH*4))
 461             padmove(&p->w_pad[0], touch_y-(p->e_pad[0]*2+PAD_HEIGHT)/2);
 462
 463         if(touch_x >= xpos[1]-(PAD_WIDTH*4) && touch_x <= xpos[1])
 464             padmove(&p->w_pad[1], touch_y-(p->e_pad[1]*2+PAD_HEIGHT)/2);
 465     }
 466 #endif
 467
 468 #ifdef HAS_BUTTON_HOLD
 469         if (rb->button_hold())
 470         return 2; /* Pause game */
 471 #endif
 472
 473         if(key & PONG_QUIT
 474 #ifdef PONG_RC_QUIT
 475            || key & PONG_RC_QUIT
 476 #endif
 477         )
 478             return 0; /* exit game NOW */
 479
 480 #ifdef PONG_PAUSE
 481         if(key == PONG_PAUSE)
 482             pause = !pause;
 483         if(pause)
 484             return 2; /* Pause game */
 485 #endif
 486
 487         key = rb->button_status(); /* ignore BUTTON_REPEAT */
 488
 489         if(key & PONG_LEFT_DOWN) /* player left goes down */
 490             padmove(&p->w_pad[0], MOVE_STEP);
 491
 492         if(key & PONG_LEFT_UP)   /* player left goes up */
 493             padmove(&p->w_pad[0], -MOVE_STEP);
 494
 495         if(key & PONG_RIGHT_DOWN) /* player right goes down */
 496             padmove(&p->w_pad[1], MOVE_STEP);
 497
 498         if(key & PONG_RIGHT_UP)   /* player right goes up */
 499             padmove(&p->w_pad[1], -MOVE_STEP);
 500
 501         if(rb->default_event_handler(key) == SYS_USB_CONNECTED)
 502             return -1; /* exit game because of USB */
 503     }
 504     return 1; /* return 0 to exit game */
 505 }
 506
 507 void showscore(struct pong *p)
 508 {
 509     static char buffer[20];
 510     int w;
 511
 512     rb->snprintf(buffer, sizeof(buffer), "%d - %d", p->score[0], p->score[1]);
 513     w = rb->lcd_getstringsize((unsigned char *)buffer, NULL, NULL);
 514     rb->lcd_putsxy( (LCD_WIDTH / 2) - (w / 2), 0, (unsigned char *)buffer);
 515 }
 516
 517 /* this is the plugin entry point */
 518 enum plugin_status plugin_start(const void* parameter)
 519 {
 520     struct pong pong;
 521     int game = 1;
 522
 523     /* init the struct with some silly values to start with */
 524
 525     pong.ballx = 20*RES;
 526     pong.bally = 20*RES;
 527
 528     pong.e_pad[0] = 0;
 529     pong.w_pad[0] = 7;
 530     pong.e_pad[1] = 0;
 531     pong.w_pad[1] = 40;
 532
 533     pong.ballspeedx = SPEEDX;
 534     pong.ballspeedy = SPEEDY;
 535
 536     pong.score[0] = pong.score[1] = 0; /* lets start at 0 - 0 ;-) */
 537
 538     /* if you don't use the parameter, you can do like
 539        this to avoid the compiler warning about it */
 540     (void)parameter;
 541
 542     /* Clear screen */
 543     rb->lcd_clear_display();
 544
 545     /* go go go */
 546     while(game > 0) {
 547         if (game == 2) { /* Game Paused */
 548             rb->splash(0, "PAUSED");
 549             while(game == 2)
 550                 game = keys(&pong); /* short circuit */
 551             rb->lcd_clear_display();
 552         }
 553         showscore(&pong);
 554         pad(&pong, 0); /* draw left pad */
 555         pad(&pong, 1); /* draw right pad */
 556         ball(&pong); /* move and draw ball */
 557
 558         rb->lcd_update();
 559
 560         game = keys(&pong); /* deal with keys */
 561     }
 562
 563     return (game == 0) ? PLUGIN_OK : PLUGIN_USB_CONNECTED;
 564 }
 565
 566 #endif /* HAVE_LCD_BITMAP */