+
+#define CHUNK_ID_LEN 4 /* IFF style chunk id length */
+#define CHUNK_SIZE_UNDEFINED 0 /* undefined chunk size == 0 */
+#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 13 /* 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_CPART_CUS3_SIZE 102 /* size of CUS3 chunk part */
+#define LEVEL_CPART_CUS3_UNUSED 16 /* unused CUS3 bytes / part */
+#define TAPE_HEADER_SIZE 20 /* size of tape file header */
+#define TAPE_HEADER_UNUSED 3 /* unused tape header bytes */
+
+#define LEVEL_CHUNK_CUS3_SIZE(x) (2 + x * LEVEL_CPART_CUS3_SIZE)
+
+/* file identifier strings */
+#define LEVEL_COOKIE_TMPL "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_x.x"
+#define TAPE_COOKIE_TMPL "ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
+#define SCORE_COOKIE "ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
+
+
+/* ========================================================================= */
+/* level file functions */
+/* ========================================================================= */
+
+static void setLevelInfoToDefaults()
+{
+ int i, j, x, y;
+
+ level.file_version = FILE_VERSION_ACTUAL;
+ level.game_version = GAME_VERSION_ACTUAL;
+
+ level.encoding_16bit_field = FALSE; /* default: only 8-bit elements */
+ level.encoding_16bit_yamyam = FALSE; /* default: only 8-bit elements */
+ level.encoding_16bit_amoeba = FALSE; /* default: only 8-bit elements */
+
+ lev_fieldx = level.fieldx = STD_LEV_FIELDX;
+ lev_fieldy = level.fieldy = STD_LEV_FIELDY;
+
+ for(x=0; x<MAX_LEV_FIELDX; x++)
+ for(y=0; y<MAX_LEV_FIELDY; y++)
+ Feld[x][y] = Ur[x][y] = EL_SAND;
+
+ level.time = 100;
+ level.gems_needed = 0;
+ level.amoeba_speed = 10;
+ level.time_magic_wall = 10;
+ level.time_wheel = 10;
+ level.time_light = 10;
+ level.time_timegate = 10;
+ level.amoeba_content = EL_DIAMOND;
+ level.double_speed = FALSE;
+ level.gravity = FALSE;
+ level.em_slippery_gems = FALSE;
+
+ level.use_custom_template = FALSE;
+
+ for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
+ level.name[i] = '\0';
+ for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
+ level.author[i] = '\0';
+
+ strcpy(level.name, NAMELESS_LEVEL_NAME);
+ strcpy(level.author, ANONYMOUS_NAME);
+
+ for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
+ level.score[i] = 10;
+
+ level.num_yamyam_contents = STD_ELEMENT_CONTENTS;
+ 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] =
+ (i < STD_ELEMENT_CONTENTS ? EL_ROCK : EL_EMPTY);
+
+ Feld[0][0] = Ur[0][0] = EL_PLAYER_1;
+ Feld[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] =
+ Ur[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] = EL_EXIT_CLOSED;
+
+ for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+ {
+ int element = EL_CUSTOM_START + i;
+
+ element_info[element].use_gfx_element = FALSE;
+ element_info[element].gfx_element = EL_EMPTY_SPACE;
+
+ element_info[element].score = 0;
+ element_info[element].gem_count = 0;
+
+ element_info[element].push_delay_fixed = 2; /* special default */
+ element_info[element].push_delay_random = 8; /* special default */
+ 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_NO_MOVING;
+ element_info[element].move_stepsize = TILEX / 8;
+
+ for(x=0; x<3; x++)
+ for(y=0; y<3; y++)
+ element_info[element].content[x][y] = EL_EMPTY_SPACE;
+
+ element_info[element].change.events = CE_BITMASK_DEFAULT;
+ element_info[element].change.target_element = EL_EMPTY_SPACE;
+
+ element_info[element].change.delay_fixed = 0;
+ element_info[element].change.delay_random = 0;
+ element_info[element].change.delay_frames = -1; /* use default */
+
+ element_info[element].change.trigger_element = EL_EMPTY_SPACE;
+
+ element_info[element].change.explode = FALSE;
+ element_info[element].change.use_content = FALSE;
+ element_info[element].change.only_complete = FALSE;
+ element_info[element].change.use_random_change = FALSE;
+ element_info[element].change.random = 0;
+ element_info[element].change.power = CP_NON_DESTRUCTIVE;
+
+ for(x=0; x<3; x++)
+ for(y=0; y<3; y++)
+ element_info[element].change.content[x][y] = EL_EMPTY_SPACE;
+
+ /* start with no properties at all */
+ for (j=0; j < NUM_EP_BITFIELDS; j++)
+ Properties[element][j] = EP_BITMASK_DEFAULT;
+ }
+
+ BorderElement = EL_STEELWALL;
+
+ level.no_level_file = FALSE;
+
+ if (leveldir_current == NULL) /* only when dumping level */
+ return;
+
+ /* try to determine better author name than 'anonymous' */
+ if (strcmp(leveldir_current->author, ANONYMOUS_NAME) != 0)
+ {
+ strncpy(level.author, leveldir_current->author, MAX_LEVEL_AUTHOR_LEN);
+ level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
+ }
+ else
+ {
+ switch (LEVELCLASS(leveldir_current))
+ {
+ case LEVELCLASS_TUTORIAL:
+ strcpy(level.author, PROGRAM_AUTHOR_STRING);
+ break;
+
+ case LEVELCLASS_CONTRIBUTION:
+ strncpy(level.author, leveldir_current->name,MAX_LEVEL_AUTHOR_LEN);
+ level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
+ break;
+
+ case LEVELCLASS_USER:
+ strncpy(level.author, getRealName(), MAX_LEVEL_AUTHOR_LEN);
+ level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
+ break;
+
+ default:
+ /* keep default value */
+ break;
+ }
+ }
+}
+
+static int checkLevelElement(int element)
+{
+ if (element >= NUM_FILE_ELEMENTS)
+ {
+ Error(ERR_WARN, "invalid level element %d", element);
+ element = EL_CHAR_QUESTION;
+ }
+ else if (element == EL_PLAYER_OBSOLETE)
+ element = EL_PLAYER_1;
+ else if (element == EL_KEY_OBSOLETE)
+ element = EL_KEY_1;
+
+ return element;
+}
+
+static int LoadLevel_VERS(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ level->file_version = getFileVersion(file);
+ level->game_version = getFileVersion(file);
+
+ return chunk_size;
+}
+
+static int LoadLevel_HEAD(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ int i, x, y;
+
+ lev_fieldx = level->fieldx = fgetc(file);
+ lev_fieldy = level->fieldy = fgetc(file);
+
+ level->time = getFile16BitBE(file);
+ level->gems_needed = getFile16BitBE(file);
+
+ 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_yamyam_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->yamyam_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);
+ level->em_slippery_gems = (fgetc(file) == 1 ? TRUE : FALSE);
+
+ level->use_custom_template = (fgetc(file) == 1 ? TRUE : FALSE);
+
+ ReadUnusedBytesFromFile(file, LEVEL_HEADER_UNUSED);
+
+ return chunk_size;
+}
+
+static int LoadLevel_AUTH(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ 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_BODY(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ 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 ?
+ getFile16BitBE(file) : fgetc(file));
+ return chunk_size;
+}
+
+static int LoadLevel_CONT(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ 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_yamyam_contents = fgetc(file);
+ fgetc(file);
+ fgetc(file);
+
+ /* correct invalid number of content fields -- should never happen */
+ if (level->num_yamyam_contents < 1 ||
+ level->num_yamyam_contents > MAX_ELEMENT_CONTENTS)
+ level->num_yamyam_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->yamyam_content[i][x][y] =
+ checkLevelElement(level->encoding_16bit_field ?
+ getFile16BitBE(file) : fgetc(file));
+ return chunk_size;
+}
+
+static int LoadLevel_CNT2(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ int i, x, y;
+ int element;
+ int num_contents, content_xsize, content_ysize;
+ int content_array[MAX_ELEMENT_CONTENTS][3][3];
+
+ element = checkLevelElement(getFile16BitBE(file));
+ 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(getFile16BitBE(file));
+
+ /* 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_YAMYAM)
+ {
+ level->num_yamyam_contents = num_contents;
+
+ for(i=0; i<num_contents; i++)
+ for(y=0; y<3; y++)
+ for(x=0; x<3; x++)
+ level->yamyam_content[i][x][y] = content_array[i][x][y];
+ }
+ else if (element == EL_BD_AMOEBA)
+ {
+ level->amoeba_content = content_array[0][0][0];
+ }
+ else
+ {
+ Error(ERR_WARN, "cannot load content for element '%d'", element);
+ }
+
+ return chunk_size;
+}
+
+static int LoadLevel_CUS1(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ int num_changed_custom_elements = getFile16BitBE(file);
+ int chunk_size_expected = 2 + num_changed_custom_elements * 6;
+ int i;
+
+ if (chunk_size_expected != chunk_size)
+ {
+ ReadUnusedBytesFromFile(file, chunk_size - 2);
+ return chunk_size_expected;
+ }
+
+ for (i=0; i < num_changed_custom_elements; i++)
+ {
+ int element = getFile16BitBE(file);
+ int properties = getFile32BitBE(file);
+
+ if (IS_CUSTOM_ELEMENT(element))
+ Properties[element][EP_BITFIELD_BASE] = properties;
+ else
+ Error(ERR_WARN, "invalid custom element number %d", element);
+ }
+
+ return chunk_size;
+}
+
+static int LoadLevel_CUS2(FILE *file, int chunk_size, struct LevelInfo *level)
+{
+ int num_changed_custom_elements = getFile16BitBE(file);
+ int chunk_size_expected = 2 + num_changed_custom_elements * 4;
+ int i;
+
+ if (chunk_size_expected != chunk_size)
+ {
+ ReadUnusedBytesFromFile(file, chunk_size - 2);
+ return chunk_size_expected;
+ }
+
+ for (i=0; i < num_changed_custom_elements; i++)
+ {
+ int element = getFile16BitBE(file);
+ int custom_target_element = getFile16BitBE(file);
+
+ if (IS_CUSTOM_ELEMENT(element))
+ element_info[element].change.target_element = custom_target_element;
+ else
+ Error(ERR_WARN, "invalid custom element number %d", element);
+ }
+
+ return chunk_size;
+}
+
+static int LoadLevel_CUS3(FILE *file, int chunk_size, struct LevelInfo *level)