// (c) 1995-2014 by Artsoft Entertainment
// Holger Schemel
// info@artsoft.org
-// http://www.artsoft.org/
+// https://www.artsoft.org/
// ----------------------------------------------------------------------------
// setup.c
// ============================================================================
#include "platform.h"
-#if !defined(PLATFORM_WIN32)
-#include <pwd.h>
-#include <sys/param.h>
-#endif
-
#include "setup.h"
#include "joystick.h"
#include "text.h"
#include "misc.h"
#include "hash.h"
+#include "zip/miniunz.h"
#define ENABLE_UNUSED_CODE FALSE // for currently unused functions
static SetupFileHash *artworkinfo_cache_old = NULL;
static SetupFileHash *artworkinfo_cache_new = NULL;
+static SetupFileHash *optional_tokens_hash = NULL;
static boolean use_artworkinfo_cache = TRUE;
if (score_dir == NULL)
{
if (program.global_scores)
- score_dir = getPath2(getCommonDataDir(), score_subdir);
+ score_dir = getPath2(getCommonDataDir(), score_subdir);
else
- score_dir = getPath2(getUserGameDataDir(), score_subdir);
+ score_dir = getPath2(getMainUserGameDataDir(), score_subdir);
}
if (level_subdir != NULL)
return score_dir;
}
+static char *getUserSubdir(int nr)
+{
+ static char user_subdir[16] = { 0 };
+
+ sprintf(user_subdir, "%03d", nr);
+
+ return user_subdir;
+}
+
+static char *getUserDir(int nr)
+{
+ static char *user_dir = NULL;
+ char *main_data_dir = getMainUserGameDataDir();
+ char *users_subdir = USERS_DIRECTORY;
+ char *user_subdir = getUserSubdir(nr);
+
+ checked_free(user_dir);
+
+ if (nr != -1)
+ user_dir = getPath3(main_data_dir, users_subdir, user_subdir);
+ else
+ user_dir = getPath2(main_data_dir, users_subdir);
+
+ return user_dir;
+}
+
static char *getLevelSetupDir(char *level_subdir)
{
static char *levelsetup_dir = NULL;
static char *cache_dir = NULL;
if (cache_dir == NULL)
- cache_dir = getPath2(getUserGameDataDir(), CACHE_DIRECTORY);
+ cache_dir = getPath2(getMainUserGameDataDir(), CACHE_DIRECTORY);
return cache_dir;
}
static char *network_dir = NULL;
if (network_dir == NULL)
- network_dir = getPath2(getUserGameDataDir(), NETWORK_DIRECTORY);
+ network_dir = getPath2(getMainUserGameDataDir(), NETWORK_DIRECTORY);
return network_dir;
}
-static char *getLevelDirFromTreeInfo(TreeInfo *node)
+char *getLevelDirFromTreeInfo(TreeInfo *node)
{
static char *level_dir = NULL;
char *getUserLevelDir(char *level_subdir)
{
static char *userlevel_dir = NULL;
- char *data_dir = getUserGameDataDir();
+ char *data_dir = getMainUserGameDataDir();
char *userlevel_subdir = LEVELS_DIRECTORY;
checked_free(userlevel_dir);
getDefaultMusicDir(MUS_CLASSIC_SUBDIR) : "");
}
-static char *getUserGraphicsDir(void)
+char *getUserGraphicsDir(void)
{
static char *usergraphics_dir = NULL;
if (usergraphics_dir == NULL)
- usergraphics_dir = getPath2(getUserGameDataDir(), GRAPHICS_DIRECTORY);
+ usergraphics_dir = getPath2(getMainUserGameDataDir(), GRAPHICS_DIRECTORY);
return usergraphics_dir;
}
-static char *getUserSoundsDir(void)
+char *getUserSoundsDir(void)
{
static char *usersounds_dir = NULL;
if (usersounds_dir == NULL)
- usersounds_dir = getPath2(getUserGameDataDir(), SOUNDS_DIRECTORY);
+ usersounds_dir = getPath2(getMainUserGameDataDir(), SOUNDS_DIRECTORY);
return usersounds_dir;
}
-static char *getUserMusicDir(void)
+char *getUserMusicDir(void)
{
static char *usermusic_dir = NULL;
if (usermusic_dir == NULL)
- usermusic_dir = getPath2(getUserGameDataDir(), MUSIC_DIRECTORY);
+ usermusic_dir = getPath2(getMainUserGameDataDir(), MUSIC_DIRECTORY);
return usermusic_dir;
}
{
// check if the program's main data base directory is configured
if (!strEqual(base_path, "."))
- return base_path;
+ return getStringCopy(base_path);
/* if the program is configured to start from current directory (default),
determine program package directory from program binary (some versions
char *getProgramConfigFilename(char *command_filename)
{
- char *command_filename_1 = getStringCopy(command_filename);
+ static char *config_filename_1 = NULL;
+ static char *config_filename_2 = NULL;
+ static char *config_filename_3 = NULL;
+ static boolean initialized = FALSE;
+
+ if (!initialized)
+ {
+ char *command_filename_1 = getStringCopy(command_filename);
+
+ // strip trailing executable suffix from command filename
+ if (strSuffix(command_filename_1, ".exe"))
+ command_filename_1[strlen(command_filename_1) - 4] = '\0';
- // strip trailing executable suffix from command filename
- if (strSuffix(command_filename_1, ".exe"))
- command_filename_1[strlen(command_filename_1) - 4] = '\0';
+ char *ro_base_path = getProgramMainDataPath(command_filename, RO_BASE_PATH);
+ char *conf_directory = getPath2(ro_base_path, CONF_DIRECTORY);
- char *ro_base_path = getProgramMainDataPath(command_filename, RO_BASE_PATH);
- char *conf_directory = getPath2(ro_base_path, CONF_DIRECTORY);
+ char *command_basepath = getBasePath(command_filename);
+ char *command_basename = getBaseNameNoSuffix(command_filename);
+ char *command_filename_2 = getPath2(command_basepath, command_basename);
- char *command_basepath = getBasePath(command_filename);
- char *command_basename = getBaseNameNoSuffix(command_filename);
- char *command_filename_2 = getPath2(command_basepath, command_basename);
+ config_filename_1 = getStringCat2(command_filename_1, ".conf");
+ config_filename_2 = getStringCat2(command_filename_2, ".conf");
+ config_filename_3 = getPath2(conf_directory, SETUP_FILENAME);
- char *config_filename_1 = getStringCat2(command_filename_1, ".conf");
- char *config_filename_2 = getStringCat2(command_filename_2, ".conf");
- char *config_filename_3 = getPath2(conf_directory, SETUP_FILENAME);
+ checked_free(ro_base_path);
+ checked_free(conf_directory);
+
+ checked_free(command_basepath);
+ checked_free(command_basename);
+
+ checked_free(command_filename_1);
+ checked_free(command_filename_2);
+
+ initialized = TRUE;
+ }
// 1st try: look for config file that exactly matches the binary filename
if (fileExists(config_filename_1))
{
free(filename);
- if (options.debug)
- Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)",
- basename);
+ 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)
{
free(filename);
- if (options.debug)
- Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)",
- basename);
+ 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)
{
free(filename);
- if (options.debug)
- Error(ERR_WARN, "cannot find artwork file '%s' (using fallback)",
- basename);
+ 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)
if (program.global_scores)
createDirectory(getCommonDataDir(), "common data", permissions);
else
- createDirectory(getUserGameDataDir(), "user data", permissions);
+ createDirectory(getMainUserGameDataDir(), "main user data", permissions);
createDirectory(getScoreDir(NULL), "main score", permissions);
createDirectory(getScoreDir(level_subdir), "level score", permissions);
{
if (!directoryExists(getUserLevelDir(level_subdir)))
{
- createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
+ createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
createDirectory(getUserLevelDir(NULL), "main user level", PERMS_PRIVATE);
createDirectory(getUserLevelDir(level_subdir), "user level", PERMS_PRIVATE);
- SaveUserLevelInfo();
+ if (setup.internal.create_user_levelset)
+ SaveUserLevelInfo();
}
}
{
if (!directoryExists(getNetworkLevelDir(level_subdir)))
{
- createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
+ createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
createDirectory(getNetworkDir(), "network data", PERMS_PRIVATE);
createDirectory(getNetworkLevelDir(NULL), "main network level", PERMS_PRIVATE);
createDirectory(getNetworkLevelDir(level_subdir), "network level", PERMS_PRIVATE);
static void InitCacheDirectory(void)
{
- createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
+ createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
createDirectory(getCacheDir(), "cache data", PERMS_PRIVATE);
}
return numTreeInfo(getTreeInfoFirstGroupEntry(node));
}
-int posTreeInfo(TreeInfo *node)
+int getPosFromTreeInfo(TreeInfo *node)
{
TreeInfo *node_cmp = getTreeInfoFirstGroupEntry(node);
int pos = 0;
return node_default;
}
-TreeInfo *getTreeInfoFromIdentifier(TreeInfo *node, char *identifier)
+static TreeInfo *getTreeInfoFromIdentifierExt(TreeInfo *node, char *identifier,
+ boolean include_node_groups)
{
if (identifier == NULL)
return NULL;
{
if (node->node_group)
{
- TreeInfo *node_group;
-
- node_group = getTreeInfoFromIdentifier(node->node_group, identifier);
+ if (include_node_groups && strEqual(identifier, node->identifier))
+ return node;
+ TreeInfo *node_group = getTreeInfoFromIdentifierExt(node->node_group,
+ identifier,
+ include_node_groups);
if (node_group)
return node_group;
}
return NULL;
}
+TreeInfo *getTreeInfoFromIdentifier(TreeInfo *node, char *identifier)
+{
+ return getTreeInfoFromIdentifierExt(node, identifier, FALSE);
+}
+
static TreeInfo *cloneTreeNode(TreeInfo **node_top, TreeInfo *node_parent,
TreeInfo *node, boolean skip_sets_without_levels)
{
while (node)
{
- if (node->graphics_set_ecs && !setup.prefer_aga_graphics &&
- !strEqual(node->graphics_set, node->graphics_set_ecs))
+ boolean want_ecs = (setup.prefer_aga_graphics == FALSE);
+ boolean want_aga = (setup.prefer_aga_graphics == TRUE);
+ boolean has_only_ecs = (!node->graphics_set && !node->graphics_set_aga);
+ boolean has_only_aga = (!node->graphics_set && !node->graphics_set_ecs);
+ char *graphics_set = NULL;
+
+ if (node->graphics_set_ecs && (want_ecs || has_only_ecs))
+ graphics_set = node->graphics_set_ecs;
+
+ if (node->graphics_set_aga && (want_aga || has_only_aga))
+ graphics_set = node->graphics_set_aga;
+
+ if (graphics_set && !strEqual(node->graphics_set, graphics_set))
{
- setString(&node->graphics_set, node->graphics_set_ecs);
+ setString(&node->graphics_set, graphics_set);
settings_changed = TRUE;
}
- else if (node->graphics_set_aga && setup.prefer_aga_graphics &&
- !strEqual(node->graphics_set, node->graphics_set_aga))
+
+ if (node->node_group != NULL)
+ settings_changed |= adjustTreeGraphicsForEMC(node->node_group);
+
+ node = node->next;
+ }
+
+ return settings_changed;
+}
+
+static boolean adjustTreeSoundsForEMC(TreeInfo *node)
+{
+ boolean settings_changed = FALSE;
+
+ while (node)
+ {
+ boolean want_default = (setup.prefer_lowpass_sounds == FALSE);
+ boolean want_lowpass = (setup.prefer_lowpass_sounds == TRUE);
+ boolean has_only_default = (!node->sounds_set && !node->sounds_set_lowpass);
+ boolean has_only_lowpass = (!node->sounds_set && !node->sounds_set_default);
+ char *sounds_set = NULL;
+
+ if (node->sounds_set_default && (want_default || has_only_default))
+ sounds_set = node->sounds_set_default;
+
+ if (node->sounds_set_lowpass && (want_lowpass || has_only_lowpass))
+ sounds_set = node->sounds_set_lowpass;
+
+ if (sounds_set && !strEqual(node->sounds_set, sounds_set))
{
- setString(&node->graphics_set, node->graphics_set_aga);
+ setString(&node->sounds_set, sounds_set);
settings_changed = TRUE;
}
if (node->node_group != NULL)
- settings_changed |= adjustTreeGraphicsForEMC(node->node_group);
+ settings_changed |= adjustTreeSoundsForEMC(node->node_group);
node = node->next;
}
{
int i;
- printf("Dumping TreeInfo:\n");
+ Debug("tree", "Dumping TreeInfo:");
while (node)
{
for (i = 0; i < (depth + 1) * 3; i++)
- printf(" ");
+ DebugContinued("", " ");
- printf("'%s' / '%s'\n", node->identifier, node->name);
+ DebugContinued("tree", "'%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);
+ Debug("tree", "subdir == '%s' ['%s', '%s'] [%d])",
+ node->subdir, node->fullpath, node->basepath, node->in_user_dir);
*/
if (node->node_group != NULL)
{
if ((dir = getenv("HOME")) == NULL)
{
- struct passwd *pwd;
+ dir = getUnixHomeDir();
- if ((pwd = getpwuid(getuid())) != NULL)
- dir = getStringCopy(pwd->pw_dir);
+ if (dir != NULL)
+ dir = getStringCopy(dir);
else
dir = ".";
}
return personal_data_dir;
}
-char *getUserGameDataDir(void)
+char *getMainUserGameDataDir(void)
{
- static char *user_game_data_dir = NULL;
+ static char *main_user_data_dir = NULL;
#if defined(PLATFORM_ANDROID)
- if (user_game_data_dir == NULL)
- user_game_data_dir = (char *)(SDL_AndroidGetExternalStorageState() &
+ if (main_user_data_dir == NULL)
+ main_user_data_dir = (char *)(SDL_AndroidGetExternalStorageState() &
SDL_ANDROID_EXTERNAL_STORAGE_WRITE ?
SDL_AndroidGetExternalStoragePath() :
SDL_AndroidGetInternalStoragePath());
#else
- if (user_game_data_dir == NULL)
- user_game_data_dir = getPath2(getPersonalDataDir(),
+ if (main_user_data_dir == NULL)
+ main_user_data_dir = getPath2(getPersonalDataDir(),
program.userdata_subdir);
#endif
- return user_game_data_dir;
+ return main_user_data_dir;
+}
+
+char *getUserGameDataDir(void)
+{
+ if (user.nr == 0)
+ return getMainUserGameDataDir();
+ else
+ return getUserDir(user.nr);
}
char *getSetupDir(void)
}
if (posix_mkdir(dir, dir_mode) != 0)
- Error(ERR_WARN, "cannot create %s directory '%s': %s",
- text, dir, strerror(errno));
+ Warn("cannot create %s directory '%s': %s", text, dir, strerror(errno));
if (permission_class == PERMS_PUBLIC && !running_setgid)
chmod(dir, dir_mode);
posix_umask(last_umask); // restore previous umask
}
+void InitMainUserDataDirectory(void)
+{
+ createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
+}
+
void InitUserDataDirectory(void)
{
- createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
+ createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
+
+ if (user.nr != 0)
+ {
+ createDirectory(getUserDir(-1), "users", PERMS_PRIVATE);
+ createDirectory(getUserDir(user.nr), "user data", PERMS_PRIVATE);
+ }
}
void SetFilePermissions(char *filename, int permission_class)
if (!list)
return;
- printf("token: '%s'\n", list->token);
- printf("value: '%s'\n", list->value);
+ Debug("setup:printSetupFileList", "token: '%s'", list->token);
+ Debug("setup:printSetupFileList", "value: '%s'", list->value);
printSetupFileList(list->next);
}
create_hashtable(16, 0.75, get_hash_from_key, keys_are_equal);
if (new_hash == NULL)
- Error(ERR_EXIT, "create_hashtable() failed -- out of memory");
+ Fail("create_hashtable() failed -- out of memory");
return new_hash;
}
// change value; if it does not exist, insert it as new
if (!change_hash_entry(hash, token, value_copy))
if (!insert_hash_entry(hash, getStringCopy(token), value_copy))
- Error(ERR_EXIT, "cannot insert into hash -- aborting");
+ Fail("cannot insert into hash -- aborting");
}
char *removeHashEntry(SetupFileHash *hash, char *token)
{
BEGIN_HASH_ITERATION(hash, itr)
{
- printf("token: '%s'\n", HASH_ITERATION_TOKEN(itr));
- printf("value: '%s'\n", HASH_ITERATION_VALUE(itr));
+ Debug("setup:printSetupFileHash", "token: '%s'", HASH_ITERATION_TOKEN(itr));
+ Debug("setup:printSetupFileHash", "value: '%s'", HASH_ITERATION_VALUE(itr));
}
END_HASH_ITERATION(hash, itr)
}
{
if (!token_value_separator_warning)
{
- Error(ERR_INFO_LINE, "-");
+ Debug("setup", "---");
if (filename != NULL)
{
- Error(ERR_WARN, "missing token/value separator(s) in config file:");
- Error(ERR_INFO, "- config file: '%s'", filename);
+ Debug("setup", "missing token/value separator(s) in config file:");
+ Debug("setup", "- config file: '%s'", filename);
}
else
{
- Error(ERR_WARN, "missing token/value separator(s):");
+ Debug("setup", "missing token/value separator(s):");
}
token_value_separator_warning = TRUE;
}
if (filename != NULL)
- Error(ERR_INFO, "- line %d: '%s'", line_nr, line_raw);
+ Debug("setup", "- line %d: '%s'", line_nr, line_raw);
else
- Error(ERR_INFO, "- line: '%s'", line_raw);
+ Debug("setup", "- line: '%s'", line_raw);
}
#endif
}
if (!(file = openFile(filename, MODE_READ)))
{
#if DEBUG_NO_CONFIG_FILE
- Error(ERR_DEBUG, "cannot open configuration file '%s'", filename);
+ Debug("setup", "cannot open configuration file '%s'", filename);
#endif
return FALSE;
}
else
{
- Error(ERR_WARN, "ignoring already processed file '%s'", value);
+ Warn("ignoring already processed file '%s'", value);
}
}
else
{
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);
+ Debug("setup", "---");
+ Debug("setup", "duplicate token(s) found in config file:");
+ Debug("setup", "- 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);
+ Debug("setup", "- token: '%s' (in line %d)", token, line_nr);
+ Debug("setup", " old value: '%s'", old_value);
+ Debug("setup", " new value: '%s'", value);
}
#endif
#if CHECK_TOKEN_VALUE_SEPARATOR__WARN_IF_MISSING
if (token_value_separator_warning)
- Error(ERR_INFO_LINE, "-");
+ Debug("setup", "---");
#endif
#if CHECK_TOKEN__WARN_IF_ALREADY_EXISTS_IN_HASH
if (token_already_exists_warning)
- Error(ERR_INFO_LINE, "-");
+ Debug("setup", "---");
#endif
if (token_count == 0 && include_count == 0)
- Error(ERR_WARN, "configuration file '%s' is empty", filename);
+ Warn("configuration file '%s' is empty", filename);
if (top_recursion_level)
freeSetupFileHash(include_filename_hash);
if (!(file = fopen(filename, MODE_WRITE)))
{
- Error(ERR_WARN, "cannot write configuration file '%s'", filename);
+ Warn("cannot write configuration file '%s'", filename);
return;
}
#define TOKEN_STR_LAST_LEVEL_SERIES "last_level_series"
#define TOKEN_STR_LAST_PLAYED_LEVEL "last_played_level"
#define TOKEN_STR_HANDICAP_LEVEL "handicap_level"
+#define TOKEN_STR_LAST_USER "last_user"
// level directory info
#define LEVELINFO_TOKEN_IDENTIFIER 0
#define LEVELINFO_TOKEN_GRAPHICS_SET_ECS 17
#define LEVELINFO_TOKEN_GRAPHICS_SET_AGA 18
#define LEVELINFO_TOKEN_GRAPHICS_SET 19
-#define LEVELINFO_TOKEN_SOUNDS_SET 20
-#define LEVELINFO_TOKEN_MUSIC_SET 21
-#define LEVELINFO_TOKEN_FILENAME 22
-#define LEVELINFO_TOKEN_FILETYPE 23
-#define LEVELINFO_TOKEN_SPECIAL_FLAGS 24
-#define LEVELINFO_TOKEN_HANDICAP 25
-#define LEVELINFO_TOKEN_SKIP_LEVELS 26
-
-#define NUM_LEVELINFO_TOKENS 27
+#define LEVELINFO_TOKEN_SOUNDS_SET_DEFAULT 20
+#define LEVELINFO_TOKEN_SOUNDS_SET_LOWPASS 21
+#define LEVELINFO_TOKEN_SOUNDS_SET 22
+#define LEVELINFO_TOKEN_MUSIC_SET 23
+#define LEVELINFO_TOKEN_FILENAME 24
+#define LEVELINFO_TOKEN_FILETYPE 25
+#define LEVELINFO_TOKEN_SPECIAL_FLAGS 26
+#define LEVELINFO_TOKEN_HANDICAP 27
+#define LEVELINFO_TOKEN_SKIP_LEVELS 28
+#define LEVELINFO_TOKEN_USE_EMC_TILES 29
+
+#define NUM_LEVELINFO_TOKENS 30
static LevelDirTree ldi;
{ TYPE_STRING, &ldi.graphics_set_ecs, "graphics_set.ecs" },
{ TYPE_STRING, &ldi.graphics_set_aga, "graphics_set.aga" },
{ TYPE_STRING, &ldi.graphics_set, "graphics_set" },
+ { TYPE_STRING, &ldi.sounds_set_default,"sounds_set.default" },
+ { TYPE_STRING, &ldi.sounds_set_lowpass,"sounds_set.lowpass" },
{ TYPE_STRING, &ldi.sounds_set, "sounds_set" },
{ 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" }
+ { TYPE_BOOLEAN, &ldi.skip_levels, "skip_levels" },
+ { TYPE_BOOLEAN, &ldi.use_emc_tiles, "use_emc_tiles" }
};
static struct TokenInfo artworkinfo_tokens[] =
{ -1, NULL, NULL },
};
+static char *optional_tokens[] =
+{
+ "program_title",
+ "program_copyright",
+ "program_company",
+
+ NULL
+};
+
static void setTreeInfoToDefaults(TreeInfo *ti, int type)
{
ti->type = type;
ti->graphics_set_ecs = NULL;
ti->graphics_set_aga = NULL;
ti->graphics_set = NULL;
+ ti->sounds_set_default = NULL;
+ ti->sounds_set_lowpass = NULL;
ti->sounds_set = NULL;
ti->music_set = NULL;
ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
ti->readonly = TRUE;
ti->handicap = TRUE;
ti->skip_levels = FALSE;
+
+ ti->use_emc_tiles = FALSE;
}
}
{
if (parent == NULL)
{
- Error(ERR_WARN, "setTreeInfoToDefaultsFromParent(): parent == NULL");
+ Warn("setTreeInfoToDefaultsFromParent(): parent == NULL");
setTreeInfoToDefaults(ti, TREE_TYPE_UNDEFINED);
ti->graphics_set_ecs = getStringCopy(parent->graphics_set_ecs);
ti->graphics_set_aga = getStringCopy(parent->graphics_set_aga);
ti->graphics_set = getStringCopy(parent->graphics_set);
+ ti->sounds_set_default = getStringCopy(parent->sounds_set_default);
+ ti->sounds_set_lowpass = getStringCopy(parent->sounds_set_lowpass);
ti->sounds_set = getStringCopy(parent->sounds_set);
ti->music_set = getStringCopy(parent->music_set);
ti->graphics_path = getStringCopy(UNDEFINED_FILENAME);
ti->readonly = parent->readonly;
ti->handicap = parent->handicap;
ti->skip_levels = parent->skip_levels;
+
+ ti->use_emc_tiles = parent->use_emc_tiles;
}
}
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_default = getStringCopy(ti->sounds_set_default);
+ ti_copy->sounds_set_lowpass = getStringCopy(ti->sounds_set_lowpass);
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->handicap = ti->handicap;
ti_copy->skip_levels = ti->skip_levels;
+ ti_copy->use_emc_tiles = ti->use_emc_tiles;
+
ti_copy->color = ti->color;
ti_copy->class_desc = getStringCopy(ti->class_desc);
ti_copy->handicap_level = ti->handicap_level;
checked_free(ti->graphics_set_ecs);
checked_free(ti->graphics_set_aga);
checked_free(ti->graphics_set);
+ checked_free(ti->sounds_set_default);
+ checked_free(ti->sounds_set_lowpass);
checked_free(ti->sounds_set);
checked_free(ti->music_set);
if (!use_artworkinfo_cache)
return NULL;
+ if (optional_tokens_hash == NULL)
+ {
+ int i;
+
+ // create hash from list of optional tokens (for quick access)
+ optional_tokens_hash = newSetupFileHash();
+ for (i = 0; optional_tokens[i] != NULL; i++)
+ setHashEntry(optional_tokens_hash, optional_tokens[i], "");
+ }
+
if (cached)
{
int i;
ldi = *artwork_info;
for (i = 0; artworkinfo_tokens[i].type != -1; i++)
{
- char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text);
+ char *token_suffix = artworkinfo_tokens[i].text;
+ char *token = getCacheToken(token_prefix, token_suffix);
char *value = getHashEntry(artworkinfo_cache_old, token);
+ boolean optional =
+ (getHashEntry(optional_tokens_hash, token_suffix) != NULL);
+
+ setSetupInfo(artworkinfo_tokens, i, value);
+
+ // check if cache entry for this item is mandatory, but missing
+ if (value == NULL && !optional)
+ {
+ Warn("missing cache entry '%s'", token);
- // if defined, use value from cache, else keep default value
- if (value != NULL)
- setSetupInfo(artworkinfo_tokens, i, value);
+ cached = FALSE;
+ }
}
*artwork_info = ldi;
+ }
+ if (cached)
+ {
char *filename_levelinfo = getPath2(getLevelDirFromTreeInfo(level_node),
LEVELINFO_FILENAME);
char *filename_artworkinfo = getPath2(getSetupArtworkDir(artwork_info),
// functions for loading level info and custom artwork info
// ----------------------------------------------------------------------------
+int GetZipFileTreeType(char *zip_filename)
+{
+ static char *top_dir_path = NULL;
+ static char *top_dir_conf_filename[NUM_BASE_TREE_TYPES] = { NULL };
+ static char *conf_basename[NUM_BASE_TREE_TYPES] =
+ {
+ GRAPHICSINFO_FILENAME,
+ SOUNDSINFO_FILENAME,
+ MUSICINFO_FILENAME,
+ LEVELINFO_FILENAME
+ };
+ int j;
+
+ checked_free(top_dir_path);
+ top_dir_path = NULL;
+
+ for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
+ {
+ checked_free(top_dir_conf_filename[j]);
+ top_dir_conf_filename[j] = NULL;
+ }
+
+ char **zip_entries = zip_list(zip_filename);
+
+ // check if zip file successfully opened
+ if (zip_entries == NULL || zip_entries[0] == NULL)
+ return TREE_TYPE_UNDEFINED;
+
+ // first zip file entry is expected to be top level directory
+ char *top_dir = zip_entries[0];
+
+ // check if valid top level directory found in zip file
+ if (!strSuffix(top_dir, "/"))
+ return TREE_TYPE_UNDEFINED;
+
+ // get filenames of valid configuration files in top level directory
+ for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
+ top_dir_conf_filename[j] = getStringCat2(top_dir, conf_basename[j]);
+
+ int tree_type = TREE_TYPE_UNDEFINED;
+ int e = 0;
+
+ while (zip_entries[e] != NULL)
+ {
+ // check if every zip file entry is below top level directory
+ if (!strPrefix(zip_entries[e], top_dir))
+ return TREE_TYPE_UNDEFINED;
+
+ // check if this zip file entry is a valid configuration filename
+ for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
+ {
+ if (strEqual(zip_entries[e], top_dir_conf_filename[j]))
+ {
+ // only exactly one valid configuration file allowed
+ if (tree_type != TREE_TYPE_UNDEFINED)
+ return TREE_TYPE_UNDEFINED;
+
+ tree_type = j;
+ }
+ }
+
+ e++;
+ }
+
+ return tree_type;
+}
+
+static boolean CheckZipFileForDirectory(char *zip_filename, char *directory,
+ int tree_type)
+{
+ static char *top_dir_path = NULL;
+ static char *top_dir_conf_filename = NULL;
+
+ checked_free(top_dir_path);
+ checked_free(top_dir_conf_filename);
+
+ top_dir_path = NULL;
+ top_dir_conf_filename = NULL;
+
+ char *conf_basename = (tree_type == TREE_TYPE_LEVEL_DIR ? LEVELINFO_FILENAME :
+ ARTWORKINFO_FILENAME(tree_type));
+
+ // check if valid configuration filename determined
+ if (conf_basename == NULL || strEqual(conf_basename, ""))
+ return FALSE;
+
+ char **zip_entries = zip_list(zip_filename);
+
+ // check if zip file successfully opened
+ if (zip_entries == NULL || zip_entries[0] == NULL)
+ return FALSE;
+
+ // first zip file entry is expected to be top level directory
+ char *top_dir = zip_entries[0];
+
+ // check if valid top level directory found in zip file
+ if (!strSuffix(top_dir, "/"))
+ return FALSE;
+
+ // get path of extracted top level directory
+ top_dir_path = getPath2(directory, top_dir);
+
+ // remove trailing directory separator from top level directory path
+ // (required to be able to check for file and directory in next step)
+ top_dir_path[strlen(top_dir_path) - 1] = '\0';
+
+ // check if zip file's top level directory already exists in target directory
+ if (fileExists(top_dir_path)) // (checks for file and directory)
+ return FALSE;
+
+ // get filename of configuration file in top level directory
+ top_dir_conf_filename = getStringCat2(top_dir, conf_basename);
+
+ boolean found_top_dir_conf_filename = FALSE;
+ int i = 0;
+
+ while (zip_entries[i] != NULL)
+ {
+ // check if every zip file entry is below top level directory
+ if (!strPrefix(zip_entries[i], top_dir))
+ return FALSE;
+
+ // check if this zip file entry is the configuration filename
+ if (strEqual(zip_entries[i], top_dir_conf_filename))
+ found_top_dir_conf_filename = TRUE;
+
+ i++;
+ }
+
+ // check if valid configuration filename was found in zip file
+ if (!found_top_dir_conf_filename)
+ return FALSE;
+
+ return TRUE;
+}
+
+char *ExtractZipFileIntoDirectory(char *zip_filename, char *directory,
+ int tree_type)
+{
+ boolean zip_file_valid = CheckZipFileForDirectory(zip_filename, directory,
+ tree_type);
+
+ if (!zip_file_valid)
+ {
+ Warn("zip file '%s' rejected!", zip_filename);
+
+ return NULL;
+ }
+
+ char **zip_entries = zip_extract(zip_filename, directory);
+
+ if (zip_entries == NULL)
+ {
+ Warn("zip file '%s' could not be extracted!", zip_filename);
+
+ return NULL;
+ }
+
+ Info("zip file '%s' successfully extracted!", zip_filename);
+
+ // first zip file entry contains top level directory
+ char *top_dir = zip_entries[0];
+
+ // remove trailing directory separator from top level directory
+ top_dir[strlen(top_dir) - 1] = '\0';
+
+ return top_dir;
+}
+
+static void ProcessZipFilesInDirectory(char *directory, int tree_type)
+{
+ Directory *dir;
+ DirectoryEntry *dir_entry;
+
+ if ((dir = openDirectory(directory)) == NULL)
+ {
+ // display error if directory is main "options.graphics_directory" etc.
+ if (tree_type == TREE_TYPE_LEVEL_DIR ||
+ directory == OPTIONS_ARTWORK_DIRECTORY(tree_type))
+ Warn("cannot read directory '%s'", directory);
+
+ return;
+ }
+
+ while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
+ {
+ // skip non-zip files (and also directories with zip extension)
+ if (!strSuffixLower(dir_entry->basename, ".zip") || dir_entry->is_directory)
+ continue;
+
+ char *zip_filename = getPath2(directory, dir_entry->basename);
+ char *zip_filename_extracted = getStringCat2(zip_filename, ".extracted");
+ char *zip_filename_rejected = getStringCat2(zip_filename, ".rejected");
+
+ // check if zip file hasn't already been extracted or rejected
+ if (!fileExists(zip_filename_extracted) &&
+ !fileExists(zip_filename_rejected))
+ {
+ char *top_dir = ExtractZipFileIntoDirectory(zip_filename, directory,
+ tree_type);
+ char *marker_filename = (top_dir != NULL ? zip_filename_extracted :
+ zip_filename_rejected);
+ FILE *marker_file;
+
+ // create empty file to mark zip file as extracted or rejected
+ if ((marker_file = fopen(marker_filename, MODE_WRITE)))
+ fclose(marker_file);
+
+ free(zip_filename);
+ free(zip_filename_extracted);
+ free(zip_filename_rejected);
+ }
+ }
+
+ closeDirectory(dir);
+}
+
// forward declaration for recursive call by "LoadLevelInfoFromLevelDir()"
static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
if (setup_file_hash == NULL)
{
#if DEBUG_NO_CONFIG_FILE
- Error(ERR_WARN, "ignoring level directory '%s'", directory_path);
+ Debug("setup", "ignoring level directory '%s'", directory_path);
#endif
free(directory_path);
TreeInfo *node_parent,
char *level_directory)
{
+ // ---------- 1st stage: process any level set zip files ----------
+
+ ProcessZipFilesInDirectory(level_directory, TREE_TYPE_LEVEL_DIR);
+
+ // ---------- 2nd stage: check for level set directories ----------
+
Directory *dir;
DirectoryEntry *dir_entry;
boolean valid_entry_found = FALSE;
if ((dir = openDirectory(level_directory)) == NULL)
{
- Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
+ Warn("cannot read level directory '%s'", level_directory);
return;
}
}
if (!valid_entry_found)
- Error(ERR_WARN, "cannot find any valid level series in directory '%s'",
+ Warn("cannot find any valid level series in directory '%s'",
level_directory);
}
return settings_changed;
}
+boolean AdjustSoundsForEMC(void)
+{
+ boolean settings_changed = FALSE;
+
+ settings_changed |= adjustTreeSoundsForEMC(leveldir_first_all);
+ settings_changed |= adjustTreeSoundsForEMC(leveldir_first);
+
+ return settings_changed;
+}
+
void LoadLevelInfo(void)
{
InitUserLevelDirectory(getLoginName());
cloneTree(&leveldir_first, leveldir_first_all, TRUE);
AdjustGraphicsForEMC();
+ AdjustSoundsForEMC();
// 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");
+ Fail("cannot find any valid level series in any directory");
sortTreeInfo(&leveldir_first);
{
#if DEBUG_NO_CONFIG_FILE
if (!strEqual(directory_name, "."))
- Error(ERR_WARN, "ignoring artwork directory '%s'", directory_path);
+ Debug("setup", "ignoring artwork directory '%s'", directory_path);
#endif
free(directory_path);
TreeInfo *node_parent,
char *base_directory, int type)
{
+ // ---------- 1st stage: process any artwork set zip files ----------
+
+ ProcessZipFilesInDirectory(base_directory, type);
+
+ // ---------- 2nd stage: check for artwork set directories ----------
+
Directory *dir;
DirectoryEntry *dir_entry;
boolean valid_entry_found = FALSE;
{
// 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);
+ Warn("cannot read directory '%s'", base_directory);
return;
}
base_directory, ".",
type);
if (!valid_entry_found)
- Error(ERR_WARN, "cannot find any valid artwork in directory '%s'",
- base_directory);
+ Warn("cannot find any valid artwork in directory '%s'", base_directory);
}
static TreeInfo *getDummyArtworkInfo(int type)
return artwork_new;
}
+void SetCurrentArtwork(int type)
+{
+ ArtworkDirTree **current_ptr = ARTWORK_CURRENT_PTR(artwork, type);
+ ArtworkDirTree *first_node = ARTWORK_FIRST_NODE(artwork, type);
+ char *setup_set = SETUP_ARTWORK_SET(setup, type);
+ char *default_subdir = ARTWORK_DEFAULT_SUBDIR(type);
+
+ // set current artwork to artwork configured in setup menu
+ *current_ptr = getTreeInfoFromIdentifier(first_node, setup_set);
+
+ // if not found, set current artwork to default artwork
+ if (*current_ptr == NULL)
+ *current_ptr = getTreeInfoFromIdentifier(first_node, default_subdir);
+
+ // if not found, set current artwork to first artwork in tree
+ if (*current_ptr == NULL)
+ *current_ptr = getFirstValidTreeInfoEntry(first_node);
+}
+
+void ChangeCurrentArtworkIfNeeded(int type)
+{
+ char *current_identifier = ARTWORK_CURRENT_IDENTIFIER(artwork, type);
+ char *setup_set = SETUP_ARTWORK_SET(setup, type);
+
+ if (!strEqual(current_identifier, setup_set))
+ SetCurrentArtwork(type);
+}
+
void LoadArtworkInfo(void)
{
LoadArtworkInfoCache();
artwork.mus_first = getDummyArtworkInfo(TREE_TYPE_MUSIC_DIR);
// before sorting, the first entries will be from the user directory
- artwork.gfx_current =
- getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set);
- if (artwork.gfx_current == NULL)
- artwork.gfx_current =
- getTreeInfoFromIdentifier(artwork.gfx_first, GFX_DEFAULT_SUBDIR);
- if (artwork.gfx_current == NULL)
- artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first);
-
- artwork.snd_current =
- getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set);
- if (artwork.snd_current == NULL)
- artwork.snd_current =
- getTreeInfoFromIdentifier(artwork.snd_first, SND_DEFAULT_SUBDIR);
- if (artwork.snd_current == NULL)
- artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first);
-
- artwork.mus_current =
- getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set);
- if (artwork.mus_current == NULL)
- artwork.mus_current =
- getTreeInfoFromIdentifier(artwork.mus_first, MUS_DEFAULT_SUBDIR);
- if (artwork.mus_current == NULL)
- artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first);
+ SetCurrentArtwork(ARTWORK_TYPE_GRAPHICS);
+ SetCurrentArtwork(ARTWORK_TYPE_SOUNDS);
+ SetCurrentArtwork(ARTWORK_TYPE_MUSIC);
artwork.gfx_current_identifier = artwork.gfx_current->identifier;
artwork.snd_current_identifier = artwork.snd_current->identifier;
artwork.mus_current_identifier = artwork.mus_current->identifier;
#if ENABLE_UNUSED_CODE
- printf("graphics set == %s\n\n", artwork.gfx_current_identifier);
- printf("sounds set == %s\n\n", artwork.snd_current_identifier);
- printf("music set == %s\n\n", artwork.mus_current_identifier);
+ Debug("setup:LoadArtworkInfo", "graphics set == %s",
+ artwork.gfx_current_identifier);
+ Debug("setup:LoadArtworkInfo", "sounds set == %s",
+ artwork.snd_current_identifier);
+ Debug("setup:LoadArtworkInfo", "music set == %s",
+ artwork.mus_current_identifier);
#endif
sortTreeInfo(&artwork.gfx_first);
print_timestamp_time("SaveArtworkInfoCache");
// needed for reloading level artwork not known at ealier stage
-
- if (!strEqual(artwork.gfx_current_identifier, setup.graphics_set))
- {
- artwork.gfx_current =
- getTreeInfoFromIdentifier(artwork.gfx_first, setup.graphics_set);
- if (artwork.gfx_current == NULL)
- artwork.gfx_current =
- getTreeInfoFromIdentifier(artwork.gfx_first, GFX_DEFAULT_SUBDIR);
- if (artwork.gfx_current == NULL)
- artwork.gfx_current = getFirstValidTreeInfoEntry(artwork.gfx_first);
- }
-
- if (!strEqual(artwork.snd_current_identifier, setup.sounds_set))
- {
- artwork.snd_current =
- getTreeInfoFromIdentifier(artwork.snd_first, setup.sounds_set);
- if (artwork.snd_current == NULL)
- artwork.snd_current =
- getTreeInfoFromIdentifier(artwork.snd_first, SND_DEFAULT_SUBDIR);
- if (artwork.snd_current == NULL)
- artwork.snd_current = getFirstValidTreeInfoEntry(artwork.snd_first);
- }
-
- if (!strEqual(artwork.mus_current_identifier, setup.music_set))
- {
- artwork.mus_current =
- getTreeInfoFromIdentifier(artwork.mus_first, setup.music_set);
- if (artwork.mus_current == NULL)
- artwork.mus_current =
- getTreeInfoFromIdentifier(artwork.mus_first, MUS_DEFAULT_SUBDIR);
- if (artwork.mus_current == NULL)
- artwork.mus_current = getFirstValidTreeInfoEntry(artwork.mus_first);
- }
+ ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_GRAPHICS);
+ ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_SOUNDS);
+ ChangeCurrentArtworkIfNeeded(ARTWORK_TYPE_MUSIC);
print_timestamp_time("getTreeInfoFromIdentifier");
print_timestamp_done("LoadLevelArtworkInfo");
}
-static boolean AddUserLevelSetToLevelInfoExt(char *level_subdir_new)
+static boolean AddTreeSetToTreeInfoExt(TreeInfo *tree_node_old, char *tree_dir,
+ char *tree_subdir_new, int type)
{
- // get level info tree node of first (original) user level set
- char *level_subdir_old = getLoginName();
- LevelDirTree *leveldir_old = getTreeInfoFromIdentifier(leveldir_first,
- level_subdir_old);
- if (leveldir_old == NULL) // should not happen
+ if (tree_node_old == NULL)
+ {
+ if (type == TREE_TYPE_LEVEL_DIR)
+ {
+ // get level info tree node of personal user level set
+ tree_node_old = getTreeInfoFromIdentifier(leveldir_first, getLoginName());
+
+ // this may happen if "setup.internal.create_user_levelset" is FALSE
+ // or if file "levelinfo.conf" is missing in personal user level set
+ if (tree_node_old == NULL)
+ tree_node_old = leveldir_first->node_group;
+ }
+ else
+ {
+ // get artwork info tree node of first artwork set
+ tree_node_old = ARTWORK_FIRST_NODE(artwork, type);
+ }
+ }
+
+ if (tree_dir == NULL)
+ tree_dir = TREE_USERDIR(type);
+
+ if (tree_node_old == NULL ||
+ tree_dir == NULL ||
+ tree_subdir_new == NULL) // should not happen
return FALSE;
int draw_deactivation_mask = GetDrawDeactivationMask();
// override draw deactivation mask (temporarily disable drawing)
SetDrawDeactivationMask(REDRAW_ALL);
- // load new level set config and add it next to first user level set
- LoadLevelInfoFromLevelConf(&leveldir_old->next, NULL,
- leveldir_old->basepath, level_subdir_new);
+ if (type == TREE_TYPE_LEVEL_DIR)
+ {
+ // load new level set config and add it next to first user level set
+ LoadLevelInfoFromLevelConf(&tree_node_old->next,
+ tree_node_old->node_parent,
+ tree_dir, tree_subdir_new);
+ }
+ else
+ {
+ // load new artwork set config and add it next to first artwork set
+ LoadArtworkInfoFromArtworkConf(&tree_node_old->next,
+ tree_node_old->node_parent,
+ tree_dir, tree_subdir_new, type);
+ }
// set draw deactivation mask to previous value
SetDrawDeactivationMask(draw_deactivation_mask);
- // get level info tree node of newly added user level set
- LevelDirTree *leveldir_new = getTreeInfoFromIdentifier(leveldir_first,
- level_subdir_new);
- if (leveldir_new == NULL) // should not happen
+ // get first node of level or artwork info tree
+ TreeInfo **tree_node_first = TREE_FIRST_NODE_PTR(type);
+
+ // get tree info node of newly added level or artwork set
+ TreeInfo *tree_node_new = getTreeInfoFromIdentifier(*tree_node_first,
+ tree_subdir_new);
+
+ if (tree_node_new == NULL) // should not happen
return FALSE;
// correct top link and parent node link of newly created tree node
- leveldir_new->node_top = leveldir_old->node_top;
- leveldir_new->node_parent = leveldir_old->node_parent;
+ tree_node_new->node_top = tree_node_old->node_top;
+ tree_node_new->node_parent = tree_node_old->node_parent;
- // sort level info tree to adjust position of newly added level set
- sortTreeInfo(&leveldir_first);
+ // sort tree info to adjust position of newly added tree set
+ sortTreeInfo(tree_node_first);
return TRUE;
}
+void AddTreeSetToTreeInfo(TreeInfo *tree_node, char *tree_dir,
+ char *tree_subdir_new, int type)
+{
+ if (!AddTreeSetToTreeInfoExt(tree_node, tree_dir, tree_subdir_new, type))
+ Fail("internal tree info structure corrupted -- aborting");
+}
+
void AddUserLevelSetToLevelInfo(char *level_subdir_new)
{
- if (!AddUserLevelSetToLevelInfoExt(level_subdir_new))
- Error(ERR_EXIT, "internal level set structure corrupted -- aborting");
+ AddTreeSetToTreeInfo(NULL, NULL, level_subdir_new, TREE_TYPE_LEVEL_DIR);
}
char *getArtworkIdentifierForUserLevelSet(int type)
{
char *artwork_set = getArtworkIdentifierForUserLevelSet(type);
TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
+ TreeInfo *ti = getTreeInfoFromIdentifier(artwork_first_node, artwork_set);
- return getTreeInfoFromIdentifier(artwork_first_node, artwork_set);
+ if (ti == NULL)
+ {
+ ti = getTreeInfoFromIdentifier(artwork_first_node,
+ ARTWORK_DEFAULT_SUBDIR(type));
+ if (ti == NULL)
+ Fail("cannot find default graphics -- should not happen");
+ }
+
+ return ti;
}
boolean checkIfCustomArtworkExistsForCurrentLevelSet(void)
if (!(file = fopen(filename, MODE_WRITE)))
{
- Error(ERR_WARN, "cannot write level info file '%s'", filename);
+ Warn("cannot write level info file '%s'", filename);
+
free(filename);
return FALSE;
return line;
}
+static void InitLastPlayedLevels_ParentNode(void)
+{
+ LevelDirTree **leveldir_top = &leveldir_first->node_group->next;
+ LevelDirTree *leveldir_new = NULL;
+
+ // check if parent node for last played levels already exists
+ if (strEqual((*leveldir_top)->identifier, TOKEN_STR_LAST_LEVEL_SERIES))
+ return;
+
+ leveldir_new = newTreeInfo();
+
+ setTreeInfoToDefaultsFromParent(leveldir_new, leveldir_first);
+
+ leveldir_new->level_group = TRUE;
+
+ setString(&leveldir_new->identifier, TOKEN_STR_LAST_LEVEL_SERIES);
+ setString(&leveldir_new->name, "<< (last played level sets)");
+
+ pushTreeInfo(leveldir_top, leveldir_new);
+
+ // create node to link back to current level directory
+ createParentTreeInfoNode(leveldir_new);
+}
+
+void UpdateLastPlayedLevels_TreeInfo(void)
+{
+ char **last_level_series = setup.level_setup.last_level_series;
+ boolean reset_leveldir_current = FALSE;
+ LevelDirTree *leveldir_last;
+ TreeInfo **node_new = NULL;
+ int i;
+
+ if (last_level_series[0] == NULL)
+ return;
+
+ InitLastPlayedLevels_ParentNode();
+
+ // check if current level set is from "last played" sub-tree to be rebuilt
+ reset_leveldir_current = strEqual(leveldir_current->node_parent->identifier,
+ TOKEN_STR_LAST_LEVEL_SERIES);
+
+ leveldir_last = getTreeInfoFromIdentifierExt(leveldir_first,
+ TOKEN_STR_LAST_LEVEL_SERIES,
+ TRUE);
+ if (leveldir_last == NULL)
+ return;
+
+ node_new = &leveldir_last->node_group->next;
+
+ freeTreeInfo(*node_new);
+
+ for (i = 0; last_level_series[i] != NULL; i++)
+ {
+ LevelDirTree *node_last = getTreeInfoFromIdentifier(leveldir_first,
+ last_level_series[i]);
+
+ *node_new = getTreeInfoCopy(node_last); // copy complete node
+
+ (*node_new)->node_top = &leveldir_first; // correct top node link
+ (*node_new)->node_parent = leveldir_last; // correct parent node link
+
+ (*node_new)->node_group = NULL;
+ (*node_new)->next = NULL;
+
+ (*node_new)->cl_first = -1; // force setting tree cursor
+
+ node_new = &((*node_new)->next);
+ }
+
+ if (reset_leveldir_current)
+ leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
+ last_level_series[0]);
+}
+
+static void UpdateLastPlayedLevels_List(void)
+{
+ char **last_level_series = setup.level_setup.last_level_series;
+ int pos = MAX_LEVELDIR_HISTORY - 1;
+ int i;
+
+ // search for potentially already existing entry in list of level sets
+ for (i = 0; last_level_series[i] != NULL; i++)
+ if (strEqual(last_level_series[i], leveldir_current->identifier))
+ pos = i;
+
+ // move list of level sets one entry down (using potentially free entry)
+ for (i = pos; i > 0; i--)
+ setString(&last_level_series[i], last_level_series[i - 1]);
+
+ // put last played level set at top position
+ setString(&last_level_series[0], leveldir_current->identifier);
+}
+
void LoadLevelSetup_LastSeries(void)
{
// --------------------------------------------------------------------------
char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
SetupFileHash *level_setup_hash = NULL;
+ int pos = 0;
+ int i;
// always start with reliable default values
leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
+ // start with empty history of last played level sets
+ setString(&setup.level_setup.last_level_series[0], NULL);
+
if (!strEqual(DEFAULT_LEVELSET, UNDEFINED_LEVELSET))
{
leveldir_current = getTreeInfoFromIdentifier(leveldir_first,
if (leveldir_current == NULL)
leveldir_current = getFirstValidTreeInfoEntry(leveldir_first);
+ for (i = 0; i < MAX_LEVELDIR_HISTORY; i++)
+ {
+ char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
+ LevelDirTree *leveldir_last;
+
+ sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
+
+ last_level_series = getHashEntry(level_setup_hash, token);
+
+ leveldir_last = getTreeInfoFromIdentifier(leveldir_first,
+ last_level_series);
+ if (leveldir_last != NULL)
+ setString(&setup.level_setup.last_level_series[pos++],
+ last_level_series);
+ }
+
+ setString(&setup.level_setup.last_level_series[pos], NULL);
+
freeSetupFileHash(level_setup_hash);
}
else
{
- Error(ERR_DEBUG, "using default setup values");
+ Debug("setup", "using default setup values");
}
free(filename);
if (leveldir_current == NULL)
return;
+ char **last_level_series = setup.level_setup.last_level_series;
char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
- char *level_subdir = leveldir_current->subdir;
FILE *file;
+ int i;
InitUserDataDirectory();
+ UpdateLastPlayedLevels_List();
+
if (!(file = fopen(filename, MODE_WRITE)))
{
- Error(ERR_WARN, "cannot write setup file '%s'", filename);
+ Warn("cannot write setup file '%s'", filename);
free(filename);
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));
+ fprintf(file, "%s\n\n", getFormattedSetupEntry(TOKEN_STR_LAST_LEVEL_SERIES,
+ leveldir_current->identifier));
+
+ for (i = 0; last_level_series[i] != NULL; i++)
+ {
+ char token[strlen(TOKEN_STR_LAST_LEVEL_SERIES) + 10];
+
+ sprintf(token, "%s.%03d", TOKEN_STR_LAST_LEVEL_SERIES, i);
+
+ fprintf(file, "%s\n", getFormattedSetupEntry(token, last_level_series[i]));
+ }
fclose(file);
{
static char *level_directory = NULL;
Directory *dir;
+#if 0
+ DirectoryEntry *dir_entry;
+#endif
+
+ checked_free(level_directory);
// check for more levels besides the 'levels' field of 'levelinfo.conf'
if ((dir = openDirectory(level_directory)) == NULL)
{
- Error(ERR_WARN, "cannot read level directory '%s'", level_directory);
+ Warn("cannot read level directory '%s'", level_directory);
return;
}
+#if 0
+ while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
+ {
+ 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)
+ {
+ Warn("additional level %d found", levelnum_value);
+
+ leveldir_current->first_level = levelnum_value;
+ }
+ else if (levelnum_value > leveldir_current->last_level)
+ {
+ Warn("additional level %d found", levelnum_value);
+
+ leveldir_current->last_level = levelnum_value;
+ }
+ }
+ }
+#endif
+
closeDirectory(dir);
}
}
else
{
- Error(ERR_DEBUG, "using default setup values");
+ Debug("setup", "using default setup values");
}
free(filename);
if (!(file = fopen(filename, MODE_WRITE)))
{
- Error(ERR_WARN, "cannot write setup file '%s'", filename);
+ Warn("cannot write setup file '%s'", filename);
+
free(filename);
+
return;
}
if (nr >= 0 && nr < MAX_LEVELS)
level_stats[nr].solved++;
}
+
+void LoadUserSetup(void)
+{
+ // --------------------------------------------------------------------------
+ // ~/.<program>/usersetup.conf
+ // --------------------------------------------------------------------------
+
+ char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
+ SetupFileHash *user_setup_hash = NULL;
+
+ // always start with reliable default values
+ user.nr = 0;
+
+ if ((user_setup_hash = loadSetupFileHash(filename)))
+ {
+ char *token_value;
+
+ // get last selected user number
+ token_value = getHashEntry(user_setup_hash, TOKEN_STR_LAST_USER);
+
+ if (token_value)
+ user.nr = MIN(MAX(0, atoi(token_value)), MAX_PLAYER_NAMES - 1);
+
+ freeSetupFileHash(user_setup_hash);
+ }
+ else
+ {
+ Debug("setup", "using default setup values");
+ }
+
+ free(filename);
+}
+
+void SaveUserSetup(void)
+{
+ // --------------------------------------------------------------------------
+ // ~/.<program>/usersetup.conf
+ // --------------------------------------------------------------------------
+
+ char *filename = getPath2(getMainUserGameDataDir(), USERSETUP_FILENAME);
+ FILE *file;
+
+ InitMainUserDataDirectory();
+
+ if (!(file = fopen(filename, MODE_WRITE)))
+ {
+ Warn("cannot write setup file '%s'", filename);
+
+ free(filename);
+
+ return;
+ }
+
+ fprintFileHeader(file, USERSETUP_FILENAME);
+
+ fprintf(file, "%s\n", getFormattedSetupEntry(TOKEN_STR_LAST_USER,
+ i_to_a(user.nr)));
+ fclose(file);
+
+ SetFilePermissions(filename, PERMS_PRIVATE);
+
+ free(filename);
+}