X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=48f5e7f158e13c68da188ade38a79d427057f63b;hb=19b66a27a5959f35c14f5c28b9b4645e89888159;hp=cb107f0e8e7aa0803b5240eab1acdfd89fe1597b;hpb=9b8ae38bcff8bb38d72b1d352a5debff85bc6291;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index cb107f0e..48f5e7f1 100644
--- a/src/game.c
+++ b/src/game.c
@@ -879,6 +879,10 @@ static struct GamePanelControlInfo game_panel_controls[] =
 				 RND(element_info[e].move_delay_random))
 #define GET_MAX_MOVE_DELAY(e)	(   (element_info[e].move_delay_fixed) + \
 				    (element_info[e].move_delay_random))
+#define GET_NEW_STEP_DELAY(e)	(   (element_info[e].step_delay_fixed) + \
+				 RND(element_info[e].step_delay_random))
+#define GET_MAX_STEP_DELAY(e)	(   (element_info[e].step_delay_fixed) + \
+				    (element_info[e].step_delay_random))
 #define GET_NEW_CE_VALUE(e)	(   (element_info[e].ce_value_fixed_initial) +\
 				 RND(element_info[e].ce_value_random_initial))
 #define GET_CE_SCORE(e)		(   (element_info[e].collect_score))
@@ -1071,6 +1075,8 @@ static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
 	CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
 #define CheckTriggeredElementChangeByPage(x, y, e, ev, p)		\
 	CheckTriggeredElementChangeExt(x,y,e,ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
+#define CheckTriggeredElementChangeByMouse(x, y, e, ev, s)		\
+	CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
 
 static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
 #define CheckElementChange(x, y, e, te, ev)				\
@@ -1079,6 +1085,8 @@ static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
 	CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s)
 #define CheckElementChangeBySide(x, y, e, te, ev, s)			\
 	CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s)
+#define CheckElementChangeByMouse(x, y, e, ev, s)			\
+	CheckElementChangeExt(x, y, e, EL_UNDEFINED, ev, CH_PLAYER_ANY, s)
 
 static void PlayLevelSound(int, int, int);
 static void PlayLevelSoundNearest(int, int, int);
@@ -1119,6 +1127,8 @@ void ExitPlayer(struct PlayerInfo *);
 static int getInvisibleActiveFromInvisibleElement(int);
 static int getInvisibleFromInvisibleActiveElement(int);
 
+static void TestFieldAfterSnapping(int, int, int, int, int);
+
 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
 
 // for detection of endless loops, caused by custom element programming
@@ -2867,12 +2877,10 @@ void UpdateAndDisplayGameControlValues(void)
   DisplayGameControlValues();
 }
 
-#if 0
-static void UpdateGameDoorValues(void)
+void UpdateGameDoorValues(void)
 {
   UpdateGameControlValues();
 }
-#endif
 
 void DrawGameDoorValues(void)
 {
@@ -3576,11 +3584,15 @@ void InitGame(void)
   InitGameEngine();
   InitGameControlValues();
 
-  // initialize tape actions from game when recording tape
   if (tape.recording)
   {
+    // initialize tape actions from game when recording tape
     tape.use_key_actions   = game.use_key_actions;
     tape.use_mouse_actions = game.use_mouse_actions;
+
+    // initialize visible playfield size when recording tape (for team mode)
+    tape.scr_fieldx = SCR_FIELDX;
+    tape.scr_fieldy = SCR_FIELDY;
   }
 
   // don't play tapes over network
@@ -3713,6 +3725,8 @@ void InitGame(void)
     player->shield_normal_time_left = 0;
     player->shield_deadly_time_left = 0;
 
+    player->last_removed_element = EL_UNDEFINED;
+
     player->inventory_infinite_element = EL_UNDEFINED;
     player->inventory_size = 0;
 
@@ -4710,14 +4724,13 @@ void GameWon(void)
 {
   static int time_count_steps;
   static int time, time_final;
-  static int score, score_final;
+  static float score, score_final; // needed for time score < 10 for 10 seconds
   static int health, health_final;
   static int game_over_delay_1 = 0;
   static int game_over_delay_2 = 0;
   static int game_over_delay_3 = 0;
-  int game_over_delay_value_1 = 50;
-  int game_over_delay_value_2 = 25;
-  int game_over_delay_value_3 = 50;
+  int time_score_base = MIN(MAX(1, level.time_score_base), 10);
+  float time_score = (float)level.score[SC_TIME_BONUS] / time_score_base;
 
   if (!game.LevelSolved_GameWon)
   {
@@ -4743,44 +4756,44 @@ void GameWon(void)
 
     TapeStop();
 
-    game_over_delay_1 = 0;
-    game_over_delay_2 = 0;
-    game_over_delay_3 = game_over_delay_value_3;
+    game_over_delay_1 = FRAMES_PER_SECOND;	// delay before counting time
+    game_over_delay_2 = FRAMES_PER_SECOND / 2;	// delay before counting health
+    game_over_delay_3 = FRAMES_PER_SECOND;	// delay before ending the game
 
     time = time_final = (game.no_time_limit ? TimePlayed : TimeLeft);
     score = score_final = game.score_final;
     health = health_final = game.health_final;
 
-    if (level.score[SC_TIME_BONUS] > 0)
+    if (time_score > 0)
     {
+      int time_frames = 0;
+
       if (TimeLeft > 0)
       {
 	time_final = 0;
-	score_final += TimeLeft * level.score[SC_TIME_BONUS];
+	time_frames = TimeLeft * FRAMES_PER_SECOND - TimeFrames;
       }
       else if (game.no_time_limit && TimePlayed < 999)
       {
 	time_final = 999;
-	score_final += (999 - TimePlayed) * level.score[SC_TIME_BONUS];
+	time_frames = (999 - TimePlayed) * FRAMES_PER_SECOND - TimeFrames;
       }
 
-      time_count_steps = MAX(1, ABS(time_final - time) / 100);
+      score_final += time_score * time_frames / FRAMES_PER_SECOND + 0.5;
 
-      game_over_delay_1 = game_over_delay_value_1;
+      time_count_steps = MAX(1, ABS(time_final - time) / 100);
 
       if (level.game_engine_type == GAME_ENGINE_TYPE_MM)
       {
 	health_final = 0;
-	score_final += health * level.score[SC_TIME_BONUS];
-
-	game_over_delay_2 = game_over_delay_value_2;
+	score_final += health * time_score;
       }
 
       game.score_final = score_final;
       game.health_final = health_final;
     }
 
-    if (level_editor_test_game)
+    if (level_editor_test_game || !setup.count_score_after_game)
     {
       time = time_final;
       score = score_final;
@@ -4844,72 +4857,79 @@ void GameWon(void)
     PlaySound(SND_GAME_WINNING);
   }
 
-  if (game_over_delay_1 > 0)
+  if (setup.count_score_after_game)
   {
-    game_over_delay_1--;
+    if (time != time_final)
+    {
+      if (game_over_delay_1 > 0)
+      {
+	game_over_delay_1--;
 
-    return;
-  }
+	return;
+      }
 
-  if (time != time_final)
-  {
-    int time_to_go = ABS(time_final - time);
-    int time_count_dir = (time < time_final ? +1 : -1);
+      int time_to_go = ABS(time_final - time);
+      int time_count_dir = (time < time_final ? +1 : -1);
 
-    if (time_to_go < time_count_steps)
-      time_count_steps = 1;
+      if (time_to_go < time_count_steps)
+	time_count_steps = 1;
 
-    time  += time_count_steps * time_count_dir;
-    score += time_count_steps * level.score[SC_TIME_BONUS];
+      time  += time_count_steps * time_count_dir;
+      score += time_count_steps * time_score;
 
-    game.LevelSolved_CountingTime = time;
-    game.LevelSolved_CountingScore = score;
+      // set final score to correct rounding differences after counting score
+      if (time == time_final)
+	score = score_final;
 
-    game_panel_controls[GAME_PANEL_TIME].value = time;
-    game_panel_controls[GAME_PANEL_SCORE].value = score;
+      game.LevelSolved_CountingTime = time;
+      game.LevelSolved_CountingScore = score;
 
-    DisplayGameControlValues();
+      game_panel_controls[GAME_PANEL_TIME].value = time;
+      game_panel_controls[GAME_PANEL_SCORE].value = score;
 
-    if (time == time_final)
-      StopSound(SND_GAME_LEVELTIME_BONUS);
-    else if (setup.sound_loops)
-      PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
-    else
-      PlaySound(SND_GAME_LEVELTIME_BONUS);
+      DisplayGameControlValues();
 
-    return;
-  }
+      if (time == time_final)
+	StopSound(SND_GAME_LEVELTIME_BONUS);
+      else if (setup.sound_loops)
+	PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
+      else
+	PlaySound(SND_GAME_LEVELTIME_BONUS);
 
-  if (game_over_delay_2 > 0)
-  {
-    game_over_delay_2--;
+      return;
+    }
 
-    return;
-  }
+    if (health != health_final)
+    {
+      if (game_over_delay_2 > 0)
+      {
+	game_over_delay_2--;
 
-  if (health != health_final)
-  {
-    int health_count_dir = (health < health_final ? +1 : -1);
+	return;
+      }
 
-    health += health_count_dir;
-    score  += level.score[SC_TIME_BONUS];
+      int health_count_dir = (health < health_final ? +1 : -1);
 
-    game.LevelSolved_CountingHealth = health;
-    game.LevelSolved_CountingScore = score;
+      health += health_count_dir;
+      score  += time_score;
 
-    game_panel_controls[GAME_PANEL_HEALTH].value = health;
-    game_panel_controls[GAME_PANEL_SCORE].value = score;
+      game.LevelSolved_CountingHealth = health;
+      game.LevelSolved_CountingScore = score;
 
-    DisplayGameControlValues();
+      game_panel_controls[GAME_PANEL_HEALTH].value = health;
+      game_panel_controls[GAME_PANEL_SCORE].value = score;
 
-    if (health == health_final)
-      StopSound(SND_GAME_LEVELTIME_BONUS);
-    else if (setup.sound_loops)
-      PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
-    else
-      PlaySound(SND_GAME_LEVELTIME_BONUS);
+      DisplayGameControlValues();
 
-    return;
+      if (health == health_final)
+	StopSound(SND_GAME_LEVELTIME_BONUS);
+      else if (setup.sound_loops)
+	PlaySoundLoop(SND_GAME_LEVELTIME_BONUS);
+      else
+	PlaySound(SND_GAME_LEVELTIME_BONUS);
+
+      return;
+    }
   }
 
   game.panel.active = FALSE;
@@ -4986,7 +5006,7 @@ void GameEnd(void)
 
   hi_pos = NewHiScore(last_level_nr);
 
-  if (hi_pos >= 0 && !setup.skip_scores_after_game)
+  if (hi_pos >= 0 && setup.show_scores_after_game)
   {
     SetGameStatus(GAME_MODE_SCORES);
 
@@ -5337,13 +5357,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);
@@ -5916,7 +5938,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);
   }
 }
 
@@ -8491,11 +8513,33 @@ void ContinueMoving(int x, int y)
   boolean pushed_by_player   = (Pushed[x][y] && IS_PLAYER(x, y));
   boolean pushed_by_conveyor = (Pushed[x][y] && !IS_PLAYER(x, y));
   boolean last_line = (newy == lev_fieldy - 1);
+  boolean use_step_delay = (GET_MAX_STEP_DELAY(element) != 0);
 
-  MovPos[x][y] += getElementMoveStepsize(x, y);
-
-  if (pushed_by_player)	// special case: moving object pushed by player
+  if (pushed_by_player)		// special case: moving object pushed by player
+  {
     MovPos[x][y] = SIGN(MovPos[x][y]) * (TILEX - ABS(PLAYERINFO(x,y)->MovPos));
+  }
+  else if (use_step_delay)	// special case: moving object has step delay
+  {
+    if (!MovDelay[x][y])
+      MovPos[x][y] += getElementMoveStepsize(x, y);
+
+    if (MovDelay[x][y])
+      MovDelay[x][y]--;
+    else
+      MovDelay[x][y] = GET_NEW_STEP_DELAY(element);
+
+    if (MovDelay[x][y])
+    {
+      TEST_DrawLevelField(x, y);
+
+      return;	// element is still waiting
+    }
+  }
+  else				// normal case: generically moving object
+  {
+    MovPos[x][y] += getElementMoveStepsize(x, y);
+  }
 
   if (ABS(MovPos[x][y]) < TILEX)
   {
@@ -11282,13 +11326,14 @@ static void CheckSingleStepMode(struct PlayerInfo *player)
 {
   if (tape.single_step && tape.recording && !tape.pausing)
   {
-    /* as it is called "single step mode", just return to pause mode when the
-       player stopped moving after one tile (or never starts moving at all) */
-    if (!player->is_moving &&
-	!player->is_pushing &&
-	!player->is_dropping_pressed &&
-	!player->effective_mouse_action.button)
-      TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
+    // as it is called "single step mode", just return to pause mode when the
+    // player stopped moving after one tile (or never starts moving at all)
+    // (reverse logic needed here in case single step mode used in team mode)
+    if (player->is_moving ||
+	player->is_pushing ||
+	player->is_dropping_pressed ||
+	player->effective_mouse_action.button)
+      game.enter_single_step_mode = FALSE;
   }
 
   CheckSaveEngineSnapshot(player);
@@ -11951,6 +11996,10 @@ void GameActions_RND(void)
     DrawGameDoorValues();
   }
 
+  // check single step mode (set flag and clear again if any player is active)
+  game.enter_single_step_mode =
+    (tape.single_step && tape.recording && !tape.pausing);
+
   for (i = 0; i < MAX_PLAYERS; i++)
   {
     int actual_player_action = stored_player[i].effective_action;
@@ -11975,6 +12024,10 @@ void GameActions_RND(void)
     ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
   }
 
+  // single step pause mode may already have been toggled by "ScrollPlayer()"
+  if (game.enter_single_step_mode && !tape.pausing)
+    TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
+
   ScrollScreen(NULL, SCROLL_GO_ON);
 
   /* for backwards compatibility, the following code emulates a fixed bug that
@@ -12027,10 +12080,17 @@ void GameActions_RND(void)
       MovDelay[x][y]--;
       if (MovDelay[x][y] <= 0)
       {
+	int element = Store[x][y];
+	int move_direction = MovDir[x][y];
+	int player_index_bit = Store2[x][y];
+
+	Store[x][y] = 0;
+	Store2[x][y] = 0;
+
 	RemoveField(x, y);
 	TEST_DrawLevelField(x, y);
 
-	TestIfElementTouchesCustomElement(x, y);	// for empty space
+	TestFieldAfterSnapping(x, y, element, move_direction, player_index_bit);
       }
     }
 
@@ -12085,6 +12145,7 @@ void GameActions_RND(void)
   if (mouse_action.button)
   {
     int new_button = (mouse_action.button && mouse_action_last.button == 0);
+    int ch_button = CH_SIDE_FROM_BUTTON(mouse_action.button);
 
     x = mouse_action.lx;
     y = mouse_action.ly;
@@ -12092,12 +12153,14 @@ void GameActions_RND(void)
 
     if (new_button)
     {
-      CheckElementChange(x, y, element, EL_UNDEFINED, CE_CLICKED_BY_MOUSE);
-      CheckTriggeredElementChange(x, y, element, CE_MOUSE_CLICKED_ON_X);
+      CheckElementChangeByMouse(x, y, element, CE_CLICKED_BY_MOUSE, ch_button);
+      CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_CLICKED_ON_X,
+					 ch_button);
     }
 
-    CheckElementChange(x, y, element, EL_UNDEFINED, CE_PRESSED_BY_MOUSE);
-    CheckTriggeredElementChange(x, y, element, CE_MOUSE_PRESSED_ON_X);
+    CheckElementChangeByMouse(x, y, element, CE_PRESSED_BY_MOUSE, ch_button);
+    CheckTriggeredElementChangeByMouse(x, y, element, CE_MOUSE_PRESSED_ON_X,
+				       ch_button);
   }
 
   SCAN_PLAYFIELD(x, y)
@@ -12448,6 +12511,8 @@ void GameActions_RND(void)
 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
 {
   int min_x = x, min_y = y, max_x = x, max_y = y;
+  int scr_fieldx = getScreenFieldSizeX();
+  int scr_fieldy = getScreenFieldSizeY();
   int i;
 
   for (i = 0; i < MAX_PLAYERS; i++)
@@ -12463,7 +12528,7 @@ static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
     max_y = MAX(max_y, jy);
   }
 
-  return (max_x - min_x < SCR_FIELDX && max_y - min_y < SCR_FIELDY);
+  return (max_x - min_x < scr_fieldx && max_y - min_y < scr_fieldy);
 }
 
 static boolean AllPlayersInVisibleScreen(void)
@@ -13029,6 +13094,21 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
       if (!player->is_pushing)
 	TestIfElementTouchesCustomElement(jx, jy);	// for empty space
 
+      if (level.finish_dig_collect &&
+	  (player->is_digging || player->is_collecting))
+      {
+	int last_element = player->last_removed_element;
+	int move_direction = player->MovDir;
+	int enter_side = MV_DIR_OPPOSITE(move_direction);
+	int change_event = (player->is_digging ? CE_PLAYER_DIGS_X :
+			    CE_PLAYER_COLLECTS_X);
+
+	CheckTriggeredElementChangeByPlayer(jx, jy, last_element, change_event,
+					    player->index_bit, enter_side);
+
+	player->last_removed_element = EL_UNDEFINED;
+      }
+
       if (!player->active)
 	RemovePlayer(player);
     }
@@ -13763,7 +13843,8 @@ void ExitPlayer(struct PlayerInfo *player)
     game.players_still_needed--;
 }
 
-static void setFieldForSnapping(int x, int y, int element, int direction)
+static void SetFieldForSnapping(int x, int y, int element, int direction,
+				int player_index_bit)
 {
   struct ElementInfo *ei = &element_info[element];
   int direction_bit = MV_DIR_TO_BIT(direction);
@@ -13773,6 +13854,9 @@ static void setFieldForSnapping(int x, int y, int element, int direction)
 
   Tile[x][y] = EL_ELEMENT_SNAPPING;
   MovDelay[x][y] = MOVE_DELAY_NORMAL_SPEED + 1 - 1;
+  MovDir[x][y] = direction;
+  Store[x][y] = element;
+  Store2[x][y] = player_index_bit;
 
   ResetGfxAnimation(x, y);
 
@@ -13782,6 +13866,20 @@ static void setFieldForSnapping(int x, int y, int element, int direction)
   GfxFrame[x][y] = -1;
 }
 
+static void TestFieldAfterSnapping(int x, int y, int element, int direction,
+				   int player_index_bit)
+{
+  TestIfElementTouchesCustomElement(x, y);	// for empty space
+
+  if (level.finish_dig_collect)
+  {
+    int dig_side = MV_DIR_OPPOSITE(direction);
+
+    CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
+					player_index_bit, dig_side);
+  }
+}
+
 /*
   =============================================================================
   checkDiagonalPushing()
@@ -14061,22 +14159,28 @@ static int DigField(struct PlayerInfo *player,
 
     PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
 
-    CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
-					player->index_bit, dig_side);
+    // use old behaviour for old levels (digging)
+    if (!level.finish_dig_collect)
+    {
+      CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_DIGS_X,
+					  player->index_bit, dig_side);
 
-    // if digging triggered player relocation, finish digging tile
-    if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
-      setFieldForSnapping(x, y, element, move_direction);
+      // if digging triggered player relocation, finish digging tile
+      if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
+	SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
+    }
 
     if (mode == DF_SNAP)
     {
       if (level.block_snap_field)
-	setFieldForSnapping(x, y, element, move_direction);
+	SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
       else
-	TestIfElementTouchesCustomElement(x, y);	// for empty space
+	TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
 
-      CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
-					  player->index_bit, dig_side);
+      // use old behaviour for old levels (snapping)
+      if (!level.finish_dig_collect)
+	CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
+					    player->index_bit, dig_side);
     }
   }
   else if (player_can_move_or_snap && IS_COLLECTIBLE(element))
@@ -14188,25 +14292,28 @@ static int DigField(struct PlayerInfo *player,
     RaiseScoreElement(element);
     PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
 
-    if (is_player)
+    // use old behaviour for old levels (collecting)
+    if (!level.finish_dig_collect && is_player)
     {
       CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_COLLECTS_X,
 					  player->index_bit, dig_side);
 
       // if collecting triggered player relocation, finish collecting tile
       if (mode == DF_DIG && (player->jx != jx || player->jy != jy))
-	setFieldForSnapping(x, y, element, move_direction);
+	SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
     }
 
     if (mode == DF_SNAP)
     {
       if (level.block_snap_field)
-	setFieldForSnapping(x, y, element, move_direction);
+	SetFieldForSnapping(x, y, element, move_direction, player->index_bit);
       else
-	TestIfElementTouchesCustomElement(x, y);	// for empty space
+	TestFieldAfterSnapping(x, y, element, move_direction, player->index_bit);
 
-      CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
-					  player->index_bit, dig_side);
+      // use old behaviour for old levels (snapping)
+      if (!level.finish_dig_collect)
+	CheckTriggeredElementChangeByPlayer(x, y, element, CE_PLAYER_SNAPS_X,
+					    player->index_bit, dig_side);
     }
   }
   else if (player_can_move_or_snap && IS_PUSHABLE(element))
@@ -14544,6 +14651,8 @@ static int DigField(struct PlayerInfo *player,
     {
       player->is_collecting = !player->is_digging;
       player->is_active = TRUE;
+
+      player->last_removed_element = element;
     }
   }