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