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