X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Flibgame%2Fsetup.c;h=16c11dfdcfdc0ce5d34f24b9e3e861ade2678620;hp=bc8a1a34740bb1b31ab92b928dfba63cffa8b8b4;hb=abe44529b439ad39b4d8dbf19cbd67c9b9844279;hpb=9f7cd608c28ded86b2c2e649c776220ae27df038 diff --git a/src/libgame/setup.c b/src/libgame/setup.c index bc8a1a34..16c11dfd 100644 --- a/src/libgame/setup.c +++ b/src/libgame/setup.c @@ -1,21 +1,20 @@ -/*********************************************************** -* Artsoft Retro-Game Library * -*----------------------------------------------------------* -* (c) 1994-2006 Artsoft Entertainment * -* Holger Schemel * -* Detmolder Strasse 189 * -* 33604 Bielefeld * -* Germany * -* e-mail: info@artsoft.org * -*----------------------------------------------------------* -* setup.c * -***********************************************************/ +// ============================================================================ +// Artsoft Retro-Game Library +// ---------------------------------------------------------------------------- +// (c) 1995-2014 by Artsoft Entertainment +// Holger Schemel +// info@artsoft.org +// http://www.artsoft.org/ +// ---------------------------------------------------------------------------- +// setup.c +// ============================================================================ #include #include #include #include #include +#include #include "platform.h" @@ -262,14 +261,14 @@ static char *getDefaultMusicDir(char *music_subdir) return music_dir; } -static char *getDefaultArtworkSet(int type) +static char *getClassicArtworkSet(int type) { return (type == TREE_TYPE_GRAPHICS_DIR ? GFX_CLASSIC_SUBDIR : type == TREE_TYPE_SOUNDS_DIR ? SND_CLASSIC_SUBDIR : type == TREE_TYPE_MUSIC_DIR ? MUS_CLASSIC_SUBDIR : ""); } -static char *getDefaultArtworkDir(int type) +static char *getClassicArtworkDir(int type) { return (type == TREE_TYPE_GRAPHICS_DIR ? getDefaultGraphicsDir(GFX_CLASSIC_SUBDIR) : @@ -334,24 +333,32 @@ char *setLevelArtworkDir(TreeInfo *ti) checked_free(*artwork_path_ptr); if ((level_artwork = getTreeInfoFromIdentifier(ti, *artwork_set_ptr))) + { *artwork_path_ptr = getStringCopy(getSetupArtworkDir(level_artwork)); + } else { - /* No (or non-existing) artwork configured in "levelinfo.conf". This would - normally result in using the artwork configured in the setup menu. But - if an artwork subdirectory exists (which might contain custom artwork - or an artwork configuration file), this level artwork must be treated - as relative to the default "classic" artwork, not to the artwork that - is currently configured in the setup menu. */ + /* + No (or non-existing) artwork configured in "levelinfo.conf". This would + normally result in using the artwork configured in the setup menu. But + if an artwork subdirectory exists (which might contain custom artwork + or an artwork configuration file), this level artwork must be treated + as relative to the default "classic" artwork, not to the artwork that + is currently configured in the setup menu. + + Update: For "special" versions of R'n'D (like "R'n'D jue"), do not use + the "default" artwork (which would be "jue0" for "R'n'D jue"), but use + the real "classic" artwork from the original R'n'D (like "gfx_classic"). + */ char *dir = getPath2(getCurrentLevelDir(), ARTWORK_DIRECTORY(ti->type)); checked_free(*artwork_set_ptr); - if (fileExists(dir)) + if (directoryExists(dir)) { - *artwork_path_ptr = getStringCopy(getDefaultArtworkDir(ti->type)); - *artwork_set_ptr = getStringCopy(getDefaultArtworkSet(ti->type)); + *artwork_path_ptr = getStringCopy(getClassicArtworkDir(ti->type)); + *artwork_set_ptr = getStringCopy(getClassicArtworkSet(ti->type)); } else { @@ -404,6 +411,19 @@ char *getSolutionTapeFilename(int nr) sprintf(basename, "%03d.%s", nr, TAPEFILE_EXTENSION); filename = getPath2(getSolutionTapeDir(), basename); + if (!fileExists(filename)) + { + static char *filename_sln = NULL; + + checked_free(filename_sln); + + sprintf(basename, "%03d.sln", nr); + filename_sln = getPath2(getSolutionTapeDir(), basename); + + if (fileExists(filename_sln)) + return filename_sln; + } + return filename; } @@ -498,53 +518,85 @@ char *getLevelSetInfoFilename() return NULL; } -char *getLevelSetTitleMessageFilename(int nr, boolean initial) +char *getLevelSetTitleMessageBasename(int nr, boolean initial) { - static char *filename = NULL; - char basename[32]; + static char basename[32]; sprintf(basename, "%s_%d.txt", (initial ? "titlemessage_initial" : "titlemessage"), nr + 1); - checked_free(filename); - filename = getPath2(getCurrentLevelDir(), basename); - - if (fileExists(filename)) - return filename; - - return NULL; + return basename; } -static char *getCorrectedArtworkBasename(char *basename) +char *getLevelSetTitleMessageFilename(int nr, boolean initial) { - char *basename_corrected = basename; + static char *filename = NULL; + char *basename; + boolean skip_setup_artwork = FALSE; -#if defined(PLATFORM_MSDOS) - if (program.filename_prefix != NULL) + checked_free(filename); + + basename = getLevelSetTitleMessageBasename(nr, initial); + + if (!gfx.override_level_graphics) { - int prefix_len = strlen(program.filename_prefix); + /* 1st try: look for special artwork in current level series directory */ + filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename); + if (fileExists(filename)) + return filename; + + free(filename); - if (strncmp(basename, program.filename_prefix, prefix_len) == 0) - basename_corrected = &basename[prefix_len]; + /* 2nd try: look for message file in current level set directory */ + filename = getPath2(getCurrentLevelDir(), basename); + if (fileExists(filename)) + return filename; - /* if corrected filename is still longer than standard MS-DOS filename - size (8 characters + 1 dot + 3 characters file extension), shorten - filename by writing file extension after 8th basename character */ - if (strlen(basename_corrected) > 8 + 1 + 3) - { - static char *msdos_filename = NULL; + free(filename); - checked_free(msdos_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; - msdos_filename = getStringCopy(basename_corrected); - strncpy(&msdos_filename[8], &basename[strlen(basename) - (1+3)], 1+3 +1); + free(filename); - basename_corrected = msdos_filename; + /* take missing artwork configured in level set config from default */ + skip_setup_artwork = TRUE; } } -#endif - return basename_corrected; + 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_DEFAULT_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) +{ + return basename; } char *getCustomImageFilename(char *basename) @@ -556,7 +608,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); @@ -591,7 +643,7 @@ char *getCustomImageFilename(char *basename) } /* 4th try: look for default artwork in new default artwork directory */ - filename = getPath2(getDefaultGraphicsDir(GFX_CLASSIC_SUBDIR), basename); + filename = getPath2(getDefaultGraphicsDir(GFX_DEFAULT_SUBDIR), basename); if (fileExists(filename)) return filename; @@ -602,6 +654,19 @@ char *getCustomImageFilename(char *basename) if (fileExists(filename)) return filename; +#if defined(CREATE_SPECIAL_EDITION) + free(filename); + + if (options.debug) + Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)", basename); + + /* 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 */ } @@ -614,7 +679,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); @@ -649,7 +714,7 @@ char *getCustomSoundFilename(char *basename) } /* 4th try: look for default artwork in new default artwork directory */ - filename = getPath2(getDefaultSoundsDir(SND_CLASSIC_SUBDIR), basename); + filename = getPath2(getDefaultSoundsDir(SND_DEFAULT_SUBDIR), basename); if (fileExists(filename)) return filename; @@ -660,6 +725,19 @@ char *getCustomSoundFilename(char *basename) if (fileExists(filename)) return filename; +#if defined(CREATE_SPECIAL_EDITION) + free(filename); + + if (options.debug) + Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)", basename); + + /* 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 */ } @@ -672,7 +750,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); @@ -707,7 +785,7 @@ char *getCustomMusicFilename(char *basename) } /* 4th try: look for default artwork in new default artwork directory */ - filename = getPath2(getDefaultMusicDir(MUS_CLASSIC_SUBDIR), basename); + filename = getPath2(getDefaultMusicDir(MUS_DEFAULT_SUBDIR), basename); if (fileExists(filename)) return filename; @@ -718,6 +796,19 @@ char *getCustomMusicFilename(char *basename) if (fileExists(filename)) return filename; +#if defined(CREATE_SPECIAL_EDITION) + free(filename); + + if (options.debug) + Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)", basename); + + /* 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 */ } @@ -756,11 +847,11 @@ 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); - if (fileExists(directory)) + if (directoryExists(directory)) return directory; free(directory); @@ -770,7 +861,7 @@ char *getCustomMusicDirectory(void) { /* 2nd try: look for special artwork configured in level series config */ directory = getStringCopy(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR)); - if (fileExists(directory)) + if (directoryExists(directory)) return directory; free(directory); @@ -784,22 +875,22 @@ char *getCustomMusicDirectory(void) { /* 3rd try: look for special artwork in configured artwork directory */ directory = getStringCopy(getSetupArtworkDir(artwork.mus_current)); - if (fileExists(directory)) + if (directoryExists(directory)) return directory; free(directory); } /* 4th try: look for default artwork in new default artwork directory */ - directory = getStringCopy(getDefaultMusicDir(MUS_CLASSIC_SUBDIR)); - if (fileExists(directory)) + directory = getStringCopy(getDefaultMusicDir(MUS_DEFAULT_SUBDIR)); + if (directoryExists(directory)) return directory; free(directory); /* 5th try: look for default artwork in old default artwork directory */ directory = getStringCopy(options.music_directory); - if (fileExists(directory)) + if (directoryExists(directory)) return directory; return NULL; /* cannot find specified artwork file anywhere */ @@ -823,7 +914,7 @@ static void SaveUserLevelInfo(); void InitUserLevelDirectory(char *level_subdir) { - if (!fileExists(getUserLevelDir(level_subdir))) + if (!directoryExists(getUserLevelDir(level_subdir))) { createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE); createDirectory(getUserLevelDir(NULL), "main user level", PERMS_PRIVATE); @@ -1065,8 +1156,13 @@ void dumpTreeInfo(TreeInfo *node, int depth) for (i = 0; i < (depth + 1) * 3; i++) printf(" "); + printf("'%s' / '%s'\n", node->identifier, node->name); + + /* + // use for dumping artwork info tree printf("subdir == '%s' ['%s', '%s'] [%d])\n", node->subdir, node->fullpath, node->basepath, node->in_user_dir); + */ if (node->node_group != NULL) dumpTreeInfo(node->node_group, depth + 1); @@ -1250,9 +1346,14 @@ char *getUserGameDataDir(void) { static char *user_game_data_dir = NULL; +#if defined(PLATFORM_ANDROID) + if (user_game_data_dir == NULL) + user_game_data_dir = (char *)SDL_AndroidGetInternalStoragePath(); +#else if (user_game_data_dir == NULL) user_game_data_dir = getPath2(getPersonalDataDir(), program.userdata_subdir); +#endif return user_game_data_dir; } @@ -1264,7 +1365,7 @@ void updateUserGameDataDir() 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)) + if (directoryExists(userdata_dir_old) && !directoryExists(userdata_dir_new)) { if (rename(userdata_dir_old, userdata_dir_new) != 0) { @@ -1304,21 +1405,42 @@ static int posix_mkdir(const char *pathname, mode_t mode) #endif } +static boolean posix_process_running_setgid() +{ +#if defined(PLATFORM_UNIX) + return (getgid() != getegid()); +#else + return FALSE; +#endif +} + void createDirectory(char *dir, char *text, int permission_class) { /* leave "other" permissions in umask untouched, but ensure group parts of USERDATA_DIR_MODE are not masked */ mode_t dir_mode = (permission_class == PERMS_PRIVATE ? DIR_PERMS_PRIVATE : DIR_PERMS_PUBLIC); - mode_t normal_umask = posix_umask(0); + mode_t last_umask = posix_umask(0); mode_t group_umask = ~(dir_mode & S_IRWXG); - posix_umask(normal_umask & group_umask); + int running_setgid = posix_process_running_setgid(); + + /* if we're setgid, protect files against "other" */ + /* else keep umask(0) to make the dir world-writable */ + + if (running_setgid) + posix_umask(last_umask & group_umask); + else + dir_mode |= MODE_W_ALL; - if (!fileExists(dir)) + if (!directoryExists(dir)) if (posix_mkdir(dir, dir_mode) != 0) - Error(ERR_WARN, "cannot create %s directory '%s'", text, dir); + Error(ERR_WARN, "cannot create %s directory '%s': %s", + text, dir, strerror(errno)); - posix_umask(normal_umask); /* reset normal umask */ + if (permission_class == PERMS_PUBLIC && !running_setgid) + chmod(dir, dir_mode); + + posix_umask(last_umask); /* restore previous umask */ } void InitUserDataDirectory() @@ -1328,8 +1450,14 @@ void InitUserDataDirectory() void SetFilePermissions(char *filename, int permission_class) { - chmod(filename, (permission_class == PERMS_PRIVATE ? - FILE_PERMS_PRIVATE : FILE_PERMS_PUBLIC)); + int running_setgid = posix_process_running_setgid(); + int perms = (permission_class == PERMS_PRIVATE ? + FILE_PERMS_PRIVATE : FILE_PERMS_PUBLIC); + + if (permission_class == PERMS_PUBLIC && !running_setgid) + perms |= MODE_W_ALL; + + chmod(filename, perms); } char *getCookie(char *file_type) @@ -1485,6 +1613,7 @@ SetupFileList *addListEntry(SetupFileList *list, char *token, char *value) return addListEntry(list->next, token, value); } +#if 0 #ifdef DEBUG static void printSetupFileList(SetupFileList *list) { @@ -1497,6 +1626,7 @@ static void printSetupFileList(SetupFileList *list) printSetupFileList(list->next); } #endif +#endif #ifdef DEBUG DEFINE_HASHTABLE_INSERT(insert_hash_entry, char, char); @@ -1510,7 +1640,7 @@ DEFINE_HASHTABLE_REMOVE(remove_hash_entry, char, char); #define remove_hash_entry hashtable_remove #endif -static unsigned int get_hash_from_key(void *key) +unsigned int get_hash_from_key(void *key) { /* djb2 @@ -1763,6 +1893,8 @@ boolean getTokenValueFromSetupLine(char *line, char **token, char **value) return getTokenValueFromSetupLineExt(line, token, value, NULL, NULL, 0, TRUE); } +#if 1 + #if 1 static boolean loadSetupFileData(void *setup_file_data, char *filename, boolean top_recursion_level, boolean is_hash) @@ -1772,9 +1904,8 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, char *token, *value, *line_ptr; void *insert_ptr = NULL; boolean read_continued_line = FALSE; - FILE *file; - int line_nr = 0; - int token_count = 0; + 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; @@ -1784,13 +1915,21 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, token_already_exists_warning = FALSE; #endif - if (!(file = fopen(filename, MODE_READ))) +#if 0 + Error(ERR_INFO, "===== opening file: '%s'", filename); +#endif + + if (!(file = openFile(filename, MODE_READ))) { Error(ERR_WARN, "cannot open configuration file '%s'", filename); return FALSE; } +#if 0 + Error(ERR_INFO, "===== reading file: '%s'", filename); +#endif + /* use "insert pointer" to store list end for constant insertion complexity */ if (!is_hash) insert_ptr = setup_file_data; @@ -1802,12 +1941,16 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, /* mark this file as already included (to prevent including it again) */ setHashEntry(include_filename_hash, getBaseNamePtr(filename), "true"); - while (!feof(file)) + while (!checkEndOfFile(file)) { /* read next line of input file */ - if (!fgets(line, MAX_LINE_LEN, file)) + if (!getStringFromFile(file, line, MAX_LINE_LEN)) break; +#if 0 + Error(ERR_INFO, "got line: '%s'", line); +#endif + /* check if line was completely read and is terminated by line break */ if (strlen(line) > 0 && line[strlen(line) - 1] == '\n') line_nr++; @@ -1873,6 +2016,8 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, free(basepath); free(basename); free(filename_include); + + include_count++; } else { @@ -1916,7 +2061,7 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, } } - fclose(file); + closeFile(file); #if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING if (token_value_separator_warning) @@ -1928,7 +2073,7 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, Error(ERR_INFO_LINE, "-"); #endif - if (token_count == 0) + if (token_count == 0 && include_count == 0) Error(ERR_WARN, "configuration file '%s' is empty", filename); if (top_recursion_level) @@ -1948,13 +2093,16 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, void *insert_ptr = NULL; boolean read_continued_line = FALSE; FILE *file; - int line_nr = 0; - int token_count = 0; + 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); @@ -1993,10 +2141,13 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, 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) @@ -2018,104 +2169,10 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, 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') + if (!getTokenValueFromSetupLineExt(line, &token, &value, filename, + line_raw, line_nr, FALSE)) 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 (strEqual(token, "include")) @@ -2135,6 +2192,8 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, free(basepath); free(basename); free(filename_include); + + include_count++; } else { @@ -2144,19 +2203,283 @@ static boolean loadSetupFileData(void *setup_file_data, char *filename, else { if (is_hash) - setHashEntry((SetupFileHash *)setup_file_data, token, value); - else - insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value); + { +#if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH + char *old_value = + getHashEntry((SetupFileHash *)setup_file_data, token); - token_count++; - } - } - } + 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); - fclose(file); + token_already_exists_warning = TRUE; + } -#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING - if (token_value_separator_warning) + 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 + + setHashEntry((SetupFileHash *)setup_file_data, token, value); + } + else + { + insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value); + } + + token_count++; + } + } + } + + fclose(file); + +#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; +} + +#endif + +#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 (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 + { + if (is_hash) + setHashEntry((SetupFileHash *)setup_file_data, token, value); + else + insert_ptr = addListEntry((SetupFileList *)insert_ptr, token, value); + + token_count++; + } + } + } + + fclose(file); + +#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING + if (token_value_separator_warning) Error(ERR_INFO_LINE, "-"); #endif @@ -2268,10 +2591,11 @@ void checkSetupFileHashIdentifier(SetupFileHash *setup_file_hash, #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 LEVELINFO_TOKEN_SPECIAL_FLAGS 21 +#define LEVELINFO_TOKEN_HANDICAP 22 +#define LEVELINFO_TOKEN_SKIP_LEVELS 23 -#define NUM_LEVELINFO_TOKENS 23 +#define NUM_LEVELINFO_TOKENS 24 static LevelDirTree ldi; @@ -2299,6 +2623,7 @@ static struct TokenInfo levelinfo_tokens[] = { TYPE_STRING, &ldi.music_set, "music_set" }, { TYPE_STRING, &ldi.level_filename, "filename" }, { TYPE_STRING, &ldi.level_filetype, "filetype" }, + { TYPE_STRING, &ldi.special_flags, "special_flags" }, { TYPE_BOOLEAN, &ldi.handicap, "handicap" }, { TYPE_BOOLEAN, &ldi.skip_levels, "skip_levels" } }; @@ -2375,6 +2700,8 @@ static void setTreeInfoToDefaults(TreeInfo *ti, int type) ti->level_filename = NULL; ti->level_filetype = NULL; + ti->special_flags = NULL; + ti->levels = 0; ti->first_level = 0; ti->last_level = 0; @@ -2446,12 +2773,18 @@ static void setTreeInfoToDefaultsFromParent(TreeInfo *ti, TreeInfo *parent) ti->level_filename = NULL; ti->level_filetype = NULL; + ti->special_flags = getStringCopy(parent->special_flags); + ti->levels = 0; ti->first_level = 0; ti->last_level = 0; ti->level_group = FALSE; ti->handicap_level = 0; +#if 1 + ti->readonly = parent->readonly; +#else ti->readonly = TRUE; +#endif ti->handicap = TRUE; ti->skip_levels = FALSE; } @@ -2497,6 +2830,8 @@ static TreeInfo *getTreeInfoCopy(TreeInfo *ti) ti_copy->level_filename = getStringCopy(ti->level_filename); ti_copy->level_filetype = getStringCopy(ti->level_filetype); + ti_copy->special_flags = getStringCopy(ti->special_flags); + ti_copy->levels = ti->levels; ti_copy->first_level = ti->first_level; ti_copy->last_level = ti->last_level; @@ -2521,7 +2856,7 @@ static TreeInfo *getTreeInfoCopy(TreeInfo *ti) return ti_copy; } -static void freeTreeInfo(TreeInfo *ti) +void freeTreeInfo(TreeInfo *ti) { if (ti == NULL) return; @@ -2558,8 +2893,18 @@ static void freeTreeInfo(TreeInfo *ti) checked_free(ti->level_filename); checked_free(ti->level_filetype); + + checked_free(ti->special_flags); } + // recursively free child node + if (ti->node_group) + freeTreeInfo(ti->node_group); + + // recursively free next node + if (ti->next) + freeTreeInfo(ti->next); + checked_free(ti); } @@ -2580,6 +2925,10 @@ void setSetupInfo(struct TokenInfo *token_info, *(boolean *)setup_value = get_boolean_from_string(token_value); break; + case TYPE_SWITCH3: + *(int *)setup_value = get_switch3_from_string(token_value); + break; + case TYPE_KEY: *(Key *)setup_value = getKeyFromKeyName(token_value); break; @@ -2606,7 +2955,7 @@ static int compareTreeInfoEntries(const void *object1, const void *object2) { const TreeInfo *entry1 = *((TreeInfo **)object1); const TreeInfo *entry2 = *((TreeInfo **)object2); - int class_sorting1, class_sorting2; + int class_sorting1 = 0, class_sorting2 = 0; int compare_result; if (entry1->type == TREE_TYPE_LEVEL_DIR) @@ -2614,7 +2963,9 @@ static int compareTreeInfoEntries(const void *object1, const void *object2) class_sorting1 = LEVELSORTING(entry1); class_sorting2 = LEVELSORTING(entry2); } - else + else if (entry1->type == TREE_TYPE_GRAPHICS_DIR || + entry1->type == TREE_TYPE_SOUNDS_DIR || + entry1->type == TREE_TYPE_MUSIC_DIR) { class_sorting1 = ARTWORKSORTING(entry1); class_sorting2 = ARTWORKSORTING(entry2); @@ -2729,14 +3080,18 @@ static char *getCacheToken(char *prefix, char *suffix) return token; } -static char *getFileTimestamp(char *filename) +static char *getFileTimestampString(char *filename) { +#if 1 + return getStringCopy(i_to_a(getFileTimestampEpochSeconds(filename))); +#else 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)); +#endif } static boolean modifiedFileTimestamp(char *filename, char *timestamp_string) @@ -2853,8 +3208,8 @@ static void setArtworkInfoCacheEntry(TreeInfo *artwork_info, LEVELINFO_FILENAME); char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info), ARTWORKINFO_FILENAME(type)); - char *timestamp_levelinfo = getFileTimestamp(filename_levelinfo); - char *timestamp_artworkinfo = getFileTimestamp(filename_artworkinfo); + char *timestamp_levelinfo = getFileTimestampString(filename_levelinfo); + char *timestamp_artworkinfo = getFileTimestampString(filename_artworkinfo); token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO"); setHashEntry(artworkinfo_cache_new, token_main, timestamp_levelinfo); @@ -2892,8 +3247,10 @@ static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first, char *level_directory, char *directory_name) { - static unsigned long progress_delay = 0; - unsigned long progress_delay_value = 100; /* (in milliseconds) */ +#if 0 + static unsigned int progress_delay = 0; + unsigned int 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; @@ -2971,6 +3328,12 @@ static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first, leveldir_new->in_user_dir = (!strEqual(leveldir_new->basepath, options.level_directory)); +#if 0 + printf("::: '%s' -> %d\n", + leveldir_new->identifier, + leveldir_new->in_user_dir); +#endif + /* adjust some settings if user's private level directory was detected */ if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED && leveldir_new->in_user_dir && @@ -2994,9 +3357,14 @@ static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first, 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 @@ -3037,6 +3405,101 @@ static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first, return TRUE; } +#if 1 +static void LoadLevelInfoFromLevelDir(TreeInfo **node_first, + TreeInfo *node_parent, + char *level_directory) +{ + Directory *dir; + DirectoryEntry *dir_entry; + boolean valid_entry_found = FALSE; + +#if 0 + Error(ERR_INFO, "looking for levels in '%s' ...", level_directory); +#endif + + if ((dir = openDirectory(level_directory)) == NULL) + { + Error(ERR_WARN, "cannot read level directory '%s'", level_directory); + + return; + } + +#if 0 + Error(ERR_INFO, "opening '%s' succeeded ...", level_directory); +#endif + + while ((dir_entry = readDirectory(dir)) != NULL) /* loop all entries */ + { + char *directory_name = dir_entry->basename; + char *directory_path = getPath2(level_directory, directory_name); + +#if 0 + Error(ERR_INFO, "checking entry '%s' ...", directory_name); +#endif + + /* skip entries for current and parent directory */ + if (strEqual(directory_name, ".") || + strEqual(directory_name, "..")) + { + free(directory_path); + + continue; + } + +#if 1 + /* find out if directory entry is itself a directory */ + if (!dir_entry->is_directory) /* not a directory */ + { + free(directory_path); + +#if 0 + Error(ERR_INFO, "* entry '%s' is not a directory ...", directory_name); +#endif + + continue; + } +#else + /* find out if directory entry is itself a directory */ + struct stat file_status; + if (stat(directory_path, &file_status) != 0 || /* cannot stat file */ + (file_status.st_mode & S_IFMT) != S_IFDIR) /* not a directory */ + { + free(directory_path); + + continue; + } +#endif + + free(directory_path); + + if (strEqual(directory_name, GRAPHICS_DIRECTORY) || + strEqual(directory_name, SOUNDS_DIRECTORY) || + strEqual(directory_name, MUSIC_DIRECTORY)) + continue; + + valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent, + level_directory, + directory_name); + } + + closeDirectory(dir); + + /* special case: top level directory may directly contain "levelinfo.conf" */ + if (node_parent == NULL && !valid_entry_found) + { + /* check if this directory directly contains a file "levelinfo.conf" */ + valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent, + level_directory, "."); + } + + if (!valid_entry_found) + Error(ERR_WARN, "cannot find any valid level series in directory '%s'", + level_directory); +} + +#else + static void LoadLevelInfoFromLevelDir(TreeInfo **node_first, TreeInfo *node_parent, char *level_directory) @@ -3045,18 +3508,31 @@ static void LoadLevelInfoFromLevelDir(TreeInfo **node_first, struct dirent *dir_entry; boolean valid_entry_found = FALSE; +#if 1 + Error(ERR_INFO, "looking for levels in '%s' ...", level_directory); +#endif + if ((dir = opendir(level_directory)) == NULL) { Error(ERR_WARN, "cannot read level directory '%s'", level_directory); + return; } +#if 1 + Error(ERR_INFO, "opening '%s' succeeded ...", level_directory); +#endif + while ((dir_entry = readdir(dir)) != NULL) /* loop until last dir entry */ { struct stat file_status; char *directory_name = dir_entry->d_name; char *directory_path = getPath2(level_directory, directory_name); +#if 1 + Error(ERR_INFO, "checking entry '%s' ...", directory_name); +#endif + /* skip entries for current and parent directory */ if (strEqual(directory_name, ".") || strEqual(directory_name, "..")) @@ -3099,6 +3575,7 @@ static void LoadLevelInfoFromLevelDir(TreeInfo **node_first, Error(ERR_WARN, "cannot find any valid level series in directory '%s'", level_directory); } +#endif boolean AdjustGraphicsForEMC() { @@ -3119,28 +3596,176 @@ void LoadLevelInfo() LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory); LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL)); - /* after loading all level set information, clone the level directory tree - and remove all level sets without levels (these may still contain artwork - to be offered in the setup menu as "custom artwork", and are therefore - checked for existing artwork in the function "LoadLevelArtworkInfo()") */ - leveldir_first_all = leveldir_first; - cloneTree(&leveldir_first, leveldir_first_all, TRUE); + /* after loading all level set information, clone the level directory tree + and remove all level sets without levels (these may still contain artwork + to be offered in the setup menu as "custom artwork", and are therefore + checked for existing artwork in the function "LoadLevelArtworkInfo()") */ + leveldir_first_all = leveldir_first; + cloneTree(&leveldir_first, leveldir_first_all, TRUE); + + AdjustGraphicsForEMC(); + + /* before sorting, the first entries will be from the user directory */ + leveldir_current = getFirstValidTreeInfoEntry(leveldir_first); + + if (leveldir_first == NULL) + Error(ERR_EXIT, "cannot find any valid level series in any directory"); + + sortTreeInfo(&leveldir_first); + +#if 0 + dumpTreeInfo(leveldir_first, 0); +#endif +} + +#if 1 + +static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first, + TreeInfo *node_parent, + char *base_directory, + char *directory_name, int type) +{ + char *directory_path = getPath2(base_directory, directory_name); + char *filename = getPath2(directory_path, ARTWORKINFO_FILENAME(type)); + SetupFileHash *setup_file_hash = NULL; + TreeInfo *artwork_new = NULL; + int i; + + if (fileExists(filename)) + setup_file_hash = loadSetupFileHash(filename); + + if (setup_file_hash == NULL) /* no config file -- look for artwork files */ + { + Directory *dir; + DirectoryEntry *dir_entry; + boolean valid_file_found = FALSE; + + if ((dir = openDirectory(directory_path)) != NULL) + { + while ((dir_entry = readDirectory(dir)) != NULL) + { + char *entry_name = dir_entry->basename; + + if (FileIsArtworkType(entry_name, type)) + { + valid_file_found = TRUE; + + break; + } + } + + closeDirectory(dir); + } + + if (!valid_file_found) + { + if (!strEqual(directory_name, ".")) + Error(ERR_WARN, "ignoring artwork directory '%s'", directory_path); + + free(directory_path); + free(filename); + + return FALSE; + } + } + + artwork_new = newTreeInfo(); + + if (node_parent) + setTreeInfoToDefaultsFromParent(artwork_new, node_parent); + else + setTreeInfoToDefaults(artwork_new, type); + + artwork_new->subdir = getStringCopy(directory_name); + + if (setup_file_hash) /* (before defining ".color" and ".class_desc") */ + { +#if 0 + checkSetupFileHashIdentifier(setup_file_hash, filename, getCookie("...")); +#endif + + /* set all structure fields according to the token/value pairs */ + ldi = *artwork_new; + for (i = 0; i < NUM_LEVELINFO_TOKENS; i++) + setSetupInfo(levelinfo_tokens, i, + getHashEntry(setup_file_hash, levelinfo_tokens[i].text)); + *artwork_new = ldi; + + if (strEqual(artwork_new->name, ANONYMOUS_NAME)) + setString(&artwork_new->name, artwork_new->subdir); + + if (artwork_new->identifier == NULL) + artwork_new->identifier = getStringCopy(artwork_new->subdir); + + if (artwork_new->name_sorting == NULL) + artwork_new->name_sorting = getStringCopy(artwork_new->name); + } + + if (node_parent == NULL) /* top level group */ + { + artwork_new->basepath = getStringCopy(base_directory); + artwork_new->fullpath = getStringCopy(artwork_new->subdir); + } + else /* sub level group */ + { + artwork_new->basepath = getStringCopy(node_parent->basepath); + artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name); + } + + artwork_new->in_user_dir = + (!strEqual(artwork_new->basepath, OPTIONS_ARTWORK_DIRECTORY(type))); + + /* (may use ".sort_priority" from "setup_file_hash" above) */ + artwork_new->color = ARTWORKCOLOR(artwork_new); - AdjustGraphicsForEMC(); + setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new)); - /* before sorting, the first entries will be from the user directory */ - leveldir_current = getFirstValidTreeInfoEntry(leveldir_first); + if (setup_file_hash == NULL) /* (after determining ".user_defined") */ + { + if (strEqual(artwork_new->subdir, ".")) + { + if (artwork_new->user_defined) + { + setString(&artwork_new->identifier, "private"); + artwork_new->sort_priority = ARTWORKCLASS_PRIVATE; + } + else + { + setString(&artwork_new->identifier, "classic"); + artwork_new->sort_priority = ARTWORKCLASS_CLASSICS; + } - if (leveldir_first == NULL) - Error(ERR_EXIT, "cannot find any valid level series in any directory"); + /* set to new values after changing ".sort_priority" */ + artwork_new->color = ARTWORKCOLOR(artwork_new); - sortTreeInfo(&leveldir_first); + setString(&artwork_new->class_desc, + getLevelClassDescription(artwork_new)); + } + else + { + setString(&artwork_new->identifier, artwork_new->subdir); + } + + setString(&artwork_new->name, artwork_new->identifier); + setString(&artwork_new->name_sorting, artwork_new->name); + } #if 0 - dumpTreeInfo(leveldir_first, 0); + DrawInitText(artwork_new->name, 150, FC_YELLOW); #endif + + pushTreeInfo(node_first, artwork_new); + + freeSetupFileHash(setup_file_hash); + + free(directory_path); + free(filename); + + return TRUE; } +#else + static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first, TreeInfo *node_parent, char *base_directory, @@ -3284,6 +3909,82 @@ static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first, return TRUE; } +#endif + +#if 1 + +static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first, + TreeInfo *node_parent, + char *base_directory, int type) +{ + Directory *dir; + DirectoryEntry *dir_entry; + boolean valid_entry_found = FALSE; + + if ((dir = openDirectory(base_directory)) == NULL) + { + /* display error if directory is main "options.graphics_directory" etc. */ + if (base_directory == OPTIONS_ARTWORK_DIRECTORY(type)) + Error(ERR_WARN, "cannot read directory '%s'", base_directory); + + return; + } + + while ((dir_entry = readDirectory(dir)) != NULL) /* loop all entries */ + { + char *directory_name = dir_entry->basename; + char *directory_path = getPath2(base_directory, directory_name); + + /* skip directory entries for current and parent directory */ + if (strEqual(directory_name, ".") || + strEqual(directory_name, "..")) + { + free(directory_path); + + continue; + } + +#if 1 + /* skip directory entries which are not a directory */ + if (!dir_entry->is_directory) /* not a directory */ + { + free(directory_path); + + continue; + } +#else + /* skip directory entries which are not a directory or are not accessible */ + struct stat file_status; + if (stat(directory_path, &file_status) != 0 || /* cannot stat file */ + (file_status.st_mode & S_IFMT) != S_IFDIR) /* not a directory */ + { + free(directory_path); + + continue; + } +#endif + + free(directory_path); + + /* check if this directory contains artwork with or without config file */ + valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent, + base_directory, + directory_name, type); + } + + closeDirectory(dir); + + /* check if this directory directly contains artwork itself */ + valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first, node_parent, + base_directory, ".", + type); + if (!valid_entry_found) + Error(ERR_WARN, "cannot find any valid artwork in directory '%s'", + base_directory); +} + +#else + static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first, TreeInfo *node_parent, char *base_directory, int type) @@ -3342,6 +4043,8 @@ static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first, base_directory); } +#endif + static TreeInfo *getDummyArtworkInfo(int type) { /* this is only needed when there is completely no artwork available */ @@ -3399,7 +4102,7 @@ void LoadArtworkInfo() getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set); if (artwork.gfx_current == NULL) artwork.gfx_current = - getTreeInfoFromIdentifier(artwork.gfx_first, GFX_CLASSIC_SUBDIR); + getTreeInfoFromIdentifier(artwork.gfx_first, GFX_DEFAULT_SUBDIR); if (artwork.gfx_current == NULL) artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first); @@ -3407,7 +4110,7 @@ void LoadArtworkInfo() getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set); if (artwork.snd_current == NULL) artwork.snd_current = - getTreeInfoFromIdentifier(artwork.snd_first, SND_CLASSIC_SUBDIR); + getTreeInfoFromIdentifier(artwork.snd_first, SND_DEFAULT_SUBDIR); if (artwork.snd_current == NULL) artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first); @@ -3415,7 +4118,7 @@ void LoadArtworkInfo() getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set); if (artwork.mus_current == NULL) artwork.mus_current = - getTreeInfoFromIdentifier(artwork.mus_first, MUS_CLASSIC_SUBDIR); + getTreeInfoFromIdentifier(artwork.mus_first, MUS_DEFAULT_SUBDIR); if (artwork.mus_current == NULL) artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first); @@ -3443,8 +4146,10 @@ void LoadArtworkInfo() void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node, LevelDirTree *level_node) { - static unsigned long progress_delay = 0; - unsigned long progress_delay_value = 100; /* (in milliseconds) */ +#if 0 + static unsigned int progress_delay = 0; + unsigned int progress_delay_value = 100; /* (in milliseconds) */ +#endif int type = (*artwork_node)->type; /* recursively check all level directories for artwork sub-directories */ @@ -3490,6 +4195,9 @@ void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node, } #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); @@ -3504,14 +4212,23 @@ void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node, void LoadLevelArtworkInfo() { + print_timestamp_init("LoadLevelArtworkInfo"); + DrawInitText("Looking for custom level artwork", 120, FC_GREEN); + print_timestamp_time("DrawTimeText"); + LoadArtworkInfoFromLevelInfo(&artwork.gfx_first, leveldir_first_all); + print_timestamp_time("LoadArtworkInfoFromLevelInfo (gfx)"); LoadArtworkInfoFromLevelInfo(&artwork.snd_first, leveldir_first_all); + print_timestamp_time("LoadArtworkInfoFromLevelInfo (snd)"); LoadArtworkInfoFromLevelInfo(&artwork.mus_first, leveldir_first_all); + print_timestamp_time("LoadArtworkInfoFromLevelInfo (mus)"); SaveArtworkInfoCache(); + print_timestamp_time("SaveArtworkInfoCache"); + /* needed for reloading level artwork not known at ealier stage */ if (!strEqual(artwork.gfx_current_identifier, setup.graphics_set)) @@ -3520,7 +4237,7 @@ void LoadLevelArtworkInfo() getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set); if (artwork.gfx_current == NULL) artwork.gfx_current = - getTreeInfoFromIdentifier(artwork.gfx_first, GFX_CLASSIC_SUBDIR); + getTreeInfoFromIdentifier(artwork.gfx_first, GFX_DEFAULT_SUBDIR); if (artwork.gfx_current == NULL) artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first); } @@ -3531,7 +4248,7 @@ void LoadLevelArtworkInfo() getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set); if (artwork.snd_current == NULL) artwork.snd_current = - getTreeInfoFromIdentifier(artwork.snd_first, SND_CLASSIC_SUBDIR); + getTreeInfoFromIdentifier(artwork.snd_first, SND_DEFAULT_SUBDIR); if (artwork.snd_current == NULL) artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first); } @@ -3542,20 +4259,26 @@ void LoadLevelArtworkInfo() getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set); if (artwork.mus_current == NULL) artwork.mus_current = - getTreeInfoFromIdentifier(artwork.mus_first, MUS_CLASSIC_SUBDIR); + getTreeInfoFromIdentifier(artwork.mus_first, MUS_DEFAULT_SUBDIR); if (artwork.mus_current == NULL) artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first); } + print_timestamp_time("getTreeInfoFromIdentifier"); + sortTreeInfo(&artwork.gfx_first); sortTreeInfo(&artwork.snd_first); sortTreeInfo(&artwork.mus_first); + print_timestamp_time("sortTreeInfo"); + #if 0 dumpTreeInfo(artwork.gfx_first, 0); dumpTreeInfo(artwork.snd_first, 0); dumpTreeInfo(artwork.mus_first, 0); #endif + + print_timestamp_done("LoadLevelArtworkInfo"); } static void SaveUserLevelInfo() @@ -3630,10 +4353,20 @@ char *getSetupValue(int type, void *value) strcpy(value_string, (*(boolean *)value ? "on" : "off")); break; + case TYPE_SWITCH3: + strcpy(value_string, (*(int *)value == AUTO ? "auto" : + *(int *)value == FALSE ? "off" : "on")); + break; + case TYPE_YES_NO: strcpy(value_string, (*(boolean *)value ? "yes" : "no")); break; + case TYPE_YES_NO_AUTO: + strcpy(value_string, (*(int *)value == AUTO ? "auto" : + *(int *)value == FALSE ? "no" : "yes")); + break; + case TYPE_ECS_AGA: strcpy(value_string, (*(boolean *)value ? "AGA" : "ECS")); break; @@ -3718,6 +4451,13 @@ void LoadLevelSetup_LastSeries() /* always start with reliable default values */ leveldir_current = getFirstValidTreeInfoEntry(leveldir_first); +#if defined(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 = @@ -3739,12 +4479,16 @@ void LoadLevelSetup_LastSeries() free(filename); } -void SaveLevelSetup_LastSeries() +static void SaveLevelSetup_LastSeries_Ext(boolean deactivate_last_level_series) { /* ----------------------------------------------------------------------- */ /* ~/./levelsetup.conf */ /* ----------------------------------------------------------------------- */ + // check if the current level directory structure is available at this point + if (leveldir_current == NULL) + return; + char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME); char *level_subdir = leveldir_current->subdir; FILE *file; @@ -3754,12 +4498,18 @@ void SaveLevelSetup_LastSeries() if (!(file = fopen(filename, MODE_WRITE))) { Error(ERR_WARN, "cannot write setup file '%s'", filename); + free(filename); + return; } fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_FILE_IDENTIFIER, getCookie("LEVELSETUP"))); + + if (deactivate_last_level_series) + fprintf(file, "# %s\n# ", "the following level set may have caused a problem and was deactivated"); + fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES, level_subdir)); @@ -3770,11 +4520,81 @@ void SaveLevelSetup_LastSeries() free(filename); } +void SaveLevelSetup_LastSeries() +{ + SaveLevelSetup_LastSeries_Ext(FALSE); +} + +void SaveLevelSetup_LastSeries_Deactivate() +{ + SaveLevelSetup_LastSeries_Ext(TRUE); +} + +#if 1 + +static void checkSeriesInfo() +{ + static char *level_directory = NULL; + Directory *dir; +#if 0 + DirectoryEntry *dir_entry; +#endif + + /* check for more levels besides the 'levels' field of 'levelinfo.conf' */ + + level_directory = getPath2((leveldir_current->in_user_dir ? + getUserLevelDir(NULL) : + options.level_directory), + leveldir_current->fullpath); + + if ((dir = openDirectory(level_directory)) == NULL) + { + Error(ERR_WARN, "cannot read level directory '%s'", level_directory); + + return; + } + +#if 0 + while ((dir_entry = readDirectory(dir)) != NULL) /* last directory entry */ + { + if (strlen(dir_entry->basename) > 4 && + dir_entry->basename[3] == '.' && + strEqual(&dir_entry->basename[4], LEVELFILE_EXTENSION)) + { + char levelnum_str[4]; + int levelnum_value; + + strncpy(levelnum_str, dir_entry->basename, 3); + levelnum_str[3] = '\0'; + + levelnum_value = atoi(levelnum_str); + + if (levelnum_value < leveldir_current->first_level) + { + Error(ERR_WARN, "additional level %d found", levelnum_value); + leveldir_current->first_level = levelnum_value; + } + else if (levelnum_value > leveldir_current->last_level) + { + Error(ERR_WARN, "additional level %d found", levelnum_value); + leveldir_current->last_level = levelnum_value; + } + } + } +#endif + + closeDirectory(dir); +} + +#else + static void checkSeriesInfo() { static char *level_directory = NULL; DIR *dir; +#if 0 struct dirent *dir_entry; +#endif /* check for more levels besides the 'levels' field of 'levelinfo.conf' */ @@ -3786,9 +4606,11 @@ static void checkSeriesInfo() if ((dir = opendir(level_directory)) == NULL) { Error(ERR_WARN, "cannot read level directory '%s'", level_directory); + return; } +#if 0 while ((dir_entry = readdir(dir)) != NULL) /* last directory entry */ { if (strlen(dir_entry->d_name) > 4 && @@ -3803,7 +4625,6 @@ static void checkSeriesInfo() levelnum_value = atoi(levelnum_str); -#if 0 if (levelnum_value < leveldir_current->first_level) { Error(ERR_WARN, "additional level %d found", levelnum_value); @@ -3814,22 +4635,31 @@ static void checkSeriesInfo() Error(ERR_WARN, "additional level %d found", levelnum_value); leveldir_current->last_level = levelnum_value; } -#endif } } +#endif closedir(dir); } +#endif + void LoadLevelSetup_SeriesInfo() { char *filename; SetupFileHash *level_setup_hash = NULL; char *level_subdir = leveldir_current->subdir; + int i; /* always start with reliable default values */ level_nr = leveldir_current->first_level; + for (i = 0; i < MAX_LEVELS; i++) + { + LevelStats_setPlayed(i, 0); + LevelStats_setSolved(i, 0); + } + checkSeriesInfo(leveldir_current); /* ----------------------------------------------------------------------- */ @@ -3844,6 +4674,8 @@ void LoadLevelSetup_SeriesInfo() { char *token_value; + /* get last played level in this level set */ + token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL); if (token_value) @@ -3856,6 +4688,8 @@ void LoadLevelSetup_SeriesInfo() level_nr = leveldir_current->last_level; } + /* get handicap level in this level set */ + token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL); if (token_value) @@ -3873,6 +4707,31 @@ void LoadLevelSetup_SeriesInfo() leveldir_current->handicap_level = level_nr; } + /* get number of played and solved levels in this level set */ + + BEGIN_HASH_ITERATION(level_setup_hash, itr) + { + char *token = HASH_ITERATION_TOKEN(itr); + char *value = HASH_ITERATION_VALUE(itr); + + if (strlen(token) == 3 && + token[0] >= '0' && token[0] <= '9' && + token[1] >= '0' && token[1] <= '9' && + token[2] >= '0' && token[2] <= '9') + { + int level_nr = atoi(token); + + if (value != NULL) + LevelStats_setPlayed(level_nr, atoi(value)); /* read 1st column */ + + value = strchr(value, ' '); + + if (value != NULL) + LevelStats_setSolved(level_nr, atoi(value)); /* read 2nd column */ + } + } + END_HASH_ITERATION(hash, itr) + checkSetupFileHashIdentifier(level_setup_hash, filename, getCookie("LEVELSETUP")); @@ -3891,6 +4750,7 @@ void SaveLevelSetup_SeriesInfo() char *level_nr_str = int2str(level_nr, 0); char *handicap_level_str = int2str(leveldir_current->handicap_level, 0); FILE *file; + int i; /* ----------------------------------------------------------------------- */ /* ~/./levelsetup//levelsetup.conf */ @@ -3911,8 +4771,24 @@ void SaveLevelSetup_SeriesInfo() getCookie("LEVELSETUP"))); fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_PLAYED_LEVEL, level_nr_str)); - fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL, - handicap_level_str)); + fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_HANDICAP_LEVEL, + handicap_level_str)); + + for (i = leveldir_current->first_level; i <= leveldir_current->last_level; + i++) + { + if (LevelStats_getPlayed(i) > 0 || + LevelStats_getSolved(i) > 0) + { + char token[16]; + char value[16]; + + sprintf(token, "%03d", i); + sprintf(value, "%d %d", LevelStats_getPlayed(i), LevelStats_getSolved(i)); + + fprintf(file, "%s\n", getFormattedSetupEntry(token, value)); + } + } fclose(file); @@ -3920,3 +4796,37 @@ void SaveLevelSetup_SeriesInfo() free(filename); } + +int LevelStats_getPlayed(int nr) +{ + return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].played : 0); +} + +int LevelStats_getSolved(int nr) +{ + return (nr >= 0 && nr < MAX_LEVELS ? level_stats[nr].solved : 0); +} + +void LevelStats_setPlayed(int nr, int value) +{ + if (nr >= 0 && nr < MAX_LEVELS) + level_stats[nr].played = value; +} + +void LevelStats_setSolved(int nr, int value) +{ + if (nr >= 0 && nr < MAX_LEVELS) + level_stats[nr].solved = value; +} + +void LevelStats_incPlayed(int nr) +{ + if (nr >= 0 && nr < MAX_LEVELS) + level_stats[nr].played++; +} + +void LevelStats_incSolved(int nr) +{ + if (nr >= 0 && nr < MAX_LEVELS) + level_stats[nr].solved++; +}