X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fmisc.c;h=c4c0352db9007474e321a03a14b7d68cb8ce1709;hb=29014045f4de045f8452fdf7ab32622c94b37eef;hp=61683e6c9564c14ef8fa0fce45133b9cc4ffceac;hpb=a5a03e15b395ba1942c180d1cd0d3a4f43b87f56;p=rocksndiamonds.git

diff --git a/src/misc.c b/src/misc.c
index 61683e6c..c4c0352d 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -1,126 +1,129 @@
 /***********************************************************
 *  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 <pwd.h>
 #include <unistd.h>
 #include <time.h>
 #include <sys/time.h>
 #include <sys/param.h>
 #include <sys/types.h>
+#include <stdarg.h>
 
-void microsleep(unsigned long usec)
-{
-  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(&current_time, NULL);
 
-  gettimeofday(&current_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;
 
-  if (mode == READ_COUNTER_100)
-    return(counter_ms/10);	/* return 1/100 secs since last init */
-  else	/*    READ_COUNTER_1000 */
-    return(counter_ms);		/* return 1/1000 secs since last init */
+  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()	/* returns 1/100 secs since last call of InitCounter() */
+unsigned long Counter()	/* get milliseconds since last call of InitCounter() */
 {
-  return(mainCounter(READ_COUNTER_100));
+  return(mainCounter(READ_COUNTER));
 }
 
-long Counter2()	/* returns 1/1000 secs since last call of InitCounter() */
+static void sleep_milliseconds(unsigned long milliseconds_delay)
 {
-  return(mainCounter(READ_COUNTER_1000));
-}
+  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 */
 
-void WaitCounter(long value) 	/* wait for counter to reach value */
-{
-  long wait;
+    unsigned long base_counter = Counter(), actual_counter = Counter();
 
-  while((wait=value-Counter())>0)
-    microsleep(wait*10000);
-}
+    while (actual_counter < base_counter + milliseconds_delay &&
+	   actual_counter >= base_counter)
+      actual_counter = Counter();
+  }
+  else
+  {
+    struct timeval delay;
 
-void WaitCounter2(long value) 	/* wait for counter to reach value */
-{
-  long wait;
+    delay.tv_sec  = milliseconds_delay / 1000;
+    delay.tv_usec = 1000 * (milliseconds_delay % 1000);
 
-  while((wait=value-Counter2())>0)
-    microsleep(wait*1000);
+    if (select(0, NULL, NULL, NULL, &delay) != 0)
+      Error(ERR_RETURN, "sleep_milliseconds(): select() failed");
+  }
 }
 
-void Delay(long value)
+void Delay(unsigned long delay)	/* Sleep specified number of milliseconds */
 {
-  microsleep(value);
+  sleep_milliseconds(delay);
 }
 
-BOOL DelayReached(long *counter_var, int delay)
+BOOL 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)
+BOOL DelayReached(unsigned long *counter_var, unsigned long delay)
 {
-  long actual_frame_counter = FrameCounter;
+  unsigned long actual_counter = Counter();
 
-  if (actual_frame_counter >= *frame_counter_var+frame_delay
-      || actual_frame_counter < *frame_counter_var)
-  {
-    *frame_counter_var = actual_frame_counter;
-    return(TRUE);
-  }
-  else
+  if (actual_counter < *counter_var + delay &&
+      actual_counter >= *counter_var)
     return(FALSE);
+
+  *counter_var = actual_counter;
+  return(TRUE);
 }
 
-unsigned long be2long(unsigned long *be)	/* big-endian -> longword */
+void WaitUntilDelayReached(unsigned long *counter_var, unsigned long delay)
 {
-  unsigned char *ptr = (unsigned char *)be;
+  unsigned long actual_counter;
+
+  while(1)
+  {
+    actual_counter = Counter();
+
+    if (actual_counter < *counter_var + delay &&
+	actual_counter >= *counter_var)
+      sleep_milliseconds((*counter_var + delay - actual_counter) / 2);
+    else
+      break;
+  }
 
-  return(ptr[0]<<24 | ptr[1]<<16 | ptr[2]<<8 | ptr[3]);
+  *counter_var = actual_counter;
 }
 
 char *int2str(int ct, int nr)
@@ -143,7 +146,7 @@ unsigned int SimpleRND(unsigned int max)
 
 unsigned int RND(unsigned int max)
 {
-  return(rand() % max);
+  return(random_linux_libc() % max);
 }
 
 unsigned int InitRND(long seed)
@@ -153,12 +156,12 @@ unsigned int InitRND(long seed)
   if (seed==NEW_RANDOMIZE)
   {
     gettimeofday(&current_time,NULL);
-    srand((unsigned int) current_time.tv_usec);
+    srandom_linux_libc((unsigned int) current_time.tv_usec);
     return((unsigned int) current_time.tv_usec);
   }
   else
   {
-    srand((unsigned int) seed);
+    srandom_linux_libc((unsigned int) seed);
     return((unsigned int) seed);
   }
 }
@@ -173,328 +176,71 @@ char *GetLoginName()
     return(pwd->pw_name);
 }
 
-void InitAnimation()
-{
-  HandleAnimation(ANIM_START);
-}
-
-void StopAnimation()
-{
-  HandleAnimation(ANIM_STOP);
-}
-
-void DoAnimation()
-{
-  HandleAnimation(ANIM_CONTINUE);
-}
-
-void HandleAnimation(int mode)
+void MarkTileDirty(int x, int y)
 {
-  static long animstart_delay = -1;
-  static long animstart_delay_value = 0;
-  static BOOL anim_restart = TRUE;
-  static BOOL reset_delay = TRUE;
-  static int toon_nr = 0;
-  int draw_mode;
-
-/*
-  if (!toons_on || game_status==PLAYING)
-    return;
-*/
-
-/*
-  if (!toons_on || tape.playing || tape.recording)
-    return;
-*/
-
-  if (!toons_on)
-    return;
-
-  switch(mode)
-  {
-    case ANIM_START:
-      anim_restart = TRUE;
-      reset_delay = TRUE;
-
-      /* Fill empty backbuffer for animation functions */
-      if (direct_draw_on && game_status==PLAYING)
-      {
-	int xx,yy;
-
-	drawto_field = backbuffer;
-
-	for(xx=0;xx<SCR_FIELDX;xx++)
-	  for(yy=0;yy<SCR_FIELDY;yy++)
-	    DrawScreenField(xx,yy);
-	DrawLevelElement(JX,JY,EL_SPIELFIGUR);
-
-	drawto_field = window;
-      }
-
-      return;
-      break;
-    case ANIM_CONTINUE:
-      break;
-    case ANIM_STOP:
-      redraw_mask |= REDRAW_FIELD;
-
-      /* Redraw background even when in direct drawing mode */
-      draw_mode = direct_draw_on;
-      direct_draw_on = FALSE;
-
-      BackToFront();
-
-      direct_draw_on = draw_mode;
+  int xx = redraw_x1 + x;
+  int yy = redraw_y1 + y;
 
-      return;
-      break;
-    default:
-      break;
-  }
-
-  if (reset_delay)
+  if (!redraw[xx][yy])
   {
-    animstart_delay = Counter();
-    animstart_delay_value = SimpleRND(500);
-    reset_delay = FALSE;
+    redraw[xx][yy] = TRUE;
+    redraw_tiles++;
+    redraw_mask |= REDRAW_TILES;
   }
+}
 
-  if (anim_restart)
-  {
-    if (!DelayReached(&animstart_delay,animstart_delay_value))
-      return;
+void Error(BOOL fatal_error, char *format_str, ...)
+{
+  FILE *output_stream = stderr;
+  va_list ap;
+  char *format_ptr;
+  char *s_value;
+  int i_value;
+  double d_value;
 
-    toon_nr = SimpleRND(NUM_TOONS);
-  }
+  va_start(ap, format_str);	/* ap points to first unnamed argument */
 
-  anim_restart = reset_delay = AnimateToon(toon_nr,anim_restart);
-}
+  fprintf(output_stream, "%s: ", program_name);
 
-BOOL AnimateToon(int toon_nr, BOOL restart)
-{
-  static pos_x = 0, pos_y = 0;
-  static delta_x = 0, delta_y = 0;
-  static int frame = 0, frame_step = 1;
-  static BOOL horiz_move, vert_move;
-  static long anim_delay = 0;
-  static int anim_delay_value = 0;
-  static int width,height;
-  static int pad_x,pad_y;
-  static int cut_x,cut_y;
-  static int src_x, src_y;
-  static int dest_x, dest_y;
-  static struct AnimInfo toon[NUM_TOONS] =
-  {
-   {DWARF_XSIZE, DWARF_YSIZE,
-    DWARF_X, DWARF_Y,
-    DWARF_FRAMES,
-    DWARF_FPS,
-    DWARF_STEPSIZE,
-    FALSE,
-    ANIMDIR_RIGHT,
-    ANIMPOS_DOWN},
-
-   {DWARF_XSIZE, DWARF_YSIZE,
-    DWARF_X, DWARF2_Y,
-    DWARF_FRAMES,
-    DWARF_FPS,
-    DWARF_STEPSIZE,
-    FALSE,
-    ANIMDIR_LEFT,
-    ANIMPOS_DOWN},
-
-   {JUMPER_XSIZE, JUMPER_YSIZE,
-    JUMPER_X, JUMPER_Y,
-    JUMPER_FRAMES,
-    JUMPER_FPS,
-    JUMPER_STEPSIZE,
-    FALSE,
-    ANIMDIR_LEFT,
-    ANIMPOS_DOWN},
-
-   {CLOWN_XSIZE, CLOWN_YSIZE,
-    CLOWN_X, CLOWN_Y,
-    CLOWN_FRAMES,
-    CLOWN_FPS,
-    CLOWN_STEPSIZE,
-    FALSE,
-    ANIMDIR_UP,
-    ANIMPOS_ANY},
-
-   {BIRD_XSIZE, BIRD_YSIZE,
-    BIRD1_X, BIRD1_Y,
-    BIRD_FRAMES,
-    BIRD_FPS,
-    BIRD_STEPSIZE,
-    TRUE,
-    ANIMDIR_RIGHT,
-    ANIMPOS_UPPER},
-
-   {BIRD_XSIZE, BIRD_YSIZE,
-    BIRD2_X, BIRD2_Y,
-    BIRD_FRAMES,
-    BIRD_FPS,
-    BIRD_STEPSIZE,
-    TRUE,
-    ANIMDIR_LEFT,
-    ANIMPOS_UPPER}
-  };
-  struct AnimInfo *anim = &toon[toon_nr];
-
-  if (restart)
+  for(format_ptr=format_str; *format_ptr; format_ptr++)
   {
-    horiz_move = (anim->direction & (ANIMDIR_LEFT | ANIMDIR_RIGHT));
-    vert_move = (anim->direction & (ANIMDIR_UP | ANIMDIR_DOWN));
-    anim_delay_value = 100/anim->frames_per_second;
-    frame = 0;
-
-    if (horiz_move)
+    if (*format_ptr != '%')
     {
-      if (anim->position==ANIMPOS_UP)
-	pos_y = 0;
-      else if (anim->position==ANIMPOS_DOWN)
-	pos_y = FULL_SYSIZE-anim->height;
-      else if (anim->position==ANIMPOS_UPPER)
-	pos_y = SimpleRND((FULL_SYSIZE-anim->height)/2);
-      else
-	pos_y = SimpleRND(FULL_SYSIZE-anim->height);
-
-      if (anim->direction==ANIMDIR_RIGHT)
-      {
-	delta_x = anim->stepsize;
-	pos_x = -anim->width+delta_x;
-      }
-      else
-      {
-	delta_x = -anim->stepsize;
-	pos_x = FULL_SXSIZE+delta_x;
-      }
-      delta_y = 0;
+      fprintf(output_stream, "%c", *format_ptr);
+      continue;
     }
-    else
+
+    switch(*++format_ptr)
     {
-      if (anim->position==ANIMPOS_LEFT)
-	pos_x = 0;
-      else if (anim->position==ANIMPOS_RIGHT)
-	pos_x = FULL_SXSIZE-anim->width;
-      else
-	pos_x = SimpleRND(FULL_SXSIZE-anim->width);
-
-      if (anim->direction==ANIMDIR_DOWN)
-      {
-	delta_y = anim->stepsize;
-	pos_y = -anim->height+delta_y;
-      }
-      else
-      {
-	delta_y = -anim->stepsize;
-	pos_y = FULL_SYSIZE+delta_y;
-      }
-      delta_x = 0;
+      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, "\nfatal(): invalid format string: %s\n", format_str);
+	exit(-1);
     }
   }
 
-  if (pos_x <= -anim->width  - anim->stepsize ||
-      pos_x >=  FULL_SXSIZE  + anim->stepsize ||
-      pos_y <= -anim->height - anim->stepsize ||
-      pos_y >=  FULL_SYSIZE  + anim->stepsize)
-    return(TRUE);
-
-  if (!DelayReached(&anim_delay,anim_delay_value))
-  {
-    if (game_status==HELPSCREEN && !restart)
-      DrawAnim(src_x+cut_x,src_y+cut_y, width,height,
-	       REAL_SX+dest_x,REAL_SY+dest_y, pad_x,pad_y);
-
-    return(FALSE);
-  }
-
-  if (pos_x<-anim->width)
-    pos_x = -anim->width;
-  else if (pos_x>FULL_SXSIZE)
-    pos_x = FULL_SXSIZE;
-  if (pos_y<-anim->height)
-    pos_y = -anim->height;
-  else if (pos_y>FULL_SYSIZE)
-    pos_y = FULL_SYSIZE;
-
-  pad_x = (horiz_move ? anim->stepsize : 0);
-  pad_y = (vert_move  ? anim->stepsize : 0);
-  src_x = anim->src_x + frame * anim->width;
-  src_y = anim->src_y;
-  dest_x = pos_x;
-  dest_y = pos_y;
-  cut_x = cut_y = 0;
-  width  = anim->width;
-  height = anim->height;
-
-  if (pos_x<0)
-  {
-    dest_x = 0;
-    width += pos_x;
-    cut_x = -pos_x;
-  }
-  else if (pos_x>FULL_SXSIZE-anim->width)
-    width -= (pos_x - (FULL_SXSIZE-anim->width));
-
-  if (pos_y<0)
-  {
-    dest_y = 0;
-    height += pos_y;
-    cut_y = -pos_y;
-  }
-  else if (pos_y>FULL_SYSIZE-anim->height)
-    height -= (pos_y - (FULL_SYSIZE-anim->height));
-
-  DrawAnim(src_x+cut_x,src_y+cut_y, width,height,
-	   REAL_SX+dest_x,REAL_SY+dest_y, pad_x,pad_y);
+  va_end(ap);
 
-  pos_x += delta_x;
-  pos_y += delta_y;
-  frame += frame_step;
+  fprintf(output_stream, "\n");
 
-  if (frame<0 || frame>=anim->frames)
+  if (fatal_error)
   {
-    if (anim->pingpong)
-    {
-      frame_step *= -1;
-      frame = (frame<0 ? 1 : anim->frames-2);
-    }
-    else
-      frame = (frame<0 ? anim->frames-1 : 0);
+    fprintf(output_stream, "%s: aborting\n", program_name);
+    CloseAll();
+    exit(1);
   }
-
-  return(FALSE);
-}
-
-void DrawAnim(int src_x, int src_y, int width, int height,
-	      int dest_x, int dest_y, int pad_x, int pad_y)
-{
-  int buf_x = DOOR_GFX_PAGEX3, buf_y = DOOR_GFX_PAGEY1;
-
-#if 1
-  /* special method to avoid flickering interference with BackToFront() */
-  XCopyArea(display,backbuffer,pix[PIX_DB_DOOR],gc,dest_x-pad_x,dest_y-pad_y,
-	    width+2*pad_x,height+2*pad_y, buf_x,buf_y);
-  XSetClipOrigin(display,clip_gc[PIX_TOONS],dest_x-src_x,dest_y-src_y);
-  XCopyArea(display,pix[PIX_TOONS],backbuffer,clip_gc[PIX_TOONS],
-	    src_x,src_y, width,height, dest_x,dest_y);
-  XCopyArea(display,backbuffer,window,gc, dest_x-pad_x,dest_y-pad_y,
-	    width+2*pad_x,height+2*pad_y, dest_x-pad_x,dest_y-pad_y);
-  BackToFront();
-  XCopyArea(display,pix[PIX_DB_DOOR],backbuffer,gc, buf_x,buf_y,
-	    width+2*pad_x,height+2*pad_y, dest_x-pad_x,dest_y-pad_y);
-#else
-  /* normal method, causing flickering interference with BackToFront() */
-  XCopyArea(display,backbuffer,pix[PIX_DB_DOOR],gc,dest_x-pad_x,dest_y-pad_y,
-	    width+2*pad_x,height+2*pad_y, buf_x,buf_y);
-  XSetClipOrigin(display,clip_gc[PIX_TOONS],
-		 buf_x-src_x+pad_x,buf_y-src_y+pad_y);
-  XCopyArea(display,pix[PIX_TOONS],pix[PIX_DB_DOOR],clip_gc[PIX_TOONS],
-	    src_x,src_y, width,height, buf_x+pad_x,buf_y+pad_y);
-  XCopyArea(display,pix[PIX_DB_DOOR],window,gc, buf_x,buf_y,
-	    width+2*pad_x,height+2*pad_y, dest_x-pad_x,dest_y-pad_y);
-#endif
-
-  XFlush(display);
 }