X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Finit.c;h=3dcfe04e8358b4370643f3f1e22450fcd571cab9;hb=91d08fad2fcec7e2b5931b4f336a89d14af313dd;hp=66083aeb87d888a3a550f65ceb875a4e6bfc760d;hpb=fa26d82a378cebf6b519c566c3f33739ebba7823;p=rocksndiamonds.git

diff --git a/src/init.c b/src/init.c
index 66083aeb..3dcfe04e 100644
--- a/src/init.c
+++ b/src/init.c
@@ -27,6 +27,7 @@
 #include "config.h"
 
 #include "conf_e2g.c"	/* include auto-generated data structure definitions */
+#include "conf_esg.c"	/* include auto-generated data structure definitions */
 
 
 static char *image_filename[NUM_PICTURES] =
@@ -57,26 +58,31 @@ static char *image_filename[NUM_PICTURES] =
 
 static Bitmap *bitmap_font_initial = NULL;
 
-static void InitGlobal(void);
-static void InitSetup(void);
-static void InitPlayerInfo(void);
-static void InitLevelInfo(void);
-static void InitArtworkInfo(void);
-static void InitLevelArtworkInfo(void);
-static void InitNetworkServer(void);
-static void InitImages(void);
-static void InitMixer(void);
-static void InitSound(void);
-static void InitGfx(void);
-static void InitGfxBackground(void);
-static void InitGadgets(void);
-static void InitElementProperties(void);
-static void InitElementInfo(void);
-static void InitGraphicInfo(void);
+static void InitGlobal();
+static void InitSetup();
+static void InitPlayerInfo();
+static void InitLevelInfo();
+static void InitArtworkInfo();
+static void InitLevelArtworkInfo();
+static void InitNetworkServer();
+static void InitArtworkConfig();
+static void InitImages();
+static void InitMixer();
+static void InitSound();
+static void InitMusic();
+static void InitGfx();
+static void InitGfxBackground();
+static void InitGadgets();
+static void InitElementImages();
+static void InitElementGraphicInfo();
+static void InitElementEditorGraphicInfo();
+static void InitElementSoundInfo();
+static void InitElementProperties();
+static void InitGraphicInfo();
 static void InitSoundInfo();
 static void Execute_Command(char *);
 
-void OpenAll(void)
+void OpenAll()
 {
   InitGlobal();		/* initialize some global variables */
 
@@ -102,9 +108,11 @@ void OpenAll(void)
   InitSetup();
   InitPlayerInfo();
   InitArtworkInfo();		/* needed before loading gfx, sound & music */
+  InitArtworkConfig();		/* needed before forking sound child process */
+  InitMixer();
 
   InitCounter();
-  InitMixer();
+
   InitJoysticks();
   InitRND(NEW_RANDOMIZE);
 
@@ -114,8 +122,7 @@ void OpenAll(void)
 
   InitEventFilter(FilterMouseMotionEvents);
 
-  InitElementProperties();	/* initializes IS_CHAR() for el2gfx() */
-  InitElementInfo();
+  InitElementProperties();
 
   InitGfx();
 
@@ -124,9 +131,7 @@ void OpenAll(void)
 
   InitImages();			/* needs to know current level directory */
   InitSound();			/* needs to know current level directory */
-#if 0
-  InitGadgets();		/* needs images + number of level series */
-#endif
+  InitMusic();			/* needs to know current level directory */
 
   InitGfxBackground();
 
@@ -141,7 +146,7 @@ void OpenAll(void)
   InitNetworkServer();
 }
 
-void InitGlobal()
+static void InitGlobal()
 {
   global.autoplay_leveldir = NULL;
 
@@ -150,12 +155,12 @@ void InitGlobal()
   global.fps_slowdown_factor = 1;
 }
 
-void InitSetup()
+static void InitSetup()
 {
   LoadSetup();					/* global setup info */
 }
 
-void InitPlayerInfo()
+static void InitPlayerInfo()
 {
   int i;
 
@@ -168,18 +173,45 @@ void InitPlayerInfo()
   local_player->connected = TRUE;
 }
 
-void InitLevelInfo()
+static void InitLevelInfo()
 {
   LoadLevelInfo();				/* global level info */
   LoadLevelSetup_LastSeries();			/* last played series info */
   LoadLevelSetup_SeriesInfo();			/* last played level info */
 }
 
-void InitArtworkInfo()
+static void InitArtworkInfo()
 {
   LoadArtworkInfo();
 }
 
+static void InitArtworkConfig()
+{
+  static char *element_prefix[MAX_NUM_ELEMENTS + 1];
+  static char *sound_class_prefix[MAX_NUM_ELEMENTS + 1];
+  static char *action_suffix[NUM_ACTIONS + 1];
+  static char *direction_suffix[NUM_DIRECTIONS + 1];
+  static char *special_suffix[NUM_SPECIAL_GFX_ARGS + 1];
+  static char *dummy[1] = { NULL };
+  int i;
+
+  for (i=0; i<MAX_NUM_ELEMENTS + 1; i++)
+    element_prefix[i] = element_info[i].token_name;
+  for (i=0; i<MAX_NUM_ELEMENTS + 1; i++)
+    sound_class_prefix[i] = element_info[i].sound_class_name;
+  for (i=0; i<NUM_ACTIONS + 1; i++)
+    action_suffix[i] = element_action_info[i].suffix;
+  for (i=0; i<NUM_DIRECTIONS + 1; i++)
+    direction_suffix[i] = element_direction_info[i].suffix;
+  for (i=0; i<NUM_SPECIAL_GFX_ARGS + 1; i++)
+    special_suffix[i] = special_suffix_info[i].suffix;
+
+  InitImageList(image_config, NUM_IMAGE_FILES, image_config_suffix,
+		element_prefix, action_suffix,direction_suffix,special_suffix);
+  InitSoundList(sound_config, NUM_SOUND_FILES, sound_config_suffix,
+		sound_class_prefix, action_suffix, dummy, dummy);
+}
+
 void InitLevelArtworkInfo()
 {
   LoadLevelArtworkInfo();
@@ -208,49 +240,96 @@ void InitNetworkServer()
 #endif
 }
 
-static void ReinitializeGraphics()
+static void InitMixer()
 {
-  ReloadCustomImages();		/* load custom image files */
+  OpenAudio();
+  StartMixer();
+}
 
-  InitGraphicInfo();		/* initialize graphic info from config file */
+static void ReinitializeGraphics()
+{
+  InitElementGraphicInfo();		/* element => game graphic mapping */
+  InitElementEditorGraphicInfo();	/* element => editor graphic mapping */
+  InitGraphicInfo();			/* graphic => properties mapping */
 
   InitFontInfo(bitmap_font_initial,
-	       new_graphic_info[IMG_MENU_FONT_BIG].bitmap,
-	       new_graphic_info[IMG_MENU_FONT_MEDIUM].bitmap,
-	       new_graphic_info[IMG_MENU_FONT_SMALL].bitmap,
-	       new_graphic_info[IMG_MENU_FONT_EM].bitmap);
+	       graphic_info[IMG_FONT_BIG].bitmap,
+	       graphic_info[IMG_FONT_MEDIUM].bitmap,
+	       graphic_info[IMG_FONT_SMALL].bitmap,
+	       graphic_info[IMG_FONT_EM].bitmap);
+
+  SetMainBackgroundImage(IMG_BACKGROUND_DEFAULT);
+  SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
 
   InitGadgets();
   InitToons();
+
+
+
+  /* !!! TEST ONLY !!! */
+  if (0)
+  {
+    Bitmap *tst_bitmap = graphic_info[IMG_SAND].bitmap;
+    Bitmap *tmp_bitmap = ZoomBitmap(tst_bitmap,
+				    tst_bitmap->width / 2,
+				    tst_bitmap->height / 2);
+
+    BlitBitmap(tmp_bitmap, tst_bitmap, 0, 0, 256, 224, 0, 448);
+
+    FreeBitmap(tmp_bitmap);
+  }
+
+  if (1)
+  {
+    printf("CREATING SMALL IMAGES...\n");
+
+#if 1
+    InitElementImages();
+#else
+    CreateImageWithSmallImages(IMG_SAND);
+    CreateImageWithSmallImages(IMG_SAND);
+#endif
+
+    printf("DONE!\n");
+  }
 }
 
-static void InitImages()
+static void ReinitializeSounds()
 {
-  InitImageList(image_config, image_config_suffix, NUM_IMAGE_FILES);
+  InitElementSoundInfo();	/* element => game sound mapping */
+  InitSoundInfo();		/* sound   => properties mapping */
 
-  ReinitializeGraphics();
+  InitPlaySoundLevel();		/* internal game sound settings */
 }
 
-static void InitMixer()
+static void ReinitializeMusic()
 {
-  OpenAudio();
+  /* currently nothing to do */
+}
 
-  InitSoundList(sound_config, sound_config_suffix, NUM_SOUND_FILES);
+static void InitImages()
+{
+  ReloadCustomImages();
+  ReinitializeGraphics();
 
-  StartMixer();
+  LoadCustomElementDescriptions();
 }
 
 static void InitSound()
 {
-  /* load custom sounds and music */
-  InitReloadSounds(artwork.snd_current->identifier);
-  InitReloadMusic(artwork.mus_current->identifier);
+  InitReloadCustomSounds(artwork.snd_current->identifier);
+  ReinitializeSounds();
+}
 
-  InitSoundInfo();
+static void InitMusic()
+{
+  InitReloadCustomMusic(artwork.mus_current->identifier);
+  ReinitializeMusic();
 }
 
 static void InitTileClipmasks()
 {
+#if 0
 #if defined(TARGET_X11)
   XGCValues clip_gc_values;
   unsigned long clip_gc_valuemask;
@@ -385,10 +464,12 @@ static void InitTileClipmasks()
 
 #endif /* TARGET_X11_NATIVE */
 #endif /* TARGET_X11 */
+#endif
 }
 
 void FreeTileClipmasks()
 {
+#if 0
 #if defined(TARGET_X11)
   int i;
 
@@ -417,6 +498,7 @@ void FreeTileClipmasks()
 #endif
 
 #endif /* TARGET_X11 */
+#endif
 }
 
 void InitGfx()
@@ -481,7 +563,7 @@ void InitGfxBackground()
   fieldbuffer = bitmap_db_field;
   SetDrawtoField(DRAW_BACKBUFFER);
 
-  BlitBitmap(new_graphic_info[IMG_MENU_BACK].bitmap, backbuffer,
+  BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, backbuffer,
 	     0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
   ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
   ClearRectangle(bitmap_db_door, 0, 0, 3 * DXSIZE, DYSIZE + VYSIZE);
@@ -528,10 +610,6 @@ void ReloadCustomArtwork()
   if (!validLevelSeries(leveldir_current))
     return;
 
-#if 0
-  printf("--> '%s'\n", artwork.gfx_current_identifier);
-#endif
-
   /* when a new level series was selected, check if there was a change
      in custom artwork stored in level series directory */
   if (leveldir_current_identifier != leveldir_current->identifier)
@@ -566,48 +644,25 @@ void ReloadCustomArtwork()
       last_override_level_graphics != setup.override_level_graphics)
   {
 #if 0
-    printf("CHANGED GFX: '%s' -> '%s'\n",
-	   artwork.gfx_current_identifier, gfx_new_identifier);
-#endif
-
-#if 0
-    int i;
+    printf("RELOADING GRAPHICS '%s' -> '%s' ('%s')\n",
+	   artwork.gfx_current_identifier,
+	   artwork.gfx_current->identifier,
+	   gfx_new_identifier);
 #endif
 
     setLevelArtworkDir(artwork.gfx_first);
 
     ClearRectangle(window, 0, 0, WIN_XSIZE, WIN_YSIZE);
 
-#if 0
-    for (i=0; i<NUM_PICTURES; i++)
-    {
-      DrawInitText(image_filename[i], 150, FC_YELLOW);
-      ReloadCustomImage(pix[i], image_filename[i]);
-    }
-#endif
-
-#if 0
-    SyncDisplay();
-#endif
-
+    ReloadCustomImages();
     ReinitializeGraphics();
 
+    LoadCustomElementDescriptions();
+
     FreeTileClipmasks();
     InitTileClipmasks();
 
-#if 0
-    InitGfxBackground();
-
-    /* force redraw of (open or closed) door graphics */
-    SetDoorState(DOOR_OPEN_ALL);
-    CloseDoor(DOOR_CLOSE_ALL | DOOR_NO_DELAY);
-#endif
-
-#if 0
-    artwork.gfx_current_identifier = gfx_new_identifier;
-#else
     artwork.gfx_current_identifier = artwork.gfx_current->identifier;
-#endif
     last_override_level_graphics = setup.override_level_graphics;
 
     redraw_screen = TRUE;
@@ -616,12 +671,20 @@ void ReloadCustomArtwork()
   if (strcmp(artwork.snd_current_identifier, snd_new_identifier) != 0 ||
       last_override_level_sounds != setup.override_level_sounds)
   {
+#if 0
+    printf("RELOADING SOUNDS '%s' -> '%s' ('%s')\n",
+	   artwork.snd_current_identifier,
+	   artwork.snd_current->identifier,
+	   snd_new_identifier);
+#endif
+
     /* set artwork path to send it to the sound server process */
     setLevelArtworkDir(artwork.snd_first);
 
-    InitReloadSounds(snd_new_identifier);
+    InitReloadCustomSounds(snd_new_identifier);
+    ReinitializeSounds();
 
-    artwork.snd_current_identifier = snd_new_identifier;
+    artwork.snd_current_identifier = artwork.snd_current->identifier;
     last_override_level_sounds = setup.override_level_sounds;
 
     redraw_screen = TRUE;
@@ -633,9 +696,10 @@ void ReloadCustomArtwork()
     /* set artwork path to send it to the sound server process */
     setLevelArtworkDir(artwork.mus_first);
 
-    InitReloadMusic(mus_new_identifier);
+    InitReloadCustomMusic(mus_new_identifier);
+    ReinitializeMusic();
 
-    artwork.mus_current_identifier = mus_new_identifier;
+    artwork.mus_current_identifier = artwork.mus_current->identifier;
     last_override_level_music = setup.override_level_music;
 
     redraw_screen = TRUE;
@@ -649,10 +713,6 @@ void ReloadCustomArtwork()
     SetDoorState(DOOR_OPEN_ALL);
     CloseDoor(DOOR_CLOSE_ALL | DOOR_NO_DELAY);
   }
-
-#if 0
-  printf("<-- '%s'\n", artwork.gfx_current_identifier);
-#endif
 }
 
 void FreeGadgets()
@@ -680,77 +740,106 @@ void InitGadgets()
   gadgets_initialized = TRUE;
 }
 
-void InitElementInfo()
+void InitElementImages()
 {
+  struct PropertyMapping *property_mapping = getImageListPropertyMapping();
+  int num_property_mappings = getImageListPropertyMappingSize();
+  int i;
 
+  /* initialize images from static configuration */
+  for (i=0; element_to_graphic[i].element > -1; i++)
+    CreateImageWithSmallImages(element_to_graphic[i].graphic);
+
+  /* initialize images from dynamic configuration */
+  for (i=0; i < num_property_mappings; i++)
+    CreateImageWithSmallImages(property_mapping[i].artwork_index);
+}
+
+void InitElementGraphicInfo()
+{
+  struct PropertyMapping *property_mapping = getImageListPropertyMapping();
+  int num_property_mappings = getImageListPropertyMappingSize();
   int i, act, dir;
 
   /* set values to -1 to identify later as "uninitialized" values */
-  for (i=0; i<MAX_ELEMENTS; i++)
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
   {
-    for (act=0; act<NUM_GFX_ACTIONS_MAPPED; act++)
+    for (act=0; act<NUM_ACTIONS; act++)
     {
       element_info[i].graphic[act] = -1;
 
-      for (dir=0; dir<NUM_MV_DIRECTIONS; dir++)
+      for (dir=0; dir<NUM_DIRECTIONS; dir++)
 	element_info[i].direction_graphic[act][dir] = -1;
     }
   }
 
   for (i=EL_CHAR_START; i<=EL_CHAR_END; i++)
-    element_info[i].graphic[GFX_ACTION_DEFAULT] =
+    element_info[i].graphic[ACTION_DEFAULT] =
       IMG_CHAR_START + (i - EL_CHAR_START);
 
   for (i=EL_CUSTOM_START; i<=EL_CUSTOM_END; i++)
-    element_info[i].graphic[GFX_ACTION_DEFAULT] =
+    element_info[i].graphic[ACTION_DEFAULT] =
       IMG_CUSTOM_START + (i - EL_CUSTOM_START);
 
-  i = 0;
-  while (element_to_graphic[i].element > -1)
+  /* initialize normal element/graphic mapping from static configuration */
+  for (i=0; element_to_graphic[i].element > -1; i++)
   {
     int element   = element_to_graphic[i].element;
-    int direction = element_to_graphic[i].direction;
     int action    = element_to_graphic[i].action;
+    int direction = element_to_graphic[i].direction;
     int graphic   = element_to_graphic[i].graphic;
 
-    if (action > -1)
-      action = graphics_action_mapping[action];
-    else
-      action = GFX_ACTION_DEFAULT;
+    if (action < 0)
+      action = ACTION_DEFAULT;
 
     if (direction > -1)
-    {
-      direction = MV_DIR_BIT(direction);
-
       element_info[element].direction_graphic[action][direction] = graphic;
-    }
     else
       element_info[element].graphic[action] = graphic;
+  }
+
+  /* initialize normal element/graphic mapping from dynamic configuration */
+  for (i=0; i < num_property_mappings; i++)
+  {
+    int element   = property_mapping[i].base_index;
+    int action    = property_mapping[i].ext1_index;
+    int direction = property_mapping[i].ext2_index;
+    int special   = property_mapping[i].ext3_index;
+    int graphic   = property_mapping[i].artwork_index;
+
+    if (special != -1)
+      continue;
+
+    if (action < 0)
+      action = ACTION_DEFAULT;
 
-    i++;
+    if (direction > -1)
+      element_info[element].direction_graphic[action][direction] = graphic;
+    else
+      element_info[element].graphic[action] = graphic;
   }
 
   /* now set all '-1' values to element specific default values */
-  for (i=0; i<MAX_ELEMENTS; i++)
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
   {
-    int default_action_graphic = element_info[i].graphic[GFX_ACTION_DEFAULT];
-    int default_action_direction_graphic[NUM_MV_DIRECTIONS];
+    int default_action_graphic = element_info[i].graphic[ACTION_DEFAULT];
+    int default_action_direction_graphic[NUM_DIRECTIONS];
 
     if (default_action_graphic == -1)
       default_action_graphic = IMG_CHAR_QUESTION;
 
-    for (dir=0; dir<NUM_MV_DIRECTIONS; dir++)
+    for (dir=0; dir<NUM_DIRECTIONS; dir++)
     {
       default_action_direction_graphic[dir] =
-	element_info[i].direction_graphic[GFX_ACTION_DEFAULT][dir];
+	element_info[i].direction_graphic[ACTION_DEFAULT][dir];
 
       if (default_action_direction_graphic[dir] == -1)
 	default_action_direction_graphic[dir] = default_action_graphic;
     }
 
-    for (act=0; act<NUM_GFX_ACTIONS_MAPPED; act++)
+    for (act=0; act<NUM_ACTIONS; act++)
     {
-      for (dir=0; dir<NUM_MV_DIRECTIONS; dir++)
+      for (dir=0; dir<NUM_DIRECTIONS; dir++)
       {
 	int default_direction_graphic = element_info[i].graphic[act];
 
@@ -770,149 +859,340 @@ void InitElementInfo()
   }
 }
 
-static void InitGraphicInfo()
+void InitElementEditorGraphicInfo()
 {
-  static int gfx_action[NUM_IMAGE_FILES];
-  Bitmap *src_bitmap;
-  int src_x, src_y;
-  int first_frame, last_frame;
+  struct PropertyMapping *property_mapping = getImageListPropertyMapping();
+  int num_property_mappings = getImageListPropertyMappingSize();
   int i;
 
-  image_files = getCurrentImageList();
+  /* always start with reliable default values */
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
+    element_info[i].editor_graphic = element_info[i].graphic[ACTION_DEFAULT];
 
-  /* set temporary graphics action field to default value */
-  for (i=0; i<NUM_IMAGE_FILES; i++)
-    gfx_action[i] = GFX_ACTION_DEFAULT;
-
-  /* set temporary graphics action field from element_to_graphic list */
-  i = 0;
-  while (element_to_graphic[i].element > -1)
+  /* initialize special element/graphic mapping from static configuration */
+  for (i=0; element_to_special_graphic[i].element > -1; i++)
   {
-    int action    = element_to_graphic[i].action;
-    int graphic   = element_to_graphic[i].graphic;
-
-    if (action == -1)
-      action = GFX_ACTION_DEFAULT;
+    int element = element_to_special_graphic[i].element;
+    int special = element_to_special_graphic[i].special;
+    int graphic = element_to_special_graphic[i].graphic;
 
-    gfx_action[graphic] = action;
+    if (special != GFX_SPECIAL_ARG_EDITOR)
+      continue;
 
-    i++;
+    element_info[element].editor_graphic = graphic;
   }
 
-  for (i=0; i<NUM_IMAGE_FILES; i++)
+  /* initialize special element/graphic mapping from dynamic configuration */
+  for (i=0; i < num_property_mappings; i++)
   {
-    int *parameter = image_files[i].parameter;
+    int element = property_mapping[i].base_index;
+    int special = property_mapping[i].ext3_index;
+    int graphic = property_mapping[i].artwork_index;
 
-    new_graphic_info[i].bitmap = getBitmapFromImageID(i);
+    if (special != GFX_SPECIAL_ARG_EDITOR)
+      continue;
 
-    new_graphic_info[i].src_x = parameter[GFX_ARG_XPOS] * TILEX;
-    new_graphic_info[i].src_y = parameter[GFX_ARG_YPOS] * TILEY;
-    new_graphic_info[i].offset_x = parameter[GFX_ARG_OFFSET];
-    new_graphic_info[i].offset_y = 0;
+    element_info[element].editor_graphic = graphic;
+  }
+}
 
-    /* animation frames are ordered vertically instead of horizontally */
-    if (parameter[GFX_ARG_VERTICAL])
-    {
-      new_graphic_info[i].offset_x = 0;
-      new_graphic_info[i].offset_y = parameter[GFX_ARG_OFFSET];
-    }
+static void InitElementSoundInfo()
+{
+  /* soon to come */
+}
 
-    /* optionally, the x and y offset of frames can be specified directly */
-    if (parameter[GFX_ARG_XOFFSET] != GFX_ARG_UNDEFINED_VALUE)
-      new_graphic_info[i].offset_x = parameter[GFX_ARG_XOFFSET];
-    if (parameter[GFX_ARG_YOFFSET] != GFX_ARG_UNDEFINED_VALUE)
-      new_graphic_info[i].offset_y = parameter[GFX_ARG_YOFFSET];
-
-    new_graphic_info[i].anim_frames = parameter[GFX_ARG_FRAMES];
-
-    new_graphic_info[i].anim_delay = parameter[GFX_ARG_DELAY];
-    if (new_graphic_info[i].anim_delay == 0)	/* delay must be at least 1 */
-      new_graphic_info[i].anim_delay = 1;
-
-    /* set mode for animation frame order */
-    if (parameter[GFX_ARG_MODE_LOOP])
-      new_graphic_info[i].anim_mode = ANIM_LOOP;
-    else if (parameter[GFX_ARG_MODE_LINEAR])
-      new_graphic_info[i].anim_mode = ANIM_LINEAR;
-    else if (parameter[GFX_ARG_MODE_PINGPONG])
-      new_graphic_info[i].anim_mode = ANIM_PINGPONG;
-    else if (parameter[GFX_ARG_MODE_PINGPONG2])
-      new_graphic_info[i].anim_mode = ANIM_PINGPONG2;
-    else if (parameter[GFX_ARG_FRAMES] > 1)
-      new_graphic_info[i].anim_mode = ANIM_LOOP;
-    else
-      new_graphic_info[i].anim_mode = ANIM_NONE;
+static void set_graphic_parameters(int graphic, int *parameter)
+{
+  Bitmap *src_bitmap = getBitmapFromImageID(graphic);
+  int num_xtiles = (src_bitmap ? src_bitmap->width          : TILEX) / TILEX;
+  int num_ytiles = (src_bitmap ? src_bitmap->height * 2 / 3 : TILEY) / TILEY;
+
+  graphic_info[graphic].bitmap = src_bitmap;
+
+  graphic_info[graphic].src_x = parameter[GFX_ARG_XPOS] * TILEX;
+  graphic_info[graphic].src_y = parameter[GFX_ARG_YPOS] * TILEY;
+  graphic_info[graphic].offset_x = parameter[GFX_ARG_OFFSET];
+  graphic_info[graphic].offset_y = 0;
+
+  /* animation frames are ordered vertically instead of horizontally */
+  if (parameter[GFX_ARG_VERTICAL])
+  {
+    graphic_info[graphic].offset_x = 0;
+    graphic_info[graphic].offset_y = parameter[GFX_ARG_OFFSET];
+  }
+
+  /* optionally, the x and y offset of frames can be specified directly */
+  if (parameter[GFX_ARG_XOFFSET] != ARG_UNDEFINED_VALUE)
+    graphic_info[graphic].offset_x = parameter[GFX_ARG_XOFFSET];
+  if (parameter[GFX_ARG_YOFFSET] != ARG_UNDEFINED_VALUE)
+    graphic_info[graphic].offset_y = parameter[GFX_ARG_YOFFSET];
+
+  /* automatically determine correct number of frames, if not defined */
+  if (parameter[GFX_ARG_FRAMES] != ARG_UNDEFINED_VALUE)
+    graphic_info[graphic].anim_frames = parameter[GFX_ARG_FRAMES];
+  else if (parameter[GFX_ARG_XPOS] == 0 && !parameter[GFX_ARG_VERTICAL])
+    graphic_info[graphic].anim_frames =	num_xtiles;
+  else if (parameter[GFX_ARG_YPOS] == 0 && parameter[GFX_ARG_VERTICAL])
+    graphic_info[graphic].anim_frames =	num_ytiles;
+  else
+    graphic_info[graphic].anim_frames = 1;
+
+  graphic_info[graphic].anim_delay = parameter[GFX_ARG_DELAY];
+  if (graphic_info[graphic].anim_delay == 0)	/* delay must be at least 1 */
+    graphic_info[graphic].anim_delay = 1;
+
+  /* set mode for animation frame order */
+  if (parameter[GFX_ARG_MODE_LOOP])
+    graphic_info[graphic].anim_mode = ANIM_LOOP;
+  else if (parameter[GFX_ARG_MODE_LINEAR])
+    graphic_info[graphic].anim_mode = ANIM_LINEAR;
+  else if (parameter[GFX_ARG_MODE_PINGPONG])
+    graphic_info[graphic].anim_mode = ANIM_PINGPONG;
+  else if (parameter[GFX_ARG_MODE_PINGPONG2])
+    graphic_info[graphic].anim_mode = ANIM_PINGPONG2;
+  else if (parameter[GFX_ARG_MODE_RANDOM])
+    graphic_info[graphic].anim_mode = ANIM_RANDOM;
+  else if (graphic_info[graphic].anim_frames > 1)
+    graphic_info[graphic].anim_mode = ANIM_LOOP;
+  else
+    graphic_info[graphic].anim_mode = ANIM_NONE;
+
+  /* set additional flag to play animation frames in reverse order */
+  if (parameter[GFX_ARG_MODE_REVERSE])
+    graphic_info[graphic].anim_mode |= ANIM_REVERSE;
+
+  /* automatically determine correct start frame, if not defined */
+  if (parameter[GFX_ARG_START_FRAME] == ARG_UNDEFINED_VALUE)
+    graphic_info[graphic].anim_start_frame = 0;
+  else if (graphic_info[graphic].anim_mode & ANIM_REVERSE)
+    graphic_info[graphic].anim_start_frame =
+      graphic_info[graphic].anim_frames - parameter[GFX_ARG_START_FRAME] - 1;
+  else
+    graphic_info[graphic].anim_start_frame = parameter[GFX_ARG_START_FRAME];
+
+  /* animation synchronized with global frame counter, not move position */
+  graphic_info[graphic].anim_global_sync = parameter[GFX_ARG_GLOBAL_SYNC];
+}
 
-    /* set additional flag to play animation frames in reverse order */
-    if (parameter[GFX_ARG_MODE_REVERSE])
-      new_graphic_info[i].anim_mode |= ANIM_REVERSE;
+static void InitGraphicInfo()
+{
+  static boolean clipmasks_initialized = FALSE;
+  int num_images = getImageListSize();
+  int i;
+#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
+  Pixmap src_pixmap;
+  XGCValues clip_gc_values;
+  unsigned long clip_gc_valuemask;
+  GC copy_clipmask_gc = None;
+#endif
 
-    /* set first frame of animation after determining animation mode */
-    new_graphic_info[i].anim_start_frame = parameter[GFX_ARG_START_FRAME];
+  if (graphic_info != NULL)
+    free(graphic_info);
 
-    /* automatically determine correct start frame, if not defined */
-    if (parameter[GFX_ARG_START_FRAME] == GFX_ARG_UNDEFINED_VALUE)
-      new_graphic_info[i].anim_start_frame = 0;
-    else if (new_graphic_info[i].anim_mode & ANIM_REVERSE)
-      new_graphic_info[i].anim_start_frame =
-	new_graphic_info[i].anim_frames - parameter[GFX_ARG_START_FRAME] - 1;
+  graphic_info = checked_calloc(num_images * sizeof(struct GraphicInfo));
 
-    /* animation synchronized with global frame counter, not move position */
-    new_graphic_info[i].anim_global_sync = parameter[GFX_ARG_GLOBAL_SYNC];
+#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
+  if (clipmasks_initialized)
+  {
+    for (i=0; i<num_images; i++)
+    {
+      if (graphic_info[i].clip_mask)
+	XFreePixmap(display, graphic_info[i].clip_mask);
+      if (graphic_info[i].clip_gc)
+	XFreeGC(display, graphic_info[i].clip_gc);
+
+      graphic_info[i].clip_mask = None;
+      graphic_info[i].clip_gc = None;
+    }
+  }
+#endif
 
-    /* set global_sync for all animations with undefined "animation action" */
-    if (parameter[GFX_ARG_GLOBAL_SYNC] == GFX_ARG_UNDEFINED_VALUE)
-      new_graphic_info[i].anim_global_sync =
-	(gfx_action[i] == GFX_ACTION_DEFAULT ? TRUE : FALSE);
+  for (i=0; i<num_images; i++)
+  {
+    struct FileInfo *image = getImageListEntry(i);
+    Bitmap *src_bitmap;
+    int src_x, src_y;
+    int first_frame, last_frame;
 
-    /* "linear" animations are never globally synchronized */
-    if (parameter[GFX_ARG_MODE_LINEAR])
-      new_graphic_info[i].anim_global_sync = FALSE;
+    set_graphic_parameters(i, image->parameter);
 
     /* now check if no animation frames are outside of the loaded image */
 
+    if (graphic_info[i].bitmap == NULL)
+      continue;		/* skip check for optional images that are undefined */
+
     first_frame = 0;
     getGraphicSource(i, first_frame, &src_bitmap, &src_x, &src_y);
     if (src_x < 0 || src_y < 0 ||
 	src_x + TILEX > src_bitmap->width ||
 	src_y + TILEY > src_bitmap->height)
     {
-      Error(ERR_RETURN, "custom artwork configuration error:");
+      Error(ERR_RETURN_LINE, "-");
+      Error(ERR_RETURN, "warning: error found in config file:");
       Error(ERR_RETURN, "- config file: '%s'",
 	    getImageConfigFilename());
       Error(ERR_RETURN, "- config token: '%s'",
 	    getTokenFromImageID(i));
       Error(ERR_RETURN, "- image file: '%s'",
 	    src_bitmap->source_filename);
-      Error(ERR_EXIT, "error: first animation frame out of bounds (%d,%d)",
+      Error(ERR_RETURN,
+	    "error: first animation frame out of bounds (%d, %d)",
 	    src_x, src_y);
+      Error(ERR_RETURN, "custom graphic rejected for this element/action");
+      Error(ERR_RETURN_LINE, "-");
+
+      set_graphic_parameters(i, image->default_parameter);
     }
 
-    last_frame = new_graphic_info[i].anim_frames - 1;
+    last_frame = graphic_info[i].anim_frames - 1;
     getGraphicSource(i, last_frame, &src_bitmap, &src_x, &src_y);
     if (src_x < 0 || src_y < 0 ||
 	src_x + TILEX > src_bitmap->width ||
 	src_y + TILEY > src_bitmap->height)
     {
-      Error(ERR_RETURN, "custom artwork configuration error:");
+      Error(ERR_RETURN_LINE, "-");
+      Error(ERR_RETURN, "warning: error found in config file:");
       Error(ERR_RETURN, "- config file: '%s'",
 	    getImageConfigFilename());
       Error(ERR_RETURN, "- config token: '%s'",
 	    getTokenFromImageID(i));
       Error(ERR_RETURN, "- image file: '%s'",
 	    src_bitmap->source_filename);
-      Error(ERR_EXIT, "error: last animation frame out of bounds (%d,%d)",
-	    src_x, src_y);
+      Error(ERR_RETURN,
+	    "error: last animation frame (%d) out of bounds (%d, %d)",
+	    last_frame, src_x, src_y);
+      Error(ERR_RETURN, "custom graphic rejected for this element/action");
+      Error(ERR_RETURN_LINE, "-");
+
+      set_graphic_parameters(i, image->default_parameter);
+    }
+
+#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
+    /* currently we need only a tile clip mask from the first frame */
+    getGraphicSource(i, first_frame, &src_bitmap, &src_x, &src_y);
+
+    if (copy_clipmask_gc == None)
+    {
+      clip_gc_values.graphics_exposures = False;
+      clip_gc_valuemask = GCGraphicsExposures;
+      copy_clipmask_gc = XCreateGC(display, src_bitmap->clip_mask,
+				   clip_gc_valuemask, &clip_gc_values);
     }
+
+    graphic_info[i].clip_mask =
+      XCreatePixmap(display, window->drawable, TILEX, TILEY, 1);
+
+    src_pixmap = src_bitmap->clip_mask;
+    XCopyArea(display, src_pixmap, graphic_info[i].clip_mask,
+	      copy_clipmask_gc, src_x, src_y, TILEX, TILEY, 0, 0);
+
+    clip_gc_values.graphics_exposures = False;
+    clip_gc_values.clip_mask = graphic_info[i].clip_mask;
+    clip_gc_valuemask = GCGraphicsExposures | GCClipMask;
+    graphic_info[i].clip_gc =
+      XCreateGC(display, window->drawable, clip_gc_valuemask, &clip_gc_values);
+#endif
   }
+
+#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
+  if (copy_clipmask_gc)
+    XFreeGC(display, copy_clipmask_gc);
+#endif
+
+  clipmasks_initialized = TRUE;
+}
+
+static void set_sound_parameters(int sound, int *parameter)
+{
+  /* explicit loop mode setting in configuration overrides default value */
+  if (parameter[SND_ARG_MODE_LOOP] != ARG_UNDEFINED_VALUE)
+    sound_info[sound].loop = parameter[SND_ARG_MODE_LOOP];
 }
 
 static void InitSoundInfo()
 {
-  sound_files = getCurrentSoundList();
+  int *sound_effect_properties;
+  int num_sounds = getSoundListSize();
+  int i, j;
+
+  if (sound_info != NULL)
+    free(sound_info);
 
-  /* initialize sound effect lookup table for element actions */
-  InitGameSound();
+  sound_effect_properties = checked_calloc(num_sounds * sizeof(int));
+  sound_info = checked_calloc(num_sounds * sizeof(struct SoundInfo));
+
+  /* initialize sound effect for all elements to "no sound" */
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
+    for (j=0; j<NUM_ACTIONS; j++)
+      element_info[i].sound[j] = SND_UNDEFINED;
+
+  for (i=0; i<num_sounds; i++)
+  {
+    struct FileInfo *sound = getSoundListEntry(i);
+    int len_effect_text = strlen(sound->token);
+
+    sound_effect_properties[i] = ACTION_OTHER;
+    sound_info[i].loop = FALSE;
+
+    /* determine all loop sounds and identify certain sound classes */
+
+    for (j=0; element_action_info[j].suffix; j++)
+    {
+      int len_action_text = strlen(element_action_info[j].suffix);
+
+      if (len_action_text < len_effect_text &&
+	  strcmp(&sound->token[len_effect_text - len_action_text],
+		 element_action_info[j].suffix) == 0)
+      {
+	sound_effect_properties[i] = element_action_info[j].value;
+
+	if (element_action_info[j].is_loop_sound)
+	  sound_info[i].loop = TRUE;
+      }
+    }
+
+    /* associate elements and some selected sound actions */
+
+    for (j=0; j<MAX_NUM_ELEMENTS; j++)
+    {
+      if (element_info[j].sound_class_name)
+      {
+	int len_class_text = strlen(element_info[j].sound_class_name);
+
+	if (len_class_text + 1 < len_effect_text &&
+	    strncmp(sound->token,
+		    element_info[j].sound_class_name, len_class_text) == 0 &&
+	    sound->token[len_class_text] == '.')
+	{
+	  int sound_action_value = sound_effect_properties[i];
+
+	  element_info[j].sound[sound_action_value] = i;
+	}
+      }
+    }
+
+    set_sound_parameters(i, sound->parameter);
+  }
+
+  free(sound_effect_properties);
+
+#if 0
+  /* TEST ONLY */
+  {
+    int element = EL_SAND;
+    int sound_action = ACTION_DIGGING;
+    int j = 0;
+
+    while (element_action_info[j].suffix)
+    {
+      if (element_action_info[j].value == sound_action)
+	printf("element %d, sound action '%s'  == %d\n",
+	       element, element_action_info[j].suffix,
+	       element_info_[element].sound[sound_action]);
+      j++;
+    }
+  }
+#endif
 }
 
 void InitElementProperties()
@@ -1802,6 +2082,7 @@ void InitElementProperties()
     EL_SAND,
     EL_SP_BASE,
     EL_SP_BUGGY_BASE,
+    EL_SP_BUGGY_BASE_ACTIVATING,
     EL_TRAP,
     EL_INVISIBLE_SAND,
     EL_INVISIBLE_SAND_ACTIVE
@@ -2114,21 +2395,21 @@ void InitElementProperties()
   static int num_properties1 = SIZEOF_ARRAY(ep1_num, int *);
   static int num_properties2 = SIZEOF_ARRAY(ep2_num, int *);
 
-  for (i=0; i<MAX_ELEMENTS; i++)
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
   {
-    Elementeigenschaften1[i] = 0;
-    Elementeigenschaften2[i] = 0;
+    Properties1[i] = 0;
+    Properties2[i] = 0;
   }
 
   for (i=0; i<num_properties1; i++)
     for (j=0; j<*(ep1_num[i]); j++)
-      Elementeigenschaften1[(ep1_array[i])[j]] |= ep1_bit[i];
+      Properties1[(ep1_array[i])[j]] |= ep1_bit[i];
   for (i=0; i<num_properties2; i++)
     for (j=0; j<*(ep2_num[i]); j++)
-      Elementeigenschaften2[(ep2_array[i])[j]] |= ep2_bit[i];
+      Properties2[(ep2_array[i])[j]] |= ep2_bit[i];
 
   for (i=EL_CHAR_START; i<=EL_CHAR_END; i++)
-    Elementeigenschaften1[i] |= (EP_BIT_CHAR | EP_BIT_INACTIVE);
+    Properties1[i] |= (EP_BIT_CHAR | EP_BIT_INACTIVE);
 }
 
 void Execute_Command(char *command)
@@ -2181,6 +2462,18 @@ void Execute_Command(char *command)
 
     exit(0);
   }
+  else if (strncmp(command, "dump level ", 11) == 0)
+  {
+    char *filename = &command[11];
+
+    if (access(filename, F_OK) != 0)
+      Error(ERR_EXIT, "cannot open file '%s'", filename);
+
+    LoadLevelFromFilename(filename);
+    DumpLevel(&level);
+
+    exit(0);
+  }
   else if (strncmp(command, "dump tape ", 10) == 0)
   {
     char *filename = &command[10];