X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Fmisc.c;h=15c8099f24755b0d8d6f0155a52281ff2c9f98ca;hp=be6894998d546e15e91b53c35eec06854848bf33;hb=0918c3eb2f6219a8cc72aa85bd9c4889788dd474;hpb=a4d4e8e444b21b58dcc88b52ff22726c545142a4 diff --git a/src/misc.c b/src/misc.c index be689499..15c8099f 100644 --- a/src/misc.c +++ b/src/misc.c @@ -18,13 +18,33 @@ #include #include #include +#include #include "misc.h" #include "init.h" #include "tools.h" #include "sound.h" #include "random.h" +#include "joystick.h" +#include "files.h" +#ifdef MSDOS +volatile unsigned long counter = 0; + +void increment_counter() +{ + counter++; +} + +END_OF_FUNCTION(increment_counter); +#endif + + + +/* maximal allowed length of a command line option */ +#define MAX_OPTION_LEN 256 + +#ifndef MSDOS static unsigned long mainCounter(int mode) { static struct timeval base_time = { 0, 0 }; @@ -41,20 +61,39 @@ static unsigned long mainCounter(int mode) return counter_ms; /* return milliseconds since last init */ } +#endif void InitCounter() /* set counter back to zero */ { +#ifndef MSDOS mainCounter(INIT_COUNTER); +#else + LOCK_VARIABLE(counter); + LOCK_FUNCTION(increment_counter); + install_int_ex(increment_counter, BPS_TO_TIMER(100)); +#endif } unsigned long Counter() /* get milliseconds since last call of InitCounter() */ { - return(mainCounter(READ_COUNTER)); +#ifndef MSDOS + return mainCounter(READ_COUNTER); +#else + return (counter * 10); +#endif } static void sleep_milliseconds(unsigned long milliseconds_delay) { - if (milliseconds_delay < 5) + boolean do_busy_waiting = (milliseconds_delay < 5 ? TRUE : FALSE); + +#ifdef MSDOS + /* donït use select() to perform waiting operations under DOS/Windows + environment; always use a busy loop for waiting instead */ + do_busy_waiting = TRUE; +#endif + + 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 to long; @@ -75,7 +114,7 @@ static void sleep_milliseconds(unsigned long milliseconds_delay) delay.tv_usec = 1000 * (milliseconds_delay % 1000); if (select(0, NULL, NULL, NULL, &delay) != 0) - Error(ERR_RETURN, "sleep_milliseconds(): select() failed"); + Error(ERR_WARN, "sleep_milliseconds(): select() failed"); } } @@ -128,12 +167,23 @@ void WaitUntilDelayReached(unsigned long *counter_var, unsigned long delay) *counter_var = actual_counter; } -char *int2str(int ct, int nr) +char *int2str(int number, int size) { - static char str[20]; + static char s[40]; - sprintf(str,"%09d",ct); - return(&str[strlen(str)-nr]); + if (size > 20) + size = 20; + + if (size) + { + sprintf(s, " %09d", number); + return &s[strlen(s) - size]; + } + else + { + sprintf(s, "%d", number); + return s; + } } unsigned int SimpleRND(unsigned int max) @@ -143,39 +193,114 @@ unsigned int SimpleRND(unsigned int max) gettimeofday(¤t_time,NULL); root = root * 4253261 + current_time.tv_sec + current_time.tv_usec; - return(root % max); + return (root % max); +} + +#ifdef DEBUG +static unsigned int last_RND_value = 0; + +unsigned int last_RND() +{ + return last_RND_value; } +#endif unsigned int RND(unsigned int max) { - return(random_linux_libc() % max); +#ifdef DEBUG + return (last_RND_value = random_linux_libc() % max); +#else + return (random_linux_libc() % max); +#endif } unsigned int InitRND(long seed) { struct timeval current_time; - if (seed==NEW_RANDOMIZE) + if (seed == NEW_RANDOMIZE) { gettimeofday(¤t_time,NULL); srandom_linux_libc((unsigned int) current_time.tv_usec); - return((unsigned int) current_time.tv_usec); + return (unsigned int)current_time.tv_usec; } else { srandom_linux_libc((unsigned int) seed); - return((unsigned int) seed); + return (unsigned int)seed; } } -char *GetLoginName() +char *getLoginName() { struct passwd *pwd; - if (!(pwd=getpwuid(getuid()))) - return("ANONYMOUS"); + if (!(pwd = getpwuid(getuid()))) + return "ANONYMOUS"; else - return(pwd->pw_name); + return pwd->pw_name; +} + +char *getHomeDir() +{ +#ifndef MSDOS + static char *home_dir = NULL; + + if (!home_dir) + { + if (!(home_dir = getenv("HOME"))) + { + struct passwd *pwd; + + if ((pwd = getpwuid(getuid()))) + home_dir = pwd->pw_dir; + else + home_dir = "."; + } + } + + return home_dir; +#else + return "."; +#endif +} + +char *getPath2(char *path1, char *path2) +{ + char *complete_path = checked_malloc(strlen(path1) + 1 + + strlen(path2) + 1); + + sprintf(complete_path, "%s/%s", path1, path2); + return complete_path; +} + +char *getPath3(char *path1, char *path2, char *path3) +{ + char *complete_path = checked_malloc(strlen(path1) + 1 + + strlen(path2) + 1 + + strlen(path3) + 1); + + sprintf(complete_path, "%s/%s/%s", path1, path2, path3); + return complete_path; +} + +char *getStringCopy(char *s) +{ + char *s_copy = checked_malloc(strlen(s) + 1); + + strcpy(s_copy, s); + return s_copy; +} + +char *getStringToLower(char *s) +{ + char *s_copy = checked_malloc(strlen(s) + 1); + char *s_ptr = s_copy; + + while (*s) + *s_ptr++ = tolower(*s++); + + return s_copy; } void MarkTileDirty(int x, int y) @@ -184,11 +309,10 @@ void MarkTileDirty(int x, int y) int yy = redraw_y1 + y; if (!redraw[xx][yy]) - { - redraw[xx][yy] = TRUE; redraw_tiles++; - redraw_mask |= REDRAW_TILES; - } + + redraw[xx][yy] = TRUE; + redraw_mask |= REDRAW_TILES; } void GetOptions(char *argv[]) @@ -199,6 +323,8 @@ void GetOptions(char *argv[]) options.display_name = NULL; options.server_host = NULL; options.server_port = 0; + options.base_directory = BASE_PATH; + options.level_directory = BASE_PATH "/" LEVELS_DIRECTORY; options.serveronly = FALSE; options.network = FALSE; options.verbose = FALSE; @@ -211,15 +337,15 @@ void GetOptions(char *argv[]) char *option_arg = NULL; int option_len = strlen(option); + if (option_len >= MAX_OPTION_LEN) + Error(ERR_EXIT_HELP, "unrecognized option '%s'", option); + strcpy(option_str, option); /* copy argument into buffer */ option = option_str; if (strcmp(option, "--") == 0) /* stop scanning arguments */ break; - if (option_len >= MAX_OPTION_LEN) - Error(ERR_EXIT_HELP, "unrecognized option '%s'", option); - if (strncmp(option, "--", 2) == 0) /* treat '--' like '-' */ option++; @@ -242,6 +368,7 @@ void GetOptions(char *argv[]) printf("Usage: %s [options] [server.name [port]]\n" "Options:\n" " -d, --display machine:0 X server display\n" + " -b, --basepath directory alternative base directory\n" " -l, --levels directory alternative level directory\n" " -s, --serveronly only start network server\n" " -n, --network network multiplayer game\n" @@ -257,53 +384,54 @@ void GetOptions(char *argv[]) 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); + + options.base_directory = option_arg; + if (option_arg == next_option) + options_left++; - printf("--display == '%s'\n", options.display_name); + /* adjust path for level directory accordingly */ + options.level_directory = + getPath2(options.base_directory, LEVELS_DIRECTORY); } else if (strncmp(option, "-levels", option_len) == 0) { if (option_arg == NULL) Error(ERR_EXIT_HELP, "option '%s' requires an argument", option_str); - level_directory = option_arg; + options.level_directory = option_arg; if (option_arg == next_option) options_left++; - - printf("--levels == '%s'\n", level_directory); } else if (strncmp(option, "-network", option_len) == 0) { - printf("--network\n"); - options.network = TRUE; } else if (strncmp(option, "-serveronly", option_len) == 0) { - printf("--serveronly\n"); - options.serveronly = TRUE; } else if (strncmp(option, "-verbose", option_len) == 0) { - printf("--verbose\n"); - options.verbose = TRUE; } else if (*option == '-') + { Error(ERR_EXIT_HELP, "unrecognized option '%s'", option_str); + } else if (options.server_host == NULL) { options.server_host = *options_left; - - printf("server.name == '%s'\n", options.server_host); } else if (options.server_port == 0) { options.server_port = atoi(*options_left); if (options.server_port < 1024) Error(ERR_EXIT_HELP, "bad port number '%d'", options.server_port); - - printf("port == %d\n", options.server_port); } else Error(ERR_EXIT_HELP, "too many arguments"); @@ -312,71 +440,58 @@ void GetOptions(char *argv[]) } } -void Error(int mode, char *format_str, ...) +void Error(int mode, char *format, ...) { - FILE *output_stream = stderr; char *process_name = ""; + FILE *error = stderr; - if (mode == ERR_EXIT_SOUNDSERVER) +#ifdef MSDOS + if ((error = openErrorFile()) == NULL) + { + printf("Cannot write to error output file!\n"); + CloseAllAndExit(1); + } +#endif + + if (mode & ERR_SOUND_SERVER) process_name = " sound server"; + else if (mode & ERR_NETWORK_SERVER) + process_name = " network server"; + else if (mode & ERR_NETWORK_CLIENT) + process_name = " network client **"; - if (format_str) + if (format) { va_list ap; - char *format_ptr; - char *s_value; - int i_value; - double d_value; - fprintf(output_stream, "%s%s: ", program_name, process_name); + fprintf(error, "%s%s: ", program_name, process_name); - va_start(ap, format_str); /* ap points to first unnamed argument */ - - for(format_ptr=format_str; *format_ptr; format_ptr++) - { - if (*format_ptr != '%') - { - fprintf(output_stream, "%c", *format_ptr); - continue; - } - - switch(*++format_ptr) - { - case 'd': - i_value = va_arg(ap, int); - fprintf(output_stream, "%d", i_value); - break; - - case 'f': - d_value = va_arg(ap, double); - fprintf(output_stream, "%f", d_value); - break; - - case 's': - s_value = va_arg(ap, char *); - fprintf(output_stream, "%s", s_value); - break; - - default: - fprintf(stderr, "\n%s: Error(): invalid format string: %s\n", - program_name, format_str); - CloseAllAndExit(10); - } - } + if (mode & ERR_WARN) + fprintf(error, "warning: "); + va_start(ap, format); + vfprintf(error, format, ap); va_end(ap); - fprintf(output_stream, "\n"); + fprintf(error, "\n"); } - if (mode == ERR_EXIT_HELP) - fprintf(output_stream, "%s: Try option '--help' for more information.\n", + if (mode & ERR_HELP) + fprintf(error, "%s: Try option '--help' for more information.\n", program_name); - if (mode != ERR_RETURN) + if (mode & ERR_EXIT) + fprintf(error, "%s%s: aborting\n", program_name, process_name); + + if (error != stderr) + fclose(error); + + if (mode & ERR_EXIT) { - fprintf(output_stream, "%s%s: aborting\n", program_name, process_name); - CloseAllAndExit(1); + if (mode & ERR_FROM_SERVER) + exit(1); /* child process: normal exit */ + else + CloseAllAndExit(1); /* main process: clean up stuff */ } } @@ -392,118 +507,390 @@ void *checked_malloc(unsigned long size) return ptr; } -char *getKeySymName(KeySym key) +void *checked_calloc(unsigned long size) +{ + void *ptr; + + ptr = calloc(1, size); + + if (ptr == NULL) + Error(ERR_EXIT, "cannot allocate %d bytes -- out of memory", size); + + return ptr; +} + +#define TRANSLATE_KEYSYM_TO_KEYNAME 0 +#define TRANSLATE_KEYSYM_TO_X11KEYNAME 1 +#define TRANSLATE_X11KEYNAME_TO_KEYSYM 2 + +void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode) { - static char key_name[20]; static struct { KeySym keysym; + char *x11name; char *name; - } translate[] = + } translate_key[] = { /* normal cursor keys */ - { XK_Left, "cursor left" }, - { XK_Right, "cursor right" }, - { XK_Up, "cursor up" }, - { XK_Down, "cursor down" }, + { XK_Left, "XK_Left", "cursor left" }, + { XK_Right, "XK_Right", "cursor right" }, + { XK_Up, "XK_Up", "cursor up" }, + { XK_Down, "XK_Down", "cursor down" }, /* keypad cursor keys */ #ifdef XK_KP_Left - { XK_KP_Left, "keypad left" }, - { XK_KP_Right, "keypad right" }, - { XK_KP_Up, "keypad up" }, - { XK_KP_Down, "keypad down" }, + { XK_KP_Left, "XK_KP_Left", "keypad left" }, + { XK_KP_Right, "XK_KP_Right", "keypad right" }, + { XK_KP_Up, "XK_KP_Up", "keypad up" }, + { XK_KP_Down, "XK_KP_Down", "keypad down" }, #endif /* other keypad keys */ #ifdef XK_KP_Enter - { XK_KP_Enter, "keypad enter" }, - { XK_KP_Add, "keypad +" }, - { XK_KP_Subtract, "keypad -" }, - { XK_KP_Multiply, "keypad mltply" }, - { XK_KP_Divide, "keypad /" }, - { XK_KP_Separator, "keypad ," }, + { XK_KP_Enter, "XK_KP_Enter", "keypad enter" }, + { XK_KP_Add, "XK_KP_Add", "keypad +" }, + { XK_KP_Subtract, "XK_KP_Subtract", "keypad -" }, + { XK_KP_Multiply, "XK_KP_Multiply", "keypad mltply" }, + { XK_KP_Divide, "XK_KP_Divide", "keypad /" }, + { XK_KP_Separator, "XK_KP_Separator", "keypad ," }, #endif /* modifier keys */ - { XK_Shift_L, "left shift" }, - { XK_Shift_R, "right shift" }, - { XK_Control_L, "left control" }, - { XK_Control_R, "right control" }, - { XK_Meta_L, "left meta" }, - { XK_Meta_R, "right meta" }, - { XK_Alt_L, "left alt" }, - { XK_Alt_R, "right alt" }, - { XK_Mode_switch, "mode switch" }, - { XK_Multi_key, "multi key" }, + { XK_Shift_L, "XK_Shift_L", "left shift" }, + { XK_Shift_R, "XK_Shift_R", "right shift" }, + { XK_Control_L, "XK_Control_L", "left control" }, + { XK_Control_R, "XK_Control_R", "right control" }, + { XK_Meta_L, "XK_Meta_L", "left meta" }, + { XK_Meta_R, "XK_Meta_R", "right meta" }, + { XK_Alt_L, "XK_Alt_L", "left alt" }, + { XK_Alt_R, "XK_Alt_R", "right alt" }, + { XK_Mode_switch, "XK_Mode_switch", "mode switch" }, + { XK_Multi_key, "XK_Multi_key", "multi key" }, /* some special keys */ - { XK_BackSpace, "backspace" }, - { XK_Delete, "delete" }, - { XK_Insert, "insert" }, - { XK_Tab, "tab" }, - { XK_Home, "home" }, - { XK_End, "end" }, - { XK_Page_Up, "page up" }, - { XK_Page_Down, "page down" }, - { XK_space, "space" }, + { XK_BackSpace, "XK_BackSpace", "backspace" }, + { XK_Delete, "XK_Delete", "delete" }, + { XK_Insert, "XK_Insert", "insert" }, + { XK_Tab, "XK_Tab", "tab" }, + { XK_Home, "XK_Home", "home" }, + { XK_End, "XK_End", "end" }, + { XK_Page_Up, "XK_Page_Up", "page up" }, + { XK_Page_Down, "XK_Page_Down", "page down" }, + { XK_space, "XK_space", "space" }, /* even more special keys */ - { XK_adiaeresis, "ä" }, - { XK_odiaeresis, "ö" }, - { XK_udiaeresis, "ü" }, - { XK_apostrophe, "'" }, - { XK_plus, "+" }, - { XK_minus, "-" }, - { XK_comma, "," }, - { XK_period, "." }, - { XK_numbersign, "#" }, - { XK_less, "less" }, - { XK_greater, "greater" }, - { XK_asciicircum, "circumflex" }, - { XK_ssharp, "sharp s" }, + { XK_adiaeresis, "XK_adiaeresis", "ä" }, + { XK_odiaeresis, "XK_odiaeresis", "ö" }, + { XK_udiaeresis, "XK_udiaeresis", "ü" }, + { XK_apostrophe, "XK_apostrophe", "'" }, + { XK_plus, "XK_plus", "+" }, + { XK_minus, "XK_minus", "-" }, + { XK_equal, "XK_equal", "equal" }, + { XK_comma, "XK_comma", "," }, + { XK_period, "XK_period", "." }, + { XK_colon, "XK_colon", ";" }, + { XK_slash, "XK_slash", "/" }, + { XK_numbersign, "XK_numbersign", "#" }, + { XK_backslash, "XK_backslash", "backslash" }, + { XK_braceleft, "XK_braceleft", "brace left" }, + { XK_braceright, "XK_braceright", "brace right" }, + { XK_less, "XK_less", "less" }, + { XK_greater, "XK_greater", "greater" }, + { XK_asciicircum, "XK_asciicircum", "circumflex" }, + { XK_ssharp, "XK_ssharp", "sharp s" }, /* end-of-array identifier */ - { 0, NULL } + { 0, NULL, NULL } }; - if (key >= XK_A && key <= XK_Z) + int i; + + if (mode == TRANSLATE_KEYSYM_TO_KEYNAME) { - sprintf(key_name, "%c", 'A' + (char)(key - XK_A)); - return key_name; + static char name_buffer[30]; + KeySym key = *keysym; + + if (key >= XK_A && key <= XK_Z) + sprintf(name_buffer, "%c", 'A' + (char)(key - XK_A)); + else if (key >= XK_a && key <= XK_z) + sprintf(name_buffer, "%c", 'a' + (char)(key - XK_a)); + else if (key >= XK_0 && key <= XK_9) + sprintf(name_buffer, "%c", '0' + (char)(key - XK_0)); + else if (key >= XK_KP_0 && key <= XK_KP_9) + sprintf(name_buffer, "keypad %c", '0' + (char)(key - XK_KP_0)); + else if (key >= XK_F1 && key <= XK_F24) + sprintf(name_buffer, "function F%d", (int)(key - XK_F1 + 1)); + else if (key == KEY_UNDEFINDED) + strcpy(name_buffer, "(undefined)"); + else + { + i = 0; + + do + { + if (key == translate_key[i].keysym) + { + strcpy(name_buffer, translate_key[i].name); + break; + } + } + while (translate_key[++i].name); + + if (!translate_key[i].name) + strcpy(name_buffer, "(unknown)"); + } + + *name = name_buffer; } - else if (key >= XK_a && key <= XK_z) + else if (mode == TRANSLATE_KEYSYM_TO_X11KEYNAME) { - sprintf(key_name, "%c", 'a' + (char)(key - XK_a)); - return key_name; + static char name_buffer[30]; + KeySym key = *keysym; + + if (key >= XK_A && key <= XK_Z) + sprintf(name_buffer, "XK_%c", 'A' + (char)(key - XK_A)); + else if (key >= XK_a && key <= XK_z) + sprintf(name_buffer, "XK_%c", 'a' + (char)(key - XK_a)); + else if (key >= XK_0 && key <= XK_9) + sprintf(name_buffer, "XK_%c", '0' + (char)(key - XK_0)); + else if (key >= XK_KP_0 && key <= XK_KP_9) + sprintf(name_buffer, "XK_KP_%c", '0' + (char)(key - XK_KP_0)); + else if (key >= XK_F1 && key <= XK_F24) + sprintf(name_buffer, "XK_F%d", (int)(key - XK_F1 + 1)); + else if (key == KEY_UNDEFINDED) + strcpy(name_buffer, "[undefined]"); + else + { + i = 0; + + do + { + if (key == translate_key[i].keysym) + { + strcpy(name_buffer, translate_key[i].x11name); + break; + } + } + while (translate_key[++i].x11name); + + if (!translate_key[i].x11name) + sprintf(name_buffer, "0x%04lx", (unsigned long)key); + } + + *x11name = name_buffer; } - else if (key >= XK_0 && key <= XK_9) + else if (mode == TRANSLATE_X11KEYNAME_TO_KEYSYM) { - sprintf(key_name, "%c", '0' + (char)(key - XK_0)); - return key_name; + KeySym key = XK_VoidSymbol; + char *name_ptr = *x11name; + + if (strncmp(name_ptr, "XK_", 3) == 0 && strlen(name_ptr) == 4) + { + char c = name_ptr[3]; + + if (c >= 'A' && c <= 'Z') + key = XK_A + (KeySym)(c - 'A'); + else if (c >= 'a' && c <= 'z') + key = XK_a + (KeySym)(c - 'a'); + else if (c >= '0' && c <= '9') + key = XK_0 + (KeySym)(c - '0'); + } + else if (strncmp(name_ptr, "XK_KP_", 6) == 0 && strlen(name_ptr) == 7) + { + char c = name_ptr[6]; + + if (c >= '0' && c <= '9') + key = XK_0 + (KeySym)(c - '0'); + } + else if (strncmp(name_ptr, "XK_F", 4) == 0 && strlen(name_ptr) <= 6) + { + char c1 = name_ptr[4]; + char c2 = name_ptr[5]; + int d = 0; + + if ((c1 >= '0' && c1 <= '9') && + ((c2 >= '0' && c1 <= '9') || c2 == '\0')) + d = atoi(&name_ptr[4]); + + if (d >=1 && d <= 24) + key = XK_F1 + (KeySym)(d - 1); + } + else if (strncmp(name_ptr, "XK_", 3) == 0) + { + i = 0; + + do + { + if (strcmp(name_ptr, translate_key[i].x11name) == 0) + { + key = translate_key[i].keysym; + break; + } + } + while (translate_key[++i].x11name); + } + else if (strncmp(name_ptr, "0x", 2) == 0) + { + unsigned long value = 0; + + name_ptr += 2; + + while (name_ptr) + { + char c = *name_ptr++; + int d = -1; + + if (c >= '0' && c <= '9') + d = (int)(c - '0'); + else if (c >= 'a' && c <= 'f') + d = (int)(c - 'a' + 10); + else if (c >= 'A' && c <= 'F') + d = (int)(c - 'A' + 10); + + if (d == -1) + { + value = -1; + break; + } + + value = value * 16 + d; + } + + if (value != -1) + key = (KeySym)value; + } + + *keysym = key; } - else if (key >= XK_KP_0 && key <= XK_KP_9) +} + +char *getKeyNameFromKeySym(KeySym keysym) +{ + char *name; + + translate_keyname(&keysym, NULL, &name, TRANSLATE_KEYSYM_TO_KEYNAME); + return name; +} + +char *getX11KeyNameFromKeySym(KeySym keysym) +{ + char *x11name; + + translate_keyname(&keysym, &x11name, NULL, TRANSLATE_KEYSYM_TO_X11KEYNAME); + return x11name; +} + +KeySym getKeySymFromX11KeyName(char *x11name) +{ + KeySym keysym; + + translate_keyname(&keysym, &x11name, NULL, TRANSLATE_X11KEYNAME_TO_KEYSYM); + return keysym; +} + +#define TRANSLATE_JOYSYMBOL_TO_JOYNAME 0 +#define TRANSLATE_JOYNAME_TO_JOYSYMBOL 1 + +void translate_joyname(int *joysymbol, char **name, int mode) +{ + static struct { - sprintf(key_name, "keypad %c", '0' + (char)(key - XK_KP_0)); - return key_name; - } - else if (key >= XK_F1 && key <= XK_F24) + int joysymbol; + char *name; + } translate_joy[] = { - sprintf(key_name, "function F%d", (int)(key - XK_F1 + 1)); - return key_name; - } - else + { JOY_LEFT, "joystick_left" }, + { JOY_RIGHT, "joystick_right" }, + { JOY_UP, "joystick_up" }, + { JOY_DOWN, "joystick_down" }, + { JOY_BUTTON_1, "joystick_button_1" }, + { JOY_BUTTON_2, "joystick_button_2" }, + }; + + int i; + + if (mode == TRANSLATE_JOYSYMBOL_TO_JOYNAME) { - int i = 0; + *name = "[undefined]"; - do + for (i=0; i<6; i++) { - if (key == translate[i].keysym) - return translate[i].name; + if (*joysymbol == translate_joy[i].joysymbol) + { + *name = translate_joy[i].name; + break; + } } - while (translate[++i].name); + } + else if (mode == TRANSLATE_JOYNAME_TO_JOYSYMBOL) + { + *joysymbol = 0; - sprintf(key_name, "(unknown)"); - return key_name; + for (i=0; i<6; i++) + { + if (strcmp(*name, translate_joy[i].name) == 0) + { + *joysymbol = translate_joy[i].joysymbol; + break; + } + } } } + +char *getJoyNameFromJoySymbol(int joysymbol) +{ + char *name; + + translate_joyname(&joysymbol, &name, TRANSLATE_JOYSYMBOL_TO_JOYNAME); + return name; +} + +int getJoySymbolFromJoyName(char *name) +{ + int joysymbol; + + translate_joyname(&joysymbol, &name, TRANSLATE_JOYNAME_TO_JOYSYMBOL); + return joysymbol; +} + +int getJoystickNrFromDeviceName(char *device_name) +{ + char c; + int joystick_nr = 0; + + if (device_name == NULL || device_name[0] == '\0') + return 0; + + c = device_name[strlen(device_name) - 1]; + + if (c >= '0' && c <= '9') + joystick_nr = (int)(c - '0'); + + if (joystick_nr < 0 || joystick_nr >= MAX_PLAYERS) + joystick_nr = 0; + + return joystick_nr; +} + +/* ----------------------------------------------------------------- */ +/* the following is only for debugging purpose and normally not used */ +/* ----------------------------------------------------------------- */ + +#define DEBUG_NUM_TIMESTAMPS 3 + +void debug_print_timestamp(int counter_nr, char *message) +{ + static long counter[DEBUG_NUM_TIMESTAMPS][2]; + + if (counter_nr >= DEBUG_NUM_TIMESTAMPS) + Error(ERR_EXIT, "debugging: increase DEBUG_NUM_TIMESTAMPS in misc.c"); + + counter[counter_nr][0] = Counter(); + + if (message) + printf("%s %.2f seconds\n", message, + (float)(counter[counter_nr][0] - counter[counter_nr][1]) / 1000); + + counter[counter_nr][1] = Counter(); +}