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 //                  https://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 #include "setup.h"
  22 #include "joystick.h"
  23 #include "text.h"
  24 #include "misc.h"
  25 #include "hash.h"
  26 #include "zip/miniunz.h"
  27
  28
  29 #define ENABLE_UNUSED_CODE      FALSE   // for currently unused functions
  30 #define DEBUG_NO_CONFIG_FILE    FALSE   // for extra-verbose debug output
  31
  32 #define NUM_LEVELCLASS_DESC     8
  33
  34 static char *levelclass_desc[NUM_LEVELCLASS_DESC] =
  35 {
  36   "Tutorial Levels",
  37   "Classic Originals",
  38   "Contributions",
  39   "Private Levels",
  40   "Boulderdash",
  41   "Emerald Mine",
  42   "Supaplex",
  43   "DX Boulderdash"
  44 };
  45
  46 #define TOKEN_VALUE_POSITION_SHORT              32
  47 #define TOKEN_VALUE_POSITION_DEFAULT            40
  48 #define TOKEN_COMMENT_POSITION_DEFAULT          60
  49
  50 #define MAX_COOKIE_LEN                          256
  51
  52
  53 static void setTreeInfoToDefaults(TreeInfo *, int);
  54 static TreeInfo *getTreeInfoCopy(TreeInfo *ti);
  55 static int compareTreeInfoEntries(const void *, const void *);
  56
  57 static int token_value_position   = TOKEN_VALUE_POSITION_DEFAULT;
  58 static int token_comment_position = TOKEN_COMMENT_POSITION_DEFAULT;
  59
  60 static SetupFileHash *artworkinfo_cache_old = NULL;
  61 static SetupFileHash *artworkinfo_cache_new = NULL;
  62 static SetupFileHash *optional_tokens_hash = NULL;
  63 static boolean use_artworkinfo_cache = TRUE;
  64 static boolean update_artworkinfo_cache = FALSE;
  65
  66
  67 // ----------------------------------------------------------------------------
  68 // file functions
  69 // ----------------------------------------------------------------------------
  70
  71 static char *getLevelClassDescription(TreeInfo *ti)
  72 {
  73   int position = ti->sort_priority / 100;
  74
  75   if (position >= 0 && position < NUM_LEVELCLASS_DESC)
  76     return levelclass_desc[position];
  77   else
  78     return "Unknown Level Class";
  79 }
  80
  81 static char *getScoreDir(char *level_subdir)
  82 {
  83   static char *score_dir = NULL;
  84   static char *score_level_dir = NULL;
  85   char *score_subdir = SCORES_DIRECTORY;
  86
  87   if (score_dir == NULL)
  88   {
  89     if (program.global_scores)
  90       score_dir = getPath2(getCommonDataDir(),       score_subdir);
  91     else
  92       score_dir = getPath2(getMainUserGameDataDir(), score_subdir);
  93   }
  94
  95   if (level_subdir != NULL)
  96   {
  97     checked_free(score_level_dir);
  98
  99     score_level_dir = getPath2(score_dir, level_subdir);
 100
 101     return score_level_dir;
 102   }
 103
 104   return score_dir;
 105 }
 106
 107 static char *getUserSubdir(int nr)
 108 {
 109   static char user_subdir[16] = { 0 };
 110
 111   sprintf(user_subdir, "%03d", nr);
 112
 113   return user_subdir;
 114 }
 115
 116 static char *getUserDir(int nr)
 117 {
 118   static char *user_dir = NULL;
 119   char *main_data_dir = getMainUserGameDataDir();
 120   char *users_subdir = USERS_DIRECTORY;
 121   char *user_subdir = getUserSubdir(nr);
 122
 123   checked_free(user_dir);
 124
 125   if (nr != -1)
 126     user_dir = getPath3(main_data_dir, users_subdir, user_subdir);
 127   else
 128     user_dir = getPath2(main_data_dir, users_subdir);
 129
 130   return user_dir;
 131 }
 132
 133 static char *getLevelSetupDir(char *level_subdir)
 134 {
 135   static char *levelsetup_dir = NULL;
 136   char *data_dir = getUserGameDataDir();
 137   char *levelsetup_subdir = LEVELSETUP_DIRECTORY;
 138
 139   checked_free(levelsetup_dir);
 140
 141   if (level_subdir != NULL)
 142     levelsetup_dir = getPath3(data_dir, levelsetup_subdir, level_subdir);
 143   else
 144     levelsetup_dir = getPath2(data_dir, levelsetup_subdir);
 145
 146   return levelsetup_dir;
 147 }
 148
 149 static char *getCacheDir(void)
 150 {
 151   static char *cache_dir = NULL;
 152
 153   if (cache_dir == NULL)
 154     cache_dir = getPath2(getMainUserGameDataDir(), CACHE_DIRECTORY);
 155
 156   return cache_dir;
 157 }
 158
 159 static char *getNetworkDir(void)
 160 {
 161   static char *network_dir = NULL;
 162
 163   if (network_dir == NULL)
 164     network_dir = getPath2(getMainUserGameDataDir(), NETWORK_DIRECTORY);
 165
 166   return network_dir;
 167 }
 168
 169 char *getLevelDirFromTreeInfo(TreeInfo *node)
 170 {
 171   static char *level_dir = NULL;
 172
 173   if (node == NULL)
 174     return options.level_directory;
 175
 176   checked_free(level_dir);
 177
 178   level_dir = getPath2((node->in_user_dir ? getUserLevelDir(NULL) :
 179                         options.level_directory), node->fullpath);
 180
 181   return level_dir;
 182 }
 183
 184 char *getUserLevelDir(char *level_subdir)
 185 {
 186   static char *userlevel_dir = NULL;
 187   char *data_dir = getMainUserGameDataDir();
 188   char *userlevel_subdir = LEVELS_DIRECTORY;
 189
 190   checked_free(userlevel_dir);
 191
 192   if (level_subdir != NULL)
 193     userlevel_dir = getPath3(data_dir, userlevel_subdir, level_subdir);
 194   else
 195     userlevel_dir = getPath2(data_dir, userlevel_subdir);
 196
 197   return userlevel_dir;
 198 }
 199
 200 char *getNetworkLevelDir(char *level_subdir)
 201 {
 202   static char *network_level_dir = NULL;
 203   char *data_dir = getNetworkDir();
 204   char *networklevel_subdir = LEVELS_DIRECTORY;
 205
 206   checked_free(network_level_dir);
 207
 208   if (level_subdir != NULL)
 209     network_level_dir = getPath3(data_dir, networklevel_subdir, level_subdir);
 210   else
 211     network_level_dir = getPath2(data_dir, networklevel_subdir);
 212
 213   return network_level_dir;
 214 }
 215
 216 char *getCurrentLevelDir(void)
 217 {
 218   return getLevelDirFromTreeInfo(leveldir_current);
 219 }
 220
 221 char *getNewUserLevelSubdir(void)
 222 {
 223   static char *new_level_subdir = NULL;
 224   char *subdir_prefix = getLoginName();
 225   char subdir_suffix[10];
 226   int max_suffix_number = 1000;
 227   int i = 0;
 228
 229   while (++i < max_suffix_number)
 230   {
 231     sprintf(subdir_suffix, "_%d", i);
 232
 233     checked_free(new_level_subdir);
 234     new_level_subdir = getStringCat2(subdir_prefix, subdir_suffix);
 235
 236     if (!directoryExists(getUserLevelDir(new_level_subdir)))
 237       break;
 238   }
 239
 240   return new_level_subdir;
 241 }
 242
 243 static char *getTapeDir(char *level_subdir)
 244 {
 245   static char *tape_dir = NULL;
 246   char *data_dir = getUserGameDataDir();
 247   char *tape_subdir = TAPES_DIRECTORY;
 248
 249   checked_free(tape_dir);
 250
 251   if (level_subdir != NULL)
 252     tape_dir = getPath3(data_dir, tape_subdir, level_subdir);
 253   else
 254     tape_dir = getPath2(data_dir, tape_subdir);
 255
 256   return tape_dir;
 257 }
 258
 259 static char *getSolutionTapeDir(void)
 260 {
 261   static char *tape_dir = NULL;
 262   char *data_dir = getCurrentLevelDir();
 263   char *tape_subdir = TAPES_DIRECTORY;
 264
 265   checked_free(tape_dir);
 266
 267   tape_dir = getPath2(data_dir, tape_subdir);
 268
 269   return tape_dir;
 270 }
 271
 272 static char *getDefaultGraphicsDir(char *graphics_subdir)
 273 {
 274   static char *graphics_dir = NULL;
 275
 276   if (graphics_subdir == NULL)
 277     return options.graphics_directory;
 278
 279   checked_free(graphics_dir);
 280
 281   graphics_dir = getPath2(options.graphics_directory, graphics_subdir);
 282
 283   return graphics_dir;
 284 }
 285
 286 static char *getDefaultSoundsDir(char *sounds_subdir)
 287 {
 288   static char *sounds_dir = NULL;
 289
 290   if (sounds_subdir == NULL)
 291     return options.sounds_directory;
 292
 293   checked_free(sounds_dir);
 294
 295   sounds_dir = getPath2(options.sounds_directory, sounds_subdir);
 296
 297   return sounds_dir;
 298 }
 299
 300 static char *getDefaultMusicDir(char *music_subdir)
 301 {
 302   static char *music_dir = NULL;
 303
 304   if (music_subdir == NULL)
 305     return options.music_directory;
 306
 307   checked_free(music_dir);
 308
 309   music_dir = getPath2(options.music_directory, music_subdir);
 310
 311   return music_dir;
 312 }
 313
 314 static char *getClassicArtworkSet(int type)
 315 {
 316   return (type == TREE_TYPE_GRAPHICS_DIR ? GFX_CLASSIC_SUBDIR :
 317           type == TREE_TYPE_SOUNDS_DIR   ? SND_CLASSIC_SUBDIR :
 318           type == TREE_TYPE_MUSIC_DIR    ? MUS_CLASSIC_SUBDIR : "");
 319 }
 320
 321 static char *getClassicArtworkDir(int type)
 322 {
 323   return (type == TREE_TYPE_GRAPHICS_DIR ?
 324           getDefaultGraphicsDir(GFX_CLASSIC_SUBDIR) :
 325           type == TREE_TYPE_SOUNDS_DIR ?
 326           getDefaultSoundsDir(SND_CLASSIC_SUBDIR) :
 327           type == TREE_TYPE_MUSIC_DIR ?
 328           getDefaultMusicDir(MUS_CLASSIC_SUBDIR) : "");
 329 }
 330
 331 char *getUserGraphicsDir(void)
 332 {
 333   static char *usergraphics_dir = NULL;
 334
 335   if (usergraphics_dir == NULL)
 336     usergraphics_dir = getPath2(getMainUserGameDataDir(), GRAPHICS_DIRECTORY);
 337
 338   return usergraphics_dir;
 339 }
 340
 341 char *getUserSoundsDir(void)
 342 {
 343   static char *usersounds_dir = NULL;
 344
 345   if (usersounds_dir == NULL)
 346     usersounds_dir = getPath2(getMainUserGameDataDir(), SOUNDS_DIRECTORY);
 347
 348   return usersounds_dir;
 349 }
 350
 351 char *getUserMusicDir(void)
 352 {
 353   static char *usermusic_dir = NULL;
 354
 355   if (usermusic_dir == NULL)
 356     usermusic_dir = getPath2(getMainUserGameDataDir(), MUSIC_DIRECTORY);
 357
 358   return usermusic_dir;
 359 }
 360
 361 static char *getSetupArtworkDir(TreeInfo *ti)
 362 {
 363   static char *artwork_dir = NULL;
 364
 365   if (ti == NULL)
 366     return NULL;
 367
 368   checked_free(artwork_dir);
 369
 370   artwork_dir = getPath2(ti->basepath, ti->fullpath);
 371
 372   return artwork_dir;
 373 }
 374
 375 char *setLevelArtworkDir(TreeInfo *ti)
 376 {
 377   char **artwork_path_ptr, **artwork_set_ptr;
 378   TreeInfo *level_artwork;
 379
 380   if (ti == NULL || leveldir_current == NULL)
 381     return NULL;
 382
 383   artwork_path_ptr = LEVELDIR_ARTWORK_PATH_PTR(leveldir_current, ti->type);
 384   artwork_set_ptr  = LEVELDIR_ARTWORK_SET_PTR( leveldir_current, ti->type);
 385
 386   checked_free(*artwork_path_ptr);
 387
 388   if ((level_artwork = getTreeInfoFromIdentifier(ti, *artwork_set_ptr)))
 389   {
 390     *artwork_path_ptr = getStringCopy(getSetupArtworkDir(level_artwork));
 391   }
 392   else
 393   {
 394     /*
 395       No (or non-existing) artwork configured in "levelinfo.conf". This would
 396       normally result in using the artwork configured in the setup menu. But
 397       if an artwork subdirectory exists (which might contain custom artwork
 398       or an artwork configuration file), this level artwork must be treated
 399       as relative to the default "classic" artwork, not to the artwork that
 400       is currently configured in the setup menu.
 401
 402       Update: For "special" versions of R'n'D (like "R'n'D jue"), do not use
 403       the "default" artwork (which would be "jue0" for "R'n'D jue"), but use
 404       the real "classic" artwork from the original R'n'D (like "gfx_classic").
 405     */
 406
 407     char *dir = getPath2(getCurrentLevelDir(), ARTWORK_DIRECTORY(ti->type));
 408
 409     checked_free(*artwork_set_ptr);
 410
 411     if (directoryExists(dir))
 412     {
 413       *artwork_path_ptr = getStringCopy(getClassicArtworkDir(ti->type));
 414       *artwork_set_ptr = getStringCopy(getClassicArtworkSet(ti->type));
 415     }
 416     else
 417     {
 418       *artwork_path_ptr = getStringCopy(UNDEFINED_FILENAME);
 419       *artwork_set_ptr = NULL;
 420     }
 421
 422     free(dir);
 423   }
 424
 425   return *artwork_set_ptr;
 426 }
 427
 428 static char *getLevelArtworkSet(int type)
 429 {
 430   if (leveldir_current == NULL)
 431     return NULL;
 432
 433   return LEVELDIR_ARTWORK_SET(leveldir_current, type);
 434 }
 435
 436 static char *getLevelArtworkDir(int type)
 437 {
 438   if (leveldir_current == NULL)
 439     return UNDEFINED_FILENAME;
 440
 441   return LEVELDIR_ARTWORK_PATH(leveldir_current, type);
 442 }
 443
 444 char *getProgramMainDataPath(char *command_filename, char *base_path)
 445 {
 446   // check if the program's main data base directory is configured
 447   if (!strEqual(base_path, "."))
 448     return getStringCopy(base_path);
 449
 450   /* if the program is configured to start from current directory (default),
 451      determine program package directory from program binary (some versions
 452      of KDE/Konqueror and Mac OS X (especially "Mavericks") apparently do not
 453      set the current working directory to the program package directory) */
 454   char *main_data_path = getBasePath(command_filename);
 455
 456 #if defined(PLATFORM_MACOSX)
 457   if (strSuffix(main_data_path, MAC_APP_BINARY_SUBDIR))
 458   {
 459     char *main_data_path_old = main_data_path;
 460
 461     // cut relative path to Mac OS X application binary directory from path
 462     main_data_path[strlen(main_data_path) -
 463                    strlen(MAC_APP_BINARY_SUBDIR)] = '\0';
 464
 465     // cut trailing path separator from path (but not if path is root directory)
 466     if (strSuffix(main_data_path, "/") && !strEqual(main_data_path, "/"))
 467       main_data_path[strlen(main_data_path) - 1] = '\0';
 468
 469     // replace empty path with current directory
 470     if (strEqual(main_data_path, ""))
 471       main_data_path = ".";
 472
 473     // add relative path to Mac OS X application resources directory to path
 474     main_data_path = getPath2(main_data_path, MAC_APP_FILES_SUBDIR);
 475
 476     free(main_data_path_old);
 477   }
 478 #endif
 479
 480   return main_data_path;
 481 }
 482
 483 char *getProgramConfigFilename(char *command_filename)
 484 {
 485   static char *config_filename_1 = NULL;
 486   static char *config_filename_2 = NULL;
 487   static char *config_filename_3 = NULL;
 488   static boolean initialized = FALSE;
 489
 490   if (!initialized)
 491   {
 492     char *command_filename_1 = getStringCopy(command_filename);
 493
 494     // strip trailing executable suffix from command filename
 495     if (strSuffix(command_filename_1, ".exe"))
 496       command_filename_1[strlen(command_filename_1) - 4] = '\0';
 497
 498     char *ro_base_path = getProgramMainDataPath(command_filename, RO_BASE_PATH);
 499     char *conf_directory = getPath2(ro_base_path, CONF_DIRECTORY);
 500
 501     char *command_basepath = getBasePath(command_filename);
 502     char *command_basename = getBaseNameNoSuffix(command_filename);
 503     char *command_filename_2 = getPath2(command_basepath, command_basename);
 504
 505     config_filename_1 = getStringCat2(command_filename_1, ".conf");
 506     config_filename_2 = getStringCat2(command_filename_2, ".conf");
 507     config_filename_3 = getPath2(conf_directory, SETUP_FILENAME);
 508
 509     checked_free(ro_base_path);
 510     checked_free(conf_directory);
 511
 512     checked_free(command_basepath);
 513     checked_free(command_basename);
 514
 515     checked_free(command_filename_1);
 516     checked_free(command_filename_2);
 517
 518     initialized = TRUE;
 519   }
 520
 521   // 1st try: look for config file that exactly matches the binary filename
 522   if (fileExists(config_filename_1))
 523     return config_filename_1;
 524
 525   // 2nd try: look for config file that matches binary filename without suffix
 526   if (fileExists(config_filename_2))
 527     return config_filename_2;
 528
 529   // 3rd try: return setup config filename in global program config directory
 530   return config_filename_3;
 531 }
 532
 533 char *getTapeFilename(int nr)
 534 {
 535   static char *filename = NULL;
 536   char basename[MAX_FILENAME_LEN];
 537
 538   checked_free(filename);
 539
 540   sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
 541   filename = getPath2(getTapeDir(leveldir_current->subdir), basename);
 542
 543   return filename;
 544 }
 545
 546 char *getSolutionTapeFilename(int nr)
 547 {
 548   static char *filename = NULL;
 549   char basename[MAX_FILENAME_LEN];
 550
 551   checked_free(filename);
 552
 553   sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
 554   filename = getPath2(getSolutionTapeDir(), basename);
 555
 556   if (!fileExists(filename))
 557   {
 558     static char *filename_sln = NULL;
 559
 560     checked_free(filename_sln);
 561
 562     sprintf(basename, "%03d.sln", nr);
 563     filename_sln = getPath2(getSolutionTapeDir(), basename);
 564
 565     if (fileExists(filename_sln))
 566       return filename_sln;
 567   }
 568
 569   return filename;
 570 }
 571
 572 char *getScoreFilename(int nr)
 573 {
 574   static char *filename = NULL;
 575   char basename[MAX_FILENAME_LEN];
 576
 577   checked_free(filename);
 578
 579   sprintf(basename, "%03d.%s", nr, SCOREFILE_EXTENSION);
 580
 581   // used instead of "leveldir_current->subdir" (for network games)
 582   filename = getPath2(getScoreDir(levelset.identifier), basename);
 583
 584   return filename;
 585 }
 586
 587 char *getSetupFilename(void)
 588 {
 589   static char *filename = NULL;
 590
 591   checked_free(filename);
 592
 593   filename = getPath2(getSetupDir(), SETUP_FILENAME);
 594
 595   return filename;
 596 }
 597
 598 char *getDefaultSetupFilename(void)
 599 {
 600   return program.config_filename;
 601 }
 602
 603 char *getEditorSetupFilename(void)
 604 {
 605   static char *filename = NULL;
 606
 607   checked_free(filename);
 608   filename = getPath2(getCurrentLevelDir(), EDITORSETUP_FILENAME);
 609
 610   if (fileExists(filename))
 611     return filename;
 612
 613   checked_free(filename);
 614   filename = getPath2(getSetupDir(), EDITORSETUP_FILENAME);
 615
 616   return filename;
 617 }
 618
 619 char *getHelpAnimFilename(void)
 620 {
 621   static char *filename = NULL;
 622
 623   checked_free(filename);
 624
 625   filename = getPath2(getCurrentLevelDir(), HELPANIM_FILENAME);
 626
 627   return filename;
 628 }
 629
 630 char *getHelpTextFilename(void)
 631 {
 632   static char *filename = NULL;
 633
 634   checked_free(filename);
 635
 636   filename = getPath2(getCurrentLevelDir(), HELPTEXT_FILENAME);
 637
 638   return filename;
 639 }
 640
 641 char *getLevelSetInfoFilename(void)
 642 {
 643   static char *filename = NULL;
 644   char *basenames[] =
 645   {
 646     "README",
 647     "README.TXT",
 648     "README.txt",
 649     "Readme",
 650     "Readme.txt",
 651     "readme",
 652     "readme.txt",
 653
 654     NULL
 655   };
 656   int i;
 657
 658   for (i = 0; basenames[i] != NULL; i++)
 659   {
 660     checked_free(filename);
 661     filename = getPath2(getCurrentLevelDir(), basenames[i]);
 662
 663     if (fileExists(filename))
 664       return filename;
 665   }
 666
 667   return NULL;
 668 }
 669
 670 static char *getLevelSetTitleMessageBasename(int nr, boolean initial)
 671 {
 672   static char basename[32];
 673
 674   sprintf(basename, "%s_%d.txt",
 675           (initial ? "titlemessage_initial" : "titlemessage"), nr + 1);
 676
 677   return basename;
 678 }
 679
 680 char *getLevelSetTitleMessageFilename(int nr, boolean initial)
 681 {
 682   static char *filename = NULL;
 683   char *basename;
 684   boolean skip_setup_artwork = FALSE;
 685
 686   checked_free(filename);
 687
 688   basename = getLevelSetTitleMessageBasename(nr, initial);
 689
 690   if (!gfx.override_level_graphics)
 691   {
 692     // 1st try: look for special artwork in current level series directory
 693     filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
 694     if (fileExists(filename))
 695       return filename;
 696
 697     free(filename);
 698
 699     // 2nd try: look for message file in current level set directory
 700     filename = getPath2(getCurrentLevelDir(), basename);
 701     if (fileExists(filename))
 702       return filename;
 703
 704     free(filename);
 705
 706     // check if there is special artwork configured in level series config
 707     if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL)
 708     {
 709       // 3rd try: look for special artwork configured in level series config
 710       filename = getPath2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
 711       if (fileExists(filename))
 712         return filename;
 713
 714       free(filename);
 715
 716       // take missing artwork configured in level set config from default
 717       skip_setup_artwork = TRUE;
 718     }
 719   }
 720
 721   if (!skip_setup_artwork)
 722   {
 723     // 4th try: look for special artwork in configured artwork directory
 724     filename = getPath2(getSetupArtworkDir(artwork.gfx_current), basename);
 725     if (fileExists(filename))
 726       return filename;
 727
 728     free(filename);
 729   }
 730
 731   // 5th try: look for default artwork in new default artwork directory
 732   filename = getPath2(getDefaultGraphicsDir(GFX_DEFAULT_SUBDIR), basename);
 733   if (fileExists(filename))
 734     return filename;
 735
 736   free(filename);
 737
 738   // 6th try: look for default artwork in old default artwork directory
 739   filename = getPath2(options.graphics_directory, basename);
 740   if (fileExists(filename))
 741     return filename;
 742
 743   return NULL;          // cannot find specified artwork file anywhere
 744 }
 745
 746 static char *getCorrectedArtworkBasename(char *basename)
 747 {
 748   return basename;
 749 }
 750
 751 char *getCustomImageFilename(char *basename)
 752 {
 753   static char *filename = NULL;
 754   boolean skip_setup_artwork = FALSE;
 755
 756   checked_free(filename);
 757
 758   basename = getCorrectedArtworkBasename(basename);
 759
 760   if (!gfx.override_level_graphics)
 761   {
 762     // 1st try: look for special artwork in current level series directory
 763     filename = getImg3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
 764     if (fileExists(filename))
 765       return filename;
 766
 767     free(filename);
 768
 769     // check if there is special artwork configured in level series config
 770     if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL)
 771     {
 772       // 2nd try: look for special artwork configured in level series config
 773       filename = getImg2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
 774       if (fileExists(filename))
 775         return filename;
 776
 777       free(filename);
 778
 779       // take missing artwork configured in level set config from default
 780       skip_setup_artwork = TRUE;
 781     }
 782   }
 783
 784   if (!skip_setup_artwork)
 785   {
 786     // 3rd try: look for special artwork in configured artwork directory
 787     filename = getImg2(getSetupArtworkDir(artwork.gfx_current), basename);
 788     if (fileExists(filename))
 789       return filename;
 790
 791     free(filename);
 792   }
 793
 794   // 4th try: look for default artwork in new default artwork directory
 795   filename = getImg2(getDefaultGraphicsDir(GFX_DEFAULT_SUBDIR), basename);
 796   if (fileExists(filename))
 797     return filename;
 798
 799   free(filename);
 800
 801   // 5th try: look for default artwork in old default artwork directory
 802   filename = getImg2(options.graphics_directory, basename);
 803   if (fileExists(filename))
 804     return filename;
 805
 806   if (!strEqual(GFX_FALLBACK_FILENAME, UNDEFINED_FILENAME))
 807   {
 808     free(filename);
 809
 810     Warn("cannot find artwork file '%s' (using fallback)", basename);
 811
 812     // 6th try: look for fallback artwork in old default artwork directory
 813     // (needed to prevent errors when trying to access unused artwork files)
 814     filename = getImg2(options.graphics_directory, GFX_FALLBACK_FILENAME);
 815     if (fileExists(filename))
 816       return filename;
 817   }
 818
 819   return NULL;          // cannot find specified artwork file anywhere
 820 }
 821
 822 char *getCustomSoundFilename(char *basename)
 823 {
 824   static char *filename = NULL;
 825   boolean skip_setup_artwork = FALSE;
 826
 827   checked_free(filename);
 828
 829   basename = getCorrectedArtworkBasename(basename);
 830
 831   if (!gfx.override_level_sounds)
 832   {
 833     // 1st try: look for special artwork in current level series directory
 834     filename = getPath3(getCurrentLevelDir(), SOUNDS_DIRECTORY, basename);
 835     if (fileExists(filename))
 836       return filename;
 837
 838     free(filename);
 839
 840     // check if there is special artwork configured in level series config
 841     if (getLevelArtworkSet(ARTWORK_TYPE_SOUNDS) != NULL)
 842     {
 843       // 2nd try: look for special artwork configured in level series config
 844       filename = getPath2(getLevelArtworkDir(TREE_TYPE_SOUNDS_DIR), basename);
 845       if (fileExists(filename))
 846         return filename;
 847
 848       free(filename);
 849
 850       // take missing artwork configured in level set config from default
 851       skip_setup_artwork = TRUE;
 852     }
 853   }
 854
 855   if (!skip_setup_artwork)
 856   {
 857     // 3rd try: look for special artwork in configured artwork directory
 858     filename = getPath2(getSetupArtworkDir(artwork.snd_current), basename);
 859     if (fileExists(filename))
 860       return filename;
 861
 862     free(filename);
 863   }
 864
 865   // 4th try: look for default artwork in new default artwork directory
 866   filename = getPath2(getDefaultSoundsDir(SND_DEFAULT_SUBDIR), basename);
 867   if (fileExists(filename))
 868     return filename;
 869
 870   free(filename);
 871
 872   // 5th try: look for default artwork in old default artwork directory
 873   filename = getPath2(options.sounds_directory, basename);
 874   if (fileExists(filename))
 875     return filename;
 876
 877   if (!strEqual(SND_FALLBACK_FILENAME, UNDEFINED_FILENAME))
 878   {
 879     free(filename);
 880
 881     Warn("cannot find artwork file '%s' (using fallback)", basename);
 882
 883     // 6th try: look for fallback artwork in old default artwork directory
 884     // (needed to prevent errors when trying to access unused artwork files)
 885     filename = getPath2(options.sounds_directory, SND_FALLBACK_FILENAME);
 886     if (fileExists(filename))
 887       return filename;
 888   }
 889
 890   return NULL;          // cannot find specified artwork file anywhere
 891 }
 892
 893 char *getCustomMusicFilename(char *basename)
 894 {
 895   static char *filename = NULL;
 896   boolean skip_setup_artwork = FALSE;
 897
 898   checked_free(filename);
 899
 900   basename = getCorrectedArtworkBasename(basename);
 901
 902   if (!gfx.override_level_music)
 903   {
 904     // 1st try: look for special artwork in current level series directory
 905     filename = getPath3(getCurrentLevelDir(), MUSIC_DIRECTORY, basename);
 906     if (fileExists(filename))
 907       return filename;
 908
 909     free(filename);
 910
 911     // check if there is special artwork configured in level series config
 912     if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
 913     {
 914       // 2nd try: look for special artwork configured in level series config
 915       filename = getPath2(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR), basename);
 916       if (fileExists(filename))
 917         return filename;
 918
 919       free(filename);
 920
 921       // take missing artwork configured in level set config from default
 922       skip_setup_artwork = TRUE;
 923     }
 924   }
 925
 926   if (!skip_setup_artwork)
 927   {
 928     // 3rd try: look for special artwork in configured artwork directory
 929     filename = getPath2(getSetupArtworkDir(artwork.mus_current), basename);
 930     if (fileExists(filename))
 931       return filename;
 932
 933     free(filename);
 934   }
 935
 936   // 4th try: look for default artwork in new default artwork directory
 937   filename = getPath2(getDefaultMusicDir(MUS_DEFAULT_SUBDIR), basename);
 938   if (fileExists(filename))
 939     return filename;
 940
 941   free(filename);
 942
 943   // 5th try: look for default artwork in old default artwork directory
 944   filename = getPath2(options.music_directory, basename);
 945   if (fileExists(filename))
 946     return filename;
 947
 948   if (!strEqual(MUS_FALLBACK_FILENAME, UNDEFINED_FILENAME))
 949   {
 950     free(filename);
 951
 952     Warn("cannot find artwork file '%s' (using fallback)", basename);
 953
 954     // 6th try: look for fallback artwork in old default artwork directory
 955     // (needed to prevent errors when trying to access unused artwork files)
 956     filename = getPath2(options.music_directory, MUS_FALLBACK_FILENAME);
 957     if (fileExists(filename))
 958       return filename;
 959   }
 960
 961   return NULL;          // cannot find specified artwork file anywhere
 962 }
 963
 964 char *getCustomArtworkFilename(char *basename, int type)
 965 {
 966   if (type == ARTWORK_TYPE_GRAPHICS)
 967     return getCustomImageFilename(basename);
 968   else if (type == ARTWORK_TYPE_SOUNDS)
 969     return getCustomSoundFilename(basename);
 970   else if (type == ARTWORK_TYPE_MUSIC)
 971     return getCustomMusicFilename(basename);
 972   else
 973     return UNDEFINED_FILENAME;
 974 }
 975
 976 char *getCustomArtworkConfigFilename(int type)
 977 {
 978   return getCustomArtworkFilename(ARTWORKINFO_FILENAME(type), type);
 979 }
 980
 981 char *getCustomArtworkLevelConfigFilename(int type)
 982 {
 983   static char *filename = NULL;
 984
 985   checked_free(filename);
 986
 987   filename = getPath2(getLevelArtworkDir(type), ARTWORKINFO_FILENAME(type));
 988
 989   return filename;
 990 }
 991
 992 char *getCustomMusicDirectory(void)
 993 {
 994   static char *directory = NULL;
 995   boolean skip_setup_artwork = FALSE;
 996
 997   checked_free(directory);
 998
 999   if (!gfx.override_level_music)
1000   {
1001     // 1st try: look for special artwork in current level series directory
1002     directory = getPath2(getCurrentLevelDir(), MUSIC_DIRECTORY);
1003     if (directoryExists(directory))
1004       return directory;
1005
1006     free(directory);
1007
1008     // check if there is special artwork configured in level series config
1009     if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
1010     {
1011       // 2nd try: look for special artwork configured in level series config
1012       directory = getStringCopy(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR));
1013       if (directoryExists(directory))
1014         return directory;
1015
1016       free(directory);
1017
1018       // take missing artwork configured in level set config from default
1019       skip_setup_artwork = TRUE;
1020     }
1021   }
1022
1023   if (!skip_setup_artwork)
1024   {
1025     // 3rd try: look for special artwork in configured artwork directory
1026     directory = getStringCopy(getSetupArtworkDir(artwork.mus_current));
1027     if (directoryExists(directory))
1028       return directory;
1029
1030     free(directory);
1031   }
1032
1033   // 4th try: look for default artwork in new default artwork directory
1034   directory = getStringCopy(getDefaultMusicDir(MUS_DEFAULT_SUBDIR));
1035   if (directoryExists(directory))
1036     return directory;
1037
1038   free(directory);
1039
1040   // 5th try: look for default artwork in old default artwork directory
1041   directory = getStringCopy(options.music_directory);
1042   if (directoryExists(directory))
1043     return directory;
1044
1045   return NULL;          // cannot find specified artwork file anywhere
1046 }
1047
1048 void InitTapeDirectory(char *level_subdir)
1049 {
1050   createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
1051   createDirectory(getTapeDir(NULL), "main tape", PERMS_PRIVATE);
1052   createDirectory(getTapeDir(level_subdir), "level tape", PERMS_PRIVATE);
1053 }
1054
1055 void InitScoreDirectory(char *level_subdir)
1056 {
1057   int permissions = (program.global_scores ? PERMS_PUBLIC : PERMS_PRIVATE);
1058
1059   if (program.global_scores)
1060     createDirectory(getCommonDataDir(), "common data", permissions);
1061   else
1062     createDirectory(getMainUserGameDataDir(), "main user data", permissions);
1063
1064   createDirectory(getScoreDir(NULL), "main score", permissions);
1065   createDirectory(getScoreDir(level_subdir), "level score", permissions);
1066 }
1067
1068 static void SaveUserLevelInfo(void);
1069
1070 void InitUserLevelDirectory(char *level_subdir)
1071 {
1072   if (!directoryExists(getUserLevelDir(level_subdir)))
1073   {
1074     createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
1075     createDirectory(getUserLevelDir(NULL), "main user level", PERMS_PRIVATE);
1076     createDirectory(getUserLevelDir(level_subdir), "user level", PERMS_PRIVATE);
1077
1078     if (setup.internal.create_user_levelset)
1079       SaveUserLevelInfo();
1080   }
1081 }
1082
1083 void InitNetworkLevelDirectory(char *level_subdir)
1084 {
1085   if (!directoryExists(getNetworkLevelDir(level_subdir)))
1086   {
1087     createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
1088     createDirectory(getNetworkDir(), "network data", PERMS_PRIVATE);
1089     createDirectory(getNetworkLevelDir(NULL), "main network level", PERMS_PRIVATE);
1090     createDirectory(getNetworkLevelDir(level_subdir), "network level", PERMS_PRIVATE);
1091   }
1092 }
1093
1094 void InitLevelSetupDirectory(char *level_subdir)
1095 {
1096   createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
1097   createDirectory(getLevelSetupDir(NULL), "main level setup", PERMS_PRIVATE);
1098   createDirectory(getLevelSetupDir(level_subdir), "level setup", PERMS_PRIVATE);
1099 }
1100
1101 static void InitCacheDirectory(void)
1102 {
1103   createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
1104   createDirectory(getCacheDir(), "cache data", PERMS_PRIVATE);
1105 }
1106
1107
1108 // ----------------------------------------------------------------------------
1109 // some functions to handle lists of level and artwork directories
1110 // ----------------------------------------------------------------------------
1111
1112 TreeInfo *newTreeInfo(void)
1113 {
1114   return checked_calloc(sizeof(TreeInfo));
1115 }
1116
1117 TreeInfo *newTreeInfo_setDefaults(int type)
1118 {
1119   TreeInfo *ti = newTreeInfo();
1120
1121   setTreeInfoToDefaults(ti, type);
1122
1123   return ti;
1124 }
1125
1126 void pushTreeInfo(TreeInfo **node_first, TreeInfo *node_new)
1127 {
1128   node_new->next = *node_first;
1129   *node_first = node_new;
1130 }
1131
1132 void removeTreeInfo(TreeInfo **node_first)
1133 {
1134   TreeInfo *node_old = *node_first;
1135
1136   *node_first = node_old->next;
1137   node_old->next = NULL;
1138
1139   freeTreeInfo(node_old);
1140 }
1141
1142 int numTreeInfo(TreeInfo *node)
1143 {
1144   int num = 0;
1145
1146   while (node)
1147   {
1148     num++;
1149     node = node->next;
1150   }
1151
1152   return num;
1153 }
1154
1155 boolean validLevelSeries(TreeInfo *node)
1156 {
1157   return (node != NULL && !node->node_group && !node->parent_link);
1158 }
1159
1160 TreeInfo *getFirstValidTreeInfoEntry(TreeInfo *node)
1161 {
1162   if (node == NULL)
1163     return NULL;
1164
1165   if (node->node_group)         // enter level group (step down into tree)
1166     return getFirstValidTreeInfoEntry(node->node_group);
1167   else if (node->parent_link)   // skip start entry of level group
1168   {
1169     if (node->next)             // get first real level series entry
1170       return getFirstValidTreeInfoEntry(node->next);
1171     else                        // leave empty level group and go on
1172       return getFirstValidTreeInfoEntry(node->node_parent->next);
1173   }
1174   else                          // this seems to be a regular level series
1175     return node;
1176 }
1177
1178 TreeInfo *getTreeInfoFirstGroupEntry(TreeInfo *node)
1179 {
1180   if (node == NULL)
1181     return NULL;
1182
1183   if (node->node_parent == NULL)                // top level group
1184     return *node->node_top;
1185   else                                          // sub level group
1186     return node->node_parent->node_group;
1187 }
1188
1189 int numTreeInfoInGroup(TreeInfo *node)
1190 {
1191   return numTreeInfo(getTreeInfoFirstGroupEntry(node));
1192 }
1193
1194 int getPosFromTreeInfo(TreeInfo *node)
1195 {
1196   TreeInfo *node_cmp = getTreeInfoFirstGroupEntry(node);
1197   int pos = 0;
1198
1199   while (node_cmp)
1200   {
1201     if (node_cmp == node)
1202       return pos;
1203
1204     pos++;
1205     node_cmp = node_cmp->next;
1206   }
1207
1208   return 0;
1209 }
1210
1211 TreeInfo *getTreeInfoFromPos(TreeInfo *node, int pos)
1212 {
1213   TreeInfo *node_default = node;
1214   int pos_cmp = 0;
1215
1216   while (node)
1217   {
1218     if (pos_cmp == pos)
1219       return node;
1220
1221     pos_cmp++;
1222     node = node->next;
1223   }
1224
1225   return node_default;
1226 }
1227
1228 static TreeInfo *getTreeInfoFromIdentifierExt(TreeInfo *node, char *identifier,
1229                                               boolean include_node_groups)
1230 {
1231   if (identifier == NULL)
1232     return NULL;
1233
1234   while (node)
1235   {
1236     if (node->node_group)
1237     {
1238       if (include_node_groups && strEqual(identifier, node->identifier))
1239         return node;
1240
1241       TreeInfo *node_group = getTreeInfoFromIdentifierExt(node->node_group,
1242                                                           identifier,
1243                                                           include_node_groups);
1244       if (node_group)
1245         return node_group;
1246     }
1247     else if (!node->parent_link)
1248     {
1249       if (strEqual(identifier, node->identifier))
1250         return node;
1251     }
1252
1253     node = node->next;
1254   }
1255
1256   return NULL;
1257 }
1258
1259 TreeInfo *getTreeInfoFromIdentifier(TreeInfo *node, char *identifier)
1260 {
1261   return getTreeInfoFromIdentifierExt(node, identifier, FALSE);
1262 }
1263
1264 static TreeInfo *cloneTreeNode(TreeInfo **node_top, TreeInfo *node_parent,
1265                                TreeInfo *node, boolean skip_sets_without_levels)
1266 {
1267   TreeInfo *node_new;
1268
1269   if (node == NULL)
1270     return NULL;
1271
1272   if (!node->parent_link && !node->level_group &&
1273       skip_sets_without_levels && node->levels == 0)
1274     return cloneTreeNode(node_top, node_parent, node->next,
1275                          skip_sets_without_levels);
1276
1277   node_new = getTreeInfoCopy(node);             // copy complete node
1278
1279   node_new->node_top = node_top;                // correct top node link
1280   node_new->node_parent = node_parent;          // correct parent node link
1281
1282   if (node->level_group)
1283     node_new->node_group = cloneTreeNode(node_top, node_new, node->node_group,
1284                                          skip_sets_without_levels);
1285
1286   node_new->next = cloneTreeNode(node_top, node_parent, node->next,
1287                                  skip_sets_without_levels);
1288
1289   return node_new;
1290 }
1291
1292 static void cloneTree(TreeInfo **ti_new, TreeInfo *ti, boolean skip_empty_sets)
1293 {
1294   TreeInfo *ti_cloned = cloneTreeNode(ti_new, NULL, ti, skip_empty_sets);
1295
1296   *ti_new = ti_cloned;
1297 }
1298
1299 static boolean adjustTreeGraphicsForEMC(TreeInfo *node)
1300 {
1301   boolean settings_changed = FALSE;
1302
1303   while (node)
1304   {
1305     boolean want_ecs = (setup.prefer_aga_graphics == FALSE);
1306     boolean want_aga = (setup.prefer_aga_graphics == TRUE);
1307     boolean has_only_ecs = (!node->graphics_set && !node->graphics_set_aga);
1308     boolean has_only_aga = (!node->graphics_set && !node->graphics_set_ecs);
1309     char *graphics_set = NULL;
1310
1311     if (node->graphics_set_ecs && (want_ecs || has_only_ecs))
1312       graphics_set = node->graphics_set_ecs;
1313
1314     if (node->graphics_set_aga && (want_aga || has_only_aga))
1315       graphics_set = node->graphics_set_aga;
1316
1317     if (graphics_set && !strEqual(node->graphics_set, graphics_set))
1318     {
1319       setString(&node->graphics_set, graphics_set);
1320       settings_changed = TRUE;
1321     }
1322
1323     if (node->node_group != NULL)
1324       settings_changed |= adjustTreeGraphicsForEMC(node->node_group);
1325
1326     node = node->next;
1327   }
1328
1329   return settings_changed;
1330 }
1331
1332 static boolean adjustTreeSoundsForEMC(TreeInfo *node)
1333 {
1334   boolean settings_changed = FALSE;
1335
1336   while (node)
1337   {
1338     boolean want_default = (setup.prefer_lowpass_sounds == FALSE);
1339     boolean want_lowpass = (setup.prefer_lowpass_sounds == TRUE);
1340     boolean has_only_default = (!node->sounds_set && !node->sounds_set_lowpass);
1341     boolean has_only_lowpass = (!node->sounds_set && !node->sounds_set_default);
1342     char *sounds_set = NULL;
1343
1344     if (node->sounds_set_default && (want_default || has_only_default))
1345       sounds_set = node->sounds_set_default;
1346
1347     if (node->sounds_set_lowpass && (want_lowpass || has_only_lowpass))
1348       sounds_set = node->sounds_set_lowpass;
1349
1350     if (sounds_set && !strEqual(node->sounds_set, sounds_set))
1351     {
1352       setString(&node->sounds_set, sounds_set);
1353       settings_changed = TRUE;
1354     }
1355
1356     if (node->node_group != NULL)
1357       settings_changed |= adjustTreeSoundsForEMC(node->node_group);
1358
1359     node = node->next;
1360   }
1361
1362   return settings_changed;
1363 }
1364
1365 void dumpTreeInfo(TreeInfo *node, int depth)
1366 {
1367   char bullet_list[] = { '-', '*', 'o' };
1368   int i;
1369
1370   if (depth == 0)
1371     Debug("tree", "Dumping TreeInfo:");
1372
1373   while (node)
1374   {
1375     char bullet = bullet_list[depth % ARRAY_SIZE(bullet_list)];
1376
1377     for (i = 0; i < depth * 2; i++)
1378       DebugContinued("", " ");
1379
1380     DebugContinued("tree", "%c '%s' ['%s] [PARENT: '%s'] %s\n",
1381                    bullet, node->name, node->identifier,
1382                    (node->node_parent ? node->node_parent->identifier : "-"),
1383                    (node->node_group ? "[GROUP]" : ""));
1384
1385     /*
1386     // use for dumping artwork info tree
1387     Debug("tree", "subdir == '%s' ['%s', '%s'] [%d])",
1388           node->subdir, node->fullpath, node->basepath, node->in_user_dir);
1389     */
1390
1391     if (node->node_group != NULL)
1392       dumpTreeInfo(node->node_group, depth + 1);
1393
1394     node = node->next;
1395   }
1396 }
1397
1398 void sortTreeInfoBySortFunction(TreeInfo **node_first,
1399                                 int (*compare_function)(const void *,
1400                                                         const void *))
1401 {
1402   int num_nodes = numTreeInfo(*node_first);
1403   TreeInfo **sort_array;
1404   TreeInfo *node = *node_first;
1405   int i = 0;
1406
1407   if (num_nodes == 0)
1408     return;
1409
1410   // allocate array for sorting structure pointers
1411   sort_array = checked_calloc(num_nodes * sizeof(TreeInfo *));
1412
1413   // writing structure pointers to sorting array
1414   while (i < num_nodes && node)         // double boundary check...
1415   {
1416     sort_array[i] = node;
1417
1418     i++;
1419     node = node->next;
1420   }
1421
1422   // sorting the structure pointers in the sorting array
1423   qsort(sort_array, num_nodes, sizeof(TreeInfo *),
1424         compare_function);
1425
1426   // update the linkage of list elements with the sorted node array
1427   for (i = 0; i < num_nodes - 1; i++)
1428     sort_array[i]->next = sort_array[i + 1];
1429   sort_array[num_nodes - 1]->next = NULL;
1430
1431   // update the linkage of the main list anchor pointer
1432   *node_first = sort_array[0];
1433
1434   free(sort_array);
1435
1436   // now recursively sort the level group structures
1437   node = *node_first;
1438   while (node)
1439   {
1440     if (node->node_group != NULL)
1441       sortTreeInfoBySortFunction(&node->node_group, compare_function);
1442
1443     node = node->next;
1444   }
1445 }
1446
1447 void sortTreeInfo(TreeInfo **node_first)
1448 {
1449   sortTreeInfoBySortFunction(node_first, compareTreeInfoEntries);
1450 }
1451
1452
1453 // ============================================================================
1454 // some stuff from "files.c"
1455 // ============================================================================
1456
1457 #if defined(PLATFORM_WIN32)
1458 #ifndef S_IRGRP
1459 #define S_IRGRP S_IRUSR
1460 #endif
1461 #ifndef S_IROTH
1462 #define S_IROTH S_IRUSR
1463 #endif
1464 #ifndef S_IWGRP
1465 #define S_IWGRP S_IWUSR
1466 #endif
1467 #ifndef S_IWOTH
1468 #define S_IWOTH S_IWUSR
1469 #endif
1470 #ifndef S_IXGRP
1471 #define S_IXGRP S_IXUSR
1472 #endif
1473 #ifndef S_IXOTH
1474 #define S_IXOTH S_IXUSR
1475 #endif
1476 #ifndef S_IRWXG
1477 #define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
1478 #endif
1479 #ifndef S_ISGID
1480 #define S_ISGID 0
1481 #endif
1482 #endif  // PLATFORM_WIN32
1483
1484 // file permissions for newly written files
1485 #define MODE_R_ALL              (S_IRUSR | S_IRGRP | S_IROTH)
1486 #define MODE_W_ALL              (S_IWUSR | S_IWGRP | S_IWOTH)
1487 #define MODE_X_ALL              (S_IXUSR | S_IXGRP | S_IXOTH)
1488
1489 #define MODE_W_PRIVATE          (S_IWUSR)
1490 #define MODE_W_PUBLIC_FILE      (S_IWUSR | S_IWGRP)
1491 #define MODE_W_PUBLIC_DIR       (S_IWUSR | S_IWGRP | S_ISGID)
1492
1493 #define DIR_PERMS_PRIVATE       (MODE_R_ALL | MODE_X_ALL | MODE_W_PRIVATE)
1494 #define DIR_PERMS_PUBLIC        (MODE_R_ALL | MODE_X_ALL | MODE_W_PUBLIC_DIR)
1495 #define DIR_PERMS_PUBLIC_ALL    (MODE_R_ALL | MODE_X_ALL | MODE_W_ALL)
1496
1497 #define FILE_PERMS_PRIVATE      (MODE_R_ALL | MODE_W_PRIVATE)
1498 #define FILE_PERMS_PUBLIC       (MODE_R_ALL | MODE_W_PUBLIC_FILE)
1499 #define FILE_PERMS_PUBLIC_ALL   (MODE_R_ALL | MODE_W_ALL)
1500
1501
1502 char *getHomeDir(void)
1503 {
1504   static char *dir = NULL;
1505
1506 #if defined(PLATFORM_WIN32)
1507   if (dir == NULL)
1508   {
1509     dir = checked_malloc(MAX_PATH + 1);
1510
1511     if (!SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, dir)))
1512       strcpy(dir, ".");
1513   }
1514 #elif defined(PLATFORM_UNIX)
1515   if (dir == NULL)
1516   {
1517     if ((dir = getenv("HOME")) == NULL)
1518     {
1519       dir = getUnixHomeDir();
1520
1521       if (dir != NULL)
1522         dir = getStringCopy(dir);
1523       else
1524         dir = ".";
1525     }
1526   }
1527 #else
1528   dir = ".";
1529 #endif
1530
1531   return dir;
1532 }
1533
1534 char *getCommonDataDir(void)
1535 {
1536   static char *common_data_dir = NULL;
1537
1538 #if defined(PLATFORM_WIN32)
1539   if (common_data_dir == NULL)
1540   {
1541     char *dir = checked_malloc(MAX_PATH + 1);
1542
1543     if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, dir))
1544         && !strEqual(dir, ""))          // empty for Windows 95/98
1545       common_data_dir = getPath2(dir, program.userdata_subdir);
1546     else
1547       common_data_dir = options.rw_base_directory;
1548   }
1549 #else
1550   if (common_data_dir == NULL)
1551     common_data_dir = options.rw_base_directory;
1552 #endif
1553
1554   return common_data_dir;
1555 }
1556
1557 char *getPersonalDataDir(void)
1558 {
1559   static char *personal_data_dir = NULL;
1560
1561 #if defined(PLATFORM_MACOSX)
1562   if (personal_data_dir == NULL)
1563     personal_data_dir = getPath2(getHomeDir(), "Documents");
1564 #else
1565   if (personal_data_dir == NULL)
1566     personal_data_dir = getHomeDir();
1567 #endif
1568
1569   return personal_data_dir;
1570 }
1571
1572 char *getMainUserGameDataDir(void)
1573 {
1574   static char *main_user_data_dir = NULL;
1575
1576 #if defined(PLATFORM_ANDROID)
1577   if (main_user_data_dir == NULL)
1578     main_user_data_dir = (char *)(SDL_AndroidGetExternalStorageState() &
1579                                   SDL_ANDROID_EXTERNAL_STORAGE_WRITE ?
1580                                   SDL_AndroidGetExternalStoragePath() :
1581                                   SDL_AndroidGetInternalStoragePath());
1582 #else
1583   if (main_user_data_dir == NULL)
1584     main_user_data_dir = getPath2(getPersonalDataDir(),
1585                                   program.userdata_subdir);
1586 #endif
1587
1588   return main_user_data_dir;
1589 }
1590
1591 char *getUserGameDataDir(void)
1592 {
1593   if (user.nr == 0)
1594     return getMainUserGameDataDir();
1595   else
1596     return getUserDir(user.nr);
1597 }
1598
1599 char *getSetupDir(void)
1600 {
1601   return getUserGameDataDir();
1602 }
1603
1604 static mode_t posix_umask(mode_t mask)
1605 {
1606 #if defined(PLATFORM_UNIX)
1607   return umask(mask);
1608 #else
1609   return 0;
1610 #endif
1611 }
1612
1613 static int posix_mkdir(const char *pathname, mode_t mode)
1614 {
1615 #if defined(PLATFORM_WIN32)
1616   return mkdir(pathname);
1617 #else
1618   return mkdir(pathname, mode);
1619 #endif
1620 }
1621
1622 static boolean posix_process_running_setgid(void)
1623 {
1624 #if defined(PLATFORM_UNIX)
1625   return (getgid() != getegid());
1626 #else
1627   return FALSE;
1628 #endif
1629 }
1630
1631 void createDirectory(char *dir, char *text, int permission_class)
1632 {
1633   if (directoryExists(dir))
1634     return;
1635
1636   // leave "other" permissions in umask untouched, but ensure group parts
1637   // of USERDATA_DIR_MODE are not masked
1638   mode_t dir_mode = (permission_class == PERMS_PRIVATE ?
1639                      DIR_PERMS_PRIVATE : DIR_PERMS_PUBLIC);
1640   mode_t last_umask = posix_umask(0);
1641   mode_t group_umask = ~(dir_mode & S_IRWXG);
1642   int running_setgid = posix_process_running_setgid();
1643
1644   if (permission_class == PERMS_PUBLIC)
1645   {
1646     // if we're setgid, protect files against "other"
1647     // else keep umask(0) to make the dir world-writable
1648
1649     if (running_setgid)
1650       posix_umask(last_umask & group_umask);
1651     else
1652       dir_mode = DIR_PERMS_PUBLIC_ALL;
1653   }
1654
1655   if (posix_mkdir(dir, dir_mode) != 0)
1656     Warn("cannot create %s directory '%s': %s", text, dir, strerror(errno));
1657
1658   if (permission_class == PERMS_PUBLIC && !running_setgid)
1659     chmod(dir, dir_mode);
1660
1661   posix_umask(last_umask);              // restore previous umask
1662 }
1663
1664 void InitMainUserDataDirectory(void)
1665 {
1666   createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
1667 }
1668
1669 void InitUserDataDirectory(void)
1670 {
1671   createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
1672
1673   if (user.nr != 0)
1674   {
1675     createDirectory(getUserDir(-1), "users", PERMS_PRIVATE);
1676     createDirectory(getUserDir(user.nr), "user data", PERMS_PRIVATE);
1677   }
1678 }
1679
1680 void SetFilePermissions(char *filename, int permission_class)
1681 {
1682   int running_setgid = posix_process_running_setgid();
1683   int perms = (permission_class == PERMS_PRIVATE ?
1684                FILE_PERMS_PRIVATE : FILE_PERMS_PUBLIC);
1685
1686   if (permission_class == PERMS_PUBLIC && !running_setgid)
1687     perms = FILE_PERMS_PUBLIC_ALL;
1688
1689   chmod(filename, perms);
1690 }
1691
1692 char *getCookie(char *file_type)
1693 {
1694   static char cookie[MAX_COOKIE_LEN + 1];
1695
1696   if (strlen(program.cookie_prefix) + 1 +
1697       strlen(file_type) + strlen("_FILE_VERSION_x.x") > MAX_COOKIE_LEN)
1698     return "[COOKIE ERROR]";    // should never happen
1699
1700   sprintf(cookie, "%s_%s_FILE_VERSION_%d.%d",
1701           program.cookie_prefix, file_type,
1702           program.version_super, program.version_major);
1703
1704   return cookie;
1705 }
1706
1707 void fprintFileHeader(FILE *file, char *basename)
1708 {
1709   char *prefix = "# ";
1710   char *sep1 = "=";
1711
1712   fprintf_line_with_prefix(file, prefix, sep1, 77);
1713   fprintf(file, "%s%s\n", prefix, basename);
1714   fprintf_line_with_prefix(file, prefix, sep1, 77);
1715   fprintf(file, "\n");
1716 }
1717
1718 int getFileVersionFromCookieString(const char *cookie)
1719 {
1720   const char *ptr_cookie1, *ptr_cookie2;
1721   const char *pattern1 = "_FILE_VERSION_";
1722   const char *pattern2 = "?.?";
1723   const int len_cookie = strlen(cookie);
1724   const int len_pattern1 = strlen(pattern1);
1725   const int len_pattern2 = strlen(pattern2);
1726   const int len_pattern = len_pattern1 + len_pattern2;
1727   int version_super, version_major;
1728
1729   if (len_cookie <= len_pattern)
1730     return -1;
1731
1732   ptr_cookie1 = &cookie[len_cookie - len_pattern];
1733   ptr_cookie2 = &cookie[len_cookie - len_pattern2];
1734
1735   if (strncmp(ptr_cookie1, pattern1, len_pattern1) != 0)
1736     return -1;
1737
1738   if (ptr_cookie2[0] < '0' || ptr_cookie2[0] > '9' ||
1739       ptr_cookie2[1] != '.' ||
1740       ptr_cookie2[2] < '0' || ptr_cookie2[2] > '9')
1741     return -1;
1742
1743   version_super = ptr_cookie2[0] - '0';
1744   version_major = ptr_cookie2[2] - '0';
1745
1746   return VERSION_IDENT(version_super, version_major, 0, 0);
1747 }
1748
1749 boolean checkCookieString(const char *cookie, const char *template)
1750 {
1751   const char *pattern = "_FILE_VERSION_?.?";
1752   const int len_cookie = strlen(cookie);
1753   const int len_template = strlen(template);
1754   const int len_pattern = strlen(pattern);
1755
1756   if (len_cookie != len_template)
1757     return FALSE;
1758
1759   if (strncmp(cookie, template, len_cookie - len_pattern) != 0)
1760     return FALSE;
1761
1762   return TRUE;
1763 }
1764
1765
1766 // ----------------------------------------------------------------------------
1767 // setup file list and hash handling functions
1768 // ----------------------------------------------------------------------------
1769
1770 char *getFormattedSetupEntry(char *token, char *value)
1771 {
1772   int i;
1773   static char entry[MAX_LINE_LEN];
1774
1775   // if value is an empty string, just return token without value
1776   if (*value == '\0')
1777     return token;
1778
1779   // start with the token and some spaces to format output line
1780   sprintf(entry, "%s:", token);
1781   for (i = strlen(entry); i < token_value_position; i++)
1782     strcat(entry, " ");
1783
1784   // continue with the token's value
1785   strcat(entry, value);
1786
1787   return entry;
1788 }
1789
1790 SetupFileList *newSetupFileList(char *token, char *value)
1791 {
1792   SetupFileList *new = checked_malloc(sizeof(SetupFileList));
1793
1794   new->token = getStringCopy(token);
1795   new->value = getStringCopy(value);
1796
1797   new->next = NULL;
1798
1799   return new;
1800 }
1801
1802 void freeSetupFileList(SetupFileList *list)
1803 {
1804   if (list == NULL)
1805     return;
1806
1807   checked_free(list->token);
1808   checked_free(list->value);
1809
1810   if (list->next)
1811     freeSetupFileList(list->next);
1812
1813   free(list);
1814 }
1815
1816 char *getListEntry(SetupFileList *list, char *token)
1817 {
1818   if (list == NULL)
1819     return NULL;
1820
1821   if (strEqual(list->token, token))
1822     return list->value;
1823   else
1824     return getListEntry(list->next, token);
1825 }
1826
1827 SetupFileList *setListEntry(SetupFileList *list, char *token, char *value)
1828 {
1829   if (list == NULL)
1830     return NULL;
1831
1832   if (strEqual(list->token, token))
1833   {
1834     checked_free(list->value);
1835
1836     list->value = getStringCopy(value);
1837
1838     return list;
1839   }
1840   else if (list->next == NULL)
1841     return (list->next = newSetupFileList(token, value));
1842   else
1843     return setListEntry(list->next, token, value);
1844 }
1845
1846 SetupFileList *addListEntry(SetupFileList *list, char *token, char *value)
1847 {
1848   if (list == NULL)
1849     return NULL;
1850
1851   if (list->next == NULL)
1852     return (list->next = newSetupFileList(token, value));
1853   else
1854     return addListEntry(list->next, token, value);
1855 }
1856
1857 #if ENABLE_UNUSED_CODE
1858 #ifdef DEBUG
1859 static void printSetupFileList(SetupFileList *list)
1860 {
1861   if (!list)
1862     return;
1863
1864   Debug("setup:printSetupFileList", "token: '%s'", list->token);
1865   Debug("setup:printSetupFileList", "value: '%s'", list->value);
1866
1867   printSetupFileList(list->next);
1868 }
1869 #endif
1870 #endif
1871
1872 #ifdef DEBUG
1873 DEFINE_HASHTABLE_INSERT(insert_hash_entry, char, char);
1874 DEFINE_HASHTABLE_SEARCH(search_hash_entry, char, char);
1875 DEFINE_HASHTABLE_CHANGE(change_hash_entry, char, char);
1876 DEFINE_HASHTABLE_REMOVE(remove_hash_entry, char, char);
1877 #else
1878 #define insert_hash_entry hashtable_insert
1879 #define search_hash_entry hashtable_search
1880 #define change_hash_entry hashtable_change
1881 #define remove_hash_entry hashtable_remove
1882 #endif
1883
1884 unsigned int get_hash_from_key(void *key)
1885 {
1886   /*
1887     djb2
1888
1889     This algorithm (k=33) was first reported by Dan Bernstein many years ago in
1890     'comp.lang.c'. Another version of this algorithm (now favored by Bernstein)
1891     uses XOR: hash(i) = hash(i - 1) * 33 ^ str[i]; the magic of number 33 (why
1892     it works better than many other constants, prime or not) has never been
1893     adequately explained.
1894
1895     If you just want to have a good hash function, and cannot wait, djb2
1896     is one of the best string hash functions i know. It has excellent
1897     distribution and speed on many different sets of keys and table sizes.
1898     You are not likely to do better with one of the "well known" functions
1899     such as PJW, K&R, etc.
1900
1901     Ozan (oz) Yigit [http://www.cs.yorku.ca/~oz/hash.html]
1902   */
1903
1904   char *str = (char *)key;
1905   unsigned int hash = 5381;
1906   int c;
1907
1908   while ((c = *str++))
1909     hash = ((hash << 5) + hash) + c;    // hash * 33 + c
1910
1911   return hash;
1912 }
1913
1914 static int keys_are_equal(void *key1, void *key2)
1915 {
1916   return (strEqual((char *)key1, (char *)key2));
1917 }
1918
1919 SetupFileHash *newSetupFileHash(void)
1920 {
1921   SetupFileHash *new_hash =
1922     create_hashtable(16, 0.75, get_hash_from_key, keys_are_equal);
1923
1924   if (new_hash == NULL)
1925     Fail("create_hashtable() failed -- out of memory");
1926
1927   return new_hash;
1928 }
1929
1930 void freeSetupFileHash(SetupFileHash *hash)
1931 {
1932   if (hash == NULL)
1933     return;
1934
1935   hashtable_destroy(hash, 1);   // 1 == also free values stored in hash
1936 }
1937
1938 char *getHashEntry(SetupFileHash *hash, char *token)
1939 {
1940   if (hash == NULL)
1941     return NULL;
1942
1943   return search_hash_entry(hash, token);
1944 }
1945
1946 void setHashEntry(SetupFileHash *hash, char *token, char *value)
1947 {
1948   char *value_copy;
1949
1950   if (hash == NULL)
1951     return;
1952
1953   value_copy = getStringCopy(value);
1954
1955   // change value; if it does not exist, insert it as new
1956   if (!change_hash_entry(hash, token, value_copy))
1957     if (!insert_hash_entry(hash, getStringCopy(token), value_copy))
1958       Fail("cannot insert into hash -- aborting");
1959 }
1960
1961 char *removeHashEntry(SetupFileHash *hash, char *token)
1962 {
1963   if (hash == NULL)
1964     return NULL;
1965
1966   return remove_hash_entry(hash, token);
1967 }
1968
1969 #if ENABLE_UNUSED_CODE
1970 #if DEBUG
1971 static void printSetupFileHash(SetupFileHash *hash)
1972 {
1973   BEGIN_HASH_ITERATION(hash, itr)
1974   {
1975     Debug("setup:printSetupFileHash", "token: '%s'", HASH_ITERATION_TOKEN(itr));
1976     Debug("setup:printSetupFileHash", "value: '%s'", HASH_ITERATION_VALUE(itr));
1977   }
1978   END_HASH_ITERATION(hash, itr)
1979 }
1980 #endif
1981 #endif
1982
1983 #define ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE            1
1984 #define CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING            0
1985 #define CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH             0
1986
1987 static boolean token_value_separator_found = FALSE;
1988 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
1989 static boolean token_value_separator_warning = FALSE;
1990 #endif
1991 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
1992 static boolean token_already_exists_warning = FALSE;
1993 #endif
1994
1995 static boolean getTokenValueFromSetupLineExt(char *line,
1996                                              char **token_ptr, char **value_ptr,
1997                                              char *filename, char *line_raw,
1998                                              int line_nr,
1999                                              boolean separator_required)
2000 {
2001   static char line_copy[MAX_LINE_LEN + 1], line_raw_copy[MAX_LINE_LEN + 1];
2002   char *token, *value, *line_ptr;
2003
2004   // when externally invoked via ReadTokenValueFromLine(), copy line buffers
2005   if (line_raw == NULL)
2006   {
2007     strncpy(line_copy, line, MAX_LINE_LEN);
2008     line_copy[MAX_LINE_LEN] = '\0';
2009     line = line_copy;
2010
2011     strcpy(line_raw_copy, line_copy);
2012     line_raw = line_raw_copy;
2013   }
2014
2015   // cut trailing comment from input line
2016   for (line_ptr = line; *line_ptr; line_ptr++)
2017   {
2018     if (*line_ptr == '#')
2019     {
2020       *line_ptr = '\0';
2021       break;
2022     }
2023   }
2024
2025   // cut trailing whitespaces from input line
2026   for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
2027     if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
2028       *line_ptr = '\0';
2029
2030   // ignore empty lines
2031   if (*line == '\0')
2032     return FALSE;
2033
2034   // cut leading whitespaces from token
2035   for (token = line; *token; token++)
2036     if (*token != ' ' && *token != '\t')
2037       break;
2038
2039   // start with empty value as reliable default
2040   value = "";
2041
2042   token_value_separator_found = FALSE;
2043
2044   // find end of token to determine start of value
2045   for (line_ptr = token; *line_ptr; line_ptr++)
2046   {
2047     // first look for an explicit token/value separator, like ':' or '='
2048     if (*line_ptr == ':' || *line_ptr == '=')
2049     {
2050       *line_ptr = '\0';                 // terminate token string
2051       value = line_ptr + 1;             // set beginning of value
2052
2053       token_value_separator_found = TRUE;
2054
2055       break;
2056     }
2057   }
2058
2059 #if ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE
2060   // fallback: if no token/value separator found, also allow whitespaces
2061   if (!token_value_separator_found && !separator_required)
2062   {
2063     for (line_ptr = token; *line_ptr; line_ptr++)
2064     {
2065       if (*line_ptr == ' ' || *line_ptr == '\t')
2066       {
2067         *line_ptr = '\0';               // terminate token string
2068         value = line_ptr + 1;           // set beginning of value
2069
2070         token_value_separator_found = TRUE;
2071
2072         break;
2073       }
2074     }
2075
2076 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2077     if (token_value_separator_found)
2078     {
2079       if (!token_value_separator_warning)
2080       {
2081         Debug("setup", "---");
2082
2083         if (filename != NULL)
2084         {
2085           Debug("setup", "missing token/value separator(s) in config file:");
2086           Debug("setup", "- config file: '%s'", filename);
2087         }
2088         else
2089         {
2090           Debug("setup", "missing token/value separator(s):");
2091         }
2092
2093         token_value_separator_warning = TRUE;
2094       }
2095
2096       if (filename != NULL)
2097         Debug("setup", "- line %d: '%s'", line_nr, line_raw);
2098       else
2099         Debug("setup", "- line: '%s'", line_raw);
2100     }
2101 #endif
2102   }
2103 #endif
2104
2105   // cut trailing whitespaces from token
2106   for (line_ptr = &token[strlen(token)]; line_ptr >= token; line_ptr--)
2107     if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
2108       *line_ptr = '\0';
2109
2110   // cut leading whitespaces from value
2111   for (; *value; value++)
2112     if (*value != ' ' && *value != '\t')
2113       break;
2114
2115   *token_ptr = token;
2116   *value_ptr = value;
2117
2118   return TRUE;
2119 }
2120
2121 boolean getTokenValueFromSetupLine(char *line, char **token, char **value)
2122 {
2123   // while the internal (old) interface does not require a token/value
2124   // separator (for downwards compatibility with existing files which
2125   // don't use them), it is mandatory for the external (new) interface
2126
2127   return getTokenValueFromSetupLineExt(line, token, value, NULL, NULL, 0, TRUE);
2128 }
2129
2130 static boolean loadSetupFileData(void *setup_file_data, char *filename,
2131                                  boolean top_recursion_level, boolean is_hash)
2132 {
2133   static SetupFileHash *include_filename_hash = NULL;
2134   char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
2135   char *token, *value, *line_ptr;
2136   void *insert_ptr = NULL;
2137   boolean read_continued_line = FALSE;
2138   File *file;
2139   int line_nr = 0, token_count = 0, include_count = 0;
2140
2141 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2142   token_value_separator_warning = FALSE;
2143 #endif
2144
2145 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2146   token_already_exists_warning = FALSE;
2147 #endif
2148
2149   if (!(file = openFile(filename, MODE_READ)))
2150   {
2151 #if DEBUG_NO_CONFIG_FILE
2152     Debug("setup", "cannot open configuration file '%s'", filename);
2153 #endif
2154
2155     return FALSE;
2156   }
2157
2158   // use "insert pointer" to store list end for constant insertion complexity
2159   if (!is_hash)
2160     insert_ptr = setup_file_data;
2161
2162   // on top invocation, create hash to mark included files (to prevent loops)
2163   if (top_recursion_level)
2164     include_filename_hash = newSetupFileHash();
2165
2166   // mark this file as already included (to prevent including it again)
2167   setHashEntry(include_filename_hash, getBaseNamePtr(filename), "true");
2168
2169   while (!checkEndOfFile(file))
2170   {
2171     // read next line of input file
2172     if (!getStringFromFile(file, line, MAX_LINE_LEN))
2173       break;
2174
2175     // check if line was completely read and is terminated by line break
2176     if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
2177       line_nr++;
2178
2179     // cut trailing line break (this can be newline and/or carriage return)
2180     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
2181       if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
2182         *line_ptr = '\0';
2183
2184     // copy raw input line for later use (mainly debugging output)
2185     strcpy(line_raw, line);
2186
2187     if (read_continued_line)
2188     {
2189       // append new line to existing line, if there is enough space
2190       if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
2191         strcat(previous_line, line_ptr);
2192
2193       strcpy(line, previous_line);      // copy storage buffer to line
2194
2195       read_continued_line = FALSE;
2196     }
2197
2198     // if the last character is '\', continue at next line
2199     if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
2200     {
2201       line[strlen(line) - 1] = '\0';    // cut off trailing backslash
2202       strcpy(previous_line, line);      // copy line to storage buffer
2203
2204       read_continued_line = TRUE;
2205
2206       continue;
2207     }
2208
2209     if (!getTokenValueFromSetupLineExt(line, &token, &value, filename,
2210                                        line_raw, line_nr, FALSE))
2211       continue;
2212
2213     if (*token)
2214     {
2215       if (strEqual(token, "include"))
2216       {
2217         if (getHashEntry(include_filename_hash, value) == NULL)
2218         {
2219           char *basepath = getBasePath(filename);
2220           char *basename = getBaseName(value);
2221           char *filename_include = getPath2(basepath, basename);
2222
2223           loadSetupFileData(setup_file_data, filename_include, FALSE, is_hash);
2224
2225           free(basepath);
2226           free(basename);
2227           free(filename_include);
2228
2229           include_count++;
2230         }
2231         else
2232         {
2233           Warn("ignoring already processed file '%s'", value);
2234         }
2235       }
2236       else
2237       {
2238         if (is_hash)
2239         {
2240 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2241           char *old_value =
2242             getHashEntry((SetupFileHash *)setup_file_data, token);
2243
2244           if (old_value != NULL)
2245           {
2246             if (!token_already_exists_warning)
2247             {
2248               Debug("setup", "---");
2249               Debug("setup", "duplicate token(s) found in config file:");
2250               Debug("setup", "- config file: '%s'", filename);
2251
2252               token_already_exists_warning = TRUE;
2253             }
2254
2255             Debug("setup", "- token: '%s' (in line %d)", token, line_nr);
2256             Debug("setup", "  old value: '%s'", old_value);
2257             Debug("setup", "  new value: '%s'", value);
2258           }
2259 #endif
2260
2261           setHashEntry((SetupFileHash *)setup_file_data, token, value);
2262         }
2263         else
2264         {
2265           insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value);
2266         }
2267
2268         token_count++;
2269       }
2270     }
2271   }
2272
2273   closeFile(file);
2274
2275 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2276   if (token_value_separator_warning)
2277     Debug("setup", "---");
2278 #endif
2279
2280 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2281   if (token_already_exists_warning)
2282     Debug("setup", "---");
2283 #endif
2284
2285   if (token_count == 0 && include_count == 0)
2286     Warn("configuration file '%s' is empty", filename);
2287
2288   if (top_recursion_level)
2289     freeSetupFileHash(include_filename_hash);
2290
2291   return TRUE;
2292 }
2293
2294 static int compareSetupFileData(const void *object1, const void *object2)
2295 {
2296   const struct ConfigInfo *entry1 = (struct ConfigInfo *)object1;
2297   const struct ConfigInfo *entry2 = (struct ConfigInfo *)object2;
2298
2299   return strcmp(entry1->token, entry2->token);
2300 }
2301
2302 static void saveSetupFileHash(SetupFileHash *hash, char *filename)
2303 {
2304   int item_count = hashtable_count(hash);
2305   int item_size = sizeof(struct ConfigInfo);
2306   struct ConfigInfo *sort_array = checked_malloc(item_count * item_size);
2307   FILE *file;
2308   int i = 0;
2309
2310   // copy string pointers from hash to array
2311   BEGIN_HASH_ITERATION(hash, itr)
2312   {
2313     sort_array[i].token = HASH_ITERATION_TOKEN(itr);
2314     sort_array[i].value = HASH_ITERATION_VALUE(itr);
2315
2316     i++;
2317
2318     if (i > item_count)         // should never happen
2319       break;
2320   }
2321   END_HASH_ITERATION(hash, itr)
2322
2323   // sort string pointers from hash in array
2324   qsort(sort_array, item_count, item_size, compareSetupFileData);
2325
2326   if (!(file = fopen(filename, MODE_WRITE)))
2327   {
2328     Warn("cannot write configuration file '%s'", filename);
2329
2330     return;
2331   }
2332
2333   for (i = 0; i < item_count; i++)
2334     fprintf(file, "%s\n", getFormattedSetupEntry(sort_array[i].token,
2335                                                  sort_array[i].value));
2336   fclose(file);
2337
2338   checked_free(sort_array);
2339 }
2340
2341 SetupFileList *loadSetupFileList(char *filename)
2342 {
2343   SetupFileList *setup_file_list = newSetupFileList("", "");
2344   SetupFileList *first_valid_list_entry;
2345
2346   if (!loadSetupFileData(setup_file_list, filename, TRUE, FALSE))
2347   {
2348     freeSetupFileList(setup_file_list);
2349
2350     return NULL;
2351   }
2352
2353   first_valid_list_entry = setup_file_list->next;
2354
2355   // free empty list header
2356   setup_file_list->next = NULL;
2357   freeSetupFileList(setup_file_list);
2358
2359   return first_valid_list_entry;
2360 }
2361
2362 SetupFileHash *loadSetupFileHash(char *filename)
2363 {
2364   SetupFileHash *setup_file_hash = newSetupFileHash();
2365
2366   if (!loadSetupFileData(setup_file_hash, filename, TRUE, TRUE))
2367   {
2368     freeSetupFileHash(setup_file_hash);
2369
2370     return NULL;
2371   }
2372
2373   return setup_file_hash;
2374 }
2375
2376
2377 // ============================================================================
2378 // setup file stuff
2379 // ============================================================================
2380
2381 #define TOKEN_STR_LAST_LEVEL_SERIES             "last_level_series"
2382 #define TOKEN_STR_LAST_PLAYED_LEVEL             "last_played_level"
2383 #define TOKEN_STR_HANDICAP_LEVEL                "handicap_level"
2384 #define TOKEN_STR_LAST_USER                     "last_user"
2385
2386 // level directory info
2387 #define LEVELINFO_TOKEN_IDENTIFIER              0
2388 #define LEVELINFO_TOKEN_NAME                    1
2389 #define LEVELINFO_TOKEN_NAME_SORTING            2
2390 #define LEVELINFO_TOKEN_AUTHOR                  3
2391 #define LEVELINFO_TOKEN_YEAR                    4
2392 #define LEVELINFO_TOKEN_PROGRAM_TITLE           5
2393 #define LEVELINFO_TOKEN_PROGRAM_COPYRIGHT       6
2394 #define LEVELINFO_TOKEN_PROGRAM_COMPANY         7
2395 #define LEVELINFO_TOKEN_IMPORTED_FROM           8
2396 #define LEVELINFO_TOKEN_IMPORTED_BY             9
2397 #define LEVELINFO_TOKEN_TESTED_BY               10
2398 #define LEVELINFO_TOKEN_LEVELS                  11
2399 #define LEVELINFO_TOKEN_FIRST_LEVEL             12
2400 #define LEVELINFO_TOKEN_SORT_PRIORITY           13
2401 #define LEVELINFO_TOKEN_LATEST_ENGINE           14
2402 #define LEVELINFO_TOKEN_LEVEL_GROUP             15
2403 #define LEVELINFO_TOKEN_READONLY                16
2404 #define LEVELINFO_TOKEN_GRAPHICS_SET_ECS        17
2405 #define LEVELINFO_TOKEN_GRAPHICS_SET_AGA        18
2406 #define LEVELINFO_TOKEN_GRAPHICS_SET            19
2407 #define LEVELINFO_TOKEN_SOUNDS_SET_DEFAULT      20
2408 #define LEVELINFO_TOKEN_SOUNDS_SET_LOWPASS      21
2409 #define LEVELINFO_TOKEN_SOUNDS_SET              22
2410 #define LEVELINFO_TOKEN_MUSIC_SET               23
2411 #define LEVELINFO_TOKEN_FILENAME                24
2412 #define LEVELINFO_TOKEN_FILETYPE                25
2413 #define LEVELINFO_TOKEN_SPECIAL_FLAGS           26
2414 #define LEVELINFO_TOKEN_HANDICAP                27
2415 #define LEVELINFO_TOKEN_SKIP_LEVELS             28
2416 #define LEVELINFO_TOKEN_USE_EMC_TILES           29
2417
2418 #define NUM_LEVELINFO_TOKENS                    30
2419
2420 static LevelDirTree ldi;
2421
2422 static struct TokenInfo levelinfo_tokens[] =
2423 {
2424   // level directory info
2425   { TYPE_STRING,        &ldi.identifier,        "identifier"            },
2426   { TYPE_STRING,        &ldi.name,              "name"                  },
2427   { TYPE_STRING,        &ldi.name_sorting,      "name_sorting"          },
2428   { TYPE_STRING,        &ldi.author,            "author"                },
2429   { TYPE_STRING,        &ldi.year,              "year"                  },
2430   { TYPE_STRING,        &ldi.program_title,     "program_title"         },
2431   { TYPE_STRING,        &ldi.program_copyright, "program_copyright"     },
2432   { TYPE_STRING,        &ldi.program_company,   "program_company"       },
2433   { TYPE_STRING,        &ldi.imported_from,     "imported_from"         },
2434   { TYPE_STRING,        &ldi.imported_by,       "imported_by"           },
2435   { TYPE_STRING,        &ldi.tested_by,         "tested_by"             },
2436   { TYPE_INTEGER,       &ldi.levels,            "levels"                },
2437   { TYPE_INTEGER,       &ldi.first_level,       "first_level"           },
2438   { TYPE_INTEGER,       &ldi.sort_priority,     "sort_priority"         },
2439   { TYPE_BOOLEAN,       &ldi.latest_engine,     "latest_engine"         },
2440   { TYPE_BOOLEAN,       &ldi.level_group,       "level_group"           },
2441   { TYPE_BOOLEAN,       &ldi.readonly,          "readonly"              },
2442   { TYPE_STRING,        &ldi.graphics_set_ecs,  "graphics_set.ecs"      },
2443   { TYPE_STRING,        &ldi.graphics_set_aga,  "graphics_set.aga"      },
2444   { TYPE_STRING,        &ldi.graphics_set,      "graphics_set"          },
2445   { TYPE_STRING,        &ldi.sounds_set_default,"sounds_set.default"    },
2446   { TYPE_STRING,        &ldi.sounds_set_lowpass,"sounds_set.lowpass"    },
2447   { TYPE_STRING,        &ldi.sounds_set,        "sounds_set"            },
2448   { TYPE_STRING,        &ldi.music_set,         "music_set"             },
2449   { TYPE_STRING,        &ldi.level_filename,    "filename"              },
2450   { TYPE_STRING,        &ldi.level_filetype,    "filetype"              },
2451   { TYPE_STRING,        &ldi.special_flags,     "special_flags"         },
2452   { TYPE_BOOLEAN,       &ldi.handicap,          "handicap"              },
2453   { TYPE_BOOLEAN,       &ldi.skip_levels,       "skip_levels"           },
2454   { TYPE_BOOLEAN,       &ldi.use_emc_tiles,     "use_emc_tiles"         }
2455 };
2456
2457 static struct TokenInfo artworkinfo_tokens[] =
2458 {
2459   // artwork directory info
2460   { TYPE_STRING,        &ldi.identifier,        "identifier"            },
2461   { TYPE_STRING,        &ldi.subdir,            "subdir"                },
2462   { TYPE_STRING,        &ldi.name,              "name"                  },
2463   { TYPE_STRING,        &ldi.name_sorting,      "name_sorting"          },
2464   { TYPE_STRING,        &ldi.author,            "author"                },
2465   { TYPE_STRING,        &ldi.program_title,     "program_title"         },
2466   { TYPE_STRING,        &ldi.program_copyright, "program_copyright"     },
2467   { TYPE_STRING,        &ldi.program_company,   "program_company"       },
2468   { TYPE_INTEGER,       &ldi.sort_priority,     "sort_priority"         },
2469   { TYPE_STRING,        &ldi.basepath,          "basepath"              },
2470   { TYPE_STRING,        &ldi.fullpath,          "fullpath"              },
2471   { TYPE_BOOLEAN,       &ldi.in_user_dir,       "in_user_dir"           },
2472   { TYPE_STRING,        &ldi.class_desc,        "class_desc"            },
2473
2474   { -1,                 NULL,                   NULL                    },
2475 };
2476
2477 static char *optional_tokens[] =
2478 {
2479   "program_title",
2480   "program_copyright",
2481   "program_company",
2482
2483   NULL
2484 };
2485
2486 static void setTreeInfoToDefaults(TreeInfo *ti, int type)
2487 {
2488   ti->type = type;
2489
2490   ti->node_top = (ti->type == TREE_TYPE_LEVEL_DIR    ? &leveldir_first :
2491                   ti->type == TREE_TYPE_GRAPHICS_DIR ? &artwork.gfx_first :
2492                   ti->type == TREE_TYPE_SOUNDS_DIR   ? &artwork.snd_first :
2493                   ti->type == TREE_TYPE_MUSIC_DIR    ? &artwork.mus_first :
2494                   NULL);
2495
2496   ti->node_parent = NULL;
2497   ti->node_group = NULL;
2498   ti->next = NULL;
2499
2500   ti->cl_first = -1;
2501   ti->cl_cursor = -1;
2502
2503   ti->subdir = NULL;
2504   ti->fullpath = NULL;
2505   ti->basepath = NULL;
2506   ti->identifier = NULL;
2507   ti->name = getStringCopy(ANONYMOUS_NAME);
2508   ti->name_sorting = NULL;
2509   ti->author = getStringCopy(ANONYMOUS_NAME);
2510   ti->year = NULL;
2511
2512   ti->program_title = NULL;
2513   ti->program_copyright = NULL;
2514   ti->program_company = NULL;
2515
2516   ti->sort_priority = LEVELCLASS_UNDEFINED;     // default: least priority
2517   ti->latest_engine = FALSE;                    // default: get from level
2518   ti->parent_link = FALSE;
2519   ti->in_user_dir = FALSE;
2520   ti->user_defined = FALSE;
2521   ti->color = 0;
2522   ti->class_desc = NULL;
2523
2524   ti->infotext = getStringCopy(TREE_INFOTEXT(ti->type));
2525
2526   if (ti->type == TREE_TYPE_LEVEL_DIR)
2527   {
2528     ti->imported_from = NULL;
2529     ti->imported_by = NULL;
2530     ti->tested_by = NULL;
2531
2532     ti->graphics_set_ecs = NULL;
2533     ti->graphics_set_aga = NULL;
2534     ti->graphics_set = NULL;
2535     ti->sounds_set_default = NULL;
2536     ti->sounds_set_lowpass = NULL;
2537     ti->sounds_set = NULL;
2538     ti->music_set = NULL;
2539     ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
2540     ti->sounds_path = getStringCopy(UNDEFINED_FILENAME);
2541     ti->music_path = getStringCopy(UNDEFINED_FILENAME);
2542
2543     ti->level_filename = NULL;
2544     ti->level_filetype = NULL;
2545
2546     ti->special_flags = NULL;
2547
2548     ti->levels = 0;
2549     ti->first_level = 0;
2550     ti->last_level = 0;
2551     ti->level_group = FALSE;
2552     ti->handicap_level = 0;
2553     ti->readonly = TRUE;
2554     ti->handicap = TRUE;
2555     ti->skip_levels = FALSE;
2556
2557     ti->use_emc_tiles = FALSE;
2558   }
2559 }
2560
2561 static void setTreeInfoToDefaultsFromParent(TreeInfo *ti, TreeInfo *parent)
2562 {
2563   if (parent == NULL)
2564   {
2565     Warn("setTreeInfoToDefaultsFromParent(): parent == NULL");
2566
2567     setTreeInfoToDefaults(ti, TREE_TYPE_UNDEFINED);
2568
2569     return;
2570   }
2571
2572   // copy all values from the parent structure
2573
2574   ti->type = parent->type;
2575
2576   ti->node_top = parent->node_top;
2577   ti->node_parent = parent;
2578   ti->node_group = NULL;
2579   ti->next = NULL;
2580
2581   ti->cl_first = -1;
2582   ti->cl_cursor = -1;
2583
2584   ti->subdir = NULL;
2585   ti->fullpath = NULL;
2586   ti->basepath = NULL;
2587   ti->identifier = NULL;
2588   ti->name = getStringCopy(ANONYMOUS_NAME);
2589   ti->name_sorting = NULL;
2590   ti->author = getStringCopy(parent->author);
2591   ti->year = getStringCopy(parent->year);
2592
2593   ti->program_title = getStringCopy(parent->program_title);
2594   ti->program_copyright = getStringCopy(parent->program_copyright);
2595   ti->program_company = getStringCopy(parent->program_company);
2596
2597   ti->sort_priority = parent->sort_priority;
2598   ti->latest_engine = parent->latest_engine;
2599   ti->parent_link = FALSE;
2600   ti->in_user_dir = parent->in_user_dir;
2601   ti->user_defined = parent->user_defined;
2602   ti->color = parent->color;
2603   ti->class_desc = getStringCopy(parent->class_desc);
2604
2605   ti->infotext = getStringCopy(parent->infotext);
2606
2607   if (ti->type == TREE_TYPE_LEVEL_DIR)
2608   {
2609     ti->imported_from = getStringCopy(parent->imported_from);
2610     ti->imported_by = getStringCopy(parent->imported_by);
2611     ti->tested_by = getStringCopy(parent->tested_by);
2612
2613     ti->graphics_set_ecs = getStringCopy(parent->graphics_set_ecs);
2614     ti->graphics_set_aga = getStringCopy(parent->graphics_set_aga);
2615     ti->graphics_set = getStringCopy(parent->graphics_set);
2616     ti->sounds_set_default = getStringCopy(parent->sounds_set_default);
2617     ti->sounds_set_lowpass = getStringCopy(parent->sounds_set_lowpass);
2618     ti->sounds_set = getStringCopy(parent->sounds_set);
2619     ti->music_set = getStringCopy(parent->music_set);
2620     ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
2621     ti->sounds_path = getStringCopy(UNDEFINED_FILENAME);
2622     ti->music_path = getStringCopy(UNDEFINED_FILENAME);
2623
2624     ti->level_filename = getStringCopy(parent->level_filename);
2625     ti->level_filetype = getStringCopy(parent->level_filetype);
2626
2627     ti->special_flags = getStringCopy(parent->special_flags);
2628
2629     ti->levels = parent->levels;
2630     ti->first_level = parent->first_level;
2631     ti->last_level = parent->last_level;
2632     ti->level_group = FALSE;
2633     ti->handicap_level = parent->handicap_level;
2634     ti->readonly = parent->readonly;
2635     ti->handicap = parent->handicap;
2636     ti->skip_levels = parent->skip_levels;
2637
2638     ti->use_emc_tiles = parent->use_emc_tiles;
2639   }
2640 }
2641
2642 static TreeInfo *getTreeInfoCopy(TreeInfo *ti)
2643 {
2644   TreeInfo *ti_copy = newTreeInfo();
2645
2646   // copy all values from the original structure
2647
2648   ti_copy->type                 = ti->type;
2649
2650   ti_copy->node_top             = ti->node_top;
2651   ti_copy->node_parent          = ti->node_parent;
2652   ti_copy->node_group           = ti->node_group;
2653   ti_copy->next                 = ti->next;
2654
2655   ti_copy->cl_first             = ti->cl_first;
2656   ti_copy->cl_cursor            = ti->cl_cursor;
2657
2658   ti_copy->subdir               = getStringCopy(ti->subdir);
2659   ti_copy->fullpath             = getStringCopy(ti->fullpath);
2660   ti_copy->basepath             = getStringCopy(ti->basepath);
2661   ti_copy->identifier           = getStringCopy(ti->identifier);
2662   ti_copy->name                 = getStringCopy(ti->name);
2663   ti_copy->name_sorting         = getStringCopy(ti->name_sorting);
2664   ti_copy->author               = getStringCopy(ti->author);
2665   ti_copy->year                 = getStringCopy(ti->year);
2666
2667   ti_copy->program_title        = getStringCopy(ti->program_title);
2668   ti_copy->program_copyright    = getStringCopy(ti->program_copyright);
2669   ti_copy->program_company      = getStringCopy(ti->program_company);
2670
2671   ti_copy->imported_from        = getStringCopy(ti->imported_from);
2672   ti_copy->imported_by          = getStringCopy(ti->imported_by);
2673   ti_copy->tested_by            = getStringCopy(ti->tested_by);
2674
2675   ti_copy->graphics_set_ecs     = getStringCopy(ti->graphics_set_ecs);
2676   ti_copy->graphics_set_aga     = getStringCopy(ti->graphics_set_aga);
2677   ti_copy->graphics_set         = getStringCopy(ti->graphics_set);
2678   ti_copy->sounds_set_default   = getStringCopy(ti->sounds_set_default);
2679   ti_copy->sounds_set_lowpass   = getStringCopy(ti->sounds_set_lowpass);
2680   ti_copy->sounds_set           = getStringCopy(ti->sounds_set);
2681   ti_copy->music_set            = getStringCopy(ti->music_set);
2682   ti_copy->graphics_path        = getStringCopy(ti->graphics_path);
2683   ti_copy->sounds_path          = getStringCopy(ti->sounds_path);
2684   ti_copy->music_path           = getStringCopy(ti->music_path);
2685
2686   ti_copy->level_filename       = getStringCopy(ti->level_filename);
2687   ti_copy->level_filetype       = getStringCopy(ti->level_filetype);
2688
2689   ti_copy->special_flags        = getStringCopy(ti->special_flags);
2690
2691   ti_copy->levels               = ti->levels;
2692   ti_copy->first_level          = ti->first_level;
2693   ti_copy->last_level           = ti->last_level;
2694   ti_copy->sort_priority        = ti->sort_priority;
2695
2696   ti_copy->latest_engine        = ti->latest_engine;
2697
2698   ti_copy->level_group          = ti->level_group;
2699   ti_copy->parent_link          = ti->parent_link;
2700   ti_copy->in_user_dir          = ti->in_user_dir;
2701   ti_copy->user_defined         = ti->user_defined;
2702   ti_copy->readonly             = ti->readonly;
2703   ti_copy->handicap             = ti->handicap;
2704   ti_copy->skip_levels          = ti->skip_levels;
2705
2706   ti_copy->use_emc_tiles        = ti->use_emc_tiles;
2707
2708   ti_copy->color                = ti->color;
2709   ti_copy->class_desc           = getStringCopy(ti->class_desc);
2710   ti_copy->handicap_level       = ti->handicap_level;
2711
2712   ti_copy->infotext             = getStringCopy(ti->infotext);
2713
2714   return ti_copy;
2715 }
2716
2717 void freeTreeInfo(TreeInfo *ti)
2718 {
2719   if (ti == NULL)
2720     return;
2721
2722   checked_free(ti->subdir);
2723   checked_free(ti->fullpath);
2724   checked_free(ti->basepath);
2725   checked_free(ti->identifier);
2726
2727   checked_free(ti->name);
2728   checked_free(ti->name_sorting);
2729   checked_free(ti->author);
2730   checked_free(ti->year);
2731
2732   checked_free(ti->program_title);
2733   checked_free(ti->program_copyright);
2734   checked_free(ti->program_company);
2735
2736   checked_free(ti->class_desc);
2737
2738   checked_free(ti->infotext);
2739
2740   if (ti->type == TREE_TYPE_LEVEL_DIR)
2741   {
2742     checked_free(ti->imported_from);
2743     checked_free(ti->imported_by);
2744     checked_free(ti->tested_by);
2745
2746     checked_free(ti->graphics_set_ecs);
2747     checked_free(ti->graphics_set_aga);
2748     checked_free(ti->graphics_set);
2749     checked_free(ti->sounds_set_default);
2750     checked_free(ti->sounds_set_lowpass);
2751     checked_free(ti->sounds_set);
2752     checked_free(ti->music_set);
2753
2754     checked_free(ti->graphics_path);
2755     checked_free(ti->sounds_path);
2756     checked_free(ti->music_path);
2757
2758     checked_free(ti->level_filename);
2759     checked_free(ti->level_filetype);
2760
2761     checked_free(ti->special_flags);
2762   }
2763
2764   // recursively free child node
2765   if (ti->node_group)
2766     freeTreeInfo(ti->node_group);
2767
2768   // recursively free next node
2769   if (ti->next)
2770     freeTreeInfo(ti->next);
2771
2772   checked_free(ti);
2773 }
2774
2775 void setSetupInfo(struct TokenInfo *token_info,
2776                   int token_nr, char *token_value)
2777 {
2778   int token_type = token_info[token_nr].type;
2779   void *setup_value = token_info[token_nr].value;
2780
2781   if (token_value == NULL)
2782     return;
2783
2784   // set setup field to corresponding token value
2785   switch (token_type)
2786   {
2787     case TYPE_BOOLEAN:
2788     case TYPE_SWITCH:
2789       *(boolean *)setup_value = get_boolean_from_string(token_value);
2790       break;
2791
2792     case TYPE_SWITCH3:
2793       *(int *)setup_value = get_switch3_from_string(token_value);
2794       break;
2795
2796     case TYPE_KEY:
2797       *(Key *)setup_value = getKeyFromKeyName(token_value);
2798       break;
2799
2800     case TYPE_KEY_X11:
2801       *(Key *)setup_value = getKeyFromX11KeyName(token_value);
2802       break;
2803
2804     case TYPE_INTEGER:
2805       *(int *)setup_value = get_integer_from_string(token_value);
2806       break;
2807
2808     case TYPE_STRING:
2809       checked_free(*(char **)setup_value);
2810       *(char **)setup_value = getStringCopy(token_value);
2811       break;
2812
2813     case TYPE_PLAYER:
2814       *(int *)setup_value = get_player_nr_from_string(token_value);
2815       break;
2816
2817     default:
2818       break;
2819   }
2820 }
2821
2822 static int compareTreeInfoEntries(const void *object1, const void *object2)
2823 {
2824   const TreeInfo *entry1 = *((TreeInfo **)object1);
2825   const TreeInfo *entry2 = *((TreeInfo **)object2);
2826   int tree_sorting1 = TREE_SORTING(entry1);
2827   int tree_sorting2 = TREE_SORTING(entry2);
2828
2829   if (tree_sorting1 != tree_sorting2)
2830     return (tree_sorting1 - tree_sorting2);
2831   else
2832     return strcasecmp(entry1->name_sorting, entry2->name_sorting);
2833 }
2834
2835 static TreeInfo *createParentTreeInfoNode(TreeInfo *node_parent)
2836 {
2837   TreeInfo *ti_new;
2838
2839   if (node_parent == NULL)
2840     return NULL;
2841
2842   ti_new = newTreeInfo();
2843   setTreeInfoToDefaults(ti_new, node_parent->type);
2844
2845   ti_new->node_parent = node_parent;
2846   ti_new->parent_link = TRUE;
2847
2848   setString(&ti_new->identifier, node_parent->identifier);
2849   setString(&ti_new->name, BACKLINK_TEXT_PARENT);
2850   setString(&ti_new->name_sorting, ti_new->name);
2851
2852   setString(&ti_new->subdir, STRING_PARENT_DIRECTORY);
2853   setString(&ti_new->fullpath, node_parent->fullpath);
2854
2855   ti_new->sort_priority = node_parent->sort_priority;
2856   ti_new->latest_engine = node_parent->latest_engine;
2857
2858   setString(&ti_new->class_desc, getLevelClassDescription(ti_new));
2859
2860   pushTreeInfo(&node_parent->node_group, ti_new);
2861
2862   return ti_new;
2863 }
2864
2865 static TreeInfo *createTopTreeInfoNode(TreeInfo *node_first)
2866 {
2867   if (node_first == NULL)
2868     return NULL;
2869
2870   TreeInfo *ti_new = newTreeInfo();
2871   int type = node_first->type;
2872
2873   setTreeInfoToDefaults(ti_new, type);
2874
2875   ti_new->node_parent = NULL;
2876   ti_new->parent_link = FALSE;
2877
2878   setString(&ti_new->identifier, node_first->identifier);
2879   setString(&ti_new->name, TREE_INFOTEXT(type));
2880   setString(&ti_new->name_sorting, ti_new->name);
2881
2882   setString(&ti_new->subdir, STRING_TOP_DIRECTORY);
2883   setString(&ti_new->fullpath, ".");
2884
2885   ti_new->sort_priority = node_first->sort_priority;;
2886   ti_new->latest_engine = node_first->latest_engine;
2887
2888   setString(&ti_new->class_desc, TREE_INFOTEXT(type));
2889
2890   ti_new->node_group = node_first;
2891   ti_new->level_group = TRUE;
2892
2893   TreeInfo *ti_new2 = createParentTreeInfoNode(ti_new);
2894
2895   setString(&ti_new2->name, TREE_BACKLINK_TEXT(type));
2896   setString(&ti_new2->name_sorting, ti_new2->name);
2897
2898   return ti_new;
2899 }
2900
2901 static void setTreeInfoParentNodes(TreeInfo *node, TreeInfo *node_parent)
2902 {
2903   while (node)
2904   {
2905     if (node->node_group)
2906       setTreeInfoParentNodes(node->node_group, node);
2907
2908     node->node_parent = node_parent;
2909
2910     node = node->next;
2911   }
2912 }
2913
2914
2915 // ----------------------------------------------------------------------------
2916 // functions for handling level and custom artwork info cache
2917 // ----------------------------------------------------------------------------
2918
2919 static void LoadArtworkInfoCache(void)
2920 {
2921   InitCacheDirectory();
2922
2923   if (artworkinfo_cache_old == NULL)
2924   {
2925     char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
2926
2927     // try to load artwork info hash from already existing cache file
2928     artworkinfo_cache_old = loadSetupFileHash(filename);
2929
2930     // if no artwork info cache file was found, start with empty hash
2931     if (artworkinfo_cache_old == NULL)
2932       artworkinfo_cache_old = newSetupFileHash();
2933
2934     free(filename);
2935   }
2936
2937   if (artworkinfo_cache_new == NULL)
2938     artworkinfo_cache_new = newSetupFileHash();
2939
2940   update_artworkinfo_cache = FALSE;
2941 }
2942
2943 static void SaveArtworkInfoCache(void)
2944 {
2945   if (!update_artworkinfo_cache)
2946     return;
2947
2948   char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
2949
2950   InitCacheDirectory();
2951
2952   saveSetupFileHash(artworkinfo_cache_new, filename);
2953
2954   free(filename);
2955 }
2956
2957 static char *getCacheTokenPrefix(char *prefix1, char *prefix2)
2958 {
2959   static char *prefix = NULL;
2960
2961   checked_free(prefix);
2962
2963   prefix = getStringCat2WithSeparator(prefix1, prefix2, ".");
2964
2965   return prefix;
2966 }
2967
2968 // (identical to above function, but separate string buffer needed -- nasty)
2969 static char *getCacheToken(char *prefix, char *suffix)
2970 {
2971   static char *token = NULL;
2972
2973   checked_free(token);
2974
2975   token = getStringCat2WithSeparator(prefix, suffix, ".");
2976
2977   return token;
2978 }
2979
2980 static char *getFileTimestampString(char *filename)
2981 {
2982   return getStringCopy(i_to_a(getFileTimestampEpochSeconds(filename)));
2983 }
2984
2985 static boolean modifiedFileTimestamp(char *filename, char *timestamp_string)
2986 {
2987   struct stat file_status;
2988
2989   if (timestamp_string == NULL)
2990     return TRUE;
2991
2992   if (!fileExists(filename))                    // file does not exist
2993     return (atoi(timestamp_string) != 0);
2994
2995   if (stat(filename, &file_status) != 0)        // cannot stat file
2996     return TRUE;
2997
2998   return (file_status.st_mtime != atoi(timestamp_string));
2999 }
3000
3001 static TreeInfo *getArtworkInfoCacheEntry(LevelDirTree *level_node, int type)
3002 {
3003   char *identifier = level_node->subdir;
3004   char *type_string = ARTWORK_DIRECTORY(type);
3005   char *token_prefix = getCacheTokenPrefix(type_string, identifier);
3006   char *token_main = getCacheToken(token_prefix, "CACHED");
3007   char *cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3008   boolean cached = (cache_entry != NULL && strEqual(cache_entry, "true"));
3009   TreeInfo *artwork_info = NULL;
3010
3011   if (!use_artworkinfo_cache)
3012     return NULL;
3013
3014   if (optional_tokens_hash == NULL)
3015   {
3016     int i;
3017
3018     // create hash from list of optional tokens (for quick access)
3019     optional_tokens_hash = newSetupFileHash();
3020     for (i = 0; optional_tokens[i] != NULL; i++)
3021       setHashEntry(optional_tokens_hash, optional_tokens[i], "");
3022   }
3023
3024   if (cached)
3025   {
3026     int i;
3027
3028     artwork_info = newTreeInfo();
3029     setTreeInfoToDefaults(artwork_info, type);
3030
3031     // set all structure fields according to the token/value pairs
3032     ldi = *artwork_info;
3033     for (i = 0; artworkinfo_tokens[i].type != -1; i++)
3034     {
3035       char *token_suffix = artworkinfo_tokens[i].text;
3036       char *token = getCacheToken(token_prefix, token_suffix);
3037       char *value = getHashEntry(artworkinfo_cache_old, token);
3038       boolean optional =
3039         (getHashEntry(optional_tokens_hash, token_suffix) != NULL);
3040
3041       setSetupInfo(artworkinfo_tokens, i, value);
3042
3043       // check if cache entry for this item is mandatory, but missing
3044       if (value == NULL && !optional)
3045       {
3046         Warn("missing cache entry '%s'", token);
3047
3048         cached = FALSE;
3049       }
3050     }
3051
3052     *artwork_info = ldi;
3053   }
3054
3055   if (cached)
3056   {
3057     char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
3058                                         LEVELINFO_FILENAME);
3059     char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
3060                                           ARTWORKINFO_FILENAME(type));
3061
3062     // check if corresponding "levelinfo.conf" file has changed
3063     token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
3064     cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3065
3066     if (modifiedFileTimestamp(filename_levelinfo, cache_entry))
3067       cached = FALSE;
3068
3069     // check if corresponding "<artworkinfo>.conf" file has changed
3070     token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
3071     cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3072
3073     if (modifiedFileTimestamp(filename_artworkinfo, cache_entry))
3074       cached = FALSE;
3075
3076     checked_free(filename_levelinfo);
3077     checked_free(filename_artworkinfo);
3078   }
3079
3080   if (!cached && artwork_info != NULL)
3081   {
3082     freeTreeInfo(artwork_info);
3083
3084     return NULL;
3085   }
3086
3087   return artwork_info;
3088 }
3089
3090 static void setArtworkInfoCacheEntry(TreeInfo *artwork_info,
3091                                      LevelDirTree *level_node, int type)
3092 {
3093   char *identifier = level_node->subdir;
3094   char *type_string = ARTWORK_DIRECTORY(type);
3095   char *token_prefix = getCacheTokenPrefix(type_string, identifier);
3096   char *token_main = getCacheToken(token_prefix, "CACHED");
3097   boolean set_cache_timestamps = TRUE;
3098   int i;
3099
3100   setHashEntry(artworkinfo_cache_new, token_main, "true");
3101
3102   if (set_cache_timestamps)
3103   {
3104     char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
3105                                         LEVELINFO_FILENAME);
3106     char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
3107                                           ARTWORKINFO_FILENAME(type));
3108     char *timestamp_levelinfo = getFileTimestampString(filename_levelinfo);
3109     char *timestamp_artworkinfo = getFileTimestampString(filename_artworkinfo);
3110
3111     token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
3112     setHashEntry(artworkinfo_cache_new, token_main, timestamp_levelinfo);
3113
3114     token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
3115     setHashEntry(artworkinfo_cache_new, token_main, timestamp_artworkinfo);
3116
3117     checked_free(filename_levelinfo);
3118     checked_free(filename_artworkinfo);
3119     checked_free(timestamp_levelinfo);
3120     checked_free(timestamp_artworkinfo);
3121   }
3122
3123   ldi = *artwork_info;
3124   for (i = 0; artworkinfo_tokens[i].type != -1; i++)
3125   {
3126     char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text);
3127     char *value = getSetupValue(artworkinfo_tokens[i].type,
3128                                 artworkinfo_tokens[i].value);
3129     if (value != NULL)
3130       setHashEntry(artworkinfo_cache_new, token, value);
3131   }
3132 }
3133
3134
3135 // ----------------------------------------------------------------------------
3136 // functions for loading level info and custom artwork info
3137 // ----------------------------------------------------------------------------
3138
3139 int GetZipFileTreeType(char *zip_filename)
3140 {
3141   static char *top_dir_path = NULL;
3142   static char *top_dir_conf_filename[NUM_BASE_TREE_TYPES] = { NULL };
3143   static char *conf_basename[NUM_BASE_TREE_TYPES] =
3144   {
3145     GRAPHICSINFO_FILENAME,
3146     SOUNDSINFO_FILENAME,
3147     MUSICINFO_FILENAME,
3148     LEVELINFO_FILENAME
3149   };
3150   int j;
3151
3152   checked_free(top_dir_path);
3153   top_dir_path = NULL;
3154
3155   for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3156   {
3157     checked_free(top_dir_conf_filename[j]);
3158     top_dir_conf_filename[j] = NULL;
3159   }
3160
3161   char **zip_entries = zip_list(zip_filename);
3162
3163   // check if zip file successfully opened
3164   if (zip_entries == NULL || zip_entries[0] == NULL)
3165     return TREE_TYPE_UNDEFINED;
3166
3167   // first zip file entry is expected to be top level directory
3168   char *top_dir = zip_entries[0];
3169
3170   // check if valid top level directory found in zip file
3171   if (!strSuffix(top_dir, "/"))
3172     return TREE_TYPE_UNDEFINED;
3173
3174   // get filenames of valid configuration files in top level directory
3175   for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3176     top_dir_conf_filename[j] = getStringCat2(top_dir, conf_basename[j]);
3177
3178   int tree_type = TREE_TYPE_UNDEFINED;
3179   int e = 0;
3180
3181   while (zip_entries[e] != NULL)
3182   {
3183     // check if every zip file entry is below top level directory
3184     if (!strPrefix(zip_entries[e], top_dir))
3185       return TREE_TYPE_UNDEFINED;
3186
3187     // check if this zip file entry is a valid configuration filename
3188     for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3189     {
3190       if (strEqual(zip_entries[e], top_dir_conf_filename[j]))
3191       {
3192         // only exactly one valid configuration file allowed
3193         if (tree_type != TREE_TYPE_UNDEFINED)
3194           return TREE_TYPE_UNDEFINED;
3195
3196         tree_type = j;
3197       }
3198     }
3199
3200     e++;
3201   }
3202
3203   return tree_type;
3204 }
3205
3206 static boolean CheckZipFileForDirectory(char *zip_filename, char *directory,
3207                                         int tree_type)
3208 {
3209   static char *top_dir_path = NULL;
3210   static char *top_dir_conf_filename = NULL;
3211
3212   checked_free(top_dir_path);
3213   checked_free(top_dir_conf_filename);
3214
3215   top_dir_path = NULL;
3216   top_dir_conf_filename = NULL;
3217
3218   char *conf_basename = (tree_type == TREE_TYPE_LEVEL_DIR ? LEVELINFO_FILENAME :
3219                          ARTWORKINFO_FILENAME(tree_type));
3220
3221   // check if valid configuration filename determined
3222   if (conf_basename == NULL || strEqual(conf_basename, ""))
3223     return FALSE;
3224
3225   char **zip_entries = zip_list(zip_filename);
3226
3227   // check if zip file successfully opened
3228   if (zip_entries == NULL || zip_entries[0] == NULL)
3229     return FALSE;
3230
3231   // first zip file entry is expected to be top level directory
3232   char *top_dir = zip_entries[0];
3233
3234   // check if valid top level directory found in zip file
3235   if (!strSuffix(top_dir, "/"))
3236     return FALSE;
3237
3238   // get path of extracted top level directory
3239   top_dir_path = getPath2(directory, top_dir);
3240
3241   // remove trailing directory separator from top level directory path
3242   // (required to be able to check for file and directory in next step)
3243   top_dir_path[strlen(top_dir_path) - 1] = '\0';
3244
3245   // check if zip file's top level directory already exists in target directory
3246   if (fileExists(top_dir_path))         // (checks for file and directory)
3247     return FALSE;
3248
3249   // get filename of configuration file in top level directory
3250   top_dir_conf_filename = getStringCat2(top_dir, conf_basename);
3251
3252   boolean found_top_dir_conf_filename = FALSE;
3253   int i = 0;
3254
3255   while (zip_entries[i] != NULL)
3256   {
3257     // check if every zip file entry is below top level directory
3258     if (!strPrefix(zip_entries[i], top_dir))
3259       return FALSE;
3260
3261     // check if this zip file entry is the configuration filename
3262     if (strEqual(zip_entries[i], top_dir_conf_filename))
3263       found_top_dir_conf_filename = TRUE;
3264
3265     i++;
3266   }
3267
3268   // check if valid configuration filename was found in zip file
3269   if (!found_top_dir_conf_filename)
3270     return FALSE;
3271
3272   return TRUE;
3273 }
3274
3275 char *ExtractZipFileIntoDirectory(char *zip_filename, char *directory,
3276                                   int tree_type)
3277 {
3278   boolean zip_file_valid = CheckZipFileForDirectory(zip_filename, directory,
3279                                                     tree_type);
3280
3281   if (!zip_file_valid)
3282   {
3283     Warn("zip file '%s' rejected!", zip_filename);
3284
3285     return NULL;
3286   }
3287
3288   char **zip_entries = zip_extract(zip_filename, directory);
3289
3290   if (zip_entries == NULL)
3291   {
3292     Warn("zip file '%s' could not be extracted!", zip_filename);
3293
3294     return NULL;
3295   }
3296
3297   Info("zip file '%s' successfully extracted!", zip_filename);
3298
3299   // first zip file entry contains top level directory
3300   char *top_dir = zip_entries[0];
3301
3302   // remove trailing directory separator from top level directory
3303   top_dir[strlen(top_dir) - 1] = '\0';
3304
3305   return top_dir;
3306 }
3307
3308 static void ProcessZipFilesInDirectory(char *directory, int tree_type)
3309 {
3310   Directory *dir;
3311   DirectoryEntry *dir_entry;
3312
3313   if ((dir = openDirectory(directory)) == NULL)
3314   {
3315     // display error if directory is main "options.graphics_directory" etc.
3316     if (tree_type == TREE_TYPE_LEVEL_DIR ||
3317         directory == OPTIONS_ARTWORK_DIRECTORY(tree_type))
3318       Warn("cannot read directory '%s'", directory);
3319
3320     return;
3321   }
3322
3323   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3324   {
3325     // skip non-zip files (and also directories with zip extension)
3326     if (!strSuffixLower(dir_entry->basename, ".zip") || dir_entry->is_directory)
3327       continue;
3328
3329     char *zip_filename = getPath2(directory, dir_entry->basename);
3330     char *zip_filename_extracted = getStringCat2(zip_filename, ".extracted");
3331     char *zip_filename_rejected  = getStringCat2(zip_filename, ".rejected");
3332
3333     // check if zip file hasn't already been extracted or rejected
3334     if (!fileExists(zip_filename_extracted) &&
3335         !fileExists(zip_filename_rejected))
3336     {
3337       char *top_dir = ExtractZipFileIntoDirectory(zip_filename, directory,
3338                                                   tree_type);
3339       char *marker_filename = (top_dir != NULL ? zip_filename_extracted :
3340                                zip_filename_rejected);
3341       FILE *marker_file;
3342
3343       // create empty file to mark zip file as extracted or rejected
3344       if ((marker_file = fopen(marker_filename, MODE_WRITE)))
3345         fclose(marker_file);
3346
3347       free(zip_filename);
3348       free(zip_filename_extracted);
3349       free(zip_filename_rejected);
3350     }
3351   }
3352
3353   closeDirectory(dir);
3354 }
3355
3356 // forward declaration for recursive call by "LoadLevelInfoFromLevelDir()"
3357 static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
3358
3359 static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
3360                                           TreeInfo *node_parent,
3361                                           char *level_directory,
3362                                           char *directory_name)
3363 {
3364   char *directory_path = getPath2(level_directory, directory_name);
3365   char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
3366   SetupFileHash *setup_file_hash;
3367   LevelDirTree *leveldir_new = NULL;
3368   int i;
3369
3370   // unless debugging, silently ignore directories without "levelinfo.conf"
3371   if (!options.debug && !fileExists(filename))
3372   {
3373     free(directory_path);
3374     free(filename);
3375
3376     return FALSE;
3377   }
3378
3379   setup_file_hash = loadSetupFileHash(filename);
3380
3381   if (setup_file_hash == NULL)
3382   {
3383 #if DEBUG_NO_CONFIG_FILE
3384     Debug("setup", "ignoring level directory '%s'", directory_path);
3385 #endif
3386
3387     free(directory_path);
3388     free(filename);
3389
3390     return FALSE;
3391   }
3392
3393   leveldir_new = newTreeInfo();
3394
3395   if (node_parent)
3396     setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
3397   else
3398     setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
3399
3400   leveldir_new->subdir = getStringCopy(directory_name);
3401
3402   // set all structure fields according to the token/value pairs
3403   ldi = *leveldir_new;
3404   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3405     setSetupInfo(levelinfo_tokens, i,
3406                  getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
3407   *leveldir_new = ldi;
3408
3409   if (strEqual(leveldir_new->name, ANONYMOUS_NAME))
3410     setString(&leveldir_new->name, leveldir_new->subdir);
3411
3412   if (leveldir_new->identifier == NULL)
3413     leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
3414
3415   if (leveldir_new->name_sorting == NULL)
3416     leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
3417
3418   if (node_parent == NULL)              // top level group
3419   {
3420     leveldir_new->basepath = getStringCopy(level_directory);
3421     leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
3422   }
3423   else                                  // sub level group
3424   {
3425     leveldir_new->basepath = getStringCopy(node_parent->basepath);
3426     leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
3427   }
3428
3429   leveldir_new->last_level =
3430     leveldir_new->first_level + leveldir_new->levels - 1;
3431
3432   leveldir_new->in_user_dir =
3433     (!strEqual(leveldir_new->basepath, options.level_directory));
3434
3435   // adjust some settings if user's private level directory was detected
3436   if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
3437       leveldir_new->in_user_dir &&
3438       (strEqual(leveldir_new->subdir, getLoginName()) ||
3439        strEqual(leveldir_new->name,   getLoginName()) ||
3440        strEqual(leveldir_new->author, getRealName())))
3441   {
3442     leveldir_new->sort_priority = LEVELCLASS_PRIVATE_START;
3443     leveldir_new->readonly = FALSE;
3444   }
3445
3446   leveldir_new->user_defined =
3447     (leveldir_new->in_user_dir && IS_LEVELCLASS_PRIVATE(leveldir_new));
3448
3449   setString(&leveldir_new->class_desc, getLevelClassDescription(leveldir_new));
3450
3451   leveldir_new->handicap_level =        // set handicap to default value
3452     (leveldir_new->user_defined || !leveldir_new->handicap ?
3453      leveldir_new->last_level : leveldir_new->first_level);
3454
3455   DrawInitText(leveldir_new->name, 150, FC_YELLOW);
3456
3457   pushTreeInfo(node_first, leveldir_new);
3458
3459   freeSetupFileHash(setup_file_hash);
3460
3461   if (leveldir_new->level_group)
3462   {
3463     // create node to link back to current level directory
3464     createParentTreeInfoNode(leveldir_new);
3465
3466     // recursively step into sub-directory and look for more level series
3467     LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
3468                               leveldir_new, directory_path);
3469   }
3470
3471   free(directory_path);
3472   free(filename);
3473
3474   return TRUE;
3475 }
3476
3477 static void LoadLevelInfoFromLevelDir(TreeInfo **node_first,
3478                                       TreeInfo *node_parent,
3479                                       char *level_directory)
3480 {
3481   // ---------- 1st stage: process any level set zip files ----------
3482
3483   ProcessZipFilesInDirectory(level_directory, TREE_TYPE_LEVEL_DIR);
3484
3485   // ---------- 2nd stage: check for level set directories ----------
3486
3487   Directory *dir;
3488   DirectoryEntry *dir_entry;
3489   boolean valid_entry_found = FALSE;
3490
3491   if ((dir = openDirectory(level_directory)) == NULL)
3492   {
3493     Warn("cannot read level directory '%s'", level_directory);
3494
3495     return;
3496   }
3497
3498   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3499   {
3500     char *directory_name = dir_entry->basename;
3501     char *directory_path = getPath2(level_directory, directory_name);
3502
3503     // skip entries for current and parent directory
3504     if (strEqual(directory_name, ".") ||
3505         strEqual(directory_name, ".."))
3506     {
3507       free(directory_path);
3508
3509       continue;
3510     }
3511
3512     // find out if directory entry is itself a directory
3513     if (!dir_entry->is_directory)                       // not a directory
3514     {
3515       free(directory_path);
3516
3517       continue;
3518     }
3519
3520     free(directory_path);
3521
3522     if (strEqual(directory_name, GRAPHICS_DIRECTORY) ||
3523         strEqual(directory_name, SOUNDS_DIRECTORY) ||
3524         strEqual(directory_name, MUSIC_DIRECTORY))
3525       continue;
3526
3527     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
3528                                                     level_directory,
3529                                                     directory_name);
3530   }
3531
3532   closeDirectory(dir);
3533
3534   // special case: top level directory may directly contain "levelinfo.conf"
3535   if (node_parent == NULL && !valid_entry_found)
3536   {
3537     // check if this directory directly contains a file "levelinfo.conf"
3538     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
3539                                                     level_directory, ".");
3540   }
3541
3542   if (!valid_entry_found)
3543     Warn("cannot find any valid level series in directory '%s'",
3544           level_directory);
3545 }
3546
3547 boolean AdjustGraphicsForEMC(void)
3548 {
3549   boolean settings_changed = FALSE;
3550
3551   settings_changed |= adjustTreeGraphicsForEMC(leveldir_first_all);
3552   settings_changed |= adjustTreeGraphicsForEMC(leveldir_first);
3553
3554   return settings_changed;
3555 }
3556
3557 boolean AdjustSoundsForEMC(void)
3558 {
3559   boolean settings_changed = FALSE;
3560
3561   settings_changed |= adjustTreeSoundsForEMC(leveldir_first_all);
3562   settings_changed |= adjustTreeSoundsForEMC(leveldir_first);
3563
3564   return settings_changed;
3565 }
3566
3567 void LoadLevelInfo(void)
3568 {
3569   InitUserLevelDirectory(getLoginName());
3570
3571   DrawInitText("Loading level series", 120, FC_GREEN);
3572
3573   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
3574   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL));
3575
3576   leveldir_first = createTopTreeInfoNode(leveldir_first);
3577
3578   /* after loading all level set information, clone the level directory tree
3579      and remove all level sets without levels (these may still contain artwork
3580      to be offered in the setup menu as "custom artwork", and are therefore
3581      checked for existing artwork in the function "LoadLevelArtworkInfo()") */
3582   leveldir_first_all = leveldir_first;
3583   cloneTree(&leveldir_first, leveldir_first_all, TRUE);
3584
3585   AdjustGraphicsForEMC();
3586   AdjustSoundsForEMC();
3587
3588   // before sorting, the first entries will be from the user directory
3589   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
3590
3591   if (leveldir_first == NULL)
3592     Fail("cannot find any valid level series in any directory");
3593
3594   sortTreeInfo(&leveldir_first);
3595
3596 #if ENABLE_UNUSED_CODE
3597   dumpTreeInfo(leveldir_first, 0);
3598 #endif
3599 }
3600
3601 static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first,
3602                                               TreeInfo *node_parent,
3603                                               char *base_directory,
3604                                               char *directory_name, int type)
3605 {
3606   char *directory_path = getPath2(base_directory, directory_name);
3607   char *filename = getPath2(directory_path, ARTWORKINFO_FILENAME(type));
3608   SetupFileHash *setup_file_hash = NULL;
3609   TreeInfo *artwork_new = NULL;
3610   int i;
3611
3612   if (fileExists(filename))
3613     setup_file_hash = loadSetupFileHash(filename);
3614
3615   if (setup_file_hash == NULL)  // no config file -- look for artwork files
3616   {
3617     Directory *dir;
3618     DirectoryEntry *dir_entry;
3619     boolean valid_file_found = FALSE;
3620
3621     if ((dir = openDirectory(directory_path)) != NULL)
3622     {
3623       while ((dir_entry = readDirectory(dir)) != NULL)
3624       {
3625         if (FileIsArtworkType(dir_entry->filename, type))
3626         {
3627           valid_file_found = TRUE;
3628
3629           break;
3630         }
3631       }
3632
3633       closeDirectory(dir);
3634     }
3635
3636     if (!valid_file_found)
3637     {
3638 #if DEBUG_NO_CONFIG_FILE
3639       if (!strEqual(directory_name, "."))
3640         Debug("setup", "ignoring artwork directory '%s'", directory_path);
3641 #endif
3642
3643       free(directory_path);
3644       free(filename);
3645
3646       return FALSE;
3647     }
3648   }
3649
3650   artwork_new = newTreeInfo();
3651
3652   if (node_parent)
3653     setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
3654   else
3655     setTreeInfoToDefaults(artwork_new, type);
3656
3657   artwork_new->subdir = getStringCopy(directory_name);
3658
3659   if (setup_file_hash)  // (before defining ".color" and ".class_desc")
3660   {
3661     // set all structure fields according to the token/value pairs
3662     ldi = *artwork_new;
3663     for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3664       setSetupInfo(levelinfo_tokens, i,
3665                    getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
3666     *artwork_new = ldi;
3667
3668     if (strEqual(artwork_new->name, ANONYMOUS_NAME))
3669       setString(&artwork_new->name, artwork_new->subdir);
3670
3671     if (artwork_new->identifier == NULL)
3672       artwork_new->identifier = getStringCopy(artwork_new->subdir);
3673
3674     if (artwork_new->name_sorting == NULL)
3675       artwork_new->name_sorting = getStringCopy(artwork_new->name);
3676   }
3677
3678   if (node_parent == NULL)              // top level group
3679   {
3680     artwork_new->basepath = getStringCopy(base_directory);
3681     artwork_new->fullpath = getStringCopy(artwork_new->subdir);
3682   }
3683   else                                  // sub level group
3684   {
3685     artwork_new->basepath = getStringCopy(node_parent->basepath);
3686     artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name);
3687   }
3688
3689   artwork_new->in_user_dir =
3690     (!strEqual(artwork_new->basepath, OPTIONS_ARTWORK_DIRECTORY(type)));
3691
3692   setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new));
3693
3694   if (setup_file_hash == NULL)  // (after determining ".user_defined")
3695   {
3696     if (strEqual(artwork_new->subdir, "."))
3697     {
3698       if (artwork_new->user_defined)
3699       {
3700         setString(&artwork_new->identifier, "private");
3701         artwork_new->sort_priority = ARTWORKCLASS_PRIVATE;
3702       }
3703       else
3704       {
3705         setString(&artwork_new->identifier, "classic");
3706         artwork_new->sort_priority = ARTWORKCLASS_CLASSICS;
3707       }
3708
3709       setString(&artwork_new->class_desc,
3710                 getLevelClassDescription(artwork_new));
3711     }
3712     else
3713     {
3714       setString(&artwork_new->identifier, artwork_new->subdir);
3715     }
3716
3717     setString(&artwork_new->name, artwork_new->identifier);
3718     setString(&artwork_new->name_sorting, artwork_new->name);
3719   }
3720
3721   pushTreeInfo(node_first, artwork_new);
3722
3723   freeSetupFileHash(setup_file_hash);
3724
3725   free(directory_path);
3726   free(filename);
3727
3728   return TRUE;
3729 }
3730
3731 static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first,
3732                                           TreeInfo *node_parent,
3733                                           char *base_directory, int type)
3734 {
3735   // ---------- 1st stage: process any artwork set zip files ----------
3736
3737   ProcessZipFilesInDirectory(base_directory, type);
3738
3739   // ---------- 2nd stage: check for artwork set directories ----------
3740
3741   Directory *dir;
3742   DirectoryEntry *dir_entry;
3743   boolean valid_entry_found = FALSE;
3744
3745   if ((dir = openDirectory(base_directory)) == NULL)
3746   {
3747     // display error if directory is main "options.graphics_directory" etc.
3748     if (base_directory == OPTIONS_ARTWORK_DIRECTORY(type))
3749       Warn("cannot read directory '%s'", base_directory);
3750
3751     return;
3752   }
3753
3754   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3755   {
3756     char *directory_name = dir_entry->basename;
3757     char *directory_path = getPath2(base_directory, directory_name);
3758
3759     // skip directory entries for current and parent directory
3760     if (strEqual(directory_name, ".") ||
3761         strEqual(directory_name, ".."))
3762     {
3763       free(directory_path);
3764
3765       continue;
3766     }
3767
3768     // skip directory entries which are not a directory
3769     if (!dir_entry->is_directory)                       // not a directory
3770     {
3771       free(directory_path);
3772
3773       continue;
3774     }
3775
3776     free(directory_path);
3777
3778     // check if this directory contains artwork with or without config file
3779     valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
3780                                                         base_directory,
3781                                                         directory_name, type);
3782   }
3783
3784   closeDirectory(dir);
3785
3786   // check if this directory directly contains artwork itself
3787   valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
3788                                                       base_directory, ".",
3789                                                       type);
3790   if (!valid_entry_found)
3791     Warn("cannot find any valid artwork in directory '%s'", base_directory);
3792 }
3793
3794 static TreeInfo *getDummyArtworkInfo(int type)
3795 {
3796   // this is only needed when there is completely no artwork available
3797   TreeInfo *artwork_new = newTreeInfo();
3798
3799   setTreeInfoToDefaults(artwork_new, type);
3800
3801   setString(&artwork_new->subdir,   UNDEFINED_FILENAME);
3802   setString(&artwork_new->fullpath, UNDEFINED_FILENAME);
3803   setString(&artwork_new->basepath, UNDEFINED_FILENAME);
3804
3805   setString(&artwork_new->identifier,   UNDEFINED_FILENAME);
3806   setString(&artwork_new->name,         UNDEFINED_FILENAME);
3807   setString(&artwork_new->name_sorting, UNDEFINED_FILENAME);
3808
3809   return artwork_new;
3810 }
3811
3812 void SetCurrentArtwork(int type)
3813 {
3814   ArtworkDirTree **current_ptr = ARTWORK_CURRENT_PTR(artwork, type);
3815   ArtworkDirTree *first_node = ARTWORK_FIRST_NODE(artwork, type);
3816   char *setup_set = SETUP_ARTWORK_SET(setup, type);
3817   char *default_subdir = ARTWORK_DEFAULT_SUBDIR(type);
3818
3819   // set current artwork to artwork configured in setup menu
3820   *current_ptr = getTreeInfoFromIdentifier(first_node, setup_set);
3821
3822   // if not found, set current artwork to default artwork
3823   if (*current_ptr == NULL)
3824     *current_ptr = getTreeInfoFromIdentifier(first_node, default_subdir);
3825
3826   // if not found, set current artwork to first artwork in tree
3827   if (*current_ptr == NULL)
3828     *current_ptr = getFirstValidTreeInfoEntry(first_node);
3829 }
3830
3831 void ChangeCurrentArtworkIfNeeded(int type)
3832 {
3833   char *current_identifier = ARTWORK_CURRENT_IDENTIFIER(artwork, type);
3834   char *setup_set = SETUP_ARTWORK_SET(setup, type);
3835
3836   if (!strEqual(current_identifier, setup_set))
3837     SetCurrentArtwork(type);
3838 }
3839
3840 void LoadArtworkInfo(void)
3841 {
3842   LoadArtworkInfoCache();
3843
3844   DrawInitText("Looking for custom artwork", 120, FC_GREEN);
3845
3846   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
3847                                 options.graphics_directory,
3848                                 TREE_TYPE_GRAPHICS_DIR);
3849   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
3850                                 getUserGraphicsDir(),
3851                                 TREE_TYPE_GRAPHICS_DIR);
3852
3853   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
3854                                 options.sounds_directory,
3855                                 TREE_TYPE_SOUNDS_DIR);
3856   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
3857                                 getUserSoundsDir(),
3858                                 TREE_TYPE_SOUNDS_DIR);
3859
3860   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
3861                                 options.music_directory,
3862                                 TREE_TYPE_MUSIC_DIR);
3863   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
3864                                 getUserMusicDir(),
3865                                 TREE_TYPE_MUSIC_DIR);
3866
3867   if (artwork.gfx_first == NULL)
3868     artwork.gfx_first = getDummyArtworkInfo(TREE_TYPE_GRAPHICS_DIR);
3869   if (artwork.snd_first == NULL)
3870     artwork.snd_first = getDummyArtworkInfo(TREE_TYPE_SOUNDS_DIR);
3871   if (artwork.mus_first == NULL)
3872     artwork.mus_first = getDummyArtworkInfo(TREE_TYPE_MUSIC_DIR);
3873
3874   // before sorting, the first entries will be from the user directory
3875   SetCurrentArtwork(ARTWORK_TYPE_GRAPHICS);
3876   SetCurrentArtwork(ARTWORK_TYPE_SOUNDS);
3877   SetCurrentArtwork(ARTWORK_TYPE_MUSIC);
3878
3879   artwork.gfx_current_identifier = artwork.gfx_current->identifier;
3880   artwork.snd_current_identifier = artwork.snd_current->identifier;
3881   artwork.mus_current_identifier = artwork.mus_current->identifier;
3882
3883 #if ENABLE_UNUSED_CODE
3884   Debug("setup:LoadArtworkInfo", "graphics set == %s",
3885         artwork.gfx_current_identifier);
3886   Debug("setup:LoadArtworkInfo", "sounds set == %s",
3887         artwork.snd_current_identifier);
3888   Debug("setup:LoadArtworkInfo", "music set == %s",
3889         artwork.mus_current_identifier);
3890 #endif
3891
3892   sortTreeInfo(&artwork.gfx_first);
3893   sortTreeInfo(&artwork.snd_first);
3894   sortTreeInfo(&artwork.mus_first);
3895
3896 #if ENABLE_UNUSED_CODE
3897   dumpTreeInfo(artwork.gfx_first, 0);
3898   dumpTreeInfo(artwork.snd_first, 0);
3899   dumpTreeInfo(artwork.mus_first, 0);
3900 #endif
3901 }
3902
3903 static void MoveArtworkInfoIntoSubTree(ArtworkDirTree **artwork_node)
3904 {
3905   ArtworkDirTree *artwork_new = newTreeInfo();
3906   char *top_node_name = "standalone artwork";
3907
3908   setTreeInfoToDefaults(artwork_new, (*artwork_node)->type);
3909
3910   artwork_new->level_group = TRUE;
3911
3912   setString(&artwork_new->identifier,   top_node_name);
3913   setString(&artwork_new->name,         top_node_name);
3914   setString(&artwork_new->name_sorting, top_node_name);
3915
3916   // create node to link back to current custom artwork directory
3917   createParentTreeInfoNode(artwork_new);
3918
3919   // move existing custom artwork tree into newly created sub-tree
3920   artwork_new->node_group->next = *artwork_node;
3921
3922   // change custom artwork tree to contain only newly created node
3923   *artwork_node = artwork_new;
3924 }
3925
3926 static void LoadArtworkInfoFromLevelInfoExt(ArtworkDirTree **artwork_node,
3927                                             ArtworkDirTree *node_parent,
3928                                             LevelDirTree *level_node,
3929                                             boolean empty_level_set_mode)
3930 {
3931   int type = (*artwork_node)->type;
3932
3933   // recursively check all level directories for artwork sub-directories
3934
3935   while (level_node)
3936   {
3937     boolean empty_level_set = (level_node->levels == 0);
3938
3939     // check all tree entries for artwork, but skip parent link entries
3940     if (!level_node->parent_link && empty_level_set == empty_level_set_mode)
3941     {
3942       TreeInfo *artwork_new = getArtworkInfoCacheEntry(level_node, type);
3943       boolean cached = (artwork_new != NULL);
3944
3945       if (cached)
3946       {
3947         pushTreeInfo(artwork_node, artwork_new);
3948       }
3949       else
3950       {
3951         TreeInfo *topnode_last = *artwork_node;
3952         char *path = getPath2(getLevelDirFromTreeInfo(level_node),
3953                               ARTWORK_DIRECTORY(type));
3954
3955         LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path, type);
3956
3957         if (topnode_last != *artwork_node)      // check for newly added node
3958         {
3959           artwork_new = *artwork_node;
3960
3961           setString(&artwork_new->identifier,   level_node->subdir);
3962           setString(&artwork_new->name,         level_node->name);
3963           setString(&artwork_new->name_sorting, level_node->name_sorting);
3964
3965           artwork_new->sort_priority = level_node->sort_priority;
3966           artwork_new->in_user_dir = level_node->in_user_dir;
3967
3968           update_artworkinfo_cache = TRUE;
3969         }
3970
3971         free(path);
3972       }
3973
3974       // insert artwork info (from old cache or filesystem) into new cache
3975       if (artwork_new != NULL)
3976         setArtworkInfoCacheEntry(artwork_new, level_node, type);
3977     }
3978
3979     DrawInitText(level_node->name, 150, FC_YELLOW);
3980
3981     if (level_node->node_group != NULL)
3982     {
3983       TreeInfo *artwork_new = newTreeInfo();
3984
3985       if (node_parent)
3986         setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
3987       else
3988         setTreeInfoToDefaults(artwork_new, type);
3989
3990       artwork_new->level_group = TRUE;
3991
3992       setString(&artwork_new->identifier,   level_node->subdir);
3993
3994       if (node_parent == NULL)          // check for top tree node
3995       {
3996         char *top_node_name = (empty_level_set_mode ?
3997                                "artwork for certain level sets" :
3998                                "artwork included in level sets");
3999
4000         setString(&artwork_new->name,         top_node_name);
4001         setString(&artwork_new->name_sorting, top_node_name);
4002       }
4003       else
4004       {
4005         setString(&artwork_new->name,         level_node->name);
4006         setString(&artwork_new->name_sorting, level_node->name_sorting);
4007       }
4008
4009       pushTreeInfo(artwork_node, artwork_new);
4010
4011       // create node to link back to current custom artwork directory
4012       createParentTreeInfoNode(artwork_new);
4013
4014       // recursively step into sub-directory and look for more custom artwork
4015       LoadArtworkInfoFromLevelInfoExt(&artwork_new->node_group, artwork_new,
4016                                       level_node->node_group,
4017                                       empty_level_set_mode);
4018
4019       // if sub-tree has no custom artwork at all, remove it
4020       if (artwork_new->node_group->next == NULL)
4021         removeTreeInfo(artwork_node);
4022     }
4023
4024     level_node = level_node->next;
4025   }
4026 }
4027
4028 static void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node)
4029 {
4030   // move peviously loaded artwork tree into separate sub-tree
4031   MoveArtworkInfoIntoSubTree(artwork_node);
4032
4033   // load artwork from level sets into separate sub-trees
4034   LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, TRUE);
4035   LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, FALSE);
4036
4037   // add top tree node over all three separate sub-trees
4038   *artwork_node = createTopTreeInfoNode(*artwork_node);
4039
4040   // set all parent links (back links) in complete artwork tree
4041   setTreeInfoParentNodes(*artwork_node, NULL);
4042 }
4043
4044 void LoadLevelArtworkInfo(void)
4045 {
4046   print_timestamp_init("LoadLevelArtworkInfo");
4047
4048   DrawInitText("Looking for custom level artwork", 120, FC_GREEN);
4049
4050   print_timestamp_time("DrawTimeText");
4051
4052   LoadArtworkInfoFromLevelInfo(&artwork.gfx_first);
4053   print_timestamp_time("LoadArtworkInfoFromLevelInfo (gfx)");
4054   LoadArtworkInfoFromLevelInfo(&artwork.snd_first);
4055   print_timestamp_time("LoadArtworkInfoFromLevelInfo (snd)");
4056   LoadArtworkInfoFromLevelInfo(&artwork.mus_first);
4057   print_timestamp_time("LoadArtworkInfoFromLevelInfo (mus)");
4058
4059   SaveArtworkInfoCache();
4060
4061   print_timestamp_time("SaveArtworkInfoCache");
4062
4063   // needed for reloading level artwork not known at ealier stage
4064   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_GRAPHICS);
4065   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_SOUNDS);
4066   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_MUSIC);
4067
4068   print_timestamp_time("getTreeInfoFromIdentifier");
4069
4070   sortTreeInfo(&artwork.gfx_first);
4071   sortTreeInfo(&artwork.snd_first);
4072   sortTreeInfo(&artwork.mus_first);
4073
4074   print_timestamp_time("sortTreeInfo");
4075
4076 #if ENABLE_UNUSED_CODE
4077   dumpTreeInfo(artwork.gfx_first, 0);
4078   dumpTreeInfo(artwork.snd_first, 0);
4079   dumpTreeInfo(artwork.mus_first, 0);
4080 #endif
4081
4082   print_timestamp_done("LoadLevelArtworkInfo");
4083 }
4084
4085 static boolean AddTreeSetToTreeInfoExt(TreeInfo *tree_node_old, char *tree_dir,
4086                                        char *tree_subdir_new, int type)
4087 {
4088   if (tree_node_old == NULL)
4089   {
4090     if (type == TREE_TYPE_LEVEL_DIR)
4091     {
4092       // get level info tree node of personal user level set
4093       tree_node_old = getTreeInfoFromIdentifier(leveldir_first, getLoginName());
4094
4095       // this may happen if "setup.internal.create_user_levelset" is FALSE
4096       // or if file "levelinfo.conf" is missing in personal user level set
4097       if (tree_node_old == NULL)
4098         tree_node_old = leveldir_first->node_group;
4099     }
4100     else
4101     {
4102       // get artwork info tree node of first artwork set
4103       tree_node_old = ARTWORK_FIRST_NODE(artwork, type);
4104     }
4105   }
4106
4107   if (tree_dir == NULL)
4108     tree_dir = TREE_USERDIR(type);
4109
4110   if (tree_node_old   == NULL ||
4111       tree_dir        == NULL ||
4112       tree_subdir_new == NULL)          // should not happen
4113     return FALSE;
4114
4115   int draw_deactivation_mask = GetDrawDeactivationMask();
4116
4117   // override draw deactivation mask (temporarily disable drawing)
4118   SetDrawDeactivationMask(REDRAW_ALL);
4119
4120   if (type == TREE_TYPE_LEVEL_DIR)
4121   {
4122     // load new level set config and add it next to first user level set
4123     LoadLevelInfoFromLevelConf(&tree_node_old->next,
4124                                tree_node_old->node_parent,
4125                                tree_dir, tree_subdir_new);
4126   }
4127   else
4128   {
4129     // load new artwork set config and add it next to first artwork set
4130     LoadArtworkInfoFromArtworkConf(&tree_node_old->next,
4131                                    tree_node_old->node_parent,
4132                                    tree_dir, tree_subdir_new, type);
4133   }
4134
4135   // set draw deactivation mask to previous value
4136   SetDrawDeactivationMask(draw_deactivation_mask);
4137
4138   // get first node of level or artwork info tree
4139   TreeInfo **tree_node_first = TREE_FIRST_NODE_PTR(type);
4140
4141   // get tree info node of newly added level or artwork set
4142   TreeInfo *tree_node_new = getTreeInfoFromIdentifier(*tree_node_first,
4143                                                       tree_subdir_new);
4144
4145   if (tree_node_new == NULL)            // should not happen
4146     return FALSE;
4147
4148   // correct top link and parent node link of newly created tree node
4149   tree_node_new->node_top    = tree_node_old->node_top;
4150   tree_node_new->node_parent = tree_node_old->node_parent;
4151
4152   // sort tree info to adjust position of newly added tree set
4153   sortTreeInfo(tree_node_first);
4154
4155   return TRUE;
4156 }
4157
4158 void AddTreeSetToTreeInfo(TreeInfo *tree_node, char *tree_dir,
4159                           char *tree_subdir_new, int type)
4160 {
4161   if (!AddTreeSetToTreeInfoExt(tree_node, tree_dir, tree_subdir_new, type))
4162     Fail("internal tree info structure corrupted -- aborting");
4163 }
4164
4165 void AddUserLevelSetToLevelInfo(char *level_subdir_new)
4166 {
4167   AddTreeSetToTreeInfo(NULL, NULL, level_subdir_new, TREE_TYPE_LEVEL_DIR);
4168 }
4169
4170 char *getArtworkIdentifierForUserLevelSet(int type)
4171 {
4172   char *classic_artwork_set = getClassicArtworkSet(type);
4173
4174   // check for custom artwork configured in "levelinfo.conf"
4175   char *leveldir_artwork_set =
4176     *LEVELDIR_ARTWORK_SET_PTR(leveldir_current, type);
4177   boolean has_leveldir_artwork_set =
4178     (leveldir_artwork_set != NULL && !strEqual(leveldir_artwork_set,
4179                                                classic_artwork_set));
4180
4181   // check for custom artwork in sub-directory "graphics" etc.
4182   TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
4183   char *leveldir_identifier = leveldir_current->identifier;
4184   boolean has_artwork_subdir =
4185     (getTreeInfoFromIdentifier(artwork_first_node,
4186                                leveldir_identifier) != NULL);
4187
4188   return (has_leveldir_artwork_set ? leveldir_artwork_set :
4189           has_artwork_subdir       ? leveldir_identifier :
4190           classic_artwork_set);
4191 }
4192
4193 TreeInfo *getArtworkTreeInfoForUserLevelSet(int type)
4194 {
4195   char *artwork_set = getArtworkIdentifierForUserLevelSet(type);
4196   TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
4197   TreeInfo *ti = getTreeInfoFromIdentifier(artwork_first_node, artwork_set);
4198
4199   if (ti == NULL)
4200   {
4201     ti = getTreeInfoFromIdentifier(artwork_first_node,
4202                                    ARTWORK_DEFAULT_SUBDIR(type));
4203     if (ti == NULL)
4204       Fail("cannot find default graphics -- should not happen");
4205   }
4206
4207   return ti;
4208 }
4209
4210 boolean checkIfCustomArtworkExistsForCurrentLevelSet(void)
4211 {
4212   char *graphics_set =
4213     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
4214   char *sounds_set =
4215     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_SOUNDS);
4216   char *music_set =
4217     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_MUSIC);
4218
4219   return (!strEqual(graphics_set, GFX_CLASSIC_SUBDIR) ||
4220           !strEqual(sounds_set,   SND_CLASSIC_SUBDIR) ||
4221           !strEqual(music_set,    MUS_CLASSIC_SUBDIR));
4222 }
4223
4224 boolean UpdateUserLevelSet(char *level_subdir, char *level_name,
4225                            char *level_author, int num_levels)
4226 {
4227   char *filename = getPath2(getUserLevelDir(level_subdir), LEVELINFO_FILENAME);
4228   char *filename_tmp = getStringCat2(filename, ".tmp");
4229   FILE *file = NULL;
4230   FILE *file_tmp = NULL;
4231   char line[MAX_LINE_LEN];
4232   boolean success = FALSE;
4233   LevelDirTree *leveldir = getTreeInfoFromIdentifier(leveldir_first,
4234                                                      level_subdir);
4235   // update values in level directory tree
4236
4237   if (level_name != NULL)
4238     setString(&leveldir->name, level_name);
4239
4240   if (level_author != NULL)
4241     setString(&leveldir->author, level_author);
4242
4243   if (num_levels != -1)
4244     leveldir->levels = num_levels;
4245
4246   // update values that depend on other values
4247
4248   setString(&leveldir->name_sorting, leveldir->name);
4249
4250   leveldir->last_level = leveldir->first_level + leveldir->levels - 1;
4251
4252   // sort order of level sets may have changed
4253   sortTreeInfo(&leveldir_first);
4254
4255   if ((file     = fopen(filename,     MODE_READ)) &&
4256       (file_tmp = fopen(filename_tmp, MODE_WRITE)))
4257   {
4258     while (fgets(line, MAX_LINE_LEN, file))
4259     {
4260       if (strPrefix(line, "name:") && level_name != NULL)
4261         fprintf(file_tmp, "%-32s%s\n", "name:", level_name);
4262       else if (strPrefix(line, "author:") && level_author != NULL)
4263         fprintf(file_tmp, "%-32s%s\n", "author:", level_author);
4264       else if (strPrefix(line, "levels:") && num_levels != -1)
4265         fprintf(file_tmp, "%-32s%d\n", "levels:", num_levels);
4266       else
4267         fputs(line, file_tmp);
4268     }
4269
4270     success = TRUE;
4271   }
4272
4273   if (file)
4274     fclose(file);
4275
4276   if (file_tmp)
4277     fclose(file_tmp);
4278
4279   if (success)
4280     success = (rename(filename_tmp, filename) == 0);
4281
4282   free(filename);
4283   free(filename_tmp);
4284
4285   return success;
4286 }
4287
4288 boolean CreateUserLevelSet(char *level_subdir, char *level_name,
4289                            char *level_author, int num_levels,
4290                            boolean use_artwork_set)
4291 {
4292   LevelDirTree *level_info;
4293   char *filename;
4294   FILE *file;
4295   int i;
4296
4297   // create user level sub-directory, if needed
4298   createDirectory(getUserLevelDir(level_subdir), "user level", PERMS_PRIVATE);
4299
4300   filename = getPath2(getUserLevelDir(level_subdir), LEVELINFO_FILENAME);
4301
4302   if (!(file = fopen(filename, MODE_WRITE)))
4303   {
4304     Warn("cannot write level info file '%s'", filename);
4305
4306     free(filename);
4307
4308     return FALSE;
4309   }
4310
4311   level_info = newTreeInfo();
4312
4313   // always start with reliable default values
4314   setTreeInfoToDefaults(level_info, TREE_TYPE_LEVEL_DIR);
4315
4316   setString(&level_info->name, level_name);
4317   setString(&level_info->author, level_author);
4318   level_info->levels = num_levels;
4319   level_info->first_level = 1;
4320   level_info->sort_priority = LEVELCLASS_PRIVATE_START;
4321   level_info->readonly = FALSE;
4322
4323   if (use_artwork_set)
4324   {
4325     level_info->graphics_set =
4326       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS));
4327     level_info->sounds_set =
4328       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_SOUNDS));
4329     level_info->music_set =
4330       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_MUSIC));
4331   }
4332
4333   token_value_position = TOKEN_VALUE_POSITION_SHORT;
4334
4335   fprintFileHeader(file, LEVELINFO_FILENAME);
4336
4337   ldi = *level_info;
4338   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
4339   {
4340     if (i == LEVELINFO_TOKEN_NAME ||
4341         i == LEVELINFO_TOKEN_AUTHOR ||
4342         i == LEVELINFO_TOKEN_LEVELS ||
4343         i == LEVELINFO_TOKEN_FIRST_LEVEL ||
4344         i == LEVELINFO_TOKEN_SORT_PRIORITY ||
4345         i == LEVELINFO_TOKEN_READONLY ||
4346         (use_artwork_set && (i == LEVELINFO_TOKEN_GRAPHICS_SET ||
4347                              i == LEVELINFO_TOKEN_SOUNDS_SET ||
4348                              i == LEVELINFO_TOKEN_MUSIC_SET)))
4349       fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
4350
4351     // just to make things nicer :)
4352     if (i == LEVELINFO_TOKEN_AUTHOR ||
4353         i == LEVELINFO_TOKEN_FIRST_LEVEL ||
4354         (use_artwork_set && i == LEVELINFO_TOKEN_READONLY))
4355       fprintf(file, "\n");
4356   }
4357
4358   token_value_position = TOKEN_VALUE_POSITION_DEFAULT;
4359
4360   fclose(file);
4361
4362   SetFilePermissions(filename, PERMS_PRIVATE);
4363
4364   freeTreeInfo(level_info);
4365   free(filename);
4366
4367   return TRUE;
4368 }
4369
4370 static void SaveUserLevelInfo(void)
4371 {
4372   CreateUserLevelSet(getLoginName(), getLoginName(), getRealName(), 100, FALSE);
4373 }
4374
4375 char *getSetupValue(int type, void *value)
4376 {
4377   static char value_string[MAX_LINE_LEN];
4378
4379   if (value == NULL)
4380     return NULL;
4381
4382   switch (type)
4383   {
4384     case TYPE_BOOLEAN:
4385       strcpy(value_string, (*(boolean *)value ? "true" : "false"));
4386       break;
4387
4388     case TYPE_SWITCH:
4389       strcpy(value_string, (*(boolean *)value ? "on" : "off"));
4390       break;
4391
4392     case TYPE_SWITCH3:
4393       strcpy(value_string, (*(int *)value == AUTO  ? "auto" :
4394                             *(int *)value == FALSE ? "off" : "on"));
4395       break;
4396
4397     case TYPE_YES_NO:
4398       strcpy(value_string, (*(boolean *)value ? "yes" : "no"));
4399       break;
4400
4401     case TYPE_YES_NO_AUTO:
4402       strcpy(value_string, (*(int *)value == AUTO  ? "auto" :
4403                             *(int *)value == FALSE ? "no" : "yes"));
4404       break;
4405
4406     case TYPE_ECS_AGA:
4407       strcpy(value_string, (*(boolean *)value ? "AGA" : "ECS"));
4408       break;
4409
4410     case TYPE_KEY:
4411       strcpy(value_string, getKeyNameFromKey(*(Key *)value));
4412       break;
4413
4414     case TYPE_KEY_X11:
4415       strcpy(value_string, getX11KeyNameFromKey(*(Key *)value));
4416       break;
4417
4418     case TYPE_INTEGER:
4419       sprintf(value_string, "%d", *(int *)value);
4420       break;
4421
4422     case TYPE_STRING:
4423       if (*(char **)value == NULL)
4424         return NULL;
4425
4426       strcpy(value_string, *(char **)value);
4427       break;
4428
4429     case TYPE_PLAYER:
4430       sprintf(value_string, "player_%d", *(int *)value + 1);
4431       break;
4432
4433     default:
4434       value_string[0] = '\0';
4435       break;
4436   }
4437
4438   if (type & TYPE_GHOSTED)
4439     strcpy(value_string, "n/a");
4440
4441   return value_string;
4442 }
4443
4444 char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
4445 {
4446   int i;
4447   char *line;
4448   static char token_string[MAX_LINE_LEN];
4449   int token_type = token_info[token_nr].type;
4450   void *setup_value = token_info[token_nr].value;
4451   char *token_text = token_info[token_nr].text;
4452   char *value_string = getSetupValue(token_type, setup_value);
4453
4454   // build complete token string
4455   sprintf(token_string, "%s%s", prefix, token_text);
4456
4457   // build setup entry line
4458   line = getFormattedSetupEntry(token_string, value_string);
4459
4460   if (token_type == TYPE_KEY_X11)
4461   {
4462     Key key = *(Key *)setup_value;
4463     char *keyname = getKeyNameFromKey(key);
4464
4465     // add comment, if useful
4466     if (!strEqual(keyname, "(undefined)") &&
4467         !strEqual(keyname, "(unknown)"))
4468     {
4469       // add at least one whitespace
4470       strcat(line, " ");
4471       for (i = strlen(line); i < token_comment_position; i++)
4472         strcat(line, " ");
4473
4474       strcat(line, "# ");
4475       strcat(line, keyname);
4476     }
4477   }
4478
4479   return line;
4480 }
4481
4482 static void InitLastPlayedLevels_ParentNode(void)
4483 {
4484   LevelDirTree **leveldir_top = &leveldir_first->node_group->next;
4485   LevelDirTree *leveldir_new = NULL;
4486
4487   // check if parent node for last played levels already exists
4488   if (strEqual((*leveldir_top)->identifier, TOKEN_STR_LAST_LEVEL_SERIES))
4489     return;
4490
4491   leveldir_new = newTreeInfo();
4492
4493   setTreeInfoToDefaultsFromParent(leveldir_new, leveldir_first);
4494
4495   leveldir_new->level_group = TRUE;
4496
4497   setString(&leveldir_new->identifier, TOKEN_STR_LAST_LEVEL_SERIES);
4498   setString(&leveldir_new->name, "<< (last played level sets)");
4499
4500   pushTreeInfo(leveldir_top, leveldir_new);
4501
4502   // create node to link back to current level directory
4503   createParentTreeInfoNode(leveldir_new);
4504 }
4505
4506 void UpdateLastPlayedLevels_TreeInfo(void)
4507 {
4508   char **last_level_series = setup.level_setup.last_level_series;
4509   boolean reset_leveldir_current = FALSE;
4510   LevelDirTree *leveldir_last;
4511   TreeInfo **node_new = NULL;
4512   int i;
4513
4514   if (last_level_series[0] == NULL)
4515     return;
4516
4517   InitLastPlayedLevels_ParentNode();
4518
4519   // check if current level set is from "last played" sub-tree to be rebuilt
4520   reset_leveldir_current = strEqual(leveldir_current->node_parent->identifier,
4521                                     TOKEN_STR_LAST_LEVEL_SERIES);
4522
4523   leveldir_last = getTreeInfoFromIdentifierExt(leveldir_first,
4524                                                TOKEN_STR_LAST_LEVEL_SERIES,
4525                                                TRUE);
4526   if (leveldir_last == NULL)
4527     return;
4528
4529   node_new = &leveldir_last->node_group->next;
4530
4531   freeTreeInfo(*node_new);
4532
4533   for (i = 0; last_level_series[i] != NULL; i++)
4534   {
4535     LevelDirTree *node_last = getTreeInfoFromIdentifier(leveldir_first,
4536                                                         last_level_series[i]);
4537
4538     *node_new = getTreeInfoCopy(node_last);     // copy complete node
4539
4540     (*node_new)->node_top = &leveldir_first;    // correct top node link
4541     (*node_new)->node_parent = leveldir_last;   // correct parent node link
4542
4543     (*node_new)->node_group = NULL;
4544     (*node_new)->next = NULL;
4545
4546     (*node_new)->cl_first = -1;                 // force setting tree cursor
4547
4548     node_new = &((*node_new)->next);
4549   }
4550
4551   if (reset_leveldir_current)
4552     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4553                                                  last_level_series[0]);
4554 }
4555
4556 static void UpdateLastPlayedLevels_List(void)
4557 {
4558   char **last_level_series = setup.level_setup.last_level_series;
4559   int pos = MAX_LEVELDIR_HISTORY - 1;
4560   int i;
4561
4562   // search for potentially already existing entry in list of level sets
4563   for (i = 0; last_level_series[i] != NULL; i++)
4564     if (strEqual(last_level_series[i], leveldir_current->identifier))
4565       pos = i;
4566
4567   // move list of level sets one entry down (using potentially free entry)
4568   for (i = pos; i > 0; i--)
4569     setString(&last_level_series[i], last_level_series[i - 1]);
4570
4571   // put last played level set at top position
4572   setString(&last_level_series[0], leveldir_current->identifier);
4573 }
4574
4575 void LoadLevelSetup_LastSeries(void)
4576 {
4577   // --------------------------------------------------------------------------
4578   // ~/.<program>/levelsetup.conf
4579   // --------------------------------------------------------------------------
4580
4581   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
4582   SetupFileHash *level_setup_hash = NULL;
4583   int pos = 0;
4584   int i;
4585
4586   // always start with reliable default values
4587   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4588
4589   // start with empty history of last played level sets
4590   setString(&setup.level_setup.last_level_series[0], NULL);
4591
4592   if (!strEqual(DEFAULT_LEVELSET, UNDEFINED_LEVELSET))
4593   {
4594     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4595                                                  DEFAULT_LEVELSET);
4596     if (leveldir_current == NULL)
4597       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4598   }
4599
4600   if ((level_setup_hash = loadSetupFileHash(filename)))
4601   {
4602     char *last_level_series =
4603       getHashEntry(level_setup_hash, TOKEN_STR_LAST_LEVEL_SERIES);
4604
4605     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4606                                                  last_level_series);
4607     if (leveldir_current == NULL)
4608       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4609
4610     for (i = 0; i < MAX_LEVELDIR_HISTORY; i++)
4611     {
4612       char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
4613       LevelDirTree *leveldir_last;
4614
4615       sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
4616
4617       last_level_series = getHashEntry(level_setup_hash, token);
4618
4619       leveldir_last = getTreeInfoFromIdentifier(leveldir_first,
4620                                                 last_level_series);
4621       if (leveldir_last != NULL)
4622         setString(&setup.level_setup.last_level_series[pos++],
4623                   last_level_series);
4624     }
4625
4626     setString(&setup.level_setup.last_level_series[pos], NULL);
4627
4628     freeSetupFileHash(level_setup_hash);
4629   }
4630   else
4631   {
4632     Debug("setup", "using default setup values");
4633   }
4634
4635   free(filename);
4636 }
4637
4638 static void SaveLevelSetup_LastSeries_Ext(boolean deactivate_last_level_series)
4639 {
4640   // --------------------------------------------------------------------------
4641   // ~/.<program>/levelsetup.conf
4642   // --------------------------------------------------------------------------
4643
4644   // check if the current level directory structure is available at this point
4645   if (leveldir_current == NULL)
4646     return;
4647
4648   char **last_level_series = setup.level_setup.last_level_series;
4649   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
4650   FILE *file;
4651   int i;
4652
4653   InitUserDataDirectory();
4654
4655   UpdateLastPlayedLevels_List();
4656
4657   if (!(file = fopen(filename, MODE_WRITE)))
4658   {
4659     Warn("cannot write setup file '%s'", filename);
4660
4661     free(filename);
4662
4663     return;
4664   }
4665
4666   fprintFileHeader(file, LEVELSETUP_FILENAME);
4667
4668   if (deactivate_last_level_series)
4669     fprintf(file, "# %s\n# ", "the following level set may have caused a problem and was deactivated");
4670
4671   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES,
4672                                                leveldir_current->identifier));
4673
4674   for (i = 0; last_level_series[i] != NULL; i++)
4675   {
4676     char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
4677
4678     sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
4679
4680     fprintf(file, "%s\n", getFormattedSetupEntry(token, last_level_series[i]));
4681   }
4682
4683   fclose(file);
4684
4685   SetFilePermissions(filename, PERMS_PRIVATE);
4686
4687   free(filename);
4688 }
4689
4690 void SaveLevelSetup_LastSeries(void)
4691 {
4692   SaveLevelSetup_LastSeries_Ext(FALSE);
4693 }
4694
4695 void SaveLevelSetup_LastSeries_Deactivate(void)
4696 {
4697   SaveLevelSetup_LastSeries_Ext(TRUE);
4698 }
4699
4700 static void checkSeriesInfo(void)
4701 {
4702   static char *level_directory = NULL;
4703   Directory *dir;
4704 #if 0
4705   DirectoryEntry *dir_entry;
4706 #endif
4707
4708   checked_free(level_directory);
4709
4710   // check for more levels besides the 'levels' field of 'levelinfo.conf'
4711
4712   level_directory = getPath2((leveldir_current->in_user_dir ?
4713                               getUserLevelDir(NULL) :
4714                               options.level_directory),
4715                              leveldir_current->fullpath);
4716
4717   if ((dir = openDirectory(level_directory)) == NULL)
4718   {
4719     Warn("cannot read level directory '%s'", level_directory);
4720
4721     return;
4722   }
4723
4724 #if 0
4725   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
4726   {
4727     if (strlen(dir_entry->basename) > 4 &&
4728         dir_entry->basename[3] == '.' &&
4729         strEqual(&dir_entry->basename[4], LEVELFILE_EXTENSION))
4730     {
4731       char levelnum_str[4];
4732       int levelnum_value;
4733
4734       strncpy(levelnum_str, dir_entry->basename, 3);
4735       levelnum_str[3] = '\0';
4736
4737       levelnum_value = atoi(levelnum_str);
4738
4739       if (levelnum_value < leveldir_current->first_level)
4740       {
4741         Warn("additional level %d found", levelnum_value);
4742
4743         leveldir_current->first_level = levelnum_value;
4744       }
4745       else if (levelnum_value > leveldir_current->last_level)
4746       {
4747         Warn("additional level %d found", levelnum_value);
4748
4749         leveldir_current->last_level = levelnum_value;
4750       }
4751     }
4752   }
4753 #endif
4754
4755   closeDirectory(dir);
4756 }
4757
4758 void LoadLevelSetup_SeriesInfo(void)
4759 {
4760   char *filename;
4761   SetupFileHash *level_setup_hash = NULL;
4762   char *level_subdir = leveldir_current->subdir;
4763   int i;
4764
4765   // always start with reliable default values
4766   level_nr = leveldir_current->first_level;
4767
4768   for (i = 0; i < MAX_LEVELS; i++)
4769   {
4770     LevelStats_setPlayed(i, 0);
4771     LevelStats_setSolved(i, 0);
4772   }
4773
4774   checkSeriesInfo();
4775
4776   // --------------------------------------------------------------------------
4777   // ~/.<program>/levelsetup/<level series>/levelsetup.conf
4778   // --------------------------------------------------------------------------
4779
4780   level_subdir = leveldir_current->subdir;
4781
4782   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
4783
4784   if ((level_setup_hash = loadSetupFileHash(filename)))
4785   {
4786     char *token_value;
4787
4788     // get last played level in this level set
4789
4790     token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL);
4791
4792     if (token_value)
4793     {
4794       level_nr = atoi(token_value);
4795
4796       if (level_nr < leveldir_current->first_level)
4797         level_nr = leveldir_current->first_level;
4798       if (level_nr > leveldir_current->last_level)
4799         level_nr = leveldir_current->last_level;
4800     }
4801
4802     // get handicap level in this level set
4803
4804     token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL);
4805
4806     if (token_value)
4807     {
4808       int level_nr = atoi(token_value);
4809
4810       if (level_nr < leveldir_current->first_level)
4811         level_nr = leveldir_current->first_level;
4812       if (level_nr > leveldir_current->last_level + 1)
4813         level_nr = leveldir_current->last_level;
4814
4815       if (leveldir_current->user_defined || !leveldir_current->handicap)
4816         level_nr = leveldir_current->last_level;
4817
4818       leveldir_current->handicap_level = level_nr;
4819     }
4820
4821     // get number of played and solved levels in this level set
4822
4823     BEGIN_HASH_ITERATION(level_setup_hash, itr)
4824     {
4825       char *token = HASH_ITERATION_TOKEN(itr);
4826       char *value = HASH_ITERATION_VALUE(itr);
4827
4828       if (strlen(token) == 3 &&
4829           token[0] >= '0' && token[0] <= '9' &&
4830           token[1] >= '0' && token[1] <= '9' &&
4831           token[2] >= '0' && token[2] <= '9')
4832       {
4833         int level_nr = atoi(token);
4834
4835         if (value != NULL)
4836           LevelStats_setPlayed(level_nr, atoi(value));  // read 1st column
4837
4838         value = strchr(value, ' ');
4839
4840         if (value != NULL)
4841           LevelStats_setSolved(level_nr, atoi(value));  // read 2nd column
4842       }
4843     }
4844     END_HASH_ITERATION(hash, itr)
4845
4846     freeSetupFileHash(level_setup_hash);
4847   }
4848   else
4849   {
4850     Debug("setup", "using default setup values");
4851   }
4852
4853   free(filename);
4854 }
4855
4856 void SaveLevelSetup_SeriesInfo(void)
4857 {
4858   char *filename;
4859   char *level_subdir = leveldir_current->subdir;
4860   char *level_nr_str = int2str(level_nr, 0);
4861   char *handicap_level_str = int2str(leveldir_current->handicap_level, 0);
4862   FILE *file;
4863   int i;
4864
4865   // --------------------------------------------------------------------------
4866   // ~/.<program>/levelsetup/<level series>/levelsetup.conf
4867   // --------------------------------------------------------------------------
4868
4869   InitLevelSetupDirectory(level_subdir);
4870
4871   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
4872
4873   if (!(file = fopen(filename, MODE_WRITE)))
4874   {
4875     Warn("cannot write setup file '%s'", filename);
4876
4877     free(filename);
4878
4879     return;
4880   }
4881
4882   fprintFileHeader(file, LEVELSETUP_FILENAME);
4883
4884   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_PLAYED_LEVEL,
4885                                                level_nr_str));
4886   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL,
4887                                                  handicap_level_str));
4888
4889   for (i = leveldir_current->first_level; i <= leveldir_current->last_level;
4890        i++)
4891   {
4892     if (LevelStats_getPlayed(i) > 0 ||
4893         LevelStats_getSolved(i) > 0)
4894     {
4895       char token[16];
4896       char value[16];
4897
4898       sprintf(token, "%03d", i);
4899       sprintf(value, "%d %d", LevelStats_getPlayed(i), LevelStats_getSolved(i));
4900
4901       fprintf(file, "%s\n", getFormattedSetupEntry(token, value));
4902     }
4903   }
4904
4905   fclose(file);
4906
4907   SetFilePermissions(filename, PERMS_PRIVATE);
4908
4909   free(filename);
4910 }
4911
4912 int LevelStats_getPlayed(int nr)
4913 {
4914   return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].played : 0);
4915 }
4916
4917 int LevelStats_getSolved(int nr)
4918 {
4919   return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].solved : 0);
4920 }
4921
4922 void LevelStats_setPlayed(int nr, int value)
4923 {
4924   if (nr >= 0 && nr < MAX_LEVELS)
4925     level_stats[nr].played = value;
4926 }
4927
4928 void LevelStats_setSolved(int nr, int value)
4929 {
4930   if (nr >= 0 && nr < MAX_LEVELS)
4931     level_stats[nr].solved = value;
4932 }
4933
4934 void LevelStats_incPlayed(int nr)
4935 {
4936   if (nr >= 0 && nr < MAX_LEVELS)
4937     level_stats[nr].played++;
4938 }
4939
4940 void LevelStats_incSolved(int nr)
4941 {
4942   if (nr >= 0 && nr < MAX_LEVELS)
4943     level_stats[nr].solved++;
4944 }
4945
4946 void LoadUserSetup(void)
4947 {
4948   // --------------------------------------------------------------------------
4949   // ~/.<program>/usersetup.conf
4950   // --------------------------------------------------------------------------
4951
4952   char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
4953   SetupFileHash *user_setup_hash = NULL;
4954
4955   // always start with reliable default values
4956   user.nr = 0;
4957
4958   if ((user_setup_hash = loadSetupFileHash(filename)))
4959   {
4960     char *token_value;
4961
4962     // get last selected user number
4963     token_value = getHashEntry(user_setup_hash, TOKEN_STR_LAST_USER);
4964
4965     if (token_value)
4966       user.nr = MIN(MAX(0, atoi(token_value)), MAX_PLAYER_NAMES - 1);
4967
4968     freeSetupFileHash(user_setup_hash);
4969   }
4970   else
4971   {
4972     Debug("setup", "using default setup values");
4973   }
4974
4975   free(filename);
4976 }
4977
4978 void SaveUserSetup(void)
4979 {
4980   // --------------------------------------------------------------------------
4981   // ~/.<program>/usersetup.conf
4982   // --------------------------------------------------------------------------
4983
4984   char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
4985   FILE *file;
4986
4987   InitMainUserDataDirectory();
4988
4989   if (!(file = fopen(filename, MODE_WRITE)))
4990   {
4991     Warn("cannot write setup file '%s'", filename);
4992
4993     free(filename);
4994
4995     return;
4996   }
4997
4998   fprintFileHeader(file, USERSETUP_FILENAME);
4999
5000   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_USER,
5001                                                i_to_a(user.nr)));
5002   fclose(file);
5003
5004   SetFilePermissions(filename, PERMS_PRIVATE);
5005
5006   free(filename);
5007 }