src/init.c

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