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_EMSCRIPTEN)
1515   dir = "/persistent";
1516 #elif defined(PLATFORM_UNIX)
1517   if (dir == NULL)
1518   {
1519     if ((dir = getenv("HOME")) == NULL)
1520     {
1521       dir = getUnixHomeDir();
1522
1523       if (dir != NULL)
1524         dir = getStringCopy(dir);
1525       else
1526         dir = ".";
1527     }
1528   }
1529 #else
1530   dir = ".";
1531 #endif
1532
1533   return dir;
1534 }
1535
1536 char *getCommonDataDir(void)
1537 {
1538   static char *common_data_dir = NULL;
1539
1540 #if defined(PLATFORM_WIN32)
1541   if (common_data_dir == NULL)
1542   {
1543     char *dir = checked_malloc(MAX_PATH + 1);
1544
1545     if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, dir))
1546         && !strEqual(dir, ""))          // empty for Windows 95/98
1547       common_data_dir = getPath2(dir, program.userdata_subdir);
1548     else
1549       common_data_dir = options.rw_base_directory;
1550   }
1551 #else
1552   if (common_data_dir == NULL)
1553     common_data_dir = options.rw_base_directory;
1554 #endif
1555
1556   return common_data_dir;
1557 }
1558
1559 char *getPersonalDataDir(void)
1560 {
1561   static char *personal_data_dir = NULL;
1562
1563 #if defined(PLATFORM_MACOSX)
1564   if (personal_data_dir == NULL)
1565     personal_data_dir = getPath2(getHomeDir(), "Documents");
1566 #else
1567   if (personal_data_dir == NULL)
1568     personal_data_dir = getHomeDir();
1569 #endif
1570
1571   return personal_data_dir;
1572 }
1573
1574 char *getMainUserGameDataDir(void)
1575 {
1576   static char *main_user_data_dir = NULL;
1577
1578 #if defined(PLATFORM_ANDROID)
1579   if (main_user_data_dir == NULL)
1580     main_user_data_dir = (char *)(SDL_AndroidGetExternalStorageState() &
1581                                   SDL_ANDROID_EXTERNAL_STORAGE_WRITE ?
1582                                   SDL_AndroidGetExternalStoragePath() :
1583                                   SDL_AndroidGetInternalStoragePath());
1584 #else
1585   if (main_user_data_dir == NULL)
1586     main_user_data_dir = getPath2(getPersonalDataDir(),
1587                                   program.userdata_subdir);
1588 #endif
1589
1590   return main_user_data_dir;
1591 }
1592
1593 char *getUserGameDataDir(void)
1594 {
1595   if (user.nr == 0)
1596     return getMainUserGameDataDir();
1597   else
1598     return getUserDir(user.nr);
1599 }
1600
1601 char *getSetupDir(void)
1602 {
1603   return getUserGameDataDir();
1604 }
1605
1606 static mode_t posix_umask(mode_t mask)
1607 {
1608 #if defined(PLATFORM_UNIX)
1609   return umask(mask);
1610 #else
1611   return 0;
1612 #endif
1613 }
1614
1615 static int posix_mkdir(const char *pathname, mode_t mode)
1616 {
1617 #if defined(PLATFORM_WIN32)
1618   return mkdir(pathname);
1619 #else
1620   return mkdir(pathname, mode);
1621 #endif
1622 }
1623
1624 static boolean posix_process_running_setgid(void)
1625 {
1626 #if defined(PLATFORM_UNIX)
1627   return (getgid() != getegid());
1628 #else
1629   return FALSE;
1630 #endif
1631 }
1632
1633 void createDirectory(char *dir, char *text, int permission_class)
1634 {
1635   if (directoryExists(dir))
1636     return;
1637
1638   // leave "other" permissions in umask untouched, but ensure group parts
1639   // of USERDATA_DIR_MODE are not masked
1640   mode_t dir_mode = (permission_class == PERMS_PRIVATE ?
1641                      DIR_PERMS_PRIVATE : DIR_PERMS_PUBLIC);
1642   mode_t last_umask = posix_umask(0);
1643   mode_t group_umask = ~(dir_mode & S_IRWXG);
1644   int running_setgid = posix_process_running_setgid();
1645
1646   if (permission_class == PERMS_PUBLIC)
1647   {
1648     // if we're setgid, protect files against "other"
1649     // else keep umask(0) to make the dir world-writable
1650
1651     if (running_setgid)
1652       posix_umask(last_umask & group_umask);
1653     else
1654       dir_mode = DIR_PERMS_PUBLIC_ALL;
1655   }
1656
1657   if (posix_mkdir(dir, dir_mode) != 0)
1658     Warn("cannot create %s directory '%s': %s", text, dir, strerror(errno));
1659
1660   if (permission_class == PERMS_PUBLIC && !running_setgid)
1661     chmod(dir, dir_mode);
1662
1663   posix_umask(last_umask);              // restore previous umask
1664 }
1665
1666 void InitMainUserDataDirectory(void)
1667 {
1668   createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
1669 }
1670
1671 void InitUserDataDirectory(void)
1672 {
1673   createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
1674
1675   if (user.nr != 0)
1676   {
1677     createDirectory(getUserDir(-1), "users", PERMS_PRIVATE);
1678     createDirectory(getUserDir(user.nr), "user data", PERMS_PRIVATE);
1679   }
1680 }
1681
1682 void SetFilePermissions(char *filename, int permission_class)
1683 {
1684   int running_setgid = posix_process_running_setgid();
1685   int perms = (permission_class == PERMS_PRIVATE ?
1686                FILE_PERMS_PRIVATE : FILE_PERMS_PUBLIC);
1687
1688   if (permission_class == PERMS_PUBLIC && !running_setgid)
1689     perms = FILE_PERMS_PUBLIC_ALL;
1690
1691   chmod(filename, perms);
1692 }
1693
1694 char *getCookie(char *file_type)
1695 {
1696   static char cookie[MAX_COOKIE_LEN + 1];
1697
1698   if (strlen(program.cookie_prefix) + 1 +
1699       strlen(file_type) + strlen("_FILE_VERSION_x.x") > MAX_COOKIE_LEN)
1700     return "[COOKIE ERROR]";    // should never happen
1701
1702   sprintf(cookie, "%s_%s_FILE_VERSION_%d.%d",
1703           program.cookie_prefix, file_type,
1704           program.version_super, program.version_major);
1705
1706   return cookie;
1707 }
1708
1709 void fprintFileHeader(FILE *file, char *basename)
1710 {
1711   char *prefix = "# ";
1712   char *sep1 = "=";
1713
1714   fprintf_line_with_prefix(file, prefix, sep1, 77);
1715   fprintf(file, "%s%s\n", prefix, basename);
1716   fprintf_line_with_prefix(file, prefix, sep1, 77);
1717   fprintf(file, "\n");
1718 }
1719
1720 int getFileVersionFromCookieString(const char *cookie)
1721 {
1722   const char *ptr_cookie1, *ptr_cookie2;
1723   const char *pattern1 = "_FILE_VERSION_";
1724   const char *pattern2 = "?.?";
1725   const int len_cookie = strlen(cookie);
1726   const int len_pattern1 = strlen(pattern1);
1727   const int len_pattern2 = strlen(pattern2);
1728   const int len_pattern = len_pattern1 + len_pattern2;
1729   int version_super, version_major;
1730
1731   if (len_cookie <= len_pattern)
1732     return -1;
1733
1734   ptr_cookie1 = &cookie[len_cookie - len_pattern];
1735   ptr_cookie2 = &cookie[len_cookie - len_pattern2];
1736
1737   if (strncmp(ptr_cookie1, pattern1, len_pattern1) != 0)
1738     return -1;
1739
1740   if (ptr_cookie2[0] < '0' || ptr_cookie2[0] > '9' ||
1741       ptr_cookie2[1] != '.' ||
1742       ptr_cookie2[2] < '0' || ptr_cookie2[2] > '9')
1743     return -1;
1744
1745   version_super = ptr_cookie2[0] - '0';
1746   version_major = ptr_cookie2[2] - '0';
1747
1748   return VERSION_IDENT(version_super, version_major, 0, 0);
1749 }
1750
1751 boolean checkCookieString(const char *cookie, const char *template)
1752 {
1753   const char *pattern = "_FILE_VERSION_?.?";
1754   const int len_cookie = strlen(cookie);
1755   const int len_template = strlen(template);
1756   const int len_pattern = strlen(pattern);
1757
1758   if (len_cookie != len_template)
1759     return FALSE;
1760
1761   if (strncmp(cookie, template, len_cookie - len_pattern) != 0)
1762     return FALSE;
1763
1764   return TRUE;
1765 }
1766
1767
1768 // ----------------------------------------------------------------------------
1769 // setup file list and hash handling functions
1770 // ----------------------------------------------------------------------------
1771
1772 char *getFormattedSetupEntry(char *token, char *value)
1773 {
1774   int i;
1775   static char entry[MAX_LINE_LEN];
1776
1777   // if value is an empty string, just return token without value
1778   if (*value == '\0')
1779     return token;
1780
1781   // start with the token and some spaces to format output line
1782   sprintf(entry, "%s:", token);
1783   for (i = strlen(entry); i < token_value_position; i++)
1784     strcat(entry, " ");
1785
1786   // continue with the token's value
1787   strcat(entry, value);
1788
1789   return entry;
1790 }
1791
1792 SetupFileList *newSetupFileList(char *token, char *value)
1793 {
1794   SetupFileList *new = checked_malloc(sizeof(SetupFileList));
1795
1796   new->token = getStringCopy(token);
1797   new->value = getStringCopy(value);
1798
1799   new->next = NULL;
1800
1801   return new;
1802 }
1803
1804 void freeSetupFileList(SetupFileList *list)
1805 {
1806   if (list == NULL)
1807     return;
1808
1809   checked_free(list->token);
1810   checked_free(list->value);
1811
1812   if (list->next)
1813     freeSetupFileList(list->next);
1814
1815   free(list);
1816 }
1817
1818 char *getListEntry(SetupFileList *list, char *token)
1819 {
1820   if (list == NULL)
1821     return NULL;
1822
1823   if (strEqual(list->token, token))
1824     return list->value;
1825   else
1826     return getListEntry(list->next, token);
1827 }
1828
1829 SetupFileList *setListEntry(SetupFileList *list, char *token, char *value)
1830 {
1831   if (list == NULL)
1832     return NULL;
1833
1834   if (strEqual(list->token, token))
1835   {
1836     checked_free(list->value);
1837
1838     list->value = getStringCopy(value);
1839
1840     return list;
1841   }
1842   else if (list->next == NULL)
1843     return (list->next = newSetupFileList(token, value));
1844   else
1845     return setListEntry(list->next, token, value);
1846 }
1847
1848 SetupFileList *addListEntry(SetupFileList *list, char *token, char *value)
1849 {
1850   if (list == NULL)
1851     return NULL;
1852
1853   if (list->next == NULL)
1854     return (list->next = newSetupFileList(token, value));
1855   else
1856     return addListEntry(list->next, token, value);
1857 }
1858
1859 #if ENABLE_UNUSED_CODE
1860 #ifdef DEBUG
1861 static void printSetupFileList(SetupFileList *list)
1862 {
1863   if (!list)
1864     return;
1865
1866   Debug("setup:printSetupFileList", "token: '%s'", list->token);
1867   Debug("setup:printSetupFileList", "value: '%s'", list->value);
1868
1869   printSetupFileList(list->next);
1870 }
1871 #endif
1872 #endif
1873
1874 #ifdef DEBUG
1875 DEFINE_HASHTABLE_INSERT(insert_hash_entry, char, char);
1876 DEFINE_HASHTABLE_SEARCH(search_hash_entry, char, char);
1877 DEFINE_HASHTABLE_CHANGE(change_hash_entry, char, char);
1878 DEFINE_HASHTABLE_REMOVE(remove_hash_entry, char, char);
1879 #else
1880 #define insert_hash_entry hashtable_insert
1881 #define search_hash_entry hashtable_search
1882 #define change_hash_entry hashtable_change
1883 #define remove_hash_entry hashtable_remove
1884 #endif
1885
1886 unsigned int get_hash_from_key(void *key)
1887 {
1888   /*
1889     djb2
1890
1891     This algorithm (k=33) was first reported by Dan Bernstein many years ago in
1892     'comp.lang.c'. Another version of this algorithm (now favored by Bernstein)
1893     uses XOR: hash(i) = hash(i - 1) * 33 ^ str[i]; the magic of number 33 (why
1894     it works better than many other constants, prime or not) has never been
1895     adequately explained.
1896
1897     If you just want to have a good hash function, and cannot wait, djb2
1898     is one of the best string hash functions i know. It has excellent
1899     distribution and speed on many different sets of keys and table sizes.
1900     You are not likely to do better with one of the "well known" functions
1901     such as PJW, K&R, etc.
1902
1903     Ozan (oz) Yigit [http://www.cs.yorku.ca/~oz/hash.html]
1904   */
1905
1906   char *str = (char *)key;
1907   unsigned int hash = 5381;
1908   int c;
1909
1910   while ((c = *str++))
1911     hash = ((hash << 5) + hash) + c;    // hash * 33 + c
1912
1913   return hash;
1914 }
1915
1916 static int keys_are_equal(void *key1, void *key2)
1917 {
1918   return (strEqual((char *)key1, (char *)key2));
1919 }
1920
1921 SetupFileHash *newSetupFileHash(void)
1922 {
1923   SetupFileHash *new_hash =
1924     create_hashtable(16, 0.75, get_hash_from_key, keys_are_equal);
1925
1926   if (new_hash == NULL)
1927     Fail("create_hashtable() failed -- out of memory");
1928
1929   return new_hash;
1930 }
1931
1932 void freeSetupFileHash(SetupFileHash *hash)
1933 {
1934   if (hash == NULL)
1935     return;
1936
1937   hashtable_destroy(hash, 1);   // 1 == also free values stored in hash
1938 }
1939
1940 char *getHashEntry(SetupFileHash *hash, char *token)
1941 {
1942   if (hash == NULL)
1943     return NULL;
1944
1945   return search_hash_entry(hash, token);
1946 }
1947
1948 void setHashEntry(SetupFileHash *hash, char *token, char *value)
1949 {
1950   char *value_copy;
1951
1952   if (hash == NULL)
1953     return;
1954
1955   value_copy = getStringCopy(value);
1956
1957   // change value; if it does not exist, insert it as new
1958   if (!change_hash_entry(hash, token, value_copy))
1959     if (!insert_hash_entry(hash, getStringCopy(token), value_copy))
1960       Fail("cannot insert into hash -- aborting");
1961 }
1962
1963 char *removeHashEntry(SetupFileHash *hash, char *token)
1964 {
1965   if (hash == NULL)
1966     return NULL;
1967
1968   return remove_hash_entry(hash, token);
1969 }
1970
1971 #if ENABLE_UNUSED_CODE
1972 #if DEBUG
1973 static void printSetupFileHash(SetupFileHash *hash)
1974 {
1975   BEGIN_HASH_ITERATION(hash, itr)
1976   {
1977     Debug("setup:printSetupFileHash", "token: '%s'", HASH_ITERATION_TOKEN(itr));
1978     Debug("setup:printSetupFileHash", "value: '%s'", HASH_ITERATION_VALUE(itr));
1979   }
1980   END_HASH_ITERATION(hash, itr)
1981 }
1982 #endif
1983 #endif
1984
1985 #define ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE            1
1986 #define CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING            0
1987 #define CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH             0
1988
1989 static boolean token_value_separator_found = FALSE;
1990 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
1991 static boolean token_value_separator_warning = FALSE;
1992 #endif
1993 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
1994 static boolean token_already_exists_warning = FALSE;
1995 #endif
1996
1997 static boolean getTokenValueFromSetupLineExt(char *line,
1998                                              char **token_ptr, char **value_ptr,
1999                                              char *filename, char *line_raw,
2000                                              int line_nr,
2001                                              boolean separator_required)
2002 {
2003   static char line_copy[MAX_LINE_LEN + 1], line_raw_copy[MAX_LINE_LEN + 1];
2004   char *token, *value, *line_ptr;
2005
2006   // when externally invoked via ReadTokenValueFromLine(), copy line buffers
2007   if (line_raw == NULL)
2008   {
2009     strncpy(line_copy, line, MAX_LINE_LEN);
2010     line_copy[MAX_LINE_LEN] = '\0';
2011     line = line_copy;
2012
2013     strcpy(line_raw_copy, line_copy);
2014     line_raw = line_raw_copy;
2015   }
2016
2017   // cut trailing comment from input line
2018   for (line_ptr = line; *line_ptr; line_ptr++)
2019   {
2020     if (*line_ptr == '#')
2021     {
2022       *line_ptr = '\0';
2023       break;
2024     }
2025   }
2026
2027   // cut trailing whitespaces from input line
2028   for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
2029     if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
2030       *line_ptr = '\0';
2031
2032   // ignore empty lines
2033   if (*line == '\0')
2034     return FALSE;
2035
2036   // cut leading whitespaces from token
2037   for (token = line; *token; token++)
2038     if (*token != ' ' && *token != '\t')
2039       break;
2040
2041   // start with empty value as reliable default
2042   value = "";
2043
2044   token_value_separator_found = FALSE;
2045
2046   // find end of token to determine start of value
2047   for (line_ptr = token; *line_ptr; line_ptr++)
2048   {
2049     // first look for an explicit token/value separator, like ':' or '='
2050     if (*line_ptr == ':' || *line_ptr == '=')
2051     {
2052       *line_ptr = '\0';                 // terminate token string
2053       value = line_ptr + 1;             // set beginning of value
2054
2055       token_value_separator_found = TRUE;
2056
2057       break;
2058     }
2059   }
2060
2061 #if ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE
2062   // fallback: if no token/value separator found, also allow whitespaces
2063   if (!token_value_separator_found && !separator_required)
2064   {
2065     for (line_ptr = token; *line_ptr; line_ptr++)
2066     {
2067       if (*line_ptr == ' ' || *line_ptr == '\t')
2068       {
2069         *line_ptr = '\0';               // terminate token string
2070         value = line_ptr + 1;           // set beginning of value
2071
2072         token_value_separator_found = TRUE;
2073
2074         break;
2075       }
2076     }
2077
2078 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2079     if (token_value_separator_found)
2080     {
2081       if (!token_value_separator_warning)
2082       {
2083         Debug("setup", "---");
2084
2085         if (filename != NULL)
2086         {
2087           Debug("setup", "missing token/value separator(s) in config file:");
2088           Debug("setup", "- config file: '%s'", filename);
2089         }
2090         else
2091         {
2092           Debug("setup", "missing token/value separator(s):");
2093         }
2094
2095         token_value_separator_warning = TRUE;
2096       }
2097
2098       if (filename != NULL)
2099         Debug("setup", "- line %d: '%s'", line_nr, line_raw);
2100       else
2101         Debug("setup", "- line: '%s'", line_raw);
2102     }
2103 #endif
2104   }
2105 #endif
2106
2107   // cut trailing whitespaces from token
2108   for (line_ptr = &token[strlen(token)]; line_ptr >= token; line_ptr--)
2109     if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
2110       *line_ptr = '\0';
2111
2112   // cut leading whitespaces from value
2113   for (; *value; value++)
2114     if (*value != ' ' && *value != '\t')
2115       break;
2116
2117   *token_ptr = token;
2118   *value_ptr = value;
2119
2120   return TRUE;
2121 }
2122
2123 boolean getTokenValueFromSetupLine(char *line, char **token, char **value)
2124 {
2125   // while the internal (old) interface does not require a token/value
2126   // separator (for downwards compatibility with existing files which
2127   // don't use them), it is mandatory for the external (new) interface
2128
2129   return getTokenValueFromSetupLineExt(line, token, value, NULL, NULL, 0, TRUE);
2130 }
2131
2132 static boolean loadSetupFileData(void *setup_file_data, char *filename,
2133                                  boolean top_recursion_level, boolean is_hash)
2134 {
2135   static SetupFileHash *include_filename_hash = NULL;
2136   char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
2137   char *token, *value, *line_ptr;
2138   void *insert_ptr = NULL;
2139   boolean read_continued_line = FALSE;
2140   File *file;
2141   int line_nr = 0, token_count = 0, include_count = 0;
2142
2143 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2144   token_value_separator_warning = FALSE;
2145 #endif
2146
2147 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2148   token_already_exists_warning = FALSE;
2149 #endif
2150
2151   if (!(file = openFile(filename, MODE_READ)))
2152   {
2153 #if DEBUG_NO_CONFIG_FILE
2154     Debug("setup", "cannot open configuration file '%s'", filename);
2155 #endif
2156
2157     return FALSE;
2158   }
2159
2160   // use "insert pointer" to store list end for constant insertion complexity
2161   if (!is_hash)
2162     insert_ptr = setup_file_data;
2163
2164   // on top invocation, create hash to mark included files (to prevent loops)
2165   if (top_recursion_level)
2166     include_filename_hash = newSetupFileHash();
2167
2168   // mark this file as already included (to prevent including it again)
2169   setHashEntry(include_filename_hash, getBaseNamePtr(filename), "true");
2170
2171   while (!checkEndOfFile(file))
2172   {
2173     // read next line of input file
2174     if (!getStringFromFile(file, line, MAX_LINE_LEN))
2175       break;
2176
2177     // check if line was completely read and is terminated by line break
2178     if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
2179       line_nr++;
2180
2181     // cut trailing line break (this can be newline and/or carriage return)
2182     for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
2183       if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
2184         *line_ptr = '\0';
2185
2186     // copy raw input line for later use (mainly debugging output)
2187     strcpy(line_raw, line);
2188
2189     if (read_continued_line)
2190     {
2191       // append new line to existing line, if there is enough space
2192       if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
2193         strcat(previous_line, line_ptr);
2194
2195       strcpy(line, previous_line);      // copy storage buffer to line
2196
2197       read_continued_line = FALSE;
2198     }
2199
2200     // if the last character is '\', continue at next line
2201     if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
2202     {
2203       line[strlen(line) - 1] = '\0';    // cut off trailing backslash
2204       strcpy(previous_line, line);      // copy line to storage buffer
2205
2206       read_continued_line = TRUE;
2207
2208       continue;
2209     }
2210
2211     if (!getTokenValueFromSetupLineExt(line, &token, &value, filename,
2212                                        line_raw, line_nr, FALSE))
2213       continue;
2214
2215     if (*token)
2216     {
2217       if (strEqual(token, "include"))
2218       {
2219         if (getHashEntry(include_filename_hash, value) == NULL)
2220         {
2221           char *basepath = getBasePath(filename);
2222           char *basename = getBaseName(value);
2223           char *filename_include = getPath2(basepath, basename);
2224
2225           loadSetupFileData(setup_file_data, filename_include, FALSE, is_hash);
2226
2227           free(basepath);
2228           free(basename);
2229           free(filename_include);
2230
2231           include_count++;
2232         }
2233         else
2234         {
2235           Warn("ignoring already processed file '%s'", value);
2236         }
2237       }
2238       else
2239       {
2240         if (is_hash)
2241         {
2242 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2243           char *old_value =
2244             getHashEntry((SetupFileHash *)setup_file_data, token);
2245
2246           if (old_value != NULL)
2247           {
2248             if (!token_already_exists_warning)
2249             {
2250               Debug("setup", "---");
2251               Debug("setup", "duplicate token(s) found in config file:");
2252               Debug("setup", "- config file: '%s'", filename);
2253
2254               token_already_exists_warning = TRUE;
2255             }
2256
2257             Debug("setup", "- token: '%s' (in line %d)", token, line_nr);
2258             Debug("setup", "  old value: '%s'", old_value);
2259             Debug("setup", "  new value: '%s'", value);
2260           }
2261 #endif
2262
2263           setHashEntry((SetupFileHash *)setup_file_data, token, value);
2264         }
2265         else
2266         {
2267           insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value);
2268         }
2269
2270         token_count++;
2271       }
2272     }
2273   }
2274
2275   closeFile(file);
2276
2277 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2278   if (token_value_separator_warning)
2279     Debug("setup", "---");
2280 #endif
2281
2282 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2283   if (token_already_exists_warning)
2284     Debug("setup", "---");
2285 #endif
2286
2287   if (token_count == 0 && include_count == 0)
2288     Warn("configuration file '%s' is empty", filename);
2289
2290   if (top_recursion_level)
2291     freeSetupFileHash(include_filename_hash);
2292
2293   return TRUE;
2294 }
2295
2296 static int compareSetupFileData(const void *object1, const void *object2)
2297 {
2298   const struct ConfigInfo *entry1 = (struct ConfigInfo *)object1;
2299   const struct ConfigInfo *entry2 = (struct ConfigInfo *)object2;
2300
2301   return strcmp(entry1->token, entry2->token);
2302 }
2303
2304 static void saveSetupFileHash(SetupFileHash *hash, char *filename)
2305 {
2306   int item_count = hashtable_count(hash);
2307   int item_size = sizeof(struct ConfigInfo);
2308   struct ConfigInfo *sort_array = checked_malloc(item_count * item_size);
2309   FILE *file;
2310   int i = 0;
2311
2312   // copy string pointers from hash to array
2313   BEGIN_HASH_ITERATION(hash, itr)
2314   {
2315     sort_array[i].token = HASH_ITERATION_TOKEN(itr);
2316     sort_array[i].value = HASH_ITERATION_VALUE(itr);
2317
2318     i++;
2319
2320     if (i > item_count)         // should never happen
2321       break;
2322   }
2323   END_HASH_ITERATION(hash, itr)
2324
2325   // sort string pointers from hash in array
2326   qsort(sort_array, item_count, item_size, compareSetupFileData);
2327
2328   if (!(file = fopen(filename, MODE_WRITE)))
2329   {
2330     Warn("cannot write configuration file '%s'", filename);
2331
2332     return;
2333   }
2334
2335   fprintf(file, "%s\n\n", getFormattedSetupEntry("program.version",
2336                                                  program.version_string));
2337   for (i = 0; i < item_count; i++)
2338     fprintf(file, "%s\n", getFormattedSetupEntry(sort_array[i].token,
2339                                                  sort_array[i].value));
2340   fclose(file);
2341
2342   checked_free(sort_array);
2343 }
2344
2345 SetupFileList *loadSetupFileList(char *filename)
2346 {
2347   SetupFileList *setup_file_list = newSetupFileList("", "");
2348   SetupFileList *first_valid_list_entry;
2349
2350   if (!loadSetupFileData(setup_file_list, filename, TRUE, FALSE))
2351   {
2352     freeSetupFileList(setup_file_list);
2353
2354     return NULL;
2355   }
2356
2357   first_valid_list_entry = setup_file_list->next;
2358
2359   // free empty list header
2360   setup_file_list->next = NULL;
2361   freeSetupFileList(setup_file_list);
2362
2363   return first_valid_list_entry;
2364 }
2365
2366 SetupFileHash *loadSetupFileHash(char *filename)
2367 {
2368   SetupFileHash *setup_file_hash = newSetupFileHash();
2369
2370   if (!loadSetupFileData(setup_file_hash, filename, TRUE, TRUE))
2371   {
2372     freeSetupFileHash(setup_file_hash);
2373
2374     return NULL;
2375   }
2376
2377   return setup_file_hash;
2378 }
2379
2380
2381 // ============================================================================
2382 // setup file stuff
2383 // ============================================================================
2384
2385 #define TOKEN_STR_LAST_LEVEL_SERIES             "last_level_series"
2386 #define TOKEN_STR_LAST_PLAYED_LEVEL             "last_played_level"
2387 #define TOKEN_STR_HANDICAP_LEVEL                "handicap_level"
2388 #define TOKEN_STR_LAST_USER                     "last_user"
2389
2390 // level directory info
2391 #define LEVELINFO_TOKEN_IDENTIFIER              0
2392 #define LEVELINFO_TOKEN_NAME                    1
2393 #define LEVELINFO_TOKEN_NAME_SORTING            2
2394 #define LEVELINFO_TOKEN_AUTHOR                  3
2395 #define LEVELINFO_TOKEN_YEAR                    4
2396 #define LEVELINFO_TOKEN_PROGRAM_TITLE           5
2397 #define LEVELINFO_TOKEN_PROGRAM_COPYRIGHT       6
2398 #define LEVELINFO_TOKEN_PROGRAM_COMPANY         7
2399 #define LEVELINFO_TOKEN_IMPORTED_FROM           8
2400 #define LEVELINFO_TOKEN_IMPORTED_BY             9
2401 #define LEVELINFO_TOKEN_TESTED_BY               10
2402 #define LEVELINFO_TOKEN_LEVELS                  11
2403 #define LEVELINFO_TOKEN_FIRST_LEVEL             12
2404 #define LEVELINFO_TOKEN_SORT_PRIORITY           13
2405 #define LEVELINFO_TOKEN_LATEST_ENGINE           14
2406 #define LEVELINFO_TOKEN_LEVEL_GROUP             15
2407 #define LEVELINFO_TOKEN_READONLY                16
2408 #define LEVELINFO_TOKEN_GRAPHICS_SET_ECS        17
2409 #define LEVELINFO_TOKEN_GRAPHICS_SET_AGA        18
2410 #define LEVELINFO_TOKEN_GRAPHICS_SET            19
2411 #define LEVELINFO_TOKEN_SOUNDS_SET_DEFAULT      20
2412 #define LEVELINFO_TOKEN_SOUNDS_SET_LOWPASS      21
2413 #define LEVELINFO_TOKEN_SOUNDS_SET              22
2414 #define LEVELINFO_TOKEN_MUSIC_SET               23
2415 #define LEVELINFO_TOKEN_FILENAME                24
2416 #define LEVELINFO_TOKEN_FILETYPE                25
2417 #define LEVELINFO_TOKEN_SPECIAL_FLAGS           26
2418 #define LEVELINFO_TOKEN_HANDICAP                27
2419 #define LEVELINFO_TOKEN_SKIP_LEVELS             28
2420 #define LEVELINFO_TOKEN_USE_EMC_TILES           29
2421
2422 #define NUM_LEVELINFO_TOKENS                    30
2423
2424 static LevelDirTree ldi;
2425
2426 static struct TokenInfo levelinfo_tokens[] =
2427 {
2428   // level directory info
2429   { TYPE_STRING,        &ldi.identifier,        "identifier"            },
2430   { TYPE_STRING,        &ldi.name,              "name"                  },
2431   { TYPE_STRING,        &ldi.name_sorting,      "name_sorting"          },
2432   { TYPE_STRING,        &ldi.author,            "author"                },
2433   { TYPE_STRING,        &ldi.year,              "year"                  },
2434   { TYPE_STRING,        &ldi.program_title,     "program_title"         },
2435   { TYPE_STRING,        &ldi.program_copyright, "program_copyright"     },
2436   { TYPE_STRING,        &ldi.program_company,   "program_company"       },
2437   { TYPE_STRING,        &ldi.imported_from,     "imported_from"         },
2438   { TYPE_STRING,        &ldi.imported_by,       "imported_by"           },
2439   { TYPE_STRING,        &ldi.tested_by,         "tested_by"             },
2440   { TYPE_INTEGER,       &ldi.levels,            "levels"                },
2441   { TYPE_INTEGER,       &ldi.first_level,       "first_level"           },
2442   { TYPE_INTEGER,       &ldi.sort_priority,     "sort_priority"         },
2443   { TYPE_BOOLEAN,       &ldi.latest_engine,     "latest_engine"         },
2444   { TYPE_BOOLEAN,       &ldi.level_group,       "level_group"           },
2445   { TYPE_BOOLEAN,       &ldi.readonly,          "readonly"              },
2446   { TYPE_STRING,        &ldi.graphics_set_ecs,  "graphics_set.ecs"      },
2447   { TYPE_STRING,        &ldi.graphics_set_aga,  "graphics_set.aga"      },
2448   { TYPE_STRING,        &ldi.graphics_set,      "graphics_set"          },
2449   { TYPE_STRING,        &ldi.sounds_set_default,"sounds_set.default"    },
2450   { TYPE_STRING,        &ldi.sounds_set_lowpass,"sounds_set.lowpass"    },
2451   { TYPE_STRING,        &ldi.sounds_set,        "sounds_set"            },
2452   { TYPE_STRING,        &ldi.music_set,         "music_set"             },
2453   { TYPE_STRING,        &ldi.level_filename,    "filename"              },
2454   { TYPE_STRING,        &ldi.level_filetype,    "filetype"              },
2455   { TYPE_STRING,        &ldi.special_flags,     "special_flags"         },
2456   { TYPE_BOOLEAN,       &ldi.handicap,          "handicap"              },
2457   { TYPE_BOOLEAN,       &ldi.skip_levels,       "skip_levels"           },
2458   { TYPE_BOOLEAN,       &ldi.use_emc_tiles,     "use_emc_tiles"         }
2459 };
2460
2461 static struct TokenInfo artworkinfo_tokens[] =
2462 {
2463   // artwork directory info
2464   { TYPE_STRING,        &ldi.identifier,        "identifier"            },
2465   { TYPE_STRING,        &ldi.subdir,            "subdir"                },
2466   { TYPE_STRING,        &ldi.name,              "name"                  },
2467   { TYPE_STRING,        &ldi.name_sorting,      "name_sorting"          },
2468   { TYPE_STRING,        &ldi.author,            "author"                },
2469   { TYPE_STRING,        &ldi.program_title,     "program_title"         },
2470   { TYPE_STRING,        &ldi.program_copyright, "program_copyright"     },
2471   { TYPE_STRING,        &ldi.program_company,   "program_company"       },
2472   { TYPE_INTEGER,       &ldi.sort_priority,     "sort_priority"         },
2473   { TYPE_STRING,        &ldi.basepath,          "basepath"              },
2474   { TYPE_STRING,        &ldi.fullpath,          "fullpath"              },
2475   { TYPE_BOOLEAN,       &ldi.in_user_dir,       "in_user_dir"           },
2476   { TYPE_STRING,        &ldi.class_desc,        "class_desc"            },
2477
2478   { -1,                 NULL,                   NULL                    },
2479 };
2480
2481 static char *optional_tokens[] =
2482 {
2483   "program_title",
2484   "program_copyright",
2485   "program_company",
2486
2487   NULL
2488 };
2489
2490 static void setTreeInfoToDefaults(TreeInfo *ti, int type)
2491 {
2492   ti->type = type;
2493
2494   ti->node_top = (ti->type == TREE_TYPE_LEVEL_DIR    ? &leveldir_first :
2495                   ti->type == TREE_TYPE_GRAPHICS_DIR ? &artwork.gfx_first :
2496                   ti->type == TREE_TYPE_SOUNDS_DIR   ? &artwork.snd_first :
2497                   ti->type == TREE_TYPE_MUSIC_DIR    ? &artwork.mus_first :
2498                   NULL);
2499
2500   ti->node_parent = NULL;
2501   ti->node_group = NULL;
2502   ti->next = NULL;
2503
2504   ti->cl_first = -1;
2505   ti->cl_cursor = -1;
2506
2507   ti->subdir = NULL;
2508   ti->fullpath = NULL;
2509   ti->basepath = NULL;
2510   ti->identifier = NULL;
2511   ti->name = getStringCopy(ANONYMOUS_NAME);
2512   ti->name_sorting = NULL;
2513   ti->author = getStringCopy(ANONYMOUS_NAME);
2514   ti->year = NULL;
2515
2516   ti->program_title = NULL;
2517   ti->program_copyright = NULL;
2518   ti->program_company = NULL;
2519
2520   ti->sort_priority = LEVELCLASS_UNDEFINED;     // default: least priority
2521   ti->latest_engine = FALSE;                    // default: get from level
2522   ti->parent_link = FALSE;
2523   ti->in_user_dir = FALSE;
2524   ti->user_defined = FALSE;
2525   ti->color = 0;
2526   ti->class_desc = NULL;
2527
2528   ti->infotext = getStringCopy(TREE_INFOTEXT(ti->type));
2529
2530   if (ti->type == TREE_TYPE_LEVEL_DIR)
2531   {
2532     ti->imported_from = NULL;
2533     ti->imported_by = NULL;
2534     ti->tested_by = NULL;
2535
2536     ti->graphics_set_ecs = NULL;
2537     ti->graphics_set_aga = NULL;
2538     ti->graphics_set = NULL;
2539     ti->sounds_set_default = NULL;
2540     ti->sounds_set_lowpass = NULL;
2541     ti->sounds_set = NULL;
2542     ti->music_set = NULL;
2543     ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
2544     ti->sounds_path = getStringCopy(UNDEFINED_FILENAME);
2545     ti->music_path = getStringCopy(UNDEFINED_FILENAME);
2546
2547     ti->level_filename = NULL;
2548     ti->level_filetype = NULL;
2549
2550     ti->special_flags = NULL;
2551
2552     ti->levels = 0;
2553     ti->first_level = 0;
2554     ti->last_level = 0;
2555     ti->level_group = FALSE;
2556     ti->handicap_level = 0;
2557     ti->readonly = TRUE;
2558     ti->handicap = TRUE;
2559     ti->skip_levels = FALSE;
2560
2561     ti->use_emc_tiles = FALSE;
2562   }
2563 }
2564
2565 static void setTreeInfoToDefaultsFromParent(TreeInfo *ti, TreeInfo *parent)
2566 {
2567   if (parent == NULL)
2568   {
2569     Warn("setTreeInfoToDefaultsFromParent(): parent == NULL");
2570
2571     setTreeInfoToDefaults(ti, TREE_TYPE_UNDEFINED);
2572
2573     return;
2574   }
2575
2576   // copy all values from the parent structure
2577
2578   ti->type = parent->type;
2579
2580   ti->node_top = parent->node_top;
2581   ti->node_parent = parent;
2582   ti->node_group = NULL;
2583   ti->next = NULL;
2584
2585   ti->cl_first = -1;
2586   ti->cl_cursor = -1;
2587
2588   ti->subdir = NULL;
2589   ti->fullpath = NULL;
2590   ti->basepath = NULL;
2591   ti->identifier = NULL;
2592   ti->name = getStringCopy(ANONYMOUS_NAME);
2593   ti->name_sorting = NULL;
2594   ti->author = getStringCopy(parent->author);
2595   ti->year = getStringCopy(parent->year);
2596
2597   ti->program_title = getStringCopy(parent->program_title);
2598   ti->program_copyright = getStringCopy(parent->program_copyright);
2599   ti->program_company = getStringCopy(parent->program_company);
2600
2601   ti->sort_priority = parent->sort_priority;
2602   ti->latest_engine = parent->latest_engine;
2603   ti->parent_link = FALSE;
2604   ti->in_user_dir = parent->in_user_dir;
2605   ti->user_defined = parent->user_defined;
2606   ti->color = parent->color;
2607   ti->class_desc = getStringCopy(parent->class_desc);
2608
2609   ti->infotext = getStringCopy(parent->infotext);
2610
2611   if (ti->type == TREE_TYPE_LEVEL_DIR)
2612   {
2613     ti->imported_from = getStringCopy(parent->imported_from);
2614     ti->imported_by = getStringCopy(parent->imported_by);
2615     ti->tested_by = getStringCopy(parent->tested_by);
2616
2617     ti->graphics_set_ecs = getStringCopy(parent->graphics_set_ecs);
2618     ti->graphics_set_aga = getStringCopy(parent->graphics_set_aga);
2619     ti->graphics_set = getStringCopy(parent->graphics_set);
2620     ti->sounds_set_default = getStringCopy(parent->sounds_set_default);
2621     ti->sounds_set_lowpass = getStringCopy(parent->sounds_set_lowpass);
2622     ti->sounds_set = getStringCopy(parent->sounds_set);
2623     ti->music_set = getStringCopy(parent->music_set);
2624     ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
2625     ti->sounds_path = getStringCopy(UNDEFINED_FILENAME);
2626     ti->music_path = getStringCopy(UNDEFINED_FILENAME);
2627
2628     ti->level_filename = getStringCopy(parent->level_filename);
2629     ti->level_filetype = getStringCopy(parent->level_filetype);
2630
2631     ti->special_flags = getStringCopy(parent->special_flags);
2632
2633     ti->levels = parent->levels;
2634     ti->first_level = parent->first_level;
2635     ti->last_level = parent->last_level;
2636     ti->level_group = FALSE;
2637     ti->handicap_level = parent->handicap_level;
2638     ti->readonly = parent->readonly;
2639     ti->handicap = parent->handicap;
2640     ti->skip_levels = parent->skip_levels;
2641
2642     ti->use_emc_tiles = parent->use_emc_tiles;
2643   }
2644 }
2645
2646 static TreeInfo *getTreeInfoCopy(TreeInfo *ti)
2647 {
2648   TreeInfo *ti_copy = newTreeInfo();
2649
2650   // copy all values from the original structure
2651
2652   ti_copy->type                 = ti->type;
2653
2654   ti_copy->node_top             = ti->node_top;
2655   ti_copy->node_parent          = ti->node_parent;
2656   ti_copy->node_group           = ti->node_group;
2657   ti_copy->next                 = ti->next;
2658
2659   ti_copy->cl_first             = ti->cl_first;
2660   ti_copy->cl_cursor            = ti->cl_cursor;
2661
2662   ti_copy->subdir               = getStringCopy(ti->subdir);
2663   ti_copy->fullpath             = getStringCopy(ti->fullpath);
2664   ti_copy->basepath             = getStringCopy(ti->basepath);
2665   ti_copy->identifier           = getStringCopy(ti->identifier);
2666   ti_copy->name                 = getStringCopy(ti->name);
2667   ti_copy->name_sorting         = getStringCopy(ti->name_sorting);
2668   ti_copy->author               = getStringCopy(ti->author);
2669   ti_copy->year                 = getStringCopy(ti->year);
2670
2671   ti_copy->program_title        = getStringCopy(ti->program_title);
2672   ti_copy->program_copyright    = getStringCopy(ti->program_copyright);
2673   ti_copy->program_company      = getStringCopy(ti->program_company);
2674
2675   ti_copy->imported_from        = getStringCopy(ti->imported_from);
2676   ti_copy->imported_by          = getStringCopy(ti->imported_by);
2677   ti_copy->tested_by            = getStringCopy(ti->tested_by);
2678
2679   ti_copy->graphics_set_ecs     = getStringCopy(ti->graphics_set_ecs);
2680   ti_copy->graphics_set_aga     = getStringCopy(ti->graphics_set_aga);
2681   ti_copy->graphics_set         = getStringCopy(ti->graphics_set);
2682   ti_copy->sounds_set_default   = getStringCopy(ti->sounds_set_default);
2683   ti_copy->sounds_set_lowpass   = getStringCopy(ti->sounds_set_lowpass);
2684   ti_copy->sounds_set           = getStringCopy(ti->sounds_set);
2685   ti_copy->music_set            = getStringCopy(ti->music_set);
2686   ti_copy->graphics_path        = getStringCopy(ti->graphics_path);
2687   ti_copy->sounds_path          = getStringCopy(ti->sounds_path);
2688   ti_copy->music_path           = getStringCopy(ti->music_path);
2689
2690   ti_copy->level_filename       = getStringCopy(ti->level_filename);
2691   ti_copy->level_filetype       = getStringCopy(ti->level_filetype);
2692
2693   ti_copy->special_flags        = getStringCopy(ti->special_flags);
2694
2695   ti_copy->levels               = ti->levels;
2696   ti_copy->first_level          = ti->first_level;
2697   ti_copy->last_level           = ti->last_level;
2698   ti_copy->sort_priority        = ti->sort_priority;
2699
2700   ti_copy->latest_engine        = ti->latest_engine;
2701
2702   ti_copy->level_group          = ti->level_group;
2703   ti_copy->parent_link          = ti->parent_link;
2704   ti_copy->in_user_dir          = ti->in_user_dir;
2705   ti_copy->user_defined         = ti->user_defined;
2706   ti_copy->readonly             = ti->readonly;
2707   ti_copy->handicap             = ti->handicap;
2708   ti_copy->skip_levels          = ti->skip_levels;
2709
2710   ti_copy->use_emc_tiles        = ti->use_emc_tiles;
2711
2712   ti_copy->color                = ti->color;
2713   ti_copy->class_desc           = getStringCopy(ti->class_desc);
2714   ti_copy->handicap_level       = ti->handicap_level;
2715
2716   ti_copy->infotext             = getStringCopy(ti->infotext);
2717
2718   return ti_copy;
2719 }
2720
2721 void freeTreeInfo(TreeInfo *ti)
2722 {
2723   if (ti == NULL)
2724     return;
2725
2726   checked_free(ti->subdir);
2727   checked_free(ti->fullpath);
2728   checked_free(ti->basepath);
2729   checked_free(ti->identifier);
2730
2731   checked_free(ti->name);
2732   checked_free(ti->name_sorting);
2733   checked_free(ti->author);
2734   checked_free(ti->year);
2735
2736   checked_free(ti->program_title);
2737   checked_free(ti->program_copyright);
2738   checked_free(ti->program_company);
2739
2740   checked_free(ti->class_desc);
2741
2742   checked_free(ti->infotext);
2743
2744   if (ti->type == TREE_TYPE_LEVEL_DIR)
2745   {
2746     checked_free(ti->imported_from);
2747     checked_free(ti->imported_by);
2748     checked_free(ti->tested_by);
2749
2750     checked_free(ti->graphics_set_ecs);
2751     checked_free(ti->graphics_set_aga);
2752     checked_free(ti->graphics_set);
2753     checked_free(ti->sounds_set_default);
2754     checked_free(ti->sounds_set_lowpass);
2755     checked_free(ti->sounds_set);
2756     checked_free(ti->music_set);
2757
2758     checked_free(ti->graphics_path);
2759     checked_free(ti->sounds_path);
2760     checked_free(ti->music_path);
2761
2762     checked_free(ti->level_filename);
2763     checked_free(ti->level_filetype);
2764
2765     checked_free(ti->special_flags);
2766   }
2767
2768   // recursively free child node
2769   if (ti->node_group)
2770     freeTreeInfo(ti->node_group);
2771
2772   // recursively free next node
2773   if (ti->next)
2774     freeTreeInfo(ti->next);
2775
2776   checked_free(ti);
2777 }
2778
2779 void setSetupInfo(struct TokenInfo *token_info,
2780                   int token_nr, char *token_value)
2781 {
2782   int token_type = token_info[token_nr].type;
2783   void *setup_value = token_info[token_nr].value;
2784
2785   if (token_value == NULL)
2786     return;
2787
2788   // set setup field to corresponding token value
2789   switch (token_type)
2790   {
2791     case TYPE_BOOLEAN:
2792     case TYPE_SWITCH:
2793       *(boolean *)setup_value = get_boolean_from_string(token_value);
2794       break;
2795
2796     case TYPE_SWITCH3:
2797       *(int *)setup_value = get_switch3_from_string(token_value);
2798       break;
2799
2800     case TYPE_KEY:
2801       *(Key *)setup_value = getKeyFromKeyName(token_value);
2802       break;
2803
2804     case TYPE_KEY_X11:
2805       *(Key *)setup_value = getKeyFromX11KeyName(token_value);
2806       break;
2807
2808     case TYPE_INTEGER:
2809       *(int *)setup_value = get_integer_from_string(token_value);
2810       break;
2811
2812     case TYPE_STRING:
2813       checked_free(*(char **)setup_value);
2814       *(char **)setup_value = getStringCopy(token_value);
2815       break;
2816
2817     case TYPE_PLAYER:
2818       *(int *)setup_value = get_player_nr_from_string(token_value);
2819       break;
2820
2821     default:
2822       break;
2823   }
2824 }
2825
2826 static int compareTreeInfoEntries(const void *object1, const void *object2)
2827 {
2828   const TreeInfo *entry1 = *((TreeInfo **)object1);
2829   const TreeInfo *entry2 = *((TreeInfo **)object2);
2830   int tree_sorting1 = TREE_SORTING(entry1);
2831   int tree_sorting2 = TREE_SORTING(entry2);
2832
2833   if (tree_sorting1 != tree_sorting2)
2834     return (tree_sorting1 - tree_sorting2);
2835   else
2836     return strcasecmp(entry1->name_sorting, entry2->name_sorting);
2837 }
2838
2839 static TreeInfo *createParentTreeInfoNode(TreeInfo *node_parent)
2840 {
2841   TreeInfo *ti_new;
2842
2843   if (node_parent == NULL)
2844     return NULL;
2845
2846   ti_new = newTreeInfo();
2847   setTreeInfoToDefaults(ti_new, node_parent->type);
2848
2849   ti_new->node_parent = node_parent;
2850   ti_new->parent_link = TRUE;
2851
2852   setString(&ti_new->identifier, node_parent->identifier);
2853   setString(&ti_new->name, BACKLINK_TEXT_PARENT);
2854   setString(&ti_new->name_sorting, ti_new->name);
2855
2856   setString(&ti_new->subdir, STRING_PARENT_DIRECTORY);
2857   setString(&ti_new->fullpath, node_parent->fullpath);
2858
2859   ti_new->sort_priority = LEVELCLASS_PARENT;
2860   ti_new->latest_engine = node_parent->latest_engine;
2861
2862   setString(&ti_new->class_desc, getLevelClassDescription(ti_new));
2863
2864   pushTreeInfo(&node_parent->node_group, ti_new);
2865
2866   return ti_new;
2867 }
2868
2869 static TreeInfo *createTopTreeInfoNode(TreeInfo *node_first)
2870 {
2871   if (node_first == NULL)
2872     return NULL;
2873
2874   TreeInfo *ti_new = newTreeInfo();
2875   int type = node_first->type;
2876
2877   setTreeInfoToDefaults(ti_new, type);
2878
2879   ti_new->node_parent = NULL;
2880   ti_new->parent_link = FALSE;
2881
2882   setString(&ti_new->identifier, "top_tree_node");
2883   setString(&ti_new->name, TREE_INFOTEXT(type));
2884   setString(&ti_new->name_sorting, ti_new->name);
2885
2886   setString(&ti_new->subdir, STRING_TOP_DIRECTORY);
2887   setString(&ti_new->fullpath, ".");
2888
2889   ti_new->sort_priority = LEVELCLASS_TOP;
2890   ti_new->latest_engine = node_first->latest_engine;
2891
2892   setString(&ti_new->class_desc, TREE_INFOTEXT(type));
2893
2894   ti_new->node_group = node_first;
2895   ti_new->level_group = TRUE;
2896
2897   TreeInfo *ti_new2 = createParentTreeInfoNode(ti_new);
2898
2899   setString(&ti_new2->name, TREE_BACKLINK_TEXT(type));
2900   setString(&ti_new2->name_sorting, ti_new2->name);
2901
2902   return ti_new;
2903 }
2904
2905 static void setTreeInfoParentNodes(TreeInfo *node, TreeInfo *node_parent)
2906 {
2907   while (node)
2908   {
2909     if (node->node_group)
2910       setTreeInfoParentNodes(node->node_group, node);
2911
2912     node->node_parent = node_parent;
2913
2914     node = node->next;
2915   }
2916 }
2917
2918
2919 // ----------------------------------------------------------------------------
2920 // functions for handling level and custom artwork info cache
2921 // ----------------------------------------------------------------------------
2922
2923 static void LoadArtworkInfoCache(void)
2924 {
2925   InitCacheDirectory();
2926
2927   if (artworkinfo_cache_old == NULL)
2928   {
2929     char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
2930
2931     // try to load artwork info hash from already existing cache file
2932     artworkinfo_cache_old = loadSetupFileHash(filename);
2933
2934     // try to get program version that artwork info cache was written with
2935     char *version = getHashEntry(artworkinfo_cache_old, "program.version");
2936
2937     // check program version of artwork info cache against current version
2938     if (!strEqual(version, program.version_string))
2939     {
2940       freeSetupFileHash(artworkinfo_cache_old);
2941
2942       artworkinfo_cache_old = NULL;
2943     }
2944
2945     // if no artwork info cache file was found, start with empty hash
2946     if (artworkinfo_cache_old == NULL)
2947       artworkinfo_cache_old = newSetupFileHash();
2948
2949     free(filename);
2950   }
2951
2952   if (artworkinfo_cache_new == NULL)
2953     artworkinfo_cache_new = newSetupFileHash();
2954
2955   update_artworkinfo_cache = FALSE;
2956 }
2957
2958 static void SaveArtworkInfoCache(void)
2959 {
2960   if (!update_artworkinfo_cache)
2961     return;
2962
2963   char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
2964
2965   InitCacheDirectory();
2966
2967   saveSetupFileHash(artworkinfo_cache_new, filename);
2968
2969   free(filename);
2970 }
2971
2972 static char *getCacheTokenPrefix(char *prefix1, char *prefix2)
2973 {
2974   static char *prefix = NULL;
2975
2976   checked_free(prefix);
2977
2978   prefix = getStringCat2WithSeparator(prefix1, prefix2, ".");
2979
2980   return prefix;
2981 }
2982
2983 // (identical to above function, but separate string buffer needed -- nasty)
2984 static char *getCacheToken(char *prefix, char *suffix)
2985 {
2986   static char *token = NULL;
2987
2988   checked_free(token);
2989
2990   token = getStringCat2WithSeparator(prefix, suffix, ".");
2991
2992   return token;
2993 }
2994
2995 static char *getFileTimestampString(char *filename)
2996 {
2997   return getStringCopy(i_to_a(getFileTimestampEpochSeconds(filename)));
2998 }
2999
3000 static boolean modifiedFileTimestamp(char *filename, char *timestamp_string)
3001 {
3002   struct stat file_status;
3003
3004   if (timestamp_string == NULL)
3005     return TRUE;
3006
3007   if (!fileExists(filename))                    // file does not exist
3008     return (atoi(timestamp_string) != 0);
3009
3010   if (stat(filename, &file_status) != 0)        // cannot stat file
3011     return TRUE;
3012
3013   return (file_status.st_mtime != atoi(timestamp_string));
3014 }
3015
3016 static TreeInfo *getArtworkInfoCacheEntry(LevelDirTree *level_node, int type)
3017 {
3018   char *identifier = level_node->subdir;
3019   char *type_string = ARTWORK_DIRECTORY(type);
3020   char *token_prefix = getCacheTokenPrefix(type_string, identifier);
3021   char *token_main = getCacheToken(token_prefix, "CACHED");
3022   char *cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3023   boolean cached = (cache_entry != NULL && strEqual(cache_entry, "true"));
3024   TreeInfo *artwork_info = NULL;
3025
3026   if (!use_artworkinfo_cache)
3027     return NULL;
3028
3029   if (optional_tokens_hash == NULL)
3030   {
3031     int i;
3032
3033     // create hash from list of optional tokens (for quick access)
3034     optional_tokens_hash = newSetupFileHash();
3035     for (i = 0; optional_tokens[i] != NULL; i++)
3036       setHashEntry(optional_tokens_hash, optional_tokens[i], "");
3037   }
3038
3039   if (cached)
3040   {
3041     int i;
3042
3043     artwork_info = newTreeInfo();
3044     setTreeInfoToDefaults(artwork_info, type);
3045
3046     // set all structure fields according to the token/value pairs
3047     ldi = *artwork_info;
3048     for (i = 0; artworkinfo_tokens[i].type != -1; i++)
3049     {
3050       char *token_suffix = artworkinfo_tokens[i].text;
3051       char *token = getCacheToken(token_prefix, token_suffix);
3052       char *value = getHashEntry(artworkinfo_cache_old, token);
3053       boolean optional =
3054         (getHashEntry(optional_tokens_hash, token_suffix) != NULL);
3055
3056       setSetupInfo(artworkinfo_tokens, i, value);
3057
3058       // check if cache entry for this item is mandatory, but missing
3059       if (value == NULL && !optional)
3060       {
3061         Warn("missing cache entry '%s'", token);
3062
3063         cached = FALSE;
3064       }
3065     }
3066
3067     *artwork_info = ldi;
3068   }
3069
3070   if (cached)
3071   {
3072     char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
3073                                         LEVELINFO_FILENAME);
3074     char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
3075                                           ARTWORKINFO_FILENAME(type));
3076
3077     // check if corresponding "levelinfo.conf" file has changed
3078     token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
3079     cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3080
3081     if (modifiedFileTimestamp(filename_levelinfo, cache_entry))
3082       cached = FALSE;
3083
3084     // check if corresponding "<artworkinfo>.conf" file has changed
3085     token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
3086     cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3087
3088     if (modifiedFileTimestamp(filename_artworkinfo, cache_entry))
3089       cached = FALSE;
3090
3091     checked_free(filename_levelinfo);
3092     checked_free(filename_artworkinfo);
3093   }
3094
3095   if (!cached && artwork_info != NULL)
3096   {
3097     freeTreeInfo(artwork_info);
3098
3099     return NULL;
3100   }
3101
3102   return artwork_info;
3103 }
3104
3105 static void setArtworkInfoCacheEntry(TreeInfo *artwork_info,
3106                                      LevelDirTree *level_node, int type)
3107 {
3108   char *identifier = level_node->subdir;
3109   char *type_string = ARTWORK_DIRECTORY(type);
3110   char *token_prefix = getCacheTokenPrefix(type_string, identifier);
3111   char *token_main = getCacheToken(token_prefix, "CACHED");
3112   boolean set_cache_timestamps = TRUE;
3113   int i;
3114
3115   setHashEntry(artworkinfo_cache_new, token_main, "true");
3116
3117   if (set_cache_timestamps)
3118   {
3119     char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
3120                                         LEVELINFO_FILENAME);
3121     char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
3122                                           ARTWORKINFO_FILENAME(type));
3123     char *timestamp_levelinfo = getFileTimestampString(filename_levelinfo);
3124     char *timestamp_artworkinfo = getFileTimestampString(filename_artworkinfo);
3125
3126     token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
3127     setHashEntry(artworkinfo_cache_new, token_main, timestamp_levelinfo);
3128
3129     token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
3130     setHashEntry(artworkinfo_cache_new, token_main, timestamp_artworkinfo);
3131
3132     checked_free(filename_levelinfo);
3133     checked_free(filename_artworkinfo);
3134     checked_free(timestamp_levelinfo);
3135     checked_free(timestamp_artworkinfo);
3136   }
3137
3138   ldi = *artwork_info;
3139   for (i = 0; artworkinfo_tokens[i].type != -1; i++)
3140   {
3141     char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text);
3142     char *value = getSetupValue(artworkinfo_tokens[i].type,
3143                                 artworkinfo_tokens[i].value);
3144     if (value != NULL)
3145       setHashEntry(artworkinfo_cache_new, token, value);
3146   }
3147 }
3148
3149
3150 // ----------------------------------------------------------------------------
3151 // functions for loading level info and custom artwork info
3152 // ----------------------------------------------------------------------------
3153
3154 int GetZipFileTreeType(char *zip_filename)
3155 {
3156   static char *top_dir_path = NULL;
3157   static char *top_dir_conf_filename[NUM_BASE_TREE_TYPES] = { NULL };
3158   static char *conf_basename[NUM_BASE_TREE_TYPES] =
3159   {
3160     GRAPHICSINFO_FILENAME,
3161     SOUNDSINFO_FILENAME,
3162     MUSICINFO_FILENAME,
3163     LEVELINFO_FILENAME
3164   };
3165   int j;
3166
3167   checked_free(top_dir_path);
3168   top_dir_path = NULL;
3169
3170   for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3171   {
3172     checked_free(top_dir_conf_filename[j]);
3173     top_dir_conf_filename[j] = NULL;
3174   }
3175
3176   char **zip_entries = zip_list(zip_filename);
3177
3178   // check if zip file successfully opened
3179   if (zip_entries == NULL || zip_entries[0] == NULL)
3180     return TREE_TYPE_UNDEFINED;
3181
3182   // first zip file entry is expected to be top level directory
3183   char *top_dir = zip_entries[0];
3184
3185   // check if valid top level directory found in zip file
3186   if (!strSuffix(top_dir, "/"))
3187     return TREE_TYPE_UNDEFINED;
3188
3189   // get filenames of valid configuration files in top level directory
3190   for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3191     top_dir_conf_filename[j] = getStringCat2(top_dir, conf_basename[j]);
3192
3193   int tree_type = TREE_TYPE_UNDEFINED;
3194   int e = 0;
3195
3196   while (zip_entries[e] != NULL)
3197   {
3198     // check if every zip file entry is below top level directory
3199     if (!strPrefix(zip_entries[e], top_dir))
3200       return TREE_TYPE_UNDEFINED;
3201
3202     // check if this zip file entry is a valid configuration filename
3203     for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3204     {
3205       if (strEqual(zip_entries[e], top_dir_conf_filename[j]))
3206       {
3207         // only exactly one valid configuration file allowed
3208         if (tree_type != TREE_TYPE_UNDEFINED)
3209           return TREE_TYPE_UNDEFINED;
3210
3211         tree_type = j;
3212       }
3213     }
3214
3215     e++;
3216   }
3217
3218   return tree_type;
3219 }
3220
3221 static boolean CheckZipFileForDirectory(char *zip_filename, char *directory,
3222                                         int tree_type)
3223 {
3224   static char *top_dir_path = NULL;
3225   static char *top_dir_conf_filename = NULL;
3226
3227   checked_free(top_dir_path);
3228   checked_free(top_dir_conf_filename);
3229
3230   top_dir_path = NULL;
3231   top_dir_conf_filename = NULL;
3232
3233   char *conf_basename = (tree_type == TREE_TYPE_LEVEL_DIR ? LEVELINFO_FILENAME :
3234                          ARTWORKINFO_FILENAME(tree_type));
3235
3236   // check if valid configuration filename determined
3237   if (conf_basename == NULL || strEqual(conf_basename, ""))
3238     return FALSE;
3239
3240   char **zip_entries = zip_list(zip_filename);
3241
3242   // check if zip file successfully opened
3243   if (zip_entries == NULL || zip_entries[0] == NULL)
3244     return FALSE;
3245
3246   // first zip file entry is expected to be top level directory
3247   char *top_dir = zip_entries[0];
3248
3249   // check if valid top level directory found in zip file
3250   if (!strSuffix(top_dir, "/"))
3251     return FALSE;
3252
3253   // get path of extracted top level directory
3254   top_dir_path = getPath2(directory, top_dir);
3255
3256   // remove trailing directory separator from top level directory path
3257   // (required to be able to check for file and directory in next step)
3258   top_dir_path[strlen(top_dir_path) - 1] = '\0';
3259
3260   // check if zip file's top level directory already exists in target directory
3261   if (fileExists(top_dir_path))         // (checks for file and directory)
3262     return FALSE;
3263
3264   // get filename of configuration file in top level directory
3265   top_dir_conf_filename = getStringCat2(top_dir, conf_basename);
3266
3267   boolean found_top_dir_conf_filename = FALSE;
3268   int i = 0;
3269
3270   while (zip_entries[i] != NULL)
3271   {
3272     // check if every zip file entry is below top level directory
3273     if (!strPrefix(zip_entries[i], top_dir))
3274       return FALSE;
3275
3276     // check if this zip file entry is the configuration filename
3277     if (strEqual(zip_entries[i], top_dir_conf_filename))
3278       found_top_dir_conf_filename = TRUE;
3279
3280     i++;
3281   }
3282
3283   // check if valid configuration filename was found in zip file
3284   if (!found_top_dir_conf_filename)
3285     return FALSE;
3286
3287   return TRUE;
3288 }
3289
3290 char *ExtractZipFileIntoDirectory(char *zip_filename, char *directory,
3291                                   int tree_type)
3292 {
3293   boolean zip_file_valid = CheckZipFileForDirectory(zip_filename, directory,
3294                                                     tree_type);
3295
3296   if (!zip_file_valid)
3297   {
3298     Warn("zip file '%s' rejected!", zip_filename);
3299
3300     return NULL;
3301   }
3302
3303   char **zip_entries = zip_extract(zip_filename, directory);
3304
3305   if (zip_entries == NULL)
3306   {
3307     Warn("zip file '%s' could not be extracted!", zip_filename);
3308
3309     return NULL;
3310   }
3311
3312   Info("zip file '%s' successfully extracted!", zip_filename);
3313
3314   // first zip file entry contains top level directory
3315   char *top_dir = zip_entries[0];
3316
3317   // remove trailing directory separator from top level directory
3318   top_dir[strlen(top_dir) - 1] = '\0';
3319
3320   return top_dir;
3321 }
3322
3323 static void ProcessZipFilesInDirectory(char *directory, int tree_type)
3324 {
3325   Directory *dir;
3326   DirectoryEntry *dir_entry;
3327
3328   if ((dir = openDirectory(directory)) == NULL)
3329   {
3330     // display error if directory is main "options.graphics_directory" etc.
3331     if (tree_type == TREE_TYPE_LEVEL_DIR ||
3332         directory == OPTIONS_ARTWORK_DIRECTORY(tree_type))
3333       Warn("cannot read directory '%s'", directory);
3334
3335     return;
3336   }
3337
3338   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3339   {
3340     // skip non-zip files (and also directories with zip extension)
3341     if (!strSuffixLower(dir_entry->basename, ".zip") || dir_entry->is_directory)
3342       continue;
3343
3344     char *zip_filename = getPath2(directory, dir_entry->basename);
3345     char *zip_filename_extracted = getStringCat2(zip_filename, ".extracted");
3346     char *zip_filename_rejected  = getStringCat2(zip_filename, ".rejected");
3347
3348     // check if zip file hasn't already been extracted or rejected
3349     if (!fileExists(zip_filename_extracted) &&
3350         !fileExists(zip_filename_rejected))
3351     {
3352       char *top_dir = ExtractZipFileIntoDirectory(zip_filename, directory,
3353                                                   tree_type);
3354       char *marker_filename = (top_dir != NULL ? zip_filename_extracted :
3355                                zip_filename_rejected);
3356       FILE *marker_file;
3357
3358       // create empty file to mark zip file as extracted or rejected
3359       if ((marker_file = fopen(marker_filename, MODE_WRITE)))
3360         fclose(marker_file);
3361
3362       free(zip_filename);
3363       free(zip_filename_extracted);
3364       free(zip_filename_rejected);
3365     }
3366   }
3367
3368   closeDirectory(dir);
3369 }
3370
3371 // forward declaration for recursive call by "LoadLevelInfoFromLevelDir()"
3372 static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
3373
3374 static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
3375                                           TreeInfo *node_parent,
3376                                           char *level_directory,
3377                                           char *directory_name)
3378 {
3379   char *directory_path = getPath2(level_directory, directory_name);
3380   char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
3381   SetupFileHash *setup_file_hash;
3382   LevelDirTree *leveldir_new = NULL;
3383   int i;
3384
3385   // unless debugging, silently ignore directories without "levelinfo.conf"
3386   if (!options.debug && !fileExists(filename))
3387   {
3388     free(directory_path);
3389     free(filename);
3390
3391     return FALSE;
3392   }
3393
3394   setup_file_hash = loadSetupFileHash(filename);
3395
3396   if (setup_file_hash == NULL)
3397   {
3398 #if DEBUG_NO_CONFIG_FILE
3399     Debug("setup", "ignoring level directory '%s'", directory_path);
3400 #endif
3401
3402     free(directory_path);
3403     free(filename);
3404
3405     return FALSE;
3406   }
3407
3408   leveldir_new = newTreeInfo();
3409
3410   if (node_parent)
3411     setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
3412   else
3413     setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
3414
3415   leveldir_new->subdir = getStringCopy(directory_name);
3416
3417   // set all structure fields according to the token/value pairs
3418   ldi = *leveldir_new;
3419   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3420     setSetupInfo(levelinfo_tokens, i,
3421                  getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
3422   *leveldir_new = ldi;
3423
3424   if (strEqual(leveldir_new->name, ANONYMOUS_NAME))
3425     setString(&leveldir_new->name, leveldir_new->subdir);
3426
3427   if (leveldir_new->identifier == NULL)
3428     leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
3429
3430   if (leveldir_new->name_sorting == NULL)
3431     leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
3432
3433   if (node_parent == NULL)              // top level group
3434   {
3435     leveldir_new->basepath = getStringCopy(level_directory);
3436     leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
3437   }
3438   else                                  // sub level group
3439   {
3440     leveldir_new->basepath = getStringCopy(node_parent->basepath);
3441     leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
3442   }
3443
3444   leveldir_new->last_level =
3445     leveldir_new->first_level + leveldir_new->levels - 1;
3446
3447   leveldir_new->in_user_dir =
3448     (!strEqual(leveldir_new->basepath, options.level_directory));
3449
3450   // adjust some settings if user's private level directory was detected
3451   if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
3452       leveldir_new->in_user_dir &&
3453       (strEqual(leveldir_new->subdir, getLoginName()) ||
3454        strEqual(leveldir_new->name,   getLoginName()) ||
3455        strEqual(leveldir_new->author, getRealName())))
3456   {
3457     leveldir_new->sort_priority = LEVELCLASS_PRIVATE_START;
3458     leveldir_new->readonly = FALSE;
3459   }
3460
3461   leveldir_new->user_defined =
3462     (leveldir_new->in_user_dir && IS_LEVELCLASS_PRIVATE(leveldir_new));
3463
3464   setString(&leveldir_new->class_desc, getLevelClassDescription(leveldir_new));
3465
3466   leveldir_new->handicap_level =        // set handicap to default value
3467     (leveldir_new->user_defined || !leveldir_new->handicap ?
3468      leveldir_new->last_level : leveldir_new->first_level);
3469
3470   DrawInitText(leveldir_new->name, 150, FC_YELLOW);
3471
3472   pushTreeInfo(node_first, leveldir_new);
3473
3474   freeSetupFileHash(setup_file_hash);
3475
3476   if (leveldir_new->level_group)
3477   {
3478     // create node to link back to current level directory
3479     createParentTreeInfoNode(leveldir_new);
3480
3481     // recursively step into sub-directory and look for more level series
3482     LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
3483                               leveldir_new, directory_path);
3484   }
3485
3486   free(directory_path);
3487   free(filename);
3488
3489   return TRUE;
3490 }
3491
3492 static void LoadLevelInfoFromLevelDir(TreeInfo **node_first,
3493                                       TreeInfo *node_parent,
3494                                       char *level_directory)
3495 {
3496   // ---------- 1st stage: process any level set zip files ----------
3497
3498   ProcessZipFilesInDirectory(level_directory, TREE_TYPE_LEVEL_DIR);
3499
3500   // ---------- 2nd stage: check for level set directories ----------
3501
3502   Directory *dir;
3503   DirectoryEntry *dir_entry;
3504   boolean valid_entry_found = FALSE;
3505
3506   if ((dir = openDirectory(level_directory)) == NULL)
3507   {
3508     Warn("cannot read level directory '%s'", level_directory);
3509
3510     return;
3511   }
3512
3513   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3514   {
3515     char *directory_name = dir_entry->basename;
3516     char *directory_path = getPath2(level_directory, directory_name);
3517
3518     // skip entries for current and parent directory
3519     if (strEqual(directory_name, ".") ||
3520         strEqual(directory_name, ".."))
3521     {
3522       free(directory_path);
3523
3524       continue;
3525     }
3526
3527     // find out if directory entry is itself a directory
3528     if (!dir_entry->is_directory)                       // not a directory
3529     {
3530       free(directory_path);
3531
3532       continue;
3533     }
3534
3535     free(directory_path);
3536
3537     if (strEqual(directory_name, GRAPHICS_DIRECTORY) ||
3538         strEqual(directory_name, SOUNDS_DIRECTORY) ||
3539         strEqual(directory_name, MUSIC_DIRECTORY))
3540       continue;
3541
3542     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
3543                                                     level_directory,
3544                                                     directory_name);
3545   }
3546
3547   closeDirectory(dir);
3548
3549   // special case: top level directory may directly contain "levelinfo.conf"
3550   if (node_parent == NULL && !valid_entry_found)
3551   {
3552     // check if this directory directly contains a file "levelinfo.conf"
3553     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
3554                                                     level_directory, ".");
3555   }
3556
3557   if (!valid_entry_found)
3558     Warn("cannot find any valid level series in directory '%s'",
3559           level_directory);
3560 }
3561
3562 boolean AdjustGraphicsForEMC(void)
3563 {
3564   boolean settings_changed = FALSE;
3565
3566   settings_changed |= adjustTreeGraphicsForEMC(leveldir_first_all);
3567   settings_changed |= adjustTreeGraphicsForEMC(leveldir_first);
3568
3569   return settings_changed;
3570 }
3571
3572 boolean AdjustSoundsForEMC(void)
3573 {
3574   boolean settings_changed = FALSE;
3575
3576   settings_changed |= adjustTreeSoundsForEMC(leveldir_first_all);
3577   settings_changed |= adjustTreeSoundsForEMC(leveldir_first);
3578
3579   return settings_changed;
3580 }
3581
3582 void LoadLevelInfo(void)
3583 {
3584   InitUserLevelDirectory(getLoginName());
3585
3586   DrawInitText("Loading level series", 120, FC_GREEN);
3587
3588   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
3589   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL));
3590
3591   leveldir_first = createTopTreeInfoNode(leveldir_first);
3592
3593   /* after loading all level set information, clone the level directory tree
3594      and remove all level sets without levels (these may still contain artwork
3595      to be offered in the setup menu as "custom artwork", and are therefore
3596      checked for existing artwork in the function "LoadLevelArtworkInfo()") */
3597   leveldir_first_all = leveldir_first;
3598   cloneTree(&leveldir_first, leveldir_first_all, TRUE);
3599
3600   AdjustGraphicsForEMC();
3601   AdjustSoundsForEMC();
3602
3603   // before sorting, the first entries will be from the user directory
3604   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
3605
3606   if (leveldir_first == NULL)
3607     Fail("cannot find any valid level series in any directory");
3608
3609   sortTreeInfo(&leveldir_first);
3610
3611 #if ENABLE_UNUSED_CODE
3612   dumpTreeInfo(leveldir_first, 0);
3613 #endif
3614 }
3615
3616 static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first,
3617                                               TreeInfo *node_parent,
3618                                               char *base_directory,
3619                                               char *directory_name, int type)
3620 {
3621   char *directory_path = getPath2(base_directory, directory_name);
3622   char *filename = getPath2(directory_path, ARTWORKINFO_FILENAME(type));
3623   SetupFileHash *setup_file_hash = NULL;
3624   TreeInfo *artwork_new = NULL;
3625   int i;
3626
3627   if (fileExists(filename))
3628     setup_file_hash = loadSetupFileHash(filename);
3629
3630   if (setup_file_hash == NULL)  // no config file -- look for artwork files
3631   {
3632     Directory *dir;
3633     DirectoryEntry *dir_entry;
3634     boolean valid_file_found = FALSE;
3635
3636     if ((dir = openDirectory(directory_path)) != NULL)
3637     {
3638       while ((dir_entry = readDirectory(dir)) != NULL)
3639       {
3640         if (FileIsArtworkType(dir_entry->filename, type))
3641         {
3642           valid_file_found = TRUE;
3643
3644           break;
3645         }
3646       }
3647
3648       closeDirectory(dir);
3649     }
3650
3651     if (!valid_file_found)
3652     {
3653 #if DEBUG_NO_CONFIG_FILE
3654       if (!strEqual(directory_name, "."))
3655         Debug("setup", "ignoring artwork directory '%s'", directory_path);
3656 #endif
3657
3658       free(directory_path);
3659       free(filename);
3660
3661       return FALSE;
3662     }
3663   }
3664
3665   artwork_new = newTreeInfo();
3666
3667   if (node_parent)
3668     setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
3669   else
3670     setTreeInfoToDefaults(artwork_new, type);
3671
3672   artwork_new->subdir = getStringCopy(directory_name);
3673
3674   if (setup_file_hash)  // (before defining ".color" and ".class_desc")
3675   {
3676     // set all structure fields according to the token/value pairs
3677     ldi = *artwork_new;
3678     for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3679       setSetupInfo(levelinfo_tokens, i,
3680                    getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
3681     *artwork_new = ldi;
3682
3683     if (strEqual(artwork_new->name, ANONYMOUS_NAME))
3684       setString(&artwork_new->name, artwork_new->subdir);
3685
3686     if (artwork_new->identifier == NULL)
3687       artwork_new->identifier = getStringCopy(artwork_new->subdir);
3688
3689     if (artwork_new->name_sorting == NULL)
3690       artwork_new->name_sorting = getStringCopy(artwork_new->name);
3691   }
3692
3693   if (node_parent == NULL)              // top level group
3694   {
3695     artwork_new->basepath = getStringCopy(base_directory);
3696     artwork_new->fullpath = getStringCopy(artwork_new->subdir);
3697   }
3698   else                                  // sub level group
3699   {
3700     artwork_new->basepath = getStringCopy(node_parent->basepath);
3701     artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name);
3702   }
3703
3704   artwork_new->in_user_dir =
3705     (!strEqual(artwork_new->basepath, OPTIONS_ARTWORK_DIRECTORY(type)));
3706
3707   setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new));
3708
3709   if (setup_file_hash == NULL)  // (after determining ".user_defined")
3710   {
3711     if (strEqual(artwork_new->subdir, "."))
3712     {
3713       if (artwork_new->user_defined)
3714       {
3715         setString(&artwork_new->identifier, "private");
3716         artwork_new->sort_priority = ARTWORKCLASS_PRIVATE;
3717       }
3718       else
3719       {
3720         setString(&artwork_new->identifier, "classic");
3721         artwork_new->sort_priority = ARTWORKCLASS_CLASSICS;
3722       }
3723
3724       setString(&artwork_new->class_desc,
3725                 getLevelClassDescription(artwork_new));
3726     }
3727     else
3728     {
3729       setString(&artwork_new->identifier, artwork_new->subdir);
3730     }
3731
3732     setString(&artwork_new->name, artwork_new->identifier);
3733     setString(&artwork_new->name_sorting, artwork_new->name);
3734   }
3735
3736   pushTreeInfo(node_first, artwork_new);
3737
3738   freeSetupFileHash(setup_file_hash);
3739
3740   free(directory_path);
3741   free(filename);
3742
3743   return TRUE;
3744 }
3745
3746 static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first,
3747                                           TreeInfo *node_parent,
3748                                           char *base_directory, int type)
3749 {
3750   // ---------- 1st stage: process any artwork set zip files ----------
3751
3752   ProcessZipFilesInDirectory(base_directory, type);
3753
3754   // ---------- 2nd stage: check for artwork set directories ----------
3755
3756   Directory *dir;
3757   DirectoryEntry *dir_entry;
3758   boolean valid_entry_found = FALSE;
3759
3760   if ((dir = openDirectory(base_directory)) == NULL)
3761   {
3762     // display error if directory is main "options.graphics_directory" etc.
3763     if (base_directory == OPTIONS_ARTWORK_DIRECTORY(type))
3764       Warn("cannot read directory '%s'", base_directory);
3765
3766     return;
3767   }
3768
3769   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3770   {
3771     char *directory_name = dir_entry->basename;
3772     char *directory_path = getPath2(base_directory, directory_name);
3773
3774     // skip directory entries for current and parent directory
3775     if (strEqual(directory_name, ".") ||
3776         strEqual(directory_name, ".."))
3777     {
3778       free(directory_path);
3779
3780       continue;
3781     }
3782
3783     // skip directory entries which are not a directory
3784     if (!dir_entry->is_directory)                       // not a directory
3785     {
3786       free(directory_path);
3787
3788       continue;
3789     }
3790
3791     free(directory_path);
3792
3793     // check if this directory contains artwork with or without config file
3794     valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
3795                                                         base_directory,
3796                                                         directory_name, type);
3797   }
3798
3799   closeDirectory(dir);
3800
3801   // check if this directory directly contains artwork itself
3802   valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
3803                                                       base_directory, ".",
3804                                                       type);
3805   if (!valid_entry_found)
3806     Warn("cannot find any valid artwork in directory '%s'", base_directory);
3807 }
3808
3809 static TreeInfo *getDummyArtworkInfo(int type)
3810 {
3811   // this is only needed when there is completely no artwork available
3812   TreeInfo *artwork_new = newTreeInfo();
3813
3814   setTreeInfoToDefaults(artwork_new, type);
3815
3816   setString(&artwork_new->subdir,   UNDEFINED_FILENAME);
3817   setString(&artwork_new->fullpath, UNDEFINED_FILENAME);
3818   setString(&artwork_new->basepath, UNDEFINED_FILENAME);
3819
3820   setString(&artwork_new->identifier,   UNDEFINED_FILENAME);
3821   setString(&artwork_new->name,         UNDEFINED_FILENAME);
3822   setString(&artwork_new->name_sorting, UNDEFINED_FILENAME);
3823
3824   return artwork_new;
3825 }
3826
3827 void SetCurrentArtwork(int type)
3828 {
3829   ArtworkDirTree **current_ptr = ARTWORK_CURRENT_PTR(artwork, type);
3830   ArtworkDirTree *first_node = ARTWORK_FIRST_NODE(artwork, type);
3831   char *setup_set = SETUP_ARTWORK_SET(setup, type);
3832   char *default_subdir = ARTWORK_DEFAULT_SUBDIR(type);
3833
3834   // set current artwork to artwork configured in setup menu
3835   *current_ptr = getTreeInfoFromIdentifier(first_node, setup_set);
3836
3837   // if not found, set current artwork to default artwork
3838   if (*current_ptr == NULL)
3839     *current_ptr = getTreeInfoFromIdentifier(first_node, default_subdir);
3840
3841   // if not found, set current artwork to first artwork in tree
3842   if (*current_ptr == NULL)
3843     *current_ptr = getFirstValidTreeInfoEntry(first_node);
3844 }
3845
3846 void ChangeCurrentArtworkIfNeeded(int type)
3847 {
3848   char *current_identifier = ARTWORK_CURRENT_IDENTIFIER(artwork, type);
3849   char *setup_set = SETUP_ARTWORK_SET(setup, type);
3850
3851   if (!strEqual(current_identifier, setup_set))
3852     SetCurrentArtwork(type);
3853 }
3854
3855 void LoadArtworkInfo(void)
3856 {
3857   LoadArtworkInfoCache();
3858
3859   DrawInitText("Looking for custom artwork", 120, FC_GREEN);
3860
3861   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
3862                                 options.graphics_directory,
3863                                 TREE_TYPE_GRAPHICS_DIR);
3864   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
3865                                 getUserGraphicsDir(),
3866                                 TREE_TYPE_GRAPHICS_DIR);
3867
3868   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
3869                                 options.sounds_directory,
3870                                 TREE_TYPE_SOUNDS_DIR);
3871   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
3872                                 getUserSoundsDir(),
3873                                 TREE_TYPE_SOUNDS_DIR);
3874
3875   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
3876                                 options.music_directory,
3877                                 TREE_TYPE_MUSIC_DIR);
3878   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
3879                                 getUserMusicDir(),
3880                                 TREE_TYPE_MUSIC_DIR);
3881
3882   if (artwork.gfx_first == NULL)
3883     artwork.gfx_first = getDummyArtworkInfo(TREE_TYPE_GRAPHICS_DIR);
3884   if (artwork.snd_first == NULL)
3885     artwork.snd_first = getDummyArtworkInfo(TREE_TYPE_SOUNDS_DIR);
3886   if (artwork.mus_first == NULL)
3887     artwork.mus_first = getDummyArtworkInfo(TREE_TYPE_MUSIC_DIR);
3888
3889   // before sorting, the first entries will be from the user directory
3890   SetCurrentArtwork(ARTWORK_TYPE_GRAPHICS);
3891   SetCurrentArtwork(ARTWORK_TYPE_SOUNDS);
3892   SetCurrentArtwork(ARTWORK_TYPE_MUSIC);
3893
3894   artwork.gfx_current_identifier = artwork.gfx_current->identifier;
3895   artwork.snd_current_identifier = artwork.snd_current->identifier;
3896   artwork.mus_current_identifier = artwork.mus_current->identifier;
3897
3898 #if ENABLE_UNUSED_CODE
3899   Debug("setup:LoadArtworkInfo", "graphics set == %s",
3900         artwork.gfx_current_identifier);
3901   Debug("setup:LoadArtworkInfo", "sounds set == %s",
3902         artwork.snd_current_identifier);
3903   Debug("setup:LoadArtworkInfo", "music set == %s",
3904         artwork.mus_current_identifier);
3905 #endif
3906
3907   sortTreeInfo(&artwork.gfx_first);
3908   sortTreeInfo(&artwork.snd_first);
3909   sortTreeInfo(&artwork.mus_first);
3910
3911 #if ENABLE_UNUSED_CODE
3912   dumpTreeInfo(artwork.gfx_first, 0);
3913   dumpTreeInfo(artwork.snd_first, 0);
3914   dumpTreeInfo(artwork.mus_first, 0);
3915 #endif
3916 }
3917
3918 static void MoveArtworkInfoIntoSubTree(ArtworkDirTree **artwork_node)
3919 {
3920   ArtworkDirTree *artwork_new = newTreeInfo();
3921   char *top_node_name = "standalone artwork";
3922
3923   setTreeInfoToDefaults(artwork_new, (*artwork_node)->type);
3924
3925   artwork_new->level_group = TRUE;
3926
3927   setString(&artwork_new->identifier,   top_node_name);
3928   setString(&artwork_new->name,         top_node_name);
3929   setString(&artwork_new->name_sorting, top_node_name);
3930
3931   // create node to link back to current custom artwork directory
3932   createParentTreeInfoNode(artwork_new);
3933
3934   // move existing custom artwork tree into newly created sub-tree
3935   artwork_new->node_group->next = *artwork_node;
3936
3937   // change custom artwork tree to contain only newly created node
3938   *artwork_node = artwork_new;
3939 }
3940
3941 static void LoadArtworkInfoFromLevelInfoExt(ArtworkDirTree **artwork_node,
3942                                             ArtworkDirTree *node_parent,
3943                                             LevelDirTree *level_node,
3944                                             boolean empty_level_set_mode)
3945 {
3946   int type = (*artwork_node)->type;
3947
3948   // recursively check all level directories for artwork sub-directories
3949
3950   while (level_node)
3951   {
3952     boolean empty_level_set = (level_node->levels == 0);
3953
3954     // check all tree entries for artwork, but skip parent link entries
3955     if (!level_node->parent_link && empty_level_set == empty_level_set_mode)
3956     {
3957       TreeInfo *artwork_new = getArtworkInfoCacheEntry(level_node, type);
3958       boolean cached = (artwork_new != NULL);
3959
3960       if (cached)
3961       {
3962         pushTreeInfo(artwork_node, artwork_new);
3963       }
3964       else
3965       {
3966         TreeInfo *topnode_last = *artwork_node;
3967         char *path = getPath2(getLevelDirFromTreeInfo(level_node),
3968                               ARTWORK_DIRECTORY(type));
3969
3970         LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path, type);
3971
3972         if (topnode_last != *artwork_node)      // check for newly added node
3973         {
3974           artwork_new = *artwork_node;
3975
3976           setString(&artwork_new->identifier,   level_node->subdir);
3977           setString(&artwork_new->name,         level_node->name);
3978           setString(&artwork_new->name_sorting, level_node->name_sorting);
3979
3980           artwork_new->sort_priority = level_node->sort_priority;
3981           artwork_new->in_user_dir = level_node->in_user_dir;
3982
3983           update_artworkinfo_cache = TRUE;
3984         }
3985
3986         free(path);
3987       }
3988
3989       // insert artwork info (from old cache or filesystem) into new cache
3990       if (artwork_new != NULL)
3991         setArtworkInfoCacheEntry(artwork_new, level_node, type);
3992     }
3993
3994     DrawInitText(level_node->name, 150, FC_YELLOW);
3995
3996     if (level_node->node_group != NULL)
3997     {
3998       TreeInfo *artwork_new = newTreeInfo();
3999
4000       if (node_parent)
4001         setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
4002       else
4003         setTreeInfoToDefaults(artwork_new, type);
4004
4005       artwork_new->level_group = TRUE;
4006
4007       setString(&artwork_new->identifier,   level_node->subdir);
4008
4009       if (node_parent == NULL)          // check for top tree node
4010       {
4011         char *top_node_name = (empty_level_set_mode ?
4012                                "artwork for certain level sets" :
4013                                "artwork included in level sets");
4014
4015         setString(&artwork_new->name,         top_node_name);
4016         setString(&artwork_new->name_sorting, top_node_name);
4017       }
4018       else
4019       {
4020         setString(&artwork_new->name,         level_node->name);
4021         setString(&artwork_new->name_sorting, level_node->name_sorting);
4022       }
4023
4024       pushTreeInfo(artwork_node, artwork_new);
4025
4026       // create node to link back to current custom artwork directory
4027       createParentTreeInfoNode(artwork_new);
4028
4029       // recursively step into sub-directory and look for more custom artwork
4030       LoadArtworkInfoFromLevelInfoExt(&artwork_new->node_group, artwork_new,
4031                                       level_node->node_group,
4032                                       empty_level_set_mode);
4033
4034       // if sub-tree has no custom artwork at all, remove it
4035       if (artwork_new->node_group->next == NULL)
4036         removeTreeInfo(artwork_node);
4037     }
4038
4039     level_node = level_node->next;
4040   }
4041 }
4042
4043 static void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node)
4044 {
4045   // move peviously loaded artwork tree into separate sub-tree
4046   MoveArtworkInfoIntoSubTree(artwork_node);
4047
4048   // load artwork from level sets into separate sub-trees
4049   LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, TRUE);
4050   LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, FALSE);
4051
4052   // add top tree node over all three separate sub-trees
4053   *artwork_node = createTopTreeInfoNode(*artwork_node);
4054
4055   // set all parent links (back links) in complete artwork tree
4056   setTreeInfoParentNodes(*artwork_node, NULL);
4057 }
4058
4059 void LoadLevelArtworkInfo(void)
4060 {
4061   print_timestamp_init("LoadLevelArtworkInfo");
4062
4063   DrawInitText("Looking for custom level artwork", 120, FC_GREEN);
4064
4065   print_timestamp_time("DrawTimeText");
4066
4067   LoadArtworkInfoFromLevelInfo(&artwork.gfx_first);
4068   print_timestamp_time("LoadArtworkInfoFromLevelInfo (gfx)");
4069   LoadArtworkInfoFromLevelInfo(&artwork.snd_first);
4070   print_timestamp_time("LoadArtworkInfoFromLevelInfo (snd)");
4071   LoadArtworkInfoFromLevelInfo(&artwork.mus_first);
4072   print_timestamp_time("LoadArtworkInfoFromLevelInfo (mus)");
4073
4074   SaveArtworkInfoCache();
4075
4076   print_timestamp_time("SaveArtworkInfoCache");
4077
4078   // needed for reloading level artwork not known at ealier stage
4079   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_GRAPHICS);
4080   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_SOUNDS);
4081   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_MUSIC);
4082
4083   print_timestamp_time("getTreeInfoFromIdentifier");
4084
4085   sortTreeInfo(&artwork.gfx_first);
4086   sortTreeInfo(&artwork.snd_first);
4087   sortTreeInfo(&artwork.mus_first);
4088
4089   print_timestamp_time("sortTreeInfo");
4090
4091 #if ENABLE_UNUSED_CODE
4092   dumpTreeInfo(artwork.gfx_first, 0);
4093   dumpTreeInfo(artwork.snd_first, 0);
4094   dumpTreeInfo(artwork.mus_first, 0);
4095 #endif
4096
4097   print_timestamp_done("LoadLevelArtworkInfo");
4098 }
4099
4100 static boolean AddTreeSetToTreeInfoExt(TreeInfo *tree_node_old, char *tree_dir,
4101                                        char *tree_subdir_new, int type)
4102 {
4103   if (tree_node_old == NULL)
4104   {
4105     if (type == TREE_TYPE_LEVEL_DIR)
4106     {
4107       // get level info tree node of personal user level set
4108       tree_node_old = getTreeInfoFromIdentifier(leveldir_first, getLoginName());
4109
4110       // this may happen if "setup.internal.create_user_levelset" is FALSE
4111       // or if file "levelinfo.conf" is missing in personal user level set
4112       if (tree_node_old == NULL)
4113         tree_node_old = leveldir_first->node_group;
4114     }
4115     else
4116     {
4117       // get artwork info tree node of first artwork set
4118       tree_node_old = ARTWORK_FIRST_NODE(artwork, type);
4119     }
4120   }
4121
4122   if (tree_dir == NULL)
4123     tree_dir = TREE_USERDIR(type);
4124
4125   if (tree_node_old   == NULL ||
4126       tree_dir        == NULL ||
4127       tree_subdir_new == NULL)          // should not happen
4128     return FALSE;
4129
4130   int draw_deactivation_mask = GetDrawDeactivationMask();
4131
4132   // override draw deactivation mask (temporarily disable drawing)
4133   SetDrawDeactivationMask(REDRAW_ALL);
4134
4135   if (type == TREE_TYPE_LEVEL_DIR)
4136   {
4137     // load new level set config and add it next to first user level set
4138     LoadLevelInfoFromLevelConf(&tree_node_old->next,
4139                                tree_node_old->node_parent,
4140                                tree_dir, tree_subdir_new);
4141   }
4142   else
4143   {
4144     // load new artwork set config and add it next to first artwork set
4145     LoadArtworkInfoFromArtworkConf(&tree_node_old->next,
4146                                    tree_node_old->node_parent,
4147                                    tree_dir, tree_subdir_new, type);
4148   }
4149
4150   // set draw deactivation mask to previous value
4151   SetDrawDeactivationMask(draw_deactivation_mask);
4152
4153   // get first node of level or artwork info tree
4154   TreeInfo **tree_node_first = TREE_FIRST_NODE_PTR(type);
4155
4156   // get tree info node of newly added level or artwork set
4157   TreeInfo *tree_node_new = getTreeInfoFromIdentifier(*tree_node_first,
4158                                                       tree_subdir_new);
4159
4160   if (tree_node_new == NULL)            // should not happen
4161     return FALSE;
4162
4163   // correct top link and parent node link of newly created tree node
4164   tree_node_new->node_top    = tree_node_old->node_top;
4165   tree_node_new->node_parent = tree_node_old->node_parent;
4166
4167   // sort tree info to adjust position of newly added tree set
4168   sortTreeInfo(tree_node_first);
4169
4170   return TRUE;
4171 }
4172
4173 void AddTreeSetToTreeInfo(TreeInfo *tree_node, char *tree_dir,
4174                           char *tree_subdir_new, int type)
4175 {
4176   if (!AddTreeSetToTreeInfoExt(tree_node, tree_dir, tree_subdir_new, type))
4177     Fail("internal tree info structure corrupted -- aborting");
4178 }
4179
4180 void AddUserLevelSetToLevelInfo(char *level_subdir_new)
4181 {
4182   AddTreeSetToTreeInfo(NULL, NULL, level_subdir_new, TREE_TYPE_LEVEL_DIR);
4183 }
4184
4185 char *getArtworkIdentifierForUserLevelSet(int type)
4186 {
4187   char *classic_artwork_set = getClassicArtworkSet(type);
4188
4189   // check for custom artwork configured in "levelinfo.conf"
4190   char *leveldir_artwork_set =
4191     *LEVELDIR_ARTWORK_SET_PTR(leveldir_current, type);
4192   boolean has_leveldir_artwork_set =
4193     (leveldir_artwork_set != NULL && !strEqual(leveldir_artwork_set,
4194                                                classic_artwork_set));
4195
4196   // check for custom artwork in sub-directory "graphics" etc.
4197   TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
4198   char *leveldir_identifier = leveldir_current->identifier;
4199   boolean has_artwork_subdir =
4200     (getTreeInfoFromIdentifier(artwork_first_node,
4201                                leveldir_identifier) != NULL);
4202
4203   return (has_leveldir_artwork_set ? leveldir_artwork_set :
4204           has_artwork_subdir       ? leveldir_identifier :
4205           classic_artwork_set);
4206 }
4207
4208 TreeInfo *getArtworkTreeInfoForUserLevelSet(int type)
4209 {
4210   char *artwork_set = getArtworkIdentifierForUserLevelSet(type);
4211   TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
4212   TreeInfo *ti = getTreeInfoFromIdentifier(artwork_first_node, artwork_set);
4213
4214   if (ti == NULL)
4215   {
4216     ti = getTreeInfoFromIdentifier(artwork_first_node,
4217                                    ARTWORK_DEFAULT_SUBDIR(type));
4218     if (ti == NULL)
4219       Fail("cannot find default graphics -- should not happen");
4220   }
4221
4222   return ti;
4223 }
4224
4225 boolean checkIfCustomArtworkExistsForCurrentLevelSet(void)
4226 {
4227   char *graphics_set =
4228     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
4229   char *sounds_set =
4230     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_SOUNDS);
4231   char *music_set =
4232     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_MUSIC);
4233
4234   return (!strEqual(graphics_set, GFX_CLASSIC_SUBDIR) ||
4235           !strEqual(sounds_set,   SND_CLASSIC_SUBDIR) ||
4236           !strEqual(music_set,    MUS_CLASSIC_SUBDIR));
4237 }
4238
4239 boolean UpdateUserLevelSet(char *level_subdir, char *level_name,
4240                            char *level_author, int num_levels)
4241 {
4242   char *filename = getPath2(getUserLevelDir(level_subdir), LEVELINFO_FILENAME);
4243   char *filename_tmp = getStringCat2(filename, ".tmp");
4244   FILE *file = NULL;
4245   FILE *file_tmp = NULL;
4246   char line[MAX_LINE_LEN];
4247   boolean success = FALSE;
4248   LevelDirTree *leveldir = getTreeInfoFromIdentifier(leveldir_first,
4249                                                      level_subdir);
4250   // update values in level directory tree
4251
4252   if (level_name != NULL)
4253     setString(&leveldir->name, level_name);
4254
4255   if (level_author != NULL)
4256     setString(&leveldir->author, level_author);
4257
4258   if (num_levels != -1)
4259     leveldir->levels = num_levels;
4260
4261   // update values that depend on other values
4262
4263   setString(&leveldir->name_sorting, leveldir->name);
4264
4265   leveldir->last_level = leveldir->first_level + leveldir->levels - 1;
4266
4267   // sort order of level sets may have changed
4268   sortTreeInfo(&leveldir_first);
4269
4270   if ((file     = fopen(filename,     MODE_READ)) &&
4271       (file_tmp = fopen(filename_tmp, MODE_WRITE)))
4272   {
4273     while (fgets(line, MAX_LINE_LEN, file))
4274     {
4275       if (strPrefix(line, "name:") && level_name != NULL)
4276         fprintf(file_tmp, "%-32s%s\n", "name:", level_name);
4277       else if (strPrefix(line, "author:") && level_author != NULL)
4278         fprintf(file_tmp, "%-32s%s\n", "author:", level_author);
4279       else if (strPrefix(line, "levels:") && num_levels != -1)
4280         fprintf(file_tmp, "%-32s%d\n", "levels:", num_levels);
4281       else
4282         fputs(line, file_tmp);
4283     }
4284
4285     success = TRUE;
4286   }
4287
4288   if (file)
4289     fclose(file);
4290
4291   if (file_tmp)
4292     fclose(file_tmp);
4293
4294   if (success)
4295     success = (rename(filename_tmp, filename) == 0);
4296
4297   free(filename);
4298   free(filename_tmp);
4299
4300   return success;
4301 }
4302
4303 boolean CreateUserLevelSet(char *level_subdir, char *level_name,
4304                            char *level_author, int num_levels,
4305                            boolean use_artwork_set)
4306 {
4307   LevelDirTree *level_info;
4308   char *filename;
4309   FILE *file;
4310   int i;
4311
4312   // create user level sub-directory, if needed
4313   createDirectory(getUserLevelDir(level_subdir), "user level", PERMS_PRIVATE);
4314
4315   filename = getPath2(getUserLevelDir(level_subdir), LEVELINFO_FILENAME);
4316
4317   if (!(file = fopen(filename, MODE_WRITE)))
4318   {
4319     Warn("cannot write level info file '%s'", filename);
4320
4321     free(filename);
4322
4323     return FALSE;
4324   }
4325
4326   level_info = newTreeInfo();
4327
4328   // always start with reliable default values
4329   setTreeInfoToDefaults(level_info, TREE_TYPE_LEVEL_DIR);
4330
4331   setString(&level_info->name, level_name);
4332   setString(&level_info->author, level_author);
4333   level_info->levels = num_levels;
4334   level_info->first_level = 1;
4335   level_info->sort_priority = LEVELCLASS_PRIVATE_START;
4336   level_info->readonly = FALSE;
4337
4338   if (use_artwork_set)
4339   {
4340     level_info->graphics_set =
4341       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS));
4342     level_info->sounds_set =
4343       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_SOUNDS));
4344     level_info->music_set =
4345       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_MUSIC));
4346   }
4347
4348   token_value_position = TOKEN_VALUE_POSITION_SHORT;
4349
4350   fprintFileHeader(file, LEVELINFO_FILENAME);
4351
4352   ldi = *level_info;
4353   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
4354   {
4355     if (i == LEVELINFO_TOKEN_NAME ||
4356         i == LEVELINFO_TOKEN_AUTHOR ||
4357         i == LEVELINFO_TOKEN_LEVELS ||
4358         i == LEVELINFO_TOKEN_FIRST_LEVEL ||
4359         i == LEVELINFO_TOKEN_SORT_PRIORITY ||
4360         i == LEVELINFO_TOKEN_READONLY ||
4361         (use_artwork_set && (i == LEVELINFO_TOKEN_GRAPHICS_SET ||
4362                              i == LEVELINFO_TOKEN_SOUNDS_SET ||
4363                              i == LEVELINFO_TOKEN_MUSIC_SET)))
4364       fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
4365
4366     // just to make things nicer :)
4367     if (i == LEVELINFO_TOKEN_AUTHOR ||
4368         i == LEVELINFO_TOKEN_FIRST_LEVEL ||
4369         (use_artwork_set && i == LEVELINFO_TOKEN_READONLY))
4370       fprintf(file, "\n");
4371   }
4372
4373   token_value_position = TOKEN_VALUE_POSITION_DEFAULT;
4374
4375   fclose(file);
4376
4377   SetFilePermissions(filename, PERMS_PRIVATE);
4378
4379   freeTreeInfo(level_info);
4380   free(filename);
4381
4382   return TRUE;
4383 }
4384
4385 static void SaveUserLevelInfo(void)
4386 {
4387   CreateUserLevelSet(getLoginName(), getLoginName(), getRealName(), 100, FALSE);
4388 }
4389
4390 char *getSetupValue(int type, void *value)
4391 {
4392   static char value_string[MAX_LINE_LEN];
4393
4394   if (value == NULL)
4395     return NULL;
4396
4397   switch (type)
4398   {
4399     case TYPE_BOOLEAN:
4400       strcpy(value_string, (*(boolean *)value ? "true" : "false"));
4401       break;
4402
4403     case TYPE_SWITCH:
4404       strcpy(value_string, (*(boolean *)value ? "on" : "off"));
4405       break;
4406
4407     case TYPE_SWITCH3:
4408       strcpy(value_string, (*(int *)value == AUTO  ? "auto" :
4409                             *(int *)value == FALSE ? "off" : "on"));
4410       break;
4411
4412     case TYPE_YES_NO:
4413       strcpy(value_string, (*(boolean *)value ? "yes" : "no"));
4414       break;
4415
4416     case TYPE_YES_NO_AUTO:
4417       strcpy(value_string, (*(int *)value == AUTO  ? "auto" :
4418                             *(int *)value == FALSE ? "no" : "yes"));
4419       break;
4420
4421     case TYPE_ECS_AGA:
4422       strcpy(value_string, (*(boolean *)value ? "AGA" : "ECS"));
4423       break;
4424
4425     case TYPE_KEY:
4426       strcpy(value_string, getKeyNameFromKey(*(Key *)value));
4427       break;
4428
4429     case TYPE_KEY_X11:
4430       strcpy(value_string, getX11KeyNameFromKey(*(Key *)value));
4431       break;
4432
4433     case TYPE_INTEGER:
4434       sprintf(value_string, "%d", *(int *)value);
4435       break;
4436
4437     case TYPE_STRING:
4438       if (*(char **)value == NULL)
4439         return NULL;
4440
4441       strcpy(value_string, *(char **)value);
4442       break;
4443
4444     case TYPE_PLAYER:
4445       sprintf(value_string, "player_%d", *(int *)value + 1);
4446       break;
4447
4448     default:
4449       value_string[0] = '\0';
4450       break;
4451   }
4452
4453   if (type & TYPE_GHOSTED)
4454     strcpy(value_string, "n/a");
4455
4456   return value_string;
4457 }
4458
4459 char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
4460 {
4461   int i;
4462   char *line;
4463   static char token_string[MAX_LINE_LEN];
4464   int token_type = token_info[token_nr].type;
4465   void *setup_value = token_info[token_nr].value;
4466   char *token_text = token_info[token_nr].text;
4467   char *value_string = getSetupValue(token_type, setup_value);
4468
4469   // build complete token string
4470   sprintf(token_string, "%s%s", prefix, token_text);
4471
4472   // build setup entry line
4473   line = getFormattedSetupEntry(token_string, value_string);
4474
4475   if (token_type == TYPE_KEY_X11)
4476   {
4477     Key key = *(Key *)setup_value;
4478     char *keyname = getKeyNameFromKey(key);
4479
4480     // add comment, if useful
4481     if (!strEqual(keyname, "(undefined)") &&
4482         !strEqual(keyname, "(unknown)"))
4483     {
4484       // add at least one whitespace
4485       strcat(line, " ");
4486       for (i = strlen(line); i < token_comment_position; i++)
4487         strcat(line, " ");
4488
4489       strcat(line, "# ");
4490       strcat(line, keyname);
4491     }
4492   }
4493
4494   return line;
4495 }
4496
4497 static void InitLastPlayedLevels_ParentNode(void)
4498 {
4499   LevelDirTree **leveldir_top = &leveldir_first->node_group->next;
4500   LevelDirTree *leveldir_new = NULL;
4501
4502   // check if parent node for last played levels already exists
4503   if (strEqual((*leveldir_top)->identifier, TOKEN_STR_LAST_LEVEL_SERIES))
4504     return;
4505
4506   leveldir_new = newTreeInfo();
4507
4508   setTreeInfoToDefaultsFromParent(leveldir_new, leveldir_first);
4509
4510   leveldir_new->level_group = TRUE;
4511   leveldir_new->sort_priority = LEVELCLASS_LAST_PLAYED_LEVEL;
4512
4513   setString(&leveldir_new->identifier, TOKEN_STR_LAST_LEVEL_SERIES);
4514   setString(&leveldir_new->name, "<< (last played level sets)");
4515   setString(&leveldir_new->name_sorting, leveldir_new->name);
4516
4517   pushTreeInfo(leveldir_top, leveldir_new);
4518
4519   // create node to link back to current level directory
4520   createParentTreeInfoNode(leveldir_new);
4521 }
4522
4523 void UpdateLastPlayedLevels_TreeInfo(void)
4524 {
4525   char **last_level_series = setup.level_setup.last_level_series;
4526   boolean reset_leveldir_current = FALSE;
4527   LevelDirTree *leveldir_last;
4528   TreeInfo **node_new = NULL;
4529   int i;
4530
4531   if (last_level_series[0] == NULL)
4532     return;
4533
4534   InitLastPlayedLevels_ParentNode();
4535
4536   // check if current level set is from "last played" sub-tree to be rebuilt
4537   reset_leveldir_current = strEqual(leveldir_current->node_parent->identifier,
4538                                     TOKEN_STR_LAST_LEVEL_SERIES);
4539
4540   leveldir_last = getTreeInfoFromIdentifierExt(leveldir_first,
4541                                                TOKEN_STR_LAST_LEVEL_SERIES,
4542                                                TRUE);
4543   if (leveldir_last == NULL)
4544     return;
4545
4546   node_new = &leveldir_last->node_group->next;
4547
4548   freeTreeInfo(*node_new);
4549
4550   for (i = 0; last_level_series[i] != NULL; i++)
4551   {
4552     LevelDirTree *node_last = getTreeInfoFromIdentifier(leveldir_first,
4553                                                         last_level_series[i]);
4554
4555     *node_new = getTreeInfoCopy(node_last);     // copy complete node
4556
4557     (*node_new)->node_top = &leveldir_first;    // correct top node link
4558     (*node_new)->node_parent = leveldir_last;   // correct parent node link
4559
4560     (*node_new)->node_group = NULL;
4561     (*node_new)->next = NULL;
4562
4563     (*node_new)->cl_first = -1;                 // force setting tree cursor
4564
4565     node_new = &((*node_new)->next);
4566   }
4567
4568   if (reset_leveldir_current)
4569     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4570                                                  last_level_series[0]);
4571 }
4572
4573 static void UpdateLastPlayedLevels_List(void)
4574 {
4575   char **last_level_series = setup.level_setup.last_level_series;
4576   int pos = MAX_LEVELDIR_HISTORY - 1;
4577   int i;
4578
4579   // search for potentially already existing entry in list of level sets
4580   for (i = 0; last_level_series[i] != NULL; i++)
4581     if (strEqual(last_level_series[i], leveldir_current->identifier))
4582       pos = i;
4583
4584   // move list of level sets one entry down (using potentially free entry)
4585   for (i = pos; i > 0; i--)
4586     setString(&last_level_series[i], last_level_series[i - 1]);
4587
4588   // put last played level set at top position
4589   setString(&last_level_series[0], leveldir_current->identifier);
4590 }
4591
4592 void LoadLevelSetup_LastSeries(void)
4593 {
4594   // --------------------------------------------------------------------------
4595   // ~/.<program>/levelsetup.conf
4596   // --------------------------------------------------------------------------
4597
4598   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
4599   SetupFileHash *level_setup_hash = NULL;
4600   int pos = 0;
4601   int i;
4602
4603   // always start with reliable default values
4604   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4605
4606   // start with empty history of last played level sets
4607   setString(&setup.level_setup.last_level_series[0], NULL);
4608
4609   if (!strEqual(DEFAULT_LEVELSET, UNDEFINED_LEVELSET))
4610   {
4611     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4612                                                  DEFAULT_LEVELSET);
4613     if (leveldir_current == NULL)
4614       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4615   }
4616
4617   if ((level_setup_hash = loadSetupFileHash(filename)))
4618   {
4619     char *last_level_series =
4620       getHashEntry(level_setup_hash, TOKEN_STR_LAST_LEVEL_SERIES);
4621
4622     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4623                                                  last_level_series);
4624     if (leveldir_current == NULL)
4625       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4626
4627     for (i = 0; i < MAX_LEVELDIR_HISTORY; i++)
4628     {
4629       char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
4630       LevelDirTree *leveldir_last;
4631
4632       sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
4633
4634       last_level_series = getHashEntry(level_setup_hash, token);
4635
4636       leveldir_last = getTreeInfoFromIdentifier(leveldir_first,
4637                                                 last_level_series);
4638       if (leveldir_last != NULL)
4639         setString(&setup.level_setup.last_level_series[pos++],
4640                   last_level_series);
4641     }
4642
4643     setString(&setup.level_setup.last_level_series[pos], NULL);
4644
4645     freeSetupFileHash(level_setup_hash);
4646   }
4647   else
4648   {
4649     Debug("setup", "using default setup values");
4650   }
4651
4652   free(filename);
4653 }
4654
4655 static void SaveLevelSetup_LastSeries_Ext(boolean deactivate_last_level_series)
4656 {
4657   // --------------------------------------------------------------------------
4658   // ~/.<program>/levelsetup.conf
4659   // --------------------------------------------------------------------------
4660
4661   // check if the current level directory structure is available at this point
4662   if (leveldir_current == NULL)
4663     return;
4664
4665   char **last_level_series = setup.level_setup.last_level_series;
4666   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
4667   FILE *file;
4668   int i;
4669
4670   InitUserDataDirectory();
4671
4672   UpdateLastPlayedLevels_List();
4673
4674   if (!(file = fopen(filename, MODE_WRITE)))
4675   {
4676     Warn("cannot write setup file '%s'", filename);
4677
4678     free(filename);
4679
4680     return;
4681   }
4682
4683   fprintFileHeader(file, LEVELSETUP_FILENAME);
4684
4685   if (deactivate_last_level_series)
4686     fprintf(file, "# %s\n# ", "the following level set may have caused a problem and was deactivated");
4687
4688   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES,
4689                                                leveldir_current->identifier));
4690
4691   for (i = 0; last_level_series[i] != NULL; i++)
4692   {
4693     char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
4694
4695     sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
4696
4697     fprintf(file, "%s\n", getFormattedSetupEntry(token, last_level_series[i]));
4698   }
4699
4700   fclose(file);
4701
4702   SetFilePermissions(filename, PERMS_PRIVATE);
4703
4704   free(filename);
4705 }
4706
4707 void SaveLevelSetup_LastSeries(void)
4708 {
4709   SaveLevelSetup_LastSeries_Ext(FALSE);
4710 }
4711
4712 void SaveLevelSetup_LastSeries_Deactivate(void)
4713 {
4714   SaveLevelSetup_LastSeries_Ext(TRUE);
4715 }
4716
4717 static void checkSeriesInfo(void)
4718 {
4719   static char *level_directory = NULL;
4720   Directory *dir;
4721 #if 0
4722   DirectoryEntry *dir_entry;
4723 #endif
4724
4725   checked_free(level_directory);
4726
4727   // check for more levels besides the 'levels' field of 'levelinfo.conf'
4728
4729   level_directory = getPath2((leveldir_current->in_user_dir ?
4730                               getUserLevelDir(NULL) :
4731                               options.level_directory),
4732                              leveldir_current->fullpath);
4733
4734   if ((dir = openDirectory(level_directory)) == NULL)
4735   {
4736     Warn("cannot read level directory '%s'", level_directory);
4737
4738     return;
4739   }
4740
4741 #if 0
4742   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
4743   {
4744     if (strlen(dir_entry->basename) > 4 &&
4745         dir_entry->basename[3] == '.' &&
4746         strEqual(&dir_entry->basename[4], LEVELFILE_EXTENSION))
4747     {
4748       char levelnum_str[4];
4749       int levelnum_value;
4750
4751       strncpy(levelnum_str, dir_entry->basename, 3);
4752       levelnum_str[3] = '\0';
4753
4754       levelnum_value = atoi(levelnum_str);
4755
4756       if (levelnum_value < leveldir_current->first_level)
4757       {
4758         Warn("additional level %d found", levelnum_value);
4759
4760         leveldir_current->first_level = levelnum_value;
4761       }
4762       else if (levelnum_value > leveldir_current->last_level)
4763       {
4764         Warn("additional level %d found", levelnum_value);
4765
4766         leveldir_current->last_level = levelnum_value;
4767       }
4768     }
4769   }
4770 #endif
4771
4772   closeDirectory(dir);
4773 }
4774
4775 void LoadLevelSetup_SeriesInfo(void)
4776 {
4777   char *filename;
4778   SetupFileHash *level_setup_hash = NULL;
4779   char *level_subdir = leveldir_current->subdir;
4780   int i;
4781
4782   // always start with reliable default values
4783   level_nr = leveldir_current->first_level;
4784
4785   for (i = 0; i < MAX_LEVELS; i++)
4786   {
4787     LevelStats_setPlayed(i, 0);
4788     LevelStats_setSolved(i, 0);
4789   }
4790
4791   checkSeriesInfo();
4792
4793   // --------------------------------------------------------------------------
4794   // ~/.<program>/levelsetup/<level series>/levelsetup.conf
4795   // --------------------------------------------------------------------------
4796
4797   level_subdir = leveldir_current->subdir;
4798
4799   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
4800
4801   if ((level_setup_hash = loadSetupFileHash(filename)))
4802   {
4803     char *token_value;
4804
4805     // get last played level in this level set
4806
4807     token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL);
4808
4809     if (token_value)
4810     {
4811       level_nr = atoi(token_value);
4812
4813       if (level_nr < leveldir_current->first_level)
4814         level_nr = leveldir_current->first_level;
4815       if (level_nr > leveldir_current->last_level)
4816         level_nr = leveldir_current->last_level;
4817     }
4818
4819     // get handicap level in this level set
4820
4821     token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL);
4822
4823     if (token_value)
4824     {
4825       int level_nr = atoi(token_value);
4826
4827       if (level_nr < leveldir_current->first_level)
4828         level_nr = leveldir_current->first_level;
4829       if (level_nr > leveldir_current->last_level + 1)
4830         level_nr = leveldir_current->last_level;
4831
4832       if (leveldir_current->user_defined || !leveldir_current->handicap)
4833         level_nr = leveldir_current->last_level;
4834
4835       leveldir_current->handicap_level = level_nr;
4836     }
4837
4838     // get number of played and solved levels in this level set
4839
4840     BEGIN_HASH_ITERATION(level_setup_hash, itr)
4841     {
4842       char *token = HASH_ITERATION_TOKEN(itr);
4843       char *value = HASH_ITERATION_VALUE(itr);
4844
4845       if (strlen(token) == 3 &&
4846           token[0] >= '0' && token[0] <= '9' &&
4847           token[1] >= '0' && token[1] <= '9' &&
4848           token[2] >= '0' && token[2] <= '9')
4849       {
4850         int level_nr = atoi(token);
4851
4852         if (value != NULL)
4853           LevelStats_setPlayed(level_nr, atoi(value));  // read 1st column
4854
4855         value = strchr(value, ' ');
4856
4857         if (value != NULL)
4858           LevelStats_setSolved(level_nr, atoi(value));  // read 2nd column
4859       }
4860     }
4861     END_HASH_ITERATION(hash, itr)
4862
4863     freeSetupFileHash(level_setup_hash);
4864   }
4865   else
4866   {
4867     Debug("setup", "using default setup values");
4868   }
4869
4870   free(filename);
4871 }
4872
4873 void SaveLevelSetup_SeriesInfo(void)
4874 {
4875   char *filename;
4876   char *level_subdir = leveldir_current->subdir;
4877   char *level_nr_str = int2str(level_nr, 0);
4878   char *handicap_level_str = int2str(leveldir_current->handicap_level, 0);
4879   FILE *file;
4880   int i;
4881
4882   // --------------------------------------------------------------------------
4883   // ~/.<program>/levelsetup/<level series>/levelsetup.conf
4884   // --------------------------------------------------------------------------
4885
4886   InitLevelSetupDirectory(level_subdir);
4887
4888   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
4889
4890   if (!(file = fopen(filename, MODE_WRITE)))
4891   {
4892     Warn("cannot write setup file '%s'", filename);
4893
4894     free(filename);
4895
4896     return;
4897   }
4898
4899   fprintFileHeader(file, LEVELSETUP_FILENAME);
4900
4901   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_PLAYED_LEVEL,
4902                                                level_nr_str));
4903   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL,
4904                                                  handicap_level_str));
4905
4906   for (i = leveldir_current->first_level; i <= leveldir_current->last_level;
4907        i++)
4908   {
4909     if (LevelStats_getPlayed(i) > 0 ||
4910         LevelStats_getSolved(i) > 0)
4911     {
4912       char token[16];
4913       char value[16];
4914
4915       sprintf(token, "%03d", i);
4916       sprintf(value, "%d %d", LevelStats_getPlayed(i), LevelStats_getSolved(i));
4917
4918       fprintf(file, "%s\n", getFormattedSetupEntry(token, value));
4919     }
4920   }
4921
4922   fclose(file);
4923
4924   SetFilePermissions(filename, PERMS_PRIVATE);
4925
4926   free(filename);
4927 }
4928
4929 int LevelStats_getPlayed(int nr)
4930 {
4931   return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].played : 0);
4932 }
4933
4934 int LevelStats_getSolved(int nr)
4935 {
4936   return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].solved : 0);
4937 }
4938
4939 void LevelStats_setPlayed(int nr, int value)
4940 {
4941   if (nr >= 0 && nr < MAX_LEVELS)
4942     level_stats[nr].played = value;
4943 }
4944
4945 void LevelStats_setSolved(int nr, int value)
4946 {
4947   if (nr >= 0 && nr < MAX_LEVELS)
4948     level_stats[nr].solved = value;
4949 }
4950
4951 void LevelStats_incPlayed(int nr)
4952 {
4953   if (nr >= 0 && nr < MAX_LEVELS)
4954     level_stats[nr].played++;
4955 }
4956
4957 void LevelStats_incSolved(int nr)
4958 {
4959   if (nr >= 0 && nr < MAX_LEVELS)
4960     level_stats[nr].solved++;
4961 }
4962
4963 void LoadUserSetup(void)
4964 {
4965   // --------------------------------------------------------------------------
4966   // ~/.<program>/usersetup.conf
4967   // --------------------------------------------------------------------------
4968
4969   char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
4970   SetupFileHash *user_setup_hash = NULL;
4971
4972   // always start with reliable default values
4973   user.nr = 0;
4974
4975   if ((user_setup_hash = loadSetupFileHash(filename)))
4976   {
4977     char *token_value;
4978
4979     // get last selected user number
4980     token_value = getHashEntry(user_setup_hash, TOKEN_STR_LAST_USER);
4981
4982     if (token_value)
4983       user.nr = MIN(MAX(0, atoi(token_value)), MAX_PLAYER_NAMES - 1);
4984
4985     freeSetupFileHash(user_setup_hash);
4986   }
4987   else
4988   {
4989     Debug("setup", "using default setup values");
4990   }
4991
4992   free(filename);
4993 }
4994
4995 void SaveUserSetup(void)
4996 {
4997   // --------------------------------------------------------------------------
4998   // ~/.<program>/usersetup.conf
4999   // --------------------------------------------------------------------------
5000
5001   char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
5002   FILE *file;
5003
5004   InitMainUserDataDirectory();
5005
5006   if (!(file = fopen(filename, MODE_WRITE)))
5007   {
5008     Warn("cannot write setup file '%s'", filename);
5009
5010     free(filename);
5011
5012     return;
5013   }
5014
5015   fprintFileHeader(file, USERSETUP_FILENAME);
5016
5017   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_USER,
5018                                                i_to_a(user.nr)));
5019   fclose(file);
5020
5021   SetFilePermissions(filename, PERMS_PRIVATE);
5022
5023   free(filename);
5024 }