![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to execute.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / games / monop|
Return to execute.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / 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 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[] = "@(#)execute.c 5.3 (Berkeley) 6/18/88";
20: #endif /* not lint */
21:
22: # include "monop.ext"
23: # include <sys/types.h>
24: # include <sys/stat.h>
25: # include <sys/time.h>
26:
27: # define SEGSIZE 8192
28:
29: typedef struct stat STAT;
30: typedef struct tm TIME;
31:
32: extern char etext[], /* end of text space */
33: rub();
34:
35: static char buf[257],
36: *yn_only[] = { "yes", "no"};
37:
38: static bool new_play; /* set if move on to new player */
39:
40: /*
41: * This routine executes the given command by index number
42: */
43: execute(com_num)
44: reg int com_num; {
45:
46: new_play = FALSE; /* new_play is true if fixing */
47: (*func[com_num])();
48: notify();
49: force_morg();
50: if (new_play)
51: next_play();
52: else if (num_doub)
53: printf("%s rolled doubles. Goes again\n", cur_p->name);
54: }
55: /*
56: * This routine moves a piece around.
57: */
58: do_move() {
59:
60: reg int r1, r2;
61: reg bool was_jail;
62:
63: new_play = was_jail = FALSE;
64: printf("roll is %d, %d\n", r1=roll(1, 6), r2=roll(1, 6));
65: if (cur_p->loc == JAIL) {
66: was_jail++;
67: if (!move_jail(r1, r2)) {
68: new_play++;
69: goto ret;
70: }
71: }
72: else {
73: if (r1 == r2 && ++num_doub == 3) {
74: printf("That's 3 doubles. You go to jail\n");
75: goto_jail();
76: new_play++;
77: goto ret;
78: }
79: move(r1+r2);
80: }
81: if (r1 != r2 || was_jail)
82: new_play++;
83: ret:
84: return;
85: }
86: /*
87: * This routine moves a normal move
88: */
89: move(rl)
90: reg int rl; {
91:
92: reg int old_loc;
93:
94: old_loc = cur_p->loc;
95: cur_p->loc = (cur_p->loc + rl) % N_SQRS;
96: if (cur_p->loc < old_loc && rl > 0) {
97: cur_p->money += 200;
98: printf("You pass %s and get $200\n", board[0].name);
99: }
100: show_move();
101: }
102: /*
103: * This routine shows the results of a move
104: */
105: show_move() {
106:
107: reg SQUARE *sqp;
108:
109: sqp = &board[cur_p->loc];
110: printf("That puts you on %s\n", sqp->name);
111: switch (sqp->type) {
112: case SAFE:
113: printf("That is a safe place\n");
114: break;
115: case CC:
116: cc(); break;
117: case CHANCE:
118: chance(); break;
119: case INC_TAX:
120: inc_tax(); break;
121: case GOTO_J:
122: goto_jail(); break;
123: case LUX_TAX:
124: lux_tax(); break;
125: case PRPTY:
126: case RR:
127: case UTIL:
128: if (sqp->owner < 0) {
129: printf("That would cost $%d\n", sqp->cost);
130: if (getyn("Do you want to buy? ") == 0) {
131: buy(player, sqp);
132: cur_p->money -= sqp->cost;
133: }
134: else if (num_play > 2)
135: bid(sqp);
136: }
137: else if (sqp->owner == player)
138: printf("You own it.\n");
139: else
140: rent(sqp);
141: }
142: }
143: /*
144: * This routine saves the current game for use at a later date
145: */
146: save() {
147:
148: reg char *sp;
149: reg int outf, num;
150: TIME tme, *tp;
151: int *dat_end, junk[18];
152: unsgn start, end;
153:
154: tp = &tme;
155: printf("Which file do you wish to save it in? ");
156: sp = buf;
157: while ((*sp++=getchar()) != '\n')
158: continue;
159: *--sp = '\0';
160:
161: /*
162: * check for existing files, and confirm overwrite if needed
163: */
164:
165: if (stat(buf, junk) > -1
166: && getyn("File exists. Do you wish to overwrite? ", yn_only) > 0)
167: return;
168:
169: if ((outf=creat(buf, 0644)) < 0) {
170: perror(buf);
171: return;
172: }
173: printf("\"%s\" ", buf);
174: time(tp); /* get current time */
175: strcpy(buf, ctime(tp));
176: for (sp = buf; *sp != '\n'; sp++)
177: continue;
178: *sp = '\0';
179: # if 0
180: start = (((int) etext + (SEGSIZE-1)) / SEGSIZE ) * SEGSIZE;
181: # else
182: start = 0;
183: # endif
184: end = sbrk(0);
185: while (start < end) { /* write out entire data space */
186: num = start + 16 * 1024 > end ? end - start : 16 * 1024;
187: write(outf, start, num);
188: start += num;
189: }
190: close(outf);
191: printf("[%s]\n", buf);
192: }
193: /*
194: * This routine restores an old game from a file
195: */
196: restore() {
197:
198: reg char *sp;
199:
200: printf("Which file do you wish to restore from? ");
201: for (sp = buf; (*sp=getchar()) != '\n'; sp++)
202: continue;
203: *sp = '\0';
204: rest_f(buf);
205: }
206: /*
207: * This does the actual restoring. It returns TRUE if the
208: * backup was successful, else false.
209: */
210: rest_f(file)
211: reg char *file; {
212:
213: reg char *sp;
214: reg int inf, num;
215: char buf[80];
216: unsgn start, end;
217: STAT sbuf;
218:
219: if ((inf=open(file, 0)) < 0) {
220: perror(file);
221: return FALSE;
222: }
223: printf("\"%s\" ", file);
224: if (fstat(inf, &sbuf) < 0) { /* get file stats */
225: perror(file);
226: exit(1);
227: }
228: # if 0
229: start = (((int) etext + (SEGSIZE-1)) / SEGSIZE ) * SEGSIZE;
230: # else
231: start = 0;
232: # endif
233: brk(end = start + sbuf.st_size);
234: while (start < end) { /* write out entire data space */
235: num = start + 16 * 1024 > end ? end - start : 16 * 1024;
236: read(inf, start, num);
237: start += num;
238: }
239: close(inf);
240: strcpy(buf, ctime(sbuf.st_mtime));
241: for (sp = buf; *sp != '\n'; sp++)
242: continue;
243: *sp = '\0';
244: printf("[%s]\n", buf);
245: return TRUE;
246: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.