X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=hachu.c;h=b39efbf3b797e3437a95c2ec01c66c315eff0eb6;hb=aa576650ea406a2b26134ac64a699e3237a02444;hp=ce8ccc42c65ec8d7012ddf86ac9df851ddf5450c;hpb=5bb5207f5d6a946c0e45cd458c66ed9010d21995;p=hachu.git diff --git a/hachu.c b/hachu.c index ce8ccc4..b39efbf 100644 --- a/hachu.c +++ b/hachu.c @@ -10,7 +10,7 @@ // promotions by pieces with Lion power stepping in & out the zone in same turn // promotion on capture -#define VERSION "0.16 k+ky" +#define VERSION "0.18" //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)))))*/ #define PATH 0 @@ -71,7 +71,7 @@ #define BSIZE BWMAX*BHMAX #define ZONE zone -#define ONE (currentVariant == V_SHO || currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK || currentVariant == V_LION) +#define ONE 1 /* currently no variants with 10-deep board */ #define BLACK 0 #define WHITE 1 @@ -140,7 +140,7 @@ typedef struct { } UndoInfo; char *array, fenArray[4000], startPos[4000], *reason, checkStack[300]; -int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag, repDraws, tsume, pvCuts, allowRep, entryProm; +int bWidth, bHeight, bsize, zone, currentVariant, chuFlag, tenFlag, chessFlag, repDraws, stalemate, tsume, pvCuts, allowRep, entryProm, pVal; int stm, xstm, hashKeyH=1, hashKeyL=1, framePtr, msp, nonCapts, rootEval, filling, promoDelta; int retMSP, retFirst, retDep, pvPtr, level, cnt50, mobilityScore; int ll, lr, ul, ur; // corner squares @@ -369,23 +369,23 @@ PieceDesc taikyokuPieces[] = { }; PieceDesc chessPieces[] = { - {"Q", "", 950, { X,X,X,X,X,X,X,X } }, + {"FK", "", 950, { X,X,X,X,X,X,X,X } }, {"R", "", 500, { X,0,X,0,X,0,X,0 } }, {"B", "", 320, { 0,X,0,X,0,X,0,X } }, {"N", "", 300, { N,N,N,N,N,N,N,N } }, {"K", "", 280, { 1,1,1,1,1,1,1,1 } }, - {"P", "Q", 80, { M,C,0,0,0,0,0,C } }, + {"P", "FK", 80, { M,C,0,0,0,0,0,C } }, { NULL } // sentinel }; PieceDesc lionPieces[] = { {"LN","", LVAL, { L,L,L,L,L,L,L,L } }, - {"Q", "", 600, { X,X,X,X,X,X,X,X } }, + {"FK", "", 600, { X,X,X,X,X,X,X,X } }, {"R", "", 300, { X,0,X,0,X,0,X,0 } }, {"K", "", 280, { 1,1,1,1,1,1,1,1 } }, {"B", "", 190, { 0,X,0,X,0,X,0,X } }, {"N", "", 180, { N,N,N,N,N,N,N,N } }, - {"P", "Q", 50, { M,C,0,0,0,0,0,C } }, + {"P", "FK", 50, { M,C,0,0,0,0,0,C } }, { NULL } // sentinel }; @@ -421,10 +421,10 @@ char tenArray[] = "LN:FLICSGK:DEGSCI:FLNL/:RV.:CS:CS.:BT:KN:LN:FK:PH:BT.:CS:CS.: "....d......d..../pppppppppppppppp/:sm:vmr:hf:se:bg:rg:vg:gg:rg:bg:se:hfr:vm:sm/" ":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"; char shoArray[] = "LNSGKGSNL/.B..:DE..R./PPPPPPPPP/........./........./........./ppppppppp/.r..:de..b./lnsgkgsnl"; -char chessArray[] = "RNBQKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbqkbnr"; -char lionArray[] = "R:LNBQKBNR/PPPPPPPP/......../......../......../......../pppppppp/r:lnbqkbnr"; +char chessArray[] = "RNB:FKKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnb:fkkbnr"; +char lionArray[] = "R:LNB:FKKBNR/PPPPPPPP/......../......../......../......../pppppppp/r:lnb:fkkbnr"; char shatArray[]= "RNBK:FKBNR/PPPPPPPP/......../......../......../......../pppppppp/rnbk:fkbnr"; -char thaiArray[]= "RNSK:SMSNR/......../PPPPPPPP/......../......../pppppppp/......../rnsk:smsnr"; +char thaiArray[]= "RNSK:SMSNR/......../PPPPPPPP/......../......../pppppppp/......../rns:smksnr"; typedef struct { int boardWidth, boardFiles, boardRanks, zoneDepth, varNr; // board sizes @@ -434,11 +434,13 @@ typedef struct { 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; +#define SAME (-1) + VariantDesc variants[] = { - { 16, 8, 8, 1, V_CHESS, "normal", chessArray }, // FIDE + { 24, 12, 12, 4, V_CHU, "chu", chuArray }, // Chu + { 16, 8, 8, 1, V_CHESS, "nocastle", chessArray }, // FIDE { 18, 9, 9, 3, V_SHO, "9x9+0_shogi", shoArray }, // Sho { 18, 9, 9, 3, V_SHO, "sho", shoArray }, // Sho duplicat - { 24, 12, 12, 4, V_CHU, "chu", chuArray }, // Chu { 30, 15, 15, 5, V_DAI, "dai", daiArray }, // Dai { 32, 16, 16, 5, V_TENJIKU, "tenjiku", tenArray }, // Tenjiku { 16, 8, 8, 1, V_SHATRANJ,"shatranj",shatArray}, // Shatranj @@ -888,18 +890,23 @@ void Init (int var) { int i, j, k; + PieceDesc *pawn; + if(var != SAME) { // the following should be already set if we stay in same variant (for TakeBack) currentVariant = variants[var].varNr; bWidth = variants[var].boardWidth; bHeight = variants[var].boardRanks; zone = variants[var].zoneDepth; array = variants[var].array; + } bsize = bWidth*bHeight; chuFlag = (currentVariant == V_CHU || currentVariant == V_LION); tenFlag = (currentVariant == V_TENJIKU); chessFlag = (currentVariant == V_CHESS || currentVariant == V_LION); - repDraws = (currentVariant == V_CHESS || currentVariant == V_SHATRANJ || currentVariant == V_MAKRUK || currentVariant == V_LION); + stalemate = (currentVariant == V_CHESS || currentVariant == V_MAKRUK || currentVariant == V_LION); + repDraws = (stalemate || currentVariant == V_SHATRANJ); ll = 0; lr = bHeight - 1; ul = (bHeight - 1)*bWidth; ur = ul + bHeight - 1; + pawn = LookUp("P", currentVariant); pVal = pawn ? pawn->value : 0; // get Pawn value for(i= -1; i<9; i++) { // board steps in linear coordinates kStep[i] = STEP(direction[i&7].x, direction[i&7].y); // King @@ -1115,7 +1122,7 @@ GenNonCapts (int promoSuppress) } } else if(r == M) { // FIDE Pawn; check double-move - if(!NewNonCapture(x, x+v, pFlag) && chessFlag && promoBoard[x-v]) + if(!NewNonCapture(x, x+v, pFlag) && chessFlag && promoBoard[x-v] & LAST_RANK) NewNonCapture(x, x+2*v, pFlag), moveStack[msp-1] |= DEFER; // use promoSuppress flag as e.p. flag } continue; @@ -1242,6 +1249,8 @@ MakeMove(Move m, UndoInfo *u) if(p[u->piece].promoFlag & LAST_RANK) cnt50 = 0; // forward piece: move is irreversible // TODO: put in some test for forward moves of non-backward pieces? +// int n = board[promoSuppress-1]; +// if( n != EMPTY && (n&TYPE) == xstm && p[n].value == 8 ) NewNonCapt(promoSuppress-1, 16, 0); if(p[u->piece].value == FVAL) { // move with Fire Demon int i, f=~fireFlags[u->piece-2]; @@ -1689,7 +1698,7 @@ void TerminationCheck(); int Search (int alpha, int beta, int difEval, int depth, int lmr, int oldPromo, int promoSuppress, int threshold) { - int i, j, k, phase, king, nextVictim, to, defer, autoFail=0, inCheck = 0, late=100000; + int i, j, k, phase, king, nextVictim, to, defer, autoFail=0, inCheck = 0, late=100000, ep; int firstMove, oldMSP = msp, curMove, sorted, bad, dubious, bestMoveNr; int resDep, iterDep, ext; int myPV = pvPtr; @@ -1844,11 +1853,14 @@ if(PATH) printf("# autofail=%d\n", autoFail); if(PATH) printf("# autofail end (%d-%d)\n", firstMove, msp); autoFail = 0; curMove = firstMove - 1; continue; // release stashed moves for search } -// if(currentVariant == V_CHESS && promoSuppress != ABSENT) { // e.p. -// int n = board[promoSuppress-1]; -// if( n != EMPTY && (n&TYPE) == xstm && p[n].value == 8 ) -// } phase = 4; // out of victims: all captures generated + if(chessFlag && (ep = promoSuppress & SQUARE) != ABSENT) { // e.p. rights. Create e.p. captures as Lion moves + int n = board[ep-1], old = msp; // a-side neighbor of pushed pawn + if( n != EMPTY && (n&TYPE) == stm && p[n].value == pVal ) NewCapture(ep-1, SPECIAL + 20 - 4*stm, 0); + n = board[ep+1]; // h-side neighbor of pushed pawn + if( n != EMPTY && (n&TYPE) == stm && p[n].value == pVal ) NewCapture(ep+1, SPECIAL + 52 - 4*stm, 0); + if(msp != old) goto extractMove; // one or more e.p. capture were generated + } case 4: // dubious captures #if 0 while( dubious < framePtr + 250 ) // add dubious captures back to move stack @@ -2037,6 +2049,7 @@ if(PATH) printf("%d:%2d:%d %3d %6x %-10s %6d %6d (%d)\n", level, depth, iterDep if(lmr && bestScore <= alpha && iterDep == depth) depth++, lmr--; // self-deepen on fail-low reply to late move by lowering reduction #endif + if(stalemate && bestScore == -INF && !inCheck) bestScore = 0; // stalemate #ifdef HASH // hash store hashTable[index].lock[hit] = hashKeyH; @@ -2337,6 +2350,11 @@ ParseMove (char *moveText) for(j=0; j<8; j++) if(e + kStep[j] == t) break; if(j >= 8) return INVALID; // this rejects Lion Dog 1+2 moves! t2 = SPECIAL + 8*i + j; + } else if(chessFlag && board[f] != EMPTY && p[board[f]].value == pVal && board[t] == EMPTY) { // Pawn to empty, could be e.p. + if(t == f + BW + 1) t2 = SPECIAL + 16; else + if(t == f + BW - 1) t2 = SPECIAL + 48; else + if(t == f - BW + 1) t2 = SPECIAL + 20; else + if(t == f - BW - 1) t2 = SPECIAL + 52; // fake double-move } ret = f<= SPECIAL && p[board[f = move>>SQLEN & SQUARE]].value == pVal) { // e.p. capture + pMove = move & ~SQUARE | f + toList[(move & SQUARE) - SPECIAL]; // print as a single move + } stm = MakeMove2(stm, move); // assumes MakeMove returns new side to move gameMove[moveNr++] = move; // remember game - printf("move %s\n", MoveToText(move, 1)); + printf("move %s\n", MoveToText(pMove, 1)); listEnd = 0; continue; // go check if we should ponder }