1 // ============================================================================
2 // Mirror Magic -- McDuffin's Revenge
3 // ----------------------------------------------------------------------------
4 // (c) 1994-2017 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
12 #include <sys/types.h>
21 #define CHUNK_ID_LEN 4 // IFF style chunk id length
22 #define CHUNK_SIZE_UNDEFINED 0 // undefined chunk size == 0
23 #define CHUNK_SIZE_NONE -1 // do not write chunk size
24 #define FILE_VERS_CHUNK_SIZE 8 // size of file version chunk
25 #define LEVEL_HEADER_SIZE 80 // size of level file header
26 #define LEVEL_HEADER_UNUSED 19 // unused level header bytes
28 // file identifier strings
29 #define LEVEL_COOKIE_TMPL "MIRRORMAGIC_LEVEL_FILE_VERSION_x.x"
30 #define SCORE_COOKIE "MIRRORMAGIC_SCORE_FILE_VERSION_1.4"
33 int default_score[LEVEL_SCORE_ELEMENTS] =
35 [SC_COLLECTIBLE] = 10,
43 // ============================================================================
44 // level file functions
45 // ============================================================================
47 static void ReadChunk_MM_VERS(File *file, int *file_version, int *game_version)
49 int file_version_major, file_version_minor, file_version_patch;
50 int game_version_major, game_version_minor, game_version_patch;
52 file_version_major = getFile8Bit(file);
53 file_version_minor = getFile8Bit(file);
54 file_version_patch = getFile8Bit(file);
55 getFile8Bit(file); // not used
57 game_version_major = getFile8Bit(file);
58 game_version_minor = getFile8Bit(file);
59 game_version_patch = getFile8Bit(file);
60 getFile8Bit(file); // not used
62 *file_version = MM_VERSION_IDENT(file_version_major,
66 *game_version = MM_VERSION_IDENT(game_version_major,
71 static void WriteChunk_MM_VERS(FILE *file, int file_version, int game_version)
73 int file_version_major = MM_VERSION_MAJOR(file_version);
74 int file_version_minor = MM_VERSION_MINOR(file_version);
75 int file_version_patch = MM_VERSION_PATCH(file_version);
76 int game_version_major = MM_VERSION_MAJOR(game_version);
77 int game_version_minor = MM_VERSION_MINOR(game_version);
78 int game_version_patch = MM_VERSION_PATCH(game_version);
80 fputc(file_version_major, file);
81 fputc(file_version_minor, file);
82 fputc(file_version_patch, file);
83 fputc(0, file); // not used
85 fputc(game_version_major, file);
86 fputc(game_version_minor, file);
87 fputc(game_version_patch, file);
88 fputc(0, file); // not used
91 void setLevelInfoToDefaults_MM(void)
95 native_mm_level.file_version = MM_FILE_VERSION_ACTUAL;
96 native_mm_level.game_version = MM_GAME_VERSION_ACTUAL;
98 native_mm_level.encoding_16bit_field = FALSE; // default: only 8-bit elements
100 native_mm_level.fieldx = STD_LEV_FIELDX;
101 native_mm_level.fieldy = STD_LEV_FIELDY;
103 for (x = 0; x < MAX_LEV_FIELDX; x++)
104 for (y = 0; y < MAX_LEV_FIELDY; y++)
105 native_mm_level.field[x][y] = Ur[x][y] = EL_EMPTY;
107 native_mm_level.time = 100;
108 native_mm_level.kettles_needed = 0;
109 native_mm_level.auto_count_kettles = TRUE;
110 native_mm_level.amoeba_speed = 0;
111 native_mm_level.time_fuse = 25;
112 native_mm_level.time_bomb = 75;
113 native_mm_level.time_ball = 75;
114 native_mm_level.time_block = 75;
115 native_mm_level.laser_red = FALSE;
116 native_mm_level.laser_green = FALSE;
117 native_mm_level.laser_blue = TRUE;
119 for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
120 native_mm_level.name[i] = '\0';
121 for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
122 native_mm_level.author[i] = '\0';
124 strcpy(native_mm_level.name, NAMELESS_LEVEL_NAME);
125 strcpy(native_mm_level.author, ANONYMOUS_NAME);
127 for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
128 native_mm_level.score[i] = 10;
133 EL_MIRROR_FIXED_START,
135 EL_POLAR_CROSS_START,
141 int num_ball_contents = sizeof(ball_content) / sizeof(int);
143 native_mm_level.num_ball_contents = num_ball_contents;
144 native_mm_level.ball_choice_mode = ANIM_RANDOM;
146 for (i = 0; i < num_ball_contents; i++)
147 native_mm_level.ball_content[i] = ball_content[i];
149 native_mm_level.field[0][0] = Ur[0][0] = EL_MCDUFFIN_RIGHT;
150 native_mm_level.field[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] =
151 Ur[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] = EL_EXIT_CLOSED;
154 static int checkLevelElement(int element)
156 if (element >= EL_FIRST_RUNTIME_EL)
158 Warn("invalid level element %d", element);
160 element = EL_CHAR_FRAGE;
166 static int LoadLevel_MM_VERS(File *file, int chunk_size,
167 struct LevelInfo_MM *level)
169 ReadChunk_MM_VERS(file, &level->file_version, &level->game_version);
174 static int LoadLevel_MM_HEAD(File *file, int chunk_size,
175 struct LevelInfo_MM *level)
180 level->fieldx = getFile8Bit(file);
181 level->fieldy = getFile8Bit(file);
183 level->time = getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
184 level->kettles_needed = getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
186 // one time unit was equivalent to four seconds in level files up to 2.0.x
187 if (level->file_version <= MM_FILE_VERSION_2_0)
190 for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
191 level->name[i] = getFile8Bit(file);
192 level->name[MAX_LEVEL_NAME_LEN] = 0;
194 for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
195 level->score[i] = getFile8Bit(file);
197 // scores were 0 and hardcoded in game engine in level files up to 2.0.x
198 if (level->file_version <= MM_FILE_VERSION_2_0)
199 for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
200 if (level->score[i] == 0)
201 level->score[i] = default_score[i];
203 level->auto_count_kettles = (getFile8Bit(file) == 1 ? TRUE : FALSE);
204 level->amoeba_speed = getFile8Bit(file);
205 level->time_fuse = getFile8Bit(file);
207 // fuse time was 0 and hardcoded in game engine in level files up to 2.0.x
208 if (level->file_version <= MM_FILE_VERSION_2_0)
209 level->time_fuse = 25;
211 laser_color = getFile8Bit(file);
212 level->laser_red = (laser_color >> 2) & 0x01;
213 level->laser_green = (laser_color >> 1) & 0x01;
214 level->laser_blue = (laser_color >> 0) & 0x01;
216 level->encoding_16bit_field = (getFile8Bit(file) == 1 ? TRUE : FALSE);
218 ReadUnusedBytesFromFile(file, LEVEL_HEADER_UNUSED);
223 static int LoadLevel_MM_AUTH(File *file, int chunk_size,
224 struct LevelInfo_MM *level)
228 for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
229 level->author[i] = getFile8Bit(file);
230 level->author[MAX_LEVEL_NAME_LEN] = 0;
235 static int LoadLevel_MM_BODY(File *file, int chunk_size,
236 struct LevelInfo_MM *level)
239 int chunk_size_expected = level->fieldx * level->fieldy;
241 /* Note: "chunk_size" was wrong before version 2.0 when elements are
242 stored with 16-bit encoding (and should be twice as big then).
243 Even worse, playfield data was stored 16-bit when only yamyam content
244 contained 16-bit elements and vice versa. */
246 if (level->encoding_16bit_field && level->file_version >= MM_FILE_VERSION_2_0)
247 chunk_size_expected *= 2;
249 if (chunk_size_expected != chunk_size)
251 ReadUnusedBytesFromFile(file, chunk_size);
253 return chunk_size_expected;
256 for (y = 0; y < level->fieldy; y++)
257 for (x = 0; x < level->fieldx; x++)
258 native_mm_level.field[x][y] = Ur[x][y] =
259 checkLevelElement(level->encoding_16bit_field ?
260 getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN) :
265 boolean LoadNativeLevel_MM(char *filename, boolean level_info_only)
267 char cookie[MAX_LINE_LEN];
268 char chunk_name[CHUNK_ID_LEN + 1];
276 int (*loader)(File *, int, struct LevelInfo_MM *);
280 { "VERS", FILE_VERS_CHUNK_SIZE, LoadLevel_MM_VERS },
281 { "HEAD", LEVEL_HEADER_SIZE, LoadLevel_MM_HEAD },
282 { "AUTH", MAX_LEVEL_AUTHOR_LEN, LoadLevel_MM_AUTH },
283 { "BODY", -1, LoadLevel_MM_BODY },
287 // always start with reliable default values
288 setLevelInfoToDefaults_MM();
290 if (!(file = openFile(filename, MODE_READ)))
292 if (!level_info_only)
293 Warn("cannot read level '%s' - creating new level", filename);
298 getFileChunk(file, chunk_name, NULL, BYTE_ORDER_BIG_ENDIAN);
299 if (strcmp(chunk_name, "MMII") == 0)
301 getFile32BitInteger(file, BYTE_ORDER_BIG_ENDIAN); // not used
303 getFileChunk(file, chunk_name, NULL, BYTE_ORDER_BIG_ENDIAN);
304 if (strcmp(chunk_name, "CAVE") != 0)
306 Warn("unknown format of level file '%s'", filename);
313 else // check for pre-2.0 file format with cookie string
315 strcpy(cookie, chunk_name);
316 getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4);
317 if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
318 cookie[strlen(cookie) - 1] = '\0';
320 if (!checkCookieString(cookie, LEVEL_COOKIE_TMPL))
322 Warn("unknown format of level file '%s'", filename);
329 if ((native_mm_level.file_version = getFileVersionFromCookieString(cookie))
332 Warn("unsupported version of level file '%s'", filename);
340 while (getFileChunk(file, chunk_name, &chunk_size, BYTE_ORDER_BIG_ENDIAN))
344 while (chunk_info[i].name != NULL &&
345 strcmp(chunk_name, chunk_info[i].name) != 0)
348 if (chunk_info[i].name == NULL)
350 Warn("unknown chunk '%s' in level file '%s'",
351 chunk_name, filename);
353 ReadUnusedBytesFromFile(file, chunk_size);
355 else if (chunk_info[i].size != -1 &&
356 chunk_info[i].size != chunk_size)
358 Warn("wrong size (%d) of chunk '%s' in level file '%s'",
359 chunk_size, chunk_name, filename);
361 ReadUnusedBytesFromFile(file, chunk_size);
365 // call function to load this level chunk
366 int chunk_size_expected =
367 (chunk_info[i].loader)(file, chunk_size, &native_mm_level);
369 // the size of some chunks cannot be checked before reading other
370 // chunks first (like "HEAD" and "BODY") that contain some header
371 // information, so check them here
372 if (chunk_size_expected != chunk_size)
373 Warn("wrong size (%d) of chunk '%s' in level file '%s'",
374 chunk_size, chunk_name, filename);
383 static void SaveLevel_MM_HEAD(FILE *file, struct LevelInfo_MM *level)
388 fputc(level->fieldx, file);
389 fputc(level->fieldy, file);
391 putFile16BitInteger(file, level->time, BYTE_ORDER_BIG_ENDIAN);
392 putFile16BitInteger(file, level->kettles_needed, BYTE_ORDER_BIG_ENDIAN);
394 for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
395 fputc(level->name[i], file);
397 for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
398 fputc(level->score[i], file);
400 fputc((level->auto_count_kettles ? 1 : 0), file);
401 fputc(level->amoeba_speed, file);
402 fputc(level->time_fuse, file);
404 laser_color = ((level->laser_red << 2) |
405 (level->laser_green << 1) |
406 (level->laser_blue << 0));
407 fputc(laser_color, file);
409 fputc((level->encoding_16bit_field ? 1 : 0), file);
411 WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
414 static void SaveLevel_MM_AUTH(FILE *file, struct LevelInfo_MM *level)
418 for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
419 fputc(level->author[i], file);
422 static void SaveLevel_MM_BODY(FILE *file, struct LevelInfo_MM *level)
426 for (y = 0; y < level->fieldy; y++)
427 for (x = 0; x < level->fieldx; x++)
428 if (level->encoding_16bit_field)
429 putFile16BitInteger(file, Ur[x][y], BYTE_ORDER_BIG_ENDIAN);
431 fputc(Ur[x][y], file);
434 void SaveNativeLevel_MM(char *filename)
440 if (!(file = fopen(filename, MODE_WRITE)))
442 Warn("cannot save level file '%s'", filename);
447 // check level field for 16-bit elements
448 native_mm_level.encoding_16bit_field = FALSE;
450 for (y = 0; y < native_mm_level.fieldy; y++)
451 for (x = 0; x < native_mm_level.fieldx; x++)
453 native_mm_level.encoding_16bit_field = TRUE;
456 native_mm_level.fieldx * native_mm_level.fieldy *
457 (native_mm_level.encoding_16bit_field ? 2 : 1);
459 putFileChunk(file, "MMII", CHUNK_SIZE_UNDEFINED, BYTE_ORDER_BIG_ENDIAN);
460 putFileChunk(file, "CAVE", CHUNK_SIZE_NONE, BYTE_ORDER_BIG_ENDIAN);
462 putFileChunk(file, "VERS", FILE_VERS_CHUNK_SIZE, BYTE_ORDER_BIG_ENDIAN);
463 WriteChunk_MM_VERS(file, MM_FILE_VERSION_ACTUAL, MM_GAME_VERSION_ACTUAL);
465 putFileChunk(file, "HEAD", LEVEL_HEADER_SIZE, BYTE_ORDER_BIG_ENDIAN);
466 SaveLevel_MM_HEAD(file, &native_mm_level);
468 putFileChunk(file, "AUTH", MAX_LEVEL_AUTHOR_LEN, BYTE_ORDER_BIG_ENDIAN);
469 SaveLevel_MM_AUTH(file, &native_mm_level);
471 putFileChunk(file, "BODY", body_chunk_size, BYTE_ORDER_BIG_ENDIAN);
472 SaveLevel_MM_BODY(file, &native_mm_level);
476 SetFilePermissions(filename, PERMS_PRIVATE);