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 FontBitmapInfo font_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_initial[j].src_x = atoi(image_config[i].value);
 490         else if (strcmp(&image_config[i].token[len_font_token], ".y") == 0)
 491           font_initial[j].src_y = atoi(image_config[i].value);
 492         else if (strcmp(&image_config[i].token[len_font_token], ".width") == 0)
 493           font_initial[j].width = atoi(image_config[i].value);
 494         else if (strcmp(&image_config[i].token[len_font_token],".height") == 0)
 495           font_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_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 FontBitmapInfo font_bitmap_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_bitmap_info[i] = font_initial[i];
 744     else
 745     {
 746       /* copy font relevant information from graphics information */
 747       font_bitmap_info[i].bitmap = graphic_info[FIRST_IMG_FONT + i].bitmap;
 748       font_bitmap_info[i].src_x  = graphic_info[FIRST_IMG_FONT + i].src_x;
 749       font_bitmap_info[i].src_y  = graphic_info[FIRST_IMG_FONT + i].src_y;
 750       font_bitmap_info[i].width  = graphic_info[FIRST_IMG_FONT + i].width;
 751       font_bitmap_info[i].height = graphic_info[FIRST_IMG_FONT + i].height;
 752       font_bitmap_info[i].draw_x = graphic_info[FIRST_IMG_FONT + i].draw_x;
 753       font_bitmap_info[i].draw_y = graphic_info[FIRST_IMG_FONT + i].draw_y;
 754     }
 755   }
 756
 757   InitFontInfo(font_bitmap_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, j;
 884
 885   /* always start with reliable default values */
 886   for (i=0; i < MAX_NUM_ELEMENTS; i++)
 887     for (j=0; j < NUM_SPECIAL_GFX_ARGS; j++)
 888       element_info[i].special_graphic[j] =
 889         element_info[i].graphic[ACTION_DEFAULT];
 890
 891   /* initialize special element/graphic mapping from static configuration */
 892   for (i=0; element_to_special_graphic[i].element > -1; i++)
 893   {
 894     int element = element_to_special_graphic[i].element;
 895     int special = element_to_special_graphic[i].special;
 896     int graphic = element_to_special_graphic[i].graphic;
 897     boolean base_redefined = getImageListEntry(el2img(element))->redefined;
 898     boolean special_redefined = getImageListEntry(graphic)->redefined;
 899
 900     if (base_redefined && !special_redefined)
 901       continue;
 902
 903     element_info[element].special_graphic[special] = graphic;
 904   }
 905
 906   /* initialize special element/graphic mapping from dynamic configuration */
 907   for (i=0; i < num_property_mappings; i++)
 908   {
 909     int element = property_mapping[i].base_index;
 910     int special = property_mapping[i].ext3_index;
 911     int graphic = property_mapping[i].artwork_index;
 912
 913     if (special >= 0 && special < NUM_SPECIAL_GFX_ARGS)
 914       element_info[element].special_graphic[special] = graphic;
 915   }
 916 }
 917
 918 static void set_graphic_parameters(int graphic, char **parameter_raw)
 919 {
 920   Bitmap *src_bitmap = getBitmapFromImageID(graphic);
 921   int num_xtiles = (src_bitmap ? src_bitmap->width          : TILEX) / TILEX;
 922   int num_ytiles = (src_bitmap ? src_bitmap->height * 2 / 3 : TILEY) / TILEY;
 923   int parameter[NUM_GFX_ARGS];
 924   int i;
 925
 926   /* get integer values from string parameters */
 927   for (i=0; i < NUM_GFX_ARGS; i++)
 928     parameter[i] =
 929       get_parameter_value(image_config_suffix[i].type, parameter_raw[i]);
 930
 931   graphic_info[graphic].bitmap = src_bitmap;
 932
 933   /* start with reliable default values */
 934   graphic_info[graphic].src_x = 0;
 935   graphic_info[graphic].src_y = 0;
 936   graphic_info[graphic].width = TILEX;
 937   graphic_info[graphic].height = TILEY;
 938   graphic_info[graphic].offset_x = 0;   /* one or both of these values ... */
 939   graphic_info[graphic].offset_y = 0;   /* ... will be corrected later */
 940
 941   /* optional x and y tile position of animation frame sequence */
 942   if (parameter[GFX_ARG_XPOS] != ARG_UNDEFINED_VALUE)
 943     graphic_info[graphic].src_x = parameter[GFX_ARG_XPOS] * TILEX;
 944   if (parameter[GFX_ARG_YPOS] != ARG_UNDEFINED_VALUE)
 945     graphic_info[graphic].src_y = parameter[GFX_ARG_YPOS] * TILEY;
 946
 947   /* optional x and y pixel position of animation frame sequence */
 948   if (parameter[GFX_ARG_X] != ARG_UNDEFINED_VALUE)
 949     graphic_info[graphic].src_x = parameter[GFX_ARG_X];
 950   if (parameter[GFX_ARG_Y] != ARG_UNDEFINED_VALUE)
 951     graphic_info[graphic].src_y = parameter[GFX_ARG_Y];
 952
 953   /* optional width and height of each animation frame */
 954   if (parameter[GFX_ARG_WIDTH] != ARG_UNDEFINED_VALUE)
 955     graphic_info[graphic].width = parameter[GFX_ARG_WIDTH];
 956   if (parameter[GFX_ARG_HEIGHT] != ARG_UNDEFINED_VALUE)
 957     graphic_info[graphic].height = parameter[GFX_ARG_HEIGHT];
 958
 959   /* correct x or y offset dependant of vertical or horizontal frame order */
 960   if (parameter[GFX_ARG_VERTICAL])      /* frames are ordered vertically */
 961   {
 962     if (parameter[GFX_ARG_OFFSET] != ARG_UNDEFINED_VALUE)
 963       graphic_info[graphic].offset_y = parameter[GFX_ARG_OFFSET];
 964     else
 965       graphic_info[graphic].offset_y = graphic_info[graphic].height;
 966   }
 967   else                                  /* frames are ordered horizontally */
 968   {
 969     if (parameter[GFX_ARG_OFFSET] != ARG_UNDEFINED_VALUE)
 970       graphic_info[graphic].offset_x = parameter[GFX_ARG_OFFSET];
 971     else
 972       graphic_info[graphic].offset_x = graphic_info[graphic].width;
 973   }
 974
 975   /* optionally, the x and y offset of frames can be specified directly */
 976   if (parameter[GFX_ARG_XOFFSET] != ARG_UNDEFINED_VALUE)
 977     graphic_info[graphic].offset_x = parameter[GFX_ARG_XOFFSET];
 978   if (parameter[GFX_ARG_YOFFSET] != ARG_UNDEFINED_VALUE)
 979     graphic_info[graphic].offset_y = parameter[GFX_ARG_YOFFSET];
 980
 981   /* automatically determine correct number of frames, if not defined */
 982   if (parameter[GFX_ARG_FRAMES] != ARG_UNDEFINED_VALUE)
 983     graphic_info[graphic].anim_frames = parameter[GFX_ARG_FRAMES];
 984   else if (parameter[GFX_ARG_XPOS] == 0 && !parameter[GFX_ARG_VERTICAL])
 985     graphic_info[graphic].anim_frames = num_xtiles;
 986   else if (parameter[GFX_ARG_YPOS] == 0 && parameter[GFX_ARG_VERTICAL])
 987     graphic_info[graphic].anim_frames = num_ytiles;
 988   else
 989     graphic_info[graphic].anim_frames = 1;
 990
 991   graphic_info[graphic].anim_delay = parameter[GFX_ARG_DELAY];
 992   if (graphic_info[graphic].anim_delay == 0)    /* delay must be at least 1 */
 993     graphic_info[graphic].anim_delay = 1;
 994
 995   /* set mode for animation frame order */
 996   if (parameter[GFX_ARG_MODE_LOOP])
 997     graphic_info[graphic].anim_mode = ANIM_LOOP;
 998   else if (parameter[GFX_ARG_MODE_LINEAR])
 999     graphic_info[graphic].anim_mode = ANIM_LINEAR;
1000   else if (parameter[GFX_ARG_MODE_PINGPONG])
1001     graphic_info[graphic].anim_mode = ANIM_PINGPONG;
1002   else if (parameter[GFX_ARG_MODE_PINGPONG2])
1003     graphic_info[graphic].anim_mode = ANIM_PINGPONG2;
1004   else if (parameter[GFX_ARG_MODE_RANDOM])
1005     graphic_info[graphic].anim_mode = ANIM_RANDOM;
1006   else if (graphic_info[graphic].anim_frames > 1)
1007     graphic_info[graphic].anim_mode = ANIM_LOOP;
1008   else
1009     graphic_info[graphic].anim_mode = ANIM_NONE;
1010
1011   /* set additional flag to play animation frames in reverse order */
1012   if (parameter[GFX_ARG_MODE_REVERSE])
1013     graphic_info[graphic].anim_mode |= ANIM_REVERSE;
1014
1015   /* automatically determine correct start frame, if not defined */
1016   if (parameter[GFX_ARG_START_FRAME] == ARG_UNDEFINED_VALUE)
1017     graphic_info[graphic].anim_start_frame = 0;
1018   else if (graphic_info[graphic].anim_mode & ANIM_REVERSE)
1019     graphic_info[graphic].anim_start_frame =
1020       graphic_info[graphic].anim_frames - parameter[GFX_ARG_START_FRAME] - 1;
1021   else
1022     graphic_info[graphic].anim_start_frame = parameter[GFX_ARG_START_FRAME];
1023
1024   /* animation synchronized with global frame counter, not move position */
1025   graphic_info[graphic].anim_global_sync = parameter[GFX_ARG_GLOBAL_SYNC];
1026
1027   /* this is only used for toon animations */
1028   graphic_info[graphic].step_offset = parameter[GFX_ARG_STEP_OFFSET];
1029   graphic_info[graphic].step_delay  = parameter[GFX_ARG_STEP_DELAY];
1030
1031   /* this is only used for drawing font characters */
1032   graphic_info[graphic].draw_x = parameter[GFX_ARG_DRAW_XOFFSET];
1033   graphic_info[graphic].draw_y = parameter[GFX_ARG_DRAW_YOFFSET];
1034 }
1035
1036 static void InitGraphicInfo()
1037 {
1038   int fallback_graphic = IMG_CHAR_EXCLAM;
1039   struct FileInfo *fallback_image = getImageListEntry(fallback_graphic);
1040   Bitmap *fallback_bitmap = getBitmapFromImageID(fallback_graphic);
1041   int num_images = getImageListSize();
1042   int i;
1043
1044 #if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
1045   static boolean clipmasks_initialized = FALSE;
1046   Pixmap src_pixmap;
1047   XGCValues clip_gc_values;
1048   unsigned long clip_gc_valuemask;
1049   GC copy_clipmask_gc = None;
1050 #endif
1051
1052   if (graphic_info != NULL)
1053     free(graphic_info);
1054
1055   graphic_info = checked_calloc(num_images * sizeof(struct GraphicInfo));
1056
1057 #if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
1058   if (clipmasks_initialized)
1059   {
1060     for (i=0; i<num_images; i++)
1061     {
1062       if (graphic_info[i].clip_mask)
1063         XFreePixmap(display, graphic_info[i].clip_mask);
1064       if (graphic_info[i].clip_gc)
1065         XFreeGC(display, graphic_info[i].clip_gc);
1066
1067       graphic_info[i].clip_mask = None;
1068       graphic_info[i].clip_gc = None;
1069     }
1070   }
1071 #endif
1072
1073   for (i=0; i<num_images; i++)
1074   {
1075     struct FileInfo *image = getImageListEntry(i);
1076     Bitmap *src_bitmap;
1077     int src_x, src_y;
1078     int first_frame, last_frame;
1079
1080     set_graphic_parameters(i, image->parameter);
1081
1082     /* now check if no animation frames are outside of the loaded image */
1083
1084     if (graphic_info[i].bitmap == NULL)
1085       continue;         /* skip check for optional images that are undefined */
1086
1087     first_frame = 0;
1088     getGraphicSource(i, first_frame, &src_bitmap, &src_x, &src_y);
1089     if (src_x < 0 || src_y < 0 ||
1090         src_x + TILEX > src_bitmap->width ||
1091         src_y + TILEY > src_bitmap->height)
1092     {
1093       Error(ERR_RETURN_LINE, "-");
1094       Error(ERR_RETURN, "warning: error found in config file:");
1095       Error(ERR_RETURN, "- config file: '%s'",
1096             getImageConfigFilename());
1097       Error(ERR_RETURN, "- config token: '%s'",
1098             getTokenFromImageID(i));
1099       Error(ERR_RETURN, "- image file: '%s'",
1100             src_bitmap->source_filename);
1101       Error(ERR_RETURN,
1102             "error: first animation frame out of bounds (%d, %d)",
1103             src_x, src_y);
1104       Error(ERR_RETURN, "custom graphic rejected for this element/action");
1105
1106       if (i == fallback_graphic)
1107         Error(ERR_EXIT, "fatal error: no fallback graphic available");
1108
1109       Error(ERR_RETURN, "fallback done to 'char_exclam' for this graphic");
1110       Error(ERR_RETURN_LINE, "-");
1111
1112       set_graphic_parameters(i, fallback_image->default_parameter);
1113       graphic_info[i].bitmap = fallback_bitmap;
1114     }
1115
1116     last_frame = graphic_info[i].anim_frames - 1;
1117     getGraphicSource(i, last_frame, &src_bitmap, &src_x, &src_y);
1118     if (src_x < 0 || src_y < 0 ||
1119         src_x + TILEX > src_bitmap->width ||
1120         src_y + TILEY > src_bitmap->height)
1121     {
1122       Error(ERR_RETURN_LINE, "-");
1123       Error(ERR_RETURN, "warning: error found in config file:");
1124       Error(ERR_RETURN, "- config file: '%s'",
1125             getImageConfigFilename());
1126       Error(ERR_RETURN, "- config token: '%s'",
1127             getTokenFromImageID(i));
1128       Error(ERR_RETURN, "- image file: '%s'",
1129             src_bitmap->source_filename);
1130       Error(ERR_RETURN,
1131             "error: last animation frame (%d) out of bounds (%d, %d)",
1132             last_frame, src_x, src_y);
1133       Error(ERR_RETURN, "custom graphic rejected for this element/action");
1134
1135       if (i == fallback_graphic)
1136         Error(ERR_EXIT, "fatal error: no fallback graphic available");
1137
1138       Error(ERR_RETURN, "fallback done to 'char_exclam' for this graphic");
1139       Error(ERR_RETURN_LINE, "-");
1140
1141       set_graphic_parameters(i, fallback_image->default_parameter);
1142       graphic_info[i].bitmap = fallback_bitmap;
1143     }
1144
1145 #if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
1146     /* currently we need only a tile clip mask from the first frame */
1147     getGraphicSource(i, first_frame, &src_bitmap, &src_x, &src_y);
1148
1149     if (copy_clipmask_gc == None)
1150     {
1151       clip_gc_values.graphics_exposures = False;
1152       clip_gc_valuemask = GCGraphicsExposures;
1153       copy_clipmask_gc = XCreateGC(display, src_bitmap->clip_mask,
1154                                    clip_gc_valuemask, &clip_gc_values);
1155     }
1156
1157     graphic_info[i].clip_mask =
1158       XCreatePixmap(display, window->drawable, TILEX, TILEY, 1);
1159
1160     src_pixmap = src_bitmap->clip_mask;
1161     XCopyArea(display, src_pixmap, graphic_info[i].clip_mask,
1162               copy_clipmask_gc, src_x, src_y, TILEX, TILEY, 0, 0);
1163
1164     clip_gc_values.graphics_exposures = False;
1165     clip_gc_values.clip_mask = graphic_info[i].clip_mask;
1166     clip_gc_valuemask = GCGraphicsExposures | GCClipMask;
1167
1168     graphic_info[i].clip_gc =
1169       XCreateGC(display, window->drawable, clip_gc_valuemask, &clip_gc_values);
1170 #endif
1171   }
1172
1173 #if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
1174   if (copy_clipmask_gc)
1175     XFreeGC(display, copy_clipmask_gc);
1176
1177   clipmasks_initialized = TRUE;
1178 #endif
1179 }
1180
1181 static void InitElementSoundInfo()
1182 {
1183   /* !!! soon to come !!! */
1184 }
1185
1186 static void set_sound_parameters(int sound, char **parameter_raw)
1187 {
1188   int parameter[NUM_SND_ARGS];
1189   int i;
1190
1191   /* get integer values from string parameters */
1192   for (i=0; i < NUM_SND_ARGS; i++)
1193     parameter[i] =
1194       get_parameter_value(sound_config_suffix[i].type, parameter_raw[i]);
1195
1196   /* explicit loop mode setting in configuration overrides default value */
1197   if (parameter[SND_ARG_MODE_LOOP] != ARG_UNDEFINED_VALUE)
1198     sound_info[sound].loop = parameter[SND_ARG_MODE_LOOP];
1199 }
1200
1201 static void InitSoundInfo()
1202 {
1203   struct PropertyMapping *property_mapping = getSoundListPropertyMapping();
1204   int num_property_mappings = getSoundListPropertyMappingSize();
1205   int *sound_effect_properties;
1206   int num_sounds = getSoundListSize();
1207   int i, j;
1208
1209   if (sound_info != NULL)
1210     free(sound_info);
1211
1212   sound_effect_properties = checked_calloc(num_sounds * sizeof(int));
1213   sound_info = checked_calloc(num_sounds * sizeof(struct SoundInfo));
1214
1215   /* initialize sound effect for all elements to "no sound" */
1216   for (i=0; i<MAX_NUM_ELEMENTS; i++)
1217     for (j=0; j<NUM_ACTIONS; j++)
1218       element_info[i].sound[j] = SND_UNDEFINED;
1219
1220   for (i=0; i<num_sounds; i++)
1221   {
1222     struct FileInfo *sound = getSoundListEntry(i);
1223     int len_effect_text = strlen(sound->token);
1224
1225     sound_effect_properties[i] = ACTION_OTHER;
1226     sound_info[i].loop = FALSE;
1227
1228     /* determine all loop sounds and identify certain sound classes */
1229
1230     for (j=0; element_action_info[j].suffix; j++)
1231     {
1232       int len_action_text = strlen(element_action_info[j].suffix);
1233
1234       if (len_action_text < len_effect_text &&
1235           strcmp(&sound->token[len_effect_text - len_action_text],
1236                  element_action_info[j].suffix) == 0)
1237       {
1238         sound_effect_properties[i] = element_action_info[j].value;
1239
1240         if (element_action_info[j].is_loop_sound)
1241           sound_info[i].loop = TRUE;
1242       }
1243     }
1244
1245     /* associate elements and some selected sound actions */
1246
1247     for (j=0; j<MAX_NUM_ELEMENTS; j++)
1248     {
1249       if (element_info[j].sound_class_name)
1250       {
1251         int len_class_text = strlen(element_info[j].sound_class_name);
1252
1253         if (len_class_text + 1 < len_effect_text &&
1254             strncmp(sound->token,
1255                     element_info[j].sound_class_name, len_class_text) == 0 &&
1256             sound->token[len_class_text] == '.')
1257         {
1258           int sound_action_value = sound_effect_properties[i];
1259
1260           element_info[j].sound[sound_action_value] = i;
1261         }
1262       }
1263     }
1264
1265     set_sound_parameters(i, sound->parameter);
1266   }
1267
1268   free(sound_effect_properties);
1269
1270   /* initialize element/sound mapping from dynamic configuration */
1271   for (i=0; i < num_property_mappings; i++)
1272   {
1273     int element   = property_mapping[i].base_index;
1274     int action    = property_mapping[i].ext1_index;
1275     int sound     = property_mapping[i].artwork_index;
1276
1277     if (action < 0)
1278       action = ACTION_DEFAULT;
1279
1280     element_info[element].sound[action] = sound;
1281   }
1282
1283 #if 0
1284   /* TEST ONLY */
1285   {
1286     int element = EL_CUSTOM_11;
1287     int j = 0;
1288
1289     while (element_action_info[j].suffix)
1290     {
1291       printf("element %d, sound action '%s'  == %d\n",
1292              element, element_action_info[j].suffix,
1293              element_info[element].sound[j]);
1294       j++;
1295     }
1296   }
1297
1298   PlaySoundLevelElementAction(0,0, EL_CUSTOM_11, ACTION_PUSHING);
1299 #endif
1300
1301 #if 0
1302   /* TEST ONLY */
1303   {
1304     int element = EL_SAND;
1305     int sound_action = ACTION_DIGGING;
1306     int j = 0;
1307
1308     while (element_action_info[j].suffix)
1309     {
1310       if (element_action_info[j].value == sound_action)
1311         printf("element %d, sound action '%s'  == %d\n",
1312                element, element_action_info[j].suffix,
1313                element_info[element].sound[sound_action]);
1314       j++;
1315     }
1316   }
1317 #endif
1318 }
1319
1320 void InitElementProperties()
1321 {
1322   int i, j;
1323
1324   static int ep_amoebalive[] =
1325   {
1326     EL_AMOEBA_WET,
1327     EL_AMOEBA_DRY,
1328     EL_AMOEBA_FULL,
1329     EL_BD_AMOEBA
1330   };
1331   static int ep_amoebalive_num = SIZEOF_ARRAY_INT(ep_amoebalive);
1332
1333   static int ep_amoeboid[] =
1334   {
1335     EL_AMOEBA_DEAD,
1336     EL_AMOEBA_WET,
1337     EL_AMOEBA_DRY,
1338     EL_AMOEBA_FULL,
1339     EL_BD_AMOEBA
1340   };
1341   static int ep_amoeboid_num = SIZEOF_ARRAY_INT(ep_amoeboid);
1342
1343   static int ep_schluessel[] =
1344   {
1345     EL_KEY1,
1346     EL_KEY2,
1347     EL_KEY3,
1348     EL_KEY4,
1349     EL_EM_KEY1,
1350     EL_EM_KEY2,
1351     EL_EM_KEY3,
1352     EL_EM_KEY4
1353   };
1354   static int ep_schluessel_num = SIZEOF_ARRAY_INT(ep_schluessel);
1355
1356   static int ep_pforte[] =
1357   {
1358     EL_GATE1,
1359     EL_GATE2,
1360     EL_GATE3,
1361     EL_GATE4,
1362     EL_GATE1_GRAY,
1363     EL_GATE2_GRAY,
1364     EL_GATE3_GRAY,
1365     EL_GATE4_GRAY,
1366     EL_EM_GATE1,
1367     EL_EM_GATE2,
1368     EL_EM_GATE3,
1369     EL_EM_GATE4,
1370     EL_EM_GATE1_GRAY,
1371     EL_EM_GATE2_GRAY,
1372     EL_EM_GATE3_GRAY,
1373     EL_EM_GATE4_GRAY,
1374     EL_SWITCHGATE_OPEN,
1375     EL_SWITCHGATE_OPENING,
1376     EL_SWITCHGATE_CLOSED,
1377     EL_SWITCHGATE_CLOSING,
1378     EL_TIMEGATE_OPEN,
1379     EL_TIMEGATE_OPENING,
1380     EL_TIMEGATE_CLOSED,
1381     EL_TIMEGATE_CLOSING,
1382     EL_TUBE_ALL,
1383     EL_TUBE_VERTICAL,
1384     EL_TUBE_HORIZONTAL,
1385     EL_TUBE_VERTICAL_LEFT,
1386     EL_TUBE_VERTICAL_RIGHT,
1387     EL_TUBE_HORIZONTAL_UP,
1388     EL_TUBE_HORIZONTAL_DOWN,
1389     EL_TUBE_LEFT_UP,
1390     EL_TUBE_LEFT_DOWN,
1391     EL_TUBE_RIGHT_UP,
1392     EL_TUBE_RIGHT_DOWN
1393   };
1394   static int ep_pforte_num = SIZEOF_ARRAY_INT(ep_pforte);
1395
1396   static int ep_solid[] =
1397   {
1398     EL_WALL,
1399     EL_WALL_GROWING,
1400     EL_WALL_GROWING_X,
1401     EL_WALL_GROWING_Y,
1402     EL_WALL_GROWING_XY,
1403     EL_BD_WALL,
1404     EL_WALL_CRUMBLED,
1405     EL_EXIT_CLOSED,
1406     EL_EXIT_OPENING,
1407     EL_EXIT_OPEN,
1408     EL_AMOEBA_DEAD,
1409     EL_AMOEBA_WET,
1410     EL_AMOEBA_DRY,
1411     EL_AMOEBA_FULL,
1412     EL_BD_AMOEBA,
1413     EL_QUICKSAND_FULL,
1414     EL_QUICKSAND_EMPTY,
1415     EL_QUICKSAND_FILLING,
1416     EL_QUICKSAND_EMPTYING,
1417     EL_MAGIC_WALL,
1418     EL_MAGIC_WALL_ACTIVE,
1419     EL_MAGIC_WALL_EMPTYING,
1420     EL_MAGIC_WALL_FILLING,
1421     EL_MAGIC_WALL_FULL,
1422     EL_MAGIC_WALL_DEAD,
1423     EL_BD_MAGIC_WALL,
1424     EL_BD_MAGIC_WALL_ACTIVE,
1425     EL_BD_MAGIC_WALL_EMPTYING,
1426     EL_BD_MAGIC_WALL_FULL,
1427     EL_BD_MAGIC_WALL_FILLING,
1428     EL_BD_MAGIC_WALL_DEAD,
1429     EL_GAMEOFLIFE,
1430     EL_BIOMAZE,
1431     EL_SP_CHIP_SINGLE,
1432     EL_SP_CHIP_LEFT,
1433     EL_SP_CHIP_RIGHT,
1434     EL_SP_CHIP_UPPER,
1435     EL_SP_CHIP_LOWER,
1436     EL_SP_TERMINAL,
1437     EL_SP_TERMINAL_ACTIVE,
1438     EL_SP_EXIT_CLOSED,
1439     EL_SP_EXIT_OPEN,
1440     EL_INVISIBLE_WALL,
1441     EL_INVISIBLE_WALL_ACTIVE,
1442     EL_SWITCHGATE_SWITCH_UP,
1443     EL_SWITCHGATE_SWITCH_DOWN,
1444     EL_TIMEGATE_SWITCH,
1445     EL_TIMEGATE_SWITCH_ACTIVE,
1446     EL_EMC_WALL_PILLAR_UPPER,
1447     EL_EMC_WALL_PILLAR_MIDDLE,
1448     EL_EMC_WALL_PILLAR_LOWER,
1449     EL_EMC_WALL4,
1450     EL_EMC_WALL5,
1451     EL_EMC_WALL6,
1452     EL_EMC_WALL7,
1453     EL_EMC_WALL8,
1454     EL_WALL_PEARL,
1455     EL_WALL_CRYSTAL,
1456
1457     /* the following elements are a direct copy of "indestructible" elements,
1458        except "EL_ACID", which is "indestructible", but not "solid"! */
1459 #if 0
1460     EL_ACID,
1461 #endif
1462     EL_STEELWALL,
1463     EL_ACIDPOOL_TOPLEFT,
1464     EL_ACIDPOOL_TOPRIGHT,
1465     EL_ACIDPOOL_BOTTOMLEFT,
1466     EL_ACIDPOOL_BOTTOM,
1467     EL_ACIDPOOL_BOTTOMRIGHT,
1468     EL_SP_HARD_GRAY,
1469     EL_SP_HARD_GREEN,
1470     EL_SP_HARD_BLUE,
1471     EL_SP_HARD_RED,
1472     EL_SP_HARD_YELLOW,
1473     EL_SP_HARD_BASE1,
1474     EL_SP_HARD_BASE2,
1475     EL_SP_HARD_BASE3,
1476     EL_SP_HARD_BASE4,
1477     EL_SP_HARD_BASE5,
1478     EL_SP_HARD_BASE6,
1479     EL_INVISIBLE_STEELWALL,
1480     EL_INVISIBLE_STEELWALL_ACTIVE,
1481     EL_CONVEYOR_BELT1_SWITCH_LEFT,
1482     EL_CONVEYOR_BELT1_SWITCH_MIDDLE,
1483     EL_CONVEYOR_BELT1_SWITCH_RIGHT,
1484     EL_CONVEYOR_BELT2_SWITCH_LEFT,
1485     EL_CONVEYOR_BELT2_SWITCH_MIDDLE,
1486     EL_CONVEYOR_BELT2_SWITCH_RIGHT,
1487     EL_CONVEYOR_BELT3_SWITCH_LEFT,
1488     EL_CONVEYOR_BELT3_SWITCH_MIDDLE,
1489     EL_CONVEYOR_BELT3_SWITCH_RIGHT,
1490     EL_CONVEYOR_BELT4_SWITCH_LEFT,
1491     EL_CONVEYOR_BELT4_SWITCH_MIDDLE,
1492     EL_CONVEYOR_BELT4_SWITCH_RIGHT,
1493     EL_LIGHT_SWITCH,
1494     EL_LIGHT_SWITCH_ACTIVE,
1495     EL_SIGN_EXCLAMATION,
1496     EL_SIGN_RADIOACTIVITY,
1497     EL_SIGN_STOP,
1498     EL_SIGN_WHEELCHAIR,
1499     EL_SIGN_PARKING,
1500     EL_SIGN_ONEWAY,
1501     EL_SIGN_HEART,
1502     EL_SIGN_TRIANGLE,
1503     EL_SIGN_ROUND,
1504     EL_SIGN_EXIT,
1505     EL_SIGN_YINYANG,
1506     EL_SIGN_OTHER,
1507     EL_STEELWALL_SLANTED,
1508     EL_EMC_STEELWALL1,
1509     EL_EMC_STEELWALL2,
1510     EL_EMC_STEELWALL3,
1511     EL_EMC_STEELWALL4,
1512     EL_CRYSTAL,
1513     EL_GATE1,
1514     EL_GATE2,
1515     EL_GATE3,
1516     EL_GATE4,
1517     EL_GATE1_GRAY,
1518     EL_GATE2_GRAY,
1519     EL_GATE3_GRAY,
1520     EL_GATE4_GRAY,
1521     EL_EM_GATE1,
1522     EL_EM_GATE2,
1523     EL_EM_GATE3,
1524     EL_EM_GATE4,
1525     EL_EM_GATE1_GRAY,
1526     EL_EM_GATE2_GRAY,
1527     EL_EM_GATE3_GRAY,
1528     EL_EM_GATE4_GRAY,
1529     EL_SWITCHGATE_OPEN,
1530     EL_SWITCHGATE_OPENING,
1531     EL_SWITCHGATE_CLOSED,
1532     EL_SWITCHGATE_CLOSING,
1533     EL_TIMEGATE_OPEN,
1534     EL_TIMEGATE_OPENING,
1535     EL_TIMEGATE_CLOSED,
1536     EL_TIMEGATE_CLOSING,
1537     EL_TUBE_ALL,
1538     EL_TUBE_VERTICAL,
1539     EL_TUBE_HORIZONTAL,
1540     EL_TUBE_VERTICAL_LEFT,
1541     EL_TUBE_VERTICAL_RIGHT,
1542     EL_TUBE_HORIZONTAL_UP,
1543     EL_TUBE_HORIZONTAL_DOWN,
1544     EL_TUBE_LEFT_UP,
1545     EL_TUBE_LEFT_DOWN,
1546     EL_TUBE_RIGHT_UP,
1547     EL_TUBE_RIGHT_DOWN
1548   };
1549   static int ep_solid_num = SIZEOF_ARRAY_INT(ep_solid);
1550
1551   static int ep_indestructible[] =
1552   {
1553     EL_STEELWALL,
1554     EL_ACID,
1555     EL_ACIDPOOL_TOPLEFT,
1556     EL_ACIDPOOL_TOPRIGHT,
1557     EL_ACIDPOOL_BOTTOMLEFT,
1558     EL_ACIDPOOL_BOTTOM,
1559     EL_ACIDPOOL_BOTTOMRIGHT,
1560     EL_SP_HARD_GRAY,
1561     EL_SP_HARD_GREEN,
1562     EL_SP_HARD_BLUE,
1563     EL_SP_HARD_RED,
1564     EL_SP_HARD_YELLOW,
1565     EL_SP_HARD_BASE1,
1566     EL_SP_HARD_BASE2,
1567     EL_SP_HARD_BASE3,
1568     EL_SP_HARD_BASE4,
1569     EL_SP_HARD_BASE5,
1570     EL_SP_HARD_BASE6,
1571     EL_INVISIBLE_STEELWALL,
1572     EL_INVISIBLE_STEELWALL_ACTIVE,
1573     EL_CONVEYOR_BELT1_SWITCH_LEFT,
1574     EL_CONVEYOR_BELT1_SWITCH_MIDDLE,
1575     EL_CONVEYOR_BELT1_SWITCH_RIGHT,
1576     EL_CONVEYOR_BELT2_SWITCH_LEFT,
1577     EL_CONVEYOR_BELT2_SWITCH_MIDDLE,
1578     EL_CONVEYOR_BELT2_SWITCH_RIGHT,
1579     EL_CONVEYOR_BELT3_SWITCH_LEFT,
1580     EL_CONVEYOR_BELT3_SWITCH_MIDDLE,
1581     EL_CONVEYOR_BELT3_SWITCH_RIGHT,
1582     EL_CONVEYOR_BELT4_SWITCH_LEFT,
1583     EL_CONVEYOR_BELT4_SWITCH_MIDDLE,
1584     EL_CONVEYOR_BELT4_SWITCH_RIGHT,
1585     EL_LIGHT_SWITCH,
1586     EL_LIGHT_SWITCH_ACTIVE,
1587     EL_SIGN_EXCLAMATION,
1588     EL_SIGN_RADIOACTIVITY,
1589     EL_SIGN_STOP,
1590     EL_SIGN_WHEELCHAIR,
1591     EL_SIGN_PARKING,
1592     EL_SIGN_ONEWAY,
1593     EL_SIGN_HEART,
1594     EL_SIGN_TRIANGLE,
1595     EL_SIGN_ROUND,
1596     EL_SIGN_EXIT,
1597     EL_SIGN_YINYANG,
1598     EL_SIGN_OTHER,
1599     EL_STEELWALL_SLANTED,
1600     EL_EMC_STEELWALL1,
1601     EL_EMC_STEELWALL2,
1602     EL_EMC_STEELWALL3,
1603     EL_EMC_STEELWALL4,
1604     EL_CRYSTAL,
1605     EL_GATE1,
1606     EL_GATE2,
1607     EL_GATE3,
1608     EL_GATE4,
1609     EL_GATE1_GRAY,
1610     EL_GATE2_GRAY,
1611     EL_GATE3_GRAY,
1612     EL_GATE4_GRAY,
1613     EL_EM_GATE1,
1614     EL_EM_GATE2,
1615     EL_EM_GATE3,
1616     EL_EM_GATE4,
1617     EL_EM_GATE1_GRAY,
1618     EL_EM_GATE2_GRAY,
1619     EL_EM_GATE3_GRAY,
1620     EL_EM_GATE4_GRAY,
1621     EL_SWITCHGATE_OPEN,
1622     EL_SWITCHGATE_OPENING,
1623     EL_SWITCHGATE_CLOSED,
1624     EL_SWITCHGATE_CLOSING,
1625     EL_TIMEGATE_OPEN,
1626     EL_TIMEGATE_OPENING,
1627     EL_TIMEGATE_CLOSED,
1628     EL_TIMEGATE_CLOSING,
1629     EL_TUBE_ALL,
1630     EL_TUBE_VERTICAL,
1631     EL_TUBE_HORIZONTAL,
1632     EL_TUBE_VERTICAL_LEFT,
1633     EL_TUBE_VERTICAL_RIGHT,
1634     EL_TUBE_HORIZONTAL_UP,
1635     EL_TUBE_HORIZONTAL_DOWN,
1636     EL_TUBE_LEFT_UP,
1637     EL_TUBE_LEFT_DOWN,
1638     EL_TUBE_RIGHT_UP,
1639     EL_TUBE_RIGHT_DOWN
1640   };
1641   static int ep_indestructible_num = SIZEOF_ARRAY_INT(ep_indestructible);
1642
1643   static int ep_slippery[] =
1644   {
1645     EL_WALL_CRUMBLED,
1646     EL_BD_WALL,
1647     EL_ROCK,
1648     EL_BD_ROCK,
1649     EL_EMERALD,
1650     EL_BD_DIAMOND,
1651     EL_EMERALD_YELLOW,
1652     EL_EMERALD_RED,
1653     EL_EMERALD_PURPLE,
1654     EL_DIAMOND,
1655     EL_BOMB,
1656     EL_NUT,
1657     EL_ROBOT_WHEEL_ACTIVE,
1658     EL_ROBOT_WHEEL,
1659     EL_TIME_ORB_FULL,
1660     EL_TIME_ORB_EMPTY,
1661     EL_LAMP_ACTIVE,
1662     EL_LAMP,
1663     EL_ACIDPOOL_TOPLEFT,
1664     EL_ACIDPOOL_TOPRIGHT,
1665     EL_SATELLITE,
1666     EL_SP_ZONK,
1667     EL_SP_INFOTRON,
1668     EL_SP_CHIP_SINGLE,
1669     EL_SP_CHIP_LEFT,
1670     EL_SP_CHIP_RIGHT,
1671     EL_SP_CHIP_UPPER,
1672     EL_SP_CHIP_LOWER,
1673     EL_SPEED_PILL,
1674     EL_STEELWALL_SLANTED,
1675     EL_PEARL,
1676     EL_CRYSTAL
1677   };
1678   static int ep_slippery_num = SIZEOF_ARRAY_INT(ep_slippery);
1679
1680   static int ep_enemy[] =
1681   {
1682     EL_BUG,
1683     EL_SPACESHIP,
1684     EL_BD_BUTTERFLY,
1685     EL_BD_FIREFLY,
1686     EL_YAMYAM,
1687     EL_DARK_YAMYAM,
1688     EL_ROBOT,
1689     EL_PACMAN,
1690     EL_SP_SNIKSNAK,
1691     EL_SP_ELECTRON
1692   };
1693   static int ep_enemy_num = SIZEOF_ARRAY_INT(ep_enemy);
1694
1695   static int ep_mauer[] =
1696   {
1697     EL_STEELWALL,
1698     EL_GATE1,
1699     EL_GATE2,
1700     EL_GATE3,
1701     EL_GATE4,
1702     EL_GATE1_GRAY,
1703     EL_GATE2_GRAY,
1704     EL_GATE3_GRAY,
1705     EL_GATE4_GRAY,
1706     EL_EM_GATE1,
1707     EL_EM_GATE2,
1708     EL_EM_GATE3,
1709     EL_EM_GATE4,
1710     EL_EM_GATE1_GRAY,
1711     EL_EM_GATE2_GRAY,
1712     EL_EM_GATE3_GRAY,
1713     EL_EM_GATE4_GRAY,
1714     EL_EXIT_CLOSED,
1715     EL_EXIT_OPENING,
1716     EL_EXIT_OPEN,
1717     EL_WALL,
1718     EL_WALL_CRUMBLED,
1719     EL_WALL_GROWING,
1720     EL_WALL_GROWING_X,
1721     EL_WALL_GROWING_Y,
1722     EL_WALL_GROWING_XY,
1723     EL_WALL_GROWING_ACTIVE,
1724     EL_BD_WALL,
1725     EL_SP_CHIP_SINGLE,
1726     EL_SP_CHIP_LEFT,
1727     EL_SP_CHIP_RIGHT,
1728     EL_SP_CHIP_UPPER,
1729     EL_SP_CHIP_LOWER,
1730     EL_SP_HARD_GRAY,
1731     EL_SP_HARD_GREEN,
1732     EL_SP_HARD_BLUE,
1733     EL_SP_HARD_RED,
1734     EL_SP_HARD_YELLOW,
1735     EL_SP_HARD_BASE1,
1736     EL_SP_HARD_BASE2,
1737     EL_SP_HARD_BASE3,
1738     EL_SP_HARD_BASE4,
1739     EL_SP_HARD_BASE5,
1740     EL_SP_HARD_BASE6,
1741     EL_SP_TERMINAL,
1742     EL_SP_TERMINAL_ACTIVE,
1743     EL_SP_EXIT_CLOSED,
1744     EL_SP_EXIT_OPEN,
1745     EL_INVISIBLE_STEELWALL,
1746     EL_INVISIBLE_STEELWALL_ACTIVE,
1747     EL_INVISIBLE_WALL,
1748     EL_INVISIBLE_WALL_ACTIVE,
1749     EL_STEELWALL_SLANTED,
1750     EL_EMC_STEELWALL1,
1751     EL_EMC_STEELWALL2,
1752     EL_EMC_STEELWALL3,
1753     EL_EMC_STEELWALL4,
1754     EL_EMC_WALL_PILLAR_UPPER,
1755     EL_EMC_WALL_PILLAR_MIDDLE,
1756     EL_EMC_WALL_PILLAR_LOWER,
1757     EL_EMC_WALL4,
1758     EL_EMC_WALL5,
1759     EL_EMC_WALL6,
1760     EL_EMC_WALL7,
1761     EL_EMC_WALL8
1762   };
1763   static int ep_mauer_num = SIZEOF_ARRAY_INT(ep_mauer);
1764
1765   static int ep_can_fall[] =
1766   {
1767     EL_ROCK,
1768     EL_BD_ROCK,
1769     EL_EMERALD,
1770     EL_BD_DIAMOND,
1771     EL_EMERALD_YELLOW,
1772     EL_EMERALD_RED,
1773     EL_EMERALD_PURPLE,
1774     EL_DIAMOND,
1775     EL_BOMB,
1776     EL_NUT,
1777     EL_AMOEBA_DROP,
1778     EL_QUICKSAND_FULL,
1779     EL_MAGIC_WALL_FULL,
1780     EL_BD_MAGIC_WALL_FULL,
1781     EL_TIME_ORB_FULL,
1782     EL_TIME_ORB_EMPTY,
1783     EL_SP_ZONK,
1784     EL_SP_INFOTRON,
1785     EL_SP_DISK_ORANGE,
1786     EL_PEARL,
1787     EL_CRYSTAL,
1788     EL_SPRING,
1789     EL_DX_SUPABOMB
1790   };
1791   static int ep_can_fall_num = SIZEOF_ARRAY_INT(ep_can_fall);
1792
1793   static int ep_can_smash[] =
1794   {
1795     EL_ROCK,
1796     EL_BD_ROCK,
1797     EL_EMERALD,
1798     EL_BD_DIAMOND,
1799     EL_EMERALD_YELLOW,
1800     EL_EMERALD_RED,
1801     EL_EMERALD_PURPLE,
1802     EL_DIAMOND,
1803     EL_BOMB,
1804     EL_NUT,
1805     EL_AMOEBA_DROP,
1806     EL_TIME_ORB_FULL,
1807     EL_TIME_ORB_EMPTY,
1808     EL_SP_ZONK,
1809     EL_SP_INFOTRON,
1810     EL_SP_DISK_ORANGE,
1811     EL_PEARL,
1812     EL_CRYSTAL,
1813     EL_SPRING,
1814     EL_DX_SUPABOMB
1815   };
1816   static int ep_can_smash_num = SIZEOF_ARRAY_INT(ep_can_smash);
1817
1818   static int ep_can_change[] =
1819   {
1820     EL_ROCK,
1821     EL_BD_ROCK,
1822     EL_EMERALD,
1823     EL_BD_DIAMOND,
1824     EL_EMERALD_YELLOW,
1825     EL_EMERALD_RED,
1826     EL_EMERALD_PURPLE,
1827     EL_DIAMOND
1828   };
1829   static int ep_can_change_num = SIZEOF_ARRAY_INT(ep_can_change);
1830
1831   static int ep_can_move[] =
1832   {
1833     EL_BUG,
1834     EL_SPACESHIP,
1835     EL_BD_BUTTERFLY,
1836     EL_BD_FIREFLY,
1837     EL_YAMYAM,
1838     EL_DARK_YAMYAM,
1839     EL_ROBOT,
1840     EL_PACMAN,
1841     EL_MOLE,
1842     EL_PENGUIN,
1843     EL_PIG,
1844     EL_DRAGON,
1845     EL_SATELLITE,
1846     EL_SP_SNIKSNAK,
1847     EL_SP_ELECTRON,
1848     EL_BALLOON,
1849     EL_SPRING
1850   };
1851   static int ep_can_move_num = SIZEOF_ARRAY_INT(ep_can_move);
1852
1853   static int ep_could_move[] =
1854   {
1855     EL_BUG_RIGHT,
1856     EL_BUG_UP,
1857     EL_BUG_LEFT,
1858     EL_BUG_DOWN,
1859     EL_SPACESHIP_RIGHT,
1860     EL_SPACESHIP_UP,
1861     EL_SPACESHIP_LEFT,
1862     EL_SPACESHIP_DOWN,
1863     EL_BD_BUTTERFLY_RIGHT,
1864     EL_BD_BUTTERFLY_UP,
1865     EL_BD_BUTTERFLY_LEFT,
1866     EL_BD_BUTTERFLY_DOWN,
1867     EL_BD_FIREFLY_RIGHT,
1868     EL_BD_FIREFLY_UP,
1869     EL_BD_FIREFLY_LEFT,
1870     EL_BD_FIREFLY_DOWN,
1871     EL_PACMAN_RIGHT,
1872     EL_PACMAN_UP,
1873     EL_PACMAN_LEFT,
1874     EL_PACMAN_DOWN
1875   };
1876   static int ep_could_move_num = SIZEOF_ARRAY_INT(ep_could_move);
1877
1878   static int ep_dont_touch[] =
1879   {
1880     EL_BUG,
1881     EL_SPACESHIP,
1882     EL_BD_BUTTERFLY,
1883     EL_BD_FIREFLY
1884   };
1885   static int ep_dont_touch_num = SIZEOF_ARRAY_INT(ep_dont_touch);
1886
1887   static int ep_dont_go_to[] =
1888   {
1889     EL_BUG,
1890     EL_SPACESHIP,
1891     EL_BD_BUTTERFLY,
1892     EL_BD_FIREFLY,
1893     EL_YAMYAM,
1894     EL_DARK_YAMYAM,
1895     EL_ROBOT,
1896     EL_PACMAN,
1897     EL_AMOEBA_DROP,
1898     EL_ACID,
1899     EL_SP_SNIKSNAK,
1900     EL_SP_ELECTRON,
1901     EL_SP_BUGGY_BASE_ACTIVE,
1902     EL_TRAP_ACTIVE,
1903     EL_LANDMINE
1904   };
1905   static int ep_dont_go_to_num = SIZEOF_ARRAY_INT(ep_dont_go_to);
1906
1907   static int ep_mampf2[] =
1908   {
1909     EL_SAND,
1910     EL_BUG,
1911     EL_SPACESHIP,
1912     EL_BD_BUTTERFLY,
1913     EL_BD_FIREFLY,
1914     EL_YAMYAM,
1915     EL_ROBOT,
1916     EL_PACMAN,
1917     EL_AMOEBA_DROP,
1918     EL_AMOEBA_DEAD,
1919     EL_AMOEBA_WET,
1920     EL_AMOEBA_DRY,
1921     EL_AMOEBA_FULL,
1922     EL_BD_AMOEBA,
1923     EL_EMERALD,
1924     EL_BD_DIAMOND,
1925     EL_EMERALD_YELLOW,
1926     EL_EMERALD_RED,
1927     EL_EMERALD_PURPLE,
1928     EL_DIAMOND,
1929     EL_PEARL,
1930     EL_CRYSTAL
1931   };
1932   static int ep_mampf2_num = SIZEOF_ARRAY_INT(ep_mampf2);
1933
1934   static int ep_bd_element[] =
1935   {
1936     EL_EMPTY,
1937     EL_SAND,
1938     EL_WALL_CRUMBLED,
1939     EL_BD_WALL,
1940     EL_ROCK,
1941     EL_BD_ROCK,
1942     EL_BD_DIAMOND,
1943     EL_BD_MAGIC_WALL,
1944     EL_EXIT_CLOSED,
1945     EL_EXIT_OPEN,
1946     EL_STEELWALL,
1947     EL_PLAYER1,
1948     EL_BD_FIREFLY,
1949     EL_BD_FIREFLY_1,
1950     EL_BD_FIREFLY_2,
1951     EL_BD_FIREFLY_3,
1952     EL_BD_FIREFLY_4,
1953     EL_BD_BUTTERFLY,
1954     EL_BD_BUTTERFLY_1,
1955     EL_BD_BUTTERFLY_2,
1956     EL_BD_BUTTERFLY_3,
1957     EL_BD_BUTTERFLY_4,
1958     EL_BD_AMOEBA,
1959     EL_CHAR_QUESTION
1960   };
1961   static int ep_bd_element_num = SIZEOF_ARRAY_INT(ep_bd_element);
1962
1963   static int ep_sb_element[] =
1964   {
1965     EL_EMPTY,
1966     EL_STEELWALL,
1967     EL_SOKOBAN_OBJECT,
1968     EL_SOKOBAN_FIELD_EMPTY,
1969     EL_SOKOBAN_FIELD_FULL,
1970     EL_PLAYER1,
1971     EL_INVISIBLE_STEELWALL
1972   };
1973   static int ep_sb_element_num = SIZEOF_ARRAY_INT(ep_sb_element);
1974
1975   static int ep_gem[] =
1976   {
1977     EL_EMERALD,
1978     EL_BD_DIAMOND,
1979     EL_EMERALD_YELLOW,
1980     EL_EMERALD_RED,
1981     EL_EMERALD_PURPLE,
1982     EL_DIAMOND
1983   };
1984   static int ep_gem_num = SIZEOF_ARRAY_INT(ep_gem);
1985
1986   static int ep_inactive[] =
1987   {
1988     EL_EMPTY,
1989     EL_SAND,
1990     EL_WALL,
1991     EL_BD_WALL,
1992     EL_WALL_CRUMBLED,
1993     EL_STEELWALL,
1994     EL_AMOEBA_DEAD,
1995     EL_QUICKSAND_EMPTY,
1996     EL_STONEBLOCK,
1997     EL_ROBOT_WHEEL,
1998     EL_KEY1,
1999     EL_KEY2,
2000     EL_KEY3,
2001     EL_KEY4,
2002     EL_EM_KEY1,
2003     EL_EM_KEY2,
2004     EL_EM_KEY3,
2005     EL_EM_KEY4,
2006     EL_GATE1,
2007     EL_GATE2,
2008     EL_GATE3,
2009     EL_GATE4,
2010     EL_GATE1_GRAY,
2011     EL_GATE2_GRAY,
2012     EL_GATE3_GRAY,
2013     EL_GATE4_GRAY,
2014     EL_EM_GATE1,
2015     EL_EM_GATE2,
2016     EL_EM_GATE3,
2017     EL_EM_GATE4,
2018     EL_EM_GATE1_GRAY,
2019     EL_EM_GATE2_GRAY,
2020     EL_EM_GATE3_GRAY,
2021     EL_EM_GATE4_GRAY,
2022     EL_DYNAMITE,
2023     EL_INVISIBLE_STEELWALL,
2024     EL_INVISIBLE_WALL,
2025     EL_INVISIBLE_SAND,
2026     EL_LAMP,
2027     EL_LAMP_ACTIVE,
2028     EL_WALL_EMERALD,
2029     EL_WALL_DIAMOND,
2030     EL_WALL_BD_DIAMOND,
2031     EL_WALL_EMERALD_YELLOW,
2032     EL_DYNABOMB_NR,
2033     EL_DYNABOMB_SZ,
2034     EL_DYNABOMB_XL,
2035     EL_SOKOBAN_OBJECT,
2036     EL_SOKOBAN_FIELD_EMPTY,
2037     EL_SOKOBAN_FIELD_FULL,
2038     EL_WALL_EMERALD_RED,
2039     EL_WALL_EMERALD_PURPLE,
2040     EL_ACIDPOOL_TOPLEFT,
2041     EL_ACIDPOOL_TOPRIGHT,
2042     EL_ACIDPOOL_BOTTOMLEFT,
2043     EL_ACIDPOOL_BOTTOM,
2044     EL_ACIDPOOL_BOTTOMRIGHT,
2045     EL_MAGIC_WALL,
2046     EL_MAGIC_WALL_DEAD,
2047     EL_BD_MAGIC_WALL,
2048     EL_BD_MAGIC_WALL_DEAD,
2049     EL_AMOEBA_TO_DIAMOND,
2050     EL_BLOCKED,
2051     EL_SP_EMPTY,
2052     EL_SP_BASE,
2053     EL_SP_PORT1_RIGHT,
2054     EL_SP_PORT1_DOWN,
2055     EL_SP_PORT1_LEFT,
2056     EL_SP_PORT1_UP,
2057     EL_SP_PORT2_RIGHT,
2058     EL_SP_PORT2_DOWN,
2059     EL_SP_PORT2_LEFT,
2060     EL_SP_PORT2_UP,
2061     EL_SP_PORT_X,
2062     EL_SP_PORT_Y,
2063     EL_SP_PORT_XY,
2064     EL_SP_DISK_RED,
2065     EL_SP_DISK_YELLOW,
2066     EL_SP_CHIP_SINGLE,
2067     EL_SP_CHIP_LEFT,
2068     EL_SP_CHIP_RIGHT,
2069     EL_SP_CHIP_UPPER,
2070     EL_SP_CHIP_LOWER,
2071     EL_SP_HARD_GRAY,
2072     EL_SP_HARD_GREEN,
2073     EL_SP_HARD_BLUE,
2074     EL_SP_HARD_RED,
2075     EL_SP_HARD_YELLOW,
2076     EL_SP_HARD_BASE1,
2077     EL_SP_HARD_BASE2,
2078     EL_SP_HARD_BASE3,
2079     EL_SP_HARD_BASE4,
2080     EL_SP_HARD_BASE5,
2081     EL_SP_HARD_BASE6,
2082     EL_CONVEYOR_BELT1_SWITCH_LEFT,
2083     EL_CONVEYOR_BELT1_SWITCH_MIDDLE,
2084     EL_CONVEYOR_BELT1_SWITCH_RIGHT,
2085     EL_CONVEYOR_BELT2_SWITCH_LEFT,
2086     EL_CONVEYOR_BELT2_SWITCH_MIDDLE,
2087     EL_CONVEYOR_BELT2_SWITCH_RIGHT,
2088     EL_CONVEYOR_BELT3_SWITCH_LEFT,
2089     EL_CONVEYOR_BELT3_SWITCH_MIDDLE,
2090     EL_CONVEYOR_BELT3_SWITCH_RIGHT,
2091     EL_CONVEYOR_BELT4_SWITCH_LEFT,
2092     EL_CONVEYOR_BELT4_SWITCH_MIDDLE,
2093     EL_CONVEYOR_BELT4_SWITCH_RIGHT,
2094     EL_SIGN_EXCLAMATION,
2095     EL_SIGN_RADIOACTIVITY,
2096     EL_SIGN_STOP,
2097     EL_SIGN_WHEELCHAIR,
2098     EL_SIGN_PARKING,
2099     EL_SIGN_ONEWAY,
2100     EL_SIGN_HEART,
2101     EL_SIGN_TRIANGLE,
2102     EL_SIGN_ROUND,
2103     EL_SIGN_EXIT,
2104     EL_SIGN_YINYANG,
2105     EL_SIGN_OTHER,
2106     EL_STEELWALL_SLANTED,
2107     EL_EMC_STEELWALL1,
2108     EL_EMC_STEELWALL2,
2109     EL_EMC_STEELWALL3,
2110     EL_EMC_STEELWALL4,
2111     EL_EMC_WALL_PILLAR_UPPER,
2112     EL_EMC_WALL_PILLAR_MIDDLE,
2113     EL_EMC_WALL_PILLAR_LOWER,
2114     EL_EMC_WALL4,
2115     EL_EMC_WALL5,
2116     EL_EMC_WALL6,
2117     EL_EMC_WALL7,
2118     EL_EMC_WALL8
2119   };
2120   static int ep_inactive_num = SIZEOF_ARRAY_INT(ep_inactive);
2121
2122   static int ep_explosive[] =
2123   {
2124     EL_BOMB,
2125     EL_DYNAMITE_ACTIVE,
2126     EL_DYNAMITE,
2127     EL_DYNABOMB_PLAYER1_ACTIVE,
2128     EL_DYNABOMB_PLAYER2_ACTIVE,
2129     EL_DYNABOMB_PLAYER3_ACTIVE,
2130     EL_DYNABOMB_PLAYER4_ACTIVE,
2131     EL_DYNABOMB_NR,
2132     EL_DYNABOMB_SZ,
2133     EL_DYNABOMB_XL,
2134     EL_BUG,
2135     EL_MOLE,
2136     EL_PENGUIN,
2137     EL_PIG,
2138     EL_DRAGON,
2139     EL_SATELLITE,
2140     EL_SP_DISK_RED,
2141     EL_SP_DISK_ORANGE,
2142     EL_SP_DISK_YELLOW,
2143     EL_SP_SNIKSNAK,
2144     EL_SP_ELECTRON,
2145     EL_DX_SUPABOMB
2146   };
2147   static int ep_explosive_num = SIZEOF_ARRAY_INT(ep_explosive);
2148
2149   static int ep_mampf3[] =
2150   {
2151     EL_EMERALD,
2152     EL_BD_DIAMOND,
2153     EL_EMERALD_YELLOW,
2154     EL_EMERALD_RED,
2155     EL_EMERALD_PURPLE,
2156     EL_DIAMOND,
2157     EL_PEARL,
2158     EL_CRYSTAL
2159   };
2160   static int ep_mampf3_num = SIZEOF_ARRAY_INT(ep_mampf3);
2161
2162   static int ep_pushable[] =
2163   {
2164     EL_ROCK,
2165     EL_BD_ROCK,
2166     EL_BOMB,
2167     EL_NUT,
2168     EL_TIME_ORB_EMPTY,
2169     EL_SOKOBAN_FIELD_FULL,
2170     EL_SOKOBAN_OBJECT,
2171     EL_SATELLITE,
2172     EL_SP_ZONK,
2173     EL_SP_DISK_ORANGE,
2174     EL_SP_DISK_YELLOW,
2175     EL_BALLOON,
2176     EL_SPRING,
2177     EL_DX_SUPABOMB
2178   };
2179   static int ep_pushable_num = SIZEOF_ARRAY_INT(ep_pushable);
2180
2181   static int ep_player[] =
2182   {
2183     EL_PLAYER1,
2184     EL_PLAYER2,
2185     EL_PLAYER3,
2186     EL_PLAYER4
2187   };
2188   static int ep_player_num = SIZEOF_ARRAY_INT(ep_player);
2189
2190   static int ep_has_content[] =
2191   {
2192     EL_YAMYAM,
2193     EL_AMOEBA_WET,
2194     EL_AMOEBA_DRY,
2195     EL_AMOEBA_FULL,
2196     EL_BD_AMOEBA
2197   };
2198   static int ep_has_content_num = SIZEOF_ARRAY_INT(ep_has_content);
2199
2200   static int ep_eatable[] =
2201   {
2202     EL_SAND,
2203     EL_SP_BASE,
2204     EL_SP_BUGGY_BASE,
2205     EL_SP_BUGGY_BASE_ACTIVATING,
2206     EL_TRAP,
2207     EL_INVISIBLE_SAND,
2208     EL_INVISIBLE_SAND_ACTIVE
2209   };
2210   static int ep_eatable_num = SIZEOF_ARRAY_INT(ep_eatable);
2211
2212   static int ep_sp_element[] =
2213   {
2214     EL_SP_EMPTY,
2215     EL_SP_ZONK,
2216     EL_SP_BASE,
2217     EL_SP_MURPHY,
2218     EL_SP_INFOTRON,
2219     EL_SP_CHIP_SINGLE,
2220     EL_SP_HARD_GRAY,
2221     EL_SP_EXIT_CLOSED,
2222     EL_SP_EXIT_OPEN,
2223     EL_SP_DISK_ORANGE,
2224     EL_SP_PORT1_RIGHT,
2225     EL_SP_PORT1_DOWN,
2226     EL_SP_PORT1_LEFT,
2227     EL_SP_PORT1_UP,
2228     EL_SP_PORT2_RIGHT,
2229     EL_SP_PORT2_DOWN,
2230     EL_SP_PORT2_LEFT,
2231     EL_SP_PORT2_UP,
2232     EL_SP_SNIKSNAK,
2233     EL_SP_DISK_YELLOW,
2234     EL_SP_TERMINAL,
2235     EL_SP_DISK_RED,
2236     EL_SP_PORT_Y,
2237     EL_SP_PORT_X,
2238     EL_SP_PORT_XY,
2239     EL_SP_ELECTRON,
2240     EL_SP_BUGGY_BASE,
2241     EL_SP_CHIP_LEFT,
2242     EL_SP_CHIP_RIGHT,
2243     EL_SP_HARD_BASE1,
2244     EL_SP_HARD_GREEN,
2245     EL_SP_HARD_BLUE,
2246     EL_SP_HARD_RED,
2247     EL_SP_HARD_YELLOW,
2248     EL_SP_HARD_BASE2,
2249     EL_SP_HARD_BASE3,
2250     EL_SP_HARD_BASE4,
2251     EL_SP_HARD_BASE5,
2252     EL_SP_HARD_BASE6,
2253     EL_SP_CHIP_UPPER,
2254     EL_SP_CHIP_LOWER,
2255     /* additional elements that appeared in newer Supaplex levels */
2256     EL_INVISIBLE_WALL,
2257     /* more than one murphy in a level results in an inactive clone */
2258     EL_SP_MURPHY_CLONE
2259   };
2260   static int ep_sp_element_num = SIZEOF_ARRAY_INT(ep_sp_element);
2261
2262   static int ep_quick_gate[] =
2263   {
2264     EL_EM_GATE1,
2265     EL_EM_GATE2,
2266     EL_EM_GATE3,
2267     EL_EM_GATE4,
2268     EL_EM_GATE1_GRAY,
2269     EL_EM_GATE2_GRAY,
2270     EL_EM_GATE3_GRAY,
2271     EL_EM_GATE4_GRAY,
2272     EL_SP_PORT1_LEFT,
2273     EL_SP_PORT2_LEFT,
2274     EL_SP_PORT1_RIGHT,
2275     EL_SP_PORT2_RIGHT,
2276     EL_SP_PORT1_UP,
2277     EL_SP_PORT2_UP,
2278     EL_SP_PORT1_DOWN,
2279     EL_SP_PORT2_DOWN,
2280     EL_SP_PORT_X,
2281     EL_SP_PORT_Y,
2282     EL_SP_PORT_XY,
2283     EL_SWITCHGATE_OPEN,
2284     EL_TIMEGATE_OPEN
2285   };
2286   static int ep_quick_gate_num = SIZEOF_ARRAY_INT(ep_quick_gate);
2287
2288   static int ep_over_player[] =
2289   {
2290     EL_SP_PORT1_LEFT,
2291     EL_SP_PORT2_LEFT,
2292     EL_SP_PORT1_RIGHT,
2293     EL_SP_PORT2_RIGHT,
2294     EL_SP_PORT1_UP,
2295     EL_SP_PORT2_UP,
2296     EL_SP_PORT1_DOWN,
2297     EL_SP_PORT2_DOWN,
2298     EL_SP_PORT_X,
2299     EL_SP_PORT_Y,
2300     EL_SP_PORT_XY,
2301     EL_TUBE_ALL,
2302     EL_TUBE_VERTICAL,
2303     EL_TUBE_HORIZONTAL,
2304     EL_TUBE_VERTICAL_LEFT,
2305     EL_TUBE_VERTICAL_RIGHT,
2306     EL_TUBE_HORIZONTAL_UP,
2307     EL_TUBE_HORIZONTAL_DOWN,
2308     EL_TUBE_LEFT_UP,
2309     EL_TUBE_LEFT_DOWN,
2310     EL_TUBE_RIGHT_UP,
2311     EL_TUBE_RIGHT_DOWN
2312   };
2313   static int ep_over_player_num = SIZEOF_ARRAY_INT(ep_over_player);
2314
2315   static int ep_active_bomb[] =
2316   {
2317     EL_DYNAMITE_ACTIVE,
2318     EL_DYNABOMB_PLAYER1_ACTIVE,
2319     EL_DYNABOMB_PLAYER2_ACTIVE,
2320     EL_DYNABOMB_PLAYER3_ACTIVE,
2321     EL_DYNABOMB_PLAYER4_ACTIVE
2322   };
2323   static int ep_active_bomb_num = SIZEOF_ARRAY_INT(ep_active_bomb);
2324
2325   static int ep_belt[] =
2326   {
2327     EL_CONVEYOR_BELT1_LEFT,
2328     EL_CONVEYOR_BELT1_MIDDLE,
2329     EL_CONVEYOR_BELT1_RIGHT,
2330     EL_CONVEYOR_BELT2_LEFT,
2331     EL_CONVEYOR_BELT2_MIDDLE,
2332     EL_CONVEYOR_BELT2_RIGHT,
2333     EL_CONVEYOR_BELT3_LEFT,
2334     EL_CONVEYOR_BELT3_MIDDLE,
2335     EL_CONVEYOR_BELT3_RIGHT,
2336     EL_CONVEYOR_BELT4_LEFT,
2337     EL_CONVEYOR_BELT4_MIDDLE,
2338     EL_CONVEYOR_BELT4_RIGHT,
2339   };
2340   static int ep_belt_num = SIZEOF_ARRAY_INT(ep_belt);
2341
2342   static int ep_belt_active[] =
2343   {
2344     EL_CONVEYOR_BELT1_LEFT_ACTIVE,
2345     EL_CONVEYOR_BELT1_MIDDLE_ACTIVE,
2346     EL_CONVEYOR_BELT1_RIGHT_ACTIVE,
2347     EL_CONVEYOR_BELT2_LEFT_ACTIVE,
2348     EL_CONVEYOR_BELT2_MIDDLE_ACTIVE,
2349     EL_CONVEYOR_BELT2_RIGHT_ACTIVE,
2350     EL_CONVEYOR_BELT3_LEFT_ACTIVE,
2351     EL_CONVEYOR_BELT3_MIDDLE_ACTIVE,
2352     EL_CONVEYOR_BELT3_RIGHT_ACTIVE,
2353     EL_CONVEYOR_BELT4_LEFT_ACTIVE,
2354     EL_CONVEYOR_BELT4_MIDDLE_ACTIVE,
2355     EL_CONVEYOR_BELT4_RIGHT_ACTIVE,
2356   };
2357   static int ep_belt_active_num = SIZEOF_ARRAY_INT(ep_belt_active);
2358
2359   static int ep_belt_switch[] =
2360   {
2361     EL_CONVEYOR_BELT1_SWITCH_LEFT,
2362     EL_CONVEYOR_BELT1_SWITCH_MIDDLE,
2363     EL_CONVEYOR_BELT1_SWITCH_RIGHT,
2364     EL_CONVEYOR_BELT2_SWITCH_LEFT,
2365     EL_CONVEYOR_BELT2_SWITCH_MIDDLE,
2366     EL_CONVEYOR_BELT2_SWITCH_RIGHT,
2367     EL_CONVEYOR_BELT3_SWITCH_LEFT,
2368     EL_CONVEYOR_BELT3_SWITCH_MIDDLE,
2369     EL_CONVEYOR_BELT3_SWITCH_RIGHT,
2370     EL_CONVEYOR_BELT4_SWITCH_LEFT,
2371     EL_CONVEYOR_BELT4_SWITCH_MIDDLE,
2372     EL_CONVEYOR_BELT4_SWITCH_RIGHT,
2373   };
2374   static int ep_belt_switch_num = SIZEOF_ARRAY_INT(ep_belt_switch);
2375
2376   static int ep_tube[] =
2377   {
2378     EL_TUBE_ALL,
2379     EL_TUBE_VERTICAL,
2380     EL_TUBE_HORIZONTAL,
2381     EL_TUBE_VERTICAL_LEFT,
2382     EL_TUBE_VERTICAL_RIGHT,
2383     EL_TUBE_HORIZONTAL_UP,
2384     EL_TUBE_HORIZONTAL_DOWN,
2385     EL_TUBE_LEFT_UP,
2386     EL_TUBE_LEFT_DOWN,
2387     EL_TUBE_RIGHT_UP,
2388     EL_TUBE_RIGHT_DOWN
2389   };
2390   static int ep_tube_num = SIZEOF_ARRAY_INT(ep_tube);
2391
2392   static long ep1_bit[] =
2393   {
2394     EP_BIT_AMOEBALIVE,
2395     EP_BIT_AMOEBOID,
2396     EP_BIT_SCHLUESSEL,
2397     EP_BIT_PFORTE,
2398     EP_BIT_SOLID,
2399     EP_BIT_INDESTRUCTIBLE,
2400     EP_BIT_SLIPPERY,
2401     EP_BIT_ENEMY,
2402     EP_BIT_MAUER,
2403     EP_BIT_CAN_FALL,
2404     EP_BIT_CAN_SMASH,
2405     EP_BIT_CAN_CHANGE,
2406     EP_BIT_CAN_MOVE,
2407     EP_BIT_COULD_MOVE,
2408     EP_BIT_DONT_TOUCH,
2409     EP_BIT_DONT_GO_TO,
2410     EP_BIT_MAMPF2,
2411     EP_BIT_BD_ELEMENT,
2412     EP_BIT_SB_ELEMENT,
2413     EP_BIT_GEM,
2414     EP_BIT_INACTIVE,
2415     EP_BIT_EXPLOSIVE,
2416     EP_BIT_MAMPF3,
2417     EP_BIT_PUSHABLE,
2418     EP_BIT_PLAYER,
2419     EP_BIT_HAS_CONTENT,
2420     EP_BIT_EATABLE,
2421     EP_BIT_SP_ELEMENT,
2422     EP_BIT_QUICK_GATE,
2423     EP_BIT_OVER_PLAYER,
2424     EP_BIT_ACTIVE_BOMB
2425   };
2426   static long ep2_bit[] =
2427   {
2428     EP_BIT_BELT,
2429     EP_BIT_BELT_ACTIVE,
2430     EP_BIT_BELT_SWITCH,
2431     EP_BIT_TUBE
2432   };
2433   static int *ep1_array[] =
2434   {
2435     ep_amoebalive,
2436     ep_amoeboid,
2437     ep_schluessel,
2438     ep_pforte,
2439     ep_solid,
2440     ep_indestructible,
2441     ep_slippery,
2442     ep_enemy,
2443     ep_mauer,
2444     ep_can_fall,
2445     ep_can_smash,
2446     ep_can_change,
2447     ep_can_move,
2448     ep_could_move,
2449     ep_dont_touch,
2450     ep_dont_go_to,
2451     ep_mampf2,
2452     ep_bd_element,
2453     ep_sb_element,
2454     ep_gem,
2455     ep_inactive,
2456     ep_explosive,
2457     ep_mampf3,
2458     ep_pushable,
2459     ep_player,
2460     ep_has_content,
2461     ep_eatable,
2462     ep_sp_element,
2463     ep_quick_gate,
2464     ep_over_player,
2465     ep_active_bomb
2466   };
2467   static int *ep2_array[] =
2468   {
2469     ep_belt,
2470     ep_belt_active,
2471     ep_belt_switch,
2472     ep_tube
2473   };
2474   static int *ep1_num[] =
2475   {
2476     &ep_amoebalive_num,
2477     &ep_amoeboid_num,
2478     &ep_schluessel_num,
2479     &ep_pforte_num,
2480     &ep_solid_num,
2481     &ep_indestructible_num,
2482     &ep_slippery_num,
2483     &ep_enemy_num,
2484     &ep_mauer_num,
2485     &ep_can_fall_num,
2486     &ep_can_smash_num,
2487     &ep_can_change_num,
2488     &ep_can_move_num,
2489     &ep_could_move_num,
2490     &ep_dont_touch_num,
2491     &ep_dont_go_to_num,
2492     &ep_mampf2_num,
2493     &ep_bd_element_num,
2494     &ep_sb_element_num,
2495     &ep_gem_num,
2496     &ep_inactive_num,
2497     &ep_explosive_num,
2498     &ep_mampf3_num,
2499     &ep_pushable_num,
2500     &ep_player_num,
2501     &ep_has_content_num,
2502     &ep_eatable_num,
2503     &ep_sp_element_num,
2504     &ep_quick_gate_num,
2505     &ep_over_player_num,
2506     &ep_active_bomb_num
2507   };
2508   static int *ep2_num[] =
2509   {
2510     &ep_belt_num,
2511     &ep_belt_active_num,
2512     &ep_belt_switch_num,
2513     &ep_tube_num
2514   };
2515   static int num_properties1 = SIZEOF_ARRAY(ep1_num, int *);
2516   static int num_properties2 = SIZEOF_ARRAY(ep2_num, int *);
2517
2518   for (i=0; i<MAX_NUM_ELEMENTS; i++)
2519   {
2520     Properties1[i] = 0;
2521     Properties2[i] = 0;
2522   }
2523
2524   for (i=0; i<num_properties1; i++)
2525     for (j=0; j<*(ep1_num[i]); j++)
2526       Properties1[(ep1_array[i])[j]] |= ep1_bit[i];
2527   for (i=0; i<num_properties2; i++)
2528     for (j=0; j<*(ep2_num[i]); j++)
2529       Properties2[(ep2_array[i])[j]] |= ep2_bit[i];
2530
2531   for (i=EL_CHAR_START; i<=EL_CHAR_END; i++)
2532     Properties1[i] |= (EP_BIT_CHAR | EP_BIT_INACTIVE);
2533 }
2534
2535 void Execute_Command(char *command)
2536 {
2537   if (strcmp(command, "print graphicsinfo.conf") == 0)
2538   {
2539     int i;
2540
2541     printf("# You can configure additional/alternative image files here.\n");
2542     printf("# (The images below are default and therefore commented out.)\n");
2543     printf("\n");
2544     printf("%s\n", getFormattedSetupEntry("name", "Classic Graphics"));
2545     printf("\n");
2546     printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
2547     printf("\n");
2548
2549     for (i=0; image_config[i].token != NULL; i++)
2550       printf("# %s\n",
2551              getFormattedSetupEntry(image_config[i].token,
2552                                     image_config[i].value));
2553
2554     exit(0);
2555   }
2556   else if (strcmp(command, "print soundsinfo.conf") == 0)
2557   {
2558     int i;
2559
2560     printf("# You can configure additional/alternative sound files here.\n");
2561     printf("# (The sounds below are default and therefore commented out.)\n");
2562     printf("\n");
2563     printf("%s\n", getFormattedSetupEntry("name", "Classic Sounds"));
2564     printf("\n");
2565     printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
2566     printf("\n");
2567
2568     for (i=0; sound_config[i].token != NULL; i++)
2569       printf("# %s\n",
2570              getFormattedSetupEntry(sound_config[i].token,
2571                                     sound_config[i].value));
2572
2573     exit(0);
2574   }
2575   else if (strcmp(command, "print musicinfo.conf") == 0)
2576   {
2577     printf("# (Currently only \"name\" and \"sort_priority\" recognized.)\n");
2578     printf("\n");
2579     printf("%s\n", getFormattedSetupEntry("name", "Classic Music"));
2580     printf("\n");
2581     printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
2582
2583     exit(0);
2584   }
2585   else if (strncmp(command, "dump level ", 11) == 0)
2586   {
2587     char *filename = &command[11];
2588
2589     if (access(filename, F_OK) != 0)
2590       Error(ERR_EXIT, "cannot open file '%s'", filename);
2591
2592     LoadLevelFromFilename(filename);
2593     DumpLevel(&level);
2594
2595     exit(0);
2596   }
2597   else if (strncmp(command, "dump tape ", 10) == 0)
2598   {
2599     char *filename = &command[10];
2600
2601     if (access(filename, F_OK) != 0)
2602       Error(ERR_EXIT, "cannot open file '%s'", filename);
2603
2604     LoadTapeFromFilename(filename);
2605     DumpTape(&tape);
2606
2607     exit(0);
2608   }
2609   else if (strncmp(command, "autoplay ", 9) == 0)
2610   {
2611     char *str_copy = getStringCopy(&command[9]);
2612     char *str_ptr = strchr(str_copy, ' ');
2613
2614     global.autoplay_leveldir = str_copy;
2615     global.autoplay_level_nr = -1;
2616
2617     if (str_ptr != NULL)
2618     {
2619       *str_ptr++ = '\0';                        /* terminate leveldir string */
2620       global.autoplay_level_nr = atoi(str_ptr); /* get level_nr value */
2621     }
2622   }
2623   else
2624   {
2625     Error(ERR_EXIT_HELP, "unrecognized command '%s'", command);
2626   }
2627 }
2628
2629 void CloseAllAndExit(int exit_value)
2630 {
2631   StopSounds();
2632   FreeAllSounds();
2633   FreeAllMusic();
2634   CloseAudio();         /* called after freeing sounds (needed for SDL) */
2635
2636   FreeAllImages();
2637   FreeTileClipmasks();
2638
2639   CloseVideoDisplay();
2640   ClosePlatformDependantStuff();
2641
2642   exit(exit_value);
2643 }