![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / games / backgammon|
Return to main.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / games / backgammon |
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: char copyright[] =
20: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
21: All rights reserved.\n";
22: #endif /* not lint */
23:
24: #ifndef lint
25: static char sccsid[] = "@(#)main.c 5.5 (Berkeley) 6/18/88";
26: #endif /* not lint */
27:
28: #include <stdio.h>
29: #include "back.h"
30:
31: #define MVPAUSE 5 /* time to sleep when stuck */
32: #define MAXUSERS 35 /* maximum number of users */
33:
34: char *instr[]; /* text of instructions */
35: char *message[]; /* update message */
36: char ospeed; /* tty output speed */
37:
38: char *helpm[] = { /* help message */
39: "Enter a space or newline to roll, or",
40: " R to reprint the board\tD to double",
41: " S to save the game\tQ to quit",
42: 0
43: };
44:
45: char *contin[] = { /* pause message */
46: "(Type a newline to continue.)",
47: "",
48: 0
49: };
50:
51: static char user1a[] =
52: "Sorry, you cannot play backgammon when there are more than ";
53: static char user1b[] =
54: " users\non the system.";
55: static char user2a[] =
56: "\nThere are now more than ";
57: static char user2b[] =
58: " users on the system, so you cannot play\nanother game. ";
59: static char rules[] = "\nDo you want the rules of the game?";
60: static char noteach[] = "Teachgammon not available!\n\007";
61: static char need[] = "Do you need instructions for this program?";
62: static char askcol[] =
63: "Enter 'r' to play red, 'w' to play white, 'b' to play both:";
64: static char rollr[] = "Red rolls a ";
65: static char rollw[] = ". White rolls a ";
66: static char rstart[] = ". Red starts.\n";
67: static char wstart[] = ". White starts.\n";
68: static char toobad1[] = "Too bad, ";
69: static char unable[] = " is unable to use that roll.\n";
70: static char toobad2[] = ". Too bad, ";
71: static char cantmv[] = " can't move.\n";
72: static char bgammon[] = "Backgammon! ";
73: static char gammon[] = "Gammon! ";
74: static char again[] = ".\nWould you like to play again?";
75: static char svpromt[] = "Would you like to save this game?";
76:
77: static char password[] = "losfurng";
78: static char pbuf[10];
79:
80: main (argc,argv)
81: int argc;
82: char **argv;
83:
84: {
85: register int i; /* non-descript index */
86: register int l; /* non-descript index */
87: register char c; /* non-descript character storage */
88: long t; /* time for random num generator */
89:
90: /* initialization */
91: bflag = 2; /* default no board */
92: signal (2,getout); /* trap interrupts */
93: if (gtty (0,&tty) == -1) /* get old tty mode */
94: errexit ("backgammon(gtty)");
95: old = tty.sg_flags;
96: #ifdef V7
97: raw = ((noech = old & ~ECHO) | CBREAK); /* set up modes */
98: #else
99: raw = ((noech = old & ~ECHO) | RAW); /* set up modes */
100: #endif
101: ospeed = tty.sg_ospeed; /* for termlib */
102:
103: /* check user count */
104: # ifdef CORY
105: if (ucount() > MAXUSERS) {
106: writel (user1a);
107: wrint (MAXUSERS);
108: writel (user1b);
109: getout();
110: }
111: # endif
112:
113: /* get terminal
114: * capabilities, and
115: * decide if it can
116: * cursor address */
117: tflag = getcaps (getenv ("TERM"));
118: /* use whole screen
119: * for text */
120: if (tflag)
121: begscr = 0;
122: t = time(0);
123: srandom(t); /* 'random' seed */
124:
125: #ifdef V7
126: while (*++argv != 0) /* process arguments */
127: #else
128: while (*++argv != -1) /* process arguments */
129: #endif
130: getarg (&argv);
131: args[acnt] = '\0';
132: if (tflag) { /* clear screen */
133: noech &= ~(CRMOD|XTABS);
134: raw &= ~(CRMOD|XTABS);
135: clear();
136: }
137: fixtty (raw); /* go into raw mode */
138:
139: /* check if restored
140: * game and save flag
141: * for later */
142: if (rfl = rflag) {
143: text (message); /* print message */
144: text (contin);
145: wrboard(); /* print board */
146: /* if new game, pretend
147: * to be a non-restored
148: * game */
149: if (cturn == 0)
150: rflag = 0;
151: } else {
152: rscore = wscore = 0; /* zero score */
153: text (message); /* update message
154: * without pausing */
155:
156: if (aflag) { /* print rules */
157: writel (rules);
158: if (yorn(0)) {
159:
160: fixtty (old); /* restore tty */
161: execl (TEACH,"teachgammon",args,0);
162:
163: tflag = 0; /* error! */
164: writel (noteach);
165: exit();
166: } else { /* if not rules, then
167: * instructions */
168: writel (need);
169: if (yorn(0)) { /* print instructions */
170: clear();
171: text (instr);
172: }
173: }
174: }
175:
176: init(); /* initialize board */
177:
178: if (pnum == 2) { /* ask for color(s) */
179: writec ('\n');
180: writel (askcol);
181: while (pnum == 2) {
182: c = readc();
183: switch (c) {
184:
185: case 'R': /* red */
186: pnum = -1;
187: break;
188:
189: case 'W': /* white */
190: pnum = 1;
191: break;
192:
193: case 'B': /* both */
194: pnum = 0;
195: break;
196:
197: case 'P':
198: if (iroll)
199: break;
200: if (tflag)
201: curmove (curr,0);
202: else
203: writec ('\n');
204: writel ("Password:");
205: signal (14,getout);
206: cflag = 1;
207: alarm (10);
208: for (i = 0; i < 10; i++) {
209: pbuf[i] = readc();
210: if (pbuf[i] == '\n')
211: break;
212: }
213: if (i == 10)
214: while (readc() != '\n');
215: alarm (0);
216: cflag = 0;
217: if (i < 10)
218: pbuf[i] = '\0';
219: for (i = 0; i < 9; i++)
220: if (pbuf[i] != password[i])
221: getout();
222: iroll = 1;
223: if (tflag)
224: curmove (curr,0);
225: else
226: writec ('\n');
227: writel (askcol);
228: break;
229:
230: default: /* error */
231: writec ('\007');
232: }
233: }
234: } else if (!aflag)
235: /* pause to read
236: * message */
237: text (contin);
238:
239: wrboard(); /* print board */
240:
241: if (tflag)
242: curmove (18,0);
243: else
244: writec ('\n');
245: }
246: /* limit text to bottom
247: * of screen */
248: if (tflag)
249: begscr = 17;
250:
251: for (;;) { /* begin game! */
252: /* initial roll if
253: * needed */
254: if ((! rflag) || raflag)
255: roll();
256:
257: /* perform ritual of
258: * first roll */
259: if (! rflag) {
260: if (tflag)
261: curmove (17,0);
262: while (D0 == D1) /* no doubles */
263: roll();
264:
265: /* print rolls */
266: writel (rollr);
267: writec (D0+'0');
268: writel (rollw);
269: writec (D1+'0');
270:
271: /* winner goes first */
272: if (D0 > D1) {
273: writel (rstart);
274: cturn = 1;
275: } else {
276: writel (wstart);
277: cturn = -1;
278: }
279: }
280:
281: /* initalize variables
282: * according to whose
283: * turn it is */
284:
285: if (cturn == 1) { /* red */
286: home = 25;
287: bar = 0;
288: inptr = &in[1];
289: inopp = &in[0];
290: offptr = &off[1];
291: offopp = &off[0];
292: Colorptr = &color[1];
293: colorptr = &color[3];
294: colen = 3;
295: } else { /* white */
296: home = 0;
297: bar = 25;
298: inptr = &in[0];
299: inopp = &in[1];
300: offptr = &off[0];
301: offopp = &off[1];
302: Colorptr = &color[0];
303: colorptr = &color[2];
304: colen = 5;
305: }
306:
307: /* do first move
308: * (special case) */
309: if (! (rflag && raflag)) {
310: if (cturn == pnum) /* computer's move */
311: move (0);
312: else { /* player's move */
313: mvlim = movallow();
314: /* reprint roll */
315: if (tflag)
316: curmove (cturn == -1? 18: 19,0);
317: proll();
318: getmove(); /* get player's move */
319: }
320: }
321: if (tflag) {
322: curmove (17,0);
323: cline();
324: begscr = 18;
325: }
326:
327: /* no longer any diff-
328: * erence between normal
329: * game and recovered
330: * game. */
331: rflag = 0;
332:
333: /* move as long as it's
334: * someone's turn */
335: while (cturn == 1 || cturn == -1) {
336:
337: /* board maintainence */
338: if (tflag)
339: refresh(); /* fix board */
340: else
341: /* redo board if -p */
342: if (cturn == bflag || bflag == 0)
343: wrboard();
344:
345: /* do computer's move */
346: if (cturn == pnum) {
347: move (1);
348:
349: /* see if double
350: * refused */
351: if (cturn == -2 || cturn == 2)
352: break;
353:
354: /* check for winning
355: * move */
356: if (*offopp == 15) {
357: cturn *= -2;
358: break;
359: }
360: continue;
361:
362: }
363:
364: /* (player's move) */
365:
366: /* clean screen if
367: * safe */
368: if (tflag && hflag) {
369: curmove (20,0);
370: clend ();
371: hflag = 1;
372: }
373:
374: /* if allowed, give him
375: * a chance to double */
376: if (dlast != cturn && gvalue < 64) {
377: if (tflag)
378: curmove (cturn == -1? 18: 19,0);
379: writel (*Colorptr);
380: c = readc();
381:
382: /* character cases */
383: switch (c) {
384:
385: /* reprint board */
386: case 'R':
387: wrboard();
388: break;
389:
390: /* save game */
391: case 'S':
392: raflag = 1;
393: save (1);
394: break;
395:
396: /* quit */
397: case 'Q':
398: quit();
399: break;
400:
401: /* double */
402: case 'D':
403: dble();
404: break;
405:
406: /* roll */
407: case ' ':
408: case '\n':
409: roll();
410: writel (" rolls ");
411: writec (D0+'0');
412: writec (' ');
413: writec (D1+'0');
414: writel (". ");
415:
416: /* see if he can move */
417: if ( (mvlim = movallow()) == 0) {
418:
419: /* can't move */
420: writel (toobad1);
421: writel (*colorptr);
422: writel (unable);
423: if (tflag) {
424: if (pnum) {
425: buflush();
426: sleep (MVPAUSE);
427: }
428: }
429: nexturn();
430: break;
431: }
432:
433: /* get move */
434: getmove();
435:
436: /* okay to clean
437: * screen */
438: hflag = 1;
439: break;
440:
441: /* invalid character */
442: default:
443:
444: /* print help message */
445: if (tflag)
446: curmove (20,0);
447: else
448: writec ('\n');
449: text (helpm);
450: if (tflag)
451: curmove (cturn == -1? 18: 19,0);
452: else
453: writec ('\n');
454:
455: /* don't erase */
456: hflag = 0;
457: }
458: } else { /* couldn't double */
459:
460: /* print roll */
461: roll();
462: if (tflag)
463: curmove (cturn == -1? 18: 19,0);
464: proll ();
465:
466: /* can he move? */
467: if ((mvlim = movallow()) == 0) {
468:
469: /* he can't */
470: writel (toobad2);
471: writel (*colorptr);
472: writel (cantmv);
473: buflush();
474: sleep (MVPAUSE);
475: nexturn();
476: continue;
477: }
478:
479: /* get move */
480: getmove();
481: }
482: }
483:
484: /* don't worry about who
485: * won if quit */
486: if (cturn == 0)
487: break;
488:
489: /* fix cturn = winner */
490: cturn /= -2;
491:
492: /* final board pos. */
493: if (tflag)
494: refresh();
495:
496: /* backgammon? */
497: mflag = 0;
498: l = bar+7*cturn;
499: for (i = bar; i != l; i += cturn)
500: if (board[i]*cturn) mflag++;
501:
502: /* compute game value */
503: if (tflag)
504: curmove (20,0);
505: if (*offopp == 15) {
506: if (mflag) {
507: writel (bgammon);
508: gvalue *= 3;
509: }
510: else if (*offptr <= 0) {
511: writel (gammon);
512: gvalue *= 2;
513: }
514: }
515:
516: /* report situation */
517: if (cturn == -1) {
518: writel ("Red wins ");
519: rscore += gvalue;
520: } else {
521: writel ("White wins ");
522: wscore += gvalue;
523: }
524: wrint (gvalue);
525: writel (" point");
526: if (gvalue > 1)
527: writec ('s');
528: writel (".\n");
529:
530: /* write score */
531: wrscore();
532:
533: /* check user count */
534: # ifdef CORY
535: if (ucount() > MAXUSERS) {
536: writel (user2a);
537: wrint (MAXUSERS);
538: writel (user2b);
539: rfl = 1;
540: break;
541: }
542: # endif
543:
544: /* see if he wants
545: * another game */
546: writel (again);
547: if ((i = yorn ('S')) == 0)
548: break;
549:
550: init();
551: if (i == 2) {
552: writel (" Save.\n");
553: cturn = 0;
554: save (0);
555: }
556:
557: /* yes, reset game */
558: wrboard();
559: }
560:
561: /* give him a chance to save if game was recovered */
562: if (rfl && cturn) {
563: writel (svpromt);
564: if (yorn (0)) {
565: /* re-initialize for
566: * recovery */
567: init();
568: cturn = 0;
569: save(0);
570: }
571: }
572:
573: /* leave peacefully */
574: getout ();
575: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.