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