// promotions by pieces with Lion power stepping in & out the zone in same turn\r
// promotion on capture\r
\r
-#define VERSION "0.16 k+ky"\r
+#define VERSION "0.18"\r
\r
-//define PATH level==0 /*|| path[0] == 0x3490a && (level==1 || path[1] == 0x285b3 && (level == 2 || path[2] == 0x8710f && (level == 3 /*|| path[3] == 0x3e865 && (level == 4 || path[4] == 0x4b865 && (level == 5)))))*/\r
+//define PATH level==0 || path[0] == 0x1103a && (level==1 || path[1] == 0x6f0f6 && (level == 2 /*|| path[2] == 0x8710f && (level == 3 /*|| path[3] == 0x3e865 && (level == 4 || path[4] == 0x4b865 && (level == 5)))*/))\r
#define PATH 0\r
\r
#define HASH\r
#define BSIZE BWMAX*BHMAX\r
#define ZONE zone\r
\r
-#define ONE (currentVariant == V_SHO || currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK || currentVariant == V_LION)\r
+#define ONE 1 /* currently no variants with 10-deep board */\r
\r
#define BLACK 0\r
#define WHITE 1\r
} UndoInfo;\r
\r
char *array, fenArray[4000], startPos[4000], *reason, checkStack[300];\r
-int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag, repDraws, tsume, pvCuts, allowRep, entryProm;\r
+int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag, repDraws, stalemate;\r
+int tsume, pvCuts, allowRep, entryProm, okazaki, pVal;\r
int stm, xstm, hashKeyH=1, hashKeyL=1, framePtr, msp, nonCapts, rootEval, filling, promoDelta;\r
int retMSP, retFirst, retDep, pvPtr, level, cnt50, mobilityScore;\r
int ll, lr, ul, ur; // corner squares\r
};\r
\r
PieceDesc chessPieces[] = {\r
- {"Q", "", 950, { X,X,X,X,X,X,X,X } },\r
+ {"FK", "", 950, { X,X,X,X,X,X,X,X } },\r
{"R", "", 500, { X,0,X,0,X,0,X,0 } },\r
{"B", "", 320, { 0,X,0,X,0,X,0,X } },\r
{"N", "", 300, { N,N,N,N,N,N,N,N } },\r
{"K", "", 280, { 1,1,1,1,1,1,1,1 } },\r
- {"P", "Q", 80, { M,C,0,0,0,0,0,C } },\r
+ {"P", "FK", 80, { M,C,0,0,0,0,0,C } },\r
{ NULL } // sentinel\r
};\r
\r
PieceDesc lionPieces[] = {\r
{"LN","", LVAL, { L,L,L,L,L,L,L,L } },\r
- {"Q", "", 600, { X,X,X,X,X,X,X,X } },\r
+ {"FK", "", 600, { X,X,X,X,X,X,X,X } },\r
{"R", "", 300, { X,0,X,0,X,0,X,0 } },\r
{"K", "", 280, { 1,1,1,1,1,1,1,1 } },\r
{"B", "", 190, { 0,X,0,X,0,X,0,X } },\r
{"N", "", 180, { N,N,N,N,N,N,N,N } },\r
- {"P", "Q", 50, { M,C,0,0,0,0,0,C } },\r
+ {"P", "FK", 50, { M,C,0,0,0,0,0,C } },\r
{ NULL } // sentinel\r
};\r
\r
"....d......d..../pppppppppppppppp/:sm:vmr:hf:se:bg:rg:vg:gg:rg:bg:se:hfr:vm:sm/"\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 lionArray[] = "R:LNBQKBNR/PPPPPPPP/......../......../......../......../pppppppp/r:lnbqkbnr";\r
+char chessArray[] = "RNB:FKKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnb:fkkbnr";\r
+char lionArray[] = "R:LNB:FKKBNR/PPPPPPPP/......../......../......../......../pppppppp/r:lnb:fkkbnr";\r
char shatArray[]= "RNBK:FKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbk:fkbnr";\r
-char thaiArray[]= "RNSK:SMSNR/......../PPPPPPPP/......../......../pppppppp/......../rnsk:smsnr";\r
+char thaiArray[]= "RNSK:SMSNR/......../PPPPPPPP/......../......../pppppppp/......../rns:smksnr";\r
\r
typedef struct {\r
int boardWidth, boardFiles, boardRanks, zoneDepth, varNr; // board sizes\r
\r
typedef enum { V_CHESS, V_SHO, V_CHU, V_DAI, V_DADA, V_MAKA, V_TAI, V_KYOKU, V_TENJIKU, V_SHATRANJ, V_MAKRUK, V_LION } Variant;\r
\r
+#define SAME (-1)\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
+ { 16, 8, 8, 1, V_CHESS, "nocastle", chessArray }, // FIDE\r
{ 18, 9, 9, 3, V_SHO, "9x9+0_shogi", shoArray }, // Sho\r
{ 18, 9, 9, 3, V_SHO, "sho", shoArray }, // Sho duplicat\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
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
+ if(!strcmp(name, "CP") || pflag && !strcmp(name, "DE")) 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
Init (int var)\r
{\r
int i, j, k;\r
+ PieceDesc *pawn;\r
\r
+ if(var != SAME) { // the following should be already set if we stay in same variant (for TakeBack)\r
currentVariant = variants[var].varNr;\r
bWidth = variants[var].boardWidth;\r
bHeight = variants[var].boardRanks;\r
zone = variants[var].zoneDepth;\r
array = variants[var].array;\r
+ }\r
bsize = bWidth*bHeight;\r
chuFlag = (currentVariant == V_CHU || currentVariant == V_LION);\r
tenFlag = (currentVariant == V_TENJIKU);\r
chessFlag = (currentVariant == V_CHESS || currentVariant == V_LION);\r
- repDraws = (currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK || currentVariant == V_LION);\r
+ stalemate = (currentVariant == V_CHESS || currentVariant == V_MAKRUK || currentVariant == V_LION);\r
+ repDraws = (stalemate || currentVariant == V_SHATRANJ);\r
ll = 0; lr = bHeight - 1; ul = (bHeight - 1)*bWidth; ur = ul + bHeight - 1;\r
+ pawn = LookUp("P", currentVariant); pVal = pawn ? pawn->value : 0; // get Pawn value\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
} else\r
if(r == M) { // FIDE Pawn; check double-move\r
- if(!NewNonCapture(x, x+v, pFlag) && chessFlag && promoBoard[x-v])\r
+ if(!NewNonCapture(x, x+v, pFlag) && chessFlag && promoBoard[x-v] & LAST_RANK)\r
NewNonCapture(x, x+2*v, pFlag), moveStack[msp-1] |= DEFER; // use promoSuppress flag as e.p. flag\r
}\r
continue;\r
\r
#ifdef KINGSAFETY\r
// basic centralization in end-game (also facilitates bare-King mating)\r
- wKing = p[royal[WHITE]].pos; if(wKing == ABSENT) wKing = p[royal[WHITE]+1].pos;\r
- bKing = p[royal[BLACK]].pos; if(bKing == ABSENT) bKing = p[royal[BLACK]+1].pos;\r
+ wKing = p[royal[WHITE]].pos; if(wKing == ABSENT) wKing = p[royal[WHITE]+2].pos;\r
+ bKing = p[royal[BLACK]].pos; if(bKing == ABSENT) bKing = p[royal[BLACK]+2].pos;\r
if(filling < 32) {\r
int lead = (stm == WHITE ? difEval : -difEval);\r
score += (PST[3*BW*BH+wKing] - PST[3*BW*BH+bKing])*(32 - filling) >> 7;\r
int\r
Search (int alpha, int beta, int difEval, int depth, int lmr, int oldPromo, int promoSuppress, int threshold)\r
{\r
- int i, j, k, phase, king, nextVictim, to, defer, autoFail=0, inCheck = 0, late=100000;\r
+ int i, j, k, phase, king, nextVictim, to, defer, autoFail=0, inCheck = 0, late=100000, ep;\r
int firstMove, oldMSP = msp, curMove, sorted, bad, dubious, bestMoveNr;\r
int resDep, iterDep, ext;\r
int myPV = pvPtr;\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]) return INF; // we have attack on Crown Prince\r
+ if(k == ABSENT || attacks[2*k + stm]) return INF; // we have attack on Crown Prince\r
}\r
//printf("King safe\n");fflush(stdout);\r
// EVALUATION & WINDOW SHIFT\r
autoFail = 0; curMove = firstMove - 1; continue; // release stashed moves for search\r
}\r
phase = 4; // out of victims: all captures generated\r
- if(chessFlag && promoSuppress != ABSENT) { // e.p. rights. Create e.p. captures as Lion moves\r
- int n = board[promoSuppress-1], old = msp; // a-side neighbor of pushed pawn\r
- if( n != EMPTY && (n&TYPE) == stm && p[n].value == 80 ) NewCapture(promoSuppress-1, SPECIAL + 20 - 4*stm, 0);\r
- n = board[promoSuppress+1]; // h-side neighbor of pushed pawn\r
- if( n != EMPTY && (n&TYPE) == stm && p[n].value == 80 ) NewCapture(promoSuppress+1, SPECIAL + 52 - 4*stm, 0);\r
+ if(chessFlag && (ep = promoSuppress & SQUARE) != ABSENT) { // e.p. rights. Create e.p. captures as Lion moves\r
+ int n = board[ep-1], old = msp; // a-side neighbor of pushed pawn\r
+ if( n != EMPTY && (n&TYPE) == stm && p[n].value == pVal ) NewCapture(ep-1, SPECIAL + 20 - 4*stm, 0);\r
+ n = board[ep+1]; // h-side neighbor of pushed pawn\r
+ if( n != EMPTY && (n&TYPE) == stm && p[n].value == pVal ) NewCapture(ep+1, SPECIAL + 52 - 4*stm, 0);\r
if(msp != old) goto extractMove; // one or more e.p. capture were generated\r
}\r
case 4: // dubious captures\r
if(dist[tb.from-tb.to] != 1 && attacks[2*tb.to + stm] && p[tb.epVictim[0]].value <= 50)\r
score = -INF; // our Lion is indeed made vulnerable and can be recaptured\r
} else { // other x Ln\r
- if(promoSuppress & PROMOTE) score = -INF; // non-Lion captures Lion after opponent did same\r
+ if(promoSuppress & PROMOTE) { // non-Lion captures Lion after opponent did same\r
+ if(!okazaki || attacks[2*tb.to + stm]) score = -INF;\r
+ }\r
defer |= PROMOTE; // if we started, flag he cannot do it in reply\r
}\r
if(score == -INF) {\r
if(lmr && bestScore <= alpha && iterDep == depth)\r
depth++, lmr--; // self-deepen on fail-low reply to late move by lowering reduction\r
#endif\r
+ if(stalemate && bestScore == -INF && !inCheck) bestScore = 0; // stalemate\r
#ifdef HASH\r
// hash store\r
hashTable[index].lock[hit] = hashKeyH;\r
for(j=0; j<8; j++) if(e + kStep[j] == t) break;\r
if(j >= 8) return INVALID; // this rejects Lion Dog 1+2 moves!\r
t2 = SPECIAL + 8*i + j;\r
- } else if(chessFlag && board[f] != EMPTY && p[board[f]].value == 80 && board[t] == EMPTY) { // Pawn to empty, could be e.p.\r
+ } else if(chessFlag && board[f] != EMPTY && p[board[f]].value == pVal && board[t] == EMPTY) { // Pawn to empty, could be e.p.\r
if(t == f + BW + 1) t2 = SPECIAL + 16; else\r
if(t == f + BW - 1) t2 = SPECIAL + 48; else\r
if(t == f - BW + 1) t2 = SPECIAL + 20; else\r
printf("# s=%d\n", startTime);fflush(stdout);\r
MapFromScratch(attacks);\r
retMove = INVALID; repCnt = 0;\r
- score = Search(-INF-1, INF+1, rootEval, maxDepth, 0, sup1, sup2, INF);\r
+ score = Search(-INF-1, INF+1, rootEval, maxDepth + QSdepth, 0, sup1, sup2, INF);\r
*move = retMove;\r
*ponderMove = pv[1];\r
printf("# best=%s\n", MoveToText(pv[0],0));\r
{ // reset the game and then replay it to the desired point\r
int last, stm;\r
last = moveNr - n; if(last < 0) last = 0;\r
- Init(currentVariant); stm = Setup2(startPos);\r
+ Init(SAME); stm = Setup2(startPos);\r
printf("# setup done");fflush(stdout);\r
for(moveNr=0; moveNr<last; moveNr++) stm = MakeMove2(stm, gameMove[moveNr]),printf("make %2d: %x\n", moveNr, gameMove[moveNr]);\r
return stm;\r
PrintResult(stm, score);\r
} else {\r
MOVE f, pMove = move;\r
- if((move & SQUARE) >= SPECIAL && p[board[f = move>>SQLEN & SQUARE]].value == 80) { // e.p. capture\r
+ if((move & SQUARE) >= SPECIAL && p[board[f = move>>SQLEN & SQUARE]].value == pVal) { // e.p. capture\r
pMove = move & ~SQUARE | f + toList[(move & SQUARE) - SPECIAL]; // print as a single move\r
}\r
stm = MakeMove2(stm, move); // assumes MakeMove returns new side to move\r
printf("feature option=\"Full analysis PV -check 1\"\n"); // example of an engine-defined option\r
printf("feature option=\"Allow repeats -check 0\"\n");\r
printf("feature option=\"Promote on entry -check 0\"\n");\r
+ printf("feature option=\"Okazaki rule -check 0\"\n");\r
printf("feature option=\"Resign -check 0\"\n"); // \r
printf("feature option=\"Contempt -spin 0 -200 200\"\n"); // and another one\r
printf("feature option=\"Tsume -combo no /// Sente mates /// Gote mates\"\n");\r
if(sscanf(inBuf+7, "Allow repeats=%d", &allowRep) == 1) continue;\r
if(sscanf(inBuf+7, "Resign=%d", &resign) == 1) continue;\r
if(sscanf(inBuf+7, "Contempt=%d", &contemptFactor) == 1) continue;\r
+ if(sscanf(inBuf+7, "Okazaki rule=%d", &okazaki) == 1) continue;\r
if(sscanf(inBuf+7, "Promote on entry=%d", &entryProm) == 1) continue;\r
if(sscanf(inBuf+7, "Tsume=%s", command) == 1) {\r
if(!strcmp(command, "no")) tsume = 0; else\r
}\r
if(!strcmp(command, "sd")) { sscanf(inBuf, "sd %d", &maxDepth); continue; }\r
if(!strcmp(command, "st")) { sscanf(inBuf, "st %d", &timePerMove); continue; }\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
projects / hachu.git / blobdiff