X-Git-Url: http://winboard.nl/cgi-bin?p=xboard.git;a=blobdiff_plain;f=moves.c;h=6a747a276705ae16d89898290a2a9329ce6fa5d4;hp=bf5ee28d2d9744c9aa45e4e1bc96471ffd2977e0;hb=HEAD;hpb=4aed6e1fe3f9c75dbb37ab41e81aed204bba602f diff --git a/moves.c b/moves.c index bf5ee28..6a747a2 100644 --- a/moves.c +++ b/moves.c @@ -5,7 +5,8 @@ * Massachusetts. * * Enhancements Copyright 1992-2001, 2002, 2003, 2004, 2005, 2006, - * 2007, 2008, 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc. + * 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Free + * Software Foundation, Inc. * * Enhancements Copyright 2005 Alessandro Scotti * @@ -54,6 +55,8 @@ #include "config.h" #include +#include +#include #if HAVE_STRING_H # include #else /* not HAVE_STRING_H */ @@ -69,8 +72,18 @@ int BlackPiece P((ChessSquare)); int SameColor P((ChessSquare, ChessSquare)); 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) @@ -101,19 +114,33 @@ SameColor (ChessSquare piece1, ChessSquare piece2) #define SameColor(piece1, piece2) (piece1 < EmptySquare && piece2 < EmptySquare && (piece1 < BlackPawn) == (piece2 < BlackPawn) || piece1 == DarkSquare || piece2 == DarkSquare) #endif -char pieceToChar[] = { +unsigned char pieceToChar[EmptySquare+1] = { 'P', 'N', 'B', 'R', 'Q', 'F', 'E', 'A', 'C', 'W', 'M', 'O', 'H', 'I', 'J', 'G', 'D', 'V', 'L', 'S', 'U', 'K', 'p', 'n', 'b', 'r', 'q', 'f', 'e', 'a', 'c', 'w', 'm', 'o', 'h', 'i', 'j', 'g', 'd', 'v', 'l', 's', 'u', 'k', 'x' }; -char pieceNickName[EmptySquare]; +unsigned char pieceNickName[EmptySquare]; +int promoPartner[EmptySquare]; char PieceToChar (ChessSquare p) { - if((int)p < 0 || (int)p >= (int)EmptySquare) return('x'); /* [HGM] for safety */ - return pieceToChar[(int) p]; + int c; + if((int)p < 0 || (int)p >= (int)EmptySquare) return('?'); /* [HGM] for safety */ + c = pieceToChar[(int) p]; + if(c & 128) c = c & 63 | 64; + return c; +} + +char +PieceSuffix (ChessSquare p) +{ + int c; + if((int)p < 0 || (int)p >= (int)EmptySquare) return 0; /* [HGM] for safety */ + c = pieceToChar[(int) p]; + if(c < 128) return 0; + return SUFFIXES[c - 128 >> 6]; } int @@ -122,7 +149,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; } @@ -165,6 +192,335 @@ 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], s[2]; + char *m, *pieceName = defaultName; + int len, c, d; + *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] == (c & ~32) + && (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(d & ~32) != 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]; + if(!m) continue; + len = strlen(buf); + *s = (d > 128 ? SUFFIXES[d-128>>6] : 0); d = 64 + (d & 63); + snprintf(buf+len, MSG_SIZ-len, "%s%s%c%s:%s", len ? ";" : "", c == '+' ? "+" : "", d, s, m); + } + return buf; +} + +int +LoadPieceDesc (char *s) +{ + ChessSquare piece; + static char suf[] = SUFFIXES; + char *r, *p, *q = s; + int ok = TRUE, promoted, c; + while(q && *s) { + p = s; + q = strchr(s, ';'); + if(q) *q = 0, s = q+1; + if(*p == '+') promoted = 1, p++; else promoted = 0; + c = *p++; + if(!c) { ok = FALSE; continue; } // bad syntax + if(*p && (r = strchr(suf, *p))) c += 64*(r - suf + 1), p++; + if(*p++ != ':') { ok = FALSE; continue; } // bad syntax + if(!strcmp(p, "(null)")) continue; // handle bug in writing of XBoard 4.8.0 + piece = CharToPiece(c); + if(piece >= EmptySquare) { ok = FALSE; continue; } // non-existent piece + if(promoted) { + piece = promoPartner[piece]; + if(pieceToChar[piece] != '+') { ok = FALSE; continue; } // promoted form does not exist + } + ASSIGN(pieceDesc[piece], p); + if(piece < BlackPawn && (pieceToChar[WHITE_TO_BLACK piece] == pieceToChar[piece] + 32 || promoted)) { + ASSIGN(pieceDesc[WHITE_TO_BLACK piece], p); + } + pieceDefs = TRUE; + if(q) *q = ';'; + } + return ok; +} + +// [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.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"; +char rotate[] = "DRCA.WHG.JKL.NO.QB....F..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 }; +int dirs3[] = { 0,0x38,0,0,0,0x83,0,0xFF,0,0,0,0xE0,0,0,0,0,0,0x0E,0xEE,0,0,0xBB,0,0,0,0 }; +int dirs4[] = { 0,0x10,0,0,0,0x01,0,0xFF,0,0,0,0x40,0,0,0,0,0,0x04,0x44,0,0,0x11,0,0,0,0 }; + +int rot[][4] = { // rotation matrices for each direction + { 1, 0, 0, 1 }, + { 0, 1, 1, 0 }, + { 0, 1,-1, 0 }, + { 1, 0, 0,-1 }, + {-1, 0, 0,-1 }, + { 0,-1,-1, 0 }, + { 0,-1, 1, 0 }, + {-1, 0, 0, 1 } +}; + +void +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, int range, char *desc, MoveCallback cb, VOIDSTAR cl) +{ + char buf[80], *p = desc, *atom = NULL; + int mine, his, dir, bit, occup, i, ep, promoRank = -1; + ChessMove promo= NormalMove; ChessSquare pc = board[r][f]; + if(pc == DarkSquare) return; // this is not a piece, but a 'hole' in the board + if(flags & F_WHITE_ON_MOVE) his = 2, mine = 1; else his = 1, mine = 2; + if(pc == WhitePawn || pc == WhiteLance) promo = WhitePromotion, promoRank = BOARD_HEIGHT-1; else + if(pc == BlackPawn || pc == BlackLance) promo = BlackPromotion, promoRank = 0; + while(*p) { // more moves to go + int expo = -1, dx, dy, x, y, mode, dirSet, ds2=0, retry=0, initial=0, jump=1, skip = 0, all = 0; + char *cont = NULL; + while(*p == 'i') initial++, desc = ++p; + while(islower(*p)) p++; // skip prefixes + if(!isupper(*p)) return; // syntax error: no atom + dx = xStep[*p-'A'] - '0';// step vector of atom + dy = yStep[*p-'A'] - '0'; + dirSet = 0; // build direction set based on atom symmetry + switch(symmetry[*p-'A']) { + case 'B': expo = 0; // bishop, slide + case 'F': all = 0xAA; // diagonal atom (degenerate 4-fold) + if(tx >= 0) goto king; // continuation legs specified in K/Q system! + 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) + b = dirs1[*desc-'a'] & dirs1[desc[1]-'a']; // intersect wide & perp wide + desc += 2; + } else desc++; + dirSet |= b; + } + dirSet &= 0xAA; if(!dirSet) dirSet = 0xAA; + break; + case 'R': expo = 0; // rook, slide + case 'W': all = 0x55; // orthogonal atom (non-deg 4-fold) + if(tx >= 0) goto king; // continuation legs specified in K/Q system! + 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': all = 0xFF; // oblique atom (degenerate 8-fold) + if(tx >= 0) goto king; // continuation legs specified in K/Q system! + if(*desc == 'h') { // chiral direction sets 'hr' and 'hl' + dirSet = (desc[1] == 'r' ? 0x55 : 0xAA); desc += 2; + } else + 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(*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++; + dirSet |= b; + } + if(!dirSet) dirSet = 0xFF; + break; + case 'Q': expo = 0; // queen, slide + case 'K': all = 0xFF; // non-deg (pseudo) 8-fold + king: + while(islower(*desc) && (i = dirType[*desc-'a']) != '0') { + int b = dirs4[*desc-'a']; // when alone, use narrow version + if(desc[1] == *desc) desc++; // doubling forces alone + else if(islower(desc[1]) && i < '4' + && ((i | dirType[desc[1]-'a']) & 3) == 3) { // combinable (perpendicular dim or same) + b = dirs3[*desc-'a'] & dirs3[desc[1]-'a']; // intersect wide & perp wide + desc += 2; + } else desc++; + dirSet |= b; + } + if(!dirSet) dirSet = (tx < 0 ? 0xFF // default is all directions, but in continuation leg + : all == 0xFF ? 0xEF : 0x45); // omits backward, and for 4-fold atoms also diags + dirSet = (dirSet << angle | dirSet >> 8-angle) & 255; // re-orient direction system + ds2 = dirSet & 0xAA; // extract diagonal directions + if(dirSet &= 0x55) // start with orthogonal moves, if present + retry = 1, dx = 0; // and schedule the diagonal moves for later + else dx = dy, dirSet = ds2; // if no orthogonal directions, do diagonal immediately + break; // should not have direction indicators + default: return; // syntax error: invalid atom + } + 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++; // move to empty + if(*desc == 'c') mode |= his, desc++; // capture foe + if(*desc == 'd') mode |= mine, desc++; // destroy (capture friend) + if(*desc == 'e') mode |= 8, desc++; // e.p. capture last mover + if(*desc == 't') mode |= 16, desc++; // exclude enemies as hop platform ('test') + if(*desc == 'p') mode |= 32, desc++; // hop over occupied + if(*desc == 'g') mode |= 64, desc++; // hop and toggle range + if(*desc == 'o') mode |= 128, desc++; // wrap around cylinder board + if(*desc == 'y') mode |= 512, desc++; // toggle range on empty square + if(*desc == 'n') jump = 0, desc++; // non-jumping + while(*desc == 'j') jump++, desc++; // must jump (on B,R,Q: skip first square) + if(*desc == 'a') cont = ++desc; // move again after doing what preceded it + 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 == 2) { if(board[r][f] != initialPosition[r-2*his+3][f]) continue; initial = 0; } else + if(initial && !range) { + if( (board[r][f] != initialPosition[r][f] || + r == 0 && board[TOUCHED_W] & 1< 0 && dx == 0 && dy == 0) { // castling indicated by O + number + mode |= 1024; dy = 1; + } + if(expo < 0) expo = 1; // use 1 for default + if(!cont) { + if(!(mode & 15)) mode |= his + 4; // no mode spec, use default = mc + } else { + strncpy(buf, cont, 80); cont = buf; // copy next leg(s), so we can modify + atom = buf; while(islower(*atom)) atom++; // skip to atom + if(mode & 32) mode ^= 256 + 32; // in non-final legs 'p' means 'pass through' + if(mode & 64 + 512) { + mode |= 256; // and 'g' too, but converts leaper <-> slider + if(mode & 512) mode ^= 0x304; // and 'y' is m-like 'g' + *atom = upgrade[*atom-'A']; // replace atom, BRQ <-> FWK + atom[1] = atom[2] = '\0'; // make sure any old range is stripped off + if(expo == 1) atom[1] = '0'; // turn other leapers into riders + } + if(!(mode & 0x30F)) mode |= 4; // and default of this leg = m + } + 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, j = skip, hop = mode, vx, vy, loop = 0; + if(!(bit & dirSet)) continue; // does not move in this direction + if(dy != 1 || mode & 1024) 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, loop++; else break; } + if(x >= BOARD_RGHT) { if(mode & 128) x -= BOARD_RGHT - BOARD_LEFT, loop++; else break; } + if(j) { j--; continue; } // skip irrespective of occupation + if(board[y][x] == DarkSquare) break; // black squares are supposed to be off board + 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 && !loop) occup = 4; else // start square counts as empty (if not around cylinder!) + if(board[y][x] < BlackPawn) occup = 0x101; else + if(board[y][x] < EmptySquare) occup = 0x102; else + occup = 4; + if(initial && expo - i + 1 != range) { if(occup == 4) continue; else break; } + if(cont) { // non-final leg + if(mode&16 && his&occup) occup &= 3;// suppress hopping foe in t-mode + if(occup & mode) { // valid intermediate square, do continuation + char origAtom = *atom; + int rg = (expo != 1 ? expo - i + 1 : range); // pass length of last *slider* leg + if(!(bit & all)) *atom = rotate[*atom - 'A']; // orth-diag interconversion to make direction valid + if(occup & mode & 0x104) // no side effects, merge legs to one move + MovesFromString(board, flags, f, r, x, y, dir, rg, cont, cb, cl); + if(occup & mode & 3 && (killX < 0 || kill2X < 0 && (legNr > 1 || killX == x && killY == y) || + (legNr == 1 ? kill2X == x && kill2Y == y : killX == x && killY == y))) { // destructive first leg + int cnt = 0; + legNr <<= 1; + MovesFromString(board, flags, f, r, x, y, dir, rg, cont, &OK, &cnt); // count possible continuations + legNr >>= 1; + if(cnt) { // and if there are + if(legNr & 1 ? killX < 0 : kill2X < 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, rg, cont, cb, cl); + legNr >>= 1; + } + } + *atom = origAtom; // undo any interconversion + } + 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 + ep = board[EP_RANK]; + if(mode & 8 && occup == 4 && board[EP_FILE] == x && (y == (ep & 127) || y - vy == ep - 128)) { // to e.p. square (or 2nd e.p. square) + cb(board, flags, mine == 1 ? WhiteCapturesEnPassant : BlackCapturesEnPassant, r, f, y, x, cl); + } + if(mode & 1024) { // castling + i = 2; // kludge to elongate move indefinitely + if(occup == 4) continue; // skip empty squares + if((x == BOARD_LEFT + skip || x > BOARD_LEFT + skip && vx < 0 && board[y][x-1-skip] == DarkSquare) + && board[y][x] == initialPosition[y][x]) { // reached initial corner piece + if(pc != WhiteKing && pc != BlackKing || expo == 1) { // non-royal castling (to be entered as two-leg move via 'Rook') + if(killX < 0) cb(board, flags, FirstLeg, r, f, y, x, cl); if(killX < f) + legNr <<= 1, cb(board, flags, NormalMove, r, f, y, f - expo, cl), legNr >>= 1; + } else + cb(board, flags, mine == 1 ? WhiteQueenSideCastle : BlackQueenSideCastle, r, f, y, f - expo, cl); + } + if((x == BOARD_RGHT-1-skip || x < BOARD_RGHT-1-skip && vx > 0 && board[y][x+1+skip] == DarkSquare) + && board[y][x] == initialPosition[y][x]) { + if(pc != WhiteKing && pc != BlackKing || expo == 1) { + if(killX < 0) cb(board, flags, FirstLeg, r, f, y, x, cl); if(killX > f) + legNr <<= 1, cb(board, flags, NormalMove, r, f, y, f + expo, cl), legNr >>= 1; + } else + cb(board, flags, mine == 1 ? WhiteKingSideCastle : BlackKingSideCastle, r, f, y, f + expo, cl); + } + break; + } + if(mode & 16 && (board[y][x] == WhiteKing || board[y][x] == BlackKing)) break; // tame piece, cannot capture royal + if(occup & mode) cb(board, flags, y == promoRank ? promo : NormalMove, r, f, y, x, cl); // allowed, generate + if(occup != 4) break; // not valid transit square + } while(--i); + } + dx = dy; dirSet = ds2; // prepare for diagonal moves of K,Q + } while(retry-- && ds2); // and start doing them + if(tx >= 0) break; // don't do other atoms in continuation legs + } +} // next atom + // [HGM] move generation now based on hierarchy of subroutines for rays and combinations of rays void @@ -263,15 +619,21 @@ Bishop (Board board, int flags, int rf, int ff, MoveCallback callback, VOIDSTAR void Sting (Board board, int flags, int rf, int ff, int dy, int dx, MoveCallback callback, VOIDSTAR closure) -{ // Lion-like move of Horned Falcon and Souring Eagle +{ // Lion-like move of Horned Falcon and Soaring 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); + callback(board, flags, killX < 0 && 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 @@ -387,15 +749,17 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, for (rf = 0; rf < BOARD_HEIGHT; rf++) for (ff = BOARD_LEFT; ff < BOARD_RGHT; ff++) { ChessSquare piece; - int rookRange; if(board[rf][ff] == EmptySquare) continue; if ((flags & F_WHITE_ON_MOVE) != (board[rf][ff] < BlackPawn)) continue; // [HGM] speed: wrong color - rookRange = 1000; m = 0; piece = board[rf][ff]; if(PieceToChar(piece) == '~') - piece = (ChessSquare) ( DEMOTED piece ); + piece = (ChessSquare) ( DEMOTED(piece) ); if(filter != EmptySquare && piece != filter) continue; + if(pieceDefs && pieceDesc[piece]) { // [HGM] gen: use engine-defined moves + MovesFromString(board, flags, ff, rf, -1, -1, 0, 0, pieceDesc[piece], callback, closure); + continue; + } if(IS_SHOGI(gameInfo.variant)) piece = (ChessSquare) ( SHOGI piece ); @@ -566,15 +930,18 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, /* Gold General (and all its promoted versions) . First do the */ /* diagonal forward steps, then proceed as normal Wazir */ - case SHOGI (PROMOTED WhitePawn): + case SHOGI (PROMO WhitePawn): if(gameInfo.variant == VariantShogi) goto WhiteGold; - case SHOGI (PROMOTED BlackPawn): + case SHOGI (PROMO BlackPawn): if(gameInfo.variant == VariantShogi) goto BlackGold; + case SHOGI WhiteAxe: + case SHOGI BlackAxe: SlideVertical(board, flags, rf, ff, callback, closure); break; - case SHOGI (PROMOTED WhiteKnight): + case SHOGI (PROMO WhiteKnight): if(gameInfo.variant == VariantShogi) goto WhiteGold; + case SHOGI WhiteClaw: case SHOGI BlackDrunk: case SHOGI BlackAlfil: Ferz(board, flags, rf, ff, callback, closure); @@ -582,8 +949,9 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, StepBackward(board, flags, rf, ff, callback, closure); break; - case SHOGI (PROMOTED BlackKnight): + case SHOGI (PROMO BlackKnight): if(gameInfo.variant == VariantShogi) goto BlackGold; + case SHOGI BlackClaw: case SHOGI WhiteDrunk: case SHOGI WhiteAlfil: Ferz(board, flags, rf, ff, callback, closure); @@ -592,15 +960,15 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, break; - case SHOGI WhiteStag: - case SHOGI BlackStag: + case SHOGI WhiteGnu: + case SHOGI BlackGnu: if(gameInfo.variant == VariantShogi) goto BlackGold; SlideVertical(board, flags, rf, ff, callback, closure); Ferz(board, flags, rf, ff, callback, closure); StepSideways(board, flags, rf, ff, callback, closure); break; - case SHOGI (PROMOTED WhiteQueen): + case SHOGI (PROMO WhiteQueen): case SHOGI WhiteTokin: case SHOGI WhiteWazir: WhiteGold: @@ -608,7 +976,7 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, Wazir(board, flags, rf, ff, callback, closure); break; - case SHOGI (PROMOTED BlackQueen): + case SHOGI (PROMO BlackQueen): case SHOGI BlackTokin: case SHOGI BlackWazir: BlackGold: @@ -737,17 +1105,18 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, /* Make Dragon-King Dababba & Rook-like outside Shogi, for better disambiguation in variant Fairy */ case WhiteDragon: case BlackDragon: - if(gameInfo.variant == VariantChuChess) goto DragonKing; + if(gameInfo.variant == VariantChuChess || gameInfo.variant == VariantSpartan) goto DragonKing; for (d = 0; d <= 1; d++) // Dababba moves that Rook cannot do for (s = -2; s <= 2; s += 4) { rt = rf + s * d; ft = ff + s * (1 - d); - if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT || board[rf+rt>>1][ff+ft>>1] == EmptySquare) continue; + if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) continue; + if (board[rf+rt>>1][ff+ft>>1] == EmptySquare) continue; if (SameColor(board[rf][ff], board[rt][ft])) continue; callback(board, flags, NormalMove, rf, ff, rt, ft, closure); } - if(gameInfo.variant == VariantSpartan) rookRange = 2; // in Spartan Chess restrict range to modern Dababba - goto doRook; + Rook(board, flags, rf, ff, callback, closure); + break; /* Shogi Dragon King has to continue as Ferz after Rook moves */ case SHOGI WhiteDragon: @@ -770,6 +1139,19 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, Knight(board, flags, rf, ff, callback, closure); break; + case WhiteTower: + case BlackTower: + for (d = 0; d <= 1; d++) // Dababba moves + for (s = -2; s <= 2; s += 4) { + rt = rf + s * d; + ft = ff + s * (1 - d); + if (rt < 0 || rt >= BOARD_HEIGHT || ft < BOARD_LEFT || ft >= BOARD_RGHT) continue; + if (SameColor(board[rf][ff], board[rt][ft])) continue; + callback(board, flags, NormalMove, rf, ff, rt, ft, closure); + } + Wazir(board, flags, rf, ff, callback, closure); + break; + /* Shogi Rooks are ordinary Rooks */ case SHOGI WhiteRook: case SHOGI BlackRook: @@ -777,7 +1159,6 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, case SHOGI BlackPRook: case WhiteRook: case BlackRook: - doRook: Rook(board, flags, rf, ff, callback, closure); break; @@ -812,6 +1193,12 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, case WhiteFerz: case BlackFerz: + if(gameInfo.variant == VariantXiangqi && ff != BOARD_WIDTH>>1) { + int rt = (piece == BlackFerz ? BOARD_HEIGHT-2 : 1); + int ft = BOARD_WIDTH>>1; + if(!SameColor(board[rf][ff], board[rt][ft])) + callback(board, flags, NormalMove, rf, ff, rt, ft, closure); + } else /* [HGM] support Shatranj pieces */ Ferz(board, flags, rf, ff, callback, closure); break; @@ -896,13 +1283,15 @@ 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; - callback(board, flags, (rt-rf)*(rt-rf) + (ff-ft)*(ff-ft) < 3 && board[rt][ft] != EmptySquare ? FirstLeg : NormalMove, + 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 && !i ? FirstLeg : NormalMove, rf, ff, rt, ft, closure); + legNr -= 2*i; } break; - case SHOGI WhiteFalcon: - case SHOGI BlackFalcon: + case SHOGI WhiteDagger: + case SHOGI BlackDagger: case SHOGI WhitePDagger: case SHOGI BlackPDagger: SlideSideways(board, flags, rf, ff, callback, closure); @@ -914,28 +1303,30 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, StepVertical(board, flags, rf, ff, callback, closure); break; - case SHOGI (PROMOTED WhiteFerz): + case SHOGI (PROMO WhiteFerz): if(gameInfo.variant == VariantShogi) goto WhiteGold; - case SHOGI (PROMOTED BlackFerz): + case SHOGI (PROMO BlackFerz): if(gameInfo.variant == VariantShogi) goto BlackGold; + case SHOGI WhiteSword: + case SHOGI BlackSword: case SHOGI WhitePSword: case SHOGI BlackPSword: SlideVertical(board, flags, rf, ff, callback, closure); StepSideways(board, flags, rf, ff, callback, closure); break; - case SHOGI WhiteUnicorn: - case SHOGI BlackUnicorn: + case SHOGI WhiteCat: + case SHOGI BlackCat: Ferz(board, flags, rf, ff, callback, closure); StepVertical(board, flags, rf, ff, callback, closure); break; - case SHOGI WhiteMan: + case SHOGI WhiteCopper: StepDiagForward(board, flags, rf, ff, callback, closure); StepVertical(board, flags, rf, ff, callback, closure); break; - case SHOGI BlackMan: + case SHOGI BlackCopper: StepDiagBackward(board, flags, rf, ff, callback, closure); StepVertical(board, flags, rf, ff, callback, closure); break; @@ -952,7 +1343,7 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, SlideVertical(board, flags, rf, ff, callback, closure); break; - case SHOGI WhiteHorned: + case SHOGI WhiteUnicorn: Sting(board, flags, rf, ff, 1, 0, callback, closure); callback(board, flags, NormalMove, rf, ff, rf, ff, closure); if(killX >= 0) break; @@ -961,7 +1352,7 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, SlideBackward(board, flags, rf, ff, callback, closure); break; - case SHOGI BlackHorned: + case SHOGI BlackUnicorn: Sting(board, flags, rf, ff, -1, 0, callback, closure); callback(board, flags, NormalMove, rf, ff, rf, ff, closure); if(killX >= 0) break; @@ -970,7 +1361,7 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, SlideForward(board, flags, rf, ff, callback, closure); break; - case SHOGI WhiteEagle: + case SHOGI WhiteFalcon: Sting(board, flags, rf, ff, 1, 1, callback, closure); Sting(board, flags, rf, ff, 1, -1, callback, closure); callback(board, flags, NormalMove, rf, ff, rf, ff, closure); @@ -979,7 +1370,7 @@ GenPseudoLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, SlideDiagBackward(board, flags, rf, ff, callback, closure); break; - case SHOGI BlackEagle: + case SHOGI BlackFalcon: Sting(board, flags, rf, ff, -1, 1, callback, closure); Sting(board, flags, rf, ff, -1, -1, callback, closure); callback(board, flags, NormalMove, rf, ff, rf, ff, closure); @@ -1039,7 +1430,7 @@ GenLegalCallback (Board board, int flags, ChessMove kind, int rf, int ff, int rt if(rFilter >= 0 && rFilter != rt || fFilter >= 0 && fFilter != ft) return; // [HGM] speed: ignore moves with wrong to-square - if (board[EP_STATUS] == EP_IRON_LION && (board[rt][ft] == WhiteLion || board[rt][ft] == BlackLion)) return; //[HGM] lion + if ((int)board[EP_STATUS] == EP_IRON_LION && (board[rt][ft] == WhiteLion || board[rt][ft] == BlackLion)) return; //[HGM] lion if (!(flags & F_IGNORE_CHECK) ) { int check, promo = (gameInfo.variant == VariantSpartan && kind == BlackPromotion); @@ -1098,6 +1489,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; @@ -1112,6 +1504,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) && @@ -1215,8 +1610,10 @@ GenLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, Ches if(k != ft && board[0][k] != EmptySquare) ft = NoRights; for(k=left; k BOARD_LEFT+2) for(k=left+1; k<=right && ft != NoRights; k++) /* then if not checked */ if(!ignoreCheck && CheckTest(board, flags, 0, ff, 0, k, FALSE)) ft = NoRights; - if(ft != NoRights && board[0][ft] == WhiteRook) - callback(board, flags, WhiteASideCastleFR, 0, swap ? ft : ff, 0, swap ? ff : ft, closure); + if(ft != NoRights && board[0][ft] == WhiteRook) { + if(flags & F_FRC_TYPE_CASTLING) callback(board, flags, WhiteASideCastleFR, 0, ff, 0, ft, closure); + if(swap) callback(board, flags, WhiteASideCastleFR, 0, ft, 0, ff, closure); + } } } else { ff = castlingRights[5]; /* King file if we have any rights */ @@ -1241,8 +1641,10 @@ GenLegal (Board board, int flags, MoveCallback callback, VOIDSTAR closure, Ches if(k != ft && board[BOARD_HEIGHT-1][k] != EmptySquare) ft = NoRights; for(k=left; k BOARD_LEFT+2) for(k=left+1; k<=right && ft != NoRights; k++) /* then if not checked */ if(!ignoreCheck && CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, k, FALSE)) ft = NoRights; - if(ft != NoRights && board[BOARD_HEIGHT-1][ft] == BlackRook) - callback(board, flags, BlackASideCastleFR, BOARD_HEIGHT-1, swap ? ft : ff, BOARD_HEIGHT-1, swap ? ff : ft, closure); + if(ft != NoRights && board[BOARD_HEIGHT-1][ft] == BlackRook) { + if(flags & F_FRC_TYPE_CASTLING) callback(board, flags, BlackASideCastleFR, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ft, closure); + if(swap) callback(board, flags, BlackASideCastleFR, BOARD_HEIGHT-1, ft, BOARD_HEIGHT-1, ff, closure); + } } } @@ -1281,11 +1686,11 @@ CheckTestCallback (Board board, int flags, ChessMove kind, int rf, int ff, int r register CheckTestClosure *cl = (CheckTestClosure *) closure; if (rt == cl->rking && ft == cl->fking) { - if(xqCheckers[EP_STATUS] >= 2 && xqCheckers[rf][ff]) return; // checker is piece with suspended checking power + if((int)xqCheckers[EP_STATUS] >= 2 && xqCheckers[rf][ff]) return; // checker is piece with suspended checking power cl->check++; xqCheckers[rf][ff] = xqCheckers[EP_STATUS] & 1; // remember who is checking (if status == 1) } - if( board[EP_STATUS] == EP_ROYAL_LION && (board[rt][ft] == WhiteLion || board[rt][ft] == BlackLion) + if( (int)board[EP_STATUS] == EP_ROYAL_LION && (board[rt][ft] == WhiteLion || board[rt][ft] == BlackLion) && (gameInfo.variant != VariantLion || board[rf][ff] != WhiteKing && board[rf][ff] != BlackKing) ) cl->check++; // [HGM] lion: forbidden counterstrike against Lion equated to putting yourself in check } @@ -1303,13 +1708,24 @@ CheckTest (Board board, int flags, int rf, int ff, int rt, int ft, int enPassant { CheckTestClosure cl; ChessSquare king = flags & F_WHITE_ON_MOVE ? WhiteKing : BlackKing; - ChessSquare captured = EmptySquare, ep, trampled; + ChessSquare captured = EmptySquare, ep=0, trampled=0, trampled2 = 0; + int saveKill = killX; /* Suppress warnings on uninitialized variables */ if(gameInfo.variant == VariantXiangqi) king = flags & F_WHITE_ON_MOVE ? WhiteWazir : BlackWazir; if(gameInfo.variant == VariantKnightmate) king = flags & F_WHITE_ON_MOVE ? WhiteUnicorn : BlackUnicorn; + if(gameInfo.variant == VariantChu || gameInfo.variant == VariantShogi) { // strictly speaking this is not needed, as Chu officially has no check + int r, f, k = king, royals=0, prince = flags & F_WHITE_ON_MOVE ? WhiteMonarch : BlackMonarch; + if(gameInfo.variant == VariantShogi) prince -= 11; // White/BlackFalcon + for(r=0; r 1) return FALSE; // no check if we have two royals (ignores double captureby Lion!) + king = board[r][f]; // remember hich one we had + } + } + } if (rt >= 0) { if (enPassant) { @@ -1317,18 +1733,22 @@ CheckTest (Board board, int flags, int rf, int ff, int rt, int ft, int enPassant board[rf][ft] = EmptySquare; } else { captured = board[rt][ft]; - if(killX >= 0) { trampled = board[killY][killX]; board[killY][killX] = EmptySquare; } + if(killX >= 0) { + trampled = board[killY][killX]; board[killY][killX] = EmptySquare; killX = -1; saveKill += (kill2X << 16) + (1 << 30); + if(kill2X >= 0) { trampled2 = board[kill2Y][kill2X]; board[kill2Y][kill2X] = EmptySquare; kill2X = -1; } + } } 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 - ChessSquare victim = killX < 0 ? EmptySquare : trampled; + ChessSquare victim = saveKill < 0 ? EmptySquare : trampled; if( (board[rt][ft] == WhiteLion || board[rt][ft] == BlackLion) && // capturer is Lion (ff - ft > 1 || ft - ff > 1 || rf - rt > 1 || rt - rf > 1) && // captures from a distance - (victim == EmptySquare || victim == WhitePawn || victim == BlackPawn) ) // no or worthless 'bridge' + (victim == EmptySquare || victim == WhitePawn || victim == BlackPawn // no or worthless 'bridge' + || victim == WhiteCobra || victim == BlackCobra) ) // (Pawn or Go Between) board[EP_STATUS] = EP_ROYAL_LION; // on distant Lion x Lion victim must not be pseudo-legally protected } } @@ -1365,7 +1785,10 @@ CheckTest (Board board, int flags, int rf, int ff, int rt, int ft, int enPassant board[rf][ft] = captured; board[rt][ft] = EmptySquare; } else { - if(killX >= 0) board[killY][killX] = trampled; + if(saveKill >= 0) { + if(saveKill & 1<<30) board[kill2Y][kill2X = saveKill >> 16 & 0xFFF] = trampled2; + board[killY][killX = saveKill & 0xFFF] = trampled; + } board[rt][ft] = captured; } board[EP_STATUS] = ep; @@ -1400,9 +1823,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; r= BOARD_HEIGHT - BOARD_HEIGHT/3 || rt >= BOARD_HEIGHT - BOARD_HEIGHT/3) ) { + (rf >= BOARD_HEIGHT - zone || rt >= BOARD_HEIGHT - zone) ) { if( (piece == WhitePawn || piece == WhiteQueen) && rt > BOARD_HEIGHT-2 || piece == WhiteKnight && rt > BOARD_HEIGHT-3) /* promotion mandatory */ cl.kind = promoChar == '=' ? IllegalMove : WhitePromotion; @@ -1503,7 +1934,7 @@ if(appData.debugMode)fprintf(debugFP,"SHOGI promoChar = %c\n", promoChar ? promo cl.kind = promoChar == '+' ? WhitePromotion : WhiteNonPromotion; } else cl.kind = promoChar == '+' ? IllegalMove : NormalMove; } else { - if( (int) piece < (int) BlackWazir && (rf < BOARD_HEIGHT/3 || rt < BOARD_HEIGHT/3) ) { + if( (int) piece < (int) BlackWazir && (rf < zone || rt < zone) ) { if( (piece == BlackPawn || piece == BlackQueen) && rt < 1 || piece == BlackKnight && rt < 2 ) /* promotion obligatory */ cl.kind = promoChar == '=' ? IllegalMove : BlackPromotion; @@ -1518,19 +1949,22 @@ if(appData.debugMode)fprintf(debugFP,"SHOGI promoChar = %c\n", promoChar ? promo ChessSquare piece = board[rf][ff]; if(piece < BlackPawn ? piece > WhiteMan : piece > BlackMan) return ImpossibleMove; // already promoted // should test if in zone, really - if(gameInfo.variant == VariantChuChess && (piece == WhiteKnight || piece == BlackKnight)) return !HasLion(board, flags); - if(PieceToChar(PROMOTED piece) == '+') return flags & F_WHITE_ON_MOVE ? WhitePromotion : BlackPromotion; + if(gameInfo.variant == VariantChuChess && (piece == WhiteKnight || piece == BlackKnight) && HasLion(board, flags)) + return IllegalMove; + if(PieceToChar(PROMOTED(piece)) == '+') return flags & F_WHITE_ON_MOVE ? WhitePromotion : BlackPromotion; } else if(promoChar == '=') cl.kind = IllegalMove; else // [HGM] shogi: no deferred promotion outside Shogi if (cl.kind == WhitePromotion || cl.kind == BlackPromotion) { ChessSquare piece = CharToPiece(flags & F_WHITE_ON_MOVE ? ToUpper(promoChar) : ToLower(promoChar)); if(piece == EmptySquare) cl.kind = ImpossibleMove; // non-existing piece - if(gameInfo.variant == VariantSpartan && cl.kind == BlackPromotion ) { + if(gameInfo.variant == VariantChuChess && promoChar == 'l' && HasLion(board, flags)) { + cl.kind = IllegalMove; // no two Lions + } else if(gameInfo.variant == VariantSpartan && cl.kind == BlackPromotion ) { if(promoChar != PieceToChar(BlackKing)) { if(CheckTest(board, flags, rf, ff, rt, ft, FALSE)) cl.kind = IllegalMove; // [HGM] spartan: only promotion to King was possible if(piece == BlackLance) cl.kind = ImpossibleMove; - } else { // promotion to King allowed only if we do not haave two yet + } else { // promotion to King allowed only if we do not have two yet int r, f, kings = 0; for(r=0; rpieceIn == EmptySquare || cl->pieceIn == board[rf][ff] || PieceToChar(board[rf][ff]) == '~' - && cl->pieceIn == (ChessSquare)(DEMOTED board[rf][ff]) + && cl->pieceIn == (ChessSquare)(DEMOTED(board[rf][ff])) ) && (cl->rfIn == -1 || cl->rfIn == rf) && (cl->ffIn == -1 || cl->ffIn == ff) && (cl->rtIn == -1 || cl->rtIn == rt || wildCard) && (cl->ftIn == -1 || cl->ftIn == ft || wildCard)) { + if(cl->count && rf == cl->rf && ff == cl->ff && rt == cl->rt && ft == cl->ft) return; // duplicate move + + if(cl->count == 1 && kifu & 0x7E && cl->rfIn == -1 && cl->ffIn == -1) { // traditional Shogi disambiguation required + int this = 1, other = 1; + if(kifu & 2) this &= (flags & 1 ? rt > rf : rt < rf), other &= (flags & 1 ? cl->rt > cl->rf : cl->rt < cl->rf); + if(kifu & 4) this &= (flags & 1 ? rt < rf : rt > rf), other &= (flags & 1 ? cl->rt < cl->rf : cl->rt > cl->rf); + if(kifu & 8) this &= (rf == rt), other &= (cl->rt == cl->rf); + if(kifu & 0x10) this &= (flags & 1 ? ft <= ff : ft >= ff), other &= (flags & 1 ? cl->ft <= cl->ff : cl->ft >= cl->ff); + if(kifu & 0x20) this &= (flags & 1 ? ft >= ff : ft <= ff), other &= (flags & 1 ? cl->ft >= cl->ff : cl->ft <= cl->ff); + if(kifu & 0x40) this &= (ft == ff), other &= (cl->ft == cl->ff); // should never be used + if(!other) cl->count--; // the old move did not satisfy the requested relative position, erase it + if(!this) return; // the current move does not satisfy the requested relative position, ignore it + } + cl->count++; if(cl->count == 1 || board[rt][ft] != EmptySquare) { // [HGM] oneclick: if multiple moves, be sure we remember capture @@ -1686,7 +2135,7 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure) GenLegal(board, flags|F_IGNORE_CHECK, DisambiguateCallback, (VOIDSTAR) closure, closure->pieceIn); if (closure->count == 0) { /* No, it's not even that */ - if(!appData.testLegality && closure->pieceIn != EmptySquare) { + if(!appData.testLegality && !pieceDefs && closure->pieceIn != EmptySquare) { int f, r; // if there is only a single piece of the requested type on the board, use that closure->rt = closure->rtIn, closure->ft = closure->ftIn; for(r=0; rcount > 1 && closure->rtIn >=0) { // [HGM] gen: move is ambiguous under engine-defined rules (and not one-click) + 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?) @@ -1712,10 +2167,14 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure) if(closure->rf != 0) closure->kind = IllegalMove; // must be on back rank if(!(board[VIRGIN][closure->ff] & VIRGIN_W)) closure->kind = IllegalMove; // non-virgin if(board[PieceToNumber(CharToPiece(ToUpper(c)))][BOARD_WIDTH-2] == 0) closure->kind = ImpossibleMove;// must be in stock + if(closure->kind == WhiteHSideCastleFR && (closure->ff == BOARD_RGHT-2 || closure->ff == BOARD_RGHT-3)) closure->kind = ImpossibleMove; + if(closure->kind == WhiteASideCastleFR && (closure->ff == BOARD_LEFT+2 || closure->ff == BOARD_LEFT+3)) closure->kind = ImpossibleMove; } else { if(closure->rf != BOARD_HEIGHT-1) closure->kind = IllegalMove; if(!(board[VIRGIN][closure->ff] & VIRGIN_B)) closure->kind = IllegalMove; // non-virgin if(board[BOARD_HEIGHT-1-PieceToNumber(CharToPiece(ToLower(c)))][1] == 0) closure->kind = ImpossibleMove; + if(closure->kind == BlackHSideCastleFR && (closure->ff == BOARD_RGHT-2 || closure->ff == BOARD_RGHT-3)) closure->kind = ImpossibleMove; + if(closure->kind == BlackASideCastleFR && (closure->ff == BOARD_LEFT+2 || closure->ff == BOARD_LEFT+3)) closure->kind = ImpossibleMove; } } else if(gameInfo.variant == VariantChu) { @@ -1725,6 +2184,7 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure) /* [HGM] Shogi promotions. On input, '=' means defer, '+' promote. Afterwards, c is set to '+' for promotions, NULL other */ if(closure->rfIn != DROP_RANK && closure->kind == NormalMove) { ChessSquare piece = closure->piece; + int zone = BOARD_HEIGHT/3 + (BOARD_HEIGHT == 8); if (c == 'd' && (piece == WhiteRook || piece == BlackRook) || c == 'h' && (piece == WhiteBishop || piece == BlackBishop) || c == 'g' && (piece <= WhiteFerz || piece <= BlackFerz && piece >= BlackPawn) ) @@ -1732,7 +2192,7 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure) if(c != NULLCHAR && c != '+' && c != '=') closure->kind = IllegalMove; // otherwise specifying a piece is illegal else if(flags & F_WHITE_ON_MOVE) { if( (int) piece < (int) WhiteWazir && - (closure->rf >= BOARD_HEIGHT-(BOARD_HEIGHT/3) || closure->rt >= BOARD_HEIGHT-(BOARD_HEIGHT/3)) ) { + (closure->rf >= BOARD_HEIGHT-zone || closure->rt >= BOARD_HEIGHT-zone) ) { if( (piece == WhitePawn || piece == WhiteQueen) && closure->rt > BOARD_HEIGHT-2 || piece == WhiteKnight && closure->rt > BOARD_HEIGHT-3) /* promotion mandatory */ closure->kind = c == '=' ? IllegalMove : WhitePromotion; @@ -1740,7 +2200,7 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure) closure->kind = c == '+' ? WhitePromotion : WhiteNonPromotion; } else closure->kind = c == '+' ? IllegalMove : NormalMove; } else { - if( (int) piece < (int) BlackWazir && (closure->rf < BOARD_HEIGHT/3 || closure->rt < BOARD_HEIGHT/3) ) { + if( (int) piece < (int) BlackWazir && (closure->rf < zone || closure->rt < zone) ) { if( (piece == BlackPawn || piece == BlackQueen) && closure->rt < 1 || piece == BlackKnight && closure->rt < 2 ) /* promotion obligatory */ closure->kind = c == '=' ? IllegalMove : BlackPromotion; @@ -1755,8 +2215,10 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure) if (closure->kind == WhitePromotion || closure->kind == BlackPromotion) { if(c == NULLCHAR) { // missing promoChar on mandatory promotion; use default for variant if(gameInfo.variant == VariantShatranj || gameInfo.variant == VariantCourier || - gameInfo.variant == VariantMakruk || gameInfo.variant == VariantASEAN) + gameInfo.variant == VariantMakruk) c = PieceToChar(BlackFerz); + else if(gameInfo.variant == VariantASEAN) + c = PieceToChar(BlackRook); else if(gameInfo.variant == VariantGreat) c = PieceToChar(BlackMan); else if(gameInfo.variant == VariantGrand) @@ -1764,6 +2226,12 @@ Disambiguate (Board board, int flags, DisambiguateClosure *closure) else c = PieceToChar(BlackQueen); } else if(c == '=') closure->kind = IllegalMove; // no deferral outside Shogi + else if(c == 'l' && gameInfo.variant == VariantChuChess && HasLion(board, flags)) closure->kind = IllegalMove; + } else if (c == '+') { // '+' outside shogi, check if pieceToCharTable enabled it + ChessSquare p = closure->piece; + if(p > WhiteMan && p < BlackPawn || p > BlackMan || PieceToChar(PROMOTED(p)) != '+') + closure->kind = ImpossibleMove; // used on non-promotable piece + else if(gameInfo.variant == VariantChuChess && HasLion(board, flags)) closure->kind = IllegalMove; } else if (c != NULLCHAR) closure->kind = IllegalMove; closure->promoChar = ToLower(c); // this can be NULLCHAR! Note we keep original promoChar even if illegal. @@ -1806,7 +2274,7 @@ CoordsToAlgebraicCallback (Board board, int flags, ChessMove kind, int rf, int f if ((rt == cl->rt && ft == cl->ft || rt == rf && ft == ff) && // [HGM] null move matches any toSquare (board[rf][ff] == cl->piece || PieceToChar(board[rf][ff]) == '~' && - (ChessSquare) (DEMOTED board[rf][ff]) == cl->piece) + (ChessSquare) (DEMOTED(board[rf][ff])) == cl->piece) ) { if (rf == cl->rf) { if (ff == cl->ff) { @@ -1832,7 +2300,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) { @@ -1850,7 +2318,7 @@ CoordsToAlgebraic (Board board, int flags, int rf, int ff, int rt, int ft, int p if (promoChar == 'x') promoChar = NULLCHAR; piece = board[rf][ff]; - if(PieceToChar(piece)=='~') piece = (ChessSquare)(DEMOTED piece); + if(PieceToChar(piece)=='~') piece = (ChessSquare)(DEMOTED(piece)); switch (piece) { case WhitePawn: @@ -1865,14 +2333,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') @@ -1941,13 +2410,13 @@ CoordsToAlgebraic (Board board, int flags, int rf, int ff, int rt, int ft, int p cl.kind = IllegalMove; cl.rank = cl.file = cl.either = 0; c = PieceToChar(piece) ; - GenLegal(board, flags, CoordsToAlgebraicCallback, (VOIDSTAR) &cl, c!='~' ? piece : (DEMOTED piece)); // [HGM] speed + GenLegal(board, flags, CoordsToAlgebraicCallback, (VOIDSTAR) &cl, c!='~' ? piece : (DEMOTED(piece))); // [HGM] speed if (cl.kind == IllegalMove && !(flags&F_IGNORE_CHECK)) { /* Generate pretty moves for moving into check, but still return IllegalMove. */ - GenLegal(board, flags|F_IGNORE_CHECK, CoordsToAlgebraicCallback, (VOIDSTAR) &cl, c!='~' ? piece : (DEMOTED piece)); + GenLegal(board, flags|F_IGNORE_CHECK, CoordsToAlgebraicCallback, (VOIDSTAR) &cl, c!='~' ? piece : (DEMOTED(piece))); if (cl.kind == IllegalMove) break; cl.kind = IllegalMove; } @@ -1959,10 +2428,11 @@ CoordsToAlgebraic (Board board, int flags, int rf, int ff, int rt, int ft, int p */ if( c == '~' || c == '+') { /* [HGM] print nonexistent piece as its demoted version */ - piece = (ChessSquare) (DEMOTED piece - 11*(gameInfo.variant == VariantChu)); + piece = (ChessSquare) (CHUDEMOTED(piece)); } if(c=='+') *outp++ = c; *outp++ = ToUpper(PieceToChar(piece)); + if(*outp = PieceSuffix(piece)) outp++; if (cl.file || (cl.either && !cl.rank)) { *outp++ = ff + AAA; @@ -1984,7 +2454,8 @@ CoordsToAlgebraic (Board board, int flags, int rf, int ff, int rt, int ft, int p /* [HGM] in Shogi non-pawns can promote */ *outp++ = promoChar; // Don't bother to correct move type, return value is never used! } - else if (gameInfo.variant != VariantSuper && promoChar && + else if (gameInfo.variant == VariantChuChess && promoChar || + gameInfo.variant != VariantSuper && promoChar && (piece == WhiteLance || piece == BlackLance) ) { // Lance sometimes represents Pawn *outp++ = '='; *outp++ = ToUpper(promoChar); @@ -2015,7 +2486,10 @@ CoordsToAlgebraic (Board board, int flags, int rf, int ff, int rt, int ft, int p int r, f; for(r=0; r