src/game_em/synchro_1.c

   1 /* first part of synchro.
   2  *
   3  * game logic for players.
   4  *
   5  * large switch statement for tiles the player interacts with.
   6  */
   7
   8 #include "tile.h"
   9 #include "level.h"
  10 #include "sample.h"
  11 #include "display.h"
  12
  13
  14 static void check_player(struct PLAYER *);
  15 static void kill_player(struct PLAYER *);
  16 static boolean player_digfield(struct PLAYER *, int, int);
  17 static boolean player_killed(struct PLAYER *);
  18
  19 void synchro_1(void)
  20 {
  21  /* must test for death and actually kill separately */
  22   boolean ply1_kill = player_killed(&ply1);
  23   boolean ply2_kill = player_killed(&ply2);
  24
  25   if (ply1.alive && ply1_kill)
  26     kill_player(&ply1);
  27   if (ply2.alive && ply2_kill)
  28     kill_player(&ply2);
  29
  30 #if 0
  31   ply1.alive = 1; /* debugging */
  32 #endif
  33
  34   ply1.oldx = ply1.x;
  35   ply1.oldy = ply1.y;
  36   ply1.anim = SPR_still;
  37   ply2.oldx = ply2.x;
  38   ply2.oldy = ply2.y;
  39   ply2.anim = SPR_still;
  40
  41   if (Random & 256)
  42   {
  43     if (ply1.alive) check_player(&ply1);
  44     if (ply2.alive) check_player(&ply2);
  45   }
  46   else
  47   {
  48     if (ply2.alive) check_player(&ply2);
  49     if (ply1.alive) check_player(&ply1);
  50   }
  51
  52   if (ply1.alive)
  53   {
  54     if (Cave[ply1.oldy][ply1.oldx] == Zplayer)
  55     {
  56       Cave[ply1.oldy][ply1.oldx] = Xblank;
  57       Next[ply1.oldy][ply1.oldx] = Xblank;
  58     }
  59
  60     if (Cave[ply1.y][ply1.x] == Xblank)
  61     {
  62       Cave[ply1.y][ply1.x] = Zplayer;
  63       Next[ply1.y][ply1.x] = Zplayer;
  64     }
  65   }
  66
  67   if (ply2.alive)
  68   {
  69     if (Cave[ply2.oldy][ply2.oldx] == Zplayer)
  70     {
  71       Cave[ply2.oldy][ply2.oldx] = Xblank;
  72       Next[ply2.oldy][ply2.oldx] = Xblank;
  73     }
  74
  75     if (Cave[ply2.y][ply2.x] == Xblank)
  76     {
  77       Cave[ply2.y][ply2.x] = Zplayer;
  78       Next[ply2.y][ply2.x] = Zplayer;
  79     }
  80   }
  81 }
  82
  83 static boolean player_killed(struct PLAYER *ply)
  84 {
  85   register unsigned int x = ply->x;
  86   register unsigned int y = ply->y;
  87
  88   if (!ply->alive)
  89     return FALSE;
  90
  91 #if 1
  92   if (lev.killed_out_of_time && setup.time_limit)
  93     return TRUE;
  94 #else
  95   if (lev.time_initial > 0 && lev.time == 0 && setup.time_limit)
  96     return TRUE;
  97 #endif
  98
  99   switch(Cave[y-1][x])
 100   {
 101     case Xbug_n:
 102     case Xbug_e:
 103     case Xbug_s:
 104     case Xbug_w:
 105     case Xbug_gon:
 106     case Xbug_goe:
 107     case Xbug_gos:
 108     case Xbug_gow:
 109     case Xtank_n:
 110     case Xtank_e:
 111     case Xtank_s:
 112     case Xtank_w:
 113     case Xtank_gon:
 114     case Xtank_goe:
 115     case Xtank_gos:
 116     case Xtank_gow:
 117       return TRUE;
 118   }
 119
 120   switch(Cave[y][x+1])
 121   {
 122     case Xbug_n:
 123     case Xbug_e:
 124     case Xbug_s:
 125     case Xbug_w:
 126     case Xbug_gon:
 127     case Xbug_goe:
 128     case Xbug_gos:
 129     case Xbug_gow:
 130     case Xtank_n:
 131     case Xtank_e:
 132     case Xtank_s:
 133     case Xtank_w:
 134     case Xtank_gon:
 135     case Xtank_goe:
 136     case Xtank_gos:
 137     case Xtank_gow:
 138       return TRUE;
 139   }
 140
 141   switch(Cave[y+1][x])
 142   {
 143     case Xbug_n:
 144     case Xbug_e:
 145     case Xbug_s:
 146     case Xbug_w:
 147     case Xbug_gon:
 148     case Xbug_goe:
 149     case Xbug_gos:
 150     case Xbug_gow:
 151     case Xtank_n:
 152     case Xtank_e:
 153     case Xtank_s:
 154     case Xtank_w:
 155     case Xtank_gon:
 156     case Xtank_goe:
 157     case Xtank_gos:
 158     case Xtank_gow:
 159       return TRUE;
 160   }
 161
 162   switch(Cave[y][x-1])
 163   {
 164     case Xbug_n:
 165     case Xbug_e:
 166     case Xbug_s:
 167     case Xbug_w:
 168     case Xbug_gon:
 169     case Xbug_goe:
 170     case Xbug_gos:
 171     case Xbug_gow:
 172     case Xtank_n:
 173     case Xtank_e:
 174     case Xtank_s:
 175     case Xtank_w:
 176     case Xtank_gon:
 177     case Xtank_goe:
 178     case Xtank_gos:
 179     case Xtank_gow:
 180       return TRUE;
 181   }
 182
 183   switch(Cave[y][x])
 184   {
 185     case Xblank:
 186     case Yacid_splash_eB:
 187     case Yacid_splash_wB:
 188     case Zplayer:
 189     case Xdynamite_1:
 190     case Xdynamite_2:
 191     case Xdynamite_3:
 192     case Xdynamite_4:
 193 #if 1
 194     case Xfake_acid_1:
 195     case Xfake_acid_2:
 196     case Xfake_acid_3:
 197     case Xfake_acid_4:
 198     case Xfake_acid_5:
 199     case Xfake_acid_6:
 200     case Xfake_acid_7:
 201     case Xfake_acid_8:
 202 #endif
 203       return FALSE;
 204   }
 205
 206   return TRUE;
 207 }
 208
 209 static void kill_player(struct PLAYER *ply)
 210 {
 211   register unsigned int x = ply->x;
 212   register unsigned int y = ply->y;
 213
 214   ply->alive = 0;
 215
 216   switch(Cave[y-1][x])
 217   {
 218     case Xbug_n:
 219     case Xbug_e:
 220     case Xbug_s:
 221     case Xbug_w:
 222     case Xbug_gon:
 223     case Xbug_goe:
 224     case Xbug_gos:
 225     case Xbug_gow:
 226       Cave[y-1][x] = Xboom_bug;
 227 #if 0
 228       play_element_sound(x, y, SAMPLE_boom, Zplayer);
 229 #endif
 230       break;
 231
 232     case Xtank_n:
 233     case Xtank_e:
 234     case Xtank_s:
 235     case Xtank_w:
 236     case Xtank_gon:
 237     case Xtank_goe:
 238     case Xtank_gos:
 239     case Xtank_gow:
 240       Cave[y-1][x] = Xboom_bomb;
 241 #if 0
 242       play_element_sound(x, y, SAMPLE_boom, Zplayer);
 243 #endif
 244       break;
 245   }
 246
 247   switch(Cave[y][x+1])
 248   {
 249     case Xbug_n:
 250     case Xbug_e:
 251     case Xbug_s:
 252     case Xbug_w:
 253     case Xbug_gon:
 254     case Xbug_goe:
 255     case Xbug_gos:
 256     case Xbug_gow:
 257       Cave[y][x+1] = Xboom_bug;
 258 #if 0
 259       play_element_sound(x, y, SAMPLE_boom, Zplayer);
 260 #endif
 261       break;
 262
 263     case Xtank_n:
 264     case Xtank_e:
 265     case Xtank_s:
 266     case Xtank_w:
 267     case Xtank_gon:
 268     case Xtank_goe:
 269     case Xtank_gos:
 270     case Xtank_gow:
 271       Cave[y][x+1] = Xboom_bomb;
 272 #if 0
 273       play_element_sound(x, y, SAMPLE_boom, Zplayer);
 274 #endif
 275       break;
 276   }
 277
 278   switch(Cave[y+1][x])
 279   {
 280     case Xbug_n:
 281     case Xbug_e:
 282     case Xbug_s:
 283     case Xbug_w:
 284     case Xbug_gon:
 285     case Xbug_goe:
 286     case Xbug_gos:
 287     case Xbug_gow:
 288       Cave[y+1][x] = Xboom_bug;
 289 #if 0
 290       play_element_sound(x, y, SAMPLE_boom, Zplayer);
 291 #endif
 292       break;
 293
 294     case Xtank_n:
 295     case Xtank_e:
 296     case Xtank_s:
 297     case Xtank_w:
 298     case Xtank_gon:
 299     case Xtank_goe:
 300     case Xtank_gos:
 301     case Xtank_gow:
 302       Cave[y+1][x] = Xboom_bomb;
 303 #if 0
 304       play_element_sound(x, y, SAMPLE_boom, Zplayer);
 305 #endif
 306       break;
 307   }
 308
 309   switch(Cave[y][x-1])
 310   {
 311     case Xbug_n:
 312     case Xbug_e:
 313     case Xbug_s:
 314     case Xbug_w:
 315     case Xbug_gon:
 316     case Xbug_goe:
 317     case Xbug_gos:
 318     case Xbug_gow:
 319       Cave[y][x-1] = Xboom_bug;
 320 #if 0
 321       play_element_sound(x, y, SAMPLE_boom, Zplayer);
 322 #endif
 323       break;
 324
 325     case Xtank_n:
 326     case Xtank_e:
 327     case Xtank_s:
 328     case Xtank_w:
 329     case Xtank_gon:
 330     case Xtank_goe:
 331     case Xtank_gos:
 332     case Xtank_gow:
 333       Cave[y][x-1] = Xboom_bomb;
 334 #if 0
 335       play_element_sound(x, y, SAMPLE_boom, Zplayer);
 336 #endif
 337       break;
 338   }
 339
 340   switch(Cave[y][x])
 341   {
 342     case Xexit_1:
 343     case Xexit_2:
 344     case Xexit_3:
 345       play_element_sound(x, y, SAMPLE_exit_leave, Xexit_1);
 346       break;
 347
 348     default:
 349       play_element_sound(x, y, SAMPLE_die, Zplayer);
 350       break;
 351   }
 352
 353   switch(Cave[y][x])
 354   {
 355 #if 1
 356     case Xacid_1:
 357     case Xacid_2:
 358     case Xacid_3:
 359     case Xacid_4:
 360     case Xacid_5:
 361     case Xacid_6:
 362     case Xacid_7:
 363     case Xacid_8:
 364       break;
 365 #endif
 366
 367     default:
 368       Cave[y][x] = Xboom_1;
 369       Boom[y][x] = Xblank;
 370       break;
 371   }
 372 }
 373
 374 static void check_player(struct PLAYER *ply)
 375 {
 376   unsigned int oldx = ply->x;
 377   unsigned int oldy = ply->y;
 378   register unsigned int x = oldx;
 379   register unsigned int y = oldy;
 380   unsigned int anim = 0;
 381   int dx = 0, dy = 0;
 382
 383 #if 0
 384   printf("::: up == %d, down == %d, left == %d, right == %d, fire == %d [spin == %d, stick == %d]\n",
 385          ply->joy_n, ply->joy_s, ply->joy_w, ply->joy_e, ply->joy_fire,
 386          ply->joy_spin, ply->joy_stick);
 387 #endif
 388
 389 #if 1
 390   if (ply->joy_w)               /* west */
 391   {
 392     x--;
 393     dx = -1;
 394     anim = 3;
 395   }
 396   else if (ply->joy_e)          /* east */
 397   {
 398     x++;
 399     dx = 1;
 400     anim = 1;
 401   }
 402
 403   if (ply->joy_n)               /* north */
 404   {
 405     y--;
 406     dy = -1;
 407     anim = 0;
 408   }
 409   else if (ply->joy_s)          /* south */
 410   {
 411     y++;
 412     dy = 1;
 413     anim = 2;
 414   }
 415
 416 #else
 417
 418   if ((ply->joy_spin = !ply->joy_spin))
 419   {
 420     if (ply->joy_n)             /* north */
 421     {
 422       y--;
 423       dy = -1;
 424       anim = 0;
 425     }
 426     else if (ply->joy_e)        /* east */
 427     {
 428       x++;
 429       dx = 1;
 430       anim = 1;
 431     }
 432     else if (ply->joy_s)        /* south */
 433     {
 434       y++;
 435       dy = 1;
 436       anim = 2;
 437     }
 438     else if (ply->joy_w)        /* west */
 439     {
 440       x--;
 441       dx = -1;
 442       anim = 3;
 443     }
 444   }
 445   else
 446   {
 447     if (ply->joy_w)             /* west */
 448     {
 449       x--;
 450       dx = -1;
 451       anim = 3;
 452     }
 453     else if (ply->joy_s)        /* south */
 454     {
 455       y++;
 456       dy = 1;
 457       anim = 2;
 458     }
 459     else if (ply->joy_e)        /* east */
 460     {
 461       x++;
 462       dx = 1;
 463       anim = 1;
 464     }
 465     else if (ply->joy_n)        /* north */
 466     {
 467       y--;
 468       dy = -1;
 469       anim = 0;
 470     }
 471   }
 472 #endif
 473
 474   if (dx == 0 && dy == 0)
 475   {
 476     ply->joy_stick = 0;
 477
 478     if (ply->joy_drop)
 479     {
 480       if (++ply->dynamite_cnt == 5 && ply->dynamite)
 481       {
 482         Cave[y][x] = Xdynamite_1;
 483         play_element_sound(x, y, SAMPLE_dynamite, Xdynamite_1);
 484         ply->dynamite--;
 485       }
 486     }
 487     else
 488     {
 489       ply->dynamite_cnt = 0;
 490     }
 491
 492     Random += 7;        /* be a bit more random if the player doesn't move */
 493
 494     return;
 495   }
 496
 497   ply->joy_stick = 1;
 498   ply->joy_n = ply->joy_e = ply->joy_s = ply->joy_w = 0;
 499   ply->dynamite_cnt = 0; /* reset dynamite timer if we move */
 500   ply->joy_spin = !ply->joy_spin;
 501
 502   if (ply->joy_snap == 0)               /* player wants to move */
 503   {
 504     boolean moved = FALSE;
 505
 506     if (ply->last_move_dir & MV_HORIZONTAL)
 507     {
 508       if (!(moved = player_digfield(ply, 0, dy)))
 509         moved = player_digfield(ply, dx, 0);
 510     }
 511     else
 512     {
 513       if (!(moved = player_digfield(ply, dx, 0)))
 514         moved = player_digfield(ply, 0, dy);
 515     }
 516
 517     if (moved)
 518     {
 519       if (oldx != ply->x)
 520         ply->last_move_dir = (dx < 0 ? MV_LEFT : MV_RIGHT);
 521       else if (oldy != ply->y)
 522         ply->last_move_dir = (dy < 0 ? MV_UP : MV_DOWN);
 523     }
 524   }
 525   else                                  /* player wants to snap */
 526   {
 527     player_digfield(ply, dx, dy);
 528   }
 529 }
 530
 531 static boolean player_digfield(struct PLAYER *ply, int dx, int dy)
 532 {
 533   int anim = (dx < 0 ? 3 : dx > 0 ? 1 : dy < 0 ? 0 : dy > 0 ? 2 : 2);
 534   unsigned int oldx = ply->x;
 535   unsigned int oldy = ply->y;
 536   register unsigned int x = oldx + dx;
 537   register unsigned int y = oldy + dy;
 538   boolean result = TRUE;
 539
 540   if (!dx && !dy)                       /* no direction specified */
 541     return FALSE;
 542
 543   if (dx && dy && ply->joy_snap)        /* more than one direction specified */
 544     return FALSE;
 545
 546   if (ply->joy_snap == 0)               /* player wants to move */
 547   {
 548     int element = Cave[y][x];
 549
 550     switch(Cave[y][x])
 551     {
 552       /* fire is released */
 553       case Xblank:
 554       case Yacid_splash_eB:
 555       case Yacid_splash_wB:
 556         Cave[y][x] = Zplayer;
 557         Next[y][x] = Zplayer;
 558 #if 1
 559       case Xfake_acid_1:
 560       case Xfake_acid_2:
 561       case Xfake_acid_3:
 562       case Xfake_acid_4:
 563       case Xfake_acid_5:
 564       case Xfake_acid_6:
 565       case Xfake_acid_7:
 566       case Xfake_acid_8:
 567 #endif
 568         play_element_sound(x, y, SAMPLE_blank, Xblank);
 569         ply->anim = SPR_walk + anim;
 570         ply->x = x;
 571         ply->y = y;
 572         break;
 573
 574 #if 1
 575       case Xacid_1:
 576       case Xacid_2:
 577       case Xacid_3:
 578       case Xacid_4:
 579       case Xacid_5:
 580       case Xacid_6:
 581       case Xacid_7:
 582       case Xacid_8:
 583 #endif
 584         if (Cave[y-1][x+1] == Xblank)
 585           Cave[y-1][x+1] = Yacid_splash_eB;
 586         if (Cave[y-1][x-1] == Xblank)
 587           Cave[y-1][x-1] = Yacid_splash_wB;
 588         play_element_sound(x, y, SAMPLE_acid, Xacid_1);
 589
 590       case Xboom_android:
 591       case Xboom_1:
 592       case Xbug_n:
 593       case Xbug_e:
 594       case Xbug_s:
 595       case Xbug_w:
 596       case Xbug_gon:
 597       case Xbug_goe:
 598       case Xbug_gos:
 599       case Xbug_gow:
 600       case Xtank_n:
 601       case Xtank_e:
 602       case Xtank_s:
 603       case Xtank_w:
 604       case Xtank_gon:
 605       case Xtank_goe:
 606       case Xtank_gos:
 607       case Xtank_gow:
 608 #if 0
 609       case Xacid_1:
 610       case Xacid_2:
 611       case Xacid_3:
 612       case Xacid_4:
 613       case Xacid_5:
 614       case Xacid_6:
 615       case Xacid_7:
 616       case Xacid_8:
 617 #endif
 618         ply->anim = SPR_walk + anim;
 619         ply->x = x;
 620         ply->y = y;
 621         break;
 622
 623       case Xgrass:
 624         Cave[y][x] = (dy ? (dy < 0 ? Ygrass_nB : Ygrass_sB) :
 625                       (dx > 0 ? Ygrass_eB : Ygrass_wB));
 626         Next[y][x] = Zplayer;
 627         play_element_sound(x, y, SAMPLE_dirt, Xgrass);
 628         ply->anim = SPR_walk + anim;
 629         ply->x = x;
 630         ply->y = y;
 631         break;
 632
 633       case Xdirt:
 634         Cave[y][x] = (dy ? (dy < 0 ? Ydirt_nB : Ydirt_sB) :
 635                       (dx > 0 ? Ydirt_eB : Ydirt_wB));
 636         Next[y][x] = Zplayer;
 637         play_element_sound(x, y, SAMPLE_dirt, Xdirt);
 638         ply->anim = SPR_walk + anim;
 639         ply->x = x;
 640         ply->y = y;
 641         break;
 642
 643       case Xdiamond:
 644       case Xdiamond_pause:
 645         Cave[y][x] = Ydiamond_eat;
 646         Next[y][x] = Zplayer;
 647         play_element_sound(x, y, SAMPLE_collect, element);
 648         lev.score += lev.diamond_score;
 649         lev.required = lev.required < 3 ? 0 : lev.required - 3;
 650         ply->anim = SPR_walk + anim;
 651         ply->x = x;
 652         ply->y = y;
 653         break;
 654
 655       case Xemerald:
 656       case Xemerald_pause:
 657         Cave[y][x] = Yemerald_eat;
 658         Next[y][x] = Zplayer;
 659         play_element_sound(x, y, SAMPLE_collect, element);
 660         lev.score += lev.emerald_score;
 661         lev.required = lev.required < 1 ? 0 : lev.required - 1;
 662         ply->anim = SPR_walk + anim;
 663         ply->x = x;
 664         ply->y = y;
 665         break;
 666
 667       case Xdynamite:
 668         Cave[y][x] = Ydynamite_eat;
 669         Next[y][x] = Zplayer;
 670         play_element_sound(x, y, SAMPLE_collect, element);
 671         lev.score += lev.dynamite_score;
 672         ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
 673         ply->anim = SPR_walk + anim;
 674         ply->x = x;
 675         ply->y = y;
 676         break;
 677
 678       case Xkey_1:
 679         ply->keys |= 0x01;
 680         Cave[y][x] = Ykey_1_eat;
 681         goto key_walk;
 682
 683       case Xkey_2:
 684         ply->keys |= 0x02;
 685         Cave[y][x] = Ykey_2_eat;
 686         goto key_walk;
 687
 688       case Xkey_3:
 689         ply->keys |= 0x04;
 690         Cave[y][x] = Ykey_3_eat;
 691         goto key_walk;
 692
 693       case Xkey_4:
 694         ply->keys |= 0x08;
 695         Cave[y][x] = Ykey_4_eat;
 696         goto key_walk;
 697
 698       case Xkey_5:
 699         ply->keys |= 0x10;
 700         Cave[y][x] = Ykey_5_eat;
 701         goto key_walk;
 702
 703       case Xkey_6:
 704         ply->keys |= 0x20;
 705         Cave[y][x] = Ykey_6_eat;
 706         goto key_walk;
 707
 708       case Xkey_7:
 709         ply->keys |= 0x40;
 710         Cave[y][x] = Ykey_7_eat;
 711         goto key_walk;
 712
 713       case Xkey_8:
 714         ply->keys |= 0x80;
 715         Cave[y][x] = Ykey_8_eat;
 716         goto key_walk;
 717
 718       key_walk:
 719
 720         Next[y][x] = Zplayer;
 721         play_element_sound(x, y, SAMPLE_collect, element);
 722         lev.score += lev.key_score;
 723         ply->anim = SPR_walk + anim;
 724         ply->x = x;
 725         ply->y = y;
 726         break;
 727
 728       case Xlenses:
 729         Cave[y][x] = Ylenses_eat;
 730         Next[y][x] = Zplayer;
 731         play_element_sound(x, y, SAMPLE_collect, element);
 732         lev.score += lev.lenses_score;
 733         lev.lenses_cnt = lev.lenses_time;
 734         ply->anim = SPR_walk + anim;
 735         ply->x = x;
 736         ply->y = y;
 737         break;
 738
 739       case Xmagnify:
 740         Cave[y][x] = Ymagnify_eat;
 741         Next[y][x] = Zplayer;
 742         play_element_sound(x, y, SAMPLE_collect, element);
 743         lev.score += lev.magnify_score;
 744         lev.magnify_cnt = lev.magnify_time;
 745         ply->anim = SPR_walk + anim;
 746         ply->x = x;
 747         ply->y = y;
 748         break;
 749
 750       case Xstone:
 751         if (dy)
 752           break;
 753
 754         switch(Cave[y][x+dx])
 755         {
 756           case Xacid_1:
 757           case Xacid_2:
 758           case Xacid_3:
 759           case Xacid_4:
 760           case Xacid_5:
 761           case Xacid_6:
 762           case Xacid_7:
 763           case Xacid_8:
 764             if (Cave[y-1][x+dx+1] == Xblank)
 765               Cave[y-1][x+dx+1] = Yacid_splash_eB;
 766             if (Cave[y-1][x+dx-1] == Xblank)
 767               Cave[y-1][x+dx-1] = Yacid_splash_wB;
 768             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
 769             goto stone_walk;
 770
 771           case Xblank:
 772           case Yacid_splash_eB:
 773           case Yacid_splash_wB:
 774             Cave[y][x+dx] = dx > 0 ? Ystone_e : Ystone_w;
 775             Next[y][x+dx] = Xstone_pause;
 776
 777           stone_walk:
 778
 779             Cave[y][x] = dx > 0 ? Ystone_eB : Ystone_wB;
 780             Next[y][x] = Zplayer;
 781             play_element_sound(x, y, SAMPLE_roll, Xstone);
 782             ply->x = x;
 783         }
 784
 785         ply->anim = SPR_push + anim;
 786         break;
 787
 788       case Xbomb:
 789         if (dy)
 790           break;
 791
 792         switch(Cave[y][x+dx])
 793         {
 794           case Xacid_1:
 795           case Xacid_2:
 796           case Xacid_3:
 797           case Xacid_4:
 798           case Xacid_5:
 799           case Xacid_6:
 800           case Xacid_7:
 801           case Xacid_8:
 802             if (Cave[y-1][x+dx+1] == Xblank)
 803               Cave[y-1][x+dx+1] = Yacid_splash_eB;
 804             if (Cave[y-1][x+dx-1] == Xblank)
 805               Cave[y-1][x+dx-1] = Yacid_splash_wB;
 806             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
 807             goto bomb_walk;
 808
 809           case Xblank:
 810           case Yacid_splash_eB:
 811           case Yacid_splash_wB:
 812             Cave[y][x+dx] = dx > 0 ? Ybomb_e : Ybomb_w;
 813             Next[y][x+dx] = Xbomb_pause;
 814
 815           bomb_walk:
 816
 817             Cave[y][x] = dx > 0 ? Ybomb_eB : Ybomb_wB;
 818             Next[y][x] = Zplayer;
 819             play_element_sound(x, y, SAMPLE_roll, Xbomb);
 820             ply->x = x;
 821         }
 822
 823         ply->anim = SPR_push + anim;
 824         break;
 825
 826       case Xnut:
 827         if (dy)
 828           break;
 829
 830         switch(Cave[y][x+dx])
 831         {
 832           case Xacid_1:
 833           case Xacid_2:
 834           case Xacid_3:
 835           case Xacid_4:
 836           case Xacid_5:
 837           case Xacid_6:
 838           case Xacid_7:
 839           case Xacid_8:
 840             if (Cave[y-1][x+dx+1] == Xblank)
 841               Cave[y-1][x+dx+1] = Yacid_splash_eB;
 842             if (Cave[y-1][x+dx-1] == Xblank)
 843               Cave[y-1][x+dx-1] = Yacid_splash_wB;
 844             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
 845             goto nut_walk;
 846
 847           case Xblank:
 848           case Yacid_splash_eB:
 849           case Yacid_splash_wB:
 850             Cave[y][x+dx] = dx > 0 ? Ynut_e : Ynut_w;
 851             Next[y][x+dx] = Xnut_pause;
 852
 853           nut_walk:
 854
 855             Cave[y][x] = dx > 0 ? Ynut_eB : Ynut_wB;
 856             Next[y][x] = Zplayer;
 857             play_element_sound(x, y, SAMPLE_roll, Xnut);
 858             ply->x = x;
 859         }
 860
 861         ply->anim = SPR_push + anim;
 862         break;
 863
 864       case Xspring:
 865         if (dy)
 866           break;
 867
 868         switch(Cave[y][x+dx])
 869         {
 870           case Xalien:
 871           case Xalien_pause:
 872             Cave[y][x] = dx > 0 ? Yspring_kill_eB : Yspring_kill_wB;
 873             Cave[y][x+dx] = dx > 0 ? Yspring_kill_e : Yspring_kill_w;
 874             Next[y][x] = Zplayer;
 875             Next[y][x+dx] = dx > 0 ? Xspring_e : Xspring_w;
 876             play_element_sound(x, y, SAMPLE_slurp, Xalien);
 877             lev.score += lev.slurp_score;
 878             ply->x = x;
 879             break;
 880
 881           case Xacid_1:
 882           case Xacid_2:
 883           case Xacid_3:
 884           case Xacid_4:
 885           case Xacid_5:
 886           case Xacid_6:
 887           case Xacid_7:
 888           case Xacid_8:
 889             if (Cave[y-1][x+dx+1] == Xblank)
 890               Cave[y-1][x+dx+1] = Yacid_splash_eB;
 891             if (Cave[y-1][x+dx-1] == Xblank)
 892               Cave[y-1][x+dx-1] = Yacid_splash_wB;
 893             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
 894             goto spring_walk;
 895
 896           case Xblank:
 897           case Yacid_splash_eB:
 898           case Yacid_splash_wB:
 899             Cave[y][x+dx] = dx > 0 ? Yspring_e : Yspring_w;
 900             Next[y][x+dx] = dx > 0 ? Xspring_e : Xspring_w;
 901
 902           spring_walk:
 903             Cave[y][x] = dx > 0 ? Yspring_eB : Yspring_wB;
 904             Next[y][x] = Zplayer;
 905             play_element_sound(x, y, SAMPLE_roll, Xspring);
 906             ply->x = x;
 907         }
 908
 909         ply->anim = SPR_push + anim;
 910         break;
 911
 912       case Xspring_pause:
 913       case Xstone_pause:
 914       case Xbomb_pause:
 915       case Xnut_pause:
 916       case Xsand_stonein_1:
 917       case Xsand_stonein_2:
 918       case Xsand_stonein_3:
 919       case Xsand_stonein_4:
 920         if (dy)
 921           break;
 922
 923         ply->anim = SPR_push + anim;
 924         break;
 925
 926       case Xballoon:
 927         switch(Cave[y+dy][x+dx])
 928         {
 929           case Xacid_1:
 930           case Xacid_2:
 931           case Xacid_3:
 932           case Xacid_4:
 933           case Xacid_5:
 934           case Xacid_6:
 935           case Xacid_7:
 936           case Xacid_8:
 937             if (Cave[y+dy-1][x+dx+1] == Xblank)
 938               Cave[y+dy-1][x+dx+1] = Yacid_splash_eB;
 939             if (Cave[y+dy-1][x+dx-1] == Xblank)
 940               Cave[y+dy-1][x+dx-1] = Yacid_splash_wB;
 941             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
 942             goto balloon_walk;
 943
 944           case Xblank:
 945           case Yacid_splash_eB:
 946           case Yacid_splash_wB:
 947             Cave[y+dy][x+dx] = (dy ? (dy < 0 ? Yballoon_n : Yballoon_s) :
 948                                 (dx > 0 ? Yballoon_e : Yballoon_w));
 949             Next[y+dy][x+dx] = Xballoon;
 950
 951           balloon_walk:
 952             Cave[y][x] = (dy ? (dy < 0 ? Yballoon_nB : Yballoon_sB) :
 953                           (dx > 0 ? Yballoon_eB : Yballoon_wB));
 954             Next[y][x] = Zplayer;
 955             play_element_sound(x, y, SAMPLE_push, Xballoon);
 956             ply->x = x;
 957             ply->y = y;
 958         }
 959
 960         ply->anim = SPR_push + anim;
 961         break;
 962
 963       case Xandroid:
 964       case Xandroid_1_n:
 965       case Xandroid_2_n:
 966       case Xandroid_1_e:
 967       case Xandroid_2_e:
 968       case Xandroid_1_s:
 969       case Xandroid_2_s:
 970       case Xandroid_1_w:
 971       case Xandroid_2_w:
 972         switch(Cave[y+dy][x+dx])
 973         {
 974           case Xacid_1:
 975           case Xacid_2:
 976           case Xacid_3:
 977           case Xacid_4:
 978           case Xacid_5:
 979           case Xacid_6:
 980           case Xacid_7:
 981           case Xacid_8:
 982             if (Cave[y+dy-1][x+dx+1] == Xblank)
 983               Cave[y+dy-1][x+dx+1] = Yacid_splash_eB;
 984             if (Cave[y+dy-1][x+dx-1] == Xblank)
 985               Cave[y+dy-1][x+dx-1] = Yacid_splash_wB;
 986             play_element_sound(x, y, SAMPLE_acid, Xacid_1);
 987             goto android_walk;
 988
 989           case Xblank:
 990           case Yacid_splash_eB:
 991           case Yacid_splash_wB:
 992             Cave[y+dy][x+dx] = (dy ? (dy < 0 ? Yandroid_n : Yandroid_s) :
 993                                 (dx > 0 ? Yandroid_e : Yandroid_w));
 994             Next[y+dy][x+dx] = (dy ? (dy < 0 ? Xandroid_2_n : Xandroid_2_s) :
 995                                 (dx > 0 ? Xandroid_2_e : Xandroid_2_w));
 996
 997           android_walk:
 998             Cave[y][x] = (dy ? (dy < 0 ? Yandroid_nB : Yandroid_sB) :
 999                           (dx > 0 ? Yandroid_eB : Yandroid_wB));
1000             Next[y][x] = Zplayer;
1001             play_element_sound(x, y, SAMPLE_push, Xandroid);
1002             ply->x = x;
1003             ply->y = y;
1004         }
1005
1006         ply->anim = SPR_push + anim;
1007         break;
1008
1009       case Xdoor_1:
1010       case Xfake_door_1:
1011         if (ply->keys & 0x01)
1012           goto door_walk;
1013         else
1014           break;
1015
1016       case Xdoor_2:
1017       case Xfake_door_2:
1018         if (ply->keys & 0x02)
1019           goto door_walk;
1020         else
1021           break;
1022
1023       case Xdoor_3:
1024       case Xfake_door_3:
1025         if (ply->keys & 0x04)
1026           goto door_walk;
1027         else
1028           break;
1029
1030       case Xdoor_4:
1031       case Xfake_door_4:
1032         if (ply->keys & 0x08)
1033           goto door_walk;
1034         else
1035           break;
1036
1037       case Xdoor_5:
1038       case Xfake_door_5:
1039         if (ply->keys & 0x10)
1040           goto door_walk;
1041         else
1042           break;
1043
1044       case Xdoor_6:
1045       case Xfake_door_6:
1046         if (ply->keys & 0x20)
1047           goto door_walk;
1048         else
1049           break;
1050
1051       case Xdoor_7:
1052       case Xfake_door_7:
1053         if (ply->keys & 0x40)
1054           goto door_walk;
1055         else
1056           break;
1057
1058       case Xdoor_8:
1059       case Xfake_door_8:
1060         if (ply->keys & 0x80)
1061           goto door_walk;
1062         else
1063           break;
1064
1065       door_walk:
1066         if (!tab_blank[Cave[y+dy][x+dx]])
1067           break;
1068
1069         Cave[y+dy][x+dx] = Zplayer;
1070         Next[y+dy][x+dx] = Zplayer;
1071         play_element_sound(x, y, SAMPLE_door, element);
1072         ply->anim = SPR_walk + anim;
1073         ply->x = x + dx;
1074         ply->y = y + dy;
1075         break;
1076
1077       case Xwheel:
1078         play_element_sound(x, y, SAMPLE_press, element);
1079         lev.wheel_cnt = lev.wheel_time;
1080         lev.wheel_x = x;
1081         lev.wheel_y = y;
1082         break;
1083
1084       case Xwind_n:
1085         lev.wind_direction = 0;
1086         goto wind_walk;
1087
1088       case Xwind_e:
1089         lev.wind_direction = 1;
1090         goto wind_walk;
1091
1092       case Xwind_s:
1093         lev.wind_direction = 2;
1094         goto wind_walk;
1095
1096       case Xwind_w:
1097         lev.wind_direction = 3;
1098         goto wind_walk;
1099
1100       case Xwind_nesw:
1101         lev.wind_direction = dy ? (dy < 0 ? 0 : 2) : (dx > 0 ? 1 : 3);
1102         goto wind_walk;
1103
1104       wind_walk:
1105         play_element_sound(x, y, SAMPLE_press, element);
1106         lev.wind_cnt = lev.wind_time;
1107         break;
1108
1109       case Xwind_stop:
1110         play_element_sound(x, y, SAMPLE_press, element);
1111         lev.wind_cnt = 0;
1112         break;
1113
1114       case Xswitch:
1115         play_element_sound(x, y, SAMPLE_press, element);
1116         lev.ball_cnt = lev.ball_time;
1117         lev.ball_state = !lev.ball_state;
1118         break;
1119
1120       case Xplant:
1121         Cave[y][x] = Yplant;
1122         Next[y][x] = Xplant;
1123         play_element_sound(x, y, SAMPLE_blank, Xplant);
1124         ply->anim = SPR_walk + anim;
1125         ply->x = x;
1126         ply->y = y;
1127         break;
1128
1129       case Xexit_1:
1130       case Xexit_2:
1131       case Xexit_3:
1132         play_element_sound(x, y, SAMPLE_exit_leave, Xexit_1);
1133
1134         lev.home--;
1135
1136 #if 0
1137         /* !!! CHECK SCORE CALCULATION !!! */
1138         if (lev.home == 0 && lev.time_initial > 0)      /* game won */
1139           lev.score += lev.time * lev.exit_score / 100;
1140 #endif
1141
1142         ply->anim = SPR_walk + anim;
1143         ply->x = x;
1144         ply->y = y;
1145
1146         break;
1147     }
1148
1149     if (ply->x == oldx && ply->y == oldy)       /* no movement */
1150       result = FALSE;
1151   }
1152   else                                  /* player wants to snap */
1153   {
1154     int element = Cave[y][x];
1155
1156     switch(Cave[y][x])
1157     {
1158       /* fire is pressed */
1159
1160       case Xgrass:
1161         Cave[y][x] = Ygrass_eat;
1162         Next[y][x] = Xblank;
1163         play_element_sound(x, y, SAMPLE_dirt, element);
1164         ply->anim = SPR_spray + anim;
1165         break;
1166
1167       case Xdirt:
1168         Cave[y][x] = Ydirt_eat;
1169         Next[y][x] = Xblank;
1170         play_element_sound(x, y, SAMPLE_dirt, element);
1171         ply->anim = SPR_spray + anim;
1172         break;
1173
1174       case Xdiamond:
1175       case Xdiamond_pause:
1176         Cave[y][x] = Ydiamond_eat;
1177         Next[y][x] = Xblank;
1178         play_element_sound(x, y, SAMPLE_collect, element);
1179         lev.score += lev.diamond_score;
1180         lev.required = lev.required < 3 ? 0 : lev.required - 3;
1181         ply->anim = SPR_walk + anim;
1182         break;
1183
1184       case Xemerald:
1185       case Xemerald_pause:
1186         Cave[y][x] = Yemerald_eat;
1187         Next[y][x] = Xblank;
1188         play_element_sound(x, y, SAMPLE_collect, element);
1189         lev.score += lev.emerald_score;
1190         lev.required = lev.required < 1 ? 0 : lev.required - 1;
1191         ply->anim = SPR_walk + anim;
1192         break;
1193
1194       case Xdynamite:
1195         Cave[y][x] = Ydynamite_eat;
1196         Next[y][x] = Xblank;
1197         play_element_sound(x, y, SAMPLE_collect, element);
1198         lev.score += lev.dynamite_score;
1199         ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
1200         ply->anim = SPR_walk + anim;
1201         break;
1202
1203       case Xkey_1:
1204         ply->keys |= 0x01;
1205         Cave[y][x] = Ykey_1_eat;
1206         goto key_shoot;
1207
1208       case Xkey_2:
1209         ply->keys |= 0x02;
1210         Cave[y][x] = Ykey_2_eat;
1211         goto key_shoot;
1212
1213       case Xkey_3:
1214         ply->keys |= 0x04;
1215         Cave[y][x] = Ykey_3_eat;
1216         goto key_shoot;
1217
1218       case Xkey_4:
1219         ply->keys |= 0x08;
1220         Cave[y][x] = Ykey_4_eat;
1221         goto key_shoot;
1222
1223       case Xkey_5:
1224         ply->keys |= 0x10;
1225         Cave[y][x] = Ykey_5_eat;
1226         goto key_shoot;
1227
1228       case Xkey_6:
1229         ply->keys |= 0x20;
1230         Cave[y][x] = Ykey_6_eat;
1231         goto key_shoot;
1232
1233       case Xkey_7:
1234         ply->keys |= 0x40;
1235         Cave[y][x] = Ykey_7_eat;
1236         goto key_shoot;
1237
1238       case Xkey_8:
1239         ply->keys |= 0x80;
1240         Cave[y][x] = Ykey_8_eat;
1241         goto key_shoot;
1242
1243       key_shoot:
1244         Next[y][x] = Xblank;
1245         play_element_sound(x, y, SAMPLE_collect, element);
1246         lev.score += lev.key_score;
1247         ply->anim = SPR_walk + anim;
1248         break;
1249
1250       case Xlenses:
1251         Cave[y][x] = Ylenses_eat;
1252         Next[y][x] = Xblank;
1253         play_element_sound(x, y, SAMPLE_collect, element);
1254         lev.score += lev.lenses_score;
1255         lev.lenses_cnt = lev.lenses_time;
1256         ply->anim = SPR_walk + anim;
1257         break;
1258
1259       case Xmagnify:
1260         Cave[y][x] = Ymagnify_eat;
1261         Next[y][x] = Xblank;
1262         play_element_sound(x, y, SAMPLE_collect, element);
1263         lev.score += lev.magnify_score;
1264         lev.magnify_cnt = lev.magnify_time;
1265         ply->anim = SPR_walk + anim;
1266         break;
1267
1268       default:
1269         result = FALSE;
1270     }
1271   }
1272
1273   return result;
1274 }