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