![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / monop|
Return to misc.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / monop |
1.1 root 1: /*
2: * Copyright (c) 1980 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: (1) source distributions retain this entire copyright
7: * notice and comment, and (2) distributions including binaries display
8: * the following acknowledgement: ``This product includes software
9: * developed by the University of California, Berkeley and its contributors''
10: * in the documentation or other materials provided with the distribution
11: * and in all advertising materials mentioning features or use of this
12: * software. Neither the name of the University nor the names of its
13: * contributors may be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)misc.c 5.4 (Berkeley) 6/1/90";
22: #endif /* not lint */
23:
24: # include "monop.ext"
25: # include <ctype.h>
26: # include <signal.h>
27:
28: # define execsh(sh) execl(sh, shell_name[roll(1, num_names)-1], 0)
29:
30: static char *shell_def = "/bin/csh",
31: *shell_name[] = {
32: ".Hi Mom!",
33: ".Kick Me",
34: ".I'm really the next process down",
35: ".Hi Kids!",
36: ".This space for rent",
37: ".Singin' in the rain....",
38: ".I am but a Cog in the Wheel of Life",
39: ".Look out!!! Behind you!!!!!",
40: ".Looking for a good time, sailor?",
41: ".I don't get NO respect...",
42: ".Augghh! You peeked!"
43: };
44:
45: static int num_names = sizeof shell_name / sizeof (char *);;
46:
47: char *shell_in();
48:
49: /*
50: * This routine executes a truncated set of commands until a
51: * "yes or "no" answer is gotten.
52: */
53: getyn(prompt)
54: reg char *prompt; {
55:
56: reg int com;
57:
58: for (;;)
59: if ((com=getinp(prompt, yn)) < 2)
60: return com;
61: else
62: (*func[com-2])();
63: }
64: /*
65: * This routine tells the player if he's out of money.
66: */
67: notify() {
68:
69: if (cur_p->money < 0)
70: printf("That leaves you $%d in debt\n", -cur_p->money);
71: else if (cur_p->money == 0)
72: printf("that leaves you broke\n");
73: else if (fixing && !told_em && cur_p->money > 0) {
74: printf("-- You are now Solvent ---\n");
75: told_em = TRUE;
76: }
77: }
78: /*
79: * This routine switches to the next player
80: */
81: next_play() {
82:
83: player = ++player % num_play;
84: cur_p = &play[player];
85: num_doub = 0;
86: }
87: /*
88: * This routine gets an integer from the keyboard after the
89: * given prompt.
90: */
91: get_int(prompt)
92: reg char *prompt; {
93:
94: reg int num;
95: reg char *sp;
96: char buf[257];
97:
98: for (;;) {
99: inter:
100: printf(prompt);
101: num = 0;
102: for (sp = buf; (*sp=getchar()) != '\n'; sp++)
103: if (*sp == -1) /* check for interrupted system call */
104: goto inter;
105: if (sp == buf)
106: continue;
107: for (sp = buf; isspace(*sp); sp++)
108: continue;
109: for (; isdigit(*sp); sp++)
110: num = num * 10 + *sp - '0';
111: if (*sp == '\n')
112: return num;
113: else
114: printf("I can't understand that\n");
115: }
116: }
117: /*
118: * This routine sets the monopoly flag from the list given.
119: */
120: set_ownlist(pl)
121: int pl; {
122:
123: reg int num; /* general counter */
124: reg MON *orig; /* remember starting monop ptr */
125: reg OWN *op; /* current owned prop */
126: OWN *orig_op; /* origianl prop before loop */
127:
128: op = play[pl].own_list;
129: #ifdef DEBUG
130: printf("op [%d] = play[pl [%d] ].own_list;\n", op, pl);
131: #endif
132: while (op) {
133: #ifdef DEBUG
134: printf("op->sqr->type = %d\n", op->sqr->type);
135: #endif
136: switch (op->sqr->type) {
137: case UTIL:
138: #ifdef DEBUG
139: printf(" case UTIL:\n");
140: #endif
141: for (num = 0; op && op->sqr->type == UTIL; op = op->next)
142: num++;
143: play[pl].num_util = num;
144: #ifdef DEBUG
145: printf("play[pl].num_util = num [%d];\n", num);
146: #endif
147: break;
148: case RR:
149: #ifdef DEBUG
150: printf(" case RR:\n");
151: #endif
152: for (num = 0; op && op->sqr->type == RR; op = op->next) {
153: #ifdef DEBUG
154: printf("iter: %d\n", num);
155: printf("op = %d, op->sqr = %d, op->sqr->type = %d\n", op, op->sqr, op->sqr->type);
156: #endif
157: num++;
158: }
159: play[pl].num_rr = num;
160: #ifdef DEBUG
161: printf("play[pl].num_rr = num [%d];\n", num);
162: #endif
163: break;
164: case PRPTY:
165: #ifdef DEBUG
166: printf(" case PRPTY:\n");
167: #endif
168: orig = op->sqr->desc->mon_desc;
169: orig_op = op;
170: num = 0;
171: while (op && op->sqr->desc->mon_desc == orig) {
172: #ifdef DEBUG
173: printf("iter: %d\n", num);
174: #endif
175: num++;
176: #ifdef DEBUG
177: printf("op = op->next ");
178: #endif
179: op = op->next;
180: #ifdef DEBUG
181: printf("[%d];\n", op);
182: #endif
183: }
184: #ifdef DEBUG
185: printf("num = %d\n");
186: #endif
187: if (orig == 0) {
188: printf("panic: bad monopoly descriptor: orig = %d\n", orig);
189: printf("player # %d\n", pl+1);
190: printhold(pl);
191: printf("orig_op = %d\n", orig_op);
192: printf("orig_op->sqr->type = %d (PRPTY)\n", op->sqr->type);
193: printf("orig_op->next = %d\n", op->next);
194: printf("orig_op->sqr->desc = %d\n", op->sqr->desc);
195: printf("op = %d\n", op);
196: printf("op->sqr->type = %d (PRPTY)\n", op->sqr->type);
197: printf("op->next = %d\n", op->next);
198: printf("op->sqr->desc = %d\n", op->sqr->desc);
199: printf("num = %d\n", num);
200: }
201: #ifdef DEBUG
202: printf("orig->num_in = %d\n", orig->num_in);
203: #endif
204: if (num == orig->num_in)
205: is_monop(orig, pl);
206: else
207: isnot_monop(orig);
208: break;
209: }
210: }
211: }
212: /*
213: * This routine sets things up as if it is a new monopoly
214: */
215: is_monop(mp, pl)
216: reg MON *mp;
217: int pl; {
218:
219: reg char *sp;
220: reg int i;
221:
222: mp->owner = pl;
223: mp->num_own = mp->num_in;
224: for (i = 0; i < mp->num_in; i++)
225: mp->sq[i]->desc->monop = TRUE;
226: mp->name = mp->mon_n;
227: }
228: /*
229: * This routine sets things up as if it is no longer a monopoly
230: */
231: isnot_monop(mp)
232: reg MON *mp; {
233:
234: reg char *sp;
235: reg int i;
236:
237: mp->owner = -1;
238: for (i = 0; i < mp->num_in; i++)
239: mp->sq[i]->desc->monop = FALSE;
240: mp->name = mp->not_m;
241: }
242: /*
243: * This routine gives a list of the current player's routine
244: */
245: list() {
246:
247: printhold(player);
248: }
249: /*
250: * This routine gives a list of a given players holdings
251: */
252: list_all() {
253:
254: reg int pl;
255:
256: while ((pl=getinp("Whose holdings do you want to see? ", name_list)) < num_play)
257: printhold(pl);
258: }
259: /*
260: * This routine gives the players a chance before it exits.
261: */
262: quit() {
263:
264: putchar('\n');
265: if (getyn("Do you all really want to quit? ", yn) == 0)
266: exit(0);
267: signal(2, quit);
268: }
269: /*
270: * This routine copies one structure to another
271: */
272: cpy_st(s1, s2, size)
273: reg int *s1, *s2, size; {
274:
275: size /= 2;
276: while (size--)
277: *s1++ = *s2++;
278: }
279: /*
280: * This routine forks off a shell. It uses the users login shell
281: */
282: shell_out() {
283:
284: static char *shell = NULL;
285:
286: printline();
287: if (shell == NULL)
288: shell = shell_in();
289: fflush();
290: if (!fork()) {
291: signal(SIGINT, SIG_DFL);
292: execsh(shell);
293: }
294: ignoresigs();
295: wait();
296: resetsigs();
297: putchar('\n');
298: printline();
299: }
300: /*
301: * This routine looks up the users login shell
302: */
303: # include <sys/types.h>
304: # include <pwd.h>
305:
306: struct passwd *getpwuid();
307:
308: char *getenv();
309:
310: char *
311: shell_in() {
312:
313: reg struct passwd *pp;
314: reg char *sp;
315:
316: if ((sp = getenv("SHELL")) == NULL) {
317: pp = getpwuid(getuid());
318: if (pp->pw_shell[0] != '\0')
319: return pp->pw_shell;
320: else
321: return shell_def;
322: /*return (*(pp->pw_shell) != '\0' ? pp->pw_shell : shell_def);*/
323: }
324: return sp;
325: }
326: /*
327: * This routine sets things up to ignore all the signals.
328: */
329: ignoresigs() {
330:
331: reg int i;
332:
333: for (i = 0; i < NSIG; i++)
334: signal(i, SIG_IGN);
335: }
336: /*
337: * This routine sets up things as they were before.
338: */
339: resetsigs() {
340:
341: reg int i;
342:
343: for (i = 0; i < NSIG; i++)
344: signal(i, SIG_DFL);
345: signal(2, quit);
346: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.