X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fsetup.c;h=df1dac7b45043d99c7c8ff48c3ab2ecfbbb90b1a;hb=bca0a1d2e0c7d05f0dfb1d1c62c85715c63652ba;hp=ff8485bce818df7358ea49379fc43503cae5a7da;hpb=e05dda5c8cc6687dcbc59e182a81aed627e262d0;p=rocksndiamonds.git diff --git a/src/libgame/setup.c b/src/libgame/setup.c index ff8485bc..df1dac7b 100644 --- a/src/libgame/setup.c +++ b/src/libgame/setup.c @@ -86,12 +86,18 @@ static char *levelclass_desc[NUM_LEVELCLASS_DESC] = #define MAX_COOKIE_LEN 256 + static void setTreeInfoToDefaults(TreeInfo *, int); +static TreeInfo *getTreeInfoCopy(TreeInfo *ti); static int compareTreeInfoEntries(const void *, const void *); static int token_value_position = TOKEN_VALUE_POSITION_DEFAULT; static int token_comment_position = TOKEN_COMMENT_POSITION_DEFAULT; +static SetupFileHash *artworkinfo_cache_old = NULL; +static SetupFileHash *artworkinfo_cache_new = NULL; +static boolean use_artworkinfo_cache = TRUE; + /* ------------------------------------------------------------------------- */ /* file functions */ @@ -155,6 +161,16 @@ static char *getLevelSetupDir(char *level_subdir) return levelsetup_dir; } +static char *getCacheDir() +{ + static char *cache_dir = NULL; + + if (cache_dir == NULL) + cache_dir = getPath2(getUserGameDataDir(), CACHE_DIRECTORY); + + return cache_dir; +} + static char *getLevelDirFromTreeInfo(TreeInfo *node) { static char *level_dir = NULL; @@ -246,6 +262,26 @@ static char *getDefaultMusicDir(char *music_subdir) return music_dir; } +#if 1 +static char *getDefaultArtworkSet(int type) +{ + return (type == TREE_TYPE_GRAPHICS_DIR ? "gfx_classic" : + type == TREE_TYPE_SOUNDS_DIR ? "snd_classic" : + type == TREE_TYPE_MUSIC_DIR ? "mus_classic" : ""); +} + +static char *getDefaultArtworkDir(int type) +{ + return (type == TREE_TYPE_GRAPHICS_DIR ? + getDefaultGraphicsDir("gfx_classic") : + type == TREE_TYPE_SOUNDS_DIR ? + getDefaultSoundsDir("snd_classic") : + type == TREE_TYPE_MUSIC_DIR ? + getDefaultMusicDir("mus_classic") : ""); +} + +#else + static char *getDefaultArtworkSet(int type) { return (type == TREE_TYPE_GRAPHICS_DIR ? GFX_CLASSIC_SUBDIR : @@ -262,6 +298,7 @@ static char *getDefaultArtworkDir(int type) type == TREE_TYPE_MUSIC_DIR ? getDefaultMusicDir(MUS_CLASSIC_SUBDIR) : ""); } +#endif static char *getUserGraphicsDir() { @@ -482,6 +519,82 @@ char *getLevelSetInfoFilename() return NULL; } +char *getLevelSetTitleMessageBasename(int nr, boolean initial) +{ + static char basename[32]; + + sprintf(basename, "%s_%d.txt", + (initial ? "titlemessage_initial" : "titlemessage"), nr + 1); + + return basename; +} + +char *getLevelSetTitleMessageFilename(int nr, boolean initial) +{ + static char *filename = NULL; + char *basename; + boolean skip_setup_artwork = FALSE; + + checked_free(filename); + + basename = getLevelSetTitleMessageBasename(nr, initial); + + if (!gfx.override_level_graphics) + { + /* 1st try: look for special artwork in current level series directory */ + filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename); + if (fileExists(filename)) + return filename; + + free(filename); + + /* 2nd try: look for message file in current level set directory */ + filename = getPath2(getCurrentLevelDir(), basename); + if (fileExists(filename)) + return filename; + + free(filename); + + /* check if there is special artwork configured in level series config */ + if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL) + { + /* 3rd try: look for special artwork configured in level series config */ + filename = getPath2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename); + if (fileExists(filename)) + return filename; + + free(filename); + + /* take missing artwork configured in level set config from default */ + skip_setup_artwork = TRUE; + } + } + + if (!skip_setup_artwork) + { + /* 4th try: look for special artwork in configured artwork directory */ + filename = getPath2(getSetupArtworkDir(artwork.gfx_current), basename); + if (fileExists(filename)) + return filename; + + free(filename); + } + + /* 5th try: look for default artwork in new default artwork directory */ + filename = getPath2(getDefaultGraphicsDir(GFX_CLASSIC_SUBDIR), basename); + if (fileExists(filename)) + return filename; + + free(filename); + + /* 6th try: look for default artwork in old default artwork directory */ + filename = getPath2(options.graphics_directory, basename); + if (fileExists(filename)) + return filename; + + return NULL; /* cannot find specified artwork file anywhere */ +} + static char *getCorrectedArtworkBasename(char *basename) { char *basename_corrected = basename; @@ -523,7 +636,7 @@ char *getCustomImageFilename(char *basename) basename = getCorrectedArtworkBasename(basename); - if (!setup.override_level_graphics) + if (!gfx.override_level_graphics) { /* 1st try: look for special artwork in current level series directory */ filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename); @@ -569,6 +682,21 @@ char *getCustomImageFilename(char *basename) if (fileExists(filename)) return filename; +#if CREATE_SPECIAL_EDITION + free(filename); + + /* !!! INSERT WARNING HERE TO REPORT MISSING ARTWORK FILES !!! */ +#if 0 + printf("::: MISSING ARTWORK FILE '%s'\n", basename); +#endif + + /* 6th try: look for fallback artwork in old default artwork directory */ + /* (needed to prevent errors when trying to access unused artwork files) */ + filename = getPath2(options.graphics_directory, GFX_FALLBACK_FILENAME); + if (fileExists(filename)) + return filename; +#endif + return NULL; /* cannot find specified artwork file anywhere */ } @@ -581,7 +709,7 @@ char *getCustomSoundFilename(char *basename) basename = getCorrectedArtworkBasename(basename); - if (!setup.override_level_sounds) + if (!gfx.override_level_sounds) { /* 1st try: look for special artwork in current level series directory */ filename = getPath3(getCurrentLevelDir(), SOUNDS_DIRECTORY, basename); @@ -627,6 +755,16 @@ char *getCustomSoundFilename(char *basename) if (fileExists(filename)) return filename; +#if CREATE_SPECIAL_EDITION + free(filename); + + /* 6th try: look for fallback artwork in old default artwork directory */ + /* (needed to prevent errors when trying to access unused artwork files) */ + filename = getPath2(options.sounds_directory, SND_FALLBACK_FILENAME); + if (fileExists(filename)) + return filename; +#endif + return NULL; /* cannot find specified artwork file anywhere */ } @@ -639,7 +777,7 @@ char *getCustomMusicFilename(char *basename) basename = getCorrectedArtworkBasename(basename); - if (!setup.override_level_music) + if (!gfx.override_level_music) { /* 1st try: look for special artwork in current level series directory */ filename = getPath3(getCurrentLevelDir(), MUSIC_DIRECTORY, basename); @@ -685,6 +823,16 @@ char *getCustomMusicFilename(char *basename) if (fileExists(filename)) return filename; +#if CREATE_SPECIAL_EDITION + free(filename); + + /* 6th try: look for fallback artwork in old default artwork directory */ + /* (needed to prevent errors when trying to access unused artwork files) */ + filename = getPath2(options.music_directory, MUS_FALLBACK_FILENAME); + if (fileExists(filename)) + return filename; +#endif + return NULL; /* cannot find specified artwork file anywhere */ } @@ -723,7 +871,7 @@ char *getCustomMusicDirectory(void) checked_free(directory); - if (!setup.override_level_music) + if (!gfx.override_level_music) { /* 1st try: look for special artwork in current level series directory */ directory = getPath2(getCurrentLevelDir(), MUSIC_DIRECTORY); @@ -794,7 +942,7 @@ void InitUserLevelDirectory(char *level_subdir) { createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE); createDirectory(getUserLevelDir(NULL), "main user level", PERMS_PRIVATE); - createDirectory(getUserLevelDir(level_subdir), "user level",PERMS_PRIVATE); + createDirectory(getUserLevelDir(level_subdir), "user level", PERMS_PRIVATE); SaveUserLevelInfo(); } @@ -804,7 +952,13 @@ void InitLevelSetupDirectory(char *level_subdir) { createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE); createDirectory(getLevelSetupDir(NULL), "main level setup", PERMS_PRIVATE); - createDirectory(getLevelSetupDir(level_subdir), "level setup",PERMS_PRIVATE); + createDirectory(getLevelSetupDir(level_subdir), "level setup", PERMS_PRIVATE); +} + +void InitCacheDirectory() +{ + createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE); + createDirectory(getCacheDir(), "cache data", PERMS_PRIVATE); } @@ -959,9 +1113,13 @@ TreeInfo *cloneTreeNode(TreeInfo **node_top, TreeInfo *node_parent, return cloneTreeNode(node_top, node_parent, node->next, skip_sets_without_levels); +#if 1 + node_new = getTreeInfoCopy(node); /* copy complete node */ +#else node_new = newTreeInfo(); *node_new = *node; /* copy complete node */ +#endif node_new->node_top = node_top; /* correct top node link */ node_new->node_parent = node_parent; /* correct parent node link */ @@ -1205,18 +1363,20 @@ char *getPersonalDataDir(void) char *getUserGameDataDir(void) { - if (program.userdata_path == NULL) - program.userdata_path = getPath2(getPersonalDataDir(), - program.userdata_subdir); + static char *user_game_data_dir = NULL; + + if (user_game_data_dir == NULL) + user_game_data_dir = getPath2(getPersonalDataDir(), + program.userdata_subdir); - return program.userdata_path; + return user_game_data_dir; } void updateUserGameDataDir() { #if defined(PLATFORM_MACOSX) char *userdata_dir_old = getPath2(getHomeDir(), program.userdata_subdir_unix); - char *userdata_dir_new = getUserGameDataDir(); + char *userdata_dir_new = getUserGameDataDir(); /* do not free() this */ /* convert old Unix style game data directory to Mac OS X style, if needed */ if (fileExists(userdata_dir_old) && !fileExists(userdata_dir_new)) @@ -1233,7 +1393,6 @@ void updateUserGameDataDir() } free(userdata_dir_old); - free(userdata_dir_new); #endif } @@ -1563,25 +1722,199 @@ static void printSetupFileHash(SetupFileHash *hash) } #endif -static void *loadSetupFileData(char *filename, boolean use_hash) +#define ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE 1 +#define CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING 0 +#define CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH 0 + +static boolean token_value_separator_found = FALSE; +#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING +static boolean token_value_separator_warning = FALSE; +#endif +#if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH +static boolean token_already_exists_warning = FALSE; +#endif + +static boolean getTokenValueFromSetupLineExt(char *line, + char **token_ptr, char **value_ptr, + char *filename, char *line_raw, + int line_nr, + boolean separator_required) +{ + static char line_copy[MAX_LINE_LEN + 1], line_raw_copy[MAX_LINE_LEN + 1]; + char *token, *value, *line_ptr; + + /* when externally invoked via ReadTokenValueFromLine(), copy line buffers */ + if (line_raw == NULL) + { + strncpy(line_copy, line, MAX_LINE_LEN); + line_copy[MAX_LINE_LEN] = '\0'; + line = line_copy; + + strcpy(line_raw_copy, line_copy); + line_raw = line_raw_copy; + } + + /* cut trailing comment from input line */ + for (line_ptr = line; *line_ptr; line_ptr++) + { + if (*line_ptr == '#') + { + *line_ptr = '\0'; + break; + } + } + + /* cut trailing whitespaces from input line */ + for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--) + if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0') + *line_ptr = '\0'; + + /* ignore empty lines */ + if (*line == '\0') + return FALSE; + + /* cut leading whitespaces from token */ + for (token = line; *token; token++) + if (*token != ' ' && *token != '\t') + break; + + /* start with empty value as reliable default */ + value = ""; + + token_value_separator_found = FALSE; + + /* find end of token to determine start of value */ + for (line_ptr = token; *line_ptr; line_ptr++) + { +#if 1 + /* first look for an explicit token/value separator, like ':' or '=' */ + if (*line_ptr == ':' || *line_ptr == '=') +#else + if (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == ':') +#endif + { + *line_ptr = '\0'; /* terminate token string */ + value = line_ptr + 1; /* set beginning of value */ + + token_value_separator_found = TRUE; + + break; + } + } + +#if ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE + /* fallback: if no token/value separator found, also allow whitespaces */ + if (!token_value_separator_found && !separator_required) + { + for (line_ptr = token; *line_ptr; line_ptr++) + { + if (*line_ptr == ' ' || *line_ptr == '\t') + { + *line_ptr = '\0'; /* terminate token string */ + value = line_ptr + 1; /* set beginning of value */ + + token_value_separator_found = TRUE; + + break; + } + } + +#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING + if (token_value_separator_found) + { + if (!token_value_separator_warning) + { + Error(ERR_INFO_LINE, "-"); + + if (filename != NULL) + { + Error(ERR_WARN, "missing token/value separator(s) in config file:"); + Error(ERR_INFO, "- config file: '%s'", filename); + } + else + { + Error(ERR_WARN, "missing token/value separator(s):"); + } + + token_value_separator_warning = TRUE; + } + + if (filename != NULL) + Error(ERR_INFO, "- line %d: '%s'", line_nr, line_raw); + else + Error(ERR_INFO, "- line: '%s'", line_raw); + } +#endif + } +#endif + + /* cut trailing whitespaces from token */ + for (line_ptr = &token[strlen(token)]; line_ptr >= token; line_ptr--) + if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0') + *line_ptr = '\0'; + + /* cut leading whitespaces from value */ + for (; *value; value++) + if (*value != ' ' && *value != '\t') + break; + +#if 0 + if (*value == '\0') + value = "true"; /* treat tokens without value as "true" */ +#endif + + *token_ptr = token; + *value_ptr = value; + + return TRUE; +} + +boolean getTokenValueFromSetupLine(char *line, char **token, char **value) +{ + /* while the internal (old) interface does not require a token/value + separator (for downwards compatibility with existing files which + don't use them), it is mandatory for the external (new) interface */ + + return getTokenValueFromSetupLineExt(line, token, value, NULL, NULL, 0, TRUE); +} + +#if 1 +static boolean loadSetupFileData(void *setup_file_data, char *filename, + boolean top_recursion_level, boolean is_hash) { - char line[MAX_LINE_LEN], previous_line[MAX_LINE_LEN]; + static SetupFileHash *include_filename_hash = NULL; + char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN]; char *token, *value, *line_ptr; - void *setup_file_data, *insert_ptr = NULL; + void *insert_ptr = NULL; boolean read_continued_line = FALSE; FILE *file; + int line_nr = 0, token_count = 0, include_count = 0; + +#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING + token_value_separator_warning = FALSE; +#endif + +#if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH + token_already_exists_warning = FALSE; +#endif if (!(file = fopen(filename, MODE_READ))) { Error(ERR_WARN, "cannot open configuration file '%s'", filename); - return NULL; + return FALSE; } - if (use_hash) - setup_file_data = newSetupFileHash(); - else - insert_ptr = setup_file_data = newSetupFileList("", ""); + /* use "insert pointer" to store list end for constant insertion complexity */ + if (!is_hash) + insert_ptr = setup_file_data; + + /* on top invocation, create hash to mark included files (to prevent loops) */ + if (top_recursion_level) + include_filename_hash = newSetupFileHash(); + + /* mark this file as already included (to prevent including it again) */ + setHashEntry(include_filename_hash, getBaseNamePtr(filename), "true"); while (!feof(file)) { @@ -1589,17 +1922,27 @@ static void *loadSetupFileData(char *filename, boolean use_hash) if (!fgets(line, MAX_LINE_LEN, file)) break; - /* cut trailing newline or carriage return */ + /* check if line was completely read and is terminated by line break */ + if (strlen(line) > 0 && line[strlen(line) - 1] == '\n') + line_nr++; + + /* cut trailing line break (this can be newline and/or carriage return) */ for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--) if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0') *line_ptr = '\0'; + /* copy raw input line for later use (mainly debugging output) */ + strcpy(line_raw, line); + if (read_continued_line) { +#if 0 + /* !!! ??? WHY ??? !!! */ /* cut leading whitespaces from input line */ for (line_ptr = line; *line_ptr; line_ptr++) if (*line_ptr != ' ' && *line_ptr != '\t') break; +#endif /* append new line to existing line, if there is enough space */ if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN) @@ -1621,96 +1964,382 @@ static void *loadSetupFileData(char *filename, boolean use_hash) continue; } - /* cut trailing comment from input line */ - for (line_ptr = line; *line_ptr; line_ptr++) + if (!getTokenValueFromSetupLineExt(line, &token, &value, filename, + line_raw, line_nr, FALSE)) + continue; + + if (*token) { - if (*line_ptr == '#') + if (strEqual(token, "include")) { - *line_ptr = '\0'; - break; - } - } - - /* cut trailing whitespaces from input line */ - for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--) - if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0') - *line_ptr = '\0'; + if (getHashEntry(include_filename_hash, value) == NULL) + { + char *basepath = getBasePath(filename); + char *basename = getBaseName(value); + char *filename_include = getPath2(basepath, basename); - /* ignore empty lines */ - if (*line == '\0') - continue; +#if 0 + Error(ERR_INFO, "[including file '%s']", filename_include); +#endif - /* cut leading whitespaces from token */ - for (token = line; *token; token++) - if (*token != ' ' && *token != '\t') - break; + loadSetupFileData(setup_file_data, filename_include, FALSE, is_hash); - /* start with empty value as reliable default */ - value = ""; + free(basepath); + free(basename); + free(filename_include); - /* find end of token to determine start of value */ - for (line_ptr = token; *line_ptr; line_ptr++) - { - if (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == ':') + include_count++; + } + else + { + Error(ERR_WARN, "ignoring already processed file '%s'", value); + } + } + else { - *line_ptr = '\0'; /* terminate token string */ - value = line_ptr + 1; /* set beginning of value */ + if (is_hash) + { +#if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH + char *old_value = + getHashEntry((SetupFileHash *)setup_file_data, token); + + if (old_value != NULL) + { + if (!token_already_exists_warning) + { + Error(ERR_INFO_LINE, "-"); + Error(ERR_WARN, "duplicate token(s) found in config file:"); + Error(ERR_INFO, "- config file: '%s'", filename); + + token_already_exists_warning = TRUE; + } + + Error(ERR_INFO, "- token: '%s' (in line %d)", token, line_nr); + Error(ERR_INFO, " old value: '%s'", old_value); + Error(ERR_INFO, " new value: '%s'", value); + } +#endif - break; + setHashEntry((SetupFileHash *)setup_file_data, token, value); + } + else + { + insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value); + } + + token_count++; } } + } - /* cut leading whitespaces from value */ - for (; *value; value++) - if (*value != ' ' && *value != '\t') - break; + fclose(file); -#if 0 +#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING + if (token_value_separator_warning) + Error(ERR_INFO_LINE, "-"); +#endif + +#if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH + if (token_already_exists_warning) + Error(ERR_INFO_LINE, "-"); +#endif + + if (token_count == 0 && include_count == 0) + Error(ERR_WARN, "configuration file '%s' is empty", filename); + + if (top_recursion_level) + freeSetupFileHash(include_filename_hash); + + return TRUE; +} + +#else + +static boolean loadSetupFileData(void *setup_file_data, char *filename, + boolean top_recursion_level, boolean is_hash) +{ + static SetupFileHash *include_filename_hash = NULL; + char line[MAX_LINE_LEN], line_raw[MAX_LINE_LEN], previous_line[MAX_LINE_LEN]; + char *token, *value, *line_ptr; + void *insert_ptr = NULL; + boolean read_continued_line = FALSE; + FILE *file; + int line_nr = 0; + int token_count = 0; + +#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING + token_value_separator_warning = FALSE; +#endif + + if (!(file = fopen(filename, MODE_READ))) + { + Error(ERR_WARN, "cannot open configuration file '%s'", filename); + + return FALSE; + } + + /* use "insert pointer" to store list end for constant insertion complexity */ + if (!is_hash) + insert_ptr = setup_file_data; + + /* on top invocation, create hash to mark included files (to prevent loops) */ + if (top_recursion_level) + include_filename_hash = newSetupFileHash(); + + /* mark this file as already included (to prevent including it again) */ + setHashEntry(include_filename_hash, getBaseNamePtr(filename), "true"); + + while (!feof(file)) + { + /* read next line of input file */ + if (!fgets(line, MAX_LINE_LEN, file)) + break; + + /* check if line was completely read and is terminated by line break */ + if (strlen(line) > 0 && line[strlen(line) - 1] == '\n') + line_nr++; + + /* cut trailing line break (this can be newline and/or carriage return) */ + for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--) + if ((*line_ptr == '\n' || *line_ptr == '\r') && *(line_ptr + 1) == '\0') + *line_ptr = '\0'; + + /* copy raw input line for later use (mainly debugging output) */ + strcpy(line_raw, line); + + if (read_continued_line) + { + /* cut leading whitespaces from input line */ + for (line_ptr = line; *line_ptr; line_ptr++) + if (*line_ptr != ' ' && *line_ptr != '\t') + break; + + /* append new line to existing line, if there is enough space */ + if (strlen(previous_line) + strlen(line_ptr) < MAX_LINE_LEN) + strcat(previous_line, line_ptr); + + strcpy(line, previous_line); /* copy storage buffer to line */ + + read_continued_line = FALSE; + } + + /* if the last character is '\', continue at next line */ + if (strlen(line) > 0 && line[strlen(line) - 1] == '\\') + { + line[strlen(line) - 1] = '\0'; /* cut off trailing backslash */ + strcpy(previous_line, line); /* copy line to storage buffer */ + + read_continued_line = TRUE; + + continue; + } + + /* cut trailing comment from input line */ + for (line_ptr = line; *line_ptr; line_ptr++) + { + if (*line_ptr == '#') + { + *line_ptr = '\0'; + break; + } + } + + /* cut trailing whitespaces from input line */ + for (line_ptr = &line[strlen(line)]; line_ptr >= line; line_ptr--) + if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0') + *line_ptr = '\0'; + + /* ignore empty lines */ + if (*line == '\0') + continue; + + /* cut leading whitespaces from token */ + for (token = line; *token; token++) + if (*token != ' ' && *token != '\t') + break; + + /* start with empty value as reliable default */ + value = ""; + + token_value_separator_found = FALSE; + + /* find end of token to determine start of value */ + for (line_ptr = token; *line_ptr; line_ptr++) + { +#if 1 + /* first look for an explicit token/value separator, like ':' or '=' */ + if (*line_ptr == ':' || *line_ptr == '=') +#else + if (*line_ptr == ' ' || *line_ptr == '\t' || *line_ptr == ':') +#endif + { + *line_ptr = '\0'; /* terminate token string */ + value = line_ptr + 1; /* set beginning of value */ + + token_value_separator_found = TRUE; + + break; + } + } + +#if ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE + /* fallback: if no token/value separator found, also allow whitespaces */ + if (!token_value_separator_found) + { + for (line_ptr = token; *line_ptr; line_ptr++) + { + if (*line_ptr == ' ' || *line_ptr == '\t') + { + *line_ptr = '\0'; /* terminate token string */ + value = line_ptr + 1; /* set beginning of value */ + + token_value_separator_found = TRUE; + + break; + } + } + +#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING + if (token_value_separator_found) + { + if (!token_value_separator_warning) + { + Error(ERR_INFO_LINE, "-"); + Error(ERR_WARN, "missing token/value separator(s) in config file:"); + Error(ERR_INFO, "- config file: '%s'", filename); + + token_value_separator_warning = TRUE; + } + + Error(ERR_INFO, "- line %d: '%s'", line_nr, line_raw); + } +#endif + } +#endif + + /* cut trailing whitespaces from token */ + for (line_ptr = &token[strlen(token)]; line_ptr >= token; line_ptr--) + if ((*line_ptr == ' ' || *line_ptr == '\t') && *(line_ptr + 1) == '\0') + *line_ptr = '\0'; + + /* cut leading whitespaces from value */ + for (; *value; value++) + if (*value != ' ' && *value != '\t') + break; + +#if 0 if (*value == '\0') value = "true"; /* treat tokens without value as "true" */ #endif if (*token) { - if (use_hash) - setHashEntry((SetupFileHash *)setup_file_data, token, value); + if (strEqual(token, "include")) + { + if (getHashEntry(include_filename_hash, value) == NULL) + { + char *basepath = getBasePath(filename); + char *basename = getBaseName(value); + char *filename_include = getPath2(basepath, basename); + +#if 0 + Error(ERR_INFO, "[including file '%s']", filename_include); +#endif + + loadSetupFileData(setup_file_data, filename_include, FALSE, is_hash); + + free(basepath); + free(basename); + free(filename_include); + } + else + { + Error(ERR_WARN, "ignoring already processed file '%s'", value); + } + } else - insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value); + { + if (is_hash) + setHashEntry((SetupFileHash *)setup_file_data, token, value); + else + insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value); + + token_count++; + } } } fclose(file); - if (use_hash) - { - if (hashtable_count((SetupFileHash *)setup_file_data) == 0) - Error(ERR_WARN, "configuration file '%s' is empty", filename); - } - else +#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING + if (token_value_separator_warning) + Error(ERR_INFO_LINE, "-"); +#endif + + if (token_count == 0) + Error(ERR_WARN, "configuration file '%s' is empty", filename); + + if (top_recursion_level) + freeSetupFileHash(include_filename_hash); + + return TRUE; +} +#endif + +void saveSetupFileHash(SetupFileHash *hash, char *filename) +{ + FILE *file; + + if (!(file = fopen(filename, MODE_WRITE))) { - SetupFileList *setup_file_list = (SetupFileList *)setup_file_data; - SetupFileList *first_valid_list_entry = setup_file_list->next; + Error(ERR_WARN, "cannot write configuration file '%s'", filename); - /* free empty list header */ - setup_file_list->next = NULL; - freeSetupFileList(setup_file_list); - setup_file_data = first_valid_list_entry; + return; + } - if (first_valid_list_entry == NULL) - Error(ERR_WARN, "configuration file '%s' is empty", filename); + BEGIN_HASH_ITERATION(hash, itr) + { + fprintf(file, "%s\n", getFormattedSetupEntry(HASH_ITERATION_TOKEN(itr), + HASH_ITERATION_VALUE(itr))); } + END_HASH_ITERATION(hash, itr) - return setup_file_data; + fclose(file); } SetupFileList *loadSetupFileList(char *filename) { - return (SetupFileList *)loadSetupFileData(filename, FALSE); + SetupFileList *setup_file_list = newSetupFileList("", ""); + SetupFileList *first_valid_list_entry; + + if (!loadSetupFileData(setup_file_list, filename, TRUE, FALSE)) + { + freeSetupFileList(setup_file_list); + + return NULL; + } + + first_valid_list_entry = setup_file_list->next; + + /* free empty list header */ + setup_file_list->next = NULL; + freeSetupFileList(setup_file_list); + + return first_valid_list_entry; } SetupFileHash *loadSetupFileHash(char *filename) { - return (SetupFileHash *)loadSetupFileData(filename, TRUE); + SetupFileHash *setup_file_hash = newSetupFileHash(); + + if (!loadSetupFileData(setup_file_hash, filename, TRUE, TRUE)) + { + freeSetupFileHash(setup_file_hash); + + return NULL; + } + + return setup_file_hash; } void checkSetupFileHashIdentifier(SetupFileHash *setup_file_hash, @@ -1738,25 +2367,27 @@ void checkSetupFileHashIdentifier(SetupFileHash *setup_file_hash, #define LEVELINFO_TOKEN_NAME 1 #define LEVELINFO_TOKEN_NAME_SORTING 2 #define LEVELINFO_TOKEN_AUTHOR 3 -#define LEVELINFO_TOKEN_IMPORTED_FROM 4 -#define LEVELINFO_TOKEN_IMPORTED_BY 5 -#define LEVELINFO_TOKEN_LEVELS 6 -#define LEVELINFO_TOKEN_FIRST_LEVEL 7 -#define LEVELINFO_TOKEN_SORT_PRIORITY 8 -#define LEVELINFO_TOKEN_LATEST_ENGINE 9 -#define LEVELINFO_TOKEN_LEVEL_GROUP 10 -#define LEVELINFO_TOKEN_READONLY 11 -#define LEVELINFO_TOKEN_GRAPHICS_SET_ECS 12 -#define LEVELINFO_TOKEN_GRAPHICS_SET_AGA 13 -#define LEVELINFO_TOKEN_GRAPHICS_SET 14 -#define LEVELINFO_TOKEN_SOUNDS_SET 15 -#define LEVELINFO_TOKEN_MUSIC_SET 16 -#define LEVELINFO_TOKEN_FILENAME 17 -#define LEVELINFO_TOKEN_FILETYPE 18 -#define LEVELINFO_TOKEN_HANDICAP 19 -#define LEVELINFO_TOKEN_SKIP_LEVELS 20 - -#define NUM_LEVELINFO_TOKENS 21 +#define LEVELINFO_TOKEN_YEAR 4 +#define LEVELINFO_TOKEN_IMPORTED_FROM 5 +#define LEVELINFO_TOKEN_IMPORTED_BY 6 +#define LEVELINFO_TOKEN_TESTED_BY 7 +#define LEVELINFO_TOKEN_LEVELS 8 +#define LEVELINFO_TOKEN_FIRST_LEVEL 9 +#define LEVELINFO_TOKEN_SORT_PRIORITY 10 +#define LEVELINFO_TOKEN_LATEST_ENGINE 11 +#define LEVELINFO_TOKEN_LEVEL_GROUP 12 +#define LEVELINFO_TOKEN_READONLY 13 +#define LEVELINFO_TOKEN_GRAPHICS_SET_ECS 14 +#define LEVELINFO_TOKEN_GRAPHICS_SET_AGA 15 +#define LEVELINFO_TOKEN_GRAPHICS_SET 16 +#define LEVELINFO_TOKEN_SOUNDS_SET 17 +#define LEVELINFO_TOKEN_MUSIC_SET 18 +#define LEVELINFO_TOKEN_FILENAME 19 +#define LEVELINFO_TOKEN_FILETYPE 20 +#define LEVELINFO_TOKEN_HANDICAP 21 +#define LEVELINFO_TOKEN_SKIP_LEVELS 22 + +#define NUM_LEVELINFO_TOKENS 23 static LevelDirTree ldi; @@ -1767,8 +2398,10 @@ static struct TokenInfo levelinfo_tokens[] = { TYPE_STRING, &ldi.name, "name" }, { TYPE_STRING, &ldi.name_sorting, "name_sorting" }, { TYPE_STRING, &ldi.author, "author" }, + { TYPE_STRING, &ldi.year, "year" }, { TYPE_STRING, &ldi.imported_from, "imported_from" }, { TYPE_STRING, &ldi.imported_by, "imported_by" }, + { TYPE_STRING, &ldi.tested_by, "tested_by" }, { TYPE_INTEGER, &ldi.levels, "levels" }, { TYPE_INTEGER, &ldi.first_level, "first_level" }, { TYPE_INTEGER, &ldi.sort_priority, "sort_priority" }, @@ -1786,6 +2419,24 @@ static struct TokenInfo levelinfo_tokens[] = { TYPE_BOOLEAN, &ldi.skip_levels, "skip_levels" } }; +static struct TokenInfo artworkinfo_tokens[] = +{ + /* artwork directory info */ + { TYPE_STRING, &ldi.identifier, "identifier" }, + { TYPE_STRING, &ldi.subdir, "subdir" }, + { TYPE_STRING, &ldi.name, "name" }, + { TYPE_STRING, &ldi.name_sorting, "name_sorting" }, + { TYPE_STRING, &ldi.author, "author" }, + { TYPE_INTEGER, &ldi.sort_priority, "sort_priority" }, + { TYPE_STRING, &ldi.basepath, "basepath" }, + { TYPE_STRING, &ldi.fullpath, "fullpath" }, + { TYPE_BOOLEAN, &ldi.in_user_dir, "in_user_dir" }, + { TYPE_INTEGER, &ldi.color, "color" }, + { TYPE_STRING, &ldi.class_desc, "class_desc" }, + + { -1, NULL, NULL }, +}; + static void setTreeInfoToDefaults(TreeInfo *ti, int type) { ti->type = type; @@ -1810,6 +2461,7 @@ static void setTreeInfoToDefaults(TreeInfo *ti, int type) ti->name = getStringCopy(ANONYMOUS_NAME); ti->name_sorting = NULL; ti->author = getStringCopy(ANONYMOUS_NAME); + ti->year = NULL; ti->sort_priority = LEVELCLASS_UNDEFINED; /* default: least priority */ ti->latest_engine = FALSE; /* default: get from level */ @@ -1825,6 +2477,7 @@ static void setTreeInfoToDefaults(TreeInfo *ti, int type) { ti->imported_from = NULL; ti->imported_by = NULL; + ti->tested_by = NULL; ti->graphics_set_ecs = NULL; ti->graphics_set_aga = NULL; @@ -1879,6 +2532,7 @@ static void setTreeInfoToDefaultsFromParent(TreeInfo *ti, TreeInfo *parent) ti->name = getStringCopy(ANONYMOUS_NAME); ti->name_sorting = NULL; ti->author = getStringCopy(parent->author); + ti->year = getStringCopy(parent->year); ti->sort_priority = parent->sort_priority; ti->latest_engine = parent->latest_engine; @@ -1894,6 +2548,7 @@ static void setTreeInfoToDefaultsFromParent(TreeInfo *ti, TreeInfo *parent) { ti->imported_from = getStringCopy(parent->imported_from); ti->imported_by = getStringCopy(parent->imported_by); + ti->tested_by = getStringCopy(parent->tested_by); ti->graphics_set_ecs = NULL; ti->graphics_set_aga = NULL; @@ -1918,8 +2573,75 @@ static void setTreeInfoToDefaultsFromParent(TreeInfo *ti, TreeInfo *parent) } } +static TreeInfo *getTreeInfoCopy(TreeInfo *ti) +{ + TreeInfo *ti_copy = newTreeInfo(); + + /* copy all values from the original structure */ + + ti_copy->type = ti->type; + + ti_copy->node_top = ti->node_top; + ti_copy->node_parent = ti->node_parent; + ti_copy->node_group = ti->node_group; + ti_copy->next = ti->next; + + ti_copy->cl_first = ti->cl_first; + ti_copy->cl_cursor = ti->cl_cursor; + + ti_copy->subdir = getStringCopy(ti->subdir); + ti_copy->fullpath = getStringCopy(ti->fullpath); + ti_copy->basepath = getStringCopy(ti->basepath); + ti_copy->identifier = getStringCopy(ti->identifier); + ti_copy->name = getStringCopy(ti->name); + ti_copy->name_sorting = getStringCopy(ti->name_sorting); + ti_copy->author = getStringCopy(ti->author); + ti_copy->year = getStringCopy(ti->year); + ti_copy->imported_from = getStringCopy(ti->imported_from); + ti_copy->imported_by = getStringCopy(ti->imported_by); + ti_copy->tested_by = getStringCopy(ti->tested_by); + + ti_copy->graphics_set_ecs = getStringCopy(ti->graphics_set_ecs); + ti_copy->graphics_set_aga = getStringCopy(ti->graphics_set_aga); + ti_copy->graphics_set = getStringCopy(ti->graphics_set); + ti_copy->sounds_set = getStringCopy(ti->sounds_set); + ti_copy->music_set = getStringCopy(ti->music_set); + ti_copy->graphics_path = getStringCopy(ti->graphics_path); + ti_copy->sounds_path = getStringCopy(ti->sounds_path); + ti_copy->music_path = getStringCopy(ti->music_path); + + ti_copy->level_filename = getStringCopy(ti->level_filename); + ti_copy->level_filetype = getStringCopy(ti->level_filetype); + + ti_copy->levels = ti->levels; + ti_copy->first_level = ti->first_level; + ti_copy->last_level = ti->last_level; + ti_copy->sort_priority = ti->sort_priority; + + ti_copy->latest_engine = ti->latest_engine; + + ti_copy->level_group = ti->level_group; + ti_copy->parent_link = ti->parent_link; + ti_copy->in_user_dir = ti->in_user_dir; + ti_copy->user_defined = ti->user_defined; + ti_copy->readonly = ti->readonly; + ti_copy->handicap = ti->handicap; + ti_copy->skip_levels = ti->skip_levels; + + ti_copy->color = ti->color; + ti_copy->class_desc = getStringCopy(ti->class_desc); + ti_copy->handicap_level = ti->handicap_level; + + ti_copy->infotext = getStringCopy(ti->infotext); + + return ti_copy; +} + static void freeTreeInfo(TreeInfo *ti) { + if (ti == NULL) + return; + checked_free(ti->subdir); checked_free(ti->fullpath); checked_free(ti->basepath); @@ -1928,6 +2650,7 @@ static void freeTreeInfo(TreeInfo *ti) checked_free(ti->name); checked_free(ti->name_sorting); checked_free(ti->author); + checked_free(ti->year); checked_free(ti->class_desc); @@ -1937,6 +2660,7 @@ static void freeTreeInfo(TreeInfo *ti) { checked_free(ti->imported_from); checked_free(ti->imported_by); + checked_free(ti->tested_by); checked_free(ti->graphics_set_ecs); checked_free(ti->graphics_set_aga); @@ -1951,6 +2675,8 @@ static void freeTreeInfo(TreeInfo *ti) checked_free(ti->level_filename); checked_free(ti->level_filetype); } + + checked_free(ti); } void setSetupInfo(struct TokenInfo *token_info, @@ -2058,6 +2784,222 @@ static void createParentTreeInfoNode(TreeInfo *node_parent) pushTreeInfo(&node_parent->node_group, ti_new); } + +/* -------------------------------------------------------------------------- */ +/* functions for handling level and custom artwork info cache */ +/* -------------------------------------------------------------------------- */ + +static void LoadArtworkInfoCache() +{ + InitCacheDirectory(); + + if (artworkinfo_cache_old == NULL) + { + char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE); + + /* try to load artwork info hash from already existing cache file */ + artworkinfo_cache_old = loadSetupFileHash(filename); + + /* if no artwork info cache file was found, start with empty hash */ + if (artworkinfo_cache_old == NULL) + artworkinfo_cache_old = newSetupFileHash(); + + free(filename); + } + + if (artworkinfo_cache_new == NULL) + artworkinfo_cache_new = newSetupFileHash(); +} + +static void SaveArtworkInfoCache() +{ + char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE); + + InitCacheDirectory(); + + saveSetupFileHash(artworkinfo_cache_new, filename); + + free(filename); +} + +static char *getCacheTokenPrefix(char *prefix1, char *prefix2) +{ + static char *prefix = NULL; + + checked_free(prefix); + + prefix = getStringCat2WithSeparator(prefix1, prefix2, "."); + + return prefix; +} + +/* (identical to above function, but separate string buffer needed -- nasty) */ +static char *getCacheToken(char *prefix, char *suffix) +{ + static char *token = NULL; + + checked_free(token); + + token = getStringCat2WithSeparator(prefix, suffix, "."); + + return token; +} + +static char *getFileTimestamp(char *filename) +{ + struct stat file_status; + + if (stat(filename, &file_status) != 0) /* cannot stat file */ + return getStringCopy(i_to_a(0)); + + return getStringCopy(i_to_a(file_status.st_mtime)); +} + +static boolean modifiedFileTimestamp(char *filename, char *timestamp_string) +{ + struct stat file_status; + + if (timestamp_string == NULL) + return TRUE; + + if (stat(filename, &file_status) != 0) /* cannot stat file */ + return TRUE; + + return (file_status.st_mtime != atoi(timestamp_string)); +} + +static TreeInfo *getArtworkInfoCacheEntry(LevelDirTree *level_node, int type) +{ + char *identifier = level_node->subdir; + char *type_string = ARTWORK_DIRECTORY(type); + char *token_prefix = getCacheTokenPrefix(type_string, identifier); + char *token_main = getCacheToken(token_prefix, "CACHED"); + char *cache_entry = getHashEntry(artworkinfo_cache_old, token_main); + boolean cached = (cache_entry != NULL && strEqual(cache_entry, "true")); + TreeInfo *artwork_info = NULL; + + if (!use_artworkinfo_cache) + return NULL; + + if (cached) + { + int i; + + artwork_info = newTreeInfo(); + setTreeInfoToDefaults(artwork_info, type); + + /* set all structure fields according to the token/value pairs */ + ldi = *artwork_info; + for (i = 0; artworkinfo_tokens[i].type != -1; i++) + { + char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text); + char *value = getHashEntry(artworkinfo_cache_old, token); + + setSetupInfo(artworkinfo_tokens, i, value); + + /* check if cache entry for this item is invalid or incomplete */ + if (value == NULL) + { +#if 1 + Error(ERR_WARN, "cache entry '%s' invalid", token); +#endif + + cached = FALSE; + } + } + + *artwork_info = ldi; + } + + if (cached) + { + char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node), + LEVELINFO_FILENAME); + char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info), + ARTWORKINFO_FILENAME(type)); + + /* check if corresponding "levelinfo.conf" file has changed */ + token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO"); + cache_entry = getHashEntry(artworkinfo_cache_old, token_main); + + if (modifiedFileTimestamp(filename_levelinfo, cache_entry)) + cached = FALSE; + + /* check if corresponding ".conf" file has changed */ + token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO"); + cache_entry = getHashEntry(artworkinfo_cache_old, token_main); + + if (modifiedFileTimestamp(filename_artworkinfo, cache_entry)) + cached = FALSE; + +#if 0 + if (!cached) + printf("::: '%s': INVALIDATED FROM CACHE BY TIMESTAMP\n", identifier); +#endif + + checked_free(filename_levelinfo); + checked_free(filename_artworkinfo); + } + + if (!cached && artwork_info != NULL) + { + freeTreeInfo(artwork_info); + + return NULL; + } + + return artwork_info; +} + +static void setArtworkInfoCacheEntry(TreeInfo *artwork_info, + LevelDirTree *level_node, int type) +{ + char *identifier = level_node->subdir; + char *type_string = ARTWORK_DIRECTORY(type); + char *token_prefix = getCacheTokenPrefix(type_string, identifier); + char *token_main = getCacheToken(token_prefix, "CACHED"); + boolean set_cache_timestamps = TRUE; + int i; + + setHashEntry(artworkinfo_cache_new, token_main, "true"); + + if (set_cache_timestamps) + { + char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node), + LEVELINFO_FILENAME); + char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info), + ARTWORKINFO_FILENAME(type)); + char *timestamp_levelinfo = getFileTimestamp(filename_levelinfo); + char *timestamp_artworkinfo = getFileTimestamp(filename_artworkinfo); + + token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO"); + setHashEntry(artworkinfo_cache_new, token_main, timestamp_levelinfo); + + token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO"); + setHashEntry(artworkinfo_cache_new, token_main, timestamp_artworkinfo); + + checked_free(filename_levelinfo); + checked_free(filename_artworkinfo); + checked_free(timestamp_levelinfo); + checked_free(timestamp_artworkinfo); + } + + ldi = *artwork_info; + for (i = 0; artworkinfo_tokens[i].type != -1; i++) + { + char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text); + char *value = getSetupValue(artworkinfo_tokens[i].type, + artworkinfo_tokens[i].value); + if (value != NULL) + setHashEntry(artworkinfo_cache_new, token, value); + } +} + + +/* -------------------------------------------------------------------------- */ +/* functions for loading level info and custom artwork info */ +/* -------------------------------------------------------------------------- */ + /* forward declaration for recursive call by "LoadLevelInfoFromLevelDir()" */ static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *); @@ -2066,6 +3008,10 @@ static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first, char *level_directory, char *directory_name) { +#if 0 + static unsigned long progress_delay = 0; + unsigned long progress_delay_value = 100; /* (in milliseconds) */ +#endif char *directory_path = getPath2(level_directory, directory_name); char *filename = getPath2(directory_path, LEVELINFO_FILENAME); SetupFileHash *setup_file_hash; @@ -2115,8 +3061,6 @@ static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first, if (strEqual(leveldir_new->name, ANONYMOUS_NAME)) setString(&leveldir_new->name, leveldir_new->subdir); - DrawInitText(leveldir_new->name, 150, FC_YELLOW); - if (leveldir_new->identifier == NULL) leveldir_new->identifier = getStringCopy(leveldir_new->subdir); @@ -2167,6 +3111,19 @@ static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first, (leveldir_new->user_defined || !leveldir_new->handicap ? leveldir_new->last_level : leveldir_new->first_level); +#if 1 +#if 1 + DrawInitTextExt(leveldir_new->name, 150, FC_YELLOW, + leveldir_new->level_group); +#else + if (leveldir_new->level_group || + DelayReached(&progress_delay, progress_delay_value)) + DrawInitText(leveldir_new->name, 150, FC_YELLOW); +#endif +#else + DrawInitText(leveldir_new->name, 150, FC_YELLOW); +#endif + #if 0 /* !!! don't skip sets without levels (else artwork base sets are missing) */ #if 1 @@ -2192,7 +3149,7 @@ static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first, /* create node to link back to current level directory */ createParentTreeInfoNode(leveldir_new); - /* step into sub-directory and look for more level series */ + /* recursively step into sub-directory and look for more level series */ LoadLevelInfoFromLevelDir(&leveldir_new->node_group, leveldir_new, directory_path); } @@ -2280,7 +3237,7 @@ void LoadLevelInfo() { InitUserLevelDirectory(getLoginName()); - DrawInitText("Loading level series:", 120, FC_GREEN); + DrawInitText("Loading level series", 120, FC_GREEN); LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory); LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL)); @@ -2380,10 +3337,6 @@ static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first, if (strEqual(artwork_new->name, ANONYMOUS_NAME)) setString(&artwork_new->name, artwork_new->subdir); -#if 0 - DrawInitText(artwork_new->name, 150, FC_YELLOW); -#endif - if (artwork_new->identifier == NULL) artwork_new->identifier = getStringCopy(artwork_new->subdir); @@ -2440,7 +3393,9 @@ static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first, setString(&artwork_new->name_sorting, artwork_new->name); } +#if 0 DrawInitText(artwork_new->name, 150, FC_YELLOW); +#endif pushTreeInfo(node_first, artwork_new); @@ -2530,7 +3485,9 @@ static TreeInfo *getDummyArtworkInfo(int type) void LoadArtworkInfo() { - DrawInitText("Looking for custom artwork:", 120, FC_GREEN); + LoadArtworkInfoCache(); + + DrawInitText("Looking for custom artwork", 120, FC_GREEN); LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL, options.graphics_directory, @@ -2609,6 +3566,12 @@ void LoadArtworkInfo() void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node, LevelDirTree *level_node) { +#if 0 + static unsigned long progress_delay = 0; + unsigned long progress_delay_value = 100; /* (in milliseconds) */ +#endif + int type = (*artwork_node)->type; + /* recursively check all level directories for artwork sub-directories */ while (level_node) @@ -2616,30 +3579,50 @@ void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node, /* check all tree entries for artwork, but skip parent link entries */ if (!level_node->parent_link) { - TreeInfo *topnode_last = *artwork_node; - char *path = getPath2(getLevelDirFromTreeInfo(level_node), - ARTWORK_DIRECTORY((*artwork_node)->type)); - - LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path, - (*artwork_node)->type); + TreeInfo *artwork_new = getArtworkInfoCacheEntry(level_node, type); + boolean cached = (artwork_new != NULL); - if (topnode_last != *artwork_node) + if (cached) { - free((*artwork_node)->identifier); - free((*artwork_node)->name); - free((*artwork_node)->name_sorting); + pushTreeInfo(artwork_node, artwork_new); + } + else + { + TreeInfo *topnode_last = *artwork_node; + char *path = getPath2(getLevelDirFromTreeInfo(level_node), + ARTWORK_DIRECTORY(type)); + + LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path, type); + + if (topnode_last != *artwork_node) /* check for newly added node */ + { + artwork_new = *artwork_node; - (*artwork_node)->identifier = getStringCopy(level_node->subdir); - (*artwork_node)->name = getStringCopy(level_node->name); - (*artwork_node)->name_sorting = getStringCopy(level_node->name); + setString(&artwork_new->identifier, level_node->subdir); + setString(&artwork_new->name, level_node->name); + setString(&artwork_new->name_sorting, level_node->name_sorting); - (*artwork_node)->sort_priority = level_node->sort_priority; - (*artwork_node)->color = LEVELCOLOR((*artwork_node)); + artwork_new->sort_priority = level_node->sort_priority; + artwork_new->color = LEVELCOLOR(artwork_new); + } + + free(path); } - free(path); + /* insert artwork info (from old cache or filesystem) into new cache */ + if (artwork_new != NULL) + setArtworkInfoCacheEntry(artwork_new, level_node, type); } +#if 1 + DrawInitTextExt(level_node->name, 150, FC_YELLOW, + level_node->level_group); +#else + if (level_node->level_group || + DelayReached(&progress_delay, progress_delay_value)) + DrawInitText(level_node->name, 150, FC_YELLOW); +#endif + if (level_node->node_group != NULL) LoadArtworkInfoFromLevelInfo(artwork_node, level_node->node_group); @@ -2649,12 +3632,14 @@ void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node, void LoadLevelArtworkInfo() { - DrawInitText("Looking for custom level artwork:", 120, FC_GREEN); + DrawInitText("Looking for custom level artwork", 120, FC_GREEN); LoadArtworkInfoFromLevelInfo(&artwork.gfx_first, leveldir_first_all); LoadArtworkInfoFromLevelInfo(&artwork.snd_first, leveldir_first_all); LoadArtworkInfoFromLevelInfo(&artwork.mus_first, leveldir_first_all); + SaveArtworkInfoCache(); + /* needed for reloading level artwork not known at ealier stage */ if (!strEqual(artwork.gfx_current_identifier, setup.graphics_set)) @@ -2794,6 +3779,9 @@ char *getSetupValue(int type, void *value) break; case TYPE_STRING: + if (*(char **)value == NULL) + return NULL; + strcpy(value_string, *(char **)value); break; @@ -2858,6 +3846,13 @@ void LoadLevelSetup_LastSeries() /* always start with reliable default values */ leveldir_current = getFirstValidTreeInfoEntry(leveldir_first); +#if CREATE_SPECIAL_EDITION_RND_JUE + leveldir_current = getTreeInfoFromIdentifier(leveldir_first, + "jue_start"); + if (leveldir_current == NULL) + leveldir_current = getFirstValidTreeInfoEntry(leveldir_first); +#endif + if ((level_setup_hash = loadSetupFileHash(filename))) { char *last_level_series =