src/events.c

   1 /***********************************************************
   2 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
   3 *----------------------------------------------------------*
   4 * (c) 1995-2006 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
  27 #define DEBUG_EVENTS            0
  28
  29
  30 static boolean cursor_inside_playfield = FALSE;
  31 static boolean playfield_cursor_set = FALSE;
  32 static unsigned long playfield_cursor_delay = 0;
  33
  34
  35 /* event filter especially needed for SDL event filtering due to
  36    delay problems with lots of mouse motion events when mouse button
  37    not pressed (X11 can handle this with 'PointerMotionHintMask') */
  38
  39 int FilterMouseMotionEvents(const Event *event)
  40 {
  41   MotionEvent *motion;
  42
  43   /* non-motion events are directly passed to event handler functions */
  44   if (event->type != EVENT_MOTIONNOTIFY)
  45     return 1;
  46
  47   motion = (MotionEvent *)event;
  48   cursor_inside_playfield = (motion->x >= SX && motion->x < SX + SXSIZE &&
  49                              motion->y >= SY && motion->y < SY + SYSIZE);
  50
  51   if (game_status == GAME_MODE_PLAYING && playfield_cursor_set)
  52   {
  53     SetMouseCursor(CURSOR_DEFAULT);
  54     playfield_cursor_set = FALSE;
  55     DelayReached(&playfield_cursor_delay, 0);
  56   }
  57
  58   /* skip mouse motion events without pressed button outside level editor */
  59   if (button_status == MB_RELEASED &&
  60       game_status != GAME_MODE_EDITOR && game_status != GAME_MODE_PLAYING)
  61     return 0;
  62   else
  63     return 1;
  64 }
  65
  66 /* to prevent delay problems, skip mouse motion events if the very next
  67    event is also a mouse motion event (and therefore effectively only
  68    handling the last of a row of mouse motion events in the event queue) */
  69
  70 boolean SkipPressedMouseMotionEvent(const Event *event)
  71 {
  72   /* nothing to do if the current event is not a mouse motion event */
  73   if (event->type != EVENT_MOTIONNOTIFY)
  74     return FALSE;
  75
  76   /* only skip motion events with pressed button outside level editor */
  77   if (button_status == MB_RELEASED ||
  78       game_status == GAME_MODE_EDITOR || game_status == GAME_MODE_PLAYING)
  79     return FALSE;
  80
  81   if (PendingEvent())
  82   {
  83     Event next_event;
  84
  85     PeekEvent(&next_event);
  86
  87     /* if next event is also a mouse motion event, skip the current one */
  88     if (next_event.type == EVENT_MOTIONNOTIFY)
  89       return TRUE;
  90   }
  91
  92   return FALSE;
  93 }
  94
  95 /* this is only really needed for non-SDL targets to filter unwanted events;
  96    when using SDL with properly installed event filter, this function can be
  97    replaced with a simple "NextEvent()" call, but it doesn't hurt either */
  98
  99 static boolean NextValidEvent(Event *event)
 100 {
 101   while (PendingEvent())
 102   {
 103     boolean handle_this_event = FALSE;
 104
 105     NextEvent(event);
 106
 107     if (FilterMouseMotionEvents(event))
 108       handle_this_event = TRUE;
 109
 110     if (SkipPressedMouseMotionEvent(event))
 111       handle_this_event = FALSE;
 112
 113     if (handle_this_event)
 114       return TRUE;
 115   }
 116
 117   return FALSE;
 118 }
 119
 120 void EventLoop(void)
 121 {
 122   while (1)
 123   {
 124     if (PendingEvent())         /* got event */
 125     {
 126       Event event;
 127
 128       while (NextValidEvent(&event))
 129       {
 130         switch(event.type)
 131         {
 132           case EVENT_BUTTONPRESS:
 133           case EVENT_BUTTONRELEASE:
 134             HandleButtonEvent((ButtonEvent *) &event);
 135             break;
 136
 137           case EVENT_MOTIONNOTIFY:
 138             HandleMotionEvent((MotionEvent *) &event);
 139             break;
 140
 141           case EVENT_KEYPRESS:
 142           case EVENT_KEYRELEASE:
 143             HandleKeyEvent((KeyEvent *) &event);
 144             break;
 145
 146           default:
 147             HandleOtherEvents(&event);
 148             break;
 149         }
 150       }
 151     }
 152     else
 153     {
 154       /* when playing, display a special mouse pointer inside the playfield */
 155       if (game_status == GAME_MODE_PLAYING && !tape.pausing)
 156       {
 157         if (!playfield_cursor_set && cursor_inside_playfield &&
 158             DelayReached(&playfield_cursor_delay, 1000))
 159         {
 160           SetMouseCursor(CURSOR_PLAYFIELD);
 161           playfield_cursor_set = TRUE;
 162         }
 163       }
 164       else if (playfield_cursor_set)
 165       {
 166         SetMouseCursor(CURSOR_DEFAULT);
 167         playfield_cursor_set = FALSE;
 168       }
 169
 170       HandleNoEvent();
 171     }
 172
 173     /* don't use all CPU time when idle; the main loop while playing
 174        has its own synchronization and is CPU friendly, too */
 175
 176     if (game_status == GAME_MODE_PLAYING)
 177     {
 178       HandleGameActions();
 179     }
 180     else
 181     {
 182       SyncDisplay();
 183       if (!PendingEvent())      /* delay only if no pending events */
 184         Delay(10);
 185     }
 186
 187     /* refresh window contents from drawing buffer, if needed */
 188     BackToFront();
 189
 190     if (game_status == GAME_MODE_QUIT)
 191       return;
 192   }
 193 }
 194
 195 void HandleOtherEvents(Event *event)
 196 {
 197   switch(event->type)
 198   {
 199     case EVENT_EXPOSE:
 200       HandleExposeEvent((ExposeEvent *) event);
 201       break;
 202
 203     case EVENT_UNMAPNOTIFY:
 204 #if 0
 205       /* This causes the game to stop not only when iconified, but also
 206          when on another virtual desktop, which might be not desired. */
 207       SleepWhileUnmapped();
 208 #endif
 209       break;
 210
 211     case EVENT_FOCUSIN:
 212     case EVENT_FOCUSOUT:
 213       HandleFocusEvent((FocusChangeEvent *) event);
 214       break;
 215
 216     case EVENT_CLIENTMESSAGE:
 217       HandleClientMessageEvent((ClientMessageEvent *) event);
 218       break;
 219
 220 #if defined(TARGET_SDL)
 221     case SDL_JOYAXISMOTION:
 222     case SDL_JOYBUTTONDOWN:
 223     case SDL_JOYBUTTONUP:
 224       HandleJoystickEvent(event);
 225       break;
 226 #endif
 227
 228     default:
 229       break;
 230   }
 231 }
 232
 233 void ClearEventQueue()
 234 {
 235   while (PendingEvent())
 236   {
 237     Event event;
 238
 239     NextEvent(&event);
 240
 241     switch(event.type)
 242     {
 243       case EVENT_BUTTONRELEASE:
 244         button_status = MB_RELEASED;
 245         break;
 246
 247       case EVENT_KEYRELEASE:
 248 #if 1
 249         ClearPlayerAction();
 250 #else
 251         key_joystick_mapping = 0;
 252 #endif
 253         break;
 254
 255       default:
 256         HandleOtherEvents(&event);
 257         break;
 258     }
 259   }
 260 }
 261
 262 void ClearPlayerAction()
 263 {
 264   int i;
 265
 266   /* simulate key release events for still pressed keys */
 267   key_joystick_mapping = 0;
 268   for (i = 0; i < MAX_PLAYERS; i++)
 269     stored_player[i].action = 0;
 270 }
 271
 272 void SleepWhileUnmapped()
 273 {
 274   boolean window_unmapped = TRUE;
 275
 276   KeyboardAutoRepeatOn();
 277
 278   while (window_unmapped)
 279   {
 280     Event event;
 281
 282     NextEvent(&event);
 283
 284     switch(event.type)
 285     {
 286       case EVENT_BUTTONRELEASE:
 287         button_status = MB_RELEASED;
 288         break;
 289
 290       case EVENT_KEYRELEASE:
 291         key_joystick_mapping = 0;
 292         break;
 293
 294       case EVENT_MAPNOTIFY:
 295         window_unmapped = FALSE;
 296         break;
 297
 298       case EVENT_UNMAPNOTIFY:
 299         /* this is only to surely prevent the 'should not happen' case
 300          * of recursively looping between 'SleepWhileUnmapped()' and
 301          * 'HandleOtherEvents()' which usually calls this funtion.
 302          */
 303         break;
 304
 305       default:
 306         HandleOtherEvents(&event);
 307         break;
 308     }
 309   }
 310
 311   if (game_status == GAME_MODE_PLAYING)
 312     KeyboardAutoRepeatOffUnlessAutoplay();
 313 }
 314
 315 void HandleExposeEvent(ExposeEvent *event)
 316 {
 317 #ifndef TARGET_SDL
 318   RedrawPlayfield(FALSE, event->x, event->y, event->width, event->height);
 319   FlushDisplay();
 320 #endif
 321 }
 322
 323 void HandleButtonEvent(ButtonEvent *event)
 324 {
 325 #if DEBUG_EVENTS
 326   printf("::: BUTTON EVENT: button %d %s\n", event->button,
 327          event->type == EVENT_BUTTONPRESS ? "pressed" : "released");
 328 #endif
 329
 330   motion_status = FALSE;
 331
 332   if (event->type == EVENT_BUTTONPRESS)
 333     button_status = event->button;
 334   else
 335     button_status = MB_RELEASED;
 336
 337   HandleButton(event->x, event->y, button_status, event->button);
 338 }
 339
 340 void HandleMotionEvent(MotionEvent *event)
 341 {
 342   if (!PointerInWindow(window))
 343     return;     /* window and pointer are on different screens */
 344
 345   if (button_status == MB_RELEASED && game_status != GAME_MODE_EDITOR)
 346     return;
 347
 348   motion_status = TRUE;
 349
 350   HandleButton(event->x, event->y, button_status, button_status);
 351 }
 352
 353 void HandleKeyEvent(KeyEvent *event)
 354 {
 355   int key_status = (event->type==EVENT_KEYPRESS ? KEY_PRESSED : KEY_RELEASED);
 356   boolean with_modifiers = (game_status == GAME_MODE_PLAYING ? FALSE : TRUE);
 357   Key key = GetEventKey(event, with_modifiers);
 358   Key keymod = (with_modifiers ? GetEventKey(event, FALSE) : key);
 359
 360 #if DEBUG_EVENTS
 361   printf("::: KEY EVENT: %d %s\n", GetEventKey(event, TRUE),
 362          event->type == EVENT_KEYPRESS ? "pressed" : "released");
 363 #endif
 364
 365   HandleKeyModState(keymod, key_status);
 366   HandleKey(key, key_status);
 367 }
 368
 369 void HandleFocusEvent(FocusChangeEvent *event)
 370 {
 371   static int old_joystick_status = -1;
 372
 373   if (event->type == EVENT_FOCUSOUT)
 374   {
 375     KeyboardAutoRepeatOn();
 376     old_joystick_status = joystick.status;
 377     joystick.status = JOYSTICK_NOT_AVAILABLE;
 378
 379     ClearPlayerAction();
 380   }
 381   else if (event->type == EVENT_FOCUSIN)
 382   {
 383     /* When there are two Rocks'n'Diamonds windows which overlap and
 384        the player moves the pointer from one game window to the other,
 385        a 'FocusOut' event is generated for the window the pointer is
 386        leaving and a 'FocusIn' event is generated for the window the
 387        pointer is entering. In some cases, it can happen that the
 388        'FocusIn' event is handled by the one game process before the
 389        'FocusOut' event by the other game process. In this case the
 390        X11 environment would end up with activated keyboard auto repeat,
 391        because unfortunately this is a global setting and not (which
 392        would be far better) set for each X11 window individually.
 393        The effect would be keyboard auto repeat while playing the game
 394        (game_status == GAME_MODE_PLAYING), which is not desired.
 395        To avoid this special case, we just wait 1/10 second before
 396        processing the 'FocusIn' event.
 397     */
 398
 399     if (game_status == GAME_MODE_PLAYING)
 400     {
 401       Delay(100);
 402       KeyboardAutoRepeatOffUnlessAutoplay();
 403     }
 404
 405     if (old_joystick_status != -1)
 406       joystick.status = old_joystick_status;
 407   }
 408 }
 409
 410 void HandleClientMessageEvent(ClientMessageEvent *event)
 411 {
 412   if (CheckCloseWindowEvent(event))
 413     CloseAllAndExit(0);
 414 }
 415
 416 void HandleButton(int mx, int my, int button, int button_nr)
 417 {
 418   static int old_mx = 0, old_my = 0;
 419
 420   if (button < 0)
 421   {
 422     mx = old_mx;
 423     my = old_my;
 424     button = -button;
 425   }
 426   else
 427   {
 428     old_mx = mx;
 429     old_my = my;
 430   }
 431
 432   if (HandleGadgets(mx, my, button))
 433   {
 434     /* do not handle this button event anymore */
 435     mx = my = -32;      /* force mouse event to be outside screen tiles */
 436   }
 437
 438   /* do not use scroll wheel button events for anything other than gadgets */
 439   if (IS_WHEEL_BUTTON(button_nr))
 440     return;
 441
 442   switch (game_status)
 443   {
 444     case GAME_MODE_TITLE:
 445       HandleTitleScreen(mx, my, 0, 0, button);
 446       break;
 447
 448     case GAME_MODE_MAIN:
 449       HandleMainMenu(mx, my, 0, 0, button);
 450       break;
 451
 452     case GAME_MODE_PSEUDO_TYPENAME:
 453       HandleTypeName(0, KSYM_Return);
 454       break;
 455
 456     case GAME_MODE_LEVELS:
 457       HandleChooseLevel(mx, my, 0, 0, button);
 458       break;
 459
 460     case GAME_MODE_SCORES:
 461       HandleHallOfFame(0, 0, 0, 0, button);
 462       break;
 463
 464     case GAME_MODE_EDITOR:
 465       HandleLevelEditorIdle();
 466       break;
 467
 468     case GAME_MODE_INFO:
 469       HandleInfoScreen(mx, my, 0, 0, button);
 470       break;
 471
 472     case GAME_MODE_SETUP:
 473       HandleSetupScreen(mx, my, 0, 0, button);
 474       break;
 475
 476     case GAME_MODE_PLAYING:
 477 #ifdef DEBUG
 478       if (button == MB_PRESSED && !motion_status && IN_GFX_SCREEN(mx, my))
 479         DumpTile(LEVELX((mx - SX) / TILEX), LEVELY((my - SY) / TILEY));
 480 #endif
 481       break;
 482
 483     default:
 484       break;
 485   }
 486 }
 487
 488 static boolean is_string_suffix(char *string, char *suffix)
 489 {
 490   int string_len = strlen(string);
 491   int suffix_len = strlen(suffix);
 492
 493   if (suffix_len > string_len)
 494     return FALSE;
 495
 496   return (strEqual(&string[string_len - suffix_len], suffix));
 497 }
 498
 499 #define MAX_CHEAT_INPUT_LEN     32
 500
 501 static void HandleKeysSpecial(Key key)
 502 {
 503   static char cheat_input[2 * MAX_CHEAT_INPUT_LEN + 1] = "";
 504   char letter = getCharFromKey(key);
 505   int cheat_input_len = strlen(cheat_input);
 506   int i;
 507
 508   if (letter == 0)
 509     return;
 510
 511   if (cheat_input_len >= 2 * MAX_CHEAT_INPUT_LEN)
 512   {
 513     for (i = 0; i < MAX_CHEAT_INPUT_LEN + 1; i++)
 514       cheat_input[i] = cheat_input[MAX_CHEAT_INPUT_LEN + i];
 515
 516     cheat_input_len = MAX_CHEAT_INPUT_LEN;
 517   }
 518
 519   cheat_input[cheat_input_len++] = letter;
 520   cheat_input[cheat_input_len] = '\0';
 521
 522 #if DEBUG_EVENTS
 523   printf("::: '%s' [%d]\n", cheat_input, cheat_input_len);
 524 #endif
 525
 526   if (game_status == GAME_MODE_MAIN)
 527   {
 528     if (is_string_suffix(cheat_input, ":insert-solution-tape") ||
 529         is_string_suffix(cheat_input, ":ist"))
 530     {
 531       InsertSolutionTape();
 532     }
 533     else if (is_string_suffix(cheat_input, ":reload-graphics") ||
 534              is_string_suffix(cheat_input, ":rg"))
 535     {
 536       ReloadCustomArtwork(1 << ARTWORK_TYPE_GRAPHICS);
 537       DrawMainMenu();
 538     }
 539     else if (is_string_suffix(cheat_input, ":reload-sounds") ||
 540              is_string_suffix(cheat_input, ":rs"))
 541     {
 542       ReloadCustomArtwork(1 << ARTWORK_TYPE_SOUNDS);
 543       DrawMainMenu();
 544     }
 545     else if (is_string_suffix(cheat_input, ":reload-music") ||
 546              is_string_suffix(cheat_input, ":rm"))
 547     {
 548       ReloadCustomArtwork(1 << ARTWORK_TYPE_MUSIC);
 549       DrawMainMenu();
 550     }
 551     else if (is_string_suffix(cheat_input, ":reload-artwork") ||
 552              is_string_suffix(cheat_input, ":ra"))
 553     {
 554       ReloadCustomArtwork(1 << ARTWORK_TYPE_GRAPHICS |
 555                           1 << ARTWORK_TYPE_SOUNDS |
 556                           1 << ARTWORK_TYPE_MUSIC);
 557       DrawMainMenu();
 558     }
 559     else if (is_string_suffix(cheat_input, ":dump-level") ||
 560              is_string_suffix(cheat_input, ":dl"))
 561     {
 562       DumpLevel(&level);
 563     }
 564     else if (is_string_suffix(cheat_input, ":dump-tape") ||
 565              is_string_suffix(cheat_input, ":dt"))
 566     {
 567       DumpTape(&tape);
 568     }
 569   }
 570   else if (game_status == GAME_MODE_PLAYING)
 571   {
 572 #ifdef DEBUG
 573     if (is_string_suffix(cheat_input, ".q"))
 574       DEBUG_SetMaximumDynamite();
 575 #endif
 576   }
 577   else if (game_status == GAME_MODE_EDITOR)
 578   {
 579     if (is_string_suffix(cheat_input, ":dump-brush") ||
 580         is_string_suffix(cheat_input, ":DB"))
 581     {
 582       DumpBrush();
 583     }
 584     else if (is_string_suffix(cheat_input, ":DDB"))
 585     {
 586       DumpBrush_Small();
 587     }
 588   }
 589 }
 590
 591 void HandleKey(Key key, int key_status)
 592 {
 593   boolean anyTextGadgetActiveOrJustFinished = anyTextGadgetActive();
 594   static struct SetupKeyboardInfo custom_key;
 595   static struct
 596   {
 597     Key *key_custom;
 598     Key key_default;
 599     byte action;
 600   } key_info[] =
 601   {
 602     { &custom_key.left,  DEFAULT_KEY_LEFT,  JOY_LEFT     },
 603     { &custom_key.right, DEFAULT_KEY_RIGHT, JOY_RIGHT    },
 604     { &custom_key.up,    DEFAULT_KEY_UP,    JOY_UP       },
 605     { &custom_key.down,  DEFAULT_KEY_DOWN,  JOY_DOWN     },
 606     { &custom_key.snap,  DEFAULT_KEY_SNAP,  JOY_BUTTON_1 },
 607     { &custom_key.drop,  DEFAULT_KEY_DROP,  JOY_BUTTON_2 }
 608   };
 609   int joy = 0;
 610   int i;
 611
 612   if (game_status == GAME_MODE_PLAYING)
 613   {
 614     /* only needed for single-step tape recording mode */
 615     static boolean clear_button_2[MAX_PLAYERS] = { FALSE,FALSE,FALSE,FALSE };
 616     static boolean element_dropped[MAX_PLAYERS] = { FALSE,FALSE,FALSE,FALSE };
 617     int pnr;
 618
 619     for (pnr = 0; pnr < MAX_PLAYERS; pnr++)
 620     {
 621       byte key_action = 0;
 622
 623       if (setup.input[pnr].use_joystick)
 624         continue;
 625
 626       custom_key = setup.input[pnr].key;
 627
 628       for (i = 0; i < 6; i++)
 629         if (key == *key_info[i].key_custom)
 630           key_action |= key_info[i].action;
 631
 632       if (tape.single_step && clear_button_2[pnr])
 633       {
 634         stored_player[pnr].action &= ~KEY_BUTTON_2;
 635         clear_button_2[pnr] = FALSE;
 636       }
 637
 638       if (key_status == KEY_PRESSED)
 639         stored_player[pnr].action |= key_action;
 640       else
 641         stored_player[pnr].action &= ~key_action;
 642
 643       if (tape.single_step && tape.recording && tape.pausing)
 644       {
 645         if (key_status == KEY_PRESSED &&
 646             (key_action & (KEY_MOTION | KEY_BUTTON_1)))
 647         {
 648           TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
 649
 650           if (key_action & KEY_MOTION)
 651           {
 652             if (stored_player[pnr].action & KEY_BUTTON_2)
 653               element_dropped[pnr] = TRUE;
 654           }
 655         }
 656         else if (key_status == KEY_RELEASED &&
 657                  (key_action & KEY_BUTTON_2))
 658         {
 659           if (!element_dropped[pnr])
 660           {
 661             TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
 662
 663             stored_player[pnr].action |= KEY_BUTTON_2;
 664             clear_button_2[pnr] = TRUE;
 665           }
 666
 667           element_dropped[pnr] = FALSE;
 668         }
 669       }
 670 #if 1
 671       else if (tape.recording && tape.pausing)
 672       {
 673         /* prevent key release events from un-pausing a paused game */
 674         if (key_status == KEY_PRESSED &&
 675             (key_action & KEY_ACTION))
 676           TapeTogglePause(TAPE_TOGGLE_MANUAL);
 677       }
 678 #else
 679       else if (tape.recording && tape.pausing && (key_action & KEY_ACTION))
 680         TapeTogglePause(TAPE_TOGGLE_MANUAL);
 681 #endif
 682     }
 683   }
 684   else
 685   {
 686     for (i = 0; i < 6; i++)
 687       if (key == key_info[i].key_default)
 688         joy |= key_info[i].action;
 689   }
 690
 691   if (joy)
 692   {
 693     if (key_status == KEY_PRESSED)
 694       key_joystick_mapping |= joy;
 695     else
 696       key_joystick_mapping &= ~joy;
 697
 698     HandleJoystick();
 699   }
 700
 701   if (game_status != GAME_MODE_PLAYING)
 702     key_joystick_mapping = 0;
 703
 704   if (key_status == KEY_RELEASED)
 705     return;
 706
 707   if ((key == KSYM_Return || key == KSYM_KP_Enter) &&
 708       (GetKeyModState() & KMOD_Alt) && video.fullscreen_available)
 709   {
 710     setup.fullscreen = !setup.fullscreen;
 711
 712     ToggleFullscreenIfNeeded();
 713
 714     if (game_status == GAME_MODE_SETUP)
 715       RedrawSetupScreenAfterFullscreenToggle();
 716
 717     return;
 718   }
 719
 720 #if 1
 721   if (game_status == GAME_MODE_PLAYING &&
 722       local_player->LevelSolved_GameEnd &&
 723       (key == KSYM_Return || key == setup.shortcut.toggle_pause))
 724 #else
 725   if (game_status == GAME_MODE_PLAYING && AllPlayersGone &&
 726       (key == KSYM_Return || key == setup.shortcut.toggle_pause))
 727 #endif
 728   {
 729     GameEnd();
 730
 731     return;
 732   }
 733
 734   if (game_status == GAME_MODE_MAIN &&
 735       (key == setup.shortcut.toggle_pause || key == KSYM_space))
 736   {
 737     StartGameActions(options.network, setup.autorecord, NEW_RANDOMIZE);
 738
 739     return;
 740   }
 741
 742   if (game_status == GAME_MODE_MAIN || game_status == GAME_MODE_PLAYING)
 743   {
 744     if (key == setup.shortcut.save_game)
 745       TapeQuickSave();
 746     else if (key == setup.shortcut.load_game)
 747       TapeQuickLoad();
 748     else if (key == setup.shortcut.toggle_pause)
 749       TapeTogglePause(TAPE_TOGGLE_MANUAL);
 750   }
 751
 752   if (game_status == GAME_MODE_PLAYING && !network_playing)
 753   {
 754     int centered_player_nr_next = -999;
 755
 756     if (key == setup.shortcut.focus_player_all)
 757       centered_player_nr_next = -1;
 758     else
 759       for (i = 0; i < MAX_PLAYERS; i++)
 760         if (key == setup.shortcut.focus_player[i])
 761           centered_player_nr_next = i;
 762
 763     if (centered_player_nr_next != -999)
 764     {
 765       game.centered_player_nr_next = centered_player_nr_next;
 766       game.set_centered_player = TRUE;
 767
 768       if (tape.recording)
 769       {
 770         tape.centered_player_nr_next = game.centered_player_nr_next;
 771         tape.set_centered_player = TRUE;
 772       }
 773     }
 774   }
 775
 776   HandleKeysSpecial(key);
 777
 778   if (HandleGadgetsKeyInput(key))
 779   {
 780     if (key != KSYM_Escape)     /* always allow ESC key to be handled */
 781       key = KSYM_UNDEFINED;
 782   }
 783
 784   switch(game_status)
 785   {
 786     case GAME_MODE_PSEUDO_TYPENAME:
 787       HandleTypeName(0, key);
 788       break;
 789
 790     case GAME_MODE_TITLE:
 791     case GAME_MODE_MAIN:
 792     case GAME_MODE_LEVELS:
 793     case GAME_MODE_SETUP:
 794     case GAME_MODE_INFO:
 795     case GAME_MODE_SCORES:
 796       switch(key)
 797       {
 798         case KSYM_space:
 799         case KSYM_Return:
 800           if (game_status == GAME_MODE_TITLE)
 801             HandleTitleScreen(0, 0, 0, 0, MB_MENU_CHOICE);
 802           else if (game_status == GAME_MODE_MAIN)
 803             HandleMainMenu(0, 0, 0, 0, MB_MENU_CHOICE);
 804           else if (game_status == GAME_MODE_LEVELS)
 805             HandleChooseLevel(0, 0, 0, 0, MB_MENU_CHOICE);
 806           else if (game_status == GAME_MODE_SETUP)
 807             HandleSetupScreen(0, 0, 0, 0, MB_MENU_CHOICE);
 808           else if (game_status == GAME_MODE_INFO)
 809             HandleInfoScreen(0, 0, 0, 0, MB_MENU_CHOICE);
 810           else if (game_status == GAME_MODE_SCORES)
 811             HandleHallOfFame(0, 0, 0, 0, MB_MENU_CHOICE);
 812           break;
 813
 814         case KSYM_Escape:
 815           if (game_status == GAME_MODE_TITLE)
 816             HandleTitleScreen(0, 0, 0, 0, MB_MENU_LEAVE);
 817           else if (game_status == GAME_MODE_LEVELS)
 818             HandleChooseLevel(0, 0, 0, 0, MB_MENU_LEAVE);
 819           else if (game_status == GAME_MODE_SETUP)
 820             HandleSetupScreen(0, 0, 0, 0, MB_MENU_LEAVE);
 821           else if (game_status == GAME_MODE_INFO)
 822             HandleInfoScreen(0, 0, 0, 0, MB_MENU_LEAVE);
 823           else if (game_status == GAME_MODE_SCORES)
 824             HandleHallOfFame(0, 0, 0, 0, MB_MENU_LEAVE);
 825           break;
 826
 827         case KSYM_Page_Up:
 828           if (game_status == GAME_MODE_LEVELS)
 829             HandleChooseLevel(0, 0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 830           else if (game_status == GAME_MODE_SETUP)
 831             HandleSetupScreen(0, 0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 832           else if (game_status == GAME_MODE_INFO)
 833             HandleInfoScreen(0, 0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 834           else if (game_status == GAME_MODE_SCORES)
 835             HandleHallOfFame(0, 0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 836           break;
 837
 838         case KSYM_Page_Down:
 839           if (game_status == GAME_MODE_LEVELS)
 840             HandleChooseLevel(0, 0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 841           else if (game_status == GAME_MODE_SETUP)
 842             HandleSetupScreen(0, 0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 843           else if (game_status == GAME_MODE_INFO)
 844             HandleInfoScreen(0, 0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 845           else if (game_status == GAME_MODE_SCORES)
 846             HandleHallOfFame(0, 0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 847           break;
 848
 849 #ifdef DEBUG
 850         case KSYM_0:
 851           GameFrameDelay = (GameFrameDelay == 500 ? GAME_FRAME_DELAY : 500);
 852           break;
 853 #endif
 854
 855         default:
 856           break;
 857       }
 858       break;
 859
 860     case GAME_MODE_EDITOR:
 861       if (!anyTextGadgetActiveOrJustFinished || key == KSYM_Escape)
 862         HandleLevelEditorKeyInput(key);
 863       break;
 864
 865     case GAME_MODE_PLAYING:
 866     {
 867       switch(key)
 868       {
 869         case KSYM_Escape:
 870           RequestQuitGame(setup.ask_on_escape);
 871           break;
 872
 873 #ifdef DEBUG
 874         case KSYM_0:
 875 #if 0
 876         case KSYM_1:
 877         case KSYM_2:
 878         case KSYM_3:
 879         case KSYM_4:
 880         case KSYM_5:
 881         case KSYM_6:
 882         case KSYM_7:
 883         case KSYM_8:
 884         case KSYM_9:
 885 #endif
 886           if (key == KSYM_0)
 887           {
 888             if (GameFrameDelay == 500)
 889               GameFrameDelay = GAME_FRAME_DELAY;
 890             else
 891               GameFrameDelay = 500;
 892           }
 893           else
 894             GameFrameDelay = (key - KSYM_0) * 10;
 895           printf("Game speed == %d%% (%d ms delay between two frames)\n",
 896                  GAME_FRAME_DELAY * 100 / GameFrameDelay, GameFrameDelay);
 897           break;
 898
 899         case KSYM_d:
 900           if (options.debug)
 901           {
 902             options.debug = FALSE;
 903             printf("debug mode disabled\n");
 904           }
 905           else
 906           {
 907             options.debug = TRUE;
 908             printf("debug mode enabled\n");
 909           }
 910           break;
 911
 912         case KSYM_S:
 913           if (!global.fps_slowdown)
 914           {
 915             global.fps_slowdown = TRUE;
 916             global.fps_slowdown_factor = 2;
 917             printf("fps slowdown enabled -- display only every 2nd frame\n");
 918           }
 919           else if (global.fps_slowdown_factor == 2)
 920           {
 921             global.fps_slowdown_factor = 4;
 922             printf("fps slowdown enabled -- display only every 4th frame\n");
 923           }
 924           else
 925           {
 926             global.fps_slowdown = FALSE;
 927             global.fps_slowdown_factor = 1;
 928             printf("fps slowdown disabled\n");
 929           }
 930           break;
 931
 932         case KSYM_f:
 933           ScrollStepSize = TILEX/8;
 934           printf("ScrollStepSize == %d (1/8)\n", ScrollStepSize);
 935           break;
 936
 937         case KSYM_g:
 938           ScrollStepSize = TILEX/4;
 939           printf("ScrollStepSize == %d (1/4)\n", ScrollStepSize);
 940           break;
 941
 942         case KSYM_h:
 943           ScrollStepSize = TILEX/2;
 944           printf("ScrollStepSize == %d (1/2)\n", ScrollStepSize);
 945           break;
 946
 947         case KSYM_l:
 948           ScrollStepSize = TILEX;
 949           printf("ScrollStepSize == %d (1/1)\n", ScrollStepSize);
 950           break;
 951
 952         case KSYM_v:
 953           printf("::: currently using game engine version %d\n",
 954                  game.engine_version);
 955           break;
 956 #endif
 957
 958         default:
 959           break;
 960       }
 961       break;
 962     }
 963
 964     default:
 965       if (key == KSYM_Escape)
 966       {
 967         game_status = GAME_MODE_MAIN;
 968         DrawMainMenu();
 969
 970         return;
 971       }
 972   }
 973 }
 974
 975 void HandleNoEvent()
 976 {
 977   if (button_status && game_status != GAME_MODE_PLAYING)
 978   {
 979     HandleButton(0, 0, -button_status, button_status);
 980
 981     return;
 982   }
 983
 984 #if defined(NETWORK_AVALIABLE)
 985   if (options.network)
 986     HandleNetworking();
 987 #endif
 988
 989   HandleJoystick();
 990 }
 991
 992 static int HandleJoystickForAllPlayers()
 993 {
 994   int i;
 995   int result = 0;
 996
 997   for (i = 0; i < MAX_PLAYERS; i++)
 998   {
 999     byte joy_action = 0;
1000
1001     /*
1002     if (!setup.input[i].use_joystick)
1003       continue;
1004       */
1005
1006     joy_action = Joystick(i);
1007     result |= joy_action;
1008
1009     if (!setup.input[i].use_joystick)
1010       continue;
1011
1012     stored_player[i].action = joy_action;
1013   }
1014
1015   return result;
1016 }
1017
1018 void HandleJoystick()
1019 {
1020   int joystick  = HandleJoystickForAllPlayers();
1021   int keyboard  = key_joystick_mapping;
1022   int joy       = (joystick | keyboard);
1023   int left      = joy & JOY_LEFT;
1024   int right     = joy & JOY_RIGHT;
1025   int up        = joy & JOY_UP;
1026   int down      = joy & JOY_DOWN;
1027   int button    = joy & JOY_BUTTON;
1028   int newbutton = (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED);
1029   int dx        = (left ? -1    : right ? 1     : 0);
1030   int dy        = (up   ? -1    : down  ? 1     : 0);
1031
1032   switch(game_status)
1033   {
1034     case GAME_MODE_TITLE:
1035     case GAME_MODE_MAIN:
1036     case GAME_MODE_LEVELS:
1037     case GAME_MODE_SETUP:
1038     case GAME_MODE_INFO:
1039     {
1040       static unsigned long joystickmove_delay = 0;
1041
1042       if (joystick && !button &&
1043           !DelayReached(&joystickmove_delay, GADGET_FRAME_DELAY))
1044         newbutton = dx = dy = 0;
1045
1046       if (game_status == GAME_MODE_TITLE)
1047         HandleTitleScreen(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1048       else if (game_status == GAME_MODE_MAIN)
1049         HandleMainMenu(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1050       else if (game_status == GAME_MODE_LEVELS)
1051         HandleChooseLevel(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1052       else if (game_status == GAME_MODE_SETUP)
1053         HandleSetupScreen(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1054       else if (game_status == GAME_MODE_INFO)
1055         HandleInfoScreen(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1056       break;
1057     }
1058
1059     case GAME_MODE_SCORES:
1060       HandleHallOfFame(0, 0, dx, dy, !newbutton);
1061       break;
1062
1063     case GAME_MODE_EDITOR:
1064       HandleLevelEditorIdle();
1065       break;
1066
1067     case GAME_MODE_PLAYING:
1068       if (tape.playing || keyboard)
1069         newbutton = ((joy & JOY_BUTTON) != 0);
1070
1071 #if 1
1072       if (local_player->LevelSolved_GameEnd && newbutton)
1073 #else
1074       if (AllPlayersGone && newbutton)
1075 #endif
1076       {
1077         GameEnd();
1078
1079         return;
1080       }
1081
1082       break;
1083
1084     default:
1085       break;
1086   }
1087 }