X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Flibgame%2Fsystem.c;h=680ff2d51ff568024693f9b53c4b4ab5536e3d42;hb=e4bf86b0ac3fd50612eee1439beba2fbaaa7cd09;hp=521e43f40bebd8a19b5e820fb0182de0cbb34dd9;hpb=e849e67ceff4a2f5d457dedee8f18de1646b9dc3;p=rocksndiamonds.git

diff --git a/src/libgame/system.c b/src/libgame/system.c
index 521e43f4..680ff2d5 100644
--- a/src/libgame/system.c
+++ b/src/libgame/system.c
@@ -1,7 +1,7 @@
 /***********************************************************
 * Artsoft Retro-Game Library                               *
 *----------------------------------------------------------*
-* (c) 1994-2001 Artsoft Entertainment                      *
+* (c) 1994-2002 Artsoft Entertainment                      *
 *               Holger Schemel                             *
 *               Detmolder Strasse 189                      *
 *               33604 Bielefeld                            *
@@ -66,10 +66,31 @@ int			FrameCounter = 0;
 /* init/close functions                                                      */
 /* ========================================================================= */
 
-void InitCommandName(char *argv0)
+void InitProgramInfo(char *argv0,
+		     char *userdata_directory, char *program_title,
+		     char *window_title, char *icon_title,
+		     char *x11_icon_filename, char *x11_iconmask_filename,
+		     char *msdos_pointer_filename,
+		     char *cookie_prefix, char *filename_prefix,
+		     int program_version)
 {
   program.command_basename =
     (strrchr(argv0, '/') ? strrchr(argv0, '/') + 1 : argv0);
+
+  program.userdata_directory = userdata_directory;
+  program.program_title = program_title;
+  program.window_title = window_title;
+  program.icon_title = icon_title;
+  program.x11_icon_filename = x11_icon_filename;
+  program.x11_iconmask_filename = x11_iconmask_filename;
+  program.msdos_pointer_filename = msdos_pointer_filename;
+
+  program.cookie_prefix = cookie_prefix;
+  program.filename_prefix = filename_prefix;
+
+  program.version_major = VERSION_MAJOR(program_version);
+  program.version_minor = VERSION_MINOR(program_version);
+  program.version_patch = VERSION_PATCH(program_version);
 }
 
 void InitExitFunction(void (*exit_function)(int))
@@ -90,10 +111,6 @@ void InitPlatformDependantStuff(void)
 {
 #if defined(PLATFORM_MSDOS)
   _fmode = O_BINARY;
-#endif
-
-#if !defined(PLATFORM_UNIX)
-  program.userdata_directory = "userdata";
   initErrorFile();
 #endif
 
@@ -105,42 +122,15 @@ void InitPlatformDependantStuff(void)
 
 void ClosePlatformDependantStuff(void)
 {
-#if !defined(PLATFORM_UNIX)
+#if defined(PLATFORM_MSDOS)
   dumpErrorFile();
 #endif
 }
 
-void InitProgramInfo(char *unix_userdata_directory, char *program_title,
-		     char *window_title, char *icon_title,
-		     char *x11_icon_filename, char *x11_iconmask_filename,
-		     char *msdos_pointer_filename,
-		     char *cookie_prefix, char *filename_prefix,
-		     int program_version)
-{
-#if defined(PLATFORM_UNIX)
-  program.userdata_directory = unix_userdata_directory;
-#else
-  program.userdata_directory = "userdata";
-#endif
-
-  program.program_title = program_title;
-  program.window_title = window_title;
-  program.icon_title = icon_title;
-  program.x11_icon_filename = x11_icon_filename;
-  program.x11_iconmask_filename = x11_iconmask_filename;
-  program.msdos_pointer_filename = msdos_pointer_filename;
-
-  program.cookie_prefix = cookie_prefix;
-  program.filename_prefix = filename_prefix;
-
-  program.version_major = VERSION_MAJOR(program_version);
-  program.version_minor = VERSION_MINOR(program_version);
-  program.version_patch = VERSION_PATCH(program_version);
-}
-
 void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize,
 		      int real_sx, int real_sy,
-		      int full_sxsize, int full_sysize)
+		      int full_sxsize, int full_sysize,
+		      Bitmap *field_save_buffer)
 {
   gfx.sx = sx;
   gfx.sy = sy;
@@ -151,7 +141,13 @@ void InitGfxFieldInfo(int sx, int sy, int sxsize, int sysize,
   gfx.full_sxsize = full_sxsize;
   gfx.full_sysize = full_sysize;
 
+  gfx.field_save_buffer = field_save_buffer;
+
+  gfx.background_bitmap = NULL;
+  gfx.background_bitmap_mask = REDRAW_NONE;
+
   SetDrawDeactivationMask(REDRAW_NONE);		/* do not deactivate drawing */
+  SetDrawBackgroundMask(REDRAW_NONE);		/* deactivate masked drawing */
 }
 
 void InitGfxDoor1Info(int dx, int dy, int dxsize, int dysize)
@@ -182,6 +178,90 @@ void SetDrawDeactivationMask(int draw_deactivation_mask)
   gfx.draw_deactivation_mask = draw_deactivation_mask;
 }
 
+void SetDrawBackgroundMask(int draw_background_mask)
+{
+  gfx.draw_background_mask = draw_background_mask;
+}
+
+static void DrawBitmapFromTile(Bitmap *bitmap, Bitmap *tile,
+			       int dest_x, int dest_y, int width, int height)
+{
+  int bitmap_xsize = width;
+  int bitmap_ysize = height;
+  int tile_xsize = tile->width;
+  int tile_ysize = tile->height;
+  int tile_xsteps = (bitmap_xsize + tile_xsize - 1) / tile_xsize;
+  int tile_ysteps = (bitmap_ysize + tile_ysize - 1) / tile_ysize;
+  int x, y;
+
+  for (y=0; y < tile_ysteps; y++)
+  {
+    for (x=0; x < tile_xsteps; x++)
+    {
+      int draw_x = dest_x + x * tile_xsize;
+      int draw_y = dest_y + y * tile_ysize;
+      int draw_xsize = MIN(tile_xsize, bitmap_xsize - x * tile_xsize);
+      int draw_ysize = MIN(tile_ysize, bitmap_ysize - y * tile_ysize);
+
+      BlitBitmap(tile, bitmap, 0, 0, draw_xsize, draw_ysize, draw_x, draw_y);
+    }
+  }
+}
+
+void SetBackgroundBitmap(Bitmap *background_bitmap_tile, int mask)
+{
+  static Bitmap *main_bitmap_tile = NULL;
+  static Bitmap *door_bitmap_tile = NULL;
+
+  if (mask == REDRAW_FIELD)
+  {
+    if (background_bitmap_tile == main_bitmap_tile)
+      return;		/* main background tile has not changed */
+
+    main_bitmap_tile = background_bitmap_tile;
+  }
+  else if (mask == REDRAW_DOOR_1)
+  {
+    if (background_bitmap_tile == door_bitmap_tile)
+      return;	/* main background tile has not changed */
+
+    door_bitmap_tile = background_bitmap_tile;
+  }
+  else		/* should not happen */
+    return;
+
+  if (background_bitmap_tile)
+    gfx.background_bitmap_mask |= mask;
+  else
+    gfx.background_bitmap_mask &= ~mask;
+
+  if (gfx.background_bitmap == NULL)
+    gfx.background_bitmap = CreateBitmap(video.width, video.height,
+					 DEFAULT_DEPTH);
+
+  if (background_bitmap_tile == NULL)	/* empty background requested */
+    return;
+
+  if (mask == REDRAW_FIELD)
+    DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
+		       gfx.real_sx, gfx.real_sy,
+		       gfx.full_sxsize, gfx.full_sysize);
+  else
+    DrawBitmapFromTile(gfx.background_bitmap, background_bitmap_tile,
+		       gfx.dx, gfx.dy,
+		       gfx.dxsize, gfx.dysize);
+}
+
+void SetMainBackgroundBitmap(Bitmap *background_bitmap_tile)
+{
+  SetBackgroundBitmap(background_bitmap_tile, REDRAW_FIELD);
+}
+
+void SetDoorBackgroundBitmap(Bitmap *background_bitmap_tile)
+{
+  SetBackgroundBitmap(background_bitmap_tile, REDRAW_DOOR_1);
+}
+
 
 /* ========================================================================= */
 /* video functions                                                           */
@@ -192,6 +272,29 @@ inline static int GetRealDepth(int depth)
   return (depth == DEFAULT_DEPTH ? video.default_depth : depth);
 }
 
+inline static void sysFillRectangle(Bitmap *bitmap, int x, int y,
+			       int width, int height, Pixel color)
+{
+#ifdef TARGET_SDL
+  SDLFillRectangle(bitmap, x, y, width, height, color);
+#else
+  X11FillRectangle(bitmap, x, y, width, height, color);
+#endif
+}
+
+inline static void sysCopyArea(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+			       int src_x, int src_y, int width, int height,
+			       int dst_x, int dst_y, int mask_mode)
+{
+#ifdef TARGET_SDL
+  SDLCopyArea(src_bitmap, dst_bitmap,
+	      src_x, src_y, width, height, dst_x, dst_y, mask_mode);
+#else
+  X11CopyArea(src_bitmap, dst_bitmap,
+	      src_x, src_y, width, height, dst_x, dst_y, mask_mode);
+#endif
+}
+
 inline void InitVideoDisplay(void)
 {
 #if defined(TARGET_SDL)
@@ -278,6 +381,9 @@ inline Bitmap *CreateBitmap(int width, int height, int depth)
   new_bitmap->line_gc[1] = window->line_gc[1];
 #endif
 
+  new_bitmap->width = width;
+  new_bitmap->height = height;
+
   return new_bitmap;
 }
 
@@ -295,7 +401,7 @@ inline static void FreeBitmapPointers(Bitmap *bitmap)
   bitmap->surface_masked = NULL;
 #else
   /* The X11 version seems to have a memory leak here -- although
-     "XFreePixmap()" is called, the correspondig memory seems not
+     "XFreePixmap()" is called, the corresponding memory seems not
      to be freed (according to "ps"). The SDL version apparently
      does not have this problem. */
 
@@ -350,45 +456,70 @@ inline void CloseWindow(DrawWindow *window)
 #endif
 }
 
-inline boolean DrawingDeactivated(int x, int y, int width, int height)
+static inline boolean CheckDrawingArea(int x, int y, int width, int height,
+				       int draw_mask)
 {
-  if (gfx.draw_deactivation_mask != REDRAW_NONE)
-  {
-    if ((gfx.draw_deactivation_mask & REDRAW_FIELD) &&
-	x < gfx.sx + gfx.sxsize)
-      return TRUE;
-  }
+  if (draw_mask == REDRAW_NONE)
+    return FALSE;
+
+  if (draw_mask & REDRAW_ALL)
+    return TRUE;
+
+  if ((draw_mask & REDRAW_FIELD) && x < gfx.real_sx + gfx.full_sxsize)
+    return TRUE;
+
+  if ((draw_mask & REDRAW_DOOR_1) && x >= gfx.dx && y < gfx.dy + gfx.dysize)
+    return TRUE;
+
+  if ((draw_mask & REDRAW_DOOR_2) && x >= gfx.dx && y >= gfx.vy)
+    return TRUE;
 
   return FALSE;
 }
 
+inline boolean DrawingDeactivated(int x, int y, int width, int height)
+{
+  return CheckDrawingArea(x, y, width, height, gfx.draw_deactivation_mask);
+}
+
+inline boolean DrawingOnBackground(int x, int y)
+{
+  return ((gfx.draw_background_mask & gfx.background_bitmap_mask) &&
+	  CheckDrawingArea(x, y, 1, 1, gfx.draw_background_mask));
+}
+
 inline void BlitBitmap(Bitmap *src_bitmap, Bitmap *dst_bitmap,
-		       int src_x, int src_y,
-		       int width, int height,
+		       int src_x, int src_y, int width, int height,
 		       int dst_x, int dst_y)
 {
   if (DrawingDeactivated(dst_x, dst_y, width, height))
     return;
 
-#ifdef TARGET_SDL
-  SDLCopyArea(src_bitmap, dst_bitmap,
-	      src_x, src_y, width, height, dst_x, dst_y, SDLCOPYAREA_OPAQUE);
-#else
-  XCopyArea(display, src_bitmap->drawable, dst_bitmap->drawable,
-	    dst_bitmap->gc, src_x, src_y, width, height, dst_x, dst_y);
-#endif
+  sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
+	      dst_x, dst_y, BLIT_OPAQUE);
 }
 
-inline void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
+inline void FillRectangle(Bitmap *bitmap, int x, int y, int width, int height,
+			  Pixel color)
 {
   if (DrawingDeactivated(x, y, width, height))
     return;
 
-#ifdef TARGET_SDL
-  SDLFillRectangle(bitmap, x, y, width, height, 0x000000);
-#else
-  XFillRectangle(display, bitmap->drawable, bitmap->gc, x, y, width, height);
-#endif
+  sysFillRectangle(bitmap, x, y, width, height, color);
+}
+
+inline void ClearRectangle(Bitmap *bitmap, int x, int y, int width, int height)
+{
+  FillRectangle(bitmap, x, y, width, height, BlackPixel(display, screen));
+}
+
+inline void ClearRectangleOnBackground(Bitmap *bitmap, int x, int y,
+				       int width, int height)
+{
+  if (DrawingOnBackground(x, y))
+    BlitBitmap(gfx.background_bitmap, bitmap, x, y, width, height, x, y);
+  else
+    ClearRectangle(bitmap, x, y, width, height);
 }
 
 #if 0
@@ -433,13 +564,30 @@ inline void BlitBitmapMasked(Bitmap *src_bitmap, Bitmap *dst_bitmap,
   if (DrawingDeactivated(dst_x, dst_y, width, height))
     return;
 
-#ifdef TARGET_SDL
-  SDLCopyArea(src_bitmap, dst_bitmap,
-	      src_x, src_y, width, height, dst_x, dst_y, SDLCOPYAREA_MASKED);
-#else
-  XCopyArea(display, src_bitmap->drawable, dst_bitmap->drawable,
-	    src_bitmap->clip_gc, src_x, src_y, width, height, dst_x, dst_y);
-#endif
+  sysCopyArea(src_bitmap, dst_bitmap, src_x, src_y, width, height,
+	      dst_x, dst_y, BLIT_MASKED);
+}
+
+inline void BlitBitmapOnBackground(Bitmap *src_bitmap, Bitmap *dst_bitmap,
+				   int src_x, int src_y,
+				   int width, int height,
+				   int dst_x, int dst_y)
+{
+  if (DrawingOnBackground(dst_x, dst_y))
+  {
+    /* draw background */
+    BlitBitmap(gfx.background_bitmap, dst_bitmap, dst_x, dst_y, width, height,
+	       dst_x, dst_y);
+
+    /* draw foreground */
+    SetClipOrigin(src_bitmap, src_bitmap->stored_clip_gc,
+		  dst_x - src_x, dst_y - src_y);
+    BlitBitmapMasked(src_bitmap, dst_bitmap, src_x, src_y, width, height,
+		     dst_x, dst_y);
+  }
+  else
+    BlitBitmap(src_bitmap, dst_bitmap, src_x, src_y, width, height,
+	       dst_x, dst_y);
 }
 
 inline void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
@@ -450,7 +598,6 @@ inline void DrawSimpleWhiteLine(Bitmap *bitmap, int from_x, int from_y,
 #else
   XSetForeground(display, bitmap->gc, WhitePixel(display, screen));
   XDrawLine(display, bitmap->drawable, bitmap->gc, from_x, from_y, to_x, to_y);
-  XSetForeground(display, bitmap->gc, BlackPixel(display, screen));
 #endif
 }
 
@@ -503,9 +650,6 @@ inline void DrawLines(Bitmap *bitmap, struct XY *points, int num_points,
   XSetForeground(display, bitmap->line_gc[1], pixel);
   XDrawLines(display, bitmap->drawable, bitmap->line_gc[1],
 	     (XPoint *)points, num_points, CoordModeOrigin);
-  /*
-  XSetForeground(display, gc, BlackPixel(display, screen));
-  */
 #endif
 }
 
@@ -516,40 +660,20 @@ inline Pixel GetPixel(Bitmap *bitmap, int x, int y)
 #elif defined(TARGET_ALLEGRO)
   return AllegroGetPixel(bitmap->drawable, x, y);
 #else
-  unsigned long pixel_value;
-  XImage *pixel_image;
-
-  pixel_image = XGetImage(display, bitmap->drawable, x, y, 1, 1,
-			  AllPlanes, ZPixmap);
-  pixel_value = XGetPixel(pixel_image, 0, 0);
-
-  XDestroyImage(pixel_image);
-
-  return pixel_value;
+  return X11GetPixel(bitmap, x, y);
 #endif
 }
 
 inline Pixel GetPixelFromRGB(Bitmap *bitmap, unsigned int color_r,
 			     unsigned int color_g, unsigned int color_b)
 {
-  Pixel pixel;
-
 #if defined(TARGET_SDL)
-  pixel = SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b);
+  return SDL_MapRGB(bitmap->surface->format, color_r, color_g, color_b);
 #elif defined(TARGET_ALLEGRO)
-  pixel = AllegroAllocColorCell(color_r << 8, color_g << 8, color_b << 8);
-#elif defined(TARGET_X11_NATIVE)
-  XColor xcolor;
-
-  xcolor.flags = DoRed | DoGreen | DoBlue;
-  xcolor.red = (color_r << 8);
-  xcolor.green = (color_g << 8);
-  xcolor.blue = (color_b << 8);
-  XAllocColor(display, cmap, &xcolor);
-  pixel = xcolor.pixel;
+  return AllegroAllocColorCell(color_r << 8, color_g << 8, color_b << 8);
+#else
+  return X11GetPixelFromRGB(color_r, color_g, color_b);
 #endif
-
-  return pixel;
 }
 
 inline Pixel GetPixelFromRGBcompact(Bitmap *bitmap, unsigned int color)
@@ -659,7 +783,8 @@ Bitmap *LoadImage(char *filename)
   new_bitmap = X11LoadImage(filename);
 #endif
 
-  new_bitmap->source_filename = getStringCopy(filename);
+  if (new_bitmap)
+    new_bitmap->source_filename = getStringCopy(filename);
 
   return new_bitmap;
 }
@@ -707,7 +832,8 @@ void ReloadCustomImage(Bitmap *bitmap, char *basename)
   if (bitmap->width != new_bitmap->width ||
       bitmap->height != new_bitmap->height)
   {
-    Error(ERR_WARN, "ReloadCustomImage: new image has wrong dimensions");
+    Error(ERR_WARN, "ReloadCustomImage: new image '%s' has wrong dimensions",
+	  filename);
     FreeBitmap(new_bitmap);
     return;
   }
@@ -716,6 +842,58 @@ void ReloadCustomImage(Bitmap *bitmap, char *basename)
   free(new_bitmap);
 }
 
+Bitmap *ZoomBitmap(Bitmap *src_bitmap, int zoom_width, int zoom_height)
+{
+  Bitmap *dst_bitmap = CreateBitmap(zoom_width, zoom_height, DEFAULT_DEPTH);
+
+#if defined(TARGET_SDL)
+  SDLZoomBitmap(src_bitmap, dst_bitmap);
+#else
+  X11ZoomBitmap(src_bitmap, dst_bitmap);
+#endif
+
+  return dst_bitmap;
+}
+
+void CreateBitmapWithSmallBitmaps(Bitmap *src_bitmap)
+{
+  Bitmap *tmp_bitmap, *tmp_bitmap_2, *tmp_bitmap_8;
+  int src_width, src_height;
+  int tmp_width, tmp_height;
+
+  src_width  = src_bitmap->width;
+  src_height = src_bitmap->height;
+
+  tmp_width  = src_width;
+  tmp_height = src_height + src_height / 2;
+
+  tmp_bitmap = CreateBitmap(tmp_width, tmp_height, DEFAULT_DEPTH);
+
+  tmp_bitmap_2 = ZoomBitmap(src_bitmap, src_width / 2, src_height / 2);
+  tmp_bitmap_8 = ZoomBitmap(src_bitmap, src_width / 8, src_height / 8);
+
+  BlitBitmap(src_bitmap, tmp_bitmap, 0, 0, src_width, src_height, 0, 0);
+  BlitBitmap(tmp_bitmap_2, tmp_bitmap, 0, 0, src_width / 2, src_height / 2,
+	     0, src_height);
+  BlitBitmap(tmp_bitmap_8, tmp_bitmap, 0, 0, src_width / 8, src_height / 8,
+	     3 * src_width / 4, src_height);
+
+  FreeBitmap(tmp_bitmap_2);
+  FreeBitmap(tmp_bitmap_8);
+
+#ifdef TARGET_SDL
+  src_bitmap->surface = tmp_bitmap->surface;
+  tmp_bitmap->surface = NULL;
+#else
+  src_bitmap->drawable = tmp_bitmap->drawable;
+  tmp_bitmap->drawable = None;
+#endif
+
+  src_bitmap->height = tmp_bitmap->height;
+
+  FreeBitmap(tmp_bitmap);
+}
+
 
 /* ========================================================================= */
 /* audio functions                                                           */
@@ -727,17 +905,18 @@ inline void OpenAudio(void)
   audio.sound_available = FALSE;
   audio.music_available = FALSE;
   audio.loops_available = FALSE;
-  audio.mods_available = FALSE;
+
   audio.sound_enabled = FALSE;
+  audio.sound_deactivated = FALSE;
 
-  audio.soundserver_pipe[0] = audio.soundserver_pipe[1] = 0;
-  audio.soundserver_pid = -1;
+  audio.mixer_pipe[0] = audio.mixer_pipe[1] = 0;
+  audio.mixer_pid = 0;
   audio.device_name = NULL;
-  audio.device_fd = 0;
+  audio.device_fd = -1;
 
-  audio.channels = 0;
+  audio.num_channels = 0;
   audio.music_channel = 0;
-  audio.music_nr = 0;
+  audio.first_sound_channel = 0;
 
 #if defined(TARGET_SDL)
   SDLOpenAudio();
@@ -810,7 +989,9 @@ inline Key GetEventKey(KeyEvent *event, boolean with_modifiers)
 	 (int)SDL_GetModState());
 #endif
 
-  if (with_modifiers && event->keysym.unicode != 0)
+  if (with_modifiers &&
+      event->keysym.unicode > 0x0000 &&
+      event->keysym.unicode < 0x2000)
     return event->keysym.unicode;
   else
     return event->keysym.sym;