src/events.c

   1 /***********************************************************
   2 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
   3 *----------------------------------------------------------*
   4 * (c) 1995-2002 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * events.c                                                 *
  12 ***********************************************************/
  13
  14 #include "libgame/libgame.h"
  15
  16 #include "events.h"
  17 #include "init.h"
  18 #include "screens.h"
  19 #include "tools.h"
  20 #include "game.h"
  21 #include "editor.h"
  22 #include "files.h"
  23 #include "tape.h"
  24 #include "network.h"
  25
  26 /* values for key_status */
  27 #define KEY_NOT_PRESSED         FALSE
  28 #define KEY_RELEASED            FALSE
  29 #define KEY_PRESSED             TRUE
  30
  31
  32 static boolean cursor_inside_playfield = FALSE;
  33 static boolean playfield_cursor_set = FALSE;
  34 static unsigned long playfield_cursor_delay = 0;
  35
  36
  37 /* event filter especially needed for SDL event filtering due to
  38    delay problems with lots of mouse motion events when mouse button
  39    not pressed (X11 can handle this with 'PointerMotionHintMask') */
  40
  41 int FilterMouseMotionEvents(const Event *event)
  42 {
  43   MotionEvent *motion;
  44
  45   /* non-motion events are directly passed to event handler functions */
  46   if (event->type != EVENT_MOTIONNOTIFY)
  47     return 1;
  48
  49   motion = (MotionEvent *)event;
  50   cursor_inside_playfield = (motion->x >= SX && motion->x < SX + SXSIZE &&
  51                              motion->y >= SY && motion->y < SY + SYSIZE);
  52
  53   if (game_status == GAME_MODE_PLAYING && playfield_cursor_set)
  54   {
  55     SetMouseCursor(CURSOR_DEFAULT);
  56     playfield_cursor_set = FALSE;
  57     DelayReached(&playfield_cursor_delay, 0);
  58   }
  59
  60   /* skip mouse motion events without pressed button outside level editor */
  61   if (button_status == MB_RELEASED && game_status != GAME_MODE_EDITOR &&
  62       game_status != GAME_MODE_PLAYING)
  63     return 0;
  64   else
  65     return 1;
  66 }
  67
  68 /* this is only really needed for non-SDL targets to filter unwanted events;
  69    when using SDL with properly installed event filter, this function can be
  70    replaced with a simple "NextEvent()" call, but it doesn't hurt either */
  71
  72 static boolean NextValidEvent(Event *event)
  73 {
  74   while (PendingEvent())
  75   {
  76     NextEvent(event);
  77
  78     if (FilterMouseMotionEvents(event))
  79       return TRUE;
  80   }
  81
  82   return FALSE;
  83 }
  84
  85 void EventLoop(void)
  86 {
  87   while(1)
  88   {
  89     if (PendingEvent())         /* got event */
  90     {
  91       Event event;
  92
  93       if (NextValidEvent(&event))
  94       {
  95         switch(event.type)
  96         {
  97           case EVENT_BUTTONPRESS:
  98           case EVENT_BUTTONRELEASE:
  99             HandleButtonEvent((ButtonEvent *) &event);
 100             break;
 101
 102           case EVENT_MOTIONNOTIFY:
 103             HandleMotionEvent((MotionEvent *) &event);
 104             break;
 105
 106           case EVENT_KEYPRESS:
 107           case EVENT_KEYRELEASE:
 108             HandleKeyEvent((KeyEvent *) &event);
 109             break;
 110
 111           default:
 112             HandleOtherEvents(&event);
 113             break;
 114         }
 115       }
 116     }
 117     else
 118     {
 119       /* when playing, display a special mouse pointer inside the playfield */
 120       if (game_status == GAME_MODE_PLAYING)
 121       {
 122         if (!playfield_cursor_set && cursor_inside_playfield &&
 123             DelayReached(&playfield_cursor_delay, 1000))
 124         {
 125           SetMouseCursor(CURSOR_PLAYFIELD);
 126           playfield_cursor_set = TRUE;
 127         }
 128       }
 129       else if (playfield_cursor_set)
 130       {
 131         SetMouseCursor(CURSOR_DEFAULT);
 132         playfield_cursor_set = FALSE;
 133       }
 134
 135       HandleNoEvent();
 136     }
 137
 138     /* don't use all CPU time when idle; the main loop while playing
 139        has its own synchronization and is CPU friendly, too */
 140
 141     if (game_status == GAME_MODE_PLAYING)
 142       HandleGameActions();
 143     else
 144     {
 145       SyncDisplay();
 146       if (!PendingEvent())      /* delay only if no pending events */
 147         Delay(10);
 148     }
 149
 150     /* refresh window contents from drawing buffer, if needed */
 151     BackToFront();
 152
 153     if (game_status == GAME_MODE_QUIT)
 154       return;
 155   }
 156 }
 157
 158 void HandleOtherEvents(Event *event)
 159 {
 160   switch(event->type)
 161   {
 162     case EVENT_EXPOSE:
 163       HandleExposeEvent((ExposeEvent *) event);
 164       break;
 165
 166     case EVENT_UNMAPNOTIFY:
 167 #if 0
 168       /* This causes the game to stop not only when iconified, but also
 169          when on another virtual desktop, which might be not desired. */
 170       SleepWhileUnmapped();
 171 #endif
 172       break;
 173
 174     case EVENT_FOCUSIN:
 175     case EVENT_FOCUSOUT:
 176       HandleFocusEvent((FocusChangeEvent *) event);
 177       break;
 178
 179     case EVENT_CLIENTMESSAGE:
 180       HandleClientMessageEvent((ClientMessageEvent *) event);
 181       break;
 182
 183 #if defined(TARGET_SDL)
 184     case SDL_JOYAXISMOTION:
 185     case SDL_JOYBUTTONDOWN:
 186     case SDL_JOYBUTTONUP:
 187       HandleJoystickEvent(event);
 188       break;
 189 #endif
 190
 191     default:
 192       break;
 193   }
 194 }
 195
 196 void ClearEventQueue()
 197 {
 198   while (PendingEvent())
 199   {
 200     Event event;
 201
 202     NextEvent(&event);
 203
 204     switch(event.type)
 205     {
 206       case EVENT_BUTTONRELEASE:
 207         button_status = MB_RELEASED;
 208         break;
 209
 210       case EVENT_KEYRELEASE:
 211         key_joystick_mapping = 0;
 212         break;
 213
 214       default:
 215         HandleOtherEvents(&event);
 216         break;
 217     }
 218   }
 219 }
 220
 221 void ClearPlayerAction()
 222 {
 223   int i;
 224
 225   /* simulate key release events for still pressed keys */
 226   key_joystick_mapping = 0;
 227   for (i=0; i<MAX_PLAYERS; i++)
 228     stored_player[i].action = 0;
 229 }
 230
 231 void SleepWhileUnmapped()
 232 {
 233   boolean window_unmapped = TRUE;
 234
 235   KeyboardAutoRepeatOn();
 236
 237   while(window_unmapped)
 238   {
 239     Event event;
 240
 241     NextEvent(&event);
 242
 243     switch(event.type)
 244     {
 245       case EVENT_BUTTONRELEASE:
 246         button_status = MB_RELEASED;
 247         break;
 248
 249       case EVENT_KEYRELEASE:
 250         key_joystick_mapping = 0;
 251         break;
 252
 253       case EVENT_MAPNOTIFY:
 254         window_unmapped = FALSE;
 255         break;
 256
 257       case EVENT_UNMAPNOTIFY:
 258         /* this is only to surely prevent the 'should not happen' case
 259          * of recursively looping between 'SleepWhileUnmapped()' and
 260          * 'HandleOtherEvents()' which usually calls this funtion.
 261          */
 262         break;
 263
 264       default:
 265         HandleOtherEvents(&event);
 266         break;
 267     }
 268   }
 269
 270   if (game_status == GAME_MODE_PLAYING)
 271     KeyboardAutoRepeatOffUnlessAutoplay();
 272 }
 273
 274 void HandleExposeEvent(ExposeEvent *event)
 275 {
 276 #ifndef TARGET_SDL
 277   RedrawPlayfield(FALSE, event->x, event->y, event->width, event->height);
 278   FlushDisplay();
 279 #endif
 280 }
 281
 282 void HandleButtonEvent(ButtonEvent *event)
 283 {
 284   motion_status = FALSE;
 285
 286   if (event->type == EVENT_BUTTONPRESS)
 287     button_status = event->button;
 288   else
 289     button_status = MB_RELEASED;
 290
 291   HandleButton(event->x, event->y, button_status);
 292 }
 293
 294 void HandleMotionEvent(MotionEvent *event)
 295 {
 296   if (!PointerInWindow(window))
 297     return;     /* window and pointer are on different screens */
 298
 299 #if 1
 300   if (button_status == MB_RELEASED && game_status != GAME_MODE_EDITOR)
 301     return;
 302 #endif
 303
 304   motion_status = TRUE;
 305
 306   HandleButton(event->x, event->y, button_status);
 307 }
 308
 309 void HandleKeyEvent(KeyEvent *event)
 310 {
 311   int key_status = (event->type==EVENT_KEYPRESS ? KEY_PRESSED : KEY_RELEASED);
 312   boolean with_modifiers = (game_status == GAME_MODE_PLAYING ? FALSE : TRUE);
 313   Key key = GetEventKey(event, with_modifiers);
 314
 315   HandleKey(key, key_status);
 316 }
 317
 318 void HandleFocusEvent(FocusChangeEvent *event)
 319 {
 320   static int old_joystick_status = -1;
 321
 322   if (event->type == EVENT_FOCUSOUT)
 323   {
 324     KeyboardAutoRepeatOn();
 325     old_joystick_status = joystick.status;
 326     joystick.status = JOYSTICK_NOT_AVAILABLE;
 327
 328     ClearPlayerAction();
 329   }
 330   else if (event->type == EVENT_FOCUSIN)
 331   {
 332     /* When there are two Rocks'n'Diamonds windows which overlap and
 333        the player moves the pointer from one game window to the other,
 334        a 'FocusOut' event is generated for the window the pointer is
 335        leaving and a 'FocusIn' event is generated for the window the
 336        pointer is entering. In some cases, it can happen that the
 337        'FocusIn' event is handled by the one game process before the
 338        'FocusOut' event by the other game process. In this case the
 339        X11 environment would end up with activated keyboard auto repeat,
 340        because unfortunately this is a global setting and not (which
 341        would be far better) set for each X11 window individually.
 342        The effect would be keyboard auto repeat while playing the game
 343        (game_status == GAME_MODE_PLAYING), which is not desired.
 344        To avoid this special case, we just wait 1/10 second before
 345        processing the 'FocusIn' event.
 346     */
 347
 348     if (game_status == GAME_MODE_PLAYING)
 349     {
 350       Delay(100);
 351       KeyboardAutoRepeatOffUnlessAutoplay();
 352     }
 353     if (old_joystick_status != -1)
 354       joystick.status = old_joystick_status;
 355   }
 356 }
 357
 358 void HandleClientMessageEvent(ClientMessageEvent *event)
 359 {
 360   if (CheckCloseWindowEvent(event))
 361     CloseAllAndExit(0);
 362 }
 363
 364 void HandleButton(int mx, int my, int button)
 365 {
 366   static int old_mx = 0, old_my = 0;
 367
 368   if (button < 0)
 369   {
 370     mx = old_mx;
 371     my = old_my;
 372     button = -button;
 373   }
 374   else
 375   {
 376     old_mx = mx;
 377     old_my = my;
 378   }
 379
 380   HandleGadgets(mx, my, button);
 381
 382   switch(game_status)
 383   {
 384     case GAME_MODE_MAIN:
 385       HandleMainMenu(mx,my, 0,0, button);
 386       break;
 387
 388     case GAME_MODE_PSEUDO_TYPENAME:
 389       HandleTypeName(0, KSYM_Return);
 390       break;
 391
 392     case GAME_MODE_LEVELS:
 393       HandleChooseLevel(mx,my, 0,0, button);
 394       break;
 395
 396     case GAME_MODE_SCORES:
 397       HandleHallOfFame(0,0, 0,0, button);
 398       break;
 399
 400     case GAME_MODE_EDITOR:
 401       break;
 402
 403     case GAME_MODE_INFO:
 404       HandleHelpScreen(button);
 405       break;
 406
 407     case GAME_MODE_SETUP:
 408       HandleSetupScreen(mx,my, 0,0, button);
 409       break;
 410
 411     case GAME_MODE_PLAYING:
 412 #ifdef DEBUG
 413       if (button == MB_RELEASED)
 414       {
 415         int sx = (mx - SX) / TILEX;
 416         int sy = (my - SY) / TILEY;
 417
 418         if (IN_VIS_FIELD(sx,sy))
 419         {
 420           int x = LEVELX(sx);
 421           int y = LEVELY(sy);
 422
 423           printf("INFO: SCREEN(%d, %d), LEVEL(%d, %d)\n", sx, sy, x, y);
 424
 425           if (!IN_LEV_FIELD(x, y))
 426             break;
 427
 428           printf("      Feld[%d][%d] == %d\n", x,y, Feld[x][y]);
 429           printf("      Store[%d][%d] == %d\n", x,y, Store[x][y]);
 430           printf("      Store2[%d][%d] == %d\n", x,y, Store2[x][y]);
 431           printf("      StorePlayer[%d][%d] == %d\n", x,y, StorePlayer[x][y]);
 432           printf("      MovPos[%d][%d] == %d\n", x,y, MovPos[x][y]);
 433           printf("      MovDir[%d][%d] == %d\n", x,y, MovDir[x][y]);
 434           printf("      MovDelay[%d][%d] == %d\n", x,y, MovDelay[x][y]);
 435           printf("      GfxElement[%d][%d] == %d\n", x,y, GfxElement[x][y]);
 436           printf("\n");
 437         }
 438       }
 439 #endif
 440       break;
 441
 442     default:
 443       break;
 444   }
 445 }
 446
 447 void HandleKey(Key key, int key_status)
 448 {
 449   int joy = 0;
 450   boolean anyTextGadgetActiveOrJustFinished = anyTextGadgetActive();
 451   static struct SetupKeyboardInfo custom_key;
 452   static struct
 453   {
 454     Key *key_custom;
 455     Key key_default;
 456     byte action;
 457   } key_info[] =
 458   {
 459     { &custom_key.left,  DEFAULT_KEY_LEFT,  JOY_LEFT     },
 460     { &custom_key.right, DEFAULT_KEY_RIGHT, JOY_RIGHT    },
 461     { &custom_key.up,    DEFAULT_KEY_UP,    JOY_UP       },
 462     { &custom_key.down,  DEFAULT_KEY_DOWN,  JOY_DOWN     },
 463     { &custom_key.snap,  DEFAULT_KEY_SNAP,  JOY_BUTTON_1 },
 464     { &custom_key.bomb,  DEFAULT_KEY_BOMB,  JOY_BUTTON_2 }
 465   };
 466
 467   if (game_status == GAME_MODE_PLAYING)
 468   {
 469     /* only needed for single-step tape recording mode */
 470     static boolean clear_button_2[MAX_PLAYERS] = { FALSE,FALSE,FALSE,FALSE };
 471     static boolean bomb_placed[MAX_PLAYERS] = { FALSE,FALSE,FALSE,FALSE };
 472     int pnr;
 473
 474     for (pnr=0; pnr<MAX_PLAYERS; pnr++)
 475     {
 476       int i;
 477       byte key_action = 0;
 478
 479       if (setup.input[pnr].use_joystick)
 480         continue;
 481
 482       custom_key = setup.input[pnr].key;
 483
 484       for (i=0; i<6; i++)
 485         if (key == *key_info[i].key_custom)
 486           key_action |= key_info[i].action;
 487
 488       if (tape.single_step && clear_button_2[pnr])
 489       {
 490         stored_player[pnr].action &= ~KEY_BUTTON_2;
 491         clear_button_2[pnr] = FALSE;
 492       }
 493
 494       if (key_status == KEY_PRESSED)
 495         stored_player[pnr].action |= key_action;
 496       else
 497         stored_player[pnr].action &= ~key_action;
 498
 499       if (tape.single_step && tape.recording && tape.pausing)
 500       {
 501         if (key_status == KEY_PRESSED &&
 502             (key_action & (KEY_MOTION | KEY_BUTTON_1)))
 503         {
 504           TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
 505
 506           if (key_action & KEY_MOTION)
 507           {
 508             if (stored_player[pnr].action & KEY_BUTTON_2)
 509               bomb_placed[pnr] = TRUE;
 510           }
 511         }
 512         else if (key_status == KEY_RELEASED &&
 513                  (key_action & KEY_BUTTON_2))
 514         {
 515           if (!bomb_placed[pnr])
 516           {
 517             TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
 518
 519             stored_player[pnr].action |= KEY_BUTTON_2;
 520             clear_button_2[pnr] = TRUE;
 521           }
 522
 523           bomb_placed[pnr] = FALSE;
 524         }
 525       }
 526       else if (tape.recording && tape.pausing && (key_action & KEY_ACTION))
 527         TapeTogglePause(TAPE_TOGGLE_MANUAL);
 528     }
 529   }
 530   else
 531   {
 532     int i;
 533
 534     for (i=0; i<6; i++)
 535       if (key == key_info[i].key_default)
 536         joy |= key_info[i].action;
 537   }
 538
 539   if (joy)
 540   {
 541     if (key_status == KEY_PRESSED)
 542       key_joystick_mapping |= joy;
 543     else
 544       key_joystick_mapping &= ~joy;
 545
 546     HandleJoystick();
 547   }
 548
 549   if (game_status != GAME_MODE_PLAYING)
 550     key_joystick_mapping = 0;
 551
 552   if (key_status == KEY_RELEASED)
 553     return;
 554
 555   if ((key == KSYM_Return || key == setup.shortcut.toggle_pause) &&
 556       game_status == GAME_MODE_PLAYING && AllPlayersGone)
 557   {
 558     CloseDoor(DOOR_CLOSE_1);
 559     game_status = GAME_MODE_MAIN;
 560     DrawMainMenu();
 561     return;
 562   }
 563
 564   /* allow quick escape to the main menu with the Escape key */
 565   if (key == KSYM_Escape &&
 566       game_status != GAME_MODE_MAIN &&
 567       game_status != GAME_MODE_PLAYING &&
 568       game_status != GAME_MODE_EDITOR &&
 569       game_status != GAME_MODE_LEVELS &&
 570       game_status != GAME_MODE_SETUP)
 571   {
 572     game_status = GAME_MODE_MAIN;
 573     DrawMainMenu();
 574     return;
 575   }
 576
 577   /* special key shortcuts */
 578   if (game_status == GAME_MODE_MAIN || game_status == GAME_MODE_PLAYING)
 579   {
 580     if (key == setup.shortcut.save_game)
 581       TapeQuickSave();
 582     else if (key == setup.shortcut.load_game)
 583       TapeQuickLoad();
 584     else if (key == setup.shortcut.toggle_pause)
 585       TapeTogglePause(TAPE_TOGGLE_MANUAL);
 586   }
 587
 588 #if 0
 589 #ifndef DEBUG
 590
 591   if (game_status == GAME_MODE_PLAYING && (tape.playing || tape.pausing))
 592     return;
 593
 594 #endif
 595 #endif
 596
 597
 598   HandleGadgetsKeyInput(key);
 599
 600   switch(game_status)
 601   {
 602     case GAME_MODE_PSEUDO_TYPENAME:
 603       HandleTypeName(0, key);
 604       break;
 605
 606     case GAME_MODE_MAIN:
 607     case GAME_MODE_LEVELS:
 608     case GAME_MODE_SETUP:
 609       switch(key)
 610       {
 611         case KSYM_Return:
 612           if (game_status == GAME_MODE_MAIN)
 613             HandleMainMenu(0,0, 0,0, MB_MENU_CHOICE);
 614           else if (game_status == GAME_MODE_LEVELS)
 615             HandleChooseLevel(0,0, 0,0, MB_MENU_CHOICE);
 616           else if (game_status == GAME_MODE_SETUP)
 617             HandleSetupScreen(0,0, 0,0, MB_MENU_CHOICE);
 618           break;
 619
 620         case KSYM_Escape:
 621           if (game_status == GAME_MODE_LEVELS)
 622             HandleChooseLevel(0,0, 0,0, MB_MENU_LEAVE);
 623           else if (game_status == GAME_MODE_SETUP)
 624             HandleSetupScreen(0,0, 0,0, MB_MENU_LEAVE);
 625           break;
 626
 627         case KSYM_Page_Up:
 628           if (game_status == GAME_MODE_LEVELS)
 629             HandleChooseLevel(0,0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 630           else if (game_status == GAME_MODE_SETUP)
 631             HandleSetupScreen(0,0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 632           break;
 633
 634         case KSYM_Page_Down:
 635           if (game_status == GAME_MODE_LEVELS)
 636             HandleChooseLevel(0,0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 637           else if (game_status == GAME_MODE_SETUP)
 638             HandleSetupScreen(0,0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 639           break;
 640
 641 #ifdef DEBUG
 642         case KSYM_t:
 643           DumpTape(&tape);
 644           break;
 645 #endif
 646
 647         default:
 648           break;
 649       }
 650       break;
 651
 652     case GAME_MODE_INFO:
 653       HandleHelpScreen(MB_RELEASED);
 654       break;
 655
 656     case GAME_MODE_SCORES:
 657       switch(key)
 658       {
 659         case KSYM_Return:
 660           game_status = GAME_MODE_MAIN;
 661           DrawMainMenu();
 662           BackToFront();
 663           break;
 664
 665         case KSYM_Page_Up:
 666           HandleHallOfFame(0,0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 667           break;
 668
 669         case KSYM_Page_Down:
 670           HandleHallOfFame(0,0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 671           break;
 672
 673         default:
 674           break;
 675       }
 676       break;
 677
 678     case GAME_MODE_EDITOR:
 679       if (!anyTextGadgetActiveOrJustFinished || key == KSYM_Escape)
 680         HandleLevelEditorKeyInput(key);
 681       break;
 682
 683     case GAME_MODE_PLAYING:
 684     {
 685       switch(key)
 686       {
 687         case KSYM_Escape:
 688           RequestQuitGame(setup.ask_on_escape);
 689           break;
 690
 691 #ifdef DEBUG
 692         case KSYM_0:
 693         case KSYM_1:
 694         case KSYM_2:
 695         case KSYM_3:
 696         case KSYM_4:
 697         case KSYM_5:
 698         case KSYM_6:
 699         case KSYM_7:
 700         case KSYM_8:
 701         case KSYM_9:
 702           if (key == KSYM_0)
 703           {
 704             if (GameFrameDelay == 500)
 705               GameFrameDelay = GAME_FRAME_DELAY;
 706             else
 707               GameFrameDelay = 500;
 708           }
 709           else
 710             GameFrameDelay = (key - KSYM_0) * 10;
 711           printf("Game speed == %d%% (%d ms delay between two frames)\n",
 712                  GAME_FRAME_DELAY * 100 / GameFrameDelay, GameFrameDelay);
 713           break;
 714
 715         case KSYM_d:
 716           if (options.debug)
 717           {
 718             options.debug = FALSE;
 719             printf("debug mode disabled\n");
 720           }
 721           else
 722           {
 723             options.debug = TRUE;
 724             printf("debug mode enabled\n");
 725           }
 726           break;
 727
 728         case KSYM_s:
 729           if (!global.fps_slowdown)
 730           {
 731             global.fps_slowdown = TRUE;
 732             global.fps_slowdown_factor = 2;
 733             printf("fps slowdown enabled -- display only every 2nd frame\n");
 734           }
 735           else if (global.fps_slowdown_factor == 2)
 736           {
 737             global.fps_slowdown_factor = 4;
 738             printf("fps slowdown enabled -- display only every 4th frame\n");
 739           }
 740           else
 741           {
 742             global.fps_slowdown = FALSE;
 743             global.fps_slowdown_factor = 1;
 744             printf("fps slowdown disabled\n");
 745           }
 746           break;
 747
 748 #if 0
 749         case KSYM_a:
 750           if (ScrollStepSize == TILEX/8)
 751             ScrollStepSize = TILEX/4;
 752           else
 753             ScrollStepSize = TILEX/8;
 754           printf("ScrollStepSize == %d\n", ScrollStepSize);
 755           break;
 756 #endif
 757
 758 #if 0
 759         case KSYM_m:
 760           if (MoveSpeed == 8)
 761           {
 762             MoveSpeed = 4;
 763             ScrollStepSize = TILEX/4;
 764           }
 765           else
 766           {
 767             MoveSpeed = 8;
 768             ScrollStepSize = TILEX/8;
 769           }
 770           printf("MoveSpeed == %d\n", MoveSpeed);
 771           break;
 772 #endif
 773
 774         case KSYM_f:
 775           ScrollStepSize = TILEX/8;
 776           printf("ScrollStepSize == %d (1/8)\n", ScrollStepSize);
 777           break;
 778
 779         case KSYM_g:
 780           ScrollStepSize = TILEX/4;
 781           printf("ScrollStepSize == %d (1/4)\n", ScrollStepSize);
 782           break;
 783
 784         case KSYM_h:
 785           ScrollStepSize = TILEX/2;
 786           printf("ScrollStepSize == %d (1/2)\n", ScrollStepSize);
 787           break;
 788
 789         case KSYM_l:
 790           ScrollStepSize = TILEX;
 791           printf("ScrollStepSize == %d (1/1)\n", ScrollStepSize);
 792           break;
 793
 794         case KSYM_Q:
 795         case KSYM_q:
 796           local_player->dynamite = 1000;
 797           break;
 798
 799
 800
 801 #if 0
 802
 803         case KSYM_z:
 804           {
 805             int i;
 806
 807             for(i=0; i<MAX_PLAYERS; i++)
 808             {
 809               printf("Player %d:\n", i);
 810               printf("  jx == %d, jy == %d\n",
 811                      stored_player[i].jx, stored_player[i].jy);
 812               printf("  last_jx == %d, last_jy == %d\n",
 813                      stored_player[i].last_jx, stored_player[i].last_jy);
 814             }
 815             printf("\n");
 816           }
 817
 818           break;
 819 #endif
 820 #endif
 821
 822         default:
 823           break;
 824       }
 825       break;
 826     }
 827     default:
 828       break;
 829   }
 830 }
 831
 832 void HandleNoEvent()
 833 {
 834   if (button_status && game_status != GAME_MODE_PLAYING)
 835   {
 836     HandleButton(0, 0, -button_status);
 837     return;
 838   }
 839
 840 #if defined(PLATFORM_UNIX)
 841   if (options.network)
 842     HandleNetworking();
 843 #endif
 844
 845   HandleJoystick();
 846 }
 847
 848 static int HandleJoystickForAllPlayers()
 849 {
 850   int i;
 851   int result = 0;
 852
 853   for (i=0; i<MAX_PLAYERS; i++)
 854   {
 855     byte joy_action = 0;
 856
 857     /*
 858     if (!setup.input[i].use_joystick)
 859       continue;
 860       */
 861
 862     joy_action = Joystick(i);
 863     result |= joy_action;
 864
 865     if (!setup.input[i].use_joystick)
 866       continue;
 867
 868     stored_player[i].action = joy_action;
 869   }
 870
 871   return result;
 872 }
 873
 874 void HandleJoystick()
 875 {
 876   int joystick  = HandleJoystickForAllPlayers();
 877   int keyboard  = key_joystick_mapping;
 878   int joy       = (joystick | keyboard);
 879   int left      = joy & JOY_LEFT;
 880   int right     = joy & JOY_RIGHT;
 881   int up        = joy & JOY_UP;
 882   int down      = joy & JOY_DOWN;
 883   int button    = joy & JOY_BUTTON;
 884   int newbutton = (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED);
 885   int dx        = (left ? -1    : right ? 1     : 0);
 886   int dy        = (up   ? -1    : down  ? 1     : 0);
 887
 888   switch(game_status)
 889   {
 890     case GAME_MODE_MAIN:
 891     case GAME_MODE_LEVELS:
 892     case GAME_MODE_SETUP:
 893     {
 894       static unsigned long joystickmove_delay = 0;
 895
 896       if (joystick && !button &&
 897           !DelayReached(&joystickmove_delay, GADGET_FRAME_DELAY))
 898         newbutton = dx = dy = 0;
 899
 900       if (game_status == GAME_MODE_MAIN)
 901         HandleMainMenu(0,0,dx,dy,newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
 902       else if (game_status == GAME_MODE_LEVELS)
 903         HandleChooseLevel(0,0,dx,dy,newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
 904       else if (game_status == GAME_MODE_SETUP)
 905         HandleSetupScreen(0,0,dx,dy,newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
 906       break;
 907     }
 908
 909     case GAME_MODE_SCORES:
 910       HandleHallOfFame(0,0, dx,dy, !newbutton);
 911       break;
 912
 913     case GAME_MODE_INFO:
 914       HandleHelpScreen(!newbutton);
 915       break;
 916
 917     case GAME_MODE_EDITOR:
 918       HandleLevelEditorIdle();
 919       break;
 920
 921     case GAME_MODE_PLAYING:
 922       if (tape.playing || keyboard)
 923         newbutton = ((joy & JOY_BUTTON) != 0);
 924
 925       if (AllPlayersGone && newbutton)
 926       {
 927         CloseDoor(DOOR_CLOSE_1);
 928         game_status = GAME_MODE_MAIN;
 929         DrawMainMenu();
 930         return;
 931       }
 932
 933       break;
 934
 935     default:
 936       break;
 937   }
 938 }