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