X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Flibgame%2Fmisc.c;h=fedc30487786287ea3e99dc75cb4aab57243e1af;hp=d57b83807a249e6cb9c339ae0a3d4803fedda5e1;hb=34dc736661e297f75d604335a7d85ea34d14c55d;hpb=c8020d330cab48d59515e0e3b7e2f856630ef80b

diff --git a/src/libgame/misc.c b/src/libgame/misc.c
index d57b8380..fedc3048 100644
--- a/src/libgame/misc.c
+++ b/src/libgame/misc.c
@@ -33,13 +33,13 @@
 #include "image.h"
 
 
-/* ========================================================================= */
-/* some generic helper functions                                             */
-/* ========================================================================= */
+// ============================================================================
+// some generic helper functions
+// ============================================================================
 
-/* ------------------------------------------------------------------------- */
-/* logging functions                                                         */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// logging functions
+// ----------------------------------------------------------------------------
 
 #define DUPLICATE_LOG_OUT_TO_STDOUT		TRUE
 #define DUPLICATE_LOG_ERR_TO_STDERR		TRUE
@@ -163,9 +163,9 @@ static void printf_log_line(char *line_chars, int line_length)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* platform independent wrappers for printf() et al.                         */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// platform independent wrappers for printf() et al.
+// ----------------------------------------------------------------------------
 
 void fprintf_line(FILE *file, char *line_chars, int line_length)
 {
@@ -222,6 +222,18 @@ void Print(char *format, ...)
   va_end(ap);
 }
 
+void PrintNoLog(char *format, ...)
+{
+  FILE *file = program.log_file_default[LOG_OUT_ID];
+  va_list ap;
+
+  va_start(ap, format);
+  vfprintf(file, format, ap);
+  va_end(ap);
+
+  fflush(file);
+}
+
 void PrintLine(char *line_chars, int line_length)
 {
   int i;
@@ -239,16 +251,15 @@ void PrintLineWithPrefix(char *prefix, char *line_chars, int line_length)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* string functions                                                          */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// string functions
+// ----------------------------------------------------------------------------
 
 /* 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.
-*/
+   the 11th call will then destroy the result from the first call and so on. */
 
 char *int2str(int number, int size)
 {
@@ -274,9 +285,9 @@ char *int2str(int number, int size)
 }
 
 
-/* something similar to "int2str()" above, but allocates its own memory
-   and has a different interface; we cannot use "itoa()", because this
-   seems to be already defined when cross-compiling to the win32 target */
+// something similar to "int2str()" above, but allocates its own memory
+// and has a different interface; we cannot use "itoa()", because this
+// seems to be already defined when cross-compiling to the win32 target
 
 char *i_to_a(unsigned int i)
 {
@@ -284,7 +295,7 @@ char *i_to_a(unsigned int i)
 
   checked_free(a);
 
-  if (i > 2147483647)	/* yes, this is a kludge */
+  if (i > 2147483647)	// yes, this is a kludge
     i = 2147483647;
 
   a = checked_malloc(10 + 1);
@@ -295,8 +306,8 @@ char *i_to_a(unsigned int i)
 }
 
 
-/* calculate base-2 logarithm of argument (rounded down to integer;
-   this function returns the number of the highest bit set in argument) */
+// calculate base-2 logarithm of argument (rounded down to integer;
+// this function returns the number of the highest bit set in argument)
 
 int log_2(unsigned int x)
 {
@@ -304,7 +315,7 @@ int log_2(unsigned int x)
 
   while ((1 << e) < x)
   {
-    x -= (1 << e);	/* for rounding down (rounding up: remove this line) */
+    x -= (1 << e);	// for rounding down (rounding up: remove this line)
     e++;
   }
 
@@ -317,14 +328,14 @@ boolean getTokenValueFromString(char *string, char **token, char **value)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* counter functions                                                         */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// counter functions
+// ----------------------------------------------------------------------------
 
-/* maximal allowed length of a command line option */
+// maximal allowed length of a command line option
 #define MAX_OPTION_LEN		256
 
-static unsigned int getCurrentMS()
+static unsigned int getCurrentMS(void)
 {
   return SDL_GetTicks();
 }
@@ -334,51 +345,33 @@ static unsigned int mainCounter(int mode)
   static unsigned int base_ms = 0;
   unsigned int current_ms;
 
-  /* get current system milliseconds */
+  // get current system milliseconds
   current_ms = getCurrentMS();
 
-  /* reset base timestamp in case of counter reset or wrap-around */
+  // reset base timestamp in case of counter reset or wrap-around
   if (mode == INIT_COUNTER || current_ms < base_ms)
     base_ms = current_ms;
 
-  /* return milliseconds since last counter reset */
+  // return milliseconds since last counter reset
   return current_ms - base_ms;
 }
 
-void InitCounter()		/* set counter back to zero */
+void InitCounter()		// set counter back to zero
 {
   mainCounter(INIT_COUNTER);
 }
 
-unsigned int Counter()	/* get milliseconds since last call of InitCounter() */
+unsigned int Counter()	// get milliseconds since last call of InitCounter()
 {
   return mainCounter(READ_COUNTER);
 }
 
 static void sleep_milliseconds(unsigned int milliseconds_delay)
 {
-  boolean do_busy_waiting = (milliseconds_delay < 5 ? TRUE : FALSE);
-
-  if (do_busy_waiting)
-  {
-    /* we want to wait only a few ms -- if we assume that we have a
-       kernel timer resolution of 10 ms, we would wait far too long;
-       therefore it's better to do a short interval of busy waiting
-       to get our sleeping time more accurate */
-
-    unsigned int base_counter = Counter(), actual_counter = Counter();
-
-    while (actual_counter < base_counter + milliseconds_delay &&
-	   actual_counter >= base_counter)
-      actual_counter = Counter();
-  }
-  else
-  {
-    SDL_Delay(milliseconds_delay);
-  }
+  SDL_Delay(milliseconds_delay);
 }
 
-void Delay(unsigned int delay)	/* Sleep specified number of milliseconds */
+void Delay(unsigned int delay)	// Sleep specified number of milliseconds
 {
   sleep_milliseconds(delay);
 }
@@ -489,19 +482,19 @@ void SkipUntilDelayReached(unsigned int *counter_var, unsigned int delay,
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* random generator functions                                                */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// random generator functions
+// ----------------------------------------------------------------------------
 
 unsigned int init_random_number(int nr, int seed)
 {
   if (seed == NEW_RANDOMIZE)
   {
-    /* default random seed */
+    // default random seed
     seed = (int)time(NULL);			// seconds since the epoch
 
 #if !defined(PLATFORM_WIN32)
-    /* add some more randomness */
+    // add some more randomness
     struct timeval current_time;
 
     gettimeofday(&current_time, NULL);
@@ -509,10 +502,10 @@ unsigned int init_random_number(int nr, int seed)
     seed += (int)current_time.tv_usec;		// microseconds since the epoch
 #endif
 
-    /* add some more randomness */
+    // add some more randomness
     seed += (int)SDL_GetTicks();		// milliseconds since SDL init
 
-    /* add some more randomness */
+    // add some more randomness
     seed += GetSimpleRandom(1000000);
   }
 
@@ -527,9 +520,9 @@ unsigned int get_random_number(int nr, int max)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* system info functions                                                     */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// system info functions
+// ----------------------------------------------------------------------------
 
 #if !defined(PLATFORM_ANDROID)
 static char *get_corrected_real_name(char *real_name)
@@ -538,16 +531,16 @@ static char *get_corrected_real_name(char *real_name)
   char *from_ptr = real_name;
   char *to_ptr   = real_name_new;
 
-  /* copy the name string, but not more than MAX_USERNAME_LEN characters */
+  // copy the name string, but not more than MAX_USERNAME_LEN characters
   while (*from_ptr && (int)(to_ptr - real_name_new) < MAX_USERNAME_LEN - 1)
   {
-    /* the name field read from "passwd" file may also contain additional
-       user information, separated by commas, which will be removed here */
+    // the name field read from "passwd" file may also contain additional
+    // user information, separated by commas, which will be removed here
     if (*from_ptr == ',')
       break;
 
-    /* the user's real name may contain 'german sharp s' characters,
-       which have no equivalent in upper case letters (used by our fonts) */
+    // the user's real name may contain 'german sharp s' characters,
+    // which have no equivalent in upper case letters (used by our fonts)
     if (*from_ptr == CHAR_BYTE_SHARP_S)
     {
       from_ptr++;
@@ -564,7 +557,7 @@ static char *get_corrected_real_name(char *real_name)
 }
 #endif
 
-char *getLoginName()
+char *getLoginName(void)
 {
   static char *login_name = NULL;
 
@@ -577,7 +570,7 @@ char *getLoginName()
     if (GetUserName(login_name, &buffer_size) == 0)
       strcpy(login_name, ANONYMOUS_NAME);
   }
-#else
+#elif defined(PLATFORM_UNIX) && !defined(PLATFORM_ANDROID)
   if (login_name == NULL)
   {
     struct passwd *pwd;
@@ -587,12 +580,14 @@ char *getLoginName()
     else
       login_name = getStringCopy(pwd->pw_name);
   }
+#else
+  login_name = ANONYMOUS_NAME;
 #endif
 
   return login_name;
 }
 
-char *getRealName()
+char *getRealName(void)
 {
   static char *real_name = NULL;
 
@@ -628,22 +623,22 @@ time_t getFileTimestampEpochSeconds(char *filename)
 {
   struct stat file_status;
 
-  if (stat(filename, &file_status) != 0)	/* cannot stat file */
+  if (stat(filename, &file_status) != 0)	// cannot stat file
     return 0;
 
   return file_status.st_mtime;
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* path manipulation functions                                               */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// path manipulation functions
+// ----------------------------------------------------------------------------
 
 static char *getLastPathSeparatorPtr(char *filename)
 {
   char *last_separator = strrchr(filename, CHAR_PATH_SEPARATOR_UNIX);
 
-  if (last_separator == NULL)	/* also try DOS/Windows variant */
+  if (last_separator == NULL)	// also try DOS/Windows variant
     last_separator = strrchr(filename, CHAR_PATH_SEPARATOR_DOS);
 
   return last_separator;
@@ -654,9 +649,9 @@ char *getBaseNamePtr(char *filename)
   char *last_separator = getLastPathSeparatorPtr(filename);
 
   if (last_separator != NULL)
-    return last_separator + 1;	/* separator found: strip base path */
+    return last_separator + 1;	// separator found: strip base path
   else
-    return filename;		/* no separator found: filename has no path */
+    return filename;		// no separator found: filename has no path
 }
 
 char *getBaseName(char *filename)
@@ -686,48 +681,24 @@ char *getBasePath(char *filename)
   char *basepath = getStringCopy(filename);
   char *last_separator = getLastPathSeparatorPtr(basepath);
 
-  if (last_separator != NULL)
-    *last_separator = '\0';	/* separator found: strip basename */
-  else
-    basepath = ".";		/* no separator found: use current path */
-
-  return basepath;
-}
-
-static char *getProgramMainDataPath()
-{
-  char *main_data_path = getStringCopy(program.command_basepath);
-
-#if defined(PLATFORM_MACOSX)
-  static char *main_data_binary_subdir = NULL;
-
-  if (main_data_binary_subdir == NULL)
+  // if no separator was found, use current directory
+  if (last_separator == NULL)
   {
-    main_data_binary_subdir = checked_malloc(strlen(program.program_title) + 1 +
-					     strlen("app") + 1 +
-					     strlen(MAC_APP_BINARY_SUBDIR) + 1);
+    free(basepath);
 
-    sprintf(main_data_binary_subdir, "%s.app/%s",
-	    program.program_title, MAC_APP_BINARY_SUBDIR);
+    return getStringCopy(".");
   }
 
-  // cut relative path to Mac OS X application binary directory from path
-  if (strSuffix(main_data_path, main_data_binary_subdir))
-    main_data_path[strlen(main_data_path) -
-		   strlen(main_data_binary_subdir)] = '\0';
-
-  // cut trailing path separator from path (but not if path is root directory)
-  if (strSuffix(main_data_path, "/") && !strEqual(main_data_path, "/"))
-    main_data_path[strlen(main_data_path) - 1] = '\0';
-#endif
+  // separator found: strip basename
+  *last_separator = '\0';
 
-  return main_data_path;
+  return basepath;
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* various string functions                                                  */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// various string functions
+// ----------------------------------------------------------------------------
 
 char *getStringCat2WithSeparator(char *s1, char *s2, char *sep)
 {
@@ -794,46 +765,27 @@ char *getPath3(char *path1, char *path2, char *path3)
   return getStringCat3WithSeparator(path1, path2, path3, STRING_PATH_SEPARATOR);
 }
 
-char *getImg2(char *path1, char *path2)
+static char *getPngOrPcxIfNotExists(char *filename)
 {
-  char *filename = getPath2(path1, path2);
-
-  if (!fileExists(filename) && strSuffix(path2, ".png"))
-  {
-    // backward compatibility: if PNG file not found, check for PCX file
-    char *path2pcx = getStringCopy(path2);
-
-    strcpy(&path2pcx[strlen(path2pcx) - 3], "pcx");
-
-    free(filename);
+  // switch from PNG to PCX file and vice versa, if file does not exist
+  // (backwards compatibility with PCX files used in previous versions)
 
-    filename = getPath2(path1, path2pcx);
-
-    free(path2pcx);
-  }
+  if (!fileExists(filename) && strSuffix(filename, ".png"))
+    strcpy(&filename[strlen(filename) - 3], "pcx");
+  else if (!fileExists(filename) && strSuffix(filename, ".pcx"))
+    strcpy(&filename[strlen(filename) - 3], "png");
 
   return filename;
 }
 
-char *getImg3(char *path1, char *path2, char *path3)
+char *getImg2(char *path1, char *path2)
 {
-  char *filename = getPath3(path1, path2, path3);
-
-  if (!fileExists(filename) && strSuffix(path3, ".png"))
-  {
-    // backward compatibility: if PNG file not found, check for PCX file
-    char *path3pcx = getStringCopy(path3);
-
-    strcpy(&path3pcx[strlen(path3pcx) - 3], "pcx");
-
-    free(filename);
-
-    filename = getPath3(path1, path2, path3pcx);
-
-    free(path3pcx);
-  }
+  return getPngOrPcxIfNotExists(getPath2(path1, path2));
+}
 
-  return filename;
+char *getImg3(char *path1, char *path2, char *path3)
+{
+  return getPngOrPcxIfNotExists(getPath3(path1, path2, path3));
 }
 
 char *getStringCopy(const char *s)
@@ -948,35 +900,24 @@ boolean strSuffixLower(char *s, char *suffix)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* command line option handling functions                                    */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// command line option handling functions
+// ----------------------------------------------------------------------------
 
 void GetOptions(int argc, char *argv[],
 		void (*print_usage_function)(void),
 		void (*print_version_function)(void))
 {
-  char *ro_base_path = RO_BASE_PATH;
-  char *rw_base_path = RW_BASE_PATH;
+  char *ro_base_path = getProgramMainDataPath(argv[0], RO_BASE_PATH);
+  char *rw_base_path = getProgramMainDataPath(argv[0], RW_BASE_PATH);
   char **argvplus = checked_calloc((argc + 1) * sizeof(char **));
   char **options_left = &argvplus[1];
 
-  /* replace original "argv" with null-terminated array of string pointers */
+  // replace original "argv" with null-terminated array of string pointers
   while (argc--)
     argvplus[argc] = argv[argc];
 
-  /* if the program is configured to start from current directory (default),
-     determine program package directory from program binary (some versions
-     of KDE/Konqueror and Mac OS X (especially "Mavericks") apparently do not
-     set the current working directory to the program package directory) */
-
-  if (strEqual(ro_base_path, "."))
-    ro_base_path = getProgramMainDataPath();
-  if (strEqual(rw_base_path, "."))
-    rw_base_path = getProgramMainDataPath();
-
-  /* initialize global program options */
-  options.display_name = NULL;
+  // initialize global program options
   options.server_host = NULL;
   options.server_port = 0;
 
@@ -987,10 +928,12 @@ void GetOptions(int argc, char *argv[],
   options.sounds_directory   = getPath2(ro_base_path, SOUNDS_DIRECTORY);
   options.music_directory    = getPath2(ro_base_path, MUSIC_DIRECTORY);
   options.docs_directory     = getPath2(ro_base_path, DOCS_DIRECTORY);
+  options.conf_directory     = getPath2(ro_base_path, CONF_DIRECTORY);
 
   options.execute_command = NULL;
   options.special_flags = NULL;
 
+  options.mytapes = FALSE;
   options.serveronly = FALSE;
   options.network = FALSE;
   options.verbose = FALSE;
@@ -1000,9 +943,15 @@ void GetOptions(int argc, char *argv[],
   options.verbose = TRUE;
 #else
 #if !defined(PLATFORM_UNIX)
-  if (*options_left == NULL)	/* no options given -- enable verbose mode */
+  if (*options_left == NULL)	// no options given -- enable verbose mode
     options.verbose = TRUE;
 #endif
+#endif
+
+#if DEBUG
+#if defined(PLATFORM_ANDROID)
+  options.debug = TRUE;
+#endif
 #endif
 
   while (*options_left)
@@ -1016,22 +965,22 @@ void GetOptions(int argc, char *argv[],
     if (option_len >= MAX_OPTION_LEN)
       Error(ERR_EXIT_HELP, "unrecognized option '%s'", option);
 
-    strcpy(option_str, option);			/* copy argument into buffer */
+    strcpy(option_str, option);			// copy argument into buffer
     option = option_str;
 
-    if (strEqual(option, "--"))			/* stop scanning arguments */
+    if (strEqual(option, "--"))			// stop scanning arguments
       break;
 
-    if (strPrefix(option, "--"))		/* treat '--' like '-' */
+    if (strPrefix(option, "--"))		// treat '--' like '-'
       option++;
 
     option_arg = strchr(option, '=');
-    if (option_arg == NULL)			/* no '=' in option */
+    if (option_arg == NULL)			// no '=' in option
       option_arg = next_option;
     else
     {
-      *option_arg++ = '\0';			/* cut argument from option */
-      if (*option_arg == '\0')			/* no argument after '=' */
+      *option_arg++ = '\0';			// cut argument from option
+      if (*option_arg == '\0')			// no argument after '='
 	Error(ERR_EXIT_HELP, "option '%s' has invalid argument", option_str);
     }
 
@@ -1047,32 +996,24 @@ void GetOptions(int argc, char *argv[],
 
       exit(0);
     }
-    else if (strncmp(option, "-display", option_len) == 0)
-    {
-      if (option_arg == NULL)
-	Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
-
-      options.display_name = option_arg;
-      if (option_arg == next_option)
-	options_left++;
-    }
     else if (strncmp(option, "-basepath", option_len) == 0)
     {
       if (option_arg == NULL)
 	Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str);
 
-      /* this should be extended to separate options for ro and rw data */
+      // this should be extended to separate options for ro and rw data
       options.ro_base_directory = ro_base_path = option_arg;
       options.rw_base_directory = rw_base_path = option_arg;
       if (option_arg == next_option)
 	options_left++;
 
-      /* adjust paths for sub-directories in base directory accordingly */
+      // adjust paths for sub-directories in base directory accordingly
       options.level_directory    = getPath2(ro_base_path, LEVELS_DIRECTORY);
       options.graphics_directory = getPath2(ro_base_path, GRAPHICS_DIRECTORY);
       options.sounds_directory   = getPath2(ro_base_path, SOUNDS_DIRECTORY);
       options.music_directory    = getPath2(ro_base_path, MUSIC_DIRECTORY);
       options.docs_directory     = getPath2(ro_base_path, DOCS_DIRECTORY);
+      options.conf_directory     = getPath2(ro_base_path, CONF_DIRECTORY);
     }
     else if (strncmp(option, "-levels", option_len) == 0)
     {
@@ -1110,6 +1051,10 @@ void GetOptions(int argc, char *argv[],
       if (option_arg == next_option)
 	options_left++;
     }
+    else if (strncmp(option, "-mytapes", option_len) == 0)
+    {
+      options.mytapes = TRUE;
+    }
     else if (strncmp(option, "-network", option_len) == 0)
     {
       options.network = TRUE;
@@ -1146,13 +1091,13 @@ void GetOptions(int argc, char *argv[],
       if (option_arg == next_option)
 	options_left++;
 
-      /* when doing batch processing, always enable verbose mode (warnings) */
+      // when doing batch processing, always enable verbose mode (warnings)
       options.verbose = TRUE;
     }
 #if defined(PLATFORM_MACOSX)
     else if (strPrefix(option, "-psn"))
     {
-      /* ignore process serial number when launched via GUI on Mac OS X */
+      // ignore process serial number when launched via GUI on Mac OS X
     }
 #endif
     else if (*option == '-')
@@ -1177,13 +1122,13 @@ void GetOptions(int argc, char *argv[],
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* error handling functions                                                  */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// error handling functions
+// ----------------------------------------------------------------------------
 
 #define MAX_INTERNAL_ERROR_SIZE		1024
 
-/* used by SetError() and GetError() to store internal error messages */
+// used by SetError() and GetError() to store internal error messages
 static char internal_error[MAX_INTERNAL_ERROR_SIZE];
 
 void SetError(char *format, ...)
@@ -1195,7 +1140,7 @@ void SetError(char *format, ...)
   va_end(ap);
 }
 
-char *GetError()
+char *GetError(void)
 {
   return internal_error;
 }
@@ -1216,7 +1161,11 @@ void Error(int mode, char *format, ...)
 		      ANDROID_LOG_UNKNOWN);
 #endif
 
-  /* display warnings only when running in verbose mode */
+  // display debug messages only when running in debug mode
+  if (mode & ERR_DEBUG && !options.debug)
+    return;
+
+  // display warnings only when running in verbose mode
   if (mode & ERR_WARN && !options.verbose)
     return;
 
@@ -1275,16 +1224,16 @@ void Error(int mode, char *format, ...)
   if (mode & ERR_EXIT)
   {
     if (mode & ERR_FROM_SERVER)
-      exit(1);				/* child process: normal exit */
+      exit(1);				// child process: normal exit
     else
-      program.exit_function(1);		/* main process: clean up stuff */
+      program.exit_function(1);		// main process: clean up stuff
   }
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* checked memory allocation and freeing functions                           */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// checked memory allocation and freeing functions
+// ----------------------------------------------------------------------------
 
 void *checked_malloc(unsigned int size)
 {
@@ -1322,14 +1271,14 @@ void *checked_realloc(void *ptr, unsigned int size)
 
 void checked_free(void *ptr)
 {
-  if (ptr != NULL)	/* this check should be done by free() anyway */
+  if (ptr != NULL)	// this check should be done by free() anyway
     free(ptr);
 }
 
 void clear_mem(void *ptr, unsigned int size)
 {
 #if defined(PLATFORM_WIN32)
-  /* for unknown reason, memset() sometimes crashes when compiled with MinGW */
+  // for unknown reason, memset() sometimes crashes when compiled with MinGW
   char *cptr = (char *)ptr;
 
   while (size--)
@@ -1340,9 +1289,9 @@ void clear_mem(void *ptr, unsigned int size)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* various helper functions                                                  */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// various helper functions
+// ----------------------------------------------------------------------------
 
 void swap_numbers(int *i1, int *i2)
 {
@@ -1388,7 +1337,7 @@ int getFile16BitInteger(File *file, int byte_order)
   if (byte_order == BYTE_ORDER_BIG_ENDIAN)
     return ((getByteFromFile(file) << 8) |
 	    (getByteFromFile(file) << 0));
-  else		 /* BYTE_ORDER_LITTLE_ENDIAN */
+  else		 // BYTE_ORDER_LITTLE_ENDIAN
     return ((getByteFromFile(file) << 0) |
 	    (getByteFromFile(file) << 8));
 }
@@ -1402,7 +1351,7 @@ int putFile16BitInteger(FILE *file, int value, int byte_order)
       fputc((value >> 8) & 0xff, file);
       fputc((value >> 0) & 0xff, file);
     }
-    else	   /* BYTE_ORDER_LITTLE_ENDIAN */
+    else	   // BYTE_ORDER_LITTLE_ENDIAN
     {
       fputc((value >> 0) & 0xff, file);
       fputc((value >> 8) & 0xff, file);
@@ -1419,7 +1368,7 @@ int getFile32BitInteger(File *file, int byte_order)
 	    (getByteFromFile(file) << 16) |
 	    (getByteFromFile(file) <<  8) |
 	    (getByteFromFile(file) <<  0));
-  else		 /* BYTE_ORDER_LITTLE_ENDIAN */
+  else		 // BYTE_ORDER_LITTLE_ENDIAN
     return ((getByteFromFile(file) <<  0) |
 	    (getByteFromFile(file) <<  8) |
 	    (getByteFromFile(file) << 16) |
@@ -1437,7 +1386,7 @@ int putFile32BitInteger(FILE *file, int value, int byte_order)
       fputc((value >>  8) & 0xff, file);
       fputc((value >>  0) & 0xff, file);
     }
-    else	   /* BYTE_ORDER_LITTLE_ENDIAN */
+    else	   // BYTE_ORDER_LITTLE_ENDIAN
     {
       fputc((value >>  0) & 0xff, file);
       fputc((value >>  8) & 0xff, file);
@@ -1454,13 +1403,13 @@ boolean getFileChunk(File *file, char *chunk_name, int *chunk_size,
 {
   const int chunk_name_length = 4;
 
-  /* read chunk name */
+  // read chunk name
   if (getStringFromFile(file, chunk_name, chunk_name_length + 1) == NULL)
     return FALSE;
 
   if (chunk_size != NULL)
   {
-    /* read chunk size */
+    // read chunk size
     *chunk_size = getFile32BitInteger(file, byte_order);
   }
 
@@ -1472,7 +1421,7 @@ int putFileChunk(FILE *file, char *chunk_name, int chunk_size,
 {
   int num_bytes = 0;
 
-  /* write chunk name */
+  // write chunk name
   if (file != NULL)
     fputs(chunk_name, file);
 
@@ -1480,7 +1429,7 @@ int putFileChunk(FILE *file, char *chunk_name, int chunk_size,
 
   if (chunk_size >= 0)
   {
-    /* write chunk size */
+    // write chunk size
     if (file != NULL)
       putFile32BitInteger(file, chunk_size, byte_order);
 
@@ -1492,28 +1441,28 @@ int putFileChunk(FILE *file, char *chunk_name, int chunk_size,
 
 int getFileVersion(File *file)
 {
+  int version_super = getByteFromFile(file);
   int version_major = getByteFromFile(file);
   int version_minor = getByteFromFile(file);
   int version_patch = getByteFromFile(file);
-  int version_build = getByteFromFile(file);
 
-  return VERSION_IDENT(version_major, version_minor, version_patch,
-		       version_build);
+  return VERSION_IDENT(version_super, version_major, version_minor,
+		       version_patch);
 }
 
 int putFileVersion(FILE *file, int version)
 {
   if (file != NULL)
   {
+    int version_super = VERSION_SUPER(version);
     int version_major = VERSION_MAJOR(version);
     int version_minor = VERSION_MINOR(version);
     int version_patch = VERSION_PATCH(version);
-    int version_build = VERSION_BUILD(version);
 
+    fputc(version_super, file);
     fputc(version_major, file);
     fputc(version_minor, file);
     fputc(version_patch, file);
-    fputc(version_build, file);
   }
 
   return 4;
@@ -1548,16 +1497,16 @@ void WriteUnusedBytesToFile(FILE *file, unsigned int bytes)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* functions to translate key identifiers between different format           */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions to translate key identifiers between different format
+// ----------------------------------------------------------------------------
 
 #define TRANSLATE_KEYSYM_TO_KEYNAME	0
 #define TRANSLATE_KEYSYM_TO_X11KEYNAME	1
 #define TRANSLATE_KEYNAME_TO_KEYSYM	2
 #define TRANSLATE_X11KEYNAME_TO_KEYSYM	3
 
-void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
+static void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
 {
   static struct
   {
@@ -1566,13 +1515,17 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     char *name;
   } translate_key[] =
   {
-    /* normal cursor keys */
+    // return and escape keys
+    { KSYM_Return,	"XK_Return",		"return" },
+    { KSYM_Escape,	"XK_Escape",		"escape" },
+
+    // normal cursor keys
     { KSYM_Left,	"XK_Left",		"cursor left" },
     { KSYM_Right,	"XK_Right",		"cursor right" },
     { KSYM_Up,		"XK_Up",		"cursor up" },
     { KSYM_Down,	"XK_Down",		"cursor down" },
 
-    /* keypad cursor keys */
+    // keypad cursor keys
 #ifdef KSYM_KP_Left
     { KSYM_KP_Left,	"XK_KP_Left",		"keypad left" },
     { KSYM_KP_Right,	"XK_KP_Right",		"keypad right" },
@@ -1580,7 +1533,7 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_KP_Down,	"XK_KP_Down",		"keypad down" },
 #endif
 
-    /* other keypad keys */
+    // other keypad keys
 #ifdef KSYM_KP_Enter
     { KSYM_KP_Enter,	"XK_KP_Enter",		"keypad enter" },
     { KSYM_KP_Add,	"XK_KP_Add",		"keypad +" },
@@ -1590,7 +1543,7 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_KP_Separator,"XK_KP_Separator",	"keypad ," },
 #endif
 
-    /* modifier keys */
+    // modifier keys
     { KSYM_Shift_L,	"XK_Shift_L",		"left shift" },
     { KSYM_Shift_R,	"XK_Shift_R",		"right shift" },
     { KSYM_Control_L,	"XK_Control_L",		"left control" },
@@ -1599,14 +1552,10 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_Meta_R,	"XK_Meta_R",		"right meta" },
     { KSYM_Alt_L,	"XK_Alt_L",		"left alt" },
     { KSYM_Alt_R,	"XK_Alt_R",		"right alt" },
-#if !defined(TARGET_SDL2)
-    { KSYM_Super_L,	"XK_Super_L",		"left super" },	 /* Win-L */
-    { KSYM_Super_R,	"XK_Super_R",		"right super" }, /* Win-R */
-#endif
-    { KSYM_Mode_switch,	"XK_Mode_switch",	"mode switch" }, /* Alt-R */
-    { KSYM_Multi_key,	"XK_Multi_key",		"multi key" },	 /* Ctrl-R */
+    { KSYM_Mode_switch,	"XK_Mode_switch",	"mode switch" }, // Alt-R
+    { KSYM_Multi_key,	"XK_Multi_key",		"multi key" },	 // Ctrl-R
 
-    /* some special keys */
+    // some special keys
     { KSYM_BackSpace,	"XK_BackSpace",		"backspace" },
     { KSYM_Delete,	"XK_Delete",		"delete" },
     { KSYM_Insert,	"XK_Insert",		"insert" },
@@ -1616,12 +1565,16 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_Page_Up,	"XK_Page_Up",		"page up" },
     { KSYM_Page_Down,	"XK_Page_Down",		"page down" },
 
-#if defined(TARGET_SDL2)
-    { KSYM_Menu,	"XK_Menu",		"menu" },	 /* menu key */
-    { KSYM_Back,	"XK_Back",		"back" },	 /* back key */
+    { KSYM_Select,	"XK_Select",		"select" },
+    { KSYM_Menu,	"XK_Menu",		"menu" },	 // menu key
+    { KSYM_Back,	"XK_Back",		"back" },	 // back key
+    { KSYM_PlayPause,	"XK_PlayPause",		"play/pause" },
+#if defined(PLATFORM_ANDROID)
+    { KSYM_Rewind,	"XK_Rewind",		"rewind" },
+    { KSYM_FastForward,	"XK_FastForward",	"fast forward" },
 #endif
 
-    /* ASCII 0x20 to 0x40 keys (except numbers) */
+    // ASCII 0x20 to 0x40 keys (except numbers)
     { KSYM_space,	"XK_space",		"space" },
     { KSYM_exclam,	"XK_exclam",		"!" },
     { KSYM_quotedbl,	"XK_quotedbl",		"\"" },
@@ -1646,7 +1599,7 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_question,	"XK_question",		"?" },
     { KSYM_at,		"XK_at",		"@" },
 
-    /* more ASCII keys */
+    // more ASCII keys
     { KSYM_bracketleft,	"XK_bracketleft",	"[" },
     { KSYM_backslash,	"XK_backslash",		"\\" },
     { KSYM_bracketright,"XK_bracketright",	"]" },
@@ -1659,7 +1612,7 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_braceright,	"XK_braceright",	"brace right" },
     { KSYM_asciitilde,	"XK_asciitilde",	"~" },
 
-    /* special (non-ASCII) keys */
+    // special (non-ASCII) keys
     { KSYM_degree,	"XK_degree",		"degree" },
     { KSYM_Adiaeresis,	"XK_Adiaeresis",	"A umlaut" },
     { KSYM_Odiaeresis,	"XK_Odiaeresis",	"O umlaut" },
@@ -1669,8 +1622,7 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_udiaeresis,	"XK_udiaeresis",	"u umlaut" },
     { KSYM_ssharp,	"XK_ssharp",		"sharp s" },
 
-#if defined(TARGET_SDL2)
-    /* special (non-ASCII) keys (UTF-8, for reverse mapping only) */
+    // special (non-ASCII) keys (UTF-8, for reverse mapping only)
     { KSYM_degree,	"XK_degree",		"\xc2\xb0" },
     { KSYM_Adiaeresis,	"XK_Adiaeresis",	"\xc3\x84" },
     { KSYM_Odiaeresis,	"XK_Odiaeresis",	"\xc3\x96" },
@@ -1680,12 +1632,10 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_udiaeresis,	"XK_udiaeresis",	"\xc3\xbc" },
     { KSYM_ssharp,	"XK_ssharp",		"\xc3\x9f" },
 
-    /* other keys (for reverse mapping only) */
+    // other keys (for reverse mapping only)
     { KSYM_space,	"XK_space",		" " },
-#endif
 
-#if defined(TARGET_SDL2)
-    /* keypad keys are not in numerical order in SDL2 */
+    // keypad keys are not in numerical order in SDL2
     { KSYM_KP_0,	"XK_KP_0",		"keypad 0" },
     { KSYM_KP_1,	"XK_KP_1",		"keypad 1" },
     { KSYM_KP_2,	"XK_KP_2",		"keypad 2" },
@@ -1696,9 +1646,8 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
     { KSYM_KP_7,	"XK_KP_7",		"keypad 7" },
     { KSYM_KP_8,	"XK_KP_8",		"keypad 8" },
     { KSYM_KP_9,	"XK_KP_9",		"keypad 9" },
-#endif
 
-    /* end-of-array identifier */
+    // end-of-array identifier
     { 0,                NULL,			NULL }
   };
 
@@ -1715,10 +1664,6 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
       sprintf(name_buffer, "%c", 'a' + (char)(key - KSYM_a));
     else if (key >= KSYM_0 && key <= KSYM_9)
       sprintf(name_buffer, "%c", '0' + (char)(key - KSYM_0));
-#if !defined(TARGET_SDL2)
-    else if (key >= KSYM_KP_0 && key <= KSYM_KP_9)
-      sprintf(name_buffer, "keypad %c", '0' + (char)(key - KSYM_KP_0));
-#endif
     else if (key >= KSYM_FKEY_FIRST && key <= KSYM_FKEY_LAST)
       sprintf(name_buffer, "F%d", (int)(key - KSYM_FKEY_FIRST + 1));
     else if (key == KSYM_UNDEFINED)
@@ -1754,10 +1699,6 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
       sprintf(name_buffer, "XK_%c", 'a' + (char)(key - KSYM_a));
     else if (key >= KSYM_0 && key <= KSYM_9)
       sprintf(name_buffer, "XK_%c", '0' + (char)(key - KSYM_0));
-#if !defined(TARGET_SDL2)
-    else if (key >= KSYM_KP_0 && key <= KSYM_KP_9)
-      sprintf(name_buffer, "XK_KP_%c", '0' + (char)(key - KSYM_KP_0));
-#endif
     else if (key >= KSYM_FKEY_FIRST && key <= KSYM_FKEY_LAST)
       sprintf(name_buffer, "XK_F%d", (int)(key - KSYM_FKEY_FIRST + 1));
     else if (key == KSYM_UNDEFINED)
@@ -1835,15 +1776,6 @@ void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
       else if (c >= '0' && c <= '9')
 	key = KSYM_0 + (Key)(c - '0');
     }
-#if !defined(TARGET_SDL2)
-    else if (strPrefix(name_ptr, "XK_KP_") && strlen(name_ptr) == 7)
-    {
-      char c = name_ptr[6];
-
-      if (c >= '0' && c <= '9')
-	key = KSYM_KP_0 + (Key)(c - '0');
-    }
-#endif
     else if (strPrefix(name_ptr, "XK_F") && strlen(name_ptr) <= 6)
     {
       char c1 = name_ptr[4];
@@ -1946,7 +1878,7 @@ char getCharFromKey(Key key)
     byte key_char;
   } translate_key_char[] =
   {
-    /* special (non-ASCII) keys (ISO-8859-1) */
+    // special (non-ASCII) keys (ISO-8859-1)
     { KSYM_degree,	CHAR_BYTE_DEGREE	},
     { KSYM_Adiaeresis,	CHAR_BYTE_UMLAUT_A	},
     { KSYM_Odiaeresis,	CHAR_BYTE_UMLAUT_O	},
@@ -1956,7 +1888,7 @@ char getCharFromKey(Key key)
     { KSYM_udiaeresis,	CHAR_BYTE_UMLAUT_u	},
     { KSYM_ssharp,	CHAR_BYTE_SHARP_S	},
 
-    /* end-of-array identifier */
+    // end-of-array identifier
     { 0,                0			}
   };
 
@@ -1988,17 +1920,17 @@ char getCharFromKey(Key key)
 
 char getValidConfigValueChar(char c)
 {
-  if (c == '#' ||	/* used to mark comments */
-      c == '\\')	/* used to mark continued lines */
+  if (c == '#' ||	// used to mark comments
+      c == '\\')	// used to mark continued lines
     c = 0;
 
   return c;
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* functions to translate string identifiers to integer or boolean value     */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions to translate string identifiers to integer or boolean value
+// ----------------------------------------------------------------------------
 
 int get_integer_from_string(char *s)
 {
@@ -2083,12 +2015,37 @@ int get_switch3_from_string(char *s)
   return result;
 }
 
+int get_player_nr_from_string(char *s)
+{
+  static char *player_text[] =
+  {
+    "player_1",
+    "player_2",
+    "player_3",
+    "player_4",
+
+    NULL
+  };
+
+  char *s_lower = getStringToLower(s);
+  int result = 0;
+  int i;
+
+  for (i = 0; player_text[i] != NULL; i++)
+    if (strEqual(s_lower, player_text[i]))
+      result = i;
+
+  free(s_lower);
+
+  return result;
+}
 
-/* ------------------------------------------------------------------------- */
-/* functions for generic lists                                               */
-/* ------------------------------------------------------------------------- */
 
-ListNode *newListNode()
+// ----------------------------------------------------------------------------
+// functions for generic lists
+// ----------------------------------------------------------------------------
+
+ListNode *newListNode(void)
 {
   return checked_calloc(sizeof(ListNode));
 }
@@ -2115,20 +2072,33 @@ void deleteNodeFromList(ListNode **node_first, char *key,
 
   if (strEqual((*node_first)->key, key))
   {
-    checked_free((*node_first)->key);
+    // after first recursion, (*node_first)->prev->next == *node_first,
+    // so *node_first would be overwritten with (*node_first)->next
+    // => use a copy of *node_first (and later of (*node_first)->next)
+    ListNode *node = *node_first;
+    ListNode *node_next = node->next;
+
+    checked_free(node->key);
 
     if (destructor_function)
-      destructor_function((*node_first)->content);
+      destructor_function(node->content);
 
-    if ((*node_first)->next)
-      (*node_first)->next->prev = (*node_first)->prev;
+    if (node->prev)
+      node->prev->next = node->next;
 
-    checked_free(*node_first);
+    if (node->next)
+      node->next->prev = node->prev;
 
-    *node_first = (*node_first)->next;
+    checked_free(node);
+
+    // after removing node, set list pointer to next valid list node
+    // (this is important if the first node of the list was deleted)
+    *node_first = node_next;
   }
   else
+  {
     deleteNodeFromList(&(*node_first)->next, key, destructor_function);
+  }
 }
 
 ListNode *getNodeFromKey(ListNode *node_first, char *key)
@@ -2147,7 +2117,8 @@ int getNumNodes(ListNode *node_first)
   return (node_first ? 1 + getNumNodes(node_first->next) : 0);
 }
 
-void dumpList(ListNode *node_first)
+#if 0
+static void dumpList(ListNode *node_first)
 {
   ListNode *node = node_first;
 
@@ -2160,11 +2131,14 @@ void dumpList(ListNode *node_first)
 
   printf("[%d nodes]\n", getNumNodes(node_first));
 }
+#endif
+
 
+// ----------------------------------------------------------------------------
+// functions for file handling
+// ----------------------------------------------------------------------------
 
-/* ------------------------------------------------------------------------- */
-/* functions for file handling                                               */
-/* ------------------------------------------------------------------------- */
+#define MAX_BUFFER_SIZE			4096
 
 File *openFile(char *filename, char *mode)
 {
@@ -2248,6 +2222,11 @@ size_t readFile(File *file, void *buffer, size_t item_size, size_t num_items)
   return fread(buffer, item_size, num_items, file->file);
 }
 
+size_t writeFile(File *file, void *buffer, size_t item_size, size_t num_items)
+{
+  return fwrite(buffer, item_size, num_items, file->file);
+}
+
 int seekFile(File *file, long offset, int whence)
 {
 #if defined(PLATFORM_ANDROID)
@@ -2317,10 +2296,40 @@ char *getStringFromFile(File *file, char *line, int size)
   return fgets(line, size, file->file);
 }
 
+int copyFile(char *filename_from, char *filename_to)
+{
+  File *file_from, *file_to;
+
+  if ((file_from = openFile(filename_from, MODE_READ)) == NULL)
+  {
+    return -1;
+  }
+
+  if ((file_to = openFile(filename_to, MODE_WRITE)) == NULL)
+  {
+    closeFile(file_from);
+
+    return -1;
+  }
+
+  while (!checkEndOfFile(file_from))
+  {
+    byte buffer[MAX_BUFFER_SIZE];
+    size_t bytes_read = readFile(file_from, buffer, 1, MAX_BUFFER_SIZE);
+
+    writeFile(file_to, buffer, 1, bytes_read);
+  }
+
+  closeFile(file_from);
+  closeFile(file_to);
+
+  return 0;
+}
 
-/* ------------------------------------------------------------------------- */
-/* functions for directory handling                                          */
-/* ------------------------------------------------------------------------- */
+
+// ----------------------------------------------------------------------------
+// functions for directory handling
+// ----------------------------------------------------------------------------
 
 Directory *openDirectory(char *dir_name)
 {
@@ -2454,9 +2463,9 @@ void freeDirectoryEntry(DirectoryEntry *dir_entry)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* functions for checking files and filenames                                */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions for checking files and filenames
+// ----------------------------------------------------------------------------
 
 boolean directoryExists(char *dir_name)
 {
@@ -2509,7 +2518,8 @@ boolean fileExists(char *filename)
   return success;
 }
 
-boolean fileHasPrefix(char *basename, char *prefix)
+#if 0
+static boolean fileHasPrefix(char *basename, char *prefix)
 {
   static char *basename_lower = NULL;
   int basename_length, prefix_length;
@@ -2530,8 +2540,9 @@ boolean fileHasPrefix(char *basename, char *prefix)
 
   return FALSE;
 }
+#endif
 
-boolean fileHasSuffix(char *basename, char *suffix)
+static boolean fileHasSuffix(char *basename, char *suffix)
 {
   static char *basename_lower = NULL;
   int basename_length, suffix_length;
@@ -2589,17 +2600,28 @@ boolean FileIsArtworkType(char *filename, int type)
   return FALSE;
 }
 
-/* ------------------------------------------------------------------------- */
-/* functions for loading artwork configuration information                   */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions for loading artwork configuration information
+// ----------------------------------------------------------------------------
 
 char *get_mapped_token(char *token)
 {
-  /* !!! make this dynamically configurable (init.c:InitArtworkConfig) !!! */
+  // !!! make this dynamically configurable (init.c:InitArtworkConfig) !!!
   static char *map_token_prefix[][2] =
   {
-    { "char_procent",		"char_percent"	},
-    { NULL,					}
+    { "char_procent",		"char_percent"			},
+    { "bd_magic_wall_filling",	"bd_magic_wall.filling"		},
+    { "bd_magic_wall_emptying",	"bd_magic_wall.emptying"	},
+    { "bd_butterfly_left",	"bd_butterfly.left"		},
+    { "bd_butterfly_right",	"bd_butterfly.right"		},
+    { "bd_butterfly_up",	"bd_butterfly.up"		},
+    { "bd_butterfly_down",	"bd_butterfly.down"		},
+    { "bd_firefly_left",	"bd_firefly.left"		},
+    { "bd_firefly_right",	"bd_firefly.right"		},
+    { "bd_firefly_up",		"bd_firefly.up"			},
+    { "bd_firefly_down",	"bd_firefly.down"		},
+
+    { NULL,							}
   };
   int i;
 
@@ -2611,189 +2633,90 @@ char *get_mapped_token(char *token)
       return getStringCat2(map_token_prefix[i][1], &token[len_token_prefix]);
   }
 
-  return NULL;
-}
-
-/* This function checks if a string <s> of the format "string1, string2, ..."
-   exactly contains a string <s_contained>. */
-
-static boolean string_has_parameter(char *s, char *s_contained)
-{
-  char *substring;
-
-  if (s == NULL || s_contained == NULL)
-    return FALSE;
-
-  if (strlen(s_contained) > strlen(s))
-    return FALSE;
-
-  if (strncmp(s, s_contained, strlen(s_contained)) == 0)
+  // change tokens containing ".gfx" by moving the "gfx" part to the very left
+  char *gfx_substring = ".gfx";
+  char *gfx_prefix = "gfx.";
+  if (strstr(token, gfx_substring) != NULL)
   {
-    char next_char = s[strlen(s_contained)];
-
-    /* check if next character is delimiter or whitespace */
-    return (next_char == ',' || next_char == '\0' ||
-	    next_char == ' ' || next_char == '\t' ? TRUE : FALSE);
-  }
-
-  /* check if string contains another parameter string after a comma */
-  substring = strchr(s, ',');
-  if (substring == NULL)	/* string does not contain a comma */
-    return FALSE;
+    char *token_prefix = getStringCopy(token);
+    char *token_gfx_pos = strstr(token_prefix, gfx_substring);
+    char *token_suffix = &token_gfx_pos[strlen(gfx_substring)];
+    char *mapped_token;
 
-  /* advance string pointer to next character after the comma */
-  substring++;
+    // cut off token string at ".gfx" substring position
+    *token_gfx_pos = '\0';
 
-  /* skip potential whitespaces after the comma */
-  while (*substring == ' ' || *substring == '\t')
-    substring++;
+    // put together prefix "gfx." and token prefix and suffix without ".gfx"
+    mapped_token = getStringCat3(gfx_prefix, token_prefix, token_suffix);
 
-  return string_has_parameter(substring, s_contained);
-}
+    free(token_prefix);
 
-int get_parameter_value(char *value_raw, char *suffix, int type)
-{
-  char *value = getStringToLower(value_raw);
-  int result = 0;	/* probably a save default value */
-
-  if (strEqual(suffix, ".direction"))
-  {
-    result = (strEqual(value, "left")  ? MV_LEFT :
-	      strEqual(value, "right") ? MV_RIGHT :
-	      strEqual(value, "up")    ? MV_UP :
-	      strEqual(value, "down")  ? MV_DOWN : MV_NONE);
-  }
-  else if (strEqual(suffix, ".position"))
-  {
-    result = (strEqual(value, "left")   ? POS_LEFT :
-	      strEqual(value, "right")  ? POS_RIGHT :
-	      strEqual(value, "top")    ? POS_TOP :
-	      strEqual(value, "upper")  ? POS_UPPER :
-	      strEqual(value, "middle") ? POS_MIDDLE :
-	      strEqual(value, "lower")  ? POS_LOWER :
-	      strEqual(value, "bottom") ? POS_BOTTOM :
-	      strEqual(value, "any")    ? POS_ANY : POS_UNDEFINED);
-  }
-  else if (strEqual(suffix, ".align"))
-  {
-    result = (strEqual(value, "left")   ? ALIGN_LEFT :
-	      strEqual(value, "right")  ? ALIGN_RIGHT :
-	      strEqual(value, "center") ? ALIGN_CENTER :
-	      strEqual(value, "middle") ? ALIGN_CENTER : ALIGN_DEFAULT);
+    return mapped_token;
   }
-  else if (strEqual(suffix, ".valign"))
-  {
-    result = (strEqual(value, "top")    ? VALIGN_TOP :
-	      strEqual(value, "bottom") ? VALIGN_BOTTOM :
-	      strEqual(value, "middle") ? VALIGN_MIDDLE :
-	      strEqual(value, "center") ? VALIGN_MIDDLE : VALIGN_DEFAULT);
-  }
-  else if (strEqual(suffix, ".anim_mode"))
-  {
-    result = (string_has_parameter(value, "none")	? ANIM_NONE :
-	      string_has_parameter(value, "loop")	? ANIM_LOOP :
-	      string_has_parameter(value, "linear")	? ANIM_LINEAR :
-	      string_has_parameter(value, "pingpong")	? ANIM_PINGPONG :
-	      string_has_parameter(value, "pingpong2")	? ANIM_PINGPONG2 :
-	      string_has_parameter(value, "random")	? ANIM_RANDOM :
-	      string_has_parameter(value, "ce_value")	? ANIM_CE_VALUE :
-	      string_has_parameter(value, "ce_score")	? ANIM_CE_SCORE :
-	      string_has_parameter(value, "ce_delay")	? ANIM_CE_DELAY :
-	      string_has_parameter(value, "horizontal")	? ANIM_HORIZONTAL :
-	      string_has_parameter(value, "vertical")	? ANIM_VERTICAL :
-	      string_has_parameter(value, "centered")	? ANIM_CENTERED :
-	      string_has_parameter(value, "all")	? ANIM_ALL :
-	      ANIM_DEFAULT);
-
-    if (string_has_parameter(value, "reverse"))
-      result |= ANIM_REVERSE;
-
-    if (string_has_parameter(value, "opaque_player"))
-      result |= ANIM_OPAQUE_PLAYER;
-
-    if (string_has_parameter(value, "static_panel"))
-      result |= ANIM_STATIC_PANEL;
-  }
-  else if (strEqual(suffix, ".class"))
-  {
-    result = get_hash_from_key(value);
-  }
-  else if (strEqual(suffix, ".style"))
-  {
-    result = STYLE_DEFAULT;
 
-    if (string_has_parameter(value, "accurate_borders"))
-      result |= STYLE_ACCURATE_BORDERS;
-
-    if (string_has_parameter(value, "inner_corners"))
-      result |= STYLE_INNER_CORNERS;
-  }
-  else if (strEqual(suffix, ".fade_mode"))
-  {
-    result = (string_has_parameter(value, "none")	? FADE_MODE_NONE :
-	      string_has_parameter(value, "fade")	? FADE_MODE_FADE :
-	      string_has_parameter(value, "crossfade")	? FADE_MODE_CROSSFADE :
-	      string_has_parameter(value, "melt")	? FADE_MODE_MELT :
-	      string_has_parameter(value, "curtain")	? FADE_MODE_CURTAIN :
-	      FADE_MODE_DEFAULT);
-  }
-  else if (strPrefix(suffix, ".font"))		/* (may also be ".font_xyz") */
-  {
-    result = gfx.get_font_from_token_function(value);
-  }
-  else		/* generic parameter of type integer or boolean */
-  {
-    result = (strEqual(value, ARG_UNDEFINED) ? ARG_UNDEFINED_VALUE :
-	      type == TYPE_INTEGER ? get_integer_from_string(value) :
-	      type == TYPE_BOOLEAN ? get_boolean_from_string(value) :
-	      ARG_UNDEFINED_VALUE);
-  }
-
-  free(value);
-
-  return result;
+  return NULL;
 }
 
-struct ScreenModeInfo *get_screen_mode_from_string(char *screen_mode_string)
-{
-  static struct ScreenModeInfo screen_mode;
-  char *screen_mode_string_x = strchr(screen_mode_string, 'x');
-  char *screen_mode_string_copy;
-  char *screen_mode_string_pos_w;
-  char *screen_mode_string_pos_h;
-
-  if (screen_mode_string_x == NULL)	/* invalid screen mode format */
-    return NULL;
-
-  screen_mode_string_copy = getStringCopy(screen_mode_string);
-
-  screen_mode_string_pos_w = screen_mode_string_copy;
-  screen_mode_string_pos_h = strchr(screen_mode_string_copy, 'x');
-  *screen_mode_string_pos_h++ = '\0';
-
-  screen_mode.width  = atoi(screen_mode_string_pos_w);
-  screen_mode.height = atoi(screen_mode_string_pos_h);
-
-  return &screen_mode;
-}
+static char *get_special_base_token(struct ArtworkListInfo *artwork_info,
+				    char *token)
+{
+  // !!! make this dynamically configurable (init.c:InitArtworkConfig) !!!
+  static struct ConfigTypeInfo prefix_list[] =
+  {
+    { "global.anim_1"	},
+    { "global.anim_2"	},
+    { "global.anim_3"	},
+    { "global.anim_4"	},
+    { "global.anim_5"	},
+    { "global.anim_6"	},
+    { "global.anim_7"	},
+    { "global.anim_8"	},
+    { "global.anim_9"	},
+    { "global.anim_10"	},
+    { "global.anim_11"	},
+    { "global.anim_12"	},
+    { "global.anim_13"	},
+    { "global.anim_14"	},
+    { "global.anim_15"	},
+    { "global.anim_16"	},
+    { "global.anim_17"	},
+    { "global.anim_18"	},
+    { "global.anim_19"	},
+    { "global.anim_20"	},
+    { "global.anim_21"	},
+    { "global.anim_22"	},
+    { "global.anim_23"	},
+    { "global.anim_24"	},
+    { "global.anim_25"	},
+    { "global.anim_26"	},
+    { "global.anim_27"	},
+    { "global.anim_28"	},
+    { "global.anim_29"	},
+    { "global.anim_30"	},
+    { "global.anim_31"	},
+    { "global.anim_32"	},
+
+    { NULL		}
+  };
+  struct ConfigTypeInfo *suffix_list = artwork_info->suffix_list;
+  boolean prefix_found = FALSE;
+  int len_suffix = 0;
+  int i;
 
-void get_aspect_ratio_from_screen_mode(struct ScreenModeInfo *screen_mode,
-				       int *x, int *y)
-{
-  float aspect_ratio = (float)screen_mode->width / (float)screen_mode->height;
-  float aspect_ratio_new;
-  int i = 1;
+  // search for prefix to check if base token has to be created
+  for (i = 0; prefix_list[i].token != NULL; i++)
+    if (strPrefix(token, prefix_list[i].token))
+      prefix_found = TRUE;
 
-  do
-  {
-    *x = i * aspect_ratio + 0.000001;
-    *y = i;
+  if (!prefix_found)
+    return NULL;
 
-    aspect_ratio_new = (float)*x / (float)*y;
+  // search for suffix (parameter) to determine base token length
+  for (i = 0; suffix_list[i].token != NULL; i++)
+    if (strSuffix(token, suffix_list[i].token))
+      len_suffix = strlen(suffix_list[i].token);
 
-    i++;
-  }
-  while (aspect_ratio_new != aspect_ratio && *y < screen_mode->height);
+  return getStringCopyN(token, strlen(token) - len_suffix);
 }
 
 static void FreeCustomArtworkList(struct ArtworkListInfo *,
@@ -2804,18 +2727,24 @@ struct FileInfo *getFileListFromConfigList(struct ConfigInfo *config_list,
 					   char **ignore_tokens,
 					   int num_file_list_entries)
 {
+  SetupFileHash *ignore_tokens_hash;
   struct FileInfo *file_list;
   int num_file_list_entries_found = 0;
   int num_suffix_list_entries = 0;
   int list_pos;
   int i, j;
 
+  // create hash from list of tokens to be ignored (for quick access)
+  ignore_tokens_hash = newSetupFileHash();
+  for (i = 0; ignore_tokens[i] != NULL; i++)
+    setHashEntry(ignore_tokens_hash, ignore_tokens[i], "");
+
   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 */
+  // always start with reliable default values
   for (i = 0; i < num_file_list_entries; i++)
   {
     file_list[i].token = NULL;
@@ -2866,10 +2795,9 @@ struct FileInfo *getFileListFromConfigList(struct ConfigInfo *config_list,
       }
     }
 
-    /* the following tokens are no file definitions, but other config tokens */
-    for (j = 0; ignore_tokens[j] != NULL; j++)
-      if (strEqual(config_list[i].token, ignore_tokens[j]))
-	is_file_entry = FALSE;
+    // the following tokens are no file definitions, but other config tokens
+    if (getHashEntry(ignore_tokens_hash, config_list[i].token) != NULL)
+      is_file_entry = FALSE;
 
     if (is_file_entry)
     {
@@ -2899,6 +2827,8 @@ struct FileInfo *getFileListFromConfigList(struct ConfigInfo *config_list,
     Error(ERR_EXIT,   "please fix");
   }
 
+  freeSetupFileHash(ignore_tokens_hash);
+
   return file_list;
 }
 
@@ -2907,7 +2837,7 @@ static boolean token_suffix_match(char *token, char *suffix, int start_pos)
   int len_token = strlen(token);
   int len_suffix = strlen(suffix);
 
-  if (start_pos < 0)	/* compare suffix from end of string */
+  if (start_pos < 0)	// compare suffix from end of string
     start_pos += len_token;
 
   if (start_pos < 0 || start_pos + len_suffix > len_token)
@@ -2931,7 +2861,7 @@ static void read_token_parameters(SetupFileHash *setup_file_hash,
 				  struct ConfigTypeInfo *suffix_list,
 				  struct FileInfo *file_list_entry)
 {
-  /* check for config token that is the base token without any suffixes */
+  // check for config token that is the base token without any suffixes
   char *filename = getHashEntry(setup_file_hash, file_list_entry->token);
   char *known_token_value = KNOWN_TOKEN_VALUE;
   int i;
@@ -2940,17 +2870,17 @@ static void read_token_parameters(SetupFileHash *setup_file_hash,
   {
     setString(&file_list_entry->filename, filename);
 
-    /* when file definition found, set all parameters to default values */
+    // when file definition found, set all parameters to default values
     for (i = 0; suffix_list[i].token != NULL; i++)
       setString(&file_list_entry->parameter[i], suffix_list[i].value);
 
     file_list_entry->redefined = TRUE;
 
-    /* mark config file token as well known from default config */
+    // mark config file token as well known from default config
     setHashEntry(setup_file_hash, file_list_entry->token, known_token_value);
   }
 
-  /* check for config tokens that can be build by base token and suffixes */
+  // check for config tokens that can be build by base token and suffixes
   for (i = 0; suffix_list[i].token != NULL; i++)
   {
     char *token = getStringCat2(file_list_entry->token, suffix_list[i].token);
@@ -2960,7 +2890,7 @@ static void read_token_parameters(SetupFileHash *setup_file_hash,
     {
       setString(&file_list_entry->parameter[i], value);
 
-      /* mark config file token as well known from default config */
+      // mark config file token as well known from default config
       setHashEntry(setup_file_hash, token, known_token_value);
     }
 
@@ -3032,9 +2962,10 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
   int num_ext2_suffixes = artwork_info->num_ext2_suffixes;
   int num_ext3_suffixes = artwork_info->num_ext3_suffixes;
   int num_ignore_tokens = artwork_info->num_ignore_tokens;
-  SetupFileHash *setup_file_hash, *valid_file_hash;
+  SetupFileHash *setup_file_hash, *valid_file_hash, *valid_file_hash_tmp;
   SetupFileHash *extra_file_hash, *empty_file_hash;
   char *known_token_value = KNOWN_TOKEN_VALUE;
+  char *base_token_value = UNDEFINED_FILENAME;
   int i, j, k, l;
 
   if (filename == NULL)
@@ -3043,7 +2974,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
   if ((setup_file_hash = loadSetupFileHash(filename)) == NULL)
     return;
 
-  /* separate valid (defined) from empty (undefined) config token values */
+  // separate valid (defined) from empty (undefined) config token values
   valid_file_hash = newSetupFileHash();
   empty_file_hash = newSetupFileHash();
   BEGIN_HASH_ITERATION(setup_file_hash, itr)
@@ -3055,11 +2986,23 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
   }
   END_HASH_ITERATION(setup_file_hash, itr)
 
-  /* at this point, we do not need the setup file hash anymore -- free it */
+  // at this point, we do not need the setup file hash anymore -- free it
   freeSetupFileHash(setup_file_hash);
 
-  /* map deprecated to current tokens (using prefix match and replace) */
+  // prevent changing hash while iterating over it by using a temporary copy
+  valid_file_hash_tmp = newSetupFileHash();
   BEGIN_HASH_ITERATION(valid_file_hash, itr)
+  {
+    setHashEntry(valid_file_hash_tmp,
+		 HASH_ITERATION_TOKEN(itr),
+		 HASH_ITERATION_VALUE(itr));
+  }
+  END_HASH_ITERATION(valid_file_hash, itr)
+
+  // (iterate over same temporary hash, as modifications are independent)
+
+  // map deprecated to current tokens (using prefix match and replace)
+  BEGIN_HASH_ITERATION(valid_file_hash_tmp, itr)
   {
     char *token = HASH_ITERATION_TOKEN(itr);
     char *mapped_token = get_mapped_token(token);
@@ -3068,26 +3011,46 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
     {
       char *value = HASH_ITERATION_VALUE(itr);
 
-      /* add mapped token */
+      // add mapped token
       setHashEntry(valid_file_hash, mapped_token, value);
 
-      /* ignore old token (by setting it to "known" keyword) */
+      // ignore old token (by setting it to "known" keyword)
       setHashEntry(valid_file_hash, token, known_token_value);
 
       free(mapped_token);
     }
   }
-  END_HASH_ITERATION(valid_file_hash, itr)
+  END_HASH_ITERATION(valid_file_hash_tmp, itr)
 
-  /* read parameters for all known config file tokens */
+  // add special base tokens (using prefix match and replace)
+  BEGIN_HASH_ITERATION(valid_file_hash_tmp, itr)
+  {
+    char *token = HASH_ITERATION_TOKEN(itr);
+    char *base_token = get_special_base_token(artwork_info, token);
+
+    if (base_token != NULL)
+    {
+      // add base token only if it does not already exist
+      if (getHashEntry(valid_file_hash, base_token) == NULL)
+	setHashEntry(valid_file_hash, base_token, base_token_value);
+
+      free(base_token);
+    }
+  }
+  END_HASH_ITERATION(valid_file_hash_tmp, itr)
+
+  // free temporary hash used for iteration
+  freeSetupFileHash(valid_file_hash_tmp);
+
+  // read parameters for all known config file tokens
   for (i = 0; i < num_file_list_entries; i++)
     read_token_parameters(valid_file_hash, suffix_list, &file_list[i]);
 
-  /* set all tokens that can be ignored here to "known" keyword */
+  // set all tokens that can be ignored here to "known" keyword
   for (i = 0; i < num_ignore_tokens; i++)
     setHashEntry(valid_file_hash, ignore_tokens[i], known_token_value);
 
-  /* copy all unknown config file tokens to extra config hash */
+  // copy all unknown config file tokens to extra config hash
   extra_file_hash = newSetupFileHash();
   BEGIN_HASH_ITERATION(valid_file_hash, itr)
   {
@@ -3098,10 +3061,10 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
   }
   END_HASH_ITERATION(valid_file_hash, itr)
 
-  /* at this point, we do not need the valid file hash anymore -- free it */
+  // at this point, we do not need the valid file hash anymore -- free it
   freeSetupFileHash(valid_file_hash);
 
-  /* now try to determine valid, dynamically defined config tokens */
+  // now try to determine valid, dynamically defined config tokens
 
   BEGIN_HASH_ITERATION(extra_file_hash, itr)
   {
@@ -3122,7 +3085,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
     boolean base_prefix_found = FALSE;
     boolean parameter_suffix_found = FALSE;
 
-    /* skip all parameter definitions (handled by read_token_parameters()) */
+    // skip all parameter definitions (handled by read_token_parameters())
     for (i = 0; i < num_suffix_list_entries && !parameter_suffix_found; i++)
     {
       int len_suffix = strlen(suffix_list[i].token);
@@ -3134,7 +3097,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
     if (parameter_suffix_found)
       continue;
 
-    /* ---------- step 0: search for matching base prefix ---------- */
+    // ---------- step 0: search for matching base prefix ----------
 
     start_pos = 0;
     for (i = 0; i < num_base_prefixes && !base_prefix_found; i++)
@@ -3157,7 +3120,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
 
       base_index = i;
 
-      if (start_pos + len_base_prefix == len_token)	/* exact match */
+      if (start_pos + len_base_prefix == len_token)	// exact match
       {
 	exact_match = TRUE;
 
@@ -3174,7 +3137,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
 	continue;
       }
 
-      /* ---------- step 1: search for matching first suffix ---------- */
+      // ---------- step 1: search for matching first suffix ----------
 
       start_pos += len_base_prefix;
       for (j = 0; j < num_ext1_suffixes && !ext1_suffix_found; j++)
@@ -3189,7 +3152,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
 
 	ext1_index = j;
 
-	if (start_pos + len_ext1_suffix == len_token)	/* exact match */
+	if (start_pos + len_ext1_suffix == len_token)	// exact match
 	{
 	  exact_match = TRUE;
 
@@ -3212,7 +3175,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
       if (exact_match)
 	break;
 
-      /* ---------- step 2: search for matching second suffix ---------- */
+      // ---------- step 2: search for matching second suffix ----------
 
       for (k = 0; k < num_ext2_suffixes && !ext2_suffix_found; k++)
       {
@@ -3226,7 +3189,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
 
 	ext2_index = k;
 
-	if (start_pos + len_ext2_suffix == len_token)	/* exact match */
+	if (start_pos + len_ext2_suffix == len_token)	// exact match
 	{
 	  exact_match = TRUE;
 
@@ -3249,7 +3212,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
       if (exact_match)
 	break;
 
-      /* ---------- step 3: search for matching third suffix ---------- */
+      // ---------- step 3: search for matching third suffix ----------
 
       for (l = 0; l < num_ext3_suffixes && !ext3_suffix_found; l++)
       {
@@ -3263,7 +3226,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
 
 	ext3_index = l;
 
-	if (start_pos + len_ext3_suffix == len_token) /* exact match */
+	if (start_pos + len_ext3_suffix == len_token) // exact match
 	{
 	  exact_match = TRUE;
 
@@ -3298,7 +3261,7 @@ static void LoadArtworkConfigFromFilename(struct ArtworkListInfo *artwork_info,
     boolean unknown_tokens_found = FALSE;
     boolean undefined_values_found = (hashtable_count(empty_file_hash) != 0);
 
-    /* list may be NULL for empty artwork config files */
+    // list may be NULL for empty artwork config files
     setup_file_list = loadSetupFileList(filename);
 
     BEGIN_HASH_ITERATION(extra_file_hash, itr)
@@ -3379,7 +3342,7 @@ void LoadArtworkConfig(struct ArtworkListInfo *artwork_info)
   DrawInitText("Loading artwork config", 120, FC_GREEN);
   DrawInitText(ARTWORKINFO_FILENAME(artwork_info->type), 150, FC_YELLOW);
 
-  /* always start with reliable default values */
+  // always start with reliable default values
   for (i = 0; i < num_file_list_entries; i++)
   {
     setString(&file_list[i].filename, file_list[i].default_filename);
@@ -3391,7 +3354,7 @@ void LoadArtworkConfig(struct ArtworkListInfo *artwork_info)
     file_list[i].fallback_to_default = FALSE;
   }
 
-  /* free previous dynamic artwork file array */
+  // free previous dynamic artwork file array
   if (artwork_info->dynamic_file_list != NULL)
   {
     for (i = 0; i < artwork_info->num_dynamic_file_list_entries; i++)
@@ -3408,7 +3371,7 @@ void LoadArtworkConfig(struct ArtworkListInfo *artwork_info)
 			  &artwork_info->num_dynamic_file_list_entries);
   }
 
-  /* free previous property mapping */
+  // free previous property mapping
   if (artwork_info->property_mapping != NULL)
   {
     free(artwork_info->property_mapping);
@@ -3419,7 +3382,7 @@ void LoadArtworkConfig(struct ArtworkListInfo *artwork_info)
 
   if (!GFX_OVERRIDE_ARTWORK(artwork_info->type))
   {
-    /* first look for special artwork configured in level series config */
+    // first look for special artwork configured in level series config
     filename_base = getCustomArtworkLevelConfigFilename(artwork_info->type);
 
     if (fileExists(filename_base))
@@ -3468,13 +3431,13 @@ static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
 
     basename = file_list_entry->default_filename;
 
-    /* fail for cloned default artwork that has no default filename defined */
+    // fail for cloned default artwork that has no default filename defined
     if (file_list_entry->default_is_cloned &&
 	strEqual(basename, UNDEFINED_FILENAME))
     {
       int error_mode = ERR_WARN;
 
-      /* we can get away without sounds and music, but not without graphics */
+      // 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;
 
@@ -3484,7 +3447,7 @@ static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
       return;
     }
 
-    /* dynamic artwork has no default filename / skip empty default artwork */
+    // dynamic artwork has no default filename / skip empty default artwork
     if (basename == NULL || strEqual(basename, UNDEFINED_FILENAME))
       return;
 
@@ -3498,7 +3461,7 @@ static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
     {
       int error_mode = ERR_WARN;
 
-      /* we can get away without sounds and music, but not without graphics */
+      // 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;
 
@@ -3508,20 +3471,20 @@ static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
     }
   }
 
-  /* check if the old and the new artwork file are the same */
+  // check if the old and the new artwork file are the same
   if (*listnode && strEqual((*listnode)->source_filename, filename))
   {
-    /* The old and new artwork are the same (have the same filename and path).
-       This usually means that this artwork does not exist in this artwork set
-       and a fallback to the existing artwork is done. */
+    // The old and new artwork are the same (have the same filename and path).
+    // This usually means that this artwork does not exist in this artwork set
+    // and a fallback to the existing artwork is done.
 
     return;
   }
 
-  /* delete existing artwork file entry */
+  // delete existing artwork file entry
   deleteArtworkListEntry(artwork_info, listnode);
 
-  /* check if the new artwork file already exists in the list of artwork */
+  // check if the new artwork file already exists in the list of artwork
   if ((node = getNodeFromKey(artwork_info->content_list, filename)) != NULL)
   {
       *listnode = (struct ListNodeInfo *)node->content;
@@ -3535,7 +3498,7 @@ static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
 
   if ((*listnode = artwork_info->load_artwork(filename)) != NULL)
   {
-    /* add new artwork file entry to the list of artwork files */
+    // add new artwork file entry to the list of artwork files
     (*listnode)->num_references = 1;
     addNodeToList(&artwork_info->content_list, (*listnode)->source_filename,
 		  *listnode);
@@ -3544,7 +3507,7 @@ static void replaceArtworkListEntry(struct ArtworkListInfo *artwork_info,
   {
     int error_mode = ERR_WARN;
 
-    /* we can get away without sounds and music, but not without graphics */
+    // we can get away without sounds and music, but not without graphics
     if (artwork_info->type == ARTWORK_TYPE_GRAPHICS)
       error_mode = ERR_EXIT;
 
@@ -3624,18 +3587,18 @@ void FreeCustomArtworkLists(struct ArtworkListInfo *artwork_info)
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* functions only needed for non-Unix (non-command-line) systems             */
-/* (MS-DOS only; SDL/Windows creates files "stdout.txt" and "stderr.txt")    */
-/* (now also added for Windows, to create files in user data directory)      */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// functions only needed for non-Unix (non-command-line) systems
+// (MS-DOS only; SDL/Windows creates files "stdout.txt" and "stderr.txt")
+// (now also added for Windows, to create files in user data directory)
+// ----------------------------------------------------------------------------
 
 char *getLogFilename(char *basename)
 {
   return getPath2(getUserGameDataDir(), basename);
 }
 
-void OpenLogFiles()
+void OpenLogFiles(void)
 {
   int i;
 
@@ -3652,12 +3615,12 @@ void OpenLogFiles()
 	    program.log_filename[i], strerror(errno));
     }
 
-    /* output should be unbuffered so it is not truncated in a crash */
+    // output should be unbuffered so it is not truncated in a crash
     setbuf(program.log_file[i], NULL);
   }
 }
 
-void CloseLogFiles()
+void CloseLogFiles(void)
 {
   int i;
 
@@ -3679,7 +3642,7 @@ void DumpLogFile(int nr)
   fclose(log_file);
 }
 
-void NotifyUserAboutErrorFile()
+void NotifyUserAboutErrorFile(void)
 {
 #if defined(PLATFORM_WIN32)
   char *title_text = getStringCat2(program.program_title, " Error Message");
@@ -3693,9 +3656,9 @@ void NotifyUserAboutErrorFile()
 }
 
 
-/* ------------------------------------------------------------------------- */
-/* the following is only for debugging purpose and normally not used         */
-/* ------------------------------------------------------------------------- */
+// ----------------------------------------------------------------------------
+// the following is only for debugging purpose and normally not used
+// ----------------------------------------------------------------------------
 
 #if DEBUG
 
@@ -3706,7 +3669,7 @@ void NotifyUserAboutErrorFile()
 #define DEBUG_TIME_IN_MICROSECONDS		0
 
 #if DEBUG_TIME_IN_MICROSECONDS
-static double Counter_Microseconds()
+static double Counter_Microseconds(void)
 {
   static struct timeval base_time = { 0, 0 };
   struct timeval current_time;
@@ -3714,7 +3677,7 @@ static double Counter_Microseconds()
 
   gettimeofday(&current_time, NULL);
 
-  /* reset base time in case of wrap-around */
+  // reset base time in case of wrap-around
   if (current_time.tv_sec < base_time.tv_sec)
     base_time = current_time;
 
@@ -3722,11 +3685,11 @@ static double Counter_Microseconds()
     ((double)(current_time.tv_sec  - base_time.tv_sec)) * 1000000 +
     ((double)(current_time.tv_usec - base_time.tv_usec));
 
-  return counter;		/* return microseconds since last init */
+  return counter;		// return microseconds since last init
 }
 #endif
 
-char *debug_print_timestamp_get_padding(int padding_size)
+static char *debug_print_timestamp_get_padding(int padding_size)
 {
   static char *padding = NULL;
   int max_padding_size = 100;
@@ -3775,7 +3738,8 @@ void debug_print_timestamp(int counter_nr, char *message)
 	   unit);
 }
 
-void debug_print_parent_only(char *format, ...)
+#if 0
+static void debug_print_parent_only(char *format, ...)
 {
   if (!IS_PARENT_PROCESS())
     return;
@@ -3791,10 +3755,11 @@ void debug_print_parent_only(char *format, ...)
     printf("\n");
   }
 }
+#endif
 
-#endif	/* DEBUG */
+#endif	// DEBUG
 
-void print_timestamp_ext(char *message, char *mode)
+static void print_timestamp_ext(char *message, char *mode)
 {
 #if DEBUG_PRINT_INIT_TIMESTAMPS
   static char *debug_message = NULL;