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