src/libgame/setup.c

   1 // ============================================================================
   2 // Artsoft Retro-Game Library
   3 // ----------------------------------------------------------------------------
   4 // (c) 1995-2014 by Artsoft Entertainment
   5 //                  Holger Schemel
   6 //                  info@artsoft.org
   7 //                  http://www.artsoft.org/
   8 // ----------------------------------------------------------------------------
   9 // setup.c
  10 // ============================================================================
  11
  12 #include <sys/types.h>
  13 #include <sys/stat.h>
  14 #include <dirent.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17 #include <errno.h>
  18
  19 #include "platform.h"
  20
  21 #if !defined(PLATFORM_WIN32)
  22 #include <pwd.h>
  23 #include <sys/param.h>
  24 #endif
  25
  26 #include "setup.h"
  27 #include "joystick.h"
  28 #include "text.h"
  29 #include "misc.h"
  30 #include "hash.h"
  31
  32
  33 #define USE_FILE_IDENTIFIERS    FALSE   /* do not use identifiers anymore */
  34 #define ENABLE_UNUSED_CODE      FALSE   /* for currently unused functions */
  35
  36 #define NUM_LEVELCLASS_DESC     8
  37
  38 static char *levelclass_desc[NUM_LEVELCLASS_DESC] =
  39 {
  40   "Tutorial Levels",
  41   "Classic Originals",
  42   "Contributions",
  43   "Private Levels",
  44   "Boulderdash",
  45   "Emerald Mine",
  46   "Supaplex",
  47   "DX Boulderdash"
  48 };
  49
  50
  51 #define LEVELCOLOR(n)   (IS_LEVELCLASS_TUTORIAL(n) ?            FC_BLUE :    \
  52                          IS_LEVELCLASS_CLASSICS(n) ?            FC_RED :     \
  53                          IS_LEVELCLASS_BD(n) ?                  FC_YELLOW :  \
  54                          IS_LEVELCLASS_EM(n) ?                  FC_YELLOW :  \
  55                          IS_LEVELCLASS_SP(n) ?                  FC_YELLOW :  \
  56                          IS_LEVELCLASS_DX(n) ?                  FC_YELLOW :  \
  57                          IS_LEVELCLASS_SB(n) ?                  FC_YELLOW :  \
  58                          IS_LEVELCLASS_CONTRIB(n) ?             FC_GREEN :   \
  59                          IS_LEVELCLASS_PRIVATE(n) ?             FC_RED :     \
  60                          FC_BLUE)
  61
  62 #define LEVELSORTING(n) (IS_LEVELCLASS_TUTORIAL(n) ?            0 :     \
  63                          IS_LEVELCLASS_CLASSICS(n) ?            1 :     \
  64                          IS_LEVELCLASS_BD(n) ?                  2 :     \
  65                          IS_LEVELCLASS_EM(n) ?                  3 :     \
  66                          IS_LEVELCLASS_SP(n) ?                  4 :     \
  67                          IS_LEVELCLASS_DX(n) ?                  5 :     \
  68                          IS_LEVELCLASS_SB(n) ?                  6 :     \
  69                          IS_LEVELCLASS_CONTRIB(n) ?             7 :     \
  70                          IS_LEVELCLASS_PRIVATE(n) ?             8 :     \
  71                          9)
  72
  73 #define ARTWORKCOLOR(n) (IS_ARTWORKCLASS_CLASSICS(n) ?          FC_RED :     \
  74                          IS_ARTWORKCLASS_CONTRIB(n) ?           FC_GREEN :   \
  75                          IS_ARTWORKCLASS_PRIVATE(n) ?           FC_RED :     \
  76                          IS_ARTWORKCLASS_LEVEL(n) ?             FC_YELLOW :  \
  77                          FC_BLUE)
  78
  79 #define ARTWORKSORTING(n) (IS_ARTWORKCLASS_CLASSICS(n) ?        0 :     \
  80                            IS_ARTWORKCLASS_LEVEL(n) ?           1 :     \
  81                            IS_ARTWORKCLASS_CONTRIB(n) ?         2 :     \
  82                            IS_ARTWORKCLASS_PRIVATE(n) ?         3 :     \
  83                            9)
  84
  85 #define TOKEN_VALUE_POSITION_SHORT              32
  86 #define TOKEN_VALUE_POSITION_DEFAULT            40
  87 #define TOKEN_COMMENT_POSITION_DEFAULT          60
  88
  89 #define MAX_COOKIE_LEN                          256
  90
  91
  92 static void setTreeInfoToDefaults(TreeInfo *, int);
  93 static TreeInfo *getTreeInfoCopy(TreeInfo *ti);
  94 static int compareTreeInfoEntries(const void *, const void *);
  95
  96 static int token_value_position   = TOKEN_VALUE_POSITION_DEFAULT;
  97 static int token_comment_position = TOKEN_COMMENT_POSITION_DEFAULT;
  98
  99 static SetupFileHash *artworkinfo_cache_old = NULL;
 100 static SetupFileHash *artworkinfo_cache_new = NULL;
 101 static boolean use_artworkinfo_cache = TRUE;
 102
 103
 104 /* ------------------------------------------------------------------------- */
 105 /* file functions                                                            */
 106 /* ------------------------------------------------------------------------- */
 107
 108 static char *getLevelClassDescription(TreeInfo *ti)
 109 {
 110   int position = ti->sort_priority / 100;
 111
 112   if (position >= 0 && position < NUM_LEVELCLASS_DESC)
 113     return levelclass_desc[position];
 114   else
 115     return "Unknown Level Class";
 116 }
 117
 118 static char *getUserLevelDir(char *level_subdir)
 119 {
 120   static char *userlevel_dir = NULL;
 121   char *data_dir = getUserGameDataDir();
 122   char *userlevel_subdir = LEVELS_DIRECTORY;
 123
 124   checked_free(userlevel_dir);
 125
 126   if (level_subdir != NULL)
 127     userlevel_dir = getPath3(data_dir, userlevel_subdir, level_subdir);
 128   else
 129     userlevel_dir = getPath2(data_dir, userlevel_subdir);
 130
 131   return userlevel_dir;
 132 }
 133
 134 static char *getScoreDir(char *level_subdir)
 135 {
 136   static char *score_dir = NULL;
 137   char *data_dir = getCommonDataDir();
 138   char *score_subdir = SCORES_DIRECTORY;
 139
 140   checked_free(score_dir);
 141
 142   if (level_subdir != NULL)
 143     score_dir = getPath3(data_dir, score_subdir, level_subdir);
 144   else
 145     score_dir = getPath2(data_dir, score_subdir);
 146
 147   return score_dir;
 148 }
 149
 150 static char *getLevelSetupDir(char *level_subdir)
 151 {
 152   static char *levelsetup_dir = NULL;
 153   char *data_dir = getUserGameDataDir();
 154   char *levelsetup_subdir = LEVELSETUP_DIRECTORY;
 155
 156   checked_free(levelsetup_dir);
 157
 158   if (level_subdir != NULL)
 159     levelsetup_dir = getPath3(data_dir, levelsetup_subdir, level_subdir);
 160   else
 161     levelsetup_dir = getPath2(data_dir, levelsetup_subdir);
 162
 163   return levelsetup_dir;
 164 }
 165
 166 static char *getCacheDir()
 167 {
 168   static char *cache_dir = NULL;
 169
 170   if (cache_dir == NULL)
 171     cache_dir = getPath2(getUserGameDataDir(), CACHE_DIRECTORY);
 172
 173   return cache_dir;
 174 }
 175
 176 static char *getLevelDirFromTreeInfo(TreeInfo *node)
 177 {
 178   static char *level_dir = NULL;
 179
 180   if (node == NULL)
 181     return options.level_directory;
 182
 183   checked_free(level_dir);
 184
 185   level_dir = getPath2((node->in_user_dir ? getUserLevelDir(NULL) :
 186                         options.level_directory), node->fullpath);
 187
 188   return level_dir;
 189 }
 190
 191 char *getCurrentLevelDir()
 192 {
 193   return getLevelDirFromTreeInfo(leveldir_current);
 194 }
 195
 196 static char *getTapeDir(char *level_subdir)
 197 {
 198   static char *tape_dir = NULL;
 199   char *data_dir = getUserGameDataDir();
 200   char *tape_subdir = TAPES_DIRECTORY;
 201
 202   checked_free(tape_dir);
 203
 204   if (level_subdir != NULL)
 205     tape_dir = getPath3(data_dir, tape_subdir, level_subdir);
 206   else
 207     tape_dir = getPath2(data_dir, tape_subdir);
 208
 209   return tape_dir;
 210 }
 211
 212 static char *getSolutionTapeDir()
 213 {
 214   static char *tape_dir = NULL;
 215   char *data_dir = getCurrentLevelDir();
 216   char *tape_subdir = TAPES_DIRECTORY;
 217
 218   checked_free(tape_dir);
 219
 220   tape_dir = getPath2(data_dir, tape_subdir);
 221
 222   return tape_dir;
 223 }
 224
 225 static char *getDefaultGraphicsDir(char *graphics_subdir)
 226 {
 227   static char *graphics_dir = NULL;
 228
 229   if (graphics_subdir == NULL)
 230     return options.graphics_directory;
 231
 232   checked_free(graphics_dir);
 233
 234   graphics_dir = getPath2(options.graphics_directory, graphics_subdir);
 235
 236   return graphics_dir;
 237 }
 238
 239 static char *getDefaultSoundsDir(char *sounds_subdir)
 240 {
 241   static char *sounds_dir = NULL;
 242
 243   if (sounds_subdir == NULL)
 244     return options.sounds_directory;
 245
 246   checked_free(sounds_dir);
 247
 248   sounds_dir = getPath2(options.sounds_directory, sounds_subdir);
 249
 250   return sounds_dir;
 251 }
 252
 253 static char *getDefaultMusicDir(char *music_subdir)
 254 {
 255   static char *music_dir = NULL;
 256
 257   if (music_subdir == NULL)
 258     return options.music_directory;
 259
 260   checked_free(music_dir);
 261
 262   music_dir = getPath2(options.music_directory, music_subdir);
 263
 264   return music_dir;
 265 }
 266
 267 static char *getClassicArtworkSet(int type)
 268 {
 269   return (type == TREE_TYPE_GRAPHICS_DIR ? GFX_CLASSIC_SUBDIR :
 270           type == TREE_TYPE_SOUNDS_DIR   ? SND_CLASSIC_SUBDIR :
 271           type == TREE_TYPE_MUSIC_DIR    ? MUS_CLASSIC_SUBDIR : "");
 272 }
 273
 274 static char *getClassicArtworkDir(int type)
 275 {
 276   return (type == TREE_TYPE_GRAPHICS_DIR ?
 277           getDefaultGraphicsDir(GFX_CLASSIC_SUBDIR) :
 278           type == TREE_TYPE_SOUNDS_DIR ?
 279           getDefaultSoundsDir(SND_CLASSIC_SUBDIR) :
 280           type == TREE_TYPE_MUSIC_DIR ?
 281           getDefaultMusicDir(MUS_CLASSIC_SUBDIR) : "");
 282 }
 283
 284 static char *getUserGraphicsDir()
 285 {
 286   static char *usergraphics_dir = NULL;
 287
 288   if (usergraphics_dir == NULL)
 289     usergraphics_dir = getPath2(getUserGameDataDir(), GRAPHICS_DIRECTORY);
 290
 291   return usergraphics_dir;
 292 }
 293
 294 static char *getUserSoundsDir()
 295 {
 296   static char *usersounds_dir = NULL;
 297
 298   if (usersounds_dir == NULL)
 299     usersounds_dir = getPath2(getUserGameDataDir(), SOUNDS_DIRECTORY);
 300
 301   return usersounds_dir;
 302 }
 303
 304 static char *getUserMusicDir()
 305 {
 306   static char *usermusic_dir = NULL;
 307
 308   if (usermusic_dir == NULL)
 309     usermusic_dir = getPath2(getUserGameDataDir(), MUSIC_DIRECTORY);
 310
 311   return usermusic_dir;
 312 }
 313
 314 static char *getSetupArtworkDir(TreeInfo *ti)
 315 {
 316   static char *artwork_dir = NULL;
 317
 318   checked_free(artwork_dir);
 319
 320   artwork_dir = getPath2(ti->basepath, ti->fullpath);
 321
 322   return artwork_dir;
 323 }
 324
 325 char *setLevelArtworkDir(TreeInfo *ti)
 326 {
 327   char **artwork_path_ptr, **artwork_set_ptr;
 328   TreeInfo *level_artwork;
 329
 330   if (ti == NULL || leveldir_current == NULL)
 331     return NULL;
 332
 333   artwork_path_ptr = LEVELDIR_ARTWORK_PATH_PTR(leveldir_current, ti->type);
 334   artwork_set_ptr  = LEVELDIR_ARTWORK_SET_PTR( leveldir_current, ti->type);
 335
 336   checked_free(*artwork_path_ptr);
 337
 338   if ((level_artwork = getTreeInfoFromIdentifier(ti, *artwork_set_ptr)))
 339   {
 340     *artwork_path_ptr = getStringCopy(getSetupArtworkDir(level_artwork));
 341   }
 342   else
 343   {
 344     /*
 345       No (or non-existing) artwork configured in "levelinfo.conf". This would
 346       normally result in using the artwork configured in the setup menu. But
 347       if an artwork subdirectory exists (which might contain custom artwork
 348       or an artwork configuration file), this level artwork must be treated
 349       as relative to the default "classic" artwork, not to the artwork that
 350       is currently configured in the setup menu.
 351
 352       Update: For "special" versions of R'n'D (like "R'n'D jue"), do not use
 353       the "default" artwork (which would be "jue0" for "R'n'D jue"), but use
 354       the real "classic" artwork from the original R'n'D (like "gfx_classic").
 355     */
 356
 357     char *dir = getPath2(getCurrentLevelDir(), ARTWORK_DIRECTORY(ti->type));
 358
 359     checked_free(*artwork_set_ptr);
 360
 361     if (directoryExists(dir))
 362     {
 363       *artwork_path_ptr = getStringCopy(getClassicArtworkDir(ti->type));
 364       *artwork_set_ptr = getStringCopy(getClassicArtworkSet(ti->type));
 365     }
 366     else
 367     {
 368       *artwork_path_ptr = getStringCopy(UNDEFINED_FILENAME);
 369       *artwork_set_ptr = NULL;
 370     }
 371
 372     free(dir);
 373   }
 374
 375   return *artwork_set_ptr;
 376 }
 377
 378 inline static char *getLevelArtworkSet(int type)
 379 {
 380   if (leveldir_current == NULL)
 381     return NULL;
 382
 383   return LEVELDIR_ARTWORK_SET(leveldir_current, type);
 384 }
 385
 386 inline static char *getLevelArtworkDir(int type)
 387 {
 388   if (leveldir_current == NULL)
 389     return UNDEFINED_FILENAME;
 390
 391   return LEVELDIR_ARTWORK_PATH(leveldir_current, type);
 392 }
 393
 394 char *getTapeFilename(int nr)
 395 {
 396   static char *filename = NULL;
 397   char basename[MAX_FILENAME_LEN];
 398
 399   checked_free(filename);
 400
 401   sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
 402   filename = getPath2(getTapeDir(leveldir_current->subdir), basename);
 403
 404   return filename;
 405 }
 406
 407 char *getSolutionTapeFilename(int nr)
 408 {
 409   static char *filename = NULL;
 410   char basename[MAX_FILENAME_LEN];
 411
 412   checked_free(filename);
 413
 414   sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
 415   filename = getPath2(getSolutionTapeDir(), basename);
 416
 417   if (!fileExists(filename))
 418   {
 419     static char *filename_sln = NULL;
 420
 421     checked_free(filename_sln);
 422
 423     sprintf(basename, "%03d.sln", nr);
 424     filename_sln = getPath2(getSolutionTapeDir(), basename);
 425
 426     if (fileExists(filename_sln))
 427       return filename_sln;
 428   }
 429
 430   return filename;
 431 }
 432
 433 char *getScoreFilename(int nr)
 434 {
 435   static char *filename = NULL;
 436   char basename[MAX_FILENAME_LEN];
 437
 438   checked_free(filename);
 439
 440   sprintf(basename, "%03d.%s", nr, SCOREFILE_EXTENSION);
 441   filename = getPath2(getScoreDir(leveldir_current->subdir), basename);
 442
 443   return filename;
 444 }
 445
 446 char *getSetupFilename()
 447 {
 448   static char *filename = NULL;
 449
 450   checked_free(filename);
 451
 452   filename = getPath2(getSetupDir(), SETUP_FILENAME);
 453
 454   return filename;
 455 }
 456
 457 char *getEditorSetupFilename()
 458 {
 459   static char *filename = NULL;
 460
 461   checked_free(filename);
 462   filename = getPath2(getCurrentLevelDir(), EDITORSETUP_FILENAME);
 463
 464   if (fileExists(filename))
 465     return filename;
 466
 467   checked_free(filename);
 468   filename = getPath2(getSetupDir(), EDITORSETUP_FILENAME);
 469
 470   return filename;
 471 }
 472
 473 char *getHelpAnimFilename()
 474 {
 475   static char *filename = NULL;
 476
 477   checked_free(filename);
 478
 479   filename = getPath2(getCurrentLevelDir(), HELPANIM_FILENAME);
 480
 481   return filename;
 482 }
 483
 484 char *getHelpTextFilename()
 485 {
 486   static char *filename = NULL;
 487
 488   checked_free(filename);
 489
 490   filename = getPath2(getCurrentLevelDir(), HELPTEXT_FILENAME);
 491
 492   return filename;
 493 }
 494
 495 char *getLevelSetInfoFilename()
 496 {
 497   static char *filename = NULL;
 498   char *basenames[] =
 499   {
 500     "README",
 501     "README.TXT",
 502     "README.txt",
 503     "Readme",
 504     "Readme.txt",
 505     "readme",
 506     "readme.txt",
 507
 508     NULL
 509   };
 510   int i;
 511
 512   for (i = 0; basenames[i] != NULL; i++)
 513   {
 514     checked_free(filename);
 515     filename = getPath2(getCurrentLevelDir(), basenames[i]);
 516
 517     if (fileExists(filename))
 518       return filename;
 519   }
 520
 521   return NULL;
 522 }
 523
 524 char *getLevelSetTitleMessageBasename(int nr, boolean initial)
 525 {
 526   static char basename[32];
 527
 528   sprintf(basename, "%s_%d.txt",
 529           (initial ? "titlemessage_initial" : "titlemessage"), nr + 1);
 530
 531   return basename;
 532 }
 533
 534 char *getLevelSetTitleMessageFilename(int nr, boolean initial)
 535 {
 536   static char *filename = NULL;
 537   char *basename;
 538   boolean skip_setup_artwork = FALSE;
 539
 540   checked_free(filename);
 541
 542   basename = getLevelSetTitleMessageBasename(nr, initial);
 543
 544   if (!gfx.override_level_graphics)
 545   {
 546     /* 1st try: look for special artwork in current level series directory */
 547     filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
 548     if (fileExists(filename))
 549       return filename;
 550
 551     free(filename);
 552
 553     /* 2nd try: look for message file in current level set directory */
 554     filename = getPath2(getCurrentLevelDir(), basename);
 555     if (fileExists(filename))
 556       return filename;
 557
 558     free(filename);
 559
 560     /* check if there is special artwork configured in level series config */
 561     if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL)
 562     {
 563       /* 3rd try: look for special artwork configured in level series config */
 564       filename = getPath2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
 565       if (fileExists(filename))
 566         return filename;
 567
 568       free(filename);
 569
 570       /* take missing artwork configured in level set config from default */
 571       skip_setup_artwork = TRUE;
 572     }
 573   }
 574
 575   if (!skip_setup_artwork)
 576   {
 577     /* 4th try: look for special artwork in configured artwork directory */
 578     filename = getPath2(getSetupArtworkDir(artwork.gfx_current), basename);
 579     if (fileExists(filename))
 580       return filename;
 581
 582     free(filename);
 583   }
 584
 585   /* 5th try: look for default artwork in new default artwork directory */
 586   filename = getPath2(getDefaultGraphicsDir(GFX_DEFAULT_SUBDIR), basename);
 587   if (fileExists(filename))
 588     return filename;
 589
 590   free(filename);
 591
 592   /* 6th try: look for default artwork in old default artwork directory */
 593   filename = getPath2(options.graphics_directory, basename);
 594   if (fileExists(filename))
 595     return filename;
 596
 597   return NULL;          /* cannot find specified artwork file anywhere */
 598 }
 599
 600 static char *getCorrectedArtworkBasename(char *basename)
 601 {
 602   return basename;
 603 }
 604
 605 char *getCustomImageFilename(char *basename)
 606 {
 607   static char *filename = NULL;
 608   boolean skip_setup_artwork = FALSE;
 609
 610   checked_free(filename);
 611
 612   basename = getCorrectedArtworkBasename(basename);
 613
 614   if (!gfx.override_level_graphics)
 615   {
 616     /* 1st try: look for special artwork in current level series directory */
 617     filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
 618     if (fileExists(filename))
 619       return filename;
 620
 621     free(filename);
 622
 623     /* check if there is special artwork configured in level series config */
 624     if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL)
 625     {
 626       /* 2nd try: look for special artwork configured in level series config */
 627       filename = getPath2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
 628       if (fileExists(filename))
 629         return filename;
 630
 631       free(filename);
 632
 633       /* take missing artwork configured in level set config from default */
 634       skip_setup_artwork = TRUE;
 635     }
 636   }
 637
 638   if (!skip_setup_artwork)
 639   {
 640     /* 3rd try: look for special artwork in configured artwork directory */
 641     filename = getPath2(getSetupArtworkDir(artwork.gfx_current), basename);
 642     if (fileExists(filename))
 643       return filename;
 644
 645     free(filename);
 646   }
 647
 648   /* 4th try: look for default artwork in new default artwork directory */
 649   filename = getPath2(getDefaultGraphicsDir(GFX_DEFAULT_SUBDIR), basename);
 650   if (fileExists(filename))
 651     return filename;
 652
 653   free(filename);
 654
 655   /* 5th try: look for default artwork in old default artwork directory */
 656   filename = getPath2(options.graphics_directory, basename);
 657   if (fileExists(filename))
 658     return filename;
 659
 660 #if defined(CREATE_SPECIAL_EDITION)
 661   free(filename);
 662
 663   if (options.debug)
 664     Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)", basename);
 665
 666   /* 6th try: look for fallback artwork in old default artwork directory */
 667   /* (needed to prevent errors when trying to access unused artwork files) */
 668   filename = getPath2(options.graphics_directory, GFX_FALLBACK_FILENAME);
 669   if (fileExists(filename))
 670     return filename;
 671 #endif
 672
 673   return NULL;          /* cannot find specified artwork file anywhere */
 674 }
 675
 676 char *getCustomSoundFilename(char *basename)
 677 {
 678   static char *filename = NULL;
 679   boolean skip_setup_artwork = FALSE;
 680
 681   checked_free(filename);
 682
 683   basename = getCorrectedArtworkBasename(basename);
 684
 685   if (!gfx.override_level_sounds)
 686   {
 687     /* 1st try: look for special artwork in current level series directory */
 688     filename = getPath3(getCurrentLevelDir(), SOUNDS_DIRECTORY, basename);
 689     if (fileExists(filename))
 690       return filename;
 691
 692     free(filename);
 693
 694     /* check if there is special artwork configured in level series config */
 695     if (getLevelArtworkSet(ARTWORK_TYPE_SOUNDS) != NULL)
 696     {
 697       /* 2nd try: look for special artwork configured in level series config */
 698       filename = getPath2(getLevelArtworkDir(TREE_TYPE_SOUNDS_DIR), basename);
 699       if (fileExists(filename))
 700         return filename;
 701
 702       free(filename);
 703
 704       /* take missing artwork configured in level set config from default */
 705       skip_setup_artwork = TRUE;
 706     }
 707   }
 708
 709   if (!skip_setup_artwork)
 710   {
 711     /* 3rd try: look for special artwork in configured artwork directory */
 712     filename = getPath2(getSetupArtworkDir(artwork.snd_current), basename);
 713     if (fileExists(filename))
 714       return filename;
 715
 716     free(filename);
 717   }
 718
 719   /* 4th try: look for default artwork in new default artwork directory */
 720   filename = getPath2(getDefaultSoundsDir(SND_DEFAULT_SUBDIR), basename);
 721   if (fileExists(filename))
 722     return filename;
 723
 724   free(filename);
 725
 726   /* 5th try: look for default artwork in old default artwork directory */
 727   filename = getPath2(options.sounds_directory, basename);
 728   if (fileExists(filename))
 729     return filename;
 730
 731 #if defined(CREATE_SPECIAL_EDITION)
 732   free(filename);
 733
 734   if (options.debug)
 735     Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)", basename);
 736
 737   /* 6th try: look for fallback artwork in old default artwork directory */
 738   /* (needed to prevent errors when trying to access unused artwork files) */
 739   filename = getPath2(options.sounds_directory, SND_FALLBACK_FILENAME);
 740   if (fileExists(filename))
 741     return filename;
 742 #endif
 743
 744   return NULL;          /* cannot find specified artwork file anywhere */
 745 }
 746
 747 char *getCustomMusicFilename(char *basename)
 748 {
 749   static char *filename = NULL;
 750   boolean skip_setup_artwork = FALSE;
 751
 752   checked_free(filename);
 753
 754   basename = getCorrectedArtworkBasename(basename);
 755
 756   if (!gfx.override_level_music)
 757   {
 758     /* 1st try: look for special artwork in current level series directory */
 759     filename = getPath3(getCurrentLevelDir(), MUSIC_DIRECTORY, basename);
 760     if (fileExists(filename))
 761       return filename;
 762
 763     free(filename);
 764
 765     /* check if there is special artwork configured in level series config */
 766     if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
 767     {
 768       /* 2nd try: look for special artwork configured in level series config */
 769       filename = getPath2(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR), basename);
 770       if (fileExists(filename))
 771         return filename;
 772
 773       free(filename);
 774
 775       /* take missing artwork configured in level set config from default */
 776       skip_setup_artwork = TRUE;
 777     }
 778   }
 779
 780   if (!skip_setup_artwork)
 781   {
 782     /* 3rd try: look for special artwork in configured artwork directory */
 783     filename = getPath2(getSetupArtworkDir(artwork.mus_current), basename);
 784     if (fileExists(filename))
 785       return filename;
 786
 787     free(filename);
 788   }
 789
 790   /* 4th try: look for default artwork in new default artwork directory */
 791   filename = getPath2(getDefaultMusicDir(MUS_DEFAULT_SUBDIR), basename);
 792   if (fileExists(filename))
 793     return filename;
 794
 795   free(filename);
 796
 797   /* 5th try: look for default artwork in old default artwork directory */
 798   filename = getPath2(options.music_directory, basename);
 799   if (fileExists(filename))
 800     return filename;
 801
 802 #if defined(CREATE_SPECIAL_EDITION)
 803   free(filename);
 804
 805   if (options.debug)
 806     Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)", basename);
 807
 808   /* 6th try: look for fallback artwork in old default artwork directory */
 809   /* (needed to prevent errors when trying to access unused artwork files) */
 810   filename = getPath2(options.music_directory, MUS_FALLBACK_FILENAME);
 811   if (fileExists(filename))
 812     return filename;
 813 #endif
 814
 815   return NULL;          /* cannot find specified artwork file anywhere */
 816 }
 817
 818 char *getCustomArtworkFilename(char *basename, int type)
 819 {
 820   if (type == ARTWORK_TYPE_GRAPHICS)
 821     return getCustomImageFilename(basename);
 822   else if (type == ARTWORK_TYPE_SOUNDS)
 823     return getCustomSoundFilename(basename);
 824   else if (type == ARTWORK_TYPE_MUSIC)
 825     return getCustomMusicFilename(basename);
 826   else
 827     return UNDEFINED_FILENAME;
 828 }
 829
 830 char *getCustomArtworkConfigFilename(int type)
 831 {
 832   return getCustomArtworkFilename(ARTWORKINFO_FILENAME(type), type);
 833 }
 834
 835 char *getCustomArtworkLevelConfigFilename(int type)
 836 {
 837   static char *filename = NULL;
 838
 839   checked_free(filename);
 840
 841   filename = getPath2(getLevelArtworkDir(type), ARTWORKINFO_FILENAME(type));
 842
 843   return filename;
 844 }
 845
 846 char *getCustomMusicDirectory(void)
 847 {
 848   static char *directory = NULL;
 849   boolean skip_setup_artwork = FALSE;
 850
 851   checked_free(directory);
 852
 853   if (!gfx.override_level_music)
 854   {
 855     /* 1st try: look for special artwork in current level series directory */
 856     directory = getPath2(getCurrentLevelDir(), MUSIC_DIRECTORY);
 857     if (directoryExists(directory))
 858       return directory;
 859
 860     free(directory);
 861
 862     /* check if there is special artwork configured in level series config */
 863     if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
 864     {
 865       /* 2nd try: look for special artwork configured in level series config */
 866       directory = getStringCopy(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR));
 867       if (directoryExists(directory))
 868         return directory;
 869
 870       free(directory);
 871
 872       /* take missing artwork configured in level set config from default */
 873       skip_setup_artwork = TRUE;
 874     }
 875   }
 876
 877   if (!skip_setup_artwork)
 878   {
 879     /* 3rd try: look for special artwork in configured artwork directory */
 880     directory = getStringCopy(getSetupArtworkDir(artwork.mus_current));
 881     if (directoryExists(directory))
 882       return directory;
 883
 884     free(directory);
 885   }
 886
 887   /* 4th try: look for default artwork in new default artwork directory */
 888   directory = getStringCopy(getDefaultMusicDir(MUS_DEFAULT_SUBDIR));
 889   if (directoryExists(directory))
 890     return directory;
 891
 892   free(directory);
 893
 894   /* 5th try: look for default artwork in old default artwork directory */
 895   directory = getStringCopy(options.music_directory);
 896   if (directoryExists(directory))
 897     return directory;
 898
 899   return NULL;          /* cannot find specified artwork file anywhere */
 900 }
 901
 902 void InitTapeDirectory(char *level_subdir)
 903 {
 904   createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
 905   createDirectory(getTapeDir(NULL), "main tape", PERMS_PRIVATE);
 906   createDirectory(getTapeDir(level_subdir), "level tape", PERMS_PRIVATE);
 907 }
 908
 909 void InitScoreDirectory(char *level_subdir)
 910 {
 911   createDirectory(getCommonDataDir(), "common data", PERMS_PUBLIC);
 912   createDirectory(getScoreDir(NULL), "main score", PERMS_PUBLIC);
 913   createDirectory(getScoreDir(level_subdir), "level score", PERMS_PUBLIC);
 914 }
 915
 916 static void SaveUserLevelInfo();
 917
 918 void InitUserLevelDirectory(char *level_subdir)
 919 {
 920   if (!directoryExists(getUserLevelDir(level_subdir)))
 921   {
 922     createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
 923     createDirectory(getUserLevelDir(NULL), "main user level", PERMS_PRIVATE);
 924     createDirectory(getUserLevelDir(level_subdir), "user level", PERMS_PRIVATE);
 925
 926     SaveUserLevelInfo();
 927   }
 928 }
 929
 930 void InitLevelSetupDirectory(char *level_subdir)
 931 {
 932   createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
 933   createDirectory(getLevelSetupDir(NULL), "main level setup", PERMS_PRIVATE);
 934   createDirectory(getLevelSetupDir(level_subdir), "level setup", PERMS_PRIVATE);
 935 }
 936
 937 void InitCacheDirectory()
 938 {
 939   createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
 940   createDirectory(getCacheDir(), "cache data", PERMS_PRIVATE);
 941 }
 942
 943
 944 /* ------------------------------------------------------------------------- */
 945 /* some functions to handle lists of level and artwork directories           */
 946 /* ------------------------------------------------------------------------- */
 947
 948 TreeInfo *newTreeInfo()
 949 {
 950   return checked_calloc(sizeof(TreeInfo));
 951 }
 952
 953 TreeInfo *newTreeInfo_setDefaults(int type)
 954 {
 955   TreeInfo *ti = newTreeInfo();
 956
 957   setTreeInfoToDefaults(ti, type);
 958
 959   return ti;
 960 }
 961
 962 void pushTreeInfo(TreeInfo **node_first, TreeInfo *node_new)
 963 {
 964   node_new->next = *node_first;
 965   *node_first = node_new;
 966 }
 967
 968 int numTreeInfo(TreeInfo *node)
 969 {
 970   int num = 0;
 971
 972   while (node)
 973   {
 974     num++;
 975     node = node->next;
 976   }
 977
 978   return num;
 979 }
 980
 981 boolean validLevelSeries(TreeInfo *node)
 982 {
 983   return (node != NULL && !node->node_group && !node->parent_link);
 984 }
 985
 986 TreeInfo *getFirstValidTreeInfoEntry(TreeInfo *node)
 987 {
 988   if (node == NULL)
 989     return NULL;
 990
 991   if (node->node_group)         /* enter level group (step down into tree) */
 992     return getFirstValidTreeInfoEntry(node->node_group);
 993   else if (node->parent_link)   /* skip start entry of level group */
 994   {
 995     if (node->next)             /* get first real level series entry */
 996       return getFirstValidTreeInfoEntry(node->next);
 997     else                        /* leave empty level group and go on */
 998       return getFirstValidTreeInfoEntry(node->node_parent->next);
 999   }
1000   else                          /* this seems to be a regular level series */
1001     return node;
1002 }
1003
1004 TreeInfo *getTreeInfoFirstGroupEntry(TreeInfo *node)
1005 {
1006   if (node == NULL)
1007     return NULL;
1008
1009   if (node->node_parent == NULL)                /* top level group */
1010     return *node->node_top;
1011   else                                          /* sub level group */
1012     return node->node_parent->node_group;
1013 }
1014
1015 int numTreeInfoInGroup(TreeInfo *node)
1016 {
1017   return numTreeInfo(getTreeInfoFirstGroupEntry(node));
1018 }
1019
1020 int posTreeInfo(TreeInfo *node)
1021 {
1022   TreeInfo *node_cmp = getTreeInfoFirstGroupEntry(node);
1023   int pos = 0;
1024
1025   while (node_cmp)
1026   {
1027     if (node_cmp == node)
1028       return pos;
1029
1030     pos++;
1031     node_cmp = node_cmp->next;
1032   }
1033
1034   return 0;
1035 }
1036
1037 TreeInfo *getTreeInfoFromPos(TreeInfo *node, int pos)
1038 {
1039   TreeInfo *node_default = node;
1040   int pos_cmp = 0;
1041
1042   while (node)
1043   {
1044     if (pos_cmp == pos)
1045       return node;
1046
1047     pos_cmp++;
1048     node = node->next;
1049   }
1050
1051   return node_default;
1052 }
1053
1054 TreeInfo *getTreeInfoFromIdentifier(TreeInfo *node, char *identifier)
1055 {
1056   if (identifier == NULL)
1057     return NULL;
1058
1059   while (node)
1060   {
1061     if (node->node_group)
1062     {
1063       TreeInfo *node_group;
1064
1065       node_group = getTreeInfoFromIdentifier(node->node_group, identifier);
1066
1067       if (node_group)
1068         return node_group;
1069     }
1070     else if (!node->parent_link)
1071     {
1072       if (strEqual(identifier, node->identifier))
1073         return node;
1074     }
1075
1076     node = node->next;
1077   }
1078
1079   return NULL;
1080 }
1081
1082 TreeInfo *cloneTreeNode(TreeInfo **node_top, TreeInfo *node_parent,
1083                         TreeInfo *node, boolean skip_sets_without_levels)
1084 {
1085   TreeInfo *node_new;
1086
1087   if (node == NULL)
1088     return NULL;
1089
1090   if (!node->parent_link && !node->level_group &&
1091       skip_sets_without_levels && node->levels == 0)
1092     return cloneTreeNode(node_top, node_parent, node->next,
1093                          skip_sets_without_levels);
1094
1095   node_new = getTreeInfoCopy(node);             /* copy complete node */
1096
1097   node_new->node_top = node_top;                /* correct top node link */
1098   node_new->node_parent = node_parent;          /* correct parent node link */
1099
1100   if (node->level_group)
1101     node_new->node_group = cloneTreeNode(node_top, node_new, node->node_group,
1102                                          skip_sets_without_levels);
1103
1104   node_new->next = cloneTreeNode(node_top, node_parent, node->next,
1105                                  skip_sets_without_levels);
1106
1107   return node_new;
1108 }
1109
1110 void cloneTree(TreeInfo **ti_new, TreeInfo *ti, boolean skip_empty_sets)
1111 {
1112   TreeInfo *ti_cloned = cloneTreeNode(ti_new, NULL, ti, skip_empty_sets);
1113
1114   *ti_new = ti_cloned;
1115 }
1116
1117 static boolean adjustTreeGraphicsForEMC(TreeInfo *node)
1118 {
1119   boolean settings_changed = FALSE;
1120
1121   while (node)
1122   {
1123     if (node->graphics_set_ecs && !setup.prefer_aga_graphics &&
1124         !strEqual(node->graphics_set, node->graphics_set_ecs))
1125     {
1126       setString(&node->graphics_set, node->graphics_set_ecs);
1127       settings_changed = TRUE;
1128     }
1129     else if (node->graphics_set_aga && setup.prefer_aga_graphics &&
1130              !strEqual(node->graphics_set, node->graphics_set_aga))
1131     {
1132       setString(&node->graphics_set, node->graphics_set_aga);
1133       settings_changed = TRUE;
1134     }
1135
1136     if (node->node_group != NULL)
1137       settings_changed |= adjustTreeGraphicsForEMC(node->node_group);
1138
1139     node = node->next;
1140   }
1141
1142   return settings_changed;
1143 }
1144
1145 void dumpTreeInfo(TreeInfo *node, int depth)
1146 {
1147   int i;
1148
1149   printf("Dumping TreeInfo:\n");
1150
1151   while (node)
1152   {
1153     for (i = 0; i < (depth + 1) * 3; i++)
1154       printf(" ");
1155
1156     printf("'%s' / '%s'\n", node->identifier, node->name);
1157
1158     /*
1159     // use for dumping artwork info tree
1160     printf("subdir == '%s' ['%s', '%s'] [%d])\n",
1161            node->subdir, node->fullpath, node->basepath, node->in_user_dir);
1162     */
1163
1164     if (node->node_group != NULL)
1165       dumpTreeInfo(node->node_group, depth + 1);
1166
1167     node = node->next;
1168   }
1169 }
1170
1171 void sortTreeInfoBySortFunction(TreeInfo **node_first,
1172                                 int (*compare_function)(const void *,
1173                                                         const void *))
1174 {
1175   int num_nodes = numTreeInfo(*node_first);
1176   TreeInfo **sort_array;
1177   TreeInfo *node = *node_first;
1178   int i = 0;
1179
1180   if (num_nodes == 0)
1181     return;
1182
1183   /* allocate array for sorting structure pointers */
1184   sort_array = checked_calloc(num_nodes * sizeof(TreeInfo *));
1185
1186   /* writing structure pointers to sorting array */
1187   while (i < num_nodes && node)         /* double boundary check... */
1188   {
1189     sort_array[i] = node;
1190
1191     i++;
1192     node = node->next;
1193   }
1194
1195   /* sorting the structure pointers in the sorting array */
1196   qsort(sort_array, num_nodes, sizeof(TreeInfo *),
1197         compare_function);
1198
1199   /* update the linkage of list elements with the sorted node array */
1200   for (i = 0; i < num_nodes - 1; i++)
1201     sort_array[i]->next = sort_array[i + 1];
1202   sort_array[num_nodes - 1]->next = NULL;
1203
1204   /* update the linkage of the main list anchor pointer */
1205   *node_first = sort_array[0];
1206
1207   free(sort_array);
1208
1209   /* now recursively sort the level group structures */
1210   node = *node_first;
1211   while (node)
1212   {
1213     if (node->node_group != NULL)
1214       sortTreeInfoBySortFunction(&node->node_group, compare_function);
1215
1216     node = node->next;
1217   }
1218 }
1219
1220 void sortTreeInfo(TreeInfo **node_first)
1221 {
1222   sortTreeInfoBySortFunction(node_first, compareTreeInfoEntries);
1223 }
1224
1225
1226 /* ========================================================================= */
1227 /* some stuff from "files.c"                                                 */
1228 /* ========================================================================= */
1229
1230 #if defined(PLATFORM_WIN32)
1231 #ifndef S_IRGRP
1232 #define S_IRGRP S_IRUSR
1233 #endif
1234 #ifndef S_IROTH
1235 #define S_IROTH S_IRUSR
1236 #endif
1237 #ifndef S_IWGRP
1238 #define S_IWGRP S_IWUSR
1239 #endif
1240 #ifndef S_IWOTH
1241 #define S_IWOTH S_IWUSR
1242 #endif
1243 #ifndef S_IXGRP
1244 #define S_IXGRP S_IXUSR
1245 #endif
1246 #ifndef S_IXOTH
1247 #define S_IXOTH S_IXUSR
1248 #endif
1249 #ifndef S_IRWXG
1250 #define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
1251 #endif
1252 #ifndef S_ISGID
1253 #define S_ISGID 0
1254 #endif
1255 #endif  /* PLATFORM_WIN32 */
1256
1257 /* file permissions for newly written files */
1258 #define MODE_R_ALL              (S_IRUSR | S_IRGRP | S_IROTH)
1259 #define MODE_W_ALL              (S_IWUSR | S_IWGRP | S_IWOTH)
1260 #define MODE_X_ALL              (S_IXUSR | S_IXGRP | S_IXOTH)
1261
1262 #define MODE_W_PRIVATE          (S_IWUSR)
1263 #define MODE_W_PUBLIC           (S_IWUSR | S_IWGRP)
1264 #define MODE_W_PUBLIC_DIR       (S_IWUSR | S_IWGRP | S_ISGID)
1265
1266 #define DIR_PERMS_PRIVATE       (MODE_R_ALL | MODE_X_ALL | MODE_W_PRIVATE)
1267 #define DIR_PERMS_PUBLIC        (MODE_R_ALL | MODE_X_ALL | MODE_W_PUBLIC_DIR)
1268
1269 #define FILE_PERMS_PRIVATE      (MODE_R_ALL | MODE_W_PRIVATE)
1270 #define FILE_PERMS_PUBLIC       (MODE_R_ALL | MODE_W_PUBLIC)
1271
1272 char *getHomeDir()
1273 {
1274   static char *dir = NULL;
1275
1276 #if defined(PLATFORM_WIN32)
1277   if (dir == NULL)
1278   {
1279     dir = checked_malloc(MAX_PATH + 1);
1280
1281     if (!SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, dir)))
1282       strcpy(dir, ".");
1283   }
1284 #elif defined(PLATFORM_UNIX)
1285   if (dir == NULL)
1286   {
1287     if ((dir = getenv("HOME")) == NULL)
1288     {
1289       struct passwd *pwd;
1290
1291       if ((pwd = getpwuid(getuid())) != NULL)
1292         dir = getStringCopy(pwd->pw_dir);
1293       else
1294         dir = ".";
1295     }
1296   }
1297 #else
1298   dir = ".";
1299 #endif
1300
1301   return dir;
1302 }
1303
1304 char *getCommonDataDir(void)
1305 {
1306   static char *common_data_dir = NULL;
1307
1308 #if defined(PLATFORM_WIN32)
1309   if (common_data_dir == NULL)
1310   {
1311     char *dir = checked_malloc(MAX_PATH + 1);
1312
1313     if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, dir))
1314         && !strEqual(dir, ""))          /* empty for Windows 95/98 */
1315       common_data_dir = getPath2(dir, program.userdata_subdir);
1316     else
1317       common_data_dir = options.rw_base_directory;
1318   }
1319 #else
1320   if (common_data_dir == NULL)
1321     common_data_dir = options.rw_base_directory;
1322 #endif
1323
1324   return common_data_dir;
1325 }
1326
1327 char *getPersonalDataDir(void)
1328 {
1329   static char *personal_data_dir = NULL;
1330
1331 #if defined(PLATFORM_MACOSX)
1332   if (personal_data_dir == NULL)
1333     personal_data_dir = getPath2(getHomeDir(), "Documents");
1334 #else
1335   if (personal_data_dir == NULL)
1336     personal_data_dir = getHomeDir();
1337 #endif
1338
1339   return personal_data_dir;
1340 }
1341
1342 char *getUserGameDataDir(void)
1343 {
1344   static char *user_game_data_dir = NULL;
1345
1346 #if defined(PLATFORM_ANDROID)
1347   if (user_game_data_dir == NULL)
1348     user_game_data_dir = (char *)SDL_AndroidGetInternalStoragePath();
1349 #else
1350   if (user_game_data_dir == NULL)
1351     user_game_data_dir = getPath2(getPersonalDataDir(),
1352                                   program.userdata_subdir);
1353 #endif
1354
1355   return user_game_data_dir;
1356 }
1357
1358 void updateUserGameDataDir()
1359 {
1360 #if defined(PLATFORM_MACOSX)
1361   char *userdata_dir_old = getPath2(getHomeDir(), program.userdata_subdir_unix);
1362   char *userdata_dir_new = getUserGameDataDir();        /* do not free() this */
1363
1364   /* convert old Unix style game data directory to Mac OS X style, if needed */
1365   if (directoryExists(userdata_dir_old) && !directoryExists(userdata_dir_new))
1366   {
1367     if (rename(userdata_dir_old, userdata_dir_new) != 0)
1368     {
1369       Error(ERR_WARN, "cannot move game data directory '%s' to '%s'",
1370             userdata_dir_old, userdata_dir_new);
1371
1372       /* continue using Unix style data directory -- this should not happen */
1373       program.userdata_path = getPath2(getPersonalDataDir(),
1374                                        program.userdata_subdir_unix);
1375     }
1376   }
1377
1378   free(userdata_dir_old);
1379 #endif
1380 }
1381
1382 char *getSetupDir()
1383 {
1384   return getUserGameDataDir();
1385 }
1386
1387 static mode_t posix_umask(mode_t mask)
1388 {
1389 #if defined(PLATFORM_UNIX)
1390   return umask(mask);
1391 #else
1392   return 0;
1393 #endif
1394 }
1395
1396 static int posix_mkdir(const char *pathname, mode_t mode)
1397 {
1398 #if defined(PLATFORM_WIN32)
1399   return mkdir(pathname);
1400 #else
1401   return mkdir(pathname, mode);
1402 #endif
1403 }
1404
1405 static boolean posix_process_running_setgid()
1406 {
1407 #if defined(PLATFORM_UNIX)
1408   return (getgid() != getegid());
1409 #else
1410   return FALSE;
1411 #endif
1412 }
1413
1414 void createDirectory(char *dir, char *text, int permission_class)
1415 {
1416   /* leave "other" permissions in umask untouched, but ensure group parts
1417      of USERDATA_DIR_MODE are not masked */
1418   mode_t dir_mode = (permission_class == PERMS_PRIVATE ?
1419                      DIR_PERMS_PRIVATE : DIR_PERMS_PUBLIC);
1420   mode_t last_umask = posix_umask(0);
1421   mode_t group_umask = ~(dir_mode & S_IRWXG);
1422   int running_setgid = posix_process_running_setgid();
1423
1424   /* if we're setgid, protect files against "other" */
1425   /* else keep umask(0) to make the dir world-writable */
1426
1427   if (running_setgid)
1428     posix_umask(last_umask & group_umask);
1429   else
1430     dir_mode |= MODE_W_ALL;
1431
1432   if (!directoryExists(dir))
1433     if (posix_mkdir(dir, dir_mode) != 0)
1434       Error(ERR_WARN, "cannot create %s directory '%s': %s",
1435             text, dir, strerror(errno));
1436
1437   if (permission_class == PERMS_PUBLIC && !running_setgid)
1438     chmod(dir, dir_mode);
1439
1440   posix_umask(last_umask);              /* restore previous umask */
1441 }
1442
1443 void InitUserDataDirectory()
1444 {
1445   createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
1446 }
1447
1448 void SetFilePermissions(char *filename, int permission_class)
1449 {
1450   int running_setgid = posix_process_running_setgid();
1451   int perms = (permission_class == PERMS_PRIVATE ?
1452                FILE_PERMS_PRIVATE : FILE_PERMS_PUBLIC);
1453
1454   if (permission_class == PERMS_PUBLIC && !running_setgid)
1455     perms |= MODE_W_ALL;
1456
1457   chmod(filename, perms);
1458 }
1459
1460 char *getCookie(char *file_type)
1461 {
1462   static char cookie[MAX_COOKIE_LEN + 1];
1463
1464   if (strlen(program.cookie_prefix) + 1 +
1465       strlen(file_type) + strlen("_FILE_VERSION_x.x") > MAX_COOKIE_LEN)
1466     return "[COOKIE ERROR]";    /* should never happen */
1467
1468   sprintf(cookie, "%s_%s_FILE_VERSION_%d.%d",
1469           program.cookie_prefix, file_type,
1470           program.version_major, program.version_minor);
1471
1472   return cookie;
1473 }
1474
1475 int getFileVersionFromCookieString(const char *cookie)
1476 {
1477   const char *ptr_cookie1, *ptr_cookie2;
1478   const char *pattern1 = "_FILE_VERSION_";
1479   const char *pattern2 = "?.?";
1480   const int len_cookie = strlen(cookie);
1481   const int len_pattern1 = strlen(pattern1);
1482   const int len_pattern2 = strlen(pattern2);
1483   const int len_pattern = len_pattern1 + len_pattern2;
1484   int version_major, version_minor;
1485
1486   if (len_cookie <= len_pattern)
1487     return -1;
1488
1489   ptr_cookie1 = &cookie[len_cookie - len_pattern];
1490   ptr_cookie2 = &cookie[len_cookie - len_pattern2];
1491
1492   if (strncmp(ptr_cookie1, pattern1, len_pattern1) != 0)
1493     return -1;
1494
1495   if (ptr_cookie2[0] < '0' || ptr_cookie2[0] > '9' ||
1496       ptr_cookie2[1] != '.' ||
1497       ptr_cookie2[2] < '0' || ptr_cookie2[2] > '9')
1498     return -1;
1499
1500   version_major = ptr_cookie2[0] - '0';
1501   version_minor = ptr_cookie2[2] - '0';
1502
1503   return VERSION_IDENT(version_major, version_minor, 0, 0);
1504 }
1505
1506 boolean checkCookieString(const char *cookie, const char *template)
1507 {
1508   const char *pattern = "_FILE_VERSION_?.?";
1509   const int len_cookie = strlen(cookie);
1510   const int len_template = strlen(template);
1511   const int len_pattern = strlen(pattern);
1512
1513   if (len_cookie != len_template)
1514     return FALSE;
1515
1516   if (strncmp(cookie, template, len_cookie - len_pattern) != 0)
1517     return FALSE;
1518
1519   return TRUE;
1520 }
1521
1522 /* ------------------------------------------------------------------------- */
1523 /* setup file list and hash handling functions                               */
1524 /* ------------------------------------------------------------------------- */
1525
1526 char *getFormattedSetupEntry(char *token, char *value)
1527 {
1528   int i;
1529   static char entry[MAX_LINE_LEN];
1530
1531   /* if value is an empty string, just return token without value */
1532   if (*value == '\0')
1533     return token;
1534
1535   /* start with the token and some spaces to format output line */
1536   sprintf(entry, "%s:", token);
1537   for (i = strlen(entry); i < token_value_position; i++)
1538     strcat(entry, " ");
1539
1540   /* continue with the token's value */
1541   strcat(entry, value);
1542
1543   return entry;
1544 }
1545
1546 SetupFileList *newSetupFileList(char *token, char *value)
1547 {
1548   SetupFileList *new = checked_malloc(sizeof(SetupFileList));
1549
1550   new->token = getStringCopy(token);
1551   new->value = getStringCopy(value);
1552
1553   new->next = NULL;
1554
1555   return new;
1556 }
1557
1558 void freeSetupFileList(SetupFileList *list)
1559 {
1560   if (list == NULL)
1561     return;
1562
1563   checked_free(list->token);
1564   checked_free(list->value);
1565
1566   if (list->next)
1567     freeSetupFileList(list->next);
1568
1569   free(list);
1570 }
1571
1572 char *getListEntry(SetupFileList *list, char *token)
1573 {
1574   if (list == NULL)
1575     return NULL;
1576
1577   if (strEqual(list->token, token))
1578     return list->value;
1579   else
1580     return getListEntry(list->next, token);
1581 }
1582
1583 SetupFileList *setListEntry(SetupFileList *list, char *token, char *value)
1584 {
1585   if (list == NULL)
1586     return NULL;
1587
1588   if (strEqual(list->token, token))
1589   {
1590     checked_free(list->value);
1591
1592     list->value = getStringCopy(value);
1593
1594     return list;
1595   }
1596   else if (list->next == NULL)
1597     return (list->next = newSetupFileList(token, value));
1598   else
1599     return setListEntry(list->next, token, value);
1600 }
1601
1602 SetupFileList *addListEntry(SetupFileList *list, char *token, char *value)
1603 {
1604   if (list == NULL)
1605     return NULL;
1606
1607   if (list->next == NULL)
1608     return (list->next = newSetupFileList(token, value));
1609   else
1610     return addListEntry(list->next, token, value);
1611 }
1612
1613 #if ENABLE_UNUSED_CODE
1614 #ifdef DEBUG
1615 static void printSetupFileList(SetupFileList *list)
1616 {
1617   if (!list)
1618     return;
1619
1620   printf("token: '%s'\n", list->token);
1621   printf("value: '%s'\n", list->value);
1622
1623   printSetupFileList(list->next);
1624 }
1625 #endif
1626 #endif
1627
1628 #ifdef DEBUG
1629 DEFINE_HASHTABLE_INSERT(insert_hash_entry, char, char);
1630 DEFINE_HASHTABLE_SEARCH(search_hash_entry, char, char);
1631 DEFINE_HASHTABLE_CHANGE(change_hash_entry, char, char);
1632 DEFINE_HASHTABLE_REMOVE(remove_hash_entry, char, char);
1633 #else
1634 #define insert_hash_entry hashtable_insert
1635 #define search_hash_entry hashtable_search
1636 #define change_hash_entry hashtable_change
1637 #define remove_hash_entry hashtable_remove
1638 #endif
1639
1640 unsigned int get_hash_from_key(void *key)
1641 {
1642   /*
1643     djb2
1644
1645     This algorithm (k=33) was first reported by Dan Bernstein many years ago in
1646     'comp.lang.c'. Another version of this algorithm (now favored by Bernstein)
1647     uses XOR: hash(i) = hash(i - 1) * 33 ^ str[i]; the magic of number 33 (why
1648     it works better than many other constants, prime or not) has never been
1649     adequately explained.
1650
1651     If you just want to have a good hash function, and cannot wait, djb2
1652     is one of the best string hash functions i know. It has excellent
1653     distribution and speed on many different sets of keys and table sizes.
1654     You are not likely to do better with one of the "well known" functions
1655     such as PJW, K&R, etc.
1656
1657     Ozan (oz) Yigit [http://www.cs.yorku.ca/~oz/hash.html]
1658   */
1659
1660   char *str = (char *)key;
1661   unsigned int hash = 5381;
1662   int c;
1663
1664   while ((c = *str++))
1665     hash = ((hash << 5) + hash) + c;    /* hash * 33 + c */
1666
1667   return hash;
1668 }
1669
1670 static int keys_are_equal(void *key1, void *key2)
1671 {
1672   return (strEqual((char *)key1, (char *)key2));
1673 }
1674
1675 SetupFileHash *newSetupFileHash()
1676 {
1677   SetupFileHash *new_hash =
1678     create_hashtable(16, 0.75, get_hash_from_key, keys_are_equal);
1679
1680   if (new_hash == NULL)
1681     Error(ERR_EXIT, "create_hashtable() failed -- out of memory");
1682
1683   return new_hash;
1684 }
1685
1686 void freeSetupFileHash(SetupFileHash *hash)
1687 {
1688   if (hash == NULL)
1689     return;
1690
1691   hashtable_destroy(hash, 1);   /* 1 == also free values stored in hash */
1692 }
1693
1694 char *getHashEntry(SetupFileHash *hash, char *token)
1695 {
1696   if (hash == NULL)
1697     return NULL;
1698
1699   return search_hash_entry(hash, token);
1700 }
1701
1702 void setHashEntry(SetupFileHash *hash, char *token, char *value)
1703 {
1704   char *value_copy;
1705
1706   if (hash == NULL)
1707     return;
1708
1709   value_copy = getStringCopy(value);
1710
1711   /* change value; if it does not exist, insert it as new */
1712   if (!change_hash_entry(hash, token, value_copy))
1713     if (!insert_hash_entry(hash, getStringCopy(token), value_copy))
1714       Error(ERR_EXIT, "cannot insert into hash -- aborting");
1715 }
1716
1717 char *removeHashEntry(SetupFileHash *hash, char *token)
1718 {
1719   if (hash == NULL)
1720     return NULL;
1721
1722   return remove_hash_entry(hash, token);
1723 }
1724
1725 #if ENABLE_UNUSED_CODE
1726 #if DEBUG
1727 static void printSetupFileHash(SetupFileHash *hash)
1728 {
1729   BEGIN_HASH_ITERATION(hash, itr)
1730   {
1731     printf("token: '%s'\n", HASH_ITERATION_TOKEN(itr));
1732     printf("value: '%s'\n", HASH_ITERATION_VALUE(itr));
1733   }
1734   END_HASH_ITERATION(hash, itr)
1735 }
1736 #endif
1737 #endif
1738
1739 #define ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE            1
1740 #define CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING            0
1741 #define CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH             0
1742
1743 static boolean token_value_separator_found = FALSE;
1744 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
1745 static boolean token_value_separator_warning = FALSE;
1746 #endif
1747 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
1748 static boolean token_already_exists_warning = FALSE;
1749 #endif
1750
1751 static boolean getTokenValueFromSetupLineExt(char *line,
1752                                              char **token_ptr, char **value_ptr,
1753                                              char *filename, char *line_raw,
1754                                              int line_nr,
1755                                              boolean separator_required)
1756 {
1757   static char line_copy[MAX_LINE_LEN + 1], line_raw_copy[MAX_LINE_LEN + 1];
1758   char *token, *value, *line_ptr;
1759
1760   /* when externally invoked via ReadTokenValueFromLine(), copy line buffers */
1761   if (line_raw == NULL)
1762   {
1763     strncpy(line_copy, line, MAX_LINE_LEN);
1764     line_copy[MAX_LINE_LEN] = '\0';
1765     line = line_copy;
1766
1767     strcpy(line_raw_copy, line_copy);
1768     line_raw = line_raw_copy;
1769   }
1770
1771   /* cut trailing comment from input line */
1772   for (line_ptr = line; *line_ptr; line_ptr++)
1773   {
1774     if (*line_ptr == '#')
1775     {
1776       *line_ptr = '\0';
1777       break;
1778     }
1779   }
1780
1781   /* cut trailing whitespaces from input line */
1782   for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
1783     if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
1784       *line_ptr = '\0';
1785
1786   /* ignore empty lines */
1787   if (*line == '\0')
1788     return FALSE;
1789
1790   /* cut leading whitespaces from token */
1791   for (token = line; *token; token++)
1792     if (*token != ' ' && *token != '\t')
1793       break;
1794
1795   /* start with empty value as reliable default */
1796   value = "";
1797
1798   token_value_separator_found = FALSE;
1799
1800   /* find end of token to determine start of value */
1801   for (line_ptr = token; *line_ptr; line_ptr++)
1802   {
1803     /* first look for an explicit token/value separator, like ':' or '=' */
1804     if (*line_ptr == ':' || *line_ptr == '=')
1805     {
1806       *line_ptr = '\0';                 /* terminate token string */
1807       value = line_ptr + 1;             /* set beginning of value */
1808
1809       token_value_separator_found = TRUE;
1810
1811       break;
1812     }
1813   }
1814
1815 #if ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE
1816   /* fallback: if no token/value separator found, also allow whitespaces */
1817   if (!token_value_separator_found && !separator_required)
1818   {
1819     for (line_ptr = token; *line_ptr; line_ptr++)
1820     {
1821       if (*line_ptr == ' ' || *line_ptr == '\t')
1822       {
1823         *line_ptr = '\0';               /* terminate token string */
1824         value = line_ptr + 1;           /* set beginning of value */
1825
1826         token_value_separator_found = TRUE;
1827
1828         break;
1829       }
1830     }
1831
1832 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
1833     if (token_value_separator_found)
1834     {
1835       if (!token_value_separator_warning)
1836       {
1837         Error(ERR_INFO_LINE, "-");
1838
1839         if (filename != NULL)
1840         {
1841           Error(ERR_WARN, "missing token/value separator(s) in config file:");
1842           Error(ERR_INFO, "- config file: '%s'", filename);
1843         }
1844         else
1845         {
1846           Error(ERR_WARN, "missing token/value separator(s):");
1847         }
1848
1849         token_value_separator_warning = TRUE;
1850       }
1851
1852       if (filename != NULL)
1853         Error(ERR_INFO, "- line %d: '%s'", line_nr, line_raw);
1854       else
1855         Error(ERR_INFO, "- line: '%s'", line_raw);
1856     }
1857 #endif
1858   }
1859 #endif
1860
1861   /* cut trailing whitespaces from token */
1862   for (line_ptr = &token[strlen(token)]; line_ptr >= token; line_ptr--)
1863     if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
1864       *line_ptr = '\0';
1865
1866   /* cut leading whitespaces from value */
1867   for (; *value; value++)
1868     if (*value != ' ' && *value != '\t')
1869       break;
1870
1871   *token_ptr = token;
1872   *value_ptr = value;
1873
1874   return TRUE;
1875 }
1876
1877 boolean getTokenValueFromSetupLine(char *line, char **token, char **value)
1878 {
1879   /* while the internal (old) interface does not require a token/value
1880      separator (for downwards compatibility with existing files which
1881      don't use them), it is mandatory for the external (new) interface */
1882
1883   return getTokenValueFromSetupLineExt(line, token, value, NULL, NULL, 0, TRUE);
1884 }
1885
1886 static boolean loadSetupFileData(void *setup_file_data, char *filename,
1887                                  boolean top_recursion_level, boolean is_hash)
1888 {
1889   static SetupFileHash *include_filename_hash = NULL;
1890   char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
1891   char *token, *value, *line_ptr;
1892   void *insert_ptr = NULL;
1893   boolean read_continued_line = FALSE;
1894   File *file;
1895   int line_nr = 0, token_count = 0, include_count = 0;
1896
1897 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
1898   token_value_separator_warning = FALSE;
1899 #endif
1900
1901 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
1902   token_already_exists_warning = FALSE;
1903 #endif
1904
1905   if (!(file = openFile(filename, MODE_READ)))
1906   {
1907     Error(ERR_WARN, "cannot open configuration file '%s'", filename);
1908
1909     return FALSE;
1910   }
1911
1912   /* use "insert pointer" to store list end for constant insertion complexity */
1913   if (!is_hash)
1914     insert_ptr = setup_file_data;
1915
1916   /* on top invocation, create hash to mark included files (to prevent loops) */
1917   if (top_recursion_level)
1918     include_filename_hash = newSetupFileHash();
1919
1920   /* mark this file as already included (to prevent including it again) */
1921   setHashEntry(include_filename_hash, getBaseNamePtr(filename), "true");
1922
1923   while (!checkEndOfFile(file))
1924   {
1925     /* read next line of input file */
1926     if (!getStringFromFile(file, line, MAX_LINE_LEN))
1927       break;
1928
1929     /* check if line was completely read and is terminated by line break */
1930     if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
1931       line_nr++;
1932
1933     /* cut trailing line break (this can be newline and/or carriage return) */
1934     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
1935       if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
1936         *line_ptr = '\0';
1937
1938     /* copy raw input line for later use (mainly debugging output) */
1939     strcpy(line_raw, line);
1940
1941     if (read_continued_line)
1942     {
1943       /* append new line to existing line, if there is enough space */
1944       if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
1945         strcat(previous_line, line_ptr);
1946
1947       strcpy(line, previous_line);      /* copy storage buffer to line */
1948
1949       read_continued_line = FALSE;
1950     }
1951
1952     /* if the last character is '\', continue at next line */
1953     if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
1954     {
1955       line[strlen(line) - 1] = '\0';    /* cut off trailing backslash */
1956       strcpy(previous_line, line);      /* copy line to storage buffer */
1957
1958       read_continued_line = TRUE;
1959
1960       continue;
1961     }
1962
1963     if (!getTokenValueFromSetupLineExt(line, &token, &value, filename,
1964                                        line_raw, line_nr, FALSE))
1965       continue;
1966
1967     if (*token)
1968     {
1969       if (strEqual(token, "include"))
1970       {
1971         if (getHashEntry(include_filename_hash, value) == NULL)
1972         {
1973           char *basepath = getBasePath(filename);
1974           char *basename = getBaseName(value);
1975           char *filename_include = getPath2(basepath, basename);
1976
1977           loadSetupFileData(setup_file_data, filename_include, FALSE, is_hash);
1978
1979           free(basepath);
1980           free(basename);
1981           free(filename_include);
1982
1983           include_count++;
1984         }
1985         else
1986         {
1987           Error(ERR_WARN, "ignoring already processed file '%s'", value);
1988         }
1989       }
1990       else
1991       {
1992         if (is_hash)
1993         {
1994 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
1995           char *old_value =
1996             getHashEntry((SetupFileHash *)setup_file_data, token);
1997
1998           if (old_value != NULL)
1999           {
2000             if (!token_already_exists_warning)
2001             {
2002               Error(ERR_INFO_LINE, "-");
2003               Error(ERR_WARN, "duplicate token(s) found in config file:");
2004               Error(ERR_INFO, "- config file: '%s'", filename);
2005
2006               token_already_exists_warning = TRUE;
2007             }
2008
2009             Error(ERR_INFO, "- token: '%s' (in line %d)", token, line_nr);
2010             Error(ERR_INFO, "  old value: '%s'", old_value);
2011             Error(ERR_INFO, "  new value: '%s'", value);
2012           }
2013 #endif
2014
2015           setHashEntry((SetupFileHash *)setup_file_data, token, value);
2016         }
2017         else
2018         {
2019           insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value);
2020         }
2021
2022         token_count++;
2023       }
2024     }
2025   }
2026
2027   closeFile(file);
2028
2029 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2030   if (token_value_separator_warning)
2031     Error(ERR_INFO_LINE, "-");
2032 #endif
2033
2034 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2035   if (token_already_exists_warning)
2036     Error(ERR_INFO_LINE, "-");
2037 #endif
2038
2039   if (token_count == 0 && include_count == 0)
2040     Error(ERR_WARN, "configuration file '%s' is empty", filename);
2041
2042   if (top_recursion_level)
2043     freeSetupFileHash(include_filename_hash);
2044
2045   return TRUE;
2046 }
2047
2048 void saveSetupFileHash(SetupFileHash *hash, char *filename)
2049 {
2050   FILE *file;
2051
2052   if (!(file = fopen(filename, MODE_WRITE)))
2053   {
2054     Error(ERR_WARN, "cannot write configuration file '%s'", filename);
2055
2056     return;
2057   }
2058
2059   BEGIN_HASH_ITERATION(hash, itr)
2060   {
2061     fprintf(file, "%s\n", getFormattedSetupEntry(HASH_ITERATION_TOKEN(itr),
2062                                                  HASH_ITERATION_VALUE(itr)));
2063   }
2064   END_HASH_ITERATION(hash, itr)
2065
2066   fclose(file);
2067 }
2068
2069 SetupFileList *loadSetupFileList(char *filename)
2070 {
2071   SetupFileList *setup_file_list = newSetupFileList("", "");
2072   SetupFileList *first_valid_list_entry;
2073
2074   if (!loadSetupFileData(setup_file_list, filename, TRUE, FALSE))
2075   {
2076     freeSetupFileList(setup_file_list);
2077
2078     return NULL;
2079   }
2080
2081   first_valid_list_entry = setup_file_list->next;
2082
2083   /* free empty list header */
2084   setup_file_list->next = NULL;
2085   freeSetupFileList(setup_file_list);
2086
2087   return first_valid_list_entry;
2088 }
2089
2090 SetupFileHash *loadSetupFileHash(char *filename)
2091 {
2092   SetupFileHash *setup_file_hash = newSetupFileHash();
2093
2094   if (!loadSetupFileData(setup_file_hash, filename, TRUE, TRUE))
2095   {
2096     freeSetupFileHash(setup_file_hash);
2097
2098     return NULL;
2099   }
2100
2101   return setup_file_hash;
2102 }
2103
2104 void checkSetupFileHashIdentifier(SetupFileHash *setup_file_hash,
2105                                   char *filename, char *identifier)
2106 {
2107 #if USE_FILE_IDENTIFIERS
2108   char *value = getHashEntry(setup_file_hash, TOKEN_STR_FILE_IDENTIFIER);
2109
2110   if (value == NULL)
2111     Error(ERR_WARN, "config file '%s' has no file identifier", filename);
2112   else if (!checkCookieString(value, identifier))
2113     Error(ERR_WARN, "config file '%s' has wrong file identifier", filename);
2114 #endif
2115 }
2116
2117
2118 /* ========================================================================= */
2119 /* setup file stuff                                                          */
2120 /* ========================================================================= */
2121
2122 #define TOKEN_STR_LAST_LEVEL_SERIES             "last_level_series"
2123 #define TOKEN_STR_LAST_PLAYED_LEVEL             "last_played_level"
2124 #define TOKEN_STR_HANDICAP_LEVEL                "handicap_level"
2125
2126 /* level directory info */
2127 #define LEVELINFO_TOKEN_IDENTIFIER              0
2128 #define LEVELINFO_TOKEN_NAME                    1
2129 #define LEVELINFO_TOKEN_NAME_SORTING            2
2130 #define LEVELINFO_TOKEN_AUTHOR                  3
2131 #define LEVELINFO_TOKEN_YEAR                    4
2132 #define LEVELINFO_TOKEN_IMPORTED_FROM           5
2133 #define LEVELINFO_TOKEN_IMPORTED_BY             6
2134 #define LEVELINFO_TOKEN_TESTED_BY               7
2135 #define LEVELINFO_TOKEN_LEVELS                  8
2136 #define LEVELINFO_TOKEN_FIRST_LEVEL             9
2137 #define LEVELINFO_TOKEN_SORT_PRIORITY           10
2138 #define LEVELINFO_TOKEN_LATEST_ENGINE           11
2139 #define LEVELINFO_TOKEN_LEVEL_GROUP             12
2140 #define LEVELINFO_TOKEN_READONLY                13
2141 #define LEVELINFO_TOKEN_GRAPHICS_SET_ECS        14
2142 #define LEVELINFO_TOKEN_GRAPHICS_SET_AGA        15
2143 #define LEVELINFO_TOKEN_GRAPHICS_SET            16
2144 #define LEVELINFO_TOKEN_SOUNDS_SET              17
2145 #define LEVELINFO_TOKEN_MUSIC_SET               18
2146 #define LEVELINFO_TOKEN_FILENAME                19
2147 #define LEVELINFO_TOKEN_FILETYPE                20
2148 #define LEVELINFO_TOKEN_SPECIAL_FLAGS           21
2149 #define LEVELINFO_TOKEN_HANDICAP                22
2150 #define LEVELINFO_TOKEN_SKIP_LEVELS             23
2151
2152 #define NUM_LEVELINFO_TOKENS                    24
2153
2154 static LevelDirTree ldi;
2155
2156 static struct TokenInfo levelinfo_tokens[] =
2157 {
2158   /* level directory info */
2159   { TYPE_STRING,        &ldi.identifier,        "identifier"            },
2160   { TYPE_STRING,        &ldi.name,              "name"                  },
2161   { TYPE_STRING,        &ldi.name_sorting,      "name_sorting"          },
2162   { TYPE_STRING,        &ldi.author,            "author"                },
2163   { TYPE_STRING,        &ldi.year,              "year"                  },
2164   { TYPE_STRING,        &ldi.imported_from,     "imported_from"         },
2165   { TYPE_STRING,        &ldi.imported_by,       "imported_by"           },
2166   { TYPE_STRING,        &ldi.tested_by,         "tested_by"             },
2167   { TYPE_INTEGER,       &ldi.levels,            "levels"                },
2168   { TYPE_INTEGER,       &ldi.first_level,       "first_level"           },
2169   { TYPE_INTEGER,       &ldi.sort_priority,     "sort_priority"         },
2170   { TYPE_BOOLEAN,       &ldi.latest_engine,     "latest_engine"         },
2171   { TYPE_BOOLEAN,       &ldi.level_group,       "level_group"           },
2172   { TYPE_BOOLEAN,       &ldi.readonly,          "readonly"              },
2173   { TYPE_STRING,        &ldi.graphics_set_ecs,  "graphics_set.ecs"      },
2174   { TYPE_STRING,        &ldi.graphics_set_aga,  "graphics_set.aga"      },
2175   { TYPE_STRING,        &ldi.graphics_set,      "graphics_set"          },
2176   { TYPE_STRING,        &ldi.sounds_set,        "sounds_set"            },
2177   { TYPE_STRING,        &ldi.music_set,         "music_set"             },
2178   { TYPE_STRING,        &ldi.level_filename,    "filename"              },
2179   { TYPE_STRING,        &ldi.level_filetype,    "filetype"              },
2180   { TYPE_STRING,        &ldi.special_flags,     "special_flags"         },
2181   { TYPE_BOOLEAN,       &ldi.handicap,          "handicap"              },
2182   { TYPE_BOOLEAN,       &ldi.skip_levels,       "skip_levels"           }
2183 };
2184
2185 static struct TokenInfo artworkinfo_tokens[] =
2186 {
2187   /* artwork directory info */
2188   { TYPE_STRING,        &ldi.identifier,        "identifier"            },
2189   { TYPE_STRING,        &ldi.subdir,            "subdir"                },
2190   { TYPE_STRING,        &ldi.name,              "name"                  },
2191   { TYPE_STRING,        &ldi.name_sorting,      "name_sorting"          },
2192   { TYPE_STRING,        &ldi.author,            "author"                },
2193   { TYPE_INTEGER,       &ldi.sort_priority,     "sort_priority"         },
2194   { TYPE_STRING,        &ldi.basepath,          "basepath"              },
2195   { TYPE_STRING,        &ldi.fullpath,          "fullpath"              },
2196   { TYPE_BOOLEAN,       &ldi.in_user_dir,       "in_user_dir"           },
2197   { TYPE_INTEGER,       &ldi.color,             "color"                 },
2198   { TYPE_STRING,        &ldi.class_desc,        "class_desc"            },
2199
2200   { -1,                 NULL,                   NULL                    },
2201 };
2202
2203 static void setTreeInfoToDefaults(TreeInfo *ti, int type)
2204 {
2205   ti->type = type;
2206
2207   ti->node_top = (ti->type == TREE_TYPE_LEVEL_DIR    ? &leveldir_first :
2208                   ti->type == TREE_TYPE_GRAPHICS_DIR ? &artwork.gfx_first :
2209                   ti->type == TREE_TYPE_SOUNDS_DIR   ? &artwork.snd_first :
2210                   ti->type == TREE_TYPE_MUSIC_DIR    ? &artwork.mus_first :
2211                   NULL);
2212
2213   ti->node_parent = NULL;
2214   ti->node_group = NULL;
2215   ti->next = NULL;
2216
2217   ti->cl_first = -1;
2218   ti->cl_cursor = -1;
2219
2220   ti->subdir = NULL;
2221   ti->fullpath = NULL;
2222   ti->basepath = NULL;
2223   ti->identifier = NULL;
2224   ti->name = getStringCopy(ANONYMOUS_NAME);
2225   ti->name_sorting = NULL;
2226   ti->author = getStringCopy(ANONYMOUS_NAME);
2227   ti->year = NULL;
2228
2229   ti->sort_priority = LEVELCLASS_UNDEFINED;     /* default: least priority */
2230   ti->latest_engine = FALSE;                    /* default: get from level */
2231   ti->parent_link = FALSE;
2232   ti->in_user_dir = FALSE;
2233   ti->user_defined = FALSE;
2234   ti->color = 0;
2235   ti->class_desc = NULL;
2236
2237   ti->infotext = getStringCopy(TREE_INFOTEXT(ti->type));
2238
2239   if (ti->type == TREE_TYPE_LEVEL_DIR)
2240   {
2241     ti->imported_from = NULL;
2242     ti->imported_by = NULL;
2243     ti->tested_by = NULL;
2244
2245     ti->graphics_set_ecs = NULL;
2246     ti->graphics_set_aga = NULL;
2247     ti->graphics_set = NULL;
2248     ti->sounds_set = NULL;
2249     ti->music_set = NULL;
2250     ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
2251     ti->sounds_path = getStringCopy(UNDEFINED_FILENAME);
2252     ti->music_path = getStringCopy(UNDEFINED_FILENAME);
2253
2254     ti->level_filename = NULL;
2255     ti->level_filetype = NULL;
2256
2257     ti->special_flags = NULL;
2258
2259     ti->levels = 0;
2260     ti->first_level = 0;
2261     ti->last_level = 0;
2262     ti->level_group = FALSE;
2263     ti->handicap_level = 0;
2264     ti->readonly = TRUE;
2265     ti->handicap = TRUE;
2266     ti->skip_levels = FALSE;
2267   }
2268 }
2269
2270 static void setTreeInfoToDefaultsFromParent(TreeInfo *ti, TreeInfo *parent)
2271 {
2272   if (parent == NULL)
2273   {
2274     Error(ERR_WARN, "setTreeInfoToDefaultsFromParent(): parent == NULL");
2275
2276     setTreeInfoToDefaults(ti, TREE_TYPE_UNDEFINED);
2277
2278     return;
2279   }
2280
2281   /* copy all values from the parent structure */
2282
2283   ti->type = parent->type;
2284
2285   ti->node_top = parent->node_top;
2286   ti->node_parent = parent;
2287   ti->node_group = NULL;
2288   ti->next = NULL;
2289
2290   ti->cl_first = -1;
2291   ti->cl_cursor = -1;
2292
2293   ti->subdir = NULL;
2294   ti->fullpath = NULL;
2295   ti->basepath = NULL;
2296   ti->identifier = NULL;
2297   ti->name = getStringCopy(ANONYMOUS_NAME);
2298   ti->name_sorting = NULL;
2299   ti->author = getStringCopy(parent->author);
2300   ti->year = getStringCopy(parent->year);
2301
2302   ti->sort_priority = parent->sort_priority;
2303   ti->latest_engine = parent->latest_engine;
2304   ti->parent_link = FALSE;
2305   ti->in_user_dir = parent->in_user_dir;
2306   ti->user_defined = parent->user_defined;
2307   ti->color = parent->color;
2308   ti->class_desc = getStringCopy(parent->class_desc);
2309
2310   ti->infotext = getStringCopy(parent->infotext);
2311
2312   if (ti->type == TREE_TYPE_LEVEL_DIR)
2313   {
2314     ti->imported_from = getStringCopy(parent->imported_from);
2315     ti->imported_by = getStringCopy(parent->imported_by);
2316     ti->tested_by = getStringCopy(parent->tested_by);
2317
2318     ti->graphics_set_ecs = NULL;
2319     ti->graphics_set_aga = NULL;
2320     ti->graphics_set = NULL;
2321     ti->sounds_set = NULL;
2322     ti->music_set = NULL;
2323     ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
2324     ti->sounds_path = getStringCopy(UNDEFINED_FILENAME);
2325     ti->music_path = getStringCopy(UNDEFINED_FILENAME);
2326
2327     ti->level_filename = NULL;
2328     ti->level_filetype = NULL;
2329
2330     ti->special_flags = getStringCopy(parent->special_flags);
2331
2332     ti->levels = 0;
2333     ti->first_level = 0;
2334     ti->last_level = 0;
2335     ti->level_group = FALSE;
2336     ti->handicap_level = 0;
2337     ti->readonly = parent->readonly;
2338     ti->handicap = TRUE;
2339     ti->skip_levels = FALSE;
2340   }
2341 }
2342
2343 static TreeInfo *getTreeInfoCopy(TreeInfo *ti)
2344 {
2345   TreeInfo *ti_copy = newTreeInfo();
2346
2347   /* copy all values from the original structure */
2348
2349   ti_copy->type                 = ti->type;
2350
2351   ti_copy->node_top             = ti->node_top;
2352   ti_copy->node_parent          = ti->node_parent;
2353   ti_copy->node_group           = ti->node_group;
2354   ti_copy->next                 = ti->next;
2355
2356   ti_copy->cl_first             = ti->cl_first;
2357   ti_copy->cl_cursor            = ti->cl_cursor;
2358
2359   ti_copy->subdir               = getStringCopy(ti->subdir);
2360   ti_copy->fullpath             = getStringCopy(ti->fullpath);
2361   ti_copy->basepath             = getStringCopy(ti->basepath);
2362   ti_copy->identifier           = getStringCopy(ti->identifier);
2363   ti_copy->name                 = getStringCopy(ti->name);
2364   ti_copy->name_sorting         = getStringCopy(ti->name_sorting);
2365   ti_copy->author               = getStringCopy(ti->author);
2366   ti_copy->year                 = getStringCopy(ti->year);
2367   ti_copy->imported_from        = getStringCopy(ti->imported_from);
2368   ti_copy->imported_by          = getStringCopy(ti->imported_by);
2369   ti_copy->tested_by            = getStringCopy(ti->tested_by);
2370
2371   ti_copy->graphics_set_ecs     = getStringCopy(ti->graphics_set_ecs);
2372   ti_copy->graphics_set_aga     = getStringCopy(ti->graphics_set_aga);
2373   ti_copy->graphics_set         = getStringCopy(ti->graphics_set);
2374   ti_copy->sounds_set           = getStringCopy(ti->sounds_set);
2375   ti_copy->music_set            = getStringCopy(ti->music_set);
2376   ti_copy->graphics_path        = getStringCopy(ti->graphics_path);
2377   ti_copy->sounds_path          = getStringCopy(ti->sounds_path);
2378   ti_copy->music_path           = getStringCopy(ti->music_path);
2379
2380   ti_copy->level_filename       = getStringCopy(ti->level_filename);
2381   ti_copy->level_filetype       = getStringCopy(ti->level_filetype);
2382
2383   ti_copy->special_flags        = getStringCopy(ti->special_flags);
2384
2385   ti_copy->levels               = ti->levels;
2386   ti_copy->first_level          = ti->first_level;
2387   ti_copy->last_level           = ti->last_level;
2388   ti_copy->sort_priority        = ti->sort_priority;
2389
2390   ti_copy->latest_engine        = ti->latest_engine;
2391
2392   ti_copy->level_group          = ti->level_group;
2393   ti_copy->parent_link          = ti->parent_link;
2394   ti_copy->in_user_dir          = ti->in_user_dir;
2395   ti_copy->user_defined         = ti->user_defined;
2396   ti_copy->readonly             = ti->readonly;
2397   ti_copy->handicap             = ti->handicap;
2398   ti_copy->skip_levels          = ti->skip_levels;
2399
2400   ti_copy->color                = ti->color;
2401   ti_copy->class_desc           = getStringCopy(ti->class_desc);
2402   ti_copy->handicap_level       = ti->handicap_level;
2403
2404   ti_copy->infotext             = getStringCopy(ti->infotext);
2405
2406   return ti_copy;
2407 }
2408
2409 void freeTreeInfo(TreeInfo *ti)
2410 {
2411   if (ti == NULL)
2412     return;
2413
2414   checked_free(ti->subdir);
2415   checked_free(ti->fullpath);
2416   checked_free(ti->basepath);
2417   checked_free(ti->identifier);
2418
2419   checked_free(ti->name);
2420   checked_free(ti->name_sorting);
2421   checked_free(ti->author);
2422   checked_free(ti->year);
2423
2424   checked_free(ti->class_desc);
2425
2426   checked_free(ti->infotext);
2427
2428   if (ti->type == TREE_TYPE_LEVEL_DIR)
2429   {
2430     checked_free(ti->imported_from);
2431     checked_free(ti->imported_by);
2432     checked_free(ti->tested_by);
2433
2434     checked_free(ti->graphics_set_ecs);
2435     checked_free(ti->graphics_set_aga);
2436     checked_free(ti->graphics_set);
2437     checked_free(ti->sounds_set);
2438     checked_free(ti->music_set);
2439
2440     checked_free(ti->graphics_path);
2441     checked_free(ti->sounds_path);
2442     checked_free(ti->music_path);
2443
2444     checked_free(ti->level_filename);
2445     checked_free(ti->level_filetype);
2446
2447     checked_free(ti->special_flags);
2448   }
2449
2450   // recursively free child node
2451   if (ti->node_group)
2452     freeTreeInfo(ti->node_group);
2453
2454   // recursively free next node
2455   if (ti->next)
2456     freeTreeInfo(ti->next);
2457
2458   checked_free(ti);
2459 }
2460
2461 void setSetupInfo(struct TokenInfo *token_info,
2462                   int token_nr, char *token_value)
2463 {
2464   int token_type = token_info[token_nr].type;
2465   void *setup_value = token_info[token_nr].value;
2466
2467   if (token_value == NULL)
2468     return;
2469
2470   /* set setup field to corresponding token value */
2471   switch (token_type)
2472   {
2473     case TYPE_BOOLEAN:
2474     case TYPE_SWITCH:
2475       *(boolean *)setup_value = get_boolean_from_string(token_value);
2476       break;
2477
2478     case TYPE_SWITCH3:
2479       *(int *)setup_value = get_switch3_from_string(token_value);
2480       break;
2481
2482     case TYPE_KEY:
2483       *(Key *)setup_value = getKeyFromKeyName(token_value);
2484       break;
2485
2486     case TYPE_KEY_X11:
2487       *(Key *)setup_value = getKeyFromX11KeyName(token_value);
2488       break;
2489
2490     case TYPE_INTEGER:
2491       *(int *)setup_value = get_integer_from_string(token_value);
2492       break;
2493
2494     case TYPE_STRING:
2495       checked_free(*(char **)setup_value);
2496       *(char **)setup_value = getStringCopy(token_value);
2497       break;
2498
2499     default:
2500       break;
2501   }
2502 }
2503
2504 static int compareTreeInfoEntries(const void *object1, const void *object2)
2505 {
2506   const TreeInfo *entry1 = *((TreeInfo **)object1);
2507   const TreeInfo *entry2 = *((TreeInfo **)object2);
2508   int class_sorting1 = 0, class_sorting2 = 0;
2509   int compare_result;
2510
2511   if (entry1->type == TREE_TYPE_LEVEL_DIR)
2512   {
2513     class_sorting1 = LEVELSORTING(entry1);
2514     class_sorting2 = LEVELSORTING(entry2);
2515   }
2516   else if (entry1->type == TREE_TYPE_GRAPHICS_DIR ||
2517            entry1->type == TREE_TYPE_SOUNDS_DIR ||
2518            entry1->type == TREE_TYPE_MUSIC_DIR)
2519   {
2520     class_sorting1 = ARTWORKSORTING(entry1);
2521     class_sorting2 = ARTWORKSORTING(entry2);
2522   }
2523
2524   if (entry1->parent_link || entry2->parent_link)
2525     compare_result = (entry1->parent_link ? -1 : +1);
2526   else if (entry1->sort_priority == entry2->sort_priority)
2527   {
2528     char *name1 = getStringToLower(entry1->name_sorting);
2529     char *name2 = getStringToLower(entry2->name_sorting);
2530
2531     compare_result = strcmp(name1, name2);
2532
2533     free(name1);
2534     free(name2);
2535   }
2536   else if (class_sorting1 == class_sorting2)
2537     compare_result = entry1->sort_priority - entry2->sort_priority;
2538   else
2539     compare_result = class_sorting1 - class_sorting2;
2540
2541   return compare_result;
2542 }
2543
2544 static void createParentTreeInfoNode(TreeInfo *node_parent)
2545 {
2546   TreeInfo *ti_new;
2547
2548   if (node_parent == NULL)
2549     return;
2550
2551   ti_new = newTreeInfo();
2552   setTreeInfoToDefaults(ti_new, node_parent->type);
2553
2554   ti_new->node_parent = node_parent;
2555   ti_new->parent_link = TRUE;
2556
2557   setString(&ti_new->identifier, node_parent->identifier);
2558   setString(&ti_new->name, ".. (parent directory)");
2559   setString(&ti_new->name_sorting, ti_new->name);
2560
2561   setString(&ti_new->subdir, "..");
2562   setString(&ti_new->fullpath, node_parent->fullpath);
2563
2564   ti_new->sort_priority = node_parent->sort_priority;
2565   ti_new->latest_engine = node_parent->latest_engine;
2566
2567   setString(&ti_new->class_desc, getLevelClassDescription(ti_new));
2568
2569   pushTreeInfo(&node_parent->node_group, ti_new);
2570 }
2571
2572
2573 /* -------------------------------------------------------------------------- */
2574 /* functions for handling level and custom artwork info cache                 */
2575 /* -------------------------------------------------------------------------- */
2576
2577 static void LoadArtworkInfoCache()
2578 {
2579   InitCacheDirectory();
2580
2581   if (artworkinfo_cache_old == NULL)
2582   {
2583     char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
2584
2585     /* try to load artwork info hash from already existing cache file */
2586     artworkinfo_cache_old = loadSetupFileHash(filename);
2587
2588     /* if no artwork info cache file was found, start with empty hash */
2589     if (artworkinfo_cache_old == NULL)
2590       artworkinfo_cache_old = newSetupFileHash();
2591
2592     free(filename);
2593   }
2594
2595   if (artworkinfo_cache_new == NULL)
2596     artworkinfo_cache_new = newSetupFileHash();
2597 }
2598
2599 static void SaveArtworkInfoCache()
2600 {
2601   char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
2602
2603   InitCacheDirectory();
2604
2605   saveSetupFileHash(artworkinfo_cache_new, filename);
2606
2607   free(filename);
2608 }
2609
2610 static char *getCacheTokenPrefix(char *prefix1, char *prefix2)
2611 {
2612   static char *prefix = NULL;
2613
2614   checked_free(prefix);
2615
2616   prefix = getStringCat2WithSeparator(prefix1, prefix2, ".");
2617
2618   return prefix;
2619 }
2620
2621 /* (identical to above function, but separate string buffer needed -- nasty) */
2622 static char *getCacheToken(char *prefix, char *suffix)
2623 {
2624   static char *token = NULL;
2625
2626   checked_free(token);
2627
2628   token = getStringCat2WithSeparator(prefix, suffix, ".");
2629
2630   return token;
2631 }
2632
2633 static char *getFileTimestampString(char *filename)
2634 {
2635   return getStringCopy(i_to_a(getFileTimestampEpochSeconds(filename)));
2636 }
2637
2638 static boolean modifiedFileTimestamp(char *filename, char *timestamp_string)
2639 {
2640   struct stat file_status;
2641
2642   if (timestamp_string == NULL)
2643     return TRUE;
2644
2645   if (stat(filename, &file_status) != 0)        /* cannot stat file */
2646     return TRUE;
2647
2648   return (file_status.st_mtime != atoi(timestamp_string));
2649 }
2650
2651 static TreeInfo *getArtworkInfoCacheEntry(LevelDirTree *level_node, int type)
2652 {
2653   char *identifier = level_node->subdir;
2654   char *type_string = ARTWORK_DIRECTORY(type);
2655   char *token_prefix = getCacheTokenPrefix(type_string, identifier);
2656   char *token_main = getCacheToken(token_prefix, "CACHED");
2657   char *cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
2658   boolean cached = (cache_entry != NULL && strEqual(cache_entry, "true"));
2659   TreeInfo *artwork_info = NULL;
2660
2661   if (!use_artworkinfo_cache)
2662     return NULL;
2663
2664   if (cached)
2665   {
2666     int i;
2667
2668     artwork_info = newTreeInfo();
2669     setTreeInfoToDefaults(artwork_info, type);
2670
2671     /* set all structure fields according to the token/value pairs */
2672     ldi = *artwork_info;
2673     for (i = 0; artworkinfo_tokens[i].type != -1; i++)
2674     {
2675       char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text);
2676       char *value = getHashEntry(artworkinfo_cache_old, token);
2677
2678       setSetupInfo(artworkinfo_tokens, i, value);
2679
2680       /* check if cache entry for this item is invalid or incomplete */
2681       if (value == NULL)
2682       {
2683         Error(ERR_WARN, "cache entry '%s' invalid", token);
2684
2685         cached = FALSE;
2686       }
2687     }
2688
2689     *artwork_info = ldi;
2690   }
2691
2692   if (cached)
2693   {
2694     char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
2695                                         LEVELINFO_FILENAME);
2696     char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
2697                                           ARTWORKINFO_FILENAME(type));
2698
2699     /* check if corresponding "levelinfo.conf" file has changed */
2700     token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
2701     cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
2702
2703     if (modifiedFileTimestamp(filename_levelinfo, cache_entry))
2704       cached = FALSE;
2705
2706     /* check if corresponding "<artworkinfo>.conf" file has changed */
2707     token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
2708     cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
2709
2710     if (modifiedFileTimestamp(filename_artworkinfo, cache_entry))
2711       cached = FALSE;
2712
2713     checked_free(filename_levelinfo);
2714     checked_free(filename_artworkinfo);
2715   }
2716
2717   if (!cached && artwork_info != NULL)
2718   {
2719     freeTreeInfo(artwork_info);
2720
2721     return NULL;
2722   }
2723
2724   return artwork_info;
2725 }
2726
2727 static void setArtworkInfoCacheEntry(TreeInfo *artwork_info,
2728                                      LevelDirTree *level_node, int type)
2729 {
2730   char *identifier = level_node->subdir;
2731   char *type_string = ARTWORK_DIRECTORY(type);
2732   char *token_prefix = getCacheTokenPrefix(type_string, identifier);
2733   char *token_main = getCacheToken(token_prefix, "CACHED");
2734   boolean set_cache_timestamps = TRUE;
2735   int i;
2736
2737   setHashEntry(artworkinfo_cache_new, token_main, "true");
2738
2739   if (set_cache_timestamps)
2740   {
2741     char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
2742                                         LEVELINFO_FILENAME);
2743     char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
2744                                           ARTWORKINFO_FILENAME(type));
2745     char *timestamp_levelinfo = getFileTimestampString(filename_levelinfo);
2746     char *timestamp_artworkinfo = getFileTimestampString(filename_artworkinfo);
2747
2748     token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
2749     setHashEntry(artworkinfo_cache_new, token_main, timestamp_levelinfo);
2750
2751     token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
2752     setHashEntry(artworkinfo_cache_new, token_main, timestamp_artworkinfo);
2753
2754     checked_free(filename_levelinfo);
2755     checked_free(filename_artworkinfo);
2756     checked_free(timestamp_levelinfo);
2757     checked_free(timestamp_artworkinfo);
2758   }
2759
2760   ldi = *artwork_info;
2761   for (i = 0; artworkinfo_tokens[i].type != -1; i++)
2762   {
2763     char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text);
2764     char *value = getSetupValue(artworkinfo_tokens[i].type,
2765                                 artworkinfo_tokens[i].value);
2766     if (value != NULL)
2767       setHashEntry(artworkinfo_cache_new, token, value);
2768   }
2769 }
2770
2771
2772 /* -------------------------------------------------------------------------- */
2773 /* functions for loading level info and custom artwork info                   */
2774 /* -------------------------------------------------------------------------- */
2775
2776 /* forward declaration for recursive call by "LoadLevelInfoFromLevelDir()" */
2777 static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
2778
2779 static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
2780                                           TreeInfo *node_parent,
2781                                           char *level_directory,
2782                                           char *directory_name)
2783 {
2784   char *directory_path = getPath2(level_directory, directory_name);
2785   char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
2786   SetupFileHash *setup_file_hash;
2787   LevelDirTree *leveldir_new = NULL;
2788   int i;
2789
2790   /* unless debugging, silently ignore directories without "levelinfo.conf" */
2791   if (!options.debug && !fileExists(filename))
2792   {
2793     free(directory_path);
2794     free(filename);
2795
2796     return FALSE;
2797   }
2798
2799   setup_file_hash = loadSetupFileHash(filename);
2800
2801   if (setup_file_hash == NULL)
2802   {
2803     Error(ERR_WARN, "ignoring level directory '%s'", directory_path);
2804
2805     free(directory_path);
2806     free(filename);
2807
2808     return FALSE;
2809   }
2810
2811   leveldir_new = newTreeInfo();
2812
2813   if (node_parent)
2814     setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
2815   else
2816     setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
2817
2818   leveldir_new->subdir = getStringCopy(directory_name);
2819
2820   checkSetupFileHashIdentifier(setup_file_hash, filename,
2821                                getCookie("LEVELINFO"));
2822
2823   /* set all structure fields according to the token/value pairs */
2824   ldi = *leveldir_new;
2825   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
2826     setSetupInfo(levelinfo_tokens, i,
2827                  getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
2828   *leveldir_new = ldi;
2829
2830   if (strEqual(leveldir_new->name, ANONYMOUS_NAME))
2831     setString(&leveldir_new->name, leveldir_new->subdir);
2832
2833   if (leveldir_new->identifier == NULL)
2834     leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
2835
2836   if (leveldir_new->name_sorting == NULL)
2837     leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
2838
2839   if (node_parent == NULL)              /* top level group */
2840   {
2841     leveldir_new->basepath = getStringCopy(level_directory);
2842     leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
2843   }
2844   else                                  /* sub level group */
2845   {
2846     leveldir_new->basepath = getStringCopy(node_parent->basepath);
2847     leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
2848   }
2849
2850   leveldir_new->last_level =
2851     leveldir_new->first_level + leveldir_new->levels - 1;
2852
2853   leveldir_new->in_user_dir =
2854     (!strEqual(leveldir_new->basepath, options.level_directory));
2855
2856   /* adjust some settings if user's private level directory was detected */
2857   if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
2858       leveldir_new->in_user_dir &&
2859       (strEqual(leveldir_new->subdir, getLoginName()) ||
2860        strEqual(leveldir_new->name,   getLoginName()) ||
2861        strEqual(leveldir_new->author, getRealName())))
2862   {
2863     leveldir_new->sort_priority = LEVELCLASS_PRIVATE_START;
2864     leveldir_new->readonly = FALSE;
2865   }
2866
2867   leveldir_new->user_defined =
2868     (leveldir_new->in_user_dir && IS_LEVELCLASS_PRIVATE(leveldir_new));
2869
2870   leveldir_new->color = LEVELCOLOR(leveldir_new);
2871
2872   setString(&leveldir_new->class_desc, getLevelClassDescription(leveldir_new));
2873
2874   leveldir_new->handicap_level =        /* set handicap to default value */
2875     (leveldir_new->user_defined || !leveldir_new->handicap ?
2876      leveldir_new->last_level : leveldir_new->first_level);
2877
2878   DrawInitText(leveldir_new->name, 150, FC_YELLOW);
2879
2880   pushTreeInfo(node_first, leveldir_new);
2881
2882   freeSetupFileHash(setup_file_hash);
2883
2884   if (leveldir_new->level_group)
2885   {
2886     /* create node to link back to current level directory */
2887     createParentTreeInfoNode(leveldir_new);
2888
2889     /* recursively step into sub-directory and look for more level series */
2890     LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
2891                               leveldir_new, directory_path);
2892   }
2893
2894   free(directory_path);
2895   free(filename);
2896
2897   return TRUE;
2898 }
2899
2900 static void LoadLevelInfoFromLevelDir(TreeInfo **node_first,
2901                                       TreeInfo *node_parent,
2902                                       char *level_directory)
2903 {
2904   Directory *dir;
2905   DirectoryEntry *dir_entry;
2906   boolean valid_entry_found = FALSE;
2907
2908   if ((dir = openDirectory(level_directory)) == NULL)
2909   {
2910     Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
2911
2912     return;
2913   }
2914
2915   while ((dir_entry = readDirectory(dir)) != NULL)      /* loop all entries */
2916   {
2917     char *directory_name = dir_entry->basename;
2918     char *directory_path = getPath2(level_directory, directory_name);
2919
2920     /* skip entries for current and parent directory */
2921     if (strEqual(directory_name, ".") ||
2922         strEqual(directory_name, ".."))
2923     {
2924       free(directory_path);
2925
2926       continue;
2927     }
2928
2929     /* find out if directory entry is itself a directory */
2930     if (!dir_entry->is_directory)                       /* not a directory */
2931     {
2932       free(directory_path);
2933
2934       continue;
2935     }
2936
2937     free(directory_path);
2938
2939     if (strEqual(directory_name, GRAPHICS_DIRECTORY) ||
2940         strEqual(directory_name, SOUNDS_DIRECTORY) ||
2941         strEqual(directory_name, MUSIC_DIRECTORY))
2942       continue;
2943
2944     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
2945                                                     level_directory,
2946                                                     directory_name);
2947   }
2948
2949   closeDirectory(dir);
2950
2951   /* special case: top level directory may directly contain "levelinfo.conf" */
2952   if (node_parent == NULL && !valid_entry_found)
2953   {
2954     /* check if this directory directly contains a file "levelinfo.conf" */
2955     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
2956                                                     level_directory, ".");
2957   }
2958
2959   if (!valid_entry_found)
2960     Error(ERR_WARN, "cannot find any valid level series in directory '%s'",
2961           level_directory);
2962 }
2963
2964 boolean AdjustGraphicsForEMC()
2965 {
2966   boolean settings_changed = FALSE;
2967
2968   settings_changed |= adjustTreeGraphicsForEMC(leveldir_first_all);
2969   settings_changed |= adjustTreeGraphicsForEMC(leveldir_first);
2970
2971   return settings_changed;
2972 }
2973
2974 void LoadLevelInfo()
2975 {
2976   InitUserLevelDirectory(getLoginName());
2977
2978   DrawInitText("Loading level series", 120, FC_GREEN);
2979
2980   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
2981   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL));
2982
2983   /* after loading all level set information, clone the level directory tree
2984      and remove all level sets without levels (these may still contain artwork
2985      to be offered in the setup menu as "custom artwork", and are therefore
2986      checked for existing artwork in the function "LoadLevelArtworkInfo()") */
2987   leveldir_first_all = leveldir_first;
2988   cloneTree(&leveldir_first, leveldir_first_all, TRUE);
2989
2990   AdjustGraphicsForEMC();
2991
2992   /* before sorting, the first entries will be from the user directory */
2993   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
2994
2995   if (leveldir_first == NULL)
2996     Error(ERR_EXIT, "cannot find any valid level series in any directory");
2997
2998   sortTreeInfo(&leveldir_first);
2999
3000 #if ENABLE_UNUSED_CODE
3001   dumpTreeInfo(leveldir_first, 0);
3002 #endif
3003 }
3004
3005 static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first,
3006                                               TreeInfo *node_parent,
3007                                               char *base_directory,
3008                                               char *directory_name, int type)
3009 {
3010   char *directory_path = getPath2(base_directory, directory_name);
3011   char *filename = getPath2(directory_path, ARTWORKINFO_FILENAME(type));
3012   SetupFileHash *setup_file_hash = NULL;
3013   TreeInfo *artwork_new = NULL;
3014   int i;
3015
3016   if (fileExists(filename))
3017     setup_file_hash = loadSetupFileHash(filename);
3018
3019   if (setup_file_hash == NULL)  /* no config file -- look for artwork files */
3020   {
3021     Directory *dir;
3022     DirectoryEntry *dir_entry;
3023     boolean valid_file_found = FALSE;
3024
3025     if ((dir = openDirectory(directory_path)) != NULL)
3026     {
3027       while ((dir_entry = readDirectory(dir)) != NULL)
3028       {
3029         char *entry_name = dir_entry->basename;
3030
3031         if (FileIsArtworkType(entry_name, type))
3032         {
3033           valid_file_found = TRUE;
3034
3035           break;
3036         }
3037       }
3038
3039       closeDirectory(dir);
3040     }
3041
3042     if (!valid_file_found)
3043     {
3044       if (!strEqual(directory_name, "."))
3045         Error(ERR_WARN, "ignoring artwork directory '%s'", directory_path);
3046
3047       free(directory_path);
3048       free(filename);
3049
3050       return FALSE;
3051     }
3052   }
3053
3054   artwork_new = newTreeInfo();
3055
3056   if (node_parent)
3057     setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
3058   else
3059     setTreeInfoToDefaults(artwork_new, type);
3060
3061   artwork_new->subdir = getStringCopy(directory_name);
3062
3063   if (setup_file_hash)  /* (before defining ".color" and ".class_desc") */
3064   {
3065     /* set all structure fields according to the token/value pairs */
3066     ldi = *artwork_new;
3067     for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3068       setSetupInfo(levelinfo_tokens, i,
3069                    getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
3070     *artwork_new = ldi;
3071
3072     if (strEqual(artwork_new->name, ANONYMOUS_NAME))
3073       setString(&artwork_new->name, artwork_new->subdir);
3074
3075     if (artwork_new->identifier == NULL)
3076       artwork_new->identifier = getStringCopy(artwork_new->subdir);
3077
3078     if (artwork_new->name_sorting == NULL)
3079       artwork_new->name_sorting = getStringCopy(artwork_new->name);
3080   }
3081
3082   if (node_parent == NULL)              /* top level group */
3083   {
3084     artwork_new->basepath = getStringCopy(base_directory);
3085     artwork_new->fullpath = getStringCopy(artwork_new->subdir);
3086   }
3087   else                                  /* sub level group */
3088   {
3089     artwork_new->basepath = getStringCopy(node_parent->basepath);
3090     artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name);
3091   }
3092
3093   artwork_new->in_user_dir =
3094     (!strEqual(artwork_new->basepath, OPTIONS_ARTWORK_DIRECTORY(type)));
3095
3096   /* (may use ".sort_priority" from "setup_file_hash" above) */
3097   artwork_new->color = ARTWORKCOLOR(artwork_new);
3098
3099   setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new));
3100
3101   if (setup_file_hash == NULL)  /* (after determining ".user_defined") */
3102   {
3103     if (strEqual(artwork_new->subdir, "."))
3104     {
3105       if (artwork_new->user_defined)
3106       {
3107         setString(&artwork_new->identifier, "private");
3108         artwork_new->sort_priority = ARTWORKCLASS_PRIVATE;
3109       }
3110       else
3111       {
3112         setString(&artwork_new->identifier, "classic");
3113         artwork_new->sort_priority = ARTWORKCLASS_CLASSICS;
3114       }
3115
3116       /* set to new values after changing ".sort_priority" */
3117       artwork_new->color = ARTWORKCOLOR(artwork_new);
3118
3119       setString(&artwork_new->class_desc,
3120                 getLevelClassDescription(artwork_new));
3121     }
3122     else
3123     {
3124       setString(&artwork_new->identifier, artwork_new->subdir);
3125     }
3126
3127     setString(&artwork_new->name, artwork_new->identifier);
3128     setString(&artwork_new->name_sorting, artwork_new->name);
3129   }
3130
3131   pushTreeInfo(node_first, artwork_new);
3132
3133   freeSetupFileHash(setup_file_hash);
3134
3135   free(directory_path);
3136   free(filename);
3137
3138   return TRUE;
3139 }
3140
3141 static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first,
3142                                           TreeInfo *node_parent,
3143                                           char *base_directory, int type)
3144 {
3145   Directory *dir;
3146   DirectoryEntry *dir_entry;
3147   boolean valid_entry_found = FALSE;
3148
3149   if ((dir = openDirectory(base_directory)) == NULL)
3150   {
3151     /* display error if directory is main "options.graphics_directory" etc. */
3152     if (base_directory == OPTIONS_ARTWORK_DIRECTORY(type))
3153       Error(ERR_WARN, "cannot read directory '%s'", base_directory);
3154
3155     return;
3156   }
3157
3158   while ((dir_entry = readDirectory(dir)) != NULL)      /* loop all entries */
3159   {
3160     char *directory_name = dir_entry->basename;
3161     char *directory_path = getPath2(base_directory, directory_name);
3162
3163     /* skip directory entries for current and parent directory */
3164     if (strEqual(directory_name, ".") ||
3165         strEqual(directory_name, ".."))
3166     {
3167       free(directory_path);
3168
3169       continue;
3170     }
3171
3172     /* skip directory entries which are not a directory */
3173     if (!dir_entry->is_directory)                       /* not a directory */
3174     {
3175       free(directory_path);
3176
3177       continue;
3178     }
3179
3180     free(directory_path);
3181
3182     /* check if this directory contains artwork with or without config file */
3183     valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
3184                                                         base_directory,
3185                                                         directory_name, type);
3186   }
3187
3188   closeDirectory(dir);
3189
3190   /* check if this directory directly contains artwork itself */
3191   valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
3192                                                       base_directory, ".",
3193                                                       type);
3194   if (!valid_entry_found)
3195     Error(ERR_WARN, "cannot find any valid artwork in directory '%s'",
3196           base_directory);
3197 }
3198
3199 static TreeInfo *getDummyArtworkInfo(int type)
3200 {
3201   /* this is only needed when there is completely no artwork available */
3202   TreeInfo *artwork_new = newTreeInfo();
3203
3204   setTreeInfoToDefaults(artwork_new, type);
3205
3206   setString(&artwork_new->subdir,   UNDEFINED_FILENAME);
3207   setString(&artwork_new->fullpath, UNDEFINED_FILENAME);
3208   setString(&artwork_new->basepath, UNDEFINED_FILENAME);
3209
3210   setString(&artwork_new->identifier,   UNDEFINED_FILENAME);
3211   setString(&artwork_new->name,         UNDEFINED_FILENAME);
3212   setString(&artwork_new->name_sorting, UNDEFINED_FILENAME);
3213
3214   return artwork_new;
3215 }
3216
3217 void LoadArtworkInfo()
3218 {
3219   LoadArtworkInfoCache();
3220
3221   DrawInitText("Looking for custom artwork", 120, FC_GREEN);
3222
3223   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
3224                                 options.graphics_directory,
3225                                 TREE_TYPE_GRAPHICS_DIR);
3226   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
3227                                 getUserGraphicsDir(),
3228                                 TREE_TYPE_GRAPHICS_DIR);
3229
3230   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
3231                                 options.sounds_directory,
3232                                 TREE_TYPE_SOUNDS_DIR);
3233   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
3234                                 getUserSoundsDir(),
3235                                 TREE_TYPE_SOUNDS_DIR);
3236
3237   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
3238                                 options.music_directory,
3239                                 TREE_TYPE_MUSIC_DIR);
3240   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
3241                                 getUserMusicDir(),
3242                                 TREE_TYPE_MUSIC_DIR);
3243
3244   if (artwork.gfx_first == NULL)
3245     artwork.gfx_first = getDummyArtworkInfo(TREE_TYPE_GRAPHICS_DIR);
3246   if (artwork.snd_first == NULL)
3247     artwork.snd_first = getDummyArtworkInfo(TREE_TYPE_SOUNDS_DIR);
3248   if (artwork.mus_first == NULL)
3249     artwork.mus_first = getDummyArtworkInfo(TREE_TYPE_MUSIC_DIR);
3250
3251   /* before sorting, the first entries will be from the user directory */
3252   artwork.gfx_current =
3253     getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set);
3254   if (artwork.gfx_current == NULL)
3255     artwork.gfx_current =
3256       getTreeInfoFromIdentifier(artwork.gfx_first, GFX_DEFAULT_SUBDIR);
3257   if (artwork.gfx_current == NULL)
3258     artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first);
3259
3260   artwork.snd_current =
3261     getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set);
3262   if (artwork.snd_current == NULL)
3263     artwork.snd_current =
3264       getTreeInfoFromIdentifier(artwork.snd_first, SND_DEFAULT_SUBDIR);
3265   if (artwork.snd_current == NULL)
3266     artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first);
3267
3268   artwork.mus_current =
3269     getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set);
3270   if (artwork.mus_current == NULL)
3271     artwork.mus_current =
3272       getTreeInfoFromIdentifier(artwork.mus_first, MUS_DEFAULT_SUBDIR);
3273   if (artwork.mus_current == NULL)
3274     artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first);
3275
3276   artwork.gfx_current_identifier = artwork.gfx_current->identifier;
3277   artwork.snd_current_identifier = artwork.snd_current->identifier;
3278   artwork.mus_current_identifier = artwork.mus_current->identifier;
3279
3280 #if ENABLE_UNUSED_CODE
3281   printf("graphics set == %s\n\n", artwork.gfx_current_identifier);
3282   printf("sounds set == %s\n\n", artwork.snd_current_identifier);
3283   printf("music set == %s\n\n", artwork.mus_current_identifier);
3284 #endif
3285
3286   sortTreeInfo(&artwork.gfx_first);
3287   sortTreeInfo(&artwork.snd_first);
3288   sortTreeInfo(&artwork.mus_first);
3289
3290 #if ENABLE_UNUSED_CODE
3291   dumpTreeInfo(artwork.gfx_first, 0);
3292   dumpTreeInfo(artwork.snd_first, 0);
3293   dumpTreeInfo(artwork.mus_first, 0);
3294 #endif
3295 }
3296
3297 void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node,
3298                                   LevelDirTree *level_node)
3299 {
3300   int type = (*artwork_node)->type;
3301
3302   /* recursively check all level directories for artwork sub-directories */
3303
3304   while (level_node)
3305   {
3306     /* check all tree entries for artwork, but skip parent link entries */
3307     if (!level_node->parent_link)
3308     {
3309       TreeInfo *artwork_new = getArtworkInfoCacheEntry(level_node, type);
3310       boolean cached = (artwork_new != NULL);
3311
3312       if (cached)
3313       {
3314         pushTreeInfo(artwork_node, artwork_new);
3315       }
3316       else
3317       {
3318         TreeInfo *topnode_last = *artwork_node;
3319         char *path = getPath2(getLevelDirFromTreeInfo(level_node),
3320                               ARTWORK_DIRECTORY(type));
3321
3322         LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path, type);
3323
3324         if (topnode_last != *artwork_node)      /* check for newly added node */
3325         {
3326           artwork_new = *artwork_node;
3327
3328           setString(&artwork_new->identifier,   level_node->subdir);
3329           setString(&artwork_new->name,         level_node->name);
3330           setString(&artwork_new->name_sorting, level_node->name_sorting);
3331
3332           artwork_new->sort_priority = level_node->sort_priority;
3333           artwork_new->color = LEVELCOLOR(artwork_new);
3334         }
3335
3336         free(path);
3337       }
3338
3339       /* insert artwork info (from old cache or filesystem) into new cache */
3340       if (artwork_new != NULL)
3341         setArtworkInfoCacheEntry(artwork_new, level_node, type);
3342     }
3343
3344     DrawInitText(level_node->name, 150, FC_YELLOW);
3345
3346     if (level_node->node_group != NULL)
3347       LoadArtworkInfoFromLevelInfo(artwork_node, level_node->node_group);
3348
3349     level_node = level_node->next;
3350   }
3351 }
3352
3353 void LoadLevelArtworkInfo()
3354 {
3355   print_timestamp_init("LoadLevelArtworkInfo");
3356
3357   DrawInitText("Looking for custom level artwork", 120, FC_GREEN);
3358
3359   print_timestamp_time("DrawTimeText");
3360
3361   LoadArtworkInfoFromLevelInfo(&artwork.gfx_first, leveldir_first_all);
3362   print_timestamp_time("LoadArtworkInfoFromLevelInfo (gfx)");
3363   LoadArtworkInfoFromLevelInfo(&artwork.snd_first, leveldir_first_all);
3364   print_timestamp_time("LoadArtworkInfoFromLevelInfo (snd)");
3365   LoadArtworkInfoFromLevelInfo(&artwork.mus_first, leveldir_first_all);
3366   print_timestamp_time("LoadArtworkInfoFromLevelInfo (mus)");
3367
3368   SaveArtworkInfoCache();
3369
3370   print_timestamp_time("SaveArtworkInfoCache");
3371
3372   /* needed for reloading level artwork not known at ealier stage */
3373
3374   if (!strEqual(artwork.gfx_current_identifier, setup.graphics_set))
3375   {
3376     artwork.gfx_current =
3377       getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set);
3378     if (artwork.gfx_current == NULL)
3379       artwork.gfx_current =
3380         getTreeInfoFromIdentifier(artwork.gfx_first, GFX_DEFAULT_SUBDIR);
3381     if (artwork.gfx_current == NULL)
3382       artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first);
3383   }
3384
3385   if (!strEqual(artwork.snd_current_identifier, setup.sounds_set))
3386   {
3387     artwork.snd_current =
3388       getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set);
3389     if (artwork.snd_current == NULL)
3390       artwork.snd_current =
3391         getTreeInfoFromIdentifier(artwork.snd_first, SND_DEFAULT_SUBDIR);
3392     if (artwork.snd_current == NULL)
3393       artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first);
3394   }
3395
3396   if (!strEqual(artwork.mus_current_identifier, setup.music_set))
3397   {
3398     artwork.mus_current =
3399       getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set);
3400     if (artwork.mus_current == NULL)
3401       artwork.mus_current =
3402         getTreeInfoFromIdentifier(artwork.mus_first, MUS_DEFAULT_SUBDIR);
3403     if (artwork.mus_current == NULL)
3404       artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first);
3405   }
3406
3407   print_timestamp_time("getTreeInfoFromIdentifier");
3408
3409   sortTreeInfo(&artwork.gfx_first);
3410   sortTreeInfo(&artwork.snd_first);
3411   sortTreeInfo(&artwork.mus_first);
3412
3413   print_timestamp_time("sortTreeInfo");
3414
3415 #if ENABLE_UNUSED_CODE
3416   dumpTreeInfo(artwork.gfx_first, 0);
3417   dumpTreeInfo(artwork.snd_first, 0);
3418   dumpTreeInfo(artwork.mus_first, 0);
3419 #endif
3420
3421   print_timestamp_done("LoadLevelArtworkInfo");
3422 }
3423
3424 static void SaveUserLevelInfo()
3425 {
3426   LevelDirTree *level_info;
3427   char *filename;
3428   FILE *file;
3429   int i;
3430
3431   filename = getPath2(getUserLevelDir(getLoginName()), LEVELINFO_FILENAME);
3432
3433   if (!(file = fopen(filename, MODE_WRITE)))
3434   {
3435     Error(ERR_WARN, "cannot write level info file '%s'", filename);
3436     free(filename);
3437     return;
3438   }
3439
3440   level_info = newTreeInfo();
3441
3442   /* always start with reliable default values */
3443   setTreeInfoToDefaults(level_info, TREE_TYPE_LEVEL_DIR);
3444
3445   setString(&level_info->name, getLoginName());
3446   setString(&level_info->author, getRealName());
3447   level_info->levels = 100;
3448   level_info->first_level = 1;
3449
3450   token_value_position = TOKEN_VALUE_POSITION_SHORT;
3451
3452   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
3453                                                  getCookie("LEVELINFO")));
3454
3455   ldi = *level_info;
3456   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3457   {
3458     if (i == LEVELINFO_TOKEN_NAME ||
3459         i == LEVELINFO_TOKEN_AUTHOR ||
3460         i == LEVELINFO_TOKEN_LEVELS ||
3461         i == LEVELINFO_TOKEN_FIRST_LEVEL)
3462       fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
3463
3464     /* just to make things nicer :) */
3465     if (i == LEVELINFO_TOKEN_AUTHOR)
3466       fprintf(file, "\n");
3467   }
3468
3469   token_value_position = TOKEN_VALUE_POSITION_DEFAULT;
3470
3471   fclose(file);
3472
3473   SetFilePermissions(filename, PERMS_PRIVATE);
3474
3475   freeTreeInfo(level_info);
3476   free(filename);
3477 }
3478
3479 char *getSetupValue(int type, void *value)
3480 {
3481   static char value_string[MAX_LINE_LEN];
3482
3483   if (value == NULL)
3484     return NULL;
3485
3486   switch (type)
3487   {
3488     case TYPE_BOOLEAN:
3489       strcpy(value_string, (*(boolean *)value ? "true" : "false"));
3490       break;
3491
3492     case TYPE_SWITCH:
3493       strcpy(value_string, (*(boolean *)value ? "on" : "off"));
3494       break;
3495
3496     case TYPE_SWITCH3:
3497       strcpy(value_string, (*(int *)value == AUTO  ? "auto" :
3498                             *(int *)value == FALSE ? "off" : "on"));
3499       break;
3500
3501     case TYPE_YES_NO:
3502       strcpy(value_string, (*(boolean *)value ? "yes" : "no"));
3503       break;
3504
3505     case TYPE_YES_NO_AUTO:
3506       strcpy(value_string, (*(int *)value == AUTO  ? "auto" :
3507                             *(int *)value == FALSE ? "no" : "yes"));
3508       break;
3509
3510     case TYPE_ECS_AGA:
3511       strcpy(value_string, (*(boolean *)value ? "AGA" : "ECS"));
3512       break;
3513
3514     case TYPE_KEY:
3515       strcpy(value_string, getKeyNameFromKey(*(Key *)value));
3516       break;
3517
3518     case TYPE_KEY_X11:
3519       strcpy(value_string, getX11KeyNameFromKey(*(Key *)value));
3520       break;
3521
3522     case TYPE_INTEGER:
3523       sprintf(value_string, "%d", *(int *)value);
3524       break;
3525
3526     case TYPE_STRING:
3527       if (*(char **)value == NULL)
3528         return NULL;
3529
3530       strcpy(value_string, *(char **)value);
3531       break;
3532
3533     default:
3534       value_string[0] = '\0';
3535       break;
3536   }
3537
3538   if (type & TYPE_GHOSTED)
3539     strcpy(value_string, "n/a");
3540
3541   return value_string;
3542 }
3543
3544 char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
3545 {
3546   int i;
3547   char *line;
3548   static char token_string[MAX_LINE_LEN];
3549   int token_type = token_info[token_nr].type;
3550   void *setup_value = token_info[token_nr].value;
3551   char *token_text = token_info[token_nr].text;
3552   char *value_string = getSetupValue(token_type, setup_value);
3553
3554   /* build complete token string */
3555   sprintf(token_string, "%s%s", prefix, token_text);
3556
3557   /* build setup entry line */
3558   line = getFormattedSetupEntry(token_string, value_string);
3559
3560   if (token_type == TYPE_KEY_X11)
3561   {
3562     Key key = *(Key *)setup_value;
3563     char *keyname = getKeyNameFromKey(key);
3564
3565     /* add comment, if useful */
3566     if (!strEqual(keyname, "(undefined)") &&
3567         !strEqual(keyname, "(unknown)"))
3568     {
3569       /* add at least one whitespace */
3570       strcat(line, " ");
3571       for (i = strlen(line); i < token_comment_position; i++)
3572         strcat(line, " ");
3573
3574       strcat(line, "# ");
3575       strcat(line, keyname);
3576     }
3577   }
3578
3579   return line;
3580 }
3581
3582 void LoadLevelSetup_LastSeries()
3583 {
3584   /* ----------------------------------------------------------------------- */
3585   /* ~/.<program>/levelsetup.conf                                            */
3586   /* ----------------------------------------------------------------------- */
3587
3588   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
3589   SetupFileHash *level_setup_hash = NULL;
3590
3591   /* always start with reliable default values */
3592   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
3593
3594 #if defined(CREATE_SPECIAL_EDITION_RND_JUE)
3595   leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
3596                                                "jue_start");
3597   if (leveldir_current == NULL)
3598     leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
3599 #endif
3600
3601   if ((level_setup_hash = loadSetupFileHash(filename)))
3602   {
3603     char *last_level_series =
3604       getHashEntry(level_setup_hash, TOKEN_STR_LAST_LEVEL_SERIES);
3605
3606     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
3607                                                  last_level_series);
3608     if (leveldir_current == NULL)
3609       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
3610
3611     checkSetupFileHashIdentifier(level_setup_hash, filename,
3612                                  getCookie("LEVELSETUP"));
3613
3614     freeSetupFileHash(level_setup_hash);
3615   }
3616   else
3617     Error(ERR_WARN, "using default setup values");
3618
3619   free(filename);
3620 }
3621
3622 static void SaveLevelSetup_LastSeries_Ext(boolean deactivate_last_level_series)
3623 {
3624   /* ----------------------------------------------------------------------- */
3625   /* ~/.<program>/levelsetup.conf                                            */
3626   /* ----------------------------------------------------------------------- */
3627
3628   // check if the current level directory structure is available at this point
3629   if (leveldir_current == NULL)
3630     return;
3631
3632   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
3633   char *level_subdir = leveldir_current->subdir;
3634   FILE *file;
3635
3636   InitUserDataDirectory();
3637
3638   if (!(file = fopen(filename, MODE_WRITE)))
3639   {
3640     Error(ERR_WARN, "cannot write setup file '%s'", filename);
3641
3642     free(filename);
3643
3644     return;
3645   }
3646
3647   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
3648                                                  getCookie("LEVELSETUP")));
3649
3650   if (deactivate_last_level_series)
3651     fprintf(file, "# %s\n# ", "the following level set may have caused a problem and was deactivated");
3652
3653   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES,
3654                                                level_subdir));
3655
3656   fclose(file);
3657
3658   SetFilePermissions(filename, PERMS_PRIVATE);
3659
3660   free(filename);
3661 }
3662
3663 void SaveLevelSetup_LastSeries()
3664 {
3665   SaveLevelSetup_LastSeries_Ext(FALSE);
3666 }
3667
3668 void SaveLevelSetup_LastSeries_Deactivate()
3669 {
3670   SaveLevelSetup_LastSeries_Ext(TRUE);
3671 }
3672
3673 static void checkSeriesInfo()
3674 {
3675   static char *level_directory = NULL;
3676   Directory *dir;
3677
3678   /* check for more levels besides the 'levels' field of 'levelinfo.conf' */
3679
3680   level_directory = getPath2((leveldir_current->in_user_dir ?
3681                               getUserLevelDir(NULL) :
3682                               options.level_directory),
3683                              leveldir_current->fullpath);
3684
3685   if ((dir = openDirectory(level_directory)) == NULL)
3686   {
3687     Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
3688
3689     return;
3690   }
3691
3692   closeDirectory(dir);
3693 }
3694
3695 void LoadLevelSetup_SeriesInfo()
3696 {
3697   char *filename;
3698   SetupFileHash *level_setup_hash = NULL;
3699   char *level_subdir = leveldir_current->subdir;
3700   int i;
3701
3702   /* always start with reliable default values */
3703   level_nr = leveldir_current->first_level;
3704
3705   for (i = 0; i < MAX_LEVELS; i++)
3706   {
3707     LevelStats_setPlayed(i, 0);
3708     LevelStats_setSolved(i, 0);
3709   }
3710
3711   checkSeriesInfo(leveldir_current);
3712
3713   /* ----------------------------------------------------------------------- */
3714   /* ~/.<program>/levelsetup/<level series>/levelsetup.conf                  */
3715   /* ----------------------------------------------------------------------- */
3716
3717   level_subdir = leveldir_current->subdir;
3718
3719   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
3720
3721   if ((level_setup_hash = loadSetupFileHash(filename)))
3722   {
3723     char *token_value;
3724
3725     /* get last played level in this level set */
3726
3727     token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL);
3728
3729     if (token_value)
3730     {
3731       level_nr = atoi(token_value);
3732
3733       if (level_nr < leveldir_current->first_level)
3734         level_nr = leveldir_current->first_level;
3735       if (level_nr > leveldir_current->last_level)
3736         level_nr = leveldir_current->last_level;
3737     }
3738
3739     /* get handicap level in this level set */
3740
3741     token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL);
3742
3743     if (token_value)
3744     {
3745       int level_nr = atoi(token_value);
3746
3747       if (level_nr < leveldir_current->first_level)
3748         level_nr = leveldir_current->first_level;
3749       if (level_nr > leveldir_current->last_level + 1)
3750         level_nr = leveldir_current->last_level;
3751
3752       if (leveldir_current->user_defined || !leveldir_current->handicap)
3753         level_nr = leveldir_current->last_level;
3754
3755       leveldir_current->handicap_level = level_nr;
3756     }
3757
3758     /* get number of played and solved levels in this level set */
3759
3760     BEGIN_HASH_ITERATION(level_setup_hash, itr)
3761     {
3762       char *token = HASH_ITERATION_TOKEN(itr);
3763       char *value = HASH_ITERATION_VALUE(itr);
3764
3765       if (strlen(token) == 3 &&
3766           token[0] >= '0' && token[0] <= '9' &&
3767           token[1] >= '0' && token[1] <= '9' &&
3768           token[2] >= '0' && token[2] <= '9')
3769       {
3770         int level_nr = atoi(token);
3771
3772         if (value != NULL)
3773           LevelStats_setPlayed(level_nr, atoi(value));  /* read 1st column */
3774
3775         value = strchr(value, ' ');
3776
3777         if (value != NULL)
3778           LevelStats_setSolved(level_nr, atoi(value));  /* read 2nd column */
3779       }
3780     }
3781     END_HASH_ITERATION(hash, itr)
3782
3783     checkSetupFileHashIdentifier(level_setup_hash, filename,
3784                                  getCookie("LEVELSETUP"));
3785
3786     freeSetupFileHash(level_setup_hash);
3787   }
3788   else
3789     Error(ERR_WARN, "using default setup values");
3790
3791   free(filename);
3792 }
3793
3794 void SaveLevelSetup_SeriesInfo()
3795 {
3796   char *filename;
3797   char *level_subdir = leveldir_current->subdir;
3798   char *level_nr_str = int2str(level_nr, 0);
3799   char *handicap_level_str = int2str(leveldir_current->handicap_level, 0);
3800   FILE *file;
3801   int i;
3802
3803   /* ----------------------------------------------------------------------- */
3804   /* ~/.<program>/levelsetup/<level series>/levelsetup.conf                  */
3805   /* ----------------------------------------------------------------------- */
3806
3807   InitLevelSetupDirectory(level_subdir);
3808
3809   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
3810
3811   if (!(file = fopen(filename, MODE_WRITE)))
3812   {
3813     Error(ERR_WARN, "cannot write setup file '%s'", filename);
3814     free(filename);
3815     return;
3816   }
3817
3818   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER,
3819                                                  getCookie("LEVELSETUP")));
3820   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_PLAYED_LEVEL,
3821                                                level_nr_str));
3822   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL,
3823                                                  handicap_level_str));
3824
3825   for (i = leveldir_current->first_level; i <= leveldir_current->last_level;
3826        i++)
3827   {
3828     if (LevelStats_getPlayed(i) > 0 ||
3829         LevelStats_getSolved(i) > 0)
3830     {
3831       char token[16];
3832       char value[16];
3833
3834       sprintf(token, "%03d", i);
3835       sprintf(value, "%d %d", LevelStats_getPlayed(i), LevelStats_getSolved(i));
3836
3837       fprintf(file, "%s\n", getFormattedSetupEntry(token, value));
3838     }
3839   }
3840
3841   fclose(file);
3842
3843   SetFilePermissions(filename, PERMS_PRIVATE);
3844
3845   free(filename);
3846 }
3847
3848 int LevelStats_getPlayed(int nr)
3849 {
3850   return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].played : 0);
3851 }
3852
3853 int LevelStats_getSolved(int nr)
3854 {
3855   return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].solved : 0);
3856 }
3857
3858 void LevelStats_setPlayed(int nr, int value)
3859 {
3860   if (nr >= 0 && nr < MAX_LEVELS)
3861     level_stats[nr].played = value;
3862 }
3863
3864 void LevelStats_setSolved(int nr, int value)
3865 {
3866   if (nr >= 0 && nr < MAX_LEVELS)
3867     level_stats[nr].solved = value;
3868 }
3869
3870 void LevelStats_incPlayed(int nr)
3871 {
3872   if (nr >= 0 && nr < MAX_LEVELS)
3873     level_stats[nr].played++;
3874 }
3875
3876 void LevelStats_incSolved(int nr)
3877 {
3878   if (nr >= 0 && nr < MAX_LEVELS)
3879     level_stats[nr].solved++;
3880 }