![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to shots.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / games / hunt|
Return to shots.c CVS log | Up to [CSRG BSD Unix] / 43BSD / games / hunt |
1.1 ! root 1: /* ! 2: * Hunt ! 3: * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold ! 4: * San Francisco, California ! 5: * ! 6: * Copyright (c) 1985 Regents of the University of California. ! 7: * All rights reserved. The Berkeley software License Agreement ! 8: * specifies the terms and conditions for redistribution. ! 9: */ ! 10: ! 11: # include "hunt.h" ! 12: # include <signal.h> ! 13: ! 14: # define PLUS_DELTA(x, max) if (x < max) x++; else x-- ! 15: # define MINUS_DELTA(x, min) if (x > min) x--; else x++ ! 16: ! 17: /* ! 18: * moveshots: ! 19: * Move the shots already in the air, taking explosions into account ! 20: */ ! 21: moveshots() ! 22: { ! 23: register BULLET *bp, *next; ! 24: register PLAYER *pp; ! 25: register int x, y; ! 26: register BULLET *blist; ! 27: register int i; ! 28: ! 29: rollexpl(); ! 30: if (Bullets == NULL) ! 31: goto ret; ! 32: ! 33: /* ! 34: * First we move through the bullet list BULSPD times, looking ! 35: * for things we may have run into. If we do run into ! 36: * something, we set up the explosion and disappear, checking ! 37: * for damage to any player who got in the way. ! 38: */ ! 39: ! 40: blist = Bullets; ! 41: Bullets = NULL; ! 42: for (bp = blist; bp != NULL; bp = next) { ! 43: next = bp->b_next; ! 44: x = bp->b_x; ! 45: y = bp->b_y; ! 46: Maze[y][x] = bp->b_over; ! 47: for (pp = Player; pp < End_player; pp++) ! 48: check(pp, y, x); ! 49: # ifdef MONITOR ! 50: for (pp = Monitor; pp < End_monitor; pp++) ! 51: check(pp, y, x); ! 52: # endif MONITOR ! 53: ! 54: for (i = 0; i < BULSPD; i++) { ! 55: if (bp->b_expl) ! 56: break; ! 57: ! 58: x = bp->b_x; ! 59: y = bp->b_y; ! 60: ! 61: switch (bp->b_face) { ! 62: case LEFTS: ! 63: x--; ! 64: break; ! 65: case RIGHT: ! 66: x++; ! 67: break; ! 68: case ABOVE: ! 69: y--; ! 70: break; ! 71: case BELOW: ! 72: y++; ! 73: break; ! 74: } ! 75: ! 76: switch (Maze[y][x]) { ! 77: case SHOT: ! 78: if (rand_num(100) < 5) { ! 79: zapshot(Bullets, bp); ! 80: zapshot(next, bp); ! 81: } ! 82: break; ! 83: case GRENADE: ! 84: if (rand_num(100) < 10) { ! 85: zapshot(Bullets, bp); ! 86: zapshot(next, bp); ! 87: } ! 88: break; ! 89: # ifdef REFLECT ! 90: case WALL4: /* reflecting walls */ ! 91: switch (bp->b_face) { ! 92: case LEFTS: ! 93: bp->b_face = BELOW; ! 94: break; ! 95: case RIGHT: ! 96: bp->b_face = ABOVE; ! 97: break; ! 98: case ABOVE: ! 99: bp->b_face = RIGHT; ! 100: break; ! 101: case BELOW: ! 102: bp->b_face = LEFTS; ! 103: break; ! 104: } ! 105: Maze[y][x] = WALL5; ! 106: # ifdef MONITOR ! 107: for (pp = Monitor; pp < End_monitor; pp++) ! 108: check(pp, y, x); ! 109: # endif MONITOR ! 110: break; ! 111: case WALL5: ! 112: switch (bp->b_face) { ! 113: case LEFTS: ! 114: bp->b_face = ABOVE; ! 115: break; ! 116: case RIGHT: ! 117: bp->b_face = BELOW; ! 118: break; ! 119: case ABOVE: ! 120: bp->b_face = LEFTS; ! 121: break; ! 122: case BELOW: ! 123: bp->b_face = RIGHT; ! 124: break; ! 125: } ! 126: Maze[y][x] = WALL4; ! 127: # ifdef MONITOR ! 128: for (pp = Monitor; pp < End_monitor; pp++) ! 129: check(pp, y, x); ! 130: # endif MONITOR ! 131: break; ! 132: # endif REFLECT ! 133: # ifdef RANDOM ! 134: case DOOR: ! 135: switch (rand_num(4)) { ! 136: case 0: ! 137: bp->b_face = ABOVE; ! 138: break; ! 139: case 1: ! 140: bp->b_face = BELOW; ! 141: break; ! 142: case 2: ! 143: bp->b_face = LEFTS; ! 144: break; ! 145: case 3: ! 146: bp->b_face = RIGHT; ! 147: break; ! 148: } ! 149: break; ! 150: # endif RANDOM ! 151: case LEFTS: ! 152: case RIGHT: ! 153: case BELOW: ! 154: case ABOVE: ! 155: # ifdef FLY ! 156: case FLYER: ! 157: # endif FLY ! 158: /* ! 159: * give the person a chance to catch a ! 160: * grenade if s/he is facing it ! 161: */ ! 162: if (rand_num(100) < 10 ! 163: && opposite(bp->b_face, Maze[y][x])) { ! 164: if (bp->b_owner != NULL) ! 165: message(bp->b_owner, ! 166: "Your charge was absorbed!"); ! 167: pp = play_at(y, x); ! 168: pp->p_ammo += bp->b_charge; ! 169: (void) sprintf(Buf, ! 170: "Absorbed charge (good shield!)"); ! 171: message(pp, Buf); ! 172: free((char *) bp); ! 173: (void) sprintf(Buf, "%3d", pp->p_ammo); ! 174: cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL); ! 175: outstr(pp, Buf, 3); ! 176: goto next_bullet; ! 177: } ! 178: /* FALLTHROUGH */ ! 179: # ifndef RANDOM ! 180: case DOOR: ! 181: # endif RANDOM ! 182: case WALL1: ! 183: case WALL2: ! 184: case WALL3: ! 185: bp->b_expl = TRUE; ! 186: break; ! 187: } ! 188: ! 189: bp->b_x = x; ! 190: bp->b_y = y; ! 191: } ! 192: ! 193: bp->b_next = Bullets; ! 194: Bullets = bp; ! 195: next_bullet: ! 196: ; ! 197: } ! 198: ! 199: blist = Bullets; ! 200: Bullets = NULL; ! 201: for (bp = blist; bp != NULL; bp = next) { ! 202: next = bp->b_next; ! 203: if (!bp->b_expl) { ! 204: save_bullet(bp); ! 205: # ifdef MONITOR ! 206: for (pp = Monitor; pp < End_monitor; pp++) ! 207: check(pp, bp->b_y, bp->b_x); ! 208: # endif MONITOR ! 209: continue; ! 210: } ! 211: ! 212: chkshot(bp); ! 213: free((char *) bp); ! 214: } ! 215: for (pp = Player; pp < End_player; pp++) ! 216: Maze[pp->p_y][pp->p_x] = pp->p_face; ! 217: ret: ! 218: for (pp = Player; pp < End_player; pp++) { ! 219: # ifdef FLY ! 220: if (pp->p_flying >= 0) { ! 221: Maze[pp->p_y][pp->p_x] = pp->p_over; ! 222: x = pp->p_x + pp->p_flyx; ! 223: y = pp->p_y + pp->p_flyy; ! 224: if (x < 1) { ! 225: x = 1 - x; ! 226: pp->p_flyx = -pp->p_flyx; ! 227: } ! 228: else if (x > WIDTH - 2) { ! 229: x = (WIDTH - 2) - (x - (WIDTH - 2)); ! 230: pp->p_flyx = -pp->p_flyx; ! 231: } ! 232: if (y < 1) { ! 233: y = 1 - y; ! 234: pp->p_flyy = -pp->p_flyy; ! 235: } ! 236: else if (y > HEIGHT - 2) { ! 237: y = (HEIGHT - 2) - (y - (HEIGHT - 2)); ! 238: pp->p_flyy = -pp->p_flyy; ! 239: } ! 240: again: switch (Maze[y][x]) { ! 241: case LEFTS: ! 242: case RIGHT: ! 243: case ABOVE: ! 244: case BELOW: ! 245: case FLYER: ! 246: switch (rand_num(4)) { ! 247: case 0: ! 248: PLUS_DELTA(x, WIDTH - 2); ! 249: break; ! 250: case 1: ! 251: MINUS_DELTA(x, 1); ! 252: break; ! 253: case 2: ! 254: PLUS_DELTA(y, HEIGHT - 2); ! 255: break; ! 256: case 3: ! 257: MINUS_DELTA(y, 1); ! 258: break; ! 259: } ! 260: goto again; ! 261: case WALL1: ! 262: case WALL2: ! 263: case WALL3: ! 264: # ifdef REFLECT ! 265: case WALL4: ! 266: case WALL5: ! 267: # endif REFLECT ! 268: # ifdef RANDOM ! 269: case DOOR: ! 270: # endif RANDOM ! 271: if (pp->p_flying == 0) ! 272: pp->p_flying++; ! 273: break; ! 274: case MINE: ! 275: checkdam(pp, NULL, NULL, MINDAM, MINE); ! 276: Maze[y][x] = SPACE; ! 277: break; ! 278: case GMINE: ! 279: checkdam(pp, NULL, NULL, MINDAM, GMINE); ! 280: checkdam(pp, NULL, NULL, MINDAM, GMINE); ! 281: Maze[y][x] = SPACE; ! 282: break; ! 283: } ! 284: pp->p_y = y; ! 285: pp->p_x = x; ! 286: pp->p_over = Maze[y][x]; ! 287: if (pp->p_flying-- == 0) { ! 288: checkdam(pp, NULL, NULL, ! 289: rand_num(pp->p_damage / 5), FALL); ! 290: rand_face(pp); ! 291: showstat(pp); ! 292: } ! 293: Maze[y][x] = pp->p_face; ! 294: showexpl(y, x, pp->p_face); ! 295: } ! 296: # endif FLY ! 297: sendcom(pp, REFRESH); /* Flush out the explosions */ ! 298: look(pp); ! 299: sendcom(pp, REFRESH); ! 300: } ! 301: # ifdef MONITOR ! 302: for (pp = Monitor; pp < End_monitor; pp++) ! 303: sendcom(pp, REFRESH); ! 304: # endif MONITOR ! 305: ! 306: # ifdef CONSTANT_MOVE ! 307: if (Bullets != NULL) { ! 308: bul_alarm(1); ! 309: return; ! 310: } ! 311: for (i = 0; i < EXPLEN; i++) ! 312: if (Expl[i] != NULL) { ! 313: bul_alarm(1); ! 314: return; ! 315: } ! 316: bul_alarm(0); ! 317: # endif CONSTANT_MOVE ! 318: ! 319: return; ! 320: } ! 321: ! 322: save_bullet(bp) ! 323: register BULLET *bp; ! 324: { ! 325: bp->b_over = Maze[bp->b_y][bp->b_x]; ! 326: switch (bp->b_over) { ! 327: case SHOT: ! 328: case GRENADE: ! 329: case SATCHEL: ! 330: case BOMB: ! 331: # ifdef OOZE ! 332: case SLIME: ! 333: # ifdef VOLCANO ! 334: case LAVA: ! 335: # endif VOLCANO ! 336: # endif OOZE ! 337: find_under(Bullets, bp); ! 338: break; ! 339: } ! 340: ! 341: switch (bp->b_over) { ! 342: case LEFTS: ! 343: case RIGHT: ! 344: case ABOVE: ! 345: case BELOW: ! 346: # ifdef FLY ! 347: case FLYER: ! 348: # endif FLY ! 349: mark_player(bp); ! 350: break; ! 351: ! 352: default: ! 353: Maze[bp->b_y][bp->b_x] = bp->b_type; ! 354: break; ! 355: } ! 356: ! 357: bp->b_next = Bullets; ! 358: Bullets = bp; ! 359: } ! 360: ! 361: /* ! 362: * chkshot ! 363: * Handle explosions ! 364: */ ! 365: chkshot(bp) ! 366: register BULLET *bp; ! 367: { ! 368: register int y, x; ! 369: register int dy, dx, absdy; ! 370: register int delta, damage; ! 371: register char expl; ! 372: register PLAYER *pp; ! 373: ! 374: switch (bp->b_type) { ! 375: case SHOT: ! 376: case MINE: ! 377: delta = 0; ! 378: break; ! 379: case GRENADE: ! 380: case GMINE: ! 381: delta = 1; ! 382: break; ! 383: case SATCHEL: ! 384: delta = 2; ! 385: break; ! 386: case BOMB: ! 387: delta = 3; ! 388: break; ! 389: # ifdef OOZE ! 390: case SLIME: ! 391: # ifdef VOLCANO ! 392: case LAVA: ! 393: # endif VOLCANO ! 394: chkslime(bp); ! 395: return; ! 396: # endif OOZE ! 397: } ! 398: for (y = bp->b_y - delta; y <= bp->b_y + delta; y++) { ! 399: if (y < 0 || y >= HEIGHT) ! 400: continue; ! 401: dy = y - bp->b_y; ! 402: absdy = (dy < 0) ? -dy : dy; ! 403: for (x = bp->b_x - delta; x <= bp->b_x + delta; x++) { ! 404: if (x < 0 || x >= WIDTH) ! 405: continue; ! 406: dx = x - bp->b_x; ! 407: if (dx == 0) ! 408: expl = (dy == 0) ? '*' : '|'; ! 409: else if (dy == 0) ! 410: expl = '-'; ! 411: else if (dx == dy) ! 412: expl = '\\'; ! 413: else if (dx == -dy) ! 414: expl = '/'; ! 415: else ! 416: expl = '*'; ! 417: showexpl(y, x, expl); ! 418: switch (Maze[y][x]) { ! 419: case LEFTS: ! 420: case RIGHT: ! 421: case ABOVE: ! 422: case BELOW: ! 423: # ifdef FLY ! 424: case FLYER: ! 425: # endif FLY ! 426: if (dx < 0) ! 427: dx = -dx; ! 428: if (absdy > dx) ! 429: damage = delta - absdy + 1; ! 430: else ! 431: damage = delta - dx + 1; ! 432: pp = play_at(y, x); ! 433: while (damage-- > 0) ! 434: checkdam(pp, bp->b_owner, bp->b_score, ! 435: MINDAM, bp->b_type); ! 436: break; ! 437: case GMINE: ! 438: case MINE: ! 439: add_shot((Maze[y][x] == GMINE) ? ! 440: GRENADE : SHOT, ! 441: y, x, LEFTS, ! 442: (Maze[y][x] == GMINE) ? ! 443: GRENREQ : BULREQ, ! 444: (PLAYER *) NULL, TRUE, SPACE); ! 445: Maze[y][x] = SPACE; ! 446: break; ! 447: } ! 448: } ! 449: } ! 450: } ! 451: ! 452: # ifdef OOZE ! 453: /* ! 454: * chkslime: ! 455: * handle slime shot exploding ! 456: */ ! 457: chkslime(bp) ! 458: register BULLET *bp; ! 459: { ! 460: register BULLET *nbp; ! 461: ! 462: switch (Maze[bp->b_y][bp->b_x]) { ! 463: case WALL1: ! 464: case WALL2: ! 465: case WALL3: ! 466: # ifdef REFLECT ! 467: case WALL4: ! 468: case WALL5: ! 469: # endif REFLECT ! 470: # ifdef RANDOM ! 471: case DOOR: ! 472: # endif RANDOM ! 473: switch (bp->b_face) { ! 474: case LEFTS: ! 475: bp->b_x++; ! 476: break; ! 477: case RIGHT: ! 478: bp->b_x--; ! 479: break; ! 480: case ABOVE: ! 481: bp->b_y++; ! 482: break; ! 483: case BELOW: ! 484: bp->b_y--; ! 485: break; ! 486: } ! 487: break; ! 488: } ! 489: nbp = (BULLET *) malloc(sizeof (BULLET)); ! 490: *nbp = *bp; ! 491: # ifdef VOLCANO ! 492: moveslime(nbp, nbp->b_type == SLIME ? SLIMESPEED : LAVASPEED); ! 493: # else VOLCANO ! 494: moveslime(nbp, SLIMESPEED); ! 495: # endif VOLCANO ! 496: } ! 497: ! 498: /* ! 499: * moveslime: ! 500: * move the given slime shot speed times and add it back if ! 501: * it hasn't fizzled yet ! 502: */ ! 503: moveslime(bp, speed) ! 504: register BULLET *bp; ! 505: register int speed; ! 506: { ! 507: register int i, j, dirmask, count; ! 508: register PLAYER *pp; ! 509: register BULLET *nbp; ! 510: ! 511: if (speed == 0) { ! 512: if (bp->b_charge <= 0) ! 513: free((char *) bp); ! 514: else ! 515: save_bullet(bp); ! 516: return; ! 517: } ! 518: ! 519: # ifdef VOLCANO ! 520: showexpl(bp->b_y, bp->b_x, bp->b_type == LAVA ? LAVA : '*'); ! 521: # else VOLCANO ! 522: showexpl(bp->b_y, bp->b_x, '*'); ! 523: # endif VOLCANO ! 524: switch (Maze[bp->b_y][bp->b_x]) { ! 525: case LEFTS: ! 526: case RIGHT: ! 527: case ABOVE: ! 528: case BELOW: ! 529: # ifdef FLY ! 530: case FLYER: ! 531: # endif FLY ! 532: pp = play_at(bp->b_y, bp->b_x); ! 533: message(pp, "You've been slimed."); ! 534: checkdam(pp, bp->b_owner, bp->b_score, MINDAM, bp->b_type); ! 535: break; ! 536: } ! 537: ! 538: if (--bp->b_charge <= 0) { ! 539: free((char *) bp); ! 540: return; ! 541: } ! 542: ! 543: dirmask = 0; ! 544: count = 0; ! 545: switch (bp->b_face) { ! 546: case LEFTS: ! 547: if (!iswall(bp->b_y, bp->b_x - 1)) ! 548: dirmask |= WEST, count++; ! 549: if (!iswall(bp->b_y - 1, bp->b_x)) ! 550: dirmask |= NORTH, count++; ! 551: if (!iswall(bp->b_y + 1, bp->b_x)) ! 552: dirmask |= SOUTH, count++; ! 553: if (dirmask == 0) ! 554: if (!iswall(bp->b_y, bp->b_x + 1)) ! 555: dirmask |= EAST, count++; ! 556: break; ! 557: case RIGHT: ! 558: if (!iswall(bp->b_y, bp->b_x + 1)) ! 559: dirmask |= EAST, count++; ! 560: if (!iswall(bp->b_y - 1, bp->b_x)) ! 561: dirmask |= NORTH, count++; ! 562: if (!iswall(bp->b_y + 1, bp->b_x)) ! 563: dirmask |= SOUTH, count++; ! 564: if (dirmask == 0) ! 565: if (!iswall(bp->b_y, bp->b_x - 1)) ! 566: dirmask |= WEST, count++; ! 567: break; ! 568: case ABOVE: ! 569: if (!iswall(bp->b_y - 1, bp->b_x)) ! 570: dirmask |= NORTH, count++; ! 571: if (!iswall(bp->b_y, bp->b_x - 1)) ! 572: dirmask |= WEST, count++; ! 573: if (!iswall(bp->b_y, bp->b_x + 1)) ! 574: dirmask |= EAST, count++; ! 575: if (dirmask == 0) ! 576: if (!iswall(bp->b_y + 1, bp->b_x)) ! 577: dirmask |= SOUTH, count++; ! 578: break; ! 579: case BELOW: ! 580: if (!iswall(bp->b_y + 1, bp->b_x)) ! 581: dirmask |= SOUTH, count++; ! 582: if (!iswall(bp->b_y, bp->b_x - 1)) ! 583: dirmask |= WEST, count++; ! 584: if (!iswall(bp->b_y, bp->b_x + 1)) ! 585: dirmask |= EAST, count++; ! 586: if (dirmask == 0) ! 587: if (!iswall(bp->b_y - 1, bp->b_x)) ! 588: dirmask |= NORTH, count++; ! 589: break; ! 590: } ! 591: if (count == 0) { ! 592: /* ! 593: * No place to go. Just sit here for a while and wait ! 594: * for adjacent squares to clear out. ! 595: */ ! 596: save_bullet(bp); ! 597: return; ! 598: } ! 599: if (bp->b_charge < count) { ! 600: /* Only bp->b_charge paths may be taken */ ! 601: while (count > bp->b_charge) { ! 602: if (dirmask & WEST) ! 603: dirmask &= ~WEST; ! 604: else if (dirmask & EAST) ! 605: dirmask &= ~EAST; ! 606: else if (dirmask & NORTH) ! 607: dirmask &= ~NORTH; ! 608: else if (dirmask & SOUTH) ! 609: dirmask &= ~SOUTH; ! 610: count--; ! 611: } ! 612: } ! 613: ! 614: i = bp->b_charge / count; ! 615: j = bp->b_charge % count; ! 616: if (dirmask & WEST) { ! 617: count--; ! 618: nbp = create_shot(bp->b_type, bp->b_y, bp->b_x - 1, LEFTS, ! 619: i, bp->b_owner, bp->b_score, TRUE, SPACE); ! 620: moveslime(nbp, speed - 1); ! 621: } ! 622: if (dirmask & EAST) { ! 623: count--; ! 624: nbp = create_shot(bp->b_type, bp->b_y, bp->b_x + 1, RIGHT, ! 625: (count < j) ? i + 1 : i, bp->b_owner, bp->b_score, ! 626: TRUE, SPACE); ! 627: moveslime(nbp, speed - 1); ! 628: } ! 629: if (dirmask & NORTH) { ! 630: count--; ! 631: nbp = create_shot(bp->b_type, bp->b_y - 1, bp->b_x, ABOVE, ! 632: (count < j) ? i + 1 : i, bp->b_owner, bp->b_score, ! 633: TRUE, SPACE); ! 634: moveslime(nbp, speed - 1); ! 635: } ! 636: if (dirmask & SOUTH) { ! 637: count--; ! 638: nbp = create_shot(bp->b_type, bp->b_y + 1, bp->b_x, BELOW, ! 639: (count < j) ? i + 1 : i, bp->b_owner, bp->b_score, ! 640: TRUE, SPACE); ! 641: moveslime(nbp, speed - 1); ! 642: } ! 643: ! 644: free((char *) bp); ! 645: } ! 646: ! 647: /* ! 648: * iswall: ! 649: * returns whether the given location is a wall ! 650: */ ! 651: iswall(y, x) ! 652: register int y, x; ! 653: { ! 654: if (y < 0 || x < 0 || y >= HEIGHT || x >= WIDTH) ! 655: return TRUE; ! 656: switch (Maze[y][x]) { ! 657: case WALL1: ! 658: case WALL2: ! 659: case WALL3: ! 660: # ifdef REFLECT ! 661: case WALL4: ! 662: case WALL5: ! 663: # endif REFLECT ! 664: # ifdef RANDOM ! 665: case DOOR: ! 666: # endif RANDOM ! 667: # ifdef VOLCANO ! 668: case LAVA: ! 669: # endif VOLCANO ! 670: return TRUE; ! 671: } ! 672: return FALSE; ! 673: } ! 674: # endif OOZE ! 675: ! 676: /* ! 677: * zapshot: ! 678: * Take a shot out of the air. ! 679: */ ! 680: zapshot(blist, obp) ! 681: register BULLET *blist, *obp; ! 682: { ! 683: register BULLET *bp; ! 684: register FLAG explode; ! 685: ! 686: explode = FALSE; ! 687: for (bp = blist; bp != NULL; bp = bp->b_next) { ! 688: if (bp->b_x != obp->b_x || bp->b_y != obp->b_y) ! 689: continue; ! 690: if (bp->b_face == obp->b_face) ! 691: continue; ! 692: explode = TRUE; ! 693: break; ! 694: } ! 695: if (!explode) ! 696: return; ! 697: explshot(blist, obp->b_y, obp->b_x); ! 698: } ! 699: ! 700: /* ! 701: * explshot - ! 702: * Make all shots at this location blow up ! 703: */ ! 704: explshot(blist, y, x) ! 705: register BULLET *blist; ! 706: register int y, x; ! 707: { ! 708: register BULLET *bp; ! 709: ! 710: for (bp = blist; bp != NULL; bp = bp->b_next) ! 711: if (bp->b_x == x && bp->b_y == y) { ! 712: bp->b_expl = TRUE; ! 713: if (bp->b_owner != NULL) ! 714: message(bp->b_owner, "Shot intercepted"); ! 715: } ! 716: } ! 717: ! 718: /* ! 719: * play_at: ! 720: * Return a pointer to the player at the given location ! 721: */ ! 722: PLAYER * ! 723: play_at(y, x) ! 724: register int y, x; ! 725: { ! 726: register PLAYER *pp; ! 727: ! 728: for (pp = Player; pp < End_player; pp++) ! 729: if (pp->p_x == x && pp->p_y == y) ! 730: return pp; ! 731: fprintf(stderr, "driver: couldn't find player at (%d,%d)\n", x, y); ! 732: abort(); ! 733: /* NOTREACHED */ ! 734: } ! 735: ! 736: /* ! 737: * opposite: ! 738: * Return TRUE if the bullet direction faces the opposite direction ! 739: * of the player in the maze ! 740: */ ! 741: opposite(face, dir) ! 742: int face; ! 743: char dir; ! 744: { ! 745: switch (face) { ! 746: case LEFTS: ! 747: return (dir == RIGHT); ! 748: case RIGHT: ! 749: return (dir == LEFTS); ! 750: case ABOVE: ! 751: return (dir == BELOW); ! 752: case BELOW: ! 753: return (dir == ABOVE); ! 754: default: ! 755: return FALSE; ! 756: } ! 757: } ! 758: ! 759: /* ! 760: * is_bullet: ! 761: * Is there a bullet at the given coordinates? If so, return ! 762: * a pointer to the bullet, otherwise return NULL ! 763: */ ! 764: BULLET * ! 765: is_bullet(y, x) ! 766: register int y, x; ! 767: { ! 768: register BULLET *bp; ! 769: ! 770: for (bp = Bullets; bp != NULL; bp = bp->b_next) ! 771: if (bp->b_y == y && bp->b_x == x) ! 772: return bp; ! 773: return NULL; ! 774: } ! 775: ! 776: /* ! 777: * fixshots: ! 778: * change the underlying character of the shots at a location ! 779: * to the given character. ! 780: */ ! 781: fixshots(y, x, over) ! 782: register int y, x; ! 783: char over; ! 784: { ! 785: register BULLET *bp; ! 786: ! 787: for (bp = Bullets; bp != NULL; bp = bp->b_next) ! 788: if (bp->b_y == y && bp->b_x == x) ! 789: bp->b_over = over; ! 790: } ! 791: ! 792: /* ! 793: * find_under: ! 794: * find the underlying character for a bullet when it lands ! 795: * on another bullet. ! 796: */ ! 797: find_under(blist, bp) ! 798: register BULLET *blist, *bp; ! 799: { ! 800: register BULLET *nbp; ! 801: ! 802: for (nbp = blist; nbp != NULL; nbp = nbp->b_next) ! 803: if (bp->b_y == nbp->b_y && bp->b_x == nbp->b_x) { ! 804: bp->b_over = nbp->b_over; ! 805: break; ! 806: } ! 807: } ! 808: ! 809: /* ! 810: * mark_player: ! 811: * mark a player as under a shot ! 812: */ ! 813: mark_player(bp) ! 814: register BULLET *bp; ! 815: { ! 816: register PLAYER *pp; ! 817: ! 818: for (pp = Player; pp < End_player; pp++) ! 819: if (pp->p_y == bp->b_y && pp->p_x == bp->b_x) { ! 820: pp->p_undershot = TRUE; ! 821: break; ! 822: } ! 823: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.