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