src/files.c

   1 /***********************************************************
   2 *  Rocks'n'Diamonds -- McDuffin Strikes Back!              *
   3 *----------------------------------------------------------*
   4 *  (c) 1995-98 Artsoft Entertainment                       *
   5 *              Holger Schemel                              *
   6 *              Oststrasse 11a                              *
   7 *              33604 Bielefeld                             *
   8 *              phone: ++49 +521 290471                     *
   9 *              email: aeglos@valinor.owl.de                *
  10 *----------------------------------------------------------*
  11 *  files.h                                                 *
  12 ***********************************************************/
  13
  14 #include <ctype.h>
  15 #include <dirent.h>
  16 #include <sys/stat.h>
  17 #include <unistd.h>
  18
  19 #include "files.h"
  20 #include "tools.h"
  21 #include "misc.h"
  22 #include "tape.h"
  23 #include "joystick.h"
  24
  25 #define MAX_FILENAME_LEN        256     /* maximal filename length */
  26 #define MAX_LINE_LEN            1000    /* maximal input line length */
  27 #define CHUNK_ID_LEN            4       /* IFF style chunk id length */
  28 #define LEVEL_HEADER_SIZE       80      /* size of level file header */
  29 #define LEVEL_HEADER_UNUSED     16      /* unused level header bytes */
  30 #define TAPE_HEADER_SIZE        20      /* size of tape file header */
  31 #define TAPE_HEADER_UNUSED      7       /* unused tape header bytes */
  32 #define FILE_VERSION_1_0        10      /* old 1.0 file version */
  33 #define FILE_VERSION_1_2        12      /* actual file version */
  34
  35 /* file identifier strings */
  36 #define LEVEL_COOKIE            "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_1.2"
  37 #define SCORE_COOKIE            "ROCKSNDIAMONDS_SCORE_FILE_VERSION_1.2"
  38 #define TAPE_COOKIE             "ROCKSNDIAMONDS_TAPE_FILE_VERSION_1.2"
  39 #define SETUP_COOKIE            "ROCKSNDIAMONDS_SETUP_FILE_VERSION_1.2"
  40 #define LEVELSETUP_COOKIE       "ROCKSNDIAMONDS_LEVELSETUP_FILE_VERSION_1.2"
  41 #define LEVELINFO_COOKIE        "ROCKSNDIAMONDS_LEVELINFO_FILE_VERSION_1.2"
  42 /* old file identifiers for backward compatibility */
  43 #define LEVEL_COOKIE_10         "ROCKSNDIAMONDS_LEVEL_FILE_VERSION_1.0"
  44 #define TAPE_COOKIE_10          "ROCKSNDIAMONDS_LEVELREC_FILE_VERSION_1.0"
  45
  46 /* file names and filename extensions */
  47 #ifndef MSDOS
  48 #define USERDATA_DIRECTORY      ".rocksndiamonds"
  49 #define SETUP_FILENAME          "setup.conf"
  50 #define LEVELSETUP_FILENAME     "levelsetup.conf"
  51 #define LEVELINFO_FILENAME      "levelinfo.conf"
  52 #define LEVELFILE_EXTENSION     "level"
  53 #define TAPEFILE_EXTENSION      "tape"
  54 #define SCOREFILE_EXTENSION     "score"
  55 #else
  56 #define USERDATA_DIRECTORY      "userdata"
  57 #define SETUP_FILENAME          "setup.cnf"
  58 #define LEVELSETUP_FILENAME     "lvlsetup.cnf"
  59 #define LEVELINFO_FILENAME      "lvlinfo.cnf"
  60 #define LEVELFILE_EXTENSION     "lvl"
  61 #define TAPEFILE_EXTENSION      "tap"
  62 #define SCOREFILE_EXTENSION     "sco"
  63 #define ERROR_FILENAME          "error.out"
  64 #endif
  65
  66 /* file permissions for newly written files */
  67 #define MODE_R_ALL              (S_IRUSR | S_IRGRP | S_IROTH)
  68 #define MODE_W_ALL              (S_IWUSR | S_IWGRP | S_IWOTH)
  69 #define MODE_X_ALL              (S_IXUSR | S_IXGRP | S_IXOTH)
  70 #define USERDATA_DIR_MODE       (MODE_R_ALL | MODE_X_ALL | S_IWUSR)
  71 #define LEVEL_PERMS             (MODE_R_ALL | MODE_W_ALL)
  72 #define SCORE_PERMS             LEVEL_PERMS
  73 #define TAPE_PERMS              LEVEL_PERMS
  74 #define SETUP_PERMS             LEVEL_PERMS
  75
  76 /* sort priorities of level series (also used as level series classes) */
  77 #define LEVELCLASS_TUTORIAL_START       10
  78 #define LEVELCLASS_TUTORIAL_END         99
  79 #define LEVELCLASS_CLASSICS_START       100
  80 #define LEVELCLASS_CLASSICS_END         199
  81 #define LEVELCLASS_CONTRIBUTION_START   200
  82 #define LEVELCLASS_CONTRIBUTION_END     299
  83 #define LEVELCLASS_USER_START           300
  84 #define LEVELCLASS_USER_END             399
  85
  86 #define LEVELCLASS_TUTORIAL             LEVELCLASS_TUTORIAL_START
  87 #define LEVELCLASS_CLASSICS             LEVELCLASS_CLASSICS_START
  88 #define LEVELCLASS_CONTRIBUTION         LEVELCLASS_CONTRIBUTION_START
  89 #define LEVELCLASS_USER                 LEVELCLASS_USER_START
  90 #define LEVELCLASS_UNDEFINED            999
  91
  92 #define IS_LEVELCLASS_TUTORIAL(n) \
  93         (leveldir[n].sort_priority >= LEVELCLASS_TUTORIAL_START && \
  94          leveldir[n].sort_priority <= LEVELCLASS_TUTORIAL_END)
  95 #define IS_LEVELCLASS_CLASSICS(n) \
  96         (leveldir[n].sort_priority >= LEVELCLASS_CLASSICS_START && \
  97          leveldir[n].sort_priority <= LEVELCLASS_CLASSICS_END)
  98 #define IS_LEVELCLASS_CONTRIBUTION(n) \
  99         (leveldir[n].sort_priority >= LEVELCLASS_CONTRIBUTION_START && \
 100          leveldir[n].sort_priority <= LEVELCLASS_CONTRIBUTION_END)
 101 #define IS_LEVELCLASS_USER(n) \
 102         (leveldir[n].sort_priority >= LEVELCLASS_USER_START && \
 103          leveldir[n].sort_priority <= LEVELCLASS_USER_END)
 104
 105 #define LEVELCLASS(n)   (IS_LEVELCLASS_TUTORIAL(n) ? LEVELCLASS_TUTORIAL : \
 106                          IS_LEVELCLASS_CLASSICS(n) ? LEVELCLASS_CLASSICS : \
 107                          IS_LEVELCLASS_CONTRIBUTION(n) ? LEVELCLASS_CONTRIBUTION : \
 108                          IS_LEVELCLASS_USER(n) ? LEVELCLASS_USER : \
 109                          LEVELCLASS_UNDEFINED)
 110
 111 #define LEVELCOLOR(n)   (IS_LEVELCLASS_TUTORIAL(n) ? FC_BLUE : \
 112                          IS_LEVELCLASS_CLASSICS(n) ? FC_YELLOW : \
 113                          IS_LEVELCLASS_CONTRIBUTION(n) ? FC_GREEN : \
 114                          IS_LEVELCLASS_USER(n) ? FC_RED : FC_BLUE)
 115
 116 static void SaveUserLevelInfo();                /* for 'InitUserLevelDir()' */
 117 static char *getSetupLine(char *, int);         /* for 'SaveUserLevelInfo()' */
 118
 119 static char *getGlobalDataDir()
 120 {
 121   return GAME_DIR;
 122 }
 123
 124 char *getUserDataDir()
 125 {
 126   static char *userdata_dir = NULL;
 127
 128   if (!userdata_dir)
 129   {
 130     char *home_dir = getHomeDir();
 131     char *data_dir = USERDATA_DIRECTORY;
 132
 133     userdata_dir = getPath2(home_dir, data_dir);
 134   }
 135
 136   return userdata_dir;
 137 }
 138
 139 static char *getSetupDir()
 140 {
 141   return getUserDataDir();
 142 }
 143
 144 static char *getUserLevelDir(char *level_subdir)
 145 {
 146   static char *userlevel_dir = NULL;
 147   char *data_dir = getUserDataDir();
 148   char *userlevel_subdir = LEVELS_DIRECTORY;
 149
 150   if (userlevel_dir)
 151     free(userlevel_dir);
 152
 153   if (strlen(level_subdir) > 0)
 154     userlevel_dir = getPath3(data_dir, userlevel_subdir, level_subdir);
 155   else
 156     userlevel_dir = getPath2(data_dir, userlevel_subdir);
 157
 158   return userlevel_dir;
 159 }
 160
 161 static char *getTapeDir(char *level_subdir)
 162 {
 163   static char *tape_dir = NULL;
 164   char *data_dir = getUserDataDir();
 165   char *tape_subdir = TAPES_DIRECTORY;
 166
 167   if (tape_dir)
 168     free(tape_dir);
 169
 170   if (strlen(level_subdir) > 0)
 171     tape_dir = getPath3(data_dir, tape_subdir, level_subdir);
 172   else
 173     tape_dir = getPath2(data_dir, tape_subdir);
 174
 175   return tape_dir;
 176 }
 177
 178 static char *getScoreDir(char *level_subdir)
 179 {
 180   static char *score_dir = NULL;
 181   char *data_dir = getGlobalDataDir();
 182   char *score_subdir = SCORES_DIRECTORY;
 183
 184   if (score_dir)
 185     free(score_dir);
 186
 187   if (strlen(level_subdir) > 0)
 188     score_dir = getPath3(data_dir, score_subdir, level_subdir);
 189   else
 190     score_dir = getPath2(data_dir, score_subdir);
 191
 192   return score_dir;
 193 }
 194
 195 static char *getLevelFilename(int nr)
 196 {
 197   static char *filename = NULL;
 198   char basename[MAX_FILENAME_LEN];
 199
 200   if (filename != NULL)
 201     free(filename);
 202
 203   sprintf(basename, "%03d.%s", nr, LEVELFILE_EXTENSION);
 204   filename = getPath3((leveldir[leveldir_nr].user_defined ?
 205                        getUserLevelDir("") :
 206                        options.level_directory),
 207                       leveldir[leveldir_nr].filename,
 208                       basename);
 209
 210   return filename;
 211 }
 212
 213 static char *getTapeFilename(int nr)
 214 {
 215   static char *filename = NULL;
 216   char basename[MAX_FILENAME_LEN];
 217
 218   if (filename != NULL)
 219     free(filename);
 220
 221   sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
 222   filename = getPath2(getTapeDir(leveldir[leveldir_nr].filename), basename);
 223
 224   return filename;
 225 }
 226
 227 static char *getScoreFilename(int nr)
 228 {
 229   static char *filename = NULL;
 230   char basename[MAX_FILENAME_LEN];
 231
 232   if (filename != NULL)
 233     free(filename);
 234
 235   sprintf(basename, "%03d.%s", nr, SCOREFILE_EXTENSION);
 236   filename = getPath2(getScoreDir(leveldir[leveldir_nr].filename), basename);
 237
 238   return filename;
 239 }
 240
 241 static void createDirectory(char *dir, char *text)
 242 {
 243   if (access(dir, F_OK) != 0)
 244     if (mkdir(dir, USERDATA_DIR_MODE) != 0)
 245       Error(ERR_WARN, "cannot create %s directory '%s'", text, dir);
 246 }
 247
 248 static void InitUserDataDirectory()
 249 {
 250   createDirectory(getUserDataDir(), "user data");
 251 }
 252
 253 static void InitTapeDirectory(char *level_subdir)
 254 {
 255   createDirectory(getUserDataDir(), "user data");
 256   createDirectory(getTapeDir(""), "main tape");
 257   createDirectory(getTapeDir(level_subdir), "level tape");
 258 }
 259
 260 static void InitScoreDirectory(char *level_subdir)
 261 {
 262   createDirectory(getScoreDir(""), "main score");
 263   createDirectory(getScoreDir(level_subdir), "level score");
 264 }
 265
 266 static void InitUserLevelDirectory(char *level_subdir)
 267 {
 268   if (access(getUserLevelDir(level_subdir), F_OK) != 0)
 269   {
 270     createDirectory(getUserDataDir(), "user data");
 271     createDirectory(getUserLevelDir(""), "main user level");
 272     createDirectory(getUserLevelDir(level_subdir), "user level");
 273
 274     SaveUserLevelInfo();
 275   }
 276 }
 277
 278 static void getFileChunk(FILE *file, char *chunk_buffer, int *chunk_length)
 279 {
 280   fgets(chunk_buffer, CHUNK_ID_LEN + 1, file);
 281
 282   *chunk_length =
 283     (fgetc(file) << 24) |
 284     (fgetc(file) << 16) |
 285     (fgetc(file) <<  8)  |
 286     (fgetc(file) <<  0);
 287 }
 288
 289 static void putFileChunk(FILE *file, char *chunk_name, int chunk_length)
 290 {
 291   fputs(chunk_name, file);
 292
 293   fputc((chunk_length >> 24) & 0xff, file);
 294   fputc((chunk_length >> 16) & 0xff, file);
 295   fputc((chunk_length >>  8) & 0xff, file);
 296   fputc((chunk_length >>  0) & 0xff, file);
 297 }
 298
 299 static void setLevelInfoToDefaults()
 300 {
 301   int i, x, y;
 302
 303   lev_fieldx = level.fieldx = STD_LEV_FIELDX;
 304   lev_fieldy = level.fieldy = STD_LEV_FIELDY;
 305
 306   for(x=0; x<MAX_LEV_FIELDX; x++)
 307     for(y=0; y<MAX_LEV_FIELDY; y++)
 308       Feld[x][y] = Ur[x][y] = EL_ERDREICH;
 309
 310   level.time = 100;
 311   level.edelsteine = 0;
 312   level.tempo_amoebe = 10;
 313   level.dauer_sieb = 10;
 314   level.dauer_ablenk = 10;
 315   level.amoebe_inhalt = EL_DIAMANT;
 316   level.double_speed = FALSE;
 317   level.gravity = FALSE;
 318
 319   for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
 320     level.name[i] = '\0';
 321   for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
 322     level.author[i] = '\0';
 323
 324   strcpy(level.name, NAMELESS_LEVEL_NAME);
 325   strcpy(level.author, ANONYMOUS_NAME);
 326
 327   for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
 328     level.score[i] = 10;
 329
 330   MampferMax = 4;
 331   for(i=0; i<8; i++)
 332     for(x=0; x<3; x++)
 333       for(y=0; y<3; y++)
 334         level.mampfer_inhalt[i][x][y] = EL_FELSBROCKEN;
 335
 336   Feld[0][0] = Ur[0][0] = EL_SPIELFIGUR;
 337   Feld[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] =
 338     Ur[STD_LEV_FIELDX-1][STD_LEV_FIELDY-1] = EL_AUSGANG_ZU;
 339
 340   BorderElement = EL_BETON;
 341
 342   /* try to determine better author name than 'anonymous' */
 343   if (strcmp(leveldir[leveldir_nr].author, ANONYMOUS_NAME) != 0)
 344   {
 345     strncpy(level.author, leveldir[leveldir_nr].author, MAX_LEVEL_AUTHOR_LEN);
 346     level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 347   }
 348   else
 349   {
 350     switch (LEVELCLASS(leveldir_nr))
 351     {
 352       case LEVELCLASS_TUTORIAL:
 353         strcpy(level.author, PROGRAM_AUTHOR_STRING);
 354         break;
 355
 356       case LEVELCLASS_CONTRIBUTION:
 357         strncpy(level.author, leveldir[leveldir_nr].name,MAX_LEVEL_AUTHOR_LEN);
 358         level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 359         break;
 360
 361       case LEVELCLASS_USER:
 362         strncpy(level.author, getRealName(), MAX_LEVEL_AUTHOR_LEN);
 363         level.author[MAX_LEVEL_AUTHOR_LEN] = '\0';
 364         break;
 365
 366       default:
 367         /* keep default value */
 368         break;
 369     }
 370   }
 371 }
 372
 373 void LoadLevel(int level_nr)
 374 {
 375   int i, x, y;
 376   char *filename = getLevelFilename(level_nr);
 377   char cookie[MAX_LINE_LEN];
 378   char chunk[CHUNK_ID_LEN + 1];
 379   int file_version = FILE_VERSION_1_2;  /* last version of level files */
 380   int chunk_length;
 381   FILE *file;
 382
 383   /* always start with reliable default values */
 384   setLevelInfoToDefaults();
 385
 386   if (!(file = fopen(filename, "r")))
 387   {
 388     Error(ERR_WARN, "cannot read level '%s' - creating new level", filename);
 389     return;
 390   }
 391
 392   /* check file identifier */
 393   fgets(cookie, MAX_LINE_LEN, file);
 394   if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
 395     cookie[strlen(cookie) - 1] = '\0';
 396
 397   if (strcmp(cookie, LEVEL_COOKIE_10) == 0)     /* old 1.0 level format */
 398     file_version = FILE_VERSION_1_0;
 399   else if (strcmp(cookie, LEVEL_COOKIE) != 0)   /* unknown level format */
 400   {
 401     Error(ERR_WARN, "wrong file identifier of level file '%s'", filename);
 402     fclose(file);
 403     return;
 404   }
 405
 406   /* read chunk "HEAD" */
 407   if (file_version >= FILE_VERSION_1_2)
 408   {
 409     getFileChunk(file, chunk, &chunk_length);
 410     if (strcmp(chunk, "HEAD") || chunk_length != LEVEL_HEADER_SIZE)
 411     {
 412       Error(ERR_WARN, "wrong 'HEAD' chunk of level file '%s'", filename);
 413       fclose(file);
 414       return;
 415     }
 416   }
 417
 418   lev_fieldx = level.fieldx = fgetc(file);
 419   lev_fieldy = level.fieldy = fgetc(file);
 420
 421   level.time            = (fgetc(file)<<8) | fgetc(file);
 422   level.edelsteine      = (fgetc(file)<<8) | fgetc(file);
 423
 424   for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
 425     level.name[i]       = fgetc(file);
 426   level.name[MAX_LEVEL_NAME_LEN] = 0;
 427
 428   for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
 429     level.score[i]      = fgetc(file);
 430
 431   MampferMax = 4;
 432   for(i=0; i<8; i++)
 433   {
 434     for(y=0; y<3; y++)
 435     {
 436       for(x=0; x<3; x++)
 437       {
 438         if (i < 4)
 439           level.mampfer_inhalt[i][x][y] = fgetc(file);
 440         else
 441           level.mampfer_inhalt[i][x][y] = EL_LEERRAUM;
 442       }
 443     }
 444   }
 445
 446   level.tempo_amoebe    = fgetc(file);
 447   level.dauer_sieb      = fgetc(file);
 448   level.dauer_ablenk    = fgetc(file);
 449   level.amoebe_inhalt   = fgetc(file);
 450   level.double_speed    = (fgetc(file) == 1 ? TRUE : FALSE);
 451   level.gravity         = (fgetc(file) == 1 ? TRUE : FALSE);
 452
 453   for(i=0; i<LEVEL_HEADER_UNUSED; i++)  /* skip unused header bytes */
 454     fgetc(file);
 455
 456   /* read chunk "BODY" */
 457   if (file_version >= FILE_VERSION_1_2)
 458   {
 459     getFileChunk(file, chunk, &chunk_length);
 460
 461     /* look for optional author chunk */
 462     if (strcmp(chunk, "AUTH") == 0 && chunk_length == MAX_LEVEL_AUTHOR_LEN)
 463     {
 464       for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
 465         level.author[i] = fgetc(file);
 466       level.author[MAX_LEVEL_NAME_LEN] = 0;
 467
 468       getFileChunk(file, chunk, &chunk_length);
 469     }
 470
 471     /* look for optional content chunk */
 472     if (strcmp(chunk, "CONT") == 0 && chunk_length == 4 + 8 * 3 * 3)
 473     {
 474       fgetc(file);
 475       MampferMax = fgetc(file);
 476       fgetc(file);
 477       fgetc(file);
 478
 479       for(i=0; i<8; i++)
 480         for(y=0; y<3; y++)
 481           for(x=0; x<3; x++)
 482             level.mampfer_inhalt[i][x][y] = fgetc(file);
 483
 484       getFileChunk(file, chunk, &chunk_length);
 485     }
 486
 487     /* next check body chunk identifier and chunk length */
 488     if (strcmp(chunk, "BODY") || chunk_length != lev_fieldx * lev_fieldy)
 489     {
 490       Error(ERR_WARN, "wrong 'BODY' chunk of level file '%s'", filename);
 491       fclose(file);
 492       return;
 493     }
 494   }
 495
 496   /* clear all other level fields (needed if resized in level editor later) */
 497   for(x=0; x<MAX_LEV_FIELDX; x++)
 498     for(y=0; y<MAX_LEV_FIELDY; y++)
 499       Feld[x][y] = Ur[x][y] = EL_LEERRAUM;
 500
 501   /* now read in the valid level fields from level file */
 502   for(y=0; y<lev_fieldy; y++)
 503     for(x=0; x<lev_fieldx; x++)
 504       Feld[x][y] = Ur[x][y] = fgetc(file);
 505
 506   fclose(file);
 507
 508   /* player was faster than monsters in pre-1.0 levels */
 509   if (file_version == FILE_VERSION_1_0 &&
 510       IS_LEVELCLASS_CONTRIBUTION(leveldir_nr))
 511   {
 512     Error(ERR_WARN, "level file '%s' has version number 1.0", filename);
 513     Error(ERR_WARN, "using high speed movement for player");
 514     level.double_speed = TRUE;
 515   }
 516 }
 517
 518 void SaveLevel(int level_nr)
 519 {
 520   int i, x, y;
 521   char *filename = getLevelFilename(level_nr);
 522   FILE *file;
 523
 524   if (!(file = fopen(filename, "w")))
 525   {
 526     Error(ERR_WARN, "cannot save level file '%s'", filename);
 527     return;
 528   }
 529
 530   fputs(LEVEL_COOKIE, file);            /* file identifier */
 531   fputc('\n', file);
 532
 533   putFileChunk(file, "HEAD", LEVEL_HEADER_SIZE);
 534
 535   fputc(level.fieldx, file);
 536   fputc(level.fieldy, file);
 537   fputc(level.time / 256, file);
 538   fputc(level.time % 256, file);
 539   fputc(level.edelsteine / 256, file);
 540   fputc(level.edelsteine % 256, file);
 541
 542   for(i=0; i<MAX_LEVEL_NAME_LEN; i++)
 543     fputc(level.name[i], file);
 544   for(i=0; i<LEVEL_SCORE_ELEMENTS; i++)
 545     fputc(level.score[i], file);
 546   for(i=0; i<4; i++)
 547     for(y=0; y<3; y++)
 548       for(x=0; x<3; x++)
 549         fputc(level.mampfer_inhalt[i][x][y], file);
 550   fputc(level.tempo_amoebe, file);
 551   fputc(level.dauer_sieb, file);
 552   fputc(level.dauer_ablenk, file);
 553   fputc(level.amoebe_inhalt, file);
 554   fputc((level.double_speed ? 1 : 0), file);
 555   fputc((level.gravity ? 1 : 0), file);
 556
 557   for(i=0; i<LEVEL_HEADER_UNUSED; i++)  /* set unused header bytes to zero */
 558     fputc(0, file);
 559
 560   putFileChunk(file, "AUTH", MAX_LEVEL_AUTHOR_LEN);
 561
 562   for(i=0; i<MAX_LEVEL_AUTHOR_LEN; i++)
 563     fputc(level.author[i], file);
 564
 565   putFileChunk(file, "CONT", 4 + 8 * 3 * 3);
 566
 567   fputc(EL_MAMPFER, file);
 568   fputc(MampferMax, file);
 569   fputc(0, file);
 570   fputc(0, file);
 571
 572   for(i=0; i<8; i++)
 573     for(y=0; y<3; y++)
 574       for(x=0; x<3; x++)
 575         fputc(level.mampfer_inhalt[i][x][y], file);
 576
 577   putFileChunk(file, "BODY", lev_fieldx * lev_fieldy);
 578
 579   for(y=0; y<lev_fieldy; y++)
 580     for(x=0; x<lev_fieldx; x++)
 581       fputc(Ur[x][y], file);
 582
 583   fclose(file);
 584
 585   chmod(filename, LEVEL_PERMS);
 586 }
 587
 588 void LoadTape(int level_nr)
 589 {
 590   int i, j;
 591   char *filename = getTapeFilename(level_nr);
 592   char cookie[MAX_LINE_LEN];
 593   char chunk[CHUNK_ID_LEN + 1];
 594   FILE *file;
 595   int num_participating_players;
 596   int file_version = FILE_VERSION_1_2;  /* last version of tape files */
 597   int chunk_length;
 598
 599   /* always start with reliable default values (empty tape) */
 600   TapeErase();
 601
 602   /* default values (also for pre-1.2 tapes) with only the first player */
 603   tape.player_participates[0] = TRUE;
 604   for(i=1; i<MAX_PLAYERS; i++)
 605     tape.player_participates[i] = FALSE;
 606
 607   /* at least one (default: the first) player participates in every tape */
 608   num_participating_players = 1;
 609
 610   if (!(file = fopen(filename, "r")))
 611     return;
 612
 613   /* check file identifier */
 614   fgets(cookie, MAX_LINE_LEN, file);
 615   if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
 616     cookie[strlen(cookie) - 1] = '\0';
 617
 618   if (strcmp(cookie, TAPE_COOKIE_10) == 0)      /* old 1.0 tape format */
 619     file_version = FILE_VERSION_1_0;
 620   else if (strcmp(cookie, TAPE_COOKIE) != 0)    /* unknown tape format */
 621   {
 622     Error(ERR_WARN, "wrong file identifier of tape file '%s'", filename);
 623     fclose(file);
 624     return;
 625   }
 626
 627   /* read chunk "HEAD" */
 628   if (file_version >= FILE_VERSION_1_2)
 629   {
 630     /* first check header chunk identifier and chunk length */
 631     fgets(chunk, CHUNK_ID_LEN + 1, file);
 632     chunk_length =
 633       (fgetc(file)<<24) | (fgetc(file)<<16) | (fgetc(file)<<8) | fgetc(file);
 634
 635     if (strcmp(chunk, "HEAD") || chunk_length != TAPE_HEADER_SIZE)
 636     {
 637       Error(ERR_WARN, "wrong 'HEAD' chunk of tape file '%s'", filename);
 638       fclose(file);
 639       return;
 640     }
 641   }
 642
 643   tape.random_seed =
 644     (fgetc(file)<<24) | (fgetc(file)<<16) | (fgetc(file)<<8) | fgetc(file);
 645   tape.date =
 646     (fgetc(file)<<24) | (fgetc(file)<<16) | (fgetc(file)<<8) | fgetc(file);
 647   tape.length =
 648     (fgetc(file)<<24) | (fgetc(file)<<16) | (fgetc(file)<<8) | fgetc(file);
 649
 650   /* read header fields that are new since version 1.2 */
 651   if (file_version >= FILE_VERSION_1_2)
 652   {
 653     byte store_participating_players = fgetc(file);
 654
 655     for(i=0; i<TAPE_HEADER_UNUSED; i++)         /* skip unused header bytes */
 656       fgetc(file);
 657
 658     /* since version 1.2, tapes store which players participate in the tape */
 659     num_participating_players = 0;
 660     for(i=0; i<MAX_PLAYERS; i++)
 661     {
 662       tape.player_participates[i] = FALSE;
 663
 664       if (store_participating_players & (1 << i))
 665       {
 666         tape.player_participates[i] = TRUE;
 667         num_participating_players++;
 668       }
 669     }
 670   }
 671
 672   tape.level_nr = level_nr;
 673   tape.counter = 0;
 674   tape.changed = FALSE;
 675
 676   tape.recording = FALSE;
 677   tape.playing = FALSE;
 678   tape.pausing = FALSE;
 679
 680   /* read chunk "BODY" */
 681   if (file_version >= FILE_VERSION_1_2)
 682   {
 683     /* next check body chunk identifier and chunk length */
 684     fgets(chunk, CHUNK_ID_LEN + 1, file);
 685     chunk_length =
 686       (fgetc(file)<<24) | (fgetc(file)<<16) | (fgetc(file)<<8) | fgetc(file);
 687     if (strcmp(chunk, "BODY") ||
 688         chunk_length != (num_participating_players + 1) * tape.length)
 689     {
 690       Error(ERR_WARN, "wrong 'BODY' chunk of tape file '%s'", filename);
 691       fclose(file);
 692       return;
 693     }
 694   }
 695
 696   for(i=0; i<tape.length; i++)
 697   {
 698     if (i >= MAX_TAPELEN)
 699       break;
 700
 701     for(j=0; j<MAX_PLAYERS; j++)
 702     {
 703       tape.pos[i].action[j] = MV_NO_MOVING;
 704
 705       if (tape.player_participates[j])
 706         tape.pos[i].action[j] = fgetc(file);
 707     }
 708
 709     tape.pos[i].delay = fgetc(file);
 710
 711     if (file_version == FILE_VERSION_1_0)
 712     {
 713       /* eliminate possible diagonal moves in old tapes */
 714       /* this is only for backward compatibility */
 715
 716       byte joy_dir[4] = { JOY_LEFT, JOY_RIGHT, JOY_UP, JOY_DOWN };
 717       byte action = tape.pos[i].action[0];
 718       int k, num_moves = 0;
 719
 720       for (k=0; k<4; k++)
 721       {
 722         if (action & joy_dir[k])
 723         {
 724           tape.pos[i + num_moves].action[0] = joy_dir[k];
 725           if (num_moves > 0)
 726             tape.pos[i + num_moves].delay = 0;
 727           num_moves++;
 728         }
 729       }
 730
 731       if (num_moves > 1)
 732       {
 733         num_moves--;
 734         i += num_moves;
 735         tape.length += num_moves;
 736       }
 737     }
 738
 739     if (feof(file))
 740       break;
 741   }
 742
 743   fclose(file);
 744
 745   if (i != tape.length)
 746     Error(ERR_WARN, "level recording file '%s' corrupted", filename);
 747
 748   tape.length_seconds = GetTapeLength();
 749 }
 750
 751 void SaveTape(int level_nr)
 752 {
 753   int i;
 754   char *filename = getTapeFilename(level_nr);
 755   FILE *file;
 756   boolean new_tape = TRUE;
 757   byte store_participating_players;
 758   int num_participating_players;
 759   int chunk_length;
 760
 761   InitTapeDirectory(leveldir[leveldir_nr].filename);
 762
 763   /* if a tape still exists, ask to overwrite it */
 764   if (access(filename, F_OK) == 0)
 765   {
 766     new_tape = FALSE;
 767     if (!Request("Replace old tape ?", REQ_ASK))
 768       return;
 769   }
 770
 771   /* count number of players and set corresponding bits for compact storage */
 772   store_participating_players = 0;
 773   num_participating_players = 0;
 774   for(i=0; i<MAX_PLAYERS; i++)
 775   {
 776     if (tape.player_participates[i])
 777     {
 778       num_participating_players++;
 779       store_participating_players |= (1 << i);
 780     }
 781   }
 782
 783   if (!(file = fopen(filename, "w")))
 784   {
 785     Error(ERR_WARN, "cannot save level recording file '%s'", filename);
 786     return;
 787   }
 788
 789   fputs(TAPE_COOKIE, file);             /* file identifier */
 790   fputc('\n', file);
 791
 792   fputs("HEAD", file);                  /* chunk identifier for file header */
 793
 794   chunk_length = TAPE_HEADER_SIZE;
 795
 796   fputc((chunk_length >>  24) & 0xff, file);
 797   fputc((chunk_length >>  16) & 0xff, file);
 798   fputc((chunk_length >>   8) & 0xff, file);
 799   fputc((chunk_length >>   0) & 0xff, file);
 800
 801   fputc((tape.random_seed >> 24) & 0xff, file);
 802   fputc((tape.random_seed >> 16) & 0xff, file);
 803   fputc((tape.random_seed >>  8) & 0xff, file);
 804   fputc((tape.random_seed >>  0) & 0xff, file);
 805
 806   fputc((tape.date >>  24) & 0xff, file);
 807   fputc((tape.date >>  16) & 0xff, file);
 808   fputc((tape.date >>   8) & 0xff, file);
 809   fputc((tape.date >>   0) & 0xff, file);
 810
 811   fputc((tape.length >>  24) & 0xff, file);
 812   fputc((tape.length >>  16) & 0xff, file);
 813   fputc((tape.length >>   8) & 0xff, file);
 814   fputc((tape.length >>   0) & 0xff, file);
 815
 816   fputc(store_participating_players, file);
 817
 818   for(i=0; i<TAPE_HEADER_UNUSED; i++)   /* set unused header bytes to zero */
 819     fputc(0, file);
 820
 821   fputs("BODY", file);                  /* chunk identifier for file body */
 822   chunk_length = (num_participating_players + 1) * tape.length;
 823
 824   fputc((chunk_length >>  24) & 0xff, file);
 825   fputc((chunk_length >>  16) & 0xff, file);
 826   fputc((chunk_length >>   8) & 0xff, file);
 827   fputc((chunk_length >>   0) & 0xff, file);
 828
 829   for(i=0; i<tape.length; i++)
 830   {
 831     int j;
 832
 833     for(j=0; j<MAX_PLAYERS; j++)
 834       if (tape.player_participates[j])
 835         fputc(tape.pos[i].action[j], file);
 836
 837     fputc(tape.pos[i].delay, file);
 838   }
 839
 840   fclose(file);
 841
 842   chmod(filename, TAPE_PERMS);
 843
 844   tape.changed = FALSE;
 845
 846   if (new_tape)
 847     Request("tape saved !", REQ_CONFIRM);
 848 }
 849
 850 void LoadScore(int level_nr)
 851 {
 852   int i;
 853   char *filename = getScoreFilename(level_nr);
 854   char cookie[MAX_LINE_LEN];
 855   char line[MAX_LINE_LEN];
 856   char *line_ptr;
 857   FILE *file;
 858
 859   /* always start with reliable default values */
 860   for(i=0; i<MAX_SCORE_ENTRIES; i++)
 861   {
 862     strcpy(highscore[i].Name, EMPTY_PLAYER_NAME);
 863     highscore[i].Score = 0;
 864   }
 865
 866   if (!(file = fopen(filename, "r")))
 867     return;
 868
 869   /* check file identifier */
 870   fgets(cookie, MAX_LINE_LEN, file);
 871   if (strlen(cookie) > 0 && cookie[strlen(cookie) - 1] == '\n')
 872     cookie[strlen(cookie) - 1] = '\0';
 873
 874   if (strcmp(cookie, SCORE_COOKIE) != 0)
 875   {
 876     Error(ERR_WARN, "wrong file identifier of score file '%s'", filename);
 877     fclose(file);
 878     return;
 879   }
 880
 881   for(i=0; i<MAX_SCORE_ENTRIES; i++)
 882   {
 883     fscanf(file, "%d", &highscore[i].Score);
 884     fgets(line, MAX_LINE_LEN, file);
 885
 886     if (line[strlen(line)-1] == '\n')
 887       line[strlen(line)-1] = '\0';
 888
 889     for (line_ptr = line; *line_ptr; line_ptr++)
 890     {
 891       if (*line_ptr != ' ' && *line_ptr != '\t' && *line_ptr != '\0')
 892       {
 893         strncpy(highscore[i].Name, line_ptr, MAX_NAMELEN - 1);
 894         highscore[i].Name[MAX_NAMELEN - 1] = '\0';
 895         break;
 896       }
 897     }
 898   }
 899
 900   fclose(file);
 901 }
 902
 903 void SaveScore(int level_nr)
 904 {
 905   int i;
 906   char *filename = getScoreFilename(level_nr);
 907   FILE *file;
 908
 909   InitScoreDirectory(leveldir[leveldir_nr].filename);
 910
 911   if (!(file = fopen(filename, "w")))
 912   {
 913     Error(ERR_WARN, "cannot save score for level %d", level_nr);
 914     return;
 915   }
 916
 917   fprintf(file, "%s\n\n", SCORE_COOKIE);
 918
 919   for(i=0; i<MAX_SCORE_ENTRIES; i++)
 920     fprintf(file, "%d %s\n", highscore[i].Score, highscore[i].Name);
 921
 922   fclose(file);
 923
 924   chmod(filename, SCORE_PERMS);
 925 }
 926
 927 #define TOKEN_STR_FILE_IDENTIFIER       "file_identifier"
 928 #define TOKEN_STR_LAST_LEVEL_SERIES     "last_level_series"
 929 #define TOKEN_STR_PLAYER_PREFIX         "player_"
 930
 931 #define TOKEN_VALUE_POSITION            30
 932
 933 /* global setup */
 934 #define SETUP_TOKEN_PLAYER_NAME         0
 935 #define SETUP_TOKEN_SOUND               1
 936 #define SETUP_TOKEN_SOUND_LOOPS         2
 937 #define SETUP_TOKEN_SOUND_MUSIC         3
 938 #define SETUP_TOKEN_SOUND_SIMPLE        4
 939 #define SETUP_TOKEN_TOONS               5
 940 #define SETUP_TOKEN_DOUBLE_BUFFERING    6
 941 #define SETUP_TOKEN_SCROLL_DELAY        7
 942 #define SETUP_TOKEN_SOFT_SCROLLING      8
 943 #define SETUP_TOKEN_FADING              9
 944 #define SETUP_TOKEN_AUTORECORD          10
 945 #define SETUP_TOKEN_QUICK_DOORS         11
 946 #define SETUP_TOKEN_TEAM_MODE           12
 947
 948 /* player setup */
 949 #define SETUP_TOKEN_USE_JOYSTICK        13
 950 #define SETUP_TOKEN_JOY_DEVICE_NAME     14
 951 #define SETUP_TOKEN_JOY_XLEFT           15
 952 #define SETUP_TOKEN_JOY_XMIDDLE         16
 953 #define SETUP_TOKEN_JOY_XRIGHT          17
 954 #define SETUP_TOKEN_JOY_YUPPER          18
 955 #define SETUP_TOKEN_JOY_YMIDDLE         19
 956 #define SETUP_TOKEN_JOY_YLOWER          20
 957 #define SETUP_TOKEN_JOY_SNAP            21
 958 #define SETUP_TOKEN_JOY_BOMB            22
 959 #define SETUP_TOKEN_KEY_LEFT            23
 960 #define SETUP_TOKEN_KEY_RIGHT           24
 961 #define SETUP_TOKEN_KEY_UP              25
 962 #define SETUP_TOKEN_KEY_DOWN            26
 963 #define SETUP_TOKEN_KEY_SNAP            27
 964 #define SETUP_TOKEN_KEY_BOMB            28
 965
 966 /* level directory info */
 967 #define LEVELINFO_TOKEN_NAME            29
 968 #define LEVELINFO_TOKEN_AUTHOR          30
 969 #define LEVELINFO_TOKEN_LEVELS          31
 970 #define LEVELINFO_TOKEN_FIRST_LEVEL     32
 971 #define LEVELINFO_TOKEN_SORT_PRIORITY   33
 972 #define LEVELINFO_TOKEN_READONLY        34
 973
 974 #define FIRST_GLOBAL_SETUP_TOKEN        SETUP_TOKEN_PLAYER_NAME
 975 #define LAST_GLOBAL_SETUP_TOKEN         SETUP_TOKEN_TEAM_MODE
 976
 977 #define FIRST_PLAYER_SETUP_TOKEN        SETUP_TOKEN_USE_JOYSTICK
 978 #define LAST_PLAYER_SETUP_TOKEN         SETUP_TOKEN_KEY_BOMB
 979
 980 #define FIRST_LEVELINFO_TOKEN           LEVELINFO_TOKEN_NAME
 981 #define LAST_LEVELINFO_TOKEN            LEVELINFO_TOKEN_READONLY
 982
 983 #define TYPE_BOOLEAN                    1
 984 #define TYPE_SWITCH                     2
 985 #define TYPE_KEYSYM                     3
 986 #define TYPE_INTEGER                    4
 987 #define TYPE_STRING                     5
 988
 989 static struct SetupInfo si;
 990 static struct SetupInputInfo sii;
 991 static struct LevelDirInfo ldi;
 992 static struct
 993 {
 994   int type;
 995   void *value;
 996   char *text;
 997 } token_info[] =
 998 {
 999   /* global setup */
1000   { TYPE_STRING,  &si.player_name,      "player_name"                   },
1001   { TYPE_SWITCH,  &si.sound,            "sound"                         },
1002   { TYPE_SWITCH,  &si.sound_loops,      "repeating_sound_loops"         },
1003   { TYPE_SWITCH,  &si.sound_music,      "background_music"              },
1004   { TYPE_SWITCH,  &si.sound_simple,     "simple_sound_effects"          },
1005   { TYPE_SWITCH,  &si.toons,            "toons"                         },
1006   { TYPE_SWITCH,  &si.double_buffering, "double_buffering"              },
1007   { TYPE_SWITCH,  &si.scroll_delay,     "scroll_delay"                  },
1008   { TYPE_SWITCH,  &si.soft_scrolling,   "soft_scrolling"                },
1009   { TYPE_SWITCH,  &si.fading,           "screen_fading"                 },
1010   { TYPE_SWITCH,  &si.autorecord,       "automatic_tape_recording"      },
1011   { TYPE_SWITCH,  &si.quick_doors,      "quick_doors"                   },
1012   { TYPE_SWITCH,  &si.team_mode,        "team_mode"                     },
1013
1014   /* player setup */
1015   { TYPE_BOOLEAN, &sii.use_joystick,    ".use_joystick"                 },
1016   { TYPE_STRING,  &sii.joy.device_name, ".joy.device_name"              },
1017   { TYPE_INTEGER, &sii.joy.xleft,       ".joy.xleft"                    },
1018   { TYPE_INTEGER, &sii.joy.xmiddle,     ".joy.xmiddle"                  },
1019   { TYPE_INTEGER, &sii.joy.xright,      ".joy.xright"                   },
1020   { TYPE_INTEGER, &sii.joy.yupper,      ".joy.yupper"                   },
1021   { TYPE_INTEGER, &sii.joy.ymiddle,     ".joy.ymiddle"                  },
1022   { TYPE_INTEGER, &sii.joy.ylower,      ".joy.ylower"                   },
1023   { TYPE_INTEGER, &sii.joy.snap,        ".joy.snap_field"               },
1024   { TYPE_INTEGER, &sii.joy.bomb,        ".joy.place_bomb"               },
1025   { TYPE_KEYSYM,  &sii.key.left,        ".key.move_left"                },
1026   { TYPE_KEYSYM,  &sii.key.right,       ".key.move_right"               },
1027   { TYPE_KEYSYM,  &sii.key.up,          ".key.move_up"                  },
1028   { TYPE_KEYSYM,  &sii.key.down,        ".key.move_down"                },
1029   { TYPE_KEYSYM,  &sii.key.snap,        ".key.snap_field"               },
1030   { TYPE_KEYSYM,  &sii.key.bomb,        ".key.place_bomb"               },
1031
1032   /* level directory info */
1033   { TYPE_STRING,  &ldi.name,            "name"                          },
1034   { TYPE_STRING,  &ldi.author,          "author"                        },
1035   { TYPE_INTEGER, &ldi.levels,          "levels"                        },
1036   { TYPE_INTEGER, &ldi.first_level,     "first_level"                   },
1037   { TYPE_INTEGER, &ldi.sort_priority,   "sort_priority"                 },
1038   { TYPE_BOOLEAN, &ldi.readonly,        "readonly"                      }
1039 };
1040
1041 static char *string_tolower(char *s)
1042 {
1043   static char s_lower[100];
1044   int i;
1045
1046   if (strlen(s) >= 100)
1047     return s;
1048
1049   strcpy(s_lower, s);
1050
1051   for (i=0; i<strlen(s_lower); i++)
1052     s_lower[i] = tolower(s_lower[i]);
1053
1054   return s_lower;
1055 }
1056
1057 static int get_string_integer_value(char *s)
1058 {
1059   static char *number_text[][3] =
1060   {
1061     { "0", "zero", "null", },
1062     { "1", "one", "first" },
1063     { "2", "two", "second" },
1064     { "3", "three", "third" },
1065     { "4", "four", "fourth" },
1066     { "5", "five", "fifth" },
1067     { "6", "six", "sixth" },
1068     { "7", "seven", "seventh" },
1069     { "8", "eight", "eighth" },
1070     { "9", "nine", "ninth" },
1071     { "10", "ten", "tenth" },
1072     { "11", "eleven", "eleventh" },
1073     { "12", "twelve", "twelfth" },
1074   };
1075
1076   int i, j;
1077
1078   for (i=0; i<13; i++)
1079     for (j=0; j<3; j++)
1080       if (strcmp(string_tolower(s), number_text[i][j]) == 0)
1081         return i;
1082
1083   return atoi(s);
1084 }
1085
1086 static boolean get_string_boolean_value(char *s)
1087 {
1088   if (strcmp(string_tolower(s), "true") == 0 ||
1089       strcmp(string_tolower(s), "yes") == 0 ||
1090       strcmp(string_tolower(s), "on") == 0 ||
1091       get_string_integer_value(s) == 1)
1092     return TRUE;
1093   else
1094     return FALSE;
1095 }
1096
1097 static char *getFormattedSetupEntry(char *token, char *value)
1098 {
1099   int i;
1100   static char entry[MAX_LINE_LEN];
1101
1102   sprintf(entry, "%s:", token);
1103   for (i=strlen(entry); i<TOKEN_VALUE_POSITION; i++)
1104     entry[i] = ' ';
1105   entry[i] = '\0';
1106
1107   strcat(entry, value);
1108
1109   return entry;
1110 }
1111
1112 static void freeSetupFileList(struct SetupFileList *setup_file_list)
1113 {
1114   if (!setup_file_list)
1115     return;
1116
1117   if (setup_file_list->token)
1118     free(setup_file_list->token);
1119   if (setup_file_list->value)
1120     free(setup_file_list->value);
1121   if (setup_file_list->next)
1122     freeSetupFileList(setup_file_list->next);
1123   free(setup_file_list);
1124 }
1125
1126 static struct SetupFileList *newSetupFileList(char *token, char *value)
1127 {
1128   struct SetupFileList *new = checked_malloc(sizeof(struct SetupFileList));
1129
1130   new->token = checked_malloc(strlen(token) + 1);
1131   strcpy(new->token, token);
1132
1133   new->value = checked_malloc(strlen(value) + 1);
1134   strcpy(new->value, value);
1135
1136   new->next = NULL;
1137
1138   return new;
1139 }
1140
1141 static char *getTokenValue(struct SetupFileList *setup_file_list,
1142                            char *token)
1143 {
1144   if (!setup_file_list)
1145     return NULL;
1146
1147   if (strcmp(setup_file_list->token, token) == 0)
1148     return setup_file_list->value;
1149   else
1150     return getTokenValue(setup_file_list->next, token);
1151 }
1152
1153 static void setTokenValue(struct SetupFileList *setup_file_list,
1154                           char *token, char *value)
1155 {
1156   if (!setup_file_list)
1157     return;
1158
1159   if (strcmp(setup_file_list->token, token) == 0)
1160   {
1161     free(setup_file_list->value);
1162     setup_file_list->value = checked_malloc(strlen(value) + 1);
1163     strcpy(setup_file_list->value, value);
1164   }
1165   else if (setup_file_list->next == NULL)
1166     setup_file_list->next = newSetupFileList(token, value);
1167   else
1168     setTokenValue(setup_file_list->next, token, value);
1169 }
1170
1171 #ifdef DEBUG
1172 static void printSetupFileList(struct SetupFileList *setup_file_list)
1173 {
1174   if (!setup_file_list)
1175     return;
1176
1177   printf("token: '%s'\n", setup_file_list->token);
1178   printf("value: '%s'\n", setup_file_list->value);
1179
1180   printSetupFileList(setup_file_list->next);
1181 }
1182 #endif
1183
1184 static struct SetupFileList *loadSetupFileList(char *filename)
1185 {
1186   int line_len;
1187   char line[MAX_LINE_LEN];
1188   char *token, *value, *line_ptr;
1189   struct SetupFileList *setup_file_list = newSetupFileList("", "");
1190   struct SetupFileList *first_valid_list_entry;
1191
1192   FILE *file;
1193
1194   if (!(file = fopen(filename, "r")))
1195   {
1196     Error(ERR_WARN, "cannot open configuration file '%s'", filename);
1197     return NULL;
1198   }
1199
1200   while(!feof(file))
1201   {
1202     /* read next line of input file */
1203     if (!fgets(line, MAX_LINE_LEN, file))
1204       break;
1205
1206     /* cut trailing comment or whitespace from input line */
1207     for (line_ptr = line; *line_ptr; line_ptr++)
1208     {
1209       if (*line_ptr == '#' || *line_ptr == '\n' || *line_ptr == '\r')
1210       {
1211         *line_ptr = '\0';
1212         break;
1213       }
1214     }
1215
1216     /* cut trailing whitespaces from input line */
1217     for (line_ptr = &line[strlen(line)]; line_ptr > line; line_ptr--)
1218       if ((*line_ptr == ' ' || *line_ptr == '\t') && line_ptr[1] == '\0')
1219         *line_ptr = '\0';
1220
1221     /* ignore empty lines */
1222     if (*line == '\0')
1223       continue;
1224
1225     line_len = strlen(line);
1226
1227     /* cut leading whitespaces from token */
1228     for (token = line; *token; token++)
1229       if (*token != ' ' && *token != '\t')
1230         break;
1231
1232     /* find end of token */
1233     for (line_ptr = token; *line_ptr; line_ptr++)
1234     {
1235       if (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == ':')
1236       {
1237         *line_ptr = '\0';
1238         break;
1239       }
1240     }
1241
1242     if (line_ptr < line + line_len)
1243       value = line_ptr + 1;
1244     else
1245       value = "\0";
1246
1247     /* cut leading whitespaces from value */
1248     for (; *value; value++)
1249       if (*value != ' ' && *value != '\t')
1250         break;
1251
1252     if (*token && *value)
1253       setTokenValue(setup_file_list, token, value);
1254   }
1255
1256   fclose(file);
1257
1258   first_valid_list_entry = setup_file_list->next;
1259
1260   /* free empty list header */
1261   setup_file_list->next = NULL;
1262   freeSetupFileList(setup_file_list);
1263
1264   if (first_valid_list_entry == NULL)
1265     Error(ERR_WARN, "configuration file '%s' is empty", filename);
1266
1267   return first_valid_list_entry;
1268 }
1269
1270 static void checkSetupFileListIdentifier(struct SetupFileList *setup_file_list,
1271                                          char *identifier)
1272 {
1273   if (!setup_file_list)
1274     return;
1275
1276   if (strcmp(setup_file_list->token, TOKEN_STR_FILE_IDENTIFIER) == 0)
1277   {
1278     if (strcmp(setup_file_list->value, identifier) != 0)
1279     {
1280       Error(ERR_WARN, "configuration file has wrong version");
1281       return;
1282     }
1283     else
1284       return;
1285   }
1286
1287   if (setup_file_list->next)
1288     checkSetupFileListIdentifier(setup_file_list->next, identifier);
1289   else
1290   {
1291     Error(ERR_WARN, "configuration file has no version information");
1292     return;
1293   }
1294 }
1295
1296 static void setLevelDirInfoToDefaults(struct LevelDirInfo *ldi)
1297 {
1298   ldi->name = getStringCopy(ANONYMOUS_NAME);
1299   ldi->author = getStringCopy(ANONYMOUS_NAME);
1300   ldi->levels = 0;
1301   ldi->first_level = 0;
1302   ldi->sort_priority = LEVELCLASS_UNDEFINED;    /* default: least priority */
1303   ldi->readonly = TRUE;
1304 }
1305
1306 static void setSetupInfoToDefaults(struct SetupInfo *si)
1307 {
1308   int i;
1309
1310   si->player_name = getStringCopy(getLoginName());
1311
1312   si->sound = TRUE;
1313   si->sound_loops = TRUE;
1314   si->sound_music = TRUE;
1315   si->sound_simple = TRUE;
1316   si->toons = TRUE;
1317   si->double_buffering = TRUE;
1318   si->direct_draw = !si->double_buffering;
1319   si->scroll_delay = TRUE;
1320   si->soft_scrolling = TRUE;
1321   si->fading = FALSE;
1322   si->autorecord = TRUE;
1323   si->quick_doors = FALSE;
1324
1325   for (i=0; i<MAX_PLAYERS; i++)
1326   {
1327     si->input[i].use_joystick = FALSE;
1328     si->input[i].joy.device_name = getStringCopy(joystick_device_name[i]);
1329     si->input[i].joy.xleft   = JOYSTICK_XLEFT;
1330     si->input[i].joy.xmiddle = JOYSTICK_XMIDDLE;
1331     si->input[i].joy.xright  = JOYSTICK_XRIGHT;
1332     si->input[i].joy.yupper  = JOYSTICK_YUPPER;
1333     si->input[i].joy.ymiddle = JOYSTICK_YMIDDLE;
1334     si->input[i].joy.ylower  = JOYSTICK_YLOWER;
1335     si->input[i].joy.snap  = (i == 0 ? JOY_BUTTON_1 : 0);
1336     si->input[i].joy.bomb  = (i == 0 ? JOY_BUTTON_2 : 0);
1337     si->input[i].key.left  = (i == 0 ? DEFAULT_KEY_LEFT  : KEY_UNDEFINDED);
1338     si->input[i].key.right = (i == 0 ? DEFAULT_KEY_RIGHT : KEY_UNDEFINDED);
1339     si->input[i].key.up    = (i == 0 ? DEFAULT_KEY_UP    : KEY_UNDEFINDED);
1340     si->input[i].key.down  = (i == 0 ? DEFAULT_KEY_DOWN  : KEY_UNDEFINDED);
1341     si->input[i].key.snap  = (i == 0 ? DEFAULT_KEY_SNAP  : KEY_UNDEFINDED);
1342     si->input[i].key.bomb  = (i == 0 ? DEFAULT_KEY_BOMB  : KEY_UNDEFINDED);
1343   }
1344 }
1345
1346 static void setSetupInfo(int token_nr, char *token_value)
1347 {
1348   int token_type = token_info[token_nr].type;
1349   void *setup_value = token_info[token_nr].value;
1350
1351   if (token_value == NULL)
1352     return;
1353
1354   /* set setup field to corresponding token value */
1355   switch (token_type)
1356   {
1357     case TYPE_BOOLEAN:
1358     case TYPE_SWITCH:
1359       *(boolean *)setup_value = get_string_boolean_value(token_value);
1360       break;
1361
1362     case TYPE_KEYSYM:
1363       *(KeySym *)setup_value = getKeySymFromX11KeyName(token_value);
1364       break;
1365
1366     case TYPE_INTEGER:
1367       *(int *)setup_value = get_string_integer_value(token_value);
1368       break;
1369
1370     case TYPE_STRING:
1371       if (*(char **)setup_value != NULL)
1372         free(*(char **)setup_value);
1373       *(char **)setup_value = getStringCopy(token_value);
1374       break;
1375
1376     default:
1377       break;
1378   }
1379 }
1380
1381 static void decodeSetupFileList(struct SetupFileList *setup_file_list)
1382 {
1383   int i, pnr;
1384
1385   if (!setup_file_list)
1386     return;
1387
1388   /* handle global setup values */
1389   si = setup;
1390   for (i=FIRST_GLOBAL_SETUP_TOKEN; i<=LAST_GLOBAL_SETUP_TOKEN; i++)
1391     setSetupInfo(i, getTokenValue(setup_file_list, token_info[i].text));
1392   setup = si;
1393
1394   /* handle player specific setup values */
1395   for (pnr=0; pnr<MAX_PLAYERS; pnr++)
1396   {
1397     char prefix[30];
1398
1399     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
1400
1401     sii = setup.input[pnr];
1402     for (i=FIRST_PLAYER_SETUP_TOKEN; i<=LAST_PLAYER_SETUP_TOKEN; i++)
1403     {
1404       char full_token[100];
1405
1406       sprintf(full_token, "%s%s", prefix, token_info[i].text);
1407       setSetupInfo(i, getTokenValue(setup_file_list, full_token));
1408     }
1409     setup.input[pnr] = sii;
1410   }
1411 }
1412
1413 int getLevelSeriesNrFromLevelSeriesName(char *level_series_name)
1414 {
1415   int i;
1416
1417   if (!level_series_name)
1418     return 0;
1419
1420   for (i=0; i<num_leveldirs; i++)
1421     if (strcmp(level_series_name, leveldir[i].filename) == 0)
1422       return i;
1423
1424   return 0;
1425 }
1426
1427 int getLastPlayedLevelOfLevelSeries(char *level_series_name)
1428 {
1429   char *token_value;
1430   int level_series_nr = getLevelSeriesNrFromLevelSeriesName(level_series_name);
1431   int last_level_nr = leveldir[level_series_nr].first_level;
1432
1433   if (!level_series_name)
1434     return 0;
1435
1436   token_value = getTokenValue(level_setup_list, level_series_name);
1437
1438   if (token_value)
1439   {
1440     last_level_nr = atoi(token_value);
1441
1442     if (last_level_nr < leveldir[level_series_nr].first_level)
1443       last_level_nr = leveldir[level_series_nr].first_level;
1444     if (last_level_nr > leveldir[level_series_nr].last_level)
1445       last_level_nr = leveldir[level_series_nr].last_level;
1446   }
1447
1448   return last_level_nr;
1449 }
1450
1451 static int compareLevelDirInfoEntries(const void *object1, const void *object2)
1452 {
1453   const struct LevelDirInfo *entry1 = object1;
1454   const struct LevelDirInfo *entry2 = object2;
1455   int compare_result;
1456
1457   if (entry1->sort_priority != entry2->sort_priority)
1458     compare_result = entry1->sort_priority - entry2->sort_priority;
1459   else
1460   {
1461     char *name1 = getStringToLower(entry1->name);
1462     char *name2 = getStringToLower(entry2->name);
1463
1464     compare_result = strcmp(name1, name2);
1465
1466     free(name1);
1467     free(name2);
1468   }
1469
1470   return compare_result;
1471 }
1472
1473 static int LoadLevelInfoFromLevelDir(char *level_directory, int start_entry)
1474 {
1475   DIR *dir;
1476   struct stat file_status;
1477   char *directory = NULL;
1478   char *filename = NULL;
1479   struct SetupFileList *setup_file_list = NULL;
1480   struct dirent *dir_entry;
1481   int i, current_entry = start_entry;
1482
1483   if ((dir = opendir(level_directory)) == NULL)
1484   {
1485     Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
1486     return current_entry;
1487   }
1488
1489   while (current_entry < MAX_LEVDIR_ENTRIES)
1490   {
1491     if ((dir_entry = readdir(dir)) == NULL)     /* last directory entry */
1492       break;
1493
1494     /* skip entries for current and parent directory */
1495     if (strcmp(dir_entry->d_name, ".")  == 0 ||
1496         strcmp(dir_entry->d_name, "..") == 0)
1497       continue;
1498
1499     /* find out if directory entry is itself a directory */
1500     directory = getPath2(level_directory, dir_entry->d_name);
1501     if (stat(directory, &file_status) != 0 ||           /* cannot stat file */
1502         (file_status.st_mode & S_IFMT) != S_IFDIR)      /* not a directory */
1503     {
1504       free(directory);
1505       continue;
1506     }
1507
1508     filename = getPath2(directory, LEVELINFO_FILENAME);
1509     setup_file_list = loadSetupFileList(filename);
1510
1511     if (setup_file_list)
1512     {
1513       checkSetupFileListIdentifier(setup_file_list, LEVELINFO_COOKIE);
1514       setLevelDirInfoToDefaults(&leveldir[current_entry]);
1515
1516       ldi = leveldir[current_entry];
1517       for (i=FIRST_LEVELINFO_TOKEN; i<=LAST_LEVELINFO_TOKEN; i++)
1518         setSetupInfo(i, getTokenValue(setup_file_list, token_info[i].text));
1519       leveldir[current_entry] = ldi;
1520
1521       leveldir[current_entry].filename = getStringCopy(dir_entry->d_name);
1522       leveldir[current_entry].last_level =
1523         leveldir[current_entry].first_level +
1524         leveldir[current_entry].levels - 1;
1525       leveldir[current_entry].user_defined =
1526         (level_directory == options.level_directory ? FALSE : TRUE);
1527       leveldir[current_entry].color = LEVELCOLOR(current_entry);
1528
1529       freeSetupFileList(setup_file_list);
1530       current_entry++;
1531     }
1532     else
1533       Error(ERR_WARN, "ignoring level directory '%s'", directory);
1534
1535     free(directory);
1536     free(filename);
1537   }
1538
1539   if (current_entry == MAX_LEVDIR_ENTRIES)
1540     Error(ERR_WARN, "using %d level directories -- ignoring the rest",
1541           current_entry);
1542
1543   closedir(dir);
1544
1545   if (current_entry == start_entry)
1546     Error(ERR_WARN, "cannot find any valid level series in directory '%s'",
1547           level_directory);
1548
1549   return current_entry;
1550 }
1551
1552 void LoadLevelInfo()
1553 {
1554   InitUserLevelDirectory(getLoginName());
1555
1556   num_leveldirs = 0;
1557   leveldir_nr = 0;
1558
1559   num_leveldirs = LoadLevelInfoFromLevelDir(options.level_directory,
1560                                             num_leveldirs);
1561   num_leveldirs = LoadLevelInfoFromLevelDir(getUserLevelDir(""),
1562                                             num_leveldirs);
1563
1564   if (num_leveldirs == 0)
1565     Error(ERR_EXIT, "cannot find any valid level series in any directory");
1566
1567   if (num_leveldirs > 1)
1568     qsort(leveldir, num_leveldirs, sizeof(struct LevelDirInfo),
1569           compareLevelDirInfoEntries);
1570 }
1571
1572 static void SaveUserLevelInfo()
1573 {
1574   char *filename;
1575   FILE *file;
1576   int i;
1577
1578   filename = getPath2(getUserLevelDir(getLoginName()), LEVELINFO_FILENAME);
1579
1580   if (!(file = fopen(filename, "w")))
1581   {
1582     Error(ERR_WARN, "cannot write level info file '%s'", filename);
1583     free(filename);
1584     return;
1585   }
1586
1587   /* always start with reliable default values */
1588   setLevelDirInfoToDefaults(&ldi);
1589
1590   ldi.name = getLoginName();
1591   ldi.author = getRealName();
1592   ldi.levels = 100;
1593   ldi.first_level = 1;
1594   ldi.sort_priority = LEVELCLASS_USER_START;
1595   ldi.readonly = FALSE;
1596
1597   fprintf(file, "%s\n\n",
1598           getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER, LEVELINFO_COOKIE));
1599
1600   for (i=FIRST_LEVELINFO_TOKEN; i<=LAST_LEVELINFO_TOKEN; i++)
1601     fprintf(file, "%s\n", getSetupLine("", i));
1602
1603   fclose(file);
1604   free(filename);
1605
1606   chmod(filename, SETUP_PERMS);
1607 }
1608
1609 void LoadSetup()
1610 {
1611   char *filename;
1612   struct SetupFileList *setup_file_list = NULL;
1613
1614   /* always start with reliable default values */
1615   setSetupInfoToDefaults(&setup);
1616
1617   filename = getPath2(getSetupDir(), SETUP_FILENAME);
1618
1619   setup_file_list = loadSetupFileList(filename);
1620
1621   if (setup_file_list)
1622   {
1623     checkSetupFileListIdentifier(setup_file_list, SETUP_COOKIE);
1624     decodeSetupFileList(setup_file_list);
1625
1626     setup.direct_draw = !setup.double_buffering;
1627
1628     freeSetupFileList(setup_file_list);
1629
1630     /* needed to work around problems with fixed length strings */
1631     if (strlen(setup.player_name) >= MAX_NAMELEN)
1632       setup.player_name[MAX_NAMELEN - 1] = '\0';
1633     else if (strlen(setup.player_name) < MAX_NAMELEN - 1)
1634     {
1635       char *new_name = checked_malloc(MAX_NAMELEN);
1636
1637       strcpy(new_name, setup.player_name);
1638       free(setup.player_name);
1639       setup.player_name = new_name;
1640     }
1641   }
1642   else
1643     Error(ERR_WARN, "using default setup values");
1644
1645   free(filename);
1646 }
1647
1648 static char *getSetupLine(char *prefix, int token_nr)
1649 {
1650   int i;
1651   static char entry[MAX_LINE_LEN];
1652   int token_type = token_info[token_nr].type;
1653   void *setup_value = token_info[token_nr].value;
1654   char *token_text = token_info[token_nr].text;
1655
1656   /* start with the prefix, token and some spaces to format output line */
1657   sprintf(entry, "%s%s:", prefix, token_text);
1658   for (i=strlen(entry); i<TOKEN_VALUE_POSITION; i++)
1659     strcat(entry, " ");
1660
1661   /* continue with the token's value (which can have different types) */
1662   switch (token_type)
1663   {
1664     case TYPE_BOOLEAN:
1665       strcat(entry, (*(boolean *)setup_value ? "true" : "false"));
1666       break;
1667
1668     case TYPE_SWITCH:
1669       strcat(entry, (*(boolean *)setup_value ? "on" : "off"));
1670       break;
1671
1672     case TYPE_KEYSYM:
1673       {
1674         KeySym keysym = *(KeySym *)setup_value;
1675         char *keyname = getKeyNameFromKeySym(keysym);
1676
1677         strcat(entry, getX11KeyNameFromKeySym(keysym));
1678         for (i=strlen(entry); i<50; i++)
1679           strcat(entry, " ");
1680
1681         /* add comment, if useful */
1682         if (strcmp(keyname, "(undefined)") != 0 &&
1683             strcmp(keyname, "(unknown)") != 0)
1684         {
1685           strcat(entry, "# ");
1686           strcat(entry, keyname);
1687         }
1688       }
1689       break;
1690
1691     case TYPE_INTEGER:
1692       {
1693         char buffer[MAX_LINE_LEN];
1694
1695         sprintf(buffer, "%d", *(int *)setup_value);
1696         strcat(entry, buffer);
1697       }
1698       break;
1699
1700     case TYPE_STRING:
1701       strcat(entry, *(char **)setup_value);
1702       break;
1703
1704     default:
1705       break;
1706   }
1707
1708   return entry;
1709 }
1710
1711 void SaveSetup()
1712 {
1713   int i, pnr;
1714   char *filename;
1715   FILE *file;
1716
1717   InitUserDataDirectory();
1718
1719   filename = getPath2(getSetupDir(), SETUP_FILENAME);
1720
1721   if (!(file = fopen(filename, "w")))
1722   {
1723     Error(ERR_WARN, "cannot write setup file '%s'", filename);
1724     free(filename);
1725     return;
1726   }
1727
1728   fprintf(file, "%s\n",
1729           getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER, SETUP_COOKIE));
1730   fprintf(file, "\n");
1731
1732   /* handle global setup values */
1733   si = setup;
1734   for (i=FIRST_GLOBAL_SETUP_TOKEN; i<=LAST_GLOBAL_SETUP_TOKEN; i++)
1735   {
1736     fprintf(file, "%s\n", getSetupLine("", i));
1737
1738     /* just to make things nicer :) */
1739     if (i == SETUP_TOKEN_PLAYER_NAME)
1740       fprintf(file, "\n");
1741   }
1742
1743   /* handle player specific setup values */
1744   for (pnr=0; pnr<MAX_PLAYERS; pnr++)
1745   {
1746     char prefix[30];
1747
1748     sprintf(prefix, "%s%d", TOKEN_STR_PLAYER_PREFIX, pnr + 1);
1749     fprintf(file, "\n");
1750
1751     sii = setup.input[pnr];
1752     for (i=FIRST_PLAYER_SETUP_TOKEN; i<=LAST_PLAYER_SETUP_TOKEN; i++)
1753       fprintf(file, "%s\n", getSetupLine(prefix, i));
1754   }
1755
1756   fclose(file);
1757   free(filename);
1758
1759   chmod(filename, SETUP_PERMS);
1760 }
1761
1762 void LoadLevelSetup()
1763 {
1764   char *filename;
1765
1766   /* always start with reliable default values */
1767   leveldir_nr = 0;
1768   level_nr = 0;
1769
1770   filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
1771
1772   if (level_setup_list)
1773     freeSetupFileList(level_setup_list);
1774
1775   level_setup_list = loadSetupFileList(filename);
1776
1777   if (level_setup_list)
1778   {
1779     char *last_level_series =
1780       getTokenValue(level_setup_list, TOKEN_STR_LAST_LEVEL_SERIES);
1781
1782     leveldir_nr = getLevelSeriesNrFromLevelSeriesName(last_level_series);
1783     level_nr = getLastPlayedLevelOfLevelSeries(last_level_series);
1784
1785     checkSetupFileListIdentifier(level_setup_list, LEVELSETUP_COOKIE);
1786   }
1787   else
1788   {
1789     level_setup_list = newSetupFileList(TOKEN_STR_FILE_IDENTIFIER,
1790                                         LEVELSETUP_COOKIE);
1791     Error(ERR_WARN, "using default setup values");
1792   }
1793
1794   free(filename);
1795 }
1796
1797 void SaveLevelSetup()
1798 {
1799   char *filename;
1800   struct SetupFileList *list_entry = level_setup_list;
1801   FILE *file;
1802
1803   InitUserDataDirectory();
1804
1805   setTokenValue(level_setup_list,
1806                 TOKEN_STR_LAST_LEVEL_SERIES, leveldir[leveldir_nr].filename);
1807
1808   setTokenValue(level_setup_list,
1809                 leveldir[leveldir_nr].filename, int2str(level_nr, 0));
1810
1811   filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
1812
1813   if (!(file = fopen(filename, "w")))
1814   {
1815     Error(ERR_WARN, "cannot write setup file '%s'", filename);
1816     free(filename);
1817     return;
1818   }
1819
1820   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
1821                                                  LEVELSETUP_COOKIE));
1822   while (list_entry)
1823   {
1824     if (strcmp(list_entry->token, TOKEN_STR_FILE_IDENTIFIER) != 0)
1825       fprintf(file, "%s\n",
1826               getFormattedSetupEntry(list_entry->token, list_entry->value));
1827
1828     /* just to make things nicer :) */
1829     if (strcmp(list_entry->token, TOKEN_STR_LAST_LEVEL_SERIES) == 0)
1830       fprintf(file, "\n");
1831
1832     list_entry = list_entry->next;
1833   }
1834
1835   fclose(file);
1836   free(filename);
1837
1838   chmod(filename, SETUP_PERMS);
1839 }
1840
1841 #ifdef MSDOS
1842 static boolean initErrorFile()
1843 {
1844   char *filename;
1845   FILE *error_file;
1846
1847   InitUserDataDirectory();
1848
1849   filename = getPath2(getUserDataDir(), ERROR_FILENAME);
1850   error_file = fopen(filename, "w");
1851   free(filename);
1852
1853   if (error_file == NULL)
1854     return FALSE;
1855
1856   fclose(error_file);
1857
1858   return TRUE;
1859 }
1860
1861 FILE *openErrorFile()
1862 {
1863   static boolean first_access = TRUE;
1864   char *filename;
1865   FILE *error_file;
1866
1867   if (first_access)
1868   {
1869     if (!initErrorFile())
1870       return NULL;
1871
1872     first_access = FALSE;
1873   }
1874
1875   filename = getPath2(getUserDataDir(), ERROR_FILENAME);
1876   error_file = fopen(filename, "a");
1877   free(filename);
1878
1879   return error_file;
1880 }
1881
1882 void dumpErrorFile()
1883 {
1884   char *filename;
1885   FILE *error_file;
1886
1887   filename = getPath2(getUserDataDir(), ERROR_FILENAME);
1888   error_file = fopen(filename, "r");
1889   free(filename);
1890
1891   if (error_file != NULL)
1892   {
1893     while (!feof(error_file))
1894       fputc(fgetc(error_file), stderr);
1895
1896     fclose(error_file);
1897   }
1898 }
1899 #endif