added graphics config option to support elements on non-black background

diff --git a/src/conf_gfx.c b/src/conf_gfx.c
index 69564a388890d826db10b9e46a9d726f7eb25a5d..343c2724bb89961065d2be9acf3a15b7aac8835f 100644 (file)
--- a/src/conf_gfx.c
+++ b/src/conf_gfx.c
@@ -9751,6 +9751,7 @@ struct ConfigInfo image_config[] =
   { "game.use_native_emc_graphics_engine",     "false"                 },
   { "game.use_native_sp_graphics_engine",      "true"                  },
   { "game.use_masked_pushing",                 "false"                 },
+  { "game.use_masked_elements",                        "false"                 },
   { "game.tile_size",                          "32"                    },
 
   { "[player].boring_delay_fixed",             "1000"                  },

diff --git a/src/game.c b/src/game.c
index f6b479efdfb6c152ac472695606977746681872e..4c4288750b20706592ac9dd2823c95f8f4a2a44a 100644 (file)
--- a/src/game.c
+++ b/src/game.c
@@ -5349,13 +5349,15 @@ void DrawDynamite(int x, int y)
     return;
 
   if (Back[x][y])
-    DrawGraphic(sx, sy, el2img(Back[x][y]), 0);
+    DrawLevelElement(x, y, Back[x][y]);
   else if (Store[x][y])
-    DrawGraphic(sx, sy, el2img(Store[x][y]), 0);
+    DrawLevelElement(x, y, Store[x][y]);
+  else if (game.use_masked_elements)
+    DrawLevelElement(x, y, EL_EMPTY);
 
   frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
 
-  if (Back[x][y] || Store[x][y])
+  if (Back[x][y] || Store[x][y] || game.use_masked_elements)
     DrawGraphicThruMask(sx, sy, graphic, frame);
   else
     DrawGraphic(sx, sy, graphic, frame);
@@ -5928,7 +5930,7 @@ static void Explode(int ex, int ey, int phase, int mode)
       DrawLevelElementThruMask(x, y, Back[x][y]);
     }
     else if (!IS_WALKABLE_INSIDE(Back[x][y]))
-      DrawGraphic(SCREENX(x), SCREENY(y), graphic, frame);
+      DrawScreenGraphic(SCREENX(x), SCREENY(y), graphic, frame);
   }
 }
 

diff --git a/src/game.h b/src/game.h
index 656bb396083890e739304799e23fdc5ed63e0243..5739ecf0668eb82c770c3c568264b5a86cd47fa6 100644 (file)
--- a/src/game.h
+++ b/src/game.h
@@ -156,6 +156,7 @@ struct GameInfo
   boolean use_native_emc_graphics_engine;
   boolean use_native_sp_graphics_engine;
   boolean use_masked_pushing;
+  boolean use_masked_elements;
   int forced_scroll_delay_value;
   int scroll_delay_value;
   int tile_size;

diff --git a/src/tools.c b/src/tools.c
index 099fd59de0c007460883d811c59d2997624745d1..b0df34409cfbc97772af22c78e8815c9ae6c3644 100644 (file)
--- a/src/tools.c
+++ b/src/tools.c
@@ -1960,6 +1960,9 @@ void DrawScreenElementExt(int x, int y, int dx, int dy, int element,
       graphic = el_act_dir2img(element, ACTION_DEFAULT, GfxDir[lx][ly]);
       frame = getGraphicAnimationFrame(graphic, GfxFrame[lx][ly]);
     }
+
+    if (game.use_masked_elements && (dx || dy))
+      mask_mode = USE_MASKING;
   }
   else // border element
   {
@@ -2078,8 +2081,27 @@ static void DrawLevelFieldCrumbledInnerCorners(int x, int y, int dx, int dy,
   cx = (dx > 0 ? TILESIZE_VAR - width  : 0);
   cy = (dy > 0 ? TILESIZE_VAR - height : 0);
 
-  BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
-            width, height, FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
+  if (game.use_masked_elements)
+  {
+    int graphic0 = el2img(EL_EMPTY);
+    int frame0 = getGraphicAnimationFrame(graphic0, GfxFrame[x][y]);
+    Bitmap *src_bitmap0;
+    int src_x0, src_y0;
+
+    getGraphicSource(graphic0, frame0, &src_bitmap0, &src_x0, &src_y0);
+
+    BlitBitmap(src_bitmap0, drawto_field, src_x0 + cx, src_y0 + cy,
+              width, height,
+              FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
+
+    BlitBitmapMasked(src_bitmap, drawto_field, src_x + cx, src_y + cy,
+                    width, height,
+                    FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
+  }
+  else
+    BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
+              width, height,
+              FX + sx * TILEX_VAR + cx, FY + sy * TILEY_VAR + cy);
 }
 
 static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
@@ -2098,6 +2120,15 @@ static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
 
   getGraphicSource(graphic, frame, &src_bitmap, &src_x, &src_y);
 
+  // only needed when using masked elements
+  int graphic0 = el2img(EL_EMPTY);
+  int frame0 = getGraphicAnimationFrame(graphic0, GfxFrame[x][y]);
+  Bitmap *src_bitmap0;
+  int src_x0, src_y0;
+
+  if (game.use_masked_elements)
+    getGraphicSource(graphic0, frame0, &src_bitmap0, &src_x0, &src_y0);
+
   // draw simple, sloppy, non-corner-accurate crumbled border
 
   width  = (dir == 1 || dir == 2 ? crumbled_border_size_var : TILESIZE_VAR);
@@ -2105,9 +2136,23 @@ static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
   cx = (dir == 2 ? crumbled_border_pos_var : 0);
   cy = (dir == 3 ? crumbled_border_pos_var : 0);
 
-  BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy, width, height,
-            FX + sx * TILEX_VAR + cx,
-            FY + sy * TILEY_VAR + cy);
+  if (game.use_masked_elements)
+  {
+    BlitBitmap(src_bitmap0, drawto_field, src_x0 + cx, src_y0 + cy,
+              width, height,
+              FX + sx * TILEX_VAR + cx,
+              FY + sy * TILEY_VAR + cy);
+
+    BlitBitmapMasked(src_bitmap, drawto_field, src_x + cx, src_y + cy,
+                    width, height,
+                    FX + sx * TILEX_VAR + cx,
+                    FY + sy * TILEY_VAR + cy);
+  }
+  else
+    BlitBitmap(src_bitmap, drawto_field, src_x + cx, src_y + cy,
+              width, height,
+              FX + sx * TILEX_VAR + cx,
+              FY + sy * TILEY_VAR + cy);
 
   // (remaining middle border part must be at least as big as corner part)
   if (!(graphic_info[graphic].style & STYLE_ACCURATE_BORDERS) ||
@@ -2153,10 +2198,23 @@ static void DrawLevelFieldCrumbledBorders(int x, int y, int graphic, int frame,
        by = cy;
       }
 
-      BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
-                width, height,
-                FX + sx * TILEX_VAR + cx,
-                FY + sy * TILEY_VAR + cy);
+      if (game.use_masked_elements)
+      {
+       BlitBitmap(src_bitmap0, drawto_field, src_x0 + bx, src_y0 + by,
+                  width, height,
+                  FX + sx * TILEX_VAR + cx,
+                  FY + sy * TILEY_VAR + cy);
+
+       BlitBitmapMasked(src_bitmap, drawto_field, src_x + bx, src_y + by,
+                        width, height,
+                        FX + sx * TILEX_VAR + cx,
+                        FY + sy * TILEY_VAR + cy);
+      }
+      else
+       BlitBitmap(src_bitmap, drawto_field, src_x + bx, src_y + by,
+                  width, height,
+                  FX + sx * TILEX_VAR + cx,
+                  FY + sy * TILEY_VAR + cy);
     }
   }
 }
@@ -2311,7 +2369,7 @@ void DrawLevelFieldCrumbledDigging(int x, int y, int direction,
   int frame2 = getGraphicAnimationFrame(graphic2, step_frame);
   int sx = SCREENX(x), sy = SCREENY(y);
 
-  DrawGraphic(sx, sy, graphic1, frame1);
+  DrawScreenGraphic(sx, sy, graphic1, frame1);
   DrawLevelFieldCrumbledExt(x, y, graphic2, frame2);
 }
 
@@ -2392,9 +2450,38 @@ static int getBorderElement(int x, int y)
   return border[steel_position][steel_type];
 }
 
+void DrawScreenGraphic(int x, int y, int graphic, int frame)
+{
+  if (game.use_masked_elements)
+  {
+    if (graphic != el2img(EL_EMPTY))
+      DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
+
+    DrawGraphicThruMask(x, y, graphic, frame);
+  }
+  else
+  {
+    DrawGraphic(x, y, graphic, frame);
+  }
+}
+
 void DrawScreenElement(int x, int y, int element)
 {
-  DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, NO_MASKING);
+  int mask_mode = NO_MASKING;
+
+  if (game.use_masked_elements)
+  {
+    int lx = LEVELX(x), ly = LEVELY(y);
+
+    if (IN_LEV_FIELD(lx, ly) && element != EL_EMPTY)
+    {
+      DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
+
+      mask_mode = USE_MASKING;
+    }
+  }
+
+  DrawScreenElementExt(x, y, 0, 0, element, NO_CUTTING, mask_mode);
   DrawLevelFieldCrumbled(LEVELX(x), LEVELY(y));
 }
 
@@ -3747,12 +3834,23 @@ void DrawFixedGraphicAnimationExt(DrawBuffer *dst_bitmap, int x, int y,
 static void DrawGraphicAnimation(int x, int y, int graphic)
 {
   int lx = LEVELX(x), ly = LEVELY(y);
+  int mask_mode = NO_MASKING;
 
   if (!IN_SCR_FIELD(x, y))
     return;
 
+  if (game.use_masked_elements)
+  {
+    if (Tile[lx][ly] != EL_EMPTY)
+    {
+      DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
+
+      mask_mode = USE_MASKING;
+    }
+  }
+
   DrawGraphicAnimationExt(drawto_field, FX + x * TILEX_VAR, FY + y * TILEY_VAR,
-                         graphic, GfxFrame[lx][ly], NO_MASKING);
+                         graphic, GfxFrame[lx][ly], mask_mode);
 
   MarkTileDirty(x, y);
 }
@@ -3760,12 +3858,24 @@ static void DrawGraphicAnimation(int x, int y, int graphic)
 void DrawFixedGraphicAnimation(int x, int y, int graphic)
 {
   int lx = LEVELX(x), ly = LEVELY(y);
+  int mask_mode = NO_MASKING;
 
   if (!IN_SCR_FIELD(x, y))
     return;
 
+  if (game.use_masked_elements)
+  {
+    if (Tile[lx][ly] != EL_EMPTY)
+    {
+      DrawScreenElementExt(x, y, 0, 0, EL_EMPTY, NO_CUTTING, NO_MASKING);
+
+      mask_mode = USE_MASKING;
+    }
+  }
+
   DrawGraphicAnimationExt(drawto_field, FX + x * TILEX, FY + y * TILEY,
-                         graphic, GfxFrame[lx][ly], NO_MASKING);
+                         graphic, GfxFrame[lx][ly], mask_mode);
+
   MarkTileDirty(x, y);
 }
 
@@ -4024,7 +4134,7 @@ static void DrawPlayerExt(struct PlayerInfo *player, int drawing_stage)
       if (GFX_CRUMBLED(old_element))
        DrawLevelFieldCrumbledDigging(jx, jy, move_dir, player->StepFrame);
       else
-       DrawGraphic(sx, sy, old_graphic, frame);
+       DrawScreenGraphic(sx, sy, old_graphic, frame);
 
       if (graphic_info[old_graphic].anim_mode & ANIM_OPAQUE_PLAYER)
        static_player_is_opaque[pnr] = TRUE;

diff --git a/src/tools.h b/src/tools.h
index 4dffbbd1ba1902a293345fc89c419bdcbdcaeb9e..cb8c9343d0f3c474f245c2e5941806e3c0d88e8f 100644 (file)
--- a/src/tools.h
+++ b/src/tools.h
@@ -180,6 +180,7 @@ void DrawLevelFieldThruMask(int, int);
 void DrawLevelFieldCrumbled(int, int);
 void DrawLevelFieldCrumbledDigging(int, int, int, int);
 void DrawLevelFieldCrumbledNeighbours(int, int);
+void DrawScreenGraphic(int, int, int, int);
 void DrawScreenElement(int, int, int);
 void DrawLevelElement(int, int, int);
 void DrawScreenField(int, int);