+ while (1)
+ {
+ actual_counter = Counter();
+
+ if (actual_counter >= *counter_var &&
+ actual_counter < *counter_var + delay)
+ sleep_milliseconds((*counter_var + delay - actual_counter) / 2);
+ else
+ break;
+ }
+
+ if (*counter_var != 0 &&
+ delay != 0 &&
+ actual_counter >= *counter_var + delay)
+ {
+ int lag = actual_counter - (*counter_var + delay);
+ int delay2 = (delay + 1) / 2;
+
+ if (lag >= delay2)
+ skip_frames = (lag + delay2) / delay;
+ }
+
+ *counter_var = actual_counter;
+
+ return skip_frames;
+}
+
+void SkipUntilDelayReached(DelayCounter *counter,
+ int *loop_var, int last_loop_value)
+{
+ int skip_frames = WaitUntilDelayReached(counter);
+
+#if 0
+#if DEBUG
+ if (skip_frames)
+ Debug("internal:SkipUntilDelayReached",
+ "%d: %d ms -> SKIP %d FRAME(S) [%d ms]",
+ *loop_var, counter->value,
+ skip_frames, skip_frames * counter->value);
+ else
+ Debug("internal:SkipUntilDelayReached",
+ "%d: %d ms",
+ *loop_var, counter->value);
+#endif
+#endif
+
+ if (skip_frames == 0)
+ return;
+
+ // when skipping frames, make sure to never skip the last frame, as
+ // this may be needed for animations to reach a defined end state;
+ // furthermore, we assume that this function is called at the end
+ // of a "for" loop, which continues by incrementing the loop variable
+ // by one before checking the loop condition again; therefore we have
+ // to check against the last loop value minus one here
+
+ last_loop_value--;
+
+ if (*loop_var < last_loop_value) // never skip the last frame
+ {
+ *loop_var += skip_frames;
+
+ if (*loop_var > last_loop_value) // never skip the last frame
+ *loop_var = last_loop_value;
+ }
+}
+
+
+// ----------------------------------------------------------------------------
+// random generator functions
+// ----------------------------------------------------------------------------
+
+static unsigned int init_random_number_ext(int nr, int seed)
+{
+ if (seed == NEW_RANDOMIZE)
+ {
+ // default random seed
+ seed = (int)time(NULL); // seconds since the epoch
+
+#if !defined(PLATFORM_WINDOWS)
+ // add some more randomness
+ struct timeval current_time;
+
+ gettimeofday(¤t_time, NULL);
+
+ seed += (int)current_time.tv_usec; // microseconds since the epoch
+#endif
+
+ // add some more randomness
+ seed += (int)SDL_GetTicks(); // milliseconds since SDL init
+
+ // add some more randomness
+ seed += GetSimpleRandom(1000000);
+ }
+
+ srandom_linux_libc(nr, (unsigned int) seed);
+
+ return (unsigned int) seed;
+}
+
+static unsigned int prng_seed_gettimeofday(void)
+{
+ struct timeval current_time;
+
+ gettimeofday(¤t_time, NULL);
+
+ prng_seed_bytes(¤t_time, sizeof(current_time));
+
+ return 0;
+}
+
+unsigned int init_random_number(int nr, int seed)
+{
+ return (nr == RANDOM_BETTER ? prng_seed_gettimeofday() :
+ init_random_number_ext(nr, seed));
+}
+
+static unsigned int get_random_number_ext(int nr)
+{
+ return (nr == RANDOM_BETTER ? prng_get_uint() :
+ random_linux_libc(nr));
+}
+
+unsigned int get_random_number(int nr, int max)
+{
+ return (max > 0 ? get_random_number_ext(nr) % max : 0);
+}
+
+
+// ----------------------------------------------------------------------------
+// system info functions
+// ----------------------------------------------------------------------------
+
+#if !defined(PLATFORM_ANDROID)
+static char *get_corrected_real_name(char *real_name)
+{
+ char *real_name_new = checked_malloc(MAX_USERNAME_LEN + 1);
+ char *from_ptr = real_name;
+ char *to_ptr = real_name_new;
+
+ // 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
+ 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)
+ if (*from_ptr == CHAR_BYTE_SHARP_S)
+ {
+ from_ptr++;
+ *to_ptr++ = 's';
+ *to_ptr++ = 's';
+ }
+ else
+ *to_ptr++ = *from_ptr++;
+ }
+
+ *to_ptr = '\0';
+
+ return real_name_new;
+}
+#endif
+
+#if defined(PLATFORM_UNIX)
+static struct passwd *getPasswdEntry(void)
+{
+#if defined(PLATFORM_EMSCRIPTEN)
+ // currently not fully supported; force fallback to default values
+ return NULL;
+#else
+ return getpwuid(getuid());
+#endif
+}
+
+char *getUnixLoginName(void)
+{
+ struct passwd *pwd = getPasswdEntry();
+
+ if (pwd != NULL && strlen(pwd->pw_name) != 0)
+ return pwd->pw_name;
+
+ return NULL;
+}
+
+char *getUnixRealName(void)
+{
+ struct passwd *pwd = getPasswdEntry();
+
+ if (pwd != NULL && strlen(pwd->pw_gecos) != 0)
+ return pwd->pw_gecos;
+
+ return NULL;
+}
+
+char *getUnixHomeDir(void)
+{
+ struct passwd *pwd = getPasswdEntry();
+
+ if (pwd != NULL && strlen(pwd->pw_dir) != 0)
+ return pwd->pw_dir;
+
+ return NULL;
+}
+#endif
+
+char *getLoginName(void)
+{
+ static char *login_name = NULL;
+
+#if defined(PLATFORM_WINDOWS)
+ if (login_name == NULL)
+ {
+ unsigned long buffer_size = MAX_USERNAME_LEN + 1;
+
+ login_name = checked_malloc(buffer_size);
+
+ if (GetUserName(login_name, &buffer_size) == 0)
+ strcpy(login_name, ANONYMOUS_NAME);
+ }
+#elif defined(PLATFORM_UNIX) && !defined(PLATFORM_ANDROID)
+ if (login_name == NULL)
+ {
+ char *name = getUnixLoginName();
+
+ if (name != NULL)
+ login_name = getStringCopy(name);
+ else
+ login_name = ANONYMOUS_NAME;
+ }
+#else
+ login_name = ANONYMOUS_NAME;
+#endif
+
+ return login_name;
+}
+
+char *getRealName(void)
+{
+ static char *real_name = NULL;
+
+#if defined(PLATFORM_WINDOWS)
+ if (real_name == NULL)
+ {
+ static char buffer[MAX_USERNAME_LEN + 1];
+ unsigned long buffer_size = MAX_USERNAME_LEN + 1;
+
+ if (GetUserName(buffer, &buffer_size) != 0)
+ real_name = get_corrected_real_name(buffer);
+ else
+ real_name = ANONYMOUS_NAME;
+ }
+#elif defined(PLATFORM_UNIX) && !defined(PLATFORM_ANDROID)
+ if (real_name == NULL)
+ {
+ char *name = getUnixRealName();
+
+ if (name != NULL)
+ real_name = get_corrected_real_name(name);
+ else
+ real_name = ANONYMOUS_NAME;
+ }
+#else
+ real_name = ANONYMOUS_NAME;
+#endif
+
+ return real_name;
+}
+
+char *getFixedUserName(char *name)
+{
+ // needed because player name must be a fixed length string
+ char *name_new = checked_malloc(MAX_PLAYER_NAME_LEN + 1);
+
+ strncpy(name_new, name, MAX_PLAYER_NAME_LEN);
+ name_new[MAX_PLAYER_NAME_LEN] = '\0';
+
+ if (strlen(name) > MAX_PLAYER_NAME_LEN) // name has been cut
+ if (strchr(name_new, ' '))
+ *strchr(name_new, ' ') = '\0';
+
+ return name_new;
+}
+
+char *getDefaultUserName(int nr)
+{
+ static char *user_name[MAX_PLAYER_NAMES] = { NULL };
+
+ nr = MIN(MAX(0, nr), MAX_PLAYER_NAMES - 1);
+
+ if (user_name[nr] == NULL)
+ {
+ user_name[nr] = (nr == 0 ? getLoginName() : EMPTY_PLAYER_NAME);
+ user_name[nr] = getFixedUserName(user_name[nr]);
+ }
+
+ return user_name[nr];
+}
+
+char *getTimestampFromEpoch(time_t epoch_seconds)
+{
+ struct tm *now = localtime(&epoch_seconds);
+ static char timestamp[20];
+
+ sprintf(timestamp, "%04d%02d%02d-%02d%02d%02d",
+ now->tm_year + 1900, now->tm_mon + 1, now->tm_mday,
+ now->tm_hour, now->tm_min, now->tm_sec);
+
+ return timestamp;
+}
+
+char *getCurrentTimestamp(void)
+{
+ return getTimestampFromEpoch(time(NULL));
+}
+
+time_t getFileTimestampEpochSeconds(char *filename)
+{
+ struct stat file_status;
+
+ if (stat(filename, &file_status) != 0) // cannot stat file
+ return 0;
+
+ return file_status.st_mtime;
+}
+
+
+// ----------------------------------------------------------------------------
+// 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
+ last_separator = strrchr(filename, CHAR_PATH_SEPARATOR_DOS);
+
+ return last_separator;
+}
+
+char *getBaseNamePtr(char *filename)
+{
+ char *last_separator = getLastPathSeparatorPtr(filename);
+
+ if (last_separator != NULL)
+ return last_separator + 1; // separator found: strip base path
+ else
+ return filename; // no separator found: filename has no path
+}
+
+char *getBaseName(char *filename)
+{
+ return getStringCopy(getBaseNamePtr(filename));
+}
+
+char *getBaseNameNoSuffix(char *filename)
+{
+ char *basename = getStringCopy(getBaseNamePtr(filename));
+
+ // remove trailing suffix (separated by dot or hyphen)
+ if (basename[0] != '.' && basename[0] != '-')
+ {
+ if (strchr(basename, '.') != NULL)
+ *strchr(basename, '.') = '\0';
+
+ if (strchr(basename, '-') != NULL)
+ *strchr(basename, '-') = '\0';
+ }
+
+ return basename;
+}
+
+char *getBasePath(char *filename)
+{
+ char *basepath = getStringCopy(filename);
+ char *last_separator = getLastPathSeparatorPtr(basepath);
+
+ // if no separator was found, use current directory
+ if (last_separator == NULL)
+ {
+ free(basepath);
+
+ return getStringCopy(".");
+ }
+
+ // separator found: strip basename
+ *last_separator = '\0';
+
+ return basepath;
+}
+
+
+// ----------------------------------------------------------------------------
+// various string functions
+// ----------------------------------------------------------------------------
+
+char *getStringCat2WithSeparator(const char *s1,
+ const char *s2,
+ const char *sep)
+{
+ if (s1 == NULL || s2 == NULL || sep == NULL)
+ return NULL;
+
+ char *complete_string = checked_malloc(strlen(s1) + strlen(sep) +
+ strlen(s2) + 1);
+
+ sprintf(complete_string, "%s%s%s", s1, sep, s2);
+
+ return complete_string;
+}
+
+char *getStringCat3WithSeparator(const char *s1,
+ const char *s2,
+ const char *s3,
+ const char *sep)
+{
+ if (s1 == NULL || s2 == NULL || s3 == NULL || sep == NULL)
+ return NULL;
+
+ char *complete_string = checked_malloc(strlen(s1) + strlen(sep) +
+ strlen(s2) + strlen(sep) +
+ strlen(s3) + 1);
+
+ sprintf(complete_string, "%s%s%s%s%s", s1, sep, s2, sep, s3);
+
+ return complete_string;
+}
+
+char *getStringCat2(const char *s1, const char *s2)
+{
+ return getStringCat2WithSeparator(s1, s2, "");
+}
+
+char *getStringCat3(const char *s1, const char *s2, const char *s3)
+{
+ return getStringCat3WithSeparator(s1, s2, s3, "");
+}
+
+char *getPath2(const char *path1, const char *path2)
+{
+#if defined(PLATFORM_ANDROID)
+ // workaround for reading from assets directory -- skip "." subdirs in path
+ if (strEqual(path1, "."))
+ return getStringCopy(path2);
+ else if (strEqual(path2, "."))
+ return getStringCopy(path1);
+#endif
+
+ return getStringCat2WithSeparator(path1, path2, STRING_PATH_SEPARATOR);
+}
+
+char *getPath3(const char *path1, const char *path2, const char *path3)
+{
+#if defined(PLATFORM_ANDROID)
+ // workaround for reading from assets directory -- skip "." subdirs in path
+ if (strEqual(path1, "."))
+ return getStringCat2WithSeparator(path2, path3, STRING_PATH_SEPARATOR);
+ else if (strEqual(path2, "."))
+ return getStringCat2WithSeparator(path1, path3, STRING_PATH_SEPARATOR);
+ else if (strEqual(path3, "."))
+ return getStringCat2WithSeparator(path1, path2, STRING_PATH_SEPARATOR);
+#endif
+
+ return getStringCat3WithSeparator(path1, path2, path3, STRING_PATH_SEPARATOR);
+}
+
+static char *getPngOrPcxIfNotExists(char *filename)
+{
+ // switch from PNG to PCX file and vice versa, if file does not exist
+ // (backwards compatibility with PCX files used in previous versions)
+
+ 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 *getImg2(const char *path1, const char *path2)
+{
+ return getPngOrPcxIfNotExists(getPath2(path1, path2));
+}
+
+char *getImg3(const char *path1, const char *path2, const char *path3)
+{
+ return getPngOrPcxIfNotExists(getPath3(path1, path2, path3));
+}
+
+char *getStringCopy(const char *s)
+{
+ char *s_copy;
+
+ if (s == NULL)
+ return NULL;
+
+ s_copy = checked_malloc(strlen(s) + 1);
+ strcpy(s_copy, s);
+
+ return s_copy;
+}
+
+char *getStringCopyN(const char *s, int n)
+{
+ char *s_copy;
+ int s_len = MAX(0, n);
+
+ if (s == NULL)
+ return NULL;
+
+ s_copy = checked_malloc(s_len + 1);
+ strncpy(s_copy, s, s_len);
+ s_copy[s_len] = '\0';
+
+ return s_copy;
+}
+
+char *getStringCopyNStatic(const char *s, int n)
+{
+ static char *s_copy = NULL;
+
+ checked_free(s_copy);
+
+ s_copy = getStringCopyN(s, n);
+
+ return s_copy;
+}
+
+char *getStringToLower(const char *s)
+{
+ char *s_copy = checked_malloc(strlen(s) + 1);
+ char *s_ptr = s_copy;
+
+ while (*s)
+ *s_ptr++ = tolower(*s++);
+ *s_ptr = '\0';
+
+ return s_copy;
+}
+
+void setString(char **old_value, const char *new_value)
+{
+ checked_free(*old_value);
+
+ *old_value = getStringCopy(new_value);
+}
+
+char **getSplitStringArray(const char *s, const char *separators, int max_tokens)
+{
+ const char *s_ptr, *s_last = s;
+ byte separator_table[256] = { FALSE };
+ int num_tokens;
+ char **tokens = NULL;
+
+ if (s == NULL)
+ return NULL;
+
+ if (separators == NULL)
+ return NULL;
+
+ if (max_tokens < 1)
+ max_tokens = INT_MAX;
+
+ // if string is empty, return empty array
+ if (*s == '\0')
+ {
+ tokens = checked_malloc(sizeof(char *));
+ tokens[0] = NULL;
+
+ return tokens;
+ }
+
+ // initialize separator table for all characters in separators string
+ for (s_ptr = separators; *s_ptr != '\0'; s_ptr++)
+ separator_table[*(byte *)s_ptr] = TRUE;
+
+ // count number of tokens in string
+ for (num_tokens = 1, s_ptr = s; *s_ptr != '\0'; s_ptr++)
+ if (separator_table[*(byte *)s_ptr] && num_tokens < max_tokens)
+ num_tokens++;
+
+ // allocate array for determined number of tokens
+ tokens = checked_malloc((num_tokens + 1) * sizeof(char *));
+
+ // copy all but last separated sub-strings to array
+ for (num_tokens = 0, s_ptr = s; *s_ptr != '\0'; s_ptr++)
+ {
+ if (separator_table[*(byte *)s_ptr] && num_tokens + 1 < max_tokens)
+ {
+ tokens[num_tokens++] = getStringCopyN(s_last, s_ptr - s_last);
+ s_last = s_ptr + 1;
+ }
+ }
+
+ // copy last separated sub-string to array
+ tokens[num_tokens++] = getStringCopyN(s_last, s_ptr - s_last);
+
+ // terminate array
+ tokens[num_tokens] = NULL;
+
+ return tokens;
+}
+
+int getStringArrayLength(char **s_array)
+{
+ int num_strings = 0;
+
+ if (s_array == NULL)
+ return 0;
+
+ while (s_array[num_strings] != NULL)
+ num_strings++;
+
+ return num_strings;
+}
+
+void freeStringArray(char **s_array)
+{
+ int i;
+
+ if (s_array == NULL)
+ return;
+
+ for (i = 0; s_array[i] != NULL; i++)
+ checked_free(s_array[i]);
+
+ checked_free(s_array);
+}
+
+char *getUnescapedString(const char *s)
+{
+ const char *s_ptr = s;
+ const char *octal_ptr;
+ char *s_unescaped;
+ char *s_unescaped_ptr;
+
+ if (s == NULL)
+ return NULL;
+
+ s_unescaped = checked_malloc(strlen(s) + 1);
+ s_unescaped_ptr = s_unescaped;
+
+ while (*s_ptr != '\0')
+ {
+ if (*s_ptr == '\\')
+ {
+ s_ptr++;
+
+ switch (*s_ptr)
+ {
+ case '\0':
+ Warn("getUnescapedString: trailing \\");
+ goto out;
+
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ *s_unescaped_ptr = 0;
+ octal_ptr = s_ptr;
+
+ while (s_ptr < octal_ptr + 3 && *s_ptr >= '0' && *s_ptr <= '7')
+ {
+ *s_unescaped_ptr = (*s_unescaped_ptr * 8) + (*s_ptr - '0');
+ s_ptr++;
+ }
+
+ s_unescaped_ptr++;
+ s_ptr--;
+ break;
+
+ case 'b':
+ *s_unescaped_ptr++ = '\b';
+ break;
+
+ case 'f':
+ *s_unescaped_ptr++ = '\f';
+ break;
+
+ case 'n':
+ *s_unescaped_ptr++ = '\n';
+ break;
+
+ case 'r':
+ *s_unescaped_ptr++ = '\r';
+ break;
+
+ case 't':
+ *s_unescaped_ptr++ = '\t';
+ break;
+
+ case 'v':
+ *s_unescaped_ptr++ = '\v';
+ break;
+
+ default:
+ /* also handles \" and \\ */
+ *s_unescaped_ptr++ = *s_ptr;
+ break;
+ }
+ }
+ else
+ {
+ *s_unescaped_ptr++ = *s_ptr;
+ }
+
+ s_ptr++;
+ }
+
+ out:
+ *s_unescaped_ptr = '\0';
+
+ return s_unescaped;
+}
+
+boolean strEqual(const char *s1, const char *s2)
+{
+ return (s1 == NULL && s2 == NULL ? TRUE :
+ s1 == NULL && s2 != NULL ? FALSE :
+ s1 != NULL && s2 == NULL ? FALSE :
+ strcmp(s1, s2) == 0);
+}
+
+boolean strEqualN(const char *s1, const char *s2, int n)
+{
+ return (s1 == NULL && s2 == NULL ? TRUE :
+ s1 == NULL && s2 != NULL ? FALSE :
+ s1 != NULL && s2 == NULL ? FALSE :
+ strncmp(s1, s2, n) == 0);
+}
+
+boolean strEqualCase(const char *s1, const char *s2)
+{
+ return (s1 == NULL && s2 == NULL ? TRUE :
+ s1 == NULL && s2 != NULL ? FALSE :
+ s1 != NULL && s2 == NULL ? FALSE :
+ strcasecmp(s1, s2) == 0);
+}
+
+boolean strEqualCaseN(const char *s1, const char *s2, int n)
+{
+ return (s1 == NULL && s2 == NULL ? TRUE :
+ s1 == NULL && s2 != NULL ? FALSE :
+ s1 != NULL && s2 == NULL ? FALSE :
+ strncasecmp(s1, s2, n) == 0);
+}
+
+boolean strPrefix(const char *s, const char *prefix)
+{
+ return (s == NULL && prefix == NULL ? TRUE :
+ s == NULL && prefix != NULL ? FALSE :
+ s != NULL && prefix == NULL ? FALSE :
+ strncmp(s, prefix, strlen(prefix)) == 0);
+}
+
+boolean strSuffix(const char *s, const char *suffix)
+{
+ return (s == NULL && suffix == NULL ? TRUE :
+ s == NULL && suffix != NULL ? FALSE :
+ s != NULL && suffix == NULL ? FALSE :
+ strlen(s) < strlen(suffix) ? FALSE :
+ strcmp(&s[strlen(s) - strlen(suffix)], suffix) == 0);
+}
+
+boolean strPrefixLower(const char *s, const char *prefix)
+{
+ char *s_lower = getStringToLower(s);
+ boolean match = strPrefix(s_lower, prefix);
+
+ free(s_lower);
+
+ return match;
+}
+
+boolean strSuffixLower(const char *s, const char *suffix)
+{
+ char *s_lower = getStringToLower(s);
+ boolean match = strSuffix(s_lower, suffix);
+
+ free(s_lower);
+
+ return match;
+}
+
+boolean isURL(const char *s)
+{
+ while (*s && *s >= 'a' && *s <= 'z')
+ s++;
+
+ return strPrefix(s, "://");
+}
+
+
+// ----------------------------------------------------------------------------
+// command line option handling functions
+// ----------------------------------------------------------------------------
+
+void GetOptions(int argc, char *argv[],
+ void (*print_usage_function)(void),
+ void (*print_version_function)(void))
+{
+ char *base_path = getProgramMainDataPath(argv[0], 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
+ while (argc--)
+ argvplus[argc] = argv[argc];
+
+ // initialize global program options
+ options.server_host = NULL;
+ options.server_port = 0;
+
+ options.base_directory = base_path;
+
+ options.level_directory = getPath2(base_path, LEVELS_DIRECTORY);
+ options.graphics_directory = getPath2(base_path, GRAPHICS_DIRECTORY);
+ options.sounds_directory = getPath2(base_path, SOUNDS_DIRECTORY);
+ options.music_directory = getPath2(base_path, MUSIC_DIRECTORY);
+ options.docs_directory = getPath2(base_path, DOCS_DIRECTORY);
+ options.conf_directory = getPath2(base_path, CONF_DIRECTORY);
+
+ options.execute_command = NULL;
+ options.tape_log_filename = NULL;
+ options.special_flags = NULL;
+ options.debug_mode = NULL;
+ options.player_name = NULL;
+ options.identifier = NULL;
+ options.level_nr = NULL;
+
+ options.display_nr = 0;
+
+ options.mytapes = FALSE;
+ options.serveronly = FALSE;
+ options.network = FALSE;
+ options.verbose = FALSE;
+ options.debug = FALSE;
+
+#if 1
+ options.verbose = TRUE;
+#else
+#if !defined(PLATFORM_UNIX)
+ 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)
+ {
+ char option_str[MAX_OPTION_LEN];
+ char *option = options_left[0];
+ char *next_option = options_left[1];
+ char *option_arg = NULL;
+ int option_len = strlen(option);
+
+ if (option_len >= MAX_OPTION_LEN)
+ FailWithHelp("unrecognized option '%s'", option);
+
+ strcpy(option_str, option); // copy argument into buffer
+ option = option_str;
+
+ if (strEqual(option, "--")) // stop scanning arguments
+ break;
+
+ if (strPrefix(option, "--")) // treat '--' like '-'
+ option++;
+
+ option_arg = strchr(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 '='
+ FailWithHelp("option '%s' has invalid argument", option_str);
+ }
+
+ option_len = strlen(option);
+
+ if (strEqual(option, "-"))
+ {
+ FailWithHelp("unrecognized option '%s'", option);
+ }
+ else if (strncmp(option, "-help", option_len) == 0)
+ {
+ print_usage_function();
+
+ exit(0);
+ }
+ else if (strncmp(option, "-basepath", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.base_directory = base_path = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+
+ // adjust paths for sub-directories in base directory accordingly
+ options.level_directory = getPath2(base_path, LEVELS_DIRECTORY);
+ options.graphics_directory = getPath2(base_path, GRAPHICS_DIRECTORY);
+ options.sounds_directory = getPath2(base_path, SOUNDS_DIRECTORY);
+ options.music_directory = getPath2(base_path, MUSIC_DIRECTORY);
+ options.docs_directory = getPath2(base_path, DOCS_DIRECTORY);
+ options.conf_directory = getPath2(base_path, CONF_DIRECTORY);
+ }
+ else if (strncmp(option, "-levels", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.level_directory = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-graphics", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.graphics_directory = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-sounds", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.sounds_directory = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-music", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.music_directory = getStringCopy(option_arg);
+ 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;
+ }
+ else if (strncmp(option, "-serveronly", option_len) == 0)
+ {
+ options.serveronly = TRUE;
+ }
+ else if (strncmp(option, "-debug", option_len) == 0)
+ {
+ options.debug = TRUE;
+
+ // optionally, debug output can be limited to a specific debug mode
+ if (option_arg != next_option)
+ options.debug_mode = getStringCopy(option_arg);
+ }
+ else if (strncmp(option, "-player-name", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.player_name = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-identifier", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.identifier = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-level-nr", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.level_nr = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-verbose", option_len) == 0)
+ {
+ options.verbose = TRUE;
+ }
+ else if (strncmp(option, "-version", option_len) == 0 ||
+ strncmp(option, "-V", option_len) == 0)
+ {
+ print_version_function();
+
+ exit(0);
+ }
+ else if (strPrefix(option, "-D"))
+ {
+ options.special_flags = getStringCopy(&option[2]);
+ }
+ else if (strncmp(option, "-execute", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.execute_command = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+
+ // when doing batch processing, always enable verbose mode (warnings)
+ options.verbose = TRUE;
+ }
+ else if (strncmp(option, "-tape_logfile", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ options.tape_log_filename = getStringCopy(option_arg);
+ if (option_arg == next_option)
+ options_left++;
+ }
+ else if (strncmp(option, "-display", option_len) == 0)
+ {
+ if (option_arg == NULL)
+ FailWithHelp("option '%s' requires an argument", option_str);
+
+ if (option_arg == next_option)
+ options_left++;