hunt/huntd/shots.c

   1 /*      $NetBSD: shots.c,v 1.16 2021/05/02 12:50:45 rillig Exp $        */
   2 /*
   3  * Copyright (c) 1983-2003, Regents of the University of California.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met:
   9  *
  10  * + Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  * + Redistributions in binary form must reproduce the above copyright
  13  *   notice, this list of conditions and the following disclaimer in the
  14  *   documentation and/or other materials provided with the distribution.
  15  * + Neither the name of the University of California, San Francisco nor
  16  *   the names of its contributors may be used to endorse or promote
  17  *   products derived from this software without specific prior written
  18  *   permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  21  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  23  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 #ifndef lint
  35 __RCSID("$NetBSD: shots.c,v 1.16 2021/05/02 12:50:45 rillig Exp $");
  36 #endif /* not lint */
  37
  38 #include <err.h>
  39 #include <signal.h>
  40 #include <stdlib.h>
  41 #include "hunt.h"
  42
  43 #define PLUS_DELTA(x, max)      if (x < max) x++; else x--
  44 #define MINUS_DELTA(x, min)     if (x > min) x--; else x++
  45
  46 static void chkshot(BULLET *, BULLET *);
  47 static void chkslime(BULLET *, BULLET *);
  48 static void explshot(BULLET *, int, int);
  49 static void find_under(BULLET *, BULLET *);
  50 static bool iswall(int, int);
  51 static void mark_boot(BULLET *);
  52 static void mark_player(BULLET *);
  53 #ifdef DRONE
  54 static void move_drone(BULLET *);
  55 #endif
  56 static void move_flyer(PLAYER *);
  57 static int move_normal_shot(BULLET *);
  58 static void move_slime(BULLET *, int, BULLET *);
  59 static void save_bullet(BULLET *);
  60 static void zapshot(BULLET *, BULLET *);
  61
  62 /*
  63  * moveshots:
  64  *      Move the shots already in the air, taking explosions into account
  65  */
  66 void
  67 moveshots(void)
  68 {
  69         BULLET *bp, *next;
  70         PLAYER *pp;
  71         int x, y;
  72         BULLET *blist;
  73
  74         rollexpl();
  75         if (Bullets == NULL)
  76                 goto ret;
  77
  78         /*
  79          * First we move through the bullet list BULSPD times, looking
  80          * for things we may have run into.  If we do run into
  81          * something, we set up the explosion and disappear, checking
  82          * for damage to any player who got in the way.
  83          */
  84
  85         blist = Bullets;
  86         Bullets = NULL;
  87         for (bp = blist; bp != NULL; bp = next) {
  88                 next = bp->b_next;
  89                 x = bp->b_x;
  90                 y = bp->b_y;
  91                 Maze[y][x] = bp->b_over;
  92                 for (pp = Player; pp < End_player; pp++)
  93                         check(pp, y, x);
  94 #ifdef MONITOR
  95                 for (pp = Monitor; pp < End_monitor; pp++)
  96                         check(pp, y, x);
  97 #endif
  98
  99                 switch (bp->b_type) {
 100                   case SHOT:
 101                   case GRENADE:
 102                   case SATCHEL:
 103                   case BOMB:
 104                         if (move_normal_shot(bp)) {
 105                                 bp->b_next = Bullets;
 106                                 Bullets = bp;
 107                         }
 108                         break;
 109 #ifdef OOZE
 110                   case SLIME:
 111                         if (bp->b_expl || move_normal_shot(bp)) {
 112                                 bp->b_next = Bullets;
 113                                 Bullets = bp;
 114                         }
 115                         break;
 116 #endif
 117 #ifdef DRONE
 118                   case DSHOT:
 119                         if (move_drone(bp)) {
 120                                 bp->b_next = Bullets;
 121                                 Bullets = bp;
 122                         }
 123                         break;
 124 #endif
 125                   default:
 126                         bp->b_next = Bullets;
 127                         Bullets = bp;
 128                         break;
 129                 }
 130         }
 131
 132         blist = Bullets;
 133         Bullets = NULL;
 134         for (bp = blist; bp != NULL; bp = next) {
 135                 next = bp->b_next;
 136                 if (!bp->b_expl) {
 137                         save_bullet(bp);
 138 #ifdef MONITOR
 139                         for (pp = Monitor; pp < End_monitor; pp++)
 140                                 check(pp, bp->b_y, bp->b_x);
 141 #endif
 142 #ifdef DRONE
 143                         if (bp->b_type == DSHOT)
 144                                 for (pp = Player; pp < End_player; pp++)
 145                                         if (pp->p_scan >= 0)
 146                                                 check(pp, bp->b_y, bp->b_x);
 147 #endif
 148                         continue;
 149                 }
 150
 151                 chkshot(bp, next);
 152                 free(bp);
 153         }
 154
 155         for (pp = Player; pp < End_player; pp++)
 156                 Maze[pp->p_y][pp->p_x] = pp->p_face;
 157
 158 ret:
 159 #ifdef BOOTS
 160         for (pp = Boot; pp < &Boot[NBOOTS]; pp++)
 161                 if (pp->p_flying >= 0)
 162                         move_flyer(pp);
 163 #endif
 164         for (pp = Player; pp < End_player; pp++) {
 165 #ifdef FLY
 166                 if (pp->p_flying >= 0)
 167                         move_flyer(pp);
 168 #endif
 169                 sendcom(pp, REFRESH);   /* Flush out the explosions */
 170                 look(pp);
 171                 sendcom(pp, REFRESH);
 172         }
 173 #ifdef MONITOR
 174         for (pp = Monitor; pp < End_monitor; pp++)
 175                 sendcom(pp, REFRESH);
 176 #endif
 177
 178         return;
 179 }
 180
 181 /*
 182  * move_normal_shot:
 183  *      Move a normal shot along its trajectory
 184  */
 185 static int
 186 move_normal_shot(BULLET *bp)
 187 {
 188         int i, x, y;
 189         PLAYER *pp;
 190
 191         for (i = 0; i < BULSPD; i++) {
 192                 if (bp->b_expl)
 193                         break;
 194
 195                 x = bp->b_x;
 196                 y = bp->b_y;
 197
 198                 switch (bp->b_face) {
 199                   case LEFTS:
 200                         x--;
 201                         break;
 202                   case RIGHT:
 203                         x++;
 204                         break;
 205                   case ABOVE:
 206                         y--;
 207                         break;
 208                   case BELOW:
 209                         y++;
 210                         break;
 211                 }
 212
 213                 switch (Maze[y][x]) {
 214                   case SHOT:
 215                         if (rand_num(100) < 5) {
 216                                 zapshot(Bullets, bp);
 217                                 zapshot(bp->b_next, bp);
 218                         }
 219                         break;
 220                   case GRENADE:
 221                         if (rand_num(100) < 10) {
 222                                 zapshot(Bullets, bp);
 223                                 zapshot(bp->b_next, bp);
 224                         }
 225                         break;
 226 #ifdef REFLECT
 227                   case WALL4:   /* reflecting walls */
 228                         switch (bp->b_face) {
 229                           case LEFTS:
 230                                 bp->b_face = BELOW;
 231                                 break;
 232                           case RIGHT:
 233                                 bp->b_face = ABOVE;
 234                                 break;
 235                           case ABOVE:
 236                                 bp->b_face = RIGHT;
 237                                 break;
 238                           case BELOW:
 239                                 bp->b_face = LEFTS;
 240                                 break;
 241                         }
 242                         Maze[y][x] = WALL5;
 243 #ifdef MONITOR
 244                         for (pp = Monitor; pp < End_monitor; pp++)
 245                                 check(pp, y, x);
 246 #endif
 247                         break;
 248                   case WALL5:
 249                         switch (bp->b_face) {
 250                           case LEFTS:
 251                                 bp->b_face = ABOVE;
 252                                 break;
 253                           case RIGHT:
 254                                 bp->b_face = BELOW;
 255                                 break;
 256                           case ABOVE:
 257                                 bp->b_face = LEFTS;
 258                                 break;
 259                           case BELOW:
 260                                 bp->b_face = RIGHT;
 261                                 break;
 262                         }
 263                         Maze[y][x] = WALL4;
 264 #ifdef MONITOR
 265                         for (pp = Monitor; pp < End_monitor; pp++)
 266                                 check(pp, y, x);
 267 #endif
 268                         break;
 269 #endif
 270 #ifdef RANDOM
 271                   case DOOR:
 272                         switch (rand_num(4)) {
 273                           case 0:
 274                                 bp->b_face = ABOVE;
 275                                 break;
 276                           case 1:
 277                                 bp->b_face = BELOW;
 278                                 break;
 279                           case 2:
 280                                 bp->b_face = LEFTS;
 281                                 break;
 282                           case 3:
 283                                 bp->b_face = RIGHT;
 284                                 break;
 285                         }
 286                         break;
 287 #endif
 288 #ifdef FLY
 289                   case FLYER:
 290                         pp = play_at(y, x);
 291                         message(pp, "Zing!");
 292                         break;
 293 #endif
 294                   case LEFTS:
 295                   case RIGHT:
 296                   case BELOW:
 297                   case ABOVE:
 298                         /*
 299                          * give the person a chance to catch a
 300                          * grenade if s/he is facing it
 301                          */
 302                         pp = play_at(y, x);
 303                         pp->p_ident->i_shot += bp->b_charge;
 304                         if (opposite(bp->b_face, Maze[y][x])) {
 305                             if (rand_num(100) < 10) {
 306                                 if (bp->b_owner != NULL)
 307                                         message(bp->b_owner,
 308                                             "Your charge was absorbed!");
 309                                 if (bp->b_score != NULL)
 310                                         bp->b_score->i_robbed += bp->b_charge;
 311                                 pp->p_ammo += bp->b_charge;
 312                                 if (pp->p_damage + bp->b_size * MINDAM
 313                                     > pp->p_damcap)
 314                                         pp->p_ident->i_saved++;
 315                                 message(pp, "Absorbed charge (good shield!)");
 316                                 pp->p_ident->i_absorbed += bp->b_charge;
 317                                 free(bp);
 318                                 (void) snprintf(Buf, sizeof(Buf),
 319                                                 "%3d", pp->p_ammo);
 320                                 cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL);
 321                                 outstr(pp, Buf, 3);
 322                                 return false;
 323                             }
 324                             pp->p_ident->i_faced += bp->b_charge;
 325                         }
 326                         /*
 327                          * Small chance that the bullet just misses the
 328                          * person.  If so, the bullet just goes on its
 329                          * merry way without exploding.
 330                          */
 331                         if (rand_num(100) < 5) {
 332                                 pp->p_ident->i_ducked += bp->b_charge;
 333                                 if (pp->p_damage + bp->b_size * MINDAM
 334                                     > pp->p_damcap)
 335                                         pp->p_ident->i_saved++;
 336                                 if (bp->b_score != NULL)
 337                                         bp->b_score->i_missed += bp->b_charge;
 338                                 message(pp, "Zing!");
 339                                 if (bp->b_owner == NULL)
 340                                         break;
 341                                 message(bp->b_owner, bp->b_score &&
 342                                         ((bp->b_score->i_missed & 0x7) == 0x7) ?
 343                                         "My!  What a bad shot you are!" :
 344                                         "Missed him");
 345                                 break;
 346                         }
 347                         /*
 348                          * The shot hit that sucker!  Blow it up.
 349                          */
 350 #ifndef RANDOM
 351                         /* FALLTHROUGH */
 352                   case DOOR:
 353 #endif
 354                         /* FALLTHROUGH */
 355                   case WALL1:
 356                   case WALL2:
 357                   case WALL3:
 358                         bp->b_expl = true;
 359                         break;
 360                 }
 361
 362                 bp->b_x = x;
 363                 bp->b_y = y;
 364         }
 365         return true;
 366 }
 367
 368 #ifdef DRONE
 369 /*
 370  * move_drone:
 371  *      Move the drone to the next square
 372  */
 373 static void
 374 move_drone(BULLET *bp)
 375 {
 376         int mask, count;
 377         int n, dir;
 378         PLAYER *pp;
 379
 380         /*
 381          * See if we can give someone a blast
 382          */
 383         if (isplayer(Maze[bp->b_y][bp->b_x - 1])) {
 384                 dir = WEST;
 385                 goto drone_move;
 386         }
 387         if (isplayer(Maze[bp->b_y - 1][bp->b_x])) {
 388                 dir = NORTH;
 389                 goto drone_move;
 390         }
 391         if (isplayer(Maze[bp->b_y + 1][bp->b_x])) {
 392                 dir = SOUTH;
 393                 goto drone_move;
 394         }
 395         if (isplayer(Maze[bp->b_y][bp->b_x + 1])) {
 396                 dir = EAST;
 397                 goto drone_move;
 398         }
 399
 400         /*
 401          * Find out what directions are clear
 402          */
 403         mask = count = 0;
 404         if (!iswall(bp->b_y, bp->b_x - 1))
 405                 mask |= WEST, count++;
 406         if (!iswall(bp->b_y - 1, bp->b_x))
 407                 mask |= NORTH, count++;
 408         if (!iswall(bp->b_y + 1, bp->b_x))
 409                 mask |= SOUTH, count++;
 410         if (!iswall(bp->b_y, bp->b_x + 1))
 411                 mask |= EAST, count++;
 412
 413         /*
 414          * All blocked up, just you wait
 415          */
 416         if (count == 0)
 417                 return true;
 418
 419         /*
 420          * Only one way to go.
 421          */
 422         if (count == 1) {
 423                 dir = mask;
 424                 goto drone_move;
 425         }
 426
 427         /*
 428          * Get rid of the direction that we came from
 429          */
 430         switch (bp->b_face) {
 431           case LEFTS:
 432                 if (mask & EAST)
 433                         mask &= ~EAST, count--;
 434                 break;
 435           case RIGHT:
 436                 if (mask & WEST)
 437                         mask &= ~WEST, count--;
 438                 break;
 439           case ABOVE:
 440                 if (mask & SOUTH)
 441                         mask &= ~SOUTH, count--;
 442                 break;
 443           case BELOW:
 444                 if (mask & NORTH)
 445                         mask &= ~NORTH, count--;
 446                 break;
 447         }
 448
 449         /*
 450          * Pick one of the remaining directions
 451          */
 452         n = rand_num(count);
 453         if (n >= 0 && mask & NORTH)
 454                 dir = NORTH, n--;
 455         if (n >= 0 && mask & SOUTH)
 456                 dir = SOUTH, n--;
 457         if (n >= 0 && mask & EAST)
 458                 dir = EAST, n--;
 459         if (n >= 0 && mask & WEST)
 460                 dir = WEST, n--;
 461
 462         /*
 463          * Now that we know the direction of movement,
 464          * just update the position of the drone
 465          */
 466 drone_move:
 467         switch (dir) {
 468           case WEST:
 469                 bp->b_x--;
 470                 bp->b_face = LEFTS;
 471                 break;
 472           case EAST:
 473                 bp->b_x++;
 474                 bp->b_face = RIGHT;
 475                 break;
 476           case NORTH:
 477                 bp->b_y--;
 478                 bp->b_face = ABOVE;
 479                 break;
 480           case SOUTH:
 481                 bp->b_y++;
 482                 bp->b_face = BELOW;
 483                 break;
 484         }
 485         switch (Maze[bp->b_y][bp->b_x]) {
 486           case LEFTS:
 487           case RIGHT:
 488           case BELOW:
 489           case ABOVE:
 490                 /*
 491                  * give the person a chance to catch a
 492                  * drone if s/he is facing it
 493                  */
 494                 if (rand_num(100) < 1 &&
 495                 opposite(bp->b_face, Maze[bp->b_y][bp->b_x])) {
 496                         pp = play_at(bp->b_y, bp->b_x);
 497                         pp->p_ammo += bp->b_charge;
 498                         message(pp, "**** Absorbed drone ****");
 499                         free(bp);
 500                         (void) snprintf(Buf, sizeof(buf), "%3d", pp->p_ammo);
 501                         cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL);
 502                         outstr(pp, Buf, 3);
 503                         return false;
 504                 }
 505                 bp->b_expl = true;
 506                 break;
 507         }
 508         return true;
 509 }
 510 #endif
 511
 512 /*
 513  * save_bullet:
 514  *      Put this bullet back onto the bullet list
 515  */
 516 static void
 517 save_bullet(BULLET *bp)
 518 {
 519         bp->b_over = Maze[bp->b_y][bp->b_x];
 520         switch (bp->b_over) {
 521           case SHOT:
 522           case GRENADE:
 523           case SATCHEL:
 524           case BOMB:
 525 #ifdef OOZE
 526           case SLIME:
 527 #ifdef VOLCANO
 528           case LAVA:
 529 #endif
 530 #endif
 531 #ifdef DRONE
 532           case DSHOT:
 533 #endif
 534                 find_under(Bullets, bp);
 535                 break;
 536         }
 537
 538         switch (bp->b_over) {
 539           case LEFTS:
 540           case RIGHT:
 541           case ABOVE:
 542           case BELOW:
 543 #ifdef FLY
 544           case FLYER:
 545 #endif
 546                 mark_player(bp);
 547                 break;
 548 #ifdef BOOTS
 549           case BOOT:
 550           case BOOT_PAIR:
 551                 mark_boot(bp);
 552                 break;
 553 #endif
 554
 555           default:
 556                 Maze[bp->b_y][bp->b_x] = bp->b_type;
 557                 break;
 558         }
 559
 560         bp->b_next = Bullets;
 561         Bullets = bp;
 562 }
 563
 564 /*
 565  * move_flyer:
 566  *      Update the position of a player in flight
 567  */
 568 static void
 569 move_flyer(PLAYER *pp)
 570 {
 571         int x, y;
 572
 573         if (pp->p_undershot) {
 574                 fixshots(pp->p_y, pp->p_x, pp->p_over);
 575                 pp->p_undershot = false;
 576         }
 577         Maze[pp->p_y][pp->p_x] = pp->p_over;
 578         x = pp->p_x + pp->p_flyx;
 579         y = pp->p_y + pp->p_flyy;
 580         if (x < 1) {
 581                 x = 1 - x;
 582                 pp->p_flyx = -pp->p_flyx;
 583         }
 584         else if (x > WIDTH - 2) {
 585                 x = (WIDTH - 2) - (x - (WIDTH - 2));
 586                 pp->p_flyx = -pp->p_flyx;
 587         }
 588         if (y < 1) {
 589                 y = 1 - y;
 590                 pp->p_flyy = -pp->p_flyy;
 591         }
 592         else if (y > HEIGHT - 2) {
 593                 y = (HEIGHT - 2) - (y - (HEIGHT - 2));
 594                 pp->p_flyy = -pp->p_flyy;
 595         }
 596 again:
 597         switch (Maze[y][x]) {
 598           default:
 599                 switch (rand_num(4)) {
 600                   case 0:
 601                         PLUS_DELTA(x, WIDTH - 2);
 602                         break;
 603                   case 1:
 604                         MINUS_DELTA(x, 1);
 605                         break;
 606                   case 2:
 607                         PLUS_DELTA(y, HEIGHT - 2);
 608                         break;
 609                   case 3:
 610                         MINUS_DELTA(y, 1);
 611                         break;
 612                 }
 613                 goto again;
 614           case WALL1:
 615           case WALL2:
 616           case WALL3:
 617 #ifdef REFLECT
 618           case WALL4:
 619           case WALL5:
 620 #endif
 621 #ifdef RANDOM
 622           case DOOR:
 623 #endif
 624                 if (pp->p_flying == 0)
 625                         pp->p_flying++;
 626                 break;
 627           case SPACE:
 628                 break;
 629         }
 630         pp->p_y = y;
 631         pp->p_x = x;
 632         if (pp->p_flying-- == 0) {
 633 #ifdef BOOTS
 634                 if (pp->p_face != BOOT && pp->p_face != BOOT_PAIR) {
 635 #endif
 636                         checkdam(pp, NULL, NULL,
 637                                 rand_num(pp->p_damage / 5), FALL);
 638                         pp->p_face = rand_dir();
 639                         showstat(pp);
 640 #ifdef BOOTS
 641                 }
 642                 else {
 643                         if (Maze[y][x] == BOOT)
 644                                 pp->p_face = BOOT_PAIR;
 645                         Maze[y][x] = SPACE;
 646                 }
 647 #endif
 648         }
 649         pp->p_over = Maze[y][x];
 650         Maze[y][x] = pp->p_face;
 651         showexpl(y, x, pp->p_face);
 652 }
 653
 654 /*
 655  * chkshot
 656  *      Handle explosions
 657  */
 658 static void
 659 chkshot(BULLET *bp, BULLET *next)
 660 {
 661         int y, x;
 662         int dy, dx, absdy;
 663         int delta, damage;
 664         char expl;
 665         PLAYER *pp;
 666
 667         delta = 0;
 668         switch (bp->b_type) {
 669           case SHOT:
 670           case MINE:
 671           case GRENADE:
 672           case GMINE:
 673           case SATCHEL:
 674           case BOMB:
 675                 delta = bp->b_size - 1;
 676                 break;
 677 #ifdef OOZE
 678           case SLIME:
 679 #ifdef VOLCANO
 680           case LAVA:
 681 #endif
 682                 chkslime(bp, next);
 683                 return;
 684 #endif
 685 #ifdef DRONE
 686           case DSHOT:
 687                 bp->b_type = SLIME;
 688                 chkslime(bp, next);
 689                 return;
 690 #endif
 691         }
 692         for (y = bp->b_y - delta; y <= bp->b_y + delta; y++) {
 693                 if (y < 0 || y >= HEIGHT)
 694                         continue;
 695                 dy = y - bp->b_y;
 696                 absdy = (dy < 0) ? -dy : dy;
 697                 for (x = bp->b_x - delta; x <= bp->b_x + delta; x++) {
 698                         if (x < 0 || x >= WIDTH)
 699                                 continue;
 700                         dx = x - bp->b_x;
 701                         if (dx == 0)
 702                                 expl = (dy == 0) ? '*' : '|';
 703                         else if (dy == 0)
 704                                 expl = '-';
 705                         else if (dx == dy)
 706                                 expl = '\\';
 707                         else if (dx == -dy)
 708                                 expl = '/';
 709                         else
 710                                 expl = '*';
 711                         showexpl(y, x, expl);
 712                         switch (Maze[y][x]) {
 713                           case LEFTS:
 714                           case RIGHT:
 715                           case ABOVE:
 716                           case BELOW:
 717 #ifdef FLY
 718                           case FLYER:
 719 #endif
 720                                 if (dx < 0)
 721                                         dx = -dx;
 722                                 if (absdy > dx)
 723                                         damage = bp->b_size - absdy;
 724                                 else
 725                                         damage = bp->b_size - dx;
 726                                 pp = play_at(y, x);
 727                                 checkdam(pp, bp->b_owner, bp->b_score,
 728                                         damage * MINDAM, bp->b_type);
 729                                 break;
 730                           case GMINE:
 731                           case MINE:
 732                                 add_shot((Maze[y][x] == GMINE) ?
 733                                         GRENADE : SHOT,
 734                                         y, x, LEFTS,
 735                                         (Maze[y][x] == GMINE) ?
 736                                         GRENREQ : BULREQ,
 737                                         NULL, true, SPACE);
 738                                 Maze[y][x] = SPACE;
 739                                 break;
 740                         }
 741                 }
 742         }
 743 }
 744
 745 #ifdef OOZE
 746 /*
 747  * chkslime:
 748  *      handle slime shot exploding
 749  */
 750 static void
 751 chkslime(BULLET *bp, BULLET *next)
 752 {
 753         BULLET  *nbp;
 754
 755         switch (Maze[bp->b_y][bp->b_x]) {
 756           case WALL1:
 757           case WALL2:
 758           case WALL3:
 759 #ifdef REFLECT
 760           case WALL4:
 761           case WALL5:
 762 #endif
 763 #ifdef RANDOM
 764           case DOOR:
 765 #endif
 766                 switch (bp->b_face) {
 767                   case LEFTS:
 768                         bp->b_x++;
 769                         break;
 770                   case RIGHT:
 771                         bp->b_x--;
 772                         break;
 773                   case ABOVE:
 774                         bp->b_y++;
 775                         break;
 776                   case BELOW:
 777                         bp->b_y--;
 778                         break;
 779                 }
 780                 break;
 781         }
 782         nbp = malloc(sizeof(*nbp));
 783         *nbp = *bp;
 784 #ifdef VOLCANO
 785         move_slime(nbp, nbp->b_type == SLIME ? SLIMESPEED : LAVASPEED, next);
 786 #else
 787         move_slime(nbp, SLIMESPEED, next);
 788 #endif
 789 }
 790
 791 /*
 792  * move_slime:
 793  *      move the given slime shot speed times and add it back if
 794  *      it hasn't fizzled yet
 795  */
 796 static void
 797 move_slime(BULLET *bp, int speed, BULLET *next)
 798 {
 799         int i, j, dirmask, count;
 800         PLAYER *pp;
 801         BULLET *nbp;
 802
 803         if (speed == 0) {
 804                 if (bp->b_charge <= 0)
 805                         free(bp);
 806                 else
 807                         save_bullet(bp);
 808                 return;
 809         }
 810
 811 #ifdef VOLCANO
 812         showexpl(bp->b_y, bp->b_x, bp->b_type == LAVA ? LAVA : '*');
 813 #else
 814         showexpl(bp->b_y, bp->b_x, '*');
 815 #endif
 816         switch (Maze[bp->b_y][bp->b_x]) {
 817           case LEFTS:
 818           case RIGHT:
 819           case ABOVE:
 820           case BELOW:
 821 #ifdef FLY
 822           case FLYER:
 823 #endif
 824                 pp = play_at(bp->b_y, bp->b_x);
 825                 message(pp, "You've been slimed.");
 826                 checkdam(pp, bp->b_owner, bp->b_score, MINDAM, bp->b_type);
 827                 break;
 828           case SHOT:
 829           case GRENADE:
 830           case SATCHEL:
 831           case BOMB:
 832 #ifdef DRONE
 833           case DSHOT:
 834 #endif
 835                 explshot(next, bp->b_y, bp->b_x);
 836                 explshot(Bullets, bp->b_y, bp->b_x);
 837                 break;
 838         }
 839
 840         if (--bp->b_charge <= 0) {
 841                 free(bp);
 842                 return;
 843         }
 844
 845         dirmask = 0;
 846         count = 0;
 847         switch (bp->b_face) {
 848           case LEFTS:
 849                 if (!iswall(bp->b_y, bp->b_x - 1))
 850                         dirmask |= WEST, count++;
 851                 if (!iswall(bp->b_y - 1, bp->b_x))
 852                         dirmask |= NORTH, count++;
 853                 if (!iswall(bp->b_y + 1, bp->b_x))
 854                         dirmask |= SOUTH, count++;
 855                 if (dirmask == 0)
 856                         if (!iswall(bp->b_y, bp->b_x + 1))
 857                                 dirmask |= EAST, count++;
 858                 break;
 859           case RIGHT:
 860                 if (!iswall(bp->b_y, bp->b_x + 1))
 861                         dirmask |= EAST, count++;
 862                 if (!iswall(bp->b_y - 1, bp->b_x))
 863                         dirmask |= NORTH, count++;
 864                 if (!iswall(bp->b_y + 1, bp->b_x))
 865                         dirmask |= SOUTH, count++;
 866                 if (dirmask == 0)
 867                         if (!iswall(bp->b_y, bp->b_x - 1))
 868                                 dirmask |= WEST, count++;
 869                 break;
 870           case ABOVE:
 871                 if (!iswall(bp->b_y - 1, bp->b_x))
 872                         dirmask |= NORTH, count++;
 873                 if (!iswall(bp->b_y, bp->b_x - 1))
 874                         dirmask |= WEST, count++;
 875                 if (!iswall(bp->b_y, bp->b_x + 1))
 876                         dirmask |= EAST, count++;
 877                 if (dirmask == 0)
 878                         if (!iswall(bp->b_y + 1, bp->b_x))
 879                                 dirmask |= SOUTH, count++;
 880                 break;
 881           case BELOW:
 882                 if (!iswall(bp->b_y + 1, bp->b_x))
 883                         dirmask |= SOUTH, count++;
 884                 if (!iswall(bp->b_y, bp->b_x - 1))
 885                         dirmask |= WEST, count++;
 886                 if (!iswall(bp->b_y, bp->b_x + 1))
 887                         dirmask |= EAST, count++;
 888                 if (dirmask == 0)
 889                         if (!iswall(bp->b_y - 1, bp->b_x))
 890                                 dirmask |= NORTH, count++;
 891                 break;
 892         }
 893         if (count == 0) {
 894                 /*
 895                  * No place to go.  Just sit here for a while and wait
 896                  * for adjacent squares to clear out.
 897                  */
 898                 save_bullet(bp);
 899                 return;
 900         }
 901         if (bp->b_charge < count) {
 902                 /* Only bp->b_charge paths may be taken */
 903                 while (count > bp->b_charge) {
 904                         if (dirmask & WEST)
 905                                 dirmask &= ~WEST;
 906                         else if (dirmask & EAST)
 907                                 dirmask &= ~EAST;
 908                         else if (dirmask & NORTH)
 909                                 dirmask &= ~NORTH;
 910                         else if (dirmask & SOUTH)
 911                                 dirmask &= ~SOUTH;
 912                         count--;
 913                 }
 914         }
 915
 916         i = bp->b_charge / count;
 917         j = bp->b_charge % count;
 918         if (dirmask & WEST) {
 919                 count--;
 920                 nbp = create_shot(bp->b_type, bp->b_y, bp->b_x - 1, LEFTS,
 921                         i, bp->b_size, bp->b_owner, bp->b_score, true, SPACE);
 922                 move_slime(nbp, speed - 1, next);
 923         }
 924         if (dirmask & EAST) {
 925                 count--;
 926                 nbp = create_shot(bp->b_type, bp->b_y, bp->b_x + 1, RIGHT,
 927                         (count < j) ? i + 1 : i, bp->b_size, bp->b_owner,
 928                         bp->b_score, true, SPACE);
 929                 move_slime(nbp, speed - 1, next);
 930         }
 931         if (dirmask & NORTH) {
 932                 count--;
 933                 nbp = create_shot(bp->b_type, bp->b_y - 1, bp->b_x, ABOVE,
 934                         (count < j) ? i + 1 : i, bp->b_size, bp->b_owner,
 935                         bp->b_score, true, SPACE);
 936                 move_slime(nbp, speed - 1, next);
 937         }
 938         if (dirmask & SOUTH) {
 939                 count--;
 940                 nbp = create_shot(bp->b_type, bp->b_y + 1, bp->b_x, BELOW,
 941                         (count < j) ? i + 1 : i, bp->b_size, bp->b_owner,
 942                         bp->b_score, true, SPACE);
 943                 move_slime(nbp, speed - 1, next);
 944         }
 945
 946         free(bp);
 947 }
 948
 949 /*
 950  * iswall:
 951  *      returns whether the given location is a wall
 952  */
 953 static bool
 954 iswall(int y, int x)
 955 {
 956         if (y < 0 || x < 0 || y >= HEIGHT || x >= WIDTH)
 957                 return true;
 958         switch (Maze[y][x]) {
 959           case WALL1:
 960           case WALL2:
 961           case WALL3:
 962 #ifdef REFLECT
 963           case WALL4:
 964           case WALL5:
 965 #endif
 966 #ifdef RANDOM
 967           case DOOR:
 968 #endif
 969 #ifdef OOZE
 970           case SLIME:
 971 #ifdef VOLCANO
 972           case LAVA:
 973 #endif
 974 #endif
 975                 return true;
 976         }
 977         return false;
 978 }
 979 #endif
 980
 981 /*
 982  * zapshot:
 983  *      Take a shot out of the air.
 984  */
 985 static void
 986 zapshot(BULLET *blist, BULLET *obp)
 987 {
 988         BULLET *bp;
 989         bool explode;
 990
 991         explode = false;
 992         for (bp = blist; bp != NULL; bp = bp->b_next) {
 993                 if (bp->b_x != obp->b_x || bp->b_y != obp->b_y)
 994                         continue;
 995                 if (bp->b_face == obp->b_face)
 996                         continue;
 997                 explode = true;
 998                 break;
 999         }
1000         if (!explode)
1001                 return;
1002         explshot(blist, obp->b_y, obp->b_x);
1003 }
1004
1005 /*
1006  * explshot -
1007  *      Make all shots at this location blow up
1008  */
1009 static void
1010 explshot(BULLET *blist, int y, int x)
1011 {
1012         BULLET *bp;
1013
1014         for (bp = blist; bp != NULL; bp = bp->b_next)
1015                 if (bp->b_x == x && bp->b_y == y) {
1016                         bp->b_expl = true;
1017                         if (bp->b_owner != NULL)
1018                                 message(bp->b_owner, "Shot intercepted");
1019                 }
1020 }
1021
1022 /*
1023  * play_at:
1024  *      Return a pointer to the player at the given location
1025  */
1026 PLAYER *
1027 play_at(int y, int x)
1028 {
1029         PLAYER *pp;
1030
1031         for (pp = Player; pp < End_player; pp++)
1032                 if (pp->p_x == x && pp->p_y == y)
1033                         return pp;
1034         errx(1, "driver: couldn't find player at (%d,%d)", x, y);
1035         /* NOTREACHED */
1036 }
1037
1038 /*
1039  * opposite:
1040  *      Return true if the bullet direction faces the opposite direction
1041  *      of the player in the maze
1042  */
1043 bool
1044 opposite(int face, char dir)
1045 {
1046         switch (face) {
1047           case LEFTS:
1048                 return (dir == RIGHT);
1049           case RIGHT:
1050                 return (dir == LEFTS);
1051           case ABOVE:
1052                 return (dir == BELOW);
1053           case BELOW:
1054                 return (dir == ABOVE);
1055           default:
1056                 return false;
1057         }
1058 }
1059
1060 /*
1061  * is_bullet:
1062  *      Is there a bullet at the given coordinates?  If so, return
1063  *      a pointer to the bullet, otherwise return NULL
1064  */
1065 BULLET *
1066 is_bullet(int y, int x)
1067 {
1068         BULLET *bp;
1069
1070         for (bp = Bullets; bp != NULL; bp = bp->b_next)
1071                 if (bp->b_y == y && bp->b_x == x)
1072                         return bp;
1073         return NULL;
1074 }
1075
1076 /*
1077  * fixshots:
1078  *      change the underlying character of the shots at a location
1079  *      to the given character.
1080  */
1081 void
1082 fixshots(int y, int x, char over)
1083 {
1084         BULLET *bp;
1085
1086         for (bp = Bullets; bp != NULL; bp = bp->b_next)
1087                 if (bp->b_y == y && bp->b_x == x)
1088                         bp->b_over = over;
1089 }
1090
1091 /*
1092  * find_under:
1093  *      find the underlying character for a bullet when it lands
1094  *      on another bullet.
1095  */
1096 static void
1097 find_under(BULLET *blist, BULLET *bp)
1098 {
1099         BULLET *nbp;
1100
1101         for (nbp = blist; nbp != NULL; nbp = nbp->b_next)
1102                 if (bp->b_y == nbp->b_y && bp->b_x == nbp->b_x) {
1103                         bp->b_over = nbp->b_over;
1104                         break;
1105                 }
1106 }
1107
1108 /*
1109  * mark_player:
1110  *      mark a player as under a shot
1111  */
1112 static void
1113 mark_player(BULLET *bp)
1114 {
1115         PLAYER *pp;
1116
1117         for (pp = Player; pp < End_player; pp++)
1118                 if (pp->p_y == bp->b_y && pp->p_x == bp->b_x) {
1119                         pp->p_undershot = true;
1120                         break;
1121                 }
1122 }
1123
1124 #ifdef BOOTS
1125 /*
1126  * mark_boot:
1127  *      mark a boot as under a shot
1128  */
1129 static void
1130 mark_boot(BULLET *bp)
1131 {
1132         PLAYER *pp;
1133
1134         for (pp = Boot; pp < &Boot[NBOOTS]; pp++)
1135                 if (pp->p_y == bp->b_y && pp->p_x == bp->b_x) {
1136                         pp->p_undershot = true;
1137                         break;
1138                 }
1139 }
1140 #endif