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