src/game_em/logic.c

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