![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to draw.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 draw.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: drawmaze(pp)
14: register PLAYER *pp;
15: {
16: register int x;
17: register char *sp;
18: register int y;
19: register char *endp;
20:
21: clrscr(pp);
22: outstr(pp, pp->p_maze[0], WIDTH);
23: for (y = 1; y < HEIGHT - 1; y++) {
24: endp = &pp->p_maze[y][WIDTH];
25: for (x = 0, sp = pp->p_maze[y]; sp < endp; x++, sp++)
26: if (*sp != SPACE) {
27: cgoto(pp, y, x);
28: if (pp->p_x == x && pp->p_y == y)
29: outch(pp, translate(*sp));
30: else
31: outch(pp, *sp);
32: }
33: }
34: cgoto(pp, HEIGHT - 1, 0);
35: outstr(pp, pp->p_maze[HEIGHT - 1], WIDTH);
36: drawstatus(pp);
37: }
38:
39: /*
40: * drawstatus - put up the status lines (this assumes the screen
41: * size is 80x24 with the maze being 64x24)
42: */
43: drawstatus(pp)
44: register PLAYER *pp;
45: {
46: register int i;
47: register PLAYER *np;
48:
49: (void) sprintf(Buf, "%-13.13s", pp->p_ident->i_name);
50: cgoto(pp, STAT_NAME_ROW, STAT_LABEL_COL);
51: outstr(pp, Buf, 13);
52:
53: cgoto(pp, STAT_AMMO_ROW, STAT_LABEL_COL);
54: outstr(pp, "Ammo:", 5);
55: (void) sprintf(Buf, "%3d", pp->p_ammo);
56: cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL);
57: outstr(pp, Buf, 3);
58:
59: cgoto(pp, STAT_CLOAK_ROW, STAT_LABEL_COL);
60: outstr(pp, "Cloak:", 6);
61: cgoto(pp, STAT_CLOAK_ROW, STAT_VALUE_COL);
62: outstr(pp, (pp->p_cloak < 0) ? " " : " on", 3);
63:
64: cgoto(pp, STAT_SCAN_ROW, STAT_LABEL_COL);
65: outstr(pp, "Scan:", 5);
66: cgoto(pp, STAT_SCAN_ROW, STAT_VALUE_COL);
67: outstr(pp, (pp->p_scan < 0) ? " " : " on", 3);
68:
69: cgoto(pp, STAT_GUN_ROW, STAT_LABEL_COL);
70: outstr(pp, "Gun:", 4);
71: cgoto(pp, STAT_GUN_ROW, STAT_VALUE_COL);
72: outstr(pp, (pp->p_ncshot < MAXNCSHOT) ? " ok" : " ", 3);
73:
74: cgoto(pp, STAT_DAM_ROW, STAT_LABEL_COL);
75: outstr(pp, "Damage:", 7);
76: (void) sprintf(Buf, "%2d/%2d", pp->p_damage, pp->p_damcap);
77: cgoto(pp, STAT_DAM_ROW, STAT_VALUE_COL);
78: outstr(pp, Buf, 5);
79:
80: cgoto(pp, STAT_KILL_ROW, STAT_LABEL_COL);
81: outstr(pp, "Kills:", 6);
82: (void) sprintf(Buf, "%3d", (pp->p_damcap - MAXDAM) / 2);
83: cgoto(pp, STAT_KILL_ROW, STAT_VALUE_COL);
84: outstr(pp, Buf, 3);
85:
86: cgoto(pp, STAT_PLAY_ROW, STAT_LABEL_COL);
87: outstr(pp, "Player:", 7);
88: for (i = STAT_PLAY_ROW + 1, np = Player; np < End_player; np++) {
89: (void) sprintf(Buf, "%5.2f%c%-10.10s", np->p_ident->i_score,
90: stat_char(np), np->p_ident->i_name);
91: cgoto(pp, i++, STAT_NAME_COL);
92: outstr(pp, Buf, STAT_NAME_LEN);
93: }
94:
95: # ifdef MONITOR
96: cgoto(pp, STAT_MON_ROW, STAT_LABEL_COL);
97: outstr(pp, "Monitor:", 8);
98: for (i = STAT_MON_ROW + 1, np = Monitor; np < End_monitor; np++) {
99: (void) sprintf(Buf, "%5.5s %-10.10s", " ", np->p_ident->i_name);
100: cgoto(pp, i++, STAT_NAME_COL);
101: outstr(pp, Buf, STAT_NAME_LEN);
102: }
103: # endif MONITOR
104: }
105:
106: # ifndef CPUHOG
107: look(pp)
108: register PLAYER *pp;
109: {
110: register int x, y;
111:
112: x = pp->p_x;
113: y = pp->p_y;
114:
115: check(pp, y - 1, x - 1);
116: check(pp, y - 1, x );
117: check(pp, y - 1, x + 1);
118: check(pp, y , x - 1);
119: check(pp, y , x );
120: check(pp, y , x + 1);
121: check(pp, y + 1, x - 1);
122: check(pp, y + 1, x );
123: check(pp, y + 1, x + 1);
124:
125: switch (pp->p_face) {
126: case LEFTS:
127: see(pp, LEFTS);
128: see(pp, ABOVE);
129: see(pp, BELOW);
130: break;
131: case RIGHT:
132: see(pp, RIGHT);
133: see(pp, ABOVE);
134: see(pp, BELOW);
135: break;
136: case ABOVE:
137: see(pp, ABOVE);
138: see(pp, LEFTS);
139: see(pp, RIGHT);
140: break;
141: case BELOW:
142: see(pp, BELOW);
143: see(pp, LEFTS);
144: see(pp, RIGHT);
145: break;
146: # ifdef FLY
147: case FLYER:
148: break;
149: # endif FLY
150: }
151: cgoto(pp, y, x);
152: }
153:
154: see(pp, face)
155: register PLAYER *pp;
156: int face;
157: {
158: register char *sp;
159: register int y, x, i, cnt;
160:
161: x = pp->p_x;
162: y = pp->p_y;
163:
164: switch (face) {
165: case LEFTS:
166: sp = &Maze[y][x];
167: for (i = 0; See_over[*--sp]; i++)
168: continue;
169:
170: if (i == 0)
171: break;
172:
173: cnt = i;
174: x = pp->p_x - 1;
175: --y;
176: while (i--)
177: check(pp, y, --x);
178: i = cnt;
179: x = pp->p_x - 1;
180: ++y;
181: while (i--)
182: check(pp, y, --x);
183: i = cnt;
184: x = pp->p_x - 1;
185: ++y;
186: while (i--)
187: check(pp, y, --x);
188: break;
189: case RIGHT:
190: sp = &Maze[y][++x];
191: for (i = 0; See_over[*sp++]; i++)
192: continue;
193:
194: if (i == 0)
195: break;
196:
197: cnt = i;
198: x = pp->p_x + 1;
199: --y;
200: while (i--)
201: check(pp, y, ++x);
202: i = cnt;
203: x = pp->p_x + 1;
204: ++y;
205: while (i--)
206: check(pp, y, ++x);
207: i = cnt;
208: x = pp->p_x + 1;
209: ++y;
210: while (i--)
211: check(pp, y, ++x);
212: break;
213: case ABOVE:
214: sp = &Maze[--y][x];
215: if (!See_over[*sp])
216: break;
217: do {
218: --y;
219: sp -= sizeof Maze[0];
220: check(pp, y, x - 1);
221: check(pp, y, x );
222: check(pp, y, x + 1);
223: } while (See_over[*sp]);
224: break;
225: case BELOW:
226: sp = &Maze[++y][x];
227: if (!See_over[*sp])
228: break;
229: do {
230: y++;
231: sp += sizeof Maze[0];
232: check(pp, y, x - 1);
233: check(pp, y, x );
234: check(pp, y, x + 1);
235: } while (See_over[*sp]);
236: break;
237: }
238: }
239:
240: # else CPUHOG
241:
242: look(pp)
243: register PLAYER *pp;
244: {
245: switch (pp->p_face) {
246: case LEFTS:
247: lookquad2(pp, pp->p_y, pp->p_x);
248: lookquad3(pp, pp->p_y, pp->p_x);
249: break;
250: case RIGHT:
251: lookquad1(pp, pp->p_y, pp->p_x);
252: lookquad4(pp, pp->p_y, pp->p_x);
253: break;
254: case ABOVE:
255: lookquad3(pp, pp->p_y, pp->p_x);
256: lookquad4(pp, pp->p_y, pp->p_x);
257: break;
258: case BELOW:
259: lookquad1(pp, pp->p_y, pp->p_x);
260: lookquad2(pp, pp->p_y, pp->p_x);
261: break;
262: }
263: cgoto(pp, pp->p_y, pp->p_x);
264: }
265: # endif CPUHOG
266:
267: check(pp, y, x)
268: PLAYER *pp;
269: int y, x;
270: {
271: register int index;
272: register int ch;
273: register PLAYER *rpp;
274:
275: index = y * sizeof Maze[0] + x;
276: ch = ((char *) Maze)[index];
277: if (ch != ((char *) pp->p_maze)[index]) {
278: rpp = pp;
279: cgoto(rpp, y, x);
280: if (x == rpp->p_x && y == rpp->p_y)
281: outch(rpp, translate(ch));
282: else
283: outch(rpp, ch);
284: ((char *) rpp->p_maze)[index] = ch;
285: }
286: }
287:
288: /*
289: * showstat
290: * Update the status of players
291: */
292: showstat(pp)
293: register PLAYER *pp;
294: {
295: register PLAYER *np;
296: register int y;
297: register char c;
298:
299: y = STAT_PLAY_ROW + 1 + (pp - Player);
300: c = stat_char(pp);
301: # ifdef MONITOR
302: for (np = Monitor; np < End_monitor; np++) {
303: cgoto(np, y, STAT_SCAN_COL);
304: outch(np, c);
305: }
306: # endif MONITOR
307: for (np = Player; np < End_player; np++) {
308: cgoto(np, y, STAT_SCAN_COL);
309: outch(np, c);
310: }
311: }
312:
313: /*
314: * drawplayer:
315: * Draw the player on the screen and show him to everyone who's scanning
316: * unless he is cloaked.
317: */
318: drawplayer(pp, draw)
319: PLAYER *pp;
320: FLAG draw;
321: {
322: register PLAYER *newp;
323: register int x, y;
324:
325: x = pp->p_x;
326: y = pp->p_y;
327: Maze[y][x] = draw ? pp->p_face : pp->p_over;
328:
329: # ifdef MONITOR
330: for (newp = Monitor; newp < End_monitor; newp++)
331: check(newp, y, x);
332: # endif MONITOR
333:
334: for (newp = Player; newp < End_player; newp++) {
335: if (!draw || newp == pp) {
336: check(newp, y, x);
337: continue;
338: }
339: if (newp->p_scan == 0) {
340: cgoto(newp, STAT_SCAN_ROW, STAT_VALUE_COL);
341: outstr(newp, " ", 3);
342: newp->p_scan--;
343: showstat(newp);
344: }
345: else if (newp->p_scan > 0) {
346: if (pp->p_cloak < 0)
347: check(newp, y, x);
348: newp->p_scan--;
349: }
350: }
351: if (!draw || pp->p_cloak < 0)
352: return;
353: if (pp->p_cloak-- == 0) {
354: cgoto(pp, STAT_CLOAK_ROW, STAT_VALUE_COL);
355: outstr(pp, " ", 3);
356: showstat(pp);
357: }
358: }
359:
360: message(pp, s)
361: register PLAYER *pp;
362: char *s;
363: {
364: cgoto(pp, HEIGHT, 0);
365: outstr(pp, s, strlen(s));
366: ce(pp);
367: }
368:
369: /*
370: * translate:
371: * Turn a charcter into the right direction character if we are
372: * looking at the current player.
373: */
374: translate(ch)
375: char ch;
376: {
377: switch (ch) {
378: case LEFTS:
379: return '<';
380: case RIGHT:
381: return '>';
382: case ABOVE:
383: return '^';
384: case BELOW:
385: return 'v';
386: }
387: return ch;
388: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.