X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame.c;h=0312c695cccb3ba28d2a893c667d9ecadd79b058;hb=62e8f84edbffc67d743bb2d6afff258079f041d5;hp=3471f671a8e145e01f08d994ff138154a085540c;hpb=209871b6f17880f98d41cf7d7953f6bf2227a16c;p=rocksndiamonds.git

diff --git a/src/game.c b/src/game.c
index 3471f671..0312c695 100644
--- a/src/game.c
+++ b/src/game.c
@@ -1,28 +1,32 @@
 /***********************************************************
-*  Rocks'n'Diamonds -- McDuffin Strikes Back!              *
+* Rocks'n'Diamonds -- McDuffin Strikes Back!               *
 *----------------------------------------------------------*
-*  (c) 1995-98 Artsoft Entertainment                       *
-*              Holger Schemel                              *
-*              Oststrasse 11a                              *
-*              33604 Bielefeld                             *
-*              phone: ++49 +521 290471                     *
-*              email: aeglos@valinor.owl.de                *
+* (c) 1995-2001 Artsoft Entertainment                      *
+*               Holger Schemel                             *
+*               Detmolder Strasse 189                      *
+*               33604 Bielefeld                            *
+*               Germany                                    *
+*               e-mail: info@artsoft.org                   *
 *----------------------------------------------------------*
-*  game.c                                                  *
+* game.c                                                   *
 ***********************************************************/
 
+#include "libgame/libgame.h"
+
 #include "game.h"
-#include "misc.h"
 #include "tools.h"
 #include "screens.h"
-#include "sound.h"
 #include "init.h"
-#include "buttons.h"
 #include "files.h"
 #include "tape.h"
-#include "joystick.h"
 #include "network.h"
 
+/* this switch controls how rocks move horizontally */
+#define OLD_GAME_BEHAVIOUR	FALSE
+
+/* EXPERIMENTAL STUFF */
+#define USE_NEW_AMOEBA_CODE	FALSE
+
 /* for DigField() */
 #define DF_NO_PUSH		0
 #define DF_DIG			1
@@ -39,9 +43,10 @@
 
 /* for Explode() */
 #define EX_PHASE_START		0
-#define EX_NORMAL		0
-#define EX_CENTER		1
-#define EX_BORDER		2
+#define EX_NO_EXPLOSION		0
+#define EX_NORMAL		1
+#define EX_CENTER		2
+#define EX_BORDER		3
 
 /* special positions in the game control window (relative to control window) */
 #define XX_LEVEL		37
@@ -71,35 +76,89 @@
 #define DX_TIME			(DX + XX_TIME)
 #define DY_TIME			(DY + YY_TIME)
 
-#define IS_LOOP_SOUND(s)	((s)==SND_KLAPPER || (s)==SND_ROEHR ||	\
-				 (s)==SND_NJAM || (s)==SND_MIEP)
-#define IS_MUSIC_SOUND(s)	((s)==SND_ALCHEMY || (s)==SND_CHASE || \
-				 (s)==SND_NETWORK || (s)==SND_CZARDASZ || \
-				 (s)==SND_TYGER || (s)==SND_VOYAGER || \
-				 (s)==SND_TWILIGHT)
+#if 0
+#define IS_LOOP_SOUND(s)	((s) == SND_BD_MAGIC_WALL_RUNNING ||	\
+	 			 (s) == SND_BD_BUTTERFLY_MOVING ||	\
+				 (s) == SND_BD_FIREFLY_MOVING ||	\
+	 			 (s) == SND_SP_SNIKSNAK_MOVING ||	\
+				 (s) == SND_SP_ELECTRON_MOVING ||	\
+	 			 (s) == SND_DYNAMITE_BURNING ||	\
+				 (s) == SND_BUG_MOVING ||	\
+	 			 (s) == SND_SPACESHIP_MOVING ||	\
+				 (s) == SND_YAMYAM_MOVING ||	\
+	 			 (s) == SND_YAMYAM_WAITING ||	\
+				 (s) == SND_ROBOT_WHEEL_RUNNING ||	\
+	 			 (s) == SND_MAGIC_WALL_RUNNING ||	\
+				 (s) == SND_BALLOON_MOVING ||	\
+	 			 (s) == SND_MOLE_MOVING ||	\
+				 (s) == SND_TIMEGATE_WHEEL_RUNNING ||	\
+	 			 (s) == SND_CONVEYOR_BELT_RUNNING ||	\
+				 (s) == SND_DYNABOMB_BURNING ||	\
+	 			 (s) == SND_PACMAN_MOVING ||	\
+				 (s) == SND_PENGUIN_MOVING ||	\
+	 			 (s) == SND_PIG_MOVING ||	\
+				 (s) == SND_DRAGON_MOVING ||	\
+	 			 (s) == SND_DRAGON_BREATHING_FIRE)
+#endif
+
+/* values for player movement speed (which is in fact a delay value) */
+#define MOVE_DELAY_NORMAL_SPEED	8
+#define MOVE_DELAY_HIGH_SPEED	4
+
+#define DOUBLE_MOVE_DELAY(x)	(x = (x <= MOVE_DELAY_HIGH_SPEED ? x * 2 : x))
+#define HALVE_MOVE_DELAY(x)	(x = (x >= MOVE_DELAY_HIGH_SPEED ? x / 2 : x))
+#define DOUBLE_PLAYER_SPEED(p)	(HALVE_MOVE_DELAY((p)->move_delay_value))
+#define HALVE_PLAYER_SPEED(p)	(DOUBLE_MOVE_DELAY((p)->move_delay_value))
+
+/* game button identifiers */
+#define GAME_CTRL_ID_STOP		0
+#define GAME_CTRL_ID_PAUSE		1
+#define GAME_CTRL_ID_PLAY		2
+#define SOUND_CTRL_ID_MUSIC		3
+#define SOUND_CTRL_ID_LOOPS		4
+#define SOUND_CTRL_ID_SIMPLE		5
 
-/* score for elements */
-#define SC_EDELSTEIN		0
-#define SC_DIAMANT		1
-#define SC_KAEFER		2
-#define SC_FLIEGER		3
-#define SC_MAMPFER		4
-#define SC_ROBOT		5
-#define SC_PACMAN		6
-#define SC_KOKOSNUSS		7
-#define SC_DYNAMIT		8
-#define SC_SCHLUESSEL		9
-#define SC_ZEITBONUS		10
+#define NUM_GAME_BUTTONS		6
 
-/* values for game_emulation */
-#define EMU_NONE		0
-#define EMU_BOULDERDASH		1
-#define EMU_SOKOBAN		2
-#define EMU_SUPAPLEX		3
+/* forward declaration for internal use */
+static void CloseAllOpenTimegates(void);
+static void CheckGravityMovement(struct PlayerInfo *);
+static void KillHeroUnlessProtected(int, int);
 
-/* to control special behaviour of certain game elements */
-int game_emulation = EMU_NONE;
+static void MapGameButtons();
+static void HandleGameButtons(struct GadgetInfo *);
 
+static struct GadgetInfo *game_gadget[NUM_GAME_BUTTONS];
+
+static boolean is_loop_sound[NUM_SOUND_EFFECTS];
+static boolean is_loop_sound_initialized = FALSE;
+static int loop_sounds[] =
+{
+  SND_BD_MAGIC_WALL_RUNNING,
+  SND_BD_BUTTERFLY_MOVING,
+  SND_BD_FIREFLY_MOVING,
+  SND_SP_SNIKSNAK_MOVING,
+  SND_SP_ELECTRON_MOVING,
+  SND_DYNAMITE_BURNING,
+  SND_BUG_MOVING,
+  SND_SPACESHIP_MOVING,
+  SND_YAMYAM_MOVING,
+  SND_YAMYAM_WAITING,
+  SND_ROBOT_WHEEL_RUNNING,
+  SND_MAGIC_WALL_RUNNING,
+  SND_BALLOON_MOVING,
+  SND_MOLE_MOVING,
+  SND_TIMEGATE_WHEEL_RUNNING,
+  SND_CONVEYOR_BELT_RUNNING,
+  SND_DYNABOMB_BURNING,
+  SND_PACMAN_MOVING,
+  SND_PENGUIN_MOVING,
+  SND_PIG_MOVING,
+  SND_DRAGON_MOVING,
+  SND_DRAGON_BREATHING_FIRE
+};
+
+#define IS_LOOP_SOUND(x)	(is_loop_sound[x])
 
 
 
@@ -140,7 +199,7 @@ static unsigned int getStateCheckSum(int counter)
     checksum += mult++ * StorePlayer[x][y];
     checksum += mult++ * Frame[x][y];
     checksum += mult++ * AmoebaNr[x][y];
-    checksum += mult++ * JustHit[x][y];
+    checksum += mult++ * JustStopped[x][y];
     checksum += mult++ * Stop[x][y];
     */
   }
@@ -158,26 +217,83 @@ static unsigned int getStateCheckSum(int counter)
 
 void GetPlayerConfig()
 {
-  if (sound_status == SOUND_OFF)
+  if (!audio.sound_available)
     setup.sound = FALSE;
 
-  if (!sound_loops_allowed)
-  {
+  if (!audio.loops_available)
     setup.sound_loops = FALSE;
+
+  if (!audio.music_available)
     setup.sound_music = FALSE;
-  }
+
+  if (!video.fullscreen_available)
+    setup.fullscreen = FALSE;
 
   setup.sound_simple = setup.sound;
 
+  SetAudioMode(setup.sound);
   InitJoysticks();
 }
 
+static int getBeltNrFromElement(int element)
+{
+  return (element < EL_BELT2_LEFT ? 0 :
+	  element < EL_BELT3_LEFT ? 1 :
+	  element < EL_BELT4_LEFT ? 2 : 3);
+}
+
+static int getBeltNrFromSwitchElement(int element)
+{
+  return (element < EL_BELT2_SWITCH_LEFT ? 0 :
+	  element < EL_BELT3_SWITCH_LEFT ? 1 :
+	  element < EL_BELT4_SWITCH_LEFT ? 2 : 3);
+}
+
+static int getBeltDirNrFromSwitchElement(int element)
+{
+  static int belt_base_element[4] =
+  {
+    EL_BELT1_SWITCH_LEFT,
+    EL_BELT2_SWITCH_LEFT,
+    EL_BELT3_SWITCH_LEFT,
+    EL_BELT4_SWITCH_LEFT
+  };
+
+  int belt_nr = getBeltNrFromSwitchElement(element);
+  int belt_dir_nr = element - belt_base_element[belt_nr];
+
+  return (belt_dir_nr % 3);
+}
+
+static int getBeltDirFromSwitchElement(int element)
+{
+  static int belt_move_dir[3] =
+  {
+    MV_LEFT,
+    MV_NO_MOVING,
+    MV_RIGHT
+  };
+
+  int belt_dir_nr = getBeltDirNrFromSwitchElement(element);
+
+  return belt_move_dir[belt_dir_nr];
+}
+
 static void InitField(int x, int y, boolean init_game)
 {
   switch (Feld[x][y])
   {
-    case EL_SPIELFIGUR:
     case EL_SP_MURPHY:
+      if (init_game)
+      {
+	if (stored_player[0].present)
+	{
+	  Feld[x][y] = EL_SP_MURPHY_CLONE;
+	  break;
+	}
+      }
+      /* no break! */
+    case EL_SPIELFIGUR:
       if (init_game)
 	Feld[x][y] = EL_SPIELER1;
       /* no break! */
@@ -192,10 +308,6 @@ static void InitField(int x, int y, boolean init_game)
 
 	player->present = TRUE;
 
-	/*
-	if (!network_playing || player->connected)
-	*/
-
 	if (!options.network || player->connected)
 	{
 	  player->active = TRUE;
@@ -206,7 +318,7 @@ static void InitField(int x, int y, boolean init_game)
 
 	  StorePlayer[x][y] = Feld[x][y];
 
-	  if (options.verbose)
+	  if (options.debug)
 	  {
 	    printf("Player %d activated.\n", player->element_nr);
 	    printf("[Local player is %d and currently %s.]\n",
@@ -234,36 +346,41 @@ static void InitField(int x, int y, boolean init_game)
 	Feld[x][y] = EL_BADEWANNE5;
       break;
 
-    case EL_KAEFER_R:
-    case EL_KAEFER_O:
-    case EL_KAEFER_L:
-    case EL_KAEFER_U:
+    case EL_KAEFER_RIGHT:
+    case EL_KAEFER_UP:
+    case EL_KAEFER_LEFT:
+    case EL_KAEFER_DOWN:
     case EL_KAEFER:
-    case EL_FLIEGER_R:
-    case EL_FLIEGER_O:
-    case EL_FLIEGER_L:
-    case EL_FLIEGER_U:
+    case EL_FLIEGER_RIGHT:
+    case EL_FLIEGER_UP:
+    case EL_FLIEGER_LEFT:
+    case EL_FLIEGER_DOWN:
     case EL_FLIEGER:
-    case EL_BUTTERFLY_R:
-    case EL_BUTTERFLY_O:
-    case EL_BUTTERFLY_L:
-    case EL_BUTTERFLY_U:
+    case EL_BUTTERFLY_RIGHT:
+    case EL_BUTTERFLY_UP:
+    case EL_BUTTERFLY_LEFT:
+    case EL_BUTTERFLY_DOWN:
     case EL_BUTTERFLY:
-    case EL_FIREFLY_R:
-    case EL_FIREFLY_O:
-    case EL_FIREFLY_L:
-    case EL_FIREFLY_U:
+    case EL_FIREFLY_RIGHT:
+    case EL_FIREFLY_UP:
+    case EL_FIREFLY_LEFT:
+    case EL_FIREFLY_DOWN:
     case EL_FIREFLY:
-    case EL_PACMAN_R:
-    case EL_PACMAN_O:
-    case EL_PACMAN_L:
-    case EL_PACMAN_U:
+    case EL_PACMAN_RIGHT:
+    case EL_PACMAN_UP:
+    case EL_PACMAN_LEFT:
+    case EL_PACMAN_DOWN:
     case EL_MAMPFER:
     case EL_MAMPFER2:
     case EL_ROBOT:
     case EL_PACMAN:
     case EL_SP_SNIKSNAK:
     case EL_SP_ELECTRON:
+    case EL_MOLE_LEFT:
+    case EL_MOLE_RIGHT:
+    case EL_MOLE_UP:
+    case EL_MOLE_DOWN:
+    case EL_MOLE:
       InitMovDir(x, y);
       break;
 
@@ -280,7 +397,7 @@ static void InitField(int x, int y, boolean init_game)
       }
       break;
 
-    case EL_DYNAMIT:
+    case EL_DYNAMITE_ACTIVE:
       MovDelay[x][y] = 96;
       break;
 
@@ -292,7 +409,6 @@ static void InitField(int x, int y, boolean init_game)
       local_player->sokobanfields_still_needed++;
       break;
 
-    case EL_MAULWURF:
     case EL_PINGUIN:
       local_player->friends_still_needed++;
       break;
@@ -306,11 +422,84 @@ static void InitField(int x, int y, boolean init_game)
       Feld[x][y] = EL_LEERRAUM;
       break;
 
+    case EL_EM_KEY_1_FILE:
+      Feld[x][y] = EL_EM_KEY_1;
+      break;
+    case EL_EM_KEY_2_FILE:
+      Feld[x][y] = EL_EM_KEY_2;
+      break;
+    case EL_EM_KEY_3_FILE:
+      Feld[x][y] = EL_EM_KEY_3;
+      break;
+    case EL_EM_KEY_4_FILE:
+      Feld[x][y] = EL_EM_KEY_4;
+      break;
+
+    case EL_BELT1_SWITCH_LEFT:
+    case EL_BELT1_SWITCH_MIDDLE:
+    case EL_BELT1_SWITCH_RIGHT:
+    case EL_BELT2_SWITCH_LEFT:
+    case EL_BELT2_SWITCH_MIDDLE:
+    case EL_BELT2_SWITCH_RIGHT:
+    case EL_BELT3_SWITCH_LEFT:
+    case EL_BELT3_SWITCH_MIDDLE:
+    case EL_BELT3_SWITCH_RIGHT:
+    case EL_BELT4_SWITCH_LEFT:
+    case EL_BELT4_SWITCH_MIDDLE:
+    case EL_BELT4_SWITCH_RIGHT:
+      if (init_game)
+      {
+	int belt_nr = getBeltNrFromSwitchElement(Feld[x][y]);
+	int belt_dir = getBeltDirFromSwitchElement(Feld[x][y]);
+	int belt_dir_nr = getBeltDirNrFromSwitchElement(Feld[x][y]);
+
+	if (game.belt_dir_nr[belt_nr] == 3)	/* initial value */
+	{
+	  game.belt_dir[belt_nr] = belt_dir;
+	  game.belt_dir_nr[belt_nr] = belt_dir_nr;
+	}
+	else	/* more than one switch -- set it like the first switch */
+	{
+	  Feld[x][y] = Feld[x][y] - belt_dir_nr + game.belt_dir_nr[belt_nr];
+	}
+      }
+      break;
+
+    case EL_SWITCHGATE_SWITCH_2:	/* always start with same switch pos */
+      if (init_game)
+	Feld[x][y] = EL_SWITCHGATE_SWITCH_1;
+      break;
+
+    case EL_LIGHT_SWITCH_ON:
+      if (init_game)
+	game.light_time_left = level.time_light * FRAMES_PER_SECOND;
+      break;
+
     default:
       break;
   }
 }
 
+void DrawGameDoorValues()
+{
+  int i, j;
+
+  for (i=0; i<MAX_PLAYERS; i++)
+    for (j=0; j<4; j++)
+      if (stored_player[i].key[j])
+	DrawMiniGraphicExt(drawto, DX_KEYS + j * MINI_TILEX, DY_KEYS,
+			   GFX_SCHLUESSEL1 + j);
+
+  DrawText(DX + XX_EMERALDS, DY + YY_EMERALDS,
+	   int2str(local_player->gems_still_needed, 3), FS_SMALL, FC_YELLOW);
+  DrawText(DX + XX_DYNAMITE, DY + YY_DYNAMITE,
+	   int2str(local_player->dynamite, 3), FS_SMALL, FC_YELLOW);
+  DrawText(DX + XX_SCORE, DY + YY_SCORE,
+	   int2str(local_player->score, 5), FS_SMALL, FC_YELLOW);
+  DrawText(DX + XX_TIME, DY + YY_TIME,
+	   int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
+}
+
 void InitGame()
 {
   int i, j, x, y;
@@ -318,6 +507,14 @@ void InitGame()
   boolean emulate_sb = TRUE;	/* unless non-SOKOBAN     elements found */
   boolean emulate_sp = TRUE;	/* unless non-SUPAPLEX    elements found */
 
+#if DEBUG
+#if USE_NEW_AMOEBA_CODE
+  printf("Using new amoeba code.\n");
+#else
+  printf("Using old amoeba code.\n");
+#endif
+#endif
+
   /* don't play tapes over network */
   network_playing = (options.network && !tape.playing);
 
@@ -333,9 +530,10 @@ void InitGame()
 
     player->action = 0;
     player->effective_action = 0;
+    player->programmed_action = 0;
 
     player->score = 0;
-    player->gems_still_needed = level.edelsteine;
+    player->gems_still_needed = level.gems_needed;
     player->sokobanfields_still_needed = 0;
     player->lights_still_needed = 0;
     player->friends_still_needed = 0;
@@ -345,13 +543,14 @@ void InitGame()
 
     player->dynamite = 0;
     player->dynabomb_count = 0;
-    player->dynabomb_size = 0;
+    player->dynabomb_size = 1;
     player->dynabombs_left = 0;
     player->dynabomb_xl = FALSE;
 
     player->MovDir = MV_NO_MOVING;
     player->MovPos = 0;
     player->Pushing = FALSE;
+    player->Switching = FALSE;
     player->GfxPos = 0;
     player->Frame = 0;
 
@@ -359,19 +558,24 @@ void InitGame()
 
     player->frame_reset_delay = 0;
 
+    player->last_move_dir = MV_NO_MOVING;
+    player->is_moving = FALSE;
+
+    player->move_delay = -1;	/* no initial move delay */
+    player->move_delay_value =
+      (level.double_speed ? MOVE_DELAY_HIGH_SPEED : MOVE_DELAY_NORMAL_SPEED);
+
     player->push_delay = 0;
     player->push_delay_value = 5;
 
-    player->move_delay = 0;
-    player->last_move_dir = MV_NO_MOVING;
-
     player->snapped = FALSE;
 
-    player->gone = FALSE;
-
     player->last_jx = player->last_jy = 0;
     player->jx = player->jy = 0;
 
+    player->shield_passive_time_left = 0;
+    player->shield_active_time_left = 0;
+
     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
     SnapField(player, 0, 0);
 
@@ -381,7 +585,7 @@ void InitGame()
 
   network_player_action_received = FALSE;
 
-#ifndef MSDOS
+#if defined(PLATFORM_UNIX)
   /* initial null action */
   if (network_playing)
     SendToServer_MovePlayer(MV_NO_MOVING);
@@ -389,29 +593,33 @@ void InitGame()
 
   ZX = ZY = -1;
 
-  MampferNr = 0;
   FrameCounter = 0;
   TimeFrames = 0;
+  TimePlayed = 0;
   TimeLeft = level.time;
 
   ScreenMovDir = MV_NO_MOVING;
   ScreenMovPos = 0;
   ScreenGfxPos = 0;
 
-  if (level.high_speed)
-  {
-    MoveSpeed = 4;
-    ScrollStepSize = TILEX/4;
-  }
-  else
-  {
-    MoveSpeed = 8;
-    ScrollStepSize = TILEX/8;
-  }
+  ScrollStepSize = 0;	/* will be correctly initialized by ScrollScreen() */
 
   AllPlayersGone = FALSE;
-  SiebAktiv = FALSE;
-  SiebCount = 0;
+
+  game.yam_content_nr = 0;
+  game.magic_wall_active = FALSE;
+  game.magic_wall_time_left = 0;
+  game.light_time_left = 0;
+  game.timegate_time_left = 0;
+  game.switchgate_pos = 0;
+  game.balloon_dir = MV_NO_MOVING;
+  game.explosions_delayed = TRUE;
+
+  for (i=0; i<4; i++)
+  {
+    game.belt_dir[i] = MV_NO_MOVING;
+    game.belt_dir_nr[i] = 3;		/* not moving, next moving left */
+  }
 
   for (i=0; i<MAX_NUM_AMOEBA; i++)
     AmoebaCnt[i] = AmoebaCnt2[i] = 0;
@@ -425,8 +633,9 @@ void InitGame()
       Store[x][y] = Store2[x][y] = StorePlayer[x][y] = 0;
       Frame[x][y] = 0;
       AmoebaNr[x][y] = 0;
-      JustHit[x][y] = 0;
+      JustStopped[x][y] = 0;
       Stop[x][y] = FALSE;
+      ExplodeField[x][y] = EX_NO_EXPLOSION;
     }
   }
 
@@ -445,6 +654,11 @@ void InitGame()
     }
   }
 
+  /* correct non-moving belts to start moving left */
+  for (i=0; i<4; i++)
+    if (game.belt_dir[i] == MV_NO_MOVING)
+      game.belt_dir_nr[i] = 3;		/* not moving, next moving left */
+
   /* check if any connected player was not found in playfield */
   for (i=0; i<MAX_PLAYERS; i++)
   {
@@ -523,7 +737,7 @@ void InitGame()
 	tape.player_participates[i] = TRUE;
   }
 
-  if (options.verbose)
+  if (options.debug)
   {
     for (i=0; i<MAX_PLAYERS; i++)
     {
@@ -539,19 +753,94 @@ void InitGame()
     }
   }
 
-  game_emulation = (emulate_bd ? EMU_BOULDERDASH :
+  /* initialize sound effect properties */
+  if (!is_loop_sound_initialized)
+  {
+    int i;
+
+    for (i=0; i<NUM_SOUND_EFFECTS; i++)
+      is_loop_sound[i] = FALSE;
+
+    for (i=0; i<SIZEOF_ARRAY_INT(loop_sounds); i++)
+      is_loop_sound[loop_sounds[i]] = TRUE;
+
+    is_loop_sound_initialized = TRUE;
+  }
+
+  game.version = (tape.playing ? tape.game_version : level.game_version);
+  game.emulation = (emulate_bd ? EMU_BOULDERDASH :
 		    emulate_sb ? EMU_SOKOBAN :
 		    emulate_sp ? EMU_SUPAPLEX : EMU_NONE);
 
-  scroll_x = scroll_y = -1;
-  if (local_player->jx >= MIDPOSX-1)
-    scroll_x = (local_player->jx <= lev_fieldx-MIDPOSX ?
+  /* dynamically adjust element properties according to game engine version */
+  {
+    static int ep_em_slippery_wall[] =
+    {
+      EL_BETON,
+      EL_MAUERWERK,
+      EL_MAUER_LEBT,
+      EL_MAUER_X,
+      EL_MAUER_Y,
+      EL_MAUER_XY
+    };
+#if 1
+    static int ep_em_slippery_wall_num = SIZEOF_ARRAY_INT(ep_em_slippery_wall);
+#else
+    static int ep_em_slippery_wall_num =
+      sizeof(ep_em_slippery_wall) / sizeof(int);
+#endif
+
+    /*
+    printf("level %d: game.version == %06d\n", level_nr, level.game_version);
+    printf("         file_version == %06d\n", level.file_version);
+    */
+
+    for (i=0; i<ep_em_slippery_wall_num; i++)
+    {
+#if 1
+      if (level.em_slippery_gems)	/* special EM style gems behaviour */
+#else
+      if (game.version >= GAME_VERSION_2_0)
+#endif
+	Elementeigenschaften2[ep_em_slippery_wall[i]] |=
+	  EP_BIT_EM_SLIPPERY_WALL;
+      else
+	Elementeigenschaften2[ep_em_slippery_wall[i]] &=
+	  ~EP_BIT_EM_SLIPPERY_WALL;
+    }
+  }
+
+  if (BorderElement == EL_LEERRAUM)
+  {
+    SBX_Left = 0;
+    SBX_Right = lev_fieldx - SCR_FIELDX;
+    SBY_Upper = 0;
+    SBY_Lower = lev_fieldy - SCR_FIELDY;
+  }
+  else
+  {
+    SBX_Left = -1;
+    SBX_Right = lev_fieldx - SCR_FIELDX + 1;
+    SBY_Upper = -1;
+    SBY_Lower = lev_fieldy - SCR_FIELDY + 1;
+  }
+
+  if (lev_fieldx + (SBX_Left == -1 ? 2 : 0) <= SCR_FIELDX)
+    SBX_Left = SBX_Right = -1 * (SCR_FIELDX - lev_fieldx) / 2;
+
+  if (lev_fieldy + (SBY_Upper == -1 ? 2 : 0) <= SCR_FIELDY)
+    SBY_Upper = SBY_Lower = -1 * (SCR_FIELDY - lev_fieldy) / 2;
+
+  scroll_x = SBX_Left;
+  scroll_y = SBY_Upper;
+  if (local_player->jx >= SBX_Left + MIDPOSX)
+    scroll_x = (local_player->jx <= SBX_Right + MIDPOSX ?
 		local_player->jx - MIDPOSX :
-		lev_fieldx - SCR_FIELDX + 1);
-  if (local_player->jy >= MIDPOSY-1)
-    scroll_y = (local_player->jy <= lev_fieldy-MIDPOSY ?
+		SBX_Right);
+  if (local_player->jy >= SBY_Upper + MIDPOSY)
+    scroll_y = (local_player->jy <= SBY_Lower + MIDPOSY ?
 		local_player->jy - MIDPOSY :
-		lev_fieldy - SCR_FIELDY + 1);
+		SBY_Lower);
 
   CloseDoor(DOOR_CLOSE_1);
 
@@ -559,49 +848,59 @@ void InitGame()
   DrawAllPlayers();
   FadeToFront();
 
-  XCopyArea(display, pix[PIX_DOOR], pix[PIX_DB_DOOR], gc,
-	    DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE,
-	    DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
-  DrawTextExt(pix[PIX_DB_DOOR], gc,
-	      DOOR_GFX_PAGEX1 + XX_LEVEL, DOOR_GFX_PAGEY1 + YY_LEVEL,
-	      int2str(level_nr, 2), FS_SMALL, FC_YELLOW);
-  DrawTextExt(pix[PIX_DB_DOOR], gc,
-	      DOOR_GFX_PAGEX1 + XX_EMERALDS, DOOR_GFX_PAGEY1 + YY_EMERALDS,
-	      int2str(local_player->gems_still_needed,3), FS_SMALL, FC_YELLOW);
-  DrawTextExt(pix[PIX_DB_DOOR], gc,
-	      DOOR_GFX_PAGEX1 + XX_DYNAMITE, DOOR_GFX_PAGEY1 + YY_DYNAMITE,
-	      int2str(local_player->dynamite, 3), FS_SMALL, FC_YELLOW);
-  DrawTextExt(pix[PIX_DB_DOOR], gc,
-	      DOOR_GFX_PAGEX1 + XX_SCORE, DOOR_GFX_PAGEY1 + YY_SCORE,
-	      int2str(local_player->score, 5), FS_SMALL, FC_YELLOW);
-  DrawTextExt(pix[PIX_DB_DOOR], gc,
-	      DOOR_GFX_PAGEX1 + XX_TIME, DOOR_GFX_PAGEY1 + YY_TIME,
-	      int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
-
-  DrawGameButton(BUTTON_GAME_STOP);
-  DrawGameButton(BUTTON_GAME_PAUSE);
-  DrawGameButton(BUTTON_GAME_PLAY);
-  DrawSoundDisplay(BUTTON_SOUND_MUSIC  | (setup.sound_music  ? BUTTON_ON : 0));
-  DrawSoundDisplay(BUTTON_SOUND_LOOPS  | (setup.sound_loops  ? BUTTON_ON : 0));
-  DrawSoundDisplay(BUTTON_SOUND_SIMPLE | (setup.sound_simple ? BUTTON_ON : 0));
-  XCopyArea(display, drawto, pix[PIX_DB_DOOR], gc,
-	    DX + GAME_CONTROL_XPOS, DY + GAME_CONTROL_YPOS,
-	    GAME_CONTROL_XSIZE, 2 * GAME_CONTROL_YSIZE,
-	    DOOR_GFX_PAGEX1 + GAME_CONTROL_XPOS,
-	    DOOR_GFX_PAGEY1 + GAME_CONTROL_YPOS);
-
-  OpenDoor(DOOR_OPEN_1);
+  /* after drawing the level, correct some elements */
+  if (game.timegate_time_left == 0)
+    CloseAllOpenTimegates();
+
+  if (setup.soft_scrolling)
+    BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
+
+  redraw_mask |= REDRAW_FROM_BACKBUFFER;
+
+  /* copy default game door content to main double buffer */
+  BlitBitmap(pix[PIX_DOOR], drawto,
+	     DOOR_GFX_PAGEX5, DOOR_GFX_PAGEY1, DXSIZE, DYSIZE, DX, DY);
+
+  if (level_nr < 100)
+    DrawText(DX + XX_LEVEL, DY + YY_LEVEL,
+	     int2str(level_nr, 2), FS_SMALL, FC_YELLOW);
+  else
+  {
+    DrawTextExt(drawto, DX + XX_EMERALDS, DY + YY_EMERALDS,
+		int2str(level_nr, 3), FS_SMALL, FC_SPECIAL3);
+    BlitBitmap(drawto, drawto,
+	       DX + XX_EMERALDS, DY + YY_EMERALDS + 1,
+	       FONT5_XSIZE * 3, FONT5_YSIZE - 1,
+	       DX + XX_LEVEL - 1, DY + YY_LEVEL + 1);
+  }
+
+  DrawGameDoorValues();
+
+  UnmapGameButtons();
+  UnmapTapeButtons();
+  game_gadget[SOUND_CTRL_ID_MUSIC]->checked = setup.sound_music;
+  game_gadget[SOUND_CTRL_ID_LOOPS]->checked = setup.sound_loops;
+  game_gadget[SOUND_CTRL_ID_SIMPLE]->checked = setup.sound_simple;
+  MapGameButtons();
+  MapTapeButtons();
+
+  /* copy actual game door content to door double buffer for OpenDoor() */
+  BlitBitmap(drawto, pix[PIX_DB_DOOR],
+	     DX, DY, DXSIZE, DYSIZE, DOOR_GFX_PAGEX1, DOOR_GFX_PAGEY1);
+
+  OpenDoor(DOOR_OPEN_ALL);
 
+  PlaySoundStereo(SND_GAME_STARTING, PSND_MAX_RIGHT);
   if (setup.sound_music)
-    PlaySoundLoop(background_loop[level_nr % num_bg_loops]);
+    PlayMusic(level_nr);
 
-  XAutoRepeatOff(display);
+  KeyboardAutoRepeatOff();
 
-  if (options.verbose)
+  if (options.debug)
   {
     for (i=0; i<4; i++)
-      printf("Spieler %d %saktiv.\n",
-	     i+1, (stored_player[i].active ? "" : "nicht "));
+      printf("Player %d %sactive.\n",
+	     i + 1, (stored_player[i].active ? "" : "not "));
   }
 }
 
@@ -615,52 +914,53 @@ void InitMovDir(int x, int y)
     {  0, -1 },
     { -1,  0 }
   };
-  static int direction[2][4] =
+  static int direction[3][4] =
   {
     { MV_RIGHT, MV_UP,   MV_LEFT,  MV_DOWN },
-    { MV_LEFT,  MV_DOWN, MV_RIGHT, MV_UP }
+    { MV_LEFT,  MV_DOWN, MV_RIGHT, MV_UP },
+    { MV_LEFT,  MV_RIGHT, MV_UP, MV_DOWN }
   };
 
   switch(element)
   {
-    case EL_KAEFER_R:
-    case EL_KAEFER_O:
-    case EL_KAEFER_L:
-    case EL_KAEFER_U:
+    case EL_KAEFER_RIGHT:
+    case EL_KAEFER_UP:
+    case EL_KAEFER_LEFT:
+    case EL_KAEFER_DOWN:
       Feld[x][y] = EL_KAEFER;
-      MovDir[x][y] = direction[0][element - EL_KAEFER_R];
+      MovDir[x][y] = direction[0][element - EL_KAEFER_RIGHT];
       break;
 
-    case EL_FLIEGER_R:
-    case EL_FLIEGER_O:
-    case EL_FLIEGER_L:
-    case EL_FLIEGER_U:
+    case EL_FLIEGER_RIGHT:
+    case EL_FLIEGER_UP:
+    case EL_FLIEGER_LEFT:
+    case EL_FLIEGER_DOWN:
       Feld[x][y] = EL_FLIEGER;
-      MovDir[x][y] = direction[0][element - EL_FLIEGER_R];
+      MovDir[x][y] = direction[0][element - EL_FLIEGER_RIGHT];
       break;
 
-    case EL_BUTTERFLY_R:
-    case EL_BUTTERFLY_O:
-    case EL_BUTTERFLY_L:
-    case EL_BUTTERFLY_U:
+    case EL_BUTTERFLY_RIGHT:
+    case EL_BUTTERFLY_UP:
+    case EL_BUTTERFLY_LEFT:
+    case EL_BUTTERFLY_DOWN:
       Feld[x][y] = EL_BUTTERFLY;
-      MovDir[x][y] = direction[0][element - EL_BUTTERFLY_R];
+      MovDir[x][y] = direction[0][element - EL_BUTTERFLY_RIGHT];
       break;
 
-    case EL_FIREFLY_R:
-    case EL_FIREFLY_O:
-    case EL_FIREFLY_L:
-    case EL_FIREFLY_U:
+    case EL_FIREFLY_RIGHT:
+    case EL_FIREFLY_UP:
+    case EL_FIREFLY_LEFT:
+    case EL_FIREFLY_DOWN:
       Feld[x][y] = EL_FIREFLY;
-      MovDir[x][y] = direction[0][element - EL_FIREFLY_R];
+      MovDir[x][y] = direction[0][element - EL_FIREFLY_RIGHT];
       break;
 
-    case EL_PACMAN_R:
-    case EL_PACMAN_O:
-    case EL_PACMAN_L:
-    case EL_PACMAN_U:
+    case EL_PACMAN_RIGHT:
+    case EL_PACMAN_UP:
+    case EL_PACMAN_LEFT:
+    case EL_PACMAN_DOWN:
       Feld[x][y] = EL_PACMAN;
-      MovDir[x][y] = direction[0][element - EL_PACMAN_R];
+      MovDir[x][y] = direction[0][element - EL_PACMAN_RIGHT];
       break;
 
     case EL_SP_SNIKSNAK:
@@ -671,6 +971,14 @@ void InitMovDir(int x, int y)
       MovDir[x][y] = MV_LEFT;
       break;
 
+    case EL_MOLE_LEFT:
+    case EL_MOLE_RIGHT:
+    case EL_MOLE_UP:
+    case EL_MOLE_DOWN:
+      Feld[x][y] = EL_MOLE;
+      MovDir[x][y] = direction[2][element - EL_MOLE_LEFT];
+      break;
+
     default:
       MovDir[x][y] = 1 << RND(4);
       if (element != EL_KAEFER &&
@@ -728,23 +1036,26 @@ void InitAmoebaNr(int x, int y)
 void GameWon()
 {
   int hi_pos;
-  int bumplevel = FALSE;
+  boolean raise_level = FALSE;
 
   if (local_player->MovPos)
     return;
 
   local_player->LevelSolved = FALSE;
 
+  PlaySoundStereo(SND_GAME_WINNING, PSND_MAX_RIGHT);
+
   if (TimeLeft)
   {
-    if (setup.sound_loops)
-      PlaySoundExt(SND_SIRR, PSND_MAX_VOLUME, PSND_MAX_RIGHT, PSND_LOOP);
+    if (!tape.playing && setup.sound_loops)
+      PlaySoundExt(SND_GAME_LEVELTIME_BONUS, PSND_MAX_VOLUME, PSND_MAX_RIGHT,
+		   SND_CTRL_PLAY_LOOP);
 
-    while(TimeLeft > 0)
+    while (TimeLeft > 0)
     {
-      if (!setup.sound_loops)
-	PlaySoundStereo(SND_SIRR, PSND_MAX_RIGHT);
-      if (TimeLeft && !(TimeLeft % 10))
+      if (!tape.playing && !setup.sound_loops)
+	PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, PSND_MAX_RIGHT);
+      if (TimeLeft > 0 && !(TimeLeft % 10))
 	RaiseScore(level.score[SC_ZEITBONUS]);
       if (TimeLeft > 100 && !(TimeLeft % 10))
 	TimeLeft -= 10;
@@ -752,14 +1063,44 @@ void GameWon()
 	TimeLeft--;
       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
       BackToFront();
-      Delay(10);
+
+      if (!tape.playing)
+	Delay(10);
+    }
+
+    if (!tape.playing && setup.sound_loops)
+      StopSound(SND_GAME_LEVELTIME_BONUS);
+  }
+  else if (level.time == 0)		/* level without time limit */
+  {
+    if (!tape.playing && setup.sound_loops)
+      PlaySoundExt(SND_GAME_LEVELTIME_BONUS, PSND_MAX_VOLUME, PSND_MAX_RIGHT,
+		   SND_CTRL_PLAY_LOOP);
+
+    while (TimePlayed < 999)
+    {
+      if (!tape.playing && !setup.sound_loops)
+	PlaySoundStereo(SND_GAME_LEVELTIME_BONUS, PSND_MAX_RIGHT);
+      if (TimePlayed < 999 && !(TimePlayed % 10))
+	RaiseScore(level.score[SC_ZEITBONUS]);
+      if (TimePlayed < 900 && !(TimePlayed % 10))
+	TimePlayed += 10;
+      else
+	TimePlayed++;
+      DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FS_SMALL, FC_YELLOW);
+      BackToFront();
+
+      if (!tape.playing)
+	Delay(10);
     }
 
-    if (setup.sound_loops)
-      StopSound(SND_SIRR);
+    if (!tape.playing && setup.sound_loops)
+      StopSound(SND_GAME_LEVELTIME_BONUS);
   }
 
+#if 0
   FadeSounds();
+#endif
 
   /* Hero disappears */
   DrawLevelField(ExitX, ExitY);
@@ -776,25 +1117,42 @@ void GameWon()
     SaveTape(tape.level_nr);		/* Ask to save tape */
   }
 
+  if (level_nr == leveldir_current->handicap_level)
+  {
+    leveldir_current->handicap_level++;
+    SaveLevelSetup_SeriesInfo();
+  }
+
+  if (level_editor_test_game)
+    local_player->score = -1;	/* no highscore when playing from editor */
+  else if (level_nr < leveldir_current->last_level)
+    raise_level = TRUE;		/* advance to next level */
+
   if ((hi_pos = NewHiScore()) >= 0) 
   {
     game_status = HALLOFFAME;
     DrawHallOfFame(hi_pos);
-    if (bumplevel && TAPE_IS_EMPTY(tape))
+    if (raise_level)
+    {
       level_nr++;
+      TapeErase();
+    }
   }
   else
   {
     game_status = MAINMENU;
-    if (bumplevel && TAPE_IS_EMPTY(tape))
+    if (raise_level)
+    {
       level_nr++;
+      TapeErase();
+    }
     DrawMainMenu();
   }
 
   BackToFront();
 }
 
-boolean NewHiScore()
+int NewHiScore()
 {
   int k, l;
   int position = -1;
@@ -833,15 +1191,16 @@ boolean NewHiScore()
 #ifdef ONE_PER_NAME
       put_into_list:
 #endif
-      strncpy(highscore[k].Name, setup.player_name, MAX_NAMELEN - 1);
-      highscore[k].Name[MAX_NAMELEN - 1] = '\0';
+      strncpy(highscore[k].Name, setup.player_name, MAX_PLAYER_NAME_LEN);
+      highscore[k].Name[MAX_PLAYER_NAME_LEN] = '\0';
       highscore[k].Score = local_player->score; 
       position = k;
       break;
     }
 
 #ifdef ONE_PER_NAME
-    else if (!strncmp(setup.player_name, highscore[k].Name, MAX_NAMELEN - 1))
+    else if (!strncmp(setup.player_name, highscore[k].Name,
+		      MAX_PLAYER_NAME_LEN))
       break;	/* player already there with a higher score */
 #endif
 
@@ -907,6 +1266,29 @@ int MovingOrBlocked2Element(int x, int y)
     return element;
 }
 
+static int MovingOrBlocked2ElementIfNotLeaving(int x, int y)
+{
+  /* like MovingOrBlocked2Element(), but if element is moving
+     and (x,y) is the field the moving element is just leaving,
+     return EL_BLOCKED instead of the element value */
+  int element = Feld[x][y];
+
+  if (IS_MOVING(x, y))
+  {
+    if (element == EL_BLOCKED)
+    {
+      int oldx, oldy;
+
+      Blocked2Moving(x, y, &oldx, &oldy);
+      return Feld[oldx][oldy];
+    }
+    else
+      return EL_BLOCKED;
+  }
+  else
+    return element;
+}
+
 static void RemoveField(int x, int y)
 {
   Feld[x][y] = EL_LEERRAUM;
@@ -936,17 +1318,16 @@ void RemoveMovingField(int x, int y)
   }
 
   if (Feld[x][y] == EL_BLOCKED &&
-      (Store[oldx][oldy] == EL_MORAST_LEER ||
-       Store[oldx][oldy] == EL_SIEB_LEER ||
-       Store[oldx][oldy] == EL_SIEB2_LEER ||
-       Store[oldx][oldy] == EL_AMOEBE_NASS))
-  {
-    Feld[oldx][oldy] = Store[oldx][oldy];
-    Store[oldx][oldy] = Store2[oldx][oldy] = 0;
-  }
+      (Feld[oldx][oldy] == EL_QUICKSAND_EMPTYING ||
+       Feld[oldx][oldy] == EL_MAGIC_WALL_EMPTYING ||
+       Feld[oldx][oldy] == EL_MAGIC_WALL_BD_EMPTYING ||
+       Feld[oldx][oldy] == EL_AMOEBA_DRIPPING))
+    Feld[oldx][oldy] = get_next_element(Feld[oldx][oldy]);
   else
     Feld[oldx][oldy] = EL_LEERRAUM;
 
+  Store[oldx][oldy] = Store2[oldx][oldy] = 0;
+
   Feld[newx][newy] = EL_LEERRAUM;
   MovPos[oldx][oldy] = MovDir[oldx][oldy] = MovDelay[oldx][oldy] = 0;
   MovPos[newx][newy] = MovDir[newx][newy] = MovDelay[newx][newy] = 0;
@@ -967,7 +1348,7 @@ void DrawDynamite(int x, int y)
   if (Store[x][y])
     DrawGraphic(sx, sy, el2gfx(Store[x][y]));
 
-  if (Feld[x][y] == EL_DYNAMIT)
+  if (Feld[x][y] == EL_DYNAMITE_ACTIVE)
   {
     if ((phase = (96 - MovDelay[x][y]) / 12) > 6)
       phase = 6;
@@ -978,7 +1359,9 @@ void DrawDynamite(int x, int y)
       phase = 7 - phase;
   }
 
-  if (Store[x][y])
+  if (game.emulation == EMU_SUPAPLEX)
+    DrawGraphic(sx, sy, GFX_SP_DISK_RED);
+  else if (Store[x][y])
     DrawGraphicThruMask(sx, sy, graphic + phase);
   else
     DrawGraphic(sx, sy, graphic + phase);
@@ -992,27 +1375,46 @@ void CheckDynamite(int x, int y)
     if (MovDelay[x][y])
     {
       if (!(MovDelay[x][y] % 12))
-	PlaySoundLevel(x, y, SND_ZISCH);
+      {
+	if (Feld[x][y] == EL_DYNAMITE_ACTIVE)
+	  PlaySoundLevel(x, y, SND_DYNAMITE_BURNING);
+	else
+	  PlaySoundLevel(x, y, SND_DYNABOMB_BURNING);
+      }
+
+      if (IS_ACTIVE_BOMB(Feld[x][y]))
+      {
+	int delay = (Feld[x][y] == EL_DYNAMITE_ACTIVE ? 12 : 6);
 
-      if (Feld[x][y] == EL_DYNAMIT && !(MovDelay[x][y] % 12))
-	DrawDynamite(x, y);
-      else if (Feld[x][y] == EL_DYNABOMB && !(MovDelay[x][y] % 6))
-	DrawDynamite(x, y);
+	if (!(MovDelay[x][y] % delay))
+	  DrawDynamite(x, y);
+      }
 
       return;
     }
   }
 
-  StopSound(SND_ZISCH);
+  if (Feld[x][y] == EL_DYNAMITE_ACTIVE)
+    StopSound(SND_DYNAMITE_BURNING);
+  else
+    StopSound(SND_DYNABOMB_BURNING);
+
   Bang(x, y);
 }
 
 void Explode(int ex, int ey, int phase, int mode)
 {
   int x, y;
-  int num_phase = 9, delay = 2;
+  int num_phase = 9, delay = (game.emulation == EMU_SUPAPLEX ? 3 : 2);
   int last_phase = num_phase * delay;
   int half_phase = (num_phase / 2) * delay;
+  int first_phase_after_start = EX_PHASE_START + 1;
+
+  if (game.explosions_delayed)
+  {
+    ExplodeField[ex][ey] = mode;
+    return;
+  }
 
   if (phase == EX_PHASE_START)		/* initialize 'Store[][]' field */
   {
@@ -1020,13 +1422,22 @@ void Explode(int ex, int ey, int phase, int mode)
 
     if (IS_MOVING(ex, ey) || IS_BLOCKED(ex, ey))
     {
+      /* put moving element to center field (and let it explode there) */
       center_element = MovingOrBlocked2Element(ex, ey);
       RemoveMovingField(ex, ey);
+      Feld[ex][ey] = center_element;
     }
 
-    for (y=ey-1; y<ey+2; y++) for(x=ex-1; x<ex+2; x++)
+    for (y=ey-1; y<=ey+1; y++) for(x=ex-1; x<=ex+1; x++)
     {
-      int element = Feld[x][y];
+      int element;
+
+      if (!IN_LEV_FIELD(x, y) ||
+	  ((mode != EX_NORMAL || center_element == EL_AMOEBA2DIAM) &&
+	   (x != ex || y != ey)))
+	continue;
+
+      element = Feld[x][y];
 
       if (IS_MOVING(x, y) || IS_BLOCKED(x, y))
       {
@@ -1034,17 +1445,25 @@ void Explode(int ex, int ey, int phase, int mode)
 	RemoveMovingField(x, y);
       }
 
-      if (!IN_LEV_FIELD(x, y) || IS_MASSIV(element) || element == EL_BURNING)
+      if (IS_MASSIVE(element) || element == EL_BURNING)
 	continue;
 
-      if ((mode!=EX_NORMAL || center_element == EL_AMOEBA2DIAM) &&
-	  (x!=ex || y!=ey))
+      if (IS_PLAYER(x, y) && SHIELD_ON(PLAYERINFO(x, y)))
+      {
+	if (IS_ACTIVE_BOMB(element))
+	{
+	  /* re-activate things under the bomb like gate or penguin */
+	  Feld[x][y] = (Store[x][y] ? Store[x][y] : EL_LEERRAUM);
+	  Store[x][y] = 0;
+	}
+
 	continue;
+      }
 
       if (element == EL_EXPLODING)
 	element = Store2[x][y];
 
-      if (IS_PLAYER(ex, ey))
+      if (IS_PLAYER(ex, ey) && !PLAYER_PROTECTED(ex, ey))
       {
 	switch(StorePlayer[ex][ey])
 	{
@@ -1063,10 +1482,10 @@ void Explode(int ex, int ey, int phase, int mode)
 	    break;
 	}
 
-	if (game_emulation == EMU_SUPAPLEX)
+	if (game.emulation == EMU_SUPAPLEX)
 	  Store[x][y] = EL_LEERRAUM;
       }
-      else if (center_element == EL_MAULWURF)
+      else if (center_element == EL_MOLE)
 	Store[x][y] = EL_EDELSTEIN_ROT;
       else if (center_element == EL_PINGUIN)
 	Store[x][y] = EL_EDELSTEIN_LILA;
@@ -1077,9 +1496,9 @@ void Explode(int ex, int ey, int phase, int mode)
       else if (center_element == EL_SP_ELECTRON)
 	Store[x][y] = EL_SP_INFOTRON;
       else if (center_element == EL_MAMPFER)
-	Store[x][y] = level.mampfer_inhalt[MampferNr][x-ex+1][y-ey+1];
+	Store[x][y] = level.yam_content[game.yam_content_nr][x-ex+1][y-ey+1];
       else if (center_element == EL_AMOEBA2DIAM)
-	Store[x][y] = level.amoebe_inhalt;
+	Store[x][y] = level.amoeba_content;
       else if (element == EL_ERZ_EDEL)
 	Store[x][y] = EL_EDELSTEIN;
       else if (element == EL_ERZ_DIAM)
@@ -1092,6 +1511,10 @@ void Explode(int ex, int ey, int phase, int mode)
 	Store[x][y] = EL_EDELSTEIN_ROT;
       else if (element == EL_ERZ_EDEL_LILA)
 	Store[x][y] = EL_EDELSTEIN_LILA;
+      else if (element == EL_WALL_PEARL)
+	Store[x][y] = EL_PEARL;
+      else if (element == EL_WALL_CRYSTAL)
+	Store[x][y] = EL_CRYSTAL;
       else if (!IS_PFORTE(Store[x][y]))
 	Store[x][y] = EL_LEERRAUM;
 
@@ -1116,7 +1539,7 @@ void Explode(int ex, int ey, int phase, int mode)
     }
 
     if (center_element == EL_MAMPFER)
-      MampferNr = (MampferNr + 1) % MampferMax;
+      game.yam_content_nr = (game.yam_content_nr + 1) % level.num_yam_contents;
 
     return;
   }
@@ -1127,14 +1550,25 @@ void Explode(int ex, int ey, int phase, int mode)
   x = ex;
   y = ey;
 
-  Frame[x][y] = (phase<last_phase ? phase+1 : 0);
+  Frame[x][y] = (phase < last_phase ? phase + 1 : 0);
+
+  if (phase == first_phase_after_start)
+  {
+    int element = Store2[x][y];
 
-  if (phase == half_phase)
+    if (element == EL_BLACK_ORB)
+    {
+      Feld[x][y] = Store2[x][y];
+      Store2[x][y] = 0;
+      Bang(x, y);
+    }
+  }
+  else if (phase == half_phase)
   {
     int element = Store2[x][y];
 
     if (IS_PLAYER(x, y))
-      KillHero(PLAYERINFO(x, y));
+      KillHeroUnlessProtected(x, y);
     else if (IS_EXPLOSIVE(element))
     {
       Feld[x][y] = Store2[x][y];
@@ -1156,12 +1590,15 @@ void Explode(int ex, int ey, int phase, int mode)
     if (CAN_MOVE(element) || COULD_MOVE(element))
       InitMovDir(x, y);
     DrawLevelField(x, y);
+
+    if (IS_PLAYER(x, y) && !PLAYERINFO(x,y)->present)
+      StorePlayer[x][y] = 0;
   }
   else if (!(phase % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
   {
     int graphic = GFX_EXPLOSION;
 
-    if (game_emulation == EMU_SUPAPLEX)
+    if (game.emulation == EMU_SUPAPLEX)
       graphic = (Store[x][y] == EL_SP_INFOTRON ?
 		 GFX_SP_EXPLODE_INFOTRON :
 		 GFX_SP_EXPLODE_EMPTY);
@@ -1169,14 +1606,24 @@ void Explode(int ex, int ey, int phase, int mode)
     if (phase == delay)
       ErdreichAnbroeckeln(SCREENX(x), SCREENY(y));
 
-    DrawGraphic(SCREENX(x), SCREENY(y), graphic + (phase / delay - 1));
+    graphic += (phase / delay - 1);
+
+    if (IS_PFORTE(Store[x][y]))
+    {
+      DrawLevelElement(x, y, Store[x][y]);
+      DrawGraphicThruMask(SCREENX(x), SCREENY(y), graphic);
+    }
+    else
+      DrawGraphic(SCREENX(x), SCREENY(y), graphic);
   }
 }
 
 void DynaExplode(int ex, int ey)
 {
   int i, j;
-  struct PlayerInfo *player = &stored_player[Store2[ex][ey] - EL_SPIELER1];
+  int dynabomb_size = 1;
+  boolean dynabomb_xl = FALSE;
+  struct PlayerInfo *player;
   static int xy[4][2] =
   {
     { 0, -1 },
@@ -1185,43 +1632,57 @@ void DynaExplode(int ex, int ey)
     { 0, +1 }
   };
 
-  Store2[ex][ey] = 0;	/* delete player information */
+  if (IS_ACTIVE_BOMB(Feld[ex][ey]))
+  {
+    player = &stored_player[Feld[ex][ey] - EL_DYNABOMB_ACTIVE_1];
+    dynabomb_size = player->dynabomb_size;
+    dynabomb_xl = player->dynabomb_xl;
+    player->dynabombs_left++;
+  }
 
   Explode(ex, ey, EX_PHASE_START, EX_CENTER);
 
   for (i=0; i<4; i++)
   {
-    for (j=1; j<=player->dynabomb_size; j++)
+    for (j=1; j<=dynabomb_size; j++)
     {
-      int x = ex+j*xy[i%4][0];
-      int y = ey+j*xy[i%4][1];
+      int x = ex + j * xy[i % 4][0];
+      int y = ey + j * xy[i % 4][1];
       int element;
 
-      if (!IN_LEV_FIELD(x, y) || IS_MASSIV(Feld[x][y]))
+      if (!IN_LEV_FIELD(x, y) || IS_MASSIVE(Feld[x][y]))
 	break;
 
       element = Feld[x][y];
+
+      /* do not restart explosions of fields with active bombs */
+      if (element == EL_EXPLODING && IS_ACTIVE_BOMB(Store2[x][y]))
+	continue;
+
       Explode(x, y, EX_PHASE_START, EX_BORDER);
 
       if (element != EL_LEERRAUM &&
 	  element != EL_ERDREICH &&
 	  element != EL_EXPLODING &&
-	  !player->dynabomb_xl)
+	  !dynabomb_xl)
 	break;
     }
   }
-
-  player->dynabombs_left++;
 }
 
 void Bang(int x, int y)
 {
   int element = Feld[x][y];
 
-  PlaySoundLevel(x, y, SND_ROAAAR);
+  if (game.emulation == EMU_SUPAPLEX)
+    PlaySoundLevel(x, y, SND_SP_ELEMENT_EXPLODING);
+  else
+    PlaySoundLevel(x, y, SND_ELEMENT_EXPLODING);
 
+#if 0
   if (IS_PLAYER(x, y))	/* remove objects that might cause smaller explosion */
     element = EL_LEERRAUM;
+#endif
 
   switch(element)
   {
@@ -1233,20 +1694,26 @@ void Bang(int x, int y)
     case EL_MAMPFER2:
     case EL_ROBOT:
     case EL_PACMAN:
+    case EL_MOLE:
       RaiseScoreElement(element);
       Explode(x, y, EX_PHASE_START, EX_NORMAL);
       break;
-    case EL_DYNABOMB:
+    case EL_DYNABOMB_ACTIVE_1:
+    case EL_DYNABOMB_ACTIVE_2:
+    case EL_DYNABOMB_ACTIVE_3:
+    case EL_DYNABOMB_ACTIVE_4:
     case EL_DYNABOMB_NR:
     case EL_DYNABOMB_SZ:
     case EL_DYNABOMB_XL:
       DynaExplode(x, y);
       break;
-    case EL_MAULWURF:
     case EL_PINGUIN:
     case EL_BIRNE_AUS:
     case EL_BIRNE_EIN:
-      Explode(x, y, EX_PHASE_START, EX_CENTER);
+      if (IS_PLAYER(x, y))
+	Explode(x, y, EX_PHASE_START, EX_NORMAL);
+      else
+	Explode(x, y, EX_PHASE_START, EX_CENTER);
       break;
     default:
       Explode(x, y, EX_PHASE_START, EX_NORMAL);
@@ -1260,7 +1727,7 @@ void Blurb(int x, int y)
 
   if (element != EL_BLURB_LEFT && element != EL_BLURB_RIGHT)	/* start */
   {
-    PlaySoundLevel(x, y, SND_BLURB);
+    PlaySoundLevel(x, y, SND_ACID_SPLASHING);
     if (IN_LEV_FIELD(x-1, y) && IS_FREE(x-1, y) &&
 	(!IN_LEV_FIELD(x-1, y-1) ||
 	 !CAN_FALL(MovingOrBlocked2Element(x-1, y-1))))
@@ -1296,43 +1763,219 @@ void Blurb(int x, int y)
   }
 }
 
-void Impact(int x, int y)
+static void ToggleBeltSwitch(int x, int y)
 {
-  boolean lastline = (y == lev_fieldy-1);
-  boolean object_hit = FALSE;
-  int element = Feld[x][y];
-  int smashed = 0;
-
-  if (!lastline)	/* check if element below was hit */
+  static int belt_base_element[4] =
   {
-    if (Feld[x][y+1] == EL_PLAYER_IS_LEAVING)
-      return;
+    EL_BELT1_SWITCH_LEFT,
+    EL_BELT2_SWITCH_LEFT,
+    EL_BELT3_SWITCH_LEFT,
+    EL_BELT4_SWITCH_LEFT
+  };
+  static int belt_move_dir[4] =
+  {
+    MV_LEFT,
+    MV_NO_MOVING,
+    MV_RIGHT,
+    MV_NO_MOVING,
+  };
 
-    object_hit = (!IS_FREE(x, y+1) && (!IS_MOVING(x, y+1) ||
-				      MovDir[x][y+1]!=MV_DOWN ||
-				      MovPos[x][y+1]<=TILEY/2));
-    if (object_hit)
-      smashed = MovingOrBlocked2Element(x, y+1);
-  }
+  int element = Feld[x][y];
+  int belt_nr = getBeltNrFromSwitchElement(element);
+  int belt_dir_nr = (game.belt_dir_nr[belt_nr] + 1) % 4;
+  int belt_dir = belt_move_dir[belt_dir_nr];
+  int xx, yy;
 
-  if (!lastline && smashed == EL_SALZSAEURE)	/* element falls into acid */
-  {
-    Blurb(x, y);
+  if (!IS_BELT_SWITCH(element))
     return;
-  }
 
-  if ((element == EL_BOMBE || element == EL_SP_DISK_ORANGE) &&
+  game.belt_dir_nr[belt_nr] = belt_dir_nr;
+  game.belt_dir[belt_nr] = belt_dir;
+
+  if (belt_dir_nr == 3)
+    belt_dir_nr = 1;
+
+  for (yy=0; yy<lev_fieldy; yy++)
+  {
+    for (xx=0; xx<lev_fieldx; xx++)
+    {
+      int element = Feld[xx][yy];
+
+      if (IS_BELT_SWITCH(element))
+      {
+	int e_belt_nr = getBeltNrFromSwitchElement(element);
+
+	if (e_belt_nr == belt_nr)
+	{
+	  Feld[xx][yy] = belt_base_element[belt_nr] + belt_dir_nr;
+	  DrawLevelField(xx, yy);
+	}
+      }
+      else if (belt_dir == MV_NO_MOVING && IS_BELT(element))
+      {
+	int e_belt_nr = getBeltNrFromElement(element);
+
+	if (e_belt_nr == belt_nr)
+	  DrawLevelField(xx, yy);    /* set belt to parking position */
+      }
+    }
+  }
+}
+
+static void ToggleSwitchgateSwitch(int x, int y)
+{
+  int xx, yy;
+
+  game.switchgate_pos = !game.switchgate_pos;
+
+  for (yy=0; yy<lev_fieldy; yy++)
+  {
+    for (xx=0; xx<lev_fieldx; xx++)
+    {
+      int element = Feld[xx][yy];
+
+      if (element == EL_SWITCHGATE_SWITCH_1 ||
+	  element == EL_SWITCHGATE_SWITCH_2)
+      {
+	Feld[xx][yy] = EL_SWITCHGATE_SWITCH_1 + game.switchgate_pos;
+	DrawLevelField(xx, yy);
+      }
+      else if (element == EL_SWITCHGATE_OPEN ||
+	       element == EL_SWITCHGATE_OPENING)
+      {
+	Feld[xx][yy] = EL_SWITCHGATE_CLOSING;
+	PlaySoundLevel(xx, yy, SND_SWITCHGATE_CLOSING);
+      }
+      else if (element == EL_SWITCHGATE_CLOSED ||
+	       element == EL_SWITCHGATE_CLOSING)
+      {
+	Feld[xx][yy] = EL_SWITCHGATE_OPENING;
+	PlaySoundLevel(xx, yy, SND_SWITCHGATE_OPENING);
+      }
+    }
+  }
+}
+
+static void RedrawAllLightSwitchesAndInvisibleElements()
+{
+  int x, y;
+
+  for (y=0; y<lev_fieldy; y++)
+  {
+    for (x=0; x<lev_fieldx; x++)
+    {
+      int element = Feld[x][y];
+
+      if (element == EL_LIGHT_SWITCH_OFF &&
+	  game.light_time_left > 0)
+      {
+	Feld[x][y] = EL_LIGHT_SWITCH_ON;
+	DrawLevelField(x, y);
+      }
+      else if (element == EL_LIGHT_SWITCH_ON &&
+	       game.light_time_left == 0)
+      {
+	Feld[x][y] = EL_LIGHT_SWITCH_OFF;
+	DrawLevelField(x, y);
+      }
+
+      if (element == EL_INVISIBLE_STEEL ||
+	  element == EL_UNSICHTBAR ||
+	  element == EL_SAND_INVISIBLE)
+	DrawLevelField(x, y);
+    }
+  }
+}
+
+static void ToggleLightSwitch(int x, int y)
+{
+  int element = Feld[x][y];
+
+  game.light_time_left =
+    (element == EL_LIGHT_SWITCH_OFF ?
+     level.time_light * FRAMES_PER_SECOND : 0);
+
+  RedrawAllLightSwitchesAndInvisibleElements();
+}
+
+static void ActivateTimegateSwitch(int x, int y)
+{
+  int xx, yy;
+
+  game.timegate_time_left = level.time_timegate * FRAMES_PER_SECOND;
+
+  for (yy=0; yy<lev_fieldy; yy++)
+  {
+    for (xx=0; xx<lev_fieldx; xx++)
+    {
+      int element = Feld[xx][yy];
+
+      if (element == EL_TIMEGATE_CLOSED ||
+	  element == EL_TIMEGATE_CLOSING)
+      {
+	Feld[xx][yy] = EL_TIMEGATE_OPENING;
+	PlaySoundLevel(xx, yy, SND_TIMEGATE_OPENING);
+      }
+
+      /*
+      else if (element == EL_TIMEGATE_SWITCH_ON)
+      {
+	Feld[xx][yy] = EL_TIMEGATE_SWITCH_OFF;
+	DrawLevelField(xx, yy);
+      }
+      */
+
+    }
+  }
+
+  Feld[x][y] = EL_TIMEGATE_SWITCH_ON;
+}
+
+void Impact(int x, int y)
+{
+  boolean lastline = (y == lev_fieldy-1);
+  boolean object_hit = FALSE;
+  int element = Feld[x][y];
+  int smashed = 0;
+
+  if (!lastline)	/* check if element below was hit */
+  {
+    if (Feld[x][y+1] == EL_PLAYER_IS_LEAVING)
+      return;
+
+    object_hit = (!IS_FREE(x, y+1) && (!IS_MOVING(x, y+1) ||
+				      MovDir[x][y+1]!=MV_DOWN ||
+				      MovPos[x][y+1]<=TILEY/2));
+    if (object_hit)
+      smashed = MovingOrBlocked2Element(x, y+1);
+  }
+
+  if (!lastline && smashed == EL_SALZSAEURE)	/* element falls into acid */
+  {
+    Blurb(x, y);
+    return;
+  }
+
+  if ((element == EL_BOMBE ||
+       element == EL_SP_DISK_ORANGE ||
+       element == EL_DX_SUPABOMB) &&
       (lastline || object_hit))	/* element is bomb */
   {
     Bang(x, y);
     return;
   }
+  else if (element == EL_PEARL)
+  {
+    Feld[x][y] = EL_PEARL_BREAKING;
+    PlaySoundLevel(x, y, SND_PEARL_BREAKING);
+    return;
+  }
 
   if (element == EL_TROPFEN && (lastline || object_hit))	/* acid drop */
   {
     if (object_hit && IS_PLAYER(x, y+1))
-      KillHero(PLAYERINFO(x, y+1));
-    else if (object_hit && (smashed == EL_MAULWURF || smashed == EL_PINGUIN))
+      KillHeroUnlessProtected(x, y+1);
+    else if (object_hit && smashed == EL_PINGUIN)
       Bang(x, y+1);
     else
     {
@@ -1345,29 +1988,33 @@ void Impact(int x, int y)
   if (!lastline && object_hit)		/* check which object was hit */
   {
     if (CAN_CHANGE(element) && 
-	(smashed == EL_SIEB_INAKTIV || smashed == EL_SIEB2_INAKTIV))
+	(smashed == EL_MAGIC_WALL_OFF || smashed == EL_MAGIC_WALL_BD_OFF))
     {
-      int x, y;
+      int xx, yy;
       int activated_magic_wall =
-	(smashed == EL_SIEB_INAKTIV ? EL_SIEB_LEER : EL_SIEB2_LEER);
+	(smashed == EL_MAGIC_WALL_OFF ? EL_MAGIC_WALL_EMPTY :
+	 EL_MAGIC_WALL_BD_EMPTY);
 
       /* activate magic wall / mill */
+      for (yy=0; yy<lev_fieldy; yy++)
+	for (xx=0; xx<lev_fieldx; xx++)
+	  if (Feld[xx][yy] == smashed)
+	    Feld[xx][yy] = activated_magic_wall;
 
-      for (y=0; y<lev_fieldy; y++)
-	for (x=0; x<lev_fieldx; x++)
-	  if (Feld[x][y] == smashed)
-	    Feld[x][y] = activated_magic_wall;
+      game.magic_wall_time_left = level.time_magic_wall * FRAMES_PER_SECOND;
+      game.magic_wall_active = TRUE;
 
-      SiebCount = level.dauer_sieb * FRAMES_PER_SECOND;
-      SiebAktiv = TRUE;
+      PlaySoundLevel(x, y, (smashed == EL_MAGIC_WALL_OFF ?
+			    SND_MAGIC_WALL_ACTIVATING :
+			    SND_BD_MAGIC_WALL_ACTIVATING));
     }
 
     if (IS_PLAYER(x, y+1))
     {
-      KillHero(PLAYERINFO(x, y+1));
+      KillHeroUnlessProtected(x, y+1);
       return;
     }
-    else if (smashed == EL_MAULWURF || smashed == EL_PINGUIN)
+    else if (smashed == EL_PINGUIN)
     {
       Bang(x, y+1);
       return;
@@ -1380,11 +2027,22 @@ void Impact(int x, int y)
 	return;
       }
     }
-    else if (element == EL_FELSBROCKEN || element == EL_SP_ZONK)
+    else if ((element == EL_SP_INFOTRON || element == EL_SP_ZONK) &&
+	     (smashed == EL_SP_SNIKSNAK || smashed == EL_SP_ELECTRON ||
+	      smashed == EL_SP_DISK_ORANGE))
+    {
+      Bang(x, y+1);
+      return;
+    }
+    else if (element == EL_FELSBROCKEN ||
+	     element == EL_SP_ZONK ||
+	     element == EL_BD_ROCK)
     {
       if (IS_ENEMY(smashed) ||
 	  smashed == EL_BOMBE || smashed == EL_SP_DISK_ORANGE ||
-	  smashed == EL_SONDE || smashed == EL_SCHWEIN || smashed == EL_DRACHE)
+	  smashed == EL_DX_SUPABOMB ||
+	  smashed == EL_SONDE || smashed == EL_SCHWEIN ||
+	  smashed == EL_DRACHE || smashed == EL_MOLE)
       {
 	Bang(x, y+1);
 	return;
@@ -1399,25 +2057,50 @@ void Impact(int x, int y)
 	else if (smashed == EL_KOKOSNUSS)
 	{
 	  Feld[x][y+1] = EL_CRACKINGNUT;
-	  PlaySoundLevel(x, y, SND_KNACK);
+	  PlaySoundLevel(x, y, SND_NUT_CRACKING);
 	  RaiseScoreElement(EL_KOKOSNUSS);
 	  return;
 	}
+	else if (smashed == EL_PEARL)
+	{
+	  Feld[x][y+1] = EL_PEARL_BREAKING;
+	  PlaySoundLevel(x, y, SND_PEARL_BREAKING);
+	  return;
+	}
 	else if (smashed == EL_DIAMANT)
 	{
 	  Feld[x][y+1] = EL_LEERRAUM;
-	  PlaySoundLevel(x, y, SND_QUIRK);
+	  PlaySoundLevel(x, y, SND_DIAMOND_BREAKING);
 	  return;
 	}
+	else if (IS_BELT_SWITCH(smashed))
+	{
+	  ToggleBeltSwitch(x, y+1);
+	}
+	else if (smashed == EL_SWITCHGATE_SWITCH_1 ||
+		 smashed == EL_SWITCHGATE_SWITCH_2)
+	{
+	  ToggleSwitchgateSwitch(x, y+1);
+	}
+	else if (smashed == EL_LIGHT_SWITCH_OFF ||
+		 smashed == EL_LIGHT_SWITCH_ON)
+	{
+	  ToggleLightSwitch(x, y+1);
+	}
       }
     }
   }
 
   /* play sound of magic wall / mill */
   if (!lastline &&
-      (Feld[x][y+1] == EL_SIEB_LEER || Feld[x][y+1] == EL_SIEB2_LEER))
+      (Feld[x][y+1] == EL_MAGIC_WALL_EMPTY ||
+       Feld[x][y+1] == EL_MAGIC_WALL_BD_EMPTY))
   {
-    PlaySoundLevel(x, y, SND_QUIRK);
+    if (Feld[x][y+1] == EL_MAGIC_WALL_EMPTY)
+      PlaySoundLevel(x, y, SND_MAGIC_WALL_CHANGING);
+    else if (Feld[x][y+1] == EL_MAGIC_WALL_BD_EMPTY)
+      PlaySoundLevel(x, y, SND_BD_MAGIC_WALL_CHANGING);
+
     return;
   }
 
@@ -1426,39 +2109,56 @@ void Impact(int x, int y)
   {
     int sound;
 
-    switch(element)
+    switch (element)
     {
-      case EL_EDELSTEIN:
       case EL_EDELSTEIN_BD:
+        sound = SND_BD_DIAMOND_IMPACT;
+	break;
+      case EL_EDELSTEIN:
       case EL_EDELSTEIN_GELB:
       case EL_EDELSTEIN_ROT:
       case EL_EDELSTEIN_LILA:
+        sound = SND_EMERALD_IMPACT;
+	break;
       case EL_DIAMANT:
-        sound = SND_PLING;
+        sound = SND_DIAMOND_IMPACT;
+	break;
+      case EL_PEARL:
+        sound = SND_PEARL_IMPACT;
+	break;
+      case EL_CRYSTAL:
+        sound = SND_CRYSTAL_IMPACT;
+	break;
+      case EL_SP_INFOTRON:
+        sound = SND_SP_INFOTRON_IMPACT;
 	break;
       case EL_KOKOSNUSS:
-	sound = SND_KLUMPF;
+	sound = SND_NUT_IMPACT;
+	break;
+      case EL_BD_ROCK:
+	sound = SND_BD_ROCK_IMPACT;
 	break;
       case EL_FELSBROCKEN:
-	sound = SND_KLOPF;
+	sound = SND_ROCK_IMPACT;
 	break;
-      case EL_SCHLUESSEL:
-      case EL_SCHLUESSEL1:
-      case EL_SCHLUESSEL2:
-      case EL_SCHLUESSEL3:
-      case EL_SCHLUESSEL4:
-	sound = SND_KINK;
+      case EL_SP_ZONK:
+	sound = SND_SP_ZONK_IMPACT;
 	break;
       case EL_ZEIT_VOLL:
+	sound = SND_TIME_ORB_FULL_IMPACT;
+	break;
       case EL_ZEIT_LEER:
-	sound = SND_DENG;
+	sound = SND_TIME_ORB_EMPTY_IMPACT;
+	break;
+      case EL_SPRING:
+	sound = SND_SPRING_IMPACT;
 	break;
       default:
 	sound = -1;
         break;
     }
 
-    if (sound>=0)
+    if (sound >= 0)
       PlaySoundLevel(x, y, sound);
   }
 }
@@ -1509,13 +2209,13 @@ void TurnRound(int x, int y)
 
   if (element == EL_KAEFER || element == EL_BUTTERFLY)
   {
-    TestIfBadThingHitsOtherBadThing(x, y);
+    TestIfBadThingTouchesOtherBadThing(x, y);
 
     if (IN_LEV_FIELD(right_x, right_y) &&
-	IS_FREE_OR_PLAYER(right_x, right_y))
+	IS_FREE(right_x, right_y))
       MovDir[x][y] = right_dir;
     else if (!IN_LEV_FIELD(move_x, move_y) ||
-	     !IS_FREE_OR_PLAYER(move_x, move_y))
+	     !IS_FREE(move_x, move_y))
       MovDir[x][y] = left_dir;
 
     if (element == EL_KAEFER && MovDir[x][y] != old_move_dir)
@@ -1526,13 +2226,13 @@ void TurnRound(int x, int y)
   else if (element == EL_FLIEGER || element == EL_FIREFLY ||
 	   element == EL_SP_SNIKSNAK || element == EL_SP_ELECTRON)
   {
-    TestIfBadThingHitsOtherBadThing(x, y);
+    TestIfBadThingTouchesOtherBadThing(x, y);
 
     if (IN_LEV_FIELD(left_x, left_y) &&
-	IS_FREE_OR_PLAYER(left_x, left_y))
+	IS_FREE(left_x, left_y))
       MovDir[x][y] = left_dir;
     else if (!IN_LEV_FIELD(move_x, move_y) ||
-	     !IS_FREE_OR_PLAYER(move_x, move_y))
+	     !IS_FREE(move_x, move_y))
       MovDir[x][y] = right_dir;
 
     if ((element == EL_FLIEGER ||
@@ -1715,8 +2415,51 @@ void TurnRound(int x, int y)
 
     MovDelay[x][y] = 0;
   }
-  else if (element == EL_ROBOT || element == EL_SONDE ||
-	   element == EL_MAULWURF || element == EL_PINGUIN)
+  else if (element == EL_MOLE)
+  {
+    boolean can_turn_left = FALSE, can_turn_right = FALSE, can_move_on = FALSE;
+
+    if (IN_LEV_FIELD(move_x, move_y) &&
+	(IS_FREE(move_x, move_y) || IS_AMOEBOID(Feld[move_x][move_y]) ||
+	 Feld[move_x][move_y] == EL_DEAMOEBING))
+      can_move_on = TRUE;
+
+    if (!can_move_on)
+    {
+      if (IN_LEV_FIELD(left_x, left_y) &&
+	  (IS_FREE(left_x, left_y) || IS_AMOEBOID(Feld[left_x][left_y])))
+	can_turn_left = TRUE;
+      if (IN_LEV_FIELD(right_x, right_y) &&
+	  (IS_FREE(right_x, right_y) || IS_AMOEBOID(Feld[right_x][right_y])))
+	can_turn_right = TRUE;
+
+      if (can_turn_left && can_turn_right)
+	MovDir[x][y] = (RND(2) ? left_dir : right_dir);
+      else if (can_turn_left)
+	MovDir[x][y] = left_dir;
+      else
+	MovDir[x][y] = right_dir;
+    }
+
+    if (MovDir[x][y] != old_move_dir)
+      MovDelay[x][y] = 9;
+  }
+  else if (element == EL_BALLOON)
+  {
+    MovDir[x][y] = game.balloon_dir;
+    MovDelay[x][y] = 0;
+  }
+  else if (element == EL_SPRING_MOVING)
+  {
+    if (!IN_LEV_FIELD(move_x, move_y) || !IS_FREE(move_x, move_y) ||
+	(IN_LEV_FIELD(x, y+1) && IS_FREE(x, y+1)))
+    {
+      Feld[x][y] = EL_SPRING;
+      MovDir[x][y] = MV_NO_MOVING;
+    }
+    MovDelay[x][y] = 0;
+  }
+  else if (element == EL_ROBOT || element == EL_SONDE || element == EL_PINGUIN)
   {
     int attr_x = -1, attr_y = -1;
 
@@ -1734,7 +2477,7 @@ void TurnRound(int x, int y)
 	struct PlayerInfo *player = &stored_player[i];
 	int jx = player->jx, jy = player->jy;
 
-	if (!player->active || player->gone)
+	if (!player->active)
 	  continue;
 
 	if (attr_x == -1 || ABS(jx-x)+ABS(jy-y) < ABS(attr_x-x)+ABS(attr_y-y))
@@ -1751,7 +2494,7 @@ void TurnRound(int x, int y)
       attr_y = ZY;
     }
 
-    if (element == EL_MAULWURF || element == EL_PINGUIN)
+    if (element == EL_PINGUIN)
     {
       int i;
       static int xy[4][2] =
@@ -1817,7 +2560,7 @@ void TurnRound(int x, int y)
 	if (IN_LEV_FIELD(newx, newy) &&
 	    (IS_FREE(newx, newy) ||
 	     Feld[newx][newy] == EL_SALZSAEURE ||
-	     ((element == EL_MAULWURF || element == EL_PINGUIN) &&
+	     (element == EL_PINGUIN &&
 	      (Feld[newx][newy] == EL_AUSGANG_AUF ||
 	       IS_MAMPF3(Feld[newx][newy])))))
 	  return;
@@ -1829,7 +2572,7 @@ void TurnRound(int x, int y)
 	if (IN_LEV_FIELD(newx, newy) &&
 	    (IS_FREE(newx, newy) ||
 	     Feld[newx][newy] == EL_SALZSAEURE ||
-	     ((element == EL_MAULWURF || element == EL_PINGUIN) &&
+	     (element == EL_PINGUIN &&
 	      (Feld[newx][newy] == EL_AUSGANG_AUF ||
 	       IS_MAMPF3(Feld[newx][newy])))))
 	  return;
@@ -1849,8 +2592,7 @@ static boolean JustBeingPushed(int x, int y)
   {
     struct PlayerInfo *player = &stored_player[i];
 
-    if (player->active && !player->gone &&
-	player->Pushing && player->MovPos)
+    if (player->active && player->Pushing && player->MovPos)
     {
       int next_jx = player->jx + (player->jx - player->last_jx);
       int next_jy = player->jy + (player->jy - player->last_jy);
@@ -1881,8 +2623,9 @@ void StartMoving(int x, int y)
       if (IS_FREE(x, y+1))
       {
 	InitMovingField(x, y, MV_DOWN);
-	Feld[x][y] = EL_FELSBROCKEN;
-	Store[x][y] = EL_MORAST_LEER;
+	Feld[x][y] = EL_QUICKSAND_EMPTYING;
+	Store[x][y] = EL_FELSBROCKEN;
+	PlaySoundLevel(x, y, SND_QUICKSAND_EMPTYING);
       }
       else if (Feld[x][y+1] == EL_MORAST_LEER)
       {
@@ -1898,22 +2641,28 @@ void StartMoving(int x, int y)
 
 	Feld[x][y] = EL_MORAST_LEER;
 	Feld[x][y+1] = EL_MORAST_VOLL;
+	Store[x][y+1] = Store[x][y];
+	Store[x][y] = 0;
+	PlaySoundLevel(x, y, SND_QUICKSAND_SLIPPING_THROUGH);
       }
     }
-    else if (element == EL_FELSBROCKEN && Feld[x][y+1] == EL_MORAST_LEER)
+    else if ((element == EL_FELSBROCKEN || element == EL_BD_ROCK) &&
+	     Feld[x][y+1] == EL_MORAST_LEER)
     {
       InitMovingField(x, y, MV_DOWN);
-      Store[x][y] = EL_MORAST_VOLL;
+      Feld[x][y] = EL_QUICKSAND_FILLING;
+      Store[x][y] = element;
+      PlaySoundLevel(x, y, SND_QUICKSAND_FILLING);
     }
-    else if (element == EL_SIEB_VOLL)
+    else if (element == EL_MAGIC_WALL_FULL)
     {
       if (IS_FREE(x, y+1))
       {
 	InitMovingField(x, y, MV_DOWN);
-	Feld[x][y] = EL_CHANGED(Store2[x][y]);
-	Store[x][y] = EL_SIEB_LEER;
+	Feld[x][y] = EL_MAGIC_WALL_EMPTYING;
+	Store[x][y] = EL_CHANGED(Store[x][y]);
       }
-      else if (Feld[x][y+1] == EL_SIEB_LEER)
+      else if (Feld[x][y+1] == EL_MAGIC_WALL_EMPTY)
       {
 	if (!MovDelay[x][y])
 	  MovDelay[x][y] = TILEY/4 + 1;
@@ -1925,21 +2674,21 @@ void StartMoving(int x, int y)
 	    return;
 	}
 
-	Feld[x][y] = EL_SIEB_LEER;
-	Feld[x][y+1] = EL_SIEB_VOLL;
-	Store2[x][y+1] = EL_CHANGED(Store2[x][y]);
-	Store2[x][y] = 0;
+	Feld[x][y] = EL_MAGIC_WALL_EMPTY;
+	Feld[x][y+1] = EL_MAGIC_WALL_FULL;
+	Store[x][y+1] = EL_CHANGED(Store[x][y]);
+	Store[x][y] = 0;
       }
     }
-    else if (element == EL_SIEB2_VOLL)
+    else if (element == EL_MAGIC_WALL_BD_FULL)
     {
       if (IS_FREE(x, y+1))
       {
 	InitMovingField(x, y, MV_DOWN);
-	Feld[x][y] = EL_CHANGED2(Store2[x][y]);
-	Store[x][y] = EL_SIEB2_LEER;
+	Feld[x][y] = EL_MAGIC_WALL_BD_EMPTYING;
+	Store[x][y] = EL_CHANGED2(Store[x][y]);
       }
-      else if (Feld[x][y+1] == EL_SIEB2_LEER)
+      else if (Feld[x][y+1] == EL_MAGIC_WALL_BD_EMPTY)
       {
 	if (!MovDelay[x][y])
 	  MovDelay[x][y] = TILEY/4 + 1;
@@ -1951,19 +2700,21 @@ void StartMoving(int x, int y)
 	    return;
 	}
 
-	Feld[x][y] = EL_SIEB2_LEER;
-	Feld[x][y+1] = EL_SIEB2_VOLL;
-	Store2[x][y+1] = EL_CHANGED2(Store2[x][y]);
-	Store2[x][y] = 0;
+	Feld[x][y] = EL_MAGIC_WALL_BD_EMPTY;
+	Feld[x][y+1] = EL_MAGIC_WALL_BD_FULL;
+	Store[x][y+1] = EL_CHANGED2(Store[x][y]);
+	Store[x][y] = 0;
       }
     }
     else if (CAN_CHANGE(element) &&
-	     (Feld[x][y+1] == EL_SIEB_LEER || Feld[x][y+1] == EL_SIEB2_LEER))
+	     (Feld[x][y+1] == EL_MAGIC_WALL_EMPTY ||
+	      Feld[x][y+1] == EL_MAGIC_WALL_BD_EMPTY))
     {
       InitMovingField(x, y, MV_DOWN);
-      Store[x][y] =
-	(Feld[x][y+1] == EL_SIEB_LEER ? EL_SIEB_VOLL : EL_SIEB2_VOLL);
-      Store2[x][y+1] = element;
+      Feld[x][y] =
+	(Feld[x][y+1] == EL_MAGIC_WALL_EMPTY ? EL_MAGIC_WALL_FILLING :
+	 EL_MAGIC_WALL_BD_FILLING);
+      Store[x][y] = element;
     }
     else if (CAN_SMASH(element) && Feld[x][y+1] == EL_SALZSAEURE)
     {
@@ -1971,7 +2722,8 @@ void StartMoving(int x, int y)
       InitMovingField(x, y, MV_DOWN);
       Store[x][y] = EL_SALZSAEURE;
     }
-    else if (CAN_SMASH(element) && Feld[x][y+1] == EL_BLOCKED && JustHit[x][y])
+    else if (CAN_SMASH(element) && Feld[x][y+1] == EL_BLOCKED &&
+	     JustStopped[x][y])
     {
       Impact(x, y);
     }
@@ -1984,7 +2736,23 @@ void StartMoving(int x, int y)
       Feld[x][y] = EL_AMOEBING;
       Store[x][y] = EL_AMOEBE_NASS;
     }
+    /* Store[x][y+1] must be zero, because:
+       (EL_MORAST_VOLL -> EL_FELSBROCKEN): Store[x][y+1] == EL_MORAST_LEER
+    */
+#if 0
+#if OLD_GAME_BEHAVIOUR
     else if (IS_SLIPPERY(Feld[x][y+1]) && !Store[x][y+1])
+#else
+    else if (IS_SLIPPERY(Feld[x][y+1]) && !Store[x][y+1] &&
+	     !IS_FALLING(x, y+1) && !JustStopped[x][y+1] &&
+	     element != EL_DX_SUPABOMB)
+#endif
+#else
+    else if ((IS_SLIPPERY(Feld[x][y+1]) ||
+	      (IS_EM_SLIPPERY_WALL(Feld[x][y+1]) && IS_GEM(element))) &&
+	     !IS_FALLING(x, y+1) && !JustStopped[x][y+1] &&
+	     element != EL_DX_SUPABOMB && element != EL_SP_DISK_ORANGE)
+#endif
     {
       boolean left  = (x>0 && IS_FREE(x-1, y) &&
 		       (IS_FREE(x-1, y+1) || Feld[x-1][y+1] == EL_SALZSAEURE));
@@ -1993,18 +2761,33 @@ void StartMoving(int x, int y)
 
       if (left || right)
       {
-	if (left && right && game_emulation != EMU_BOULDERDASH)
+	if (left && right &&
+	    (game.emulation != EMU_BOULDERDASH &&
+	     element != EL_BD_ROCK && element != EL_EDELSTEIN_BD))
 	  left = !(right = RND(2));
 
 	InitMovingField(x, y, left ? MV_LEFT : MV_RIGHT);
       }
     }
+    else if (IS_BELT(Feld[x][y+1]))
+    {
+      boolean left_is_free  = (x>0 && IS_FREE(x-1, y));
+      boolean right_is_free = (x<lev_fieldx-1 && IS_FREE(x+1, y));
+      int belt_nr = getBeltNrFromElement(Feld[x][y+1]);
+      int belt_dir = game.belt_dir[belt_nr];
+
+      if ((belt_dir == MV_LEFT  && left_is_free) ||
+	  (belt_dir == MV_RIGHT && right_is_free))
+	InitMovingField(x, y, belt_dir);
+    }
   }
   else if (CAN_MOVE(element))
   {
     int newx, newy;
 
-    if (element == EL_SONDE && JustBeingPushed(x, y))
+    if ((element == EL_SONDE || element == EL_BALLOON ||
+	 element == EL_SPRING_MOVING)
+	&& JustBeingPushed(x, y))
       return;
 
     if (!MovDelay[x][y])	/* start new movement phase */
@@ -2015,9 +2798,11 @@ void StartMoving(int x, int y)
       if (element!=EL_MAMPFER && element!=EL_MAMPFER2 && element!=EL_PACMAN)
       {
 	TurnRound(x, y);
-	if (MovDelay[x][y] && (element == EL_KAEFER || element == EL_FLIEGER ||
+	if (MovDelay[x][y] && (element == EL_KAEFER ||
+			       element == EL_FLIEGER ||
 			       element == EL_SP_SNIKSNAK ||
-			       element == EL_SP_ELECTRON))
+			       element == EL_SP_ELECTRON ||
+			       element == EL_MOLE))
 	  DrawLevelField(x, y);
       }
     }
@@ -2031,15 +2816,19 @@ void StartMoving(int x, int y)
       {
 	int phase = MovDelay[x][y] % 8;
 
-	if (phase>3)
-	  phase = 7-phase;
+	if (phase > 3)
+	  phase = 7 - phase;
 
 	if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
-	  DrawGraphic(SCREENX(x), SCREENY(y), el2gfx(element)+phase);
+	  DrawGraphic(SCREENX(x), SCREENY(y), el2gfx(element) + phase);
 
-	if ((element == EL_MAMPFER || element == EL_MAMPFER2)
-	    && MovDelay[x][y]%4 == 3)
-	  PlaySoundLevel(x, y, SND_NJAM);
+	if (MovDelay[x][y] % 4 == 3)
+	{
+	  if (element == EL_MAMPFER)
+	    PlaySoundLevel(x, y, SND_YAMYAM_WAITING);
+	  else if (element == EL_MAMPFER2)
+	    PlaySoundLevel(x, y, SND_DARK_YAMYAM_WAITING);
+	}
       }
       else if (element == EL_SP_ELECTRON)
 	DrawGraphicAnimation(x, y, GFX2_SP_ELECTRON, 8, 2, ANIM_NORMAL);
@@ -2090,43 +2879,74 @@ void StartMoving(int x, int y)
 	return;
     }
 
-    if (element == EL_KAEFER || element == EL_BUTTERFLY)
-    {
-      PlaySoundLevel(x, y, SND_KLAPPER);
-    }
-    else if (element == EL_FLIEGER || element == EL_FIREFLY)
-    {
-      PlaySoundLevel(x, y, SND_ROEHR);
-    }
+    if (element == EL_KAEFER)
+      PlaySoundLevel(x, y, SND_BUG_MOVING);
+    else if (element == EL_FLIEGER)
+      PlaySoundLevel(x, y, SND_SPACESHIP_MOVING);
+    else if (element == EL_BUTTERFLY)
+      PlaySoundLevel(x, y, SND_BD_BUTTERFLY_MOVING);
+    else if (element == EL_FIREFLY)
+      PlaySoundLevel(x, y, SND_BD_FIREFLY_MOVING);
+    else if (element == EL_SP_SNIKSNAK)
+      PlaySoundLevel(x, y, SND_SP_SNIKSNAK_MOVING);
+    else if (element == EL_SP_ELECTRON)
+      PlaySoundLevel(x, y, SND_SP_ELECTRON_MOVING);
+    else if (element == EL_MAMPFER)
+      PlaySoundLevel(x, y, SND_YAMYAM_MOVING);
+    else if (element == EL_MAMPFER2)
+      PlaySoundLevel(x, y, SND_DARK_YAMYAM_MOVING);
+    else if (element == EL_BALLOON)
+      PlaySoundLevel(x, y, SND_BALLOON_MOVING);
+    else if (element == EL_SPRING_MOVING)
+      PlaySoundLevel(x, y, SND_SPRING_MOVING);
+    else if (element == EL_MOLE)
+      PlaySoundLevel(x, y, SND_MOLE_MOVING);
+    else if (element == EL_SONDE)
+      PlaySoundLevel(x, y, SND_SATELLITE_MOVING);
+    else if (element == EL_PACMAN)
+      PlaySoundLevel(x, y, SND_PACMAN_MOVING);
+    else if (element == EL_PINGUIN)
+      PlaySoundLevel(x, y, SND_PENGUIN_MOVING);
+    else if (element == EL_SCHWEIN)
+      PlaySoundLevel(x, y, SND_PIG_MOVING);
+    else if (element == EL_DRACHE)
+      PlaySoundLevel(x, y, SND_DRAGON_MOVING);
 
     /* now make next step */
 
     Moving2Blocked(x, y, &newx, &newy);	/* get next screen position */
 
-    if (IS_ENEMY(element) && IS_PLAYER(newx, newy))
+    if (IS_ENEMY(element) && IS_PLAYER(newx, newy) &&
+	!PLAYER_PROTECTED(newx, newy))
     {
+
+#if 1
+      TestIfBadThingRunsIntoHero(x, y, MovDir[x][y]);
+      return;
+#else
       /* enemy got the player */
       MovDir[x][y] = 0;
       KillHero(PLAYERINFO(newx, newy));
       return;
+#endif
+
     }
-    else if ((element == EL_MAULWURF || element == EL_PINGUIN ||
-	      element == EL_ROBOT || element == EL_SONDE) &&
+    else if ((element == EL_PINGUIN || element == EL_ROBOT ||
+	      element == EL_SONDE || element == EL_BALLOON) &&
 	     IN_LEV_FIELD(newx, newy) &&
 	     MovDir[x][y] == MV_DOWN && Feld[newx][newy] == EL_SALZSAEURE)
     {
       Blurb(x, y);
       Store[x][y] = EL_SALZSAEURE;
     }
-    else if ((element == EL_MAULWURF || element == EL_PINGUIN) &&
-	     IN_LEV_FIELD(newx, newy))
+    else if (element == EL_PINGUIN && IN_LEV_FIELD(newx, newy))
     {
       if (Feld[newx][newy] == EL_AUSGANG_AUF)
       {
 	Feld[x][y] = EL_LEERRAUM;
 	DrawLevelField(x, y);
 
-	PlaySoundLevel(newx, newy, SND_BUING);
+	PlaySoundLevel(newx, newy, SND_PENGUIN_ENTERING_EXIT);
 	if (IN_SCR_FIELD(SCREENX(newx), SCREENY(newy)))
 	  DrawGraphicThruMask(SCREENX(newx), SCREENY(newy), el2gfx(element));
 
@@ -2164,6 +2984,8 @@ void StartMoving(int x, int y)
 	  Feld[newx][newy] = EL_LEERRAUM;
 	  DrawLevelField(newx, newy);
 	}
+
+	PlaySoundLevel(x, y, SND_PIG_EATING_GEM);
       }
       else if (!IS_FREE(newx, newy))
       {
@@ -2204,6 +3026,8 @@ void StartMoving(int x, int y)
 	  else
 	    DrawLevelField(x, y);
 
+	  PlaySoundLevel(x, y, SND_DRAGON_BREATHING_FIRE);
+
 	  MovDelay[x][y] = 50;
 	  Feld[newx][newy] = EL_BURNING;
 	  if (IN_LEV_FIELD(newx1, newy1) && Feld[newx1][newy1] == EL_LEERRAUM)
@@ -2224,6 +3048,8 @@ void StartMoving(int x, int y)
 	Feld[newx][newy] = EL_LEERRAUM;
 	DrawLevelField(newx, newy);
       }
+
+      PlaySoundLevel(x, y, SND_YAMYAM_EATING_DIAMOND);
     }
     else if (element == EL_MAMPFER2 && IN_LEV_FIELD(newx, newy) &&
 	     IS_MAMPF2(Feld[newx][newy]))
@@ -2243,9 +3069,11 @@ void StartMoving(int x, int y)
 	Feld[newx][newy] = EL_LEERRAUM;
 	DrawLevelField(newx, newy);
       }
+
+      PlaySoundLevel(x, y, SND_DARK_YAMYAM_EATING_ANY);
     }
-    else if (element == EL_PACMAN && IN_LEV_FIELD(newx, newy) &&
-	     IS_AMOEBOID(Feld[newx][newy]))
+    else if ((element == EL_PACMAN || element == EL_MOLE)
+	     && IN_LEV_FIELD(newx, newy) && IS_AMOEBOID(Feld[newx][newy]))
     {
       if (AmoebaNr[newx][newy])
       {
@@ -2255,8 +3083,26 @@ void StartMoving(int x, int y)
 	  AmoebaCnt[AmoebaNr[newx][newy]]--;
       }
 
-      Feld[newx][newy] = EL_LEERRAUM;
-      DrawLevelField(newx, newy);
+      if (element == EL_MOLE)
+      {
+	Feld[newx][newy] = EL_DEAMOEBING;
+	PlaySoundLevel(x, y, SND_MOLE_EATING_AMOEBA);
+	MovDelay[newx][newy] = 0;	/* start amoeba shrinking delay */
+	return;				/* wait for shrinking amoeba */
+      }
+      else	/* element == EL_PACMAN */
+      {
+	Feld[newx][newy] = EL_LEERRAUM;
+	DrawLevelField(newx, newy);
+	PlaySoundLevel(x, y, SND_PACMAN_EATING_AMOEBA);
+      }
+    }
+    else if (element == EL_MOLE && IN_LEV_FIELD(newx, newy) &&
+	     (Feld[newx][newy] == EL_DEAMOEBING ||
+	      (Feld[newx][newy] == EL_LEERRAUM && Stop[newx][newy])))
+    {
+      /* wait for shrinking amoeba to completely disappear */
+      return;
     }
     else if (!IN_LEV_FIELD(newx, newy) || !IS_FREE(newx, newy))
     {
@@ -2265,7 +3111,7 @@ void StartMoving(int x, int y)
       TurnRound(x, y);
 
       if (element == EL_KAEFER || element == EL_FLIEGER ||
-	  element == EL_SP_SNIKSNAK)
+	  element == EL_SP_SNIKSNAK || element == EL_MOLE)
 	DrawLevelField(x, y);
       else if (element == EL_BUTTERFLY || element == EL_FIREFLY)
 	DrawGraphicAnimation(x, y, el2gfx(element), 2, 4, ANIM_NORMAL);
@@ -2274,11 +3120,14 @@ void StartMoving(int x, int y)
       else if (element == EL_SP_ELECTRON)
 	DrawGraphicAnimation(x, y, GFX2_SP_ELECTRON, 8, 2, ANIM_NORMAL);
 
+      if (DONT_TOUCH(element))
+	TestIfBadThingTouchesHero(x, y);
+
       return;
     }
 
     if (element == EL_ROBOT && IN_SCR_FIELD(x, y))
-      PlaySoundLevel(x, y, SND_SCHLURF);
+      PlaySoundLevel(x, y, SND_ROBOT_MOVING);
 
     InitMovingField(x, y, MovDir[x][y]);
   }
@@ -2295,14 +3144,28 @@ void ContinueMoving(int x, int y)
   int dy = (direction == MV_UP   ? -1 : direction == MV_DOWN  ? +1 : 0);
   int horiz_move = (dx!=0);
   int newx = x + dx, newy = y + dy;
-  int step = (horiz_move ? dx : dy) * TILEX/8;
+  int step = (horiz_move ? dx : dy) * TILEX / 8;
+
+  if (element == EL_TROPFEN || element == EL_AMOEBA_DRIPPING)
+    step /= 2;
+  else if (element == EL_QUICKSAND_FILLING ||
+	   element == EL_QUICKSAND_EMPTYING)
+    step /= 4;
+  else if (element == EL_MAGIC_WALL_FILLING ||
+	   element == EL_MAGIC_WALL_BD_FILLING ||
+	   element == EL_MAGIC_WALL_EMPTYING ||
+	   element == EL_MAGIC_WALL_BD_EMPTYING)
+    step /= 2;
+  else if (CAN_FALL(element) && horiz_move &&
+	   y < lev_fieldy-1 && IS_BELT(Feld[x][y+1]))
+    step /= 2;
+  else if (element == EL_SPRING_MOVING)
+    step*=2;
 
-  if (CAN_FALL(element) && horiz_move && !IS_SP_ELEMENT(element))
+#if OLD_GAME_BEHAVIOUR
+  else if (CAN_FALL(element) && horiz_move && !IS_SP_ELEMENT(element))
     step*=2;
-  else if (element == EL_TROPFEN)
-    step/=2;
-  else if (Store[x][y] == EL_MORAST_VOLL || Store[x][y] == EL_MORAST_LEER)
-    step/=4;
+#endif
 
   MovPos[x][y] += step;
 
@@ -2311,49 +3174,81 @@ void ContinueMoving(int x, int y)
     Feld[x][y] = EL_LEERRAUM;
     Feld[newx][newy] = element;
 
-    if (Store[x][y] == EL_MORAST_VOLL)
+    if (element == EL_MOLE)
     {
-      Store[x][y] = 0;
-      Feld[newx][newy] = EL_MORAST_VOLL;
-      element = EL_MORAST_VOLL;
+      int i;
+      static int xy[4][2] =
+      {
+	{ 0, -1 },
+	{ -1, 0 },
+	{ +1, 0 },
+	{ 0, +1 }
+      };
+
+      Feld[x][y] = EL_ERDREICH;
+      DrawLevelField(x, y);
+
+      for(i=0; i<4; i++)
+      {
+	int xx, yy;
+
+	xx = x + xy[i][0];
+	yy = y + xy[i][1];
+
+	if (IN_LEV_FIELD(xx, yy) && Feld[xx][yy] == EL_ERDREICH)
+	  DrawLevelField(xx, yy);	/* for "ErdreichAnbroeckeln()" */
+      }
     }
-    else if (Store[x][y] == EL_MORAST_LEER)
+
+    if (element == EL_QUICKSAND_FILLING)
     {
-      Store[x][y] = 0;
-      Feld[x][y] = EL_MORAST_LEER;
+      element = Feld[newx][newy] = get_next_element(element);
+      Store[newx][newy] = Store[x][y];
     }
-    else if (Store[x][y] == EL_SIEB_VOLL)
+    else if (element == EL_QUICKSAND_EMPTYING)
     {
-      Store[x][y] = 0;
-      element = Feld[newx][newy] = (SiebAktiv ? EL_SIEB_VOLL : EL_SIEB_TOT);
+      Feld[x][y] = get_next_element(element);
+      element = Feld[newx][newy] = Store[x][y];
     }
-    else if (Store[x][y] == EL_SIEB_LEER)
+    else if (element == EL_MAGIC_WALL_FILLING)
     {
-      Store[x][y] = Store2[x][y] = 0;
-      Feld[x][y] = (SiebAktiv ? EL_SIEB_LEER : EL_SIEB_TOT);
+      element = Feld[newx][newy] = get_next_element(element);
+      if (!game.magic_wall_active)
+	element = Feld[newx][newy] = EL_MAGIC_WALL_DEAD;
+      Store[newx][newy] = Store[x][y];
     }
-    else if (Store[x][y] == EL_SIEB2_VOLL)
+    else if (element == EL_MAGIC_WALL_EMPTYING)
     {
-      Store[x][y] = 0;
-      element = Feld[newx][newy] = (SiebAktiv ? EL_SIEB2_VOLL : EL_SIEB2_TOT);
+      Feld[x][y] = get_next_element(element);
+      if (!game.magic_wall_active)
+	Feld[x][y] = EL_MAGIC_WALL_DEAD;
+      element = Feld[newx][newy] = Store[x][y];
     }
-    else if (Store[x][y] == EL_SIEB2_LEER)
+    else if (element == EL_MAGIC_WALL_BD_FILLING)
     {
-      Store[x][y] = Store2[x][y] = 0;
-      Feld[x][y] = (SiebAktiv ? EL_SIEB2_LEER : EL_SIEB2_TOT);
+      element = Feld[newx][newy] = get_next_element(element);
+      if (!game.magic_wall_active)
+	element = Feld[newx][newy] = EL_MAGIC_WALL_BD_DEAD;
+      Store[newx][newy] = Store[x][y];
     }
-    else if (Store[x][y] == EL_SALZSAEURE)
+    else if (element == EL_MAGIC_WALL_BD_EMPTYING)
     {
-      Store[x][y] = 0;
-      Feld[newx][newy] = EL_SALZSAEURE;
-      element = EL_SALZSAEURE;
+      Feld[x][y] = get_next_element(element);
+      if (!game.magic_wall_active)
+	Feld[x][y] = EL_MAGIC_WALL_BD_DEAD;
+      element = Feld[newx][newy] = Store[x][y];
     }
-    else if (Store[x][y] == EL_AMOEBE_NASS)
+    else if (element == EL_AMOEBA_DRIPPING)
     {
-      Store[x][y] = 0;
-      Feld[x][y] = EL_AMOEBE_NASS;
+      Feld[x][y] = get_next_element(element);
+      element = Feld[newx][newy] = Store[x][y];
+    }
+    else if (Store[x][y] == EL_SALZSAEURE)
+    {
+      element = Feld[newx][newy] = EL_SALZSAEURE;
     }
 
+    Store[x][y] = 0;
     MovPos[x][y] = MovDir[x][y] = MovDelay[x][y] = 0;
     MovDelay[newx][newy] = 0;
 
@@ -2364,16 +3259,16 @@ void ContinueMoving(int x, int y)
     DrawLevelField(newx, newy);
 
     Stop[newx][newy] = TRUE;
-    JustHit[x][newy] = 3;
+    JustStopped[newx][newy] = 3;
 
     if (DONT_TOUCH(element))	/* object may be nasty to player or others */
     {
-      TestIfBadThingHitsHero(newx, newy);
-      TestIfBadThingHitsFriend(newx, newy);
-      TestIfBadThingHitsOtherBadThing(newx, newy);
+      TestIfBadThingTouchesHero(newx, newy);
+      TestIfBadThingTouchesFriend(newx, newy);
+      TestIfBadThingTouchesOtherBadThing(newx, newy);
     }
     else if (element == EL_PINGUIN)
-      TestIfFriendHitsBadThing(newx, newy);
+      TestIfFriendTouchesBadThing(newx, newy);
 
     if (CAN_SMASH(element) && direction == MV_DOWN &&
 	(newy == lev_fieldy-1 || !IS_FREE(x, newy+1)))
@@ -2489,6 +3384,9 @@ void AmoebeUmwandeln(int ax, int ay)
 	}
       }
     }
+    PlaySoundLevel(ax, ay, (IS_GEM(level.amoeba_content) ?
+			    SND_AMOEBA_TURNING_TO_GEM :
+			    SND_AMOEBA_TURNING_TO_ROCK));
     Bang(ax, ay);
   }
   else
@@ -2510,7 +3408,12 @@ void AmoebeUmwandeln(int ax, int ay)
 	continue;
 
       if (Feld[x][y] == EL_AMOEBA2DIAM)
+      {
+	PlaySoundLevel(x, y, (IS_GEM(level.amoeba_content) ?
+			      SND_AMOEBA_TURNING_TO_GEM :
+			      SND_AMOEBA_TURNING_TO_ROCK));
 	Bang(x, y);
+      }
     }
   }
 }
@@ -2549,8 +3452,9 @@ void AmoebeUmwandelnBD(int ax, int ay, int new_element)
   }
 
   if (done)
-    PlaySoundLevel(ax, ay,
-		   (new_element == EL_FELSBROCKEN ? SND_KLOPF : SND_PLING));
+    PlaySoundLevel(ax, ay, (new_element == EL_BD_ROCK ?
+			    SND_BD_AMOEBA_TURNING_TO_ROCK :
+			    SND_BD_AMOEBA_TURNING_TO_GEM));
 }
 
 void AmoebeWaechst(int x, int y)
@@ -2564,7 +3468,10 @@ void AmoebeWaechst(int x, int y)
 
     if (DelayReached(&sound_delay, sound_delay_value))
     {
-      PlaySoundLevel(x, y, SND_AMOEBE);
+      if (Store[x][y] == EL_AMOEBE_BD)
+	PlaySoundLevel(x, y, SND_BD_AMOEBA_GROWING);
+      else
+	PlaySoundLevel(x, y, SND_AMOEBA_GROWING);
       sound_delay_value = 30;
     }
   }
@@ -2584,6 +3491,37 @@ void AmoebeWaechst(int x, int y)
   }
 }
 
+void AmoebaDisappearing(int x, int y)
+{
+  static unsigned long sound_delay = 0;
+  static unsigned long sound_delay_value = 0;
+
+  if (!MovDelay[x][y])		/* start new shrinking cycle */
+  {
+    MovDelay[x][y] = 7;
+
+    if (DelayReached(&sound_delay, sound_delay_value))
+      sound_delay_value = 30;
+  }
+
+  if (MovDelay[x][y])		/* wait some time before shrinking */
+  {
+    MovDelay[x][y]--;
+    if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+      DrawGraphic(SCREENX(x), SCREENY(y), GFX_AMOEBING + MovDelay[x][y]/2);
+
+    if (!MovDelay[x][y])
+    {
+      Feld[x][y] = EL_LEERRAUM;
+      DrawLevelField(x, y);
+
+      /* don't let mole enter this field in this cycle;
+	 (give priority to objects falling to this field from above) */
+      Stop[x][y] = TRUE;
+    }
+  }
+}
+
 void AmoebeAbleger(int ax, int ay)
 {
   int i;
@@ -2597,7 +3535,7 @@ void AmoebeAbleger(int ax, int ay)
     { 0, +1 }
   };
 
-  if (!level.tempo_amoebe)
+  if (!level.amoeba_speed)
   {
     Feld[ax][ay] = EL_AMOEBE_TOT;
     DrawLevelField(ax, ay);
@@ -2605,7 +3543,7 @@ void AmoebeAbleger(int ax, int ay)
   }
 
   if (!MovDelay[ax][ay])	/* start making new amoeba field */
-    MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.tempo_amoebe));
+    MovDelay[ax][ay] = RND(FRAMES_PER_SECOND * 25 / (1 + level.amoeba_speed));
 
   if (MovDelay[ax][ay])		/* wait some time before making new amoeba */
   {
@@ -2660,7 +3598,7 @@ void AmoebeAbleger(int ax, int ay)
 
     if (newax == ax && neway == ay)		/* amoeba cannot grow */
     {
-      if (i == 4 && (!waiting_for_player || game_emulation == EMU_BOULDERDASH))
+      if (i == 4 && (!waiting_for_player || game.emulation == EMU_BOULDERDASH))
       {
 	Feld[ax][ay] = EL_AMOEBE_TOT;
 	DrawLevelField(ax, ay);
@@ -2671,7 +3609,7 @@ void AmoebeAbleger(int ax, int ay)
 	  if (element == EL_AMOEBE_VOLL)
 	    AmoebeUmwandeln(ax, ay);
 	  else if (element == EL_AMOEBE_BD)
-	    AmoebeUmwandelnBD(ax, ay, level.amoebe_inhalt);
+	    AmoebeUmwandelnBD(ax, ay, level.amoeba_content);
 	}
       }
       return;
@@ -2700,7 +3638,7 @@ void AmoebeAbleger(int ax, int ay)
 
       if (element == EL_AMOEBE_BD && AmoebaCnt2[new_group_nr] >= 200)
       {
-	AmoebeUmwandelnBD(newax, neway, EL_FELSBROCKEN);
+	AmoebeUmwandelnBD(newax, neway, EL_BD_ROCK);
 	return;
       }
     }
@@ -2709,16 +3647,19 @@ void AmoebeAbleger(int ax, int ay)
   if (element != EL_AMOEBE_NASS || neway < ay || !IS_FREE(newax, neway) ||
       (neway == lev_fieldy - 1 && newax != ax))
   {
-    Feld[newax][neway] = EL_AMOEBING;
+    Feld[newax][neway] = EL_AMOEBING;	/* simple growth of new amoeba tile */
     Store[newax][neway] = element;
   }
   else if (neway == ay)
-    Feld[newax][neway] = EL_TROPFEN;
+  {
+    Feld[newax][neway] = EL_TROPFEN;	/* drop left or right from amoeba */
+    PlaySoundLevel(newax, neway, SND_AMOEBA_DROPPING);
+  }
   else
   {
-    InitMovingField(ax, ay, MV_DOWN);
-    Feld[ax][ay] = EL_TROPFEN;
-    Store[ax][ay] = EL_AMOEBE_NASS;
+    InitMovingField(ax, ay, MV_DOWN);	/* drop dripping out of amoeba */
+    Feld[ax][ay] = EL_AMOEBA_DRIPPING;
+    Store[ax][ay] = EL_TROPFEN;
     ContinueMoving(ax, ay);
     return;
   }
@@ -2732,6 +3673,7 @@ void Life(int ax, int ay)
   static int life[4] = { 2, 3, 3, 3 };	/* parameters for "game of life" */
   int life_time = 40;
   int element = Feld[ax][ay];
+  boolean changed = FALSE;
 
   if (Stop[ax][ay])
     return;
@@ -2770,32 +3712,38 @@ void Life(int ax, int ay)
 
     if (xx == ax && yy == ay)		/* field in the middle */
     {
-      if (nachbarn<life[0] || nachbarn>life[1])
+      if (nachbarn < life[0] || nachbarn > life[1])
       {
 	Feld[xx][yy] = EL_LEERRAUM;
 	if (!Stop[xx][yy])
 	  DrawLevelField(xx, yy);
 	Stop[xx][yy] = TRUE;
+	changed = TRUE;
       }
     }
     else if (IS_FREE(xx, yy) || Feld[xx][yy] == EL_ERDREICH)
     {					/* free border field */
-      if (nachbarn>=life[2] && nachbarn<=life[3])
+      if (nachbarn >= life[2] && nachbarn <= life[3])
       {
 	Feld[xx][yy] = element;
 	MovDelay[xx][yy] = (element == EL_LIFE ? 0 : life_time-1);
 	if (!Stop[xx][yy])
 	  DrawLevelField(xx, yy);
 	Stop[xx][yy] = TRUE;
+	changed = TRUE;
       }
     }
   }
+
+  if (changed)
+    PlaySoundLevel(ax, ay, element == EL_LIFE ? SND_GAMEOFLIFE_GROWING :
+		   SND_BIOMAZE_GROWING);
 }
 
-void Ablenk(int x, int y)
+void RobotWheel(int x, int y)
 {
   if (!MovDelay[x][y])		/* next animation frame */
-    MovDelay[x][y] = level.dauer_ablenk * FRAMES_PER_SECOND;
+    MovDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
 
   if (MovDelay[x][y])		/* wait some time before next frame */
   {
@@ -2805,7 +3753,7 @@ void Ablenk(int x, int y)
       if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
 	DrawGraphic(SCREENX(x), SCREENY(y), GFX_ABLENK+MovDelay[x][y]%4);
       if (!(MovDelay[x][y]%4))
-	PlaySoundLevel(x, y, SND_MIEP);
+	PlaySoundLevel(x, y, SND_ROBOT_WHEEL_RUNNING);
       return;
     }
   }
@@ -2816,18 +3764,43 @@ void Ablenk(int x, int y)
     ZX = ZY = -1;
 }
 
-void Birne(int x, int y)
+void TimegateWheel(int x, int y)
 {
   if (!MovDelay[x][y])		/* next animation frame */
-    MovDelay[x][y] = 800;
+    MovDelay[x][y] = level.time_wheel * FRAMES_PER_SECOND;
 
   if (MovDelay[x][y])		/* wait some time before next frame */
   {
     MovDelay[x][y]--;
     if (MovDelay[x][y])
     {
-      if (!(MovDelay[x][y]%5))
-      {
+      if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+	DrawGraphic(SCREENX(x), SCREENY(y),
+		    GFX_TIMEGATE_SWITCH + MovDelay[x][y]%4);
+      if (!(MovDelay[x][y]%4))
+	PlaySoundLevel(x, y, SND_TIMEGATE_WHEEL_RUNNING);
+      return;
+    }
+  }
+
+  Feld[x][y] = EL_TIMEGATE_SWITCH_OFF;
+  DrawLevelField(x, y);
+  if (ZX == x && ZY == y)
+    ZX = ZY = -1;
+}
+
+void Birne(int x, int y)
+{
+  if (!MovDelay[x][y])		/* next animation frame */
+    MovDelay[x][y] = 800;
+
+  if (MovDelay[x][y])		/* wait some time before next frame */
+  {
+    MovDelay[x][y]--;
+    if (MovDelay[x][y])
+    {
+      if (!(MovDelay[x][y]%5))
+      {
 	if (!(MovDelay[x][y]%10))
 	  Feld[x][y]=EL_ABLENK_EIN;
 	else
@@ -2862,7 +3835,8 @@ void NussKnacken(int x, int y)
   {
     MovDelay[x][y]--;
     if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
-      DrawGraphic(SCREENX(x), SCREENY(y), GFX_CRACKINGNUT+3-MovDelay[x][y]/2);
+      DrawGraphic(SCREENX(x), SCREENY(y),
+		  GFX_CRACKINGNUT + 3 - MovDelay[x][y]/2);
 
     if (!MovDelay[x][y])
     {
@@ -2872,9 +3846,29 @@ void NussKnacken(int x, int y)
   }
 }
 
+void BreakingPearl(int x, int y)
+{
+  if (!MovDelay[x][y])		/* next animation frame */
+    MovDelay[x][y] = 9;
+
+  if (MovDelay[x][y])		/* wait some time before next frame */
+  {
+    MovDelay[x][y]--;
+    if (MovDelay[x][y]/2 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+      DrawGraphic(SCREENX(x), SCREENY(y),
+		  GFX_PEARL_BREAKING + 4 - MovDelay[x][y]/2);
+
+    if (!MovDelay[x][y])
+    {
+      Feld[x][y] = EL_LEERRAUM;
+      DrawLevelField(x, y);
+    }
+  }
+}
+
 void SiebAktivieren(int x, int y, int typ)
 {
-  int graphic = (typ == 1 ? GFX_SIEB_VOLL : GFX_SIEB2_VOLL) + 3;
+  int graphic = (typ == 1 ? GFX_MAGIC_WALL_FULL : GFX_MAGIC_WALL_BD_FULL) + 3;
 
   DrawGraphicAnimation(x, y, graphic, 4, 4, ANIM_REVERSE);
 }
@@ -2891,7 +3885,7 @@ void AusgangstuerPruefen(int x, int y)
 		   (x > LEVELX(BX2) ? LEVELX(BX2) : x),
 		   y < LEVELY(BY1) ? LEVELY(BY1) :
 		   (y > LEVELY(BY2) ? LEVELY(BY2) : y),
-		   SND_OEFFNEN);
+		   SND_EXIT_OPENING);
   }
 }
 
@@ -2924,6 +3918,121 @@ void AusgangstuerBlinken(int x, int y)
   DrawGraphicAnimation(x, y, GFX_AUSGANG_AUF, 4, 4, ANIM_OSCILLATE);
 }
 
+void OpenSwitchgate(int x, int y)
+{
+  int delay = 6;
+
+  if (!MovDelay[x][y])		/* next animation frame */
+    MovDelay[x][y] = 5 * delay;
+
+  if (MovDelay[x][y])		/* wait some time before next frame */
+  {
+    int phase;
+
+    MovDelay[x][y]--;
+    phase = MovDelay[x][y] / delay;
+    if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+      DrawGraphic(SCREENX(x), SCREENY(y), GFX_SWITCHGATE_OPEN - phase);
+
+    if (!MovDelay[x][y])
+    {
+      Feld[x][y] = EL_SWITCHGATE_OPEN;
+      DrawLevelField(x, y);
+    }
+  }
+}
+
+void CloseSwitchgate(int x, int y)
+{
+  int delay = 6;
+
+  if (!MovDelay[x][y])		/* next animation frame */
+    MovDelay[x][y] = 5 * delay;
+
+  if (MovDelay[x][y])		/* wait some time before next frame */
+  {
+    int phase;
+
+    MovDelay[x][y]--;
+    phase = MovDelay[x][y] / delay;
+    if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+      DrawGraphic(SCREENX(x), SCREENY(y), GFX_SWITCHGATE_CLOSED + phase);
+
+    if (!MovDelay[x][y])
+    {
+      Feld[x][y] = EL_SWITCHGATE_CLOSED;
+      DrawLevelField(x, y);
+    }
+  }
+}
+
+void OpenTimegate(int x, int y)
+{
+  int delay = 6;
+
+  if (!MovDelay[x][y])		/* next animation frame */
+    MovDelay[x][y] = 5 * delay;
+
+  if (MovDelay[x][y])		/* wait some time before next frame */
+  {
+    int phase;
+
+    MovDelay[x][y]--;
+    phase = MovDelay[x][y] / delay;
+    if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+      DrawGraphic(SCREENX(x), SCREENY(y), GFX_TIMEGATE_OPEN - phase);
+
+    if (!MovDelay[x][y])
+    {
+      Feld[x][y] = EL_TIMEGATE_OPEN;
+      DrawLevelField(x, y);
+    }
+  }
+}
+
+void CloseTimegate(int x, int y)
+{
+  int delay = 6;
+
+  if (!MovDelay[x][y])		/* next animation frame */
+    MovDelay[x][y] = 5 * delay;
+
+  if (MovDelay[x][y])		/* wait some time before next frame */
+  {
+    int phase;
+
+    MovDelay[x][y]--;
+    phase = MovDelay[x][y] / delay;
+    if (!(MovDelay[x][y] % delay) && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+      DrawGraphic(SCREENX(x), SCREENY(y), GFX_TIMEGATE_CLOSED + phase);
+
+    if (!MovDelay[x][y])
+    {
+      Feld[x][y] = EL_TIMEGATE_CLOSED;
+      DrawLevelField(x, y);
+    }
+  }
+}
+
+static void CloseAllOpenTimegates()
+{
+  int x, y;
+
+  for (y=0; y<lev_fieldy; y++)
+  {
+    for (x=0; x<lev_fieldx; x++)
+    {
+      int element = Feld[x][y];
+
+      if (element == EL_TIMEGATE_OPEN || element == EL_TIMEGATE_OPENING)
+      {
+	Feld[x][y] = EL_TIMEGATE_CLOSING;
+	PlaySoundLevel(x, y, SND_TIMEGATE_CLOSING);
+      }
+    }
+  }
+}
+
 void EdelsteinFunkeln(int x, int y)
 {
   if (!IN_SCR_FIELD(SCREENX(x), SCREENY(y)) || IS_MOVING(x, y))
@@ -2961,8 +4070,8 @@ void EdelsteinFunkeln(int x, int y)
 	  dest_x = FX + SCREENX(x)*TILEX;
 	  dest_y = FY + SCREENY(y)*TILEY;
 
-	  XCopyArea(display, drawto_field, window, gc,
-		    dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
+	  BlitBitmap(drawto_field, window,
+		     dest_x, dest_y, TILEX, TILEY, dest_x, dest_y);
 	  SetDrawtoField(DRAW_DIRECT);
 	}
       }
@@ -3028,6 +4137,7 @@ void MauerAbleger(int ax, int ay)
   boolean links_frei = FALSE, rechts_frei = FALSE;
   boolean oben_massiv = FALSE, unten_massiv = FALSE;
   boolean links_massiv = FALSE, rechts_massiv = FALSE;
+  boolean new_wall = FALSE;
 
   if (!MovDelay[ax][ay])	/* start building new wall */
     MovDelay[ax][ay] = 6;
@@ -3057,6 +4167,7 @@ void MauerAbleger(int ax, int ay)
       MovDir[ax][ay-1] = MV_UP;
       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay-1)))
   	DrawGraphic(SCREENX(ax), SCREENY(ay-1), GFX_MAUER_UP);
+      new_wall = TRUE;
     }
     if (unten_frei)
     {
@@ -3065,6 +4176,7 @@ void MauerAbleger(int ax, int ay)
       MovDir[ax][ay+1] = MV_DOWN;
       if (IN_SCR_FIELD(SCREENX(ax), SCREENY(ay+1)))
   	DrawGraphic(SCREENX(ax), SCREENY(ay+1), GFX_MAUER_DOWN);
+      new_wall = TRUE;
     }
   }
 
@@ -3078,6 +4190,7 @@ void MauerAbleger(int ax, int ay)
       MovDir[ax-1][ay] = MV_LEFT;
       if (IN_SCR_FIELD(SCREENX(ax-1), SCREENY(ay)))
   	DrawGraphic(SCREENX(ax-1), SCREENY(ay), GFX_MAUER_LEFT);
+      new_wall = TRUE;
     }
     if (rechts_frei)
     {
@@ -3086,6 +4199,7 @@ void MauerAbleger(int ax, int ay)
       MovDir[ax+1][ay] = MV_RIGHT;
       if (IN_SCR_FIELD(SCREENX(ax+1), SCREENY(ay)))
   	DrawGraphic(SCREENX(ax+1), SCREENY(ay), GFX_MAUER_RIGHT);
+      new_wall = TRUE;
     }
   }
 
@@ -3106,6 +4220,9 @@ void MauerAbleger(int ax, int ay)
       ((links_massiv && rechts_massiv) ||
        element == EL_MAUER_Y))
     Feld[ax][ay] = EL_MAUERWERK;
+
+  if (new_wall)
+    PlaySoundLevel(ax, ay, SND_WALL_GROWING);
 }
 
 void CheckForDragon(int x, int y)
@@ -3157,13 +4274,147 @@ void CheckForDragon(int x, int y)
   }
 }
 
+static void CheckBuggyBase(int x, int y)
+{
+  int element = Feld[x][y];
+
+  if (element == EL_SP_BUG)
+  {
+    if (!MovDelay[x][y])	/* wait some time before activating base */
+      MovDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
+
+    if (MovDelay[x][y])
+    {
+      MovDelay[x][y]--;
+      if (MovDelay[x][y] < 5 && IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+	DrawGraphic(SCREENX(x), SCREENY(y), GFX_SP_BUG_WARNING);
+      if (MovDelay[x][y])
+	return;
+
+      Feld[x][y] = EL_SP_BUG_ACTIVE;
+    }
+  }
+  else if (element == EL_SP_BUG_ACTIVE)
+  {
+    if (!MovDelay[x][y])	/* start activating buggy base */
+      MovDelay[x][y] = 1 * FRAMES_PER_SECOND + RND(1 * FRAMES_PER_SECOND);
+
+    if (MovDelay[x][y])
+    {
+      MovDelay[x][y]--;
+      if (MovDelay[x][y])
+      {
+	int i;
+	static int xy[4][2] =
+	{
+	  { 0, -1 },
+	  { -1, 0 },
+	  { +1, 0 },
+	  { 0, +1 }
+	};
+
+	if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+	  DrawGraphic(SCREENX(x),SCREENY(y), GFX_SP_BUG_ACTIVE + SimpleRND(4));
+
+	for (i=0; i<4; i++)
+	{
+	  int xx = x + xy[i][0], yy = y + xy[i][1];
+
+	  if (IS_PLAYER(xx, yy))
+	  {
+	    PlaySoundLevel(x, y, SND_SP_BUGGY_BASE_ACTIVATING);
+	    break;
+	  }
+	}
+
+	return;
+      }
+
+      Feld[x][y] = EL_SP_BUG;
+      DrawLevelField(x, y);
+    }
+  }
+}
+
+static void CheckTrap(int x, int y)
+{
+  int element = Feld[x][y];
+
+  if (element == EL_TRAP_INACTIVE)
+  {
+    if (!MovDelay[x][y])	/* wait some time before activating trap */
+      MovDelay[x][y] = 2 * FRAMES_PER_SECOND + RND(5 * FRAMES_PER_SECOND);
+
+    if (MovDelay[x][y])
+    {
+      MovDelay[x][y]--;
+      if (MovDelay[x][y])
+	return;
+
+      Feld[x][y] = EL_TRAP_ACTIVE;
+      PlaySoundLevel(x, y, SND_TRAP_ACTIVATING);
+    }
+  }
+  else if (element == EL_TRAP_ACTIVE)
+  {
+    int delay = 4;
+    int num_frames = 8;
+
+    if (!MovDelay[x][y])	/* start activating trap */
+      MovDelay[x][y] = num_frames * delay;
+
+    if (MovDelay[x][y])
+    {
+      MovDelay[x][y]--;
+
+      if (MovDelay[x][y])
+      {
+	if (!(MovDelay[x][y] % delay))
+	{
+	  int phase = MovDelay[x][y]/delay;
+
+	  if (phase >= num_frames/2)
+	    phase = num_frames - phase;
+
+	  if (IN_SCR_FIELD(SCREENX(x), SCREENY(y)))
+	  {
+	    DrawGraphic(SCREENX(x),SCREENY(y), GFX_TRAP_INACTIVE + phase - 1);
+	    ErdreichAnbroeckeln(SCREENX(x), SCREENY(y));
+	  }
+	}
+
+	return;
+      }
+
+      Feld[x][y] = EL_TRAP_INACTIVE;
+      DrawLevelField(x, y);
+    }
+  }
+}
+
+static void DrawBeltAnimation(int x, int y, int element)
+{
+  int belt_nr = getBeltNrFromElement(element);
+  int belt_dir = game.belt_dir[belt_nr];
+
+  if (belt_dir != MV_NO_MOVING)
+  {
+    int delay = 2;
+    int mode = (belt_dir == MV_LEFT ? ANIM_NORMAL : ANIM_REVERSE);
+    int graphic = el2gfx(element) + (belt_dir == MV_LEFT ? 0 : 7);
+
+    DrawGraphicAnimation(x, y, graphic, 8, delay, mode);
+  }
+}
+
 static void PlayerActions(struct PlayerInfo *player, byte player_action)
 {
   static byte stored_player_action[MAX_PLAYERS];
   static int num_stored_actions = 0;
+#if 0
   static boolean save_tape_entry = FALSE;
+#endif
   boolean moved = FALSE, snapped = FALSE, bombed = FALSE;
-  int jx = player->jx, jy = player->jy;
   int left	= player_action & JOY_LEFT;
   int right	= player_action & JOY_RIGHT;
   int up	= player_action & JOY_UP;
@@ -3176,12 +4427,14 @@ static void PlayerActions(struct PlayerInfo *player, byte player_action)
   stored_player_action[player->index_nr] = 0;
   num_stored_actions++;
 
-  if (!player->active || player->gone || tape.pausing)
+  if (!player->active || tape.pausing)
     return;
 
   if (player_action)
   {
+#if 0
     save_tape_entry = TRUE;
+#endif
     player->frame_reset_delay = 0;
 
     if (button1)
@@ -3193,44 +4446,81 @@ static void PlayerActions(struct PlayerInfo *player, byte player_action)
       moved = MoveFigure(player, dx, dy);
     }
 
+    if (tape.single_step && tape.recording && !tape.pausing)
+    {
+      if (button1 || (bombed && !moved))
+      {
+	TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
+	SnapField(player, 0, 0);		/* stop snapping */
+      }
+    }
+
+#if 0
     if (tape.recording && (moved || snapped || bombed))
     {
       if (bombed && !moved)
 	player_action &= JOY_BUTTON;
 
       stored_player_action[player->index_nr] = player_action;
-
-#if 0
-      /* this allows cycled sequences of PlayerActions() */
-      if (num_stored_actions >= MAX_PLAYERS)
-      {
-	TapeRecordAction(stored_player_action);
-	num_stored_actions = 0;
-      }
-#endif
-
+      save_tape_entry = TRUE;
     }
     else if (tape.playing && snapped)
       SnapField(player, 0, 0);			/* stop snapping */
+#else
+    stored_player_action[player->index_nr] = player_action;
+#endif
   }
   else
   {
+    /* no actions for this player (no input at player's configured device) */
+
     DigField(player, 0, 0, 0, 0, DF_NO_PUSH);
     SnapField(player, 0, 0);
-    if (++player->frame_reset_delay > MoveSpeed)
+    CheckGravityMovement(player);
+
+#if 1
+    if (player->MovPos == 0)	/* needed for tape.playing */
+      player->is_moving = FALSE;
+#endif
+#if 0
+    if (player->MovPos == 0)	/* needed for tape.playing */
+      player->last_move_dir = MV_NO_MOVING;
+
+    /* !!! CHECK THIS AGAIN !!!
+       (Seems to be needed for some EL_ROBOT stuff, but breaks
+       tapes when walking through pipes!)
+    */
+
+    /* it seems that "player->last_move_dir" is misused as some sort of
+       "player->is_just_moving_in_this_moment", which is needed for the
+       robot stuff (robots don't kill players when they are moving)
+    */
+#endif 
+
+    if (++player->frame_reset_delay > player->move_delay_value)
       player->Frame = 0;
   }
 
+#if 0
   if (tape.recording && num_stored_actions >= MAX_PLAYERS && save_tape_entry)
   {
     TapeRecordAction(stored_player_action);
     num_stored_actions = 0;
     save_tape_entry = FALSE;
   }
+#else
+  if (tape.recording && num_stored_actions >= MAX_PLAYERS)
+  {
+    TapeRecordAction(stored_player_action);
+    num_stored_actions = 0;
+  }
+#endif
 
+#if 0
   if (tape.playing && !tape.pausing && !player_action &&
       tape.counter < tape.length)
   {
+    int jx = player->jx, jy = player->jy;
     int next_joy =
       tape.pos[tape.counter].action[player->index_nr] & (JOY_LEFT|JOY_RIGHT);
 
@@ -3242,7 +4532,8 @@ static void PlayerActions(struct PlayerInfo *player, byte player_action)
       if (IN_LEV_FIELD(jx+dx, jy) && IS_PUSHABLE(Feld[jx+dx][jy]))
       {
 	int el = Feld[jx+dx][jy];
-	int push_delay = (IS_SB_ELEMENT(el) || el == EL_SONDE ? 2 : 10);
+	int push_delay = (IS_SB_ELEMENT(el) || el == EL_SONDE ? 2 :
+			  (el == EL_BALLOON || el == EL_SPRING) ? 0 : 10);
 
 	if (tape.delay_played + push_delay >= tape.pos[tape.counter].delay)
 	{
@@ -3253,6 +4544,7 @@ static void PlayerActions(struct PlayerInfo *player, byte player_action)
       }
     }
   }
+#endif
 }
 
 void GameActions()
@@ -3270,40 +4562,12 @@ void GameActions()
   action_delay_value =
     (tape.playing && tape.fast_forward ? FfwdFrameDelay : GameFrameDelay);
 
-  /*
-  if (tape.playing && tape.fast_forward)
-  {
-    char buf[100];
-
-    sprintf(buf, "FFWD: %ld ms", action_delay_value);
-    print_debug(buf);
-  }
-  */
-
-
-  /* main game synchronization point */
+  if (tape.playing && tape.index_search && !tape.pausing)
+    action_delay_value = 0;
 
+  /* ---------- main game synchronization point ---------- */
 
-
-
-#if 1
   WaitUntilDelayReached(&action_delay, action_delay_value);
-#else
-
-  while (!DelayReached(&action_delay, action_delay_value))
-  {
-    char buf[100];
-
-    sprintf(buf, "%ld %ld %ld",
-	    Counter(), action_delay, action_delay_value);
-    print_debug(buf);
-  }
-  print_debug("done");
-
-#endif
-
-
-
 
   if (network_playing && !network_player_action_received)
   {
@@ -3313,7 +4577,7 @@ void GameActions()
 #endif
     */
 
-#ifndef MSDOS
+#if defined(PLATFORM_UNIX)
     /* last chance to get network player actions without main loop delay */
     HandleNetworking();
 #endif
@@ -3332,22 +4596,9 @@ void GameActions()
     }
   }
 
-
-  /*
-  if (tape.pausing || (tape.playing && !TapePlayDelay()))
-    return;
-  else if (tape.recording)
-    TapeRecordDelay();
-  */
-
   if (tape.pausing)
     return;
 
-  if (tape.playing)
-    TapePlayDelay();
-  else if (tape.recording)
-    TapeRecordDelay();
-
   recorded_player_action = (tape.playing ? TapePlayAction() : NULL);
 
   for (i=0; i<MAX_PLAYERS; i++)
@@ -3358,7 +4609,7 @@ void GameActions()
       stored_player[i].effective_action = stored_player[i].action;
   }
 
-#ifndef MSDOS
+#if defined(PLATFORM_UNIX)
   if (network_playing)
     SendToServer_MovePlayer(summarized_player_action);
 #endif
@@ -3370,6 +4621,9 @@ void GameActions()
   {
     int actual_player_action = stored_player[i].effective_action;
 
+    if (stored_player[i].programmed_action)
+      actual_player_action = stored_player[i].programmed_action;
+
     if (recorded_player_action)
       actual_player_action = recorded_player_action[i];
 
@@ -3382,41 +4636,25 @@ void GameActions()
   ScrollScreen(NULL, SCROLL_GO_ON);
 
 
-  /*
-  if (tape.pausing || (tape.playing && !TapePlayDelay()))
-    return;
-  else if (tape.recording)
-    TapeRecordDelay();
-  */
-
-
-
-
 
 #ifdef DEBUG
-  /*
-  if (TimeFrames == 0 && !local_player->gone)
+#if 0
+  if (TimeFrames == 0 && local_player->active)
   {
     extern unsigned int last_RND();
 
     printf("DEBUG: %03d last RND was %d \t [state checksum is %d]\n",
-	   level.time - TimeLeft,
-	   last_RND(),
-	   getStateCheckSum(level.time - TimeLeft));
+	   TimePlayed, last_RND(), getStateCheckSum(TimePlayed));
   }
-  */
 #endif
-
-
+#endif
 
 #ifdef DEBUG
-  /*
+#if 0
   if (GameFrameDelay >= 500)
     printf("FrameCounter == %d\n", FrameCounter);
-  */
 #endif
-
-
+#endif
 
 
 
@@ -3426,8 +4664,8 @@ void GameActions()
   for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
   {
     Stop[x][y] = FALSE;
-    if (JustHit[x][y]>0)
-      JustHit[x][y]--;
+    if (JustStopped[x][y] > 0)
+      JustStopped[x][y]--;
 
 #if DEBUG
     if (IS_BLOCKED(x, y))
@@ -3437,7 +4675,7 @@ void GameActions()
       Blocked2Moving(x, y, &oldx, &oldy);
       if (!IS_MOVING(oldx, oldy))
       {
-	printf("GameActions(): (BLOCKED=>MOVING) context corrupted!\n");
+	printf("GameActions(): (BLOCKED => MOVING) context corrupted!\n");
 	printf("GameActions(): BLOCKED: x = %d, y = %d\n", x, y);
 	printf("GameActions(): !MOVING: oldx = %d, oldy = %d\n", oldx, oldy);
 	printf("GameActions(): This should never happen!\n");
@@ -3457,29 +4695,41 @@ void GameActions()
     {
       StartMoving(x, y);
 
-      if (IS_GEM(element))
+      if (IS_GEM(element) || element == EL_SP_INFOTRON)
 	EdelsteinFunkeln(x, y);
     }
     else if (IS_MOVING(x, y))
       ContinueMoving(x, y);
-    else if (element == EL_DYNAMIT || element == EL_DYNABOMB)
+    else if (IS_ACTIVE_BOMB(element))
       CheckDynamite(x, y);
-    else if (element == EL_EXPLODING)
+#if 0
+    else if (element == EL_EXPLODING && !game.explosions_delayed)
       Explode(x, y, Frame[x][y], EX_NORMAL);
+#endif
     else if (element == EL_AMOEBING)
       AmoebeWaechst(x, y);
+    else if (element == EL_DEAMOEBING)
+      AmoebaDisappearing(x, y);
+
+#if !USE_NEW_AMOEBA_CODE
     else if (IS_AMOEBALIVE(element))
       AmoebeAbleger(x, y);
+#endif
+
     else if (element == EL_LIFE || element == EL_LIFE_ASYNC)
       Life(x, y);
     else if (element == EL_ABLENK_EIN)
-      Ablenk(x, y);
+      RobotWheel(x, y);
+    else if (element == EL_TIMEGATE_SWITCH_ON)
+      TimegateWheel(x, y);
     else if (element == EL_SALZSAEURE)
       Blubber(x, y);
     else if (element == EL_BLURB_LEFT || element == EL_BLURB_RIGHT)
       Blurb(x, y);
     else if (element == EL_CRACKINGNUT)
       NussKnacken(x, y);
+    else if (element == EL_PEARL_BREAKING)
+      BreakingPearl(x, y);
     else if (element == EL_AUSGANG_ZU)
       AusgangstuerPruefen(x, y);
     else if (element == EL_AUSGANG_ACT)
@@ -3495,24 +4745,58 @@ void GameActions()
       MauerAbleger(x, y);
     else if (element == EL_BURNING)
       CheckForDragon(x, y);
+    else if (element == EL_SP_BUG || element == EL_SP_BUG_ACTIVE)
+      CheckBuggyBase(x, y);
+    else if (element == EL_TRAP_INACTIVE || element == EL_TRAP_ACTIVE)
+      CheckTrap(x, y);
     else if (element == EL_SP_TERMINAL)
       DrawGraphicAnimation(x, y, GFX2_SP_TERMINAL, 7, 12, ANIM_NORMAL);
     else if (element == EL_SP_TERMINAL_ACTIVE)
       DrawGraphicAnimation(x, y, GFX2_SP_TERMINAL_ACTIVE, 7, 4, ANIM_NORMAL);
+    else if (IS_BELT(element))
+    {
+      DrawBeltAnimation(x, y, element);
+      if (!(FrameCounter % 2))
+	PlaySoundLevel(x, y, SND_CONVEYOR_BELT_RUNNING);
+    }
+    else if (element == EL_SWITCHGATE_OPENING)
+      OpenSwitchgate(x, y);
+    else if (element == EL_SWITCHGATE_CLOSING)
+      CloseSwitchgate(x, y);
+    else if (element == EL_TIMEGATE_OPENING)
+      OpenTimegate(x, y);
+    else if (element == EL_TIMEGATE_CLOSING)
+      CloseTimegate(x, y);
+    else if (element == EL_EXTRA_TIME)
+      DrawGraphicAnimation(x, y, GFX_EXTRA_TIME, 6, 4, ANIM_NORMAL);
+    else if (element == EL_SHIELD_PASSIVE)
+    {
+      DrawGraphicAnimation(x, y, GFX_SHIELD_PASSIVE, 6, 4, ANIM_NORMAL);
+      if (!(FrameCounter % 4))
+	PlaySoundLevel(x, y, SND_SHIELD_PASSIVE_ACTIVATED);
+    }
+    else if (element == EL_SHIELD_ACTIVE)
+    {
+      DrawGraphicAnimation(x, y, GFX_SHIELD_ACTIVE, 6, 4, ANIM_NORMAL);
+      if (!(FrameCounter % 4))
+	PlaySoundLevel(x, y, SND_SHIELD_ACTIVE_ACTIVATED);
+    }
 
-    if (SiebAktiv)
+    if (game.magic_wall_active)
     {
       boolean sieb = FALSE;
       int jx = local_player->jx, jy = local_player->jy;
 
-      if (element == EL_SIEB_LEER || element == EL_SIEB_VOLL ||
-	  Store[x][y] == EL_SIEB_LEER)
+      if (element == EL_MAGIC_WALL_FULL ||
+	  element == EL_MAGIC_WALL_EMPTY ||
+	  element == EL_MAGIC_WALL_EMPTYING)
       {
 	SiebAktivieren(x, y, 1);
 	sieb = TRUE;
       }
-      else if (element == EL_SIEB2_LEER || element == EL_SIEB2_VOLL ||
-	       Store[x][y] == EL_SIEB2_LEER)
+      else if (element == EL_MAGIC_WALL_BD_FULL ||
+	       element == EL_MAGIC_WALL_BD_EMPTY ||
+	       element == EL_MAGIC_WALL_BD_EMPTYING)
       {
 	SiebAktivieren(x, y, 2);
 	sieb = TRUE;
@@ -3527,55 +4811,194 @@ void GameActions()
     }
   }
 
-  if (SiebAktiv)
+#if USE_NEW_AMOEBA_CODE
+  /* new experimental amoeba growth stuff */
+#if 1
+  if (!(FrameCounter % 8))
+#endif
+  {
+    static unsigned long random = 1684108901;
+
+    for (i = 0; i < level.amoeba_speed * 28 / 8; i++)
+    {
+#if 0
+      x = (random >> 10) % lev_fieldx;
+      y = (random >> 20) % lev_fieldy;
+#else
+      x = RND(lev_fieldx);
+      y = RND(lev_fieldy);
+#endif
+      element = Feld[x][y];
+
+      if (!IS_PLAYER(x,y) &&
+	  (element == EL_LEERRAUM ||
+	   element == EL_ERDREICH ||
+	   element == EL_MORAST_LEER ||
+	   element == EL_BLURB_LEFT ||
+	   element == EL_BLURB_RIGHT))
+      {
+	if ((IN_LEV_FIELD(x, y-1) && Feld[x][y-1] == EL_AMOEBE_NASS) ||
+	    (IN_LEV_FIELD(x-1, y) && Feld[x-1][y] == EL_AMOEBE_NASS) ||
+	    (IN_LEV_FIELD(x+1, y) && Feld[x+1][y] == EL_AMOEBE_NASS) ||
+	    (IN_LEV_FIELD(x, y+1) && Feld[x][y+1] == EL_AMOEBE_NASS))
+	  Feld[x][y] = EL_TROPFEN;
+      }
+
+      random = random * 129 + 1;
+    }
+  }
+#endif
+
+#if 0
+  if (game.explosions_delayed)
+#endif
   {
-    if (!(SiebCount % 4))
-      PlaySoundLevel(sieb_x, sieb_y, SND_MIEP);
+    game.explosions_delayed = FALSE;
 
-    if (SiebCount > 0)
+    for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
     {
-      SiebCount--;
-      if (!SiebCount)
+      element = Feld[x][y];
+
+      if (ExplodeField[x][y])
+	Explode(x, y, EX_PHASE_START, ExplodeField[x][y]);
+      else if (element == EL_EXPLODING)
+	Explode(x, y, Frame[x][y], EX_NORMAL);
+
+      ExplodeField[x][y] = EX_NO_EXPLOSION;
+    }
+
+    game.explosions_delayed = TRUE;
+  }
+
+  if (game.magic_wall_active)
+  {
+    if (!(game.magic_wall_time_left % 4))
+    {
+      int element = Feld[sieb_x][sieb_y];
+
+      if (element == EL_MAGIC_WALL_BD_FULL ||
+	  element == EL_MAGIC_WALL_BD_EMPTY ||
+	  element == EL_MAGIC_WALL_BD_EMPTYING)
+	PlaySoundLevel(sieb_x, sieb_y, SND_BD_MAGIC_WALL_RUNNING);
+      else
+	PlaySoundLevel(sieb_x, sieb_y, SND_MAGIC_WALL_RUNNING);
+    }
+
+    if (game.magic_wall_time_left > 0)
+    {
+      game.magic_wall_time_left--;
+      if (!game.magic_wall_time_left)
       {
 	for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
 	{
 	  element = Feld[x][y];
-	  if (element == EL_SIEB_LEER || element == EL_SIEB_VOLL)
+
+	  if (element == EL_MAGIC_WALL_EMPTY ||
+	      element == EL_MAGIC_WALL_FULL)
 	  {
-	    Feld[x][y] = EL_SIEB_TOT;
+	    Feld[x][y] = EL_MAGIC_WALL_DEAD;
 	    DrawLevelField(x, y);
 	  }
-	  else if (element == EL_SIEB2_LEER || element == EL_SIEB2_VOLL)
+	  else if (element == EL_MAGIC_WALL_BD_EMPTY ||
+		   element == EL_MAGIC_WALL_BD_FULL)
 	  {
-	    Feld[x][y] = EL_SIEB2_TOT;
+	    Feld[x][y] = EL_MAGIC_WALL_BD_DEAD;
 	    DrawLevelField(x, y);
 	  }
 	}
 
-	SiebAktiv = FALSE;
+	game.magic_wall_active = FALSE;
       }
     }
   }
 
-  if (TimeLeft > 0 && TimeFrames >= (1000 / GameFrameDelay) && !tape.pausing)
+  if (game.light_time_left > 0)
+  {
+    game.light_time_left--;
+
+    if (game.light_time_left == 0)
+    {
+      for (y=0; y<lev_fieldy; y++) for (x=0; x<lev_fieldx; x++)
+      {
+	element = Feld[x][y];
+
+	if (element == EL_LIGHT_SWITCH_ON)
+	{
+	  Feld[x][y] = EL_LIGHT_SWITCH_OFF;
+	  DrawLevelField(x, y);
+	}
+	else if (element == EL_INVISIBLE_STEEL ||
+		 element == EL_UNSICHTBAR ||
+		 element == EL_SAND_INVISIBLE)
+	  DrawLevelField(x, y);
+      }
+    }
+  }
+
+  if (game.timegate_time_left > 0)
+  {
+    game.timegate_time_left--;
+
+    if (game.timegate_time_left == 0)
+      CloseAllOpenTimegates();
+  }
+
+  if (TimeFrames >= (1000 / GameFrameDelay))
   {
     TimeFrames = 0;
-    TimeLeft--;
+    TimePlayed++;
+
+    for (i=0; i<MAX_PLAYERS; i++)
+    {
+      if (SHIELD_ON(&stored_player[i]))
+      {
+	stored_player[i].shield_passive_time_left--;
+
+	if (stored_player[i].shield_active_time_left > 0)
+	  stored_player[i].shield_active_time_left--;
+      }
+    }
 
     if (tape.recording || tape.playing)
-      DrawVideoDisplay(VIDEO_STATE_TIME_ON, level.time-TimeLeft);
+      DrawVideoDisplay(VIDEO_STATE_TIME_ON, TimePlayed);
 
-    if (TimeLeft<=10)
-      PlaySoundStereo(SND_GONG, PSND_MAX_RIGHT);
+    if (TimeLeft > 0)
+    {
+      TimeLeft--;
 
-    DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
+      if (TimeLeft <= 10 && setup.time_limit)
+	PlaySoundStereo(SND_GAME_RUNNING_OUT_OF_TIME, PSND_MAX_RIGHT);
 
-    if (!TimeLeft)
-      for (i=0; i<MAX_PLAYERS; i++)
-	KillHero(&stored_player[i]);
+      DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
+
+      if (!TimeLeft && setup.time_limit)
+	for (i=0; i<MAX_PLAYERS; i++)
+	  KillHero(&stored_player[i]);
+    }
+    else if (level.time == 0 && !AllPlayersGone) /* level without time limit */
+      DrawText(DX_TIME, DY_TIME, int2str(TimePlayed, 3), FS_SMALL, FC_YELLOW);
   }
 
   DrawAllPlayers();
+
+  if (options.debug)			/* calculate frames per second */
+  {
+    static unsigned long fps_counter = 0;
+    static int fps_frames = 0;
+    unsigned long fps_delay_ms = Counter() - fps_counter;
+
+    fps_frames++;
+
+    if (fps_delay_ms >= 500)	/* calculate fps every 0.5 seconds */
+    {
+      global.frames_per_second = 1000 * (float)fps_frames / fps_delay_ms;
+
+      fps_frames = 0;
+      fps_counter = Counter();
+    }
+
+    redraw_mask |= REDRAW_FPS;
+  }
 }
 
 static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
@@ -3587,8 +5010,7 @@ static boolean AllPlayersInSight(struct PlayerInfo *player, int x, int y)
   {
     int jx = stored_player[i].jx, jy = stored_player[i].jy;
 
-    if (!stored_player[i].active || stored_player[i].gone ||
-	&stored_player[i] == player)
+    if (!stored_player[i].active || &stored_player[i] == player)
       continue;
 
     min_x = MIN(min_x, jx);
@@ -3608,7 +5030,7 @@ static boolean AllPlayersInVisibleScreen()
   {
     int jx = stored_player[i].jx, jy = stored_player[i].jy;
 
-    if (!stored_player[i].active || stored_player[i].gone)
+    if (!stored_player[i].active)
       continue;
 
     if (!IN_VIS_FIELD(SCREENX(jx), SCREENY(jy)))
@@ -3623,13 +5045,13 @@ void ScrollLevel(int dx, int dy)
   int softscroll_offset = (setup.soft_scrolling ? TILEX : 0);
   int x, y;
 
-  XCopyArea(display, drawto_field, drawto_field, gc,
-	    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);
+  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);
 
   if (dx)
   {
@@ -3647,6 +5069,32 @@ void ScrollLevel(int dx, int dy)
   redraw_mask |= REDRAW_FIELD;
 }
 
+static void CheckGravityMovement(struct PlayerInfo *player)
+{
+  if (level.gravity && !player->programmed_action)
+  {
+    int move_dir_vertical = player->action & (MV_UP | MV_DOWN);
+    int move_dir_horizontal = player->action & (MV_LEFT | MV_RIGHT);
+    int move_dir =
+      (player->last_move_dir & (MV_LEFT | MV_RIGHT) ?
+       (move_dir_vertical ? move_dir_vertical : move_dir_horizontal) :
+       (move_dir_horizontal ? move_dir_horizontal : move_dir_vertical));
+    int jx = player->jx, jy = player->jy;
+    int dx = (move_dir & MV_LEFT ? -1 : move_dir & MV_RIGHT ? +1 : 0);
+    int dy = (move_dir & MV_UP ? -1 : move_dir & MV_DOWN ? +1 : 0);
+    int new_jx = jx + dx, new_jy = jy + dy;
+    boolean field_under_player_is_free =
+      (IN_LEV_FIELD(jx, jy + 1) && IS_FREE(jx, jy + 1));
+    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_ERDREICH));
+
+    if (field_under_player_is_free && !player_is_moving_to_valid_field)
+      player->programmed_action = MV_DOWN;
+  }
+}
+
 boolean MoveFigureOneStep(struct PlayerInfo *player,
 			  int dx, int dy, int real_dx, int real_dy)
 {
@@ -3655,7 +5103,7 @@ boolean MoveFigureOneStep(struct PlayerInfo *player,
   int element;
   int can_move;
 
-  if (player->gone || (!dx && !dy))
+  if (!player->active || (!dx && !dy))
     return MF_NO_ACTION;
 
   player->MovDir = (dx < 0 ? MV_LEFT :
@@ -3669,7 +5117,11 @@ boolean MoveFigureOneStep(struct PlayerInfo *player,
   if (!options.network && !AllPlayersInSight(player, new_jx, new_jy))
     return MF_NO_ACTION;
 
+#if 0
   element = MovingOrBlocked2Element(new_jx, new_jy);
+#else
+  element = MovingOrBlocked2ElementIfNotLeaving(new_jx, new_jy);
+#endif
 
   if (DONT_GO_TO(element))
   {
@@ -3683,7 +5135,7 @@ boolean MoveFigureOneStep(struct PlayerInfo *player,
       BuryHero(player);
     }
     else
-      KillHero(player);
+      TestIfHeroRunsIntoBadThing(jx, jy, player->MovDir);
 
     return MF_MOVING;
   }
@@ -3699,7 +5151,8 @@ boolean MoveFigureOneStep(struct PlayerInfo *player,
   jy = player->jy = new_jy;
   StorePlayer[jx][jy] = player->element_nr;
 
-  player->MovPos = (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / MoveSpeed);
+  player->MovPos =
+    (dx > 0 || dy > 0 ? -1 : 1) * (TILEX - TILEX / player->move_delay_value);
 
   ScrollFigure(player, SCROLL_INIT);
 
@@ -3712,25 +5165,35 @@ boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
   int old_jx = jx, old_jy = jy;
   int moved = MF_NO_ACTION;
 
-  if (player->gone || (!dx && !dy))
+  if (!player->active || (!dx && !dy))
     return FALSE;
 
-  if (!FrameReached(&player->move_delay, MoveSpeed) && !tape.playing)
+#if 0
+  if (!FrameReached(&player->move_delay, player->move_delay_value) &&
+      !tape.playing)
     return FALSE;
+#else
+  if (!FrameReached(&player->move_delay, player->move_delay_value) &&
+      !(tape.playing && tape.game_version < GAME_VERSION_2_0))
+    return FALSE;
+#endif
+
+  /* remove the last programmed player action */
+  player->programmed_action = 0;
 
   if (player->MovPos)
   {
     /* should only happen if pre-1.2 tape recordings are played */
     /* this is only for backward compatibility */
 
-    int old_move_speed = MoveSpeed;
+    int original_move_delay_value = player->move_delay_value;
 
 #if DEBUG
     printf("THIS SHOULD ONLY HAPPEN WITH PRE-1.2 LEVEL TAPES.\n");
 #endif
 
     /* scroll remaining steps with finest movement resolution */
-    MoveSpeed = 8;
+    player->move_delay_value = MOVE_DELAY_NORMAL_SPEED;
 
     while (player->MovPos)
     {
@@ -3741,7 +5204,7 @@ boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
       BackToFront();
     }
 
-    MoveSpeed = old_move_speed;
+    player->move_delay_value = original_move_delay_value;
   }
 
   if (player->last_move_dir & (MV_LEFT | MV_RIGHT))
@@ -3776,13 +5239,13 @@ boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
     {
       if (jx != old_jx)		/* player has moved horizontally */
       {
- 	if ((player->MovDir == MV_LEFT && scroll_x > jx-MIDPOSX+offset) ||
-	    (player->MovDir == MV_RIGHT && scroll_x < jx-MIDPOSX-offset))
+ 	if ((player->MovDir == MV_LEFT && scroll_x > jx - MIDPOSX + offset) ||
+	    (player->MovDir == MV_RIGHT && scroll_x < jx - MIDPOSX - offset))
 	  scroll_x = jx-MIDPOSX + (scroll_x < jx-MIDPOSX ? -offset : +offset);
 
 	/* don't scroll over playfield boundaries */
-	if (scroll_x < -1 || scroll_x > lev_fieldx - SCR_FIELDX + 1)
-	  scroll_x = (scroll_x < -1 ? -1 : lev_fieldx - SCR_FIELDX + 1);
+	if (scroll_x < SBX_Left || scroll_x > SBX_Right)
+	  scroll_x = (scroll_x < SBX_Left ? SBX_Left : SBX_Right);
 
 	/* don't scroll more than one field at a time */
 	scroll_x = old_scroll_x + SIGN(scroll_x - old_scroll_x);
@@ -3794,13 +5257,13 @@ boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
       }
       else			/* player has moved vertically */
       {
-	if ((player->MovDir == MV_UP && scroll_y > jy-MIDPOSY+offset) ||
-	    (player->MovDir == MV_DOWN && scroll_y < jy-MIDPOSY-offset))
+	if ((player->MovDir == MV_UP && scroll_y > jy - MIDPOSY + offset) ||
+	    (player->MovDir == MV_DOWN && scroll_y < jy - MIDPOSY - offset))
 	  scroll_y = jy-MIDPOSY + (scroll_y < jy-MIDPOSY ? -offset : +offset);
 
 	/* don't scroll over playfield boundaries */
-	if (scroll_y < -1 || scroll_y > lev_fieldy - SCR_FIELDY + 1)
-	  scroll_y = (scroll_y < -1 ? -1 : lev_fieldy - SCR_FIELDY + 1);
+	if (scroll_y < SBY_Upper || scroll_y > SBY_Lower)
+	  scroll_y = (scroll_y < SBY_Upper ? SBY_Upper : SBY_Lower);
 
 	/* don't scroll more than one field at a time */
 	scroll_y = old_scroll_y + SIGN(scroll_y - old_scroll_y);
@@ -3842,13 +5305,21 @@ boolean MoveFigure(struct PlayerInfo *player, int dx, int dy)
     DrawLevelField(jx, jy);	/* for "ErdreichAnbroeckeln()" */
 
     player->last_move_dir = player->MovDir;
+    player->is_moving = TRUE;
   }
   else
+  {
+    CheckGravityMovement(player);
+
+    /*
     player->last_move_dir = MV_NO_MOVING;
+    */
+    player->is_moving = FALSE;
+  }
 
-  TestIfHeroHitsBadThing(jx, jy);
+  TestIfHeroTouchesBadThing(jx, jy);
 
-  if (player->gone)
+  if (!player->active)
     RemoveHero(player);
 
   return moved;
@@ -3858,14 +5329,15 @@ void ScrollFigure(struct PlayerInfo *player, int mode)
 {
   int jx = player->jx, jy = player->jy;
   int last_jx = player->last_jx, last_jy = player->last_jy;
+  int move_stepsize = TILEX / player->move_delay_value;
 
-  if (!player->active || player->gone || !player->MovPos)
+  if (!player->active || !player->MovPos)
     return;
 
   if (mode == SCROLL_INIT)
   {
     player->actual_frame_counter = FrameCounter;
-    player->GfxPos = ScrollStepSize * (player->MovPos / ScrollStepSize);
+    player->GfxPos = move_stepsize * (player->MovPos / move_stepsize);
 
     if (Feld[last_jx][last_jy] == EL_LEERRAUM)
       Feld[last_jx][last_jy] = EL_PLAYER_IS_LEAVING;
@@ -3876,16 +5348,29 @@ void ScrollFigure(struct PlayerInfo *player, int mode)
   else if (!FrameReached(&player->actual_frame_counter, 1))
     return;
 
-  player->MovPos += (player->MovPos > 0 ? -1 : 1) * TILEX / MoveSpeed;
-  player->GfxPos = ScrollStepSize * (player->MovPos / ScrollStepSize);
+  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)
     Feld[last_jx][last_jy] = EL_LEERRAUM;
 
+  /* before DrawPlayer() to draw correct player graphic for this case */
+  if (player->MovPos == 0)
+    CheckGravityMovement(player);
+
   DrawPlayer(player);
 
-  if (!player->MovPos)
+  if (player->MovPos == 0)
   {
+    if (IS_QUICK_GATE(Feld[last_jx][last_jy]))
+    {
+      /* continue with normal speed after quickly moving through gate */
+      HALVE_PLAYER_SPEED(player);
+
+      /* be able to make the next move without delay */
+      player->move_delay = 0;
+    }
+
     player->last_jx = jx;
     player->last_jy = jy;
 
@@ -3896,6 +5381,10 @@ void ScrollFigure(struct PlayerInfo *player, int mode)
       if (!local_player->friends_still_needed)
 	player->LevelSolved = player->GameOver = TRUE;
     }
+
+    if (tape.single_step && tape.recording && !tape.pausing &&
+	!player->programmed_action)
+      TapeTogglePause(TAPE_TOGGLE_AUTOMATIC);
   }
 }
 
@@ -3905,6 +5394,9 @@ void ScrollScreen(struct PlayerInfo *player, int mode)
 
   if (mode == SCROLL_INIT)
   {
+    /* set scrolling step size according to actual player's moving speed */
+    ScrollStepSize = TILEX / player->move_delay_value;
+
     screen_frame_counter = FrameCounter;
     ScreenMovDir = player->MovDir;
     ScreenMovPos = player->MovPos;
@@ -3916,7 +5408,7 @@ void ScrollScreen(struct PlayerInfo *player, int mode)
 
   if (ScreenMovPos)
   {
-    ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * TILEX / MoveSpeed;
+    ScreenMovPos += (ScreenMovPos > 0 ? -1 : 1) * ScrollStepSize;
     ScreenGfxPos = ScrollStepSize * (ScreenMovPos / ScrollStepSize);
     redraw_mask |= REDRAW_FIELD;
   }
@@ -3924,17 +5416,17 @@ void ScrollScreen(struct PlayerInfo *player, int mode)
     ScreenMovDir = MV_NO_MOVING;
 }
 
-void TestIfGoodThingHitsBadThing(int goodx, int goody)
+void TestIfGoodThingHitsBadThing(int good_x, int good_y, int good_move_dir)
 {
-  int i, killx = goodx, killy = goody;
-  static int xy[4][2] =
+  int i, kill_x = -1, kill_y = -1;
+  static int test_xy[4][2] =
   {
     { 0, -1 },
     { -1, 0 },
     { +1, 0 },
     { 0, +1 }
   };
-  static int harmless[4] =
+  static int test_dir[4] =
   {
     MV_UP,
     MV_LEFT,
@@ -3944,46 +5436,62 @@ void TestIfGoodThingHitsBadThing(int goodx, int goody)
 
   for (i=0; i<4; i++)
   {
-    int x, y, element;
+    int test_x, test_y, test_move_dir, test_element;
 
-    x = goodx + xy[i][0];
-    y = goody + xy[i][1];
-    if (!IN_LEV_FIELD(x, y))
+    test_x = good_x + test_xy[i][0];
+    test_y = good_y + test_xy[i][1];
+    if (!IN_LEV_FIELD(test_x, test_y))
       continue;
 
-    element = Feld[x][y];
+    test_move_dir =
+      (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
 
-    if (DONT_TOUCH(element))
-    {
-      if (MovDir[x][y] == harmless[i])
-	continue;
+#if 0
+    test_element = Feld[test_x][test_y];
+#else
+    test_element = MovingOrBlocked2ElementIfNotLeaving(test_x, test_y);
+#endif
 
-      killx = x;
-      killy = y;
+    /* 1st case: good thing is moving towards DONT_GO_TO style bad thing;
+       2nd case: DONT_TOUCH style bad thing does not move away from good thing
+    */
+    if ((DONT_GO_TO(test_element) && good_move_dir == test_dir[i]) ||
+	(DONT_TOUCH(test_element) && test_move_dir != test_dir[i]))
+    {
+      kill_x = test_x;
+      kill_y = test_y;
       break;
     }
   }
 
-  if (killx != goodx || killy != goody)
+  if (kill_x != -1 || kill_y != -1)
   {
-    if (IS_PLAYER(goodx, goody))
-      KillHero(PLAYERINFO(goodx, goody));
+    if (IS_PLAYER(good_x, good_y))
+    {
+      struct PlayerInfo *player = PLAYERINFO(good_x, good_y);
+
+      if (player->shield_active_time_left > 0)
+	Bang(kill_x, kill_y);
+      else if (!PLAYER_PROTECTED(good_x, good_y))
+	KillHero(player);
+    }
     else
-      Bang(goodx, goody);
+      Bang(good_x, good_y);
   }
 }
 
-void TestIfBadThingHitsGoodThing(int badx, int bady)
+void TestIfBadThingHitsGoodThing(int bad_x, int bad_y, int bad_move_dir)
 {
-  int i, killx = badx, killy = bady;
-  static int xy[4][2] =
+  int i, kill_x = -1, kill_y = -1;
+  int bad_element = Feld[bad_x][bad_y];
+  static int test_xy[4][2] =
   {
     { 0, -1 },
     { -1, 0 },
     { +1, 0 },
     { 0, +1 }
   };
-  static int harmless[4] =
+  static int test_dir[4] =
   {
     MV_UP,
     MV_LEFT,
@@ -3991,66 +5499,117 @@ void TestIfBadThingHitsGoodThing(int badx, int bady)
     MV_DOWN
   };
 
+  if (bad_element == EL_EXPLODING)	/* skip just exploding bad things */
+    return;
+
   for (i=0; i<4; i++)
   {
-    int x, y, element;
+    int test_x, test_y, test_move_dir, test_element;
 
-    x = badx + xy[i][0];
-    y = bady + xy[i][1];
-    if (!IN_LEV_FIELD(x, y))
+    test_x = bad_x + test_xy[i][0];
+    test_y = bad_y + test_xy[i][1];
+    if (!IN_LEV_FIELD(test_x, test_y))
       continue;
 
-    element = Feld[x][y];
+    test_move_dir =
+      (IS_MOVING(test_x, test_y) ? MovDir[test_x][test_y] : MV_NO_MOVING);
 
-    if (IS_PLAYER(x, y))
-    {
-      killx = x;
-      killy = y;
-      break;
-    }
-    else if (element == EL_PINGUIN)
+    test_element = Feld[test_x][test_y];
+
+    /* 1st case: good thing is moving towards DONT_GO_TO style bad thing;
+       2nd case: DONT_TOUCH style bad thing does not move away from good thing
+    */
+    if ((DONT_GO_TO(bad_element) &&  bad_move_dir == test_dir[i]) ||
+	(DONT_TOUCH(bad_element) && test_move_dir != test_dir[i]))
     {
-      if (MovDir[x][y] == harmless[i] && IS_MOVING(x, y))
-	continue;
+      /* good thing is player or penguin that does not move away */
+      if (IS_PLAYER(test_x, test_y))
+      {
+	struct PlayerInfo *player = PLAYERINFO(test_x, test_y);
 
-      killx = x;
-      killy = y;
-      break;
+	if (bad_element == EL_ROBOT && player->is_moving)
+	  continue;	/* robot does not kill player if he is moving */
+
+	kill_x = test_x;
+	kill_y = test_y;
+	break;
+      }
+      else if (test_element == EL_PINGUIN)
+      {
+	kill_x = test_x;
+	kill_y = test_y;
+	break;
+      }
     }
   }
 
-  if (killx != badx || killy != bady)
+  if (kill_x != -1 || kill_y != -1)
   {
-    if (IS_PLAYER(killx, killy))
-      KillHero(PLAYERINFO(killx, killy));
+    if (IS_PLAYER(kill_x, kill_y))
+    {
+      struct PlayerInfo *player = PLAYERINFO(kill_x, kill_y);
+
+#if 0
+      int dir = player->MovDir;
+      int newx = player->jx + (dir == MV_LEFT ? -1 : dir == MV_RIGHT ? +1 : 0);
+      int newy = player->jy + (dir == MV_UP   ? -1 : dir == MV_DOWN  ? +1 : 0);
+
+      if (Feld[bad_x][bad_y] == EL_ROBOT && player->is_moving &&
+	  newx != bad_x && newy != bad_y)
+	;	/* robot does not kill player if he is moving */
+      else
+	printf("-> %d\n", player->MovDir);
+
+      if (Feld[bad_x][bad_y] == EL_ROBOT && player->is_moving &&
+	  newx != bad_x && newy != bad_y)
+	;	/* robot does not kill player if he is moving */
+      else
+	;
+#endif
+
+      if (player->shield_active_time_left > 0)
+	Bang(bad_x, bad_y);
+      else if (!PLAYER_PROTECTED(kill_x, kill_y))
+	KillHero(player);
+    }
     else
-      Bang(killx, killy);
+      Bang(kill_x, kill_y);
   }
 }
 
-void TestIfHeroHitsBadThing(int x, int y)
+void TestIfHeroTouchesBadThing(int x, int y)
+{
+  TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
+}
+
+void TestIfHeroRunsIntoBadThing(int x, int y, int move_dir)
+{
+  TestIfGoodThingHitsBadThing(x, y, move_dir);
+}
+
+void TestIfBadThingTouchesHero(int x, int y)
 {
-  TestIfGoodThingHitsBadThing(x, y);
+  TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
 }
 
-void TestIfBadThingHitsHero(int x, int y)
+void TestIfBadThingRunsIntoHero(int x, int y, int move_dir)
 {
-  TestIfBadThingHitsGoodThing(x, y);
+  TestIfBadThingHitsGoodThing(x, y, move_dir);
 }
 
-void TestIfFriendHitsBadThing(int x, int y)
+void TestIfFriendTouchesBadThing(int x, int y)
 {
-  TestIfGoodThingHitsBadThing(x, y);
+  TestIfGoodThingHitsBadThing(x, y, MV_NO_MOVING);
 }
 
-void TestIfBadThingHitsFriend(int x, int y)
+void TestIfBadThingTouchesFriend(int x, int y)
 {
-  TestIfBadThingHitsGoodThing(x, y);
+  TestIfBadThingHitsGoodThing(x, y, MV_NO_MOVING);
 }
 
-void TestIfBadThingHitsOtherBadThing(int badx, int bady)
+void TestIfBadThingTouchesOtherBadThing(int bad_x, int bad_y)
 {
-  int i, killx = badx, killy = bady;
+  int i, kill_x = bad_x, kill_y = bad_y;
   static int xy[4][2] =
   {
     { 0, -1 },
@@ -4063,8 +5622,8 @@ void TestIfBadThingHitsOtherBadThing(int badx, int bady)
   {
     int x, y, element;
 
-    x=badx + xy[i][0];
-    y=bady + xy[i][1];
+    x = bad_x + xy[i][0];
+    y = bad_y + xy[i][1];
     if (!IN_LEV_FIELD(x, y))
       continue;
 
@@ -4072,39 +5631,49 @@ void TestIfBadThingHitsOtherBadThing(int badx, int bady)
     if (IS_AMOEBOID(element) || element == EL_LIFE ||
 	element == EL_AMOEBING || element == EL_TROPFEN)
     {
-      killx = x;
-      killy = y;
+      kill_x = x;
+      kill_y = y;
       break;
     }
   }
 
-  if (killx != badx || killy != bady)
-    Bang(badx, bady);
+  if (kill_x != bad_x || kill_y != bad_y)
+    Bang(bad_x, bad_y);
 }
 
 void KillHero(struct PlayerInfo *player)
 {
   int jx = player->jx, jy = player->jy;
 
-  if (player->gone)
+  if (!player->active)
     return;
 
   if (IS_PFORTE(Feld[jx][jy]))
     Feld[jx][jy] = EL_LEERRAUM;
 
+  /* deactivate shield (else Bang()/Explode() would not work right) */
+  player->shield_passive_time_left = 0;
+  player->shield_active_time_left = 0;
+
   Bang(jx, jy);
   BuryHero(player);
 }
 
+static void KillHeroUnlessProtected(int x, int y)
+{
+  if (!PLAYER_PROTECTED(x, y))
+    KillHero(PLAYERINFO(x, y));
+}
+
 void BuryHero(struct PlayerInfo *player)
 {
   int jx = player->jx, jy = player->jy;
 
-  if (player->gone)
+  if (!player->active)
     return;
 
-  PlaySoundLevel(jx, jy, SND_AUTSCH);
-  PlaySoundLevel(jx, jy, SND_LACHEN);
+  PlaySoundLevel(jx, jy, SND_PLAYER_DYING);
+  PlaySoundLevel(jx, jy, SND_GAME_LOSING);
 
   player->GameOver = TRUE;
   RemoveHero(player);
@@ -4115,11 +5684,14 @@ void RemoveHero(struct PlayerInfo *player)
   int jx = player->jx, jy = player->jy;
   int i, found = FALSE;
 
-  player->gone = TRUE;
-  StorePlayer[jx][jy] = 0;
+  player->present = FALSE;
+  player->active = FALSE;
+
+  if (!ExplodeField[jx][jy])
+    StorePlayer[jx][jy] = 0;
 
   for (i=0; i<MAX_PLAYERS; i++)
-    if (stored_player[i].active && !stored_player[i].gone)
+    if (stored_player[i].active)
       found = TRUE;
 
   if (!found)
@@ -4134,6 +5706,10 @@ int DigField(struct PlayerInfo *player,
 {
   int jx = player->jx, jy = player->jy;
   int dx = x - jx, dy = y - jy;
+  int move_direction = (dx == -1 ? MV_LEFT :
+			dx == +1 ? MV_RIGHT :
+			dy == -1 ? MV_UP :
+			dy == +1 ? MV_DOWN : MV_NO_MOVING);
   int element;
 
   if (!player->MovPos)
@@ -4141,6 +5717,7 @@ int DigField(struct PlayerInfo *player,
 
   if (mode == DF_NO_PUSH)
   {
+    player->Switching = FALSE;
     player->push_delay = 0;
     return MF_NO_ACTION;
   }
@@ -4148,15 +5725,60 @@ int DigField(struct PlayerInfo *player,
   if (IS_MOVING(x, y) || IS_PLAYER(x, y))
     return MF_NO_ACTION;
 
+  if (IS_TUBE(Feld[jx][jy]))
+  {
+    int i = 0;
+    int tube_leave_directions[][2] =
+    {
+      { EL_TUBE_CROSS,		MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
+      { EL_TUBE_VERTICAL,	                     MV_UP | MV_DOWN },
+      { EL_TUBE_HORIZONTAL,	MV_LEFT | MV_RIGHT                   },
+      { EL_TUBE_VERT_LEFT,	MV_LEFT |            MV_UP | MV_DOWN },
+      { EL_TUBE_VERT_RIGHT,	          MV_RIGHT | MV_UP | MV_DOWN },
+      { EL_TUBE_HORIZ_UP,	MV_LEFT | MV_RIGHT | MV_UP           },
+      { EL_TUBE_HORIZ_DOWN,	MV_LEFT | MV_RIGHT |         MV_DOWN },
+      { EL_TUBE_LEFT_UP,	MV_LEFT |            MV_UP           },
+      { EL_TUBE_LEFT_DOWN,	MV_LEFT |                    MV_DOWN },
+      { EL_TUBE_RIGHT_UP,	          MV_RIGHT | MV_UP           },
+      { EL_TUBE_RIGHT_DOWN,	          MV_RIGHT |         MV_DOWN },
+      { -1,                     MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN }
+    };
+
+    while (tube_leave_directions[i][0] != Feld[jx][jy])
+    {
+      i++;
+      if (tube_leave_directions[i][0] == -1)	/* should not happen */
+	break;
+    }
+
+    if (!(tube_leave_directions[i][1] & move_direction))
+      return MF_NO_ACTION;	/* tube has no opening in this direction */
+  }
+
   element = Feld[x][y];
 
-  switch(element)
+  switch (element)
   {
     case EL_LEERRAUM:
-      break;
-
     case EL_ERDREICH:
-      Feld[x][y] = EL_LEERRAUM;
+    case EL_SAND_INVISIBLE:
+    case EL_TRAP_INACTIVE:
+    case EL_SP_BASE:
+    case EL_SP_BUG:
+      RemoveField(x, y);
+
+      if (element == EL_LEERRAUM)
+	PlaySoundLevel(x, y, SND_EMPTY_SPACE_DIGGING);
+      else if (element == EL_ERDREICH)
+	PlaySoundLevel(x, y, SND_SAND_DIGGING);
+      else if (element == EL_SAND_INVISIBLE)
+	PlaySoundLevel(x, y, SND_SAND_INVISIBLE_DIGGING);
+      else if (element == EL_TRAP_INACTIVE)
+	PlaySoundLevel(x, y, SND_TRAP_INACTIVE_DIGGING);
+      else if (element == EL_SP_BASE)
+	PlaySoundLevel(x, y, SND_SP_BASE_DIGGING);
+      else if (element == EL_SP_BUG)
+	PlaySoundLevel(x, y, SND_SP_BUGGY_BASE_DIGGING);
       break;
 
     case EL_EDELSTEIN:
@@ -4166,55 +5788,101 @@ int DigField(struct PlayerInfo *player,
     case EL_EDELSTEIN_LILA:
     case EL_DIAMANT:
     case EL_SP_INFOTRON:
+    case EL_PEARL:
+    case EL_CRYSTAL:
       RemoveField(x, y);
-      local_player->gems_still_needed -= (element == EL_DIAMANT ? 3 : 1);
+      local_player->gems_still_needed -= (element == EL_DIAMANT ? 3 :
+					  element == EL_PEARL ? 5 :
+					  element == EL_CRYSTAL ? 8 : 1);
       if (local_player->gems_still_needed < 0)
 	local_player->gems_still_needed = 0;
       RaiseScoreElement(element);
       DrawText(DX_EMERALDS, DY_EMERALDS,
 	       int2str(local_player->gems_still_needed, 3),
 	       FS_SMALL, FC_YELLOW);
-      PlaySoundLevel(x, y, SND_PONG);
+
+      if (element == EL_EDELSTEIN_BD)
+	PlaySoundLevel(x, y, SND_BD_DIAMOND_COLLECTING);
+      else if (element == EL_DIAMANT)
+	PlaySoundLevel(x, y, SND_DIAMOND_COLLECTING);
+      else if (element == EL_SP_INFOTRON)
+	PlaySoundLevel(x, y, SND_SP_INFOTRON_COLLECTING);
+      else if (element == EL_PEARL)
+	PlaySoundLevel(x, y, SND_PEARL_COLLECTING);
+      else if (element == EL_CRYSTAL)
+	PlaySoundLevel(x, y, SND_CRYSTAL_COLLECTING);
+      else	/* EL_EDELSTEIN style element */
+	PlaySoundLevel(x, y, SND_EMERALD_COLLECTING);
       break;
 
     case EL_SPEED_PILL:
       RemoveField(x, y);
-      MoveSpeed = 4;
-      ScrollStepSize = TILEX/4;
-      PlaySoundLevel(x, y, SND_PONG);
+      player->move_delay_value = MOVE_DELAY_HIGH_SPEED;
+      PlaySoundLevel(x, y, SND_SPEED_PILL_COLLECTING);
+      break;
+
+    case EL_ENVELOPE:
+      Feld[x][y] = EL_LEERRAUM;
+      PlaySoundLevel(x, y, SND_ENVELOPE_COLLECTING);
+      break;
+
+    case EL_EXTRA_TIME:
+      RemoveField(x, y);
+      if (level.time > 0)
+      {
+	TimeLeft += 10;
+	DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
+      }
+      PlaySoundStereo(SND_EXTRA_TIME_COLLECTING, PSND_MAX_RIGHT);
+      break;
+
+    case EL_SHIELD_PASSIVE:
+      RemoveField(x, y);
+      player->shield_passive_time_left += 10;
+      PlaySoundLevel(x, y, SND_SHIELD_PASSIVE_COLLECTING);
+      break;
+
+    case EL_SHIELD_ACTIVE:
+      RemoveField(x, y);
+      player->shield_passive_time_left += 10;
+      player->shield_active_time_left += 10;
+      PlaySoundLevel(x, y, SND_SHIELD_ACTIVE_COLLECTING);
       break;
 
-    case EL_DYNAMIT_AUS:
+    case EL_DYNAMITE_INACTIVE:
     case EL_SP_DISK_RED:
       RemoveField(x, y);
       player->dynamite++;
-      RaiseScoreElement(EL_DYNAMIT);
+      RaiseScoreElement(EL_DYNAMITE_INACTIVE);
       DrawText(DX_DYNAMITE, DY_DYNAMITE,
 	       int2str(local_player->dynamite, 3),
 	       FS_SMALL, FC_YELLOW);
-      PlaySoundLevel(x, y, SND_PONG);
+      if (element == EL_SP_DISK_RED)
+	PlaySoundLevel(x, y, SND_SP_DISK_RED_COLLECTING);
+      else
+	PlaySoundLevel(x, y, SND_DYNAMITE_COLLECTING);
       break;
 
     case EL_DYNABOMB_NR:
       RemoveField(x, y);
       player->dynabomb_count++;
       player->dynabombs_left++;
-      RaiseScoreElement(EL_DYNAMIT);
-      PlaySoundLevel(x, y, SND_PONG);
+      RaiseScoreElement(EL_DYNAMITE_INACTIVE);
+      PlaySoundLevel(x, y, SND_DYNABOMB_NR_COLLECTING);
       break;
 
     case EL_DYNABOMB_SZ:
       RemoveField(x, y);
       player->dynabomb_size++;
-      RaiseScoreElement(EL_DYNAMIT);
-      PlaySoundLevel(x, y, SND_PONG);
+      RaiseScoreElement(EL_DYNAMITE_INACTIVE);
+      PlaySoundLevel(x, y, SND_DYNABOMB_SZ_COLLECTING);
       break;
 
     case EL_DYNABOMB_XL:
       RemoveField(x, y);
       player->dynabomb_xl = TRUE;
-      RaiseScoreElement(EL_DYNAMIT);
-      PlaySoundLevel(x, y, SND_PONG);
+      RaiseScoreElement(EL_DYNAMITE_INACTIVE);
+      PlaySoundLevel(x, y, SND_DYNABOMB_XL_COLLECTING);
       break;
 
     case EL_SCHLUESSEL1:
@@ -4222,18 +5890,34 @@ int DigField(struct PlayerInfo *player,
     case EL_SCHLUESSEL3:
     case EL_SCHLUESSEL4:
     {
-      int key_nr = element-EL_SCHLUESSEL1;
+      int key_nr = element - EL_SCHLUESSEL1;
+
+      RemoveField(x, y);
+      player->key[key_nr] = TRUE;
+      RaiseScoreElement(EL_SCHLUESSEL);
+      DrawMiniGraphicExt(drawto, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
+			 GFX_SCHLUESSEL1 + key_nr);
+      DrawMiniGraphicExt(window, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
+			 GFX_SCHLUESSEL1 + key_nr);
+      PlaySoundLevel(x, y, SND_KEY_COLLECTING);
+      break;
+    }
+
+    case EL_EM_KEY_1:
+    case EL_EM_KEY_2:
+    case EL_EM_KEY_3:
+    case EL_EM_KEY_4:
+    {
+      int key_nr = element - EL_EM_KEY_1;
 
       RemoveField(x, y);
       player->key[key_nr] = TRUE;
       RaiseScoreElement(EL_SCHLUESSEL);
-      DrawMiniGraphicExt(drawto, gc,
-			 DX_KEYS+key_nr*MINI_TILEX, DY_KEYS,
-			 GFX_SCHLUESSEL1+key_nr);
-      DrawMiniGraphicExt(window, gc,
-			 DX_KEYS+key_nr*MINI_TILEX, DY_KEYS,
-			 GFX_SCHLUESSEL1+key_nr);
-      PlaySoundLevel(x, y, SND_PONG);
+      DrawMiniGraphicExt(drawto, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
+			 GFX_SCHLUESSEL1 + key_nr);
+      DrawMiniGraphicExt(window, DX_KEYS + key_nr * MINI_TILEX, DY_KEYS,
+			 GFX_SCHLUESSEL1 + key_nr);
+      PlaySoundLevel(x, y, SND_KEY_COLLECTING);
       break;
     }
 
@@ -4242,6 +5926,7 @@ int DigField(struct PlayerInfo *player,
       ZX = x;
       ZY = y;
       DrawLevelField(x, y);
+      PlaySoundLevel(x, y, SND_ROBOT_WHEEL_ACTIVATING);
       return MF_ACTION;
       break;
 
@@ -4249,6 +5934,8 @@ int DigField(struct PlayerInfo *player,
       {
 	int xx, yy;
 
+	PlaySoundLevel(x, y, SND_SP_TERMINAL_ACTIVATING);
+
 	for (yy=0; yy<lev_fieldy; yy++)
 	{
 	  for (xx=0; xx<lev_fieldx; xx++)
@@ -4264,20 +5951,92 @@ int DigField(struct PlayerInfo *player,
       }
       break;
 
+    case EL_BELT1_SWITCH_LEFT:
+    case EL_BELT1_SWITCH_MIDDLE:
+    case EL_BELT1_SWITCH_RIGHT:
+    case EL_BELT2_SWITCH_LEFT:
+    case EL_BELT2_SWITCH_MIDDLE:
+    case EL_BELT2_SWITCH_RIGHT:
+    case EL_BELT3_SWITCH_LEFT:
+    case EL_BELT3_SWITCH_MIDDLE:
+    case EL_BELT3_SWITCH_RIGHT:
+    case EL_BELT4_SWITCH_LEFT:
+    case EL_BELT4_SWITCH_MIDDLE:
+    case EL_BELT4_SWITCH_RIGHT:
+      if (!player->Switching)
+      {
+	player->Switching = TRUE;
+	ToggleBeltSwitch(x, y);
+	PlaySoundLevel(x, y, SND_CONVEYOR_BELT_SWITCH_ACTIVATING);
+      }
+      return MF_ACTION;
+      break;
+
+    case EL_SWITCHGATE_SWITCH_1:
+    case EL_SWITCHGATE_SWITCH_2:
+      if (!player->Switching)
+      {
+	player->Switching = TRUE;
+	ToggleSwitchgateSwitch(x, y);
+	PlaySoundLevel(x, y, SND_SWITCHGATE_SWITCH_ACTIVATING);
+      }
+      return MF_ACTION;
+      break;
+
+    case EL_LIGHT_SWITCH_OFF:
+    case EL_LIGHT_SWITCH_ON:
+      if (!player->Switching)
+      {
+	player->Switching = TRUE;
+	ToggleLightSwitch(x, y);
+	PlaySoundLevel(x, y, element == EL_LIGHT_SWITCH_OFF ?
+		       SND_LIGHT_SWITCH_ACTIVATING :
+		       SND_LIGHT_SWITCH_DEACTIVATING);
+      }
+      return MF_ACTION;
+      break;
+
+    case EL_TIMEGATE_SWITCH_OFF:
+      ActivateTimegateSwitch(x, y);
+      PlaySoundLevel(x, y, SND_TIMEGATE_WHEEL_ACTIVATING);
+
+      return MF_ACTION;
+      break;
+
+    case EL_BALLOON_SEND_LEFT:
+    case EL_BALLOON_SEND_RIGHT:
+    case EL_BALLOON_SEND_UP:
+    case EL_BALLOON_SEND_DOWN:
+    case EL_BALLOON_SEND_ANY:
+      if (element == EL_BALLOON_SEND_ANY)
+	game.balloon_dir = move_direction;
+      else
+	game.balloon_dir = (element == EL_BALLOON_SEND_LEFT  ? MV_LEFT :
+			    element == EL_BALLOON_SEND_RIGHT ? MV_RIGHT :
+			    element == EL_BALLOON_SEND_UP    ? MV_UP :
+			    element == EL_BALLOON_SEND_DOWN  ? MV_DOWN :
+			    MV_NO_MOVING);
+
+      return MF_ACTION;
+      break;
+
     case EL_SP_EXIT:
       if (local_player->gems_still_needed > 0)
 	return MF_NO_ACTION;
 
       player->LevelSolved = player->GameOver = TRUE;
-      PlaySoundLevel(x, y, SND_BUING);
+      PlaySoundStereo(SND_SP_EXIT_ENTERING, PSND_MAX_RIGHT);
       break;
 
     case EL_FELSBROCKEN:
+    case EL_BD_ROCK:
     case EL_BOMBE:
+    case EL_DX_SUPABOMB:
     case EL_KOKOSNUSS:
     case EL_ZEIT_LEER:
     case EL_SP_ZONK:
     case EL_SP_DISK_ORANGE:
+    case EL_SPRING:
       if (dy || mode == DF_SNAP)
 	return MF_NO_ACTION;
 
@@ -4294,29 +6053,54 @@ int DigField(struct PlayerInfo *player,
 
       if (player->push_delay == 0)
 	player->push_delay = FrameCounter;
+#if 0
+      if (!FrameReached(&player->push_delay, player->push_delay_value) &&
+	  !tape.playing && element != EL_SPRING)
+	return MF_NO_ACTION;
+#else
       if (!FrameReached(&player->push_delay, player->push_delay_value) &&
-	  !tape.playing)
+	  !(tape.playing && tape.game_version < GAME_VERSION_2_0) &&
+	  element != EL_SPRING)
 	return MF_NO_ACTION;
+#endif
 
       RemoveField(x, y);
       Feld[x+dx][y+dy] = element;
 
-      player->push_delay_value = 2+RND(8);
+      if (element == EL_SPRING)
+      {
+	Feld[x+dx][y+dy] = EL_SPRING_MOVING;
+	MovDir[x+dx][y+dy] = move_direction;
+      }
+
+      player->push_delay_value = (element == EL_SPRING ? 0 : 2 + RND(8));
 
       DrawLevelField(x+dx, y+dy);
       if (element == EL_FELSBROCKEN)
-	PlaySoundLevel(x+dx, y+dy, SND_PUSCH);
+	PlaySoundLevel(x+dx, y+dy, SND_ROCK_PUSHING);
+      else if (element == EL_BD_ROCK)
+	PlaySoundLevel(x+dx, y+dy, SND_BD_ROCK_PUSHING);
+      else if (element == EL_BOMBE)
+	PlaySoundLevel(x+dx, y+dy, SND_BOMB_PUSHING);
+      else if (element == EL_DX_SUPABOMB)
+	PlaySoundLevel(x+dx, y+dy, SND_DX_BOMB_PUSHING);
       else if (element == EL_KOKOSNUSS)
-	PlaySoundLevel(x+dx, y+dy, SND_KNURK);
-      else
-	PlaySoundLevel(x+dx, y+dy, SND_KLOPF);
+	PlaySoundLevel(x+dx, y+dy, SND_NUT_PUSHING);
+      else if (element == EL_ZEIT_LEER)
+	PlaySoundLevel(x+dx, y+dy, SND_TIME_ORB_EMPTY_PUSHING);
+      else if (element == EL_SP_ZONK)
+	PlaySoundLevel(x+dx, y+dy, SND_SP_ZONK_PUSHING);
+      else if (element == EL_SP_DISK_ORANGE)
+	PlaySoundLevel(x+dx, y+dy, SND_SP_DISK_ORANGE_PUSHING);
+      else if (element == EL_SPRING)
+	PlaySoundLevel(x+dx, y+dy, SND_SPRING_PUSHING);
       break;
 
     case EL_PFORTE1:
     case EL_PFORTE2:
     case EL_PFORTE3:
     case EL_PFORTE4:
-      if (!player->key[element-EL_PFORTE1])
+      if (!player->key[element - EL_PFORTE1])
 	return MF_NO_ACTION;
       break;
 
@@ -4324,8 +6108,58 @@ int DigField(struct PlayerInfo *player,
     case EL_PFORTE2X:
     case EL_PFORTE3X:
     case EL_PFORTE4X:
-      if (!player->key[element-EL_PFORTE1X])
+      if (!player->key[element - EL_PFORTE1X])
+	return MF_NO_ACTION;
+      break;
+
+    case EL_EM_GATE_1:
+    case EL_EM_GATE_2:
+    case EL_EM_GATE_3:
+    case EL_EM_GATE_4:
+      if (!player->key[element - EL_EM_GATE_1])
+	return MF_NO_ACTION;
+      if (!IN_LEV_FIELD(x + dx, y + dy) || !IS_FREE(x + dx, y + dy))
+	return MF_NO_ACTION;
+
+      /* automatically move to the next field with double speed */
+      player->programmed_action = move_direction;
+      DOUBLE_PLAYER_SPEED(player);
+
+      PlaySoundLevel(x, y, SND_GATE_PASSING);
+
+      break;
+
+    case EL_EM_GATE_1X:
+    case EL_EM_GATE_2X:
+    case EL_EM_GATE_3X:
+    case EL_EM_GATE_4X:
+      if (!player->key[element - EL_EM_GATE_1X])
+	return MF_NO_ACTION;
+      if (!IN_LEV_FIELD(x + dx, y + dy) || !IS_FREE(x + dx, y + dy))
 	return MF_NO_ACTION;
+
+      /* automatically move to the next field with double speed */
+      player->programmed_action = move_direction;
+      DOUBLE_PLAYER_SPEED(player);
+
+      PlaySoundLevel(x, y, SND_GATE_PASSING);
+
+      break;
+
+    case EL_SWITCHGATE_OPEN:
+    case EL_TIMEGATE_OPEN:
+      if (!IN_LEV_FIELD(x + dx, y + dy) || !IS_FREE(x + dx, y + dy))
+	return MF_NO_ACTION;
+
+      /* automatically move to the next field with double speed */
+      player->programmed_action = move_direction;
+      DOUBLE_PLAYER_SPEED(player);
+
+      if (element == EL_SWITCHGATE_OPEN)
+	PlaySoundLevel(x, y, SND_SWITCHGATE_PASSING);
+      else
+	PlaySoundLevel(x, y, SND_TIMEGATE_PASSING);
+
       break;
 
     case EL_SP_PORT1_LEFT:
@@ -4362,6 +6196,53 @@ int DigField(struct PlayerInfo *player,
 	  !IN_LEV_FIELD(x + dx, y + dy) ||
 	  !IS_FREE(x + dx, y + dy))
 	return MF_NO_ACTION;
+
+      /* automatically move to the next field with double speed */
+      player->programmed_action = move_direction;
+      DOUBLE_PLAYER_SPEED(player);
+
+      PlaySoundLevel(x, y, SND_SP_PORT_PASSING);
+      break;
+
+    case EL_TUBE_CROSS:
+    case EL_TUBE_VERTICAL:
+    case EL_TUBE_HORIZONTAL:
+    case EL_TUBE_VERT_LEFT:
+    case EL_TUBE_VERT_RIGHT:
+    case EL_TUBE_HORIZ_UP:
+    case EL_TUBE_HORIZ_DOWN:
+    case EL_TUBE_LEFT_UP:
+    case EL_TUBE_LEFT_DOWN:
+    case EL_TUBE_RIGHT_UP:
+    case EL_TUBE_RIGHT_DOWN:
+      {
+	int i = 0;
+	int tube_enter_directions[][2] =
+	{
+	  { EL_TUBE_CROSS,	MV_LEFT | MV_RIGHT | MV_UP | MV_DOWN },
+	  { EL_TUBE_VERTICAL,	                     MV_UP | MV_DOWN },
+	  { EL_TUBE_HORIZONTAL,	MV_LEFT | MV_RIGHT                   },
+	  { EL_TUBE_VERT_LEFT,	          MV_RIGHT | MV_UP | MV_DOWN },
+	  { EL_TUBE_VERT_RIGHT,	MV_LEFT            | MV_UP | MV_DOWN },
+	  { EL_TUBE_HORIZ_UP,	MV_LEFT | MV_RIGHT |         MV_DOWN },
+	  { EL_TUBE_HORIZ_DOWN,	MV_LEFT | MV_RIGHT | MV_UP           },
+	  { EL_TUBE_LEFT_UP,	          MV_RIGHT |         MV_DOWN },
+	  { EL_TUBE_LEFT_DOWN,	          MV_RIGHT | MV_UP           },
+	  { EL_TUBE_RIGHT_UP,	MV_LEFT |                    MV_DOWN },
+	  { EL_TUBE_RIGHT_DOWN,	MV_LEFT |            MV_UP           },
+	  { -1,			MV_NO_MOVING                         }
+	};
+
+	while (tube_enter_directions[i][0] != element)
+	{
+	  i++;
+	  if (tube_enter_directions[i][0] == -1)	/* should not happen */
+	    break;
+	}
+
+	if (!(tube_enter_directions[i][1] & move_direction))
+	  return MF_NO_ACTION;	/* tube has no opening in this direction */
+      }
       break;
 
     case EL_AUSGANG_ZU:
@@ -4374,15 +6255,7 @@ int DigField(struct PlayerInfo *player,
       if (mode == DF_SNAP)
 	return MF_NO_ACTION;
 
-      PlaySoundLevel(x, y, SND_BUING);
-
-      /*
-      player->gone = TRUE;
-      PlaySoundLevel(x, y, SND_BUING);
-
-      if (!local_player->friends_still_needed)
-	player->LevelSolved = player->GameOver = TRUE;
-      */
+      PlaySoundLevel(x, y, SND_EXIT_ENTERING);
 
       break;
 
@@ -4390,7 +6263,7 @@ int DigField(struct PlayerInfo *player,
       Feld[x][y] = EL_BIRNE_EIN;
       local_player->lights_still_needed--;
       DrawLevelField(x, y);
-      PlaySoundLevel(x, y, SND_DENG);
+      PlaySoundLevel(x, y, SND_LAMP_ACTIVATING);
       return MF_ACTION;
       break;
 
@@ -4399,17 +6272,18 @@ int DigField(struct PlayerInfo *player,
       TimeLeft += 10;
       DrawText(DX_TIME, DY_TIME, int2str(TimeLeft, 3), FS_SMALL, FC_YELLOW);
       DrawLevelField(x, y);
-      PlaySoundStereo(SND_GONG, PSND_MAX_RIGHT);
+      PlaySoundStereo(SND_TIME_ORB_FULL_COLLECTING, PSND_MAX_RIGHT);
       return MF_ACTION;
       break;
 
     case EL_SOKOBAN_FELD_LEER:
       break;
 
-    case EL_SOKOBAN_FELD_VOLL:
     case EL_SOKOBAN_OBJEKT:
+    case EL_SOKOBAN_FELD_VOLL:
     case EL_SONDE:
     case EL_SP_DISK_YELLOW:
+    case EL_BALLOON:
       if (mode == DF_SNAP)
 	return MF_NO_ACTION;
 
@@ -4434,9 +6308,16 @@ int DigField(struct PlayerInfo *player,
 
       if (player->push_delay == 0)
 	player->push_delay = FrameCounter;
+#if 0
+      if (!FrameReached(&player->push_delay, player->push_delay_value) &&
+	  !tape.playing && element != EL_BALLOON)
+	return MF_NO_ACTION;
+#else
       if (!FrameReached(&player->push_delay, player->push_delay_value) &&
-	  !tape.playing)
+	  !(tape.playing && tape.game_version < GAME_VERSION_2_0) &&
+	  element != EL_BALLOON)
 	return MF_NO_ACTION;
+#endif
 
       if (IS_SB_ELEMENT(element))
       {
@@ -4453,10 +6334,18 @@ int DigField(struct PlayerInfo *player,
 	  Feld[x+dx][y+dy] = EL_SOKOBAN_FELD_VOLL;
 	  local_player->sokobanfields_still_needed--;
 	  if (element == EL_SOKOBAN_OBJEKT)
-	    PlaySoundLevel(x, y, SND_DENG);
+	    PlaySoundLevel(x, y, SND_SOKOBAN_FIELD_FILLING);
+	  else
+	    PlaySoundLevel(x, y, SND_SOKOBAN_OBJECT_PUSHING);
 	}
 	else
+	{
 	  Feld[x+dx][y+dy] = EL_SOKOBAN_OBJEKT;
+	  if (element == EL_SOKOBAN_FELD_VOLL)
+	    PlaySoundLevel(x, y, SND_SOKOBAN_FIELD_CLEARING);
+	  else
+	    PlaySoundLevel(x, y, SND_SOKOBAN_OBJECT_PUSHING);
+	}
       }
       else
       {
@@ -4464,35 +6353,34 @@ int DigField(struct PlayerInfo *player,
 	Feld[x+dx][y+dy] = element;
       }
 
-      player->push_delay_value = 2;
+      player->push_delay_value = (element == EL_BALLOON ? 0 : 2);
 
       DrawLevelField(x, y);
       DrawLevelField(x+dx, y+dy);
-      PlaySoundLevel(x+dx, y+dy, SND_PUSCH);
+      if (element == EL_SONDE)
+	PlaySoundLevel(x+dx, y+dy, SND_SATELLITE_PUSHING);
+      else if (element == EL_SP_DISK_YELLOW)
+	PlaySoundLevel(x+dx, y+dy, SND_SP_DISK_YELLOW_PUSHING);
+      else if (element == EL_BALLOON)
+	PlaySoundLevel(x+dx, y+dy, SND_BALLOON_PUSHING);
 
       if (IS_SB_ELEMENT(element) &&
 	  local_player->sokobanfields_still_needed == 0 &&
-	  game_emulation == EMU_SOKOBAN)
+	  game.emulation == EMU_SOKOBAN)
       {
 	player->LevelSolved = player->GameOver = TRUE;
-	PlaySoundLevel(x, y, SND_BUING);
+	PlaySoundLevel(x, y, SND_SOKOBAN_GAME_SOLVING);
       }
 
       break;
 
-    case EL_MAULWURF:
     case EL_PINGUIN:
     case EL_SCHWEIN:
     case EL_DRACHE:
       break;
 
     default:
-      if (IS_EATABLE(element))		/* other kinds of 'dirt' */
-	Feld[x][y] = EL_LEERRAUM;
-      else
-	return MF_NO_ACTION;
-
-      break;
+      return MF_NO_ACTION;
   }
 
   player->push_delay = 0;
@@ -4505,7 +6393,7 @@ boolean SnapField(struct PlayerInfo *player, int dx, int dy)
   int jx = player->jx, jy = player->jy;
   int x = jx + dx, y = jy + dy;
 
-  if (player->gone || !IN_LEV_FIELD(x, y))
+  if (!player->active || !IN_LEV_FIELD(x, y))
     return FALSE;
 
   if (dx && dy)
@@ -4540,14 +6428,13 @@ boolean PlaceBomb(struct PlayerInfo *player)
   int jx = player->jx, jy = player->jy;
   int element;
 
-  if (player->gone || player->MovPos)
+  if (!player->active || player->MovPos)
     return FALSE;
 
   element = Feld[jx][jy];
 
   if ((player->dynamite == 0 && player->dynabombs_left == 0) ||
-      element == EL_DYNAMIT || element == EL_DYNABOMB ||
-      element == EL_EXPLODING)
+      IS_ACTIVE_BOMB(element) || element == EL_EXPLODING)
     return FALSE;
 
   if (element != EL_LEERRAUM)
@@ -4555,61 +6442,72 @@ boolean PlaceBomb(struct PlayerInfo *player)
 
   if (player->dynamite)
   {
-    Feld[jx][jy] = EL_DYNAMIT;
+    Feld[jx][jy] = EL_DYNAMITE_ACTIVE;
     MovDelay[jx][jy] = 96;
     player->dynamite--;
     DrawText(DX_DYNAMITE, DY_DYNAMITE, int2str(local_player->dynamite, 3),
 	     FS_SMALL, FC_YELLOW);
     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
-      DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), GFX_DYNAMIT);
+    {
+      if (game.emulation == EMU_SUPAPLEX)
+	DrawGraphic(SCREENX(jx), SCREENY(jy), GFX_SP_DISK_RED);
+      else
+	DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), GFX_DYNAMIT);
+    }
+
+    PlaySoundLevel(jx, jy, SND_DYNAMITE_PLACING);
   }
   else
   {
-    Feld[jx][jy] = EL_DYNABOMB;
-    Store2[jx][jy] = player->element_nr;	/* for DynaExplode() */
+    Feld[jx][jy] = EL_DYNABOMB_ACTIVE_1 + (player->element_nr - EL_SPIELER1);
     MovDelay[jx][jy] = 96;
     player->dynabombs_left--;
     if (IN_SCR_FIELD(SCREENX(jx), SCREENY(jy)))
       DrawGraphicThruMask(SCREENX(jx), SCREENY(jy), GFX_DYNABOMB);
+
+    PlaySoundLevel(jx, jy, SND_DYNABOMB_PLACING);
   }
 
   return TRUE;
 }
 
-void PlaySoundLevel(int x, int y, int sound_nr)
+void PlaySoundLevel(int x, int y, int nr)
 {
   int sx = SCREENX(x), sy = SCREENY(y);
-  int volume, stereo;
+  int volume, stereo_position;
   int silence_distance = 8;
+  int type = (IS_LOOP_SOUND(nr) ? SND_CTRL_PLAY_LOOP : SND_CTRL_PLAY_SOUND);
 
-  if ((!setup.sound_simple && !IS_LOOP_SOUND(sound_nr)) ||
-      (!setup.sound_loops && IS_LOOP_SOUND(sound_nr)))
+  if ((!setup.sound_simple && !IS_LOOP_SOUND(nr)) ||
+      (!setup.sound_loops && IS_LOOP_SOUND(nr)))
     return;
 
   if (!IN_LEV_FIELD(x, y) ||
-      sx < -silence_distance || sx >= SCR_FIELDX+silence_distance ||
-      sy < -silence_distance || sy >= SCR_FIELDY+silence_distance)
+      sx < -silence_distance || sx >= SCR_FIELDX + silence_distance ||
+      sy < -silence_distance || sy >= SCR_FIELDY + silence_distance)
     return;
 
   volume = PSND_MAX_VOLUME;
 
-#ifndef MSDOS
-  stereo = (sx-SCR_FIELDX/2)*12;
+#if !defined(PLATFORM_MSDOS)
+  stereo_position = (sx - SCR_FIELDX / 2) * 12;
 #else
-  stereo = PSND_MIDDLE+(2*sx-(SCR_FIELDX-1))*5;
-  if(stereo > PSND_MAX_RIGHT) stereo = PSND_MAX_RIGHT;
-  if(stereo < PSND_MAX_LEFT) stereo = PSND_MAX_LEFT;
+  stereo_position = PSND_MIDDLE + (2 * sx - (SCR_FIELDX - 1)) * 5;
+  if (stereo_position > PSND_MAX_RIGHT)
+    stereo_position = PSND_MAX_RIGHT;
+  if (stereo_position < PSND_MAX_LEFT)
+    stereo_position = PSND_MAX_LEFT;
 #endif
 
   if (!IN_SCR_FIELD(sx, sy))
   {
-    int dx = ABS(sx-SCR_FIELDX/2)-SCR_FIELDX/2;
-    int dy = ABS(sy-SCR_FIELDY/2)-SCR_FIELDY/2;
+    int dx = ABS(sx - SCR_FIELDX/2) - SCR_FIELDX/2;
+    int dy = ABS(sy - SCR_FIELDY/2) - SCR_FIELDY/2;
 
-    volume -= volume*(dx > dy ? dx : dy)/silence_distance;
+    volume -= volume * (dx > dy ? dx : dy) / silence_distance;
   }
 
-  PlaySoundExt(sound_nr, volume, stereo, PSND_NO_LOOP);
+  PlaySoundExt(nr, volume, stereo_position, type);
 }
 
 void RaiseScore(int value)
@@ -4654,7 +6552,7 @@ void RaiseScoreElement(int element)
     case EL_KOKOSNUSS:
       RaiseScore(level.score[SC_KOKOSNUSS]);
       break;
-    case EL_DYNAMIT:
+    case EL_DYNAMITE_INACTIVE:
       RaiseScore(level.score[SC_DYNAMIT]);
       break;
     case EL_SCHLUESSEL:
@@ -4664,3 +6562,240 @@ void RaiseScoreElement(int element)
       break;
   }
 }
+
+void RequestQuitGame(boolean ask_if_really_quit)
+{
+  if (AllPlayersGone ||
+      !ask_if_really_quit ||
+      level_editor_test_game ||
+      Request("Do you really want to quit the game ?",
+	      REQ_ASK | REQ_STAY_CLOSED))
+  {
+#if defined(PLATFORM_UNIX)
+    if (options.network)
+      SendToServer_StopPlaying();
+    else
+#endif
+    {
+      game_status = MAINMENU;
+      DrawMainMenu();
+    }
+  }
+  else
+  {
+    OpenDoor(DOOR_OPEN_1 | DOOR_COPY_BACK);
+  }
+}
+
+
+/* ---------- new game button stuff ---------------------------------------- */
+
+/* graphic position values for game buttons */
+#define GAME_BUTTON_XSIZE	30
+#define GAME_BUTTON_YSIZE	30
+#define GAME_BUTTON_XPOS	5
+#define GAME_BUTTON_YPOS	215
+#define SOUND_BUTTON_XPOS	5
+#define SOUND_BUTTON_YPOS	(GAME_BUTTON_YPOS + GAME_BUTTON_YSIZE)
+
+#define GAME_BUTTON_STOP_XPOS	(GAME_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
+#define GAME_BUTTON_PAUSE_XPOS	(GAME_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
+#define GAME_BUTTON_PLAY_XPOS	(GAME_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
+#define SOUND_BUTTON_MUSIC_XPOS	(SOUND_BUTTON_XPOS + 0 * GAME_BUTTON_XSIZE)
+#define SOUND_BUTTON_LOOPS_XPOS	(SOUND_BUTTON_XPOS + 1 * GAME_BUTTON_XSIZE)
+#define SOUND_BUTTON_SIMPLE_XPOS (SOUND_BUTTON_XPOS + 2 * GAME_BUTTON_XSIZE)
+
+static struct
+{
+  int x, y;
+  int gadget_id;
+  char *infotext;
+} gamebutton_info[NUM_GAME_BUTTONS] =
+{
+  {
+    GAME_BUTTON_STOP_XPOS,	GAME_BUTTON_YPOS,
+    GAME_CTRL_ID_STOP,
+    "stop game"
+  },
+  {
+    GAME_BUTTON_PAUSE_XPOS,	GAME_BUTTON_YPOS,
+    GAME_CTRL_ID_PAUSE,
+    "pause game"
+  },
+  {
+    GAME_BUTTON_PLAY_XPOS,	GAME_BUTTON_YPOS,
+    GAME_CTRL_ID_PLAY,
+    "play game"
+  },
+  {
+    SOUND_BUTTON_MUSIC_XPOS,	SOUND_BUTTON_YPOS,
+    SOUND_CTRL_ID_MUSIC,
+    "background music on/off"
+  },
+  {
+    SOUND_BUTTON_LOOPS_XPOS,	SOUND_BUTTON_YPOS,
+    SOUND_CTRL_ID_LOOPS,
+    "sound loops on/off"
+  },
+  {
+    SOUND_BUTTON_SIMPLE_XPOS,	SOUND_BUTTON_YPOS,
+    SOUND_CTRL_ID_SIMPLE,
+    "normal sounds on/off"
+  }
+};
+
+void CreateGameButtons()
+{
+  int i;
+
+  for (i=0; i<NUM_GAME_BUTTONS; i++)
+  {
+    Bitmap *gd_bitmap = pix[PIX_DOOR];
+    struct GadgetInfo *gi;
+    int button_type;
+    boolean checked;
+    unsigned long event_mask;
+    int gd_xoffset, gd_yoffset;
+    int gd_x1, gd_x2, gd_y1, gd_y2;
+    int id = i;
+
+    gd_xoffset = gamebutton_info[i].x;
+    gd_yoffset = gamebutton_info[i].y;
+    gd_x1 = DOOR_GFX_PAGEX4 + gd_xoffset;
+    gd_x2 = DOOR_GFX_PAGEX3 + gd_xoffset;
+
+    if (id == GAME_CTRL_ID_STOP ||
+	id == GAME_CTRL_ID_PAUSE ||
+	id == GAME_CTRL_ID_PLAY)
+    {
+      button_type = GD_TYPE_NORMAL_BUTTON;
+      checked = FALSE;
+      event_mask = GD_EVENT_RELEASED;
+      gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
+      gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
+    }
+    else
+    {
+      button_type = GD_TYPE_CHECK_BUTTON;
+      checked =
+	((id == SOUND_CTRL_ID_MUSIC && setup.sound_music) ||
+	 (id == SOUND_CTRL_ID_LOOPS && setup.sound_loops) ||
+	 (id == SOUND_CTRL_ID_SIMPLE && setup.sound_simple) ? TRUE : FALSE);
+      event_mask = GD_EVENT_PRESSED;
+      gd_y1  = DOOR_GFX_PAGEY1 + gd_yoffset;
+      gd_y2  = DOOR_GFX_PAGEY1 + gd_yoffset - GAME_BUTTON_YSIZE;
+    }
+
+    gi = CreateGadget(GDI_CUSTOM_ID, id,
+		      GDI_INFO_TEXT, gamebutton_info[i].infotext,
+		      GDI_X, DX + gd_xoffset,
+		      GDI_Y, DY + gd_yoffset,
+		      GDI_WIDTH, GAME_BUTTON_XSIZE,
+		      GDI_HEIGHT, GAME_BUTTON_YSIZE,
+		      GDI_TYPE, button_type,
+		      GDI_STATE, GD_BUTTON_UNPRESSED,
+		      GDI_CHECKED, checked,
+		      GDI_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y1,
+		      GDI_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y1,
+		      GDI_ALT_DESIGN_UNPRESSED, gd_bitmap, gd_x1, gd_y2,
+		      GDI_ALT_DESIGN_PRESSED, gd_bitmap, gd_x2, gd_y2,
+		      GDI_EVENT_MASK, event_mask,
+		      GDI_CALLBACK_ACTION, HandleGameButtons,
+		      GDI_END);
+
+    if (gi == NULL)
+      Error(ERR_EXIT, "cannot create gadget");
+
+    game_gadget[id] = gi;
+  }
+}
+
+static void MapGameButtons()
+{
+  int i;
+
+  for (i=0; i<NUM_GAME_BUTTONS; i++)
+    MapGadget(game_gadget[i]);
+}
+
+void UnmapGameButtons()
+{
+  int i;
+
+  for (i=0; i<NUM_GAME_BUTTONS; i++)
+    UnmapGadget(game_gadget[i]);
+}
+
+static void HandleGameButtons(struct GadgetInfo *gi)
+{
+  int id = gi->custom_id;
+
+  if (game_status != PLAYING)
+    return;
+
+  switch (id)
+  {
+    case GAME_CTRL_ID_STOP:
+      RequestQuitGame(TRUE);
+      break;
+
+    case GAME_CTRL_ID_PAUSE:
+      if (options.network)
+      {
+#if defined(PLATFORM_UNIX)
+	if (tape.pausing)
+	  SendToServer_ContinuePlaying();
+	else
+	  SendToServer_PausePlaying();
+#endif
+      }
+      else
+	TapeTogglePause(TAPE_TOGGLE_MANUAL);
+      break;
+
+    case GAME_CTRL_ID_PLAY:
+      if (tape.pausing)
+      {
+#if defined(PLATFORM_UNIX)
+	if (options.network)
+	  SendToServer_ContinuePlaying();
+	else
+#endif
+	{
+	  tape.pausing = FALSE;
+	  DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
+	}
+      }
+      break;
+
+    case SOUND_CTRL_ID_MUSIC:
+      if (setup.sound_music)
+      { 
+	setup.sound_music = FALSE;
+	FadeMusic();
+      }
+      else if (audio.music_available)
+      { 
+	setup.sound = setup.sound_music = TRUE;
+	PlayMusic(level_nr);
+      }
+      break;
+
+    case SOUND_CTRL_ID_LOOPS:
+      if (setup.sound_loops)
+	setup.sound_loops = FALSE;
+      else if (audio.loops_available)
+	setup.sound = setup.sound_loops = TRUE;
+      break;
+
+    case SOUND_CTRL_ID_SIMPLE:
+      if (setup.sound_simple)
+	setup.sound_simple = FALSE;
+      else if (audio.sound_available)
+	setup.sound = setup.sound_simple = TRUE;
+      break;
+
+    default:
+      break;
+  }
+}