src/screens.c

   1 /***********************************************************
   2 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
   3 *----------------------------------------------------------*
   4 * (c) 1995-2001 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * screens.c                                                *
  12 ***********************************************************/
  13
  14 #include "libgame/libgame.h"
  15
  16 #include "screens.h"
  17 #include "events.h"
  18 #include "game.h"
  19 #include "tools.h"
  20 #include "editor.h"
  21 #include "files.h"
  22 #include "tape.h"
  23 #include "cartoons.h"
  24 #include "network.h"
  25 #include "init.h"
  26
  27 /* screens in the setup menu */
  28 #define SETUP_MODE_MAIN                 0
  29 #define SETUP_MODE_INPUT                1
  30 #define SETUP_MODE_SHORTCUT             2
  31 #define SETUP_MODE_GRAPHICS             3
  32 #define SETUP_MODE_SOUND                4
  33 #define SETUP_MODE_CHOOSE_GRAPHICS      5
  34 #define SETUP_MODE_CHOOSE_SOUNDS        6
  35 #define SETUP_MODE_CHOOSE_MUSIC         7
  36
  37 #define MAX_SETUP_MODES                 8
  38
  39 /* for input setup functions */
  40 #define SETUPINPUT_SCREEN_POS_START     0
  41 #define SETUPINPUT_SCREEN_POS_END       (SCR_FIELDY - 4)
  42 #define SETUPINPUT_SCREEN_POS_EMPTY1    (SETUPINPUT_SCREEN_POS_START + 3)
  43 #define SETUPINPUT_SCREEN_POS_EMPTY2    (SETUPINPUT_SCREEN_POS_END - 1)
  44
  45 /* for various menu stuff  */
  46 #define MAX_MENU_ENTRIES_ON_SCREEN      (SCR_FIELDY - 2)
  47 #define MENU_SCREEN_START_YPOS          2
  48 #define MENU_SCREEN_VALUE_XPOS          14
  49
  50 /* buttons and scrollbars identifiers */
  51 #define SCREEN_CTRL_ID_SCROLL_UP        0
  52 #define SCREEN_CTRL_ID_SCROLL_DOWN      1
  53 #define SCREEN_CTRL_ID_SCROLL_VERTICAL  2
  54
  55 #define NUM_SCREEN_SCROLLBUTTONS        2
  56 #define NUM_SCREEN_SCROLLBARS           1
  57 #define NUM_SCREEN_GADGETS              3
  58
  59 /* forward declarations of internal functions */
  60 static void HandleScreenGadgets(struct GadgetInfo *);
  61 static void execExitSetupChooseArtwork(void);
  62 static void HandleSetupScreen_Generic(int, int, int, int, int);
  63 static void HandleSetupScreen_Input(int, int, int, int, int);
  64 static void CustomizeKeyboard(int);
  65 static void CalibrateJoystick(int);
  66 static void HandleChooseTree(int, int, int, int, int, TreeInfo **);
  67
  68 static struct GadgetInfo *screen_gadget[NUM_SCREEN_GADGETS];
  69 static int setup_mode = SETUP_MODE_MAIN;
  70
  71 static void drawCursorExt(int pos, int color, int graphic)
  72 {
  73   static int cursor_array[SCR_FIELDY];
  74
  75   if (graphic)
  76     cursor_array[pos] = graphic;
  77
  78   graphic = cursor_array[pos];
  79
  80   if (color == FC_RED)
  81     graphic = (graphic == GFX_ARROW_BLUE_LEFT  ? GFX_ARROW_RED_LEFT  :
  82                graphic == GFX_ARROW_BLUE_RIGHT ? GFX_ARROW_RED_RIGHT :
  83                GFX_KUGEL_ROT);
  84
  85   DrawGraphic(0, MENU_SCREEN_START_YPOS + pos, graphic);
  86 }
  87
  88 static void initCursor(int pos, int graphic)
  89 {
  90   drawCursorExt(pos, FC_BLUE, graphic);
  91 }
  92
  93 static void drawCursor(int pos, int color)
  94 {
  95   drawCursorExt(pos, color, 0);
  96 }
  97
  98 void DrawHeadline()
  99 {
 100   int x = SX + (SXSIZE - strlen(PROGRAM_TITLE_STRING) * FONT1_XSIZE) / 2;
 101
 102   DrawText(x, SY + 8, PROGRAM_TITLE_STRING, FS_BIG, FC_YELLOW);
 103   DrawTextFCentered(46, FC_RED, WINDOW_SUBTITLE_STRING);
 104 }
 105
 106 static void ToggleFullscreenIfNeeded()
 107 {
 108   if (setup.fullscreen != video.fullscreen_enabled)
 109   {
 110     /* save old door content */
 111     BlitBitmap(backbuffer, pix[PIX_DB_DOOR],
 112                DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
 113
 114     /* toggle fullscreen */
 115     ChangeVideoModeIfNeeded(setup.fullscreen);
 116     setup.fullscreen = video.fullscreen_enabled;
 117
 118     /* redraw background to newly created backbuffer */
 119     BlitBitmap(pix[PIX_BACK], backbuffer, 0,0, WIN_XSIZE,WIN_YSIZE, 0,0);
 120
 121     /* restore old door content */
 122     BlitBitmap(pix[PIX_DB_DOOR], backbuffer,
 123                DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
 124
 125     redraw_mask = REDRAW_ALL;
 126   }
 127 }
 128
 129 void DrawMainMenu()
 130 {
 131   static LevelDirTree *leveldir_last_valid = NULL;
 132   int i;
 133   char *name_text = (!options.network && setup.team_mode ? "Team:" : "Name:");
 134
 135   UnmapAllGadgets();
 136   FadeSounds();
 137   KeyboardAutoRepeatOn();
 138   ActivateJoystickIfAvailable();
 139   SetDrawDeactivationMask(REDRAW_NONE);
 140
 141   /* needed if last screen was the playing screen, invoked from level editor */
 142   if (level_editor_test_game)
 143   {
 144     game_status = LEVELED;
 145     DrawLevelEd();
 146     return;
 147   }
 148
 149   /* needed if last screen was the editor screen */
 150   UndrawSpecialEditorDoor();
 151
 152   /* needed if last screen was the setup screen and fullscreen state changed */
 153   ToggleFullscreenIfNeeded();
 154
 155 #ifdef TARGET_SDL
 156   SetDrawtoField(DRAW_BACKBUFFER);
 157 #endif
 158
 159   /* map gadgets for main menu screen */
 160   MapTapeButtons();
 161
 162   /* leveldir_current may be invalid (level group, parent link) */
 163   if (!validLevelSeries(leveldir_current))
 164     leveldir_current = getFirstValidLevelSeries(leveldir_last_valid);
 165
 166   /* store valid level series information */
 167   leveldir_last_valid = leveldir_current;
 168
 169   /* level_nr may have been set to value over handicap with level editor */
 170   if (setup.handicap && level_nr > leveldir_current->handicap_level)
 171     level_nr = leveldir_current->handicap_level;
 172
 173   GetPlayerConfig();
 174   LoadLevel(level_nr);
 175
 176   ClearWindow();
 177   DrawHeadline();
 178   DrawText(SX + 32,    SY + 2*32, name_text, FS_BIG, FC_GREEN);
 179   DrawText(SX + 6*32,  SY + 2*32, setup.player_name, FS_BIG, FC_RED);
 180   DrawText(SX + 32,    SY + 3*32, "Level:", FS_BIG, FC_GREEN);
 181   DrawText(SX + 11*32, SY + 3*32, int2str(level_nr,3), FS_BIG,
 182            (leveldir_current->readonly ? FC_RED : FC_YELLOW));
 183   DrawText(SX + 32,    SY + 4*32, "Hall Of Fame", FS_BIG, FC_GREEN);
 184   DrawText(SX + 32,    SY + 5*32, "Level Creator", FS_BIG, FC_GREEN);
 185   DrawText(SY + 32,    SY + 6*32, "Info Screen", FS_BIG, FC_GREEN);
 186   DrawText(SX + 32,    SY + 7*32, "Start Game", FS_BIG, FC_GREEN);
 187   DrawText(SX + 32,    SY + 8*32, "Setup", FS_BIG, FC_GREEN);
 188   DrawText(SX + 32,    SY + 9*32, "Quit", FS_BIG, FC_GREEN);
 189
 190   DrawMicroLevel(MICROLEV_XPOS, MICROLEV_YPOS, TRUE);
 191
 192   DrawTextF(7*32 + 6, 3*32 + 9, FC_RED, "%d-%d",
 193             leveldir_current->first_level,
 194             leveldir_current->last_level);
 195
 196   if (leveldir_current->readonly)
 197   {
 198     DrawTextF(15*32 + 6, 3*32 + 9 - 7, FC_RED, "READ");
 199     DrawTextF(15*32 + 6, 3*32 + 9 + 7, FC_RED, "ONLY");
 200   }
 201
 202   for(i=0; i<8; i++)
 203     initCursor(i, (i == 1 || i == 6 ? GFX_ARROW_BLUE_RIGHT : GFX_KUGEL_BLAU));
 204
 205   DrawGraphic(10, 3, GFX_ARROW_BLUE_LEFT);
 206   DrawGraphic(14, 3, GFX_ARROW_BLUE_RIGHT);
 207
 208   DrawText(SX + 56, SY + 326, "A Game by Artsoft Entertainment",
 209            FS_SMALL, FC_RED);
 210
 211   if (leveldir_current->name)
 212   {
 213     int len = strlen(leveldir_current->name);
 214     int lxpos = SX + (SXSIZE - len * FONT4_XSIZE) / 2;
 215     int lypos = SY + 352;
 216
 217     DrawText(lxpos, lypos, leveldir_current->name, FS_SMALL, FC_SPECIAL2);
 218   }
 219
 220   FadeToFront();
 221   InitAnimation();
 222   HandleMainMenu(0,0, 0,0, MB_MENU_INITIALIZE);
 223
 224   TapeStop();
 225   if (TAPE_IS_EMPTY(tape))
 226     LoadTape(level_nr);
 227   DrawCompleteVideoDisplay();
 228
 229   OpenDoor(DOOR_CLOSE_1 | DOOR_OPEN_2);
 230
 231 #if 0
 232   ClearEventQueue();
 233 #endif
 234
 235 }
 236
 237 static void gotoTopLevelDir()
 238 {
 239   /* move upwards to top level directory */
 240   while (leveldir_current->node_parent)
 241   {
 242     /* write a "path" into level tree for easy navigation to last level */
 243     if (leveldir_current->node_parent->node_group->cl_first == -1)
 244     {
 245       int num_leveldirs = numTreeInfoInGroup(leveldir_current);
 246       int leveldir_pos = posTreeInfo(leveldir_current);
 247       int num_page_entries;
 248       int cl_first, cl_cursor;
 249
 250       if (num_leveldirs <= MAX_MENU_ENTRIES_ON_SCREEN)
 251         num_page_entries = num_leveldirs;
 252       else
 253         num_page_entries = MAX_MENU_ENTRIES_ON_SCREEN - 1;
 254
 255       cl_first = MAX(0, leveldir_pos - num_page_entries + 1);
 256       cl_cursor = leveldir_pos - cl_first;
 257
 258       leveldir_current->node_parent->node_group->cl_first = cl_first;
 259       leveldir_current->node_parent->node_group->cl_cursor = cl_cursor;
 260     }
 261
 262     leveldir_current = leveldir_current->node_parent;
 263   }
 264 }
 265
 266 void HandleMainMenu(int mx, int my, int dx, int dy, int button)
 267 {
 268   static int choice = 0;
 269   int x = 0;
 270   int y = choice;
 271
 272   if (button == MB_MENU_INITIALIZE)
 273   {
 274     drawCursor(choice, FC_RED);
 275     return;
 276   }
 277
 278   if (mx || my)         /* mouse input */
 279   {
 280     x = (mx - SX) / 32;
 281     y = (my - SY) / 32 - MENU_SCREEN_START_YPOS;
 282   }
 283   else if (dx || dy)    /* keyboard input */
 284   {
 285     if (dx && choice == 1)
 286       x = (dx < 0 ? 10 : 14);
 287     else if (dy)
 288       y = choice + dy;
 289   }
 290
 291   if (y == 1 && ((x == 10 && level_nr > leveldir_current->first_level) ||
 292                  (x == 14 && level_nr < leveldir_current->last_level)) &&
 293       button)
 294   {
 295     static unsigned long level_delay = 0;
 296     int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
 297     int new_level_nr, old_level_nr = level_nr;
 298     int font_color = (leveldir_current->readonly ? FC_RED : FC_YELLOW);
 299
 300     new_level_nr = level_nr + (x == 10 ? -step : +step);
 301     if (new_level_nr < leveldir_current->first_level)
 302       new_level_nr = leveldir_current->first_level;
 303     if (new_level_nr > leveldir_current->last_level)
 304       new_level_nr = leveldir_current->last_level;
 305
 306     if (setup.handicap && new_level_nr > leveldir_current->handicap_level)
 307       new_level_nr = leveldir_current->handicap_level;
 308
 309     if (old_level_nr == new_level_nr ||
 310         !DelayReached(&level_delay, GADGET_FRAME_DELAY))
 311       goto out;
 312
 313     level_nr = new_level_nr;
 314
 315     DrawTextExt(drawto, SX + 11 * 32, SY + 3 * 32,
 316                 int2str(level_nr, 3), FS_BIG, font_color);
 317     DrawTextExt(window, SX + 11 * 32, SY + 3 * 32,
 318                 int2str(level_nr, 3), FS_BIG, font_color);
 319
 320     LoadLevel(level_nr);
 321     DrawMicroLevel(MICROLEV_XPOS, MICROLEV_YPOS, TRUE);
 322
 323     TapeErase();
 324     LoadTape(level_nr);
 325     DrawCompleteVideoDisplay();
 326
 327     /* needed because DrawMicroLevel() takes some time */
 328     BackToFront();
 329     SyncDisplay();
 330     DelayReached(&level_delay, 0);      /* reset delay counter */
 331   }
 332   else if (x == 0 && y >= 0 && y <= 7)
 333   {
 334     if (button)
 335     {
 336       if (y != choice)
 337       {
 338         drawCursor(y, FC_RED);
 339         drawCursor(choice, FC_BLUE);
 340         choice = y;
 341       }
 342     }
 343     else
 344     {
 345       if (y == 0)
 346       {
 347         game_status = TYPENAME;
 348         HandleTypeName(strlen(setup.player_name), 0);
 349       }
 350       else if (y == 1)
 351       {
 352         if (leveldir_first)
 353         {
 354           game_status = CHOOSELEVEL;
 355           SaveLevelSetup_LastSeries();
 356           SaveLevelSetup_SeriesInfo();
 357
 358           gotoTopLevelDir();
 359
 360           DrawChooseLevel();
 361         }
 362       }
 363       else if (y == 2)
 364       {
 365         game_status = HALLOFFAME;
 366         DrawHallOfFame(-1);
 367       }
 368       else if (y == 3)
 369       {
 370         if (leveldir_current->readonly &&
 371             strcmp(setup.player_name, "Artsoft") != 0)
 372           Request("This level is read only !", REQ_CONFIRM);
 373         game_status = LEVELED;
 374         DrawLevelEd();
 375       }
 376       else if (y == 4)
 377       {
 378         game_status = HELPSCREEN;
 379         DrawHelpScreen();
 380       }
 381       else if (y == 5)
 382       {
 383         if (setup.autorecord)
 384           TapeStartRecording();
 385
 386 #if defined(PLATFORM_UNIX)
 387         if (options.network)
 388           SendToServer_StartPlaying();
 389         else
 390 #endif
 391         {
 392           game_status = PLAYING;
 393           StopAnimation();
 394           InitGame();
 395         }
 396       }
 397       else if (y == 6)
 398       {
 399         game_status = SETUP;
 400         setup_mode = SETUP_MODE_MAIN;
 401         DrawSetupScreen();
 402       }
 403       else if (y == 7)
 404       {
 405         SaveLevelSetup_LastSeries();
 406         SaveLevelSetup_SeriesInfo();
 407         if (Request("Do you really want to quit ?", REQ_ASK | REQ_STAY_CLOSED))
 408           game_status = EXITGAME;
 409       }
 410     }
 411   }
 412
 413   BackToFront();
 414
 415   out:
 416
 417   if (game_status == MAINMENU)
 418   {
 419     DrawMicroLevel(MICROLEV_XPOS, MICROLEV_YPOS, FALSE);
 420     DoAnimation();
 421   }
 422 }
 423
 424
 425 #define MAX_HELPSCREEN_ELS      10
 426 #define HA_NEXT                 -999
 427 #define HA_END                  -1000
 428
 429 static long helpscreen_state;
 430 static int helpscreen_step[MAX_HELPSCREEN_ELS];
 431 static int helpscreen_frame[MAX_HELPSCREEN_ELS];
 432 static int helpscreen_delay[MAX_HELPSCREEN_ELS];
 433 static int helpscreen_action[] =
 434 {
 435   GFX_SPIELER1_DOWN,4,2,
 436   GFX_SPIELER1_UP,4,2,
 437   GFX_SPIELER1_LEFT,4,2,
 438   GFX_SPIELER1_RIGHT,4,2,
 439   GFX_SPIELER1_PUSH_LEFT,4,2,
 440   GFX_SPIELER1_PUSH_RIGHT,4,2,                                  HA_NEXT,
 441   GFX_ERDREICH,1,100,                                           HA_NEXT,
 442   GFX_LEERRAUM,1,100,                                           HA_NEXT,
 443   GFX_MORAST_LEER,1,100,                                        HA_NEXT,
 444   GFX_BETON,1,100,                                              HA_NEXT,
 445   GFX_MAUERWERK,1,100,                                          HA_NEXT,
 446   GFX_MAUER_L1,  3,4, GFX_MAUERWERK,1,20, GFX_LEERRAUM,1,10,
 447   GFX_MAUER_R1,  3,4, GFX_MAUERWERK,1,20, GFX_LEERRAUM,1,10,
 448   GFX_MAUER_UP,  3,4, GFX_MAUERWERK,1,20, GFX_LEERRAUM,1,10,
 449   GFX_MAUER_DOWN,3,4, GFX_MAUERWERK,1,20, GFX_LEERRAUM,1,10,    HA_NEXT,
 450   GFX_UNSICHTBAR,1,100,                                         HA_NEXT,
 451   GFX_FELSBODEN,1,100,                                          HA_NEXT,
 452   GFX_CHAR_A,30,4, GFX_CHAR_AUSRUF,32,4,                        HA_NEXT,
 453   GFX_EDELSTEIN,2,5,                                            HA_NEXT,
 454   GFX_DIAMANT,2,5,                                              HA_NEXT,
 455   GFX_EDELSTEIN_BD,2,5,                                         HA_NEXT,
 456   GFX_EDELSTEIN_GELB,2,5, GFX_EDELSTEIN_ROT,2,5,
 457   GFX_EDELSTEIN_LILA,2,5,                                       HA_NEXT,
 458   GFX_FELSBROCKEN,4,5,                                          HA_NEXT,
 459   GFX_BOMBE,1,50, GFX_EXPLOSION,8,1, GFX_LEERRAUM,1,10,         HA_NEXT,
 460   GFX_KOKOSNUSS,1,50, GFX_CRACKINGNUT,3,1, GFX_EDELSTEIN,1,10,  HA_NEXT,
 461   GFX_ERZ_EDEL,1,50, GFX_EXPLOSION,8,1, GFX_EDELSTEIN,1,10,     HA_NEXT,
 462   GFX_ERZ_DIAM,1,50, GFX_EXPLOSION,8,1, GFX_DIAMANT,1,10,       HA_NEXT,
 463   GFX_ERZ_EDEL_BD,1,50, GFX_EXPLOSION,8,1,GFX_EDELSTEIN_BD,1,10,HA_NEXT,
 464   GFX_ERZ_EDEL_GELB,1,50, GFX_EXPLOSION,8,1,
 465   GFX_EDELSTEIN_GELB,1,10, GFX_ERZ_EDEL_ROT,1,50,
 466   GFX_EXPLOSION,8,1, GFX_EDELSTEIN_ROT,1,10,
 467   GFX_ERZ_EDEL_LILA,1,50, GFX_EXPLOSION,8,1,
 468   GFX_EDELSTEIN_LILA,1,10,                                      HA_NEXT,
 469   GFX_GEBLUBBER,4,4,                                            HA_NEXT,
 470   GFX_SCHLUESSEL1,4,25,                                         HA_NEXT,
 471   GFX_PFORTE1,4,25,                                             HA_NEXT,
 472   GFX_PFORTE1X,4,25,                                            HA_NEXT,
 473   GFX_DYNAMIT_AUS,1,100,                                        HA_NEXT,
 474   GFX_DYNAMIT,7,6, GFX_EXPLOSION,8,1, GFX_LEERRAUM,1,10,        HA_NEXT,
 475   GFX_DYNABOMB+0,4,3, GFX_DYNABOMB+3,1,3, GFX_DYNABOMB+2,1,3,
 476   GFX_DYNABOMB+1,1,3, GFX_DYNABOMB+0,1,3, GFX_EXPLOSION,8,1,
 477   GFX_LEERRAUM,1,10,                                            HA_NEXT,
 478   GFX_DYNABOMB_NR,1,100,                                        HA_NEXT,
 479   GFX_DYNABOMB_SZ,1,100,                                        HA_NEXT,
 480   GFX_FLIEGER+4,1,3, GFX_FLIEGER+0,1,3, GFX_FLIEGER+4,1,3,
 481   GFX_FLIEGER+5,1,3, GFX_FLIEGER+1,1,3, GFX_FLIEGER+5,1,3,
 482   GFX_FLIEGER+6,1,3, GFX_FLIEGER+2,1,3, GFX_FLIEGER+6,1,3,
 483   GFX_FLIEGER+7,1,3, GFX_FLIEGER+3,1,3, GFX_FLIEGER+7,1,3,      HA_NEXT,
 484   GFX_KAEFER+4,1,1, GFX_KAEFER+0,1,1, GFX_KAEFER+4,1,1,
 485   GFX_KAEFER+5,1,1, GFX_KAEFER+1,1,1, GFX_KAEFER+5,1,1,
 486   GFX_KAEFER+6,1,1, GFX_KAEFER+2,1,1, GFX_KAEFER+6,1,1,
 487   GFX_KAEFER+7,1,1, GFX_KAEFER+3,1,1, GFX_KAEFER+7,1,1,         HA_NEXT,
 488   GFX_BUTTERFLY,2,2,                                            HA_NEXT,
 489   GFX_FIREFLY,2,2,                                              HA_NEXT,
 490   GFX_PACMAN+0,1,3, GFX_PACMAN+4,1,2, GFX_PACMAN+0,1,3,
 491   GFX_PACMAN+1,1,3, GFX_PACMAN+5,1,2, GFX_PACMAN+1,1,3,
 492   GFX_PACMAN+2,1,3, GFX_PACMAN+6,1,2, GFX_PACMAN+2,1,3,
 493   GFX_PACMAN+3,1,3, GFX_PACMAN+7,1,2, GFX_PACMAN+3,1,3,         HA_NEXT,
 494   GFX_MAMPFER+0,4,1, GFX_MAMPFER+3,1,1, GFX_MAMPFER+2,1,1,
 495   GFX_MAMPFER+1,1,1, GFX_MAMPFER+0,1,1,                         HA_NEXT,
 496   GFX_MAMPFER2+0,4,1, GFX_MAMPFER2+3,1,1, GFX_MAMPFER2+2,1,1,
 497   GFX_MAMPFER2+1,1,1, GFX_MAMPFER2+0,1,1,                       HA_NEXT,
 498   GFX_ROBOT+0,4,1, GFX_ROBOT+3,1,1, GFX_ROBOT+2,1,1,
 499   GFX_ROBOT+1,1,1, GFX_ROBOT+0,1,1,                             HA_NEXT,
 500   GFX_MOLE_DOWN,4,2,
 501   GFX_MOLE_UP,4,2,
 502   GFX_MOLE_LEFT,4,2,
 503   GFX_MOLE_RIGHT,4,2,                                           HA_NEXT,
 504   GFX_PINGUIN_DOWN,4,2,
 505   GFX_PINGUIN_UP,4,2,
 506   GFX_PINGUIN_LEFT,4,2,
 507   GFX_PINGUIN_RIGHT,4,2,                                        HA_NEXT,
 508   GFX_SCHWEIN_DOWN,4,2,
 509   GFX_SCHWEIN_UP,4,2,
 510   GFX_SCHWEIN_LEFT,4,2,
 511   GFX_SCHWEIN_RIGHT,4,2,                                        HA_NEXT,
 512   GFX_DRACHE_DOWN,4,2,
 513   GFX_DRACHE_UP,4,2,
 514   GFX_DRACHE_LEFT,4,2,
 515   GFX_DRACHE_RIGHT,4,2,                                         HA_NEXT,
 516   GFX_SONDE_START,8,1,                                          HA_NEXT,
 517   GFX_ABLENK,4,1,                                               HA_NEXT,
 518   GFX_BIRNE_AUS,1,25, GFX_BIRNE_EIN,1,25,                       HA_NEXT,
 519   GFX_ZEIT_VOLL,1,25, GFX_ZEIT_LEER,1,25,                       HA_NEXT,
 520   GFX_TROPFEN,1,25, GFX_AMOEBING,4,1, GFX_AMOEBE_LEBT,1,10,     HA_NEXT,
 521   GFX_AMOEBE_TOT+2,2,50, GFX_AMOEBE_TOT,2,50,                   HA_NEXT,
 522   GFX_AMOEBE_LEBT,4,40,                                         HA_NEXT,
 523   GFX_AMOEBE_LEBT,1,10, GFX_AMOEBING,4,2,                       HA_NEXT,
 524   GFX_AMOEBE_LEBT,1,25, GFX_AMOEBE_TOT,1,25, GFX_EXPLOSION,8,1,
 525   GFX_DIAMANT,1,10,                                             HA_NEXT,
 526   GFX_LIFE,1,100,                                               HA_NEXT,
 527   GFX_LIFE_ASYNC,1,100,                                         HA_NEXT,
 528   GFX_MAGIC_WALL_OFF,4,2,                                       HA_NEXT,
 529   GFX_MAGIC_WALL_BD_OFF,4,2,                                    HA_NEXT,
 530   GFX_AUSGANG_ZU,1,100, GFX_AUSGANG_ACT,4,2,
 531   GFX_AUSGANG_AUF+0,4,2, GFX_AUSGANG_AUF+3,1,2,
 532   GFX_AUSGANG_AUF+2,1,2, GFX_AUSGANG_AUF+1,1,2,                 HA_NEXT,
 533   GFX_AUSGANG_AUF+0,4,2, GFX_AUSGANG_AUF+3,1,2,
 534   GFX_AUSGANG_AUF+2,1,2, GFX_AUSGANG_AUF+1,1,2,                 HA_NEXT,
 535   GFX_SOKOBAN_OBJEKT,1,100,                                     HA_NEXT,
 536   GFX_SOKOBAN_FELD_LEER,1,100,                                  HA_NEXT,
 537   GFX_SOKOBAN_FELD_VOLL,1,100,                                  HA_NEXT,
 538   GFX_SPEED_PILL,1,100,                                         HA_NEXT,
 539   HA_END
 540 };
 541 static char *helpscreen_eltext[][2] =
 542 {
 543  {"THE HERO:",                          "(Is _this_ guy good old Rockford?)"},
 544  {"Normal sand:",                       "You can dig through it"},
 545  {"Empty field:",                       "You can walk through it"},
 546  {"Quicksand: You cannot pass it,",     "but rocks can fall though it"},
 547  {"Massive Wall:",                      "Nothing can go through it"},
 548  {"Normal Wall: You can't go through",  "it, but you can bomb it away"},
 549  {"Growing Wall: Grows in several di-", "rections if there is an empty field"},
 550  {"Invisible Wall: Behaves like normal","wall, but is invisible"},
 551  {"Old Wall: Like normal wall, but",    "some things can fall down from it"},
 552  {"Letter Wall: Looks like a letter,",  "behaves like a normal wall"},
 553  {"Emerald: You must collect enough of","them to finish a level"},
 554  {"Diamond: Counts as 3 emeralds, but", "can be destroyed by rocks"},
 555  {"Diamond (BD style): Counts like one","emerald and behaves a bit different"},
 556  {"Colorful Gems:",                     "Seem to behave like Emeralds"},
 557  {"Rock: Smashes several things;",      "Can be moved by the player"},
 558  {"Bomb: You can move it, but be",      "careful when dropping it"},
 559  {"Nut: Throw a rock on it to open it;","Each nut contains an emerald"},
 560  {"Wall with an emerald inside:",       "Bomb the wall away to get it"},
 561  {"Wall with a diamond inside:",        "Bomb the wall away to get it"},
 562  {"Wall with BD style diamond inside:", "Bomb the wall away to get it"},
 563  {"Wall with colorful gem inside:",     "Bomb the wall away to get it"},
 564  {"Acid: Things that fall in are gone", "forever (including our hero)"},
 565  {"Key: Opens the door that has the",   "same color (red/yellow/green/blue)"},
 566  {"Door: Can be opened by the key",     "with the same color"},
 567  {"Door: You have to find out the",     "right color of the key for it"},
 568  {"Dynamite: Collect it and use it to", "destroy walls or kill enemies"},
 569  {"Dynamite: This one explodes after",  "a few seconds"},
 570  {"Dyna Bomb: Explodes in 4 directions","with variable explosion size"},
 571  {"Dyna Bomb: Increases the number of", "dyna bombs available at a time"},
 572  {"Dyna Bomb: Increases the size of",   "explosion of dyna bombs"},
 573  {"Spaceship: Moves at the left side",  "of walls; don't touch it!"},
 574  {"Bug: Moves at the right side",       "of walls; don't touch it!"},
 575  {"Butterfly: Moves at the right side", "of walls; don't touch it!"},
 576  {"Firefly: Moves at the left side",    "of walls; don't touch it!"},
 577  {"Pacman: Eats the amoeba and you,",   "if you're not careful"},
 578  {"Cruncher: Eats diamonds and you,",   "if you're not careful"},
 579  {"Cruncher (BD style):",               "Eats almost everything"},
 580  {"Robot: Tries to kill the player",    ""},
 581  {"The mole: Eats the amoeba and turns","empty space into normal sand"},
 582  {"The penguin: Guide him to the exit,","but keep him away from monsters!"},
 583  {"The Pig: Harmless, but eats all",    "gems it can get"},
 584  {"The Dragon: Breathes fire,",         "especially to some monsters"},
 585  {"Sonde: Follows you everywhere;",     "harmless, but may block your way"},
 586  {"Magic Wheel: Touch it to get rid of","the robots for some seconds"},
 587  {"Light Bulb: All of them must be",    "switched on to finish a level"},
 588  {"Extra Time Orb: Adds some seconds",  "to the time available for the level"},
 589  {"Amoeba Drop: Grows to an amoeba on", "the ground - don't touch it"},
 590  {"Dead Amoeba: Does not grow, but",    "can still kill bugs and spaceships"},
 591  {"Normal Amoeba: Grows through empty", "fields, sand and quicksand"},
 592  {"Dropping Amoeba: This one makes",    "drops that grow to a new amoeba"},
 593  {"Living Amoeba (BD style): Contains", "other element, when surrounded"},
 594  {"Game Of Life: Behaves like the well","known 'Game Of Life' (2333 style)"},
 595  {"Biomaze: A bit like the 'Game Of",   "Life', but builds crazy mazes"},
 596  {"Magic Wall: Changes rocks, emeralds","and diamonds when they pass it"},
 597  {"Magic Wall (BD style):",             "Changes rocks and BD style diamonds"},
 598  {"Exit door: Opens if you have enough","emeralds to finish the level"},
 599  {"Open exit door: Enter here to leave","the level and exit the actual game"},
 600  {"Sokoban element: Object which must", "be pushed to an empty field"},
 601  {"Sokoban element: Empty field where", "a Sokoban object can be placed on"},
 602  {"Sokoban element: Field with object", "which can be pushed away"},
 603  {"Speed pill: Lets the player run",    "twice as fast as normally"},
 604 };
 605 static int num_helpscreen_els = sizeof(helpscreen_eltext)/(2*sizeof(char *));
 606
 607 static char *helpscreen_music[][3] =
 608 {
 609   { "Alchemy",                  "Ian Boddy",            "Drive" },
 610   { "The Chase",                "Propaganda",           "A Secret Wish" },
 611   { "Network 23",               "Tangerine Dream",      "Exit" },
 612   { "Czardasz",                 "Robert Pieculewicz",   "Czardasz" },
 613   { "21st Century Common Man",  "Tangerine Dream",      "Tyger" },
 614   { "Voyager",                  "The Alan Parsons Project","Pyramid" },
 615   { "Twilight Painter",         "Tangerine Dream",      "Heartbreakers" }
 616 };
 617 static int num_helpscreen_music = 7;
 618 static int helpscreen_musicpos;
 619
 620 void DrawHelpScreenElAction(int start)
 621 {
 622   int i = 0, j = 0;
 623   int frame, graphic;
 624   int xstart = SX+16, ystart = SY+64+2*32, ystep = TILEY+4;
 625
 626   while(helpscreen_action[j] != HA_END)
 627   {
 628     if (i>=start+MAX_HELPSCREEN_ELS || i>=num_helpscreen_els)
 629       break;
 630     else if (i<start || helpscreen_delay[i-start])
 631     {
 632       if (i>=start && helpscreen_delay[i-start])
 633         helpscreen_delay[i-start]--;
 634
 635       while(helpscreen_action[j] != HA_NEXT)
 636         j++;
 637       j++;
 638       i++;
 639       continue;
 640     }
 641
 642     j += 3*helpscreen_step[i-start];
 643     graphic = helpscreen_action[j++];
 644
 645     if (helpscreen_frame[i-start])
 646     {
 647       frame = helpscreen_action[j++] - helpscreen_frame[i-start];
 648       helpscreen_frame[i-start]--;
 649     }
 650     else
 651     {
 652       frame = 0;
 653       helpscreen_frame[i-start] = helpscreen_action[j++]-1;
 654     }
 655
 656     helpscreen_delay[i-start] = helpscreen_action[j++] - 1;
 657
 658     if (helpscreen_action[j] == HA_NEXT)
 659     {
 660       if (!helpscreen_frame[i-start])
 661         helpscreen_step[i-start] = 0;
 662     }
 663     else
 664     {
 665       if (!helpscreen_frame[i-start])
 666         helpscreen_step[i-start]++;
 667       while(helpscreen_action[j] != HA_NEXT)
 668         j++;
 669     }
 670     j++;
 671
 672     DrawGraphicExt(drawto, xstart, ystart+(i-start)*ystep, graphic+frame);
 673     i++;
 674   }
 675
 676   for(i=2;i<16;i++)
 677   {
 678     MarkTileDirty(0,i);
 679     MarkTileDirty(1,i);
 680   }
 681 }
 682
 683 void DrawHelpScreenElText(int start)
 684 {
 685   int i;
 686   int xstart = SX + 56, ystart = SY + 65 + 2 * 32, ystep = TILEY + 4;
 687   int ybottom = SYSIZE - 20;
 688
 689   ClearWindow();
 690   DrawHeadline();
 691
 692   DrawTextFCentered(100, FC_GREEN, "The game elements:");
 693
 694   for(i=start; i < start + MAX_HELPSCREEN_ELS && i < num_helpscreen_els; i++)
 695   {
 696     DrawText(xstart,
 697              ystart + (i - start) * ystep + (*helpscreen_eltext[i][1] ? 0 : 8),
 698              helpscreen_eltext[i][0], FS_SMALL, FC_YELLOW);
 699     DrawText(xstart, ystart + (i - start) * ystep + 16,
 700              helpscreen_eltext[i][1], FS_SMALL, FC_YELLOW);
 701   }
 702
 703   DrawTextFCentered(ybottom, FC_BLUE, "Press any key or button for next page");
 704 }
 705
 706 void DrawHelpScreenMusicText(int num)
 707 {
 708   int ystart = 150, ystep = 30;
 709   int ybottom = SYSIZE - 20;
 710
 711   FadeSounds();
 712   ClearWindow();
 713   DrawHeadline();
 714
 715   DrawTextFCentered(100, FC_GREEN, "The game background music loops:");
 716
 717   DrawTextFCentered(ystart + 0 * ystep, FC_YELLOW,
 718                     "Excerpt from");
 719   DrawTextFCentered(ystart + 1 * ystep, FC_RED, "\"%s\"",
 720                     helpscreen_music[num][0]);
 721   DrawTextFCentered(ystart + 2 * ystep, FC_YELLOW,
 722                     "by");
 723   DrawTextFCentered(ystart + 3 * ystep, FC_RED,
 724                     "%s", helpscreen_music[num][1]);
 725   DrawTextFCentered(ystart + 4 * ystep, FC_YELLOW,
 726                     "from the album");
 727   DrawTextFCentered(ystart + 5 * ystep, FC_RED, "\"%s\"",
 728                     helpscreen_music[num][2]);
 729
 730   DrawTextFCentered(ybottom, FC_BLUE, "Press any key or button for next page");
 731
 732 #if 0
 733   PlaySoundLoop(background_loop[num]);
 734 #endif
 735 }
 736
 737 void DrawHelpScreenCreditsText()
 738 {
 739   int ystart = 150, ystep = 30;
 740   int ybottom = SYSIZE - 20;
 741
 742   FadeSounds();
 743   ClearWindow();
 744   DrawHeadline();
 745
 746   DrawTextFCentered(100, FC_GREEN,
 747                     "Credits:");
 748   DrawTextFCentered(ystart + 0 * ystep, FC_YELLOW,
 749                     "DOS port of the game:");
 750   DrawTextFCentered(ystart + 1 * ystep, FC_RED,
 751                     "Guido Schulz");
 752   DrawTextFCentered(ystart + 2 * ystep, FC_YELLOW,
 753                     "Additional toons:");
 754   DrawTextFCentered(ystart + 3 * ystep, FC_RED,
 755                     "Karl Hörnell");
 756   DrawTextFCentered(ystart + 5 * ystep, FC_YELLOW,
 757                     "...and many thanks to all contributors");
 758   DrawTextFCentered(ystart + 6 * ystep, FC_YELLOW,
 759                     "of new levels!");
 760
 761   DrawTextFCentered(ybottom, FC_BLUE, "Press any key or button for next page");
 762 }
 763
 764 void DrawHelpScreenContactText()
 765 {
 766   int ystart = 150, ystep = 30;
 767   int ybottom = SYSIZE - 20;
 768
 769   ClearWindow();
 770   DrawHeadline();
 771
 772   DrawTextFCentered(100, FC_GREEN, "Program information:");
 773
 774   DrawTextFCentered(ystart + 0 * ystep, FC_YELLOW,
 775                     "This game is Freeware!");
 776   DrawTextFCentered(ystart + 1 * ystep, FC_YELLOW,
 777                     "If you like it, send e-mail to:");
 778   DrawTextFCentered(ystart + 2 * ystep, FC_RED,
 779                     "info@artsoft.org");
 780   DrawTextFCentered(ystart + 3 * ystep, FC_YELLOW,
 781                     "or SnailMail to:");
 782   DrawTextFCentered(ystart + 4 * ystep + 0, FC_RED,
 783                     "Holger Schemel");
 784   DrawTextFCentered(ystart + 4 * ystep + 20, FC_RED,
 785                     "Detmolder Strasse 189");
 786   DrawTextFCentered(ystart + 4 * ystep + 40, FC_RED,
 787                     "33604 Bielefeld");
 788   DrawTextFCentered(ystart + 4 * ystep + 60, FC_RED,
 789                     "Germany");
 790
 791   DrawTextFCentered(ystart + 7 * ystep, FC_YELLOW,
 792                     "If you have created new levels,");
 793   DrawTextFCentered(ystart + 8 * ystep, FC_YELLOW,
 794                     "send them to me to include them!");
 795   DrawTextFCentered(ystart + 9 * ystep, FC_YELLOW,
 796                     ":-)");
 797
 798   DrawTextFCentered(ybottom, FC_BLUE, "Press any key or button for main menu");
 799 }
 800
 801 void DrawHelpScreen()
 802 {
 803   int i;
 804
 805   UnmapAllGadgets();
 806   CloseDoor(DOOR_CLOSE_2);
 807
 808   for(i=0;i<MAX_HELPSCREEN_ELS;i++)
 809     helpscreen_step[i] = helpscreen_frame[i] = helpscreen_delay[i] = 0;
 810   helpscreen_musicpos = 0;
 811   helpscreen_state = 0;
 812   DrawHelpScreenElText(0);
 813   DrawHelpScreenElAction(0);
 814
 815   FadeToFront();
 816   InitAnimation();
 817   PlaySoundLoop(SND_RHYTHMLOOP);
 818 }
 819
 820 void HandleHelpScreen(int button)
 821 {
 822   static unsigned long hs_delay = 0;
 823   int num_helpscreen_els_pages =
 824     (num_helpscreen_els + MAX_HELPSCREEN_ELS-1) / MAX_HELPSCREEN_ELS;
 825   int button_released = !button;
 826   int i;
 827
 828   if (button_released)
 829   {
 830     if (helpscreen_state < num_helpscreen_els_pages - 1)
 831     {
 832       for(i=0;i<MAX_HELPSCREEN_ELS;i++)
 833         helpscreen_step[i] = helpscreen_frame[i] = helpscreen_delay[i] = 0;
 834       helpscreen_state++;
 835       DrawHelpScreenElText(helpscreen_state*MAX_HELPSCREEN_ELS);
 836       DrawHelpScreenElAction(helpscreen_state*MAX_HELPSCREEN_ELS);
 837     }
 838     else if (helpscreen_state <
 839              num_helpscreen_els_pages + num_helpscreen_music - 1)
 840     {
 841       helpscreen_state++;
 842       DrawHelpScreenMusicText(helpscreen_state - num_helpscreen_els_pages);
 843     }
 844     else if (helpscreen_state ==
 845              num_helpscreen_els_pages + num_helpscreen_music - 1)
 846     {
 847       helpscreen_state++;
 848       DrawHelpScreenCreditsText();
 849     }
 850     else if (helpscreen_state ==
 851              num_helpscreen_els_pages + num_helpscreen_music)
 852     {
 853       helpscreen_state++;
 854       DrawHelpScreenContactText();
 855     }
 856     else
 857     {
 858       FadeSounds();
 859       DrawMainMenu();
 860       game_status = MAINMENU;
 861     }
 862   }
 863   else
 864   {
 865     if (DelayReached(&hs_delay,GAME_FRAME_DELAY * 2))
 866     {
 867       if (helpscreen_state<num_helpscreen_els_pages)
 868         DrawHelpScreenElAction(helpscreen_state*MAX_HELPSCREEN_ELS);
 869     }
 870     DoAnimation();
 871   }
 872
 873   BackToFront();
 874 }
 875
 876 void HandleTypeName(int newxpos, Key key)
 877 {
 878   static int xpos = 0, ypos = 2;
 879
 880   if (newxpos)
 881   {
 882     xpos = newxpos;
 883     DrawText(SX + 6*32, SY + ypos*32, setup.player_name, FS_BIG, FC_YELLOW);
 884     DrawGraphic(xpos + 6, ypos, GFX_KUGEL_ROT);
 885     return;
 886   }
 887
 888   if (((key >= KSYM_A && key <= KSYM_Z) ||
 889        (key >= KSYM_a && key <= KSYM_z)) &&
 890       xpos < MAX_PLAYER_NAME_LEN)
 891   {
 892     char ascii;
 893
 894     if (key >= KSYM_A && key <= KSYM_Z)
 895       ascii = 'A' + (char)(key - KSYM_A);
 896     else
 897       ascii = 'a' + (char)(key - KSYM_a);
 898
 899     setup.player_name[xpos] = ascii;
 900     setup.player_name[xpos + 1] = 0;
 901     xpos++;
 902     DrawTextExt(drawto, SX + 6*32, SY + ypos*32,
 903                 setup.player_name, FS_BIG, FC_YELLOW);
 904     DrawTextExt(window, SX + 6*32, SY + ypos*32,
 905                 setup.player_name, FS_BIG, FC_YELLOW);
 906     DrawGraphic(xpos + 6, ypos, GFX_KUGEL_ROT);
 907   }
 908   else if ((key == KSYM_Delete || key == KSYM_BackSpace) && xpos > 0)
 909   {
 910     xpos--;
 911     setup.player_name[xpos] = 0;
 912     DrawGraphic(xpos + 6, ypos, GFX_KUGEL_ROT);
 913     DrawGraphic(xpos + 7, ypos, GFX_LEERRAUM);
 914   }
 915   else if (key == KSYM_Return && xpos > 0)
 916   {
 917     DrawText(SX + 6*32, SY + ypos*32, setup.player_name, FS_BIG, FC_RED);
 918     DrawGraphic(xpos + 6, ypos, GFX_LEERRAUM);
 919
 920     SaveSetup();
 921     game_status = MAINMENU;
 922   }
 923
 924   BackToFront();
 925 }
 926
 927 static void DrawChooseTree(TreeInfo **ti_ptr)
 928 {
 929   UnmapAllGadgets();
 930   CloseDoor(DOOR_CLOSE_2);
 931
 932   ClearWindow();
 933   HandleChooseTree(0,0, 0,0, MB_MENU_INITIALIZE, ti_ptr);
 934   MapChooseTreeGadgets(*ti_ptr);
 935
 936   FadeToFront();
 937   InitAnimation();
 938 }
 939
 940 static void AdjustChooseTreeScrollbar(int id, int first_entry, TreeInfo *ti)
 941 {
 942   struct GadgetInfo *gi = screen_gadget[id];
 943   int items_max, items_visible, item_position;
 944
 945   items_max = numTreeInfoInGroup(ti);
 946   items_visible = MAX_MENU_ENTRIES_ON_SCREEN - 1;
 947   item_position = first_entry;
 948
 949   if (item_position > items_max - items_visible)
 950     item_position = items_max - items_visible;
 951
 952   ModifyGadget(gi, GDI_SCROLLBAR_ITEMS_MAX, items_max,
 953                GDI_SCROLLBAR_ITEM_POSITION, item_position, GDI_END);
 954 }
 955
 956 static void drawChooseTreeList(int first_entry, int num_page_entries,
 957                                TreeInfo *ti)
 958 {
 959   int i;
 960   char buffer[SCR_FIELDX * 2];
 961   int max_buffer_len = (SCR_FIELDX - 2) * 2;
 962   int num_entries = numTreeInfoInGroup(ti);
 963   char *title_string = NULL;
 964   int offset = (ti->type == TREE_TYPE_LEVEL_DIR ? 0 : 16);
 965
 966   ClearRectangle(backbuffer, SX, SY, SXSIZE - 32, SYSIZE);
 967   redraw_mask |= REDRAW_FIELD;
 968
 969   title_string =
 970     (ti->type == TREE_TYPE_LEVEL_DIR ? "Level Directories" :
 971      ti->type == TREE_TYPE_GRAPHICS_DIR ? "Custom Graphics" :
 972      ti->type == TREE_TYPE_SOUNDS_DIR ? "Custom Sounds" :
 973      ti->type == TREE_TYPE_MUSIC_DIR ? "Custom Music" : "");
 974
 975   DrawText(SX + offset, SY + offset, title_string, FS_BIG,
 976            (ti->type == TREE_TYPE_LEVEL_DIR ? FC_GREEN : FC_YELLOW));
 977
 978   for(i=0; i<num_page_entries; i++)
 979   {
 980     TreeInfo *node, *node_first;
 981     int entry_pos = first_entry + i;
 982     int ypos = MENU_SCREEN_START_YPOS + i;
 983
 984     node_first = getTreeInfoFirstGroupEntry(ti);
 985     node = getTreeInfoFromPos(node_first, entry_pos);
 986
 987     strncpy(buffer, node->name , max_buffer_len);
 988     buffer[max_buffer_len] = '\0';
 989
 990     DrawText(SX + 32, SY + ypos * 32, buffer, FS_MEDIUM, node->color);
 991
 992     if (node->parent_link)
 993       initCursor(i, GFX_ARROW_BLUE_LEFT);
 994     else if (node->level_group)
 995       initCursor(i, GFX_ARROW_BLUE_RIGHT);
 996     else
 997       initCursor(i, GFX_KUGEL_BLAU);
 998   }
 999
1000   if (first_entry > 0)
1001     DrawGraphic(0, 1, GFX_ARROW_BLUE_UP);
1002
1003   if (first_entry + num_page_entries < num_entries)
1004     DrawGraphic(0, MAX_MENU_ENTRIES_ON_SCREEN + 1, GFX_ARROW_BLUE_DOWN);
1005 }
1006
1007 static void drawChooseTreeInfo(int entry_pos, TreeInfo *ti)
1008 {
1009   TreeInfo *node, *node_first;
1010   int x, last_redraw_mask = redraw_mask;
1011
1012   if (ti->type != TREE_TYPE_LEVEL_DIR)
1013     return;
1014
1015   node_first = getTreeInfoFirstGroupEntry(ti);
1016   node = getTreeInfoFromPos(node_first, entry_pos);
1017
1018   ClearRectangle(drawto, SX + 32, SY + 32, SXSIZE - 64, 32);
1019
1020   if (node->parent_link)
1021     DrawTextFCentered(40, FC_RED, "leave group \"%s\"", node->class_desc);
1022   else if (node->level_group)
1023     DrawTextFCentered(40, FC_RED, "enter group \"%s\"", node->class_desc);
1024   else if (ti->type == TREE_TYPE_LEVEL_DIR)
1025     DrawTextFCentered(40, FC_RED, "%3d levels (%s)",
1026                       node->levels, node->class_desc);
1027
1028   /* let BackToFront() redraw only what is needed */
1029   redraw_mask = last_redraw_mask | REDRAW_TILES;
1030   for (x=0; x<SCR_FIELDX; x++)
1031     MarkTileDirty(x, 1);
1032 }
1033
1034 static void HandleChooseTree(int mx, int my, int dx, int dy, int button,
1035                              TreeInfo **ti_ptr)
1036 {
1037   static unsigned long choose_delay = 0;
1038   TreeInfo *ti = *ti_ptr;
1039   int x = 0;
1040   int y = ti->cl_cursor;
1041   int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
1042   int num_entries = numTreeInfoInGroup(ti);
1043   int num_page_entries;
1044
1045   if (num_entries <= MAX_MENU_ENTRIES_ON_SCREEN)
1046     num_page_entries = num_entries;
1047   else
1048     num_page_entries = MAX_MENU_ENTRIES_ON_SCREEN - 1;
1049
1050   if (button == MB_MENU_INITIALIZE)
1051   {
1052     int entry_pos = posTreeInfo(ti);
1053
1054     if (ti->cl_first == -1)
1055     {
1056       ti->cl_first = MAX(0, entry_pos - num_page_entries + 1);
1057       ti->cl_cursor =
1058         entry_pos - ti->cl_first;
1059     }
1060
1061     if (dx == 999)      /* first entry is set by scrollbar position */
1062       ti->cl_first = dy;
1063     else
1064       AdjustChooseTreeScrollbar(SCREEN_CTRL_ID_SCROLL_VERTICAL,
1065                                 ti->cl_first, ti);
1066
1067     drawChooseTreeList(ti->cl_first, num_page_entries, ti);
1068     drawChooseTreeInfo(ti->cl_first + ti->cl_cursor, ti);
1069     drawCursor(ti->cl_cursor, FC_RED);
1070     return;
1071   }
1072   else if (button == MB_MENU_LEAVE)
1073   {
1074     if (ti->node_parent)
1075     {
1076       *ti_ptr = ti->node_parent;
1077       DrawChooseTree(ti_ptr);
1078     }
1079     else if (game_status == SETUP)
1080     {
1081       execExitSetupChooseArtwork();
1082     }
1083     else
1084     {
1085       game_status = MAINMENU;
1086       DrawMainMenu();
1087     }
1088
1089     return;
1090   }
1091
1092   if (mx || my)         /* mouse input */
1093   {
1094     x = (mx - SX) / 32;
1095     y = (my - SY) / 32 - MENU_SCREEN_START_YPOS;
1096   }
1097   else if (dx || dy)    /* keyboard input */
1098   {
1099     if (dy)
1100       y = ti->cl_cursor + dy;
1101
1102     if (ABS(dy) == SCR_FIELDY)  /* handle KSYM_Page_Up, KSYM_Page_Down */
1103     {
1104       dy = SIGN(dy);
1105       step = num_page_entries - 1;
1106       y = (dy < 0 ? -1 : num_page_entries);
1107     }
1108   }
1109
1110   if (x == 0 && y == -1)
1111   {
1112     if (ti->cl_first > 0 &&
1113         (dy || DelayReached(&choose_delay, GADGET_FRAME_DELAY)))
1114     {
1115       ti->cl_first -= step;
1116       if (ti->cl_first < 0)
1117         ti->cl_first = 0;
1118
1119       drawChooseTreeList(ti->cl_first, num_page_entries, ti);
1120       drawChooseTreeInfo(ti->cl_first + ti->cl_cursor, ti);
1121       drawCursor(ti->cl_cursor, FC_RED);
1122       AdjustChooseTreeScrollbar(SCREEN_CTRL_ID_SCROLL_VERTICAL,
1123                                 ti->cl_first, ti);
1124       return;
1125     }
1126   }
1127   else if (x == 0 && y > num_page_entries - 1)
1128   {
1129     if (ti->cl_first + num_page_entries < num_entries &&
1130         (dy || DelayReached(&choose_delay, GADGET_FRAME_DELAY)))
1131     {
1132       ti->cl_first += step;
1133       if (ti->cl_first + num_page_entries > num_entries)
1134         ti->cl_first = MAX(0, num_entries - num_page_entries);
1135
1136       drawChooseTreeList(ti->cl_first, num_page_entries, ti);
1137       drawChooseTreeInfo(ti->cl_first + ti->cl_cursor, ti);
1138       drawCursor(ti->cl_cursor, FC_RED);
1139       AdjustChooseTreeScrollbar(SCREEN_CTRL_ID_SCROLL_VERTICAL,
1140                                 ti->cl_first, ti);
1141       return;
1142     }
1143   }
1144
1145   if (dx == 1)
1146   {
1147     TreeInfo *node_first, *node_cursor;
1148     int entry_pos = ti->cl_first + y;
1149
1150     node_first = getTreeInfoFirstGroupEntry(ti);
1151     node_cursor = getTreeInfoFromPos(node_first, entry_pos);
1152
1153     if (node_cursor->node_group)
1154     {
1155       node_cursor->cl_first = ti->cl_first;
1156       node_cursor->cl_cursor = ti->cl_cursor;
1157       *ti_ptr = node_cursor->node_group;
1158       DrawChooseTree(ti_ptr);
1159       return;
1160     }
1161   }
1162   else if (dx == -1 && ti->node_parent)
1163   {
1164     *ti_ptr = ti->node_parent;
1165     DrawChooseTree(ti_ptr);
1166     return;
1167   }
1168
1169   if (x == 0 && y >= 0 && y < num_page_entries)
1170   {
1171     if (button)
1172     {
1173       if (y != ti->cl_cursor)
1174       {
1175         drawCursor(y, FC_RED);
1176         drawCursor(ti->cl_cursor, FC_BLUE);
1177         drawChooseTreeInfo(ti->cl_first + y, ti);
1178         ti->cl_cursor = y;
1179       }
1180     }
1181     else
1182     {
1183       TreeInfo *node_first, *node_cursor;
1184       int entry_pos = ti->cl_first + y;
1185
1186       node_first = getTreeInfoFirstGroupEntry(ti);
1187       node_cursor = getTreeInfoFromPos(node_first, entry_pos);
1188
1189       if (node_cursor->node_group)
1190       {
1191         node_cursor->cl_first = ti->cl_first;
1192         node_cursor->cl_cursor = ti->cl_cursor;
1193         *ti_ptr = node_cursor->node_group;
1194         DrawChooseTree(ti_ptr);
1195       }
1196       else if (node_cursor->parent_link)
1197       {
1198         *ti_ptr = node_cursor->node_parent;
1199         DrawChooseTree(ti_ptr);
1200       }
1201       else
1202       {
1203         node_cursor->cl_first = ti->cl_first;
1204         node_cursor->cl_cursor = ti->cl_cursor;
1205         *ti_ptr = node_cursor;
1206
1207         if (ti->type == TREE_TYPE_LEVEL_DIR)
1208         {
1209           LoadLevelSetup_SeriesInfo();
1210
1211           SaveLevelSetup_LastSeries();
1212           SaveLevelSetup_SeriesInfo();
1213           TapeErase();
1214         }
1215
1216         if (game_status == SETUP)
1217         {
1218           execExitSetupChooseArtwork();
1219         }
1220         else
1221         {
1222           game_status = MAINMENU;
1223           DrawMainMenu();
1224         }
1225       }
1226     }
1227   }
1228
1229   BackToFront();
1230
1231   if (game_status == CHOOSELEVEL || game_status == SETUP)
1232     DoAnimation();
1233 }
1234
1235 void DrawChooseLevel()
1236 {
1237   DrawChooseTree(&leveldir_current);
1238 }
1239
1240 void HandleChooseLevel(int mx, int my, int dx, int dy, int button)
1241 {
1242   HandleChooseTree(mx, my, dx, dy, button, &leveldir_current);
1243 }
1244
1245 void DrawHallOfFame(int highlight_position)
1246 {
1247   UnmapAllGadgets();
1248   FadeSounds();
1249   CloseDoor(DOOR_CLOSE_2);
1250
1251   if (highlight_position < 0)
1252     LoadScore(level_nr);
1253
1254   FadeToFront();
1255   InitAnimation();
1256   HandleHallOfFame(highlight_position,0, 0,0, MB_MENU_INITIALIZE);
1257   PlaySound(SND_HALLOFFAME);
1258 }
1259
1260 static void drawHallOfFameList(int first_entry, int highlight_position)
1261 {
1262   int i;
1263
1264   ClearWindow();
1265   DrawText(SX + 80, SY + 8, "Hall Of Fame", FS_BIG, FC_YELLOW);
1266   DrawTextFCentered(46, FC_RED, "HighScores of Level %d", level_nr);
1267
1268   for(i=0; i<MAX_MENU_ENTRIES_ON_SCREEN; i++)
1269   {
1270     int entry = first_entry + i;
1271     int color = (entry == highlight_position ? FC_RED : FC_GREEN);
1272
1273 #if 0
1274     DrawText(SX, SY + 64 + i * 32, ".................", FS_BIG, color);
1275     DrawText(SX, SY + 64 + i * 32, highscore[i].Name, FS_BIG, color);
1276     DrawText(SX + 12 * 32, SY + 64 + i * 32,
1277              int2str(highscore[i].Score, 5), FS_BIG, color);
1278 #else
1279     DrawText(SX, SY + 64 + i * 32, "..................................",
1280              FS_MEDIUM, FC_YELLOW);
1281     DrawText(SX, SY + 64 + i * 32, int2str(entry + 1, 3),
1282              FS_MEDIUM, FC_YELLOW);
1283     DrawText(SX + 64, SY + 64 + i * 32, highscore[entry].Name, FS_BIG, color);
1284     DrawText(SX + 14 * 32 + 16, SY + 64 + i * 32,
1285              int2str(highscore[entry].Score, 5), FS_MEDIUM, color);
1286 #endif
1287   }
1288 }
1289
1290 void HandleHallOfFame(int mx, int my, int dx, int dy, int button)
1291 {
1292   static int first_entry = 0;
1293   static int highlight_position = 0;
1294   int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
1295   int button_released = !button;
1296
1297   if (button == MB_MENU_INITIALIZE)
1298   {
1299     first_entry = 0;
1300     highlight_position = mx;
1301     drawHallOfFameList(first_entry, highlight_position);
1302     return;
1303   }
1304
1305   if (ABS(dy) == SCR_FIELDY)    /* handle KSYM_Page_Up, KSYM_Page_Down */
1306     step = MAX_MENU_ENTRIES_ON_SCREEN - 1;
1307
1308   if (dy < 0)
1309   {
1310     if (first_entry > 0)
1311     {
1312       first_entry -= step;
1313       if (first_entry < 0)
1314         first_entry = 0;
1315
1316       drawHallOfFameList(first_entry, highlight_position);
1317       return;
1318     }
1319   }
1320   else if (dy > 0)
1321   {
1322     if (first_entry + MAX_MENU_ENTRIES_ON_SCREEN < MAX_SCORE_ENTRIES)
1323     {
1324       first_entry += step;
1325       if (first_entry + MAX_MENU_ENTRIES_ON_SCREEN > MAX_SCORE_ENTRIES)
1326         first_entry = MAX(0, MAX_SCORE_ENTRIES - MAX_MENU_ENTRIES_ON_SCREEN);
1327
1328       drawHallOfFameList(first_entry, highlight_position);
1329       return;
1330     }
1331   }
1332
1333   if (button_released)
1334   {
1335     FadeSound(SND_HALLOFFAME);
1336     game_status = MAINMENU;
1337     DrawMainMenu();
1338   }
1339
1340   BackToFront();
1341
1342   if (game_status == HALLOFFAME)
1343     DoAnimation();
1344 }
1345
1346
1347 /* ========================================================================= */
1348 /* setup screen functions                                                    */
1349 /* ========================================================================= */
1350
1351 static struct TokenInfo *setup_info;
1352 static int num_setup_info;
1353 static char *custom_graphics, *custom_sounds, *custom_music;
1354
1355 static void execSetupMain()
1356 {
1357   setup_mode = SETUP_MODE_MAIN;
1358   DrawSetupScreen();
1359 }
1360
1361 static void execSetupGraphics()
1362 {
1363   custom_graphics = artwork.gfx_current->name;
1364
1365   setup_mode = SETUP_MODE_GRAPHICS;
1366   DrawSetupScreen();
1367 }
1368
1369 static void execSetupSound()
1370 {
1371   custom_sounds = artwork.snd_current->name;
1372   custom_music = artwork.mus_current->name;
1373
1374   setup_mode = SETUP_MODE_SOUND;
1375   DrawSetupScreen();
1376 }
1377
1378 static void execSetupChooseGraphics()
1379 {
1380   setup_mode = SETUP_MODE_CHOOSE_GRAPHICS;
1381   DrawSetupScreen();
1382 }
1383
1384 static void execSetupChooseSounds()
1385 {
1386   setup_mode = SETUP_MODE_CHOOSE_SOUNDS;
1387   DrawSetupScreen();
1388 }
1389
1390 static void execSetupChooseMusic()
1391 {
1392   setup_mode = SETUP_MODE_CHOOSE_MUSIC;
1393   DrawSetupScreen();
1394 }
1395
1396 static void execSetupInput()
1397 {
1398   setup_mode = SETUP_MODE_INPUT;
1399   DrawSetupScreen();
1400 }
1401
1402 static void execSetupShortcut()
1403 {
1404   setup_mode = SETUP_MODE_SHORTCUT;
1405   DrawSetupScreen();
1406 }
1407
1408 static void execExitSetupChooseArtwork()
1409 {
1410   if (setup_mode == SETUP_MODE_CHOOSE_GRAPHICS)
1411     execSetupGraphics();
1412   else
1413     execSetupSound();
1414 }
1415
1416 static void execExitSetup()
1417 {
1418   game_status = MAINMENU;
1419   DrawMainMenu();
1420 }
1421
1422 static void execSaveAndExitSetup()
1423 {
1424   SaveSetup();
1425   execExitSetup();
1426 }
1427
1428 static struct TokenInfo setup_info_main[] =
1429 {
1430   { TYPE_ENTER_MENU,    execSetupGraphics,      "Graphics Setup"        },
1431   { TYPE_ENTER_MENU,    execSetupSound,         "Sound Setup"           },
1432   { TYPE_ENTER_MENU,    execSetupInput,         "Input Devices"         },
1433   { TYPE_ENTER_MENU,    execSetupShortcut,      "Key Shortcuts"         },
1434   { TYPE_EMPTY,         NULL,                   ""                      },
1435 #if 0
1436   { TYPE_SWITCH,        &setup.double_buffering,"Buffered gfx:"         },
1437   { TYPE_SWITCH,        &setup.fading,          "Fading:"               },
1438 #endif
1439   { TYPE_SWITCH,        &setup.quick_doors,     "Quick Doors:"          },
1440   { TYPE_SWITCH,        &setup.ask_on_escape,   "Ask on Esc:"           },
1441   { TYPE_SWITCH,        &setup.toons,           "Toons:"                },
1442   { TYPE_SWITCH,        &setup.autorecord,      "Auto-Record:"          },
1443   { TYPE_SWITCH,        &setup.team_mode,       "Team-Mode:"            },
1444   { TYPE_SWITCH,        &setup.handicap,        "Handicap:"             },
1445   { TYPE_SWITCH,        &setup.time_limit,      "Timelimit:"            },
1446   { TYPE_EMPTY,         NULL,                   ""                      },
1447   { TYPE_LEAVE_MENU,    execExitSetup,          "Exit"                  },
1448   { TYPE_LEAVE_MENU,    execSaveAndExitSetup,   "Save and exit"         },
1449   { 0,                  NULL,                   NULL                    }
1450 };
1451
1452 static struct TokenInfo setup_info_graphics[] =
1453 {
1454   { TYPE_ENTER_MENU,    execSetupChooseGraphics,"Custom Graphics"       },
1455   { TYPE_STRING,        &custom_graphics,       ""                      },
1456   { TYPE_EMPTY,         NULL,                   ""                      },
1457   { TYPE_SWITCH,        &setup.fullscreen,      "Fullscreen:"           },
1458   { TYPE_SWITCH,        &setup.scroll_delay,    "Scroll Delay:"         },
1459   { TYPE_SWITCH,        &setup.soft_scrolling,  "Soft Scroll.:"         },
1460   { TYPE_EMPTY,         NULL,                   ""                      },
1461   { TYPE_LEAVE_MENU,    execSetupMain,          "Exit"                  },
1462   { 0,                  NULL,                   NULL                    }
1463 };
1464
1465 static struct TokenInfo setup_info_sound[] =
1466 {
1467   { TYPE_SWITCH,        &setup.sound,           "Sound:",               },
1468   { TYPE_EMPTY,         NULL,                   ""                      },
1469   { TYPE_SWITCH,        &setup.sound_simple,    "Simple Sound:"         },
1470   { TYPE_SWITCH,        &setup.sound_loops,     "Sound Loops:"          },
1471   { TYPE_SWITCH,        &setup.sound_music,     "Game Music:"           },
1472   { TYPE_EMPTY,         NULL,                   ""                      },
1473   { TYPE_ENTER_MENU,    execSetupChooseSounds,  "Custom Sounds"         },
1474   { TYPE_STRING,        &custom_sounds,         ""                      },
1475   { TYPE_ENTER_MENU,    execSetupChooseMusic,   "Custom Music"          },
1476   { TYPE_STRING,        &custom_music,          ""                      },
1477   { TYPE_EMPTY,         NULL,                   ""                      },
1478   { TYPE_LEAVE_MENU,    execSetupMain,          "Exit"                  },
1479   { 0,                  NULL,                   NULL                    }
1480 };
1481
1482 static struct TokenInfo setup_info_shortcut[] =
1483 {
1484   { TYPE_KEYTEXT,       NULL,                   "Quick Save Game:",     },
1485   { TYPE_KEY,           &setup.shortcut.save_game,      ""              },
1486   { TYPE_KEYTEXT,       NULL,                   "Quick Load Game:",     },
1487   { TYPE_KEY,           &setup.shortcut.load_game,      ""              },
1488   { TYPE_EMPTY,         NULL,                   ""                      },
1489   { TYPE_LEAVE_MENU,    execSetupMain,          "Exit"                  },
1490   { 0,                  NULL,                   NULL                    }
1491 };
1492
1493 static Key getSetupKey()
1494 {
1495   Key key = KSYM_UNDEFINED;
1496   boolean got_key_event = FALSE;
1497
1498   while (!got_key_event)
1499   {
1500     if (PendingEvent())         /* got event */
1501     {
1502       Event event;
1503
1504       NextEvent(&event);
1505
1506       switch(event.type)
1507       {
1508         case EVENT_KEYPRESS:
1509           {
1510             key = GetEventKey((KeyEvent *)&event, TRUE);
1511
1512             /* press 'Escape' or 'Enter' to keep the existing key binding */
1513             if (key == KSYM_Escape || key == KSYM_Return)
1514               key = KSYM_UNDEFINED;     /* keep old value */
1515
1516             got_key_event = TRUE;
1517           }
1518           break;
1519
1520         case EVENT_KEYRELEASE:
1521           key_joystick_mapping = 0;
1522           break;
1523
1524         default:
1525           HandleOtherEvents(&event);
1526           break;
1527       }
1528     }
1529
1530     BackToFront();
1531     DoAnimation();
1532
1533     /* don't eat all CPU time */
1534     Delay(10);
1535   }
1536
1537   return key;
1538 }
1539
1540 static void drawSetupValue(int pos)
1541 {
1542   int xpos = MENU_SCREEN_VALUE_XPOS;
1543   int ypos = MENU_SCREEN_START_YPOS + pos;
1544   int value_color = FC_YELLOW;
1545   char *value_string = getSetupValue(setup_info[pos].type & ~TYPE_GHOSTED,
1546                                      setup_info[pos].value);
1547
1548   if (setup_info[pos].type & TYPE_KEY)
1549   {
1550     xpos = 3;
1551
1552     if (setup_info[pos].type & TYPE_QUERY)
1553     {
1554       value_string = "<press key>";
1555       value_color = FC_RED;
1556     }
1557   }
1558   else if (setup_info[pos].type & TYPE_STRING)
1559   {
1560     xpos = 3;
1561
1562     if (strlen(value_string) > 14)
1563       value_string[14] = '\0';
1564   }
1565   else if (setup_info[pos].type & TYPE_BOOLEAN_STYLE &&
1566            !*(boolean *)(setup_info[pos].value))
1567     value_color = FC_BLUE;
1568
1569   DrawText(SX + xpos * 32, SY + ypos * 32,
1570            (xpos == 3 ? "              " : "   "), FS_BIG, FC_YELLOW);
1571   DrawText(SX + xpos * 32, SY + ypos * 32, value_string, FS_BIG, value_color);
1572 }
1573
1574 static void changeSetupValue(int pos)
1575 {
1576   if (setup_info[pos].type & TYPE_BOOLEAN_STYLE)
1577   {
1578     *(boolean *)setup_info[pos].value ^= TRUE;
1579   }
1580   else if (setup_info[pos].type & TYPE_KEY)
1581   {
1582     Key key;
1583
1584     setup_info[pos].type |= TYPE_QUERY;
1585     drawSetupValue(pos);
1586     setup_info[pos].type &= ~TYPE_QUERY;
1587
1588     key = getSetupKey();
1589     if (key != KSYM_UNDEFINED)
1590       *(Key *)setup_info[pos].value = key;
1591   }
1592
1593   drawSetupValue(pos);
1594 }
1595
1596 static void DrawSetupScreen_Generic()
1597 {
1598   char *title_string = NULL;
1599   int i;
1600
1601   UnmapAllGadgets();
1602   CloseDoor(DOOR_CLOSE_2);
1603   ClearWindow();
1604
1605   if (setup_mode == SETUP_MODE_MAIN)
1606   {
1607     setup_info = setup_info_main;
1608     title_string = "Setup";
1609   }
1610   else if (setup_mode == SETUP_MODE_GRAPHICS)
1611   {
1612     setup_info = setup_info_graphics;
1613     title_string = "Setup Graphics";
1614   }
1615   else if (setup_mode == SETUP_MODE_SOUND)
1616   {
1617     setup_info = setup_info_sound;
1618     title_string = "Setup Sound";
1619   }
1620   else if (setup_mode == SETUP_MODE_SHORTCUT)
1621   {
1622     setup_info = setup_info_shortcut;
1623     title_string = "Setup Shortcuts";
1624   }
1625
1626   DrawText(SX + 16, SY + 16, title_string, FS_BIG, FC_YELLOW);
1627
1628   num_setup_info = 0;
1629   for(i=0; setup_info[i].type != 0 && i < MAX_MENU_ENTRIES_ON_SCREEN; i++)
1630   {
1631     void *value_ptr = setup_info[i].value;
1632     int ypos = MENU_SCREEN_START_YPOS + i;
1633     int font_size = FS_BIG;
1634
1635     /* set some entries to "unchangeable" according to other variables */
1636     if ((value_ptr == &setup.sound       && !audio.sound_available) ||
1637         (value_ptr == &setup.sound_loops && !audio.loops_available) ||
1638         (value_ptr == &setup.sound_music && !audio.music_available) ||
1639         (value_ptr == &setup.sound_music && !audio.music_available) ||
1640         (value_ptr == &setup.fullscreen  && !video.fullscreen_available))
1641       setup_info[i].type |= TYPE_GHOSTED;
1642
1643     if (setup_info[i].type & TYPE_ENTER_OR_LEAVE_MENU)
1644       font_size = FS_BIG;
1645
1646     DrawText(SX + 32, SY + ypos * 32, setup_info[i].text, font_size, FC_GREEN);
1647
1648     if (setup_info[i].type & TYPE_ENTER_MENU)
1649       initCursor(i, GFX_ARROW_BLUE_RIGHT);
1650     else if (setup_info[i].type & TYPE_LEAVE_MENU)
1651       initCursor(i, GFX_ARROW_BLUE_LEFT);
1652     else if (setup_info[i].type & ~TYPE_SKIP_ENTRY)
1653       initCursor(i, GFX_KUGEL_BLAU);
1654
1655     if (setup_info[i].type & TYPE_VALUE)
1656       drawSetupValue(i);
1657
1658     num_setup_info++;
1659   }
1660
1661   FadeToFront();
1662   InitAnimation();
1663   HandleSetupScreen_Generic(0,0,0,0,MB_MENU_INITIALIZE);
1664 }
1665
1666 void HandleSetupScreen_Generic(int mx, int my, int dx, int dy, int button)
1667 {
1668   static int choice_store[MAX_SETUP_MODES];
1669   int choice = choice_store[setup_mode];
1670   int x = 0;
1671   int y = choice;
1672
1673   if (button == MB_MENU_INITIALIZE)
1674   {
1675     drawCursor(choice, FC_RED);
1676     return;
1677   }
1678   else if (button == MB_MENU_LEAVE)
1679   {
1680     for (y=0; y<num_setup_info; y++)
1681     {
1682       if (setup_info[y].type & TYPE_LEAVE_MENU)
1683       {
1684         void (*menu_callback_function)(void) = setup_info[y].value;
1685
1686         menu_callback_function();
1687         break;  /* absolutely needed because function changes 'setup_info'! */
1688       }
1689     }
1690
1691     return;
1692   }
1693
1694   if (mx || my)         /* mouse input */
1695   {
1696     x = (mx - SX) / 32;
1697     y = (my - SY) / 32 - MENU_SCREEN_START_YPOS;
1698   }
1699   else if (dx || dy)    /* keyboard input */
1700   {
1701     if (dx)
1702     {
1703       int menu_navigation_type = (dx < 0 ? TYPE_LEAVE_MENU : TYPE_ENTER_MENU);
1704
1705       if ((setup_info[choice].type & menu_navigation_type) ||
1706           (setup_info[choice].type & TYPE_BOOLEAN_STYLE))
1707         button = MB_MENU_CHOICE;
1708     }
1709     else if (dy)
1710       y = choice + dy;
1711
1712     /* jump to next non-empty menu entry (up or down) */
1713     while (y > 0 && y < num_setup_info - 1 &&
1714            (setup_info[y].type & TYPE_SKIP_ENTRY))
1715       y += dy;
1716   }
1717
1718   if (x == 0 && y >= 0 && y < num_setup_info &&
1719       (setup_info[y].type & ~TYPE_SKIP_ENTRY))
1720   {
1721     if (button)
1722     {
1723       if (y != choice)
1724       {
1725         drawCursor(y, FC_RED);
1726         drawCursor(choice, FC_BLUE);
1727         choice = choice_store[setup_mode] = y;
1728       }
1729     }
1730     else if (!(setup_info[y].type & TYPE_GHOSTED))
1731     {
1732 #if 0
1733       if (setup_info[y].type & TYPE_BOOLEAN_STYLE)
1734       {
1735         boolean new_value = !*(boolean *)(setup_info[y].value);
1736
1737         *(boolean *)setup_info[y].value = new_value;
1738         drawSetupValue(y);
1739       }
1740       else if (setup_info[y].type == TYPE_KEYTEXT &&
1741                setup_info[y + 1].type == TYPE_KEY)
1742       {
1743         changeSetupValue(y + 1);
1744       }
1745       else if (setup_info[y].type & TYPE_ENTER_OR_LEAVE_MENU)
1746       {
1747         void (*menu_callback_function)(void) = setup_info[choice].value;
1748
1749         menu_callback_function();
1750       }
1751 #else
1752       if (setup_info[y].type & TYPE_ENTER_OR_LEAVE_MENU)
1753       {
1754         void (*menu_callback_function)(void) = setup_info[choice].value;
1755
1756         menu_callback_function();
1757       }
1758       else
1759       {
1760         if ((setup_info[y].type & TYPE_KEYTEXT) &&
1761             (setup_info[y + 1].type & TYPE_KEY))
1762           y++;
1763
1764         if (setup_info[y].type & TYPE_VALUE)
1765           changeSetupValue(y);
1766       }
1767 #endif
1768     }
1769   }
1770
1771   BackToFront();
1772
1773   if (game_status == SETUP)
1774     DoAnimation();
1775 }
1776
1777 void DrawSetupScreen_Input()
1778 {
1779   ClearWindow();
1780   DrawText(SX+16, SY+16, "Setup Input", FS_BIG, FC_YELLOW);
1781
1782   initCursor(0, GFX_KUGEL_BLAU);
1783   initCursor(1, GFX_KUGEL_BLAU);
1784   initCursor(2, GFX_ARROW_BLUE_RIGHT);
1785   initCursor(13, GFX_ARROW_BLUE_LEFT);
1786
1787   DrawGraphic(10, MENU_SCREEN_START_YPOS, GFX_ARROW_BLUE_LEFT);
1788   DrawGraphic(12, MENU_SCREEN_START_YPOS, GFX_ARROW_BLUE_RIGHT);
1789
1790   DrawText(SX+32, SY+2*32, "Player:", FS_BIG, FC_GREEN);
1791   DrawText(SX+32, SY+3*32, "Device:", FS_BIG, FC_GREEN);
1792   DrawText(SX+32, SY+15*32, "Exit", FS_BIG, FC_GREEN);
1793
1794   DeactivateJoystickForCalibration();
1795   DrawTextFCentered(SYSIZE - 20, FC_BLUE,
1796                     "Joysticks deactivated on this screen");
1797
1798   HandleSetupScreen_Input(0,0, 0,0, MB_MENU_INITIALIZE);
1799   FadeToFront();
1800   InitAnimation();
1801 }
1802
1803 static void setJoystickDeviceToNr(char *device_name, int device_nr)
1804 {
1805   if (device_name == NULL)
1806     return;
1807
1808   if (device_nr < 0 || device_nr >= MAX_PLAYERS)
1809     device_nr = 0;
1810
1811   if (strlen(device_name) > 1)
1812   {
1813     char c1 = device_name[strlen(device_name) - 1];
1814     char c2 = device_name[strlen(device_name) - 2];
1815
1816     if (c1 >= '0' && c1 <= '9' && !(c2 >= '0' && c2 <= '9'))
1817       device_name[strlen(device_name) - 1] = '0' + (char)(device_nr % 10);
1818   }
1819   else
1820     strncpy(device_name, getDeviceNameFromJoystickNr(device_nr),
1821             strlen(device_name));
1822 }
1823
1824 static void drawPlayerSetupInputInfo(int player_nr)
1825 {
1826   int i;
1827   static struct SetupKeyboardInfo custom_key;
1828   static struct
1829   {
1830     Key *key;
1831     char *text;
1832   } custom[] =
1833   {
1834     { &custom_key.left,  "Joystick Left"  },
1835     { &custom_key.right, "Joystick Right" },
1836     { &custom_key.up,    "Joystick Up"    },
1837     { &custom_key.down,  "Joystick Down"  },
1838     { &custom_key.snap,  "Button 1"       },
1839     { &custom_key.bomb,  "Button 2"       }
1840   };
1841   static char *joystick_name[MAX_PLAYERS] =
1842   {
1843     "Joystick1",
1844     "Joystick2",
1845     "Joystick3",
1846     "Joystick4"
1847   };
1848
1849   custom_key = setup.input[player_nr].key;
1850
1851   DrawText(SX+11*32, SY+2*32, int2str(player_nr + 1, 1), FS_BIG, FC_RED);
1852   DrawGraphic(8, 2, GFX_SPIELER1 + player_nr);
1853
1854   if (setup.input[player_nr].use_joystick)
1855   {
1856     char *device_name = setup.input[player_nr].joy.device_name;
1857
1858     DrawText(SX+8*32, SY+3*32,
1859              joystick_name[getJoystickNrFromDeviceName(device_name)],
1860              FS_BIG, FC_YELLOW);
1861     DrawText(SX+32, SY+4*32, "Calibrate", FS_BIG, FC_GREEN);
1862   }
1863   else
1864   {
1865     DrawText(SX+8*32, SY+3*32, "Keyboard ", FS_BIG, FC_YELLOW);
1866     DrawText(SX+32, SY+4*32, "Customize", FS_BIG, FC_GREEN);
1867   }
1868
1869   DrawText(SX+32, SY+5*32, "Actual Settings:", FS_BIG, FC_GREEN);
1870   DrawGraphic(1, 6, GFX_ARROW_BLUE_LEFT);
1871   DrawGraphic(1, 7, GFX_ARROW_BLUE_RIGHT);
1872   DrawGraphic(1, 8, GFX_ARROW_BLUE_UP);
1873   DrawGraphic(1, 9, GFX_ARROW_BLUE_DOWN);
1874   DrawText(SX+2*32, SY+6*32, ":", FS_BIG, FC_BLUE);
1875   DrawText(SX+2*32, SY+7*32, ":", FS_BIG, FC_BLUE);
1876   DrawText(SX+2*32, SY+8*32, ":", FS_BIG, FC_BLUE);
1877   DrawText(SX+2*32, SY+9*32, ":", FS_BIG, FC_BLUE);
1878   DrawText(SX+32, SY+10*32, "Snap Field:", FS_BIG, FC_BLUE);
1879   DrawText(SX+32, SY+12*32, "Place Bomb:", FS_BIG, FC_BLUE);
1880
1881   for (i=0; i<6; i++)
1882   {
1883     int ypos = 6 + i + (i > 3 ? i-3 : 0);
1884
1885     DrawText(SX + 3*32, SY + ypos*32,
1886              "              ", FS_BIG, FC_YELLOW);
1887     DrawText(SX + 3*32, SY + ypos*32,
1888              (setup.input[player_nr].use_joystick ?
1889               custom[i].text :
1890               getKeyNameFromKey(*custom[i].key)),
1891              FS_BIG, FC_YELLOW);
1892   }
1893 }
1894
1895 void HandleSetupScreen_Input(int mx, int my, int dx, int dy, int button)
1896 {
1897   static int choice = 0;
1898   static int player_nr = 0;
1899   int x = 0;
1900   int y = choice;
1901   int pos_start  = SETUPINPUT_SCREEN_POS_START;
1902   int pos_empty1 = SETUPINPUT_SCREEN_POS_EMPTY1;
1903   int pos_empty2 = SETUPINPUT_SCREEN_POS_EMPTY2;
1904   int pos_end    = SETUPINPUT_SCREEN_POS_END;
1905
1906   if (button == MB_MENU_INITIALIZE)
1907   {
1908     drawPlayerSetupInputInfo(player_nr);
1909     drawCursor(choice, FC_RED);
1910     return;
1911   }
1912   else if (button == MB_MENU_LEAVE)
1913   {
1914     setup_mode = SETUP_MODE_MAIN;
1915     DrawSetupScreen();
1916     InitJoysticks();
1917   }
1918
1919   if (mx || my)         /* mouse input */
1920   {
1921     x = (mx - SX) / 32;
1922     y = (my - SY) / 32 - MENU_SCREEN_START_YPOS;
1923   }
1924   else if (dx || dy)    /* keyboard input */
1925   {
1926     if (dx && choice == 0)
1927       x = (dx < 0 ? 10 : 12);
1928     else if ((dx && choice == 1) ||
1929              (dx == +1 && choice == 2) ||
1930              (dx == -1 && choice == pos_end))
1931       button = MB_MENU_CHOICE;
1932     else if (dy)
1933       y = choice + dy;
1934
1935     if (y >= pos_empty1 && y <= pos_empty2)
1936       y = (dy > 0 ? pos_empty2 + 1 : pos_empty1 - 1);
1937   }
1938
1939   if (y == 0 && ((x == 0 && !button) || ((x == 10 || x == 12) && button)))
1940   {
1941     static unsigned long delay = 0;
1942
1943     if (!DelayReached(&delay, GADGET_FRAME_DELAY))
1944       goto out;
1945
1946     player_nr = (player_nr + (x == 10 ? -1 : +1) + MAX_PLAYERS) % MAX_PLAYERS;
1947
1948     drawPlayerSetupInputInfo(player_nr);
1949   }
1950   else if (x == 0 && y >= pos_start && y <= pos_end &&
1951            !(y >= pos_empty1 && y <= pos_empty2))
1952   {
1953     if (button)
1954     {
1955       if (y != choice)
1956       {
1957         drawCursor(y, FC_RED);
1958         drawCursor(choice, FC_BLUE);
1959         choice = y;
1960       }
1961     }
1962     else
1963     {
1964       if (y == 1)
1965       {
1966         char *device_name = setup.input[player_nr].joy.device_name;
1967
1968         if (!setup.input[player_nr].use_joystick)
1969         {
1970           int new_device_nr = (dx >= 0 ? 0 : MAX_PLAYERS - 1);
1971
1972           setJoystickDeviceToNr(device_name, new_device_nr);
1973           setup.input[player_nr].use_joystick = TRUE;
1974         }
1975         else
1976         {
1977           int device_nr = getJoystickNrFromDeviceName(device_name);
1978           int new_device_nr = device_nr + (dx >= 0 ? +1 : -1);
1979
1980           if (new_device_nr < 0 || new_device_nr >= MAX_PLAYERS)
1981             setup.input[player_nr].use_joystick = FALSE;
1982           else
1983             setJoystickDeviceToNr(device_name, new_device_nr);
1984         }
1985
1986         drawPlayerSetupInputInfo(player_nr);
1987       }
1988       else if (y == 2)
1989       {
1990         if (setup.input[player_nr].use_joystick)
1991         {
1992           InitJoysticks();
1993           CalibrateJoystick(player_nr);
1994         }
1995         else
1996           CustomizeKeyboard(player_nr);
1997       }
1998       else if (y == pos_end)
1999       {
2000         InitJoysticks();
2001
2002         setup_mode = SETUP_MODE_MAIN;
2003         DrawSetupScreen();
2004       }
2005     }
2006   }
2007
2008   BackToFront();
2009
2010   out:
2011
2012   if (game_status == SETUP)
2013     DoAnimation();
2014 }
2015
2016 void CustomizeKeyboard(int player_nr)
2017 {
2018   int i;
2019   int step_nr;
2020   boolean finished = FALSE;
2021   static struct SetupKeyboardInfo custom_key;
2022   static struct
2023   {
2024     Key *key;
2025     char *text;
2026   } customize_step[] =
2027   {
2028     { &custom_key.left,  "Move Left"  },
2029     { &custom_key.right, "Move Right" },
2030     { &custom_key.up,    "Move Up"    },
2031     { &custom_key.down,  "Move Down"  },
2032     { &custom_key.snap,  "Snap Field" },
2033     { &custom_key.bomb,  "Place Bomb" }
2034   };
2035
2036   /* read existing key bindings from player setup */
2037   custom_key = setup.input[player_nr].key;
2038
2039   ClearWindow();
2040   DrawText(SX + 16, SY + 16, "Keyboard Input", FS_BIG, FC_YELLOW);
2041
2042   BackToFront();
2043   InitAnimation();
2044
2045   step_nr = 0;
2046   DrawText(SX, SY + (2+2*step_nr)*32,
2047            customize_step[step_nr].text, FS_BIG, FC_RED);
2048   DrawText(SX, SY + (2+2*step_nr+1)*32,
2049            "Key:", FS_BIG, FC_RED);
2050   DrawText(SX + 4*32, SY + (2+2*step_nr+1)*32,
2051            getKeyNameFromKey(*customize_step[step_nr].key),
2052            FS_BIG, FC_BLUE);
2053
2054   while(!finished)
2055   {
2056     if (PendingEvent())         /* got event */
2057     {
2058       Event event;
2059
2060       NextEvent(&event);
2061
2062       switch(event.type)
2063       {
2064         case EVENT_KEYPRESS:
2065           {
2066             Key key = GetEventKey((KeyEvent *)&event, TRUE);
2067
2068             if (key == KSYM_Escape || (key == KSYM_Return && step_nr == 6))
2069             {
2070               finished = TRUE;
2071               break;
2072             }
2073
2074             /* all keys configured -- wait for "Escape" or "Return" key */
2075             if (step_nr == 6)
2076               break;
2077
2078             /* press 'Enter' to keep the existing key binding */
2079             if (key == KSYM_Return)
2080               key = *customize_step[step_nr].key;
2081
2082             /* check if key already used */
2083             for (i=0; i<step_nr; i++)
2084               if (*customize_step[i].key == key)
2085                 break;
2086             if (i < step_nr)
2087               break;
2088
2089             /* got new key binding */
2090             *customize_step[step_nr].key = key;
2091             DrawText(SX + 4*32, SY + (2+2*step_nr+1)*32,
2092                      "             ", FS_BIG, FC_YELLOW);
2093             DrawText(SX + 4*32, SY + (2+2*step_nr+1)*32,
2094                      getKeyNameFromKey(key), FS_BIG, FC_YELLOW);
2095             step_nr++;
2096
2097             /* un-highlight last query */
2098             DrawText(SX, SY+(2+2*(step_nr-1))*32,
2099                      customize_step[step_nr-1].text, FS_BIG, FC_GREEN);
2100             DrawText(SX, SY+(2+2*(step_nr-1)+1)*32,
2101                      "Key:", FS_BIG, FC_GREEN);
2102
2103             /* press 'Enter' to leave */
2104             if (step_nr == 6)
2105             {
2106               DrawText(SX + 16, SY + 15*32+16,
2107                        "Press Enter", FS_BIG, FC_YELLOW);
2108               break;
2109             }
2110
2111             /* query next key binding */
2112             DrawText(SX, SY+(2+2*step_nr)*32,
2113                      customize_step[step_nr].text, FS_BIG, FC_RED);
2114             DrawText(SX, SY+(2+2*step_nr+1)*32,
2115                      "Key:", FS_BIG, FC_RED);
2116             DrawText(SX + 4*32, SY+(2+2*step_nr+1)*32,
2117                      getKeyNameFromKey(*customize_step[step_nr].key),
2118                      FS_BIG, FC_BLUE);
2119           }
2120           break;
2121
2122         case EVENT_KEYRELEASE:
2123           key_joystick_mapping = 0;
2124           break;
2125
2126         default:
2127           HandleOtherEvents(&event);
2128           break;
2129       }
2130     }
2131
2132     BackToFront();
2133     DoAnimation();
2134
2135     /* don't eat all CPU time */
2136     Delay(10);
2137   }
2138
2139   /* write new key bindings back to player setup */
2140   setup.input[player_nr].key = custom_key;
2141
2142   StopAnimation();
2143   DrawSetupScreen_Input();
2144 }
2145
2146 static boolean CalibrateJoystickMain(int player_nr)
2147 {
2148   int new_joystick_xleft = JOYSTICK_XMIDDLE;
2149   int new_joystick_xright = JOYSTICK_XMIDDLE;
2150   int new_joystick_yupper = JOYSTICK_YMIDDLE;
2151   int new_joystick_ylower = JOYSTICK_YMIDDLE;
2152   int new_joystick_xmiddle, new_joystick_ymiddle;
2153
2154   int joystick_fd = joystick.fd[player_nr];
2155   int x, y, last_x, last_y, xpos = 8, ypos = 3;
2156   boolean check[3][3];
2157   int check_remaining = 3 * 3;
2158   int joy_x, joy_y;
2159   int joy_value;
2160   int result = -1;
2161
2162   if (joystick.status == JOYSTICK_NOT_AVAILABLE)
2163     return FALSE;
2164
2165   if (joystick_fd < 0 || !setup.input[player_nr].use_joystick)
2166     return FALSE;
2167
2168   ClearWindow();
2169
2170   for(y=0; y<3; y++)
2171   {
2172     for(x=0; x<3; x++)
2173     {
2174       check[x][y] = FALSE;
2175       DrawGraphic(xpos + x - 1, ypos + y - 1, GFX_KUGEL_BLAU);
2176     }
2177   }
2178
2179   DrawText(SX,      SY +  6 * 32, " ROTATE JOYSTICK ", FS_BIG, FC_YELLOW);
2180   DrawText(SX,      SY +  7 * 32, "IN ALL DIRECTIONS", FS_BIG, FC_YELLOW);
2181   DrawText(SX + 16, SY +  9 * 32, "  IF ALL BALLS  ",  FS_BIG, FC_YELLOW);
2182   DrawText(SX,      SY + 10 * 32, "   ARE YELLOW,   ", FS_BIG, FC_YELLOW);
2183   DrawText(SX,      SY + 11 * 32, " CENTER JOYSTICK ", FS_BIG, FC_YELLOW);
2184   DrawText(SX,      SY + 12 * 32, "       AND       ", FS_BIG, FC_YELLOW);
2185   DrawText(SX,      SY + 13 * 32, "PRESS ANY BUTTON!", FS_BIG, FC_YELLOW);
2186
2187   joy_value = Joystick(player_nr);
2188   last_x = (joy_value & JOY_LEFT ? -1 : joy_value & JOY_RIGHT ? +1 : 0);
2189   last_y = (joy_value & JOY_UP   ? -1 : joy_value & JOY_DOWN  ? +1 : 0);
2190
2191   /* eventually uncalibrated center position (joystick could be uncentered) */
2192   if (!ReadJoystick(joystick_fd, &joy_x, &joy_y, NULL, NULL))
2193     return FALSE;
2194
2195   new_joystick_xmiddle = joy_x;
2196   new_joystick_ymiddle = joy_y;
2197
2198   DrawGraphic(xpos + last_x, ypos + last_y, GFX_KUGEL_ROT);
2199   BackToFront();
2200
2201   while(Joystick(player_nr) & JOY_BUTTON);      /* wait for released button */
2202   InitAnimation();
2203
2204   while(result < 0)
2205   {
2206     if (PendingEvent())         /* got event */
2207     {
2208       Event event;
2209
2210       NextEvent(&event);
2211
2212       switch(event.type)
2213       {
2214         case EVENT_KEYPRESS:
2215           switch(GetEventKey((KeyEvent *)&event, TRUE))
2216           {
2217             case KSYM_Return:
2218               if (check_remaining == 0)
2219                 result = 1;
2220               break;
2221
2222             case KSYM_Escape:
2223               result = 0;
2224               break;
2225
2226             default:
2227               break;
2228           }
2229           break;
2230
2231         case EVENT_KEYRELEASE:
2232           key_joystick_mapping = 0;
2233           break;
2234
2235         default:
2236           HandleOtherEvents(&event);
2237           break;
2238       }
2239     }
2240
2241     if (!ReadJoystick(joystick_fd, &joy_x, &joy_y, NULL, NULL))
2242       return FALSE;
2243
2244     new_joystick_xleft  = MIN(new_joystick_xleft,  joy_x);
2245     new_joystick_xright = MAX(new_joystick_xright, joy_x);
2246     new_joystick_yupper = MIN(new_joystick_yupper, joy_y);
2247     new_joystick_ylower = MAX(new_joystick_ylower, joy_y);
2248
2249     setup.input[player_nr].joy.xleft = new_joystick_xleft;
2250     setup.input[player_nr].joy.yupper = new_joystick_yupper;
2251     setup.input[player_nr].joy.xright = new_joystick_xright;
2252     setup.input[player_nr].joy.ylower = new_joystick_ylower;
2253     setup.input[player_nr].joy.xmiddle = new_joystick_xmiddle;
2254     setup.input[player_nr].joy.ymiddle = new_joystick_ymiddle;
2255
2256     CheckJoystickData();
2257
2258     joy_value = Joystick(player_nr);
2259
2260     if (joy_value & JOY_BUTTON && check_remaining == 0)
2261       result = 1;
2262
2263     x = (joy_value & JOY_LEFT ? -1 : joy_value & JOY_RIGHT ? +1 : 0);
2264     y = (joy_value & JOY_UP   ? -1 : joy_value & JOY_DOWN  ? +1 : 0);
2265
2266     if (x != last_x || y != last_y)
2267     {
2268       DrawGraphic(xpos + last_x, ypos + last_y, GFX_KUGEL_GELB);
2269       DrawGraphic(xpos + x,      ypos + y,      GFX_KUGEL_ROT);
2270
2271       last_x = x;
2272       last_y = y;
2273
2274       if (check_remaining > 0 && !check[x+1][y+1])
2275       {
2276         check[x+1][y+1] = TRUE;
2277         check_remaining--;
2278       }
2279
2280 #if 0
2281 #ifdef DEBUG
2282       printf("LEFT / MIDDLE / RIGHT == %d / %d / %d\n",
2283              setup.input[player_nr].joy.xleft,
2284              setup.input[player_nr].joy.xmiddle,
2285              setup.input[player_nr].joy.xright);
2286       printf("UP / MIDDLE / DOWN == %d / %d / %d\n",
2287              setup.input[player_nr].joy.yupper,
2288              setup.input[player_nr].joy.ymiddle,
2289              setup.input[player_nr].joy.ylower);
2290 #endif
2291 #endif
2292
2293     }
2294
2295     BackToFront();
2296     DoAnimation();
2297
2298     /* don't eat all CPU time */
2299     Delay(10);
2300   }
2301
2302   /* calibrated center position (joystick should now be centered) */
2303   if (!ReadJoystick(joystick_fd, &joy_x, &joy_y, NULL, NULL))
2304     return FALSE;
2305
2306   new_joystick_xmiddle = joy_x;
2307   new_joystick_ymiddle = joy_y;
2308
2309   StopAnimation();
2310
2311   DrawSetupScreen_Input();
2312
2313   /* wait until the last pressed button was released */
2314   while (Joystick(player_nr) & JOY_BUTTON)
2315   {
2316     if (PendingEvent())         /* got event */
2317     {
2318       Event event;
2319
2320       NextEvent(&event);
2321       HandleOtherEvents(&event);
2322
2323       Delay(10);
2324     }
2325   }
2326
2327   return TRUE;
2328 }
2329
2330 void CalibrateJoystick(int player_nr)
2331 {
2332   if (!CalibrateJoystickMain(player_nr))
2333   {
2334     ClearWindow();
2335
2336     DrawText(SX + 16, SY + 6*32, "  JOYSTICK NOT  ",  FS_BIG, FC_YELLOW);
2337     DrawText(SX,      SY + 7*32, "    AVAILABLE    ", FS_BIG, FC_YELLOW);
2338     BackToFront();
2339     Delay(2000);        /* show error message for two seconds */
2340   }
2341 }
2342
2343 void DrawSetupScreen()
2344 {
2345   if (setup_mode == SETUP_MODE_INPUT)
2346     DrawSetupScreen_Input();
2347   else if (setup_mode == SETUP_MODE_CHOOSE_GRAPHICS)
2348     DrawChooseTree(&artwork.gfx_current);
2349   else if (setup_mode == SETUP_MODE_CHOOSE_SOUNDS)
2350     DrawChooseTree(&artwork.snd_current);
2351   else if (setup_mode == SETUP_MODE_CHOOSE_MUSIC)
2352     DrawChooseTree(&artwork.mus_current);
2353   else
2354     DrawSetupScreen_Generic();
2355 }
2356
2357 void HandleSetupScreen(int mx, int my, int dx, int dy, int button)
2358 {
2359   if (setup_mode == SETUP_MODE_INPUT)
2360     HandleSetupScreen_Input(mx, my, dx, dy, button);
2361   else if (setup_mode == SETUP_MODE_CHOOSE_GRAPHICS)
2362     HandleChooseTree(mx, my, dx, dy, button, &artwork.gfx_current);
2363   else if (setup_mode == SETUP_MODE_CHOOSE_SOUNDS)
2364     HandleChooseTree(mx, my, dx, dy, button, &artwork.snd_current);
2365   else if (setup_mode == SETUP_MODE_CHOOSE_MUSIC)
2366     HandleChooseTree(mx, my, dx, dy, button, &artwork.mus_current);
2367   else
2368     HandleSetupScreen_Generic(mx, my, dx, dy, button);
2369 }
2370
2371 void HandleGameActions()
2372 {
2373   if (game_status != PLAYING)
2374     return;
2375
2376   if (local_player->LevelSolved)
2377     GameWon();
2378
2379   if (AllPlayersGone && !TAPE_IS_STOPPED(tape))
2380     TapeStop();
2381
2382   GameActions();
2383
2384   BackToFront();
2385 }
2386
2387 /* ---------- new screen button stuff -------------------------------------- */
2388
2389 /* graphic position and size values for buttons and scrollbars */
2390 #define SC_SCROLLBUTTON_XPOS            64
2391 #define SC_SCROLLBUTTON_YPOS            0
2392 #define SC_SCROLLBAR_XPOS               0
2393 #define SC_SCROLLBAR_YPOS               64
2394
2395 #define SC_SCROLLBUTTON_XSIZE           32
2396 #define SC_SCROLLBUTTON_YSIZE           32
2397
2398 #define SC_SCROLL_UP_XPOS               (SXSIZE - SC_SCROLLBUTTON_XSIZE)
2399 #define SC_SCROLL_UP_YPOS               SC_SCROLLBUTTON_YSIZE
2400 #define SC_SCROLL_DOWN_XPOS             SC_SCROLL_UP_XPOS
2401 #define SC_SCROLL_DOWN_YPOS             (SYSIZE - SC_SCROLLBUTTON_YSIZE)
2402 #define SC_SCROLL_VERTICAL_XPOS         SC_SCROLL_UP_XPOS
2403 #define SC_SCROLL_VERTICAL_YPOS   (SC_SCROLL_UP_YPOS + SC_SCROLLBUTTON_YSIZE)
2404 #define SC_SCROLL_VERTICAL_XSIZE        SC_SCROLLBUTTON_XSIZE
2405 #define SC_SCROLL_VERTICAL_YSIZE        (SYSIZE - 3 * SC_SCROLLBUTTON_YSIZE)
2406
2407 #define SC_BORDER_SIZE                  14
2408
2409 static struct
2410 {
2411   int xpos, ypos;
2412   int x, y;
2413   int gadget_id;
2414   char *infotext;
2415 } scrollbutton_info[NUM_SCREEN_SCROLLBUTTONS] =
2416 {
2417   {
2418     SC_SCROLLBUTTON_XPOS + 0 * SC_SCROLLBUTTON_XSIZE,   SC_SCROLLBUTTON_YPOS,
2419     SC_SCROLL_UP_XPOS,                                  SC_SCROLL_UP_YPOS,
2420     SCREEN_CTRL_ID_SCROLL_UP,
2421     "scroll level series up"
2422   },
2423   {
2424     SC_SCROLLBUTTON_XPOS + 1 * SC_SCROLLBUTTON_XSIZE,   SC_SCROLLBUTTON_YPOS,
2425     SC_SCROLL_DOWN_XPOS,                                SC_SCROLL_DOWN_YPOS,
2426     SCREEN_CTRL_ID_SCROLL_DOWN,
2427     "scroll level series down"
2428   }
2429 };
2430
2431 static struct
2432 {
2433   int xpos, ypos;
2434   int x, y;
2435   int width, height;
2436   int type;
2437   int gadget_id;
2438   char *infotext;
2439 } scrollbar_info[NUM_SCREEN_SCROLLBARS] =
2440 {
2441   {
2442     SC_SCROLLBAR_XPOS,                  SC_SCROLLBAR_YPOS,
2443     SX + SC_SCROLL_VERTICAL_XPOS,       SY + SC_SCROLL_VERTICAL_YPOS,
2444     SC_SCROLL_VERTICAL_XSIZE,           SC_SCROLL_VERTICAL_YSIZE,
2445     GD_TYPE_SCROLLBAR_VERTICAL,
2446     SCREEN_CTRL_ID_SCROLL_VERTICAL,
2447     "scroll level series vertically"
2448   }
2449 };
2450
2451 static void CreateScreenScrollbuttons()
2452 {
2453   Bitmap *gd_bitmap = pix[PIX_MORE];
2454   struct GadgetInfo *gi;
2455   unsigned long event_mask;
2456   int i;
2457
2458   for (i=0; i<NUM_SCREEN_SCROLLBUTTONS; i++)
2459   {
2460     int id = scrollbutton_info[i].gadget_id;
2461     int x, y, width, height;
2462     int gd_x1, gd_x2, gd_y1, gd_y2;
2463
2464     x = scrollbutton_info[i].x;
2465     y = scrollbutton_info[i].y;
2466
2467     event_mask = GD_EVENT_PRESSED | GD_EVENT_REPEATED;
2468
2469     x += SX;
2470     y += SY;
2471     width = SC_SCROLLBUTTON_XSIZE;
2472     height = SC_SCROLLBUTTON_YSIZE;
2473     gd_x1 = scrollbutton_info[i].xpos;
2474     gd_y1 = scrollbutton_info[i].ypos;
2475     gd_x2 = gd_x1;
2476     gd_y2 = gd_y1 + SC_SCROLLBUTTON_YSIZE;
2477
2478     gi = CreateGadget(GDI_CUSTOM_ID, id,
2479                       GDI_CUSTOM_TYPE_ID, i,
2480                       GDI_INFO_TEXT, scrollbutton_info[i].infotext,
2481                       GDI_X, x,
2482                       GDI_Y, y,
2483                       GDI_WIDTH, width,
2484                       GDI_HEIGHT, height,
2485                       GDI_TYPE, GD_TYPE_NORMAL_BUTTON,
2486                       GDI_STATE, GD_BUTTON_UNPRESSED,
2487                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
2488                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
2489                       GDI_EVENT_MASK, event_mask,
2490                       GDI_CALLBACK_ACTION, HandleScreenGadgets,
2491                       GDI_END);
2492
2493     if (gi == NULL)
2494       Error(ERR_EXIT, "cannot create gadget");
2495
2496     screen_gadget[id] = gi;
2497   }
2498 }
2499
2500 static void CreateScreenScrollbars()
2501 {
2502   int i;
2503
2504   for (i=0; i<NUM_SCREEN_SCROLLBARS; i++)
2505   {
2506     int id = scrollbar_info[i].gadget_id;
2507     Bitmap *gd_bitmap = pix[PIX_MORE];
2508     int gd_x1, gd_x2, gd_y1, gd_y2;
2509     struct GadgetInfo *gi;
2510     int items_max, items_visible, item_position;
2511     unsigned long event_mask;
2512     int num_page_entries = MAX_MENU_ENTRIES_ON_SCREEN - 1;
2513
2514 #if 0
2515     if (num_leveldirs <= MAX_MENU_ENTRIES_ON_SCREEN)
2516       num_page_entries = num_leveldirs;
2517     else
2518       num_page_entries = MAX_MENU_ENTRIES_ON_SCREEN - 1;
2519
2520     items_max = MAX(num_leveldirs, num_page_entries);
2521     items_visible = num_page_entries;
2522     item_position = 0;
2523 #else
2524     items_max = num_page_entries;
2525     items_visible = num_page_entries;
2526     item_position = 0;
2527 #endif
2528
2529     event_mask = GD_EVENT_MOVING | GD_EVENT_OFF_BORDERS;
2530
2531     gd_x1 = scrollbar_info[i].xpos;
2532     gd_x2 = gd_x1 + scrollbar_info[i].width;
2533     gd_y1 = scrollbar_info[i].ypos;
2534     gd_y2 = scrollbar_info[i].ypos;
2535
2536     gi = CreateGadget(GDI_CUSTOM_ID, id,
2537                       GDI_CUSTOM_TYPE_ID, i,
2538                       GDI_INFO_TEXT, scrollbar_info[i].infotext,
2539                       GDI_X, scrollbar_info[i].x,
2540                       GDI_Y, scrollbar_info[i].y,
2541                       GDI_WIDTH, scrollbar_info[i].width,
2542                       GDI_HEIGHT, scrollbar_info[i].height,
2543                       GDI_TYPE, scrollbar_info[i].type,
2544                       GDI_SCROLLBAR_ITEMS_MAX, items_max,
2545                       GDI_SCROLLBAR_ITEMS_VISIBLE, items_visible,
2546                       GDI_SCROLLBAR_ITEM_POSITION, item_position,
2547                       GDI_STATE, GD_BUTTON_UNPRESSED,
2548                       GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
2549                       GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
2550                       GDI_BORDER_SIZE, SC_BORDER_SIZE,
2551                       GDI_EVENT_MASK, event_mask,
2552                       GDI_CALLBACK_ACTION, HandleScreenGadgets,
2553                       GDI_END);
2554
2555     if (gi == NULL)
2556       Error(ERR_EXIT, "cannot create gadget");
2557
2558     screen_gadget[id] = gi;
2559   }
2560 }
2561
2562 void CreateScreenGadgets()
2563 {
2564   CreateScreenScrollbuttons();
2565   CreateScreenScrollbars();
2566 }
2567
2568 void MapChooseTreeGadgets(TreeInfo *ti)
2569 {
2570   int num_entries = numTreeInfoInGroup(ti);
2571   int i;
2572
2573   if (num_entries <= MAX_MENU_ENTRIES_ON_SCREEN)
2574     return;
2575
2576   for (i=0; i<NUM_SCREEN_GADGETS; i++)
2577     MapGadget(screen_gadget[i]);
2578 }
2579
2580 void UnmapChooseTreeGadgets()
2581 {
2582   int i;
2583
2584   for (i=0; i<NUM_SCREEN_GADGETS; i++)
2585     UnmapGadget(screen_gadget[i]);
2586 }
2587
2588 static void HandleScreenGadgets(struct GadgetInfo *gi)
2589 {
2590   int id = gi->custom_id;
2591
2592   if (game_status != CHOOSELEVEL)
2593     return;
2594
2595   switch (id)
2596   {
2597     case SCREEN_CTRL_ID_SCROLL_UP:
2598       HandleChooseLevel(SX,SY + 32, 0,0, MB_MENU_MARK);
2599       break;
2600
2601     case SCREEN_CTRL_ID_SCROLL_DOWN:
2602       HandleChooseLevel(SX,SY + SYSIZE - 32, 0,0, MB_MENU_MARK);
2603       break;
2604
2605     case SCREEN_CTRL_ID_SCROLL_VERTICAL:
2606       HandleChooseLevel(0,0, 999,gi->event.item_position, MB_MENU_INITIALIZE);
2607       break;
2608
2609     default:
2610       break;
2611   }
2612 }