X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame_em%2Fsynchro_2.c;h=7ed2bfbd93934b630cd8b5f88ce462e78eb6a763;hb=a4c71d580965e41a96f02d4014357a941eeef2fb;hp=e7d2b3a7d1be5348f74389680457d7434461aa8c;hpb=eff474825c141289a835a313dcd83fa1f461faab;p=rocksndiamonds.git

diff --git a/src/game_em/synchro_2.c b/src/game_em/synchro_2.c
index e7d2b3a7..7ed2bfbd 100644
--- a/src/game_em/synchro_2.c
+++ b/src/game_em/synchro_2.c
@@ -13,11 +13,47 @@
 
 #define SPRING_ROLL	/* spring rolling off round things continues to roll */
 
-#define RANDOM (random_em = random_em << 31 | random_em >> 1)
+#define RANDOM_RAW	(seed = seed << 31 | seed >> 1)
+#define RANDOM(x)	(RANDOM_RAW & (x - 1))
 
-static unsigned int random_em;
+static unsigned int seed;
 static int score;
 
+static void Lboom_bug(int x, int y)
+{
+  Next[x][y] = Znormal;
+  Boom[x-1][y-1] = Xemerald;
+  Boom[x][y-1] = Xemerald;
+  Boom[x+1][y-1] = Xemerald;
+  Boom[x-1][y] = Xemerald;
+  Boom[x][y] = Xdiamond;
+  Boom[x+1][y] = Xemerald;
+  Boom[x-1][y+1] = Xemerald;
+  Boom[x][y+1] = Xemerald;
+  Boom[x+1][y+1] = Xemerald;
+
+#if PLAY_ELEMENT_SOUND
+  play_element_sound(x, y, SOUND_boom, element);
+#endif
+}
+
+static void Lboom_tank(int x, int y)
+{
+  Next[x][y] = Znormal;
+  Boom[x-1][y-1] = Xblank;
+  Boom[x][y-1] = Xblank;
+  Boom[x+1][y-1] = Xblank;
+  Boom[x-1][y] = Xblank;
+  Boom[x][y] = Xblank;
+  Boom[x+1][y] = Xblank;
+  Boom[x-1][y+1] = Xblank;
+  Boom[x][y+1] = Xblank;
+  Boom[x+1][y+1] = Xblank;
+#if PLAY_ELEMENT_SOUND
+  play_element_sound(x, y, SOUND_boom, element);
+#endif
+}
+
 static void set_nearest_player_xy(int x, int y, int *dx, int *dy)
 {
   int distance, distance_shortest = EM_MAX_CAVE_WIDTH + EM_MAX_CAVE_HEIGHT;
@@ -44,447 +80,494 @@ static void set_nearest_player_xy(int x, int y, int *dx, int *dy)
   }
 }
 
-static void Lpush_stone_e(int x, int y)
+static void Lacid_1(int x, int y)
 {
-  switch (Cave[y][x+1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xstone;
-      Next[y][x] = Xstone;
-      return;
-
-    default:
-      Cave[y][x] = Ystone_eB;
-      Cave[y][x+1] = Ystone_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xstone_pause;
-      return;
-  }
+  Next[x][y] = Xacid_2;
 }
 
-static void Lpush_stone_w(int x, int y)
+static void Lacid_2(int x, int y)
 {
-  switch (Cave[y][x-1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xstone;
-      Next[y][x] = Xstone;
-      return;
-
-    default:
-      Cave[y][x] = Ystone_wB;
-      Cave[y][x-1] = Ystone_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xstone_pause;
-      return;
-  }
+  Next[x][y] = Xacid_3;
 }
 
-static void Lpush_nut_e(int x, int y)
+static void Lacid_3(int x, int y)
 {
-  switch (Cave[y][x+1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xnut;
-      Next[y][x] = Xnut;
-      return;
-
-    default:
-      Cave[y][x] = Ynut_eB;
-      Cave[y][x+1] = Ynut_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xnut_pause;
-      return;
-  }
+  Next[x][y] = Xacid_4;
 }
 
-static void Lpush_nut_w(int x, int y)
+static void Lacid_4(int x, int y)
 {
-  switch (Cave[y][x-1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xnut;
-      Next[y][x] = Xnut;
-      return;
-
-    default:
-      Cave[y][x] = Ynut_wB;
-      Cave[y][x-1] = Ynut_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xnut_pause;
-      return;
-  }
+  Next[x][y] = Xacid_5;
 }
 
-static void Lpush_spring_e(int x, int y)
+static void Lacid_5(int x, int y)
 {
-  switch (Cave[y][x+1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xspring;
-      Next[y][x] = Xspring;
-      return;
-
-    default:
-      Cave[y][x] = Yspring_eB;
-      Cave[y][x+1] = Yspring_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xspring_e;
-      return;
-  }
+  Next[x][y] = Xacid_6;
 }
 
-static void Lpush_spring_w(int x, int y)
+static void Lacid_6(int x, int y)
 {
-  switch (Cave[y][x-1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xspring;
-      Next[y][x] = Xspring;
-      return;
-
-    default:
-      Cave[y][x] = Yspring_wB;
-      Cave[y][x-1] = Yspring_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xspring_w;
-      return;
-  }
+  Next[x][y] = Xacid_7;
 }
 
-static void Lpush_emerald_e(int x, int y)
+static void Lacid_7(int x, int y)
 {
-  switch (Cave[y][x+1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xemerald;
-      Next[y][x] = Xemerald;
-      return;
-
-    default:
-      Cave[y][x] = Yemerald_eB;
-      Cave[y][x+1] = Yemerald_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xemerald_pause;
-      return;
-  }
+  Next[x][y] = Xacid_8;
 }
 
-static void Lpush_emerald_w(int x, int y)
+static void Lacid_8(int x, int y)
 {
-  switch (Cave[y][x-1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xemerald;
-      Next[y][x] = Xemerald;
-      return;
-
-    default:
-      Cave[y][x] = Yemerald_wB;
-      Cave[y][x-1] = Yemerald_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xemerald_pause;
-      return;
-  }
+  Next[x][y] = Xacid_1;
 }
 
-static void Lpush_diamond_e(int x, int y)
+#ifdef EM_ENGINE_USE_ADDITIONAL_ELEMENTS
+static void Lfake_acid_1(int x, int y)
 {
-  switch (Cave[y][x+1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xdiamond;
-      Next[y][x] = Xdiamond;
-      return;
+  Next[x][y] = Xfake_acid_2;
+}
 
-    default:
-      Cave[y][x] = Ydiamond_eB;
-      Cave[y][x+1] = Ydiamond_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xdiamond_pause;
-      return;
-  }
+static void Lfake_acid_2(int x, int y)
+{
+  Next[x][y] = Xfake_acid_3;
 }
 
-static void Lpush_diamond_w(int x, int y)
+static void Lfake_acid_3(int x, int y)
 {
-  switch (Cave[y][x-1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xdiamond;
-      Next[y][x] = Xdiamond;
-      return;
+  Next[x][y] = Xfake_acid_4;
+}
 
-    default:
-      Cave[y][x] = Ydiamond_wB;
-      Cave[y][x-1] = Ydiamond_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xdiamond_pause;
-      return;
-  }
+static void Lfake_acid_4(int x, int y)
+{
+  Next[x][y] = Xfake_acid_5;
 }
 
-static void Lpush_bomb_e(int x, int y)
+static void Lfake_acid_5(int x, int y)
 {
-  switch (Cave[y][x+1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xbomb;
-      Next[y][x] = Xbomb;
-      return;
+  Next[x][y] = Xfake_acid_6;
+}
 
-    default:
-      Cave[y][x] = Ybomb_eB;
-      Cave[y][x+1] = Ybomb_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xbomb_pause;
-      return;
-  }
+static void Lfake_acid_6(int x, int y)
+{
+  Next[x][y] = Xfake_acid_7;
 }
 
-static void Lpush_bomb_w(int x, int y)
+static void Lfake_acid_7(int x, int y)
 {
-  switch (Cave[y][x-1])
-  {
-    case Zborder:
-    case Znormal:
-    case Zdynamite:
-    case Xboom_bug:
-    case Xboom_bomb:
-    case Xboom_android:
-    case Xboom_1:
-    case Zplayer:
-      Cave[y][x] = Xbomb;
-      Next[y][x] = Xbomb;
-      return;
+  Next[x][y] = Xfake_acid_8;
+}
 
-    default:
-      Cave[y][x] = Ybomb_wB;
-      Cave[y][x-1] = Ybomb_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xbomb_pause;
-      return;
-  }
+static void Lfake_acid_8(int x, int y)
+{
+  Next[x][y] = Xfake_acid_1;
 }
+#endif
 
-static void Lstone(int x, int y)
+static void Landroid(int x, int y)
 {
-  switch (Cave[y+1][x])
+  int dx, dy, temp;
+
+  if (lev.android_clone_cnt == 0)
   {
-    case Xacid_1:
-    case Xacid_2:
-    case Xacid_3:
-    case Xacid_4:
-    case Xacid_5:
-    case Xacid_6:
-    case Xacid_7:
-    case Xacid_8:
-      Cave[y][x] = Ystone_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
-      play_element_sound(x, y, SOUND_acid, Xacid_1);
-      return;
+    if (Cave[x-1][y-1] != Xblank &&
+	Cave[x][y-1]   != Xblank &&
+	Cave[x+1][y-1] != Xblank &&
+	Cave[x-1][y]   != Xblank &&
+	Cave[x+1][y]   != Xblank &&
+	Cave[x-1][y+1] != Xblank &&
+	Cave[x][y+1]   != Xblank &&
+	Cave[x+1][y+1] != Xblank)
+      goto android_move;
 
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-#if 1
-    case Xfake_acid_1:
-    case Xfake_acid_2:
-    case Xfake_acid_3:
-    case Xfake_acid_4:
-    case Xfake_acid_5:
-    case Xfake_acid_6:
-    case Xfake_acid_7:
-    case Xfake_acid_8:
-#endif
-      Cave[y][x] = Ystone_sB;
-      Cave[y+1][x] = Ystone_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xstone_fall;
-      return;
+    switch (RANDOM(8))
+    {
+      /* randomly find an object to clone */
 
-    case Xsand:
-      Cave[y][x] = Xsand_stonein_1;
-      Cave[y+1][x] = Xsand_sandstone_1;
-      Next[y][x] = Xsand_stonein_2;
-      Next[y+1][x] = Xsand_sandstone_2;
-      return;
+      case 0: /* S,NE,W,NW,SE,E,SW,N */
+	temp = lev.android_array[Cave[x][y+1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y-1]];   if (temp != Xblank) break;
+	goto android_move;
 
-    case Xspring:
-    case Xspring_pause:
-    case Xspring_e:
-    case Xspring_w:
-    case Xandroid:
-    case Xandroid_1_n:
-    case Xandroid_2_n:
-    case Xandroid_1_e:
-    case Xandroid_2_e:
-    case Xandroid_1_s:
-    case Xandroid_2_s:
-    case Xandroid_1_w:
-    case Xandroid_2_w:
-    case Xstone:
-    case Xstone_pause:
-    case Xemerald:
-    case Xemerald_pause:
-    case Xdiamond:
-    case Xdiamond_pause:
-    case Xbomb:
-    case Xbomb_pause:
-    case Xballoon:
-    case Xacid_ne:
-    case Xacid_nw:
-    case Xball_1:
-    case Xball_2:
-    case Xnut:
-    case Xnut_pause:
-    case Xslidewall_ns:
-    case Xslidewall_ew:
-    case Xkey_1:
-    case Xkey_2:
-    case Xkey_3:
-    case Xkey_4:
-    case Xkey_5:
-    case Xkey_6:
-    case Xkey_7:
-    case Xkey_8:
-    case Xbumper:
-    case Xswitch:
-    case Xlenses:
-    case Xmagnify:
-    case Xroundwall_1:
-    case Xroundwall_2:
-    case Xroundwall_3:
-    case Xroundwall_4:
-      if (RANDOM & 1)
+      case 1: /* NW,SE,N,S,NE,SW,E,W */
+	temp = lev.android_array[Cave[x-1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y-1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y+1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y]];   if (temp != Xblank) break;
+	goto android_move;
+
+      case 2: /* SW,E,S,W,N,NW,SE,NE */
+	temp = lev.android_array[Cave[x-1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y+1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y-1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y-1]]; if (temp != Xblank) break;
+	goto android_move;
+
+      case 3: /* N,SE,NE,E,W,S,NW,SW */
+	temp = lev.android_array[Cave[x][y-1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y+1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y+1]]; if (temp != Xblank) break;
+	goto android_move;
+
+      case 4: /* SE,NW,E,NE,SW,W,N,S */
+	temp = lev.android_array[Cave[x+1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y-1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y+1]];   if (temp != Xblank) break;
+	goto android_move;
+
+      case 5: /* NE,W,SE,SW,S,N,E,NW */
+	temp = lev.android_array[Cave[x+1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y+1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y-1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y-1]]; if (temp != Xblank) break;
+	goto android_move;
+
+      case 6: /* E,N,SW,S,NW,NE,SE,W */
+	temp = lev.android_array[Cave[x+1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y-1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y+1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y]];   if (temp != Xblank) break;
+	goto android_move;
+
+      case 7: /* W,SW,NW,N,E,SE,NE,S */
+	temp = lev.android_array[Cave[x-1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x-1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y-1]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y]];   if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y+1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x+1][y-1]]; if (temp != Xblank) break;
+	temp = lev.android_array[Cave[x][y+1]];   if (temp != Xblank) break;
+	goto android_move;
+    }
+
+    Next[x][y] = temp;	/* the item we chose to clone */
+    play_element_sound(x, y, SOUND_android_clone, temp);
+
+    switch (RANDOM(8))
+    {
+      /* randomly find a direction to move */
+
+      case 0: /* S,NE,W,NW,SE,E,SW,N */
+	if (Cave[x][y+1] == Xblank)   goto android_s;
+	if (Cave[x+1][y-1] == Xblank) goto android_ne;
+	if (Cave[x-1][y] == Xblank)   goto android_w;
+	if (Cave[x-1][y-1] == Xblank) goto android_nw;
+	if (Cave[x+1][y+1] == Xblank) goto android_se;
+	if (Cave[x+1][y] == Xblank)   goto android_e;
+	if (Cave[x-1][y+1] == Xblank) goto android_sw;
+	if (Cave[x][y-1] == Xblank)   goto android_n;
+	goto android_move;
+
+      case 1: /* NW,SE,N,S,NE,SW,E,W */
+	if (Cave[x-1][y-1] == Xblank) goto android_nw;
+	if (Cave[x+1][y+1] == Xblank) goto android_se;
+	if (Cave[x][y-1] == Xblank)   goto android_n;
+	if (Cave[x][y+1] == Xblank)   goto android_s;
+	if (Cave[x+1][y-1] == Xblank) goto android_ne;
+	if (Cave[x-1][y+1] == Xblank) goto android_sw;
+	if (Cave[x+1][y] == Xblank)   goto android_e;
+	if (Cave[x-1][y] == Xblank)   goto android_w;
+	goto android_move;
+
+      case 2: /* SW,E,S,W,N,NW,SE,NE */
+	if (Cave[x-1][y+1] == Xblank) goto android_sw;
+	if (Cave[x+1][y] == Xblank)   goto android_e;
+	if (Cave[x][y+1] == Xblank)   goto android_s;
+	if (Cave[x-1][y] == Xblank)   goto android_w;
+	if (Cave[x][y-1] == Xblank)   goto android_n;
+	if (Cave[x-1][y-1] == Xblank) goto android_nw;
+	if (Cave[x+1][y+1] == Xblank) goto android_se;
+	if (Cave[x+1][y-1] == Xblank) goto android_ne;
+	goto android_move;
+
+      case 3: /* N,SE,NE,E,W,S,NW,SW */
+	if (Cave[x][y-1] == Xblank)   goto android_n;
+	if (Cave[x+1][y+1] == Xblank) goto android_se;
+	if (Cave[x+1][y-1] == Xblank) goto android_ne;
+	if (Cave[x+1][y] == Xblank)   goto android_e;
+	if (Cave[x-1][y] == Xblank)   goto android_w;
+	if (Cave[x][y+1] == Xblank)   goto android_s;
+	if (Cave[x-1][y-1] == Xblank) goto android_nw;
+	if (Cave[x-1][y+1] == Xblank) goto android_sw;
+	goto android_move;
+
+      case 4: /* SE,NW,E,NE,SW,W,N,S */
+	if (Cave[x+1][y+1] == Xblank) goto android_se;
+	if (Cave[x-1][y-1] == Xblank) goto android_nw;
+	if (Cave[x+1][y] == Xblank)   goto android_e;
+	if (Cave[x+1][y-1] == Xblank) goto android_ne;
+	if (Cave[x-1][y+1] == Xblank) goto android_sw;
+	if (Cave[x-1][y] == Xblank)   goto android_w;
+	if (Cave[x][y-1] == Xblank)   goto android_n;
+	if (Cave[x][y+1] == Xblank)   goto android_s;
+	goto android_move;
+
+      case 5: /* NE,W,SE,SW,S,N,E,NW */
+	if (Cave[x+1][y-1] == Xblank) goto android_ne;
+	if (Cave[x-1][y] == Xblank)   goto android_w;
+	if (Cave[x+1][y+1] == Xblank) goto android_se;
+	if (Cave[x-1][y+1] == Xblank) goto android_sw;
+	if (Cave[x][y+1] == Xblank)   goto android_s;
+	if (Cave[x][y-1] == Xblank)   goto android_n;
+	if (Cave[x+1][y] == Xblank)   goto android_e;
+	if (Cave[x-1][y-1] == Xblank) goto android_nw;
+	goto android_move;
+
+      case 6: /* E,N,SW,S,NW,NE,SE,W */
+	if (Cave[x+1][y] == Xblank)   goto android_e;
+	if (Cave[x][y-1] == Xblank)   goto android_n;
+	if (Cave[x-1][y+1] == Xblank) goto android_sw;
+	if (Cave[x][y+1] == Xblank)   goto android_s;
+	if (Cave[x-1][y-1] == Xblank) goto android_nw;
+	if (Cave[x+1][y-1] == Xblank) goto android_ne;
+	if (Cave[x+1][y+1] == Xblank) goto android_se;
+	if (Cave[x-1][y] == Xblank)   goto android_w;
+	goto android_move;
+
+      case 7: /* W,SW,NW,N,E,SE,NE,S */
+	if (Cave[x-1][y] == Xblank)   goto android_w;
+	if (Cave[x-1][y+1] == Xblank) goto android_sw;
+	if (Cave[x-1][y-1] == Xblank) goto android_nw;
+	if (Cave[x][y-1] == Xblank)   goto android_n;
+	if (Cave[x+1][y] == Xblank)   goto android_e;
+	if (Cave[x+1][y+1] == Xblank) goto android_se;
+	if (Cave[x+1][y-1] == Xblank) goto android_ne;
+	if (Cave[x][y+1] == Xblank)   goto android_s;
+	goto android_move;
+    }
+  }
+
+ android_move:
+  if (lev.android_move_cnt == 0)
+  {
+    if (Cave[x-1][y-1] == Zplayer ||
+	Cave[x][y-1]   == Zplayer ||
+	Cave[x+1][y-1] == Zplayer ||
+	Cave[x-1][y]   == Zplayer ||
+	Cave[x+1][y]   == Zplayer ||
+	Cave[x-1][y+1] == Zplayer ||
+	Cave[x][y+1]   == Zplayer ||
+	Cave[x+1][y+1] == Zplayer)
+      goto android_still;
+
+    set_nearest_player_xy(x, y, &dx, &dy);
+
+    Next[x][y] = Xblank;	/* assume we will move */
+    temp = ((x < dx) + 1 - (x > dx)) + ((y < dy) + 1 - (y > dy)) * 3;
+
+    if (RANDOM(2))
+    {
+      switch (temp)
       {
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
-	{
-	  Cave[y][x] = Ystone_eB;
-	  Cave[y][x+1] = Ystone_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xstone_pause;
-	  return;
-	}
+	/* attempt clockwise move first if direct path is blocked */
 
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
-	{
-	  Cave[y][x] = Ystone_wB;
-	  Cave[y][x-1] = Ystone_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xstone_pause;
-	  return;
-	}
+	case 0: /* north west */
+	  if (tab_android_move[Cave[x-1][y-1]]) goto android_nw;
+	  if (tab_android_move[Cave[x][y-1]])   goto android_n;
+	  if (tab_android_move[Cave[x-1][y]])   goto android_w;
+	  break;
+
+	case 1: /* north */
+	  if (tab_android_move[Cave[x][y-1]])   goto android_n;
+	  if (tab_android_move[Cave[x+1][y-1]]) goto android_ne;
+	  if (tab_android_move[Cave[x-1][y-1]]) goto android_nw;
+	  break;
+
+	case 2: /* north east */
+	  if (tab_android_move[Cave[x+1][y-1]]) goto android_ne;
+	  if (tab_android_move[Cave[x+1][y]])   goto android_e;
+	  if (tab_android_move[Cave[x][y-1]])   goto android_n;
+	  break;
+
+	case 3: /* west */
+	  if (tab_android_move[Cave[x-1][y]])   goto android_w;
+	  if (tab_android_move[Cave[x-1][y-1]]) goto android_nw;
+	  if (tab_android_move[Cave[x-1][y+1]]) goto android_sw;
+	  break;
+
+	case 4: /* nowhere */
+	  break;
+
+	case 5: /* east */
+	  if (tab_android_move[Cave[x+1][y]])   goto android_e;
+	  if (tab_android_move[Cave[x+1][y+1]]) goto android_se;
+	  if (tab_android_move[Cave[x+1][y-1]]) goto android_ne;
+	  break;
+
+	case 6: /* south west */
+	  if (tab_android_move[Cave[x-1][y+1]]) goto android_sw;
+	  if (tab_android_move[Cave[x-1][y]])   goto android_w;
+	  if (tab_android_move[Cave[x][y+1]])   goto android_s;
+	  break;
+
+	case 7: /* south */
+	  if (tab_android_move[Cave[x][y+1]])   goto android_s;
+	  if (tab_android_move[Cave[x-1][y+1]]) goto android_sw;
+	  if (tab_android_move[Cave[x+1][y+1]]) goto android_se;
+	  break;
+
+	case 8: /* south east */
+	  if (tab_android_move[Cave[x+1][y+1]]) goto android_se;
+	  if (tab_android_move[Cave[x][y+1]])   goto android_s;
+	  if (tab_android_move[Cave[x+1][y]])   goto android_e;
+	  break;
       }
-      else
+    }
+    else
+    {
+      switch (temp)
       {
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
-	{
-	  Cave[y][x] = Ystone_wB;
-	  Cave[y][x-1] = Ystone_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xstone_pause;
-	  return;
-	}
+	/* attempt counterclockwise move first if direct path is blocked */
 
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
-	{
-	  Cave[y][x] = Ystone_eB;
-	  Cave[y][x+1] = Ystone_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xstone_pause;
-	  return;
-	}
+	case 0: /* north west */
+	  if (tab_android_move[Cave[x-1][y-1]]) goto android_nw;
+	  if (tab_android_move[Cave[x-1][y]])   goto android_w;
+	  if (tab_android_move[Cave[x][y-1]])   goto android_n;
+	  break;
+
+	case 1: /* north */
+	  if (tab_android_move[Cave[x][y-1]])   goto android_n;
+	  if (tab_android_move[Cave[x-1][y-1]]) goto android_nw;
+	  if (tab_android_move[Cave[x+1][y-1]]) goto android_ne;
+	  break;
+
+	case 2: /* north east */
+	  if (tab_android_move[Cave[x+1][y-1]]) goto android_ne;
+	  if (tab_android_move[Cave[x][y-1]])   goto android_n;
+	  if (tab_android_move[Cave[x+1][y]])   goto android_e;
+	  break;
+
+	case 3: /* west */
+	  if (tab_android_move[Cave[x-1][y]])   goto android_w;
+	  if (tab_android_move[Cave[x-1][y+1]]) goto android_sw;
+	  if (tab_android_move[Cave[x-1][y-1]]) goto android_nw;
+	  break;
+
+	case 4: /* nowhere */
+	  break;
+
+	case 5: /* east */
+	  if (tab_android_move[Cave[x+1][y]])   goto android_e;
+	  if (tab_android_move[Cave[x+1][y-1]]) goto android_ne;
+	  if (tab_android_move[Cave[x+1][y+1]]) goto android_se;
+	  break;
+
+	case 6: /* south west */
+	  if (tab_android_move[Cave[x-1][y+1]]) goto android_sw;
+	  if (tab_android_move[Cave[x][y+1]])   goto android_s;
+	  if (tab_android_move[Cave[x-1][y]])   goto android_w;
+	  break;
+
+	case 7: /* south */
+	  if (tab_android_move[Cave[x][y+1]])   goto android_s;
+	  if (tab_android_move[Cave[x+1][y+1]]) goto android_se;
+	  if (tab_android_move[Cave[x-1][y+1]]) goto android_sw;
+	  break;
+
+	case 8: /* south east */
+	  if (tab_android_move[Cave[x+1][y+1]]) goto android_se;
+	  if (tab_android_move[Cave[x+1][y]])   goto android_e;
+	  if (tab_android_move[Cave[x][y+1]])   goto android_s;
+	  break;
       }
+    }
   }
+
+ android_still:
+  Next[x][y] = Xandroid;
+  return;
+
+ android_n:
+  Cave[x][y] = Yandroid_nB;
+  Cave[x][y-1] = Yandroid_n;
+  Next[x][y-1] = Xandroid;
+  play_element_sound(x, y, SOUND_android_move, Xandroid);
+  return;
+
+ android_ne:
+  Cave[x][y] = Yandroid_neB;
+  Cave[x+1][y-1] = Yandroid_ne;
+  Next[x+1][y-1] = Xandroid;
+  play_element_sound(x, y, SOUND_android_move, Xandroid);
+  return;
+
+ android_e:
+  Cave[x][y] = Yandroid_eB;
+  Cave[x+1][y] = Yandroid_e;
+  Next[x+1][y] = Xandroid;
+  play_element_sound(x, y, SOUND_android_move, Xandroid);
+  return;
+
+ android_se:
+  Cave[x][y] = Yandroid_seB;
+  Cave[x+1][y+1] = Yandroid_se;
+  Next[x+1][y+1] = Xandroid;
+  play_element_sound(x, y, SOUND_android_move, Xandroid);
+  return;
+
+ android_s:
+  Cave[x][y] = Yandroid_sB;
+  Cave[x][y+1] = Yandroid_s;
+  Next[x][y+1] = Xandroid;
+  play_element_sound(x, y, SOUND_android_move, Xandroid);
+  return;
+
+ android_sw:
+  Cave[x][y] = Yandroid_swB;
+  Cave[x-1][y+1] = Yandroid_sw;
+  Next[x-1][y+1] = Xandroid;
+  play_element_sound(x, y, SOUND_android_move, Xandroid);
+  return;
+
+ android_w:
+  Cave[x][y] = Yandroid_wB;
+  Cave[x-1][y] = Yandroid_w;
+  Next[x-1][y] = Xandroid;
+  play_element_sound(x, y, SOUND_android_move, Xandroid);
+  return;
+
+ android_nw:
+  Cave[x][y] = Yandroid_nwB;
+  Cave[x-1][y-1] = Yandroid_nw;
+  Next[x-1][y-1] = Xandroid;
+  play_element_sound(x, y, SOUND_android_move, Xandroid);
+  return;
 }
 
-static void Lstone_pause(int x, int y)
+static void Landroid_1_n(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y-1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -494,44 +577,34 @@ static void Lstone_pause(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ystone_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yandroid_nB;
+      if (Cave[x+1][y-2] == Xblank)
+	Cave[x+1][y-2] = Xacid_splash_e;
+      if (Cave[x-1][y-2] == Xblank)
+	Cave[x-1][y-2] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-#if 1
-    case Xfake_acid_1:
-    case Xfake_acid_2:
-    case Xfake_acid_3:
-    case Xfake_acid_4:
-    case Xfake_acid_5:
-    case Xfake_acid_6:
-    case Xfake_acid_7:
-    case Xfake_acid_8:
-#endif
-      Cave[y][x] = Ystone_sB;
-      Cave[y+1][x] = Ystone_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xstone_fall;
+      Cave[x][y] = Yandroid_nB;
+      Cave[x][y-1] = Yandroid_n;
+      Next[x][y] = Xblank;
+      Next[x][y-1] = Xandroid;
+      play_element_sound(x, y, SOUND_android_move, Xandroid_1_n);
       return;
 
     default:
-      Cave[y][x] = Xstone;
-      Next[y][x] = Xstone;
+      Landroid(x, y);
       return;
   }
 }
 
-static void Lstone_fall(int x, int y)
+static void Landroid_2_n(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y-1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -541,285 +614,34 @@ static void Lstone_fall(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ystone_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yandroid_nB;
+      if (Cave[x+1][y-2] == Xblank)
+	Cave[x+1][y-2] = Xacid_splash_e;
+      if (Cave[x-1][y-2] == Xblank)
+	Cave[x-1][y-2] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Zplayer:
-#if 1
-    case Xfake_acid_1:
-    case Xfake_acid_2:
-    case Xfake_acid_3:
-    case Xfake_acid_4:
-    case Xfake_acid_5:
-    case Xfake_acid_6:
-    case Xfake_acid_7:
-    case Xfake_acid_8:
-#endif
-      Cave[y][x] = Ystone_sB;
-      Cave[y+1][x] = Ystone_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xstone_fall;
+      Cave[x][y] = Yandroid_nB;
+      Cave[x][y-1] = Yandroid_n;
+      Next[x][y] = Xblank;
+      Next[x][y-1] = Xandroid_1_n;
+      play_element_sound(x, y, SOUND_android_move, Xandroid_2_n);
       return;
 
-    case Xnut:
-    case Xnut_pause:
-      Cave[y+1][x] = Ynut_stone;
-      Next[y][x] = Xstone;
-      Next[y+1][x] = Xemerald;
-      play_element_sound(x, y, SOUND_crack, Xnut);
-      score += lev.nut_score;
+    default:
+      Landroid(x, y);
       return;
+  }
+}
 
-    case Xbug_1_n:
-    case Xbug_1_e:
-    case Xbug_1_s:
-    case Xbug_1_w:
-    case Xbug_2_n:
-    case Xbug_2_e:
-    case Xbug_2_s:
-    case Xbug_2_w:
-      Cave[y][x] = Ystone_sB;
-      Cave[y+1][x] = Ybug_stone;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = Xemerald;
-      Boom[y][x] = Xemerald;
-      Boom[y][x+1] = Xemerald;
-      Boom[y+1][x-1] = Xemerald;
-      Boom[y+1][x] = Xdiamond;
-      Boom[y+1][x+1] = Xemerald;
-      Boom[y+2][x-1] = Xemerald;
-      Boom[y+2][x] = Xemerald;
-      Boom[y+2][x+1] = Xemerald;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xstone_fall);
-#endif
-      score += lev.bug_score;
-      return;
-
-    case Xtank_1_n:
-    case Xtank_1_e:
-    case Xtank_1_s:
-    case Xtank_1_w:
-    case Xtank_2_n:
-    case Xtank_2_e:
-    case Xtank_2_s:
-    case Xtank_2_w:
-      Cave[y][x] = Ystone_sB;
-      Cave[y+1][x] = Ytank_stone;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = Xblank;
-      Boom[y][x] = Xblank;
-      Boom[y][x+1] = Xblank;
-      Boom[y+1][x-1] = Xblank;
-      Boom[y+1][x] = Xblank;
-      Boom[y+1][x+1] = Xblank;
-      Boom[y+2][x-1] = Xblank;
-      Boom[y+2][x] = Xblank;
-      Boom[y+2][x+1] = Xblank;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xstone_fall);
-#endif
-      score += lev.tank_score;
-      return;
-
-    case Xspring:
-      if (RANDOM & 1)
-      {
-	switch (Cave[y+1][x+1])
-	{
-	  case Xblank:
-	  case Xacid_splash_e:
-	  case Xacid_splash_w:
-	  case Xalien:
-	  case Xalien_pause:
-	    Cave[y+1][x] = Xspring_e;
-	    break;
-
-	  default:
-	    Cave[y+1][x] = Xspring_w;
-	    break;
-	}
-      }
-      else
-      {
-	switch (Cave[y+1][x-1])
-	{
-	  case Xblank:
-	  case Xacid_splash_e:
-	  case Xacid_splash_w:
-	  case Xalien:
-	  case Xalien_pause:
-	    Cave[y+1][x] = Xspring_w;
-	    break;
-	  default:
-	    Cave[y+1][x] = Xspring_e;
-	    break;
-	}
-      }
-
-      Next[y][x] = Xstone;
-      return;
-
-    case Xeater_n:
-    case Xeater_e:
-    case Xeater_s:
-    case Xeater_w:
-      Cave[y][x] = Ystone_sB;
-      Cave[y+1][x] = Yeater_stone;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = lev.eater_array[lev.eater_pos][0];
-      Boom[y][x] = lev.eater_array[lev.eater_pos][1];
-      Boom[y][x+1] = lev.eater_array[lev.eater_pos][2];
-      Boom[y+1][x-1] = lev.eater_array[lev.eater_pos][3];
-      Boom[y+1][x] = lev.eater_array[lev.eater_pos][4];
-      Boom[y+1][x+1] = lev.eater_array[lev.eater_pos][5];
-      Boom[y+2][x-1] = lev.eater_array[lev.eater_pos][6];
-      Boom[y+2][x] = lev.eater_array[lev.eater_pos][7];
-      Boom[y+2][x+1] = lev.eater_array[lev.eater_pos][8];
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xstone_fall);
-#endif
-      lev.eater_pos = (lev.eater_pos + 1) & 7;
-      score += lev.eater_score;
-      return;
-
-    case Xalien:
-    case Xalien_pause:
-      Cave[y][x] = Ystone_sB;
-      Cave[y+1][x] = Yalien_stone;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = Xblank;
-      Boom[y][x] = Xblank;
-      Boom[y][x+1] = Xblank;
-      Boom[y+1][x-1] = Xblank;
-      Boom[y+1][x] = Xblank;
-      Boom[y+1][x+1] = Xblank;
-      Boom[y+2][x-1] = Xblank;
-      Boom[y+2][x] = Xblank;
-      Boom[y+2][x+1] = Xblank;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xstone_fall);
-#endif
-      score += lev.alien_score;
-      return;
-
-    case Xdiamond:
-    case Xdiamond_pause:
-      switch (Cave[y+2][x])
-      {
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	case Zplayer:
-	case Xbug_1_n:
-	case Xbug_1_e:
-	case Xbug_1_s:
-	case Xbug_1_w:
-	case Xbug_2_n:
-	case Xbug_2_e:
-	case Xbug_2_s:
-	case Xbug_2_w:
-	case Xtank_1_n:
-	case Xtank_1_e:
-	case Xtank_1_s:
-	case Xtank_1_w:
-	case Xtank_2_n:
-	case Xtank_2_e:
-	case Xtank_2_s:
-	case Xtank_2_w:
-	case Xspring_fall:
-	case Xandroid:
-	case Xandroid_1_n:
-	case Xandroid_2_n:
-	case Xandroid_1_e:
-	case Xandroid_2_e:
-	case Xandroid_1_s:
-	case Xandroid_2_s:
-	case Xandroid_1_w:
-	case Xandroid_2_w:
-	case Xstone_fall:
-	case Xemerald_fall:
-	case Xdiamond_fall:
-	case Xbomb_fall:
-	case Xacid_s:
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	case Xnut_fall:
-	case Xplant:
-	case Yplant:
-	  Next[y][x] = Xstone;
-	  play_element_sound(x, y, SOUND_stone, Xstone);
-	  return;
-      }
-
-      Cave[y][x] = Ystone_sB;
-      Cave[y+1][x] = Ydiamond_stone;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xstone_pause;
-      play_element_sound(x, y, SOUND_squash, Xdiamond);
-      return;
-
-    case Xbomb:
-    case Xbomb_pause:
-      Cave[y+1][x] = Ybomb_blank;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = Xblank;
-      Boom[y][x] = Xblank;
-      Boom[y][x+1] = Xblank;
-      Boom[y+1][x-1] = Xblank;
-      Boom[y+1][x] = Xblank;
-      Boom[y+1][x+1] = Xblank;
-      Boom[y+2][x-1] = Xblank;
-      Boom[y+2][x] = Xblank;
-      Boom[y+2][x+1] = Xblank;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xstone_fall);
-#endif
-      return;
-
-    case Xwonderwall:
-      if (lev.wonderwall_time)
-      {
-	lev.wonderwall_state = 1;
-	Cave[y][x] = Ystone_sB;
-
-	if (tab_blank[Cave[y+2][x]])
-	{
-	  Cave[y+2][x] = Yemerald_s;
-	  Next[y+2][x] = Xemerald_fall;
-	}
-
-	Next[y][x] = Xblank;
-	play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
-	return;
-      }
-
-    default:
-      Cave[y][x] = Xstone;
-      Next[y][x] = Xstone;
-      play_element_sound(x, y, SOUND_stone, Xstone);
-      return;
-  }
-}
-
-static void Lnut(int x, int y)
+static void Landroid_1_e(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x+1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -829,114 +651,34 @@ static void Lnut(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ynut_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yandroid_eB;
+      if (Cave[x+2][y-1] == Xblank)
+	Cave[x+2][y-1] = Xacid_splash_e;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Ynut_sB;
-      Cave[y+1][x] = Ynut_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xnut_fall;
+      Cave[x][y] = Yandroid_eB;
+      Cave[x+1][y] = Yandroid_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xandroid;
+      play_element_sound(x, y, SOUND_android_move, Xandroid_1_e);
       return;
 
-    case Xspring:
-    case Xspring_pause:
-    case Xspring_e:
-    case Xspring_w:
-    case Xandroid:
-    case Xandroid_1_n:
-    case Xandroid_2_n:
-    case Xandroid_1_e:
-    case Xandroid_2_e:
-    case Xandroid_1_s:
-    case Xandroid_2_s:
-    case Xandroid_1_w:
-    case Xandroid_2_w:
-    case Xstone:
-    case Xstone_pause:
-    case Xemerald:
-    case Xemerald_pause:
-    case Xdiamond:
-    case Xdiamond_pause:
-    case Xbomb:
-    case Xbomb_pause:
-    case Xballoon:
-    case Xacid_ne:
-    case Xacid_nw:
-    case Xball_1:
-    case Xball_2:
-    case Xnut:
-    case Xnut_pause:
-    case Xslidewall_ns:
-    case Xslidewall_ew:
-    case Xkey_1:
-    case Xkey_2:
-    case Xkey_3:
-    case Xkey_4:
-    case Xkey_5:
-    case Xkey_6:
-    case Xkey_7:
-    case Xkey_8:
-    case Xbumper:
-    case Xswitch:
-    case Xroundwall_1:
-    case Xroundwall_2:
-    case Xroundwall_3:
-    case Xroundwall_4:
-      if (RANDOM & 1)
-      {
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
-	{
-	  Cave[y][x] = Ynut_eB;
-	  Cave[y][x+1] = Ynut_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xnut_pause;
-	  return;
-	}
-
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
-	{
-	  Cave[y][x] = Ynut_wB;
-	  Cave[y][x-1] = Ynut_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xnut_pause;
-	  return;
-	}
-      }
-      else
-      {
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
-	{
-	  Cave[y][x] = Ynut_wB;
-	  Cave[y][x-1] = Ynut_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xnut_pause;
-	  return;
-	}
-
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
-	{
-	  Cave[y][x] = Ynut_eB;
-	  Cave[y][x+1] = Ynut_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xnut_pause;
-	  return;
-	}
-      }
+    default:
+      Landroid(x, y);
+      return;
   }
 }
 
-static void Lnut_pause(int x, int y)
+static void Landroid_2_e(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x+1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -946,34 +688,34 @@ static void Lnut_pause(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ynut_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yandroid_eB;
+      if (Cave[x+2][y-1] == Xblank)
+	Cave[x+2][y-1] = Xacid_splash_e;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Ynut_sB;
-      Cave[y+1][x] = Ynut_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xnut_fall;
+      Cave[x][y] = Yandroid_eB;
+      Cave[x+1][y] = Yandroid_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xandroid_1_e;
+      play_element_sound(x, y, SOUND_android_move, Xandroid_2_e);
       return;
 
     default:
-      Cave[y][x] = Xnut;
-      Next[y][x] = Xnut;
+      Landroid(x, y);
       return;
   }
 }
 
-static void Lnut_fall(int x, int y)
+static void Landroid_1_s(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -983,71 +725,34 @@ static void Lnut_fall(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ynut_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yandroid_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Zplayer:
-      Cave[y][x] = Ynut_sB;
-      Cave[y+1][x] = Ynut_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xnut_fall;
+      Cave[x][y] = Yandroid_sB;
+      Cave[x][y+1] = Yandroid_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xandroid;
+      play_element_sound(x, y, SOUND_android_move, Xandroid_1_s);
       return;
 
     default:
-      Cave[y][x] = Xnut;
-      Next[y][x] = Xnut;
-      play_element_sound(x, y, SOUND_nut, Xnut);
+      Landroid(x, y);
       return;
   }
 }
 
-static void Lboom_bug(int x, int y)
-{
-  Next[y][x] = Znormal;
-  Boom[y-1][x-1] = Xemerald;
-  Boom[y-1][x] = Xemerald;
-  Boom[y-1][x+1] = Xemerald;
-  Boom[y][x-1] = Xemerald;
-  Boom[y][x] = Xdiamond;
-  Boom[y][x+1] = Xemerald;
-  Boom[y+1][x-1] = Xemerald;
-  Boom[y+1][x] = Xemerald;
-  Boom[y+1][x+1] = Xemerald;
-
-#if PLAY_ELEMENT_SOUND
-  play_element_sound(x, y, SOUND_boom, element);
-#endif
-}
-
-static void Lboom_tank(int x, int y)
-{
-  Next[y][x] = Znormal;
-  Boom[y-1][x-1] = Xblank;
-  Boom[y-1][x] = Xblank;
-  Boom[y-1][x+1] = Xblank;
-  Boom[y][x-1] = Xblank;
-  Boom[y][x] = Xblank;
-  Boom[y][x+1] = Xblank;
-  Boom[y+1][x-1] = Xblank;
-  Boom[y+1][x] = Xblank;
-  Boom[y+1][x+1] = Xblank;
-#if PLAY_ELEMENT_SOUND
-  play_element_sound(x, y, SOUND_boom, element);
-#endif
-}
-
-static void Lbug_n(int x, int y)
+static void Landroid_2_s(int x, int y)
 {
-  switch (Cave[y-1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -1057,55 +762,35 @@ static void Lbug_n(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ybug_nB;
-      if (Cave[y-2][x+1] == Xblank)
-	Cave[y-2][x+1] = Xacid_splash_e;
-      if (Cave[y-2][x-1] == Xblank)
-	Cave[y-2][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yandroid_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Zplayer:
-      Cave[y][x] = Ybug_nB;
-      Cave[y-1][x] = Ybug_n;
-      Next[y][x] = Xblank;
-      Next[y-1][x] = Xbug_1_n;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_n);
+      Cave[x][y] = Yandroid_sB;
+      Cave[x][y+1] = Yandroid_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xandroid_1_s;
+      play_element_sound(x, y, SOUND_android_move, Xandroid_2_s);
       return;
 
     default:
-      Cave[y][x] = Ybug_n_w;
-      Next[y][x] = Xbug_2_w;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_n);
+      Landroid(x, y);
       return;
   }
 }
 
-static void Lbug_1_n(int x, int y)
+static void Landroid_1_w(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  switch (Cave[x-1][y])
   {
-    Lboom_bug(x, y);
-
-    return;
-  }
-
-  switch (Cave[y][x+1])
-  {
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
     case Xacid_1:
     case Xacid_2:
     case Xacid_3:
@@ -1114,36 +799,34 @@ static void Lbug_1_n(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-    case Zplayer:
-      Cave[y][x] = Ybug_n_e;
-      Next[y][x] = Xbug_2_e;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_n);
+      Cave[x][y] = Yandroid_wB;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_e;
+      if (Cave[x-2][y-1] == Xblank)
+	Cave[x-2][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
+      play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
-    default:
-      Lbug_n(x, y);
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+      Cave[x][y] = Yandroid_wB;
+      Cave[x-1][y] = Yandroid_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xandroid;
+      play_element_sound(x, y, SOUND_android_move, Xandroid_1_w);
       return;
-  }
-}
-
-static void Lbug_2_n(int x, int y)
-{
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
-  {
-    Lboom_bug(x, y);
 
-    return;
+    default:
+      Landroid(x, y);
+      return;
   }
-
-  Lbug_n(x, y);
 }
 
-static void Lbug_e(int x, int y)
+static void Landroid_2_w(int x, int y)
 {
-  switch (Cave[y][x+1])
+  switch (Cave[x-1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -1153,93 +836,66 @@ static void Lbug_e(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ybug_eB;
-      if (Cave[y-1][x+2] == Xblank)
-	Cave[y-1][x+2] = Xacid_splash_e;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yandroid_wB;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_e;
+      if (Cave[x-2][y-1] == Xblank)
+	Cave[x-2][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Zplayer:
-      Cave[y][x] = Ybug_eB;
-      Cave[y][x+1] = Ybug_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xbug_1_e;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_e);
+      Cave[x][y] = Yandroid_wB;
+      Cave[x-1][y] = Yandroid_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xandroid_1_w;
+      play_element_sound(x, y, SOUND_android_move, Xandroid_1_w);
       return;
 
     default:
-      Cave[y][x] = Ybug_e_n;
-      Next[y][x] = Xbug_2_n;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_e);
+      Landroid(x, y);
       return;
   }
 }
 
-static void Lbug_1_e(int x, int y)
+static void Leater_n(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (Cave[x+1][y] == Xdiamond)
   {
-    Lboom_bug(x, y);
-
+    Cave[x+1][y] = Ydiamond_blank;
+    Next[x+1][y] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
     return;
   }
 
-  switch (Cave[y+1][x])
+  if (Cave[x][y+1] == Xdiamond)
   {
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Xacid_1:
-    case Xacid_2:
-    case Xacid_3:
-    case Xacid_4:
-    case Xacid_5:
-    case Xacid_6:
-    case Xacid_7:
-    case Xacid_8:
-    case Zplayer:
-      Cave[y][x] = Ybug_e_s;
-      Next[y][x] = Xbug_2_s;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_e);
-      return;
-
-    default:
-      Lbug_e(x, y);
-      return;
+    Cave[x][y+1] = Ydiamond_blank;
+    Next[x][y+1] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
+    return;
   }
-}
 
-static void Lbug_2_e(int x, int y)
-{
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (Cave[x-1][y] == Xdiamond)
   {
-    Lboom_bug(x, y);
-
+    Cave[x-1][y] = Ydiamond_blank;
+    Next[x-1][y] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
     return;
   }
 
-  Lbug_e(x, y);
-}
+  if (Cave[x][y-1] == Xdiamond)
+  {
+    Cave[x][y-1] = Ydiamond_blank;
+    Next[x][y-1] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
+    return;
+  }
 
-static void Lbug_s(int x, int y)
-{
-  switch (Cave[y+1][x])
+  switch (Cave[x][y-1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -1249,12 +905,12 @@ static void Lbug_s(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ybug_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yeater_nB;
+      if (Cave[x+1][y-2] == Xblank)
+	Cave[x+1][y-2] = Xacid_splash_e;
+      if (Cave[x-1][y-2] == Xblank)
+	Cave[x-1][y-2] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
@@ -1264,78 +920,54 @@ static void Lbug_s(int x, int y)
     case Xplant:
     case Yplant:
     case Zplayer:
-      Cave[y][x] = Ybug_sB;
-      Cave[y+1][x] = Ybug_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xbug_1_s;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_s);
+      Cave[x][y] = Yeater_nB;
+      Cave[x][y-1] = Yeater_n;
+      Next[x][y] = Xblank;
+      Next[x][y-1] = Xeater_n;
       return;
 
     default:
-      Cave[y][x] = Ybug_s_e;
-      Next[y][x] = Xbug_2_e;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_s);
+      Next[x][y] = RANDOM(2) ? Xeater_e : Xeater_w;
+      play_element_sound(x, y, SOUND_eater, Xeater_n);
       return;
   }
 }
 
-static void Lbug_1_s(int x, int y)
+static void Leater_e(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (Cave[x][y+1] == Xdiamond)
   {
-    Lboom_bug(x, y);
-
+    Cave[x][y+1] = Ydiamond_blank;
+    Next[x][y+1] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
     return;
   }
 
-  switch (Cave[y][x-1])
+  if (Cave[x-1][y] == Xdiamond)
   {
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Xacid_1:
-    case Xacid_2:
-    case Xacid_3:
-    case Xacid_4:
-    case Xacid_5:
-    case Xacid_6:
-    case Xacid_7:
-    case Xacid_8:
-    case Zplayer:
-      Cave[y][x] = Ybug_s_w;
-      Next[y][x] = Xbug_2_w;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_s);
-      return;
-
-    default:
-      Lbug_s(x, y);
-      return;
+    Cave[x-1][y] = Ydiamond_blank;
+    Next[x-1][y] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
+    return;
   }
-}
 
-static void Lbug_2_s(int x, int y)
-{
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (Cave[x][y-1] == Xdiamond)
   {
-    Lboom_bug(x, y);
-
+    Cave[x][y-1] = Ydiamond_blank;
+    Next[x][y-1] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
     return;
   }
 
-  Lbug_s(x, y);
-}
+  if (Cave[x+1][y] == Xdiamond)
+  {
+    Cave[x+1][y] = Ydiamond_blank;
+    Next[x+1][y] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
+    return;
+  }
 
-static void Lbug_w(int x, int y)
-{
-  switch (Cave[y][x-1])
+  switch (Cave[x+1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -1345,12 +977,12 @@ static void Lbug_w(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ybug_wB;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_e;
-      if (Cave[y-1][x-2] == Xblank)
-	Cave[y-1][x-2] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yeater_eB;
+      if (Cave[x+2][y-1] == Xblank)
+	Cave[x+2][y-1] = Xacid_splash_e;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
@@ -1360,78 +992,54 @@ static void Lbug_w(int x, int y)
     case Xplant:
     case Yplant:
     case Zplayer:
-      Cave[y][x] = Ybug_wB;
-      Cave[y][x-1] = Ybug_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xbug_1_w;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_w);
+      Cave[x][y] = Yeater_eB;
+      Cave[x+1][y] = Yeater_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xeater_e;
       return;
 
     default:
-      Cave[y][x] = Ybug_w_s;
-      Next[y][x] = Xbug_2_s;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_w);
+      Next[x][y] = RANDOM(2) ? Xeater_n : Xeater_s;
+      play_element_sound(x, y, SOUND_eater, Xeater_e);
       return;
   }
 }
 
-static void Lbug_1_w(int x, int y)
+static void Leater_s(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (Cave[x-1][y] == Xdiamond)
   {
-    Lboom_bug(x, y);
-
+    Cave[x-1][y] = Ydiamond_blank;
+    Next[x-1][y] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
     return;
   }
 
-  switch (Cave[y-1][x])
+  if (Cave[x][y-1] == Xdiamond)
   {
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Xacid_1:
-    case Xacid_2:
-    case Xacid_3:
-    case Xacid_4:
-    case Xacid_5:
-    case Xacid_6:
-    case Xacid_7:
-    case Xacid_8:
-    case Zplayer:
-      Cave[y][x] = Ybug_w_n;
-      Next[y][x] = Xbug_2_n;
-      play_element_sound(x, y, SOUND_bug, Xbug_1_w);
-      return;
-
-    default:
-      Lbug_w(x, y);
-      return;
+    Cave[x][y-1] = Ydiamond_blank;
+    Next[x][y-1] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
+    return;
   }
-}
 
-static void Lbug_2_w(int x, int y)
-{
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (Cave[x+1][y] == Xdiamond)
   {
-    Lboom_bug(x, y);
-
+    Cave[x+1][y] = Ydiamond_blank;
+    Next[x+1][y] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
     return;
   }
 
-  Lbug_w(x, y);
-}
+  if (Cave[x][y+1] == Xdiamond)
+  {
+    Cave[x][y+1] = Ydiamond_blank;
+    Next[x][y+1] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
+    return;
+  }
 
-static void Ltank_n(int x, int y)
-{
-  switch (Cave[y-1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -1441,12 +1049,12 @@ static void Ltank_n(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ytank_nB;
-      if (Cave[y-2][x+1] == Xblank)
-	Cave[y-2][x+1] = Xacid_splash_e;
-      if (Cave[y-2][x-1] == Xblank)
-	Cave[y-2][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yeater_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
@@ -1456,78 +1064,54 @@ static void Ltank_n(int x, int y)
     case Xplant:
     case Yplant:
     case Zplayer:
-      Cave[y][x] = Ytank_nB;
-      Cave[y-1][x] = Ytank_n;
-      Next[y][x] = Xblank;
-      Next[y-1][x] = Xtank_1_n;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_n);
+      Cave[x][y] = Yeater_sB;
+      Cave[x][y+1] = Yeater_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xeater_s;
       return;
 
     default:
-      Cave[y][x] = Ytank_n_e;
-      Next[y][x] = Xtank_2_e;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_n);
+      Next[x][y] = RANDOM(2) ? Xeater_e : Xeater_w;
+      play_element_sound(x, y, SOUND_eater, Xeater_s);
       return;
   }
 }
 
-static void Ltank_1_n(int x, int y)
+static void Leater_w(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (Cave[x][y-1] == Xdiamond)
   {
-    Lboom_tank(x, y);
-
+    Cave[x][y-1] = Ydiamond_blank;
+    Next[x][y-1] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
     return;
   }
 
-  switch (Cave[y][x-1])
+  if (Cave[x+1][y] == Xdiamond)
   {
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Xacid_1:
-    case Xacid_2:
-    case Xacid_3:
-    case Xacid_4:
-    case Xacid_5:
-    case Xacid_6:
-    case Xacid_7:
-    case Xacid_8:
-    case Zplayer:
-      Cave[y][x] = Ytank_n_w;
-      Next[y][x] = Xtank_2_w;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_n);
-      return;
-
-    default:
-      Ltank_n(x, y);
-      return;
+    Cave[x+1][y] = Ydiamond_blank;
+    Next[x+1][y] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
+    return;
   }
-}
 
-static void Ltank_2_n(int x, int y)
-{
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (Cave[x][y+1] == Xdiamond)
   {
-    Lboom_tank(x, y);
-
+    Cave[x][y+1] = Ydiamond_blank;
+    Next[x][y+1] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
     return;
   }
 
-  Ltank_n(x, y);
-}
+  if (Cave[x-1][y] == Xdiamond)
+  {
+    Cave[x-1][y] = Ydiamond_blank;
+    Next[x-1][y] = Xblank;
+    play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
+    return;
+  }
 
-static void Ltank_e(int x, int y)
-{
-  switch (Cave[y][x+1])
+  switch (Cave[x-1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -1537,12 +1121,12 @@ static void Ltank_e(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ytank_eB;
-      if (Cave[y-1][x+2] == Xblank)
-	Cave[y-1][x+2] = Xacid_splash_e;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yeater_wB;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_e;
+      if (Cave[x-2][y-1] == Xblank)
+	Cave[x-2][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
@@ -1552,78 +1136,189 @@ static void Ltank_e(int x, int y)
     case Xplant:
     case Yplant:
     case Zplayer:
-      Cave[y][x] = Ytank_eB;
-      Cave[y][x+1] = Ytank_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xtank_1_e;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_e);
+      Cave[x][y] = Yeater_wB;
+      Cave[x-1][y] = Yeater_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xeater_w;
       return;
 
     default:
-      Cave[y][x] = Ytank_e_s;
-      Next[y][x] = Xtank_2_s;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_e);
+      Next[x][y] = RANDOM(2) ? Xeater_n : Xeater_s;
+      play_element_sound(x, y, SOUND_eater, Xeater_w);
       return;
   }
 }
 
-static void Ltank_1_e(int x, int y)
+static void Lalien(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
-  {
-    Lboom_tank(x, y);
+  int dx, dy;
 
-    return;
+  if (lev.wheel_cnt)
+  {
+    dx = lev.wheel_x;
+    dy = lev.wheel_y;
   }
-
-  switch (Cave[y-1][x])
+  else
   {
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Xacid_1:
-    case Xacid_2:
-    case Xacid_3:
-    case Xacid_4:
-    case Xacid_5:
-    case Xacid_6:
-    case Xacid_7:
-    case Xacid_8:
-    case Zplayer:
-      Cave[y][x] = Ytank_e_n;
-      Next[y][x] = Xtank_2_n;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_e);
-      return;
-
-    default:
-      Ltank_e(x, y);
-      return;
+    set_nearest_player_xy(x, y, &dx, &dy);
   }
-}
 
-static void Ltank_2_e(int x, int y)
-{
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (RANDOM(2))
   {
-    Lboom_tank(x, y);
-
-    return;
+    if (y > dy)
+    {
+      switch (Cave[x][y-1])
+      {
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	  Cave[x][y] = Yalien_nB;
+	  if (Cave[x+1][y-2] == Xblank)
+	    Cave[x+1][y-2] = Xacid_splash_e;
+	  if (Cave[x-1][y-2] == Xblank)
+	    Cave[x-1][y-2] = Xacid_splash_w;
+	  Next[x][y] = Xblank;
+	  play_element_sound(x, y, SOUND_acid, Xacid_1);
+	  return;
+
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	case Xplant:
+	case Yplant:
+	case Zplayer:
+	  Cave[x][y] = Yalien_nB;
+	  Cave[x][y-1] = Yalien_n;
+	  Next[x][y] = Xblank;
+	  Next[x][y-1] = Xalien_pause;
+	  play_element_sound(x, y, SOUND_alien, Xalien);
+	  return;
+      }
+    }
+    else if (y < dy)
+    {
+      switch (Cave[x][y+1])
+      {
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	  Cave[x][y] = Yalien_sB;
+	  Next[x][y] = Xblank;
+	  if (Cave[x+1][y] == Xblank)
+	    Cave[x+1][y] = Xacid_splash_e;
+	  if (Cave[x-1][y] == Xblank)
+	    Cave[x-1][y] = Xacid_splash_w;
+	  play_element_sound(x, y, SOUND_acid, Xacid_1);
+	  return;
+
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	case Xplant:
+	case Yplant:
+	case Zplayer:
+	  Cave[x][y] = Yalien_sB;
+	  Cave[x][y+1] = Yalien_s;
+	  Next[x][y] = Xblank;
+	  Next[x][y+1] = Xalien_pause;
+	  play_element_sound(x, y, SOUND_alien, Xalien);
+	  return;
+      }
+    }
   }
+  else
+  {
+    if (x < dx)
+    {
+      switch (Cave[x+1][y])
+      {
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	  Cave[x][y] = Yalien_eB;
+	  if (Cave[x+2][y-1] == Xblank)
+	    Cave[x+2][y-1] = Xacid_splash_e;
+	  if (Cave[x][y-1] == Xblank)
+	    Cave[x][y-1] = Xacid_splash_w;
+	  Next[x][y] = Xblank;
+	  play_element_sound(x, y, SOUND_acid, Xacid_1);
+	  return;
 
-  Ltank_e(x, y);
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	case Xplant:
+	case Yplant:
+	case Zplayer:
+	  Cave[x][y] = Yalien_eB;
+	  Cave[x+1][y] = Yalien_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xalien_pause;
+	  play_element_sound(x, y, SOUND_alien, Xalien);
+	  return;
+      }
+    }
+    else if (x > dx)
+    {
+      switch (Cave[x-1][y])
+      {
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	  Cave[x][y] = Yalien_wB;
+	  if (Cave[x][y-1] == Xblank)
+	    Cave[x][y-1] = Xacid_splash_e;
+	  if (Cave[x-2][y-1] == Xblank)
+	    Cave[x-2][y-1] = Xacid_splash_w;
+	  Next[x][y] = Xblank;
+	  play_element_sound(x, y, SOUND_acid, Xacid_1);
+	  return;
+
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	case Xplant:
+	case Yplant:
+	case Zplayer:
+	  Cave[x][y] = Yalien_wB;
+	  Cave[x-1][y] = Yalien_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xalien_pause;
+	  play_element_sound(x, y, SOUND_alien, Xalien);
+	  return;
+      }
+    }
+  }
 }
 
-static void Ltank_s(int x, int y)
+static void Lalien_pause(int x, int y)
+{
+  Next[x][y] = Xalien;
+}
+
+static void Lbug_n(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y-1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -1633,12 +1328,12 @@ static void Ltank_s(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ytank_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ybug_nB;
+      if (Cave[x+1][y-2] == Xblank)
+	Cave[x+1][y-2] = Xacid_splash_e;
+      if (Cave[x-1][y-2] == Xblank)
+	Cave[x-1][y-2] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
@@ -1648,34 +1343,34 @@ static void Ltank_s(int x, int y)
     case Xplant:
     case Yplant:
     case Zplayer:
-      Cave[y][x] = Ytank_sB;
-      Cave[y+1][x] = Ytank_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xtank_1_s;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_s);
+      Cave[x][y] = Ybug_nB;
+      Cave[x][y-1] = Ybug_n;
+      Next[x][y] = Xblank;
+      Next[x][y-1] = Xbug_1_n;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_n);
       return;
 
     default:
-      Cave[y][x] = Ytank_s_w;
-      Next[y][x] = Xtank_2_w;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_s);
+      Cave[x][y] = Ybug_n_w;
+      Next[x][y] = Xbug_2_w;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_n);
       return;
   }
 }
 
-static void Ltank_1_s(int x, int y)
+static void Lbug_1_n(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
   {
-    Lboom_tank(x, y);
+    Lboom_bug(x, y);
 
     return;
   }
 
-  switch (Cave[y][x+1])
+  switch (Cave[x+1][y])
   {
     case Xblank:
     case Xacid_splash_e:
@@ -1691,35 +1386,35 @@ static void Ltank_1_s(int x, int y)
     case Xacid_7:
     case Xacid_8:
     case Zplayer:
-      Cave[y][x] = Ytank_s_e;
-      Next[y][x] = Xtank_2_e;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_s);
+      Cave[x][y] = Ybug_n_e;
+      Next[x][y] = Xbug_2_e;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_n);
       return;
 
     default:
-      Ltank_s(x, y);
+      Lbug_n(x, y);
       return;
   }
 }
 
-static void Ltank_2_s(int x, int y)
+static void Lbug_2_n(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
   {
-    Lboom_tank(x, y);
+    Lboom_bug(x, y);
 
     return;
   }
 
-  Ltank_s(x, y);
+  Lbug_n(x, y);
 }
 
-static void Ltank_w(int x, int y)
+static void Lbug_e(int x, int y)
 {
-  switch (Cave[y][x-1])
+  switch (Cave[x+1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -1729,12 +1424,12 @@ static void Ltank_w(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ytank_wB;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_e;
-      if (Cave[y-1][x-2] == Xblank)
-	Cave[y-1][x-2] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ybug_eB;
+      if (Cave[x+2][y-1] == Xblank)
+	Cave[x+2][y-1] = Xacid_splash_e;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
@@ -1744,34 +1439,34 @@ static void Ltank_w(int x, int y)
     case Xplant:
     case Yplant:
     case Zplayer:
-      Cave[y][x] = Ytank_wB;
-      Cave[y][x-1] = Ytank_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xtank_1_w;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_w);
+      Cave[x][y] = Ybug_eB;
+      Cave[x+1][y] = Ybug_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xbug_1_e;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_e);
       return;
 
     default:
-      Cave[y][x] = Ytank_w_n;
-      Next[y][x] = Xtank_2_n;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_w);
+      Cave[x][y] = Ybug_e_n;
+      Next[x][y] = Xbug_2_n;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_e);
       return;
   }
 }
 
-static void Ltank_1_w(int x, int y)
+static void Lbug_1_e(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
   {
-    Lboom_tank(x, y);
+    Lboom_bug(x, y);
 
     return;
   }
 
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xblank:
     case Xacid_splash_e:
@@ -1787,439 +1482,189 @@ static void Ltank_1_w(int x, int y)
     case Xacid_7:
     case Xacid_8:
     case Zplayer:
-      Cave[y][x] = Ytank_w_s;
-      Next[y][x] = Xtank_2_s;
-      play_element_sound(x, y, SOUND_tank, Xtank_1_w);
+      Cave[x][y] = Ybug_e_s;
+      Next[x][y] = Xbug_2_s;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_e);
       return;
 
     default:
-      Ltank_w(x, y);
+      Lbug_e(x, y);
       return;
   }
 }
 
-static void Ltank_2_w(int x, int y)
+static void Lbug_2_e(int x, int y)
 {
-  if (tab_amoeba[Cave[y-1][x]] ||
-      tab_amoeba[Cave[y][x+1]] ||
-      tab_amoeba[Cave[y+1][x]] ||
-      tab_amoeba[Cave[y][x-1]])
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
   {
-    Lboom_tank(x, y);
+    Lboom_bug(x, y);
 
     return;
   }
 
-  Ltank_w(x, y);
+  Lbug_e(x, y);
 }
 
-static void Landroid(int x, int y)
+static void Lbug_s(int x, int y)
 {
-  int dx, dy, temp;
-
-  if (lev.android_clone_cnt == 0)
+  switch (Cave[x][y+1])
   {
-    if (Cave[y-1][x-1] != Xblank &&
-	Cave[y-1][x]   != Xblank &&
-	Cave[y-1][x+1] != Xblank &&
-	Cave[y][x-1]   != Xblank &&
-	Cave[y][x+1]   != Xblank &&
-	Cave[y+1][x-1] != Xblank &&
-	Cave[y+1][x]   != Xblank &&
-	Cave[y+1][x+1] != Xblank)
-      goto android_move;
-
-    switch (RANDOM & 7)
-    {
-      /* randomly find an object to clone */
+    case Xacid_1:
+    case Xacid_2:
+    case Xacid_3:
+    case Xacid_4:
+    case Xacid_5:
+    case Xacid_6:
+    case Xacid_7:
+    case Xacid_8:
+      Cave[x][y] = Ybug_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
+      play_element_sound(x, y, SOUND_acid, Xacid_1);
+      return;
 
-      case 0: /* S,NE,W,NW,SE,E,SW,N */
-	temp = lev.android_array[Cave[y+1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x-1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x+1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x]];   if (temp != Xblank) break;
-	goto android_move;
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
+    case Zplayer:
+      Cave[x][y] = Ybug_sB;
+      Cave[x][y+1] = Ybug_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xbug_1_s;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_s);
+      return;
 
-      case 1: /* NW,SE,N,S,NE,SW,E,W */
-	temp = lev.android_array[Cave[y-1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x+1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x-1]];   if (temp != Xblank) break;
-	goto android_move;
+    default:
+      Cave[x][y] = Ybug_s_e;
+      Next[x][y] = Xbug_2_e;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_s);
+      return;
+  }
+}
 
-      case 2: /* SW,E,S,W,N,NW,SE,NE */
-	temp = lev.android_array[Cave[y+1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x+1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x-1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x+1]]; if (temp != Xblank) break;
-	goto android_move;
+static void Lbug_1_s(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_bug(x, y);
 
-      case 3: /* N,SE,NE,E,W,S,NW,SW */
-	temp = lev.android_array[Cave[y-1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x+1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x-1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x-1]]; if (temp != Xblank) break;
-	goto android_move;
+    return;
+  }
 
-      case 4: /* SE,NW,E,NE,SW,W,N,S */
-	temp = lev.android_array[Cave[y+1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x+1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x-1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x]];   if (temp != Xblank) break;
-	goto android_move;
+  switch (Cave[x-1][y])
+  {
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
+    case Xacid_1:
+    case Xacid_2:
+    case Xacid_3:
+    case Xacid_4:
+    case Xacid_5:
+    case Xacid_6:
+    case Xacid_7:
+    case Xacid_8:
+    case Zplayer:
+      Cave[x][y] = Ybug_s_w;
+      Next[x][y] = Xbug_2_w;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_s);
+      return;
 
-      case 5: /* NE,W,SE,SW,S,N,E,NW */
-	temp = lev.android_array[Cave[y-1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x-1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x+1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x-1]]; if (temp != Xblank) break;
-	goto android_move;
+    default:
+      Lbug_s(x, y);
+      return;
+  }
+}
 
-      case 6: /* E,N,SW,S,NW,NE,SE,W */
-	temp = lev.android_array[Cave[y][x+1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x-1]];   if (temp != Xblank) break;
-	goto android_move;
+static void Lbug_2_s(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_bug(x, y);
 
-      case 7: /* W,SW,NW,N,E,SE,NE,S */
-	temp = lev.android_array[Cave[y][x-1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x-1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y][x+1]];   if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y-1][x+1]]; if (temp != Xblank) break;
-	temp = lev.android_array[Cave[y+1][x]];   if (temp != Xblank) break;
-	goto android_move;
-    }
+    return;
+  }
 
-    Next[y][x] = temp;	/* the item we chose to clone */
-    play_element_sound(x, y, SOUND_android_clone, temp);
+  Lbug_s(x, y);
+}
 
-    switch (RANDOM & 7)
-    {
-      /* randomly find a direction to move */
+static void Lbug_w(int x, int y)
+{
+  switch (Cave[x-1][y])
+  {
+    case Xacid_1:
+    case Xacid_2:
+    case Xacid_3:
+    case Xacid_4:
+    case Xacid_5:
+    case Xacid_6:
+    case Xacid_7:
+    case Xacid_8:
+      Cave[x][y] = Ybug_wB;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_e;
+      if (Cave[x-2][y-1] == Xblank)
+	Cave[x-2][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
+      play_element_sound(x, y, SOUND_acid, Xacid_1);
+      return;
 
-      case 0: /* S,NE,W,NW,SE,E,SW,N */
-	if (Cave[y+1][x] == Xblank)   goto android_s;
-	if (Cave[y-1][x+1] == Xblank) goto android_ne;
-	if (Cave[y][x-1] == Xblank)   goto android_w;
-	if (Cave[y-1][x-1] == Xblank) goto android_nw;
-	if (Cave[y+1][x+1] == Xblank) goto android_se;
-	if (Cave[y][x+1] == Xblank)   goto android_e;
-	if (Cave[y+1][x-1] == Xblank) goto android_sw;
-	if (Cave[y-1][x] == Xblank)   goto android_n;
-	goto android_move;
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
+    case Zplayer:
+      Cave[x][y] = Ybug_wB;
+      Cave[x-1][y] = Ybug_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xbug_1_w;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_w);
+      return;
 
-      case 1: /* NW,SE,N,S,NE,SW,E,W */
-	if (Cave[y-1][x-1] == Xblank) goto android_nw;
-	if (Cave[y+1][x+1] == Xblank) goto android_se;
-	if (Cave[y-1][x] == Xblank)   goto android_n;
-	if (Cave[y+1][x] == Xblank)   goto android_s;
-	if (Cave[y-1][x+1] == Xblank) goto android_ne;
-	if (Cave[y+1][x-1] == Xblank) goto android_sw;
-	if (Cave[y][x+1] == Xblank)   goto android_e;
-	if (Cave[y][x-1] == Xblank)   goto android_w;
-	goto android_move;
-
-      case 2: /* SW,E,S,W,N,NW,SE,NE */
-	if (Cave[y+1][x-1] == Xblank) goto android_sw;
-	if (Cave[y][x+1] == Xblank)   goto android_e;
-	if (Cave[y+1][x] == Xblank)   goto android_s;
-	if (Cave[y][x-1] == Xblank)   goto android_w;
-	if (Cave[y-1][x] == Xblank)   goto android_n;
-	if (Cave[y-1][x-1] == Xblank) goto android_nw;
-	if (Cave[y+1][x+1] == Xblank) goto android_se;
-	if (Cave[y-1][x+1] == Xblank) goto android_ne;
-	goto android_move;
-
-      case 3: /* N,SE,NE,E,W,S,NW,SW */
-	if (Cave[y-1][x] == Xblank)   goto android_n;
-	if (Cave[y+1][x+1] == Xblank) goto android_se;
-	if (Cave[y-1][x+1] == Xblank) goto android_ne;
-	if (Cave[y][x+1] == Xblank)   goto android_e;
-	if (Cave[y][x-1] == Xblank)   goto android_w;
-	if (Cave[y+1][x] == Xblank)   goto android_s;
-	if (Cave[y-1][x-1] == Xblank) goto android_nw;
-	if (Cave[y+1][x-1] == Xblank) goto android_sw;
-	goto android_move;
-
-      case 4: /* SE,NW,E,NE,SW,W,N,S */
-	if (Cave[y+1][x+1] == Xblank) goto android_se;
-	if (Cave[y-1][x-1] == Xblank) goto android_nw;
-	if (Cave[y][x+1] == Xblank)   goto android_e;
-	if (Cave[y-1][x+1] == Xblank) goto android_ne;
-	if (Cave[y+1][x-1] == Xblank) goto android_sw;
-	if (Cave[y][x-1] == Xblank)   goto android_w;
-	if (Cave[y-1][x] == Xblank)   goto android_n;
-	if (Cave[y+1][x] == Xblank)   goto android_s;
-	goto android_move;
-
-      case 5: /* NE,W,SE,SW,S,N,E,NW */
-	if (Cave[y-1][x+1] == Xblank) goto android_ne;
-	if (Cave[y][x-1] == Xblank)   goto android_w;
-	if (Cave[y+1][x+1] == Xblank) goto android_se;
-	if (Cave[y+1][x-1] == Xblank) goto android_sw;
-	if (Cave[y+1][x] == Xblank)   goto android_s;
-	if (Cave[y-1][x] == Xblank)   goto android_n;
-	if (Cave[y][x+1] == Xblank)   goto android_e;
-	if (Cave[y-1][x-1] == Xblank) goto android_nw;
-	goto android_move;
-
-      case 6: /* E,N,SW,S,NW,NE,SE,W */
-	if (Cave[y][x+1] == Xblank)   goto android_e;
-	if (Cave[y-1][x] == Xblank)   goto android_n;
-	if (Cave[y+1][x-1] == Xblank) goto android_sw;
-	if (Cave[y+1][x] == Xblank)   goto android_s;
-	if (Cave[y-1][x-1] == Xblank) goto android_nw;
-	if (Cave[y-1][x+1] == Xblank) goto android_ne;
-	if (Cave[y+1][x+1] == Xblank) goto android_se;
-	if (Cave[y][x-1] == Xblank)   goto android_w;
-	goto android_move;
-
-      case 7: /* W,SW,NW,N,E,SE,NE,S */
-	if (Cave[y][x-1] == Xblank)   goto android_w;
-	if (Cave[y+1][x-1] == Xblank) goto android_sw;
-	if (Cave[y-1][x-1] == Xblank) goto android_nw;
-	if (Cave[y-1][x] == Xblank)   goto android_n;
-	if (Cave[y][x+1] == Xblank)   goto android_e;
-	if (Cave[y+1][x+1] == Xblank) goto android_se;
-	if (Cave[y-1][x+1] == Xblank) goto android_ne;
-	if (Cave[y+1][x] == Xblank)   goto android_s;
-	goto android_move;
-    }
+    default:
+      Cave[x][y] = Ybug_w_s;
+      Next[x][y] = Xbug_2_s;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_w);
+      return;
   }
+}
 
- android_move:
-  if (lev.android_move_cnt == 0)
+static void Lbug_1_w(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
   {
-    if (Cave[y-1][x-1] == Zplayer ||
-	Cave[y-1][x]   == Zplayer ||
-	Cave[y-1][x+1] == Zplayer ||
-	Cave[y][x-1]   == Zplayer ||
-	Cave[y][x+1]   == Zplayer ||
-	Cave[y+1][x-1] == Zplayer ||
-	Cave[y+1][x]   == Zplayer ||
-	Cave[y+1][x+1] == Zplayer)
-      goto android_still;
-
-    set_nearest_player_xy(x, y, &dx, &dy);
-
-    Next[y][x] = Xblank;	/* assume we will move */
-    temp = ((x < dx) + 1 - (x > dx)) + ((y < dy) + 1 - (y > dy)) * 3;
-
-    if (RANDOM & 1)
-    {
-      switch (temp)
-      {
-	/* attempt clockwise move first if direct path is blocked */
-
-	case 0: /* north west */
-	  if (tab_android_move[Cave[y-1][x-1]]) goto android_nw;
-	  if (tab_android_move[Cave[y-1][x]])   goto android_n;
-	  if (tab_android_move[Cave[y][x-1]])   goto android_w;
-	  break;
-
-	case 1: /* north */
-	  if (tab_android_move[Cave[y-1][x]])   goto android_n;
-	  if (tab_android_move[Cave[y-1][x+1]]) goto android_ne;
-	  if (tab_android_move[Cave[y-1][x-1]]) goto android_nw;
-	  break;
-
-	case 2: /* north east */
-	  if (tab_android_move[Cave[y-1][x+1]]) goto android_ne;
-	  if (tab_android_move[Cave[y][x+1]])   goto android_e;
-	  if (tab_android_move[Cave[y-1][x]])   goto android_n;
-	  break;
-
-	case 3: /* west */
-	  if (tab_android_move[Cave[y][x-1]])   goto android_w;
-	  if (tab_android_move[Cave[y-1][x-1]]) goto android_nw;
-	  if (tab_android_move[Cave[y+1][x-1]]) goto android_sw;
-	  break;
-
-	case 4: /* nowhere */
-	  break;
-
-	case 5: /* east */
-	  if (tab_android_move[Cave[y][x+1]])   goto android_e;
-	  if (tab_android_move[Cave[y+1][x+1]]) goto android_se;
-	  if (tab_android_move[Cave[y-1][x+1]]) goto android_ne;
-	  break;
-
-	case 6: /* south west */
-	  if (tab_android_move[Cave[y+1][x-1]]) goto android_sw;
-	  if (tab_android_move[Cave[y][x-1]])   goto android_w;
-	  if (tab_android_move[Cave[y+1][x]])   goto android_s;
-	  break;
-
-	case 7: /* south */
-	  if (tab_android_move[Cave[y+1][x]])   goto android_s;
-	  if (tab_android_move[Cave[y+1][x-1]]) goto android_sw;
-	  if (tab_android_move[Cave[y+1][x+1]]) goto android_se;
-	  break;
-
-	case 8: /* south east */
-	  if (tab_android_move[Cave[y+1][x+1]]) goto android_se;
-	  if (tab_android_move[Cave[y+1][x]])   goto android_s;
-	  if (tab_android_move[Cave[y][x+1]])   goto android_e;
-	  break;
-      }
-    }
-    else
-    {
-      switch (temp)
-      {
-	/* attempt counterclockwise move first if direct path is blocked */
-
-	case 0: /* north west */
-	  if (tab_android_move[Cave[y-1][x-1]]) goto android_nw;
-	  if (tab_android_move[Cave[y][x-1]])   goto android_w;
-	  if (tab_android_move[Cave[y-1][x]])   goto android_n;
-	  break;
-
-	case 1: /* north */
-	  if (tab_android_move[Cave[y-1][x]])   goto android_n;
-	  if (tab_android_move[Cave[y-1][x-1]]) goto android_nw;
-	  if (tab_android_move[Cave[y-1][x+1]]) goto android_ne;
-	  break;
-
-	case 2: /* north east */
-	  if (tab_android_move[Cave[y-1][x+1]]) goto android_ne;
-	  if (tab_android_move[Cave[y-1][x]])   goto android_n;
-	  if (tab_android_move[Cave[y][x+1]])   goto android_e;
-	  break;
-
-	case 3: /* west */
-	  if (tab_android_move[Cave[y][x-1]])   goto android_w;
-	  if (tab_android_move[Cave[y+1][x-1]]) goto android_sw;
-	  if (tab_android_move[Cave[y-1][x-1]]) goto android_nw;
-	  break;
-
-	case 4: /* nowhere */
-	  break;
-
-	case 5: /* east */
-	  if (tab_android_move[Cave[y][x+1]])   goto android_e;
-	  if (tab_android_move[Cave[y-1][x+1]]) goto android_ne;
-	  if (tab_android_move[Cave[y+1][x+1]]) goto android_se;
-	  break;
-
-	case 6: /* south west */
-	  if (tab_android_move[Cave[y+1][x-1]]) goto android_sw;
-	  if (tab_android_move[Cave[y+1][x]])   goto android_s;
-	  if (tab_android_move[Cave[y][x-1]])   goto android_w;
-	  break;
-
-	case 7: /* south */
-	  if (tab_android_move[Cave[y+1][x]])   goto android_s;
-	  if (tab_android_move[Cave[y+1][x+1]]) goto android_se;
-	  if (tab_android_move[Cave[y+1][x-1]]) goto android_sw;
-	  break;
+    Lboom_bug(x, y);
 
-	case 8: /* south east */
-	  if (tab_android_move[Cave[y+1][x+1]]) goto android_se;
-	  if (tab_android_move[Cave[y][x+1]])   goto android_e;
-	  if (tab_android_move[Cave[y+1][x]])   goto android_s;
-	  break;
-      }
-    }
+    return;
   }
 
- android_still:
-  Next[y][x] = Xandroid;
-  return;
-
- android_n:
-  Cave[y][x] = Yandroid_nB;
-  Cave[y-1][x] = Yandroid_n;
-  Next[y-1][x] = Xandroid;
-  play_element_sound(x, y, SOUND_android_move, Xandroid);
-  return;
-
- android_ne:
-  Cave[y][x] = Yandroid_neB;
-  Cave[y-1][x+1] = Yandroid_ne;
-  Next[y-1][x+1] = Xandroid;
-  play_element_sound(x, y, SOUND_android_move, Xandroid);
-  return;
-
- android_e:
-  Cave[y][x] = Yandroid_eB;
-  Cave[y][x+1] = Yandroid_e;
-  Next[y][x+1] = Xandroid;
-  play_element_sound(x, y, SOUND_android_move, Xandroid);
-  return;
-
- android_se:
-  Cave[y][x] = Yandroid_seB;
-  Cave[y+1][x+1] = Yandroid_se;
-  Next[y+1][x+1] = Xandroid;
-  play_element_sound(x, y, SOUND_android_move, Xandroid);
-  return;
-
- android_s:
-  Cave[y][x] = Yandroid_sB;
-  Cave[y+1][x] = Yandroid_s;
-  Next[y+1][x] = Xandroid;
-  play_element_sound(x, y, SOUND_android_move, Xandroid);
-  return;
-
- android_sw:
-  Cave[y][x] = Yandroid_swB;
-  Cave[y+1][x-1] = Yandroid_sw;
-  Next[y+1][x-1] = Xandroid;
-  play_element_sound(x, y, SOUND_android_move, Xandroid);
-  return;
-
- android_w:
-  Cave[y][x] = Yandroid_wB;
-  Cave[y][x-1] = Yandroid_w;
-  Next[y][x-1] = Xandroid;
-  play_element_sound(x, y, SOUND_android_move, Xandroid);
-  return;
-
- android_nw:
-  Cave[y][x] = Yandroid_nwB;
-  Cave[y-1][x-1] = Yandroid_nw;
-  Next[y-1][x-1] = Xandroid;
-  play_element_sound(x, y, SOUND_android_move, Xandroid);
-  return;
-}
-
-static void Landroid_1_n(int x, int y)
-{
-  switch (Cave[y-1][x])
+  switch (Cave[x][y-1])
   {
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
     case Xacid_1:
     case Xacid_2:
     case Xacid_3:
@@ -2228,34 +1673,36 @@ static void Landroid_1_n(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yandroid_nB;
-      if (Cave[y-2][x+1] == Xblank)
-	Cave[y-2][x+1] = Xacid_splash_e;
-      if (Cave[y-2][x-1] == Xblank)
-	Cave[y-2][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
-      play_element_sound(x, y, SOUND_acid, Xacid_1);
-      return;
-
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-      Cave[y][x] = Yandroid_nB;
-      Cave[y-1][x] = Yandroid_n;
-      Next[y][x] = Xblank;
-      Next[y-1][x] = Xandroid;
-      play_element_sound(x, y, SOUND_android_move, Xandroid_1_n);
+    case Zplayer:
+      Cave[x][y] = Ybug_w_n;
+      Next[x][y] = Xbug_2_n;
+      play_element_sound(x, y, SOUND_bug, Xbug_1_w);
       return;
 
     default:
-      Landroid(x, y);
+      Lbug_w(x, y);
       return;
   }
 }
 
-static void Landroid_2_n(int x, int y)
+static void Lbug_2_w(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_bug(x, y);
+
+    return;
+  }
+
+  Lbug_w(x, y);
+}
+
+static void Ltank_n(int x, int y)
 {
-  switch (Cave[y-1][x])
+  switch (Cave[x][y-1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2265,35 +1712,55 @@ static void Landroid_2_n(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yandroid_nB;
-      if (Cave[y-2][x+1] == Xblank)
-	Cave[y-2][x+1] = Xacid_splash_e;
-      if (Cave[y-2][x-1] == Xblank)
-	Cave[y-2][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ytank_nB;
+      if (Cave[x+1][y-2] == Xblank)
+	Cave[x+1][y-2] = Xacid_splash_e;
+      if (Cave[x-1][y-2] == Xblank)
+	Cave[x-1][y-2] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yandroid_nB;
-      Cave[y-1][x] = Yandroid_n;
-      Next[y][x] = Xblank;
-      Next[y-1][x] = Xandroid_1_n;
-      play_element_sound(x, y, SOUND_android_move, Xandroid_2_n);
+    case Xplant:
+    case Yplant:
+    case Zplayer:
+      Cave[x][y] = Ytank_nB;
+      Cave[x][y-1] = Ytank_n;
+      Next[x][y] = Xblank;
+      Next[x][y-1] = Xtank_1_n;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_n);
       return;
 
     default:
-      Landroid(x, y);
+      Cave[x][y] = Ytank_n_e;
+      Next[x][y] = Xtank_2_e;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_n);
       return;
   }
 }
 
-static void Landroid_1_e(int x, int y)
+static void Ltank_1_n(int x, int y)
 {
-  switch (Cave[y][x+1])
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_tank(x, y);
+
+    return;
+  }
+
+  switch (Cave[x-1][y])
   {
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
     case Xacid_1:
     case Xacid_2:
     case Xacid_3:
@@ -2302,34 +1769,36 @@ static void Landroid_1_e(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yandroid_eB;
-      if (Cave[y-1][x+2] == Xblank)
-	Cave[y-1][x+2] = Xacid_splash_e;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_w;
-      Next[y][x] = Xblank;
-      play_element_sound(x, y, SOUND_acid, Xacid_1);
-      return;
-
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-      Cave[y][x] = Yandroid_eB;
-      Cave[y][x+1] = Yandroid_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xandroid;
-      play_element_sound(x, y, SOUND_android_move, Xandroid_1_e);
+    case Zplayer:
+      Cave[x][y] = Ytank_n_w;
+      Next[x][y] = Xtank_2_w;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_n);
       return;
 
     default:
-      Landroid(x, y);
+      Ltank_n(x, y);
       return;
   }
 }
 
-static void Landroid_2_e(int x, int y)
+static void Ltank_2_n(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_tank(x, y);
+
+    return;
+  }
+
+  Ltank_n(x, y);
+}
+
+static void Ltank_e(int x, int y)
 {
-  switch (Cave[y][x+1])
+  switch (Cave[x+1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2339,35 +1808,55 @@ static void Landroid_2_e(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yandroid_eB;
-      if (Cave[y-1][x+2] == Xblank)
-	Cave[y-1][x+2] = Xacid_splash_e;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ytank_eB;
+      if (Cave[x+2][y-1] == Xblank)
+	Cave[x+2][y-1] = Xacid_splash_e;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yandroid_eB;
-      Cave[y][x+1] = Yandroid_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xandroid_1_e;
-      play_element_sound(x, y, SOUND_android_move, Xandroid_2_e);
+    case Xplant:
+    case Yplant:
+    case Zplayer:
+      Cave[x][y] = Ytank_eB;
+      Cave[x+1][y] = Ytank_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xtank_1_e;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_e);
       return;
 
     default:
-      Landroid(x, y);
+      Cave[x][y] = Ytank_e_s;
+      Next[x][y] = Xtank_2_s;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_e);
       return;
   }
 }
 
-static void Landroid_1_s(int x, int y)
+static void Ltank_1_e(int x, int y)
 {
-  switch (Cave[y+1][x])
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_tank(x, y);
+
+    return;
+  }
+
+  switch (Cave[x][y-1])
   {
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
     case Xacid_1:
     case Xacid_2:
     case Xacid_3:
@@ -2376,34 +1865,36 @@ static void Landroid_1_s(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yandroid_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
-      play_element_sound(x, y, SOUND_acid, Xacid_1);
-      return;
-
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-      Cave[y][x] = Yandroid_sB;
-      Cave[y+1][x] = Yandroid_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xandroid;
-      play_element_sound(x, y, SOUND_android_move, Xandroid_1_s);
+    case Zplayer:
+      Cave[x][y] = Ytank_e_n;
+      Next[x][y] = Xtank_2_n;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_e);
       return;
 
     default:
-      Landroid(x, y);
+      Ltank_e(x, y);
       return;
   }
 }
 
-static void Landroid_2_s(int x, int y)
+static void Ltank_2_e(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_tank(x, y);
+
+    return;
+  }
+
+  Ltank_e(x, y);
+}
+
+static void Ltank_s(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2413,35 +1904,55 @@ static void Landroid_2_s(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yandroid_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ytank_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yandroid_sB;
-      Cave[y+1][x] = Yandroid_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xandroid_1_s;
-      play_element_sound(x, y, SOUND_android_move, Xandroid_2_s);
+    case Xplant:
+    case Yplant:
+    case Zplayer:
+      Cave[x][y] = Ytank_sB;
+      Cave[x][y+1] = Ytank_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xtank_1_s;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_s);
       return;
 
     default:
-      Landroid(x, y);
+      Cave[x][y] = Ytank_s_w;
+      Next[x][y] = Xtank_2_w;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_s);
       return;
   }
 }
 
-static void Landroid_1_w(int x, int y)
+static void Ltank_1_s(int x, int y)
 {
-  switch (Cave[y][x-1])
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_tank(x, y);
+
+    return;
+  }
+
+  switch (Cave[x+1][y])
   {
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
     case Xacid_1:
     case Xacid_2:
     case Xacid_3:
@@ -2450,34 +1961,36 @@ static void Landroid_1_w(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yandroid_wB;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_e;
-      if (Cave[y-1][x-2] == Xblank)
-	Cave[y-1][x-2] = Xacid_splash_w;
-      Next[y][x] = Xblank;
-      play_element_sound(x, y, SOUND_acid, Xacid_1);
-      return;
-
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-      Cave[y][x] = Yandroid_wB;
-      Cave[y][x-1] = Yandroid_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xandroid;
-      play_element_sound(x, y, SOUND_android_move, Xandroid_1_w);
+    case Zplayer:
+      Cave[x][y] = Ytank_s_e;
+      Next[x][y] = Xtank_2_e;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_s);
       return;
 
     default:
-      Landroid(x, y);
+      Ltank_s(x, y);
       return;
   }
 }
 
-static void Landroid_2_w(int x, int y)
+static void Ltank_2_s(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_tank(x, y);
+
+    return;
+  }
+
+  Ltank_s(x, y);
+}
+
+static void Ltank_w(int x, int y)
 {
-  switch (Cave[y][x-1])
+  switch (Cave[x-1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2487,34 +2000,93 @@ static void Landroid_2_w(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yandroid_wB;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_e;
-      if (Cave[y-1][x-2] == Xblank)
-	Cave[y-1][x-2] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ytank_wB;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_e;
+      if (Cave[x-2][y-1] == Xblank)
+	Cave[x-2][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yandroid_wB;
-      Cave[y][x-1] = Yandroid_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xandroid_1_w;
-      play_element_sound(x, y, SOUND_android_move, Xandroid_1_w);
+    case Xplant:
+    case Yplant:
+    case Zplayer:
+      Cave[x][y] = Ytank_wB;
+      Cave[x-1][y] = Ytank_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xtank_1_w;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_w);
       return;
 
     default:
-      Landroid(x, y);
+      Cave[x][y] = Ytank_w_n;
+      Next[x][y] = Xtank_2_n;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_w);
       return;
   }
 }
 
-static void Lspring(int x, int y)
+static void Ltank_1_w(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_tank(x, y);
+
+    return;
+  }
+
+  switch (Cave[x][y+1])
+  {
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
+    case Xacid_1:
+    case Xacid_2:
+    case Xacid_3:
+    case Xacid_4:
+    case Xacid_5:
+    case Xacid_6:
+    case Xacid_7:
+    case Xacid_8:
+    case Zplayer:
+      Cave[x][y] = Ytank_w_s;
+      Next[x][y] = Xtank_2_s;
+      play_element_sound(x, y, SOUND_tank, Xtank_1_w);
+      return;
+
+    default:
+      Ltank_w(x, y);
+      return;
+  }
+}
+
+static void Ltank_2_w(int x, int y)
+{
+  if (tab_amoeba[Cave[x][y-1]] ||
+      tab_amoeba[Cave[x+1][y]] ||
+      tab_amoeba[Cave[x][y+1]] ||
+      tab_amoeba[Cave[x-1][y]])
+  {
+    Lboom_tank(x, y);
+
+    return;
+  }
+
+  Ltank_w(x, y);
+}
+
+static void Lemerald(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2524,24 +2096,22 @@ static void Lspring(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yspring_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yemerald_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Yspring_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xspring_fall;
+      Cave[x][y] = Yemerald_sB;
+      Cave[x][y+1] = Yemerald_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xemerald_fall;
       return;
 
     case Xspring:
@@ -2574,6 +2144,7 @@ static void Lspring(int x, int y)
     case Xnut_pause:
     case Xslidewall_ns:
     case Xslidewall_ew:
+    case Xwonderwall:
     case Xkey_1:
     case Xkey_2:
     case Xkey_3:
@@ -2584,84 +2155,73 @@ static void Lspring(int x, int y)
     case Xkey_8:
     case Xbumper:
     case Xswitch:
+    case Xsteel_1:
+    case Xsteel_2:
+    case Xsteel_3:
+    case Xsteel_4:
+    case Xwall_1:
+    case Xwall_2:
+    case Xwall_3:
+    case Xwall_4:
     case Xroundwall_1:
     case Xroundwall_2:
     case Xroundwall_3:
     case Xroundwall_4:
-      if (RANDOM & 1)
+      if (RANDOM(2))
       {
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
 	{
-	  Cave[y][x] = Yspring_eB;
-	  Cave[y][x+1] = Yspring_e;
-	  if (Cave[y+1][x] == Xbumper)
-	    Cave[y+1][x] = XbumperB;
-	  Next[y][x] = Xblank;
-
-#ifdef SPRING_ROLL
-	  Next[y][x+1] = Xspring_e;
-#else	
-	  Next[y][x+1] = Xspring_pause;
-#endif
+	  Cave[x][y] = Yemerald_eB;
+	  Cave[x+1][y] = Yemerald_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xemerald_pause;
 	  return;
 	}
 
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
 	{
-	  Cave[y][x] = Yspring_wB;
-	  Cave[y][x-1] = Yspring_w;
-	  if (Cave[y+1][x] == Xbumper)
-	    Cave[y+1][x] = XbumperB;
-	  Next[y][x] = Xblank;
-
-#ifdef SPRING_ROLL
-	  Next[y][x-1] = Xspring_w;
-#else
-	  Next[y][x-1] = Xspring_pause;
-#endif
+	  Cave[x][y] = Yemerald_wB;
+	  Cave[x-1][y] = Yemerald_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xemerald_pause;
 	  return;
 	}
       }
       else
       {
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
 	{
-	  Cave[y][x] = Yspring_wB;
-	  Cave[y][x-1] = Yspring_w;
-	  if (Cave[y+1][x] == Xbumper)
-	    Cave[y+1][x] = XbumperB;
-	  Next[y][x] = Xblank;
-
-#ifdef SPRING_ROLL
-	  Next[y][x-1] = Xspring_w;
-#else
-	  Next[y][x-1] = Xspring_pause;
-#endif
+	  Cave[x][y] = Yemerald_wB;
+	  Cave[x-1][y] = Yemerald_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xemerald_pause;
 	  return;
 	}
 
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
 	{
-	  Cave[y][x] = Yspring_eB;
-	  Cave[y][x+1] = Yspring_e;
-	  if (Cave[y+1][x] == Xbumper)
-	    Cave[y+1][x] = XbumperB;
-	  Next[y][x] = Xblank;
-
-#ifdef SPRING_ROLL
-	  Next[y][x+1] = Xspring_e;
-#else
-	  Next[y][x+1] = Xspring_pause;
-#endif
+	  Cave[x][y] = Yemerald_eB;
+	  Cave[x+1][y] = Yemerald_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xemerald_pause;
 	  return;
 	}
       }
+
+    default:
+      if (++lev.shine_cnt > 50)
+      {
+	lev.shine_cnt = RANDOM(8);
+	Cave[x][y] = Xemerald_shine;
+      }
+
+      return;
   }
 }
 
-static void Lspring_pause(int x, int y)
+static void Lemerald_pause(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2671,34 +2231,34 @@ static void Lspring_pause(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yspring_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yemerald_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Yspring_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xspring_fall;
+      Cave[x][y] = Yemerald_sB;
+      Cave[x][y+1] = Yemerald_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xemerald_fall;
       return;
 
     default:
-      Cave[y][x] = Xspring;
-      Next[y][x] = Xspring;
+      Cave[x][y] = Xemerald;
+      Next[x][y] = Xemerald;
       return;
   }
 }
 
-static void Lspring_e(int x, int y)
+static void Lemerald_fall(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2708,29 +2268,52 @@ static void Lspring_e(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yspring_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yemerald_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Yspring_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xspring_fall;
+    case Zplayer:
+      Cave[x][y] = Yemerald_sB;
+      Cave[x][y+1] = Yemerald_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xemerald_fall;
       return;
 
-    case Xbumper:
-      Cave[y+1][x] = XbumperB;
+    case Xwonderwall:
+      if (lev.wonderwall_time)
+      {
+	lev.wonderwall_state = 1;
+	Cave[x][y] = Yemerald_sB;
+	if (tab_blank[Cave[x][y+2]])
+	{
+	  Cave[x][y+2] = Ydiamond_s;
+	  Next[x][y+2] = Xdiamond_fall;
+	}
+
+	Next[x][y] = Xblank;
+	play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
+	return;
+      }
+
+    default:
+      Cave[x][y] = Xemerald;
+      Next[x][y] = Xemerald;
+      play_element_sound(x, y, SOUND_diamond, Xemerald);
+      return;
   }
+}
 
-  switch (Cave[y][x+1])
+static void Ldiamond(int x, int y)
+{
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2740,60 +2323,132 @@ static void Lspring_e(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yspring_eB;
-      if (Cave[y-1][x+2] == Xblank)
-	Cave[y-1][x+2] = Xacid_splash_e;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ydiamond_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Yalien_nB:
-    case Yalien_eB:
-    case Yalien_sB:
-    case Yalien_wB:
-      Cave[y][x] = Yspring_eB;
-      Cave[y][x+1] = Yspring_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xspring_e;
-      return;
-
-    case Xalien:
-    case Xalien_pause:
-    case Yalien_n:
-    case Yalien_e:
-    case Yalien_s:
-    case Yalien_w:
-      Cave[y][x] = Yspring_alien_eB;
-      Cave[y][x+1] = Yspring_alien_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xspring_e;
-      play_element_sound(x, y, SOUND_slurp, Xalien);
-      score += lev.slurp_score;
+      Cave[x][y] = Ydiamond_sB;
+      Cave[x][y+1] = Ydiamond_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xdiamond_fall;
       return;
 
+    case Xspring:
+    case Xspring_pause:
+    case Xspring_e:
+    case Xspring_w:
+    case Xandroid:
+    case Xandroid_1_n:
+    case Xandroid_2_n:
+    case Xandroid_1_e:
+    case Xandroid_2_e:
+    case Xandroid_1_s:
+    case Xandroid_2_s:
+    case Xandroid_1_w:
+    case Xandroid_2_w:
+    case Xstone:
+    case Xstone_pause:
+    case Xemerald:
+    case Xemerald_pause:
+    case Xdiamond:
+    case Xdiamond_pause:
+    case Xbomb:
+    case Xbomb_pause:
+    case Xballoon:
+    case Xacid_ne:
+    case Xacid_nw:
+    case Xball_1:
+    case Xball_2:
+    case Xnut:
+    case Xnut_pause:
+    case Xslidewall_ns:
+    case Xslidewall_ew:
+    case Xwonderwall:
+    case Xkey_1:
+    case Xkey_2:
+    case Xkey_3:
+    case Xkey_4:
+    case Xkey_5:
+    case Xkey_6:
+    case Xkey_7:
+    case Xkey_8:
     case Xbumper:
-    case XbumperB:
-      Cave[y][x+1] = XbumperB;
-      Next[y][x] = Xspring_w;
-      play_element_sound(x, y, SOUND_spring, Xspring);
-      return;
+    case Xswitch:
+    case Xsteel_1:
+    case Xsteel_2:
+    case Xsteel_3:
+    case Xsteel_4:
+    case Xwall_1:
+    case Xwall_2:
+    case Xwall_3:
+    case Xwall_4:
+    case Xroundwall_1:
+    case Xroundwall_2:
+    case Xroundwall_3:
+    case Xroundwall_4:
+      if (RANDOM(2))
+      {
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
+	{
+	  Cave[x][y] = Ydiamond_eB;
+	  Cave[x+1][y] = Ydiamond_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xdiamond_pause;
+	  return;
+	}
+
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
+	{
+	  Cave[x][y] = Ydiamond_wB;
+	  Cave[x-1][y] = Ydiamond_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xdiamond_pause;
+	  return;
+	}
+      }
+      else
+      {
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
+	{
+	  Cave[x][y] = Ydiamond_wB;
+	  Cave[x-1][y] = Ydiamond_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xdiamond_pause;
+	  return;
+	}
+
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
+	{
+	  Cave[x][y] = Ydiamond_eB;
+	  Cave[x+1][y] = Ydiamond_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xdiamond_pause;
+	  return;
+	}
+      }
 
     default:
-      Cave[y][x] = Xspring;
-      Next[y][x] = Xspring;
-      play_element_sound(x, y, SOUND_spring, Xspring);
+      if (++lev.shine_cnt > 50)
+      {
+	lev.shine_cnt = RANDOM(8);
+	Cave[x][y] = Xdiamond_shine;
+      }
+
       return;
   }
 }
 
-static void Lspring_w(int x, int y)
+static void Ldiamond_pause(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2803,29 +2458,34 @@ static void Lspring_w(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yspring_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ydiamond_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Yspring_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xspring_fall;
+      Cave[x][y] = Ydiamond_sB;
+      Cave[x][y+1] = Ydiamond_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xdiamond_fall;
       return;
 
-    case Xbumper:
-      Cave[y+1][x] = XbumperB;
+    default:
+      Cave[x][y] = Xdiamond;
+      Next[x][y] = Xdiamond;
+      return;
   }
+}
 
-  switch (Cave[y][x-1])
+static void Ldiamond_fall(int x, int y)
+{
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2835,60 +2495,52 @@ static void Lspring_w(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yspring_wB;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_e;
-      if (Cave[y-1][x-2] == Xblank)
-	Cave[y-1][x-2] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ydiamond_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Yalien_nB:
-    case Yalien_eB:
-    case Yalien_sB:
-    case Yalien_wB:
-      Cave[y][x] = Yspring_wB;
-      Cave[y][x-1] = Yspring_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xspring_w;
+    case Zplayer:
+      Cave[x][y] = Ydiamond_sB;
+      Cave[x][y+1] = Ydiamond_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xdiamond_fall;
       return;
 
-    case Xalien:
-    case Xalien_pause:
-    case Yalien_n:
-    case Yalien_e:
-    case Yalien_s:
-    case Yalien_w:
-      Cave[y][x] = Yspring_alien_wB;
-      Cave[y][x-1] = Yspring_alien_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xspring_w;
-      play_element_sound(x, y, SOUND_slurp, Xalien);
-      score += lev.slurp_score;
-      return;
+    case Xwonderwall:
+      if (lev.wonderwall_time)
+      {
+	lev.wonderwall_state = 1;
+	Cave[x][y] = Ydiamond_sB;
+	if (tab_blank[Cave[x][y+2]])
+	{
+	  Cave[x][y+2] = Ystone_s;
+	  Next[x][y+2] = Xstone_fall;
+	}
 
-    case Xbumper:
-    case XbumperB:
-      Cave[y][x-1] = XbumperB;
-      Next[y][x] = Xspring_e;
-      play_element_sound(x, y, SOUND_spring, Xspring);
-      return;
+	Next[x][y] = Xblank;
+	play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
+	return;
+      }
 
     default:
-      Cave[y][x] = Xspring;
-      Next[y][x] = Xspring;
-      play_element_sound(x, y, SOUND_spring, Xspring);
+      Cave[x][y] = Xdiamond;
+      Next[x][y] = Xdiamond;
+      play_element_sound(x, y, SOUND_diamond, Xdiamond);
       return;
   }
 }
 
-static void Lspring_fall(int x, int y)
+static void Lstone(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -2898,181 +2550,135 @@ static void Lspring_fall(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yspring_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ystone_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Zplayer:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Yspring_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xspring_fall;
-      return;
-
-    case Xbomb:
-    case Xbomb_pause:
-      Cave[y+1][x] = Ybomb_blank;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = Xblank;
-      Boom[y][x] = Xblank;
-      Boom[y][x+1] = Xblank;
-      Boom[y+1][x-1] = Xblank;
-      Boom[y+1][x] = Xblank;
-      Boom[y+1][x+1] = Xblank;
-      Boom[y+2][x-1] = Xblank;
-      Boom[y+2][x] = Xblank;
-      Boom[y+2][x+1] = Xblank;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xspring_fall);
-#endif
-      return;
-
-    case Xbug_1_n:
-    case Xbug_1_e:
-    case Xbug_1_s:
-    case Xbug_1_w:
-    case Xbug_2_n:
-    case Xbug_2_e:
-    case Xbug_2_s:
-    case Xbug_2_w:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Ybug_spring;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = Xemerald;
-      Boom[y][x] = Xemerald;
-      Boom[y][x+1] = Xemerald;
-      Boom[y+1][x-1] = Xemerald;
-      Boom[y+1][x] = Xdiamond;
-      Boom[y+1][x+1] = Xemerald;
-      Boom[y+2][x-1] = Xemerald;
-      Boom[y+2][x] = Xemerald;
-      Boom[y+2][x+1] = Xemerald;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xspring_fall);
+    case Xplant:
+    case Yplant:
+#ifdef EM_ENGINE_USE_ADDITIONAL_ELEMENTS
+    case Xfake_acid_1:
+    case Xfake_acid_2:
+    case Xfake_acid_3:
+    case Xfake_acid_4:
+    case Xfake_acid_5:
+    case Xfake_acid_6:
+    case Xfake_acid_7:
+    case Xfake_acid_8:
 #endif
-      score += lev.bug_score;
+      Cave[x][y] = Ystone_sB;
+      Cave[x][y+1] = Ystone_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xstone_fall;
       return;
 
-    case Xtank_1_n:
-    case Xtank_1_e:
-    case Xtank_1_s:
-    case Xtank_1_w:
-    case Xtank_2_n:
-    case Xtank_2_e:
-    case Xtank_2_s:
-    case Xtank_2_w:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Ytank_spring;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = Xblank;
-      Boom[y][x] = Xblank;
-      Boom[y][x+1] = Xblank;
-      Boom[y+1][x-1] = Xblank;
-      Boom[y+1][x] = Xblank;
-      Boom[y+1][x+1] = Xblank;
-      Boom[y+2][x-1] = Xblank;
-      Boom[y+2][x] = Xblank;
-      Boom[y+2][x+1] = Xblank;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xspring_fall);
-#endif
-      score += lev.tank_score;
+    case Xsand:
+      Cave[x][y] = Xsand_stonein_1;
+      Cave[x][y+1] = Xsand_sandstone_1;
+      Next[x][y] = Xsand_stonein_2;
+      Next[x][y+1] = Xsand_sandstone_2;
       return;
 
-    case Xeater_n:
-    case Xeater_e:
-    case Xeater_s:
-    case Xeater_w:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Yeater_spring;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = lev.eater_array[lev.eater_pos][0];
-      Boom[y][x] = lev.eater_array[lev.eater_pos][1];
-      Boom[y][x+1] = lev.eater_array[lev.eater_pos][2];
-      Boom[y+1][x-1] = lev.eater_array[lev.eater_pos][3];
-      Boom[y+1][x] = lev.eater_array[lev.eater_pos][4];
-      Boom[y+1][x+1] = lev.eater_array[lev.eater_pos][5];
-      Boom[y+2][x-1] = lev.eater_array[lev.eater_pos][6];
-      Boom[y+2][x] = lev.eater_array[lev.eater_pos][7];
-      Boom[y+2][x+1] = lev.eater_array[lev.eater_pos][8];
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xspring_fall);
-#endif
-      lev.eater_pos = (lev.eater_pos + 1) & 7;
-      score += lev.eater_score;
-      return;
+    case Xspring:
+    case Xspring_pause:
+    case Xspring_e:
+    case Xspring_w:
+    case Xandroid:
+    case Xandroid_1_n:
+    case Xandroid_2_n:
+    case Xandroid_1_e:
+    case Xandroid_2_e:
+    case Xandroid_1_s:
+    case Xandroid_2_s:
+    case Xandroid_1_w:
+    case Xandroid_2_w:
+    case Xstone:
+    case Xstone_pause:
+    case Xemerald:
+    case Xemerald_pause:
+    case Xdiamond:
+    case Xdiamond_pause:
+    case Xbomb:
+    case Xbomb_pause:
+    case Xballoon:
+    case Xacid_ne:
+    case Xacid_nw:
+    case Xball_1:
+    case Xball_2:
+    case Xnut:
+    case Xnut_pause:
+    case Xslidewall_ns:
+    case Xslidewall_ew:
+    case Xkey_1:
+    case Xkey_2:
+    case Xkey_3:
+    case Xkey_4:
+    case Xkey_5:
+    case Xkey_6:
+    case Xkey_7:
+    case Xkey_8:
+    case Xbumper:
+    case Xswitch:
+    case Xlenses:
+    case Xmagnify:
+    case Xroundwall_1:
+    case Xroundwall_2:
+    case Xroundwall_3:
+    case Xroundwall_4:
+      if (RANDOM(2))
+      {
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
+	{
+	  Cave[x][y] = Ystone_eB;
+	  Cave[x+1][y] = Ystone_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xstone_pause;
+	  return;
+	}
 
-    case Xalien:
-    case Xalien_pause:
-      Cave[y][x] = Yspring_sB;
-      Cave[y+1][x] = Yalien_spring;
-      Next[y+1][x] = Znormal;
-      Boom[y][x-1] = Xblank;
-      Boom[y][x] = Xblank;
-      Boom[y][x+1] = Xblank;
-      Boom[y+1][x-1] = Xblank;
-      Boom[y+1][x] = Xblank;
-      Boom[y+1][x+1] = Xblank;
-      Boom[y+2][x-1] = Xblank;
-      Boom[y+2][x] = Xblank;
-      Boom[y+2][x+1] = Xblank;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xspring_fall);
-#endif
-      score += lev.alien_score;
-      return;
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
+	{
+	  Cave[x][y] = Ystone_wB;
+	  Cave[x-1][y] = Ystone_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xstone_pause;
+	  return;
+	}
+      }
+      else
+      {
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
+	{
+	  Cave[x][y] = Ystone_wB;
+	  Cave[x-1][y] = Ystone_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xstone_pause;
+	  return;
+	}
 
-    default:
-      Cave[y][x] = Xspring;
-      Next[y][x] = Xspring;
-      play_element_sound(x, y, SOUND_spring, Xspring);
-      return;
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
+	{
+	  Cave[x][y] = Ystone_eB;
+	  Cave[x+1][y] = Ystone_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xstone_pause;
+	  return;
+	}
+      }
   }
 }
 
-static void Leater_n(int x, int y)
+static void Lstone_pause(int x, int y)
 {
-  if (Cave[y][x+1] == Xdiamond)
-  {
-    Cave[y][x+1] = Ydiamond_blank;
-    Next[y][x+1] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
-    return;
-  }
-
-  if (Cave[y+1][x] == Xdiamond)
-  {
-    Cave[y+1][x] = Ydiamond_blank;
-    Next[y+1][x] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
-    return;
-  }
-
-  if (Cave[y][x-1] == Xdiamond)
-  {
-    Cave[y][x-1] = Ydiamond_blank;
-    Next[y][x-1] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
-    return;
-  }
-
-  if (Cave[y-1][x] == Xdiamond)
-  {
-    Cave[y-1][x] = Ydiamond_blank;
-    Next[y-1][x] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
-    return;
-  }
-
-  switch (Cave[y-1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3082,69 +2688,44 @@ static void Leater_n(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yeater_nB;
-      if (Cave[y-2][x+1] == Xblank)
-	Cave[y-2][x+1] = Xacid_splash_e;
-      if (Cave[y-2][x-1] == Xblank)
-	Cave[y-2][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ystone_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Zplayer:
-      Cave[y][x] = Yeater_nB;
-      Cave[y-1][x] = Yeater_n;
-      Next[y][x] = Xblank;
-      Next[y-1][x] = Xeater_n;
+#ifdef EM_ENGINE_USE_ADDITIONAL_ELEMENTS
+    case Xfake_acid_1:
+    case Xfake_acid_2:
+    case Xfake_acid_3:
+    case Xfake_acid_4:
+    case Xfake_acid_5:
+    case Xfake_acid_6:
+    case Xfake_acid_7:
+    case Xfake_acid_8:
+#endif
+      Cave[x][y] = Ystone_sB;
+      Cave[x][y+1] = Ystone_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xstone_fall;
       return;
 
     default:
-      Next[y][x] = RANDOM & 1 ? Xeater_e : Xeater_w;
-      play_element_sound(x, y, SOUND_eater, Xeater_n);
+      Cave[x][y] = Xstone;
+      Next[x][y] = Xstone;
       return;
   }
 }
 
-static void Leater_e(int x, int y)
+static void Lstone_fall(int x, int y)
 {
-  if (Cave[y+1][x] == Xdiamond)
-  {
-    Cave[y+1][x] = Ydiamond_blank;
-    Next[y+1][x] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
-    return;
-  }
-
-  if (Cave[y][x-1] == Xdiamond)
-  {
-    Cave[y][x-1] = Ydiamond_blank;
-    Next[y][x-1] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
-    return;
-  }
-
-  if (Cave[y-1][x] == Xdiamond)
-  {
-    Cave[y-1][x] = Ydiamond_blank;
-    Next[y-1][x] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
-    return;
-  }
-
-  if (Cave[y][x+1] == Xdiamond)
-  {
-    Cave[y][x+1] = Ydiamond_blank;
-    Next[y][x+1] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
-    return;
-  }
-
-  switch (Cave[y][x+1])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3154,69 +2735,285 @@ static void Leater_e(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yeater_eB;
-      if (Cave[y-1][x+2] == Xblank)
-	Cave[y-1][x+2] = Xacid_splash_e;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ystone_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
     case Zplayer:
-      Cave[y][x] = Yeater_eB;
-      Cave[y][x+1] = Yeater_e;
-      Next[y][x] = Xblank;
-      Next[y][x+1] = Xeater_e;
+#ifdef EM_ENGINE_USE_ADDITIONAL_ELEMENTS
+    case Xfake_acid_1:
+    case Xfake_acid_2:
+    case Xfake_acid_3:
+    case Xfake_acid_4:
+    case Xfake_acid_5:
+    case Xfake_acid_6:
+    case Xfake_acid_7:
+    case Xfake_acid_8:
+#endif
+      Cave[x][y] = Ystone_sB;
+      Cave[x][y+1] = Ystone_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xstone_fall;
       return;
 
-    default:
-      Next[y][x] = RANDOM & 1 ? Xeater_n : Xeater_s;
-      play_element_sound(x, y, SOUND_eater, Xeater_e);
+    case Xnut:
+    case Xnut_pause:
+      Cave[x][y+1] = Ynut_stone;
+      Next[x][y] = Xstone;
+      Next[x][y+1] = Xemerald;
+      play_element_sound(x, y, SOUND_crack, Xnut);
+      score += lev.nut_score;
       return;
-  }
-}
 
-static void Leater_s(int x, int y)
-{
-  if (Cave[y][x-1] == Xdiamond)
-  {
-    Cave[y][x-1] = Ydiamond_blank;
-    Next[y][x-1] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
-    return;
-  }
-
-  if (Cave[y-1][x] == Xdiamond)
-  {
-    Cave[y-1][x] = Ydiamond_blank;
-    Next[y-1][x] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
-    return;
-  }
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
+      Cave[x][y] = Ystone_sB;
+      Cave[x][y+1] = Ybug_stone;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = Xemerald;
+      Boom[x][y] = Xemerald;
+      Boom[x+1][y] = Xemerald;
+      Boom[x-1][y+1] = Xemerald;
+      Boom[x][y+1] = Xdiamond;
+      Boom[x+1][y+1] = Xemerald;
+      Boom[x-1][y+2] = Xemerald;
+      Boom[x][y+2] = Xemerald;
+      Boom[x+1][y+2] = Xemerald;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xstone_fall);
+#endif
+      score += lev.bug_score;
+      return;
 
-  if (Cave[y][x+1] == Xdiamond)
-  {
-    Cave[y][x+1] = Ydiamond_blank;
-    Next[y][x+1] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
-    return;
-  }
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
+      Cave[x][y] = Ystone_sB;
+      Cave[x][y+1] = Ytank_stone;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = Xblank;
+      Boom[x][y] = Xblank;
+      Boom[x+1][y] = Xblank;
+      Boom[x-1][y+1] = Xblank;
+      Boom[x][y+1] = Xblank;
+      Boom[x+1][y+1] = Xblank;
+      Boom[x-1][y+2] = Xblank;
+      Boom[x][y+2] = Xblank;
+      Boom[x+1][y+2] = Xblank;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xstone_fall);
+#endif
+      score += lev.tank_score;
+      return;
 
-  if (Cave[y+1][x] == Xdiamond)
-  {
-    Cave[y+1][x] = Ydiamond_blank;
-    Next[y+1][x] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
-    return;
+    case Xspring:
+      if (RANDOM(2))
+      {
+	switch (Cave[x+1][y+1])
+	{
+	  case Xblank:
+	  case Xacid_splash_e:
+	  case Xacid_splash_w:
+	  case Xalien:
+	  case Xalien_pause:
+	    Cave[x][y+1] = Xspring_e;
+	    break;
+
+	  default:
+	    Cave[x][y+1] = Xspring_w;
+	    break;
+	}
+      }
+      else
+      {
+	switch (Cave[x-1][y+1])
+	{
+	  case Xblank:
+	  case Xacid_splash_e:
+	  case Xacid_splash_w:
+	  case Xalien:
+	  case Xalien_pause:
+	    Cave[x][y+1] = Xspring_w;
+	    break;
+	  default:
+	    Cave[x][y+1] = Xspring_e;
+	    break;
+	}
+      }
+
+      Next[x][y] = Xstone;
+      return;
+
+    case Xeater_n:
+    case Xeater_e:
+    case Xeater_s:
+    case Xeater_w:
+      Cave[x][y] = Ystone_sB;
+      Cave[x][y+1] = Yeater_stone;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = lev.eater_array[lev.eater_pos][0];
+      Boom[x][y] = lev.eater_array[lev.eater_pos][1];
+      Boom[x+1][y] = lev.eater_array[lev.eater_pos][2];
+      Boom[x-1][y+1] = lev.eater_array[lev.eater_pos][3];
+      Boom[x][y+1] = lev.eater_array[lev.eater_pos][4];
+      Boom[x+1][y+1] = lev.eater_array[lev.eater_pos][5];
+      Boom[x-1][y+2] = lev.eater_array[lev.eater_pos][6];
+      Boom[x][y+2] = lev.eater_array[lev.eater_pos][7];
+      Boom[x+1][y+2] = lev.eater_array[lev.eater_pos][8];
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xstone_fall);
+#endif
+      lev.eater_pos = (lev.eater_pos + 1) & 7;
+      score += lev.eater_score;
+      return;
+
+    case Xalien:
+    case Xalien_pause:
+      Cave[x][y] = Ystone_sB;
+      Cave[x][y+1] = Yalien_stone;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = Xblank;
+      Boom[x][y] = Xblank;
+      Boom[x+1][y] = Xblank;
+      Boom[x-1][y+1] = Xblank;
+      Boom[x][y+1] = Xblank;
+      Boom[x+1][y+1] = Xblank;
+      Boom[x-1][y+2] = Xblank;
+      Boom[x][y+2] = Xblank;
+      Boom[x+1][y+2] = Xblank;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xstone_fall);
+#endif
+      score += lev.alien_score;
+      return;
+
+    case Xdiamond:
+    case Xdiamond_pause:
+      switch (Cave[x][y+2])
+      {
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	case Zplayer:
+	case Xbug_1_n:
+	case Xbug_1_e:
+	case Xbug_1_s:
+	case Xbug_1_w:
+	case Xbug_2_n:
+	case Xbug_2_e:
+	case Xbug_2_s:
+	case Xbug_2_w:
+	case Xtank_1_n:
+	case Xtank_1_e:
+	case Xtank_1_s:
+	case Xtank_1_w:
+	case Xtank_2_n:
+	case Xtank_2_e:
+	case Xtank_2_s:
+	case Xtank_2_w:
+	case Xspring_fall:
+	case Xandroid:
+	case Xandroid_1_n:
+	case Xandroid_2_n:
+	case Xandroid_1_e:
+	case Xandroid_2_e:
+	case Xandroid_1_s:
+	case Xandroid_2_s:
+	case Xandroid_1_w:
+	case Xandroid_2_w:
+	case Xstone_fall:
+	case Xemerald_fall:
+	case Xdiamond_fall:
+	case Xbomb_fall:
+	case Xacid_s:
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	case Xnut_fall:
+	case Xplant:
+	case Yplant:
+	  Next[x][y] = Xstone;
+	  play_element_sound(x, y, SOUND_stone, Xstone);
+	  return;
+      }
+
+      Cave[x][y] = Ystone_sB;
+      Cave[x][y+1] = Ydiamond_stone;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xstone_pause;
+      play_element_sound(x, y, SOUND_squash, Xdiamond);
+      return;
+
+    case Xbomb:
+    case Xbomb_pause:
+      Cave[x][y+1] = Ybomb_blank;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = Xblank;
+      Boom[x][y] = Xblank;
+      Boom[x+1][y] = Xblank;
+      Boom[x-1][y+1] = Xblank;
+      Boom[x][y+1] = Xblank;
+      Boom[x+1][y+1] = Xblank;
+      Boom[x-1][y+2] = Xblank;
+      Boom[x][y+2] = Xblank;
+      Boom[x+1][y+2] = Xblank;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xstone_fall);
+#endif
+      return;
+
+    case Xwonderwall:
+      if (lev.wonderwall_time)
+      {
+	lev.wonderwall_state = 1;
+	Cave[x][y] = Ystone_sB;
+
+	if (tab_blank[Cave[x][y+2]])
+	{
+	  Cave[x][y+2] = Yemerald_s;
+	  Next[x][y+2] = Xemerald_fall;
+	}
+
+	Next[x][y] = Xblank;
+	play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
+	return;
+      }
+
+    default:
+      Cave[x][y] = Xstone;
+      Next[x][y] = Xstone;
+      play_element_sound(x, y, SOUND_stone, Xstone);
+      return;
   }
+}
 
-  switch (Cave[y+1][x])
+static void Lbomb(int x, int y)
+{
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3226,69 +3023,114 @@ static void Leater_s(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yeater_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ybomb_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Zplayer:
-      Cave[y][x] = Yeater_sB;
-      Cave[y+1][x] = Yeater_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xeater_s;
-      return;
-
-    default:
-      Next[y][x] = RANDOM & 1 ? Xeater_e : Xeater_w;
-      play_element_sound(x, y, SOUND_eater, Xeater_s);
+      Cave[x][y] = Ybomb_sB;
+      Cave[x][y+1] = Ybomb_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xbomb_fall;
       return;
-  }
-}
-
-static void Leater_w(int x, int y)
-{
-  if (Cave[y-1][x] == Xdiamond)
-  {
-    Cave[y-1][x] = Ydiamond_blank;
-    Next[y-1][x] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
-    return;
-  }
 
-  if (Cave[y][x+1] == Xdiamond)
-  {
-    Cave[y][x+1] = Ydiamond_blank;
-    Next[y][x+1] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
-    return;
-  }
+    case Xspring:
+    case Xspring_pause:
+    case Xspring_e:
+    case Xspring_w:
+    case Xandroid:
+    case Xandroid_1_n:
+    case Xandroid_2_n:
+    case Xandroid_1_e:
+    case Xandroid_2_e:
+    case Xandroid_1_s:
+    case Xandroid_2_s:
+    case Xandroid_1_w:
+    case Xandroid_2_w:
+    case Xstone:
+    case Xstone_pause:
+    case Xemerald:
+    case Xemerald_pause:
+    case Xdiamond:
+    case Xdiamond_pause:
+    case Xbomb:
+    case Xbomb_pause:
+    case Xballoon:
+    case Xacid_ne:
+    case Xacid_nw:
+    case Xball_1:
+    case Xball_2:
+    case Xnut:
+    case Xnut_pause:
+    case Xslidewall_ns:
+    case Xslidewall_ew:
+    case Xkey_1:
+    case Xkey_2:
+    case Xkey_3:
+    case Xkey_4:
+    case Xkey_5:
+    case Xkey_6:
+    case Xkey_7:
+    case Xkey_8:
+    case Xbumper:
+    case Xswitch:
+    case Xroundwall_1:
+    case Xroundwall_2:
+    case Xroundwall_3:
+    case Xroundwall_4:
+      if (RANDOM(2))
+      {
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
+	{
+	  Cave[x][y] = Ybomb_eB;
+	  Cave[x+1][y] = Ybomb_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xbomb_pause;
+	  return;
+	}
 
-  if (Cave[y+1][x] == Xdiamond)
-  {
-    Cave[y+1][x] = Ydiamond_blank;
-    Next[y+1][x] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
-    return;
-  }
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
+	{
+	  Cave[x][y] = Ybomb_wB;
+	  Cave[x-1][y] = Ybomb_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xbomb_pause;
+	  return;
+	}
+      }
+      else
+      {
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
+	{
+	  Cave[x][y] = Ybomb_wB;
+	  Cave[x-1][y] = Ybomb_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xbomb_pause;
+	  return;
+	}
 
-  if (Cave[y][x-1] == Xdiamond)
-  {
-    Cave[y][x-1] = Ydiamond_blank;
-    Next[y][x-1] = Xblank;
-    play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
-    return;
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
+	{
+	  Cave[x][y] = Ybomb_eB;
+	  Cave[x+1][y] = Ybomb_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xbomb_pause;
+	  return;
+	}
+      }
   }
+}
 
-  switch (Cave[y][x-1])
+static void Lbomb_pause(int x, int y)
+{
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3298,204 +3140,83 @@ static void Leater_w(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yeater_wB;
-      if (Cave[y-1][x] == Xblank)
-	Cave[y-1][x] = Xacid_splash_e;
-      if (Cave[y-1][x-2] == Xblank)
-	Cave[y-1][x-2] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ybomb_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Zplayer:
-      Cave[y][x] = Yeater_wB;
-      Cave[y][x-1] = Yeater_w;
-      Next[y][x] = Xblank;
-      Next[y][x-1] = Xeater_w;
+      Cave[x][y] = Ybomb_sB;
+      Cave[x][y+1] = Ybomb_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xbomb_fall;
       return;
 
     default:
-      Next[y][x] = RANDOM & 1 ? Xeater_n : Xeater_s;
-      play_element_sound(x, y, SOUND_eater, Xeater_w);
+      Cave[x][y] = Xbomb;
+      Next[x][y] = Xbomb;
       return;
   }
 }
 
-static void Lalien(int x, int y)
+static void Lbomb_fall(int x, int y)
 {
-  int dx, dy;
-
-  if (lev.wheel_cnt)
-  {
-    dx = lev.wheel_x;
-    dy = lev.wheel_y;
-  }
-  else
+  switch (Cave[x][y+1])
   {
-    set_nearest_player_xy(x, y, &dx, &dy);
-  }
-
-  if (RANDOM & 1)
-  {
-    if (y > dy)
-    {
-      switch (Cave[y-1][x])
-      {
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	  Cave[y][x] = Yalien_nB;
-	  if (Cave[y-2][x+1] == Xblank)
-	    Cave[y-2][x+1] = Xacid_splash_e;
-	  if (Cave[y-2][x-1] == Xblank)
-	    Cave[y-2][x-1] = Xacid_splash_w;
-	  Next[y][x] = Xblank;
-	  play_element_sound(x, y, SOUND_acid, Xacid_1);
-	  return;
-
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	case Xplant:
-	case Yplant:
-	case Zplayer:
-	  Cave[y][x] = Yalien_nB;
-	  Cave[y-1][x] = Yalien_n;
-	  Next[y][x] = Xblank;
-	  Next[y-1][x] = Xalien_pause;
-	  play_element_sound(x, y, SOUND_alien, Xalien);
-	  return;
-      }
-    }
-    else if (y < dy)
-    {
-      switch (Cave[y+1][x])
-      {
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	  Cave[y][x] = Yalien_sB;
-	  Next[y][x] = Xblank;
-	  if (Cave[y][x+1] == Xblank)
-	    Cave[y][x+1] = Xacid_splash_e;
-	  if (Cave[y][x-1] == Xblank)
-	    Cave[y][x-1] = Xacid_splash_w;
-	  play_element_sound(x, y, SOUND_acid, Xacid_1);
-	  return;
-
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	case Xplant:
-	case Yplant:
-	case Zplayer:
-	  Cave[y][x] = Yalien_sB;
-	  Cave[y+1][x] = Yalien_s;
-	  Next[y][x] = Xblank;
-	  Next[y+1][x] = Xalien_pause;
-	  play_element_sound(x, y, SOUND_alien, Xalien);
-	  return;
-      }
-    }
-  }
-  else
-  {
-    if (x < dx)
-    {
-      switch (Cave[y][x+1])
-      {
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	  Cave[y][x] = Yalien_eB;
-	  if (Cave[y-1][x+2] == Xblank)
-	    Cave[y-1][x+2] = Xacid_splash_e;
-	  if (Cave[y-1][x] == Xblank)
-	    Cave[y-1][x] = Xacid_splash_w;
-	  Next[y][x] = Xblank;
-	  play_element_sound(x, y, SOUND_acid, Xacid_1);
-	  return;
+    case Xacid_1:
+    case Xacid_2:
+    case Xacid_3:
+    case Xacid_4:
+    case Xacid_5:
+    case Xacid_6:
+    case Xacid_7:
+    case Xacid_8:
+      Cave[x][y] = Ybomb_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
+      play_element_sound(x, y, SOUND_acid, Xacid_1);
+      return;
 
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	case Xplant:
-	case Yplant:
-	case Zplayer:
-	  Cave[y][x] = Yalien_eB;
-	  Cave[y][x+1] = Yalien_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xalien_pause;
-	  play_element_sound(x, y, SOUND_alien, Xalien);
-	  return;
-      }
-    }
-    else if (x > dx)
-    {
-      switch (Cave[y][x-1])
-      {
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	  Cave[y][x] = Yalien_wB;
-	  if (Cave[y-1][x] == Xblank)
-	    Cave[y-1][x] = Xacid_splash_e;
-	  if (Cave[y-1][x-2] == Xblank)
-	    Cave[y-1][x-2] = Xacid_splash_w;
-	  Next[y][x] = Xblank;
-	  play_element_sound(x, y, SOUND_acid, Xacid_1);
-	  return;
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+      Cave[x][y] = Ybomb_sB;
+      Cave[x][y+1] = Ybomb_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xbomb_fall;
+      return;
 
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	case Xplant:
-	case Yplant:
-	case Zplayer:
-	  Cave[y][x] = Yalien_wB;
-	  Cave[y][x-1] = Yalien_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xalien_pause;
-	  play_element_sound(x, y, SOUND_alien, Xalien);
-	  return;
-      }
-    }
+    default:
+      Cave[x][y] = Ybomb_blank;
+      Next[x][y] = Znormal;
+      Boom[x-1][y-1] = Xblank;
+      Boom[x][y-1] = Xblank;
+      Boom[x+1][y-1] = Xblank;
+      Boom[x-1][y] = Xblank;
+      Boom[x][y] = Xblank;
+      Boom[x+1][y] = Xblank;
+      Boom[x-1][y+1] = Xblank;
+      Boom[x][y+1] = Xblank;
+      Boom[x+1][y+1] = Xblank;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xbomb_fall);
+#endif
+      return;
   }
 }
 
-static void Lalien_pause(int x, int y)
-{
-  Next[y][x] = Xalien;
-}
-
-static void Lemerald(int x, int y)
+static void Lnut(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3505,22 +3226,22 @@ static void Lemerald(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yemerald_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ynut_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yemerald_sB;
-      Cave[y+1][x] = Yemerald_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xemerald_fall;
+      Cave[x][y] = Ynut_sB;
+      Cave[x][y+1] = Ynut_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xnut_fall;
       return;
 
     case Xspring:
@@ -3553,7 +3274,6 @@ static void Lemerald(int x, int y)
     case Xnut_pause:
     case Xslidewall_ns:
     case Xslidewall_ew:
-    case Xwonderwall:
     case Xkey_1:
     case Xkey_2:
     case Xkey_3:
@@ -3564,73 +3284,56 @@ static void Lemerald(int x, int y)
     case Xkey_8:
     case Xbumper:
     case Xswitch:
-    case Xsteel_1:
-    case Xsteel_2:
-    case Xsteel_3:
-    case Xsteel_4:
-    case Xwall_1:
-    case Xwall_2:
-    case Xwall_3:
-    case Xwall_4:
     case Xroundwall_1:
     case Xroundwall_2:
     case Xroundwall_3:
     case Xroundwall_4:
-      if (RANDOM & 1)
+      if (RANDOM(2))
       {
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
 	{
-	  Cave[y][x] = Yemerald_eB;
-	  Cave[y][x+1] = Yemerald_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xemerald_pause;
+	  Cave[x][y] = Ynut_eB;
+	  Cave[x+1][y] = Ynut_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xnut_pause;
 	  return;
 	}
 
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
 	{
-	  Cave[y][x] = Yemerald_wB;
-	  Cave[y][x-1] = Yemerald_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xemerald_pause;
+	  Cave[x][y] = Ynut_wB;
+	  Cave[x-1][y] = Ynut_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xnut_pause;
 	  return;
 	}
       }
       else
       {
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
 	{
-	  Cave[y][x] = Yemerald_wB;
-	  Cave[y][x-1] = Yemerald_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xemerald_pause;
+	  Cave[x][y] = Ynut_wB;
+	  Cave[x-1][y] = Ynut_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xnut_pause;
 	  return;
 	}
 
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
 	{
-	  Cave[y][x] = Yemerald_eB;
-	  Cave[y][x+1] = Yemerald_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xemerald_pause;
+	  Cave[x][y] = Ynut_eB;
+	  Cave[x+1][y] = Ynut_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xnut_pause;
 	  return;
 	}
       }
-
-    default:
-      if (++lev.shine_cnt > 50)
-      {
-	lev.shine_cnt = RANDOM & 7;
-	Cave[y][x] = Xemerald_shine;
-      }
-
-      return;
   }
 }
 
-static void Lemerald_pause(int x, int y)
+static void Lnut_pause(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3640,34 +3343,34 @@ static void Lemerald_pause(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yemerald_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ynut_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Yemerald_sB;
-      Cave[y+1][x] = Yemerald_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xemerald_fall;
+      Cave[x][y] = Ynut_sB;
+      Cave[x][y+1] = Ynut_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xnut_fall;
       return;
 
     default:
-      Cave[y][x] = Xemerald;
-      Next[y][x] = Xemerald;
+      Cave[x][y] = Xnut;
+      Next[x][y] = Xnut;
       return;
   }
 }
 
-static void Lemerald_fall(int x, int y)
+static void Lnut_fall(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3677,12 +3380,12 @@ static void Lemerald_fall(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Yemerald_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Ynut_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
@@ -3690,39 +3393,23 @@ static void Lemerald_fall(int x, int y)
     case Xacid_splash_e:
     case Xacid_splash_w:
     case Zplayer:
-      Cave[y][x] = Yemerald_sB;
-      Cave[y+1][x] = Yemerald_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xemerald_fall;
+      Cave[x][y] = Ynut_sB;
+      Cave[x][y+1] = Ynut_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xnut_fall;
       return;
 
-    case Xwonderwall:
-      if (lev.wonderwall_time)
-      {
-	lev.wonderwall_state = 1;
-	Cave[y][x] = Yemerald_sB;
-	if (tab_blank[Cave[y+2][x]])
-	{
-	  Cave[y+2][x] = Ydiamond_s;
-	  Next[y+2][x] = Xdiamond_fall;
-	}
-
-	Next[y][x] = Xblank;
-	play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
-	return;
-      }
-
     default:
-      Cave[y][x] = Xemerald;
-      Next[y][x] = Xemerald;
-      play_element_sound(x, y, SOUND_diamond, Xemerald);
+      Cave[x][y] = Xnut;
+      Next[x][y] = Xnut;
+      play_element_sound(x, y, SOUND_nut, Xnut);
       return;
   }
 }
 
-static void Ldiamond(int x, int y)
+static void Lspring(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3732,22 +3419,24 @@ static void Ldiamond(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ydiamond_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yspring_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Ydiamond_sB;
-      Cave[y+1][x] = Ydiamond_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xdiamond_fall;
+    case Xplant:
+    case Yplant:
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Yspring_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xspring_fall;
       return;
 
     case Xspring:
@@ -3780,7 +3469,6 @@ static void Ldiamond(int x, int y)
     case Xnut_pause:
     case Xslidewall_ns:
     case Xslidewall_ew:
-    case Xwonderwall:
     case Xkey_1:
     case Xkey_2:
     case Xkey_3:
@@ -3791,73 +3479,84 @@ static void Ldiamond(int x, int y)
     case Xkey_8:
     case Xbumper:
     case Xswitch:
-    case Xsteel_1:
-    case Xsteel_2:
-    case Xsteel_3:
-    case Xsteel_4:
-    case Xwall_1:
-    case Xwall_2:
-    case Xwall_3:
-    case Xwall_4:
     case Xroundwall_1:
     case Xroundwall_2:
     case Xroundwall_3:
     case Xroundwall_4:
-      if (RANDOM & 1)
+      if (RANDOM(2))
       {
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
 	{
-	  Cave[y][x] = Ydiamond_eB;
-	  Cave[y][x+1] = Ydiamond_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xdiamond_pause;
+	  Cave[x][y] = Yspring_eB;
+	  Cave[x+1][y] = Yspring_e;
+	  if (Cave[x][y+1] == Xbumper)
+	    Cave[x][y+1] = XbumperB;
+	  Next[x][y] = Xblank;
+
+#ifdef SPRING_ROLL
+	  Next[x+1][y] = Xspring_e;
+#else	
+	  Next[x+1][y] = Xspring_pause;
+#endif
 	  return;
 	}
 
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
 	{
-	  Cave[y][x] = Ydiamond_wB;
-	  Cave[y][x-1] = Ydiamond_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xdiamond_pause;
+	  Cave[x][y] = Yspring_wB;
+	  Cave[x-1][y] = Yspring_w;
+	  if (Cave[x][y+1] == Xbumper)
+	    Cave[x][y+1] = XbumperB;
+	  Next[x][y] = Xblank;
+
+#ifdef SPRING_ROLL
+	  Next[x-1][y] = Xspring_w;
+#else
+	  Next[x-1][y] = Xspring_pause;
+#endif
 	  return;
 	}
       }
       else
       {
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
+	if (tab_blank[Cave[x-1][y]] && tab_acid[Cave[x-1][y+1]])
 	{
-	  Cave[y][x] = Ydiamond_wB;
-	  Cave[y][x-1] = Ydiamond_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xdiamond_pause;
+	  Cave[x][y] = Yspring_wB;
+	  Cave[x-1][y] = Yspring_w;
+	  if (Cave[x][y+1] == Xbumper)
+	    Cave[x][y+1] = XbumperB;
+	  Next[x][y] = Xblank;
+
+#ifdef SPRING_ROLL
+	  Next[x-1][y] = Xspring_w;
+#else
+	  Next[x-1][y] = Xspring_pause;
+#endif
 	  return;
 	}
 
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
+	if (tab_blank[Cave[x+1][y]] && tab_acid[Cave[x+1][y+1]])
 	{
-	  Cave[y][x] = Ydiamond_eB;
-	  Cave[y][x+1] = Ydiamond_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xdiamond_pause;
+	  Cave[x][y] = Yspring_eB;
+	  Cave[x+1][y] = Yspring_e;
+	  if (Cave[x][y+1] == Xbumper)
+	    Cave[x][y+1] = XbumperB;
+	  Next[x][y] = Xblank;
+
+#ifdef SPRING_ROLL
+	  Next[x+1][y] = Xspring_e;
+#else
+	  Next[x+1][y] = Xspring_pause;
+#endif
 	  return;
 	}
       }
-
-    default:
-      if (++lev.shine_cnt > 50)
-      {
-	lev.shine_cnt = RANDOM & 7;
-	Cave[y][x] = Xdiamond_shine;
-      }
-
-      return;
   }
 }
 
-static void Ldiamond_pause(int x, int y)
+static void Lspring_pause(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3867,34 +3566,34 @@ static void Ldiamond_pause(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ydiamond_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yspring_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Ydiamond_sB;
-      Cave[y+1][x] = Ydiamond_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xdiamond_fall;
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Yspring_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xspring_fall;
       return;
 
     default:
-      Cave[y][x] = Xdiamond;
-      Next[y][x] = Xdiamond;
+      Cave[x][y] = Xspring;
+      Next[x][y] = Xspring;
       return;
   }
 }
 
-static void Ldiamond_fall(int x, int y)
+static void Lspring_e(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3904,54 +3603,92 @@ static void Ldiamond_fall(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ydiamond_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yspring_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Zplayer:
-      Cave[y][x] = Ydiamond_sB;
-      Cave[y+1][x] = Ydiamond_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xdiamond_fall;
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Yspring_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xspring_fall;
       return;
 
-    case Xwonderwall:
-      if (lev.wonderwall_time)
-      {
-	lev.wonderwall_state = 1;
-	Cave[y][x] = Ydiamond_sB;
-	if (tab_blank[Cave[y+2][x]])
-	{
-	  Cave[y+2][x] = Ystone_s;
-	  Next[y+2][x] = Xstone_fall;
-	}
+    case Xbumper:
+      Cave[x][y+1] = XbumperB;
+  }
 
-	Next[y][x] = Xblank;
-	play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
-	return;
-      }
+  switch (Cave[x+1][y])
+  {
+    case Xacid_1:
+    case Xacid_2:
+    case Xacid_3:
+    case Xacid_4:
+    case Xacid_5:
+    case Xacid_6:
+    case Xacid_7:
+    case Xacid_8:
+      Cave[x][y] = Yspring_eB;
+      if (Cave[x+2][y-1] == Xblank)
+	Cave[x+2][y-1] = Xacid_splash_e;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
+      play_element_sound(x, y, SOUND_acid, Xacid_1);
+      return;
+
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Yalien_nB:
+    case Yalien_eB:
+    case Yalien_sB:
+    case Yalien_wB:
+      Cave[x][y] = Yspring_eB;
+      Cave[x+1][y] = Yspring_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xspring_e;
+      return;
+
+    case Xalien:
+    case Xalien_pause:
+    case Yalien_n:
+    case Yalien_e:
+    case Yalien_s:
+    case Yalien_w:
+      Cave[x][y] = Yspring_alien_eB;
+      Cave[x+1][y] = Yspring_alien_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xspring_e;
+      play_element_sound(x, y, SOUND_slurp, Xalien);
+      score += lev.slurp_score;
+      return;
+
+    case Xbumper:
+    case XbumperB:
+      Cave[x+1][y] = XbumperB;
+      Next[x][y] = Xspring_w;
+      play_element_sound(x, y, SOUND_spring, Xspring);
+      return;
 
     default:
-      Cave[y][x] = Xdiamond;
-      Next[y][x] = Xdiamond;
-      play_element_sound(x, y, SOUND_diamond, Xdiamond);
+      Cave[x][y] = Xspring;
+      Next[x][y] = Xspring;
+      play_element_sound(x, y, SOUND_spring, Xspring);
       return;
   }
 }
 
-static void Ldrip_fall(int x, int y)
+static void Lspring_w(int x, int y)
 {
-  int temp;
-
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -3961,90 +3698,29 @@ static void Ldrip_fall(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ydrip_1_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xdrip_stretchB;
+      Cave[x][y] = Yspring_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-    case Xplant:
-    case Yplant:
-    case Zplayer:
-      Cave[y][x] = Ydrip_1_sB;
-      Cave[y+1][x] = Ydrip_1_s;
-      Next[y][x] = Xdrip_stretchB;
-      Next[y+1][x] = Xdrip_stretch;
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Yspring_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xspring_fall;
       return;
 
-    default:
-      switch (RANDOM & 7)
-      {
-	case 0:
-	  temp = Xamoeba_1;
-	  break;
-
-	case 1:
-	  temp = Xamoeba_2;
-	  break;
-
-	case 2:
-	  temp = Xamoeba_3;
-	  break;
-
-	case 3:
-	  temp = Xamoeba_4;
-	  break;
-
-	case 4:
-	  temp = Xamoeba_5;
-	  break;
-
-	case 5:
-	  temp = Xamoeba_6;
-	  break;
-
-	case 6:
-	  temp = Xamoeba_7;
-	  break;
-
-	case 7:
-	  temp = Xamoeba_8;
-	  break;
-      }
-
-      Cave[y][x] = temp;
-      Next[y][x] = temp;
-      play_element_sound(x, y, SOUND_drip, Xdrip_fall);
-      return;
+    case Xbumper:
+      Cave[x][y+1] = XbumperB;
   }
-}
-
-static void Ldrip_stretch(int x, int y)
-{
-  Cave[y][x] = Ydrip_2_s;
-  Next[y][x] = Xdrip_fall;
-}
-
-static void Ldrip_stretchB(int x, int y)
-{
-  Cave[y][x] = Ydrip_2_sB;
-  Next[y][x] = Xblank;
-}
-
-static void Ldrip(int x, int y)
-{
-  Next[y][x] = Xdrip_fall;
-}
 
-static void Lbomb(int x, int y)
-{
-  switch (Cave[y+1][x])
+  switch (Cave[x-1][y])
   {
     case Xacid_1:
     case Xacid_2:
@@ -4054,114 +3730,60 @@ static void Lbomb(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ybomb_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yspring_wB;
+      if (Cave[x][y-1] == Xblank)
+	Cave[x][y-1] = Xacid_splash_e;
+      if (Cave[x-2][y-1] == Xblank)
+	Cave[x-2][y-1] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Ybomb_sB;
-      Cave[y+1][x] = Ybomb_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xbomb_fall;
+    case Yalien_nB:
+    case Yalien_eB:
+    case Yalien_sB:
+    case Yalien_wB:
+      Cave[x][y] = Yspring_wB;
+      Cave[x-1][y] = Yspring_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xspring_w;
       return;
 
-    case Xspring:
-    case Xspring_pause:
-    case Xspring_e:
-    case Xspring_w:
-    case Xandroid:
-    case Xandroid_1_n:
-    case Xandroid_2_n:
-    case Xandroid_1_e:
-    case Xandroid_2_e:
-    case Xandroid_1_s:
-    case Xandroid_2_s:
-    case Xandroid_1_w:
-    case Xandroid_2_w:
-    case Xstone:
-    case Xstone_pause:
-    case Xemerald:
-    case Xemerald_pause:
-    case Xdiamond:
-    case Xdiamond_pause:
-    case Xbomb:
-    case Xbomb_pause:
-    case Xballoon:
-    case Xacid_ne:
-    case Xacid_nw:
-    case Xball_1:
-    case Xball_2:
-    case Xnut:
-    case Xnut_pause:
-    case Xslidewall_ns:
-    case Xslidewall_ew:
-    case Xkey_1:
-    case Xkey_2:
-    case Xkey_3:
-    case Xkey_4:
-    case Xkey_5:
-    case Xkey_6:
-    case Xkey_7:
-    case Xkey_8:
-    case Xbumper:
-    case Xswitch:
-    case Xroundwall_1:
-    case Xroundwall_2:
-    case Xroundwall_3:
-    case Xroundwall_4:
-      if (RANDOM & 1)
-      {
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
-	{
-	  Cave[y][x] = Ybomb_eB;
-	  Cave[y][x+1] = Ybomb_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xbomb_pause;
-	  return;
-	}
+    case Xalien:
+    case Xalien_pause:
+    case Yalien_n:
+    case Yalien_e:
+    case Yalien_s:
+    case Yalien_w:
+      Cave[x][y] = Yspring_alien_wB;
+      Cave[x-1][y] = Yspring_alien_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xspring_w;
+      play_element_sound(x, y, SOUND_slurp, Xalien);
+      score += lev.slurp_score;
+      return;
 
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
-	{
-	  Cave[y][x] = Ybomb_wB;
-	  Cave[y][x-1] = Ybomb_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xbomb_pause;
-	  return;
-	}
-      }
-      else
-      {
-	if (tab_blank[Cave[y][x-1]] && tab_acid[Cave[y+1][x-1]])
-	{
-	  Cave[y][x] = Ybomb_wB;
-	  Cave[y][x-1] = Ybomb_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xbomb_pause;
-	  return;
-	}
+    case Xbumper:
+    case XbumperB:
+      Cave[x-1][y] = XbumperB;
+      Next[x][y] = Xspring_e;
+      play_element_sound(x, y, SOUND_spring, Xspring);
+      return;
 
-	if (tab_blank[Cave[y][x+1]] && tab_acid[Cave[y+1][x+1]])
-	{
-	  Cave[y][x] = Ybomb_eB;
-	  Cave[y][x+1] = Ybomb_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xbomb_pause;
-	  return;
-	}
-      }
+    default:
+      Cave[x][y] = Xspring;
+      Next[x][y] = Xspring;
+      play_element_sound(x, y, SOUND_spring, Xspring);
+      return;
   }
 }
 
-static void Lbomb_pause(int x, int y)
+static void Lspring_fall(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x][y+1])
   {
     case Xacid_1:
     case Xacid_2:
@@ -4171,370 +3793,737 @@ static void Lbomb_pause(int x, int y)
     case Xacid_6:
     case Xacid_7:
     case Xacid_8:
-      Cave[y][x] = Ybomb_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
+      Cave[x][y] = Yspring_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xblank;
       play_element_sound(x, y, SOUND_acid, Xacid_1);
       return;
 
     case Xblank:
     case Xacid_splash_e:
     case Xacid_splash_w:
-      Cave[y][x] = Ybomb_sB;
-      Cave[y+1][x] = Ybomb_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xbomb_fall;
+    case Zplayer:
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Yspring_s;
+      Next[x][y] = Xblank;
+      Next[x][y+1] = Xspring_fall;
+      return;
+
+    case Xbomb:
+    case Xbomb_pause:
+      Cave[x][y+1] = Ybomb_blank;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = Xblank;
+      Boom[x][y] = Xblank;
+      Boom[x+1][y] = Xblank;
+      Boom[x-1][y+1] = Xblank;
+      Boom[x][y+1] = Xblank;
+      Boom[x+1][y+1] = Xblank;
+      Boom[x-1][y+2] = Xblank;
+      Boom[x][y+2] = Xblank;
+      Boom[x+1][y+2] = Xblank;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xspring_fall);
+#endif
+      return;
+
+    case Xbug_1_n:
+    case Xbug_1_e:
+    case Xbug_1_s:
+    case Xbug_1_w:
+    case Xbug_2_n:
+    case Xbug_2_e:
+    case Xbug_2_s:
+    case Xbug_2_w:
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Ybug_spring;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = Xemerald;
+      Boom[x][y] = Xemerald;
+      Boom[x+1][y] = Xemerald;
+      Boom[x-1][y+1] = Xemerald;
+      Boom[x][y+1] = Xdiamond;
+      Boom[x+1][y+1] = Xemerald;
+      Boom[x-1][y+2] = Xemerald;
+      Boom[x][y+2] = Xemerald;
+      Boom[x+1][y+2] = Xemerald;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xspring_fall);
+#endif
+      score += lev.bug_score;
+      return;
+
+    case Xtank_1_n:
+    case Xtank_1_e:
+    case Xtank_1_s:
+    case Xtank_1_w:
+    case Xtank_2_n:
+    case Xtank_2_e:
+    case Xtank_2_s:
+    case Xtank_2_w:
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Ytank_spring;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = Xblank;
+      Boom[x][y] = Xblank;
+      Boom[x+1][y] = Xblank;
+      Boom[x-1][y+1] = Xblank;
+      Boom[x][y+1] = Xblank;
+      Boom[x+1][y+1] = Xblank;
+      Boom[x-1][y+2] = Xblank;
+      Boom[x][y+2] = Xblank;
+      Boom[x+1][y+2] = Xblank;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xspring_fall);
+#endif
+      score += lev.tank_score;
+      return;
+
+    case Xeater_n:
+    case Xeater_e:
+    case Xeater_s:
+    case Xeater_w:
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Yeater_spring;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = lev.eater_array[lev.eater_pos][0];
+      Boom[x][y] = lev.eater_array[lev.eater_pos][1];
+      Boom[x+1][y] = lev.eater_array[lev.eater_pos][2];
+      Boom[x-1][y+1] = lev.eater_array[lev.eater_pos][3];
+      Boom[x][y+1] = lev.eater_array[lev.eater_pos][4];
+      Boom[x+1][y+1] = lev.eater_array[lev.eater_pos][5];
+      Boom[x-1][y+2] = lev.eater_array[lev.eater_pos][6];
+      Boom[x][y+2] = lev.eater_array[lev.eater_pos][7];
+      Boom[x+1][y+2] = lev.eater_array[lev.eater_pos][8];
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xspring_fall);
+#endif
+      lev.eater_pos = (lev.eater_pos + 1) & 7;
+      score += lev.eater_score;
+      return;
+
+    case Xalien:
+    case Xalien_pause:
+      Cave[x][y] = Yspring_sB;
+      Cave[x][y+1] = Yalien_spring;
+      Next[x][y+1] = Znormal;
+      Boom[x-1][y] = Xblank;
+      Boom[x][y] = Xblank;
+      Boom[x+1][y] = Xblank;
+      Boom[x-1][y+1] = Xblank;
+      Boom[x][y+1] = Xblank;
+      Boom[x+1][y+1] = Xblank;
+      Boom[x-1][y+2] = Xblank;
+      Boom[x][y+2] = Xblank;
+      Boom[x+1][y+2] = Xblank;
+#if PLAY_ELEMENT_SOUND
+      play_element_sound(x, y, SOUND_boom, Xspring_fall);
+#endif
+      score += lev.alien_score;
       return;
 
     default:
-      Cave[y][x] = Xbomb;
-      Next[y][x] = Xbomb;
+      Cave[x][y] = Xspring;
+      Next[x][y] = Xspring;
+      play_element_sound(x, y, SOUND_spring, Xspring);
       return;
   }
 }
 
-static void Lbomb_fall(int x, int y)
+static void Lpush_emerald_e(int x, int y)
 {
-  switch (Cave[y+1][x])
+  switch (Cave[x+1][y])
   {
-    case Xacid_1:
-    case Xacid_2:
-    case Xacid_3:
-    case Xacid_4:
-    case Xacid_5:
-    case Xacid_6:
-    case Xacid_7:
-    case Xacid_8:
-      Cave[y][x] = Ybomb_sB;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xblank;
-      play_element_sound(x, y, SOUND_acid, Xacid_1);
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xemerald;
+      Next[x][y] = Xemerald;
       return;
 
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-      Cave[y][x] = Ybomb_sB;
-      Cave[y+1][x] = Ybomb_s;
-      Next[y][x] = Xblank;
-      Next[y+1][x] = Xbomb_fall;
+    default:
+      Cave[x][y] = Yemerald_eB;
+      Cave[x+1][y] = Yemerald_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xemerald_pause;
+      return;
+  }
+}
+
+static void Lpush_emerald_w(int x, int y)
+{
+  switch (Cave[x-1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xemerald;
+      Next[x][y] = Xemerald;
       return;
 
     default:
-      Cave[y][x] = Ybomb_blank;
-      Next[y][x] = Znormal;
-      Boom[y-1][x-1] = Xblank;
-      Boom[y-1][x] = Xblank;
-      Boom[y-1][x+1] = Xblank;
-      Boom[y][x-1] = Xblank;
-      Boom[y][x] = Xblank;
-      Boom[y][x+1] = Xblank;
-      Boom[y+1][x-1] = Xblank;
-      Boom[y+1][x] = Xblank;
-      Boom[y+1][x+1] = Xblank;
-#if PLAY_ELEMENT_SOUND
-      play_element_sound(x, y, SOUND_boom, Xbomb_fall);
-#endif
+      Cave[x][y] = Yemerald_wB;
+      Cave[x-1][y] = Yemerald_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xemerald_pause;
       return;
   }
 }
 
-static void Lballoon(int x, int y)
+static void Lpush_diamond_e(int x, int y)
 {
-  if (lev.wind_cnt == 0)
-    return;
-
-  switch (lev.wind_direction)
+  switch (Cave[x+1][y])
   {
-    case 0: /* north */
-      switch (Cave[y-1][x])
-      {
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	  Cave[y][x] = Yballoon_nB;
-	  if (Cave[y-2][x+1] == Xblank)
-	    Cave[y-2][x+1] = Xacid_splash_e;
-	  if (Cave[y-2][x-1] == Xblank)
-	    Cave[y-2][x-1] = Xacid_splash_w;
-	  Next[y][x] = Xblank;
-	  play_element_sound(x, y, SOUND_acid, Xacid_1);
-	  return;
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xdiamond;
+      Next[x][y] = Xdiamond;
+      return;
 
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	  Cave[y][x] = Yballoon_nB;
-	  Cave[y-1][x] = Yballoon_n;
-	  Next[y][x] = Xblank;
-	  Next[y-1][x] = Xballoon;
-	  return;
-      }
-      break;
+    default:
+      Cave[x][y] = Ydiamond_eB;
+      Cave[x+1][y] = Ydiamond_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xdiamond_pause;
+      return;
+  }
+}
 
-    case 1: /* east */
-      switch (Cave[y][x+1])
-      {
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	  Cave[y][x] = Yballoon_eB;
-	  if (Cave[y-1][x+2] == Xblank)
-	    Cave[y-1][x+2] = Xacid_splash_e;
-	  if (Cave[y-1][x] == Xblank)
-	    Cave[y-1][x] = Xacid_splash_w;
-	  Next[y][x] = Xblank;
-	  play_element_sound(x, y, SOUND_acid, Xacid_1);
-	  return;
+static void Lpush_diamond_w(int x, int y)
+{
+  switch (Cave[x-1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xdiamond;
+      Next[x][y] = Xdiamond;
+      return;
 
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	  Cave[y][x] = Yballoon_eB;
-	  Cave[y][x+1] = Yballoon_e;
-	  Next[y][x] = Xblank;
-	  Next[y][x+1] = Xballoon;
-	  return;
-      }
-      break;
+    default:
+      Cave[x][y] = Ydiamond_wB;
+      Cave[x-1][y] = Ydiamond_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xdiamond_pause;
+      return;
+  }
+}
 
-    case 2: /* south */
-      switch (Cave[y+1][x])
-      {
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	  Cave[y][x] = Yballoon_sB;
-	  if (Cave[y][x+1] == Xblank)
-	    Cave[y][x+1] = Xacid_splash_e;
-	  if (Cave[y][x-1] == Xblank)
-	    Cave[y][x-1] = Xacid_splash_w;
-	  Next[y][x] = Xblank;
-	  play_element_sound(x, y, SOUND_acid, Xacid_1);
-	  return;
+static void Lpush_stone_e(int x, int y)
+{
+  switch (Cave[x+1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xstone;
+      Next[x][y] = Xstone;
+      return;
 
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	  Cave[y][x] = Yballoon_sB;
-	  Cave[y+1][x] = Yballoon_s;
-	  Next[y][x] = Xblank;
-	  Next[y+1][x] = Xballoon;
-	  return;
-      }
-      break;
+    default:
+      Cave[x][y] = Ystone_eB;
+      Cave[x+1][y] = Ystone_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xstone_pause;
+      return;
+  }
+}
 
-    case 3: /* west */
-      switch (Cave[y][x-1])
-      {
-	case Xacid_1:
-	case Xacid_2:
-	case Xacid_3:
-	case Xacid_4:
-	case Xacid_5:
-	case Xacid_6:
-	case Xacid_7:
-	case Xacid_8:
-	  Cave[y][x] = Yballoon_wB;
-	  if (Cave[y-1][x] == Xblank)
-	    Cave[y-1][x] = Xacid_splash_e;
-	  if (Cave[y-1][x-2] == Xblank)
-	    Cave[y-1][x-2] = Xacid_splash_w;
-	  Next[y][x] = Xblank;
-	  play_element_sound(x, y, SOUND_acid, Xacid_1);
-	  return;
+static void Lpush_stone_w(int x, int y)
+{
+  switch (Cave[x-1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xstone;
+      Next[x][y] = Xstone;
+      return;
 
-	case Xblank:
-	case Xacid_splash_e:
-	case Xacid_splash_w:
-	  Cave[y][x] = Yballoon_wB;
-	  Cave[y][x-1] = Yballoon_w;
-	  Next[y][x] = Xblank;
-	  Next[y][x-1] = Xballoon;
-	  return;
-      }
-      break;
+    default:
+      Cave[x][y] = Ystone_wB;
+      Cave[x-1][y] = Ystone_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xstone_pause;
+      return;
   }
 }
 
-static void Lacid_1(int x, int y)
+static void Lpush_bomb_e(int x, int y)
 {
-  Next[y][x] = Xacid_2;
+  switch (Cave[x+1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xbomb;
+      Next[x][y] = Xbomb;
+      return;
+
+    default:
+      Cave[x][y] = Ybomb_eB;
+      Cave[x+1][y] = Ybomb_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xbomb_pause;
+      return;
+  }
 }
 
-static void Lacid_2(int x, int y)
+static void Lpush_bomb_w(int x, int y)
 {
-  Next[y][x] = Xacid_3;
+  switch (Cave[x-1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xbomb;
+      Next[x][y] = Xbomb;
+      return;
+
+    default:
+      Cave[x][y] = Ybomb_wB;
+      Cave[x-1][y] = Ybomb_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xbomb_pause;
+      return;
+  }
 }
 
-static void Lacid_3(int x, int y)
+static void Lpush_nut_e(int x, int y)
 {
-  Next[y][x] = Xacid_4;
+  switch (Cave[x+1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xnut;
+      Next[x][y] = Xnut;
+      return;
+
+    default:
+      Cave[x][y] = Ynut_eB;
+      Cave[x+1][y] = Ynut_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xnut_pause;
+      return;
+  }
 }
 
-static void Lacid_4(int x, int y)
+static void Lpush_nut_w(int x, int y)
 {
-  Next[y][x] = Xacid_5;
+  switch (Cave[x-1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xnut;
+      Next[x][y] = Xnut;
+      return;
+
+    default:
+      Cave[x][y] = Ynut_wB;
+      Cave[x-1][y] = Ynut_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xnut_pause;
+      return;
+  }
 }
 
-static void Lacid_5(int x, int y)
+static void Lpush_spring_e(int x, int y)
 {
-  Next[y][x] = Xacid_6;
+  switch (Cave[x+1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xspring;
+      Next[x][y] = Xspring;
+      return;
+
+    default:
+      Cave[x][y] = Yspring_eB;
+      Cave[x+1][y] = Yspring_e;
+      Next[x][y] = Xblank;
+      Next[x+1][y] = Xspring_e;
+      return;
+  }
 }
 
-static void Lacid_6(int x, int y)
+static void Lpush_spring_w(int x, int y)
 {
-  Next[y][x] = Xacid_7;
+  switch (Cave[x-1][y])
+  {
+    case Zborder:
+    case Znormal:
+    case Zdynamite:
+    case Xboom_bug:
+    case Xboom_bomb:
+    case Xboom_android:
+    case Xboom_1:
+    case Zplayer:
+      Cave[x][y] = Xspring;
+      Next[x][y] = Xspring;
+      return;
+
+    default:
+      Cave[x][y] = Yspring_wB;
+      Cave[x-1][y] = Yspring_w;
+      Next[x][y] = Xblank;
+      Next[x-1][y] = Xspring_w;
+      return;
+  }
 }
 
-static void Lacid_7(int x, int y)
+static void Ldynamite_1(int x, int y)
 {
-  Next[y][x] = Xacid_8;
+  play_element_sound(x, y, SOUND_tick, Xdynamite_1);
+  Next[x][y] = Xdynamite_2;
 }
 
-static void Lacid_8(int x, int y)
+static void Ldynamite_2(int x, int y)
 {
-  Next[y][x] = Xacid_1;
+  play_element_sound(x, y, SOUND_tick, Xdynamite_2);
+  Next[x][y] = Xdynamite_3;
 }
 
-static void Lfake_acid_1(int x, int y)
+static void Ldynamite_3(int x, int y)
 {
-  Next[y][x] = Xfake_acid_2;
+  play_element_sound(x, y, SOUND_tick, Xdynamite_3);
+  Next[x][y] = Xdynamite_4;
 }
 
-static void Lfake_acid_2(int x, int y)
+static void Ldynamite_4(int x, int y)
 {
-  Next[y][x] = Xfake_acid_3;
+  play_element_sound(x, y, SOUND_tick, Xdynamite_4);
+  Next[x][y] = Zdynamite;
+  Boom[x-1][y-1] = Xblank;
+  Boom[x][y-1] = Xblank;
+  Boom[x+1][y-1] = Xblank;
+  Boom[x-1][y] = Xblank;
+  Boom[x][y] = Xblank;
+  Boom[x+1][y] = Xblank;
+  Boom[x-1][y+1] = Xblank;
+  Boom[x][y+1] = Xblank;
+  Boom[x+1][y+1] = Xblank;
 }
 
-static void Lfake_acid_3(int x, int y)
+static void Lfake_door_1(int x, int y)
 {
-  Next[y][x] = Xfake_acid_4;
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xdoor_1;
 }
 
-static void Lfake_acid_4(int x, int y)
+static void Lfake_door_2(int x, int y)
 {
-  Next[y][x] = Xfake_acid_5;
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xdoor_2;
 }
 
-static void Lfake_acid_5(int x, int y)
+static void Lfake_door_3(int x, int y)
 {
-  Next[y][x] = Xfake_acid_6;
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xdoor_3;
 }
 
-static void Lfake_acid_6(int x, int y)
+static void Lfake_door_4(int x, int y)
 {
-  Next[y][x] = Xfake_acid_7;
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xdoor_4;
 }
 
-static void Lfake_acid_7(int x, int y)
+static void Lfake_door_5(int x, int y)
 {
-  Next[y][x] = Xfake_acid_8;
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xdoor_5;
 }
 
-static void Lfake_acid_8(int x, int y)
+static void Lfake_door_6(int x, int y)
 {
-  Next[y][x] = Xfake_acid_1;
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xdoor_6;
 }
 
-static void Lball_common(int x, int y)
+static void Lfake_door_7(int x, int y)
 {
-  play_element_sound(x, y, SOUND_ball, Xball_1);
-
-  if (lev.ball_random)
-  {
-    switch (RANDOM & 7)
-    {
-      case 0:
-	if (lev.ball_array[lev.ball_pos][0] != Xblank &&
-	    tab_blank[Cave[y-1][x-1]])
-	{
-	  Cave[y-1][x-1] = Yball_blank;
-	  Next[y-1][x-1] = lev.ball_array[lev.ball_pos][0];
-	}
-	break;
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xdoor_7;
+}
 
-      case 1:
-	if (lev.ball_array[lev.ball_pos][1] != Xblank &&
-	    tab_blank[Cave[y-1][x]])
-	{
-	  Cave[y-1][x] = Yball_blank;
-	  Next[y-1][x] = lev.ball_array[lev.ball_pos][1];
-	}
-	break;
+static void Lfake_door_8(int x, int y)
+{
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xdoor_8;
+}
 
-      case 2:
-	if (lev.ball_array[lev.ball_pos][2] != Xblank &&
-	    tab_blank[Cave[y-1][x+1]])
-	{
-	  Cave[y-1][x+1] = Yball_blank;
-	  Next[y-1][x+1] = lev.ball_array[lev.ball_pos][2];
-	}
-	break;
+static void Lballoon(int x, int y)
+{
+  if (lev.wind_cnt == 0)
+    return;
 
-      case 3:
-	if (lev.ball_array[lev.ball_pos][3] != Xblank &&
-	    tab_blank[Cave[y][x-1]])
+  switch (lev.wind_direction)
+  {
+    case 0: /* north */
+      switch (Cave[x][y-1])
+      {
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	  Cave[x][y] = Yballoon_nB;
+	  if (Cave[x+1][y-2] == Xblank)
+	    Cave[x+1][y-2] = Xacid_splash_e;
+	  if (Cave[x-1][y-2] == Xblank)
+	    Cave[x-1][y-2] = Xacid_splash_w;
+	  Next[x][y] = Xblank;
+	  play_element_sound(x, y, SOUND_acid, Xacid_1);
+	  return;
+
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	  Cave[x][y] = Yballoon_nB;
+	  Cave[x][y-1] = Yballoon_n;
+	  Next[x][y] = Xblank;
+	  Next[x][y-1] = Xballoon;
+	  return;
+      }
+      break;
+
+    case 1: /* east */
+      switch (Cave[x+1][y])
+      {
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	  Cave[x][y] = Yballoon_eB;
+	  if (Cave[x+2][y-1] == Xblank)
+	    Cave[x+2][y-1] = Xacid_splash_e;
+	  if (Cave[x][y-1] == Xblank)
+	    Cave[x][y-1] = Xacid_splash_w;
+	  Next[x][y] = Xblank;
+	  play_element_sound(x, y, SOUND_acid, Xacid_1);
+	  return;
+
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	  Cave[x][y] = Yballoon_eB;
+	  Cave[x+1][y] = Yballoon_e;
+	  Next[x][y] = Xblank;
+	  Next[x+1][y] = Xballoon;
+	  return;
+      }
+      break;
+
+    case 2: /* south */
+      switch (Cave[x][y+1])
+      {
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	  Cave[x][y] = Yballoon_sB;
+	  if (Cave[x+1][y] == Xblank)
+	    Cave[x+1][y] = Xacid_splash_e;
+	  if (Cave[x-1][y] == Xblank)
+	    Cave[x-1][y] = Xacid_splash_w;
+	  Next[x][y] = Xblank;
+	  play_element_sound(x, y, SOUND_acid, Xacid_1);
+	  return;
+
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	  Cave[x][y] = Yballoon_sB;
+	  Cave[x][y+1] = Yballoon_s;
+	  Next[x][y] = Xblank;
+	  Next[x][y+1] = Xballoon;
+	  return;
+      }
+      break;
+
+    case 3: /* west */
+      switch (Cave[x-1][y])
+      {
+	case Xacid_1:
+	case Xacid_2:
+	case Xacid_3:
+	case Xacid_4:
+	case Xacid_5:
+	case Xacid_6:
+	case Xacid_7:
+	case Xacid_8:
+	  Cave[x][y] = Yballoon_wB;
+	  if (Cave[x][y-1] == Xblank)
+	    Cave[x][y-1] = Xacid_splash_e;
+	  if (Cave[x-2][y-1] == Xblank)
+	    Cave[x-2][y-1] = Xacid_splash_w;
+	  Next[x][y] = Xblank;
+	  play_element_sound(x, y, SOUND_acid, Xacid_1);
+	  return;
+
+	case Xblank:
+	case Xacid_splash_e:
+	case Xacid_splash_w:
+	  Cave[x][y] = Yballoon_wB;
+	  Cave[x-1][y] = Yballoon_w;
+	  Next[x][y] = Xblank;
+	  Next[x-1][y] = Xballoon;
+	  return;
+      }
+      break;
+  }
+}
+
+static void Lball_common(int x, int y)
+{
+  play_element_sound(x, y, SOUND_ball, Xball_1);
+
+  if (lev.ball_random)
+  {
+    switch (RANDOM(8))
+    {
+      case 0:
+	if (lev.ball_array[lev.ball_pos][0] != Xblank &&
+	    tab_blank[Cave[x-1][y-1]])
+	{
+	  Cave[x-1][y-1] = Yball_blank;
+	  Next[x-1][y-1] = lev.ball_array[lev.ball_pos][0];
+	}
+	break;
+
+      case 1:
+	if (lev.ball_array[lev.ball_pos][1] != Xblank &&
+	    tab_blank[Cave[x][y-1]])
+	{
+	  Cave[x][y-1] = Yball_blank;
+	  Next[x][y-1] = lev.ball_array[lev.ball_pos][1];
+	}
+	break;
+
+      case 2:
+	if (lev.ball_array[lev.ball_pos][2] != Xblank &&
+	    tab_blank[Cave[x+1][y-1]])
+	{
+	  Cave[x+1][y-1] = Yball_blank;
+	  Next[x+1][y-1] = lev.ball_array[lev.ball_pos][2];
+	}
+	break;
+
+      case 3:
+	if (lev.ball_array[lev.ball_pos][3] != Xblank &&
+	    tab_blank[Cave[x-1][y]])
 	{
-	  Cave[y][x-1] = Yball_blank;
-	  Next[y][x-1] = lev.ball_array[lev.ball_pos][3];
+	  Cave[x-1][y] = Yball_blank;
+	  Next[x-1][y] = lev.ball_array[lev.ball_pos][3];
 	}
 	break;
 
       case 4:
 	if (lev.ball_array[lev.ball_pos][4] != Xblank &&
-	    tab_blank[Cave[y][x+1]])
+	    tab_blank[Cave[x+1][y]])
 	{
-	  Cave[y][x+1] = Yball_blank;
-	  Next[y][x+1] = lev.ball_array[lev.ball_pos][4];
+	  Cave[x+1][y] = Yball_blank;
+	  Next[x+1][y] = lev.ball_array[lev.ball_pos][4];
 	}
 	break;
 
       case 5:
 	if (lev.ball_array[lev.ball_pos][5] != Xblank &&
-	    tab_blank[Cave[y+1][x-1]])
+	    tab_blank[Cave[x-1][y+1]])
 	{
-	  Cave[y+1][x-1] = Yball_blank;
-	  Next[y+1][x-1] = lev.ball_array[lev.ball_pos][5];
+	  Cave[x-1][y+1] = Yball_blank;
+	  Next[x-1][y+1] = lev.ball_array[lev.ball_pos][5];
 	}
 	break;
 
       case 6:
 	if (lev.ball_array[lev.ball_pos][6] != Xblank &&
-	    tab_blank[Cave[y+1][x]])
+	    tab_blank[Cave[x][y+1]])
 	{
-	  Cave[y+1][x] = Yball_blank;
-	  Next[y+1][x] = lev.ball_array[lev.ball_pos][6];
+	  Cave[x][y+1] = Yball_blank;
+	  Next[x][y+1] = lev.ball_array[lev.ball_pos][6];
 	}
 	break;
 
       case 7:
 	if (lev.ball_array[lev.ball_pos][7] != Xblank &&
-	    tab_blank[Cave[y+1][x+1]])
+	    tab_blank[Cave[x+1][y+1]])
 	{
-	  Cave[y+1][x+1] = Yball_blank;
-	  Next[y+1][x+1] = lev.ball_array[lev.ball_pos][7];
+	  Cave[x+1][y+1] = Yball_blank;
+	  Next[x+1][y+1] = lev.ball_array[lev.ball_pos][7];
 	}
 	break;
     }
@@ -4542,59 +4531,59 @@ static void Lball_common(int x, int y)
   else
   {
     if (lev.ball_array[lev.ball_pos][0] != Xblank &&
-	tab_blank[Cave[y-1][x-1]])
+	tab_blank[Cave[x-1][y-1]])
     {
-      Cave[y-1][x-1] = Yball_blank;
-      Next[y-1][x-1] = lev.ball_array[lev.ball_pos][0];
+      Cave[x-1][y-1] = Yball_blank;
+      Next[x-1][y-1] = lev.ball_array[lev.ball_pos][0];
     }
 
     if (lev.ball_array[lev.ball_pos][1] != Xblank &&
-	tab_blank[Cave[y-1][x]])
+	tab_blank[Cave[x][y-1]])
     {
-      Cave[y-1][x] = Yball_blank;
-      Next[y-1][x] = lev.ball_array[lev.ball_pos][1];
+      Cave[x][y-1] = Yball_blank;
+      Next[x][y-1] = lev.ball_array[lev.ball_pos][1];
     }
 
     if (lev.ball_array[lev.ball_pos][2] != Xblank &&
-	tab_blank[Cave[y-1][x+1]])
+	tab_blank[Cave[x+1][y-1]])
     {
-      Cave[y-1][x+1] = Yball_blank;
-      Next[y-1][x+1] = lev.ball_array[lev.ball_pos][2];
+      Cave[x+1][y-1] = Yball_blank;
+      Next[x+1][y-1] = lev.ball_array[lev.ball_pos][2];
     }
 
     if (lev.ball_array[lev.ball_pos][3] != Xblank &&
-	tab_blank[Cave[y][x-1]])
+	tab_blank[Cave[x-1][y]])
     {
-      Cave[y][x-1] = Yball_blank;
-      Next[y][x-1] = lev.ball_array[lev.ball_pos][3];
+      Cave[x-1][y] = Yball_blank;
+      Next[x-1][y] = lev.ball_array[lev.ball_pos][3];
     }
 
     if (lev.ball_array[lev.ball_pos][4] != Xblank &&
-	tab_blank[Cave[y][x+1]])
+	tab_blank[Cave[x+1][y]])
     {
-      Cave[y][x+1] = Yball_blank;
-      Next[y][x+1] = lev.ball_array[lev.ball_pos][4];
+      Cave[x+1][y] = Yball_blank;
+      Next[x+1][y] = lev.ball_array[lev.ball_pos][4];
     }
 
     if (lev.ball_array[lev.ball_pos][5] != Xblank &&
-	tab_blank[Cave[y+1][x-1]])
+	tab_blank[Cave[x-1][y+1]])
     {
-      Cave[y+1][x-1] = Yball_blank;
-      Next[y+1][x-1] = lev.ball_array[lev.ball_pos][5];
+      Cave[x-1][y+1] = Yball_blank;
+      Next[x-1][y+1] = lev.ball_array[lev.ball_pos][5];
     }
 
     if (lev.ball_array[lev.ball_pos][6] != Xblank &&
-	tab_blank[Cave[y+1][x]])
+	tab_blank[Cave[x][y+1]])
     {
-      Cave[y+1][x] = Yball_blank;
-      Next[y+1][x] = lev.ball_array[lev.ball_pos][6];
+      Cave[x][y+1] = Yball_blank;
+      Next[x][y+1] = lev.ball_array[lev.ball_pos][6];
     }
 
     if (lev.ball_array[lev.ball_pos][7] != Xblank &&
-	tab_blank[Cave[y+1][x+1]])
+	tab_blank[Cave[x+1][y+1]])
     {
-      Cave[y+1][x+1] = Yball_blank;
-      Next[y+1][x+1] = lev.ball_array[lev.ball_pos][7];
+      Cave[x+1][y+1] = Yball_blank;
+      Next[x+1][y+1] = lev.ball_array[lev.ball_pos][7];
     }
   }
 
@@ -4606,1072 +4595,556 @@ static void Lball_1(int x, int y)
   if (lev.ball_state == 0)
     return;
 
-  Cave[y][x] = Yball_1;
-  Next[y][x] = Xball_2;
-  if (lev.ball_cnt)
-    return;
-
-  Lball_common(x, y);
-}
-
-static void Lball_2(int x, int y)
-{
-  if (lev.ball_state == 0)
-    return;
-
-  Cave[y][x] = Yball_2;
-  Next[y][x] = Xball_1;
+  Cave[x][y] = Yball_1;
+  Next[x][y] = Xball_2;
   if (lev.ball_cnt)
     return;
 
   Lball_common(x, y);
 }
 
-static void Lslidewall_ns(int x, int y)
-{
-  if (tab_blank[Cave[y-1][x]])
-  {
-    Cave[y-1][x] = Yslidewall_ns_blank;
-    Next[y-1][x] = Xslidewall_ns;
-    play_element_sound(x, y, SOUND_slidewall, Xslidewall_ns);
-  }
-
-  if (tab_blank[Cave[y+1][x]])
-  {
-    Cave[y+1][x] = Yslidewall_ns_blank;
-    Next[y+1][x] = Xslidewall_ns;
-    play_element_sound(x, y, SOUND_slidewall, Xslidewall_ns);
-  }
-}
-
-static void Lslidewall_ew(int x, int y)
-{
-  if (tab_blank[Cave[y][x+1]])
-  {
-    Cave[y][x+1] = Yslidewall_ew_blank;
-    Next[y][x+1] = Xslidewall_ew;
-    play_element_sound(x, y, SOUND_slidewall, Xslidewall_ew);
-  }
-
-  if (tab_blank[Cave[y][x-1]])
-  {
-    Cave[y][x-1] = Yslidewall_ew_blank;
-    Next[y][x-1] = Xslidewall_ew;
-    play_element_sound(x, y, SOUND_slidewall, Xslidewall_ew);
-  }
-}
-
-static void Lwonderwall(int x, int y)
-{
-  if (lev.wonderwall_time && lev.wonderwall_state)
-  {
-    Cave[y][x] = XwonderwallB;
-    play_element_sound(x, y, SOUND_wonder, Xwonderwall);
-  }
-}
-
-static void Lexit(int x, int y)
-{
-  if (lev.required > 0)
-    return;
-
-  int temp = RANDOM & 63;
-
-  if (temp < 21)
-  {
-    Cave[y][x] = Xexit_1;
-    Next[y][x] = Xexit_2;
-  }
-  else if (temp < 42)
-  {
-    Cave[y][x] = Xexit_2;
-    Next[y][x] = Xexit_3;
-  }
-  else
-  {
-    Cave[y][x] = Xexit_3;
-    Next[y][x] = Xexit_1;
-  }
-
-  play_element_sound(x, y, SOUND_exit_open, Xexit);
-}
-
-static void Lexit_1(int x, int y)
-{
-  Next[y][x] = Xexit_2;
-}
-
-static void Lexit_2(int x, int y)
-{
-  Next[y][x] = Xexit_3;
-}
-
-static void Lexit_3(int x, int y)
-{
-  Next[y][x] = Xexit_1;
-}
-
-static void Lpause(int x, int y)
-{
-  Next[y][x] = Xblank;
-}
-
-static void Ldynamite_1(int x, int y)
-{
-  play_element_sound(x, y, SOUND_tick, Xdynamite_1);
-  Next[y][x] = Xdynamite_2;
-}
-
-static void Ldynamite_2(int x, int y)
-{
-  play_element_sound(x, y, SOUND_tick, Xdynamite_2);
-  Next[y][x] = Xdynamite_3;
-}
-
-static void Ldynamite_3(int x, int y)
-{
-  play_element_sound(x, y, SOUND_tick, Xdynamite_3);
-  Next[y][x] = Xdynamite_4;
-}
-
-static void Ldynamite_4(int x, int y)
-{
-  play_element_sound(x, y, SOUND_tick, Xdynamite_4);
-  Next[y][x] = Zdynamite;
-  Boom[y-1][x-1] = Xblank;
-  Boom[y-1][x] = Xblank;
-  Boom[y-1][x+1] = Xblank;
-  Boom[y][x-1] = Xblank;
-  Boom[y][x] = Xblank;
-  Boom[y][x+1] = Xblank;
-  Boom[y+1][x-1] = Xblank;
-  Boom[y+1][x] = Xblank;
-  Boom[y+1][x+1] = Xblank;
-}
-
-static void Lwheel(int x, int y)
-{
-  if (lev.wheel_cnt && x == lev.wheel_x && y == lev.wheel_y)
-    Cave[y][x] = XwheelB;
-}
-
-static void Lswitch(int x, int y)
-{
-  if (lev.ball_state)
-    Cave[y][x] = XswitchB;
-}
-
-static void Lsand_stone(int x, int y)
-{
-  switch (Cave[y+1][x])
-  {
-    case Xacid_1:
-    case Xacid_2:
-    case Xacid_3:
-    case Xacid_4:
-    case Xacid_5:
-    case Xacid_6:
-    case Xacid_7:
-    case Xacid_8:
-      Cave[y][x] = Xsand_stonesand_quickout_1;
-      if (Cave[y][x+1] == Xblank)
-	Cave[y][x+1] = Xacid_splash_e;
-      if (Cave[y][x-1] == Xblank)
-	Cave[y][x-1] = Xacid_splash_w;
-      Next[y][x] = Xsand_stonesand_quickout_2;
-      play_element_sound(x, y, SOUND_acid, Xacid_1);
-      return;
-
-    case Xblank:
-    case Xacid_splash_e:
-    case Xacid_splash_w:
-      Cave[y][x] = Xsand_stonesand_quickout_1;
-      Cave[y+1][x] = Xsand_stoneout_1;
-      Next[y][x] = Xsand_stonesand_quickout_2;
-      Next[y+1][x] = Xsand_stoneout_2;
-      return;
-
-    case Xsand:
-      Cave[y][x] = Xsand_stonesand_1;
-      Cave[y+1][x] = Xsand_sandstone_1;
-      Next[y][x] = Xsand_stonesand_2;
-      Next[y+1][x] = Xsand_sandstone_2;
-      return;
-  }
-}
-
-static void Lsand_stonein_1(int x, int y)
-{
-  Next[y][x] = Xsand_stonein_2;
-}
-
-static void Lsand_stonein_2(int x, int y)
-{
-  Next[y][x] = Xsand_stonein_3;
-}
-
-static void Lsand_stonein_3(int x, int y)
-{
-  Next[y][x] = Xsand_stonein_4;
-}
-
-static void Lsand_stonein_4(int x, int y)
-{
-  Next[y][x] = Xblank;
-}
-
-static void Lsand_stonesand_1(int x, int y)
-{
-  Next[y][x] = Xsand_stonesand_2;
-}
-
-static void Lsand_stonesand_2(int x, int y)
-{
-  Next[y][x] = Xsand_stonesand_3;
-}
-
-static void Lsand_stonesand_3(int x, int y)
-{
-  Next[y][x] = Xsand_stonesand_4;
-}
-
-static void Lsand_stonesand_4(int x, int y)
-{
-  Next[y][x] = Xsand;
-}
-
-#if 1
-static void Lsand_stonesand_quickout_1(int x, int y)
-{
-  Next[y][x] = Xsand_stonesand_quickout_2;
-}
-
-static void Lsand_stonesand_quickout_2(int x, int y)
-{
-  Next[y][x] = Xsand;
-}
-#endif
-
-static void Lsand_stoneout_1(int x, int y)
-{
-  Next[y][x] = Xsand_stoneout_2;
-}
-
-static void Lsand_stoneout_2(int x, int y)
-{
-  Next[y][x] = Xstone_fall;
-}
-
-static void Lsand_sandstone_1(int x, int y)
-{
-  Next[y][x] = Xsand_sandstone_2;
-}
-
-static void Lsand_sandstone_2(int x, int y)
-{
-  Next[y][x] = Xsand_sandstone_3;
-}
-
-static void Lsand_sandstone_3(int x, int y)
-{
-  Next[y][x] = Xsand_sandstone_4;
-}
-
-static void Lsand_sandstone_4(int x, int y)
-{
-  Next[y][x] = Xsand_stone;
-}
-
-static void Lfake_amoeba(int x, int y)
-{
-  if (lev.lenses_cnt)
-    Cave[y][x] = Xfake_amoebaB;
-}
-
-static void Lfake_blank(int x, int y)
-{
-  if (lev.lenses_cnt)
-    Cave[y][x] = Xfake_blankB;
-}
-
-static void Lfake_grass(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xfake_grassB;
-}
-
-static void Lfake_door_1(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xdoor_1;
-}
-
-static void Lfake_door_2(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xdoor_2;
-}
-
-static void Lfake_door_3(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xdoor_3;
-}
-
-static void Lfake_door_4(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xdoor_4;
-}
-
-static void Lfake_door_5(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xdoor_5;
-}
-
-static void Lfake_door_6(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xdoor_6;
-}
-
-static void Lfake_door_7(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xdoor_7;
-}
-
-static void Lfake_door_8(int x, int y)
-{
-  if (lev.magnify_cnt)
-    Cave[y][x] = Xdoor_8;
-}
-
-static void Lboom_1(int x, int y)
-{
-  Next[y][x] = Xboom_2;
-#if !PLAY_ELEMENT_SOUND
-  if (x != lev.exit_x && y != lev.exit_y)
-    play_sound(x, y, SOUND_boom);
-  else
-    lev.exit_x = lev.exit_y = -1;
-#endif
-}
-
-static void Lboom_2(int x, int y)
-{
-  Next[y][x] = Boom[y][x];
-}
-
-static void Lboom_android(int x, int y)
-{
-#if PLAY_ELEMENT_SOUND
-  play_element_sound(x, y, SOUND_boom, Xandroid);
-#endif
-
-  Lboom_1(x, y);
-}
-
-void synchro_2(void)
-{
-  int x = 0;
-  int y = 1;
-  short *cave_cache = Cave[y];	/* might be a win */
-  int element;
-
-  random_em = RandomEM;
-  score = 0;
-
- loop:
-
-  element = cave_cache[++x];
-
-  switch (element)
-  {
-    default:
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xpush_stone_e:
-      Lpush_stone_e(x, y);
-      goto loop;
-
-    case Xpush_stone_w:
-      Lpush_stone_w(x, y);
-      goto loop;
-
-    case Xpush_nut_e:
-      Lpush_nut_e(x, y);
-      goto loop;
-
-    case Xpush_nut_w:
-      Lpush_nut_w(x, y);
-      goto loop;
-
-    case Xpush_spring_e:
-      Lpush_spring_e(x, y);
-      goto loop;
-
-    case Xpush_spring_w:
-      Lpush_spring_w(x, y);
-      goto loop;
-
-    case Xpush_emerald_e:
-      Lpush_emerald_e(x, y);
-      goto loop;
-
-    case Xpush_emerald_w:
-      Lpush_emerald_w(x, y);
-      goto loop;
-
-    case Xpush_diamond_e:
-      Lpush_diamond_e(x, y);
-      goto loop;
-
-    case Xpush_diamond_w:
-      Lpush_diamond_w(x, y);
-      goto loop;
-
-    case Xpush_bomb_e:
-      Lpush_bomb_e(x, y);
-      goto loop;
-
-    case Xpush_bomb_w:
-      Lpush_bomb_w(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xstone:
-      Lstone(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xstone_pause:
-      Lstone_pause(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xstone_fall:
-      Lstone_fall(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xnut:
-      Lnut(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xnut_pause:
-      Lnut_pause(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xnut_fall:
-      Lnut_fall(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xbug_1_n:
-      Lbug_1_n(x, y);
-      goto loop;
-
-    case Xbug_2_n:
-      Lbug_2_n(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xbug_1_e:
-      Lbug_1_e(x, y);
-      goto loop;
-
-    case Xbug_2_e:
-      Lbug_2_e(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xbug_1_s:
-      Lbug_1_s(x, y);
-      goto loop;
-
-    case Xbug_2_s:
-      Lbug_2_s(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xbug_1_w:
-      Lbug_1_w(x, y);
-      goto loop;
-
-    case Xbug_2_w:
-      Lbug_2_w(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xtank_1_n:
-      Ltank_1_n(x, y);
-      goto loop;
-
-    case Xtank_2_n:
-      Ltank_2_n(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xtank_1_e:
-      Ltank_1_e(x, y);
-      goto loop;
-
-    case Xtank_2_e:
-      Ltank_2_e(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xtank_1_s:
-      Ltank_1_s(x, y);
-      goto loop;
-
-    case Xtank_2_s:
-      Ltank_2_s(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xtank_1_w:
-      Ltank_1_w(x, y);
-      goto loop;
-
-    case Xtank_2_w:
-      Ltank_2_w(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xandroid:
-      Landroid(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xandroid_1_n:
-      Landroid_1_n(x, y);
-      goto loop;
-
-    case Xandroid_2_n:
-      Landroid_2_n(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xandroid_1_e:
-      Landroid_1_e(x, y);
-      goto loop;
-
-    case Xandroid_2_e:
-      Landroid_2_e(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xandroid_1_s:
-      Landroid_1_s(x, y);
-      goto loop;
-
-    case Xandroid_2_s:
-      Landroid_2_s(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xandroid_1_w:
-      Landroid_1_w(x, y);
-      goto loop;
-
-    case Xandroid_2_w:
-      Landroid_2_w(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xspring:
-      Lspring(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xspring_pause:
-      Lspring_pause(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xspring_e:
-      Lspring_e(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xspring_w:
-      Lspring_w(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xspring_fall:
-      Lspring_fall(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xeater_n:
-      Leater_n(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xeater_e:
-      Leater_e(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xeater_s:
-      Leater_s(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xeater_w:
-      Leater_w(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xalien:
-      Lalien(x, y);
-      goto loop;
-
-    case Xalien_pause:
-      Lalien_pause(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xemerald:
-      Lemerald(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xemerald_pause:
-      Lemerald_pause(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xemerald_fall:
-      Lemerald_fall(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xdiamond:
-      Ldiamond(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xdiamond_pause:
-      Ldiamond_pause(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xdiamond_fall:
-      Ldiamond_fall(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xdrip_fall:
-      Ldrip_fall(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xdrip_stretch:
-      Ldrip_stretch(x, y);
-      goto loop;
-
-    case Xdrip_stretchB:
-      Ldrip_stretchB(x, y);
-      goto loop;
-
-    case Xdrip:
-      Ldrip(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xbomb:
-      Lbomb(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xbomb_pause:
-      Lbomb_pause(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
+static void Lball_2(int x, int y)
+{
+  if (lev.ball_state == 0)
+    return;
 
-    case Xbomb_fall:
-      Lbomb_fall(x, y);
-      goto loop;
+  Cave[x][y] = Yball_2;
+  Next[x][y] = Xball_1;
+  if (lev.ball_cnt)
+    return;
 
-    /* --------------------------------------------------------------------- */
+  Lball_common(x, y);
+}
 
-    case Xballoon:
-      Lballoon(x, y);
-      goto loop;
+static void Ldrip(int x, int y)
+{
+  Next[x][y] = Xdrip_fall;
+}
 
-    /* --------------------------------------------------------------------- */
+static void Ldrip_fall(int x, int y)
+{
+  int temp;
 
+  switch (Cave[x][y+1])
+  {
     case Xacid_1:
-      Lacid_1(x, y);
-      goto loop;
-
     case Xacid_2:
-      Lacid_2(x, y);
-      goto loop;
-
     case Xacid_3:
-      Lacid_3(x, y);
-      goto loop;
-
     case Xacid_4:
-      Lacid_4(x, y);
-      goto loop;
-
     case Xacid_5:
-      Lacid_5(x, y);
-      goto loop;
-
     case Xacid_6:
-      Lacid_6(x, y);
-      goto loop;
-
     case Xacid_7:
-      Lacid_7(x, y);
-      goto loop;
-
     case Xacid_8:
-      Lacid_8(x, y);
-      goto loop;
-
-    case Xfake_acid_1:
-      Lfake_acid_1(x, y);
-      goto loop;
-
-    case Xfake_acid_2:
-      Lfake_acid_2(x, y);
-      goto loop;
-
-    case Xfake_acid_3:
-      Lfake_acid_3(x, y);
-      goto loop;
-
-    case Xfake_acid_4:
-      Lfake_acid_4(x, y);
-      goto loop;
-
-    case Xfake_acid_5:
-      Lfake_acid_5(x, y);
-      goto loop;
-
-    case Xfake_acid_6:
-      Lfake_acid_6(x, y);
-      goto loop;
-
-    case Xfake_acid_7:
-      Lfake_acid_7(x, y);
-      goto loop;
-
-    case Xfake_acid_8:
-      Lfake_acid_8(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xball_1:
-      Lball_1(x, y);
-      goto loop;
-
-    case Xball_2:
-      Lball_2(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xslidewall_ns:
-      Lslidewall_ns(x, y);
-      goto loop;
-
-    case Xslidewall_ew:
-      Lslidewall_ew(x, y);
-      goto loop;
+      Cave[x][y] = Ydrip_1_sB;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xdrip_stretchB;
+      play_element_sound(x, y, SOUND_acid, Xacid_1);
+      return;
 
-    /* --------------------------------------------------------------------- */
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+    case Xplant:
+    case Yplant:
+    case Zplayer:
+      Cave[x][y] = Ydrip_1_sB;
+      Cave[x][y+1] = Ydrip_1_s;
+      Next[x][y] = Xdrip_stretchB;
+      Next[x][y+1] = Xdrip_stretch;
+      return;
 
-    case Xwonderwall:
-      Lwonderwall(x, y);
-      goto loop;
+    default:
+      switch (RANDOM(8))
+      {
+	case 0: temp = Xamoeba_1; break;
+	case 1: temp = Xamoeba_2; break;
+	case 2: temp = Xamoeba_3; break;
+	case 3: temp = Xamoeba_4; break;
+	case 4: temp = Xamoeba_5; break;
+	case 5: temp = Xamoeba_6; break;
+	case 6: temp = Xamoeba_7; break;
+	case 7: temp = Xamoeba_8; break;
+      }
 
-    /* --------------------------------------------------------------------- */
+      Cave[x][y] = temp;
+      Next[x][y] = temp;
+      play_element_sound(x, y, SOUND_drip, Xdrip_fall);
+      return;
+  }
+}
 
-    case Xexit:
-      Lexit(x, y);
-      goto loop;
+static void Ldrip_stretch(int x, int y)
+{
+  Cave[x][y] = Ydrip_2_s;
+  Next[x][y] = Xdrip_fall;
+}
 
-    case Xexit_1:
-      Lexit_1(x, y);
-      goto loop;
+static void Ldrip_stretchB(int x, int y)
+{
+  Cave[x][y] = Ydrip_2_sB;
+  Next[x][y] = Xblank;
+}
 
-    case Xexit_2:
-      Lexit_2(x, y);
-      goto loop;
+static void Lwonderwall(int x, int y)
+{
+  if (lev.wonderwall_time && lev.wonderwall_state)
+  {
+    Cave[x][y] = XwonderwallB;
+    play_element_sound(x, y, SOUND_wonder, Xwonderwall);
+  }
+}
 
-    case Xexit_3:
-      Lexit_3(x, y);
-      goto loop;
+static void Lwheel(int x, int y)
+{
+  if (lev.wheel_cnt && x == lev.wheel_x && y == lev.wheel_y)
+    Cave[x][y] = XwheelB;
+}
 
-    /* --------------------------------------------------------------------- */
+static void Lswitch(int x, int y)
+{
+  if (lev.ball_state)
+    Cave[x][y] = XswitchB;
+}
 
-    case Xpause:
-      Lpause(x, y);
-      goto loop;
+static void Lfake_blank(int x, int y)
+{
+  if (lev.lenses_cnt)
+    Cave[x][y] = Xfake_blankB;
+}
 
-    /* --------------------------------------------------------------------- */
+static void Lfake_grass(int x, int y)
+{
+  if (lev.magnify_cnt)
+    Cave[x][y] = Xfake_grassB;
+}
 
-    case Xdynamite_1:
-      Ldynamite_1(x, y);
-      goto loop;
+static void Lfake_amoeba(int x, int y)
+{
+  if (lev.lenses_cnt)
+    Cave[x][y] = Xfake_amoebaB;
+}
 
-    case Xdynamite_2:
-      Ldynamite_2(x, y);
-      goto loop;
+static void Lsand_stone(int x, int y)
+{
+  switch (Cave[x][y+1])
+  {
+    case Xacid_1:
+    case Xacid_2:
+    case Xacid_3:
+    case Xacid_4:
+    case Xacid_5:
+    case Xacid_6:
+    case Xacid_7:
+    case Xacid_8:
+      Cave[x][y] = Xsand_stonesand_quickout_1;
+      if (Cave[x+1][y] == Xblank)
+	Cave[x+1][y] = Xacid_splash_e;
+      if (Cave[x-1][y] == Xblank)
+	Cave[x-1][y] = Xacid_splash_w;
+      Next[x][y] = Xsand_stonesand_quickout_2;
+      play_element_sound(x, y, SOUND_acid, Xacid_1);
+      return;
 
-    case Xdynamite_3:
-      Ldynamite_3(x, y);
-      goto loop;
+    case Xblank:
+    case Xacid_splash_e:
+    case Xacid_splash_w:
+      Cave[x][y] = Xsand_stonesand_quickout_1;
+      Cave[x][y+1] = Xsand_stoneout_1;
+      Next[x][y] = Xsand_stonesand_quickout_2;
+      Next[x][y+1] = Xsand_stoneout_2;
+      return;
 
-    case Xdynamite_4:
-      Ldynamite_4(x, y);
-      goto loop;
+    case Xsand:
+      Cave[x][y] = Xsand_stonesand_1;
+      Cave[x][y+1] = Xsand_sandstone_1;
+      Next[x][y] = Xsand_stonesand_2;
+      Next[x][y+1] = Xsand_sandstone_2;
+      return;
+  }
+}
 
-    /* --------------------------------------------------------------------- */
+static void Lsand_stonein_1(int x, int y)
+{
+  Next[x][y] = Xsand_stonein_2;
+}
 
-    case Xwheel:
-      Lwheel(x, y);
-      goto loop;
+static void Lsand_stonein_2(int x, int y)
+{
+  Next[x][y] = Xsand_stonein_3;
+}
 
-    /* --------------------------------------------------------------------- */
+static void Lsand_stonein_3(int x, int y)
+{
+  Next[x][y] = Xsand_stonein_4;
+}
 
-    case Xswitch:
-      Lswitch(x, y);
-      goto loop;
+static void Lsand_stonein_4(int x, int y)
+{
+  Next[x][y] = Xblank;
+}
 
-    /* --------------------------------------------------------------------- */
+static void Lsand_sandstone_1(int x, int y)
+{
+  Next[x][y] = Xsand_sandstone_2;
+}
 
-    case Xsand_stone:
-      Lsand_stone(x, y);
-      goto loop;
+static void Lsand_sandstone_2(int x, int y)
+{
+  Next[x][y] = Xsand_sandstone_3;
+}
 
-    case Xsand_stonein_1:
-      Lsand_stonein_1(x, y);
-      goto loop;
+static void Lsand_sandstone_3(int x, int y)
+{
+  Next[x][y] = Xsand_sandstone_4;
+}
 
-    case Xsand_stonein_2:
-      Lsand_stonein_2(x, y);
-      goto loop;
+static void Lsand_sandstone_4(int x, int y)
+{
+  Next[x][y] = Xsand_stone;
+}
 
-    case Xsand_stonein_3:
-      Lsand_stonein_3(x, y);
-      goto loop;
+static void Lsand_stonesand_1(int x, int y)
+{
+  Next[x][y] = Xsand_stonesand_2;
+}
 
-    case Xsand_stonein_4:
-      Lsand_stonein_4(x, y);
-      goto loop;
+static void Lsand_stonesand_2(int x, int y)
+{
+  Next[x][y] = Xsand_stonesand_3;
+}
 
-    case Xsand_stonesand_1:
-      Lsand_stonesand_1(x, y);
-      goto loop;
+static void Lsand_stonesand_3(int x, int y)
+{
+  Next[x][y] = Xsand_stonesand_4;
+}
 
-    case Xsand_stonesand_2:
-      Lsand_stonesand_2(x, y);
-      goto loop;
+static void Lsand_stonesand_4(int x, int y)
+{
+  Next[x][y] = Xsand;
+}
 
-    case Xsand_stonesand_3:
-      Lsand_stonesand_3(x, y);
-      goto loop;
+static void Lsand_stoneout_1(int x, int y)
+{
+  Next[x][y] = Xsand_stoneout_2;
+}
 
-    case Xsand_stonesand_4:
-      Lsand_stonesand_4(x, y);
-      goto loop;
+static void Lsand_stoneout_2(int x, int y)
+{
+  Next[x][y] = Xstone_fall;
+}
 
-#if 1
-    case Xsand_stonesand_quickout_1:
-      Lsand_stonesand_quickout_1(x, y);
-      goto loop;
+#ifdef EM_ENGINE_USE_ADDITIONAL_ELEMENTS
+static void Lsand_stonesand_quickout_1(int x, int y)
+{
+  Next[x][y] = Xsand_stonesand_quickout_2;
+}
 
-    case Xsand_stonesand_quickout_2:
-      Lsand_stonesand_quickout_2(x, y);
-      goto loop;
+static void Lsand_stonesand_quickout_2(int x, int y)
+{
+  Next[x][y] = Xsand;
+}
 #endif
 
-    case Xsand_stoneout_1:
-      Lsand_stoneout_1(x, y);
-      goto loop;
-
-    case Xsand_stoneout_2:
-      Lsand_stoneout_2(x, y);
-      goto loop;
-
-    case Xsand_sandstone_1:
-      Lsand_sandstone_1(x, y);
-      goto loop;
-
-    case Xsand_sandstone_2:
-      Lsand_sandstone_2(x, y);
-      goto loop;
-
-    case Xsand_sandstone_3:
-      Lsand_sandstone_3(x, y);
-      goto loop;
-
-    case Xsand_sandstone_4:
-      Lsand_sandstone_4(x, y);
-      goto loop;
-
-    /* --------------------------------------------------------------------- */
-
-    case Xfake_amoeba:
-      Lfake_amoeba(x, y);
-      goto loop;
+static void Lslidewall_ns(int x, int y)
+{
+  if (tab_blank[Cave[x][y-1]])
+  {
+    Cave[x][y-1] = Yslidewall_ns_blank;
+    Next[x][y-1] = Xslidewall_ns;
+    play_element_sound(x, y, SOUND_slidewall, Xslidewall_ns);
+  }
 
-    /* --------------------------------------------------------------------- */
+  if (tab_blank[Cave[x][y+1]])
+  {
+    Cave[x][y+1] = Yslidewall_ns_blank;
+    Next[x][y+1] = Xslidewall_ns;
+    play_element_sound(x, y, SOUND_slidewall, Xslidewall_ns);
+  }
+}
 
-    case Xfake_blank:
-      Lfake_blank(x, y);
-      goto loop;
+static void Lslidewall_ew(int x, int y)
+{
+  if (tab_blank[Cave[x+1][y]])
+  {
+    Cave[x+1][y] = Yslidewall_ew_blank;
+    Next[x+1][y] = Xslidewall_ew;
+    play_element_sound(x, y, SOUND_slidewall, Xslidewall_ew);
+  }
 
-    /* --------------------------------------------------------------------- */
+  if (tab_blank[Cave[x-1][y]])
+  {
+    Cave[x-1][y] = Yslidewall_ew_blank;
+    Next[x-1][y] = Xslidewall_ew;
+    play_element_sound(x, y, SOUND_slidewall, Xslidewall_ew);
+  }
+}
 
-    case Xfake_grass:
-      Lfake_grass(x, y);
-      goto loop;
+static void Lexit(int x, int y)
+{
+  if (lev.required > 0)
+    return;
 
-    /* --------------------------------------------------------------------- */
+  switch (RANDOM(64) / 21)
+  {
+    case 0:
+      Cave[x][y] = Xexit_1;
+      Next[x][y] = Xexit_2;
+      break;
 
-    case Xfake_door_1:
-      Lfake_door_1(x, y);
-      goto loop;
+    case 1:
+      Cave[x][y] = Xexit_2;
+      Next[x][y] = Xexit_3;
+      break;
 
-    case Xfake_door_2:
-      Lfake_door_2(x, y);
-      goto loop;
+    default:
+      Cave[x][y] = Xexit_3;
+      Next[x][y] = Xexit_1;
+      break;
+  }
 
-    case Xfake_door_3:
-      Lfake_door_3(x, y);
-      goto loop;
+  play_element_sound(x, y, SOUND_exit_open, Xexit);
+}
 
-    case Xfake_door_4:
-      Lfake_door_4(x, y);
-      goto loop;
+static void Lexit_1(int x, int y)
+{
+  Next[x][y] = Xexit_2;
+}
 
-    case Xfake_door_5:
-      Lfake_door_5(x, y);
-      goto loop;
+static void Lexit_2(int x, int y)
+{
+  Next[x][y] = Xexit_3;
+}
 
-    case Xfake_door_6:
-      Lfake_door_6(x, y);
-      goto loop;
+static void Lexit_3(int x, int y)
+{
+  Next[x][y] = Xexit_1;
+}
 
-    case Xfake_door_7:
-      Lfake_door_7(x, y);
-      goto loop;
+static void Lpause(int x, int y)
+{
+  Next[x][y] = Xblank;
+}
 
-    case Xfake_door_8:
-      Lfake_door_8(x, y);
-      goto loop;
+static void Lboom_1(int x, int y)
+{
+  Next[x][y] = Xboom_2;
+#if !PLAY_ELEMENT_SOUND
+  if (x != lev.exit_x && y != lev.exit_y)
+    play_sound(x, y, SOUND_boom);
+  else
+    lev.exit_x = lev.exit_y = -1;
+#endif
+}
 
-    /* --------------------------------------------------------------------- */
+static void Lboom_2(int x, int y)
+{
+  Next[x][y] = Boom[x][y];
+}
 
-    case Xboom_bug:
-      Lboom_bug(x, y);
-      goto loop;
+static void Lboom_android(int x, int y)
+{
+#if PLAY_ELEMENT_SOUND
+  play_element_sound(x, y, SOUND_boom, Xandroid);
+#endif
 
-    case Xboom_bomb:
-      Lboom_tank(x, y);
-      goto loop;
+  Lboom_1(x, y);
+}
 
-    case Xboom_android:
-      Lboom_android(x, y);
-      goto loop;
+static void handle_tile(int x, int y)
+{
+  switch (Cave[x][y])
+  {
+    case Xacid_1:		Lacid_1(x, y);			break;
+    case Xacid_2:		Lacid_2(x, y);			break;
+    case Xacid_3:		Lacid_3(x, y);			break;
+    case Xacid_4:		Lacid_4(x, y);			break;
+    case Xacid_5:		Lacid_5(x, y);			break;
+    case Xacid_6:		Lacid_6(x, y);			break;
+    case Xacid_7:		Lacid_7(x, y);			break;
+    case Xacid_8:		Lacid_8(x, y);			break;
+
+#ifdef EM_ENGINE_USE_ADDITIONAL_ELEMENTS
+    case Xfake_acid_1:		Lfake_acid_1(x, y);		break;
+    case Xfake_acid_2:		Lfake_acid_2(x, y);		break;
+    case Xfake_acid_3:		Lfake_acid_3(x, y);		break;
+    case Xfake_acid_4:		Lfake_acid_4(x, y);		break;
+    case Xfake_acid_5:		Lfake_acid_5(x, y);		break;
+    case Xfake_acid_6:		Lfake_acid_6(x, y);		break;
+    case Xfake_acid_7:		Lfake_acid_7(x, y);		break;
+    case Xfake_acid_8:		Lfake_acid_8(x, y);		break;
+#endif
 
-    case Xboom_1:
-      Lboom_1(x, y);
-      goto loop;
+    case Xandroid:		Landroid(x, y);			break;
+    case Xandroid_1_n:		Landroid_1_n(x, y);		break;
+    case Xandroid_2_n:		Landroid_2_n(x, y);		break;
+    case Xandroid_1_e:		Landroid_1_e(x, y);		break;
+    case Xandroid_2_e:		Landroid_2_e(x, y);		break;
+    case Xandroid_1_s:		Landroid_1_s(x, y);		break;
+    case Xandroid_2_s:		Landroid_2_s(x, y);		break;
+    case Xandroid_1_w:		Landroid_1_w(x, y);		break;
+    case Xandroid_2_w:		Landroid_2_w(x, y);		break;
+
+    case Xeater_n:		Leater_n(x, y);			break;
+    case Xeater_e:		Leater_e(x, y);			break;
+    case Xeater_s:		Leater_s(x, y);			break;
+    case Xeater_w:		Leater_w(x, y);			break;
+
+    case Xalien:		Lalien(x, y);			break;
+    case Xalien_pause:		Lalien_pause(x, y);		break;
+
+    case Xbug_1_n:		Lbug_1_n(x, y);			break;
+    case Xbug_2_n:		Lbug_2_n(x, y);			break;
+    case Xbug_1_e:		Lbug_1_e(x, y);			break;
+    case Xbug_2_e:		Lbug_2_e(x, y);			break;
+    case Xbug_1_s:		Lbug_1_s(x, y);			break;
+    case Xbug_2_s:		Lbug_2_s(x, y);			break;
+    case Xbug_1_w:		Lbug_1_w(x, y);			break;
+    case Xbug_2_w:		Lbug_2_w(x, y);			break;
+
+    case Xtank_1_n:		Ltank_1_n(x, y);		break;
+    case Xtank_2_n:		Ltank_2_n(x, y);		break;
+    case Xtank_1_e:		Ltank_1_e(x, y);		break;
+    case Xtank_2_e:		Ltank_2_e(x, y);		break;
+    case Xtank_1_s:		Ltank_1_s(x, y);		break;
+    case Xtank_2_s:		Ltank_2_s(x, y);		break;
+    case Xtank_1_w:		Ltank_1_w(x, y);		break;
+    case Xtank_2_w:		Ltank_2_w(x, y);		break;
+
+    case Xemerald:		Lemerald(x, y);			break;
+    case Xemerald_pause:	Lemerald_pause(x, y);		break;
+    case Xemerald_fall:		Lemerald_fall(x, y);		break;
+
+    case Xdiamond:		Ldiamond(x, y);			break;
+    case Xdiamond_pause:	Ldiamond_pause(x, y);		break;
+    case Xdiamond_fall:		Ldiamond_fall(x, y);		break;
+
+    case Xstone:		Lstone(x, y);			break;
+    case Xstone_pause:		Lstone_pause(x, y);		break;
+    case Xstone_fall:		Lstone_fall(x, y);		break;
+
+    case Xbomb:			Lbomb(x, y);			break;
+    case Xbomb_pause:		Lbomb_pause(x, y);		break;
+    case Xbomb_fall:		Lbomb_fall(x, y);		break;
+
+    case Xnut:			Lnut(x, y);			break;
+    case Xnut_pause:		Lnut_pause(x, y);		break;
+    case Xnut_fall:		Lnut_fall(x, y);		break;
+
+    case Xspring:		Lspring(x, y);			break;
+    case Xspring_pause:		Lspring_pause(x, y);		break;
+    case Xspring_e:		Lspring_e(x, y);		break;
+    case Xspring_w:		Lspring_w(x, y);		break;
+    case Xspring_fall:		Lspring_fall(x, y);		break;
+
+    case Xpush_emerald_e:	Lpush_emerald_e(x, y);		break;
+    case Xpush_emerald_w:	Lpush_emerald_w(x, y);		break;
+    case Xpush_diamond_e:	Lpush_diamond_e(x, y);		break;
+    case Xpush_diamond_w:	Lpush_diamond_w(x, y);		break;
+    case Xpush_stone_e:		Lpush_stone_e(x, y);		break;
+    case Xpush_stone_w:		Lpush_stone_w(x, y);		break;
+    case Xpush_bomb_e:		Lpush_bomb_e(x, y);		break;
+    case Xpush_bomb_w:		Lpush_bomb_w(x, y);		break;
+    case Xpush_nut_e:		Lpush_nut_e(x, y);		break;
+    case Xpush_nut_w:		Lpush_nut_w(x, y);		break;
+    case Xpush_spring_e:	Lpush_spring_e(x, y);		break;
+    case Xpush_spring_w:	Lpush_spring_w(x, y);		break;
+
+    case Xdynamite_1:		Ldynamite_1(x, y);		break;
+    case Xdynamite_2:		Ldynamite_2(x, y);		break;
+    case Xdynamite_3:		Ldynamite_3(x, y);		break;
+    case Xdynamite_4:		Ldynamite_4(x, y);		break;
+
+    case Xfake_door_1:		Lfake_door_1(x, y);		break;
+    case Xfake_door_2:		Lfake_door_2(x, y);		break;
+    case Xfake_door_3:		Lfake_door_3(x, y);		break;
+    case Xfake_door_4:		Lfake_door_4(x, y);		break;
+    case Xfake_door_5:		Lfake_door_5(x, y);		break;
+    case Xfake_door_6:		Lfake_door_6(x, y);		break;
+    case Xfake_door_7:		Lfake_door_7(x, y);		break;
+    case Xfake_door_8:		Lfake_door_8(x, y);		break;
+
+    case Xballoon:		Lballoon(x, y);			break;
+
+    case Xball_1:		Lball_1(x, y);			break;
+    case Xball_2:		Lball_2(x, y);			break;
+
+    case Xdrip:			Ldrip(x, y);			break;
+    case Xdrip_fall:		Ldrip_fall(x, y);		break;
+    case Xdrip_stretch:		Ldrip_stretch(x, y);		break;
+    case Xdrip_stretchB:	Ldrip_stretchB(x, y);		break;
+
+    case Xwonderwall:		Lwonderwall(x, y);		break;
+
+    case Xwheel:		Lwheel(x, y);			break;
+
+    case Xswitch:		Lswitch(x, y);			break;
+
+    case Xfake_blank:		Lfake_blank(x, y);		break;
+    case Xfake_grass:		Lfake_grass(x, y);		break;
+    case Xfake_amoeba:		Lfake_amoeba(x, y);		break;
+
+    case Xsand_stone:		Lsand_stone(x, y);		break;
+    case Xsand_stonein_1:	Lsand_stonein_1(x, y);		break;
+    case Xsand_stonein_2:	Lsand_stonein_2(x, y);		break;
+    case Xsand_stonein_3:	Lsand_stonein_3(x, y);		break;
+    case Xsand_stonein_4:	Lsand_stonein_4(x, y);		break;
+    case Xsand_sandstone_1:	Lsand_sandstone_1(x, y);	break;
+    case Xsand_sandstone_2:	Lsand_sandstone_2(x, y);	break;
+    case Xsand_sandstone_3:	Lsand_sandstone_3(x, y);	break;
+    case Xsand_sandstone_4:	Lsand_sandstone_4(x, y);	break;
+    case Xsand_stonesand_1:	Lsand_stonesand_1(x, y);	break;
+    case Xsand_stonesand_2:	Lsand_stonesand_2(x, y);	break;
+    case Xsand_stonesand_3:	Lsand_stonesand_3(x, y);	break;
+    case Xsand_stonesand_4:	Lsand_stonesand_4(x, y);	break;
+    case Xsand_stoneout_1:	Lsand_stoneout_1(x, y);		break;
+    case Xsand_stoneout_2:	Lsand_stoneout_2(x, y);		break;
+#ifdef EM_ENGINE_USE_ADDITIONAL_ELEMENTS
+    case Xsand_stonesand_quickout_1: Lsand_stonesand_quickout_1(x, y); break;
+    case Xsand_stonesand_quickout_2: Lsand_stonesand_quickout_2(x, y); break;
+#endif
 
-    case Xboom_2:
-      Lboom_2(x, y);
-      goto loop;
+    case Xslidewall_ns:		Lslidewall_ns(x, y);		break;
+    case Xslidewall_ew:		Lslidewall_ew(x, y);		break;
 
-    /* --------------------------------------------------------------------- */
+    case Xexit:			Lexit(x, y);			break;
+    case Xexit_1:		Lexit_1(x, y);			break;
+    case Xexit_2:		Lexit_2(x, y);			break;
+    case Xexit_3:		Lexit_3(x, y);			break;
 
-    case Zborder:
-      if (++y < HEIGHT - 1)
-      {
-	x = 0;
-	cave_cache = Cave[y];
-	goto loop;
-      }
+    case Xpause:		Lpause(x, y);			break;
 
-      goto done;
+    case Xboom_bug:		Lboom_bug(x, y);		break;
+    case Xboom_bomb:		Lboom_tank(x, y);		break;
+    case Xboom_android:		Lboom_android(x, y);		break;
+    case Xboom_1:		Lboom_1(x, y);			break;
+    case Xboom_2:		Lboom_2(x, y);			break;
   }
+}
+
+void synchro_2(void)
+{
+  int x, y;
 
-#undef RANDOM
-#undef PLAY
-#undef PLAY_FORCE
+  seed = RandomEM;
+  score = 0;
 
- done:
+  for (y = 1; y < HEIGHT - 1; y++)
+    for (x = 0; x < WIDTH; x++)
+      handle_tile(x, y);
 
   if (ply[0].alive || ply[1].alive || ply[2].alive || ply[3].alive)
     lev.score += score;		/* only add a score if someone is alive */
   else
     game_em.game_over = TRUE;
 
-  RandomEM = random_em;
-
-  {
-    void *temp = Cave;
+  RandomEM = seed;
 
-    /* triple buffering */
-    Cave = Next;
-    Next = Draw;
-    Draw = temp;
-  }
+  /* triple buffering */
+  void *temp = Cave;
+  Cave = Next;
+  Next = Draw;
+  Draw = temp;
 }