X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fsetup.c;h=454f66c521fd0765f5bd6ffc07b52e9cf4d2f64c;hb=f25f84638db551dfef62b019ca2390193ad53600;hp=0b39ff7cc44cc3dccc5e353ed84726800195a4b4;hpb=93806fb4c23f4b6ef58d9562e908a1b89ece869d;p=rocksndiamonds.git

diff --git a/src/libgame/setup.c b/src/libgame/setup.c
index 0b39ff7c..454f66c5 100644
--- a/src/libgame/setup.c
+++ b/src/libgame/setup.c
@@ -27,6 +27,9 @@
 #define SETUP_FILENAME		"setup.conf"
 #define LEVELSETUP_FILENAME	"levelsetup.conf"
 #define LEVELINFO_FILENAME	"levelinfo.conf"
+#define GRAPHICSINFO_FILENAME	"graphicsinfo.conf"
+#define SOUNDSINFO_FILENAME	"soundsinfo.conf"
+#define MUSICINFO_FILENAME	"musicinfo.conf"
 #define LEVELFILE_EXTENSION	"level"
 #define TAPEFILE_EXTENSION	"tape"
 #define SCOREFILE_EXTENSION	"score"
@@ -35,6 +38,9 @@
 #define SETUP_FILENAME		"setup.cnf"
 #define LEVELSETUP_FILENAME	"lvlsetup.cnf"
 #define LEVELINFO_FILENAME	"lvlinfo.cnf"
+#define GRAPHICSINFO_FILENAME	"gfxinfo.cnf"
+#define SOUNDSINFO_FILENAME	"sndinfo.cnf"
+#define MUSICINFO_FILENAME	"musinfo.cnf"
 #define LEVELFILE_EXTENSION	"lvl"
 #define TAPEFILE_EXTENSION	"tap"
 #define SCOREFILE_EXTENSION	"sco"
@@ -82,7 +88,7 @@ static char *levelclass_desc[NUM_LEVELCLASS_DESC] =
 /* file functions                                                            */
 /* ------------------------------------------------------------------------- */
 
-char *getLevelClassDescription(struct LevelDirInfo *ldi)
+static char *getLevelClassDescription(TreeInfo *ldi)
 {
   int position = ldi->sort_priority / 100;
 
@@ -101,7 +107,7 @@ static char *getUserLevelDir(char *level_subdir)
   if (userlevel_dir)
     free(userlevel_dir);
 
-  if (strlen(level_subdir) > 0)
+  if (level_subdir != NULL)
     userlevel_dir = getPath3(data_dir, userlevel_subdir, level_subdir);
   else
     userlevel_dir = getPath2(data_dir, userlevel_subdir);
@@ -118,7 +124,7 @@ static char *getTapeDir(char *level_subdir)
   if (tape_dir)
     free(tape_dir);
 
-  if (strlen(level_subdir) > 0)
+  if (level_subdir != NULL)
     tape_dir = getPath3(data_dir, tape_subdir, level_subdir);
   else
     tape_dir = getPath2(data_dir, tape_subdir);
@@ -135,7 +141,7 @@ static char *getScoreDir(char *level_subdir)
   if (score_dir)
     free(score_dir);
 
-  if (strlen(level_subdir) > 0)
+  if (level_subdir != NULL)
     score_dir = getPath3(data_dir, score_subdir, level_subdir);
   else
     score_dir = getPath2(data_dir, score_subdir);
@@ -152,7 +158,7 @@ static char *getLevelSetupDir(char *level_subdir)
   if (levelsetup_dir)
     free(levelsetup_dir);
 
-  if (strlen(level_subdir) > 0)
+  if (level_subdir != NULL)
     levelsetup_dir = getPath3(data_dir, levelsetup_subdir, level_subdir);
   else
     levelsetup_dir = getPath2(data_dir, levelsetup_subdir);
@@ -160,6 +166,57 @@ static char *getLevelSetupDir(char *level_subdir)
   return levelsetup_dir;
 }
 
+static char *getUserGraphicsDir(char *graphics_subdir)
+{
+  static char *usergraphics_dir = NULL;
+  char *data_dir = getUserDataDir();
+  char *usergraphics_subdir = GRAPHICS_DIRECTORY;
+
+  if (usergraphics_dir)
+    free(usergraphics_dir);
+
+  if (graphics_subdir != NULL)
+    usergraphics_dir = getPath3(data_dir, usergraphics_subdir,graphics_subdir);
+  else
+    usergraphics_dir = getPath2(data_dir, usergraphics_subdir);
+
+  return usergraphics_dir;
+}
+
+static char *getUserSoundsDir(char *sounds_subdir)
+{
+  static char *usersounds_dir = NULL;
+  char *data_dir = getUserDataDir();
+  char *usersounds_subdir = SOUNDS_DIRECTORY;
+
+  if (usersounds_dir)
+    free(usersounds_dir);
+
+  if (sounds_subdir != NULL)
+    usersounds_dir = getPath3(data_dir, usersounds_subdir,sounds_subdir);
+  else
+    usersounds_dir = getPath2(data_dir, usersounds_subdir);
+
+  return usersounds_dir;
+}
+
+static char *getUserMusicDir(char *music_subdir)
+{
+  static char *usermusic_dir = NULL;
+  char *data_dir = getUserDataDir();
+  char *usermusic_subdir = MUSIC_DIRECTORY;
+
+  if (usermusic_dir)
+    free(usermusic_dir);
+
+  if (music_subdir != NULL)
+    usermusic_dir = getPath3(data_dir, usermusic_subdir,music_subdir);
+  else
+    usermusic_dir = getPath2(data_dir, usermusic_subdir);
+
+  return usermusic_dir;
+}
+
 char *getLevelFilename(int nr)
 {
   static char *filename = NULL;
@@ -170,7 +227,7 @@ char *getLevelFilename(int nr)
 
   sprintf(basename, "%03d.%s", nr, LEVELFILE_EXTENSION);
   filename = getPath3((leveldir_current->user_defined ?
-		       getUserLevelDir("") :
+		       getUserLevelDir(NULL) :
 		       options.level_directory),
 		      leveldir_current->fullpath,
 		      basename);
@@ -247,16 +304,34 @@ char *getImageFilename(char *basename)
   return filename;
 }
 
+char *getCustomImageFilename(char *basename)
+{
+#if 0
+  if (strcmp(basename, "RocksFont.pcx") == 0)
+  {
+    char *dir = options.graphics_directory;
+
+    printf("checking directory '%s' ...\n", dir);
+
+    /*
+    dir = getPath2(options.graphics_directory);
+    */
+  }
+#endif
+
+  return getImageFilename(basename);
+}
+
 void InitTapeDirectory(char *level_subdir)
 {
   createDirectory(getUserDataDir(), "user data", PERMS_PRIVATE);
-  createDirectory(getTapeDir(""), "main tape", PERMS_PRIVATE);
+  createDirectory(getTapeDir(NULL), "main tape", PERMS_PRIVATE);
   createDirectory(getTapeDir(level_subdir), "level tape", PERMS_PRIVATE);
 }
 
 void InitScoreDirectory(char *level_subdir)
 {
-  createDirectory(getScoreDir(""), "main score", PERMS_PUBLIC);
+  createDirectory(getScoreDir(NULL), "main score", PERMS_PUBLIC);
   createDirectory(getScoreDir(level_subdir), "level score", PERMS_PUBLIC);
 }
 
@@ -267,7 +342,7 @@ void InitUserLevelDirectory(char *level_subdir)
   if (access(getUserLevelDir(level_subdir), F_OK) != 0)
   {
     createDirectory(getUserDataDir(), "user data", PERMS_PRIVATE);
-    createDirectory(getUserLevelDir(""), "main user level", PERMS_PRIVATE);
+    createDirectory(getUserLevelDir(NULL), "main user level", PERMS_PRIVATE);
     createDirectory(getUserLevelDir(level_subdir), "user level",PERMS_PRIVATE);
 
     SaveUserLevelInfo();
@@ -277,7 +352,7 @@ void InitUserLevelDirectory(char *level_subdir)
 void InitLevelSetupDirectory(char *level_subdir)
 {
   createDirectory(getUserDataDir(), "user data", PERMS_PRIVATE);
-  createDirectory(getLevelSetupDir(""), "main level setup", PERMS_PRIVATE);
+  createDirectory(getLevelSetupDir(NULL), "main level setup", PERMS_PRIVATE);
   createDirectory(getLevelSetupDir(level_subdir), "level setup",PERMS_PRIVATE);
 }
 
@@ -330,19 +405,18 @@ void WriteChunk_VERS(FILE *file, int file_version, int game_version)
 /* some functions to handle lists of level directories                       */
 /* ------------------------------------------------------------------------- */
 
-struct LevelDirInfo *newLevelDirInfo()
+TreeInfo *newTreeInfo()
 {
-  return checked_calloc(sizeof(struct LevelDirInfo));
+  return checked_calloc(sizeof(TreeInfo));
 }
 
-void pushLevelDirInfo(struct LevelDirInfo **node_first,
-		      struct LevelDirInfo *node_new)
+void pushTreeInfo(TreeInfo **node_first, TreeInfo *node_new)
 {
   node_new->next = *node_first;
   *node_first = node_new;
 }
 
-int numLevelDirInfo(struct LevelDirInfo *node)
+int numTreeInfo(TreeInfo *node)
 {
   int num = 0;
 
@@ -355,12 +429,12 @@ int numLevelDirInfo(struct LevelDirInfo *node)
   return num;
 }
 
-boolean validLevelSeries(struct LevelDirInfo *node)
+boolean validLevelSeries(TreeInfo *node)
 {
   return (node != NULL && !node->node_group && !node->parent_link);
 }
 
-struct LevelDirInfo *getFirstValidLevelSeries(struct LevelDirInfo *node)
+TreeInfo *getFirstValidLevelSeries(TreeInfo *node)
 {
   if (node == NULL)
   {
@@ -382,7 +456,7 @@ struct LevelDirInfo *getFirstValidLevelSeries(struct LevelDirInfo *node)
     return node;
 }
 
-struct LevelDirInfo *getLevelDirInfoFirstGroupEntry(struct LevelDirInfo *node)
+TreeInfo *getTreeInfoFirstGroupEntry(TreeInfo *node)
 {
   if (node == NULL)
     return NULL;
@@ -393,14 +467,14 @@ struct LevelDirInfo *getLevelDirInfoFirstGroupEntry(struct LevelDirInfo *node)
     return node->node_parent->node_group;
 }
 
-int numLevelDirInfoInGroup(struct LevelDirInfo *node)
+int numTreeInfoInGroup(TreeInfo *node)
 {
-  return numLevelDirInfo(getLevelDirInfoFirstGroupEntry(node));
+  return numTreeInfo(getTreeInfoFirstGroupEntry(node));
 }
 
-int posLevelDirInfo(struct LevelDirInfo *node)
+int posTreeInfo(TreeInfo *node)
 {
-  struct LevelDirInfo *node_cmp = getLevelDirInfoFirstGroupEntry(node);
+  TreeInfo *node_cmp = getTreeInfoFirstGroupEntry(node);
   int pos = 0;
 
   while (node_cmp)
@@ -415,9 +489,9 @@ int posLevelDirInfo(struct LevelDirInfo *node)
   return 0;
 }
 
-struct LevelDirInfo *getLevelDirInfoFromPos(struct LevelDirInfo *node, int pos)
+TreeInfo *getTreeInfoFromPos(TreeInfo *node, int pos)
 {
-  struct LevelDirInfo *node_default = node;
+  TreeInfo *node_default = node;
   int pos_cmp = 0;
 
   while (node)
@@ -432,8 +506,7 @@ struct LevelDirInfo *getLevelDirInfoFromPos(struct LevelDirInfo *node, int pos)
   return node_default;
 }
 
-struct LevelDirInfo *getLevelDirInfoFromFilenameExt(struct LevelDirInfo *node,
-						    char *filename)
+TreeInfo *getTreeInfoFromFilenameExt(TreeInfo *node, char *filename)
 {
   if (filename == NULL)
     return NULL;
@@ -442,9 +515,9 @@ struct LevelDirInfo *getLevelDirInfoFromFilenameExt(struct LevelDirInfo *node,
   {
     if (node->node_group)
     {
-      struct LevelDirInfo *node_group;
+      TreeInfo *node_group;
 
-      node_group = getLevelDirInfoFromFilenameExt(node->node_group, filename);
+      node_group = getTreeInfoFromFilenameExt(node->node_group, filename);
 
       if (node_group)
 	return node_group;
@@ -461,12 +534,12 @@ struct LevelDirInfo *getLevelDirInfoFromFilenameExt(struct LevelDirInfo *node,
   return NULL;
 }
 
-struct LevelDirInfo *getLevelDirInfoFromFilename(char *filename)
+TreeInfo *getTreeInfoFromFilename(char *filename)
 {
-  return getLevelDirInfoFromFilenameExt(leveldir_first, filename);
+  return getTreeInfoFromFilenameExt(leveldir_first, filename);
 }
 
-void dumpLevelDirInfo(struct LevelDirInfo *node, int depth)
+void dumpTreeInfo(TreeInfo *node, int depth)
 {
   int i;
 
@@ -475,28 +548,28 @@ void dumpLevelDirInfo(struct LevelDirInfo *node, int depth)
     for (i=0; i<depth * 3; i++)
       printf(" ");
 
-    printf("filename == '%s'\n", node->filename);
+    printf("filename == '%s' [%s]\n", node->filename, node->name);
 
     if (node->node_group != NULL)
-      dumpLevelDirInfo(node->node_group, depth + 1);
+      dumpTreeInfo(node->node_group, depth + 1);
 
     node = node->next;
   }
 }
 
-void sortLevelDirInfo(struct LevelDirInfo **node_first,
-		      int (*compare_function)(const void *, const void *))
+void sortTreeInfo(TreeInfo **node_first,
+		  int (*compare_function)(const void *, const void *))
 {
-  int num_nodes = numLevelDirInfo(*node_first);
-  struct LevelDirInfo **sort_array;
-  struct LevelDirInfo *node = *node_first;
+  int num_nodes = numTreeInfo(*node_first);
+  TreeInfo **sort_array;
+  TreeInfo *node = *node_first;
   int i = 0;
 
   if (num_nodes == 0)
     return;
 
   /* allocate array for sorting structure pointers */
-  sort_array = checked_calloc(num_nodes * sizeof(struct LevelDirInfo *));
+  sort_array = checked_calloc(num_nodes * sizeof(TreeInfo *));
 
   /* writing structure pointers to sorting array */
   while (i < num_nodes && node)		/* double boundary check... */
@@ -508,7 +581,7 @@ void sortLevelDirInfo(struct LevelDirInfo **node_first,
   }
 
   /* sorting the structure pointers in the sorting array */
-  qsort(sort_array, num_nodes, sizeof(struct LevelDirInfo *),
+  qsort(sort_array, num_nodes, sizeof(TreeInfo *),
 	compare_function);
 
   /* update the linkage of list elements with the sorted node array */
@@ -526,7 +599,7 @@ void sortLevelDirInfo(struct LevelDirInfo **node_first,
   while (node)
   {
     if (node->node_group != NULL)
-      sortLevelDirInfo(&node->node_group, compare_function);
+      sortTreeInfo(&node->node_group, compare_function);
 
     node = node->next;
   }
@@ -984,25 +1057,34 @@ void checkSetupFileListIdentifier(struct SetupFileList *setup_file_list,
 
 #define NUM_LEVELINFO_TOKENS		10
 
-static struct LevelDirInfo ldi;
+static LevelDirTree ldi;
 
 static struct TokenInfo levelinfo_tokens[] =
 {
   /* level directory info */
-  { TYPE_STRING,  &ldi.name,		"name"				},
-  { TYPE_STRING,  &ldi.name_short,	"name_short"			},
-  { TYPE_STRING,  &ldi.name_sorting,	"name_sorting"			},
-  { TYPE_STRING,  &ldi.author,		"author"			},
-  { TYPE_STRING,  &ldi.imported_from,	"imported_from"			},
-  { TYPE_INTEGER, &ldi.levels,		"levels"			},
-  { TYPE_INTEGER, &ldi.first_level,	"first_level"			},
-  { TYPE_INTEGER, &ldi.sort_priority,	"sort_priority"			},
-  { TYPE_BOOLEAN, &ldi.level_group,	"level_group"			},
-  { TYPE_BOOLEAN, &ldi.readonly,	"readonly"			}
+  { TYPE_STRING,  &ldi.name,		"name"		},
+  { TYPE_STRING,  &ldi.name_short,	"name_short"	},
+  { TYPE_STRING,  &ldi.name_sorting,	"name_sorting"	},
+  { TYPE_STRING,  &ldi.author,		"author"	},
+  { TYPE_STRING,  &ldi.imported_from,	"imported_from"	},
+  { TYPE_INTEGER, &ldi.levels,		"levels"	},
+  { TYPE_INTEGER, &ldi.first_level,	"first_level"	},
+  { TYPE_INTEGER, &ldi.sort_priority,	"sort_priority"	},
+  { TYPE_BOOLEAN, &ldi.level_group,	"level_group"	},
+  { TYPE_BOOLEAN, &ldi.readonly,	"readonly"	}
 };
 
-static void setLevelDirInfoToDefaults(struct LevelDirInfo *ldi)
+static void setTreeInfoToDefaults(TreeInfo *ldi)
 {
+  ldi->node_parent = NULL;
+  ldi->node_group = NULL;
+  ldi->next = NULL;
+
+  ldi->cl_first = -1;
+  ldi->cl_cursor = -1;
+
+  /* ldi->type is expected to be already set! */
+
   ldi->filename = NULL;
   ldi->fullpath = NULL;
   ldi->basepath = NULL;
@@ -1010,32 +1092,30 @@ static void setLevelDirInfoToDefaults(struct LevelDirInfo *ldi)
   ldi->name_short = NULL;
   ldi->name_sorting = NULL;
   ldi->author = getStringCopy(ANONYMOUS_NAME);
-  ldi->imported_from = NULL;
-  ldi->levels = 0;
-  ldi->first_level = 0;
-  ldi->last_level = 0;
+
   ldi->sort_priority = LEVELCLASS_UNDEFINED;	/* default: least priority */
-  ldi->level_group = FALSE;
   ldi->parent_link = FALSE;
   ldi->user_defined = FALSE;
-  ldi->readonly = TRUE;
   ldi->color = 0;
   ldi->class_desc = NULL;
-  ldi->handicap_level = 0;
-  ldi->cl_first = -1;
-  ldi->cl_cursor = -1;
 
-  ldi->node_parent = NULL;
-  ldi->node_group = NULL;
-  ldi->next = NULL;
+  if (ldi->type == TREE_TYPE_LEVEL_DIR)
+  {
+    ldi->imported_from = NULL;
+    ldi->levels = 0;
+    ldi->first_level = 0;
+    ldi->last_level = 0;
+    ldi->level_group = FALSE;
+    ldi->handicap_level = 0;
+    ldi->readonly = TRUE;
+  }
 }
 
-static void setLevelDirInfoToDefaultsFromParent(struct LevelDirInfo *ldi,
-						struct LevelDirInfo *parent)
+static void setTreeInfoToDefaultsFromParent(TreeInfo *ldi, TreeInfo *parent)
 {
   if (parent == NULL)
   {
-    setLevelDirInfoToDefaults(ldi);
+    setTreeInfoToDefaults(ldi);
     return;
   }
 
@@ -1084,6 +1164,10 @@ void setSetupInfo(struct TokenInfo *token_info,
       break;
 
     case TYPE_KEY:
+      *(Key *)setup_value = getKeyFromKeyName(token_value);
+      break;
+
+    case TYPE_KEY_X11:
       *(Key *)setup_value = getKeyFromX11KeyName(token_value);
       break;
 
@@ -1102,10 +1186,10 @@ void setSetupInfo(struct TokenInfo *token_info,
   }
 }
 
-static int compareLevelDirInfoEntries(const void *object1, const void *object2)
+static int compareTreeInfoEntries(const void *object1, const void *object2)
 {
-  const struct LevelDirInfo *entry1 = *((struct LevelDirInfo **)object1);
-  const struct LevelDirInfo *entry2 = *((struct LevelDirInfo **)object2);
+  const TreeInfo *entry1 = *((TreeInfo **)object1);
+  const TreeInfo *entry2 = *((TreeInfo **)object2);
   int compare_result;
 
   if (entry1->parent_link || entry2->parent_link)
@@ -1128,30 +1212,131 @@ static int compareLevelDirInfoEntries(const void *object1, const void *object2)
   return compare_result;
 }
 
-static void createParentLevelDirNode(struct LevelDirInfo *node_parent)
+static void createParentTreeInfoNode(TreeInfo *node_parent)
 {
-  struct LevelDirInfo *leveldir_new = newLevelDirInfo();
+  TreeInfo *ti_new;
+
+  if (node_parent == NULL)
+    return;
+
+  ti_new = newTreeInfo();
+  ti_new->type = node_parent->type;
+
+  setTreeInfoToDefaults(ti_new);
+
+  ti_new->node_parent = node_parent;
+  ti_new->parent_link = TRUE;
+
+  ti_new->name = ".. (parent directory)";
+  ti_new->name_short = getStringCopy(ti_new->name);
+  ti_new->name_sorting = getStringCopy(ti_new->name);
 
-  setLevelDirInfoToDefaults(leveldir_new);
+  ti_new->filename = "..";
+  ti_new->fullpath = getStringCopy(node_parent->fullpath);
 
-  leveldir_new->node_parent = node_parent;
-  leveldir_new->parent_link = TRUE;
+  ti_new->sort_priority = node_parent->sort_priority;
+  ti_new->class_desc = getLevelClassDescription(ti_new);
 
-  leveldir_new->name = ".. (parent directory)";
-  leveldir_new->name_short = getStringCopy(leveldir_new->name);
-  leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
+  pushTreeInfo(&node_parent->node_group, ti_new);
+}
+
+/* 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);
+  struct SetupFileList *setup_file_list = loadSetupFileList(filename);
+  LevelDirTree *leveldir_new = NULL;
+  int i;
 
-  leveldir_new->filename = "..";
-  leveldir_new->fullpath = getStringCopy(node_parent->fullpath);
+  if (setup_file_list == NULL)
+  {
+    Error(ERR_WARN, "ignoring level directory '%s'", level_directory);
 
-  leveldir_new->sort_priority = node_parent->sort_priority;
+    free(directory_path);
+    free(filename);
+
+    return FALSE;
+  }
+
+  leveldir_new = newTreeInfo();
+  leveldir_new->type = TREE_TYPE_LEVEL_DIR;
+
+  checkSetupFileListIdentifier(setup_file_list, getCookie("LEVELINFO"));
+  setTreeInfoToDefaultsFromParent(leveldir_new, node_parent);
+
+  /* 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,
+		 getTokenValue(setup_file_list, levelinfo_tokens[i].text));
+  *leveldir_new = ldi;
+
+  DrawInitText(leveldir_new->name, 150, FC_YELLOW);
+
+  if (leveldir_new->name_short == NULL)
+    leveldir_new->name_short = getStringCopy(leveldir_new->name);
+
+  if (leveldir_new->name_sorting == NULL)
+    leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
+
+  leveldir_new->filename = getStringCopy(directory_name);
+
+  if (node_parent == NULL)		/* top level group */
+  {
+    leveldir_new->basepath = level_directory;
+    leveldir_new->fullpath = leveldir_new->filename;
+  }
+  else					/* sub level group */
+  {
+    leveldir_new->basepath = node_parent->basepath;
+    leveldir_new->fullpath = getPath2(node_parent->fullpath, directory_name);
+  }
+
+  if (leveldir_new->levels < 1)
+    leveldir_new->levels = 1;
+
+  leveldir_new->last_level =
+    leveldir_new->first_level + leveldir_new->levels - 1;
+
+  leveldir_new->user_defined =
+    (leveldir_new->basepath == options.level_directory ? FALSE : TRUE);
+
+  leveldir_new->color = LEVELCOLOR(leveldir_new);
   leveldir_new->class_desc = getLevelClassDescription(leveldir_new);
 
-  pushLevelDirInfo(&node_parent->node_group, leveldir_new);
+  leveldir_new->handicap_level =	/* set handicap to default value */
+    (leveldir_new->user_defined ?
+     leveldir_new->last_level :
+     leveldir_new->first_level);
+
+  pushTreeInfo(node_first, leveldir_new);
+
+  freeSetupFileList(setup_file_list);
+
+  if (leveldir_new->level_group)
+  {
+    /* create node to link back to current level directory */
+    createParentTreeInfoNode(leveldir_new);
+
+    /* step into sub-directory and look for more level series */
+    LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
+			      leveldir_new, directory_path);
+  }
+
+  free(directory_path);
+  free(filename);
+
+  return TRUE;
 }
 
-static void LoadLevelInfoFromLevelDir(struct LevelDirInfo **node_first,
-				      struct LevelDirInfo *node_parent,
+static void LoadLevelInfoFromLevelDir(TreeInfo **node_first,
+				      TreeInfo *node_parent,
 				      char *level_directory)
 {
   DIR *dir;
@@ -1166,11 +1351,9 @@ static void LoadLevelInfoFromLevelDir(struct LevelDirInfo **node_first,
 
   while ((dir_entry = readdir(dir)) != NULL)	/* loop until last dir entry */
   {
-    struct SetupFileList *setup_file_list = NULL;
     struct stat file_status;
     char *directory_name = dir_entry->d_name;
     char *directory_path = getPath2(level_directory, directory_name);
-    char *filename = NULL;
 
     /* skip entries for current and parent directory */
     if (strcmp(directory_name, ".")  == 0 ||
@@ -1188,110 +1371,277 @@ static void LoadLevelInfoFromLevelDir(struct LevelDirInfo **node_first,
       continue;
     }
 
-    filename = getPath2(directory_path, LEVELINFO_FILENAME);
-    setup_file_list = loadSetupFileList(filename);
-
-    if (setup_file_list)
-    {
-      struct LevelDirInfo *leveldir_new = newLevelDirInfo();
-      int i;
+    free(directory_path);
 
-      checkSetupFileListIdentifier(setup_file_list, getCookie("LEVELINFO"));
-      setLevelDirInfoToDefaultsFromParent(leveldir_new, node_parent);
+    valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
+						    level_directory,
+						    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,
-		     getTokenValue(setup_file_list, levelinfo_tokens[i].text));
-      *leveldir_new = ldi;
+  closedir(dir);
 
-      DrawInitText(leveldir_new->name, 150, FC_YELLOW);
+  if (!valid_entry_found)
+  {
+    /* check if this directory directly contains a file "levelinfo.conf" */
+    valid_entry_found |= LoadLevelInfoFromLevelConf(node_first, node_parent,
+						    level_directory, ".");
+  }
 
-      if (leveldir_new->name_short == NULL)
-	leveldir_new->name_short = getStringCopy(leveldir_new->name);
+  if (!valid_entry_found)
+    Error(ERR_WARN, "cannot find any valid level series in directory '%s'",
+	  level_directory);
+}
 
-      if (leveldir_new->name_sorting == NULL)
-	leveldir_new->name_sorting = getStringCopy(leveldir_new->name);
+void LoadLevelInfo()
+{
+  InitUserLevelDirectory(getLoginName());
 
-      leveldir_new->filename = getStringCopy(directory_name);
+  DrawInitText("Loading level series:", 120, FC_GREEN);
 
-      if (node_parent == NULL)		/* top level group */
-      {
-	leveldir_new->basepath = level_directory;
-	leveldir_new->fullpath = leveldir_new->filename;
-      }
-      else				/* sub level group */
-      {
-	leveldir_new->basepath = node_parent->basepath;
-	leveldir_new->fullpath = getPath2(node_parent->fullpath,
-					  directory_name);
-      }
+  LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
+  LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(NULL));
 
-      if (leveldir_new->levels < 1)
-	leveldir_new->levels = 1;
+  leveldir_current = getFirstValidLevelSeries(leveldir_first);
 
-      leveldir_new->last_level =
-	leveldir_new->first_level + leveldir_new->levels - 1;
+  if (leveldir_first == NULL)
+    Error(ERR_EXIT, "cannot find any valid level series in any directory");
 
-      leveldir_new->user_defined =
-	(leveldir_new->basepath == options.level_directory ? FALSE : TRUE);
+  sortTreeInfo(&leveldir_first, compareTreeInfoEntries);
 
-      leveldir_new->color = LEVELCOLOR(leveldir_new);
-      leveldir_new->class_desc = getLevelClassDescription(leveldir_new);
+#if 0
+  dumpTreeInfo(leveldir_first, 0);
+#endif
+}
 
-      leveldir_new->handicap_level =	/* set handicap to default value */
-	(leveldir_new->user_defined ?
-	 leveldir_new->last_level :
-	 leveldir_new->first_level);
+static boolean LoadArtworkInfoFromArtworkConf(TreeInfo **node_first,
+					      TreeInfo *node_parent,
+					      char *base_directory,
+					      char *directory_name, int type)
+{
+  char *directory_path = getPath2(base_directory, directory_name);
+  char *filename =
+    getPath2(directory_path,
+	     (type == TREE_TYPE_GRAPHICS_DIR ? GRAPHICSINFO_FILENAME :
+	      type == TREE_TYPE_SOUNDS_DIR ? SOUNDSINFO_FILENAME :
+	      type == TREE_TYPE_MUSIC_DIR ? MUSICINFO_FILENAME : ""));
+  struct SetupFileList *setup_file_list = NULL;
+  TreeInfo *artwork_new = NULL;
+  char *check_dir = NULL;
+  int i;
 
-      pushLevelDirInfo(node_first, leveldir_new);
+  if (access(getUserLevelDir(filename), F_OK) == 0)	/* file exists */
+    loadSetupFileList(filename);
 
-      freeSetupFileList(setup_file_list);
-      valid_entry_found = TRUE;
+  if (setup_file_list == NULL)	/* no config file -- look for artwork files */
+  {
+    DIR *dir;
+    struct dirent *dir_entry;
+    boolean valid_file_found = FALSE;
 
-      if (leveldir_new->level_group)
+    if ((dir = opendir(base_directory)) != NULL)
+    {
+      while ((dir_entry = readdir(dir)) != NULL)
       {
-	/* create node to link back to current level directory */
-	createParentLevelDirNode(leveldir_new);
+	char *entry_name = dir_entry->d_name;
 
-	/* step into sub-directory and look for more level series */
-	LoadLevelInfoFromLevelDir(&leveldir_new->node_group,
-				  leveldir_new, directory_path);
+	if ((type == TREE_TYPE_GRAPHICS_DIR && FileIsGraphic(entry_name)) ||
+	    (type == TREE_TYPE_SOUNDS_DIR && FileIsSound(entry_name)) ||
+	    (type == TREE_TYPE_MUSIC_DIR && FileIsMusic(entry_name)))
+	{
+	  valid_file_found = TRUE;
+	  break;
+	}
       }
+
+      closedir(dir);
     }
+
+    if (!valid_file_found)
+    {
+      Error(ERR_WARN, "ignoring artwork directory '%s'", base_directory);
+
+      free(directory_path);
+      free(filename);
+
+      return FALSE;
+    }
+  }
+
+  artwork_new = newTreeInfo();
+  artwork_new->type = type;
+
+  setTreeInfoToDefaultsFromParent(artwork_new, node_parent);
+
+  artwork_new->filename = getStringCopy(directory_name);
+
+  if (setup_file_list)
+  {
+#if 0
+    checkSetupFileListIdentifier(setup_file_list, getCookie("..."));
+#endif
+
+    /* set all structure fields according to the token/value pairs */
+    ldi = *artwork_new;
+    for (i=0; i<NUM_LEVELINFO_TOKENS; i++)
+      setSetupInfo(levelinfo_tokens, i,
+		   getTokenValue(setup_file_list, levelinfo_tokens[i].text));
+    *artwork_new = ldi;
+
+    DrawInitText(artwork_new->name, 150, FC_YELLOW);
+
+    if (artwork_new->name_short == NULL)
+      artwork_new->name_short = getStringCopy(artwork_new->name);
+
+    if (artwork_new->name_sorting == NULL)
+      artwork_new->name_sorting = getStringCopy(artwork_new->name);
+  }
+  else
+  {
+    if (artwork_new->name != NULL)
+      free(artwork_new->name);
+
+    if (strcmp(artwork_new->filename, ".") == 0)
+      artwork_new->name = getStringCopy("default");
     else
-      Error(ERR_WARN, "ignoring level directory '%s'", directory_path);
+      artwork_new->name = getStringCopy(artwork_new->filename);
+
+    artwork_new->name_short = getStringCopy(artwork_new->name);
+    artwork_new->name_sorting = getStringCopy(artwork_new->name);
+  }
+
+  if (node_parent == NULL)		/* top level group */
+  {
+    artwork_new->basepath = base_directory;
+    artwork_new->fullpath = artwork_new->filename;
+  }
+  else					/* sub level group */
+  {
+    artwork_new->basepath = node_parent->basepath;
+    artwork_new->fullpath = getPath2(node_parent->fullpath, directory_name);
+  }
+
+  check_dir = (type == TREE_TYPE_GRAPHICS_DIR ? options.graphics_directory :
+	       type == TREE_TYPE_SOUNDS_DIR ? options.sounds_directory :
+	       type == TREE_TYPE_MUSIC_DIR ? options.music_directory : "");
+  artwork_new->user_defined =
+    (artwork_new->basepath == check_dir ? FALSE : TRUE);
+
+#if 0
+  artwork_new->color = LEVELCOLOR(artwork_new);
+  artwork_new->class_desc = getLevelClassDescription(artwork_new);
+#endif
+
+  pushTreeInfo(node_first, artwork_new);
+
+  freeSetupFileList(setup_file_list);
+
+  free(directory_path);
+  free(filename);
+
+  return TRUE;
+}
+
+static void LoadArtworkInfoFromArtworkDir(TreeInfo **node_first,
+					  TreeInfo *node_parent,
+					  char *base_directory, int type)
+{
+  DIR *dir;
+  struct dirent *dir_entry;
+  boolean valid_entry_found = FALSE;
+
+  if ((dir = opendir(base_directory)) == NULL)
+  {
+    if ((type == TREE_TYPE_GRAPHICS_DIR &&
+	 base_directory == options.graphics_directory) ||
+	(type == TREE_TYPE_SOUNDS_DIR &&
+	 base_directory == options.sounds_directory) ||
+	(type == TREE_TYPE_MUSIC_DIR &&
+	 base_directory == options.music_directory))
+      Error(ERR_WARN, "cannot read directory '%s'", base_directory);
+    return;
+  }
+
+  while ((dir_entry = readdir(dir)) != NULL)	/* loop until last dir entry */
+  {
+    struct stat file_status;
+    char *directory_name = dir_entry->d_name;
+    char *directory_path = getPath2(base_directory, directory_name);
+
+    /* skip entries for current and parent directory */
+    if (strcmp(directory_name, ".")  == 0 ||
+	strcmp(directory_name, "..") == 0)
+    {
+      free(directory_path);
+      continue;
+    }
+
+    /* find out if directory entry is itself a directory */
+    if (stat(directory_path, &file_status) != 0 ||	/* cannot stat file */
+	(file_status.st_mode & S_IFMT) != S_IFDIR)	/* not a directory */
+    {
+      free(directory_path);
+      continue;
+    }
 
     free(directory_path);
-    free(filename);
+
+    valid_entry_found |= LoadArtworkInfoFromArtworkConf(node_first,node_parent,
+							base_directory,
+							directory_name, type);
   }
 
   closedir(dir);
 
   if (!valid_entry_found)
-    Error(ERR_WARN, "cannot find any valid level series in directory '%s'",
-	  level_directory);
+  {
+    /* check if this directory directly contains an artwork config file */
+    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);
 }
 
-void LoadLevelInfo()
+void LoadArtworkInfo()
 {
-  InitUserLevelDirectory(getLoginName());
+  DrawInitText("Looking for custom artwork:", 120, FC_GREEN);
 
-  DrawInitText("Loading level series:", 120, FC_GREEN);
+  LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
+				options.graphics_directory,
+				TREE_TYPE_GRAPHICS_DIR);
+  LoadArtworkInfoFromArtworkDir(&artwork.gfx_first, NULL,
+				getUserGraphicsDir(NULL),
+				TREE_TYPE_GRAPHICS_DIR);
 
-  LoadLevelInfoFromLevelDir(&leveldir_first, NULL, options.level_directory);
-  LoadLevelInfoFromLevelDir(&leveldir_first, NULL, getUserLevelDir(""));
+  LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
+				options.sounds_directory,
+				TREE_TYPE_SOUNDS_DIR);
+  LoadArtworkInfoFromArtworkDir(&artwork.snd_first, NULL,
+				getUserSoundsDir(NULL),
+				TREE_TYPE_SOUNDS_DIR);
 
-  leveldir_current = getFirstValidLevelSeries(leveldir_first);
+  LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
+				options.music_directory,
+				TREE_TYPE_MUSIC_DIR);
+  LoadArtworkInfoFromArtworkDir(&artwork.mus_first, NULL,
+				getUserMusicDir(NULL),
+				TREE_TYPE_MUSIC_DIR);
 
-  if (leveldir_first == NULL)
-    Error(ERR_EXIT, "cannot find any valid level series in any directory");
+  artwork.gfx_current = artwork.gfx_first;
+  artwork.snd_current = artwork.snd_first;
+  artwork.mus_current = artwork.mus_first;
 
-  sortLevelDirInfo(&leveldir_first, compareLevelDirInfoEntries);
+  sortTreeInfo(&artwork.gfx_first, compareTreeInfoEntries);
+  sortTreeInfo(&artwork.snd_first, compareTreeInfoEntries);
+  sortTreeInfo(&artwork.mus_first, compareTreeInfoEntries);
 
 #if 0
-  dumpLevelDirInfo(leveldir_first, 0);
+  dumpTreeInfo(artwork.gfx_first, 0);
+  dumpTreeInfo(artwork.snd_first, 0);
+  dumpTreeInfo(artwork.mus_first, 0);
 #endif
 }
 
@@ -1311,7 +1661,7 @@ static void SaveUserLevelInfo()
   }
 
   /* always start with reliable default values */
-  setLevelDirInfoToDefaults(&ldi);
+  setTreeInfoToDefaults(&ldi);
 
   ldi.name = getLoginName();
   ldi.author = getRealName();
@@ -1335,66 +1685,82 @@ static void SaveUserLevelInfo()
   SetFilePermissions(filename, PERMS_PRIVATE);
 }
 
-char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
+char *getSetupValue(int type, void *value)
 {
-  int i;
-  static char entry[MAX_LINE_LEN];
-  int token_type = token_info[token_nr].type;
-  void *setup_value = token_info[token_nr].value;
-  char *token_text = token_info[token_nr].text;
-
-  /* start with the prefix, token and some spaces to format output line */
-  sprintf(entry, "%s%s:", prefix, token_text);
-  for (i=strlen(entry); i<TOKEN_VALUE_POSITION; i++)
-    strcat(entry, " ");
+  static char value_string[MAX_LINE_LEN];
 
-  /* continue with the token's value (which can have different types) */
-  switch (token_type)
+  switch (type)
   {
     case TYPE_BOOLEAN:
-      strcat(entry, (*(boolean *)setup_value ? "true" : "false"));
+      strcpy(value_string, (*(boolean *)value ? "true" : "false"));
       break;
 
     case TYPE_SWITCH:
-      strcat(entry, (*(boolean *)setup_value ? "on" : "off"));
+      strcpy(value_string, (*(boolean *)value ? "on" : "off"));
       break;
 
-    case TYPE_KEY:
-      {
-	Key key = *(Key *)setup_value;
-	char *keyname = getKeyNameFromKey(key);
+    case TYPE_YES_NO:
+      strcpy(value_string, (*(boolean *)value ? "yes" : "no"));
+      break;
 
-	strcat(entry, getX11KeyNameFromKey(key));
-	for (i=strlen(entry); i<50; i++)
-	  strcat(entry, " ");
+    case TYPE_KEY:
+      strcpy(value_string, getKeyNameFromKey(*(Key *)value));
+      break;
 
-	/* add comment, if useful */
-	if (strcmp(keyname, "(undefined)") != 0 &&
-	    strcmp(keyname, "(unknown)") != 0)
-	{
-	  strcat(entry, "# ");
-	  strcat(entry, keyname);
-	}
-      }
+    case TYPE_KEY_X11:
+      strcpy(value_string, getX11KeyNameFromKey(*(Key *)value));
       break;
 
     case TYPE_INTEGER:
-      {
-	char buffer[MAX_LINE_LEN];
-
-	sprintf(buffer, "%d", *(int *)setup_value);
-	strcat(entry, buffer);
-      }
+      sprintf(value_string, "%d", *(int *)value);
       break;
 
     case TYPE_STRING:
-      strcat(entry, *(char **)setup_value);
+      strcpy(value_string, *(char **)value);
       break;
 
     default:
+      value_string[0] = '\0';
       break;
   }
 
+  return value_string;
+}
+
+char *getSetupLine(struct TokenInfo *token_info, char *prefix, int token_nr)
+{
+  int i;
+  static char entry[MAX_LINE_LEN];
+  int token_type = token_info[token_nr].type;
+  void *setup_value = token_info[token_nr].value;
+  char *token_text = token_info[token_nr].text;
+  char *value_string = getSetupValue(token_type, setup_value);
+
+  /* start with the prefix, token and some spaces to format output line */
+  sprintf(entry, "%s%s:", prefix, token_text);
+  for (i=strlen(entry); i<TOKEN_VALUE_POSITION; i++)
+    strcat(entry, " ");
+
+  /* continue with the token's value (which can have different types) */
+  strcat(entry, value_string);
+
+  if (token_type == TYPE_KEY_X11)
+  {
+    Key key = *(Key *)setup_value;
+    char *keyname = getKeyNameFromKey(key);
+
+    /* add comment, if useful */
+    if (strcmp(keyname, "(undefined)") != 0 &&
+	strcmp(keyname, "(unknown)") != 0)
+    {
+      for (i=strlen(entry); i<50; i++)
+	strcat(entry, " ");
+
+      strcat(entry, "# ");
+      strcat(entry, keyname);
+    }
+  }
+
   return entry;
 }
 
@@ -1417,7 +1783,7 @@ void LoadLevelSetup_LastSeries()
     char *last_level_series =
       getTokenValue(level_setup_list, TOKEN_STR_LAST_LEVEL_SERIES);
 
-    leveldir_current = getLevelDirInfoFromFilename(last_level_series);
+    leveldir_current = getTreeInfoFromFilename(last_level_series);
     if (leveldir_current == NULL)
       leveldir_current = leveldir_first;
 
@@ -1472,7 +1838,7 @@ static void checkSeriesInfo()
   /* check for more levels besides the 'levels' field of 'levelinfo.conf' */
 
   level_directory = getPath2((leveldir_current->user_defined ?
-			      getUserLevelDir("") :
+			      getUserLevelDir(NULL) :
 			      options.level_directory),
 			     leveldir_current->fullpath);