X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=daa0b30eb457c97ec29bd0aa69755f40964e19fd;hb=e4f31a4e6f4b611a1dddb16afb66e3af177dd937;hp=4f3b21efbe945297eb8dda2778220deadcc5e6cc;hpb=efbd589db2977f140135f247cd4aacfe6c546410;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index 4f3b21ef..daa0b30e 100644
--- a/src/game.c
+++ b/src/game.c
@@ -41,9 +41,17 @@
 #define USE_STOP_CHANGED_ELEMENTS	(USE_NEW_STUFF		* 1)
 #define USE_ELEMENT_TOUCHING_BUGFIX	(USE_NEW_STUFF		* 1)
 #define USE_NEW_CONTINUOUS_SNAPPING	(USE_NEW_STUFF		* 1)
+#define USE_GFX_RESET_GFX_ANIMATION	(USE_NEW_STUFF		* 1)
+#define USE_BOTH_SWITCHGATE_SWITCHES	(USE_NEW_STUFF		* 1)
+#define USE_PLAYER_GRAVITY		(USE_NEW_STUFF		* 1)
+#define USE_FIXED_BORDER_RUNNING_GFX	(USE_NEW_STUFF		* 1)
+#define USE_QUICKSAND_BD_ROCK_BUGFIX	(USE_NEW_STUFF		* 0)
 
 #define USE_QUICKSAND_IMPACT_BUGFIX	(USE_NEW_STUFF		* 0)
 
+#define USE_CODE_THAT_BREAKS_SNAKE_BITE	(USE_NEW_STUFF		* 1)
+
+
 /* for DigField() */
 #define DF_NO_PUSH		0
 #define DF_DIG			1
@@ -159,13 +167,21 @@
 	((e) >= NUM_FILE_ELEMENTS ? EL_UNKNOWN : (e))
 #endif
 
-#define GET_TARGET_ELEMENT(e, ch, cv, cs)				\
+#define RESOLVED_REFERENCE_ELEMENT(be, e)				\
+	((be) + (e) - EL_SELF < EL_CUSTOM_START ? EL_CUSTOM_START :	\
+	 (be) + (e) - EL_SELF > EL_CUSTOM_END   ? EL_CUSTOM_END :	\
+	 (be) + (e) - EL_SELF)
+
+#define GET_TARGET_ELEMENT(be, e, ch, cv, cs)				\
 	((e) == EL_TRIGGER_PLAYER   ? (ch)->actual_trigger_player    :	\
 	 (e) == EL_TRIGGER_ELEMENT  ? (ch)->actual_trigger_element   :	\
 	 (e) == EL_TRIGGER_CE_VALUE ? (ch)->actual_trigger_ce_value  :	\
 	 (e) == EL_TRIGGER_CE_SCORE ? (ch)->actual_trigger_ce_score  :	\
 	 (e) == EL_CURRENT_CE_VALUE ? (cv) :				\
-	 (e) == EL_CURRENT_CE_SCORE ? (cs) : (e))
+	 (e) == EL_CURRENT_CE_SCORE ? (cs) :				\
+	 (e) >= EL_LAST_CE_8 && (e) <= EL_NEXT_CE_8 ?			\
+	 RESOLVED_REFERENCE_ELEMENT(be, e) :				\
+	 (e))
 
 #define CAN_GROW_INTO(e)						\
 	((e) == EL_SAND || (IS_DIGGABLE(e) && level.grow_into_diggable))
@@ -363,6 +379,8 @@ void RemovePlayer(struct PlayerInfo *);
 boolean SnapField(struct PlayerInfo *, int, int);
 boolean DropElement(struct PlayerInfo *);
 
+static int getInvisibleActiveFromInvisibleElement(int);
+static int getInvisibleFromInvisibleActiveElement(int);
 
 static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
 
@@ -775,6 +793,7 @@ static int get_move_delay_from_stepsize(int move_stepsize)
 static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
 			       boolean init_game)
 {
+  int player_nr = player->index_nr;
   int move_delay = get_move_delay_from_stepsize(move_stepsize);
   boolean cannot_move = (move_stepsize == STEPSIZE_NOT_MOVING ? TRUE : FALSE);
 
@@ -786,8 +805,8 @@ static void SetPlayerMoveSpeed(struct PlayerInfo *player, int move_stepsize,
 
   if (init_game)
   {
-    player->move_delay       = game.initial_move_delay;
-    player->move_delay_value = game.initial_move_delay_value;
+    player->move_delay       = game.initial_move_delay[player_nr];
+    player->move_delay_value = game.initial_move_delay_value[player_nr];
 
     player->move_delay_value_next = -1;
 
@@ -1116,16 +1135,26 @@ static void InitField(int x, int y, boolean init_game)
       }
       break;
 
+#if !USE_BOTH_SWITCHGATE_SWITCHES
     case EL_SWITCHGATE_SWITCH_DOWN:	/* always start with same switch pos */
       if (init_game)
 	Feld[x][y] = EL_SWITCHGATE_SWITCH_UP;
       break;
+#endif
 
     case EL_LIGHT_SWITCH_ACTIVE:
       if (init_game)
 	game.light_time_left = level.time_light * FRAMES_PER_SECOND;
       break;
 
+    case EL_INVISIBLE_STEELWALL:
+    case EL_INVISIBLE_WALL:
+    case EL_INVISIBLE_SAND:
+      if (game.light_time_left > 0 ||
+	  game.lenses_time_left > 0)
+        Feld[x][y] = getInvisibleActiveFromInvisibleElement(element);
+      break;
+
     case EL_EMC_MAGIC_BALL:
       if (game.ball_state)
 	Feld[x][y] = EL_EMC_MAGIC_BALL_ACTIVE;
@@ -1180,6 +1209,7 @@ static void InitField(int x, int y, boolean init_game)
 	InitField(x, y, init_game);
 #endif
       }
+
       break;
   }
 
@@ -1236,12 +1266,16 @@ static inline void InitField_WithBug2(int x, int y, boolean init_game)
 
 inline void DrawGameValue_Emeralds(int value)
 {
-  DrawText(DX_EMERALDS, DY_EMERALDS, int2str(value, 3), FONT_TEXT_2);
+  int xpos = (3 * 14 - 3 * getFontWidth(FONT_TEXT_2)) / 2;
+
+  DrawText(DX_EMERALDS + xpos, DY_EMERALDS, int2str(value, 3), FONT_TEXT_2);
 }
 
 inline void DrawGameValue_Dynamite(int value)
 {
-  DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(value, 3), FONT_TEXT_2);
+  int xpos = (3 * 14 - 3 * getFontWidth(FONT_TEXT_2)) / 2;
+
+  DrawText(DX_DYNAMITE + xpos, DY_DYNAMITE, int2str(value, 3), FONT_TEXT_2);
 }
 
 inline void DrawGameValue_Keys(int key[MAX_NUM_KEYS])
@@ -1267,15 +1301,24 @@ inline void DrawGameValue_Keys(int key[MAX_NUM_KEYS])
 
 inline void DrawGameValue_Score(int value)
 {
-  DrawText(DX_SCORE, DY_SCORE, int2str(value, 5), FONT_TEXT_2);
+  int xpos = (5 * 14 - 5 * getFontWidth(FONT_TEXT_2)) / 2;
+
+  DrawText(DX_SCORE + xpos, DY_SCORE, int2str(value, 5), FONT_TEXT_2);
 }
 
 inline void DrawGameValue_Time(int value)
 {
+  int xpos3 = (3 * 14 - 3 * getFontWidth(FONT_TEXT_2)) / 2;
+  int xpos4 = (4 * 10 - 4 * getFontWidth(FONT_LEVEL_NUMBER)) / 2;
+
+  /* clear background if value just changed its size */
+  if (value == 999 || value == 1000)
+    ClearRectangle(drawto, DX_TIME1, DY_TIME, 14 * 3, 14);
+
   if (value < 1000)
-    DrawText(DX_TIME1, DY_TIME, int2str(value, 3), FONT_TEXT_2);
+    DrawText(DX_TIME1 + xpos3, DY_TIME, int2str(value, 3), FONT_TEXT_2);
   else
-    DrawText(DX_TIME2, DY_TIME, int2str(value, 4), FONT_LEVEL_NUMBER);
+    DrawText(DX_TIME2 + xpos4, DY_TIME, int2str(value, 4), FONT_LEVEL_NUMBER);
 }
 
 inline void DrawGameValue_Level(int value)
@@ -1421,6 +1464,18 @@ static void resolve_group_element(int group_element, int recursion_depth)
 }
 #endif
 
+#if 0
+static void replace_reference_element(int base_element, int *element)
+{
+  if (*element >= EL_LAST_CE_8 && *element <= EL_NEXT_CE_8)
+  {
+    *element = base_element + *element - EL_SELF;
+    *element = (*element < EL_CUSTOM_START ? EL_CUSTOM_START :
+		*element > EL_CUSTOM_END   ? EL_CUSTOM_END   : *element);
+  }
+}
+#endif
+
 /*
   =============================================================================
   InitGameEngine()
@@ -1566,8 +1621,9 @@ static void InitGameEngine()
 
 #if 1
   /* dynamically adjust player properties according to level information */
-  game.initial_move_delay_value =
-    get_move_delay_from_stepsize(level.initial_player_stepsize);
+  for (i = 0; i < MAX_PLAYERS; i++)
+    game.initial_move_delay_value[i] =
+      get_move_delay_from_stepsize(level.initial_player_stepsize[i]);
 #else
   /* dynamically adjust player properties according to level information */
   game.initial_move_delay_value =
@@ -1575,8 +1631,10 @@ static void InitGameEngine()
 #endif
 
   /* dynamically adjust player properties according to game engine version */
-  game.initial_move_delay = (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
-			     game.initial_move_delay_value : 0);
+  for (i = 0; i < MAX_PLAYERS; i++)
+    game.initial_move_delay[i] =
+      (game.engine_version <= VERSION_IDENT(2,0,1,0) ?
+       game.initial_move_delay_value[i] : 0);
 
   /* ---------- initialize player's initial push delay --------------------- */
 
@@ -1720,6 +1778,11 @@ static void InitGameEngine()
 	      for (l = 0; l < group->num_elements_resolved; l++)
 		trigger_events[group->element_resolved[l]][k] = TRUE;
 	    }
+#if 1
+	    else if (trigger_element == EL_ANY_ELEMENT)
+	      for (l = 0; l < MAX_NUM_ELEMENTS; l++)
+		trigger_events[l][k] = TRUE;
+#endif
 	    else
 	      trigger_events[trigger_element][k] = TRUE;
 	  }
@@ -1735,8 +1798,22 @@ static void InitGameEngine()
   {
     if (!IS_CUSTOM_ELEMENT(i))
     {
+#if 1
+      /* set default push delay values (corrected since version 3.0.7-1) */
+      if (game.engine_version < VERSION_IDENT(3,0,7,1))
+      {
+	element_info[i].push_delay_fixed = 2;
+	element_info[i].push_delay_random = 8;
+      }
+      else
+      {
+	element_info[i].push_delay_fixed = 8;
+	element_info[i].push_delay_random = 8;
+      }
+#else
       element_info[i].push_delay_fixed  = game.default_push_delay_fixed;
       element_info[i].push_delay_random = game.default_push_delay_random;
+#endif
     }
   }
 
@@ -1843,6 +1920,29 @@ static void InitGameEngine()
 	 EL_EMPTY);
     }
   }
+
+#if 0
+  /* ---------- initialize reference elements ------------------------------- */
+  for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+  {
+    int element = EL_CUSTOM_START + i;
+    struct ElementInfo *ei = &element_info[element];
+
+    for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
+      replace_reference_element(element, &ei->content.e[x][y]);
+
+    for (j = 0; j < ei->num_change_pages; j++)
+    {
+      struct ElementChangeInfo *change = &ei->change_page[j];
+
+      replace_reference_element(element, &change->target_element);
+      replace_reference_element(element, &change->trigger_element);
+
+      for (y = 0; y < 3; y++) for (x = 0; x < 3; x++)
+	replace_reference_element(element, &change->target_content.e[x][y]);
+    }
+  }
+#endif
 }
 
 int get_num_special_action(int element, int action_first, int action_last)
@@ -1937,6 +2037,8 @@ void InitGame()
     player->block_last_field = FALSE;	/* initialized in InitPlayerField() */
     player->block_delay_adjustment = 0;	/* initialized in InitPlayerField() */
 
+    player->gravity = level.initial_player_gravity[i];
+
     player->can_fall_into_acid = CAN_MOVE_INTO_ACID(player->element_nr);
 
     player->actual_frame_counter = 0;
@@ -1945,6 +2047,8 @@ void InitGame()
 
     player->last_move_dir = MV_NONE;
 
+    player->is_active = FALSE;
+
     player->is_waiting = FALSE;
     player->is_moving = FALSE;
     player->is_auto_moving = FALSE;
@@ -1992,7 +2096,7 @@ void InitGame()
     player->show_envelope = 0;
 
 #if 1
-    SetPlayerMoveSpeed(player, level.initial_player_stepsize, TRUE);
+    SetPlayerMoveSpeed(player, level.initial_player_stepsize[i], TRUE);
 #else
     player->move_delay       = game.initial_move_delay;
     player->move_delay_value = game.initial_move_delay_value;
@@ -2058,8 +2162,15 @@ void InitGame()
   game.timegate_time_left = 0;
   game.switchgate_pos = 0;
   game.wind_direction = level.wind_direction_initial;
+
+#if !USE_PLAYER_GRAVITY
+#if 1
+  game.gravity = FALSE;
+#else
   game.gravity = level.initial_gravity;
+#endif
   game.explosions_delayed = TRUE;
+#endif
 
   game.lenses_time_left = 0;
   game.magnify_time_left = 0;
@@ -2898,7 +3009,7 @@ int NewHiScore()
 
   LoadScore(level_nr);
 
-  if (strcmp(setup.player_name, EMPTY_PLAYER_NAME) == 0 ||
+  if (strEqual(setup.player_name, EMPTY_PLAYER_NAME) ||
       local_player->score < highscore[MAX_SCORE_ENTRIES - 1].Score) 
     return -1;
 
@@ -2914,7 +3025,7 @@ int NewHiScore()
 
 #ifdef ONE_PER_NAME
 	for (l = k; l < MAX_SCORE_ENTRIES; l++)
-	  if (!strcmp(setup.player_name, highscore[l].Name))
+	  if (strEqual(setup.player_name, highscore[l].Name))
 	    m = l;
 	if (m == k)	/* player's new highscore overwrites his old one */
 	  goto put_into_list;
@@ -2998,10 +3109,26 @@ void InitPlayerGfxAnimation(struct PlayerInfo *player, int action, int dir)
   }
 }
 
-static void ResetRandomAnimationValue(int x, int y)
+#if USE_GFX_RESET_GFX_ANIMATION
+static void ResetGfxFrame(int x, int y, boolean redraw)
 {
-  GfxRandom[x][y] = INIT_GFX_RANDOM();
+  int element = Feld[x][y];
+  int graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
+  int last_gfx_frame = GfxFrame[x][y];
+
+  if (graphic_info[graphic].anim_global_sync)
+    GfxFrame[x][y] = FrameCounter;
+  else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
+    GfxFrame[x][y] = CustomValue[x][y];
+  else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
+    GfxFrame[x][y] = element_info[element].collect_score;
+  else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
+    GfxFrame[x][y] = ChangeDelay[x][y];
+
+  if (redraw && GfxFrame[x][y] != last_gfx_frame)
+    DrawLevelGraphicAnimation(x, y, graphic);
 }
+#endif
 
 static void ResetGfxAnimation(int x, int y)
 {
@@ -3009,9 +3136,9 @@ static void ResetGfxAnimation(int x, int y)
   int element, graphic;
 #endif
 
-  GfxFrame[x][y] = 0;
   GfxAction[x][y] = ACTION_DEFAULT;
   GfxDir[x][y] = MovDir[x][y];
+  GfxFrame[x][y] = 0;
 
 #if 0
   element = Feld[x][y];
@@ -3023,9 +3150,20 @@ static void ResetGfxAnimation(int x, int y)
     GfxFrame[x][y] = CustomValue[x][y];
   else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
     GfxFrame[x][y] = element_info[element].collect_score;
+  else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
+    GfxFrame[x][y] = ChangeDelay[x][y];
+#endif
+
+#if USE_GFX_RESET_GFX_ANIMATION
+  ResetGfxFrame(x, y, FALSE);
 #endif
 }
 
+static void ResetRandomAnimationValue(int x, int y)
+{
+  GfxRandom[x][y] = INIT_GFX_RANDOM();
+}
+
 void InitMovingField(int x, int y, int direction)
 {
   int element = Feld[x][y];
@@ -3054,6 +3192,8 @@ void InitMovingField(int x, int y, int direction)
     GfxFrame[x][y] = CustomValue[x][y];
   else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
     GfxFrame[x][y] = element_info[element].collect_score;
+  else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
+    GfxFrame[x][y] = ChangeDelay[x][y];
 #endif
 
   /* this is needed for CEs with property "can move" / "not moving" */
@@ -4372,12 +4512,25 @@ static void ToggleSwitchgateSwitch(int x, int y)
   {
     int element = Feld[xx][yy];
 
+#if !USE_BOTH_SWITCHGATE_SWITCHES
     if (element == EL_SWITCHGATE_SWITCH_UP ||
 	element == EL_SWITCHGATE_SWITCH_DOWN)
     {
       Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP + game.switchgate_pos;
       DrawLevelField(xx, yy);
     }
+#else
+    if (element == EL_SWITCHGATE_SWITCH_UP)
+    {
+      Feld[xx][yy] = EL_SWITCHGATE_SWITCH_DOWN;
+      DrawLevelField(xx, yy);
+    }
+    else if (element == EL_SWITCHGATE_SWITCH_DOWN)
+    {
+      Feld[xx][yy] = EL_SWITCHGATE_SWITCH_UP;
+      DrawLevelField(xx, yy);
+    }
+#endif
     else if (element == EL_SWITCHGATE_OPEN ||
 	     element == EL_SWITCHGATE_OPENING)
     {
@@ -5683,7 +5836,7 @@ inline static void TurnRoundExt(int x, int y)
 static void TurnRound(int x, int y)
 {
   int direction = MovDir[x][y];
-#if 1
+#if 0
   int element, graphic;
 #endif
 
@@ -5698,6 +5851,8 @@ static void TurnRound(int x, int y)
     GfxAction[x][y] = ACTION_TURNING_FROM_LEFT + MV_DIR_TO_BIT(direction);
 
 #if 1
+  ResetGfxFrame(x, y, FALSE);
+#else
   element = Feld[x][y];
   graphic = el_act_dir2img(element, GfxAction[x][y], GfxDir[x][y]);
 
@@ -5707,6 +5862,8 @@ static void TurnRound(int x, int y)
     GfxFrame[x][y] = CustomValue[x][y];
   else if (ANIM_MODE(graphic) == ANIM_CE_SCORE)
     GfxFrame[x][y] = element_info[element].collect_score;
+  else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
+    GfxFrame[x][y] = ChangeDelay[x][y];
 #endif
 }
 
@@ -5757,7 +5914,12 @@ void StartMoving(int x, int y)
 	started_moving = TRUE;
 
 	Feld[x][y] = EL_QUICKSAND_EMPTYING;
+#if USE_QUICKSAND_BD_ROCK_BUGFIX
+	if (Store[x][y] != EL_ROCK && Store[x][y] != EL_BD_ROCK)
+	  Store[x][y] = EL_ROCK;
+#else
 	Store[x][y] = EL_ROCK;
+#endif
 
 	PlayLevelSoundAction(x, y, ACTION_EMPTYING);
       }
@@ -7700,7 +7862,8 @@ void MauerAbleger(int ax, int ay)
 
   if (element == EL_EXPANDABLE_WALL_HORIZONTAL ||
       element == EL_EXPANDABLE_WALL_ANY ||
-      element == EL_EXPANDABLE_WALL)
+      element == EL_EXPANDABLE_WALL ||
+      element == EL_BD_EXPANDABLE_WALL)
   {
     if (links_frei)
     {
@@ -7926,7 +8089,7 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page)
      CA_ARG_MAX);
 
   int action_arg_number_reset =
-    (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize :
+    (action_type == CA_SET_PLAYER_SPEED ? level.initial_player_stepsize[0] :
      action_type == CA_SET_LEVEL_GEMS ? level.gems_needed :
      action_type == CA_SET_LEVEL_TIME ? level.time :
      action_type == CA_SET_LEVEL_SCORE ? 0 :
@@ -8052,6 +8215,7 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page)
       break;
     }
 
+#if !USE_PLAYER_GRAVITY
     case CA_SET_LEVEL_GRAVITY:
     {
       game.gravity = (action_arg == CA_ARG_GRAVITY_OFF    ? FALSE         :
@@ -8060,6 +8224,7 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page)
 		      game.gravity);
       break;
     }
+#endif
 
     case CA_SET_LEVEL_WIND:
     {
@@ -8146,6 +8311,10 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page)
 	    action_mode = (action_arg == CA_ARG_SPEED_SLOWER ? CA_MODE_DIVIDE :
 			   CA_MODE_MULTIPLY);
 	  }
+	  else if (action_arg == CA_ARG_NUMBER_RESET)
+	  {
+	    action_arg_number = level.initial_player_stepsize[i];
+	  }
 
 	  move_stepsize =
 	    getModifiedActionNumber(move_stepsize,
@@ -8198,6 +8367,25 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page)
       break;
     }
 
+#if USE_PLAYER_GRAVITY
+    case CA_SET_PLAYER_GRAVITY:
+    {
+      for (i = 0; i < MAX_PLAYERS; i++)
+      {
+	if (trigger_player_bits & (1 << i))
+	{
+	  stored_player[i].gravity =
+	    (action_arg == CA_ARG_GRAVITY_OFF    ? FALSE                     :
+	     action_arg == CA_ARG_GRAVITY_ON     ? TRUE                      :
+	     action_arg == CA_ARG_GRAVITY_TOGGLE ? !stored_player[i].gravity :
+	     stored_player[i].gravity);
+	}
+      }
+
+      break;
+    }
+#endif
+
     case CA_SET_PLAYER_ARTWORK:
     {
       for (i = 0; i < MAX_PLAYERS; i++)
@@ -8233,27 +8421,34 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page)
     case CA_SET_CE_VALUE:
     {
 #if USE_NEW_CUSTOM_VALUE
-      int last_custom_value = CustomValue[x][y];
+      int last_ce_value = CustomValue[x][y];
 
       CustomValue[x][y] = action_arg_number_new;
 
 #if 0
-      printf("::: Count == %d\n", CustomValue[x][y]);
+      printf("::: CE value == %d\n", CustomValue[x][y]);
 #endif
 
-      if (CustomValue[x][y] == 0 && last_custom_value > 0)
+      if (CustomValue[x][y] != last_ce_value)
       {
+	CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_CHANGES);
+	CheckTriggeredElementChange(x, y, element, CE_VALUE_CHANGES_OF_X);
+
+	if (CustomValue[x][y] == 0)
+	{
 #if 0
-	printf("::: CE_VALUE_GETS_ZERO\n");
+	  printf("::: CE_VALUE_GETS_ZERO\n");
 #endif
 
-	CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
-	CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
+	  CheckElementChange(x, y, element, EL_UNDEFINED, CE_VALUE_GETS_ZERO);
+	  CheckTriggeredElementChange(x, y, element, CE_VALUE_GETS_ZERO_OF_X);
 
 #if 0
-	printf("::: RESULT: %d, %d\n", Feld[x][y], ChangePage[x][y]);
+	  printf("::: RESULT: %d, %d\n", Feld[x][y], ChangePage[x][y]);
 #endif
+	}
       }
+
 #endif
 
       break;
@@ -8261,8 +8456,59 @@ static void ExecuteCustomElementAction(int x, int y, int element, int page)
 
     case CA_SET_CE_SCORE:
     {
+#if USE_NEW_CUSTOM_VALUE
+      int last_ce_score = ei->collect_score;
+
       ei->collect_score = action_arg_number_new;
 
+#if 0
+      printf("::: CE score == %d\n", ei->collect_score);
+#endif
+
+      if (ei->collect_score != last_ce_score)
+      {
+	CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_CHANGES);
+	CheckTriggeredElementChange(x, y, element, CE_SCORE_CHANGES_OF_X);
+
+	if (ei->collect_score == 0)
+	{
+	  int xx, yy;
+
+#if 0
+	  printf("::: CE_SCORE_GETS_ZERO\n");
+#endif
+
+	  CheckElementChange(x, y, element, EL_UNDEFINED, CE_SCORE_GETS_ZERO);
+	  CheckTriggeredElementChange(x, y, element, CE_SCORE_GETS_ZERO_OF_X);
+
+#if 0
+	  printf("::: RESULT: %d, %d\n", Feld[x][y], ChangePage[x][y]);
+#endif
+
+#if 1
+	  /*
+	    This is a very special case that seems to be a mixture between
+	    CheckElementChange() and CheckTriggeredElementChange(): while
+	    the first one only affects single elements that are triggered
+	    directly, the second one affects multiple elements in the playfield
+	    that are triggered indirectly by another element. This is a third
+	    case: Changing the CE score always affects multiple identical CEs,
+	    so every affected CE must be checked, not only the single CE for
+	    which the CE score was changed in the first place (as every instance
+	    of that CE shares the same CE score, and therefore also can change)!
+	  */
+	  SCAN_PLAYFIELD(xx, yy)
+	  {
+	    if (Feld[xx][yy] == element)
+	      CheckElementChange(xx, yy, element, EL_UNDEFINED,
+				 CE_SCORE_GETS_ZERO);
+	  }
+#endif
+	}
+      }
+
+#endif
+
       break;
     }
 
@@ -8288,11 +8534,18 @@ static void CreateFieldExt(int x, int y, int element, boolean is_change)
 #if USE_NEW_CUSTOM_VALUE
   int last_ce_value = CustomValue[x][y];
 #endif
-  boolean add_player = (ELEM_IS_PLAYER(new_element) &&
-			IS_WALKABLE(old_element));
+  boolean new_element_is_player = ELEM_IS_PLAYER(new_element);
+  boolean add_player_onto_element = (new_element_is_player &&
+#if USE_CODE_THAT_BREAKS_SNAKE_BITE
+				     /* this breaks SnakeBite when a snake is
+					halfway through a door that closes */
+				     /* NOW FIXED AT LEVEL INIT IN files.c */
+				     new_element != EL_SOKOBAN_FIELD_PLAYER &&
+#endif
+				     IS_WALKABLE(old_element));
 
 #if 0
-  /* check if element under player changes from accessible to unaccessible
+  /* check if element under the player changes from accessible to unaccessible
      (needed for special case of dropping element which then changes) */
   if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y) &&
       IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
@@ -8303,7 +8556,7 @@ static void CreateFieldExt(int x, int y, int element, boolean is_change)
   }
 #endif
 
-  if (!add_player)
+  if (!add_player_onto_element)
   {
     if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
       RemoveMovingField(x, y);
@@ -8312,8 +8565,10 @@ static void CreateFieldExt(int x, int y, int element, boolean is_change)
 
     Feld[x][y] = new_element;
 
+#if !USE_GFX_RESET_GFX_ANIMATION
     ResetGfxAnimation(x, y);
     ResetRandomAnimationValue(x, y);
+#endif
 
     if (element_info[new_element].move_direction_initial == MV_START_PREVIOUS)
       MovDir[x][y] = previous_move_direction;
@@ -8327,6 +8582,11 @@ static void CreateFieldExt(int x, int y, int element, boolean is_change)
 
     new_element = Feld[x][y];	/* element may have changed */
 
+#if USE_GFX_RESET_GFX_ANIMATION
+    ResetGfxAnimation(x, y);
+    ResetRandomAnimationValue(x, y);
+#endif
+
     DrawLevelField(x, y);
 
     if (GFX_CRUMBLED(new_element))
@@ -8334,8 +8594,9 @@ static void CreateFieldExt(int x, int y, int element, boolean is_change)
   }
 
 #if 1
-  /* check if element under player changes from accessible to unaccessible
+  /* check if element under the player changes from accessible to unaccessible
      (needed for special case of dropping element which then changes) */
+  /* (must be checked after creating new element for walkable group elements) */
   if (IS_PLAYER(x, y) && !PLAYER_EXPLOSION_PROTECTED(x, y) &&
       IS_ACCESSIBLE(old_element) && !IS_ACCESSIBLE(new_element))
   {
@@ -8346,7 +8607,7 @@ static void CreateFieldExt(int x, int y, int element, boolean is_change)
 #endif
 
   /* "ChangeCount" not set yet to allow "entered by player" change one time */
-  if (ELEM_IS_PLAYER(new_element))
+  if (new_element_is_player)
     RelocatePlayer(x, y, new_element);
 
   if (is_change)
@@ -8507,7 +8768,7 @@ static boolean ChangeElement(int x, int y, int element, int page)
 	  ChangeEvent[ex][ey] = ChangeEvent[x][y];
 
 	  content_element = change->target_content.e[xx][yy];
-	  target_element = GET_TARGET_ELEMENT(content_element, change,
+	  target_element = GET_TARGET_ELEMENT(element, content_element, change,
 					      ce_value, ce_score);
 
 	  CreateElementFromChange(ex, ey, target_element);
@@ -8529,7 +8790,7 @@ static boolean ChangeElement(int x, int y, int element, int page)
   }
   else
   {
-    target_element = GET_TARGET_ELEMENT(change->target_element, change,
+    target_element = GET_TARGET_ELEMENT(element, change->target_element, change,
 					ce_value, ce_score);
 
     if (element == EL_DIAGONAL_GROWING ||
@@ -9469,6 +9730,10 @@ void GameActions_EM_Main()
   for (i = 0; i < MAX_PLAYERS; i++)
     effective_action[i] = stored_player[i].effective_action;
 
+#if 0
+  printf("::: %04d: %08x\n", FrameCounter, effective_action[0]);
+#endif
+
   GameActions_EM(effective_action, warp_mode);
 
   CheckLevelTime();
@@ -9699,6 +9964,9 @@ void GameActions_RND()
       printf("::: Yo man! Rocks can fall!\n");
 #endif
 
+#if 1
+    ResetGfxFrame(x, y, TRUE);
+#else
     if (graphic_info[graphic].anim_global_sync)
       GfxFrame[x][y] = FrameCounter;
     else if (ANIM_MODE(graphic) == ANIM_CE_VALUE)
@@ -9723,6 +9991,18 @@ void GameActions_RND()
 #endif
 	DrawLevelGraphicAnimation(x, y, graphic);
     }
+    else if (ANIM_MODE(graphic) == ANIM_CE_DELAY)
+    {
+      int old_gfx_frame = GfxFrame[x][y];
+
+      GfxFrame[x][y] = ChangeDelay[x][y];
+
+#if 1
+      if (GfxFrame[x][y] != old_gfx_frame)
+#endif
+	DrawLevelGraphicAnimation(x, y, graphic);
+    }
+#endif
 
     if (ANIM_MODE(graphic) == ANIM_RANDOM &&
 	IS_NEXT_FRAME(GfxFrame[x][y], graphic))
@@ -9824,7 +10104,8 @@ void GameActions_RND()
     else if (element == EL_EXPANDABLE_WALL ||
 	     element == EL_EXPANDABLE_WALL_HORIZONTAL ||
 	     element == EL_EXPANDABLE_WALL_VERTICAL ||
-	     element == EL_EXPANDABLE_WALL_ANY)
+	     element == EL_EXPANDABLE_WALL_ANY ||
+	     element == EL_BD_EXPANDABLE_WALL)
       MauerAbleger(x, y);
     else if (element == EL_FLAMES)
       CheckForDragon(x, y);
@@ -10169,11 +10450,15 @@ static boolean canMoveToValidFieldWithGravity(int x, int y, int move_dir)
 
 static void CheckGravityMovement(struct PlayerInfo *player)
 {
+#if USE_PLAYER_GRAVITY
+  if (player->gravity && !player->programmed_action)
+#else
   if (game.gravity && !player->programmed_action)
+#endif
   {
     int move_dir_horizontal = player->effective_action & MV_HORIZONTAL;
     int move_dir_vertical   = player->effective_action & MV_VERTICAL;
-    boolean player_is_snapping = player->effective_action & JOY_BUTTON_1;
+    boolean player_is_snapping = (player->effective_action & JOY_BUTTON_1);
     int jx = player->jx, jy = player->jy;
     boolean player_is_moving_to_valid_field =
       (!player_is_snapping &&
@@ -10191,7 +10476,11 @@ static void CheckGravityMovementWhenNotMoving(struct PlayerInfo *player)
 {
   return CheckGravityMovement(player);
 
+#if USE_PLAYER_GRAVITY
+  if (player->gravity && !player->programmed_action)
+#else
   if (game.gravity && !player->programmed_action)
+#endif
   {
     int jx = player->jx, jy = player->jy;
     boolean field_under_player_is_free =
@@ -10392,6 +10681,8 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
     player->move_delay_value = original_move_delay_value;
   }
 
+  player->is_active = FALSE;
+
   if (player->last_move_dir & MV_HORIZONTAL)
   {
     if (!(moved |= MovePlayerOneStep(player, 0, dy, dx, dy)))
@@ -10403,6 +10694,17 @@ boolean MovePlayer(struct PlayerInfo *player, int dx, int dy)
       moved |= MovePlayerOneStep(player, 0, dy, dx, dy);
   }
 
+#if USE_FIXED_BORDER_RUNNING_GFX
+  if (!moved && !player->is_active)
+  {
+    player->is_moving = FALSE;
+    player->is_digging = FALSE;
+    player->is_collecting = FALSE;
+    player->is_snapping = FALSE;
+    player->is_pushing = FALSE;
+  }
+#endif
+
   jx = player->jx;
   jy = player->jy;
 
@@ -10574,8 +10876,13 @@ void ScrollPlayer(struct PlayerInfo *player, int mode)
 	last_field_block_delay += player->move_delay_value;
 
 	/* when blocking enabled, prevent moving up despite gravity */
+#if USE_PLAYER_GRAVITY
+	if (player->gravity && player->MovDir == MV_UP)
+	  block_delay_adjustment = -1;
+#else
 	if (game.gravity && player->MovDir == MV_UP)
 	  block_delay_adjustment = -1;
+#endif
       }
 
       /* add block delay adjustment (also possible when not blocking) */
@@ -11497,6 +11804,8 @@ int DigField(struct PlayerInfo *player,
 	   game.engine_version >= VERSION_IDENT(2,2,0,0))
     old_element = Back[jx][jy];
 
+  /* checking here causes player to move into acid even if the current field
+     cannot be left to that direction */
 #if 0
 #if USE_FIXED_DONT_RUN_INTO
   if (player_can_move && DONT_RUN_INTO(element))
@@ -11518,6 +11827,43 @@ int DigField(struct PlayerInfo *player,
 #endif
 #endif
 
+#if 1	/* ------------------------------ NEW ------------------------------ */
+
+  if (IS_WALKABLE(old_element) && !ACCESS_FROM(old_element, move_direction))
+    return MP_NO_ACTION;	/* field has no opening in this direction */
+
+  if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
+    return MP_NO_ACTION;	/* field has no opening in this direction */
+
+#if USE_FIXED_DONT_RUN_INTO
+  if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
+  {
+    SplashAcid(x, y);
+#if 1
+    Feld[jx][jy] = player->artwork_element;
+#else
+    Feld[jx][jy] = EL_PLAYER_1;
+#endif
+    InitMovingField(jx, jy, MV_DOWN);
+    Store[jx][jy] = EL_ACID;
+    ContinueMoving(jx, jy);
+    BuryPlayer(player);
+
+    return MP_DONT_RUN_INTO;
+  }
+#endif
+
+#if USE_FIXED_DONT_RUN_INTO
+  if (player_can_move && DONT_RUN_INTO(element))
+  {
+    TestIfPlayerRunsIntoBadThing(jx, jy, player->MovDir);
+
+    return MP_DONT_RUN_INTO;
+  }
+#endif
+
+#else	/* ------------------------------ OLD ------------------------------ */
+
 #if 1
 #if USE_FIXED_DONT_RUN_INTO
   if (player_can_move && DONT_RUN_INTO(element))
@@ -11535,6 +11881,7 @@ int DigField(struct PlayerInfo *player,
   if (IS_PASSABLE(old_element) && !ACCESS_FROM(old_element,opposite_direction))
     return MP_NO_ACTION;	/* field has no opening in this direction */
 
+  /* checking here causes player to explode when moving into acid */
 #if 1
 #if USE_FIXED_DONT_RUN_INTO
   if (player_can_move && element == EL_ACID && move_direction == MV_DOWN)
@@ -11551,6 +11898,8 @@ int DigField(struct PlayerInfo *player,
 #endif
 #endif
 
+#endif	/* ------------------------------ END ------------------------------ */
+
 #if 0
 #if USE_FIXED_DONT_RUN_INTO
   if (player_can_move && DONT_RUN_INTO(element))
@@ -11603,10 +11952,17 @@ int DigField(struct PlayerInfo *player,
     return MP_NO_ACTION;
   }
 
+#if USE_PLAYER_GRAVITY
+  if (player->gravity && is_player && !player->is_auto_moving &&
+      canFallDown(player) && move_direction != MV_DOWN &&
+      !canMoveToValidFieldWithGravity(jx, jy, move_direction))
+    return MP_NO_ACTION;	/* player cannot walk here due to gravity */
+#else
   if (game.gravity && is_player && !player->is_auto_moving &&
       canFallDown(player) && move_direction != MV_DOWN &&
       !canMoveToValidFieldWithGravity(jx, jy, move_direction))
     return MP_NO_ACTION;	/* player cannot walk here due to gravity */
+#endif
 
   if (player_can_move &&
       IS_WALKABLE(element) && ACCESS_FROM(element, opposite_direction))
@@ -11670,23 +12026,50 @@ int DigField(struct PlayerInfo *player,
       if (!player->key[EM_GATE_GRAY_ACTIVE_NR(element)])
 	return MP_NO_ACTION;
     }
+    else if (IS_EMC_GATE(element))
+    {
+      if (!player->key[EMC_GATE_NR(element)])
+	return MP_NO_ACTION;
+    }
+    else if (IS_EMC_GATE_GRAY(element))
+    {
+      if (!player->key[EMC_GATE_GRAY_NR(element)])
+	return MP_NO_ACTION;
+    }
+    else if (IS_EMC_GATE_GRAY_ACTIVE(element))
+    {
+      if (!player->key[EMC_GATE_GRAY_ACTIVE_NR(element)])
+	return MP_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)
+#if USE_PLAYER_GRAVITY
+	player->gravity = !player->gravity;
+#else
 	game.gravity = !game.gravity;
+#endif
       else if (element == EL_SP_GRAVITY_ON_PORT_LEFT ||
 	       element == EL_SP_GRAVITY_ON_PORT_RIGHT ||
 	       element == EL_SP_GRAVITY_ON_PORT_UP ||
 	       element == EL_SP_GRAVITY_ON_PORT_DOWN)
+#if USE_PLAYER_GRAVITY
+	player->gravity = TRUE;
+#else
 	game.gravity = TRUE;
+#endif
       else if (element == EL_SP_GRAVITY_OFF_PORT_LEFT ||
 	       element == EL_SP_GRAVITY_OFF_PORT_RIGHT ||
 	       element == EL_SP_GRAVITY_OFF_PORT_UP ||
 	       element == EL_SP_GRAVITY_OFF_PORT_DOWN)
+#if USE_PLAYER_GRAVITY
+	player->gravity = FALSE;
+#else
 	game.gravity = FALSE;
+#endif
     }
 
     /* automatically move to the next field with double speed */
@@ -11906,6 +12289,7 @@ int DigField(struct PlayerInfo *player,
     }
 
     player->is_pushing = TRUE;
+    player->is_active = TRUE;
 
     if (!(IN_LEV_FIELD(nextx, nexty) &&
 	  (IS_FREE(nextx, nexty) ||
@@ -12158,7 +12542,10 @@ int DigField(struct PlayerInfo *player,
   if (is_player)		/* function can also be called by EL_PENGUIN */
   {
     if (Feld[x][y] != element)		/* really digged/collected something */
+    {
       player->is_collecting = !player->is_digging;
+      player->is_active = TRUE;
+    }
   }
 
   return MP_MOVING;
@@ -12227,6 +12614,7 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy)
     return FALSE;
 
   player->is_snapping = TRUE;
+  player->is_active = TRUE;
 
   if (player->MovPos == 0)
   {