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 and artwork 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 TreeInfo *cloneTreeNode(TreeInfo **node_top, TreeInfo *node_parent,
 931                         TreeInfo *node, boolean skip_sets_without_levels)
 932 {
 933   TreeInfo *node_new;
 934
 935   if (node == NULL)
 936     return NULL;
 937
 938   if (!node->parent_link && !node->level_group &&
 939       skip_sets_without_levels && node->levels == 0)
 940     return cloneTreeNode(node_top, node_parent, node->next,
 941                          skip_sets_without_levels);
 942
 943   node_new = newTreeInfo();
 944
 945   *node_new = *node;                            /* copy complete node */
 946
 947   node_new->node_top = node_top;                /* correct top node link */
 948   node_new->node_parent = node_parent;          /* correct parent node link */
 949
 950   if (node->level_group)
 951     node_new->node_group = cloneTreeNode(node_top, node_new, node->node_group,
 952                                          skip_sets_without_levels);
 953
 954   node_new->next = cloneTreeNode(node_top, node_parent, node->next,
 955                                  skip_sets_without_levels);
 956
 957   return node_new;
 958 }
 959
 960 void cloneTree(TreeInfo **ti_new, TreeInfo *ti, boolean skip_empty_sets)
 961 {
 962   TreeInfo *ti_cloned = cloneTreeNode(ti_new, NULL, ti, skip_empty_sets);
 963
 964   *ti_new = ti_cloned;
 965 }
 966
 967 void dumpTreeInfo(TreeInfo *node, int depth)
 968 {
 969   int i;
 970
 971   printf("Dumping TreeInfo:\n");
 972
 973   while (node)
 974   {
 975     for (i = 0; i < (depth + 1) * 3; i++)
 976       printf(" ");
 977
 978     printf("subdir == '%s' ['%s', '%s'] [%d])\n",
 979            node->subdir, node->fullpath, node->basepath, node->in_user_dir);
 980
 981     if (node->node_group != NULL)
 982       dumpTreeInfo(node->node_group, depth + 1);
 983
 984     node = node->next;
 985   }
 986 }
 987
 988 void sortTreeInfo(TreeInfo **node_first,
 989                   int (*compare_function)(const void *, const void *))
 990 {
 991   int num_nodes = numTreeInfo(*node_first);
 992   TreeInfo **sort_array;
 993   TreeInfo *node = *node_first;
 994   int i = 0;
 995
 996   if (num_nodes == 0)
 997     return;
 998
 999   /* allocate array for sorting structure pointers */
1000   sort_array = checked_calloc(num_nodes * sizeof(TreeInfo *));
1001
1002   /* writing structure pointers to sorting array */
1003   while (i < num_nodes && node)         /* double boundary check... */
1004   {
1005     sort_array[i] = node;
1006
1007     i++;
1008     node = node->next;
1009   }
1010
1011   /* sorting the structure pointers in the sorting array */
1012   qsort(sort_array, num_nodes, sizeof(TreeInfo *),
1013         compare_function);
1014
1015   /* update the linkage of list elements with the sorted node array */
1016   for (i = 0; i < num_nodes - 1; i++)
1017     sort_array[i]->next = sort_array[i + 1];
1018   sort_array[num_nodes - 1]->next = NULL;
1019
1020   /* update the linkage of the main list anchor pointer */
1021   *node_first = sort_array[0];
1022
1023   free(sort_array);
1024
1025   /* now recursively sort the level group structures */
1026   node = *node_first;
1027   while (node)
1028   {
1029     if (node->node_group != NULL)
1030       sortTreeInfo(&node->node_group, compare_function);
1031
1032     node = node->next;
1033   }
1034 }
1035
1036
1037 /* ========================================================================= */
1038 /* some stuff from "files.c"                                                 */
1039 /* ========================================================================= */
1040
1041 #if defined(PLATFORM_WIN32)
1042 #ifndef S_IRGRP
1043 #define S_IRGRP S_IRUSR
1044 #endif
1045 #ifndef S_IROTH
1046 #define S_IROTH S_IRUSR
1047 #endif
1048 #ifndef S_IWGRP
1049 #define S_IWGRP S_IWUSR
1050 #endif
1051 #ifndef S_IWOTH
1052 #define S_IWOTH S_IWUSR
1053 #endif
1054 #ifndef S_IXGRP
1055 #define S_IXGRP S_IXUSR
1056 #endif
1057 #ifndef S_IXOTH
1058 #define S_IXOTH S_IXUSR
1059 #endif
1060 #ifndef S_IRWXG
1061 #define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
1062 #endif
1063 #ifndef S_ISGID
1064 #define S_ISGID 0
1065 #endif
1066 #endif  /* PLATFORM_WIN32 */
1067
1068 /* file permissions for newly written files */
1069 #define MODE_R_ALL              (S_IRUSR | S_IRGRP | S_IROTH)
1070 #define MODE_W_ALL              (S_IWUSR | S_IWGRP | S_IWOTH)
1071 #define MODE_X_ALL              (S_IXUSR | S_IXGRP | S_IXOTH)
1072
1073 #define MODE_W_PRIVATE          (S_IWUSR)
1074 #define MODE_W_PUBLIC           (S_IWUSR | S_IWGRP)
1075 #define MODE_W_PUBLIC_DIR       (S_IWUSR | S_IWGRP | S_ISGID)
1076
1077 #define DIR_PERMS_PRIVATE       (MODE_R_ALL | MODE_X_ALL | MODE_W_PRIVATE)
1078 #define DIR_PERMS_PUBLIC        (MODE_R_ALL | MODE_X_ALL | MODE_W_PUBLIC_DIR)
1079
1080 #define FILE_PERMS_PRIVATE      (MODE_R_ALL | MODE_W_PRIVATE)
1081 #define FILE_PERMS_PUBLIC       (MODE_R_ALL | MODE_W_PUBLIC)
1082
1083 char *getUserDataDir(void)
1084 {
1085   static char *userdata_dir = NULL;
1086
1087   if (userdata_dir == NULL)
1088     userdata_dir = getPath2(getHomeDir(), program.userdata_directory);
1089
1090   return userdata_dir;
1091 }
1092
1093 char *getCommonDataDir(void)
1094 {
1095   static char *common_data_dir = NULL;
1096
1097 #if defined(PLATFORM_WIN32)
1098   if (common_data_dir == NULL)
1099   {
1100     char *dir = checked_malloc(MAX_PATH + 1);
1101
1102     if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, dir))
1103         && strcmp(dir, "") != 0)        /* empty for Windows 95/98 */
1104       common_data_dir = getPath2(dir, program.userdata_directory);
1105     else
1106       common_data_dir = options.rw_base_directory;
1107   }
1108 #else
1109   if (common_data_dir == NULL)
1110     common_data_dir = options.rw_base_directory;
1111 #endif
1112
1113   return common_data_dir;
1114 }
1115
1116 char *getSetupDir()
1117 {
1118   return getUserDataDir();
1119 }
1120
1121 static mode_t posix_umask(mode_t mask)
1122 {
1123 #if defined(PLATFORM_UNIX)
1124   return umask(mask);
1125 #else
1126   return 0;
1127 #endif
1128 }
1129
1130 static int posix_mkdir(const char *pathname, mode_t mode)
1131 {
1132 #if defined(PLATFORM_WIN32)
1133   return mkdir(pathname);
1134 #else
1135   return mkdir(pathname, mode);
1136 #endif
1137 }
1138
1139 void createDirectory(char *dir, char *text, int permission_class)
1140 {
1141   /* leave "other" permissions in umask untouched, but ensure group parts
1142      of USERDATA_DIR_MODE are not masked */
1143   mode_t dir_mode = (permission_class == PERMS_PRIVATE ?
1144                      DIR_PERMS_PRIVATE : DIR_PERMS_PUBLIC);
1145   mode_t normal_umask = posix_umask(0);
1146   mode_t group_umask = ~(dir_mode & S_IRWXG);
1147   posix_umask(normal_umask & group_umask);
1148
1149   if (!fileExists(dir))
1150     if (posix_mkdir(dir, dir_mode) != 0)
1151       Error(ERR_WARN, "cannot create %s directory '%s'", text, dir);
1152
1153   posix_umask(normal_umask);            /* reset normal umask */
1154 }
1155
1156 void InitUserDataDirectory()
1157 {
1158   createDirectory(getUserDataDir(), "user data", PERMS_PRIVATE);
1159 }
1160
1161 void SetFilePermissions(char *filename, int permission_class)
1162 {
1163   chmod(filename, (permission_class == PERMS_PRIVATE ?
1164                    FILE_PERMS_PRIVATE : FILE_PERMS_PUBLIC));
1165 }
1166
1167 char *getCookie(char *file_type)
1168 {
1169   static char cookie[MAX_COOKIE_LEN + 1];
1170
1171   if (strlen(program.cookie_prefix) + 1 +
1172       strlen(file_type) + strlen("_FILE_VERSION_x.x") > MAX_COOKIE_LEN)
1173     return "[COOKIE ERROR]";    /* should never happen */
1174
1175   sprintf(cookie, "%s_%s_FILE_VERSION_%d.%d",
1176           program.cookie_prefix, file_type,
1177           program.version_major, program.version_minor);
1178
1179   return cookie;
1180 }
1181
1182 int getFileVersionFromCookieString(const char *cookie)
1183 {
1184   const char *ptr_cookie1, *ptr_cookie2;
1185   const char *pattern1 = "_FILE_VERSION_";
1186   const char *pattern2 = "?.?";
1187   const int len_cookie = strlen(cookie);
1188   const int len_pattern1 = strlen(pattern1);
1189   const int len_pattern2 = strlen(pattern2);
1190   const int len_pattern = len_pattern1 + len_pattern2;
1191   int version_major, version_minor;
1192
1193   if (len_cookie <= len_pattern)
1194     return -1;
1195
1196   ptr_cookie1 = &cookie[len_cookie - len_pattern];
1197   ptr_cookie2 = &cookie[len_cookie - len_pattern2];
1198
1199   if (strncmp(ptr_cookie1, pattern1, len_pattern1) != 0)
1200     return -1;
1201
1202   if (ptr_cookie2[0] < '0' || ptr_cookie2[0] > '9' ||
1203       ptr_cookie2[1] != '.' ||
1204       ptr_cookie2[2] < '0' || ptr_cookie2[2] > '9')
1205     return -1;
1206
1207   version_major = ptr_cookie2[0] - '0';
1208   version_minor = ptr_cookie2[2] - '0';
1209
1210   return VERSION_IDENT(version_major, version_minor, 0, 0);
1211 }
1212
1213 boolean checkCookieString(const char *cookie, const char *template)
1214 {
1215   const char *pattern = "_FILE_VERSION_?.?";
1216   const int len_cookie = strlen(cookie);
1217   const int len_template = strlen(template);
1218   const int len_pattern = strlen(pattern);
1219
1220   if (len_cookie != len_template)
1221     return FALSE;
1222
1223   if (strncmp(cookie, template, len_cookie - len_pattern) != 0)
1224     return FALSE;
1225
1226   return TRUE;
1227 }
1228
1229 /* ------------------------------------------------------------------------- */
1230 /* setup file list and hash handling functions                               */
1231 /* ------------------------------------------------------------------------- */
1232
1233 char *getFormattedSetupEntry(char *token, char *value)
1234 {
1235   int i;
1236   static char entry[MAX_LINE_LEN];
1237
1238   /* if value is an empty string, just return token without value */
1239   if (*value == '\0')
1240     return token;
1241
1242   /* start with the token and some spaces to format output line */
1243   sprintf(entry, "%s:", token);
1244   for (i = strlen(entry); i < token_value_position; i++)
1245     strcat(entry, " ");
1246
1247   /* continue with the token's value */
1248   strcat(entry, value);
1249
1250   return entry;
1251 }
1252
1253 SetupFileList *newSetupFileList(char *token, char *value)
1254 {
1255   SetupFileList *new = checked_malloc(sizeof(SetupFileList));
1256
1257   new->token = getStringCopy(token);
1258   new->value = getStringCopy(value);
1259
1260   new->next = NULL;
1261
1262   return new;
1263 }
1264
1265 void freeSetupFileList(SetupFileList *list)
1266 {
1267   if (list == NULL)
1268     return;
1269
1270   checked_free(list->token);
1271   checked_free(list->value);
1272
1273   if (list->next)
1274     freeSetupFileList(list->next);
1275
1276   free(list);
1277 }
1278
1279 char *getListEntry(SetupFileList *list, char *token)
1280 {
1281   if (list == NULL)
1282     return NULL;
1283
1284   if (strcmp(list->token, token) == 0)
1285     return list->value;
1286   else
1287     return getListEntry(list->next, token);
1288 }
1289
1290 SetupFileList *setListEntry(SetupFileList *list, char *token, char *value)
1291 {
1292   if (list == NULL)
1293     return NULL;
1294
1295   if (strcmp(list->token, token) == 0)
1296   {
1297     checked_free(list->value);
1298
1299     list->value = getStringCopy(value);
1300
1301     return list;
1302   }
1303   else if (list->next == NULL)
1304     return (list->next = newSetupFileList(token, value));
1305   else
1306     return setListEntry(list->next, token, value);
1307 }
1308
1309 SetupFileList *addListEntry(SetupFileList *list, char *token, char *value)
1310 {
1311   if (list == NULL)
1312     return NULL;
1313
1314   if (list->next == NULL)
1315     return (list->next = newSetupFileList(token, value));
1316   else
1317     return addListEntry(list->next, token, value);
1318 }
1319
1320 #ifdef DEBUG
1321 static void printSetupFileList(SetupFileList *list)
1322 {
1323   if (!list)
1324     return;
1325
1326   printf("token: '%s'\n", list->token);
1327   printf("value: '%s'\n", list->value);
1328
1329   printSetupFileList(list->next);
1330 }
1331 #endif
1332
1333 #ifdef DEBUG
1334 DEFINE_HASHTABLE_INSERT(insert_hash_entry, char, char);
1335 DEFINE_HASHTABLE_SEARCH(search_hash_entry, char, char);
1336 DEFINE_HASHTABLE_CHANGE(change_hash_entry, char, char);
1337 DEFINE_HASHTABLE_REMOVE(remove_hash_entry, char, char);
1338 #else
1339 #define insert_hash_entry hashtable_insert
1340 #define search_hash_entry hashtable_search
1341 #define change_hash_entry hashtable_change
1342 #define remove_hash_entry hashtable_remove
1343 #endif
1344
1345 static unsigned int get_hash_from_key(void *key)
1346 {
1347   /*
1348     djb2
1349
1350     This algorithm (k=33) was first reported by Dan Bernstein many years ago in
1351     'comp.lang.c'. Another version of this algorithm (now favored by Bernstein)
1352     uses XOR: hash(i) = hash(i - 1) * 33 ^ str[i]; the magic of number 33 (why
1353     it works better than many other constants, prime or not) has never been
1354     adequately explained.
1355
1356     If you just want to have a good hash function, and cannot wait, djb2
1357     is one of the best string hash functions i know. It has excellent
1358     distribution and speed on many different sets of keys and table sizes.
1359     You are not likely to do better with one of the "well known" functions
1360     such as PJW, K&R, etc.
1361
1362     Ozan (oz) Yigit [http://www.cs.yorku.ca/~oz/hash.html]
1363   */
1364
1365   char *str = (char *)key;
1366   unsigned int hash = 5381;
1367   int c;
1368
1369   while ((c = *str++))
1370     hash = ((hash << 5) + hash) + c;    /* hash * 33 + c */
1371
1372   return hash;
1373 }
1374
1375 static int keys_are_equal(void *key1, void *key2)
1376 {
1377   return (strcmp((char *)key1, (char *)key2) == 0);
1378 }
1379
1380 SetupFileHash *newSetupFileHash()
1381 {
1382   SetupFileHash *new_hash =
1383     create_hashtable(16, 0.75, get_hash_from_key, keys_are_equal);
1384
1385   if (new_hash == NULL)
1386     Error(ERR_EXIT, "create_hashtable() failed -- out of memory");
1387
1388   return new_hash;
1389 }
1390
1391 void freeSetupFileHash(SetupFileHash *hash)
1392 {
1393   if (hash == NULL)
1394     return;
1395
1396   hashtable_destroy(hash, 1);   /* 1 == also free values stored in hash */
1397 }
1398
1399 char *getHashEntry(SetupFileHash *hash, char *token)
1400 {
1401   if (hash == NULL)
1402     return NULL;
1403
1404   return search_hash_entry(hash, token);
1405 }
1406
1407 void setHashEntry(SetupFileHash *hash, char *token, char *value)
1408 {
1409   char *value_copy;
1410
1411   if (hash == NULL)
1412     return;
1413
1414   value_copy = getStringCopy(value);
1415
1416   /* change value; if it does not exist, insert it as new */
1417   if (!change_hash_entry(hash, token, value_copy))
1418     if (!insert_hash_entry(hash, getStringCopy(token), value_copy))
1419       Error(ERR_EXIT, "cannot insert into hash -- aborting");
1420 }
1421
1422 char *removeHashEntry(SetupFileHash *hash, char *token)
1423 {
1424   if (hash == NULL)
1425     return NULL;
1426
1427   return remove_hash_entry(hash, token);
1428 }
1429
1430 #if 0
1431 static void printSetupFileHash(SetupFileHash *hash)
1432 {
1433   BEGIN_HASH_ITERATION(hash, itr)
1434   {
1435     printf("token: '%s'\n", HASH_ITERATION_TOKEN(itr));
1436     printf("value: '%s'\n", HASH_ITERATION_VALUE(itr));
1437   }
1438   END_HASH_ITERATION(hash, itr)
1439 }
1440 #endif
1441
1442 static void *loadSetupFileData(char *filename, boolean use_hash)
1443 {
1444   char line[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
1445   char *token, *value, *line_ptr;
1446   void *setup_file_data, *insert_ptr = NULL;
1447   boolean read_continued_line = FALSE;
1448   FILE *file;
1449
1450   if (!(file = fopen(filename, MODE_READ)))
1451   {
1452     Error(ERR_WARN, "cannot open configuration file '%s'", filename);
1453
1454     return NULL;
1455   }
1456
1457   if (use_hash)
1458     setup_file_data = newSetupFileHash();
1459   else
1460     insert_ptr = setup_file_data = newSetupFileList("", "");
1461
1462   while (!feof(file))
1463   {
1464     /* read next line of input file */
1465     if (!fgets(line, MAX_LINE_LEN, file))
1466       break;
1467
1468     /* cut trailing newline or carriage return */
1469     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
1470       if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
1471         *line_ptr = '\0';
1472
1473     if (read_continued_line)
1474     {
1475       /* cut leading whitespaces from input line */
1476       for (line_ptr = line; *line_ptr; line_ptr++)
1477         if (*line_ptr != ' ' && *line_ptr != '\t')
1478           break;
1479
1480       /* append new line to existing line, if there is enough space */
1481       if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
1482         strcat(previous_line, line_ptr);
1483
1484       strcpy(line, previous_line);      /* copy storage buffer to line */
1485
1486       read_continued_line = FALSE;
1487     }
1488
1489     /* if the last character is '\', continue at next line */
1490     if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
1491     {
1492       line[strlen(line) - 1] = '\0';    /* cut off trailing backslash */
1493       strcpy(previous_line, line);      /* copy line to storage buffer */
1494
1495       read_continued_line = TRUE;
1496
1497       continue;
1498     }
1499
1500     /* cut trailing comment from input line */
1501     for (line_ptr = line; *line_ptr; line_ptr++)
1502     {
1503       if (*line_ptr == '#')
1504       {
1505         *line_ptr = '\0';
1506         break;
1507       }
1508     }
1509
1510     /* cut trailing whitespaces from input line */
1511     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
1512       if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
1513         *line_ptr = '\0';
1514
1515     /* ignore empty lines */
1516     if (*line == '\0')
1517       continue;
1518
1519     /* cut leading whitespaces from token */
1520     for (token = line; *token; token++)
1521       if (*token != ' ' && *token != '\t')
1522         break;
1523
1524     /* start with empty value as reliable default */
1525     value = "";
1526
1527     /* find end of token to determine start of value */
1528     for (line_ptr = token; *line_ptr; line_ptr++)
1529     {
1530       if (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == ':')
1531       {
1532         *line_ptr = '\0';               /* terminate token string */
1533         value = line_ptr + 1;           /* set beginning of value */
1534
1535         break;
1536       }
1537     }
1538
1539     /* cut leading whitespaces from value */
1540     for (; *value; value++)
1541       if (*value != ' ' && *value != '\t')
1542         break;
1543
1544 #if 0
1545     if (*value == '\0')
1546       value = "true";   /* treat tokens without value as "true" */
1547 #endif
1548
1549     if (*token)
1550     {
1551       if (use_hash)
1552         setHashEntry((SetupFileHash *)setup_file_data, token, value);
1553       else
1554         insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value);
1555     }
1556   }
1557
1558   fclose(file);
1559
1560   if (use_hash)
1561   {
1562     if (hashtable_count((SetupFileHash *)setup_file_data) == 0)
1563       Error(ERR_WARN, "configuration file '%s' is empty", filename);
1564   }
1565   else
1566   {
1567     SetupFileList *setup_file_list = (SetupFileList *)setup_file_data;
1568     SetupFileList *first_valid_list_entry = setup_file_list->next;
1569
1570     /* free empty list header */
1571     setup_file_list->next = NULL;
1572     freeSetupFileList(setup_file_list);
1573     setup_file_data = first_valid_list_entry;
1574
1575     if (first_valid_list_entry == NULL)
1576       Error(ERR_WARN, "configuration file '%s' is empty", filename);
1577   }
1578
1579   return setup_file_data;
1580 }
1581
1582 SetupFileList *loadSetupFileList(char *filename)
1583 {
1584   return (SetupFileList *)loadSetupFileData(filename, FALSE);
1585 }
1586
1587 SetupFileHash *loadSetupFileHash(char *filename)
1588 {
1589   return (SetupFileHash *)loadSetupFileData(filename, TRUE);
1590 }
1591
1592 void checkSetupFileHashIdentifier(SetupFileHash *setup_file_hash,
1593                                   char *identifier)
1594 {
1595   char *value = getHashEntry(setup_file_hash, TOKEN_STR_FILE_IDENTIFIER);
1596
1597   if (value == NULL)
1598     Error(ERR_WARN, "configuration file has no file identifier");
1599   else if (!checkCookieString(value, identifier))
1600     Error(ERR_WARN, "configuration file has wrong file identifier");
1601 }
1602
1603
1604 /* ========================================================================= */
1605 /* setup file stuff                                                          */
1606 /* ========================================================================= */
1607
1608 #define TOKEN_STR_LAST_LEVEL_SERIES     "last_level_series"
1609 #define TOKEN_STR_LAST_PLAYED_LEVEL     "last_played_level"
1610 #define TOKEN_STR_HANDICAP_LEVEL        "handicap_level"
1611
1612 /* level directory info */
1613 #define LEVELINFO_TOKEN_IDENTIFIER      0
1614 #define LEVELINFO_TOKEN_NAME            1
1615 #define LEVELINFO_TOKEN_NAME_SORTING    2
1616 #define LEVELINFO_TOKEN_AUTHOR          3
1617 #define LEVELINFO_TOKEN_IMPORTED_FROM   4
1618 #define LEVELINFO_TOKEN_IMPORTED_BY     5
1619 #define LEVELINFO_TOKEN_LEVELS          6
1620 #define LEVELINFO_TOKEN_FIRST_LEVEL     7
1621 #define LEVELINFO_TOKEN_SORT_PRIORITY   8
1622 #define LEVELINFO_TOKEN_LATEST_ENGINE   9
1623 #define LEVELINFO_TOKEN_LEVEL_GROUP     10
1624 #define LEVELINFO_TOKEN_READONLY        11
1625 #define LEVELINFO_TOKEN_GRAPHICS_SET    12
1626 #define LEVELINFO_TOKEN_SOUNDS_SET      13
1627 #define LEVELINFO_TOKEN_MUSIC_SET       14
1628 #define LEVELINFO_TOKEN_FILENAME        15
1629 #define LEVELINFO_TOKEN_FILETYPE        16
1630 #define LEVELINFO_TOKEN_HANDICAP        17
1631 #define LEVELINFO_TOKEN_SKIP_LEVELS     18
1632
1633 #define NUM_LEVELINFO_TOKENS            19
1634
1635 static LevelDirTree ldi;
1636
1637 static struct TokenInfo levelinfo_tokens[] =
1638 {
1639   /* level directory info */
1640   { TYPE_STRING,        &ldi.identifier,        "identifier"    },
1641   { TYPE_STRING,        &ldi.name,              "name"          },
1642   { TYPE_STRING,        &ldi.name_sorting,      "name_sorting"  },
1643   { TYPE_STRING,        &ldi.author,            "author"        },
1644   { TYPE_STRING,        &ldi.imported_from,     "imported_from" },
1645   { TYPE_STRING,        &ldi.imported_by,       "imported_by"   },
1646   { TYPE_INTEGER,       &ldi.levels,            "levels"        },
1647   { TYPE_INTEGER,       &ldi.first_level,       "first_level"   },
1648   { TYPE_INTEGER,       &ldi.sort_priority,     "sort_priority" },
1649   { TYPE_BOOLEAN,       &ldi.latest_engine,     "latest_engine" },
1650   { TYPE_BOOLEAN,       &ldi.level_group,       "level_group"   },
1651   { TYPE_BOOLEAN,       &ldi.readonly,          "readonly"      },
1652   { TYPE_STRING,        &ldi.graphics_set,      "graphics_set"  },
1653   { TYPE_STRING,        &ldi.sounds_set,        "sounds_set"    },
1654   { TYPE_STRING,        &ldi.music_set,         "music_set"     },
1655   { TYPE_STRING,        &ldi.level_filename,    "filename"      },
1656   { TYPE_STRING,        &ldi.level_filetype,    "filetype"      },
1657   { TYPE_BOOLEAN,       &ldi.handicap,          "handicap"      },
1658   { TYPE_BOOLEAN,       &ldi.skip_levels,       "skip_levels"   }
1659 };
1660
1661 static void setTreeInfoToDefaults(TreeInfo *ldi, int type)
1662 {
1663   ldi->type = type;
1664
1665   ldi->node_top = (ldi->type == TREE_TYPE_LEVEL_DIR ? &leveldir_first :
1666                    ldi->type == TREE_TYPE_GRAPHICS_DIR ? &artwork.gfx_first :
1667                    ldi->type == TREE_TYPE_SOUNDS_DIR ? &artwork.snd_first :
1668                    ldi->type == TREE_TYPE_MUSIC_DIR ? &artwork.mus_first :
1669                    NULL);
1670
1671   ldi->node_parent = NULL;
1672   ldi->node_group = NULL;
1673   ldi->next = NULL;
1674
1675   ldi->cl_first = -1;
1676   ldi->cl_cursor = -1;
1677
1678   ldi->subdir = NULL;
1679   ldi->fullpath = NULL;
1680   ldi->basepath = NULL;
1681   ldi->identifier = NULL;
1682   ldi->name = getStringCopy(ANONYMOUS_NAME);
1683   ldi->name_sorting = NULL;
1684   ldi->author = getStringCopy(ANONYMOUS_NAME);
1685
1686   ldi->sort_priority = LEVELCLASS_UNDEFINED;    /* default: least priority */
1687   ldi->latest_engine = FALSE;                   /* default: get from level */
1688   ldi->parent_link = FALSE;
1689   ldi->in_user_dir = FALSE;
1690   ldi->user_defined = FALSE;
1691   ldi->color = 0;
1692   ldi->class_desc = NULL;
1693
1694   if (ldi->type == TREE_TYPE_LEVEL_DIR)
1695   {
1696     ldi->imported_from = NULL;
1697     ldi->imported_by = NULL;
1698
1699     ldi->graphics_set = NULL;
1700     ldi->sounds_set = NULL;
1701     ldi->music_set = NULL;
1702     ldi->graphics_path = getStringCopy(UNDEFINED_FILENAME);
1703     ldi->sounds_path = getStringCopy(UNDEFINED_FILENAME);
1704     ldi->music_path = getStringCopy(UNDEFINED_FILENAME);
1705
1706     ldi->level_filename = NULL;
1707     ldi->level_filetype = NULL;
1708
1709     ldi->levels = 0;
1710     ldi->first_level = 0;
1711     ldi->last_level = 0;
1712     ldi->level_group = FALSE;
1713     ldi->handicap_level = 0;
1714     ldi->readonly = TRUE;
1715     ldi->handicap = TRUE;
1716     ldi->skip_levels = FALSE;
1717   }
1718 }
1719
1720 static void setTreeInfoToDefaultsFromParent(TreeInfo *ldi, TreeInfo *parent)
1721 {
1722   if (parent == NULL)
1723   {
1724     Error(ERR_WARN, "setTreeInfoToDefaultsFromParent(): parent == NULL");
1725
1726     setTreeInfoToDefaults(ldi, TREE_TYPE_UNDEFINED);
1727
1728     return;
1729   }
1730
1731   /* copy all values from the parent structure */
1732
1733   ldi->type = parent->type;
1734
1735   ldi->node_top = parent->node_top;
1736   ldi->node_parent = parent;
1737   ldi->node_group = NULL;
1738   ldi->next = NULL;
1739
1740   ldi->cl_first = -1;
1741   ldi->cl_cursor = -1;
1742
1743   ldi->subdir = NULL;
1744   ldi->fullpath = NULL;
1745   ldi->basepath = NULL;
1746   ldi->identifier = NULL;
1747   ldi->name = getStringCopy(ANONYMOUS_NAME);
1748   ldi->name_sorting = NULL;
1749   ldi->author = getStringCopy(parent->author);
1750
1751   ldi->sort_priority = parent->sort_priority;
1752   ldi->latest_engine = parent->latest_engine;
1753   ldi->parent_link = FALSE;
1754   ldi->in_user_dir = parent->in_user_dir;
1755   ldi->user_defined = parent->user_defined;
1756   ldi->color = parent->color;
1757   ldi->class_desc = getStringCopy(parent->class_desc);
1758
1759   if (ldi->type == TREE_TYPE_LEVEL_DIR)
1760   {
1761     ldi->imported_from = getStringCopy(parent->imported_from);
1762     ldi->imported_by = getStringCopy(parent->imported_by);
1763
1764     ldi->graphics_set = NULL;
1765     ldi->sounds_set = NULL;
1766     ldi->music_set = NULL;
1767     ldi->graphics_path = getStringCopy(UNDEFINED_FILENAME);
1768     ldi->sounds_path = getStringCopy(UNDEFINED_FILENAME);
1769     ldi->music_path = getStringCopy(UNDEFINED_FILENAME);
1770
1771     ldi->level_filename = NULL;
1772     ldi->level_filetype = NULL;
1773
1774     ldi->levels = 0;
1775     ldi->first_level = 0;
1776     ldi->last_level = 0;
1777     ldi->level_group = FALSE;
1778     ldi->handicap_level = 0;
1779     ldi->readonly = TRUE;
1780     ldi->handicap = TRUE;
1781     ldi->skip_levels = FALSE;
1782   }
1783 }
1784
1785 static void freeTreeInfo(TreeInfo *ldi)
1786 {
1787   checked_free(ldi->subdir);
1788   checked_free(ldi->fullpath);
1789   checked_free(ldi->basepath);
1790   checked_free(ldi->identifier);
1791
1792   checked_free(ldi->name);
1793   checked_free(ldi->name_sorting);
1794   checked_free(ldi->author);
1795
1796   checked_free(ldi->class_desc);
1797
1798   if (ldi->type == TREE_TYPE_LEVEL_DIR)
1799   {
1800     checked_free(ldi->imported_from);
1801     checked_free(ldi->imported_by);
1802
1803     checked_free(ldi->graphics_set);
1804     checked_free(ldi->sounds_set);
1805     checked_free(ldi->music_set);
1806
1807     checked_free(ldi->graphics_path);
1808     checked_free(ldi->sounds_path);
1809     checked_free(ldi->music_path);
1810
1811     checked_free(ldi->level_filename);
1812     checked_free(ldi->level_filetype);
1813   }
1814 }
1815
1816 void setSetupInfo(struct TokenInfo *token_info,
1817                   int token_nr, char *token_value)
1818 {
1819   int token_type = token_info[token_nr].type;
1820   void *setup_value = token_info[token_nr].value;
1821
1822   if (token_value == NULL)
1823     return;
1824
1825   /* set setup field to corresponding token value */
1826   switch (token_type)
1827   {
1828     case TYPE_BOOLEAN:
1829     case TYPE_SWITCH:
1830       *(boolean *)setup_value = get_boolean_from_string(token_value);
1831       break;
1832
1833     case TYPE_KEY:
1834       *(Key *)setup_value = getKeyFromKeyName(token_value);
1835       break;
1836
1837     case TYPE_KEY_X11:
1838       *(Key *)setup_value = getKeyFromX11KeyName(token_value);
1839       break;
1840
1841     case TYPE_INTEGER:
1842       *(int *)setup_value = get_integer_from_string(token_value);
1843       break;
1844
1845     case TYPE_STRING:
1846       checked_free(*(char **)setup_value);
1847       *(char **)setup_value = getStringCopy(token_value);
1848       break;
1849
1850     default:
1851       break;
1852   }
1853 }
1854
1855 static int compareTreeInfoEntries(const void *object1, const void *object2)
1856 {
1857   const TreeInfo *entry1 = *((TreeInfo **)object1);
1858   const TreeInfo *entry2 = *((TreeInfo **)object2);
1859   int class_sorting1, class_sorting2;
1860   int compare_result;
1861
1862   if (entry1->type == TREE_TYPE_LEVEL_DIR)
1863   {
1864     class_sorting1 = LEVELSORTING(entry1);
1865     class_sorting2 = LEVELSORTING(entry2);
1866   }
1867   else
1868   {
1869     class_sorting1 = ARTWORKSORTING(entry1);
1870     class_sorting2 = ARTWORKSORTING(entry2);
1871   }
1872
1873   if (entry1->parent_link || entry2->parent_link)
1874     compare_result = (entry1->parent_link ? -1 : +1);
1875   else if (entry1->sort_priority == entry2->sort_priority)
1876   {
1877     char *name1 = getStringToLower(entry1->name_sorting);
1878     char *name2 = getStringToLower(entry2->name_sorting);
1879
1880     compare_result = strcmp(name1, name2);
1881
1882     free(name1);
1883     free(name2);
1884   }
1885   else if (class_sorting1 == class_sorting2)
1886     compare_result = entry1->sort_priority - entry2->sort_priority;
1887   else
1888     compare_result = class_sorting1 - class_sorting2;
1889
1890   return compare_result;
1891 }
1892
1893 static void createParentTreeInfoNode(TreeInfo *node_parent)
1894 {
1895   TreeInfo *ti_new;
1896
1897   if (node_parent == NULL)
1898     return;
1899
1900   ti_new = newTreeInfo();
1901   setTreeInfoToDefaults(ti_new, node_parent->type);
1902
1903   ti_new->node_parent = node_parent;
1904   ti_new->parent_link = TRUE;
1905
1906   setString(&ti_new->identifier, node_parent->identifier);
1907   setString(&ti_new->name, ".. (parent directory)");
1908   setString(&ti_new->name_sorting, ti_new->name);
1909
1910   setString(&ti_new->subdir, "..");
1911   setString(&ti_new->fullpath, node_parent->fullpath);
1912
1913   ti_new->sort_priority = node_parent->sort_priority;
1914   ti_new->latest_engine = node_parent->latest_engine;
1915
1916   setString(&ti_new->class_desc, getLevelClassDescription(ti_new));
1917
1918   pushTreeInfo(&node_parent->node_group, ti_new);
1919 }
1920
1921 /* forward declaration for recursive call by "LoadLevelInfoFromLevelDir()" */
1922 static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
1923
1924 static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
1925                                           TreeInfo *node_parent,
1926                                           char *level_directory,
1927                                           char *directory_name)
1928 {
1929   char *directory_path = getPath2(level_directory, directory_name);
1930   char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
1931   SetupFileHash *setup_file_hash;
1932   LevelDirTree *leveldir_new = NULL;
1933   int i;
1934
1935   /* unless debugging, silently ignore directories without "levelinfo.conf" */
1936   if (!options.debug && !fileExists(filename))
1937   {
1938     free(directory_path);
1939     free(filename);
1940
1941     return FALSE;
1942   }
1943
1944   setup_file_hash = loadSetupFileHash(filename);
1945
1946   if (setup_file_hash == NULL)
1947   {
1948     Error(ERR_WARN, "ignoring level directory '%s'", directory_path);
1949
1950     free(directory_path);
1951     free(filename);
1952
1953     return FALSE;
1954   }
1955
1956   leveldir_new = newTreeInfo();
1957
1958   if (node_parent)
1959     setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
1960   else
1961     setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
1962
1963   leveldir_new->subdir = getStringCopy(directory_name);
1964
1965   checkSetupFileHashIdentifier(setup_file_hash, getCookie("LEVELINFO"));
1966
1967   /* set all structure fields according to the token/value pairs */
1968   ldi = *leveldir_new;
1969   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
1970     setSetupInfo(levelinfo_tokens, i,
1971                  getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
1972   *leveldir_new = ldi;
1973
1974   if (strcmp(leveldir_new->name, ANONYMOUS_NAME) == 0)
1975     setString(&leveldir_new->name, leveldir_new->subdir);
1976
1977   DrawInitText(leveldir_new->name, 150, FC_YELLOW);
1978
1979   if (leveldir_new->identifier == NULL)
1980     leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
1981
1982   if (leveldir_new->name_sorting == NULL)
1983     leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
1984
1985   if (node_parent == NULL)              /* top level group */
1986   {
1987     leveldir_new->basepath = getStringCopy(level_directory);
1988     leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
1989   }
1990   else                                  /* sub level group */
1991   {
1992     leveldir_new->basepath = getStringCopy(node_parent->basepath);
1993     leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
1994   }
1995
1996 #if 0
1997   if (leveldir_new->levels < 1)
1998     leveldir_new->levels = 1;
1999 #endif
2000
2001   leveldir_new->last_level =
2002     leveldir_new->first_level + leveldir_new->levels - 1;
2003
2004   leveldir_new->in_user_dir =
2005     (strcmp(leveldir_new->basepath, options.level_directory) != 0);
2006
2007   /* adjust some settings if user's private level directory was detected */
2008   if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
2009       leveldir_new->in_user_dir &&
2010       (strcmp(leveldir_new->subdir, getLoginName()) == 0 ||
2011        strcmp(leveldir_new->name,   getLoginName()) == 0 ||
2012        strcmp(leveldir_new->author, getRealName())  == 0))
2013   {
2014     leveldir_new->sort_priority = LEVELCLASS_PRIVATE_START;
2015     leveldir_new->readonly = FALSE;
2016   }
2017
2018   leveldir_new->user_defined =
2019     (leveldir_new->in_user_dir && IS_LEVELCLASS_PRIVATE(leveldir_new));
2020
2021   leveldir_new->color = LEVELCOLOR(leveldir_new);
2022
2023   setString(&leveldir_new->class_desc, getLevelClassDescription(leveldir_new));
2024
2025   leveldir_new->handicap_level =        /* set handicap to default value */
2026     (leveldir_new->user_defined || !leveldir_new->handicap ?
2027      leveldir_new->last_level : leveldir_new->first_level);
2028
2029 #if 0
2030   /* !!! don't skip sets without levels (else artwork base sets are missing) */
2031 #if 1
2032   if (leveldir_new->levels < 1 && !leveldir_new->level_group)
2033   {
2034     /* skip level sets without levels (which are probably artwork base sets) */
2035
2036     freeSetupFileHash(setup_file_hash);
2037     free(directory_path);
2038     free(filename);
2039
2040     return FALSE;
2041   }
2042 #endif
2043 #endif
2044
2045   pushTreeInfo(node_first, leveldir_new);
2046
2047   freeSetupFileHash(setup_file_hash);
2048
2049   if (leveldir_new->level_group)
2050   {
2051     /* create node to link back to current level directory */
2052     createParentTreeInfoNode(leveldir_new);
2053
2054     /* step into sub-directory and look for more level series */
2055     LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
2056                               leveldir_new, directory_path);
2057   }
2058
2059   free(directory_path);
2060   free(filename);
2061
2062   return TRUE;
2063 }
2064
2065 static void LoadLevelInfoFromLevelDir(TreeInfo **node_first,
2066                                       TreeInfo *node_parent,
2067                                       char *level_directory)
2068 {
2069   DIR *dir;
2070   struct dirent *dir_entry;
2071   boolean valid_entry_found = FALSE;
2072
2073   if ((dir = opendir(level_directory)) == NULL)
2074   {
2075     Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
2076     return;
2077   }
2078
2079   while ((dir_entry = readdir(dir)) != NULL)    /* loop until last dir entry */
2080   {
2081     struct stat file_status;
2082     char *directory_name = dir_entry->d_name;
2083     char *directory_path = getPath2(level_directory, directory_name);
2084
2085     /* skip entries for current and parent directory */
2086     if (strcmp(directory_name, ".")  == 0 ||
2087         strcmp(directory_name, "..") == 0)
2088     {
2089       free(directory_path);
2090       continue;
2091     }
2092
2093     /* find out if directory entry is itself a directory */
2094     if (stat(directory_path, &file_status) != 0 ||      /* cannot stat file */
2095         (file_status.st_mode & S_IFMT) != S_IFDIR)      /* not a directory */
2096     {
2097       free(directory_path);
2098       continue;
2099     }
2100
2101     free(directory_path);
2102
2103     if (strcmp(directory_name, GRAPHICS_DIRECTORY) == 0 ||
2104         strcmp(directory_name, SOUNDS_DIRECTORY) == 0 ||
2105         strcmp(directory_name, MUSIC_DIRECTORY) == 0)
2106       continue;
2107
2108     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
2109                                                     level_directory,
2110                                                     directory_name);
2111   }
2112
2113   closedir(dir);
2114
2115   if (!valid_entry_found)
2116   {
2117     /* check if this directory directly contains a file "levelinfo.conf" */
2118     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
2119                                                     level_directory, ".");
2120   }
2121
2122   if (!valid_entry_found)
2123     Error(ERR_WARN, "cannot find any valid level series in directory '%s'",
2124           level_directory);
2125 }
2126
2127 void LoadLevelInfo()
2128 {
2129   InitUserLevelDirectory(getLoginName());
2130
2131   DrawInitText("Loading level series:", 120, FC_GREEN);
2132
2133   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
2134   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL));
2135
2136 #if 1
2137   /* after loading all level set information, clone the level directory tree
2138      and remove all level sets without levels (these may still contain artwork
2139      to be offered in the setup menu as "custom artwork", and are therefore
2140      checked for existing artwork in the function "LoadLevelArtworkInfo()") */
2141   leveldir_first_all = leveldir_first;
2142   cloneTree(&leveldir_first, leveldir_first_all, TRUE);
2143 #endif
2144
2145   /* before sorting, the first entries will be from the user directory */
2146   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
2147
2148   if (leveldir_first == NULL)
2149     Error(ERR_EXIT, "cannot find any valid level series in any directory");
2150
2151   sortTreeInfo(&leveldir_first, compareTreeInfoEntries);
2152
2153 #if 0
2154   dumpTreeInfo(leveldir_first, 0);
2155 #endif
2156 }
2157
2158 static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first,
2159                                               TreeInfo *node_parent,
2160                                               char *base_directory,
2161                                               char *directory_name, int type)
2162 {
2163   char *directory_path = getPath2(base_directory, directory_name);
2164   char *filename = getPath2(directory_path, ARTWORKINFO_FILENAME(type));
2165   SetupFileHash *setup_file_hash = NULL;
2166   TreeInfo *artwork_new = NULL;
2167   int i;
2168
2169   if (fileExists(filename))
2170     setup_file_hash = loadSetupFileHash(filename);
2171
2172   if (setup_file_hash == NULL)  /* no config file -- look for artwork files */
2173   {
2174     DIR *dir;
2175     struct dirent *dir_entry;
2176     boolean valid_file_found = FALSE;
2177
2178     if ((dir = opendir(directory_path)) != NULL)
2179     {
2180       while ((dir_entry = readdir(dir)) != NULL)
2181       {
2182         char *entry_name = dir_entry->d_name;
2183
2184         if (FileIsArtworkType(entry_name, type))
2185         {
2186           valid_file_found = TRUE;
2187           break;
2188         }
2189       }
2190
2191       closedir(dir);
2192     }
2193
2194     if (!valid_file_found)
2195     {
2196       if (strcmp(directory_name, ".") != 0)
2197         Error(ERR_WARN, "ignoring artwork directory '%s'", directory_path);
2198
2199       free(directory_path);
2200       free(filename);
2201
2202       return FALSE;
2203     }
2204   }
2205
2206   artwork_new = newTreeInfo();
2207
2208   if (node_parent)
2209     setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
2210   else
2211     setTreeInfoToDefaults(artwork_new, type);
2212
2213   artwork_new->subdir = getStringCopy(directory_name);
2214
2215   if (setup_file_hash)  /* (before defining ".color" and ".class_desc") */
2216   {
2217 #if 0
2218     checkSetupFileHashIdentifier(setup_file_hash, getCookie("..."));
2219 #endif
2220
2221     /* set all structure fields according to the token/value pairs */
2222     ldi = *artwork_new;
2223     for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
2224       setSetupInfo(levelinfo_tokens, i,
2225                    getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
2226     *artwork_new = ldi;
2227
2228     if (strcmp(artwork_new->name, ANONYMOUS_NAME) == 0)
2229       setString(&artwork_new->name, artwork_new->subdir);
2230
2231 #if 0
2232     DrawInitText(artwork_new->name, 150, FC_YELLOW);
2233 #endif
2234
2235     if (artwork_new->identifier == NULL)
2236       artwork_new->identifier = getStringCopy(artwork_new->subdir);
2237
2238     if (artwork_new->name_sorting == NULL)
2239       artwork_new->name_sorting = getStringCopy(artwork_new->name);
2240   }
2241
2242   if (node_parent == NULL)              /* top level group */
2243   {
2244     artwork_new->basepath = getStringCopy(base_directory);
2245     artwork_new->fullpath = getStringCopy(artwork_new->subdir);
2246   }
2247   else                                  /* sub level group */
2248   {
2249     artwork_new->basepath = getStringCopy(node_parent->basepath);
2250     artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name);
2251   }
2252
2253   artwork_new->in_user_dir =
2254     (strcmp(artwork_new->basepath, OPTIONS_ARTWORK_DIRECTORY(type)) != 0);
2255
2256   /* (may use ".sort_priority" from "setup_file_hash" above) */
2257   artwork_new->color = ARTWORKCOLOR(artwork_new);
2258
2259   setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new));
2260
2261   if (setup_file_hash == NULL)  /* (after determining ".user_defined") */
2262   {
2263     if (strcmp(artwork_new->subdir, ".") == 0)
2264     {
2265       if (artwork_new->user_defined)
2266       {
2267         setString(&artwork_new->identifier, "private");
2268         artwork_new->sort_priority = ARTWORKCLASS_PRIVATE;
2269       }
2270       else
2271       {
2272         setString(&artwork_new->identifier, "classic");
2273         artwork_new->sort_priority = ARTWORKCLASS_CLASSICS;
2274       }
2275
2276       /* set to new values after changing ".sort_priority" */
2277       artwork_new->color = ARTWORKCOLOR(artwork_new);
2278
2279       setString(&artwork_new->class_desc,
2280                 getLevelClassDescription(artwork_new));
2281     }
2282     else
2283     {
2284       setString(&artwork_new->identifier, artwork_new->subdir);
2285     }
2286
2287     setString(&artwork_new->name, artwork_new->identifier);
2288     setString(&artwork_new->name_sorting, artwork_new->name);
2289   }
2290
2291   DrawInitText(artwork_new->name, 150, FC_YELLOW);
2292
2293   pushTreeInfo(node_first, artwork_new);
2294
2295   freeSetupFileHash(setup_file_hash);
2296
2297   free(directory_path);
2298   free(filename);
2299
2300   return TRUE;
2301 }
2302
2303 static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first,
2304                                           TreeInfo *node_parent,
2305                                           char *base_directory, int type)
2306 {
2307   DIR *dir;
2308   struct dirent *dir_entry;
2309   boolean valid_entry_found = FALSE;
2310
2311   if ((dir = opendir(base_directory)) == NULL)
2312   {
2313     if (base_directory == OPTIONS_ARTWORK_DIRECTORY(type))
2314       Error(ERR_WARN, "cannot read directory '%s'", base_directory);
2315     return;
2316   }
2317
2318   while ((dir_entry = readdir(dir)) != NULL)    /* loop until last dir entry */
2319   {
2320     struct stat file_status;
2321     char *directory_name = dir_entry->d_name;
2322     char *directory_path = getPath2(base_directory, directory_name);
2323
2324     /* skip entries for current and parent directory */
2325     if (strcmp(directory_name, ".")  == 0 ||
2326         strcmp(directory_name, "..") == 0)
2327     {
2328       free(directory_path);
2329       continue;
2330     }
2331
2332     /* find out if directory entry is itself a directory */
2333     if (stat(directory_path, &file_status) != 0 ||      /* cannot stat file */
2334         (file_status.st_mode & S_IFMT) != S_IFDIR)      /* not a directory */
2335     {
2336       free(directory_path);
2337       continue;
2338     }
2339
2340     free(directory_path);
2341
2342     /* check if this directory contains artwork with or without config file */
2343     valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first,node_parent,
2344                                                         base_directory,
2345                                                         directory_name, type);
2346   }
2347
2348   closedir(dir);
2349
2350   /* check if this directory directly contains artwork itself */
2351   valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first,node_parent,
2352                                                       base_directory, ".",
2353                                                       type);
2354   if (!valid_entry_found)
2355     Error(ERR_WARN, "cannot find any valid artwork in directory '%s'",
2356           base_directory);
2357 }
2358
2359 static TreeInfo *getDummyArtworkInfo(int type)
2360 {
2361   /* this is only needed when there is completely no artwork available */
2362   TreeInfo *artwork_new = newTreeInfo();
2363
2364   setTreeInfoToDefaults(artwork_new, type);
2365
2366   setString(&artwork_new->subdir,   UNDEFINED_FILENAME);
2367   setString(&artwork_new->fullpath, UNDEFINED_FILENAME);
2368   setString(&artwork_new->basepath, UNDEFINED_FILENAME);
2369
2370   setString(&artwork_new->identifier,   UNDEFINED_FILENAME);
2371   setString(&artwork_new->name,         UNDEFINED_FILENAME);
2372   setString(&artwork_new->name_sorting, UNDEFINED_FILENAME);
2373
2374   return artwork_new;
2375 }
2376
2377 void LoadArtworkInfo()
2378 {
2379   DrawInitText("Looking for custom artwork:", 120, FC_GREEN);
2380
2381   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
2382                                 options.graphics_directory,
2383                                 TREE_TYPE_GRAPHICS_DIR);
2384   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
2385                                 getUserGraphicsDir(),
2386                                 TREE_TYPE_GRAPHICS_DIR);
2387
2388   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
2389                                 options.sounds_directory,
2390                                 TREE_TYPE_SOUNDS_DIR);
2391   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
2392                                 getUserSoundsDir(),
2393                                 TREE_TYPE_SOUNDS_DIR);
2394
2395   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
2396                                 options.music_directory,
2397                                 TREE_TYPE_MUSIC_DIR);
2398   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
2399                                 getUserMusicDir(),
2400                                 TREE_TYPE_MUSIC_DIR);
2401
2402   if (artwork.gfx_first == NULL)
2403     artwork.gfx_first = getDummyArtworkInfo(TREE_TYPE_GRAPHICS_DIR);
2404   if (artwork.snd_first == NULL)
2405     artwork.snd_first = getDummyArtworkInfo(TREE_TYPE_SOUNDS_DIR);
2406   if (artwork.mus_first == NULL)
2407     artwork.mus_first = getDummyArtworkInfo(TREE_TYPE_MUSIC_DIR);
2408
2409   /* before sorting, the first entries will be from the user directory */
2410   artwork.gfx_current =
2411     getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set);
2412   if (artwork.gfx_current == NULL)
2413     artwork.gfx_current =
2414       getTreeInfoFromIdentifier(artwork.gfx_first, GFX_CLASSIC_SUBDIR);
2415   if (artwork.gfx_current == NULL)
2416     artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first);
2417
2418   artwork.snd_current =
2419     getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set);
2420   if (artwork.snd_current == NULL)
2421     artwork.snd_current =
2422       getTreeInfoFromIdentifier(artwork.snd_first, SND_CLASSIC_SUBDIR);
2423   if (artwork.snd_current == NULL)
2424     artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first);
2425
2426   artwork.mus_current =
2427     getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set);
2428   if (artwork.mus_current == NULL)
2429     artwork.mus_current =
2430       getTreeInfoFromIdentifier(artwork.mus_first, MUS_CLASSIC_SUBDIR);
2431   if (artwork.mus_current == NULL)
2432     artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first);
2433
2434   artwork.gfx_current_identifier = artwork.gfx_current->identifier;
2435   artwork.snd_current_identifier = artwork.snd_current->identifier;
2436   artwork.mus_current_identifier = artwork.mus_current->identifier;
2437
2438 #if 0
2439   printf("graphics set == %s\n\n", artwork.gfx_current_identifier);
2440   printf("sounds set == %s\n\n", artwork.snd_current_identifier);
2441   printf("music set == %s\n\n", artwork.mus_current_identifier);
2442 #endif
2443
2444   sortTreeInfo(&artwork.gfx_first, compareTreeInfoEntries);
2445   sortTreeInfo(&artwork.snd_first, compareTreeInfoEntries);
2446   sortTreeInfo(&artwork.mus_first, compareTreeInfoEntries);
2447
2448 #if 0
2449   dumpTreeInfo(artwork.gfx_first, 0);
2450   dumpTreeInfo(artwork.snd_first, 0);
2451   dumpTreeInfo(artwork.mus_first, 0);
2452 #endif
2453 }
2454
2455 void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node,
2456                                   LevelDirTree *level_node)
2457 {
2458   /* recursively check all level directories for artwork sub-directories */
2459
2460   while (level_node)
2461   {
2462     char *path = getPath2(getLevelDirFromTreeInfo(level_node),
2463                           ARTWORK_DIRECTORY((*artwork_node)->type));
2464
2465     if (!level_node->parent_link)
2466     {
2467       TreeInfo *topnode_last = *artwork_node;
2468
2469       LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path,
2470                                     (*artwork_node)->type);
2471
2472       if (topnode_last != *artwork_node)
2473       {
2474         free((*artwork_node)->identifier);
2475         free((*artwork_node)->name);
2476         free((*artwork_node)->name_sorting);
2477
2478         (*artwork_node)->identifier   = getStringCopy(level_node->subdir);
2479         (*artwork_node)->name         = getStringCopy(level_node->name);
2480         (*artwork_node)->name_sorting = getStringCopy(level_node->name);
2481
2482         (*artwork_node)->sort_priority = level_node->sort_priority;
2483         (*artwork_node)->color = LEVELCOLOR((*artwork_node));
2484       }
2485     }
2486
2487     free(path);
2488
2489     if (level_node->node_group != NULL)
2490       LoadArtworkInfoFromLevelInfo(artwork_node, level_node->node_group);
2491
2492     level_node = level_node->next;
2493   }
2494 }
2495
2496 void LoadLevelArtworkInfo()
2497 {
2498   DrawInitText("Looking for custom level artwork:", 120, FC_GREEN);
2499
2500   LoadArtworkInfoFromLevelInfo(&artwork.gfx_first, leveldir_first_all);
2501   LoadArtworkInfoFromLevelInfo(&artwork.snd_first, leveldir_first_all);
2502   LoadArtworkInfoFromLevelInfo(&artwork.mus_first, leveldir_first_all);
2503
2504   /* needed for reloading level artwork not known at ealier stage */
2505
2506   if (strcmp(artwork.gfx_current_identifier, setup.graphics_set) != 0)
2507   {
2508     artwork.gfx_current =
2509       getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set);
2510     if (artwork.gfx_current == NULL)
2511       artwork.gfx_current =
2512         getTreeInfoFromIdentifier(artwork.gfx_first, GFX_CLASSIC_SUBDIR);
2513     if (artwork.gfx_current == NULL)
2514       artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first);
2515   }
2516
2517   if (strcmp(artwork.snd_current_identifier, setup.sounds_set) != 0)
2518   {
2519     artwork.snd_current =
2520       getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set);
2521     if (artwork.snd_current == NULL)
2522       artwork.snd_current =
2523         getTreeInfoFromIdentifier(artwork.snd_first, SND_CLASSIC_SUBDIR);
2524     if (artwork.snd_current == NULL)
2525       artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first);
2526   }
2527
2528   if (strcmp(artwork.mus_current_identifier, setup.music_set) != 0)
2529   {
2530     artwork.mus_current =
2531       getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set);
2532     if (artwork.mus_current == NULL)
2533       artwork.mus_current =
2534         getTreeInfoFromIdentifier(artwork.mus_first, MUS_CLASSIC_SUBDIR);
2535     if (artwork.mus_current == NULL)
2536       artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first);
2537   }
2538
2539   sortTreeInfo(&artwork.gfx_first, compareTreeInfoEntries);
2540   sortTreeInfo(&artwork.snd_first, compareTreeInfoEntries);
2541   sortTreeInfo(&artwork.mus_first, compareTreeInfoEntries);
2542
2543 #if 0
2544   dumpTreeInfo(artwork.gfx_first, 0);
2545   dumpTreeInfo(artwork.snd_first, 0);
2546   dumpTreeInfo(artwork.mus_first, 0);
2547 #endif
2548 }
2549
2550 static void SaveUserLevelInfo()
2551 {
2552   LevelDirTree *level_info;
2553   char *filename;
2554   FILE *file;
2555   int i;
2556
2557   filename = getPath2(getUserLevelDir(getLoginName()), LEVELINFO_FILENAME);
2558
2559   if (!(file = fopen(filename, MODE_WRITE)))
2560   {
2561     Error(ERR_WARN, "cannot write level info file '%s'", filename);
2562     free(filename);
2563     return;
2564   }
2565
2566   level_info = newTreeInfo();
2567
2568   /* always start with reliable default values */
2569   setTreeInfoToDefaults(level_info, TREE_TYPE_LEVEL_DIR);
2570
2571   setString(&level_info->name, getLoginName());
2572   setString(&level_info->author, getRealName());
2573   level_info->levels = 100;
2574   level_info->first_level = 1;
2575
2576   token_value_position = TOKEN_VALUE_POSITION_SHORT;
2577
2578   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
2579                                                  getCookie("LEVELINFO")));
2580
2581   ldi = *level_info;
2582   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
2583   {
2584     if (i == LEVELINFO_TOKEN_NAME ||
2585         i == LEVELINFO_TOKEN_AUTHOR ||
2586         i == LEVELINFO_TOKEN_LEVELS ||
2587         i == LEVELINFO_TOKEN_FIRST_LEVEL)
2588       fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
2589
2590     /* just to make things nicer :) */
2591     if (i == LEVELINFO_TOKEN_AUTHOR)
2592       fprintf(file, "\n");
2593   }
2594
2595   token_value_position = TOKEN_VALUE_POSITION_DEFAULT;
2596
2597   fclose(file);
2598
2599   SetFilePermissions(filename, PERMS_PRIVATE);
2600
2601   freeTreeInfo(level_info);
2602   free(filename);
2603 }
2604
2605 char *getSetupValue(int type, void *value)
2606 {
2607   static char value_string[MAX_LINE_LEN];
2608
2609   if (value == NULL)
2610     return NULL;
2611
2612   switch (type)
2613   {
2614     case TYPE_BOOLEAN:
2615       strcpy(value_string, (*(boolean *)value ? "true" : "false"));
2616       break;
2617
2618     case TYPE_SWITCH:
2619       strcpy(value_string, (*(boolean *)value ? "on" : "off"));
2620       break;
2621
2622     case TYPE_YES_NO:
2623       strcpy(value_string, (*(boolean *)value ? "yes" : "no"));
2624       break;
2625
2626     case TYPE_KEY:
2627       strcpy(value_string, getKeyNameFromKey(*(Key *)value));
2628       break;
2629
2630     case TYPE_KEY_X11:
2631       strcpy(value_string, getX11KeyNameFromKey(*(Key *)value));
2632       break;
2633
2634     case TYPE_INTEGER:
2635       sprintf(value_string, "%d", *(int *)value);
2636       break;
2637
2638     case TYPE_STRING:
2639       strcpy(value_string, *(char **)value);
2640       break;
2641
2642     default:
2643       value_string[0] = '\0';
2644       break;
2645   }
2646
2647   return value_string;
2648 }
2649
2650 char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
2651 {
2652   int i;
2653   char *line;
2654   static char token_string[MAX_LINE_LEN];
2655   int token_type = token_info[token_nr].type;
2656   void *setup_value = token_info[token_nr].value;
2657   char *token_text = token_info[token_nr].text;
2658   char *value_string = getSetupValue(token_type, setup_value);
2659
2660   /* build complete token string */
2661   sprintf(token_string, "%s%s", prefix, token_text);
2662
2663   /* build setup entry line */
2664   line = getFormattedSetupEntry(token_string, value_string);
2665
2666   if (token_type == TYPE_KEY_X11)
2667   {
2668     Key key = *(Key *)setup_value;
2669     char *keyname = getKeyNameFromKey(key);
2670
2671     /* add comment, if useful */
2672     if (strcmp(keyname, "(undefined)") != 0 &&
2673         strcmp(keyname, "(unknown)") != 0)
2674     {
2675       /* add at least one whitespace */
2676       strcat(line, " ");
2677       for (i = strlen(line); i < token_comment_position; i++)
2678         strcat(line, " ");
2679
2680       strcat(line, "# ");
2681       strcat(line, keyname);
2682     }
2683   }
2684
2685   return line;
2686 }
2687
2688 void LoadLevelSetup_LastSeries()
2689 {
2690   /* ----------------------------------------------------------------------- */
2691   /* ~/.<program>/levelsetup.conf                                            */
2692   /* ----------------------------------------------------------------------- */
2693
2694   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
2695   SetupFileHash *level_setup_hash = NULL;
2696
2697   /* always start with reliable default values */
2698   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
2699
2700   if ((level_setup_hash = loadSetupFileHash(filename)))
2701   {
2702     char *last_level_series =
2703       getHashEntry(level_setup_hash, TOKEN_STR_LAST_LEVEL_SERIES);
2704
2705     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
2706                                                  last_level_series);
2707     if (leveldir_current == NULL)
2708       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
2709
2710     checkSetupFileHashIdentifier(level_setup_hash, getCookie("LEVELSETUP"));
2711
2712     freeSetupFileHash(level_setup_hash);
2713   }
2714   else
2715     Error(ERR_WARN, "using default setup values");
2716
2717   free(filename);
2718 }
2719
2720 void SaveLevelSetup_LastSeries()
2721 {
2722   /* ----------------------------------------------------------------------- */
2723   /* ~/.<program>/levelsetup.conf                                            */
2724   /* ----------------------------------------------------------------------- */
2725
2726   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
2727   char *level_subdir = leveldir_current->subdir;
2728   FILE *file;
2729
2730   InitUserDataDirectory();
2731
2732   if (!(file = fopen(filename, MODE_WRITE)))
2733   {
2734     Error(ERR_WARN, "cannot write setup file '%s'", filename);
2735     free(filename);
2736     return;
2737   }
2738
2739   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
2740                                                  getCookie("LEVELSETUP")));
2741   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES,
2742                                                level_subdir));
2743
2744   fclose(file);
2745
2746   SetFilePermissions(filename, PERMS_PRIVATE);
2747
2748   free(filename);
2749 }
2750
2751 static void checkSeriesInfo()
2752 {
2753   static char *level_directory = NULL;
2754   DIR *dir;
2755   struct dirent *dir_entry;
2756
2757   /* check for more levels besides the 'levels' field of 'levelinfo.conf' */
2758
2759   level_directory = getPath2((leveldir_current->in_user_dir ?
2760                               getUserLevelDir(NULL) :
2761                               options.level_directory),
2762                              leveldir_current->fullpath);
2763
2764   if ((dir = opendir(level_directory)) == NULL)
2765   {
2766     Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
2767     return;
2768   }
2769
2770   while ((dir_entry = readdir(dir)) != NULL)    /* last directory entry */
2771   {
2772     if (strlen(dir_entry->d_name) > 4 &&
2773         dir_entry->d_name[3] == '.' &&
2774         strcmp(&dir_entry->d_name[4], LEVELFILE_EXTENSION) == 0)
2775     {
2776       char levelnum_str[4];
2777       int levelnum_value;
2778
2779       strncpy(levelnum_str, dir_entry->d_name, 3);
2780       levelnum_str[3] = '\0';
2781
2782       levelnum_value = atoi(levelnum_str);
2783
2784 #if 0
2785       if (levelnum_value < leveldir_current->first_level)
2786       {
2787         Error(ERR_WARN, "additional level %d found", levelnum_value);
2788         leveldir_current->first_level = levelnum_value;
2789       }
2790       else if (levelnum_value > leveldir_current->last_level)
2791       {
2792         Error(ERR_WARN, "additional level %d found", levelnum_value);
2793         leveldir_current->last_level = levelnum_value;
2794       }
2795 #endif
2796     }
2797   }
2798
2799   closedir(dir);
2800 }
2801
2802 void LoadLevelSetup_SeriesInfo()
2803 {
2804   char *filename;
2805   SetupFileHash *level_setup_hash = NULL;
2806   char *level_subdir = leveldir_current->subdir;
2807
2808   /* always start with reliable default values */
2809   level_nr = leveldir_current->first_level;
2810
2811   checkSeriesInfo(leveldir_current);
2812
2813   /* ----------------------------------------------------------------------- */
2814   /* ~/.<program>/levelsetup/<level series>/levelsetup.conf                  */
2815   /* ----------------------------------------------------------------------- */
2816
2817   level_subdir = leveldir_current->subdir;
2818
2819   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
2820
2821   if ((level_setup_hash = loadSetupFileHash(filename)))
2822   {
2823     char *token_value;
2824
2825     token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL);
2826
2827     if (token_value)
2828     {
2829       level_nr = atoi(token_value);
2830
2831       if (level_nr < leveldir_current->first_level)
2832         level_nr = leveldir_current->first_level;
2833       if (level_nr > leveldir_current->last_level)
2834         level_nr = leveldir_current->last_level;
2835     }
2836
2837     token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL);
2838
2839     if (token_value)
2840     {
2841       int level_nr = atoi(token_value);
2842
2843       if (level_nr < leveldir_current->first_level)
2844         level_nr = leveldir_current->first_level;
2845       if (level_nr > leveldir_current->last_level + 1)
2846         level_nr = leveldir_current->last_level;
2847
2848       if (leveldir_current->user_defined || !leveldir_current->handicap)
2849         level_nr = leveldir_current->last_level;
2850
2851       leveldir_current->handicap_level = level_nr;
2852     }
2853
2854     checkSetupFileHashIdentifier(level_setup_hash, getCookie("LEVELSETUP"));
2855
2856     freeSetupFileHash(level_setup_hash);
2857   }
2858   else
2859     Error(ERR_WARN, "using default setup values");
2860
2861   free(filename);
2862 }
2863
2864 void SaveLevelSetup_SeriesInfo()
2865 {
2866   char *filename;
2867   char *level_subdir = leveldir_current->subdir;
2868   char *level_nr_str = int2str(level_nr, 0);
2869   char *handicap_level_str = int2str(leveldir_current->handicap_level, 0);
2870   FILE *file;
2871
2872   /* ----------------------------------------------------------------------- */
2873   /* ~/.<program>/levelsetup/<level series>/levelsetup.conf                  */
2874   /* ----------------------------------------------------------------------- */
2875
2876   InitLevelSetupDirectory(level_subdir);
2877
2878   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
2879
2880   if (!(file = fopen(filename, MODE_WRITE)))
2881   {
2882     Error(ERR_WARN, "cannot write setup file '%s'", filename);
2883     free(filename);
2884     return;
2885   }
2886
2887   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
2888                                                  getCookie("LEVELSETUP")));
2889   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_PLAYED_LEVEL,
2890                                                level_nr_str));
2891   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL,
2892                                                handicap_level_str));
2893
2894   fclose(file);
2895
2896   SetFilePermissions(filename, PERMS_PRIVATE);
2897
2898   free(filename);
2899 }