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