X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=moves.c;h=8c09e23328e6ed8da2590d5c1e0a284fca5b78b2;hb=c085216cb15fadc8f11a13a52acacacd6059bbad;hp=2e772e1bac6b787ef83c72ea3ce08bb972671bc0;hpb=07596a90fd52fa895bab836cf22e83c6c3f37e62;p=xboard.git diff --git a/moves.c b/moves.c index 2e772e1..8c09e23 100644 --- a/moves.c +++ b/moves.c @@ -74,6 +74,16 @@ int PosFlags(int index); extern signed char initialRights[BOARD_FILES]; /* [HGM] all rights enabled, set in InitPosition */ int quickFlag; char *pieceDesc[EmptySquare]; +char *defaultDesc[EmptySquare] = { + "fmWfceFifmnD", "N", "B", "R", "Q", + "F", "A", "BN", "RN", "W", "K", + "mRcpR", "N0", "BW", "RF", "gQ", + "", "", "QN", "", "N", "", + "", "", "", "", "", + "", "", "", "", "", "", + "", "", "", "", "", + "", "", "", "", "", "K" +}; int WhitePiece (ChessSquare piece) @@ -125,7 +135,7 @@ PieceToNumber (ChessSquare p) /* [HGM] holdings: count piece type, ignoring non int i=0; ChessSquare start = (int)p >= (int)BlackPawn ? BlackPawn : WhitePawn; - while(start++ != p) if(pieceToChar[(int)start-1] != '.') i++; + while(start++ != p) if(pieceToChar[start-1] != '.' && pieceToChar[start-1] != '+') i++; return i; } @@ -168,13 +178,65 @@ CompareBoards (Board board1, Board board2) return TRUE; } +char defaultName[] = "PNBRQ......................................K" // white + "pnbrq......................................k"; // black +char shogiName[] = "PNBRLS...G.++++++..........................K" // white + "pnbrls...g.++++++..........................k"; // black +char xqName[] = "PH.R.AE..K.C................................" // white + "ph.r.ae..k.c................................"; // black + +char * +CollectPieceDescriptors () +{ // make a line of piece descriptions for use in the PGN Piece tag: + // dump all engine defined pieces, and pieces with non-standard names, + // but suppress black pieces that are the same as their white counterpart + ChessSquare p; + static char buf[MSG_SIZ]; + char *m, c, d, *pieceName = defaultName; + int len; + *buf = NULLCHAR; + if(!pieceDefs) return ""; + if(gameInfo.variant == VariantChu) return ""; // for now don't do this for Chu Shogi + if(gameInfo.variant == VariantShogi) pieceName = shogiName; + if(gameInfo.variant == VariantXiangqi) pieceName = xqName; + for(p=WhitePawn; p= BlackPawn && pieceToChar[BLACK_TO_WHITE p] == toupper(c) + && (c != '+' || pieceToChar[DEMOTED BLACK_TO_WHITE p] == d)) { // black member of normal pair + char *wm = pieceDesc[BLACK_TO_WHITE p]; + if(!m && !wm || m && wm && !strcmp(wm, m)) continue; // moves as a white piece + } else // white or unpaired black + if((p < BlackPawn || CharToPiece(toupper(d)) != EmptySquare) && // white or lone black + !pieceDesc[p] /*&& pieceName[p] == c*/) continue; // orthodox piece known by its usual name +// TODO: listing pieces because of unusual name can only be done if we have accurate Betza of all defaults + if(!m) m = defaultDesc[p]; + len = strlen(buf); + snprintf(buf+len, MSG_SIZ-len, "%s%s%c:%s", len ? ";" : "", c == '+' ? "+" : "", d, m); + } + return buf; +} + // [HGM] gen: configurable move generation from Betza notation sent by engine. +// Some notes about two-leg moves: GenPseudoLegal() works in two modes, depending on whether a 'kill- +// square has been set: without one is generates all moves, and a global int legNr flags in bits 0 and 1 +// if the move has 1 or 2 legs. Only the marking of squares makes use of this info, by only marking +// target squares of leg 1 (rejecting null move). A dummy move with MoveType 'FirstLeg' to the relay square +// is generated, so a cyan marker can be put there, and other functions can ignore such a move. When the +// user selects this square, it becomes the kill-square. Once a kill-square is set, only 2-leg moves are +// generated that use that square as relay, plus 1-leg moves, so the 1-leg move that goes to the kill-square +// can be marked during 2nd-leg entry to terminate the move there. For judging the pseudo-legality of the +// 2nd leg, the from-square has to be considered empty, although the moving piece is still on it. + +Boolean pieceDefs; // alphabet "abcdefghijklmnopqrstuvwxyz" -char symmetry[] = "FBNW.F.WFNKN.N..QR....W..N"; -char xStep[] = "2110.1.03102.10.00....0..2"; -char yStep[] = "2132.1.33313.20.11....1..3"; +char symmetry[] = "FBNW.FFW.NKN.NW.QR....W..N"; +char xStep[] = "2110.130.102.10.00....0..2"; +char yStep[] = "2132.133.313.20.11....1..3"; char dirType[] = "01000104000200000260050000"; +char upgrade[] = "AFCD.BGH.JQL.NO.KW....R..Z"; + // alphabet "a b c d e f g h i j k l m n o p q r s t u v w x y z " int dirs1[] = { 0,0x3C,0,0,0,0xC3,0,0, 0,0,0,0xF0,0,0,0,0,0,0x0F,0 ,0,0,0 ,0,0,0,0 }; int dirs2[] = { 0,0x18,0,0,0,0x81,0,0xFF,0,0,0,0x60,0,0,0,0,0,0x06,0x66,0,0,0x99,0,0,0,0 }; @@ -191,21 +253,29 @@ int rot[][4] = { // rotation matrices for each direction }; void -MovesFromString (Board board, int flags, int f, int r, char *desc, MoveCallback cb, VOIDSTAR cl) +OK (Board board, int flags, ChessMove kind, int rf, int ff, int rt, int ft, VOIDSTAR cl) +{ + (*(int*)cl)++; +} + +void +MovesFromString (Board board, int flags, int f, int r, int tx, int ty, int angle, char *desc, MoveCallback cb, VOIDSTAR cl) { - char *p = desc; + char buf[80], *p = desc; int mine, his, dir, bit, occup, i; if(flags & F_WHITE_ON_MOVE) his = 2, mine = 1; else his = 1, mine = 2; while(*p) { // more moves to go - int expo = 1, dx, dy, x, y, mode, dirSet, retry=0, initial=0; - if(*p == 'i') initial = 1, p++; + int expo = 1, dx, dy, x, y, mode, dirSet, retry=0, initial=0, jump=1, skip = 0; + char *cont = NULL; + if(*p == 'i') initial = 1, desc = ++p; while(islower(*p)) p++; // skip prefixes if(!isupper(*p)) return; // syntax error: no atom dirSet = 0; // build direction set based on atom symmetry switch(symmetry[*p-'A']) { case 'B': expo = 0; // bishop, slide case 'F': // diagonal atom (degenerate 4-fold) - while(islower(*desc) && (i = dirType[*desc-'a']) != '0') { + if(tx < 0) { // for continuation legs relative directions are orthogonal! + while(islower(*desc) && (i = dirType[*desc-'a']) != '0') { int b = dirs1[*desc-'a']; // use wide version if( islower(desc[1]) && ((i | dirType[desc[1]-'a']) & 3) == 3) { // combinable (perpendicular dim) @@ -213,20 +283,22 @@ MovesFromString (Board board, int flags, int f, int r, char *desc, MoveCallback desc += 2; } else desc++; dirSet |= b; + } + dirSet &= 0x55; if(!dirSet) dirSet = 0x55; + break; } - dirSet &= 0x99; if(!dirSet) dirSet = 0x99; - break; case 'R': expo = 0; // rook, slide case 'W': // orthogonal atom (non-deg 4-fold) while(islower(*desc) && (dirType[*desc-'a'] & ~4) != '0') dirSet |= dirs2[*desc++-'a']; dirSet &= 0x55; if(!dirSet) dirSet = 0x55; + dirSet = (dirSet << angle | dirSet >> 8-angle) & 255; // re-orient direction system break; case 'N': // oblique atom (degenerate 8-fold) while(islower(*desc) && (i = dirType[*desc-'a']) != '0') { int b = dirs2[*desc-'a']; // when alone, use narrow version if(desc[1] == 'h') b = dirs1[*desc-'a'], desc += 2; // dirs1 is wide version - else if(islower(desc[1]) && i < '4' - && ((i | dirType[desc[1]-'a']) & 3) == 3) { // combinable (perpendicular dim) + else if(*desc == desc[1] || islower(desc[1]) && i < '4' + && ((i | dirType[desc[1]-'a']) & 3) == 3) { // combinable (perpendicular dim or same) b = dirs1[*desc-'a'] & dirs2[desc[1]-'a']; // intersect wide & perp narrow desc += 2; } else desc++; @@ -241,36 +313,104 @@ MovesFromString (Board board, int flags, int f, int r, char *desc, MoveCallback break; // should not have direction indicators default: return; // syntax error: invalid atom } - if(mine == 2) dirSet = dirSet >> 4 | dirSet << 4 & 255; // invert black moves + if(mine == 2 && tx < 0) dirSet = dirSet >> 4 | dirSet << 4 & 255; // invert black moves mode = 0; // build mode mask if(*desc == 'm') mode |= 4, desc++; if(*desc == 'c') mode |= his, desc++; if(*desc == 'd') mode |= mine, desc++; - if(!mode) mode = his + 4;// no mode spec, use default = mc + if(*desc == 'e') mode |= 8, desc++; + if(*desc == 'p') mode |= 32, desc++; + if(*desc == 'g') mode |= 64, desc++; + if(*desc == 'o') mode |= 128, desc++; + if(*desc == 'n') jump = 0, desc++; + while(*desc == 'j') jump++, desc++; + if(*desc == 'a') cont = ++desc; dx = xStep[*p-'A'] - '0'; // step vector of atom dy = yStep[*p-'A'] - '0'; if(isdigit(*++p)) expo = atoi(p++); // read exponent if(expo > 9) p++; // allow double-digit desc = p; // this is start of next move - if(initial && (mine == 1 ? r > 1 : r < BOARD_HEIGHT - 2)) continue; + if(initial && (board[r][f] != initialPosition[r][f] || + r == 0 && board[TOUCHED_W] & 1< 1 && dx == 0 && dy == 0) { // castling indicated by O + number + mode |= 16; dy = 1; + } + if(!cont) { + if(!(mode & 15)) mode = his + 4; // no mode spec, use default = mc + } else { + if(mode & 32) mode ^= 256 + 32; // in non-final legs 'p' means 'pass through' + if(mode & 64) { + mode |= 256; // and 'g' too, but converts leaper <-> slider + strncpy(buf, cont, 80); cont = buf; // copy next leg(s), so we can modify + while(islower(*cont)) cont++; // skip to atom + *cont = upgrade[*cont-'A']; // replace atom, BRQ <-> FWK + if(expo == 1) *++cont = '0'; // turn other leapers into riders + *++cont = '\0'; // make sure any old range is stripped off + cont = buf; // use modified string for continuation leg + } + if(!(mode & 0x10F)) mode = his + 0x104; // and default = mcp + } + if(dy == 1) skip = jump - 1, jump = 1; // on W & F atoms 'j' = skip first square do { for(dir=0, bit=1; dir<8; dir++, bit += bit) { // loop over directions - int i = expo; + int i = expo, j = skip, hop = mode, vx, vy; if(!(bit & dirSet)) continue; // does not move in this direction - x = f; y = r; // start square - do { - x += dx*rot[dir][0] + dy*rot[dir][1]; // step to next square - y += dx*rot[dir][2] + dy*rot[dir][3]; - if(y < 0 || y >= BOARD_HEIGHT || x < BOARD_LEFT || x >= BOARD_RGHT) break; - if(board[y][x] < BlackPawn) occup = 1; else - if(board[y][x] < EmptySquare) occup = 2; else + if(dy != 1) j = 0; // + vx = dx*rot[dir][0] + dy*rot[dir][1]; // rotate step vector + vy = dx*rot[dir][2] + dy*rot[dir][3]; + if(tx < 0) x = f, y = r; // start square + else x = tx, y = ty; // from previous to-square if continuation + do { // traverse ray + x += vx; y += vy; // step to next square + if(y < 0 || y >= BOARD_HEIGHT) break; // vertically off-board: always done + if(x < BOARD_LEFT) { if(mode & 128) x += BOARD_RGHT - BOARD_LEFT; else break; } + if(x >= BOARD_RGHT) { if(mode & 128) x -= BOARD_RGHT - BOARD_LEFT; else break; } + if(j) { j--; continue; } // skip irrespective of occupation + if(!jump && board[y - vy + vy/2][x - vx + vx/2] != EmptySquare) break; // blocked + if(jump > 1 && board[y - vy + vy/2][x - vx + vx/2] == EmptySquare) break; // no hop + if(x == f && y == r) occup = 4; else // start square counts as empty + if(board[y][x] < BlackPawn) occup = 0x101; else + if(board[y][x] < EmptySquare) occup = 0x102; else occup = 4; - if(occup & mode) cb(board, flags, NormalMove, r, f, y, x, cl); // allowed, generate + if(cont) { // non-final leg + if(occup & mode) { // valid intermediate square, do continuation + if(occup & mode & 0x104) // no side effects, merge legs to one move + MovesFromString(board, flags, f, r, x, y, dir, cont, cb, cl); + if(occup & mode & 3 && (killX < 0 || killX == x && killY == y)) { // destructive first leg + int cnt = 0; + MovesFromString(board, flags, f, r, x, y, dir, cont, &OK, &cnt); // count possible continuations + if(cnt) { // and if there are + if(killX < 0) cb(board, flags, FirstLeg, r, f, y, x, cl); // then generate their first leg + legNr <<= 1; + MovesFromString(board, flags, f, r, x, y, dir, cont, cb, cl); + legNr >>= 1; + } + } + } + if(occup != 4) break; // occupied squares always terminate the leg + continue; + } + if(hop & 32+64) { if(occup != 4) { if(hop & 64 && i != 1) i = 2; hop &= 31; } continue; } // hopper + if(mode & 8 && y == board[EP_RANK] && occup == 4 && board[EP_FILE] == x) { // to e.p. square + cb(board, flags, mine == 1 ? WhiteCapturesEnPassant : BlackCapturesEnPassant, r, f, y, x, cl); + } + if(mode & 16) { // castling + i = 2; // kludge to elongate move indefinitely + if(occup == 4) continue; // skip empty squares + if(x == BOARD_LEFT && board[y][x] == initialPosition[y][x]) // reached initial corner piece + cb(board, flags, mine == 1 ? WhiteQueenSideCastle : BlackQueenSideCastle, r, f, y, f - expo, cl); + if(x == BOARD_RGHT-1 && board[y][x] == initialPosition[y][x]) + cb(board, flags, mine == 1 ? WhiteKingSideCastle : BlackKingSideCastle, r, f, y, f + expo, cl); + break; + } + if(occup & mode) cb(board, flags, NormalMove, r, f, y, x, cl); // allowed, generate if(occup != 4) break; // not valid transit square } while(--i); } dx = dy = 1; dirSet = 0x99; // prepare for diagonal moves of K,Q } while(retry--); // and start doing them + if(tx >= 0) break; // don't do other atoms in continuation legs } } // next atom @@ -375,12 +515,18 @@ Sting (Board board, int flags, int rf, int ff, int dy, int dx, MoveCallback call { // Lion-like move of Horned Falcon and Souring Eagle int ft = ff + dx, rt = rf + dy; if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) return; + legNr += 2; if (!SameColor(board[rf][ff], board[rt][ft])) callback(board, flags, board[rt][ft] != EmptySquare ? FirstLeg : NormalMove, rf, ff, rt, ft, closure); + legNr -= 2; ft += dx; rt += dy; if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) return; + legNr += 2; if (!SameColor(board[rf][ff], board[rt][ft])) callback(board, flags, NormalMove, rf, ff, rt, ft, closure); + if (!SameColor(board[rf][ff], board[rf+dy][ff+dx])) + callback(board, flags, NormalMove, rf, ff, rf, ff, closure); + legNr -= 2; } void @@ -503,7 +649,10 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, if(PieceToChar(piece) == '~') piece = (ChessSquare) ( DEMOTED piece ); if(filter != EmptySquare && piece != filter) continue; - if(pieceDesc[piece]) { MovesFromString(board, flags, ff, rf, pieceDesc[piece], callback, closure); continue; } // [HGM] gen + if(pieceDefs && pieceDesc[piece]) { // [HGM] gen: use engine-defined moves + MovesFromString(board, flags, ff, rf, -1, -1, 0, pieceDesc[piece], callback, closure); + continue; + } if(IS_SHOGI(gameInfo.variant)) piece = (ChessSquare) ( SHOGI piece ); @@ -1007,8 +1156,10 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, for(rt = rf - 2; rt <= rf + 2; rt++) for(ft = ff - 2; ft <= ff + 2; ft++) { if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) continue; if (!(ff == ft && rf == rt) && SameColor(board[rf][ff], board[rt][ft])) continue; + i = (killX >= 0 && (rt-killY)*(rt-killY) + (killX-ft)*(killX-ft) < 3); legNr += 2*i; callback(board, flags, (rt-rf)*(rt-rf) + (ff-ft)*(ff-ft) < 3 && board[rt][ft] != EmptySquare ? FirstLeg : NormalMove, rf, ff, rt, ft, closure); + legNr -= 2*i; } break; @@ -1209,6 +1360,7 @@ GenLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, Ches int ignoreCheck = (flags & F_IGNORE_CHECK) != 0; ChessSquare wKing = WhiteKing, bKing = BlackKing, *castlingRights = board[CASTLING]; int inCheck = !ignoreCheck && CheckTest(board, flags, -1, -1, -1, -1, FALSE); // kludge alert: this would mark pre-existing checkers if status==1 + char *p; cl.cb = callback; cl.cl = closure; @@ -1223,6 +1375,9 @@ GenLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, Ches wKing = WhiteUnicorn; bKing = BlackUnicorn; } + p = (flags & F_WHITE_ON_MOVE ? pieceDesc[wKing] : pieceDesc[bKing]); + if(p && strchr(p, 'O')) return FALSE; // [HGM] gen: castlings were already generated from string + for (ff = BOARD_WIDTH>>1; ff >= (BOARD_WIDTH-1)>>1; ff-- /*ics wild 1*/) { if ((flags & F_WHITE_ON_MOVE) && (flags & F_WHITE_KCASTLE_OK) && @@ -1451,7 +1606,7 @@ CheckTest (Board board, int flags, int rf, int ff, int rt, int ft, int enPassant } if(rf == DROP_RANK) board[rt][ft] = ff; else { // [HGM] drop board[rt][ft] = board[rf][ff]; - board[rf][ff] = EmptySquare; + if(rf != rt || ff != ft) board[rf][ff] = EmptySquare; } ep = board[EP_STATUS]; if( captured == WhiteLion || captured == BlackLion ) { // [HGM] lion: Chu Lion-capture rules @@ -1530,9 +1685,9 @@ if(appData.debugMode) fprintf(debugFP, "LegalDrop: %d @ %d,%d)\n", piece, ft, rt piece == WhiteKnight && rt > BOARD_HEIGHT-3 || piece == BlackKnight && rt < 2 ) return IllegalMove; // e.g. where dropped piece has no moves if(piece == WhitePawn || piece == BlackPawn) { - int r; + int r, max = 1 + (BOARD_HEIGHT == 7); // two Pawns per file in Tori! for(r=1; rrtIn == -1 || cl->rtIn == rt || wildCard) && (cl->ftIn == -1 || cl->ftIn == ft || wildCard)) { + if(cl->count && rf == cl->rf && ff == cl->ff) return; // duplicate move + cl->count++; if(cl->count == 1 || board[rt][ft] != EmptySquare) { // [HGM] oneclick: if multiple moves, be sure we remember capture @@ -1841,6 +1998,12 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure) return; } } + } else if(pieceDefs && closure->count > 1) { // [HGM] gen: move is ambiguous under engine-defined rules + DisambiguateClosure spare = *closure; + pieceDefs = FALSE; spare.count = 0; // See if the (erroneous) built-in rules would resolve that + GenLegal(board, flags, DisambiguateCallback, (VOIDSTAR) &spare, closure->pieceIn); + if(spare.count == 1) *closure = spare; // It does, so use those in stead (game from file saved before gen patch?) + pieceDefs = TRUE; } if (c == 'x') c = NULLCHAR; // get rid of any 'x' (which should never happen?) @@ -1979,7 +2142,7 @@ CoordsToAlgebraic (Board board, int flags, int rf, int ff, int rt, int ft, int p { ChessSquare piece; ChessMove kind; - char *outp = out, c; + char *outp = out, c, capture; CoordsToAlgebraicClosure cl; if (rf == DROP_RANK) { @@ -2012,14 +2175,15 @@ CoordsToAlgebraic (Board board, int flags, int rf, int ff, int rt, int ft, int p } /* Pawn move */ *outp++ = ff + AAA; - if (ff == ft && board[rt][ft] == EmptySquare) { /* [HGM] Xiangqi has straight noncapts! */ + capture = board[rt][ft] != EmptySquare || kind == WhiteCapturesEnPassant || kind == BlackCapturesEnPassant; + if (ff == ft && !capture) { /* [HGM] Xiangqi has straight noncapts! */ /* Non-capture; use style "e5" */ if(rt+ONE <= '9') *outp++ = rt + ONE; else { *outp++ = (rt+ONE-'0')/10 + '0';*outp++ = (rt+ONE-'0')%10 + '0'; } } else { /* Capture; use style "exd5" */ - if(gameInfo.variant != VariantXiangqi || board[rt][ft] != EmptySquare ) + if(capture) *outp++ = 'x'; /* [HGM] Xiangqi has sideway noncaptures across river! */ *outp++ = ft + AAA; if(rt+ONE <= '9')