2.11BSD/src/games/cribbage/io.c
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*/
#ifndef lint
static char sccsid[] = "@(#)io.c 5.1 (Berkeley) 5/30/85";
#endif not lint
# include <curses.h>
# include <ctype.h>
# include <signal.h>
# include "deck.h"
# include "cribbage.h"
# include "cribcur.h"
# define LINESIZE 128
# ifdef CTRL
# undef CTRL
# endif
# define CTRL(X) ('X' - 'A' + 1)
# ifndef erasechar()
# define erasechar() _tty.sg_erase
# endif erasechar()
# ifndef killchar()
# define killchar() _tty.sg_kill
# endif killchar()
char linebuf[ LINESIZE ];
char *rankname[ RANKS ] = { "ACE", "TWO", "THREE", "FOUR",
"FIVE", "SIX", "SEVEN", "EIGHT",
"NINE", "TEN", "JACK", "QUEEN",
"KING" };
char *rankchar[ RANKS ] = { "A", "2", "3", "4", "5", "6", "7",
"8", "9", "T", "J", "Q", "K" };
char *suitname[ SUITS ] = { "SPADES", "HEARTS", "DIAMONDS",
"CLUBS" };
char *suitchar[ SUITS ] = { "S", "H", "D", "C" };
/*
* msgcard:
* Call msgcrd in one of two forms
*/
msgcard(c, brief)
CARD c;
BOOLEAN brief;
{
if (brief)
return msgcrd(c, TRUE, (char *) NULL, TRUE);
else
return msgcrd(c, FALSE, " of ", FALSE);
}
/*
* msgcrd:
* Print the value of a card in ascii
*/
msgcrd(c, brfrank, mid, brfsuit)
CARD c;
char *mid;
BOOLEAN brfrank, brfsuit;
{
if (c.rank == EMPTY || c.suit == EMPTY)
return FALSE;
if (brfrank)
addmsg("%1.1s", rankchar[c.rank]);
else
addmsg(rankname[c.rank]);
if (mid != NULL)
addmsg(mid);
if (brfsuit)
addmsg("%1.1s", suitchar[c.suit]);
else
addmsg(suitname[c.suit]);
return TRUE;
}
/*
* printcard:
* Print out a card.
*/
printcard(win, cardno, c, blank)
WINDOW *win;
int cardno;
CARD c;
BOOLEAN blank;
{
prcard(win, cardno * 2, cardno, c, blank);
}
/*
* prcard:
* Print out a card on the window at the specified location
*/
prcard(win, y, x, c, blank)
WINDOW *win;
int y, x;
CARD c;
BOOLEAN blank;
{
if (c.rank == EMPTY)
return;
mvwaddstr(win, y + 0, x, "+-----+");
mvwaddstr(win, y + 1, x, "| |");
mvwaddstr(win, y + 2, x, "| |");
mvwaddstr(win, y + 3, x, "| |");
mvwaddstr(win, y + 4, x, "+-----+");
if (!blank) {
mvwaddch(win, y + 1, x + 1, rankchar[c.rank][0]);
waddch(win, suitchar[c.suit][0]);
mvwaddch(win, y + 3, x + 4, rankchar[c.rank][0]);
waddch(win, suitchar[c.suit][0]);
}
}
/*
* prhand:
* Print a hand of n cards
*/
prhand(h, n, win, blank)
CARD h[];
int n;
WINDOW *win;
BOOLEAN blank;
{
register int i;
werase(win);
for (i = 0; i < n; i++)
printcard(win, i, *h++, blank);
wrefresh(win);
}
/*
* infrom:
* reads a card, supposedly in hand, accepting unambigous brief
* input, returns the index of the card found...
*/
infrom(hand, n, prompt)
CARD hand[];
int n;
char *prompt;
{
register int i, j;
CARD crd;
if (n < 1) {
printf("\nINFROM: %d = n < 1!!\n", n);
exit(74);
}
for (;;) {
msg(prompt);
if (incard(&crd)) { /* if card is full card */
if (!isone(crd, hand, n))
msg("That's not in your hand");
else {
for (i = 0; i < n; i++)
if (hand[i].rank == crd.rank &&
hand[i].suit == crd.suit)
break;
if (i >= n) {
printf("\nINFROM: isone or something messed up\n");
exit(77);
}
return i;
}
}
else /* if not full card... */
if (crd.rank != EMPTY) {
for (i = 0; i < n; i++)
if (hand[i].rank == crd.rank)
break;
if (i >= n)
msg("No such rank in your hand");
else {
for (j = i + 1; j < n; j++)
if (hand[j].rank == crd.rank)
break;
if (j < n)
msg("Ambiguous rank");
else
return i;
}
}
else
msg("Sorry, I missed that");
}
/* NOTREACHED */
}
/*
* incard:
* Inputs a card in any format. It reads a line ending with a CR
* and then parses it.
*/
incard(crd)
CARD *crd;
{
char *getline();
register int i;
int rnk, sut;
char *line, *p, *p1;
BOOLEAN retval;
retval = FALSE;
rnk = sut = EMPTY;
if (!(line = getline()))
goto gotit;
p = p1 = line;
while( *p1 != ' ' && *p1 != NULL ) ++p1;
*p1++ = NULL;
if( *p == NULL ) goto gotit;
/* IMPORTANT: no real card has 2 char first name */
if( strlen(p) == 2 ) { /* check for short form */
rnk = EMPTY;
for( i = 0; i < RANKS; i++ ) {
if( *p == *rankchar[i] ) {
rnk = i;
break;
}
}
if( rnk == EMPTY ) goto gotit; /* it's nothing... */
++p; /* advance to next char */
sut = EMPTY;
for( i = 0; i < SUITS; i++ ) {
if( *p == *suitchar[i] ) {
sut = i;
break;
}
}
if( sut != EMPTY ) retval = TRUE;
goto gotit;
}
rnk = EMPTY;
for( i = 0; i < RANKS; i++ ) {
if( !strcmp( p, rankname[i] ) || !strcmp( p, rankchar[i] ) ) {
rnk = i;
break;
}
}
if( rnk == EMPTY ) goto gotit;
p = p1;
while( *p1 != ' ' && *p1 != NULL ) ++p1;
*p1++ = NULL;
if( *p == NULL ) goto gotit;
if( !strcmp( "OF", p ) ) {
p = p1;
while( *p1 != ' ' && *p1 != NULL ) ++p1;
*p1++ = NULL;
if( *p == NULL ) goto gotit;
}
sut = EMPTY;
for( i = 0; i < SUITS; i++ ) {
if( !strcmp( p, suitname[i] ) || !strcmp( p, suitchar[i] ) ) {
sut = i;
break;
}
}
if( sut != EMPTY ) retval = TRUE;
gotit:
(*crd).rank = rnk;
(*crd).suit = sut;
return( retval );
}
/*
* getuchar:
* Reads and converts to upper case
*/
getuchar()
{
register int c;
c = readchar();
if (islower(c))
c = toupper(c);
waddch(Msgwin, c);
return c;
}
/*
* number:
* Reads in a decimal number and makes sure it is between "lo" and
* "hi" inclusive.
*/
number(lo, hi, prompt)
int lo, hi;
char *prompt;
{
char *getline();
register char *p;
register int sum;
sum = 0;
for (;;) {
msg(prompt);
if(!(p = getline()) || *p == NULL) {
msg(quiet ? "Not a number" : "That doesn't look like a number");
continue;
}
sum = 0;
if (!isdigit(*p))
sum = lo - 1;
else
while (isdigit(*p)) {
sum = 10 * sum + (*p - '0');
++p;
}
if (*p != ' ' && *p != '\t' && *p != NULL)
sum = lo - 1;
if (sum >= lo && sum <= hi)
return sum;
if (sum == lo - 1)
msg("that doesn't look like a number, try again --> ");
else
msg("%d is not between %d and %d inclusive, try again --> ",
sum, lo, hi);
}
}
/*
* msg:
* Display a message at the top of the screen.
*/
char Msgbuf[BUFSIZ] = { '\0' };
int Mpos = 0;
static int Newpos = 0;
/* VARARGS1 */
msg(fmt, args)
char *fmt;
int args;
{
doadd(fmt, &args);
endmsg();
}
/*
* addmsg:
* Add things to the current message
*/
/* VARARGS1 */
addmsg(fmt, args)
char *fmt;
int args;
{
doadd(fmt, &args);
}
/*
* endmsg:
* Display a new msg.
*/
int Lineno = 0;
endmsg()
{
register int len;
register char *mp, *omp;
static int lastline = 0;
/*
* All messages should start with uppercase
*/
mvaddch(lastline + Y_MSG_START, SCORE_X, ' ');
if (islower(Msgbuf[0]) && Msgbuf[1] != ')')
Msgbuf[0] = toupper(Msgbuf[0]);
mp = Msgbuf;
len = strlen(mp);
if (len / MSG_X + Lineno >= MSG_Y) {
while (Lineno < MSG_Y) {
wmove(Msgwin, Lineno++, 0);
wclrtoeol(Msgwin);
}
Lineno = 0;
}
mvaddch(Lineno + Y_MSG_START, SCORE_X, '*');
lastline = Lineno;
do {
mvwaddstr(Msgwin, Lineno, 0, mp);
if ((len = strlen(mp)) > MSG_X) {
omp = mp;
for (mp = &mp[MSG_X-1]; *mp != ' '; mp--)
continue;
while (*mp == ' ')
mp--;
mp++;
wmove(Msgwin, Lineno, mp - omp);
wclrtoeol(Msgwin);
}
if (++Lineno >= MSG_Y)
Lineno = 0;
} while (len > MSG_X);
wclrtoeol(Msgwin);
Mpos = len;
Newpos = 0;
wrefresh(Msgwin);
refresh();
wrefresh(Msgwin);
}
/*
* doadd:
* Perform an add onto the message buffer
*/
doadd(fmt, args)
char *fmt;
int *args;
{
static FILE junk;
/*
* Do the printf into Msgbuf
*/
junk._flag = _IOWRT + _IOSTRG;
junk._ptr = &Msgbuf[Newpos];
junk._cnt = 32767;
_doprnt(fmt, args, &junk);
putc('\0', &junk);
Newpos = strlen(Msgbuf);
}
/*
* do_wait:
* Wait for the user to type ' ' before doing anything else
*/
do_wait()
{
register int line;
static char prompt[] = { '-', '-', 'M', 'o', 'r', 'e', '-', '-', '\0' };
if (Mpos + sizeof prompt < MSG_X)
wmove(Msgwin, Lineno > 0 ? Lineno - 1 : MSG_Y - 1, Mpos);
else {
mvwaddch(Msgwin, Lineno, 0, ' ');
wclrtoeol(Msgwin);
if (++Lineno >= MSG_Y)
Lineno = 0;
}
waddstr(Msgwin, prompt);
wrefresh(Msgwin);
wait_for(' ');
}
/*
* wait_for
* Sit around until the guy types the right key
*/
wait_for(ch)
register char ch;
{
register char c;
if (ch == '\n')
while ((c = readchar()) != '\n')
continue;
else
while (readchar() != ch)
continue;
}
/*
* readchar:
* Reads and returns a character, checking for gross input errors
*/
readchar()
{
register int cnt, y, x;
auto char c;
over:
cnt = 0;
while (read(0, &c, 1) <= 0)
if (cnt++ > 100) /* if we are getting infinite EOFs */
bye(); /* quit the game */
if (c == CTRL(L)) {
wrefresh(curscr);
goto over;
}
if (c == '\r')
return '\n';
else
return c;
}
/*
* getline:
* Reads the next line up to '\n' or EOF. Multiple spaces are
* compressed to one space; a space is inserted before a ','
*/
char *
getline()
{
register char *sp;
register int c, oy, ox;
register WINDOW *oscr;
oscr = stdscr;
stdscr = Msgwin;
getyx(stdscr, oy, ox);
refresh();
/*
* loop reading in the string, and put it in a temporary buffer
*/
for (sp = linebuf; (c = readchar()) != '\n'; clrtoeol(), refresh()) {
if (c == -1)
continue;
else if (c == erasechar()) { /* process erase character */
if (sp > linebuf) {
register int i;
sp--;
for (i = strlen(unctrl(*sp)); i; i--)
addch('\b');
}
continue;
}
else if (c == killchar()) { /* process kill character */
sp = linebuf;
move(oy, ox);
continue;
}
else if (sp == linebuf && c == ' ')
continue;
if (sp >= &linebuf[LINESIZE-1] || !(isprint(c) || c == ' '))
putchar(CTRL(G));
else {
if (islower(c))
c = toupper(c);
*sp++ = c;
addstr(unctrl(c));
Mpos++;
}
}
*sp = '\0';
stdscr = oscr;
return linebuf;
}
/*
* bye:
* Leave the program, cleaning things up as we go.
*/
bye()
{
signal(SIGINT, SIG_IGN);
mvcur(0, COLS - 1, LINES - 1, 0);
fflush(stdout);
endwin();
putchar('\n');
exit(1);
}