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