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