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