X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=a67f9def973370667b5e45266cbfd76c70ecb4fd;hb=ad15815ec04f42779d0717a6d291f93b8e847d39;hp=461518830eff29fd78da568bfbbbabecf7fc90f3;hpb=b17705c5e8242e7769094e538b52c52c3c1687d0;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index 46151883..a67f9def 100644
--- a/src/game.c
+++ b/src/game.c
@@ -169,9 +169,10 @@ static void KillHeroUnlessProtected(int, int);
 static void TestIfPlayerTouchesCustomElement(int, int);
 static void TestIfElementTouchesCustomElement(int, int);
 
+static boolean CheckTriggeredElementSideChange(int, int, int, int, int);
 static boolean CheckTriggeredElementChange(int, int, int, int);
+static boolean CheckElementSideChange(int, int, int, int, int, int);
 static boolean CheckElementChange(int, int, int, int);
-static void ChangeElementNow(int, int, int);
 
 static void PlaySoundLevel(int, int, int);
 static void PlaySoundLevelNearest(int, int, int);
@@ -216,7 +217,7 @@ struct ChangingElementInfo
   void (*post_change_function)(int x, int y);
 };
 
-static struct ChangingElementInfo changing_element_list[] =
+static struct ChangingElementInfo change_delay_list[] =
 {
   {
     EL_NUT_BREAKING,
@@ -242,6 +243,30 @@ static struct ChangingElementInfo changing_element_list[] =
     NULL,
     NULL
   },
+  {
+    EL_EXIT_CLOSING,
+    EL_EXIT_CLOSED,
+    29,
+    NULL,
+    NULL,
+    NULL
+  },
+  {
+    EL_SP_EXIT_OPENING,
+    EL_SP_EXIT_OPEN,
+    29,
+    NULL,
+    NULL,
+    NULL
+  },
+  {
+    EL_SP_EXIT_CLOSING,
+    EL_SP_EXIT_CLOSED,
+    29,
+    NULL,
+    NULL,
+    NULL
+  },
   {
     EL_SWITCHGATE_OPENING,
     EL_SWITCHGATE_OPEN,
@@ -415,19 +440,21 @@ collect_count_list[] =
   { EL_UNDEFINED,		0 },
 };
 
-static boolean changing_element[MAX_NUM_ELEMENTS];
 static unsigned long trigger_events[MAX_NUM_ELEMENTS];
 
-#define IS_AUTO_CHANGING(e)	(changing_element[e])
+#define IS_AUTO_CHANGING(e)	(element_info[e].change_events & \
+				 CH_EVENT_BIT(CE_DELAY))
 #define IS_JUST_CHANGING(x, y)	(ChangeDelay[x][y] != 0)
 #define IS_CHANGING(x, y)	(IS_AUTO_CHANGING(Feld[x][y]) || \
 				 IS_JUST_CHANGING(x, y))
 
+#define CE_PAGE(e, ce)		(element_info[e].event_page[ce])
+
 
 void GetPlayerConfig()
 {
   if (!audio.sound_available)
-    setup.sound = FALSE;
+    setup.sound_simple = FALSE;
 
   if (!audio.loops_available)
     setup.sound_loops = FALSE;
@@ -438,7 +465,7 @@ void GetPlayerConfig()
   if (!video.fullscreen_available)
     setup.fullscreen = FALSE;
 
-  setup.sound_simple = setup.sound;
+  setup.sound = (setup.sound_simple || setup.sound_loops || setup.sound_music);
 
   SetAudioMode(setup.sound);
   InitJoysticks();
@@ -647,10 +674,13 @@ static void InitField(int x, int y, boolean init_game)
       MovDir[x][y] = 1 << RND(4);
       break;
 
+#if 0
     case EL_SP_EMPTY:
       Feld[x][y] = EL_EMPTY;
       break;
+#endif
 
+#if 0
     case EL_EM_KEY_1_FILE:
       Feld[x][y] = EL_EM_KEY_1;
       break;
@@ -663,6 +693,7 @@ static void InitField(int x, int y, boolean init_game)
     case EL_EM_KEY_4_FILE:
       Feld[x][y] = EL_EM_KEY_4;
       break;
+#endif
 
     case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
     case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
@@ -742,7 +773,7 @@ void DrawGameDoorValues()
 
 static void InitGameEngine()
 {
-  int i;
+  int i, j, k;
 
   /* set game engine from tape file when re-playing, else from level file */
   game.engine_version = (tape.playing ? tape.engine_version :
@@ -752,11 +783,11 @@ static void InitGameEngine()
   InitElementPropertiesEngine(game.engine_version);
 
 #if 0
-    printf("level %d: level version == %06d\n", level_nr, level.game_version);
-    printf("          tape version == %06d [%s] [file: %06d]\n",
-	   tape.engine_version, (tape.playing ? "PLAYING" : "RECORDING"),
-	   tape.file_version);
-    printf("       => game.engine_version == %06d\n", game.engine_version);
+  printf("level %d: level version == %06d\n", level_nr, level.game_version);
+  printf("          tape version == %06d [%s] [file: %06d]\n",
+	 tape.engine_version, (tape.playing ? "PLAYING" : "RECORDING"),
+	 tape.file_version);
+  printf("       => game.engine_version == %06d\n", game.engine_version);
 #endif
 
   /* ---------- initialize player's initial move delay --------------------- */
@@ -773,78 +804,82 @@ static void InitGameEngine()
   /* ---------- initialize changing elements ------------------------------- */
 
   /* initialize changing elements information */
-  for (i=0; i<MAX_NUM_ELEMENTS; i++)
+  for (i=0; i < MAX_NUM_ELEMENTS; i++)
   {
-#if 1
-    element_info[i].change.pre_change_function = NULL;
-    element_info[i].change.change_function = NULL;
-    element_info[i].change.post_change_function = NULL;
+    struct ElementInfo *ei = &element_info[i];
+
+    /* this pointer might have been changed in the level editor */
+    ei->change = &ei->change_page[0];
 
     if (!IS_CUSTOM_ELEMENT(i))
     {
-      element_info[i].change.target_element = EL_EMPTY_SPACE;
-      element_info[i].change.delay_fixed = 0;
-      element_info[i].change.delay_random = 0;
-      element_info[i].change.delay_frames = 1;
+      ei->change->target_element = EL_EMPTY_SPACE;
+      ei->change->delay_fixed = 0;
+      ei->change->delay_random = 0;
+      ei->change->delay_frames = 1;
     }
 
-    changing_element[i] = FALSE;
-#else
-    changing_element[i].base_element = EL_UNDEFINED;
-    changing_element[i].next_element = EL_UNDEFINED;
-    changing_element[i].change_delay = -1;
-    changing_element[i].pre_change_function = NULL;
-    changing_element[i].change_function = NULL;
-    changing_element[i].post_change_function = NULL;
-#endif
+    ei->change_events = CE_BITMASK_DEFAULT;
+    for (j=0; j < NUM_CHANGE_EVENTS; j++)
+    {
+      ei->event_page_nr[j] = 0;
+      ei->event_page[j] = &ei->change_page[0];
+    }
   }
 
   /* add changing elements from pre-defined list */
-  for (i=0; changing_element_list[i].element != EL_UNDEFINED; i++)
+  for (i=0; change_delay_list[i].element != EL_UNDEFINED; i++)
   {
-    int element = changing_element_list[i].element;
-    struct ChangingElementInfo *ce = &changing_element_list[i];
-    struct ElementChangeInfo *change = &element_info[element].change;
+    struct ChangingElementInfo *ch_delay = &change_delay_list[i];
+    struct ElementInfo *ei = &element_info[ch_delay->element];
+
+    ei->change->target_element       = ch_delay->target_element;
+    ei->change->delay_fixed          = ch_delay->change_delay;
+
+    ei->change->pre_change_function  = ch_delay->pre_change_function;
+    ei->change->change_function      = ch_delay->change_function;
+    ei->change->post_change_function = ch_delay->post_change_function;
+
+    ei->change_events |= CH_EVENT_BIT(CE_DELAY);
+  }
 
 #if 1
-    change->target_element       = ce->target_element;
-    change->delay_fixed          = ce->change_delay;
-    change->pre_change_function  = ce->pre_change_function;
-    change->change_function      = ce->change_function;
-    change->post_change_function = ce->post_change_function;
+  /* add change events from custom element configuration */
+  for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+  {
+    struct ElementInfo *ei = &element_info[EL_CUSTOM_START + i];
 
-    changing_element[element] = TRUE;
-#else
-    changing_element[element].base_element         = ce->base_element;
-    changing_element[element].next_element         = ce->next_element;
-    changing_element[element].change_delay         = ce->change_delay;
-    changing_element[element].pre_change_function  = ce->pre_change_function;
-    changing_element[element].change_function      = ce->change_function;
-    changing_element[element].post_change_function = ce->post_change_function;
-#endif
+    for (j=0; j < ei->num_change_pages; j++)
+    {
+      if (!ei->change_page[j].can_change)
+	continue;
+
+      for (k=0; k < NUM_CHANGE_EVENTS; k++)
+      {
+	/* only add event page for the first page found with this event */
+	if (ei->change_page[j].events & CH_EVENT_BIT(k) &&
+	    !(ei->change_events & CH_EVENT_BIT(k)))
+	{
+	  ei->change_events |= CH_EVENT_BIT(k);
+	  ei->event_page_nr[k] = j;
+	  ei->event_page[k] = &ei->change_page[j];
+	}
+      }
+    }
   }
 
-  /* add changing elements from custom element configuration */
+#else
+
+  /* add change events from custom element configuration */
   for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
   {
     int element = EL_CUSTOM_START + i;
-#if 0
-    struct ElementChangeInfo *change = &element_info[element].change;
-#endif
 
     /* only add custom elements that change after fixed/random frame delay */
-    if (!CAN_CHANGE(element) || !HAS_CHANGE_EVENT(element, CE_DELAY))
-      continue;
-
-#if 1
-    changing_element[element] = TRUE;
-#else
-    changing_element[element].base_element = element;
-    changing_element[element].next_element = change->target_element;
-    changing_element[element].change_delay = (change->delay_fixed *
-					      change->delay_frames);
-#endif
+    if (CAN_CHANGE(element) && HAS_CHANGE_EVENT(element, CE_DELAY))
+      element_info[element].change_events |= CH_EVENT_BIT(CE_DELAY);
   }
+#endif
 
   /* ---------- initialize trigger events ---------------------------------- */
 
@@ -852,11 +887,32 @@ static void InitGameEngine()
   for (i=0; i<MAX_NUM_ELEMENTS; i++)
     trigger_events[i] = EP_BITMASK_DEFAULT;
 
+#if 1
+  /* add trigger events from element change event properties */
+  for (i=0; i<MAX_NUM_ELEMENTS; i++)
+  {
+    struct ElementInfo *ei = &element_info[i];
+
+    for (j=0; j < ei->num_change_pages; j++)
+    {
+      if (!ei->change_page->can_change)
+	continue;
+
+      if (ei->change_page[j].events & CH_EVENT_BIT(CE_BY_OTHER_ACTION))
+      {
+	int trigger_element = ei->change_page[j].trigger_element;
+
+	trigger_events[trigger_element] |= ei->change_page[j].events;
+      }
+    }
+  }
+#else
   /* add trigger events from element change event properties */
   for (i=0; i<MAX_NUM_ELEMENTS; i++)
-    if (HAS_CHANGE_EVENT(i, CE_BY_OTHER))
-      trigger_events[element_info[i].change.trigger_element] |=
-	element_info[i].change.events;
+    if (HAS_CHANGE_EVENT(i, CE_BY_OTHER_ACTION))
+      trigger_events[element_info[i].change->trigger_element] |=
+	element_info[i].change->events;
+#endif
 
   /* ---------- initialize push delay -------------------------------------- */
 
@@ -976,6 +1032,9 @@ void InitGame()
     player->Frame = 0;
     player->StepFrame = 0;
 
+    player->switch_x = -1;
+    player->switch_y = -1;
+
     player->use_murphy_graphic = FALSE;
     player->use_disk_red_graphic = FALSE;
 
@@ -988,6 +1047,8 @@ void InitGame()
     player->is_digging = FALSE;
     player->is_collecting = FALSE;
 
+    player->show_envelope = 0;
+
     player->move_delay       = game.initial_move_delay;
     player->move_delay_value = game.initial_move_delay_value;
 
@@ -1041,8 +1102,11 @@ void InitGame()
   game.timegate_time_left = 0;
   game.switchgate_pos = 0;
   game.balloon_dir = MV_NO_MOVING;
+  game.gravity = level.initial_gravity;
   game.explosions_delayed = TRUE;
 
+  game.envelope_active = FALSE;
+
   for (i=0; i<4; i++)
   {
     game.belt_dir[i] = MV_NO_MOVING;
@@ -1064,7 +1128,10 @@ void InitGame()
       JustStopped[x][y] = 0;
       Stop[x][y] = FALSE;
       Pushed[x][y] = FALSE;
-      Changing[x][y] = FALSE;
+
+      Changed[x][y] = CE_BITMASK_DEFAULT;
+      ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
+
       ExplodePhase[x][y] = 0;
       ExplodeField[x][y] = EX_NO_EXPLOSION;
 
@@ -1222,46 +1289,65 @@ void InitGame()
   {
     int start_x = 0, start_y = 0;
     int found_rating = 0;
+    int found_element = EL_UNDEFINED;
 
-    for(y=0; y < lev_fieldy; y++)
+    for(y=0; y < lev_fieldy; y++) for(x=0; x < lev_fieldx; x++)
     {
-      for(x=0; x < lev_fieldx; x++)
-      {
-	int element = Feld[x][y];
+      int element = Feld[x][y];
+      int content;
+      int xx, yy;
+      boolean is_player;
 
-	if (IS_CUSTOM_ELEMENT(element))
+      if (!IS_CUSTOM_ELEMENT(element))
+	continue;
+
+      if (CAN_CHANGE(element))
+      {
+	for (i=0; i < element_info[element].num_change_pages; i++)
 	{
-	  int xx, yy;
+	  content = element_info[element].change_page[i].target_element;
+	  is_player = ELEM_IS_PLAYER(content);
 
-	  for(yy=0; yy < 3; yy++)
+	  if (is_player && (found_rating < 3 || element < found_element))
 	  {
-	    for(xx=0; xx < 3; xx++)
-	    {
-	      int content;
-	      boolean is_player;
+	    start_x = x;
+	    start_y = y;
+
+	    found_rating = 3;
+	    found_element = element;
+	  }
+	}
+      }
 
-	      content = element_info[element].content[xx][yy];
-	      is_player = (ELEM_IS_PLAYER(content) || content == EL_SP_MURPHY);
+      for(yy=0; yy < 3; yy++) for(xx=0; xx < 3; xx++)
+      {
+	content = element_info[element].content[xx][yy];
+	is_player = ELEM_IS_PLAYER(content);
 
-	      if (is_player && found_rating < 2)
-	      {
-		start_x = x + xx - 1;
-		start_y = y + yy - 1;
+	if (is_player && (found_rating < 2 || element < found_element))
+	{
+	  start_x = x + xx - 1;
+	  start_y = y + yy - 1;
 
-		found_rating = 2;
-	      }
+	  found_rating = 2;
+	  found_element = element;
+	}
 
-	      content = element_info[element].change.content[xx][yy];
-	      is_player = (ELEM_IS_PLAYER(content) || content == EL_SP_MURPHY);
+	if (!CAN_CHANGE(element))
+	  continue;
 
-	      if (is_player && found_rating < 1)
-	      {
-		start_x = x + xx - 1;
-		start_y = y + yy - 1;
+	for (i=0; i < element_info[element].num_change_pages; i++)
+	{
+	  content = element_info[element].change_page[i].content[xx][yy];
+	  is_player = ELEM_IS_PLAYER(content);
 
-		found_rating = 1;
-	      }
-	    }
+	  if (is_player && (found_rating < 1 || element < found_element))
+	  {
+	    start_x = x + xx - 1;
+	    start_y = y + yy - 1;
+
+	    found_rating = 1;
+	    found_element = element;
 	  }
 	}
       }
@@ -1536,8 +1622,13 @@ void GameWon()
   if (local_player->MovPos)
     return;
 
+#if 1
+  if (tape.auto_play)		/* tape might already be stopped here */
+    tape.auto_play_level_solved = TRUE;
+#else
   if (tape.playing && tape.auto_play)
     tape.auto_play_level_solved = TRUE;
+#endif
 
   local_player->LevelSolved = FALSE;
 
@@ -1596,6 +1687,18 @@ void GameWon()
       StopSound(SND_GAME_LEVELTIME_BONUS);
   }
 
+  /* close exit door after last player */
+  if ((Feld[ExitX][ExitY] == EL_EXIT_OPEN ||
+       Feld[ExitX][ExitY] == EL_SP_EXIT_OPEN) && AllPlayersGone)
+  {
+    int element = Feld[ExitX][ExitY];
+
+    Feld[ExitX][ExitY] = (element == EL_EXIT_OPEN ? EL_EXIT_CLOSING :
+			  EL_SP_EXIT_CLOSING);
+
+    PlaySoundLevelElementAction(ExitX, ExitY, element, ACTION_CLOSING);
+  }
+
   /* Hero disappears */
   DrawLevelField(ExitX, ExitY);
   BackToFront();
@@ -1960,22 +2063,50 @@ void RelocatePlayer(int x, int y, int element)
     }
 
     RemoveField(player->jx, player->jy);
+    DrawLevelField(player->jx, player->jy);
   }
 
   InitPlayerField(x, y, element, TRUE);
 
   if (player == local_player)
   {
-    scroll_x = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
-		local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
-		local_player->jx - MIDPOSX);
+    int scroll_xx = -999, scroll_yy = -999;
 
-    scroll_y = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
-		local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
-		local_player->jy - MIDPOSY);
-  }
+    while (scroll_xx != scroll_x || scroll_yy != scroll_y)
+    {
+      int dx = 0, dy = 0;
+      int fx = FX, fy = FY;
 
-  DrawLevel();
+      scroll_xx = (local_player->jx < SBX_Left  + MIDPOSX ? SBX_Left :
+		   local_player->jx > SBX_Right + MIDPOSX ? SBX_Right :
+		   local_player->jx - MIDPOSX);
+
+      scroll_yy = (local_player->jy < SBY_Upper + MIDPOSY ? SBY_Upper :
+		   local_player->jy > SBY_Lower + MIDPOSY ? SBY_Lower :
+		   local_player->jy - MIDPOSY);
+
+      dx = (scroll_xx < scroll_x ? +1 : scroll_xx > scroll_x ? -1 : 0);
+      dy = (scroll_yy < scroll_y ? +1 : scroll_yy > scroll_y ? -1 : 0);
+
+      scroll_x -= dx;
+      scroll_y -= dy;
+
+      fx += dx * TILEX / 2;
+      fy += dy * TILEY / 2;
+
+      ScrollLevel(dx, dy);
+      DrawAllPlayers();
+
+      /* scroll in to steps of half tile size to make things smoother */
+      BlitBitmap(drawto_field, window, fx, fy, SXSIZE, SYSIZE, SX, SY);
+      FlushDisplay();
+      Delay(GAME_FRAME_DELAY);
+
+      /* scroll second step to align at full tile size */
+      BackToFront();
+      Delay(GAME_FRAME_DELAY);
+    }
+  }
 }
 
 void Explode(int ex, int ey, int phase, int mode)
@@ -2207,6 +2338,24 @@ void Explode(int ex, int ey, int phase, int mode)
 
   ExplodePhase[x][y] = (phase < last_phase ? phase + 1 : 0);
 
+#ifdef DEBUG
+
+  /* activate this even in non-DEBUG version until cause for crash in
+     getGraphicAnimationFrame() (see below) is found and eliminated */
+#endif
+#if 1
+
+  if (GfxElement[x][y] == EL_UNDEFINED)
+  {
+    printf("\n\n");
+    printf("Explode(): x = %d, y = %d: GfxElement == EL_UNDEFINED\n", x, y);
+    printf("Explode(): This should never happen!\n");
+    printf("\n\n");
+
+    GfxElement[x][y] = EL_EMPTY;
+  }
+#endif
+
   if (phase == first_phase_after_start)
   {
     int element = Store2[x][y];
@@ -2252,7 +2401,9 @@ void Explode(int ex, int ey, int phase, int mode)
       InitMovDir(x, y);
     DrawLevelField(x, y);
 
-    if (CAN_BE_CRUMBLED(element))
+    TestIfElementTouchesCustomElement(x, y);
+
+    if (GFX_CRUMBLED(element))
       DrawLevelFieldCrumbledSandNeighbours(x, y);
 
     if (IS_PLAYER(x, y) && !PLAYERINFO(x,y)->present)
@@ -2352,7 +2503,11 @@ void Bang(int x, int y)
   int element = Feld[x][y];
 #endif
 
+#if 1
+  if (IS_PLAYER(x, y) && !PLAYER_PROTECTED(x, y))
+#else
   if (IS_PLAYER(x, y))
+#endif
   {
     struct PlayerInfo *player = PLAYERINFO(x, y);
 
@@ -2824,24 +2979,12 @@ void Impact(int x, int y)
     PlaySoundLevel(x, y, SND_PEARL_BREAKING);
     return;
   }
-#if 1
   else if (impact && CheckElementChange(x, y, element, CE_IMPACT))
   {
     PlaySoundLevelElementAction(x, y, element, ACTION_IMPACT);
 
     return;
   }
-#else
-  else if (impact && CAN_CHANGE(element) &&
-	   HAS_CHANGE_EVENT(element, CE_IMPACT))
-  {
-    PlaySoundLevelElementAction(x, y, element, ACTION_IMPACT);
-
-    ChangeElementNow(x, y, element);
-
-    return;
-  }
-#endif
 
   if (impact && element == EL_AMOEBA_DROP)
   {
@@ -2973,17 +3116,15 @@ void Impact(int x, int y)
 	{
 	  ToggleLightSwitch(x, y + 1);
 	}
-#if 1
 	else
 	{
 	  CheckElementChange(x, y + 1, smashed, CE_SMASHED);
+
+	  CheckTriggeredElementSideChange(x, y + 1, smashed, CH_SIDE_TOP,
+					  CE_OTHER_IS_SWITCHING);
+	  CheckElementSideChange(x, y + 1, smashed, CH_SIDE_TOP,
+				 CE_SWITCHED, -1);
 	}
-#else
-	else if (CAN_CHANGE(smashed) && HAS_CHANGE_EVENT(smashed, CE_SMASHED))
-	{
-	  ChangeElementNow(x, y + 1, smashed);
-	}
-#endif
       }
       else
       {
@@ -3541,6 +3682,13 @@ void TurnRound(int x, int y)
       MovDir[x][y] = old_move_dir;
     }
   }
+  else if (element_info[element].move_pattern == MV_WHEN_PUSHED)
+  {
+    if (!IN_LEV_FIELD_AND_IS_FREE(move_x, move_y))
+      MovDir[x][y] = MV_NO_MOVING;
+
+    MovDelay[x][y] = 0;
+  }
 }
 
 static boolean JustBeingPushed(int x, int y)
@@ -3579,7 +3727,8 @@ void StartMoving(int x, int y)
 
   if (CAN_FALL(element) && y < lev_fieldy - 1)
   {
-    if ((x>0 && IS_PLAYER(x-1, y)) || (x<lev_fieldx-1 && IS_PLAYER(x+1, y)))
+    if ((x > 0 && IS_PLAYER(x - 1, y)) ||
+	(x < lev_fieldx-1 && IS_PLAYER(x + 1, y)))
       if (JustBeingPushed(x, y))
 	return;
 
@@ -3721,6 +3870,15 @@ void StartMoving(int x, int y)
 #endif
     }
 #if 1
+
+#if 0
+    /* TEST: bug where player gets not killed by falling rock ... */
+    else if (CAN_SMASH(element) &&
+	     (Feld[x][y + 1] == EL_BLOCKED ||
+	      IS_PLAYER(x, y + 1)) &&
+	     JustStopped[x][y] && !Pushed[x][y + 1])
+
+#else
 #if 1
     else if (game.engine_version < RELEASE_IDENT(2,2,0,7) &&
 	     CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
@@ -3729,6 +3887,8 @@ void StartMoving(int x, int y)
     else if (CAN_SMASH(element) && Feld[x][y + 1] == EL_BLOCKED &&
 	     JustStopped[x][y])
 #endif
+#endif
+
     {
       /* calling "Impact()" here is not only completely unneccessary
 	 (because it already gets called from "ContinueMoving()" in
@@ -3839,11 +3999,16 @@ void StartMoving(int x, int y)
   {
     int newx, newy;
 
+#if 1
+    if (IS_PUSHABLE(element) && JustBeingPushed(x, y))
+      return;
+#else
     if ((element == EL_SATELLITE ||
 	 element == EL_BALLOON ||
 	 element == EL_SPRING)
 	&& JustBeingPushed(x, y))
       return;
+#endif
 
 #if 0
 #if 0
@@ -3980,7 +4145,8 @@ void StartMoving(int x, int y)
 
     Moving2Blocked(x, y, &newx, &newy);	/* get next screen position */
 
-    if (DONT_COLLIDE_WITH(element) && IS_PLAYER(newx, newy) &&
+    if (DONT_COLLIDE_WITH(element) &&
+	IN_LEV_FIELD(newx, newy) && IS_PLAYER(newx, newy) &&
 	!PLAYER_PROTECTED(newx, newy))
     {
 #if 1
@@ -4091,6 +4257,11 @@ void StartMoving(int x, int y)
 	    element1 != EL_DRAGON && element2 != EL_DRAGON &&
 	    element1 != EL_FLAMES && element2 != EL_FLAMES)
 	{
+#if 1
+	  ResetGfxAnimation(x, y);
+	  GfxAction[x][y] = ACTION_ATTACKING;
+#endif
+
 	  if (IS_PLAYER(x, y))
 	    DrawPlayerField(x, y);
 	  else
@@ -4104,6 +4275,7 @@ void StartMoving(int x, int y)
 	    Feld[newx1][newy1] = EL_FLAMES;
 	  if (IN_LEV_FIELD(newx2, newy2) && Feld[newx2][newy2] == EL_EMPTY)
 	    Feld[newx2][newy2] = EL_FLAMES;
+
 	  return;
 	}
       }
@@ -4314,6 +4486,12 @@ void ContinueMoving(int x, int y)
 
     /* copy element change control values to new field */
     ChangeDelay[newx][newy] = ChangeDelay[x][y];
+    Changed[newx][newy] = Changed[x][y];
+    ChangeEvent[newx][newy] = ChangeEvent[x][y];
+
+    ChangeDelay[x][y] = 0;
+    Changed[x][y] = CE_BITMASK_DEFAULT;
+    ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
 
     /* copy animation control values to new field */
     GfxFrame[newx][newy]  = GfxFrame[x][y];
@@ -4352,6 +4530,12 @@ void ContinueMoving(int x, int y)
 
     Stop[newx][newy] = TRUE;	/* ignore this element until the next frame */
 
+    /* prevent pushed element from moving on in pushed direction */
+    if (pushed && CAN_MOVE(element) &&
+	element_info[element].move_pattern & MV_ANY_DIRECTION &&
+	!(element_info[element].move_pattern & MovDir[newx][newy]))
+      TurnRound(newx, newy);
+
     if (!pushed)	/* special case: moving object pushed by player */
       JustStopped[newx][newy] = 3;
 
@@ -4369,7 +4553,11 @@ void ContinueMoving(int x, int y)
       Impact(x, newy);
 
     if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
-      CheckElementChange(newx, newy, element, CE_COLLISION);
+      CheckElementSideChange(newx, newy, element, direction, CE_COLLISION, -1);
+
+#if 1
+    TestIfElementTouchesCustomElement(x, y);		/* for empty space */
+#endif
 
     TestIfPlayerTouchesCustomElement(newx, newy);
     TestIfElementTouchesCustomElement(newx, newy);
@@ -4912,6 +5100,9 @@ void CheckExit(int x, int y)
     return;
   }
 
+  if (AllPlayersGone)	/* do not re-open exit door closed after last player */
+    return;
+
   Feld[x][y] = EL_EXIT_OPENING;
 
   PlaySoundLevelNearest(x, y, SND_CLASS_EXIT_OPENING);
@@ -4930,7 +5121,10 @@ void CheckExitSP(int x, int y)
     return;
   }
 
-  Feld[x][y] = EL_SP_EXIT_OPEN;
+  if (AllPlayersGone)	/* do not re-open exit door closed after last player */
+    return;
+
+  Feld[x][y] = EL_SP_EXIT_OPENING;
 
   PlaySoundLevelNearest(x, y, SND_CLASS_SP_EXIT_OPENING);
 }
@@ -5269,17 +5463,20 @@ static void ChangeActiveTrap(int x, int y)
 
 static void ChangeElementNowExt(int x, int y, int target_element)
 {
-#if 0	/* !!! let the player exacpe from a suddenly unaccessible element */
-  if (IS_PLAYER(x, y) && !IS_ACCESSIBLE(target_element))
+  /* 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) &&
+      IS_ACCESSIBLE(Feld[x][y]) && !IS_ACCESSIBLE(target_element))
   {
     Bang(x, y);
     return;
   }
-#endif
 
   RemoveField(x, y);
   Feld[x][y] = target_element;
 
+  Changed[x][y] |= ChangeEvent[x][y];	/* ignore same changes in this frame */
+
   ResetGfxAnimation(x, y);
   ResetRandomAnimationValue(x, y);
 
@@ -5289,29 +5486,43 @@ static void ChangeElementNowExt(int x, int y, int target_element)
 
   DrawLevelField(x, y);
 
-  if (CAN_BE_CRUMBLED(Feld[x][y]))
+  if (GFX_CRUMBLED(Feld[x][y]))
     DrawLevelFieldCrumbledSandNeighbours(x, y);
 
   TestIfBadThingTouchesHero(x, y);
   TestIfPlayerTouchesCustomElement(x, y);
   TestIfElementTouchesCustomElement(x, y);
+
+  if (ELEM_IS_PLAYER(target_element))
+    RelocatePlayer(x, y, target_element);
 }
 
-static void ChangeElementNow(int x, int y, int element)
+static boolean ChangeElementNow(int x, int y, int element, int page)
 {
-  struct ElementChangeInfo *change = &element_info[element].change;
+  struct ElementChangeInfo *change = &element_info[element].change_page[page];
 
-  /* prevent CheckTriggeredElementChange() from looping */
-  Changing[x][y] = TRUE;
+  /* always use default change event to prevent running into a loop */
+  if (ChangeEvent[x][y] == CE_BITMASK_DEFAULT)
+    ChangeEvent[x][y] = CH_EVENT_BIT(CE_DELAY);
 
-  CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_IS_CHANGING);
+  /* do not change already changed elements with same change event */
+#if 0
+  if (Changed[x][y] & ChangeEvent[x][y])
+    return FALSE;
+#else
+  if (Changed[x][y])
+    return FALSE;
+#endif
+
+  Changed[x][y] |= ChangeEvent[x][y];	/* ignore same changes in this frame */
 
-  Changing[x][y] = FALSE;
+  CheckTriggeredElementChange(x, y, Feld[x][y], CE_OTHER_IS_CHANGING);
 
   if (change->explode)
   {
     Bang(x, y);
-    return;
+
+    return TRUE;
   }
 
   if (change->use_content)
@@ -5369,7 +5580,7 @@ static void ChangeElementNow(int x, int y, int element)
 
       if (change->only_complete && change->use_random_change &&
 	  RND(100) < change->random)
-	return;
+	return FALSE;
 
       for (yy = 0; yy < 3; yy++) for(xx = 0; xx < 3 ; xx++)
       {
@@ -5382,13 +5593,15 @@ static void ChangeElementNow(int x, int y, int element)
 	  if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
 	    RemoveMovingField(ex, ey);
 
+	  ChangeEvent[ex][ey] = ChangeEvent[x][y];
+
 	  ChangeElementNowExt(ex, ey, change->content[xx][yy]);
 
 	  something_has_changed = TRUE;
 
-	  /* for symmetry reasons, stop newly created border elements */
+	  /* for symmetry reasons, freeze newly created border elements */
 	  if (ex != x || ey != y)
-	    Stop[ex][ey] = TRUE;
+	    Stop[ex][ey] = TRUE;	/* no more moving in this frame */
 	}
       }
 
@@ -5402,44 +5615,38 @@ static void ChangeElementNow(int x, int y, int element)
 
     PlaySoundLevelElementAction(x, y, element, ACTION_CHANGING);
   }
+
+  return TRUE;
 }
 
-static void ChangeElement(int x, int y)
+static void ChangeElement(int x, int y, int page)
 {
-#if 1
   int element = MovingOrBlocked2Element(x, y);
-#else
-  int element = Feld[x][y];
+  struct ElementChangeInfo *change = &element_info[element].change_page[page];
+
+#if 0
+#ifdef DEBUG
+  if (!CAN_CHANGE(element))
+  {
+    printf("\n\n");
+    printf("ChangeElement(): %d,%d: element = %d ('%s')\n",
+	   x, y, element, element_info[element].token_name);
+    printf("ChangeElement(): This should never happen!\n");
+    printf("\n\n");
+  }
+#endif
 #endif
-  struct ElementChangeInfo *change = &element_info[element].change;
 
   if (ChangeDelay[x][y] == 0)		/* initialize element change */
   {
-#if 1
     ChangeDelay[x][y] = (    change->delay_fixed  * change->delay_frames +
 			 RND(change->delay_random * change->delay_frames)) + 1;
-#else
-    ChangeDelay[x][y] = changing_element[element].change_delay + 1;
-
-    if (IS_CUSTOM_ELEMENT(element) && HAS_CHANGE_EVENT(element, CE_DELAY))
-    {
-      int max_random_delay = element_info[element].change.delay_random;
-      int delay_frames = element_info[element].change.delay_frames;
-
-      ChangeDelay[x][y] += RND(max_random_delay * delay_frames);
-    }
-#endif
 
     ResetGfxAnimation(x, y);
     ResetRandomAnimationValue(x, y);
 
-#if 1
     if (change->pre_change_function)
       change->pre_change_function(x, y);
-#else
-    if (changing_element[element].pre_change_function)
-      changing_element[element].pre_change_function(x, y);
-#endif
   }
 
   ChangeDelay[x][y]--;
@@ -5451,20 +5658,11 @@ static void ChangeElement(int x, int y)
     if (IS_ANIMATED(graphic))
       DrawLevelGraphicAnimationIfNeeded(x, y, graphic);
 
-#if 1
     if (change->change_function)
       change->change_function(x, y);
-#else
-    if (changing_element[element].change_function)
-      changing_element[element].change_function(x, y);
-#endif
   }
   else					/* finish element change */
   {
-#if 0
-    int next_element = changing_element[element].next_element;
-#endif
-
     if (IS_MOVING(x, y))		/* never change a running system ;-) */
     {
       ChangeDelay[x][y] = 1;		/* try change after next move step */
@@ -5472,70 +5670,107 @@ static void ChangeElement(int x, int y)
       return;
     }
 
-#if 1
-    ChangeElementNow(x, y, element);
-
-    if (change->post_change_function)
-      change->post_change_function(x, y);
-#else
-    if (next_element != EL_UNDEFINED)
-      ChangeElementNow(x, y, next_element);
-    else
-      ChangeElementNow(x, y, element_info[element].change.target_element);
-
-    if (changing_element[element].post_change_function)
-      changing_element[element].post_change_function(x, y);
-#endif
+    if (ChangeElementNow(x, y, element, page))
+    {
+      if (change->post_change_function)
+	change->post_change_function(x, y);
+    }
   }
 }
 
-static boolean CheckTriggeredElementChange(int lx, int ly, int trigger_element,
-					   int trigger_event)
+static boolean CheckTriggeredElementSideChange(int lx, int ly,
+					       int trigger_element,
+					       int trigger_side,
+					       int trigger_event)
 {
-  int i, x, y;
+  int i, j, x, y;
 
   if (!(trigger_events[trigger_element] & CH_EVENT_BIT(trigger_event)))
     return FALSE;
 
-  for (i=0; i<MAX_NUM_ELEMENTS; i++)
+  for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
   {
-    if (!CAN_CHANGE(i) || !HAS_CHANGE_EVENT(i, trigger_event) ||
-	element_info[i].change.trigger_element != trigger_element)
+    int element = EL_CUSTOM_START + i;
+
+    boolean change_element = FALSE;
+    int page = 0;
+
+    if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
       continue;
 
-    for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
+    for (j=0; j < element_info[element].num_change_pages; j++)
     {
-      if (x == lx && y == ly)	/* do not change trigger element itself */
-	continue;
-
-      if (Changing[x][y])	/* do not change just changing elements */
-	continue;
+      struct ElementChangeInfo *change = &element_info[element].change_page[j];
 
-      if (Feld[x][y] == i)
+      if (change->sides & trigger_side &&
+	  change->trigger_element == trigger_element)
       {
-	ChangeDelay[x][y] = 1;
-	ChangeElement(x, y);
+	change_element = TRUE;
+	page = j;
+
+	break;
       }
     }
-  }
 
-  return TRUE;
-}
+    if (!change_element)
+      continue;
 
-static boolean CheckElementChange(int x, int y, int element, int trigger_event)
+    for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
+    {
+#if 0
+      if (x == lx && y == ly)	/* do not change trigger element itself */
+	continue;
+#endif
+
+      if (Feld[x][y] == element)
+      {
+	ChangeDelay[x][y] = 1;
+	ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
+	ChangeElement(x, y, page);
+      }
+    }
+  }
+
+  return TRUE;
+}
+
+static boolean CheckTriggeredElementChange(int lx, int ly, int trigger_element,
+					   int trigger_event)
 {
-  if (!CAN_CHANGE(element) || !HAS_CHANGE_EVENT(element, trigger_event))
+  return CheckTriggeredElementSideChange(lx, ly, trigger_element, CH_SIDE_ANY,
+					 trigger_event);
+}
+
+static boolean CheckElementSideChange(int x, int y, int element, int side,
+				      int trigger_event, int page)
+{
+  if (!CAN_CHANGE(element) || !HAS_ANY_CHANGE_EVENT(element, trigger_event))
     return FALSE;
 
   if (Feld[x][y] == EL_BLOCKED)
+  {
     Blocked2Moving(x, y, &x, &y);
+    element = Feld[x][y];
+  }
+
+  if (page < 0)
+    page = element_info[element].event_page_nr[trigger_event];
+
+  if (!(element_info[element].change_page[page].sides & side))
+    return FALSE;
 
   ChangeDelay[x][y] = 1;
-  ChangeElement(x, y);
+  ChangeEvent[x][y] = CH_EVENT_BIT(trigger_event);
+  ChangeElement(x, y, page);
 
   return TRUE;
 }
 
+static boolean CheckElementChange(int x, int y, int element, int trigger_event)
+{
+  return CheckElementSideChange(x, y, element, CH_SIDE_ANY, trigger_event, -1);
+}
+
 static void PlayerActions(struct PlayerInfo *player, byte player_action)
 {
   static byte stored_player_action[MAX_PLAYERS];
@@ -5588,13 +5823,7 @@ static void PlayerActions(struct PlayerInfo *player, byte player_action)
     CheckGravityMovement(player);
 
     if (player->MovPos == 0)
-    {
-#if 0
-      printf("Trying... Player frame reset\n");
-#endif
-
       InitPlayerGfxAnimation(player, ACTION_DEFAULT, player->MovDir);
-    }
 
     if (player->MovPos == 0)	/* needed for tape.playing */
       player->is_moving = FALSE;
@@ -5729,6 +5958,9 @@ void GameActions()
 
   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
   {
+    Changed[x][y] = CE_BITMASK_DEFAULT;
+    ChangeEvent[x][y] = CE_BITMASK_DEFAULT;
+
     Stop[x][y] = FALSE;
     if (JustStopped[x][y] > 0)
       JustStopped[x][y]--;
@@ -5737,7 +5969,7 @@ void GameActions()
 
 #if 1
     /* reset finished pushing action (not done in ContinueMoving() to allow
-       continous pushing animation for elements without push delay) */
+       continous pushing animation for elements with zero push delay) */
     if (GfxAction[x][y] == ACTION_PUSHING && !IS_MOVING(x, y))
     {
       ResetGfxAnimation(x, y);
@@ -5805,7 +6037,7 @@ void GameActions()
     /* this may take place after moving, so 'element' may have changed */
     if (IS_CHANGING(x, y))
     {
-      ChangeElement(x, y);
+      ChangeElement(x, y, element_info[element].event_page_nr[CE_DELAY]);
       element = Feld[x][y];
       graphic = el_act_dir2img(element, GfxAction[x][y], MovDir[x][y]);
     }
@@ -6056,7 +6288,7 @@ void GameActions()
     }
   }
 
-  if (TimeFrames >= (1000 / GameFrameDelay))
+  if (TimeFrames >= FRAMES_PER_SECOND)
   {
     TimeFrames = 0;
     TimePlayed++;
@@ -6141,6 +6373,15 @@ void GameActions()
       stored_player[i].StepFrame += move_frames;
   }
 #endif
+
+#if 1
+  if (local_player->show_envelope != 0 && local_player->MovPos == 0)
+  {
+    ShowEnvelope(local_player->show_envelope - EL_ENVELOPE_1);
+
+    local_player->show_envelope = 0;
+  }
+#endif
 }
 
 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
@@ -6188,24 +6429,24 @@ void ScrollLevel(int dx, int dy)
   int x, y;
 
   BlitBitmap(drawto_field, drawto_field,
-	     FX + TILEX*(dx == -1) - softscroll_offset,
-	     FY + TILEY*(dy == -1) - softscroll_offset,
-	     SXSIZE - TILEX*(dx!=0) + 2*softscroll_offset,
-	     SYSIZE - TILEY*(dy!=0) + 2*softscroll_offset,
-	     FX + TILEX*(dx == 1) - softscroll_offset,
-	     FY + TILEY*(dy == 1) - softscroll_offset);
+	     FX + TILEX * (dx == -1) - softscroll_offset,
+	     FY + TILEY * (dy == -1) - softscroll_offset,
+	     SXSIZE - TILEX * (dx!=0) + 2 * softscroll_offset,
+	     SYSIZE - TILEY * (dy!=0) + 2 * softscroll_offset,
+	     FX + TILEX * (dx == 1) - softscroll_offset,
+	     FY + TILEY * (dy == 1) - softscroll_offset);
 
   if (dx)
   {
     x = (dx == 1 ? BX1 : BX2);
-    for (y=BY1; y<=BY2; y++)
+    for (y=BY1; y <= BY2; y++)
       DrawScreenField(x, y);
   }
 
   if (dy)
   {
     y = (dy == 1 ? BY1 : BY2);
-    for (x=BX1; x<=BX2; x++)
+    for (x=BX1; x <= BX2; x++)
       DrawScreenField(x, y);
   }
 
@@ -6214,7 +6455,7 @@ void ScrollLevel(int dx, int dy)
 
 static void CheckGravityMovement(struct PlayerInfo *player)
 {
-  if (level.gravity && !player->programmed_action)
+  if (game.gravity && !player->programmed_action)
   {
     int move_dir_vertical = player->action & (MV_UP | MV_DOWN);
     int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT);
@@ -6251,8 +6492,22 @@ static void CheckGravityMovement(struct PlayerInfo *player)
 boolean MoveFigureOneStep(struct PlayerInfo *player,
 			  int dx, int dy, int real_dx, int real_dy)
 {
+  static int change_sides[4][2] =
+  {
+    /* enter side        leave side */
+    { CH_SIDE_RIGHT,	CH_SIDE_LEFT	},	/* moving left  */
+    { CH_SIDE_LEFT,	CH_SIDE_RIGHT	},	/* moving right */
+    { CH_SIDE_BOTTOM,	CH_SIDE_TOP	},	/* moving up    */
+    { CH_SIDE_TOP,	CH_SIDE_BOTTOM	}	/* moving down  */
+  };
+  int move_direction = (dx == -1 ? MV_LEFT :
+			dx == +1 ? MV_RIGHT :
+			dy == -1 ? MV_UP :
+			dy == +1 ? MV_DOWN : MV_NO_MOVING);
+  int enter_side = change_sides[MV_DIR_BIT(move_direction)][0];
+  int leave_side = change_sides[MV_DIR_BIT(move_direction)][1];
   int jx = player->jx, jy = player->jy;
-  int new_jx = jx+dx, new_jy = jy+dy;
+  int new_jx = jx + dx, new_jy = jy + dy;
   int element;
   int can_move;
 
@@ -6297,18 +6552,40 @@ boolean MoveFigureOneStep(struct PlayerInfo *player,
   if (can_move != MF_MOVING)
     return can_move;
 
+  /* check if DigField() has caused relocation of the player */
+  if (player->jx != jx || player->jy != jy)
+    return MF_NO_ACTION;
+
   StorePlayer[jx][jy] = 0;
   player->last_jx = jx;
   player->last_jy = jy;
-  jx = player->jx = new_jx;
-  jy = player->jy = new_jy;
-  StorePlayer[jx][jy] = player->element_nr;
+  player->jx = new_jx;
+  player->jy = new_jy;
+  StorePlayer[new_jx][new_jy] = player->element_nr;
 
   player->MovPos =
     (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
 
   ScrollFigure(player, SCROLL_INIT);
 
+#if 1
+  if (IS_CUSTOM_ELEMENT(Feld[jx][jy]))
+  {
+    CheckTriggeredElementSideChange(jx, jy, Feld[jx][jy], leave_side,
+				    CE_OTHER_GETS_LEFT);
+    CheckElementSideChange(jx, jy, Feld[jx][jy], leave_side,
+			   CE_LEFT_BY_PLAYER, -1);
+  }
+
+  if (IS_CUSTOM_ELEMENT(Feld[new_jx][new_jy]))
+  {
+    CheckTriggeredElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy],
+				    enter_side, CE_OTHER_GETS_ENTERED);
+    CheckElementSideChange(new_jx, new_jy, Feld[new_jx][new_jy], enter_side,
+			   CE_ENTERED_BY_PLAYER, -1);
+  }
+#endif
+
   return MF_MOVING;
 }
 
@@ -6466,6 +6743,13 @@ boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
 
     player->last_move_dir = player->MovDir;
     player->is_moving = TRUE;
+#if 1
+    player->snapped = FALSE;
+#endif
+
+#if 1
+    player->Switching = FALSE;
+#endif
   }
   else
   {
@@ -6525,7 +6809,7 @@ void ScrollFigure(struct PlayerInfo *player, int mode)
   DrawPlayer(player);	/* needed here only to cleanup last field */
 #endif
 
-  if (player->MovPos == 0)
+  if (player->MovPos == 0)	/* player reached destination field */
   {
     if (IS_PASSABLE(Feld[last_jx][last_jy]))
     {
@@ -6540,12 +6824,14 @@ void ScrollFigure(struct PlayerInfo *player, int mode)
     player->last_jy = jy;
 
     if (Feld[jx][jy] == EL_EXIT_OPEN ||
-	Feld[jx][jy] == EL_SP_EXIT_OPEN)
+	Feld[jx][jy] == EL_SP_EXIT_OPEN ||
+	Feld[jx][jy] == EL_SP_EXIT_OPENING)	/* <-- special case */
     {
+      DrawPlayer(player);	/* needed here only to cleanup last field */
       RemoveHero(player);
 
       if (local_player->friends_still_needed == 0 ||
-	  Feld[jx][jy] == EL_SP_EXIT_OPEN)
+	  IS_SP_ELEMENT(Feld[jx][jy]))
 	player->LevelSolved = player->GameOver = TRUE;
     }
 
@@ -6585,7 +6871,9 @@ void ScrollScreen(struct PlayerInfo *player, int mode)
 
 void TestIfPlayerTouchesCustomElement(int x, int y)
 {
+#if 0
   static boolean check_changing = FALSE;
+#endif
   static int xy[4][2] =
   {
     { 0, -1 },
@@ -6593,21 +6881,51 @@ void TestIfPlayerTouchesCustomElement(int x, int y)
     { +1, 0 },
     { 0, +1 }
   };
+  static int change_sides[4][2] =
+  {
+    /* center side       border side */
+    { CH_SIDE_TOP,	CH_SIDE_BOTTOM	},	/* check top    */
+    { CH_SIDE_LEFT,	CH_SIDE_RIGHT	},	/* check left   */
+    { CH_SIDE_RIGHT,	CH_SIDE_LEFT	},	/* check right  */
+    { CH_SIDE_BOTTOM,	CH_SIDE_TOP	}	/* check bottom */
+  };
   int i;
 
+#if 0
   if (check_changing)	/* prevent this function from running into a loop */
     return;
 
   check_changing = TRUE;
+#endif
 
   for (i=0; i<4; i++)
   {
     int xx = x + xy[i][0];
     int yy = y + xy[i][1];
+    int center_side = change_sides[i][0];
+    int border_side = change_sides[i][1];
 
     if (!IN_LEV_FIELD(xx, yy))
       continue;
 
+#if 1
+    if (IS_PLAYER(x, y))
+    {
+      CheckTriggeredElementSideChange(xx, yy, Feld[xx][yy], border_side,
+				      CE_OTHER_GETS_TOUCHED);
+      CheckElementSideChange(xx, yy, Feld[xx][yy], border_side,
+			     CE_TOUCHED_BY_PLAYER, -1);
+    }
+    else if (IS_PLAYER(xx, yy))
+    {
+      CheckTriggeredElementSideChange(x, y, Feld[x][y], center_side,
+				      CE_OTHER_GETS_TOUCHED);
+      CheckElementSideChange(x, y, Feld[x][y], center_side,
+			     CE_TOUCHED_BY_PLAYER, -1);
+
+      break;
+    }
+#else
     if (IS_PLAYER(x, y))
     {
       CheckTriggeredElementChange(xx, yy, Feld[xx][yy], CE_OTHER_GETS_TOUCHED);
@@ -6620,14 +6938,19 @@ void TestIfPlayerTouchesCustomElement(int x, int y)
 
       break;
     }
+#endif
   }
 
+#if 0
   check_changing = FALSE;
+#endif
 }
 
 void TestIfElementTouchesCustomElement(int x, int y)
 {
+#if 0
   static boolean check_changing = FALSE;
+#endif
   static int xy[4][2] =
   {
     { 0, -1 },
@@ -6635,19 +6958,32 @@ void TestIfElementTouchesCustomElement(int x, int y)
     { +1, 0 },
     { 0, +1 }
   };
+  static int change_sides[4][2] =
+  {
+    /* center side       border side */
+    { CH_SIDE_TOP,	CH_SIDE_BOTTOM	},	/* check top    */
+    { CH_SIDE_LEFT,	CH_SIDE_RIGHT	},	/* check left   */
+    { CH_SIDE_RIGHT,	CH_SIDE_LEFT	},	/* check right  */
+    { CH_SIDE_BOTTOM,	CH_SIDE_TOP	}	/* check bottom */
+  };
   boolean change_center_element = FALSE;
+  int center_element_change_page = 0;
   int center_element = Feld[x][y];
-  int i;
+  int i, j;
 
+#if 0
   if (check_changing)	/* prevent this function from running into a loop */
     return;
 
   check_changing = TRUE;
+#endif
 
   for (i=0; i<4; i++)
   {
     int xx = x + xy[i][0];
     int yy = y + xy[i][1];
+    int center_side = change_sides[i][0];
+    int border_side = change_sides[i][1];
     int border_element;
 
     if (!IN_LEV_FIELD(xx, yy))
@@ -6657,19 +6993,54 @@ void TestIfElementTouchesCustomElement(int x, int y)
 
     /* check for change of center element (but change it only once) */
     if (IS_CUSTOM_ELEMENT(center_element) &&
-	border_element == element_info[center_element].change.trigger_element)
-      change_center_element = TRUE;
+	HAS_ANY_CHANGE_EVENT(center_element, CE_OTHER_IS_TOUCHING) &&
+	!change_center_element)
+    {
+      for (j=0; j < element_info[center_element].num_change_pages; j++)
+      {
+	struct ElementChangeInfo *change =
+	  &element_info[center_element].change_page[j];
+
+	if (change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
+	    change->sides & border_side &&
+	    change->trigger_element == border_element)
+	{
+	  change_center_element = TRUE;
+	  center_element_change_page = j;
+
+	  break;
+	}
+      }
+    }
 
     /* check for change of border element */
     if (IS_CUSTOM_ELEMENT(border_element) &&
-	center_element == element_info[border_element].change.trigger_element)
-      CheckElementChange(xx, yy, border_element, CE_OTHER_IS_TOUCHING);
+	HAS_ANY_CHANGE_EVENT(border_element, CE_OTHER_IS_TOUCHING))
+    {
+      for (j=0; j < element_info[border_element].num_change_pages; j++)
+      {
+	struct ElementChangeInfo *change =
+	  &element_info[border_element].change_page[j];
+
+	if (change->events & CH_EVENT_BIT(CE_OTHER_IS_TOUCHING) &&
+	    change->sides & center_side &&
+	    change->trigger_element == center_element)
+	{
+	  CheckElementSideChange(xx, yy, border_element, CH_SIDE_ANY,
+				 CE_OTHER_IS_TOUCHING, j);
+	  break;
+	}
+      }
+    }
   }
 
   if (change_center_element)
-    CheckElementChange(x, y, center_element, CE_OTHER_IS_TOUCHING);
+    CheckElementSideChange(x, y, center_element, CH_SIDE_ANY,
+			   CE_OTHER_IS_TOUCHING, center_element_change_page);
 
+#if 0
   check_changing = FALSE;
+#endif
 }
 
 void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
@@ -7001,6 +7372,13 @@ static boolean checkDiagonalPushing(struct PlayerInfo *player,
 int DigField(struct PlayerInfo *player,
 	     int x, int y, int real_dx, int real_dy, int mode)
 {
+  static int change_sides[4] =
+  {
+    CH_SIDE_RIGHT,	/* moving left  */
+    CH_SIDE_LEFT,	/* moving right */
+    CH_SIDE_BOTTOM,	/* moving up    */
+    CH_SIDE_TOP,	/* moving down  */
+  };
   boolean use_spring_bug = (game.engine_version < VERSION_IDENT(2,2,0));
   int jx = player->jx, jy = player->jy;
   int dx = x - jx, dy = y - jy;
@@ -7009,6 +7387,7 @@ int DigField(struct PlayerInfo *player,
 			dx == +1 ? MV_RIGHT :
 			dy == -1 ? MV_UP :
 			dy == +1 ? MV_DOWN : MV_NO_MOVING);
+  int dig_side = change_sides[MV_DIR_BIT(move_direction)];
   int element;
 
   if (player->MovPos == 0)
@@ -7075,6 +7454,7 @@ int DigField(struct PlayerInfo *player,
 
   switch (element)
   {
+#if 0
     case EL_ROBOT_WHEEL:
       Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
       ZX = x;
@@ -7083,7 +7463,9 @@ int DigField(struct PlayerInfo *player,
       PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
       return MF_ACTION;
       break;
+#endif
 
+#if 0
     case EL_SP_TERMINAL:
       {
 	int xx, yy;
@@ -7104,7 +7486,9 @@ int DigField(struct PlayerInfo *player,
 	return MF_ACTION;
       }
       break;
+#endif
 
+#if 0
     case EL_CONVEYOR_BELT_1_SWITCH_LEFT:
     case EL_CONVEYOR_BELT_1_SWITCH_MIDDLE:
     case EL_CONVEYOR_BELT_1_SWITCH_RIGHT:
@@ -7117,31 +7501,56 @@ int DigField(struct PlayerInfo *player,
     case EL_CONVEYOR_BELT_4_SWITCH_LEFT:
     case EL_CONVEYOR_BELT_4_SWITCH_MIDDLE:
     case EL_CONVEYOR_BELT_4_SWITCH_RIGHT:
+#if 1
+      if (!PLAYER_SWITCHING(player, x, y))
+#else
       if (!player->Switching)
+#endif
       {
 	player->Switching = TRUE;
+	player->switch_x = x;
+	player->switch_y = y;
+
 	ToggleBeltSwitch(x, y);
 	PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
       }
       return MF_ACTION;
       break;
+#endif
 
+#if 0
     case EL_SWITCHGATE_SWITCH_UP:
     case EL_SWITCHGATE_SWITCH_DOWN:
+#if 1
+      if (!PLAYER_SWITCHING(player, x, y))
+#else
       if (!player->Switching)
+#endif
       {
 	player->Switching = TRUE;
+	player->switch_x = x;
+	player->switch_y = y;
+
 	ToggleSwitchgateSwitch(x, y);
 	PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
       }
       return MF_ACTION;
       break;
+#endif
 
+#if 0
     case EL_LIGHT_SWITCH:
     case EL_LIGHT_SWITCH_ACTIVE:
+#if 1
+      if (!PLAYER_SWITCHING(player, x, y))
+#else
       if (!player->Switching)
+#endif
       {
 	player->Switching = TRUE;
+	player->switch_x = x;
+	player->switch_y = y;
+
 	ToggleLightSwitch(x, y);
 	PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
 		       SND_LIGHT_SWITCH_ACTIVATING :
@@ -7149,14 +7558,18 @@ int DigField(struct PlayerInfo *player,
       }
       return MF_ACTION;
       break;
+#endif
 
+#if 0
     case EL_TIMEGATE_SWITCH:
       ActivateTimegateSwitch(x, y);
       PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
 
       return MF_ACTION;
       break;
+#endif
 
+#if 0
     case EL_BALLOON_SWITCH_LEFT:
     case EL_BALLOON_SWITCH_RIGHT:
     case EL_BALLOON_SWITCH_UP:
@@ -7174,6 +7587,7 @@ int DigField(struct PlayerInfo *player,
 
       return MF_ACTION;
       break;
+#endif
 
     case EL_SP_PORT_LEFT:
     case EL_SP_PORT_RIGHT:
@@ -7214,7 +7628,7 @@ int DigField(struct PlayerInfo *player,
 	  element == EL_SP_GRAVITY_PORT_RIGHT ||
 	  element == EL_SP_GRAVITY_PORT_UP ||
 	  element == EL_SP_GRAVITY_PORT_DOWN)
-	level.gravity = !level.gravity;
+	game.gravity = !game.gravity;
 
       /* automatically move to the next field with double speed */
       player->programmed_action = move_direction;
@@ -7266,6 +7680,7 @@ int DigField(struct PlayerInfo *player,
       }
       break;
 
+#if 0
     case EL_LAMP:
       Feld[x][y] = EL_LAMP_ACTIVE;
       local_player->lights_still_needed--;
@@ -7273,7 +7688,9 @@ int DigField(struct PlayerInfo *player,
       PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
       return MF_ACTION;
       break;
+#endif
 
+#if 0
     case EL_TIME_ORB_FULL:
       Feld[x][y] = EL_TIME_ORB_EMPTY;
       TimeLeft += 10;
@@ -7282,6 +7699,7 @@ int DigField(struct PlayerInfo *player,
       PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
       return MF_ACTION;
       break;
+#endif
 
     default:
 
@@ -7299,7 +7717,9 @@ int DigField(struct PlayerInfo *player,
 	  if (!player->key[element - EL_GATE_1_GRAY])
 	    return MF_NO_ACTION;
 	}
-	else if (element == EL_EXIT_OPEN || element == EL_SP_EXIT_OPEN)
+	else if (element == EL_EXIT_OPEN ||
+		 element == EL_SP_EXIT_OPEN ||
+		 element == EL_SP_EXIT_OPENING)
 	{
 	  sound_action = ACTION_PASSING;	/* player is passing exit */
 	}
@@ -7321,6 +7741,11 @@ int DigField(struct PlayerInfo *player,
 	if (!IN_LEV_FIELD(nextx, nexty) || !IS_FREE(nextx, nexty))
 	  return MF_NO_ACTION;
 
+#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)
 	{
 	  if (!player->key[element - EL_EM_GATE_1])
@@ -7350,13 +7775,17 @@ int DigField(struct PlayerInfo *player,
 	  GfxElement[x][y] = GFX_ELEMENT(element);
 #else
 	  GfxElement[x][y] =
-	    (CAN_BE_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
+	    (GFX_CRUMBLED(element) ? EL_SAND : GFX_ELEMENT(element));
 #endif
 	  player->is_digging = TRUE;
 	}
 
 	PlaySoundLevelElementAction(x, y, element, ACTION_DIGGING);
 
+	CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_DIGGED);
+
+	TestIfElementTouchesCustomElement(x, y);	/* for empty space */
+
 	break;
       }
       else if (IS_COLLECTIBLE(element))
@@ -7417,6 +7846,14 @@ int DigField(struct PlayerInfo *player,
 			     el2edimg(EL_KEY_1 + key_nr));
 	  redraw_mask |= REDRAW_DOOR_1;
 	}
+	else if (IS_ENVELOPE(element))
+	{
+#if 1
+	  player->show_envelope = element;
+#else
+	  ShowEnvelope(element - EL_ENVELOPE_1);
+#endif
+	}
 	else if (IS_DROPPABLE(element))	/* can be collected and dropped */
 	{
 	  int i;
@@ -7444,6 +7881,8 @@ int DigField(struct PlayerInfo *player,
 
 	CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_COLLECTED);
 
+	TestIfElementTouchesCustomElement(x, y);	/* for empty space */
+
 	break;
       }
       else if (IS_PUSHABLE(element))
@@ -7458,9 +7897,15 @@ int DigField(struct PlayerInfo *player,
 	    !(element == EL_SPRING && use_spring_bug))
 	  return MF_NO_ACTION;
 
+#if 1
+	/* do not push elements already moving away faster than player */
+	if (CAN_MOVE(element) && MovDir[x][y] == move_direction &&
+	    ABS(getElementMoveStepsize(x, y)) > MOVE_STEPSIZE_NORMAL)
+	  return MF_NO_ACTION;
+#else
 	if (element == EL_SPRING && MovDir[x][y] != MV_NO_MOVING)
 	  return MF_NO_ACTION;
-
+#endif
 	if (!player->Pushing &&
 	    game.engine_version >= RELEASE_IDENT(2,2,0,7))
 	  player->push_delay_value = GET_NEW_PUSH_DELAY(element);
@@ -7533,15 +7978,187 @@ int DigField(struct PlayerInfo *player,
 	if (game.engine_version < RELEASE_IDENT(2,2,0,7))
 	  player->push_delay_value = GET_NEW_PUSH_DELAY(element);
 
+#if 1
+	CheckTriggeredElementSideChange(x, y, element, dig_side,
+					CE_OTHER_GETS_PUSHED);
+	CheckElementSideChange(x, y, element, dig_side,
+			       CE_PUSHED_BY_PLAYER, -1);
+#else
 	CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PUSHED);
 	CheckElementChange(x, y, element, CE_PUSHED_BY_PLAYER);
+#endif
 
 	break;
       }
+      else if (IS_SWITCHABLE(element))
+      {
+	if (PLAYER_SWITCHING(player, x, y))
+	  return MF_ACTION;
+
+#if 1
+	PlaySoundLevelElementAction(x, y, element, ACTION_ACTIVATING);
+#endif
+
+	if (element == EL_ROBOT_WHEEL)
+	{
+	  Feld[x][y] = EL_ROBOT_WHEEL_ACTIVE;
+	  ZX = x;
+	  ZY = y;
+
+	  DrawLevelField(x, y);
+
+#if 0
+	  PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
+#endif
+	}
+	else if (element == EL_SP_TERMINAL)
+	{
+	  int xx, yy;
+
+#if 0
+	  PlaySoundLevel(x, y, SND_SP_TERMINAL_ACTIVATING);
+#endif
+
+	  for (yy=0; yy<lev_fieldy; yy++)
+	  {
+	    for (xx=0; xx<lev_fieldx; xx++)
+	    {
+	      if (Feld[xx][yy] == EL_SP_DISK_YELLOW)
+		Bang(xx, yy);
+	      else if (Feld[xx][yy] == EL_SP_TERMINAL)
+		Feld[xx][yy] = EL_SP_TERMINAL_ACTIVE;
+	    }
+	  }
+	}
+	else if (IS_BELT_SWITCH(element))
+	{
+#if 0
+	  if (!PLAYER_SWITCHING(player, x, y))
+#endif
+	  {
+	    player->Switching = TRUE;
+	    player->switch_x = x;
+	    player->switch_y = y;
+
+	    ToggleBeltSwitch(x, y);
+
+#if 0
+	    PlaySoundLevel(x, y, SND_CLASS_CONVEYOR_BELT_SWITCH_ACTIVATING);
+#endif
+	  }
+	}
+	else if (element == EL_SWITCHGATE_SWITCH_UP ||
+		 element == EL_SWITCHGATE_SWITCH_DOWN)
+	{
+#if 0
+	  if (!PLAYER_SWITCHING(player, x, y))
+#endif
+	  {
+	    player->Switching = TRUE;
+	    player->switch_x = x;
+	    player->switch_y = y;
+
+	    ToggleSwitchgateSwitch(x, y);
+
+#if 0
+	    PlaySoundLevel(x, y, SND_CLASS_SWITCHGATE_SWITCH_ACTIVATING);
+#endif
+	  }
+	}
+	else if (element == EL_LIGHT_SWITCH ||
+		 element == EL_LIGHT_SWITCH_ACTIVE)
+	{
+#if 0
+	  if (!PLAYER_SWITCHING(player, x, y))
+#endif
+	  {
+	    player->Switching = TRUE;
+	    player->switch_x = x;
+	    player->switch_y = y;
+
+	    ToggleLightSwitch(x, y);
+
+#if 0
+	    PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH ?
+			   SND_LIGHT_SWITCH_ACTIVATING :
+			   SND_LIGHT_SWITCH_DEACTIVATING);
+#endif
+	  }
+	}
+	else if (element == EL_TIMEGATE_SWITCH)
+	{
+	  ActivateTimegateSwitch(x, y);
+
+#if 0
+	  PlaySoundLevel(x, y, SND_TIMEGATE_SWITCH_ACTIVATING);
+#endif
+	}
+	else if (element == EL_BALLOON_SWITCH_LEFT ||
+		 element == EL_BALLOON_SWITCH_RIGHT ||
+		 element == EL_BALLOON_SWITCH_UP ||
+		 element == EL_BALLOON_SWITCH_DOWN ||
+		 element == EL_BALLOON_SWITCH_ANY)
+	{
+	  if (element == EL_BALLOON_SWITCH_ANY)
+	    game.balloon_dir = move_direction;
+	  else
+	    game.balloon_dir = (element == EL_BALLOON_SWITCH_LEFT  ? MV_LEFT :
+				element == EL_BALLOON_SWITCH_RIGHT ? MV_RIGHT :
+				element == EL_BALLOON_SWITCH_UP    ? MV_UP :
+				element == EL_BALLOON_SWITCH_DOWN  ? MV_DOWN :
+				MV_NO_MOVING);
+
+#if 0
+	  PlaySoundLevel(x, y, SND_CLASS_BALLOON_SWITCH_ACTIVATING);
+#endif
+	}
+	else if (element == EL_LAMP)
+	{
+	  Feld[x][y] = EL_LAMP_ACTIVE;
+	  local_player->lights_still_needed--;
+
+	  DrawLevelField(x, y);
+
+#if 0
+	  PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
+#endif
+	}
+	else if (element == EL_TIME_ORB_FULL)
+	{
+	  Feld[x][y] = EL_TIME_ORB_EMPTY;
+	  TimeLeft += 10;
+	  DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FONT_TEXT_2);
+
+	  DrawLevelField(x, y);
+
+#if 0
+	  PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, SOUND_MIDDLE);
+#endif
+	}
+
+	return MF_ACTION;
+      }
       else
       {
-	CheckTriggeredElementChange(x, y, element, CE_OTHER_GETS_PRESSED);
-	CheckElementChange(x, y, element, CE_PRESSED_BY_PLAYER);
+#if 1
+	if (!PLAYER_SWITCHING(player, x, y))
+#else
+	if (!player->Switching)
+#endif
+	{
+	  player->Switching = TRUE;
+	  player->switch_x = x;
+	  player->switch_y = y;
+
+	  CheckTriggeredElementSideChange(x, y, element, dig_side,
+					  CE_OTHER_IS_SWITCHING);
+	  CheckElementSideChange(x, y, element, dig_side, CE_SWITCHED, -1);
+	}
+
+	CheckTriggeredElementSideChange(x, y, element, dig_side,
+					CE_OTHER_GETS_PRESSED);
+	CheckElementSideChange(x, y, element, dig_side,
+			       CE_PRESSED_BY_PLAYER, -1);
       }
 
       return MF_NO_ACTION;
@@ -7584,8 +8201,15 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy)
     {
       player->is_digging = FALSE;
       player->is_collecting = FALSE;
+#if 1
+      player->is_moving = FALSE;
+#endif
     }
 
+#if 0
+    printf("::: trying to snap...\n");
+#endif
+
     return FALSE;
   }
 
@@ -7594,12 +8218,25 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy)
 
   player->MovDir = snap_direction;
 
+#if 1
+  player->is_digging = FALSE;
+  player->is_collecting = FALSE;
+#if 1
+  player->is_moving = FALSE;
+#endif
+#endif
+
   if (DigField(player, x, y, 0, 0, DF_SNAP) == MF_NO_ACTION)
     return FALSE;
 
   player->snapped = TRUE;
+#if 1
   player->is_digging = FALSE;
   player->is_collecting = FALSE;
+#if 1
+  player->is_moving = FALSE;
+#endif
+#endif
 
   DrawLevelField(x, y);
   BackToFront();
@@ -7662,6 +8299,8 @@ boolean DropElement(struct PlayerInfo *player)
 
     CheckTriggeredElementChange(jx, jy, new_element, CE_OTHER_GETS_DROPPED);
     CheckElementChange(jx, jy, new_element, CE_DROPPED_BY_PLAYER);
+
+    TestIfElementTouchesCustomElement(jx, jy);
   }
   else		/* player is dropping a dyna bomb */
   {