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