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