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     return;
 715   }
 716
 717 #if 1
 718   if (game_status == GAME_MODE_PLAYING &&
 719       local_player->LevelSolved_GameEnd &&
 720       (key == KSYM_Return || key == setup.shortcut.toggle_pause))
 721 #else
 722   if (game_status == GAME_MODE_PLAYING && AllPlayersGone &&
 723       (key == KSYM_Return || key == setup.shortcut.toggle_pause))
 724 #endif
 725   {
 726     GameEnd();
 727
 728     return;
 729   }
 730
 731   if (game_status == GAME_MODE_MAIN &&
 732       (key == setup.shortcut.toggle_pause || key == KSYM_space))
 733   {
 734     StartGameActions(options.network, setup.autorecord, NEW_RANDOMIZE);
 735
 736     return;
 737   }
 738
 739   if (game_status == GAME_MODE_MAIN || game_status == GAME_MODE_PLAYING)
 740   {
 741     if (key == setup.shortcut.save_game)
 742       TapeQuickSave();
 743     else if (key == setup.shortcut.load_game)
 744       TapeQuickLoad();
 745     else if (key == setup.shortcut.toggle_pause)
 746       TapeTogglePause(TAPE_TOGGLE_MANUAL);
 747   }
 748
 749   if (game_status == GAME_MODE_PLAYING && !network_playing)
 750   {
 751     int centered_player_nr_next = -999;
 752
 753     if (key == setup.shortcut.focus_player_all)
 754       centered_player_nr_next = -1;
 755     else
 756       for (i = 0; i < MAX_PLAYERS; i++)
 757         if (key == setup.shortcut.focus_player[i])
 758           centered_player_nr_next = i;
 759
 760     if (centered_player_nr_next != -999)
 761     {
 762       game.centered_player_nr_next = centered_player_nr_next;
 763       game.set_centered_player = TRUE;
 764
 765       if (tape.recording)
 766       {
 767         tape.centered_player_nr_next = game.centered_player_nr_next;
 768         tape.set_centered_player = TRUE;
 769       }
 770     }
 771   }
 772
 773   HandleKeysSpecial(key);
 774
 775   if (HandleGadgetsKeyInput(key))
 776   {
 777     if (key != KSYM_Escape)     /* always allow ESC key to be handled */
 778       key = KSYM_UNDEFINED;
 779   }
 780
 781   switch(game_status)
 782   {
 783     case GAME_MODE_PSEUDO_TYPENAME:
 784       HandleTypeName(0, key);
 785       break;
 786
 787     case GAME_MODE_TITLE:
 788     case GAME_MODE_MAIN:
 789     case GAME_MODE_LEVELS:
 790     case GAME_MODE_SETUP:
 791     case GAME_MODE_INFO:
 792     case GAME_MODE_SCORES:
 793       switch(key)
 794       {
 795         case KSYM_space:
 796         case KSYM_Return:
 797           if (game_status == GAME_MODE_TITLE)
 798             HandleTitleScreen(0, 0, 0, 0, MB_MENU_CHOICE);
 799           else if (game_status == GAME_MODE_MAIN)
 800             HandleMainMenu(0, 0, 0, 0, MB_MENU_CHOICE);
 801           else if (game_status == GAME_MODE_LEVELS)
 802             HandleChooseLevel(0, 0, 0, 0, MB_MENU_CHOICE);
 803           else if (game_status == GAME_MODE_SETUP)
 804             HandleSetupScreen(0, 0, 0, 0, MB_MENU_CHOICE);
 805           else if (game_status == GAME_MODE_INFO)
 806             HandleInfoScreen(0, 0, 0, 0, MB_MENU_CHOICE);
 807           else if (game_status == GAME_MODE_SCORES)
 808             HandleHallOfFame(0, 0, 0, 0, MB_MENU_CHOICE);
 809           break;
 810
 811         case KSYM_Escape:
 812           if (game_status == GAME_MODE_TITLE)
 813             HandleTitleScreen(0, 0, 0, 0, MB_MENU_LEAVE);
 814           else if (game_status == GAME_MODE_LEVELS)
 815             HandleChooseLevel(0, 0, 0, 0, MB_MENU_LEAVE);
 816           else if (game_status == GAME_MODE_SETUP)
 817             HandleSetupScreen(0, 0, 0, 0, MB_MENU_LEAVE);
 818           else if (game_status == GAME_MODE_INFO)
 819             HandleInfoScreen(0, 0, 0, 0, MB_MENU_LEAVE);
 820           else if (game_status == GAME_MODE_SCORES)
 821             HandleHallOfFame(0, 0, 0, 0, MB_MENU_LEAVE);
 822           break;
 823
 824         case KSYM_Page_Up:
 825           if (game_status == GAME_MODE_LEVELS)
 826             HandleChooseLevel(0, 0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 827           else if (game_status == GAME_MODE_SETUP)
 828             HandleSetupScreen(0, 0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 829           else if (game_status == GAME_MODE_INFO)
 830             HandleInfoScreen(0, 0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 831           else if (game_status == GAME_MODE_SCORES)
 832             HandleHallOfFame(0, 0, 0, -1 * SCROLL_PAGE, MB_MENU_MARK);
 833           break;
 834
 835         case KSYM_Page_Down:
 836           if (game_status == GAME_MODE_LEVELS)
 837             HandleChooseLevel(0, 0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 838           else if (game_status == GAME_MODE_SETUP)
 839             HandleSetupScreen(0, 0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 840           else if (game_status == GAME_MODE_INFO)
 841             HandleInfoScreen(0, 0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 842           else if (game_status == GAME_MODE_SCORES)
 843             HandleHallOfFame(0, 0, 0, +1 * SCROLL_PAGE, MB_MENU_MARK);
 844           break;
 845
 846 #ifdef DEBUG
 847         case KSYM_0:
 848           GameFrameDelay = (GameFrameDelay == 500 ? GAME_FRAME_DELAY : 500);
 849           break;
 850 #endif
 851
 852         default:
 853           break;
 854       }
 855       break;
 856
 857     case GAME_MODE_EDITOR:
 858       if (!anyTextGadgetActiveOrJustFinished || key == KSYM_Escape)
 859         HandleLevelEditorKeyInput(key);
 860       break;
 861
 862     case GAME_MODE_PLAYING:
 863     {
 864       switch(key)
 865       {
 866         case KSYM_Escape:
 867           RequestQuitGame(setup.ask_on_escape);
 868           break;
 869
 870 #ifdef DEBUG
 871         case KSYM_0:
 872 #if 0
 873         case KSYM_1:
 874         case KSYM_2:
 875         case KSYM_3:
 876         case KSYM_4:
 877         case KSYM_5:
 878         case KSYM_6:
 879         case KSYM_7:
 880         case KSYM_8:
 881         case KSYM_9:
 882 #endif
 883           if (key == KSYM_0)
 884           {
 885             if (GameFrameDelay == 500)
 886               GameFrameDelay = GAME_FRAME_DELAY;
 887             else
 888               GameFrameDelay = 500;
 889           }
 890           else
 891             GameFrameDelay = (key - KSYM_0) * 10;
 892           printf("Game speed == %d%% (%d ms delay between two frames)\n",
 893                  GAME_FRAME_DELAY * 100 / GameFrameDelay, GameFrameDelay);
 894           break;
 895
 896         case KSYM_d:
 897           if (options.debug)
 898           {
 899             options.debug = FALSE;
 900             printf("debug mode disabled\n");
 901           }
 902           else
 903           {
 904             options.debug = TRUE;
 905             printf("debug mode enabled\n");
 906           }
 907           break;
 908
 909         case KSYM_S:
 910           if (!global.fps_slowdown)
 911           {
 912             global.fps_slowdown = TRUE;
 913             global.fps_slowdown_factor = 2;
 914             printf("fps slowdown enabled -- display only every 2nd frame\n");
 915           }
 916           else if (global.fps_slowdown_factor == 2)
 917           {
 918             global.fps_slowdown_factor = 4;
 919             printf("fps slowdown enabled -- display only every 4th frame\n");
 920           }
 921           else
 922           {
 923             global.fps_slowdown = FALSE;
 924             global.fps_slowdown_factor = 1;
 925             printf("fps slowdown disabled\n");
 926           }
 927           break;
 928
 929         case KSYM_f:
 930           ScrollStepSize = TILEX/8;
 931           printf("ScrollStepSize == %d (1/8)\n", ScrollStepSize);
 932           break;
 933
 934         case KSYM_g:
 935           ScrollStepSize = TILEX/4;
 936           printf("ScrollStepSize == %d (1/4)\n", ScrollStepSize);
 937           break;
 938
 939         case KSYM_h:
 940           ScrollStepSize = TILEX/2;
 941           printf("ScrollStepSize == %d (1/2)\n", ScrollStepSize);
 942           break;
 943
 944         case KSYM_l:
 945           ScrollStepSize = TILEX;
 946           printf("ScrollStepSize == %d (1/1)\n", ScrollStepSize);
 947           break;
 948
 949         case KSYM_v:
 950           printf("::: currently using game engine version %d\n",
 951                  game.engine_version);
 952           break;
 953 #endif
 954
 955         default:
 956           break;
 957       }
 958       break;
 959     }
 960
 961     default:
 962       if (key == KSYM_Escape)
 963       {
 964         game_status = GAME_MODE_MAIN;
 965         DrawMainMenu();
 966
 967         return;
 968       }
 969   }
 970 }
 971
 972 void HandleNoEvent()
 973 {
 974   if (button_status && game_status != GAME_MODE_PLAYING)
 975   {
 976     HandleButton(0, 0, -button_status, button_status);
 977
 978     return;
 979   }
 980
 981 #if defined(NETWORK_AVALIABLE)
 982   if (options.network)
 983     HandleNetworking();
 984 #endif
 985
 986   HandleJoystick();
 987 }
 988
 989 static int HandleJoystickForAllPlayers()
 990 {
 991   int i;
 992   int result = 0;
 993
 994   for (i = 0; i < MAX_PLAYERS; i++)
 995   {
 996     byte joy_action = 0;
 997
 998     /*
 999     if (!setup.input[i].use_joystick)
1000       continue;
1001       */
1002
1003     joy_action = Joystick(i);
1004     result |= joy_action;
1005
1006     if (!setup.input[i].use_joystick)
1007       continue;
1008
1009     stored_player[i].action = joy_action;
1010   }
1011
1012   return result;
1013 }
1014
1015 void HandleJoystick()
1016 {
1017   int joystick  = HandleJoystickForAllPlayers();
1018   int keyboard  = key_joystick_mapping;
1019   int joy       = (joystick | keyboard);
1020   int left      = joy & JOY_LEFT;
1021   int right     = joy & JOY_RIGHT;
1022   int up        = joy & JOY_UP;
1023   int down      = joy & JOY_DOWN;
1024   int button    = joy & JOY_BUTTON;
1025   int newbutton = (AnyJoystickButton() == JOY_BUTTON_NEW_PRESSED);
1026   int dx        = (left ? -1    : right ? 1     : 0);
1027   int dy        = (up   ? -1    : down  ? 1     : 0);
1028
1029   switch(game_status)
1030   {
1031     case GAME_MODE_TITLE:
1032     case GAME_MODE_MAIN:
1033     case GAME_MODE_LEVELS:
1034     case GAME_MODE_SETUP:
1035     case GAME_MODE_INFO:
1036     {
1037       static unsigned long joystickmove_delay = 0;
1038
1039       if (joystick && !button &&
1040           !DelayReached(&joystickmove_delay, GADGET_FRAME_DELAY))
1041         newbutton = dx = dy = 0;
1042
1043       if (game_status == GAME_MODE_TITLE)
1044         HandleTitleScreen(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1045       else if (game_status == GAME_MODE_MAIN)
1046         HandleMainMenu(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1047       else if (game_status == GAME_MODE_LEVELS)
1048         HandleChooseLevel(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1049       else if (game_status == GAME_MODE_SETUP)
1050         HandleSetupScreen(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1051       else if (game_status == GAME_MODE_INFO)
1052         HandleInfoScreen(0,0,dx,dy, newbutton ? MB_MENU_CHOICE : MB_MENU_MARK);
1053       break;
1054     }
1055
1056     case GAME_MODE_SCORES:
1057       HandleHallOfFame(0, 0, dx, dy, !newbutton);
1058       break;
1059
1060     case GAME_MODE_EDITOR:
1061       HandleLevelEditorIdle();
1062       break;
1063
1064     case GAME_MODE_PLAYING:
1065       if (tape.playing || keyboard)
1066         newbutton = ((joy & JOY_BUTTON) != 0);
1067
1068 #if 1
1069       if (local_player->LevelSolved_GameEnd && newbutton)
1070 #else
1071       if (AllPlayersGone && newbutton)
1072 #endif
1073       {
1074         GameEnd();
1075
1076         return;
1077       }
1078
1079       break;
1080
1081     default:
1082       break;
1083   }
1084 }