// promotions by pieces with Lion power stepping in & out the zone in same turn\r
// promotion on capture\r
\r
-#define VERSION "0.1beta"\r
+#define VERSION "0.4beta"\r
\r
#define PATH level==0 || path[0] == 0xc4028 && (level==1 /*|| path[1] == 0x75967 && (level == 2 || path[2] == 0x3400b && (level == 3))*/)\r
//define PATH 0\r
#define BSIZE BWMAX*BHMAX\r
#define ZONE zone\r
\r
-#define ONE (currentVariant == V_SHO || currentVariant == V_CHESS)\r
+#define ONE (currentVariant == V_SHO || currentVariant == V_CHESS || currentVariant == V_SHATRANJ)\r
\r
#define BLACK 0\r
#define WHITE 1\r
char fireMask;\r
} UndoInfo;\r
\r
-char *array;\r
-int bWidth, bHeight, bsize, zone, currentVariant;\r
-int stm, xstm, hashKeyH, hashKeyL, framePtr, msp, nonCapts, rootEval, retMSP, retFirst, retDep, pvPtr, level, cnt50, chuFlag=1, tenFlag, mobilityScore;\r
-int nodes, startTime, tlim1, tlim2;\r
-Move retMove, moveStack[10000], path[100], repStack[300], pv[1000];\r
+char *array, fenArray[4000], *reason;\r
+int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag;\r
+int stm, xstm, hashKeyH, hashKeyL, framePtr, msp, nonCapts, rootEval, retMSP, retFirst, retDep, pvPtr, level, cnt50, mobilityScore;\r
+int nodes, startTime, tlim1, tlim2, repCnt, comp;\r
+Move retMove, moveStack[10000], path[100], repStack[300], pv[1000], repeatMove[300];\r
+\r
+ int maxDepth; // used by search\r
\r
#define X 36 /* slider */\r
#define R 37 /* jump capture */\r
{ NULL } // sentinel\r
};\r
\r
+PieceDesc shatranjPieces[] = {\r
+ {"Q", "", 15, { 0,1,0,1,0,1,0,1 } },\r
+ {"R", "", 50, { X,0,X,0,X,0,X,0 } },\r
+ {"B", "", 9, { 0,J,0,J,0,J,0,J } },\r
+ {"N", "", 30, { N,N,N,N,N,N,N,N } },\r
+ {"K", "", 28, { 1,1,1,1,1,1,1,1 } },\r
+ {"P", "Q", 8, { M,C,0,0,0,0,0,C } },\r
+ { NULL } // sentinel\r
+};\r
+\r
char chuArray[] = "L:FLCSGK:DEGSC:FLL/:RV.B.:BT:KN:PH:BT.B.:RV/:SM:VMR:DH:DK:LN:FK:DK:DHR:VM:SM/PPPPPPPPPPPP/...:GB....:GB..."\r
"/............/............/"\r
"...:gb....:gb.../pppppppppppp/:sm:vmr:dh:dk:fk:ln:dk:dhr:vm:sm/:rv.b.:bt:ph:kn:bt.b.:rv/l:flcsg:dekgsc:fll";\r
":ss:vsb:dh:dk:wb:fi:fe:lh:fi:wb:dk:dhb:vs:ss/:rv.:cs:cs.:bt:ph:fk:ln:kn:bt.:cs:cs.:rv/ln:flicsg:dekgsci:flnl";\r
char shoArray[] = "LNSGKGSNL/.B..:DE..R./PPPPPPPPP/........./........./........./ppppppppp/.r..:de..b./lnsgkgsnl";\r
char chessArray[] = "RNBQKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbqkbnr";\r
+char shatArray[]= "RNBKQBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbkqbnr";\r
\r
typedef struct {\r
int boardWidth, boardFiles, boardRanks, zoneDepth, varNr; // board sizes\r
char *array; // initial position\r
} VariantDesc;\r
\r
-typedef enum { V_CHESS, V_SHO, V_CHU, V_DAI, V_TENJIKU, V_DADA, V_MAKA, V_TAI, V_KYOKU } Variant;\r
+typedef enum { V_CHESS, V_SHO, V_CHU, V_DAI, V_TENJIKU, V_DADA, V_MAKA, V_TAI, V_KYOKU, V_SHATRANJ } Variant;\r
\r
VariantDesc variants[] = {\r
{ 16, 8, 8, 1, V_CHESS, "normal", chessArray }, // FIDE\r
{ 24, 12, 12, 4, V_CHU, "chu", chuArray }, // Chu\r
{ 30, 15, 15, 5, V_DAI, "dai", daiArray }, // Dai\r
{ 32, 16, 16, 5, V_TENJIKU, "tenjiku", tenArray }, // Tenjiku\r
+ { 16, 8, 8, 1, V_SHATRANJ,"shatranj",shatArray}, // Shatranj\r
+\r
// { 0, 0, 0, 0, 0 }, // sentinel\r
{ 34, 17, 17, 0, V_DADA, "dada", chuArray }, // Dai Dai\r
{ 38, 19, 19, 0, V_MAKA, "maka", chuArray }, // Maka Dai Dai\r
return ListLookUp(name, chuPieces);\r
case V_CHESS: // FIDE\r
return ListLookUp(name, chessPieces);\r
+ case V_SHATRANJ: // Shatranj\r
+ return ListLookUp(name, shatranjPieces);\r
}\r
return NULL;\r
}\r
}\r
}\r
for(i=stm+2; i<last[stm]; i+=2) { // second pass: promoted pieces\r
+\r
if((k = p[i].promo) == -2 && p[i].pos == ABSENT) { // orphaned promoted piece not present\r
SqueezeOut(i);\r
}\r
char c, *q, name[3];\r
PieceDesc *p1, *p2;\r
last[WHITE] = 1; last[BLACK] = 0;\r
- if(var == V_CHESS) // add dummy Crown Princes\r
+ if(var == V_CHESS || var == V_SHATRANJ) // add dummy Crown Princes\r
p[AddPiece(WHITE, LookUp("CP", V_CHU))].pos = p[AddPiece(BLACK, LookUp("CP", V_CHU))].pos = ABSENT;\r
for(i=0; ; i++) {\r
//printf("next rank: %s\n", array);\r
for(j = BW*i; ; j++) {\r
+ int pflag=0;\r
+ if(*array == '+') pflag++, array++;\r
c = name[0] = *array++;\r
if(!c) goto eos;\r
if(c == '.') continue;\r
if(name[1]) name[1] += 'A' - 'a';\r
} else color = WHITE;\r
p1 = LookUp(name, var);\r
+ if(!p1) printf("tellusererror Unknown piece '%s' in setup\n", name), exit(-1);\r
+ if(pflag && p1->promoted) p1 = LookUp(p1->promoted, var); // use promoted piece instead\r
n = AddPiece(color, p1);\r
p[n].pos = j;\r
- if(p1->promoted[0]) {\r
+ if(p1->promoted[0] && !pflag) {\r
p2 = LookUp(p1->promoted, var);\r
m = AddPiece(color, p2);\r
if(m <= n) n += 2;\r
bsize = bWidth*bHeight;\r
chuFlag = (currentVariant == V_CHU);\r
tenFlag = (currentVariant == V_TENJIKU);\r
+ chessFlag = (currentVariant == V_CHESS);\r
\r
for(i= -1; i<9; i++) { // board steps in linear coordinates\r
kStep[i] = STEP(direction[i&7].x, direction[i&7].y); // King\r
\r
// piece-square tables\r
for(i=0; i<BH; i++) for(j=0; j<BH; j++) {\r
- int s = BW*i + j, d = BH*(BH-2) - (2*i - BH + 1)*(2*i - BH + 1) - (2*j - BH + 1)*(2*j - BH + 1);\r
+ int s = BW*i + j, d = BH*(BH-2) - abs(2*i - BH + 1)*(BH-1) - (2*j - BH + 1)*(2*j - BH + 1);\r
+ PST[s] = 0;\r
PST[BH+s] = d/4 - (i == 0 || i == BH-1 ? 15 : 0) - (j == 0 || j == BH-1 ? 15 : 0);\r
PST[BH*BW+s] = d/6;\r
PST[BH*BW+BH+s] = d/12;\r
p[EDGE].qval = 5; // tenjiku jump-capturer sentinel\r
}\r
\r
+int\r
+PSTest ()\r
+{\r
+ int r, f, score, tot=0;\r
+ for(r=0; r<BH; r++) for(f=0; f<BH; f++) {\r
+ int s = BW*r+f;\r
+ int piece = board[s];\r
+ if(!piece) continue;\r
+ score = p[piece].value + PST[p[piece].pst + s];\r
+ if(piece & 1) tot += score; else tot -= score;\r
+ }\r
+ return tot;\r
+}\r
+\r
int flag;\r
\r
inline int\r
}\r
} else\r
if(r == M) { // FIDE Pawn; check double-move\r
- if(!NewNonCapture(x, x+v, pFlag) && promoBoard[x-v])\r
- NewNonCapture(x, x+2*v+DEFER, pFlag); // use promoSuppress flag as e.p. flag\r
+ if(!NewNonCapture(x, x+v, pFlag) && chessFlag && promoBoard[x-v])\r
+ NewNonCapture(x, x+2*v, pFlag), moveStack[msp-1] |= DEFER; // use promoSuppress flag as e.p. flag\r
}\r
continue;\r
}\r
GenCapts(int sqr, int victimValue)\r
{ // generate all moves that capture the piece on the given square\r
int i, range, att = attacks[2*sqr + stm];\r
-//printf("GenCapts(%d,%d)\n",sqr,victimValue);\r
+//printf("GenCapts(%c%d,%d) %08x\n",sqr%BW+'a',sqr/BW,victimValue,att);\r
if(!att) return; // no attackers at all!\r
for(i=0; i<8; i++) { // try all rays\r
int x, v, jumper, jcapt=0;\r
for(i=0; i<8; i++) { // scan all knight jumps to locate source\r
int x = sqr - nStep[i], attacker = board[x];\r
if(attacker == EMPTY || (attacker & TYPE) != stm) continue;\r
- if(p[attacker].range[i] <= N && p[attacker].range[i] >= S) { // has Knight jump in our direction\r
+ if(p[attacker].range[i] <= L && p[attacker].range[i] >= S || p[attacker].range[i] == N) { // has Knight jump in our direction\r
NewCapture(x, sqr + victimValue, p[attacker].promoFlag); // plain jump (as in N)\r
if(p[attacker].range[i] < N) { // Lion power; generate double captures over two possible intermediates\r
int v = kStep[i]; // leftish path\r
nodes++;\r
pv[pvPtr++] = 0; // start empty PV, directly behind PV of parent\r
\r
- firstMove = curMove = sorted = msp += 20; // leave 20 empty slots in front of move list\r
+ firstMove = curMove = sorted = msp += 50; // leave 50 empty slots in front of move list\r
tb.fireMask = phase = 0; iterDep=1; replyDep = (depth < 1 ? depth : 1) - 1;\r
do {\r
if(flag && depth>= 0) printf("iter %d:%d\n", depth,iterDep),fflush(stdout);\r
#if 0\r
if(curEval >= beta) {\r
stm ^= WHITE;\r
- score = -Search(-beta, -iterAlpha, difEval, depth-3, promoSuppress & SQUARE, ABSENT);\r
+ score = -Search(-beta, -iterAlpha, -difEval, depth-3, promoSuppress & SQUARE, ABSENT);\r
stm ^= WHITE;\r
if(score >= beta) { msp = oldMSP; retDep += 3; return score + (score < curEval); }\r
}\r
// MOVE EXTRACTION\r
extractMove:\r
if(flag & depth >= 0) printf("%2d:%d extract %d/%d\n", depth, iterDep, curMove, msp);\r
- if(curMove < sorted) {\r
+ if(curMove > sorted) {\r
move = moveStack[sorted=j=curMove];\r
for(i=curMove+1; i<msp; i++)\r
if(moveStack[i] > move) move = moveStack[j=i]; // search move with highest priority\r
if(flag & depth >= 0) printf("%2d:%d made %d/%d %s\n", depth, iterDep, curMove, msp, MoveToText(moveStack[curMove], 0));\r
for(i=2; i<=cnt50; i+=2) if(repStack[level-i+200] == hashKeyH) {\r
moveStack[curMove] = 0; // erase forbidden move\r
- score = -INF; goto repetition;\r
+ if(!level) repeatMove[repCnt++] = move & 0xFFFFFF; // remember outlawed move\r
+ score = -INF; moveStack[curMove] = 0; goto repetition;\r
}\r
repStack[level+200] = hashKeyH;\r
\r
if(promoSuppress & PROMOTE) score = -INF; // non-Lion captures Lion after opponent did same\r
defer |= PROMOTE; // if we started, flag he cannot do it in reply\r
}\r
- if(score == -INF) { moveStack[curMove] = 0; goto abortMove; } // zap illegal moves\r
+ if(score == -INF) {\r
+ if(level == 1) repeatMove[repCnt++] = move & 0xFFFFFF | (p[tb.piece].value == 10*LVAL ? 3<<24 : 1 << 24);\r
+ moveStack[curMove] = 0; // zap illegal moves\r
+ goto abortMove;\r
+ }\r
}\r
#if 1\r
score = -Search(-beta, -iterAlpha, -difEval - tb.booty, replyDep, promoSuppress & ~PROMOTE, defer);\r
int i; // WB thinking output\r
printf("%d %d %d %d", iterDep, bestScore, (GetTickCount() - startTime)/10, nodes);\r
for(i=0; pv[i]; i++) printf(" %s", MoveToText(pv[i], 0));\r
- printf("\n"); fflush(stdout);\r
+ if(iterDep == 1) printf(" { root eval = %4.2f dif = %4.2f; abs = %4.2f}", curEval/100., difEval/100., PSTest()/100.);\r
+ printf("\n");\r
+ fflush(stdout);\r
}\r
if(GetTickCount() - startTime > tlim1) break; // do not start iteration we can (most likely) not finish\r
}\r
#define INVALID 0\r
\r
// some parameter of your engine\r
- #define MAXMOVES 500 /* maximum game length */\r
- #define MAXPLY 60 /* maximum search depth */\r
+ #define MAXMOVES 2000 /* maximum game length */\r
+ #define MAXPLY 20 /* maximum search depth */\r
\r
#define OFF 0\r
#define ON 1\r
\r
-#define DEFAULT_FEN ""\r
-\r
typedef Move MOVE;\r
\r
int moveNr; // part of game state; incremented by MakeMove\r
sup2 = sup1; sup1 = sup0;\r
}\r
\r
+char fenNames[] = "RV....DKDEFL..DHGB......SMLNKN..FK....BT..VM..PH...."; // pairs of char\r
+char fenPromo[] = "WLDHSMSECPB R HFDE....WHFB..LNG ..DKVMFS..FO..FK...."; // pairs of char\r
+\r
+char *\r
+Convert (char *fen)\r
+{\r
+ char *p = fenArray, *q, *rows[36], tmp[4000];\r
+ int n=0;\r
+ printf("# convert FEN '%s'\n", fen);\r
+ q = strchr(fen, ' '); if(q) *q = 0; q = fen;\r
+ do { rows[n++] = q; q = strchr(q, '/'); if(!q) break; *q++ = 0; } while(1);\r
+ *tmp = 0;\r
+ while(--n >= 0) { strcat(tmp, rows[n]); if(n) strcat(tmp, "/"); }\r
+ fen = tmp;\r
+ printf("# flipped FEN '%s'\n", fen);\r
+ while(*fen) {\r
+ if(*fen == ' ') { *p = 0; break; }\r
+ if(n=atoi(fen)) fen++; // digits read\r
+ if(n > 9) fen++; // double digit\r
+ while(n-- > 0) *p++ = '.'; // expand to empty squares\r
+ if(isalpha(*fen)) {\r
+ char *table = fenNames;\r
+ n = *fen > 'Z' ? 'a' - 'A' : 0;\r
+ if((currentVariant == V_CHESS || currentVariant == V_SHATRANJ) && *fen - 'A' - n == 'N' // In Chess N is Knight, not Lion\r
+ || table[2* (*fen - 'A' - n)] == '.') *p++ = *fen; else {\r
+ *p++ = ':';\r
+ *p++ = table[2* (*fen - 'A' - n)] + n;\r
+ *p++ = table[2* (*fen - 'A' - n)+1] + n;\r
+ }\r
+ } else *p++ = *fen;\r
+ fen++;\r
+ }\r
+ printf("# converted FEN '%s'\n", fenArray);\r
+ return fenArray;\r
+}\r
+\r
int\r
Setup2 (char *fen)\r
{\r
+ int stm = WHITE;\r
+ if(fen) {\r
+ char *q = strchr(fen, '\n');\r
+ if(q) *q = 0;\r
+ if(q = strchr(fen, ' ')) stm = (q[1] == 'b' ? BLACK : WHITE); // fen contains color field\r
+ if(strchr(fen, '.') || strchr(fen, ':')) array = fen; else array = Convert(fen);\r
+ }\r
SetUp(array, currentVariant);\r
sup0 = sup1 = sup2 = ABSENT;\r
- rootEval = cnt50 = hashKeyH = hashKeyL = 0;\r
- return WHITE;\r
+ rootEval = cnt50 = hashKeyH = hashKeyL = moveNr = 0;\r
+ return stm;\r
}\r
\r
void\r
if(*moveText == '+') ret |= PROMOTE;\r
printf("# suppress = %c%d\n", sup1%BW+'a', sup1/BW);\r
MapFromScratch(attacks);\r
- postThinking--;\r
+ postThinking--; repCnt = 0;\r
Search(-INF-1, INF+1, 0, 1, sup1 & ~PROMOTE, sup2);\r
postThinking++;\r
for(i=retFirst; i<retMSP; i++) {\r
if((moveStack[i] & (PROMOTE | DEFER-1)) == ret) break;\r
if((moveStack[i] & DEFER-1) == ret) deferred = i; // promoted version of entered non-promotion is legal\r
}\r
+printf("# moveNr = %d in {%d,%d}\n", i, retFirst, retMSP);\r
if(i>=retMSP) { // no exact match\r
if(deferred) { // but maybe non-sensical deferral\r
int flags = p[board[f]].promoFlag;\r
if(!(flags & promoBoard[f])) moveStack[i] |= DEFER; // came from outside zone, so essential deferral\r
}\r
}\r
- if(i >= retMSP)\r
- for(i=retFirst; i<retMSP; i++) printf("# %d. %08x %08x %s\n", i-20, moveStack[i], ret, MoveToText(moveStack[i], 0));\r
+ if(i >= retMSP) {\r
+ for(i=retFirst; i<retMSP; i++) printf("# %d. %08x %08x %s\n", i-50, moveStack[i], ret, MoveToText(moveStack[i], 0));\r
+ reason = NULL;\r
+ for(i=0; i<repCnt; i++) {if((repeatMove[i] & 0xFFFFFF) == ret) {\r
+ if(repeatMove[i] & 1<<24) reason = (repeatMove[i] & 1<<25 ? "Distant capture of protected Lion" : "Counterstrike against Lion");\r
+ else reason = "Repeats earlier position";\r
+ break;\r
+ }\r
+ printf("# %d. %08x %08x %s\n", i, repeatMove[i], ret, MoveToText(repeatMove[i], 0));\r
+}\r
+ }\r
}\r
return (i >= retMSP ? INVALID : moveStack[i]);\r
}\r
//pmap(attacks, WHITE);\r
//pmap(attacks, BLACK);\r
//flag=1;\r
- postThinking--;\r
+ postThinking--; repCnt = 0;\r
Search(-INF-1, INF+1, 0, 1, sup1 & ~PROMOTE, sup2);\r
postThinking++;\r
flag=0;\r
int\r
SearchBestMove (int stm, int timeLeft, int mps, int timeControl, int inc, int timePerMove, MOVE *move, MOVE *ponderMove)\r
{\r
- int score, targetTime, movesLeft = 50;\r
+ int score, targetTime, movesLeft = BW*BH/4 + 20;\r
if(mps) movesLeft = mps - (moveNr>>1)%mps;\r
targetTime = timeLeft*10 / (movesLeft + 2) + 1000 * inc;\r
+ if(moveNr < 30) targetTime *= 0.5 + moveNr/60.; // speedup in opening\r
if(timePerMove > 0) targetTime = timeLeft * 5;\r
startTime = GetTickCount();\r
tlim1 = 0.2*targetTime;\r
tlim2 = 1.9*targetTime;\r
nodes = 0;\r
MapFromScratch(attacks);\r
- score = Search(-INF-1, INF+1, rootEval, 20, sup1, sup2);\r
+ retMove = INVALID; repCnt = 0;\r
+ score = Search(-INF-1, INF+1, rootEval, maxDepth, sup1, sup2);\r
*move = retMove;\r
*ponderMove = INVALID;\r
return score;\r
int TakeBack(int n)\r
{ // reset the game and then replay it to the desired point\r
int last, stm;\r
- stm = Setup2(NULL);\r
+ Init(currentVariant); stm = Setup2(NULL);\r
printf("# setup done");fflush(stdout);\r
last = moveNr - n; if(last < 0) last = 0;\r
for(moveNr=0; moveNr<last; moveNr++) stm = MakeMove2(stm, gameMove[moveNr]),printf("make %2d: %x\n", moveNr, gameMove[moveNr]);\r
\r
void PrintResult(int stm, int score)\r
{\r
- if(score == 0) printf("1/2-1/2\n");\r
- if(score > 0 && stm == WHITE || score < 0 && stm == BLACK) printf("1-0\n");\r
- else printf("0-1\n");\r
+ char tail[100];\r
+ if(reason) sprintf(tail, " {%s}", reason); else *tail = 0;\r
+ if(score == 0) printf("1/2-1/2%s\n", tail);\r
+ if(score > 0 && stm == WHITE || score < 0 && stm == BLACK) printf("1-0%s\n", tail);\r
+ else printf("0-1%s\n", tail);\r
}\r
\r
main()\r
int engineSide=NONE; // side played by engine\r
int timeLeft; // timeleft on engine's clock\r
int mps, timeControl, inc, timePerMove; // time-control parameters, to be used by Search\r
- int maxDepth; // used by search\r
MOVE move, ponderMove;\r
int i, score;\r
char inBuf[8000], command[80];\r
\r
if(stm == engineSide) { // if it is the engine's turn to move, set it thinking, and let it move\r
\r
+pboard(board);\r
score = SearchBestMove(stm, timeLeft, mps, timeControl, inc, timePerMove, &move, &ponderMove);\r
\r
if(move == INVALID) { // game apparently ended\r
+ int kcapt = 0, xstm = stm ^ WHITE, king, k = p[king=royal[xstm]].pos;\r
+ if( k != ABSENT) { // test if King capture possible\r
+ if(attacks[2*k + stm]) {\r
+ if( p[king + 2].pos == ABSENT ) kcapt = 1; // we have an attack on his only King\r
+ }\r
+ } else { // he has no king! Test for attacks on Crown Prince\r
+ k = p[king + 2].pos;\r
+ if(attacks[2*k + stm]) kcapt = 1; // we have attack on Crown Prince\r
+ }\r
+ if(kcapt) { // print King capture before claiming\r
+ GenCapts(k, 0);\r
+ printf("move %s\n", MoveToText(moveStack[msp-1], 1));\r
+ reason = "king capture";\r
+ } else reason = "resign";\r
engineSide = NONE; // so stop playing\r
PrintResult(stm, score);\r
} else {\r
// wait for input, and read it until we have collected a complete line\r
for(i = 0; (inBuf[i] = getchar()) != '\n'; i++);\r
inBuf[i+1] = 0;\r
-pboard(board);\r
-pmoves(retFirst, retMSP);\r
\r
// extract the first word\r
sscanf(inBuf, "%s", command);\r
}\r
if(!strcmp(command, "protover")){\r
printf("feature ping=1 setboard=1 colors=0 usermove=1 memory=1 debug=1 sigint=0 sigterm=0\n");\r
- printf("feature variants=\"normal,chu,dai,tenjiku,12x12+0_fairy,9x9+0_shogi\"\n");\r
+ printf("feature variants=\"normal,shatranj,chu,dai,tenjiku,12x12+0_fairy,9x9+0_shogi\"\n");\r
printf("feature myname=\"HaChu " VERSION "\" highlight=1\n");\r
printf("feature option=\"Resign -check 0\"\n"); // example of an engine-defined option\r
printf("feature option=\"Contempt -spin 0 -200 200\"\n"); // and another one\r
for(i=0; i<5; i++) {\r
sscanf(inBuf+8, "%s", command);\r
if(!strcmp(variants[i].name, command)) {\r
-printf("var %d\n",i);\r
Init(i); stm = Setup2(NULL); break;\r
}\r
}\r
if(!strcmp(command, "memory")) { SetMemorySize(atoi(inBuf+7)); continue; }\r
if(!strcmp(command, "ping")) { printf("pong%s", inBuf+4); continue; }\r
// if(!strcmp(command, "")) { sscanf(inBuf, " %d", &); continue; }\r
- if(!strcmp(command, "new")) { engineSide = BLACK; Init(V_CHESS); stm = Setup2(DEFAULT_FEN); maxDepth = MAXPLY; randomize = OFF; continue; }\r
- if(!strcmp(command, "setboard")){ engineSide = NONE; stm = Setup2(inBuf+9); continue; }\r
+ if(!strcmp(command, "new")) {\r
+ engineSide = BLACK; Init(V_CHESS); stm = Setup2(NULL); maxDepth = MAXPLY; randomize = OFF; comp = 0;\r
+ continue;\r
+ }\r
+ if(!strcmp(command, "setboard")){ engineSide = NONE; Init(currentVariant); stm = Setup2(inBuf+9); continue; }\r
if(!strcmp(command, "easy")) { ponder = OFF; continue; }\r
if(!strcmp(command, "hard")) { ponder = ON; continue; }\r
if(!strcmp(command, "undo")) { stm = TakeBack(1); continue; }\r
if(!strcmp(command, "l")) { pplist(); continue; }\r
// ignored commands:\r
if(!strcmp(command, "xboard")) { continue; }\r
- if(!strcmp(command, "computer")){ continue; }\r
+ if(!strcmp(command, "computer")){ comp = 1; continue; }\r
if(!strcmp(command, "name")) { continue; }\r
if(!strcmp(command, "ics")) { continue; }\r
if(!strcmp(command, "accepted")){ continue; }\r
if(!strcmp(command, "")) { continue; }\r
if(!strcmp(command, "usermove")){\r
int move = ParseMove(inBuf+9);\r
- if(move == INVALID) printf("Illegal move\n");\r
- else {\r
+pboard(board);\r
+ if(move == INVALID) {\r
+ if(reason) printf("Illegal move {%s}\n", reason); else printf("%s\n", reason="Illegal move");\r
+ if(comp) PrintResult(stm, -INF); // against computer: claim\r
+ } else {\r
stm = MakeMove2(stm, move);\r
ponderMove = INVALID;\r
gameMove[moveNr++] = move; // remember game\r
projects / hachu.git / blobdiff