![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expl.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 expl.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:
13: /*
14: * showexpl:
15: * Show the explosions as they currently are
16: */
17: showexpl(y, x, type)
18: register int y, x;
19: char type;
20: {
21: register PLAYER *pp;
22: register EXPL *ep;
23:
24: if (y < 0 || y >= HEIGHT)
25: return;
26: if (x < 0 || x >= WIDTH)
27: return;
28: ep = (EXPL *) malloc(sizeof (EXPL)); /* NOSTRICT */
29: ep->e_y = y;
30: ep->e_x = x;
31: ep->e_char = type;
32: ep->e_next = Expl[0];
33: Expl[0] = ep;
34: for (pp = Player; pp < End_player; pp++) {
35: if (pp->p_maze[y][x] == type)
36: continue;
37: pp->p_maze[y][x] = type;
38: cgoto(pp, y, x);
39: outch(pp, type);
40: }
41: # ifdef MONITOR
42: for (pp = Monitor; pp < End_monitor; pp++) {
43: if (pp->p_maze[y][x] == type)
44: continue;
45: pp->p_maze[y][x] = type;
46: cgoto(pp, y, x);
47: outch(pp, type);
48: }
49: # endif MONITOR
50: switch (Maze[y][x]) {
51: case WALL1:
52: case WALL2:
53: case WALL3:
54: # ifdef RANDOM
55: case DOOR:
56: # endif RANDOM
57: # ifdef REFLECT
58: case WALL4:
59: case WALL5:
60: # endif REFLECT
61: if (y >= UBOUND && y < DBOUND && x >= LBOUND && x < RBOUND)
62: remove_wall(y, x);
63: break;
64: }
65: }
66:
67: /*
68: * rollexpl:
69: * Roll the explosions over, so the next one in the list is at the
70: * top
71: */
72: rollexpl()
73: {
74: register EXPL *ep;
75: register PLAYER *pp;
76: register int y, x;
77: register char c;
78: register EXPL *nextep;
79:
80: for (ep = Expl[EXPLEN - 1]; ep != NULL; ep = nextep) {
81: nextep = ep->e_next;
82: y = ep->e_y;
83: x = ep->e_x;
84: if (y < UBOUND || y >= DBOUND || x < LBOUND || x >= RBOUND)
85: c = Maze[y][x];
86: else
87: c = SPACE;
88: for (pp = Player; pp < End_player; pp++)
89: if (pp->p_maze[y][x] == ep->e_char) {
90: pp->p_maze[y][x] = c;
91: cgoto(pp, y, x);
92: outch(pp, c);
93: }
94: # ifdef MONITOR
95: for (pp = Monitor; pp < End_monitor; pp++)
96: check(pp, y, x);
97: # endif MONITOR
98: free((char *) ep);
99: }
100: for (x = EXPLEN - 1; x > 0; x--)
101: Expl[x] = Expl[x - 1];
102: Expl[0] = NULL;
103: }
104:
105: /* There's about 700 walls in the initial maze. So we pick a number
106: * that keeps the maze relatively full. */
107: # define MAXREMOVE 40
108:
109: static REGEN removed[MAXREMOVE];
110: static REGEN *rem_index = removed;
111:
112: /*
113: * remove_wall - add a location where the wall was blown away.
114: * if there is no space left over, put the a wall at
115: * the location currently pointed at.
116: */
117: remove_wall(y, x)
118: int y, x;
119: {
120: register REGEN *r;
121: # if defined(MONITOR) || defined(FLY)
122: register PLAYER *pp;
123: # endif MONITOR || FLY
124: # ifdef FLY
125: register char save_char;
126: # endif FLY
127:
128: r = rem_index;
129: while (r->r_y != 0) {
130: # ifdef FLY
131: switch (Maze[r->r_y][r->r_x]) {
132: case SPACE:
133: case LEFTS:
134: case RIGHT:
135: case ABOVE:
136: case BELOW:
137: case FLYER:
138: save_char = Maze[r->r_y][r->r_x];
139: goto found;
140: }
141: # else FLY
142: if (Maze[r->r_y][r->r_x] == SPACE)
143: break;
144: # endif FLY
145: if (++r >= &removed[MAXREMOVE])
146: r = removed;
147: }
148:
149: found:
150: if (r->r_y != 0) {
151: /* Slot being used, put back this wall */
152: # ifdef FLY
153: if (save_char == SPACE)
154: Maze[r->r_y][r->r_x] = Orig_maze[r->r_y][r->r_x];
155: else {
156: pp = play_at(r->r_y, r->r_x);
157: if (pp->p_flying >= 0)
158: pp->p_flying += rand_num(10);
159: else {
160: pp->p_flying = rand_num(20);
161: pp->p_flyx = 2 * rand_num(6) - 5;
162: pp->p_flyy = 2 * rand_num(6) - 5;
163: }
164: pp->p_over = Orig_maze[r->r_y][r->r_x];
165: pp->p_face = FLYER;
166: Maze[r->r_y][r->r_x] = FLYER;
167: showexpl(r->r_y, r->r_x, FLYER);
168: }
169: # else FLY
170: Maze[r->r_y][r->r_x] = Orig_maze[r->r_y][r->r_x];
171: # endif FLY
172: # ifdef RANDOM
173: if (rand_num(100) == 0)
174: Maze[r->r_y][r->r_x] = DOOR;
175: # endif RANDOM
176: # ifdef REFLECT
177: if (rand_num(100) == 0) /* one percent of the time */
178: Maze[r->r_y][r->r_x] = WALL4;
179: # endif REFLECT
180: # ifdef MONITOR
181: for (pp = Monitor; pp < End_monitor; pp++)
182: check(pp, r->r_y, r->r_x);
183: # endif MONITOR
184: }
185:
186: r->r_y = y;
187: r->r_x = x;
188: if (++r >= &removed[MAXREMOVE])
189: rem_index = removed;
190: else
191: rem_index = r;
192:
193: Maze[y][x] = SPACE;
194: # ifdef MONITOR
195: for (pp = Monitor; pp < End_monitor; pp++)
196: check(pp, y, x);
197: # endif MONITOR
198: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.