X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=blobdiff_plain;f=src%2Fgame.c;h=6fc7f7bdc7dbd196ecfd616c94935a282f716466;hp=d3ac230748cb7b01f3bb4d65969f7789fbd378fd;hb=ed22fcb49eb39c34da82c51f44cbe64ca5b409c4;hpb=d42e0a36609c7990f8b9f6fcd80f37f65bcf5149

diff --git a/src/game.c b/src/game.c
index d3ac2307..6fc7f7bd 100644
--- a/src/game.c
+++ b/src/game.c
@@ -43,10 +43,12 @@
 
 /* for Explode() */
 #define EX_PHASE_START		0
-#define EX_NO_EXPLOSION		0
-#define EX_NORMAL		1
-#define EX_CENTER		2
-#define EX_BORDER		3
+#define EX_TYPE_NONE		0
+#define EX_TYPE_NORMAL		(1 << 0)
+#define EX_TYPE_CENTER		(1 << 1)
+#define EX_TYPE_BORDER		(1 << 2)
+#define EX_TYPE_CROSS		(1 << 3)
+#define EX_TYPE_SINGLE_TILE	(EX_TYPE_CENTER | EX_TYPE_BORDER)
 
 /* special positions in the game control window (relative to control window) */
 #define XX_LEVEL		37
@@ -98,101 +100,146 @@
 
 #define GET_NEW_PUSH_DELAY(e)	(   (element_info[e].push_delay_fixed) + \
 				 RND(element_info[e].push_delay_random))
+#define GET_NEW_DROP_DELAY(e)	(   (element_info[e].drop_delay_fixed) + \
+				 RND(element_info[e].drop_delay_random))
 #define GET_NEW_MOVE_DELAY(e)	(   (element_info[e].move_delay_fixed) + \
 				 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 ELEMENT_CAN_ENTER_FIELD_BASE(e, x, y, condition)		\
+#define GET_TARGET_ELEMENT(e, ch)					\
+	((e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element :	\
+	 (e) == EL_TRIGGER_PLAYER  ? (ch)->actual_trigger_player : (e))
+
+#define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition)			\
+		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
+					(condition)))
+
+#define ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, condition)		\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
 					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID) ||	\
 					(condition)))
 
-#if 0
-#define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition)		\
+#define ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, condition)		\
+		(IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||	\
+					(CAN_MOVE_INTO_ACID(e) &&	\
+					 Feld[x][y] == EL_ACID) ||	\
+					(condition)))
+
+#define ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, condition)		\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
 					(condition) ||			\
+					(CAN_MOVE_INTO_ACID(e) &&	\
+					 Feld[x][y] == EL_ACID) ||	\
 					(DONT_COLLIDE_WITH(e) &&	\
 					 IS_PLAYER(x, y) &&		\
 					 !PLAYER_ENEMY_PROTECTED(x, y))))
-#else
+
+#if 0
 #define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition)		\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
 					(condition) ||			\
-					(CAN_MOVE_INTO_ACID(e) &&	\
-					 Feld[x][y] == EL_ACID) ||	\
 					(DONT_COLLIDE_WITH(e) &&	\
 					 IS_PLAYER(x, y) &&		\
 					 !PLAYER_ENEMY_PROTECTED(x, y))))
 #endif
 
-#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, 0)
-
-#define ELEMENT_CAN_ENTER_FIELD_OR_ACID(e, x, y)			\
-	ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, (Feld[x][y] == EL_ACID))
+	ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, 0)
 
-#define ELEMENT_CAN_ENTER_FIELD_OR_ACID_2(x, y)				\
-	ELEMENT_CAN_ENTER_FIELD_GENERIC_2(x, y, (Feld[x][y] == EL_ACID))
+#if 1
+#define SATELLITE_CAN_ENTER_FIELD(x, y)					\
+	ELEMENT_CAN_ENTER_FIELD_BASE_2(EL_SATELLITE, x, y, 0)
+#else
+#define SATELLITE_CAN_ENTER_FIELD(x, y)					\
+	ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, Feld[x][y] == EL_ACID)
+#endif
 
 #if 0
 #define ENEMY_CAN_ENTER_FIELD(e, x, y) (IN_LEV_FIELD(x, y) && IS_FREE(x, y))
-#else
-#define ENEMY_CAN_ENTER_FIELD(e, x, y) ELEMENT_CAN_ENTER_FIELD_BASE(e, x, y, 0)
 #endif
 
-#define YAMYAM_CAN_ENTER_FIELD(x, y)					\
+#define ENEMY_CAN_ENTER_FIELD(e, x, y)					\
+	ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
+
+#if 1
+
+#define YAMYAM_CAN_ENTER_FIELD(e, x, y)					\
+	ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, Feld[x][y] == EL_DIAMOND)
+
+#define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y)				\
+	ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x,y, IS_FOOD_DARK_YAMYAM(Feld[x][y]))
+
+#define PACMAN_CAN_ENTER_FIELD(e, x, y)					\
+	ELEMENT_CAN_ENTER_FIELD_BASE_3(e, x, y, IS_AMOEBOID(Feld[x][y]))
+
+#define PIG_CAN_ENTER_FIELD(e, x, y)					\
+	ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, IS_FOOD_PIG(Feld[x][y]))
+
+#define PENGUIN_CAN_ENTER_FIELD(e, x, y)				\
+	ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (Feld[x][y] == EL_EXIT_OPEN ||\
+						 IS_FOOD_PENGUIN(Feld[x][y])))
+#define DRAGON_CAN_ENTER_FIELD(e, x, y)					\
+	ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
+
+#define MOLE_CAN_ENTER_FIELD(e, x, y, condition)			\
+	ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, (condition))
+
+#define SPRING_CAN_ENTER_FIELD(e, x, y)					\
+	ELEMENT_CAN_ENTER_FIELD_BASE_2(e, x, y, 0)
+
+#else
+
+#define YAMYAM_CAN_ENTER_FIELD(e, x, y)					\
 		(IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||	\
-					(CAN_MOVE_INTO_ACID(EL_YAMYAM) && \
+					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID) ||	\
 					Feld[x][y] == EL_DIAMOND))
 
-#define DARK_YAMYAM_CAN_ENTER_FIELD(x, y)				\
+#define DARK_YAMYAM_CAN_ENTER_FIELD(e, x, y)				\
 		(IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||	\
-					(CAN_MOVE_INTO_ACID(EL_DARK_YAMYAM) &&\
+					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID) ||	\
 					IS_FOOD_DARK_YAMYAM(Feld[x][y])))
 
-#define PACMAN_CAN_ENTER_FIELD(x, y)					\
+#define PACMAN_CAN_ENTER_FIELD(e, x, y)					\
 		(IN_LEV_FIELD(x, y) && (IS_FREE_OR_PLAYER(x, y) ||	\
-					(CAN_MOVE_INTO_ACID(EL_PACMAN) && \
+					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID) ||	\
 					IS_AMOEBOID(Feld[x][y])))
 
-#define PIG_CAN_ENTER_FIELD(x, y)					\
+#define PIG_CAN_ENTER_FIELD(e, x, y)					\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
-					(CAN_MOVE_INTO_ACID(EL_PIG) &&	\
+					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID) ||	\
 					IS_FOOD_PIG(Feld[x][y])))
 
-#define PENGUIN_CAN_ENTER_FIELD(x, y)					\
+#define PENGUIN_CAN_ENTER_FIELD(e, x, y)				\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
-					(CAN_MOVE_INTO_ACID(EL_PENGUIN) && \
+					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID) ||	\
 					IS_FOOD_PENGUIN(Feld[x][y]) ||	\
 					Feld[x][y] == EL_EXIT_OPEN))
 
-#define DRAGON_CAN_ENTER_FIELD(x, y)					\
+#define DRAGON_CAN_ENTER_FIELD(e, x, y)					\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
-					(CAN_MOVE_INTO_ACID(EL_DRAGON) && \
+					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID)))
 
-#define MOLE_CAN_ENTER_FIELD(x, y, condition)				\
+#define MOLE_CAN_ENTER_FIELD(e, x, y, condition)			\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
-					(CAN_MOVE_INTO_ACID(EL_MOLE) &&	\
+					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID) ||	\
 					(condition)))
 
-#define SPRING_CAN_ENTER_FIELD(x, y)					\
+#define SPRING_CAN_ENTER_FIELD(e, x, y)					\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
-					(CAN_MOVE_INTO_ACID(EL_SPRING) && \
+					(CAN_MOVE_INTO_ACID(e) &&	\
 					 Feld[x][y] == EL_ACID)))
 
+#endif
+
 #define GROUP_NR(e)		((e) - EL_GROUP_START)
 #define MOVE_ENTER_EL(e)	(element_info[e].move_enter_element)
 #define IS_IN_GROUP(e, nr)	(element_info[e].in_group[nr] == TRUE)
@@ -213,7 +260,7 @@
 #endif
 
 #define CUSTOM_ELEMENT_CAN_ENTER_FIELD(e, x, y)				\
-	ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
+	ELEMENT_CAN_ENTER_FIELD_BASE_4(e, x, y, CE_ENTER_FIELD_COND(e, x, y))
 
 #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))
@@ -248,28 +295,33 @@ static void KillHeroUnlessExplosionProtected(int, int);
 static void TestIfPlayerTouchesCustomElement(int, int);
 static void TestIfElementTouchesCustomElement(int, int);
 static void TestIfElementHitsCustomElement(int, int, int);
+#if 0
+static void TestIfElementSmashesCustomElement(int, int, int);
+#endif
 
 static void ChangeElement(int, int, int);
 
 static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
 #define CheckTriggeredElementChange(x, y, e, ev)			\
-	CheckTriggeredElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, -1)
+	CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY,	\
+				       CH_SIDE_ANY, -1)
 #define CheckTriggeredElementChangePlayer(x, y, e, ev, p, s)		\
 	CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
 #define CheckTriggeredElementChangeSide(x, y, e, ev, s)			\
-	CheckTriggeredElementChangeExt(x, y, e, ev, -1, s, -1)
+	CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
 #define CheckTriggeredElementChangePage(x, y, e, ev, p)			\
-	CheckTriggeredElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, p)
+	CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY,	\
+				       CH_SIDE_ANY, p)
 
-static boolean CheckElementChangeExt(int, int, int, int, int, int, int);
-#define CheckElementChange(x, y, e, ev)					\
-	CheckElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, -1)
+static boolean CheckElementChangeExt(int, int, int, int, int, int, int, int);
+#define CheckElementChange(x, y, e, te, ev)				\
+	CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY, -1)
 #define CheckElementChangePlayer(x, y, e, ev, p, s)			\
-	CheckElementChangeExt(x, y, e, ev, p, s, -1)
-#define CheckElementChangeSide(x, y, e, ev, s)				\
-	CheckElementChangeExt(x, y, e, ev, -1, s, -1)
-#define CheckElementChangePage(x, y, e, ev, p)				\
-	CheckElementChangeExt(x, y, e, ev, -1, CH_SIDE_ANY, p)
+	CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s, CH_PAGE_ANY)
+#define CheckElementChangeSide(x, y, e, te, ev, s)			\
+	CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, s, CH_PAGE_ANY)
+#define CheckElementChangePage(x, y, e, te, ev, p)			\
+	CheckElementChangeExt(x, y, e, te, ev, CH_PLAYER_ANY, CH_SIDE_ANY, p)
 
 static void PlayLevelSound(int, int, int);
 static void PlayLevelSoundNearest(int, int, int);
@@ -907,7 +959,7 @@ static inline void InitField_WithBug1(int x, int y, boolean init_game)
   InitField(x, y, init_game);
 
   /* not needed to call InitMovDir() -- already done by InitField()! */
-  if (game.engine_version < VERSION_IDENT(3,0,9,0) &&
+  if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
       CAN_MOVE(Feld[x][y]))
     InitMovDir(x, y);
 }
@@ -919,7 +971,7 @@ static inline void InitField_WithBug2(int x, int y, boolean init_game)
   InitField(x, y, init_game);
 
   /* not needed to call InitMovDir() -- already done by InitField()! */
-  if (game.engine_version < VERSION_IDENT(3,0,9,0) &&
+  if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
       CAN_MOVE(old_element) &&
       (old_element < EL_MOLE_LEFT || old_element > EL_MOLE_DOWN))
     InitMovDir(x, y);
@@ -1153,6 +1205,10 @@ static void InitGameEngine()
     ei->change->post_change_function = ch_delay->post_change_function;
 
     ei->change_events |= CH_EVENT_BIT(CE_DELAY);
+
+#if 1
+    SET_PROPERTY(ch_delay->element, EP_CAN_CHANGE, TRUE);
+#endif
   }
 
 #if 1
@@ -1193,6 +1249,19 @@ static void InitGameEngine()
   }
 #endif
 
+  /* ---------- initialize run-time trigger player and element ------------- */
+
+  for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+  {
+    struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
+
+    for (j = 0; j < ei->num_change_pages; j++)
+    {
+      ei->change_page[j].actual_trigger_element = EL_EMPTY;
+      ei->change_page[j].actual_trigger_player = EL_PLAYER_1;
+    }
+  }
+
   /* ---------- initialize trigger events ---------------------------------- */
 
   /* initialize trigger events information */
@@ -1257,14 +1326,14 @@ static void InitGameEngine()
   }
 
   /* set push delay value for Supaplex elements for newer engine versions */
-  if (game.engine_version >= VERSION_IDENT(3,0,9,0))
+  if (game.engine_version >= VERSION_IDENT(3,1,0,0))
   {
     for (i = 0; i < MAX_NUM_ELEMENTS; i++)
     {
       if (IS_SP_ELEMENT(i))
       {
-	element_info[i].push_delay_fixed  = 6;
-	element_info[i].push_delay_random = 0;
+	element_info[i].push_delay_fixed  = 6;	/* just enough to escape ... */
+	element_info[i].push_delay_random = 0;	/* ... from falling zonk     */
       }
     }
   }
@@ -1284,6 +1353,7 @@ static void InitGameEngine()
     element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
   }
 
+#if 0
   /* ---------- initialize move dig/leave ---------------------------------- */
 
   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
@@ -1291,6 +1361,7 @@ static void InitGameEngine()
     element_info[i].can_leave_element = FALSE;
     element_info[i].can_leave_element_last = FALSE;
   }
+#endif
 
   /* ---------- initialize gem count --------------------------------------- */
 
@@ -1388,6 +1459,7 @@ void InitGame()
     player->use_murphy_graphic = FALSE;
 
     player->block_last_field = FALSE;
+    player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
 
     player->actual_frame_counter = 0;
 
@@ -1547,7 +1619,7 @@ void InitGame()
 
       ExplodePhase[x][y] = 0;
       ExplodeDelay[x][y] = 0;
-      ExplodeField[x][y] = EX_NO_EXPLOSION;
+      ExplodeField[x][y] = EX_TYPE_NONE;
 
       RunnerVisit[x][y] = 0;
       PlayerVisit[x][y] = 0;
@@ -1586,23 +1658,32 @@ void InitGame()
   {
     if (!IS_CUSTOM_ELEMENT(i))
     {
-      int num_phase = 9;
-      int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
-      int last_phase = num_phase * delay;
+      int num_phase = 8;
+      int delay = (((IS_SP_ELEMENT(i) && i != EL_EMPTY_SPACE) &&
+		    game.engine_version >= VERSION_IDENT(3,1,0,0)) ||
+		   game.emulation == EMU_SUPAPLEX ? 3 : 2);
+      int last_phase = (num_phase + 1) * delay;
       int half_phase = (num_phase / 2) * delay;
 
-      element_info[i].explosion_delay = last_phase;
+      element_info[i].explosion_delay = last_phase - 1;
       element_info[i].ignition_delay = half_phase;
 
+#if 0
+      if (i == EL_BLACK_ORB)
+	element_info[i].ignition_delay = 0;
+#else
       if (i == EL_BLACK_ORB)
 	element_info[i].ignition_delay = 1;
+#endif
     }
 
-    if (element_info[i].explosion_delay < 2)	/* !!! check again !!! */
-      element_info[i].explosion_delay = 2;
+#if 0
+    if (element_info[i].explosion_delay < 1)	/* !!! check again !!! */
+      element_info[i].explosion_delay = 1;
 
     if (element_info[i].ignition_delay < 1)	/* !!! check again !!! */
       element_info[i].ignition_delay = 1;
+#endif
   }
 
   /* correct non-moving belts to start moving left */
@@ -1631,6 +1712,10 @@ void InitGame()
 	  some_player->present = FALSE;
 	  some_player->active = FALSE;
 
+#if 0
+	  player->element_nr = some_player->element_nr;
+#endif
+
 	  StorePlayer[jx][jy] = player->element_nr;
 	  player->jx = player->last_jx = jx;
 	  player->jy = player->last_jy = jy;
@@ -1784,7 +1869,7 @@ void InitGame()
 
 	for (i = 0; i < element_info[element].num_change_pages; i++)
 	{
-	  content = element_info[element].change_page[i].content[xx][yy];
+	  content= element_info[element].change_page[i].target_content[xx][yy];
 	  is_player = ELEM_IS_PLAYER(content);
 
 	  if (is_player && (found_rating < 1 || element < found_element))
@@ -2009,6 +2094,11 @@ void InitMovDir(int x, int y)
 
 	      break;
 	    }
+
+#if 1
+	    if (MovDir[x][y] == MV_NO_MOVING)	/* no start direction found */
+	      MovDir[x][y] = 1 << RND(4);	/* => use random direction */
+#endif
 	  }
 	}		 
       }
@@ -2535,17 +2625,16 @@ void RelocatePlayer(int x, int y, int element_raw)
   int element = (element_raw == EL_SP_MURPHY ? EL_PLAYER_1 : element_raw);
   struct PlayerInfo *player = &stored_player[element - EL_PLAYER_1];
   boolean ffwd_delay = (tape.playing && tape.fast_forward);
-  boolean no_delay = (tape.index_search);
+  boolean no_delay = (tape.warp_forward);
   int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
   int wait_delay_value = (no_delay ? 0 : frame_delay_value);
+  int old_jx, old_jy;
 
   if (player->GameOver)		/* do not reanimate dead player */
     return;
 
-#if 1
   RemoveField(x, y);		/* temporarily remove newly placed player */
   DrawLevelField(x, y);
-#endif
 
   if (player->present)
   {
@@ -2567,13 +2656,124 @@ void RelocatePlayer(int x, int y, int element_raw)
     player->is_moving = FALSE;
   }
 
+  old_jx = player->jx;
+  old_jy = player->jy;
+
   Feld[x][y] = element;
   InitPlayerField(x, y, element, TRUE);
 
-  if (player == local_player)
+  if (player != local_player)	/* do not visually relocate other players */
+    return;
+
+  if (level.instant_relocation)
+  {
+#if 1
+    int offset = (setup.scroll_delay ? 3 : 0);
+    int jx = local_player->jx;
+    int jy = local_player->jy;
+
+    if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
+    {
+      scroll_x = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
+		  local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
+		  local_player->jx - MIDPOSX);
+
+      scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
+		  local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
+		  local_player->jy - MIDPOSY);
+    }
+    else
+    {
+      if ((player->MovDir == MV_LEFT  && scroll_x > jx - MIDPOSX + offset) ||
+	  (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
+	scroll_x = jx - MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
+
+      if ((player->MovDir == MV_UP  && scroll_y > jy - MIDPOSY + offset) ||
+	  (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
+	scroll_y = jy - MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
+
+      /* don't scroll over playfield boundaries */
+      if (scroll_x < SBX_Left || scroll_x > SBX_Right)
+	scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
+
+      /* don't scroll over playfield boundaries */
+      if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
+	scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
+    }
+#else
+    scroll_x += (local_player->jx - old_jx);
+    scroll_y += (local_player->jy - old_jy);
+
+    /* don't scroll over playfield boundaries */
+    if (scroll_x < SBX_Left || scroll_x > SBX_Right)
+      scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
+
+    /* don't scroll over playfield boundaries */
+    if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
+      scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
+#endif
+
+    RedrawPlayfield(TRUE, 0,0,0,0);
+  }
+  else
   {
+#if 1
+#if 0
+    int offset = (setup.scroll_delay ? 3 : 0);
+    int jx = local_player->jx;
+    int jy = local_player->jy;
+#endif
+    int scroll_xx = -999, scroll_yy = -999;
+
+    ScrollScreen(NULL, SCROLL_GO_ON);	/* scroll last frame to full tile */
+
+    while (scroll_xx != scroll_x || scroll_yy != scroll_y)
+    {
+      int dx = 0, dy = 0;
+      int fx = FX, fy = FY;
+
+      scroll_xx = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
+		   local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
+		   local_player->jx - MIDPOSX);
+
+      scroll_yy = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
+		   local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
+		   local_player->jy - MIDPOSY);
+
+      dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
+      dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
+
+#if 1
+      if (dx == 0 && dy == 0)		/* no scrolling needed at all */
+	break;
+#else
+      if (scroll_xx == scroll_x && scroll_yy == scroll_y)
+	break;
+#endif
+
+      scroll_x -= dx;
+      scroll_y -= dy;
+
+      fx += dx * TILEX / 2;
+      fy += dy * TILEY / 2;
+
+      ScrollLevel(dx, dy);
+      DrawAllPlayers();
+
+      /* scroll in two steps of half tile size to make things smoother */
+      BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
+      FlushDisplay();
+      Delay(wait_delay_value);
+
+      /* scroll second step to align at full tile size */
+      BackToFront();
+      Delay(wait_delay_value);
+    }
+#else
     int scroll_xx = -999, scroll_yy = -999;
 
+    ScrollScreen(NULL, SCROLL_GO_ON);	/* scroll last frame to full tile */
+
     while (scroll_xx != scroll_x || scroll_yy != scroll_y)
     {
       int dx = 0, dy = 0;
@@ -2590,6 +2790,14 @@ void RelocatePlayer(int x, int y, int element_raw)
       dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
       dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
 
+#if 1
+      if (dx == 0 && dy == 0)		/* no scrolling needed at all */
+	break;
+#else
+      if (scroll_xx == scroll_x && scroll_yy == scroll_y)
+	break;
+#endif
+
       scroll_x -= dx;
       scroll_y -= dy;
 
@@ -2608,6 +2816,7 @@ void RelocatePlayer(int x, int y, int element_raw)
       BackToFront();
       Delay(wait_delay_value);
     }
+#endif
   }
 }
 
@@ -2640,15 +2849,20 @@ void Explode(int ex, int ey, int phase, int mode)
   {
     int center_element = Feld[ex][ey];
 
+#if 0
+    printf("::: start explosion %d,%d [%d]\n", ex, ey, FrameCounter);
+#endif
+
 #if 0
     /* --- This is only really needed (and now handled) in "Impact()". --- */
     /* do not explode moving elements that left the explode field in time */
     if (game.engine_version >= VERSION_IDENT(2,2,0,7) &&
-	center_element == EL_EMPTY && (mode == EX_NORMAL || mode == EX_CENTER))
+	center_element == EL_EMPTY &&
+	(mode == EX_TYPE_NORMAL || mode == EX_TYPE_CENTER))
       return;
 #endif
 
-    if (mode == EX_NORMAL || mode == EX_CENTER)
+    if (mode == EX_TYPE_NORMAL || mode == EX_TYPE_CENTER)
       PlayLevelSoundAction(ex, ey, ACTION_EXPLODING);
 
     /* remove things displayed in background while burning dynamite */
@@ -2664,9 +2878,18 @@ void Explode(int ex, int ey, int phase, int mode)
     }
 
 #if 1
+
+#if 1
+    last_phase = element_info[center_element].explosion_delay + 1;
+#else
     last_phase = element_info[center_element].explosion_delay;
 #endif
 
+#if 0
+    printf("::: %d -> %d\n", center_element, last_phase);
+#endif
+#endif
+
     for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
     {
       int xx = x - ex + 1;
@@ -2674,11 +2897,20 @@ void Explode(int ex, int ey, int phase, int mode)
       int element;
 
 #if 1
-      if (!IN_LEV_FIELD(x, y) || (mode != EX_NORMAL && (x != ex || y != ey)))
+#if 1
+      if (!IN_LEV_FIELD(x, y) ||
+	  (mode & EX_TYPE_SINGLE_TILE && (x != ex || y != ey)) ||
+	  (mode == EX_TYPE_CROSS      && (x != ex && y != ey)))
+	continue;
+#else
+      if (!IN_LEV_FIELD(x, y) ||
+	  (mode != EX_TYPE_NORMAL && (x != ex || y != ey)))
 	continue;
+#endif
 #else
       if (!IN_LEV_FIELD(x, y) ||
-	  ((mode != EX_NORMAL || center_element == EL_AMOEBA_TO_DIAMOND) &&
+	  ((mode != EX_TYPE_NORMAL ||
+	    center_element == EL_AMOEBA_TO_DIAMOND) &&
 	   (x != ex || y != ey)))
 	continue;
 #endif
@@ -2770,8 +3002,13 @@ void Explode(int ex, int ey, int phase, int mode)
 	    break;
 	}
 
+#if 1
+	if (PLAYERINFO(ex, ey)->use_murphy_graphic)
+	  Store[x][y] = EL_EMPTY;
+#else
 	if (game.emulation == EMU_SUPAPLEX)
 	  Store[x][y] = EL_EMPTY;
+#endif
       }
       else if (center_element == EL_MOLE)
 	Store[x][y] = EL_EMERALD_RED;
@@ -2812,7 +3049,7 @@ void Explode(int ex, int ey, int phase, int mode)
 	Store[x][y] = EL_EMPTY;
 
       if (x != ex || y != ey ||
-	  center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_BORDER)
+	  center_element == EL_AMOEBA_TO_DIAMOND || mode == EX_TYPE_BORDER)
 	Store2[x][y] = element;
 
 #if 0
@@ -2845,6 +3082,15 @@ void Explode(int ex, int ey, int phase, int mode)
 #if 1
       ExplodeDelay[x][y] = last_phase;
 #endif
+
+#if 0
+#if 1
+      GfxFrame[x][y] = 0;	/* animation does not start until next frame */
+#else
+      GfxFrame[x][y] = -1;	/* animation does not start until next frame */
+#endif
+#endif
+
       Stop[x][y] = TRUE;
     }
 
@@ -2861,6 +3107,15 @@ void Explode(int ex, int ey, int phase, int mode)
   x = ex;
   y = ey;
 
+#if 1
+  if (phase == 1)
+    GfxFrame[x][y] = 0;		/* restart explosion animation */
+#endif
+
+#if 0
+  printf(":X: phase == %d [%d]\n", phase, GfxFrame[x][y]);
+#endif
+
 #if 1
   last_phase = ExplodeDelay[x][y];
 #endif
@@ -2891,6 +3146,10 @@ void Explode(int ex, int ey, int phase, int mode)
   if (IS_PLAYER(x, y))
     border_element = StorePlayer[x][y];
 
+#if 0
+  printf("::: phase == %d\n", phase);
+#endif
+
   if (phase == element_info[border_element].ignition_delay ||
       phase == last_phase)
   {
@@ -2980,6 +3239,14 @@ void Explode(int ex, int ey, int phase, int mode)
   {
     int element;
 
+#if 0
+  printf("::: done: phase == %d\n", phase);
+#endif
+
+#if 0
+    printf("::: explosion %d,%d done [%d]\n", x, y, FrameCounter);
+#endif
+
     element = Feld[x][y] = Store[x][y];
     Store[x][y] = Store2[x][y] = 0;
     GfxElement[x][y] = EL_UNDEFINED;
@@ -3011,7 +3278,7 @@ void Explode(int ex, int ey, int phase, int mode)
 #if 1
     /* !!! not needed !!! */
 #if 1
-    if (game.engine_version < VERSION_IDENT(3,0,9,0) &&
+    if (game.engine_version < VERSION_IDENT(3,1,0,0) &&
 	CAN_MOVE(Feld[x][y]) && Feld[x][y] != EL_MOLE)
       InitMovDir(x, y);
 #else
@@ -3047,7 +3314,20 @@ void Explode(int ex, int ey, int phase, int mode)
 		   stored == EL_SP_INFOTRON ? IMG_SP_EXPLOSION_INFOTRON :
 		   IMG_SP_EXPLOSION);
 #endif
+#if 1
+    int frame = getGraphicAnimationFrame(graphic, GfxFrame[x][y]);
+#else
     int frame = getGraphicAnimationFrame(graphic, phase - delay);
+#endif
+
+#if 0
+  printf("::: phase == %d [%d]\n", phase, GfxFrame[x][y]);
+#endif
+
+#if 0
+    printf("::: %d / %d [%d - %d]\n",
+	   GfxFrame[x][y], phase - delay, phase, delay);
+#endif
 
 #if 0
     printf("::: %d ['%s'] -> %d\n", GfxElement[x][y],
@@ -3096,7 +3376,7 @@ void DynaExplode(int ex, int ey)
     player->dynabombs_left++;
   }
 
-  Explode(ex, ey, EX_PHASE_START, EX_CENTER);
+  Explode(ex, ey, EX_PHASE_START, EX_TYPE_CENTER);
 
   for (i = 0; i < NUM_DIRECTIONS; i++)
   {
@@ -3115,7 +3395,7 @@ void DynaExplode(int ex, int ey)
       if (element == EL_EXPLOSION && IS_ACTIVE_BOMB(Store2[x][y]))
 	continue;
 
-      Explode(x, y, EX_PHASE_START, EX_BORDER);
+      Explode(x, y, EX_PHASE_START, EX_TYPE_BORDER);
 
       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
       if (element != EL_EMPTY &&
@@ -3175,7 +3455,7 @@ void Bang(int x, int y)
     case EL_PACMAN:
     case EL_MOLE:
       RaiseScoreElement(element);
-      Explode(x, y, EX_PHASE_START, EX_NORMAL);
+      Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
       break;
     case EL_DYNABOMB_PLAYER_1_ACTIVE:
     case EL_DYNABOMB_PLAYER_2_ACTIVE:
@@ -3193,17 +3473,21 @@ void Bang(int x, int y)
     case EL_AMOEBA_TO_DIAMOND:
 #endif
       if (IS_PLAYER(x, y))
-	Explode(x, y, EX_PHASE_START, EX_NORMAL);
+	Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
       else
-	Explode(x, y, EX_PHASE_START, EX_CENTER);
+	Explode(x, y, EX_PHASE_START, EX_TYPE_CENTER);
       break;
     default:
-      if (CAN_EXPLODE_DYNA(element))
+      if (CAN_EXPLODE_CROSS(element))
+#if 1
+	Explode(x, y, EX_PHASE_START, EX_TYPE_CROSS);
+#else
 	DynaExplode(x, y);
+#endif
       else if (CAN_EXPLODE_1X1(element))
-	Explode(x, y, EX_PHASE_START, EX_CENTER);
+	Explode(x, y, EX_PHASE_START, EX_TYPE_CENTER);
       else
-	Explode(x, y, EX_PHASE_START, EX_NORMAL);
+	Explode(x, y, EX_PHASE_START, EX_TYPE_NORMAL);
       break;
   }
 
@@ -3596,7 +3880,7 @@ void Impact(int x, int y)
   boolean object_hit = FALSE;
   boolean impact = (lastline || object_hit);
   int element = Feld[x][y];
-  int smashed = EL_UNDEFINED;
+  int smashed = EL_STEELWALL;
 
   if (!lastline)	/* check if element below was hit */
   {
@@ -3647,7 +3931,7 @@ void Impact(int x, int y)
     PlayLevelSound(x, y, SND_PEARL_BREAKING);
     return;
   }
-  else if (impact && CheckElementChange(x, y, element, CE_IMPACT))
+  else if (impact && CheckElementChange(x, y, element, smashed, CE_IMPACT))
   {
     PlayLevelSoundElementAction(x, y, element, ACTION_IMPACT);
 
@@ -3788,16 +4072,21 @@ void Impact(int x, int y)
 	}
 	else
 	{
-	  CheckElementChange(x, y + 1, smashed, CE_SMASHED);
+#if 0
+	  TestIfElementSmashesCustomElement(x, y, MV_DOWN);
+#endif
+
+	  CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
 
 	  CheckTriggeredElementChangeSide(x, y + 1, smashed,
 					  CE_OTHER_IS_SWITCHING, CH_SIDE_TOP);
-	  CheckElementChangeSide(x, y + 1, smashed, CE_SWITCHED, CH_SIDE_TOP);
+	  CheckElementChangeSide(x, y + 1, smashed, element,
+				 CE_SWITCHED, CH_SIDE_TOP);
 	}
       }
       else
       {
-	CheckElementChange(x, y + 1, smashed, CE_SMASHED);
+	CheckElementChange(x, y + 1, smashed, element, CE_SMASHED);
       }
     }
   }
@@ -3884,6 +4173,7 @@ inline static void TurnRoundExt(int x, int y)
     else if (element == EL_BD_BUTTERFLY)     /* && MovDir[x][y] == left_dir) */
       MovDelay[x][y] = 1;
   }
+#if 0
   else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY ||
 	   element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
   {
@@ -3902,10 +4192,38 @@ inline static void TurnRoundExt(int x, int y)
     else if (element == EL_BD_FIREFLY)	    /* && MovDir[x][y] == right_dir) */
       MovDelay[x][y] = 1;
   }
+#else
+  else if (element == EL_SPACESHIP || element == EL_BD_FIREFLY)
+  {
+    TestIfBadThingTouchesOtherBadThing(x, y);
+
+    if (ENEMY_CAN_ENTER_FIELD(element, left_x, left_y))
+      MovDir[x][y] = left_dir;
+    else if (!ENEMY_CAN_ENTER_FIELD(element, move_x, move_y))
+      MovDir[x][y] = right_dir;
+
+    if (element == EL_SPACESHIP	&& MovDir[x][y] != old_move_dir)
+      MovDelay[x][y] = 9;
+    else if (element == EL_BD_FIREFLY)	    /* && MovDir[x][y] == right_dir) */
+      MovDelay[x][y] = 1;
+  }
+  else if (element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
+  {
+    TestIfBadThingTouchesOtherBadThing(x, y);
+
+    if (ELEMENT_CAN_ENTER_FIELD_BASE_4(element, left_x, left_y, 0))
+      MovDir[x][y] = left_dir;
+    else if (!ELEMENT_CAN_ENTER_FIELD_BASE_4(element, move_x, move_y, 0))
+      MovDir[x][y] = right_dir;
+
+    if (MovDir[x][y] != old_move_dir)
+      MovDelay[x][y] = 9;
+  }
+#endif
   else if (element == EL_YAMYAM)
   {
-    boolean can_turn_left  = YAMYAM_CAN_ENTER_FIELD(left_x, left_y);
-    boolean can_turn_right = YAMYAM_CAN_ENTER_FIELD(right_x, right_y);
+    boolean can_turn_left  = YAMYAM_CAN_ENTER_FIELD(element, left_x, left_y);
+    boolean can_turn_right = YAMYAM_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);
@@ -3920,8 +4238,10 @@ inline static void TurnRoundExt(int x, int y)
   }
   else if (element == EL_DARK_YAMYAM)
   {
-    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);
+    boolean can_turn_left  = DARK_YAMYAM_CAN_ENTER_FIELD(element,
+							 left_x, left_y);
+    boolean can_turn_right = DARK_YAMYAM_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);
@@ -3936,8 +4256,8 @@ inline static void TurnRoundExt(int x, int y)
   }
   else if (element == EL_PACMAN)
   {
-    boolean can_turn_left  = PACMAN_CAN_ENTER_FIELD(left_x, left_y);
-    boolean can_turn_right = PACMAN_CAN_ENTER_FIELD(right_x, right_y);
+    boolean can_turn_left  = PACMAN_CAN_ENTER_FIELD(element, left_x, left_y);
+    boolean can_turn_right = PACMAN_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);
@@ -3952,9 +4272,9 @@ inline static void TurnRoundExt(int x, int y)
   }
   else if (element == EL_PIG)
   {
-    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 can_turn_left  = PIG_CAN_ENTER_FIELD(element, left_x, left_y);
+    boolean can_turn_right = PIG_CAN_ENTER_FIELD(element, right_x, right_y);
+    boolean can_move_on    = PIG_CAN_ENTER_FIELD(element, move_x, move_y);
     boolean should_turn_left, should_turn_right, should_move_on;
     int rnd_value = 24;
     int rnd = RND(rnd_value);
@@ -4015,9 +4335,9 @@ inline static void TurnRoundExt(int x, int y)
   }
   else if (element == EL_DRAGON)
   {
-    boolean can_turn_left  = DRAGON_CAN_ENTER_FIELD(left_x, left_y);
-    boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(right_x, right_y);
-    boolean can_move_on    = DRAGON_CAN_ENTER_FIELD(move_x, move_y);
+    boolean can_turn_left  = DRAGON_CAN_ENTER_FIELD(element, left_x, left_y);
+    boolean can_turn_right = DRAGON_CAN_ENTER_FIELD(element, right_x, right_y);
+    boolean can_move_on    = DRAGON_CAN_ENTER_FIELD(element, move_x, move_y);
     int rnd_value = 24;
     int rnd = RND(rnd_value);
 
@@ -4065,17 +4385,17 @@ inline static void TurnRoundExt(int x, int y)
   else if (element == EL_MOLE)
   {
     boolean can_move_on =
-      (MOLE_CAN_ENTER_FIELD(move_x, move_y,
+      (MOLE_CAN_ENTER_FIELD(element, move_x, move_y,
 			    IS_AMOEBOID(Feld[move_x][move_y]) ||
 			    Feld[move_x][move_y] == EL_AMOEBA_SHRINKING));
     if (!can_move_on)
     {
       boolean can_turn_left =
-	(MOLE_CAN_ENTER_FIELD(left_x, left_y,
+	(MOLE_CAN_ENTER_FIELD(element, left_x, left_y,
 			      IS_AMOEBOID(Feld[left_x][left_y])));
 
       boolean can_turn_right =
-	(MOLE_CAN_ENTER_FIELD(right_x, right_y,
+	(MOLE_CAN_ENTER_FIELD(element, right_x, right_y,
 			      IS_AMOEBOID(Feld[right_x][right_y])));
 
       if (can_turn_left && can_turn_right)
@@ -4098,12 +4418,12 @@ inline static void TurnRoundExt(int x, int y)
   {
 #if 0
     if (MovDir[x][y] & MV_HORIZONTAL &&
-	!SPRING_CAN_ENTER_FIELD(move_x, move_y))
+	!SPRING_CAN_ENTER_FIELD(element, move_x, move_y))
       MovDir[x][y] = MV_NO_MOVING;
 #else
     if (MovDir[x][y] & MV_HORIZONTAL &&
-	(!SPRING_CAN_ENTER_FIELD(move_x, move_y) ||
-	 SPRING_CAN_ENTER_FIELD(x, y + 1)))
+	(!SPRING_CAN_ENTER_FIELD(element, move_x, move_y) ||
+	 SPRING_CAN_ENTER_FIELD(element, x, y + 1)))
       MovDir[x][y] = MV_NO_MOVING;
 #endif
 
@@ -4210,14 +4530,14 @@ inline static void TurnRoundExt(int x, int y)
 	  new_move_dir & (first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
 	Moving2Blocked(x, y, &newx, &newy);
 
-	if (PENGUIN_CAN_ENTER_FIELD(newx, newy))
+	if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy))
 	  return;
 
 	MovDir[x][y] =
 	  new_move_dir & (!first_horiz ? MV_HORIZONTAL : MV_VERTICAL);
 	Moving2Blocked(x, y, &newx, &newy);
 
-	if (PENGUIN_CAN_ENTER_FIELD(newx, newy))
+	if (PENGUIN_CAN_ENTER_FIELD(EL_PENGUIN, newx, newy))
 	  return;
 
 	MovDir[x][y] = old_move_dir;
@@ -4239,14 +4559,14 @@ inline static void TurnRoundExt(int x, int 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))
+	if (SATELLITE_CAN_ENTER_FIELD(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))
+	if (SATELLITE_CAN_ENTER_FIELD(newx, newy))
 	  return;
 
 	MovDir[x][y] = old_move_dir;
@@ -4852,7 +5172,7 @@ void StartMoving(int x, int y)
 #endif
 
 #if 1
-    if (game.engine_version >= VERSION_IDENT(3,0,9,0) &&
+    if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
 	WasJustMoving[x][y] && IN_LEV_FIELD(newx, newy) &&
 	(Feld[newx][newy] == EL_BLOCKED || IS_PLAYER(newx, newy)))
     {
@@ -5022,11 +5342,30 @@ void StartMoving(int x, int y)
 	  {
 	    int flamed = MovingOrBlocked2Element(xx, yy);
 
+	    /* !!! */
+#if 0
+	    if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
+	      Bang(xx, yy);
+	    else if (IS_MOVING(xx, yy) || IS_BLOCKED(xx, yy))
+	      RemoveMovingField(xx, yy);
+	    else
+	      RemoveField(xx, yy);
+#else
 	    if (IS_CLASSIC_ENEMY(flamed) || CAN_EXPLODE_BY_DRAGONFIRE(flamed))
 	      Bang(xx, yy);
 	    else
 	      RemoveMovingField(xx, yy);
+#endif
+
+#if 0
+	    if (ChangeDelay[xx][yy])
+	      printf("::: !!! [%d]\n", (IS_MOVING(xx, yy) ||
+					Feld[xx][yy] == EL_BLOCKED));
+#endif
 
+#if 1
+	    ChangeDelay[xx][yy] = 0;
+#endif
 	    Feld[xx][yy] = EL_FLAMES;
 	    if (IN_SCR_FIELD(sx, sy))
 	    {
@@ -5083,7 +5422,7 @@ void StartMoving(int x, int y)
     else if (CAN_MOVE_INTO_ACID(element) &&
 	     IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID &&
 	     (MovDir[x][y] == MV_DOWN ||
-	      game.engine_version > VERSION_IDENT(3,0,8,0)))
+	      game.engine_version >= VERSION_IDENT(3,1,0,0)))
 #else
     else if (CAN_MOVE_INTO_ACID(element) && MovDir[x][y] == MV_DOWN &&
 	     IN_LEV_FIELD(newx, newy) && Feld[newx][newy] == EL_ACID)
@@ -5226,9 +5565,22 @@ void StartMoving(int x, int y)
 	PlayLevelSoundAction(x, y, action);
       }
 
+#if 1
+#if 1
+      Store[newx][newy] = EL_EMPTY;
       if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element)))
-	element_info[element].can_leave_element = TRUE;
-
+	Store[newx][newy] = element_info[element].move_leave_element;
+#else
+      Store[newx][newy] = EL_EMPTY;
+      if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element)) ||
+	  element_info[element].move_leave_type == LEAVE_TYPE_UNLIMITED)
+	Store[newx][newy] = element_info[element].move_leave_element;
+#endif
+#else
+      if (IS_EQUAL_OR_IN_GROUP(new_element, MOVE_ENTER_EL(element)))
+	element_info[element].can_leave_element = TRUE;
+#endif
+
       if (move_pattern & MV_MAZE_RUNNER_STYLE)
       {
 	RunnerVisit[x][y] = FrameCounter;
@@ -5280,11 +5632,25 @@ void StartMoving(int x, int y)
 
 	  MovDelay[x][y] = 50;
 
+	  /* !!! */
+#if 0
+	  RemoveField(newx, newy);
+#endif
 	  Feld[newx][newy] = EL_FLAMES;
 	  if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_EMPTY)
+	  {
+#if 0
+	    RemoveField(newx1, newy1);
+#endif
 	    Feld[newx1][newy1] = EL_FLAMES;
+	  }
 	  if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
+	  {
+#if 0
+	    RemoveField(newx2, newy2);
+#endif
 	    Feld[newx2][newy2] = EL_FLAMES;
+	  }
 
 	  return;
 	}
@@ -5520,16 +5886,34 @@ void ContinueMoving(int x, int y)
   {
     element = Feld[newx][newy] = EL_ACID;
   }
+#if 1
+  else if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) &&
+	   ei->move_leave_element != EL_EMPTY &&
+	   (ei->move_leave_type == LEAVE_TYPE_UNLIMITED ||
+	    Store[x][y] != EL_EMPTY))
+  {
+    /* some elements can leave other elements behind after moving */
+
+    Feld[x][y] = ei->move_leave_element;
+    InitField(x, y, FALSE);
+
+    if (GFX_CRUMBLED(Feld[x][y]))
+      DrawLevelFieldCrumbledSandNeighbours(x, y);
+  }
+#endif
 
-  Store[x][y] = 0;
+  Store[x][y] = EL_EMPTY;
   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];
-  ChangePage[newx][newy] = ChangePage[x][y];
-  Changed[newx][newy] = Changed[x][y];
-  ChangeEvent[newx][newy] = ChangeEvent[x][y];
+  if (CAN_CHANGE(element))
+  {
+    /* copy element change control values to new field */
+    ChangeDelay[newx][newy] = ChangeDelay[x][y];
+    ChangePage[newx][newy]  = ChangePage[x][y];
+    Changed[newx][newy]     = Changed[x][y];
+    ChangeEvent[newx][newy] = ChangeEvent[x][y];
+  }
 
   ChangeDelay[x][y] = 0;
   ChangePage[x][y] = -1;
@@ -5546,7 +5930,7 @@ void ContinueMoving(int x, int y)
 
   ResetGfxAnimation(x, y);	/* reset animation values for old field */
 
-#if 1
+#if 0
   /* some elements can leave other elements behind after moving */
   if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) &&
       ei->move_leave_element != EL_EMPTY &&
@@ -5684,7 +6068,7 @@ void ContinueMoving(int x, int y)
 		change->trigger_element == touched_element)
 	    {
 	      CheckElementChangePage(newx, newy, hitting_element,
-				     CE_OTHER_IS_HITTING, i);
+				     touched_element, CE_OTHER_IS_HITTING, i);
 	      break;
 	    }
 	  }
@@ -5704,7 +6088,7 @@ void ContinueMoving(int x, int y)
 		change->trigger_element == hitting_element)
 	    {
 	      CheckElementChangePage(nextx, nexty, touched_element,
-				     CE_OTHER_GETS_HIT, i);
+				     hitting_element, CE_OTHER_GETS_HIT, i);
 	      break;
 	    }
 	  }
@@ -6660,11 +7044,19 @@ static void ChangeElementNowExt(int x, int y, int target_element)
 static boolean ChangeElementNow(int x, int y, int element, int page)
 {
   struct ElementChangeInfo *change = &element_info[element].change_page[page];
+  int target_element;
 
   /* always use default change event to prevent running into a loop */
   if (ChangeEvent[x][y] == CE_BITMASK_DEFAULT)
     ChangeEvent[x][y] = CH_EVENT_BIT(CE_DELAY);
 
+  if (ChangeEvent[x][y] == CH_EVENT_BIT(CE_DELAY))
+  {
+    /* reset actual trigger element and player */
+    change->actual_trigger_element = EL_EMPTY;
+    change->actual_trigger_player = EL_PLAYER_1;
+  }
+
   /* do not change already changed elements with same change event */
 #if 0
   if (Changed[x][y] & ChangeEvent[x][y])
@@ -6685,35 +7077,38 @@ static boolean ChangeElementNow(int x, int y, int element, int page)
     return TRUE;
   }
 
-  if (change->use_content)
+  if (change->use_target_content)
   {
-    boolean complete_change = TRUE;
-    boolean can_change[3][3];
+    boolean complete_replace = TRUE;
+    boolean can_replace[3][3];
     int xx, yy;
 
     for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
     {
-      boolean half_destructible;
+      boolean is_empty;
+      boolean is_diggable;
+      boolean is_destructible;
       int ex = x + xx - 1;
       int ey = y + yy - 1;
+      int content_element = change->target_content[xx][yy];
       int e;
 
-      can_change[xx][yy] = TRUE;
+      can_replace[xx][yy] = TRUE;
 
       if (ex == x && ey == y)	/* do not check changing element itself */
 	continue;
 
-      if (change->content[xx][yy] == EL_EMPTY_SPACE)
+      if (content_element == EL_EMPTY_SPACE)
       {
-	can_change[xx][yy] = FALSE;	/* do not change empty borders */
+	can_replace[xx][yy] = FALSE;	/* do not replace border with space */
 
 	continue;
       }
 
       if (!IN_LEV_FIELD(ex, ey))
       {
-	can_change[xx][yy] = FALSE;
-	complete_change = FALSE;
+	can_replace[xx][yy] = FALSE;
+	complete_replace = FALSE;
 
 	continue;
       }
@@ -6723,39 +7118,64 @@ static boolean ChangeElementNow(int x, int y, int element, int page)
       if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
 	e = MovingOrBlocked2Element(ex, ey);
 
+#if 1
+      is_empty = (IS_FREE(ex, ey) || (IS_PLAYER(ex, ey) &&
+				      IS_WALKABLE(content_element)));
+      is_diggable = (is_empty || IS_DIGGABLE(e));
+      is_destructible = (is_empty || !IS_INDESTRUCTIBLE(e));
+
+      can_replace[xx][yy] =
+	((change->replace_when == CP_WHEN_EMPTY && is_empty) ||
+	 (change->replace_when == CP_WHEN_DIGGABLE && is_diggable) ||
+	 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible));
+
+      if (!can_replace[xx][yy])
+	complete_replace = FALSE;
+#else
+      empty_for_element = (IS_FREE(ex, ey) || (IS_FREE_OR_PLAYER(ex, ey) &&
+					       IS_WALKABLE(content_element)));
+#if 1
+      half_destructible = (empty_for_element || IS_DIGGABLE(e));
+#else
       half_destructible = (IS_FREE(ex, ey) || IS_DIGGABLE(e));
+#endif
 
-      if ((change->power <= CP_NON_DESTRUCTIVE  && !IS_FREE(ex, ey)) ||
-	  (change->power <= CP_HALF_DESTRUCTIVE && !half_destructible) ||
-	  (change->power <= CP_FULL_DESTRUCTIVE && IS_INDESTRUCTIBLE(e)))
+      if ((change->replace_when <= CP_WHEN_EMPTY  && !empty_for_element) ||
+	  (change->replace_when <= CP_WHEN_DIGGABLE && !half_destructible) ||
+	  (change->replace_when <= CP_WHEN_DESTRUCTIBLE && IS_INDESTRUCTIBLE(e)))
       {
-	can_change[xx][yy] = FALSE;
-	complete_change = FALSE;
+	can_replace[xx][yy] = FALSE;
+	complete_replace = FALSE;
       }
+#endif
     }
 
-    if (!change->only_complete || complete_change)
+    if (!change->only_if_complete || complete_replace)
     {
       boolean something_has_changed = FALSE;
 
-      if (change->only_complete && change->use_random_change &&
-	  RND(100) < change->random)
+      if (change->only_if_complete && change->use_random_replace &&
+	  RND(100) < change->random_percentage)
 	return FALSE;
 
       for (yy = 0; yy < 3; yy++) for (xx = 0; xx < 3 ; xx++)
       {
 	int ex = x + xx - 1;
 	int ey = y + yy - 1;
+	int content_element;
 
-	if (can_change[xx][yy] && (!change->use_random_change ||
-				   RND(100) < change->random))
+	if (can_replace[xx][yy] && (!change->use_random_replace ||
+				    RND(100) < change->random_percentage))
 	{
 	  if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
 	    RemoveMovingField(ex, ey);
 
 	  ChangeEvent[ex][ey] = ChangeEvent[x][y];
 
-	  ChangeElementNowExt(ex, ey, change->content[xx][yy]);
+	  content_element = change->target_content[xx][yy];
+	  target_element = GET_TARGET_ELEMENT(content_element, change);
+
+	  ChangeElementNowExt(ex, ey, target_element);
 
 	  something_has_changed = TRUE;
 
@@ -6771,7 +7191,9 @@ static boolean ChangeElementNow(int x, int y, int element, int page)
   }
   else
   {
-    ChangeElementNowExt(x, y, change->target_element);
+    target_element = GET_TARGET_ELEMENT(change->target_element, change);
+
+    ChangeElementNowExt(x, y, target_element);
 
     PlayLevelSoundElementAction(x, y, element, ACTION_CHANGING);
   }
@@ -6785,9 +7207,8 @@ static void ChangeElement(int x, int y, int page)
   struct ElementInfo *ei = &element_info[element];
   struct ElementChangeInfo *change = &ei->change_page[page];
 
-#if 0
 #ifdef DEBUG
-  if (!CAN_CHANGE(element))
+  if (!CAN_CHANGE(element) && !CAN_CHANGE(Back[x][y]))
   {
     printf("\n\n");
     printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
@@ -6796,8 +7217,18 @@ static void ChangeElement(int x, int y, int page)
     printf("\n\n");
   }
 #endif
+
+  /* this can happen with classic bombs on walkable, changing elements */
+  if (!CAN_CHANGE(element))
+  {
+#if 0
+    if (!CAN_CHANGE(Back[x][y]))	/* prevent permanent repetition */
+      ChangeDelay[x][y] = 0;
 #endif
 
+    return;
+  }
+
   if (ChangeDelay[x][y] == 0)		/* initialize element change */
   {
     ChangeDelay[x][y] = (    change->delay_fixed  * change->delay_frames +
@@ -6828,6 +7259,8 @@ static void ChangeElement(int x, int y, int page)
     {
       page = ChangePage[x][y];
       ChangePage[x][y] = -1;
+
+      change = &ei->change_page[page];
     }
 
 #if 0
@@ -6858,6 +7291,7 @@ static boolean CheckTriggeredElementChangeExt(int lx, int ly,
 					      int trigger_page)
 {
   int i, j, x, y;
+  int trigger_page_bits = (trigger_page < 0 ? CH_PAGE_ANY : 1 << trigger_page);
 
   if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
     return FALSE;
@@ -6880,7 +7314,7 @@ static boolean CheckTriggeredElementChangeExt(int lx, int ly,
 	  change->events & CH_EVENT_BIT(trigger_event) &&
 	  change->trigger_side & trigger_side &&
 	  change->trigger_player & trigger_player &&
-	  change->trigger_page & (1 << trigger_page) &&
+	  change->trigger_page & trigger_page_bits &&
 	  IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element))
       {
 #if 0
@@ -6892,6 +7326,9 @@ static boolean CheckTriggeredElementChangeExt(int lx, int ly,
 	change_element = TRUE;
 	page = j;
 
+	change->actual_trigger_element = trigger_element;
+	change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
+
 	break;
       }
     }
@@ -6920,6 +7357,7 @@ static boolean CheckTriggeredElementChangeExt(int lx, int ly,
 
 static boolean CheckElementChangeExt(int x, int y,
 				     int element,
+				     int trigger_element,
 				     int trigger_event,
 				     int trigger_player,
 				     int trigger_side,
@@ -6934,6 +7372,20 @@ static boolean CheckElementChangeExt(int x, int y,
     element = Feld[x][y];
   }
 
+#if 1
+  if (Feld[x][y] != element)	/* check if element has already changed */
+  {
+#if 0
+    printf("::: %d ('%s') != %d ('%s') [%d]\n",
+	   Feld[x][y], element_info[Feld[x][y]].token_name,
+	   element, element_info[element].token_name,
+	   trigger_event);
+#endif
+
+    return FALSE;
+  }
+#endif
+
 #if 1
   if (trigger_page < 0)
   {
@@ -6952,6 +7404,9 @@ static boolean CheckElementChangeExt(int x, int y,
 	change_element = TRUE;
 	trigger_page = i;
 
+	change->actual_trigger_element = trigger_element;
+	change->actual_trigger_player = EL_PLAYER_1 + log_2(trigger_player);
+
 	break;
       }
     }
@@ -6959,6 +7414,14 @@ static boolean CheckElementChangeExt(int x, int y,
     if (!change_element)
       return FALSE;
   }
+  else
+  {
+    struct ElementInfo *ei = &element_info[element];
+    struct ElementChangeInfo *change = &ei->change_page[trigger_page];
+
+    change->actual_trigger_element = trigger_element;
+    change->actual_trigger_player = EL_PLAYER_1;	/* unused */
+  }
 
 #else
 
@@ -7182,7 +7645,8 @@ static byte PlayerActions(struct PlayerInfo *player, byte player_action)
 
 #if 0
     /* !!! TEST !!! */
-    CheckGravityMovement(player);
+    if (player->MovPos == 0)
+      CheckGravityMovement(player);
 #endif
     if (button1)
       snapped = SnapField(player, dx, dy);
@@ -7339,7 +7803,7 @@ void GameActions()
   action_delay_value =
     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
 
-  if (tape.playing && tape.index_search && !tape.pausing)
+  if (tape.playing && tape.warp_forward && !tape.pausing)
     action_delay_value = 0;
 
   /* ---------- main game synchronization point ---------- */
@@ -7383,6 +7847,15 @@ void GameActions()
   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
 
 #if 1
+  if (recorded_player_action == NULL && tape.pausing)
+    return;
+#endif
+
+#if 0
+  printf("::: %d\n", stored_player[0].action);
+#endif
+
+#if 0
   if (recorded_player_action != NULL)
     for (i = 0; i < MAX_PLAYERS; i++)
       stored_player[i].action = recorded_player_action[i];
@@ -7404,16 +7877,52 @@ void GameActions()
   if (!options.network && !setup.team_mode)
     local_player->effective_action = summarized_player_action;
 
+#if 1
+  if (recorded_player_action != NULL)
+    for (i = 0; i < MAX_PLAYERS; i++)
+      stored_player[i].effective_action = recorded_player_action[i];
+#endif
+
+#if 1
+  for (i = 0; i < MAX_PLAYERS; i++)
+  {
+    tape_action[i] = stored_player[i].effective_action;
+
+    if (tape.recording && tape_action[i] && !tape.player_participates[i])
+      tape.player_participates[i] = TRUE;    /* player just appeared from CE */
+  }
+
+  /* only save actions from input devices, but not programmed actions */
+  if (tape.recording)
+    TapeRecordAction(tape_action);
+#endif
+
   for (i = 0; i < MAX_PLAYERS; i++)
   {
     int actual_player_action = stored_player[i].effective_action;
 
 #if 1
-    /* OLD: overwrite programmed action with tape action (BAD!!!) */
+    /* !!! THIS BREAKS THE FOLLOWING TAPES: !!!
+       - rnd_equinox_tetrachloride 048
+       - rnd_equinox_tetrachloride_ii 096
+       - rnd_emanuel_schmieg 002
+       - doctor_sloan_ww 001, 020
+    */
+    if (stored_player[i].MovPos == 0)
+      CheckGravityMovement(&stored_player[i]);
+#endif
+
+#if 1
+    /* overwrite programmed action with tape action */
     if (stored_player[i].programmed_action)
       actual_player_action = stored_player[i].programmed_action;
 #endif
 
+#if 0
+    if (stored_player[i].programmed_action)
+      printf("::: %d\n", stored_player[i].programmed_action);
+#endif
+
     if (recorded_player_action)
     {
 #if 0
@@ -7429,20 +7938,30 @@ void GameActions()
     }
 
 #if 0
-    /* NEW: overwrite tape action with programmed action */
+    /* overwrite tape action with programmed action */
     if (stored_player[i].programmed_action)
       actual_player_action = stored_player[i].programmed_action;
 #endif
 
+#if 0
+    if (i == 0)
+      printf("::: action: %d: %x [%d]\n",
+	     stored_player[i].MovPos, actual_player_action, FrameCounter);
+#endif
+
+#if 1
+    PlayerActions(&stored_player[i], actual_player_action);
+#else
     tape_action[i] = PlayerActions(&stored_player[i], actual_player_action);
 
     if (tape.recording && tape_action[i] && !tape.player_participates[i])
       tape.player_participates[i] = TRUE;    /* player just appeared from CE */
+#endif
 
     ScrollPlayer(&stored_player[i], SCROLL_GO_ON);
   }
 
-#if 1
+#if 0
   if (tape.recording)
     TapeRecordAction(tape_action);
 #endif
@@ -7668,7 +8187,7 @@ void GameActions()
       CheckDynamite(x, y);
 #if 0
     else if (element == EL_EXPLOSION && !game.explosions_delayed)
-      Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
+      Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
 #endif
     else if (element == EL_AMOEBA_GROWING)
       AmoebeWaechst(x, y);
@@ -7784,9 +8303,9 @@ void GameActions()
       if (ExplodeField[x][y])
 	Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
       else if (element == EL_EXPLOSION)
-	Explode(x, y, ExplodePhase[x][y], EX_NORMAL);
+	Explode(x, y, ExplodePhase[x][y], EX_TYPE_NORMAL);
 
-      ExplodeField[x][y] = EX_NO_EXPLOSION;
+      ExplodeField[x][y] = EX_TYPE_NONE;
     }
 
     game.explosions_delayed = TRUE;
@@ -8073,8 +8592,13 @@ static void CheckGravityMovement(struct PlayerInfo *player)
 {
   if (game.gravity && !player->programmed_action)
   {
+#if 1
+    int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
+    int move_dir_vertical   = player->effective_action & MV_VERTICAL;
+#else
     int move_dir_horizontal = player->action & MV_HORIZONTAL;
     int move_dir_vertical   = player->action & MV_VERTICAL;
+#endif
     int move_dir =
       (player->last_move_dir & MV_HORIZONTAL ?
        (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
@@ -8083,9 +8607,21 @@ static void CheckGravityMovement(struct PlayerInfo *player)
     int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
     int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
     int new_jx = jx + dx, new_jy = jy + dy;
+#if 1
+    boolean player_is_snapping = player->effective_action & JOY_BUTTON_1;
+#else
     boolean player_is_snapping = player->action & JOY_BUTTON_1;
-    boolean field_under_player_is_free =
-      (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
+#endif
+#if 1
+    boolean player_can_fall_down =
+      (IN_LEV_FIELD(jx, jy + 1) &&
+       (IS_FREE(jx, jy + 1) ||
+	(Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)));
+#else
+    boolean player_can_fall_down =
+      (IN_LEV_FIELD(jx, jy + 1) &&
+       (IS_FREE(jx, jy + 1)));
+#endif
     boolean player_is_moving_to_valid_field =
       (
 #if 1
@@ -8104,19 +8640,22 @@ static void CheckGravityMovement(struct PlayerInfo *player)
 	!(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
 
 #if 0
-    printf("::: checking gravity NOW [%d, %d, %d] [%d] ...\n",
-	   field_under_player_is_free,
+    printf("::: checking gravity NOW [%d, %d, %d] [%d] [%d / %d] ...\n",
+	   player_can_fall_down,
 	   player_is_standing_on_valid_field,
 	   player_is_moving_to_valid_field,
-	   (player_is_moving_to_valid_field ? Feld[new_jx][new_jy] : -1));
+	   (player_is_moving_to_valid_field ? Feld[new_jx][new_jy] : -1),
+	   player->effective_action,
+	   player->can_fall_into_acid);
 #endif
 
-    if (field_under_player_is_free &&
+    if (player_can_fall_down &&
 	!player_is_standing_on_valid_field &&
 	!player_is_moving_to_valid_field)
     {
 #if 0
-      printf("::: setting programmed_action to MV_DOWN ...\n");
+      printf("::: setting programmed_action to MV_DOWN [%d,%d - %d] ...\n",
+	     jx, jy, FrameCounter);
 #endif
 
       player->programmed_action = MV_DOWN;
@@ -8233,7 +8772,9 @@ boolean MovePlayerOneStep(struct PlayerInfo *player,
 
   player->step_counter++;
 
+#if 0
   player->drop_delay = 0;
+#endif
 
   PlayerVisit[jx][jy] = FrameCounter;
 
@@ -8366,7 +8907,7 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
     {
       if (jx != old_jx)		/* player has moved horizontally */
       {
- 	if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
+ 	if ((player->MovDir == MV_LEFT  && scroll_x > jx - MIDPOSX + offset) ||
 	    (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
 	  scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
 
@@ -8378,13 +8919,13 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
 	scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
 
 	/* don't scroll against the player's moving direction */
-	if ((player->MovDir == MV_LEFT && scroll_x > old_scroll_x) ||
+	if ((player->MovDir == MV_LEFT  && scroll_x > old_scroll_x) ||
 	    (player->MovDir == MV_RIGHT && scroll_x < old_scroll_x))
 	  scroll_x = old_scroll_x;
       }
       else			/* player has moved vertically */
       {
-	if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
+	if ((player->MovDir == MV_UP   && scroll_y > jy - MIDPOSY + offset) ||
 	    (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
 	  scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
 
@@ -8396,7 +8937,7 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
 	scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
 
 	/* don't scroll against the player's moving direction */
-	if ((player->MovDir == MV_UP && scroll_y > old_scroll_y) ||
+	if ((player->MovDir == MV_UP   && scroll_y > old_scroll_y) ||
 	    (player->MovDir == MV_DOWN && scroll_y < old_scroll_y))
 	  scroll_y = old_scroll_y;
       }
@@ -8450,7 +8991,8 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
     player->is_dropping = FALSE;
 
 
-#if 1
+#if 0
+    /* !!! ENABLE THIS FOR OLD VERSIONS !!! */
     {
       static int trigger_sides[4][2] =
       {
@@ -8465,24 +9007,22 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
       int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
 
 #if 1
+      CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
+					CE_OTHER_GETS_LEFT,
+					player->index_bit, leave_side);
+
       if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
-      {
-	CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
-					  CE_OTHER_GETS_LEFT,
-					  player->index_bit, leave_side);
 	CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
 				 CE_LEFT_BY_PLAYER,
 				 player->index_bit, leave_side);
-      }
+
+      CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
+					CE_OTHER_GETS_ENTERED,
+					player->index_bit, enter_side);
 
       if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
-      {
-	CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
-					  CE_OTHER_GETS_ENTERED,
-					  player->index_bit, enter_side);
 	CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER,
 				 player->index_bit, enter_side);
-      }
 #endif
 
     }
@@ -8599,6 +9139,46 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
 	player->LevelSolved = player->GameOver = TRUE;
     }
 
+#if 1
+    /* !!! ENABLE THIS FOR NEW VERSIONS !!! */
+    /* this breaks one level: "machine", level 000 */
+    {
+      static int trigger_sides[4][2] =
+      {
+	/* enter side           leave side */
+	{ CH_SIDE_RIGHT,	CH_SIDE_LEFT	},	/* moving left  */
+	{ CH_SIDE_LEFT,		CH_SIDE_RIGHT	},	/* moving right */
+	{ CH_SIDE_BOTTOM,	CH_SIDE_TOP	},	/* moving up    */
+	{ CH_SIDE_TOP,		CH_SIDE_BOTTOM	}	/* moving down  */
+      };
+      int move_direction = player->MovDir;
+      int enter_side = trigger_sides[MV_DIR_BIT(move_direction)][0];
+      int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
+      int old_jx = last_jx;
+      int old_jy = last_jy;
+
+#if 1
+      CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
+					CE_OTHER_GETS_LEFT,
+					player->index_bit, leave_side);
+
+      if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
+	CheckElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
+				 CE_LEFT_BY_PLAYER,
+				 player->index_bit, leave_side);
+
+      CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
+					CE_OTHER_GETS_ENTERED,
+					player->index_bit, enter_side);
+
+      if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
+	CheckElementChangePlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER,
+				 player->index_bit, enter_side);
+#endif
+
+    }
+#endif
+
     if (game.engine_version >= VERSION_IDENT(3,0,7,0))
     {
       TestIfHeroTouchesBadThing(jx, jy);
@@ -8786,6 +9366,7 @@ void TestIfElementTouchesCustomElement(int x, int y)
   boolean change_center_element = FALSE;
   int center_element_change_page = 0;
   int center_element = Feld[x][y];	/* should always be non-moving! */
+  int border_trigger_element;
   int i, j;
 
   for (i = 0; i < NUM_DIRECTIONS; i++)
@@ -8830,6 +9411,7 @@ void TestIfElementTouchesCustomElement(int x, int y)
 	{
 	  change_center_element = TRUE;
 	  center_element_change_page = j;
+	  border_trigger_element = border_element;
 
 	  break;
 	}
@@ -8855,8 +9437,12 @@ void TestIfElementTouchesCustomElement(int x, int y)
 #endif
 	    )
 	{
-	  CheckElementChangePage(xx, yy, border_element, CE_OTHER_IS_TOUCHING,
-				 j);
+#if 0
+	  printf("::: border_element %d, %d\n", x, y);
+#endif
+
+	  CheckElementChangePage(xx, yy, border_element, center_element,
+				 CE_OTHER_IS_TOUCHING, j);
 	  break;
 	}
       }
@@ -8864,8 +9450,14 @@ void TestIfElementTouchesCustomElement(int x, int y)
   }
 
   if (change_center_element)
-    CheckElementChangePage(x, y, center_element, CE_OTHER_IS_TOUCHING,
-			   center_element_change_page);
+  {
+#if 0
+    printf("::: center_element %d, %d\n", x, y);
+#endif
+
+    CheckElementChangePage(x, y, center_element, border_trigger_element,
+			   CE_OTHER_IS_TOUCHING, center_element_change_page);
+  }
 }
 
 void TestIfElementHitsCustomElement(int x, int y, int direction)
@@ -8874,6 +9466,7 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
   int hitx = x + dx, hity = y + dy;
   int hitting_element = Feld[x][y];
+  int touched_element;
 #if 0
   boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
 			!IS_FREE(hitx, hity) &&
@@ -8890,15 +9483,20 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
     return;
 #endif
 
-  CheckElementChangeSide(x, y, hitting_element, CE_HITTING_SOMETHING,
-			 direction);
+  touched_element = (IN_LEV_FIELD(hitx, hity) ?
+		     MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
+
+  CheckElementChangeSide(x, y, hitting_element, touched_element,
+			 CE_HITTING_SOMETHING, direction);
 
   if (IN_LEV_FIELD(hitx, hity))
   {
     int opposite_direction = MV_DIR_OPPOSITE(direction);
     int hitting_side = direction;
     int touched_side = opposite_direction;
+#if 0
     int touched_element = MovingOrBlocked2Element(hitx, hity);
+#endif
 #if 1
     boolean object_hit = (!IS_MOVING(hitx, hity) ||
 			  MovDir[hitx][hity] != direction ||
@@ -8911,8 +9509,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
     {
       int i;
 
-      CheckElementChangeSide(hitx, hity, touched_element, CE_HIT_BY_SOMETHING,
-			     opposite_direction);
+      CheckElementChangeSide(hitx, hity, touched_element, hitting_element,
+			     CE_HIT_BY_SOMETHING, opposite_direction);
 
       if (IS_CUSTOM_ELEMENT(hitting_element) &&
 	  HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_HITTING))
@@ -8933,8 +9531,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
 #endif
 	      )
 	  {
-	    CheckElementChangePage(x, y, hitting_element, CE_OTHER_IS_HITTING,
-				   i);
+	    CheckElementChangePage(x, y, hitting_element, touched_element,
+				   CE_OTHER_IS_HITTING, i);
 	    break;
 	  }
 	}
@@ -8959,7 +9557,7 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
 	      )
 	  {
 	    CheckElementChangePage(hitx, hity, touched_element,
-				   CE_OTHER_GETS_HIT, i);
+				   hitting_element, CE_OTHER_GETS_HIT, i);
 	    break;
 	  }
 	}
@@ -8968,6 +9566,114 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
   }
 }
 
+#if 0
+void TestIfElementSmashesCustomElement(int x, int y, int direction)
+{
+  int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
+  int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
+  int hitx = x + dx, hity = y + dy;
+  int hitting_element = Feld[x][y];
+  int touched_element;
+#if 0
+  boolean object_hit = (IN_LEV_FIELD(hitx, hity) &&
+			!IS_FREE(hitx, hity) &&
+			(!IS_MOVING(hitx, hity) ||
+			 MovDir[hitx][hity] != direction ||
+			 ABS(MovPos[hitx][hity]) <= TILEY / 2));
+#endif
+
+  if (IN_LEV_FIELD(hitx, hity) && IS_FREE(hitx, hity))
+    return;
+
+#if 0
+  if (IN_LEV_FIELD(hitx, hity) && !object_hit)
+    return;
+#endif
+
+  touched_element = (IN_LEV_FIELD(hitx, hity) ?
+		     MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
+
+  CheckElementChangeSide(x, y, hitting_element, touched_element,
+			 EP_CAN_SMASH_EVERYTHING, direction);
+
+  if (IN_LEV_FIELD(hitx, hity))
+  {
+    int opposite_direction = MV_DIR_OPPOSITE(direction);
+    int hitting_side = direction;
+    int touched_side = opposite_direction;
+#if 0
+    int touched_element = MovingOrBlocked2Element(hitx, hity);
+#endif
+#if 1
+    boolean object_hit = (!IS_MOVING(hitx, hity) ||
+			  MovDir[hitx][hity] != direction ||
+			  ABS(MovPos[hitx][hity]) <= TILEY / 2);
+
+    object_hit = TRUE;
+#endif
+
+    if (object_hit)
+    {
+      int i;
+
+      CheckElementChangeSide(hitx, hity, touched_element, hitting_element,
+			     CE_SMASHED_BY_SOMETHING, opposite_direction);
+
+      if (IS_CUSTOM_ELEMENT(hitting_element) &&
+	  HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_SMASHING))
+      {
+	for (i = 0; i < element_info[hitting_element].num_change_pages; i++)
+	{
+	  struct ElementChangeInfo *change =
+	    &element_info[hitting_element].change_page[i];
+
+	  if (change->can_change &&
+	      change->events & CH_EVENT_BIT(CE_OTHER_IS_SMASHING) &&
+	      change->trigger_side & touched_side &&
+	  
+#if 1
+	      IS_EQUAL_OR_IN_GROUP(touched_element, change->trigger_element)
+#else
+	      change->trigger_element == touched_element
+#endif
+	      )
+	  {
+	    CheckElementChangePage(x, y, hitting_element, touched_element,
+				   CE_OTHER_IS_SMASHING, i);
+	    break;
+	  }
+	}
+      }
+
+      if (IS_CUSTOM_ELEMENT(touched_element) &&
+	  HAS_ANY_CHANGE_EVENT(touched_element, CE_OTHER_GETS_SMASHED))
+      {
+	for (i = 0; i < element_info[touched_element].num_change_pages; i++)
+	{
+	  struct ElementChangeInfo *change =
+	    &element_info[touched_element].change_page[i];
+
+	  if (change->can_change &&
+	      change->events & CH_EVENT_BIT(CE_OTHER_GETS_SMASHED) &&
+	      change->trigger_side & hitting_side &&
+#if 1
+	      IS_EQUAL_OR_IN_GROUP(hitting_element, change->trigger_element)
+#else
+	      change->trigger_element == hitting_element
+#endif
+	      )
+	  {
+	    CheckElementChangePage(hitx, hity, touched_element,
+				   hitting_element, CE_OTHER_GETS_SMASHED, i);
+	    break;
+	  }
+	}
+      }
+    }
+  }
+}
+#endif
+
 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
 {
   int i, kill_x = -1, kill_y = -1;
@@ -9459,6 +10165,10 @@ int DigField(struct PlayerInfo *player,
       DOUBLE_PLAYER_SPEED(player);
 #endif
 
+#if 0
+      printf("::: passing port %d,%d [%d]\n", x, y, FrameCounter);
+#endif
+
       PlayLevelSound(x, y, SND_CLASS_SP_PORT_PASSING);
       break;
 
@@ -9607,7 +10317,7 @@ int DigField(struct PlayerInfo *player,
 	PlayLevelSoundElementAction(x, y, element, ACTION_DIGGING);
 
 	CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_DIGGED,
-					  player->index_bit, CH_SIDE_ANY);
+					  player->index_bit, dig_side);
 
 #if 1
 	if (mode == DF_SNAP)
@@ -9707,7 +10417,7 @@ int DigField(struct PlayerInfo *player,
 
 	CheckTriggeredElementChangePlayer(x, y, element,
 					  CE_OTHER_GETS_COLLECTED,
-					  player->index_bit, CH_SIDE_ANY);
+					  player->index_bit, dig_side);
 
 #if 1
 	if (mode == DF_SNAP)
@@ -10003,8 +10713,13 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy)
 			dy == -1 ? MV_UP :
 			dy == +1 ? MV_DOWN : MV_NO_MOVING);
 
+#if 0
+  if (player->MovPos)
+    return FALSE;
+#else
   if (player->MovPos && game.engine_version >= VERSION_IDENT(2,2,0,0))
     return FALSE;
+#endif
 
   if (!player->active || !IN_LEV_FIELD(x, y))
     return FALSE;
@@ -10067,15 +10782,25 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy)
 
 boolean DropElement(struct PlayerInfo *player)
 {
+  static int trigger_sides[4] =
+  {
+    CH_SIDE_LEFT,	/* dropping left  */
+    CH_SIDE_RIGHT,	/* dropping right */
+    CH_SIDE_TOP,	/* dropping up    */
+    CH_SIDE_BOTTOM,	/* dropping down  */
+  };
   int jx = player->jx, jy = player->jy;
+  int drop_direction = player->MovDir;
+  int drop_side = trigger_sides[MV_DIR_BIT(drop_direction)];
   int old_element = Feld[jx][jy];
-  int new_element = (player->inventory_size > 0 ?
-		     player->inventory_element[player->inventory_size - 1] :
-		     player->inventory_infinite_element != EL_UNDEFINED ?
-		     player->inventory_infinite_element :
-		     player->dynabombs_left > 0 ?
-		     EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
-		     EL_UNDEFINED);
+  int drop_element = (player->inventory_size > 0 ?
+		      player->inventory_element[player->inventory_size - 1] :
+		      player->inventory_infinite_element != EL_UNDEFINED ?
+		      player->inventory_infinite_element :
+		      player->dynabombs_left > 0 ?
+		      EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr :
+		      EL_UNDEFINED);
+  int new_element = drop_element;	/* default: element does not change */
 
   /* check if player is active, not moving and ready to drop */
   if (!player->active || player->MovPos || player->drop_delay > 0)
@@ -10146,9 +10871,9 @@ boolean DropElement(struct PlayerInfo *player)
 
     CheckTriggeredElementChangePlayer(jx, jy, new_element,
 				      CE_OTHER_GETS_DROPPED,
-				      player->index_bit, CH_SIDE_ANY);
+				      player->index_bit, drop_side);
     CheckElementChangePlayer(jx, jy, new_element, CE_DROPPED_BY_PLAYER,
-			     player->index_bit, CH_SIDE_ANY);
+			     player->index_bit, drop_side);
 
     TestIfElementTouchesCustomElement(jx, jy);
   }
@@ -10183,12 +10908,14 @@ boolean DropElement(struct PlayerInfo *player)
 #endif
   }
 
-  new_element = Feld[jx][jy];
+  new_element = Feld[jx][jy];		/* element might have changed */
 
   if (IS_CUSTOM_ELEMENT(new_element) && CAN_MOVE(new_element) &&
       element_info[new_element].move_pattern == MV_WHEN_DROPPED)
   {
+#if 0
     int move_stepsize = element_info[new_element].move_stepsize;
+#endif
     int direction, dx, dy, nextx, nexty;
 
     if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
@@ -10216,18 +10943,24 @@ boolean DropElement(struct PlayerInfo *player)
 #if 1
       TestIfElementHitsCustomElement(jx, jy, direction);
 #else
-      CheckElementChangeSide(jx, jy, new_element, CE_HITTING_SOMETHING,
-			     direction);
+      CheckElementChangeSide(jx, jy, new_element, touched_element,
+			     CE_HITTING_SOMETHING, direction);
 #endif
     }
 
+#if 0
     player->drop_delay = 2 * TILEX / move_stepsize + 1;
+#endif
   }
 
 #if 0
   player->drop_delay = 8 + 8 + 8;
 #endif
 
+#if 1
+  player->drop_delay = GET_NEW_DROP_DELAY(drop_element);
+#endif
+
 #endif
 
   player->is_dropping = TRUE;
@@ -10451,7 +11184,19 @@ void RequestQuitGame(boolean ask_if_really_quit)
   }
   else
   {
+
+#if 1
+    if (tape.playing && tape.deactivate_display)
+      TapeDeactivateDisplayOff(TRUE);
+#endif
+
     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
+
+#if 1
+    if (tape.playing && tape.deactivate_display)
+      TapeDeactivateDisplayOn();
+#endif
+
   }
 }