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