// (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 */
+#define ENABLE_UNUSED_CODE FALSE // for currently unused functions
+#define DEBUG_NO_CONFIG_FILE FALSE // for extra-verbose debug output
#define NUM_LEVELCLASS_DESC 8
"DX Boulderdash"
};
-
-#define LEVELCOLOR(n) (IS_LEVELCLASS_TUTORIAL(n) ? FC_BLUE : \
- IS_LEVELCLASS_CLASSICS(n) ? FC_RED : \
- IS_LEVELCLASS_BD(n) ? FC_YELLOW : \
- IS_LEVELCLASS_EM(n) ? FC_YELLOW : \
- IS_LEVELCLASS_SP(n) ? FC_YELLOW : \
- IS_LEVELCLASS_DX(n) ? FC_YELLOW : \
- IS_LEVELCLASS_SB(n) ? FC_YELLOW : \
- IS_LEVELCLASS_CONTRIB(n) ? FC_GREEN : \
- IS_LEVELCLASS_PRIVATE(n) ? FC_RED : \
- FC_BLUE)
-
-#define LEVELSORTING(n) (IS_LEVELCLASS_TUTORIAL(n) ? 0 : \
- IS_LEVELCLASS_CLASSICS(n) ? 1 : \
- IS_LEVELCLASS_BD(n) ? 2 : \
- IS_LEVELCLASS_EM(n) ? 3 : \
- IS_LEVELCLASS_SP(n) ? 4 : \
- IS_LEVELCLASS_DX(n) ? 5 : \
- IS_LEVELCLASS_SB(n) ? 6 : \
- IS_LEVELCLASS_CONTRIB(n) ? 7 : \
- IS_LEVELCLASS_PRIVATE(n) ? 8 : \
- 9)
-
-#define ARTWORKCOLOR(n) (IS_ARTWORKCLASS_CLASSICS(n) ? FC_RED : \
- IS_ARTWORKCLASS_CONTRIB(n) ? FC_GREEN : \
- IS_ARTWORKCLASS_PRIVATE(n) ? FC_RED : \
- IS_ARTWORKCLASS_LEVEL(n) ? FC_YELLOW : \
- FC_BLUE)
-
-#define ARTWORKSORTING(n) (IS_ARTWORKCLASS_CLASSICS(n) ? 0 : \
- IS_ARTWORKCLASS_LEVEL(n) ? 1 : \
- IS_ARTWORKCLASS_CONTRIB(n) ? 2 : \
- IS_ARTWORKCLASS_PRIVATE(n) ? 3 : \
- 9)
-
#define TOKEN_VALUE_POSITION_SHORT 32
#define TOKEN_VALUE_POSITION_DEFAULT 40
#define TOKEN_COMMENT_POSITION_DEFAULT 60
#define MAX_COOKIE_LEN 256
+#define TREE_NODE_TYPE_DEFAULT 0
+#define TREE_NODE_TYPE_PARENT 1
+#define TREE_NODE_TYPE_GROUP 2
+#define TREE_NODE_TYPE_COPY 3
+
+#define TREE_NODE_TYPE(ti) (ti->node_group ? TREE_NODE_TYPE_GROUP : \
+ ti->parent_link ? TREE_NODE_TYPE_PARENT : \
+ ti->is_copy ? TREE_NODE_TYPE_COPY : \
+ TREE_NODE_TYPE_DEFAULT)
+
static void setTreeInfoToDefaults(TreeInfo *, int);
static TreeInfo *getTreeInfoCopy(TreeInfo *ti);
static SetupFileHash *artworkinfo_cache_old = NULL;
static SetupFileHash *artworkinfo_cache_new = NULL;
+static SetupFileHash *optional_tokens_hash = NULL;
static boolean use_artworkinfo_cache = TRUE;
+static boolean update_artworkinfo_cache = FALSE;
-/* ------------------------------------------------------------------------- */
-/* file functions */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// file functions
+// ----------------------------------------------------------------------------
static char *getLevelClassDescription(TreeInfo *ti)
{
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;
return levelsetup_dir;
}
-static char *getCacheDir()
+static char *getCacheDir(void)
{
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 *getLevelDirFromTreeInfo(TreeInfo *node)
+static char *getNetworkDir(void)
+{
+ static char *network_dir = NULL;
+
+ if (network_dir == NULL)
+ network_dir = getPath2(getMainUserGameDataDir(), NETWORK_DIRECTORY);
+
+ return network_dir;
+}
+
+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);
return userlevel_dir;
}
-char *getCurrentLevelDir()
+char *getNetworkLevelDir(char *level_subdir)
+{
+ static char *network_level_dir = NULL;
+ char *data_dir = getNetworkDir();
+ char *networklevel_subdir = LEVELS_DIRECTORY;
+
+ checked_free(network_level_dir);
+
+ if (level_subdir != NULL)
+ network_level_dir = getPath3(data_dir, networklevel_subdir, level_subdir);
+ else
+ network_level_dir = getPath2(data_dir, networklevel_subdir);
+
+ return network_level_dir;
+}
+
+char *getCurrentLevelDir(void)
{
return getLevelDirFromTreeInfo(leveldir_current);
}
-char *getNewUserLevelSubdir()
+char *getNewUserLevelSubdir(void)
{
static char *new_level_subdir = NULL;
char *subdir_prefix = getLoginName();
return tape_dir;
}
-static char *getSolutionTapeDir()
+static char *getSolutionTapeDir(void)
{
static char *tape_dir = NULL;
char *data_dir = getCurrentLevelDir();
getDefaultMusicDir(MUS_CLASSIC_SUBDIR) : "");
}
-static char *getUserGraphicsDir()
+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()
+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()
+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;
}
return *artwork_set_ptr;
}
-inline static char *getLevelArtworkSet(int type)
+static char *getLevelArtworkSet(int type)
{
if (leveldir_current == NULL)
return NULL;
return LEVELDIR_ARTWORK_SET(leveldir_current, type);
}
-inline static char *getLevelArtworkDir(int type)
+static char *getLevelArtworkDir(int type)
{
if (leveldir_current == NULL)
return UNDEFINED_FILENAME;
char *getProgramMainDataPath(char *command_filename, char *base_path)
{
- /* check if the program's main data base directory is configured */
+ // 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';
+
+ 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);
+
+ config_filename_1 = getStringCat2(command_filename_1, ".conf");
+ config_filename_2 = getStringCat2(command_filename_2, ".conf");
+ config_filename_3 = getPath2(conf_directory, SETUP_FILENAME);
- // strip trailing executable suffix from command filename
- if (strSuffix(command_filename_1, ".exe"))
- command_filename_1[strlen(command_filename_1) - 4] = '\0';
+ checked_free(ro_base_path);
+ checked_free(conf_directory);
- char *ro_base_path = getProgramMainDataPath(command_filename, RO_BASE_PATH);
- char *conf_directory = getPath2(ro_base_path, CONF_DIRECTORY);
+ checked_free(command_basepath);
+ checked_free(command_basename);
- char *command_basepath = getBasePath(command_filename);
- char *command_basename = getBaseNameNoSuffix(command_filename);
- char *command_filename_2 = getPath2(command_basepath, command_basename);
+ checked_free(command_filename_1);
+ checked_free(command_filename_2);
- 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);
+ initialized = TRUE;
+ }
// 1st try: look for config file that exactly matches the binary filename
if (fileExists(config_filename_1))
checked_free(filename);
sprintf(basename, "%03d.%s", nr, SCOREFILE_EXTENSION);
- filename = getPath2(getScoreDir(leveldir_current->subdir), basename);
+
+ // used instead of "leveldir_current->subdir" (for network games)
+ filename = getPath2(getScoreDir(levelset.identifier), basename);
return filename;
}
-char *getSetupFilename()
+char *getSetupFilename(void)
{
static char *filename = NULL;
return filename;
}
-char *getDefaultSetupFilename()
+char *getDefaultSetupFilename(void)
{
return program.config_filename;
}
-char *getEditorSetupFilename()
+char *getEditorSetupFilename(void)
{
static char *filename = NULL;
return filename;
}
-char *getHelpAnimFilename()
+char *getHelpAnimFilename(void)
{
static char *filename = NULL;
return filename;
}
-char *getHelpTextFilename()
+char *getHelpTextFilename(void)
{
static char *filename = NULL;
return filename;
}
-char *getLevelSetInfoFilename()
+char *getLevelSetInfoFilename(void)
{
static char *filename = NULL;
char *basenames[] =
return NULL;
}
-char *getLevelSetTitleMessageBasename(int nr, boolean initial)
+static char *getLevelSetTitleMessageBasename(int nr, boolean initial)
{
static char basename[32];
if (!gfx.override_level_graphics)
{
- /* 1st try: look for special artwork in current level series directory */
+ // 1st try: look for special artwork in current level series directory
filename = getPath3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
if (fileExists(filename))
return filename;
free(filename);
- /* 2nd try: look for message file in current level set directory */
+ // 2nd try: look for message file in current level set directory
filename = getPath2(getCurrentLevelDir(), basename);
if (fileExists(filename))
return filename;
free(filename);
- /* check if there is special artwork configured in level series config */
+ // 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 */
+ // 3rd try: look for special artwork configured in level series config
filename = getPath2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
if (fileExists(filename))
return filename;
free(filename);
- /* take missing artwork configured in level set config from default */
+ // take missing artwork configured in level set config from default
skip_setup_artwork = TRUE;
}
}
if (!skip_setup_artwork)
{
- /* 4th try: look for special artwork in configured artwork directory */
+ // 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 */
+ // 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 */
+ // 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 */
+ return NULL; // cannot find specified artwork file anywhere
}
static char *getCorrectedArtworkBasename(char *basename)
if (!gfx.override_level_graphics)
{
- /* 1st try: look for special artwork in current level series directory */
+ // 1st try: look for special artwork in current level series directory
filename = getImg3(getCurrentLevelDir(), GRAPHICS_DIRECTORY, basename);
if (fileExists(filename))
return filename;
free(filename);
- /* check if there is special artwork configured in level series config */
+ // check if there is special artwork configured in level series config
if (getLevelArtworkSet(ARTWORK_TYPE_GRAPHICS) != NULL)
{
- /* 2nd try: look for special artwork configured in level series config */
+ // 2nd try: look for special artwork configured in level series config
filename = getImg2(getLevelArtworkDir(ARTWORK_TYPE_GRAPHICS), basename);
if (fileExists(filename))
return filename;
free(filename);
- /* take missing artwork configured in level set config from default */
+ // take missing artwork configured in level set config from default
skip_setup_artwork = TRUE;
}
}
if (!skip_setup_artwork)
{
- /* 3rd try: look for special artwork in configured artwork directory */
+ // 3rd try: look for special artwork in configured artwork directory
filename = getImg2(getSetupArtworkDir(artwork.gfx_current), basename);
if (fileExists(filename))
return filename;
free(filename);
}
- /* 4th try: look for default artwork in new default artwork directory */
+ // 4th try: look for default artwork in new default artwork directory
filename = getImg2(getDefaultGraphicsDir(GFX_DEFAULT_SUBDIR), basename);
if (fileExists(filename))
return filename;
free(filename);
- /* 5th try: look for default artwork in old default artwork directory */
+ // 5th try: look for default artwork in old default artwork directory
filename = getImg2(options.graphics_directory, basename);
if (fileExists(filename))
return filename;
{
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) */
+ // 6th try: look for fallback artwork in old default artwork directory
+ // (needed to prevent errors when trying to access unused artwork files)
filename = getImg2(options.graphics_directory, GFX_FALLBACK_FILENAME);
if (fileExists(filename))
return filename;
}
- return NULL; /* cannot find specified artwork file anywhere */
+ return NULL; // cannot find specified artwork file anywhere
}
char *getCustomSoundFilename(char *basename)
if (!gfx.override_level_sounds)
{
- /* 1st try: look for special artwork in current level series directory */
+ // 1st try: look for special artwork in current level series directory
filename = getPath3(getCurrentLevelDir(), SOUNDS_DIRECTORY, basename);
if (fileExists(filename))
return filename;
free(filename);
- /* check if there is special artwork configured in level series config */
+ // check if there is special artwork configured in level series config
if (getLevelArtworkSet(ARTWORK_TYPE_SOUNDS) != NULL)
{
- /* 2nd try: look for special artwork configured in level series config */
+ // 2nd try: look for special artwork configured in level series config
filename = getPath2(getLevelArtworkDir(TREE_TYPE_SOUNDS_DIR), basename);
if (fileExists(filename))
return filename;
free(filename);
- /* take missing artwork configured in level set config from default */
+ // take missing artwork configured in level set config from default
skip_setup_artwork = TRUE;
}
}
if (!skip_setup_artwork)
{
- /* 3rd try: look for special artwork in configured artwork directory */
+ // 3rd try: look for special artwork in configured artwork directory
filename = getPath2(getSetupArtworkDir(artwork.snd_current), basename);
if (fileExists(filename))
return filename;
free(filename);
}
- /* 4th try: look for default artwork in new default artwork directory */
+ // 4th try: look for default artwork in new default artwork directory
filename = getPath2(getDefaultSoundsDir(SND_DEFAULT_SUBDIR), basename);
if (fileExists(filename))
return filename;
free(filename);
- /* 5th try: look for default artwork in old default artwork directory */
+ // 5th try: look for default artwork in old default artwork directory
filename = getPath2(options.sounds_directory, basename);
if (fileExists(filename))
return filename;
{
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) */
+ // 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;
}
- return NULL; /* cannot find specified artwork file anywhere */
+ return NULL; // cannot find specified artwork file anywhere
}
char *getCustomMusicFilename(char *basename)
if (!gfx.override_level_music)
{
- /* 1st try: look for special artwork in current level series directory */
+ // 1st try: look for special artwork in current level series directory
filename = getPath3(getCurrentLevelDir(), MUSIC_DIRECTORY, basename);
if (fileExists(filename))
return filename;
free(filename);
- /* check if there is special artwork configured in level series config */
+ // check if there is special artwork configured in level series config
if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
{
- /* 2nd try: look for special artwork configured in level series config */
+ // 2nd try: look for special artwork configured in level series config
filename = getPath2(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR), basename);
if (fileExists(filename))
return filename;
free(filename);
- /* take missing artwork configured in level set config from default */
+ // take missing artwork configured in level set config from default
skip_setup_artwork = TRUE;
}
}
if (!skip_setup_artwork)
{
- /* 3rd try: look for special artwork in configured artwork directory */
+ // 3rd try: look for special artwork in configured artwork directory
filename = getPath2(getSetupArtworkDir(artwork.mus_current), basename);
if (fileExists(filename))
return filename;
free(filename);
}
- /* 4th try: look for default artwork in new default artwork directory */
+ // 4th try: look for default artwork in new default artwork directory
filename = getPath2(getDefaultMusicDir(MUS_DEFAULT_SUBDIR), basename);
if (fileExists(filename))
return filename;
free(filename);
- /* 5th try: look for default artwork in old default artwork directory */
+ // 5th try: look for default artwork in old default artwork directory
filename = getPath2(options.music_directory, basename);
if (fileExists(filename))
return filename;
{
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) */
+ // 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;
}
- return NULL; /* cannot find specified artwork file anywhere */
+ return NULL; // cannot find specified artwork file anywhere
}
char *getCustomArtworkFilename(char *basename, int type)
if (!gfx.override_level_music)
{
- /* 1st try: look for special artwork in current level series directory */
+ // 1st try: look for special artwork in current level series directory
directory = getPath2(getCurrentLevelDir(), MUSIC_DIRECTORY);
if (directoryExists(directory))
return directory;
free(directory);
- /* check if there is special artwork configured in level series config */
+ // check if there is special artwork configured in level series config
if (getLevelArtworkSet(ARTWORK_TYPE_MUSIC) != NULL)
{
- /* 2nd try: look for special artwork configured in level series config */
+ // 2nd try: look for special artwork configured in level series config
directory = getStringCopy(getLevelArtworkDir(TREE_TYPE_MUSIC_DIR));
if (directoryExists(directory))
return directory;
free(directory);
- /* take missing artwork configured in level set config from default */
+ // take missing artwork configured in level set config from default
skip_setup_artwork = TRUE;
}
}
if (!skip_setup_artwork)
{
- /* 3rd try: look for special artwork in configured artwork directory */
+ // 3rd try: look for special artwork in configured artwork directory
directory = getStringCopy(getSetupArtworkDir(artwork.mus_current));
if (directoryExists(directory))
return directory;
free(directory);
}
- /* 4th try: look for default artwork in new default artwork directory */
+ // 4th try: look for default artwork in new default artwork 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 */
+ // 5th try: look for default artwork in old default artwork directory
directory = getStringCopy(options.music_directory);
if (directoryExists(directory))
return directory;
- return NULL; /* cannot find specified artwork file anywhere */
+ return NULL; // cannot find specified artwork file anywhere
}
void InitTapeDirectory(char *level_subdir)
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);
}
-static void SaveUserLevelInfo();
+static void SaveUserLevelInfo(void);
void InitUserLevelDirectory(char *level_subdir)
{
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();
+ }
+}
+
+void InitNetworkLevelDirectory(char *level_subdir)
+{
+ if (!directoryExists(getNetworkLevelDir(level_subdir)))
+ {
+ 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);
}
}
createDirectory(getLevelSetupDir(level_subdir), "level setup", PERMS_PRIVATE);
}
-void InitCacheDirectory()
+static void InitCacheDirectory(void)
{
- createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
+ createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
createDirectory(getCacheDir(), "cache data", PERMS_PRIVATE);
}
-/* ------------------------------------------------------------------------- */
-/* some functions to handle lists of level and artwork directories */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// some functions to handle lists of level and artwork directories
+// ----------------------------------------------------------------------------
-TreeInfo *newTreeInfo()
+TreeInfo *newTreeInfo(void)
{
return checked_calloc(sizeof(TreeInfo));
}
*node_first = node_new;
}
+void removeTreeInfo(TreeInfo **node_first)
+{
+ TreeInfo *node_old = *node_first;
+
+ *node_first = node_old->next;
+ node_old->next = NULL;
+
+ freeTreeInfo(node_old);
+}
+
int numTreeInfo(TreeInfo *node)
{
int num = 0;
boolean validLevelSeries(TreeInfo *node)
{
- return (node != NULL && !node->node_group && !node->parent_link);
+ // in a number of cases, tree node is no valid level set
+ if (node == NULL || node->node_group || node->parent_link || node->is_copy)
+ return FALSE;
+
+ return TRUE;
+}
+
+TreeInfo *getValidLevelSeries(TreeInfo *node, TreeInfo *default_node)
+{
+ if (validLevelSeries(node))
+ return node;
+ else if (node->is_copy)
+ return getTreeInfoFromIdentifier(leveldir_first, node->identifier);
+ else
+ return getFirstValidTreeInfoEntry(default_node);
}
TreeInfo *getFirstValidTreeInfoEntry(TreeInfo *node)
if (node == NULL)
return NULL;
- if (node->node_group) /* enter level group (step down into tree) */
+ if (node->node_group) // enter level group (step down into tree)
return getFirstValidTreeInfoEntry(node->node_group);
- else if (node->parent_link) /* skip start entry of level group */
+ else if (node->parent_link) // skip start entry of level group
{
- if (node->next) /* get first real level series entry */
+ if (node->next) // get first real level series entry
return getFirstValidTreeInfoEntry(node->next);
- else /* leave empty level group and go on */
+ else // leave empty level group and go on
return getFirstValidTreeInfoEntry(node->node_parent->next);
}
- else /* this seems to be a regular level series */
+ else // this seems to be a regular level series
return node;
}
if (node == NULL)
return NULL;
- if (node->node_parent == NULL) /* top level group */
+ if (node->node_parent == NULL) // top level group
return *node->node_top;
- else /* sub level group */
+ else // sub level group
return node->node_parent->node_group;
}
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,
+ int node_type_wanted)
{
if (identifier == NULL)
return NULL;
while (node)
{
+ if (TREE_NODE_TYPE(node) == node_type_wanted &&
+ strEqual(identifier, node->identifier))
+ return node;
+
if (node->node_group)
{
- TreeInfo *node_group;
-
- node_group = getTreeInfoFromIdentifier(node->node_group, identifier);
-
+ TreeInfo *node_group = getTreeInfoFromIdentifierExt(node->node_group,
+ identifier,
+ node_type_wanted);
if (node_group)
return node_group;
}
- else if (!node->parent_link)
- {
- if (strEqual(identifier, node->identifier))
- return node;
- }
node = node->next;
}
return NULL;
}
-TreeInfo *cloneTreeNode(TreeInfo **node_top, TreeInfo *node_parent,
- TreeInfo *node, boolean skip_sets_without_levels)
+TreeInfo *getTreeInfoFromIdentifier(TreeInfo *node, char *identifier)
+{
+ return getTreeInfoFromIdentifierExt(node, identifier, TREE_NODE_TYPE_DEFAULT);
+}
+
+static TreeInfo *cloneTreeNode(TreeInfo **node_top, TreeInfo *node_parent,
+ TreeInfo *node, boolean skip_sets_without_levels)
{
TreeInfo *node_new;
return cloneTreeNode(node_top, node_parent, node->next,
skip_sets_without_levels);
- node_new = getTreeInfoCopy(node); /* copy complete node */
+ node_new = getTreeInfoCopy(node); // copy complete node
- node_new->node_top = node_top; /* correct top node link */
- node_new->node_parent = node_parent; /* correct parent node link */
+ node_new->node_top = node_top; // correct top node link
+ node_new->node_parent = node_parent; // correct parent node link
if (node->level_group)
node_new->node_group = cloneTreeNode(node_top, node_new, node->node_group,
return node_new;
}
-void cloneTree(TreeInfo **ti_new, TreeInfo *ti, boolean skip_empty_sets)
+static void cloneTree(TreeInfo **ti_new, TreeInfo *ti, boolean skip_empty_sets)
{
TreeInfo *ti_cloned = cloneTreeNode(ti_new, NULL, ti, skip_empty_sets);
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;
}
void dumpTreeInfo(TreeInfo *node, int depth)
{
+ char bullet_list[] = { '-', '*', 'o' };
int i;
- printf("Dumping TreeInfo:\n");
+ if (depth == 0)
+ Debug("tree", "Dumping TreeInfo:");
while (node)
{
- for (i = 0; i < (depth + 1) * 3; i++)
- printf(" ");
+ char bullet = bullet_list[depth % ARRAY_SIZE(bullet_list)];
- printf("'%s' / '%s'\n", node->identifier, node->name);
+ for (i = 0; i < depth * 2; i++)
+ DebugContinued("", " ");
+
+ DebugContinued("tree", "%c '%s' ['%s] [PARENT: '%s'] %s\n",
+ bullet, node->name, node->identifier,
+ (node->node_parent ? node->node_parent->identifier : "-"),
+ (node->node_group ? "[GROUP]" : ""));
/*
// 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 (num_nodes == 0)
return;
- /* allocate array for sorting structure pointers */
+ // allocate array for sorting structure pointers
sort_array = checked_calloc(num_nodes * sizeof(TreeInfo *));
- /* writing structure pointers to sorting array */
- while (i < num_nodes && node) /* double boundary check... */
+ // writing structure pointers to sorting array
+ while (i < num_nodes && node) // double boundary check...
{
sort_array[i] = node;
node = node->next;
}
- /* sorting the structure pointers in the sorting array */
+ // sorting the structure pointers in the sorting array
qsort(sort_array, num_nodes, sizeof(TreeInfo *),
compare_function);
- /* update the linkage of list elements with the sorted node array */
+ // update the linkage of list elements with the sorted node array
for (i = 0; i < num_nodes - 1; i++)
sort_array[i]->next = sort_array[i + 1];
sort_array[num_nodes - 1]->next = NULL;
- /* update the linkage of the main list anchor pointer */
+ // update the linkage of the main list anchor pointer
*node_first = sort_array[0];
free(sort_array);
- /* now recursively sort the level group structures */
+ // now recursively sort the level group structures
node = *node_first;
while (node)
{
}
-/* ========================================================================= */
-/* some stuff from "files.c" */
-/* ========================================================================= */
+// ============================================================================
+// some stuff from "files.c"
+// ============================================================================
#if defined(PLATFORM_WIN32)
#ifndef S_IRGRP
#ifndef S_ISGID
#define S_ISGID 0
#endif
-#endif /* PLATFORM_WIN32 */
+#endif // PLATFORM_WIN32
-/* file permissions for newly written files */
+// file permissions for newly written files
#define MODE_R_ALL (S_IRUSR | S_IRGRP | S_IROTH)
#define MODE_W_ALL (S_IWUSR | S_IWGRP | S_IWOTH)
#define MODE_X_ALL (S_IXUSR | S_IXGRP | S_IXOTH)
#define FILE_PERMS_PUBLIC_ALL (MODE_R_ALL | MODE_W_ALL)
-char *getHomeDir()
+char *getHomeDir(void)
{
static char *dir = NULL;
if (!SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, dir)))
strcpy(dir, ".");
}
+#elif defined(PLATFORM_EMSCRIPTEN)
+ dir = "/persistent";
#elif defined(PLATFORM_UNIX)
if (dir == 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 = ".";
}
char *dir = checked_malloc(MAX_PATH + 1);
if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, 0, dir))
- && !strEqual(dir, "")) /* empty for Windows 95/98 */
+ && !strEqual(dir, "")) // empty for Windows 95/98
common_data_dir = getPath2(dir, program.userdata_subdir);
else
common_data_dir = options.rw_base_directory;
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()
+char *getSetupDir(void)
{
return getUserGameDataDir();
}
#endif
}
-static boolean posix_process_running_setgid()
+static boolean posix_process_running_setgid(void)
{
#if defined(PLATFORM_UNIX)
return (getgid() != getegid());
if (directoryExists(dir))
return;
- /* leave "other" permissions in umask untouched, but ensure group parts
- of USERDATA_DIR_MODE are not masked */
+ // 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 last_umask = posix_umask(0);
if (permission_class == PERMS_PUBLIC)
{
- /* if we're setgid, protect files against "other" */
- /* else keep umask(0) to make the dir world-writable */
+ // 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);
}
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 */
+ posix_umask(last_umask); // restore previous umask
}
-void InitUserDataDirectory()
+void InitMainUserDataDirectory(void)
{
- createDirectory(getUserGameDataDir(), "user data", PERMS_PRIVATE);
+ createDirectory(getMainUserGameDataDir(), "main user data", PERMS_PRIVATE);
+}
+
+void InitUserDataDirectory(void)
+{
+ 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 (strlen(program.cookie_prefix) + 1 +
strlen(file_type) + strlen("_FILE_VERSION_x.x") > MAX_COOKIE_LEN)
- return "[COOKIE ERROR]"; /* should never happen */
+ return "[COOKIE ERROR]"; // should never happen
sprintf(cookie, "%s_%s_FILE_VERSION_%d.%d",
program.cookie_prefix, file_type,
- program.version_major, program.version_minor);
+ program.version_super, program.version_major);
return cookie;
}
const int len_pattern1 = strlen(pattern1);
const int len_pattern2 = strlen(pattern2);
const int len_pattern = len_pattern1 + len_pattern2;
- int version_major, version_minor;
+ int version_super, version_major;
if (len_cookie <= len_pattern)
return -1;
ptr_cookie2[2] < '0' || ptr_cookie2[2] > '9')
return -1;
- version_major = ptr_cookie2[0] - '0';
- version_minor = ptr_cookie2[2] - '0';
+ version_super = ptr_cookie2[0] - '0';
+ version_major = ptr_cookie2[2] - '0';
- return VERSION_IDENT(version_major, version_minor, 0, 0);
+ return VERSION_IDENT(version_super, version_major, 0, 0);
}
boolean checkCookieString(const char *cookie, const char *template)
}
-/* ------------------------------------------------------------------------- */
-/* setup file list and hash handling functions */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// setup file list and hash handling functions
+// ----------------------------------------------------------------------------
char *getFormattedSetupEntry(char *token, char *value)
{
int i;
static char entry[MAX_LINE_LEN];
- /* if value is an empty string, just return token without value */
+ // if value is an empty string, just return token without value
if (*value == '\0')
return token;
- /* start with the token and some spaces to format output line */
+ // start with the token and some spaces to format output line
sprintf(entry, "%s:", token);
for (i = strlen(entry); i < token_value_position; i++)
strcat(entry, " ");
- /* continue with the token's value */
+ // continue with the token's value
strcat(entry, value);
return entry;
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);
}
int c;
while ((c = *str++))
- hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+ hash = ((hash << 5) + hash) + c; // hash * 33 + c
return hash;
}
return (strEqual((char *)key1, (char *)key2));
}
-SetupFileHash *newSetupFileHash()
+SetupFileHash *newSetupFileHash(void)
{
SetupFileHash *new_hash =
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;
}
if (hash == NULL)
return;
- hashtable_destroy(hash, 1); /* 1 == also free values stored in hash */
+ hashtable_destroy(hash, 1); // 1 == also free values stored in hash
}
char *getHashEntry(SetupFileHash *hash, char *token)
value_copy = getStringCopy(value);
- /* change value; if it does not exist, insert it as new */
+ // 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)
}
static char line_copy[MAX_LINE_LEN + 1], line_raw_copy[MAX_LINE_LEN + 1];
char *token, *value, *line_ptr;
- /* when externally invoked via ReadTokenValueFromLine(), copy line buffers */
+ // when externally invoked via ReadTokenValueFromLine(), copy line buffers
if (line_raw == NULL)
{
strncpy(line_copy, line, MAX_LINE_LEN);
line_raw = line_raw_copy;
}
- /* cut trailing comment from input line */
+ // cut trailing comment from input line
for (line_ptr = line; *line_ptr; line_ptr++)
{
if (*line_ptr == '#')
}
}
- /* cut trailing whitespaces from input line */
+ // 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 */
+ // ignore empty lines
if (*line == '\0')
return FALSE;
- /* cut leading whitespaces from token */
+ // cut leading whitespaces from token
for (token = line; *token; token++)
if (*token != ' ' && *token != '\t')
break;
- /* start with empty value as reliable default */
+ // start with empty value as reliable default
value = "";
token_value_separator_found = FALSE;
- /* find end of token to determine start of value */
+ // find end of token to determine start of value
for (line_ptr = token; *line_ptr; line_ptr++)
{
- /* first look for an explicit token/value separator, like ':' or '=' */
+ // first look for an explicit token/value separator, like ':' or '='
if (*line_ptr == ':' || *line_ptr == '=')
{
- *line_ptr = '\0'; /* terminate token string */
- value = line_ptr + 1; /* set beginning of value */
+ *line_ptr = '\0'; // terminate token string
+ value = line_ptr + 1; // set beginning of value
token_value_separator_found = TRUE;
}
#if ALLOW_TOKEN_VALUE_SEPARATOR_BEING_WHITESPACE
- /* fallback: if no token/value separator found, also allow whitespaces */
+ // fallback: if no token/value separator found, also allow whitespaces
if (!token_value_separator_found && !separator_required)
{
for (line_ptr = token; *line_ptr; line_ptr++)
{
if (*line_ptr == ' ' || *line_ptr == '\t')
{
- *line_ptr = '\0'; /* terminate token string */
- value = line_ptr + 1; /* set beginning of value */
+ *line_ptr = '\0'; // terminate token string
+ value = line_ptr + 1; // set beginning of value
token_value_separator_found = TRUE;
{
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
}
#endif
- /* cut trailing whitespaces from token */
+ // 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 */
+ // cut leading whitespaces from value
for (; *value; value++)
if (*value != ' ' && *value != '\t')
break;
boolean getTokenValueFromSetupLine(char *line, char **token, char **value)
{
- /* while the internal (old) interface does not require a token/value
- separator (for downwards compatibility with existing files which
- don't use them), it is mandatory for the external (new) interface */
+ // while the internal (old) interface does not require a token/value
+ // separator (for downwards compatibility with existing files which
+ // don't use them), it is mandatory for the external (new) interface
return getTokenValueFromSetupLineExt(line, token, value, NULL, NULL, 0, TRUE);
}
if (!(file = openFile(filename, MODE_READ)))
{
- Error(ERR_DEBUG, "cannot open configuration file '%s'", filename);
+#if DEBUG_NO_CONFIG_FILE
+ Debug("setup", "cannot open configuration file '%s'", filename);
+#endif
return FALSE;
}
- /* use "insert pointer" to store list end for constant insertion complexity */
+ // 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) */
+ // 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) */
+ // mark this file as already included (to prevent including it again)
setHashEntry(include_filename_hash, getBaseNamePtr(filename), "true");
while (!checkEndOfFile(file))
{
- /* read next line of input file */
+ // read next line of input file
if (!getStringFromFile(file, line, MAX_LINE_LEN))
break;
- /* check if line was completely read and is terminated by line 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) */
+ // 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) */
+ // copy raw input line for later use (mainly debugging output)
strcpy(line_raw, line);
if (read_continued_line)
{
- /* append new line to existing line, if there is enough space */
+ // 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 */
+ strcpy(line, previous_line); // copy storage buffer to line
read_continued_line = FALSE;
}
- /* if the last character is '\', continue at next line */
+ // 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 */
+ line[strlen(line) - 1] = '\0'; // cut off trailing backslash
+ strcpy(previous_line, line); // copy line to storage buffer
read_continued_line = TRUE;
}
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);
return TRUE;
}
-void saveSetupFileHash(SetupFileHash *hash, char *filename)
+static int compareSetupFileData(const void *object1, const void *object2)
+{
+ const struct ConfigInfo *entry1 = (struct ConfigInfo *)object1;
+ const struct ConfigInfo *entry2 = (struct ConfigInfo *)object2;
+
+ return strcmp(entry1->token, entry2->token);
+}
+
+static void saveSetupFileHash(SetupFileHash *hash, char *filename)
{
+ int item_count = hashtable_count(hash);
+ int item_size = sizeof(struct ConfigInfo);
+ struct ConfigInfo *sort_array = checked_malloc(item_count * item_size);
FILE *file;
+ int i = 0;
- if (!(file = fopen(filename, MODE_WRITE)))
+ // copy string pointers from hash to array
+ BEGIN_HASH_ITERATION(hash, itr)
{
- Error(ERR_WARN, "cannot write configuration file '%s'", filename);
+ sort_array[i].token = HASH_ITERATION_TOKEN(itr);
+ sort_array[i].value = HASH_ITERATION_VALUE(itr);
- return;
+ i++;
+
+ if (i > item_count) // should never happen
+ break;
}
+ END_HASH_ITERATION(hash, itr)
- BEGIN_HASH_ITERATION(hash, itr)
+ // sort string pointers from hash in array
+ qsort(sort_array, item_count, item_size, compareSetupFileData);
+
+ if (!(file = fopen(filename, MODE_WRITE)))
{
- fprintf(file, "%s\n", getFormattedSetupEntry(HASH_ITERATION_TOKEN(itr),
- HASH_ITERATION_VALUE(itr)));
+ Warn("cannot write configuration file '%s'", filename);
+
+ return;
}
- END_HASH_ITERATION(hash, itr)
+ fprintf(file, "%s\n\n", getFormattedSetupEntry("program.version",
+ program.version_string));
+ for (i = 0; i < item_count; i++)
+ fprintf(file, "%s\n", getFormattedSetupEntry(sort_array[i].token,
+ sort_array[i].value));
fclose(file);
+
+ checked_free(sort_array);
}
SetupFileList *loadSetupFileList(char *filename)
first_valid_list_entry = setup_file_list->next;
- /* free empty list header */
+ // free empty list header
setup_file_list->next = NULL;
freeSetupFileList(setup_file_list);
}
-/* ========================================================================= */
-/* setup file stuff */
-/* ========================================================================= */
+// ============================================================================
+// setup file stuff
+// ============================================================================
#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 */
+// level directory info
#define LEVELINFO_TOKEN_IDENTIFIER 0
#define LEVELINFO_TOKEN_NAME 1
#define LEVELINFO_TOKEN_NAME_SORTING 2
#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;
static struct TokenInfo levelinfo_tokens[] =
{
- /* level directory info */
+ // level directory info
{ TYPE_STRING, &ldi.identifier, "identifier" },
{ TYPE_STRING, &ldi.name, "name" },
{ TYPE_STRING, &ldi.name_sorting, "name_sorting" },
{ 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[] =
{
- /* artwork directory info */
+ // artwork directory info
{ TYPE_STRING, &ldi.identifier, "identifier" },
{ TYPE_STRING, &ldi.subdir, "subdir" },
{ TYPE_STRING, &ldi.name, "name" },
{ TYPE_STRING, &ldi.basepath, "basepath" },
{ TYPE_STRING, &ldi.fullpath, "fullpath" },
{ TYPE_BOOLEAN, &ldi.in_user_dir, "in_user_dir" },
- { TYPE_INTEGER, &ldi.color, "color" },
{ TYPE_STRING, &ldi.class_desc, "class_desc" },
{ -1, NULL, NULL },
};
+static char *optional_tokens[] =
+{
+ "program_title",
+ "program_copyright",
+ "program_company",
+
+ NULL
+};
+
static void setTreeInfoToDefaults(TreeInfo *ti, int type)
{
ti->type = type;
ti->program_copyright = NULL;
ti->program_company = NULL;
- ti->sort_priority = LEVELCLASS_UNDEFINED; /* default: least priority */
- ti->latest_engine = FALSE; /* default: get from level */
+ ti->sort_priority = LEVELCLASS_UNDEFINED; // default: least priority
+ ti->latest_engine = FALSE; // default: get from level
ti->parent_link = FALSE;
+ ti->is_copy = FALSE;
ti->in_user_dir = FALSE;
ti->user_defined = FALSE;
ti->color = 0;
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);
return;
}
- /* copy all values from the parent structure */
+ // copy all values from the parent structure
ti->type = parent->type;
ti->sort_priority = parent->sort_priority;
ti->latest_engine = parent->latest_engine;
ti->parent_link = FALSE;
+ ti->is_copy = FALSE;
ti->in_user_dir = parent->in_user_dir;
ti->user_defined = parent->user_defined;
ti->color = parent->color;
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;
}
}
{
TreeInfo *ti_copy = newTreeInfo();
- /* copy all values from the original structure */
+ // copy all values from the original structure
ti_copy->type = ti->type;
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->level_group = ti->level_group;
ti_copy->parent_link = ti->parent_link;
+ ti_copy->is_copy = ti->is_copy;
ti_copy->in_user_dir = ti->in_user_dir;
ti_copy->user_defined = ti->user_defined;
ti_copy->readonly = ti->readonly;
ti_copy->handicap = ti->handicap;
ti_copy->skip_levels = ti->skip_levels;
+ ti_copy->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 (token_value == NULL)
return;
- /* set setup field to corresponding token value */
+ // set setup field to corresponding token value
switch (token_type)
{
case TYPE_BOOLEAN:
*(char **)setup_value = getStringCopy(token_value);
break;
+ case TYPE_PLAYER:
+ *(int *)setup_value = get_player_nr_from_string(token_value);
+ break;
+
default:
break;
}
{
const TreeInfo *entry1 = *((TreeInfo **)object1);
const TreeInfo *entry2 = *((TreeInfo **)object2);
- int class_sorting1 = 0, class_sorting2 = 0;
- int compare_result;
-
- if (entry1->type == TREE_TYPE_LEVEL_DIR)
- {
- class_sorting1 = LEVELSORTING(entry1);
- class_sorting2 = LEVELSORTING(entry2);
- }
- 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);
- }
-
- if (entry1->parent_link || entry2->parent_link)
- compare_result = (entry1->parent_link ? -1 : +1);
- else if (entry1->sort_priority == entry2->sort_priority)
- {
- char *name1 = getStringToLower(entry1->name_sorting);
- char *name2 = getStringToLower(entry2->name_sorting);
-
- compare_result = strcmp(name1, name2);
+ int tree_sorting1 = TREE_SORTING(entry1);
+ int tree_sorting2 = TREE_SORTING(entry2);
- free(name1);
- free(name2);
- }
- else if (class_sorting1 == class_sorting2)
- compare_result = entry1->sort_priority - entry2->sort_priority;
+ if (tree_sorting1 != tree_sorting2)
+ return (tree_sorting1 - tree_sorting2);
else
- compare_result = class_sorting1 - class_sorting2;
-
- return compare_result;
+ return strcasecmp(entry1->name_sorting, entry2->name_sorting);
}
static TreeInfo *createParentTreeInfoNode(TreeInfo *node_parent)
ti_new->parent_link = TRUE;
setString(&ti_new->identifier, node_parent->identifier);
- setString(&ti_new->name, ".. (parent directory)");
+ setString(&ti_new->name, BACKLINK_TEXT_PARENT);
setString(&ti_new->name_sorting, ti_new->name);
setString(&ti_new->subdir, STRING_PARENT_DIRECTORY);
setString(&ti_new->fullpath, node_parent->fullpath);
- ti_new->sort_priority = node_parent->sort_priority;
+ ti_new->sort_priority = LEVELCLASS_PARENT;
ti_new->latest_engine = node_parent->latest_engine;
setString(&ti_new->class_desc, getLevelClassDescription(ti_new));
static TreeInfo *createTopTreeInfoNode(TreeInfo *node_first)
{
- TreeInfo *ti_new, *ti_new2;
-
if (node_first == NULL)
return NULL;
- ti_new = newTreeInfo();
- setTreeInfoToDefaults(ti_new, TREE_TYPE_LEVEL_DIR);
+ TreeInfo *ti_new = newTreeInfo();
+ int type = node_first->type;
+
+ setTreeInfoToDefaults(ti_new, type);
ti_new->node_parent = NULL;
ti_new->parent_link = FALSE;
- setString(&ti_new->identifier, node_first->identifier);
- setString(&ti_new->name, "level sets");
+ setString(&ti_new->identifier, "top_tree_node");
+ setString(&ti_new->name, TREE_INFOTEXT(type));
setString(&ti_new->name_sorting, ti_new->name);
setString(&ti_new->subdir, STRING_TOP_DIRECTORY);
setString(&ti_new->fullpath, ".");
- ti_new->sort_priority = node_first->sort_priority;;
+ ti_new->sort_priority = LEVELCLASS_TOP;
ti_new->latest_engine = node_first->latest_engine;
- setString(&ti_new->class_desc, "level sets");
+ setString(&ti_new->class_desc, TREE_INFOTEXT(type));
ti_new->node_group = node_first;
ti_new->level_group = TRUE;
- ti_new2 = createParentTreeInfoNode(ti_new);
+ TreeInfo *ti_new2 = createParentTreeInfoNode(ti_new);
- setString(&ti_new2->name, ".. (main menu)");
+ setString(&ti_new2->name, TREE_BACKLINK_TEXT(type));
setString(&ti_new2->name_sorting, ti_new2->name);
return ti_new;
}
+static void setTreeInfoParentNodes(TreeInfo *node, TreeInfo *node_parent)
+{
+ while (node)
+ {
+ if (node->node_group)
+ setTreeInfoParentNodes(node->node_group, node);
+
+ node->node_parent = node_parent;
+
+ node = node->next;
+ }
+}
+
-/* -------------------------------------------------------------------------- */
-/* functions for handling level and custom artwork info cache */
-/* -------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions for handling level and custom artwork info cache
+// ----------------------------------------------------------------------------
-static void LoadArtworkInfoCache()
+static void LoadArtworkInfoCache(void)
{
InitCacheDirectory();
{
char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
- /* try to load artwork info hash from already existing cache file */
+ // try to load artwork info hash from already existing cache file
artworkinfo_cache_old = loadSetupFileHash(filename);
- /* if no artwork info cache file was found, start with empty hash */
+ // try to get program version that artwork info cache was written with
+ char *version = getHashEntry(artworkinfo_cache_old, "program.version");
+
+ // check program version of artwork info cache against current version
+ if (!strEqual(version, program.version_string))
+ {
+ freeSetupFileHash(artworkinfo_cache_old);
+
+ artworkinfo_cache_old = NULL;
+ }
+
+ // if no artwork info cache file was found, start with empty hash
if (artworkinfo_cache_old == NULL)
artworkinfo_cache_old = newSetupFileHash();
if (artworkinfo_cache_new == NULL)
artworkinfo_cache_new = newSetupFileHash();
+
+ update_artworkinfo_cache = FALSE;
}
-static void SaveArtworkInfoCache()
+static void SaveArtworkInfoCache(void)
{
+ if (!update_artworkinfo_cache)
+ return;
+
char *filename = getPath2(getCacheDir(), ARTWORKINFO_CACHE_FILE);
InitCacheDirectory();
return prefix;
}
-/* (identical to above function, but separate string buffer needed -- nasty) */
+// (identical to above function, but separate string buffer needed -- nasty)
static char *getCacheToken(char *prefix, char *suffix)
{
static char *token = NULL;
if (timestamp_string == NULL)
return TRUE;
- if (stat(filename, &file_status) != 0) /* cannot stat file */
+ if (!fileExists(filename)) // file does not exist
+ return (atoi(timestamp_string) != 0);
+
+ if (stat(filename, &file_status) != 0) // cannot stat file
return TRUE;
return (file_status.st_mtime != atoi(timestamp_string));
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;
artwork_info = newTreeInfo();
setTreeInfoToDefaults(artwork_info, type);
- /* set all structure fields according to the token/value pairs */
+ // set all structure fields according to the token/value pairs
ldi = *artwork_info;
for (i = 0; artworkinfo_tokens[i].type != -1; i++)
{
- char *token = getCacheToken(token_prefix, artworkinfo_tokens[i].text);
+ char *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),
ARTWORKINFO_FILENAME(type));
- /* check if corresponding "levelinfo.conf" file has changed */
+ // check if corresponding "levelinfo.conf" file has changed
token_main = getCacheToken(token_prefix, "TIMESTAMP_LEVELINFO");
cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
if (modifiedFileTimestamp(filename_levelinfo, cache_entry))
cached = FALSE;
- /* check if corresponding "<artworkinfo>.conf" file has changed */
+ // check if corresponding "<artworkinfo>.conf" file has changed
token_main = getCacheToken(token_prefix, "TIMESTAMP_ARTWORKINFO");
cache_entry = getHashEntry(artworkinfo_cache_old, token_main);
}
-/* -------------------------------------------------------------------------- */
-/* functions for loading level info and custom artwork info */
-/* -------------------------------------------------------------------------- */
-
-/* forward declaration for recursive call by "LoadLevelInfoFromLevelDir()" */
-static void LoadLevelInfoFromLevelDir(TreeInfo **, TreeInfo *, char *);
+// ----------------------------------------------------------------------------
+// functions for loading level info and custom artwork info
+// ----------------------------------------------------------------------------
-static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
- TreeInfo *node_parent,
- char *level_directory,
- char *directory_name)
+int GetZipFileTreeType(char *zip_filename)
{
- char *directory_path = getPath2(level_directory, directory_name);
- char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
- SetupFileHash *setup_file_hash;
- LevelDirTree *leveldir_new = NULL;
- int i;
-
- /* unless debugging, silently ignore directories without "levelinfo.conf" */
- if (!options.debug && !fileExists(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] =
{
- free(directory_path);
- free(filename);
-
- return FALSE;
- }
+ GRAPHICSINFO_FILENAME,
+ SOUNDSINFO_FILENAME,
+ MUSICINFO_FILENAME,
+ LEVELINFO_FILENAME
+ };
+ int j;
- setup_file_hash = loadSetupFileHash(filename);
+ checked_free(top_dir_path);
+ top_dir_path = NULL;
- if (setup_file_hash == NULL)
+ for (j = 0; j < NUM_BASE_TREE_TYPES; j++)
{
- Error(ERR_WARN, "ignoring level directory '%s'", directory_path);
+ checked_free(top_dir_conf_filename[j]);
+ top_dir_conf_filename[j] = NULL;
+ }
- free(directory_path);
- free(filename);
+ char **zip_entries = zip_list(zip_filename);
- return FALSE;
- }
+ // check if zip file successfully opened
+ if (zip_entries == NULL || zip_entries[0] == NULL)
+ return TREE_TYPE_UNDEFINED;
- leveldir_new = newTreeInfo();
+ // first zip file entry is expected to be top level directory
+ char *top_dir = zip_entries[0];
- if (node_parent)
- setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
- else
- setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
+ // check if valid top level directory found in zip file
+ if (!strSuffix(top_dir, "/"))
+ return TREE_TYPE_UNDEFINED;
- leveldir_new->subdir = getStringCopy(directory_name);
+ // 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]);
- /* set all structure fields according to the token/value pairs */
- ldi = *leveldir_new;
- for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
- setSetupInfo(levelinfo_tokens, i,
- getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
- *leveldir_new = ldi;
+ int tree_type = TREE_TYPE_UNDEFINED;
+ int e = 0;
- if (strEqual(leveldir_new->name, ANONYMOUS_NAME))
- setString(&leveldir_new->name, leveldir_new->subdir);
+ 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;
- if (leveldir_new->identifier == NULL)
- leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
+ // 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;
- if (leveldir_new->name_sorting == NULL)
- leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
+ tree_type = j;
+ }
+ }
- if (node_parent == NULL) /* top level group */
- {
- leveldir_new->basepath = getStringCopy(level_directory);
- leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
- }
- else /* sub level group */
- {
- leveldir_new->basepath = getStringCopy(node_parent->basepath);
- leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
+ e++;
}
- leveldir_new->last_level =
- leveldir_new->first_level + leveldir_new->levels - 1;
+ return tree_type;
+}
- leveldir_new->in_user_dir =
- (!strEqual(leveldir_new->basepath, options.level_directory));
+static boolean CheckZipFileForDirectory(char *zip_filename, char *directory,
+ int tree_type)
+{
+ static char *top_dir_path = NULL;
+ static char *top_dir_conf_filename = NULL;
- /* adjust some settings if user's private level directory was detected */
- if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
+ 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 *);
+
+static boolean LoadLevelInfoFromLevelConf(TreeInfo **node_first,
+ TreeInfo *node_parent,
+ char *level_directory,
+ char *directory_name)
+{
+ char *directory_path = getPath2(level_directory, directory_name);
+ char *filename = getPath2(directory_path, LEVELINFO_FILENAME);
+ SetupFileHash *setup_file_hash;
+ LevelDirTree *leveldir_new = NULL;
+ int i;
+
+ // unless debugging, silently ignore directories without "levelinfo.conf"
+ if (!options.debug && !fileExists(filename))
+ {
+ free(directory_path);
+ free(filename);
+
+ return FALSE;
+ }
+
+ setup_file_hash = loadSetupFileHash(filename);
+
+ if (setup_file_hash == NULL)
+ {
+#if DEBUG_NO_CONFIG_FILE
+ Debug("setup", "ignoring level directory '%s'", directory_path);
+#endif
+
+ free(directory_path);
+ free(filename);
+
+ return FALSE;
+ }
+
+ leveldir_new = newTreeInfo();
+
+ if (node_parent)
+ setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
+ else
+ setTreeInfoToDefaults(leveldir_new, TREE_TYPE_LEVEL_DIR);
+
+ leveldir_new->subdir = getStringCopy(directory_name);
+
+ // set all structure fields according to the token/value pairs
+ ldi = *leveldir_new;
+ for (i = 0; i < NUM_LEVELINFO_TOKENS; i++)
+ setSetupInfo(levelinfo_tokens, i,
+ getHashEntry(setup_file_hash, levelinfo_tokens[i].text));
+ *leveldir_new = ldi;
+
+ if (strEqual(leveldir_new->name, ANONYMOUS_NAME))
+ setString(&leveldir_new->name, leveldir_new->subdir);
+
+ if (leveldir_new->identifier == NULL)
+ leveldir_new->identifier = getStringCopy(leveldir_new->subdir);
+
+ if (leveldir_new->name_sorting == NULL)
+ leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
+
+ if (node_parent == NULL) // top level group
+ {
+ leveldir_new->basepath = getStringCopy(level_directory);
+ leveldir_new->fullpath = getStringCopy(leveldir_new->subdir);
+ }
+ else // sub level group
+ {
+ leveldir_new->basepath = getStringCopy(node_parent->basepath);
+ leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
+ }
+
+ leveldir_new->last_level =
+ leveldir_new->first_level + leveldir_new->levels - 1;
+
+ leveldir_new->in_user_dir =
+ (!strEqual(leveldir_new->basepath, options.level_directory));
+
+ // adjust some settings if user's private level directory was detected
+ if (leveldir_new->sort_priority == LEVELCLASS_UNDEFINED &&
leveldir_new->in_user_dir &&
(strEqual(leveldir_new->subdir, getLoginName()) ||
strEqual(leveldir_new->name, getLoginName()) ||
leveldir_new->user_defined =
(leveldir_new->in_user_dir && IS_LEVELCLASS_PRIVATE(leveldir_new));
- leveldir_new->color = LEVELCOLOR(leveldir_new);
-
setString(&leveldir_new->class_desc, getLevelClassDescription(leveldir_new));
- leveldir_new->handicap_level = /* set handicap to default value */
+ leveldir_new->handicap_level = // set handicap to default value
(leveldir_new->user_defined || !leveldir_new->handicap ?
leveldir_new->last_level : leveldir_new->first_level);
if (leveldir_new->level_group)
{
- /* create node to link back to current level directory */
+ // create node to link back to current level directory
createParentTreeInfoNode(leveldir_new);
- /* recursively step into sub-directory and look for more level series */
+ // recursively step into sub-directory and look for more level series
LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
leveldir_new, directory_path);
}
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;
}
- while ((dir_entry = readDirectory(dir)) != NULL) /* loop all entries */
+ while ((dir_entry = readDirectory(dir)) != NULL) // loop all entries
{
char *directory_name = dir_entry->basename;
char *directory_path = getPath2(level_directory, directory_name);
- /* skip entries for current and parent directory */
+ // skip entries for current and parent directory
if (strEqual(directory_name, ".") ||
strEqual(directory_name, ".."))
{
continue;
}
- /* find out if directory entry is itself a directory */
- if (!dir_entry->is_directory) /* not a directory */
+ // find out if directory entry is itself a directory
+ if (!dir_entry->is_directory) // not a directory
{
free(directory_path);
closeDirectory(dir);
- /* special case: top level directory may directly contain "levelinfo.conf" */
+ // 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" */
+ // 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'",
+ Warn("cannot find any valid level series in directory '%s'",
level_directory);
}
-boolean AdjustGraphicsForEMC()
+boolean AdjustGraphicsForEMC(void)
{
boolean settings_changed = FALSE;
return settings_changed;
}
-void LoadLevelInfo()
+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 */
+ // 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 (fileExists(filename))
setup_file_hash = loadSetupFileHash(filename);
- if (setup_file_hash == NULL) /* no config file -- look for artwork files */
+ if (setup_file_hash == NULL) // no config file -- look for artwork files
{
Directory *dir;
DirectoryEntry *dir_entry;
if (!valid_file_found)
{
+#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);
free(filename);
artwork_new->subdir = getStringCopy(directory_name);
- if (setup_file_hash) /* (before defining ".color" and ".class_desc") */
+ if (setup_file_hash) // (before defining ".color" and ".class_desc")
{
- /* set all structure fields according to the token/value pairs */
+ // 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,
artwork_new->name_sorting = getStringCopy(artwork_new->name);
}
- if (node_parent == NULL) /* top level group */
+ if (node_parent == NULL) // top level group
{
artwork_new->basepath = getStringCopy(base_directory);
artwork_new->fullpath = getStringCopy(artwork_new->subdir);
}
- else /* sub level group */
+ 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);
-
setString(&artwork_new->class_desc, getLevelClassDescription(artwork_new));
- if (setup_file_hash == NULL) /* (after determining ".user_defined") */
+ if (setup_file_hash == NULL) // (after determining ".user_defined")
{
if (strEqual(artwork_new->subdir, "."))
{
artwork_new->sort_priority = ARTWORKCLASS_CLASSICS;
}
- /* set to new values after changing ".sort_priority" */
- artwork_new->color = ARTWORKCOLOR(artwork_new);
-
setString(&artwork_new->class_desc,
getLevelClassDescription(artwork_new));
}
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;
if ((dir = openDirectory(base_directory)) == NULL)
{
- /* display error if directory is main "options.graphics_directory" etc. */
+ // 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;
}
- while ((dir_entry = readDirectory(dir)) != NULL) /* loop all entries */
+ 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 */
+ // skip directory entries for current and parent directory
if (strEqual(directory_name, ".") ||
strEqual(directory_name, ".."))
{
continue;
}
- /* skip directory entries which are not a directory */
- if (!dir_entry->is_directory) /* not a directory */
+ // skip directory entries which are not a directory
+ if (!dir_entry->is_directory) // not a directory
{
free(directory_path);
free(directory_path);
- /* check if this directory contains artwork with or without config file */
+ // 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 */
+ // 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);
+ Warn("cannot find any valid artwork in directory '%s'", base_directory);
}
static TreeInfo *getDummyArtworkInfo(int type)
{
- /* this is only needed when there is completely no artwork available */
+ // this is only needed when there is completely no artwork available
TreeInfo *artwork_new = newTreeInfo();
setTreeInfoToDefaults(artwork_new, type);
return artwork_new;
}
-void LoadArtworkInfo()
+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();
if (artwork.mus_first == NULL)
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);
+ // before sorting, the first entries will be from the user directory
+ 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);
#endif
}
-void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node,
- LevelDirTree *level_node)
+static void MoveArtworkInfoIntoSubTree(ArtworkDirTree **artwork_node)
+{
+ ArtworkDirTree *artwork_new = newTreeInfo();
+ char *top_node_name = "standalone artwork";
+
+ setTreeInfoToDefaults(artwork_new, (*artwork_node)->type);
+
+ artwork_new->level_group = TRUE;
+
+ setString(&artwork_new->identifier, top_node_name);
+ setString(&artwork_new->name, top_node_name);
+ setString(&artwork_new->name_sorting, top_node_name);
+
+ // create node to link back to current custom artwork directory
+ createParentTreeInfoNode(artwork_new);
+
+ // move existing custom artwork tree into newly created sub-tree
+ artwork_new->node_group->next = *artwork_node;
+
+ // change custom artwork tree to contain only newly created node
+ *artwork_node = artwork_new;
+}
+
+static void LoadArtworkInfoFromLevelInfoExt(ArtworkDirTree **artwork_node,
+ ArtworkDirTree *node_parent,
+ LevelDirTree *level_node,
+ boolean empty_level_set_mode)
{
int type = (*artwork_node)->type;
- /* recursively check all level directories for artwork sub-directories */
+ // recursively check all level directories for artwork sub-directories
while (level_node)
{
- /* check all tree entries for artwork, but skip parent link entries */
- if (!level_node->parent_link)
+ boolean empty_level_set = (level_node->levels == 0);
+
+ // check all tree entries for artwork, but skip parent link entries
+ if (!level_node->parent_link && empty_level_set == empty_level_set_mode)
{
TreeInfo *artwork_new = getArtworkInfoCacheEntry(level_node, type);
boolean cached = (artwork_new != NULL);
LoadArtworkInfoFromArtworkDir(artwork_node, NULL, path, type);
- if (topnode_last != *artwork_node) /* check for newly added node */
+ if (topnode_last != *artwork_node) // check for newly added node
{
artwork_new = *artwork_node;
setString(&artwork_new->name_sorting, level_node->name_sorting);
artwork_new->sort_priority = level_node->sort_priority;
- artwork_new->color = LEVELCOLOR(artwork_new);
+ artwork_new->in_user_dir = level_node->in_user_dir;
+
+ update_artworkinfo_cache = TRUE;
}
free(path);
}
- /* insert artwork info (from old cache or filesystem) into new cache */
+ // insert artwork info (from old cache or filesystem) into new cache
if (artwork_new != NULL)
setArtworkInfoCacheEntry(artwork_new, level_node, type);
}
DrawInitText(level_node->name, 150, FC_YELLOW);
if (level_node->node_group != NULL)
- LoadArtworkInfoFromLevelInfo(artwork_node, level_node->node_group);
+ {
+ TreeInfo *artwork_new = newTreeInfo();
+
+ if (node_parent)
+ setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
+ else
+ setTreeInfoToDefaults(artwork_new, type);
+
+ artwork_new->level_group = TRUE;
+
+ setString(&artwork_new->identifier, level_node->subdir);
+
+ if (node_parent == NULL) // check for top tree node
+ {
+ char *top_node_name = (empty_level_set_mode ?
+ "artwork for certain level sets" :
+ "artwork included in level sets");
+
+ setString(&artwork_new->name, top_node_name);
+ setString(&artwork_new->name_sorting, top_node_name);
+ }
+ else
+ {
+ setString(&artwork_new->name, level_node->name);
+ setString(&artwork_new->name_sorting, level_node->name_sorting);
+ }
+
+ pushTreeInfo(artwork_node, artwork_new);
+
+ // create node to link back to current custom artwork directory
+ createParentTreeInfoNode(artwork_new);
+
+ // recursively step into sub-directory and look for more custom artwork
+ LoadArtworkInfoFromLevelInfoExt(&artwork_new->node_group, artwork_new,
+ level_node->node_group,
+ empty_level_set_mode);
+
+ // if sub-tree has no custom artwork at all, remove it
+ if (artwork_new->node_group->next == NULL)
+ removeTreeInfo(artwork_node);
+ }
level_node = level_node->next;
}
}
-void LoadLevelArtworkInfo()
+static void LoadArtworkInfoFromLevelInfo(ArtworkDirTree **artwork_node)
+{
+ // move peviously loaded artwork tree into separate sub-tree
+ MoveArtworkInfoIntoSubTree(artwork_node);
+
+ // load artwork from level sets into separate sub-trees
+ LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, TRUE);
+ LoadArtworkInfoFromLevelInfoExt(artwork_node, NULL, leveldir_first_all, FALSE);
+
+ // add top tree node over all three separate sub-trees
+ *artwork_node = createTopTreeInfoNode(*artwork_node);
+
+ // set all parent links (back links) in complete artwork tree
+ setTreeInfoParentNodes(*artwork_node, NULL);
+}
+
+void LoadLevelArtworkInfo(void)
{
print_timestamp_init("LoadLevelArtworkInfo");
print_timestamp_time("DrawTimeText");
- LoadArtworkInfoFromLevelInfo(&artwork.gfx_first, leveldir_first_all);
+ LoadArtworkInfoFromLevelInfo(&artwork.gfx_first);
print_timestamp_time("LoadArtworkInfoFromLevelInfo (gfx)");
- LoadArtworkInfoFromLevelInfo(&artwork.snd_first, leveldir_first_all);
+ LoadArtworkInfoFromLevelInfo(&artwork.snd_first);
print_timestamp_time("LoadArtworkInfoFromLevelInfo (snd)");
- LoadArtworkInfoFromLevelInfo(&artwork.mus_first, leveldir_first_all);
+ LoadArtworkInfoFromLevelInfo(&artwork.mus_first);
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))
- {
- 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);
- }
+ // needed for reloading level artwork not known at ealier stage
+ 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 *classic_artwork_set = getClassicArtworkSet(type);
- /* check for custom artwork configured in "levelinfo.conf" */
+ // check for custom artwork configured in "levelinfo.conf"
char *leveldir_artwork_set =
*LEVELDIR_ARTWORK_SET_PTR(leveldir_current, type);
boolean has_leveldir_artwork_set =
(leveldir_artwork_set != NULL && !strEqual(leveldir_artwork_set,
classic_artwork_set));
- /* check for custom artwork in sub-directory "graphics" etc. */
+ // check for custom artwork in sub-directory "graphics" etc.
TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
char *leveldir_identifier = leveldir_current->identifier;
boolean has_artwork_subdir =
{
char *artwork_set = getArtworkIdentifierForUserLevelSet(type);
TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
+ TreeInfo *ti = 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 getTreeInfoFromIdentifier(artwork_first_node, artwork_set);
+ return ti;
}
-boolean checkIfCustomArtworkExistsForCurrentLevelSet()
+boolean checkIfCustomArtworkExistsForCurrentLevelSet(void)
{
char *graphics_set =
getArtworkIdentifierForUserLevelSet(ARTWORK_TYPE_GRAPHICS);
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;
level_info = newTreeInfo();
- /* always start with reliable default values */
+ // always start with reliable default values
setTreeInfoToDefaults(level_info, TREE_TYPE_LEVEL_DIR);
setString(&level_info->name, level_name);
i == LEVELINFO_TOKEN_MUSIC_SET)))
fprintf(file, "%s\n", getSetupLine(levelinfo_tokens, "", i));
- /* just to make things nicer :) */
+ // just to make things nicer :)
if (i == LEVELINFO_TOKEN_AUTHOR ||
i == LEVELINFO_TOKEN_FIRST_LEVEL ||
(use_artwork_set && i == LEVELINFO_TOKEN_READONLY))
return TRUE;
}
-static void SaveUserLevelInfo()
+static void SaveUserLevelInfo(void)
{
CreateUserLevelSet(getLoginName(), getLoginName(), getRealName(), 100, FALSE);
}
strcpy(value_string, *(char **)value);
break;
+ case TYPE_PLAYER:
+ sprintf(value_string, "player_%d", *(int *)value + 1);
+ break;
+
default:
value_string[0] = '\0';
break;
char *token_text = token_info[token_nr].text;
char *value_string = getSetupValue(token_type, setup_value);
- /* build complete token string */
+ // build complete token string
sprintf(token_string, "%s%s", prefix, token_text);
- /* build setup entry line */
+ // build setup entry line
line = getFormattedSetupEntry(token_string, value_string);
if (token_type == TYPE_KEY_X11)
Key key = *(Key *)setup_value;
char *keyname = getKeyNameFromKey(key);
- /* add comment, if useful */
+ // add comment, if useful
if (!strEqual(keyname, "(undefined)") &&
!strEqual(keyname, "(unknown)"))
{
- /* add at least one whitespace */
+ // add at least one whitespace
strcat(line, " ");
for (i = strlen(line); i < token_comment_position; i++)
strcat(line, " ");
return line;
}
-void LoadLevelSetup_LastSeries()
+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;
+ leveldir_new->sort_priority = LEVELCLASS_LAST_PLAYED_LEVEL;
+
+ setString(&leveldir_new->identifier, TOKEN_STR_LAST_LEVEL_SERIES);
+ setString(&leveldir_new->name, "<< (last played level sets)");
+ setString(&leveldir_new->name_sorting, leveldir_new->name);
+
+ 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;
+ LevelDirTree *leveldir_last;
+ TreeInfo **node_new = NULL;
+ int i;
+
+ if (last_level_series[0] == NULL)
+ return;
+
+ InitLastPlayedLevels_ParentNode();
+
+ leveldir_last = getTreeInfoFromIdentifierExt(leveldir_first,
+ TOKEN_STR_LAST_LEVEL_SERIES,
+ TREE_NODE_TYPE_GROUP);
+ if (leveldir_last == NULL)
+ return;
+
+ node_new = &leveldir_last->node_group->next;
+
+ freeTreeInfo(*node_new);
+
+ *node_new = NULL;
+
+ for (i = 0; last_level_series[i] != NULL; i++)
+ {
+ LevelDirTree *node_last = getTreeInfoFromIdentifier(leveldir_first,
+ last_level_series[i]);
+ if (node_last == NULL)
+ continue;
+
+ *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)->is_copy = TRUE; // mark entry as node copy
+
+ (*node_new)->node_group = NULL;
+ (*node_new)->next = NULL;
+
+ (*node_new)->cl_first = -1; // force setting tree cursor
+
+ node_new = &((*node_new)->next);
+ }
+}
+
+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);
+}
+
+static TreeInfo *StoreOrRestoreLastPlayedLevels(TreeInfo *node, boolean store)
{
- /* ----------------------------------------------------------------------- */
- /* ~/.<program>/levelsetup.conf */
- /* ----------------------------------------------------------------------- */
+ static char *identifier = NULL;
+
+ if (store)
+ {
+ setString(&identifier, (node && node->is_copy ? node->identifier : NULL));
+
+ return NULL; // not used
+ }
+ else
+ {
+ TreeInfo *node_new = getTreeInfoFromIdentifierExt(leveldir_first,
+ identifier,
+ TREE_NODE_TYPE_COPY);
+ return (node_new != NULL ? node_new : node);
+ }
+}
+
+void StoreLastPlayedLevels(TreeInfo *node)
+{
+ StoreOrRestoreLastPlayedLevels(node, TRUE);
+}
+
+void RestoreLastPlayedLevels(TreeInfo **node)
+{
+ *node = StoreOrRestoreLastPlayedLevels(*node, FALSE);
+}
+
+void LoadLevelSetup_LastSeries(void)
+{
+ // --------------------------------------------------------------------------
+ // ~/.<program>/levelsetup.conf
+ // --------------------------------------------------------------------------
char *filename = getPath2(getSetupDir(), LEVELSETUP_FILENAME);
SetupFileHash *level_setup_hash = NULL;
+ int pos = 0;
+ int i;
- /* always start with reliable default values */
+ // 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);
static void SaveLevelSetup_LastSeries_Ext(boolean deactivate_last_level_series)
{
- /* ----------------------------------------------------------------------- */
- /* ~/.<program>/levelsetup.conf */
- /* ----------------------------------------------------------------------- */
+ // --------------------------------------------------------------------------
+ // ~/.<program>/levelsetup.conf
+ // --------------------------------------------------------------------------
// check if the current level directory structure is available at this point
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);
free(filename);
}
-void SaveLevelSetup_LastSeries()
+void SaveLevelSetup_LastSeries(void)
{
SaveLevelSetup_LastSeries_Ext(FALSE);
}
-void SaveLevelSetup_LastSeries_Deactivate()
+void SaveLevelSetup_LastSeries_Deactivate(void)
{
SaveLevelSetup_LastSeries_Ext(TRUE);
}
-static void checkSeriesInfo()
+static void checkSeriesInfo(void)
{
static char *level_directory = NULL;
Directory *dir;
+#if 0
+ DirectoryEntry *dir_entry;
+#endif
- /* check for more levels besides the 'levels' field of 'levelinfo.conf' */
+ checked_free(level_directory);
+
+ // check for more levels besides the 'levels' field of 'levelinfo.conf'
level_directory = getPath2((leveldir_current->in_user_dir ?
getUserLevelDir(NULL) :
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);
}
-void LoadLevelSetup_SeriesInfo()
+void LoadLevelSetup_SeriesInfo(void)
{
char *filename;
SetupFileHash *level_setup_hash = NULL;
char *level_subdir = leveldir_current->subdir;
int i;
- /* always start with reliable default values */
+ // always start with reliable default values
level_nr = leveldir_current->first_level;
for (i = 0; i < MAX_LEVELS; i++)
checkSeriesInfo();
- /* ----------------------------------------------------------------------- */
- /* ~/.<program>/levelsetup/<level series>/levelsetup.conf */
- /* ----------------------------------------------------------------------- */
+ // --------------------------------------------------------------------------
+ // ~/.<program>/levelsetup/<level series>/levelsetup.conf
+ // --------------------------------------------------------------------------
level_subdir = leveldir_current->subdir;
{
char *token_value;
- /* get last played level in this level set */
+ // get last played level in this level set
token_value = getHashEntry(level_setup_hash, TOKEN_STR_LAST_PLAYED_LEVEL);
level_nr = leveldir_current->last_level;
}
- /* get handicap level in this level set */
+ // get handicap level in this level set
token_value = getHashEntry(level_setup_hash, TOKEN_STR_HANDICAP_LEVEL);
leveldir_current->handicap_level = level_nr;
}
- /* get number of played and solved levels in this level set */
+ // get number of played and solved levels in this level set
BEGIN_HASH_ITERATION(level_setup_hash, itr)
{
int level_nr = atoi(token);
if (value != NULL)
- LevelStats_setPlayed(level_nr, atoi(value)); /* read 1st column */
+ LevelStats_setPlayed(level_nr, atoi(value)); // read 1st column
value = strchr(value, ' ');
if (value != NULL)
- LevelStats_setSolved(level_nr, atoi(value)); /* read 2nd column */
+ LevelStats_setSolved(level_nr, atoi(value)); // read 2nd column
}
}
END_HASH_ITERATION(hash, itr)
}
else
{
- Error(ERR_DEBUG, "using default setup values");
+ Debug("setup", "using default setup values");
}
free(filename);
}
-void SaveLevelSetup_SeriesInfo()
+void SaveLevelSetup_SeriesInfo(void)
{
char *filename;
char *level_subdir = leveldir_current->subdir;
FILE *file;
int i;
- /* ----------------------------------------------------------------------- */
- /* ~/.<program>/levelsetup/<level series>/levelsetup.conf */
- /* ----------------------------------------------------------------------- */
+ // --------------------------------------------------------------------------
+ // ~/.<program>/levelsetup/<level series>/levelsetup.conf
+ // --------------------------------------------------------------------------
InitLevelSetupDirectory(level_subdir);
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);
+}
projects / rocksndiamonds.git / blobdiff