release e_id after fork in daemon code; ignore events scheduled by

[unix-history] / usr / src / games / cribbage / io.c

# include	<curses.h>
# include	<ctype.h>
# include	<unctrl.h>
# include	"deck.h"
# include	"cribbage.h"

# define	LINESIZE		128

# define	CTRL(X)			('X' - 'A' + 1)

# ifndef	attron
#	define	erasechar()	_tty.sg_erase
#	define	killchar()	_tty.sg_kill
# endif		attron

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)
WINDOW		*win;
int		cardno;
CARD		c;
{
	prcard(win, cardno * 2, cardno, c);
}

/*
 * prcard:
 *	Print out a card on the window at the specified location
 */
prcard(win, y, x, c)
WINDOW		*win;
int		y, x;
CARD		c;
{
	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, "+-----+");
	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)
CARD		h[];
int		n;
WINDOW		*win;
{
	register int	i;

	werase(win);
	for (i = 0; i < n; i++)
	    printcard(win, i, h[i]);
	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 (;;) {
	    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");
	    msg(prompt);
	}
	/* 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);
	addch(c);
	return c;
}



/*
 * number reads in a decimal number and makes sure it is between
 * lo and hi inclusive
 * a cr counts as lo
 */

number( lo, hi )

    int         lo, hi;
{
	char                    *getline();
	register  char          *p;
	register  int            sum;

	sum = 0;
	do  {
	    if(  !( p = getline() )  )  return( lo );   /* no line = lo */
	    if(  *p == NULL  )  return( lo );
	    sum = 0;
	    while(  *p == ' '  ||  *p == '\t'  )  ++p;
	    if(  *p < '0'  ||  *p > '9'  )  {
		sum = lo - 1;
	    }
	    else  {
		do  {
		    sum = 10*sum + (*p - '0');
		    ++p;
		}  while(  '0' <= *p  &&  *p <= '9'  );
	    }
	    if(  *p != ' '  &&  *p != '\t'  &&  *p != NULL  )  sum = lo - 1;
	    if(  sum >= lo  &&  sum <= hi  )  break;
	    if(  sum == lo - 1  )  {
		printf( "that doesn't look like a number, try again --> " );
	    }
	    else  {
		printf( "%d is not between %d and %d inclusive, try again --> ",
								sum, lo, hi );
	    }
	}  while( TRUE );
	return( sum );
}

/*
 * msg:
 *	Display a message at the top of the screen.
 */
char		Msgbuf[BUFSIZ] = "";

int		Mpos = 0;

static int	Newpos = 0;

/* VARARGS1 */
msg(fmt, args)
char	*fmt;
int	args;
{
    /*
     * if the string is "", just clear the line
     */
    if (*fmt == '\0') {
	move(LINES - 1, 0);
	clrtoeol();
	Mpos = 0;
	Hasread = TRUE;
	return;
    }
    /*
     * otherwise add to the message and flush it out
     */
    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 (giving him a chance to see the previous one
 *	if it is up there with the --More--)
 */
endmsg()
{
    if (!Hasread) {
	move(LINES - 1, Mpos);
	addstr("--More--");
	refresh();
	wait_for(' ');
    }
    /*
     * All messages should start with uppercase, except ones that
     * start with a pack addressing character
     */
    if (islower(Msgbuf[0]) && Msgbuf[1] != ')')
	Msgbuf[0] = toupper(Msgbuf[0]);
    mvaddstr(LINES - 1, 0, Msgbuf);
    clrtoeol();
    Mpos = Newpos;
    Newpos = 0;
    refresh();
    Hasread = FALSE;
}

/*
 * 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);
}

/*
 * 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;
    }
    Hasread = TRUE;
    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;

    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));
/*###366 [cc] Mpos undefined %%%*/
	    Mpos++;
	}
    }
    *sp = '\0';
    return linebuf;
}