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