X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;ds=inline;f=src%2Fgame.c;h=d304e76ee8b873daeb975bf330464948858afbba;hb=647942379469ffe30e70264514b1cefa659dc870;hp=ecf2ca0ffaf8088a75e31e0e76a671895c0fee69;hpb=15064a21ef26f67d41de4930badd03838978c9d7;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index ecf2ca0f..d304e76e 100644
--- a/src/game.c
+++ b/src/game.c
@@ -107,7 +107,7 @@
 					(condition) ||			\
 					(DONT_COLLIDE_WITH(e) &&	\
 					 IS_PLAYER(x, y) &&		\
-					 !PLAYER_PROTECTED(x, y))))
+					 !PLAYER_ENEMY_PROTECTED(x, y))))
 #else
 #define ELEMENT_CAN_ENTER_FIELD_GENERIC(e, x, y, condition)		\
 		(IN_LEV_FIELD(x, y) && (IS_FREE(x, y) ||		\
@@ -164,16 +164,27 @@
 #endif
 #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, g)	(element_info[e].in_group[g] == TRUE)
+#define IS_IN_GROUP(e, nr)	(element_info[e].in_group[nr] == TRUE)
 #define IS_IN_GROUP_EL(e, ge)	(IS_IN_GROUP(e, (ge) - EL_GROUP_START))
 
+#define IS_EQUAL_OR_IN_GROUP(e, ge)					\
+	(IS_GROUP_ELEMENT(ge) ? IS_IN_GROUP(e, GROUP_NR(ge)) : (e) == (ge))
+
+#if 1
+#define CE_ENTER_FIELD_COND(e, x, y)					\
+		(!IS_PLAYER(x, y) &&					\
+		 (Feld[x][y] == EL_ACID ||				\
+		  IS_EQUAL_OR_IN_GROUP(Feld[x][y], MOVE_ENTER_EL(e))))
+#else
 #define CE_ENTER_FIELD_COND(e, x, y)					\
 		(!IS_PLAYER(x, y) &&					\
 		 (Feld[x][y] == EL_ACID ||				\
 		  Feld[x][y] == MOVE_ENTER_EL(e) ||			\
 		  (IS_GROUP_ELEMENT(MOVE_ENTER_EL(e)) &&		\
 		   IS_IN_GROUP_EL(Feld[x][y], MOVE_ENTER_EL(e)))))
+#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))
@@ -205,7 +216,8 @@ static void ScrollScreen(struct PlayerInfo *, int);
 static void InitBeltMovement(void);
 static void CloseAllOpenTimegates(void);
 static void CheckGravityMovement(struct PlayerInfo *);
-static void KillHeroUnlessProtected(int, int);
+static void KillHeroUnlessEnemyProtected(int, int);
+static void KillHeroUnlessExplosionProtected(int, int);
 
 static void TestIfPlayerTouchesCustomElement(int, int);
 static void TestIfElementTouchesCustomElement(int, int);
@@ -595,6 +607,10 @@ static void InitPlayerField(int x, int y, int element, boolean init_game)
 
     player->present = TRUE;
 
+    player->block_last_field = (element == EL_SP_MURPHY ?
+				level.sp_block_last_field :
+				level.block_last_field);
+
     if (!options.network || player->connected)
     {
       player->active = TRUE;
@@ -799,9 +815,22 @@ static void InitField(int x, int y, boolean init_game)
       else if (IS_GROUP_ELEMENT(element))
       {
 	struct ElementGroupInfo *group = element_info[element].group;
-	int random_pos = RND(group->num_elements_resolved);
+	int last_anim_random_frame = gfx.anim_random_frame;
+	int element_pos;
+
+	if (group->choice_mode == ANIM_RANDOM)
+	  gfx.anim_random_frame = RND(group->num_elements_resolved);
+
+	element_pos = getAnimationFrame(group->num_elements_resolved, 1,
+					group->choice_mode, 0,
+					group->choice_pos);
 
-	Feld[x][y] = group->element_resolved[random_pos];
+	if (group->choice_mode == ANIM_RANDOM)
+	  gfx.anim_random_frame = last_anim_random_frame;
+
+	group->choice_pos++;
+
+	Feld[x][y] = group->element_resolved[element_pos];
 
 	InitField(x, y, init_game);
       }
@@ -842,7 +871,7 @@ static void resolve_group_element(int group_element, int recursion_depth)
 	  group_element - EL_GROUP_START + 1);
 
     /* replace element which caused too deep recursion by question mark */
-    group->element_resolved[group->num_elements_resolved++] = EL_CHAR_QUESTION;
+    group->element_resolved[group->num_elements_resolved++] = EL_UNKNOWN;
 
     return;
   }
@@ -850,8 +879,10 @@ static void resolve_group_element(int group_element, int recursion_depth)
   if (recursion_depth == 0)			/* initialization */
   {
     group = element_info[group_element].group;
-    group->num_elements_resolved = 0;
     group_nr = group_element - EL_GROUP_START;
+
+    group->num_elements_resolved = 0;
+    group->choice_pos = 0;
   }
 
   for (i = 0; i < actual_group->num_elements; i++)
@@ -1037,7 +1068,16 @@ static void InitGameEngine()
       {
 	int trigger_element = ei->change_page[j].trigger_element;
 
-	trigger_events[trigger_element] |= ei->change_page[j].events;
+	if (IS_GROUP_ELEMENT(trigger_element))
+	{
+	  struct ElementGroupInfo *group = element_info[trigger_element].group;
+
+	  for (k = 0; k < group->num_elements_resolved; k++)
+	    trigger_events[group->element_resolved[k]]
+	      |= ei->change_page[j].events;
+	}
+	else
+	  trigger_events[trigger_element] |= ei->change_page[j].events;
       }
     }
   }
@@ -1070,6 +1110,19 @@ static void InitGameEngine()
     element_info[e].push_delay_random = push_delay_list[i].push_delay_random;
   }
 
+  /* set push delay value for Supaplex elements for newer engine versions */
+  if (game.engine_version >= VERSION_IDENT(3,0,9,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;
+      }
+    }
+  }
+
   /* ---------- initialize move stepsize ----------------------------------- */
 
   /* initialize move stepsize values to default */
@@ -1085,6 +1138,14 @@ static void InitGameEngine()
     element_info[e].move_stepsize = move_stepsize_list[i].move_stepsize;
   }
 
+  /* ---------- initialize move dig/leave ---------------------------------- */
+
+  for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+  {
+    element_info[i].can_leave_element = FALSE;
+    element_info[i].can_leave_element_last = FALSE;
+  }
+
   /* ---------- initialize gem count --------------------------------------- */
 
   /* initialize gem count values for each element */
@@ -1167,6 +1228,8 @@ void InitGame()
 
     player->use_murphy_graphic = FALSE;
 
+    player->block_last_field = FALSE;
+
     player->actual_frame_counter = 0;
 
     player->step_counter = 0;
@@ -1322,6 +1385,7 @@ void InitGame()
       ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
 
       ExplodePhase[x][y] = 0;
+      ExplodeDelay[x][y] = 0;
       ExplodeField[x][y] = EX_NO_EXPLOSION;
 
       RunnerVisit[x][y] = 0;
@@ -1356,6 +1420,30 @@ void InitGame()
 		    emulate_sb ? EMU_SOKOBAN :
 		    emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
 
+  /* initialize explosion and ignition delay */
+  for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+  {
+    if (!IS_CUSTOM_ELEMENT(i))
+    {
+      int num_phase = 9;
+      int delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
+      int last_phase = num_phase * delay;
+      int half_phase = (num_phase / 2) * delay;
+
+      element_info[i].explosion_delay = last_phase;
+      element_info[i].ignition_delay = half_phase;
+
+      if (i == EL_BLACK_ORB)
+	element_info[i].ignition_delay = 1;
+    }
+
+    if (element_info[i].explosion_delay < 2)	/* !!! check again !!! */
+      element_info[i].explosion_delay = 2;
+
+    if (element_info[i].ignition_delay < 1)	/* !!! check again !!! */
+      element_info[i].ignition_delay = 1;
+  }
+
   /* correct non-moving belts to start moving left */
   for (i = 0; i < 4; i++)
     if (game.belt_dir[i] == MV_NO_MOVING)
@@ -1378,7 +1466,9 @@ void InitGame()
 	{
 	  player->present = TRUE;
 	  player->active = TRUE;
+
 	  some_player->present = FALSE;
+	  some_player->active = FALSE;
 
 	  StorePlayer[jx][jy] = player->element_nr;
 	  player->jx = player->last_jx = jx;
@@ -1392,7 +1482,7 @@ void InitGame()
 
   if (tape.playing)
   {
-    /* when playing a tape, eliminate all players who do not participate */
+    /* when playing a tape, eliminate all players which do not participate */
 
     for (i = 0; i < MAX_PLAYERS; i++)
     {
@@ -1423,6 +1513,8 @@ void InitGame()
 	    int jx = player->jx, jy = player->jy;
 
 	    player->active = FALSE;
+	    player->present = FALSE;
+
 	    StorePlayer[jx][jy] = 0;
 	    Feld[jx][jy] = EL_EMPTY;
 	  }
@@ -1723,23 +1815,37 @@ void InitMovDir(int x, int y)
     default:
       if (IS_CUSTOM_ELEMENT(element))
       {
-	if (element_info[element].move_direction_initial != MV_NO_MOVING)
-	  MovDir[x][y] = element_info[element].move_direction_initial;
-	else if (element_info[element].move_pattern == MV_ALL_DIRECTIONS ||
-		 element_info[element].move_pattern == MV_TURNING_LEFT ||
-		 element_info[element].move_pattern == MV_TURNING_RIGHT ||
-		 element_info[element].move_pattern == MV_TURNING_LEFT_RIGHT ||
-		 element_info[element].move_pattern == MV_TURNING_RIGHT_LEFT ||
-		 element_info[element].move_pattern == MV_TURNING_RANDOM)
+	struct ElementInfo *ei = &element_info[element];
+	int move_direction_initial = ei->move_direction_initial;
+	int move_pattern = ei->move_pattern;
+
+	if (move_direction_initial == MV_START_PREVIOUS)
+	{
+	  if (MovDir[x][y] != MV_NO_MOVING)
+	    return;
+
+	  move_direction_initial = MV_START_AUTOMATIC;
+	}
+
+	if (move_direction_initial == MV_START_RANDOM)
+	  MovDir[x][y] = 1 << RND(4);
+	else if (move_direction_initial & MV_ANY_DIRECTION)
+	  MovDir[x][y] = move_direction_initial;
+	else if (move_pattern == MV_ALL_DIRECTIONS ||
+		 move_pattern == MV_TURNING_LEFT ||
+		 move_pattern == MV_TURNING_RIGHT ||
+		 move_pattern == MV_TURNING_LEFT_RIGHT ||
+		 move_pattern == MV_TURNING_RIGHT_LEFT ||
+		 move_pattern == MV_TURNING_RANDOM)
 	  MovDir[x][y] = 1 << RND(4);
-	else if (element_info[element].move_pattern == MV_HORIZONTAL)
+	else if (move_pattern == MV_HORIZONTAL)
 	  MovDir[x][y] = (RND(2) ? MV_LEFT : MV_RIGHT);
-	else if (element_info[element].move_pattern == MV_VERTICAL)
+	else if (move_pattern == MV_VERTICAL)
 	  MovDir[x][y] = (RND(2) ? MV_UP : MV_DOWN);
-	else if (element_info[element].move_pattern & MV_ANY_DIRECTION)
+	else if (move_pattern & MV_ANY_DIRECTION)
 	  MovDir[x][y] = element_info[element].move_pattern;
-	else if (element_info[element].move_pattern == MV_ALONG_LEFT_SIDE ||
-		 element_info[element].move_pattern == MV_ALONG_RIGHT_SIDE)
+	else if (move_pattern == MV_ALONG_LEFT_SIDE ||
+		 move_pattern == MV_ALONG_RIGHT_SIDE)
 	{
 	  for (i = 0; i < 4; i++)
 	  {
@@ -1748,7 +1854,7 @@ void InitMovDir(int x, int y)
 
 	    if (!IN_LEV_FIELD(x1, y1) || !IS_FREE(x1, y1))
 	    {
-	      if (element_info[element].move_pattern == MV_ALONG_RIGHT_SIDE)
+	      if (move_pattern == MV_ALONG_RIGHT_SIDE)
 		MovDir[x][y] = direction[0][i];
 	      else
 		MovDir[x][y] = direction[1][i];
@@ -2258,6 +2364,10 @@ void CheckDynamite(int x, int y)
 void RelocatePlayer(int x, int y, int element)
 {
   struct PlayerInfo *player = &stored_player[element - EL_PLAYER_1];
+  boolean ffwd_delay = (tape.playing && tape.fast_forward);
+  boolean no_delay = (tape.index_search);
+  int frame_delay_value = (ffwd_delay ? FfwdFrameDelay : GameFrameDelay);
+  int wait_delay_value = (no_delay ? 0 : frame_delay_value);
 
   if (player->GameOver)		/* do not reanimate dead player */
     return;
@@ -2278,7 +2388,7 @@ void RelocatePlayer(int x, int y, int element)
       DrawPlayer(player);
 
       BackToFront();
-      Delay(GAME_FRAME_DELAY);
+      Delay(wait_delay_value);
     }
 
     DrawPlayer(player);		/* needed here only to cleanup last field */
@@ -2322,11 +2432,11 @@ void RelocatePlayer(int x, int y, int element)
       /* scroll in two steps of half tile size to make things smoother */
       BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
       FlushDisplay();
-      Delay(GAME_FRAME_DELAY);
+      Delay(wait_delay_value);
 
       /* scroll second step to align at full tile size */
       BackToFront();
-      Delay(GAME_FRAME_DELAY);
+      Delay(wait_delay_value);
     }
   }
 }
@@ -2339,6 +2449,9 @@ void Explode(int ex, int ey, int phase, int mode)
   int last_phase = num_phase * delay;
   int half_phase = (num_phase / 2) * delay;
   int first_phase_after_start = EX_PHASE_START + 1;
+  int border_element;
+
+  int last_phase_TEST = last_phase;
 
   if (game.explosions_delayed)
   {
@@ -2373,6 +2486,10 @@ void Explode(int ex, int ey, int phase, int mode)
       Feld[ex][ey] = center_element;
     }
 
+#if 1
+    last_phase = element_info[center_element].explosion_delay;
+#endif
+
     for (y = ey - 1; y <= ey + 1; y++) for (x = ex - 1; x <= ex + 1; x++)
     {
       int xx = x - ex + 1;
@@ -2452,22 +2569,22 @@ void Explode(int ex, int ey, int phase, int mode)
       RemoveField(x, y);
 #endif
 
-      if (IS_PLAYER(ex, ey) && !PLAYER_PROTECTED(ex, ey))
+      if (IS_PLAYER(ex, ey) && !PLAYER_EXPLOSION_PROTECTED(ex, ey))
       {
 	switch(StorePlayer[ex][ey])
 	{
 	  case EL_PLAYER_2:
-	    Store[x][y] = EL_EMERALD_RED;
+	    Store[x][y] = EL_PLAYER_IS_EXPLODING_2;
 	    break;
 	  case EL_PLAYER_3:
-	    Store[x][y] = EL_EMERALD;
+	    Store[x][y] = EL_PLAYER_IS_EXPLODING_3;
 	    break;
 	  case EL_PLAYER_4:
-	    Store[x][y] = EL_EMERALD_PURPLE;
+	    Store[x][y] = EL_PLAYER_IS_EXPLODING_4;
 	    break;
 	  case EL_PLAYER_1:
 	  default:
-	    Store[x][y] = EL_EMERALD_YELLOW;
+	    Store[x][y] = EL_PLAYER_IS_EXPLODING_1;
 	    break;
 	}
 
@@ -2543,6 +2660,9 @@ void Explode(int ex, int ey, int phase, int mode)
 #endif
 
       ExplodePhase[x][y] = 1;
+#if 1
+      ExplodeDelay[x][y] = last_phase;
+#endif
       Stop[x][y] = TRUE;
     }
 
@@ -2559,6 +2679,10 @@ void Explode(int ex, int ey, int phase, int mode)
   x = ex;
   y = ey;
 
+#if 1
+  last_phase = ExplodeDelay[x][y];
+#endif
+
   ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
 
 #ifdef DEBUG
@@ -2579,6 +2703,52 @@ void Explode(int ex, int ey, int phase, int mode)
   }
 #endif
 
+#if 1
+
+  border_element = Store2[x][y];
+  if (IS_PLAYER(x, y))
+    border_element = StorePlayer[x][y];
+
+  if (phase == element_info[border_element].ignition_delay ||
+      phase == last_phase)
+  {
+    boolean border_explosion = FALSE;
+
+    if (IS_PLAYER(x, y))
+    {
+      KillHeroUnlessExplosionProtected(x, y);
+      border_explosion = TRUE;
+
+      if (phase == last_phase)
+	printf("::: IS_PLAYER\n");
+    }
+    else if (CAN_EXPLODE_BY_FIRE(border_element))
+    {
+      Feld[x][y] = Store2[x][y];
+      Store2[x][y] = 0;
+      Bang(x, y);
+      border_explosion = TRUE;
+
+      if (phase == last_phase)
+	printf("::: CAN_EXPLODE_BY_FIRE\n");
+    }
+    else if (border_element == EL_AMOEBA_TO_DIAMOND)
+    {
+      AmoebeUmwandeln(x, y);
+      border_explosion = TRUE;
+
+      if (phase == last_phase)
+	printf("::: EL_AMOEBA_TO_DIAMOND\n");
+    }
+
+#if 0
+    if (border_explosion && phase == last_phase)
+      return;
+#endif
+  }
+
+#else
+
   if (phase == first_phase_after_start)
   {
     int element = Store2[x][y];
@@ -2595,7 +2765,7 @@ void Explode(int ex, int ey, int phase, int mode)
     int element = Store2[x][y];
 
     if (IS_PLAYER(x, y))
-      KillHeroUnlessProtected(x, y);
+      KillHeroUnlessExplosionProtected(x, y);
     else if (CAN_EXPLODE_BY_FIRE(element))
     {
       Feld[x][y] = Store2[x][y];
@@ -2605,6 +2775,7 @@ void Explode(int ex, int ey, int phase, int mode)
     else if (element == EL_AMOEBA_TO_DIAMOND)
       AmoebeUmwandeln(x, y);
   }
+#endif
 
   if (phase == last_phase)
   {
@@ -2614,6 +2785,17 @@ void Explode(int ex, int ey, int phase, int mode)
     Store[x][y] = Store2[x][y] = 0;
     GfxElement[x][y] = EL_UNDEFINED;
 
+    /* player can escape from explosions and might therefore be still alive */
+    if (element >= EL_PLAYER_IS_EXPLODING_1 &&
+	element <= EL_PLAYER_IS_EXPLODING_4)
+      Feld[x][y] = (stored_player[element - EL_PLAYER_IS_EXPLODING_1].active ?
+		    EL_EMPTY :
+		    element == EL_PLAYER_IS_EXPLODING_1 ? EL_EMERALD_YELLOW :
+		    element == EL_PLAYER_IS_EXPLODING_2 ? EL_EMERALD_RED :
+		    element == EL_PLAYER_IS_EXPLODING_3 ? EL_EMERALD :
+		    EL_EMERALD_PURPLE);
+
+    /* restore probably existing indestructible background element */
     if (Back[x][y] && IS_INDESTRUCTIBLE(Back[x][y]))
       element = Feld[x][y] = Back[x][y];
     Back[x][y] = 0;
@@ -2624,8 +2806,11 @@ void Explode(int ex, int ey, int phase, int mode)
     ChangePage[x][y] = -1;
 
     InitField(x, y, FALSE);
+#if 1
+    /* !!! not needed !!! */
     if (CAN_MOVE(element))
       InitMovDir(x, y);
+#endif
     DrawLevelField(x, y);
 
     TestIfElementTouchesCustomElement(x, y);
@@ -2639,7 +2824,11 @@ void Explode(int ex, int ey, int phase, int mode)
     if (ELEM_IS_PLAYER(element))
       RelocatePlayer(x, y, element);
   }
+#if 1
+  else if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+#else
   else if (phase >= delay && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+#endif
   {
 #if 1
     int graphic = el_act2img(GfxElement[x][y], ACTION_EXPLODING);
@@ -2738,7 +2927,7 @@ void Bang(int x, int y)
 #endif
 
 #if 1
-  if (IS_PLAYER(x, y) && !PLAYER_PROTECTED(x, y))
+  if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y))
 #else
   if (IS_PLAYER(x, y))
 #endif
@@ -3229,7 +3418,7 @@ void Impact(int x, int y)
   if (impact && element == EL_AMOEBA_DROP)
   {
     if (object_hit && IS_PLAYER(x, y + 1))
-      KillHeroUnlessProtected(x, y + 1);
+      KillHeroUnlessEnemyProtected(x, y + 1);
     else if (object_hit && smashed == EL_PENGUIN)
       Bang(x, y + 1);
     else
@@ -3271,7 +3460,7 @@ void Impact(int x, int y)
     {
       if (CAN_SMASH_PLAYER(element))
       {
-	KillHeroUnlessProtected(x, y + 1);
+	KillHeroUnlessEnemyProtected(x, y + 1);
 	return;
       }
     }
@@ -3291,11 +3480,13 @@ void Impact(int x, int y)
 	return;
       }
     }
-    else if ((element == EL_SP_INFOTRON ||
-	      element == EL_SP_ZONK) &&
-	     (smashed == EL_SP_SNIKSNAK ||
-	      smashed == EL_SP_ELECTRON ||
-	      smashed == EL_SP_DISK_ORANGE))
+    else if (((element == EL_SP_INFOTRON ||
+	       element == EL_SP_ZONK) &&
+	      (smashed == EL_SP_SNIKSNAK ||
+	       smashed == EL_SP_ELECTRON ||
+	       smashed == EL_SP_DISK_ORANGE)) ||
+	     (element == EL_SP_INFOTRON &&
+	      smashed == EL_SP_DISK_YELLOW))
     {
       Bang(x, y + 1);
       return;
@@ -4610,7 +4801,7 @@ void StartMoving(int x, int y)
 
     if (DONT_COLLIDE_WITH(element) &&
 	IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
-	!PLAYER_PROTECTED(newx, newy))
+	!PLAYER_ENEMY_PROTECTED(newx, newy))
     {
 #if 1
       TestIfBadThingRunsIntoHero(x, y, MovDir[x][y]);
@@ -4718,6 +4909,8 @@ void StartMoving(int x, int y)
 
 )
     {
+      int new_element = Feld[newx][newy];
+
 #if 0
       printf("::: '%s' digs '%s' [%d]\n",
 	     element_info[element].token_name,
@@ -4727,8 +4920,9 @@ void StartMoving(int x, int y)
 
       if (!IS_FREE(newx, newy))
       {
-	int new_element = Feld[newx][newy];
-	int sound;
+	int action = (IS_DIGGABLE(new_element) ? ACTION_DIGGING :
+		      IS_COLLECTIBLE(new_element) ? ACTION_COLLECTING :
+		      ACTION_BREAKING);
 
 	/* no element can dig solid indestructible elements */
 	if (IS_INDESTRUCTIBLE(new_element) &&
@@ -4753,13 +4947,12 @@ void StartMoving(int x, int y)
 	  DrawLevelField(newx, newy);
 	}
 
-	sound = (IS_DIGGABLE(new_element) ? ACTION_DIGGING :
-		 IS_COLLECTIBLE(new_element) ? ACTION_COLLECTING :
-		 ACTION_BREAKING);
-
-	PlayLevelSoundAction(x, y, sound);
+	PlayLevelSoundAction(x, y, action);
       }
 
+      if (new_element == element_info[element].move_enter_element)
+	element_info[element].can_leave_element = TRUE;
+
       if (move_pattern & MV_MAZE_RUNNER_STYLE)
       {
 	RunnerVisit[x][y] = FrameCounter;
@@ -4940,6 +5133,7 @@ void StartMoving(int x, int y)
 void ContinueMoving(int x, int y)
 {
   int element = Feld[x][y];
+  struct ElementInfo *ei = &element_info[element];
   int direction = MovDir[x][y];
   int dx = (direction == MV_LEFT ? -1 : direction == MV_RIGHT ? +1 : 0);
   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
@@ -5057,22 +5251,21 @@ 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))
+  /* some elements can leave other elements behind after moving */
+  if (IS_CUSTOM_ELEMENT(element) && !IS_PLAYER(x, y) &&
+      ei->move_leave_element != EL_EMPTY &&
+      (ei->move_leave_type == LEAVE_TYPE_UNLIMITED ||
+       ei->can_leave_element_last))
   {
-    int new_element = element_info[element].move_leave_element;
-
-    Feld[x][y] = new_element;
-
-    if (new_element != EL_EMPTY)
-    {
-      InitField(x, y, FALSE);
-
-      TestIfElementTouchesCustomElement(x, y);
+    Feld[x][y] = ei->move_leave_element;
+    InitField(x, y, FALSE);
 
-      if (GFX_CRUMBLED(new_element))
-	DrawLevelFieldCrumbledSandNeighbours(x, y);
-    }
+    if (GFX_CRUMBLED(Feld[x][y]))
+      DrawLevelFieldCrumbledSandNeighbours(x, y);
   }
+
+  ei->can_leave_element_last = ei->can_leave_element;
+  ei->can_leave_element = FALSE;
 #endif
 
 #if 0
@@ -5134,7 +5327,7 @@ void ContinueMoving(int x, int y)
     Impact(x, newy);
 
 #if 1
-  TestIfElementTouchesCustomElement(x, y);		/* for empty space */
+  TestIfElementTouchesCustomElement(x, y);	/* empty or new element */
 #endif
 
 #if 0
@@ -5159,15 +5352,7 @@ void ContinueMoving(int x, int y)
 #if 0
     if (IN_LEV_FIELD(nextx, nexty))
     {
-      static int opposite_directions[] =
-      {
-	MV_RIGHT,
-	MV_LEFT,
-	MV_DOWN,
-	MV_UP
-      };
-      int move_dir_bit = MV_DIR_BIT(direction);
-      int opposite_direction = opposite_directions[move_dir_bit];
+      int opposite_direction = MV_DIR_OPPOSITE(direction);
       int hitting_side = direction;
       int touched_side = opposite_direction;
       int touched_element = MovingOrBlocked2Element(nextx, nexty);
@@ -6126,9 +6311,11 @@ static void ChangeActiveTrap(int x, int y)
 
 static void ChangeElementNowExt(int x, int y, int target_element)
 {
+  int previous_move_direction = MovDir[x][y];
+
   /* check if element under player changes from accessible to unaccessible
      (needed for special case of dropping element which then changes) */
-  if (IS_PLAYER(x, y) && !PLAYER_PROTECTED(x, y) &&
+  if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y) &&
       IS_ACCESSIBLE(Feld[x][y]) && !IS_ACCESSIBLE(target_element))
   {
     Bang(x, y);
@@ -6143,6 +6330,9 @@ static void ChangeElementNowExt(int x, int y, int target_element)
   ResetGfxAnimation(x, y);
   ResetRandomAnimationValue(x, y);
 
+  if (element_info[Feld[x][y]].move_direction_initial == MV_START_PREVIOUS)
+    MovDir[x][y] = previous_move_direction;
+
   InitField(x, y, FALSE);
   if (CAN_MOVE(Feld[x][y]))
     InitMovDir(x, y);
@@ -6382,7 +6572,12 @@ static boolean CheckTriggeredElementSideChange(int lx, int ly,
 	  change->events & CH_EVENT_BIT(trigger_event) &&
 #endif
 	  change->sides & trigger_side &&
-	  change->trigger_element == trigger_element)
+#if 1
+	  IS_EQUAL_OR_IN_GROUP(trigger_element, change->trigger_element)
+#else
+	  change->trigger_element == trigger_element
+#endif
+	  )
       {
 #if 0
 	if (!(change->events & CH_EVENT_BIT(trigger_event)))
@@ -7461,6 +7656,38 @@ void ScrollLevel(int dx, int dy)
   redraw_mask |= REDRAW_FIELD;
 }
 
+static boolean canEnterSupaplexPort(int x, int y, int dx, int dy)
+{
+  int nextx = x + dx, nexty = y + dy;
+  int element = Feld[x][y];
+
+  if ((dx == -1 &&
+       element != EL_SP_PORT_LEFT &&
+       element != EL_SP_GRAVITY_PORT_LEFT &&
+       element != EL_SP_PORT_HORIZONTAL &&
+       element != EL_SP_PORT_ANY) ||
+      (dx == +1 &&
+       element != EL_SP_PORT_RIGHT &&
+       element != EL_SP_GRAVITY_PORT_RIGHT &&
+       element != EL_SP_PORT_HORIZONTAL &&
+       element != EL_SP_PORT_ANY) ||
+      (dy == -1 &&
+       element != EL_SP_PORT_UP &&
+       element != EL_SP_GRAVITY_PORT_UP &&
+       element != EL_SP_PORT_VERTICAL &&
+       element != EL_SP_PORT_ANY) ||
+      (dy == +1 &&
+       element != EL_SP_PORT_DOWN &&
+       element != EL_SP_GRAVITY_PORT_DOWN &&
+       element != EL_SP_PORT_VERTICAL &&
+       element != EL_SP_PORT_ANY) ||
+      !IN_LEV_FIELD(nextx, nexty) ||
+      !IS_FREE(nextx, nexty))
+    return FALSE;
+
+  return TRUE;
+}
+
 static void CheckGravityMovement(struct PlayerInfo *player)
 {
   if (game.gravity && !player->programmed_action)
@@ -7480,7 +7707,9 @@ static void CheckGravityMovement(struct PlayerInfo *player)
     boolean player_is_moving_to_valid_field =
       (IN_LEV_FIELD(new_jx, new_jy) &&
        (Feld[new_jx][new_jy] == EL_SP_BASE ||
-	Feld[new_jx][new_jy] == EL_SAND));
+	Feld[new_jx][new_jy] == EL_SAND ||
+	(IS_SP_PORT(Feld[new_jx][new_jy]) &&
+	 canEnterSupaplexPort(new_jx, new_jy, dx, dy))));
     /* !!! extend EL_SAND to anything diggable !!! */
 
     if (field_under_player_is_free &&
@@ -7868,6 +8097,7 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
 #if 0
     DrawPlayer(player);
 #endif
+
     return;
   }
   else if (!FrameReached(&player->actual_frame_counter, 1))
@@ -7876,7 +8106,8 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
   player->MovPos += (player->MovPos > 0 ? -1 : 1) * move_stepsize;
   player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
 
-  if (Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
+  if (!player->block_last_field &&
+      Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
     Feld[last_jx][last_jy] = EL_EMPTY;
 
   /* before DrawPlayer() to draw correct player graphic for this case */
@@ -7914,6 +8145,10 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
     }
 #endif
 
+    if (player->block_last_field &&
+	Feld[last_jx][last_jy] == EL_PLAYER_IS_LEAVING)
+      Feld[last_jx][last_jy] = EL_EMPTY;
+
     player->last_jx = jx;
     player->last_jy = jy;
 
@@ -8111,7 +8346,12 @@ void TestIfElementTouchesCustomElement(int x, int y)
 	if (change->can_change &&
 	    change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
 	    change->sides & border_side &&
-	    change->trigger_element == border_element)
+#if 1
+	    IS_EQUAL_OR_IN_GROUP(border_element, change->trigger_element)
+#else
+	    change->trigger_element == border_element
+#endif
+	    )
 	{
 	  change_center_element = TRUE;
 	  center_element_change_page = j;
@@ -8133,7 +8373,12 @@ void TestIfElementTouchesCustomElement(int x, int y)
 	if (change->can_change &&
 	    change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
 	    change->sides & center_side &&
-	    change->trigger_element == center_element)
+#if 1
+	    IS_EQUAL_OR_IN_GROUP(center_element, change->trigger_element)
+#else
+	    change->trigger_element == center_element
+#endif
+	    )
 	{
 	  CheckElementSideChange(xx, yy, border_element, CH_SIDE_ANY,
 				 CE_OTHER_IS_TOUCHING, j);
@@ -8175,15 +8420,7 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
 
   if (IN_LEV_FIELD(hitx, hity))
   {
-    static int opposite_directions[] =
-    {
-      MV_RIGHT,
-      MV_LEFT,
-      MV_DOWN,
-      MV_UP
-    };
-    int move_dir_bit = MV_DIR_BIT(direction);
-    int opposite_direction = opposite_directions[move_dir_bit];
+    int opposite_direction = MV_DIR_OPPOSITE(direction);
     int hitting_side = direction;
     int touched_side = opposite_direction;
     int touched_element = MovingOrBlocked2Element(hitx, hity);
@@ -8213,7 +8450,13 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
 	  if (change->can_change &&
 	      change->events & CH_EVENT_BIT(CE_OTHER_IS_HITTING) &&
 	      change->sides & touched_side &&
-	      change->trigger_element == touched_element)
+	  
+#if 1
+	      IS_EQUAL_OR_IN_GROUP(touched_element, change->trigger_element)
+#else
+	      change->trigger_element == touched_element
+#endif
+	      )
 	  {
 	    CheckElementSideChange(x, y, hitting_element,
 				   CH_SIDE_ANY, CE_OTHER_IS_HITTING, i);
@@ -8233,7 +8476,12 @@ void TestIfElementHitsCustomElement(int x, int y, int direction)
 	  if (change->can_change &&
 	      change->events & CH_EVENT_BIT(CE_OTHER_GETS_HIT) &&
 	      change->sides & hitting_side &&
-	      change->trigger_element == hitting_element)
+#if 1
+	      IS_EQUAL_OR_IN_GROUP(hitting_element, change->trigger_element)
+#else
+	      change->trigger_element == hitting_element
+#endif
+	      )
 	  {
 	    CheckElementSideChange(hitx, hity, touched_element,
 				   CH_SIDE_ANY, CE_OTHER_GETS_HIT, i);
@@ -8301,7 +8549,7 @@ void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
 
       if (player->shield_deadly_time_left > 0)
 	Bang(kill_x, kill_y);
-      else if (!PLAYER_PROTECTED(good_x, good_y))
+      else if (!PLAYER_ENEMY_PROTECTED(good_x, good_y))
 	KillHero(player);
     }
     else
@@ -8393,7 +8641,7 @@ void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
 
       if (player->shield_deadly_time_left > 0)
 	Bang(bad_x, bad_y);
-      else if (!PLAYER_PROTECTED(kill_x, kill_y))
+      else if (!PLAYER_ENEMY_PROTECTED(kill_x, kill_y))
 	KillHero(player);
     }
     else
@@ -8483,9 +8731,15 @@ void KillHero(struct PlayerInfo *player)
   BuryHero(player);
 }
 
-static void KillHeroUnlessProtected(int x, int y)
+static void KillHeroUnlessEnemyProtected(int x, int y)
 {
-  if (!PLAYER_PROTECTED(x, y))
+  if (!PLAYER_ENEMY_PROTECTED(x, y))
+    KillHero(PLAYERINFO(x, y));
+}
+
+static void KillHeroUnlessExplosionProtected(int x, int y)
+{
+  if (!PLAYER_EXPLOSION_PROTECTED(x, y))
     KillHero(PLAYERINFO(x, y));
 }
 
@@ -8662,6 +8916,10 @@ int DigField(struct PlayerInfo *player,
     case EL_SP_GRAVITY_PORT_RIGHT:
     case EL_SP_GRAVITY_PORT_UP:
     case EL_SP_GRAVITY_PORT_DOWN:
+#if 1
+      if (!canEnterSupaplexPort(x, y, dx, dy))
+	return MF_NO_ACTION;
+#else
       if ((dx == -1 &&
 	   element != EL_SP_PORT_LEFT &&
 	   element != EL_SP_GRAVITY_PORT_LEFT &&
@@ -8685,6 +8943,7 @@ int DigField(struct PlayerInfo *player,
 	  !IN_LEV_FIELD(nextx, nexty) ||
 	  !IS_FREE(nextx, nexty))
 	return MF_NO_ACTION;
+#endif
 
       if (element == EL_SP_GRAVITY_PORT_LEFT ||
 	  element == EL_SP_GRAVITY_PORT_RIGHT ||
@@ -9349,6 +9608,11 @@ boolean DropElement(struct PlayerInfo *player)
 
     PlayLevelSoundAction(jx, jy, ACTION_DROPPING);
 
+#if 1
+    /* needed if previous element just changed to "empty" in the last frame */
+    Changed[jx][jy] = 0;		/* allow another change */
+#endif
+
     CheckTriggeredElementChange(jx, jy, new_element, CE_OTHER_GETS_DROPPED);
     CheckElementChange(jx, jy, new_element, CE_DROPPED_BY_PLAYER);
 
@@ -9386,7 +9650,7 @@ boolean DropElement(struct PlayerInfo *player)
     int move_stepsize = element_info[new_element].move_stepsize;
     int direction, dx, dy, nextx, nexty;
 
-    if (element_info[new_element].move_direction_initial == MV_NO_MOVING)
+    if (element_info[new_element].move_direction_initial == MV_START_AUTOMATIC)
       MovDir[jx][jy] = player->MovDir;
 
     direction = MovDir[jx][jy];
@@ -9406,7 +9670,7 @@ boolean DropElement(struct PlayerInfo *player)
     }
     else
     {
-      Changed[jx][jy] = 0;            /* allow another change */
+      Changed[jx][jy] = 0;		/* allow another change */
 
 #if 1
       TestIfElementHitsCustomElement(jx, jy, direction);