src/init.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 * init.c                                                   *
  12 ***********************************************************/
  13
  14 #include "libgame/libgame.h"
  15
  16 #include "init.h"
  17 #include "events.h"
  18 #include "screens.h"
  19 #include "editor.h"
  20 #include "game.h"
  21 #include "tape.h"
  22 #include "tools.h"
  23 #include "files.h"
  24 #include "network.h"
  25 #include "netserv.h"
  26 #include "cartoons.h"
  27 #include "config.h"
  28
  29 #include "conf_e2g.c"   /* include auto-generated data structure definitions */
  30
  31
  32 static char *image_filename[NUM_PICTURES] =
  33 {
  34 #if 0
  35   "RocksScreen.pcx",
  36   "RocksDoor.pcx",
  37   "RocksToons.pcx",
  38   "RocksFontBig.pcx",
  39   "RocksFontSmall.pcx",
  40   "RocksFontMedium.pcx",
  41   "RocksFontEM.pcx"
  42 #else
  43   "RocksScreen.pcx",
  44   "RocksElements.pcx",
  45   "RocksDoor.pcx",
  46   "RocksHeroes.pcx",
  47   "RocksToons.pcx",
  48   "RocksSP.pcx",
  49   "RocksDC.pcx",
  50   "RocksMore.pcx",
  51   "RocksFontBig.pcx",
  52   "RocksFontSmall.pcx",
  53   "RocksFontMedium.pcx",
  54   "RocksFontEM.pcx"
  55 #endif
  56 };
  57
  58 static Bitmap *bitmap_font_initial = NULL;
  59
  60 static void InitGlobal(void);
  61 static void InitSetup(void);
  62 static void InitPlayerInfo(void);
  63 static void InitLevelInfo(void);
  64 static void InitArtworkInfo(void);
  65 static void InitLevelArtworkInfo(void);
  66 static void InitNetworkServer(void);
  67 static void InitArtworkConfig(void);
  68 static void InitImages(void);
  69 static void InitMixer(void);
  70 static void InitSound(void);
  71 static void InitMusic(void);
  72 static void InitGfx(void);
  73 static void InitGfxBackground(void);
  74 static void InitGadgets(void);
  75 static void InitElementProperties(void);
  76 static void InitElementGraphicInfo(void);
  77 static void InitElementSoundInfo(void);
  78 static void InitGraphicInfo(void);
  79 static void InitSoundInfo();
  80 static void Execute_Command(char *);
  81
  82 void OpenAll(void)
  83 {
  84   InitGlobal();         /* initialize some global variables */
  85
  86   if (options.execute_command)
  87     Execute_Command(options.execute_command);
  88
  89   if (options.serveronly)
  90   {
  91 #if defined(PLATFORM_UNIX)
  92     NetworkServer(options.server_port, options.serveronly);
  93 #else
  94     Error(ERR_WARN, "networking only supported in Unix version");
  95 #endif
  96     exit(0);    /* never reached */
  97   }
  98
  99   InitProgramInfo(UNIX_USERDATA_DIRECTORY,
 100                   PROGRAM_TITLE_STRING, getWindowTitleString(),
 101                   ICON_TITLE_STRING, X11_ICON_FILENAME, X11_ICONMASK_FILENAME,
 102                   MSDOS_POINTER_FILENAME,
 103                   COOKIE_PREFIX, FILENAME_PREFIX, GAME_VERSION_ACTUAL);
 104
 105   InitSetup();
 106   InitPlayerInfo();
 107   InitArtworkInfo();            /* needed before loading gfx, sound & music */
 108   InitArtworkConfig();          /* needed before forking sound child process */
 109   InitMixer();
 110
 111   InitCounter();
 112
 113   InitJoysticks();
 114   InitRND(NEW_RANDOMIZE);
 115
 116   InitVideoDisplay();
 117   InitVideoBuffer(&backbuffer, &window, WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH,
 118                   setup.fullscreen);
 119
 120   InitEventFilter(FilterMouseMotionEvents);
 121
 122   InitElementProperties();
 123
 124   InitGfx();
 125
 126   InitLevelInfo();
 127   InitLevelArtworkInfo();
 128
 129   InitImages();                 /* needs to know current level directory */
 130   InitSound();                  /* needs to know current level directory */
 131   InitMusic();                  /* needs to know current level directory */
 132
 133   InitGfxBackground();
 134
 135   if (global.autoplay_leveldir)
 136   {
 137     AutoPlayTape();
 138     return;
 139   }
 140
 141   DrawMainMenu();
 142
 143   InitNetworkServer();
 144 }
 145
 146 static void InitGlobal()
 147 {
 148   global.autoplay_leveldir = NULL;
 149
 150   global.frames_per_second = 0;
 151   global.fps_slowdown = FALSE;
 152   global.fps_slowdown_factor = 1;
 153 }
 154
 155 static void InitSetup()
 156 {
 157   LoadSetup();                                  /* global setup info */
 158 }
 159
 160 static void InitPlayerInfo()
 161 {
 162   int i;
 163
 164   /* choose default local player */
 165   local_player = &stored_player[0];
 166
 167   for (i=0; i<MAX_PLAYERS; i++)
 168     stored_player[i].connected = FALSE;
 169
 170   local_player->connected = TRUE;
 171 }
 172
 173 static void InitLevelInfo()
 174 {
 175   LoadLevelInfo();                              /* global level info */
 176   LoadLevelSetup_LastSeries();                  /* last played series info */
 177   LoadLevelSetup_SeriesInfo();                  /* last played level info */
 178 }
 179
 180 static void InitArtworkInfo()
 181 {
 182   LoadArtworkInfo();
 183 }
 184
 185 static void InitArtworkConfig()
 186 {
 187   static char *element_prefix[MAX_NUM_ELEMENTS + 1];
 188   static char *sound_class_prefix[MAX_NUM_ELEMENTS + 1];
 189   static char *action_suffix[NUM_ACTIONS + 1];
 190   static char *direction_suffix[NUM_DIRECTIONS + 1];
 191   static char *dummy[1] = { NULL };
 192   int i;
 193
 194   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 195     element_info[i].custom_description = NULL;
 196
 197   for (i=0; i<MAX_NUM_ELEMENTS + 1; i++)
 198     element_prefix[i] = element_info[i].token_name;
 199   for (i=0; i<MAX_NUM_ELEMENTS + 1; i++)
 200     sound_class_prefix[i] = element_info[i].sound_class_name;
 201   for (i=0; i<NUM_ACTIONS + 1; i++)
 202     action_suffix[i] = element_action_info[i].suffix;
 203   for (i=0; i<NUM_DIRECTIONS + 1; i++)
 204     direction_suffix[i] = element_direction_info[i].suffix;
 205
 206   InitImageList(image_config, NUM_IMAGE_FILES, image_config_suffix,
 207                 element_prefix, action_suffix, direction_suffix);
 208   InitSoundList(sound_config, NUM_SOUND_FILES, sound_config_suffix,
 209                 sound_class_prefix, action_suffix, dummy);
 210 }
 211
 212 void InitLevelArtworkInfo()
 213 {
 214   LoadLevelArtworkInfo();
 215 }
 216
 217 void InitNetworkServer()
 218 {
 219 #if defined(PLATFORM_UNIX)
 220   int nr_wanted;
 221 #endif
 222
 223   if (!options.network)
 224     return;
 225
 226 #if defined(PLATFORM_UNIX)
 227   nr_wanted = Request("Choose player", REQ_PLAYER | REQ_STAY_CLOSED);
 228
 229   if (!ConnectToServer(options.server_host, options.server_port))
 230     Error(ERR_EXIT, "cannot connect to network game server");
 231
 232   SendToServer_PlayerName(setup.player_name);
 233   SendToServer_ProtocolVersion();
 234
 235   if (nr_wanted)
 236     SendToServer_NrWanted(nr_wanted);
 237 #endif
 238 }
 239
 240 static void InitMixer()
 241 {
 242   OpenAudio();
 243   StartMixer();
 244 }
 245
 246 static void ReinitializeGraphics()
 247 {
 248   InitElementGraphicInfo();     /* initialize element/graphic config info */
 249   InitGraphicInfo();            /* initialize graphic info from config file */
 250
 251   InitFontInfo(bitmap_font_initial,
 252                graphic_info[IMG_FONT_BIG].bitmap,
 253                graphic_info[IMG_FONT_MEDIUM].bitmap,
 254                graphic_info[IMG_FONT_SMALL].bitmap,
 255                graphic_info[IMG_FONT_EM].bitmap);
 256
 257   SetMainBackgroundImage(IMG_BACKGROUND_DEFAULT);
 258   SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
 259
 260   InitGadgets();
 261   InitToons();
 262
 263
 264
 265   /* !!! TEST ONLY !!! */
 266
 267 #ifdef TARGET_SDL
 268
 269   {
 270     Bitmap tmp_bitmap;
 271     SDL_Surface *dst = SDLZoomSurface(graphic_info[IMG_SAND].bitmap->surface,
 272                                       0.5, 0.5);
 273     tmp_bitmap.surface = dst;
 274
 275     BlitBitmap(&tmp_bitmap, graphic_info[IMG_SAND].bitmap,
 276                0, 0, 256, 224, 0, 448);
 277
 278     SDL_FreeSurface(dst);
 279   }
 280
 281 #elif defined(PLATFORM_MSDOS)
 282
 283   stretch_blit((BITMAP *)(graphic_info[IMG_SAND].bitmap->drawable),
 284                (BITMAP *)(graphic_info[IMG_SAND].bitmap->drawable),
 285                0, 0, 512, 448,
 286                0, 448, 256, 224);
 287
 288 #endif
 289 }
 290
 291 static void ReinitializeSounds()
 292 {
 293   InitElementSoundInfo();       /* initialize element/sound config info */
 294   InitSoundInfo();              /* initialize sounds info from config file */
 295
 296   InitPlaySoundLevel();         /* initialize internal game sound values */
 297 }
 298
 299 static void ReinitializeMusic()
 300 {
 301   /* currently nothing to do */
 302 }
 303
 304 static void InitImages()
 305 {
 306   ReloadCustomImages();
 307   ReinitializeGraphics();
 308
 309   LoadCustomElementDescriptions();
 310 }
 311
 312 static void InitSound()
 313 {
 314   InitReloadCustomSounds(artwork.snd_current->identifier);
 315   ReinitializeSounds();
 316 }
 317
 318 static void InitMusic()
 319 {
 320   InitReloadCustomMusic(artwork.mus_current->identifier);
 321   ReinitializeMusic();
 322 }
 323
 324 static void InitTileClipmasks()
 325 {
 326 #if 0
 327 #if defined(TARGET_X11)
 328   XGCValues clip_gc_values;
 329   unsigned long clip_gc_valuemask;
 330
 331 #if defined(TARGET_X11_NATIVE)
 332
 333 #if 0
 334   GC copy_clipmask_gc;
 335
 336   static struct
 337   {
 338     int start;
 339     int count;
 340   }
 341   tile_needs_clipping[] =
 342   {
 343     { GFX_SPIELER1_UP, 4 },
 344     { GFX_SPIELER1_DOWN, 4 },
 345     { GFX_SPIELER1_LEFT, 4 },
 346     { GFX_SPIELER1_RIGHT, 4 },
 347     { GFX_SPIELER1_PUSH_LEFT, 4 },
 348     { GFX_SPIELER1_PUSH_RIGHT, 4 },
 349     { GFX_SPIELER2_UP, 4 },
 350     { GFX_SPIELER2_DOWN, 4 },
 351     { GFX_SPIELER2_LEFT, 4 },
 352     { GFX_SPIELER2_RIGHT, 4 },
 353     { GFX_SPIELER2_PUSH_LEFT, 4 },
 354     { GFX_SPIELER2_PUSH_RIGHT, 4 },
 355     { GFX_SPIELER3_UP, 4 },
 356     { GFX_SPIELER3_DOWN, 4 },
 357     { GFX_SPIELER3_LEFT, 4 },
 358     { GFX_SPIELER3_RIGHT, 4 },
 359     { GFX_SPIELER3_PUSH_LEFT, 4 },
 360     { GFX_SPIELER3_PUSH_RIGHT, 4 },
 361     { GFX_SPIELER4_UP, 4 },
 362     { GFX_SPIELER4_DOWN, 4 },
 363     { GFX_SPIELER4_LEFT, 4 },
 364     { GFX_SPIELER4_RIGHT, 4 },
 365     { GFX_SPIELER4_PUSH_LEFT, 4 },
 366     { GFX_SPIELER4_PUSH_RIGHT, 4 },
 367     { GFX_SP_MURPHY, 1 },
 368     { GFX_MURPHY_GO_LEFT, 3 },
 369     { GFX_MURPHY_GO_RIGHT, 3 },
 370     { GFX_MURPHY_SNAP_UP, 1 },
 371     { GFX_MURPHY_SNAP_DOWN, 1 },
 372     { GFX_MURPHY_SNAP_RIGHT, 1 },
 373     { GFX_MURPHY_SNAP_LEFT, 1 },
 374     { GFX_MURPHY_PUSH_RIGHT, 1 },
 375     { GFX_MURPHY_PUSH_LEFT, 1 },
 376     { GFX_GEBLUBBER, 4 },
 377     { GFX_DYNAMIT, 7 },
 378     { GFX_DYNABOMB, 4 },
 379     { GFX_EXPLOSION, 8 },
 380     { GFX_SOKOBAN_OBJEKT, 1 },
 381     { GFX_FUNKELN_BLAU, 3 },
 382     { GFX_FUNKELN_WEISS, 3 },
 383     { GFX2_SHIELD_PASSIVE, 3 },
 384     { GFX2_SHIELD_ACTIVE, 3 },
 385     { -1, 0 }
 386   };
 387 #endif
 388
 389 #endif /* TARGET_X11_NATIVE */
 390 #endif /* TARGET_X11 */
 391
 392   int i;
 393
 394   /* initialize pixmap array for special X11 tile clipping to Pixmap 'None' */
 395   for (i=0; i<NUM_TILES; i++)
 396     tile_clipmask[i] = None;
 397
 398 #if defined(TARGET_X11)
 399   /* This stuff is needed because X11 (XSetClipOrigin(), to be precise) is
 400      often very slow when preparing a masked XCopyArea() for big Pixmaps.
 401      To prevent this, create small (tile-sized) mask Pixmaps which will then
 402      be set much faster with XSetClipOrigin() and speed things up a lot. */
 403
 404   clip_gc_values.graphics_exposures = False;
 405   clip_gc_valuemask = GCGraphicsExposures;
 406   tile_clip_gc = XCreateGC(display, window->drawable,
 407                            clip_gc_valuemask, &clip_gc_values);
 408
 409 #if 0
 410   for (i=0; i<NUM_BITMAPS; i++)
 411   {
 412     if (pix[i]->clip_mask)
 413     {
 414       clip_gc_values.graphics_exposures = False;
 415       clip_gc_values.clip_mask = pix[i]->clip_mask;
 416       clip_gc_valuemask = GCGraphicsExposures | GCClipMask;
 417       pix[i]->stored_clip_gc = XCreateGC(display, window->drawable,
 418                                          clip_gc_valuemask, &clip_gc_values);
 419     }
 420   }
 421 #endif
 422
 423 #if defined(TARGET_X11_NATIVE)
 424
 425 #if 0
 426   /* create graphic context structures needed for clipping */
 427   clip_gc_values.graphics_exposures = False;
 428   clip_gc_valuemask = GCGraphicsExposures;
 429   copy_clipmask_gc = XCreateGC(display, pix[PIX_BACK]->clip_mask,
 430                                clip_gc_valuemask, &clip_gc_values);
 431
 432   /* create only those clipping Pixmaps we really need */
 433   for (i=0; tile_needs_clipping[i].start>=0; i++)
 434   {
 435     int j;
 436
 437     for (j=0; j<tile_needs_clipping[i].count; j++)
 438     {
 439       int tile = tile_needs_clipping[i].start + j;
 440       int graphic = tile;
 441       int src_x, src_y;
 442       Bitmap *src_bitmap;
 443       Pixmap src_pixmap;
 444
 445       getGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
 446       src_pixmap = src_bitmap->clip_mask;
 447
 448       tile_clipmask[tile] = XCreatePixmap(display, window->drawable,
 449                                           TILEX, TILEY, 1);
 450
 451       XCopyArea(display, src_pixmap, tile_clipmask[tile], copy_clipmask_gc,
 452                 src_x, src_y, TILEX, TILEY, 0, 0);
 453     }
 454   }
 455
 456   XFreeGC(display, copy_clipmask_gc);
 457 #endif
 458
 459 #endif /* TARGET_X11_NATIVE */
 460 #endif /* TARGET_X11 */
 461 #endif
 462 }
 463
 464 void FreeTileClipmasks()
 465 {
 466 #if 0
 467 #if defined(TARGET_X11)
 468   int i;
 469
 470   for (i=0; i<NUM_TILES; i++)
 471   {
 472     if (tile_clipmask[i] != None)
 473     {
 474       XFreePixmap(display, tile_clipmask[i]);
 475       tile_clipmask[i] = None;
 476     }
 477   }
 478
 479   if (tile_clip_gc)
 480     XFreeGC(display, tile_clip_gc);
 481   tile_clip_gc = None;
 482
 483 #if 0
 484   for (i=0; i<NUM_BITMAPS; i++)
 485   {
 486     if (pix[i] != NULL && pix[i]->stored_clip_gc)
 487     {
 488       XFreeGC(display, pix[i]->stored_clip_gc);
 489       pix[i]->stored_clip_gc = None;
 490     }
 491   }
 492 #endif
 493
 494 #endif /* TARGET_X11 */
 495 #endif
 496 }
 497
 498 void InitGfx()
 499 {
 500 #if 0
 501   int i;
 502 #endif
 503
 504   /* initialize screen properties */
 505   InitGfxFieldInfo(SX, SY, SXSIZE, SYSIZE,
 506                    REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
 507   InitGfxDoor1Info(DX, DY, DXSIZE, DYSIZE);
 508   InitGfxDoor2Info(VX, VY, VXSIZE, VYSIZE);
 509   InitGfxScrollbufferInfo(FXSIZE, FYSIZE);
 510
 511   /* create additional image buffers for double-buffering */
 512   bitmap_db_field = CreateBitmap(FXSIZE, FYSIZE, DEFAULT_DEPTH);
 513   bitmap_db_door  = CreateBitmap(3 * DXSIZE, DYSIZE + VYSIZE, DEFAULT_DEPTH);
 514
 515 #if 0
 516   pix[PIX_FONT_SMALL] = LoadCustomImage(image_filename[PIX_FONT_SMALL]);
 517
 518   InitFontInfo(NULL, NULL, pix[PIX_FONT_SMALL], NULL);
 519 #else
 520   bitmap_font_initial = LoadCustomImage(image_filename[PIX_FONT_SMALL]);
 521
 522   InitFontInfo(bitmap_font_initial, NULL, NULL, NULL, NULL);
 523 #endif
 524
 525   DrawInitText(WINDOW_TITLE_STRING, 20, FC_YELLOW);
 526   DrawInitText(WINDOW_SUBTITLE_STRING, 50, FC_RED);
 527
 528   DrawInitText("Loading graphics:", 120, FC_GREEN);
 529
 530 #if 0
 531   for (i=0; i<NUM_PICTURES; i++)
 532   {
 533 #if 0
 534     if (i != PIX_FONT_SMALL)
 535 #endif
 536     {
 537       DrawInitText(image_filename[i], 150, FC_YELLOW);
 538
 539       pix[i] = LoadCustomImage(image_filename[i]);
 540     }
 541   }
 542 #endif
 543
 544 #if 0
 545   InitFontInfo(pix[PIX_FONT_BIG], pix[PIX_FONT_MEDIUM], pix[PIX_FONT_SMALL],
 546                pix[PIX_FONT_EM]);
 547 #endif
 548
 549   InitTileClipmasks();
 550 }
 551
 552 void InitGfxBackground()
 553 {
 554   int x, y;
 555
 556   drawto = backbuffer;
 557   fieldbuffer = bitmap_db_field;
 558   SetDrawtoField(DRAW_BACKBUFFER);
 559
 560   BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, backbuffer,
 561              0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
 562   ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
 563   ClearRectangle(bitmap_db_door, 0, 0, 3 * DXSIZE, DYSIZE + VYSIZE);
 564
 565   for (x=0; x<MAX_BUF_XSIZE; x++)
 566     for (y=0; y<MAX_BUF_YSIZE; y++)
 567       redraw[x][y] = 0;
 568   redraw_tiles = 0;
 569   redraw_mask = REDRAW_ALL;
 570 }
 571
 572 void ReloadCustomArtwork()
 573 {
 574   static char *leveldir_current_identifier = NULL;
 575   static boolean last_override_level_graphics = FALSE;
 576   static boolean last_override_level_sounds = FALSE;
 577   static boolean last_override_level_music = FALSE;
 578   /* identifier for new artwork; default: artwork configured in setup */
 579   char *gfx_new_identifier = artwork.gfx_current->identifier;
 580   char *snd_new_identifier = artwork.snd_current->identifier;
 581   char *mus_new_identifier = artwork.mus_current->identifier;
 582   boolean redraw_screen = FALSE;
 583
 584   if (leveldir_current_identifier == NULL)
 585     leveldir_current_identifier = leveldir_current->identifier;
 586
 587 #if 0
 588   printf("CURRENT GFX: '%s' ['%s']\n", artwork.gfx_current->identifier,
 589          leveldir_current->graphics_set);
 590   printf("CURRENT LEV: '%s' / '%s'\n", leveldir_current_identifier,
 591          leveldir_current->identifier);
 592 #endif
 593
 594 #if 0
 595   printf("graphics --> '%s' ('%s')\n",
 596          artwork.gfx_current_identifier, artwork.gfx_current->filename);
 597   printf("sounds   --> '%s' ('%s')\n",
 598          artwork.snd_current_identifier, artwork.snd_current->filename);
 599   printf("music    --> '%s' ('%s')\n",
 600          artwork.mus_current_identifier, artwork.mus_current->filename);
 601 #endif
 602
 603   /* leveldir_current may be invalid (level group, parent link) */
 604   if (!validLevelSeries(leveldir_current))
 605     return;
 606
 607   /* when a new level series was selected, check if there was a change
 608      in custom artwork stored in level series directory */
 609   if (leveldir_current_identifier != leveldir_current->identifier)
 610   {
 611     char *identifier_old = leveldir_current_identifier;
 612     char *identifier_new = leveldir_current->identifier;
 613
 614     if (getTreeInfoFromIdentifier(artwork.gfx_first, identifier_old) !=
 615         getTreeInfoFromIdentifier(artwork.gfx_first, identifier_new))
 616       gfx_new_identifier = identifier_new;
 617     if (getTreeInfoFromIdentifier(artwork.snd_first, identifier_old) !=
 618         getTreeInfoFromIdentifier(artwork.snd_first, identifier_new))
 619       snd_new_identifier = identifier_new;
 620     if (getTreeInfoFromIdentifier(artwork.mus_first, identifier_new) !=
 621         getTreeInfoFromIdentifier(artwork.mus_first, identifier_new))
 622       mus_new_identifier = identifier_new;
 623
 624     leveldir_current_identifier = leveldir_current->identifier;
 625   }
 626
 627   /* custom level artwork configured in level series configuration file
 628      always overrides custom level artwork stored in level series directory
 629      and (level independant) custom artwork configured in setup menue */
 630   if (leveldir_current->graphics_set != NULL)
 631     gfx_new_identifier = leveldir_current->graphics_set;
 632   if (leveldir_current->sounds_set != NULL)
 633     snd_new_identifier = leveldir_current->sounds_set;
 634   if (leveldir_current->music_set != NULL)
 635     mus_new_identifier = leveldir_current->music_set;
 636
 637   if (strcmp(artwork.gfx_current_identifier, gfx_new_identifier) != 0 ||
 638       last_override_level_graphics != setup.override_level_graphics)
 639   {
 640 #if 0
 641     printf("RELOADING GRAPHICS '%s' -> '%s' ('%s')\n",
 642            artwork.gfx_current_identifier,
 643            artwork.gfx_current->identifier,
 644            gfx_new_identifier);
 645 #endif
 646
 647     setLevelArtworkDir(artwork.gfx_first);
 648
 649     ClearRectangle(window, 0, 0, WIN_XSIZE, WIN_YSIZE);
 650
 651     ReloadCustomImages();
 652     ReinitializeGraphics();
 653
 654     LoadCustomElementDescriptions();
 655
 656     FreeTileClipmasks();
 657     InitTileClipmasks();
 658
 659     artwork.gfx_current_identifier = artwork.gfx_current->identifier;
 660     last_override_level_graphics = setup.override_level_graphics;
 661
 662     redraw_screen = TRUE;
 663   }
 664
 665   if (strcmp(artwork.snd_current_identifier, snd_new_identifier) != 0 ||
 666       last_override_level_sounds != setup.override_level_sounds)
 667   {
 668 #if 0
 669     printf("RELOADING SOUNDS '%s' -> '%s' ('%s')\n",
 670            artwork.snd_current_identifier,
 671            artwork.snd_current->identifier,
 672            snd_new_identifier);
 673 #endif
 674
 675     /* set artwork path to send it to the sound server process */
 676     setLevelArtworkDir(artwork.snd_first);
 677
 678     InitReloadCustomSounds(snd_new_identifier);
 679     ReinitializeSounds();
 680
 681     artwork.snd_current_identifier = artwork.snd_current->identifier;
 682     last_override_level_sounds = setup.override_level_sounds;
 683
 684     redraw_screen = TRUE;
 685   }
 686
 687   if (strcmp(artwork.mus_current_identifier, mus_new_identifier) != 0 ||
 688       last_override_level_music != setup.override_level_music)
 689   {
 690     /* set artwork path to send it to the sound server process */
 691     setLevelArtworkDir(artwork.mus_first);
 692
 693     InitReloadCustomMusic(mus_new_identifier);
 694     ReinitializeMusic();
 695
 696     artwork.mus_current_identifier = artwork.mus_current->identifier;
 697     last_override_level_music = setup.override_level_music;
 698
 699     redraw_screen = TRUE;
 700   }
 701
 702   if (redraw_screen)
 703   {
 704     InitGfxBackground();
 705
 706     /* force redraw of (open or closed) door graphics */
 707     SetDoorState(DOOR_OPEN_ALL);
 708     CloseDoor(DOOR_CLOSE_ALL | DOOR_NO_DELAY);
 709   }
 710 }
 711
 712 void FreeGadgets()
 713 {
 714   FreeLevelEditorGadgets();
 715   FreeGameButtons();
 716   FreeTapeButtons();
 717   FreeToolButtons();
 718   FreeScreenGadgets();
 719 }
 720
 721 void InitGadgets()
 722 {
 723   static boolean gadgets_initialized = FALSE;
 724
 725   if (gadgets_initialized)
 726     FreeGadgets();
 727
 728   CreateLevelEditorGadgets();
 729   CreateGameButtons();
 730   CreateTapeButtons();
 731   CreateToolButtons();
 732   CreateScreenGadgets();
 733
 734   gadgets_initialized = TRUE;
 735 }
 736
 737 void InitElementGraphicInfo()
 738 {
 739   struct PropertyMapping *property_mapping = getImageListPropertyMapping();
 740   int num_property_mappings = getImageListPropertyMappingSize();
 741   int i, act, dir;
 742
 743   /* set values to -1 to identify later as "uninitialized" values */
 744   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 745   {
 746     for (act=0; act<NUM_ACTIONS; act++)
 747     {
 748       element_info[i].graphic[act] = -1;
 749
 750       for (dir=0; dir<NUM_DIRECTIONS; dir++)
 751         element_info[i].direction_graphic[act][dir] = -1;
 752     }
 753   }
 754
 755   for (i=EL_CHAR_START; i<=EL_CHAR_END; i++)
 756     element_info[i].graphic[ACTION_DEFAULT] =
 757       IMG_CHAR_START + (i - EL_CHAR_START);
 758
 759   for (i=EL_CUSTOM_START; i<=EL_CUSTOM_END; i++)
 760     element_info[i].graphic[ACTION_DEFAULT] =
 761       IMG_CUSTOM_START + (i - EL_CUSTOM_START);
 762
 763   /* initialize element/graphic mapping from static configuration */
 764   for (i=0; element_to_graphic[i].element > -1; i++)
 765   {
 766     int element   = element_to_graphic[i].element;
 767     int action    = element_to_graphic[i].action;
 768     int direction = element_to_graphic[i].direction;
 769     int graphic   = element_to_graphic[i].graphic;
 770
 771     if (action < 0)
 772       action = ACTION_DEFAULT;
 773
 774     if (direction > -1)
 775       element_info[element].direction_graphic[action][direction] = graphic;
 776     else
 777       element_info[element].graphic[action] = graphic;
 778   }
 779
 780   /* initialize element/graphic mapping from dynamic configuration */
 781   for (i=0; i < num_property_mappings; i++)
 782   {
 783     int element   = property_mapping[i].base_index;
 784     int action    = property_mapping[i].ext1_index;
 785     int direction = property_mapping[i].ext2_index;
 786     int graphic   = property_mapping[i].artwork_index;
 787
 788     if (action < 0)
 789       action = ACTION_DEFAULT;
 790
 791     if (direction > -1)
 792       element_info[element].direction_graphic[action][direction] = graphic;
 793     else
 794       element_info[element].graphic[action] = graphic;
 795   }
 796
 797   /* now set all '-1' values to element specific default values */
 798   for (i=0; i<MAX_NUM_ELEMENTS; i++)
 799   {
 800     int default_action_graphic = element_info[i].graphic[ACTION_DEFAULT];
 801     int default_action_direction_graphic[NUM_DIRECTIONS];
 802
 803     if (default_action_graphic == -1)
 804       default_action_graphic = IMG_CHAR_QUESTION;
 805
 806     for (dir=0; dir<NUM_DIRECTIONS; dir++)
 807     {
 808       default_action_direction_graphic[dir] =
 809         element_info[i].direction_graphic[ACTION_DEFAULT][dir];
 810
 811       if (default_action_direction_graphic[dir] == -1)
 812         default_action_direction_graphic[dir] = default_action_graphic;
 813     }
 814
 815     for (act=0; act<NUM_ACTIONS; act++)
 816     {
 817       for (dir=0; dir<NUM_DIRECTIONS; dir++)
 818       {
 819         int default_direction_graphic = element_info[i].graphic[act];
 820
 821         /* no graphic for current action -- use default direction graphic */
 822         if (default_direction_graphic == -1)
 823           default_direction_graphic = default_action_direction_graphic[dir];
 824
 825         if (element_info[i].direction_graphic[act][dir] == -1)
 826           element_info[i].direction_graphic[act][dir] =
 827             default_direction_graphic;
 828       }
 829
 830       /* no graphic for this specific action -- use default action graphic */
 831       if (element_info[i].graphic[act] == -1)
 832         element_info[i].graphic[act] = default_action_graphic;
 833     }
 834   }
 835 }
 836
 837 static void InitElementSoundInfo()
 838 {
 839   /* soon to come */
 840 }
 841
 842 static void set_graphic_parameters(int graphic, int *parameter)
 843 {
 844   Bitmap *src_bitmap = getBitmapFromImageID(graphic);
 845   int num_xtiles = (src_bitmap ? src_bitmap->width          : TILEX) / TILEX;
 846   int num_ytiles = (src_bitmap ? src_bitmap->height * 2 / 3 : TILEY) / TILEY;
 847
 848   graphic_info[graphic].bitmap = src_bitmap;
 849
 850   graphic_info[graphic].src_x = parameter[GFX_ARG_XPOS] * TILEX;
 851   graphic_info[graphic].src_y = parameter[GFX_ARG_YPOS] * TILEY;
 852   graphic_info[graphic].offset_x = parameter[GFX_ARG_OFFSET];
 853   graphic_info[graphic].offset_y = 0;
 854
 855   /* animation frames are ordered vertically instead of horizontally */
 856   if (parameter[GFX_ARG_VERTICAL])
 857   {
 858     graphic_info[graphic].offset_x = 0;
 859     graphic_info[graphic].offset_y = parameter[GFX_ARG_OFFSET];
 860   }
 861
 862   /* optionally, the x and y offset of frames can be specified directly */
 863   if (parameter[GFX_ARG_XOFFSET] != ARG_UNDEFINED_VALUE)
 864     graphic_info[graphic].offset_x = parameter[GFX_ARG_XOFFSET];
 865   if (parameter[GFX_ARG_YOFFSET] != ARG_UNDEFINED_VALUE)
 866     graphic_info[graphic].offset_y = parameter[GFX_ARG_YOFFSET];
 867
 868   /* automatically determine correct number of frames, if not defined */
 869   if (parameter[GFX_ARG_FRAMES] != ARG_UNDEFINED_VALUE)
 870     graphic_info[graphic].anim_frames = parameter[GFX_ARG_FRAMES];
 871   else if (parameter[GFX_ARG_XPOS] == 0 && !parameter[GFX_ARG_VERTICAL])
 872     graphic_info[graphic].anim_frames = num_xtiles;
 873   else if (parameter[GFX_ARG_YPOS] == 0 && parameter[GFX_ARG_VERTICAL])
 874     graphic_info[graphic].anim_frames = num_ytiles;
 875   else
 876     graphic_info[graphic].anim_frames = 1;
 877
 878   graphic_info[graphic].anim_delay = parameter[GFX_ARG_DELAY];
 879   if (graphic_info[graphic].anim_delay == 0)    /* delay must be at least 1 */
 880     graphic_info[graphic].anim_delay = 1;
 881
 882   /* set mode for animation frame order */
 883   if (parameter[GFX_ARG_MODE_LOOP])
 884     graphic_info[graphic].anim_mode = ANIM_LOOP;
 885   else if (parameter[GFX_ARG_MODE_LINEAR])
 886     graphic_info[graphic].anim_mode = ANIM_LINEAR;
 887   else if (parameter[GFX_ARG_MODE_PINGPONG])
 888     graphic_info[graphic].anim_mode = ANIM_PINGPONG;
 889   else if (parameter[GFX_ARG_MODE_PINGPONG2])
 890     graphic_info[graphic].anim_mode = ANIM_PINGPONG2;
 891   else if (parameter[GFX_ARG_MODE_RANDOM])
 892     graphic_info[graphic].anim_mode = ANIM_RANDOM;
 893   else if (graphic_info[graphic].anim_frames > 1)
 894     graphic_info[graphic].anim_mode = ANIM_LOOP;
 895   else
 896     graphic_info[graphic].anim_mode = ANIM_NONE;
 897
 898   /* set additional flag to play animation frames in reverse order */
 899   if (parameter[GFX_ARG_MODE_REVERSE])
 900     graphic_info[graphic].anim_mode |= ANIM_REVERSE;
 901
 902   /* automatically determine correct start frame, if not defined */
 903   if (parameter[GFX_ARG_START_FRAME] == ARG_UNDEFINED_VALUE)
 904     graphic_info[graphic].anim_start_frame = 0;
 905   else if (graphic_info[graphic].anim_mode & ANIM_REVERSE)
 906     graphic_info[graphic].anim_start_frame =
 907       graphic_info[graphic].anim_frames - parameter[GFX_ARG_START_FRAME] - 1;
 908   else
 909     graphic_info[graphic].anim_start_frame = parameter[GFX_ARG_START_FRAME];
 910
 911   /* animation synchronized with global frame counter, not move position */
 912   graphic_info[graphic].anim_global_sync = parameter[GFX_ARG_GLOBAL_SYNC];
 913 }
 914
 915 static void InitGraphicInfo()
 916 {
 917   static boolean clipmasks_initialized = FALSE;
 918   int num_images = getImageListSize();
 919   int i;
 920 #if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
 921   Pixmap src_pixmap;
 922   XGCValues clip_gc_values;
 923   unsigned long clip_gc_valuemask;
 924   GC copy_clipmask_gc = None;
 925 #endif
 926
 927   if (graphic_info != NULL)
 928     free(graphic_info);
 929
 930   graphic_info = checked_calloc(num_images * sizeof(struct GraphicInfo));
 931
 932 #if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
 933   if (clipmasks_initialized)
 934   {
 935     for (i=0; i<num_images; i++)
 936     {
 937       if (graphic_info[i].clip_mask)
 938         XFreePixmap(display, graphic_info[i].clip_mask);
 939       if (graphic_info[i].clip_gc)
 940         XFreeGC(display, graphic_info[i].clip_gc);
 941
 942       graphic_info[i].clip_mask = None;
 943       graphic_info[i].clip_gc = None;
 944     }
 945   }
 946 #endif
 947
 948   for (i=0; i<num_images; i++)
 949   {
 950     struct FileInfo *image = getImageListEntry(i);
 951     Bitmap *src_bitmap;
 952     int src_x, src_y;
 953     int first_frame, last_frame;
 954
 955     set_graphic_parameters(i, image->parameter);
 956
 957     /* now check if no animation frames are outside of the loaded image */
 958
 959     if (graphic_info[i].bitmap == NULL)
 960       continue;         /* skip check for optional images that are undefined */
 961
 962     first_frame = 0;
 963     getGraphicSource(i, first_frame, &src_bitmap, &src_x, &src_y);
 964     if (src_x < 0 || src_y < 0 ||
 965         src_x + TILEX > src_bitmap->width ||
 966         src_y + TILEY > src_bitmap->height)
 967     {
 968       Error(ERR_RETURN_LINE, "-");
 969       Error(ERR_RETURN, "warning: error found in config file:");
 970       Error(ERR_RETURN, "- config file: '%s'",
 971             getImageConfigFilename());
 972       Error(ERR_RETURN, "- config token: '%s'",
 973             getTokenFromImageID(i));
 974       Error(ERR_RETURN, "- image file: '%s'",
 975             src_bitmap->source_filename);
 976       Error(ERR_RETURN,
 977             "error: first animation frame out of bounds (%d, %d)",
 978             src_x, src_y);
 979       Error(ERR_RETURN, "custom graphic rejected for this element/action");
 980       Error(ERR_RETURN_LINE, "-");
 981
 982       set_graphic_parameters(i, image->default_parameter);
 983     }
 984
 985     last_frame = graphic_info[i].anim_frames - 1;
 986     getGraphicSource(i, last_frame, &src_bitmap, &src_x, &src_y);
 987     if (src_x < 0 || src_y < 0 ||
 988         src_x + TILEX > src_bitmap->width ||
 989         src_y + TILEY > src_bitmap->height)
 990     {
 991       Error(ERR_RETURN_LINE, "-");
 992       Error(ERR_RETURN, "warning: error found in config file:");
 993       Error(ERR_RETURN, "- config file: '%s'",
 994             getImageConfigFilename());
 995       Error(ERR_RETURN, "- config token: '%s'",
 996             getTokenFromImageID(i));
 997       Error(ERR_RETURN, "- image file: '%s'",
 998             src_bitmap->source_filename);
 999       Error(ERR_RETURN,
1000             "error: last animation frame (%d) out of bounds (%d, %d)",
1001             last_frame, src_x, src_y);
1002       Error(ERR_RETURN, "custom graphic rejected for this element/action");
1003       Error(ERR_RETURN_LINE, "-");
1004
1005       set_graphic_parameters(i, image->default_parameter);
1006     }
1007
1008 #if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
1009     /* currently we need only a tile clip mask from the first frame */
1010     getGraphicSource(i, first_frame, &src_bitmap, &src_x, &src_y);
1011
1012     if (copy_clipmask_gc == None)
1013     {
1014       clip_gc_values.graphics_exposures = False;
1015       clip_gc_valuemask = GCGraphicsExposures;
1016       copy_clipmask_gc = XCreateGC(display, src_bitmap->clip_mask,
1017                                    clip_gc_valuemask, &clip_gc_values);
1018     }
1019
1020     graphic_info[i].clip_mask =
1021       XCreatePixmap(display, window->drawable, TILEX, TILEY, 1);
1022
1023     src_pixmap = src_bitmap->clip_mask;
1024     XCopyArea(display, src_pixmap, graphic_info[i].clip_mask,
1025               copy_clipmask_gc, src_x, src_y, TILEX, TILEY, 0, 0);
1026
1027     clip_gc_values.graphics_exposures = False;
1028     clip_gc_values.clip_mask = graphic_info[i].clip_mask;
1029     clip_gc_valuemask = GCGraphicsExposures | GCClipMask;
1030     graphic_info[i].clip_gc =
1031       XCreateGC(display, window->drawable, clip_gc_valuemask, &clip_gc_values);
1032 #endif
1033   }
1034
1035 #if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
1036   if (copy_clipmask_gc)
1037     XFreeGC(display, copy_clipmask_gc);
1038 #endif
1039
1040   clipmasks_initialized = TRUE;
1041 }
1042
1043 static void set_sound_parameters(int sound, int *parameter)
1044 {
1045   /* explicit loop mode setting in configuration overrides default value */
1046   if (parameter[SND_ARG_MODE_LOOP] != ARG_UNDEFINED_VALUE)
1047     sound_info[sound].loop = parameter[SND_ARG_MODE_LOOP];
1048 }
1049
1050 static void InitSoundInfo()
1051 {
1052   int *sound_effect_properties;
1053   int num_sounds = getSoundListSize();
1054   int i, j;
1055
1056   if (sound_info != NULL)
1057     free(sound_info);
1058
1059   sound_effect_properties = checked_calloc(num_sounds * sizeof(int));
1060   sound_info = checked_calloc(num_sounds * sizeof(struct SoundInfo));
1061
1062   /* initialize sound effect for all elements to "no sound" */
1063   for (i=0; i<MAX_NUM_ELEMENTS; i++)
1064     for (j=0; j<NUM_ACTIONS; j++)
1065       element_info[i].sound[j] = SND_UNDEFINED;
1066
1067   for (i=0; i<num_sounds; i++)
1068   {
1069     struct FileInfo *sound = getSoundListEntry(i);
1070     int len_effect_text = strlen(sound->token);
1071
1072     sound_effect_properties[i] = ACTION_OTHER;
1073     sound_info[i].loop = FALSE;
1074
1075     /* determine all loop sounds and identify certain sound classes */
1076
1077     for (j=0; element_action_info[j].suffix; j++)
1078     {
1079       int len_action_text = strlen(element_action_info[j].suffix);
1080
1081       if (len_action_text < len_effect_text &&
1082           strcmp(&sound->token[len_effect_text - len_action_text],
1083                  element_action_info[j].suffix) == 0)
1084       {
1085         sound_effect_properties[i] = element_action_info[j].value;
1086
1087         if (element_action_info[j].is_loop_sound)
1088           sound_info[i].loop = TRUE;
1089       }
1090     }
1091
1092     /* associate elements and some selected sound actions */
1093
1094     for (j=0; j<MAX_NUM_ELEMENTS; j++)
1095     {
1096       if (element_info[j].sound_class_name)
1097       {
1098         int len_class_text = strlen(element_info[j].sound_class_name);
1099
1100         if (len_class_text + 1 < len_effect_text &&
1101             strncmp(sound->token,
1102                     element_info[j].sound_class_name, len_class_text) == 0 &&
1103             sound->token[len_class_text] == '.')
1104         {
1105           int sound_action_value = sound_effect_properties[i];
1106
1107           element_info[j].sound[sound_action_value] = i;
1108         }
1109       }
1110     }
1111
1112     set_sound_parameters(i, sound->parameter);
1113   }
1114
1115   free(sound_effect_properties);
1116
1117 #if 0
1118   /* TEST ONLY */
1119   {
1120     int element = EL_SAND;
1121     int sound_action = ACTION_DIGGING;
1122     int j = 0;
1123
1124     while (element_action_info[j].suffix)
1125     {
1126       if (element_action_info[j].value == sound_action)
1127         printf("element %d, sound action '%s'  == %d\n",
1128                element, element_action_info[j].suffix,
1129                element_info_[element].sound[sound_action]);
1130       j++;
1131     }
1132   }
1133 #endif
1134 }
1135
1136 void InitElementProperties()
1137 {
1138   int i, j;
1139
1140   static int ep_amoebalive[] =
1141   {
1142     EL_AMOEBA_WET,
1143     EL_AMOEBA_DRY,
1144     EL_AMOEBA_FULL,
1145     EL_BD_AMOEBA
1146   };
1147   static int ep_amoebalive_num = SIZEOF_ARRAY_INT(ep_amoebalive);
1148
1149   static int ep_amoeboid[] =
1150   {
1151     EL_AMOEBA_DEAD,
1152     EL_AMOEBA_WET,
1153     EL_AMOEBA_DRY,
1154     EL_AMOEBA_FULL,
1155     EL_BD_AMOEBA
1156   };
1157   static int ep_amoeboid_num = SIZEOF_ARRAY_INT(ep_amoeboid);
1158
1159   static int ep_schluessel[] =
1160   {
1161     EL_KEY1,
1162     EL_KEY2,
1163     EL_KEY3,
1164     EL_KEY4,
1165     EL_EM_KEY1,
1166     EL_EM_KEY2,
1167     EL_EM_KEY3,
1168     EL_EM_KEY4
1169   };
1170   static int ep_schluessel_num = SIZEOF_ARRAY_INT(ep_schluessel);
1171
1172   static int ep_pforte[] =
1173   {
1174     EL_GATE1,
1175     EL_GATE2,
1176     EL_GATE3,
1177     EL_GATE4,
1178     EL_GATE1_GRAY,
1179     EL_GATE2_GRAY,
1180     EL_GATE3_GRAY,
1181     EL_GATE4_GRAY,
1182     EL_EM_GATE1,
1183     EL_EM_GATE2,
1184     EL_EM_GATE3,
1185     EL_EM_GATE4,
1186     EL_EM_GATE1_GRAY,
1187     EL_EM_GATE2_GRAY,
1188     EL_EM_GATE3_GRAY,
1189     EL_EM_GATE4_GRAY,
1190     EL_SWITCHGATE_OPEN,
1191     EL_SWITCHGATE_OPENING,
1192     EL_SWITCHGATE_CLOSED,
1193     EL_SWITCHGATE_CLOSING,
1194     EL_TIMEGATE_OPEN,
1195     EL_TIMEGATE_OPENING,
1196     EL_TIMEGATE_CLOSED,
1197     EL_TIMEGATE_CLOSING,
1198     EL_TUBE_ALL,
1199     EL_TUBE_VERTICAL,
1200     EL_TUBE_HORIZONTAL,
1201     EL_TUBE_VERTICAL_LEFT,
1202     EL_TUBE_VERTICAL_RIGHT,
1203     EL_TUBE_HORIZONTAL_UP,
1204     EL_TUBE_HORIZONTAL_DOWN,
1205     EL_TUBE_LEFT_UP,
1206     EL_TUBE_LEFT_DOWN,
1207     EL_TUBE_RIGHT_UP,
1208     EL_TUBE_RIGHT_DOWN
1209   };
1210   static int ep_pforte_num = SIZEOF_ARRAY_INT(ep_pforte);
1211
1212   static int ep_solid[] =
1213   {
1214     EL_STEELWALL,
1215     EL_WALL,
1216     EL_WALL_GROWING,
1217     EL_WALL_GROWING_X,
1218     EL_WALL_GROWING_Y,
1219     EL_WALL_GROWING_XY,
1220     EL_BD_WALL,
1221     EL_WALL_CRUMBLED,
1222     EL_EXIT_CLOSED,
1223     EL_EXIT_OPENING,
1224     EL_EXIT_OPEN,
1225     EL_AMOEBA_DEAD,
1226     EL_AMOEBA_WET,
1227     EL_AMOEBA_DRY,
1228     EL_AMOEBA_FULL,
1229     EL_BD_AMOEBA,
1230     EL_QUICKSAND_FULL,
1231     EL_QUICKSAND_EMPTY,
1232     EL_QUICKSAND_FILLING,
1233     EL_QUICKSAND_EMPTYING,
1234     EL_MAGIC_WALL,
1235     EL_MAGIC_WALL_ACTIVE,
1236     EL_MAGIC_WALL_EMPTYING,
1237     EL_MAGIC_WALL_FILLING,
1238     EL_MAGIC_WALL_FULL,
1239     EL_MAGIC_WALL_DEAD,
1240     EL_BD_MAGIC_WALL,
1241     EL_BD_MAGIC_WALL_ACTIVE,
1242     EL_BD_MAGIC_WALL_EMPTYING,
1243     EL_BD_MAGIC_WALL_FULL,
1244     EL_BD_MAGIC_WALL_FILLING,
1245     EL_BD_MAGIC_WALL_DEAD,
1246     EL_GAMEOFLIFE,
1247     EL_BIOMAZE,
1248     EL_ACIDPOOL_TOPLEFT,
1249     EL_ACIDPOOL_TOPRIGHT,
1250     EL_ACIDPOOL_BOTTOMLEFT,
1251     EL_ACIDPOOL_BOTTOM,
1252     EL_ACIDPOOL_BOTTOMRIGHT,
1253     EL_SP_CHIP_SINGLE,
1254     EL_SP_CHIP_LEFT,
1255     EL_SP_CHIP_RIGHT,
1256     EL_SP_CHIP_UPPER,
1257     EL_SP_CHIP_LOWER,
1258     EL_SP_HARD_GRAY,
1259     EL_SP_HARD_GREEN,
1260     EL_SP_HARD_BLUE,
1261     EL_SP_HARD_RED,
1262     EL_SP_HARD_YELLOW,
1263     EL_SP_HARD_BASE1,
1264     EL_SP_HARD_BASE2,
1265     EL_SP_HARD_BASE3,
1266     EL_SP_HARD_BASE4,
1267     EL_SP_HARD_BASE5,
1268     EL_SP_HARD_BASE6,
1269     EL_SP_TERMINAL,
1270     EL_SP_TERMINAL_ACTIVE,
1271     EL_SP_EXIT_CLOSED,
1272     EL_SP_EXIT_OPEN,
1273     EL_INVISIBLE_STEELWALL,
1274     EL_INVISIBLE_STEELWALL_ACTIVE,
1275     EL_INVISIBLE_WALL,
1276     EL_INVISIBLE_WALL_ACTIVE,
1277     EL_CONVEYOR_BELT1_SWITCH_LEFT,
1278     EL_CONVEYOR_BELT1_SWITCH_MIDDLE,
1279     EL_CONVEYOR_BELT1_SWITCH_RIGHT,
1280     EL_CONVEYOR_BELT2_SWITCH_LEFT,
1281     EL_CONVEYOR_BELT2_SWITCH_MIDDLE,
1282     EL_CONVEYOR_BELT2_SWITCH_RIGHT,
1283     EL_CONVEYOR_BELT3_SWITCH_LEFT,
1284     EL_CONVEYOR_BELT3_SWITCH_MIDDLE,
1285     EL_CONVEYOR_BELT3_SWITCH_RIGHT,
1286     EL_CONVEYOR_BELT4_SWITCH_LEFT,
1287     EL_CONVEYOR_BELT4_SWITCH_MIDDLE,
1288     EL_CONVEYOR_BELT4_SWITCH_RIGHT,
1289     EL_SWITCHGATE_SWITCH_UP,
1290     EL_SWITCHGATE_SWITCH_DOWN,
1291     EL_LIGHT_SWITCH,
1292     EL_LIGHT_SWITCH_ACTIVE,
1293     EL_TIMEGATE_SWITCH,
1294     EL_TIMEGATE_SWITCH_ACTIVE,
1295     EL_SIGN_EXCLAMATION,
1296     EL_SIGN_RADIOACTIVITY,
1297     EL_SIGN_STOP,
1298     EL_SIGN_WHEELCHAIR,
1299     EL_SIGN_PARKING,
1300     EL_SIGN_ONEWAY,
1301     EL_SIGN_HEART,
1302     EL_SIGN_TRIANGLE,
1303     EL_SIGN_ROUND,
1304     EL_SIGN_EXIT,
1305     EL_SIGN_YINYANG,
1306     EL_SIGN_OTHER,
1307     EL_STEELWALL_SLANTED,
1308     EL_EMC_STEELWALL1,
1309     EL_EMC_STEELWALL2,
1310     EL_EMC_STEELWALL3,
1311     EL_EMC_STEELWALL4,
1312     EL_EMC_WALL_PILLAR_UPPER,
1313     EL_EMC_WALL_PILLAR_MIDDLE,
1314     EL_EMC_WALL_PILLAR_LOWER,
1315     EL_EMC_WALL4,
1316     EL_EMC_WALL5,
1317     EL_EMC_WALL6,
1318     EL_EMC_WALL7,
1319     EL_EMC_WALL8,
1320     EL_CRYSTAL,
1321     EL_WALL_PEARL,
1322     EL_WALL_CRYSTAL,
1323     EL_GATE1,
1324     EL_GATE2,
1325     EL_GATE3,
1326     EL_GATE4,
1327     EL_GATE1_GRAY,
1328     EL_GATE2_GRAY,
1329     EL_GATE3_GRAY,
1330     EL_GATE4_GRAY,
1331     EL_EM_GATE1,
1332     EL_EM_GATE2,
1333     EL_EM_GATE3,
1334     EL_EM_GATE4,
1335     EL_EM_GATE1_GRAY,
1336     EL_EM_GATE2_GRAY,
1337     EL_EM_GATE3_GRAY,
1338     EL_EM_GATE4_GRAY,
1339     EL_SWITCHGATE_OPEN,
1340     EL_SWITCHGATE_OPENING,
1341     EL_SWITCHGATE_CLOSED,
1342     EL_SWITCHGATE_CLOSING,
1343     EL_TIMEGATE_OPEN,
1344     EL_TIMEGATE_OPENING,
1345     EL_TIMEGATE_CLOSED,
1346     EL_TIMEGATE_CLOSING,
1347     EL_TUBE_ALL,
1348     EL_TUBE_VERTICAL,
1349     EL_TUBE_HORIZONTAL,
1350     EL_TUBE_VERTICAL_LEFT,
1351     EL_TUBE_VERTICAL_RIGHT,
1352     EL_TUBE_HORIZONTAL_UP,
1353     EL_TUBE_HORIZONTAL_DOWN,
1354     EL_TUBE_LEFT_UP,
1355     EL_TUBE_LEFT_DOWN,
1356     EL_TUBE_RIGHT_UP,
1357     EL_TUBE_RIGHT_DOWN
1358   };
1359   static int ep_solid_num = SIZEOF_ARRAY_INT(ep_solid);
1360
1361   static int ep_massive[] =
1362   {
1363     EL_STEELWALL,
1364     EL_ACID,
1365     EL_ACIDPOOL_TOPLEFT,
1366     EL_ACIDPOOL_TOPRIGHT,
1367     EL_ACIDPOOL_BOTTOMLEFT,
1368     EL_ACIDPOOL_BOTTOM,
1369     EL_ACIDPOOL_BOTTOMRIGHT,
1370     EL_SP_HARD_GRAY,
1371     EL_SP_HARD_GREEN,
1372     EL_SP_HARD_BLUE,
1373     EL_SP_HARD_RED,
1374     EL_SP_HARD_YELLOW,
1375     EL_SP_HARD_BASE1,
1376     EL_SP_HARD_BASE2,
1377     EL_SP_HARD_BASE3,
1378     EL_SP_HARD_BASE4,
1379     EL_SP_HARD_BASE5,
1380     EL_SP_HARD_BASE6,
1381     EL_INVISIBLE_STEELWALL,
1382     EL_INVISIBLE_STEELWALL_ACTIVE,
1383     EL_CONVEYOR_BELT1_SWITCH_LEFT,
1384     EL_CONVEYOR_BELT1_SWITCH_MIDDLE,
1385     EL_CONVEYOR_BELT1_SWITCH_RIGHT,
1386     EL_CONVEYOR_BELT2_SWITCH_LEFT,
1387     EL_CONVEYOR_BELT2_SWITCH_MIDDLE,
1388     EL_CONVEYOR_BELT2_SWITCH_RIGHT,
1389     EL_CONVEYOR_BELT3_SWITCH_LEFT,
1390     EL_CONVEYOR_BELT3_SWITCH_MIDDLE,
1391     EL_CONVEYOR_BELT3_SWITCH_RIGHT,
1392     EL_CONVEYOR_BELT4_SWITCH_LEFT,
1393     EL_CONVEYOR_BELT4_SWITCH_MIDDLE,
1394     EL_CONVEYOR_BELT4_SWITCH_RIGHT,
1395     EL_LIGHT_SWITCH,
1396     EL_LIGHT_SWITCH_ACTIVE,
1397     EL_SIGN_EXCLAMATION,
1398     EL_SIGN_RADIOACTIVITY,
1399     EL_SIGN_STOP,
1400     EL_SIGN_WHEELCHAIR,
1401     EL_SIGN_PARKING,
1402     EL_SIGN_ONEWAY,
1403     EL_SIGN_HEART,
1404     EL_SIGN_TRIANGLE,
1405     EL_SIGN_ROUND,
1406     EL_SIGN_EXIT,
1407     EL_SIGN_YINYANG,
1408     EL_SIGN_OTHER,
1409     EL_STEELWALL_SLANTED,
1410     EL_EMC_STEELWALL1,
1411     EL_EMC_STEELWALL2,
1412     EL_EMC_STEELWALL3,
1413     EL_EMC_STEELWALL4,
1414     EL_CRYSTAL,
1415     EL_GATE1,
1416     EL_GATE2,
1417     EL_GATE3,
1418     EL_GATE4,
1419     EL_GATE1_GRAY,
1420     EL_GATE2_GRAY,
1421     EL_GATE3_GRAY,
1422     EL_GATE4_GRAY,
1423     EL_EM_GATE1,
1424     EL_EM_GATE2,
1425     EL_EM_GATE3,
1426     EL_EM_GATE4,
1427     EL_EM_GATE1_GRAY,
1428     EL_EM_GATE2_GRAY,
1429     EL_EM_GATE3_GRAY,
1430     EL_EM_GATE4_GRAY,
1431     EL_SWITCHGATE_OPEN,
1432     EL_SWITCHGATE_OPENING,
1433     EL_SWITCHGATE_CLOSED,
1434     EL_SWITCHGATE_CLOSING,
1435     EL_TIMEGATE_OPEN,
1436     EL_TIMEGATE_OPENING,
1437     EL_TIMEGATE_CLOSED,
1438     EL_TIMEGATE_CLOSING,
1439     EL_TUBE_ALL,
1440     EL_TUBE_VERTICAL,
1441     EL_TUBE_HORIZONTAL,
1442     EL_TUBE_VERTICAL_LEFT,
1443     EL_TUBE_VERTICAL_RIGHT,
1444     EL_TUBE_HORIZONTAL_UP,
1445     EL_TUBE_HORIZONTAL_DOWN,
1446     EL_TUBE_LEFT_UP,
1447     EL_TUBE_LEFT_DOWN,
1448     EL_TUBE_RIGHT_UP,
1449     EL_TUBE_RIGHT_DOWN
1450   };
1451   static int ep_massive_num = SIZEOF_ARRAY_INT(ep_massive);
1452
1453   static int ep_slippery[] =
1454   {
1455     EL_WALL_CRUMBLED,
1456     EL_BD_WALL,
1457     EL_ROCK,
1458     EL_BD_ROCK,
1459     EL_EMERALD,
1460     EL_BD_DIAMOND,
1461     EL_EMERALD_YELLOW,
1462     EL_EMERALD_RED,
1463     EL_EMERALD_PURPLE,
1464     EL_DIAMOND,
1465     EL_BOMB,
1466     EL_NUT,
1467     EL_ROBOT_WHEEL_ACTIVE,
1468     EL_ROBOT_WHEEL,
1469     EL_TIME_ORB_FULL,
1470     EL_TIME_ORB_EMPTY,
1471     EL_LAMP_ACTIVE,
1472     EL_LAMP,
1473     EL_ACIDPOOL_TOPLEFT,
1474     EL_ACIDPOOL_TOPRIGHT,
1475     EL_SATELLITE,
1476     EL_SP_ZONK,
1477     EL_SP_INFOTRON,
1478     EL_SP_CHIP_SINGLE,
1479     EL_SP_CHIP_LEFT,
1480     EL_SP_CHIP_RIGHT,
1481     EL_SP_CHIP_UPPER,
1482     EL_SP_CHIP_LOWER,
1483     EL_SPEED_PILL,
1484     EL_STEELWALL_SLANTED,
1485     EL_PEARL,
1486     EL_CRYSTAL
1487   };
1488   static int ep_slippery_num = SIZEOF_ARRAY_INT(ep_slippery);
1489
1490   static int ep_enemy[] =
1491   {
1492     EL_BUG,
1493     EL_SPACESHIP,
1494     EL_BD_BUTTERFLY,
1495     EL_BD_FIREFLY,
1496     EL_YAMYAM,
1497     EL_DARK_YAMYAM,
1498     EL_ROBOT,
1499     EL_PACMAN,
1500     EL_SP_SNIKSNAK,
1501     EL_SP_ELECTRON
1502   };
1503   static int ep_enemy_num = SIZEOF_ARRAY_INT(ep_enemy);
1504
1505   static int ep_mauer[] =
1506   {
1507     EL_STEELWALL,
1508     EL_GATE1,
1509     EL_GATE2,
1510     EL_GATE3,
1511     EL_GATE4,
1512     EL_GATE1_GRAY,
1513     EL_GATE2_GRAY,
1514     EL_GATE3_GRAY,
1515     EL_GATE4_GRAY,
1516     EL_EM_GATE1,
1517     EL_EM_GATE2,
1518     EL_EM_GATE3,
1519     EL_EM_GATE4,
1520     EL_EM_GATE1_GRAY,
1521     EL_EM_GATE2_GRAY,
1522     EL_EM_GATE3_GRAY,
1523     EL_EM_GATE4_GRAY,
1524     EL_EXIT_CLOSED,
1525     EL_EXIT_OPENING,
1526     EL_EXIT_OPEN,
1527     EL_WALL,
1528     EL_WALL_CRUMBLED,
1529     EL_WALL_GROWING,
1530     EL_WALL_GROWING_X,
1531     EL_WALL_GROWING_Y,
1532     EL_WALL_GROWING_XY,
1533     EL_WALL_GROWING_ACTIVE,
1534     EL_BD_WALL,
1535     EL_SP_CHIP_SINGLE,
1536     EL_SP_CHIP_LEFT,
1537     EL_SP_CHIP_RIGHT,
1538     EL_SP_CHIP_UPPER,
1539     EL_SP_CHIP_LOWER,
1540     EL_SP_HARD_GRAY,
1541     EL_SP_HARD_GREEN,
1542     EL_SP_HARD_BLUE,
1543     EL_SP_HARD_RED,
1544     EL_SP_HARD_YELLOW,
1545     EL_SP_HARD_BASE1,
1546     EL_SP_HARD_BASE2,
1547     EL_SP_HARD_BASE3,
1548     EL_SP_HARD_BASE4,
1549     EL_SP_HARD_BASE5,
1550     EL_SP_HARD_BASE6,
1551     EL_SP_TERMINAL,
1552     EL_SP_TERMINAL_ACTIVE,
1553     EL_SP_EXIT_CLOSED,
1554     EL_SP_EXIT_OPEN,
1555     EL_INVISIBLE_STEELWALL,
1556     EL_INVISIBLE_STEELWALL_ACTIVE,
1557     EL_INVISIBLE_WALL,
1558     EL_INVISIBLE_WALL_ACTIVE,
1559     EL_STEELWALL_SLANTED,
1560     EL_EMC_STEELWALL1,
1561     EL_EMC_STEELWALL2,
1562     EL_EMC_STEELWALL3,
1563     EL_EMC_STEELWALL4,
1564     EL_EMC_WALL_PILLAR_UPPER,
1565     EL_EMC_WALL_PILLAR_MIDDLE,
1566     EL_EMC_WALL_PILLAR_LOWER,
1567     EL_EMC_WALL4,
1568     EL_EMC_WALL5,
1569     EL_EMC_WALL6,
1570     EL_EMC_WALL7,
1571     EL_EMC_WALL8
1572   };
1573   static int ep_mauer_num = SIZEOF_ARRAY_INT(ep_mauer);
1574
1575   static int ep_can_fall[] =
1576   {
1577     EL_ROCK,
1578     EL_BD_ROCK,
1579     EL_EMERALD,
1580     EL_BD_DIAMOND,
1581     EL_EMERALD_YELLOW,
1582     EL_EMERALD_RED,
1583     EL_EMERALD_PURPLE,
1584     EL_DIAMOND,
1585     EL_BOMB,
1586     EL_NUT,
1587     EL_AMOEBA_DROP,
1588     EL_QUICKSAND_FULL,
1589     EL_MAGIC_WALL_FULL,
1590     EL_BD_MAGIC_WALL_FULL,
1591     EL_TIME_ORB_FULL,
1592     EL_TIME_ORB_EMPTY,
1593     EL_SP_ZONK,
1594     EL_SP_INFOTRON,
1595     EL_SP_DISK_ORANGE,
1596     EL_PEARL,
1597     EL_CRYSTAL,
1598     EL_SPRING,
1599     EL_DX_SUPABOMB
1600   };
1601   static int ep_can_fall_num = SIZEOF_ARRAY_INT(ep_can_fall);
1602
1603   static int ep_can_smash[] =
1604   {
1605     EL_ROCK,
1606     EL_BD_ROCK,
1607     EL_EMERALD,
1608     EL_BD_DIAMOND,
1609     EL_EMERALD_YELLOW,
1610     EL_EMERALD_RED,
1611     EL_EMERALD_PURPLE,
1612     EL_DIAMOND,
1613     EL_KEY1,
1614     EL_KEY2,
1615     EL_KEY3,
1616     EL_KEY4,
1617     EL_EM_KEY1,
1618     EL_EM_KEY2,
1619     EL_EM_KEY3,
1620     EL_EM_KEY4,
1621     EL_BOMB,
1622     EL_NUT,
1623     EL_AMOEBA_DROP,
1624     EL_TIME_ORB_FULL,
1625     EL_TIME_ORB_EMPTY,
1626     EL_SP_ZONK,
1627     EL_SP_INFOTRON,
1628     EL_SP_DISK_ORANGE,
1629     EL_PEARL,
1630     EL_CRYSTAL,
1631     EL_SPRING,
1632     EL_DX_SUPABOMB
1633   };
1634   static int ep_can_smash_num = SIZEOF_ARRAY_INT(ep_can_smash);
1635
1636   static int ep_can_change[] =
1637   {
1638     EL_ROCK,
1639     EL_BD_ROCK,
1640     EL_EMERALD,
1641     EL_BD_DIAMOND,
1642     EL_EMERALD_YELLOW,
1643     EL_EMERALD_RED,
1644     EL_EMERALD_PURPLE,
1645     EL_DIAMOND
1646   };
1647   static int ep_can_change_num = SIZEOF_ARRAY_INT(ep_can_change);
1648
1649   static int ep_can_move[] =
1650   {
1651     EL_BUG,
1652     EL_SPACESHIP,
1653     EL_BD_BUTTERFLY,
1654     EL_BD_FIREFLY,
1655     EL_YAMYAM,
1656     EL_DARK_YAMYAM,
1657     EL_ROBOT,
1658     EL_PACMAN,
1659     EL_MOLE,
1660     EL_PENGUIN,
1661     EL_PIG,
1662     EL_DRAGON,
1663     EL_SATELLITE,
1664     EL_SP_SNIKSNAK,
1665     EL_SP_ELECTRON,
1666     EL_BALLOON,
1667     EL_SPRING
1668   };
1669   static int ep_can_move_num = SIZEOF_ARRAY_INT(ep_can_move);
1670
1671   static int ep_could_move[] =
1672   {
1673     EL_BUG_RIGHT,
1674     EL_BUG_UP,
1675     EL_BUG_LEFT,
1676     EL_BUG_DOWN,
1677     EL_SPACESHIP_RIGHT,
1678     EL_SPACESHIP_UP,
1679     EL_SPACESHIP_LEFT,
1680     EL_SPACESHIP_DOWN,
1681     EL_BD_BUTTERFLY_RIGHT,
1682     EL_BD_BUTTERFLY_UP,
1683     EL_BD_BUTTERFLY_LEFT,
1684     EL_BD_BUTTERFLY_DOWN,
1685     EL_BD_FIREFLY_RIGHT,
1686     EL_BD_FIREFLY_UP,
1687     EL_BD_FIREFLY_LEFT,
1688     EL_BD_FIREFLY_DOWN,
1689     EL_PACMAN_RIGHT,
1690     EL_PACMAN_UP,
1691     EL_PACMAN_LEFT,
1692     EL_PACMAN_DOWN
1693   };
1694   static int ep_could_move_num = SIZEOF_ARRAY_INT(ep_could_move);
1695
1696   static int ep_dont_touch[] =
1697   {
1698     EL_BUG,
1699     EL_SPACESHIP,
1700     EL_BD_BUTTERFLY,
1701     EL_BD_FIREFLY
1702   };
1703   static int ep_dont_touch_num = SIZEOF_ARRAY_INT(ep_dont_touch);
1704
1705   static int ep_dont_go_to[] =
1706   {
1707     EL_BUG,
1708     EL_SPACESHIP,
1709     EL_BD_BUTTERFLY,
1710     EL_BD_FIREFLY,
1711     EL_YAMYAM,
1712     EL_DARK_YAMYAM,
1713     EL_ROBOT,
1714     EL_PACMAN,
1715     EL_AMOEBA_DROP,
1716     EL_ACID,
1717     EL_SP_SNIKSNAK,
1718     EL_SP_ELECTRON,
1719     EL_SP_BUGGY_BASE_ACTIVE,
1720     EL_TRAP_ACTIVE,
1721     EL_LANDMINE
1722   };
1723   static int ep_dont_go_to_num = SIZEOF_ARRAY_INT(ep_dont_go_to);
1724
1725   static int ep_mampf2[] =
1726   {
1727     EL_SAND,
1728     EL_BUG,
1729     EL_SPACESHIP,
1730     EL_BD_BUTTERFLY,
1731     EL_BD_FIREFLY,
1732     EL_YAMYAM,
1733     EL_ROBOT,
1734     EL_PACMAN,
1735     EL_AMOEBA_DROP,
1736     EL_AMOEBA_DEAD,
1737     EL_AMOEBA_WET,
1738     EL_AMOEBA_DRY,
1739     EL_AMOEBA_FULL,
1740     EL_BD_AMOEBA,
1741     EL_EMERALD,
1742     EL_BD_DIAMOND,
1743     EL_EMERALD_YELLOW,
1744     EL_EMERALD_RED,
1745     EL_EMERALD_PURPLE,
1746     EL_DIAMOND,
1747     EL_PEARL,
1748     EL_CRYSTAL
1749   };
1750   static int ep_mampf2_num = SIZEOF_ARRAY_INT(ep_mampf2);
1751
1752   static int ep_bd_element[] =
1753   {
1754     EL_EMPTY,
1755     EL_SAND,
1756     EL_WALL_CRUMBLED,
1757     EL_BD_WALL,
1758     EL_ROCK,
1759     EL_BD_ROCK,
1760     EL_BD_DIAMOND,
1761     EL_BD_MAGIC_WALL,
1762     EL_EXIT_CLOSED,
1763     EL_EXIT_OPEN,
1764     EL_STEELWALL,
1765     EL_PLAYER1,
1766     EL_BD_FIREFLY,
1767     EL_BD_FIREFLY_1,
1768     EL_BD_FIREFLY_2,
1769     EL_BD_FIREFLY_3,
1770     EL_BD_FIREFLY_4,
1771     EL_BD_BUTTERFLY,
1772     EL_BD_BUTTERFLY_1,
1773     EL_BD_BUTTERFLY_2,
1774     EL_BD_BUTTERFLY_3,
1775     EL_BD_BUTTERFLY_4,
1776     EL_BD_AMOEBA,
1777     EL_CHAR_QUESTION
1778   };
1779   static int ep_bd_element_num = SIZEOF_ARRAY_INT(ep_bd_element);
1780
1781   static int ep_sb_element[] =
1782   {
1783     EL_EMPTY,
1784     EL_STEELWALL,
1785     EL_SOKOBAN_OBJECT,
1786     EL_SOKOBAN_FIELD_EMPTY,
1787     EL_SOKOBAN_FIELD_FULL,
1788     EL_PLAYER1,
1789     EL_INVISIBLE_STEELWALL
1790   };
1791   static int ep_sb_element_num = SIZEOF_ARRAY_INT(ep_sb_element);
1792
1793   static int ep_gem[] =
1794   {
1795     EL_EMERALD,
1796     EL_BD_DIAMOND,
1797     EL_EMERALD_YELLOW,
1798     EL_EMERALD_RED,
1799     EL_EMERALD_PURPLE,
1800     EL_DIAMOND
1801   };
1802   static int ep_gem_num = SIZEOF_ARRAY_INT(ep_gem);
1803
1804   static int ep_inactive[] =
1805   {
1806     EL_EMPTY,
1807     EL_SAND,
1808     EL_WALL,
1809     EL_BD_WALL,
1810     EL_WALL_CRUMBLED,
1811     EL_STEELWALL,
1812     EL_AMOEBA_DEAD,
1813     EL_QUICKSAND_EMPTY,
1814     EL_STONEBLOCK,
1815     EL_ROBOT_WHEEL,
1816     EL_KEY1,
1817     EL_KEY2,
1818     EL_KEY3,
1819     EL_KEY4,
1820     EL_EM_KEY1,
1821     EL_EM_KEY2,
1822     EL_EM_KEY3,
1823     EL_EM_KEY4,
1824     EL_GATE1,
1825     EL_GATE2,
1826     EL_GATE3,
1827     EL_GATE4,
1828     EL_GATE1_GRAY,
1829     EL_GATE2_GRAY,
1830     EL_GATE3_GRAY,
1831     EL_GATE4_GRAY,
1832     EL_EM_GATE1,
1833     EL_EM_GATE2,
1834     EL_EM_GATE3,
1835     EL_EM_GATE4,
1836     EL_EM_GATE1_GRAY,
1837     EL_EM_GATE2_GRAY,
1838     EL_EM_GATE3_GRAY,
1839     EL_EM_GATE4_GRAY,
1840     EL_DYNAMITE,
1841     EL_INVISIBLE_STEELWALL,
1842     EL_INVISIBLE_WALL,
1843     EL_INVISIBLE_SAND,
1844     EL_LAMP,
1845     EL_LAMP_ACTIVE,
1846     EL_WALL_EMERALD,
1847     EL_WALL_DIAMOND,
1848     EL_WALL_BD_DIAMOND,
1849     EL_WALL_EMERALD_YELLOW,
1850     EL_DYNABOMB_NR,
1851     EL_DYNABOMB_SZ,
1852     EL_DYNABOMB_XL,
1853     EL_SOKOBAN_OBJECT,
1854     EL_SOKOBAN_FIELD_EMPTY,
1855     EL_SOKOBAN_FIELD_FULL,
1856     EL_WALL_EMERALD_RED,
1857     EL_WALL_EMERALD_PURPLE,
1858     EL_ACIDPOOL_TOPLEFT,
1859     EL_ACIDPOOL_TOPRIGHT,
1860     EL_ACIDPOOL_BOTTOMLEFT,
1861     EL_ACIDPOOL_BOTTOM,
1862     EL_ACIDPOOL_BOTTOMRIGHT,
1863     EL_MAGIC_WALL,
1864     EL_MAGIC_WALL_DEAD,
1865     EL_BD_MAGIC_WALL,
1866     EL_BD_MAGIC_WALL_DEAD,
1867     EL_AMOEBA_TO_DIAMOND,
1868     EL_BLOCKED,
1869     EL_SP_EMPTY,
1870     EL_SP_BASE,
1871     EL_SP_PORT1_RIGHT,
1872     EL_SP_PORT1_DOWN,
1873     EL_SP_PORT1_LEFT,
1874     EL_SP_PORT1_UP,
1875     EL_SP_PORT2_RIGHT,
1876     EL_SP_PORT2_DOWN,
1877     EL_SP_PORT2_LEFT,
1878     EL_SP_PORT2_UP,
1879     EL_SP_PORT_X,
1880     EL_SP_PORT_Y,
1881     EL_SP_PORT_XY,
1882     EL_SP_DISK_RED,
1883     EL_SP_DISK_YELLOW,
1884     EL_SP_CHIP_SINGLE,
1885     EL_SP_CHIP_LEFT,
1886     EL_SP_CHIP_RIGHT,
1887     EL_SP_CHIP_UPPER,
1888     EL_SP_CHIP_LOWER,
1889     EL_SP_HARD_GRAY,
1890     EL_SP_HARD_GREEN,
1891     EL_SP_HARD_BLUE,
1892     EL_SP_HARD_RED,
1893     EL_SP_HARD_YELLOW,
1894     EL_SP_HARD_BASE1,
1895     EL_SP_HARD_BASE2,
1896     EL_SP_HARD_BASE3,
1897     EL_SP_HARD_BASE4,
1898     EL_SP_HARD_BASE5,
1899     EL_SP_HARD_BASE6,
1900     EL_CONVEYOR_BELT1_SWITCH_LEFT,
1901     EL_CONVEYOR_BELT1_SWITCH_MIDDLE,
1902     EL_CONVEYOR_BELT1_SWITCH_RIGHT,
1903     EL_CONVEYOR_BELT2_SWITCH_LEFT,
1904     EL_CONVEYOR_BELT2_SWITCH_MIDDLE,
1905     EL_CONVEYOR_BELT2_SWITCH_RIGHT,
1906     EL_CONVEYOR_BELT3_SWITCH_LEFT,
1907     EL_CONVEYOR_BELT3_SWITCH_MIDDLE,
1908     EL_CONVEYOR_BELT3_SWITCH_RIGHT,
1909     EL_CONVEYOR_BELT4_SWITCH_LEFT,
1910     EL_CONVEYOR_BELT4_SWITCH_MIDDLE,
1911     EL_CONVEYOR_BELT4_SWITCH_RIGHT,
1912     EL_SIGN_EXCLAMATION,
1913     EL_SIGN_RADIOACTIVITY,
1914     EL_SIGN_STOP,
1915     EL_SIGN_WHEELCHAIR,
1916     EL_SIGN_PARKING,
1917     EL_SIGN_ONEWAY,
1918     EL_SIGN_HEART,
1919     EL_SIGN_TRIANGLE,
1920     EL_SIGN_ROUND,
1921     EL_SIGN_EXIT,
1922     EL_SIGN_YINYANG,
1923     EL_SIGN_OTHER,
1924     EL_STEELWALL_SLANTED,
1925     EL_EMC_STEELWALL1,
1926     EL_EMC_STEELWALL2,
1927     EL_EMC_STEELWALL3,
1928     EL_EMC_STEELWALL4,
1929     EL_EMC_WALL_PILLAR_UPPER,
1930     EL_EMC_WALL_PILLAR_MIDDLE,
1931     EL_EMC_WALL_PILLAR_LOWER,
1932     EL_EMC_WALL4,
1933     EL_EMC_WALL5,
1934     EL_EMC_WALL6,
1935     EL_EMC_WALL7,
1936     EL_EMC_WALL8
1937   };
1938   static int ep_inactive_num = SIZEOF_ARRAY_INT(ep_inactive);
1939
1940   static int ep_explosive[] =
1941   {
1942     EL_BOMB,
1943     EL_DYNAMITE_ACTIVE,
1944     EL_DYNAMITE,
1945     EL_DYNABOMB_PLAYER1_ACTIVE,
1946     EL_DYNABOMB_PLAYER2_ACTIVE,
1947     EL_DYNABOMB_PLAYER3_ACTIVE,
1948     EL_DYNABOMB_PLAYER4_ACTIVE,
1949     EL_DYNABOMB_NR,
1950     EL_DYNABOMB_SZ,
1951     EL_DYNABOMB_XL,
1952     EL_BUG,
1953     EL_MOLE,
1954     EL_PENGUIN,
1955     EL_PIG,
1956     EL_DRAGON,
1957     EL_SATELLITE,
1958     EL_SP_DISK_RED,
1959     EL_SP_DISK_ORANGE,
1960     EL_SP_DISK_YELLOW,
1961     EL_SP_SNIKSNAK,
1962     EL_SP_ELECTRON,
1963     EL_DX_SUPABOMB
1964   };
1965   static int ep_explosive_num = SIZEOF_ARRAY_INT(ep_explosive);
1966
1967   static int ep_mampf3[] =
1968   {
1969     EL_EMERALD,
1970     EL_BD_DIAMOND,
1971     EL_EMERALD_YELLOW,
1972     EL_EMERALD_RED,
1973     EL_EMERALD_PURPLE,
1974     EL_DIAMOND,
1975     EL_PEARL,
1976     EL_CRYSTAL
1977   };
1978   static int ep_mampf3_num = SIZEOF_ARRAY_INT(ep_mampf3);
1979
1980   static int ep_pushable[] =
1981   {
1982     EL_ROCK,
1983     EL_BD_ROCK,
1984     EL_BOMB,
1985     EL_NUT,
1986     EL_TIME_ORB_EMPTY,
1987     EL_SOKOBAN_FIELD_FULL,
1988     EL_SOKOBAN_OBJECT,
1989     EL_SATELLITE,
1990     EL_SP_ZONK,
1991     EL_SP_DISK_ORANGE,
1992     EL_SP_DISK_YELLOW,
1993     EL_BALLOON,
1994     EL_SPRING,
1995     EL_DX_SUPABOMB
1996   };
1997   static int ep_pushable_num = SIZEOF_ARRAY_INT(ep_pushable);
1998
1999   static int ep_player[] =
2000   {
2001     EL_PLAYER1,
2002     EL_PLAYER2,
2003     EL_PLAYER3,
2004     EL_PLAYER4
2005   };
2006   static int ep_player_num = SIZEOF_ARRAY_INT(ep_player);
2007
2008   static int ep_has_content[] =
2009   {
2010     EL_YAMYAM,
2011     EL_AMOEBA_WET,
2012     EL_AMOEBA_DRY,
2013     EL_AMOEBA_FULL,
2014     EL_BD_AMOEBA
2015   };
2016   static int ep_has_content_num = SIZEOF_ARRAY_INT(ep_has_content);
2017
2018   static int ep_eatable[] =
2019   {
2020     EL_SAND,
2021     EL_SP_BASE,
2022     EL_SP_BUGGY_BASE,
2023     EL_SP_BUGGY_BASE_ACTIVATING,
2024     EL_TRAP,
2025     EL_INVISIBLE_SAND,
2026     EL_INVISIBLE_SAND_ACTIVE
2027   };
2028   static int ep_eatable_num = SIZEOF_ARRAY_INT(ep_eatable);
2029
2030   static int ep_sp_element[] =
2031   {
2032     EL_SP_EMPTY,
2033     EL_SP_ZONK,
2034     EL_SP_BASE,
2035     EL_SP_MURPHY,
2036     EL_SP_INFOTRON,
2037     EL_SP_CHIP_SINGLE,
2038     EL_SP_HARD_GRAY,
2039     EL_SP_EXIT_CLOSED,
2040     EL_SP_EXIT_OPEN,
2041     EL_SP_DISK_ORANGE,
2042     EL_SP_PORT1_RIGHT,
2043     EL_SP_PORT1_DOWN,
2044     EL_SP_PORT1_LEFT,
2045     EL_SP_PORT1_UP,
2046     EL_SP_PORT2_RIGHT,
2047     EL_SP_PORT2_DOWN,
2048     EL_SP_PORT2_LEFT,
2049     EL_SP_PORT2_UP,
2050     EL_SP_SNIKSNAK,
2051     EL_SP_DISK_YELLOW,
2052     EL_SP_TERMINAL,
2053     EL_SP_DISK_RED,
2054     EL_SP_PORT_Y,
2055     EL_SP_PORT_X,
2056     EL_SP_PORT_XY,
2057     EL_SP_ELECTRON,
2058     EL_SP_BUGGY_BASE,
2059     EL_SP_CHIP_LEFT,
2060     EL_SP_CHIP_RIGHT,
2061     EL_SP_HARD_BASE1,
2062     EL_SP_HARD_GREEN,
2063     EL_SP_HARD_BLUE,
2064     EL_SP_HARD_RED,
2065     EL_SP_HARD_YELLOW,
2066     EL_SP_HARD_BASE2,
2067     EL_SP_HARD_BASE3,
2068     EL_SP_HARD_BASE4,
2069     EL_SP_HARD_BASE5,
2070     EL_SP_HARD_BASE6,
2071     EL_SP_CHIP_UPPER,
2072     EL_SP_CHIP_LOWER,
2073     /* additional elements that appeared in newer Supaplex levels */
2074     EL_INVISIBLE_WALL,
2075     /* more than one murphy in a level results in an inactive clone */
2076     EL_SP_MURPHY_CLONE
2077   };
2078   static int ep_sp_element_num = SIZEOF_ARRAY_INT(ep_sp_element);
2079
2080   static int ep_quick_gate[] =
2081   {
2082     EL_EM_GATE1,
2083     EL_EM_GATE2,
2084     EL_EM_GATE3,
2085     EL_EM_GATE4,
2086     EL_EM_GATE1_GRAY,
2087     EL_EM_GATE2_GRAY,
2088     EL_EM_GATE3_GRAY,
2089     EL_EM_GATE4_GRAY,
2090     EL_SP_PORT1_LEFT,
2091     EL_SP_PORT2_LEFT,
2092     EL_SP_PORT1_RIGHT,
2093     EL_SP_PORT2_RIGHT,
2094     EL_SP_PORT1_UP,
2095     EL_SP_PORT2_UP,
2096     EL_SP_PORT1_DOWN,
2097     EL_SP_PORT2_DOWN,
2098     EL_SP_PORT_X,
2099     EL_SP_PORT_Y,
2100     EL_SP_PORT_XY,
2101     EL_SWITCHGATE_OPEN,
2102     EL_TIMEGATE_OPEN
2103   };
2104   static int ep_quick_gate_num = SIZEOF_ARRAY_INT(ep_quick_gate);
2105
2106   static int ep_over_player[] =
2107   {
2108     EL_SP_PORT1_LEFT,
2109     EL_SP_PORT2_LEFT,
2110     EL_SP_PORT1_RIGHT,
2111     EL_SP_PORT2_RIGHT,
2112     EL_SP_PORT1_UP,
2113     EL_SP_PORT2_UP,
2114     EL_SP_PORT1_DOWN,
2115     EL_SP_PORT2_DOWN,
2116     EL_SP_PORT_X,
2117     EL_SP_PORT_Y,
2118     EL_SP_PORT_XY,
2119     EL_TUBE_ALL,
2120     EL_TUBE_VERTICAL,
2121     EL_TUBE_HORIZONTAL,
2122     EL_TUBE_VERTICAL_LEFT,
2123     EL_TUBE_VERTICAL_RIGHT,
2124     EL_TUBE_HORIZONTAL_UP,
2125     EL_TUBE_HORIZONTAL_DOWN,
2126     EL_TUBE_LEFT_UP,
2127     EL_TUBE_LEFT_DOWN,
2128     EL_TUBE_RIGHT_UP,
2129     EL_TUBE_RIGHT_DOWN
2130   };
2131   static int ep_over_player_num = SIZEOF_ARRAY_INT(ep_over_player);
2132
2133   static int ep_active_bomb[] =
2134   {
2135     EL_DYNAMITE_ACTIVE,
2136     EL_DYNABOMB_PLAYER1_ACTIVE,
2137     EL_DYNABOMB_PLAYER2_ACTIVE,
2138     EL_DYNABOMB_PLAYER3_ACTIVE,
2139     EL_DYNABOMB_PLAYER4_ACTIVE
2140   };
2141   static int ep_active_bomb_num = SIZEOF_ARRAY_INT(ep_active_bomb);
2142
2143   static int ep_belt[] =
2144   {
2145     EL_CONVEYOR_BELT1_LEFT,
2146     EL_CONVEYOR_BELT1_MIDDLE,
2147     EL_CONVEYOR_BELT1_RIGHT,
2148     EL_CONVEYOR_BELT2_LEFT,
2149     EL_CONVEYOR_BELT2_MIDDLE,
2150     EL_CONVEYOR_BELT2_RIGHT,
2151     EL_CONVEYOR_BELT3_LEFT,
2152     EL_CONVEYOR_BELT3_MIDDLE,
2153     EL_CONVEYOR_BELT3_RIGHT,
2154     EL_CONVEYOR_BELT4_LEFT,
2155     EL_CONVEYOR_BELT4_MIDDLE,
2156     EL_CONVEYOR_BELT4_RIGHT,
2157   };
2158   static int ep_belt_num = SIZEOF_ARRAY_INT(ep_belt);
2159
2160   static int ep_belt_active[] =
2161   {
2162     EL_CONVEYOR_BELT1_LEFT_ACTIVE,
2163     EL_CONVEYOR_BELT1_MIDDLE_ACTIVE,
2164     EL_CONVEYOR_BELT1_RIGHT_ACTIVE,
2165     EL_CONVEYOR_BELT2_LEFT_ACTIVE,
2166     EL_CONVEYOR_BELT2_MIDDLE_ACTIVE,
2167     EL_CONVEYOR_BELT2_RIGHT_ACTIVE,
2168     EL_CONVEYOR_BELT3_LEFT_ACTIVE,
2169     EL_CONVEYOR_BELT3_MIDDLE_ACTIVE,
2170     EL_CONVEYOR_BELT3_RIGHT_ACTIVE,
2171     EL_CONVEYOR_BELT4_LEFT_ACTIVE,
2172     EL_CONVEYOR_BELT4_MIDDLE_ACTIVE,
2173     EL_CONVEYOR_BELT4_RIGHT_ACTIVE,
2174   };
2175   static int ep_belt_active_num = SIZEOF_ARRAY_INT(ep_belt_active);
2176
2177   static int ep_belt_switch[] =
2178   {
2179     EL_CONVEYOR_BELT1_SWITCH_LEFT,
2180     EL_CONVEYOR_BELT1_SWITCH_MIDDLE,
2181     EL_CONVEYOR_BELT1_SWITCH_RIGHT,
2182     EL_CONVEYOR_BELT2_SWITCH_LEFT,
2183     EL_CONVEYOR_BELT2_SWITCH_MIDDLE,
2184     EL_CONVEYOR_BELT2_SWITCH_RIGHT,
2185     EL_CONVEYOR_BELT3_SWITCH_LEFT,
2186     EL_CONVEYOR_BELT3_SWITCH_MIDDLE,
2187     EL_CONVEYOR_BELT3_SWITCH_RIGHT,
2188     EL_CONVEYOR_BELT4_SWITCH_LEFT,
2189     EL_CONVEYOR_BELT4_SWITCH_MIDDLE,
2190     EL_CONVEYOR_BELT4_SWITCH_RIGHT,
2191   };
2192   static int ep_belt_switch_num = SIZEOF_ARRAY_INT(ep_belt_switch);
2193
2194   static int ep_tube[] =
2195   {
2196     EL_TUBE_ALL,
2197     EL_TUBE_VERTICAL,
2198     EL_TUBE_HORIZONTAL,
2199     EL_TUBE_VERTICAL_LEFT,
2200     EL_TUBE_VERTICAL_RIGHT,
2201     EL_TUBE_HORIZONTAL_UP,
2202     EL_TUBE_HORIZONTAL_DOWN,
2203     EL_TUBE_LEFT_UP,
2204     EL_TUBE_LEFT_DOWN,
2205     EL_TUBE_RIGHT_UP,
2206     EL_TUBE_RIGHT_DOWN
2207   };
2208   static int ep_tube_num = SIZEOF_ARRAY_INT(ep_tube);
2209
2210   static long ep1_bit[] =
2211   {
2212     EP_BIT_AMOEBALIVE,
2213     EP_BIT_AMOEBOID,
2214     EP_BIT_SCHLUESSEL,
2215     EP_BIT_PFORTE,
2216     EP_BIT_SOLID,
2217     EP_BIT_MASSIVE,
2218     EP_BIT_SLIPPERY,
2219     EP_BIT_ENEMY,
2220     EP_BIT_MAUER,
2221     EP_BIT_CAN_FALL,
2222     EP_BIT_CAN_SMASH,
2223     EP_BIT_CAN_CHANGE,
2224     EP_BIT_CAN_MOVE,
2225     EP_BIT_COULD_MOVE,
2226     EP_BIT_DONT_TOUCH,
2227     EP_BIT_DONT_GO_TO,
2228     EP_BIT_MAMPF2,
2229     EP_BIT_BD_ELEMENT,
2230     EP_BIT_SB_ELEMENT,
2231     EP_BIT_GEM,
2232     EP_BIT_INACTIVE,
2233     EP_BIT_EXPLOSIVE,
2234     EP_BIT_MAMPF3,
2235     EP_BIT_PUSHABLE,
2236     EP_BIT_PLAYER,
2237     EP_BIT_HAS_CONTENT,
2238     EP_BIT_EATABLE,
2239     EP_BIT_SP_ELEMENT,
2240     EP_BIT_QUICK_GATE,
2241     EP_BIT_OVER_PLAYER,
2242     EP_BIT_ACTIVE_BOMB
2243   };
2244   static long ep2_bit[] =
2245   {
2246     EP_BIT_BELT,
2247     EP_BIT_BELT_ACTIVE,
2248     EP_BIT_BELT_SWITCH,
2249     EP_BIT_TUBE
2250   };
2251   static int *ep1_array[] =
2252   {
2253     ep_amoebalive,
2254     ep_amoeboid,
2255     ep_schluessel,
2256     ep_pforte,
2257     ep_solid,
2258     ep_massive,
2259     ep_slippery,
2260     ep_enemy,
2261     ep_mauer,
2262     ep_can_fall,
2263     ep_can_smash,
2264     ep_can_change,
2265     ep_can_move,
2266     ep_could_move,
2267     ep_dont_touch,
2268     ep_dont_go_to,
2269     ep_mampf2,
2270     ep_bd_element,
2271     ep_sb_element,
2272     ep_gem,
2273     ep_inactive,
2274     ep_explosive,
2275     ep_mampf3,
2276     ep_pushable,
2277     ep_player,
2278     ep_has_content,
2279     ep_eatable,
2280     ep_sp_element,
2281     ep_quick_gate,
2282     ep_over_player,
2283     ep_active_bomb
2284   };
2285   static int *ep2_array[] =
2286   {
2287     ep_belt,
2288     ep_belt_active,
2289     ep_belt_switch,
2290     ep_tube
2291   };
2292   static int *ep1_num[] =
2293   {
2294     &ep_amoebalive_num,
2295     &ep_amoeboid_num,
2296     &ep_schluessel_num,
2297     &ep_pforte_num,
2298     &ep_solid_num,
2299     &ep_massive_num,
2300     &ep_slippery_num,
2301     &ep_enemy_num,
2302     &ep_mauer_num,
2303     &ep_can_fall_num,
2304     &ep_can_smash_num,
2305     &ep_can_change_num,
2306     &ep_can_move_num,
2307     &ep_could_move_num,
2308     &ep_dont_touch_num,
2309     &ep_dont_go_to_num,
2310     &ep_mampf2_num,
2311     &ep_bd_element_num,
2312     &ep_sb_element_num,
2313     &ep_gem_num,
2314     &ep_inactive_num,
2315     &ep_explosive_num,
2316     &ep_mampf3_num,
2317     &ep_pushable_num,
2318     &ep_player_num,
2319     &ep_has_content_num,
2320     &ep_eatable_num,
2321     &ep_sp_element_num,
2322     &ep_quick_gate_num,
2323     &ep_over_player_num,
2324     &ep_active_bomb_num
2325   };
2326   static int *ep2_num[] =
2327   {
2328     &ep_belt_num,
2329     &ep_belt_active_num,
2330     &ep_belt_switch_num,
2331     &ep_tube_num
2332   };
2333   static int num_properties1 = SIZEOF_ARRAY(ep1_num, int *);
2334   static int num_properties2 = SIZEOF_ARRAY(ep2_num, int *);
2335
2336   for (i=0; i<MAX_NUM_ELEMENTS; i++)
2337   {
2338     Properties1[i] = 0;
2339     Properties2[i] = 0;
2340   }
2341
2342   for (i=0; i<num_properties1; i++)
2343     for (j=0; j<*(ep1_num[i]); j++)
2344       Properties1[(ep1_array[i])[j]] |= ep1_bit[i];
2345   for (i=0; i<num_properties2; i++)
2346     for (j=0; j<*(ep2_num[i]); j++)
2347       Properties2[(ep2_array[i])[j]] |= ep2_bit[i];
2348
2349   for (i=EL_CHAR_START; i<=EL_CHAR_END; i++)
2350     Properties1[i] |= (EP_BIT_CHAR | EP_BIT_INACTIVE);
2351 }
2352
2353 void Execute_Command(char *command)
2354 {
2355   if (strcmp(command, "print graphicsinfo.conf") == 0)
2356   {
2357     int i;
2358
2359     printf("# You can configure additional/alternative image files here.\n");
2360     printf("# (The images below are default and therefore commented out.)\n");
2361     printf("\n");
2362     printf("%s\n", getFormattedSetupEntry("name", "Classic Graphics"));
2363     printf("\n");
2364     printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
2365     printf("\n");
2366
2367     for (i=0; image_config[i].token != NULL; i++)
2368       printf("# %s\n",
2369              getFormattedSetupEntry(image_config[i].token,
2370                                     image_config[i].value));
2371
2372     exit(0);
2373   }
2374   else if (strcmp(command, "print soundsinfo.conf") == 0)
2375   {
2376     int i;
2377
2378     printf("# You can configure additional/alternative sound files here.\n");
2379     printf("# (The sounds below are default and therefore commented out.)\n");
2380     printf("\n");
2381     printf("%s\n", getFormattedSetupEntry("name", "Classic Sounds"));
2382     printf("\n");
2383     printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
2384     printf("\n");
2385
2386     for (i=0; sound_config[i].token != NULL; i++)
2387       printf("# %s\n",
2388              getFormattedSetupEntry(sound_config[i].token,
2389                                     sound_config[i].value));
2390
2391     exit(0);
2392   }
2393   else if (strcmp(command, "print musicinfo.conf") == 0)
2394   {
2395     printf("# (Currently only \"name\" and \"sort_priority\" recognized.)\n");
2396     printf("\n");
2397     printf("%s\n", getFormattedSetupEntry("name", "Classic Music"));
2398     printf("\n");
2399     printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
2400
2401     exit(0);
2402   }
2403   else if (strncmp(command, "dump level ", 11) == 0)
2404   {
2405     char *filename = &command[11];
2406
2407     if (access(filename, F_OK) != 0)
2408       Error(ERR_EXIT, "cannot open file '%s'", filename);
2409
2410     LoadLevelFromFilename(filename);
2411     DumpLevel(&level);
2412
2413     exit(0);
2414   }
2415   else if (strncmp(command, "dump tape ", 10) == 0)
2416   {
2417     char *filename = &command[10];
2418
2419     if (access(filename, F_OK) != 0)
2420       Error(ERR_EXIT, "cannot open file '%s'", filename);
2421
2422     LoadTapeFromFilename(filename);
2423     DumpTape(&tape);
2424
2425     exit(0);
2426   }
2427   else if (strncmp(command, "autoplay ", 9) == 0)
2428   {
2429     char *str_copy = getStringCopy(&command[9]);
2430     char *str_ptr = strchr(str_copy, ' ');
2431
2432     global.autoplay_leveldir = str_copy;
2433     global.autoplay_level_nr = -1;
2434
2435     if (str_ptr != NULL)
2436     {
2437       *str_ptr++ = '\0';                        /* terminate leveldir string */
2438       global.autoplay_level_nr = atoi(str_ptr); /* get level_nr value */
2439     }
2440   }
2441   else
2442   {
2443     Error(ERR_EXIT_HELP, "unrecognized command '%s'", command);
2444   }
2445 }
2446
2447 void CloseAllAndExit(int exit_value)
2448 {
2449   StopSounds();
2450   FreeAllSounds();
2451   FreeAllMusic();
2452   CloseAudio();         /* called after freeing sounds (needed for SDL) */
2453
2454   FreeAllImages();
2455   FreeTileClipmasks();
2456
2457   if (bitmap_font_initial)
2458     FreeBitmap(bitmap_font_initial);
2459
2460   CloseVideoDisplay();
2461   ClosePlatformDependantStuff();
2462
2463   exit(exit_value);
2464 }