-/***********************************************************************/\r
-/* HaChu */\r
-/* A WinBoard engine for large (dropless) Shogi variants by H.G.Muller */\r
-/* The engine is based on incremental updating of an attack map and */\r
-/* mobility scores, since the effort in this only grows proportional */\r
-/* to board edge length, rather than board area. */\r
-/***********************************************************************/\r
+/**************************************************************************/\r
+/* HaChu */\r
+/* A WinBoard engine for Chu Shogi (and some related games) by H.G.Muller */\r
+/**************************************************************************/\r
+/* This source code is released in the public domain */\r
+/**************************************************************************/\r
\r
// TODO:\r
// in GenCapts we do not generate jumps of more than two squares yet\r
// 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 0\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 0\r
\r
#define HASH\r
#define KILLERS\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)\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, tsume, pvCuts, allowRep, entryProm, 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
+ {"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", "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 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
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, V_MAKRUK } Variant;\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
- { 18, 9, 9, 3, V_SHO, "9x9+0_shogi", shoArray }, // Sho\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
{ 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
+ { 16, 8, 8, 1, V_LION, "lion", lionArray}, // Mighty Lion\r
\r
-// { 0, 0, 0, 0, 0 }, // sentinel\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
{ 50, 25, 25, 0, V_TAI, "tai", chuArray }, // Tai\r
return ListLookUp(name, shatranjPieces);\r
case V_MAKRUK: // Makruk\r
return ListLookUp(name, makrukPieces);\r
+ case V_LION: // Mighty Lion\r
+ return ListLookUp(name, lionPieces);\r
}\r
return NULL;\r
}\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);\r
+ chuFlag = (currentVariant == V_CHU || currentVariant == V_LION);\r
tenFlag = (currentVariant == V_TENJIKU);\r
- chessFlag = (currentVariant == V_CHESS);\r
- repDraws = (currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK);\r
+ chessFlag = (currentVariant == V_CHESS || 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
mobilityScore -= MapOneColor(0, last[BLACK], map);\r
}\r
\r
-void\r
-Connect (int sqr, int piece, int dir)\r
-{ // scan to both sides along ray to elongate attacks from there, and remove our own attacks on there, if needed\r
- int x, step = kStep[dir], r1 = p[piece].range[dir], r2 = p[piece].range[dir+4], r3, r4, piece1, piece2;\r
- int d1, d2, r, y, c;\r
-\r
- if((attacks[2*sqr] + attacks[2*sqr+1]) & attackMask[dir]) { // there are incoming attack(s) from 'behind'\r
- x = sqr;\r
- while(board[x-=step] == EMPTY); // in any case, scan to attacker, to see where / what it is\r
- d1 = dist[x-sqr]; piece1 = board[x];\r
- attacks[2*x + stm] -= -(d1 <= r2) & one[dir+4]; // remove our attack on it if in-range\r
- if((attacks[2*sqr] + attacks[2*sqr+1]) & attackMask[dir+4]) { // there are also incoming attack(s) from 'ahead'\r
-\r
- y = sqr;\r
- while(board[y+=step] == EMPTY); // also always scan to that one to see what it is\r
- d2 = dist[y-sqr]; piece2 = board[y];\r
- attacks[2*y+stm] -= -(d2 <= r1) & one[dir]; // remove our attack on it if in-range\r
- // we have two pieces now shooting at each other. See how far they get.\r
- if(d1 + d2 <= (r3 = p[piece1].range[dir])) { // 1 hits 2\r
- attacks[2*y + (piece1 & WHITE)] += one[dir]; // count attack\r
- UPDATE_MOBILITY(piece1, d2);\r
- } else UPDATE_MOBILITY(piece1, r3 - d1); // does not connect, but could still gain mobility\r
- if(d1 + d2 <= (r4 = p[piece2].range[dir+4])) { // 2 hits 1\r
- attacks[2*x + (piece2 & WHITE)] += one[dir+4]; // count attack\r
- UPDATE_MOBILITY(piece2, d1);\r
- } else UPDATE_MOBILITY(piece2, r4 - d2); // does not connect, but could still gain mobility\r
- // if r1 or r2<0, moves typically jump, and thus cannot be unblocked. Exceptions are FF and BS distant moves.\r
- // test for d1+d2 > 2 && rN == F && d== 3 or rN == S\r
- if(d1 <= 2) { // could be jump interactions\r
- if(d1 == 2) {\r
- if(r2 <= J) attacks[2*x + stm] -= one[dir+4];\r
- if(r1 <= J) attacks[2*y + stm] -= one[dir];\r
- } else { // d1 == 1\r
- if(r2 < J) attacks[2*x + stm] -= one[dir+4];\r
- if(r1 < J) attacks[2*y + stm] -= one[dir];\r
- if(board[x-step] != EMPTY && board[x-step] != EDGE)\r
- attacks[2*(x-step) + stm] -= one[dir+4];\r
- }\r
- }\r
-\r
- } else { // we were only attacked from behind\r
-\r
- r = (r2 = p[piece1].range[dir]) - d1;\r
- if(r < 0 || c > one[dir+4]) { // Oops! This was not our attacker, or not the only one. There must be a jump attack from even further behind!\r
- // for now, forget jumpers\r
- }\r
- y = sqr; \r
- while(r--)\r
- if(board[y+=step] != EMPTY) {\r
- d2 = dist[y-sqr]; piece2 = board[y];\r
- if(piece2 != EDGE) { // extended move hits a piece\r
- attacks[2*y + (piece1 & WHITE)] += one[dir]; // count attack\r
- attacks[2*y + stm] -= -(d2 <= r1) & one[dir]; // remove our own attack on it, if in-range\r
- }\r
- UPDATE_MOBILITY(piece1, d2); // count extra mobility even if we hit edge\r
- return;\r
- }\r
- // we hit nothing with the extended move of the attacker behind us.\r
- UPDATE_MOBILITY(piece1, r2 - d1);\r
- r = r1 - r2 + d1; // extra squares covered by mover\r
- while(r-- > 0)\r
- if(board[y+=step] != EMPTY) {\r
- d2 = dist[y-sqr]; piece2 = board[y];\r
- if(piece2 != EDGE) { // extended move hits a piece\r
- attacks[2*y + stm] -= one[dir]; // count attack\r
- }\r
- return;\r
- }\r
- }\r
- // if r2<0 we should again test for F and S moves\r
-\r
- } else // no incoming attack from behind\r
- if(c = (attacks[2*sqr] + attacks[2*sqr+1]) & attackMask[dir+4]) { // but incoming attack(s) from 'ahead'\r
-\r
- y = sqr; while(board[y+=step]); // locate attacker\r
- d2 = dist[y-sqr]; piece2 = board[y];\r
- attacks[2*y + stm] -= -(d2 <= r1) & one[dir]; // remove our attack on it if in-range\r
- r = (r1 = p[piece1].range[dir]) - d2;\r
- if(r < 0 || c > one[dir]) { // Oops! This was not our attacker, or not the only one. There must be a jump attack from even further behind!\r
- // for now, forget jumpers\r
- }\r
- x = sqr;\r
- while(r--)\r
- if(board[x-=step] != EMPTY) {\r
- d1 = dist[x-sqr]; piece1 = board[x];\r
- if(piece1 != EDGE) { // extended move hits a piece\r
- attacks[2*x + (piece2 & WHITE)] += one[dir+4]; // count attack\r
- attacks[2*x + stm] -= -(d1 <= r2) & one[dir+4]; // remove our own attack on it, if in-range\r
- }\r
- UPDATE_MOBILITY(piece2, d1); // count extra mobility even if we hit edge\r
- return;\r
- }\r
- // we hit nothing with the extended move of the attacker behind us.\r
- UPDATE_MOBILITY(piece2, r2 - d1);\r
- r = r2 - r1 + d2; // extra squares covered by mover\r
- while(r-- > 0)\r
- if(board[x-=step] != EMPTY) {\r
- d1 = dist[x-sqr]; piece1 = board[x];\r
- if(piece1 != EDGE) { // extended move hits a piece\r
- attacks[2*x + stm] -= one[dir+4]; // count attack\r
- }\r
- return;\r
- }\r
-\r
- } else { // no incoming attacks from either side. Only delete attacks of mover on others\r
-\r
- x = sqr;\r
- while(r1--)\r
- if(board[x+=step] != EMPTY) { // piece found that we attacked\r
- attacks[2*x + stm] -= one[dir]; // decrement attacks along that direction\r
- break;\r
- }\r
-\r
- x = sqr;\r
- while(r2--)\r
- if(board[x-=step] != EMPTY) { // piece found that we attacked\r
- attacks[2*x + stm] -= one[dir+4]; // decrement attacks along opposite direction\r
- break;\r
- }\r
-\r
- }\r
-}\r
-\r
-inline int\r
-Hit (int r, int d)\r
-{ // test if move with range r reaches over (un-obstructed) distance d\r
- if(r < 0) switch(r) {\r
- case J: return (d == 2);\r
- case D:\r
- case L: return (d <= 2);\r
- case T:\r
- case F: return (d <= 3);\r
- case S: return 1;\r
- default: return 0;\r
- } else return (d <= r);\r
- return 0; // not reached\r
-}\r
-\r
-void\r
-Disconnect (int sqr, int piece, int dir)\r
-{\r
- int x = sqr, step = kStep[dir], piece1, piece2, d1, d2, r1, r2, y;\r
- while( board[x+=step] == EMPTY );\r
- piece1 = board[x];\r
- if(piece1 != EDGE) { // x has hit a piece\r
- d1 = dist[x-sqr];\r
- r1 = p[piece1].range[dir+4];\r
- y = sqr; while( board[y-=step] == EMPTY );\r
- piece2 = board[y];\r
- if(piece2 != EDGE) { // both ends of the ray hit a piece\r
- d2 = dist[y-sqr];\r
- r2 = p[piece2].range[dir];\r
- if(r1 >= d1) { // piece1 hits us\r
- attacks[2*sqr + (piece1 & WHITE)] += one[dir+4];\r
- if(r1 >= d1 + d2) // was hitting piece2 before, now blocked\r
- attacks[2*y + (piece1 & WHITE)] -= one[dir+4];\r
- }\r
- if(r2 >= d2) { // piece2 hits us\r
- attacks[2*sqr + (piece2 & WHITE)] += one[dir];\r
- if(r2 >= d1 + d2) // was hitting piece1 before, now blocked\r
- attacks[2*x + (piece2 & WHITE)] -= one[dir];\r
- }\r
- if( Hit(p[piece].range[dir], d1) )\r
- attacks[2*sqr + stm] += one[dir];\r
- if( Hit(p[piece].range[dir+4], d2) )\r
- attacks[2*sqr + stm] += one[dir+4];\r
- return;\r
- }\r
- } else {\r
- x = sqr; while( board[x-=step] == EMPTY );\r
- piece1 = board[x];\r
- if(piece1 == EDGE) return; // ray empty on both sides\r
- d1 = dist[x-sqr];\r
- r1 = p[piece1].range[dir];\r
- dir += 4;\r
- }\r
- // we only get here if one side looks to the board edge\r
- if(r1 >= d1) // piece1 hits us\r
- attacks[2*sqr + (piece1 & WHITE)] += one[dir^4];\r
- if( Hit(p[piece].range[dir], d1) )\r
- attacks[2*sqr + stm] += one[dir];\r
-}\r
-\r
-void\r
-Occupy (int sqr)\r
-{ // determines attacks on square and blocking when a piece lands on an empty square\r
- int i;\r
- for(i=0; i<4; i++) {\r
- Disconnect(sqr, board[sqr], i);\r
- }\r
-}\r
-\r
-void\r
-Evacuate (int sqr, int piece)\r
-{ // determines change in attacks on neighbors due to unblocking and mover when the mentioned piece vacates the given square\r
- int i;\r
- for(i=0; i<4; i++) Connect(sqr, piece, i);\r
-}\r
-\r
int\r
MakeMove(Move m, UndoInfo *u)\r
{\r
\r
if(p[u->piece].promoFlag & LAST_RANK) cnt50 = 0; // forward piece: move is irreversible\r
// TODO: put in some test for forward moves of non-backward pieces?\r
+// int n = board[promoSuppress-1];\r
+// if( n != EMPTY && (n&TYPE) == xstm && p[n].value == 8 ) NewNonCapt(promoSuppress-1, 16, 0);\r
\r
if(p[u->piece].value == FVAL) { // move with Fire Demon\r
int i, f=~fireFlags[u->piece-2];\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
if(PATH) printf("# autofail end (%d-%d)\n", firstMove, msp);\r
autoFail = 0; curMove = firstMove - 1; continue; // release stashed moves for search\r
}\r
-// if(currentVariant == V_CHESS && promoSuppress != ABSENT) { // e.p.\r
-// int n = board[promoSuppress-1];\r
-// if( n != EMPTY && (n&TYPE) == xstm && p[n].value == 8 ) \r
-// }\r
phase = 4; // out of victims: all captures generated\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 0\r
while( dubious < framePtr + 250 ) // add dubious captures back to move stack\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
sup2 = sup1; sup1 = sup0;\r
}\r
\r
-char fenNames[] = "RV....DKDEFL..DHGB......SMLNKN..FK....BT..VM..PH...."; // pairs of char\r
+char fenNames[] = "RV....DKDEFL..DHGB......SMLNKN..FK....BT..VM..PH..LN"; // pairs of char\r
char fenPromo[] = "WLDHSMSECPB R HFDE....WHFB..LNG ..DKVMFS..FO..FK...."; // pairs of char\r
\r
char *\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(currentVariant == V_LION && (*fen == 'L' || *fen == 'l')) *fen += 'Z' - 'L'; // L in Mighty-Lion Chess changed in Z for Lion\r
if(isalpha(*fen)) {\r
char *table = fenNames;\r
n = *fen > 'Z' ? 'a' - 'A' : 0;\r
- if((currentVariant == V_CHESS || currentVariant == V_SHATRANJ ||\r
+ if((currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_LION ||\r
currentVariant == V_MAKRUK || currentVariant == V_SHO) && *fen - n == 'N' // In Chess N is Knight, not Lion\r
|| table[2* (*fen - 'A' - n)] == '.') *p++ = *fen; else {\r
*p++ = ':';\r
postThinking--; repCnt = 0; tlim1 = tlim2 = tlim3 = 1e8; abortFlag = msp = 0;\r
Search(-INF-1, INF+1, 0, QSdepth+1, 0, sup1 & ~PROMOTE, sup2, INF);\r
postThinking++;\r
+\r
listStart = retFirst; listEnd = msp = retMSP;\r
}\r
\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 == 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
+ if(t == f - BW - 1) t2 = SPECIAL + 52; // fake double-move\r
}\r
ret = f<<SQLEN | t2;\r
if(*moveText != '\n' && *moveText != '=') ret |= PROMOTE;\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
engineSide = NONE; // so stop playing\r
PrintResult(stm, score);\r
} else {\r
+ MOVE f, pMove = move;\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
gameMove[moveNr++] = move; // remember game\r
- printf("move %s\n", MoveToText(move, 1));\r
+ printf("move %s\n", MoveToText(pMove, 1));\r
listEnd = 0;\r
continue; // go check if we should ponder\r
}\r
continue;\r
}\r
if(!strcmp(command, "protover")){\r
+ for(i=0; variants[i].boardWidth; i++)\r
+ printf("%s%s", (i ? "," : "feature variants=\""), variants[i].name); printf("\"\n");\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,makruk,chu,dai,tenjiku,12x12+0_fairy,9x9+0_shogi\"\n");\r
printf("feature myname=\"HaChu " VERSION "\" highlight=1\n");\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
continue;\r
}\r
if(!strcmp(command, "variant")) {\r
- for(i=0; i<7; i++) {\r
+ for(i=0; variants[i].boardWidth; 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
+ if(currentVariant == V_SHO)\r
+ printf("setup (PNBRLSE..G.+++++++Kpnbrlse..g.+++++++k) 9x9+0_shogi lnsgkgsnl/1r2e2b1/ppppppppp/9/9/9/PPPPPPPPP/1B2E2R1/LNSGKGSNL w 0 1\n");\r
repStack[199] = hashKeyH, checkStack[199] = 0;\r
continue;\r
}\r
projects / hachu.git / blobdiff