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