X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fmisc.c;h=abea627781cfebb3d2a20b09351055ccc69177e4;hb=ee0895b12e544444db37febb1242bcc8a72d6ad8;hp=6db94000c6a955dc0c053639f310fef91b8e0c70;hpb=28f0f8708f4b4f8c4f39f1b23bc5fc7e0fed7579;p=rocksndiamonds.git

diff --git a/src/libgame/misc.c b/src/libgame/misc.c
index 6db94000..abea6277 100644
--- a/src/libgame/misc.c
+++ b/src/libgame/misc.c
@@ -32,6 +32,60 @@
 #include "text.h"
 
 
+/* ------------------------------------------------------------------------- */
+/* some generic helper functions                                             */
+/* ------------------------------------------------------------------------- */
+
+void fprintf_line(FILE *stream, char *line_string, int line_length)
+{
+  int i;
+
+  for (i=0; i<line_length; i++)
+    fprintf(stream, "%s", line_string);
+
+  fprintf(stream, "\n");
+}
+
+void printf_line(char *line_string, int line_length)
+{
+  fprintf_line(stdout, line_string, line_length);
+}
+
+/* int2str() returns a number converted to a string;
+   the used memory is static, but will be overwritten by later calls,
+   so if you want to save the result, copy it to a private string buffer;
+   there can be 10 local calls of int2str() without buffering the result --
+   the 11th call will then destroy the result from the first call and so on.
+*/
+
+char *int2str(int number, int size)
+{
+  static char shift_array[10][40];
+  static int shift_counter = 0;
+  char *s = shift_array[shift_counter];
+
+  shift_counter = (shift_counter + 1) % 10;
+
+  if (size > 20)
+    size = 20;
+
+  if (size)
+  {
+    sprintf(s, "                    %09d", number);
+    return &s[strlen(s) - size];
+  }
+  else
+  {
+    sprintf(s, "%d", number);
+    return s;
+  }
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* counter functions                                                         */
+/* ------------------------------------------------------------------------- */
+
 #if defined(PLATFORM_MSDOS)
 volatile unsigned long counter = 0;
 
@@ -202,35 +256,10 @@ void WaitUntilDelayReached(unsigned long *counter_var, unsigned long delay)
   *counter_var = actual_counter;
 }
 
-/* int2str() returns a number converted to a string;
-   the used memory is static, but will be overwritten by later calls,
-   so if you want to save the result, copy it to a private string buffer;
-   there can be 10 local calls of int2str() without buffering the result --
-   the 11th call will then destroy the result from the first call and so on.
-*/
-
-char *int2str(int number, int size)
-{
-  static char shift_array[10][40];
-  static int shift_counter = 0;
-  char *s = shift_array[shift_counter];
-
-  shift_counter = (shift_counter + 1) % 10;
-
-  if (size > 20)
-    size = 20;
 
-  if (size)
-  {
-    sprintf(s, "                    %09d", number);
-    return &s[strlen(s) - size];
-  }
-  else
-  {
-    sprintf(s, "%d", number);
-    return s;
-  }
-}
+/* ------------------------------------------------------------------------- */
+/* random generator functions                                                */
+/* ------------------------------------------------------------------------- */
 
 unsigned int SimpleRND(unsigned int max)
 {
@@ -302,6 +331,11 @@ unsigned int InitRND(long seed)
 #endif
 }
 
+
+/* ------------------------------------------------------------------------- */
+/* system info functions                                                     */
+/* ------------------------------------------------------------------------- */
+
 char *getLoginName()
 {
 #if defined(PLATFORM_WIN32)
@@ -384,6 +418,11 @@ char *getHomeDir()
 #endif
 }
 
+
+/* ------------------------------------------------------------------------- */
+/* various string functions                                                  */
+/* ------------------------------------------------------------------------- */
+
 char *getPath2(char *path1, char *path2)
 {
   char *complete_path = checked_malloc(strlen(path1) + 1 +
@@ -403,6 +442,14 @@ char *getPath3(char *path1, char *path2, char *path3)
   return complete_path;
 }
 
+static char *getStringCat2(char *s1, char *s2)
+{
+  char *complete_string = checked_malloc(strlen(s1) + strlen(s2) + 1);
+
+  sprintf(complete_string, "%s%s", s1, s2);
+  return complete_string;
+}
+
 char *getStringCopy(char *s)
 {
   char *s_copy;
@@ -428,6 +475,40 @@ char *getStringToLower(char *s)
   return s_copy;
 }
 
+
+/* ------------------------------------------------------------------------- */
+/* command line option handling functions                                    */
+/* ------------------------------------------------------------------------- */
+
+static void printUsage()
+{
+  printf("\n"
+	 "Usage: %s [OPTION]... [HOSTNAME [PORT]]\n"
+	 "\n"
+	 "Options:\n"
+	 "  -d, --display HOSTNAME[:SCREEN]  specify X server display\n"
+	 "  -b, --basepath DIRECTORY         alternative base DIRECTORY\n"
+	 "  -l, --level DIRECTORY            alternative level DIRECTORY\n"
+	 "  -g, --graphics DIRECTORY         alternative graphics DIRECTORY\n"
+	 "  -s, --sounds DIRECTORY           alternative sounds DIRECTORY\n"
+	 "  -m, --music DIRECTORY            alternative music DIRECTORY\n"
+	 "  -n, --network                    network multiplayer game\n"
+	 "      --serveronly                 only start network server\n"
+	 "  -v, --verbose                    verbose mode\n"
+	 "      --debug                      display debugging information\n"
+	 "  -e, --execute COMMAND            execute batch COMMAND:\n"
+	 "\n"
+	 "Valid commands for '--execute' option:\n"
+	 "  \"print graphicsinfo.conf\"        print default graphics config\n"
+	 "  \"print soundsinfo.conf\"          print default sounds config\n"
+	 "  \"print musicinfo.conf\"           print default music config\n"
+	 "  \"dump level FILE\"                dump level data from FILE\n"
+	 "  \"dump tape FILE\"                 dump tape data from FILE\n"
+	 "  \"autoplay LEVELDIR\"              play level tapes for LEVELDIR\n"
+	 "\n",
+	 program.command_basename);
+}
+
 void GetOptions(char *argv[])
 {
   char **options_left = &argv[1];
@@ -442,11 +523,11 @@ void GetOptions(char *argv[])
   options.graphics_directory = RO_BASE_PATH "/" GRAPHICS_DIRECTORY;
   options.sounds_directory = RO_BASE_PATH "/" SOUNDS_DIRECTORY;
   options.music_directory = RO_BASE_PATH "/" MUSIC_DIRECTORY;
+  options.execute_command = NULL;
   options.serveronly = FALSE;
   options.network = FALSE;
   options.verbose = FALSE;
   options.debug = FALSE;
-  options.debug_command = NULL;
 
   while (*options_left)
   {
@@ -484,22 +565,7 @@ void GetOptions(char *argv[])
       Error(ERR_EXIT_HELP, "unrecognized option '%s'", option);
     else if (strncmp(option, "-help", option_len) == 0)
     {
-      printf("Usage: %s [options] [<server host> [<server port>]]\n"
-	     "Options:\n"
-	     "  -d, --display <host>[:<scr>]  X server display\n"
-	     "  -b, --basepath <directory>    alternative base directory\n"
-	     "  -l, --level <directory>       alternative level directory\n"
-	     "  -g, --graphics <directory>    alternative graphics directory\n"
-	     "  -s, --sounds <directory>      alternative sounds directory\n"
-	     "  -m, --music <directory>       alternative music directory\n"
-	     "  -n, --network                 network multiplayer game\n"
-	     "      --serveronly              only start network server\n"
-	     "  -v, --verbose                 verbose mode\n"
-	     "      --debug                   display debugging information\n",
-	     program.command_basename);
-
-      if (options.debug)
-	printf("      --debug-command <command> execute special command\n");
+      printUsage();
 
       exit(0);
     }
@@ -579,12 +645,12 @@ void GetOptions(char *argv[])
     {
       options.debug = TRUE;
     }
-    else if (strncmp(option, "-debug-command", option_len) == 0)
+    else if (strncmp(option, "-execute", option_len) == 0)
     {
       if (option_arg == NULL)
 	Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 
-      options.debug_command = option_arg;
+      options.execute_command = option_arg;
       if (option_arg == next_option)
 	options_left++;
     }
@@ -609,6 +675,11 @@ void GetOptions(char *argv[])
   }
 }
 
+
+/* ------------------------------------------------------------------------- */
+/* error handling functions                                                  */
+/* ------------------------------------------------------------------------- */
+
 /* used by SetError() and GetError() to store internal error messages */
 static char internal_error[1024];	/* this is bad */
 
@@ -628,6 +699,7 @@ char *GetError()
 
 void Error(int mode, char *format, ...)
 {
+  static boolean last_line_was_separator = FALSE;
   char *process_name = "";
   FILE *error = stderr;
   char *newline = "\n";
@@ -636,6 +708,18 @@ void Error(int mode, char *format, ...)
   if (mode & ERR_WARN && !options.verbose)
     return;
 
+  if (mode == ERR_RETURN_LINE)
+  {
+    if (!last_line_was_separator)
+      fprintf_line(error, format, 79);
+
+    last_line_was_separator = TRUE;
+
+    return;
+  }
+
+  last_line_was_separator = FALSE;
+
 #if defined(PLATFORM_MSDOS)
   newline = "\r\n";
 
@@ -689,6 +773,11 @@ void Error(int mode, char *format, ...)
   }
 }
 
+
+/* ------------------------------------------------------------------------- */
+/* memory allocation functions                                               */
+/* ------------------------------------------------------------------------- */
+
 void *checked_malloc(unsigned long size)
 {
   void *ptr;
@@ -723,6 +812,11 @@ void *checked_realloc(void *ptr, unsigned long size)
   return ptr;
 }
 
+
+/* ------------------------------------------------------------------------- */
+/* various helper functions                                                  */
+/* ------------------------------------------------------------------------- */
+
 inline void swap_numbers(int *i1, int *i2)
 {
   int help = *i1;
@@ -1213,9 +1307,66 @@ char getCharFromKey(Key key)
 }
 
 
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
+/* functions to translate string identifiers to integer or boolean value     */
+/* ------------------------------------------------------------------------- */
+
+int get_integer_from_string(char *s)
+{
+  static char *number_text[][3] =
+  {
+    { "0", "zero", "null", },
+    { "1", "one", "first" },
+    { "2", "two", "second" },
+    { "3", "three", "third" },
+    { "4", "four", "fourth" },
+    { "5", "five", "fifth" },
+    { "6", "six", "sixth" },
+    { "7", "seven", "seventh" },
+    { "8", "eight", "eighth" },
+    { "9", "nine", "ninth" },
+    { "10", "ten", "tenth" },
+    { "11", "eleven", "eleventh" },
+    { "12", "twelve", "twelfth" },
+  };
+
+  int i, j;
+  char *s_lower = getStringToLower(s);
+  int result = -1;
+
+  for (i=0; i<13; i++)
+    for (j=0; j<3; j++)
+      if (strcmp(s_lower, number_text[i][j]) == 0)
+	result = i;
+
+  if (result == -1)
+    result = atoi(s);
+
+  free(s_lower);
+
+  return result;
+}
+
+boolean get_boolean_from_string(char *s)
+{
+  char *s_lower = getStringToLower(s);
+  boolean result = FALSE;
+
+  if (strcmp(s_lower, "true") == 0 ||
+      strcmp(s_lower, "yes") == 0 ||
+      strcmp(s_lower, "on") == 0 ||
+      get_integer_from_string(s) == 1)
+    result = TRUE;
+
+  free(s_lower);
+
+  return result;
+}
+
+
+/* ------------------------------------------------------------------------- */
 /* functions for generic lists                                               */
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
 
 ListNode *newListNode()
 {
@@ -1285,7 +1436,7 @@ void dumpList(ListNode *node_first)
   while (node)
   {
     printf("['%s' (%d)]\n", node->key,
-	   ((struct ArtworkListNodeInfo *)node->content)->num_references);
+	   ((struct ListNodeInfo *)node->content)->num_references);
     node = node->next;
   }
 
@@ -1293,9 +1444,9 @@ void dumpList(ListNode *node_first)
 }
 
 
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
 /* functions for checking filenames                                          */
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
 
 boolean FileIsGraphic(char *filename)
 {
@@ -1344,52 +1495,235 @@ boolean FileIsArtworkType(char *basename, int type)
   return FALSE;
 }
 
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
 /* functions for loading artwork configuration information                   */
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
 
-static void LoadArtworkConfig(struct ArtworkListInfo *artwork_info)
+static int get_parameter_value(int type, char *value)
 {
-  int num_list_entries = artwork_info->num_list_entries;
-  struct ArtworkConfigInfo *config_list = artwork_info->config_list;
+  return (strcmp(value, ARG_UNDEFINED) == 0 ? ARG_UNDEFINED_VALUE :
+	  type == TYPE_INTEGER ? get_integer_from_string(value) :
+	  type == TYPE_BOOLEAN ? get_boolean_from_string(value) :
+	  -1);
+}
+
+struct FileInfo *getFileListFromConfigList(struct ConfigInfo *config_list,
+					   struct ConfigInfo *suffix_list,
+					   int num_file_list_entries)
+{
+  struct FileInfo *file_list;
+  int num_file_list_entries_found = 0;
+  int num_suffix_list_entries = 0;
+  int list_pos = 0;
+  int i, j;
+
+  file_list = checked_calloc(num_file_list_entries * sizeof(struct FileInfo));
+
+  for (i=0; suffix_list[i].token != NULL; i++)
+    num_suffix_list_entries++;
+
+  /* always start with reliable default values */
+  for (i=0; i<num_file_list_entries; i++)
+  {
+    file_list[i].token = NULL;
+    file_list[i].default_filename = NULL;
+    file_list[i].filename = NULL;
+
+    if (num_suffix_list_entries > 0)
+    {
+      int parameter_array_size = num_suffix_list_entries * sizeof(int);
+
+      file_list[i].default_parameter = checked_calloc(parameter_array_size);
+      file_list[i].parameter = checked_calloc(parameter_array_size);
+
+      for (j=0; j<num_suffix_list_entries; j++)
+      {
+	int default_parameter =
+	  get_parameter_value(suffix_list[j].type, suffix_list[j].value);
+
+	file_list[i].default_parameter[j] = default_parameter;
+	file_list[i].parameter[j] = default_parameter;
+      }
+    }
+  }
+
+  for (i=0; config_list[i].token != NULL; i++)
+  {
+    int len_config_token = strlen(config_list[i].token);
+    int len_config_value = strlen(config_list[i].value);
+    boolean is_file_entry = TRUE;
+
+    for (j=0; suffix_list[j].token != NULL; j++)
+    {
+      int len_suffix = strlen(suffix_list[j].token);
+
+      if (len_suffix < len_config_token &&
+	  strcmp(&config_list[i].token[len_config_token - len_suffix],
+		 suffix_list[j].token) == 0)
+      {
+	file_list[list_pos].default_parameter[j] =
+	  get_parameter_value(suffix_list[j].type, config_list[i].value);
+
+	is_file_entry = FALSE;
+	break;
+      }
+    }
+
+    if (is_file_entry)
+    {
+      if (i > 0)
+	list_pos++;
+
+      if (list_pos >= num_file_list_entries)
+	break;
+
+      /* simple sanity check if this is really a file definition */
+      if (strcmp(&config_list[i].value[len_config_value - 4], ".pcx") != 0 &&
+	  strcmp(&config_list[i].value[len_config_value - 4], ".wav") != 0 &&
+	  strcmp(config_list[i].value, UNDEFINED_FILENAME) != 0)
+      {
+	Error(ERR_RETURN, "Configuration directive '%s' -> '%s':",
+	      config_list[i].token, config_list[i].value);
+	Error(ERR_EXIT, "This seems to be no valid definition -- please fix");
+      }
+
+      file_list[list_pos].token = config_list[i].token;
+      file_list[list_pos].default_filename = config_list[i].value;
+    }
+  }
+
+  num_file_list_entries_found = list_pos + 1;
+  if (num_file_list_entries_found != num_file_list_entries)
+  {
+    Error(ERR_RETURN, "inconsistant config list information:");
+    Error(ERR_RETURN, "- should be:   %d (according to 'src/conf_gfx.h')",
+	  num_file_list_entries);
+    Error(ERR_RETURN, "- found to be: %d (according to 'src/conf_gfx.c')",
+	  num_file_list_entries_found);
+    Error(ERR_EXIT,   "please fix");
+  }
+
+  return file_list;
+}
+
+void LoadArtworkConfig(struct ArtworkListInfo *artwork_info)
+{
+  struct FileInfo *file_list = artwork_info->file_list;
+  struct ConfigInfo *suffix_list = artwork_info->suffix_list;
+  int num_file_list_entries = artwork_info->num_file_list_entries;
+  int num_suffix_list_entries = artwork_info->num_suffix_list_entries;
   char *filename = getCustomArtworkConfigFilename(artwork_info->type);
   struct SetupFileList *setup_file_list;
-  int i;
+  char *known_token_value = "[KNOWN_TOKEN]";
+  int i, j;
 
 #if 0
   printf("GOT CUSTOM ARTWORK CONFIG FILE '%s'\n", filename);
 #endif
 
   /* always start with reliable default values */
-  for (i=0; i<num_list_entries; i++)
-    config_list[i].filename = NULL;
+  for (i=0; i<num_file_list_entries; i++)
+  {
+    if (file_list[i].filename != NULL)
+      free(file_list[i].filename);
+    file_list[i].filename = NULL;
+
+    for (j=0; j<num_suffix_list_entries; j++)
+      file_list[i].parameter[j] = file_list[i].default_parameter[j];
+  }
 
   if (filename == NULL)
     return;
 
-  if ((setup_file_list = loadSetupFileList(filename)))
+  if ((setup_file_list = loadSetupFileList(filename)) == NULL)
+    return;
+
+  for (i=0; i<num_file_list_entries; i++)
   {
-    for (i=0; i<num_list_entries; i++)
-      config_list[i].filename =
-	getStringCopy(getTokenValue(setup_file_list, config_list[i].token));
+    /* check for config token that is the base token without any suffixes */
+    char *filename = getTokenValue(setup_file_list, file_list[i].token);
 
-    freeSetupFileList(setup_file_list);
+    if (filename != NULL)
+    {
+      for (j=0; j<num_suffix_list_entries; j++)
+	file_list[i].parameter[j] =
+	  get_parameter_value(suffix_list[j].type, suffix_list[j].value);
 
-#if 0
-    for (i=0; i<num_list_entries; i++)
+      file_list[i].filename = getStringCopy(filename);
+
+      /* mark token as well known from default config */
+      setTokenValue(setup_file_list, file_list[i].token, known_token_value);
+    }
+    else
+      file_list[i].filename = getStringCopy(file_list[i].default_filename);
+
+    /* check for config tokens that can be build by base token and suffixes */
+    for (j=0; j<num_suffix_list_entries; j++)
     {
-      printf("'%s' ", config_list[i].token);
-      if (config_list[i].filename)
-	printf("-> '%s'\n", config_list[i].filename);
-      else
-	printf("-> UNDEFINED [-> '%s']\n", config_list[i].default_filename);
+      char *token = getStringCat2(file_list[i].token, suffix_list[j].token);
+      char *value = getTokenValue(setup_file_list, token);
+
+      if (value != NULL)
+      {
+	file_list[i].parameter[j] =
+	  get_parameter_value(suffix_list[j].type, value);
+
+	/* mark token as well known from default config */
+	setTokenValue(setup_file_list, token, known_token_value);
+      }
+
+      free(token);
     }
-#endif
   }
+
+  /* set some additional tokens to "known" */
+  setTokenValue(setup_file_list, "name", known_token_value);
+  setTokenValue(setup_file_list, "sort_priority", known_token_value);
+
+  if (options.verbose && !IS_CHILD_PROCESS(audio.mixer_pid))
+  {
+    boolean unknown_tokens_found = FALSE;
+
+    /* check each token in config file if it is defined in default config */
+    while (setup_file_list != NULL)
+    {
+      if (strcmp(setup_file_list->value, known_token_value) != 0)
+      {
+	if (!unknown_tokens_found)
+	{
+	  Error(ERR_RETURN_LINE, "-");
+	  Error(ERR_RETURN, "warning: unknown token(s) found in config file:");
+	  Error(ERR_RETURN, "- config file: '%s'", filename);
+
+	  unknown_tokens_found = TRUE;
+	}
+
+	Error(ERR_RETURN, "- unknown token: '%s'", setup_file_list->token);
+      }
+
+      setup_file_list = setup_file_list->next;
+    }
+
+    if (unknown_tokens_found)
+      Error(ERR_RETURN_LINE, "-");
+  }
+
+  freeSetupFileList(setup_file_list);
+
+#if 0
+  for (i=0; i<num_file_list_entries; i++)
+  {
+    printf("'%s' ", file_list[i].token);
+    if (file_list[i].filename)
+      printf("-> '%s'\n", file_list[i].filename);
+    else
+      printf("-> UNDEFINED [-> '%s']\n", file_list[i].default_filename);
+  }
+#endif
 }
 
-void deleteArtworkListEntry(struct ArtworkListInfo *artwork_info,
-			    struct ArtworkListNodeInfo **listnode)
+static void deleteArtworkListEntry(struct ArtworkListInfo *artwork_info,
+				   struct ListNodeInfo **listnode)
 {
   if (*listnode)
   {
@@ -1405,7 +1739,7 @@ void deleteArtworkListEntry(struct ArtworkListInfo *artwork_info,
       printf("[deleting artwork '%s']\n", filename);
 #endif
 
-      deleteNodeFromList(&artwork_info->file_list, filename,
+      deleteNodeFromList(&artwork_info->content_list, filename,
 			 artwork_info->free_artwork);
     }
 
@@ -1414,10 +1748,30 @@ void deleteArtworkListEntry(struct ArtworkListInfo *artwork_info,
 }
 
 static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
-				    struct ArtworkListNodeInfo **listnode,
-				    char *filename)
-{
+				    struct ListNodeInfo **listnode,
+				    char *basename)
+{
+  char *init_text[] =
+  { "",
+    "Loading graphics:",
+    "Loading sounds:",
+    "Loading music:"
+  };
+
   ListNode *node;
+  char *filename = getCustomArtworkFilename(basename, artwork_info->type);
+
+  if (filename == NULL)
+  {
+    int error_mode = ERR_WARN;
+
+    /* we can get away without sounds and music, but not without graphics */
+    if (*listnode == NULL && artwork_info->type == ARTWORK_TYPE_GRAPHICS)
+      error_mode = ERR_EXIT;
+
+    Error(error_mode, "cannot find artwork file '%s'", basename);
+    return;
+  }
 
   /* check if the old and the new artwork file are the same */
   if (*listnode && strcmp((*listnode)->source_filename, filename) == 0)
@@ -1437,28 +1791,51 @@ static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
   deleteArtworkListEntry(artwork_info, listnode);
 
   /* check if the new artwork file already exists in the list of artworks */
-  if ((node = getNodeFromKey(artwork_info->file_list, filename)) != NULL)
+  if ((node = getNodeFromKey(artwork_info->content_list, filename)) != NULL)
   {
 #if 0
       printf("[artwork '%s' already exists (other list entry)]\n", filename);
 #endif
 
-      *listnode = (struct ArtworkListNodeInfo *)node->content;
+      *listnode = (struct ListNodeInfo *)node->content;
       (*listnode)->num_references++;
+
+      return;
   }
-  else if ((*listnode = artwork_info->load_artwork(filename)) != NULL)
+
+  DrawInitText(init_text[artwork_info->type], 120, FC_GREEN);
+  DrawInitText(basename, 150, FC_YELLOW);
+
+  if ((*listnode = artwork_info->load_artwork(filename)) != NULL)
   {
+#if 0
+      printf("[adding new artwork '%s']\n", filename);
+#endif
+
     (*listnode)->num_references = 1;
-    addNodeToList(&artwork_info->file_list, (*listnode)->source_filename,
+    addNodeToList(&artwork_info->content_list, (*listnode)->source_filename,
 		  *listnode);
   }
+  else
+  {
+    int error_mode = ERR_WARN;
+
+    /* we can get away without sounds and music, but not without graphics */
+    if (artwork_info->type == ARTWORK_TYPE_GRAPHICS)
+      error_mode = ERR_EXIT;
+
+    Error(error_mode, "cannot load artwork file '%s'", basename);
+    return;
+  }
 }
 
 static void LoadCustomArtwork(struct ArtworkListInfo *artwork_info,
-			      struct ArtworkListNodeInfo **listnode,
+			      struct ListNodeInfo **listnode,
 			      char *basename)
 {
+#if 0
   char *filename = getCustomArtworkFilename(basename, artwork_info->type);
+#endif
 
 #if 0
   printf("GOT CUSTOM ARTWORK FILE '%s'\n", filename);
@@ -1470,6 +1847,7 @@ static void LoadCustomArtwork(struct ArtworkListInfo *artwork_info,
     return;
   }
 
+#if 0
   if (filename == NULL)
   {
     Error(ERR_WARN, "cannot find artwork file '%s'", basename);
@@ -1477,18 +1855,21 @@ static void LoadCustomArtwork(struct ArtworkListInfo *artwork_info,
   }
 
   replaceArtworkListEntry(artwork_info, listnode, filename);
+#else
+  replaceArtworkListEntry(artwork_info, listnode, basename);
+#endif
 }
 
-void LoadArtworkToList(struct ArtworkListInfo *artwork_info,
-		       char *basename, int list_pos)
+static void LoadArtworkToList(struct ArtworkListInfo *artwork_info,
+			      char *basename, int list_pos)
 {
   if (artwork_info->artwork_list == NULL ||
-      list_pos >= artwork_info->num_list_entries)
+      list_pos >= artwork_info->num_file_list_entries)
     return;
 
 #if 0
   printf("loading artwork '%s' ...  [%d]\n",
-	 basename, getNumNodes(artwork_info->file_list));
+	 basename, getNumNodes(artwork_info->content_list));
 #endif
 
   LoadCustomArtwork(artwork_info, &artwork_info->artwork_list[list_pos],
@@ -1496,12 +1877,13 @@ void LoadArtworkToList(struct ArtworkListInfo *artwork_info,
 
 #if 0
   printf("loading artwork '%s' done [%d]\n",
-	 basename, getNumNodes(artwork_info->file_list));
+	 basename, getNumNodes(artwork_info->content_list));
 #endif
 }
 
-void ReloadCustomArtworkFiles(struct ArtworkListInfo *artwork_info)
+void ReloadCustomArtworkList(struct ArtworkListInfo *artwork_info)
 {
+#if 0
   static struct
   {
     char *text;
@@ -1514,55 +1896,83 @@ void ReloadCustomArtworkFiles(struct ArtworkListInfo *artwork_info)
     { "Loading sounds:",	TRUE },
     { "Loading music:",		TRUE }
   };
+#endif
 
-  int num_list_entries = artwork_info->num_list_entries;
-  struct ArtworkConfigInfo *config_list = artwork_info->config_list;
+  int num_file_list_entries = artwork_info->num_file_list_entries;
+  struct FileInfo *file_list = artwork_info->file_list;
   int i;
 
 #if 0
-  Delay(5000);
+  LoadArtworkConfig(artwork_info);
 #endif
 
 #if 0
-  printf("DEBUG: reloading sounds '%s' ...\n",artwork.snd_current_identifier);
-#endif
-
-  LoadArtworkConfig(artwork_info);
-
   if (draw_init[artwork_info->type].do_it)
     DrawInitText(draw_init[artwork_info->type].text, 120, FC_GREEN);
+#endif
 
 #if 0
-  printf("DEBUG: reloading %d sounds ...\n", num_list_entries);
+  printf("DEBUG: reloading %d artwork files ...\n", num_file_list_entries);
 #endif
 
-  for(i=0; i<num_list_entries; i++)
+  for(i=0; i<num_file_list_entries; i++)
   {
+#if 0
     if (draw_init[artwork_info->type].do_it)
-      DrawInitText(config_list[i].token, 150, FC_YELLOW);
+      DrawInitText(file_list[i].token, 150, FC_YELLOW);
+#endif
 
-    if (config_list[i].filename)
-      LoadArtworkToList(artwork_info, config_list[i].filename, i);
-    else
-      LoadArtworkToList(artwork_info, config_list[i].default_filename, i);
+    LoadArtworkToList(artwork_info, file_list[i].filename, i);
+
+#if 0
+    printf("DEBUG:   loading artwork file '%s'...\n", file_list[i].filename);
+#endif
   }
 
+#if 0
   draw_init[artwork_info->type].do_it = FALSE;
+#endif
 
   /*
-  printf("list size == %d\n", getNumNodes(artwork_info->file_list));
+  printf("list size == %d\n", getNumNodes(artwork_info->content_list));
   */
 
 #if 0
-  dumpList(artwork_info->file_list);
+  dumpList(artwork_info->content_list);
 #endif
 }
 
+void FreeCustomArtworkList(struct ArtworkListInfo *artwork_info)
+{
+  int i;
 
-/* ========================================================================= */
+  if (artwork_info == NULL || artwork_info->artwork_list == NULL)
+    return;
+
+#if 0
+  printf("%s: FREEING ARTWORK ...\n",
+	 IS_CHILD_PROCESS(audio.mixer_pid) ? "CHILD" : "PARENT");
+#endif
+
+  for(i=0; i<artwork_info->num_file_list_entries; i++)
+    deleteArtworkListEntry(artwork_info, &artwork_info->artwork_list[i]);
+
+#if 0
+  printf("%s: FREEING ARTWORK -- DONE\n",
+	 IS_CHILD_PROCESS(audio.mixer_pid) ? "CHILD" : "PARENT");
+#endif
+
+  free(artwork_info->artwork_list);
+
+  artwork_info->artwork_list = NULL;
+  artwork_info->num_file_list_entries = 0;
+}
+
+
+/* ------------------------------------------------------------------------- */
 /* functions only needed for non-Unix (non-command-line) systems             */
 /* (MS-DOS only; SDL/Windows creates files "stdout.txt" and "stderr.txt")    */
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
 
 #if defined(PLATFORM_MSDOS)
 
@@ -1593,9 +2003,9 @@ void dumpErrorFile()
 #endif
 
 
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
 /* the following is only for debugging purpose and normally not used         */
-/* ========================================================================= */
+/* ------------------------------------------------------------------------- */
 
 #define DEBUG_NUM_TIMESTAMPS	3