X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ftools.c;h=d950959c53d4e723912185e7a23f32ff4b22c9df;hb=46c5d03b337f538c20380ebe975bc4609eb1d542;hp=e469a50181a8d909f787300a2e5ec2adab998dac;hpb=43d8239a719759a411bc31e0330e5e1cb353c32e;p=rocksndiamonds.git

diff --git a/src/tools.c b/src/tools.c
index e469a501..d950959c 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -118,7 +118,7 @@ void SetDrawtoField(int mode)
 
     drawto_field = fieldbuffer;
   }
-  else	/* DRAW_DIRECT, DRAW_BACKBUFFER */
+  else	/* DRAW_BACKBUFFER */
   {
     FX = SX;
     FY = SY;
@@ -129,7 +129,7 @@ void SetDrawtoField(int mode)
     redraw_x1 = 0;
     redraw_y1 = 0;
 
-    drawto_field = (mode == DRAW_DIRECT ? window :  backbuffer);
+    drawto_field = backbuffer;
   }
 }
 
@@ -154,23 +154,17 @@ void RedrawPlayfield(boolean force_redraw, int x, int y, int width, int height)
       height = gfx.sysize + 2 * TILEY;
     }
 
-    if (force_redraw || setup.direct_draw)
+    if (force_redraw)
     {
       int xx, yy;
       int x1 = (x - SX) / TILEX, y1 = (y - SY) / TILEY;
       int x2 = (x - SX + width) / TILEX, y2 = (y - SY + height) / TILEY;
 
-      if (setup.direct_draw)
-	SetDrawtoField(DRAW_BACKBUFFER);
-
       for (xx = BX1; xx <= BX2; xx++)
 	for (yy = BY1; yy <= BY2; yy++)
 	  if (xx >= x1 && xx <= x2 && yy >= y1 && yy <= y2)
 	    DrawScreenField(xx, yy);
       DrawAllPlayers();
-
-      if (setup.direct_draw)
-	SetDrawtoField(DRAW_DIRECT);
     }
 
     if (setup.soft_scrolling)
@@ -266,9 +260,6 @@ void BackToFront()
   int x,y;
   DrawBuffer *buffer = (drawto_field == window ? backbuffer : drawto_field);
 
-  if (setup.direct_draw && game_status == GAME_MODE_PLAYING)
-    redraw_mask &= ~REDRAW_MAIN;
-
   if (redraw_mask & REDRAW_TILES && redraw_tiles > REDRAWTILES_THRESHOLD)
     redraw_mask |= REDRAW_FIELD;
 
@@ -520,7 +511,7 @@ static void FadeExt(int fade_mask, int fade_mode, int fade_type)
   }
 #endif
 
-#if 1
+#if 0
   if (fading.fade_mode == FADE_MODE_NONE)
   {
     BackToFront();
@@ -535,12 +526,13 @@ static void FadeExt(int fade_mask, int fade_mode, int fade_type)
   printf("::: NOW FADING %d ... [%d]\n", fade_mode, fade_type);
 #endif
 
-#if 1
+#if 0
   if (fade_mask == REDRAW_NONE)
     fade_mask = REDRAW_FIELD;
 #endif
 
-  if (fade_mask & REDRAW_FIELD)
+  // if (fade_mask & REDRAW_FIELD)
+  if (fade_mask == REDRAW_FIELD)
   {
     x = REAL_SX;
     y = REAL_SY;
@@ -567,15 +559,28 @@ static void FadeExt(int fade_mask, int fade_mode, int fade_type)
   }
 
 #if 1
-  if (!setup.fade_screens || fade_delay == 0)
+  if (!setup.fade_screens ||
+      fade_delay == 0 ||
+      fading.fade_mode == FADE_MODE_NONE)
 #else
-  if (!setup.fade_screens || fade_delay == 0 || fading.anim_mode == ANIM_NONE)
+  if (!setup.fade_screens || fade_delay == 0)
 #endif
   {
     if (fade_mode == FADE_MODE_FADE_OUT)
+      return;
+
+#if 0
+    if (fade_mode == FADE_MODE_FADE_OUT &&
+	fading.fade_mode != FADE_MODE_NONE)
       ClearRectangle(backbuffer, x, y, width, height);
+#endif
 
+#if 1
+    BlitBitmap(backbuffer, window, x, y, width, height, x, y);
+    redraw_mask = REDRAW_NONE;
+#else
     BackToFront();
+#endif
 
     return;
   }
@@ -588,69 +593,22 @@ static void FadeExt(int fade_mask, int fade_mode, int fade_type)
 
 void FadeIn(int fade_mask)
 {
-#if 0
-  global.border_status = game_status;
-#endif
-
-#if 1
-  // printf("::: now fading in...\n");
-
   if (fading.fade_mode & FADE_TYPE_TRANSFORM)
     FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_IN);
   else
     FadeExt(fade_mask, FADE_MODE_FADE_IN, FADE_TYPE_FADE_IN);
-#else
-#if 1
-  if (fading.fade_mode == FADE_MODE_CROSSFADE)
-    FadeExt(fade_mask, FADE_MODE_CROSSFADE);
-  else
-    FadeExt(fade_mask, FADE_MODE_FADE_IN);
-#else
-  FadeExt(fade_mask, FADE_MODE_FADE_IN);
-#endif
-#endif
 }
 
 void FadeOut(int fade_mask)
 {
-#if 1
-  // printf("::: fading.fade_mode == %d\n", fading.fade_mode);
-
-#if 1
   if (fading.fade_mode & FADE_TYPE_TRANSFORM)
     FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_OUT);
   else
     FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
-#else
-  if (fading.fade_mode & FADE_TYPE_TRANSFORM)
-    FadeCrossSaveBackbuffer();
-  else
-    FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
-#endif
 
-#else
-#if 1
-  if (fading.fade_mode == FADE_MODE_CROSSFADE)
-    FadeCrossSaveBackbuffer();
-  else
-    FadeExt(fade_mask, FADE_MODE_FADE_OUT);
-#else
-  FadeExt(fade_mask, FADE_MODE_FADE_OUT);
-#endif
-#endif
-
-#if 1
   global.border_status = game_status;
-#endif
 }
 
-#if 0
-void FadeCross(int fade_mask)
-{
-  FadeExt(fade_mask, FADE_MODE_CROSSFADE);
-}
-#endif
-
 static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
 {
   static struct TitleFadingInfo fading_leave_stored;
@@ -825,7 +783,7 @@ void DrawBackgroundForGraphic(int x, int y, int width, int height, int graphic)
   DrawBackground(x, y, width, height);
 }
 
-void ClearWindow()
+void ClearField()
 {
   /* !!! "drawto" might still point to playfield buffer here (see above) !!! */
   /* (when entering hall of fame after playing) */
@@ -839,12 +797,6 @@ void ClearWindow()
   }
   else
     SetDrawtoField(DRAW_BACKBUFFER);
-
-  if (setup.direct_draw && game_status == GAME_MODE_PLAYING)
-  {
-    ClearRectangle(window, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
-    SetDrawtoField(DRAW_DIRECT);
-  }
 }
 
 void MarkTileDirty(int x, int y)
@@ -1940,7 +1892,7 @@ void DrawLevel()
   int x,y;
 
   SetDrawBackgroundMask(REDRAW_NONE);
-  ClearWindow();
+  ClearField();
 
   for (x = BX1; x <= BX2; x++)
     for (y = BY1; y <= BY2; y++)
@@ -2507,9 +2459,6 @@ void DrawPlayer(struct PlayerInfo *player)
   if (!IN_SCR_FIELD(sx, sy))
     return;
 
-  if (setup.direct_draw)
-    SetDrawtoField(DRAW_BUFFERED);
-
   /* ----------------------------------------------------------------------- */
   /* draw things behind the player, if needed                                */
   /* ----------------------------------------------------------------------- */
@@ -2688,18 +2637,6 @@ void DrawPlayer(struct PlayerInfo *player)
       DrawLevelFieldThruMask(jx, jy);
   }
 
-  if (setup.direct_draw)
-  {
-    int dst_x = SX + SCREENX(MIN(jx, last_jx)) * TILEX;
-    int dst_y = SY + SCREENY(MIN(jy, last_jy)) * TILEY;
-    int x_size = TILEX * (1 + ABS(jx - last_jx));
-    int y_size = TILEY * (1 + ABS(jy - last_jy));
-
-    BlitBitmap(drawto_field, window,
-	       dst_x, dst_y, x_size, y_size, dst_x, dst_y);
-    SetDrawtoField(DRAW_DIRECT);
-  }
-
   MarkTileDirty(sx, sy);
 }
 
@@ -4859,6 +4796,24 @@ em_object_mapping_list[] =
     Xsand_stonein_4,			FALSE,	TRUE,
     EL_ROCK,				ACTION_FILLING, -1
   },
+#if 1
+  {
+    Xsand_stonesand_1,			FALSE,	FALSE,
+    EL_QUICKSAND_EMPTYING,		-1, -1
+  },
+  {
+    Xsand_stonesand_2,			FALSE,	FALSE,
+    EL_QUICKSAND_EMPTYING,		-1, -1
+  },
+  {
+    Xsand_stonesand_3,			FALSE,	FALSE,
+    EL_QUICKSAND_EMPTYING,		-1, -1
+  },
+  {
+    Xsand_stonesand_4,			FALSE,	FALSE,
+    EL_QUICKSAND_EMPTYING,		-1, -1
+  },
+#else
   {
     Xsand_stonesand_1,			FALSE,	FALSE,
     EL_QUICKSAND_FULL,			-1, -1
@@ -4875,6 +4830,7 @@ em_object_mapping_list[] =
     Xsand_stonesand_4,			FALSE,	FALSE,
     EL_QUICKSAND_FULL,			-1, -1
   },
+#endif
   {
     Xsand_stoneout_1,			FALSE,	FALSE,
     EL_ROCK,				ACTION_EMPTYING, -1
@@ -4883,6 +4839,24 @@ em_object_mapping_list[] =
     Xsand_stoneout_2,			FALSE,	FALSE,
     EL_ROCK,				ACTION_EMPTYING, -1
   },
+#if 1
+  {
+    Xsand_sandstone_1,			FALSE,	FALSE,
+    EL_QUICKSAND_FILLING,		-1, -1
+  },
+  {
+    Xsand_sandstone_2,			FALSE,	FALSE,
+    EL_QUICKSAND_FILLING,		-1, -1
+  },
+  {
+    Xsand_sandstone_3,			FALSE,	FALSE,
+    EL_QUICKSAND_FILLING,		-1, -1
+  },
+  {
+    Xsand_sandstone_4,			FALSE,	FALSE,
+    EL_QUICKSAND_FILLING,		-1, -1
+  },
+#else
   {
     Xsand_sandstone_1,			FALSE,	FALSE,
     EL_QUICKSAND_FULL,			-1, -1
@@ -4899,6 +4873,7 @@ em_object_mapping_list[] =
     Xsand_sandstone_4,			FALSE,	FALSE,
     EL_QUICKSAND_FULL,			-1, -1
   },
+#endif
   {
     Xplant,				TRUE,	FALSE,
     EL_EMC_PLANT,			-1, -1
@@ -5977,6 +5952,140 @@ static struct Mapping_EM_to_RND_object object_mapping[TILE_MAX];
 static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][SPR_MAX];
 #endif
 
+inline static int get_effective_element_EM(int tile, int frame_em)
+{
+  int element             = object_mapping[tile].element_rnd;
+  int action              = object_mapping[tile].action;
+  boolean is_backside     = object_mapping[tile].is_backside;
+  boolean action_removing = (action == ACTION_DIGGING ||
+			     action == ACTION_SNAPPING ||
+			     action == ACTION_COLLECTING);
+
+  if (frame_em < 7)
+  {
+    switch (tile)
+    {
+      case Yacid_splash_eB:
+      case Yacid_splash_wB:
+	return (frame_em > 5 ? EL_EMPTY : element);
+
+      default:
+	return element;
+    }
+  }
+  else	/* frame_em == 7 */
+  {
+    switch (tile)
+    {
+      case Yacid_splash_eB:
+      case Yacid_splash_wB:
+	return EL_EMPTY;
+
+      case Yemerald_stone:
+	return EL_EMERALD;
+
+      case Ydiamond_stone:
+	return EL_ROCK;
+
+      case Xdrip_stretch:
+      case Xdrip_stretchB:
+      case Ydrip_s1:
+      case Ydrip_s1B:
+      case Xball_1B:
+      case Xball_2:
+      case Xball_2B:
+      case Yball_eat:
+      case Ykey_1_eat:
+      case Ykey_2_eat:
+      case Ykey_3_eat:
+      case Ykey_4_eat:
+      case Ykey_5_eat:
+      case Ykey_6_eat:
+      case Ykey_7_eat:
+      case Ykey_8_eat:
+      case Ylenses_eat:
+      case Ymagnify_eat:
+      case Ygrass_eat:
+      case Ydirt_eat:
+      case Xsand_stonein_1:
+      case Xsand_stonein_2:
+      case Xsand_stonein_3:
+      case Xsand_stonein_4:
+	return element;
+
+      default:
+	return (is_backside || action_removing ? EL_EMPTY : element);
+    }
+  }
+}
+
+inline static boolean check_linear_animation_EM(int tile)
+{
+  switch (tile)
+  {
+    case Xsand_stonesand_1:
+    case Xsand_sandstone_1:
+    case Xboom_1:
+    case Xdynamite_1:
+    case Ybug_w_n:
+    case Ybug_n_e:
+    case Ybug_e_s:
+    case Ybug_s_w:
+    case Ybug_e_n:
+    case Ybug_s_e:
+    case Ybug_w_s:
+    case Ybug_n_w:
+    case Ytank_w_n:
+    case Ytank_n_e:
+    case Ytank_e_s:
+    case Ytank_s_w:
+    case Ytank_e_n:
+    case Ytank_s_e:
+    case Ytank_w_s:
+    case Ytank_n_w:
+      return TRUE;
+  }
+
+  return FALSE;
+}
+
+inline static void set_crumbled_graphics_EM(struct GraphicInfo_EM *g_em,
+					    boolean has_crumbled_graphics,
+					    int crumbled, int sync_frame)
+{
+  /* if element can be crumbled, but certain action graphics are just empty
+     space (like instantly snapping sand to empty space in 1 frame), do not
+     treat these empty space graphics as crumbled graphics in EMC engine */
+  if (crumbled == IMG_EMPTY_SPACE)
+    has_crumbled_graphics = FALSE;
+
+  if (has_crumbled_graphics)
+  {
+    struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
+    int frame_crumbled = getAnimationFrame(g_crumbled->anim_frames,
+					   g_crumbled->anim_delay,
+					   g_crumbled->anim_mode,
+					   g_crumbled->anim_start_frame,
+					   sync_frame);
+
+    getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
+		     &g_em->crumbled_src_x, &g_em->crumbled_src_y);
+
+    g_em->crumbled_border_size = graphic_info[crumbled].border_size;
+
+    g_em->has_crumbled_graphics = TRUE;
+  }
+  else
+  {
+    g_em->crumbled_bitmap = NULL;
+    g_em->crumbled_src_x = 0;
+    g_em->crumbled_src_y = 0;
+    g_em->crumbled_border_size = 0;
+
+    g_em->has_crumbled_graphics = FALSE;
+  }
+}
+
 void ResetGfxAnimation_EM(int x, int y, int tile)
 {
   GfxFrame[x][y] = 0;
@@ -5984,43 +6093,33 @@ void ResetGfxAnimation_EM(int x, int y, int tile)
 
 void SetGfxAnimation_EM(int tile, int frame_em, int x, int y)
 {
-#if 0
-  int element         = object_mapping[tile].element_rnd;
-#endif
-  int action          = object_mapping[tile].action;
-  int direction       = object_mapping[tile].direction;
-  boolean is_backside = object_mapping[tile].is_backside;
+  int action = object_mapping[tile].action;
   boolean action_removing = (action == ACTION_DIGGING ||
 			     action == ACTION_SNAPPING ||
 			     action == ACTION_COLLECTING);
-
-#if 0
-  printf("::: SET: %d, %d: '%s'\n", x, y, EL_NAME(element));
-#endif
-
-#if 1
-  if (action_removing)
-  {
-#if 0
-    printf("::: %d, %d: action_removing [%s]\n", x, y, EL_NAME(element));
-#endif
-
-    GfxFrame[x][y] = 7 - frame_em;
+  boolean action_moving   = (action == ACTION_FALLING ||
+			     action == ACTION_MOVING ||
+			     action == ACTION_PUSHING ||
+			     action == ACTION_EATING ||
+			     action == ACTION_FILLING ||
+			     action == ACTION_EMPTYING);
+  boolean action_falling  = (action == ACTION_FALLING ||
+			     action == ACTION_FILLING ||
+			     action == ACTION_EMPTYING);
+
+  if (action_removing || check_linear_animation_EM(tile))
+  {
+    GfxFrame[x][y] = frame_em;
   }
-  else if (action == ACTION_FALLING ||
-	   action == ACTION_MOVING ||
-	   action == ACTION_PUSHING ||
-	   action == ACTION_EATING ||
-	   action == ACTION_FILLING ||
-	   action == ACTION_EMPTYING)
-  {
-    int move_dir =
-      (action == ACTION_FALLING ||
-       action == ACTION_FILLING ||
-       action == ACTION_EMPTYING ? MV_DOWN : direction);
+  else if (action_moving)
+  {
+    boolean is_backside = object_mapping[tile].is_backside;
 
     if (is_backside)
     {
+      int direction = object_mapping[tile].direction;
+      int move_dir = (action_falling ? MV_DOWN : direction);
+
       GfxFrame[x][y]++;
 
       if (move_dir == MV_LEFT)
@@ -6032,36 +6131,19 @@ void SetGfxAnimation_EM(int tile, int frame_em, int x, int y)
       else if (move_dir == MV_DOWN)
 	GfxFrame[x][y + 1] = GfxFrame[x][y];
     }
-
-#if 0
-    printf("::: %d, %d: %s, %d, %d [%d]\n", x, y, EL_NAME(element), is_backside,
-	   move_dir, GfxFrame[x][y]);
-#endif
   }
   else
+  {
     GfxFrame[x][y]++;
-#else
-  GfxFrame[x][y] = 7 - frame_em;
-#endif
+  }
 }
 
-void getGraphicSourceObjectExt_EM(int tile, int frame_em,
-				  Bitmap **src_bitmap, int *src_x, int *src_y,
-				  Bitmap **crumbled_src_bitmap,
-				  int *crumbled_src_x, int *crumbled_src_y,
-				  int x, int y)
+void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
+				  int tile, int frame_em, int x, int y)
 {
-  int element         = object_mapping[tile].element_rnd;
   int action          = object_mapping[tile].action;
   int direction       = object_mapping[tile].direction;
-  boolean is_backside = object_mapping[tile].is_backside;
-  boolean action_removing = (action == ACTION_DIGGING ||
-			     action == ACTION_SNAPPING ||
-			     action == ACTION_COLLECTING);
-  int effective_element = (frame_em > 0 ? element :
-			   is_backside ? EL_EMPTY :
-			   action_removing ? EL_EMPTY :
-			   element);
+  int effective_element = get_effective_element_EM(tile, frame_em);
   int graphic = (direction == MV_NONE ?
 		 el_act2img(effective_element, action) :
 		 el_act_dir2img(effective_element, action, direction));
@@ -6072,31 +6154,25 @@ void getGraphicSourceObjectExt_EM(int tile, int frame_em,
   int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
   boolean has_crumbled_graphics = (base_crumbled != base_graphic);
   struct GraphicInfo *g = &graphic_info[graphic];
-  struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
-  int sync_frame;
-
 #if 0
-  printf("::: GET: %d, %d: '%s'\n", x, y, EL_NAME(element));
+  struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
 #endif
+  int sync_frame;
 
 #if 0
-  if (GfxFrame[x][y] < 8)
-    printf("::: %d, %d: %d [%s]\n", x, y, GfxFrame[x][y], EL_NAME(element));
+  if (frame_em == 0)	/* reset animation frame for certain elements */
+  {
+    if (check_linear_animation_EM(tile))
+      GfxFrame[x][y] = 0;
+  }
 #endif
 
-#if 1
   if (graphic_info[graphic].anim_global_sync)
     sync_frame = FrameCounter;
   else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
     sync_frame = GfxFrame[x][y];
   else
-    sync_frame = 0;	/* steel border */
-#else
-  if (graphic_info[graphic].anim_global_sync)
-    sync_frame = FrameCounter;
-  else
-    sync_frame = 7 - frame_em;
-#endif
+    sync_frame = 0;	/* playfield border (pseudo steel) */
 
   SetRandomAnimationValue(x, y);
 
@@ -6106,25 +6182,22 @@ void getGraphicSourceObjectExt_EM(int tile, int frame_em,
 				g->anim_start_frame,
 				sync_frame);
 
-  getGraphicSourceExt(graphic, frame, src_bitmap, src_x, src_y, FALSE);
+  getGraphicSourceExt(graphic, frame, &g_em->bitmap,
+		      &g_em->src_x, &g_em->src_y, FALSE);
 
-#if 0
-  if (x == 1 && y == 1 && frame == 0)
-    printf("--> %d, %d, %d\n", *crumbled_src_x, *crumbled_src_y, tile);
-#endif
-
-#if 0
-  getGraphicSource(crumbled, frame, crumbled_src_bitmap,
-		   crumbled_src_x, crumbled_src_y);
-#endif
-
-#if 1
   /* (updating the "crumbled" graphic definitions is probably not really needed,
      as animations for crumbled graphics can't be longer than one EMC cycle) */
+#if 1
+  set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
+			   sync_frame);
+
+#else
+
+  g_em->crumbled_bitmap = NULL;
+  g_em->crumbled_src_x = 0;
+  g_em->crumbled_src_y = 0;
 
-  *crumbled_src_bitmap = NULL;
-  *crumbled_src_x = 0;
-  *crumbled_src_y = 0;
+  g_em->has_crumbled_graphics = FALSE;
 
   if (has_crumbled_graphics && crumbled != IMG_EMPTY_SPACE)
   {
@@ -6134,14 +6207,16 @@ void getGraphicSourceObjectExt_EM(int tile, int frame_em,
 					   g_crumbled->anim_start_frame,
 					   sync_frame);
 
-    getGraphicSource(crumbled, frame_crumbled, crumbled_src_bitmap,
-		     crumbled_src_x, crumbled_src_y);
+    getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
+		     &g_em->crumbled_src_x, &g_em->crumbled_src_y);
+
+    g_em->has_crumbled_graphics = TRUE;
   }
 #endif
 }
 
-void getGraphicSourcePlayerExt_EM(int player_nr, int anim, int frame_em,
-				  Bitmap **src_bitmap, int *src_x, int *src_y)
+void getGraphicSourcePlayerExt_EM(struct GraphicInfo_EM *g_em,
+				  int player_nr, int anim, int frame_em)
 {
   int element   = player_mapping[player_nr][anim].element_rnd;
   int action    = player_mapping[player_nr][anim].action;
@@ -6154,10 +6229,19 @@ void getGraphicSourcePlayerExt_EM(int player_nr, int anim, int frame_em,
 
   InitPlayerGfxAnimation(&stored_player[player_nr], action, direction);
 
-  stored_player[player_nr].StepFrame = 7 - frame_em;
+  stored_player[player_nr].StepFrame = frame_em;
 
   sync_frame = stored_player[player_nr].Frame;
 
+  int frame = getAnimationFrame(g->anim_frames,
+				g->anim_delay,
+				g->anim_mode,
+				g->anim_start_frame,
+				sync_frame);
+
+  getGraphicSourceExt(graphic, frame, &g_em->bitmap,
+		      &g_em->src_x, &g_em->src_y, FALSE);
+
 #if 0
   printf("::: %d: %d, %d [%d]\n",
 	 player_nr,
@@ -6165,14 +6249,6 @@ void getGraphicSourcePlayerExt_EM(int player_nr, int anim, int frame_em,
 	 stored_player[player_nr].StepFrame,
 	 FrameCounter);
 #endif
-
-  int frame = getAnimationFrame(g->anim_frames,
-				g->anim_delay,
-				g->anim_mode,
-				g->anim_start_frame,
-				sync_frame);
-
-  getGraphicSourceExt(graphic, frame, src_bitmap, src_x, src_y, FALSE);
 }
 
 void InitGraphicInfo_EM(void)
@@ -6252,9 +6328,11 @@ void InitGraphicInfo_EM(void)
     int action = object_mapping[i].action;
     int direction = object_mapping[i].direction;
     boolean is_backside = object_mapping[i].is_backside;
+#if 0
     boolean action_removing = (action == ACTION_DIGGING ||
 			       action == ACTION_SNAPPING ||
 			       action == ACTION_COLLECTING);
+#endif
     boolean action_exploding = ((action == ACTION_EXPLODING ||
 				 action == ACTION_SMASHED_BY_ROCK ||
 				 action == ACTION_SMASHED_BY_SPRING) &&
@@ -6264,6 +6342,9 @@ void InitGraphicInfo_EM(void)
 
     for (j = 0; j < 8; j++)
     {
+#if 1
+      int effective_element = get_effective_element_EM(i, j);
+#else
       int effective_element = (j > 5 && i == Yacid_splash_eB ? EL_EMPTY :
 			       j > 5 && i == Yacid_splash_wB ? EL_EMPTY :
 			       j < 7 ? element :
@@ -6296,6 +6377,7 @@ void InitGraphicInfo_EM(void)
 			       is_backside ? EL_EMPTY :
 			       action_removing ? EL_EMPTY :
 			       element);
+#endif
       int effective_action = (j < 7 ? action :
 			      i == Xdrip_stretch ? action :
 			      i == Xdrip_stretchB ? action :
@@ -6337,7 +6419,9 @@ void InitGraphicInfo_EM(void)
       boolean has_action_graphics = (graphic != base_graphic);
       boolean has_crumbled_graphics = (base_crumbled != base_graphic);
       struct GraphicInfo *g = &graphic_info[graphic];
+#if 0
       struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
+#endif
       struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][7 - j];
       Bitmap *src_bitmap;
       int src_x, src_y;
@@ -6474,13 +6558,20 @@ void InitGraphicInfo_EM(void)
       g_em->width  = TILEX;
       g_em->height = TILEY;
 
+      g_em->preserve_background = FALSE;
+
+#if 1
+      set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
+			       sync_frame);
+
+#else
+
       g_em->crumbled_bitmap = NULL;
       g_em->crumbled_src_x = 0;
       g_em->crumbled_src_y = 0;
       g_em->crumbled_border_size = 0;
 
       g_em->has_crumbled_graphics = FALSE;
-      g_em->preserve_background = FALSE;
 
 #if 0
       if (has_crumbled_graphics && crumbled == IMG_EMPTY_SPACE)
@@ -6526,8 +6617,11 @@ void InitGraphicInfo_EM(void)
 		 frame);
 #endif
 
-
+#if 0
+	printf("::: EMC tile %d is crumbled\n", i);
+#endif
       }
+#endif
 
 #if 0
       if (element == EL_ROCK &&