X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=2069cb1d35397dedc14306ddfea9fe845a658514;hb=87c8124b5296a3f5debfcb1273f4aa3beb563e8e;hp=948d46bb90083e3228985d257963e25038fe1bb2;hpb=87faaa07872dcc20b7a36a720529d284fc4447fd;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index 948d46bb..2069cb1d 100644
--- a/src/game.c
+++ b/src/game.c
@@ -96,6 +96,55 @@
 #define GET_NEW_MOVE_DELAY(e)	(   (element_info[e].move_delay_fixed) + \
 				 RND(element_info[e].move_delay_random))
 
+#define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition)		\
+		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
+					(condition) ||			\
+					(DONT_COLLIDE_WITH(e) &&	\
+					 IS_FREE_OR_PLAYER(x, y))))
+
+#define ELEMENT_CAN_ENTER_FIELD_GENERIC_2(x, y, condition)		\
+		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
+					(condition)))
+
+#define ELEMENT_CAN_ENTER_FIELD(e, x, y)				\
+	ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, 1)
+
+#define ELEMENT_CAN_ENTER_FIELD_OR_ACID(e, x, y)			\
+	ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, (Feld[x][y] == EL_ACID))
+
+#define ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(x, y)				\
+	ELEMENT_CAN_ENTER_FIELD_GENERIC_2(x, y, (Feld[x][y] == EL_ACID))
+
+#define ENEMY_CAN_ENTER_FIELD(x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
+
+#define YAMYAM_CAN_ENTER_FIELD(x, y)					\
+		(IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||	\
+					Feld[x][y] == EL_DIAMOND))
+
+#define DARK_YAMYAM_CAN_ENTER_FIELD(x, y)				\
+		(IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||	\
+					IS_FOOD_DARK_YAMYAM(Feld[x][y])))
+
+#define PACMAN_CAN_ENTER_FIELD(x, y)					\
+		(IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||	\
+					IS_AMOEBOID(Feld[x][y])))
+
+#define PIG_CAN_ENTER_FIELD(x, y)					\
+		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
+					IS_FOOD_PIG(Feld[x][y])))
+
+#define PENGUIN_CAN_ENTER_FIELD(x, y)					\
+		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
+					IS_FOOD_PENGUIN(Feld[x][y]) ||	\
+					Feld[x][y] == EL_EXIT_OPEN ||	\
+					Feld[x][y] == EL_ACID))
+
+#define MOLE_CAN_ENTER_FIELD(x, y, condition)				\
+		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) || (condition)))
+
+#define IN_LEV_FIELD_AND_IS_FREE(x, y)  (IN_LEV_FIELD(x, y) &&  IS_FREE(x, y))
+#define IN_LEV_FIELD_AND_NOT_FREE(x, y) (IN_LEV_FIELD(x, y) && !IS_FREE(x, y))
+
 /* game button identifiers */
 #define GAME_CTRL_ID_STOP		0
 #define GAME_CTRL_ID_PAUSE		1
@@ -114,6 +163,10 @@ static void CloseAllOpenTimegates(void);
 static void CheckGravityMovement(struct PlayerInfo *);
 static void KillHeroUnlessProtected(int, int);
 
+static void CheckTriggeredElementChange(int, int);
+static void CheckPlayerElementChange(int, int, int, int);
+static void ChangeElementDoIt(int, int, int);
+
 static void PlaySoundLevel(int, int, int);
 static void PlaySoundLevelNearest(int, int, int);
 static void PlaySoundLevelAction(int, int, int);
@@ -300,8 +353,13 @@ static struct ChangingElementInfo changing_element_list[] =
 };
 
 static struct ChangingElementInfo changing_element[MAX_NUM_ELEMENTS];
+static unsigned long trigger_events[MAX_NUM_ELEMENTS];
 
 #define IS_AUTO_CHANGING(e)  (changing_element[e].base_element != EL_UNDEFINED)
+#define IS_JUST_CHANGING(x, y)	(ChangeDelay[x][y] != 0)
+#define IS_CHANGING(x, y)	(IS_AUTO_CHANGING(Feld[x][y]) || \
+				 IS_JUST_CHANGING(x, y))
+#define TRIGGERS_BY_COLLECTING(e) (trigger_events[e] & CE_OTHER_COLLECTING)
 
 
 void GetPlayerConfig()
@@ -674,7 +732,7 @@ static void InitGameEngine()
     struct ElementChangeInfo *change = &element_info[element].change;
 
     /* only add custom elements that change after fixed/random frame delay */
-    if (!IS_CHANGEABLE(element) || !HAS_CHANGE_EVENT(element, CE_DELAY))
+    if (!CAN_CHANGE(element) || !HAS_CHANGE_EVENT(element, CE_DELAY))
       continue;
 
     changing_element[element].base_element = element;
@@ -682,6 +740,16 @@ static void InitGameEngine()
     changing_element[element].change_delay = (change->delay_fixed *
 					      change->delay_frames);
   }
+
+  /* initialize trigger events information */
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
+    trigger_events[i] = EP_BITMASK_DEFAULT;
+
+  /* add trigger events from element change event properties */
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
+    if (HAS_CHANGE_EVENT(i, CE_BY_OTHER))
+      trigger_events[element_info[i].change.trigger] |=
+	element_info[i].change.events;
 }
 
 
@@ -835,6 +903,7 @@ void InitGame()
     {
       Feld[x][y] = Ur[x][y];
       MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
+      ChangeDelay[x][y] = 0;
       Store[x][y] = Store2[x][y] = StorePlayer[x][y] = Back[x][y] = 0;
       AmoebaNr[x][y] = 0;
       JustStopped[x][y] = 0;
@@ -1530,6 +1599,7 @@ static void RemoveField(int x, int y)
   MovPos[x][y] = 0;
   MovDir[x][y] = 0;
   MovDelay[x][y] = 0;
+  ChangeDelay[x][y] = 0;
 }
 
 void RemoveMovingField(int x, int y)
@@ -1566,6 +1636,7 @@ void RemoveMovingField(int x, int y)
   Feld[newx][newy] = EL_EMPTY;
   MovPos[oldx][oldy] = MovDir[oldx][oldy] = MovDelay[oldx][oldy] = 0;
   MovPos[newx][newy] = MovDir[newx][newy] = MovDelay[newx][newy] = 0;
+  ChangeDelay[oldx][oldy] = ChangeDelay[newx][newy] = 0;
   GfxAction[oldx][oldy] = GfxAction[newx][newy] = ACTION_DEFAULT;
 
   DrawLevelField(oldx, oldy);
@@ -1786,7 +1857,11 @@ void Explode(int ex, int ey, int phase, int mode)
       }
 
       Feld[x][y] = EL_EXPLOSION;
+#if 1
+      GfxElement[x][y] = center_element;
+#else
       GfxElement[x][y] = EL_UNDEFINED;
+#endif
       MovDir[x][y] = MovPos[x][y] = 0;
       AmoebaNr[x][y] = 0;
       ExplodePhase[x][y] = 1;
@@ -1841,12 +1916,13 @@ void Explode(int ex, int ey, int phase, int mode)
 
     element = Feld[x][y] = Store[x][y];
     Store[x][y] = Store2[x][y] = 0;
+    GfxElement[x][y] = EL_UNDEFINED;
 
     if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
       element = Feld[x][y] = Back[x][y];
     Back[x][y] = 0;
 
-    MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = 0;
+    MovDir[x][y] = MovPos[x][y] = MovDelay[x][y] = ChangeDelay[x][y] = 0;
     InitField(x, y, FALSE);
     if (CAN_MOVE(element))
       InitMovDir(x, y);
@@ -1857,10 +1933,14 @@ void Explode(int ex, int ey, int phase, int mode)
   }
   else if (phase >= delay && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
   {
+#if 1
+    int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
+#else
     int stored = Store[x][y];
     int graphic = (game.emulation != EMU_SUPAPLEX ? IMG_EXPLOSION :
 		   stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON :
 		   IMG_SP_EXPLOSION);
+#endif
     int frame = getGraphicAnimationFrame(graphic, phase - delay);
 
     if (phase == delay)
@@ -1937,10 +2017,22 @@ void Bang(int x, int y)
 {
   int element = Feld[x][y];
 
+  if (IS_PLAYER(x, y))
+  {
+    struct PlayerInfo *player = PLAYERINFO(x, y);
+
+    element = Feld[x][y] = (player->use_murphy_graphic ? EL_SP_MURPHY :
+			    player->element_nr);
+  }
+
+#if 1
+  PlaySoundLevelAction(x, y, ACTION_EXPLODING);
+#else
   if (game.emulation == EMU_SUPAPLEX)
     PlaySoundLevel(x, y, SND_SP_ELEMENT_EXPLODING);
   else
     PlaySoundLevel(x, y, SND_ELEMENT_EXPLODING);
+#endif
 
 #if 0
   if (IS_PLAYER(x, y))	/* remove objects that might cause smaller explosion */
@@ -1982,6 +2074,8 @@ void Bang(int x, int y)
       Explode(x, y, EX_PHASE_START, EX_NORMAL);
       break;
   }
+
+  CheckTriggeredElementChange(element, CE_OTHER_EXPLODING);
 }
 
 void SplashAcid(int x, int y)
@@ -2316,19 +2410,22 @@ void Impact(int x, int y)
 {
   boolean lastline = (y == lev_fieldy-1);
   boolean object_hit = FALSE;
+  boolean impact = (lastline || object_hit);
   int element = Feld[x][y];
-  int smashed = 0;
+  int smashed = EL_UNDEFINED;
 
   if (!lastline)	/* check if element below was hit */
   {
-    if (Feld[x][y+1] == EL_PLAYER_IS_LEAVING)
+    if (Feld[x][y + 1] == EL_PLAYER_IS_LEAVING)
       return;
 
-    object_hit = (!IS_FREE(x, y+1) && (!IS_MOVING(x, y+1) ||
-				      MovDir[x][y+1] != MV_DOWN ||
-				      MovPos[x][y+1] <= TILEY / 2));
+    object_hit = (!IS_FREE(x, y + 1) && (!IS_MOVING(x, y + 1) ||
+					 MovDir[x][y + 1] != MV_DOWN ||
+					 MovPos[x][y + 1] <= TILEY / 2));
     if (object_hit)
-      smashed = MovingOrBlocked2Element(x, y+1);
+      smashed = MovingOrBlocked2Element(x, y + 1);
+
+    impact = (lastline || object_hit);
   }
 
   if (!lastline && smashed == EL_ACID)	/* element falls into acid */
@@ -2337,33 +2434,39 @@ void Impact(int x, int y)
     return;
   }
 
-  if (lastline || object_hit)
+  if (impact)
   {
     ResetGfxAnimation(x, y);
     DrawLevelField(x, y);
   }
 
-  if ((element == EL_BOMB ||
-       element == EL_SP_DISK_ORANGE ||
-       element == EL_DX_SUPABOMB) &&
-      (lastline || object_hit))		/* element is bomb */
+  if (impact && CAN_EXPLODE_IMPACT(element))
   {
     Bang(x, y);
     return;
   }
-  else if (element == EL_PEARL)
+  else if (impact && element == EL_PEARL)
   {
     Feld[x][y] = EL_PEARL_BREAKING;
     PlaySoundLevel(x, y, SND_PEARL_BREAKING);
     return;
   }
+  else if (impact && CAN_CHANGE(element) &&
+	   HAS_CHANGE_EVENT(element, CE_IMPACT))
+  {
+    PlaySoundLevelElementAction(x, y, element, ACTION_IMPACT);
+
+    ChangeElementDoIt(x, y, element_info[element].change.successor);
+
+    return;
+  }
 
-  if (element == EL_AMOEBA_DROP && (lastline || object_hit))
+  if (impact && element == EL_AMOEBA_DROP)
   {
-    if (object_hit && IS_PLAYER(x, y+1))
-      KillHeroUnlessProtected(x, y+1);
+    if (object_hit && IS_PLAYER(x, y + 1))
+      KillHeroUnlessProtected(x, y + 1);
     else if (object_hit && smashed == EL_PENGUIN)
-      Bang(x, y+1);
+      Bang(x, y + 1);
     else
     {
       Feld[x][y] = EL_AMOEBA_GROWING;
@@ -2374,7 +2477,7 @@ void Impact(int x, int y)
     return;
   }
 
-  if (!lastline && object_hit)		/* check which object was hit */
+  if (object_hit)		/* check which object was hit */
   {
     if (CAN_PASS_MAGIC_WALL(element) && 
 	(smashed == EL_MAGIC_WALL ||
@@ -2401,13 +2504,19 @@ void Impact(int x, int y)
 
     if (IS_PLAYER(x, y + 1))
     {
-      KillHeroUnlessProtected(x, y+1);
-      return;
+      if (CAN_SMASH_PLAYER(element))
+      {
+	KillHeroUnlessProtected(x, y + 1);
+	return;
+      }
     }
     else if (smashed == EL_PENGUIN)
     {
-      Bang(x, y + 1);
-      return;
+      if (CAN_SMASH_PLAYER(element))
+      {
+	Bang(x, y + 1);
+	return;
+      }
     }
     else if (element == EL_BD_DIAMOND)
     {
@@ -2426,23 +2535,15 @@ void Impact(int x, int y)
       Bang(x, y + 1);
       return;
     }
-    else if (element == EL_ROCK ||
-	     element == EL_SP_ZONK ||
-	     element == EL_BD_ROCK)
+    else if (CAN_SMASH_EVERYTHING(element))
     {
       if (IS_CLASSIC_ENEMY(smashed) ||
-	  smashed == EL_BOMB ||
-	  smashed == EL_SP_DISK_ORANGE ||
-	  smashed == EL_DX_SUPABOMB ||
-	  smashed == EL_SATELLITE ||
-	  smashed == EL_PIG ||
-	  smashed == EL_DRAGON ||
-	  smashed == EL_MOLE)
+	  CAN_EXPLODE_SMASHED(smashed))
       {
 	Bang(x, y + 1);
 	return;
       }
-      else if (!IS_MOVING(x, y + 1))
+      else if (!IS_MOVING(x, y + 1) && !IS_BLOCKED(x, y + 1))
       {
 	if (smashed == EL_LAMP ||
 	    smashed == EL_LAMP_ACTIVE)
@@ -2452,36 +2553,41 @@ void Impact(int x, int y)
 	}
 	else if (smashed == EL_NUT)
 	{
-	  Feld[x][y+1] = EL_NUT_BREAKING;
+	  Feld[x][y + 1] = EL_NUT_BREAKING;
 	  PlaySoundLevel(x, y, SND_NUT_BREAKING);
 	  RaiseScoreElement(EL_NUT);
 	  return;
 	}
 	else if (smashed == EL_PEARL)
 	{
-	  Feld[x][y+1] = EL_PEARL_BREAKING;
+	  Feld[x][y + 1] = EL_PEARL_BREAKING;
 	  PlaySoundLevel(x, y, SND_PEARL_BREAKING);
 	  return;
 	}
 	else if (smashed == EL_DIAMOND)
 	{
-	  Feld[x][y+1] = EL_EMPTY;
+	  Feld[x][y + 1] = EL_DIAMOND_BREAKING;
 	  PlaySoundLevel(x, y, SND_DIAMOND_BREAKING);
 	  return;
 	}
 	else if (IS_BELT_SWITCH(smashed))
 	{
-	  ToggleBeltSwitch(x, y+1);
+	  ToggleBeltSwitch(x, y + 1);
 	}
 	else if (smashed == EL_SWITCHGATE_SWITCH_UP ||
 		 smashed == EL_SWITCHGATE_SWITCH_DOWN)
 	{
-	  ToggleSwitchgateSwitch(x, y+1);
+	  ToggleSwitchgateSwitch(x, y + 1);
 	}
 	else if (smashed == EL_LIGHT_SWITCH ||
 		 smashed == EL_LIGHT_SWITCH_ACTIVE)
 	{
-	  ToggleLightSwitch(x, y+1);
+	  ToggleLightSwitch(x, y + 1);
+	}
+	else if (CAN_CHANGE(smashed) &&
+		 HAS_CHANGE_EVENT(smashed, CE_SMASHED))
+	{
+	  ChangeElementDoIt(x, y + 1, element_info[smashed].change.successor);
 	}
       }
     }
@@ -2489,12 +2595,12 @@ void Impact(int x, int y)
 
   /* play sound of magic wall / mill */
   if (!lastline &&
-      (Feld[x][y+1] == EL_MAGIC_WALL_ACTIVE ||
-       Feld[x][y+1] == EL_BD_MAGIC_WALL_ACTIVE))
+      (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
+       Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
   {
-    if (Feld[x][y+1] == EL_MAGIC_WALL_ACTIVE)
+    if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
       PlaySoundLevel(x, y, SND_MAGIC_WALL_FILLING);
-    else if (Feld[x][y+1] == EL_BD_MAGIC_WALL_ACTIVE)
+    else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
       PlaySoundLevel(x, y, SND_BD_MAGIC_WALL_FILLING);
 
     return;
@@ -2530,7 +2636,9 @@ void TurnRound(int x, int y)
     { MV_UP,	MV_DOWN,	MV_LEFT	 },
     { 0,	0,		0	 },
     { MV_LEFT,	MV_RIGHT,	MV_DOWN	 },
-    { 0,0,0 },	{ 0,0,0 },	{ 0,0,0	 },
+    { 0,	0,		0	 },
+    { 0,	0,		0	 },
+    { 0,	0,		0	 },
     { MV_RIGHT,	MV_LEFT,	MV_UP	 }
   };
 
@@ -2549,15 +2657,15 @@ void TurnRound(int x, int y)
   int right_x = x + right_dx, right_y = y + right_dy;
   int move_x  = x + move_dx,  move_y  = y + move_dy;
 
+  int xx, yy;
+
   if (element == EL_BUG || element == EL_BD_BUTTERFLY)
   {
     TestIfBadThingTouchesOtherBadThing(x, y);
 
-    if (IN_LEV_FIELD(right_x, right_y) &&
-	IS_FREE(right_x, right_y))
+    if (ENEMY_CAN_ENTER_FIELD(right_x, right_y))
       MovDir[x][y] = right_dir;
-    else if (!IN_LEV_FIELD(move_x, move_y) ||
-	     !IS_FREE(move_x, move_y))
+    else if (!ENEMY_CAN_ENTER_FIELD(move_x, move_y))
       MovDir[x][y] = left_dir;
 
     if (element == EL_BUG && MovDir[x][y] != old_move_dir)
@@ -2570,15 +2678,14 @@ void TurnRound(int x, int y)
   {
     TestIfBadThingTouchesOtherBadThing(x, y);
 
-    if (IN_LEV_FIELD(left_x, left_y) &&
-	IS_FREE(left_x, left_y))
+    if (ENEMY_CAN_ENTER_FIELD(left_x, left_y))
       MovDir[x][y] = left_dir;
-    else if (!IN_LEV_FIELD(move_x, move_y) ||
-	     !IS_FREE(move_x, move_y))
+    else if (!ENEMY_CAN_ENTER_FIELD(move_x, move_y))
       MovDir[x][y] = right_dir;
 
     if ((element == EL_SPACESHIP ||
-	 element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
+	 element == EL_SP_SNIKSNAK ||
+	 element == EL_SP_ELECTRON)
 	&& MovDir[x][y] != old_move_dir)
       MovDelay[x][y] = 9;
     else if (element == EL_BD_FIREFLY)	    /* && MovDir[x][y] == right_dir) */
@@ -2586,16 +2693,8 @@ void TurnRound(int x, int y)
   }
   else if (element == EL_YAMYAM)
   {
-    boolean can_turn_left = FALSE, can_turn_right = FALSE;
-
-    if (IN_LEV_FIELD(left_x, left_y) &&
-	(IS_FREE_OR_PLAYER(left_x, left_y) ||
-	 Feld[left_x][left_y] == EL_DIAMOND))
-      can_turn_left = TRUE;
-    if (IN_LEV_FIELD(right_x, right_y) &&
-	(IS_FREE_OR_PLAYER(right_x, right_y) ||
-	 Feld[right_x][right_y] == EL_DIAMOND))
-      can_turn_right = TRUE;
+    boolean can_turn_left  = YAMYAM_CAN_ENTER_FIELD(left_x, left_y);
+    boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(right_x, right_y);
 
     if (can_turn_left && can_turn_right)
       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
@@ -2606,20 +2705,12 @@ void TurnRound(int x, int y)
     else
       MovDir[x][y] = back_dir;
 
-    MovDelay[x][y] = 16+16*RND(3);
+    MovDelay[x][y] = 16 + 16 * RND(3);
   }
   else if (element == EL_DARK_YAMYAM)
   {
-    boolean can_turn_left = FALSE, can_turn_right = FALSE;
-
-    if (IN_LEV_FIELD(left_x, left_y) &&
-	(IS_FREE_OR_PLAYER(left_x, left_y) ||
-	 IS_FOOD_DARK_YAMYAM(Feld[left_x][left_y])))
-      can_turn_left = TRUE;
-    if (IN_LEV_FIELD(right_x, right_y) &&
-	(IS_FREE_OR_PLAYER(right_x, right_y) ||
-	 IS_FOOD_DARK_YAMYAM(Feld[right_x][right_y])))
-      can_turn_right = TRUE;
+    boolean can_turn_left  = DARK_YAMYAM_CAN_ENTER_FIELD(left_x, left_y);
+    boolean can_turn_right = DARK_YAMYAM_CAN_ENTER_FIELD(right_x, right_y);
 
     if (can_turn_left && can_turn_right)
       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
@@ -2630,20 +2721,12 @@ void TurnRound(int x, int y)
     else
       MovDir[x][y] = back_dir;
 
-    MovDelay[x][y] = 16+16*RND(3);
+    MovDelay[x][y] = 16 + 16 * RND(3);
   }
   else if (element == EL_PACMAN)
   {
-    boolean can_turn_left = FALSE, can_turn_right = FALSE;
-
-    if (IN_LEV_FIELD(left_x, left_y) &&
-	(IS_FREE_OR_PLAYER(left_x, left_y) ||
-	 IS_AMOEBOID(Feld[left_x][left_y])))
-      can_turn_left = TRUE;
-    if (IN_LEV_FIELD(right_x, right_y) &&
-	(IS_FREE_OR_PLAYER(right_x, right_y) ||
-	 IS_AMOEBOID(Feld[right_x][right_y])))
-      can_turn_right = TRUE;
+    boolean can_turn_left  = PACMAN_CAN_ENTER_FIELD(left_x, left_y);
+    boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(right_x, right_y);
 
     if (can_turn_left && can_turn_right)
       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
@@ -2654,56 +2737,45 @@ void TurnRound(int x, int y)
     else
       MovDir[x][y] = back_dir;
 
-    MovDelay[x][y] = 6+RND(40);
+    MovDelay[x][y] = 6 + RND(40);
   }
   else if (element == EL_PIG)
   {
-    boolean can_turn_left = FALSE, can_turn_right = FALSE, can_move_on = FALSE;
-    boolean should_turn_left = FALSE, should_turn_right = FALSE;
-    boolean should_move_on = FALSE;
+    boolean can_turn_left  = PIG_CAN_ENTER_FIELD(left_x, left_y);
+    boolean can_turn_right = PIG_CAN_ENTER_FIELD(right_x, right_y);
+    boolean can_move_on    = PIG_CAN_ENTER_FIELD(move_x, move_y);
+    boolean should_turn_left, should_turn_right, should_move_on;
     int rnd_value = 24;
     int rnd = RND(rnd_value);
 
-    if (IN_LEV_FIELD(left_x, left_y) &&
-	(IS_FREE(left_x, left_y) || IS_FOOD_PIG(Feld[left_x][left_y])))
-      can_turn_left = TRUE;
-    if (IN_LEV_FIELD(right_x, right_y) &&
-	(IS_FREE(right_x, right_y) || IS_FOOD_PIG(Feld[right_x][right_y])))
-      can_turn_right = TRUE;
-    if (IN_LEV_FIELD(move_x, move_y) &&
-	(IS_FREE(move_x, move_y) || IS_FOOD_PIG(Feld[move_x][move_y])))
-      can_move_on = TRUE;
-
-    if (can_turn_left &&
-	(!can_move_on ||
-	 (IN_LEV_FIELD(x+back_dx+left_dx, y+back_dy+left_dy) &&
-	  !IS_FREE(x+back_dx+left_dx, y+back_dy+left_dy))))
-      should_turn_left = TRUE;
-    if (can_turn_right &&
-	(!can_move_on ||
-	 (IN_LEV_FIELD(x+back_dx+right_dx, y+back_dy+right_dy) &&
-	  !IS_FREE(x+back_dx+right_dx, y+back_dy+right_dy))))
-      should_turn_right = TRUE;
-    if (can_move_on &&
-	(!can_turn_left || !can_turn_right ||
-	 (IN_LEV_FIELD(x+move_dx+left_dx, y+move_dy+left_dy) &&
-	  !IS_FREE(x+move_dx+left_dx, y+move_dy+left_dy)) ||
-	 (IN_LEV_FIELD(x+move_dx+right_dx, y+move_dy+right_dy) &&
-	  !IS_FREE(x+move_dx+right_dx, y+move_dy+right_dy))))
-      should_move_on = TRUE;
+    should_turn_left = (can_turn_left &&
+			(!can_move_on ||
+			 IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + left_dx,
+						   y + back_dy + left_dy)));
+    should_turn_right = (can_turn_right &&
+			 (!can_move_on ||
+			  IN_LEV_FIELD_AND_NOT_FREE(x + back_dx + right_dx,
+						    y + back_dy + right_dy)));
+    should_move_on = (can_move_on &&
+		      (!can_turn_left ||
+		       !can_turn_right ||
+		       IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + left_dx,
+						 y + move_dy + left_dy) ||
+		       IN_LEV_FIELD_AND_NOT_FREE(x + move_dx + right_dx,
+						 y + move_dy + right_dy)));
 
     if (should_turn_left || should_turn_right || should_move_on)
     {
       if (should_turn_left && should_turn_right && should_move_on)
-	MovDir[x][y] = (rnd < rnd_value/3 ? left_dir :
-			rnd < 2*rnd_value/3 ? right_dir :
+	MovDir[x][y] = (rnd < rnd_value / 3     ? left_dir :
+			rnd < 2 * rnd_value / 3 ? right_dir :
 			old_move_dir);
       else if (should_turn_left && should_turn_right)
-	MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
+	MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
       else if (should_turn_left && should_move_on)
-	MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : old_move_dir);
+	MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : old_move_dir);
       else if (should_turn_right && should_move_on)
-	MovDir[x][y] = (rnd < rnd_value/2 ? right_dir : old_move_dir);
+	MovDir[x][y] = (rnd < rnd_value / 2 ? right_dir : old_move_dir);
       else if (should_turn_left)
 	MovDir[x][y] = left_dir;
       else if (should_turn_right)
@@ -2711,69 +2783,67 @@ void TurnRound(int x, int y)
       else if (should_move_on)
 	MovDir[x][y] = old_move_dir;
     }
-    else if (can_move_on && rnd > rnd_value/8)
+    else if (can_move_on && rnd > rnd_value / 8)
       MovDir[x][y] = old_move_dir;
     else if (can_turn_left && can_turn_right)
-      MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
-    else if (can_turn_left && rnd > rnd_value/8)
+      MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
+    else if (can_turn_left && rnd > rnd_value / 8)
       MovDir[x][y] = left_dir;
     else if (can_turn_right && rnd > rnd_value/8)
       MovDir[x][y] = right_dir;
     else
       MovDir[x][y] = back_dir;
 
-    if (!IS_FREE(x+move_xy[MovDir[x][y]].x, y+move_xy[MovDir[x][y]].y) &&
-	!IS_FOOD_PIG(Feld[x+move_xy[MovDir[x][y]].x][y+move_xy[MovDir[x][y]].y]))
+    xx = x + move_xy[MovDir[x][y]].x;
+    yy = y + move_xy[MovDir[x][y]].y;
+
+    if (!IS_FREE(xx, yy) && !IS_FOOD_PIG(Feld[xx][yy]))
       MovDir[x][y] = old_move_dir;
 
     MovDelay[x][y] = 0;
   }
   else if (element == EL_DRAGON)
   {
-    boolean can_turn_left = FALSE, can_turn_right = FALSE, can_move_on = FALSE;
+    boolean can_turn_left  = IN_LEV_FIELD_AND_IS_FREE(left_x, left_y);
+    boolean can_turn_right = IN_LEV_FIELD_AND_IS_FREE(right_x, right_y);
+    boolean can_move_on    = IN_LEV_FIELD_AND_IS_FREE(move_x, move_y);
     int rnd_value = 24;
     int rnd = RND(rnd_value);
 
-    if (IN_LEV_FIELD(left_x, left_y) && IS_FREE(left_x, left_y))
-      can_turn_left = TRUE;
-    if (IN_LEV_FIELD(right_x, right_y) && IS_FREE(right_x, right_y))
-      can_turn_right = TRUE;
-    if (IN_LEV_FIELD(move_x, move_y) && IS_FREE(move_x, move_y))
-      can_move_on = TRUE;
-
-    if (can_move_on && rnd > rnd_value/8)
+    if (can_move_on && rnd > rnd_value / 8)
       MovDir[x][y] = old_move_dir;
     else if (can_turn_left && can_turn_right)
-      MovDir[x][y] = (rnd < rnd_value/2 ? left_dir : right_dir);
-    else if (can_turn_left && rnd > rnd_value/8)
+      MovDir[x][y] = (rnd < rnd_value / 2 ? left_dir : right_dir);
+    else if (can_turn_left && rnd > rnd_value / 8)
       MovDir[x][y] = left_dir;
-    else if (can_turn_right && rnd > rnd_value/8)
+    else if (can_turn_right && rnd > rnd_value / 8)
       MovDir[x][y] = right_dir;
     else
       MovDir[x][y] = back_dir;
 
-    if (!IS_FREE(x+move_xy[MovDir[x][y]].x, y+move_xy[MovDir[x][y]].y))
+    xx = x + move_xy[MovDir[x][y]].x;
+    yy = y + move_xy[MovDir[x][y]].y;
+
+    if (!IS_FREE(xx, yy))
       MovDir[x][y] = old_move_dir;
 
     MovDelay[x][y] = 0;
   }
   else if (element == EL_MOLE)
   {
-    boolean can_turn_left = FALSE, can_turn_right = FALSE, can_move_on = FALSE;
-
-    if (IN_LEV_FIELD(move_x, move_y) &&
-	(IS_FREE(move_x, move_y) || IS_AMOEBOID(Feld[move_x][move_y]) ||
-	 Feld[move_x][move_y] == EL_AMOEBA_SHRINKING))
-      can_move_on = TRUE;
-
+    boolean can_move_on =
+      (MOLE_CAN_ENTER_FIELD(move_x, move_y,
+			    IS_AMOEBOID(Feld[move_x][move_y]) ||
+			    Feld[move_x][move_y] == EL_AMOEBA_SHRINKING));
     if (!can_move_on)
     {
-      if (IN_LEV_FIELD(left_x, left_y) &&
-	  (IS_FREE(left_x, left_y) || IS_AMOEBOID(Feld[left_x][left_y])))
-	can_turn_left = TRUE;
-      if (IN_LEV_FIELD(right_x, right_y) &&
-	  (IS_FREE(right_x, right_y) || IS_AMOEBOID(Feld[right_x][right_y])))
-	can_turn_right = TRUE;
+      boolean can_turn_left =
+	(MOLE_CAN_ENTER_FIELD(left_x, left_y,
+			      IS_AMOEBOID(Feld[left_x][left_y])));
+
+      boolean can_turn_right =
+	(MOLE_CAN_ENTER_FIELD(right_x, right_y,
+			      IS_AMOEBOID(Feld[right_x][right_y])));
 
       if (can_turn_left && can_turn_right)
 	MovDir[x][y] = (RND(2) ? left_dir : right_dir);
@@ -2793,9 +2863,9 @@ void TurnRound(int x, int y)
   }
   else if (element == EL_SPRING)
   {
-    if ((MovDir[x][y] == MV_LEFT || MovDir[x][y] == MV_RIGHT) &&
-	(!IN_LEV_FIELD(move_x, move_y) || !IS_FREE(move_x, move_y) ||
-	 (IN_LEV_FIELD(x, y + 1) && IS_FREE(x, y + 1))))
+    if (MovDir[x][y] & MV_HORIZONTAL &&
+	(!IN_LEV_FIELD_AND_IS_FREE(move_x, move_y) ||
+	 IN_LEV_FIELD_AND_IS_FREE(x, y + 1)))
       MovDir[x][y] = MV_NO_MOVING;
 
     MovDelay[x][y] = 0;
@@ -2823,7 +2893,8 @@ void TurnRound(int x, int y)
 	if (!player->active)
 	  continue;
 
-	if (attr_x == -1 || ABS(jx-x)+ABS(jy-y) < ABS(attr_x-x)+ABS(attr_y-y))
+	if (attr_x == -1 ||
+	    ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
 	{
 	  attr_x = jx;
 	  attr_y = jy;
@@ -2881,11 +2952,11 @@ void TurnRound(int x, int y)
       Moving2Blocked(x, y, &newx, &newy);
 
       if (IN_LEV_FIELD(newx, newy) && IS_FREE_OR_PLAYER(newx, newy))
-	MovDelay[x][y] = 8+8*!RND(3);
+	MovDelay[x][y] = 8 + 8 * !RND(3);
       else
 	MovDelay[x][y] = 16;
     }
-    else
+    else if (element == EL_PENGUIN)
     {
       int newx, newy;
 
@@ -2900,24 +2971,43 @@ void TurnRound(int x, int y)
 	  new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
 	Moving2Blocked(x, y, &newx, &newy);
 
-	if (IN_LEV_FIELD(newx, newy) &&
-	    (IS_FREE(newx, newy) ||
-	     Feld[newx][newy] == EL_ACID ||
-	     (element == EL_PENGUIN &&
-	      (Feld[newx][newy] == EL_EXIT_OPEN ||
-	       IS_FOOD_PENGUIN(Feld[newx][newy])))))
+	if (PENGUIN_CAN_ENTER_FIELD(newx, newy))
 	  return;
 
 	MovDir[x][y] =
 	  new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
 	Moving2Blocked(x, y, &newx, &newy);
 
-	if (IN_LEV_FIELD(newx, newy) &&
-	    (IS_FREE(newx, newy) ||
-	     Feld[newx][newy] == EL_ACID ||
-	     (element == EL_PENGUIN &&
-	      (Feld[newx][newy] == EL_EXIT_OPEN ||
-	       IS_FOOD_PENGUIN(Feld[newx][newy])))))
+	if (PENGUIN_CAN_ENTER_FIELD(newx, newy))
+	  return;
+
+	MovDir[x][y] = old_move_dir;
+	return;
+      }
+    }
+    else	/* (element == EL_SATELLITE) */
+    {
+      int newx, newy;
+
+      MovDelay[x][y] = 1;
+
+      if (MovDir[x][y] & MV_HORIZONTAL && MovDir[x][y] & MV_VERTICAL)
+      {
+	boolean first_horiz = RND(2);
+	int new_move_dir = MovDir[x][y];
+
+	MovDir[x][y] =
+	  new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
+	Moving2Blocked(x, y, &newx, &newy);
+
+	if (ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(newx, newy))
+	  return;
+
+	MovDir[x][y] =
+	  new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
+	Moving2Blocked(x, y, &newx, &newy);
+
+	if (ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(newx, newy))
 	  return;
 
 	MovDir[x][y] = old_move_dir;
@@ -2927,16 +3017,8 @@ void TurnRound(int x, int y)
   }
   else if (element_info[element].move_pattern == MV_ALL_DIRECTIONS)
   {
-    boolean can_turn_left = FALSE, can_turn_right = FALSE;
-
-    if (IN_LEV_FIELD(left_x, left_y) &&
-	(IS_FREE(left_x, left_y) ||
-	 (DONT_COLLIDE_WITH(element) && IS_FREE_OR_PLAYER(left_x, left_y))))
-      can_turn_left = TRUE;
-    if (IN_LEV_FIELD(right_x, right_y) &&
-	(IS_FREE(right_x, right_y) ||
-	 (DONT_COLLIDE_WITH(element) && IS_FREE_OR_PLAYER(right_x, right_y))))
-      can_turn_right = TRUE;
+    boolean can_turn_left  = ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y);
+    boolean can_turn_right = ELEMENT_CAN_ENTER_FIELD(element, right_x,right_y);
 
     if (can_turn_left && can_turn_right)
       MovDir[x][y] = (RND(3) ? (RND(2) ? left_dir : right_dir) : back_dir);
@@ -2968,13 +3050,9 @@ void TurnRound(int x, int y)
   }
   else if (element_info[element].move_pattern == MV_ALONG_LEFT_SIDE)
   {
-    if (IN_LEV_FIELD(left_x, left_y) &&
-	(IS_FREE(left_x, left_y) ||
-	 (DONT_COLLIDE_WITH(element) && IS_FREE_OR_PLAYER(left_x, left_y))))
+    if (ELEMENT_CAN_ENTER_FIELD(element, left_x, left_y))
       MovDir[x][y] = left_dir;
-    else if (!IN_LEV_FIELD(move_x, move_y) ||
-	     (!IS_FREE(move_x, move_y) &&
-	      (!DONT_COLLIDE_WITH(element) || !IS_FREE_OR_PLAYER(move_x, move_y))))
+    else if (!ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
       MovDir[x][y] = right_dir;
 
     if (MovDir[x][y] != old_move_dir)
@@ -2982,13 +3060,9 @@ void TurnRound(int x, int y)
   }
   else if (element_info[element].move_pattern == MV_ALONG_RIGHT_SIDE)
   {
-    if (IN_LEV_FIELD(right_x, right_y) &&
-	(IS_FREE(right_x, right_y) ||
-	 (DONT_COLLIDE_WITH(element) && IS_FREE_OR_PLAYER(right_x, right_y))))
+    if (ELEMENT_CAN_ENTER_FIELD(element, right_x, right_y))
       MovDir[x][y] = right_dir;
-    else if (!IN_LEV_FIELD(move_x, move_y) ||
-	     (!IS_FREE(move_x, move_y) &&
-	      (!DONT_COLLIDE_WITH(element) || !IS_FREE_OR_PLAYER(move_x, move_y))))
+    else if (!ELEMENT_CAN_ENTER_FIELD(element, move_x, move_y))
       MovDir[x][y] = left_dir;
 
     if (MovDir[x][y] != old_move_dir)
@@ -3019,7 +3093,8 @@ void TurnRound(int x, int y)
 	if (!player->active)
 	  continue;
 
-	if (attr_x == -1 || ABS(jx-x)+ABS(jy-y) < ABS(attr_x-x)+ABS(attr_y-y))
+	if (attr_x == -1 ||
+	    ABS(jx - x) + ABS(jy - y) < ABS(attr_x - x) + ABS(attr_y - y))
 	{
 	  attr_x = jx;
 	  attr_y = jy;
@@ -3048,20 +3123,14 @@ void TurnRound(int x, int y)
 	new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
       Moving2Blocked(x, y, &newx, &newy);
 
-      if (IN_LEV_FIELD(newx, newy) && (IS_FREE(newx, newy) ||
-				       (DONT_COLLIDE_WITH(element) &&
-					IS_FREE_OR_PLAYER(newx, newy)) ||
-				       Feld[newx][newy] == EL_ACID))
+      if (ELEMENT_CAN_ENTER_FIELD_OR_ACID(element, newx, newy))
 	return;
 
       MovDir[x][y] =
 	new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
       Moving2Blocked(x, y, &newx, &newy);
 
-      if (IN_LEV_FIELD(newx, newy) && (IS_FREE(newx, newy) ||
-				       (DONT_COLLIDE_WITH(element) &&
-					IS_FREE_OR_PLAYER(newx, newy)) ||
-				       Feld[newx][newy] == EL_ACID))
+      if (ELEMENT_CAN_ENTER_FIELD_OR_ACID(element, newx, newy))
 	return;
 
       MovDir[x][y] = old_move_dir;
@@ -3109,7 +3178,7 @@ void StartMoving(int x, int y)
 
     if (element == EL_QUICKSAND_FULL)
     {
-      if (IS_FREE(x, y+1))
+      if (IS_FREE(x, y + 1))
       {
 	InitMovingField(x, y, MV_DOWN);
 	started_moving = TRUE;
@@ -3122,7 +3191,7 @@ void StartMoving(int x, int y)
 	PlaySoundLevel(x, y, SND_QUICKSAND_EMPTYING);
 #endif
       }
-      else if (Feld[x][y+1] == EL_QUICKSAND_EMPTY)
+      else if (Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
       {
 	if (!MovDelay[x][y])
 	  MovDelay[x][y] = TILEY + 1;
@@ -3135,8 +3204,8 @@ void StartMoving(int x, int y)
 	}
 
 	Feld[x][y] = EL_QUICKSAND_EMPTY;
-	Feld[x][y+1] = EL_QUICKSAND_FULL;
-	Store[x][y+1] = Store[x][y];
+	Feld[x][y + 1] = EL_QUICKSAND_FULL;
+	Store[x][y + 1] = Store[x][y];
 	Store[x][y] = 0;
 #if 1
 	PlaySoundLevelAction(x, y, ACTION_FILLING);
@@ -3146,7 +3215,7 @@ void StartMoving(int x, int y)
       }
     }
     else if ((element == EL_ROCK || element == EL_BD_ROCK) &&
-	     Feld[x][y+1] == EL_QUICKSAND_EMPTY)
+	     Feld[x][y + 1] == EL_QUICKSAND_EMPTY)
     {
       InitMovingField(x, y, MV_DOWN);
       started_moving = TRUE;
@@ -3161,7 +3230,7 @@ void StartMoving(int x, int y)
     }
     else if (element == EL_MAGIC_WALL_FULL)
     {
-      if (IS_FREE(x, y+1))
+      if (IS_FREE(x, y + 1))
       {
 	InitMovingField(x, y, MV_DOWN);
 	started_moving = TRUE;
@@ -3169,7 +3238,7 @@ void StartMoving(int x, int y)
 	Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
 	Store[x][y] = EL_CHANGED(Store[x][y]);
       }
-      else if (Feld[x][y+1] == EL_MAGIC_WALL_ACTIVE)
+      else if (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE)
       {
 	if (!MovDelay[x][y])
 	  MovDelay[x][y] = TILEY/4 + 1;
@@ -3182,14 +3251,14 @@ void StartMoving(int x, int y)
 	}
 
 	Feld[x][y] = EL_MAGIC_WALL_ACTIVE;
-	Feld[x][y+1] = EL_MAGIC_WALL_FULL;
-	Store[x][y+1] = EL_CHANGED(Store[x][y]);
+	Feld[x][y + 1] = EL_MAGIC_WALL_FULL;
+	Store[x][y + 1] = EL_CHANGED(Store[x][y]);
 	Store[x][y] = 0;
       }
     }
     else if (element == EL_BD_MAGIC_WALL_FULL)
     {
-      if (IS_FREE(x, y+1))
+      if (IS_FREE(x, y + 1))
       {
 	InitMovingField(x, y, MV_DOWN);
 	started_moving = TRUE;
@@ -3197,7 +3266,7 @@ void StartMoving(int x, int y)
 	Feld[x][y] = EL_BD_MAGIC_WALL_EMPTYING;
 	Store[x][y] = EL_CHANGED2(Store[x][y]);
       }
-      else if (Feld[x][y+1] == EL_BD_MAGIC_WALL_ACTIVE)
+      else if (Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE)
       {
 	if (!MovDelay[x][y])
 	  MovDelay[x][y] = TILEY/4 + 1;
@@ -3210,27 +3279,27 @@ void StartMoving(int x, int y)
 	}
 
 	Feld[x][y] = EL_BD_MAGIC_WALL_ACTIVE;
-	Feld[x][y+1] = EL_BD_MAGIC_WALL_FULL;
-	Store[x][y+1] = EL_CHANGED2(Store[x][y]);
+	Feld[x][y + 1] = EL_BD_MAGIC_WALL_FULL;
+	Store[x][y + 1] = EL_CHANGED2(Store[x][y]);
 	Store[x][y] = 0;
       }
     }
     else if (CAN_PASS_MAGIC_WALL(element) &&
-	     (Feld[x][y+1] == EL_MAGIC_WALL_ACTIVE ||
-	      Feld[x][y+1] == EL_BD_MAGIC_WALL_ACTIVE))
+	     (Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ||
+	      Feld[x][y + 1] == EL_BD_MAGIC_WALL_ACTIVE))
     {
       InitMovingField(x, y, MV_DOWN);
       started_moving = TRUE;
 
       Feld[x][y] =
-	(Feld[x][y+1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
+	(Feld[x][y + 1] == EL_MAGIC_WALL_ACTIVE ? EL_MAGIC_WALL_FILLING :
 	 EL_BD_MAGIC_WALL_FILLING);
       Store[x][y] = element;
     }
 #if 0
-    else if (CAN_SMASH(element) && Feld[x][y+1] == EL_ACID)
+    else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_ACID)
 #else
-    else if (CAN_FALL(element) && Feld[x][y+1] == EL_ACID)
+    else if (CAN_FALL(element) && Feld[x][y + 1] == EL_ACID)
 #endif
     {
       SplashAcid(x, y);
@@ -3241,15 +3310,15 @@ void StartMoving(int x, int y)
       Store[x][y] = EL_ACID;
 #if 0
       /* !!! TEST !!! better use "_FALLING" etc. !!! */
-      GfxAction[x][y+1] = ACTION_ACTIVE;
+      GfxAction[x][y + 1] = ACTION_ACTIVE;
 #endif
     }
-    else if (CAN_SMASH(element) && Feld[x][y+1] == EL_BLOCKED &&
+    else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
 	     JustStopped[x][y])
     {
       Impact(x, y);
     }
-    else if (IS_FREE(x, y+1) && element == EL_SPRING && use_spring_bug)
+    else if (IS_FREE(x, y + 1) && element == EL_SPRING && use_spring_bug)
     {
       if (MovDir[x][y] == MV_NO_MOVING)
       {
@@ -3257,7 +3326,7 @@ void StartMoving(int x, int y)
 	started_moving = TRUE;
       }
     }
-    else if (IS_FREE(x, y+1))
+    else if (IS_FREE(x, y + 1) || Feld[x][y + 1] == EL_DIAMOND_BREAKING)
     {
       if (JustStopped[x][y])	/* prevent animation from being restarted */
 	MovDir[x][y] = MV_DOWN;
@@ -3270,28 +3339,28 @@ void StartMoving(int x, int y)
       Feld[x][y] = EL_AMOEBA_GROWING;
       Store[x][y] = EL_AMOEBA_WET;
     }
-    /* Store[x][y+1] must be zero, because:
-       (EL_QUICKSAND_FULL -> EL_ROCK): Store[x][y+1] == EL_QUICKSAND_EMPTY
+    /* Store[x][y + 1] must be zero, because:
+       (EL_QUICKSAND_FULL -> EL_ROCK): Store[x][y + 1] == EL_QUICKSAND_EMPTY
     */
 #if 0
 #if OLD_GAME_BEHAVIOUR
-    else if (IS_SLIPPERY(Feld[x][y+1]) && !Store[x][y+1])
+    else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1])
 #else
-    else if (IS_SLIPPERY(Feld[x][y+1]) && !Store[x][y+1] &&
-	     !IS_FALLING(x, y+1) && !JustStopped[x][y+1] &&
+    else if (IS_SLIPPERY(Feld[x][y + 1]) && !Store[x][y + 1] &&
+	     !IS_FALLING(x, y + 1) && !JustStopped[x][y + 1] &&
 	     element != EL_DX_SUPABOMB)
 #endif
 #else
-    else if ((IS_SLIPPERY(Feld[x][y+1]) ||
-	      (IS_EM_SLIPPERY_WALL(Feld[x][y+1]) && IS_GEM(element))) &&
-	     !IS_FALLING(x, y+1) && !JustStopped[x][y+1] &&
+    else if ((IS_SLIPPERY(Feld[x][y + 1]) ||
+	      (IS_EM_SLIPPERY_WALL(Feld[x][y + 1]) && IS_GEM(element))) &&
+	     !IS_FALLING(x, y + 1) && !JustStopped[x][y + 1] &&
 	     element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
 #endif
     {
       boolean left  = (x>0 && IS_FREE(x-1, y) &&
-		       (IS_FREE(x-1, y+1) || Feld[x-1][y+1] == EL_ACID));
+		       (IS_FREE(x-1, y + 1) || Feld[x-1][y + 1] == EL_ACID));
       boolean right = (x<lev_fieldx-1 && IS_FREE(x+1, y) &&
-		       (IS_FREE(x+1, y+1) || Feld[x+1][y+1] == EL_ACID));
+		       (IS_FREE(x+1, y + 1) || Feld[x+1][y + 1] == EL_ACID));
 
       if (left || right)
       {
@@ -3304,11 +3373,11 @@ void StartMoving(int x, int y)
 	started_moving = TRUE;
       }
     }
-    else if (IS_BELT_ACTIVE(Feld[x][y+1]))
+    else if (IS_BELT_ACTIVE(Feld[x][y + 1]))
     {
       boolean left_is_free  = (x>0 && IS_FREE(x-1, y));
       boolean right_is_free = (x<lev_fieldx-1 && IS_FREE(x+1, y));
-      int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y+1]);
+      int belt_nr = getBeltNrFromBeltActiveElement(Feld[x][y + 1]);
       int belt_dir = game.belt_dir[belt_nr];
 
       if ((belt_dir == MV_LEFT  && left_is_free) ||
@@ -3708,7 +3777,7 @@ void ContinueMoving(int x, int y)
   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
   int horiz_move = (dx != 0);
   int newx = x + dx, newy = y + dy;
-  int step = (horiz_move ? dx : dy) * TILEX / 8;
+  int step = (horiz_move ? dx : dy) * TILEX / MOVE_DELAY_NORMAL_SPEED;
 
   if (element == EL_AMOEBA_DROP || element == EL_AMOEBA_DROPPING)
     step /= 2;
@@ -3725,6 +3794,8 @@ void ContinueMoving(int x, int y)
     step /= 2;
   else if (element == EL_SPRING && horiz_move)
     step *= 2;
+  else if (IS_CUSTOM_ELEMENT(element))
+    step = SIGN(step) * element_info[element].move_stepsize;
 
 #if OLD_GAME_BEHAVIOUR
   else if (CAN_FALL(element) && horiz_move && !IS_SP_ELEMENT(element))
@@ -3737,6 +3808,7 @@ void ContinueMoving(int x, int y)
   {
     Feld[x][y] = EL_EMPTY;
     Feld[newx][newy] = element;
+    MovPos[x][y] = 0;	/* force "not moving" for "crumbled sand" */
 
     if (element == EL_MOLE)
     {
@@ -3816,6 +3888,9 @@ void ContinueMoving(int x, int y)
     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
     MovDelay[newx][newy] = 0;
 
+    /* copy element change control values to new field */
+    ChangeDelay[newx][newy] = ChangeDelay[x][y];
+
     /* copy animation control values to new field */
     GfxFrame[newx][newy]  = GfxFrame[x][y];
     GfxAction[newx][newy] = GfxAction[x][y];	/* keep action one frame */
@@ -3854,9 +3929,15 @@ void ContinueMoving(int x, int y)
     else if (element == EL_PENGUIN)
       TestIfFriendTouchesBadThing(newx, newy);
 
+#if 1
+    if (CAN_FALL(element) && direction == MV_DOWN &&
+	(newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1)))
+      Impact(x, newy);
+#else
     if (CAN_SMASH(element) && direction == MV_DOWN &&
 	(newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1)))
       Impact(x, newy);
+#endif
   }
   else				/* still moving on */
   {
@@ -4354,7 +4435,7 @@ void Life(int ax, int ay)
 
 static void InitRobotWheel(int x, int y)
 {
-  MovDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
+  ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
 }
 
 static void RunRobotWheel(int x, int y)
@@ -4370,7 +4451,7 @@ static void StopRobotWheel(int x, int y)
 
 static void InitTimegateWheel(int x, int y)
 {
-  MovDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
+  ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
 }
 
 static void RunTimegateWheel(int x, int y)
@@ -4696,7 +4777,7 @@ static void InitBuggyBase(int x, int y)
   int element = Feld[x][y];
   int activating_delay = FRAMES_PER_SECOND / 4;
 
-  MovDelay[x][y] =
+  ChangeDelay[x][y] =
     (element == EL_SP_BUGGY_BASE ?
      2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND) - activating_delay :
      element == EL_SP_BUGGY_BASE_ACTIVATING ?
@@ -4731,7 +4812,7 @@ static void WarnBuggyBase(int x, int y)
 
 static void InitTrap(int x, int y)
 {
-  MovDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
+  ChangeDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
 }
 
 static void ActivateTrap(int x, int y)
@@ -4748,23 +4829,66 @@ static void ChangeActiveTrap(int x, int y)
     DrawLevelFieldCrumbledSand(x, y);
 }
 
+static void ChangeElementDoIt(int x, int y, int element_new)
+{
+  CheckTriggeredElementChange(Feld[x][y], CE_OTHER_CHANGING);
+
+  RemoveField(x, y);
+  Feld[x][y] = element_new;
+
+  ResetGfxAnimation(x, y);
+  ResetRandomAnimationValue(x, y);
+
+  InitField(x, y, FALSE);
+  if (CAN_MOVE(Feld[x][y]))
+    InitMovDir(x, y);
+
+  DrawLevelField(x, y);
+
+  if (CAN_BE_CRUMBLED(Feld[x][y]))
+  {
+    int sx = SCREENX(x), sy = SCREENY(y);
+    static int xy[4][2] =
+    {
+      { 0, -1 },
+      { -1, 0 },
+      { +1, 0 },
+      { 0, +1 }
+    };
+    int i;
+
+    for(i=0; i<4; i++)
+    {
+      int xx = x + xy[i][0];
+      int yy = y + xy[i][1];
+      int sxx = sx + xy[i][0];
+      int syy = sy + xy[i][1];
+
+      if (!IN_LEV_FIELD(xx, yy) ||
+	  !IN_SCR_FIELD(sxx, syy) ||
+	  !CAN_BE_CRUMBLED(Feld[xx][yy]) ||
+	  IS_MOVING(xx, yy))
+	continue;
+
+      DrawLevelField(xx, yy);
+    }
+  }
+}
+
 static void ChangeElement(int x, int y)
 {
   int element = Feld[x][y];
 
-  if (IS_MOVING(x, y))			/* never change a running system :-) */
-    return;
-
-  if (MovDelay[x][y] == 0)		/* initialize element change */
+  if (ChangeDelay[x][y] == 0)		/* initialize element change */
   {
-    MovDelay[x][y] = changing_element[element].change_delay + 1;
+    ChangeDelay[x][y] = changing_element[element].change_delay + 1;
 
     if (IS_CUSTOM_ELEMENT(element) && HAS_CHANGE_EVENT(element, CE_DELAY))
     {
       int max_random_delay = element_info[element].change.delay_random;
       int delay_frames = element_info[element].change.delay_frames;
 
-      MovDelay[x][y] += RND(max_random_delay * delay_frames);
+      ChangeDelay[x][y] += RND(max_random_delay * delay_frames);
     }
 
     ResetGfxAnimation(x, y);
@@ -4774,35 +4898,81 @@ static void ChangeElement(int x, int y)
       changing_element[element].pre_change_function(x, y);
   }
 
-  MovDelay[x][y]--;
+  ChangeDelay[x][y]--;
 
-  if (MovDelay[x][y] != 0)		/* continue element change */
+  if (ChangeDelay[x][y] != 0)		/* continue element change */
   {
-    if (IS_ANIMATED(el2img(element)))
-      DrawLevelElementAnimationIfNeeded(x, y, element);
+    int graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
+
+    if (IS_ANIMATED(graphic))
+      DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
 
     if (changing_element[element].change_function)
       changing_element[element].change_function(x, y);
   }
   else					/* finish element change */
   {
-    Feld[x][y] = changing_element[element].next_element;
+    int next_element = changing_element[element].next_element;
 
-    ResetGfxAnimation(x, y);
-    ResetRandomAnimationValue(x, y);
+    if (IS_MOVING(x, y))		/* never change a running system ;-) */
+    {
+      ChangeDelay[x][y] = 1;		/* try change after next move step */
 
-#if 1
-    InitField(x, y, FALSE);
-    if (CAN_MOVE(element))
-      InitMovDir(x, y);
-#endif
-    DrawLevelField(x, y);
+      return;
+    }
+
+    if (next_element != EL_UNDEFINED)
+      ChangeElementDoIt(x, y, next_element);
+    else
+      ChangeElementDoIt(x, y, element_info[element].change.successor);
 
     if (changing_element[element].post_change_function)
       changing_element[element].post_change_function(x, y);
   }
 }
 
+static void CheckTriggeredElementChange(int trigger_element, int trigger_event)
+{
+  int i, x, y;
+
+  if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
+    return;
+
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
+  {
+    if (!CAN_CHANGE(i) || !HAS_CHANGE_EVENT(i, trigger_event) ||
+	element_info[i].change.trigger != trigger_element)
+      continue;
+
+    for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
+    {
+      if (Feld[x][y] == i)
+      {
+	ChangeDelay[x][y] = 1;
+	ChangeElement(x, y);
+      }
+    }
+  }
+}
+
+static void CheckPlayerElementChange(int x, int y, int element,
+				     int trigger_event)
+{
+  if (!CAN_CHANGE(element) || !HAS_CHANGE_EVENT(element, trigger_event))
+    return;
+
+  if (trigger_event == CE_PUSHED_BY_PLAYER)
+  {
+#if 0
+    /* !!! does not work -- debug !!! */
+    ChangeDelay[x][y] = 2;	/* give one frame (+1) to start pushing */
+    ChangeElement(x, y);
+#endif
+  }
+  else
+    ChangeElementDoIt(x, y, element_info[element].change.successor);
+}
+
 static void PlayerActions(struct PlayerInfo *player, byte player_action)
 {
   static byte stored_player_action[MAX_PLAYERS];
@@ -5033,6 +5203,16 @@ void GameActions()
       continue;
     }
 
+#if 1
+    /* this may take place after moving, so 'element' may have changed */
+    if (IS_CHANGING(x, y))
+    {
+      ChangeElement(x, y);
+      element = Feld[x][y];
+      graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
+    }
+#endif
+
     if (!IS_MOVING(x, y) && (CAN_FALL(element) || CAN_MOVE(element)))
     {
       StartMoving(x, y);
@@ -5115,11 +5295,11 @@ void GameActions()
 #endif
     else if (element == EL_EXPLOSION)
       ;	/* drawing of correct explosion animation is handled separately */
-    else if (IS_ANIMATED(graphic) && !IS_AUTO_CHANGING(element))
+    else if (IS_ANIMATED(graphic) && !IS_CHANGING(x, y))
       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
 
-#if 1
-    /* this may take place after moving, therefore element may have changed */
+#if 0
+    /* this may take place after moving, so 'element' may have changed */
     if (IS_AUTO_CHANGING(Feld[x][y]))
       ChangeElement(x, y);
 #endif
@@ -6053,7 +6233,11 @@ void BuryHero(struct PlayerInfo *player)
   if (!player->active)
     return;
 
+#if 1
+  PlaySoundLevelElementAction(jx, jy, player->element_nr, ACTION_DYING);
+#else
   PlaySoundLevel(jx, jy, SND_CLASS_PLAYER_DYING);
+#endif
   PlaySoundLevel(jx, jy, SND_GAME_LOSING);
 
   player->GameOver = TRUE;
@@ -6192,7 +6376,13 @@ int DigField(struct PlayerInfo *player,
 
   switch (element)
   {
+#if 0
     case EL_EMPTY:
+      PlaySoundLevelElementAction(x, y, player->element_nr, ACTION_MOVING);
+      break;
+#endif
+
+#if 0
     case EL_SAND:
     case EL_INVISIBLE_SAND:
     case EL_INVISIBLE_SAND_ACTIVE:
@@ -6201,15 +6391,16 @@ int DigField(struct PlayerInfo *player,
     case EL_SP_BUGGY_BASE:
     case EL_SP_BUGGY_BASE_ACTIVATING:
       RemoveField(x, y);
-#if 1
+
       if (mode != DF_SNAP && element != EL_EMPTY)
       {
 	GfxElement[x][y] = (CAN_BE_CRUMBLED(element) ? EL_SAND : element);
 	player->is_digging = TRUE;
       }
-#endif
+
       PlaySoundLevelElementAction(x, y, element, ACTION_DIGGING);
       break;
+#endif
 
     case EL_EMERALD:
     case EL_BD_DIAMOND:
@@ -6221,13 +6412,13 @@ int DigField(struct PlayerInfo *player,
     case EL_PEARL:
     case EL_CRYSTAL:
       RemoveField(x, y);
-#if 1
+
       if (mode != DF_SNAP)
       {
 	GfxElement[x][y] = element;
 	player->is_collecting = TRUE;
       }
-#endif
+
       local_player->gems_still_needed -= (element == EL_DIAMOND ? 3 :
 					  element == EL_PEARL ? 5 :
 					  element == EL_CRYSTAL ? 8 : 1);
@@ -6237,18 +6428,31 @@ int DigField(struct PlayerInfo *player,
       DrawText(DX_EMERALDS, DY_EMERALDS,
 	       int2str(local_player->gems_still_needed, 3), FONT_TEXT_2);
       PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
     case EL_SPEED_PILL:
       RemoveField(x, y);
       player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_SPEED_PILL_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
+#if 0
     case EL_ENVELOPE:
       Feld[x][y] = EL_EMPTY;
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_ENVELOPE_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
+#endif
 
     case EL_EXTRA_TIME:
       RemoveField(x, y);
@@ -6257,20 +6461,35 @@ int DigField(struct PlayerInfo *player,
 	TimeLeft += 10;
 	DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
       }
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundStereo(SND_EXTRA_TIME_COLLECTING, SOUND_MIDDLE);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
     case EL_SHIELD_NORMAL:
       RemoveField(x, y);
       player->shield_normal_time_left += 10;
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_SHIELD_NORMAL_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
     case EL_SHIELD_DEADLY:
       RemoveField(x, y);
       player->shield_normal_time_left += 10;
       player->shield_deadly_time_left += 10;
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_SHIELD_DEADLY_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
     case EL_DYNAMITE:
@@ -6282,6 +6501,7 @@ int DigField(struct PlayerInfo *player,
       DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(local_player->dynamite, 3),
 	       FONT_TEXT_2);
       PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
     case EL_DYNABOMB_INCREASE_NUMBER:
@@ -6289,21 +6509,36 @@ int DigField(struct PlayerInfo *player,
       player->dynabomb_count++;
       player->dynabombs_left++;
       RaiseScoreElement(EL_DYNAMITE);
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_DYNABOMB_INCREASE_NUMBER_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
     case EL_DYNABOMB_INCREASE_SIZE:
       RemoveField(x, y);
       player->dynabomb_size++;
       RaiseScoreElement(EL_DYNAMITE);
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_DYNABOMB_INCREASE_SIZE_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
     case EL_DYNABOMB_INCREASE_POWER:
       RemoveField(x, y);
       player->dynabomb_xl = TRUE;
       RaiseScoreElement(EL_DYNAMITE);
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_DYNABOMB_INCREASE_POWER_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
 
     case EL_KEY_1:
@@ -6321,7 +6556,12 @@ int DigField(struct PlayerInfo *player,
 			 graphic);
       DrawMiniGraphicExt(window, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
 			 graphic);
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_CLASS_KEY_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
     }
 
@@ -6340,7 +6580,12 @@ int DigField(struct PlayerInfo *player,
 			 graphic);
       DrawMiniGraphicExt(window, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
 			 graphic);
+#if 1
+      PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
+#else
       PlaySoundLevel(x, y, SND_CLASS_KEY_COLLECTING);
+#endif
+      CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
       break;
     }
 
@@ -6512,6 +6757,9 @@ int DigField(struct PlayerInfo *player,
 
       DrawLevelField(x + dx, y + dy);
       PlaySoundLevelElementAction(x, y, element, ACTION_PUSHING);
+
+      CheckTriggeredElementChange(element, CE_OTHER_PUSHING);
+
       break;
 
     case EL_GATE_1:
@@ -6698,8 +6946,10 @@ int DigField(struct PlayerInfo *player,
       return MF_ACTION;
       break;
 
+#if 0
     case EL_SOKOBAN_FIELD_EMPTY:
       break;
+#endif
 
     case EL_SOKOBAN_OBJECT:
     case EL_SOKOBAN_FIELD_FULL:
@@ -6797,6 +7047,8 @@ int DigField(struct PlayerInfo *player,
 	PlaySoundLevel(x, y, SND_GAME_SOKOBAN_SOLVING);
       }
 
+      CheckTriggeredElementChange(element, CE_OTHER_PUSHING);
+
       break;
 
     case EL_PENGUIN:
@@ -6808,19 +7060,20 @@ int DigField(struct PlayerInfo *player,
 
       if (IS_WALKABLE(element))
       {
+	PlaySoundLevelElementAction(x, y, player->element_nr, ACTION_MOVING);
 	break;
       }
       else if (IS_DIGGABLE(element))
       {
 	RemoveField(x, y);
-#if 1
+
 	if (mode != DF_SNAP)
 	{
 	  GfxElement[x][y] =
 	    (CAN_BE_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
 	  player->is_digging = TRUE;
 	}
-#endif
+
 	PlaySoundLevelElementAction(x, y, element, ACTION_DIGGING);
 
 	break;
@@ -6828,15 +7081,19 @@ int DigField(struct PlayerInfo *player,
       else if (IS_COLLECTIBLE(element))
       {
 	RemoveField(x, y);
-#if 1
+
 	if (mode != DF_SNAP)
 	{
 	  GfxElement[x][y] = element;
 	  player->is_collecting = TRUE;
 	}
-#endif
+
+	RaiseScoreElement(element);
+
 	PlaySoundLevelElementAction(x, y, element, ACTION_COLLECTING);
 
+	CheckTriggeredElementChange(element, CE_OTHER_COLLECTING);
+
 	break;
       }
       else if (IS_PUSHABLE(element))
@@ -6879,8 +7136,15 @@ int DigField(struct PlayerInfo *player,
 	DrawLevelField(x + dx, y + dy);
 	PlaySoundLevelElementAction(x, y, element, ACTION_PUSHING);
 
+	CheckTriggeredElementChange(element, CE_OTHER_PUSHING);
+	CheckPlayerElementChange(x, y, element, CE_PUSHED_BY_PLAYER);
+
 	break;
       }
+      else
+      {
+	CheckPlayerElementChange(x, y, element, CE_PRESSED_BY_PLAYER);
+      }
 
       return MF_NO_ACTION;
   }
@@ -7188,6 +7452,7 @@ void RaiseScoreElement(int element)
       RaiseScore(level.score[SC_KEY]);
       break;
     default:
+      RaiseScore(element_info[element].score);
       break;
   }
 }