1 // ============================================================================
2 // Artsoft Retro-Game Library
3 // ----------------------------------------------------------------------------
4 // (c) 1995-2014 by Artsoft Entertainment
7 // https://www.artsoft.org/
8 // ----------------------------------------------------------------------------
10 // ============================================================================
12 #include <sys/types.h>
27 #include "zip/miniunz.h"
30 #define ENABLE_UNUSED_CODE FALSE // for currently unused functions
31 #define DEBUG_NO_CONFIG_FILE FALSE // for extra-verbose debug output
33 #define NUM_LEVELCLASS_DESC 8
35 static char *levelclass_desc[NUM_LEVELCLASS_DESC] =
47 #define TOKEN_VALUE_POSITION_SHORT 32
48 #define TOKEN_VALUE_POSITION_DEFAULT 40
49 #define TOKEN_COMMENT_POSITION_DEFAULT 60
51 #define TREE_NODE_TYPE_DEFAULT 0
52 #define TREE_NODE_TYPE_PARENT 1
53 #define TREE_NODE_TYPE_GROUP 2
54 #define TREE_NODE_TYPE_COPY 3
56 #define TREE_NODE_TYPE(ti) (ti->node_group ? TREE_NODE_TYPE_GROUP : \
57 ti->parent_link ? TREE_NODE_TYPE_PARENT : \
58 ti->is_copy ? TREE_NODE_TYPE_COPY : \
59 TREE_NODE_TYPE_DEFAULT)
62 static void setTreeInfoToDefaults(TreeInfo *, int);
63 static TreeInfo *getTreeInfoCopy(TreeInfo *ti);
64 static int compareTreeInfoEntries(const void *, const void *);
66 static int token_value_position = TOKEN_VALUE_POSITION_DEFAULT;
67 static int token_comment_position = TOKEN_COMMENT_POSITION_DEFAULT;
69 static SetupFileHash *artworkinfo_cache_old = NULL;
70 static SetupFileHash *artworkinfo_cache_new = NULL;
71 static SetupFileHash *optional_tokens_hash = NULL;
72 static SetupFileHash *missing_file_hash = NULL;
73 static boolean use_artworkinfo_cache = TRUE;
74 static boolean update_artworkinfo_cache = FALSE;
77 // ----------------------------------------------------------------------------
79 // ----------------------------------------------------------------------------
81 static void WarnUsingFallback(char *filename)
83 if (getHashEntry(missing_file_hash, filename) == NULL)
85 setHashEntry(missing_file_hash, filename, "");
87 Debug("setup", "cannot find artwork file '%s' (using fallback)", filename);
91 static char *getLevelClassDescription(TreeInfo *ti)
93 int position = ti->sort_priority / 100;
95 if (position >= 0 && position < NUM_LEVELCLASS_DESC)
96 return levelclass_desc[position];
98 return "Unknown Level Class";
101 static char *getCacheDir(void)
103 static char *cache_dir = NULL;
105 if (cache_dir == NULL)
106 cache_dir = getPath2(getMainUserGameDataDir(), CACHE_DIRECTORY);
111 static char *getScoreDir(char *level_subdir)
113 static char *score_dir = NULL;
114 static char *score_level_dir = NULL;
115 char *score_subdir = SCORES_DIRECTORY;
117 if (score_dir == NULL)
118 score_dir = getPath2(getMainUserGameDataDir(), score_subdir);
120 if (level_subdir != NULL)
122 checked_free(score_level_dir);
124 score_level_dir = getPath2(score_dir, level_subdir);
126 return score_level_dir;
132 static char *getScoreCacheDir(char *level_subdir)
134 static char *score_dir = NULL;
135 static char *score_level_dir = NULL;
136 char *score_subdir = SCORES_DIRECTORY;
138 if (score_dir == NULL)
139 score_dir = getPath2(getCacheDir(), score_subdir);
141 if (level_subdir != NULL)
143 checked_free(score_level_dir);
145 score_level_dir = getPath2(score_dir, level_subdir);
147 return score_level_dir;
153 static char *getScoreTapeDir(char *level_subdir, int nr)
155 static char *score_tape_dir = NULL;
156 char tape_subdir[MAX_FILENAME_LEN];
158 checked_free(score_tape_dir);
160 sprintf(tape_subdir, "%03d", nr);
161 score_tape_dir = getPath2(getScoreDir(level_subdir), tape_subdir);
163 return score_tape_dir;
166 static char *getScoreCacheTapeDir(char *level_subdir, int nr)
168 static char *score_cache_tape_dir = NULL;
169 char tape_subdir[MAX_FILENAME_LEN];
171 checked_free(score_cache_tape_dir);
173 sprintf(tape_subdir, "%03d", nr);
174 score_cache_tape_dir = getPath2(getScoreCacheDir(level_subdir), tape_subdir);
176 return score_cache_tape_dir;
179 static char *getUserSubdir(int nr)
181 static char user_subdir[16] = { 0 };
183 sprintf(user_subdir, "%03d", nr);
188 static char *getUserDir(int nr)
190 static char *user_dir = NULL;
191 char *main_data_dir = getMainUserGameDataDir();
192 char *users_subdir = USERS_DIRECTORY;
193 char *user_subdir = getUserSubdir(nr);
195 checked_free(user_dir);
198 user_dir = getPath3(main_data_dir, users_subdir, user_subdir);
200 user_dir = getPath2(main_data_dir, users_subdir);
205 static char *getLevelSetupDir(char *level_subdir)
207 static char *levelsetup_dir = NULL;
208 char *data_dir = getUserGameDataDir();
209 char *levelsetup_subdir = LEVELSETUP_DIRECTORY;
211 checked_free(levelsetup_dir);
213 if (level_subdir != NULL)
214 levelsetup_dir = getPath3(data_dir, levelsetup_subdir, level_subdir);
216 levelsetup_dir = getPath2(data_dir, levelsetup_subdir);
218 return levelsetup_dir;
221 static char *getNetworkDir(void)
223 static char *network_dir = NULL;
225 if (network_dir == NULL)
226 network_dir = getPath2(getMainUserGameDataDir(), NETWORK_DIRECTORY);
231 char *getLevelDirFromTreeInfo(TreeInfo *node)
233 static char *level_dir = NULL;
236 return options.level_directory;
238 checked_free(level_dir);
240 level_dir = getPath2((node->in_user_dir ? getUserLevelDir(NULL) :
241 options.level_directory), node->fullpath);
246 char *getUserLevelDir(char *level_subdir)
248 static char *userlevel_dir = NULL;
249 char *data_dir = getMainUserGameDataDir();
250 char *userlevel_subdir = LEVELS_DIRECTORY;
252 checked_free(userlevel_dir);
254 if (level_subdir != NULL)
255 userlevel_dir = getPath3(data_dir, userlevel_subdir, level_subdir);
257 userlevel_dir = getPath2(data_dir, userlevel_subdir);
259 return userlevel_dir;
262 char *getNetworkLevelDir(char *level_subdir)
264 static char *network_level_dir = NULL;
265 char *data_dir = getNetworkDir();
266 char *networklevel_subdir = LEVELS_DIRECTORY;
268 checked_free(network_level_dir);
270 if (level_subdir != NULL)
271 network_level_dir = getPath3(data_dir, networklevel_subdir, level_subdir);
273 network_level_dir = getPath2(data_dir, networklevel_subdir);
275 return network_level_dir;
278 char *getCurrentLevelDir(void)
280 return getLevelDirFromTreeInfo(leveldir_current);
283 char *getNewUserLevelSubdir(void)
285 static char *new_level_subdir = NULL;
286 char *subdir_prefix = getLoginName();
287 char subdir_suffix[10];
288 int max_suffix_number = 1000;
291 while (++i < max_suffix_number)
293 sprintf(subdir_suffix, "_%d", i);
295 checked_free(new_level_subdir);
296 new_level_subdir = getStringCat2(subdir_prefix, subdir_suffix);
298 if (!directoryExists(getUserLevelDir(new_level_subdir)))
302 return new_level_subdir;
305 char *getTapeDir(char *level_subdir)
307 static char *tape_dir = NULL;
308 char *data_dir = getUserGameDataDir();
309 char *tape_subdir = TAPES_DIRECTORY;
311 checked_free(tape_dir);
313 if (level_subdir != NULL)
314 tape_dir = getPath3(data_dir, tape_subdir, level_subdir);
316 tape_dir = getPath2(data_dir, tape_subdir);
321 static char *getSolutionTapeDir(void)
323 static char *tape_dir = NULL;
324 char *data_dir = getCurrentLevelDir();
325 char *tape_subdir = TAPES_DIRECTORY;
327 checked_free(tape_dir);
329 tape_dir = getPath2(data_dir, tape_subdir);
334 static char *getDefaultGraphicsDir(char *graphics_subdir)
336 static char *graphics_dir = NULL;
338 if (graphics_subdir == NULL)
339 return options.graphics_directory;
341 checked_free(graphics_dir);
343 graphics_dir = getPath2(options.graphics_directory, graphics_subdir);
348 static char *getDefaultSoundsDir(char *sounds_subdir)
350 static char *sounds_dir = NULL;
352 if (sounds_subdir == NULL)
353 return options.sounds_directory;
355 checked_free(sounds_dir);
357 sounds_dir = getPath2(options.sounds_directory, sounds_subdir);
362 static char *getDefaultMusicDir(char *music_subdir)
364 static char *music_dir = NULL;
366 if (music_subdir == NULL)
367 return options.music_directory;
369 checked_free(music_dir);
371 music_dir = getPath2(options.music_directory, music_subdir);
376 static char *getClassicArtworkSet(int type)
378 return (type == TREE_TYPE_GRAPHICS_DIR ? GFX_CLASSIC_SUBDIR :
379 type == TREE_TYPE_SOUNDS_DIR ? SND_CLASSIC_SUBDIR :
380 type == TREE_TYPE_MUSIC_DIR ? MUS_CLASSIC_SUBDIR : "");
383 static char *getClassicArtworkDir(int type)
385 return (type == TREE_TYPE_GRAPHICS_DIR ?
386 getDefaultGraphicsDir(GFX_CLASSIC_SUBDIR) :
387 type == TREE_TYPE_SOUNDS_DIR ?
388 getDefaultSoundsDir(SND_CLASSIC_SUBDIR) :
389 type == TREE_TYPE_MUSIC_DIR ?
390 getDefaultMusicDir(MUS_CLASSIC_SUBDIR) : "");
393 char *getUserGraphicsDir(void)
395 static char *usergraphics_dir = NULL;
397 if (usergraphics_dir == NULL)
398 usergraphics_dir = getPath2(getMainUserGameDataDir(), GRAPHICS_DIRECTORY);
400 return usergraphics_dir;
403 char *getUserSoundsDir(void)
405 static char *usersounds_dir = NULL;
407 if (usersounds_dir == NULL)
408 usersounds_dir = getPath2(getMainUserGameDataDir(), SOUNDS_DIRECTORY);
410 return usersounds_dir;
413 char *getUserMusicDir(void)
415 static char *usermusic_dir = NULL;
417 if (usermusic_dir == NULL)
418 usermusic_dir = getPath2(getMainUserGameDataDir(), MUSIC_DIRECTORY);
420 return usermusic_dir;
423 static char *getSetupArtworkDir(TreeInfo *ti)
425 static char *artwork_dir = NULL;
430 checked_free(artwork_dir);
432 artwork_dir = getPath2(ti->basepath, ti->fullpath);
437 char *setLevelArtworkDir(TreeInfo *ti)
439 char **artwork_path_ptr, **artwork_set_ptr;
440 TreeInfo *level_artwork;
442 if (ti == NULL || leveldir_current == NULL)
445 artwork_path_ptr = LEVELDIR_ARTWORK_PATH_PTR(leveldir_current, ti->type);
446 artwork_set_ptr = LEVELDIR_ARTWORK_SET_PTR( leveldir_current, ti->type);
448 checked_free(*artwork_path_ptr);
450 if ((level_artwork = getTreeInfoFromIdentifier(ti, *artwork_set_ptr)))
452 *artwork_path_ptr = getStringCopy(getSetupArtworkDir(level_artwork));
457 No (or non-existing) artwork configured in "levelinfo.conf". This would
458 normally result in using the artwork configured in the setup menu. But
459 if an artwork subdirectory exists (which might contain custom artwork
460 or an artwork configuration file), this level artwork must be treated
461 as relative to the default "classic" artwork, not to the artwork that
462 is currently configured in the setup menu.
464 Update: For "special" versions of R'n'D (like "R'n'D jue"), do not use
465 the "default" artwork (which would be "jue0" for "R'n'D jue"), but use
466 the real "classic" artwork from the original R'n'D (like "gfx_classic").
469 char *dir = getPath2(getCurrentLevelDir(), ARTWORK_DIRECTORY(ti->type));
471 checked_free(*artwork_set_ptr);
473 if (directoryExists(dir))
475 *artwork_path_ptr = getStringCopy(getClassicArtworkDir(ti->type));
476 *artwork_set_ptr = getStringCopy(getClassicArtworkSet(ti->type));
480 *artwork_path_ptr = getStringCopy(UNDEFINED_FILENAME);
481 *artwork_set_ptr = NULL;
487 return *artwork_set_ptr;
490 static char *getLevelArtworkSet(int type)
492 if (leveldir_current == NULL)
495 return LEVELDIR_ARTWORK_SET(leveldir_current, type);
498 static char *getLevelArtworkDir(int type)
500 if (leveldir_current == NULL)
501 return UNDEFINED_FILENAME;
503 return LEVELDIR_ARTWORK_PATH(leveldir_current, type);
506 char *getProgramMainDataPath(char *command_filename, char *base_path)
508 // check if the program's main data base directory is configured
509 if (!strEqual(base_path, "."))
510 return getStringCopy(base_path);
512 /* if the program is configured to start from current directory (default),
513 determine program package directory from program binary (some versions
514 of KDE/Konqueror and Mac OS X (especially "Mavericks") apparently do not
515 set the current working directory to the program package directory) */
516 char *main_data_path = getBasePath(command_filename);
518 #if defined(PLATFORM_MAC)
519 if (strSuffix(main_data_path, MAC_APP_BINARY_SUBDIR))
521 char *main_data_path_old = main_data_path;
523 // cut relative path to Mac OS X application binary directory from path
524 main_data_path[strlen(main_data_path) -
525 strlen(MAC_APP_BINARY_SUBDIR)] = '\0';
527 // cut trailing path separator from path (but not if path is root directory)
528 if (strSuffix(main_data_path, "/") && !strEqual(main_data_path, "/"))
529 main_data_path[strlen(main_data_path) - 1] = '\0';
531 // replace empty path with current directory
532 if (strEqual(main_data_path, ""))
533 main_data_path = ".";
535 // add relative path to Mac OS X application resources directory to path
536 main_data_path = getPath2(main_data_path, MAC_APP_FILES_SUBDIR);
538 free(main_data_path_old);
542 return main_data_path;
545 char *getProgramConfigFilename(char *command_filename)
547 static char *config_filename_1 = NULL;
548 static char *config_filename_2 = NULL;
549 static char *config_filename_3 = NULL;
550 static boolean initialized = FALSE;
554 char *command_filename_1 = getStringCopy(command_filename);
556 // strip trailing executable suffix from command filename
557 if (strSuffix(command_filename_1, ".exe"))
558 command_filename_1[strlen(command_filename_1) - 4] = '\0';
560 char *base_path = getProgramMainDataPath(command_filename, BASE_PATH);
561 char *conf_directory = getPath2(base_path, CONF_DIRECTORY);
563 char *command_basepath = getBasePath(command_filename);
564 char *command_basename = getBaseNameNoSuffix(command_filename);
565 char *command_filename_2 = getPath2(command_basepath, command_basename);
567 config_filename_1 = getStringCat2(command_filename_1, ".conf");
568 config_filename_2 = getStringCat2(command_filename_2, ".conf");
569 config_filename_3 = getPath2(conf_directory, SETUP_FILENAME);
571 checked_free(base_path);
572 checked_free(conf_directory);
574 checked_free(command_basepath);
575 checked_free(command_basename);
577 checked_free(command_filename_1);
578 checked_free(command_filename_2);
583 // 1st try: look for config file that exactly matches the binary filename
584 if (fileExists(config_filename_1))
585 return config_filename_1;
587 // 2nd try: look for config file that matches binary filename without suffix
588 if (fileExists(config_filename_2))
589 return config_filename_2;
591 // 3rd try: return setup config filename in global program config directory
592 return config_filename_3;
595 static char *getPlatformConfigFilename(char *config_filename)
597 static char *platform_config_filename = NULL;
598 static boolean initialized = FALSE;
602 char *config_basepath = getBasePath(config_filename);
603 char *config_basename = getBaseNameNoSuffix(config_filename);
604 char *config_filename_prefix = getPath2(config_basepath, config_basename);
605 char *platform_string_lower = getStringToLower(PLATFORM_STRING);
606 char *platform_suffix = getStringCat2("-", platform_string_lower);
608 platform_config_filename = getStringCat3(config_filename_prefix,
609 platform_suffix, ".conf");
611 checked_free(config_basepath);
612 checked_free(config_basename);
613 checked_free(config_filename_prefix);
614 checked_free(platform_string_lower);
615 checked_free(platform_suffix);
620 return platform_config_filename;
623 char *getTapeFilename(int nr)
625 static char *filename = NULL;
626 char basename[MAX_FILENAME_LEN];
628 checked_free(filename);
630 sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
631 filename = getPath2(getTapeDir(leveldir_current->subdir), basename);
636 char *getTemporaryTapeFilename(void)
638 static char *filename = NULL;
639 char basename[MAX_FILENAME_LEN];
641 checked_free(filename);
643 sprintf(basename, "tmp.%s", TAPEFILE_EXTENSION);
644 filename = getPath2(getTapeDir(NULL), basename);
649 char *getDefaultSolutionTapeFilename(int nr)
651 static char *filename = NULL;
652 char basename[MAX_FILENAME_LEN];
654 checked_free(filename);
656 sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION);
657 filename = getPath2(getSolutionTapeDir(), basename);
662 char *getSokobanSolutionTapeFilename(int nr)
664 static char *filename = NULL;
665 char basename[MAX_FILENAME_LEN];
667 checked_free(filename);
669 sprintf(basename, "%03d.sln", nr);
670 filename = getPath2(getSolutionTapeDir(), basename);
675 char *getSolutionTapeFilename(int nr)
677 char *filename = getDefaultSolutionTapeFilename(nr);
679 if (!fileExists(filename))
681 char *filename2 = getSokobanSolutionTapeFilename(nr);
683 if (fileExists(filename2))
690 char *getScoreFilename(int nr)
692 static char *filename = NULL;
693 char basename[MAX_FILENAME_LEN];
695 checked_free(filename);
697 sprintf(basename, "%03d.%s", nr, SCOREFILE_EXTENSION);
699 // used instead of "leveldir_current->subdir" (for network games)
700 filename = getPath2(getScoreDir(levelset.identifier), basename);
705 char *getScoreCacheFilename(int nr)
707 static char *filename = NULL;
708 char basename[MAX_FILENAME_LEN];
710 checked_free(filename);
712 sprintf(basename, "%03d.%s", nr, SCOREFILE_EXTENSION);
714 // used instead of "leveldir_current->subdir" (for network games)
715 filename = getPath2(getScoreCacheDir(levelset.identifier), basename);
720 char *getScoreTapeBasename(char *name)
722 static char basename[MAX_FILENAME_LEN];
723 char basename_raw[MAX_FILENAME_LEN];
726 sprintf(timestamp, "%s", getCurrentTimestamp());
727 sprintf(basename_raw, "%s-%s", timestamp, name);
728 sprintf(basename, "%s-%08x", timestamp, get_hash_from_key(basename_raw));
733 char *getScoreTapeFilename(char *basename_no_ext, int nr)
735 static char *filename = NULL;
736 char basename[MAX_FILENAME_LEN];
738 checked_free(filename);
740 sprintf(basename, "%s.%s", basename_no_ext, TAPEFILE_EXTENSION);
742 // used instead of "leveldir_current->subdir" (for network games)
743 filename = getPath2(getScoreTapeDir(levelset.identifier, nr), basename);
748 char *getScoreCacheTapeFilename(char *basename_no_ext, int nr)
750 static char *filename = NULL;
751 char basename[MAX_FILENAME_LEN];
753 checked_free(filename);
755 sprintf(basename, "%s.%s", basename_no_ext, TAPEFILE_EXTENSION);
757 // used instead of "leveldir_current->subdir" (for network games)
758 filename = getPath2(getScoreCacheTapeDir(levelset.identifier, nr), basename);
763 char *getSetupFilename(void)
765 static char *filename = NULL;
767 checked_free(filename);
769 filename = getPath2(getSetupDir(), SETUP_FILENAME);
774 char *getDefaultSetupFilename(void)
776 return program.config_filename;
779 char *getPlatformSetupFilename(void)
781 return getPlatformConfigFilename(program.config_filename);
784 char *getEditorSetupFilename(void)
786 static char *filename = NULL;
788 checked_free(filename);
789 filename = getPath2(getCurrentLevelDir(), EDITORSETUP_FILENAME);
791 if (fileExists(filename))
794 checked_free(filename);
795 filename = getPath2(getSetupDir(), EDITORSETUP_FILENAME);
800 char *getHelpAnimFilename(void)
802 static char *filename = NULL;
804 checked_free(filename);
806 filename = getPath2(getCurrentLevelDir(), HELPANIM_FILENAME);
811 char *getHelpTextFilename(void)
813 static char *filename = NULL;
815 checked_free(filename);
817 filename = getPath2(getCurrentLevelDir(), HELPTEXT_FILENAME);
822 static char *getLevelSetInfoBasename(int nr)
824 static char basename[32];
826 sprintf(basename, "levelset_%d.txt", nr + 1);
831 char *getLevelSetInfoFilename(int nr)
833 char *basename = getLevelSetInfoBasename(nr);
834 static char *info_subdir = NULL;
835 static char *filename = NULL;
837 if (info_subdir == NULL)
838 info_subdir = getPath2(DOCS_DIRECTORY, LEVELSET_INFO_DIRECTORY);
840 checked_free(filename);
842 // look for level set info file the current level set directory
843 filename = getPath3(getCurrentLevelDir(), info_subdir, basename);
844 if (fileExists(filename))
864 for (i = 0; basenames[i] != NULL; i++)
866 checked_free(filename);
867 filename = getPath2(getCurrentLevelDir(), basenames[i]);
869 if (fileExists(filename))
876 static char *getLevelSetTitleMessageBasename(int nr, boolean initial)
878 static char basename[32];
880 sprintf(basename, "%s_%d.txt",
881 (initial ? "titlemessage_initial" : "titlemessage"), nr + 1);
886 char *getLevelSetTitleMessageFilename(int nr, boolean initial)
888 static char *filename = NULL;
890 boolean skip_setup_artwork = FALSE;
892 checked_free(filename);
894 basename = getLevelSetTitleMessageBasename(nr, initial);
896 if (!gfx.override_level_graphics)
898 // 1st try: look for special artwork in current level series directory
899 filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
900 if (fileExists(filename))
905 // 2nd try: look for message file in current level set directory
906 filename = getPath2(getCurrentLevelDir(), basename);
907 if (fileExists(filename))
912 // check if there is special artwork configured in level series config
913 if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL)
915 // 3rd try: look for special artwork configured in level series config
916 filename = getPath2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
917 if (fileExists(filename))
922 // take missing artwork configured in level set config from default
923 skip_setup_artwork = TRUE;
927 if (!skip_setup_artwork)
929 // 4th try: look for special artwork in configured artwork directory
930 filename = getPath2(getSetupArtworkDir(artwork.gfx_current), basename);
931 if (fileExists(filename))
937 // 5th try: look for default artwork in new default artwork directory
938 filename = getPath2(getDefaultGraphicsDir(GFX_DEFAULT_SUBDIR), basename);
939 if (fileExists(filename))
944 // 6th try: look for default artwork in old default artwork directory
945 filename = getPath2(options.graphics_directory, basename);
946 if (fileExists(filename))
949 return NULL; // cannot find specified artwork file anywhere
952 static char *getCreditsBasename(int nr)
954 static char basename[32];
956 sprintf(basename, "credits_%d.txt", nr + 1);
961 char *getCreditsFilename(int nr, boolean global)
963 char *basename = getCreditsBasename(nr);
964 char *basepath = NULL;
965 static char *credits_subdir = NULL;
966 static char *filename = NULL;
968 if (credits_subdir == NULL)
969 credits_subdir = getPath2(DOCS_DIRECTORY, CREDITS_DIRECTORY);
971 checked_free(filename);
973 // look for credits file in the game's base or current level set directory
974 basepath = (global ? options.base_directory : getCurrentLevelDir());
976 filename = getPath3(basepath, credits_subdir, basename);
977 if (fileExists(filename))
980 return NULL; // cannot find credits file
983 static char *getProgramInfoBasename(int nr)
985 static char basename[32];
987 sprintf(basename, "program_%d.txt", nr + 1);
992 char *getProgramInfoFilename(int nr)
994 char *basename = getProgramInfoBasename(nr);
995 static char *info_subdir = NULL;
996 static char *filename = NULL;
998 if (info_subdir == NULL)
999 info_subdir = getPath2(DOCS_DIRECTORY, PROGRAM_INFO_DIRECTORY);
1001 checked_free(filename);
1003 // look for program info file in the game's base directory
1004 filename = getPath3(options.base_directory, info_subdir, basename);
1005 if (fileExists(filename))
1008 return NULL; // cannot find program info file
1011 static char *getCorrectedArtworkBasename(char *basename)
1016 char *getCustomImageFilename(char *basename)
1018 static char *filename = NULL;
1019 boolean skip_setup_artwork = FALSE;
1021 checked_free(filename);
1023 basename = getCorrectedArtworkBasename(basename);
1025 if (!gfx.override_level_graphics)
1027 // 1st try: look for special artwork in current level series directory
1028 filename = getImg3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
1029 if (fileExists(filename))
1034 // check if there is special artwork configured in level series config
1035 if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL)
1037 // 2nd try: look for special artwork configured in level series config
1038 filename = getImg2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
1039 if (fileExists(filename))
1044 // take missing artwork configured in level set config from default
1045 skip_setup_artwork = TRUE;
1049 if (!skip_setup_artwork)
1051 // 3rd try: look for special artwork in configured artwork directory
1052 filename = getImg2(getSetupArtworkDir(artwork.gfx_current), basename);
1053 if (fileExists(filename))
1059 // 4th try: look for default artwork in new default artwork directory
1060 filename = getImg2(getDefaultGraphicsDir(GFX_DEFAULT_SUBDIR), basename);
1061 if (fileExists(filename))
1066 // 5th try: look for default artwork in old default artwork directory
1067 filename = getImg2(options.graphics_directory, basename);
1068 if (fileExists(filename))
1071 if (!strEqual(GFX_FALLBACK_FILENAME, UNDEFINED_FILENAME))
1075 WarnUsingFallback(basename);
1077 // 6th try: look for fallback artwork in old default artwork directory
1078 // (needed to prevent errors when trying to access unused artwork files)
1079 filename = getImg2(options.graphics_directory, GFX_FALLBACK_FILENAME);
1080 if (fileExists(filename))
1084 return NULL; // cannot find specified artwork file anywhere
1087 char *getCustomSoundFilename(char *basename)
1089 static char *filename = NULL;
1090 boolean skip_setup_artwork = FALSE;
1092 checked_free(filename);
1094 basename = getCorrectedArtworkBasename(basename);
1096 if (!gfx.override_level_sounds)
1098 // 1st try: look for special artwork in current level series directory
1099 filename = getPath3(getCurrentLevelDir(), SOUNDS_DIRECTORY, basename);
1100 if (fileExists(filename))
1105 // check if there is special artwork configured in level series config
1106 if (getLevelArtworkSet(ARTWORK_TYPE_SOUNDS) != NULL)
1108 // 2nd try: look for special artwork configured in level series config
1109 filename = getPath2(getLevelArtworkDir(TREE_TYPE_SOUNDS_DIR), basename);
1110 if (fileExists(filename))
1115 // take missing artwork configured in level set config from default
1116 skip_setup_artwork = TRUE;
1120 if (!skip_setup_artwork)
1122 // 3rd try: look for special artwork in configured artwork directory
1123 filename = getPath2(getSetupArtworkDir(artwork.snd_current), basename);
1124 if (fileExists(filename))
1130 // 4th try: look for default artwork in new default artwork directory
1131 filename = getPath2(getDefaultSoundsDir(SND_DEFAULT_SUBDIR), basename);
1132 if (fileExists(filename))
1137 // 5th try: look for default artwork in old default artwork directory
1138 filename = getPath2(options.sounds_directory, basename);
1139 if (fileExists(filename))
1142 if (!strEqual(SND_FALLBACK_FILENAME, UNDEFINED_FILENAME))
1146 WarnUsingFallback(basename);
1148 // 6th try: look for fallback artwork in old default artwork directory
1149 // (needed to prevent errors when trying to access unused artwork files)
1150 filename = getPath2(options.sounds_directory, SND_FALLBACK_FILENAME);
1151 if (fileExists(filename))
1155 return NULL; // cannot find specified artwork file anywhere
1158 char *getCustomMusicFilename(char *basename)
1160 static char *filename = NULL;
1161 boolean skip_setup_artwork = FALSE;
1163 checked_free(filename);
1165 basename = getCorrectedArtworkBasename(basename);
1167 if (!gfx.override_level_music)
1169 // 1st try: look for special artwork in current level series directory
1170 filename = getPath3(getCurrentLevelDir(), MUSIC_DIRECTORY, basename);
1171 if (fileExists(filename))
1176 // check if there is special artwork configured in level series config
1177 if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
1179 // 2nd try: look for special artwork configured in level series config
1180 filename = getPath2(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR), basename);
1181 if (fileExists(filename))
1186 // take missing artwork configured in level set config from default
1187 skip_setup_artwork = TRUE;
1191 if (!skip_setup_artwork)
1193 // 3rd try: look for special artwork in configured artwork directory
1194 filename = getPath2(getSetupArtworkDir(artwork.mus_current), basename);
1195 if (fileExists(filename))
1201 // 4th try: look for default artwork in new default artwork directory
1202 filename = getPath2(getDefaultMusicDir(MUS_DEFAULT_SUBDIR), basename);
1203 if (fileExists(filename))
1208 // 5th try: look for default artwork in old default artwork directory
1209 filename = getPath2(options.music_directory, basename);
1210 if (fileExists(filename))
1213 if (!strEqual(MUS_FALLBACK_FILENAME, UNDEFINED_FILENAME))
1217 WarnUsingFallback(basename);
1219 // 6th try: look for fallback artwork in old default artwork directory
1220 // (needed to prevent errors when trying to access unused artwork files)
1221 filename = getPath2(options.music_directory, MUS_FALLBACK_FILENAME);
1222 if (fileExists(filename))
1226 return NULL; // cannot find specified artwork file anywhere
1229 char *getCustomArtworkFilename(char *basename, int type)
1231 if (type == ARTWORK_TYPE_GRAPHICS)
1232 return getCustomImageFilename(basename);
1233 else if (type == ARTWORK_TYPE_SOUNDS)
1234 return getCustomSoundFilename(basename);
1235 else if (type == ARTWORK_TYPE_MUSIC)
1236 return getCustomMusicFilename(basename);
1238 return UNDEFINED_FILENAME;
1241 char *getCustomArtworkConfigFilename(int type)
1243 return getCustomArtworkFilename(ARTWORKINFO_FILENAME(type), type);
1246 char *getCustomArtworkLevelConfigFilename(int type)
1248 static char *filename = NULL;
1250 checked_free(filename);
1252 filename = getPath2(getLevelArtworkDir(type), ARTWORKINFO_FILENAME(type));
1257 static boolean directoryExists_CheckMusic(char *directory, boolean check_music)
1259 if (!directoryExists(directory))
1266 DirectoryEntry *dir_entry;
1267 int num_music = getMusicListSize();
1268 boolean music_found = FALSE;
1270 if ((dir = openDirectory(directory)) == NULL)
1273 while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
1275 char *basename = dir_entry->basename;
1276 boolean music_already_used = FALSE;
1279 // skip all music files that are configured in music config file
1280 for (i = 0; i < num_music; i++)
1282 struct FileInfo *music = getMusicListEntry(i);
1284 if (strEqual(basename, music->filename))
1286 music_already_used = TRUE;
1292 if (music_already_used)
1295 if (FileIsMusic(dir_entry->filename))
1303 closeDirectory(dir);
1308 static char *getCustomMusicDirectoryExt(boolean check_music)
1310 static char *directory = NULL;
1311 boolean skip_setup_artwork = FALSE;
1313 checked_free(directory);
1315 if (!gfx.override_level_music)
1317 // 1st try: look for special artwork in current level series directory
1318 directory = getPath2(getCurrentLevelDir(), MUSIC_DIRECTORY);
1319 if (directoryExists_CheckMusic(directory, check_music))
1324 // check if there is special artwork configured in level series config
1325 if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
1327 // 2nd try: look for special artwork configured in level series config
1328 directory = getStringCopy(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR));
1329 if (directoryExists_CheckMusic(directory, check_music))
1334 // take missing artwork configured in level set config from default
1335 skip_setup_artwork = TRUE;
1339 if (!skip_setup_artwork)
1341 // 3rd try: look for special artwork in configured artwork directory
1342 directory = getStringCopy(getSetupArtworkDir(artwork.mus_current));
1343 if (directoryExists_CheckMusic(directory, check_music))
1349 // 4th try: look for default artwork in new default artwork directory
1350 directory = getStringCopy(getDefaultMusicDir(MUS_DEFAULT_SUBDIR));
1351 if (directoryExists_CheckMusic(directory, check_music))
1356 // 5th try: look for default artwork in old default artwork directory
1357 directory = getStringCopy(options.music_directory);
1358 if (directoryExists_CheckMusic(directory, check_music))
1361 return NULL; // cannot find specified artwork file anywhere
1364 char *getCustomMusicDirectory(void)
1366 return getCustomMusicDirectoryExt(FALSE);
1369 char *getCustomMusicDirectory_NoConf(void)
1371 return getCustomMusicDirectoryExt(TRUE);
1374 void MarkTapeDirectoryUploadsAsComplete(char *level_subdir)
1376 char *filename = getPath2(getTapeDir(level_subdir), UPLOADED_FILENAME);
1378 touchFile(filename);
1380 checked_free(filename);
1383 void MarkTapeDirectoryUploadsAsIncomplete(char *level_subdir)
1385 char *filename = getPath2(getTapeDir(level_subdir), UPLOADED_FILENAME);
1389 checked_free(filename);
1392 boolean CheckTapeDirectoryUploadsComplete(char *level_subdir)
1394 char *filename = getPath2(getTapeDir(level_subdir), UPLOADED_FILENAME);
1395 boolean success = fileExists(filename);
1397 checked_free(filename);
1402 void InitMissingFileHash(void)
1404 if (missing_file_hash == NULL)
1405 freeSetupFileHash(missing_file_hash);
1407 missing_file_hash = newSetupFileHash();
1410 void InitTapeDirectory(char *level_subdir)
1412 boolean new_tape_dir = !directoryExists(getTapeDir(level_subdir));
1414 createDirectory(getUserGameDataDir(), "user data");
1415 createDirectory(getTapeDir(NULL), "main tape");
1416 createDirectory(getTapeDir(level_subdir), "level tape");
1419 MarkTapeDirectoryUploadsAsComplete(level_subdir);
1422 void InitScoreDirectory(char *level_subdir)
1424 createDirectory(getMainUserGameDataDir(), "main user data");
1425 createDirectory(getScoreDir(NULL), "main score");
1426 createDirectory(getScoreDir(level_subdir), "level score");
1429 void InitScoreCacheDirectory(char *level_subdir)
1431 createDirectory(getMainUserGameDataDir(), "main user data");
1432 createDirectory(getCacheDir(), "cache data");
1433 createDirectory(getScoreCacheDir(NULL), "main score");
1434 createDirectory(getScoreCacheDir(level_subdir), "level score");
1437 void InitScoreTapeDirectory(char *level_subdir, int nr)
1439 InitScoreDirectory(level_subdir);
1441 createDirectory(getScoreTapeDir(level_subdir, nr), "score tape");
1444 void InitScoreCacheTapeDirectory(char *level_subdir, int nr)
1446 InitScoreCacheDirectory(level_subdir);
1448 createDirectory(getScoreCacheTapeDir(level_subdir, nr), "score tape");
1451 static void SaveUserLevelInfo(void);
1453 void InitUserLevelDirectory(char *level_subdir)
1455 if (!directoryExists(getUserLevelDir(level_subdir)))
1457 createDirectory(getMainUserGameDataDir(), "main user data");
1458 createDirectory(getUserLevelDir(NULL), "main user level");
1460 if (setup.internal.create_user_levelset)
1462 createDirectory(getUserLevelDir(level_subdir), "user level");
1464 SaveUserLevelInfo();
1469 void InitNetworkLevelDirectory(char *level_subdir)
1471 if (!directoryExists(getNetworkLevelDir(level_subdir)))
1473 createDirectory(getMainUserGameDataDir(), "main user data");
1474 createDirectory(getNetworkDir(), "network data");
1475 createDirectory(getNetworkLevelDir(NULL), "main network level");
1476 createDirectory(getNetworkLevelDir(level_subdir), "network level");
1480 void InitLevelSetupDirectory(char *level_subdir)
1482 createDirectory(getUserGameDataDir(), "user data");
1483 createDirectory(getLevelSetupDir(NULL), "main level setup");
1484 createDirectory(getLevelSetupDir(level_subdir), "level setup");
1487 static void InitCacheDirectory(void)
1489 createDirectory(getMainUserGameDataDir(), "main user data");
1490 createDirectory(getCacheDir(), "cache data");
1494 // ----------------------------------------------------------------------------
1495 // some functions to handle lists of level and artwork directories
1496 // ----------------------------------------------------------------------------
1498 TreeInfo *newTreeInfo(void)
1500 return checked_calloc(sizeof(TreeInfo));
1503 TreeInfo *newTreeInfo_setDefaults(int type)
1505 TreeInfo *ti = newTreeInfo();
1507 setTreeInfoToDefaults(ti, type);
1512 void pushTreeInfo(TreeInfo **node_first, TreeInfo *node_new)
1514 node_new->next = *node_first;
1515 *node_first = node_new;
1518 void removeTreeInfo(TreeInfo **node_first)
1520 TreeInfo *node_old = *node_first;
1522 *node_first = node_old->next;
1523 node_old->next = NULL;
1525 freeTreeInfo(node_old);
1528 int numTreeInfo(TreeInfo *node)
1541 boolean validLevelSeries(TreeInfo *node)
1543 // in a number of cases, tree node is no valid level set
1544 if (node == NULL || node->node_group || node->parent_link || node->is_copy)
1550 TreeInfo *getValidLevelSeries(TreeInfo *node, TreeInfo *default_node)
1552 if (validLevelSeries(node))
1554 else if (node->is_copy)
1555 return getTreeInfoFromIdentifier(leveldir_first, node->identifier);
1557 return getFirstValidTreeInfoEntry(default_node);
1560 static TreeInfo *getValidTreeInfoEntryExt(TreeInfo *node, boolean get_next_node)
1565 if (node->node_group) // enter node group (step down into tree)
1566 return getFirstValidTreeInfoEntry(node->node_group);
1568 if (node->parent_link) // skip first node (back link) of node group
1569 get_next_node = TRUE;
1571 if (!get_next_node) // get current regular tree node
1574 // get next regular tree node, or step up until one is found
1575 while (node->next == NULL && node->node_parent != NULL)
1576 node = node->node_parent;
1578 return getFirstValidTreeInfoEntry(node->next);
1581 TreeInfo *getFirstValidTreeInfoEntry(TreeInfo *node)
1583 return getValidTreeInfoEntryExt(node, FALSE);
1586 TreeInfo *getNextValidTreeInfoEntry(TreeInfo *node)
1588 return getValidTreeInfoEntryExt(node, TRUE);
1591 TreeInfo *getTreeInfoFirstGroupEntry(TreeInfo *node)
1596 if (node->node_parent == NULL) // top level group
1597 return *node->node_top;
1598 else // sub level group
1599 return node->node_parent->node_group;
1602 int numTreeInfoInGroup(TreeInfo *node)
1604 return numTreeInfo(getTreeInfoFirstGroupEntry(node));
1607 int getPosFromTreeInfo(TreeInfo *node)
1609 TreeInfo *node_cmp = getTreeInfoFirstGroupEntry(node);
1614 if (node_cmp == node)
1618 node_cmp = node_cmp->next;
1624 TreeInfo *getTreeInfoFromPos(TreeInfo *node, int pos)
1626 TreeInfo *node_default = node;
1638 return node_default;
1641 static TreeInfo *getTreeInfoFromIdentifierExt(TreeInfo *node, char *identifier,
1642 int node_type_wanted)
1644 if (identifier == NULL)
1649 if (TREE_NODE_TYPE(node) == node_type_wanted &&
1650 strEqual(identifier, node->identifier))
1653 if (node->node_group)
1655 TreeInfo *node_group = getTreeInfoFromIdentifierExt(node->node_group,
1668 TreeInfo *getTreeInfoFromIdentifier(TreeInfo *node, char *identifier)
1670 return getTreeInfoFromIdentifierExt(node, identifier, TREE_NODE_TYPE_DEFAULT);
1673 static TreeInfo *cloneTreeNode(TreeInfo **node_top, TreeInfo *node_parent,
1674 TreeInfo *node, boolean skip_sets_without_levels)
1681 if (!node->parent_link && !node->level_group &&
1682 skip_sets_without_levels && node->levels == 0)
1683 return cloneTreeNode(node_top, node_parent, node->next,
1684 skip_sets_without_levels);
1686 node_new = getTreeInfoCopy(node); // copy complete node
1688 node_new->node_top = node_top; // correct top node link
1689 node_new->node_parent = node_parent; // correct parent node link
1691 if (node->level_group)
1692 node_new->node_group = cloneTreeNode(node_top, node_new, node->node_group,
1693 skip_sets_without_levels);
1695 node_new->next = cloneTreeNode(node_top, node_parent, node->next,
1696 skip_sets_without_levels);
1701 static void cloneTree(TreeInfo **ti_new, TreeInfo *ti, boolean skip_empty_sets)
1703 TreeInfo *ti_cloned = cloneTreeNode(ti_new, NULL, ti, skip_empty_sets);
1705 *ti_new = ti_cloned;
1708 static boolean adjustTreeGraphicsForEMC(TreeInfo *node)
1710 boolean settings_changed = FALSE;
1714 boolean want_ecs = (setup.prefer_aga_graphics == FALSE);
1715 boolean want_aga = (setup.prefer_aga_graphics == TRUE);
1716 boolean has_only_ecs = (!node->graphics_set && !node->graphics_set_aga);
1717 boolean has_only_aga = (!node->graphics_set && !node->graphics_set_ecs);
1718 char *graphics_set = NULL;
1720 if (node->graphics_set_ecs && (want_ecs || has_only_ecs))
1721 graphics_set = node->graphics_set_ecs;
1723 if (node->graphics_set_aga && (want_aga || has_only_aga))
1724 graphics_set = node->graphics_set_aga;
1726 if (graphics_set && !strEqual(node->graphics_set, graphics_set))
1728 setString(&node->graphics_set, graphics_set);
1729 settings_changed = TRUE;
1732 if (node->node_group != NULL)
1733 settings_changed |= adjustTreeGraphicsForEMC(node->node_group);
1738 return settings_changed;
1741 static boolean adjustTreeSoundsForEMC(TreeInfo *node)
1743 boolean settings_changed = FALSE;
1747 boolean want_default = (setup.prefer_lowpass_sounds == FALSE);
1748 boolean want_lowpass = (setup.prefer_lowpass_sounds == TRUE);
1749 boolean has_only_default = (!node->sounds_set && !node->sounds_set_lowpass);
1750 boolean has_only_lowpass = (!node->sounds_set && !node->sounds_set_default);
1751 char *sounds_set = NULL;
1753 if (node->sounds_set_default && (want_default || has_only_default))
1754 sounds_set = node->sounds_set_default;
1756 if (node->sounds_set_lowpass && (want_lowpass || has_only_lowpass))
1757 sounds_set = node->sounds_set_lowpass;
1759 if (sounds_set && !strEqual(node->sounds_set, sounds_set))
1761 setString(&node->sounds_set, sounds_set);
1762 settings_changed = TRUE;
1765 if (node->node_group != NULL)
1766 settings_changed |= adjustTreeSoundsForEMC(node->node_group);
1771 return settings_changed;
1774 int dumpTreeInfo(TreeInfo *node, int depth)
1776 char bullet_list[] = { '-', '*', 'o' };
1777 int num_leaf_nodes = 0;
1781 Debug("tree", "Dumping TreeInfo:");
1785 char bullet = bullet_list[depth % ARRAY_SIZE(bullet_list)];
1787 for (i = 0; i < depth * 2; i++)
1788 DebugContinued("", " ");
1790 DebugContinued("tree", "%c '%s' ['%s] [PARENT: '%s'] %s\n",
1791 bullet, node->name, node->identifier,
1792 (node->node_parent ? node->node_parent->identifier : "-"),
1793 (node->node_group ? "[GROUP]" :
1794 node->is_copy ? "[COPY]" : ""));
1796 if (!node->node_group && !node->parent_link)
1800 // use for dumping artwork info tree
1801 Debug("tree", "subdir == '%s' ['%s', '%s'] [%d])",
1802 node->subdir, node->fullpath, node->basepath, node->in_user_dir);
1805 if (node->node_group != NULL)
1806 num_leaf_nodes += dumpTreeInfo(node->node_group, depth + 1);
1812 Debug("tree", "Summary: %d leaf nodes found", num_leaf_nodes);
1814 return num_leaf_nodes;
1817 void sortTreeInfoBySortFunction(TreeInfo **node_first,
1818 int (*compare_function)(const void *,
1821 int num_nodes = numTreeInfo(*node_first);
1822 TreeInfo **sort_array;
1823 TreeInfo *node = *node_first;
1829 // allocate array for sorting structure pointers
1830 sort_array = checked_calloc(num_nodes * sizeof(TreeInfo *));
1832 // writing structure pointers to sorting array
1833 while (i < num_nodes && node) // double boundary check...
1835 sort_array[i] = node;
1841 // sorting the structure pointers in the sorting array
1842 qsort(sort_array, num_nodes, sizeof(TreeInfo *),
1845 // update the linkage of list elements with the sorted node array
1846 for (i = 0; i < num_nodes - 1; i++)
1847 sort_array[i]->next = sort_array[i + 1];
1848 sort_array[num_nodes - 1]->next = NULL;
1850 // update the linkage of the main list anchor pointer
1851 *node_first = sort_array[0];
1855 // now recursively sort the level group structures
1859 if (node->node_group != NULL)
1860 sortTreeInfoBySortFunction(&node->node_group, compare_function);
1866 void sortTreeInfo(TreeInfo **node_first)
1868 sortTreeInfoBySortFunction(node_first, compareTreeInfoEntries);
1872 // ============================================================================
1873 // some stuff from "files.c"
1874 // ============================================================================
1876 #if defined(PLATFORM_WINDOWS)
1878 #define S_IRGRP S_IRUSR
1881 #define S_IROTH S_IRUSR
1884 #define S_IWGRP S_IWUSR
1887 #define S_IWOTH S_IWUSR
1890 #define S_IXGRP S_IXUSR
1893 #define S_IXOTH S_IXUSR
1896 #define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
1901 #endif // PLATFORM_WINDOWS
1903 // file permissions for newly written files
1904 #define MODE_R_ALL (S_IRUSR | S_IRGRP | S_IROTH)
1905 #define MODE_W_ALL (S_IWUSR | S_IWGRP | S_IWOTH)
1906 #define MODE_X_ALL (S_IXUSR | S_IXGRP | S_IXOTH)
1908 #define MODE_W_PRIVATE (S_IWUSR)
1909 #define MODE_W_PUBLIC_FILE (S_IWUSR | S_IWGRP)
1910 #define MODE_W_PUBLIC_DIR (S_IWUSR | S_IWGRP | S_ISGID)
1912 #define DIR_PERMS_PRIVATE (MODE_R_ALL | MODE_X_ALL | MODE_W_PRIVATE)
1913 #define DIR_PERMS_PUBLIC (MODE_R_ALL | MODE_X_ALL | MODE_W_PUBLIC_DIR)
1914 #define DIR_PERMS_PUBLIC_ALL (MODE_R_ALL | MODE_X_ALL | MODE_W_ALL)
1916 #define FILE_PERMS_PRIVATE (MODE_R_ALL | MODE_W_PRIVATE)
1917 #define FILE_PERMS_PUBLIC (MODE_R_ALL | MODE_W_PUBLIC_FILE)
1918 #define FILE_PERMS_PUBLIC_ALL (MODE_R_ALL | MODE_W_ALL)
1921 char *getHomeDir(void)
1923 static char *dir = NULL;
1925 #if defined(PLATFORM_WINDOWS)
1928 dir = checked_malloc(MAX_PATH + 1);
1930 if (!SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, dir)))
1933 #elif defined(PLATFORM_EMSCRIPTEN)
1934 dir = PERSISTENT_DIRECTORY;
1935 #elif defined(PLATFORM_UNIX)
1938 if ((dir = getenv("HOME")) == NULL)
1940 dir = getUnixHomeDir();
1943 dir = getStringCopy(dir);
1955 char *getPersonalDataDir(void)
1957 static char *personal_data_dir = NULL;
1959 #if defined(PLATFORM_MAC)
1960 if (personal_data_dir == NULL)
1961 personal_data_dir = getPath2(getHomeDir(), "Documents");
1963 if (personal_data_dir == NULL)
1964 personal_data_dir = getHomeDir();
1967 return personal_data_dir;
1970 char *getMainUserGameDataDir(void)
1972 static char *main_user_data_dir = NULL;
1974 #if defined(PLATFORM_ANDROID)
1975 if (main_user_data_dir == NULL)
1976 main_user_data_dir = (char *)(SDL_AndroidGetExternalStorageState() &
1977 SDL_ANDROID_EXTERNAL_STORAGE_WRITE ?
1978 SDL_AndroidGetExternalStoragePath() :
1979 SDL_AndroidGetInternalStoragePath());
1981 if (main_user_data_dir == NULL)
1982 main_user_data_dir = getPath2(getPersonalDataDir(),
1983 program.userdata_subdir);
1986 return main_user_data_dir;
1989 char *getUserGameDataDir(void)
1992 return getMainUserGameDataDir();
1994 return getUserDir(user.nr);
1997 char *getSetupDir(void)
1999 return getUserGameDataDir();
2002 static mode_t posix_umask(mode_t mask)
2004 #if defined(PLATFORM_UNIX)
2011 static int posix_mkdir(const char *pathname, mode_t mode)
2013 #if defined(PLATFORM_WINDOWS)
2014 return mkdir(pathname);
2016 return mkdir(pathname, mode);
2020 static boolean posix_process_running_setgid(void)
2022 #if defined(PLATFORM_UNIX)
2023 return (getgid() != getegid());
2029 void createDirectory(char *dir, char *text)
2031 if (directoryExists(dir))
2034 // leave "other" permissions in umask untouched, but ensure group parts
2035 // of USERDATA_DIR_MODE are not masked
2036 int permission_class = PERMS_PRIVATE;
2037 mode_t dir_mode = (permission_class == PERMS_PRIVATE ?
2038 DIR_PERMS_PRIVATE : DIR_PERMS_PUBLIC);
2039 mode_t last_umask = posix_umask(0);
2040 mode_t group_umask = ~(dir_mode & S_IRWXG);
2041 int running_setgid = posix_process_running_setgid();
2043 if (permission_class == PERMS_PUBLIC)
2045 // if we're setgid, protect files against "other"
2046 // else keep umask(0) to make the dir world-writable
2049 posix_umask(last_umask & group_umask);
2051 dir_mode = DIR_PERMS_PUBLIC_ALL;
2054 if (posix_mkdir(dir, dir_mode) != 0)
2055 Warn("cannot create %s directory '%s': %s", text, dir, strerror(errno));
2057 if (permission_class == PERMS_PUBLIC && !running_setgid)
2058 chmod(dir, dir_mode);
2060 posix_umask(last_umask); // restore previous umask
2063 void InitMainUserDataDirectory(void)
2065 createDirectory(getMainUserGameDataDir(), "main user data");
2068 void InitUserDataDirectory(void)
2070 createDirectory(getMainUserGameDataDir(), "main user data");
2074 createDirectory(getUserDir(-1), "users");
2075 createDirectory(getUserDir(user.nr), "user data");
2079 void SetFilePermissions(char *filename, int permission_class)
2081 int running_setgid = posix_process_running_setgid();
2082 int perms = (permission_class == PERMS_PRIVATE ?
2083 FILE_PERMS_PRIVATE : FILE_PERMS_PUBLIC);
2085 if (permission_class == PERMS_PUBLIC && !running_setgid)
2086 perms = FILE_PERMS_PUBLIC_ALL;
2088 chmod(filename, perms);
2091 void fprintFileHeader(FILE *file, char *basename)
2093 char *prefix = "# ";
2096 fprintf_line_with_prefix(file, prefix, sep1, 77);
2097 fprintf(file, "%s%s\n", prefix, basename);
2098 fprintf_line_with_prefix(file, prefix, sep1, 77);
2099 fprintf(file, "\n");
2102 int getFileVersionFromCookieString(const char *cookie)
2104 const char *ptr_cookie1, *ptr_cookie2;
2105 const char *pattern1 = "_FILE_VERSION_";
2106 const char *pattern2 = "?.?";
2107 const int len_cookie = strlen(cookie);
2108 const int len_pattern1 = strlen(pattern1);
2109 const int len_pattern2 = strlen(pattern2);
2110 const int len_pattern = len_pattern1 + len_pattern2;
2111 int version_super, version_major;
2113 if (len_cookie <= len_pattern)
2116 ptr_cookie1 = &cookie[len_cookie - len_pattern];
2117 ptr_cookie2 = &cookie[len_cookie - len_pattern2];
2119 if (strncmp(ptr_cookie1, pattern1, len_pattern1) != 0)
2122 if (ptr_cookie2[0] < '0' || ptr_cookie2[0] > '9' ||
2123 ptr_cookie2[1] != '.' ||
2124 ptr_cookie2[2] < '0' || ptr_cookie2[2] > '9')
2127 version_super = ptr_cookie2[0] - '0';
2128 version_major = ptr_cookie2[2] - '0';
2130 return VERSION_IDENT(version_super, version_major, 0, 0);
2133 boolean checkCookieString(const char *cookie, const char *template)
2135 const char *pattern = "_FILE_VERSION_?.?";
2136 const int len_cookie = strlen(cookie);
2137 const int len_template = strlen(template);
2138 const int len_pattern = strlen(pattern);
2140 if (len_cookie != len_template)
2143 if (strncmp(cookie, template, len_cookie - len_pattern) != 0)
2150 // ----------------------------------------------------------------------------
2151 // setup file list and hash handling functions
2152 // ----------------------------------------------------------------------------
2154 char *getFormattedSetupEntry(char *token, char *value)
2157 static char entry[MAX_LINE_LEN];
2159 // if value is an empty string, just return token without value
2163 // start with the token and some spaces to format output line
2164 sprintf(entry, "%s:", token);
2165 for (i = strlen(entry); i < token_value_position; i++)
2168 // continue with the token's value
2169 strcat(entry, value);
2174 SetupFileList *newSetupFileList(char *token, char *value)
2176 SetupFileList *new = checked_malloc(sizeof(SetupFileList));
2178 new->token = getStringCopy(token);
2179 new->value = getStringCopy(value);
2186 void freeSetupFileList(SetupFileList *list)
2191 checked_free(list->token);
2192 checked_free(list->value);
2195 freeSetupFileList(list->next);
2200 char *getListEntry(SetupFileList *list, char *token)
2205 if (strEqual(list->token, token))
2208 return getListEntry(list->next, token);
2211 SetupFileList *setListEntry(SetupFileList *list, char *token, char *value)
2216 if (strEqual(list->token, token))
2218 checked_free(list->value);
2220 list->value = getStringCopy(value);
2224 else if (list->next == NULL)
2225 return (list->next = newSetupFileList(token, value));
2227 return setListEntry(list->next, token, value);
2230 SetupFileList *addListEntry(SetupFileList *list, char *token, char *value)
2235 if (list->next == NULL)
2236 return (list->next = newSetupFileList(token, value));
2238 return addListEntry(list->next, token, value);
2241 #if ENABLE_UNUSED_CODE
2243 static void printSetupFileList(SetupFileList *list)
2248 Debug("setup:printSetupFileList", "token: '%s'", list->token);
2249 Debug("setup:printSetupFileList", "value: '%s'", list->value);
2251 printSetupFileList(list->next);
2257 DEFINE_HASHTABLE_INSERT(insert_hash_entry, char, char);
2258 DEFINE_HASHTABLE_SEARCH(search_hash_entry, char, char);
2259 DEFINE_HASHTABLE_CHANGE(change_hash_entry, char, char);
2260 DEFINE_HASHTABLE_REMOVE(remove_hash_entry, char, char);
2262 #define insert_hash_entry hashtable_insert
2263 #define search_hash_entry hashtable_search
2264 #define change_hash_entry hashtable_change
2265 #define remove_hash_entry hashtable_remove
2268 unsigned int get_hash_from_key(void *key)
2273 This algorithm (k=33) was first reported by Dan Bernstein many years ago in
2274 'comp.lang.c'. Another version of this algorithm (now favored by Bernstein)
2275 uses XOR: hash(i) = hash(i - 1) * 33 ^ str[i]; the magic of number 33 (why
2276 it works better than many other constants, prime or not) has never been
2277 adequately explained.
2279 If you just want to have a good hash function, and cannot wait, djb2
2280 is one of the best string hash functions i know. It has excellent
2281 distribution and speed on many different sets of keys and table sizes.
2282 You are not likely to do better with one of the "well known" functions
2283 such as PJW, K&R, etc.
2285 Ozan (oz) Yigit [http://www.cs.yorku.ca/~oz/hash.html]
2288 char *str = (char *)key;
2289 unsigned int hash = 5381;
2292 while ((c = *str++))
2293 hash = ((hash << 5) + hash) + c; // hash * 33 + c
2298 int hash_keys_are_equal(void *key1, void *key2)
2300 return (strEqual((char *)key1, (char *)key2));
2303 SetupFileHash *newSetupFileHash(void)
2305 SetupFileHash *new_hash =
2306 create_hashtable(16, 0.75, get_hash_from_key, hash_keys_are_equal);
2308 if (new_hash == NULL)
2309 Fail("create_hashtable() failed -- out of memory");
2314 void freeSetupFileHash(SetupFileHash *hash)
2319 hashtable_destroy(hash, 1); // 1 == also free values stored in hash
2322 char *getHashEntry(SetupFileHash *hash, char *token)
2327 return search_hash_entry(hash, token);
2330 void setHashEntry(SetupFileHash *hash, char *token, char *value)
2337 value_copy = getStringCopy(value);
2339 // change value; if it does not exist, insert it as new
2340 if (!change_hash_entry(hash, token, value_copy))
2341 if (!insert_hash_entry(hash, getStringCopy(token), value_copy))
2342 Fail("cannot insert into hash -- aborting");
2345 char *removeHashEntry(SetupFileHash *hash, char *token)
2350 return remove_hash_entry(hash, token);
2353 #if ENABLE_UNUSED_CODE
2355 static void printSetupFileHash(SetupFileHash *hash)
2357 BEGIN_HASH_ITERATION(hash, itr)
2359 Debug("setup:printSetupFileHash", "token: '%s'", HASH_ITERATION_TOKEN(itr));
2360 Debug("setup:printSetupFileHash", "value: '%s'", HASH_ITERATION_VALUE(itr));
2362 END_HASH_ITERATION(hash, itr)
2367 #define ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE 1
2368 #define CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING 0
2369 #define CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH 0
2371 static boolean token_value_separator_found = FALSE;
2372 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2373 static boolean token_value_separator_warning = FALSE;
2375 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2376 static boolean token_already_exists_warning = FALSE;
2379 static boolean getTokenValueFromSetupLineExt(char *line,
2380 char **token_ptr, char **value_ptr,
2381 char *filename, char *line_raw,
2383 boolean separator_required)
2385 static char line_copy[MAX_LINE_LEN + 1], line_raw_copy[MAX_LINE_LEN + 1];
2386 char *token, *value, *line_ptr;
2388 // when externally invoked via ReadTokenValueFromLine(), copy line buffers
2389 if (line_raw == NULL)
2391 strncpy(line_copy, line, MAX_LINE_LEN);
2392 line_copy[MAX_LINE_LEN] = '\0';
2395 strcpy(line_raw_copy, line_copy);
2396 line_raw = line_raw_copy;
2399 // cut trailing comment from input line
2400 for (line_ptr = line; *line_ptr; line_ptr++)
2402 if (*line_ptr == '#')
2409 // cut trailing whitespaces from input line
2410 for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
2411 if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
2414 // ignore empty lines
2418 // cut leading whitespaces from token
2419 for (token = line; *token; token++)
2420 if (*token != ' ' && *token != '\t')
2423 // start with empty value as reliable default
2426 token_value_separator_found = FALSE;
2428 // find end of token to determine start of value
2429 for (line_ptr = token; *line_ptr; line_ptr++)
2431 // first look for an explicit token/value separator, like ':' or '='
2432 if (*line_ptr == ':' || *line_ptr == '=')
2434 *line_ptr = '\0'; // terminate token string
2435 value = line_ptr + 1; // set beginning of value
2437 token_value_separator_found = TRUE;
2443 #if ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE
2444 // fallback: if no token/value separator found, also allow whitespaces
2445 if (!token_value_separator_found && !separator_required)
2447 for (line_ptr = token; *line_ptr; line_ptr++)
2449 if (*line_ptr == ' ' || *line_ptr == '\t')
2451 *line_ptr = '\0'; // terminate token string
2452 value = line_ptr + 1; // set beginning of value
2454 token_value_separator_found = TRUE;
2460 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2461 if (token_value_separator_found)
2463 if (!token_value_separator_warning)
2465 Debug("setup", "---");
2467 if (filename != NULL)
2469 Debug("setup", "missing token/value separator(s) in config file:");
2470 Debug("setup", "- config file: '%s'", filename);
2474 Debug("setup", "missing token/value separator(s):");
2477 token_value_separator_warning = TRUE;
2480 if (filename != NULL)
2481 Debug("setup", "- line %d: '%s'", line_nr, line_raw);
2483 Debug("setup", "- line: '%s'", line_raw);
2489 // cut trailing whitespaces from token
2490 for (line_ptr = &token[strlen(token)]; line_ptr >= token; line_ptr--)
2491 if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0')
2494 // cut leading whitespaces from value
2495 for (; *value; value++)
2496 if (*value != ' ' && *value != '\t')
2505 boolean getTokenValueFromSetupLine(char *line, char **token, char **value)
2507 // while the internal (old) interface does not require a token/value
2508 // separator (for downwards compatibility with existing files which
2509 // don't use them), it is mandatory for the external (new) interface
2511 return getTokenValueFromSetupLineExt(line, token, value, NULL, NULL, 0, TRUE);
2514 static boolean loadSetupFileData(void *setup_file_data, char *filename,
2515 boolean top_recursion_level, boolean is_hash)
2517 static SetupFileHash *include_filename_hash = NULL;
2518 char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN];
2519 char *token, *value, *line_ptr;
2520 void *insert_ptr = NULL;
2521 boolean read_continued_line = FALSE;
2523 int line_nr = 0, token_count = 0, include_count = 0;
2525 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2526 token_value_separator_warning = FALSE;
2529 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2530 token_already_exists_warning = FALSE;
2533 if (!(file = openFile(filename, MODE_READ)))
2535 #if DEBUG_NO_CONFIG_FILE
2536 Debug("setup", "cannot open configuration file '%s'", filename);
2542 // use "insert pointer" to store list end for constant insertion complexity
2544 insert_ptr = setup_file_data;
2546 // on top invocation, create hash to mark included files (to prevent loops)
2547 if (top_recursion_level)
2548 include_filename_hash = newSetupFileHash();
2550 // mark this file as already included (to prevent including it again)
2551 setHashEntry(include_filename_hash, getBaseNamePtr(filename), "true");
2553 while (!checkEndOfFile(file))
2555 // read next line of input file
2556 if (!getStringFromFile(file, line, MAX_LINE_LEN))
2559 // check if line was completely read and is terminated by line break
2560 if (strlen(line) > 0 && line[strlen(line) - 1] == '\n')
2563 // cut trailing line break (this can be newline and/or carriage return)
2564 for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--)
2565 if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0')
2568 // copy raw input line for later use (mainly debugging output)
2569 strcpy(line_raw, line);
2571 if (read_continued_line)
2573 // append new line to existing line, if there is enough space
2574 if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN)
2575 strcat(previous_line, line_ptr);
2577 strcpy(line, previous_line); // copy storage buffer to line
2579 read_continued_line = FALSE;
2582 // if the last character is '\', continue at next line
2583 if (strlen(line) > 0 && line[strlen(line) - 1] == '\\')
2585 line[strlen(line) - 1] = '\0'; // cut off trailing backslash
2586 strcpy(previous_line, line); // copy line to storage buffer
2588 read_continued_line = TRUE;
2593 if (!getTokenValueFromSetupLineExt(line, &token, &value, filename,
2594 line_raw, line_nr, FALSE))
2599 if (strEqual(token, "include"))
2601 if (getHashEntry(include_filename_hash, value) == NULL)
2603 char *basepath = getBasePath(filename);
2604 char *basename = getBaseName(value);
2605 char *filename_include = getPath2(basepath, basename);
2607 loadSetupFileData(setup_file_data, filename_include, FALSE, is_hash);
2611 free(filename_include);
2617 Warn("ignoring already processed file '%s'", value);
2624 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2626 getHashEntry((SetupFileHash *)setup_file_data, token);
2628 if (old_value != NULL)
2630 if (!token_already_exists_warning)
2632 Debug("setup", "---");
2633 Debug("setup", "duplicate token(s) found in config file:");
2634 Debug("setup", "- config file: '%s'", filename);
2636 token_already_exists_warning = TRUE;
2639 Debug("setup", "- token: '%s' (in line %d)", token, line_nr);
2640 Debug("setup", " old value: '%s'", old_value);
2641 Debug("setup", " new value: '%s'", value);
2645 setHashEntry((SetupFileHash *)setup_file_data, token, value);
2649 insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value);
2659 #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
2660 if (token_value_separator_warning)
2661 Debug("setup", "---");
2664 #if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
2665 if (token_already_exists_warning)
2666 Debug("setup", "---");
2669 if (token_count == 0 && include_count == 0)
2670 Warn("configuration file '%s' is empty", filename);
2672 if (top_recursion_level)
2673 freeSetupFileHash(include_filename_hash);
2678 static int compareSetupFileData(const void *object1, const void *object2)
2680 const struct ConfigInfo *entry1 = (struct ConfigInfo *)object1;
2681 const struct ConfigInfo *entry2 = (struct ConfigInfo *)object2;
2683 return strcmp(entry1->token, entry2->token);
2686 static void saveSetupFileHash(SetupFileHash *hash, char *filename)
2688 int item_count = hashtable_count(hash);
2689 int item_size = sizeof(struct ConfigInfo);
2690 struct ConfigInfo *sort_array = checked_malloc(item_count * item_size);
2694 // copy string pointers from hash to array
2695 BEGIN_HASH_ITERATION(hash, itr)
2697 sort_array[i].token = HASH_ITERATION_TOKEN(itr);
2698 sort_array[i].value = HASH_ITERATION_VALUE(itr);
2702 if (i > item_count) // should never happen
2705 END_HASH_ITERATION(hash, itr)
2707 // sort string pointers from hash in array
2708 qsort(sort_array, item_count, item_size, compareSetupFileData);
2710 if (!(file = fopen(filename, MODE_WRITE)))
2712 Warn("cannot write configuration file '%s'", filename);
2717 fprintf(file, "%s\n\n", getFormattedSetupEntry("program.version",
2718 program.version_string));
2719 for (i = 0; i < item_count; i++)
2720 fprintf(file, "%s\n", getFormattedSetupEntry(sort_array[i].token,
2721 sort_array[i].value));
2724 checked_free(sort_array);
2727 SetupFileList *loadSetupFileList(char *filename)
2729 SetupFileList *setup_file_list = newSetupFileList("", "");
2730 SetupFileList *first_valid_list_entry;
2732 if (!loadSetupFileData(setup_file_list, filename, TRUE, FALSE))
2734 freeSetupFileList(setup_file_list);
2739 first_valid_list_entry = setup_file_list->next;
2741 // free empty list header
2742 setup_file_list->next = NULL;
2743 freeSetupFileList(setup_file_list);
2745 return first_valid_list_entry;
2748 SetupFileHash *loadSetupFileHash(char *filename)
2750 SetupFileHash *setup_file_hash = newSetupFileHash();
2752 if (!loadSetupFileData(setup_file_hash, filename, TRUE, TRUE))
2754 freeSetupFileHash(setup_file_hash);
2759 return setup_file_hash;
2763 // ============================================================================
2765 // ============================================================================
2767 #define TOKEN_STR_LAST_LEVEL_SERIES "last_level_series"
2768 #define TOKEN_STR_LAST_PLAYED_LEVEL "last_played_level"
2769 #define TOKEN_STR_HANDICAP_LEVEL "handicap_level"
2770 #define TOKEN_STR_LAST_USER "last_user"
2772 // level directory info
2773 #define LEVELINFO_TOKEN_IDENTIFIER 0
2774 #define LEVELINFO_TOKEN_NAME 1
2775 #define LEVELINFO_TOKEN_NAME_SORTING 2
2776 #define LEVELINFO_TOKEN_AUTHOR 3
2777 #define LEVELINFO_TOKEN_YEAR 4
2778 #define LEVELINFO_TOKEN_PROGRAM_TITLE 5
2779 #define LEVELINFO_TOKEN_PROGRAM_COPYRIGHT 6
2780 #define LEVELINFO_TOKEN_PROGRAM_COMPANY 7
2781 #define LEVELINFO_TOKEN_IMPORTED_FROM 8
2782 #define LEVELINFO_TOKEN_IMPORTED_BY 9
2783 #define LEVELINFO_TOKEN_TESTED_BY 10
2784 #define LEVELINFO_TOKEN_LEVELS 11
2785 #define LEVELINFO_TOKEN_FIRST_LEVEL 12
2786 #define LEVELINFO_TOKEN_SORT_PRIORITY 13
2787 #define LEVELINFO_TOKEN_LATEST_ENGINE 14
2788 #define LEVELINFO_TOKEN_LEVEL_GROUP 15
2789 #define LEVELINFO_TOKEN_READONLY 16
2790 #define LEVELINFO_TOKEN_GRAPHICS_SET_ECS 17
2791 #define LEVELINFO_TOKEN_GRAPHICS_SET_AGA 18
2792 #define LEVELINFO_TOKEN_GRAPHICS_SET 19
2793 #define LEVELINFO_TOKEN_SOUNDS_SET_DEFAULT 20
2794 #define LEVELINFO_TOKEN_SOUNDS_SET_LOWPASS 21
2795 #define LEVELINFO_TOKEN_SOUNDS_SET 22
2796 #define LEVELINFO_TOKEN_MUSIC_SET 23
2797 #define LEVELINFO_TOKEN_FILENAME 24
2798 #define LEVELINFO_TOKEN_FILETYPE 25
2799 #define LEVELINFO_TOKEN_SPECIAL_FLAGS 26
2800 #define LEVELINFO_TOKEN_EMPTY_LEVEL_NAME 27
2801 #define LEVELINFO_TOKEN_FORCE_LEVEL_NAME 28
2802 #define LEVELINFO_TOKEN_HANDICAP 29
2803 #define LEVELINFO_TOKEN_TIME_LIMIT 30
2804 #define LEVELINFO_TOKEN_SKIP_LEVELS 31
2805 #define LEVELINFO_TOKEN_USE_EMC_TILES 32
2806 #define LEVELINFO_TOKEN_INFO_SCREENS_FROM_MAIN 33
2808 #define NUM_LEVELINFO_TOKENS 34
2810 static LevelDirTree ldi;
2812 static struct TokenInfo levelinfo_tokens[] =
2814 // level directory info
2815 { TYPE_STRING, &ldi.identifier, "identifier" },
2816 { TYPE_STRING, &ldi.name, "name" },
2817 { TYPE_STRING, &ldi.name_sorting, "name_sorting" },
2818 { TYPE_STRING, &ldi.author, "author" },
2819 { TYPE_STRING, &ldi.year, "year" },
2820 { TYPE_STRING, &ldi.program_title, "program_title" },
2821 { TYPE_STRING, &ldi.program_copyright, "program_copyright" },
2822 { TYPE_STRING, &ldi.program_company, "program_company" },
2823 { TYPE_STRING, &ldi.imported_from, "imported_from" },
2824 { TYPE_STRING, &ldi.imported_by, "imported_by" },
2825 { TYPE_STRING, &ldi.tested_by, "tested_by" },
2826 { TYPE_INTEGER, &ldi.levels, "levels" },
2827 { TYPE_INTEGER, &ldi.first_level, "first_level" },
2828 { TYPE_INTEGER, &ldi.sort_priority, "sort_priority" },
2829 { TYPE_BOOLEAN, &ldi.latest_engine, "latest_engine" },
2830 { TYPE_BOOLEAN, &ldi.level_group, "level_group" },
2831 { TYPE_BOOLEAN, &ldi.readonly, "readonly" },
2832 { TYPE_STRING, &ldi.graphics_set_ecs, "graphics_set.ecs" },
2833 { TYPE_STRING, &ldi.graphics_set_aga, "graphics_set.aga" },
2834 { TYPE_STRING, &ldi.graphics_set, "graphics_set" },
2835 { TYPE_STRING, &ldi.sounds_set_default,"sounds_set.default" },
2836 { TYPE_STRING, &ldi.sounds_set_lowpass,"sounds_set.lowpass" },
2837 { TYPE_STRING, &ldi.sounds_set, "sounds_set" },
2838 { TYPE_STRING, &ldi.music_set, "music_set" },
2839 { TYPE_STRING, &ldi.level_filename, "filename" },
2840 { TYPE_STRING, &ldi.level_filetype, "filetype" },
2841 { TYPE_STRING, &ldi.special_flags, "special_flags" },
2842 { TYPE_STRING, &ldi.empty_level_name, "empty_level_name" },
2843 { TYPE_BOOLEAN, &ldi.force_level_name, "force_level_name" },
2844 { TYPE_BOOLEAN, &ldi.handicap, "handicap" },
2845 { TYPE_BOOLEAN, &ldi.time_limit, "time_limit" },
2846 { TYPE_BOOLEAN, &ldi.skip_levels, "skip_levels" },
2847 { TYPE_BOOLEAN, &ldi.use_emc_tiles, "use_emc_tiles" },
2848 { TYPE_BOOLEAN, &ldi.info_screens_from_main, "info_screens_from_main" }
2851 static struct TokenInfo artworkinfo_tokens[] =
2853 // artwork directory info
2854 { TYPE_STRING, &ldi.identifier, "identifier" },
2855 { TYPE_STRING, &ldi.subdir, "subdir" },
2856 { TYPE_STRING, &ldi.name, "name" },
2857 { TYPE_STRING, &ldi.name_sorting, "name_sorting" },
2858 { TYPE_STRING, &ldi.author, "author" },
2859 { TYPE_STRING, &ldi.program_title, "program_title" },
2860 { TYPE_STRING, &ldi.program_copyright, "program_copyright" },
2861 { TYPE_STRING, &ldi.program_company, "program_company" },
2862 { TYPE_INTEGER, &ldi.sort_priority, "sort_priority" },
2863 { TYPE_STRING, &ldi.basepath, "basepath" },
2864 { TYPE_STRING, &ldi.fullpath, "fullpath" },
2865 { TYPE_BOOLEAN, &ldi.in_user_dir, "in_user_dir" },
2866 { TYPE_STRING, &ldi.class_desc, "class_desc" },
2871 static char *optional_tokens[] =
2874 "program_copyright",
2880 static void setTreeInfoToDefaults(TreeInfo *ti, int type)
2884 ti->node_top = (ti->type == TREE_TYPE_LEVEL_DIR ? &leveldir_first :
2885 ti->type == TREE_TYPE_GRAPHICS_DIR ? &artwork.gfx_first :
2886 ti->type == TREE_TYPE_SOUNDS_DIR ? &artwork.snd_first :
2887 ti->type == TREE_TYPE_MUSIC_DIR ? &artwork.mus_first :
2890 ti->node_parent = NULL;
2891 ti->node_group = NULL;
2898 ti->fullpath = NULL;
2899 ti->basepath = NULL;
2900 ti->identifier = NULL;
2901 ti->name = getStringCopy(ANONYMOUS_NAME);
2902 ti->name_sorting = NULL;
2903 ti->author = getStringCopy(ANONYMOUS_NAME);
2906 ti->program_title = NULL;
2907 ti->program_copyright = NULL;
2908 ti->program_company = NULL;
2910 ti->sort_priority = LEVELCLASS_UNDEFINED; // default: least priority
2911 ti->latest_engine = FALSE; // default: get from level
2912 ti->parent_link = FALSE;
2913 ti->is_copy = FALSE;
2914 ti->in_user_dir = FALSE;
2915 ti->user_defined = FALSE;
2917 ti->class_desc = NULL;
2919 ti->infotext = getStringCopy(TREE_INFOTEXT(ti->type));
2921 if (ti->type == TREE_TYPE_LEVEL_DIR)
2923 ti->imported_from = NULL;
2924 ti->imported_by = NULL;
2925 ti->tested_by = NULL;
2927 ti->graphics_set_ecs = NULL;
2928 ti->graphics_set_aga = NULL;
2929 ti->graphics_set = NULL;
2930 ti->sounds_set_default = NULL;
2931 ti->sounds_set_lowpass = NULL;
2932 ti->sounds_set = NULL;
2933 ti->music_set = NULL;
2934 ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
2935 ti->sounds_path = getStringCopy(UNDEFINED_FILENAME);
2936 ti->music_path = getStringCopy(UNDEFINED_FILENAME);
2938 ti->level_filename = NULL;
2939 ti->level_filetype = NULL;
2941 ti->special_flags = NULL;
2943 ti->empty_level_name = NULL;
2944 ti->force_level_name = FALSE;
2947 ti->first_level = 0;
2949 ti->level_group = FALSE;
2950 ti->handicap_level = 0;
2951 ti->readonly = TRUE;
2952 ti->handicap = TRUE;
2953 ti->time_limit = TRUE;
2954 ti->skip_levels = FALSE;
2956 ti->use_emc_tiles = FALSE;
2957 ti->info_screens_from_main = FALSE;
2961 static void setTreeInfoToDefaultsFromParent(TreeInfo *ti, TreeInfo *parent)
2965 Warn("setTreeInfoToDefaultsFromParent(): parent == NULL");
2967 setTreeInfoToDefaults(ti, TREE_TYPE_UNDEFINED);
2972 // copy all values from the parent structure
2974 ti->type = parent->type;
2976 ti->node_top = parent->node_top;
2977 ti->node_parent = parent;
2978 ti->node_group = NULL;
2985 ti->fullpath = NULL;
2986 ti->basepath = NULL;
2987 ti->identifier = NULL;
2988 ti->name = getStringCopy(ANONYMOUS_NAME);
2989 ti->name_sorting = NULL;
2990 ti->author = getStringCopy(parent->author);
2991 ti->year = getStringCopy(parent->year);
2993 ti->program_title = getStringCopy(parent->program_title);
2994 ti->program_copyright = getStringCopy(parent->program_copyright);
2995 ti->program_company = getStringCopy(parent->program_company);
2997 ti->sort_priority = parent->sort_priority;
2998 ti->latest_engine = parent->latest_engine;
2999 ti->parent_link = FALSE;
3000 ti->is_copy = FALSE;
3001 ti->in_user_dir = parent->in_user_dir;
3002 ti->user_defined = parent->user_defined;
3003 ti->color = parent->color;
3004 ti->class_desc = getStringCopy(parent->class_desc);
3006 ti->infotext = getStringCopy(parent->infotext);
3008 if (ti->type == TREE_TYPE_LEVEL_DIR)
3010 ti->imported_from = getStringCopy(parent->imported_from);
3011 ti->imported_by = getStringCopy(parent->imported_by);
3012 ti->tested_by = getStringCopy(parent->tested_by);
3014 ti->graphics_set_ecs = getStringCopy(parent->graphics_set_ecs);
3015 ti->graphics_set_aga = getStringCopy(parent->graphics_set_aga);
3016 ti->graphics_set = getStringCopy(parent->graphics_set);
3017 ti->sounds_set_default = getStringCopy(parent->sounds_set_default);
3018 ti->sounds_set_lowpass = getStringCopy(parent->sounds_set_lowpass);
3019 ti->sounds_set = getStringCopy(parent->sounds_set);
3020 ti->music_set = getStringCopy(parent->music_set);
3021 ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
3022 ti->sounds_path = getStringCopy(UNDEFINED_FILENAME);
3023 ti->music_path = getStringCopy(UNDEFINED_FILENAME);
3025 ti->level_filename = getStringCopy(parent->level_filename);
3026 ti->level_filetype = getStringCopy(parent->level_filetype);
3028 ti->special_flags = getStringCopy(parent->special_flags);
3030 ti->empty_level_name = getStringCopy(parent->empty_level_name);
3031 ti->force_level_name = parent->force_level_name;
3033 ti->levels = parent->levels;
3034 ti->first_level = parent->first_level;
3035 ti->last_level = parent->last_level;
3036 ti->level_group = FALSE;
3037 ti->handicap_level = parent->handicap_level;
3038 ti->readonly = parent->readonly;
3039 ti->handicap = parent->handicap;
3040 ti->time_limit = parent->time_limit;
3041 ti->skip_levels = parent->skip_levels;
3043 ti->use_emc_tiles = parent->use_emc_tiles;
3044 ti->info_screens_from_main = parent->info_screens_from_main;
3048 static TreeInfo *getTreeInfoCopy(TreeInfo *ti)
3050 TreeInfo *ti_copy = newTreeInfo();
3052 // copy all values from the original structure
3054 ti_copy->type = ti->type;
3056 ti_copy->node_top = ti->node_top;
3057 ti_copy->node_parent = ti->node_parent;
3058 ti_copy->node_group = ti->node_group;
3059 ti_copy->next = ti->next;
3061 ti_copy->cl_first = ti->cl_first;
3062 ti_copy->cl_cursor = ti->cl_cursor;
3064 ti_copy->subdir = getStringCopy(ti->subdir);
3065 ti_copy->fullpath = getStringCopy(ti->fullpath);
3066 ti_copy->basepath = getStringCopy(ti->basepath);
3067 ti_copy->identifier = getStringCopy(ti->identifier);
3068 ti_copy->name = getStringCopy(ti->name);
3069 ti_copy->name_sorting = getStringCopy(ti->name_sorting);
3070 ti_copy->author = getStringCopy(ti->author);
3071 ti_copy->year = getStringCopy(ti->year);
3073 ti_copy->program_title = getStringCopy(ti->program_title);
3074 ti_copy->program_copyright = getStringCopy(ti->program_copyright);
3075 ti_copy->program_company = getStringCopy(ti->program_company);
3077 ti_copy->imported_from = getStringCopy(ti->imported_from);
3078 ti_copy->imported_by = getStringCopy(ti->imported_by);
3079 ti_copy->tested_by = getStringCopy(ti->tested_by);
3081 ti_copy->graphics_set_ecs = getStringCopy(ti->graphics_set_ecs);
3082 ti_copy->graphics_set_aga = getStringCopy(ti->graphics_set_aga);
3083 ti_copy->graphics_set = getStringCopy(ti->graphics_set);
3084 ti_copy->sounds_set_default = getStringCopy(ti->sounds_set_default);
3085 ti_copy->sounds_set_lowpass = getStringCopy(ti->sounds_set_lowpass);
3086 ti_copy->sounds_set = getStringCopy(ti->sounds_set);
3087 ti_copy->music_set = getStringCopy(ti->music_set);
3088 ti_copy->graphics_path = getStringCopy(ti->graphics_path);
3089 ti_copy->sounds_path = getStringCopy(ti->sounds_path);
3090 ti_copy->music_path = getStringCopy(ti->music_path);
3092 ti_copy->level_filename = getStringCopy(ti->level_filename);
3093 ti_copy->level_filetype = getStringCopy(ti->level_filetype);
3095 ti_copy->special_flags = getStringCopy(ti->special_flags);
3097 ti_copy->empty_level_name = getStringCopy(ti->empty_level_name);
3098 ti_copy->force_level_name = ti->force_level_name;
3100 ti_copy->levels = ti->levels;
3101 ti_copy->first_level = ti->first_level;
3102 ti_copy->last_level = ti->last_level;
3103 ti_copy->sort_priority = ti->sort_priority;
3105 ti_copy->latest_engine = ti->latest_engine;
3107 ti_copy->level_group = ti->level_group;
3108 ti_copy->parent_link = ti->parent_link;
3109 ti_copy->is_copy = ti->is_copy;
3110 ti_copy->in_user_dir = ti->in_user_dir;
3111 ti_copy->user_defined = ti->user_defined;
3112 ti_copy->readonly = ti->readonly;
3113 ti_copy->handicap = ti->handicap;
3114 ti_copy->time_limit = ti->time_limit;
3115 ti_copy->skip_levels = ti->skip_levels;
3117 ti_copy->use_emc_tiles = ti->use_emc_tiles;
3118 ti_copy->info_screens_from_main = ti->info_screens_from_main;
3120 ti_copy->color = ti->color;
3121 ti_copy->class_desc = getStringCopy(ti->class_desc);
3122 ti_copy->handicap_level = ti->handicap_level;
3124 ti_copy->infotext = getStringCopy(ti->infotext);
3129 void freeTreeInfo(TreeInfo *ti)
3134 checked_free(ti->subdir);
3135 checked_free(ti->fullpath);
3136 checked_free(ti->basepath);
3137 checked_free(ti->identifier);
3139 checked_free(ti->name);
3140 checked_free(ti->name_sorting);
3141 checked_free(ti->author);
3142 checked_free(ti->year);
3144 checked_free(ti->program_title);
3145 checked_free(ti->program_copyright);
3146 checked_free(ti->program_company);
3148 checked_free(ti->class_desc);
3150 checked_free(ti->infotext);
3152 if (ti->type == TREE_TYPE_LEVEL_DIR)
3154 checked_free(ti->imported_from);
3155 checked_free(ti->imported_by);
3156 checked_free(ti->tested_by);
3158 checked_free(ti->graphics_set_ecs);
3159 checked_free(ti->graphics_set_aga);
3160 checked_free(ti->graphics_set);
3161 checked_free(ti->sounds_set_default);
3162 checked_free(ti->sounds_set_lowpass);
3163 checked_free(ti->sounds_set);
3164 checked_free(ti->music_set);
3166 checked_free(ti->graphics_path);
3167 checked_free(ti->sounds_path);
3168 checked_free(ti->music_path);
3170 checked_free(ti->level_filename);
3171 checked_free(ti->level_filetype);
3173 checked_free(ti->special_flags);
3176 // recursively free child node
3178 freeTreeInfo(ti->node_group);
3180 // recursively free next node
3182 freeTreeInfo(ti->next);
3187 void setSetupInfo(struct TokenInfo *token_info,
3188 int token_nr, char *token_value)
3190 int token_type = token_info[token_nr].type;
3191 void *setup_value = token_info[token_nr].value;
3193 if (token_value == NULL)
3196 // set setup field to corresponding token value
3201 *(boolean *)setup_value = get_boolean_from_string(token_value);
3205 *(int *)setup_value = get_switch3_from_string(token_value);
3209 *(Key *)setup_value = getKeyFromKeyName(token_value);
3213 *(Key *)setup_value = getKeyFromX11KeyName(token_value);
3217 *(int *)setup_value = get_integer_from_string(token_value);
3221 checked_free(*(char **)setup_value);
3222 *(char **)setup_value = getStringCopy(token_value);
3226 *(int *)setup_value = get_player_nr_from_string(token_value);
3234 static int compareTreeInfoEntries(const void *object1, const void *object2)
3236 const TreeInfo *entry1 = *((TreeInfo **)object1);
3237 const TreeInfo *entry2 = *((TreeInfo **)object2);
3238 int tree_sorting1 = TREE_SORTING(entry1);
3239 int tree_sorting2 = TREE_SORTING(entry2);
3241 if (tree_sorting1 != tree_sorting2)
3242 return (tree_sorting1 - tree_sorting2);
3244 return strcasecmp(entry1->name_sorting, entry2->name_sorting);
3247 static TreeInfo *createParentTreeInfoNode(TreeInfo *node_parent)
3251 if (node_parent == NULL)
3254 ti_new = newTreeInfo();
3255 setTreeInfoToDefaults(ti_new, node_parent->type);
3257 ti_new->node_parent = node_parent;
3258 ti_new->parent_link = TRUE;
3260 setString(&ti_new->identifier, node_parent->identifier);
3261 setString(&ti_new->name, BACKLINK_TEXT_PARENT);
3262 setString(&ti_new->name_sorting, ti_new->name);
3264 setString(&ti_new->subdir, STRING_PARENT_DIRECTORY);
3265 setString(&ti_new->fullpath, node_parent->fullpath);
3267 ti_new->sort_priority = LEVELCLASS_PARENT;
3268 ti_new->latest_engine = node_parent->latest_engine;
3270 setString(&ti_new->class_desc, getLevelClassDescription(ti_new));
3272 pushTreeInfo(&node_parent->node_group, ti_new);
3277 static TreeInfo *createTopTreeInfoNode(TreeInfo *node_first)
3279 if (node_first == NULL)
3282 TreeInfo *ti_new = newTreeInfo();
3283 int type = node_first->type;
3285 setTreeInfoToDefaults(ti_new, type);
3287 ti_new->node_parent = NULL;
3288 ti_new->parent_link = FALSE;
3290 setString(&ti_new->identifier, "top_tree_node");
3291 setString(&ti_new->name, TREE_INFOTEXT(type));
3292 setString(&ti_new->name_sorting, ti_new->name);
3294 setString(&ti_new->subdir, STRING_TOP_DIRECTORY);
3295 setString(&ti_new->fullpath, ".");
3297 ti_new->sort_priority = LEVELCLASS_TOP;
3298 ti_new->latest_engine = node_first->latest_engine;
3300 setString(&ti_new->class_desc, TREE_INFOTEXT(type));
3302 ti_new->node_group = node_first;
3303 ti_new->level_group = TRUE;
3305 TreeInfo *ti_new2 = createParentTreeInfoNode(ti_new);
3307 setString(&ti_new2->name, TREE_BACKLINK_TEXT(type));
3308 setString(&ti_new2->name_sorting, ti_new2->name);
3313 static void setTreeInfoParentNodes(TreeInfo *node, TreeInfo *node_parent)
3317 if (node->node_group)
3318 setTreeInfoParentNodes(node->node_group, node);
3320 node->node_parent = node_parent;
3326 TreeInfo *addTopTreeInfoNode(TreeInfo *node_first)
3328 // add top tree node with back link node in previous tree
3329 node_first = createTopTreeInfoNode(node_first);
3331 // set all parent links (back links) in complete tree
3332 setTreeInfoParentNodes(node_first, NULL);
3338 // ----------------------------------------------------------------------------
3339 // functions for handling level and custom artwork info cache
3340 // ----------------------------------------------------------------------------
3342 static void LoadArtworkInfoCache(void)
3344 InitCacheDirectory();
3346 if (artworkinfo_cache_old == NULL)
3348 char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
3350 // try to load artwork info hash from already existing cache file
3351 artworkinfo_cache_old = loadSetupFileHash(filename);
3353 // try to get program version that artwork info cache was written with
3354 char *version = getHashEntry(artworkinfo_cache_old, "program.version");
3356 // check program version of artwork info cache against current version
3357 if (!strEqual(version, program.version_string))
3359 freeSetupFileHash(artworkinfo_cache_old);
3361 artworkinfo_cache_old = NULL;
3364 // if no artwork info cache file was found, start with empty hash
3365 if (artworkinfo_cache_old == NULL)
3366 artworkinfo_cache_old = newSetupFileHash();
3371 if (artworkinfo_cache_new == NULL)
3372 artworkinfo_cache_new = newSetupFileHash();
3374 update_artworkinfo_cache = FALSE;
3377 static void SaveArtworkInfoCache(void)
3379 if (!update_artworkinfo_cache)
3382 char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
3384 InitCacheDirectory();
3386 saveSetupFileHash(artworkinfo_cache_new, filename);
3391 static char *getCacheTokenPrefix(char *prefix1, char *prefix2)
3393 static char *prefix = NULL;
3395 checked_free(prefix);
3397 prefix = getStringCat2WithSeparator(prefix1, prefix2, ".");
3402 // (identical to above function, but separate string buffer needed -- nasty)
3403 static char *getCacheToken(char *prefix, char *suffix)
3405 static char *token = NULL;
3407 checked_free(token);
3409 token = getStringCat2WithSeparator(prefix, suffix, ".");
3414 static char *getFileTimestampString(char *filename)
3416 return getStringCopy(i_to_a(getFileTimestampEpochSeconds(filename)));
3419 static boolean modifiedFileTimestamp(char *filename, char *timestamp_string)
3421 struct stat file_status;
3423 if (timestamp_string == NULL)
3426 if (!fileExists(filename)) // file does not exist
3427 return (atoi(timestamp_string) != 0);
3429 if (stat(filename, &file_status) != 0) // cannot stat file
3432 return (file_status.st_mtime != atoi(timestamp_string));
3435 static TreeInfo *getArtworkInfoCacheEntry(LevelDirTree *level_node, int type)
3437 char *identifier = level_node->subdir;
3438 char *type_string = ARTWORK_DIRECTORY(type);
3439 char *token_prefix = getCacheTokenPrefix(type_string, identifier);
3440 char *token_main = getCacheToken(token_prefix, "CACHED");
3441 char *cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3442 boolean cached = (cache_entry != NULL && strEqual(cache_entry, "true"));
3443 TreeInfo *artwork_info = NULL;
3445 if (!use_artworkinfo_cache)
3448 if (optional_tokens_hash == NULL)
3452 // create hash from list of optional tokens (for quick access)
3453 optional_tokens_hash = newSetupFileHash();
3454 for (i = 0; optional_tokens[i] != NULL; i++)
3455 setHashEntry(optional_tokens_hash, optional_tokens[i], "");
3462 artwork_info = newTreeInfo();
3463 setTreeInfoToDefaults(artwork_info, type);
3465 // set all structure fields according to the token/value pairs
3466 ldi = *artwork_info;
3467 for (i = 0; artworkinfo_tokens[i].type != -1; i++)
3469 char *token_suffix = artworkinfo_tokens[i].text;
3470 char *token = getCacheToken(token_prefix, token_suffix);
3471 char *value = getHashEntry(artworkinfo_cache_old, token);
3473 (getHashEntry(optional_tokens_hash, token_suffix) != NULL);
3475 setSetupInfo(artworkinfo_tokens, i, value);
3477 // check if cache entry for this item is mandatory, but missing
3478 if (value == NULL && !optional)
3480 Warn("missing cache entry '%s'", token);
3486 *artwork_info = ldi;
3491 char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
3492 LEVELINFO_FILENAME);
3493 char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
3494 ARTWORKINFO_FILENAME(type));
3496 // check if corresponding "levelinfo.conf" file has changed
3497 token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
3498 cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3500 if (modifiedFileTimestamp(filename_levelinfo, cache_entry))
3503 // check if corresponding "<artworkinfo>.conf" file has changed
3504 token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
3505 cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
3507 if (modifiedFileTimestamp(filename_artworkinfo, cache_entry))
3510 checked_free(filename_levelinfo);
3511 checked_free(filename_artworkinfo);
3514 if (!cached && artwork_info != NULL)
3516 freeTreeInfo(artwork_info);
3521 return artwork_info;
3524 static void setArtworkInfoCacheEntry(TreeInfo *artwork_info,
3525 LevelDirTree *level_node, int type)
3527 char *identifier = level_node->subdir;
3528 char *type_string = ARTWORK_DIRECTORY(type);
3529 char *token_prefix = getCacheTokenPrefix(type_string, identifier);
3530 char *token_main = getCacheToken(token_prefix, "CACHED");
3531 boolean set_cache_timestamps = TRUE;
3534 setHashEntry(artworkinfo_cache_new, token_main, "true");
3536 if (set_cache_timestamps)
3538 char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
3539 LEVELINFO_FILENAME);
3540 char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
3541 ARTWORKINFO_FILENAME(type));
3542 char *timestamp_levelinfo = getFileTimestampString(filename_levelinfo);
3543 char *timestamp_artworkinfo = getFileTimestampString(filename_artworkinfo);
3545 token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
3546 setHashEntry(artworkinfo_cache_new, token_main, timestamp_levelinfo);
3548 token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
3549 setHashEntry(artworkinfo_cache_new, token_main, timestamp_artworkinfo);
3551 checked_free(filename_levelinfo);
3552 checked_free(filename_artworkinfo);
3553 checked_free(timestamp_levelinfo);
3554 checked_free(timestamp_artworkinfo);
3557 ldi = *artwork_info;
3558 for (i = 0; artworkinfo_tokens[i].type != -1; i++)
3560 char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text);
3561 char *value = getSetupValue(artworkinfo_tokens[i].type,
3562 artworkinfo_tokens[i].value);
3564 setHashEntry(artworkinfo_cache_new, token, value);
3569 // ----------------------------------------------------------------------------
3570 // functions for loading level info and custom artwork info
3571 // ----------------------------------------------------------------------------
3573 int GetZipFileTreeType(char *zip_filename)
3575 static char *top_dir_path = NULL;
3576 static char *top_dir_conf_filename[NUM_BASE_TREE_TYPES] = { NULL };
3577 static char *conf_basename[NUM_BASE_TREE_TYPES] =
3579 GRAPHICSINFO_FILENAME,
3580 SOUNDSINFO_FILENAME,
3586 checked_free(top_dir_path);
3587 top_dir_path = NULL;
3589 for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3591 checked_free(top_dir_conf_filename[j]);
3592 top_dir_conf_filename[j] = NULL;
3595 char **zip_entries = zip_list(zip_filename);
3597 // check if zip file successfully opened
3598 if (zip_entries == NULL || zip_entries[0] == NULL)
3599 return TREE_TYPE_UNDEFINED;
3601 // first zip file entry is expected to be top level directory
3602 char *top_dir = zip_entries[0];
3604 // check if valid top level directory found in zip file
3605 if (!strSuffix(top_dir, "/"))
3606 return TREE_TYPE_UNDEFINED;
3608 // get filenames of valid configuration files in top level directory
3609 for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3610 top_dir_conf_filename[j] = getStringCat2(top_dir, conf_basename[j]);
3612 int tree_type = TREE_TYPE_UNDEFINED;
3615 while (zip_entries[e] != NULL)
3617 // check if every zip file entry is below top level directory
3618 if (!strPrefix(zip_entries[e], top_dir))
3619 return TREE_TYPE_UNDEFINED;
3621 // check if this zip file entry is a valid configuration filename
3622 for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
3624 if (strEqual(zip_entries[e], top_dir_conf_filename[j]))
3626 // only exactly one valid configuration file allowed
3627 if (tree_type != TREE_TYPE_UNDEFINED)
3628 return TREE_TYPE_UNDEFINED;
3640 static boolean CheckZipFileForDirectory(char *zip_filename, char *directory,
3643 static char *top_dir_path = NULL;
3644 static char *top_dir_conf_filename = NULL;
3646 checked_free(top_dir_path);
3647 checked_free(top_dir_conf_filename);
3649 top_dir_path = NULL;
3650 top_dir_conf_filename = NULL;
3652 char *conf_basename = (tree_type == TREE_TYPE_LEVEL_DIR ? LEVELINFO_FILENAME :
3653 ARTWORKINFO_FILENAME(tree_type));
3655 // check if valid configuration filename determined
3656 if (conf_basename == NULL || strEqual(conf_basename, ""))
3659 char **zip_entries = zip_list(zip_filename);
3661 // check if zip file successfully opened
3662 if (zip_entries == NULL || zip_entries[0] == NULL)
3665 // first zip file entry is expected to be top level directory
3666 char *top_dir = zip_entries[0];
3668 // check if valid top level directory found in zip file
3669 if (!strSuffix(top_dir, "/"))
3672 // get path of extracted top level directory
3673 top_dir_path = getPath2(directory, top_dir);
3675 // remove trailing directory separator from top level directory path
3676 // (required to be able to check for file and directory in next step)
3677 top_dir_path[strlen(top_dir_path) - 1] = '\0';
3679 // check if zip file's top level directory already exists in target directory
3680 if (fileExists(top_dir_path)) // (checks for file and directory)
3683 // get filename of configuration file in top level directory
3684 top_dir_conf_filename = getStringCat2(top_dir, conf_basename);
3686 boolean found_top_dir_conf_filename = FALSE;
3689 while (zip_entries[i] != NULL)
3691 // check if every zip file entry is below top level directory
3692 if (!strPrefix(zip_entries[i], top_dir))
3695 // check if this zip file entry is the configuration filename
3696 if (strEqual(zip_entries[i], top_dir_conf_filename))
3697 found_top_dir_conf_filename = TRUE;
3702 // check if valid configuration filename was found in zip file
3703 if (!found_top_dir_conf_filename)
3709 char *ExtractZipFileIntoDirectory(char *zip_filename, char *directory,
3712 boolean zip_file_valid = CheckZipFileForDirectory(zip_filename, directory,
3715 if (!zip_file_valid)
3717 Warn("zip file '%s' rejected!", zip_filename);
3722 char **zip_entries = zip_extract(zip_filename, directory);
3724 if (zip_entries == NULL)
3726 Warn("zip file '%s' could not be extracted!", zip_filename);
3731 Info("zip file '%s' successfully extracted!", zip_filename);
3733 // first zip file entry contains top level directory
3734 char *top_dir = zip_entries[0];
3736 // remove trailing directory separator from top level directory
3737 top_dir[strlen(top_dir) - 1] = '\0';
3742 static void ProcessZipFilesInDirectory(char *directory, int tree_type)
3745 DirectoryEntry *dir_entry;
3747 if ((dir = openDirectory(directory)) == NULL)
3749 // display error if directory is main "options.graphics_directory" etc.
3750 if (tree_type == TREE_TYPE_LEVEL_DIR ||
3751 directory == OPTIONS_ARTWORK_DIRECTORY(tree_type))
3752 Warn("cannot read directory '%s'", directory);
3757 while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
3759 // skip non-zip files (and also directories with zip extension)
3760 if (!strSuffixLower(dir_entry->basename, ".zip") || dir_entry->is_directory)
3763 char *zip_filename = getPath2(directory, dir_entry->basename);
3764 char *zip_filename_extracted = getStringCat2(zip_filename, ".extracted");
3765 char *zip_filename_rejected = getStringCat2(zip_filename, ".rejected");
3767 // check if zip file hasn't already been extracted or rejected
3768 if (!fileExists(zip_filename_extracted) &&
3769 !fileExists(zip_filename_rejected))
3771 char *top_dir = ExtractZipFileIntoDirectory(zip_filename, directory,
3773 char *marker_filename = (top_dir != NULL ? zip_filename_extracted :
3774 zip_filename_rejected);
3777 // create empty file to mark zip file as extracted or rejected
3778 if ((marker_file = fopen(marker_filename, MODE_WRITE)))
3779 fclose(marker_file);
3782 free(zip_filename_extracted);
3783 free(zip_filename_rejected);
3787 closeDirectory(dir);
3790 // forward declaration for recursive call by "LoadLevelInfoFromLevelDir()"
3791 static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
3793 static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
3794 TreeInfo *node_parent,
3795 char *level_directory,
3796 char *directory_name)
3798 char *directory_path = getPath2(level_directory, directory_name);
3799 char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
3800 SetupFileHash *setup_file_hash;
3801 LevelDirTree *leveldir_new = NULL;
3804 // unless debugging, silently ignore directories without "levelinfo.conf"
3805 if (!options.debug && !fileExists(filename))
3807 free(directory_path);
3813 setup_file_hash = loadSetupFileHash(filename);
3815 if (setup_file_hash == NULL)
3817 #if DEBUG_NO_CONFIG_FILE
3818 Debug("setup", "ignoring level directory '%s'", directory_path);
3821 free(directory_path);
3827 leveldir_new = newTreeInfo();
3830 setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
3832 setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
3834 leveldir_new->subdir = getStringCopy(directory_name);
3836 // set all structure fields according to the token/value pairs
3837 ldi = *leveldir_new;
3838 for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
3839 setSetupInfo(levelinfo_tokens, i,
3840 getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
3841 *leveldir_new = ldi;
3843 if (strEqual(leveldir_new->name, ANONYMOUS_NAME))
3844 setString(&leveldir_new->name, leveldir_new->subdir);
3846 if (leveldir_new->identifier == NULL)
3847 leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
3849 if (leveldir_new->name_sorting == NULL)
3850 leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
3852 if (node_parent == NULL) // top level group
3854 leveldir_new->basepath = getStringCopy(level_directory);
3855 leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
3857 else // sub level group
3859 leveldir_new->basepath = getStringCopy(node_parent->basepath);
3860 leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
3863 leveldir_new->last_level =
3864 leveldir_new->first_level + leveldir_new->levels - 1;
3866 leveldir_new->in_user_dir =
3867 (!strEqual(leveldir_new->basepath, options.level_directory));
3869 // adjust some settings if user's private level directory was detected
3870 if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
3871 leveldir_new->in_user_dir &&
3872 (strEqual(leveldir_new->subdir, getLoginName()) ||
3873 strEqual(leveldir_new->name, getLoginName()) ||
3874 strEqual(leveldir_new->author, getRealName())))
3876 leveldir_new->sort_priority = LEVELCLASS_PRIVATE_START;
3877 leveldir_new->readonly = FALSE;
3880 leveldir_new->user_defined =
3881 (leveldir_new->in_user_dir && IS_LEVELCLASS_PRIVATE(leveldir_new));
3883 setString(&leveldir_new->class_desc, getLevelClassDescription(leveldir_new));
3885 leveldir_new->handicap_level = // set handicap to default value
3886 (leveldir_new->user_defined || !leveldir_new->handicap ?
3887 leveldir_new->last_level : leveldir_new->first_level);
3889 DrawInitTextItem(leveldir_new->name);
3891 pushTreeInfo(node_first, leveldir_new);
3893 freeSetupFileHash(setup_file_hash);
3895 if (leveldir_new->level_group)
3897 // create node to link back to current level directory
3898 createParentTreeInfoNode(leveldir_new);
3900 // recursively step into sub-directory and look for more level series
3901 LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
3902 leveldir_new, directory_path);
3905 free(directory_path);
3911 static void LoadLevelInfoFromLevelDir(TreeInfo **node_first,
3912 TreeInfo *node_parent,
3913 char *level_directory)
3915 // ---------- 1st stage: process any level set zip files ----------
3917 ProcessZipFilesInDirectory(level_directory, TREE_TYPE_LEVEL_DIR);
3919 // ---------- 2nd stage: check for level set directories ----------
3922 DirectoryEntry *dir_entry;
3923 boolean valid_entry_found = FALSE;
3925 if ((dir = openDirectory(level_directory)) == NULL)
3927 Warn("cannot read level directory '%s'", level_directory);
3932 while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
3934 char *directory_name = dir_entry->basename;
3935 char *directory_path = getPath2(level_directory, directory_name);
3937 // skip entries for current and parent directory
3938 if (strEqual(directory_name, ".") ||
3939 strEqual(directory_name, ".."))
3941 free(directory_path);
3946 // find out if directory entry is itself a directory
3947 if (!dir_entry->is_directory) // not a directory
3949 free(directory_path);
3954 free(directory_path);
3956 if (strEqual(directory_name, GRAPHICS_DIRECTORY) ||
3957 strEqual(directory_name, SOUNDS_DIRECTORY) ||
3958 strEqual(directory_name, MUSIC_DIRECTORY))
3961 valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
3966 closeDirectory(dir);
3968 // special case: top level directory may directly contain "levelinfo.conf"
3969 if (node_parent == NULL && !valid_entry_found)
3971 // check if this directory directly contains a file "levelinfo.conf"
3972 valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
3973 level_directory, ".");
3976 boolean valid_entry_expected =
3977 (strEqual(level_directory, options.level_directory) ||
3978 setup.internal.create_user_levelset);
3980 if (valid_entry_expected && !valid_entry_found)
3981 Warn("cannot find any valid level series in directory '%s'",
3985 boolean AdjustGraphicsForEMC(void)
3987 boolean settings_changed = FALSE;
3989 settings_changed |= adjustTreeGraphicsForEMC(leveldir_first_all);
3990 settings_changed |= adjustTreeGraphicsForEMC(leveldir_first);
3992 return settings_changed;
3995 boolean AdjustSoundsForEMC(void)
3997 boolean settings_changed = FALSE;
3999 settings_changed |= adjustTreeSoundsForEMC(leveldir_first_all);
4000 settings_changed |= adjustTreeSoundsForEMC(leveldir_first);
4002 return settings_changed;
4005 void LoadLevelInfo(void)
4007 InitUserLevelDirectory(getLoginName());
4009 DrawInitTextHead("Loading level series");
4011 LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
4012 LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL));
4014 leveldir_first = createTopTreeInfoNode(leveldir_first);
4016 /* after loading all level set information, clone the level directory tree
4017 and remove all level sets without levels (these may still contain artwork
4018 to be offered in the setup menu as "custom artwork", and are therefore
4019 checked for existing artwork in the function "LoadLevelArtworkInfo()") */
4020 leveldir_first_all = leveldir_first;
4021 cloneTree(&leveldir_first, leveldir_first_all, TRUE);
4023 AdjustGraphicsForEMC();
4024 AdjustSoundsForEMC();
4026 // before sorting, the first entries will be from the user directory
4027 leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
4029 if (leveldir_first == NULL)
4030 Fail("cannot find any valid level series in any directory");
4032 sortTreeInfo(&leveldir_first);
4034 #if ENABLE_UNUSED_CODE
4035 dumpTreeInfo(leveldir_first, 0);
4039 static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first,
4040 TreeInfo *node_parent,
4041 char *base_directory,
4042 char *directory_name, int type)
4044 char *directory_path = getPath2(base_directory, directory_name);
4045 char *filename = getPath2(directory_path, ARTWORKINFO_FILENAME(type));
4046 SetupFileHash *setup_file_hash = NULL;
4047 TreeInfo *artwork_new = NULL;
4050 if (fileExists(filename))
4051 setup_file_hash = loadSetupFileHash(filename);
4053 if (setup_file_hash == NULL) // no config file -- look for artwork files
4056 DirectoryEntry *dir_entry;
4057 boolean valid_file_found = FALSE;
4059 if ((dir = openDirectory(directory_path)) != NULL)
4061 while ((dir_entry = readDirectory(dir)) != NULL)
4063 if (FileIsArtworkType(dir_entry->filename, type))
4065 valid_file_found = TRUE;
4071 closeDirectory(dir);
4074 if (!valid_file_found)
4076 #if DEBUG_NO_CONFIG_FILE
4077 if (!strEqual(directory_name, "."))
4078 Debug("setup", "ignoring artwork directory '%s'", directory_path);
4081 free(directory_path);
4088 artwork_new = newTreeInfo();
4091 setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
4093 setTreeInfoToDefaults(artwork_new, type);
4095 artwork_new->subdir = getStringCopy(directory_name);
4097 if (setup_file_hash) // (before defining ".color" and ".class_desc")
4099 // set all structure fields according to the token/value pairs
4101 for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
4102 setSetupInfo(levelinfo_tokens, i,
4103 getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
4106 if (strEqual(artwork_new->name, ANONYMOUS_NAME))
4107 setString(&artwork_new->name, artwork_new->subdir);
4109 if (artwork_new->identifier == NULL)
4110 artwork_new->identifier = getStringCopy(artwork_new->subdir);
4112 if (artwork_new->name_sorting == NULL)
4113 artwork_new->name_sorting = getStringCopy(artwork_new->name);
4116 if (node_parent == NULL) // top level group
4118 artwork_new->basepath = getStringCopy(base_directory);
4119 artwork_new->fullpath = getStringCopy(artwork_new->subdir);
4121 else // sub level group
4123 artwork_new->basepath = getStringCopy(node_parent->basepath);
4124 artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name);
4127 artwork_new->in_user_dir =
4128 (!strEqual(artwork_new->basepath, OPTIONS_ARTWORK_DIRECTORY(type)));
4130 setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new));
4132 if (setup_file_hash == NULL) // (after determining ".user_defined")
4134 if (strEqual(artwork_new->subdir, "."))
4136 if (artwork_new->user_defined)
4138 setString(&artwork_new->identifier, "private");
4139 artwork_new->sort_priority = ARTWORKCLASS_PRIVATE;
4143 setString(&artwork_new->identifier, "classic");
4144 artwork_new->sort_priority = ARTWORKCLASS_CLASSICS;
4147 setString(&artwork_new->class_desc,
4148 getLevelClassDescription(artwork_new));
4152 setString(&artwork_new->identifier, artwork_new->subdir);
4155 setString(&artwork_new->name, artwork_new->identifier);
4156 setString(&artwork_new->name_sorting, artwork_new->name);
4159 pushTreeInfo(node_first, artwork_new);
4161 freeSetupFileHash(setup_file_hash);
4163 free(directory_path);
4169 static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first,
4170 TreeInfo *node_parent,
4171 char *base_directory, int type)
4173 // ---------- 1st stage: process any artwork set zip files ----------
4175 ProcessZipFilesInDirectory(base_directory, type);
4177 // ---------- 2nd stage: check for artwork set directories ----------
4180 DirectoryEntry *dir_entry;
4181 boolean valid_entry_found = FALSE;
4183 if ((dir = openDirectory(base_directory)) == NULL)
4185 // display error if directory is main "options.graphics_directory" etc.
4186 if (base_directory == OPTIONS_ARTWORK_DIRECTORY(type))
4187 Warn("cannot read directory '%s'", base_directory);
4192 while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
4194 char *directory_name = dir_entry->basename;
4195 char *directory_path = getPath2(base_directory, directory_name);
4197 // skip directory entries for current and parent directory
4198 if (strEqual(directory_name, ".") ||
4199 strEqual(directory_name, ".."))
4201 free(directory_path);
4206 // skip directory entries which are not a directory
4207 if (!dir_entry->is_directory) // not a directory
4209 free(directory_path);
4214 free(directory_path);
4216 // check if this directory contains artwork with or without config file
4217 valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
4219 directory_name, type);
4222 closeDirectory(dir);
4224 // check if this directory directly contains artwork itself
4225 valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent,
4226 base_directory, ".",
4228 if (!valid_entry_found)
4229 Warn("cannot find any valid artwork in directory '%s'", base_directory);
4232 static TreeInfo *getDummyArtworkInfo(int type)
4234 // this is only needed when there is completely no artwork available
4235 TreeInfo *artwork_new = newTreeInfo();
4237 setTreeInfoToDefaults(artwork_new, type);
4239 setString(&artwork_new->subdir, UNDEFINED_FILENAME);
4240 setString(&artwork_new->fullpath, UNDEFINED_FILENAME);
4241 setString(&artwork_new->basepath, UNDEFINED_FILENAME);
4243 setString(&artwork_new->identifier, UNDEFINED_FILENAME);
4244 setString(&artwork_new->name, UNDEFINED_FILENAME);
4245 setString(&artwork_new->name_sorting, UNDEFINED_FILENAME);
4250 void SetCurrentArtwork(int type)
4252 ArtworkDirTree **current_ptr = ARTWORK_CURRENT_PTR(artwork, type);
4253 ArtworkDirTree *first_node = ARTWORK_FIRST_NODE(artwork, type);
4254 char *setup_set = SETUP_ARTWORK_SET(setup, type);
4255 char *default_subdir = ARTWORK_DEFAULT_SUBDIR(type);
4257 // set current artwork to artwork configured in setup menu
4258 *current_ptr = getTreeInfoFromIdentifier(first_node, setup_set);
4260 // if not found, set current artwork to default artwork
4261 if (*current_ptr == NULL)
4262 *current_ptr = getTreeInfoFromIdentifier(first_node, default_subdir);
4264 // if not found, set current artwork to first artwork in tree
4265 if (*current_ptr == NULL)
4266 *current_ptr = getFirstValidTreeInfoEntry(first_node);
4269 void ChangeCurrentArtworkIfNeeded(int type)
4271 char *current_identifier = ARTWORK_CURRENT_IDENTIFIER(artwork, type);
4272 char *setup_set = SETUP_ARTWORK_SET(setup, type);
4274 if (!strEqual(current_identifier, setup_set))
4275 SetCurrentArtwork(type);
4278 void LoadArtworkInfo(void)
4280 LoadArtworkInfoCache();
4282 DrawInitTextHead("Looking for custom artwork");
4284 LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
4285 options.graphics_directory,
4286 TREE_TYPE_GRAPHICS_DIR);
4287 LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
4288 getUserGraphicsDir(),
4289 TREE_TYPE_GRAPHICS_DIR);
4291 LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
4292 options.sounds_directory,
4293 TREE_TYPE_SOUNDS_DIR);
4294 LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
4296 TREE_TYPE_SOUNDS_DIR);
4298 LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
4299 options.music_directory,
4300 TREE_TYPE_MUSIC_DIR);
4301 LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
4303 TREE_TYPE_MUSIC_DIR);
4305 if (artwork.gfx_first == NULL)
4306 artwork.gfx_first = getDummyArtworkInfo(TREE_TYPE_GRAPHICS_DIR);
4307 if (artwork.snd_first == NULL)
4308 artwork.snd_first = getDummyArtworkInfo(TREE_TYPE_SOUNDS_DIR);
4309 if (artwork.mus_first == NULL)
4310 artwork.mus_first = getDummyArtworkInfo(TREE_TYPE_MUSIC_DIR);
4312 // before sorting, the first entries will be from the user directory
4313 SetCurrentArtwork(ARTWORK_TYPE_GRAPHICS);
4314 SetCurrentArtwork(ARTWORK_TYPE_SOUNDS);
4315 SetCurrentArtwork(ARTWORK_TYPE_MUSIC);
4317 artwork.gfx_current_identifier = artwork.gfx_current->identifier;
4318 artwork.snd_current_identifier = artwork.snd_current->identifier;
4319 artwork.mus_current_identifier = artwork.mus_current->identifier;
4321 #if ENABLE_UNUSED_CODE
4322 Debug("setup:LoadArtworkInfo", "graphics set == %s",
4323 artwork.gfx_current_identifier);
4324 Debug("setup:LoadArtworkInfo", "sounds set == %s",
4325 artwork.snd_current_identifier);
4326 Debug("setup:LoadArtworkInfo", "music set == %s",
4327 artwork.mus_current_identifier);
4330 sortTreeInfo(&artwork.gfx_first);
4331 sortTreeInfo(&artwork.snd_first);
4332 sortTreeInfo(&artwork.mus_first);
4334 #if ENABLE_UNUSED_CODE
4335 dumpTreeInfo(artwork.gfx_first, 0);
4336 dumpTreeInfo(artwork.snd_first, 0);
4337 dumpTreeInfo(artwork.mus_first, 0);
4341 static void MoveArtworkInfoIntoSubTree(ArtworkDirTree **artwork_node)
4343 ArtworkDirTree *artwork_new = newTreeInfo();
4344 char *top_node_name = "standalone artwork";
4346 setTreeInfoToDefaults(artwork_new, (*artwork_node)->type);
4348 artwork_new->level_group = TRUE;
4350 setString(&artwork_new->identifier, top_node_name);
4351 setString(&artwork_new->name, top_node_name);
4352 setString(&artwork_new->name_sorting, top_node_name);
4354 // create node to link back to current custom artwork directory
4355 createParentTreeInfoNode(artwork_new);
4357 // move existing custom artwork tree into newly created sub-tree
4358 artwork_new->node_group->next = *artwork_node;
4360 // change custom artwork tree to contain only newly created node
4361 *artwork_node = artwork_new;
4364 static void LoadArtworkInfoFromLevelInfoExt(ArtworkDirTree **artwork_node,
4365 ArtworkDirTree *node_parent,
4366 LevelDirTree *level_node,
4367 boolean empty_level_set_mode)
4369 int type = (*artwork_node)->type;
4371 // recursively check all level directories for artwork sub-directories
4375 boolean empty_level_set = (level_node->levels == 0);
4377 // check all tree entries for artwork, but skip parent link entries
4378 if (!level_node->parent_link && empty_level_set == empty_level_set_mode)
4380 TreeInfo *artwork_new = getArtworkInfoCacheEntry(level_node, type);
4381 boolean cached = (artwork_new != NULL);
4385 pushTreeInfo(artwork_node, artwork_new);
4389 TreeInfo *topnode_last = *artwork_node;
4390 char *path = getPath2(getLevelDirFromTreeInfo(level_node),
4391 ARTWORK_DIRECTORY(type));
4393 LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path, type);
4395 if (topnode_last != *artwork_node) // check for newly added node
4397 artwork_new = *artwork_node;
4399 setString(&artwork_new->identifier, level_node->subdir);
4400 setString(&artwork_new->name, level_node->name);
4401 setString(&artwork_new->name_sorting, level_node->name_sorting);
4403 artwork_new->sort_priority = level_node->sort_priority;
4404 artwork_new->in_user_dir = level_node->in_user_dir;
4406 update_artworkinfo_cache = TRUE;
4412 // insert artwork info (from old cache or filesystem) into new cache
4413 if (artwork_new != NULL)
4414 setArtworkInfoCacheEntry(artwork_new, level_node, type);
4417 DrawInitTextItem(level_node->name);
4419 if (level_node->node_group != NULL)
4421 TreeInfo *artwork_new = newTreeInfo();
4424 setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
4426 setTreeInfoToDefaults(artwork_new, type);
4428 artwork_new->level_group = TRUE;
4430 setString(&artwork_new->identifier, level_node->subdir);
4432 if (node_parent == NULL) // check for top tree node
4434 char *top_node_name = (empty_level_set_mode ?
4435 "artwork for certain level sets" :
4436 "artwork included in level sets");
4438 setString(&artwork_new->name, top_node_name);
4439 setString(&artwork_new->name_sorting, top_node_name);
4443 setString(&artwork_new->name, level_node->name);
4444 setString(&artwork_new->name_sorting, level_node->name_sorting);
4447 pushTreeInfo(artwork_node, artwork_new);
4449 // create node to link back to current custom artwork directory
4450 createParentTreeInfoNode(artwork_new);
4452 // recursively step into sub-directory and look for more custom artwork
4453 LoadArtworkInfoFromLevelInfoExt(&artwork_new->node_group, artwork_new,
4454 level_node->node_group,
4455 empty_level_set_mode);
4457 // if sub-tree has no custom artwork at all, remove it
4458 if (artwork_new->node_group->next == NULL)
4459 removeTreeInfo(artwork_node);
4462 level_node = level_node->next;
4466 static void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node)
4468 // move peviously loaded artwork tree into separate sub-tree
4469 MoveArtworkInfoIntoSubTree(artwork_node);
4471 // load artwork from level sets into separate sub-trees
4472 LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, TRUE);
4473 LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, FALSE);
4475 // add top tree node over all sub-trees and set parent links
4476 *artwork_node = addTopTreeInfoNode(*artwork_node);
4479 void LoadLevelArtworkInfo(void)
4481 print_timestamp_init("LoadLevelArtworkInfo");
4483 DrawInitTextHead("Looking for custom level artwork");
4485 print_timestamp_time("DrawTimeText");
4487 LoadArtworkInfoFromLevelInfo(&artwork.gfx_first);
4488 print_timestamp_time("LoadArtworkInfoFromLevelInfo (gfx)");
4489 LoadArtworkInfoFromLevelInfo(&artwork.snd_first);
4490 print_timestamp_time("LoadArtworkInfoFromLevelInfo (snd)");
4491 LoadArtworkInfoFromLevelInfo(&artwork.mus_first);
4492 print_timestamp_time("LoadArtworkInfoFromLevelInfo (mus)");
4494 SaveArtworkInfoCache();
4496 print_timestamp_time("SaveArtworkInfoCache");
4498 // needed for reloading level artwork not known at ealier stage
4499 ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_GRAPHICS);
4500 ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_SOUNDS);
4501 ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_MUSIC);
4503 print_timestamp_time("getTreeInfoFromIdentifier");
4505 sortTreeInfo(&artwork.gfx_first);
4506 sortTreeInfo(&artwork.snd_first);
4507 sortTreeInfo(&artwork.mus_first);
4509 print_timestamp_time("sortTreeInfo");
4511 #if ENABLE_UNUSED_CODE
4512 dumpTreeInfo(artwork.gfx_first, 0);
4513 dumpTreeInfo(artwork.snd_first, 0);
4514 dumpTreeInfo(artwork.mus_first, 0);
4517 print_timestamp_done("LoadLevelArtworkInfo");
4520 static boolean AddTreeSetToTreeInfoExt(TreeInfo *tree_node_old, char *tree_dir,
4521 char *tree_subdir_new, int type)
4523 if (tree_node_old == NULL)
4525 if (type == TREE_TYPE_LEVEL_DIR)
4527 // get level info tree node of personal user level set
4528 tree_node_old = getTreeInfoFromIdentifier(leveldir_first, getLoginName());
4530 // this may happen if "setup.internal.create_user_levelset" is FALSE
4531 // or if file "levelinfo.conf" is missing in personal user level set
4532 if (tree_node_old == NULL)
4533 tree_node_old = leveldir_first->node_group;
4537 // get artwork info tree node of first artwork set
4538 tree_node_old = ARTWORK_FIRST_NODE(artwork, type);
4542 if (tree_dir == NULL)
4543 tree_dir = TREE_USERDIR(type);
4545 if (tree_node_old == NULL ||
4547 tree_subdir_new == NULL) // should not happen
4550 int draw_deactivation_mask = GetDrawDeactivationMask();
4552 // override draw deactivation mask (temporarily disable drawing)
4553 SetDrawDeactivationMask(REDRAW_ALL);
4555 if (type == TREE_TYPE_LEVEL_DIR)
4557 // load new level set config and add it next to first user level set
4558 LoadLevelInfoFromLevelConf(&tree_node_old->next,
4559 tree_node_old->node_parent,
4560 tree_dir, tree_subdir_new);
4564 // load new artwork set config and add it next to first artwork set
4565 LoadArtworkInfoFromArtworkConf(&tree_node_old->next,
4566 tree_node_old->node_parent,
4567 tree_dir, tree_subdir_new, type);
4570 // set draw deactivation mask to previous value
4571 SetDrawDeactivationMask(draw_deactivation_mask);
4573 // get first node of level or artwork info tree
4574 TreeInfo **tree_node_first = TREE_FIRST_NODE_PTR(type);
4576 // get tree info node of newly added level or artwork set
4577 TreeInfo *tree_node_new = getTreeInfoFromIdentifier(*tree_node_first,
4580 if (tree_node_new == NULL) // should not happen
4583 // correct top link and parent node link of newly created tree node
4584 tree_node_new->node_top = tree_node_old->node_top;
4585 tree_node_new->node_parent = tree_node_old->node_parent;
4587 // sort tree info to adjust position of newly added tree set
4588 sortTreeInfo(tree_node_first);
4593 void AddTreeSetToTreeInfo(TreeInfo *tree_node, char *tree_dir,
4594 char *tree_subdir_new, int type)
4596 if (!AddTreeSetToTreeInfoExt(tree_node, tree_dir, tree_subdir_new, type))
4597 Fail("internal tree info structure corrupted -- aborting");
4600 void AddUserLevelSetToLevelInfo(char *level_subdir_new)
4602 AddTreeSetToTreeInfo(NULL, NULL, level_subdir_new, TREE_TYPE_LEVEL_DIR);
4605 char *getArtworkIdentifierForUserLevelSet(int type)
4607 char *classic_artwork_set = getClassicArtworkSet(type);
4609 // check for custom artwork configured in "levelinfo.conf"
4610 char *leveldir_artwork_set =
4611 *LEVELDIR_ARTWORK_SET_PTR(leveldir_current, type);
4612 boolean has_leveldir_artwork_set =
4613 (leveldir_artwork_set != NULL && !strEqual(leveldir_artwork_set,
4614 classic_artwork_set));
4616 // check for custom artwork in sub-directory "graphics" etc.
4617 TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
4618 char *leveldir_identifier = leveldir_current->identifier;
4619 boolean has_artwork_subdir =
4620 (getTreeInfoFromIdentifier(artwork_first_node,
4621 leveldir_identifier) != NULL);
4623 return (has_leveldir_artwork_set ? leveldir_artwork_set :
4624 has_artwork_subdir ? leveldir_identifier :
4625 classic_artwork_set);
4628 TreeInfo *getArtworkTreeInfoForUserLevelSet(int type)
4630 char *artwork_set = getArtworkIdentifierForUserLevelSet(type);
4631 TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
4632 TreeInfo *ti = getTreeInfoFromIdentifier(artwork_first_node, artwork_set);
4636 ti = getTreeInfoFromIdentifier(artwork_first_node,
4637 ARTWORK_DEFAULT_SUBDIR(type));
4639 Fail("cannot find default graphics -- should not happen");
4645 boolean checkIfCustomArtworkExistsForCurrentLevelSet(void)
4647 char *graphics_set =
4648 getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
4650 getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_SOUNDS);
4652 getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_MUSIC);
4654 return (!strEqual(graphics_set, GFX_CLASSIC_SUBDIR) ||
4655 !strEqual(sounds_set, SND_CLASSIC_SUBDIR) ||
4656 !strEqual(music_set, MUS_CLASSIC_SUBDIR));
4659 boolean UpdateUserLevelSet(char *level_subdir, char *level_name,
4660 char *level_author, int num_levels)
4662 char *filename = getPath2(getUserLevelDir(level_subdir), LEVELINFO_FILENAME);
4663 char *filename_tmp = getStringCat2(filename, ".tmp");
4665 FILE *file_tmp = NULL;
4666 char line[MAX_LINE_LEN];
4667 boolean success = FALSE;
4668 LevelDirTree *leveldir = getTreeInfoFromIdentifier(leveldir_first,
4670 // update values in level directory tree
4672 if (level_name != NULL)
4673 setString(&leveldir->name, level_name);
4675 if (level_author != NULL)
4676 setString(&leveldir->author, level_author);
4678 if (num_levels != -1)
4679 leveldir->levels = num_levels;
4681 // update values that depend on other values
4683 setString(&leveldir->name_sorting, leveldir->name);
4685 leveldir->last_level = leveldir->first_level + leveldir->levels - 1;
4687 // sort order of level sets may have changed
4688 sortTreeInfo(&leveldir_first);
4690 if ((file = fopen(filename, MODE_READ)) &&
4691 (file_tmp = fopen(filename_tmp, MODE_WRITE)))
4693 while (fgets(line, MAX_LINE_LEN, file))
4695 if (strPrefix(line, "name:") && level_name != NULL)
4696 fprintf(file_tmp, "%-32s%s\n", "name:", level_name);
4697 else if (strPrefix(line, "author:") && level_author != NULL)
4698 fprintf(file_tmp, "%-32s%s\n", "author:", level_author);
4699 else if (strPrefix(line, "levels:") && num_levels != -1)
4700 fprintf(file_tmp, "%-32s%d\n", "levels:", num_levels);
4702 fputs(line, file_tmp);
4715 success = (rename(filename_tmp, filename) == 0);
4723 boolean CreateUserLevelSet(char *level_subdir, char *level_name,
4724 char *level_author, int num_levels,
4725 boolean use_artwork_set)
4727 LevelDirTree *level_info;
4732 // create user level sub-directory, if needed
4733 createDirectory(getUserLevelDir(level_subdir), "user level");
4735 filename = getPath2(getUserLevelDir(level_subdir), LEVELINFO_FILENAME);
4737 if (!(file = fopen(filename, MODE_WRITE)))
4739 Warn("cannot write level info file '%s'", filename);
4746 level_info = newTreeInfo();
4748 // always start with reliable default values
4749 setTreeInfoToDefaults(level_info, TREE_TYPE_LEVEL_DIR);
4751 setString(&level_info->name, level_name);
4752 setString(&level_info->author, level_author);
4753 level_info->levels = num_levels;
4754 level_info->first_level = 1;
4755 level_info->sort_priority = LEVELCLASS_PRIVATE_START;
4756 level_info->readonly = FALSE;
4758 if (use_artwork_set)
4760 level_info->graphics_set =
4761 getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS));
4762 level_info->sounds_set =
4763 getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_SOUNDS));
4764 level_info->music_set =
4765 getStringCopy(getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_MUSIC));
4768 token_value_position = TOKEN_VALUE_POSITION_SHORT;
4770 fprintFileHeader(file, LEVELINFO_FILENAME);
4773 for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
4775 if (i == LEVELINFO_TOKEN_NAME ||
4776 i == LEVELINFO_TOKEN_AUTHOR ||
4777 i == LEVELINFO_TOKEN_LEVELS ||
4778 i == LEVELINFO_TOKEN_FIRST_LEVEL ||
4779 i == LEVELINFO_TOKEN_SORT_PRIORITY ||
4780 i == LEVELINFO_TOKEN_READONLY ||
4781 (use_artwork_set && (i == LEVELINFO_TOKEN_GRAPHICS_SET ||
4782 i == LEVELINFO_TOKEN_SOUNDS_SET ||
4783 i == LEVELINFO_TOKEN_MUSIC_SET)))
4784 fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
4786 // just to make things nicer :)
4787 if (i == LEVELINFO_TOKEN_AUTHOR ||
4788 i == LEVELINFO_TOKEN_FIRST_LEVEL ||
4789 (use_artwork_set && i == LEVELINFO_TOKEN_READONLY))
4790 fprintf(file, "\n");
4793 token_value_position = TOKEN_VALUE_POSITION_DEFAULT;
4797 SetFilePermissions(filename, PERMS_PRIVATE);
4799 freeTreeInfo(level_info);
4805 static void SaveUserLevelInfo(void)
4807 CreateUserLevelSet(getLoginName(), getLoginName(), getRealName(), 100, FALSE);
4810 char *getSetupValue(int type, void *value)
4812 static char value_string[MAX_LINE_LEN];
4820 strcpy(value_string, (*(boolean *)value ? "true" : "false"));
4824 strcpy(value_string, (*(boolean *)value ? "on" : "off"));
4828 strcpy(value_string, (*(int *)value == AUTO ? "auto" :
4829 *(int *)value == FALSE ? "off" : "on"));
4833 strcpy(value_string, (*(boolean *)value ? "yes" : "no"));
4836 case TYPE_YES_NO_AUTO:
4837 strcpy(value_string, (*(int *)value == AUTO ? "auto" :
4838 *(int *)value == FALSE ? "no" : "yes"));
4842 strcpy(value_string, (*(boolean *)value ? "AGA" : "ECS"));
4846 strcpy(value_string, getKeyNameFromKey(*(Key *)value));
4850 strcpy(value_string, getX11KeyNameFromKey(*(Key *)value));
4854 sprintf(value_string, "%d", *(int *)value);
4858 if (*(char **)value == NULL)
4861 strcpy(value_string, *(char **)value);
4865 sprintf(value_string, "player_%d", *(int *)value + 1);
4869 value_string[0] = '\0';
4873 if (type & TYPE_GHOSTED)
4874 strcpy(value_string, "n/a");
4876 return value_string;
4879 char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
4883 static char token_string[MAX_LINE_LEN];
4884 int token_type = token_info[token_nr].type;
4885 void *setup_value = token_info[token_nr].value;
4886 char *token_text = token_info[token_nr].text;
4887 char *value_string = getSetupValue(token_type, setup_value);
4889 // build complete token string
4890 sprintf(token_string, "%s%s", prefix, token_text);
4892 // build setup entry line
4893 line = getFormattedSetupEntry(token_string, value_string);
4895 if (token_type == TYPE_KEY_X11)
4897 Key key = *(Key *)setup_value;
4898 char *keyname = getKeyNameFromKey(key);
4900 // add comment, if useful
4901 if (!strEqual(keyname, "(undefined)") &&
4902 !strEqual(keyname, "(unknown)"))
4904 // add at least one whitespace
4906 for (i = strlen(line); i < token_comment_position; i++)
4910 strcat(line, keyname);
4917 static void InitLastPlayedLevels_ParentNode(void)
4919 LevelDirTree **leveldir_top = &leveldir_first->node_group->next;
4920 LevelDirTree *leveldir_new = NULL;
4922 // check if parent node for last played levels already exists
4923 if (strEqual((*leveldir_top)->identifier, TOKEN_STR_LAST_LEVEL_SERIES))
4926 leveldir_new = newTreeInfo();
4928 setTreeInfoToDefaultsFromParent(leveldir_new, leveldir_first);
4930 leveldir_new->level_group = TRUE;
4931 leveldir_new->sort_priority = LEVELCLASS_LAST_PLAYED_LEVEL;
4933 setString(&leveldir_new->identifier, TOKEN_STR_LAST_LEVEL_SERIES);
4934 setString(&leveldir_new->name, "<< (last played level sets)");
4935 setString(&leveldir_new->name_sorting, leveldir_new->name);
4937 pushTreeInfo(leveldir_top, leveldir_new);
4939 // create node to link back to current level directory
4940 createParentTreeInfoNode(leveldir_new);
4943 void UpdateLastPlayedLevels_TreeInfo(void)
4945 char **last_level_series = setup.level_setup.last_level_series;
4946 LevelDirTree *leveldir_last;
4947 TreeInfo **node_new = NULL;
4950 if (last_level_series[0] == NULL)
4953 InitLastPlayedLevels_ParentNode();
4955 leveldir_last = getTreeInfoFromIdentifierExt(leveldir_first,
4956 TOKEN_STR_LAST_LEVEL_SERIES,
4957 TREE_NODE_TYPE_GROUP);
4958 if (leveldir_last == NULL)
4961 node_new = &leveldir_last->node_group->next;
4963 freeTreeInfo(*node_new);
4967 for (i = 0; last_level_series[i] != NULL; i++)
4969 LevelDirTree *node_last = getTreeInfoFromIdentifier(leveldir_first,
4970 last_level_series[i]);
4971 if (node_last == NULL)
4974 *node_new = getTreeInfoCopy(node_last); // copy complete node
4976 (*node_new)->node_top = &leveldir_first; // correct top node link
4977 (*node_new)->node_parent = leveldir_last; // correct parent node link
4979 (*node_new)->is_copy = TRUE; // mark entry as node copy
4981 (*node_new)->node_group = NULL;
4982 (*node_new)->next = NULL;
4984 (*node_new)->cl_first = -1; // force setting tree cursor
4986 node_new = &((*node_new)->next);
4990 static void UpdateLastPlayedLevels_List(void)
4992 char **last_level_series = setup.level_setup.last_level_series;
4993 int pos = MAX_LEVELDIR_HISTORY - 1;
4996 // search for potentially already existing entry in list of level sets
4997 for (i = 0; last_level_series[i] != NULL; i++)
4998 if (strEqual(last_level_series[i], leveldir_current->identifier))
5001 // move list of level sets one entry down (using potentially free entry)
5002 for (i = pos; i > 0; i--)
5003 setString(&last_level_series[i], last_level_series[i - 1]);
5005 // put last played level set at top position
5006 setString(&last_level_series[0], leveldir_current->identifier);
5009 static TreeInfo *StoreOrRestoreLastPlayedLevels(TreeInfo *node, boolean store)
5011 static char *identifier = NULL;
5015 setString(&identifier, (node && node->is_copy ? node->identifier : NULL));
5017 return NULL; // not used
5021 TreeInfo *node_new = getTreeInfoFromIdentifierExt(leveldir_first,
5023 TREE_NODE_TYPE_COPY);
5024 return (node_new != NULL ? node_new : node);
5028 void StoreLastPlayedLevels(TreeInfo *node)
5030 StoreOrRestoreLastPlayedLevels(node, TRUE);
5033 void RestoreLastPlayedLevels(TreeInfo **node)
5035 *node = StoreOrRestoreLastPlayedLevels(*node, FALSE);
5038 void LoadLevelSetup_LastSeries(void)
5040 // --------------------------------------------------------------------------
5041 // ~/.<program>/levelsetup.conf
5042 // --------------------------------------------------------------------------
5044 char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
5045 SetupFileHash *level_setup_hash = NULL;
5049 // always start with reliable default values
5050 leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
5052 // start with empty history of last played level sets
5053 setString(&setup.level_setup.last_level_series[0], NULL);
5055 if (!strEqual(DEFAULT_LEVELSET, UNDEFINED_LEVELSET))
5057 leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
5059 if (leveldir_current == NULL)
5060 leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
5063 if ((level_setup_hash = loadSetupFileHash(filename)))
5065 char *last_level_series =
5066 getHashEntry(level_setup_hash, TOKEN_STR_LAST_LEVEL_SERIES);
5068 leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
5070 if (leveldir_current == NULL)
5071 leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
5073 for (i = 0; i < MAX_LEVELDIR_HISTORY; i++)
5075 char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
5076 LevelDirTree *leveldir_last;
5078 sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
5080 last_level_series = getHashEntry(level_setup_hash, token);
5082 leveldir_last = getTreeInfoFromIdentifier(leveldir_first,
5084 if (leveldir_last != NULL)
5085 setString(&setup.level_setup.last_level_series[pos++],
5089 setString(&setup.level_setup.last_level_series[pos], NULL);
5091 freeSetupFileHash(level_setup_hash);
5095 Debug("setup", "using default setup values");
5101 static void SaveLevelSetup_LastSeries_Ext(boolean deactivate_last_level_series)
5103 // --------------------------------------------------------------------------
5104 // ~/.<program>/levelsetup.conf
5105 // --------------------------------------------------------------------------
5107 // check if the current level directory structure is available at this point
5108 if (leveldir_current == NULL)
5111 char **last_level_series = setup.level_setup.last_level_series;
5112 char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
5116 InitUserDataDirectory();
5118 UpdateLastPlayedLevels_List();
5120 if (!(file = fopen(filename, MODE_WRITE)))
5122 Warn("cannot write setup file '%s'", filename);
5129 fprintFileHeader(file, LEVELSETUP_FILENAME);
5131 if (deactivate_last_level_series)
5132 fprintf(file, "# %s\n# ", "the following level set may have caused a problem and was deactivated");
5134 fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES,
5135 leveldir_current->identifier));
5137 for (i = 0; last_level_series[i] != NULL; i++)
5139 char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 1 + 10 + 1];
5141 sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
5143 fprintf(file, "%s\n", getFormattedSetupEntry(token, last_level_series[i]));
5148 SetFilePermissions(filename, PERMS_PRIVATE);
5153 void SaveLevelSetup_LastSeries(void)
5155 SaveLevelSetup_LastSeries_Ext(FALSE);
5158 void SaveLevelSetup_LastSeries_Deactivate(void)
5160 SaveLevelSetup_LastSeries_Ext(TRUE);
5163 static void checkSeriesInfo(void)
5165 static char *level_directory = NULL;
5168 DirectoryEntry *dir_entry;
5171 checked_free(level_directory);
5173 // check for more levels besides the 'levels' field of 'levelinfo.conf'
5175 level_directory = getPath2((leveldir_current->in_user_dir ?
5176 getUserLevelDir(NULL) :
5177 options.level_directory),
5178 leveldir_current->fullpath);
5180 if ((dir = openDirectory(level_directory)) == NULL)
5182 Warn("cannot read level directory '%s'", level_directory);
5188 while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
5190 if (strlen(dir_entry->basename) > 4 &&
5191 dir_entry->basename[3] == '.' &&
5192 strEqual(&dir_entry->basename[4], LEVELFILE_EXTENSION))
5194 char levelnum_str[4];
5197 strncpy(levelnum_str, dir_entry->basename, 3);
5198 levelnum_str[3] = '\0';
5200 levelnum_value = atoi(levelnum_str);
5202 if (levelnum_value < leveldir_current->first_level)
5204 Warn("additional level %d found", levelnum_value);
5206 leveldir_current->first_level = levelnum_value;
5208 else if (levelnum_value > leveldir_current->last_level)
5210 Warn("additional level %d found", levelnum_value);
5212 leveldir_current->last_level = levelnum_value;
5218 closeDirectory(dir);
5221 void LoadLevelSetup_SeriesInfo(void)
5224 SetupFileHash *level_setup_hash = NULL;
5225 char *level_subdir = leveldir_current->subdir;
5228 // always start with reliable default values
5229 level_nr = leveldir_current->first_level;
5231 for (i = 0; i < MAX_LEVELS; i++)
5233 LevelStats_setPlayed(i, 0);
5234 LevelStats_setSolved(i, 0);
5239 // --------------------------------------------------------------------------
5240 // ~/.<program>/levelsetup/<level series>/levelsetup.conf
5241 // --------------------------------------------------------------------------
5243 level_subdir = leveldir_current->subdir;
5245 filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
5247 if ((level_setup_hash = loadSetupFileHash(filename)))
5251 // get last played level in this level set
5253 token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL);
5257 level_nr = atoi(token_value);
5259 if (level_nr < leveldir_current->first_level)
5260 level_nr = leveldir_current->first_level;
5261 if (level_nr > leveldir_current->last_level)
5262 level_nr = leveldir_current->last_level;
5265 // get handicap level in this level set
5267 token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL);
5271 int level_nr = atoi(token_value);
5273 if (level_nr < leveldir_current->first_level)
5274 level_nr = leveldir_current->first_level;
5275 if (level_nr > leveldir_current->last_level + 1)
5276 level_nr = leveldir_current->last_level;
5278 if (leveldir_current->user_defined || !leveldir_current->handicap)
5279 level_nr = leveldir_current->last_level;
5281 leveldir_current->handicap_level = level_nr;
5284 // get number of played and solved levels in this level set
5286 BEGIN_HASH_ITERATION(level_setup_hash, itr)
5288 char *token = HASH_ITERATION_TOKEN(itr);
5289 char *value = HASH_ITERATION_VALUE(itr);
5291 if (strlen(token) == 3 &&
5292 token[0] >= '0' && token[0] <= '9' &&
5293 token[1] >= '0' && token[1] <= '9' &&
5294 token[2] >= '0' && token[2] <= '9')
5296 int level_nr = atoi(token);
5299 LevelStats_setPlayed(level_nr, atoi(value)); // read 1st column
5301 value = strchr(value, ' ');
5304 LevelStats_setSolved(level_nr, atoi(value)); // read 2nd column
5307 END_HASH_ITERATION(hash, itr)
5309 freeSetupFileHash(level_setup_hash);
5313 Debug("setup", "using default setup values");
5319 void SaveLevelSetup_SeriesInfo(void)
5322 char *level_subdir = leveldir_current->subdir;
5323 char *level_nr_str = int2str(level_nr, 0);
5324 char *handicap_level_str = int2str(leveldir_current->handicap_level, 0);
5328 // --------------------------------------------------------------------------
5329 // ~/.<program>/levelsetup/<level series>/levelsetup.conf
5330 // --------------------------------------------------------------------------
5332 InitLevelSetupDirectory(level_subdir);
5334 filename = getPath2(getLevelSetupDir(level_subdir), LEVELSETUP_FILENAME);
5336 if (!(file = fopen(filename, MODE_WRITE)))
5338 Warn("cannot write setup file '%s'", filename);
5345 fprintFileHeader(file, LEVELSETUP_FILENAME);
5347 fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_PLAYED_LEVEL,
5349 fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL,
5350 handicap_level_str));
5352 for (i = leveldir_current->first_level; i <= leveldir_current->last_level;
5355 if (LevelStats_getPlayed(i) > 0 ||
5356 LevelStats_getSolved(i) > 0)
5361 sprintf(token, "%03d", i);
5362 sprintf(value, "%d %d", LevelStats_getPlayed(i), LevelStats_getSolved(i));
5364 fprintf(file, "%s\n", getFormattedSetupEntry(token, value));
5370 SetFilePermissions(filename, PERMS_PRIVATE);
5375 int LevelStats_getPlayed(int nr)
5377 return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].played : 0);
5380 int LevelStats_getSolved(int nr)
5382 return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].solved : 0);
5385 void LevelStats_setPlayed(int nr, int value)
5387 if (nr >= 0 && nr < MAX_LEVELS)
5388 level_stats[nr].played = value;
5391 void LevelStats_setSolved(int nr, int value)
5393 if (nr >= 0 && nr < MAX_LEVELS)
5394 level_stats[nr].solved = value;
5397 void LevelStats_incPlayed(int nr)
5399 if (nr >= 0 && nr < MAX_LEVELS)
5400 level_stats[nr].played++;
5403 void LevelStats_incSolved(int nr)
5405 if (nr >= 0 && nr < MAX_LEVELS)
5406 level_stats[nr].solved++;
5409 void LoadUserSetup(void)
5411 // --------------------------------------------------------------------------
5412 // ~/.<program>/usersetup.conf
5413 // --------------------------------------------------------------------------
5415 char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
5416 SetupFileHash *user_setup_hash = NULL;
5418 // always start with reliable default values
5421 if ((user_setup_hash = loadSetupFileHash(filename)))
5425 // get last selected user number
5426 token_value = getHashEntry(user_setup_hash, TOKEN_STR_LAST_USER);
5429 user.nr = MIN(MAX(0, atoi(token_value)), MAX_PLAYER_NAMES - 1);
5431 freeSetupFileHash(user_setup_hash);
5435 Debug("setup", "using default setup values");
5441 void SaveUserSetup(void)
5443 // --------------------------------------------------------------------------
5444 // ~/.<program>/usersetup.conf
5445 // --------------------------------------------------------------------------
5447 char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
5450 InitMainUserDataDirectory();
5452 if (!(file = fopen(filename, MODE_WRITE)))
5454 Warn("cannot write setup file '%s'", filename);
5461 fprintFileHeader(file, USERSETUP_FILENAME);
5463 fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_USER,
5467 SetFilePermissions(filename, PERMS_PRIVATE);