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 == COWON_D2_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 == PHILIPS_SA9200_PAD
 188 #define PONG_QUIT BUTTON_POWER
 189 #define PONG_PAUSE BUTTON_MENU
 190 #define PONG_LEFT_UP BUTTON_UP
 191 #define PONG_LEFT_DOWN BUTTON_DOWN
 192 #define PONG_RIGHT_UP BUTTON_VOL_UP
 193 #define PONG_RIGHT_DOWN BUTTON_VOL_DOWN
 194
 195 #elif CONFIG_KEYPAD == ONDAVX747_PAD || \
 196 CONFIG_KEYPAD == ONDAVX777_PAD || \
 197 CONFIG_KEYPAD == MROBE500_PAD
 198 #define PONG_QUIT BUTTON_POWER
 199
 200 #elif CONFIG_KEYPAD == SAMSUNG_YH_PAD
 201 #define PONG_QUIT        BUTTON_REC
 202 #define PONG_PAUSE       BUTTON_PLAY
 203 #define PONG_LEFT_UP     BUTTON_UP
 204 #define PONG_LEFT_DOWN   BUTTON_DOWN
 205 #define PONG_RIGHT_UP    BUTTON_FFWD
 206 #define PONG_RIGHT_DOWN  BUTTON_REW
 207
 208 #elif CONFIG_KEYPAD == PBELL_VIBE500_PAD
 209 #define PONG_QUIT        BUTTON_REC
 210 #define PONG_PAUSE       BUTTON_OK
 211 #define PONG_LEFT_UP     BUTTON_MENU
 212 #define PONG_LEFT_DOWN   BUTTON_PREV
 213 #define PONG_RIGHT_UP    BUTTON_PLAY
 214 #define PONG_RIGHT_DOWN  BUTTON_NEXT
 215
 216 #else
 217 #error No keymap defined!
 218 #endif
 219
 220 #ifdef HAVE_TOUCHSCREEN
 221 #ifndef PONG_QUIT
 222 #define PONG_QUIT       BUTTON_TOPMIDDLE
 223 #endif
 224 #ifndef PONG_LEFT_UP
 225 #define PONG_LEFT_UP    BUTTON_TOPLEFT
 226 #endif
 227 #ifndef PONG_LEFT_DOWN
 228 #define PONG_LEFT_DOWN  BUTTON_BOTTOMLEFT
 229 #endif
 230 #ifndef PONG_RIGHT_UP
 231 #define PONG_RIGHT_UP   BUTTON_TOPRIGHT
 232 #endif
 233 #ifndef PONG_RIGHT_DOWN
 234 #define PONG_RIGHT_DOWN BUTTON_BOTTOMRIGHT
 235 #endif
 236 #ifndef PONG_PAUSE
 237 #define PONG_PAUSE      BUTTON_CENTER
 238 #endif
 239 #endif
 240
 241 struct pong {
 242     int ballx; /* current X*RES position of the ball */
 243     int bally; /* current Y*RES position of the ball */
 244     int w_pad[2]; /* wanted current Y positions of pads */
 245     int e_pad[2]; /* existing current Y positions of pads */
 246     int ballspeedx; /*  */
 247     int ballspeedy; /*  */
 248
 249     int score[2];
 250 };
 251
 252 void singlepad(int x, int y, int set)
 253 {
 254     if(set) {
 255         rb->lcd_fillrect(x, y, PAD_WIDTH, PAD_HEIGHT);
 256     }
 257     else {
 258         rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
 259         rb->lcd_fillrect(x, y, PAD_WIDTH, PAD_HEIGHT);
 260         rb->lcd_set_drawmode(DRMODE_SOLID);
 261     }
 262 }
 263
 264 static int xpos[2]={0, LCD_WIDTH-PAD_WIDTH};
 265 void pad(struct pong *p, int pad)
 266 {
 267     /* clear existing pad */
 268     singlepad(xpos[pad], p->e_pad[pad], 0);
 269
 270     /* draw wanted pad */
 271     singlepad(xpos[pad], p->w_pad[pad], 1);
 272
 273     /* existing is now the wanted */
 274     p->e_pad[pad] = p->w_pad[pad];
 275 }
 276
 277 bool wallcollide(struct pong *p, int pad)
 278 {
 279     /* we have already checked for pad-collision, just check if this hits
 280        the wall */
 281     if(pad) {
 282         /* right-side */
 283         if(p->ballx > LCD_WIDTH*RES)
 284             return true;
 285     }
 286     else {
 287         if(p->ballx < 0)
 288             return true;
 289     }
 290     return false;
 291 }
 292
 293 /* returns true if the ball has hit a pad, and then the info variable
 294    will have extra angle info */
 295
 296 bool padcollide(struct pong *p, int pad, int *info)
 297 {
 298     int x = p->ballx/RES;
 299     int y = p->bally/RES;
 300
 301     if((y < (p->e_pad[pad]+PAD_HEIGHT)) &&
 302        (y + BALL_HEIGHT > p->e_pad[pad])) {
 303         /* Y seems likely right */
 304
 305         /* store the delta between ball-middle MINUS pad-middle, so
 306            it returns:
 307            0 when the ball hits exactly the middle of the pad
 308            positive numbers when the ball is below the middle of the pad
 309            negative numbers when the ball is above the middle of the pad
 310
 311            max number is +- PAD_HEIGHT/2
 312         */
 313
 314         *info = (y+BALL_HEIGHT/2) - (p->e_pad[pad] + PAD_HEIGHT/2);
 315
 316         if(pad) {
 317             /* right-side */
 318             if((x + BALL_WIDTH) >= (LCD_WIDTH - PAD_WIDTH))
 319                 return true; /* phump */
 320         }
 321         else {
 322             if(x <= PAD_WIDTH)
 323                 return true;
 324         }
 325     }
 326     return false; /* nah */
 327 }
 328
 329 void bounce(struct pong *p, int pad, int info)
 330 {
 331     (void)pad; /* not used right now */
 332     p->ballspeedx = -p->ballspeedx;
 333
 334     /* info is the hit-angle into the pad */
 335     if(p->ballspeedy > 0) {
 336         /* downwards */
 337         if(info > 0) {
 338             /* below the middle of the pad */
 339             p->ballspeedy += info * RES/3;
 340         }
 341         else if(info < 0) {
 342             /* above the middle */
 343             p->ballspeedy = info * RES/2;
 344         }
 345     }
 346     else {
 347         /* upwards */
 348         if(info > 0) {
 349             /* below the middle of the pad */
 350             p->ballspeedy = info * RES/2;
 351         }
 352         else if(info < 0) {
 353             /* above the middle */
 354             p->ballspeedy -= info * RES/3;
 355         }
 356     }
 357
 358     p->ballspeedy += rb->rand()%21-10;
 359
 360 #if 0
 361     fprintf(stderr, "INFO: %d YSPEED: %d\n", info, p->ballspeedy);
 362 #endif
 363 }
 364
 365 void score(struct pong *p, int pad)
 366 {
 367     if(pad)
 368         rb->splash(HZ/4, "right scores!");
 369     else
 370         rb->splash(HZ/4, "left scores!");
 371     rb->lcd_clear_display();
 372     p->score[pad]++;
 373
 374     /* then move the X-speed of the ball and give it a random Y position */
 375     p->ballspeedx = -p->ballspeedx;
 376     p->bally = rb->rand()%(LCD_HEIGHT*RES - BALL_HEIGHT);
 377
 378     /* avoid hitting the pad with the new ball */
 379     p->ballx = (p->ballx < 0) ?
 380         (RES * PAD_WIDTH) : (RES * (LCD_WIDTH - PAD_WIDTH - BALL_WIDTH));
 381
 382     /* restore Y-speed to default */
 383     p->ballspeedy = (p->ballspeedy > 0) ? SPEEDY : -SPEEDY;
 384
 385     /* set the existing pad positions to something weird to force pad
 386        updates */
 387     p->e_pad[0] = -1;
 388     p->e_pad[1] = -1;
 389 }
 390
 391 void ball(struct pong *p)
 392 {
 393     int x = p->ballx/RES;
 394     int y = p->bally/RES;
 395
 396     int newx;
 397     int newy;
 398
 399     int info;
 400
 401     /* movement */
 402     p->ballx += p->ballspeedx;
 403     p->bally += p->ballspeedy;
 404
 405     newx = p->ballx/RES;
 406     newy = p->bally/RES;
 407
 408     /* detect if ball hits a wall */
 409     if(newy + BALL_HEIGHT > LCD_HEIGHT) {
 410         /* hit floor, bounce */
 411         p->ballspeedy = -p->ballspeedy;
 412         newy = LCD_HEIGHT - BALL_HEIGHT;
 413         p->bally = newy * RES;
 414     }
 415     else if(newy < 0) {
 416         /* hit ceiling, bounce */
 417         p->ballspeedy = -p->ballspeedy;
 418         p->bally = 0;
 419         newy = 0;
 420     }
 421
 422     /* detect if ball hit pads */
 423     if(padcollide(p, 0, &info))
 424         bounce(p, 0, info);
 425     else if(padcollide(p, 1, &info))
 426         bounce(p, 1, info);
 427     else if(wallcollide(p, 0))
 428         score(p, 1);
 429     else if(wallcollide(p, 1))
 430         score(p, 0);
 431
 432         newx = p->ballx/RES;
 433         newy = p->bally/RES;
 434
 435     /* clear old position */
 436     rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
 437     rb->lcd_fillrect(x, y, BALL_WIDTH, BALL_HEIGHT);
 438     rb->lcd_set_drawmode(DRMODE_SOLID);
 439
 440     /* draw the new ball position */
 441     rb->lcd_fillrect(newx, newy, BALL_WIDTH, BALL_HEIGHT);
 442 }
 443
 444 void padmove(int *pos, int dir)
 445 {
 446     *pos += dir;
 447     if(*pos > (LCD_HEIGHT-PAD_HEIGHT))
 448         *pos = (LCD_HEIGHT-PAD_HEIGHT);
 449     else if(*pos < 0)
 450         *pos = 0;
 451 }
 452
 453 int keys(struct pong *p)
 454 {
 455     int key;
 456 #ifdef PONG_PAUSE
 457     static bool pause = false;
 458 #endif
 459
 460     /* number of ticks this function will loop reading keys */
 461 #ifndef HAVE_TOUCHSCREEN
 462     int time = 4;
 463 #else
 464     int time = 1;
 465 #endif
 466     int start = *rb->current_tick;
 467     int end = start + time;
 468
 469     while(TIME_BEFORE(*rb->current_tick, end)) {
 470         key = rb->button_get_w_tmo(end - *rb->current_tick);
 471
 472 #ifdef HAVE_TOUCHSCREEN
 473         short touch_x, touch_y;
 474         if(key & BUTTON_TOUCHSCREEN)
 475         {
 476             touch_x = rb->button_get_data() >> 16;
 477             touch_y = rb->button_get_data() & 0xFFFF;
 478             if(touch_x >= xpos[0] && touch_x <= xpos[0]+(PAD_WIDTH*4))
 479                 padmove(&p->w_pad[0], touch_y-(p->e_pad[0]*2+PAD_HEIGHT)/2);
 480
 481             if(touch_x >= xpos[1]-(PAD_WIDTH*4) && touch_x <= xpos[1])
 482                 padmove(&p->w_pad[1], touch_y-(p->e_pad[1]*2+PAD_HEIGHT)/2);
 483         }
 484 #endif
 485
 486 #ifdef HAS_BUTTON_HOLD
 487         if (rb->button_hold())
 488         return 2; /* Pause game */
 489 #endif
 490
 491         if(key & PONG_QUIT
 492 #ifdef PONG_RC_QUIT
 493            || key & PONG_RC_QUIT
 494 #endif
 495         )
 496             return 0; /* exit game NOW */
 497
 498 #ifdef PONG_PAUSE
 499         if(key == PONG_PAUSE)
 500             pause = !pause;
 501         if(pause)
 502             return 2; /* Pause game */
 503 #endif
 504
 505         key = rb->button_status(); /* ignore BUTTON_REPEAT */
 506
 507         if(key & PONG_LEFT_DOWN) /* player left goes down */
 508             padmove(&p->w_pad[0], MOVE_STEP);
 509
 510         if(key & PONG_LEFT_UP)   /* player left goes up */
 511             padmove(&p->w_pad[0], -MOVE_STEP);
 512
 513         if(key & PONG_RIGHT_DOWN) /* player right goes down */
 514             padmove(&p->w_pad[1], MOVE_STEP);
 515
 516         if(key & PONG_RIGHT_UP)   /* player right goes up */
 517             padmove(&p->w_pad[1], -MOVE_STEP);
 518
 519         if(rb->default_event_handler(key) == SYS_USB_CONNECTED)
 520             return -1; /* exit game because of USB */
 521     }
 522     return 1; /* return 0 to exit game */
 523 }
 524
 525 void showscore(struct pong *p)
 526 {
 527     static char buffer[20];
 528     int w;
 529
 530     rb->snprintf(buffer, sizeof(buffer), "%d - %d", p->score[0], p->score[1]);
 531     w = rb->lcd_getstringsize((unsigned char *)buffer, NULL, NULL);
 532     rb->lcd_putsxy( (LCD_WIDTH / 2) - (w / 2), 0, (unsigned char *)buffer);
 533 }
 534
 535 /* this is the plugin entry point */
 536 enum plugin_status plugin_start(const void* parameter)
 537 {
 538     struct pong pong;
 539     int game = 1;
 540
 541     /* init the struct with some silly values to start with */
 542
 543     pong.ballx = 20*RES;
 544     pong.bally = 20*RES;
 545
 546     pong.e_pad[0] = 0;
 547     pong.w_pad[0] = 7;
 548     pong.e_pad[1] = 0;
 549     pong.w_pad[1] = 40;
 550
 551     pong.ballspeedx = SPEEDX;
 552     pong.ballspeedy = SPEEDY;
 553
 554     pong.score[0] = pong.score[1] = 0; /* lets start at 0 - 0 ;-) */
 555
 556     /* if you don't use the parameter, you can do like
 557        this to avoid the compiler warning about it */
 558     (void)parameter;
 559
 560     /* Clear screen */
 561     rb->lcd_clear_display();
 562
 563     /* go go go */
 564     while(game > 0) {
 565         if (game == 2) { /* Game Paused */
 566             rb->splash(0, "PAUSED");
 567             while(game == 2)
 568                 game = keys(&pong); /* short circuit */
 569             rb->lcd_clear_display();
 570         }
 571         showscore(&pong);
 572         pad(&pong, 0); /* draw left pad */
 573         pad(&pong, 1); /* draw right pad */
 574         ball(&pong); /* move and draw ball */
 575
 576         rb->lcd_update();
 577
 578         game = keys(&pong); /* deal with keys */
 579     }
 580
 581     return (game == 0) ? PLUGIN_OK : PLUGIN_USB_CONNECTED;
 582 }
 583
 584 #endif /* HAVE_LCD_BITMAP */