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