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