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