![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / games / cribbage|
Return to io.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / 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 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[] = "@(#)io.c 5.4 (Berkeley) 6/18/88";
20: #endif /* not lint */
21:
22: # include <curses.h>
23: # include <ctype.h>
24: # include <signal.h>
25: # include "deck.h"
26: # include "cribbage.h"
27: # include "cribcur.h"
28:
29: # define LINESIZE 128
30:
31: # ifdef CTRL
32: # undef CTRL
33: # endif
34: # define CTRL(X) ('X' - 'A' + 1)
35:
36: # ifdef notdef /* defined in curses.h */
37: # define erasechar() _tty.sg_erase
38: # define killchar() _tty.sg_kill
39: # endif
40:
41: char linebuf[ LINESIZE ];
42:
43: char *rankname[ RANKS ] = { "ACE", "TWO", "THREE", "FOUR",
44: "FIVE", "SIX", "SEVEN", "EIGHT",
45: "NINE", "TEN", "JACK", "QUEEN",
46: "KING" };
47:
48: char *rankchar[ RANKS ] = { "A", "2", "3", "4", "5", "6", "7",
49: "8", "9", "T", "J", "Q", "K" };
50:
51: char *suitname[ SUITS ] = { "SPADES", "HEARTS", "DIAMONDS",
52: "CLUBS" };
53:
54: char *suitchar[ SUITS ] = { "S", "H", "D", "C" };
55:
56:
57:
58: /*
59: * msgcard:
60: * Call msgcrd in one of two forms
61: */
62: msgcard(c, brief)
63: CARD c;
64: BOOLEAN brief;
65: {
66: if (brief)
67: return msgcrd(c, TRUE, (char *) NULL, TRUE);
68: else
69: return msgcrd(c, FALSE, " of ", FALSE);
70: }
71:
72:
73:
74: /*
75: * msgcrd:
76: * Print the value of a card in ascii
77: */
78: msgcrd(c, brfrank, mid, brfsuit)
79: CARD c;
80: char *mid;
81: BOOLEAN brfrank, brfsuit;
82: {
83: if (c.rank == EMPTY || c.suit == EMPTY)
84: return FALSE;
85: if (brfrank)
86: addmsg("%1.1s", rankchar[c.rank]);
87: else
88: addmsg(rankname[c.rank]);
89: if (mid != NULL)
90: addmsg(mid);
91: if (brfsuit)
92: addmsg("%1.1s", suitchar[c.suit]);
93: else
94: addmsg(suitname[c.suit]);
95: return TRUE;
96: }
97:
98: /*
99: * printcard:
100: * Print out a card.
101: */
102: printcard(win, cardno, c, blank)
103: WINDOW *win;
104: int cardno;
105: CARD c;
106: BOOLEAN blank;
107: {
108: prcard(win, cardno * 2, cardno, c, blank);
109: }
110:
111: /*
112: * prcard:
113: * Print out a card on the window at the specified location
114: */
115: prcard(win, y, x, c, blank)
116: WINDOW *win;
117: int y, x;
118: CARD c;
119: BOOLEAN blank;
120: {
121: if (c.rank == EMPTY)
122: return;
123: mvwaddstr(win, y + 0, x, "+-----+");
124: mvwaddstr(win, y + 1, x, "| |");
125: mvwaddstr(win, y + 2, x, "| |");
126: mvwaddstr(win, y + 3, x, "| |");
127: mvwaddstr(win, y + 4, x, "+-----+");
128: if (!blank) {
129: mvwaddch(win, y + 1, x + 1, rankchar[c.rank][0]);
130: waddch(win, suitchar[c.suit][0]);
131: mvwaddch(win, y + 3, x + 4, rankchar[c.rank][0]);
132: waddch(win, suitchar[c.suit][0]);
133: }
134: }
135:
136: /*
137: * prhand:
138: * Print a hand of n cards
139: */
140: prhand(h, n, win, blank)
141: CARD h[];
142: int n;
143: WINDOW *win;
144: BOOLEAN blank;
145: {
146: register int i;
147:
148: werase(win);
149: for (i = 0; i < n; i++)
150: printcard(win, i, *h++, blank);
151: wrefresh(win);
152: }
153:
154:
155:
156: /*
157: * infrom:
158: * reads a card, supposedly in hand, accepting unambigous brief
159: * input, returns the index of the card found...
160: */
161: infrom(hand, n, prompt)
162: CARD hand[];
163: int n;
164: char *prompt;
165: {
166: register int i, j;
167: CARD crd;
168:
169: if (n < 1) {
170: printf("\nINFROM: %d = n < 1!!\n", n);
171: exit(74);
172: }
173: for (;;) {
174: msg(prompt);
175: if (incard(&crd)) { /* if card is full card */
176: if (!isone(crd, hand, n))
177: msg("That's not in your hand");
178: else {
179: for (i = 0; i < n; i++)
180: if (hand[i].rank == crd.rank &&
181: hand[i].suit == crd.suit)
182: break;
183: if (i >= n) {
184: printf("\nINFROM: isone or something messed up\n");
185: exit(77);
186: }
187: return i;
188: }
189: }
190: else /* if not full card... */
191: if (crd.rank != EMPTY) {
192: for (i = 0; i < n; i++)
193: if (hand[i].rank == crd.rank)
194: break;
195: if (i >= n)
196: msg("No such rank in your hand");
197: else {
198: for (j = i + 1; j < n; j++)
199: if (hand[j].rank == crd.rank)
200: break;
201: if (j < n)
202: msg("Ambiguous rank");
203: else
204: return i;
205: }
206: }
207: else
208: msg("Sorry, I missed that");
209: }
210: /* NOTREACHED */
211: }
212:
213:
214:
215: /*
216: * incard:
217: * Inputs a card in any format. It reads a line ending with a CR
218: * and then parses it.
219: */
220: incard(crd)
221: CARD *crd;
222: {
223: char *getline();
224: register int i;
225: int rnk, sut;
226: char *line, *p, *p1;
227: BOOLEAN retval;
228:
229: retval = FALSE;
230: rnk = sut = EMPTY;
231: if (!(line = getline()))
232: goto gotit;
233: p = p1 = line;
234: while( *p1 != ' ' && *p1 != NULL ) ++p1;
235: *p1++ = NULL;
236: if( *p == NULL ) goto gotit;
237: /* IMPORTANT: no real card has 2 char first name */
238: if( strlen(p) == 2 ) { /* check for short form */
239: rnk = EMPTY;
240: for( i = 0; i < RANKS; i++ ) {
241: if( *p == *rankchar[i] ) {
242: rnk = i;
243: break;
244: }
245: }
246: if( rnk == EMPTY ) goto gotit; /* it's nothing... */
247: ++p; /* advance to next char */
248: sut = EMPTY;
249: for( i = 0; i < SUITS; i++ ) {
250: if( *p == *suitchar[i] ) {
251: sut = i;
252: break;
253: }
254: }
255: if( sut != EMPTY ) retval = TRUE;
256: goto gotit;
257: }
258: rnk = EMPTY;
259: for( i = 0; i < RANKS; i++ ) {
260: if( !strcmp( p, rankname[i] ) || !strcmp( p, rankchar[i] ) ) {
261: rnk = i;
262: break;
263: }
264: }
265: if( rnk == EMPTY ) goto gotit;
266: p = p1;
267: while( *p1 != ' ' && *p1 != NULL ) ++p1;
268: *p1++ = NULL;
269: if( *p == NULL ) goto gotit;
270: if( !strcmp( "OF", p ) ) {
271: p = p1;
272: while( *p1 != ' ' && *p1 != NULL ) ++p1;
273: *p1++ = NULL;
274: if( *p == NULL ) goto gotit;
275: }
276: sut = EMPTY;
277: for( i = 0; i < SUITS; i++ ) {
278: if( !strcmp( p, suitname[i] ) || !strcmp( p, suitchar[i] ) ) {
279: sut = i;
280: break;
281: }
282: }
283: if( sut != EMPTY ) retval = TRUE;
284: gotit:
285: (*crd).rank = rnk;
286: (*crd).suit = sut;
287: return( retval );
288: }
289:
290:
291:
292: /*
293: * getuchar:
294: * Reads and converts to upper case
295: */
296: getuchar()
297: {
298: register int c;
299:
300: c = readchar();
301: if (islower(c))
302: c = toupper(c);
303: waddch(Msgwin, c);
304: return c;
305: }
306:
307: /*
308: * number:
309: * Reads in a decimal number and makes sure it is between "lo" and
310: * "hi" inclusive.
311: */
312: number(lo, hi, prompt)
313: int lo, hi;
314: char *prompt;
315: {
316: char *getline();
317: register char *p;
318: register int sum;
319:
320: sum = 0;
321: for (;;) {
322: msg(prompt);
323: if(!(p = getline()) || *p == NULL) {
324: msg(quiet ? "Not a number" : "That doesn't look like a number");
325: continue;
326: }
327: sum = 0;
328:
329: if (!isdigit(*p))
330: sum = lo - 1;
331: else
332: while (isdigit(*p)) {
333: sum = 10 * sum + (*p - '0');
334: ++p;
335: }
336:
337: if (*p != ' ' && *p != '\t' && *p != NULL)
338: sum = lo - 1;
339: if (sum >= lo && sum <= hi)
340: return sum;
341: if (sum == lo - 1)
342: msg("that doesn't look like a number, try again --> ");
343: else
344: msg("%d is not between %d and %d inclusive, try again --> ",
345: sum, lo, hi);
346: }
347: }
348:
349: /*
350: * msg:
351: * Display a message at the top of the screen.
352: */
353: char Msgbuf[BUFSIZ] = { '\0' };
354:
355: int Mpos = 0;
356:
357: static int Newpos = 0;
358:
359: /* VARARGS1 */
360: msg(fmt, args)
361: char *fmt;
362: int args;
363: {
364: doadd(fmt, &args);
365: endmsg();
366: }
367:
368: /*
369: * addmsg:
370: * Add things to the current message
371: */
372: /* VARARGS1 */
373: addmsg(fmt, args)
374: char *fmt;
375: int args;
376: {
377: doadd(fmt, &args);
378: }
379:
380: /*
381: * endmsg:
382: * Display a new msg.
383: */
384:
385: int Lineno = 0;
386:
387: endmsg()
388: {
389: register int len;
390: register char *mp, *omp;
391: static int lastline = 0;
392:
393: /*
394: * All messages should start with uppercase
395: */
396: mvaddch(lastline + Y_MSG_START, SCORE_X, ' ');
397: if (islower(Msgbuf[0]) && Msgbuf[1] != ')')
398: Msgbuf[0] = toupper(Msgbuf[0]);
399: mp = Msgbuf;
400: len = strlen(mp);
401: if (len / MSG_X + Lineno >= MSG_Y) {
402: while (Lineno < MSG_Y) {
403: wmove(Msgwin, Lineno++, 0);
404: wclrtoeol(Msgwin);
405: }
406: Lineno = 0;
407: }
408: mvaddch(Lineno + Y_MSG_START, SCORE_X, '*');
409: lastline = Lineno;
410: do {
411: mvwaddstr(Msgwin, Lineno, 0, mp);
412: if ((len = strlen(mp)) > MSG_X) {
413: omp = mp;
414: for (mp = &mp[MSG_X-1]; *mp != ' '; mp--)
415: continue;
416: while (*mp == ' ')
417: mp--;
418: mp++;
419: wmove(Msgwin, Lineno, mp - omp);
420: wclrtoeol(Msgwin);
421: }
422: if (++Lineno >= MSG_Y)
423: Lineno = 0;
424: } while (len > MSG_X);
425: wclrtoeol(Msgwin);
426: Mpos = len;
427: Newpos = 0;
428: wrefresh(Msgwin);
429: refresh();
430: wrefresh(Msgwin);
431: }
432:
433: /*
434: * doadd:
435: * Perform an add onto the message buffer
436: */
437: doadd(fmt, args)
438: char *fmt;
439: int *args;
440: {
441: static FILE junk;
442:
443: /*
444: * Do the printf into Msgbuf
445: */
446: junk._flag = _IOWRT + _IOSTRG;
447: junk._ptr = &Msgbuf[Newpos];
448: junk._cnt = 32767;
449: _doprnt(fmt, args, &junk);
450: putc('\0', &junk);
451: Newpos = strlen(Msgbuf);
452: }
453:
454: /*
455: * do_wait:
456: * Wait for the user to type ' ' before doing anything else
457: */
458: do_wait()
459: {
460: register int line;
461: static char prompt[] = { '-', '-', 'M', 'o', 'r', 'e', '-', '-', '\0' };
462:
463: if (Mpos + sizeof prompt < MSG_X)
464: wmove(Msgwin, Lineno > 0 ? Lineno - 1 : MSG_Y - 1, Mpos);
465: else {
466: mvwaddch(Msgwin, Lineno, 0, ' ');
467: wclrtoeol(Msgwin);
468: if (++Lineno >= MSG_Y)
469: Lineno = 0;
470: }
471: waddstr(Msgwin, prompt);
472: wrefresh(Msgwin);
473: wait_for(' ');
474: }
475:
476: /*
477: * wait_for
478: * Sit around until the guy types the right key
479: */
480: wait_for(ch)
481: register char ch;
482: {
483: register char c;
484:
485: if (ch == '\n')
486: while ((c = readchar()) != '\n')
487: continue;
488: else
489: while (readchar() != ch)
490: continue;
491: }
492:
493: /*
494: * readchar:
495: * Reads and returns a character, checking for gross input errors
496: */
497: readchar()
498: {
499: register int cnt, y, x;
500: auto char c;
501:
502: over:
503: cnt = 0;
504: while (read(0, &c, 1) <= 0)
505: if (cnt++ > 100) /* if we are getting infinite EOFs */
506: bye(); /* quit the game */
507: if (c == CTRL(L)) {
508: wrefresh(curscr);
509: goto over;
510: }
511: if (c == '\r')
512: return '\n';
513: else
514: return c;
515: }
516:
517: /*
518: * getline:
519: * Reads the next line up to '\n' or EOF. Multiple spaces are
520: * compressed to one space; a space is inserted before a ','
521: */
522: char *
523: getline()
524: {
525: register char *sp;
526: register int c, oy, ox;
527: register WINDOW *oscr;
528:
529: oscr = stdscr;
530: stdscr = Msgwin;
531: getyx(stdscr, oy, ox);
532: refresh();
533: /*
534: * loop reading in the string, and put it in a temporary buffer
535: */
536: for (sp = linebuf; (c = readchar()) != '\n'; clrtoeol(), refresh()) {
537: if (c == -1)
538: continue;
539: else if (c == erasechar()) { /* process erase character */
540: if (sp > linebuf) {
541: register int i;
542:
543: sp--;
544: for (i = strlen(unctrl(*sp)); i; i--)
545: addch('\b');
546: }
547: continue;
548: }
549: else if (c == killchar()) { /* process kill character */
550: sp = linebuf;
551: move(oy, ox);
552: continue;
553: }
554: else if (sp == linebuf && c == ' ')
555: continue;
556: if (sp >= &linebuf[LINESIZE-1] || !(isprint(c) || c == ' '))
557: putchar(CTRL(G));
558: else {
559: if (islower(c))
560: c = toupper(c);
561: *sp++ = c;
562: addstr(unctrl(c));
563: Mpos++;
564: }
565: }
566: *sp = '\0';
567: stdscr = oscr;
568: return linebuf;
569: }
570:
571: /*
572: * bye:
573: * Leave the program, cleaning things up as we go.
574: */
575: bye()
576: {
577: signal(SIGINT, SIG_IGN);
578: mvcur(0, COLS - 1, LINES - 1, 0);
579: fflush(stdout);
580: endwin();
581: putchar('\n');
582: exit(1);
583: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.