// promotions by pieces with Lion power stepping in & out the zone in same turn\r
// promotion on capture\r
\r
-#define VERSION "0.4beta"\r
+#define VERSION "0.7beta"\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
\r
+#define XHASH\r
+#define XKILLERS\r
+#define XNULLMOVE\r
+\r
#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
#include <signal.h>\r
#include <time.h>\r
+#include <stdint.h>\r
\r
#ifdef WIN32 \r
# include <windows.h>\r
+ int InputWaiting()\r
+ { // checks for waiting input in pipe\r
+ static int pipe, init;\r
+ static HANDLE inp;\r
+ DWORD cnt;\r
+\r
+ if(!init) inp = GetStdHandle(STD_INPUT_HANDLE);\r
+ if(!PeekNamedPipe(inp, NULL, 0, NULL, &cnt, NULL)) return 1;\r
+ return cnt;\r
+ }\r
#else\r
# include <sys/time.h>\r
+# include <sys/ioctl.h>\r
+ int InputWaiting()\r
+ {\r
+ int cnt;\r
+ if(ioctl(0, FIONREAD, &cnt)) return 1;\r
+ return cnt;\r
+ }\r
int GetTickCount() // with thanks to Tord\r
{ struct timeval t;\r
gettimeofday(&t, NULL);\r
#define BSIZE BWMAX*BHMAX\r
#define ZONE zone\r
\r
-#define ONE (currentVariant == V_SHO || currentVariant == V_CHESS || currentVariant == V_SHATRANJ)\r
+#define ONE (currentVariant == V_SHO || currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK)\r
\r
#define BLACK 0\r
#define WHITE 1\r
void pbytes(unsigned char *b);\r
\r
typedef struct {\r
+ int lock[5];\r
+ int move[5];\r
+ short int score[5];\r
+ char depth[5];\r
+ char flag[5];\r
+ char age[4];\r
+} HashBucket;\r
+\r
+HashBucket *hashTable;\r
+int hashMask;\r
+\r
+#define H_UPPER 2\r
+#define H_LOWER 1\r
+\r
+typedef struct {\r
char *name, *promoted;\r
int value;\r
signed char range[8];\r
} UndoInfo;\r
\r
char *array, fenArray[4000], *reason;\r
-int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag;\r
+int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag, repDraws;\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
+int nodes, startTime, tlim1, tlim2, tlim3, repCnt, comp, abortFlag;\r
+Move ponderMove;\r
+Move retMove, moveStack[10000], path[100], repStack[300], pv[1000], repeatMove[300], killer[100][2];\r
\r
int maxDepth; // used by search\r
\r
};\r
\r
PieceDesc shatranjPieces[] = {\r
- {"Q", "", 15, { 0,1,0,1,0,1,0,1 } },\r
+ {"FK", "", 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
+ {"P", "FK", 8, { M,C,0,0,0,0,0,C } },\r
+ { NULL } // sentinel\r
+};\r
+\r
+PieceDesc makrukPieces[] = {\r
+ {"SM","", 15, { 0,1,0,1,0,1,0,1 } },\r
+ {"R", "", 50, { X,0,X,0,X,0,X,0 } },\r
+ {"S", "", 20, { 1,1,0,1,0,1,0,1 } }, // silver\r
+ {"N", "", 30, { N,N,N,N,N,N,N,N } },\r
+ {"K", "", 28, { 1,1,1,1,1,1,1,1 } },\r
+ {"P", "SM", 8, { M,C,0,0,0,0,0,C } },\r
{ NULL } // sentinel\r
};\r
\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
+char shatArray[]= "RNBK:FKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbk:fkbnr";\r
+char thaiArray[]= "RNSK:SMSNR/......../PPPPPPPP/......../......../pppppppp/......../rnsk:smsnr";\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, V_SHATRANJ } Variant;\r
+typedef enum { V_CHESS, V_SHO, V_CHU, V_DAI, V_TENJIKU, V_DADA, V_MAKA, V_TAI, V_KYOKU, V_SHATRANJ, V_MAKRUK } Variant;\r
\r
VariantDesc variants[] = {\r
{ 16, 8, 8, 1, V_CHESS, "normal", chessArray }, // FIDE\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
+ { 16, 8, 8, 3, V_MAKRUK, "makruk", thaiArray}, // Makruk\r
\r
// { 0, 0, 0, 0, 0 }, // sentinel\r
{ 34, 17, 17, 0, V_DADA, "dada", chuArray }, // Dai Dai\r
return ListLookUp(name, chessPieces);\r
case V_SHATRANJ: // Shatranj\r
return ListLookUp(name, shatranjPieces);\r
+ case V_MAKRUK: // Makruk\r
+ return ListLookUp(name, makrukPieces);\r
}\r
return NULL;\r
}\r
SetUp(char *array, int var)\r
{\r
int i, j, n, m, nr, color;\r
- char c, *q, name[3];\r
+ char c, *q, name[3], prince = 0;\r
PieceDesc *p1, *p2;\r
last[WHITE] = 1; last[BLACK] = 0;\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
name[0] += 'A' - 'a';\r
if(name[1]) name[1] += 'A' - 'a';\r
} else color = WHITE;\r
+ if(!strcmp(name, "CP")) prince |= color+1; // remember if we added Crown Prince\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] && !pflag) {\r
+ if(!strcmp(p1->promoted, "CP")) prince |= color+1; // remember if we added Crown Prince\r
p2 = LookUp(p1->promoted, var);\r
m = AddPiece(color, p2);\r
if(m <= n) n += 2;\r
}\r
}\r
eos:\r
+ // add dummy Crown Princes if not yet added\r
+ if(!(prince & WHITE+1)) p[AddPiece(WHITE, LookUp("CP", V_CHU))].pos = ABSENT;\r
+ if(!(prince & BLACK+1)) p[AddPiece(BLACK, LookUp("CP", V_CHU))].pos = ABSENT;\r
for(i=0; i<8; i++) fireFlags[i] = 0;\r
for(i=2, n=1; i<10; i++) if(p[i].value == 10*FVAL) {\r
int x = p[i].pos; // mark all burn zones\r
chuFlag = (currentVariant == V_CHU);\r
tenFlag = (currentVariant == V_TENJIKU);\r
chessFlag = (currentVariant == V_CHESS);\r
+ repDraws = (currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK);\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
NewCapture(x, SPECIAL + 8*(i-1&7) + (i+1&7) + victimValue - SORTKEY(attacker), p[attacker].promoFlag);\r
v = kStep[i+1];\r
if((board[x+v] & TYPE) == xstm && board[x+v] > board[sqr])\r
+\r
NewCapture(x, SPECIAL + 8*(i+1&7) + (i-1&7) + victimValue - SORTKEY(attacker), p[attacker].promoFlag);\r
}\r
} else { // primary victim on first ring\r
if(p[i].pos != ABSENT) tb->fireMask |= fireFlags[i-2];\r
}\r
\r
+void TerminationCheck();\r
+\r
#define QSdepth 0\r
\r
int\r
int i, j, k, firstMove, oldMSP = msp, curMove, sorted, bad, phase, king, iterDep, replyDep, nextVictim, to, defer, dubious, bestMoveNr;\r
int resDep;\r
int myPV = pvPtr;\r
- int score, bestScore, curEval, iterAlpha;\r
+ int score, bestScore, oldBest, curEval, iterAlpha;\r
Move move, nullMove;\r
UndoInfo tb;\r
+#ifdef HASH\r
+ Move hashMove; int index, nr, hit;\r
+#endif\r
if(PATH) /*pboard(board),pmap(attacks, BLACK),*/printf("search(%d) {%d,%d} eval=%d, stm=%d\n",depth,alpha,beta,difEval,stm),fflush(stdout);\r
xstm = stm ^ WHITE;\r
//printf("map made\n");fflush(stdout);\r
alpha -= (alpha < curEval);\r
beta -= (beta <= curEval);\r
\r
- nodes++;\r
+ if(!(nodes++ & 4095)) TerminationCheck();\r
pv[pvPtr++] = 0; // start empty PV, directly behind PV of parent\r
\r
+\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
+ iterDep = 0; tb.fireMask = phase = 0;\r
+\r
+#ifdef HASH\r
+ index = hashKeyL & hashMask; nr = hashKeyL >> 30; hit = -1;\r
+ if(hashTable[index].lock[nr] == hashKeyH) hit = nr; else\r
+ if(hashTable[index].lock[4] == hashKeyH) hit = 4;\r
+ if(hit >= 0) {\r
+ bestScore = hashTable[index].score[hit];\r
+ if((bestScore <= alpha || hashTable[index].flag[hit] & H_LOWER) &&\r
+ (bestScore >= beta || hashTable[index].flag[hit] & H_UPPER) ) {\r
+ iterDep = hashTable[index].depth[hit];\r
+ }\r
+ } else { // decide on replacement\r
+ if(depth >= hashTable[index].depth[nr]) hit = nr; else hit = 4;\r
+ }\r
+#endif\r
+\r
+ replyDep = (depth < 1 ? depth-1 : iterDep);\r
+ while(++iterDep <= depth || iterDep == 1) {\r
if(flag && depth>= 0) printf("iter %d:%d\n", depth,iterDep),fflush(stdout);\r
iterAlpha = alpha; bestScore = -INF; bestMoveNr = 0; resDep = 60;\r
for(curMove = firstMove; ; curMove++) { // loop over moves\r
bestScore = curEval; resDep = QSdepth;\r
if(bestScore >= beta || depth < -1) goto cutoff;\r
}\r
-#if 0\r
- if(curEval >= beta) {\r
+#ifdef NULLMOVE\r
+ else if(curEval >= beta) {\r
stm ^= WHITE;\r
- score = -Search(-beta, -iterAlpha, -difEval, depth-3, promoSuppress & SQUARE, ABSENT);\r
+ score = -Search(-beta, 1-beta, -difEval, depth > 3 ? depth-3 : 0, promoSuppress & SQUARE, ABSENT);\r
stm ^= WHITE;\r
if(score >= beta) { msp = oldMSP; retDep += 3; return score + (score < curEval); }\r
}\r
//if(PATH) printf("mask=%x\n",tb.fireMask),pbytes(fireBoard);\r
phase = 1;\r
case 1: // hash move\r
+#ifdef HASH\r
+ if(hashMove) {\r
+ moveStack[sorted = msp++] = hashMove;\r
+ goto extractMove;\r
+ }\r
+#endif\r
phase = 2;\r
case 2: // capture-gen init\r
nextVictim = xstm;\r
case 6: // non-captures\r
nonCapts = msp;\r
nullMove = GenNonCapts(oldPromo);\r
+#ifdef KILLERS\r
+ { // swap killers to front\r
+ Move h = killer[level][0]; int j = curMove;\r
+ for(i=curMove; i<msp; i++) if(moveStack[i] == h) { moveStack[i] = moveStack[j]; moveStack[j++] = h; break; }\r
+ h = killer[level][1];\r
+ for(i=curMove; i<msp; i++) if(moveStack[i] == h) { moveStack[i] = moveStack[j]; moveStack[j++] = h; break; }\r
+ }\r
+#endif\r
phase = 7;\r
sorted = msp; // do not sort noncapts\r
break;\r
\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
+ if(repDraws) { score = 0; goto repetition; }\r
moveStack[curMove] = 0; // erase forbidden move\r
if(!level) repeatMove[repCnt++] = move & 0xFFFFFF; // remember outlawed move\r
score = -INF; moveStack[curMove] = 0; goto repetition;\r
repetition:\r
UnMake(&tb);\r
xstm = stm; stm ^= WHITE;\r
+ if(abortFlag > 0) { // unwind search\r
+printf("# abort (%d) @ %d\n", abortFlag, level);\r
+ if(curMove == firstMove) bestScore = oldBest, bestMoveNr = firstMove; // none searched yet\r
+ goto leave;\r
+ }\r
#if 1\r
if(PATH) printf("%d:%2d:%d %3d %6x %-10s %6d %6d\n", level, depth, iterDep, curMove, moveStack[curMove], MoveToText(moveStack[curMove], 0), score, bestScore);\r
\r
}\r
bestMoveNr = firstMove;\r
if(score >= beta) { // beta cutoff\r
- // update killer\r
+#ifdef KILLERS\r
+ if(iterDep == depth && move != killer[level][0]) {\r
+ // update killer\r
+ killer[level][1] = killer[level][0]; killer[level][0] = move;\r
+ }\r
+#endif\r
resDep = retDep;\r
goto cutoff;\r
}\r
printf("\n");\r
fflush(stdout);\r
}\r
- if(GetTickCount() - startTime > tlim1) break; // do not start iteration we can (most likely) not finish\r
+printf("# s=%d t=%d 1=%d 3=%d f=%d\n",startTime,GetTickCount(),tlim1,tlim3,abortFlag);\r
+ if(!(abortFlag & 1) && GetTickCount() - startTime > tlim1) break; // do not start iteration we can (most likely) not finish\r
}\r
replyDep = iterDep;\r
- } while(++iterDep <= depth); // next depth\r
+#ifdef HASH\r
+ // hash store\r
+ hashTable[index].lock[hit] = hashKeyH;\r
+ hashTable[index].depth[hit] = iterDep;\r
+ hashTable[index].flag[hit] = (bestScore < beta) * H_UPPER;\r
+ if(bestScore > alpha) {\r
+ hashTable[index].flag[hit] |= H_LOWER;\r
+ hashTable[index].move[hit] = bestMoveNr ? moveStack[bestMoveNr] : 0;\r
+ } else hashTable[index].move[hit] = 0;\r
+#endif\r
+ } // next depth\r
+leave:\r
retMSP = msp;\r
retFirst = firstMove;\r
msp = oldMSP; // pop move list\r
void SetMemorySize(int n); // if n is different from last time, resize all tables to make memory usage below n MB\r
char *MoveToText(MOVE move, int m); // converts the move from your internal format to text like e2e2, e1g1, a7a8q.\r
MOVE ParseMove(char *moveText); // converts a long-algebraic text move to your internal move format\r
- int SearchBestMove(int stm, int timeLeft, int mps, int timeControl, int inc, int timePerMove, MOVE *move, MOVE *ponderMove);\r
+ int SearchBestMove(MOVE *move, MOVE *ponderMove);\r
void PonderUntilInput(int stm); // Search current position for stm, deepening forever until there is input.\r
\r
UndoInfo undoInfo;\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
+ if((currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK) && *fen - 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
void\r
SetMemorySize (int n)\r
{\r
+#ifdef HASH\r
+ static HashBucket *realHash;\r
+ static int oldSize;\r
+ int m = 1;\r
+ intptr_t l;\r
+ if(n != oldSize) {\r
+ if(oldSize) free(realHash);\r
+ while(m*sizeof(HashBucket) <= n*512) m <<= 1;\r
+ m *= 1024; hashMask = m - 1;\r
+ realHash = calloc(m + 1, sizeof(HashBucket));\r
+ l = (intptr_t) realHash; hashTable = (HashBucket*) (l & ~63); // align with cache line\r
+ }\r
+#endif\r
}\r
\r
char *\r
{\r
static char buf[50];\r
int f = move>>SQLEN & SQUARE, g = f, t = move & SQUARE;\r
+ char *promoChar = "";\r
if(f == t) { sprintf(buf, "@@@@"); return buf; } // null-move notation in WB protocol\r
buf[0] = '\0';\r
if(t >= SPECIAL) { // kludgy! Print as side effect non-standard WB command to remove victims from double-capture (breaks hint command!)\r
}\r
t = g + toList[t - SPECIAL];\r
}\r
- sprintf(buf+strlen(buf), "%c%d%c%d%s", f%BW+'a', f/BW+ONE, t%BW+'a', t/BW+ONE, move & PROMOTE ? "+" : "");\r
+ if(move & PROMOTE) promoChar = currentVariant == V_MAKRUK ? "m" : repDraws ? "q" : "+";\r
+ sprintf(buf+strlen(buf), "%c%d%c%d%s", f%BW+'a', f/BW+ONE, t%BW+'a', t/BW+ONE, promoChar);\r
return buf;\r
}\r
\r
return 2 + (r + ONE > 9);\r
}\r
\r
+int listStart, listEnd;\r
+char boardCopy[BSIZE];\r
+\r
+void\r
+ListMoves ()\r
+{ // create move list on move stack\r
+ int i;\r
+ for(i=0; i< BSIZE; i++) boardCopy[i] = !!board[i];\r
+MapFromScratch(attacks);\r
+ postThinking--; repCnt = 0; tlim1 = tlim2 = tlim3 = 1e8; abortFlag = msp = 0;\r
+ Search(-INF-1, INF+1, 0, 1, sup1 & ~PROMOTE, sup2);\r
+ postThinking++;\r
+ listStart = retFirst; listEnd = msp = retMSP;\r
+}\r
+\r
MOVE\r
ParseMove (char *moveText)\r
{\r
t2 = SPECIAL + 8*i + j;\r
}\r
ret = f<<SQLEN | t2;\r
- if(*moveText == '+') ret |= PROMOTE;\r
+ if(*moveText != '\n' && *moveText != '=') ret |= PROMOTE;\r
printf("# suppress = %c%d\n", sup1%BW+'a', sup1/BW);\r
-MapFromScratch(attacks);\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
+// ListMoves();\r
+ for(i=listStart; i<listEnd; i++) {\r
if(moveStack[i] == INVALID) continue;\r
if(c == '@' && (moveStack[i] & SQUARE) == (moveStack[i] >> SQLEN & SQUARE)) break; // any null move matches @@@@\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
+printf("# moveNr = %d in {%d,%d}\n", i, listStart, listEnd);\r
+ if(i>=listEnd) { // no exact match\r
if(deferred) { // but maybe non-sensical deferral\r
int flags = p[board[f]].promoFlag;\r
printf("# deferral of %d\n", deferred);\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-50, moveStack[i], ret, MoveToText(moveStack[i], 0));\r
+ if(i >= listEnd) {\r
+ for(i=listStart; i<listEnd; 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
}\r
}\r
}\r
- return (i >= retMSP ? INVALID : moveStack[i]);\r
+ return (i >= listEnd ? INVALID : moveStack[i]);\r
}\r
\r
void\r
char b[BSIZE], buf[2000], *q;\r
for(i=0; i<bsize; i++) b[i] = 0;\r
ReadSquare(coords, &sqr);\r
-MapFromScratch(attacks);\r
-//pmap(attacks, WHITE);\r
-//pmap(attacks, BLACK);\r
-//flag=1;\r
- postThinking--; repCnt = 0;\r
- Search(-INF-1, INF+1, 0, 1, sup1 & ~PROMOTE, sup2);\r
- postThinking++;\r
-flag=0;\r
- for(i=retFirst; i<retMSP; i++) {\r
+// ListMoves();\r
+ for(i=listStart; i<listEnd; i++) {\r
if(sqr == (moveStack[i]>>SQLEN & SQUARE)) {\r
int t = moveStack[i] & SQUARE;\r
if(t >= SPECIAL) continue;\r
- b[t] = (board[t] == EMPTY ? 'Y' : 'R'); cnt++;\r
+ b[t] = (!boardCopy[t] ? 'Y' : 'R'); cnt++;\r
}\r
}\r
if(!cnt) { // no moves from given square\r
if(sqr != lastPut) return; // refrain from sending empty FEN\r
// we lifted a piece for second leg of move\r
- for(i=retFirst; i<retMSP; i++) {\r
+ for(i=listStart; i<listEnd; i++) {\r
if(lastLift == (moveStack[i]>>SQLEN & SQUARE)) {\r
int e, t = moveStack[i] & SQUARE;\r
if(t < SPECIAL) continue; // only special moves\r
e = lastLift + epList[t - SPECIAL]; // decode\r
t = lastLift + toList[t - SPECIAL];\r
if(e != sqr) continue;\r
- b[t] = (board[t] == EMPTY ? 'Y' : 'R'); cnt++;\r
+ b[t] = (!boardCopy[t] ? 'Y' : 'R'); cnt++;\r
}\r
}\r
if(!cnt) return;\r
printf("highlight %s\n", buf);\r
}\r
\r
-int\r
-SearchBestMove (int stm, int timeLeft, int mps, int timeControl, int inc, int timePerMove, MOVE *move, MOVE *ponderMove)\r
+int timeLeft; // timeleft on engine's clock\r
+int mps, timeControl, inc, timePerMove; // time-control parameters, to be used by Search\r
+char inBuf[8000], command[80], ponderMoveText[20];\r
+\r
+void\r
+SetSearchTimes (int timeLeft)\r
{\r
- int score, targetTime, movesLeft = BW*BH/4 + 20;\r
+ int targetTime, movesLeft = BW*BH/4 + 20;\r
if(mps) movesLeft = mps - (moveNr>>1)%mps;\r
- targetTime = timeLeft*10 / (movesLeft + 2) + 1000 * inc;\r
+ targetTime = (timeLeft - 1000*inc) / (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
+ if(timePerMove > 0) targetTime = 0.5*timeLeft, movesLeft = 1;\r
tlim1 = 0.2*targetTime;\r
tlim2 = 1.9*targetTime;\r
+ tlim3 = 5*timeLeft / (movesLeft + 4.1);\r
+}\r
+\r
+int\r
+SearchBestMove (MOVE *move, MOVE *ponderMove)\r
+{\r
+ int score;\r
+ startTime = GetTickCount();\r
nodes = 0;\r
MapFromScratch(attacks);\r
retMove = INVALID; repCnt = 0;\r
score = Search(-INF-1, INF+1, rootEval, maxDepth, sup1, sup2);\r
*move = retMove;\r
- *ponderMove = INVALID;\r
+ *ponderMove = pv[1];\r
return score;\r
}\r
\r
+\r
void\r
PonderUntilInput (int stm)\r
{\r
+MapFromScratch(attacks);\r
+ repCnt = 0; abortFlag = -1;\r
+ Search(-INF-1, INF+1, rootEval, maxDepth, sup1, sup2);\r
}\r
-\r
+ \r
int TakeBack(int n)\r
{ // reset the game and then replay it to the desired point\r
int last, stm;\r
else printf("0-1%s\n", tail);\r
}\r
\r
+ void GetLine(int root)\r
+ {\r
+ int i, c;\r
+ while(1) {\r
+ // wait for input, and read it until we have collected a complete line\r
+ for(i = 0; (inBuf[i] = c = getchar()) != '\n'; i++) if(c == EOF || i>7997) exit(0);\r
+ inBuf[i+1] = 0;\r
+\r
+ // extract the first word\r
+ sscanf(inBuf, "%s", command);\r
+printf("# in (mode = %d,%d): %s\n", root, abortFlag, command);\r
+ if(!strcmp(command, "otim")) { continue; } // do not start pondering after receiving time commands, as move will follow immediately\r
+ if(!strcmp(command, "time")) { sscanf(inBuf, "time %d", &timeLeft); continue; }\r
+ if(!strcmp(command, "put")) { ReadSquare(inBuf+4, &lastPut); continue; } // ditto\r
+ if(!strcmp(command, ".")) { inBuf[0] = 0; return; } // ignore for now\r
+ if(!strcmp(command, "lift")) { inBuf[0] = 0; Highlight(inBuf+5); return; } // treat here\r
+ abortFlag = 1;\r
+ return;\r
+ }\r
+ }\r
+\r
+ void\r
+ TerminationCheck()\r
+ {\r
+ if(abortFlag < 0) { // check for input\r
+ if(InputWaiting()) GetLine(0); // read & examine input command\r
+ } else { // check for time\r
+ if(GetTickCount() - startTime > tlim3) abortFlag = 2;\r
+ }\r
+ }\r
+\r
main()\r
{\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
- MOVE move, ponderMove;\r
- int i, score;\r
- char inBuf[8000], command[80];\r
+ MOVE move;\r
+ int i, score, curVarNr;\r
\r
Init(V_CHU); // Chu\r
+ listEnd = 1;\r
\r
while(1) { // infinite loop\r
\r
fflush(stdout); // make sure everything is printed before we do something that might take time\r
+ *inBuf = 0;\r
+\r
+ if(listEnd == 0) ListMoves(); // always maintain a list of legal moves in root position\r
\r
+ abortFlag = 0;\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
+ SetSearchTimes(10*timeLeft);\r
+ score = SearchBestMove(&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
stm = MakeMove2(stm, move); // assumes MakeMove returns new side to move\r
gameMove[moveNr++] = move; // remember game\r
printf("move %s\n", MoveToText(move, 1));\r
+ listEnd = 0;\r
}\r
}\r
\r
}\r
}\r
\r
- noPonder:\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
-\r
- // extract the first word\r
- sscanf(inBuf, "%s", command);\r
-printf("in: %s\n", command);\r
+ fflush(stdout); // make sure everything is printed before we do something that might take time\r
+ if(!*inBuf) GetLine(1); // takes care of time and otim commands\r
\r
// recognize the command,and execute it\r
if(!strcmp(command, "quit")) { break; } // breaks out of infinite loop\r
if(!strcmp(command, "force")) { engineSide = NONE; continue; }\r
if(!strcmp(command, "analyze")) { engineSide = ANALYZE; continue; }\r
if(!strcmp(command, "exit")) { engineSide = NONE; continue; }\r
- if(!strcmp(command, "otim")) { goto noPonder; } // do not start pondering after receiving time commands, as move will follow immediately\r
- if(!strcmp(command, "time")) { sscanf(inBuf, "time %d", &timeLeft); goto noPonder; }\r
if(!strcmp(command, "level")) {\r
int min, sec=0;\r
sscanf(inBuf, "level %d %d %d", &mps, &min, &inc) == 3 || // if this does not work, it must be min:sec format\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,shatranj,chu,dai,tenjiku,12x12+0_fairy,9x9+0_shogi\"\n");\r
+ printf("feature variants=\"normal,shatranj,makruk,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
if(sscanf(inBuf+7, "Contempt=%d", &contemptFactor) == 1) continue;\r
continue;\r
}\r
- if(!strcmp(command, "variant")) {\r
- for(i=0; i<6; i++) {\r
- sscanf(inBuf+8, "%s", command);\r
- if(!strcmp(variants[i].name, command)) {\r
- Init(i); stm = Setup2(NULL); break;\r
- }\r
- }\r
- continue;\r
- }\r
if(!strcmp(command, "sd")) { sscanf(inBuf, "sd %d", &maxDepth); continue; }\r
if(!strcmp(command, "st")) { sscanf(inBuf, "st %d", &timePerMove); continue; }\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")) {\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, "remove")) { stm = TakeBack(2); continue; }\r
if(!strcmp(command, "go")) { engineSide = stm; continue; }\r
if(!strcmp(command, "post")) { postThinking = ON; continue; }\r
if(!strcmp(command, "nopost")) { postThinking = OFF;continue; }\r
if(!strcmp(command, "random")) { randomize = ON; continue; }\r
if(!strcmp(command, "hint")) { if(ponderMove != INVALID) printf("Hint: %s\n", MoveToText(ponderMove, 0)); continue; }\r
- if(!strcmp(command, "lift")) { Highlight(inBuf+5); continue; }\r
- if(!strcmp(command, "put")) { ReadSquare(inBuf+4, &lastPut); continue; }\r
if(!strcmp(command, "book")) { continue; }\r
// non-standard commands\r
if(!strcmp(command, "p")) { pboard(board); continue; }\r
if(!strcmp(command, "accepted")){ continue; }\r
if(!strcmp(command, "rejected")){ continue; }\r
if(!strcmp(command, "result")) { continue; }\r
- if(!strcmp(command, "hover")) { continue; }\r
+ if(!strcmp(command, "hover")) { continue; }\r
if(!strcmp(command, "")) { continue; }\r
if(!strcmp(command, "usermove")){\r
int move = ParseMove(inBuf+9);\r
if(comp) PrintResult(stm, -INF); // against computer: claim\r
} else {\r
stm = MakeMove2(stm, move);\r
- ponderMove = INVALID;\r
+ ponderMove = INVALID; listEnd = 0;\r
gameMove[moveNr++] = move; // remember game\r
}\r
continue;\r
}\r
+ listEnd = 0;\r
+ if(!strcmp(command, "new")) {\r
+ engineSide = BLACK; Init(V_CHESS); stm = Setup2(NULL); maxDepth = MAXPLY; randomize = OFF; curVarNr = comp = 0;\r
+ continue;\r
+ }\r
+ if(!strcmp(command, "variant")) {\r
+ for(i=0; i<7; i++) {\r
+ sscanf(inBuf+8, "%s", command);\r
+ if(!strcmp(variants[i].name, command)) {\r
+ Init(curVarNr = i); stm = Setup2(NULL); break;\r
+ }\r
+ }\r
+ continue;\r
+ }\r
+ if(!strcmp(command, "setboard")){ engineSide = NONE; Init(curVarNr); stm = Setup2(inBuf+9); continue; }\r
+ if(!strcmp(command, "undo")) { stm = TakeBack(1); continue; }\r
+ if(!strcmp(command, "remove")) { stm = TakeBack(2); continue; }\r
printf("Error: unknown command\n");\r
}\r
}\r
projects / hachu.git / blobdiff