src/files.c

   1 /***********************************************************
   2 * Rocks'n'Diamonds -- McDuffin Strikes Back!               *
   3 *----------------------------------------------------------*
   4 * (c) 1995-2001 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * files.c                                                  *
  12 ***********************************************************/
  13
  14 #include <ctype.h>
  15 #include <sys/stat.h>
  16
  17 #include "libgame/libgame.h"
  18
  19 #include "files.h"
  20 #include "tools.h"
  21 #include "tape.h"
  22
  23
  24 #define CHUNK_ID_LEN            4       /* IFF style chunk id length  */
  25 #define CHUNK_SIZE_UNDEFINED    0       /* undefined chunk size == 0  */
  26 #define CHUNK_SIZE_NONE         -1      /* do not write chunk size    */
  27 #define FILE_VERS_CHUNK_SIZE    8       /* size of file version chunk */
  28 #define LEVEL_HEADER_SIZE       80      /* size of level file header  */
  29 #define LEVEL_HEADER_UNUSED     14      /* unused level header bytes  */
  30 #define LEVEL_CHUNK_CNT2_SIZE   160     /* size of level CNT2 chunk   */
  31 #define LEVEL_CHUNK_CNT2_UNUSED 11      /* unused CNT2 chunk bytes    */
  32 #define TAPE_HEADER_SIZE        20      /* size of tape file header   */
  33 #define TAPE_HEADER_UNUSED      7       /* unused tape header bytes   */
  34
  35 /* file identifier strings */
  36 #define LEVEL_COOKIE_TMPL       "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_x.x"
  37 #define TAPE_COOKIE_TMPL        "ROCKSNDIAMONDS_TAPE_FILE_VERSION_x.x"
  38 #define SCORE_COOKIE            "ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
  39
  40
  41 /* ========================================================================= */
  42 /* level file functions                                                      */
  43 /* ========================================================================= */
  44
  45 static void setLevelInfoToDefaults()
  46 {
  47   int i, x, y;
  48
  49   level.file_version = FILE_VERSION_ACTUAL;
  50   level.game_version = GAME_VERSION_ACTUAL;
  51
  52   level.encoding_16bit_field = FALSE;   /* default: only 8-bit elements */
  53   level.encoding_16bit_yamyam = FALSE;  /* default: only 8-bit elements */
  54   level.encoding_16bit_amoeba = FALSE;  /* default: only 8-bit elements */
  55
  56   lev_fieldx = level.fieldx = STD_LEV_FIELDX;
  57   lev_fieldy = level.fieldy = STD_LEV_FIELDY;
  58
  59   for(x=0; x<MAX_LEV_FIELDX; x++)
  60     for(y=0; y<MAX_LEV_FIELDY; y++)
  61       Feld[x][y] = Ur[x][y] = EL_ERDREICH;
  62
  63   level.time = 100;
  64   level.gems_needed = 0;
  65   level.amoeba_speed = 10;
  66   level.time_magic_wall = 10;
  67   level.time_wheel = 10;
  68   level.time_light = 10;
  69   level.time_timegate = 10;
  70   level.amoeba_content = EL_DIAMANT;
  71   level.double_speed = FALSE;
  72   level.gravity = FALSE;
  73   level.em_slippery_gems = FALSE;
  74
  75   for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
  76     level.name[i] = '\0';
  77   for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
  78     level.author[i] = '\0';
  79
  80   strcpy(level.name, NAMELESS_LEVEL_NAME);
  81   strcpy(level.author, ANONYMOUS_NAME);
  82
  83   for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
  84     level.score[i] = 10;
  85
  86   level.num_yam_contents = STD_ELEMENT_CONTENTS;
  87   for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
  88     for(x=0; x<3; x++)
  89       for(y=0; y<3; y++)
  90         level.yam_content[i][x][y] =
  91           (i < STD_ELEMENT_CONTENTS ? EL_FELSBROCKEN : EL_LEERRAUM);
  92
  93   Feld[0][0] = Ur[0][0] = EL_SPIELFIGUR;
  94   Feld[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] =
  95     Ur[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] = EL_AUSGANG_ZU;
  96
  97   BorderElement = EL_BETON;
  98
  99   /* try to determine better author name than 'anonymous' */
 100   if (strcmp(leveldir_current->author, ANONYMOUS_NAME) != 0)
 101   {
 102     strncpy(level.author, leveldir_current->author, MAX_LEVEL_AUTHOR_LEN);
 103     level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 104   }
 105   else
 106   {
 107     switch (LEVELCLASS(leveldir_current))
 108     {
 109       case LEVELCLASS_TUTORIAL:
 110         strcpy(level.author, PROGRAM_AUTHOR_STRING);
 111         break;
 112
 113       case LEVELCLASS_CONTRIBUTION:
 114         strncpy(level.author, leveldir_current->name,MAX_LEVEL_AUTHOR_LEN);
 115         level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 116         break;
 117
 118       case LEVELCLASS_USER:
 119         strncpy(level.author, getRealName(), MAX_LEVEL_AUTHOR_LEN);
 120         level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 121         break;
 122
 123       default:
 124         /* keep default value */
 125         break;
 126     }
 127   }
 128 }
 129
 130 static int checkLevelElement(int element)
 131 {
 132   if (element >= EL_FIRST_RUNTIME_EL)
 133   {
 134     Error(ERR_WARN, "invalid level element %d", element);
 135     element = EL_CHAR_FRAGE;
 136   }
 137
 138   return element;
 139 }
 140
 141 static int LoadLevel_VERS(FILE *file, int chunk_size, struct LevelInfo *level)
 142 {
 143   ReadChunk_VERS(file, &(level->file_version), &(level->game_version));
 144
 145   return chunk_size;
 146 }
 147
 148 static int LoadLevel_HEAD(FILE *file, int chunk_size, struct LevelInfo *level)
 149 {
 150   int i, x, y;
 151
 152   lev_fieldx = level->fieldx = fgetc(file);
 153   lev_fieldy = level->fieldy = fgetc(file);
 154
 155   level->time           = getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
 156   level->gems_needed    = getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
 157
 158   for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
 159     level->name[i] = fgetc(file);
 160   level->name[MAX_LEVEL_NAME_LEN] = 0;
 161
 162   for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
 163     level->score[i] = fgetc(file);
 164
 165   level->num_yam_contents = STD_ELEMENT_CONTENTS;
 166   for(i=0; i<STD_ELEMENT_CONTENTS; i++)
 167     for(y=0; y<3; y++)
 168       for(x=0; x<3; x++)
 169         level->yam_content[i][x][y] = checkLevelElement(fgetc(file));
 170
 171   level->amoeba_speed           = fgetc(file);
 172   level->time_magic_wall        = fgetc(file);
 173   level->time_wheel             = fgetc(file);
 174   level->amoeba_content         = checkLevelElement(fgetc(file));
 175   level->double_speed           = (fgetc(file) == 1 ? TRUE : FALSE);
 176   level->gravity                = (fgetc(file) == 1 ? TRUE : FALSE);
 177   level->encoding_16bit_field   = (fgetc(file) == 1 ? TRUE : FALSE);
 178   level->em_slippery_gems       = (fgetc(file) == 1 ? TRUE : FALSE);
 179
 180   ReadUnusedBytesFromFile(file, LEVEL_HEADER_UNUSED);
 181
 182   return chunk_size;
 183 }
 184
 185 static int LoadLevel_AUTH(FILE *file, int chunk_size, struct LevelInfo *level)
 186 {
 187   int i;
 188
 189   for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
 190     level->author[i] = fgetc(file);
 191   level->author[MAX_LEVEL_NAME_LEN] = 0;
 192
 193   return chunk_size;
 194 }
 195
 196 static int LoadLevel_CONT(FILE *file, int chunk_size, struct LevelInfo *level)
 197 {
 198   int i, x, y;
 199   int header_size = 4;
 200   int content_size = MAX_ELEMENT_CONTENTS * 3 * 3;
 201   int chunk_size_expected = header_size + content_size;
 202
 203   /* Note: "chunk_size" was wrong before version 2.0 when elements are
 204      stored with 16-bit encoding (and should be twice as big then).
 205      Even worse, playfield data was stored 16-bit when only yamyam content
 206      contained 16-bit elements and vice versa. */
 207
 208   if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
 209     chunk_size_expected += content_size;
 210
 211   if (chunk_size_expected != chunk_size)
 212   {
 213     ReadUnusedBytesFromFile(file, chunk_size);
 214     return chunk_size_expected;
 215   }
 216
 217   fgetc(file);
 218   level->num_yam_contents = fgetc(file);
 219   fgetc(file);
 220   fgetc(file);
 221
 222   /* correct invalid number of content fields -- should never happen */
 223   if (level->num_yam_contents < 1 ||
 224       level->num_yam_contents > MAX_ELEMENT_CONTENTS)
 225     level->num_yam_contents = STD_ELEMENT_CONTENTS;
 226
 227   for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
 228     for(y=0; y<3; y++)
 229       for(x=0; x<3; x++)
 230         level->yam_content[i][x][y] =
 231           checkLevelElement(level->encoding_16bit_field ?
 232                             getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN) :
 233                             fgetc(file));
 234   return chunk_size;
 235 }
 236
 237 static int LoadLevel_BODY(FILE *file, int chunk_size, struct LevelInfo *level)
 238 {
 239   int x, y;
 240   int chunk_size_expected = level->fieldx * level->fieldy;
 241
 242   /* Note: "chunk_size" was wrong before version 2.0 when elements are
 243      stored with 16-bit encoding (and should be twice as big then).
 244      Even worse, playfield data was stored 16-bit when only yamyam content
 245      contained 16-bit elements and vice versa. */
 246
 247   if (level->encoding_16bit_field && level->file_version >= FILE_VERSION_2_0)
 248     chunk_size_expected *= 2;
 249
 250   if (chunk_size_expected != chunk_size)
 251   {
 252     ReadUnusedBytesFromFile(file, chunk_size);
 253     return chunk_size_expected;
 254   }
 255
 256   for(y=0; y<level->fieldy; y++)
 257     for(x=0; x<level->fieldx; x++)
 258       Feld[x][y] = Ur[x][y] =
 259         checkLevelElement(level->encoding_16bit_field ?
 260                           getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN) :
 261                           fgetc(file));
 262   return chunk_size;
 263 }
 264
 265 static int LoadLevel_CNT2(FILE *file, int chunk_size, struct LevelInfo *level)
 266 {
 267   int i, x, y;
 268   int element;
 269   int num_contents, content_xsize, content_ysize;
 270   int content_array[MAX_ELEMENT_CONTENTS][3][3];
 271
 272   element = checkLevelElement(getFile16BitInteger(file,BYTE_ORDER_BIG_ENDIAN));
 273   num_contents = fgetc(file);
 274   content_xsize = fgetc(file);
 275   content_ysize = fgetc(file);
 276   ReadUnusedBytesFromFile(file, LEVEL_CHUNK_CNT2_UNUSED);
 277
 278   for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
 279     for(y=0; y<3; y++)
 280       for(x=0; x<3; x++)
 281         content_array[i][x][y] =
 282           checkLevelElement(getFile16BitInteger(file, BYTE_ORDER_BIG_ENDIAN));
 283
 284   /* correct invalid number of content fields -- should never happen */
 285   if (num_contents < 1 || num_contents > MAX_ELEMENT_CONTENTS)
 286     num_contents = STD_ELEMENT_CONTENTS;
 287
 288   if (element == EL_MAMPFER)
 289   {
 290     level->num_yam_contents = num_contents;
 291
 292     for(i=0; i<num_contents; i++)
 293       for(y=0; y<3; y++)
 294         for(x=0; x<3; x++)
 295           level->yam_content[i][x][y] = content_array[i][x][y];
 296   }
 297   else if (element == EL_AMOEBE_BD)
 298   {
 299     level->amoeba_content = content_array[0][0][0];
 300   }
 301   else
 302   {
 303     Error(ERR_WARN, "cannot load content for element '%d'", element);
 304   }
 305
 306   return chunk_size;
 307 }
 308
 309 void LoadLevel(int level_nr)
 310 {
 311   char *filename = getLevelFilename(level_nr);
 312   char cookie[MAX_LINE_LEN];
 313   char chunk_name[CHUNK_ID_LEN + 1];
 314   int chunk_size;
 315   FILE *file;
 316
 317   /* always start with reliable default values */
 318   setLevelInfoToDefaults();
 319
 320   if (!(file = fopen(filename, MODE_READ)))
 321   {
 322     Error(ERR_WARN, "cannot read level '%s' - creating new level", filename);
 323     return;
 324   }
 325
 326   getFileChunk(file, chunk_name, NULL, BYTE_ORDER_BIG_ENDIAN);
 327   if (strcmp(chunk_name, "RND1") == 0)
 328   {
 329     getFile32BitInteger(file, BYTE_ORDER_BIG_ENDIAN);   /* not used */
 330
 331     getFileChunk(file, chunk_name, NULL, BYTE_ORDER_BIG_ENDIAN);
 332     if (strcmp(chunk_name, "CAVE") != 0)
 333     {
 334       Error(ERR_WARN, "unknown format of level file '%s'", filename);
 335       fclose(file);
 336       return;
 337     }
 338   }
 339   else  /* check for pre-2.0 file format with cookie string */
 340   {
 341     strcpy(cookie, chunk_name);
 342     fgets(&cookie[4], MAX_LINE_LEN - 4, file);
 343     if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
 344       cookie[strlen(cookie) - 1] = '\0';
 345
 346     if (!checkCookieString(cookie, LEVEL_COOKIE_TMPL))
 347     {
 348       Error(ERR_WARN, "unknown format of level file '%s'", filename);
 349       fclose(file);
 350       return;
 351     }
 352
 353     if ((level.file_version = getFileVersionFromCookieString(cookie)) == -1)
 354     {
 355       Error(ERR_WARN, "unsupported version of level file '%s'", filename);
 356       fclose(file);
 357       return;
 358     }
 359
 360     /* pre-2.0 level files have no game version, so use file version here */
 361     level.game_version = level.file_version;
 362   }
 363
 364   if (level.file_version < FILE_VERSION_1_2)
 365   {
 366     /* level files from versions before 1.2.0 without chunk structure */
 367     LoadLevel_HEAD(file, LEVEL_HEADER_SIZE,           &level);
 368     LoadLevel_BODY(file, level.fieldx * level.fieldy, &level);
 369   }
 370   else
 371   {
 372     static struct
 373     {
 374       char *name;
 375       int size;
 376       int (*loader)(FILE *, int, struct LevelInfo *);
 377     }
 378     chunk_info[] =
 379     {
 380       { "VERS", FILE_VERS_CHUNK_SIZE,   LoadLevel_VERS },
 381       { "HEAD", LEVEL_HEADER_SIZE,      LoadLevel_HEAD },
 382       { "AUTH", MAX_LEVEL_AUTHOR_LEN,   LoadLevel_AUTH },
 383       { "CONT", -1,                     LoadLevel_CONT },
 384       { "BODY", -1,                     LoadLevel_BODY },
 385       { "CNT2", LEVEL_CHUNK_CNT2_SIZE,  LoadLevel_CNT2 },
 386       {  NULL,  0,                      NULL }
 387     };
 388
 389     while (getFileChunk(file, chunk_name, &chunk_size, BYTE_ORDER_BIG_ENDIAN))
 390     {
 391       int i = 0;
 392
 393       while (chunk_info[i].name != NULL &&
 394              strcmp(chunk_name, chunk_info[i].name) != 0)
 395         i++;
 396
 397       if (chunk_info[i].name == NULL)
 398       {
 399         Error(ERR_WARN, "unknown chunk '%s' in level file '%s'",
 400               chunk_name, filename);
 401         ReadUnusedBytesFromFile(file, chunk_size);
 402       }
 403       else if (chunk_info[i].size != -1 &&
 404                chunk_info[i].size != chunk_size)
 405       {
 406         Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
 407               chunk_size, chunk_name, filename);
 408         ReadUnusedBytesFromFile(file, chunk_size);
 409       }
 410       else
 411       {
 412         /* call function to load this level chunk */
 413         int chunk_size_expected =
 414           (chunk_info[i].loader)(file, chunk_size, &level);
 415
 416         /* the size of some chunks cannot be checked before reading other
 417            chunks first (like "HEAD" and "BODY") that contain some header
 418            information, so check them here */
 419         if (chunk_size_expected != chunk_size)
 420         {
 421           Error(ERR_WARN, "wrong size (%d) of chunk '%s' in level file '%s'",
 422                 chunk_size, chunk_name, filename);
 423         }
 424       }
 425     }
 426   }
 427
 428   fclose(file);
 429
 430   if (IS_LEVELCLASS_CONTRIBUTION(leveldir_current) ||
 431       IS_LEVELCLASS_USER(leveldir_current))
 432   {
 433     /* For user contributed and private levels, use the version of
 434        the game engine the levels were created for.
 435        Since 2.0.1, the game engine version is now directly stored
 436        in the level file (chunk "VERS"), so there is no need anymore
 437        to set the game version from the file version (except for old,
 438        pre-2.0 levels, where the game version is still taken from the
 439        file format version used to store the level -- see above). */
 440
 441     /* do some special adjustments to support older level versions */
 442     if (level.file_version == FILE_VERSION_1_0)
 443     {
 444       Error(ERR_WARN, "level file '%s' has version number 1.0", filename);
 445       Error(ERR_WARN, "using high speed movement for player");
 446
 447       /* player was faster than monsters in (pre-)1.0 levels */
 448       level.double_speed = TRUE;
 449     }
 450   }
 451   else
 452   {
 453     /* Always use the latest version of the game engine for all but
 454        user contributed and private levels; this allows for actual
 455        corrections in the game engine to take effect for existing,
 456        converted levels (from "classic" or other existing games) to
 457        make the game emulation more accurate, while (hopefully) not
 458        breaking existing levels created from other players. */
 459
 460     level.game_version = GAME_VERSION_ACTUAL;
 461
 462     /* Set special EM style gems behaviour: EM style gems slip down from
 463        normal, steel and growing wall. As this is a more fundamental change,
 464        it seems better to set the default behaviour to "off" (as it is more
 465        natural) and make it configurable in the level editor (as a property
 466        of gem style elements). Already existing converted levels (neither
 467        private nor contributed levels) are changed to the new behaviour. */
 468
 469     if (level.file_version < FILE_VERSION_2_0)
 470       level.em_slippery_gems = TRUE;
 471   }
 472
 473   /* determine border element for this level */
 474   SetBorderElement();
 475 }
 476
 477 static void SaveLevel_HEAD(FILE *file, struct LevelInfo *level)
 478 {
 479   int i, x, y;
 480
 481   fputc(level->fieldx, file);
 482   fputc(level->fieldy, file);
 483
 484   putFile16BitInteger(file, level->time,        BYTE_ORDER_BIG_ENDIAN);
 485   putFile16BitInteger(file, level->gems_needed, BYTE_ORDER_BIG_ENDIAN);
 486
 487   for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
 488     fputc(level->name[i], file);
 489
 490   for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
 491     fputc(level->score[i], file);
 492
 493   for(i=0; i<STD_ELEMENT_CONTENTS; i++)
 494     for(y=0; y<3; y++)
 495       for(x=0; x<3; x++)
 496         fputc((level->encoding_16bit_yamyam ? EL_LEERRAUM :
 497                level->yam_content[i][x][y]),
 498               file);
 499   fputc(level->amoeba_speed, file);
 500   fputc(level->time_magic_wall, file);
 501   fputc(level->time_wheel, file);
 502   fputc((level->encoding_16bit_amoeba ? EL_LEERRAUM : level->amoeba_content),
 503         file);
 504   fputc((level->double_speed ? 1 : 0), file);
 505   fputc((level->gravity ? 1 : 0), file);
 506   fputc((level->encoding_16bit_field ? 1 : 0), file);
 507   fputc((level->em_slippery_gems ? 1 : 0), file);
 508
 509   WriteUnusedBytesToFile(file, LEVEL_HEADER_UNUSED);
 510 }
 511
 512 static void SaveLevel_AUTH(FILE *file, struct LevelInfo *level)
 513 {
 514   int i;
 515
 516   for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
 517     fputc(level->author[i], file);
 518 }
 519
 520 #if 0
 521 static void SaveLevel_CONT(FILE *file, struct LevelInfo *level)
 522 {
 523   int i, x, y;
 524
 525   fputc(EL_MAMPFER, file);
 526   fputc(level->num_yam_contents, file);
 527   fputc(0, file);
 528   fputc(0, file);
 529
 530   for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
 531     for(y=0; y<3; y++)
 532       for(x=0; x<3; x++)
 533         if (level->encoding_16bit_field)
 534           putFile16BitInteger(file, level->yam_content[i][x][y],
 535                               BYTE_ORDER_BIG_ENDIAN);
 536         else
 537           fputc(level->yam_content[i][x][y], file);
 538 }
 539 #endif
 540
 541 static void SaveLevel_BODY(FILE *file, struct LevelInfo *level)
 542 {
 543   int x, y;
 544
 545   for(y=0; y<level->fieldy; y++)
 546     for(x=0; x<level->fieldx; x++)
 547       if (level->encoding_16bit_field)
 548         putFile16BitInteger(file, Ur[x][y], BYTE_ORDER_BIG_ENDIAN);
 549       else
 550         fputc(Ur[x][y], file);
 551 }
 552
 553 static void SaveLevel_CNT2(FILE *file, struct LevelInfo *level, int element)
 554 {
 555   int i, x, y;
 556   int num_contents, content_xsize, content_ysize;
 557   int content_array[MAX_ELEMENT_CONTENTS][3][3];
 558
 559   if (element == EL_MAMPFER)
 560   {
 561     num_contents = level->num_yam_contents;
 562     content_xsize = 3;
 563     content_ysize = 3;
 564
 565     for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
 566       for(y=0; y<3; y++)
 567         for(x=0; x<3; x++)
 568           content_array[i][x][y] = level->yam_content[i][x][y];
 569   }
 570   else if (element == EL_AMOEBE_BD)
 571   {
 572     num_contents = 1;
 573     content_xsize = 1;
 574     content_ysize = 1;
 575
 576     for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
 577       for(y=0; y<3; y++)
 578         for(x=0; x<3; x++)
 579           content_array[i][x][y] = EL_LEERRAUM;
 580     content_array[0][0][0] = level->amoeba_content;
 581   }
 582   else
 583   {
 584     /* chunk header already written -- write empty chunk data */
 585     WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_SIZE);
 586
 587     Error(ERR_WARN, "cannot save content for element '%d'", element);
 588     return;
 589   }
 590
 591   putFile16BitInteger(file, element, BYTE_ORDER_BIG_ENDIAN);
 592   fputc(num_contents, file);
 593   fputc(content_xsize, file);
 594   fputc(content_ysize, file);
 595
 596   WriteUnusedBytesToFile(file, LEVEL_CHUNK_CNT2_UNUSED);
 597
 598   for(i=0; i<MAX_ELEMENT_CONTENTS; i++)
 599     for(y=0; y<3; y++)
 600       for(x=0; x<3; x++)
 601         putFile16BitInteger(file, content_array[i][x][y],
 602                             BYTE_ORDER_BIG_ENDIAN);
 603 }
 604
 605 void SaveLevel(int level_nr)
 606 {
 607   int i, x, y;
 608   char *filename = getLevelFilename(level_nr);
 609   int body_chunk_size;
 610   FILE *file;
 611
 612   if (!(file = fopen(filename, MODE_WRITE)))
 613   {
 614     Error(ERR_WARN, "cannot save level file '%s'", filename);
 615     return;
 616   }
 617
 618
 619   /* check level field for 16-bit elements */
 620   level.encoding_16bit_field = FALSE;
 621   for(y=0; y<level.fieldy; y++)
 622     for(x=0; x<level.fieldx; x++)
 623       if (Ur[x][y] > 255)
 624         level.encoding_16bit_field = TRUE;
 625
 626   /* check yamyam content for 16-bit elements */
 627   level.encoding_16bit_yamyam = FALSE;
 628   for(i=0; i<level.num_yam_contents; i++)
 629     for(y=0; y<3; y++)
 630       for(x=0; x<3; x++)
 631         if (level.yam_content[i][x][y] > 255)
 632           level.encoding_16bit_yamyam = TRUE;
 633
 634   /* check amoeba content for 16-bit elements */
 635   level.encoding_16bit_amoeba = FALSE;
 636   if (level.amoeba_content > 255)
 637     level.encoding_16bit_amoeba = TRUE;
 638
 639   body_chunk_size =
 640     level.fieldx * level.fieldy * (level.encoding_16bit_field ? 2 : 1);
 641
 642   putFileChunk(file, "RND1", CHUNK_SIZE_UNDEFINED, BYTE_ORDER_BIG_ENDIAN);
 643   putFileChunk(file, "CAVE", CHUNK_SIZE_NONE,      BYTE_ORDER_BIG_ENDIAN);
 644
 645   putFileChunk(file, "VERS", FILE_VERS_CHUNK_SIZE, BYTE_ORDER_BIG_ENDIAN);
 646   WriteChunk_VERS(file, FILE_VERSION_ACTUAL, GAME_VERSION_ACTUAL);
 647
 648   putFileChunk(file, "HEAD", LEVEL_HEADER_SIZE, BYTE_ORDER_BIG_ENDIAN);
 649   SaveLevel_HEAD(file, &level);
 650
 651   putFileChunk(file, "AUTH", MAX_LEVEL_AUTHOR_LEN, BYTE_ORDER_BIG_ENDIAN);
 652   SaveLevel_AUTH(file, &level);
 653
 654   putFileChunk(file, "BODY", body_chunk_size, BYTE_ORDER_BIG_ENDIAN);
 655   SaveLevel_BODY(file, &level);
 656
 657   if (level.encoding_16bit_yamyam ||
 658       level.num_yam_contents != STD_ELEMENT_CONTENTS)
 659   {
 660     putFileChunk(file, "CNT2", LEVEL_CHUNK_CNT2_SIZE, BYTE_ORDER_BIG_ENDIAN);
 661     SaveLevel_CNT2(file, &level, EL_MAMPFER);
 662   }
 663
 664   if (level.encoding_16bit_amoeba)
 665   {
 666     putFileChunk(file, "CNT2", LEVEL_CHUNK_CNT2_SIZE, BYTE_ORDER_BIG_ENDIAN);
 667     SaveLevel_CNT2(file, &level, EL_AMOEBE_BD);
 668   }
 669
 670   fclose(file);
 671
 672   SetFilePermissions(filename, PERMS_PRIVATE);
 673 }
 674
 675
 676 /* ========================================================================= */
 677 /* tape file functions                                                       */
 678 /* ========================================================================= */
 679
 680 static void setTapeInfoToDefaults()
 681 {
 682   int i;
 683
 684   /* always start with reliable default values (empty tape) */
 685   tape.file_version = FILE_VERSION_ACTUAL;
 686   tape.game_version = GAME_VERSION_ACTUAL;
 687   TapeErase();
 688
 689   /* default values (also for pre-1.2 tapes) with only the first player */
 690   tape.player_participates[0] = TRUE;
 691   for(i=1; i<MAX_PLAYERS; i++)
 692     tape.player_participates[i] = FALSE;
 693
 694   /* at least one (default: the first) player participates in every tape */
 695   tape.num_participating_players = 1;
 696
 697   tape.level_nr = level_nr;
 698   tape.counter = 0;
 699   tape.changed = FALSE;
 700
 701   tape.recording = FALSE;
 702   tape.playing = FALSE;
 703   tape.pausing = FALSE;
 704 }
 705
 706 static int LoadTape_VERS(FILE *file, int chunk_size, struct TapeInfo *tape)
 707 {
 708   ReadChunk_VERS(file, &(tape->file_version), &(tape->game_version));
 709
 710   return chunk_size;
 711 }
 712
 713 static int LoadTape_HEAD(FILE *file, int chunk_size, struct TapeInfo *tape)
 714 {
 715   int i;
 716
 717   tape->random_seed = getFile32BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
 718   tape->date        = getFile32BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
 719   tape->length      = getFile32BitInteger(file, BYTE_ORDER_BIG_ENDIAN);
 720
 721   /* read header fields that are new since version 1.2 */
 722   if (tape->file_version >= FILE_VERSION_1_2)
 723   {
 724     byte store_participating_players = fgetc(file);
 725
 726     ReadUnusedBytesFromFile(file, TAPE_HEADER_UNUSED);
 727
 728     /* since version 1.2, tapes store which players participate in the tape */
 729     tape->num_participating_players = 0;
 730     for(i=0; i<MAX_PLAYERS; i++)
 731     {
 732       tape->player_participates[i] = FALSE;
 733
 734       if (store_participating_players & (1 << i))
 735       {
 736         tape->player_participates[i] = TRUE;
 737         tape->num_participating_players++;
 738       }
 739     }
 740   }
 741
 742   return chunk_size;
 743 }
 744
 745 static int LoadTape_BODY(FILE *file, int chunk_size, struct TapeInfo *tape)
 746 {
 747   int i, j;
 748   int chunk_size_expected =
 749     (tape->num_participating_players + 1) * tape->length;
 750
 751   if (chunk_size_expected != chunk_size)
 752   {
 753     ReadUnusedBytesFromFile(file, chunk_size);
 754     return chunk_size_expected;
 755   }
 756
 757   for(i=0; i<tape->length; i++)
 758   {
 759     if (i >= MAX_TAPELEN)
 760       break;
 761
 762     for(j=0; j<MAX_PLAYERS; j++)
 763     {
 764       tape->pos[i].action[j] = MV_NO_MOVING;
 765
 766       if (tape->player_participates[j])
 767         tape->pos[i].action[j] = fgetc(file);
 768     }
 769
 770     tape->pos[i].delay = fgetc(file);
 771
 772     if (tape->file_version == FILE_VERSION_1_0)
 773     {
 774       /* eliminate possible diagonal moves in old tapes */
 775       /* this is only for backward compatibility */
 776
 777       byte joy_dir[4] = { JOY_LEFT, JOY_RIGHT, JOY_UP, JOY_DOWN };
 778       byte action = tape->pos[i].action[0];
 779       int k, num_moves = 0;
 780
 781       for (k=0; k<4; k++)
 782       {
 783         if (action & joy_dir[k])
 784         {
 785           tape->pos[i + num_moves].action[0] = joy_dir[k];
 786           if (num_moves > 0)
 787             tape->pos[i + num_moves].delay = 0;
 788           num_moves++;
 789         }
 790       }
 791
 792       if (num_moves > 1)
 793       {
 794         num_moves--;
 795         i += num_moves;
 796         tape->length += num_moves;
 797       }
 798     }
 799     else if (tape->file_version < FILE_VERSION_2_0)
 800     {
 801       /* convert pre-2.0 tapes to new tape format */
 802
 803       if (tape->pos[i].delay > 1)
 804       {
 805         /* action part */
 806         tape->pos[i + 1] = tape->pos[i];
 807         tape->pos[i + 1].delay = 1;
 808
 809         /* delay part */
 810         for(j=0; j<MAX_PLAYERS; j++)
 811           tape->pos[i].action[j] = MV_NO_MOVING;
 812         tape->pos[i].delay--;
 813
 814         i++;
 815         tape->length++;
 816       }
 817     }
 818
 819     if (feof(file))
 820       break;
 821   }
 822
 823   if (i != tape->length)
 824     chunk_size = (tape->num_participating_players + 1) * i;
 825
 826   return chunk_size;
 827 }
 828
 829 void LoadTape(int level_nr)
 830 {
 831   char *filename = getTapeFilename(level_nr);
 832   char cookie[MAX_LINE_LEN];
 833   char chunk_name[CHUNK_ID_LEN + 1];
 834   FILE *file;
 835   int chunk_size;
 836
 837   /* always start with reliable default values */
 838   setTapeInfoToDefaults();
 839
 840   if (!(file = fopen(filename, MODE_READ)))
 841     return;
 842
 843   getFileChunk(file, chunk_name, NULL, BYTE_ORDER_BIG_ENDIAN);
 844   if (strcmp(chunk_name, "RND1") == 0)
 845   {
 846     getFile32BitInteger(file, BYTE_ORDER_BIG_ENDIAN);   /* not used */
 847
 848     getFileChunk(file, chunk_name, NULL, BYTE_ORDER_BIG_ENDIAN);
 849     if (strcmp(chunk_name, "TAPE") != 0)
 850     {
 851       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
 852       fclose(file);
 853       return;
 854     }
 855   }
 856   else  /* check for pre-2.0 file format with cookie string */
 857   {
 858     strcpy(cookie, chunk_name);
 859     fgets(&cookie[4], MAX_LINE_LEN - 4, file);
 860     if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
 861       cookie[strlen(cookie) - 1] = '\0';
 862
 863     if (!checkCookieString(cookie, TAPE_COOKIE_TMPL))
 864     {
 865       Error(ERR_WARN, "unknown format of tape file '%s'", filename);
 866       fclose(file);
 867       return;
 868     }
 869
 870     if ((tape.file_version = getFileVersionFromCookieString(cookie)) == -1)
 871     {
 872       Error(ERR_WARN, "unsupported version of tape file '%s'", filename);
 873       fclose(file);
 874       return;
 875     }
 876
 877     /* pre-2.0 tape files have no game version, so use file version here */
 878     tape.game_version = tape.file_version;
 879   }
 880
 881   if (tape.file_version < FILE_VERSION_1_2)
 882   {
 883     /* tape files from versions before 1.2.0 without chunk structure */
 884     LoadTape_HEAD(file, TAPE_HEADER_SIZE, &tape);
 885     LoadTape_BODY(file, 2 * tape.length,  &tape);
 886   }
 887   else
 888   {
 889     static struct
 890     {
 891       char *name;
 892       int size;
 893       int (*loader)(FILE *, int, struct TapeInfo *);
 894     }
 895     chunk_info[] =
 896     {
 897       { "VERS", FILE_VERS_CHUNK_SIZE,   LoadTape_VERS },
 898       { "HEAD", TAPE_HEADER_SIZE,       LoadTape_HEAD },
 899       { "BODY", -1,                     LoadTape_BODY },
 900       {  NULL,  0,                      NULL }
 901     };
 902
 903     while (getFileChunk(file, chunk_name, &chunk_size, BYTE_ORDER_BIG_ENDIAN))
 904     {
 905       int i = 0;
 906
 907       while (chunk_info[i].name != NULL &&
 908              strcmp(chunk_name, chunk_info[i].name) != 0)
 909         i++;
 910
 911       if (chunk_info[i].name == NULL)
 912       {
 913         Error(ERR_WARN, "unknown chunk '%s' in tape file '%s'",
 914               chunk_name, filename);
 915         ReadUnusedBytesFromFile(file, chunk_size);
 916       }
 917       else if (chunk_info[i].size != -1 &&
 918                chunk_info[i].size != chunk_size)
 919       {
 920         Error(ERR_WARN, "wrong size (%d) of chunk '%s' in tape file '%s'",
 921               chunk_size, chunk_name, filename);
 922         ReadUnusedBytesFromFile(file, chunk_size);
 923       }
 924       else
 925       {
 926         /* call function to load this tape chunk */
 927         int chunk_size_expected =
 928           (chunk_info[i].loader)(file, chunk_size, &tape);
 929
 930         /* the size of some chunks cannot be checked before reading other
 931            chunks first (like "HEAD" and "BODY") that contain some header
 932            information, so check them here */
 933         if (chunk_size_expected != chunk_size)
 934         {
 935           Error(ERR_WARN, "wrong size (%d) of chunk '%s' in tape file '%s'",
 936                 chunk_size, chunk_name, filename);
 937         }
 938       }
 939     }
 940   }
 941
 942   fclose(file);
 943
 944   tape.length_seconds = GetTapeLength();
 945 }
 946
 947 static void SaveTape_HEAD(FILE *file, struct TapeInfo *tape)
 948 {
 949   int i;
 950   byte store_participating_players = 0;
 951
 952   /* set bits for participating players for compact storage */
 953   for(i=0; i<MAX_PLAYERS; i++)
 954     if (tape->player_participates[i])
 955       store_participating_players |= (1 << i);
 956
 957   putFile32BitInteger(file, tape->random_seed, BYTE_ORDER_BIG_ENDIAN);
 958   putFile32BitInteger(file, tape->date, BYTE_ORDER_BIG_ENDIAN);
 959   putFile32BitInteger(file, tape->length, BYTE_ORDER_BIG_ENDIAN);
 960
 961   fputc(store_participating_players, file);
 962
 963   WriteUnusedBytesToFile(file, TAPE_HEADER_UNUSED);
 964 }
 965
 966 static void SaveTape_BODY(FILE *file, struct TapeInfo *tape)
 967 {
 968   int i, j;
 969
 970   for(i=0; i<tape->length; i++)
 971   {
 972     for(j=0; j<MAX_PLAYERS; j++)
 973       if (tape->player_participates[j])
 974         fputc(tape->pos[i].action[j], file);
 975
 976     fputc(tape->pos[i].delay, file);
 977   }
 978 }
 979
 980 void SaveTape(int level_nr)
 981 {
 982   int i;
 983   char *filename = getTapeFilename(level_nr);
 984   FILE *file;
 985   boolean new_tape = TRUE;
 986   int num_participating_players = 0;
 987   int body_chunk_size;
 988
 989   InitTapeDirectory(leveldir_current->filename);
 990
 991   /* if a tape still exists, ask to overwrite it */
 992   if (access(filename, F_OK) == 0)
 993   {
 994     new_tape = FALSE;
 995     if (!Request("Replace old tape ?", REQ_ASK))
 996       return;
 997   }
 998
 999   if (!(file = fopen(filename, MODE_WRITE)))
1000   {
1001     Error(ERR_WARN, "cannot save level recording file '%s'", filename);
1002     return;
1003   }
1004
1005   /* count number of participating players  */
1006   for(i=0; i<MAX_PLAYERS; i++)
1007     if (tape.player_participates[i])
1008       num_participating_players++;
1009
1010   body_chunk_size = (num_participating_players + 1) * tape.length;
1011
1012   putFileChunk(file, "RND1", CHUNK_SIZE_UNDEFINED, BYTE_ORDER_BIG_ENDIAN);
1013   putFileChunk(file, "TAPE", CHUNK_SIZE_NONE,      BYTE_ORDER_BIG_ENDIAN);
1014
1015   putFileChunk(file, "VERS", FILE_VERS_CHUNK_SIZE, BYTE_ORDER_BIG_ENDIAN);
1016   WriteChunk_VERS(file, FILE_VERSION_ACTUAL, GAME_VERSION_ACTUAL);
1017
1018   putFileChunk(file, "HEAD", TAPE_HEADER_SIZE, BYTE_ORDER_BIG_ENDIAN);
1019   SaveTape_HEAD(file, &tape);
1020
1021   putFileChunk(file, "BODY", body_chunk_size, BYTE_ORDER_BIG_ENDIAN);
1022   SaveTape_BODY(file, &tape);
1023
1024   fclose(file);
1025
1026   SetFilePermissions(filename, PERMS_PRIVATE);
1027
1028   tape.changed = FALSE;
1029
1030   if (new_tape)
1031     Request("tape saved !", REQ_CONFIRM);
1032 }
1033
1034 void DumpTape(struct TapeInfo *tape)
1035 {
1036   int i, j;
1037
1038   if (TAPE_IS_EMPTY(*tape))
1039   {
1040     Error(ERR_WARN, "no tape available for level %d", tape->level_nr);
1041     return;
1042   }
1043
1044   printf("\n");
1045   printf("-------------------------------------------------------------------------------\n");
1046   printf("Tape of Level %d (file version %06d, game version %06d\n",
1047          tape->level_nr, tape->file_version, tape->game_version);
1048   printf("-------------------------------------------------------------------------------\n");
1049
1050   for(i=0; i<tape->length; i++)
1051   {
1052     if (i >= MAX_TAPELEN)
1053       break;
1054
1055     for(j=0; j<MAX_PLAYERS; j++)
1056     {
1057       if (tape->player_participates[j])
1058       {
1059         int action = tape->pos[i].action[j];
1060
1061         printf("%d:%02x ", j, action);
1062         printf("[%c%c%c%c|%c%c] - ",
1063                (action & JOY_LEFT ? '<' : ' '),
1064                (action & JOY_RIGHT ? '>' : ' '),
1065                (action & JOY_UP ? '^' : ' '),
1066                (action & JOY_DOWN ? 'v' : ' '),
1067                (action & JOY_BUTTON_1 ? '1' : ' '),
1068                (action & JOY_BUTTON_2 ? '2' : ' '));
1069       }
1070     }
1071
1072     printf("(%03d)\n", tape->pos[i].delay);
1073   }
1074
1075   printf("-------------------------------------------------------------------------------\n");
1076 }
1077
1078
1079 /* ========================================================================= */
1080 /* score file functions                                                      */
1081 /* ========================================================================= */
1082
1083 void LoadScore(int level_nr)
1084 {
1085   int i;
1086   char *filename = getScoreFilename(level_nr);
1087   char cookie[MAX_LINE_LEN];
1088   char line[MAX_LINE_LEN];
1089   char *line_ptr;
1090   FILE *file;
1091
1092   /* always start with reliable default values */
1093   for(i=0; i<MAX_SCORE_ENTRIES; i++)
1094   {
1095     strcpy(highscore[i].Name, EMPTY_PLAYER_NAME);
1096     highscore[i].Score = 0;
1097   }
1098
1099   if (!(file = fopen(filename, MODE_READ)))
1100     return;
1101
1102   /* check file identifier */
1103   fgets(cookie, MAX_LINE_LEN, file);
1104   if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
1105     cookie[strlen(cookie) - 1] = '\0';
1106
1107   if (!checkCookieString(cookie, SCORE_COOKIE))
1108   {
1109     Error(ERR_WARN, "unknown format of score file '%s'", filename);
1110     fclose(file);
1111     return;
1112   }
1113
1114   for(i=0; i<MAX_SCORE_ENTRIES; i++)
1115   {
1116     fscanf(file, "%d", &highscore[i].Score);
1117     fgets(line, MAX_LINE_LEN, file);
1118
1119     if (line[strlen(line) - 1] == '\n')
1120       line[strlen(line) - 1] = '\0';
1121
1122     for (line_ptr = line; *line_ptr; line_ptr++)
1123     {
1124       if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != '\0')
1125       {
1126         strncpy(highscore[i].Name, line_ptr, MAX_PLAYER_NAME_LEN);
1127         highscore[i].Name[MAX_PLAYER_NAME_LEN] = '\0';
1128         break;
1129       }
1130     }
1131   }
1132
1133   fclose(file);
1134 }
1135
1136 void SaveScore(int level_nr)
1137 {
1138   int i;
1139   char *filename = getScoreFilename(level_nr);
1140   FILE *file;
1141
1142   InitScoreDirectory(leveldir_current->filename);
1143
1144   if (!(file = fopen(filename, MODE_WRITE)))
1145   {
1146     Error(ERR_WARN, "cannot save score for level %d", level_nr);
1147     return;
1148   }
1149
1150   fprintf(file, "%s\n\n", SCORE_COOKIE);
1151
1152   for(i=0; i<MAX_SCORE_ENTRIES; i++)
1153     fprintf(file, "%d %s\n", highscore[i].Score, highscore[i].Name);
1154
1155   fclose(file);
1156
1157   SetFilePermissions(filename, PERMS_PUBLIC);
1158 }
1159
1160
1161 /* ========================================================================= */
1162 /* setup file functions                                                      */
1163 /* ========================================================================= */
1164
1165 #define TOKEN_STR_PLAYER_PREFIX         "player_"
1166
1167 /* global setup */
1168 #define SETUP_TOKEN_PLAYER_NAME         0
1169 #define SETUP_TOKEN_SOUND               1
1170 #define SETUP_TOKEN_SOUND_LOOPS         2
1171 #define SETUP_TOKEN_SOUND_MUSIC         3
1172 #define SETUP_TOKEN_SOUND_SIMPLE        4
1173 #define SETUP_TOKEN_TOONS               5
1174 #define SETUP_TOKEN_SCROLL_DELAY        6
1175 #define SETUP_TOKEN_SOFT_SCROLLING      7
1176 #define SETUP_TOKEN_FADING              8
1177 #define SETUP_TOKEN_AUTORECORD          9
1178 #define SETUP_TOKEN_QUICK_DOORS         10
1179 #define SETUP_TOKEN_TEAM_MODE           11
1180 #define SETUP_TOKEN_HANDICAP            12
1181 #define SETUP_TOKEN_TIME_LIMIT          13
1182 #define SETUP_TOKEN_FULLSCREEN          14
1183 #define SETUP_TOKEN_ASK_ON_ESCAPE       15
1184
1185 #define NUM_GLOBAL_SETUP_TOKENS         16
1186
1187 /* shortcut setup */
1188 #define SETUP_TOKEN_SAVE_GAME           0
1189 #define SETUP_TOKEN_LOAD_GAME           1
1190
1191 #define NUM_SHORTCUT_SETUP_TOKENS       2
1192
1193 /* player setup */
1194 #define SETUP_TOKEN_USE_JOYSTICK        0
1195 #define SETUP_TOKEN_JOY_DEVICE_NAME     1
1196 #define SETUP_TOKEN_JOY_XLEFT           2
1197 #define SETUP_TOKEN_JOY_XMIDDLE         3
1198 #define SETUP_TOKEN_JOY_XRIGHT          4
1199 #define SETUP_TOKEN_JOY_YUPPER          5
1200 #define SETUP_TOKEN_JOY_YMIDDLE         6
1201 #define SETUP_TOKEN_JOY_YLOWER          7
1202 #define SETUP_TOKEN_JOY_SNAP            8
1203 #define SETUP_TOKEN_JOY_BOMB            9
1204 #define SETUP_TOKEN_KEY_LEFT            10
1205 #define SETUP_TOKEN_KEY_RIGHT           11
1206 #define SETUP_TOKEN_KEY_UP              12
1207 #define SETUP_TOKEN_KEY_DOWN            13
1208 #define SETUP_TOKEN_KEY_SNAP            14
1209 #define SETUP_TOKEN_KEY_BOMB            15
1210
1211 #define NUM_PLAYER_SETUP_TOKENS         16
1212
1213 static struct SetupInfo si;
1214 static struct SetupShortcutInfo ssi;
1215 static struct SetupInputInfo sii;
1216
1217 static struct TokenInfo global_setup_tokens[] =
1218 {
1219   /* global setup */
1220   { TYPE_STRING, &si.player_name,       "player_name"                   },
1221   { TYPE_SWITCH, &si.sound,             "sound"                         },
1222   { TYPE_SWITCH, &si.sound_loops,       "repeating_sound_loops"         },
1223   { TYPE_SWITCH, &si.sound_music,       "background_music"              },
1224   { TYPE_SWITCH, &si.sound_simple,      "simple_sound_effects"          },
1225   { TYPE_SWITCH, &si.toons,             "toons"                         },
1226   { TYPE_SWITCH, &si.scroll_delay,      "scroll_delay"                  },
1227   { TYPE_SWITCH, &si.soft_scrolling,    "soft_scrolling"                },
1228   { TYPE_SWITCH, &si.fading,            "screen_fading"                 },
1229   { TYPE_SWITCH, &si.autorecord,        "automatic_tape_recording"      },
1230   { TYPE_SWITCH, &si.quick_doors,       "quick_doors"                   },
1231   { TYPE_SWITCH, &si.team_mode,         "team_mode"                     },
1232   { TYPE_SWITCH, &si.handicap,          "handicap"                      },
1233   { TYPE_SWITCH, &si.time_limit,        "time_limit"                    },
1234   { TYPE_SWITCH, &si.ask_on_escape,     "ask_on_escape"                 },
1235   { TYPE_SWITCH, &si.fullscreen,        "fullscreen"                    }
1236 };
1237
1238 static struct TokenInfo shortcut_setup_tokens[] =
1239 {
1240   /* shortcut setup */
1241   { TYPE_KEY_X11, &ssi.save_game,               "shortcut.save_game"    },
1242   { TYPE_KEY_X11, &ssi.load_game,               "shortcut.load_game"    }
1243 };
1244
1245 static struct TokenInfo player_setup_tokens[] =
1246 {
1247   /* player setup */
1248   { TYPE_BOOLEAN, &sii.use_joystick,    ".use_joystick"                 },
1249   { TYPE_STRING,  &sii.joy.device_name, ".joy.device_name"              },
1250   { TYPE_INTEGER, &sii.joy.xleft,       ".joy.xleft"                    },
1251   { TYPE_INTEGER, &sii.joy.xmiddle,     ".joy.xmiddle"                  },
1252   { TYPE_INTEGER, &sii.joy.xright,      ".joy.xright"                   },
1253   { TYPE_INTEGER, &sii.joy.yupper,      ".joy.yupper"                   },
1254   { TYPE_INTEGER, &sii.joy.ymiddle,     ".joy.ymiddle"                  },
1255   { TYPE_INTEGER, &sii.joy.ylower,      ".joy.ylower"                   },
1256   { TYPE_INTEGER, &sii.joy.snap,        ".joy.snap_field"               },
1257   { TYPE_INTEGER, &sii.joy.bomb,        ".joy.place_bomb"               },
1258   { TYPE_KEY_X11, &sii.key.left,        ".key.move_left"                },
1259   { TYPE_KEY_X11, &sii.key.right,       ".key.move_right"               },
1260   { TYPE_KEY_X11, &sii.key.up,          ".key.move_up"                  },
1261   { TYPE_KEY_X11, &sii.key.down,        ".key.move_down"                },
1262   { TYPE_KEY_X11, &sii.key.snap,        ".key.snap_field"               },
1263   { TYPE_KEY_X11, &sii.key.bomb,        ".key.place_bomb"               }
1264 };
1265
1266 static void setSetupInfoToDefaults(struct SetupInfo *si)
1267 {
1268   int i;
1269
1270   si->player_name = getStringCopy(getLoginName());
1271
1272   si->sound = TRUE;
1273   si->sound_loops = TRUE;
1274   si->sound_music = TRUE;
1275   si->sound_simple = TRUE;
1276   si->toons = TRUE;
1277   si->double_buffering = TRUE;
1278   si->direct_draw = !si->double_buffering;
1279   si->scroll_delay = TRUE;
1280   si->soft_scrolling = TRUE;
1281   si->fading = FALSE;
1282   si->autorecord = TRUE;
1283   si->quick_doors = FALSE;
1284   si->team_mode = FALSE;
1285   si->handicap = TRUE;
1286   si->time_limit = TRUE;
1287   si->fullscreen = FALSE;
1288   si->ask_on_escape = TRUE;
1289
1290   si->shortcut.save_game = DEFAULT_KEY_SAVE_GAME;
1291   si->shortcut.load_game = DEFAULT_KEY_LOAD_GAME;
1292
1293   for (i=0; i<MAX_PLAYERS; i++)
1294   {
1295     si->input[i].use_joystick = FALSE;
1296     si->input[i].joy.device_name=getStringCopy(getDeviceNameFromJoystickNr(i));
1297     si->input[i].joy.xleft   = JOYSTICK_XLEFT;
1298     si->input[i].joy.xmiddle = JOYSTICK_XMIDDLE;
1299     si->input[i].joy.xright  = JOYSTICK_XRIGHT;
1300     si->input[i].joy.yupper  = JOYSTICK_YUPPER;
1301     si->input[i].joy.ymiddle = JOYSTICK_YMIDDLE;
1302     si->input[i].joy.ylower  = JOYSTICK_YLOWER;
1303     si->input[i].joy.snap  = (i == 0 ? JOY_BUTTON_1 : 0);
1304     si->input[i].joy.bomb  = (i == 0 ? JOY_BUTTON_2 : 0);
1305     si->input[i].key.left  = (i == 0 ? DEFAULT_KEY_LEFT  : KSYM_UNDEFINED);
1306     si->input[i].key.right = (i == 0 ? DEFAULT_KEY_RIGHT : KSYM_UNDEFINED);
1307     si->input[i].key.up    = (i == 0 ? DEFAULT_KEY_UP    : KSYM_UNDEFINED);
1308     si->input[i].key.down  = (i == 0 ? DEFAULT_KEY_DOWN  : KSYM_UNDEFINED);
1309     si->input[i].key.snap  = (i == 0 ? DEFAULT_KEY_SNAP  : KSYM_UNDEFINED);
1310     si->input[i].key.bomb  = (i == 0 ? DEFAULT_KEY_BOMB  : KSYM_UNDEFINED);
1311   }
1312 }
1313
1314 static void decodeSetupFileList(struct SetupFileList *setup_file_list)
1315 {
1316   int i, pnr;
1317
1318   if (!setup_file_list)
1319     return;
1320
1321   /* global setup */
1322   si = setup;
1323   for (i=0; i<NUM_GLOBAL_SETUP_TOKENS; i++)
1324     setSetupInfo(global_setup_tokens, i,
1325                  getTokenValue(setup_file_list, global_setup_tokens[i].text));
1326   setup = si;
1327
1328   /* shortcut setup */
1329   ssi = setup.shortcut;
1330   for (i=0; i<NUM_SHORTCUT_SETUP_TOKENS; i++)
1331     setSetupInfo(shortcut_setup_tokens, i,
1332                  getTokenValue(setup_file_list,shortcut_setup_tokens[i].text));
1333   setup.shortcut = ssi;
1334
1335   /* player setup */
1336   for (pnr=0; pnr<MAX_PLAYERS; pnr++)
1337   {
1338     char prefix[30];
1339
1340     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
1341
1342     sii = setup.input[pnr];
1343     for (i=0; i<NUM_PLAYER_SETUP_TOKENS; i++)
1344     {
1345       char full_token[100];
1346
1347       sprintf(full_token, "%s%s", prefix, player_setup_tokens[i].text);
1348       setSetupInfo(player_setup_tokens, i,
1349                    getTokenValue(setup_file_list, full_token));
1350     }
1351     setup.input[pnr] = sii;
1352   }
1353 }
1354
1355 void LoadSetup()
1356 {
1357   char *filename = getSetupFilename();
1358   struct SetupFileList *setup_file_list = NULL;
1359
1360   /* always start with reliable default values */
1361   setSetupInfoToDefaults(&setup);
1362
1363   setup_file_list = loadSetupFileList(filename);
1364
1365   if (setup_file_list)
1366   {
1367     checkSetupFileListIdentifier(setup_file_list, getCookie("SETUP"));
1368     decodeSetupFileList(setup_file_list);
1369
1370     setup.direct_draw = !setup.double_buffering;
1371
1372     freeSetupFileList(setup_file_list);
1373
1374     /* needed to work around problems with fixed length strings */
1375     if (strlen(setup.player_name) > MAX_PLAYER_NAME_LEN)
1376       setup.player_name[MAX_PLAYER_NAME_LEN] = '\0';
1377     else if (strlen(setup.player_name) < MAX_PLAYER_NAME_LEN)
1378     {
1379       char *new_name = checked_malloc(MAX_PLAYER_NAME_LEN + 1);
1380
1381       strcpy(new_name, setup.player_name);
1382       free(setup.player_name);
1383       setup.player_name = new_name;
1384     }
1385   }
1386   else
1387     Error(ERR_WARN, "using default setup values");
1388 }
1389
1390 void SaveSetup()
1391 {
1392   char *filename = getSetupFilename();
1393   FILE *file;
1394   int i, pnr;
1395
1396   InitUserDataDirectory();
1397
1398   if (!(file = fopen(filename, MODE_WRITE)))
1399   {
1400     Error(ERR_WARN, "cannot write setup file '%s'", filename);
1401     return;
1402   }
1403
1404   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
1405                                                getCookie("SETUP")));
1406   fprintf(file, "\n");
1407
1408   /* global setup */
1409   si = setup;
1410   for (i=0; i<NUM_GLOBAL_SETUP_TOKENS; i++)
1411   {
1412     fprintf(file, "%s\n", getSetupLine(global_setup_tokens, "", i));
1413
1414     /* just to make things nicer :) */
1415     if (i == SETUP_TOKEN_PLAYER_NAME)
1416       fprintf(file, "\n");
1417   }
1418
1419   /* shortcut setup */
1420   ssi = setup.shortcut;
1421   fprintf(file, "\n");
1422   for (i=0; i<NUM_SHORTCUT_SETUP_TOKENS; i++)
1423     fprintf(file, "%s\n", getSetupLine(shortcut_setup_tokens, "", i));
1424
1425   /* player setup */
1426   for (pnr=0; pnr<MAX_PLAYERS; pnr++)
1427   {
1428     char prefix[30];
1429
1430     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
1431     fprintf(file, "\n");
1432
1433     sii = setup.input[pnr];
1434     for (i=0; i<NUM_PLAYER_SETUP_TOKENS; i++)
1435       fprintf(file, "%s\n", getSetupLine(player_setup_tokens, prefix, i));
1436   }
1437
1438   fclose(file);
1439
1440   SetFilePermissions(filename, PERMS_PRIVATE);
1441 }