src/game_em/logic.c

   1 /* 2008-09-24 23:20:29
   2  *
   3  * David Tritscher
   4  *
   5  * my own version of the emerald mine engine
   6  */
   7
   8 #include "main_em.h"
   9
  10
  11 #define SPRING_ROLL     /* spring rolling off round things continues to roll */
  12 #define ACID_ROLL       /* rolling objects go into acid rather than remove it */
  13 #define ACID_PLAYER     /* player gets killed by acid, but without explosion */
  14
  15 #define RANDOM_BUG      /* handle problem with old tapes using 64-bit random */
  16
  17 #define RANDOM(x)       ((seed = seed << 31 | seed >> 1) % x)
  18
  19 static short **cave, **next, **boom;
  20 static unsigned int seed;
  21 static int score;
  22
  23 static const byte is_blank[GAME_TILE_MAX] =
  24 {
  25   [Xblank]              = 1,
  26   [Xsplash_e]           = 1,
  27   [Xsplash_w]           = 1,
  28   [Xfake_acid_1]        = 1,
  29   [Xfake_acid_2]        = 1,
  30   [Xfake_acid_3]        = 1,
  31   [Xfake_acid_4]        = 1,
  32   [Xfake_acid_5]        = 1,
  33   [Xfake_acid_6]        = 1,
  34   [Xfake_acid_7]        = 1,
  35   [Xfake_acid_8]        = 1
  36 };
  37
  38 static const byte is_blank_or_acid[GAME_TILE_MAX] =
  39 {
  40   [Xblank]              = 1,
  41   [Xsplash_e]           = 1,
  42   [Xsplash_w]           = 1,
  43   [Xfake_acid_1]        = 1,
  44   [Xfake_acid_2]        = 1,
  45   [Xfake_acid_3]        = 1,
  46   [Xfake_acid_4]        = 1,
  47   [Xfake_acid_5]        = 1,
  48   [Xfake_acid_6]        = 1,
  49   [Xfake_acid_7]        = 1,
  50   [Xfake_acid_8]        = 1,
  51   [Xacid_1]             = 1,
  52   [Xacid_2]             = 1,
  53   [Xacid_3]             = 1,
  54   [Xacid_4]             = 1,
  55   [Xacid_5]             = 1,
  56   [Xacid_6]             = 1,
  57   [Xacid_7]             = 1,
  58   [Xacid_8]             = 1
  59 };
  60
  61 static const byte is_player[GAME_TILE_MAX] =
  62 {
  63   [Zplayer]             = 1,
  64   [Xfake_acid_1_player] = 1,
  65   [Xfake_acid_2_player] = 1,
  66   [Xfake_acid_3_player] = 1,
  67   [Xfake_acid_4_player] = 1,
  68   [Xfake_acid_5_player] = 1,
  69   [Xfake_acid_6_player] = 1,
  70   [Xfake_acid_7_player] = 1,
  71   [Xfake_acid_8_player] = 1
  72 };
  73
  74 static const byte add_player[GAME_TILE_MAX] =
  75 {
  76   [Xblank]              = Zplayer,
  77   [Xsplash_e]           = Zplayer,
  78   [Xsplash_w]           = Zplayer,
  79   [Xfake_acid_1]        = Xfake_acid_1_player,
  80   [Xfake_acid_2]        = Xfake_acid_2_player,
  81   [Xfake_acid_3]        = Xfake_acid_3_player,
  82   [Xfake_acid_4]        = Xfake_acid_4_player,
  83   [Xfake_acid_5]        = Xfake_acid_5_player,
  84   [Xfake_acid_6]        = Xfake_acid_6_player,
  85   [Xfake_acid_7]        = Xfake_acid_7_player,
  86   [Xfake_acid_8]        = Xfake_acid_8_player
  87 };
  88
  89 static const byte remove_player[GAME_TILE_MAX] =
  90 {
  91   [Zplayer]             = Xblank,
  92   [Xfake_acid_1_player] = Xfake_acid_1,
  93   [Xfake_acid_2_player] = Xfake_acid_2,
  94   [Xfake_acid_3_player] = Xfake_acid_3,
  95   [Xfake_acid_4_player] = Xfake_acid_4,
  96   [Xfake_acid_5_player] = Xfake_acid_5,
  97   [Xfake_acid_6_player] = Xfake_acid_6,
  98   [Xfake_acid_7_player] = Xfake_acid_7,
  99   [Xfake_acid_8_player] = Xfake_acid_8
 100 };
 101
 102 static const byte is_amoeba[GAME_TILE_MAX] =
 103 {
 104   [Xfake_amoeba]        = 1,
 105   [Yfake_amoeba]        = 1,
 106   [Xamoeba_1]           = 1,
 107   [Xamoeba_2]           = 1,
 108   [Xamoeba_3]           = 1,
 109   [Xamoeba_4]           = 1,
 110   [Xamoeba_5]           = 1,
 111   [Xamoeba_6]           = 1,
 112   [Xamoeba_7]           = 1,
 113   [Xamoeba_8]           = 1
 114 };
 115
 116 static byte is_android_blank[GAME_TILE_MAX] =
 117 {
 118   [Xblank]              = 1,
 119   [Xsplash_e]           = 1,
 120   [Xsplash_w]           = 1,
 121   [Xfake_acid_1]        = 1,
 122   [Xfake_acid_2]        = 1,
 123   [Xfake_acid_3]        = 1,
 124   [Xfake_acid_4]        = 1,
 125   [Xfake_acid_5]        = 1,
 126   [Xfake_acid_6]        = 1,
 127   [Xfake_acid_7]        = 1,
 128   [Xfake_acid_8]        = 1
 129 };
 130
 131 static const byte is_android_walkable[GAME_TILE_MAX] =
 132 {
 133   [Xblank]              = 1,
 134   [Xsplash_e]           = 1,
 135   [Xsplash_w]           = 1,
 136   [Xfake_acid_1]        = 1,
 137   [Xfake_acid_2]        = 1,
 138   [Xfake_acid_3]        = 1,
 139   [Xfake_acid_4]        = 1,
 140   [Xfake_acid_5]        = 1,
 141   [Xfake_acid_6]        = 1,
 142   [Xfake_acid_7]        = 1,
 143   [Xfake_acid_8]        = 1,
 144   [Xplant]              = 1
 145 };
 146
 147 static void Lboom_generic(int x, int y, int element, int element_middle)
 148 {
 149   boom[x-1][y-1] = element;
 150   boom[x][y-1]   = element;
 151   boom[x+1][y-1] = element;
 152   boom[x-1][y]   = element;
 153   boom[x][y]     = element_middle;
 154   boom[x+1][y]   = element;
 155   boom[x-1][y+1] = element;
 156   boom[x][y+1]   = element;
 157   boom[x+1][y+1] = element;
 158 }
 159
 160 static void Lboom_bug(int x, int y)
 161 {
 162   if (game_em.use_old_explosions)
 163     next[x][y] = Zbug;
 164
 165   Lboom_generic(x, y, Xemerald, Xdiamond);
 166
 167 #if PLAY_ELEMENT_SOUND
 168   play_element_sound(x, y, SOUND_boom, Xbug_1_n);
 169 #endif
 170 }
 171
 172 static void Lboom_tank(int x, int y)
 173 {
 174   if (game_em.use_old_explosions)
 175     next[x][y] = Ztank;
 176
 177   Lboom_generic(x, y, Xblank, Xblank);
 178
 179 #if PLAY_ELEMENT_SOUND
 180   play_element_sound(x, y, SOUND_boom, Xtank_1_n);
 181 #endif
 182 }
 183
 184 static void Lboom_eater(int x, int y)
 185 {
 186   if (game_em.use_old_explosions)
 187     next[x][y] = Zeater;
 188
 189   boom[x-1][y-1] = lev.eater_array[lev.eater_pos][0];
 190   boom[x][y-1]   = lev.eater_array[lev.eater_pos][1];
 191   boom[x+1][y-1] = lev.eater_array[lev.eater_pos][2];
 192   boom[x-1][y]   = lev.eater_array[lev.eater_pos][3];
 193   boom[x][y]     = lev.eater_array[lev.eater_pos][4];
 194   boom[x+1][y]   = lev.eater_array[lev.eater_pos][5];
 195   boom[x-1][y+1] = lev.eater_array[lev.eater_pos][6];
 196   boom[x][y+1]   = lev.eater_array[lev.eater_pos][7];
 197   boom[x+1][y+1] = lev.eater_array[lev.eater_pos][8];
 198
 199   lev.eater_pos = (lev.eater_pos + 1) % lev.num_eater_arrays;
 200
 201 #if PLAY_ELEMENT_SOUND
 202   play_element_sound(x, y, SOUND_boom, Xeater_n);
 203 #endif
 204 }
 205
 206 static void Lboom_bug_old(int x, int y)
 207 {
 208   if (!game_em.use_old_explosions)
 209     return;
 210
 211   Lboom_bug(x, y);
 212 }
 213
 214 static void Lboom_tank_old(int x, int y)
 215 {
 216   if (!game_em.use_old_explosions)
 217     return;
 218
 219   Lboom_tank(x, y);
 220 }
 221
 222 static void Lboom_eater_old(int x, int y)
 223 {
 224   if (!game_em.use_old_explosions)
 225     return;
 226
 227   Lboom_eater(x, y);
 228 }
 229
 230 static void Lboom_bug_new(int x, int y, boolean chain_explosion)
 231 {
 232   if (game_em.use_old_explosions)
 233     return;
 234
 235   if (chain_explosion)
 236     cave[x][y] = Xchain;
 237
 238   Lboom_bug(x, y);
 239 }
 240
 241 static void Lboom_tank_new(int x, int y, boolean chain_explosion)
 242 {
 243   if (game_em.use_old_explosions)
 244     return;
 245
 246   if (chain_explosion)
 247     cave[x][y] = Xchain;
 248
 249   Lboom_tank(x, y);
 250 }
 251
 252 static void Lboom_eater_new(int x, int y, boolean chain_explosion)
 253 {
 254   if (game_em.use_old_explosions)
 255     return;
 256
 257   if (chain_explosion)
 258     cave[x][y] = Xchain;
 259
 260   Lboom_eater(x, y);
 261 }
 262
 263 static void Lboom_cave_new(int x, int y, int element)
 264 {
 265   if (game_em.use_old_explosions)
 266     return;
 267
 268   cave[x][y] = element;
 269 }
 270
 271 static void Lboom_next_new(int x, int y, int element)
 272 {
 273   if (game_em.use_old_explosions)
 274     return;
 275
 276   next[x][y] = element;
 277 }
 278
 279 static void Lpush_element_old(int x, int y, int element)
 280 {
 281   if (!game_em.use_old_push_elements)
 282     return;
 283
 284   cave[x][y] = element;
 285   next[x][y] = element;
 286 }
 287
 288 static boolean player_killed(struct PLAYER *ply)
 289 {
 290   int x = ply->x;
 291   int y = ply->y;
 292
 293   if (!ply->alive)
 294     return FALSE;
 295
 296   if (lev.killed_out_of_time && setup.time_limit)
 297     return TRUE;
 298
 299   switch (cave[x][y-1])
 300   {
 301     case Xbug_1_n:
 302     case Xbug_1_e:
 303     case Xbug_1_s:
 304     case Xbug_1_w:
 305     case Xbug_2_n:
 306     case Xbug_2_e:
 307     case Xbug_2_s:
 308     case Xbug_2_w:
 309     case Xtank_1_n:
 310     case Xtank_1_e:
 311     case Xtank_1_s:
 312     case Xtank_1_w:
 313     case Xtank_2_n:
 314     case Xtank_2_e:
 315     case Xtank_2_s:
 316     case Xtank_2_w:
 317       return TRUE;
 318   }
 319
 320   switch (cave[x+1][y])
 321   {
 322     case Xbug_1_n:
 323     case Xbug_1_e:
 324     case Xbug_1_s:
 325     case Xbug_1_w:
 326     case Xbug_2_n:
 327     case Xbug_2_e:
 328     case Xbug_2_s:
 329     case Xbug_2_w:
 330     case Xtank_1_n:
 331     case Xtank_1_e:
 332     case Xtank_1_s:
 333     case Xtank_1_w:
 334     case Xtank_2_n:
 335     case Xtank_2_e:
 336     case Xtank_2_s:
 337     case Xtank_2_w:
 338       return TRUE;
 339   }
 340
 341   switch (cave[x][y+1])
 342   {
 343     case Xbug_1_n:
 344     case Xbug_1_e:
 345     case Xbug_1_s:
 346     case Xbug_1_w:
 347     case Xbug_2_n:
 348     case Xbug_2_e:
 349     case Xbug_2_s:
 350     case Xbug_2_w:
 351     case Xtank_1_n:
 352     case Xtank_1_e:
 353     case Xtank_1_s:
 354     case Xtank_1_w:
 355     case Xtank_2_n:
 356     case Xtank_2_e:
 357     case Xtank_2_s:
 358     case Xtank_2_w:
 359       return TRUE;
 360   }
 361
 362   switch (cave[x-1][y])
 363   {
 364     case Xbug_1_n:
 365     case Xbug_1_e:
 366     case Xbug_1_s:
 367     case Xbug_1_w:
 368     case Xbug_2_n:
 369     case Xbug_2_e:
 370     case Xbug_2_s:
 371     case Xbug_2_w:
 372     case Xtank_1_n:
 373     case Xtank_1_e:
 374     case Xtank_1_s:
 375     case Xtank_1_w:
 376     case Xtank_2_n:
 377     case Xtank_2_e:
 378     case Xtank_2_s:
 379     case Xtank_2_w:
 380       return TRUE;
 381   }
 382
 383   switch (cave[x][y])
 384   {
 385     case Zplayer:
 386     case Xblank:
 387     case Xsplash_e:
 388     case Xsplash_w:
 389     case Xfake_acid_1:
 390     case Xfake_acid_2:
 391     case Xfake_acid_3:
 392     case Xfake_acid_4:
 393     case Xfake_acid_5:
 394     case Xfake_acid_6:
 395     case Xfake_acid_7:
 396     case Xfake_acid_8:
 397     case Xfake_acid_1_player:
 398     case Xfake_acid_2_player:
 399     case Xfake_acid_3_player:
 400     case Xfake_acid_4_player:
 401     case Xfake_acid_5_player:
 402     case Xfake_acid_6_player:
 403     case Xfake_acid_7_player:
 404     case Xfake_acid_8_player:
 405     case Xdynamite_1:
 406     case Xdynamite_2:
 407     case Xdynamite_3:
 408     case Xdynamite_4:
 409       return FALSE;
 410   }
 411
 412   return TRUE;
 413 }
 414
 415 static void kill_player(struct PLAYER *ply)
 416 {
 417   int x = ply->x;
 418   int y = ply->y;
 419
 420   ply->alive = FALSE;
 421
 422   switch (cave[x][y-1])
 423   {
 424     case Xbug_1_n:
 425     case Xbug_1_e:
 426     case Xbug_1_s:
 427     case Xbug_1_w:
 428     case Xbug_2_n:
 429     case Xbug_2_e:
 430     case Xbug_2_s:
 431     case Xbug_2_w:
 432       cave[x][y-1] = Xboom_bug;
 433       Lboom_bug_new(x, y-1, TRUE);
 434       break;
 435
 436     case Xtank_1_n:
 437     case Xtank_1_e:
 438     case Xtank_1_s:
 439     case Xtank_1_w:
 440     case Xtank_2_n:
 441     case Xtank_2_e:
 442     case Xtank_2_s:
 443     case Xtank_2_w:
 444       cave[x][y-1] = Xboom_tank;
 445       Lboom_tank_new(x, y-1, TRUE);
 446       break;
 447   }
 448
 449   switch (cave[x+1][y])
 450   {
 451     case Xbug_1_n:
 452     case Xbug_1_e:
 453     case Xbug_1_s:
 454     case Xbug_1_w:
 455     case Xbug_2_n:
 456     case Xbug_2_e:
 457     case Xbug_2_s:
 458     case Xbug_2_w:
 459       cave[x+1][y] = Xboom_bug;
 460       Lboom_bug_new(x+1, y, TRUE);
 461       break;
 462
 463     case Xtank_1_n:
 464     case Xtank_1_e:
 465     case Xtank_1_s:
 466     case Xtank_1_w:
 467     case Xtank_2_n:
 468     case Xtank_2_e:
 469     case Xtank_2_s:
 470     case Xtank_2_w:
 471       cave[x+1][y] = Xboom_tank;
 472       Lboom_tank_new(x+1, y, TRUE);
 473       break;
 474   }
 475
 476   switch (cave[x][y+1])
 477   {
 478     case Xbug_1_n:
 479     case Xbug_1_e:
 480     case Xbug_1_s:
 481     case Xbug_1_w:
 482     case Xbug_2_n:
 483     case Xbug_2_e:
 484     case Xbug_2_s:
 485     case Xbug_2_w:
 486       cave[x][y+1] = Xboom_bug;
 487       Lboom_bug_new(x, y+1, TRUE);
 488       break;
 489
 490     case Xtank_1_n:
 491     case Xtank_1_e:
 492     case Xtank_1_s:
 493     case Xtank_1_w:
 494     case Xtank_2_n:
 495     case Xtank_2_e:
 496     case Xtank_2_s:
 497     case Xtank_2_w:
 498       cave[x][y+1] = Xboom_tank;
 499       Lboom_tank_new(x, y+1, TRUE);
 500       break;
 501   }
 502
 503   switch (cave[x-1][y])
 504   {
 505     case Xbug_1_n:
 506     case Xbug_1_e:
 507     case Xbug_1_s:
 508     case Xbug_1_w:
 509     case Xbug_2_n:
 510     case Xbug_2_e:
 511     case Xbug_2_s:
 512     case Xbug_2_w:
 513       cave[x-1][y] = Xboom_bug;
 514       Lboom_bug_new(x-1, y, TRUE);
 515       break;
 516
 517     case Xtank_1_n:
 518     case Xtank_1_e:
 519     case Xtank_1_s:
 520     case Xtank_1_w:
 521     case Xtank_2_n:
 522     case Xtank_2_e:
 523     case Xtank_2_s:
 524     case Xtank_2_w:
 525       cave[x-1][y] = Xboom_tank;
 526       Lboom_tank_new(x-1, y, TRUE);
 527       break;
 528   }
 529
 530   switch (cave[x][y])
 531   {
 532     case Xexit_1:
 533     case Xexit_2:
 534     case Xexit_3:
 535       lev.exit_x = x;
 536       lev.exit_y = y;
 537       play_element_sound(x, y, SOUND_exit_leave, Xexit_1);
 538       break;
 539
 540     default:
 541       play_element_sound(x, y, SOUND_die, Zplayer);
 542       break;
 543   }
 544
 545   switch (cave[x][y])
 546   {
 547 #ifdef ACID_PLAYER
 548     case Xacid_1:
 549     case Xacid_2:
 550     case Xacid_3:
 551     case Xacid_4:
 552     case Xacid_5:
 553     case Xacid_6:
 554     case Xacid_7:
 555     case Xacid_8:
 556       break;
 557 #endif
 558
 559     default:
 560       cave[x][y] = Xboom_1;
 561       boom[x][y] = Xblank;
 562       break;
 563   }
 564 }
 565
 566 static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
 567 {
 568   int anim = (dx < 0 ? 3 : dx > 0 ? 1 : dy < 0 ? 0 : dy > 0 ? 2 : 2);
 569   int oldx = ply->x;
 570   int oldy = ply->y;
 571   int x = oldx + dx;
 572   int y = oldy + dy;
 573   boolean result = TRUE;
 574
 575   if (!dx && !dy)                       /* no direction specified */
 576     return FALSE;
 577
 578   if (dx && dy && ply->joy_snap)        /* more than one direction specified */
 579     return FALSE;
 580
 581   if (!ply->joy_snap)                   /* player wants to move */
 582   {
 583     int element = cave[x][y];
 584
 585     switch (cave[x][y])
 586     {
 587       /* fire is released */
 588       case Xblank:
 589       case Xsplash_e:
 590       case Xsplash_w:
 591       case Xfake_acid_1:
 592       case Xfake_acid_2:
 593       case Xfake_acid_3:
 594       case Xfake_acid_4:
 595       case Xfake_acid_5:
 596       case Xfake_acid_6:
 597       case Xfake_acid_7:
 598       case Xfake_acid_8:
 599         cave[x][y] = add_player[element];
 600         next[x][y] = add_player[element];
 601
 602         play_element_sound(x, y, SOUND_blank, Xblank);
 603         ply->anim = PLY_walk_n + anim;
 604         ply->x = x;
 605         ply->y = y;
 606         break;
 607
 608       case Xacid_1:
 609       case Xacid_2:
 610       case Xacid_3:
 611       case Xacid_4:
 612       case Xacid_5:
 613       case Xacid_6:
 614       case Xacid_7:
 615       case Xacid_8:
 616 #ifdef ACID_PLAYER
 617         if (cave[x+1][y-1] == Xblank)
 618           cave[x+1][y-1] = Xsplash_e;
 619         if (cave[x-1][y-1] == Xblank)
 620           cave[x-1][y-1] = Xsplash_w;
 621         play_element_sound(x, y, SOUND_acid, Xacid_1);
 622         // FALL THROUGH
 623 #endif
 624       case Xboom_android:
 625       case Xboom_1:
 626       case Xbug_1_n:
 627       case Xbug_1_e:
 628       case Xbug_1_s:
 629       case Xbug_1_w:
 630       case Xbug_2_n:
 631       case Xbug_2_e:
 632       case Xbug_2_s:
 633       case Xbug_2_w:
 634       case Xtank_1_n:
 635       case Xtank_1_e:
 636       case Xtank_1_s:
 637       case Xtank_1_w:
 638       case Xtank_2_n:
 639       case Xtank_2_e:
 640       case Xtank_2_s:
 641       case Xtank_2_w:
 642         ply->anim = PLY_walk_n + anim;
 643         ply->x = x;
 644         ply->y = y;
 645         break;
 646
 647       case Xgrass:
 648         cave[x][y] = (dy ? (dy < 0 ? Ygrass_nB : Ygrass_sB) :
 649                       (dx > 0 ? Ygrass_eB : Ygrass_wB));
 650         next[x][y] = Zplayer;
 651         play_element_sound(x, y, SOUND_dirt, Xgrass);
 652         ply->anim = PLY_walk_n + anim;
 653         ply->x = x;
 654         ply->y = y;
 655         break;
 656
 657       case Xdirt:
 658         cave[x][y] = (dy ? (dy < 0 ? Ydirt_nB : Ydirt_sB) :
 659                       (dx > 0 ? Ydirt_eB : Ydirt_wB));
 660         next[x][y] = Zplayer;
 661         play_element_sound(x, y, SOUND_dirt, Xdirt);
 662         ply->anim = PLY_walk_n + anim;
 663         ply->x = x;
 664         ply->y = y;
 665         break;
 666
 667       case Xdiamond:
 668       case Xdiamond_pause:
 669         cave[x][y] = Ydiamond_blank;
 670         next[x][y] = Zplayer;
 671         play_element_sound(x, y, SOUND_collect, element);
 672         lev.score += lev.diamond_score;
 673         lev.gems_needed = lev.gems_needed < 3 ? 0 : lev.gems_needed - 3;
 674         game.snapshot.collected_item = TRUE;
 675         ply->anim = PLY_walk_n + anim;
 676         ply->x = x;
 677         ply->y = y;
 678         break;
 679
 680       case Xemerald:
 681       case Xemerald_pause:
 682         cave[x][y] = Yemerald_blank;
 683         next[x][y] = Zplayer;
 684         play_element_sound(x, y, SOUND_collect, element);
 685         lev.score += lev.emerald_score;
 686         lev.gems_needed = lev.gems_needed < 1 ? 0 : lev.gems_needed - 1;
 687         game.snapshot.collected_item = TRUE;
 688         ply->anim = PLY_walk_n + anim;
 689         ply->x = x;
 690         ply->y = y;
 691         break;
 692
 693       case Xdynamite:
 694         cave[x][y] = Ydynamite_blank;
 695         next[x][y] = Zplayer;
 696         play_element_sound(x, y, SOUND_collect, element);
 697         lev.score += lev.dynamite_score;
 698         ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
 699         ply->anim = PLY_walk_n + anim;
 700         ply->x = x;
 701         ply->y = y;
 702         break;
 703
 704       case Xkey_1:
 705         ply->keys |= 0x01;
 706         cave[x][y] = Ykey_1_blank;
 707         goto key_walk;
 708
 709       case Xkey_2:
 710         ply->keys |= 0x02;
 711         cave[x][y] = Ykey_2_blank;
 712         goto key_walk;
 713
 714       case Xkey_3:
 715         ply->keys |= 0x04;
 716         cave[x][y] = Ykey_3_blank;
 717         goto key_walk;
 718
 719       case Xkey_4:
 720         ply->keys |= 0x08;
 721         cave[x][y] = Ykey_4_blank;
 722         goto key_walk;
 723
 724       case Xkey_5:
 725         ply->keys |= 0x10;
 726         cave[x][y] = Ykey_5_blank;
 727         goto key_walk;
 728
 729       case Xkey_6:
 730         ply->keys |= 0x20;
 731         cave[x][y] = Ykey_6_blank;
 732         goto key_walk;
 733
 734       case Xkey_7:
 735         ply->keys |= 0x40;
 736         cave[x][y] = Ykey_7_blank;
 737         goto key_walk;
 738
 739       case Xkey_8:
 740         ply->keys |= 0x80;
 741         cave[x][y] = Ykey_8_blank;
 742         goto key_walk;
 743
 744       key_walk:
 745
 746         next[x][y] = Zplayer;
 747         play_element_sound(x, y, SOUND_collect, element);
 748         lev.score += lev.key_score;
 749         ply->anim = PLY_walk_n + anim;
 750         ply->x = x;
 751         ply->y = y;
 752         break;
 753
 754       case Xlenses:
 755         cave[x][y] = Ylenses_blank;
 756         next[x][y] = Zplayer;
 757         play_element_sound(x, y, SOUND_collect, element);
 758         lev.score += lev.lenses_score;
 759         lev.lenses_cnt = lev.lenses_time;
 760         ply->anim = PLY_walk_n + anim;
 761         ply->x = x;
 762         ply->y = y;
 763         break;
 764
 765       case Xmagnify:
 766         cave[x][y] = Ymagnify_blank;
 767         next[x][y] = Zplayer;
 768         play_element_sound(x, y, SOUND_collect, element);
 769         lev.score += lev.magnify_score;
 770         lev.magnify_cnt = lev.magnify_time;
 771         ply->anim = PLY_walk_n + anim;
 772         ply->x = x;
 773         ply->y = y;
 774         break;
 775
 776       case Xstone:
 777         if (dy)
 778           break;
 779
 780         switch (cave[x+dx][y])
 781         {
 782           case Xblank:
 783           case Xsplash_e:
 784           case Xsplash_w:
 785           case Xfake_acid_1:
 786           case Xfake_acid_2:
 787           case Xfake_acid_3:
 788           case Xfake_acid_4:
 789           case Xfake_acid_5:
 790           case Xfake_acid_6:
 791           case Xfake_acid_7:
 792           case Xfake_acid_8:
 793             cave[x+dx][y] = dx > 0 ? Ystone_e : Ystone_w;
 794             next[x+dx][y] = Xstone_pause;
 795             goto stone_walk;
 796
 797           case Xacid_1:
 798           case Xacid_2:
 799           case Xacid_3:
 800           case Xacid_4:
 801           case Xacid_5:
 802           case Xacid_6:
 803           case Xacid_7:
 804           case Xacid_8:
 805             if (cave[x+dx+1][y-1] == Xblank)
 806               cave[x+dx+1][y-1] = Xsplash_e;
 807             if (cave[x+dx-1][y-1] == Xblank)
 808               cave[x+dx-1][y-1] = Xsplash_w;
 809             play_element_sound(x, y, SOUND_acid, Xacid_1);
 810
 811           stone_walk:
 812
 813             cave[x][y] = dx > 0 ? Ystone_eB : Ystone_wB;
 814             next[x][y] = Zplayer;
 815             play_element_sound(x, y, SOUND_roll, Xstone);
 816             ply->x = x;
 817             break;
 818         }
 819
 820         ply->anim = PLY_push_n + anim;
 821         break;
 822
 823       case Xbomb:
 824         if (dy)
 825           break;
 826
 827         switch (cave[x+dx][y])
 828         {
 829           case Xblank:
 830           case Xsplash_e:
 831           case Xsplash_w:
 832           case Xfake_acid_1:
 833           case Xfake_acid_2:
 834           case Xfake_acid_3:
 835           case Xfake_acid_4:
 836           case Xfake_acid_5:
 837           case Xfake_acid_6:
 838           case Xfake_acid_7:
 839           case Xfake_acid_8:
 840             cave[x+dx][y] = dx > 0 ? Ybomb_e : Ybomb_w;
 841             next[x+dx][y] = Xbomb_pause;
 842             goto bomb_walk;
 843
 844           case Xacid_1:
 845           case Xacid_2:
 846           case Xacid_3:
 847           case Xacid_4:
 848           case Xacid_5:
 849           case Xacid_6:
 850           case Xacid_7:
 851           case Xacid_8:
 852             if (cave[x+dx+1][y-1] == Xblank)
 853               cave[x+dx+1][y-1] = Xsplash_e;
 854             if (cave[x+dx-1][y-1] == Xblank)
 855               cave[x+dx-1][y-1] = Xsplash_w;
 856             play_element_sound(x, y, SOUND_acid, Xacid_1);
 857
 858           bomb_walk:
 859
 860             cave[x][y] = dx > 0 ? Ybomb_eB : Ybomb_wB;
 861             next[x][y] = Zplayer;
 862             play_element_sound(x, y, SOUND_roll, Xbomb);
 863             ply->x = x;
 864             break;
 865         }
 866
 867         ply->anim = PLY_push_n + anim;
 868         break;
 869
 870       case Xnut:
 871         if (dy)
 872           break;
 873
 874         switch (cave[x+dx][y])
 875         {
 876           case Xblank:
 877           case Xsplash_e:
 878           case Xsplash_w:
 879           case Xfake_acid_1:
 880           case Xfake_acid_2:
 881           case Xfake_acid_3:
 882           case Xfake_acid_4:
 883           case Xfake_acid_5:
 884           case Xfake_acid_6:
 885           case Xfake_acid_7:
 886           case Xfake_acid_8:
 887             cave[x+dx][y] = dx > 0 ? Ynut_e : Ynut_w;
 888             next[x+dx][y] = Xnut_pause;
 889             goto nut_walk;
 890
 891           case Xacid_1:
 892           case Xacid_2:
 893           case Xacid_3:
 894           case Xacid_4:
 895           case Xacid_5:
 896           case Xacid_6:
 897           case Xacid_7:
 898           case Xacid_8:
 899             if (cave[x+dx+1][y-1] == Xblank)
 900               cave[x+dx+1][y-1] = Xsplash_e;
 901             if (cave[x+dx-1][y-1] == Xblank)
 902               cave[x+dx-1][y-1] = Xsplash_w;
 903             play_element_sound(x, y, SOUND_acid, Xacid_1);
 904
 905           nut_walk:
 906
 907             cave[x][y] = dx > 0 ? Ynut_eB : Ynut_wB;
 908             next[x][y] = Zplayer;
 909             play_element_sound(x, y, SOUND_roll, Xnut);
 910             ply->x = x;
 911             break;
 912         }
 913
 914         ply->anim = PLY_push_n + anim;
 915         break;
 916
 917       case Xspring:
 918         if (dy)
 919           break;
 920
 921         switch (cave[x+dx][y])
 922         {
 923           case Xblank:
 924           case Xsplash_e:
 925           case Xsplash_w:
 926           case Xfake_acid_1:
 927           case Xfake_acid_2:
 928           case Xfake_acid_3:
 929           case Xfake_acid_4:
 930           case Xfake_acid_5:
 931           case Xfake_acid_6:
 932           case Xfake_acid_7:
 933           case Xfake_acid_8:
 934             cave[x+dx][y] = dx > 0 ? Yspring_e : Yspring_w;
 935             next[x+dx][y] = dx > 0 ? Xspring_e : Xspring_w;
 936             goto spring_walk;
 937
 938           case Xacid_1:
 939           case Xacid_2:
 940           case Xacid_3:
 941           case Xacid_4:
 942           case Xacid_5:
 943           case Xacid_6:
 944           case Xacid_7:
 945           case Xacid_8:
 946             if (cave[x+dx+1][y-1] == Xblank)
 947               cave[x+dx+1][y-1] = Xsplash_e;
 948             if (cave[x+dx-1][y-1] == Xblank)
 949               cave[x+dx-1][y-1] = Xsplash_w;
 950             play_element_sound(x, y, SOUND_acid, Xacid_1);
 951
 952           spring_walk:
 953
 954             cave[x][y] = dx > 0 ? Yspring_eB : Yspring_wB;
 955             next[x][y] = Zplayer;
 956             play_element_sound(x, y, SOUND_roll, Xspring);
 957             ply->x = x;
 958             break;
 959
 960           case Xalien:
 961           case Xalien_pause:
 962             cave[x][y] = dx > 0 ? Yspring_alien_eB : Yspring_alien_wB;
 963             cave[x+dx][y] = dx > 0 ? Yspring_alien_e : Yspring_alien_w;
 964             next[x][y] = Zplayer;
 965             next[x+dx][y] = dx > 0 ? Xspring_e : Xspring_w;
 966             play_element_sound(x, y, SOUND_slurp, Xalien);
 967             lev.score += lev.slurp_score;
 968             ply->x = x;
 969             break;
 970         }
 971
 972         ply->anim = PLY_push_n + anim;
 973         break;
 974
 975       case Xspring_pause:
 976       case Xstone_pause:
 977       case Xbomb_pause:
 978       case Xnut_pause:
 979       case Xsand_stonein_1:
 980       case Xsand_stonein_2:
 981       case Xsand_stonein_3:
 982       case Xsand_stonein_4:
 983         if (dy)
 984           break;
 985
 986         ply->anim = PLY_push_n + anim;
 987         break;
 988
 989       case Xballoon:
 990         switch (cave[x+dx][y+dy])
 991         {
 992           case Xblank:
 993           case Xsplash_e:
 994           case Xsplash_w:
 995           case Xfake_acid_1:
 996           case Xfake_acid_2:
 997           case Xfake_acid_3:
 998           case Xfake_acid_4:
 999           case Xfake_acid_5:
1000           case Xfake_acid_6:
1001           case Xfake_acid_7:
1002           case Xfake_acid_8:
1003             cave[x+dx][y+dy] = (dy ? (dy < 0 ? Yballoon_n : Yballoon_s) :
1004                                 (dx > 0 ? Yballoon_e : Yballoon_w));
1005             next[x+dx][y+dy] = Xballoon;
1006             goto balloon_walk;
1007
1008           case Xacid_1:
1009           case Xacid_2:
1010           case Xacid_3:
1011           case Xacid_4:
1012           case Xacid_5:
1013           case Xacid_6:
1014           case Xacid_7:
1015           case Xacid_8:
1016             if (cave[x+dx+1][y+dy-1] == Xblank)
1017               cave[x+dx+1][y+dy-1] = Xsplash_e;
1018             if (cave[x+dx-1][y+dy-1] == Xblank)
1019               cave[x+dx-1][y+dy-1] = Xsplash_w;
1020             play_element_sound(x, y, SOUND_acid, Xacid_1);
1021
1022           balloon_walk:
1023
1024             cave[x][y] = (dy ? (dy < 0 ? Yballoon_nB : Yballoon_sB) :
1025                           (dx > 0 ? Yballoon_eB : Yballoon_wB));
1026             next[x][y] = Zplayer;
1027             play_element_sound(x, y, SOUND_push, Xballoon);
1028             ply->x = x;
1029             ply->y = y;
1030             break;
1031         }
1032
1033         ply->anim = PLY_push_n + anim;
1034         break;
1035
1036       case Xandroid:
1037       case Xandroid_1_n:
1038       case Xandroid_2_n:
1039       case Xandroid_1_e:
1040       case Xandroid_2_e:
1041       case Xandroid_1_s:
1042       case Xandroid_2_s:
1043       case Xandroid_1_w:
1044       case Xandroid_2_w:
1045         switch (cave[x+dx][y+dy])
1046         {
1047           case Xblank:
1048           case Xsplash_e:
1049           case Xsplash_w:
1050           case Xfake_acid_1:
1051           case Xfake_acid_2:
1052           case Xfake_acid_3:
1053           case Xfake_acid_4:
1054           case Xfake_acid_5:
1055           case Xfake_acid_6:
1056           case Xfake_acid_7:
1057           case Xfake_acid_8:
1058             cave[x+dx][y+dy] = (dy ? (dy < 0 ? Yandroid_n : Yandroid_s) :
1059                                 (dx > 0 ? Yandroid_e : Yandroid_w));
1060             next[x+dx][y+dy] = (dy ? (dy < 0 ? Xandroid_2_n : Xandroid_2_s) :
1061                                 (dx > 0 ? Xandroid_2_e : Xandroid_2_w));
1062             goto android_walk;
1063
1064           case Xacid_1:
1065           case Xacid_2:
1066           case Xacid_3:
1067           case Xacid_4:
1068           case Xacid_5:
1069           case Xacid_6:
1070           case Xacid_7:
1071           case Xacid_8:
1072             if (cave[x+dx+1][y+dy-1] == Xblank)
1073               cave[x+dx+1][y+dy-1] = Xsplash_e;
1074             if (cave[x+dx-1][y+dy-1] == Xblank)
1075               cave[x+dx-1][y+dy-1] = Xsplash_w;
1076             play_element_sound(x, y, SOUND_acid, Xacid_1);
1077
1078           android_walk:
1079
1080             cave[x][y] = (dy ? (dy < 0 ? Yandroid_nB : Yandroid_sB) :
1081                           (dx > 0 ? Yandroid_eB : Yandroid_wB));
1082             next[x][y] = Zplayer;
1083             play_element_sound(x, y, SOUND_push, Xandroid);
1084             ply->x = x;
1085             ply->y = y;
1086             break;
1087         }
1088
1089         ply->anim = PLY_push_n + anim;
1090         break;
1091
1092       case Xdoor_1:
1093       case Xfake_door_1:
1094         if (ply->keys & 0x01)
1095           goto door_walk;
1096         else
1097           break;
1098
1099       case Xdoor_2:
1100       case Xfake_door_2:
1101         if (ply->keys & 0x02)
1102           goto door_walk;
1103         else
1104           break;
1105
1106       case Xdoor_3:
1107       case Xfake_door_3:
1108         if (ply->keys & 0x04)
1109           goto door_walk;
1110         else
1111           break;
1112
1113       case Xdoor_4:
1114       case Xfake_door_4:
1115         if (ply->keys & 0x08)
1116           goto door_walk;
1117         else
1118           break;
1119
1120       case Xdoor_5:
1121       case Xfake_door_5:
1122         if (ply->keys & 0x10)
1123           goto door_walk;
1124         else
1125           break;
1126
1127       case Xdoor_6:
1128       case Xfake_door_6:
1129         if (ply->keys & 0x20)
1130           goto door_walk;
1131         else
1132           break;
1133
1134       case Xdoor_7:
1135       case Xfake_door_7:
1136         if (ply->keys & 0x40)
1137           goto door_walk;
1138         else
1139           break;
1140
1141       case Xdoor_8:
1142       case Xfake_door_8:
1143         if (ply->keys & 0x80)
1144           goto door_walk;
1145         else
1146           break;
1147
1148       door_walk:
1149
1150         if (!is_blank[cave[x+dx][y+dy]])
1151           break;
1152
1153         int element_next = cave[x+dx][y+dy];
1154
1155         cave[x+dx][y+dy] = add_player[element_next];
1156         next[x+dx][y+dy] = add_player[element_next];
1157
1158         play_element_sound(x, y, SOUND_door, element);
1159         ply->anim = PLY_walk_n + anim;
1160         ply->x = x + dx;
1161         ply->y = y + dy;
1162         break;
1163
1164       case Xwheel:
1165         play_element_sound(x, y, SOUND_press, element);
1166         lev.wheel_cnt = lev.wheel_time;
1167         lev.wheel_x = x;
1168         lev.wheel_y = y;
1169         break;
1170
1171       case Xwind_n:
1172         lev.wind_direction = 0;
1173         goto wind_walk;
1174
1175       case Xwind_e:
1176         lev.wind_direction = 1;
1177         goto wind_walk;
1178
1179       case Xwind_s:
1180         lev.wind_direction = 2;
1181         goto wind_walk;
1182
1183       case Xwind_w:
1184         lev.wind_direction = 3;
1185         goto wind_walk;
1186
1187       case Xwind_any:
1188         lev.wind_direction = dy ? (dy < 0 ? 0 : 2) : (dx > 0 ? 1 : 3);
1189         goto wind_walk;
1190
1191       wind_walk:
1192
1193         play_element_sound(x, y, SOUND_press, element);
1194         lev.wind_cnt = lev.wind_time;
1195         break;
1196
1197       case Xwind_stop:
1198         play_element_sound(x, y, SOUND_press, element);
1199         lev.wind_cnt = 0;
1200         break;
1201
1202       case Xswitch:
1203         play_element_sound(x, y, SOUND_press, element);
1204         lev.ball_cnt = lev.ball_time;
1205         lev.ball_active = !lev.ball_active;
1206         break;
1207
1208       case Xplant:
1209         cave[x][y] = Yplant;
1210         next[x][y] = Xplant;
1211         play_element_sound(x, y, SOUND_blank, Xplant);
1212         ply->anim = PLY_walk_n + anim;
1213         ply->x = x;
1214         ply->y = y;
1215         break;
1216
1217       case Xexit_1:
1218       case Xexit_2:
1219       case Xexit_3:
1220         lev.home--;
1221
1222         if (lev.home == 0)
1223           game_em.level_solved = TRUE;
1224
1225         ply->anim = PLY_walk_n + anim;
1226         ply->x = x;
1227         ply->y = y;
1228
1229         break;
1230     }
1231
1232     if (ply->x == oldx && ply->y == oldy)       /* no movement */
1233       result = FALSE;
1234   }
1235   else                                  /* player wants to snap */
1236   {
1237     int element = cave[x][y];
1238
1239     switch (cave[x][y])
1240     {
1241       /* fire is pressed */
1242
1243       case Xgrass:
1244         cave[x][y] = Ygrass_blank;
1245         next[x][y] = Xblank;
1246         play_element_sound(x, y, SOUND_dirt, element);
1247         ply->anim = PLY_shoot_n + anim;
1248         break;
1249
1250       case Xdirt:
1251         cave[x][y] = Ydirt_blank;
1252         next[x][y] = Xblank;
1253         play_element_sound(x, y, SOUND_dirt, element);
1254         ply->anim = PLY_shoot_n + anim;
1255         break;
1256
1257       case Xdiamond:
1258       case Xdiamond_pause:
1259         cave[x][y] = Ydiamond_blank;
1260         next[x][y] = Xblank;
1261         play_element_sound(x, y, SOUND_collect, element);
1262         lev.score += lev.diamond_score;
1263         lev.gems_needed = lev.gems_needed < 3 ? 0 : lev.gems_needed - 3;
1264         game.snapshot.collected_item = TRUE;
1265         ply->anim = PLY_walk_n + anim;
1266         break;
1267
1268       case Xemerald:
1269       case Xemerald_pause:
1270         cave[x][y] = Yemerald_blank;
1271         next[x][y] = Xblank;
1272         play_element_sound(x, y, SOUND_collect, element);
1273         lev.score += lev.emerald_score;
1274         lev.gems_needed = lev.gems_needed < 1 ? 0 : lev.gems_needed - 1;
1275         game.snapshot.collected_item = TRUE;
1276         ply->anim = PLY_walk_n + anim;
1277         break;
1278
1279       case Xdynamite:
1280         cave[x][y] = Ydynamite_blank;
1281         next[x][y] = Xblank;
1282         play_element_sound(x, y, SOUND_collect, element);
1283         lev.score += lev.dynamite_score;
1284         ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
1285         ply->anim = PLY_walk_n + anim;
1286         break;
1287
1288       case Xkey_1:
1289         ply->keys |= 0x01;
1290         cave[x][y] = Ykey_1_blank;
1291         goto key_shoot;
1292
1293       case Xkey_2:
1294         ply->keys |= 0x02;
1295         cave[x][y] = Ykey_2_blank;
1296         goto key_shoot;
1297
1298       case Xkey_3:
1299         ply->keys |= 0x04;
1300         cave[x][y] = Ykey_3_blank;
1301         goto key_shoot;
1302
1303       case Xkey_4:
1304         ply->keys |= 0x08;
1305         cave[x][y] = Ykey_4_blank;
1306         goto key_shoot;
1307
1308       case Xkey_5:
1309         ply->keys |= 0x10;
1310         cave[x][y] = Ykey_5_blank;
1311         goto key_shoot;
1312
1313       case Xkey_6:
1314         ply->keys |= 0x20;
1315         cave[x][y] = Ykey_6_blank;
1316         goto key_shoot;
1317
1318       case Xkey_7:
1319         ply->keys |= 0x40;
1320         cave[x][y] = Ykey_7_blank;
1321         goto key_shoot;
1322
1323       case Xkey_8:
1324         ply->keys |= 0x80;
1325         cave[x][y] = Ykey_8_blank;
1326         goto key_shoot;
1327
1328       key_shoot:
1329
1330         next[x][y] = Xblank;
1331         play_element_sound(x, y, SOUND_collect, element);
1332         lev.score += lev.key_score;
1333         ply->anim = PLY_walk_n + anim;
1334         break;
1335
1336       case Xlenses:
1337         cave[x][y] = Ylenses_blank;
1338         next[x][y] = Xblank;
1339         play_element_sound(x, y, SOUND_collect, element);
1340         lev.score += lev.lenses_score;
1341         lev.lenses_cnt = lev.lenses_time;
1342         ply->anim = PLY_walk_n + anim;
1343         break;
1344
1345       case Xmagnify:
1346         cave[x][y] = Ymagnify_blank;
1347         next[x][y] = Xblank;
1348         play_element_sound(x, y, SOUND_collect, element);
1349         lev.score += lev.magnify_score;
1350         lev.magnify_cnt = lev.magnify_time;
1351         ply->anim = PLY_walk_n + anim;
1352         break;
1353
1354       default:
1355         result = FALSE;
1356     }
1357   }
1358
1359   /* check for wrap-around movement */
1360   if (ply->x < lev.left ||
1361       ply->x > lev.right - 1)
1362     play_element_sound(oldx, oldy, SOUND_door, Xdoor_1);
1363
1364   return result;
1365 }
1366
1367 static void check_player(struct PLAYER *ply)
1368 {
1369   int oldx = ply->x;
1370   int oldy = ply->y;
1371   int x = oldx;
1372   int y = oldy;
1373   int dx = 0, dy = 0;
1374
1375   game_em.last_player_direction[ply->num] = MV_NONE;
1376
1377   if (ply->joy_w)               /* west */
1378   {
1379     x--;
1380     dx = -1;
1381   }
1382   else if (ply->joy_e)          /* east */
1383   {
1384     x++;
1385     dx = 1;
1386   }
1387
1388   if (ply->joy_n)               /* north */
1389   {
1390     y--;
1391     dy = -1;
1392   }
1393   else if (ply->joy_s)          /* south */
1394   {
1395     y++;
1396     dy = 1;
1397   }
1398
1399   if (dx || dy)
1400   {
1401     int oldx = ply->x;
1402     int oldy = ply->y;
1403     int x = oldx + dx;
1404     int y = oldy + dy;
1405     boolean players_visible_before_move;
1406     boolean players_visible_after_move;
1407     boolean can_move;
1408
1409     players_visible_before_move = checkIfAllPlayersFitToScreen();
1410
1411     ply->x = x;
1412     ply->y = y;
1413
1414     players_visible_after_move = checkIfAllPlayersFitToScreen();
1415
1416     /*
1417       player is allowed to move only in the following cases:
1418       - it is not needed to display all players (not focussed to all players)
1419       - all players are (still or again) visible after the move
1420       - some players were already outside visible screen area before the move
1421     */
1422     can_move = (game.centered_player_nr != -1 ||
1423                 players_visible_after_move ||
1424                 !players_visible_before_move);
1425
1426     ply->x = oldx;
1427     ply->y = oldy;
1428
1429     if (!can_move)
1430     {
1431       ply->joy_n = FALSE;
1432       ply->joy_e = FALSE;
1433       ply->joy_s = FALSE;
1434       ply->joy_w = FALSE;
1435
1436       return;
1437     }
1438   }
1439
1440   if (dx == 0 && dy == 0)
1441   {
1442     ply->joy_stick = FALSE;
1443
1444     if (ply->joy_drop)
1445     {
1446       if (++ply->dynamite_cnt == 5 && ply->dynamite)
1447       {
1448         cave[x][y] = Xdynamite_1;
1449         play_element_sound(x, y, SOUND_dynamite, Xdynamite_1);
1450         ply->dynamite--;
1451       }
1452     }
1453     else
1454     {
1455       ply->dynamite_cnt = 0;
1456     }
1457
1458     /* be a bit more random if the player doesn't move */
1459     game_em.random += 7;
1460
1461     return;
1462   }
1463
1464   ply->joy_stick = TRUE;
1465   ply->joy_n = FALSE;
1466   ply->joy_e = FALSE;
1467   ply->joy_s = FALSE;
1468   ply->joy_w = FALSE;
1469
1470   ply->dynamite_cnt = 0;        /* reset dynamite timer if we move */
1471
1472   if (!ply->joy_snap)           /* player wants to move */
1473   {
1474     boolean moved = FALSE;
1475
1476     if (ply->last_move_dir & MV_HORIZONTAL)
1477     {
1478       if (!(moved = player_digfield(ply, 0, dy)))
1479         moved = player_digfield(ply, dx, 0);
1480     }
1481     else
1482     {
1483       if (!(moved = player_digfield(ply, dx, 0)))
1484         moved = player_digfield(ply, 0, dy);
1485     }
1486
1487     if (moved)
1488     {
1489       if (oldx != ply->x)
1490         ply->last_move_dir = (dx < 0 ? MV_LEFT : MV_RIGHT);
1491       else if (oldy != ply->y)
1492         ply->last_move_dir = (dy < 0 ? MV_UP : MV_DOWN);
1493
1494       game_em.any_player_moving = TRUE;
1495       game_em.last_moving_player = ply->num;
1496       game_em.last_player_direction[ply->num] = ply->last_move_dir;
1497     }
1498   }
1499   else                                  /* player wants to snap */
1500   {
1501     game_em.any_player_snapping = player_digfield(ply, dx, dy);
1502   }
1503 }
1504
1505 static void set_nearest_player_xy(int x, int y, int *dx, int *dy)
1506 {
1507   int distance, distance_shortest = CAVE_WIDTH + CAVE_HEIGHT;
1508   int i;
1509
1510   /* default values if no players are alive anymore */
1511   *dx = 0;
1512   *dy = 0;
1513
1514   for (i = 0; i < MAX_PLAYERS; i++)
1515   {
1516     if (!ply[i].alive)
1517       continue;
1518
1519     distance = ABS(ply[i].x - x) + ABS(ply[i].y - y);
1520
1521     if (distance < distance_shortest)
1522     {
1523       *dx = ply[i].x;
1524       *dy = ply[i].y;
1525
1526       distance_shortest = distance;
1527     }
1528   }
1529 }
1530
1531 static void Lacid_1(int x, int y)
1532 {
1533   next[x][y] = Xacid_2;
1534 }
1535
1536 static void Lacid_2(int x, int y)
1537 {
1538   next[x][y] = Xacid_3;
1539 }
1540
1541 static void Lacid_3(int x, int y)
1542 {
1543   next[x][y] = Xacid_4;
1544 }
1545
1546 static void Lacid_4(int x, int y)
1547 {
1548   next[x][y] = Xacid_5;
1549 }
1550
1551 static void Lacid_5(int x, int y)
1552 {
1553   next[x][y] = Xacid_6;
1554 }
1555
1556 static void Lacid_6(int x, int y)
1557 {
1558   next[x][y] = Xacid_7;
1559 }
1560
1561 static void Lacid_7(int x, int y)
1562 {
1563   next[x][y] = Xacid_8;
1564 }
1565
1566 static void Lacid_8(int x, int y)
1567 {
1568   next[x][y] = Xacid_1;
1569 }
1570
1571 static void Lfake_acid_1(int x, int y)
1572 {
1573   next[x][y] = Xfake_acid_2;
1574 }
1575
1576 static void Lfake_acid_2(int x, int y)
1577 {
1578   next[x][y] = Xfake_acid_3;
1579 }
1580
1581 static void Lfake_acid_3(int x, int y)
1582 {
1583   next[x][y] = Xfake_acid_4;
1584 }
1585
1586 static void Lfake_acid_4(int x, int y)
1587 {
1588   next[x][y] = Xfake_acid_5;
1589 }
1590
1591 static void Lfake_acid_5(int x, int y)
1592 {
1593   next[x][y] = Xfake_acid_6;
1594 }
1595
1596 static void Lfake_acid_6(int x, int y)
1597 {
1598   next[x][y] = Xfake_acid_7;
1599 }
1600
1601 static void Lfake_acid_7(int x, int y)
1602 {
1603   next[x][y] = Xfake_acid_8;
1604 }
1605
1606 static void Lfake_acid_8(int x, int y)
1607 {
1608   next[x][y] = Xfake_acid_1;
1609 }
1610
1611 static void Landroid(int x, int y)
1612 {
1613   int dx, dy, temp;
1614
1615   if (lev.android_clone_cnt == 0)
1616   {
1617     if (!is_android_blank[cave[x-1][y-1]] &&
1618         !is_android_blank[cave[x][y-1]]   &&
1619         !is_android_blank[cave[x+1][y-1]] &&
1620         !is_android_blank[cave[x-1][y]]   &&
1621         !is_android_blank[cave[x+1][y]]   &&
1622         !is_android_blank[cave[x-1][y+1]] &&
1623         !is_android_blank[cave[x][y+1]]   &&
1624         !is_android_blank[cave[x+1][y+1]])
1625       goto android_move;
1626
1627     switch (RANDOM(8))
1628     {
1629       /* randomly find an object to clone */
1630
1631       case 0: /* S,NE,W,NW,SE,E,SW,N */
1632         temp = lev.android_array[cave[x][y+1]];   if (temp != Xblank) break;
1633         temp = lev.android_array[cave[x+1][y-1]]; if (temp != Xblank) break;
1634         temp = lev.android_array[cave[x-1][y]];   if (temp != Xblank) break;
1635         temp = lev.android_array[cave[x-1][y-1]]; if (temp != Xblank) break;
1636         temp = lev.android_array[cave[x+1][y+1]]; if (temp != Xblank) break;
1637         temp = lev.android_array[cave[x+1][y]];   if (temp != Xblank) break;
1638         temp = lev.android_array[cave[x-1][y+1]]; if (temp != Xblank) break;
1639         temp = lev.android_array[cave[x][y-1]];   if (temp != Xblank) break;
1640         goto android_move;
1641
1642       case 1: /* NW,SE,N,S,NE,SW,E,W */
1643         temp = lev.android_array[cave[x-1][y-1]]; if (temp != Xblank) break;
1644         temp = lev.android_array[cave[x+1][y+1]]; if (temp != Xblank) break;
1645         temp = lev.android_array[cave[x][y-1]];   if (temp != Xblank) break;
1646         temp = lev.android_array[cave[x][y+1]];   if (temp != Xblank) break;
1647         temp = lev.android_array[cave[x+1][y-1]]; if (temp != Xblank) break;
1648         temp = lev.android_array[cave[x-1][y+1]]; if (temp != Xblank) break;
1649         temp = lev.android_array[cave[x+1][y]];   if (temp != Xblank) break;
1650         temp = lev.android_array[cave[x-1][y]];   if (temp != Xblank) break;
1651         goto android_move;
1652
1653       case 2: /* SW,E,S,W,N,NW,SE,NE */
1654         temp = lev.android_array[cave[x-1][y+1]]; if (temp != Xblank) break;
1655         temp = lev.android_array[cave[x+1][y]];   if (temp != Xblank) break;
1656         temp = lev.android_array[cave[x][y+1]];   if (temp != Xblank) break;
1657         temp = lev.android_array[cave[x-1][y]];   if (temp != Xblank) break;
1658         temp = lev.android_array[cave[x][y-1]];   if (temp != Xblank) break;
1659         temp = lev.android_array[cave[x-1][y-1]]; if (temp != Xblank) break;
1660         temp = lev.android_array[cave[x+1][y+1]]; if (temp != Xblank) break;
1661         temp = lev.android_array[cave[x+1][y-1]]; if (temp != Xblank) break;
1662         goto android_move;
1663
1664       case 3: /* N,SE,NE,E,W,S,NW,SW */
1665         temp = lev.android_array[cave[x][y-1]];   if (temp != Xblank) break;
1666         temp = lev.android_array[cave[x+1][y+1]]; if (temp != Xblank) break;
1667         temp = lev.android_array[cave[x+1][y-1]]; if (temp != Xblank) break;
1668         temp = lev.android_array[cave[x+1][y]];   if (temp != Xblank) break;
1669         temp = lev.android_array[cave[x-1][y]];   if (temp != Xblank) break;
1670         temp = lev.android_array[cave[x][y+1]];   if (temp != Xblank) break;
1671         temp = lev.android_array[cave[x-1][y-1]]; if (temp != Xblank) break;
1672         temp = lev.android_array[cave[x-1][y+1]]; if (temp != Xblank) break;
1673         goto android_move;
1674
1675       case 4: /* SE,NW,E,NE,SW,W,N,S */
1676         temp = lev.android_array[cave[x+1][y+1]]; if (temp != Xblank) break;
1677         temp = lev.android_array[cave[x-1][y-1]]; if (temp != Xblank) break;
1678         temp = lev.android_array[cave[x+1][y]];   if (temp != Xblank) break;
1679         temp = lev.android_array[cave[x+1][y-1]]; if (temp != Xblank) break;
1680         temp = lev.android_array[cave[x-1][y+1]]; if (temp != Xblank) break;
1681         temp = lev.android_array[cave[x-1][y]];   if (temp != Xblank) break;
1682         temp = lev.android_array[cave[x][y-1]];   if (temp != Xblank) break;
1683         temp = lev.android_array[cave[x][y+1]];   if (temp != Xblank) break;
1684         goto android_move;
1685
1686       case 5: /* NE,W,SE,SW,S,N,E,NW */
1687         temp = lev.android_array[cave[x+1][y-1]]; if (temp != Xblank) break;
1688         temp = lev.android_array[cave[x-1][y]];   if (temp != Xblank) break;
1689         temp = lev.android_array[cave[x+1][y+1]]; if (temp != Xblank) break;
1690         temp = lev.android_array[cave[x-1][y+1]]; if (temp != Xblank) break;
1691         temp = lev.android_array[cave[x][y+1]];   if (temp != Xblank) break;
1692         temp = lev.android_array[cave[x][y-1]];   if (temp != Xblank) break;
1693         temp = lev.android_array[cave[x+1][y]];   if (temp != Xblank) break;
1694         temp = lev.android_array[cave[x-1][y-1]]; if (temp != Xblank) break;
1695         goto android_move;
1696
1697       case 6: /* E,N,SW,S,NW,NE,SE,W */
1698         temp = lev.android_array[cave[x+1][y]];   if (temp != Xblank) break;
1699         temp = lev.android_array[cave[x][y-1]];   if (temp != Xblank) break;
1700         temp = lev.android_array[cave[x-1][y+1]]; if (temp != Xblank) break;
1701         temp = lev.android_array[cave[x][y+1]];   if (temp != Xblank) break;
1702         temp = lev.android_array[cave[x-1][y-1]]; if (temp != Xblank) break;
1703         temp = lev.android_array[cave[x+1][y-1]]; if (temp != Xblank) break;
1704         temp = lev.android_array[cave[x+1][y+1]]; if (temp != Xblank) break;
1705         temp = lev.android_array[cave[x-1][y]];   if (temp != Xblank) break;
1706         goto android_move;
1707
1708       case 7: /* W,SW,NW,N,E,SE,NE,S */
1709         temp = lev.android_array[cave[x-1][y]];   if (temp != Xblank) break;
1710         temp = lev.android_array[cave[x-1][y+1]]; if (temp != Xblank) break;
1711         temp = lev.android_array[cave[x-1][y-1]]; if (temp != Xblank) break;
1712         temp = lev.android_array[cave[x][y-1]];   if (temp != Xblank) break;
1713         temp = lev.android_array[cave[x+1][y]];   if (temp != Xblank) break;
1714         temp = lev.android_array[cave[x+1][y+1]]; if (temp != Xblank) break;
1715         temp = lev.android_array[cave[x+1][y-1]]; if (temp != Xblank) break;
1716         temp = lev.android_array[cave[x][y+1]];   if (temp != Xblank) break;
1717         goto android_move;
1718     }
1719
1720     next[x][y] = temp;  /* the item we chose to clone */
1721     play_element_sound(x, y, SOUND_android_clone, temp);
1722
1723     switch (RANDOM(8))
1724     {
1725       /* randomly find a direction to move */
1726
1727       case 0: /* S,NE,W,NW,SE,E,SW,N */
1728         if (is_android_blank[cave[x][y+1]])   goto android_s;
1729         if (is_android_blank[cave[x+1][y-1]]) goto android_ne;
1730         if (is_android_blank[cave[x-1][y]])   goto android_w;
1731         if (is_android_blank[cave[x-1][y-1]]) goto android_nw;
1732         if (is_android_blank[cave[x+1][y+1]]) goto android_se;
1733         if (is_android_blank[cave[x+1][y]])   goto android_e;
1734         if (is_android_blank[cave[x-1][y+1]]) goto android_sw;
1735         if (is_android_blank[cave[x][y-1]])   goto android_n;
1736         goto android_move;
1737
1738       case 1: /* NW,SE,N,S,NE,SW,E,W */
1739         if (is_android_blank[cave[x-1][y-1]]) goto android_nw;
1740         if (is_android_blank[cave[x+1][y+1]]) goto android_se;
1741         if (is_android_blank[cave[x][y-1]])   goto android_n;
1742         if (is_android_blank[cave[x][y+1]])   goto android_s;
1743         if (is_android_blank[cave[x+1][y-1]]) goto android_ne;
1744         if (is_android_blank[cave[x-1][y+1]]) goto android_sw;
1745         if (is_android_blank[cave[x+1][y]])   goto android_e;
1746         if (is_android_blank[cave[x-1][y]])   goto android_w;
1747         goto android_move;
1748
1749       case 2: /* SW,E,S,W,N,NW,SE,NE */
1750         if (is_android_blank[cave[x-1][y+1]]) goto android_sw;
1751         if (is_android_blank[cave[x+1][y]])   goto android_e;
1752         if (is_android_blank[cave[x][y+1]])   goto android_s;
1753         if (is_android_blank[cave[x-1][y]])   goto android_w;
1754         if (is_android_blank[cave[x][y-1]])   goto android_n;
1755         if (is_android_blank[cave[x-1][y-1]]) goto android_nw;
1756         if (is_android_blank[cave[x+1][y+1]]) goto android_se;
1757         if (is_android_blank[cave[x+1][y-1]]) goto android_ne;
1758         goto android_move;
1759
1760       case 3: /* N,SE,NE,E,W,S,NW,SW */
1761         if (is_android_blank[cave[x][y-1]])   goto android_n;
1762         if (is_android_blank[cave[x+1][y+1]]) goto android_se;
1763         if (is_android_blank[cave[x+1][y-1]]) goto android_ne;
1764         if (is_android_blank[cave[x+1][y]])   goto android_e;
1765         if (is_android_blank[cave[x-1][y]])   goto android_w;
1766         if (is_android_blank[cave[x][y+1]])   goto android_s;
1767         if (is_android_blank[cave[x-1][y-1]]) goto android_nw;
1768         if (is_android_blank[cave[x-1][y+1]]) goto android_sw;
1769         goto android_move;
1770
1771       case 4: /* SE,NW,E,NE,SW,W,N,S */
1772         if (is_android_blank[cave[x+1][y+1]]) goto android_se;
1773         if (is_android_blank[cave[x-1][y-1]]) goto android_nw;
1774         if (is_android_blank[cave[x+1][y]])   goto android_e;
1775         if (is_android_blank[cave[x+1][y-1]]) goto android_ne;
1776         if (is_android_blank[cave[x-1][y+1]]) goto android_sw;
1777         if (is_android_blank[cave[x-1][y]])   goto android_w;
1778         if (is_android_blank[cave[x][y-1]])   goto android_n;
1779         if (is_android_blank[cave[x][y+1]])   goto android_s;
1780         goto android_move;
1781
1782       case 5: /* NE,W,SE,SW,S,N,E,NW */
1783         if (is_android_blank[cave[x+1][y-1]]) goto android_ne;
1784         if (is_android_blank[cave[x-1][y]])   goto android_w;
1785         if (is_android_blank[cave[x+1][y+1]]) goto android_se;
1786         if (is_android_blank[cave[x-1][y+1]]) goto android_sw;
1787         if (is_android_blank[cave[x][y+1]])   goto android_s;
1788         if (is_android_blank[cave[x][y-1]])   goto android_n;
1789         if (is_android_blank[cave[x+1][y]])   goto android_e;
1790         if (is_android_blank[cave[x-1][y-1]]) goto android_nw;
1791         goto android_move;
1792
1793       case 6: /* E,N,SW,S,NW,NE,SE,W */
1794         if (is_android_blank[cave[x+1][y]])   goto android_e;
1795         if (is_android_blank[cave[x][y-1]])   goto android_n;
1796         if (is_android_blank[cave[x-1][y+1]]) goto android_sw;
1797         if (is_android_blank[cave[x][y+1]])   goto android_s;
1798         if (is_android_blank[cave[x-1][y-1]]) goto android_nw;
1799         if (is_android_blank[cave[x+1][y-1]]) goto android_ne;
1800         if (is_android_blank[cave[x+1][y+1]]) goto android_se;
1801         if (is_android_blank[cave[x-1][y]])   goto android_w;
1802         goto android_move;
1803
1804       case 7: /* W,SW,NW,N,E,SE,NE,S */
1805         if (is_android_blank[cave[x-1][y]])   goto android_w;
1806         if (is_android_blank[cave[x-1][y+1]]) goto android_sw;
1807         if (is_android_blank[cave[x-1][y-1]]) goto android_nw;
1808         if (is_android_blank[cave[x][y-1]])   goto android_n;
1809         if (is_android_blank[cave[x+1][y]])   goto android_e;
1810         if (is_android_blank[cave[x+1][y+1]]) goto android_se;
1811         if (is_android_blank[cave[x+1][y-1]]) goto android_ne;
1812         if (is_android_blank[cave[x][y+1]])   goto android_s;
1813         goto android_move;
1814     }
1815   }
1816
1817  android_move:
1818   if (lev.android_move_cnt == 0)
1819   {
1820     if (is_player[cave[x-1][y-1]] ||
1821         is_player[cave[x][y-1]]   ||
1822         is_player[cave[x+1][y-1]] ||
1823         is_player[cave[x-1][y]]   ||
1824         is_player[cave[x+1][y]]   ||
1825         is_player[cave[x-1][y+1]] ||
1826         is_player[cave[x][y+1]]   ||
1827         is_player[cave[x+1][y+1]])
1828       goto android_still;
1829
1830     set_nearest_player_xy(x, y, &dx, &dy);
1831
1832     next[x][y] = Xblank;        /* assume we will move */
1833     temp = ((x < dx) + 1 - (x > dx)) + ((y < dy) + 1 - (y > dy)) * 3;
1834
1835     if (RANDOM(2))
1836     {
1837       switch (temp)
1838       {
1839         /* attempt clockwise move first if direct path is blocked */
1840
1841         case 0: /* north west */
1842           if (is_android_walkable[cave[x-1][y-1]]) goto android_nw;
1843           if (is_android_walkable[cave[x][y-1]])   goto android_n;
1844           if (is_android_walkable[cave[x-1][y]])   goto android_w;
1845           break;
1846
1847         case 1: /* north */
1848           if (is_android_walkable[cave[x][y-1]])   goto android_n;
1849           if (is_android_walkable[cave[x+1][y-1]]) goto android_ne;
1850           if (is_android_walkable[cave[x-1][y-1]]) goto android_nw;
1851           break;
1852
1853         case 2: /* north east */
1854           if (is_android_walkable[cave[x+1][y-1]]) goto android_ne;
1855           if (is_android_walkable[cave[x+1][y]])   goto android_e;
1856           if (is_android_walkable[cave[x][y-1]])   goto android_n;
1857           break;
1858
1859         case 3: /* west */
1860           if (is_android_walkable[cave[x-1][y]])   goto android_w;
1861           if (is_android_walkable[cave[x-1][y-1]]) goto android_nw;
1862           if (is_android_walkable[cave[x-1][y+1]]) goto android_sw;
1863           break;
1864
1865         case 4: /* nowhere */
1866           break;
1867
1868         case 5: /* east */
1869           if (is_android_walkable[cave[x+1][y]])   goto android_e;
1870           if (is_android_walkable[cave[x+1][y+1]]) goto android_se;
1871           if (is_android_walkable[cave[x+1][y-1]]) goto android_ne;
1872           break;
1873
1874         case 6: /* south west */
1875           if (is_android_walkable[cave[x-1][y+1]]) goto android_sw;
1876           if (is_android_walkable[cave[x-1][y]])   goto android_w;
1877           if (is_android_walkable[cave[x][y+1]])   goto android_s;
1878           break;
1879
1880         case 7: /* south */
1881           if (is_android_walkable[cave[x][y+1]])   goto android_s;
1882           if (is_android_walkable[cave[x-1][y+1]]) goto android_sw;
1883           if (is_android_walkable[cave[x+1][y+1]]) goto android_se;
1884           break;
1885
1886         case 8: /* south east */
1887           if (is_android_walkable[cave[x+1][y+1]]) goto android_se;
1888           if (is_android_walkable[cave[x][y+1]])   goto android_s;
1889           if (is_android_walkable[cave[x+1][y]])   goto android_e;
1890           break;
1891       }
1892     }
1893     else
1894     {
1895       switch (temp)
1896       {
1897         /* attempt counterclockwise move first if direct path is blocked */
1898
1899         case 0: /* north west */
1900           if (is_android_walkable[cave[x-1][y-1]]) goto android_nw;
1901           if (is_android_walkable[cave[x-1][y]])   goto android_w;
1902           if (is_android_walkable[cave[x][y-1]])   goto android_n;
1903           break;
1904
1905         case 1: /* north */
1906           if (is_android_walkable[cave[x][y-1]])   goto android_n;
1907           if (is_android_walkable[cave[x-1][y-1]]) goto android_nw;
1908           if (is_android_walkable[cave[x+1][y-1]]) goto android_ne;
1909           break;
1910
1911         case 2: /* north east */
1912           if (is_android_walkable[cave[x+1][y-1]]) goto android_ne;
1913           if (is_android_walkable[cave[x][y-1]])   goto android_n;
1914           if (is_android_walkable[cave[x+1][y]])   goto android_e;
1915           break;
1916
1917         case 3: /* west */
1918           if (is_android_walkable[cave[x-1][y]])   goto android_w;
1919           if (is_android_walkable[cave[x-1][y+1]]) goto android_sw;
1920           if (is_android_walkable[cave[x-1][y-1]]) goto android_nw;
1921           break;
1922
1923         case 4: /* nowhere */
1924           break;
1925
1926         case 5: /* east */
1927           if (is_android_walkable[cave[x+1][y]])   goto android_e;
1928           if (is_android_walkable[cave[x+1][y-1]]) goto android_ne;
1929           if (is_android_walkable[cave[x+1][y+1]]) goto android_se;
1930           break;
1931
1932         case 6: /* south west */
1933           if (is_android_walkable[cave[x-1][y+1]]) goto android_sw;
1934           if (is_android_walkable[cave[x][y+1]])   goto android_s;
1935           if (is_android_walkable[cave[x-1][y]])   goto android_w;
1936           break;
1937
1938         case 7: /* south */
1939           if (is_android_walkable[cave[x][y+1]])   goto android_s;
1940           if (is_android_walkable[cave[x+1][y+1]]) goto android_se;
1941           if (is_android_walkable[cave[x-1][y+1]]) goto android_sw;
1942           break;
1943
1944         case 8: /* south east */
1945           if (is_android_walkable[cave[x+1][y+1]]) goto android_se;
1946           if (is_android_walkable[cave[x+1][y]])   goto android_e;
1947           if (is_android_walkable[cave[x][y+1]])   goto android_s;
1948           break;
1949       }
1950     }
1951   }
1952
1953  android_still:
1954   next[x][y] = Xandroid;
1955   return;
1956
1957  android_n:
1958   cave[x][y] = Yandroid_nB;
1959   cave[x][y-1] = Yandroid_n;
1960   next[x][y-1] = Xandroid;
1961   play_element_sound(x, y, SOUND_android_move, Xandroid);
1962   return;
1963
1964  android_ne:
1965   cave[x][y] = Yandroid_neB;
1966   cave[x+1][y-1] = Yandroid_ne;
1967   next[x+1][y-1] = Xandroid;
1968   play_element_sound(x, y, SOUND_android_move, Xandroid);
1969   return;
1970
1971  android_e:
1972   cave[x][y] = Yandroid_eB;
1973   cave[x+1][y] = Yandroid_e;
1974   next[x+1][y] = Xandroid;
1975   play_element_sound(x, y, SOUND_android_move, Xandroid);
1976   return;
1977
1978  android_se:
1979   cave[x][y] = Yandroid_seB;
1980   cave[x+1][y+1] = Yandroid_se;
1981   next[x+1][y+1] = Xandroid;
1982   play_element_sound(x, y, SOUND_android_move, Xandroid);
1983   return;
1984
1985  android_s:
1986   cave[x][y] = Yandroid_sB;
1987   cave[x][y+1] = Yandroid_s;
1988   next[x][y+1] = Xandroid;
1989   play_element_sound(x, y, SOUND_android_move, Xandroid);
1990   return;
1991
1992  android_sw:
1993   cave[x][y] = Yandroid_swB;
1994   cave[x-1][y+1] = Yandroid_sw;
1995   next[x-1][y+1] = Xandroid;
1996   play_element_sound(x, y, SOUND_android_move, Xandroid);
1997   return;
1998
1999  android_w:
2000   cave[x][y] = Yandroid_wB;
2001   cave[x-1][y] = Yandroid_w;
2002   next[x-1][y] = Xandroid;
2003   play_element_sound(x, y, SOUND_android_move, Xandroid);
2004   return;
2005
2006  android_nw:
2007   cave[x][y] = Yandroid_nwB;
2008   cave[x-1][y-1] = Yandroid_nw;
2009   next[x-1][y-1] = Xandroid;
2010   play_element_sound(x, y, SOUND_android_move, Xandroid);
2011   return;
2012 }
2013
2014 static void Landroid_1_n(int x, int y)
2015 {
2016   switch (cave[x][y-1])
2017   {
2018     case Xblank:
2019     case Xsplash_e:
2020     case Xsplash_w:
2021     case Xfake_acid_1:
2022     case Xfake_acid_2:
2023     case Xfake_acid_3:
2024     case Xfake_acid_4:
2025     case Xfake_acid_5:
2026     case Xfake_acid_6:
2027     case Xfake_acid_7:
2028     case Xfake_acid_8:
2029       cave[x][y] = Yandroid_nB;
2030       next[x][y] = Xblank;
2031       cave[x][y-1] = Yandroid_n;
2032       next[x][y-1] = Xandroid;
2033       play_element_sound(x, y, SOUND_android_move, Xandroid_1_n);
2034       return;
2035
2036     case Xacid_1:
2037     case Xacid_2:
2038     case Xacid_3:
2039     case Xacid_4:
2040     case Xacid_5:
2041     case Xacid_6:
2042     case Xacid_7:
2043     case Xacid_8:
2044       cave[x][y] = Yandroid_nB;
2045       next[x][y] = Xblank;
2046       if (cave[x+1][y-2] == Xblank)
2047         cave[x+1][y-2] = Xsplash_e;
2048       if (cave[x-1][y-2] == Xblank)
2049         cave[x-1][y-2] = Xsplash_w;
2050       play_element_sound(x, y, SOUND_acid, Xacid_1);
2051       return;
2052
2053     default:
2054       Landroid(x, y);
2055       return;
2056   }
2057 }
2058
2059 static void Landroid_2_n(int x, int y)
2060 {
2061   switch (cave[x][y-1])
2062   {
2063     case Xblank:
2064     case Xsplash_e:
2065     case Xsplash_w:
2066     case Xfake_acid_1:
2067     case Xfake_acid_2:
2068     case Xfake_acid_3:
2069     case Xfake_acid_4:
2070     case Xfake_acid_5:
2071     case Xfake_acid_6:
2072     case Xfake_acid_7:
2073     case Xfake_acid_8:
2074       cave[x][y] = Yandroid_nB;
2075       next[x][y] = Xblank;
2076       cave[x][y-1] = Yandroid_n;
2077       next[x][y-1] = Xandroid_1_n;
2078       play_element_sound(x, y, SOUND_android_move, Xandroid_2_n);
2079       return;
2080
2081     case Xacid_1:
2082     case Xacid_2:
2083     case Xacid_3:
2084     case Xacid_4:
2085     case Xacid_5:
2086     case Xacid_6:
2087     case Xacid_7:
2088     case Xacid_8:
2089       cave[x][y] = Yandroid_nB;
2090       next[x][y] = Xblank;
2091       if (cave[x+1][y-2] == Xblank)
2092         cave[x+1][y-2] = Xsplash_e;
2093       if (cave[x-1][y-2] == Xblank)
2094         cave[x-1][y-2] = Xsplash_w;
2095       play_element_sound(x, y, SOUND_acid, Xacid_1);
2096       return;
2097
2098     default:
2099       Landroid(x, y);
2100       return;
2101   }
2102 }
2103
2104 static void Landroid_1_e(int x, int y)
2105 {
2106   switch (cave[x+1][y])
2107   {
2108     case Xblank:
2109     case Xsplash_e:
2110     case Xsplash_w:
2111     case Xfake_acid_1:
2112     case Xfake_acid_2:
2113     case Xfake_acid_3:
2114     case Xfake_acid_4:
2115     case Xfake_acid_5:
2116     case Xfake_acid_6:
2117     case Xfake_acid_7:
2118     case Xfake_acid_8:
2119       cave[x][y] = Yandroid_eB;
2120       next[x][y] = Xblank;
2121       cave[x+1][y] = Yandroid_e;
2122       next[x+1][y] = Xandroid;
2123       play_element_sound(x, y, SOUND_android_move, Xandroid_1_e);
2124       return;
2125
2126     case Xacid_1:
2127     case Xacid_2:
2128     case Xacid_3:
2129     case Xacid_4:
2130     case Xacid_5:
2131     case Xacid_6:
2132     case Xacid_7:
2133     case Xacid_8:
2134       cave[x][y] = Yandroid_eB;
2135       next[x][y] = Xblank;
2136       if (cave[x+2][y-1] == Xblank)
2137         cave[x+2][y-1] = Xsplash_e;
2138       if (cave[x][y-1] == Xblank)
2139         cave[x][y-1] = Xsplash_w;
2140       play_element_sound(x, y, SOUND_acid, Xacid_1);
2141       return;
2142
2143     default:
2144       Landroid(x, y);
2145       return;
2146   }
2147 }
2148
2149 static void Landroid_2_e(int x, int y)
2150 {
2151   switch (cave[x+1][y])
2152   {
2153     case Xblank:
2154     case Xsplash_e:
2155     case Xsplash_w:
2156     case Xfake_acid_1:
2157     case Xfake_acid_2:
2158     case Xfake_acid_3:
2159     case Xfake_acid_4:
2160     case Xfake_acid_5:
2161     case Xfake_acid_6:
2162     case Xfake_acid_7:
2163     case Xfake_acid_8:
2164       cave[x][y] = Yandroid_eB;
2165       next[x][y] = Xblank;
2166       cave[x+1][y] = Yandroid_e;
2167       next[x+1][y] = Xandroid_1_e;
2168       play_element_sound(x, y, SOUND_android_move, Xandroid_2_e);
2169       return;
2170
2171     case Xacid_1:
2172     case Xacid_2:
2173     case Xacid_3:
2174     case Xacid_4:
2175     case Xacid_5:
2176     case Xacid_6:
2177     case Xacid_7:
2178     case Xacid_8:
2179       cave[x][y] = Yandroid_eB;
2180       next[x][y] = Xblank;
2181       if (cave[x+2][y-1] == Xblank)
2182         cave[x+2][y-1] = Xsplash_e;
2183       if (cave[x][y-1] == Xblank)
2184         cave[x][y-1] = Xsplash_w;
2185       play_element_sound(x, y, SOUND_acid, Xacid_1);
2186       return;
2187
2188     default:
2189       Landroid(x, y);
2190       return;
2191   }
2192 }
2193
2194 static void Landroid_1_s(int x, int y)
2195 {
2196   switch (cave[x][y+1])
2197   {
2198     case Xblank:
2199     case Xsplash_e:
2200     case Xsplash_w:
2201     case Xfake_acid_1:
2202     case Xfake_acid_2:
2203     case Xfake_acid_3:
2204     case Xfake_acid_4:
2205     case Xfake_acid_5:
2206     case Xfake_acid_6:
2207     case Xfake_acid_7:
2208     case Xfake_acid_8:
2209       cave[x][y] = Yandroid_sB;
2210       next[x][y] = Xblank;
2211       cave[x][y+1] = Yandroid_s;
2212       next[x][y+1] = Xandroid;
2213       play_element_sound(x, y, SOUND_android_move, Xandroid_1_s);
2214       return;
2215
2216     case Xacid_1:
2217     case Xacid_2:
2218     case Xacid_3:
2219     case Xacid_4:
2220     case Xacid_5:
2221     case Xacid_6:
2222     case Xacid_7:
2223     case Xacid_8:
2224       cave[x][y] = Yandroid_sB;
2225       next[x][y] = Xblank;
2226       if (cave[x+1][y] == Xblank)
2227         cave[x+1][y] = Xsplash_e;
2228       if (cave[x-1][y] == Xblank)
2229         cave[x-1][y] = Xsplash_w;
2230       play_element_sound(x, y, SOUND_acid, Xacid_1);
2231       return;
2232
2233     default:
2234       Landroid(x, y);
2235       return;
2236   }
2237 }
2238
2239 static void Landroid_2_s(int x, int y)
2240 {
2241   switch (cave[x][y+1])
2242   {
2243     case Xblank:
2244     case Xsplash_e:
2245     case Xsplash_w:
2246     case Xfake_acid_1:
2247     case Xfake_acid_2:
2248     case Xfake_acid_3:
2249     case Xfake_acid_4:
2250     case Xfake_acid_5:
2251     case Xfake_acid_6:
2252     case Xfake_acid_7:
2253     case Xfake_acid_8:
2254       cave[x][y] = Yandroid_sB;
2255       next[x][y] = Xblank;
2256       cave[x][y+1] = Yandroid_s;
2257       next[x][y+1] = Xandroid_1_s;
2258       play_element_sound(x, y, SOUND_android_move, Xandroid_2_s);
2259       return;
2260
2261     case Xacid_1:
2262     case Xacid_2:
2263     case Xacid_3:
2264     case Xacid_4:
2265     case Xacid_5:
2266     case Xacid_6:
2267     case Xacid_7:
2268     case Xacid_8:
2269       cave[x][y] = Yandroid_sB;
2270       next[x][y] = Xblank;
2271       if (cave[x+1][y] == Xblank)
2272         cave[x+1][y] = Xsplash_e;
2273       if (cave[x-1][y] == Xblank)
2274         cave[x-1][y] = Xsplash_w;
2275       play_element_sound(x, y, SOUND_acid, Xacid_1);
2276       return;
2277
2278     default:
2279       Landroid(x, y);
2280       return;
2281   }
2282 }
2283
2284 static void Landroid_1_w(int x, int y)
2285 {
2286   switch (cave[x-1][y])
2287   {
2288     case Xblank:
2289     case Xsplash_e:
2290     case Xsplash_w:
2291     case Xfake_acid_1:
2292     case Xfake_acid_2:
2293     case Xfake_acid_3:
2294     case Xfake_acid_4:
2295     case Xfake_acid_5:
2296     case Xfake_acid_6:
2297     case Xfake_acid_7:
2298     case Xfake_acid_8:
2299       cave[x][y] = Yandroid_wB;
2300       next[x][y] = Xblank;
2301       cave[x-1][y] = Yandroid_w;
2302       next[x-1][y] = Xandroid;
2303       play_element_sound(x, y, SOUND_android_move, Xandroid_1_w);
2304       return;
2305
2306     case Xacid_1:
2307     case Xacid_2:
2308     case Xacid_3:
2309     case Xacid_4:
2310     case Xacid_5:
2311     case Xacid_6:
2312     case Xacid_7:
2313     case Xacid_8:
2314       cave[x][y] = Yandroid_wB;
2315       next[x][y] = Xblank;
2316       if (cave[x][y-1] == Xblank)
2317         cave[x][y-1] = Xsplash_e;
2318       if (cave[x-2][y-1] == Xblank)
2319         cave[x-2][y-1] = Xsplash_w;
2320       play_element_sound(x, y, SOUND_acid, Xacid_1);
2321       return;
2322
2323     default:
2324       Landroid(x, y);
2325       return;
2326   }
2327 }
2328
2329 static void Landroid_2_w(int x, int y)
2330 {
2331   switch (cave[x-1][y])
2332   {
2333     case Xblank:
2334     case Xsplash_e:
2335     case Xsplash_w:
2336     case Xfake_acid_1:
2337     case Xfake_acid_2:
2338     case Xfake_acid_3:
2339     case Xfake_acid_4:
2340     case Xfake_acid_5:
2341     case Xfake_acid_6:
2342     case Xfake_acid_7:
2343     case Xfake_acid_8:
2344       cave[x][y] = Yandroid_wB;
2345       next[x][y] = Xblank;
2346       cave[x-1][y] = Yandroid_w;
2347       next[x-1][y] = Xandroid_1_w;
2348       play_element_sound(x, y, SOUND_android_move, Xandroid_1_w);
2349       return;
2350
2351     case Xacid_1:
2352     case Xacid_2:
2353     case Xacid_3:
2354     case Xacid_4:
2355     case Xacid_5:
2356     case Xacid_6:
2357     case Xacid_7:
2358     case Xacid_8:
2359       cave[x][y] = Yandroid_wB;
2360       next[x][y] = Xblank;
2361       if (cave[x][y-1] == Xblank)
2362         cave[x][y-1] = Xsplash_e;
2363       if (cave[x-2][y-1] == Xblank)
2364         cave[x-2][y-1] = Xsplash_w;
2365       play_element_sound(x, y, SOUND_acid, Xacid_1);
2366       return;
2367
2368     default:
2369       Landroid(x, y);
2370       return;
2371   }
2372 }
2373
2374 static void Leater_n(int x, int y)
2375 {
2376   if (cave[x+1][y] == Xdiamond)
2377   {
2378     cave[x+1][y] = Ydiamond_blank;
2379     next[x+1][y] = Xblank;
2380     play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
2381     return;
2382   }
2383
2384   if (cave[x][y+1] == Xdiamond)
2385   {
2386     cave[x][y+1] = Ydiamond_blank;
2387     next[x][y+1] = Xblank;
2388     play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
2389     return;
2390   }
2391
2392   if (cave[x-1][y] == Xdiamond)
2393   {
2394     cave[x-1][y] = Ydiamond_blank;
2395     next[x-1][y] = Xblank;
2396     play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
2397     return;
2398   }
2399
2400   if (cave[x][y-1] == Xdiamond)
2401   {
2402     cave[x][y-1] = Ydiamond_blank;
2403     next[x][y-1] = Xblank;
2404     play_element_sound(x, y, SOUND_eater_eat, Xeater_n);
2405     return;
2406   }
2407
2408   switch (cave[x][y-1])
2409   {
2410     case Zplayer:
2411     case Xblank:
2412     case Xsplash_e:
2413     case Xsplash_w:
2414     case Xfake_acid_1:
2415     case Xfake_acid_2:
2416     case Xfake_acid_3:
2417     case Xfake_acid_4:
2418     case Xfake_acid_5:
2419     case Xfake_acid_6:
2420     case Xfake_acid_7:
2421     case Xfake_acid_8:
2422     case Xfake_acid_1_player:
2423     case Xfake_acid_2_player:
2424     case Xfake_acid_3_player:
2425     case Xfake_acid_4_player:
2426     case Xfake_acid_5_player:
2427     case Xfake_acid_6_player:
2428     case Xfake_acid_7_player:
2429     case Xfake_acid_8_player:
2430     case Xplant:
2431     case Yplant:
2432       cave[x][y] = Yeater_nB;
2433       next[x][y] = Xblank;
2434       cave[x][y-1] = Yeater_n;
2435       next[x][y-1] = Xeater_n;
2436       return;
2437
2438     case Xacid_1:
2439     case Xacid_2:
2440     case Xacid_3:
2441     case Xacid_4:
2442     case Xacid_5:
2443     case Xacid_6:
2444     case Xacid_7:
2445     case Xacid_8:
2446       cave[x][y] = Yeater_nB;
2447       next[x][y] = Xblank;
2448       if (cave[x+1][y-2] == Xblank)
2449         cave[x+1][y-2] = Xsplash_e;
2450       if (cave[x-1][y-2] == Xblank)
2451         cave[x-1][y-2] = Xsplash_w;
2452       play_element_sound(x, y, SOUND_acid, Xacid_1);
2453       return;
2454
2455     default:
2456       next[x][y] = RANDOM(2) ? Xeater_e : Xeater_w;
2457       play_element_sound(x, y, SOUND_eater, Xeater_n);
2458       return;
2459   }
2460 }
2461
2462 static void Leater_e(int x, int y)
2463 {
2464   if (cave[x][y+1] == Xdiamond)
2465   {
2466     cave[x][y+1] = Ydiamond_blank;
2467     next[x][y+1] = Xblank;
2468     play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
2469     return;
2470   }
2471
2472   if (cave[x-1][y] == Xdiamond)
2473   {
2474     cave[x-1][y] = Ydiamond_blank;
2475     next[x-1][y] = Xblank;
2476     play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
2477     return;
2478   }
2479
2480   if (cave[x][y-1] == Xdiamond)
2481   {
2482     cave[x][y-1] = Ydiamond_blank;
2483     next[x][y-1] = Xblank;
2484     play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
2485     return;
2486   }
2487
2488   if (cave[x+1][y] == Xdiamond)
2489   {
2490     cave[x+1][y] = Ydiamond_blank;
2491     next[x+1][y] = Xblank;
2492     play_element_sound(x, y, SOUND_eater_eat, Xeater_e);
2493     return;
2494   }
2495
2496   switch (cave[x+1][y])
2497   {
2498     case Zplayer:
2499     case Xblank:
2500     case Xsplash_e:
2501     case Xsplash_w:
2502     case Xfake_acid_1:
2503     case Xfake_acid_2:
2504     case Xfake_acid_3:
2505     case Xfake_acid_4:
2506     case Xfake_acid_5:
2507     case Xfake_acid_6:
2508     case Xfake_acid_7:
2509     case Xfake_acid_8:
2510     case Xfake_acid_1_player:
2511     case Xfake_acid_2_player:
2512     case Xfake_acid_3_player:
2513     case Xfake_acid_4_player:
2514     case Xfake_acid_5_player:
2515     case Xfake_acid_6_player:
2516     case Xfake_acid_7_player:
2517     case Xfake_acid_8_player:
2518     case Xplant:
2519     case Yplant:
2520       cave[x][y] = Yeater_eB;
2521       next[x][y] = Xblank;
2522       cave[x+1][y] = Yeater_e;
2523       next[x+1][y] = Xeater_e;
2524       return;
2525
2526     case Xacid_1:
2527     case Xacid_2:
2528     case Xacid_3:
2529     case Xacid_4:
2530     case Xacid_5:
2531     case Xacid_6:
2532     case Xacid_7:
2533     case Xacid_8:
2534       cave[x][y] = Yeater_eB;
2535       next[x][y] = Xblank;
2536       if (cave[x+2][y-1] == Xblank)
2537         cave[x+2][y-1] = Xsplash_e;
2538       if (cave[x][y-1] == Xblank)
2539         cave[x][y-1] = Xsplash_w;
2540       play_element_sound(x, y, SOUND_acid, Xacid_1);
2541       return;
2542
2543     default:
2544       next[x][y] = RANDOM(2) ? Xeater_n : Xeater_s;
2545       play_element_sound(x, y, SOUND_eater, Xeater_e);
2546       return;
2547   }
2548 }
2549
2550 static void Leater_s(int x, int y)
2551 {
2552   if (cave[x-1][y] == Xdiamond)
2553   {
2554     cave[x-1][y] = Ydiamond_blank;
2555     next[x-1][y] = Xblank;
2556     play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
2557     return;
2558   }
2559
2560   if (cave[x][y-1] == Xdiamond)
2561   {
2562     cave[x][y-1] = Ydiamond_blank;
2563     next[x][y-1] = Xblank;
2564     play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
2565     return;
2566   }
2567
2568   if (cave[x+1][y] == Xdiamond)
2569   {
2570     cave[x+1][y] = Ydiamond_blank;
2571     next[x+1][y] = Xblank;
2572     play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
2573     return;
2574   }
2575
2576   if (cave[x][y+1] == Xdiamond)
2577   {
2578     cave[x][y+1] = Ydiamond_blank;
2579     next[x][y+1] = Xblank;
2580     play_element_sound(x, y, SOUND_eater_eat, Xeater_s);
2581     return;
2582   }
2583
2584   switch (cave[x][y+1])
2585   {
2586     case Zplayer:
2587     case Xblank:
2588     case Xsplash_e:
2589     case Xsplash_w:
2590     case Xfake_acid_1:
2591     case Xfake_acid_2:
2592     case Xfake_acid_3:
2593     case Xfake_acid_4:
2594     case Xfake_acid_5:
2595     case Xfake_acid_6:
2596     case Xfake_acid_7:
2597     case Xfake_acid_8:
2598     case Xfake_acid_1_player:
2599     case Xfake_acid_2_player:
2600     case Xfake_acid_3_player:
2601     case Xfake_acid_4_player:
2602     case Xfake_acid_5_player:
2603     case Xfake_acid_6_player:
2604     case Xfake_acid_7_player:
2605     case Xfake_acid_8_player:
2606     case Xplant:
2607     case Yplant:
2608       cave[x][y] = Yeater_sB;
2609       next[x][y] = Xblank;
2610       cave[x][y+1] = Yeater_s;
2611       next[x][y+1] = Xeater_s;
2612       return;
2613
2614     case Xacid_1:
2615     case Xacid_2:
2616     case Xacid_3:
2617     case Xacid_4:
2618     case Xacid_5:
2619     case Xacid_6:
2620     case Xacid_7:
2621     case Xacid_8:
2622       cave[x][y] = Yeater_sB;
2623       next[x][y] = Xblank;
2624       if (cave[x+1][y] == Xblank)
2625         cave[x+1][y] = Xsplash_e;
2626       if (cave[x-1][y] == Xblank)
2627         cave[x-1][y] = Xsplash_w;
2628       play_element_sound(x, y, SOUND_acid, Xacid_1);
2629       return;
2630
2631     default:
2632       next[x][y] = RANDOM(2) ? Xeater_e : Xeater_w;
2633       play_element_sound(x, y, SOUND_eater, Xeater_s);
2634       return;
2635   }
2636 }
2637
2638 static void Leater_w(int x, int y)
2639 {
2640   if (cave[x][y-1] == Xdiamond)
2641   {
2642     cave[x][y-1] = Ydiamond_blank;
2643     next[x][y-1] = Xblank;
2644     play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
2645     return;
2646   }
2647
2648   if (cave[x+1][y] == Xdiamond)
2649   {
2650     cave[x+1][y] = Ydiamond_blank;
2651     next[x+1][y] = Xblank;
2652     play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
2653     return;
2654   }
2655
2656   if (cave[x][y+1] == Xdiamond)
2657   {
2658     cave[x][y+1] = Ydiamond_blank;
2659     next[x][y+1] = Xblank;
2660     play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
2661     return;
2662   }
2663
2664   if (cave[x-1][y] == Xdiamond)
2665   {
2666     cave[x-1][y] = Ydiamond_blank;
2667     next[x-1][y] = Xblank;
2668     play_element_sound(x, y, SOUND_eater_eat, Xeater_w);
2669     return;
2670   }
2671
2672   switch (cave[x-1][y])
2673   {
2674     case Zplayer:
2675     case Xblank:
2676     case Xsplash_e:
2677     case Xsplash_w:
2678     case Xfake_acid_1:
2679     case Xfake_acid_2:
2680     case Xfake_acid_3:
2681     case Xfake_acid_4:
2682     case Xfake_acid_5:
2683     case Xfake_acid_6:
2684     case Xfake_acid_7:
2685     case Xfake_acid_8:
2686     case Xfake_acid_1_player:
2687     case Xfake_acid_2_player:
2688     case Xfake_acid_3_player:
2689     case Xfake_acid_4_player:
2690     case Xfake_acid_5_player:
2691     case Xfake_acid_6_player:
2692     case Xfake_acid_7_player:
2693     case Xfake_acid_8_player:
2694     case Xplant:
2695     case Yplant:
2696       cave[x][y] = Yeater_wB;
2697       next[x][y] = Xblank;
2698       cave[x-1][y] = Yeater_w;
2699       next[x-1][y] = Xeater_w;
2700       return;
2701
2702     case Xacid_1:
2703     case Xacid_2:
2704     case Xacid_3:
2705     case Xacid_4:
2706     case Xacid_5:
2707     case Xacid_6:
2708     case Xacid_7:
2709     case Xacid_8:
2710       cave[x][y] = Yeater_wB;
2711       next[x][y] = Xblank;
2712       if (cave[x][y-1] == Xblank)
2713         cave[x][y-1] = Xsplash_e;
2714       if (cave[x-2][y-1] == Xblank)
2715         cave[x-2][y-1] = Xsplash_w;
2716       play_element_sound(x, y, SOUND_acid, Xacid_1);
2717       return;
2718
2719     default:
2720       next[x][y] = RANDOM(2) ? Xeater_n : Xeater_s;
2721       play_element_sound(x, y, SOUND_eater, Xeater_w);
2722       return;
2723   }
2724 }
2725
2726 static void Lalien(int x, int y)
2727 {
2728   int dx, dy;
2729
2730   if (lev.wheel_cnt)
2731   {
2732     dx = lev.wheel_x;
2733     dy = lev.wheel_y;
2734   }
2735   else
2736   {
2737     set_nearest_player_xy(x, y, &dx, &dy);
2738   }
2739
2740   if (RANDOM(2))
2741   {
2742     if (y > dy)
2743     {
2744       switch (cave[x][y-1])
2745       {
2746         case Zplayer:
2747         case Xblank:
2748         case Xsplash_e:
2749         case Xsplash_w:
2750         case Xfake_acid_1:
2751         case Xfake_acid_2:
2752         case Xfake_acid_3:
2753         case Xfake_acid_4:
2754         case Xfake_acid_5:
2755         case Xfake_acid_6:
2756         case Xfake_acid_7:
2757         case Xfake_acid_8:
2758         case Xfake_acid_1_player:
2759         case Xfake_acid_2_player:
2760         case Xfake_acid_3_player:
2761         case Xfake_acid_4_player:
2762         case Xfake_acid_5_player:
2763         case Xfake_acid_6_player:
2764         case Xfake_acid_7_player:
2765         case Xfake_acid_8_player:
2766         case Xplant:
2767         case Yplant:
2768           cave[x][y] = Yalien_nB;
2769           next[x][y] = Xblank;
2770           cave[x][y-1] = Yalien_n;
2771           next[x][y-1] = Xalien_pause;
2772           play_element_sound(x, y, SOUND_alien, Xalien);
2773           return;
2774
2775         case Xacid_1:
2776         case Xacid_2:
2777         case Xacid_3:
2778         case Xacid_4:
2779         case Xacid_5:
2780         case Xacid_6:
2781         case Xacid_7:
2782         case Xacid_8:
2783           cave[x][y] = Yalien_nB;
2784           next[x][y] = Xblank;
2785           if (cave[x+1][y-2] == Xblank)
2786             cave[x+1][y-2] = Xsplash_e;
2787           if (cave[x-1][y-2] == Xblank)
2788             cave[x-1][y-2] = Xsplash_w;
2789           play_element_sound(x, y, SOUND_acid, Xacid_1);
2790           return;
2791       }
2792     }
2793     else if (y < dy)
2794     {
2795       switch (cave[x][y+1])
2796       {
2797         case Zplayer:
2798         case Xblank:
2799         case Xsplash_e:
2800         case Xsplash_w:
2801         case Xfake_acid_1:
2802         case Xfake_acid_2:
2803         case Xfake_acid_3:
2804         case Xfake_acid_4:
2805         case Xfake_acid_5:
2806         case Xfake_acid_6:
2807         case Xfake_acid_7:
2808         case Xfake_acid_8:
2809         case Xfake_acid_1_player:
2810         case Xfake_acid_2_player:
2811         case Xfake_acid_3_player:
2812         case Xfake_acid_4_player:
2813         case Xfake_acid_5_player:
2814         case Xfake_acid_6_player:
2815         case Xfake_acid_7_player:
2816         case Xfake_acid_8_player:
2817         case Xplant:
2818         case Yplant:
2819           cave[x][y] = Yalien_sB;
2820           next[x][y] = Xblank;
2821           cave[x][y+1] = Yalien_s;
2822           next[x][y+1] = Xalien_pause;
2823           play_element_sound(x, y, SOUND_alien, Xalien);
2824           return;
2825
2826         case Xacid_1:
2827         case Xacid_2:
2828         case Xacid_3:
2829         case Xacid_4:
2830         case Xacid_5:
2831         case Xacid_6:
2832         case Xacid_7:
2833         case Xacid_8:
2834           cave[x][y] = Yalien_sB;
2835           next[x][y] = Xblank;
2836           if (cave[x+1][y] == Xblank)
2837             cave[x+1][y] = Xsplash_e;
2838           if (cave[x-1][y] == Xblank)
2839             cave[x-1][y] = Xsplash_w;
2840           play_element_sound(x, y, SOUND_acid, Xacid_1);
2841           return;
2842       }
2843     }
2844   }
2845   else
2846   {
2847     if (x < dx)
2848     {
2849       switch (cave[x+1][y])
2850       {
2851         case Zplayer:
2852         case Xblank:
2853         case Xsplash_e:
2854         case Xsplash_w:
2855         case Xfake_acid_1:
2856         case Xfake_acid_2:
2857         case Xfake_acid_3:
2858         case Xfake_acid_4:
2859         case Xfake_acid_5:
2860         case Xfake_acid_6:
2861         case Xfake_acid_7:
2862         case Xfake_acid_8:
2863         case Xfake_acid_1_player:
2864         case Xfake_acid_2_player:
2865         case Xfake_acid_3_player:
2866         case Xfake_acid_4_player:
2867         case Xfake_acid_5_player:
2868         case Xfake_acid_6_player:
2869         case Xfake_acid_7_player:
2870         case Xfake_acid_8_player:
2871         case Xplant:
2872         case Yplant:
2873           cave[x][y] = Yalien_eB;
2874           next[x][y] = Xblank;
2875           cave[x+1][y] = Yalien_e;
2876           next[x+1][y] = Xalien_pause;
2877           play_element_sound(x, y, SOUND_alien, Xalien);
2878           return;
2879
2880         case Xacid_1:
2881         case Xacid_2:
2882         case Xacid_3:
2883         case Xacid_4:
2884         case Xacid_5:
2885         case Xacid_6:
2886         case Xacid_7:
2887         case Xacid_8:
2888           cave[x][y] = Yalien_eB;
2889           next[x][y] = Xblank;
2890           if (cave[x+2][y-1] == Xblank)
2891             cave[x+2][y-1] = Xsplash_e;
2892           if (cave[x][y-1] == Xblank)
2893             cave[x][y-1] = Xsplash_w;
2894           play_element_sound(x, y, SOUND_acid, Xacid_1);
2895           return;
2896       }
2897     }
2898     else if (x > dx)
2899     {
2900       switch (cave[x-1][y])
2901       {
2902         case Zplayer:
2903         case Xblank:
2904         case Xsplash_e:
2905         case Xsplash_w:
2906         case Xfake_acid_1:
2907         case Xfake_acid_2:
2908         case Xfake_acid_3:
2909         case Xfake_acid_4:
2910         case Xfake_acid_5:
2911         case Xfake_acid_6:
2912         case Xfake_acid_7:
2913         case Xfake_acid_8:
2914         case Xfake_acid_1_player:
2915         case Xfake_acid_2_player:
2916         case Xfake_acid_3_player:
2917         case Xfake_acid_4_player:
2918         case Xfake_acid_5_player:
2919         case Xfake_acid_6_player:
2920         case Xfake_acid_7_player:
2921         case Xfake_acid_8_player:
2922         case Xplant:
2923         case Yplant:
2924           cave[x][y] = Yalien_wB;
2925           next[x][y] = Xblank;
2926           cave[x-1][y] = Yalien_w;
2927           next[x-1][y] = Xalien_pause;
2928           play_element_sound(x, y, SOUND_alien, Xalien);
2929           return;
2930
2931         case Xacid_1:
2932         case Xacid_2:
2933         case Xacid_3:
2934         case Xacid_4:
2935         case Xacid_5:
2936         case Xacid_6:
2937         case Xacid_7:
2938         case Xacid_8:
2939           cave[x][y] = Yalien_wB;
2940           next[x][y] = Xblank;
2941           if (cave[x][y-1] == Xblank)
2942             cave[x][y-1] = Xsplash_e;
2943           if (cave[x-2][y-1] == Xblank)
2944             cave[x-2][y-1] = Xsplash_w;
2945           play_element_sound(x, y, SOUND_acid, Xacid_1);
2946           return;
2947       }
2948     }
2949   }
2950 }
2951
2952 static void Lalien_pause(int x, int y)
2953 {
2954   next[x][y] = Xalien;
2955 }
2956
2957 static void Lbug_n(int x, int y)
2958 {
2959   switch (cave[x][y-1])
2960   {
2961     case Zplayer:
2962     case Xblank:
2963     case Xsplash_e:
2964     case Xsplash_w:
2965     case Xfake_acid_1:
2966     case Xfake_acid_2:
2967     case Xfake_acid_3:
2968     case Xfake_acid_4:
2969     case Xfake_acid_5:
2970     case Xfake_acid_6:
2971     case Xfake_acid_7:
2972     case Xfake_acid_8:
2973     case Xfake_acid_1_player:
2974     case Xfake_acid_2_player:
2975     case Xfake_acid_3_player:
2976     case Xfake_acid_4_player:
2977     case Xfake_acid_5_player:
2978     case Xfake_acid_6_player:
2979     case Xfake_acid_7_player:
2980     case Xfake_acid_8_player:
2981     case Xplant:
2982     case Yplant:
2983       cave[x][y] = Ybug_nB;
2984       next[x][y] = Xblank;
2985       cave[x][y-1] = Ybug_n;
2986       next[x][y-1] = Xbug_1_n;
2987       play_element_sound(x, y, SOUND_bug, Xbug_1_n);
2988       return;
2989
2990     case Xacid_1:
2991     case Xacid_2:
2992     case Xacid_3:
2993     case Xacid_4:
2994     case Xacid_5:
2995     case Xacid_6:
2996     case Xacid_7:
2997     case Xacid_8:
2998       cave[x][y] = Ybug_nB;
2999       next[x][y] = Xblank;
3000       if (cave[x+1][y-2] == Xblank)
3001         cave[x+1][y-2] = Xsplash_e;
3002       if (cave[x-1][y-2] == Xblank)
3003         cave[x-1][y-2] = Xsplash_w;
3004       play_element_sound(x, y, SOUND_acid, Xacid_1);
3005       return;
3006
3007     default:
3008       cave[x][y] = Ybug_n_w;
3009       next[x][y] = Xbug_2_w;
3010       play_element_sound(x, y, SOUND_bug, Xbug_1_n);
3011       return;
3012   }
3013 }
3014
3015 static void Lbug_1_n(int x, int y)
3016 {
3017   if (is_amoeba[cave[x][y-1]] ||
3018       is_amoeba[cave[x+1][y]] ||
3019       is_amoeba[cave[x][y+1]] ||
3020       is_amoeba[cave[x-1][y]])
3021   {
3022     next[x][y] = Zboom;
3023     Lboom_bug(x, y);
3024
3025     return;
3026   }
3027
3028   switch (cave[x+1][y])
3029   {
3030     case Zplayer:
3031     case Xblank:
3032     case Xsplash_e:
3033     case Xsplash_w:
3034     case Xfake_acid_1:
3035     case Xfake_acid_2:
3036     case Xfake_acid_3:
3037     case Xfake_acid_4:
3038     case Xfake_acid_5:
3039     case Xfake_acid_6:
3040     case Xfake_acid_7:
3041     case Xfake_acid_8:
3042     case Xfake_acid_1_player:
3043     case Xfake_acid_2_player:
3044     case Xfake_acid_3_player:
3045     case Xfake_acid_4_player:
3046     case Xfake_acid_5_player:
3047     case Xfake_acid_6_player:
3048     case Xfake_acid_7_player:
3049     case Xfake_acid_8_player:
3050     case Xplant:
3051     case Yplant:
3052     case Xacid_1:
3053     case Xacid_2:
3054     case Xacid_3:
3055     case Xacid_4:
3056     case Xacid_5:
3057     case Xacid_6:
3058     case Xacid_7:
3059     case Xacid_8:
3060       cave[x][y] = Ybug_n_e;
3061       next[x][y] = Xbug_2_e;
3062       play_element_sound(x, y, SOUND_bug, Xbug_1_n);
3063       return;
3064
3065     default:
3066       Lbug_n(x, y);
3067       return;
3068   }
3069 }
3070
3071 static void Lbug_2_n(int x, int y)
3072 {
3073   if (is_amoeba[cave[x][y-1]] ||
3074       is_amoeba[cave[x+1][y]] ||
3075       is_amoeba[cave[x][y+1]] ||
3076       is_amoeba[cave[x-1][y]])
3077   {
3078     next[x][y] = Zboom;
3079     Lboom_bug(x, y);
3080
3081     return;
3082   }
3083
3084   Lbug_n(x, y);
3085 }
3086
3087 static void Lbug_e(int x, int y)
3088 {
3089   switch (cave[x+1][y])
3090   {
3091     case Zplayer:
3092     case Xblank:
3093     case Xsplash_e:
3094     case Xsplash_w:
3095     case Xfake_acid_1:
3096     case Xfake_acid_2:
3097     case Xfake_acid_3:
3098     case Xfake_acid_4:
3099     case Xfake_acid_5:
3100     case Xfake_acid_6:
3101     case Xfake_acid_7:
3102     case Xfake_acid_8:
3103     case Xfake_acid_1_player:
3104     case Xfake_acid_2_player:
3105     case Xfake_acid_3_player:
3106     case Xfake_acid_4_player:
3107     case Xfake_acid_5_player:
3108     case Xfake_acid_6_player:
3109     case Xfake_acid_7_player:
3110     case Xfake_acid_8_player:
3111     case Xplant:
3112     case Yplant:
3113       cave[x][y] = Ybug_eB;
3114       next[x][y] = Xblank;
3115       cave[x+1][y] = Ybug_e;
3116       next[x+1][y] = Xbug_1_e;
3117       play_element_sound(x, y, SOUND_bug, Xbug_1_e);
3118       return;
3119
3120     case Xacid_1:
3121     case Xacid_2:
3122     case Xacid_3:
3123     case Xacid_4:
3124     case Xacid_5:
3125     case Xacid_6:
3126     case Xacid_7:
3127     case Xacid_8:
3128       cave[x][y] = Ybug_eB;
3129       next[x][y] = Xblank;
3130       if (cave[x+2][y-1] == Xblank)
3131         cave[x+2][y-1] = Xsplash_e;
3132       if (cave[x][y-1] == Xblank)
3133         cave[x][y-1] = Xsplash_w;
3134       play_element_sound(x, y, SOUND_acid, Xacid_1);
3135       return;
3136
3137     default:
3138       cave[x][y] = Ybug_e_n;
3139       next[x][y] = Xbug_2_n;
3140       play_element_sound(x, y, SOUND_bug, Xbug_1_e);
3141       return;
3142   }
3143 }
3144
3145 static void Lbug_1_e(int x, int y)
3146 {
3147   if (is_amoeba[cave[x][y-1]] ||
3148       is_amoeba[cave[x+1][y]] ||
3149       is_amoeba[cave[x][y+1]] ||
3150       is_amoeba[cave[x-1][y]])
3151   {
3152     next[x][y] = Zboom;
3153     Lboom_bug(x, y);
3154
3155     return;
3156   }
3157
3158   switch (cave[x][y+1])
3159   {
3160     case Zplayer:
3161     case Xblank:
3162     case Xsplash_e:
3163     case Xsplash_w:
3164     case Xfake_acid_1:
3165     case Xfake_acid_2:
3166     case Xfake_acid_3:
3167     case Xfake_acid_4:
3168     case Xfake_acid_5:
3169     case Xfake_acid_6:
3170     case Xfake_acid_7:
3171     case Xfake_acid_8:
3172     case Xfake_acid_1_player:
3173     case Xfake_acid_2_player:
3174     case Xfake_acid_3_player:
3175     case Xfake_acid_4_player:
3176     case Xfake_acid_5_player:
3177     case Xfake_acid_6_player:
3178     case Xfake_acid_7_player:
3179     case Xfake_acid_8_player:
3180     case Xplant:
3181     case Yplant:
3182     case Xacid_1:
3183     case Xacid_2:
3184     case Xacid_3:
3185     case Xacid_4:
3186     case Xacid_5:
3187     case Xacid_6:
3188     case Xacid_7:
3189     case Xacid_8:
3190       cave[x][y] = Ybug_e_s;
3191       next[x][y] = Xbug_2_s;
3192       play_element_sound(x, y, SOUND_bug, Xbug_1_e);
3193       return;
3194
3195     default:
3196       Lbug_e(x, y);
3197       return;
3198   }
3199 }
3200
3201 static void Lbug_2_e(int x, int y)
3202 {
3203   if (is_amoeba[cave[x][y-1]] ||
3204       is_amoeba[cave[x+1][y]] ||
3205       is_amoeba[cave[x][y+1]] ||
3206       is_amoeba[cave[x-1][y]])
3207   {
3208     next[x][y] = Zboom;
3209     Lboom_bug(x, y);
3210
3211     return;
3212   }
3213
3214   Lbug_e(x, y);
3215 }
3216
3217 static void Lbug_s(int x, int y)
3218 {
3219   switch (cave[x][y+1])
3220   {
3221     case Zplayer:
3222     case Xblank:
3223     case Xsplash_e:
3224     case Xsplash_w:
3225     case Xfake_acid_1:
3226     case Xfake_acid_2:
3227     case Xfake_acid_3:
3228     case Xfake_acid_4:
3229     case Xfake_acid_5:
3230     case Xfake_acid_6:
3231     case Xfake_acid_7:
3232     case Xfake_acid_8:
3233     case Xfake_acid_1_player:
3234     case Xfake_acid_2_player:
3235     case Xfake_acid_3_player:
3236     case Xfake_acid_4_player:
3237     case Xfake_acid_5_player:
3238     case Xfake_acid_6_player:
3239     case Xfake_acid_7_player:
3240     case Xfake_acid_8_player:
3241     case Xplant:
3242     case Yplant:
3243       cave[x][y] = Ybug_sB;
3244       next[x][y] = Xblank;
3245       cave[x][y+1] = Ybug_s;
3246       next[x][y+1] = Xbug_1_s;
3247       play_element_sound(x, y, SOUND_bug, Xbug_1_s);
3248       return;
3249
3250     case Xacid_1:
3251     case Xacid_2:
3252     case Xacid_3:
3253     case Xacid_4:
3254     case Xacid_5:
3255     case Xacid_6:
3256     case Xacid_7:
3257     case Xacid_8:
3258       cave[x][y] = Ybug_sB;
3259       next[x][y] = Xblank;
3260       if (cave[x+1][y] == Xblank)
3261         cave[x+1][y] = Xsplash_e;
3262       if (cave[x-1][y] == Xblank)
3263         cave[x-1][y] = Xsplash_w;
3264       play_element_sound(x, y, SOUND_acid, Xacid_1);
3265       return;
3266
3267     default:
3268       cave[x][y] = Ybug_s_e;
3269       next[x][y] = Xbug_2_e;
3270       play_element_sound(x, y, SOUND_bug, Xbug_1_s);
3271       return;
3272   }
3273 }
3274
3275 static void Lbug_1_s(int x, int y)
3276 {
3277   if (is_amoeba[cave[x][y-1]] ||
3278       is_amoeba[cave[x+1][y]] ||
3279       is_amoeba[cave[x][y+1]] ||
3280       is_amoeba[cave[x-1][y]])
3281   {
3282     next[x][y] = Zboom;
3283     Lboom_bug(x, y);
3284
3285     return;
3286   }
3287
3288   switch (cave[x-1][y])
3289   {
3290     case Zplayer:
3291     case Xblank:
3292     case Xsplash_e:
3293     case Xsplash_w:
3294     case Xfake_acid_1:
3295     case Xfake_acid_2:
3296     case Xfake_acid_3:
3297     case Xfake_acid_4:
3298     case Xfake_acid_5:
3299     case Xfake_acid_6:
3300     case Xfake_acid_7:
3301     case Xfake_acid_8:
3302     case Xfake_acid_1_player:
3303     case Xfake_acid_2_player:
3304     case Xfake_acid_3_player:
3305     case Xfake_acid_4_player:
3306     case Xfake_acid_5_player:
3307     case Xfake_acid_6_player:
3308     case Xfake_acid_7_player:
3309     case Xfake_acid_8_player:
3310     case Xplant:
3311     case Yplant:
3312     case Xacid_1:
3313     case Xacid_2:
3314     case Xacid_3:
3315     case Xacid_4:
3316     case Xacid_5:
3317     case Xacid_6:
3318     case Xacid_7:
3319     case Xacid_8:
3320       cave[x][y] = Ybug_s_w;
3321       next[x][y] = Xbug_2_w;
3322       play_element_sound(x, y, SOUND_bug, Xbug_1_s);
3323       return;
3324
3325     default:
3326       Lbug_s(x, y);
3327       return;
3328   }
3329 }
3330
3331 static void Lbug_2_s(int x, int y)
3332 {
3333   if (is_amoeba[cave[x][y-1]] ||
3334       is_amoeba[cave[x+1][y]] ||
3335       is_amoeba[cave[x][y+1]] ||
3336       is_amoeba[cave[x-1][y]])
3337   {
3338     next[x][y] = Zboom;
3339     Lboom_bug(x, y);
3340
3341     return;
3342   }
3343
3344   Lbug_s(x, y);
3345 }
3346
3347 static void Lbug_w(int x, int y)
3348 {
3349   switch (cave[x-1][y])
3350   {
3351     case Zplayer:
3352     case Xblank:
3353     case Xsplash_e:
3354     case Xsplash_w:
3355     case Xfake_acid_1:
3356     case Xfake_acid_2:
3357     case Xfake_acid_3:
3358     case Xfake_acid_4:
3359     case Xfake_acid_5:
3360     case Xfake_acid_6:
3361     case Xfake_acid_7:
3362     case Xfake_acid_8:
3363     case Xfake_acid_1_player:
3364     case Xfake_acid_2_player:
3365     case Xfake_acid_3_player:
3366     case Xfake_acid_4_player:
3367     case Xfake_acid_5_player:
3368     case Xfake_acid_6_player:
3369     case Xfake_acid_7_player:
3370     case Xfake_acid_8_player:
3371     case Xplant:
3372     case Yplant:
3373       cave[x][y] = Ybug_wB;
3374       next[x][y] = Xblank;
3375       cave[x-1][y] = Ybug_w;
3376       next[x-1][y] = Xbug_1_w;
3377       play_element_sound(x, y, SOUND_bug, Xbug_1_w);
3378       return;
3379
3380     case Xacid_1:
3381     case Xacid_2:
3382     case Xacid_3:
3383     case Xacid_4:
3384     case Xacid_5:
3385     case Xacid_6:
3386     case Xacid_7:
3387     case Xacid_8:
3388       cave[x][y] = Ybug_wB;
3389       next[x][y] = Xblank;
3390       if (cave[x][y-1] == Xblank)
3391         cave[x][y-1] = Xsplash_e;
3392       if (cave[x-2][y-1] == Xblank)
3393         cave[x-2][y-1] = Xsplash_w;
3394       play_element_sound(x, y, SOUND_acid, Xacid_1);
3395       return;
3396
3397     default:
3398       cave[x][y] = Ybug_w_s;
3399       next[x][y] = Xbug_2_s;
3400       play_element_sound(x, y, SOUND_bug, Xbug_1_w);
3401       return;
3402   }
3403 }
3404
3405 static void Lbug_1_w(int x, int y)
3406 {
3407   if (is_amoeba[cave[x][y-1]] ||
3408       is_amoeba[cave[x+1][y]] ||
3409       is_amoeba[cave[x][y+1]] ||
3410       is_amoeba[cave[x-1][y]])
3411   {
3412     next[x][y] = Zboom;
3413     Lboom_bug(x, y);
3414
3415     return;
3416   }
3417
3418   switch (cave[x][y-1])
3419   {
3420     case Zplayer:
3421     case Xblank:
3422     case Xsplash_e:
3423     case Xsplash_w:
3424     case Xfake_acid_1:
3425     case Xfake_acid_2:
3426     case Xfake_acid_3:
3427     case Xfake_acid_4:
3428     case Xfake_acid_5:
3429     case Xfake_acid_6:
3430     case Xfake_acid_7:
3431     case Xfake_acid_8:
3432     case Xfake_acid_1_player:
3433     case Xfake_acid_2_player:
3434     case Xfake_acid_3_player:
3435     case Xfake_acid_4_player:
3436     case Xfake_acid_5_player:
3437     case Xfake_acid_6_player:
3438     case Xfake_acid_7_player:
3439     case Xfake_acid_8_player:
3440     case Xplant:
3441     case Yplant:
3442     case Xacid_1:
3443     case Xacid_2:
3444     case Xacid_3:
3445     case Xacid_4:
3446     case Xacid_5:
3447     case Xacid_6:
3448     case Xacid_7:
3449     case Xacid_8:
3450       cave[x][y] = Ybug_w_n;
3451       next[x][y] = Xbug_2_n;
3452       play_element_sound(x, y, SOUND_bug, Xbug_1_w);
3453       return;
3454
3455     default:
3456       Lbug_w(x, y);
3457       return;
3458   }
3459 }
3460
3461 static void Lbug_2_w(int x, int y)
3462 {
3463   if (is_amoeba[cave[x][y-1]] ||
3464       is_amoeba[cave[x+1][y]] ||
3465       is_amoeba[cave[x][y+1]] ||
3466       is_amoeba[cave[x-1][y]])
3467   {
3468     next[x][y] = Zboom;
3469     Lboom_bug(x, y);
3470
3471     return;
3472   }
3473
3474   Lbug_w(x, y);
3475 }
3476
3477 static void Ltank_n(int x, int y)
3478 {
3479   switch (cave[x][y-1])
3480   {
3481     case Zplayer:
3482     case Xblank:
3483     case Xsplash_e:
3484     case Xsplash_w:
3485     case Xfake_acid_1:
3486     case Xfake_acid_2:
3487     case Xfake_acid_3:
3488     case Xfake_acid_4:
3489     case Xfake_acid_5:
3490     case Xfake_acid_6:
3491     case Xfake_acid_7:
3492     case Xfake_acid_8:
3493     case Xfake_acid_1_player:
3494     case Xfake_acid_2_player:
3495     case Xfake_acid_3_player:
3496     case Xfake_acid_4_player:
3497     case Xfake_acid_5_player:
3498     case Xfake_acid_6_player:
3499     case Xfake_acid_7_player:
3500     case Xfake_acid_8_player:
3501     case Xplant:
3502     case Yplant:
3503       cave[x][y] = Ytank_nB;
3504       next[x][y] = Xblank;
3505       cave[x][y-1] = Ytank_n;
3506       next[x][y-1] = Xtank_1_n;
3507       play_element_sound(x, y, SOUND_tank, Xtank_1_n);
3508       return;
3509
3510     case Xacid_1:
3511     case Xacid_2:
3512     case Xacid_3:
3513     case Xacid_4:
3514     case Xacid_5:
3515     case Xacid_6:
3516     case Xacid_7:
3517     case Xacid_8:
3518       cave[x][y] = Ytank_nB;
3519       next[x][y] = Xblank;
3520       if (cave[x+1][y-2] == Xblank)
3521         cave[x+1][y-2] = Xsplash_e;
3522       if (cave[x-1][y-2] == Xblank)
3523         cave[x-1][y-2] = Xsplash_w;
3524       play_element_sound(x, y, SOUND_acid, Xacid_1);
3525       return;
3526
3527     default:
3528       cave[x][y] = Ytank_n_e;
3529       next[x][y] = Xtank_2_e;
3530       play_element_sound(x, y, SOUND_tank, Xtank_1_n);
3531       return;
3532   }
3533 }
3534
3535 static void Ltank_1_n(int x, int y)
3536 {
3537   if (is_amoeba[cave[x][y-1]] ||
3538       is_amoeba[cave[x+1][y]] ||
3539       is_amoeba[cave[x][y+1]] ||
3540       is_amoeba[cave[x-1][y]])
3541   {
3542     next[x][y] = Zboom;
3543     Lboom_tank(x, y);
3544
3545     return;
3546   }
3547
3548   switch (cave[x-1][y])
3549   {
3550     case Zplayer:
3551     case Xblank:
3552     case Xsplash_e:
3553     case Xsplash_w:
3554     case Xfake_acid_1:
3555     case Xfake_acid_2:
3556     case Xfake_acid_3:
3557     case Xfake_acid_4:
3558     case Xfake_acid_5:
3559     case Xfake_acid_6:
3560     case Xfake_acid_7:
3561     case Xfake_acid_8:
3562     case Xfake_acid_1_player:
3563     case Xfake_acid_2_player:
3564     case Xfake_acid_3_player:
3565     case Xfake_acid_4_player:
3566     case Xfake_acid_5_player:
3567     case Xfake_acid_6_player:
3568     case Xfake_acid_7_player:
3569     case Xfake_acid_8_player:
3570     case Xplant:
3571     case Yplant:
3572     case Xacid_1:
3573     case Xacid_2:
3574     case Xacid_3:
3575     case Xacid_4:
3576     case Xacid_5:
3577     case Xacid_6:
3578     case Xacid_7:
3579     case Xacid_8:
3580       cave[x][y] = Ytank_n_w;
3581       next[x][y] = Xtank_2_w;
3582       play_element_sound(x, y, SOUND_tank, Xtank_1_n);
3583       return;
3584
3585     default:
3586       Ltank_n(x, y);
3587       return;
3588   }
3589 }
3590
3591 static void Ltank_2_n(int x, int y)
3592 {
3593   if (is_amoeba[cave[x][y-1]] ||
3594       is_amoeba[cave[x+1][y]] ||
3595       is_amoeba[cave[x][y+1]] ||
3596       is_amoeba[cave[x-1][y]])
3597   {
3598     next[x][y] = Zboom;
3599     Lboom_tank(x, y);
3600
3601     return;
3602   }
3603
3604   Ltank_n(x, y);
3605 }
3606
3607 static void Ltank_e(int x, int y)
3608 {
3609   switch (cave[x+1][y])
3610   {
3611     case Zplayer:
3612     case Xblank:
3613     case Xsplash_e:
3614     case Xsplash_w:
3615     case Xfake_acid_1:
3616     case Xfake_acid_2:
3617     case Xfake_acid_3:
3618     case Xfake_acid_4:
3619     case Xfake_acid_5:
3620     case Xfake_acid_6:
3621     case Xfake_acid_7:
3622     case Xfake_acid_8:
3623     case Xfake_acid_1_player:
3624     case Xfake_acid_2_player:
3625     case Xfake_acid_3_player:
3626     case Xfake_acid_4_player:
3627     case Xfake_acid_5_player:
3628     case Xfake_acid_6_player:
3629     case Xfake_acid_7_player:
3630     case Xfake_acid_8_player:
3631     case Xplant:
3632     case Yplant:
3633       cave[x][y] = Ytank_eB;
3634       next[x][y] = Xblank;
3635       cave[x+1][y] = Ytank_e;
3636       next[x+1][y] = Xtank_1_e;
3637       play_element_sound(x, y, SOUND_tank, Xtank_1_e);
3638       return;
3639
3640     case Xacid_1:
3641     case Xacid_2:
3642     case Xacid_3:
3643     case Xacid_4:
3644     case Xacid_5:
3645     case Xacid_6:
3646     case Xacid_7:
3647     case Xacid_8:
3648       cave[x][y] = Ytank_eB;
3649       next[x][y] = Xblank;
3650       if (cave[x+2][y-1] == Xblank)
3651         cave[x+2][y-1] = Xsplash_e;
3652       if (cave[x][y-1] == Xblank)
3653         cave[x][y-1] = Xsplash_w;
3654       play_element_sound(x, y, SOUND_acid, Xacid_1);
3655       return;
3656
3657     default:
3658       cave[x][y] = Ytank_e_s;
3659       next[x][y] = Xtank_2_s;
3660       play_element_sound(x, y, SOUND_tank, Xtank_1_e);
3661       return;
3662   }
3663 }
3664
3665 static void Ltank_1_e(int x, int y)
3666 {
3667   if (is_amoeba[cave[x][y-1]] ||
3668       is_amoeba[cave[x+1][y]] ||
3669       is_amoeba[cave[x][y+1]] ||
3670       is_amoeba[cave[x-1][y]])
3671   {
3672     next[x][y] = Zboom;
3673     Lboom_tank(x, y);
3674
3675     return;
3676   }
3677
3678   switch (cave[x][y-1])
3679   {
3680     case Zplayer:
3681     case Xblank:
3682     case Xsplash_e:
3683     case Xsplash_w:
3684     case Xfake_acid_1:
3685     case Xfake_acid_2:
3686     case Xfake_acid_3:
3687     case Xfake_acid_4:
3688     case Xfake_acid_5:
3689     case Xfake_acid_6:
3690     case Xfake_acid_7:
3691     case Xfake_acid_8:
3692     case Xfake_acid_1_player:
3693     case Xfake_acid_2_player:
3694     case Xfake_acid_3_player:
3695     case Xfake_acid_4_player:
3696     case Xfake_acid_5_player:
3697     case Xfake_acid_6_player:
3698     case Xfake_acid_7_player:
3699     case Xfake_acid_8_player:
3700     case Xplant:
3701     case Yplant:
3702     case Xacid_1:
3703     case Xacid_2:
3704     case Xacid_3:
3705     case Xacid_4:
3706     case Xacid_5:
3707     case Xacid_6:
3708     case Xacid_7:
3709     case Xacid_8:
3710       cave[x][y] = Ytank_e_n;
3711       next[x][y] = Xtank_2_n;
3712       play_element_sound(x, y, SOUND_tank, Xtank_1_e);
3713       return;
3714
3715     default:
3716       Ltank_e(x, y);
3717       return;
3718   }
3719 }
3720
3721 static void Ltank_2_e(int x, int y)
3722 {
3723   if (is_amoeba[cave[x][y-1]] ||
3724       is_amoeba[cave[x+1][y]] ||
3725       is_amoeba[cave[x][y+1]] ||
3726       is_amoeba[cave[x-1][y]])
3727   {
3728     next[x][y] = Zboom;
3729     Lboom_tank(x, y);
3730
3731     return;
3732   }
3733
3734   Ltank_e(x, y);
3735 }
3736
3737 static void Ltank_s(int x, int y)
3738 {
3739   switch (cave[x][y+1])
3740   {
3741     case Zplayer:
3742     case Xblank:
3743     case Xsplash_e:
3744     case Xsplash_w:
3745     case Xfake_acid_1:
3746     case Xfake_acid_2:
3747     case Xfake_acid_3:
3748     case Xfake_acid_4:
3749     case Xfake_acid_5:
3750     case Xfake_acid_6:
3751     case Xfake_acid_7:
3752     case Xfake_acid_8:
3753     case Xfake_acid_1_player:
3754     case Xfake_acid_2_player:
3755     case Xfake_acid_3_player:
3756     case Xfake_acid_4_player:
3757     case Xfake_acid_5_player:
3758     case Xfake_acid_6_player:
3759     case Xfake_acid_7_player:
3760     case Xfake_acid_8_player:
3761     case Xplant:
3762     case Yplant:
3763       cave[x][y] = Ytank_sB;
3764       next[x][y] = Xblank;
3765       cave[x][y+1] = Ytank_s;
3766       next[x][y+1] = Xtank_1_s;
3767       play_element_sound(x, y, SOUND_tank, Xtank_1_s);
3768       return;
3769
3770     case Xacid_1:
3771     case Xacid_2:
3772     case Xacid_3:
3773     case Xacid_4:
3774     case Xacid_5:
3775     case Xacid_6:
3776     case Xacid_7:
3777     case Xacid_8:
3778       cave[x][y] = Ytank_sB;
3779       next[x][y] = Xblank;
3780       if (cave[x+1][y] == Xblank)
3781         cave[x+1][y] = Xsplash_e;
3782       if (cave[x-1][y] == Xblank)
3783         cave[x-1][y] = Xsplash_w;
3784       play_element_sound(x, y, SOUND_acid, Xacid_1);
3785       return;
3786
3787     default:
3788       cave[x][y] = Ytank_s_w;
3789       next[x][y] = Xtank_2_w;
3790       play_element_sound(x, y, SOUND_tank, Xtank_1_s);
3791       return;
3792   }
3793 }
3794
3795 static void Ltank_1_s(int x, int y)
3796 {
3797   if (is_amoeba[cave[x][y-1]] ||
3798       is_amoeba[cave[x+1][y]] ||
3799       is_amoeba[cave[x][y+1]] ||
3800       is_amoeba[cave[x-1][y]])
3801   {
3802     next[x][y] = Zboom;
3803     Lboom_tank(x, y);
3804
3805     return;
3806   }
3807
3808   switch (cave[x+1][y])
3809   {
3810     case Zplayer:
3811     case Xblank:
3812     case Xsplash_e:
3813     case Xsplash_w:
3814     case Xfake_acid_1:
3815     case Xfake_acid_2:
3816     case Xfake_acid_3:
3817     case Xfake_acid_4:
3818     case Xfake_acid_5:
3819     case Xfake_acid_6:
3820     case Xfake_acid_7:
3821     case Xfake_acid_8:
3822     case Xfake_acid_1_player:
3823     case Xfake_acid_2_player:
3824     case Xfake_acid_3_player:
3825     case Xfake_acid_4_player:
3826     case Xfake_acid_5_player:
3827     case Xfake_acid_6_player:
3828     case Xfake_acid_7_player:
3829     case Xfake_acid_8_player:
3830     case Xplant:
3831     case Yplant:
3832     case Xacid_1:
3833     case Xacid_2:
3834     case Xacid_3:
3835     case Xacid_4:
3836     case Xacid_5:
3837     case Xacid_6:
3838     case Xacid_7:
3839     case Xacid_8:
3840       cave[x][y] = Ytank_s_e;
3841       next[x][y] = Xtank_2_e;
3842       play_element_sound(x, y, SOUND_tank, Xtank_1_s);
3843       return;
3844
3845     default:
3846       Ltank_s(x, y);
3847       return;
3848   }
3849 }
3850
3851 static void Ltank_2_s(int x, int y)
3852 {
3853   if (is_amoeba[cave[x][y-1]] ||
3854       is_amoeba[cave[x+1][y]] ||
3855       is_amoeba[cave[x][y+1]] ||
3856       is_amoeba[cave[x-1][y]])
3857   {
3858     next[x][y] = Zboom;
3859     Lboom_tank(x, y);
3860
3861     return;
3862   }
3863
3864   Ltank_s(x, y);
3865 }
3866
3867 static void Ltank_w(int x, int y)
3868 {
3869   switch (cave[x-1][y])
3870   {
3871     case Zplayer:
3872     case Xblank:
3873     case Xsplash_e:
3874     case Xsplash_w:
3875     case Xfake_acid_1:
3876     case Xfake_acid_2:
3877     case Xfake_acid_3:
3878     case Xfake_acid_4:
3879     case Xfake_acid_5:
3880     case Xfake_acid_6:
3881     case Xfake_acid_7:
3882     case Xfake_acid_8:
3883     case Xfake_acid_1_player:
3884     case Xfake_acid_2_player:
3885     case Xfake_acid_3_player:
3886     case Xfake_acid_4_player:
3887     case Xfake_acid_5_player:
3888     case Xfake_acid_6_player:
3889     case Xfake_acid_7_player:
3890     case Xfake_acid_8_player:
3891     case Xplant:
3892     case Yplant:
3893       cave[x][y] = Ytank_wB;
3894       next[x][y] = Xblank;
3895       cave[x-1][y] = Ytank_w;
3896       next[x-1][y] = Xtank_1_w;
3897       play_element_sound(x, y, SOUND_tank, Xtank_1_w);
3898       return;
3899
3900     case Xacid_1:
3901     case Xacid_2:
3902     case Xacid_3:
3903     case Xacid_4:
3904     case Xacid_5:
3905     case Xacid_6:
3906     case Xacid_7:
3907     case Xacid_8:
3908       cave[x][y] = Ytank_wB;
3909       next[x][y] = Xblank;
3910       if (cave[x][y-1] == Xblank)
3911         cave[x][y-1] = Xsplash_e;
3912       if (cave[x-2][y-1] == Xblank)
3913         cave[x-2][y-1] = Xsplash_w;
3914       play_element_sound(x, y, SOUND_acid, Xacid_1);
3915       return;
3916
3917     default:
3918       cave[x][y] = Ytank_w_n;
3919       next[x][y] = Xtank_2_n;
3920       play_element_sound(x, y, SOUND_tank, Xtank_1_w);
3921       return;
3922   }
3923 }
3924
3925 static void Ltank_1_w(int x, int y)
3926 {
3927   if (is_amoeba[cave[x][y-1]] ||
3928       is_amoeba[cave[x+1][y]] ||
3929       is_amoeba[cave[x][y+1]] ||
3930       is_amoeba[cave[x-1][y]])
3931   {
3932     next[x][y] = Zboom;
3933     Lboom_tank(x, y);
3934
3935     return;
3936   }
3937
3938   switch (cave[x][y+1])
3939   {
3940     case Zplayer:
3941     case Xblank:
3942     case Xsplash_e:
3943     case Xsplash_w:
3944     case Xfake_acid_1:
3945     case Xfake_acid_2:
3946     case Xfake_acid_3:
3947     case Xfake_acid_4:
3948     case Xfake_acid_5:
3949     case Xfake_acid_6:
3950     case Xfake_acid_7:
3951     case Xfake_acid_8:
3952     case Xfake_acid_1_player:
3953     case Xfake_acid_2_player:
3954     case Xfake_acid_3_player:
3955     case Xfake_acid_4_player:
3956     case Xfake_acid_5_player:
3957     case Xfake_acid_6_player:
3958     case Xfake_acid_7_player:
3959     case Xfake_acid_8_player:
3960     case Xplant:
3961     case Yplant:
3962     case Xacid_1:
3963     case Xacid_2:
3964     case Xacid_3:
3965     case Xacid_4:
3966     case Xacid_5:
3967     case Xacid_6:
3968     case Xacid_7:
3969     case Xacid_8:
3970       cave[x][y] = Ytank_w_s;
3971       next[x][y] = Xtank_2_s;
3972       play_element_sound(x, y, SOUND_tank, Xtank_1_w);
3973       return;
3974
3975     default:
3976       Ltank_w(x, y);
3977       return;
3978   }
3979 }
3980
3981 static void Ltank_2_w(int x, int y)
3982 {
3983   if (is_amoeba[cave[x][y-1]] ||
3984       is_amoeba[cave[x+1][y]] ||
3985       is_amoeba[cave[x][y+1]] ||
3986       is_amoeba[cave[x-1][y]])
3987   {
3988     next[x][y] = Zboom;
3989     Lboom_tank(x, y);
3990
3991     return;
3992   }
3993
3994   Ltank_w(x, y);
3995 }
3996
3997 static void Lemerald(int x, int y)
3998 {
3999   switch (cave[x][y+1])
4000   {
4001     case Xblank:
4002     case Xsplash_e:
4003     case Xsplash_w:
4004     case Xfake_acid_1:
4005     case Xfake_acid_2:
4006     case Xfake_acid_3:
4007     case Xfake_acid_4:
4008     case Xfake_acid_5:
4009     case Xfake_acid_6:
4010     case Xfake_acid_7:
4011     case Xfake_acid_8:
4012       cave[x][y] = Yemerald_sB;
4013       next[x][y] = Xblank;
4014       cave[x][y+1] = Yemerald_s;
4015       next[x][y+1] = Xemerald_fall;
4016       return;
4017
4018     case Xacid_1:
4019     case Xacid_2:
4020     case Xacid_3:
4021     case Xacid_4:
4022     case Xacid_5:
4023     case Xacid_6:
4024     case Xacid_7:
4025     case Xacid_8:
4026       cave[x][y] = Yemerald_sB;
4027       next[x][y] = Xblank;
4028       if (cave[x+1][y] == Xblank)
4029         cave[x+1][y] = Xsplash_e;
4030       if (cave[x-1][y] == Xblank)
4031         cave[x-1][y] = Xsplash_w;
4032       play_element_sound(x, y, SOUND_acid, Xacid_1);
4033       return;
4034
4035     case Xandroid:
4036     case Xandroid_1_n:
4037     case Xandroid_2_n:
4038     case Xandroid_1_e:
4039     case Xandroid_2_e:
4040     case Xandroid_1_s:
4041     case Xandroid_2_s:
4042     case Xandroid_1_w:
4043     case Xandroid_2_w:
4044     case Xemerald:
4045     case Xemerald_pause:
4046     case Xdiamond:
4047     case Xdiamond_pause:
4048     case Xstone:
4049     case Xstone_pause:
4050     case Xbomb:
4051     case Xbomb_pause:
4052     case Xnut:
4053     case Xnut_pause:
4054     case Xspring:
4055     case Xspring_pause:
4056     case Xspring_e:
4057     case Xspring_w:
4058     case Xkey_1:
4059     case Xkey_2:
4060     case Xkey_3:
4061     case Xkey_4:
4062     case Xkey_5:
4063     case Xkey_6:
4064     case Xkey_7:
4065     case Xkey_8:
4066     case Xballoon:
4067     case Xball_1:
4068     case Xball_2:
4069     case Xwonderwall:
4070     case Xswitch:
4071     case Xbumper:
4072     case Ybumper:
4073     case Xacid_ne:
4074     case Xacid_nw:
4075     case Xslide_ns:
4076     case Xslide_ew:
4077     case Xwall_1:
4078     case Xwall_2:
4079     case Xwall_3:
4080     case Xwall_4:
4081     case Xroundwall_1:
4082     case Xroundwall_2:
4083     case Xroundwall_3:
4084     case Xroundwall_4:
4085     case Xsteel_1:
4086     case Xsteel_2:
4087     case Xsteel_3:
4088     case Xsteel_4:
4089       if (RANDOM(2))
4090       {
4091         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
4092         {
4093           cave[x][y] = Yemerald_eB;
4094           next[x][y] = Xblank;
4095           cave[x+1][y] = Yemerald_e;
4096           next[x+1][y] = Xemerald_pause;
4097           if (cave[x][y+1] == Xbumper)
4098             cave[x][y+1] = Ybumper;
4099           return;
4100         }
4101
4102         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
4103         {
4104           cave[x][y] = Yemerald_wB;
4105           next[x][y] = Xblank;
4106           cave[x-1][y] = Yemerald_w;
4107           next[x-1][y] = Xemerald_pause;
4108           if (cave[x][y+1] == Xbumper)
4109             cave[x][y+1] = Ybumper;
4110           return;
4111         }
4112       }
4113       else
4114       {
4115         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
4116         {
4117           cave[x][y] = Yemerald_wB;
4118           next[x][y] = Xblank;
4119           cave[x-1][y] = Yemerald_w;
4120           next[x-1][y] = Xemerald_pause;
4121           if (cave[x][y+1] == Xbumper)
4122             cave[x][y+1] = Ybumper;
4123           return;
4124         }
4125
4126         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
4127         {
4128           cave[x][y] = Yemerald_eB;
4129           next[x][y] = Xblank;
4130           cave[x+1][y] = Yemerald_e;
4131           next[x+1][y] = Xemerald_pause;
4132           if (cave[x][y+1] == Xbumper)
4133             cave[x][y+1] = Ybumper;
4134           return;
4135         }
4136       }
4137
4138     default:
4139       if (++lev.shine_cnt > 50)
4140       {
4141         lev.shine_cnt = RANDOM(8);
4142         cave[x][y] = Xemerald_shine;
4143       }
4144
4145       return;
4146   }
4147 }
4148
4149 static void Lemerald_pause(int x, int y)
4150 {
4151   switch (cave[x][y+1])
4152   {
4153     case Xblank:
4154     case Xsplash_e:
4155     case Xsplash_w:
4156     case Xfake_acid_1:
4157     case Xfake_acid_2:
4158     case Xfake_acid_3:
4159     case Xfake_acid_4:
4160     case Xfake_acid_5:
4161     case Xfake_acid_6:
4162     case Xfake_acid_7:
4163     case Xfake_acid_8:
4164       cave[x][y] = Yemerald_sB;
4165       next[x][y] = Xblank;
4166       cave[x][y+1] = Yemerald_s;
4167       next[x][y+1] = Xemerald_fall;
4168       return;
4169
4170     case Xacid_1:
4171     case Xacid_2:
4172     case Xacid_3:
4173     case Xacid_4:
4174     case Xacid_5:
4175     case Xacid_6:
4176     case Xacid_7:
4177     case Xacid_8:
4178       cave[x][y] = Yemerald_sB;
4179       next[x][y] = Xblank;
4180       if (cave[x+1][y] == Xblank)
4181         cave[x+1][y] = Xsplash_e;
4182       if (cave[x-1][y] == Xblank)
4183         cave[x-1][y] = Xsplash_w;
4184       play_element_sound(x, y, SOUND_acid, Xacid_1);
4185       return;
4186
4187     default:
4188       cave[x][y] = Xemerald;
4189       next[x][y] = Xemerald;
4190       return;
4191   }
4192 }
4193
4194 static void Lemerald_fall(int x, int y)
4195 {
4196   switch (cave[x][y+1])
4197   {
4198     case Zplayer:
4199     case Xblank:
4200     case Xsplash_e:
4201     case Xsplash_w:
4202     case Xfake_acid_1:
4203     case Xfake_acid_2:
4204     case Xfake_acid_3:
4205     case Xfake_acid_4:
4206     case Xfake_acid_5:
4207     case Xfake_acid_6:
4208     case Xfake_acid_7:
4209     case Xfake_acid_8:
4210     case Xfake_acid_1_player:
4211     case Xfake_acid_2_player:
4212     case Xfake_acid_3_player:
4213     case Xfake_acid_4_player:
4214     case Xfake_acid_5_player:
4215     case Xfake_acid_6_player:
4216     case Xfake_acid_7_player:
4217     case Xfake_acid_8_player:
4218       cave[x][y] = Yemerald_sB;
4219       next[x][y] = Xblank;
4220       cave[x][y+1] = Yemerald_s;
4221       next[x][y+1] = Xemerald_fall;
4222       return;
4223
4224     case Xacid_1:
4225     case Xacid_2:
4226     case Xacid_3:
4227     case Xacid_4:
4228     case Xacid_5:
4229     case Xacid_6:
4230     case Xacid_7:
4231     case Xacid_8:
4232       cave[x][y] = Yemerald_sB;
4233       next[x][y] = Xblank;
4234       if (cave[x+1][y] == Xblank)
4235         cave[x+1][y] = Xsplash_e;
4236       if (cave[x-1][y] == Xblank)
4237         cave[x-1][y] = Xsplash_w;
4238       play_element_sound(x, y, SOUND_acid, Xacid_1);
4239       return;
4240
4241     case Xwonderwall:
4242       if (lev.wonderwall_time > 0)
4243       {
4244         lev.wonderwall_active = TRUE;
4245         cave[x][y] = Yemerald_sB;
4246         next[x][y] = Xblank;
4247         if (is_blank[cave[x][y+2]])
4248         {
4249           cave[x][y+2] = Ydiamond_s;
4250           next[x][y+2] = Xdiamond_fall;
4251         }
4252         play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
4253         return;
4254       }
4255
4256     default:
4257       cave[x][y] = Xemerald;
4258       next[x][y] = Xemerald;
4259       play_element_sound(x, y, SOUND_diamond, Xemerald);
4260       return;
4261   }
4262 }
4263
4264 static void Ldiamond(int x, int y)
4265 {
4266   switch (cave[x][y+1])
4267   {
4268     case Xblank:
4269     case Xsplash_e:
4270     case Xsplash_w:
4271     case Xfake_acid_1:
4272     case Xfake_acid_2:
4273     case Xfake_acid_3:
4274     case Xfake_acid_4:
4275     case Xfake_acid_5:
4276     case Xfake_acid_6:
4277     case Xfake_acid_7:
4278     case Xfake_acid_8:
4279       cave[x][y] = Ydiamond_sB;
4280       next[x][y] = Xblank;
4281       cave[x][y+1] = Ydiamond_s;
4282       next[x][y+1] = Xdiamond_fall;
4283       return;
4284
4285     case Xacid_1:
4286     case Xacid_2:
4287     case Xacid_3:
4288     case Xacid_4:
4289     case Xacid_5:
4290     case Xacid_6:
4291     case Xacid_7:
4292     case Xacid_8:
4293       cave[x][y] = Ydiamond_sB;
4294       next[x][y] = Xblank;
4295       if (cave[x+1][y] == Xblank)
4296         cave[x+1][y] = Xsplash_e;
4297       if (cave[x-1][y] == Xblank)
4298         cave[x-1][y] = Xsplash_w;
4299       play_element_sound(x, y, SOUND_acid, Xacid_1);
4300       return;
4301
4302     case Xandroid:
4303     case Xandroid_1_n:
4304     case Xandroid_2_n:
4305     case Xandroid_1_e:
4306     case Xandroid_2_e:
4307     case Xandroid_1_s:
4308     case Xandroid_2_s:
4309     case Xandroid_1_w:
4310     case Xandroid_2_w:
4311     case Xemerald:
4312     case Xemerald_pause:
4313     case Xdiamond:
4314     case Xdiamond_pause:
4315     case Xstone:
4316     case Xstone_pause:
4317     case Xbomb:
4318     case Xbomb_pause:
4319     case Xnut:
4320     case Xnut_pause:
4321     case Xspring:
4322     case Xspring_pause:
4323     case Xspring_e:
4324     case Xspring_w:
4325     case Xkey_1:
4326     case Xkey_2:
4327     case Xkey_3:
4328     case Xkey_4:
4329     case Xkey_5:
4330     case Xkey_6:
4331     case Xkey_7:
4332     case Xkey_8:
4333     case Xballoon:
4334     case Xball_1:
4335     case Xball_2:
4336     case Xwonderwall:
4337     case Xswitch:
4338     case Xbumper:
4339     case Ybumper:
4340     case Xacid_ne:
4341     case Xacid_nw:
4342     case Xslide_ns:
4343     case Xslide_ew:
4344     case Xwall_1:
4345     case Xwall_2:
4346     case Xwall_3:
4347     case Xwall_4:
4348     case Xroundwall_1:
4349     case Xroundwall_2:
4350     case Xroundwall_3:
4351     case Xroundwall_4:
4352     case Xsteel_1:
4353     case Xsteel_2:
4354     case Xsteel_3:
4355     case Xsteel_4:
4356       if (RANDOM(2))
4357       {
4358         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
4359         {
4360           cave[x][y] = Ydiamond_eB;
4361           next[x][y] = Xblank;
4362           cave[x+1][y] = Ydiamond_e;
4363           next[x+1][y] = Xdiamond_pause;
4364           if (cave[x][y+1] == Xbumper)
4365             cave[x][y+1] = Ybumper;
4366           return;
4367         }
4368
4369         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
4370         {
4371           cave[x][y] = Ydiamond_wB;
4372           next[x][y] = Xblank;
4373           cave[x-1][y] = Ydiamond_w;
4374           next[x-1][y] = Xdiamond_pause;
4375           if (cave[x][y+1] == Xbumper)
4376             cave[x][y+1] = Ybumper;
4377           return;
4378         }
4379       }
4380       else
4381       {
4382         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
4383         {
4384           cave[x][y] = Ydiamond_wB;
4385           next[x][y] = Xblank;
4386           cave[x-1][y] = Ydiamond_w;
4387           next[x-1][y] = Xdiamond_pause;
4388           if (cave[x][y+1] == Xbumper)
4389             cave[x][y+1] = Ybumper;
4390           return;
4391         }
4392
4393         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
4394         {
4395           cave[x][y] = Ydiamond_eB;
4396           next[x][y] = Xblank;
4397           cave[x+1][y] = Ydiamond_e;
4398           next[x+1][y] = Xdiamond_pause;
4399           if (cave[x][y+1] == Xbumper)
4400             cave[x][y+1] = Ybumper;
4401           return;
4402         }
4403       }
4404
4405     default:
4406       if (++lev.shine_cnt > 50)
4407       {
4408         lev.shine_cnt = RANDOM(8);
4409         cave[x][y] = Xdiamond_shine;
4410       }
4411
4412       return;
4413   }
4414 }
4415
4416 static void Ldiamond_pause(int x, int y)
4417 {
4418   switch (cave[x][y+1])
4419   {
4420     case Xblank:
4421     case Xsplash_e:
4422     case Xsplash_w:
4423     case Xfake_acid_1:
4424     case Xfake_acid_2:
4425     case Xfake_acid_3:
4426     case Xfake_acid_4:
4427     case Xfake_acid_5:
4428     case Xfake_acid_6:
4429     case Xfake_acid_7:
4430     case Xfake_acid_8:
4431       cave[x][y] = Ydiamond_sB;
4432       next[x][y] = Xblank;
4433       cave[x][y+1] = Ydiamond_s;
4434       next[x][y+1] = Xdiamond_fall;
4435       return;
4436
4437     case Xacid_1:
4438     case Xacid_2:
4439     case Xacid_3:
4440     case Xacid_4:
4441     case Xacid_5:
4442     case Xacid_6:
4443     case Xacid_7:
4444     case Xacid_8:
4445       cave[x][y] = Ydiamond_sB;
4446       next[x][y] = Xblank;
4447       if (cave[x+1][y] == Xblank)
4448         cave[x+1][y] = Xsplash_e;
4449       if (cave[x-1][y] == Xblank)
4450         cave[x-1][y] = Xsplash_w;
4451       play_element_sound(x, y, SOUND_acid, Xacid_1);
4452       return;
4453
4454     default:
4455       cave[x][y] = Xdiamond;
4456       next[x][y] = Xdiamond;
4457       return;
4458   }
4459 }
4460
4461 static void Ldiamond_fall(int x, int y)
4462 {
4463   switch (cave[x][y+1])
4464   {
4465     case Zplayer:
4466     case Xblank:
4467     case Xsplash_e:
4468     case Xsplash_w:
4469     case Xfake_acid_1:
4470     case Xfake_acid_2:
4471     case Xfake_acid_3:
4472     case Xfake_acid_4:
4473     case Xfake_acid_5:
4474     case Xfake_acid_6:
4475     case Xfake_acid_7:
4476     case Xfake_acid_8:
4477     case Xfake_acid_1_player:
4478     case Xfake_acid_2_player:
4479     case Xfake_acid_3_player:
4480     case Xfake_acid_4_player:
4481     case Xfake_acid_5_player:
4482     case Xfake_acid_6_player:
4483     case Xfake_acid_7_player:
4484     case Xfake_acid_8_player:
4485       cave[x][y] = Ydiamond_sB;
4486       next[x][y] = Xblank;
4487       cave[x][y+1] = Ydiamond_s;
4488       next[x][y+1] = Xdiamond_fall;
4489       return;
4490
4491     case Xacid_1:
4492     case Xacid_2:
4493     case Xacid_3:
4494     case Xacid_4:
4495     case Xacid_5:
4496     case Xacid_6:
4497     case Xacid_7:
4498     case Xacid_8:
4499       cave[x][y] = Ydiamond_sB;
4500       next[x][y] = Xblank;
4501       if (cave[x+1][y] == Xblank)
4502         cave[x+1][y] = Xsplash_e;
4503       if (cave[x-1][y] == Xblank)
4504         cave[x-1][y] = Xsplash_w;
4505       play_element_sound(x, y, SOUND_acid, Xacid_1);
4506       return;
4507
4508     case Xwonderwall:
4509       if (lev.wonderwall_time > 0)
4510       {
4511         lev.wonderwall_active = TRUE;
4512         cave[x][y] = Ydiamond_sB;
4513         next[x][y] = Xblank;
4514         if (is_blank[cave[x][y+2]])
4515         {
4516           cave[x][y+2] = Ystone_s;
4517           next[x][y+2] = Xstone_fall;
4518         }
4519         play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
4520         return;
4521       }
4522
4523     default:
4524       cave[x][y] = Xdiamond;
4525       next[x][y] = Xdiamond;
4526       play_element_sound(x, y, SOUND_diamond, Xdiamond);
4527       return;
4528   }
4529 }
4530
4531 static void Lstone(int x, int y)
4532 {
4533   switch (cave[x][y+1])
4534   {
4535     case Xblank:
4536     case Xsplash_e:
4537     case Xsplash_w:
4538     case Xfake_acid_1:
4539     case Xfake_acid_2:
4540     case Xfake_acid_3:
4541     case Xfake_acid_4:
4542     case Xfake_acid_5:
4543     case Xfake_acid_6:
4544     case Xfake_acid_7:
4545     case Xfake_acid_8:
4546     case Xplant:
4547     case Yplant:
4548       cave[x][y] = Ystone_sB;
4549       next[x][y] = Xblank;
4550       cave[x][y+1] = Ystone_s;
4551       next[x][y+1] = Xstone_fall;
4552       return;
4553
4554     case Xacid_1:
4555     case Xacid_2:
4556     case Xacid_3:
4557     case Xacid_4:
4558     case Xacid_5:
4559     case Xacid_6:
4560     case Xacid_7:
4561     case Xacid_8:
4562       cave[x][y] = Ystone_sB;
4563       next[x][y] = Xblank;
4564       if (cave[x+1][y] == Xblank)
4565         cave[x+1][y] = Xsplash_e;
4566       if (cave[x-1][y] == Xblank)
4567         cave[x-1][y] = Xsplash_w;
4568       play_element_sound(x, y, SOUND_acid, Xacid_1);
4569       return;
4570
4571     case Xsand:
4572       cave[x][y] = Xsand_stonein_1;
4573       next[x][y] = Xsand_stonein_2;
4574       cave[x][y+1] = Xsand_sandstone_1;
4575       next[x][y+1] = Xsand_sandstone_2;
4576       return;
4577
4578     case Xandroid:
4579     case Xandroid_1_n:
4580     case Xandroid_2_n:
4581     case Xandroid_1_e:
4582     case Xandroid_2_e:
4583     case Xandroid_1_s:
4584     case Xandroid_2_s:
4585     case Xandroid_1_w:
4586     case Xandroid_2_w:
4587     case Xemerald:
4588     case Xemerald_pause:
4589     case Xdiamond:
4590     case Xdiamond_pause:
4591     case Xstone:
4592     case Xstone_pause:
4593     case Xbomb:
4594     case Xbomb_pause:
4595     case Xnut:
4596     case Xnut_pause:
4597     case Xspring:
4598     case Xspring_pause:
4599     case Xspring_e:
4600     case Xspring_w:
4601     case Xkey_1:
4602     case Xkey_2:
4603     case Xkey_3:
4604     case Xkey_4:
4605     case Xkey_5:
4606     case Xkey_6:
4607     case Xkey_7:
4608     case Xkey_8:
4609     case Xballoon:
4610     case Xball_1:
4611     case Xball_2:
4612     case Xswitch:
4613     case Xbumper:
4614     case Ybumper:
4615     case Xacid_ne:
4616     case Xacid_nw:
4617     case Xlenses:
4618     case Xmagnify:
4619     case Xslide_ns:
4620     case Xslide_ew:
4621     case Xroundwall_1:
4622     case Xroundwall_2:
4623     case Xroundwall_3:
4624     case Xroundwall_4:
4625       if (RANDOM(2))
4626       {
4627         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
4628         {
4629           cave[x][y] = Ystone_eB;
4630           next[x][y] = Xblank;
4631           cave[x+1][y] = Ystone_e;
4632           next[x+1][y] = Xstone_pause;
4633           if (cave[x][y+1] == Xbumper)
4634             cave[x][y+1] = Ybumper;
4635           return;
4636         }
4637
4638         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
4639         {
4640           cave[x][y] = Ystone_wB;
4641           next[x][y] = Xblank;
4642           cave[x-1][y] = Ystone_w;
4643           next[x-1][y] = Xstone_pause;
4644           if (cave[x][y+1] == Xbumper)
4645             cave[x][y+1] = Ybumper;
4646           return;
4647         }
4648       }
4649       else
4650       {
4651         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
4652         {
4653           cave[x][y] = Ystone_wB;
4654           next[x][y] = Xblank;
4655           cave[x-1][y] = Ystone_w;
4656           next[x-1][y] = Xstone_pause;
4657           if (cave[x][y+1] == Xbumper)
4658             cave[x][y+1] = Ybumper;
4659           return;
4660         }
4661
4662         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
4663         {
4664           cave[x][y] = Ystone_eB;
4665           next[x][y] = Xblank;
4666           cave[x+1][y] = Ystone_e;
4667           next[x+1][y] = Xstone_pause;
4668           if (cave[x][y+1] == Xbumper)
4669             cave[x][y+1] = Ybumper;
4670           return;
4671         }
4672       }
4673   }
4674 }
4675
4676 static void Lstone_pause(int x, int y)
4677 {
4678   switch (cave[x][y+1])
4679   {
4680     case Xblank:
4681     case Xsplash_e:
4682     case Xsplash_w:
4683     case Xfake_acid_1:
4684     case Xfake_acid_2:
4685     case Xfake_acid_3:
4686     case Xfake_acid_4:
4687     case Xfake_acid_5:
4688     case Xfake_acid_6:
4689     case Xfake_acid_7:
4690     case Xfake_acid_8:
4691       cave[x][y] = Ystone_sB;
4692       next[x][y] = Xblank;
4693       cave[x][y+1] = Ystone_s;
4694       next[x][y+1] = Xstone_fall;
4695       return;
4696
4697     case Xacid_1:
4698     case Xacid_2:
4699     case Xacid_3:
4700     case Xacid_4:
4701     case Xacid_5:
4702     case Xacid_6:
4703     case Xacid_7:
4704     case Xacid_8:
4705       cave[x][y] = Ystone_sB;
4706       next[x][y] = Xblank;
4707       if (cave[x+1][y] == Xblank)
4708         cave[x+1][y] = Xsplash_e;
4709       if (cave[x-1][y] == Xblank)
4710         cave[x-1][y] = Xsplash_w;
4711       play_element_sound(x, y, SOUND_acid, Xacid_1);
4712       return;
4713
4714     default:
4715       cave[x][y] = Xstone;
4716       next[x][y] = Xstone;
4717       return;
4718   }
4719 }
4720
4721 static void Lstone_fall(int x, int y)
4722 {
4723   switch (cave[x][y+1])
4724   {
4725     case Zplayer:
4726     case Xblank:
4727     case Xsplash_e:
4728     case Xsplash_w:
4729     case Xfake_acid_1:
4730     case Xfake_acid_2:
4731     case Xfake_acid_3:
4732     case Xfake_acid_4:
4733     case Xfake_acid_5:
4734     case Xfake_acid_6:
4735     case Xfake_acid_7:
4736     case Xfake_acid_8:
4737     case Xfake_acid_1_player:
4738     case Xfake_acid_2_player:
4739     case Xfake_acid_3_player:
4740     case Xfake_acid_4_player:
4741     case Xfake_acid_5_player:
4742     case Xfake_acid_6_player:
4743     case Xfake_acid_7_player:
4744     case Xfake_acid_8_player:
4745       cave[x][y] = Ystone_sB;
4746       next[x][y] = Xblank;
4747       cave[x][y+1] = Ystone_s;
4748       next[x][y+1] = Xstone_fall;
4749       return;
4750
4751     case Xacid_1:
4752     case Xacid_2:
4753     case Xacid_3:
4754     case Xacid_4:
4755     case Xacid_5:
4756     case Xacid_6:
4757     case Xacid_7:
4758     case Xacid_8:
4759       cave[x][y] = Ystone_sB;
4760       next[x][y] = Xblank;
4761       if (cave[x+1][y] == Xblank)
4762         cave[x+1][y] = Xsplash_e;
4763       if (cave[x-1][y] == Xblank)
4764         cave[x-1][y] = Xsplash_w;
4765       play_element_sound(x, y, SOUND_acid, Xacid_1);
4766       return;
4767
4768     case Xeater_n:
4769     case Xeater_e:
4770     case Xeater_s:
4771     case Xeater_w:
4772       cave[x][y] = Ystone_sB;
4773       Lboom_next_new(x, y, Xblank);
4774       cave[x][y+1] = Yeater_stone;
4775       next[x][y+1] = Zeater;
4776       Lboom_eater_old(x, y+1);
4777       score += lev.eater_score;
4778       return;
4779
4780     case Xalien:
4781     case Xalien_pause:
4782       cave[x][y] = Ystone_sB;
4783       Lboom_next_new(x, y, Xblank);
4784       cave[x][y+1] = Yalien_stone;
4785       next[x][y+1] = Ztank;
4786       Lboom_tank_old(x, y+1);
4787       score += lev.alien_score;
4788       return;
4789
4790     case Xbug_1_n:
4791     case Xbug_1_e:
4792     case Xbug_1_s:
4793     case Xbug_1_w:
4794     case Xbug_2_n:
4795     case Xbug_2_e:
4796     case Xbug_2_s:
4797     case Xbug_2_w:
4798       cave[x][y] = Ystone_sB;
4799       Lboom_next_new(x, y, Xblank);
4800       cave[x][y+1] = Ybug_stone;
4801       next[x][y+1] = Zbug;
4802       Lboom_bug_old(x, y+1);
4803       score += lev.bug_score;
4804       return;
4805
4806     case Xtank_1_n:
4807     case Xtank_1_e:
4808     case Xtank_1_s:
4809     case Xtank_1_w:
4810     case Xtank_2_n:
4811     case Xtank_2_e:
4812     case Xtank_2_s:
4813     case Xtank_2_w:
4814       cave[x][y] = Ystone_sB;
4815       Lboom_next_new(x, y, Xblank);
4816       cave[x][y+1] = Ytank_stone;
4817       next[x][y+1] = Ztank;
4818       Lboom_tank_old(x, y+1);
4819       score += lev.tank_score;
4820       return;
4821
4822     case Xdiamond:
4823     case Xdiamond_pause:
4824       switch (cave[x][y+2])
4825       {
4826         case Zplayer:
4827         case Xblank:
4828         case Xsplash_e:
4829         case Xsplash_w:
4830         case Xfake_acid_1:
4831         case Xfake_acid_2:
4832         case Xfake_acid_3:
4833         case Xfake_acid_4:
4834         case Xfake_acid_5:
4835         case Xfake_acid_6:
4836         case Xfake_acid_7:
4837         case Xfake_acid_8:
4838         case Xfake_acid_1_player:
4839         case Xfake_acid_2_player:
4840         case Xfake_acid_3_player:
4841         case Xfake_acid_4_player:
4842         case Xfake_acid_5_player:
4843         case Xfake_acid_6_player:
4844         case Xfake_acid_7_player:
4845         case Xfake_acid_8_player:
4846         case Xplant:
4847         case Yplant:
4848         case Xacid_1:
4849         case Xacid_2:
4850         case Xacid_3:
4851         case Xacid_4:
4852         case Xacid_5:
4853         case Xacid_6:
4854         case Xacid_7:
4855         case Xacid_8:
4856         case Xandroid:
4857         case Xandroid_1_n:
4858         case Xandroid_2_n:
4859         case Xandroid_1_e:
4860         case Xandroid_2_e:
4861         case Xandroid_1_s:
4862         case Xandroid_2_s:
4863         case Xandroid_1_w:
4864         case Xandroid_2_w:
4865         case Xbug_1_n:
4866         case Xbug_1_e:
4867         case Xbug_1_s:
4868         case Xbug_1_w:
4869         case Xbug_2_n:
4870         case Xbug_2_e:
4871         case Xbug_2_s:
4872         case Xbug_2_w:
4873         case Xtank_1_n:
4874         case Xtank_1_e:
4875         case Xtank_1_s:
4876         case Xtank_1_w:
4877         case Xtank_2_n:
4878         case Xtank_2_e:
4879         case Xtank_2_s:
4880         case Xtank_2_w:
4881         case Xemerald_fall:
4882         case Xdiamond_fall:
4883         case Xstone_fall:
4884         case Xbomb_fall:
4885         case Xnut_fall:
4886         case Xspring_fall:
4887         case Xacid_s:
4888           next[x][y] = Xstone;
4889           play_element_sound(x, y, SOUND_stone, Xstone);
4890           return;
4891       }
4892
4893       cave[x][y] = Ystone_sB;
4894       next[x][y] = Xblank;
4895       cave[x][y+1] = Ydiamond_stone;
4896       next[x][y+1] = Xstone_pause;
4897       play_element_sound(x, y, SOUND_squash, Xdiamond);
4898       return;
4899
4900     case Xbomb:
4901     case Xbomb_pause:
4902       Lboom_cave_new(x, y, Xstone);
4903       Lboom_next_new(x, y, Xstone);
4904       cave[x][y+1] = Ybomb_blank;
4905       next[x][y+1] = Ztank;
4906       Lboom_tank_old(x, y+1);
4907       return;
4908
4909     case Xnut:
4910     case Xnut_pause:
4911       next[x][y] = Xstone;
4912       cave[x][y+1] = Ynut_stone;
4913       next[x][y+1] = Xemerald;
4914       play_element_sound(x, y, SOUND_crack, Xnut);
4915       score += lev.nut_score;
4916       return;
4917
4918     case Xspring:
4919       if (RANDOM(2))
4920       {
4921         switch (cave[x+1][y+1])
4922         {
4923           case Xblank:
4924           case Xsplash_e:
4925           case Xsplash_w:
4926           case Xfake_acid_1:
4927           case Xfake_acid_2:
4928           case Xfake_acid_3:
4929           case Xfake_acid_4:
4930           case Xfake_acid_5:
4931           case Xfake_acid_6:
4932           case Xfake_acid_7:
4933           case Xfake_acid_8:
4934           case Xalien:
4935           case Xalien_pause:
4936             cave[x][y+1] = Xspring_e;
4937             break;
4938
4939           default:
4940             cave[x][y+1] = Xspring_w;
4941             break;
4942         }
4943       }
4944       else
4945       {
4946         switch (cave[x-1][y+1])
4947         {
4948           case Xblank:
4949           case Xsplash_e:
4950           case Xsplash_w:
4951           case Xfake_acid_1:
4952           case Xfake_acid_2:
4953           case Xfake_acid_3:
4954           case Xfake_acid_4:
4955           case Xfake_acid_5:
4956           case Xfake_acid_6:
4957           case Xfake_acid_7:
4958           case Xfake_acid_8:
4959           case Xalien:
4960           case Xalien_pause:
4961             cave[x][y+1] = Xspring_w;
4962             break;
4963           default:
4964             cave[x][y+1] = Xspring_e;
4965             break;
4966         }
4967       }
4968
4969       next[x][y] = Xstone;
4970       return;
4971
4972     case Xwonderwall:
4973       if (lev.wonderwall_time > 0)
4974       {
4975         lev.wonderwall_active = TRUE;
4976         cave[x][y] = Ystone_sB;
4977         next[x][y] = Xblank;
4978         if (is_blank[cave[x][y+2]])
4979         {
4980           cave[x][y+2] = Yemerald_s;
4981           next[x][y+2] = Xemerald_fall;
4982         }
4983         play_element_sound(x, y, SOUND_wonderfall, Xwonderwall);
4984         return;
4985       }
4986
4987     default:
4988       cave[x][y] = Xstone;
4989       next[x][y] = Xstone;
4990       play_element_sound(x, y, SOUND_stone, Xstone);
4991       return;
4992   }
4993 }
4994
4995 static void Lbomb(int x, int y)
4996 {
4997   switch (cave[x][y+1])
4998   {
4999     case Xblank:
5000     case Xsplash_e:
5001     case Xsplash_w:
5002     case Xfake_acid_1:
5003     case Xfake_acid_2:
5004     case Xfake_acid_3:
5005     case Xfake_acid_4:
5006     case Xfake_acid_5:
5007     case Xfake_acid_6:
5008     case Xfake_acid_7:
5009     case Xfake_acid_8:
5010       cave[x][y] = Ybomb_sB;
5011       next[x][y] = Xblank;
5012       cave[x][y+1] = Ybomb_s;
5013       next[x][y+1] = Xbomb_fall;
5014       return;
5015
5016     case Xacid_1:
5017     case Xacid_2:
5018     case Xacid_3:
5019     case Xacid_4:
5020     case Xacid_5:
5021     case Xacid_6:
5022     case Xacid_7:
5023     case Xacid_8:
5024       cave[x][y] = Ybomb_sB;
5025       next[x][y] = Xblank;
5026       if (cave[x+1][y] == Xblank)
5027         cave[x+1][y] = Xsplash_e;
5028       if (cave[x-1][y] == Xblank)
5029         cave[x-1][y] = Xsplash_w;
5030       play_element_sound(x, y, SOUND_acid, Xacid_1);
5031       return;
5032
5033     case Xandroid:
5034     case Xandroid_1_n:
5035     case Xandroid_2_n:
5036     case Xandroid_1_e:
5037     case Xandroid_2_e:
5038     case Xandroid_1_s:
5039     case Xandroid_2_s:
5040     case Xandroid_1_w:
5041     case Xandroid_2_w:
5042     case Xemerald:
5043     case Xemerald_pause:
5044     case Xdiamond:
5045     case Xdiamond_pause:
5046     case Xstone:
5047     case Xstone_pause:
5048     case Xbomb:
5049     case Xbomb_pause:
5050     case Xnut:
5051     case Xnut_pause:
5052     case Xspring:
5053     case Xspring_pause:
5054     case Xspring_e:
5055     case Xspring_w:
5056     case Xkey_1:
5057     case Xkey_2:
5058     case Xkey_3:
5059     case Xkey_4:
5060     case Xkey_5:
5061     case Xkey_6:
5062     case Xkey_7:
5063     case Xkey_8:
5064     case Xballoon:
5065     case Xball_1:
5066     case Xball_2:
5067     case Xswitch:
5068     case Xbumper:
5069     case Ybumper:
5070     case Xacid_ne:
5071     case Xacid_nw:
5072     case Xslide_ns:
5073     case Xslide_ew:
5074     case Xroundwall_1:
5075     case Xroundwall_2:
5076     case Xroundwall_3:
5077     case Xroundwall_4:
5078       if (RANDOM(2))
5079       {
5080         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
5081         {
5082           cave[x][y] = Ybomb_eB;
5083           next[x][y] = Xblank;
5084           cave[x+1][y] = Ybomb_e;
5085           next[x+1][y] = Xbomb_pause;
5086           if (cave[x][y+1] == Xbumper)
5087             cave[x][y+1] = Ybumper;
5088           return;
5089         }
5090
5091         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
5092         {
5093           cave[x][y] = Ybomb_wB;
5094           next[x][y] = Xblank;
5095           cave[x-1][y] = Ybomb_w;
5096           next[x-1][y] = Xbomb_pause;
5097           if (cave[x][y+1] == Xbumper)
5098             cave[x][y+1] = Ybumper;
5099           return;
5100         }
5101       }
5102       else
5103       {
5104         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
5105         {
5106           cave[x][y] = Ybomb_wB;
5107           next[x][y] = Xblank;
5108           cave[x-1][y] = Ybomb_w;
5109           next[x-1][y] = Xbomb_pause;
5110           if (cave[x][y+1] == Xbumper)
5111             cave[x][y+1] = Ybumper;
5112           return;
5113         }
5114
5115         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
5116         {
5117           cave[x][y] = Ybomb_eB;
5118           next[x][y] = Xblank;
5119           cave[x+1][y] = Ybomb_e;
5120           next[x+1][y] = Xbomb_pause;
5121           if (cave[x][y+1] == Xbumper)
5122             cave[x][y+1] = Ybumper;
5123           return;
5124         }
5125       }
5126   }
5127 }
5128
5129 static void Lbomb_pause(int x, int y)
5130 {
5131   switch (cave[x][y+1])
5132   {
5133     case Xblank:
5134     case Xsplash_e:
5135     case Xsplash_w:
5136     case Xfake_acid_1:
5137     case Xfake_acid_2:
5138     case Xfake_acid_3:
5139     case Xfake_acid_4:
5140     case Xfake_acid_5:
5141     case Xfake_acid_6:
5142     case Xfake_acid_7:
5143     case Xfake_acid_8:
5144       cave[x][y] = Ybomb_sB;
5145       next[x][y] = Xblank;
5146       cave[x][y+1] = Ybomb_s;
5147       next[x][y+1] = Xbomb_fall;
5148       return;
5149
5150     case Xacid_1:
5151     case Xacid_2:
5152     case Xacid_3:
5153     case Xacid_4:
5154     case Xacid_5:
5155     case Xacid_6:
5156     case Xacid_7:
5157     case Xacid_8:
5158       cave[x][y] = Ybomb_sB;
5159       next[x][y] = Xblank;
5160       if (cave[x+1][y] == Xblank)
5161         cave[x+1][y] = Xsplash_e;
5162       if (cave[x-1][y] == Xblank)
5163         cave[x-1][y] = Xsplash_w;
5164       play_element_sound(x, y, SOUND_acid, Xacid_1);
5165       return;
5166
5167     default:
5168       cave[x][y] = Xbomb;
5169       next[x][y] = Xbomb;
5170       return;
5171   }
5172 }
5173
5174 static void Lbomb_fall(int x, int y)
5175 {
5176   switch (cave[x][y+1])
5177   {
5178     case Xblank:
5179     case Xsplash_e:
5180     case Xsplash_w:
5181     case Xfake_acid_1:
5182     case Xfake_acid_2:
5183     case Xfake_acid_3:
5184     case Xfake_acid_4:
5185     case Xfake_acid_5:
5186     case Xfake_acid_6:
5187     case Xfake_acid_7:
5188     case Xfake_acid_8:
5189       cave[x][y] = Ybomb_sB;
5190       next[x][y] = Xblank;
5191       cave[x][y+1] = Ybomb_s;
5192       next[x][y+1] = Xbomb_fall;
5193       return;
5194
5195     case Xacid_1:
5196     case Xacid_2:
5197     case Xacid_3:
5198     case Xacid_4:
5199     case Xacid_5:
5200     case Xacid_6:
5201     case Xacid_7:
5202     case Xacid_8:
5203       cave[x][y] = Ybomb_sB;
5204       next[x][y] = Xblank;
5205       if (cave[x+1][y] == Xblank)
5206         cave[x+1][y] = Xsplash_e;
5207       if (cave[x-1][y] == Xblank)
5208         cave[x-1][y] = Xsplash_w;
5209       play_element_sound(x, y, SOUND_acid, Xacid_1);
5210       return;
5211
5212     default:
5213       cave[x][y] = Ybomb_blank;
5214       next[x][y] = Ztank;
5215       Lboom_tank_old(x, y);
5216       return;
5217   }
5218 }
5219
5220 static void Lnut(int x, int y)
5221 {
5222   switch (cave[x][y+1])
5223   {
5224     case Xblank:
5225     case Xsplash_e:
5226     case Xsplash_w:
5227     case Xfake_acid_1:
5228     case Xfake_acid_2:
5229     case Xfake_acid_3:
5230     case Xfake_acid_4:
5231     case Xfake_acid_5:
5232     case Xfake_acid_6:
5233     case Xfake_acid_7:
5234     case Xfake_acid_8:
5235       cave[x][y] = Ynut_sB;
5236       next[x][y] = Xblank;
5237       cave[x][y+1] = Ynut_s;
5238       next[x][y+1] = Xnut_fall;
5239       return;
5240
5241     case Xacid_1:
5242     case Xacid_2:
5243     case Xacid_3:
5244     case Xacid_4:
5245     case Xacid_5:
5246     case Xacid_6:
5247     case Xacid_7:
5248     case Xacid_8:
5249       cave[x][y] = Ynut_sB;
5250       next[x][y] = Xblank;
5251       if (cave[x+1][y] == Xblank)
5252         cave[x+1][y] = Xsplash_e;
5253       if (cave[x-1][y] == Xblank)
5254         cave[x-1][y] = Xsplash_w;
5255       play_element_sound(x, y, SOUND_acid, Xacid_1);
5256       return;
5257
5258     case Xandroid:
5259     case Xandroid_1_n:
5260     case Xandroid_2_n:
5261     case Xandroid_1_e:
5262     case Xandroid_2_e:
5263     case Xandroid_1_s:
5264     case Xandroid_2_s:
5265     case Xandroid_1_w:
5266     case Xandroid_2_w:
5267     case Xemerald:
5268     case Xemerald_pause:
5269     case Xdiamond:
5270     case Xdiamond_pause:
5271     case Xstone:
5272     case Xstone_pause:
5273     case Xbomb:
5274     case Xbomb_pause:
5275     case Xnut:
5276     case Xnut_pause:
5277     case Xspring:
5278     case Xspring_pause:
5279     case Xspring_e:
5280     case Xspring_w:
5281     case Xkey_1:
5282     case Xkey_2:
5283     case Xkey_3:
5284     case Xkey_4:
5285     case Xkey_5:
5286     case Xkey_6:
5287     case Xkey_7:
5288     case Xkey_8:
5289     case Xballoon:
5290     case Xball_1:
5291     case Xball_2:
5292     case Xswitch:
5293     case Xbumper:
5294     case Ybumper:
5295     case Xacid_ne:
5296     case Xacid_nw:
5297     case Xslide_ns:
5298     case Xslide_ew:
5299     case Xroundwall_1:
5300     case Xroundwall_2:
5301     case Xroundwall_3:
5302     case Xroundwall_4:
5303       if (RANDOM(2))
5304       {
5305         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
5306         {
5307           cave[x][y] = Ynut_eB;
5308           next[x][y] = Xblank;
5309           cave[x+1][y] = Ynut_e;
5310           next[x+1][y] = Xnut_pause;
5311           if (cave[x][y+1] == Xbumper)
5312             cave[x][y+1] = Ybumper;
5313           return;
5314         }
5315
5316         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
5317         {
5318           cave[x][y] = Ynut_wB;
5319           next[x][y] = Xblank;
5320           cave[x-1][y] = Ynut_w;
5321           next[x-1][y] = Xnut_pause;
5322           if (cave[x][y+1] == Xbumper)
5323             cave[x][y+1] = Ybumper;
5324           return;
5325         }
5326       }
5327       else
5328       {
5329         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
5330         {
5331           cave[x][y] = Ynut_wB;
5332           next[x][y] = Xblank;
5333           cave[x-1][y] = Ynut_w;
5334           next[x-1][y] = Xnut_pause;
5335           if (cave[x][y+1] == Xbumper)
5336             cave[x][y+1] = Ybumper;
5337           return;
5338         }
5339
5340         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
5341         {
5342           cave[x][y] = Ynut_eB;
5343           next[x][y] = Xblank;
5344           cave[x+1][y] = Ynut_e;
5345           next[x+1][y] = Xnut_pause;
5346           if (cave[x][y+1] == Xbumper)
5347             cave[x][y+1] = Ybumper;
5348           return;
5349         }
5350       }
5351   }
5352 }
5353
5354 static void Lnut_pause(int x, int y)
5355 {
5356   switch (cave[x][y+1])
5357   {
5358     case Xblank:
5359     case Xsplash_e:
5360     case Xsplash_w:
5361     case Xfake_acid_1:
5362     case Xfake_acid_2:
5363     case Xfake_acid_3:
5364     case Xfake_acid_4:
5365     case Xfake_acid_5:
5366     case Xfake_acid_6:
5367     case Xfake_acid_7:
5368     case Xfake_acid_8:
5369       cave[x][y] = Ynut_sB;
5370       next[x][y] = Xblank;
5371       cave[x][y+1] = Ynut_s;
5372       next[x][y+1] = Xnut_fall;
5373       return;
5374
5375     case Xacid_1:
5376     case Xacid_2:
5377     case Xacid_3:
5378     case Xacid_4:
5379     case Xacid_5:
5380     case Xacid_6:
5381     case Xacid_7:
5382     case Xacid_8:
5383       cave[x][y] = Ynut_sB;
5384       next[x][y] = Xblank;
5385       if (cave[x+1][y] == Xblank)
5386         cave[x+1][y] = Xsplash_e;
5387       if (cave[x-1][y] == Xblank)
5388         cave[x-1][y] = Xsplash_w;
5389       play_element_sound(x, y, SOUND_acid, Xacid_1);
5390       return;
5391
5392     default:
5393       cave[x][y] = Xnut;
5394       next[x][y] = Xnut;
5395       return;
5396   }
5397 }
5398
5399 static void Lnut_fall(int x, int y)
5400 {
5401   switch (cave[x][y+1])
5402   {
5403     case Zplayer:
5404     case Xblank:
5405     case Xsplash_e:
5406     case Xsplash_w:
5407     case Xfake_acid_1:
5408     case Xfake_acid_2:
5409     case Xfake_acid_3:
5410     case Xfake_acid_4:
5411     case Xfake_acid_5:
5412     case Xfake_acid_6:
5413     case Xfake_acid_7:
5414     case Xfake_acid_8:
5415     case Xfake_acid_1_player:
5416     case Xfake_acid_2_player:
5417     case Xfake_acid_3_player:
5418     case Xfake_acid_4_player:
5419     case Xfake_acid_5_player:
5420     case Xfake_acid_6_player:
5421     case Xfake_acid_7_player:
5422     case Xfake_acid_8_player:
5423       cave[x][y] = Ynut_sB;
5424       next[x][y] = Xblank;
5425       cave[x][y+1] = Ynut_s;
5426       next[x][y+1] = Xnut_fall;
5427       return;
5428
5429     case Xacid_1:
5430     case Xacid_2:
5431     case Xacid_3:
5432     case Xacid_4:
5433     case Xacid_5:
5434     case Xacid_6:
5435     case Xacid_7:
5436     case Xacid_8:
5437       cave[x][y] = Ynut_sB;
5438       next[x][y] = Xblank;
5439       if (cave[x+1][y] == Xblank)
5440         cave[x+1][y] = Xsplash_e;
5441       if (cave[x-1][y] == Xblank)
5442         cave[x-1][y] = Xsplash_w;
5443       play_element_sound(x, y, SOUND_acid, Xacid_1);
5444       return;
5445
5446     default:
5447       cave[x][y] = Xnut;
5448       next[x][y] = Xnut;
5449       play_element_sound(x, y, SOUND_nut, Xnut);
5450       return;
5451   }
5452 }
5453
5454 static void Lspring(int x, int y)
5455 {
5456   switch (cave[x][y+1])
5457   {
5458     case Xblank:
5459     case Xsplash_e:
5460     case Xsplash_w:
5461     case Xfake_acid_1:
5462     case Xfake_acid_2:
5463     case Xfake_acid_3:
5464     case Xfake_acid_4:
5465     case Xfake_acid_5:
5466     case Xfake_acid_6:
5467     case Xfake_acid_7:
5468     case Xfake_acid_8:
5469     case Xplant:
5470     case Yplant:
5471       cave[x][y] = Yspring_sB;
5472       next[x][y] = Xblank;
5473       cave[x][y+1] = Yspring_s;
5474       next[x][y+1] = Xspring_fall;
5475       return;
5476
5477     case Xacid_1:
5478     case Xacid_2:
5479     case Xacid_3:
5480     case Xacid_4:
5481     case Xacid_5:
5482     case Xacid_6:
5483     case Xacid_7:
5484     case Xacid_8:
5485       cave[x][y] = Yspring_sB;
5486       next[x][y] = Xblank;
5487       if (cave[x+1][y] == Xblank)
5488         cave[x+1][y] = Xsplash_e;
5489       if (cave[x-1][y] == Xblank)
5490         cave[x-1][y] = Xsplash_w;
5491       play_element_sound(x, y, SOUND_acid, Xacid_1);
5492       return;
5493
5494     case Xandroid:
5495     case Xandroid_1_n:
5496     case Xandroid_2_n:
5497     case Xandroid_1_e:
5498     case Xandroid_2_e:
5499     case Xandroid_1_s:
5500     case Xandroid_2_s:
5501     case Xandroid_1_w:
5502     case Xandroid_2_w:
5503     case Xemerald:
5504     case Xemerald_pause:
5505     case Xdiamond:
5506     case Xdiamond_pause:
5507     case Xstone:
5508     case Xstone_pause:
5509     case Xbomb:
5510     case Xbomb_pause:
5511     case Xnut:
5512     case Xnut_pause:
5513     case Xspring:
5514     case Xspring_pause:
5515     case Xspring_e:
5516     case Xspring_w:
5517     case Xkey_1:
5518     case Xkey_2:
5519     case Xkey_3:
5520     case Xkey_4:
5521     case Xkey_5:
5522     case Xkey_6:
5523     case Xkey_7:
5524     case Xkey_8:
5525     case Xballoon:
5526     case Xball_1:
5527     case Xball_2:
5528     case Xswitch:
5529     case Xbumper:
5530     case Ybumper:
5531     case Xacid_ne:
5532     case Xacid_nw:
5533     case Xslide_ns:
5534     case Xslide_ew:
5535     case Xroundwall_1:
5536     case Xroundwall_2:
5537     case Xroundwall_3:
5538     case Xroundwall_4:
5539       if (RANDOM(2))
5540       {
5541         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
5542         {
5543           cave[x][y] = Yspring_eB;
5544           next[x][y] = Xblank;
5545           cave[x+1][y] = Yspring_e;
5546 #ifdef SPRING_ROLL
5547           next[x+1][y] = Xspring_e;
5548 #else
5549           next[x+1][y] = Xspring_pause;
5550 #endif
5551           if (cave[x][y+1] == Xbumper)
5552             cave[x][y+1] = Ybumper;
5553           return;
5554         }
5555
5556         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
5557         {
5558           cave[x][y] = Yspring_wB;
5559           next[x][y] = Xblank;
5560           cave[x-1][y] = Yspring_w;
5561 #ifdef SPRING_ROLL
5562           next[x-1][y] = Xspring_w;
5563 #else
5564           next[x-1][y] = Xspring_pause;
5565 #endif
5566           if (cave[x][y+1] == Xbumper)
5567             cave[x][y+1] = Ybumper;
5568           return;
5569         }
5570       }
5571       else
5572       {
5573         if (is_blank[cave[x-1][y]] && is_blank_or_acid[cave[x-1][y+1]])
5574         {
5575           cave[x][y] = Yspring_wB;
5576           next[x][y] = Xblank;
5577           cave[x-1][y] = Yspring_w;
5578 #ifdef SPRING_ROLL
5579           next[x-1][y] = Xspring_w;
5580 #else
5581           next[x-1][y] = Xspring_pause;
5582 #endif
5583           if (cave[x][y+1] == Xbumper)
5584             cave[x][y+1] = Ybumper;
5585           return;
5586         }
5587
5588         if (is_blank[cave[x+1][y]] && is_blank_or_acid[cave[x+1][y+1]])
5589         {
5590           cave[x][y] = Yspring_eB;
5591           next[x][y] = Xblank;
5592           cave[x+1][y] = Yspring_e;
5593 #ifdef SPRING_ROLL
5594           next[x+1][y] = Xspring_e;
5595 #else
5596           next[x+1][y] = Xspring_pause;
5597 #endif
5598           if (cave[x][y+1] == Xbumper)
5599             cave[x][y+1] = Ybumper;
5600           return;
5601         }
5602       }
5603   }
5604 }
5605
5606 static void Lspring_pause(int x, int y)
5607 {
5608   switch (cave[x][y+1])
5609   {
5610     case Xblank:
5611     case Xsplash_e:
5612     case Xsplash_w:
5613     case Xfake_acid_1:
5614     case Xfake_acid_2:
5615     case Xfake_acid_3:
5616     case Xfake_acid_4:
5617     case Xfake_acid_5:
5618     case Xfake_acid_6:
5619     case Xfake_acid_7:
5620     case Xfake_acid_8:
5621       cave[x][y] = Yspring_sB;
5622       next[x][y] = Xblank;
5623       cave[x][y+1] = Yspring_s;
5624       next[x][y+1] = Xspring_fall;
5625       return;
5626
5627     case Xacid_1:
5628     case Xacid_2:
5629     case Xacid_3:
5630     case Xacid_4:
5631     case Xacid_5:
5632     case Xacid_6:
5633     case Xacid_7:
5634     case Xacid_8:
5635       cave[x][y] = Yspring_sB;
5636       next[x][y] = Xblank;
5637       if (cave[x+1][y] == Xblank)
5638         cave[x+1][y] = Xsplash_e;
5639       if (cave[x-1][y] == Xblank)
5640         cave[x-1][y] = Xsplash_w;
5641       play_element_sound(x, y, SOUND_acid, Xacid_1);
5642       return;
5643
5644     default:
5645       cave[x][y] = Xspring;
5646       next[x][y] = Xspring;
5647       return;
5648   }
5649 }
5650
5651 static void Lspring_e(int x, int y)
5652 {
5653   switch (cave[x][y+1])
5654   {
5655     case Xblank:
5656     case Xsplash_e:
5657     case Xsplash_w:
5658     case Xfake_acid_1:
5659     case Xfake_acid_2:
5660     case Xfake_acid_3:
5661     case Xfake_acid_4:
5662     case Xfake_acid_5:
5663     case Xfake_acid_6:
5664     case Xfake_acid_7:
5665     case Xfake_acid_8:
5666       cave[x][y] = Yspring_sB;
5667       next[x][y] = Xblank;
5668       cave[x][y+1] = Yspring_s;
5669       next[x][y+1] = Xspring_fall;
5670       return;
5671
5672     case Xacid_1:
5673     case Xacid_2:
5674     case Xacid_3:
5675     case Xacid_4:
5676     case Xacid_5:
5677     case Xacid_6:
5678     case Xacid_7:
5679     case Xacid_8:
5680       cave[x][y] = Yspring_sB;
5681       next[x][y] = Xblank;
5682       if (cave[x+1][y] == Xblank)
5683         cave[x+1][y] = Xsplash_e;
5684       if (cave[x-1][y] == Xblank)
5685         cave[x-1][y] = Xsplash_w;
5686       play_element_sound(x, y, SOUND_acid, Xacid_1);
5687       return;
5688
5689     case Xbumper:
5690       cave[x][y+1] = Ybumper;
5691   }
5692
5693   switch (cave[x+1][y])
5694   {
5695     case Xblank:
5696     case Xsplash_e:
5697     case Xsplash_w:
5698     case Xfake_acid_1:
5699     case Xfake_acid_2:
5700     case Xfake_acid_3:
5701     case Xfake_acid_4:
5702     case Xfake_acid_5:
5703     case Xfake_acid_6:
5704     case Xfake_acid_7:
5705     case Xfake_acid_8:
5706     case Yalien_nB:
5707     case Yalien_eB:
5708     case Yalien_sB:
5709     case Yalien_wB:
5710       cave[x][y] = Yspring_eB;
5711       next[x][y] = Xblank;
5712       cave[x+1][y] = Yspring_e;
5713       next[x+1][y] = Xspring_e;
5714       return;
5715
5716     case Xacid_1:
5717     case Xacid_2:
5718     case Xacid_3:
5719     case Xacid_4:
5720     case Xacid_5:
5721     case Xacid_6:
5722     case Xacid_7:
5723     case Xacid_8:
5724       cave[x][y] = Yspring_eB;
5725       next[x][y] = Xblank;
5726       if (cave[x+2][y-1] == Xblank)
5727         cave[x+2][y-1] = Xsplash_e;
5728       if (cave[x][y-1] == Xblank)
5729         cave[x][y-1] = Xsplash_w;
5730       play_element_sound(x, y, SOUND_acid, Xacid_1);
5731       return;
5732
5733     case Xalien:
5734     case Xalien_pause:
5735     case Yalien_n:
5736     case Yalien_e:
5737     case Yalien_s:
5738     case Yalien_w:
5739       cave[x][y] = Yspring_alien_eB;
5740       next[x][y] = Xblank;
5741       cave[x+1][y] = Yspring_alien_e;
5742       next[x+1][y] = Xspring_e;
5743       play_element_sound(x, y, SOUND_slurp, Xalien);
5744       score += lev.slurp_score;
5745       return;
5746
5747     case Xbumper:
5748     case Ybumper:
5749       cave[x+1][y] = Ybumper;
5750       next[x][y] = Xspring_w;
5751       play_element_sound(x, y, SOUND_spring, Xspring);
5752       return;
5753
5754     default:
5755       cave[x][y] = Xspring;
5756       next[x][y] = Xspring;
5757       play_element_sound(x, y, SOUND_spring, Xspring);
5758       return;
5759   }
5760 }
5761
5762 static void Lspring_w(int x, int y)
5763 {
5764   switch (cave[x][y+1])
5765   {
5766     case Xblank:
5767     case Xsplash_e:
5768     case Xsplash_w:
5769     case Xfake_acid_1:
5770     case Xfake_acid_2:
5771     case Xfake_acid_3:
5772     case Xfake_acid_4:
5773     case Xfake_acid_5:
5774     case Xfake_acid_6:
5775     case Xfake_acid_7:
5776     case Xfake_acid_8:
5777       cave[x][y] = Yspring_sB;
5778       next[x][y] = Xblank;
5779       cave[x][y+1] = Yspring_s;
5780       next[x][y+1] = Xspring_fall;
5781       return;
5782
5783     case Xacid_1:
5784     case Xacid_2:
5785     case Xacid_3:
5786     case Xacid_4:
5787     case Xacid_5:
5788     case Xacid_6:
5789     case Xacid_7:
5790     case Xacid_8:
5791       cave[x][y] = Yspring_sB;
5792       next[x][y] = Xblank;
5793       if (cave[x+1][y] == Xblank)
5794         cave[x+1][y] = Xsplash_e;
5795       if (cave[x-1][y] == Xblank)
5796         cave[x-1][y] = Xsplash_w;
5797       play_element_sound(x, y, SOUND_acid, Xacid_1);
5798       return;
5799
5800     case Xbumper:
5801       cave[x][y+1] = Ybumper;
5802   }
5803
5804   switch (cave[x-1][y])
5805   {
5806     case Xblank:
5807     case Xsplash_e:
5808     case Xsplash_w:
5809     case Xfake_acid_1:
5810     case Xfake_acid_2:
5811     case Xfake_acid_3:
5812     case Xfake_acid_4:
5813     case Xfake_acid_5:
5814     case Xfake_acid_6:
5815     case Xfake_acid_7:
5816     case Xfake_acid_8:
5817     case Yalien_nB:
5818     case Yalien_eB:
5819     case Yalien_sB:
5820     case Yalien_wB:
5821       cave[x][y] = Yspring_wB;
5822       next[x][y] = Xblank;
5823       cave[x-1][y] = Yspring_w;
5824       next[x-1][y] = Xspring_w;
5825       return;
5826
5827     case Xacid_1:
5828     case Xacid_2:
5829     case Xacid_3:
5830     case Xacid_4:
5831     case Xacid_5:
5832     case Xacid_6:
5833     case Xacid_7:
5834     case Xacid_8:
5835       cave[x][y] = Yspring_wB;
5836       next[x][y] = Xblank;
5837       if (cave[x][y-1] == Xblank)
5838         cave[x][y-1] = Xsplash_e;
5839       if (cave[x-2][y-1] == Xblank)
5840         cave[x-2][y-1] = Xsplash_w;
5841       play_element_sound(x, y, SOUND_acid, Xacid_1);
5842       return;
5843
5844     case Xalien:
5845     case Xalien_pause:
5846     case Yalien_n:
5847     case Yalien_e:
5848     case Yalien_s:
5849     case Yalien_w:
5850       cave[x][y] = Yspring_alien_wB;
5851       next[x][y] = Xblank;
5852       cave[x-1][y] = Yspring_alien_w;
5853       next[x-1][y] = Xspring_w;
5854       play_element_sound(x, y, SOUND_slurp, Xalien);
5855       score += lev.slurp_score;
5856       return;
5857
5858     case Xbumper:
5859     case Ybumper:
5860       cave[x-1][y] = Ybumper;
5861       next[x][y] = Xspring_e;
5862       play_element_sound(x, y, SOUND_spring, Xspring);
5863       return;
5864
5865     default:
5866       cave[x][y] = Xspring;
5867       next[x][y] = Xspring;
5868       play_element_sound(x, y, SOUND_spring, Xspring);
5869       return;
5870   }
5871 }
5872
5873 static void Lspring_fall(int x, int y)
5874 {
5875   switch (cave[x][y+1])
5876   {
5877     case Zplayer:
5878     case Xblank:
5879     case Xsplash_e:
5880     case Xsplash_w:
5881     case Xfake_acid_1:
5882     case Xfake_acid_2:
5883     case Xfake_acid_3:
5884     case Xfake_acid_4:
5885     case Xfake_acid_5:
5886     case Xfake_acid_6:
5887     case Xfake_acid_7:
5888     case Xfake_acid_8:
5889     case Xfake_acid_1_player:
5890     case Xfake_acid_2_player:
5891     case Xfake_acid_3_player:
5892     case Xfake_acid_4_player:
5893     case Xfake_acid_5_player:
5894     case Xfake_acid_6_player:
5895     case Xfake_acid_7_player:
5896     case Xfake_acid_8_player:
5897       cave[x][y] = Yspring_sB;
5898       next[x][y] = Xblank;
5899       cave[x][y+1] = Yspring_s;
5900       next[x][y+1] = Xspring_fall;
5901       return;
5902
5903     case Xacid_1:
5904     case Xacid_2:
5905     case Xacid_3:
5906     case Xacid_4:
5907     case Xacid_5:
5908     case Xacid_6:
5909     case Xacid_7:
5910     case Xacid_8:
5911       cave[x][y] = Yspring_sB;
5912       next[x][y] = Xblank;
5913       if (cave[x+1][y] == Xblank)
5914         cave[x+1][y] = Xsplash_e;
5915       if (cave[x-1][y] == Xblank)
5916         cave[x-1][y] = Xsplash_w;
5917       play_element_sound(x, y, SOUND_acid, Xacid_1);
5918       return;
5919
5920     case Xeater_n:
5921     case Xeater_e:
5922     case Xeater_s:
5923     case Xeater_w:
5924       cave[x][y] = Yspring_sB;
5925       next[x][y] = Xblank;
5926       cave[x][y+1] = Yeater_spring;
5927       next[x][y+1] = Zeater;
5928       Lboom_eater_old(x, y+1);
5929       score += lev.eater_score;
5930       return;
5931
5932     case Xalien:
5933     case Xalien_pause:
5934       cave[x][y] = Yspring_sB;
5935       next[x][y] = Xblank;
5936       cave[x][y+1] = Yalien_spring;
5937       next[x][y+1] = Ztank;
5938       Lboom_tank_old(x, y+1);
5939       score += lev.alien_score;
5940       return;
5941
5942     case Xbug_1_n:
5943     case Xbug_1_e:
5944     case Xbug_1_s:
5945     case Xbug_1_w:
5946     case Xbug_2_n:
5947     case Xbug_2_e:
5948     case Xbug_2_s:
5949     case Xbug_2_w:
5950       cave[x][y] = Yspring_sB;
5951       next[x][y] = Xblank;
5952       cave[x][y+1] = Ybug_spring;
5953       next[x][y+1] = Zbug;
5954       Lboom_bug_old(x, y+1);
5955       score += lev.bug_score;
5956       return;
5957
5958     case Xtank_1_n:
5959     case Xtank_1_e:
5960     case Xtank_1_s:
5961     case Xtank_1_w:
5962     case Xtank_2_n:
5963     case Xtank_2_e:
5964     case Xtank_2_s:
5965     case Xtank_2_w:
5966       cave[x][y] = Yspring_sB;
5967       next[x][y] = Xblank;
5968       cave[x][y+1] = Ytank_spring;
5969       next[x][y+1] = Ztank;
5970       Lboom_tank_old(x, y+1);
5971       score += lev.tank_score;
5972       return;
5973
5974     case Xbomb:
5975     case Xbomb_pause:
5976       cave[x][y] = Xspring;
5977       next[x][y] = Xspring;
5978       cave[x][y+1] = Ybomb_blank;
5979       next[x][y+1] = Ztank;
5980       Lboom_tank_old(x, y+1);
5981       return;
5982
5983     default:
5984       cave[x][y] = Xspring;
5985       next[x][y] = Xspring;
5986       play_element_sound(x, y, SOUND_spring, Xspring);
5987       return;
5988   }
5989 }
5990
5991 static void Lpush_emerald_e(int x, int y)
5992 {
5993   cave[x][y] = Yemerald_eB;
5994   next[x][y] = Xblank;
5995
5996   switch (cave[x+1][y])
5997   {
5998     case Zplayer:
5999       if (!game_em.use_old_push_elements)
6000         break;
6001     case Zborder:
6002     case Zbug:
6003     case Ztank:
6004     case Zeater:
6005     case Zdynamite:
6006     case Zboom:
6007     case Xchain:
6008     case Xboom_bug:
6009     case Xboom_tank:
6010     case Xboom_android:
6011     case Xboom_1:
6012       Lpush_element_old(x, y, Xemerald);
6013       return;
6014
6015 #ifdef ACID_ROLL
6016     case Xacid_1:
6017     case Xacid_2:
6018     case Xacid_3:
6019     case Xacid_4:
6020     case Xacid_5:
6021     case Xacid_6:
6022     case Xacid_7:
6023     case Xacid_8:
6024       if (game_em.use_old_push_into_acid)
6025         break;
6026       if (cave[x+2][y-1] == Xblank)
6027         cave[x+2][y-1] = Xsplash_e;
6028       if (cave[x][y-1] == Xblank)
6029         cave[x][y-1] = Xsplash_w;
6030       play_element_sound(x, y, SOUND_acid, Xacid_1);
6031       return;
6032 #endif
6033   }
6034
6035   cave[x+1][y] = Yemerald_e;
6036   next[x+1][y] = Xemerald_pause;
6037 }
6038
6039 static void Lpush_emerald_w(int x, int y)
6040 {
6041   cave[x][y] = Yemerald_wB;
6042   next[x][y] = Xblank;
6043
6044   switch (cave[x-1][y])
6045   {
6046     case Zplayer:
6047       if (!game_em.use_old_push_elements)
6048         break;
6049     case Zborder:
6050     case Zbug:
6051     case Ztank:
6052     case Zeater:
6053     case Zdynamite:
6054     case Zboom:
6055     case Xchain:
6056     case Xboom_bug:
6057     case Xboom_tank:
6058     case Xboom_android:
6059     case Xboom_1:
6060       Lpush_element_old(x, y, Xemerald);
6061       return;
6062
6063 #ifdef ACID_ROLL
6064     case Xacid_1:
6065     case Xacid_2:
6066     case Xacid_3:
6067     case Xacid_4:
6068     case Xacid_5:
6069     case Xacid_6:
6070     case Xacid_7:
6071     case Xacid_8:
6072       if (game_em.use_old_push_into_acid)
6073         break;
6074       if (cave[x][y-1] == Xblank)
6075         cave[x][y-1] = Xsplash_e;
6076       if (cave[x-2][y-1] == Xblank)
6077         cave[x-2][y-1] = Xsplash_w;
6078       play_element_sound(x, y, SOUND_acid, Xacid_1);
6079       return;
6080 #endif
6081   }
6082
6083   cave[x-1][y] = Yemerald_w;
6084   next[x-1][y] = Xemerald_pause;
6085 }
6086
6087 static void Lpush_diamond_e(int x, int y)
6088 {
6089   cave[x][y] = Ydiamond_eB;
6090   next[x][y] = Xblank;
6091
6092   switch (cave[x+1][y])
6093   {
6094     case Zplayer:
6095       if (!game_em.use_old_push_elements)
6096         break;
6097     case Zborder:
6098     case Zbug:
6099     case Ztank:
6100     case Zeater:
6101     case Zdynamite:
6102     case Zboom:
6103     case Xchain:
6104     case Xboom_bug:
6105     case Xboom_tank:
6106     case Xboom_android:
6107     case Xboom_1:
6108       Lpush_element_old(x, y, Xdiamond);
6109       return;
6110
6111 #ifdef ACID_ROLL
6112     case Xacid_1:
6113     case Xacid_2:
6114     case Xacid_3:
6115     case Xacid_4:
6116     case Xacid_5:
6117     case Xacid_6:
6118     case Xacid_7:
6119     case Xacid_8:
6120       if (game_em.use_old_push_into_acid)
6121         break;
6122       if (cave[x+2][y-1] == Xblank)
6123         cave[x+2][y-1] = Xsplash_e;
6124       if (cave[x][y-1] == Xblank)
6125         cave[x][y-1] = Xsplash_w;
6126       play_element_sound(x, y, SOUND_acid, Xacid_1);
6127       return;
6128 #endif
6129   }
6130
6131   cave[x+1][y] = Ydiamond_e;
6132   next[x+1][y] = Xdiamond_pause;
6133 }
6134
6135 static void Lpush_diamond_w(int x, int y)
6136 {
6137   cave[x][y] = Ydiamond_wB;
6138   next[x][y] = Xblank;
6139
6140   switch (cave[x-1][y])
6141   {
6142     case Zplayer:
6143       if (!game_em.use_old_push_elements)
6144         break;
6145     case Zborder:
6146     case Zbug:
6147     case Ztank:
6148     case Zeater:
6149     case Zdynamite:
6150     case Zboom:
6151     case Xchain:
6152     case Xboom_bug:
6153     case Xboom_tank:
6154     case Xboom_android:
6155     case Xboom_1:
6156       Lpush_element_old(x, y, Xdiamond);
6157       return;
6158
6159 #ifdef ACID_ROLL
6160     case Xacid_1:
6161     case Xacid_2:
6162     case Xacid_3:
6163     case Xacid_4:
6164     case Xacid_5:
6165     case Xacid_6:
6166     case Xacid_7:
6167     case Xacid_8:
6168       if (game_em.use_old_push_into_acid)
6169         break;
6170       if (cave[x][y-1] == Xblank)
6171         cave[x][y-1] = Xsplash_e;
6172       if (cave[x-2][y-1] == Xblank)
6173         cave[x-2][y-1] = Xsplash_w;
6174       play_element_sound(x, y, SOUND_acid, Xacid_1);
6175       return;
6176 #endif
6177   }
6178
6179   cave[x-1][y] = Ydiamond_w;
6180   next[x-1][y] = Xdiamond_pause;
6181 }
6182
6183 static void Lpush_stone_e(int x, int y)
6184 {
6185   cave[x][y] = Ystone_eB;
6186   next[x][y] = Xblank;
6187
6188   switch (cave[x+1][y])
6189   {
6190     case Zplayer:
6191       if (!game_em.use_old_push_elements)
6192         break;
6193     case Zborder:
6194     case Zbug:
6195     case Ztank:
6196     case Zeater:
6197     case Zdynamite:
6198     case Zboom:
6199     case Xchain:
6200     case Xboom_bug:
6201     case Xboom_tank:
6202     case Xboom_android:
6203     case Xboom_1:
6204       Lpush_element_old(x, y, Xstone);
6205       return;
6206
6207 #ifdef ACID_ROLL
6208     case Xacid_1:
6209     case Xacid_2:
6210     case Xacid_3:
6211     case Xacid_4:
6212     case Xacid_5:
6213     case Xacid_6:
6214     case Xacid_7:
6215     case Xacid_8:
6216       if (game_em.use_old_push_into_acid)
6217         break;
6218       if (cave[x+2][y-1] == Xblank)
6219         cave[x+2][y-1] = Xsplash_e;
6220       if (cave[x][y-1] == Xblank)
6221         cave[x][y-1] = Xsplash_w;
6222       play_element_sound(x, y, SOUND_acid, Xacid_1);
6223       return;
6224 #endif
6225   }
6226
6227   cave[x+1][y] = Ystone_e;
6228   next[x+1][y] = Xstone_pause;
6229 }
6230
6231 static void Lpush_stone_w(int x, int y)
6232 {
6233   cave[x][y] = Ystone_wB;
6234   next[x][y] = Xblank;
6235
6236   switch (cave[x-1][y])
6237   {
6238     case Zplayer:
6239       if (!game_em.use_old_push_elements)
6240         break;
6241     case Zborder:
6242     case Zbug:
6243     case Ztank:
6244     case Zeater:
6245     case Zdynamite:
6246     case Zboom:
6247     case Xchain:
6248     case Xboom_bug:
6249     case Xboom_tank:
6250     case Xboom_android:
6251     case Xboom_1:
6252       Lpush_element_old(x, y, Xstone);
6253       return;
6254
6255 #ifdef ACID_ROLL
6256     case Xacid_1:
6257     case Xacid_2:
6258     case Xacid_3:
6259     case Xacid_4:
6260     case Xacid_5:
6261     case Xacid_6:
6262     case Xacid_7:
6263     case Xacid_8:
6264       if (game_em.use_old_push_into_acid)
6265         break;
6266       if (cave[x][y-1] == Xblank)
6267         cave[x][y-1] = Xsplash_e;
6268       if (cave[x-2][y-1] == Xblank)
6269         cave[x-2][y-1] = Xsplash_w;
6270       play_element_sound(x, y, SOUND_acid, Xacid_1);
6271       return;
6272 #endif
6273   }
6274
6275   cave[x-1][y] = Ystone_w;
6276   next[x-1][y] = Xstone_pause;
6277 }
6278
6279 static void Lpush_bomb_e(int x, int y)
6280 {
6281   cave[x][y] = Ybomb_eB;
6282   next[x][y] = Xblank;
6283
6284   switch (cave[x+1][y])
6285   {
6286     case Zplayer:
6287       if (!game_em.use_old_push_elements)
6288         break;
6289     case Zborder:
6290     case Zbug:
6291     case Ztank:
6292     case Zeater:
6293     case Zdynamite:
6294     case Zboom:
6295     case Xchain:
6296     case Xboom_bug:
6297     case Xboom_tank:
6298     case Xboom_android:
6299     case Xboom_1:
6300       Lpush_element_old(x, y, Xbomb);
6301       return;
6302
6303 #ifdef ACID_ROLL
6304     case Xacid_1:
6305     case Xacid_2:
6306     case Xacid_3:
6307     case Xacid_4:
6308     case Xacid_5:
6309     case Xacid_6:
6310     case Xacid_7:
6311     case Xacid_8:
6312       if (game_em.use_old_push_into_acid)
6313         break;
6314       if (cave[x+2][y-1] == Xblank)
6315         cave[x+2][y-1] = Xsplash_e;
6316       if (cave[x][y-1] == Xblank)
6317         cave[x][y-1] = Xsplash_w;
6318       play_element_sound(x, y, SOUND_acid, Xacid_1);
6319       return;
6320 #endif
6321   }
6322
6323   cave[x+1][y] = Ybomb_e;
6324   next[x+1][y] = Xbomb_pause;
6325 }
6326
6327 static void Lpush_bomb_w(int x, int y)
6328 {
6329   cave[x][y] = Ybomb_wB;
6330   next[x][y] = Xblank;
6331
6332   switch (cave[x-1][y])
6333   {
6334     case Zplayer:
6335       if (!game_em.use_old_push_elements)
6336         break;
6337     case Zborder:
6338     case Zbug:
6339     case Ztank:
6340     case Zeater:
6341     case Zdynamite:
6342     case Zboom:
6343     case Xchain:
6344     case Xboom_bug:
6345     case Xboom_tank:
6346     case Xboom_android:
6347     case Xboom_1:
6348       Lpush_element_old(x, y, Xbomb);
6349       return;
6350
6351 #ifdef ACID_ROLL
6352     case Xacid_1:
6353     case Xacid_2:
6354     case Xacid_3:
6355     case Xacid_4:
6356     case Xacid_5:
6357     case Xacid_6:
6358     case Xacid_7:
6359     case Xacid_8:
6360       if (game_em.use_old_push_into_acid)
6361         break;
6362       if (cave[x][y-1] == Xblank)
6363         cave[x][y-1] = Xsplash_e;
6364       if (cave[x-2][y-1] == Xblank)
6365         cave[x-2][y-1] = Xsplash_w;
6366       play_element_sound(x, y, SOUND_acid, Xacid_1);
6367       return;
6368 #endif
6369   }
6370
6371   cave[x-1][y] = Ybomb_w;
6372   next[x-1][y] = Xbomb_pause;
6373 }
6374
6375 static void Lpush_nut_e(int x, int y)
6376 {
6377   cave[x][y] = Ynut_eB;
6378   next[x][y] = Xblank;
6379
6380   switch (cave[x+1][y])
6381   {
6382     case Zplayer:
6383       if (!game_em.use_old_push_elements)
6384         break;
6385     case Zborder:
6386     case Zbug:
6387     case Ztank:
6388     case Zeater:
6389     case Zdynamite:
6390     case Zboom:
6391     case Xchain:
6392     case Xboom_bug:
6393     case Xboom_tank:
6394     case Xboom_android:
6395     case Xboom_1:
6396       Lpush_element_old(x, y, Xnut);
6397       return;
6398
6399 #ifdef ACID_ROLL
6400     case Xacid_1:
6401     case Xacid_2:
6402     case Xacid_3:
6403     case Xacid_4:
6404     case Xacid_5:
6405     case Xacid_6:
6406     case Xacid_7:
6407     case Xacid_8:
6408       if (game_em.use_old_push_into_acid)
6409         break;
6410       if (cave[x+2][y-1] == Xblank)
6411         cave[x+2][y-1] = Xsplash_e;
6412       if (cave[x][y-1] == Xblank)
6413         cave[x][y-1] = Xsplash_w;
6414       play_element_sound(x, y, SOUND_acid, Xacid_1);
6415       return;
6416 #endif
6417   }
6418
6419   cave[x+1][y] = Ynut_e;
6420   next[x+1][y] = Xnut_pause;
6421 }
6422
6423 static void Lpush_nut_w(int x, int y)
6424 {
6425   cave[x][y] = Ynut_wB;
6426   next[x][y] = Xblank;
6427
6428   switch (cave[x-1][y])
6429   {
6430     case Zplayer:
6431       if (!game_em.use_old_push_elements)
6432         break;
6433     case Zborder:
6434     case Zbug:
6435     case Ztank:
6436     case Zeater:
6437     case Zdynamite:
6438     case Zboom:
6439     case Xchain:
6440     case Xboom_bug:
6441     case Xboom_tank:
6442     case Xboom_android:
6443     case Xboom_1:
6444       Lpush_element_old(x, y, Xnut);
6445       return;
6446
6447 #ifdef ACID_ROLL
6448     case Xacid_1:
6449     case Xacid_2:
6450     case Xacid_3:
6451     case Xacid_4:
6452     case Xacid_5:
6453     case Xacid_6:
6454     case Xacid_7:
6455     case Xacid_8:
6456       if (game_em.use_old_push_into_acid)
6457         break;
6458       if (cave[x][y-1] == Xblank)
6459         cave[x][y-1] = Xsplash_e;
6460       if (cave[x-2][y-1] == Xblank)
6461         cave[x-2][y-1] = Xsplash_w;
6462       play_element_sound(x, y, SOUND_acid, Xacid_1);
6463       return;
6464 #endif
6465   }
6466
6467   cave[x-1][y] = Ynut_w;
6468   next[x-1][y] = Xnut_pause;
6469 }
6470
6471 static void Lpush_spring_e(int x, int y)
6472 {
6473   cave[x][y] = Yspring_eB;
6474   next[x][y] = Xblank;
6475
6476   switch (cave[x+1][y])
6477   {
6478     case Zplayer:
6479       if (!game_em.use_old_push_elements)
6480         break;
6481     case Zborder:
6482     case Zbug:
6483     case Ztank:
6484     case Zeater:
6485     case Zdynamite:
6486     case Zboom:
6487     case Xchain:
6488     case Xboom_bug:
6489     case Xboom_tank:
6490     case Xboom_android:
6491     case Xboom_1:
6492       Lpush_element_old(x, y, Xspring);
6493       return;
6494
6495 #ifdef ACID_ROLL
6496     case Xacid_1:
6497     case Xacid_2:
6498     case Xacid_3:
6499     case Xacid_4:
6500     case Xacid_5:
6501     case Xacid_6:
6502     case Xacid_7:
6503     case Xacid_8:
6504       if (game_em.use_old_push_into_acid)
6505         break;
6506       if (cave[x+2][y-1] == Xblank)
6507         cave[x+2][y-1] = Xsplash_e;
6508       if (cave[x][y-1] == Xblank)
6509         cave[x][y-1] = Xsplash_w;
6510       play_element_sound(x, y, SOUND_acid, Xacid_1);
6511       return;
6512 #endif
6513   }
6514
6515   cave[x+1][y] = Yspring_e;
6516   next[x+1][y] = Xspring_e;
6517 }
6518
6519 static void Lpush_spring_w(int x, int y)
6520 {
6521   cave[x][y] = Yspring_wB;
6522   next[x][y] = Xblank;
6523
6524   switch (cave[x-1][y])
6525   {
6526     case Zplayer:
6527       if (!game_em.use_old_push_elements)
6528         break;
6529     case Zborder:
6530     case Zbug:
6531     case Ztank:
6532     case Zeater:
6533     case Zdynamite:
6534     case Zboom:
6535     case Xchain:
6536     case Xboom_bug:
6537     case Xboom_tank:
6538     case Xboom_android:
6539     case Xboom_1:
6540       Lpush_element_old(x, y, Xspring);
6541       return;
6542
6543 #ifdef ACID_ROLL
6544     case Xacid_1:
6545     case Xacid_2:
6546     case Xacid_3:
6547     case Xacid_4:
6548     case Xacid_5:
6549     case Xacid_6:
6550     case Xacid_7:
6551     case Xacid_8:
6552       if (game_em.use_old_push_into_acid)
6553         break;
6554       if (cave[x][y-1] == Xblank)
6555         cave[x][y-1] = Xsplash_e;
6556       if (cave[x-2][y-1] == Xblank)
6557         cave[x-2][y-1] = Xsplash_w;
6558       play_element_sound(x, y, SOUND_acid, Xacid_1);
6559       return;
6560 #endif
6561   }
6562
6563   cave[x-1][y] = Yspring_w;
6564   next[x-1][y] = Xspring_w;
6565 }
6566
6567 static void Ldynamite_1(int x, int y)
6568 {
6569   play_element_sound(x, y, SOUND_tick, Xdynamite_1);
6570   next[x][y] = Xdynamite_2;
6571 }
6572
6573 static void Ldynamite_2(int x, int y)
6574 {
6575   play_element_sound(x, y, SOUND_tick, Xdynamite_2);
6576   next[x][y] = Xdynamite_3;
6577 }
6578
6579 static void Ldynamite_3(int x, int y)
6580 {
6581   play_element_sound(x, y, SOUND_tick, Xdynamite_3);
6582   next[x][y] = Xdynamite_4;
6583 }
6584
6585 static void Ldynamite_4(int x, int y)
6586 {
6587   play_element_sound(x, y, SOUND_tick, Xdynamite_4);
6588   next[x][y] = Zdynamite;
6589
6590   Lboom_generic(x, y, Xblank, Xblank);
6591 }
6592
6593 static void Lfake_door_1(int x, int y)
6594 {
6595   if (lev.magnify_cnt)
6596     cave[x][y] = Xdoor_1;
6597 }
6598
6599 static void Lfake_door_2(int x, int y)
6600 {
6601   if (lev.magnify_cnt)
6602     cave[x][y] = Xdoor_2;
6603 }
6604
6605 static void Lfake_door_3(int x, int y)
6606 {
6607   if (lev.magnify_cnt)
6608     cave[x][y] = Xdoor_3;
6609 }
6610
6611 static void Lfake_door_4(int x, int y)
6612 {
6613   if (lev.magnify_cnt)
6614     cave[x][y] = Xdoor_4;
6615 }
6616
6617 static void Lfake_door_5(int x, int y)
6618 {
6619   if (lev.magnify_cnt)
6620     cave[x][y] = Xdoor_5;
6621 }
6622
6623 static void Lfake_door_6(int x, int y)
6624 {
6625   if (lev.magnify_cnt)
6626     cave[x][y] = Xdoor_6;
6627 }
6628
6629 static void Lfake_door_7(int x, int y)
6630 {
6631   if (lev.magnify_cnt)
6632     cave[x][y] = Xdoor_7;
6633 }
6634
6635 static void Lfake_door_8(int x, int y)
6636 {
6637   if (lev.magnify_cnt)
6638     cave[x][y] = Xdoor_8;
6639 }
6640
6641 static void Lballoon(int x, int y)
6642 {
6643   if (lev.wind_cnt == 0)
6644     return;
6645
6646   switch (lev.wind_direction)
6647   {
6648     case 0: /* north */
6649       switch (cave[x][y-1])
6650       {
6651         case Xblank:
6652         case Xsplash_e:
6653         case Xsplash_w:
6654         case Xfake_acid_1:
6655         case Xfake_acid_2:
6656         case Xfake_acid_3:
6657         case Xfake_acid_4:
6658         case Xfake_acid_5:
6659         case Xfake_acid_6:
6660         case Xfake_acid_7:
6661         case Xfake_acid_8:
6662           cave[x][y] = Yballoon_nB;
6663           next[x][y] = Xblank;
6664           cave[x][y-1] = Yballoon_n;
6665           next[x][y-1] = Xballoon;
6666           return;
6667
6668         case Xacid_1:
6669         case Xacid_2:
6670         case Xacid_3:
6671         case Xacid_4:
6672         case Xacid_5:
6673         case Xacid_6:
6674         case Xacid_7:
6675         case Xacid_8:
6676           cave[x][y] = Yballoon_nB;
6677           next[x][y] = Xblank;
6678           if (cave[x+1][y-2] == Xblank)
6679             cave[x+1][y-2] = Xsplash_e;
6680           if (cave[x-1][y-2] == Xblank)
6681             cave[x-1][y-2] = Xsplash_w;
6682           play_element_sound(x, y, SOUND_acid, Xacid_1);
6683           return;
6684       }
6685       break;
6686
6687     case 1: /* east */
6688       switch (cave[x+1][y])
6689       {
6690         case Xblank:
6691         case Xsplash_e:
6692         case Xsplash_w:
6693         case Xfake_acid_1:
6694         case Xfake_acid_2:
6695         case Xfake_acid_3:
6696         case Xfake_acid_4:
6697         case Xfake_acid_5:
6698         case Xfake_acid_6:
6699         case Xfake_acid_7:
6700         case Xfake_acid_8:
6701           cave[x][y] = Yballoon_eB;
6702           next[x][y] = Xblank;
6703           cave[x+1][y] = Yballoon_e;
6704           next[x+1][y] = Xballoon;
6705           return;
6706
6707         case Xacid_1:
6708         case Xacid_2:
6709         case Xacid_3:
6710         case Xacid_4:
6711         case Xacid_5:
6712         case Xacid_6:
6713         case Xacid_7:
6714         case Xacid_8:
6715           cave[x][y] = Yballoon_eB;
6716           next[x][y] = Xblank;
6717           if (cave[x+2][y-1] == Xblank)
6718             cave[x+2][y-1] = Xsplash_e;
6719           if (cave[x][y-1] == Xblank)
6720             cave[x][y-1] = Xsplash_w;
6721           play_element_sound(x, y, SOUND_acid, Xacid_1);
6722           return;
6723       }
6724       break;
6725
6726     case 2: /* south */
6727       switch (cave[x][y+1])
6728       {
6729         case Xblank:
6730         case Xsplash_e:
6731         case Xsplash_w:
6732         case Xfake_acid_1:
6733         case Xfake_acid_2:
6734         case Xfake_acid_3:
6735         case Xfake_acid_4:
6736         case Xfake_acid_5:
6737         case Xfake_acid_6:
6738         case Xfake_acid_7:
6739         case Xfake_acid_8:
6740           cave[x][y] = Yballoon_sB;
6741           next[x][y] = Xblank;
6742           cave[x][y+1] = Yballoon_s;
6743           next[x][y+1] = Xballoon;
6744           return;
6745
6746         case Xacid_1:
6747         case Xacid_2:
6748         case Xacid_3:
6749         case Xacid_4:
6750         case Xacid_5:
6751         case Xacid_6:
6752         case Xacid_7:
6753         case Xacid_8:
6754           cave[x][y] = Yballoon_sB;
6755           next[x][y] = Xblank;
6756           if (cave[x+1][y] == Xblank)
6757             cave[x+1][y] = Xsplash_e;
6758           if (cave[x-1][y] == Xblank)
6759             cave[x-1][y] = Xsplash_w;
6760           play_element_sound(x, y, SOUND_acid, Xacid_1);
6761           return;
6762       }
6763       break;
6764
6765     case 3: /* west */
6766       switch (cave[x-1][y])
6767       {
6768         case Xblank:
6769         case Xsplash_e:
6770         case Xsplash_w:
6771         case Xfake_acid_1:
6772         case Xfake_acid_2:
6773         case Xfake_acid_3:
6774         case Xfake_acid_4:
6775         case Xfake_acid_5:
6776         case Xfake_acid_6:
6777         case Xfake_acid_7:
6778         case Xfake_acid_8:
6779           cave[x][y] = Yballoon_wB;
6780           next[x][y] = Xblank;
6781           cave[x-1][y] = Yballoon_w;
6782           next[x-1][y] = Xballoon;
6783           return;
6784
6785         case Xacid_1:
6786         case Xacid_2:
6787         case Xacid_3:
6788         case Xacid_4:
6789         case Xacid_5:
6790         case Xacid_6:
6791         case Xacid_7:
6792         case Xacid_8:
6793           cave[x][y] = Yballoon_wB;
6794           next[x][y] = Xblank;
6795           if (cave[x][y-1] == Xblank)
6796             cave[x][y-1] = Xsplash_e;
6797           if (cave[x-2][y-1] == Xblank)
6798             cave[x-2][y-1] = Xsplash_w;
6799           play_element_sound(x, y, SOUND_acid, Xacid_1);
6800           return;
6801       }
6802       break;
6803   }
6804 }
6805
6806 static void Lball_common(int x, int y)
6807 {
6808   play_element_sound(x, y, SOUND_ball, Xball_1);
6809
6810   if (lev.ball_random)
6811   {
6812     switch (RANDOM(8))
6813     {
6814       case 0:
6815         if (lev.ball_array[lev.ball_pos][0] != Xblank &&
6816             is_blank[cave[x-1][y-1]])
6817         {
6818           cave[x-1][y-1] = Yball_blank;
6819           next[x-1][y-1] = lev.ball_array[lev.ball_pos][0];
6820         }
6821         break;
6822
6823       case 1:
6824         if (lev.ball_array[lev.ball_pos][1] != Xblank &&
6825             is_blank[cave[x][y-1]])
6826         {
6827           cave[x][y-1] = Yball_blank;
6828           next[x][y-1] = lev.ball_array[lev.ball_pos][1];
6829         }
6830         break;
6831
6832       case 2:
6833         if (lev.ball_array[lev.ball_pos][2] != Xblank &&
6834             is_blank[cave[x+1][y-1]])
6835         {
6836           cave[x+1][y-1] = Yball_blank;
6837           next[x+1][y-1] = lev.ball_array[lev.ball_pos][2];
6838         }
6839         break;
6840
6841       case 3:
6842         if (lev.ball_array[lev.ball_pos][3] != Xblank &&
6843             is_blank[cave[x-1][y]])
6844         {
6845           cave[x-1][y] = Yball_blank;
6846           next[x-1][y] = lev.ball_array[lev.ball_pos][3];
6847         }
6848         break;
6849
6850       case 4:
6851         if (lev.ball_array[lev.ball_pos][4] != Xblank &&
6852             is_blank[cave[x+1][y]])
6853         {
6854           cave[x+1][y] = Yball_blank;
6855           next[x+1][y] = lev.ball_array[lev.ball_pos][4];
6856         }
6857         break;
6858
6859       case 5:
6860         if (lev.ball_array[lev.ball_pos][5] != Xblank &&
6861             is_blank[cave[x-1][y+1]])
6862         {
6863           cave[x-1][y+1] = Yball_blank;
6864           next[x-1][y+1] = lev.ball_array[lev.ball_pos][5];
6865         }
6866         break;
6867
6868       case 6:
6869         if (lev.ball_array[lev.ball_pos][6] != Xblank &&
6870             is_blank[cave[x][y+1]])
6871         {
6872           cave[x][y+1] = Yball_blank;
6873           next[x][y+1] = lev.ball_array[lev.ball_pos][6];
6874         }
6875         break;
6876
6877       case 7:
6878         if (lev.ball_array[lev.ball_pos][7] != Xblank &&
6879             is_blank[cave[x+1][y+1]])
6880         {
6881           cave[x+1][y+1] = Yball_blank;
6882           next[x+1][y+1] = lev.ball_array[lev.ball_pos][7];
6883         }
6884         break;
6885     }
6886   }
6887   else
6888   {
6889     if (lev.ball_array[lev.ball_pos][0] != Xblank &&
6890         is_blank[cave[x-1][y-1]])
6891     {
6892       cave[x-1][y-1] = Yball_blank;
6893       next[x-1][y-1] = lev.ball_array[lev.ball_pos][0];
6894     }
6895
6896     if (lev.ball_array[lev.ball_pos][1] != Xblank &&
6897         is_blank[cave[x][y-1]])
6898     {
6899       cave[x][y-1] = Yball_blank;
6900       next[x][y-1] = lev.ball_array[lev.ball_pos][1];
6901     }
6902
6903     if (lev.ball_array[lev.ball_pos][2] != Xblank &&
6904         is_blank[cave[x+1][y-1]])
6905     {
6906       cave[x+1][y-1] = Yball_blank;
6907       next[x+1][y-1] = lev.ball_array[lev.ball_pos][2];
6908     }
6909
6910     if (lev.ball_array[lev.ball_pos][3] != Xblank &&
6911         is_blank[cave[x-1][y]])
6912     {
6913       cave[x-1][y] = Yball_blank;
6914       next[x-1][y] = lev.ball_array[lev.ball_pos][3];
6915     }
6916
6917     if (lev.ball_array[lev.ball_pos][4] != Xblank &&
6918         is_blank[cave[x+1][y]])
6919     {
6920       cave[x+1][y] = Yball_blank;
6921       next[x+1][y] = lev.ball_array[lev.ball_pos][4];
6922     }
6923
6924     if (lev.ball_array[lev.ball_pos][5] != Xblank &&
6925         is_blank[cave[x-1][y+1]])
6926     {
6927       cave[x-1][y+1] = Yball_blank;
6928       next[x-1][y+1] = lev.ball_array[lev.ball_pos][5];
6929     }
6930
6931     if (lev.ball_array[lev.ball_pos][6] != Xblank &&
6932         is_blank[cave[x][y+1]])
6933     {
6934       cave[x][y+1] = Yball_blank;
6935       next[x][y+1] = lev.ball_array[lev.ball_pos][6];
6936     }
6937
6938     if (lev.ball_array[lev.ball_pos][7] != Xblank &&
6939         is_blank[cave[x+1][y+1]])
6940     {
6941       cave[x+1][y+1] = Yball_blank;
6942       next[x+1][y+1] = lev.ball_array[lev.ball_pos][7];
6943     }
6944   }
6945
6946   lev.ball_pos = (lev.ball_pos + 1) % lev.num_ball_arrays;
6947 }
6948
6949 static void Lball_1(int x, int y)
6950 {
6951   if (!lev.ball_active)
6952     return;
6953
6954   cave[x][y] = Yball_1;
6955   next[x][y] = Xball_2;
6956   if (lev.ball_cnt)
6957     return;
6958
6959   Lball_common(x, y);
6960 }
6961
6962 static void Lball_2(int x, int y)
6963 {
6964   if (!lev.ball_active)
6965     return;
6966
6967   cave[x][y] = Yball_2;
6968   next[x][y] = Xball_1;
6969   if (lev.ball_cnt)
6970     return;
6971
6972   Lball_common(x, y);
6973 }
6974
6975 static void Ldrip(int x, int y)
6976 {
6977   next[x][y] = Xdrip_fall;
6978 }
6979
6980 static void Ldrip_fall(int x, int y)
6981 {
6982   int temp;
6983
6984   switch (cave[x][y+1])
6985   {
6986     case Zplayer:
6987     case Xblank:
6988     case Xsplash_e:
6989     case Xsplash_w:
6990     case Xfake_acid_1:
6991     case Xfake_acid_2:
6992     case Xfake_acid_3:
6993     case Xfake_acid_4:
6994     case Xfake_acid_5:
6995     case Xfake_acid_6:
6996     case Xfake_acid_7:
6997     case Xfake_acid_8:
6998     case Xfake_acid_1_player:
6999     case Xfake_acid_2_player:
7000     case Xfake_acid_3_player:
7001     case Xfake_acid_4_player:
7002     case Xfake_acid_5_player:
7003     case Xfake_acid_6_player:
7004     case Xfake_acid_7_player:
7005     case Xfake_acid_8_player:
7006     case Xplant:
7007     case Yplant:
7008       cave[x][y] = Ydrip_1_sB;
7009       next[x][y] = Xdrip_stretchB;
7010       cave[x][y+1] = Ydrip_1_s;
7011       next[x][y+1] = Xdrip_stretch;
7012       return;
7013
7014     case Xacid_1:
7015     case Xacid_2:
7016     case Xacid_3:
7017     case Xacid_4:
7018     case Xacid_5:
7019     case Xacid_6:
7020     case Xacid_7:
7021     case Xacid_8:
7022       cave[x][y] = Ydrip_1_sB;
7023       next[x][y] = Xdrip_stretchB;
7024       if (cave[x+1][y] == Xblank)
7025         cave[x+1][y] = Xsplash_e;
7026       if (cave[x-1][y] == Xblank)
7027         cave[x-1][y] = Xsplash_w;
7028       play_element_sound(x, y, SOUND_acid, Xacid_1);
7029       return;
7030
7031     default:
7032       switch (RANDOM(8))
7033       {
7034         case 0: temp = Xamoeba_1; break;
7035         case 1: temp = Xamoeba_2; break;
7036         case 2: temp = Xamoeba_3; break;
7037         case 3: temp = Xamoeba_4; break;
7038         case 4: temp = Xamoeba_5; break;
7039         case 5: temp = Xamoeba_6; break;
7040         case 6: temp = Xamoeba_7; break;
7041         case 7: temp = Xamoeba_8; break;
7042       }
7043
7044       cave[x][y] = temp;
7045       next[x][y] = temp;
7046       play_element_sound(x, y, SOUND_drip, Xdrip_fall);
7047       return;
7048   }
7049 }
7050
7051 static void Ldrip_stretch(int x, int y)
7052 {
7053   cave[x][y] = Ydrip_2_s;
7054   next[x][y] = Xdrip_fall;
7055 }
7056
7057 static void Ldrip_stretchB(int x, int y)
7058 {
7059   cave[x][y] = Ydrip_2_sB;
7060   next[x][y] = Xblank;
7061 }
7062
7063 static void Lwonderwall(int x, int y)
7064 {
7065   if (lev.wonderwall_time > 0 && lev.wonderwall_active)
7066   {
7067     cave[x][y] = Ywonderwall;
7068     play_element_sound(x, y, SOUND_wonder, Xwonderwall);
7069   }
7070 }
7071
7072 static void Lwheel(int x, int y)
7073 {
7074   if (lev.wheel_cnt && x == lev.wheel_x && y == lev.wheel_y)
7075     cave[x][y] = Ywheel;
7076 }
7077
7078 static void Lswitch(int x, int y)
7079 {
7080   if (lev.ball_active)
7081     cave[x][y] = Yswitch;
7082 }
7083
7084 static void Lfake_blank(int x, int y)
7085 {
7086   if (lev.lenses_cnt)
7087     cave[x][y] = Yfake_blank;
7088 }
7089
7090 static void Lfake_grass(int x, int y)
7091 {
7092   if (lev.magnify_cnt)
7093     cave[x][y] = Yfake_grass;
7094 }
7095
7096 static void Lfake_amoeba(int x, int y)
7097 {
7098   if (lev.lenses_cnt)
7099     cave[x][y] = Yfake_amoeba;
7100 }
7101
7102 static void Lsand_stone(int x, int y)
7103 {
7104   switch (cave[x][y+1])
7105   {
7106     case Xblank:
7107     case Xsplash_e:
7108     case Xsplash_w:
7109     case Xfake_acid_1:
7110     case Xfake_acid_2:
7111     case Xfake_acid_3:
7112     case Xfake_acid_4:
7113     case Xfake_acid_5:
7114     case Xfake_acid_6:
7115     case Xfake_acid_7:
7116     case Xfake_acid_8:
7117       cave[x][y] = Xsand_stonesand_quickout_1;
7118       next[x][y] = Xsand_stonesand_quickout_2;
7119       cave[x][y+1] = Xsand_stoneout_1;
7120       next[x][y+1] = Xsand_stoneout_2;
7121       return;
7122
7123     case Xacid_1:
7124     case Xacid_2:
7125     case Xacid_3:
7126     case Xacid_4:
7127     case Xacid_5:
7128     case Xacid_6:
7129     case Xacid_7:
7130     case Xacid_8:
7131       cave[x][y] = Xsand_stonesand_quickout_1;
7132       next[x][y] = Xsand_stonesand_quickout_2;
7133       if (cave[x+1][y] == Xblank)
7134         cave[x+1][y] = Xsplash_e;
7135       if (cave[x-1][y] == Xblank)
7136         cave[x-1][y] = Xsplash_w;
7137       play_element_sound(x, y, SOUND_acid, Xacid_1);
7138       return;
7139
7140     case Xsand:
7141       cave[x][y] = Xsand_stonesand_1;
7142       next[x][y] = Xsand_stonesand_2;
7143       cave[x][y+1] = Xsand_sandstone_1;
7144       next[x][y+1] = Xsand_sandstone_2;
7145       return;
7146   }
7147 }
7148
7149 static void Lsand_stonein_1(int x, int y)
7150 {
7151   next[x][y] = Xsand_stonein_2;
7152 }
7153
7154 static void Lsand_stonein_2(int x, int y)
7155 {
7156   next[x][y] = Xsand_stonein_3;
7157 }
7158
7159 static void Lsand_stonein_3(int x, int y)
7160 {
7161   next[x][y] = Xsand_stonein_4;
7162 }
7163
7164 static void Lsand_stonein_4(int x, int y)
7165 {
7166   next[x][y] = Xblank;
7167 }
7168
7169 static void Lsand_sandstone_1(int x, int y)
7170 {
7171   next[x][y] = Xsand_sandstone_2;
7172 }
7173
7174 static void Lsand_sandstone_2(int x, int y)
7175 {
7176   next[x][y] = Xsand_sandstone_3;
7177 }
7178
7179 static void Lsand_sandstone_3(int x, int y)
7180 {
7181   next[x][y] = Xsand_sandstone_4;
7182 }
7183
7184 static void Lsand_sandstone_4(int x, int y)
7185 {
7186   next[x][y] = Xsand_stone;
7187 }
7188
7189 static void Lsand_stonesand_1(int x, int y)
7190 {
7191   next[x][y] = Xsand_stonesand_2;
7192 }
7193
7194 static void Lsand_stonesand_2(int x, int y)
7195 {
7196   next[x][y] = Xsand_stonesand_3;
7197 }
7198
7199 static void Lsand_stonesand_3(int x, int y)
7200 {
7201   next[x][y] = Xsand_stonesand_4;
7202 }
7203
7204 static void Lsand_stonesand_4(int x, int y)
7205 {
7206   next[x][y] = Xsand;
7207 }
7208
7209 static void Lsand_stoneout_1(int x, int y)
7210 {
7211   next[x][y] = Xsand_stoneout_2;
7212 }
7213
7214 static void Lsand_stoneout_2(int x, int y)
7215 {
7216   next[x][y] = Xstone_fall;
7217 }
7218
7219 static void Lsand_stonesand_quickout_1(int x, int y)
7220 {
7221   next[x][y] = Xsand_stonesand_quickout_2;
7222 }
7223
7224 static void Lsand_stonesand_quickout_2(int x, int y)
7225 {
7226   next[x][y] = Xsand;
7227 }
7228
7229 static void Lslide_ns(int x, int y)
7230 {
7231   if (is_blank[cave[x][y-1]])
7232   {
7233     cave[x][y-1] = Yslide_ns_blank;
7234     next[x][y-1] = Xslide_ns;
7235     play_element_sound(x, y, SOUND_slide, Xslide_ns);
7236   }
7237
7238   if (is_blank[cave[x][y+1]])
7239   {
7240     cave[x][y+1] = Yslide_ns_blank;
7241     next[x][y+1] = Xslide_ns;
7242     play_element_sound(x, y, SOUND_slide, Xslide_ns);
7243   }
7244 }
7245
7246 static void Lslide_ew(int x, int y)
7247 {
7248   if (is_blank[cave[x+1][y]])
7249   {
7250     cave[x+1][y] = Yslide_ew_blank;
7251     next[x+1][y] = Xslide_ew;
7252     play_element_sound(x, y, SOUND_slide, Xslide_ew);
7253   }
7254
7255   if (is_blank[cave[x-1][y]])
7256   {
7257     cave[x-1][y] = Yslide_ew_blank;
7258     next[x-1][y] = Xslide_ew;
7259     play_element_sound(x, y, SOUND_slide, Xslide_ew);
7260   }
7261 }
7262
7263 static void Lexit(int x, int y)
7264 {
7265   if (lev.gems_needed > 0)
7266     return;
7267
7268   switch (RANDOM(64) / 21)
7269   {
7270     case 0:
7271       cave[x][y] = Xexit_1;
7272       next[x][y] = Xexit_2;
7273       break;
7274
7275     case 1:
7276       cave[x][y] = Xexit_2;
7277       next[x][y] = Xexit_3;
7278       break;
7279
7280     default:
7281       cave[x][y] = Xexit_3;
7282       next[x][y] = Xexit_1;
7283       break;
7284   }
7285
7286   play_element_sound(x, y, SOUND_exit_open, Xexit);
7287 }
7288
7289 static void Lexit_1(int x, int y)
7290 {
7291   next[x][y] = Xexit_2;
7292 }
7293
7294 static void Lexit_2(int x, int y)
7295 {
7296   next[x][y] = Xexit_3;
7297 }
7298
7299 static void Lexit_3(int x, int y)
7300 {
7301   next[x][y] = Xexit_1;
7302 }
7303
7304 static void Lpause(int x, int y)
7305 {
7306   next[x][y] = Xblank;
7307 }
7308
7309 static void Lamoeba(int x, int y)
7310 {
7311   switch (cave[x][y])
7312   {
7313     case Xblank:
7314     case Xsplash_e:
7315     case Xsplash_w:
7316     case Xfake_acid_1:
7317     case Xfake_acid_2:
7318     case Xfake_acid_3:
7319     case Xfake_acid_4:
7320     case Xfake_acid_5:
7321     case Xfake_acid_6:
7322     case Xfake_acid_7:
7323     case Xfake_acid_8:
7324     case Xplant:
7325     case Yplant:
7326     case Xgrass:
7327     case Xdirt:
7328     case Xsand:
7329       if (is_amoeba[cave[x][y-1]] ||
7330           is_amoeba[cave[x+1][y]] ||
7331           is_amoeba[cave[x][y+1]] ||
7332           is_amoeba[cave[x-1][y]])
7333         cave[x][y] = Xdrip;
7334   }
7335 }
7336
7337 static void Lboom_one(int x, int y, boolean by_dynamite)
7338 {
7339   switch (cave[x][y])
7340   {
7341     case Zborder:
7342     case Zbug:
7343     case Ztank:
7344     case Zeater:
7345     case Zdynamite:
7346     case Zboom:
7347     case Xchain:
7348     case Xboom_bug:
7349     case Xboom_tank:
7350     case Xboom_android:
7351     case Xacid_1:
7352     case Xacid_2:
7353     case Xacid_3:
7354     case Xacid_4:
7355     case Xacid_5:
7356     case Xacid_6:
7357     case Xacid_7:
7358     case Xacid_8:
7359     case Xplant:
7360     case Yplant:
7361     case Xdoor_1:
7362     case Xdoor_2:
7363     case Xdoor_3:
7364     case Xdoor_4:
7365     case Xdoor_5:
7366     case Xdoor_6:
7367     case Xdoor_7:
7368     case Xdoor_8:
7369     case Xfake_door_1:
7370     case Xfake_door_2:
7371     case Xfake_door_3:
7372     case Xfake_door_4:
7373     case Xfake_door_5:
7374     case Xfake_door_6:
7375     case Xfake_door_7:
7376     case Xfake_door_8:
7377     case Xacid_ne:
7378     case Xacid_nw:
7379     case Xacid_s:
7380     case Xacid_se:
7381     case Xacid_sw:
7382     case Xsteel_1:
7383     case Xsteel_2:
7384     case Xsteel_3:
7385     case Xsteel_4:
7386       return;
7387
7388     case Xandroid:
7389     case Xandroid_1_n:
7390     case Xandroid_2_n:
7391     case Xandroid_1_e:
7392     case Xandroid_2_e:
7393     case Xandroid_1_s:
7394     case Xandroid_2_s:
7395     case Xandroid_1_w:
7396     case Xandroid_2_w:
7397       if (by_dynamite)
7398         cave[x][y] = Xboom_android;
7399       return;
7400
7401     case Xbug_1_n:
7402     case Xbug_1_e:
7403     case Xbug_1_s:
7404     case Xbug_1_w:
7405     case Xbug_2_n:
7406     case Xbug_2_e:
7407     case Xbug_2_s:
7408     case Xbug_2_w:
7409       cave[x][y] = Xboom_bug;
7410       Lboom_bug_new(x, y, TRUE);
7411       return;
7412
7413     case Xbomb:
7414     case Xbomb_pause:
7415     case Xbomb_fall:
7416       cave[x][y] = Xboom_tank;
7417       Lboom_tank_new(x, y, TRUE);
7418       return;
7419
7420     default:
7421       cave[x][y] = Xboom_1;
7422       return;
7423   }
7424 }
7425
7426 static void Lboom_nine(int x, int y, boolean by_dynamite)
7427 {
7428   Lboom_one(x,   y-1, by_dynamite);
7429   Lboom_one(x-1, y,   by_dynamite);
7430   Lboom_one(x+1, y,   by_dynamite);
7431   Lboom_one(x,   y+1, by_dynamite);
7432   Lboom_one(x-1, y-1, by_dynamite);
7433   Lboom_one(x+1, y-1, by_dynamite);
7434   Lboom_one(x-1, y+1, by_dynamite);
7435   Lboom_one(x+1, y+1, by_dynamite);
7436
7437   cave[x][y] = Xboom_1;
7438 }
7439
7440 static void Lexplode(int x, int y)
7441 {
7442   switch (cave[x][y])
7443   {
7444     case Zbug:
7445       Lboom_bug_new(x, y, FALSE);
7446       Lboom_nine(x, y, FALSE);
7447       break;
7448
7449     case Ztank:
7450       Lboom_tank_new(x, y, FALSE);
7451       Lboom_nine(x, y, FALSE);
7452       break;
7453
7454     case Zeater:
7455       Lboom_eater_new(x, y, FALSE);
7456       Lboom_nine(x, y, FALSE);
7457       break;
7458
7459     case Zdynamite:
7460       Lboom_nine(x, y, TRUE);
7461       break;
7462
7463     case Zboom:
7464       Lboom_nine(x, y, FALSE);
7465       break;
7466   }
7467 }
7468
7469 static void Lboom_1(int x, int y)
7470 {
7471   next[x][y] = Xboom_2;
7472 #if !PLAY_ELEMENT_SOUND
7473   if (x != lev.exit_x && y != lev.exit_y)
7474     play_sound(x, y, SOUND_boom);
7475   else
7476     lev.exit_x = lev.exit_y = -1;
7477 #endif
7478 }
7479
7480 static void Lboom_2(int x, int y)
7481 {
7482   next[x][y] = boom[x][y];
7483 }
7484
7485 static void Lboom_android(int x, int y)
7486 {
7487 #if PLAY_ELEMENT_SOUND
7488   play_element_sound(x, y, SOUND_boom, Xandroid);
7489 #endif
7490
7491   Lboom_1(x, y);
7492 }
7493
7494 static void Lchain(int x, int y)
7495 {
7496   next[x][y] = Zboom;
7497 }
7498
7499 static void handle_tile(int x, int y)
7500 {
7501   switch (cave[x][y])
7502   {
7503     case Xacid_1:               Lacid_1(x, y);                  break;
7504     case Xacid_2:               Lacid_2(x, y);                  break;
7505     case Xacid_3:               Lacid_3(x, y);                  break;
7506     case Xacid_4:               Lacid_4(x, y);                  break;
7507     case Xacid_5:               Lacid_5(x, y);                  break;
7508     case Xacid_6:               Lacid_6(x, y);                  break;
7509     case Xacid_7:               Lacid_7(x, y);                  break;
7510     case Xacid_8:               Lacid_8(x, y);                  break;
7511
7512     case Xfake_acid_1:          Lfake_acid_1(x, y);             break;
7513     case Xfake_acid_2:          Lfake_acid_2(x, y);             break;
7514     case Xfake_acid_3:          Lfake_acid_3(x, y);             break;
7515     case Xfake_acid_4:          Lfake_acid_4(x, y);             break;
7516     case Xfake_acid_5:          Lfake_acid_5(x, y);             break;
7517     case Xfake_acid_6:          Lfake_acid_6(x, y);             break;
7518     case Xfake_acid_7:          Lfake_acid_7(x, y);             break;
7519     case Xfake_acid_8:          Lfake_acid_8(x, y);             break;
7520
7521     case Xandroid:              Landroid(x, y);                 break;
7522     case Xandroid_1_n:          Landroid_1_n(x, y);             break;
7523     case Xandroid_2_n:          Landroid_2_n(x, y);             break;
7524     case Xandroid_1_e:          Landroid_1_e(x, y);             break;
7525     case Xandroid_2_e:          Landroid_2_e(x, y);             break;
7526     case Xandroid_1_s:          Landroid_1_s(x, y);             break;
7527     case Xandroid_2_s:          Landroid_2_s(x, y);             break;
7528     case Xandroid_1_w:          Landroid_1_w(x, y);             break;
7529     case Xandroid_2_w:          Landroid_2_w(x, y);             break;
7530
7531     case Xeater_n:              Leater_n(x, y);                 break;
7532     case Xeater_e:              Leater_e(x, y);                 break;
7533     case Xeater_s:              Leater_s(x, y);                 break;
7534     case Xeater_w:              Leater_w(x, y);                 break;
7535
7536     case Xalien:                Lalien(x, y);                   break;
7537     case Xalien_pause:          Lalien_pause(x, y);             break;
7538
7539     case Xbug_1_n:              Lbug_1_n(x, y);                 break;
7540     case Xbug_2_n:              Lbug_2_n(x, y);                 break;
7541     case Xbug_1_e:              Lbug_1_e(x, y);                 break;
7542     case Xbug_2_e:              Lbug_2_e(x, y);                 break;
7543     case Xbug_1_s:              Lbug_1_s(x, y);                 break;
7544     case Xbug_2_s:              Lbug_2_s(x, y);                 break;
7545     case Xbug_1_w:              Lbug_1_w(x, y);                 break;
7546     case Xbug_2_w:              Lbug_2_w(x, y);                 break;
7547
7548     case Xtank_1_n:             Ltank_1_n(x, y);                break;
7549     case Xtank_2_n:             Ltank_2_n(x, y);                break;
7550     case Xtank_1_e:             Ltank_1_e(x, y);                break;
7551     case Xtank_2_e:             Ltank_2_e(x, y);                break;
7552     case Xtank_1_s:             Ltank_1_s(x, y);                break;
7553     case Xtank_2_s:             Ltank_2_s(x, y);                break;
7554     case Xtank_1_w:             Ltank_1_w(x, y);                break;
7555     case Xtank_2_w:             Ltank_2_w(x, y);                break;
7556
7557     case Xemerald:              Lemerald(x, y);                 break;
7558     case Xemerald_pause:        Lemerald_pause(x, y);           break;
7559     case Xemerald_fall:         Lemerald_fall(x, y);            break;
7560
7561     case Xdiamond:              Ldiamond(x, y);                 break;
7562     case Xdiamond_pause:        Ldiamond_pause(x, y);           break;
7563     case Xdiamond_fall:         Ldiamond_fall(x, y);            break;
7564
7565     case Xstone:                Lstone(x, y);                   break;
7566     case Xstone_pause:          Lstone_pause(x, y);             break;
7567     case Xstone_fall:           Lstone_fall(x, y);              break;
7568
7569     case Xbomb:                 Lbomb(x, y);                    break;
7570     case Xbomb_pause:           Lbomb_pause(x, y);              break;
7571     case Xbomb_fall:            Lbomb_fall(x, y);               break;
7572
7573     case Xnut:                  Lnut(x, y);                     break;
7574     case Xnut_pause:            Lnut_pause(x, y);               break;
7575     case Xnut_fall:             Lnut_fall(x, y);                break;
7576
7577     case Xspring:               Lspring(x, y);                  break;
7578     case Xspring_pause:         Lspring_pause(x, y);            break;
7579     case Xspring_e:             Lspring_e(x, y);                break;
7580     case Xspring_w:             Lspring_w(x, y);                break;
7581     case Xspring_fall:          Lspring_fall(x, y);             break;
7582
7583     case Xpush_emerald_e:       Lpush_emerald_e(x, y);          break;
7584     case Xpush_emerald_w:       Lpush_emerald_w(x, y);          break;
7585     case Xpush_diamond_e:       Lpush_diamond_e(x, y);          break;
7586     case Xpush_diamond_w:       Lpush_diamond_w(x, y);          break;
7587     case Xpush_stone_e:         Lpush_stone_e(x, y);            break;
7588     case Xpush_stone_w:         Lpush_stone_w(x, y);            break;
7589     case Xpush_bomb_e:          Lpush_bomb_e(x, y);             break;
7590     case Xpush_bomb_w:          Lpush_bomb_w(x, y);             break;
7591     case Xpush_nut_e:           Lpush_nut_e(x, y);              break;
7592     case Xpush_nut_w:           Lpush_nut_w(x, y);              break;
7593     case Xpush_spring_e:        Lpush_spring_e(x, y);           break;
7594     case Xpush_spring_w:        Lpush_spring_w(x, y);           break;
7595
7596     case Xdynamite_1:           Ldynamite_1(x, y);              break;
7597     case Xdynamite_2:           Ldynamite_2(x, y);              break;
7598     case Xdynamite_3:           Ldynamite_3(x, y);              break;
7599     case Xdynamite_4:           Ldynamite_4(x, y);              break;
7600
7601     case Xfake_door_1:          Lfake_door_1(x, y);             break;
7602     case Xfake_door_2:          Lfake_door_2(x, y);             break;
7603     case Xfake_door_3:          Lfake_door_3(x, y);             break;
7604     case Xfake_door_4:          Lfake_door_4(x, y);             break;
7605     case Xfake_door_5:          Lfake_door_5(x, y);             break;
7606     case Xfake_door_6:          Lfake_door_6(x, y);             break;
7607     case Xfake_door_7:          Lfake_door_7(x, y);             break;
7608     case Xfake_door_8:          Lfake_door_8(x, y);             break;
7609
7610     case Xballoon:              Lballoon(x, y);                 break;
7611
7612     case Xball_1:               Lball_1(x, y);                  break;
7613     case Xball_2:               Lball_2(x, y);                  break;
7614
7615     case Xdrip:                 Ldrip(x, y);                    break;
7616     case Xdrip_fall:            Ldrip_fall(x, y);               break;
7617     case Xdrip_stretch:         Ldrip_stretch(x, y);            break;
7618     case Xdrip_stretchB:        Ldrip_stretchB(x, y);           break;
7619
7620     case Xwonderwall:           Lwonderwall(x, y);              break;
7621
7622     case Xwheel:                Lwheel(x, y);                   break;
7623
7624     case Xswitch:               Lswitch(x, y);                  break;
7625
7626     case Xfake_blank:           Lfake_blank(x, y);              break;
7627     case Xfake_grass:           Lfake_grass(x, y);              break;
7628     case Xfake_amoeba:          Lfake_amoeba(x, y);             break;
7629
7630     case Xsand_stone:           Lsand_stone(x, y);              break;
7631     case Xsand_stonein_1:       Lsand_stonein_1(x, y);          break;
7632     case Xsand_stonein_2:       Lsand_stonein_2(x, y);          break;
7633     case Xsand_stonein_3:       Lsand_stonein_3(x, y);          break;
7634     case Xsand_stonein_4:       Lsand_stonein_4(x, y);          break;
7635     case Xsand_sandstone_1:     Lsand_sandstone_1(x, y);        break;
7636     case Xsand_sandstone_2:     Lsand_sandstone_2(x, y);        break;
7637     case Xsand_sandstone_3:     Lsand_sandstone_3(x, y);        break;
7638     case Xsand_sandstone_4:     Lsand_sandstone_4(x, y);        break;
7639     case Xsand_stonesand_1:     Lsand_stonesand_1(x, y);        break;
7640     case Xsand_stonesand_2:     Lsand_stonesand_2(x, y);        break;
7641     case Xsand_stonesand_3:     Lsand_stonesand_3(x, y);        break;
7642     case Xsand_stonesand_4:     Lsand_stonesand_4(x, y);        break;
7643     case Xsand_stoneout_1:      Lsand_stoneout_1(x, y);         break;
7644     case Xsand_stoneout_2:      Lsand_stoneout_2(x, y);         break;
7645     case Xsand_stonesand_quickout_1: Lsand_stonesand_quickout_1(x, y); break;
7646     case Xsand_stonesand_quickout_2: Lsand_stonesand_quickout_2(x, y); break;
7647
7648     case Xslide_ns:             Lslide_ns(x, y);                break;
7649     case Xslide_ew:             Lslide_ew(x, y);                break;
7650
7651     case Xexit:                 Lexit(x, y);                    break;
7652     case Xexit_1:               Lexit_1(x, y);                  break;
7653     case Xexit_2:               Lexit_2(x, y);                  break;
7654     case Xexit_3:               Lexit_3(x, y);                  break;
7655
7656     case Xpause:                Lpause(x, y);                   break;
7657
7658     case Xchain:                Lchain(x, y);                   break;
7659     case Xboom_bug:             Lboom_bug(x, y);                break;
7660     case Xboom_tank:            Lboom_tank(x, y);               break;
7661     case Xboom_android:         Lboom_android(x, y);            break;
7662     case Xboom_1:               Lboom_1(x, y);                  break;
7663     case Xboom_2:               Lboom_2(x, y);                  break;
7664   }
7665 }
7666
7667 boolean logic_check_wrap(void)
7668 {
7669   int i;
7670
7671   for (i = 0; i < MAX_PLAYERS; i++)
7672   {
7673     if (!ply[i].alive)
7674       continue;
7675
7676     /* check for wrap-around movement */
7677     if (ply[i].x < lev.left ||
7678         ply[i].x > lev.right - 1)
7679       return TRUE;
7680   }
7681
7682   return FALSE;
7683 }
7684
7685 void logic_move(void)
7686 {
7687   int i;
7688
7689   for (i = 0; i < MAX_PLAYERS; i++)
7690   {
7691     if (!ply[i].alive)
7692       continue;
7693
7694     /* check for wrap-around movement */
7695     if (ply[i].x < lev.left ||
7696         ply[i].x > lev.right - 1)
7697     {
7698       ply[i].x = (ply[i].x < lev.left ? lev.right - 1 : lev.left);
7699
7700       if (!lev.infinite_true)
7701         ply[i].y += (ply[i].x == lev.left ? 1 : -1);
7702
7703       game.centered_player_nr_next = i;
7704       game.set_centered_player = TRUE;
7705       game.set_centered_player_wrap = TRUE;
7706     }
7707
7708     ply[i].prev_x = ply[i].x;
7709     ply[i].prev_y = ply[i].y;
7710     ply[i].anim = PLY_still;
7711   }
7712 }
7713
7714 static void logic_players(void)
7715 {
7716   int start_check_nr;
7717   int i;
7718
7719   cave = lev.cave;
7720   next = lev.next;
7721   boom = lev.boom;
7722
7723   game_em.any_player_moving = FALSE;
7724   game_em.any_player_snapping = FALSE;
7725
7726   /* must test for death and actually kill separately */
7727   for (i = 0; i < MAX_PLAYERS; i++)
7728   {
7729     boolean ply_kill = player_killed(&ply[i]);
7730
7731     if (ply[i].alive && ply_kill)
7732       kill_player(&ply[i]);
7733   }
7734
7735   logic_move();
7736
7737   start_check_nr = ((game_em.random & 128 ? 0 : 1) * 2 +
7738                     (game_em.random & 256 ? 0 : 1));
7739
7740   for (i = 0; i < MAX_PLAYERS; i++)
7741   {
7742     int check_nr = (start_check_nr + i) % MAX_PLAYERS;
7743
7744     if (ply[check_nr].alive)
7745       check_player(&ply[check_nr]);
7746   }
7747
7748   for (i = 0; i < MAX_PLAYERS; i++)
7749   {
7750     if (!ply[i].alive)
7751       continue;
7752
7753     if (is_player[cave[ply[i].prev_x][ply[i].prev_y]])
7754     {
7755       int element = cave[ply[i].prev_x][ply[i].prev_y];
7756
7757       cave[ply[i].prev_x][ply[i].prev_y] = remove_player[element];
7758       next[ply[i].prev_x][ply[i].prev_y] = remove_player[element];
7759     }
7760
7761     if (is_blank[cave[ply[i].x][ply[i].y]])
7762     {
7763       int element = cave[ply[i].x][ply[i].y];
7764
7765       cave[ply[i].x][ply[i].y] = add_player[element];
7766       next[ply[i].x][ply[i].y] = add_player[element];
7767     }
7768   }
7769 }
7770
7771 static void logic_objects(void)
7772 {
7773   int x, y;
7774
7775   cave = lev.cave;
7776   next = lev.next;
7777   boom = lev.boom;
7778
7779   seed = game_em.random;
7780   score = 0;
7781
7782   for (y = lev.top; y < lev.bottom; y++)
7783     for (x = lev.left; x < lev.right; x++)
7784       handle_tile(x, y);
7785
7786   if (ply[0].alive || ply[1].alive || ply[2].alive || ply[3].alive)
7787     lev.score += score;         /* only add a score if someone is alive */
7788   else
7789     game_em.game_over = TRUE;
7790
7791   game_em.random = seed;
7792
7793   /* triple buffering */
7794   void *temp = lev.cave;
7795   lev.cave = lev.next;
7796   lev.next = lev.draw;
7797   lev.draw = temp;
7798 }
7799
7800 static void logic_globals(void)
7801 {
7802   int x;
7803   int y;
7804   int count;
7805 #ifdef RANDOM_BUG
7806   uint64_t random;
7807 #else
7808   uint32_t random;
7809 #endif
7810
7811   cave = lev.cave;
7812   next = lev.next;
7813   boom = lev.boom;
7814
7815   /* update variables */
7816
7817   if (lev.score > 9999)
7818     lev.score = 9999;
7819
7820   if (lev.android_move_cnt-- == 0)
7821     lev.android_move_cnt = lev.android_move_time;
7822   if (lev.android_clone_cnt-- == 0)
7823     lev.android_clone_cnt = lev.android_clone_time;
7824   if (lev.ball_active)
7825     if (lev.ball_cnt-- == 0)
7826       lev.ball_cnt = lev.ball_time;
7827   if (lev.lenses_cnt)
7828     lev.lenses_cnt--;
7829   if (lev.magnify_cnt)
7830     lev.magnify_cnt--;
7831   if (lev.wheel_cnt)
7832     lev.wheel_cnt--;
7833   if (lev.wind_cnt)
7834     lev.wind_cnt--;
7835   if (lev.wonderwall_time > 0 && lev.wonderwall_active)
7836     lev.wonderwall_time--;
7837
7838   if (lev.wheel_cnt)
7839     play_element_sound(lev.wheel_x, lev.wheel_y, SOUND_wheel, Xwheel);
7840
7841   /* grow amoeba */
7842
7843   random = game_em.random;
7844
7845   for (count = lev.amoeba_time; count--;)
7846   {
7847     x = lev.left - 1 + (random >> 10) % (CAVE_WIDTH  + 2);
7848     y = lev.top  - 1 + (random >> 20) % (CAVE_HEIGHT + 2);
7849
7850     if (x >= lev.left && x < lev.right &&
7851         y >= lev.top  && y < lev.bottom)
7852       Lamoeba(x, y);
7853
7854     random = random * 129 + 1;
7855
7856 #ifdef RANDOM_BUG
7857     if (!game_em.use_random_bug)
7858       random = (uint32_t)random;
7859 #endif
7860   }
7861
7862   game_em.random = random;
7863
7864   /* handle explosions */
7865
7866   for (y = lev.top; y < lev.bottom; y++)
7867     for (x = lev.left; x < lev.right; x++)
7868       Lexplode(x, y);
7869
7870   /* triple buffering */
7871
7872   for (y = lev.top; y < lev.bottom; y++)
7873     for (x = lev.left; x < lev.right; x++)
7874       next[x][y] = cave[x][y];
7875 }
7876
7877 void logic_init(void)
7878 {
7879   int splash_is_blank = !game_em.use_old_android;
7880
7881   is_android_blank[Xsplash_e] = splash_is_blank;
7882   is_android_blank[Xsplash_w] = splash_is_blank;
7883 }
7884
7885 void logic(void)
7886 {
7887   if (frame == 0)
7888   {
7889     logic_players();
7890     logic_objects();
7891   }
7892
7893   if (frame == 1)
7894   {
7895     logic_globals();
7896   }
7897 }