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