X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ffiles.c;h=5a5bf6405538feceb3115a6dd39a4d9deecc1d5d;hb=7d171d862abdecced79f60535b49a686386cefe1;hp=8e6ec1bb99c58cae3cca6f98f50d4bf1c7b1cefb;hpb=f7eeeedb1a0bb21cbd8366cf241faffc76aafc16;p=rocksndiamonds.git

diff --git a/src/files.c b/src/files.c
index 8e6ec1bb..5a5bf640 100644
--- a/src/files.c
+++ b/src/files.c
@@ -29,7 +29,7 @@
 #define CHUNK_SIZE_NONE		-1	/* do not write chunk size    */
 #define FILE_VERS_CHUNK_SIZE	8	/* size of file version chunk */
 #define LEVEL_HEADER_SIZE	80	/* size of level file header  */
-#define LEVEL_HEADER_UNUSED	7	/* unused level header bytes  */
+#define LEVEL_HEADER_UNUSED	0	/* unused level header bytes  */
 #define LEVEL_CHUNK_CNT2_SIZE	160	/* size of level CNT2 chunk   */
 #define LEVEL_CHUNK_CNT2_UNUSED	11	/* unused CNT2 chunk bytes    */
 #define LEVEL_CHUNK_CNT3_HEADER	16	/* size of level CNT3 header  */
@@ -49,22 +49,6 @@
 #define TAPE_COOKIE_TMPL	"ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
 #define SCORE_COOKIE		"ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
 
-/* values for level file type identifier */
-#define LEVEL_FILE_TYPE_UNKNOWN		0
-#define LEVEL_FILE_TYPE_RND		1
-#define LEVEL_FILE_TYPE_BD		2
-#define LEVEL_FILE_TYPE_EM		3
-#define LEVEL_FILE_TYPE_SP		4
-#define LEVEL_FILE_TYPE_DX		5
-#define LEVEL_FILE_TYPE_SB		6
-#define LEVEL_FILE_TYPE_DC		7
-
-#define LEVEL_FILE_TYPE_RND_PACKED	(10 + LEVEL_FILE_TYPE_RND)
-#define LEVEL_FILE_TYPE_EM_PACKED	(10 + LEVEL_FILE_TYPE_EM)
-
-#define IS_SINGLE_LEVEL_FILE(x)		(x < 10)
-#define IS_PACKED_LEVEL_FILE(x)		(x > 10)
-
 
 /* ========================================================================= */
 /* level file functions                                                      */
@@ -106,15 +90,15 @@ void setElementChangeInfoToDefaults(struct ElementChangeInfo *change)
   change->trigger_element = EL_EMPTY_SPACE;
 
   change->explode = FALSE;
-  change->use_content = FALSE;
-  change->only_complete = FALSE;
-  change->use_random_change = FALSE;
-  change->random = 100;
-  change->power = CP_NON_DESTRUCTIVE;
+  change->use_target_content = FALSE;
+  change->only_if_complete = FALSE;
+  change->use_random_replace = FALSE;
+  change->random_percentage = 100;
+  change->replace_when = CP_WHEN_EMPTY;
 
   for (x = 0; x < 3; x++)
     for (y = 0; y < 3; y++)
-      change->content[x][y] = EL_EMPTY_SPACE;
+      change->target_content[x][y] = EL_EMPTY_SPACE;
 
   change->direct_action = 0;
   change->other_action = 0;
@@ -126,8 +110,14 @@ void setElementChangeInfoToDefaults(struct ElementChangeInfo *change)
 
 static void setLevelInfoToDefaults(struct LevelInfo *level)
 {
+  static boolean clipboard_elements_initialized = FALSE;
+
   int i, j, x, y;
 
+  level->native_em_level = &native_em_level;
+
+  level->game_engine_type = GAME_ENGINE_TYPE_RND;
+
   level->file_version = FILE_VERSION_ACTUAL;
   level->game_version = GAME_VERSION_ACTUAL;
 
@@ -157,13 +147,19 @@ static void setLevelInfoToDefaults(struct LevelInfo *level)
   level->double_speed = FALSE;
   level->initial_gravity = FALSE;
   level->em_slippery_gems = FALSE;
-  level->block_last_field = FALSE;
-  level->sp_block_last_field = TRUE;
+  level->instant_relocation = FALSE;
+  level->can_pass_to_walkable = FALSE;
+  level->grow_into_diggable = TRUE;
 
-  level->use_spring_bug = FALSE;
+  level->block_last_field = FALSE;	/* EM does not block by default */
+  level->sp_block_last_field = TRUE;	/* SP blocks the last field */
+  level->block_delay = 8;		/* when blocking, block 8 frames */
+  level->sp_block_delay = 9;		/* SP indeed blocks 9 frames, not 8 */
 
   level->can_move_into_acid_bits = ~0;	/* everything can move into acid */
+  level->dont_collide_with_bits = ~0;	/* always deadly when colliding */
 
+  level->use_spring_bug = FALSE;
   level->use_step_counter = FALSE;
 
   level->use_custom_template = FALSE;
@@ -200,10 +196,16 @@ static void setLevelInfoToDefaults(struct LevelInfo *level)
   {
     int element = i;
 
+    /* never initialize clipboard elements after the very first time */
+    if (IS_CLIPBOARD_ELEMENT(element) && clipboard_elements_initialized)
+      continue;
+
     setElementChangePages(&element_info[element], 1);
     setElementChangeInfoToDefaults(element_info[element].change);
 
-    if (IS_CUSTOM_ELEMENT(element) || IS_GROUP_ELEMENT(element))
+    if (IS_CUSTOM_ELEMENT(element) ||
+	IS_GROUP_ELEMENT(element) ||
+	IS_INTERNAL_ELEMENT(element))
     {
       for (j = 0; j < MAX_ELEMENT_NAME_LEN + 1; j++)
 	element_info[element].description[j] = '\0';
@@ -217,9 +219,12 @@ static void setLevelInfoToDefaults(struct LevelInfo *level)
 
       element_info[element].use_gfx_element = FALSE;
       element_info[element].gfx_element = EL_EMPTY_SPACE;
+
+      element_info[element].modified_settings = FALSE;
     }
 
-    if (IS_CUSTOM_ELEMENT(element))
+    if (IS_CUSTOM_ELEMENT(element) ||
+	IS_INTERNAL_ELEMENT(element))
     {
       element_info[element].access_direction = MV_ALL_DIRECTIONS;
 
@@ -228,19 +233,23 @@ static void setLevelInfoToDefaults(struct LevelInfo *level)
 
       element_info[element].push_delay_fixed = -1;	/* initialize later */
       element_info[element].push_delay_random = -1;	/* initialize later */
+      element_info[element].drop_delay_fixed = 0;
+      element_info[element].drop_delay_random = 0;
       element_info[element].move_delay_fixed = 0;
       element_info[element].move_delay_random = 0;
 
       element_info[element].move_pattern = MV_ALL_DIRECTIONS;
       element_info[element].move_direction_initial = MV_START_AUTOMATIC;
       element_info[element].move_stepsize = TILEX / 8;
+
       element_info[element].move_enter_element = EL_EMPTY_SPACE;
       element_info[element].move_leave_element = EL_EMPTY_SPACE;
       element_info[element].move_leave_type = LEAVE_TYPE_UNLIMITED;
 
       element_info[element].slippery_type = SLIPPERY_ANY_RANDOM;
 
-      element_info[element].explosion_delay = 18;
+      element_info[element].explosion_type = EXPLODES_3X3;
+      element_info[element].explosion_delay = 16;
       element_info[element].ignition_delay = 8;
 
       for (x = 0; x < 3; x++)
@@ -253,7 +262,6 @@ static void setLevelInfoToDefaults(struct LevelInfo *level)
       element_info[element].walk_to_action = 0;
       element_info[element].smash_targets = 0;
       element_info[element].deadliness = 0;
-      element_info[element].consistency = 0;
 
       element_info[element].can_explode_by_fire = FALSE;
       element_info[element].can_explode_smashed = FALSE;
@@ -267,10 +275,10 @@ static void setLevelInfoToDefaults(struct LevelInfo *level)
 
       /* now set default properties */
       SET_PROPERTY(element, EP_CAN_MOVE_INTO_ACID, TRUE);
-
-      element_info[element].modified_settings = FALSE;
     }
-    else if (IS_GROUP_ELEMENT(element) || element == EL_INTERNAL_EDITOR)
+
+    if (IS_GROUP_ELEMENT(element) ||
+	IS_INTERNAL_ELEMENT(element))
     {
       /* initialize memory for list of elements in group */
       if (element_info[element].group == NULL)
@@ -287,9 +295,13 @@ static void setLevelInfoToDefaults(struct LevelInfo *level)
     }
   }
 
+  clipboard_elements_initialized = TRUE;
+
   BorderElement = EL_STEELWALL;
 
-  level->no_level_file = FALSE;
+  level->no_valid_file = FALSE;
+
+  level->changed = FALSE;
 
   if (leveldir_current == NULL)		/* only when dumping level */
     return;
@@ -527,6 +539,20 @@ static void determineLevelFileInfo_Filetype(struct LevelFileInfo *lfi)
     lfi->type = getFileTypeFromBasename(lfi->basename);
 }
 
+#if 1
+static void setLevelFileInfo(struct LevelFileInfo *level_file_info, int nr)
+{
+  /* always start with reliable default values */
+  setFileInfoToDefaults(level_file_info);
+
+  level_file_info->nr = nr;	/* set requested level number */
+
+  determineLevelFileInfo_Filename(level_file_info);
+  determineLevelFileInfo_Filetype(level_file_info);
+}
+
+#else
+
 static struct LevelFileInfo *getLevelFileInfo(int nr)
 {
   static struct LevelFileInfo level_file_info;
@@ -541,7 +567,7 @@ static struct LevelFileInfo *getLevelFileInfo(int nr)
 
   return &level_file_info;
 }
-
+#endif
 
 /* ------------------------------------------------------------------------- */
 /* functions for loading R'n'D level                                         */
@@ -549,7 +575,7 @@ static struct LevelFileInfo *getLevelFileInfo(int nr)
 
 int getMappedElement(int element)
 {
-  /* map some (historic, now obsolete) elements */
+  /* remap some (historic, now obsolete) elements */
 
 #if 1
   switch (element)
@@ -610,6 +636,32 @@ int getMappedElement(int element)
   return element;
 }
 
+int getMappedElementByVersion(int element, int game_version)
+{
+  /* remap some elements due to certain game version */
+
+  if (game_version <= VERSION_IDENT(2,2,0,0))
+  {
+    /* map game font elements */
+    element = (element == EL_CHAR('[')  ? EL_CHAR_AUMLAUT :
+	       element == EL_CHAR('\\') ? EL_CHAR_OUMLAUT :
+	       element == EL_CHAR(']')  ? EL_CHAR_UUMLAUT :
+	       element == EL_CHAR('^')  ? EL_CHAR_COPYRIGHT : element);
+  }
+
+  if (game_version < VERSION_IDENT(3,0,0,0))
+  {
+    /* map Supaplex gravity tube elements */
+    element = (element == EL_SP_GRAVITY_PORT_LEFT  ? EL_SP_PORT_LEFT  :
+	       element == EL_SP_GRAVITY_PORT_RIGHT ? EL_SP_PORT_RIGHT :
+	       element == EL_SP_GRAVITY_PORT_UP    ? EL_SP_PORT_UP    :
+	       element == EL_SP_GRAVITY_PORT_DOWN  ? EL_SP_PORT_DOWN  :
+	       element);
+  }
+
+  return element;
+}
+
 static int LoadLevel_VERS(FILE *file, int chunk_size, struct LevelInfo *level)
 {
   level->file_version = getFileVersion(file);
@@ -654,12 +706,17 @@ static int LoadLevel_HEAD(FILE *file, int chunk_size, struct LevelInfo *level)
 
   level->block_last_field	= (getFile8Bit(file) == 1 ? TRUE : FALSE);
   level->sp_block_last_field	= (getFile8Bit(file) == 1 ? TRUE : FALSE);
+  level->can_move_into_acid_bits = getFile32BitBE(file);
+  level->dont_collide_with_bits = getFile8Bit(file);
 
   level->use_spring_bug		= (getFile8Bit(file) == 1 ? TRUE : FALSE);
+  level->use_step_counter	= (getFile8Bit(file) == 1 ? TRUE : FALSE);
 
-  level->can_move_into_acid_bits = getFile16BitBE(file);
+  level->instant_relocation	= (getFile8Bit(file) == 1 ? TRUE : FALSE);
+  level->can_pass_to_walkable	= (getFile8Bit(file) == 1 ? TRUE : FALSE);
+  level->grow_into_diggable	= (getFile8Bit(file) == 1 ? TRUE : FALSE);
 
-  level->use_step_counter	= (getFile8Bit(file) == 1 ? TRUE : FALSE);
+  level->game_engine_type	= getFile8Bit(file);
 
   ReadUnusedBytesFromFile(file, LEVEL_HEADER_UNUSED);
 
@@ -940,16 +997,16 @@ static int LoadLevel_CUS3(FILE *file, int chunk_size, struct LevelInfo *level)
       getMappedElement(getFile16BitBE(file));
 
     element_info[element].change->explode = getFile8Bit(file);
-    element_info[element].change->use_content = getFile8Bit(file);
-    element_info[element].change->only_complete = getFile8Bit(file);
-    element_info[element].change->use_random_change = getFile8Bit(file);
+    element_info[element].change->use_target_content = getFile8Bit(file);
+    element_info[element].change->only_if_complete = getFile8Bit(file);
+    element_info[element].change->use_random_replace = getFile8Bit(file);
 
-    element_info[element].change->random = getFile8Bit(file);
-    element_info[element].change->power = getFile8Bit(file);
+    element_info[element].change->random_percentage = getFile8Bit(file);
+    element_info[element].change->replace_when = getFile8Bit(file);
 
     for (y = 0; y < 3; y++)
       for (x = 0; x < 3; x++)
-	element_info[element].change->content[x][y] =
+	element_info[element].change->target_content[x][y] =
 	  getMappedElement(getFile16BitBE(file));
 
     element_info[element].slippery_type = getFile8Bit(file);
@@ -1010,8 +1067,10 @@ static int LoadLevel_CUS4(FILE *file, int chunk_size, struct LevelInfo *level)
   ei->collect_score = getFile8Bit(file);
   ei->collect_count = getFile8Bit(file);
 
-  ei->push_delay_fixed = getFile16BitBE(file);
-  ei->push_delay_random = getFile16BitBE(file);
+  ei->drop_delay_fixed = getFile8Bit(file);
+  ei->push_delay_fixed = getFile8Bit(file);
+  ei->drop_delay_random = getFile8Bit(file);
+  ei->push_delay_random = getFile8Bit(file);
   ei->move_delay_fixed = getFile16BitBE(file);
   ei->move_delay_random = getFile16BitBE(file);
 
@@ -1037,9 +1096,10 @@ static int LoadLevel_CUS4(FILE *file, int chunk_size, struct LevelInfo *level)
 
   ei->explosion_delay = getFile8Bit(file);
   ei->ignition_delay = getFile8Bit(file);
+  ei->explosion_type = getFile8Bit(file);
 
   /* some free bytes for future custom property values and padding */
-  ReadUnusedBytesFromFile(file, 2);
+  ReadUnusedBytesFromFile(file, 1);
 
   /* read change property values */
 
@@ -1063,16 +1123,16 @@ static int LoadLevel_CUS4(FILE *file, int chunk_size, struct LevelInfo *level)
     change->trigger_element = getMappedElement(getFile16BitBE(file));
 
     change->explode = getFile8Bit(file);
-    change->use_content = getFile8Bit(file);
-    change->only_complete = getFile8Bit(file);
-    change->use_random_change = getFile8Bit(file);
+    change->use_target_content = getFile8Bit(file);
+    change->only_if_complete = getFile8Bit(file);
+    change->use_random_replace = getFile8Bit(file);
 
-    change->random = getFile8Bit(file);
-    change->power = getFile8Bit(file);
+    change->random_percentage = getFile8Bit(file);
+    change->replace_when = getFile8Bit(file);
 
     for (y = 0; y < 3; y++)
       for (x = 0; x < 3; x++)
-	change->content[x][y] = getMappedElement(getFile16BitBE(file));
+	change->target_content[x][y] = getMappedElement(getFile16BitBE(file));
 
     change->can_change = getFile8Bit(file);
 
@@ -1156,7 +1216,7 @@ static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
 
   if (!(file = fopen(filename, MODE_READ)))
   {
-    level->no_level_file = TRUE;
+    level->no_valid_file = TRUE;
 
     if (level != &level_template)
       Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
@@ -1172,6 +1232,8 @@ static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
     getFileChunkBE(file, chunk_name, NULL);
     if (strcmp(chunk_name, "CAVE") != 0)
     {
+      level->no_valid_file = TRUE;
+
       Error(ERR_WARN, "unknown format of level file '%s'", filename);
       fclose(file);
       return;
@@ -1186,6 +1248,8 @@ static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
 
     if (!checkCookieString(cookie, LEVEL_COOKIE_TMPL))
     {
+      level->no_valid_file = TRUE;
+
       Error(ERR_WARN, "unknown format of level file '%s'", filename);
       fclose(file);
       return;
@@ -1193,6 +1257,8 @@ static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
 
     if ((level->file_version = getFileVersionFromCookieString(cookie)) == -1)
     {
+      level->no_valid_file = TRUE;
+
       Error(ERR_WARN, "unsupported version of level file '%s'", filename);
       fclose(file);
       return;
@@ -1279,6 +1345,8 @@ static void LoadLevelFromFileInfo_RND(struct LevelInfo *level,
 /* functions for loading EM level                                            */
 /* ------------------------------------------------------------------------- */
 
+#if 0
+
 static int map_em_element_yam(int element)
 {
   switch (element)
@@ -1591,29 +1659,26 @@ static int map_em_element_field(int element)
 #define EM_LEVEL_XSIZE			64
 #define EM_LEVEL_YSIZE			32
 
-static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
-				     struct LevelFileInfo *level_file_info)
+static void OLD_LoadLevelFromFileInfo_EM(struct LevelInfo *level,
+					 struct LevelFileInfo *level_file_info)
 {
   char *filename = level_file_info->filename;
   FILE *file;
   unsigned char leveldata[EM_LEVEL_SIZE];
   unsigned char *header = &leveldata[EM_LEVEL_XSIZE * EM_LEVEL_YSIZE];
-  unsigned char code0 = 0x65;
-  unsigned char code1 = 0x11;
-  boolean level_is_crypted = FALSE;
   int nr = level_file_info->nr;
   int i, x, y;
 
   if (!(file = fopen(filename, MODE_READ)))
   {
-    level->no_level_file = TRUE;
+    level->no_valid_file = TRUE;
 
     Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
 
     return;
   }
 
-  for(i = 0; i < EM_LEVEL_SIZE; i++)
+  for (i = 0; i < EM_LEVEL_SIZE; i++)
     leveldata[i] = fgetc(file);
 
   fclose(file);
@@ -1624,20 +1689,20 @@ static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
   if ((leveldata[0] == 0xf1 ||
        leveldata[0] == 0xf5) && leveldata[2] == 0xe7 && leveldata[3] == 0xee)
   {
-    level_is_crypted = TRUE;
+    unsigned char code0 = 0x65;
+    unsigned char code1 = 0x11;
 
     if (leveldata[0] == 0xf5)	/* error in crypted Emerald Mine 2 levels */
       leveldata[0] = 0xf1;
-  }
 
-  if (level_is_crypted)		/* decode crypted level data */
-  {
-    for(i = 0; i < EM_LEVEL_SIZE; i++)
+    /* decode crypted level data */
+
+    for (i = 0; i < EM_LEVEL_SIZE; i++)
     {
       leveldata[i] ^= code0;
       leveldata[i] -= code1;
 
-      code0  = (code0 + 7) & 0xff;
+      code0 = (code0 + 7) & 0xff;
     }
   }
 
@@ -1670,9 +1735,9 @@ static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
 
   level->num_yamyam_contents = 4;
 
-  for(i = 0; i < level->num_yamyam_contents; i++)
-    for(y = 0; y < 3; y++)
-      for(x = 0; x < 3; x++)
+  for (i = 0; i < level->num_yamyam_contents; i++)
+    for (y = 0; y < 3; y++)
+      for (x = 0; x < 3; x++)
 	level->yamyam_content[i][x][y] =
 	  map_em_element_yam(header[i * 9 + y * 3 + x]);
 
@@ -1700,6 +1765,151 @@ static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
   level->field[x][y] = EL_PLAYER_2;
 }
 
+#else
+
+void CopyNativeLevel_RND_to_EM(struct LevelInfo *level)
+{
+  struct LevelInfo_EM *level_em = level->native_em_level;
+  struct LEVEL *lev = level_em->lev;
+  struct PLAYER *ply1 = level_em->ply1;
+  struct PLAYER *ply2 = level_em->ply2;
+  int i, x, y;
+
+  lev->width  = MIN(level->fieldx, EM_MAX_CAVE_WIDTH);
+  lev->height = MIN(level->fieldy, EM_MAX_CAVE_HEIGHT);
+
+  lev->time_initial = level->time;
+  lev->required_initial = level->gems_needed;
+
+  lev->emerald_score	= level->score[SC_EMERALD];
+  lev->diamond_score	= level->score[SC_DIAMOND];
+  lev->alien_score	= level->score[SC_ROBOT];
+  lev->tank_score	= level->score[SC_SPACESHIP];
+  lev->bug_score	= level->score[SC_BUG];
+  lev->eater_score	= level->score[SC_YAMYAM];
+  lev->nut_score	= level->score[SC_NUT];
+  lev->dynamite_score	= level->score[SC_DYNAMITE];
+  lev->key_score	= level->score[SC_TIME_BONUS];	/* ??? CHECK THIS */
+
+  for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
+    for (y = 0; y < 3; y++)
+      for (x = 0; x < 3; x++)
+	lev->eater_array[i][y * 3 + x] =
+	  map_element_RND_to_EM(level->yamyam_content[i][x][y]);
+
+  lev->ameuba_time		= level->amoeba_speed;
+  lev->wonderwall_time_initial	= level->time_magic_wall;
+  lev->wheel_time		= level->time_wheel;
+
+  /* first fill the complete playfield with the default border element */
+  for (y = 0; y < EM_MAX_CAVE_HEIGHT; y++)
+    for (x = 0; x < EM_MAX_CAVE_WIDTH; x++)
+      level_em->cave[x][y] = ZBORDER;
+
+  /* then copy the real level contents from level file into the playfield */
+  for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++)
+  {
+    int new_element = map_element_RND_to_EM(level->field[x][y]);
+
+    level_em->cave[x + 1][y + 1] = new_element;
+  }
+
+  ply1->x_initial = 0;
+  ply1->y_initial = 0;
+
+  ply2->x_initial = 0;
+  ply2->y_initial = 0;
+
+  /* at last, set the two players at their positions in the playfield */
+  for (y = 0; y < lev->height; y++) for (x = 0; x < lev->width; x++)
+  {
+    if (level->field[x][y] == EL_PLAYER_1)
+    {
+      ply1->x_initial = x + 1;
+      ply1->y_initial = y + 1;
+    }
+    else if (level->field[x][y] == EL_PLAYER_2)
+    {
+      ply2->x_initial = x + 1;
+      ply2->y_initial = y + 1;
+    }
+  }
+}
+
+void CopyNativeLevel_EM_to_RND(struct LevelInfo *level)
+{
+  struct LevelInfo_EM *level_em = level->native_em_level;
+  struct LEVEL *lev = level_em->lev;
+  struct PLAYER *ply1 = level_em->ply1;
+  struct PLAYER *ply2 = level_em->ply2;
+  int i, x, y;
+
+  level->fieldx = MIN(lev->width,  MAX_LEV_FIELDX);
+  level->fieldy = MIN(lev->height, MAX_LEV_FIELDY);
+
+  level->time = lev->time_initial;
+  level->gems_needed = lev->required_initial;
+
+  sprintf(level->name, "Level %d", level->file_info.nr);
+
+  level->score[SC_EMERALD]	= lev->emerald_score;
+  level->score[SC_DIAMOND]	= lev->diamond_score;
+  level->score[SC_ROBOT]	= lev->alien_score;
+  level->score[SC_SPACESHIP]	= lev->tank_score;
+  level->score[SC_BUG]		= lev->bug_score;
+  level->score[SC_YAMYAM]	= lev->eater_score;
+  level->score[SC_NUT]		= lev->nut_score;
+  level->score[SC_DYNAMITE]	= lev->dynamite_score;
+  level->score[SC_TIME_BONUS]	= lev->key_score;	/* ??? CHECK THIS */
+
+  level->num_yamyam_contents = MAX_ELEMENT_CONTENTS;
+
+  for (i = 0; i < level->num_yamyam_contents; i++)
+    for (y = 0; y < 3; y++)
+      for (x = 0; x < 3; x++)
+	level->yamyam_content[i][x][y] =
+	  map_element_EM_to_RND(lev->eater_array[i][y * 3 + x]);
+
+  level->amoeba_speed		= lev->ameuba_time;
+  level->time_magic_wall	= lev->wonderwall_time_initial;
+  level->time_wheel		= lev->wheel_time;
+
+  for (y = 0; y < level->fieldy; y++) for (x = 0; x < level->fieldx; x++)
+  {
+    int new_element = map_element_EM_to_RND(level_em->cave[x + 1][y + 1]);
+
+    if (new_element == EL_AMOEBA_WET && level->amoeba_speed == 0)
+      new_element = EL_AMOEBA_DEAD;
+
+    level->field[x][y] = new_element;
+  }
+
+  level->field[ply1->x_initial - 1][ply1->y_initial - 1] = EL_PLAYER_1;
+  level->field[ply2->x_initial - 1][ply2->y_initial - 1] = EL_PLAYER_2;
+}
+
+static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
+				     struct LevelFileInfo *level_file_info)
+{
+  if (!LoadNativeLevel_EM(level_file_info->filename))
+    level->no_valid_file = TRUE;
+}
+
+#endif
+
+void CopyNativeLevel_RND_to_Native(struct LevelInfo *level)
+{
+  if (level->game_engine_type == GAME_ENGINE_TYPE_EM)
+    CopyNativeLevel_RND_to_EM(level);
+}
+
+void CopyNativeLevel_Native_to_RND(struct LevelInfo *level)
+{
+  if (level->game_engine_type == GAME_ENGINE_TYPE_EM)
+    CopyNativeLevel_EM_to_RND(level);
+}
+
+
 /* ------------------------------------------------------------------------- */
 /* functions for loading SP level                                            */
 /* ------------------------------------------------------------------------- */
@@ -1713,8 +1923,12 @@ static void LoadLevelFromFileInfo_EM(struct LevelInfo *level,
 static void LoadLevelFromFileStream_SP(FILE *file, struct LevelInfo *level,
 				       int nr)
 {
+  int num_special_ports;
   int i, x, y;
 
+  /* for details of the Supaplex level format, see Herman Perk's Supaplex
+     documentation file "SPFIX63.DOC" from his Supaplex "SpeedFix" package */
+
   /* read level body (width * height == 60 * 24 tiles == 1440 bytes) */
   for (y = 0; y < SP_LEVEL_YSIZE; y++)
   {
@@ -1739,28 +1953,104 @@ static void LoadLevelFromFileStream_SP(FILE *file, struct LevelInfo *level,
     }
   }
 
-  ReadUnusedBytesFromFile(file, 4);
+  ReadUnusedBytesFromFile(file, 4);	/* (not used by Supaplex engine) */
 
-  /* Initial gravitation: 1 == "on", anything else (0) == "off" */
+  /* initial gravity: 1 == "on", anything else (0) == "off" */
   level->initial_gravity = (fgetc(file) == 1 ? TRUE : FALSE);
 
-  ReadUnusedBytesFromFile(file, 1);
+  ReadUnusedBytesFromFile(file, 1);	/* (not used by Supaplex engine) */
 
   /* level title in uppercase letters, padded with dashes ("-") (23 bytes) */
   for (i = 0; i < SP_LEVEL_NAME_LEN; i++)
     level->name[i] = fgetc(file);
   level->name[SP_LEVEL_NAME_LEN] = '\0';
 
-  /* initial "freeze zonks": 2 == "on", anything else (0) == "off" */
-  ReadUnusedBytesFromFile(file, 1);	/* !!! NOT SUPPORTED YET !!! */
+  /* initial "freeze zonks": 2 == "on", anything else (0, 1) == "off" */
+  ReadUnusedBytesFromFile(file, 1);	/* (not used by R'n'D engine) */
 
   /* number of infotrons needed; 0 means that Supaplex will count the total
-     amount of infotrons in the level and use the low byte of that number.
+     amount of infotrons in the level and use the low byte of that number
      (a multiple of 256 infotrons will result in "0 infotrons needed"!) */
   level->gems_needed = fgetc(file);
 
-  /* information about special gravity port entries */
-  ReadUnusedBytesFromFile(file, 65);	/* !!! NOT SUPPORTED YET !!! */
+  /* number of special ("gravity") port entries below (maximum 10 allowed) */
+  num_special_ports = fgetc(file);
+
+  /* database of properties of up to 10 special ports (6 bytes per port) */
+  for (i = 0; i < 10; i++)
+  {
+    int port_location, port_x, port_y, port_element;
+    int gravity;
+
+    /* high and low byte of the location of a special port; if (x, y) are the
+       coordinates of a port in the field and (0, 0) is the top-left corner,
+       the 16 bit value here calculates as 2 * (x + (y * 60)) (this is twice
+       of what may be expected: Supaplex works with a game field in memory
+       which is 2 bytes per tile) */
+    port_location = getFile16BitBE(file);
+
+    /* change gravity: 1 == "turn on", anything else (0) == "turn off" */
+    gravity = fgetc(file);
+
+    /* "freeze zonks": 2 == "turn on", anything else (0, 1) == "turn off" */
+    ReadUnusedBytesFromFile(file, 1);	/* (not used by R'n'D engine) */
+
+    /* "freeze enemies": 1 == "turn on", anything else (0) == "turn off" */
+    ReadUnusedBytesFromFile(file, 1);	/* (not used by R'n'D engine) */
+
+    ReadUnusedBytesFromFile(file, 1);	/* (not used by Supaplex engine) */
+
+    if (i >= num_special_ports)
+      continue;
+
+    port_x = (port_location / 2) % SP_LEVEL_XSIZE;
+    port_y = (port_location / 2) / SP_LEVEL_XSIZE;
+
+    if (port_x < 0 || port_x >= SP_LEVEL_XSIZE ||
+	port_y < 0 || port_y >= SP_LEVEL_YSIZE)
+    {
+      Error(ERR_WARN, "special port position (%d, %d) out of bounds",
+	    port_x, port_y);
+
+      continue;
+    }
+
+    port_element = level->field[port_x][port_y];
+
+    if (port_element < EL_SP_GRAVITY_PORT_RIGHT ||
+	port_element > EL_SP_GRAVITY_PORT_UP)
+    {
+      Error(ERR_WARN, "no special port at position (%d, %d)", port_x, port_y);
+
+      continue;
+    }
+
+    /* change previous (wrong) gravity inverting special port to either
+       gravity enabling special port or gravity disabling special port */
+    level->field[port_x][port_y] +=
+      (gravity == 1 ? EL_SP_GRAVITY_ON_PORT_RIGHT :
+       EL_SP_GRAVITY_OFF_PORT_RIGHT) - EL_SP_GRAVITY_PORT_RIGHT;
+  }
+
+  ReadUnusedBytesFromFile(file, 4);	/* (not used by Supaplex engine) */
+
+  /* change special gravity ports without database entries to normal ports */
+  for (y = 0; y < SP_LEVEL_YSIZE; y++)
+    for (x = 0; x < SP_LEVEL_XSIZE; x++)
+      if (level->field[x][y] >= EL_SP_GRAVITY_PORT_RIGHT &&
+	  level->field[x][y] <= EL_SP_GRAVITY_PORT_UP)
+	level->field[x][y] += EL_SP_PORT_RIGHT - EL_SP_GRAVITY_PORT_RIGHT;
+
+  /* auto-determine number of infotrons if it was stored as "0" -- see above */
+  if (level->gems_needed == 0)
+  {
+    for (y = 0; y < SP_LEVEL_YSIZE; y++)
+      for (x = 0; x < SP_LEVEL_XSIZE; x++)
+	if (level->field[x][y] == EL_SP_INFOTRON)
+	  level->gems_needed++;
+
+    level->gems_needed &= 0xff;		/* only use low byte -- see above */
+  }
 
   level->fieldx = SP_LEVEL_XSIZE;
   level->fieldy = SP_LEVEL_YSIZE;
@@ -1771,13 +2061,13 @@ static void LoadLevelFromFileStream_SP(FILE *file, struct LevelInfo *level,
   level->time_wheel = 0;
   level->amoeba_content = EL_EMPTY;
 
-  for(i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
+  for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
     level->score[i] = 0;		/* !!! CORRECT THIS !!! */
 
   /* there are no yamyams in supaplex levels */
-  for(i = 0; i < level->num_yamyam_contents; i++)
-    for(y = 0; y < 3; y++)
-      for(x = 0; x < 3; x++)
+  for (i = 0; i < level->num_yamyam_contents; i++)
+    for (y = 0; y < 3; y++)
+      for (x = 0; x < 3; x++)
 	level->yamyam_content[i][x][y] = EL_EMPTY;
 }
 
@@ -1798,7 +2088,7 @@ static void LoadLevelFromFileInfo_SP(struct LevelInfo *level,
 
   if (!(file = fopen(filename, MODE_READ)))
   {
-    level->no_level_file = TRUE;
+    level->no_valid_file = TRUE;
 
     Error(ERR_WARN, "cannot read level '%s' -- using empty level", filename);
 
@@ -1808,7 +2098,7 @@ static void LoadLevelFromFileInfo_SP(struct LevelInfo *level,
   /* position file stream to the requested level inside the level package */
   if (fseek(file, nr * SP_LEVEL_SIZE, SEEK_SET) != 0)
   {
-    level->no_level_file = TRUE;
+    level->no_valid_file = TRUE;
 
     Error(ERR_WARN, "cannot fseek level '%s' -- using empty level", filename);
 
@@ -1978,6 +2268,7 @@ void LoadLevelFromFileInfo(struct LevelInfo *level,
 
     case LEVEL_FILE_TYPE_EM:
       LoadLevelFromFileInfo_EM(level, level_file_info);
+      level->game_engine_type = GAME_ENGINE_TYPE_EM;
       break;
 
     case LEVEL_FILE_TYPE_SP:
@@ -1988,6 +2279,11 @@ void LoadLevelFromFileInfo(struct LevelInfo *level,
       LoadLevelFromFileInfo_RND(level, level_file_info);
       break;
   }
+
+  if (level->game_engine_type == GAME_ENGINE_TYPE_UNKNOWN)
+    level->game_engine_type = GAME_ENGINE_TYPE_RND;
+
+  CopyNativeLevel_Native_to_RND(level);
 }
 
 void LoadLevelFromFilename(struct LevelInfo *level, char *filename)
@@ -2040,6 +2336,11 @@ static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
        pre-2.0 levels, where the game version is still taken from the
        file format version used to store the level -- see above). */
 
+#if 1
+    /* player was faster than enemies in 1.0.0 and before */
+    if (level->file_version == FILE_VERSION_1_0)
+      level->double_speed = TRUE;
+#else
     /* do some special adjustments to support older level versions */
     if (level->file_version == FILE_VERSION_1_0)
     {
@@ -2049,19 +2350,23 @@ static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
       /* player was faster than monsters in (pre-)1.0 levels */
       level->double_speed = TRUE;
     }
+#endif
 
-    /* Default behaviour for EM style gems was "slippery" only in 2.0.1 */
+    /* default behaviour for EM style gems was "slippery" only in 2.0.1 */
     if (level->game_version == VERSION_IDENT(2,0,1,0))
       level->em_slippery_gems = TRUE;
 
+    /* springs could be pushed over pits before (pre-release version) 2.2.0 */
     if (level->game_version < VERSION_IDENT(2,2,0,0))
       level->use_spring_bug = TRUE;
 
-    if (level->game_version < VERSION_IDENT(3,0,9,0))
+    /* only few elements were able to actively move into acid before 3.1.0 */
+    if (level->game_version < VERSION_IDENT(3,1,0,0))
     {
       int i, j;
 
       level->can_move_into_acid_bits = 0; /* nothing can move into acid */
+      level->dont_collide_with_bits = 0; /* nothing is deadly when colliding */
 
       setMoveIntoAcidProperty(level, EL_ROBOT,     TRUE);
       setMoveIntoAcidProperty(level, EL_SATELLITE, TRUE);
@@ -2085,8 +2390,25 @@ static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
 	}
       }
     }
+
+#if 1	/* USE_NEW_BLOCK_STYLE */
+    /* blocking the last field when moving was corrected in version 3.1.1 */
+    if (level->game_version < VERSION_IDENT(3,1,1,0))
+    {
+#if 0
+      printf("::: %d\n", level->block_last_field);
+#endif
+
+      /* even "not blocking" was blocking the last field for one frame */
+      level->block_delay    = (level->block_last_field    ? 7 : 1);
+      level->sp_block_delay = (level->sp_block_last_field ? 7 : 1);
+
+      level->block_last_field = TRUE;
+      level->sp_block_last_field = TRUE;
+    }
+#endif
   }
-  else
+  else		/* always use the latest game engine version */
   {
 #if 0
     printf("\n::: ALWAYS USE LATEST ENGINE FOR THIS LEVEL: [%d] '%s'\n",
@@ -2130,7 +2452,7 @@ static void LoadLevel_InitVersion(struct LevelInfo *level, char *filename)
 
 static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
 {
-  int i, j;
+  int i, j, x, y;
 
   /* map custom element change events that have changed in newer versions
      (these following values were accidentally changed in version 3.0.1) */
@@ -2189,7 +2511,7 @@ static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
     }
   }
 
-  /* correct custom element fields (for old levels without these options) */
+  /* correct custom element values (for old levels without these options) */
   for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
   {
     int element = EL_CUSTOM_START + i;
@@ -2207,6 +2529,39 @@ static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
     }
   }
 
+  /* initialize "can_explode" field for old levels which did not store this */
+  /* !!! CHECK THIS -- "<= 3,1,0,0" IS PROBABLY WRONG !!! */
+  if (level->game_version <= VERSION_IDENT(3,1,0,0))
+  {
+    for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+    {
+      int element = EL_CUSTOM_START + i;
+
+      if (EXPLODES_1X1_OLD(element))
+	element_info[element].explosion_type = EXPLODES_1X1;
+
+      SET_PROPERTY(element, EP_CAN_EXPLODE, (EXPLODES_BY_FIRE(element) ||
+					     EXPLODES_SMASHED(element) ||
+					     EXPLODES_IMPACT(element)));
+    }
+  }
+
+  /* correct previously hard-coded move delay values for maze runner style */
+  if (level->game_version < VERSION_IDENT(3,1,1,0))
+  {
+    for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+    {
+      int element = EL_CUSTOM_START + i;
+
+      if (element_info[element].move_pattern & MV_MAZE_RUNNER_STYLE)
+      {
+	/* previously hard-coded and therefore ignored */
+	element_info[element].move_delay_fixed = 9;
+	element_info[element].move_delay_random = 0;
+      }
+    }
+  }
+
 #if 0
   /* set default push delay values (corrected since version 3.0.7-1) */
   if (level->game_version < VERSION_IDENT(3,0,7,1))
@@ -2232,6 +2587,16 @@ static void LoadLevel_InitElements(struct LevelInfo *level, char *filename)
   }
 #endif
 
+  /* map elements that have changed in newer versions */
+  level->amoeba_content = getMappedElementByVersion(level->amoeba_content,
+						    level->game_version);
+  for (i = 0; i < MAX_ELEMENT_CONTENTS; i++)
+    for (x = 0; x < 3; x++)
+      for (y = 0; y < 3; y++)
+	level->yamyam_content[i][x][y] =
+	  getMappedElementByVersion(level->yamyam_content[i][x][y],
+				    level->game_version);
+
   /* initialize element properties for level editor etc. */
   InitElementPropertiesEngine(level->game_version);
 }
@@ -2247,6 +2612,9 @@ static void LoadLevel_InitPlayfield(struct LevelInfo *level, char *filename)
     {
       int element = level->field[x][y];
 
+#if 1
+      element = getMappedElementByVersion(element, level->game_version);
+#else
       if (level->game_version <= VERSION_IDENT(2,2,0,0))
       {
 	/* map game font elements */
@@ -2265,6 +2633,7 @@ static void LoadLevel_InitPlayfield(struct LevelInfo *level, char *filename)
 		   element == EL_SP_GRAVITY_PORT_DOWN  ? EL_SP_PORT_DOWN  :
 		   element);
       }
+#endif
 
       level->field[x][y] = element;
     }
@@ -2285,6 +2654,16 @@ static void LoadLevel_InitPlayfield(struct LevelInfo *level, char *filename)
 
 void LoadLevelTemplate(int nr)
 {
+#if 1
+  char *filename;
+
+  setLevelFileInfo(&level_template.file_info, nr);
+  filename = level_template.file_info.filename;
+
+  LoadLevelFromFileInfo(&level_template, &level_template.file_info);
+
+#else
+
 #if 1
   struct LevelFileInfo *level_file_info = getLevelFileInfo(nr);
   char *filename = level_file_info->filename;
@@ -2295,15 +2674,31 @@ void LoadLevelTemplate(int nr)
 
   LoadLevelFromFilename_RND(&level_template, filename);
 #endif
+#endif
 
+#if 1
+  LoadLevel_InitVersion(&level_template, filename);
+  LoadLevel_InitElements(&level_template, filename);
+#else
   LoadLevel_InitVersion(&level, filename);
   LoadLevel_InitElements(&level, filename);
+#endif
 
   ActivateLevelTemplate();
 }
 
 void LoadLevel(int nr)
 {
+#if 1
+  char *filename;
+
+  setLevelFileInfo(&level.file_info, nr);
+  filename = level.file_info.filename;
+
+  LoadLevelFromFileInfo(&level, &level.file_info);
+
+#else
+
 #if 1
   struct LevelFileInfo *level_file_info = getLevelFileInfo(nr);
   char *filename = level_file_info->filename;
@@ -2313,6 +2708,7 @@ void LoadLevel(int nr)
   char *filename = getLevelFilename(nr);
 
   LoadLevelFromFilename_RND(&level, filename);
+#endif
 #endif
 
   if (level.use_custom_template)
@@ -2368,12 +2764,17 @@ static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level)
 
   putFile8Bit(file, (level->block_last_field ? 1 : 0));
   putFile8Bit(file, (level->sp_block_last_field ? 1 : 0));
+  putFile32BitBE(file, level->can_move_into_acid_bits);
+  putFile8Bit(file, level->dont_collide_with_bits);
 
   putFile8Bit(file, (level->use_spring_bug ? 1 : 0));
+  putFile8Bit(file, (level->use_step_counter ? 1 : 0));
 
-  putFile16BitBE(file, level->can_move_into_acid_bits);
+  putFile8Bit(file, (level->instant_relocation ? 1 : 0));
+  putFile8Bit(file, (level->can_pass_to_walkable ? 1 : 0));
+  putFile8Bit(file, (level->grow_into_diggable ? 1 : 0));
 
-  putFile8Bit(file, (level->use_step_counter ? 1 : 0));
+  putFile8Bit(file, level->game_engine_type);
 
   WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
 }
@@ -2600,12 +3001,12 @@ static void SaveLevel_CUS3(FILE *file, struct LevelInfo *level,
 	putFile16BitBE(file, element_info[element].change->trigger_element);
 
 	putFile8Bit(file, element_info[element].change->explode);
-	putFile8Bit(file, element_info[element].change->use_content);
-	putFile8Bit(file, element_info[element].change->only_complete);
-	putFile8Bit(file, element_info[element].change->use_random_change);
+	putFile8Bit(file, element_info[element].change->use_target_content);
+	putFile8Bit(file, element_info[element].change->only_if_complete);
+	putFile8Bit(file, element_info[element].change->use_random_replace);
 
-	putFile8Bit(file, element_info[element].change->random);
-	putFile8Bit(file, element_info[element].change->power);
+	putFile8Bit(file, element_info[element].change->random_percentage);
+	putFile8Bit(file, element_info[element].change->replace_when);
 
 	for (y = 0; y < 3; y++)
 	  for (x = 0; x < 3; x++)
@@ -2652,8 +3053,10 @@ static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
   putFile8Bit(file, ei->collect_score);
   putFile8Bit(file, ei->collect_count);
 
-  putFile16BitBE(file, ei->push_delay_fixed);
-  putFile16BitBE(file, ei->push_delay_random);
+  putFile8Bit(file, ei->drop_delay_fixed);
+  putFile8Bit(file, ei->push_delay_fixed);
+  putFile8Bit(file, ei->drop_delay_random);
+  putFile8Bit(file, ei->push_delay_random);
   putFile16BitBE(file, ei->move_delay_fixed);
   putFile16BitBE(file, ei->move_delay_random);
 
@@ -2679,9 +3082,10 @@ static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
 
   putFile8Bit(file, ei->explosion_delay);
   putFile8Bit(file, ei->ignition_delay);
+  putFile8Bit(file, ei->explosion_type);
 
   /* some free bytes for future custom property values and padding */
-  WriteUnusedBytesToFile(file, 2);
+  WriteUnusedBytesToFile(file, 1);
 
   /* write change property values */
 
@@ -2700,16 +3104,16 @@ static void SaveLevel_CUS4(FILE *file, struct LevelInfo *level, int element)
     putFile16BitBE(file, change->trigger_element);
 
     putFile8Bit(file, change->explode);
-    putFile8Bit(file, change->use_content);
-    putFile8Bit(file, change->only_complete);
-    putFile8Bit(file, change->use_random_change);
+    putFile8Bit(file, change->use_target_content);
+    putFile8Bit(file, change->only_if_complete);
+    putFile8Bit(file, change->use_random_replace);
 
-    putFile8Bit(file, change->random);
-    putFile8Bit(file, change->power);
+    putFile8Bit(file, change->random_percentage);
+    putFile8Bit(file, change->replace_when);
 
     for (y = 0; y < 3; y++)
       for (x = 0; x < 3; x++)
-	putFile16BitBE(file, change->content[x][y]);
+	putFile16BitBE(file, change->target_content[x][y]);
 
     putFile8Bit(file, change->can_change);
 
@@ -2888,6 +3292,13 @@ void SaveLevelTemplate()
 
 void DumpLevel(struct LevelInfo *level)
 {
+  if (level->no_valid_file)
+  {
+    Error(ERR_WARN, "cannot dump -- no valid level file found");
+
+    return;
+  }
+
   printf_line("-", 79);
   printf("Level xxx (file version %08d, game version %08d)\n",
 	 level->file_version, level->game_version);
@@ -2946,6 +3357,8 @@ static void setTapeInfoToDefaults()
   tape.recording = FALSE;
   tape.playing = FALSE;
   tape.pausing = FALSE;
+
+  tape.no_valid_file = FALSE;
 }
 
 static int LoadTape_VERS(FILE *file, int chunk_size, struct TapeInfo *tape)
@@ -3110,7 +3523,15 @@ void LoadTapeFromFilename(char *filename)
   setTapeInfoToDefaults();
 
   if (!(file = fopen(filename, MODE_READ)))
+  {
+    tape.no_valid_file = TRUE;
+
+#if 0
+    Error(ERR_WARN, "cannot read tape '%s' -- using empty tape", filename);
+#endif
+
     return;
+  }
 
   getFileChunkBE(file, chunk_name, NULL);
   if (strcmp(chunk_name, "RND1") == 0)
@@ -3120,6 +3541,8 @@ void LoadTapeFromFilename(char *filename)
     getFileChunkBE(file, chunk_name, NULL);
     if (strcmp(chunk_name, "TAPE") != 0)
     {
+      tape.no_valid_file = TRUE;
+
       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
       fclose(file);
       return;
@@ -3134,6 +3557,8 @@ void LoadTapeFromFilename(char *filename)
 
     if (!checkCookieString(cookie, TAPE_COOKIE_TMPL))
     {
+      tape.no_valid_file = TRUE;
+
       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
       fclose(file);
       return;
@@ -3141,6 +3566,8 @@ void LoadTapeFromFilename(char *filename)
 
     if ((tape.file_version = getFileVersionFromCookieString(cookie)) == -1)
     {
+      tape.no_valid_file = TRUE;
+
       Error(ERR_WARN, "unsupported version of tape file '%s'", filename);
       fclose(file);
       return;
@@ -3357,15 +3784,27 @@ void DumpTape(struct TapeInfo *tape)
 {
   int i, j;
 
+#if 1
+  if (tape->no_valid_file)
+  {
+    Error(ERR_WARN, "cannot dump -- no valid tape file found");
+
+    return;
+  }
+#else
   if (TAPE_IS_EMPTY(*tape))
   {
     Error(ERR_WARN, "no tape available for level %d", tape->level_nr);
+
     return;
   }
+#endif
 
   printf_line("-", 79);
   printf("Tape of Level %03d (file version %08d, game version %08d)\n",
 	 tape->level_nr, tape->file_version, tape->game_version);
+  printf("                  (effective engine version %08d)\n",
+	 tape->engine_version);
   printf("Level series identifier: '%s'\n", tape->level_identifier);
   printf_line("-", 79);
 
@@ -4608,3 +5047,117 @@ void LoadHelpTextInfo()
   END_HASH_ITERATION(hash, itr)
 #endif
 }
+
+
+/* ------------------------------------------------------------------------- *
+ * convert levels
+ * ------------------------------------------------------------------------- */
+
+#define MAX_NUM_CONVERT_LEVELS		1000
+
+void ConvertLevels()
+{
+  static LevelDirTree *convert_leveldir = NULL;
+  static int convert_level_nr = -1;
+  static int num_levels_handled = 0;
+  static int num_levels_converted = 0;
+  static boolean levels_failed[MAX_NUM_CONVERT_LEVELS];
+  int i;
+
+  convert_leveldir = getTreeInfoFromIdentifier(leveldir_first,
+					       global.convert_leveldir);
+
+  if (convert_leveldir == NULL)
+    Error(ERR_EXIT, "no such level identifier: '%s'",
+	  global.convert_leveldir);
+
+  leveldir_current = convert_leveldir;
+
+  if (global.convert_level_nr != -1)
+  {
+    convert_leveldir->first_level = global.convert_level_nr;
+    convert_leveldir->last_level  = global.convert_level_nr;
+  }
+
+  convert_level_nr = convert_leveldir->first_level;
+
+  printf_line("=", 79);
+  printf("Converting levels\n");
+  printf_line("-", 79);
+  printf("Level series identifier: '%s'\n", convert_leveldir->identifier);
+  printf("Level series name:       '%s'\n", convert_leveldir->name);
+  printf("Level series author:     '%s'\n", convert_leveldir->author);
+  printf("Number of levels:        %d\n",   convert_leveldir->levels);
+  printf_line("=", 79);
+  printf("\n");
+
+  for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
+    levels_failed[i] = FALSE;
+
+  while (convert_level_nr <= convert_leveldir->last_level)
+  {
+    char *level_filename;
+    boolean new_level;
+
+    level_nr = convert_level_nr++;
+
+    printf("Level %03d: ", level_nr);
+
+    LoadLevel(level_nr);
+    if (level.no_valid_file)
+    {
+      printf("(no level)\n");
+      continue;
+    }
+
+    printf("converting level ... ");
+
+    level_filename = getDefaultLevelFilename(level_nr);
+    new_level = !fileExists(level_filename);
+
+    if (new_level)
+    {
+      SaveLevel(level_nr);
+
+      num_levels_converted++;
+
+      printf("converted.\n");
+    }
+    else
+    {
+      if (level_nr >= 0 && level_nr < MAX_NUM_CONVERT_LEVELS)
+	levels_failed[level_nr] = TRUE;
+
+      printf("NOT CONVERTED -- LEVEL ALREADY EXISTS.\n");
+    }
+
+    num_levels_handled++;
+  }
+
+  printf("\n");
+  printf_line("=", 79);
+  printf("Number of levels handled: %d\n", num_levels_handled);
+  printf("Number of levels converted: %d (%d%%)\n", num_levels_converted,
+	 (num_levels_handled ?
+	  num_levels_converted * 100 / num_levels_handled : 0));
+  printf_line("-", 79);
+  printf("Summary (for automatic parsing by scripts):\n");
+  printf("LEVELDIR '%s', CONVERTED %d/%d (%d%%)",
+	 convert_leveldir->identifier, num_levels_converted,
+	 num_levels_handled,
+	 (num_levels_handled ?
+	  num_levels_converted * 100 / num_levels_handled : 0));
+
+  if (num_levels_handled != num_levels_converted)
+  {
+    printf(", FAILED:");
+    for (i = 0; i < MAX_NUM_CONVERT_LEVELS; i++)
+      if (levels_failed[i])
+	printf(" %03d", i);
+  }
+
+  printf("\n");
+  printf_line("=", 79);
+
+  CloseAllAndExit(0);
+}