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