X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=59ced41619717c82f6fc88b6e1a34d074651ccb7;hb=af07d74262e7d5075feaea67fa16c04c6be0e3f6;hp=2731d0ef9cd301832ead0a7081d430670ad2ce63;hpb=b611c2d6ac899a0f03450eb3d56270296bef3c35;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index 2731d0ef..59ced416 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
@@ -94,10 +96,15 @@
 /* values for other actions */
 #define MOVE_STEPSIZE_NORMAL	(TILEX / MOVE_DELAY_NORMAL_SPEED)
 
+#define GET_DX_FROM_DIR(d)	((d) == MV_LEFT ? -1 : (d) == MV_RIGHT ? 1 : 0)
+#define GET_DY_FROM_DIR(d)	((d) == MV_UP   ? -1 : (d) == MV_DOWN  ? 1 : 0)
+
 #define	INIT_GFX_RANDOM()	(SimpleRND(1000000))
 
 #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) + \
@@ -107,6 +114,9 @@
 	((e) == EL_TRIGGER_ELEMENT ? (ch)->actual_trigger_element :	\
 	 (e) == EL_TRIGGER_PLAYER  ? (ch)->actual_trigger_player : (e))
 
+#define CAN_GROW_INTO(e)						\
+	(e == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
+
 #define ELEMENT_CAN_ENTER_FIELD_BASE_X(x, y, condition)			\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
 					(condition)))
@@ -261,6 +271,11 @@
 #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))
 
+#define ACCESS_FROM(e, d)		(element_info[e].access_direction &(d))
+#define IS_WALKABLE_FROM(e, d)		(IS_WALKABLE(e)   && ACCESS_FROM(e, d))
+#define IS_PASSABLE_FROM(e, d)		(IS_PASSABLE(e)   && ACCESS_FROM(e, d))
+#define IS_ACCESSIBLE_FROM(e, d)	(IS_ACCESSIBLE(e) && ACCESS_FROM(e, d))
+
 /* game button identifiers */
 #define GAME_CTRL_ID_STOP		0
 #define GAME_CTRL_ID_PAUSE		1
@@ -301,22 +316,22 @@ static boolean CheckTriggeredElementChangeExt(int, int, int, int, int,int,int);
 #define CheckTriggeredElementChange(x, y, e, ev)			\
 	CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY,	\
 				       CH_SIDE_ANY, -1)
-#define CheckTriggeredElementChangePlayer(x, y, e, ev, p, s)		\
+#define CheckTriggeredElementChangeByPlayer(x, y, e, ev, p, s)		\
 	CheckTriggeredElementChangeExt(x, y, e, ev, p, s, -1)
-#define CheckTriggeredElementChangeSide(x, y, e, ev, s)			\
+#define CheckTriggeredElementChangeBySide(x, y, e, ev, s)		\
 	CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY, s, -1)
-#define CheckTriggeredElementChangePage(x, y, e, ev, p)			\
+#define CheckTriggeredElementChangeByPage(x, y, e, ev, p)		\
 	CheckTriggeredElementChangeExt(x, y, e, ev, CH_PLAYER_ANY,	\
 				       CH_SIDE_ANY, p)
 
 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)			\
+#define CheckElementChangeByPlayer(x, y, e, ev, p, s)			\
 	CheckElementChangeExt(x, y, e, EL_EMPTY, ev, p, s, CH_PAGE_ANY)
-#define CheckElementChangeSide(x, y, e, te, ev, s)			\
+#define CheckElementChangeBySide(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)			\
+#define CheckElementChangeByPage(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);
@@ -592,7 +607,7 @@ struct
   int element;
   int direction;
 }
-tube_access[] =
+access_direction_list[] =
 {
   { EL_TUBE_ANY,		MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
   { EL_TUBE_VERTICAL,		                     MV_UP | MV_DOWN },
@@ -606,7 +621,19 @@ tube_access[] =
   { EL_TUBE_RIGHT_UP,		          MV_RIGHT | MV_UP           },
   { EL_TUBE_RIGHT_DOWN,		          MV_RIGHT |         MV_DOWN },
 
-  { EL_UNDEFINED,		0				     }
+  { EL_SP_PORT_LEFT,		          MV_RIGHT                   },
+  { EL_SP_PORT_RIGHT,		MV_LEFT                              },
+  { EL_SP_PORT_UP,		                             MV_DOWN },
+  { EL_SP_PORT_DOWN,		                     MV_UP           },
+  { EL_SP_PORT_HORIZONTAL,	MV_LEFT | MV_RIGHT                   },
+  { EL_SP_PORT_VERTICAL,	                     MV_UP | MV_DOWN },
+  { EL_SP_PORT_ANY,		MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
+  { EL_SP_GRAVITY_PORT_LEFT,	          MV_RIGHT                   },
+  { EL_SP_GRAVITY_PORT_RIGHT,	MV_LEFT                              },
+  { EL_SP_GRAVITY_PORT_UP,	                             MV_DOWN },
+  { EL_SP_GRAVITY_PORT_DOWN,	                     MV_UP           },
+
+  { EL_UNDEFINED,		MV_NO_MOVING			     }
 };
 
 static unsigned long trigger_events[MAX_NUM_ELEMENTS];
@@ -975,9 +1002,10 @@ static inline void InitField_WithBug2(int x, int y, boolean init_game)
   /* this case is in fact a combination of not less than three bugs:
      first, it calls InitMovDir() for elements that can move, although this is
      already done by InitField(); then, it checks the element that was at this
-     field _before_ the call to InitField() (which can change it)
-
- */
+     field _before_ the call to InitField() (which can change it); lastly, it
+     was not called for "mole with direction" elements, which were treated as
+     "cannot move" due to (fixed) wrong element initialization in "src/init.c"
+  */
 }
 
 inline void DrawGameValue_Emeralds(int value)
@@ -1201,6 +1229,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
@@ -1345,6 +1377,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++)
@@ -1352,6 +1385,7 @@ static void InitGameEngine()
     element_info[i].can_leave_element = FALSE;
     element_info[i].can_leave_element_last = FALSE;
   }
+#endif
 
   /* ---------- initialize gem count --------------------------------------- */
 
@@ -1367,15 +1401,15 @@ static void InitGameEngine()
 
   /* ---------- initialize access direction -------------------------------- */
 
-  /* initialize access direction values to default */
+  /* initialize access direction values to default (access from every side) */
   for (i = 0; i < MAX_NUM_ELEMENTS; i++)
     if (!IS_CUSTOM_ELEMENT(i))
       element_info[i].access_direction = MV_ALL_DIRECTIONS;
 
   /* set access direction value for certain elements from pre-defined list */
-  for (i = 0; tube_access[i].element != EL_UNDEFINED; i++)
-    element_info[tube_access[i].element].access_direction =
-      tube_access[i].direction;
+  for (i = 0; access_direction_list[i].element != EL_UNDEFINED; i++)
+    element_info[access_direction_list[i].element].access_direction =
+      access_direction_list[i].direction;
 }
 
 
@@ -1459,6 +1493,7 @@ void InitGame()
 
     player->is_waiting = FALSE;
     player->is_moving = FALSE;
+    player->is_auto_moving = FALSE;
     player->is_digging = FALSE;
     player->is_snapping = FALSE;
     player->is_collecting = FALSE;
@@ -1601,6 +1636,7 @@ void InitGame()
       AmoebaNr[x][y] = 0;
       WasJustMoving[x][y] = 0;
       WasJustFalling[x][y] = 0;
+      CheckCollision[x][y] = 0;
       Stop[x][y] = FALSE;
       Pushed[x][y] = FALSE;
 
@@ -1609,7 +1645,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;
@@ -1649,7 +1685,7 @@ void InitGame()
     if (!IS_CUSTOM_ELEMENT(i))
     {
       int num_phase = 8;
-      int delay = ((IS_SP_ELEMENT(i) &&
+      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;
@@ -2070,6 +2106,12 @@ void InitMovDir(int x, int y)
 	else if (move_pattern == MV_ALONG_LEFT_SIDE ||
 		 move_pattern == MV_ALONG_RIGHT_SIDE)
 	{
+#if 1
+	  /* use random direction as default start direction */
+	  if (game.engine_version >= VERSION_IDENT(3,1,0,2))
+	    MovDir[x][y] = 1 << RND(4);
+#endif
+
 	  for (i = 0; i < NUM_DIRECTIONS; i++)
 	  {
 	    int x1 = x + xy[i][0];
@@ -2480,6 +2522,10 @@ static void RemoveField(int x, int y)
   ChangePage[x][y] = -1;
   Pushed[x][y] = FALSE;
 
+#if 0
+  ExplodeField[x][y] = EX_TYPE_NONE;
+#endif
+
   GfxElement[x][y] = EL_UNDEFINED;
   GfxAction[x][y] = ACTION_DEFAULT;
   GfxDir[x][y] = MV_NO_MOVING;
@@ -2610,7 +2656,7 @@ 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;
@@ -2703,9 +2749,11 @@ void RelocatePlayer(int x, int y, int element_raw)
   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 */
@@ -2840,11 +2888,12 @@ void Explode(int ex, int ey, int phase, int mode)
     /* --- 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 */
@@ -2879,11 +2928,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
@@ -3022,7 +3080,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
@@ -3212,6 +3270,10 @@ 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
@@ -3345,7 +3407,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++)
   {
@@ -3364,14 +3426,18 @@ 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);
 
+#if 1
+      if (element != EL_EMPTY && element != EL_EXPLOSION &&
+	  !CAN_GROW_INTO(element) && !dynabomb_xl)
+	break;
+#else
       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
-      if (element != EL_EMPTY &&
-	  element != EL_SAND &&
-	  element != EL_EXPLOSION &&
-	  !dynabomb_xl)
+      if (element != EL_EMPTY && element != EL_EXPLOSION &&
+	  element != EL_SAND && !dynabomb_xl)
 	break;
+#endif
     }
   }
 }
@@ -3424,7 +3490,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:
@@ -3442,17 +3508,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;
   }
 
@@ -3877,6 +3947,7 @@ void Impact(int x, int y)
     return;
   }
 
+  /* !!! not sufficient for all cases -- see EL_PEARL below !!! */
   /* only reset graphic animation if graphic really changes after impact */
   if (impact &&
       el_act_dir2img(element, GfxAction[x][y], MV_DOWN) != el2img(element))
@@ -3892,6 +3963,8 @@ void Impact(int x, int y)
   }
   else if (impact && element == EL_PEARL)
   {
+    ResetGfxAnimation(x, y);
+
     Feld[x][y] = EL_PEARL_BREAKING;
     PlayLevelSound(x, y, SND_PEARL_BREAKING);
     return;
@@ -4011,6 +4084,8 @@ void Impact(int x, int y)
 	}
 	else if (smashed == EL_PEARL)
 	{
+	  ResetGfxAnimation(x, y);
+
 	  Feld[x][y + 1] = EL_PEARL_BREAKING;
 	  PlayLevelSound(x, y, SND_PEARL_BREAKING);
 	  return;
@@ -4043,10 +4118,18 @@ void Impact(int x, int y)
 
 	  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, element,
-				 CE_SWITCHED, CH_SIDE_TOP);
+#if 1
+	  /* !!! TEST ONLY !!! */
+	  CheckElementChangeBySide(x, y + 1, smashed, element,
+				   CE_SWITCHED, CH_SIDE_TOP);
+	  CheckTriggeredElementChangeBySide(x, y + 1, smashed,
+					    CE_OTHER_IS_SWITCHING,CH_SIDE_TOP);
+#else
+	  CheckTriggeredElementChangeBySide(x, y + 1, smashed,
+					    CE_OTHER_IS_SWITCHING,CH_SIDE_TOP);
+	  CheckElementChangeBySide(x, y + 1, smashed, element,
+				   CE_SWITCHED, CH_SIDE_TOP);
+#endif
 	}
       }
       else
@@ -4426,7 +4509,13 @@ inline static void TurnRoundExt(int x, int y)
       }
     }
 
+#if 1
+    if (element == EL_ROBOT && ZX >= 0 && ZY >= 0 &&
+	(Feld[ZX][ZY] == EL_ROBOT_WHEEL_ACTIVE ||
+	 game.engine_version < VERSION_IDENT(3,1,0,0)))
+#else
     if (element == EL_ROBOT && ZX >= 0 && ZY >= 0)
+#endif
     {
       attr_x = ZX;
       attr_y = ZY;
@@ -4970,12 +5059,16 @@ void StartMoving(int x, int y)
 #endif
     }
 #if 1
-    else if ((game.engine_version < VERSION_IDENT(2,2,0,7) &&
-	      CAN_SMASH(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
-	      (Feld[x][y + 1] == EL_BLOCKED)) ||
+    else if ((game.engine_version >= VERSION_IDENT(3,1,0,0) &&
+	      CheckCollision[x][y] && !IS_FREE(x, y + 1)) ||
+
 	     (game.engine_version >= VERSION_IDENT(3,0,7,0) &&
 	      CAN_SMASH(element) && WasJustFalling[x][y] &&
-	      (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))))
+	      (Feld[x][y + 1] == EL_BLOCKED || IS_PLAYER(x, y + 1))) ||
+
+	     (game.engine_version < VERSION_IDENT(2,2,0,7) &&
+	      CAN_SMASH(element) && WasJustMoving[x][y] && !Pushed[x][y + 1] &&
+	      (Feld[x][y + 1] == EL_BLOCKED)))
 
 #else
 #if 1
@@ -5136,10 +5229,16 @@ void StartMoving(int x, int y)
       return;
 #endif
 
+#if 1
+
 #if 1
+    if (game.engine_version >= VERSION_IDENT(3,1,0,0) &&
+	CheckCollision[x][y] && IN_LEV_FIELD_AND_NOT_FREE(newx, newy))
+#else
     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)))
+#endif
     {
 #if 0
       printf("::: element %d '%s' WasJustMoving %d [%d, %d, %d, %d]\n",
@@ -5307,11 +5406,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))
 	    {
@@ -5508,11 +5626,27 @@ void StartMoving(int x, int y)
 	  DrawLevelField(newx, newy);
 	}
 
+	/* if digged element was about to explode, prevent the explosion */
+	ExplodeField[newx][newy] = EX_TYPE_NONE;
+
 	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)))
+	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)
       {
@@ -5565,11 +5699,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;
 	}
@@ -5701,6 +5849,7 @@ void StartMoving(int x, int y)
 void ContinueMoving(int x, int y)
 {
   int element = Feld[x][y];
+  int stored = Store[x][y];
   struct ElementInfo *ei = &element_info[element];
   int direction = MovDir[x][y];
   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
@@ -5805,16 +5954,34 @@ void ContinueMoving(int x, int y)
   {
     element = Feld[newx][newy] = EL_ACID;
   }
+#if 0
+  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 */
 
-  Store[x][y] = 0;
+    Feld[x][y] = ei->move_leave_element;
+    InitField(x, y, FALSE);
+
+    if (GFX_CRUMBLED(Feld[x][y]))
+      DrawLevelFieldCrumbledSandNeighbours(x, y);
+  }
+#endif
+
+  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;
@@ -5832,6 +5999,22 @@ void ContinueMoving(int x, int y)
   ResetGfxAnimation(x, y);	/* reset animation values for old field */
 
 #if 1
+  if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) &&
+      ei->move_leave_element != EL_EMPTY &&
+      (ei->move_leave_type == LEAVE_TYPE_UNLIMITED ||
+       stored != 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
+
+#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 &&
@@ -5866,9 +6049,18 @@ void ContinueMoving(int x, int y)
     MovDir[newx][newy] = 0;
   */
 
+#if 0
   if (!CAN_MOVE(element) ||
       (CAN_FALL(element) && direction == MV_DOWN))
     GfxDir[x][y] = MovDir[newx][newy] = 0;
+#else
+  if (!CAN_MOVE(element) ||
+      (CAN_FALL(element) && direction == MV_DOWN &&
+       (element == EL_SPRING ||
+	element_info[element].move_pattern == MV_WHEN_PUSHED ||
+	element_info[element].move_pattern == MV_WHEN_DROPPED)))
+    GfxDir[x][y] = MovDir[newx][newy] = 0;
+#endif
 
 #endif
 #endif
@@ -5893,10 +6085,16 @@ void ContinueMoving(int x, int y)
 
   if (!pushed_by_player)
   {
+    int nextx = newx + dx, nexty = newy + dy;
+    boolean check_collision_again = IN_LEV_FIELD_AND_IS_FREE(nextx, nexty);
+
     WasJustMoving[newx][newy] = 3;
 
     if (CAN_FALL(element) && direction == MV_DOWN)
       WasJustFalling[newx][newy] = 3;
+
+    if ((!CAN_FALL(element) || direction == MV_DOWN) && check_collision_again)
+      CheckCollision[newx][newy] = 2;
   }
 
   if (DONT_TOUCH(element))	/* object may be nasty to player or others */
@@ -5914,6 +6112,26 @@ void ContinueMoving(int x, int y)
       (newy == lev_fieldy - 1 || !IS_FREE(x, newy + 1)))
     Impact(x, newy);
 
+#if 1
+  if (pushed_by_player)
+  {
+    static int trigger_sides[4] =
+    {
+      CH_SIDE_RIGHT,	/* moving left  */
+      CH_SIDE_LEFT,	/* moving right */
+      CH_SIDE_BOTTOM,	/* moving up    */
+      CH_SIDE_TOP,	/* moving down  */
+    };
+    int dig_side = trigger_sides[MV_DIR_BIT(direction)];
+    struct PlayerInfo *player = PLAYERINFO(x, y);
+
+    CheckElementChangeByPlayer(newx, newy, element, CE_PUSHED_BY_PLAYER,
+			       player->index_bit, dig_side);
+    CheckTriggeredElementChangeByPlayer(newx,newy,element,CE_OTHER_GETS_PUSHED,
+					player->index_bit, dig_side);
+  }
+#endif
+
 #if 1
   TestIfElementTouchesCustomElement(x, y);	/* empty or new element */
 #endif
@@ -5934,8 +6152,8 @@ void ContinueMoving(int x, int y)
     int hitting_element = Feld[newx][newy];
 
     /* !!! fix side (direction) orientation here and elsewhere !!! */
-    CheckElementChangeSide(newx, newy, hitting_element, CE_HITTING_SOMETHING,
-			   direction);
+    CheckElementChangeBySide(newx, newy, hitting_element, CE_HITTING_SOMETHING,
+			     direction);
 
 #if 0
     if (IN_LEV_FIELD(nextx, nexty))
@@ -5952,8 +6170,8 @@ void ContinueMoving(int x, int y)
       {
 	int i;
 
-	CheckElementChangeSide(nextx, nexty, touched_element,
-			       CE_HIT_BY_SOMETHING, opposite_direction);
+	CheckElementChangeBySide(nextx, nexty, touched_element,
+				 CE_HIT_BY_SOMETHING, opposite_direction);
 
 	if (IS_CUSTOM_ELEMENT(hitting_element) &&
 	    HAS_ANY_CHANGE_EVENT(hitting_element, CE_OTHER_IS_HITTING))
@@ -5968,8 +6186,8 @@ void ContinueMoving(int x, int y)
 		change->trigger_side & touched_side &&
 		change->trigger_element == touched_element)
 	    {
-	      CheckElementChangePage(newx, newy, hitting_element,
-				     touched_element, CE_OTHER_IS_HITTING, i);
+	      CheckElementChangeByPage(newx, newy, hitting_element,
+				       touched_element, CE_OTHER_IS_HITTING,i);
 	      break;
 	    }
 	  }
@@ -5988,8 +6206,8 @@ void ContinueMoving(int x, int y)
 		change->trigger_side & hitting_side &&
 		change->trigger_element == hitting_element)
 	    {
-	      CheckElementChangePage(nextx, nexty, touched_element,
-				     hitting_element, CE_OTHER_GETS_HIT, i);
+	      CheckElementChangeByPage(nextx, nexty, touched_element,
+				       hitting_element, CE_OTHER_GETS_HIT, i);
 	      break;
 	    }
 	  }
@@ -6305,6 +6523,15 @@ void AmoebeAbleger(int ax, int ay)
     if (!IN_LEV_FIELD(x, y))
       return;
 
+#if 1
+    if (IS_FREE(x, y) ||
+	CAN_GROW_INTO(Feld[x][y]) ||
+	Feld[x][y] == EL_QUICKSAND_EMPTY)
+    {
+      newax = x;
+      neway = y;
+    }
+#else
     /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
     if (IS_FREE(x, y) ||
 	Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
@@ -6312,6 +6539,7 @@ void AmoebeAbleger(int ax, int ay)
       newax = x;
       neway = y;
     }
+#endif
 
     if (newax == ax && neway == ay)
       return;
@@ -6330,6 +6558,16 @@ void AmoebeAbleger(int ax, int ay)
       if (!IN_LEV_FIELD(x, y))
 	continue;
 
+#if 1
+      if (IS_FREE(x, y) ||
+	  CAN_GROW_INTO(Feld[x][y]) ||
+	  Feld[x][y] == EL_QUICKSAND_EMPTY)
+      {
+	newax = x;
+	neway = y;
+	break;
+      }
+#else
       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
       if (IS_FREE(x, y) ||
 	  Feld[x][y] == EL_SAND || Feld[x][y] == EL_QUICKSAND_EMPTY)
@@ -6338,13 +6576,18 @@ void AmoebeAbleger(int ax, int ay)
 	neway = y;
 	break;
       }
+#endif
       else if (IS_PLAYER(x, y))
 	waiting_for_player = TRUE;
     }
 
     if (newax == ax && neway == ay)		/* amoeba cannot grow */
     {
+#if 1
+      if (i == 4 && (!waiting_for_player || element == EL_BD_AMOEBA))
+#else
       if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH))
+#endif
       {
 	Feld[ax][ay] = EL_AMOEBA_DEAD;
 	DrawLevelField(ax, ay);
@@ -6475,6 +6718,20 @@ void Life(int ax, int ay)
 	changed = TRUE;
       }
     }
+#if 1
+    else if (IS_FREE(xx, yy) || CAN_GROW_INTO(Feld[xx][yy]))
+    {					/* free border field */
+      if (nachbarn >= life[2] && nachbarn <= life[3])
+      {
+	Feld[xx][yy] = element;
+	MovDelay[xx][yy] = (element == EL_GAME_OF_LIFE ? 0 : life_time-1);
+	if (!Stop[xx][yy])
+	  DrawLevelField(xx, yy);
+	Stop[xx][yy] = TRUE;
+	changed = TRUE;
+      }
+    }
+#else
     /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
     else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_SAND)
     {					/* free border field */
@@ -6488,6 +6745,7 @@ void Life(int ax, int ay)
 	changed = TRUE;
       }
     }
+#endif
   }
 
   if (changed)
@@ -6513,7 +6771,12 @@ static void StopRobotWheel(int x, int y)
 
 static void InitTimegateWheel(int x, int y)
 {
+#if 1
+  ChangeDelay[x][y] = level.time_timegate * FRAMES_PER_SECOND;
+#else
+  /* another brainless, "type style" bug ... :-( */
   ChangeDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
+#endif
 }
 
 static void RunTimegateWheel(int x, int y)
@@ -6969,7 +7232,7 @@ static boolean ChangeElementNow(int x, int y, int element, int page)
 
   Changed[x][y] |= ChangeEvent[x][y];	/* ignore same changes in this frame */
 
-  CheckTriggeredElementChangePage(x,y, Feld[x][y], CE_OTHER_IS_CHANGING, page);
+  CheckTriggeredElementChangeByPage(x,y,Feld[x][y], CE_OTHER_IS_CHANGING,page);
 
   if (change->explode)
   {
@@ -6988,6 +7251,8 @@ static boolean ChangeElementNow(int x, int y, int element, int page)
     {
       boolean is_empty;
       boolean is_diggable;
+      boolean is_collectible;
+      boolean is_removable;
       boolean is_destructible;
       int ex = x + xx - 1;
       int ey = y + yy - 1;
@@ -7020,14 +7285,24 @@ static boolean ChangeElementNow(int x, int y, int element, int page)
 	e = MovingOrBlocked2Element(ex, ey);
 
 #if 1
+
+#if 1
+      is_empty = (IS_FREE(ex, ey) || (IS_FREE_OR_PLAYER(ex, ey) &&
+				      IS_WALKABLE(content_element)));
+#else
       is_empty = (IS_FREE(ex, ey) || (IS_PLAYER(ex, ey) &&
 				      IS_WALKABLE(content_element)));
+#endif
       is_diggable = (is_empty || IS_DIGGABLE(e));
+      is_collectible = (is_empty || IS_COLLECTIBLE(e));
+      is_removable = (is_diggable || is_collectible);
       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_EMPTY        && is_empty) ||
+	 (change->replace_when == CP_WHEN_DIGGABLE     && is_diggable) ||
+	 (change->replace_when == CP_WHEN_COLLECTIBLE  && is_collectible) ||
+	 (change->replace_when == CP_WHEN_REMOVABLE    && is_removable) ||
 	 (change->replace_when == CP_WHEN_DESTRUCTIBLE && is_destructible));
 
       if (!can_replace[xx][yy])
@@ -7108,9 +7383,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",
@@ -7119,8 +7393,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 +
@@ -7264,6 +7548,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)
   {
@@ -7681,7 +7979,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 ---------- */
@@ -7919,6 +8217,8 @@ void GameActions()
       WasJustMoving[x][y]--;
     if (WasJustFalling[x][y] > 0)
       WasJustFalling[x][y]--;
+    if (CheckCollision[x][y] > 0)
+      CheckCollision[x][y]--;
 
     GfxFrame[x][y]++;
 
@@ -8065,7 +8365,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);
@@ -8148,6 +8448,21 @@ void GameActions()
 #endif
       element = Feld[x][y];
 
+#if 1
+      if (!IS_PLAYER(x,y) &&
+	  (element == EL_EMPTY ||
+	   CAN_GROW_INTO(element) ||
+	   element == EL_QUICKSAND_EMPTY ||
+	   element == EL_ACID_SPLASH_LEFT ||
+	   element == EL_ACID_SPLASH_RIGHT))
+      {
+	if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBA_WET) ||
+	    (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBA_WET) ||
+	    (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBA_WET) ||
+	    (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
+	  Feld[x][y] = EL_AMOEBA_DROP;
+      }
+#else
       /* !!! extend EL_SAND to anything diggable (but maybe not SP_BASE) !!! */
       if (!IS_PLAYER(x,y) &&
 	  (element == EL_EMPTY ||
@@ -8162,6 +8477,7 @@ void GameActions()
 	    (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBA_WET))
 	  Feld[x][y] = EL_AMOEBA_DROP;
       }
+#endif
 
       random = random * 129 + 1;
     }
@@ -8181,9 +8497,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;
@@ -8434,6 +8750,7 @@ void ScrollLevel(int dx, int dy)
   redraw_mask |= REDRAW_FIELD;
 }
 
+#if 0
 static boolean canEnterSupaplexPort(int x, int y, int dx, int dy)
 {
   int nextx = x + dx, nexty = y + dy;
@@ -8465,6 +8782,63 @@ static boolean canEnterSupaplexPort(int x, int y, int dx, int dy)
 
   return TRUE;
 }
+#endif
+
+static boolean canFallDown(struct PlayerInfo *player)
+{
+  int jx = player->jx, jy = player->jy;
+
+  return (IN_LEV_FIELD(jx, jy + 1) &&
+	  (IS_FREE(jx, jy + 1) ||
+	   (Feld[jx][jy + 1] == EL_ACID && player->can_fall_into_acid)) &&
+	  IS_WALKABLE_FROM(Feld[jx][jy], MV_DOWN) &&
+	  !IS_WALKABLE_INSIDE(Feld[jx][jy]));
+}
+
+static boolean canPassField(int x, int y, int move_dir)
+{
+  int opposite_dir = MV_DIR_OPPOSITE(move_dir);
+  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 nextx = x + dx;
+  int nexty = y + dy;
+  int element = Feld[x][y];
+
+  return (IS_PASSABLE_FROM(element, opposite_dir) &&
+	  !CAN_MOVE(element) &&
+	  IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
+	  IS_WALKABLE_FROM(Feld[nextx][nexty], move_dir) &&
+	  (level.can_pass_to_walkable || IS_FREE(nextx, nexty)));
+}
+
+static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
+{
+  int opposite_dir = MV_DIR_OPPOSITE(move_dir);
+  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 newx = x + dx;
+  int newy = y + dy;
+#if 0
+  int nextx = newx + dx;
+  int nexty = newy + dy;
+#endif
+
+#if 1
+  return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
+	  (IS_DIGGABLE(Feld[newx][newy]) ||
+	   IS_WALKABLE_FROM(Feld[newx][newy], opposite_dir) ||
+	   canPassField(newx, newy, move_dir)));
+#else
+  return (IN_LEV_FIELD(newx, newy) && !IS_FREE_OR_PLAYER(newx, newy) &&
+	  (IS_DIGGABLE(Feld[newx][newy]) ||
+	   IS_WALKABLE_FROM(Feld[newx][newy], opposite_dir) ||
+	   (IS_PASSABLE_FROM(Feld[newx][newy], opposite_dir) &&
+	    !CAN_MOVE(Feld[newx][newy]) &&
+	    IN_LEV_FIELD(nextx, nexty) && !IS_PLAYER(nextx, nexty) &&
+	    IS_WALKABLE_FROM(Feld[nextx][nexty], move_dir) &&
+	    (level.can_pass_to_walkable || IS_FREE(nextx, nexty)))));
+#endif
+}
 
 static void CheckGravityMovement(struct PlayerInfo *player)
 {
@@ -8477,56 +8851,97 @@ static void CheckGravityMovement(struct PlayerInfo *player)
     int move_dir_horizontal = player->action & MV_HORIZONTAL;
     int move_dir_vertical   = player->action & MV_VERTICAL;
 #endif
+
+#if 1
+    boolean player_is_snapping = player->effective_action & JOY_BUTTON_1;
+#else
+    boolean player_is_snapping = player->action & JOY_BUTTON_1;
+#endif
+
+    int jx = player->jx, jy = player->jy;
+
+    boolean player_is_moving_to_valid_field =
+      (!player_is_snapping &&
+       (canMoveToValidFieldWithGravity(jx, jy, move_dir_horizontal) ||
+	canMoveToValidFieldWithGravity(jx, jy, move_dir_vertical)));
+
+#if 0
     int move_dir =
       (player->last_move_dir & MV_HORIZONTAL ?
        (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
        (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
-    int jx = player->jx, jy = player->jy;
+#endif
+
+#if 0
+    int opposite_dir = MV_DIR_OPPOSITE(move_dir);
     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;
+    int nextx = new_jx + dx, nexty = new_jy + dy;
 #endif
+
+#if 1
+
 #if 1
+    boolean player_can_fall_down = canFallDown(player);
+#else
     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)));
+#endif
+
 #else
     boolean player_can_fall_down =
       (IN_LEV_FIELD(jx, jy + 1) &&
        (IS_FREE(jx, jy + 1)));
 #endif
+
+#if 0
     boolean player_is_moving_to_valid_field =
       (
 #if 1
        !player_is_snapping &&
 #endif
+
+#if 1
+       IN_LEV_FIELD(new_jx, new_jy) &&
+       (IS_DIGGABLE(Feld[new_jx][new_jy]) ||
+	(IS_SP_PORT(Feld[new_jx][new_jy]) &&
+	 element_info[Feld[new_jx][new_jy]].access_direction & opposite_dir &&
+	 IN_LEV_FIELD(nextx, nexty) &&
+	 element_info[Feld[nextx][nexty]].access_direction & move_dir))
+#else
        IN_LEV_FIELD(new_jx, new_jy) &&
        (Feld[new_jx][new_jy] == EL_SP_BASE ||
 	Feld[new_jx][new_jy] == EL_SAND ||
 	(IS_SP_PORT(Feld[new_jx][new_jy]) &&
-	 canEnterSupaplexPort(new_jx, new_jy, dx, dy))));
+	 canEnterSupaplexPort(new_jx, new_jy, dx, dy)))
     /* !!! extend EL_SAND to anything diggable !!! */
+#endif
+       );
+#endif
 
+#if 0
     boolean player_is_standing_on_valid_field =
       (IS_WALKABLE_INSIDE(Feld[jx][jy]) ||
-       (IS_WALKABLE(Feld[jx][jy]) &&
-	!(element_info[Feld[jx][jy]].access_direction & MV_DOWN)));
+       (IS_WALKABLE(Feld[jx][jy]) && !ACCESS_FROM(Feld[jx][jy], MV_DOWN)));
+#endif
 
 #if 0
-    printf("::: checking gravity NOW [%d, %d, %d] [%d] ...\n",
+    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 (player_can_fall_down &&
+#if 0
 	!player_is_standing_on_valid_field &&
+#endif
 	!player_is_moving_to_valid_field)
     {
 #if 0
@@ -8648,7 +9063,9 @@ boolean MovePlayerOneStep(struct PlayerInfo *player,
 
   player->step_counter++;
 
+#if 0
   player->drop_delay = 0;
+#endif
 
   PlayerVisit[jx][jy] = FrameCounter;
 
@@ -8657,17 +9074,17 @@ boolean MovePlayerOneStep(struct PlayerInfo *player,
 #if 0
   if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
   {
-    CheckTriggeredElementChangeSide(jx, jy, Feld[jx][jy], CE_OTHER_GETS_LEFT,
-				    leave_side);
-    CheckElementChangeSide(jx, jy, Feld[jx][jy], CE_LEFT_BY_PLAYER,leave_side);
+    CheckTriggeredElementChangeBySide(jx, jy, Feld[jx][jy], CE_OTHER_GETS_LEFT,
+				      leave_side);
+    CheckElementChangeBySide(jx,jy, Feld[jx][jy],CE_LEFT_BY_PLAYER,leave_side);
   }
 
   if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy]))
   {
-    CheckTriggeredElementChangeSide(new_jx, new_jy, Feld[new_jx][new_jy],
-				    CE_OTHER_GETS_ENTERED, enter_side);
-    CheckElementChangeSide(new_jx, new_jy, Feld[new_jx][new_jy],
-			   CE_ENTERED_BY_PLAYER, enter_side);
+    CheckTriggeredElementChangeBySide(new_jx, new_jy, Feld[new_jx][new_jy],
+				      CE_OTHER_GETS_ENTERED, enter_side);
+    CheckElementChangeBySide(new_jx, new_jy, Feld[new_jx][new_jy],
+			     CE_ENTERED_BY_PLAYER, enter_side);
   }
 #endif
 
@@ -8719,6 +9136,9 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
 
 #endif
 
+  /* store if player is automatically moved to next field */
+  player->is_auto_moving = (player->programmed_action != MV_NO_MOVING);
+
   /* remove the last programmed player action */
   player->programmed_action = 0;
 
@@ -8867,6 +9287,10 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
 
 #if 0
     /* !!! ENABLE THIS FOR OLD VERSIONS !!! */
+
+#if 1
+    if (game.engine_version < VERSION_IDENT(3,1,0,0))
+#endif
     {
       static int trigger_sides[4][2] =
       {
@@ -8881,24 +9305,23 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
       int leave_side = trigger_sides[MV_DIR_BIT(move_direction)][1];
 
 #if 1
+      /* !!! TEST ONLY !!! */
       if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
-      {
-	CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
+	CheckElementChangeByPlayer(old_jx, old_jy, Feld[old_jx][old_jy],
+				   CE_LEFT_BY_PLAYER,
+				   player->index_bit, leave_side);
+
+      CheckTriggeredElementChangeByPlayer(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);
-      }
 
       if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
-      {
-	CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
+	CheckElementChangeByPlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER,
+				   player->index_bit, enter_side);
+
+      CheckTriggeredElementChangeByPlayer(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
 
     }
@@ -9018,6 +9441,9 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
 #if 1
     /* !!! ENABLE THIS FOR NEW VERSIONS !!! */
     /* this breaks one level: "machine", level 000 */
+#if 0
+    if (game.engine_version >= VERSION_IDENT(3,1,0,0))
+#endif
     {
       static int trigger_sides[4][2] =
       {
@@ -9034,24 +9460,23 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
       int old_jy = last_jy;
 
 #if 1
+      /* !!! TEST ONLY !!! */
       if (IS_CUSTOM_ELEMENT(Feld[old_jx][old_jy]))
-      {
-	CheckTriggeredElementChangePlayer(old_jx, old_jy, Feld[old_jx][old_jy],
+	CheckElementChangeByPlayer(old_jx, old_jy, Feld[old_jx][old_jy],
+				   CE_LEFT_BY_PLAYER,
+				   player->index_bit, leave_side);
+
+      CheckTriggeredElementChangeByPlayer(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);
-      }
 
       if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
-      {
-	CheckTriggeredElementChangePlayer(jx, jy, Feld[jx][jy],
+	CheckElementChangeByPlayer(jx, jy, Feld[jx][jy], CE_ENTERED_BY_PLAYER,
+				   player->index_bit, enter_side);
+
+      CheckTriggeredElementChangeByPlayer(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
 
     }
@@ -9190,11 +9615,20 @@ void TestIfPlayerTouchesCustomElement(int x, int y)
       else
 	continue;		/* center and border element do not touch */
 
-      CheckTriggeredElementChangePlayer(xx, yy, border_element,
-					CE_OTHER_GETS_TOUCHED,
-					player->index_bit, border_side);
-      CheckElementChangePlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
-			       player->index_bit, border_side);
+#if 1
+      /* !!! TEST ONLY !!! */
+      CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
+				 player->index_bit, border_side);
+      CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
+					  CE_OTHER_GETS_TOUCHED,
+					  player->index_bit, border_side);
+#else
+      CheckTriggeredElementChangeByPlayer(xx, yy, border_element,
+					  CE_OTHER_GETS_TOUCHED,
+					  player->index_bit, border_side);
+      CheckElementChangeByPlayer(xx, yy, border_element, CE_TOUCHED_BY_PLAYER,
+				 player->index_bit, border_side);
+#endif
     }
     else if (IS_PLAYER(xx, yy))
     {
@@ -9206,11 +9640,20 @@ void TestIfPlayerTouchesCustomElement(int x, int y)
 	  continue;		/* center and border element do not touch */
       }
 
-      CheckTriggeredElementChangePlayer(x, y, center_element,
-					CE_OTHER_GETS_TOUCHED,
-					player->index_bit, center_side);
-      CheckElementChangePlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
-			       player->index_bit, center_side);
+#if 1
+      /* !!! TEST ONLY !!! */
+      CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
+				 player->index_bit, center_side);
+      CheckTriggeredElementChangeByPlayer(x, y, center_element,
+					  CE_OTHER_GETS_TOUCHED,
+					  player->index_bit, center_side);
+#else
+      CheckTriggeredElementChangeByPlayer(x, y, center_element,
+					  CE_OTHER_GETS_TOUCHED,
+					  player->index_bit, center_side);
+      CheckElementChangeByPlayer(x, y, center_element, CE_TOUCHED_BY_PLAYER,
+				 player->index_bit, center_side);
+#endif
 
       break;
     }
@@ -9319,8 +9762,8 @@ void TestIfElementTouchesCustomElement(int x, int y)
 	  printf("::: border_element %d, %d\n", x, y);
 #endif
 
-	  CheckElementChangePage(xx, yy, border_element, center_element,
-				 CE_OTHER_IS_TOUCHING, j);
+	  CheckElementChangeByPage(xx, yy, border_element, center_element,
+				   CE_OTHER_IS_TOUCHING, j);
 	  break;
 	}
       }
@@ -9333,8 +9776,8 @@ void TestIfElementTouchesCustomElement(int x, int y)
     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);
+    CheckElementChangeByPage(x, y, center_element, border_trigger_element,
+			     CE_OTHER_IS_TOUCHING, center_element_change_page);
   }
 }
 
@@ -9364,8 +9807,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
   touched_element = (IN_LEV_FIELD(hitx, hity) ?
 		     MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
 
-  CheckElementChangeSide(x, y, hitting_element, touched_element,
-			 CE_HITTING_SOMETHING, direction);
+  CheckElementChangeBySide(x, y, hitting_element, touched_element,
+			   CE_HITTING_SOMETHING, direction);
 
   if (IN_LEV_FIELD(hitx, hity))
   {
@@ -9387,8 +9830,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
     {
       int i;
 
-      CheckElementChangeSide(hitx, hity, touched_element, hitting_element,
-			     CE_HIT_BY_SOMETHING, opposite_direction);
+      CheckElementChangeBySide(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))
@@ -9409,8 +9852,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
 #endif
 	      )
 	  {
-	    CheckElementChangePage(x, y, hitting_element, touched_element,
-				   CE_OTHER_IS_HITTING, i);
+	    CheckElementChangeByPage(x, y, hitting_element, touched_element,
+				     CE_OTHER_IS_HITTING, i);
 	    break;
 	  }
 	}
@@ -9434,8 +9877,8 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
 #endif
 	      )
 	  {
-	    CheckElementChangePage(hitx, hity, touched_element,
-				   hitting_element, CE_OTHER_GETS_HIT, i);
+	    CheckElementChangeByPage(hitx, hity, touched_element,
+				     hitting_element, CE_OTHER_GETS_HIT, i);
 	    break;
 	  }
 	}
@@ -9471,8 +9914,8 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction)
   touched_element = (IN_LEV_FIELD(hitx, hity) ?
 		     MovingOrBlocked2Element(hitx, hity) : EL_STEELWALL);
 
-  CheckElementChangeSide(x, y, hitting_element, touched_element,
-			 EP_CAN_SMASH_EVERYTHING, direction);
+  CheckElementChangeBySide(x, y, hitting_element, touched_element,
+			   EP_CAN_SMASH_EVERYTHING, direction);
 
   if (IN_LEV_FIELD(hitx, hity))
   {
@@ -9494,8 +9937,8 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction)
     {
       int i;
 
-      CheckElementChangeSide(hitx, hity, touched_element, hitting_element,
-			     CE_SMASHED_BY_SOMETHING, opposite_direction);
+      CheckElementChangeBySide(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))
@@ -9516,8 +9959,8 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction)
 #endif
 	      )
 	  {
-	    CheckElementChangePage(x, y, hitting_element, touched_element,
-				   CE_OTHER_IS_SMASHING, i);
+	    CheckElementChangeByPage(x, y, hitting_element, touched_element,
+				     CE_OTHER_IS_SMASHING, i);
 	    break;
 	  }
 	}
@@ -9541,8 +9984,8 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction)
 #endif
 	      )
 	  {
-	    CheckElementChangePage(hitx, hity, touched_element,
-				   hitting_element, CE_OTHER_GETS_SMASHED, i);
+	    CheckElementChangeByPage(hitx, hity, touched_element,
+				     hitting_element, CE_OTHER_GETS_SMASHED,i);
 	    break;
 	  }
 	}
@@ -9555,6 +9998,7 @@ void TestIfElementSmashesCustomElement(int x, int y, int direction)
 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
 {
   int i, kill_x = -1, kill_y = -1;
+  int bad_element = -1;
   static int test_xy[4][2] =
   {
     { 0, -1 },
@@ -9576,6 +10020,7 @@ void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
 
     test_x = good_x + test_xy[i][0];
     test_y = good_y + test_xy[i][1];
+
     if (!IN_LEV_FIELD(test_x, test_y))
       continue;
 
@@ -9596,6 +10041,8 @@ void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
     {
       kill_x = test_x;
       kill_y = test_y;
+      bad_element = test_element;
+
       break;
     }
   }
@@ -9606,10 +10053,18 @@ void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
     {
       struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
 
+#if 1
+      if (player->shield_deadly_time_left > 0 &&
+	  !IS_INDESTRUCTIBLE(bad_element))
+	Bang(kill_x, kill_y);
+      else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
+	KillHero(player);
+#else
       if (player->shield_deadly_time_left > 0)
 	Bang(kill_x, kill_y);
       else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
 	KillHero(player);
+#endif
     }
     else
       Bang(good_x, good_y);
@@ -9698,10 +10153,18 @@ void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
     {
       struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
 
+#if 1
+      if (player->shield_deadly_time_left > 0 &&
+	  !IS_INDESTRUCTIBLE(bad_element))
+	Bang(bad_x, bad_y);
+      else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
+	KillHero(player);
+#else
       if (player->shield_deadly_time_left > 0)
 	Bang(bad_x, bad_y);
       else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
 	KillHero(player);
+#endif
     }
     else
       Bang(kill_x, kill_y);
@@ -9970,8 +10433,10 @@ int DigField(struct PlayerInfo *player,
 
 #endif
 
-  if (IS_WALKABLE(old_element) &&
-      !(element_info[old_element].access_direction & move_direction))
+  if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
+    return MF_NO_ACTION;	/* field has no opening in this direction */
+
+  if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
     return MF_NO_ACTION;	/* field has no opening in this direction */
 
   element = Feld[x][y];
@@ -9982,6 +10447,7 @@ int DigField(struct PlayerInfo *player,
 
   switch (element)
   {
+#if 0
     case EL_SP_PORT_LEFT:
     case EL_SP_PORT_RIGHT:
     case EL_SP_PORT_UP:
@@ -10049,6 +10515,7 @@ int DigField(struct PlayerInfo *player,
 
       PlayLevelSound(x, y, SND_CLASS_SP_PORT_PASSING);
       break;
+#endif
 
 #if 0
     case EL_TUBE_ANY:
@@ -10097,19 +10564,32 @@ int DigField(struct PlayerInfo *player,
 
     default:
 
+#if 1
+      if (IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
+#else
       if (IS_WALKABLE(element))
+#endif
       {
 	int sound_action = ACTION_WALKING;
 
-	if (!(element_info[element].access_direction & opposite_direction))
+#if 0
+	if (!ACCESS_FROM(element, opposite_direction))
 	  return MF_NO_ACTION;	/* field not accessible from this direction */
+#endif
 
-	if (element >= EL_GATE_1 && element <= EL_GATE_4)
+#if 1
+	if (element == EL_EMPTY_SPACE &&
+	    game.gravity && !player->is_auto_moving &&
+	    canFallDown(player) && move_direction != MV_DOWN)
+	  return MF_NO_ACTION;	/* player cannot walk here due to gravity */
+#endif
+
+	if (IS_GATE(element))
 	{
 	  if (!player->key[element - EL_GATE_1])
 	    return MF_NO_ACTION;
 	}
-	else if (element >= EL_GATE_1_GRAY && element <= EL_GATE_4_GRAY)
+	else if (IS_GATE_GRAY(element))
 	{
 	  if (!player->key[element - EL_GATE_1_GRAY])
 	    return MF_NO_ACTION;
@@ -10133,30 +10613,63 @@ int DigField(struct PlayerInfo *player,
 
 	break;
       }
+#if 1
+      else if (IS_PASSABLE(element) && canPassField(x, y, move_direction))
+#else
       else if (IS_PASSABLE(element))
+#endif
       {
+#if 0
+	if (!canPassField(x, y, move_direction))
+	  return MF_NO_ACTION;
+#else
+
+#if 0
+#if 1
+	if (!IN_LEV_FIELD(nextx, nexty) || IS_PLAYER(nextx, nexty) ||
+	    !IS_WALKABLE_FROM(Feld[nextx][nexty], move_direction) ||
+	    (!level.can_pass_to_walkable && !IS_FREE(nextx, nexty)))
+	  return MF_NO_ACTION;
+#else
 	if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
 	  return MF_NO_ACTION;
+#endif
+#endif
 
+#if 1
+	if (!ACCESS_FROM(element, opposite_direction))
+	  return MF_NO_ACTION;	/* field not accessible from this direction */
+#else
 	if (IS_CUSTOM_ELEMENT(element) &&
-	    !(element_info[element].access_direction & opposite_direction))
+	    !ACCESS_FROM(element, opposite_direction))
 	  return MF_NO_ACTION;	/* field not accessible from this direction */
+#endif
 
 #if 1
 	if (CAN_MOVE(element))	/* only fixed elements can be passed! */
 	  return MF_NO_ACTION;
 #endif
 
-	if (element >= EL_EM_GATE_1 && element <= EL_EM_GATE_4)
+#endif
+
+	if (IS_EM_GATE(element))
 	{
 	  if (!player->key[element - EL_EM_GATE_1])
 	    return MF_NO_ACTION;
 	}
-	else if (element >= EL_EM_GATE_1_GRAY && element <= EL_EM_GATE_4_GRAY)
+	else if (IS_EM_GATE_GRAY(element))
 	{
 	  if (!player->key[element - EL_EM_GATE_1_GRAY])
 	    return MF_NO_ACTION;
 	}
+	else if (IS_SP_PORT(element))
+	{
+	  if (element == EL_SP_GRAVITY_PORT_LEFT ||
+	      element == EL_SP_GRAVITY_PORT_RIGHT ||
+	      element == EL_SP_GRAVITY_PORT_UP ||
+	      element == EL_SP_GRAVITY_PORT_DOWN)
+	    game.gravity = !game.gravity;
+	}
 
 	/* automatically move to the next field with double speed */
 	player->programmed_action = move_direction;
@@ -10194,8 +10707,8 @@ 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);
+	CheckTriggeredElementChangeByPlayer(x, y, element,CE_OTHER_GETS_DIGGED,
+					    player->index_bit, dig_side);
 
 #if 1
 	if (mode == DF_SNAP)
@@ -10267,7 +10780,8 @@ int DigField(struct PlayerInfo *player,
 	  ShowEnvelope(element - EL_ENVELOPE_1);
 #endif
 	}
-	else if (IS_DROPPABLE(element))	/* can be collected and dropped */
+	else if (IS_DROPPABLE(element) ||
+		 IS_THROWABLE(element))	/* can be collected and dropped */
 	{
 	  int i;
 
@@ -10293,9 +10807,9 @@ int DigField(struct PlayerInfo *player,
 	RaiseScoreElement(element);
 	PlayLevelSoundElementAction(x, y, element, ACTION_COLLECTING);
 
-	CheckTriggeredElementChangePlayer(x, y, element,
-					  CE_OTHER_GETS_COLLECTED,
-					  player->index_bit, CH_SIDE_ANY);
+	CheckTriggeredElementChangeByPlayer(x, y, element,
+					    CE_OTHER_GETS_COLLECTED,
+					    player->index_bit, dig_side);
 
 #if 1
 	if (mode == DF_SNAP)
@@ -10451,10 +10965,23 @@ int DigField(struct PlayerInfo *player,
 	else
 	  player->push_delay_value = -1;	/* get new value later */
 
-	CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_PUSHED,
-					  player->index_bit, dig_side);
-	CheckElementChangePlayer(x, y, element, CE_PUSHED_BY_PLAYER,
-				 player->index_bit, dig_side);
+#if 1
+	/* check for element change _after_ element has been pushed! */
+#else
+
+#if 1
+      /* !!! TEST ONLY !!! */
+	CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
+				   player->index_bit, dig_side);
+	CheckTriggeredElementChangeByPlayer(x, y, element,CE_OTHER_GETS_PUSHED,
+					    player->index_bit, dig_side);
+#else
+	CheckTriggeredElementChangeByPlayer(x, y, element,CE_OTHER_GETS_PUSHED,
+					    player->index_bit, dig_side);
+	CheckElementChangeByPlayer(x, y, element, CE_PUSHED_BY_PLAYER,
+				   player->index_bit, dig_side);
+#endif
+#endif
 
 	break;
       }
@@ -10558,17 +11085,34 @@ int DigField(struct PlayerInfo *player,
 	  player->switch_x = x;
 	  player->switch_y = y;
 
-	  CheckTriggeredElementChangePlayer(x, y, element,
-					    CE_OTHER_IS_SWITCHING,
-					    player->index_bit, dig_side);
-	  CheckElementChangePlayer(x, y, element, CE_SWITCHED,
-				   player->index_bit, dig_side);
+#if 1
+	  /* !!! TEST ONLY !!! */
+	  CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
+				     player->index_bit, dig_side);
+	  CheckTriggeredElementChangeByPlayer(x, y, element,
+					      CE_OTHER_IS_SWITCHING,
+					      player->index_bit, dig_side);
+#else
+	  CheckTriggeredElementChangeByPlayer(x, y, element,
+					      CE_OTHER_IS_SWITCHING,
+					      player->index_bit, dig_side);
+	  CheckElementChangeByPlayer(x, y, element, CE_SWITCHED,
+				     player->index_bit, dig_side);
+#endif
 	}
 
-	CheckTriggeredElementChangePlayer(x, y, element, CE_OTHER_GETS_PRESSED,
-					  player->index_bit, dig_side);
-	CheckElementChangePlayer(x, y, element, CE_PRESSED_BY_PLAYER,
-				 player->index_bit, dig_side);
+#if 1
+	/* !!! TEST ONLY !!! (this breaks "machine", level 000) */
+	CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
+				   player->index_bit, dig_side);
+	CheckTriggeredElementChangeByPlayer(x,y, element,CE_OTHER_GETS_PRESSED,
+					    player->index_bit, dig_side);
+#else
+	CheckTriggeredElementChangeByPlayer(x,y, element,CE_OTHER_GETS_PRESSED,
+					    player->index_bit, dig_side);
+	CheckElementChangeByPlayer(x, y, element, CE_PRESSED_BY_PLAYER,
+				   player->index_bit, dig_side);
+#endif
       }
 
       return MF_NO_ACTION;
@@ -10660,15 +11204,36 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy)
 
 boolean DropElement(struct PlayerInfo *player)
 {
-  int jx = player->jx, jy = player->jy;
-  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);
+  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 old_element, new_element;
+  int dropx = player->jx, dropy = player->jy;
+  int drop_direction = player->MovDir;
+  int drop_side = trigger_sides[MV_DIR_BIT(drop_direction)];
+  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);
+
+  if (IS_THROWABLE(drop_element))
+  {
+    dropx += GET_DX_FROM_DIR(drop_direction);
+    dropy += GET_DY_FROM_DIR(drop_direction);
+
+    if (!IN_LEV_FIELD(dropx, dropy))
+      return FALSE;
+  }
+
+  old_element = Feld[dropx][dropy];	/* old element at dropping position */
+  new_element = drop_element;		/* default: no change when dropping */
 
   /* check if player is active, not moving and ready to drop */
   if (!player->active || player->MovPos || player->drop_delay > 0)
@@ -10701,10 +11266,10 @@ boolean DropElement(struct PlayerInfo *player)
 #endif
 
   if (old_element != EL_EMPTY)
-    Back[jx][jy] = old_element;		/* store old element on this field */
+    Back[dropx][dropy] = old_element;	/* store old element on this field */
 
-  ResetGfxAnimation(jx, jy);
-  ResetRandomAnimationValue(jx, jy);
+  ResetGfxAnimation(dropx, dropy);
+  ResetRandomAnimationValue(dropx, dropy);
 
   if (player->inventory_size > 0 ||
       player->inventory_infinite_element != EL_UNDEFINED)
@@ -10725,25 +11290,35 @@ boolean DropElement(struct PlayerInfo *player)
 	new_element = EL_SP_DISK_RED_ACTIVE;
     }
 
-    Feld[jx][jy] = new_element;
+    Feld[dropx][dropy] = new_element;
 
-    if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
-      DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
+    if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
+      DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
+			  el2img(Feld[dropx][dropy]), 0);
 
-    PlayLevelSoundAction(jx, jy, ACTION_DROPPING);
+    PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
 
 #if 1
     /* needed if previous element just changed to "empty" in the last frame */
-    Changed[jx][jy] = 0;		/* allow another change */
+    Changed[dropx][dropy] = 0;		/* allow another change */
 #endif
 
-    CheckTriggeredElementChangePlayer(jx, jy, new_element,
-				      CE_OTHER_GETS_DROPPED,
-				      player->index_bit, CH_SIDE_ANY);
-    CheckElementChangePlayer(jx, jy, new_element, CE_DROPPED_BY_PLAYER,
-			     player->index_bit, CH_SIDE_ANY);
+#if 1
+    /* !!! TEST ONLY !!! */
+    CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
+			       player->index_bit, drop_side);
+    CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
+					CE_OTHER_GETS_DROPPED,
+					player->index_bit, drop_side);
+#else
+    CheckTriggeredElementChangeByPlayer(dropx, dropy, new_element,
+					CE_OTHER_GETS_DROPPED,
+					player->index_bit, drop_side);
+    CheckElementChangeByPlayer(dropx, dropy, new_element, CE_DROPPED_BY_PLAYER,
+			       player->index_bit, drop_side);
+#endif
 
-    TestIfElementTouchesCustomElement(jx, jy);
+    TestIfElementTouchesCustomElement(dropx, dropy);
   }
   else		/* player is dropping a dyna bomb */
   {
@@ -10753,74 +11328,92 @@ boolean DropElement(struct PlayerInfo *player)
     new_element = EL_DYNABOMB_PLAYER_1_ACTIVE + player->index_nr;
 #endif
 
-    Feld[jx][jy] = new_element;
+    Feld[dropx][dropy] = new_element;
 
-    if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
-      DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), el2img(Feld[jx][jy]), 0);
+    if (IN_SCR_FIELD(SCREENX(dropx), SCREENY(dropy)))
+      DrawGraphicThruMask(SCREENX(dropx), SCREENY(dropy),
+			  el2img(Feld[dropx][dropy]), 0);
 
-    PlayLevelSoundAction(jx, jy, ACTION_DROPPING);
+    PlayLevelSoundAction(dropx, dropy, ACTION_DROPPING);
   }
 
 
 
 #if 1
 
-  if (Feld[jx][jy] == new_element)	/* uninitialized unless CE change */
+  if (Feld[dropx][dropy] == new_element) /* uninitialized unless CE change */
   {
 #if 1
-    InitField_WithBug1(jx, jy, FALSE);
+    InitField_WithBug1(dropx, dropy, FALSE);
 #else
-    InitField(jx, jy, FALSE);
-    if (CAN_MOVE(Feld[jx][jy]))
-      InitMovDir(jx, jy);
+    InitField(dropx, dropy, FALSE);
+    if (CAN_MOVE(Feld[dropx][dropy]))
+      InitMovDir(dropx, dropy);
 #endif
   }
 
-  new_element = Feld[jx][jy];
+  new_element = Feld[dropx][dropy];	/* 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;
-    int direction, dx, dy, nextx, nexty;
+#endif
+    int move_direction, nextx, nexty;
 
     if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
-      MovDir[jx][jy] = player->MovDir;
+      MovDir[dropx][dropy] = drop_direction;
 
-    direction = MovDir[jx][jy];
-    dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
-    dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
-    nextx = jx + dx;
-    nexty = jy + dy;
+    move_direction = MovDir[dropx][dropy];
+    nextx = dropx + GET_DX_FROM_DIR(move_direction);
+    nexty = dropy + GET_DY_FROM_DIR(move_direction);
+
+#if 1
+      Changed[dropx][dropy] = 0;	/* allow another change */
+      CheckCollision[dropx][dropy] = 2;
+#else
 
     if (IN_LEV_FIELD(nextx, nexty) && IS_FREE(nextx, nexty))
     {
 #if 0
-      WasJustMoving[jx][jy] = 3;
+      WasJustMoving[dropx][dropy] = 3;
 #else
-      InitMovingField(jx, jy, direction);
-      ContinueMoving(jx, jy);
+#if 1
+      InitMovingField(dropx, dropy, move_direction);
+      ContinueMoving(dropx, dropy);
+#endif
 #endif
     }
+#if 1
     else
     {
-      Changed[jx][jy] = 0;		/* allow another change */
+      Changed[dropx][dropy] = 0;	/* allow another change */
 
 #if 1
-      TestIfElementHitsCustomElement(jx, jy, direction);
+      TestIfElementHitsCustomElement(dropx, dropy, move_direction);
 #else
-      CheckElementChangeSide(jx, jy, new_element, touched_element,
-			     CE_HITTING_SOMETHING, direction);
+      CheckElementChangeBySide(dropx, dropy, new_element, touched_element,
+			       CE_HITTING_SOMETHING, move_direction);
 #endif
     }
+#endif
+
+#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;
@@ -11046,21 +11639,15 @@ void RequestQuitGame(boolean ask_if_really_quit)
   {
 
 #if 1
-    if (tape.playing && tape.index_search)
-    {
-      SetDrawDeactivationMask(REDRAW_NONE);
-      audio.sound_deactivated = FALSE;
-    }
+    if (tape.playing && tape.deactivate_display)
+      TapeDeactivateDisplayOff(TRUE);
 #endif
 
     OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
 
 #if 1
-    if (tape.playing && tape.index_search)
-    {
-      SetDrawDeactivationMask(REDRAW_FIELD);
-      audio.sound_deactivated = TRUE;
-    }
+    if (tape.playing && tape.deactivate_display)
+      TapeDeactivateDisplayOn();
 #endif
 
   }