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