src/libgame/setup.c

   1 /***********************************************************
   2 * Artsoft Retro-Game Library                               *
   3 *----------------------------------------------------------*
   4 * (c) 1994-2002 Artsoft Entertainment                      *
   5 *               Holger Schemel                             *
   6 *               Detmolder Strasse 189                      *
   7 *               33604 Bielefeld                            *
   8 *               Germany                                    *
   9 *               e-mail: info@artsoft.org                   *
  10 *----------------------------------------------------------*
  11 * setup.c                                                  *
  12 ***********************************************************/
  13
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16 #include <dirent.h>
  17 #include <string.h>
  18 #include <unistd.h>
  19
  20 #include "setup.h"
  21 #include "joystick.h"
  22 #include "text.h"
  23 #include "misc.h"
  24 #include "hash.h"
  25
  26
  27 #define NUM_LEVELCLASS_DESC     8
  28
  29 static char *levelclass_desc[NUM_LEVELCLASS_DESC] =
  30 {
  31   "Tutorial Levels",
  32   "Classic Originals",
  33   "Contributions",
  34   "Private Levels",
  35   "Boulderdash",
  36   "Emerald Mine",
  37   "Supaplex",
  38   "DX Boulderdash"
  39 };
  40
  41
  42 #define LEVELCOLOR(n)   (IS_LEVELCLASS_TUTORIAL(n) ?            FC_BLUE :    \
  43                          IS_LEVELCLASS_CLASSICS(n) ?            FC_RED :     \
  44                          IS_LEVELCLASS_BD(n) ?                  FC_YELLOW :  \
  45                          IS_LEVELCLASS_EM(n) ?                  FC_YELLOW :  \
  46                          IS_LEVELCLASS_SP(n) ?                  FC_YELLOW :  \
  47                          IS_LEVELCLASS_DX(n) ?                  FC_YELLOW :  \
  48                          IS_LEVELCLASS_SB(n) ?                  FC_YELLOW :  \
  49                          IS_LEVELCLASS_CONTRIB(n) ?             FC_GREEN :   \
  50                          IS_LEVELCLASS_PRIVATE(n) ?             FC_RED :     \
  51                          FC_BLUE)
  52
  53 #define LEVELSORTING(n) (IS_LEVELCLASS_TUTORIAL(n) ?            0 :     \
  54                          IS_LEVELCLASS_CLASSICS(n) ?            1 :     \
  55                          IS_LEVELCLASS_BD(n) ?                  2 :     \
  56                          IS_LEVELCLASS_EM(n) ?                  3 :     \
  57                          IS_LEVELCLASS_SP(n) ?                  4 :     \
  58                          IS_LEVELCLASS_DX(n) ?                  5 :     \
  59                          IS_LEVELCLASS_SB(n) ?                  6 :     \
  60                          IS_LEVELCLASS_CONTRIB(n) ?             7 :     \
  61                          IS_LEVELCLASS_PRIVATE(n) ?             8 :     \
  62                          9)
  63
  64 #define ARTWORKCOLOR(n) (IS_ARTWORKCLASS_CLASSICS(n) ?          FC_RED :     \
  65                          IS_ARTWORKCLASS_CONTRIB(n) ?           FC_GREEN :   \
  66                          IS_ARTWORKCLASS_PRIVATE(n) ?           FC_RED :     \
  67                          IS_ARTWORKCLASS_LEVEL(n) ?             FC_YELLOW :  \
  68                          FC_BLUE)
  69
  70 #define ARTWORKSORTING(n) (IS_ARTWORKCLASS_CLASSICS(n) ?        0 :     \
  71                            IS_ARTWORKCLASS_LEVEL(n) ?           1 :     \
  72                            IS_ARTWORKCLASS_CONTRIB(n) ?         2 :     \
  73                            IS_ARTWORKCLASS_PRIVATE(n) ?         3 :     \
  74                            9)
  75
  76 #define TOKEN_VALUE_POSITION_SHORT              32
  77 #define TOKEN_VALUE_POSITION_DEFAULT            40
  78 #define TOKEN_COMMENT_POSITION_DEFAULT          60
  79
  80 #define MAX_COOKIE_LEN                          256
  81
  82 static int token_value_position   = TOKEN_VALUE_POSITION_DEFAULT;
  83 static int token_comment_position = TOKEN_COMMENT_POSITION_DEFAULT;
  84
  85
  86 /* ------------------------------------------------------------------------- */
  87 /* file functions                                                            */
  88 /* ------------------------------------------------------------------------- */
  89
  90 static char *getLevelClassDescription(TreeInfo *ldi)
  91 {
  92   int position = ldi->sort_priority / 100;
  93
  94   if (position >= 0 && position < NUM_LEVELCLASS_DESC)
  95     return levelclass_desc[position];
  96   else
  97     return "Unknown Level Class";
  98 }
  99
 100 static char *getUserLevelDir(char *level_subdir)
 101 {
 102   static char *userlevel_dir = NULL;
 103   char *data_dir = getUserDataDir();
 104   char *userlevel_subdir = LEVELS_DIRECTORY;
 105
 106   checked_free(userlevel_dir);
 107
 108   if (level_subdir != NULL)
 109     userlevel_dir = getPath3(data_dir, userlevel_subdir, level_subdir);
 110   else
 111     userlevel_dir = getPath2(data_dir, userlevel_subdir);
 112
 113   return userlevel_dir;
 114 }
 115
 116 static char *getScoreDir(char *level_subdir)
 117 {
 118   static char *score_dir = NULL;
 119   char *data_dir = getCommonDataDir();
 120   char *score_subdir = SCORES_DIRECTORY;
 121
 122   checked_free(score_dir);
 123
 124   if (level_subdir != NULL)
 125     score_dir = getPath3(data_dir, score_subdir, level_subdir);
 126   else
 127     score_dir = getPath2(data_dir, score_subdir);
 128
 129   return score_dir;
 130 }
 131
 132 static char *getLevelSetupDir(char *level_subdir)
 133 {
 134   static char *levelsetup_dir = NULL;
 135   char *data_dir = getUserDataDir();
 136   char *levelsetup_subdir = LEVELSETUP_DIRECTORY;
 137
 138   checked_free(levelsetup_dir);
 139
 140   if (level_subdir != NULL)
 141     levelsetup_dir = getPath3(data_dir, levelsetup_subdir, level_subdir);
 142   else
 143     levelsetup_dir = getPath2(data_dir, levelsetup_subdir);
 144
 145   return levelsetup_dir;
 146 }
 147
 148 static char *getLevelDirFromTreeInfo(TreeInfo *node)
 149 {
 150   static char *level_dir = NULL;
 151
 152   if (node == NULL)
 153     return options.level_directory;
 154
 155   checked_free(level_dir);
 156
 157   level_dir = getPath2((node->in_user_dir ? getUserLevelDir(NULL) :
 158                         options.level_directory), node->fullpath);
 159
 160   return level_dir;
 161 }
 162
 163 char *getCurrentLevelDir()
 164 {
 165   return getLevelDirFromTreeInfo(leveldir_current);
 166 }
 167
 168 static char *getTapeDir(char *level_subdir)
 169 {
 170   static char *tape_dir = NULL;
 171   char *data_dir = getUserDataDir();
 172   char *tape_subdir = TAPES_DIRECTORY;
 173
 174   checked_free(tape_dir);
 175
 176   if (level_subdir != NULL)
 177     tape_dir = getPath3(data_dir, tape_subdir, level_subdir);
 178   else
 179     tape_dir = getPath2(data_dir, tape_subdir);
 180
 181   return tape_dir;
 182 }
 183
 184 static char *getSolutionTapeDir()
 185 {
 186   static char *tape_dir = NULL;
 187   char *data_dir = getCurrentLevelDir();
 188   char *tape_subdir = TAPES_DIRECTORY;
 189
 190   checked_free(tape_dir);
 191
 192   tape_dir = getPath2(data_dir, tape_subdir);
 193
 194   return tape_dir;
 195 }
 196
 197 static char *getDefaultGraphicsDir(char *graphics_subdir)
 198 {
 199   static char *graphics_dir = NULL;
 200
 201   if (graphics_subdir == NULL)
 202     return options.graphics_directory;
 203
 204   checked_free(graphics_dir);
 205
 206   graphics_dir = getPath2(options.graphics_directory, graphics_subdir);
 207
 208   return graphics_dir;
 209 }
 210
 211 static char *getDefaultSoundsDir(char *sounds_subdir)
 212 {
 213   static char *sounds_dir = NULL;
 214
 215   if (sounds_subdir == NULL)
 216     return options.sounds_directory;
 217
 218   checked_free(sounds_dir);
 219
 220   sounds_dir = getPath2(options.sounds_directory, sounds_subdir);
 221
 222   return sounds_dir;
 223 }
 224
 225 static char *getDefaultMusicDir(char *music_subdir)
 226 {
 227   static char *music_dir = NULL;
 228
 229   if (music_subdir == NULL)
 230     return options.music_directory;
 231
 232   checked_free(music_dir);
 233
 234   music_dir = getPath2(options.music_directory, music_subdir);
 235
 236   return music_dir;
 237 }
 238
 239 static char *getDefaultArtworkSet(int type)
 240 {
 241   return (type == TREE_TYPE_GRAPHICS_DIR ? GFX_CLASSIC_SUBDIR :
 242           type == TREE_TYPE_SOUNDS_DIR   ? SND_CLASSIC_SUBDIR :
 243           type == TREE_TYPE_MUSIC_DIR    ? MUS_CLASSIC_SUBDIR : "");
 244 }
 245
 246 static char *getDefaultArtworkDir(int type)
 247 {
 248   return (type == TREE_TYPE_GRAPHICS_DIR ?
 249           getDefaultGraphicsDir(GFX_CLASSIC_SUBDIR) :
 250           type == TREE_TYPE_SOUNDS_DIR ?
 251           getDefaultSoundsDir(SND_CLASSIC_SUBDIR) :
 252           type == TREE_TYPE_MUSIC_DIR ?
 253           getDefaultMusicDir(MUS_CLASSIC_SUBDIR) : "");
 254 }
 255
 256 static char *getUserGraphicsDir()
 257 {
 258   static char *usergraphics_dir = NULL;
 259
 260   if (usergraphics_dir == NULL)
 261     usergraphics_dir = getPath2(getUserDataDir(), GRAPHICS_DIRECTORY);
 262
 263   return usergraphics_dir;
 264 }
 265
 266 static char *getUserSoundsDir()
 267 {
 268   static char *usersounds_dir = NULL;
 269
 270   if (usersounds_dir == NULL)
 271     usersounds_dir = getPath2(getUserDataDir(), SOUNDS_DIRECTORY);
 272
 273   return usersounds_dir;
 274 }
 275
 276 static char *getUserMusicDir()
 277 {
 278   static char *usermusic_dir = NULL;
 279
 280   if (usermusic_dir == NULL)
 281     usermusic_dir = getPath2(getUserDataDir(), MUSIC_DIRECTORY);
 282
 283   return usermusic_dir;
 284 }
 285
 286 static char *getSetupArtworkDir(TreeInfo *ti)
 287 {
 288   static char *artwork_dir = NULL;
 289
 290   checked_free(artwork_dir);
 291
 292   artwork_dir = getPath2(ti->basepath, ti->fullpath);
 293
 294   return artwork_dir;
 295 }
 296
 297 char *setLevelArtworkDir(TreeInfo *ti)
 298 {
 299   char **artwork_path_ptr, **artwork_set_ptr;
 300   TreeInfo *level_artwork;
 301
 302   if (ti == NULL || leveldir_current == NULL)
 303     return NULL;
 304
 305   artwork_path_ptr = LEVELDIR_ARTWORK_PATH_PTR(leveldir_current, ti->type);
 306   artwork_set_ptr  = LEVELDIR_ARTWORK_SET_PTR( leveldir_current, ti->type);
 307
 308   checked_free(*artwork_path_ptr);
 309
 310   if ((level_artwork = getTreeInfoFromIdentifier(ti, *artwork_set_ptr)))
 311     *artwork_path_ptr = getStringCopy(getSetupArtworkDir(level_artwork));
 312   else
 313   {
 314     /* No (or non-existing) artwork configured in "levelinfo.conf". This would
 315        normally result in using the artwork configured in the setup menu. But
 316        if an artwork subdirectory exists (which might contain custom artwork
 317        or an artwork configuration file), this level artwork must be treated
 318        as relative to the default "classic" artwork, not to the artwork that
 319        is currently configured in the setup menu. */
 320
 321     char *dir = getPath2(getCurrentLevelDir(), ARTWORK_DIRECTORY(ti->type));
 322
 323     checked_free(*artwork_set_ptr);
 324
 325     if (fileExists(dir))
 326     {
 327       *artwork_path_ptr = getStringCopy(getDefaultArtworkDir(ti->type));
 328       *artwork_set_ptr = getStringCopy(getDefaultArtworkSet(ti->type));
 329     }
 330     else
 331     {
 332       *artwork_path_ptr = getStringCopy(UNDEFINED_FILENAME);
 333       *artwork_set_ptr = NULL;
 334     }
 335
 336     free(dir);
 337   }
 338
 339   return *artwork_set_ptr;
 340 }
 341
 342 inline static char *getLevelArtworkSet(int type)
 343 {
 344   if (leveldir_current == NULL)
 345     return NULL;
 346
 347   return LEVELDIR_ARTWORK_SET(leveldir_current, type);
 348 }
 349
 350 inline static char *getLevelArtworkDir(int type)
 351 {
 352   if (leveldir_current == NULL)
 353     return UNDEFINED_FILENAME;
 354
 355   return LEVELDIR_ARTWORK_PATH(leveldir_current, type);
 356 }
 357
 358 char *getTapeFilename(int nr)
 359 {
 360   static char *filename = NULL;
 361   char basename[MAX_FILENAME_LEN];
 362
 363   checked_free(filename);
 364
 365   sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
 366   filename = getPath2(getTapeDir(leveldir_current->subdir), basename);
 367
 368   return filename;
 369 }
 370
 371 char *getSolutionTapeFilename(int nr)
 372 {
 373   static char *filename = NULL;
 374   char basename[MAX_FILENAME_LEN];
 375
 376   checked_free(filename);
 377
 378   sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
 379   filename = getPath2(getSolutionTapeDir(), basename);
 380
 381   return filename;
 382 }
 383
 384 char *getScoreFilename(int nr)
 385 {
 386   static char *filename = NULL;
 387   char basename[MAX_FILENAME_LEN];
 388
 389   checked_free(filename);
 390
 391   sprintf(basename, "%03d.%s", nr, SCOREFILE_EXTENSION);
 392   filename = getPath2(getScoreDir(leveldir_current->subdir), basename);
 393
 394   return filename;
 395 }
 396
 397 char *getSetupFilename()
 398 {
 399   static char *filename = NULL;
 400
 401   checked_free(filename);
 402
 403   filename = getPath2(getSetupDir(), SETUP_FILENAME);
 404
 405   return filename;
 406 }
 407
 408 char *getEditorSetupFilename()
 409 {
 410   static char *filename = NULL;
 411
 412   checked_free(filename);
 413   filename = getPath2(getCurrentLevelDir(), EDITORSETUP_FILENAME);
 414
 415   if (fileExists(filename))
 416     return filename;
 417
 418   checked_free(filename);
 419   filename = getPath2(getSetupDir(), EDITORSETUP_FILENAME);
 420
 421   return filename;
 422 }
 423
 424 char *getHelpAnimFilename()
 425 {
 426   static char *filename = NULL;
 427
 428   checked_free(filename);
 429
 430   filename = getPath2(getCurrentLevelDir(), HELPANIM_FILENAME);
 431
 432   return filename;
 433 }
 434
 435 char *getHelpTextFilename()
 436 {
 437   static char *filename = NULL;
 438
 439   checked_free(filename);
 440
 441   filename = getPath2(getCurrentLevelDir(), HELPTEXT_FILENAME);
 442
 443   return filename;
 444 }
 445
 446 char *getLevelSetInfoFilename()
 447 {
 448   static char *filename = NULL;
 449   char *basenames[] =
 450   {
 451     "README",
 452     "README.TXT",
 453     "README.txt",
 454     "Readme",
 455     "Readme.txt",
 456     "readme",
 457     "readme.txt",
 458
 459     NULL
 460   };
 461   int i;
 462
 463   for (i = 0; basenames[i] != NULL; i++)
 464   {
 465     checked_free(filename);
 466     filename = getPath2(getCurrentLevelDir(), basenames[i]);
 467
 468     if (fileExists(filename))
 469       return filename;
 470   }
 471
 472   return NULL;
 473 }
 474
 475 static char *getCorrectedArtworkBasename(char *basename)
 476 {
 477   char *basename_corrected = basename;
 478
 479 #if defined(PLATFORM_MSDOS)
 480   if (program.filename_prefix != NULL)
 481   {
 482     int prefix_len = strlen(program.filename_prefix);
 483
 484     if (strncmp(basename, program.filename_prefix, prefix_len) == 0)
 485       basename_corrected = &basename[prefix_len];
 486
 487     /* if corrected filename is still longer than standard MS-DOS filename
 488        size (8 characters + 1 dot + 3 characters file extension), shorten
 489        filename by writing file extension after 8th basename character */
 490     if (strlen(basename_corrected) > 8 + 1 + 3)
 491     {
 492       static char *msdos_filename = NULL;
 493
 494       checked_free(msdos_filename);
 495
 496       msdos_filename = getStringCopy(basename_corrected);
 497       strncpy(&msdos_filename[8], &basename[strlen(basename) - (1+3)], 1+3 +1);
 498
 499       basename_corrected = msdos_filename;
 500     }
 501   }
 502 #endif
 503
 504   return basename_corrected;
 505 }
 506
 507 char *getCustomImageFilename(char *basename)
 508 {
 509   static char *filename = NULL;
 510   boolean skip_setup_artwork = FALSE;
 511
 512   checked_free(filename);
 513
 514   basename = getCorrectedArtworkBasename(basename);
 515
 516   if (!setup.override_level_graphics)
 517   {
 518     /* 1st try: look for special artwork in current level series directory */
 519     filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
 520     if (fileExists(filename))
 521       return filename;
 522
 523     free(filename);
 524
 525     /* check if there is special artwork configured in level series config */
 526     if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL)
 527     {
 528       /* 2nd try: look for special artwork configured in level series config */
 529       filename = getPath2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
 530       if (fileExists(filename))
 531         return filename;
 532
 533       free(filename);
 534
 535       /* take missing artwork configured in level set config from default */
 536       skip_setup_artwork = TRUE;
 537     }
 538   }
 539
 540   if (!skip_setup_artwork)
 541   {
 542     /* 3rd try: look for special artwork in configured artwork directory */
 543     filename = getPath2(getSetupArtworkDir(artwork.gfx_current), basename);
 544     if (fileExists(filename))
 545       return filename;
 546
 547     free(filename);
 548   }
 549
 550   /* 4th try: look for default artwork in new default artwork directory */
 551   filename = getPath2(getDefaultGraphicsDir(GFX_CLASSIC_SUBDIR), basename);
 552   if (fileExists(filename))
 553     return filename;
 554
 555   free(filename);
 556
 557   /* 5th try: look for default artwork in old default artwork directory */
 558   filename = getPath2(options.graphics_directory, basename);
 559   if (fileExists(filename))
 560     return filename;
 561
 562   return NULL;          /* cannot find specified artwork file anywhere */
 563 }
 564
 565 char *getCustomSoundFilename(char *basename)
 566 {
 567   static char *filename = NULL;
 568   boolean skip_setup_artwork = FALSE;
 569
 570   checked_free(filename);
 571
 572   basename = getCorrectedArtworkBasename(basename);
 573
 574   if (!setup.override_level_sounds)
 575   {
 576     /* 1st try: look for special artwork in current level series directory */
 577     filename = getPath3(getCurrentLevelDir(), SOUNDS_DIRECTORY, basename);
 578     if (fileExists(filename))
 579       return filename;
 580
 581     free(filename);
 582
 583     /* check if there is special artwork configured in level series config */
 584     if (getLevelArtworkSet(ARTWORK_TYPE_SOUNDS) != NULL)
 585     {
 586       /* 2nd try: look for special artwork configured in level series config */
 587       filename = getPath2(getLevelArtworkDir(TREE_TYPE_SOUNDS_DIR), basename);
 588       if (fileExists(filename))
 589         return filename;
 590
 591       free(filename);
 592
 593       /* take missing artwork configured in level set config from default */
 594       skip_setup_artwork = TRUE;
 595     }
 596   }
 597
 598   if (!skip_setup_artwork)
 599   {
 600     /* 3rd try: look for special artwork in configured artwork directory */
 601     filename = getPath2(getSetupArtworkDir(artwork.snd_current), basename);
 602     if (fileExists(filename))
 603       return filename;
 604
 605     free(filename);
 606   }
 607
 608   /* 4th try: look for default artwork in new default artwork directory */
 609   filename = getPath2(getDefaultSoundsDir(SND_CLASSIC_SUBDIR), basename);
 610   if (fileExists(filename))
 611     return filename;
 612
 613   free(filename);
 614
 615   /* 5th try: look for default artwork in old default artwork directory */
 616   filename = getPath2(options.sounds_directory, basename);
 617   if (fileExists(filename))
 618     return filename;
 619
 620   return NULL;          /* cannot find specified artwork file anywhere */
 621 }
 622
 623 char *getCustomMusicFilename(char *basename)
 624 {
 625   static char *filename = NULL;
 626   boolean skip_setup_artwork = FALSE;
 627
 628   checked_free(filename);
 629
 630   basename = getCorrectedArtworkBasename(basename);
 631
 632   if (!setup.override_level_music)
 633   {
 634     /* 1st try: look for special artwork in current level series directory */
 635     filename = getPath3(getCurrentLevelDir(), MUSIC_DIRECTORY, basename);
 636     if (fileExists(filename))
 637       return filename;
 638
 639     free(filename);
 640
 641     /* check if there is special artwork configured in level series config */
 642     if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
 643     {
 644       /* 2nd try: look for special artwork configured in level series config */
 645       filename = getPath2(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR), basename);
 646       if (fileExists(filename))
 647         return filename;
 648
 649       free(filename);
 650
 651       /* take missing artwork configured in level set config from default */
 652       skip_setup_artwork = TRUE;
 653     }
 654   }
 655
 656   if (!skip_setup_artwork)
 657   {
 658     /* 3rd try: look for special artwork in configured artwork directory */
 659     filename = getPath2(getSetupArtworkDir(artwork.mus_current), basename);
 660     if (fileExists(filename))
 661       return filename;
 662
 663     free(filename);
 664   }
 665
 666   /* 4th try: look for default artwork in new default artwork directory */
 667   filename = getPath2(getDefaultMusicDir(MUS_CLASSIC_SUBDIR), basename);
 668   if (fileExists(filename))
 669     return filename;
 670
 671   free(filename);
 672
 673   /* 5th try: look for default artwork in old default artwork directory */
 674   filename = getPath2(options.music_directory, basename);
 675   if (fileExists(filename))
 676     return filename;
 677
 678   return NULL;          /* cannot find specified artwork file anywhere */
 679 }
 680
 681 char *getCustomArtworkFilename(char *basename, int type)
 682 {
 683   if (type == ARTWORK_TYPE_GRAPHICS)
 684     return getCustomImageFilename(basename);
 685   else if (type == ARTWORK_TYPE_SOUNDS)
 686     return getCustomSoundFilename(basename);
 687   else if (type == ARTWORK_TYPE_MUSIC)
 688     return getCustomMusicFilename(basename);
 689   else
 690     return UNDEFINED_FILENAME;
 691 }
 692
 693 char *getCustomArtworkConfigFilename(int type)
 694 {
 695   return getCustomArtworkFilename(ARTWORKINFO_FILENAME(type), type);
 696 }
 697
 698 char *getCustomArtworkLevelConfigFilename(int type)
 699 {
 700   static char *filename = NULL;
 701
 702   checked_free(filename);
 703
 704   filename = getPath2(getLevelArtworkDir(type), ARTWORKINFO_FILENAME(type));
 705
 706   return filename;
 707 }
 708
 709 char *getCustomMusicDirectory(void)
 710 {
 711   static char *directory = NULL;
 712   boolean skip_setup_artwork = FALSE;
 713
 714   checked_free(directory);
 715
 716   if (!setup.override_level_music)
 717   {
 718     /* 1st try: look for special artwork in current level series directory */
 719     directory = getPath2(getCurrentLevelDir(), MUSIC_DIRECTORY);
 720     if (fileExists(directory))
 721       return directory;
 722
 723     free(directory);
 724
 725     /* check if there is special artwork configured in level series config */
 726     if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
 727     {
 728       /* 2nd try: look for special artwork configured in level series config */
 729       directory = getStringCopy(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR));
 730       if (fileExists(directory))
 731         return directory;
 732
 733       free(directory);
 734
 735       /* take missing artwork configured in level set config from default */
 736       skip_setup_artwork = TRUE;
 737     }
 738   }
 739
 740   if (!skip_setup_artwork)
 741   {
 742     /* 3rd try: look for special artwork in configured artwork directory */
 743     directory = getStringCopy(getSetupArtworkDir(artwork.mus_current));
 744     if (fileExists(directory))
 745       return directory;
 746
 747     free(directory);
 748   }
 749
 750   /* 4th try: look for default artwork in new default artwork directory */
 751   directory = getStringCopy(getDefaultMusicDir(MUS_CLASSIC_SUBDIR));
 752   if (fileExists(directory))
 753     return directory;
 754
 755   free(directory);
 756
 757   /* 5th try: look for default artwork in old default artwork directory */
 758   directory = getStringCopy(options.music_directory);
 759   if (fileExists(directory))
 760     return directory;
 761
 762   return NULL;          /* cannot find specified artwork file anywhere */
 763 }
 764
 765 void InitTapeDirectory(char *level_subdir)
 766 {
 767   createDirectory(getUserDataDir(), "user data", PERMS_PRIVATE);
 768   createDirectory(getTapeDir(NULL), "main tape", PERMS_PRIVATE);
 769   createDirectory(getTapeDir(level_subdir), "level tape", PERMS_PRIVATE);
 770 }
 771
 772 void InitScoreDirectory(char *level_subdir)
 773 {
 774   createDirectory(getCommonDataDir(), "common data", PERMS_PUBLIC);
 775   createDirectory(getScoreDir(NULL), "main score", PERMS_PUBLIC);
 776   createDirectory(getScoreDir(level_subdir), "level score", PERMS_PUBLIC);
 777 }
 778
 779 static void SaveUserLevelInfo();
 780
 781 void InitUserLevelDirectory(char *level_subdir)
 782 {
 783   if (!fileExists(getUserLevelDir(level_subdir)))
 784   {
 785     createDirectory(getUserDataDir(), "user data", PERMS_PRIVATE);
 786     createDirectory(getUserLevelDir(NULL), "main user level", PERMS_PRIVATE);
 787     createDirectory(getUserLevelDir(level_subdir), "user level",PERMS_PRIVATE);
 788
 789     SaveUserLevelInfo();
 790   }
 791 }
 792
 793 void InitLevelSetupDirectory(char *level_subdir)
 794 {
 795   createDirectory(getUserDataDir(), "user data", PERMS_PRIVATE);
 796   createDirectory(getLevelSetupDir(NULL), "main level setup", PERMS_PRIVATE);
 797   createDirectory(getLevelSetupDir(level_subdir), "level setup",PERMS_PRIVATE);
 798 }
 799
 800
 801 /* ------------------------------------------------------------------------- */
 802 /* some functions to handle lists of level directories                       */
 803 /* ------------------------------------------------------------------------- */
 804
 805 TreeInfo *newTreeInfo()
 806 {
 807   return checked_calloc(sizeof(TreeInfo));
 808 }
 809
 810 void pushTreeInfo(TreeInfo **node_first, TreeInfo *node_new)
 811 {
 812   node_new->next = *node_first;
 813   *node_first = node_new;
 814 }
 815
 816 int numTreeInfo(TreeInfo *node)
 817 {
 818   int num = 0;
 819
 820   while (node)
 821   {
 822     num++;
 823     node = node->next;
 824   }
 825
 826   return num;
 827 }
 828
 829 boolean validLevelSeries(TreeInfo *node)
 830 {
 831   return (node != NULL && !node->node_group && !node->parent_link);
 832 }
 833
 834 TreeInfo *getFirstValidTreeInfoEntry(TreeInfo *node)
 835 {
 836   if (node == NULL)
 837     return NULL;
 838
 839   if (node->node_group)         /* enter level group (step down into tree) */
 840     return getFirstValidTreeInfoEntry(node->node_group);
 841   else if (node->parent_link)   /* skip start entry of level group */
 842   {
 843     if (node->next)             /* get first real level series entry */
 844       return getFirstValidTreeInfoEntry(node->next);
 845     else                        /* leave empty level group and go on */
 846       return getFirstValidTreeInfoEntry(node->node_parent->next);
 847   }
 848   else                          /* this seems to be a regular level series */
 849     return node;
 850 }
 851
 852 TreeInfo *getTreeInfoFirstGroupEntry(TreeInfo *node)
 853 {
 854   if (node == NULL)
 855     return NULL;
 856
 857   if (node->node_parent == NULL)                /* top level group */
 858     return *node->node_top;
 859   else                                          /* sub level group */
 860     return node->node_parent->node_group;
 861 }
 862
 863 int numTreeInfoInGroup(TreeInfo *node)
 864 {
 865   return numTreeInfo(getTreeInfoFirstGroupEntry(node));
 866 }
 867
 868 int posTreeInfo(TreeInfo *node)
 869 {
 870   TreeInfo *node_cmp = getTreeInfoFirstGroupEntry(node);
 871   int pos = 0;
 872
 873   while (node_cmp)
 874   {
 875     if (node_cmp == node)
 876       return pos;
 877
 878     pos++;
 879     node_cmp = node_cmp->next;
 880   }
 881
 882   return 0;
 883 }
 884
 885 TreeInfo *getTreeInfoFromPos(TreeInfo *node, int pos)
 886 {
 887   TreeInfo *node_default = node;
 888   int pos_cmp = 0;
 889
 890   while (node)
 891   {
 892     if (pos_cmp == pos)
 893       return node;
 894
 895     pos_cmp++;
 896     node = node->next;
 897   }
 898
 899   return node_default;
 900 }
 901
 902 TreeInfo *getTreeInfoFromIdentifier(TreeInfo *node, char *identifier)
 903 {
 904   if (identifier == NULL)
 905     return NULL;
 906
 907   while (node)
 908   {
 909     if (node->node_group)
 910     {
 911       TreeInfo *node_group;
 912
 913       node_group = getTreeInfoFromIdentifier(node->node_group, identifier);
 914
 915       if (node_group)
 916         return node_group;
 917     }
 918     else if (!node->parent_link)
 919     {
 920       if (strcmp(identifier, node->identifier) == 0)
 921         return node;
 922     }
 923
 924     node = node->next;
 925   }
 926
 927   return NULL;
 928 }
 929
 930 void dumpTreeInfo(TreeInfo *node, int depth)
 931 {
 932   int i;
 933
 934   printf("Dumping TreeInfo:\n");
 935
 936   while (node)
 937   {
 938     for (i = 0; i < (depth + 1) * 3; i++)
 939       printf(" ");
 940
 941 #if 1
 942     printf("subdir == '%s' ['%s', '%s'] [%d])\n",
 943            node->subdir, node->fullpath, node->basepath, node->in_user_dir);
 944 #else
 945     printf("subdir == '%s' (%s) [%s] (%d)\n",
 946            node->subdir, node->name, node->identifier, node->sort_priority);
 947 #endif
 948
 949     if (node->node_group != NULL)
 950       dumpTreeInfo(node->node_group, depth + 1);
 951
 952     node = node->next;
 953   }
 954 }
 955
 956 void sortTreeInfo(TreeInfo **node_first,
 957                   int (*compare_function)(const void *, const void *))
 958 {
 959   int num_nodes = numTreeInfo(*node_first);
 960   TreeInfo **sort_array;
 961   TreeInfo *node = *node_first;
 962   int i = 0;
 963
 964   if (num_nodes == 0)
 965     return;
 966
 967   /* allocate array for sorting structure pointers */
 968   sort_array = checked_calloc(num_nodes * sizeof(TreeInfo *));
 969
 970   /* writing structure pointers to sorting array */
 971   while (i < num_nodes && node)         /* double boundary check... */
 972   {
 973     sort_array[i] = node;
 974
 975     i++;
 976     node = node->next;
 977   }
 978
 979   /* sorting the structure pointers in the sorting array */
 980   qsort(sort_array, num_nodes, sizeof(TreeInfo *),
 981         compare_function);
 982
 983   /* update the linkage of list elements with the sorted node array */
 984   for (i = 0; i < num_nodes - 1; i++)
 985     sort_array[i]->next = sort_array[i + 1];
 986   sort_array[num_nodes - 1]->next = NULL;
 987
 988   /* update the linkage of the main list anchor pointer */
 989   *node_first = sort_array[0];
 990
 991   free(sort_array);
 992
 993   /* now recursively sort the level group structures */
 994   node = *node_first;
 995   while (node)
 996   {
 997     if (node->node_group != NULL)
 998       sortTreeInfo(&node->node_group, compare_function);
 999
1000     node = node->next;
1001   }
1002 }
1003
1004
1005 /* ========================================================================= */
1006 /* some stuff from "files.c"                                                 */
1007 /* ========================================================================= */
1008
1009 #if defined(PLATFORM_WIN32)
1010 #ifndef S_IRGRP
1011 #define S_IRGRP S_IRUSR
1012 #endif
1013 #ifndef S_IROTH
1014 #define S_IROTH S_IRUSR
1015 #endif
1016 #ifndef S_IWGRP
1017 #define S_IWGRP S_IWUSR
1018 #endif
1019 #ifndef S_IWOTH
1020 #define S_IWOTH S_IWUSR
1021 #endif
1022 #ifndef S_IXGRP
1023 #define S_IXGRP S_IXUSR
1024 #endif
1025 #ifndef S_IXOTH
1026 #define S_IXOTH S_IXUSR
1027 #endif
1028 #ifndef S_IRWXG
1029 #define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
1030 #endif
1031 #ifndef S_ISGID
1032 #define S_ISGID 0
1033 #endif
1034 #endif  /* PLATFORM_WIN32 */
1035
1036 /* file permissions for newly written files */
1037 #define MODE_R_ALL              (S_IRUSR | S_IRGRP | S_IROTH)
1038 #define MODE_W_ALL              (S_IWUSR | S_IWGRP | S_IWOTH)
1039 #define MODE_X_ALL              (S_IXUSR | S_IXGRP | S_IXOTH)
1040
1041 #define MODE_W_PRIVATE          (S_IWUSR)
1042 #define MODE_W_PUBLIC           (S_IWUSR | S_IWGRP)
1043 #define MODE_W_PUBLIC_DIR       (S_IWUSR | S_IWGRP | S_ISGID)
1044
1045 #define DIR_PERMS_PRIVATE       (MODE_R_ALL | MODE_X_ALL | MODE_W_PRIVATE)
1046 #define DIR_PERMS_PUBLIC        (MODE_R_ALL | MODE_X_ALL | MODE_W_PUBLIC_DIR)
1047
1048 #define FILE_PERMS_PRIVATE      (MODE_R_ALL | MODE_W_PRIVATE)
1049 #define FILE_PERMS_PUBLIC       (MODE_R_ALL | MODE_W_PUBLIC)
1050
1051 char *getUserDataDir(void)
1052 {
1053   static char *userdata_dir = NULL;
1054
1055   if (userdata_dir == NULL)
1056     userdata_dir = getPath2(getHomeDir(), program.userdata_directory);
1057
1058   return userdata_dir;
1059 }
1060
1061 char *getCommonDataDir(void)
1062 {
1063   static char *common_data_dir = NULL;
1064
1065 #if defined(PLATFORM_WIN32)
1066   if (common_data_dir == NULL)
1067   {
1068     char *dir = checked_malloc(MAX_PATH + 1);
1069
1070     if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, dir))
1071         && strcmp(dir, "") != 0)        /* empty for Windows 95/98 */
1072       common_data_dir = getPath2(dir, program.userdata_directory);
1073     else
1074       common_data_dir = options.rw_base_directory;
1075   }
1076 #else
1077   if (common_data_dir == NULL)
1078     common_data_dir = options.rw_base_directory;
1079 #endif
1080
1081   return common_data_dir;
1082 }
1083
1084 char *getSetupDir()
1085 {
1086   return getUserDataDir();
1087 }
1088
1089 static mode_t posix_umask(mode_t mask)
1090 {
1091 #if defined(PLATFORM_UNIX)
1092   return umask(mask);
1093 #else
1094   return 0;
1095 #endif
1096 }
1097
1098 static int posix_mkdir(const char *pathname, mode_t mode)
1099 {
1100 #if defined(PLATFORM_WIN32)
1101   return mkdir(pathname);
1102 #else
1103   return mkdir(pathname, mode);
1104 #endif
1105 }
1106
1107 void createDirectory(char *dir, char *text, int permission_class)
1108 {
1109   /* leave "other" permissions in umask untouched, but ensure group parts
1110      of USERDATA_DIR_MODE are not masked */
1111   mode_t dir_mode = (permission_class == PERMS_PRIVATE ?
1112                      DIR_PERMS_PRIVATE : DIR_PERMS_PUBLIC);
1113   mode_t normal_umask = posix_umask(0);
1114   mode_t group_umask = ~(dir_mode & S_IRWXG);
1115   posix_umask(normal_umask & group_umask);
1116
1117   if (!fileExists(dir))
1118     if (posix_mkdir(dir, dir_mode) != 0)
1119       Error(ERR_WARN, "cannot create %s directory '%s'", text, dir);
1120
1121   posix_umask(normal_umask);            /* reset normal umask */
1122 }
1123
1124 void InitUserDataDirectory()
1125 {
1126   createDirectory(getUserDataDir(), "user data", PERMS_PRIVATE);
1127 }
1128
1129 void SetFilePermissions(char *filename, int permission_class)
1130 {
1131   chmod(filename, (permission_class == PERMS_PRIVATE ?
1132                    FILE_PERMS_PRIVATE : FILE_PERMS_PUBLIC));
1133 }
1134
1135 char *getCookie(char *file_type)
1136 {
1137   static char cookie[MAX_COOKIE_LEN + 1];
1138
1139   if (strlen(program.cookie_prefix) + 1 +
1140       strlen(file_type) + strlen("_FILE_VERSION_x.x") > MAX_COOKIE_LEN)
1141     return "[COOKIE ERROR]";    /* should never happen */
1142
1143   sprintf(cookie, "%s_%s_FILE_VERSION_%d.%d",
1144           program.cookie_prefix, file_type,
1145           program.version_major, program.version_minor);
1146
1147   return cookie;
1148 }
1149
1150 int getFileVersionFromCookieString(const char *cookie)
1151 {
1152   const char *ptr_cookie1, *ptr_cookie2;
1153   const char *pattern1 = "_FILE_VERSION_";
1154   const char *pattern2 = "?.?";
1155   const int len_cookie = strlen(cookie);
1156   const int len_pattern1 = strlen(pattern1);
1157   const int len_pattern2 = strlen(pattern2);
1158   const int len_pattern = len_pattern1 + len_pattern2;
1159   int version_major, version_minor;
1160
1161   if (len_cookie <= len_pattern)
1162     return -1;
1163
1164   ptr_cookie1 = &cookie[len_cookie - len_pattern];
1165   ptr_cookie2 = &cookie[len_cookie - len_pattern2];
1166
1167   if (strncmp(ptr_cookie1, pattern1, len_pattern1) != 0)
1168     return -1;
1169
1170   if (ptr_cookie2[0] < '0' || ptr_cookie2[0] > '9' ||
1171       ptr_cookie2[1] != '.' ||
1172       ptr_cookie2[2] < '0' || ptr_cookie2[2] > '9')
1173     return -1;
1174
1175   version_major = ptr_cookie2[0] - '0';
1176   version_minor = ptr_cookie2[2] - '0';
1177
1178   return VERSION_IDENT(version_major, version_minor, 0, 0);
1179 }
1180
1181 boolean checkCookieString(const char *cookie, const char *template)
1182 {
1183   const char *pattern = "_FILE_VERSION_?.?";
1184   const int len_cookie = strlen(cookie);
1185   const int len_template = strlen(template);
1186   const int len_pattern = strlen(pattern);
1187
1188   if (len_cookie != len_template)
1189     return FALSE;
1190
1191   if (strncmp(cookie, template, len_cookie - len_pattern) != 0)
1192     return FALSE;
1193
1194   return TRUE;
1195 }
1196
1197 /* ------------------------------------------------------------------------- */
1198 /* setup file list and hash handling functions                               */
1199 /* ------------------------------------------------------------------------- */
1200
1201 char *getFormattedSetupEntry(char *token, char *value)
1202 {
1203   int i;
1204   static char entry[MAX_LINE_LEN];
1205
1206   /* if value is an empty string, just return token without value */
1207   if (*value == '\0')
1208     return token;
1209
1210   /* start with the token and some spaces to format output line */
1211   sprintf(entry, "%s:", token);
1212   for (i = strlen(entry); i < token_value_position; i++)
1213     strcat(entry, " ");
1214
1215   /* continue with the token's value */
1216   strcat(entry, value);
1217
1218   return entry;
1219 }
1220
1221 SetupFileList *newSetupFileList(char *token, char *value)
1222 {
1223   SetupFileList *new = checked_malloc(sizeof(SetupFileList));
1224
1225   new->token = getStringCopy(token);
1226   new->value = getStringCopy(value);
1227
1228   new->next = NULL;
1229
1230   return new;
1231 }
1232
1233 void freeSetupFileList(SetupFileList *list)
1234 {
1235   if (list == NULL)
1236     return;
1237
1238   checked_free(list->token);
1239   checked_free(list->value);
1240
1241   if (list->next)
1242     freeSetupFileList(list->next);
1243
1244   free(list);
1245 }
1246
1247 char *getListEntry(SetupFileList *list, char *token)
1248 {
1249   if (list == NULL)
1250     return NULL;
1251
1252   if (strcmp(list->token, token) == 0)
1253     return list->value;
1254   else
1255     return getListEntry(list->next, token);
1256 }
1257
1258 SetupFileList *setListEntry(SetupFileList *list, char *token, char *value)
1259 {
1260   if (list == NULL)
1261     return NULL;
1262
1263   if (strcmp(list->token, token) == 0)
1264   {
1265     checked_free(list->value);
1266
1267     list->value = getStringCopy(value);
1268
1269     return list;
1270   }
1271   else if (list->next == NULL)
1272     return (list->next = newSetupFileList(token, value));
1273   else
1274     return setListEntry(list->next, token, value);
1275 }
1276
1277 SetupFileList *addListEntry(SetupFileList *list, char *token, char *value)
1278 {
1279   if (list == NULL)
1280     return NULL;
1281
1282   if (list->next == NULL)
1283     return (list->next = newSetupFileList(token, value));
1284   else
1285     return addListEntry(list->next, token, value);
1286 }
1287
1288 #ifdef DEBUG
1289 static void printSetupFileList(SetupFileList *list)
1290 {
1291   if (!list)
1292     return;
1293
1294   printf("token: '%s'\n", list->token);
1295   printf("value: '%s'\n", list->value);
1296
1297   printSetupFileList(list->next);
1298 }
1299 #endif
1300
1301 #ifdef DEBUG
1302 DEFINE_HASHTABLE_INSERT(insert_hash_entry, char, char);
1303 DEFINE_HASHTABLE_SEARCH(search_hash_entry, char, char);
1304 DEFINE_HASHTABLE_CHANGE(change_hash_entry, char, char);
1305 DEFINE_HASHTABLE_REMOVE(remove_hash_entry, char, char);
1306 #else
1307 #define insert_hash_entry hashtable_insert
1308 #define search_hash_entry hashtable_search
1309 #define change_hash_entry hashtable_change
1310 #define remove_hash_entry hashtable_remove
1311 #endif
1312
1313 static unsigned int get_hash_from_key(void *key)
1314 {
1315   /*
1316     djb2
1317
1318     This algorithm (k=33) was first reported by Dan Bernstein many years ago in
1319     'comp.lang.c'. Another version of this algorithm (now favored by Bernstein)
1320     uses XOR: hash(i) = hash(i - 1) * 33 ^ str[i]; the magic of number 33 (why
1321     it works better than many other constants, prime or not) has never been
1322     adequately explained.
1323
1324     If you just want to have a good hash function, and cannot wait, djb2
1325     is one of the best string hash functions i know. It has excellent
1326     distribution and speed on many different sets of keys and table sizes.
1327     You are not likely to do better with one of the "well known" functions
1328     such as PJW, K&R, etc.
1329
1330     Ozan (oz) Yigit [http://www.cs.yorku.ca/~oz/hash.html]
1331   */
1332
1333   char *str = (char *)key;
1334   unsigned int hash = 5381;
1335   int c;
1336
1337   while ((c = *str++))
1338     hash = ((hash << 5) + hash) + c;    /* hash * 33 + c */
1339
1340   return hash;
1341 }
1342
1343 static int keys_are_equal(void *key1, void *key2)
1344 {
1345   return (strcmp((char *)key1, (char *)key2) == 0);
1346 }
1347
1348 SetupFileHash *newSetupFileHash()
1349 {
1350   SetupFileHash *new_hash =
1351     create_hashtable(16, 0.75, get_hash_from_key, keys_are_equal);
1352
1353   if (new_hash == NULL)
1354     Error(ERR_EXIT, "create_hashtable() failed -- out of memory");
1355
1356   return new_hash;
1357 }
1358
1359 void freeSetupFileHash(SetupFileHash *hash)
1360 {
1361   if (hash == NULL)
1362     return;
1363
1364   hashtable_destroy(hash, 1);   /* 1 == also free values stored in hash */
1365 }
1366
1367 char *getHashEntry(SetupFileHash *hash, char *token)
1368 {
1369   if (hash == NULL)
1370     return NULL;
1371
1372   return search_hash_entry(hash, token);
1373 }
1374
1375 void setHashEntry(SetupFileHash *hash, char *token, char *value)
1376 {
1377   char *value_copy;
1378
1379   if (hash == NULL)
1380     return;
1381
1382   value_copy = getStringCopy(value);
1383
1384   /* change value; if it does not exist, insert it as new */
1385   if (!change_hash_entry(hash, token, value_copy))
1386     if (!insert_hash_entry(hash, getStringCopy(token), value_copy))
1387       Error(ERR_EXIT, "cannot insert into hash -- aborting");
1388 }
1389
1390 char *removeHashEntry(SetupFileHash *hash, char *token)
1391 {
1392   if (hash == NULL)
1393     return NULL;
1394
1395   return remove_hash_entry(hash, token);
1396 }
1397
1398 #if 0
1399 #ifdef DEBUG
1400 static void printSetupFileHash(SetupFileHash *hash)
1401 {
1402   BEGIN_HASH_ITERATION(hash, itr)
1403   {
1404     printf("token: '%s'\n", HASH_ITERATION_TOKEN(itr));
1405     printf("value: '%s'\n", HASH_ITERATION_VALUE(itr));
1406   }
1407   END_HASH_ITERATION(hash, itr)
1408 }
1409 #endif
1410 #endif
1411
1412 static void *loadSetupFileData(char *filename, boolean use_hash)
1413 {
1414   char line[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
1415   char *token, *value, *line_ptr;
1416   void *setup_file_data, *insert_ptr = NULL;
1417   boolean read_continued_line = FALSE;
1418   FILE *file;
1419
1420   if (!(file = fopen(filename, MODE_READ)))
1421   {
1422     Error(ERR_WARN, "cannot open configuration file '%s'", filename);
1423
1424     return NULL;
1425   }
1426
1427   if (use_hash)
1428     setup_file_data = newSetupFileHash();
1429   else
1430     insert_ptr = setup_file_data = newSetupFileList("", "");
1431
1432   while (!feof(file))
1433   {
1434     /* read next line of input file */
1435     if (!fgets(line, MAX_LINE_LEN, file))
1436       break;
1437
1438     /* cut trailing newline or carriage return */
1439     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
1440       if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
1441         *line_ptr = '\0';
1442
1443     if (read_continued_line)
1444     {
1445       /* cut leading whitespaces from input line */
1446       for (line_ptr = line; *line_ptr; line_ptr++)
1447         if (*line_ptr != ' ' && *line_ptr != '\t')
1448           break;
1449
1450       /* append new line to existing line, if there is enough space */
1451       if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
1452         strcat(previous_line, line_ptr);
1453
1454       strcpy(line, previous_line);      /* copy storage buffer to line */
1455
1456       read_continued_line = FALSE;
1457     }
1458
1459     /* if the last character is '\', continue at next line */
1460     if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
1461     {
1462       line[strlen(line) - 1] = '\0';    /* cut off trailing backslash */
1463       strcpy(previous_line, line);      /* copy line to storage buffer */
1464
1465       read_continued_line = TRUE;
1466
1467       continue;
1468     }
1469
1470     /* cut trailing comment from input line */
1471     for (line_ptr = line; *line_ptr; line_ptr++)
1472     {
1473       if (*line_ptr == '#')
1474       {
1475         *line_ptr = '\0';
1476         break;
1477       }
1478     }
1479
1480     /* cut trailing whitespaces from input line */
1481     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
1482       if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
1483         *line_ptr = '\0';
1484
1485     /* ignore empty lines */
1486     if (*line == '\0')
1487       continue;
1488
1489     /* cut leading whitespaces from token */
1490     for (token = line; *token; token++)
1491       if (*token != ' ' && *token != '\t')
1492         break;
1493
1494     /* start with empty value as reliable default */
1495     value = "";
1496
1497     /* find end of token to determine start of value */
1498     for (line_ptr = token; *line_ptr; line_ptr++)
1499     {
1500       if (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == ':')
1501       {
1502         *line_ptr = '\0';               /* terminate token string */
1503         value = line_ptr + 1;           /* set beginning of value */
1504
1505         break;
1506       }
1507     }
1508
1509     /* cut leading whitespaces from value */
1510     for (; *value; value++)
1511       if (*value != ' ' && *value != '\t')
1512         break;
1513
1514 #if 0
1515     if (*value == '\0')
1516       value = "true";   /* treat tokens without value as "true" */
1517 #endif
1518
1519     if (*token)
1520     {
1521       if (use_hash)
1522         setHashEntry((SetupFileHash *)setup_file_data, token, value);
1523       else
1524         insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value);
1525     }
1526   }
1527
1528   fclose(file);
1529
1530   if (use_hash)
1531   {
1532     if (hashtable_count((SetupFileHash *)setup_file_data) == 0)
1533       Error(ERR_WARN, "configuration file '%s' is empty", filename);
1534   }
1535   else
1536   {
1537     SetupFileList *setup_file_list = (SetupFileList *)setup_file_data;
1538     SetupFileList *first_valid_list_entry = setup_file_list->next;
1539
1540     /* free empty list header */
1541     setup_file_list->next = NULL;
1542     freeSetupFileList(setup_file_list);
1543     setup_file_data = first_valid_list_entry;
1544
1545     if (first_valid_list_entry == NULL)
1546       Error(ERR_WARN, "configuration file '%s' is empty", filename);
1547   }
1548
1549   return setup_file_data;
1550 }
1551
1552 SetupFileList *loadSetupFileList(char *filename)
1553 {
1554   return (SetupFileList *)loadSetupFileData(filename, FALSE);
1555 }
1556
1557 SetupFileHash *loadSetupFileHash(char *filename)
1558 {
1559   return (SetupFileHash *)loadSetupFileData(filename, TRUE);
1560 }
1561
1562 void checkSetupFileHashIdentifier(SetupFileHash *setup_file_hash,
1563                                   char *identifier)
1564 {
1565   char *value = getHashEntry(setup_file_hash, TOKEN_STR_FILE_IDENTIFIER);
1566
1567   if (value == NULL)
1568     Error(ERR_WARN, "configuration file has no file identifier");
1569   else if (!checkCookieString(value, identifier))
1570     Error(ERR_WARN, "configuration file has wrong file identifier");
1571 }
1572
1573
1574 /* ========================================================================= */
1575 /* setup file stuff                                                          */
1576 /* ========================================================================= */
1577
1578 #define TOKEN_STR_LAST_LEVEL_SERIES     "last_level_series"
1579 #define TOKEN_STR_LAST_PLAYED_LEVEL     "last_played_level"
1580 #define TOKEN_STR_HANDICAP_LEVEL        "handicap_level"
1581
1582 /* level directory info */
1583 #define LEVELINFO_TOKEN_IDENTIFIER      0
1584 #define LEVELINFO_TOKEN_NAME            1
1585 #define LEVELINFO_TOKEN_NAME_SORTING    2
1586 #define LEVELINFO_TOKEN_AUTHOR          3
1587 #define LEVELINFO_TOKEN_IMPORTED_FROM   4
1588 #define LEVELINFO_TOKEN_IMPORTED_BY     5
1589 #define LEVELINFO_TOKEN_LEVELS          6
1590 #define LEVELINFO_TOKEN_FIRST_LEVEL     7
1591 #define LEVELINFO_TOKEN_SORT_PRIORITY   8
1592 #define LEVELINFO_TOKEN_LATEST_ENGINE   9
1593 #define LEVELINFO_TOKEN_LEVEL_GROUP     10
1594 #define LEVELINFO_TOKEN_READONLY        11
1595 #define LEVELINFO_TOKEN_GRAPHICS_SET    12
1596 #define LEVELINFO_TOKEN_SOUNDS_SET      13
1597 #define LEVELINFO_TOKEN_MUSIC_SET       14
1598 #define LEVELINFO_TOKEN_FILENAME        15
1599 #define LEVELINFO_TOKEN_FILETYPE        16
1600 #define LEVELINFO_TOKEN_HANDICAP        17
1601 #define LEVELINFO_TOKEN_SKIP_LEVELS     18
1602
1603 #define NUM_LEVELINFO_TOKENS            19
1604
1605 static LevelDirTree ldi;
1606
1607 static struct TokenInfo levelinfo_tokens[] =
1608 {
1609   /* level directory info */
1610   { TYPE_STRING,        &ldi.identifier,        "identifier"    },
1611   { TYPE_STRING,        &ldi.name,              "name"          },
1612   { TYPE_STRING,        &ldi.name_sorting,      "name_sorting"  },
1613   { TYPE_STRING,        &ldi.author,            "author"        },
1614   { TYPE_STRING,        &ldi.imported_from,     "imported_from" },
1615   { TYPE_STRING,        &ldi.imported_by,       "imported_by"   },
1616   { TYPE_INTEGER,       &ldi.levels,            "levels"        },
1617   { TYPE_INTEGER,       &ldi.first_level,       "first_level"   },
1618   { TYPE_INTEGER,       &ldi.sort_priority,     "sort_priority" },
1619   { TYPE_BOOLEAN,       &ldi.latest_engine,     "latest_engine" },
1620   { TYPE_BOOLEAN,       &ldi.level_group,       "level_group"   },
1621   { TYPE_BOOLEAN,       &ldi.readonly,          "readonly"      },
1622   { TYPE_STRING,        &ldi.graphics_set,      "graphics_set"  },
1623   { TYPE_STRING,        &ldi.sounds_set,        "sounds_set"    },
1624   { TYPE_STRING,        &ldi.music_set,         "music_set"     },
1625   { TYPE_STRING,        &ldi.level_filename,    "filename"      },
1626   { TYPE_STRING,        &ldi.level_filetype,    "filetype"      },
1627   { TYPE_BOOLEAN,       &ldi.handicap,          "handicap"      },
1628   { TYPE_BOOLEAN,       &ldi.skip_levels,       "skip_levels"   }
1629 };
1630
1631 static void setTreeInfoToDefaults(TreeInfo *ldi, int type)
1632 {
1633   ldi->type = type;
1634
1635   ldi->node_top = (ldi->type == TREE_TYPE_LEVEL_DIR ? &leveldir_first :
1636                    ldi->type == TREE_TYPE_GRAPHICS_DIR ? &artwork.gfx_first :
1637                    ldi->type == TREE_TYPE_SOUNDS_DIR ? &artwork.snd_first :
1638                    ldi->type == TREE_TYPE_MUSIC_DIR ? &artwork.mus_first :
1639                    NULL);
1640
1641   ldi->node_parent = NULL;
1642   ldi->node_group = NULL;
1643   ldi->next = NULL;
1644
1645   ldi->cl_first = -1;
1646   ldi->cl_cursor = -1;
1647
1648   ldi->subdir = NULL;
1649   ldi->fullpath = NULL;
1650   ldi->basepath = NULL;
1651   ldi->identifier = NULL;
1652   ldi->name = getStringCopy(ANONYMOUS_NAME);
1653   ldi->name_sorting = NULL;
1654   ldi->author = getStringCopy(ANONYMOUS_NAME);
1655
1656   ldi->sort_priority = LEVELCLASS_UNDEFINED;    /* default: least priority */
1657   ldi->latest_engine = FALSE;                   /* default: get from level */
1658   ldi->parent_link = FALSE;
1659   ldi->in_user_dir = FALSE;
1660   ldi->user_defined = FALSE;
1661   ldi->color = 0;
1662   ldi->class_desc = NULL;
1663
1664   if (ldi->type == TREE_TYPE_LEVEL_DIR)
1665   {
1666     ldi->imported_from = NULL;
1667     ldi->imported_by = NULL;
1668
1669     ldi->graphics_set = NULL;
1670     ldi->sounds_set = NULL;
1671     ldi->music_set = NULL;
1672     ldi->graphics_path = getStringCopy(UNDEFINED_FILENAME);
1673     ldi->sounds_path = getStringCopy(UNDEFINED_FILENAME);
1674     ldi->music_path = getStringCopy(UNDEFINED_FILENAME);
1675
1676     ldi->level_filename = NULL;
1677     ldi->level_filetype = NULL;
1678
1679     ldi->levels = 0;
1680     ldi->first_level = 0;
1681     ldi->last_level = 0;
1682     ldi->level_group = FALSE;
1683     ldi->handicap_level = 0;
1684     ldi->readonly = TRUE;
1685     ldi->handicap = TRUE;
1686     ldi->skip_levels = FALSE;
1687   }
1688 }
1689
1690 static void setTreeInfoToDefaultsFromParent(TreeInfo *ldi, TreeInfo *parent)
1691 {
1692   if (parent == NULL)
1693   {
1694     Error(ERR_WARN, "setTreeInfoToDefaultsFromParent(): parent == NULL");
1695
1696     setTreeInfoToDefaults(ldi, TREE_TYPE_UNDEFINED);
1697
1698     return;
1699   }
1700
1701 #if 1
1702   /* copy all values from the parent structure */
1703
1704   ldi->type = parent->type;
1705
1706   ldi->node_top = parent->node_top;
1707   ldi->node_parent = parent;
1708   ldi->node_group = NULL;
1709   ldi->next = NULL;
1710
1711   ldi->cl_first = -1;
1712   ldi->cl_cursor = -1;
1713
1714   ldi->subdir = NULL;
1715   ldi->fullpath = NULL;
1716   ldi->basepath = NULL;
1717   ldi->identifier = NULL;
1718   ldi->name = getStringCopy(ANONYMOUS_NAME);
1719   ldi->name_sorting = NULL;
1720   ldi->author = getStringCopy(parent->author);
1721
1722   ldi->sort_priority = parent->sort_priority;
1723   ldi->latest_engine = parent->latest_engine;
1724   ldi->parent_link = FALSE;
1725   ldi->in_user_dir = parent->in_user_dir;
1726   ldi->user_defined = parent->user_defined;
1727   ldi->color = parent->color;
1728   ldi->class_desc = getStringCopy(parent->class_desc);
1729
1730   if (ldi->type == TREE_TYPE_LEVEL_DIR)
1731   {
1732     ldi->imported_from = getStringCopy(parent->imported_from);
1733     ldi->imported_by = getStringCopy(parent->imported_by);
1734
1735     ldi->graphics_set = NULL;
1736     ldi->sounds_set = NULL;
1737     ldi->music_set = NULL;
1738     ldi->graphics_path = getStringCopy(UNDEFINED_FILENAME);
1739     ldi->sounds_path = getStringCopy(UNDEFINED_FILENAME);
1740     ldi->music_path = getStringCopy(UNDEFINED_FILENAME);
1741
1742     ldi->level_filename = NULL;
1743     ldi->level_filetype = NULL;
1744
1745     ldi->levels = 0;
1746     ldi->first_level = 0;
1747     ldi->last_level = 0;
1748     ldi->level_group = FALSE;
1749     ldi->handicap_level = 0;
1750     ldi->readonly = TRUE;
1751     ldi->handicap = TRUE;
1752     ldi->skip_levels = FALSE;
1753   }
1754
1755 #else
1756
1757   /* first copy all values from the parent structure ... */
1758   *ldi = *parent;
1759
1760   /* ... then set all fields to default that cannot be inherited from parent.
1761      This is especially important for all those fields that can be set from
1762      the 'levelinfo.conf' config file, because the function 'setSetupInfo()'
1763      calls 'free()' for all already set token values which requires that no
1764      other structure's pointer may point to them!
1765   */
1766
1767   ldi->subdir = NULL;
1768   ldi->fullpath = NULL;
1769   ldi->basepath = NULL;
1770   ldi->identifier = NULL;
1771   ldi->name = getStringCopy(ANONYMOUS_NAME);
1772   ldi->name_sorting = NULL;
1773   ldi->author = getStringCopy(parent->author);
1774
1775   ldi->imported_from = getStringCopy(parent->imported_from);
1776   ldi->imported_by = getStringCopy(parent->imported_by);
1777   ldi->class_desc = getStringCopy(parent->class_desc);
1778
1779   ldi->graphics_set = NULL;
1780   ldi->sounds_set = NULL;
1781   ldi->music_set = NULL;
1782   ldi->graphics_path = NULL;
1783   ldi->sounds_path = NULL;
1784   ldi->music_path = NULL;
1785
1786   ldi->level_group = FALSE;
1787   ldi->parent_link = FALSE;
1788
1789   ldi->node_top = parent->node_top;
1790   ldi->node_parent = parent;
1791   ldi->node_group = NULL;
1792   ldi->next = NULL;
1793
1794 #endif
1795 }
1796
1797 static void freeTreeInfo(TreeInfo *ldi)
1798 {
1799   checked_free(ldi->subdir);
1800   checked_free(ldi->fullpath);
1801   checked_free(ldi->basepath);
1802   checked_free(ldi->identifier);
1803
1804   checked_free(ldi->name);
1805   checked_free(ldi->name_sorting);
1806   checked_free(ldi->author);
1807
1808   checked_free(ldi->class_desc);
1809
1810   if (ldi->type == TREE_TYPE_LEVEL_DIR)
1811   {
1812     checked_free(ldi->imported_from);
1813     checked_free(ldi->imported_by);
1814
1815     checked_free(ldi->graphics_set);
1816     checked_free(ldi->sounds_set);
1817     checked_free(ldi->music_set);
1818
1819     checked_free(ldi->graphics_path);
1820     checked_free(ldi->sounds_path);
1821     checked_free(ldi->music_path);
1822
1823     checked_free(ldi->level_filename);
1824     checked_free(ldi->level_filetype);
1825   }
1826 }
1827
1828 void setSetupInfo(struct TokenInfo *token_info,
1829                   int token_nr, char *token_value)
1830 {
1831   int token_type = token_info[token_nr].type;
1832   void *setup_value = token_info[token_nr].value;
1833
1834   if (token_value == NULL)
1835     return;
1836
1837   /* set setup field to corresponding token value */
1838   switch (token_type)
1839   {
1840     case TYPE_BOOLEAN:
1841     case TYPE_SWITCH:
1842       *(boolean *)setup_value = get_boolean_from_string(token_value);
1843       break;
1844
1845     case TYPE_KEY:
1846       *(Key *)setup_value = getKeyFromKeyName(token_value);
1847       break;
1848
1849     case TYPE_KEY_X11:
1850       *(Key *)setup_value = getKeyFromX11KeyName(token_value);
1851       break;
1852
1853     case TYPE_INTEGER:
1854       *(int *)setup_value = get_integer_from_string(token_value);
1855       break;
1856
1857     case TYPE_STRING:
1858       checked_free(*(char **)setup_value);
1859       *(char **)setup_value = getStringCopy(token_value);
1860       break;
1861
1862     default:
1863       break;
1864   }
1865 }
1866
1867 static int compareTreeInfoEntries(const void *object1, const void *object2)
1868 {
1869   const TreeInfo *entry1 = *((TreeInfo **)object1);
1870   const TreeInfo *entry2 = *((TreeInfo **)object2);
1871   int class_sorting1, class_sorting2;
1872   int compare_result;
1873
1874   if (entry1->type == TREE_TYPE_LEVEL_DIR)
1875   {
1876     class_sorting1 = LEVELSORTING(entry1);
1877     class_sorting2 = LEVELSORTING(entry2);
1878   }
1879   else
1880   {
1881     class_sorting1 = ARTWORKSORTING(entry1);
1882     class_sorting2 = ARTWORKSORTING(entry2);
1883   }
1884
1885   if (entry1->parent_link || entry2->parent_link)
1886     compare_result = (entry1->parent_link ? -1 : +1);
1887   else if (entry1->sort_priority == entry2->sort_priority)
1888   {
1889     char *name1 = getStringToLower(entry1->name_sorting);
1890     char *name2 = getStringToLower(entry2->name_sorting);
1891
1892     compare_result = strcmp(name1, name2);
1893
1894     free(name1);
1895     free(name2);
1896   }
1897   else if (class_sorting1 == class_sorting2)
1898     compare_result = entry1->sort_priority - entry2->sort_priority;
1899   else
1900     compare_result = class_sorting1 - class_sorting2;
1901
1902   return compare_result;
1903 }
1904
1905 static void createParentTreeInfoNode(TreeInfo *node_parent)
1906 {
1907   TreeInfo *ti_new;
1908
1909   if (node_parent == NULL)
1910     return;
1911
1912   ti_new = newTreeInfo();
1913   setTreeInfoToDefaults(ti_new, node_parent->type);
1914
1915   ti_new->node_parent = node_parent;
1916   ti_new->parent_link = TRUE;
1917
1918 #if 1
1919   setString(&ti_new->identifier, node_parent->identifier);
1920   setString(&ti_new->name, ".. (parent directory)");
1921   setString(&ti_new->name_sorting, ti_new->name);
1922
1923   setString(&ti_new->subdir, "..");
1924   setString(&ti_new->fullpath, node_parent->fullpath);
1925
1926   ti_new->sort_priority = node_parent->sort_priority;
1927   ti_new->latest_engine = node_parent->latest_engine;
1928
1929   setString(&ti_new->class_desc, getLevelClassDescription(ti_new));
1930 #else
1931   ti_new->identifier = getStringCopy(node_parent->identifier);
1932   ti_new->name = ".. (parent directory)";
1933   ti_new->name_sorting = getStringCopy(ti_new->name);
1934
1935   ti_new->subdir = "..";
1936   ti_new->fullpath = getStringCopy(node_parent->fullpath);
1937
1938   ti_new->sort_priority = node_parent->sort_priority;
1939   ti_new->latest_engine = node_parent->latest_engine;
1940
1941   ti_new->class_desc = getLevelClassDescription(ti_new);
1942 #endif
1943
1944   pushTreeInfo(&node_parent->node_group, ti_new);
1945 }
1946
1947 /* forward declaration for recursive call by "LoadLevelInfoFromLevelDir()" */
1948 static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
1949
1950 static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
1951                                           TreeInfo *node_parent,
1952                                           char *level_directory,
1953                                           char *directory_name)
1954 {
1955   char *directory_path = getPath2(level_directory, directory_name);
1956   char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
1957   SetupFileHash *setup_file_hash;
1958   LevelDirTree *leveldir_new = NULL;
1959   int i;
1960
1961   /* unless debugging, silently ignore directories without "levelinfo.conf" */
1962   if (!options.debug && !fileExists(filename))
1963   {
1964     free(directory_path);
1965     free(filename);
1966
1967     return FALSE;
1968   }
1969
1970   setup_file_hash = loadSetupFileHash(filename);
1971
1972   if (setup_file_hash == NULL)
1973   {
1974     Error(ERR_WARN, "ignoring level directory '%s'", directory_path);
1975
1976     free(directory_path);
1977     free(filename);
1978
1979     return FALSE;
1980   }
1981
1982   leveldir_new = newTreeInfo();
1983
1984   if (node_parent)
1985     setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
1986   else
1987     setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
1988
1989   leveldir_new->subdir = getStringCopy(directory_name);
1990
1991   checkSetupFileHashIdentifier(setup_file_hash, getCookie("LEVELINFO"));
1992
1993   /* set all structure fields according to the token/value pairs */
1994   ldi = *leveldir_new;
1995   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
1996     setSetupInfo(levelinfo_tokens, i,
1997                  getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
1998   *leveldir_new = ldi;
1999
2000 #if 1
2001   if (strcmp(leveldir_new->name, ANONYMOUS_NAME) == 0)
2002     setString(&leveldir_new->name, leveldir_new->subdir);
2003 #else
2004   if (strcmp(leveldir_new->name, ANONYMOUS_NAME) == 0)
2005   {
2006     free(leveldir_new->name);
2007     leveldir_new->name = getStringCopy(leveldir_new->subdir);
2008   }
2009 #endif
2010
2011   DrawInitText(leveldir_new->name, 150, FC_YELLOW);
2012
2013   if (leveldir_new->identifier == NULL)
2014     leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
2015
2016   if (leveldir_new->name_sorting == NULL)
2017     leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
2018
2019   if (node_parent == NULL)              /* top level group */
2020   {
2021     leveldir_new->basepath = getStringCopy(level_directory);
2022     leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
2023   }
2024   else                                  /* sub level group */
2025   {
2026     leveldir_new->basepath = getStringCopy(node_parent->basepath);
2027     leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
2028   }
2029
2030   if (leveldir_new->levels < 1)
2031     leveldir_new->levels = 1;
2032
2033   leveldir_new->last_level =
2034     leveldir_new->first_level + leveldir_new->levels - 1;
2035
2036 #if 1
2037   leveldir_new->in_user_dir =
2038     (strcmp(leveldir_new->basepath, options.level_directory) != 0);
2039 #else
2040   leveldir_new->in_user_dir =
2041     (leveldir_new->basepath == options.level_directory ? FALSE : TRUE);
2042 #endif
2043
2044 #if 1
2045   /* adjust sort priority if user's private level directory was detected */
2046   if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
2047       leveldir_new->in_user_dir &&
2048       strcmp(leveldir_new->subdir, getLoginName()) == 0)
2049     leveldir_new->sort_priority = LEVELCLASS_PRIVATE_START;
2050 #endif
2051
2052   leveldir_new->user_defined =
2053     (leveldir_new->in_user_dir && IS_LEVELCLASS_PRIVATE(leveldir_new));
2054
2055   leveldir_new->color = LEVELCOLOR(leveldir_new);
2056 #if 1
2057   setString(&leveldir_new->class_desc, getLevelClassDescription(leveldir_new));
2058 #else
2059   leveldir_new->class_desc = getLevelClassDescription(leveldir_new);
2060 #endif
2061
2062   leveldir_new->handicap_level =        /* set handicap to default value */
2063     (leveldir_new->user_defined || !leveldir_new->handicap ?
2064      leveldir_new->last_level : leveldir_new->first_level);
2065
2066   pushTreeInfo(node_first, leveldir_new);
2067
2068   freeSetupFileHash(setup_file_hash);
2069
2070   if (leveldir_new->level_group)
2071   {
2072     /* create node to link back to current level directory */
2073     createParentTreeInfoNode(leveldir_new);
2074
2075     /* step into sub-directory and look for more level series */
2076     LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
2077                               leveldir_new, directory_path);
2078   }
2079
2080   free(directory_path);
2081   free(filename);
2082
2083   return TRUE;
2084 }
2085
2086 static void LoadLevelInfoFromLevelDir(TreeInfo **node_first,
2087                                       TreeInfo *node_parent,
2088                                       char *level_directory)
2089 {
2090   DIR *dir;
2091   struct dirent *dir_entry;
2092   boolean valid_entry_found = FALSE;
2093
2094   if ((dir = opendir(level_directory)) == NULL)
2095   {
2096     Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
2097     return;
2098   }
2099
2100   while ((dir_entry = readdir(dir)) != NULL)    /* loop until last dir entry */
2101   {
2102     struct stat file_status;
2103     char *directory_name = dir_entry->d_name;
2104     char *directory_path = getPath2(level_directory, directory_name);
2105
2106     /* skip entries for current and parent directory */
2107     if (strcmp(directory_name, ".")  == 0 ||
2108         strcmp(directory_name, "..") == 0)
2109     {
2110       free(directory_path);
2111       continue;
2112     }
2113
2114     /* find out if directory entry is itself a directory */
2115     if (stat(directory_path, &file_status) != 0 ||      /* cannot stat file */
2116         (file_status.st_mode & S_IFMT) != S_IFDIR)      /* not a directory */
2117     {
2118       free(directory_path);
2119       continue;
2120     }
2121
2122     free(directory_path);
2123
2124     if (strcmp(directory_name, GRAPHICS_DIRECTORY) == 0 ||
2125         strcmp(directory_name, SOUNDS_DIRECTORY) == 0 ||
2126         strcmp(directory_name, MUSIC_DIRECTORY) == 0)
2127       continue;
2128
2129     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
2130                                                     level_directory,
2131                                                     directory_name);
2132   }
2133
2134   closedir(dir);
2135
2136   if (!valid_entry_found)
2137   {
2138     /* check if this directory directly contains a file "levelinfo.conf" */
2139     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
2140                                                     level_directory, ".");
2141   }
2142
2143   if (!valid_entry_found)
2144     Error(ERR_WARN, "cannot find any valid level series in directory '%s'",
2145           level_directory);
2146 }
2147
2148 void LoadLevelInfo()
2149 {
2150   InitUserLevelDirectory(getLoginName());
2151
2152   DrawInitText("Loading level series:", 120, FC_GREEN);
2153
2154   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
2155   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL));
2156
2157   /* before sorting, the first entries will be from the user directory */
2158   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
2159
2160   if (leveldir_first == NULL)
2161     Error(ERR_EXIT, "cannot find any valid level series in any directory");
2162
2163   sortTreeInfo(&leveldir_first, compareTreeInfoEntries);
2164
2165 #if 0
2166   dumpTreeInfo(leveldir_first, 0);
2167 #endif
2168 }
2169
2170 static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first,
2171                                               TreeInfo *node_parent,
2172                                               char *base_directory,
2173                                               char *directory_name, int type)
2174 {
2175   char *directory_path = getPath2(base_directory, directory_name);
2176   char *filename = getPath2(directory_path, ARTWORKINFO_FILENAME(type));
2177   SetupFileHash *setup_file_hash = NULL;
2178   TreeInfo *artwork_new = NULL;
2179   int i;
2180
2181   if (fileExists(filename))
2182     setup_file_hash = loadSetupFileHash(filename);
2183
2184   if (setup_file_hash == NULL)  /* no config file -- look for artwork files */
2185   {
2186     DIR *dir;
2187     struct dirent *dir_entry;
2188     boolean valid_file_found = FALSE;
2189
2190     if ((dir = opendir(directory_path)) != NULL)
2191     {
2192       while ((dir_entry = readdir(dir)) != NULL)
2193       {
2194         char *entry_name = dir_entry->d_name;
2195
2196         if (FileIsArtworkType(entry_name, type))
2197         {
2198           valid_file_found = TRUE;
2199           break;
2200         }
2201       }
2202
2203       closedir(dir);
2204     }
2205
2206     if (!valid_file_found)
2207     {
2208       if (strcmp(directory_name, ".") != 0)
2209         Error(ERR_WARN, "ignoring artwork directory '%s'", directory_path);
2210
2211       free(directory_path);
2212       free(filename);
2213
2214       return FALSE;
2215     }
2216   }
2217
2218   artwork_new = newTreeInfo();
2219
2220   if (node_parent)
2221     setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
2222   else
2223     setTreeInfoToDefaults(artwork_new, type);
2224
2225   artwork_new->subdir = getStringCopy(directory_name);
2226
2227   if (setup_file_hash)  /* (before defining ".color" and ".class_desc") */
2228   {
2229 #if 0
2230     checkSetupFileHashIdentifier(setup_file_hash, getCookie("..."));
2231 #endif
2232
2233     /* set all structure fields according to the token/value pairs */
2234     ldi = *artwork_new;
2235     for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
2236       setSetupInfo(levelinfo_tokens, i,
2237                    getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
2238     *artwork_new = ldi;
2239
2240 #if 1
2241     if (strcmp(artwork_new->name, ANONYMOUS_NAME) == 0)
2242       setString(&artwork_new->name, artwork_new->subdir);
2243 #else
2244     if (strcmp(artwork_new->name, ANONYMOUS_NAME) == 0)
2245     {
2246       free(artwork_new->name);
2247       artwork_new->name = getStringCopy(artwork_new->subdir);
2248     }
2249 #endif
2250
2251 #if 0
2252     DrawInitText(artwork_new->name, 150, FC_YELLOW);
2253 #endif
2254
2255     if (artwork_new->identifier == NULL)
2256       artwork_new->identifier = getStringCopy(artwork_new->subdir);
2257
2258     if (artwork_new->name_sorting == NULL)
2259       artwork_new->name_sorting = getStringCopy(artwork_new->name);
2260   }
2261
2262   if (node_parent == NULL)              /* top level group */
2263   {
2264     artwork_new->basepath = getStringCopy(base_directory);
2265     artwork_new->fullpath = getStringCopy(artwork_new->subdir);
2266   }
2267   else                                  /* sub level group */
2268   {
2269     artwork_new->basepath = getStringCopy(node_parent->basepath);
2270     artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name);
2271   }
2272
2273 #if 1
2274   artwork_new->in_user_dir =
2275     (strcmp(artwork_new->basepath, OPTIONS_ARTWORK_DIRECTORY(type)) != 0);
2276 #else
2277   artwork_new->in_user_dir =
2278     (artwork_new->basepath == OPTIONS_ARTWORK_DIRECTORY(type) ? FALSE : TRUE);
2279 #endif
2280
2281   /* (may use ".sort_priority" from "setup_file_hash" above) */
2282   artwork_new->color = ARTWORKCOLOR(artwork_new);
2283 #if 1
2284   setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new));
2285 #else
2286   artwork_new->class_desc = getLevelClassDescription(artwork_new);
2287 #endif
2288
2289   if (setup_file_hash == NULL)  /* (after determining ".user_defined") */
2290   {
2291 #if 0
2292     if (artwork_new->name != NULL)
2293     {
2294       free(artwork_new->name);
2295       artwork_new->name = NULL;
2296     }
2297 #endif
2298
2299 #if 0
2300     if (artwork_new->identifier != NULL)
2301     {
2302       free(artwork_new->identifier);
2303       artwork_new->identifier = NULL;
2304     }
2305 #endif
2306
2307     if (strcmp(artwork_new->subdir, ".") == 0)
2308     {
2309       if (artwork_new->user_defined)
2310       {
2311 #if 1
2312         setString(&artwork_new->identifier, "private");
2313 #else
2314         artwork_new->identifier = getStringCopy("private");
2315 #endif
2316         artwork_new->sort_priority = ARTWORKCLASS_PRIVATE;
2317       }
2318       else
2319       {
2320 #if 1
2321         setString(&artwork_new->identifier, "classic");
2322 #else
2323         artwork_new->identifier = getStringCopy("classic");
2324 #endif
2325         artwork_new->sort_priority = ARTWORKCLASS_CLASSICS;
2326       }
2327
2328       /* set to new values after changing ".sort_priority" */
2329       artwork_new->color = ARTWORKCOLOR(artwork_new);
2330 #if 1
2331       setString(&artwork_new->class_desc,
2332                 getLevelClassDescription(artwork_new));
2333 #else
2334       artwork_new->class_desc = getLevelClassDescription(artwork_new);
2335 #endif
2336     }
2337     else
2338     {
2339 #if 1
2340       setString(&artwork_new->identifier, artwork_new->subdir);
2341 #else
2342       artwork_new->identifier = getStringCopy(artwork_new->subdir);
2343 #endif
2344     }
2345
2346 #if 1
2347     setString(&artwork_new->name, artwork_new->identifier);
2348     setString(&artwork_new->name_sorting, artwork_new->name);
2349 #else
2350     artwork_new->name = getStringCopy(artwork_new->identifier);
2351     artwork_new->name_sorting = getStringCopy(artwork_new->name);
2352 #endif
2353   }
2354
2355   DrawInitText(artwork_new->name, 150, FC_YELLOW);
2356
2357   pushTreeInfo(node_first, artwork_new);
2358
2359   freeSetupFileHash(setup_file_hash);
2360
2361   free(directory_path);
2362   free(filename);
2363
2364   return TRUE;
2365 }
2366
2367 static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first,
2368                                           TreeInfo *node_parent,
2369                                           char *base_directory, int type)
2370 {
2371   DIR *dir;
2372   struct dirent *dir_entry;
2373   boolean valid_entry_found = FALSE;
2374
2375   if ((dir = opendir(base_directory)) == NULL)
2376   {
2377     if (base_directory == OPTIONS_ARTWORK_DIRECTORY(type))
2378       Error(ERR_WARN, "cannot read directory '%s'", base_directory);
2379     return;
2380   }
2381
2382   while ((dir_entry = readdir(dir)) != NULL)    /* loop until last dir entry */
2383   {
2384     struct stat file_status;
2385     char *directory_name = dir_entry->d_name;
2386     char *directory_path = getPath2(base_directory, directory_name);
2387
2388     /* skip entries for current and parent directory */
2389     if (strcmp(directory_name, ".")  == 0 ||
2390         strcmp(directory_name, "..") == 0)
2391     {
2392       free(directory_path);
2393       continue;
2394     }
2395
2396     /* find out if directory entry is itself a directory */
2397     if (stat(directory_path, &file_status) != 0 ||      /* cannot stat file */
2398         (file_status.st_mode & S_IFMT) != S_IFDIR)      /* not a directory */
2399     {
2400       free(directory_path);
2401       continue;
2402     }
2403
2404     free(directory_path);
2405
2406     /* check if this directory contains artwork with or without config file */
2407     valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first,node_parent,
2408                                                         base_directory,
2409                                                         directory_name, type);
2410   }
2411
2412   closedir(dir);
2413
2414   /* check if this directory directly contains artwork itself */
2415   valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first,node_parent,
2416                                                       base_directory, ".",
2417                                                       type);
2418   if (!valid_entry_found)
2419     Error(ERR_WARN, "cannot find any valid artwork in directory '%s'",
2420           base_directory);
2421 }
2422
2423 static TreeInfo *getDummyArtworkInfo(int type)
2424 {
2425   /* this is only needed when there is completely no artwork available */
2426   TreeInfo *artwork_new = newTreeInfo();
2427
2428   setTreeInfoToDefaults(artwork_new, type);
2429
2430 #if 1
2431   setString(&artwork_new->subdir,   UNDEFINED_FILENAME);
2432   setString(&artwork_new->fullpath, UNDEFINED_FILENAME);
2433   setString(&artwork_new->basepath, UNDEFINED_FILENAME);
2434
2435   setString(&artwork_new->identifier,   UNDEFINED_FILENAME);
2436   setString(&artwork_new->name,         UNDEFINED_FILENAME);
2437   setString(&artwork_new->name_sorting, UNDEFINED_FILENAME);
2438 #else
2439   artwork_new->subdir   = getStringCopy(UNDEFINED_FILENAME);
2440   artwork_new->fullpath = getStringCopy(UNDEFINED_FILENAME);
2441   artwork_new->basepath = getStringCopy(UNDEFINED_FILENAME);
2442
2443   checked_free(artwork_new->name);
2444
2445   artwork_new->identifier   = getStringCopy(UNDEFINED_FILENAME);
2446   artwork_new->name         = getStringCopy(UNDEFINED_FILENAME);
2447   artwork_new->name_sorting = getStringCopy(UNDEFINED_FILENAME);
2448 #endif
2449
2450   return artwork_new;
2451 }
2452
2453 void LoadArtworkInfo()
2454 {
2455   DrawInitText("Looking for custom artwork:", 120, FC_GREEN);
2456
2457   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
2458                                 options.graphics_directory,
2459                                 TREE_TYPE_GRAPHICS_DIR);
2460   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
2461                                 getUserGraphicsDir(),
2462                                 TREE_TYPE_GRAPHICS_DIR);
2463
2464   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
2465                                 options.sounds_directory,
2466                                 TREE_TYPE_SOUNDS_DIR);
2467   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
2468                                 getUserSoundsDir(),
2469                                 TREE_TYPE_SOUNDS_DIR);
2470
2471   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
2472                                 options.music_directory,
2473                                 TREE_TYPE_MUSIC_DIR);
2474   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
2475                                 getUserMusicDir(),
2476                                 TREE_TYPE_MUSIC_DIR);
2477
2478   if (artwork.gfx_first == NULL)
2479     artwork.gfx_first = getDummyArtworkInfo(TREE_TYPE_GRAPHICS_DIR);
2480   if (artwork.snd_first == NULL)
2481     artwork.snd_first = getDummyArtworkInfo(TREE_TYPE_SOUNDS_DIR);
2482   if (artwork.mus_first == NULL)
2483     artwork.mus_first = getDummyArtworkInfo(TREE_TYPE_MUSIC_DIR);
2484
2485   /* before sorting, the first entries will be from the user directory */
2486   artwork.gfx_current =
2487     getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set);
2488   if (artwork.gfx_current == NULL)
2489     artwork.gfx_current =
2490       getTreeInfoFromIdentifier(artwork.gfx_first, GFX_CLASSIC_SUBDIR);
2491   if (artwork.gfx_current == NULL)
2492     artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first);
2493
2494   artwork.snd_current =
2495     getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set);
2496   if (artwork.snd_current == NULL)
2497     artwork.snd_current =
2498       getTreeInfoFromIdentifier(artwork.snd_first, SND_CLASSIC_SUBDIR);
2499   if (artwork.snd_current == NULL)
2500     artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first);
2501
2502   artwork.mus_current =
2503     getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set);
2504   if (artwork.mus_current == NULL)
2505     artwork.mus_current =
2506       getTreeInfoFromIdentifier(artwork.mus_first, MUS_CLASSIC_SUBDIR);
2507   if (artwork.mus_current == NULL)
2508     artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first);
2509
2510   artwork.gfx_current_identifier = artwork.gfx_current->identifier;
2511   artwork.snd_current_identifier = artwork.snd_current->identifier;
2512   artwork.mus_current_identifier = artwork.mus_current->identifier;
2513
2514 #if 0
2515   printf("graphics set == %s\n\n", artwork.gfx_current_identifier);
2516   printf("sounds set == %s\n\n", artwork.snd_current_identifier);
2517   printf("music set == %s\n\n", artwork.mus_current_identifier);
2518 #endif
2519
2520   sortTreeInfo(&artwork.gfx_first, compareTreeInfoEntries);
2521   sortTreeInfo(&artwork.snd_first, compareTreeInfoEntries);
2522   sortTreeInfo(&artwork.mus_first, compareTreeInfoEntries);
2523
2524 #if 0
2525   dumpTreeInfo(artwork.gfx_first, 0);
2526   dumpTreeInfo(artwork.snd_first, 0);
2527   dumpTreeInfo(artwork.mus_first, 0);
2528 #endif
2529 }
2530
2531 void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node,
2532                                   LevelDirTree *level_node)
2533 {
2534   /* recursively check all level directories for artwork sub-directories */
2535
2536   while (level_node)
2537   {
2538     char *path = getPath2(getLevelDirFromTreeInfo(level_node),
2539                           ARTWORK_DIRECTORY((*artwork_node)->type));
2540
2541 #if 0
2542     if (!level_node->parent_link)
2543       printf("CHECKING '%s' ['%s', '%s'] ...\n", path,
2544              level_node->subdir, level_node->name);
2545 #endif
2546
2547     if (!level_node->parent_link)
2548     {
2549       TreeInfo *topnode_last = *artwork_node;
2550
2551       LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path,
2552                                     (*artwork_node)->type);
2553
2554       if (topnode_last != *artwork_node)
2555       {
2556         free((*artwork_node)->identifier);
2557         free((*artwork_node)->name);
2558         free((*artwork_node)->name_sorting);
2559
2560         (*artwork_node)->identifier   = getStringCopy(level_node->subdir);
2561         (*artwork_node)->name         = getStringCopy(level_node->name);
2562         (*artwork_node)->name_sorting = getStringCopy(level_node->name);
2563
2564         (*artwork_node)->sort_priority = level_node->sort_priority;
2565         (*artwork_node)->color = LEVELCOLOR((*artwork_node));
2566       }
2567     }
2568
2569     free(path);
2570
2571     if (level_node->node_group != NULL)
2572       LoadArtworkInfoFromLevelInfo(artwork_node, level_node->node_group);
2573
2574     level_node = level_node->next;
2575   }
2576 }
2577
2578 void LoadLevelArtworkInfo()
2579 {
2580   DrawInitText("Looking for custom level artwork:", 120, FC_GREEN);
2581
2582   LoadArtworkInfoFromLevelInfo(&artwork.gfx_first, leveldir_first);
2583   LoadArtworkInfoFromLevelInfo(&artwork.snd_first, leveldir_first);
2584   LoadArtworkInfoFromLevelInfo(&artwork.mus_first, leveldir_first);
2585
2586   /* needed for reloading level artwork not known at ealier stage */
2587
2588   if (strcmp(artwork.gfx_current_identifier, setup.graphics_set) != 0)
2589   {
2590     artwork.gfx_current =
2591       getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set);
2592     if (artwork.gfx_current == NULL)
2593       artwork.gfx_current =
2594         getTreeInfoFromIdentifier(artwork.gfx_first, GFX_CLASSIC_SUBDIR);
2595     if (artwork.gfx_current == NULL)
2596       artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first);
2597   }
2598
2599   if (strcmp(artwork.snd_current_identifier, setup.sounds_set) != 0)
2600   {
2601     artwork.snd_current =
2602       getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set);
2603     if (artwork.snd_current == NULL)
2604       artwork.snd_current =
2605         getTreeInfoFromIdentifier(artwork.snd_first, SND_CLASSIC_SUBDIR);
2606     if (artwork.snd_current == NULL)
2607       artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first);
2608   }
2609
2610   if (strcmp(artwork.mus_current_identifier, setup.music_set) != 0)
2611   {
2612     artwork.mus_current =
2613       getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set);
2614     if (artwork.mus_current == NULL)
2615       artwork.mus_current =
2616         getTreeInfoFromIdentifier(artwork.mus_first, MUS_CLASSIC_SUBDIR);
2617     if (artwork.mus_current == NULL)
2618       artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first);
2619   }
2620
2621   sortTreeInfo(&artwork.gfx_first, compareTreeInfoEntries);
2622   sortTreeInfo(&artwork.snd_first, compareTreeInfoEntries);
2623   sortTreeInfo(&artwork.mus_first, compareTreeInfoEntries);
2624
2625 #if 0
2626   dumpTreeInfo(artwork.gfx_first, 0);
2627   dumpTreeInfo(artwork.snd_first, 0);
2628   dumpTreeInfo(artwork.mus_first, 0);
2629 #endif
2630 }
2631
2632 static void SaveUserLevelInfo()
2633 {
2634   LevelDirTree *level_info;
2635   char *filename;
2636   FILE *file;
2637   int i;
2638
2639   filename = getPath2(getUserLevelDir(getLoginName()), LEVELINFO_FILENAME);
2640
2641   if (!(file = fopen(filename, MODE_WRITE)))
2642   {
2643     Error(ERR_WARN, "cannot write level info file '%s'", filename);
2644     free(filename);
2645     return;
2646   }
2647
2648   level_info = newTreeInfo();
2649
2650   /* always start with reliable default values */
2651   setTreeInfoToDefaults(level_info, TREE_TYPE_LEVEL_DIR);
2652
2653 #if 1
2654   setString(&level_info->name, getLoginName());
2655   setString(&level_info->author, getRealName());
2656   level_info->levels = 100;
2657   level_info->first_level = 1;
2658 #if 0
2659   level_info->sort_priority = LEVELCLASS_PRIVATE_START;
2660   level_info->readonly = FALSE;
2661   setString(&level_info->graphics_set, GFX_CLASSIC_SUBDIR);
2662   setString(&level_info->sounds_set,   SND_CLASSIC_SUBDIR);
2663   setString(&level_info->music_set,    MUS_CLASSIC_SUBDIR);
2664 #endif
2665 #else
2666   ldi.name = getStringCopy(getLoginName());
2667   ldi.author = getStringCopy(getRealName());
2668   ldi.levels = 100;
2669   ldi.first_level = 1;
2670   ldi.sort_priority = LEVELCLASS_PRIVATE_START;
2671   ldi.readonly = FALSE;
2672   ldi.graphics_set = getStringCopy(GFX_CLASSIC_SUBDIR);
2673   ldi.sounds_set = getStringCopy(SND_CLASSIC_SUBDIR);
2674   ldi.music_set = getStringCopy(MUS_CLASSIC_SUBDIR);
2675 #endif
2676
2677   token_value_position = TOKEN_VALUE_POSITION_SHORT;
2678
2679   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
2680                                                  getCookie("LEVELINFO")));
2681
2682   ldi = *level_info;
2683   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
2684   {
2685 #if 1
2686     if (i == LEVELINFO_TOKEN_NAME ||
2687         i == LEVELINFO_TOKEN_AUTHOR ||
2688         i == LEVELINFO_TOKEN_LEVELS ||
2689         i == LEVELINFO_TOKEN_FIRST_LEVEL)
2690       fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
2691
2692     /* just to make things nicer :) */
2693     if (i == LEVELINFO_TOKEN_AUTHOR)
2694       fprintf(file, "\n");
2695 #else
2696     if (i != LEVELINFO_TOKEN_IDENTIFIER &&
2697         i != LEVELINFO_TOKEN_NAME_SORTING &&
2698         i != LEVELINFO_TOKEN_IMPORTED_FROM &&
2699         i != LEVELINFO_TOKEN_IMPORTED_BY &&
2700         i != LEVELINFO_TOKEN_FILENAME &&
2701         i != LEVELINFO_TOKEN_FILETYPE)
2702       fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
2703 #endif
2704   }
2705
2706   token_value_position = TOKEN_VALUE_POSITION_DEFAULT;
2707
2708   fclose(file);
2709
2710   SetFilePermissions(filename, PERMS_PRIVATE);
2711
2712   freeTreeInfo(level_info);
2713   free(filename);
2714 }
2715
2716 char *getSetupValue(int type, void *value)
2717 {
2718   static char value_string[MAX_LINE_LEN];
2719
2720   if (value == NULL)
2721     return NULL;
2722
2723   switch (type)
2724   {
2725     case TYPE_BOOLEAN:
2726       strcpy(value_string, (*(boolean *)value ? "true" : "false"));
2727       break;
2728
2729     case TYPE_SWITCH:
2730       strcpy(value_string, (*(boolean *)value ? "on" : "off"));
2731       break;
2732
2733     case TYPE_YES_NO:
2734       strcpy(value_string, (*(boolean *)value ? "yes" : "no"));
2735       break;
2736
2737     case TYPE_KEY:
2738       strcpy(value_string, getKeyNameFromKey(*(Key *)value));
2739       break;
2740
2741     case TYPE_KEY_X11:
2742       strcpy(value_string, getX11KeyNameFromKey(*(Key *)value));
2743       break;
2744
2745     case TYPE_INTEGER:
2746       sprintf(value_string, "%d", *(int *)value);
2747       break;
2748
2749     case TYPE_STRING:
2750       strcpy(value_string, *(char **)value);
2751       break;
2752
2753     default:
2754       value_string[0] = '\0';
2755       break;
2756   }
2757
2758   return value_string;
2759 }
2760
2761 char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
2762 {
2763   int i;
2764   char *line;
2765   static char token_string[MAX_LINE_LEN];
2766   int token_type = token_info[token_nr].type;
2767   void *setup_value = token_info[token_nr].value;
2768   char *token_text = token_info[token_nr].text;
2769   char *value_string = getSetupValue(token_type, setup_value);
2770
2771   /* build complete token string */
2772   sprintf(token_string, "%s%s", prefix, token_text);
2773
2774   /* build setup entry line */
2775   line = getFormattedSetupEntry(token_string, value_string);
2776
2777   if (token_type == TYPE_KEY_X11)
2778   {
2779     Key key = *(Key *)setup_value;
2780     char *keyname = getKeyNameFromKey(key);
2781
2782     /* add comment, if useful */
2783     if (strcmp(keyname, "(undefined)") != 0 &&
2784         strcmp(keyname, "(unknown)") != 0)
2785     {
2786       /* add at least one whitespace */
2787       strcat(line, " ");
2788       for (i = strlen(line); i < token_comment_position; i++)
2789         strcat(line, " ");
2790
2791       strcat(line, "# ");
2792       strcat(line, keyname);
2793     }
2794   }
2795
2796   return line;
2797 }
2798
2799 void LoadLevelSetup_LastSeries()
2800 {
2801   /* ----------------------------------------------------------------------- */
2802   /* ~/.<program>/levelsetup.conf                                            */
2803   /* ----------------------------------------------------------------------- */
2804
2805   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
2806   SetupFileHash *level_setup_hash = NULL;
2807
2808   /* always start with reliable default values */
2809   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
2810
2811   if ((level_setup_hash = loadSetupFileHash(filename)))
2812   {
2813     char *last_level_series =
2814       getHashEntry(level_setup_hash, TOKEN_STR_LAST_LEVEL_SERIES);
2815
2816     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
2817                                                  last_level_series);
2818     if (leveldir_current == NULL)
2819       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
2820
2821     checkSetupFileHashIdentifier(level_setup_hash, getCookie("LEVELSETUP"));
2822
2823     freeSetupFileHash(level_setup_hash);
2824   }
2825   else
2826     Error(ERR_WARN, "using default setup values");
2827
2828   free(filename);
2829 }
2830
2831 void SaveLevelSetup_LastSeries()
2832 {
2833   /* ----------------------------------------------------------------------- */
2834   /* ~/.<program>/levelsetup.conf                                            */
2835   /* ----------------------------------------------------------------------- */
2836
2837   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
2838   char *level_subdir = leveldir_current->subdir;
2839   FILE *file;
2840
2841   InitUserDataDirectory();
2842
2843   if (!(file = fopen(filename, MODE_WRITE)))
2844   {
2845     Error(ERR_WARN, "cannot write setup file '%s'", filename);
2846     free(filename);
2847     return;
2848   }
2849
2850   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
2851                                                  getCookie("LEVELSETUP")));
2852   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES,
2853                                                level_subdir));
2854
2855   fclose(file);
2856
2857   SetFilePermissions(filename, PERMS_PRIVATE);
2858
2859   free(filename);
2860 }
2861
2862 static void checkSeriesInfo()
2863 {
2864   static char *level_directory = NULL;
2865   DIR *dir;
2866   struct dirent *dir_entry;
2867
2868   /* check for more levels besides the 'levels' field of 'levelinfo.conf' */
2869
2870   level_directory = getPath2((leveldir_current->in_user_dir ?
2871                               getUserLevelDir(NULL) :
2872                               options.level_directory),
2873                              leveldir_current->fullpath);
2874
2875   if ((dir = opendir(level_directory)) == NULL)
2876   {
2877     Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
2878     return;
2879   }
2880
2881   while ((dir_entry = readdir(dir)) != NULL)    /* last directory entry */
2882   {
2883     if (strlen(dir_entry->d_name) > 4 &&
2884         dir_entry->d_name[3] == '.' &&
2885         strcmp(&dir_entry->d_name[4], LEVELFILE_EXTENSION) == 0)
2886     {
2887       char levelnum_str[4];
2888       int levelnum_value;
2889
2890       strncpy(levelnum_str, dir_entry->d_name, 3);
2891       levelnum_str[3] = '\0';
2892
2893       levelnum_value = atoi(levelnum_str);
2894
2895 #if 0
2896       if (levelnum_value < leveldir_current->first_level)
2897       {
2898         Error(ERR_WARN, "additional level %d found", levelnum_value);
2899         leveldir_current->first_level = levelnum_value;
2900       }
2901       else if (levelnum_value > leveldir_current->last_level)
2902       {
2903         Error(ERR_WARN, "additional level %d found", levelnum_value);
2904         leveldir_current->last_level = levelnum_value;
2905       }
2906 #endif
2907     }
2908   }
2909
2910   closedir(dir);
2911 }
2912
2913 void LoadLevelSetup_SeriesInfo()
2914 {
2915   char *filename;
2916   SetupFileHash *level_setup_hash = NULL;
2917   char *level_subdir = leveldir_current->subdir;
2918
2919   /* always start with reliable default values */
2920   level_nr = leveldir_current->first_level;
2921
2922   checkSeriesInfo(leveldir_current);
2923
2924   /* ----------------------------------------------------------------------- */
2925   /* ~/.<program>/levelsetup/<level series>/levelsetup.conf                  */
2926   /* ----------------------------------------------------------------------- */
2927
2928   level_subdir = leveldir_current->subdir;
2929
2930   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
2931
2932   if ((level_setup_hash = loadSetupFileHash(filename)))
2933   {
2934     char *token_value;
2935
2936     token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL);
2937
2938     if (token_value)
2939     {
2940       level_nr = atoi(token_value);
2941
2942       if (level_nr < leveldir_current->first_level)
2943         level_nr = leveldir_current->first_level;
2944       if (level_nr > leveldir_current->last_level)
2945         level_nr = leveldir_current->last_level;
2946     }
2947
2948     token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL);
2949
2950     if (token_value)
2951     {
2952       int level_nr = atoi(token_value);
2953
2954       if (level_nr < leveldir_current->first_level)
2955         level_nr = leveldir_current->first_level;
2956       if (level_nr > leveldir_current->last_level + 1)
2957         level_nr = leveldir_current->last_level;
2958
2959       if (leveldir_current->user_defined || !leveldir_current->handicap)
2960         level_nr = leveldir_current->last_level;
2961
2962       leveldir_current->handicap_level = level_nr;
2963     }
2964
2965     checkSetupFileHashIdentifier(level_setup_hash, getCookie("LEVELSETUP"));
2966
2967     freeSetupFileHash(level_setup_hash);
2968   }
2969   else
2970     Error(ERR_WARN, "using default setup values");
2971
2972   free(filename);
2973 }
2974
2975 void SaveLevelSetup_SeriesInfo()
2976 {
2977   char *filename;
2978   char *level_subdir = leveldir_current->subdir;
2979   char *level_nr_str = int2str(level_nr, 0);
2980   char *handicap_level_str = int2str(leveldir_current->handicap_level, 0);
2981   FILE *file;
2982
2983   /* ----------------------------------------------------------------------- */
2984   /* ~/.<program>/levelsetup/<level series>/levelsetup.conf                  */
2985   /* ----------------------------------------------------------------------- */
2986
2987   InitLevelSetupDirectory(level_subdir);
2988
2989   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
2990
2991   if (!(file = fopen(filename, MODE_WRITE)))
2992   {
2993     Error(ERR_WARN, "cannot write setup file '%s'", filename);
2994     free(filename);
2995     return;
2996   }
2997
2998   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
2999                                                  getCookie("LEVELSETUP")));
3000   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_PLAYED_LEVEL,
3001                                                level_nr_str));
3002   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL,
3003                                                handicap_level_str));
3004
3005   fclose(file);
3006
3007   SetFilePermissions(filename, PERMS_PRIVATE);
3008
3009   free(filename);
3010 }