+ 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)
+{
+ int i, x, y;
+ char *filename = getLevelFilename(level_nr);
+#if 0
+ boolean encoding_16bit_amoeba = FALSE;
+ boolean encoding_16bit_yamyam = FALSE;
+#endif
+ boolean encoding_16bit = FALSE; /* default: only 8-bit elements */
+ char *oldest_possible_cookie;
+ FILE *file;
+
+ if (!(file = fopen(filename, MODE_WRITE)))
+ {
+ Error(ERR_WARN, "cannot save level file '%s'", filename);
+ return;
+ }
+
+ /* check yam content for 16-bit elements */
+ for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ if (level.yam_content[i][x][y] > 255)
+ encoding_16bit = TRUE;
+
+ /* check level field for 16-bit elements */
+ for(y=0; y<lev_fieldy; y++)
+ for(x=0; x<lev_fieldx; x++)
+ if (Ur[x][y] > 255)
+ encoding_16bit = TRUE;
+
+ oldest_possible_cookie = (encoding_16bit ? LEVEL_COOKIE : LEVEL_COOKIE_12);
+
+ fputs(oldest_possible_cookie, file); /* file identifier */
+ fputc('\n', file);
+
+ putFileChunk(file, "HEAD", LEVEL_HEADER_SIZE, BYTE_ORDER_BIG_ENDIAN);
+
+ fputc(level.fieldx, file);
+ fputc(level.fieldy, file);
+
+ putFile16BitInteger(file, level.time, BYTE_ORDER_BIG_ENDIAN);
+ putFile16BitInteger(file, level.gems_needed, BYTE_ORDER_BIG_ENDIAN);
+
+ for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
+ fputc(level.name[i], file);
+ for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
+ fputc(level.score[i], file);
+ for(i=0; i<STD_ELEMENT_CONTENTS; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ fputc(encoding_16bit ? EL_LEERRAUM : level.yam_content[i][x][y], file);
+ fputc(level.amoeba_speed, file);
+ fputc(level.time_magic_wall, file);
+ fputc(level.time_wheel, file);
+ fputc(level.amoeba_content, file);
+ fputc((level.double_speed ? 1 : 0), file);
+ fputc((level.gravity ? 1 : 0), file);
+
+ fputc((encoding_16bit ? 1 : 0), file);
+
+ for(i=0; i<LEVEL_HEADER_UNUSED; i++) /* set unused header bytes to zero */
+ fputc(0, file);
+
+ putFileChunk(file, "AUTH", MAX_LEVEL_AUTHOR_LEN, BYTE_ORDER_BIG_ENDIAN);
+
+ for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
+ fputc(level.author[i], file);
+
+ putFileChunk(file, "CONT", 4 + MAX_ELEMENT_CONTENTS * 3 * 3,
+ BYTE_ORDER_BIG_ENDIAN);
+
+ fputc(EL_MAMPFER, file);
+ fputc(level.num_yam_contents, file);
+ fputc(0, file);
+ fputc(0, file);
+
+ for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ if (encoding_16bit)
+ putFile16BitInteger(file, level.yam_content[i][x][y],
+ BYTE_ORDER_BIG_ENDIAN);
+ else
+ fputc(level.yam_content[i][x][y], file);
+
+ putFileChunk(file, "BODY", lev_fieldx * lev_fieldy, BYTE_ORDER_BIG_ENDIAN);
+
+ for(y=0; y<lev_fieldy; y++)
+ for(x=0; x<lev_fieldx; x++)
+ if (encoding_16bit)
+ putFile16BitInteger(file, Ur[x][y], BYTE_ORDER_BIG_ENDIAN);
+ else
+ fputc(Ur[x][y], file);
+
+ fclose(file);
+
+ chmod(filename, LEVEL_PERMS);
+}
+
+static void SaveLevel_HEAD(struct LevelInfo *level, FILE *file)
+{
+ int i, x, y;
+
+ fputc(level->fieldx, file);
+ fputc(level->fieldy, file);
+
+ putFile16BitInteger(file, level->time, BYTE_ORDER_BIG_ENDIAN);
+ putFile16BitInteger(file, level->gems_needed, BYTE_ORDER_BIG_ENDIAN);
+
+ for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
+ fputc(level->name[i], file);
+
+ for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
+ fputc(level->score[i], file);
+
+ for(i=0; i<STD_ELEMENT_CONTENTS; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ fputc((level->encoding_16bit_yamyam ? EL_LEERRAUM :
+ level->yam_content[i][x][y]),
+ file);
+ fputc(level->amoeba_speed, file);
+ fputc(level->time_magic_wall, file);
+ fputc(level->time_wheel, file);
+ fputc((level->encoding_16bit_amoeba ? EL_LEERRAUM : level->amoeba_content),
+ file);
+ fputc((level->double_speed ? 1 : 0), file);
+ fputc((level->gravity ? 1 : 0), file);
+
+ fputc((level->encoding_16bit_field ? 1 : 0), file);
+
+ WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
+}
+
+static void SaveLevel_AUTH(struct LevelInfo *level, FILE *file)
+{
+ int i;
+
+ for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
+ fputc(level->author[i], file);
+}
+
+#if 0
+static void SaveLevel_CONT(struct LevelInfo *level, FILE *file)
+{
+ int i, x, y;
+
+ fputc(EL_MAMPFER, file);
+ fputc(level->num_yam_contents, file);
+ fputc(0, file);
+ fputc(0, file);
+
+ for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ if (level->encoding_16bit_field)
+ putFile16BitInteger(file, level->yam_content[i][x][y],
+ BYTE_ORDER_BIG_ENDIAN);
+ else
+ fputc(level->yam_content[i][x][y], file);
+}
+#endif
+
+static void SaveLevel_BODY(struct LevelInfo *level, FILE *file)
+{
+ int x, y;
+
+ for(y=0; y<lev_fieldy; y++)
+ for(x=0; x<lev_fieldx; x++)
+ if (level->encoding_16bit_field)
+ putFile16BitInteger(file, Ur[x][y], BYTE_ORDER_BIG_ENDIAN);
+ else
+ fputc(Ur[x][y], file);
+}
+
+static void SaveLevel_CNT2(struct LevelInfo *level, FILE *file, int element)
+{
+ int i, x, y;
+ int num_contents, content_xsize, content_ysize;
+ int content_array[MAX_ELEMENT_CONTENTS][3][3];
+
+ if (element == EL_MAMPFER)
+ {
+ num_contents = level->num_yam_contents;
+ content_xsize = 3;
+ content_ysize = 3;
+
+ 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] = level->yam_content[i][x][y];
+ }
+ else if (element == EL_AMOEBE_BD)
+ {
+ num_contents = 1;
+ content_xsize = 1;
+ content_ysize = 1;
+
+ 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] = EL_LEERRAUM;
+ content_array[0][0][0] = level->amoeba_content;
+ }
+ else
+ {
+ /* chunk header already written -- write empty chunk data */
+ WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_SIZE);
+
+ Error(ERR_WARN, "cannot save content for element '%d'", element);
+ return;
+ }
+
+ putFile16BitInteger(file, element, BYTE_ORDER_BIG_ENDIAN);
+ fputc(num_contents, file);
+ fputc(content_xsize, file);
+ fputc(content_ysize, file);
+
+ WriteUnusedBytesToFile(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++)
+ putFile16BitInteger(file, content_array[i][x][y],
+ BYTE_ORDER_BIG_ENDIAN);
+}
+
+void SaveLevel(int level_nr)
+{
+ int i, x, y;
+ char *filename = getLevelFilename(level_nr);
+ int body_chunk_size;