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