acn/backgammon-vt100
acn/backgammon-vt100
1
0
Fork 0
Code Releases Activity
d99670287c
backgammon-vt100/gameplan.c

866 lines
22 KiB
C
Raw Normal View History

First upload
2019-08-30 10:39:29 +02:00
/* Gammon IV, by David C. Oshel, Ames, Iowa */
/*--------------------------------------------------------------------*/
/* GAMEPLAN.C -- separately compiled module, contains the tactics and */
/* strategy for making the computer's move in Gammon IV */
/* BACKGMMN.REL calls MyMove(), MyMove() calls topstone */
/* and movestone and a few others. Uses the globals in */
/* GAMEPLAN.HDR quite heavily. Bgversion declared here */
/*--------------------------------------------------------------------*/
#include "gameplan.hdr" /* contains external, global declarations */
/*-------------------------------------------------------------------------*/
/* */
/* Bgversion is an external reference in the main module. Use this string */
/* to take credit for a decent gameplaying algorithm if you find one! */
/* */
char *bgversion = ".20 -April 1, 1986- by David C. Oshel";
/*....v....1....v....2....v....3....v...*/
/* just 38 characters for version info! */
/* */
/*-------------------------------------------------------------------------*/
/*=============================================*/
/* M Y M O V E */
/*=============================================*/
naked() { /* am I leaving too many blots? */
static int i, clink;
i = 24; clink = 0;
while (i) {
if (point[i].stones == 1 && point[i].owner == ME) clink++;
i--;
}
return (clink > 2);
} /* end: naked */
yourfolly() { /* look for lotsa blots in your inner table */
static int i, clink;
i = 18; clink = 0;
while (i < 25) {
if (point[i].owner == YU && point[i].stones == 1)
clink++;
i++;
}
return (clink >= 3);
} /* end: yourfolly */
goodboard() { /* look for four made points near my inner table */
static int i, clank, clink;
i = 9; clank = 0;
while (i > 3) {
if (point[i].owner == ME && point[i].stones > 1) clank++;
i--;
}
if (clank > 4) return (TRUE); /* bar is nearly blocked */
i = 6; clank = clink = 0;
while (i) {
if (point[i].owner != ME)
;
else if (point[i].stones == 1) clink++; else clank++;
i--;
}
return (clank > 3 && clink < 2);
} /* end: goodboard */
bearoff() {
return (topstone(ME) < 7);
} /* end: bearoff */
scanahead( from ) int from; {
static int count;
count = 0;
while (--from > 0) {
++count;
if ( point[ from ].owner == YU ) return (count);
}
return (7);
} /* end: scanahead */
endgame() { /* Is no strategy required from here on in? */
return ( (25 - topstone(YU)) > topstone(ME) );
} /* end: endgame */
/*------------------------------------------------------------*/
/* MATCHUP */
/* */
/* 2-stone functions that force the choice of the next move. */
/* These are the HEART and SOUL of this backgammon algorithm! */
/*------------------------------------------------------------*/
setpend( from, to ) int from, to; {
pending.fr = from;
pending.to = to;
pending.flag = TRUE;
} /* end: setpend */
clrpend() {
pending.flag = FALSE;
} /* end: clrpend */
natural(f1,t1,f2,t2) int f1,t1,f2,t2; {
clrpend();
if (point[t2].stones == 1 && t1 == f2) setpend(f2,t2);
return (pending.flag);
} /* end: natural */
matchup( test4 ) int (* test4)(); {
static int i, j, ti, tj;
if ( pending.flag ) return (FALSE); /* this is probably redundant */
for (i = 1; i < 26; i++) {
ti = list[0][i];
if ( ti == ERROR ) goto zoo;
for (j = 1; j < 26; j++) {
tj = list[1][j];
if ( tj == ERROR ) goto voo;
if ( (* test4)( i, ti, j, tj ) ) {
lurch( i, ti, 0);
return (TRUE);
}
voo: ;
}
zoo: ;
}
return (FALSE);
} /* end: matchup */
matchhi( test4 ) int (* test4)(); {
static int i, j, ti, tj;
if ( pending.flag ) return (FALSE); /* this is probably redundant */
for (i = 1; i < 26; i++) {
ti = list[1][i];
if ( ti == ERROR ) goto zoo;
for (j = 1; j < 26; j++) {
tj = list[0][j];
if ( tj == ERROR ) goto voo;
if ( (* test4)( i, ti, j, tj ) ) {
lurch( i, ti, 1);
return (TRUE);
}
voo: ;
}
zoo: ;
}
return (FALSE);
} /* end: matchhi */
/*--------------------------------------------------------*/
/* CLOCKWISE and COUNTERCLOCK */
/* */
/* the rest of these are single-stone decisions based on */
/* rules of thumb, board-scanning functions */
/*--------------------------------------------------------*/
plainstupid( from ) int from; { /* don't break a safe point */
return (from < 13 && (point[from].stones == 2 && scanahead(from) < 7));
} /* end: plainstupid */
unwise( innertablept ) int innertablept; {
/* if it's a hit, just for god's sake don't put him on the bar!! */
if ( innertablept < 7 ) {
if (point[ innertablept ].owner == YU ||
point[ YRBAR ].stones > 0)
return (TRUE);
}
return(FALSE);
} /* end: unwise */
covermine( from, to ) int from, to; {
if ( from < 8 ) return(FALSE);
return ( (point[ to ].stones == 1) && (point[ to ].owner == ME) );
} /* end: covermine */
idareyou( from, to ) int from, to; {
if (unwise( to )) return (FALSE);
if ( (point[ from ].stones != 2)
&& (point[ to ].stones < 2)
&& (scanahead( to ) > 6) ) return ( TRUE );
else return (FALSE);
} /* end: idareyou */
hitandrun( from, to ) int from, to; {
return ( point[ to ].owner == YU );
} /* end: hitandrun */
dbuild( from, to ) int from, to; {
static int diceleft;
diceleft = (myturns? 2 + movesleft: movesleft);
if (diceleft > 1) {
/* can't possibly be only one stone on from point */
/* or kamikaze would have covered it on last move */
return ( point[to].stones == 0 );
}
return (FALSE);
} /* end: dbuild */
kamikaze( from, to ) int from, to; {
/* cover my distant blot, or razzle-dazzle 'em with the long doubles hit */
static int j, k, diceleft;
k = from;
j = from - to;
diceleft = myturns * movesleft; /* NB: 2*2 == 2+2, "fourtunately" */
while ( diceleft-- ) { /* predicting where doubles land is easy! */
k -= j;
if (k < 1) return (FALSE); /* out of bounds */
if ( point[ k ].stones == 0 ) continue; /* simplify */
if ( point[ k ].stones == 1 ) /* found my blot or yours? */
return (TRUE);
else if ( point[k].owner == YU ) /* found your blockade? */
return (FALSE);
else continue; /* found my safe point, so ignore it */
}
return (FALSE);
} /* end: kamikaze */
hittite( from, to ) int from, to; {
return (hitandrun(from,to) && to > 9);
} /* end: hittite */
safehit( from, to ) int from, to; {
return (hittite(from,to) && idareyou(from,to));
} /* end: safehit */
foolsdemise( from, to ) int from, to; {
/* annihilate orphaned blots in enemy's inner, my outer table */
return (to > 17 && point[to].owner == YU);
} /* end: foolsdemise */
landonme( from, to ) int from, to; {
if ( plainstupid(from) ) return (FALSE);
if ( loneranger(from,to) ) {
if (from < 19 && to > 6) return(TRUE);
}
else return ( point[ to ].owner == ME && point[to].stones < 4);
} /* end: landonme */
/* these evaluations have meaning only in the endgame */
nobackgammon( from, to ) int from, to; { /* endgame */
return (from > 19);
} /* end: nobackgammon */
crosstable( from, to ) int from, to; {
/* always move a table ahead if possible, in the endgame */
if (from < 7) return (FALSE);
if (from > 18 && to <= 18) return (TRUE);
if (from > 12 && to <= 12) return (TRUE);
if (from > 6 && to <= 6) return (TRUE);
return (FALSE);
} /* end: crosstable */
fiftytworule( from, to ) int from, to; { /* endgame */
static int p;
if (from < 7) return (FALSE); /* not in inner table! */
p = from % 6;
if (p == 0) return (TRUE); /* improve the six */
if (p != 5) return ( (to % 6) < 3 ); /* best improve under five */
} /* end: fiftytworule */
/* these evaluations are universally applicable, last resort moves */
gohome( from, to ) int from, to; { /* always go home if you can */
return (to == MYHOME);
} /* end: gohome */
scatter( from, to ) int from, to; { /* scatter, esp. in the endgame */
if (plainstupid(from) || unwise(to)) return (FALSE);
return ( point[ from ].stones > 1 && point[ to ].stones == 0 );
} /* end: scatter */
runnerup( from, to ) int from, to; {
if (from < 10 || from > 18) return (FALSE);
return (TRUE);
} /* end: runnerup */
loneranger( from, to ) int from, to; {
return( point[ from ].stones == 1 );
} /* end: loneranger */
run( dummy1, dummy2 ) int dummy1, dummy2; { /* MUST move something! */
return (TRUE);
} /* end: run */
/* clockwise and counterclock make a 1-stone choice on rules of thumb */
counterclock( test ) int (* test)(); {
static int i,j;
for (i = 0; i < 2; i++) {
for (j = 1; j < 25; j++) {
if ( list[i][j] == ERROR ) continue;
if ( (* test)( j, list[i][j] ) ) {
lurch( j, list[i][j], i);
return ( TRUE );
} } }
return (FALSE);
} /* end: counterclock */
clockwise( test ) int (* test)(); {
static int i,j;
for (i = 0; i < 2; i++) {
for (j = 25; j > 0; j--) {
if ( list[i][j] == ERROR ) continue;
if ( (* test)( j, list[i][j] ) ) {
lurch( j, list[i][j], i);
return ( TRUE );
} } }
return (FALSE);
} /* end: clockwise */
/*-------------------------------------------*/
/* Make Prime */
/*-------------------------------------------*/
static int prmchk;
buildprime( f1,t1,f2,t2 ) int f1,t1,f2,t2; {
clrpend();
/* check for the doubles bug */
if ((dice[0] == dice[1]) && (point[f1].stones < 2)) return(FALSE);
/* look for the combination */
if ( t1 == prmchk && t2 == prmchk) setpend(f2,t2);
/* stick like glue to a made point, but doubles may move forward */
if (dice[0] != dice[1]) {
if ((f2 < 8) && (point[f2].stones == 2)) clrpend();
if ((f1 < 8) && (point[f1].stones == 2)) clrpend();
}
return(pending.flag);
} /* end: buildprime */
makeprime() {
static int i, tab[] = { ERROR,1,2,3,20,22,24,9,4,6,8,5,7 };
i = 12;
while (i) {
prmchk = tab[i];
i--;
if ( point[ prmchk ].stones > 1 ) continue;
else if ( matchup( buildprime ) ) return(TRUE);
}
return(FALSE);
} /* end: makeprime */
coverprime( from, to ) int from, to; {
return (((to == prmchk) &&
(point[prmchk].owner == ME)) &&
(point[from].stones != 2));
} /* coverprime */
cleanup() {
static int i, tab[] = { ERROR,1,2,3,20,22,24,9,4,6,8,5,7 };
i = 12;
while (i) {
prmchk = tab[i];
i--;
if ( point[ prmchk ].stones != 1 ) continue;
else if ( counterclock( coverprime ) ) return(TRUE);
}
return(FALSE);
} /* end: cleanup */
/*-------------------------------------*/
/* Walking Prime */
/*-------------------------------------*/
swivelhips( from, to ) int from, to; {
return ( from > prmchk );
} /* end: swivelhips */
slink( from, to ) int from, to; {
return( (from > prmchk) && (point[to].stones == 1) );
} /* end: slink */
weasel() {
if ( clockwise( slink ) )
return(TRUE);
if ( counterclock( swivelhips ) )
return(TRUE);
if ( clockwise( run ) )
return(TRUE);
} /* end: weasel */
ihaveprime( from ) int from; {
static int i, to, ez;
ez = 0;
for (i = 0; i < 6; i++) {
to = from - i;
if ((point[to].owner == ME) && (point[to].stones > 1)) ez++;
}
return (ez > 4);
} /* end: ihaveprime */
walkingprime() {
/* looks for the walking prime anywhere in the front tables */
/* then tries to bring up a runner from behind the prime, */
/* ensuring that a back stone WILL move before a front one */
static int i;
i = 12;
while (i > 5) {
if ( ihaveprime(i) ) {
prmchk = i;
if ( weasel() ) return (TRUE);
}
i--;
}
return(FALSE);
} /* end: walkingprime */
/*---------- Book Moves ----------*/
/* only valid if my move is first */
/*--------------------------------*/
zip(a,b,c,d) int a,b,c,d; {
lurch(a,b,0);
lurch(c,d,0);
movesleft = 0; return( TRUE );
} /* end: zip */
zoom( a,b,c,d,e,f,g,h ) int a,b,c,d,e,f,g,h; {
myturns = 0; zip(a,b,c,d); zip(e,f,g,h); return( TRUE );
} /* end: zoom */
book() {
int a,b;
if (!firstmove) return (FALSE);
firstmove = FALSE;
a = min(dice[0],dice[1]);
b = max(dice[0],dice[1]);
switch (level) {
case 0: { return ( book0(a,b) ); break; }
case 1: { return ( book1(a,b) ); break; }
case 2: { return ( book2(a,b) ); break; }
}
}
book0( a,b ) int a, b; {
switch (a) {
case 1: { switch (b) {
case 1: return ( zoom(8,7,8,7,6,5,6,5) );
case 2: return ( zip(24,23,13,11) );
case 3: return ( zip(8,5,6,5) );
case 4: return ( zip(24,23,13,9) );
case 5: return ( zip(24,23,13,8) );
case 6: return ( zip(13,7,8,7) );
}
break; }
case 2: { switch (b) {
case 2: return ( zoom(6,4,6,4,13,11,13,11) );
case 3: return ( zip(13,11,13,10) );
case 4: return ( zip(8,4,6,4) );
case 5: return ( zip(13,8,13,11) );
case 6: return ( zip(24,18,13,11) );
}
break; }
case 3: { switch (b) {
case 3: return ( zoom(13,10,13,10,10,7,10,7) );
case 4: return ( zip(13,10,13,9) );
case 5: return ( zip(13,10,13,8) );
case 6: return ( zip(24,18,13,10) );
}
break; }
case 4: { switch (b) {
case 4: return ( zoom(13,9,13,9,24,20,24,20) );
case 5: return ( zip(13,8,13,9) );
case 6: return ( zip(24,18,18,14) );
}
break; }
case 5: { switch (b) {
case 5: return ( zoom(13,8,13,8,8,3,8,3) );
case 6: return ( zip(24,18,18,13) );
}
break; }
case 6: { return ( zoom(13,7,13,7,24,18,24,18) );
break; }
}
} /* end: book0 */
book1( a,b ) int a, b; { /* mostly follows Becker */
switch (a) {
case 1: { switch (b) {
case 1: return ( zoom(8,7,8,7,6,5,6,5) );
case 2: return ( zip(13,11,6,5) );
case 3: return ( zip(8,5,6,5) );
case 4: return ( zip(13,9,6,5) );
case 5: return ( zip(13,8,6,5) );
case 6: return ( zip(13,7,8,7) );
}
break; }
case 2: { switch (b) {
case 2: return ( zoom(6,4,6,4,13,11,13,11) );
case 3: return ( zip(13,11,13,10) );
case 4: return ( zip(8,4,6,4) );
case 5: return ( zip(13,8,13,11) );
case 6: return ( zip(13,7,7,5) );
}
break; }
case 3: { switch (b) {
case 3: return ( zoom(13,10,13,10,8,5,8,5) );
case 4: return ( zip(13,10,13,9) );
case 5: return ( zip(13,8,8,5) );
case 6: return ( zip(13,7,13,10) );
}
break; }
case 4: { switch (b) {
case 4: return ( zoom(13,9,13,9,9,5,9,5) );
case 5: return ( zip(13,8,13,9) );
case 6: return ( zip(13,7,13,9) );
}
break; }
case 5: { switch (b) {
case 5: return ( zoom(13,8,13,8,8,3,8,3) );
case 6: return ( zip(13,7,13,8) );
}
break; }
case 6: { return ( zoom(13,7,13,7,24,18,24,18) );
break; }
}
} /* end: book1 */
book2( a,b ) int a, b; { /* mostly follows Becker */
switch (a) {
case 1: { switch (b) {
case 1: return ( zoom(8,7,8,7,6,5,6,5) );
case 2: return ( zip(13,11,24,23) );
case 3: return ( zip(8,5,6,5) );
case 4: return ( zip(13,9,24,23) );
case 5: return ( zip(13,8,24,23) );
case 6: return ( zip(13,7,8,7) );
}
break; }
case 2: { switch (b) {
case 2: return ( zoom(6,4,6,4,24,23,24,23) );
case 3: return ( zip(13,11,13,10) );
case 4: return ( zip(8,4,6,4) );
case 5: return ( zip(13,8,13,11) );
case 6: return ( zip(13,7,13,11) );
}
break; }
case 3: { switch (b) {
case 3: return ( zoom(13,10,13,10,10,7,10,7) );
case 4: return ( zip(13,10,13,9) );
case 5: return ( zip(13,8,8,5) );
case 6: return ( zip(13,7,13,10) );
}
break; }
case 4: { switch (b) {
case 4: return ( zoom(13,9,13,9,9,5,9,5) );
case 5: return ( zip(13,8,13,9) );
case 6: return ( zip(13,7,13,9) );
}
break; }
case 5: { switch (b) {
case 5: return ( zoom(13,8,13,8,8,3,8,3) );
case 6: return ( zip(13,7,13,8) );
}
break; }
case 6: { return ( zoom(13,7,13,7,24,18,24,18) );
break; }
}
} /* end: book2 */
/*====== MyMove ======*/
torve() {
if ( makeprime() ) { /* this will use doubles, if it can */
return;
}
else if ( walkingprime() ) { /* i have six prime points, so run!!! */
return;
}
else if ( dice[0] == dice[1] ) { /* this is too easy! */
if ( counterclock( kamikaze ) )
return;
if ( counterclock( dbuild ) ) /* claim new turf */
return;
if ( clockwise( run ) )
return;
}
else if ( cleanup() ) { /* cover my single blot on prime points */
return;
}
else if ( bearoff() ) { /* I'm ready, but you're in the back game! */
if ( counterclock( gohome ) )
return;
if ( clockwise( run ) )
return;
}
else {
if ( clockwise( hitandrun ) )
return;
if ( matchup( natural ) )
return;
if ( clockwise( landonme ) )
return;
if ( counterclock( runnerup ) )
return;
if ( clockwise( scatter ) )
return;
if ( clockwise( run ) )
return;
}
} /* end: torve */
villiers() {
if ( makeprime() ) { /* this will use doubles, if it can */
return;
}
else if ( walkingprime() ) { /* i have six prime points, so run!!! */
return;
}
else if ( dice[0] == dice[1] ) { /* this is too easy! */
if ( counterclock( kamikaze ) )
return;
if ( counterclock( dbuild ) ) /* claim new turf */
return;
if ( clockwise( run ) )
return;
}
else if ( cleanup() ) { /* cover my single blot on prime points */
return;
}
else if ( bearoff() ) { /* I'm ready, but you're in the back game! */
if ( counterclock( gohome ) )
return;
if ( clockwise( run ) )
return;
}
else {
if ( clockwise( foolsdemise ) )
return;
if ( clockwise( idareyou ) )
return;
if ( counterclock( covermine ) )
return;
if ( matchup( natural ) )
return;
if ( clockwise( landonme ) )
return;
if ( clockwise( runnerup ) )
return;
if ( clockwise( scatter ) )
return;
if ( clockwise( run ) )
return;
}
} /* end: villiers */
louisa() {
if ( makeprime() ) { /* this will use doubles, if it can */
return;
}
else if ( walkingprime() ) { /* i have six prime points, so run!!! */
return;
}
else if ( dice[0] == dice[1] ) { /* this is too easy! */
if ( counterclock( kamikaze ) )
return;
if ( counterclock( dbuild ) ) /* claim new turf */
return;
if ( clockwise( run ) )
return;
}
else if ( cleanup() ) { /* cover my single blot on prime points */
return;
}
else if ( bearoff() ) { /* I'm ready, but you're in the back game! */
if ( counterclock( gohome ) )
return;
if ( clockwise( run ) )
return;
}
else if ( (!naked() && goodboard()) || yourfolly() ) {
if ( clockwise( hitandrun ) )
return;
if ( matchup( natural ) )
return;
if ( clockwise( landonme ) )
return;
if ( counterclock( runnerup ) )
return;
if ( clockwise( scatter ) )
return;
if ( clockwise( run ) )
return;
}
else {
if ( clockwise( foolsdemise ) )
return;
if ( clockwise( idareyou ) )
return;
if ( counterclock( covermine ) )
return;
if ( matchup( natural ) )
return;
if ( clockwise( landonme ) )
return;
if ( clockwise( runnerup ) )
return;
if ( clockwise( scatter ) )
return;
if ( clockwise( run ) )
return;
}
} /* end: louisa */
mymove() {
int i, d;
if ( nomove() ) {
if (lookforit && (dice[0] != dice[1])) {
lookforit = FALSE;
puts("\008... ");
switch (level) {
case 0: { puts("Blocked!"); break; }
case 1: { puts("Well, no!"); break; }
case 2: { puts("Thurb!"); break; }
}
sleep(10);
restoreboard();
update();
/* put the high die in list zero */
d = dice[0]; dice[0] = dice[1]; dice[1] = d;
cantuse = ERROR; movesleft = 2; myturns = 1;
switch (level) {
case 0: { setchat("I move"); break; }
case 1: { setchat("Let's try"); break; }
case 2: { setchat("Move is"); break; }
}
debug(chatter);
prmchk = 12;
weasel();
/* the rules say, use both dice if you can, or */
/* the highest if one or the other but not both */
}
else {
lookforit = TRUE;
strcat(chatter," and now I'm blocked ");
myturns = movesleft = 0;
} }
else if ( book() ) {
return;
}
else if ( pending.flag ) {
lurch( pending.fr, pending.to, 1 );
clrpend();
}
else if ( endgame() ) { /* very solid tactics here!! */
if ( clockwise( gohome ) )
return;
if ( clockwise( nobackgammon ) ) /* no excuse! */
return;
if ( clockwise( crosstable ) )
return;
if ( clockwise( fiftytworule ) )
return;
if ( clockwise( scatter ) )
return;
if ( clockwise( run ) )
return;
}
else if ( point[ MYBAR ].stones > 0 ) { /* I'm on the bar! */
if ( clockwise( hitandrun ) ) /* wreak havoc, please */
return;
if ( clockwise( run ) ) /* note: uses low die first */
return;
}
else switch (level) {
case 0: { villiers(); break; }
case 1: { louisa(); break; }
case 2: { torve(); break; }
}
} /* end: mymove */
/*------------------------------*/
/* end of the GAMEPLAN.C module */
/*------------------------------*/

Copy Permalink