![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to crib.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / cribbage|
Return to crib.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / cribbage |
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: char copyright[] =
22: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)crib.c 5.5 (Berkeley) 6/1/90";
28: #endif /* not lint */
29:
30: # include <sys/signal.h>
31: # include <curses.h>
32: # include "deck.h"
33: # include "cribbage.h"
34: # include "cribcur.h"
35: # include "pathnames.h"
36:
37: main(argc, argv)
38: int argc;
39: char *argv[];
40: {
41: extern char *optarg;
42: extern int optind;
43: register char *p;
44: int ch;
45: BOOLEAN playing;
46: char *s; /* for reading arguments */
47: FILE *f;
48: FILE *fopen();
49: char *getline(), *getlogin();
50: void rint();
51:
52: while ((ch = getopt(argc, argv, "eqr")) != EOF)
53: switch(ch) {
54: case 'e':
55: explain = TRUE;
56: break;
57: case 'q':
58: quiet = TRUE;
59: break;
60: case 'r':
61: rflag = TRUE;
62: break;
63: case '?':
64: default:
65: (void) fprintf(stderr, "usage: cribbage [-eqr]\n");
66: exit(1);
67: }
68:
69: initscr();
70: signal(SIGINT, rint);
71: crmode();
72: noecho();
73: Playwin = subwin(stdscr, PLAY_Y, PLAY_X, 0, 0);
74: Tablewin = subwin(stdscr, TABLE_Y, TABLE_X, 0, PLAY_X);
75: Compwin = subwin(stdscr, COMP_Y, COMP_X, 0, TABLE_X + PLAY_X);
76: Msgwin = subwin(stdscr, MSG_Y, MSG_X, Y_MSG_START, SCORE_X + 1);
77: leaveok(Playwin, TRUE);
78: leaveok(Tablewin, TRUE);
79: leaveok(Compwin, TRUE);
80: clearok(stdscr, FALSE);
81:
82: if (!quiet) {
83: msg("Do you need instructions for cribbage? ");
84: if (getuchar() == 'Y') {
85: endwin();
86: clear();
87: mvcur(0, COLS - 1, LINES - 1, 0);
88: fflush(stdout);
89: instructions();
90: crmode();
91: noecho();
92: clear();
93: refresh();
94: msg("For the rules of this program, do \"man cribbage\"");
95: }
96: }
97: playing = TRUE;
98: do {
99: wclrtobot(Msgwin);
100: msg(quiet ? "L or S? " : "Long (to 121) or Short (to 61)? ");
101: if (glimit == SGAME)
102: glimit = (getuchar() == 'L' ? LGAME : SGAME);
103: else
104: glimit = (getuchar() == 'S' ? SGAME : LGAME);
105: game();
106: msg("Another game? ");
107: playing = (getuchar() == 'Y');
108: } while (playing);
109:
110: if (f = fopen(_PATH_LOG, "a")) {
111: (void)fprintf(f, "%s: won %5.5d, lost %5.5d\n",
112: getlogin(), cgames, pgames);
113: (void)fclose(f);
114: }
115: bye();
116: if (!f) {
117: (void)fprintf(stderr, "\ncribbage: can't open %s.\n",
118: _PATH_LOG);
119: exit(1);
120: }
121: exit(0);
122: }
123:
124: /*
125: * makeboard:
126: * Print out the initial board on the screen
127: */
128: makeboard()
129: {
130: mvaddstr(SCORE_Y + 0, SCORE_X, "+---------------------------------------+");
131: mvaddstr(SCORE_Y + 1, SCORE_X, "| Score: 0 YOU |");
132: mvaddstr(SCORE_Y + 2, SCORE_X, "| *.....:.....:.....:.....:.....:..... |");
133: mvaddstr(SCORE_Y + 3, SCORE_X, "| *.....:.....:.....:.....:.....:..... |");
134: mvaddstr(SCORE_Y + 4, SCORE_X, "| |");
135: mvaddstr(SCORE_Y + 5, SCORE_X, "| *.....:.....:.....:.....:.....:..... |");
136: mvaddstr(SCORE_Y + 6, SCORE_X, "| *.....:.....:.....:.....:.....:..... |");
137: mvaddstr(SCORE_Y + 7, SCORE_X, "| Score: 0 ME |");
138: mvaddstr(SCORE_Y + 8, SCORE_X, "+---------------------------------------+");
139: gamescore();
140: }
141:
142: /*
143: * gamescore:
144: * Print out the current game score
145: */
146: gamescore()
147: {
148: extern int Lastscore[];
149:
150: if (pgames || cgames) {
151: mvprintw(SCORE_Y + 1, SCORE_X + 28, "Games: %3d", pgames);
152: mvprintw(SCORE_Y + 7, SCORE_X + 28, "Games: %3d", cgames);
153: }
154: Lastscore[0] = -1;
155: Lastscore[1] = -1;
156: }
157:
158: /*
159: * game:
160: * Play one game up to glimit points. Actually, we only ASK the
161: * player what card to turn. We do a random one, anyway.
162: */
163: game()
164: {
165: register int i, j;
166: BOOLEAN flag;
167: BOOLEAN compcrib;
168:
169: makeboard();
170: refresh();
171: makedeck(deck);
172: shuffle(deck);
173: if (gamecount == 0) {
174: flag = TRUE;
175: do {
176: if (!rflag) { /* player cuts deck */
177: msg(quiet ? "Cut for crib? " :
178: "Cut to see whose crib it is -- low card wins? ");
179: getline();
180: }
181: i = (rand() >> 4) % CARDS; /* random cut */
182: do { /* comp cuts deck */
183: j = (rand() >> 4) % CARDS;
184: } while (j == i);
185: addmsg(quiet ? "You cut " : "You cut the ");
186: msgcard(deck[i], FALSE);
187: endmsg();
188: addmsg(quiet ? "I cut " : "I cut the ");
189: msgcard(deck[j], FALSE);
190: endmsg();
191: flag = (deck[i].rank == deck[j].rank);
192: if (flag) {
193: msg(quiet ? "We tied..." :
194: "We tied and have to try again...");
195: shuffle(deck);
196: continue;
197: }
198: else
199: compcrib = (deck[i].rank > deck[j].rank);
200: } while (flag);
201: }
202: else {
203: werase(Tablewin);
204: wrefresh(Tablewin);
205: werase(Compwin);
206: wrefresh(Compwin);
207: msg("Loser (%s) gets first crib", (iwon ? "you" : "me"));
208: compcrib = !iwon;
209: }
210:
211: pscore = cscore = 0;
212: flag = TRUE;
213: do {
214: shuffle(deck);
215: flag = !playhand(compcrib);
216: compcrib = !compcrib;
217: } while (flag);
218: ++gamecount;
219: if (cscore < pscore) {
220: if (glimit - cscore > 60) {
221: msg("YOU DOUBLE SKUNKED ME!");
222: pgames += 4;
223: }
224: else if (glimit - cscore > 30) {
225: msg("YOU SKUNKED ME!");
226: pgames += 2;
227: }
228: else {
229: msg("YOU WON!");
230: ++pgames;
231: }
232: iwon = FALSE;
233: }
234: else {
235: if (glimit - pscore > 60) {
236: msg("I DOUBLE SKUNKED YOU!");
237: cgames += 4;
238: }
239: else if (glimit - pscore > 30) {
240: msg("I SKUNKED YOU!");
241: cgames += 2;
242: }
243: else {
244: msg("I WON!");
245: ++cgames;
246: }
247: iwon = TRUE;
248: }
249: gamescore();
250: }
251:
252: /*
253: * playhand:
254: * Do up one hand of the game
255: */
256: playhand(mycrib)
257: BOOLEAN mycrib;
258: {
259: register int deckpos;
260: extern char Msgbuf[];
261:
262: werase(Compwin);
263:
264: knownum = 0;
265: deckpos = deal(mycrib);
266: sorthand(chand, FULLHAND);
267: sorthand(phand, FULLHAND);
268: makeknown(chand, FULLHAND);
269: prhand(phand, FULLHAND, Playwin, FALSE);
270: discard(mycrib);
271: if (cut(mycrib, deckpos))
272: return TRUE;
273: if (peg(mycrib))
274: return TRUE;
275: werase(Tablewin);
276: wrefresh(Tablewin);
277: if (score(mycrib))
278: return TRUE;
279: return FALSE;
280: }
281:
282:
283:
284: /*
285: * deal cards to both players from deck
286: */
287:
288: deal( mycrib )
289: {
290: register int i, j;
291:
292: j = 0;
293: for( i = 0; i < FULLHAND; i++ ) {
294: if( mycrib ) {
295: phand[i] = deck[j++];
296: chand[i] = deck[j++];
297: }
298: else {
299: chand[i] = deck[j++];
300: phand[i] = deck[j++];
301: }
302: }
303: return( j );
304: }
305:
306: /*
307: * discard:
308: * Handle players discarding into the crib...
309: * Note: we call cdiscard() after prining first message so player doesn't wait
310: */
311: discard(mycrib)
312: BOOLEAN mycrib;
313: {
314: register char *prompt;
315: CARD crd;
316:
317: prcrib(mycrib, TRUE);
318: prompt = (quiet ? "Discard --> " : "Discard a card --> ");
319: cdiscard(mycrib); /* puts best discard at end */
320: crd = phand[infrom(phand, FULLHAND, prompt)];
321: remove(crd, phand, FULLHAND);
322: prhand(phand, FULLHAND, Playwin, FALSE);
323: crib[0] = crd;
324: /* next four lines same as last four except for cdiscard() */
325: crd = phand[infrom(phand, FULLHAND - 1, prompt)];
326: remove(crd, phand, FULLHAND - 1);
327: prhand(phand, FULLHAND, Playwin, FALSE);
328: crib[1] = crd;
329: crib[2] = chand[4];
330: crib[3] = chand[5];
331: chand[4].rank = chand[4].suit = chand[5].rank = chand[5].suit = EMPTY;
332: }
333:
334: /*
335: * cut:
336: * Cut the deck and set turnover. Actually, we only ASK the
337: * player what card to turn. We do a random one, anyway.
338: */
339: cut(mycrib, pos)
340: BOOLEAN mycrib;
341: int pos;
342: {
343: register int i, cardx;
344: BOOLEAN win = FALSE;
345:
346: if (mycrib) {
347: if (!rflag) { /* random cut */
348: msg(quiet ? "Cut the deck? " :
349: "How many cards down do you wish to cut the deck? ");
350: getline();
351: }
352: i = (rand() >> 4) % (CARDS - pos);
353: turnover = deck[i + pos];
354: addmsg(quiet ? "You cut " : "You cut the ");
355: msgcard(turnover, FALSE);
356: endmsg();
357: if (turnover.rank == JACK) {
358: msg("I get two for his heels");
359: win = chkscr(&cscore,2 );
360: }
361: }
362: else {
363: i = (rand() >> 4) % (CARDS - pos) + pos;
364: turnover = deck[i];
365: addmsg(quiet ? "I cut " : "I cut the ");
366: msgcard(turnover, FALSE);
367: endmsg();
368: if (turnover.rank == JACK) {
369: msg("You get two for his heels");
370: win = chkscr(&pscore, 2);
371: }
372: }
373: makeknown(&turnover, 1);
374: prcrib(mycrib, FALSE);
375: return win;
376: }
377:
378: /*
379: * prcrib:
380: * Print out the turnover card with crib indicator
381: */
382: prcrib(mycrib, blank)
383: BOOLEAN mycrib, blank;
384: {
385: register int y, cardx;
386:
387: if (mycrib)
388: cardx = CRIB_X;
389: else
390: cardx = 0;
391:
392: mvaddstr(CRIB_Y, cardx + 1, "CRIB");
393: prcard(stdscr, CRIB_Y + 1, cardx, turnover, blank);
394:
395: if (mycrib)
396: cardx = 0;
397: else
398: cardx = CRIB_X;
399:
400: for (y = CRIB_Y; y <= CRIB_Y + 5; y++)
401: mvaddstr(y, cardx, " ");
402: }
403:
404: /*
405: * peg:
406: * Handle all the pegging...
407: */
408:
409: static CARD Table[14];
410:
411: static int Tcnt;
412:
413: peg(mycrib)
414: BOOLEAN mycrib;
415: {
416: static CARD ch[CINHAND], ph[CINHAND];
417: CARD crd;
418: register int i, j, k;
419: register int l;
420: register int cnum, pnum, sum;
421: register BOOLEAN myturn, mego, ugo, last, played;
422:
423: cnum = pnum = CINHAND;
424: for (i = 0; i < CINHAND; i++) { /* make copies of hands */
425: ch[i] = chand[i];
426: ph[i] = phand[i];
427: }
428: Tcnt = 0; /* index to table of cards played */
429: sum = 0; /* sum of cards played */
430: mego = ugo = FALSE;
431: myturn = !mycrib;
432: for (;;) {
433: last = TRUE; /* enable last flag */
434: prhand(ph, pnum, Playwin, FALSE);
435: prhand(ch, cnum, Compwin, TRUE);
436: prtable(sum);
437: if (myturn) { /* my tyrn to play */
438: if (!anymove(ch, cnum, sum)) { /* if no card to play */
439: if (!mego && cnum) { /* go for comp? */
440: msg("GO");
441: mego = TRUE;
442: }
443: if (anymove(ph, pnum, sum)) /* can player move? */
444: myturn = !myturn;
445: else { /* give him his point */
446: msg(quiet ? "You get one" : "You get one point");
447: if (chkscr(&pscore, 1))
448: return TRUE;
449: sum = 0;
450: mego = ugo = FALSE;
451: Tcnt = 0;
452: }
453: }
454: else {
455: played = TRUE;
456: j = -1;
457: k = 0;
458: for (i = 0; i < cnum; i++) { /* maximize score */
459: l = pegscore(ch[i], Table, Tcnt, sum);
460: if (l > k) {
461: k = l;
462: j = i;
463: }
464: }
465: if (j < 0) /* if nothing scores */
466: j = cchose(ch, cnum, sum);
467: crd = ch[j];
468: remove(crd, ch, cnum--);
469: sum += VAL(crd.rank);
470: Table[Tcnt++] = crd;
471: if (k > 0) {
472: addmsg(quiet ? "I get %d playing " :
473: "I get %d points playing ", k);
474: msgcard(crd, FALSE);
475: endmsg();
476: if (chkscr(&cscore, k))
477: return TRUE;
478: }
479: myturn = !myturn;
480: }
481: }
482: else {
483: if (!anymove(ph, pnum, sum)) { /* can player move? */
484: if (!ugo && pnum) { /* go for player */
485: msg("You have a GO");
486: ugo = TRUE;
487: }
488: if (anymove(ch, cnum, sum)) /* can computer play? */
489: myturn = !myturn;
490: else {
491: msg(quiet ? "I get one" : "I get one point");
492: do_wait();
493: if (chkscr(&cscore, 1))
494: return TRUE;
495: sum = 0;
496: mego = ugo = FALSE;
497: Tcnt = 0;
498: }
499: }
500: else { /* player plays */
501: played = FALSE;
502: if (pnum == 1) {
503: crd = ph[0];
504: msg("You play your last card");
505: }
506: else
507: for (;;) {
508: prhand(ph, pnum, Playwin, FALSE);
509: crd = ph[infrom(ph, pnum, "Your play: ")];
510: if (sum + VAL(crd.rank) <= 31)
511: break;
512: else
513: msg("Total > 31 -- try again");
514: }
515: makeknown(&crd, 1);
516: remove(crd, ph, pnum--);
517: i = pegscore(crd, Table, Tcnt, sum);
518: sum += VAL(crd.rank);
519: Table[Tcnt++] = crd;
520: if (i > 0) {
521: msg(quiet ? "You got %d" : "You got %d points", i);
522: if (chkscr(&pscore, i))
523: return TRUE;
524: }
525: myturn = !myturn;
526: }
527: }
528: if (sum >= 31) {
529: if (!myturn)
530: do_wait();
531: sum = 0;
532: mego = ugo = FALSE;
533: Tcnt = 0;
534: last = FALSE; /* disable last flag */
535: }
536: if (!pnum && !cnum)
537: break; /* both done */
538: }
539: prhand(ph, pnum, Playwin, FALSE);
540: prhand(ch, cnum, Compwin, TRUE);
541: prtable(sum);
542: if (last)
543: if (played) {
544: msg(quiet ? "I get one for last" : "I get one point for last");
545: do_wait();
546: if (chkscr(&cscore, 1))
547: return TRUE;
548: }
549: else {
550: msg(quiet ? "You get one for last" :
551: "You get one point for last");
552: if (chkscr(&pscore, 1))
553: return TRUE;
554: }
555: return FALSE;
556: }
557:
558: /*
559: * prtable:
560: * Print out the table with the current score
561: */
562: prtable(score)
563: int score;
564: {
565: prhand(Table, Tcnt, Tablewin, FALSE);
566: mvwprintw(Tablewin, (Tcnt + 2) * 2, Tcnt + 1, "%2d", score);
567: wrefresh(Tablewin);
568: }
569:
570: /*
571: * score:
572: * Handle the scoring of the hands
573: */
574: score(mycrib)
575: BOOLEAN mycrib;
576: {
577: sorthand(crib, CINHAND);
578: if (mycrib) {
579: if (plyrhand(phand, "hand"))
580: return TRUE;
581: if (comphand(chand, "hand"))
582: return TRUE;
583: do_wait();
584: if (comphand(crib, "crib"))
585: return TRUE;
586: }
587: else {
588: if (comphand(chand, "hand"))
589: return TRUE;
590: if (plyrhand(phand, "hand"))
591: return TRUE;
592: if (plyrhand(crib, "crib"))
593: return TRUE;
594: }
595: return FALSE;
596: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.