X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fmisc.c;h=be6894998d546e15e91b53c35eec06854848bf33;hb=a4d4e8e444b21b58dcc88b52ff22726c545142a4;hp=28d04a6d1b3844eb59994f17142859aa4905a3ff;hpb=1256664ceac31f448a0139edd3bd0dc8fa5a8697;p=rocksndiamonds.git diff --git a/src/misc.c b/src/misc.c index 28d04a6d..be689499 100644 --- a/src/misc.c +++ b/src/misc.c @@ -1,122 +1,131 @@ /*********************************************************** * Rocks'n'Diamonds -- McDuffin Strikes Back! * *----------------------------------------------------------* -* ©1995 Artsoft Development * -* Holger Schemel * -* 33659 Bielefeld-Senne * -* Telefon: (0521) 493245 * -* eMail: aeglos@valinor.owl.de * -* aeglos@uni-paderborn.de * -* q99492@pbhrzx.uni-paderborn.de * +* (c) 1995-98 Artsoft Entertainment * +* Holger Schemel * +* Oststrasse 11a * +* 33604 Bielefeld * +* phone: ++49 +521 290471 * +* email: aeglos@valinor.owl.de * *----------------------------------------------------------* * misc.c * ***********************************************************/ -#include "misc.h" -#include "tools.h" -#include "sound.h" -#include "random.h" - #include #include #include #include #include #include +#include -void microsleep(unsigned long usec) -{ - if (usec < 5000) - { - /* we want to wait less than 5 ms -- if we assume that we have a - kernel timer resolution of 10 ms, we would wait far to long; - therefore it's better to do a short interval of busy waiting - to get our sleeping time more accurate */ - - long base_counter = Counter(), actual_counter = Counter(); - long delay = usec/1000; - - while (actual_counter < base_counter+delay && - actual_counter >= base_counter) - actual_counter = Counter(); - } - else - { - struct timeval delay; - - delay.tv_sec = usec / 1000000; - delay.tv_usec = usec % 1000000; - - if (select(0,NULL,NULL,NULL,&delay) != 0) - fprintf(stderr,"%s: in function microsleep: select failed!\n", - progname); - } -} +#include "misc.h" +#include "init.h" +#include "tools.h" +#include "sound.h" +#include "random.h" -long mainCounter(int mode) +static unsigned long mainCounter(int mode) { static struct timeval base_time = { 0, 0 }; struct timeval current_time; - long counter_ms; + unsigned long counter_ms; + + gettimeofday(¤t_time, NULL); - gettimeofday(¤t_time,NULL); if (mode == INIT_COUNTER || current_time.tv_sec < base_time.tv_sec) base_time = current_time; - counter_ms = (current_time.tv_sec - base_time.tv_sec)*1000 - + (current_time.tv_usec - base_time.tv_usec)/1000; + counter_ms = (current_time.tv_sec - base_time.tv_sec) * 1000 + + (current_time.tv_usec - base_time.tv_usec) / 1000; return counter_ms; /* return milliseconds since last init */ } -void InitCounter() /* set counter back to zero */ +void InitCounter() /* set counter back to zero */ { mainCounter(INIT_COUNTER); } -long Counter() /* get milliseconds since last call of InitCounter() */ +unsigned long Counter() /* get milliseconds since last call of InitCounter() */ { return(mainCounter(READ_COUNTER)); } -void WaitCounter(long value) /* wait for counter to reach value */ +static void sleep_milliseconds(unsigned long milliseconds_delay) { - long wait; + if (milliseconds_delay < 5) + { + /* 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; + therefore it's better to do a short interval of busy waiting + to get our sleeping time more accurate */ - while((wait=value-Counter())>0) - microsleep(wait * 1000); + unsigned long base_counter = Counter(), actual_counter = Counter(); + + while (actual_counter < base_counter + milliseconds_delay && + actual_counter >= base_counter) + actual_counter = Counter(); + } + else + { + struct timeval delay; + + delay.tv_sec = milliseconds_delay / 1000; + delay.tv_usec = 1000 * (milliseconds_delay % 1000); + + if (select(0, NULL, NULL, NULL, &delay) != 0) + Error(ERR_RETURN, "sleep_milliseconds(): select() failed"); + } } -void Delay(long value) /* Delay 'value' milliseconds */ +void Delay(unsigned long delay) /* Sleep specified number of milliseconds */ { - microsleep(value * 1000); + sleep_milliseconds(delay); } -BOOL DelayReached(long *counter_var, int delay) +boolean FrameReached(unsigned long *frame_counter_var, + unsigned long frame_delay) { - long actual_counter = Counter(); + unsigned long actual_frame_counter = FrameCounter; - if (actual_counter >= *counter_var+delay || actual_counter < *counter_var) - { - *counter_var = actual_counter; - return(TRUE); - } - else + if (actual_frame_counter < *frame_counter_var+frame_delay && + actual_frame_counter >= *frame_counter_var) return(FALSE); + + *frame_counter_var = actual_frame_counter; + return(TRUE); } -BOOL FrameReached(long *frame_counter_var, int frame_delay) +boolean DelayReached(unsigned long *counter_var, + unsigned long delay) { - long actual_frame_counter = FrameCounter; + unsigned long actual_counter = Counter(); + + if (actual_counter < *counter_var + delay && + actual_counter >= *counter_var) + return(FALSE); - if (actual_frame_counter >= *frame_counter_var+frame_delay || - actual_frame_counter < *frame_counter_var) + *counter_var = actual_counter; + return(TRUE); +} + +void WaitUntilDelayReached(unsigned long *counter_var, unsigned long delay) +{ + unsigned long actual_counter; + + while(1) { - *frame_counter_var = actual_frame_counter; - return(TRUE); + actual_counter = Counter(); + + if (actual_counter < *counter_var + delay && + actual_counter >= *counter_var) + sleep_milliseconds((*counter_var + delay - actual_counter) / 2); + else + break; } - else - return(FALSE); + + *counter_var = actual_counter; } char *int2str(int ct, int nr) @@ -181,3 +190,320 @@ void MarkTileDirty(int x, int y) redraw_mask |= REDRAW_TILES; } } + +void GetOptions(char *argv[]) +{ + char **options_left = &argv[1]; + + /* initialize global program options */ + options.display_name = NULL; + options.server_host = NULL; + options.server_port = 0; + options.serveronly = FALSE; + options.network = FALSE; + options.verbose = FALSE; + + 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); + + 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++; + + 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 '=' */ + Error(ERR_EXIT_HELP, "option '%s' has invalid argument", option_str); + } + + option_len = strlen(option); + + if (strcmp(option, "-") == 0) + Error(ERR_EXIT_HELP, "unrecognized option '%s'", option); + else if (strncmp(option, "-help", option_len) == 0) + { + printf("Usage: %s [options] [server.name [port]]\n" + "Options:\n" + " -d, --display machine:0 X server display\n" + " -l, --levels directory alternative level directory\n" + " -s, --serveronly only start network server\n" + " -n, --network network multiplayer game\n" + " -v, --verbose verbose mode\n", + program_name); + 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++; + + printf("--display == '%s'\n", options.display_name); + } + 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; + 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"); + + options_left++; + } +} + +void Error(int mode, char *format_str, ...) +{ + FILE *output_stream = stderr; + char *process_name = ""; + + if (mode == ERR_EXIT_SOUNDSERVER) + process_name = " sound server"; + + if (format_str) + { + va_list ap; + char *format_ptr; + char *s_value; + int i_value; + double d_value; + + fprintf(output_stream, "%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); + } + } + + va_end(ap); + + fprintf(output_stream, "\n"); + } + + if (mode == ERR_EXIT_HELP) + fprintf(output_stream, "%s: Try option '--help' for more information.\n", + program_name); + + if (mode != ERR_RETURN) + { + fprintf(output_stream, "%s%s: aborting\n", program_name, process_name); + CloseAllAndExit(1); + } +} + +void *checked_malloc(unsigned long size) +{ + void *ptr; + + ptr = malloc(size); + + if (ptr == NULL) + Error(ERR_EXIT, "cannot allocate %d bytes -- out of memory", size); + + return ptr; +} + +char *getKeySymName(KeySym key) +{ + static char key_name[20]; + static struct + { + KeySym keysym; + char *name; + } translate[] = + { + /* normal cursor keys */ + { XK_Left, "cursor left" }, + { XK_Right, "cursor right" }, + { XK_Up, "cursor up" }, + { 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" }, +#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 ," }, +#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" }, + + /* 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" }, + + /* 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" }, + + /* end-of-array identifier */ + { 0, NULL } + }; + + if (key >= XK_A && key <= XK_Z) + { + sprintf(key_name, "%c", 'A' + (char)(key - XK_A)); + return key_name; + } + else if (key >= XK_a && key <= XK_z) + { + sprintf(key_name, "%c", 'a' + (char)(key - XK_a)); + return key_name; + } + else if (key >= XK_0 && key <= XK_9) + { + sprintf(key_name, "%c", '0' + (char)(key - XK_0)); + return key_name; + } + else if (key >= XK_KP_0 && key <= XK_KP_9) + { + sprintf(key_name, "keypad %c", '0' + (char)(key - XK_KP_0)); + return key_name; + } + else if (key >= XK_F1 && key <= XK_F24) + { + sprintf(key_name, "function F%d", (int)(key - XK_F1 + 1)); + return key_name; + } + else + { + int i = 0; + + do + { + if (key == translate[i].keysym) + return translate[i].name; + } + while (translate[++i].name); + + sprintf(key_name, "(unknown)"); + return key_name; + } +}