Initial import from FreeBSD RELENG_4:
[dragonfly.git] / games / cribbage / io.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright (c) 1980, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#ifndef lint
35#if 0
36static char sccsid[] = "@(#)io.c 8.1 (Berkeley) 5/31/93";
37#endif
38static const char rcsid[] =
39 "$FreeBSD: src/games/cribbage/io.c,v 1.5.2.2 2001/02/18 02:20:31 kris Exp $";
40#endif /* not lint */
41
42#include <ctype.h>
43#include <curses.h>
44#include <signal.h>
45#include <stdlib.h>
46#include <string.h>
47#include <termios.h>
48#include <unistd.h>
49
50#if __STDC__
51#include <stdarg.h>
52#else
53#include <varargs.h>
54#endif
55
56#include "deck.h"
57#include "cribbage.h"
58#include "cribcur.h"
59
60#define LINESIZE 128
61
62#ifdef CTRL
63#undef CTRL
64#endif
65#define CTRL(X) (X - 'A' + 1)
66
67char linebuf[LINESIZE];
68
69char *rankname[RANKS] = {
70 "ACE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN",
71 "EIGHT", "NINE", "TEN", "JACK", "QUEEN", "KING"
72};
73
74char *rankchar[RANKS] = {
75 "A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K"
76};
77
78char *suitname[SUITS] = {"SPADES", "HEARTS", "DIAMONDS", "CLUBS"};
79
80char *suitchar[SUITS] = {"S", "H", "D", "C"};
81
82/*
83 * msgcard:
84 * Call msgcrd in one of two forms
85 */
86int
87msgcard(c, brief)
88 CARD c;
89 BOOLEAN brief;
90{
91 if (brief)
92 return (msgcrd(c, TRUE, NULL, TRUE));
93 else
94 return (msgcrd(c, FALSE, " of ", FALSE));
95}
96
97/*
98 * msgcrd:
99 * Print the value of a card in ascii
100 */
101int
102msgcrd(c, brfrank, mid, brfsuit)
103 CARD c;
104 BOOLEAN brfrank, brfsuit;
105 char *mid;
106{
107 if (c.rank == EMPTY || c.suit == EMPTY)
108 return (FALSE);
109 if (brfrank)
110 addmsg("%1.1s", rankchar[c.rank]);
111 else
112 addmsg("%s", rankname[c.rank]);
113 if (mid != NULL)
114 addmsg("%s", mid);
115 if (brfsuit)
116 addmsg("%1.1s", suitchar[c.suit]);
117 else
118 addmsg("%s", suitname[c.suit]);
119 return (TRUE);
120}
121
122/*
123 * printcard:
124 * Print out a card.
125 */
126void
127printcard(win, cardno, c, blank)
128 WINDOW *win;
129 int cardno;
130 CARD c;
131 BOOLEAN blank;
132{
133 prcard(win, cardno * 2, cardno, c, blank);
134}
135
136/*
137 * prcard:
138 * Print out a card on the window at the specified location
139 */
140void
141prcard(win, y, x, c, blank)
142 WINDOW *win;
143 int y, x;
144 CARD c;
145 BOOLEAN blank;
146{
147 if (c.rank == EMPTY)
148 return;
149
150 mvwaddstr(win, y + 0, x, "+-----+");
151 mvwaddstr(win, y + 1, x, "| |");
152 mvwaddstr(win, y + 2, x, "| |");
153 mvwaddstr(win, y + 3, x, "| |");
154 mvwaddstr(win, y + 4, x, "+-----+");
155 if (!blank) {
156 mvwaddch(win, y + 1, x + 1, rankchar[c.rank][0]);
157 waddch(win, suitchar[c.suit][0]);
158 mvwaddch(win, y + 3, x + 4, rankchar[c.rank][0]);
159 waddch(win, suitchar[c.suit][0]);
160 }
161}
162
163/*
164 * prhand:
165 * Print a hand of n cards
166 */
167void
168prhand(h, n, win, blank)
169 CARD h[];
170 int n;
171 WINDOW *win;
172 BOOLEAN blank;
173{
174 int i;
175
176 werase(win);
177 for (i = 0; i < n; i++)
178 printcard(win, i, *h++, blank);
179 wrefresh(win);
180}
181
182/*
183 * infrom:
184 * reads a card, supposedly in hand, accepting unambigous brief
185 * input, returns the index of the card found...
186 */
187int
188infrom(hand, n, prompt)
189 CARD hand[];
190 int n;
191 char *prompt;
192{
193 int i, j;
194 CARD crd;
195
196 if (n < 1) {
197 printf("\nINFROM: %d = n < 1!!\n", n);
198 exit(74);
199 }
200 for (;;) {
201 msg("%s", prompt);
202 if (incard(&crd)) { /* if card is full card */
203 if (!isone(crd, hand, n))
204 msg("That's not in your hand");
205 else {
206 for (i = 0; i < n; i++)
207 if (hand[i].rank == crd.rank &&
208 hand[i].suit == crd.suit)
209 break;
210 if (i >= n) {
211 printf("\nINFROM: isone or something messed up\n");
212 exit(77);
213 }
214 return (i);
215 }
216 } else /* if not full card... */
217 if (crd.rank != EMPTY) {
218 for (i = 0; i < n; i++)
219 if (hand[i].rank == crd.rank)
220 break;
221 if (i >= n)
222 msg("No such rank in your hand");
223 else {
224 for (j = i + 1; j < n; j++)
225 if (hand[j].rank == crd.rank)
226 break;
227 if (j < n)
228 msg("Ambiguous rank");
229 else
230 return (i);
231 }
232 } else
233 msg("Sorry, I missed that");
234 }
235 /* NOTREACHED */
236}
237
238/*
239 * incard:
240 * Inputs a card in any format. It reads a line ending with a CR
241 * and then parses it.
242 */
243int
244incard(crd)
245 CARD *crd;
246{
247 int i;
248 int rnk, sut;
249 char *line, *p, *p1;
250 BOOLEAN retval;
251
252 retval = FALSE;
253 rnk = sut = EMPTY;
254 if (!(line = getline()))
255 goto gotit;
256 p = p1 = line;
257 while (*p1 != ' ' && *p1 != '\0')
258 ++p1;
259 *p1++ = '\0';
260 if (*p == '\0')
261 goto gotit;
262
263 /* IMPORTANT: no real card has 2 char first name */
264 if (strlen(p) == 2) { /* check for short form */
265 rnk = EMPTY;
266 for (i = 0; i < RANKS; i++) {
267 if (*p == *rankchar[i]) {
268 rnk = i;
269 break;
270 }
271 }
272 if (rnk == EMPTY)
273 goto gotit; /* it's nothing... */
274 ++p; /* advance to next char */
275 sut = EMPTY;
276 for (i = 0; i < SUITS; i++) {
277 if (*p == *suitchar[i]) {
278 sut = i;
279 break;
280 }
281 }
282 if (sut != EMPTY)
283 retval = TRUE;
284 goto gotit;
285 }
286 rnk = EMPTY;
287 for (i = 0; i < RANKS; i++) {
288 if (!strcmp(p, rankname[i]) || !strcmp(p, rankchar[i])) {
289 rnk = i;
290 break;
291 }
292 }
293 if (rnk == EMPTY)
294 goto gotit;
295 p = p1;
296 while (*p1 != ' ' && *p1 != '\0')
297 ++p1;
298 *p1++ = '\0';
299 if (*p == '\0')
300 goto gotit;
301 if (!strcmp("OF", p)) {
302 p = p1;
303 while (*p1 != ' ' && *p1 != '\0')
304 ++p1;
305 *p1++ = '\0';
306 if (*p == '\0')
307 goto gotit;
308 }
309 sut = EMPTY;
310 for (i = 0; i < SUITS; i++) {
311 if (!strcmp(p, suitname[i]) || !strcmp(p, suitchar[i])) {
312 sut = i;
313 break;
314 }
315 }
316 if (sut != EMPTY)
317 retval = TRUE;
318gotit:
319 (*crd).rank = rnk;
320 (*crd).suit = sut;
321 return (retval);
322}
323
324/*
325 * getuchar:
326 * Reads and converts to upper case
327 */
328int
329getuchar()
330{
331 int c;
332
333 c = readchar();
334 if (islower(c))
335 c = toupper(c);
336 waddch(Msgwin, c);
337 return (c);
338}
339
340/*
341 * number:
342 * Reads in a decimal number and makes sure it is between "lo" and
343 * "hi" inclusive.
344 */
345int
346number(lo, hi, prompt)
347 int lo, hi;
348 char *prompt;
349{
350 char *p;
351 int sum;
352
353 for (sum = 0;;) {
354 msg("%s", prompt);
355 if (!(p = getline()) || *p == '\0') {
356 msg(quiet ? "Not a number" :
357 "That doesn't look like a number");
358 continue;
359 }
360 sum = 0;
361
362 if (!isdigit(*p))
363 sum = lo - 1;
364 else
365 while (isdigit(*p)) {
366 sum = 10 * sum + (*p - '0');
367 ++p;
368 }
369
370 if (*p != ' ' && *p != '\t' && *p != '\0')
371 sum = lo - 1;
372 if (sum >= lo && sum <= hi)
373 break;
374 if (sum == lo - 1)
375 msg("that doesn't look like a number, try again --> ");
376 else
377 msg("%d is not between %d and %d inclusive, try again --> ",
378 sum, lo, hi);
379 }
380 return (sum);
381}
382
383/*
384 * msg:
385 * Display a message at the top of the screen.
386 */
387char Msgbuf[BUFSIZ] = {'\0'};
388int Mpos = 0;
389static int Newpos = 0;
390
391void
392#if __STDC__
393msg(const char *fmt, ...)
394#else
395msg(fmt, va_alist)
396 char *fmt;
397 va_dcl
398#endif
399{
400 va_list ap;
401
402#if __STDC__
403 va_start(ap, fmt);
404#else
405 va_start(ap);
406#endif
407 (void)vsprintf(&Msgbuf[Newpos], fmt, ap);
408 va_end(ap);
409 endmsg();
410}
411
412/*
413 * addmsg:
414 * Add things to the current message
415 */
416void
417#if __STDC__
418addmsg(const char *fmt, ...)
419#else
420addmsg(fmt, va_alist)
421 char *fmt;
422 va_dcl
423#endif
424{
425 va_list ap;
426
427#if __STDC__
428 va_start(ap, fmt);
429#else
430 va_start(ap);
431#endif
432 (void)vsprintf(&Msgbuf[Newpos], fmt, ap);
433 va_end(ap);
434}
435
436/*
437 * endmsg:
438 * Display a new msg.
439 */
440int Lineno = 0;
441
442void
443endmsg()
444{
445 static int lastline = 0;
446 int len;
447 char *mp, *omp;
448
449 /* All messages should start with uppercase */
450 mvaddch(lastline + Y_MSG_START, SCORE_X, ' ');
451 if (islower(Msgbuf[0]) && Msgbuf[1] != ')')
452 Msgbuf[0] = toupper(Msgbuf[0]);
453 mp = Msgbuf;
454 len = strlen(mp);
455 if (len / MSG_X + Lineno >= MSG_Y) {
456 while (Lineno < MSG_Y) {
457 wmove(Msgwin, Lineno++, 0);
458 wclrtoeol(Msgwin);
459 }
460 Lineno = 0;
461 }
462 mvaddch(Lineno + Y_MSG_START, SCORE_X, '*');
463 lastline = Lineno;
464 do {
465 mvwaddstr(Msgwin, Lineno, 0, mp);
466 if ((len = strlen(mp)) > MSG_X) {
467 omp = mp;
468 for (mp = &mp[MSG_X - 1]; *mp != ' '; mp--)
469 continue;
470 while (*mp == ' ')
471 mp--;
472 mp++;
473 wmove(Msgwin, Lineno, mp - omp);
474 wclrtoeol(Msgwin);
475 }
476 if (++Lineno >= MSG_Y)
477 Lineno = 0;
478 } while (len > MSG_X);
479 wclrtoeol(Msgwin);
480 Mpos = len;
481 Newpos = 0;
482 wrefresh(Msgwin);
483 refresh();
484 wrefresh(Msgwin);
485}
486
487/*
488 * do_wait:
489 * Wait for the user to type ' ' before doing anything else
490 */
491void
492do_wait()
493{
494 static char prompt[] = {'-', '-', 'M', 'o', 'r', 'e', '-', '-', '\0'};
495
496 if (Mpos + sizeof prompt < MSG_X)
497 wmove(Msgwin, Lineno > 0 ? Lineno - 1 : MSG_Y - 1, Mpos);
498 else {
499 mvwaddch(Msgwin, Lineno, 0, ' ');
500 wclrtoeol(Msgwin);
501 if (++Lineno >= MSG_Y)
502 Lineno = 0;
503 }
504 waddstr(Msgwin, prompt);
505 wrefresh(Msgwin);
506 wait_for(' ');
507}
508
509/*
510 * wait_for
511 * Sit around until the guy types the right key
512 */
513void
514wait_for(ch)
515 int ch;
516{
517 char c;
518
519 if (ch == '\n')
520 while ((c = readchar()) != '\n')
521 continue;
522 else
523 while (readchar() != ch)
524 continue;
525}
526
527/*
528 * readchar:
529 * Reads and returns a character, checking for gross input errors
530 */
531int
532readchar()
533{
534 int cnt;
535 char c;
536
537over:
538 cnt = 0;
539 while (read(STDIN_FILENO, &c, sizeof(char)) <= 0)
540 if (cnt++ > 100) { /* if we are getting infinite EOFs */
541 bye(); /* quit the game */
542 exit(1);
543 }
544 if (c == CTRL('L')) {
545 wrefresh(curscr);
546 goto over;
547 }
548 if (c == '\r')
549 return ('\n');
550 else
551 return (c);
552}
553
554/*
555 * getline:
556 * Reads the next line up to '\n' or EOF. Multiple spaces are
557 * compressed to one space; a space is inserted before a ','
558 */
559char *
560getline()
561{
562 char *sp;
563 int c, oy, ox;
564 WINDOW *oscr;
565
566 oscr = stdscr;
567 stdscr = Msgwin;
568 getyx(stdscr, oy, ox);
569 refresh();
570 /* loop reading in the string, and put it in a temporary buffer */
571 for (sp = linebuf; (c = readchar()) != '\n'; clrtoeol(), refresh()) {
572 if (c == -1)
573 continue;
574 else
575 if (c == erasechar()) { /* process erase character */
576 if (sp > linebuf) {
577 int i;
578
579 sp--;
580 for (i = strlen(unctrl(*sp)); i; i--)
581 addch('\b');
582 }
583 continue;
584 } else
585 if (c == killchar()) { /* process kill
586 * character */
587 sp = linebuf;
588 move(oy, ox);
589 continue;
590 } else
591 if (sp == linebuf && c == ' ')
592 continue;
593 if (sp >= &linebuf[LINESIZE - 1] || !(isprint(c) || c == ' '))
594 putchar(CTRL('G'));
595 else {
596 if (islower(c))
597 c = toupper(c);
598 *sp++ = c;
599 addstr(unctrl(c));
600 Mpos++;
601 }
602 }
603 *sp = '\0';
604 stdscr = oscr;
605 return (linebuf);
606}
607
608void
609rint(signo)
610 int signo;
611{
612 bye();
613 exit(1);
614}
615
616/*
617 * bye:
618 * Leave the program, cleaning things up as we go.
619 */
620void
621bye()
622{
623 signal(SIGINT, SIG_IGN);
624 mvcur(0, COLS - 1, LINES - 1, 0);
625 fflush(stdout);
626 endwin();
627 putchar('\n');
628}