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_initial > 0 && 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         Cave[y][x] = Ykey_1_eat;
 545         goto key_walk;
 546
 547       case Xkey_2:
 548         ply->keys |= 0x02;
 549         Cave[y][x] = Ykey_2_eat;
 550         goto key_walk;
 551
 552       case Xkey_3:
 553         ply->keys |= 0x04;
 554         Cave[y][x] = Ykey_3_eat;
 555         goto key_walk;
 556
 557       case Xkey_4:
 558         ply->keys |= 0x08;
 559         Cave[y][x] = Ykey_4_eat;
 560         goto key_walk;
 561
 562       case Xkey_5:
 563         ply->keys |= 0x10;
 564         Cave[y][x] = Ykey_5_eat;
 565         goto key_walk;
 566
 567       case Xkey_6:
 568         ply->keys |= 0x20;
 569         Cave[y][x] = Ykey_6_eat;
 570         goto key_walk;
 571
 572       case Xkey_7:
 573         ply->keys |= 0x40;
 574         Cave[y][x] = Ykey_7_eat;
 575         goto key_walk;
 576
 577       case Xkey_8:
 578         ply->keys |= 0x80;
 579         Cave[y][x] = Ykey_8_eat;
 580         goto key_walk;
 581
 582       key_walk:
 583
 584         Next[y][x] = Zplayer;
 585         play_element_sound(x, y, SAMPLE_collect, element);
 586         lev.score += lev.key_score;
 587         ply->anim = SPR_walk + anim;
 588         ply->x = x;
 589         ply->y = y;
 590         break;
 591
 592       case Xlenses:
 593         Cave[y][x] = Ylenses_eat;
 594         Next[y][x] = Zplayer;
 595         play_element_sound(x, y, SAMPLE_collect, element);
 596         lev.score += lev.lenses_score;
 597         lev.lenses_cnt = lev.lenses_time;
 598         ply->anim = SPR_walk + anim;
 599         ply->x = x;
 600         ply->y = y;
 601         break;
 602
 603       case Xmagnify:
 604         Cave[y][x] = Ymagnify_eat;
 605         Next[y][x] = Zplayer;
 606         play_element_sound(x, y, SAMPLE_collect, element);
 607         lev.score += lev.magnify_score;
 608         lev.magnify_cnt = lev.magnify_time;
 609         ply->anim = SPR_walk + anim;
 610         ply->x = x;
 611         ply->y = y;
 612         break;
 613
 614       case Xstone:
 615         if (dy)
 616           break;
 617
 618         switch(Cave[y][x+dx])
 619         {
 620           case Xacid_1:
 621           case Xacid_2:
 622           case Xacid_3:
 623           case Xacid_4:
 624           case Xacid_5:
 625           case Xacid_6:
 626           case Xacid_7:
 627           case Xacid_8:
 628             if (Cave[y-1][x+dx+1] == Xblank)
 629               Cave[y-1][x+dx+1] = Yacid_splash_eB;
 630             if (Cave[y-1][x+dx-1] == Xblank)
 631               Cave[y-1][x+dx-1] = Yacid_splash_wB;
 632             play_sound(x, y, SAMPLE_acid);
 633             goto stone_walk;
 634
 635           case Xblank:
 636           case Yacid_splash_eB:
 637           case Yacid_splash_wB:
 638             Cave[y][x+dx] = dx > 0 ? Ystone_e : Ystone_w;
 639             Next[y][x+dx] = Xstone_pause;
 640
 641           stone_walk:
 642
 643             Cave[y][x] = dx > 0 ? Ystone_eB : Ystone_wB;
 644             Next[y][x] = Zplayer;
 645             play_element_sound(x, y, SAMPLE_roll, Xstone);
 646             ply->x = x;
 647         }
 648
 649         ply->anim = SPR_push + anim;
 650         break;
 651
 652       case Xbomb:
 653         if (dy)
 654           break;
 655
 656         switch(Cave[y][x+dx])
 657         {
 658           case Xacid_1:
 659           case Xacid_2:
 660           case Xacid_3:
 661           case Xacid_4:
 662           case Xacid_5:
 663           case Xacid_6:
 664           case Xacid_7:
 665           case Xacid_8:
 666             if (Cave[y-1][x+dx+1] == Xblank)
 667               Cave[y-1][x+dx+1] = Yacid_splash_eB;
 668             if (Cave[y-1][x+dx-1] == Xblank)
 669               Cave[y-1][x+dx-1] = Yacid_splash_wB;
 670             play_sound(x, y, SAMPLE_acid);
 671             goto bomb_walk;
 672
 673           case Xblank:
 674           case Yacid_splash_eB:
 675           case Yacid_splash_wB:
 676             Cave[y][x+dx] = dx > 0 ? Ybomb_e : Ybomb_w;
 677             Next[y][x+dx] = Xbomb_pause;
 678
 679           bomb_walk:
 680
 681             Cave[y][x] = dx > 0 ? Ybomb_eB : Ybomb_wB;
 682             Next[y][x] = Zplayer;
 683             play_element_sound(x, y, SAMPLE_roll, Xbomb);
 684             ply->x = x;
 685         }
 686
 687         ply->anim = SPR_push + anim;
 688         break;
 689
 690       case Xnut:
 691         if (dy)
 692           break;
 693
 694         switch(Cave[y][x+dx])
 695         {
 696           case Xacid_1:
 697           case Xacid_2:
 698           case Xacid_3:
 699           case Xacid_4:
 700           case Xacid_5:
 701           case Xacid_6:
 702           case Xacid_7:
 703           case Xacid_8:
 704             if (Cave[y-1][x+dx+1] == Xblank)
 705               Cave[y-1][x+dx+1] = Yacid_splash_eB;
 706             if (Cave[y-1][x+dx-1] == Xblank)
 707               Cave[y-1][x+dx-1] = Yacid_splash_wB;
 708             play_sound(x, y, SAMPLE_acid);
 709             goto nut_walk;
 710
 711           case Xblank:
 712           case Yacid_splash_eB:
 713           case Yacid_splash_wB:
 714             Cave[y][x+dx] = dx > 0 ? Ynut_e : Ynut_w;
 715             Next[y][x+dx] = Xnut_pause;
 716
 717           nut_walk:
 718
 719             Cave[y][x] = dx > 0 ? Ynut_eB : Ynut_wB;
 720             Next[y][x] = Zplayer;
 721             play_element_sound(x, y, SAMPLE_roll, Xnut);
 722             ply->x = x;
 723         }
 724
 725         ply->anim = SPR_push + anim;
 726         break;
 727
 728       case Xspring:
 729         if (dy)
 730           break;
 731
 732         switch(Cave[y][x+dx])
 733         {
 734           case Xalien:
 735           case Xalien_pause:
 736             Cave[y][x] = dx > 0 ? Yspring_kill_eB : Yspring_kill_wB;
 737             Cave[y][x+dx] = dx > 0 ? Yspring_kill_e : Yspring_kill_w;
 738             Next[y][x] = Zplayer;
 739             Next[y][x+dx] = dx > 0 ? Xspring_e : Xspring_w;
 740             play_element_sound(x, y, SAMPLE_slurp, Xalien);
 741             lev.score += lev.slurp_score;
 742             ply->x = x;
 743             break;
 744
 745           case Xacid_1:
 746           case Xacid_2:
 747           case Xacid_3:
 748           case Xacid_4:
 749           case Xacid_5:
 750           case Xacid_6:
 751           case Xacid_7:
 752           case Xacid_8:
 753             if (Cave[y-1][x+dx+1] == Xblank)
 754               Cave[y-1][x+dx+1] = Yacid_splash_eB;
 755             if (Cave[y-1][x+dx-1] == Xblank)
 756               Cave[y-1][x+dx-1] = Yacid_splash_wB;
 757             play_sound(x, y, SAMPLE_acid);
 758             goto spring_walk;
 759
 760           case Xblank:
 761           case Yacid_splash_eB:
 762           case Yacid_splash_wB:
 763             Cave[y][x+dx] = dx > 0 ? Yspring_e : Yspring_w;
 764             Next[y][x+dx] = dx > 0 ? Xspring_e : Xspring_w;
 765
 766           spring_walk:
 767             Cave[y][x] = dx > 0 ? Yspring_eB : Yspring_wB;
 768             Next[y][x] = Zplayer;
 769             play_element_sound(x, y, SAMPLE_roll, Xspring);
 770             ply->x = x;
 771         }
 772
 773         ply->anim = SPR_push + anim;
 774         break;
 775
 776       case Xspring_pause:
 777       case Xstone_pause:
 778       case Xbomb_pause:
 779       case Xnut_pause:
 780       case Xsand_stonein_1:
 781       case Xsand_stonein_2:
 782       case Xsand_stonein_3:
 783       case Xsand_stonein_4:
 784         if (dy)
 785           break;
 786
 787         ply->anim = SPR_push + anim;
 788         break;
 789
 790       case Xballoon:
 791         switch(Cave[y+dy][x+dx])
 792         {
 793           case Xacid_1:
 794           case Xacid_2:
 795           case Xacid_3:
 796           case Xacid_4:
 797           case Xacid_5:
 798           case Xacid_6:
 799           case Xacid_7:
 800           case Xacid_8:
 801             if (Cave[y+dy-1][x+dx+1] == Xblank)
 802               Cave[y+dy-1][x+dx+1] = Yacid_splash_eB;
 803             if (Cave[y+dy-1][x+dx-1] == Xblank)
 804               Cave[y+dy-1][x+dx-1] = Yacid_splash_wB;
 805             play_sound(x, y, SAMPLE_acid);
 806             goto balloon_walk;
 807
 808           case Xblank:
 809           case Yacid_splash_eB:
 810           case Yacid_splash_wB:
 811             Cave[y+dy][x+dx] = (dy ? (dy < 0 ? Yballoon_n : Yballoon_s) :
 812                                 (dx > 0 ? Yballoon_e : Yballoon_w));
 813             Next[y+dy][x+dx] = Xballoon;
 814
 815           balloon_walk:
 816             Cave[y][x] = (dy ? (dy < 0 ? Yballoon_nB : Yballoon_sB) :
 817                           (dx > 0 ? Yballoon_eB : Yballoon_wB));
 818             Next[y][x] = Zplayer;
 819             play_element_sound(x, y, SAMPLE_push, Xballoon);
 820             ply->x = x;
 821             ply->y = y;
 822         }
 823
 824         ply->anim = SPR_push + anim;
 825         break;
 826
 827       case Xandroid:
 828       case Xandroid_1_n:
 829       case Xandroid_2_n:
 830       case Xandroid_1_e:
 831       case Xandroid_2_e:
 832       case Xandroid_1_s:
 833       case Xandroid_2_s:
 834       case Xandroid_1_w:
 835       case Xandroid_2_w:
 836         switch(Cave[y+dy][x+dx])
 837         {
 838           case Xacid_1:
 839           case Xacid_2:
 840           case Xacid_3:
 841           case Xacid_4:
 842           case Xacid_5:
 843           case Xacid_6:
 844           case Xacid_7:
 845           case Xacid_8:
 846             if (Cave[y+dy-1][x+dx+1] == Xblank)
 847               Cave[y+dy-1][x+dx+1] = Yacid_splash_eB;
 848             if (Cave[y+dy-1][x+dx-1] == Xblank)
 849               Cave[y+dy-1][x+dx-1] = Yacid_splash_wB;
 850             play_sound(x, y, SAMPLE_acid);
 851             goto android_walk;
 852
 853           case Xblank:
 854           case Yacid_splash_eB:
 855           case Yacid_splash_wB:
 856             Cave[y+dy][x+dx] = (dy ? (dy < 0 ? Yandroid_n : Yandroid_s) :
 857                                 (dx > 0 ? Yandroid_e : Yandroid_w));
 858             Next[y+dy][x+dx] = (dy ? (dy < 0 ? Xandroid_2_n : Xandroid_2_s) :
 859                                 (dx > 0 ? Xandroid_2_e : Xandroid_2_w));
 860
 861           android_walk:
 862             Cave[y][x] = (dy ? (dy < 0 ? Yandroid_nB : Yandroid_sB) :
 863                           (dx > 0 ? Yandroid_eB : Yandroid_wB));
 864             Next[y][x] = Zplayer;
 865             play_element_sound(x, y, SAMPLE_push, Xandroid);
 866             ply->x = x;
 867             ply->y = y;
 868         }
 869
 870         ply->anim = SPR_push + anim;
 871         break;
 872
 873       case Xdoor_1:
 874       case Xfake_door_1:
 875         if (ply->keys & 0x01)
 876           goto door_walk;
 877         else
 878           break;
 879
 880       case Xdoor_2:
 881       case Xfake_door_2:
 882         if (ply->keys & 0x02)
 883           goto door_walk;
 884         else
 885           break;
 886
 887       case Xdoor_3:
 888       case Xfake_door_3:
 889         if (ply->keys & 0x04)
 890           goto door_walk;
 891         else
 892           break;
 893
 894       case Xdoor_4:
 895       case Xfake_door_4:
 896         if (ply->keys & 0x08)
 897           goto door_walk;
 898         else
 899           break;
 900
 901       case Xdoor_5:
 902       case Xfake_door_5:
 903         if (ply->keys & 0x10)
 904           goto door_walk;
 905         else
 906           break;
 907
 908       case Xdoor_6:
 909       case Xfake_door_6:
 910         if (ply->keys & 0x20)
 911           goto door_walk;
 912         else
 913           break;
 914
 915       case Xdoor_7:
 916       case Xfake_door_7:
 917         if (ply->keys & 0x40)
 918           goto door_walk;
 919         else
 920           break;
 921
 922       case Xdoor_8:
 923       case Xfake_door_8:
 924         if (ply->keys & 0x80)
 925           goto door_walk;
 926         else
 927           break;
 928
 929       door_walk:
 930         if (!tab_blank[Cave[y+dy][x+dx]])
 931           break;
 932
 933         Cave[y+dy][x+dx] = Zplayer;
 934         Next[y+dy][x+dx] = Zplayer;
 935         play_element_sound(x, y, SAMPLE_door, element);
 936         ply->anim = SPR_walk + anim;
 937         ply->x = x + dx;
 938         ply->y = y + dy;
 939         break;
 940
 941       case Xwheel:
 942         play_element_sound(x, y, SAMPLE_press, element);
 943         lev.wheel_cnt = lev.wheel_time;
 944         lev.wheel_x = x;
 945         lev.wheel_y = y;
 946         break;
 947
 948       case Xwind_n:
 949         lev.wind_direction = 0;
 950         goto wind_walk;
 951
 952       case Xwind_e:
 953         lev.wind_direction = 1;
 954         goto wind_walk;
 955
 956       case Xwind_s:
 957         lev.wind_direction = 2;
 958         goto wind_walk;
 959
 960       case Xwind_w:
 961         lev.wind_direction = 3;
 962         goto wind_walk;
 963
 964       case Xwind_nesw:
 965         lev.wind_direction = dy ? (dy < 0 ? 0 : 2) : (dx > 0 ? 1 : 3);
 966         goto wind_walk;
 967
 968       wind_walk:
 969         play_element_sound(x, y, SAMPLE_press, element);
 970         lev.wind_cnt = lev.wind_time;
 971         break;
 972
 973       case Xwind_stop:
 974         play_element_sound(x, y, SAMPLE_press, element);
 975         lev.wind_cnt = 0;
 976         break;
 977
 978       case Xswitch:
 979         play_element_sound(x, y, SAMPLE_press, element);
 980         lev.ball_cnt = lev.ball_time;
 981         lev.ball_state = !lev.ball_state;
 982         break;
 983
 984       case Xplant:
 985         Cave[y][x] = Yplant;
 986         Next[y][x] = Xplant;
 987         play_element_sound(x, y, SAMPLE_blank, Xplant);
 988         ply->anim = SPR_walk + anim;
 989         ply->x = x;
 990         ply->y = y;
 991         break;
 992
 993       case Xexit_1:
 994       case Xexit_2:
 995       case Xexit_3:
 996         play_element_sound(x, y, SAMPLE_exit, Xexit_1);
 997
 998         if (--lev.home == 0 && lev.time_initial > 0)    /* game won */
 999           lev.score += lev.time * lev.exit_score / 100;
1000
1001         ply->anim = SPR_walk + anim;
1002         ply->x = x;
1003         ply->y = y;
1004
1005         break;
1006     }
1007   }
1008   else
1009   {
1010     int element = Cave[y][x];
1011
1012     switch(Cave[y][x])
1013     {
1014       /* fire is pressed */
1015
1016       case Xgrass:
1017         Cave[y][x] = Ygrass_eat;
1018         Next[y][x] = Xblank;
1019         play_element_sound(x, y, SAMPLE_dirt, element);
1020         ply->anim = SPR_spray + anim;
1021         break;
1022
1023       case Xdirt:
1024         Cave[y][x] = Ydirt_eat;
1025         Next[y][x] = Xblank;
1026         play_element_sound(x, y, SAMPLE_dirt, element);
1027         ply->anim = SPR_spray + anim;
1028         break;
1029
1030       case Xdiamond:
1031       case Xdiamond_pause:
1032         Cave[y][x] = Ydiamond_eat;
1033         Next[y][x] = Xblank;
1034         play_element_sound(x, y, SAMPLE_collect, element);
1035         lev.score += lev.diamond_score;
1036         lev.required = lev.required < 3 ? 0 : lev.required - 3;
1037         ply->anim = SPR_walk + anim;
1038         break;
1039
1040       case Xemerald:
1041       case Xemerald_pause:
1042         Cave[y][x] = Yemerald_eat;
1043         Next[y][x] = Xblank;
1044         play_element_sound(x, y, SAMPLE_collect, element);
1045         lev.score += lev.emerald_score;
1046         lev.required = lev.required < 1 ? 0 : lev.required - 1;
1047         ply->anim = SPR_walk + anim;
1048         break;
1049
1050       case Xdynamite:
1051         Cave[y][x] = Ydynamite_eat;
1052         Next[y][x] = Xblank;
1053         play_element_sound(x, y, SAMPLE_collect, element);
1054         lev.score += lev.dynamite_score;
1055         ply->dynamite = ply->dynamite > 9998 ? 9999 : ply->dynamite + 1;
1056         ply->anim = SPR_walk + anim;
1057         break;
1058
1059       case Xkey_1:
1060         ply->keys |= 0x01;
1061         Cave[y][x] = Ykey_1_eat;
1062         goto key_shoot;
1063
1064       case Xkey_2:
1065         ply->keys |= 0x02;
1066         Cave[y][x] = Ykey_2_eat;
1067         goto key_shoot;
1068
1069       case Xkey_3:
1070         ply->keys |= 0x04;
1071         Cave[y][x] = Ykey_3_eat;
1072         goto key_shoot;
1073
1074       case Xkey_4:
1075         ply->keys |= 0x08;
1076         Cave[y][x] = Ykey_4_eat;
1077         goto key_shoot;
1078
1079       case Xkey_5:
1080         ply->keys |= 0x10;
1081         Cave[y][x] = Ykey_5_eat;
1082         goto key_shoot;
1083
1084       case Xkey_6:
1085         ply->keys |= 0x20;
1086         Cave[y][x] = Ykey_6_eat;
1087         goto key_shoot;
1088
1089       case Xkey_7:
1090         ply->keys |= 0x40;
1091         Cave[y][x] = Ykey_7_eat;
1092         goto key_shoot;
1093
1094       case Xkey_8:
1095         ply->keys |= 0x80;
1096         Cave[y][x] = Ykey_8_eat;
1097         goto key_shoot;
1098
1099       key_shoot:
1100         Next[y][x] = Xblank;
1101         play_element_sound(x, y, SAMPLE_collect, element);
1102         lev.score += lev.key_score;
1103         ply->anim = SPR_walk + anim;
1104         break;
1105
1106       case Xlenses:
1107         Cave[y][x] = Ylenses_eat;
1108         Next[y][x] = Xblank;
1109         play_element_sound(x, y, SAMPLE_collect, element);
1110         lev.score += lev.lenses_score;
1111         lev.lenses_cnt = lev.lenses_time;
1112         ply->anim = SPR_walk + anim;
1113         break;
1114
1115       case Xmagnify:
1116         Cave[y][x] = Ymagnify_eat;
1117         Next[y][x] = Xblank;
1118         play_element_sound(x, y, SAMPLE_collect, element);
1119         lev.score += lev.magnify_score;
1120         lev.magnify_cnt = lev.magnify_time;
1121         ply->anim = SPR_walk + anim;
1122         break;
1123     }
1124   }
1125 }