changed delays in MM engine from clock delay to deterministic frame delay
[rocksndiamonds.git] / src / game_mm / mm_files.c
1 // ============================================================================
2 // Mirror Magic -- McDuffin's Revenge
3 // ----------------------------------------------------------------------------
4 // (c) 1994-2017 by Artsoft Entertainment
5 //                  Holger Schemel
6 //                  info@artsoft.org
7 //                  http://www.artsoft.org/
8 // ----------------------------------------------------------------------------
9 // mm_files.c
10 // ============================================================================
11
12 #include <sys/types.h>
13 #include <sys/stat.h>
14 #include <ctype.h>
15 #include <dirent.h>
16
17 #include "main_mm.h"
18
19 #include "mm_main.h"
20
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 */
27
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"
31
32
33 /* ========================================================================= */
34 /* level file functions                                                      */
35 /* ========================================================================= */
36
37 static void ReadChunk_MM_VERS(File *file, int *file_version, int *game_version)
38 {
39   int file_version_major, file_version_minor, file_version_patch;
40   int game_version_major, game_version_minor, game_version_patch;
41
42   file_version_major = getFile8Bit(file);
43   file_version_minor = getFile8Bit(file);
44   file_version_patch = getFile8Bit(file);
45   getFile8Bit(file);            /* not used */
46
47   game_version_major = getFile8Bit(file);
48   game_version_minor = getFile8Bit(file);
49   game_version_patch = getFile8Bit(file);
50   getFile8Bit(file);            /* not used */
51
52   *file_version = MM_VERSION_IDENT(file_version_major,
53                                    file_version_minor,
54                                    file_version_patch);
55
56   *game_version = MM_VERSION_IDENT(game_version_major,
57                                    game_version_minor,
58                                    game_version_patch);
59 }
60
61 static void WriteChunk_MM_VERS(FILE *file, int file_version, int game_version)
62 {
63   int file_version_major = MM_VERSION_MAJOR(file_version);
64   int file_version_minor = MM_VERSION_MINOR(file_version);
65   int file_version_patch = MM_VERSION_PATCH(file_version);
66   int game_version_major = MM_VERSION_MAJOR(game_version);
67   int game_version_minor = MM_VERSION_MINOR(game_version);
68   int game_version_patch = MM_VERSION_PATCH(game_version);
69
70   fputc(file_version_major, file);
71   fputc(file_version_minor, file);
72   fputc(file_version_patch, file);
73   fputc(0, file);       /* not used */
74
75   fputc(game_version_major, file);
76   fputc(game_version_minor, file);
77   fputc(game_version_patch, file);
78   fputc(0, file);       /* not used */
79 }
80
81 void setLevelInfoToDefaults_MM()
82 {
83   int i, x, y;
84
85   native_mm_level.file_version = MM_FILE_VERSION_ACTUAL;
86   native_mm_level.game_version = MM_GAME_VERSION_ACTUAL;
87
88   native_mm_level.encoding_16bit_field = FALSE; /* default: only 8-bit elements */
89
90   lev_fieldx = native_mm_level.fieldx = STD_LEV_FIELDX;
91   lev_fieldy = native_mm_level.fieldy = STD_LEV_FIELDY;
92
93   for (x = 0; x < MAX_LEV_FIELDX; x++)
94     for (y = 0; y < MAX_LEV_FIELDY; y++)
95       native_mm_level.field[x][y] = Feld[x][y] = Ur[x][y] = EL_EMPTY;
96
97   native_mm_level.time = 100;
98   native_mm_level.kettles_needed = 0;
99   native_mm_level.auto_count_kettles = TRUE;
100   native_mm_level.amoeba_speed = 0;
101   native_mm_level.time_fuse = 0;
102   native_mm_level.laser_red = FALSE;
103   native_mm_level.laser_green = FALSE;
104   native_mm_level.laser_blue = TRUE;
105
106   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
107     native_mm_level.name[i] = '\0';
108   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
109     native_mm_level.author[i] = '\0';
110
111   strcpy(native_mm_level.name, NAMELESS_LEVEL_NAME);
112   strcpy(native_mm_level.author, ANONYMOUS_NAME);
113
114   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
115     native_mm_level.score[i] = 10;
116
117   native_mm_level.field[0][0] = Feld[0][0] = Ur[0][0] = EL_MCDUFFIN_RIGHT;
118   native_mm_level.field[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] =
119     Feld[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] =
120     Ur[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] = EL_EXIT_CLOSED;
121 }
122
123 static int checkLevelElement(int element)
124 {
125   if (element >= EL_FIRST_RUNTIME_EL)
126   {
127     Error(ERR_WARN, "invalid level element %d", element);
128     element = EL_CHAR_FRAGE;
129   }
130
131   return element;
132 }
133
134 static int LoadLevel_MM_VERS(File *file, int chunk_size,
135                              struct LevelInfo_MM *level)
136 {
137   ReadChunk_MM_VERS(file, &level->file_version, &level->game_version);
138
139   return chunk_size;
140 }
141
142 static int LoadLevel_MM_HEAD(File *file, int chunk_size,
143                              struct LevelInfo_MM *level)
144 {
145   int i;
146   int laser_color;
147
148   lev_fieldx = level->fieldx = getFile8Bit(file);
149   lev_fieldy = level->fieldy = getFile8Bit(file);
150
151   level->time           = getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
152   level->kettles_needed = getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
153
154   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
155     level->name[i] = getFile8Bit(file);
156   level->name[MAX_LEVEL_NAME_LEN] = 0;
157
158   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
159     level->score[i] = getFile8Bit(file);
160
161   level->auto_count_kettles     = (getFile8Bit(file) == 1 ? TRUE : FALSE);
162   level->amoeba_speed           = getFile8Bit(file);
163   level->time_fuse              = getFile8Bit(file);
164
165   laser_color                   = getFile8Bit(file);
166   level->laser_red              = (laser_color >> 2) & 0x01;
167   level->laser_green            = (laser_color >> 1) & 0x01;
168   level->laser_blue             = (laser_color >> 0) & 0x01;
169
170   level->encoding_16bit_field   = (getFile8Bit(file) == 1 ? TRUE : FALSE);
171
172   ReadUnusedBytesFromFile(file, LEVEL_HEADER_UNUSED);
173
174   return chunk_size;
175 }
176
177 static int LoadLevel_MM_AUTH(File *file, int chunk_size,
178                              struct LevelInfo_MM *level)
179 {
180   int i;
181
182   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
183     level->author[i] = getFile8Bit(file);
184   level->author[MAX_LEVEL_NAME_LEN] = 0;
185
186   return chunk_size;
187 }
188
189 static int LoadLevel_MM_BODY(File *file, int chunk_size,
190                              struct LevelInfo_MM *level)
191 {
192   int x, y;
193   int chunk_size_expected = level->fieldx * level->fieldy;
194
195   /* Note: "chunk_size" was wrong before version 2.0 when elements are
196      stored with 16-bit encoding (and should be twice as big then).
197      Even worse, playfield data was stored 16-bit when only yamyam content
198      contained 16-bit elements and vice versa. */
199
200   if (level->encoding_16bit_field && level->file_version >= MM_FILE_VERSION_2_0)
201     chunk_size_expected *= 2;
202
203   if (chunk_size_expected != chunk_size)
204   {
205     ReadUnusedBytesFromFile(file, chunk_size);
206
207     return chunk_size_expected;
208   }
209
210   for (y = 0; y < level->fieldy; y++)
211     for (x = 0; x < level->fieldx; x++)
212       native_mm_level.field[x][y] = Feld[x][y] = Ur[x][y] =
213         checkLevelElement(level->encoding_16bit_field ?
214                           getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN) :
215                           getFile8Bit(file));
216   return chunk_size;
217 }
218
219 boolean LoadNativeLevel_MM(char *filename, boolean level_info_only)
220 {
221   char cookie[MAX_LINE_LEN];
222   char chunk_name[CHUNK_ID_LEN + 1];
223   int chunk_size;
224   File *file;
225
226   static struct
227   {
228     char *name;
229     int size;
230     int (*loader)(File *, int, struct LevelInfo_MM *);
231   }
232   chunk_info[] =
233   {
234     { "VERS", FILE_VERS_CHUNK_SIZE,     LoadLevel_MM_VERS },
235     { "HEAD", LEVEL_HEADER_SIZE,        LoadLevel_MM_HEAD },
236     { "AUTH", MAX_LEVEL_AUTHOR_LEN,     LoadLevel_MM_AUTH },
237     { "BODY", -1,                       LoadLevel_MM_BODY },
238     {  NULL,  0,                        NULL }
239   };
240
241   /* always start with reliable default values */
242   setLevelInfoToDefaults_MM();
243
244   if (!(file = openFile(filename, MODE_READ)))
245   {
246     if (!level_info_only)
247       Error(ERR_WARN, "cannot read level '%s' - creating new level", filename);
248
249     return FALSE;
250   }
251
252   getFileChunk(file, chunk_name, NULL, BYTE_ORDER_BIG_ENDIAN);
253   if (strcmp(chunk_name, "MMII") == 0)
254   {
255     getFile32BitInteger(file, BYTE_ORDER_BIG_ENDIAN);   /* not used */
256
257     getFileChunk(file, chunk_name, NULL, BYTE_ORDER_BIG_ENDIAN);
258     if (strcmp(chunk_name, "CAVE") != 0)
259     {
260       Error(ERR_WARN, "unknown format of level file '%s'", filename);
261
262       closeFile(file);
263
264       return FALSE;
265     }
266   }
267   else  /* check for pre-2.0 file format with cookie string */
268   {
269     strcpy(cookie, chunk_name);
270     getStringFromFile(file, &cookie[4], MAX_LINE_LEN - 4);
271     if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
272       cookie[strlen(cookie) - 1] = '\0';
273
274     if (!checkCookieString(cookie, LEVEL_COOKIE_TMPL))
275     {
276       Error(ERR_WARN, "unknown format of level file '%s'", filename);
277
278       closeFile(file);
279
280       return FALSE;
281     }
282
283     if ((native_mm_level.file_version = getFileVersionFromCookieString(cookie))
284         == -1)
285     {
286       Error(ERR_WARN, "unsupported version of level file '%s'", filename);
287
288       closeFile(file);
289
290       return FALSE;
291     }
292   }
293
294   while (getFileChunk(file, chunk_name, &chunk_size, BYTE_ORDER_BIG_ENDIAN))
295   {
296     int i = 0;
297
298     while (chunk_info[i].name != NULL &&
299            strcmp(chunk_name, chunk_info[i].name) != 0)
300       i++;
301
302     if (chunk_info[i].name == NULL)
303     {
304       Error(ERR_WARN, "unknown chunk '%s' in level file '%s'",
305             chunk_name, filename);
306
307       ReadUnusedBytesFromFile(file, chunk_size);
308     }
309     else if (chunk_info[i].size != -1 &&
310              chunk_info[i].size != chunk_size)
311     {
312       Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
313             chunk_size, chunk_name, filename);
314
315       ReadUnusedBytesFromFile(file, chunk_size);
316     }
317     else
318     {
319       /* call function to load this level chunk */
320       int chunk_size_expected =
321         (chunk_info[i].loader)(file, chunk_size, &native_mm_level);
322
323       /* the size of some chunks cannot be checked before reading other
324          chunks first (like "HEAD" and "BODY") that contain some header
325          information, so check them here */
326       if (chunk_size_expected != chunk_size)
327         Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
328               chunk_size, chunk_name, filename);
329     }
330   }
331
332   closeFile(file);
333
334   return TRUE;
335 }
336
337 static void SaveLevel_MM_HEAD(FILE *file, struct LevelInfo_MM *level)
338 {
339   int i;
340   int laser_color;
341
342   fputc(level->fieldx, file);
343   fputc(level->fieldy, file);
344
345   putFile16BitInteger(file, level->time,           BYTE_ORDER_BIG_ENDIAN);
346   putFile16BitInteger(file, level->kettles_needed, BYTE_ORDER_BIG_ENDIAN);
347
348   for (i = 0; i < MAX_LEVEL_NAME_LEN; i++)
349     fputc(level->name[i], file);
350
351   for (i = 0; i < LEVEL_SCORE_ELEMENTS; i++)
352     fputc(level->score[i], file);
353
354   fputc((level->auto_count_kettles ? 1 : 0), file);
355   fputc(level->amoeba_speed, file);
356   fputc(level->time_fuse, file);
357
358   laser_color = ((level->laser_red   << 2) |
359                  (level->laser_green << 1) |
360                  (level->laser_blue  << 0));
361   fputc(laser_color, file);
362
363   fputc((level->encoding_16bit_field ? 1 : 0), file);
364
365   WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
366 }
367
368 static void SaveLevel_MM_AUTH(FILE *file, struct LevelInfo_MM *level)
369 {
370   int i;
371
372   for (i = 0; i < MAX_LEVEL_AUTHOR_LEN; i++)
373     fputc(level->author[i], file);
374 }
375
376 static void SaveLevel_MM_BODY(FILE *file, struct LevelInfo_MM *level)
377 {
378   int x, y;
379
380   for (y = 0; y < level->fieldy; y++)
381     for (x = 0; x < level->fieldx; x++)
382       if (level->encoding_16bit_field)
383         putFile16BitInteger(file, Ur[x][y], BYTE_ORDER_BIG_ENDIAN);
384       else
385         fputc(Ur[x][y], file);
386 }
387
388 void SaveNativeLevel_MM(char *filename)
389 {
390   int x, y;
391   int body_chunk_size;
392   FILE *file;
393
394   if (!(file = fopen(filename, MODE_WRITE)))
395   {
396     Error(ERR_WARN, "cannot save level file '%s'", filename);
397
398     return;
399   }
400
401   /* check level field for 16-bit elements */
402   native_mm_level.encoding_16bit_field = FALSE;
403
404   for (y = 0; y < native_mm_level.fieldy; y++)
405     for (x = 0; x < native_mm_level.fieldx; x++)
406       if (Ur[x][y] > 255)
407         native_mm_level.encoding_16bit_field = TRUE;
408
409   body_chunk_size =
410     native_mm_level.fieldx * native_mm_level.fieldy *
411     (native_mm_level.encoding_16bit_field ? 2 : 1);
412
413   putFileChunk(file, "MMII", CHUNK_SIZE_UNDEFINED, BYTE_ORDER_BIG_ENDIAN);
414   putFileChunk(file, "CAVE", CHUNK_SIZE_NONE,      BYTE_ORDER_BIG_ENDIAN);
415
416   putFileChunk(file, "VERS", FILE_VERS_CHUNK_SIZE, BYTE_ORDER_BIG_ENDIAN);
417   WriteChunk_MM_VERS(file, MM_FILE_VERSION_ACTUAL, MM_GAME_VERSION_ACTUAL);
418
419   putFileChunk(file, "HEAD", LEVEL_HEADER_SIZE, BYTE_ORDER_BIG_ENDIAN);
420   SaveLevel_MM_HEAD(file, &native_mm_level);
421
422   putFileChunk(file, "AUTH", MAX_LEVEL_AUTHOR_LEN, BYTE_ORDER_BIG_ENDIAN);
423   SaveLevel_MM_AUTH(file, &native_mm_level);
424
425   putFileChunk(file, "BODY", body_chunk_size, BYTE_ORDER_BIG_ENDIAN);
426   SaveLevel_MM_BODY(file, &native_mm_level);
427
428   fclose(file);
429
430   SetFilePermissions(filename, PERMS_PRIVATE);
431 }