X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Ftools.c;h=5bf10171387d179ff2adb285317fedecc954e247;hb=852a8eef1e8858a40da0be4093eba3deaf468f51;hp=28f7d9e57b3cb8f7c4efeb21fcecc1e874ccabea;hpb=10f7dade083dc6f44b4a4f2123f3808d9558dac0;p=rocksndiamonds.git

diff --git a/src/tools.c b/src/tools.c
index 28f7d9e5..5bf10171 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -427,8 +427,12 @@ void BackToFront()
     if (!global.fps_slowdown)
       info1[0] = '\0';
 
-    sprintf(text, "%.1f fps%s", global.frames_per_second, info1);
+    sprintf(text, "%04.1f fps%s", global.frames_per_second, info1);
+#if 1
+    DrawTextExt(window, SX + SXSIZE + SX, 0, text, FONT_TEXT_2, BLIT_OPAQUE);
+#else
     DrawTextExt(window, SX, SY, text, FONT_TEXT_2, BLIT_OPAQUE);
+#endif
   }
 
   FlushDisplay();
@@ -1364,6 +1368,13 @@ void DrawLevelFieldThruMask(int x, int y)
   DrawLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING);
 }
 
+/* !!! implementation of quicksand is totally broken !!! */
+#define IS_CRUMBLED_TILE(x, y, e)					\
+	(GFX_CRUMBLED(e) && (!IN_LEV_FIELD(x, y) ||			\
+			     !IS_MOVING(x, y) ||			\
+			     (e) == EL_QUICKSAND_EMPTYING ||		\
+			     (e) == EL_QUICKSAND_FAST_EMPTYING))
+
 static void DrawLevelFieldCrumbledSandExt(int x, int y, int graphic, int frame)
 {
   Bitmap *src_bitmap;
@@ -1386,7 +1397,11 @@ static void DrawLevelFieldCrumbledSandExt(int x, int y, int graphic, int frame)
   element = TILE_GFX_ELEMENT(x, y);
 
   /* crumble field itself */
+#if 1
+  if (IS_CRUMBLED_TILE(x, y, element))
+#else
   if (GFX_CRUMBLED(element) && !IS_MOVING(x, y))
+#endif
   {
     if (!IN_SCR_FIELD(sx, sy))
       return;
@@ -1402,8 +1417,13 @@ static void DrawLevelFieldCrumbledSandExt(int x, int y, int graphic, int frame)
 		 BorderElement);
 
       /* check if neighbour field is of same type */
+#if 1
+      if (IS_CRUMBLED_TILE(xx, yy, element))
+	continue;
+#else
       if (GFX_CRUMBLED(element) && !IS_MOVING(xx, yy))
 	continue;
+#endif
 
       if (i == 1 || i == 2)
       {
@@ -1435,18 +1455,29 @@ static void DrawLevelFieldCrumbledSandExt(int x, int y, int graphic, int frame)
       int sxx = sx + xy[i][0];
       int syy = sy + xy[i][1];
 
+#if 1
+      if (!IN_LEV_FIELD(xx, yy) ||
+	  !IN_SCR_FIELD(sxx, syy))
+	continue;
+#else
       if (!IN_LEV_FIELD(xx, yy) ||
 	  !IN_SCR_FIELD(sxx, syy) ||
 	  IS_MOVING(xx, yy))
 	continue;
+#endif
 
       if (Feld[xx][yy] == EL_ELEMENT_SNAPPING)
 	continue;
 
       element = TILE_GFX_ELEMENT(xx, yy);
 
+#if 1
+      if (!IS_CRUMBLED_TILE(xx, yy, element))
+	continue;
+#else
       if (!GFX_CRUMBLED(element))
 	continue;
+#endif
 
       graphic = el_act2crm(element, ACTION_DEFAULT);
       crumbled_border_size = graphic_info[graphic].border_size;
@@ -1600,6 +1631,7 @@ void DrawScreenField(int x, int y)
       element = getBorderElement(lx, ly);
 
     DrawScreenElement(x, y, element);
+
     return;
   }
 
@@ -1625,8 +1657,22 @@ void DrawScreenField(int x, int y)
 	     element == EL_DC_MAGIC_WALL_FILLING)
       cut_mode = CUT_BELOW;
 
+#if 0
+    if (lx == 9 && ly == 1)
+      printf("::: %s [%d] [%d, %d] [%d]\n",
+	     EL_NAME(TILE_GFX_ELEMENT(lx, ly)),
+	     el_act2crm(TILE_GFX_ELEMENT(lx, ly), ACTION_DEFAULT),
+	     element_info[EL_QUICKSAND_EMPTYING].graphic[ACTION_DEFAULT],
+	     element_info[EL_QUICKSAND_EMPTYING].crumbled[ACTION_DEFAULT],
+	     GFX_CRUMBLED(TILE_GFX_ELEMENT(lx, ly)));
+#endif
+
     if (cut_mode == CUT_ABOVE)
+#if 1
+      DrawScreenElement(x, y, element);
+#else
       DrawScreenElementShifted(x, y, 0, 0, element, NO_CUTTING);
+#endif
     else
       DrawScreenElement(x, y, EL_EMPTY);
 
@@ -1635,8 +1681,16 @@ void DrawScreenField(int x, int y)
     else if (cut_mode == NO_CUTTING)
       DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
     else
+    {
       DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
 
+#if 1
+      if (cut_mode == CUT_BELOW &&
+	  IN_LEV_FIELD(lx, ly + 1) && IN_SCR_FIELD(x, y + 1))
+	DrawLevelElement(lx, ly + 1, element);
+#endif
+    }
+
     if (content == EL_ACID)
     {
       int dir = MovDir[lx][ly];
@@ -1891,7 +1945,13 @@ void DrawLevel()
 {
   int x,y;
 
+#if 1
+  SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
+  SetDrawBackgroundMask(REDRAW_FIELD);
+#else
   SetDrawBackgroundMask(REDRAW_NONE);
+#endif
+
   ClearField();
 
   for (x = BX1; x <= BX2; x++)
@@ -3148,6 +3208,11 @@ unsigned int MoveDoor(unsigned int door_state)
     door_state &= ~DOOR_CLOSE_ALL;
   }
 
+#if 1
+  if (game_status == GAME_MODE_EDITOR)
+    door_state |= DOOR_NO_DELAY;
+#endif
+
   if (door_state & DOOR_ACTION)
   {
     boolean handle_door_1 = (door_state & DOOR_ACTION_1);
@@ -4796,6 +4861,32 @@ 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
+  },
+  {
+    Xsand_stonesand_quickout_1,		FALSE,	FALSE,
+    EL_QUICKSAND_EMPTYING,		-1, -1
+  },
+  {
+    Xsand_stonesand_quickout_2,		FALSE,	FALSE,
+    EL_QUICKSAND_EMPTYING,		-1, -1
+  },
+#else
   {
     Xsand_stonesand_1,			FALSE,	FALSE,
     EL_QUICKSAND_FULL,			-1, -1
@@ -4812,6 +4903,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
@@ -4820,6 +4912,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
@@ -4836,6 +4946,7 @@ em_object_mapping_list[] =
     Xsand_sandstone_4,			FALSE,	FALSE,
     EL_QUICKSAND_FULL,			-1, -1
   },
+#endif
   {
     Xplant,				TRUE,	FALSE,
     EL_EMC_PLANT,			-1, -1
@@ -5914,50 +6025,206 @@ 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_stonesand_quickout_1:
+    case Xsand_sandstone_1:
+    case Xsand_stonein_1:
+    case Xsand_stoneout_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;
 }
 
-void SetGfxAnimation_EM(int tile, int frame_em, int x, int y)
+void SetGfxAnimation_EM(struct GraphicInfo_EM *g_em,
+			int tile, int frame_em, int x, int y)
 {
-#if 0
-  int element         = object_mapping[tile].element_rnd;
+  int action = object_mapping[tile].action;
+#if 1
+  int direction = object_mapping[tile].direction;
+  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));
+  struct GraphicInfo *g = &graphic_info[graphic];
+  int sync_frame;
 #endif
-  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);
+  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 0
-  printf("::: SET: %d, %d: '%s'\n", x, y, EL_NAME(element));
+  if (tile == Xsand_stonesand_1 ||
+      tile == Xsand_stonesand_2 ||
+      tile == Xsand_stonesand_3 ||
+      tile == Xsand_stonesand_4)
+    printf("::: 1: quicksand frame %d [%d]\n", GfxFrame[x][y], tile);
 #endif
 
 #if 1
-  if (action_removing)
+  if ((action_removing || check_linear_animation_EM(tile)) && frame_em == 0)
   {
-#if 0
-    printf("::: %d, %d: action_removing [%s]\n", x, y, EL_NAME(element));
-#endif
+    GfxFrame[x][y] = 0;
+
+    // printf("::: resetting... [%d]\n", tile);
+  }
+#else
+  if (action_removing || check_linear_animation_EM(tile))
+  {
+    GfxFrame[x][y] = frame_em;
 
-    GfxFrame[x][y] = 7 - frame_em;
+    // printf("::: resetting... [%d]\n", tile);
   }
-  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);
+#endif
+  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)
@@ -5969,145 +6236,23 @@ 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
-}
-
-#if 1
-
-int get_effective_element_EM(int tile, int frame)
-{
-  int i = tile;
-  int j = 7 - frame;
-
-  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);
-#if 0
-  boolean action_exploding = ((action == ACTION_EXPLODING ||
-			       action == ACTION_SMASHED_BY_ROCK ||
-			       action == ACTION_SMASHED_BY_SPRING) &&
-			      element != EL_DIAMOND);
-  boolean action_active = (action == ACTION_ACTIVE);
-  boolean action_other = (action == ACTION_OTHER);
-#endif
-
   {
-    {
-      int effective_element = (j > 5 && i == Yacid_splash_eB ? EL_EMPTY :
-			       j > 5 && i == Yacid_splash_wB ? EL_EMPTY :
-			       j < 7 ? element :
-			       i == Xdrip_stretch ? element :
-			       i == Xdrip_stretchB ? element :
-			       i == Ydrip_s1 ? element :
-			       i == Ydrip_s1B ? element :
-			       i == Xball_1B ? element :
-			       i == Xball_2 ? element :
-			       i == Xball_2B ? element :
-			       i == Yball_eat ? element :
-			       i == Ykey_1_eat ? element :
-			       i == Ykey_2_eat ? element :
-			       i == Ykey_3_eat ? element :
-			       i == Ykey_4_eat ? element :
-			       i == Ykey_5_eat ? element :
-			       i == Ykey_6_eat ? element :
-			       i == Ykey_7_eat ? element :
-			       i == Ykey_8_eat ? element :
-			       i == Ylenses_eat ? element :
-			       i == Ymagnify_eat ? element :
-			       i == Ygrass_eat ? element :
-			       i == Ydirt_eat ? element :
-			       i == Yemerald_stone ? EL_EMERALD :
-			       i == Ydiamond_stone ? EL_ROCK :
-			       i == Xsand_stonein_1 ? element :
-			       i == Xsand_stonein_2 ? element :
-			       i == Xsand_stonein_3 ? element :
-			       i == Xsand_stonein_4 ? element :
-			       is_backside ? EL_EMPTY :
-			       action_removing ? EL_EMPTY :
-			       element);
+    GfxFrame[x][y]++;
 
-      return effective_element;
-    }
+    /* special case: animation for Xsand_stonesand_quickout_1/2 twice as fast */
+    if (tile == Xsand_stonesand_quickout_1 ||
+	tile == Xsand_stonesand_quickout_2)
+      GfxFrame[x][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);
-#if 1
-  int effective_element = get_effective_element_EM(tile, frame_em);
-#else
-  int effective_element = (frame_em > 0 ? element :
-			   is_backside ? EL_EMPTY :
-			   action_removing ? EL_EMPTY :
-			   element);
-#endif
-  int graphic = (direction == MV_NONE ?
-		 el_act2img(effective_element, action) :
-		 el_act_dir2img(effective_element, action, direction));
-  int crumbled = (direction == MV_NONE ?
-		  el_act2crm(effective_element, action) :
-		  el_act_dir2crm(effective_element, action, direction));
-  int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
-  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));
-#endif
 
 #if 0
-  if (GfxFrame[x][y] < 8)
-    printf("::: %d, %d: %d [%s]\n", x, y, GfxFrame[x][y], EL_NAME(element));
-#endif
-
-#if 1
-  if (frame_em == 7)	/* reset animation frame for certain elements */
-  {
-    if (tile == Xboom_1 ||
-	tile == Xdynamite_1 ||
-	tile == Ybug_w_n ||
-	tile == Ybug_n_e ||
-	tile == Ybug_e_s ||
-	tile == Ybug_s_w ||
-	tile == Ybug_e_n ||
-	tile == Ybug_s_e ||
-	tile == Ybug_w_s ||
-	tile == Ybug_n_w ||
-	tile == Ytank_w_n ||
-	tile == Ytank_n_e ||
-	tile == Ytank_e_s ||
-	tile == Ytank_s_w ||
-	tile == Ytank_e_n ||
-	tile == Ytank_s_e ||
-	tile == Ytank_w_s ||
-	tile == Ytank_n_w)
-      GfxFrame[x][y] = 0;
-  }
+  if (tile == Xsand_stonesand_1 ||
+      tile == Xsand_stonesand_2 ||
+      tile == Xsand_stonesand_3 ||
+      tile == Xsand_stonesand_4)
+    printf("::: 2: quicksand frame %d [%d]\n", GfxFrame[x][y], tile);
 #endif
 
 #if 1
@@ -6116,13 +6261,7 @@ void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
   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);
 
@@ -6132,77 +6271,17 @@ void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
 				g->anim_start_frame,
 				sync_frame);
 
-#if 0
-  if (graphic == IMG_DEFAULT_EXPLODING)
-    printf("::: IMG_DEFAULT_EXPLODING: (%d, %d), %d => %d [%d]\n",
-	   tile, frame_em, sync_frame, frame, Xboom_1);
-#endif
-
-  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 0
-  if (g_em->crumbled_bitmap != NULL &&
-      !(has_crumbled_graphics && crumbled != IMG_EMPTY_SPACE))
-    printf("::: CRUMBLED CHANGES FOR tile %d [%s] [%d]\n",
-	   tile, EL_NAME(element), Ydirt_eat);
-#endif
-
-  g_em->crumbled_bitmap = NULL;
-  g_em->crumbled_src_x = 0;
-  g_em->crumbled_src_y = 0;
-
-  g_em->has_crumbled_graphics = FALSE;
-
-  if (has_crumbled_graphics && crumbled != IMG_EMPTY_SPACE)
-  {
-    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->has_crumbled_graphics = TRUE;
-  }
+  g_em->unique_identifier =
+    (graphic << 16) | ((frame % 8) << 12) | (g_em->width << 6) | g_em->height;
 #endif
 }
 
-#else
-
-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 action = object_mapping[tile].action;
+  int direction = object_mapping[tile].direction;
+  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));
@@ -6213,55 +6292,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));
-#endif
-
-#if 1
-  if (frame_em == 7)	/* reset animation frame for certain elements */
-  {
-    if (tile == Xboom_1 ||
-	tile == Ybug_w_n ||
-	tile == Ybug_n_e ||
-	tile == Ybug_e_s ||
-	tile == Ybug_s_w ||
-	tile == Ybug_e_n ||
-	tile == Ybug_s_e ||
-	tile == Ybug_w_s ||
-	tile == Ybug_n_w ||
-	tile == Ytank_w_n ||
-	tile == Ytank_n_e ||
-	tile == Ytank_e_s ||
-	tile == Ytank_s_w ||
-	tile == Ytank_e_n ||
-	tile == Ytank_s_e ||
-	tile == Ytank_w_s ||
-	tile == Ytank_n_w)
+  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);
 
@@ -6271,31 +6320,22 @@ void getGraphicSourceObjectExt_EM(int tile, int frame_em,
 				g->anim_start_frame,
 				sync_frame);
 
-#if 0
-  if (graphic == IMG_DEFAULT_EXPLODING)
-    printf("::: IMG_DEFAULT_EXPLODING: (%d, %d), %d => %d [%d]\n",
-	   tile, frame_em, sync_frame, frame, Xboom_1);
-#endif
-
-  getGraphicSourceExt(graphic, frame, src_bitmap, src_x, 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
+  getGraphicSourceExt(graphic, frame, &g_em->bitmap,
+		      &g_em->src_x, &g_em->src_y, FALSE);
 
-#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)
   {
@@ -6305,16 +6345,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
 }
 
-#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;
@@ -6327,10 +6367,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,
@@ -6338,14 +6387,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)
@@ -6425,9 +6466,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) &&
@@ -6437,6 +6480,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 :
@@ -6469,6 +6515,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 :
@@ -6510,7 +6557,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;
@@ -6647,13 +6696,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)
@@ -6703,6 +6759,7 @@ void InitGraphicInfo_EM(void)
 	printf("::: EMC tile %d is crumbled\n", i);
 #endif
       }
+#endif
 
 #if 0
       if (element == EL_ROCK &&