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