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

static char	*sccsid = "@(#)support.c	1.14 (Berkeley) %G%";

#include	<curses.h>
#include	"deck.h"
#include	"cribbage.h"
#include	"cribcur.h"


#define		NTV		10		/* number scores to test */

/* score to test reachability of, and order to test them in */
int		tv[ NTV ]	= { 8, 7, 9, 6, 11, 12, 13, 14, 10, 5 };


/*
 * computer chooses what to play in pegging...
 * only called if no playable card will score points
 */

cchose( h, n, s )

    CARD		h[];
    int			n;
    int			s;
{
	register  int		i, j, l;

	if(  n <= 1  )  return( 0 );
	if(  s < 4  )  {		/* try for good value */
	    if(  ( j = anysumto(h, n, s, 4) )  >=  0  )  return( j );
	    if(  ( j = anysumto(h, n, s, 3) ) >= 0  &&  s == 0  )
								return( j );
	}
	if(  s > 0  &&  s < 20  )  {
	    for( i = 1; i <= 10; i++ )  {	/* try for retaliation to 31 */
		if(  ( j = anysumto(h, n, s, 21-i) )  >=  0  )  {
		    if(  ( l = numofval(h, n, i) )  >  0  )  {
			if(  l > 1  ||  VAL( h[j].rank ) != i  )  return( j );
		    }
		}
	    }
	}
	if(  s < 15  )  {
	    for( i = 0; i < NTV; i++ )  {	/* for retaliation after 15 */
		if(  ( j = anysumto(h, n, s, tv[i]) )  >=  0  )  {
		    if(  ( l = numofval(h, n, 15-tv[i]) )  >  0  )  {
			if(  l > 1  ||  VAL( h[j].rank ) != 15-tv[i]  )  return( j );
		    }
		}
	    }
	}
	j = -1;
	for( i = n - 1; i >= 0; --i )  {	/* remember: h is sorted */
	    l = s + VAL( h[i].rank );
	    if(  l > 31  )  continue;
	    if(  l != 5  &&  l != 10  &&  l != 21  )  {
		j = i;
		break;
	    }
	}
	if(  j >= 0  )  return( j );
	for( i = n - 1; i >= 0; --i )  {
	    l = s + VAL( h[i].rank );
	    if(  l > 31  )  continue;
	    if(  j < 0  )  j = i;
	    if(  l != 5  &&  l != 21  )  {
		j = i;
		break;
	    }
	}
	return( j );
}


/*
 * plyrhand:
 *	Evaluate and score a player hand or crib
 */
plyrhand(hand, s)
CARD		hand[];
char		*s;
{
    register int	i, j;
    register BOOLEAN	win;
    static char		prompt[BUFSIZ];

    prhand(hand, CINHAND, Playwin, FALSE);
    sprintf(prompt, "Your %s scores ", s);
    i = scorehand(hand, turnover, CINHAND, strcmp(s, "crib") == 0, explain);
    if ((j = number(0, 29, prompt)) == 19)
	j = 0;
    if (i != j) {
	if (i < j) {
	    win = chkscr(&pscore, i);
	    msg("It's really only %d points; I get %d", i, 2);
	    if (!win)
		win = chkscr(&cscore, 2);
	}
	else {
	    win = chkscr(&pscore, j);
	    msg("You should have taken %d, not %d!", i, j);
	}
	if (explain)
	    msg("Explanation: %s", expl);
	do_wait();
    }
    else
	win = chkscr(&pscore, i);
    return win;
}

/*
 * comphand:
 *	Handle scoring and displaying the computers hand
 */
comphand(h, s)
CARD		h[];
char		*s;
{
	register int		j;

	j = scorehand(h, turnover, CINHAND, strcmp(s, "crib") == 0, FALSE);
	prhand(h, CINHAND, Compwin, FALSE);
	msg("My %s scores %d", s, (j == 0 ? 19 : j));
	return chkscr(&cscore, j);
}

/*
 * chkscr:
 *	Add inc to scr and test for > glimit, printing on the scoring
 *	board while we're at it.
 */

int	Lastscore[2] = {-1, -1};

chkscr(scr, inc)
int		*scr, inc;
{
	BOOLEAN		myturn;

	myturn = (scr == &cscore);
	if (inc != 0) {
		prpeg(Lastscore[myturn], '.', myturn);
		Lastscore[myturn] = *scr;
		*scr += inc;
		prpeg(*scr, PEG, myturn);
		refresh();
	}
	return (*scr >= glimit);
}

/*
 * prpeg:
 *	Put out the peg character on the score board and put the
 *	score up on the board.
 */
prpeg(score, peg, myturn)
register int	score;
char		peg;
BOOLEAN		myturn;
{
	register int	y, x;

	if (!myturn)
		y = SCORE_Y + 2;
	else
		y = SCORE_Y + 5;

	if (score <= 0 || score >= glimit) {
		if (peg == '.')
			peg = ' ';
		if (score == 0)
			x = SCORE_X + 2;
		else {
			x = SCORE_X + 2;
			y++;
		}
	}
	else {
		x = (score - 1) % 30;
		if (score > 90 || (score > 30 && score <= 60)) {
			y++;
			x = 29 - x;
		}
		x += x / 5;
		x += SCORE_X + 3;
	}
	mvaddch(y, x, peg);
	mvprintw(SCORE_Y + (myturn ? 7 : 1), SCORE_X + 10, "%3d", score);
}

/*
 * cdiscard -- the computer figures out what is the best discard for
 * the crib and puts the best two cards at the end
 */

cdiscard( mycrib )

    BOOLEAN		mycrib;
{
	CARD			d[ CARDS ],  h[ FULLHAND ],  cb[ 2 ];
	register  int		i, j, k;
	int			nc, ns;
	long			sums[ 15 ];
	static  int		undo1[15]   = {0,0,0,0,0,1,1,1,1,2,2,2,3,3,4};
	static  int		undo2[15]   = {1,2,3,4,5,2,3,4,5,3,4,5,4,5,5};

	makedeck( d );
	nc = CARDS;
	for( i = 0; i < knownum; i++ )  {	/* get all other cards */
	    remove( known[i], d, nc-- );
	}
	for( i = 0; i < 15; i++ )  sums[i] = 0L;
	ns = 0;
	for( i = 0; i < (FULLHAND - 1); i++ )  {
	    cb[0] = chand[i];
	    for( j = i + 1; j < FULLHAND; j++ )  {
		cb[1] = chand[j];
		for( k = 0; k < FULLHAND; k++ )  h[k] = chand[k];
		remove( chand[i], h, FULLHAND );
		remove( chand[j], h, FULLHAND - 1 );
		for( k = 0; k < nc; k++ )  {
		    sums[ns] += scorehand( h, d[k], CINHAND, TRUE, FALSE );
		    if( mycrib )  sums[ns] += adjust( cb, d[k] );
		    else	  sums[ns] -= adjust( cb, d[k] );
		}
		++ns;
	    }
	}
	j = 0;
	for( i = 1; i < 15; i++ )  if(  sums[i] > sums[j]  )  j = i;
	for( k = 0; k < FULLHAND; k++ )  h[k] = chand[k];
	remove( h[ undo1[j] ], chand, FULLHAND );
	remove( h[ undo2[j] ], chand, FULLHAND - 1 );
	chand[4] = h[ undo1[j] ];
	chand[5] = h[ undo2[j] ];
}


/*
 * returns true if some card in hand can be played without exceeding 31
 */

anymove( hand, n, sum )

    CARD		hand[];
    int			n;
    int			sum;
{
	register  int		i, j;

	if(  n < 1  )  return( FALSE );
	j = hand[0].rank;
	for( i = 1; i < n; i++ )  {
	    if(  hand[i].rank < j  )  j = hand[i].rank;
	}
	return(  sum + VAL( j )  <=  31  );
}


/*
 * anysumto returns the index (0 <= i < n) of the card in hand that brings
 * the s up to t, or -1 if there is none
 */

anysumto( hand, n, s, t )

    CARD		hand[];
    int			n;
    int			s,  t;
{
	register  int		i;

	for( i = 0; i < n; i++ )  {
	    if(  s + VAL( hand[i].rank )  ==  t  )  return( i );
	}
	return( -1 );
}


/*
 * return the number of cards in h having the given rank value
 */

numofval( h, n, v )

    CARD		h[];
    int			n;
    int			v;
{
	register  int		i, j;

	j = 0;
	for( i = 0; i < n; i++ )  {
	    if(  VAL( h[i].rank )  ==  v  )  ++j;
	}
	return( j );
}


/*
 * makeknown remembers all n cards in h for future recall
 */

makeknown( h, n )

    CARD		h[];
    int			n;
{
	register  int		i;

	for( i = 0; i < n; i++ )  {
	    known[ knownum++ ] = h[i];
	}
}
Commit	Line	Data
f870d435	1	static char *sccsid = "@(#)support.c 1.14 (Berkeley) %G%";
9a6fbd6d	2
5836528f	3	#include <curses.h>
feeca497 KA	4	#include "deck.h"
feeca497 KA	5	#include "cribbage.h"
5836528f	6	#include "cribcur.h"
feeca497 KA	7
	8
	9	#define NTV 10 /* number scores to test */
	10
	11	/* score to test reachability of, and order to test them in */
	12	int tv[ NTV ] = { 8, 7, 9, 6, 11, 12, 13, 14, 10, 5 };
	13
	14
	15	/*
	16	* computer chooses what to play in pegging...
	17	* only called if no playable card will score points
	18	*/
	19
	20	cchose( h, n, s )
	21
	22	CARD h[];
	23	int n;
	24	int s;
	25	{
	26	register int i, j, l;
	27
	28	if( n <= 1 ) return( 0 );
	29	if( s < 4 ) { /* try for good value */
	30	if( ( j = anysumto(h, n, s, 4) ) >= 0 ) return( j );
	31	if( ( j = anysumto(h, n, s, 3) ) >= 0 && s == 0 )
	32	return( j );
	33	}
	34	if( s > 0 && s < 20 ) {
	35	for( i = 1; i <= 10; i++ ) { /* try for retaliation to 31 */
	36	if( ( j = anysumto(h, n, s, 21-i) ) >= 0 ) {
	37	if( ( l = numofval(h, n, i) ) > 0 ) {
	38	if( l > 1 \|\| VAL( h[j].rank ) != i ) return( j );
	39	}
	40	}
	41	}
	42	}
	43	if( s < 15 ) {
	44	for( i = 0; i < NTV; i++ ) { /* for retaliation after 15 */
	45	if( ( j = anysumto(h, n, s, tv[i]) ) >= 0 ) {
	46	if( ( l = numofval(h, n, 15-tv[i]) ) > 0 ) {
	47	if( l > 1 \|\| VAL( h[j].rank ) != 15-tv[i] ) return( j );
	48	}
	49	}
	50	}
	51	}
	52	j = -1;
	53	for( i = n - 1; i >= 0; --i ) { /* remember: h is sorted */
	54	l = s + VAL( h[i].rank );
	55	if( l > 31 ) continue;
	56	if( l != 5 && l != 10 && l != 21 ) {
	57	j = i;
	58	break;
	59	}
	60	}
	61	if( j >= 0 ) return( j );
	62	for( i = n - 1; i >= 0; --i ) {
	63	l = s + VAL( h[i].rank );
	64	if( l > 31 ) continue;
	65	if( j < 0 ) j = i;
	66	if( l != 5 && l != 21 ) {
	67	j = i;
	68	break;
	69	}
	70	}
71	return( j );
72	}
73
74
75
76	/*
5836528f KA	77	* plyrhand:
5836528f KA	78	* Evaluate and score a player hand or crib
feeca497	79	*/
5836528f KA	80	plyrhand(hand, s)
	81	CARD hand[];
	82	char *s;
feeca497	83	{
0033d0c1 KA	84	register int i, j;
	85	register BOOLEAN win;
	86	static char prompt[BUFSIZ];
	87
	88	prhand(hand, CINHAND, Playwin, FALSE);
	89	sprintf(prompt, "Your %s scores ", s);
f870d435	90	i = scorehand(hand, turnover, CINHAND, strcmp(s, "crib") == 0, explain);
0033d0c1 KA	91	if ((j = number(0, 29, prompt)) == 19)
	92	j = 0;
	93	if (i != j) {
	94	if (i < j) {
5836528f	95	win = chkscr(&pscore, i);
0033d0c1 KA	96	msg("It's really only %d points; I get %d", i, 2);
	97	if (!win)
	98	win = chkscr(&cscore, 2);
	99	}
	100	else {
	101	win = chkscr(&pscore, j);
	102	msg("You should have taken %d, not %d!", i, j);
	103	}
	104	if (explain)
	105	msg("Explanation: %s", expl);
	106	do_wait();
	107	}
	108	else
	109	win = chkscr(&pscore, i);
	110	return win;
feeca497 KA	111	}
feeca497 KA	112
5836528f KA	113	/*
	114	* comphand:
	115	* Handle scoring and displaying the computers hand
	116	*/
	117	comphand(h, s)
	118	CARD h[];
	119	char *s;
	120	{
	121	register int j;
feeca497	122
f870d435	123	j = scorehand(h, turnover, CINHAND, strcmp(s, "crib") == 0, FALSE);
5dc185f5	124	prhand(h, CINHAND, Compwin, FALSE);
5836528f KA	125	msg("My %s scores %d", s, (j == 0 ? 19 : j));
	126	return chkscr(&cscore, j);
	127	}
feeca497 KA	128
feeca497 KA	129	/*
5836528f KA	130	* chkscr:
	131	* Add inc to scr and test for > glimit, printing on the scoring
	132	* board while we're at it.
feeca497 KA	133	*/
feeca497 KA	134
a410e8bc	135	int Lastscore[2] = {-1, -1};
feeca497	136
5836528f KA	137	chkscr(scr, inc)
5836528f KA	138	int *scr, inc;
feeca497	139	{
5836528f	140	BOOLEAN myturn;
feeca497	141
5836528f KA	142	myturn = (scr == &cscore);
	143	if (inc != 0) {
	144	prpeg(Lastscore[myturn], '.', myturn);
	145	Lastscore[myturn] = *scr;
a410e8bc KA	146	*scr += inc;
a410e8bc KA	147	prpeg(*scr, PEG, myturn);
3ba687c0	148	refresh();
5836528f	149	}
2067fe68	150	return (*scr >= glimit);
5836528f	151	}
feeca497 KA	152
feeca497 KA	153	/*
5836528f	154	* prpeg:
608476cd KA	155	* Put out the peg character on the score board and put the
608476cd KA	156	* score up on the board.
feeca497	157	*/
5836528f KA	158	prpeg(score, peg, myturn)
	159	register int score;
	160	char peg;
	161	BOOLEAN myturn;
feeca497	162	{
5836528f KA	163	register int y, x;
5836528f KA	164
5836528f KA	165	if (!myturn)
	166	y = SCORE_Y + 2;
	167	else
	168	y = SCORE_Y + 5;
a410e8bc KA	169
	170	if (score <= 0 \|\| score >= glimit) {
	171	if (peg == '.')
	172	peg = ' ';
	173	if (score == 0)
	174	x = SCORE_X + 2;
	175	else {
	176	x = SCORE_X + 2;
	177	y++;
	178	}
	179	}
	180	else {
	181	x = (score - 1) % 30;
	182	if (score > 90 \|\| (score > 30 && score <= 60)) {
	183	y++;
	184	x = 29 - x;
	185	}
	186	x += x / 5;
	187	x += SCORE_X + 3;
5836528f	188	}
5836528f	189	mvaddch(y, x, peg);
608476cd	190	mvprintw(SCORE_Y + (myturn ? 7 : 1), SCORE_X + 10, "%3d", score);
feeca497 KA	191	}
feeca497 KA	192
feeca497 KA	193	/*
	194	* cdiscard -- the computer figures out what is the best discard for
	195	* the crib and puts the best two cards at the end
	196	*/
	197
	198	cdiscard( mycrib )
	199
	200	BOOLEAN mycrib;
	201	{
	202	CARD d[ CARDS ], h[ FULLHAND ], cb[ 2 ];
	203	register int i, j, k;
	204	int nc, ns;
	205	long sums[ 15 ];
	206	static int undo1[15] = {0,0,0,0,0,1,1,1,1,2,2,2,3,3,4};
	207	static int undo2[15] = {1,2,3,4,5,2,3,4,5,3,4,5,4,5,5};
	208
	209	makedeck( d );
	210	nc = CARDS;
	211	for( i = 0; i < knownum; i++ ) { /* get all other cards */
	212	remove( known[i], d, nc-- );
	213	}
	214	for( i = 0; i < 15; i++ ) sums[i] = 0L;
	215	ns = 0;
	216	for( i = 0; i < (FULLHAND - 1); i++ ) {
	217	cb[0] = chand[i];
	218	for( j = i + 1; j < FULLHAND; j++ ) {
	219	cb[1] = chand[j];
	220	for( k = 0; k < FULLHAND; k++ ) h[k] = chand[k];
	221	remove( chand[i], h, FULLHAND );
	222	remove( chand[j], h, FULLHAND - 1 );
	223	for( k = 0; k < nc; k++ ) {
56b49d73	224	sums[ns] += scorehand( h, d[k], CINHAND, TRUE, FALSE );
feeca497 KA	225	if( mycrib ) sums[ns] += adjust( cb, d[k] );
	226	else sums[ns] -= adjust( cb, d[k] );
	227	}
	228	++ns;
	229	}
	230	}
	231	j = 0;
	232	for( i = 1; i < 15; i++ ) if( sums[i] > sums[j] ) j = i;
	233	for( k = 0; k < FULLHAND; k++ ) h[k] = chand[k];
	234	remove( h[ undo1[j] ], chand, FULLHAND );
	235	remove( h[ undo2[j] ], chand, FULLHAND - 1 );
	236	chand[4] = h[ undo1[j] ];
	237	chand[5] = h[ undo2[j] ];
	238	}
	239
	240
	241
	242	/*
	243	* returns true if some card in hand can be played without exceeding 31
	244	*/
	245
	246	anymove( hand, n, sum )
	247
	248	CARD hand[];
	249	int n;
	250	int sum;
	251	{
	252	register int i, j;
	253
	254	if( n < 1 ) return( FALSE );
	255	j = hand[0].rank;
	256	for( i = 1; i < n; i++ ) {
	257	if( hand[i].rank < j ) j = hand[i].rank;
	258	}
	259	return( sum + VAL( j ) <= 31 );
	260	}
	261
	262
	263
	264	/*
	265	* anysumto returns the index (0 <= i < n) of the card in hand that brings
	266	* the s up to t, or -1 if there is none
	267	*/
	268
	269	anysumto( hand, n, s, t )
	270
	271	CARD hand[];
	272	int n;
	273	int s, t;
	274	{
	275	register int i;
	276
	277	for( i = 0; i < n; i++ ) {
	278	if( s + VAL( hand[i].rank ) == t ) return( i );
	279	}
	280	return( -1 );
	281	}
	282
	283
	284
	285
	286	/*
	287	* return the number of cards in h having the given rank value
	288	*/
289
290	numofval( h, n, v )
291
292	CARD h[];
293	int n;
294	int v;
295	{
296	register int i, j;
297
298	j = 0;
299	for( i = 0; i < n; i++ ) {
300	if( VAL( h[i].rank ) == v ) ++j;
301	}
302	return( j );
303	}
304
305
306
307	/*
308	* makeknown remembers all n cards in h for future recall
309	*/
310
311	makeknown( h, n )
312
313	CARD h[];
314	int n;
315	{
316	register int i;
317
318	for( i = 0; i < n; i++ ) {
319	known[ knownum++ ] = h[i];
320	}
321	}
322