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, BACKLINK_TEXT_PARENT);
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   int type = node_first->type;
2908
2909   setTreeInfoToDefaults(ti_new, type);
2910
2911   ti_new->node_parent = NULL;
2912   ti_new->parent_link = FALSE;
2913
2914   setString(&ti_new->identifier, node_first->identifier);
2915   setString(&ti_new->name, TREE_INFOTEXT(type));
2916   setString(&ti_new->name_sorting, ti_new->name);
2917
2918   setString(&ti_new->subdir, STRING_TOP_DIRECTORY);
2919   setString(&ti_new->fullpath, ".");
2920
2921   ti_new->sort_priority = node_first->sort_priority;;
2922   ti_new->latest_engine = node_first->latest_engine;
2923
2924   setString(&ti_new->class_desc, TREE_INFOTEXT(type));
2925
2926   ti_new->node_group = node_first;
2927   ti_new->level_group = TRUE;
2928
2929   TreeInfo *ti_new2 = createParentTreeInfoNode(ti_new);
2930
2931   setString(&ti_new2->name, TREE_BACKLINK_TEXT(type));
2932   setString(&ti_new2->name_sorting, ti_new2->name);
2933
2934   return ti_new;
2935 }
2936
2937 static void setTreeInfoParentNodes(TreeInfo *node, TreeInfo *node_parent)
2938 {
2939   while (node)
2940   {
2941     if (node->node_group)
2942       setTreeInfoParentNodes(node->node_group, node);
2943
2944     node->node_parent = node_parent;
2945
2946     node = node->next;
2947   }
2948 }
2949
2950
2951 // ----------------------------------------------------------------------------
2952 // functions for handling level and custom artwork info cache
2953 // ----------------------------------------------------------------------------
2954
2955 static void LoadArtworkInfoCache(void)
2956 {
2957   InitCacheDirectory();
2958
2959   if (artworkinfo_cache_old == NULL)
2960   {
2961     char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
2962
2963     // try to load artwork info hash from already existing cache file
2964     artworkinfo_cache_old = loadSetupFileHash(filename);
2965
2966     // if no artwork info cache file was found, start with empty hash
2967     if (artworkinfo_cache_old == NULL)
2968       artworkinfo_cache_old = newSetupFileHash();
2969
2970     free(filename);
2971   }
2972
2973   if (artworkinfo_cache_new == NULL)
2974     artworkinfo_cache_new = newSetupFileHash();
2975 }
2976
2977 static void SaveArtworkInfoCache(void)
2978 {
2979   char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
2980
2981   InitCacheDirectory();
2982
2983   saveSetupFileHash(artworkinfo_cache_new, filename);
2984
2985   free(filename);
2986 }
2987
2988 static char *getCacheTokenPrefix(char *prefix1, char *prefix2)
2989 {
2990   static char *prefix = NULL;
2991
2992   checked_free(prefix);
2993
2994   prefix = getStringCat2WithSeparator(prefix1, prefix2, ".");
2995
2996   return prefix;
2997 }
2998
2999 // (identical to above function, but separate string buffer needed -- nasty)
3000 static char *getCacheToken(char *prefix, char *suffix)
3001 {
3002   static char *token = NULL;
3003
3004   checked_free(token);
3005
3006   token = getStringCat2WithSeparator(prefix, suffix, ".");
3007
3008   return token;
3009 }
3010
3011 static char *getFileTimestampString(char *filename)
3012 {
3013   return getStringCopy(i_to_a(getFileTimestampEpochSeconds(filename)));
3014 }
3015
3016 static boolean modifiedFileTimestamp(char *filename, char *timestamp_string)
3017 {
3018   struct stat file_status;
3019
3020   if (timestamp_string == NULL)
3021     return TRUE;
3022
3023   if (stat(filename, &file_status) != 0)        // cannot stat file
3024     return TRUE;
3025
3026   return (file_status.st_mtime != atoi(timestamp_string));
3027 }
3028
3029 static TreeInfo *getArtworkInfoCacheEntry(LevelDirTree *level_node, int type)
3030 {
3031   char *identifier = level_node->subdir;
3032   char *type_string = ARTWORK_DIRECTORY(type);
3033   char *token_prefix = getCacheTokenPrefix(type_string, identifier);
3034   char *token_main = getCacheToken(token_prefix, "CACHED");
3035   char *cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3036   boolean cached = (cache_entry != NULL && strEqual(cache_entry, "true"));
3037   TreeInfo *artwork_info = NULL;
3038
3039   if (!use_artworkinfo_cache)
3040     return NULL;
3041
3042   if (optional_tokens_hash == NULL)
3043   {
3044     int i;
3045
3046     // create hash from list of optional tokens (for quick access)
3047     optional_tokens_hash = newSetupFileHash();
3048     for (i = 0; optional_tokens[i] != NULL; i++)
3049       setHashEntry(optional_tokens_hash, optional_tokens[i], "");
3050   }
3051
3052   if (cached)
3053   {
3054     int i;
3055
3056     artwork_info = newTreeInfo();
3057     setTreeInfoToDefaults(artwork_info, type);
3058
3059     // set all structure fields according to the token/value pairs
3060     ldi = *artwork_info;
3061     for (i = 0; artworkinfo_tokens[i].type != -1; i++)
3062     {
3063       char *token_suffix = artworkinfo_tokens[i].text;
3064       char *token = getCacheToken(token_prefix, token_suffix);
3065       char *value = getHashEntry(artworkinfo_cache_old, token);
3066       boolean optional =
3067         (getHashEntry(optional_tokens_hash, token_suffix) != NULL);
3068
3069       setSetupInfo(artworkinfo_tokens, i, value);
3070
3071       // check if cache entry for this item is mandatory, but missing
3072       if (value == NULL && !optional)
3073       {
3074         Warn("missing cache entry '%s'", token);
3075
3076         cached = FALSE;
3077       }
3078     }
3079
3080     *artwork_info = ldi;
3081   }
3082
3083   if (cached)
3084   {
3085     char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
3086                                         LEVELINFO_FILENAME);
3087     char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
3088                                           ARTWORKINFO_FILENAME(type));
3089
3090     // check if corresponding "levelinfo.conf" file has changed
3091     token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
3092     cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3093
3094     if (modifiedFileTimestamp(filename_levelinfo, cache_entry))
3095       cached = FALSE;
3096
3097     // check if corresponding "<artworkinfo>.conf" file has changed
3098     token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
3099     cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3100
3101     if (modifiedFileTimestamp(filename_artworkinfo, cache_entry))
3102       cached = FALSE;
3103
3104     checked_free(filename_levelinfo);
3105     checked_free(filename_artworkinfo);
3106   }
3107
3108   if (!cached && artwork_info != NULL)
3109   {
3110     freeTreeInfo(artwork_info);
3111
3112     return NULL;
3113   }
3114
3115   return artwork_info;
3116 }
3117
3118 static void setArtworkInfoCacheEntry(TreeInfo *artwork_info,
3119                                      LevelDirTree *level_node, int type)
3120 {
3121   char *identifier = level_node->subdir;
3122   char *type_string = ARTWORK_DIRECTORY(type);
3123   char *token_prefix = getCacheTokenPrefix(type_string, identifier);
3124   char *token_main = getCacheToken(token_prefix, "CACHED");
3125   boolean set_cache_timestamps = TRUE;
3126   int i;
3127
3128   setHashEntry(artworkinfo_cache_new, token_main, "true");
3129
3130   if (set_cache_timestamps)
3131   {
3132     char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
3133                                         LEVELINFO_FILENAME);
3134     char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
3135                                           ARTWORKINFO_FILENAME(type));
3136     char *timestamp_levelinfo = getFileTimestampString(filename_levelinfo);
3137     char *timestamp_artworkinfo = getFileTimestampString(filename_artworkinfo);
3138
3139     token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
3140     setHashEntry(artworkinfo_cache_new, token_main, timestamp_levelinfo);
3141
3142     token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
3143     setHashEntry(artworkinfo_cache_new, token_main, timestamp_artworkinfo);
3144
3145     checked_free(filename_levelinfo);
3146     checked_free(filename_artworkinfo);
3147     checked_free(timestamp_levelinfo);
3148     checked_free(timestamp_artworkinfo);
3149   }
3150
3151   ldi = *artwork_info;
3152   for (i = 0; artworkinfo_tokens[i].type != -1; i++)
3153   {
3154     char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text);
3155     char *value = getSetupValue(artworkinfo_tokens[i].type,
3156                                 artworkinfo_tokens[i].value);
3157     if (value != NULL)
3158       setHashEntry(artworkinfo_cache_new, token, value);
3159   }
3160 }
3161
3162
3163 // ----------------------------------------------------------------------------
3164 // functions for loading level info and custom artwork info
3165 // ----------------------------------------------------------------------------
3166
3167 int GetZipFileTreeType(char *zip_filename)
3168 {
3169   static char *top_dir_path = NULL;
3170   static char *top_dir_conf_filename[NUM_BASE_TREE_TYPES] = { NULL };
3171   static char *conf_basename[NUM_BASE_TREE_TYPES] =
3172   {
3173     GRAPHICSINFO_FILENAME,
3174     SOUNDSINFO_FILENAME,
3175     MUSICINFO_FILENAME,
3176     LEVELINFO_FILENAME
3177   };
3178   int j;
3179
3180   checked_free(top_dir_path);
3181   top_dir_path = NULL;
3182
3183   for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3184   {
3185     checked_free(top_dir_conf_filename[j]);
3186     top_dir_conf_filename[j] = NULL;
3187   }
3188
3189   char **zip_entries = zip_list(zip_filename);
3190
3191   // check if zip file successfully opened
3192   if (zip_entries == NULL || zip_entries[0] == NULL)
3193     return TREE_TYPE_UNDEFINED;
3194
3195   // first zip file entry is expected to be top level directory
3196   char *top_dir = zip_entries[0];
3197
3198   // check if valid top level directory found in zip file
3199   if (!strSuffix(top_dir, "/"))
3200     return TREE_TYPE_UNDEFINED;
3201
3202   // get filenames of valid configuration files in top level directory
3203   for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3204     top_dir_conf_filename[j] = getStringCat2(top_dir, conf_basename[j]);
3205
3206   int tree_type = TREE_TYPE_UNDEFINED;
3207   int e = 0;
3208
3209   while (zip_entries[e] != NULL)
3210   {
3211     // check if every zip file entry is below top level directory
3212     if (!strPrefix(zip_entries[e], top_dir))
3213       return TREE_TYPE_UNDEFINED;
3214
3215     // check if this zip file entry is a valid configuration filename
3216     for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3217     {
3218       if (strEqual(zip_entries[e], top_dir_conf_filename[j]))
3219       {
3220         // only exactly one valid configuration file allowed
3221         if (tree_type != TREE_TYPE_UNDEFINED)
3222           return TREE_TYPE_UNDEFINED;
3223
3224         tree_type = j;
3225       }
3226     }
3227
3228     e++;
3229   }
3230
3231   return tree_type;
3232 }
3233
3234 static boolean CheckZipFileForDirectory(char *zip_filename, char *directory,
3235                                         int tree_type)
3236 {
3237   static char *top_dir_path = NULL;
3238   static char *top_dir_conf_filename = NULL;
3239
3240   checked_free(top_dir_path);
3241   checked_free(top_dir_conf_filename);
3242
3243   top_dir_path = NULL;
3244   top_dir_conf_filename = NULL;
3245
3246   char *conf_basename = (tree_type == TREE_TYPE_LEVEL_DIR ? LEVELINFO_FILENAME :
3247                          ARTWORKINFO_FILENAME(tree_type));
3248
3249   // check if valid configuration filename determined
3250   if (conf_basename == NULL || strEqual(conf_basename, ""))
3251     return FALSE;
3252
3253   char **zip_entries = zip_list(zip_filename);
3254
3255   // check if zip file successfully opened
3256   if (zip_entries == NULL || zip_entries[0] == NULL)
3257     return FALSE;
3258
3259   // first zip file entry is expected to be top level directory
3260   char *top_dir = zip_entries[0];
3261
3262   // check if valid top level directory found in zip file
3263   if (!strSuffix(top_dir, "/"))
3264     return FALSE;
3265
3266   // get path of extracted top level directory
3267   top_dir_path = getPath2(directory, top_dir);
3268
3269   // remove trailing directory separator from top level directory path
3270   // (required to be able to check for file and directory in next step)
3271   top_dir_path[strlen(top_dir_path) - 1] = '\0';
3272
3273   // check if zip file's top level directory already exists in target directory
3274   if (fileExists(top_dir_path))         // (checks for file and directory)
3275     return FALSE;
3276
3277   // get filename of configuration file in top level directory
3278   top_dir_conf_filename = getStringCat2(top_dir, conf_basename);
3279
3280   boolean found_top_dir_conf_filename = FALSE;
3281   int i = 0;
3282
3283   while (zip_entries[i] != NULL)
3284   {
3285     // check if every zip file entry is below top level directory
3286     if (!strPrefix(zip_entries[i], top_dir))
3287       return FALSE;
3288
3289     // check if this zip file entry is the configuration filename
3290     if (strEqual(zip_entries[i], top_dir_conf_filename))
3291       found_top_dir_conf_filename = TRUE;
3292
3293     i++;
3294   }
3295
3296   // check if valid configuration filename was found in zip file
3297   if (!found_top_dir_conf_filename)
3298     return FALSE;
3299
3300   return TRUE;
3301 }
3302
3303 char *ExtractZipFileIntoDirectory(char *zip_filename, char *directory,
3304                                   int tree_type)
3305 {
3306   boolean zip_file_valid = CheckZipFileForDirectory(zip_filename, directory,
3307                                                     tree_type);
3308
3309   if (!zip_file_valid)
3310   {
3311     Warn("zip file '%s' rejected!", zip_filename);
3312
3313     return NULL;
3314   }
3315
3316   char **zip_entries = zip_extract(zip_filename, directory);
3317
3318   if (zip_entries == NULL)
3319   {
3320     Warn("zip file '%s' could not be extracted!", zip_filename);
3321
3322     return NULL;
3323   }
3324
3325   Info("zip file '%s' successfully extracted!", zip_filename);
3326
3327   // first zip file entry contains top level directory
3328   char *top_dir = zip_entries[0];
3329
3330   // remove trailing directory separator from top level directory
3331   top_dir[strlen(top_dir) - 1] = '\0';
3332
3333   return top_dir;
3334 }
3335
3336 static void ProcessZipFilesInDirectory(char *directory, int tree_type)
3337 {
3338   Directory *dir;
3339   DirectoryEntry *dir_entry;
3340
3341   if ((dir = openDirectory(directory)) == NULL)
3342   {
3343     // display error if directory is main "options.graphics_directory" etc.
3344     if (tree_type == TREE_TYPE_LEVEL_DIR ||
3345         directory == OPTIONS_ARTWORK_DIRECTORY(tree_type))
3346       Warn("cannot read directory '%s'", directory);
3347
3348     return;
3349   }
3350
3351   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3352   {
3353     // skip non-zip files (and also directories with zip extension)
3354     if (!strSuffixLower(dir_entry->basename, ".zip") || dir_entry->is_directory)
3355       continue;
3356
3357     char *zip_filename = getPath2(directory, dir_entry->basename);
3358     char *zip_filename_extracted = getStringCat2(zip_filename, ".extracted");
3359     char *zip_filename_rejected  = getStringCat2(zip_filename, ".rejected");
3360
3361     // check if zip file hasn't already been extracted or rejected
3362     if (!fileExists(zip_filename_extracted) &&
3363         !fileExists(zip_filename_rejected))
3364     {
3365       char *top_dir = ExtractZipFileIntoDirectory(zip_filename, directory,
3366                                                   tree_type);
3367       char *marker_filename = (top_dir != NULL ? zip_filename_extracted :
3368                                zip_filename_rejected);
3369       FILE *marker_file;
3370
3371       // create empty file to mark zip file as extracted or rejected
3372       if ((marker_file = fopen(marker_filename, MODE_WRITE)))
3373         fclose(marker_file);
3374
3375       free(zip_filename);
3376       free(zip_filename_extracted);
3377       free(zip_filename_rejected);
3378     }
3379   }
3380
3381   closeDirectory(dir);
3382 }
3383
3384 // forward declaration for recursive call by "LoadLevelInfoFromLevelDir()"
3385 static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
3386
3387 static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
3388                                           TreeInfo *node_parent,
3389                                           char *level_directory,
3390                                           char *directory_name)
3391 {
3392   char *directory_path = getPath2(level_directory, directory_name);
3393   char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
3394   SetupFileHash *setup_file_hash;
3395   LevelDirTree *leveldir_new = NULL;
3396   int i;
3397
3398   // unless debugging, silently ignore directories without "levelinfo.conf"
3399   if (!options.debug && !fileExists(filename))
3400   {
3401     free(directory_path);
3402     free(filename);
3403
3404     return FALSE;
3405   }
3406
3407   setup_file_hash = loadSetupFileHash(filename);
3408
3409   if (setup_file_hash == NULL)
3410   {
3411 #if DEBUG_NO_CONFIG_FILE
3412     Debug("setup", "ignoring level directory '%s'", directory_path);
3413 #endif
3414
3415     free(directory_path);
3416     free(filename);
3417
3418     return FALSE;
3419   }
3420
3421   leveldir_new = newTreeInfo();
3422
3423   if (node_parent)
3424     setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
3425   else
3426     setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
3427
3428   leveldir_new->subdir = getStringCopy(directory_name);
3429
3430   // set all structure fields according to the token/value pairs
3431   ldi = *leveldir_new;
3432   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3433     setSetupInfo(levelinfo_tokens, i,
3434                  getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
3435   *leveldir_new = ldi;
3436
3437   if (strEqual(leveldir_new->name, ANONYMOUS_NAME))
3438     setString(&leveldir_new->name, leveldir_new->subdir);
3439
3440   if (leveldir_new->identifier == NULL)
3441     leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
3442
3443   if (leveldir_new->name_sorting == NULL)
3444     leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
3445
3446   if (node_parent == NULL)              // top level group
3447   {
3448     leveldir_new->basepath = getStringCopy(level_directory);
3449     leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
3450   }
3451   else                                  // sub level group
3452   {
3453     leveldir_new->basepath = getStringCopy(node_parent->basepath);
3454     leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
3455   }
3456
3457   leveldir_new->last_level =
3458     leveldir_new->first_level + leveldir_new->levels - 1;
3459
3460   leveldir_new->in_user_dir =
3461     (!strEqual(leveldir_new->basepath, options.level_directory));
3462
3463   // adjust some settings if user's private level directory was detected
3464   if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
3465       leveldir_new->in_user_dir &&
3466       (strEqual(leveldir_new->subdir, getLoginName()) ||
3467        strEqual(leveldir_new->name,   getLoginName()) ||
3468        strEqual(leveldir_new->author, getRealName())))
3469   {
3470     leveldir_new->sort_priority = LEVELCLASS_PRIVATE_START;
3471     leveldir_new->readonly = FALSE;
3472   }
3473
3474   leveldir_new->user_defined =
3475     (leveldir_new->in_user_dir && IS_LEVELCLASS_PRIVATE(leveldir_new));
3476
3477   leveldir_new->color = LEVELCOLOR(leveldir_new);
3478
3479   setString(&leveldir_new->class_desc, getLevelClassDescription(leveldir_new));
3480
3481   leveldir_new->handicap_level =        // set handicap to default value
3482     (leveldir_new->user_defined || !leveldir_new->handicap ?
3483      leveldir_new->last_level : leveldir_new->first_level);
3484
3485   DrawInitText(leveldir_new->name, 150, FC_YELLOW);
3486
3487   pushTreeInfo(node_first, leveldir_new);
3488
3489   freeSetupFileHash(setup_file_hash);
3490
3491   if (leveldir_new->level_group)
3492   {
3493     // create node to link back to current level directory
3494     createParentTreeInfoNode(leveldir_new);
3495
3496     // recursively step into sub-directory and look for more level series
3497     LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
3498                               leveldir_new, directory_path);
3499   }
3500
3501   free(directory_path);
3502   free(filename);
3503
3504   return TRUE;
3505 }
3506
3507 static void LoadLevelInfoFromLevelDir(TreeInfo **node_first,
3508                                       TreeInfo *node_parent,
3509                                       char *level_directory)
3510 {
3511   // ---------- 1st stage: process any level set zip files ----------
3512
3513   ProcessZipFilesInDirectory(level_directory, TREE_TYPE_LEVEL_DIR);
3514
3515   // ---------- 2nd stage: check for level set directories ----------
3516
3517   Directory *dir;
3518   DirectoryEntry *dir_entry;
3519   boolean valid_entry_found = FALSE;
3520
3521   if ((dir = openDirectory(level_directory)) == NULL)
3522   {
3523     Warn("cannot read level directory '%s'", level_directory);
3524
3525     return;
3526   }
3527
3528   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3529   {
3530     char *directory_name = dir_entry->basename;
3531     char *directory_path = getPath2(level_directory, directory_name);
3532
3533     // skip entries for current and parent directory
3534     if (strEqual(directory_name, ".") ||
3535         strEqual(directory_name, ".."))
3536     {
3537       free(directory_path);
3538
3539       continue;
3540     }
3541
3542     // find out if directory entry is itself a directory
3543     if (!dir_entry->is_directory)                       // not a directory
3544     {
3545       free(directory_path);
3546
3547       continue;
3548     }
3549
3550     free(directory_path);
3551
3552     if (strEqual(directory_name, GRAPHICS_DIRECTORY) ||
3553         strEqual(directory_name, SOUNDS_DIRECTORY) ||
3554         strEqual(directory_name, MUSIC_DIRECTORY))
3555       continue;
3556
3557     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
3558                                                     level_directory,
3559                                                     directory_name);
3560   }
3561
3562   closeDirectory(dir);
3563
3564   // special case: top level directory may directly contain "levelinfo.conf"
3565   if (node_parent == NULL && !valid_entry_found)
3566   {
3567     // check if this directory directly contains a file "levelinfo.conf"
3568     valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
3569                                                     level_directory, ".");
3570   }
3571
3572   if (!valid_entry_found)
3573     Warn("cannot find any valid level series in directory '%s'",
3574           level_directory);
3575 }
3576
3577 boolean AdjustGraphicsForEMC(void)
3578 {
3579   boolean settings_changed = FALSE;
3580
3581   settings_changed |= adjustTreeGraphicsForEMC(leveldir_first_all);
3582   settings_changed |= adjustTreeGraphicsForEMC(leveldir_first);
3583
3584   return settings_changed;
3585 }
3586
3587 boolean AdjustSoundsForEMC(void)
3588 {
3589   boolean settings_changed = FALSE;
3590
3591   settings_changed |= adjustTreeSoundsForEMC(leveldir_first_all);
3592   settings_changed |= adjustTreeSoundsForEMC(leveldir_first);
3593
3594   return settings_changed;
3595 }
3596
3597 void LoadLevelInfo(void)
3598 {
3599   InitUserLevelDirectory(getLoginName());
3600
3601   DrawInitText("Loading level series", 120, FC_GREEN);
3602
3603   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
3604   LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL));
3605
3606   leveldir_first = createTopTreeInfoNode(leveldir_first);
3607
3608   /* after loading all level set information, clone the level directory tree
3609      and remove all level sets without levels (these may still contain artwork
3610      to be offered in the setup menu as "custom artwork", and are therefore
3611      checked for existing artwork in the function "LoadLevelArtworkInfo()") */
3612   leveldir_first_all = leveldir_first;
3613   cloneTree(&leveldir_first, leveldir_first_all, TRUE);
3614
3615   AdjustGraphicsForEMC();
3616   AdjustSoundsForEMC();
3617
3618   // before sorting, the first entries will be from the user directory
3619   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
3620
3621   if (leveldir_first == NULL)
3622     Fail("cannot find any valid level series in any directory");
3623
3624   sortTreeInfo(&leveldir_first);
3625
3626 #if ENABLE_UNUSED_CODE
3627   dumpTreeInfo(leveldir_first, 0);
3628 #endif
3629 }
3630
3631 static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first,
3632                                               TreeInfo *node_parent,
3633                                               char *base_directory,
3634                                               char *directory_name, int type)
3635 {
3636   char *directory_path = getPath2(base_directory, directory_name);
3637   char *filename = getPath2(directory_path, ARTWORKINFO_FILENAME(type));
3638   SetupFileHash *setup_file_hash = NULL;
3639   TreeInfo *artwork_new = NULL;
3640   int i;
3641
3642   if (fileExists(filename))
3643     setup_file_hash = loadSetupFileHash(filename);
3644
3645   if (setup_file_hash == NULL)  // no config file -- look for artwork files
3646   {
3647     Directory *dir;
3648     DirectoryEntry *dir_entry;
3649     boolean valid_file_found = FALSE;
3650
3651     if ((dir = openDirectory(directory_path)) != NULL)
3652     {
3653       while ((dir_entry = readDirectory(dir)) != NULL)
3654       {
3655         if (FileIsArtworkType(dir_entry->filename, type))
3656         {
3657           valid_file_found = TRUE;
3658
3659           break;
3660         }
3661       }
3662
3663       closeDirectory(dir);
3664     }
3665
3666     if (!valid_file_found)
3667     {
3668 #if DEBUG_NO_CONFIG_FILE
3669       if (!strEqual(directory_name, "."))
3670         Debug("setup", "ignoring artwork directory '%s'", directory_path);
3671 #endif
3672
3673       free(directory_path);
3674       free(filename);
3675
3676       return FALSE;
3677     }
3678   }
3679
3680   artwork_new = newTreeInfo();
3681
3682   if (node_parent)
3683     setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
3684   else
3685     setTreeInfoToDefaults(artwork_new, type);
3686
3687   artwork_new->subdir = getStringCopy(directory_name);
3688
3689   if (setup_file_hash)  // (before defining ".color" and ".class_desc")
3690   {
3691     // set all structure fields according to the token/value pairs
3692     ldi = *artwork_new;
3693     for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3694       setSetupInfo(levelinfo_tokens, i,
3695                    getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
3696     *artwork_new = ldi;
3697
3698     if (strEqual(artwork_new->name, ANONYMOUS_NAME))
3699       setString(&artwork_new->name, artwork_new->subdir);
3700
3701     if (artwork_new->identifier == NULL)
3702       artwork_new->identifier = getStringCopy(artwork_new->subdir);
3703
3704     if (artwork_new->name_sorting == NULL)
3705       artwork_new->name_sorting = getStringCopy(artwork_new->name);
3706   }
3707
3708   if (node_parent == NULL)              // top level group
3709   {
3710     artwork_new->basepath = getStringCopy(base_directory);
3711     artwork_new->fullpath = getStringCopy(artwork_new->subdir);
3712   }
3713   else                                  // sub level group
3714   {
3715     artwork_new->basepath = getStringCopy(node_parent->basepath);
3716     artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name);
3717   }
3718
3719   artwork_new->in_user_dir =
3720     (!strEqual(artwork_new->basepath, OPTIONS_ARTWORK_DIRECTORY(type)));
3721
3722   // (may use ".sort_priority" from "setup_file_hash" above)
3723   artwork_new->color = ARTWORKCOLOR(artwork_new);
3724
3725   setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new));
3726
3727   if (setup_file_hash == NULL)  // (after determining ".user_defined")
3728   {
3729     if (strEqual(artwork_new->subdir, "."))
3730     {
3731       if (artwork_new->user_defined)
3732       {
3733         setString(&artwork_new->identifier, "private");
3734         artwork_new->sort_priority = ARTWORKCLASS_PRIVATE;
3735       }
3736       else
3737       {
3738         setString(&artwork_new->identifier, "classic");
3739         artwork_new->sort_priority = ARTWORKCLASS_CLASSICS;
3740       }
3741
3742       // set to new values after changing ".sort_priority"
3743       artwork_new->color = ARTWORKCOLOR(artwork_new);
3744
3745       setString(&artwork_new->class_desc,
3746                 getLevelClassDescription(artwork_new));
3747     }
3748     else
3749     {
3750       setString(&artwork_new->identifier, artwork_new->subdir);
3751     }
3752
3753     setString(&artwork_new->name, artwork_new->identifier);
3754     setString(&artwork_new->name_sorting, artwork_new->name);
3755   }
3756
3757   pushTreeInfo(node_first, artwork_new);
3758
3759   freeSetupFileHash(setup_file_hash);
3760
3761   free(directory_path);
3762   free(filename);
3763
3764   return TRUE;
3765 }
3766
3767 static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first,
3768                                           TreeInfo *node_parent,
3769                                           char *base_directory, int type)
3770 {
3771   // ---------- 1st stage: process any artwork set zip files ----------
3772
3773   ProcessZipFilesInDirectory(base_directory, type);
3774
3775   // ---------- 2nd stage: check for artwork set directories ----------
3776
3777   Directory *dir;
3778   DirectoryEntry *dir_entry;
3779   boolean valid_entry_found = FALSE;
3780
3781   if ((dir = openDirectory(base_directory)) == NULL)
3782   {
3783     // display error if directory is main "options.graphics_directory" etc.
3784     if (base_directory == OPTIONS_ARTWORK_DIRECTORY(type))
3785       Warn("cannot read directory '%s'", base_directory);
3786
3787     return;
3788   }
3789
3790   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
3791   {
3792     char *directory_name = dir_entry->basename;
3793     char *directory_path = getPath2(base_directory, directory_name);
3794
3795     // skip directory entries for current and parent directory
3796     if (strEqual(directory_name, ".") ||
3797         strEqual(directory_name, ".."))
3798     {
3799       free(directory_path);
3800
3801       continue;
3802     }
3803
3804     // skip directory entries which are not a directory
3805     if (!dir_entry->is_directory)                       // not a directory
3806     {
3807       free(directory_path);
3808
3809       continue;
3810     }
3811
3812     free(directory_path);
3813
3814     // check if this directory contains artwork with or without config file
3815     valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
3816                                                         base_directory,
3817                                                         directory_name, type);
3818   }
3819
3820   closeDirectory(dir);
3821
3822   // check if this directory directly contains artwork itself
3823   valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
3824                                                       base_directory, ".",
3825                                                       type);
3826   if (!valid_entry_found)
3827     Warn("cannot find any valid artwork in directory '%s'", base_directory);
3828 }
3829
3830 static TreeInfo *getDummyArtworkInfo(int type)
3831 {
3832   // this is only needed when there is completely no artwork available
3833   TreeInfo *artwork_new = newTreeInfo();
3834
3835   setTreeInfoToDefaults(artwork_new, type);
3836
3837   setString(&artwork_new->subdir,   UNDEFINED_FILENAME);
3838   setString(&artwork_new->fullpath, UNDEFINED_FILENAME);
3839   setString(&artwork_new->basepath, UNDEFINED_FILENAME);
3840
3841   setString(&artwork_new->identifier,   UNDEFINED_FILENAME);
3842   setString(&artwork_new->name,         UNDEFINED_FILENAME);
3843   setString(&artwork_new->name_sorting, UNDEFINED_FILENAME);
3844
3845   return artwork_new;
3846 }
3847
3848 void SetCurrentArtwork(int type)
3849 {
3850   ArtworkDirTree **current_ptr = ARTWORK_CURRENT_PTR(artwork, type);
3851   ArtworkDirTree *first_node = ARTWORK_FIRST_NODE(artwork, type);
3852   char *setup_set = SETUP_ARTWORK_SET(setup, type);
3853   char *default_subdir = ARTWORK_DEFAULT_SUBDIR(type);
3854
3855   // set current artwork to artwork configured in setup menu
3856   *current_ptr = getTreeInfoFromIdentifier(first_node, setup_set);
3857
3858   // if not found, set current artwork to default artwork
3859   if (*current_ptr == NULL)
3860     *current_ptr = getTreeInfoFromIdentifier(first_node, default_subdir);
3861
3862   // if not found, set current artwork to first artwork in tree
3863   if (*current_ptr == NULL)
3864     *current_ptr = getFirstValidTreeInfoEntry(first_node);
3865 }
3866
3867 void ChangeCurrentArtworkIfNeeded(int type)
3868 {
3869   char *current_identifier = ARTWORK_CURRENT_IDENTIFIER(artwork, type);
3870   char *setup_set = SETUP_ARTWORK_SET(setup, type);
3871
3872   if (!strEqual(current_identifier, setup_set))
3873     SetCurrentArtwork(type);
3874 }
3875
3876 void LoadArtworkInfo(void)
3877 {
3878   LoadArtworkInfoCache();
3879
3880   DrawInitText("Looking for custom artwork", 120, FC_GREEN);
3881
3882   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
3883                                 options.graphics_directory,
3884                                 TREE_TYPE_GRAPHICS_DIR);
3885   LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
3886                                 getUserGraphicsDir(),
3887                                 TREE_TYPE_GRAPHICS_DIR);
3888
3889   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
3890                                 options.sounds_directory,
3891                                 TREE_TYPE_SOUNDS_DIR);
3892   LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
3893                                 getUserSoundsDir(),
3894                                 TREE_TYPE_SOUNDS_DIR);
3895
3896   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
3897                                 options.music_directory,
3898                                 TREE_TYPE_MUSIC_DIR);
3899   LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
3900                                 getUserMusicDir(),
3901                                 TREE_TYPE_MUSIC_DIR);
3902
3903   if (artwork.gfx_first == NULL)
3904     artwork.gfx_first = getDummyArtworkInfo(TREE_TYPE_GRAPHICS_DIR);
3905   if (artwork.snd_first == NULL)
3906     artwork.snd_first = getDummyArtworkInfo(TREE_TYPE_SOUNDS_DIR);
3907   if (artwork.mus_first == NULL)
3908     artwork.mus_first = getDummyArtworkInfo(TREE_TYPE_MUSIC_DIR);
3909
3910   // before sorting, the first entries will be from the user directory
3911   SetCurrentArtwork(ARTWORK_TYPE_GRAPHICS);
3912   SetCurrentArtwork(ARTWORK_TYPE_SOUNDS);
3913   SetCurrentArtwork(ARTWORK_TYPE_MUSIC);
3914
3915   artwork.gfx_current_identifier = artwork.gfx_current->identifier;
3916   artwork.snd_current_identifier = artwork.snd_current->identifier;
3917   artwork.mus_current_identifier = artwork.mus_current->identifier;
3918
3919 #if ENABLE_UNUSED_CODE
3920   Debug("setup:LoadArtworkInfo", "graphics set == %s",
3921         artwork.gfx_current_identifier);
3922   Debug("setup:LoadArtworkInfo", "sounds set == %s",
3923         artwork.snd_current_identifier);
3924   Debug("setup:LoadArtworkInfo", "music set == %s",
3925         artwork.mus_current_identifier);
3926 #endif
3927
3928   sortTreeInfo(&artwork.gfx_first);
3929   sortTreeInfo(&artwork.snd_first);
3930   sortTreeInfo(&artwork.mus_first);
3931
3932 #if ENABLE_UNUSED_CODE
3933   dumpTreeInfo(artwork.gfx_first, 0);
3934   dumpTreeInfo(artwork.snd_first, 0);
3935   dumpTreeInfo(artwork.mus_first, 0);
3936 #endif
3937 }
3938
3939 static void MoveArtworkInfoIntoSubTree(ArtworkDirTree **artwork_node)
3940 {
3941   ArtworkDirTree *artwork_new = newTreeInfo();
3942   char *top_node_name = "dedicated custom artwork";
3943
3944   setTreeInfoToDefaults(artwork_new, (*artwork_node)->type);
3945
3946   artwork_new->level_group = TRUE;
3947
3948   setString(&artwork_new->identifier,   top_node_name);
3949   setString(&artwork_new->name,         top_node_name);
3950   setString(&artwork_new->name_sorting, top_node_name);
3951
3952   // create node to link back to current custom artwork directory
3953   createParentTreeInfoNode(artwork_new);
3954
3955   // move existing custom artwork tree into newly created sub-tree
3956   artwork_new->node_group->next = *artwork_node;
3957
3958   // change custom artwork tree to contain only newly created node
3959   *artwork_node = artwork_new;
3960 }
3961
3962 static void LoadArtworkInfoFromLevelInfoExt(ArtworkDirTree **artwork_node,
3963                                             ArtworkDirTree *node_parent,
3964                                             LevelDirTree *level_node,
3965                                             boolean empty_level_set_mode)
3966 {
3967   int type = (*artwork_node)->type;
3968
3969   // recursively check all level directories for artwork sub-directories
3970
3971   while (level_node)
3972   {
3973     boolean empty_level_set = (level_node->levels == 0);
3974
3975     // check all tree entries for artwork, but skip parent link entries
3976     if (!level_node->parent_link && empty_level_set == empty_level_set_mode)
3977     {
3978       TreeInfo *artwork_new = getArtworkInfoCacheEntry(level_node, type);
3979       boolean cached = (artwork_new != NULL);
3980
3981       if (cached)
3982       {
3983         pushTreeInfo(artwork_node, artwork_new);
3984       }
3985       else
3986       {
3987         TreeInfo *topnode_last = *artwork_node;
3988         char *path = getPath2(getLevelDirFromTreeInfo(level_node),
3989                               ARTWORK_DIRECTORY(type));
3990
3991         LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path, type);
3992
3993         if (topnode_last != *artwork_node)      // check for newly added node
3994         {
3995           artwork_new = *artwork_node;
3996
3997           setString(&artwork_new->identifier,   level_node->subdir);
3998           setString(&artwork_new->name,         level_node->name);
3999           setString(&artwork_new->name_sorting, level_node->name_sorting);
4000
4001           artwork_new->sort_priority = level_node->sort_priority;
4002           artwork_new->color = LEVELCOLOR(artwork_new);
4003         }
4004
4005         free(path);
4006       }
4007
4008       // insert artwork info (from old cache or filesystem) into new cache
4009       if (artwork_new != NULL)
4010         setArtworkInfoCacheEntry(artwork_new, level_node, type);
4011     }
4012
4013     DrawInitText(level_node->name, 150, FC_YELLOW);
4014
4015     if (level_node->node_group != NULL)
4016     {
4017       TreeInfo *artwork_new = newTreeInfo();
4018
4019       if (node_parent)
4020         setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
4021       else
4022         setTreeInfoToDefaults(artwork_new, type);
4023
4024       artwork_new->level_group = TRUE;
4025
4026       setString(&artwork_new->identifier,   level_node->subdir);
4027
4028       if (node_parent == NULL)          // check for top tree node
4029       {
4030         char *top_node_name = (empty_level_set_mode ?
4031                                "artwork-only level sets" :
4032                                "artwork from level sets");
4033
4034         setString(&artwork_new->name,         top_node_name);
4035         setString(&artwork_new->name_sorting, top_node_name);
4036       }
4037       else
4038       {
4039         setString(&artwork_new->name,         level_node->name);
4040         setString(&artwork_new->name_sorting, level_node->name_sorting);
4041       }
4042
4043       pushTreeInfo(artwork_node, artwork_new);
4044
4045       // create node to link back to current custom artwork directory
4046       createParentTreeInfoNode(artwork_new);
4047
4048       // recursively step into sub-directory and look for more custom artwork
4049       LoadArtworkInfoFromLevelInfoExt(&artwork_new->node_group, artwork_new,
4050                                       level_node->node_group,
4051                                       empty_level_set_mode);
4052
4053       // if sub-tree has no custom artwork at all, remove it
4054       if (artwork_new->node_group->next == NULL)
4055         removeTreeInfo(artwork_node);
4056     }
4057
4058     level_node = level_node->next;
4059   }
4060 }
4061
4062 static void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node)
4063 {
4064   // move peviously loaded artwork tree into separate sub-tree
4065   MoveArtworkInfoIntoSubTree(artwork_node);
4066
4067   // load artwork from level sets into separate sub-trees
4068   LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, TRUE);
4069   LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, FALSE);
4070
4071   // set all parent links (back links) in complete artwork tree
4072   setTreeInfoParentNodes(*artwork_node, NULL);
4073 }
4074
4075 void LoadLevelArtworkInfo(void)
4076 {
4077   print_timestamp_init("LoadLevelArtworkInfo");
4078
4079   DrawInitText("Looking for custom level artwork", 120, FC_GREEN);
4080
4081   print_timestamp_time("DrawTimeText");
4082
4083   LoadArtworkInfoFromLevelInfo(&artwork.gfx_first);
4084   print_timestamp_time("LoadArtworkInfoFromLevelInfo (gfx)");
4085   LoadArtworkInfoFromLevelInfo(&artwork.snd_first);
4086   print_timestamp_time("LoadArtworkInfoFromLevelInfo (snd)");
4087   LoadArtworkInfoFromLevelInfo(&artwork.mus_first);
4088   print_timestamp_time("LoadArtworkInfoFromLevelInfo (mus)");
4089
4090   SaveArtworkInfoCache();
4091
4092   print_timestamp_time("SaveArtworkInfoCache");
4093
4094   // needed for reloading level artwork not known at ealier stage
4095   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_GRAPHICS);
4096   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_SOUNDS);
4097   ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_MUSIC);
4098
4099   print_timestamp_time("getTreeInfoFromIdentifier");
4100
4101   sortTreeInfo(&artwork.gfx_first);
4102   sortTreeInfo(&artwork.snd_first);
4103   sortTreeInfo(&artwork.mus_first);
4104
4105   print_timestamp_time("sortTreeInfo");
4106
4107 #if ENABLE_UNUSED_CODE
4108   dumpTreeInfo(artwork.gfx_first, 0);
4109   dumpTreeInfo(artwork.snd_first, 0);
4110   dumpTreeInfo(artwork.mus_first, 0);
4111 #endif
4112
4113   print_timestamp_done("LoadLevelArtworkInfo");
4114 }
4115
4116 static boolean AddTreeSetToTreeInfoExt(TreeInfo *tree_node_old, char *tree_dir,
4117                                        char *tree_subdir_new, int type)
4118 {
4119   if (tree_node_old == NULL)
4120   {
4121     if (type == TREE_TYPE_LEVEL_DIR)
4122     {
4123       // get level info tree node of personal user level set
4124       tree_node_old = getTreeInfoFromIdentifier(leveldir_first, getLoginName());
4125
4126       // this may happen if "setup.internal.create_user_levelset" is FALSE
4127       // or if file "levelinfo.conf" is missing in personal user level set
4128       if (tree_node_old == NULL)
4129         tree_node_old = leveldir_first->node_group;
4130     }
4131     else
4132     {
4133       // get artwork info tree node of first artwork set
4134       tree_node_old = ARTWORK_FIRST_NODE(artwork, type);
4135     }
4136   }
4137
4138   if (tree_dir == NULL)
4139     tree_dir = TREE_USERDIR(type);
4140
4141   if (tree_node_old   == NULL ||
4142       tree_dir        == NULL ||
4143       tree_subdir_new == NULL)          // should not happen
4144     return FALSE;
4145
4146   int draw_deactivation_mask = GetDrawDeactivationMask();
4147
4148   // override draw deactivation mask (temporarily disable drawing)
4149   SetDrawDeactivationMask(REDRAW_ALL);
4150
4151   if (type == TREE_TYPE_LEVEL_DIR)
4152   {
4153     // load new level set config and add it next to first user level set
4154     LoadLevelInfoFromLevelConf(&tree_node_old->next,
4155                                tree_node_old->node_parent,
4156                                tree_dir, tree_subdir_new);
4157   }
4158   else
4159   {
4160     // load new artwork set config and add it next to first artwork set
4161     LoadArtworkInfoFromArtworkConf(&tree_node_old->next,
4162                                    tree_node_old->node_parent,
4163                                    tree_dir, tree_subdir_new, type);
4164   }
4165
4166   // set draw deactivation mask to previous value
4167   SetDrawDeactivationMask(draw_deactivation_mask);
4168
4169   // get first node of level or artwork info tree
4170   TreeInfo **tree_node_first = TREE_FIRST_NODE_PTR(type);
4171
4172   // get tree info node of newly added level or artwork set
4173   TreeInfo *tree_node_new = getTreeInfoFromIdentifier(*tree_node_first,
4174                                                       tree_subdir_new);
4175
4176   if (tree_node_new == NULL)            // should not happen
4177     return FALSE;
4178
4179   // correct top link and parent node link of newly created tree node
4180   tree_node_new->node_top    = tree_node_old->node_top;
4181   tree_node_new->node_parent = tree_node_old->node_parent;
4182
4183   // sort tree info to adjust position of newly added tree set
4184   sortTreeInfo(tree_node_first);
4185
4186   return TRUE;
4187 }
4188
4189 void AddTreeSetToTreeInfo(TreeInfo *tree_node, char *tree_dir,
4190                           char *tree_subdir_new, int type)
4191 {
4192   if (!AddTreeSetToTreeInfoExt(tree_node, tree_dir, tree_subdir_new, type))
4193     Fail("internal tree info structure corrupted -- aborting");
4194 }
4195
4196 void AddUserLevelSetToLevelInfo(char *level_subdir_new)
4197 {
4198   AddTreeSetToTreeInfo(NULL, NULL, level_subdir_new, TREE_TYPE_LEVEL_DIR);
4199 }
4200
4201 char *getArtworkIdentifierForUserLevelSet(int type)
4202 {
4203   char *classic_artwork_set = getClassicArtworkSet(type);
4204
4205   // check for custom artwork configured in "levelinfo.conf"
4206   char *leveldir_artwork_set =
4207     *LEVELDIR_ARTWORK_SET_PTR(leveldir_current, type);
4208   boolean has_leveldir_artwork_set =
4209     (leveldir_artwork_set != NULL && !strEqual(leveldir_artwork_set,
4210                                                classic_artwork_set));
4211
4212   // check for custom artwork in sub-directory "graphics" etc.
4213   TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
4214   char *leveldir_identifier = leveldir_current->identifier;
4215   boolean has_artwork_subdir =
4216     (getTreeInfoFromIdentifier(artwork_first_node,
4217                                leveldir_identifier) != NULL);
4218
4219   return (has_leveldir_artwork_set ? leveldir_artwork_set :
4220           has_artwork_subdir       ? leveldir_identifier :
4221           classic_artwork_set);
4222 }
4223
4224 TreeInfo *getArtworkTreeInfoForUserLevelSet(int type)
4225 {
4226   char *artwork_set = getArtworkIdentifierForUserLevelSet(type);
4227   TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
4228   TreeInfo *ti = getTreeInfoFromIdentifier(artwork_first_node, artwork_set);
4229
4230   if (ti == NULL)
4231   {
4232     ti = getTreeInfoFromIdentifier(artwork_first_node,
4233                                    ARTWORK_DEFAULT_SUBDIR(type));
4234     if (ti == NULL)
4235       Fail("cannot find default graphics -- should not happen");
4236   }
4237
4238   return ti;
4239 }
4240
4241 boolean checkIfCustomArtworkExistsForCurrentLevelSet(void)
4242 {
4243   char *graphics_set =
4244     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
4245   char *sounds_set =
4246     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_SOUNDS);
4247   char *music_set =
4248     getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_MUSIC);
4249
4250   return (!strEqual(graphics_set, GFX_CLASSIC_SUBDIR) ||
4251           !strEqual(sounds_set,   SND_CLASSIC_SUBDIR) ||
4252           !strEqual(music_set,    MUS_CLASSIC_SUBDIR));
4253 }
4254
4255 boolean UpdateUserLevelSet(char *level_subdir, char *level_name,
4256                            char *level_author, int num_levels)
4257 {
4258   char *filename = getPath2(getUserLevelDir(level_subdir), LEVELINFO_FILENAME);
4259   char *filename_tmp = getStringCat2(filename, ".tmp");
4260   FILE *file = NULL;
4261   FILE *file_tmp = NULL;
4262   char line[MAX_LINE_LEN];
4263   boolean success = FALSE;
4264   LevelDirTree *leveldir = getTreeInfoFromIdentifier(leveldir_first,
4265                                                      level_subdir);
4266   // update values in level directory tree
4267
4268   if (level_name != NULL)
4269     setString(&leveldir->name, level_name);
4270
4271   if (level_author != NULL)
4272     setString(&leveldir->author, level_author);
4273
4274   if (num_levels != -1)
4275     leveldir->levels = num_levels;
4276
4277   // update values that depend on other values
4278
4279   setString(&leveldir->name_sorting, leveldir->name);
4280
4281   leveldir->last_level = leveldir->first_level + leveldir->levels - 1;
4282
4283   // sort order of level sets may have changed
4284   sortTreeInfo(&leveldir_first);
4285
4286   if ((file     = fopen(filename,     MODE_READ)) &&
4287       (file_tmp = fopen(filename_tmp, MODE_WRITE)))
4288   {
4289     while (fgets(line, MAX_LINE_LEN, file))
4290     {
4291       if (strPrefix(line, "name:") && level_name != NULL)
4292         fprintf(file_tmp, "%-32s%s\n", "name:", level_name);
4293       else if (strPrefix(line, "author:") && level_author != NULL)
4294         fprintf(file_tmp, "%-32s%s\n", "author:", level_author);
4295       else if (strPrefix(line, "levels:") && num_levels != -1)
4296         fprintf(file_tmp, "%-32s%d\n", "levels:", num_levels);
4297       else
4298         fputs(line, file_tmp);
4299     }
4300
4301     success = TRUE;
4302   }
4303
4304   if (file)
4305     fclose(file);
4306
4307   if (file_tmp)
4308     fclose(file_tmp);
4309
4310   if (success)
4311     success = (rename(filename_tmp, filename) == 0);
4312
4313   free(filename);
4314   free(filename_tmp);
4315
4316   return success;
4317 }
4318
4319 boolean CreateUserLevelSet(char *level_subdir, char *level_name,
4320                            char *level_author, int num_levels,
4321                            boolean use_artwork_set)
4322 {
4323   LevelDirTree *level_info;
4324   char *filename;
4325   FILE *file;
4326   int i;
4327
4328   // create user level sub-directory, if needed
4329   createDirectory(getUserLevelDir(level_subdir), "user level", PERMS_PRIVATE);
4330
4331   filename = getPath2(getUserLevelDir(level_subdir), LEVELINFO_FILENAME);
4332
4333   if (!(file = fopen(filename, MODE_WRITE)))
4334   {
4335     Warn("cannot write level info file '%s'", filename);
4336
4337     free(filename);
4338
4339     return FALSE;
4340   }
4341
4342   level_info = newTreeInfo();
4343
4344   // always start with reliable default values
4345   setTreeInfoToDefaults(level_info, TREE_TYPE_LEVEL_DIR);
4346
4347   setString(&level_info->name, level_name);
4348   setString(&level_info->author, level_author);
4349   level_info->levels = num_levels;
4350   level_info->first_level = 1;
4351   level_info->sort_priority = LEVELCLASS_PRIVATE_START;
4352   level_info->readonly = FALSE;
4353
4354   if (use_artwork_set)
4355   {
4356     level_info->graphics_set =
4357       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS));
4358     level_info->sounds_set =
4359       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_SOUNDS));
4360     level_info->music_set =
4361       getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_MUSIC));
4362   }
4363
4364   token_value_position = TOKEN_VALUE_POSITION_SHORT;
4365
4366   fprintFileHeader(file, LEVELINFO_FILENAME);
4367
4368   ldi = *level_info;
4369   for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
4370   {
4371     if (i == LEVELINFO_TOKEN_NAME ||
4372         i == LEVELINFO_TOKEN_AUTHOR ||
4373         i == LEVELINFO_TOKEN_LEVELS ||
4374         i == LEVELINFO_TOKEN_FIRST_LEVEL ||
4375         i == LEVELINFO_TOKEN_SORT_PRIORITY ||
4376         i == LEVELINFO_TOKEN_READONLY ||
4377         (use_artwork_set && (i == LEVELINFO_TOKEN_GRAPHICS_SET ||
4378                              i == LEVELINFO_TOKEN_SOUNDS_SET ||
4379                              i == LEVELINFO_TOKEN_MUSIC_SET)))
4380       fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
4381
4382     // just to make things nicer :)
4383     if (i == LEVELINFO_TOKEN_AUTHOR ||
4384         i == LEVELINFO_TOKEN_FIRST_LEVEL ||
4385         (use_artwork_set && i == LEVELINFO_TOKEN_READONLY))
4386       fprintf(file, "\n");
4387   }
4388
4389   token_value_position = TOKEN_VALUE_POSITION_DEFAULT;
4390
4391   fclose(file);
4392
4393   SetFilePermissions(filename, PERMS_PRIVATE);
4394
4395   freeTreeInfo(level_info);
4396   free(filename);
4397
4398   return TRUE;
4399 }
4400
4401 static void SaveUserLevelInfo(void)
4402 {
4403   CreateUserLevelSet(getLoginName(), getLoginName(), getRealName(), 100, FALSE);
4404 }
4405
4406 char *getSetupValue(int type, void *value)
4407 {
4408   static char value_string[MAX_LINE_LEN];
4409
4410   if (value == NULL)
4411     return NULL;
4412
4413   switch (type)
4414   {
4415     case TYPE_BOOLEAN:
4416       strcpy(value_string, (*(boolean *)value ? "true" : "false"));
4417       break;
4418
4419     case TYPE_SWITCH:
4420       strcpy(value_string, (*(boolean *)value ? "on" : "off"));
4421       break;
4422
4423     case TYPE_SWITCH3:
4424       strcpy(value_string, (*(int *)value == AUTO  ? "auto" :
4425                             *(int *)value == FALSE ? "off" : "on"));
4426       break;
4427
4428     case TYPE_YES_NO:
4429       strcpy(value_string, (*(boolean *)value ? "yes" : "no"));
4430       break;
4431
4432     case TYPE_YES_NO_AUTO:
4433       strcpy(value_string, (*(int *)value == AUTO  ? "auto" :
4434                             *(int *)value == FALSE ? "no" : "yes"));
4435       break;
4436
4437     case TYPE_ECS_AGA:
4438       strcpy(value_string, (*(boolean *)value ? "AGA" : "ECS"));
4439       break;
4440
4441     case TYPE_KEY:
4442       strcpy(value_string, getKeyNameFromKey(*(Key *)value));
4443       break;
4444
4445     case TYPE_KEY_X11:
4446       strcpy(value_string, getX11KeyNameFromKey(*(Key *)value));
4447       break;
4448
4449     case TYPE_INTEGER:
4450       sprintf(value_string, "%d", *(int *)value);
4451       break;
4452
4453     case TYPE_STRING:
4454       if (*(char **)value == NULL)
4455         return NULL;
4456
4457       strcpy(value_string, *(char **)value);
4458       break;
4459
4460     case TYPE_PLAYER:
4461       sprintf(value_string, "player_%d", *(int *)value + 1);
4462       break;
4463
4464     default:
4465       value_string[0] = '\0';
4466       break;
4467   }
4468
4469   if (type & TYPE_GHOSTED)
4470     strcpy(value_string, "n/a");
4471
4472   return value_string;
4473 }
4474
4475 char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
4476 {
4477   int i;
4478   char *line;
4479   static char token_string[MAX_LINE_LEN];
4480   int token_type = token_info[token_nr].type;
4481   void *setup_value = token_info[token_nr].value;
4482   char *token_text = token_info[token_nr].text;
4483   char *value_string = getSetupValue(token_type, setup_value);
4484
4485   // build complete token string
4486   sprintf(token_string, "%s%s", prefix, token_text);
4487
4488   // build setup entry line
4489   line = getFormattedSetupEntry(token_string, value_string);
4490
4491   if (token_type == TYPE_KEY_X11)
4492   {
4493     Key key = *(Key *)setup_value;
4494     char *keyname = getKeyNameFromKey(key);
4495
4496     // add comment, if useful
4497     if (!strEqual(keyname, "(undefined)") &&
4498         !strEqual(keyname, "(unknown)"))
4499     {
4500       // add at least one whitespace
4501       strcat(line, " ");
4502       for (i = strlen(line); i < token_comment_position; i++)
4503         strcat(line, " ");
4504
4505       strcat(line, "# ");
4506       strcat(line, keyname);
4507     }
4508   }
4509
4510   return line;
4511 }
4512
4513 static void InitLastPlayedLevels_ParentNode(void)
4514 {
4515   LevelDirTree **leveldir_top = &leveldir_first->node_group->next;
4516   LevelDirTree *leveldir_new = NULL;
4517
4518   // check if parent node for last played levels already exists
4519   if (strEqual((*leveldir_top)->identifier, TOKEN_STR_LAST_LEVEL_SERIES))
4520     return;
4521
4522   leveldir_new = newTreeInfo();
4523
4524   setTreeInfoToDefaultsFromParent(leveldir_new, leveldir_first);
4525
4526   leveldir_new->level_group = TRUE;
4527
4528   setString(&leveldir_new->identifier, TOKEN_STR_LAST_LEVEL_SERIES);
4529   setString(&leveldir_new->name, "<< (last played level sets)");
4530
4531   pushTreeInfo(leveldir_top, leveldir_new);
4532
4533   // create node to link back to current level directory
4534   createParentTreeInfoNode(leveldir_new);
4535 }
4536
4537 void UpdateLastPlayedLevels_TreeInfo(void)
4538 {
4539   char **last_level_series = setup.level_setup.last_level_series;
4540   boolean reset_leveldir_current = FALSE;
4541   LevelDirTree *leveldir_last;
4542   TreeInfo **node_new = NULL;
4543   int i;
4544
4545   if (last_level_series[0] == NULL)
4546     return;
4547
4548   InitLastPlayedLevels_ParentNode();
4549
4550   // check if current level set is from "last played" sub-tree to be rebuilt
4551   reset_leveldir_current = strEqual(leveldir_current->node_parent->identifier,
4552                                     TOKEN_STR_LAST_LEVEL_SERIES);
4553
4554   leveldir_last = getTreeInfoFromIdentifierExt(leveldir_first,
4555                                                TOKEN_STR_LAST_LEVEL_SERIES,
4556                                                TRUE);
4557   if (leveldir_last == NULL)
4558     return;
4559
4560   node_new = &leveldir_last->node_group->next;
4561
4562   freeTreeInfo(*node_new);
4563
4564   for (i = 0; last_level_series[i] != NULL; i++)
4565   {
4566     LevelDirTree *node_last = getTreeInfoFromIdentifier(leveldir_first,
4567                                                         last_level_series[i]);
4568
4569     *node_new = getTreeInfoCopy(node_last);     // copy complete node
4570
4571     (*node_new)->node_top = &leveldir_first;    // correct top node link
4572     (*node_new)->node_parent = leveldir_last;   // correct parent node link
4573
4574     (*node_new)->node_group = NULL;
4575     (*node_new)->next = NULL;
4576
4577     (*node_new)->cl_first = -1;                 // force setting tree cursor
4578
4579     node_new = &((*node_new)->next);
4580   }
4581
4582   if (reset_leveldir_current)
4583     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4584                                                  last_level_series[0]);
4585 }
4586
4587 static void UpdateLastPlayedLevels_List(void)
4588 {
4589   char **last_level_series = setup.level_setup.last_level_series;
4590   int pos = MAX_LEVELDIR_HISTORY - 1;
4591   int i;
4592
4593   // search for potentially already existing entry in list of level sets
4594   for (i = 0; last_level_series[i] != NULL; i++)
4595     if (strEqual(last_level_series[i], leveldir_current->identifier))
4596       pos = i;
4597
4598   // move list of level sets one entry down (using potentially free entry)
4599   for (i = pos; i > 0; i--)
4600     setString(&last_level_series[i], last_level_series[i - 1]);
4601
4602   // put last played level set at top position
4603   setString(&last_level_series[0], leveldir_current->identifier);
4604 }
4605
4606 void LoadLevelSetup_LastSeries(void)
4607 {
4608   // --------------------------------------------------------------------------
4609   // ~/.<program>/levelsetup.conf
4610   // --------------------------------------------------------------------------
4611
4612   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
4613   SetupFileHash *level_setup_hash = NULL;
4614   int pos = 0;
4615   int i;
4616
4617   // always start with reliable default values
4618   leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4619
4620   // start with empty history of last played level sets
4621   setString(&setup.level_setup.last_level_series[0], NULL);
4622
4623   if (!strEqual(DEFAULT_LEVELSET, UNDEFINED_LEVELSET))
4624   {
4625     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4626                                                  DEFAULT_LEVELSET);
4627     if (leveldir_current == NULL)
4628       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4629   }
4630
4631   if ((level_setup_hash = loadSetupFileHash(filename)))
4632   {
4633     char *last_level_series =
4634       getHashEntry(level_setup_hash, TOKEN_STR_LAST_LEVEL_SERIES);
4635
4636     leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
4637                                                  last_level_series);
4638     if (leveldir_current == NULL)
4639       leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4640
4641     for (i = 0; i < MAX_LEVELDIR_HISTORY; i++)
4642     {
4643       char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
4644       LevelDirTree *leveldir_last;
4645
4646       sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
4647
4648       last_level_series = getHashEntry(level_setup_hash, token);
4649
4650       leveldir_last = getTreeInfoFromIdentifier(leveldir_first,
4651                                                 last_level_series);
4652       if (leveldir_last != NULL)
4653         setString(&setup.level_setup.last_level_series[pos++],
4654                   last_level_series);
4655     }
4656
4657     setString(&setup.level_setup.last_level_series[pos], NULL);
4658
4659     freeSetupFileHash(level_setup_hash);
4660   }
4661   else
4662   {
4663     Debug("setup", "using default setup values");
4664   }
4665
4666   free(filename);
4667 }
4668
4669 static void SaveLevelSetup_LastSeries_Ext(boolean deactivate_last_level_series)
4670 {
4671   // --------------------------------------------------------------------------
4672   // ~/.<program>/levelsetup.conf
4673   // --------------------------------------------------------------------------
4674
4675   // check if the current level directory structure is available at this point
4676   if (leveldir_current == NULL)
4677     return;
4678
4679   char **last_level_series = setup.level_setup.last_level_series;
4680   char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
4681   FILE *file;
4682   int i;
4683
4684   InitUserDataDirectory();
4685
4686   UpdateLastPlayedLevels_List();
4687
4688   if (!(file = fopen(filename, MODE_WRITE)))
4689   {
4690     Warn("cannot write setup file '%s'", filename);
4691
4692     free(filename);
4693
4694     return;
4695   }
4696
4697   fprintFileHeader(file, LEVELSETUP_FILENAME);
4698
4699   if (deactivate_last_level_series)
4700     fprintf(file, "# %s\n# ", "the following level set may have caused a problem and was deactivated");
4701
4702   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES,
4703                                                leveldir_current->identifier));
4704
4705   for (i = 0; last_level_series[i] != NULL; i++)
4706   {
4707     char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
4708
4709     sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
4710
4711     fprintf(file, "%s\n", getFormattedSetupEntry(token, last_level_series[i]));
4712   }
4713
4714   fclose(file);
4715
4716   SetFilePermissions(filename, PERMS_PRIVATE);
4717
4718   free(filename);
4719 }
4720
4721 void SaveLevelSetup_LastSeries(void)
4722 {
4723   SaveLevelSetup_LastSeries_Ext(FALSE);
4724 }
4725
4726 void SaveLevelSetup_LastSeries_Deactivate(void)
4727 {
4728   SaveLevelSetup_LastSeries_Ext(TRUE);
4729 }
4730
4731 static void checkSeriesInfo(void)
4732 {
4733   static char *level_directory = NULL;
4734   Directory *dir;
4735 #if 0
4736   DirectoryEntry *dir_entry;
4737 #endif
4738
4739   checked_free(level_directory);
4740
4741   // check for more levels besides the 'levels' field of 'levelinfo.conf'
4742
4743   level_directory = getPath2((leveldir_current->in_user_dir ?
4744                               getUserLevelDir(NULL) :
4745                               options.level_directory),
4746                              leveldir_current->fullpath);
4747
4748   if ((dir = openDirectory(level_directory)) == NULL)
4749   {
4750     Warn("cannot read level directory '%s'", level_directory);
4751
4752     return;
4753   }
4754
4755 #if 0
4756   while ((dir_entry = readDirectory(dir)) != NULL)      // loop all entries
4757   {
4758     if (strlen(dir_entry->basename) > 4 &&
4759         dir_entry->basename[3] == '.' &&
4760         strEqual(&dir_entry->basename[4], LEVELFILE_EXTENSION))
4761     {
4762       char levelnum_str[4];
4763       int levelnum_value;
4764
4765       strncpy(levelnum_str, dir_entry->basename, 3);
4766       levelnum_str[3] = '\0';
4767
4768       levelnum_value = atoi(levelnum_str);
4769
4770       if (levelnum_value < leveldir_current->first_level)
4771       {
4772         Warn("additional level %d found", levelnum_value);
4773
4774         leveldir_current->first_level = levelnum_value;
4775       }
4776       else if (levelnum_value > leveldir_current->last_level)
4777       {
4778         Warn("additional level %d found", levelnum_value);
4779
4780         leveldir_current->last_level = levelnum_value;
4781       }
4782     }
4783   }
4784 #endif
4785
4786   closeDirectory(dir);
4787 }
4788
4789 void LoadLevelSetup_SeriesInfo(void)
4790 {
4791   char *filename;
4792   SetupFileHash *level_setup_hash = NULL;
4793   char *level_subdir = leveldir_current->subdir;
4794   int i;
4795
4796   // always start with reliable default values
4797   level_nr = leveldir_current->first_level;
4798
4799   for (i = 0; i < MAX_LEVELS; i++)
4800   {
4801     LevelStats_setPlayed(i, 0);
4802     LevelStats_setSolved(i, 0);
4803   }
4804
4805   checkSeriesInfo();
4806
4807   // --------------------------------------------------------------------------
4808   // ~/.<program>/levelsetup/<level series>/levelsetup.conf
4809   // --------------------------------------------------------------------------
4810
4811   level_subdir = leveldir_current->subdir;
4812
4813   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
4814
4815   if ((level_setup_hash = loadSetupFileHash(filename)))
4816   {
4817     char *token_value;
4818
4819     // get last played level in this level set
4820
4821     token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL);
4822
4823     if (token_value)
4824     {
4825       level_nr = atoi(token_value);
4826
4827       if (level_nr < leveldir_current->first_level)
4828         level_nr = leveldir_current->first_level;
4829       if (level_nr > leveldir_current->last_level)
4830         level_nr = leveldir_current->last_level;
4831     }
4832
4833     // get handicap level in this level set
4834
4835     token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL);
4836
4837     if (token_value)
4838     {
4839       int level_nr = atoi(token_value);
4840
4841       if (level_nr < leveldir_current->first_level)
4842         level_nr = leveldir_current->first_level;
4843       if (level_nr > leveldir_current->last_level + 1)
4844         level_nr = leveldir_current->last_level;
4845
4846       if (leveldir_current->user_defined || !leveldir_current->handicap)
4847         level_nr = leveldir_current->last_level;
4848
4849       leveldir_current->handicap_level = level_nr;
4850     }
4851
4852     // get number of played and solved levels in this level set
4853
4854     BEGIN_HASH_ITERATION(level_setup_hash, itr)
4855     {
4856       char *token = HASH_ITERATION_TOKEN(itr);
4857       char *value = HASH_ITERATION_VALUE(itr);
4858
4859       if (strlen(token) == 3 &&
4860           token[0] >= '0' && token[0] <= '9' &&
4861           token[1] >= '0' && token[1] <= '9' &&
4862           token[2] >= '0' && token[2] <= '9')
4863       {
4864         int level_nr = atoi(token);
4865
4866         if (value != NULL)
4867           LevelStats_setPlayed(level_nr, atoi(value));  // read 1st column
4868
4869         value = strchr(value, ' ');
4870
4871         if (value != NULL)
4872           LevelStats_setSolved(level_nr, atoi(value));  // read 2nd column
4873       }
4874     }
4875     END_HASH_ITERATION(hash, itr)
4876
4877     freeSetupFileHash(level_setup_hash);
4878   }
4879   else
4880   {
4881     Debug("setup", "using default setup values");
4882   }
4883
4884   free(filename);
4885 }
4886
4887 void SaveLevelSetup_SeriesInfo(void)
4888 {
4889   char *filename;
4890   char *level_subdir = leveldir_current->subdir;
4891   char *level_nr_str = int2str(level_nr, 0);
4892   char *handicap_level_str = int2str(leveldir_current->handicap_level, 0);
4893   FILE *file;
4894   int i;
4895
4896   // --------------------------------------------------------------------------
4897   // ~/.<program>/levelsetup/<level series>/levelsetup.conf
4898   // --------------------------------------------------------------------------
4899
4900   InitLevelSetupDirectory(level_subdir);
4901
4902   filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
4903
4904   if (!(file = fopen(filename, MODE_WRITE)))
4905   {
4906     Warn("cannot write setup file '%s'", filename);
4907
4908     free(filename);
4909
4910     return;
4911   }
4912
4913   fprintFileHeader(file, LEVELSETUP_FILENAME);
4914
4915   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_PLAYED_LEVEL,
4916                                                level_nr_str));
4917   fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL,
4918                                                  handicap_level_str));
4919
4920   for (i = leveldir_current->first_level; i <= leveldir_current->last_level;
4921        i++)
4922   {
4923     if (LevelStats_getPlayed(i) > 0 ||
4924         LevelStats_getSolved(i) > 0)
4925     {
4926       char token[16];
4927       char value[16];
4928
4929       sprintf(token, "%03d", i);
4930       sprintf(value, "%d %d", LevelStats_getPlayed(i), LevelStats_getSolved(i));
4931
4932       fprintf(file, "%s\n", getFormattedSetupEntry(token, value));
4933     }
4934   }
4935
4936   fclose(file);
4937
4938   SetFilePermissions(filename, PERMS_PRIVATE);
4939
4940   free(filename);
4941 }
4942
4943 int LevelStats_getPlayed(int nr)
4944 {
4945   return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].played : 0);
4946 }
4947
4948 int LevelStats_getSolved(int nr)
4949 {
4950   return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].solved : 0);
4951 }
4952
4953 void LevelStats_setPlayed(int nr, int value)
4954 {
4955   if (nr >= 0 && nr < MAX_LEVELS)
4956     level_stats[nr].played = value;
4957 }
4958
4959 void LevelStats_setSolved(int nr, int value)
4960 {
4961   if (nr >= 0 && nr < MAX_LEVELS)
4962     level_stats[nr].solved = value;
4963 }
4964
4965 void LevelStats_incPlayed(int nr)
4966 {
4967   if (nr >= 0 && nr < MAX_LEVELS)
4968     level_stats[nr].played++;
4969 }
4970
4971 void LevelStats_incSolved(int nr)
4972 {
4973   if (nr >= 0 && nr < MAX_LEVELS)
4974     level_stats[nr].solved++;
4975 }
4976
4977 void LoadUserSetup(void)
4978 {
4979   // --------------------------------------------------------------------------
4980   // ~/.<program>/usersetup.conf
4981   // --------------------------------------------------------------------------
4982
4983   char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
4984   SetupFileHash *user_setup_hash = NULL;
4985
4986   // always start with reliable default values
4987   user.nr = 0;
4988
4989   if ((user_setup_hash = loadSetupFileHash(filename)))
4990   {
4991     char *token_value;
4992
4993     // get last selected user number
4994     token_value = getHashEntry(user_setup_hash, TOKEN_STR_LAST_USER);
4995
4996     if (token_value)
4997       user.nr = MIN(MAX(0, atoi(token_value)), MAX_PLAYER_NAMES - 1);
4998
4999     freeSetupFileHash(user_setup_hash);
5000   }
5001   else
5002   {
5003     Debug("setup", "using default setup values");
5004   }
5005
5006   free(filename);
5007 }
5008
5009 void SaveUserSetup(void)
5010 {
5011   // --------------------------------------------------------------------------
5012   // ~/.<program>/usersetup.conf
5013   // --------------------------------------------------------------------------
5014
5015   char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
5016   FILE *file;
5017
5018   InitMainUserDataDirectory();
5019
5020   if (!(file = fopen(filename, MODE_WRITE)))
5021   {
5022     Warn("cannot write setup file '%s'", filename);
5023
5024     free(filename);
5025
5026     return;
5027   }
5028
5029   fprintFileHeader(file, USERSETUP_FILENAME);
5030
5031   fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_USER,
5032                                                i_to_a(user.nr)));
5033   fclose(file);
5034
5035   SetFilePermissions(filename, PERMS_PRIVATE);
5036
5037   free(filename);
5038 }