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 }