+static void ReadUnusedBytesFromFile(FILE *file, unsigned long bytes)
+{
+ while (bytes--)
+ fgetc(file);
+}
+
+static void WriteUnusedBytesToFile(FILE *file, unsigned long bytes)
+{
+ while (bytes--)
+ fputc(0, file);
+}
+
+static int LoadLevel_HEAD(struct LevelInfo *level, FILE *file, int chunk_size)
+{
+ int i, x, y;
+
+ lev_fieldx = level->fieldx = fgetc(file);
+ lev_fieldy = level->fieldy = fgetc(file);
+
+ level->time = getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
+ level->gems_needed = getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
+
+ for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
+ level->name[i] = fgetc(file);
+ level->name[MAX_LEVEL_NAME_LEN] = 0;
+
+ for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
+ level->score[i] = fgetc(file);
+
+ level->num_yam_contents = STD_ELEMENT_CONTENTS;
+ for(i=0; i<STD_ELEMENT_CONTENTS; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ level->yam_content[i][x][y] = checkLevelElement(fgetc(file));
+
+ level->amoeba_speed = fgetc(file);
+ level->time_magic_wall = fgetc(file);
+ level->time_wheel = fgetc(file);
+ level->amoeba_content = checkLevelElement(fgetc(file));
+ level->double_speed = (fgetc(file) == 1 ? TRUE : FALSE);
+ level->gravity = (fgetc(file) == 1 ? TRUE : FALSE);
+
+ level->encoding_16bit_field = (fgetc(file) == 1 ? TRUE : FALSE);
+
+ ReadUnusedBytesFromFile(file, LEVEL_HEADER_UNUSED);
+
+ return chunk_size;
+}
+
+static int LoadLevel_AUTH(struct LevelInfo *level, FILE *file, int chunk_size)
+{
+ int i;
+
+ for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
+ level->author[i] = fgetc(file);
+ level->author[MAX_LEVEL_NAME_LEN] = 0;
+
+ return chunk_size;
+}
+
+static int LoadLevel_CONT(struct LevelInfo *level, FILE *file, int chunk_size)
+{
+ int i, x, y;
+ int header_size = 4;
+ int content_size = MAX_ELEMENT_CONTENTS * 3 * 3;
+ int chunk_size_expected = header_size + content_size;
+
+ /* Note: "chunk_size" was wrong before version 2.0 when elements are
+ stored with 16-bit encoding (and should be twice as big then).
+ Even worse, playfield data was stored 16-bit when only yamyam content
+ contained 16-bit elements and vice versa. */
+
+ if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
+ chunk_size_expected += content_size;
+
+ if (chunk_size_expected != chunk_size)
+ {
+ ReadUnusedBytesFromFile(file, chunk_size);
+ return chunk_size_expected;
+ }
+
+ fgetc(file);
+ level->num_yam_contents = fgetc(file);
+ fgetc(file);
+ fgetc(file);
+
+ /* correct invalid number of content fields -- should never happen */
+ if (level->num_yam_contents < 1 ||
+ level->num_yam_contents > MAX_ELEMENT_CONTENTS)
+ level->num_yam_contents = STD_ELEMENT_CONTENTS;
+
+ for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ level->yam_content[i][x][y] =
+ checkLevelElement(level->encoding_16bit_field ?
+ getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN) :
+ fgetc(file));
+ return chunk_size;
+}
+
+static int LoadLevel_BODY(struct LevelInfo *level, FILE *file, int chunk_size)
+{
+ int x, y;
+ int chunk_size_expected = level->fieldx * level->fieldy;
+
+ /* Note: "chunk_size" was wrong before version 2.0 when elements are
+ stored with 16-bit encoding (and should be twice as big then).
+ Even worse, playfield data was stored 16-bit when only yamyam content
+ contained 16-bit elements and vice versa. */
+
+ if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
+ chunk_size_expected *= 2;
+
+ if (chunk_size_expected != chunk_size)
+ {
+ ReadUnusedBytesFromFile(file, chunk_size);
+ return chunk_size_expected;
+ }
+
+ for(y=0; y<level->fieldy; y++)
+ for(x=0; x<level->fieldx; x++)
+ Feld[x][y] = Ur[x][y] =
+ checkLevelElement(level->encoding_16bit_field ?
+ getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN) :
+ fgetc(file));
+ return chunk_size;
+}
+
+static int LoadLevel_CNT2(struct LevelInfo *level, FILE *file, int chunk_size)
+{
+ int i, x, y;
+ int element;
+ int num_contents, content_xsize, content_ysize;
+ int content_array[MAX_ELEMENT_CONTENTS][3][3];
+
+ element = checkLevelElement(getFile16BitInteger(file,BYTE_ORDER_BIG_ENDIAN));
+ num_contents = fgetc(file);
+ content_xsize = fgetc(file);
+ content_ysize = fgetc(file);
+ ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT2_UNUSED);
+
+ for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ content_array[i][x][y] =
+ checkLevelElement(getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN));
+
+ /* correct invalid number of content fields -- should never happen */
+ if (num_contents < 1 || num_contents > MAX_ELEMENT_CONTENTS)
+ num_contents = STD_ELEMENT_CONTENTS;
+
+ if (element == EL_MAMPFER)
+ {
+ level->num_yam_contents = num_contents;
+
+ for(i=0; i<num_contents; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ level->yam_content[i][x][y] = content_array[i][x][y];
+ }
+ else if (element == EL_AMOEBE_BD)
+ {
+ level->amoeba_content = content_array[0][0][0];
+ }
+ else
+ {
+ Error(ERR_WARN, "cannot load content for element '%d'", element);
+ }
+
+ return chunk_size;
+}
+
+void LoadLevel(int level_nr)
+{
+ char *filename = getLevelFilename(level_nr);
+ char cookie[MAX_LINE_LEN];
+ char chunk_name[CHUNK_ID_LEN + 1];
+ int chunk_size;
+ FILE *file;
+
+ /* always start with reliable default values */
+ setLevelInfoToDefaults();
+
+ if (!(file = fopen(filename, MODE_READ)))
+ {
+ Error(ERR_WARN, "cannot read level '%s' - creating new level", filename);
+ return;
+ }
+
+ /* check file identifier */
+ fgets(cookie, MAX_LINE_LEN, file);
+ if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
+ cookie[strlen(cookie) - 1] = '\0';
+
+ if (!checkCookieString(cookie, LEVEL_COOKIE)) /* unknown file format */
+ {
+ Error(ERR_WARN, "unknown format of level file '%s'", filename);
+ fclose(file);
+ return;
+ }
+
+ if ((level.file_version = getFileVersionFromCookieString(cookie)) == -1)
+ {
+ Error(ERR_WARN, "unsupported version of level file '%s'", filename);
+ fclose(file);
+ return;
+ }
+
+ if (level.file_version < FILE_VERSION_1_2)
+ {
+ /* level files from versions before 1.2.0 without chunk structure */
+ LoadLevel_HEAD(&level, file, LEVEL_HEADER_SIZE);
+ LoadLevel_BODY(&level, file, level.fieldx * level.fieldy);
+ }
+ else
+ {
+ static struct
+ {
+ char *name;
+ int size;
+ int (*loader)(struct LevelInfo *, FILE *, int);
+ }
+ chunk_info[] =
+ {
+ { "HEAD", LEVEL_HEADER_SIZE, LoadLevel_HEAD },
+ { "AUTH", MAX_LEVEL_AUTHOR_LEN, LoadLevel_AUTH },
+ { "CONT", -1, LoadLevel_CONT },
+ { "BODY", -1, LoadLevel_BODY },
+ { "CNT2", LEVEL_CHUNK_CNT2_SIZE, LoadLevel_CNT2 },
+ { NULL, 0, NULL }
+ };
+
+ while (getFileChunk(file, chunk_name, &chunk_size, BYTE_ORDER_BIG_ENDIAN))
+ {
+ int i = 0;
+
+ while (chunk_info[i].name != NULL &&
+ strcmp(chunk_name, chunk_info[i].name) != 0)
+ i++;
+
+ if (chunk_info[i].name == NULL)
+ {
+ Error(ERR_WARN, "unknown chunk '%s' in level file '%s'",
+ chunk_name, filename);
+ ReadUnusedBytesFromFile(file, chunk_size);
+ }
+ else if (chunk_info[i].size != -1 &&
+ chunk_info[i].size != chunk_size)
+ {
+ Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
+ chunk_size, chunk_name, filename);
+ ReadUnusedBytesFromFile(file, chunk_size);
+ }
+ else
+ {
+ /* call function to load this level chunk */
+ int chunk_size_expected =
+ (chunk_info[i].loader)(&level, file, chunk_size);
+
+ /* the size of some chunks cannot be checked before reading other
+ chunks first (like "HEAD" and "BODY") that contain some header
+ information, so check them here */
+ if (chunk_size_expected != chunk_size)
+ {
+ Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
+ chunk_size, chunk_name, filename);
+ }
+ }
+ }
+ }
+
+ fclose(file);
+
+ if (IS_LEVELCLASS_CONTRIBUTION(leveldir_current) ||
+ IS_LEVELCLASS_USER(leveldir_current))
+ {
+ /* for user contributed and private levels, use the version of
+ the game engine the levels were created for */
+ level.game_version = level.file_version;
+
+ /* player was faster than monsters in pre-1.0 levels */
+ if (level.file_version == FILE_VERSION_1_0)
+ {
+ Error(ERR_WARN, "level file '%s' has version number 1.0", filename);
+ Error(ERR_WARN, "using high speed movement for player");
+ level.double_speed = TRUE;
+ }
+ }
+ else
+ {
+ /* always use the latest version of the game engine for all but
+ user contributed and private levels */
+ level.game_version = GAME_VERSION_ACTUAL;
+ }
+
+ /* determine border element for this level */
+ SetBorderElement();
+}
+
+void OLD_SaveLevel(int level_nr)