X-Git-Url: http://winboard.nl/cgi-bin?a=blobdiff_plain;f=moves.c;h=57e350e668573386467fe894c92e041f4ad5858b;hb=056614196635a4730170261fe0e638191f14c620;hp=accbfedcc9352171c6b95f05d5675dd776960839;hpb=3096093223ecdfbf7062e9f8c569347e472d6243;p=xboard.git diff --git a/moves.c b/moves.c index accbfed..57e350e 100644 --- a/moves.c +++ b/moves.c @@ -1,1024 +1,1241 @@ -/* - * moves.c - Move generation and checking - * $Id: moves.c,v 2.1 2003/10/27 19:21:00 mann Exp $ - * - * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts. - * Enhancements Copyright 1992-95 Free Software Foundation, Inc. - * - * The following terms apply to Digital Equipment Corporation's copyright - * interest in XBoard: - * ------------------------------------------------------------------------ - * All Rights Reserved - * - * Permission to use, copy, modify, and distribute this software and its - * documentation for any purpose and without fee is hereby granted, - * provided that the above copyright notice appear in all copies and that - * both that copyright notice and this permission notice appear in - * supporting documentation, and that the name of Digital not be - * used in advertising or publicity pertaining to distribution of the - * software without specific, written prior permission. - * - * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING - * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL - * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR - * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, - * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, - * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS - * SOFTWARE. - * ------------------------------------------------------------------------ - * - * The following terms apply to the enhanced version of XBoard distributed - * by the Free Software Foundation: - * ------------------------------------------------------------------------ - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * ------------------------------------------------------------------------ - */ - -#include "config.h" - -#include -#if HAVE_STRING_H -# include -#else /* not HAVE_STRING_H */ -# include -#endif /* not HAVE_STRING_H */ -#include "common.h" -#include "backend.h" -#include "moves.h" -#include "parser.h" - -int WhitePiece P((ChessSquare)); -int BlackPiece P((ChessSquare)); -int SameColor P((ChessSquare, ChessSquare)); - - -int WhitePiece(piece) - ChessSquare piece; -{ - return (int) piece >= (int) WhitePawn && (int) piece <= (int) WhiteKing; -} - -int BlackPiece(piece) - ChessSquare piece; -{ - return (int) piece >= (int) BlackPawn && (int) piece <= (int) BlackKing; -} - -int SameColor(piece1, piece2) - ChessSquare piece1, piece2; -{ - return ((int) piece1 >= (int) WhitePawn && - (int) piece1 <= (int) WhiteKing && - (int) piece2 >= (int) WhitePawn && - (int) piece2 <= (int) WhiteKing) - || ((int) piece1 >= (int) BlackPawn && - (int) piece1 <= (int) BlackKing && - (int) piece2 >= (int) BlackPawn && - (int) piece2 <= (int) BlackKing); -} - -ChessSquare PromoPiece(moveType) - ChessMove moveType; -{ - switch (moveType) { - default: - return EmptySquare; - case WhitePromotionQueen: - return WhiteQueen; - case BlackPromotionQueen: - return BlackQueen; - case WhitePromotionRook: - return WhiteRook; - case BlackPromotionRook: - return BlackRook; - case WhitePromotionBishop: - return WhiteBishop; - case BlackPromotionBishop: - return BlackBishop; - case WhitePromotionKnight: - return WhiteKnight; - case BlackPromotionKnight: - return BlackKnight; - case WhitePromotionKing: - return WhiteKing; - case BlackPromotionKing: - return BlackKing; - } -} - -ChessMove PromoCharToMoveType(whiteOnMove, promoChar) - int whiteOnMove; - int promoChar; -{ - if (whiteOnMove) { - switch (promoChar) { - case 'n': - case 'N': - return WhitePromotionKnight; - case 'b': - case 'B': - return WhitePromotionBishop; - case 'r': - case 'R': - return WhitePromotionRook; - case 'q': - case 'Q': - return WhitePromotionQueen; - case 'k': - case 'K': - return WhitePromotionKing; - case NULLCHAR: - default: - return NormalMove; - } - } else { - switch (promoChar) { - case 'n': - case 'N': - return BlackPromotionKnight; - case 'b': - case 'B': - return BlackPromotionBishop; - case 'r': - case 'R': - return BlackPromotionRook; - case 'q': - case 'Q': - return BlackPromotionQueen; - case 'k': - case 'K': - return BlackPromotionKing; - case NULLCHAR: - default: - return NormalMove; - } - } -} - -char pieceToChar[] = { - 'P', 'N', 'B', 'R', 'Q', 'K', - 'p', 'n', 'b', 'r', 'q', 'k', 'x' - }; - -char PieceToChar(p) - ChessSquare p; -{ - return pieceToChar[(int) p]; -} - -ChessSquare CharToPiece(c) - int c; -{ - switch (c) { - default: - case 'x': return EmptySquare; - case 'P': return WhitePawn; - case 'R': return WhiteRook; - case 'N': return WhiteKnight; - case 'B': return WhiteBishop; - case 'Q': return WhiteQueen; - case 'K': return WhiteKing; - case 'p': return BlackPawn; - case 'r': return BlackRook; - case 'n': return BlackKnight; - case 'b': return BlackBishop; - case 'q': return BlackQueen; - case 'k': return BlackKing; - } -} - -void CopyBoard(to, from) - Board to, from; -{ - int i, j; - - for (i = 0; i < BOARD_SIZE; i++) - for (j = 0; j < BOARD_SIZE; j++) - to[i][j] = from[i][j]; -} - -int CompareBoards(board1, board2) - Board board1, board2; -{ - int i, j; - - for (i = 0; i < BOARD_SIZE; i++) - for (j = 0; j < BOARD_SIZE; j++) { - if (board1[i][j] != board2[i][j]) - return FALSE; - } - return TRUE; -} - - -/* Call callback once for each pseudo-legal move in the given - position, except castling moves. A move is pseudo-legal if it is - legal, or if it would be legal except that it leaves the king in - check. In the arguments, epfile is EP_NONE if the previous move - was not a double pawn push, or the file 0..7 if it was, or - EP_UNKNOWN if we don't know and want to allow all e.p. captures. - Promotion moves generated are to Queen only. -*/ -void GenPseudoLegal(board, flags, epfile, callback, closure) - Board board; - int flags; - int epfile; - MoveCallback callback; - VOIDSTAR closure; -{ - int rf, ff; - int i, j, d, s, fs, rs, rt, ft; - - for (rf = 0; rf <= 7; rf++) - for (ff = 0; ff <= 7; ff++) { - if (flags & F_WHITE_ON_MOVE) { - if (!WhitePiece(board[rf][ff])) continue; - } else { - if (!BlackPiece(board[rf][ff])) continue; - } - switch (board[rf][ff]) { - case EmptySquare: - default: - /* can't happen */ - break; - - case WhitePawn: - if (rf < 7 && board[rf + 1][ff] == EmptySquare) { - callback(board, flags, - rf == 6 ? WhitePromotionQueen : NormalMove, - rf, ff, rf + 1, ff, closure); - } - if (rf == 1 && board[2][ff] == EmptySquare && - board[3][ff] == EmptySquare) { - callback(board, flags, NormalMove, - rf, ff, 3, ff, closure); - } - for (s = -1; s <= 1; s += 2) { - if (rf < 7 && ff + s >= 0 && ff + s <= 7 && - ((flags & F_KRIEGSPIEL_CAPTURE) || - BlackPiece(board[rf + 1][ff + s]))) { - callback(board, flags, - rf == 6 ? WhitePromotionQueen : NormalMove, - rf, ff, rf + 1, ff + s, closure); - } - if (rf == 4) { - if (ff + s >= 0 && ff + s <= 7 && - (epfile == ff + s || epfile == EP_UNKNOWN) && - board[4][ff + s] == BlackPawn && - board[5][ff + s] == EmptySquare) { - callback(board, flags, WhiteCapturesEnPassant, - rf, ff, 5, ff + s, closure); - } - } - } - break; - - case BlackPawn: - if (rf > 0 && board[rf - 1][ff] == EmptySquare) { - callback(board, flags, - rf == 1 ? BlackPromotionQueen : NormalMove, - rf, ff, rf - 1, ff, closure); - } - if (rf == 6 && board[5][ff] == EmptySquare && - board[4][ff] == EmptySquare) { - callback(board, flags, NormalMove, - rf, ff, 4, ff, closure); - } - for (s = -1; s <= 1; s += 2) { - if (rf > 0 && ff + s >= 0 && ff + s <= 7 && - ((flags & F_KRIEGSPIEL_CAPTURE) || - WhitePiece(board[rf - 1][ff + s]))) { - callback(board, flags, - rf == 1 ? BlackPromotionQueen : NormalMove, - rf, ff, rf - 1, ff + s, closure); - } - if (rf == 3) { - if (ff + s >= 0 && ff + s <= 7 && - (epfile == ff + s || epfile == EP_UNKNOWN) && - board[3][ff + s] == WhitePawn && - board[2][ff + s] == EmptySquare) { - callback(board, flags, BlackCapturesEnPassant, - rf, ff, 2, ff + s, closure); - } - } - } - break; - - case WhiteKnight: - case BlackKnight: - for (i = -1; i <= 1; i += 2) - for (j = -1; j <= 1; j += 2) - for (s = 1; s <= 2; s++) { - rt = rf + i*s; - ft = ff + j*(3-s); - if (rt < 0 || rt > 7 || ft < 0 || ft > 7) continue; - if (SameColor(board[rf][ff], board[rt][ft])) continue; - callback(board, flags, NormalMove, - rf, ff, rt, ft, closure); - } - break; - - case WhiteBishop: - case BlackBishop: - for (rs = -1; rs <= 1; rs += 2) - for (fs = -1; fs <= 1; fs += 2) - for (i = 1;; i++) { - rt = rf + (i * rs); - ft = ff + (i * fs); - if (rt < 0 || rt > 7 || ft < 0 || ft > 7) break; - if (SameColor(board[rf][ff], board[rt][ft])) break; - callback(board, flags, NormalMove, - rf, ff, rt, ft, closure); - if (board[rt][ft] != EmptySquare) break; - } - break; - - case WhiteRook: - case BlackRook: - for (d = 0; d <= 1; d++) - for (s = -1; s <= 1; s += 2) - for (i = 1;; i++) { - rt = rf + (i * s) * d; - ft = ff + (i * s) * (1 - d); - if (rt < 0 || rt > 7 || ft < 0 || ft > 7) break; - if (SameColor(board[rf][ff], board[rt][ft])) break; - callback(board, flags, NormalMove, - rf, ff, rt, ft, closure); - if (board[rt][ft] != EmptySquare) break; - } - break; - - case WhiteQueen: - case BlackQueen: - for (rs = -1; rs <= 1; rs++) - for (fs = -1; fs <= 1; fs++) { - if (rs == 0 && fs == 0) continue; - for (i = 1;; i++) { - rt = rf + (i * rs); - ft = ff + (i * fs); - if (rt < 0 || rt > 7 || ft < 0 || ft > 7) break; - if (SameColor(board[rf][ff], board[rt][ft])) break; - callback(board, flags, NormalMove, - rf, ff, rt, ft, closure); - if (board[rt][ft] != EmptySquare) break; - } - } - break; - - case WhiteKing: - case BlackKing: - for (i = -1; i <= 1; i++) - for (j = -1; j <= 1; j++) { - if (i == 0 && j == 0) continue; - rt = rf + i; - ft = ff + j; - if (rt < 0 || rt > 7 || ft < 0 || ft > 7) continue; - if (SameColor(board[rf][ff], board[rt][ft])) continue; - callback(board, flags, NormalMove, - rf, ff, rt, ft, closure); - } - break; - } - } -} - - -typedef struct { - MoveCallback cb; - VOIDSTAR cl; -} GenLegalClosure; - -extern void GenLegalCallback P((Board board, int flags, ChessMove kind, - int rf, int ff, int rt, int ft, - VOIDSTAR closure)); - -void GenLegalCallback(board, flags, kind, rf, ff, rt, ft, closure) - Board board; - int flags; - ChessMove kind; - int rf, ff, rt, ft; - VOIDSTAR closure; -{ - register GenLegalClosure *cl = (GenLegalClosure *) closure; - - if (!(flags & F_IGNORE_CHECK) && - CheckTest(board, flags, rf, ff, rt, ft, - kind == WhiteCapturesEnPassant || - kind == BlackCapturesEnPassant)) return; - if (flags & F_ATOMIC_CAPTURE) { - if (board[rt][ft] != EmptySquare || - kind == WhiteCapturesEnPassant || kind == BlackCapturesEnPassant) { - int r, f; - ChessSquare king = (flags & F_WHITE_ON_MOVE) ? WhiteKing : BlackKing; - if (board[rf][ff] == king) return; - for (r = rt-1; r <= rt+1; r++) { - for (f = ft-1; f <= ft+1; f++) { - if (r >= 0 && r <= 7 && f >= 0 && f <= 7 && - board[r][f] == king) return; - } - } - } - } - cl->cb(board, flags, kind, rf, ff, rt, ft, cl->cl); -} - - -typedef struct { - int rf, ff, rt, ft; - ChessMove kind; -} LegalityTestClosure; - - -/* Like GenPseudoLegal, but (1) include castling moves, (2) unless - F_IGNORE_CHECK is set in the flags, omit moves that would leave the - king in check, and (3) if F_ATOMIC_CAPTURE is set in the flags, omit - moves that would destroy your own king. The CASTLE_OK flags are - true if castling is not yet ruled out by a move of the king or - rook. Return TRUE if the player on move is currently in check and - F_IGNORE_CHECK is not set. */ -int GenLegal(board, flags, epfile, callback, closure) - Board board; - int flags; - int epfile; - MoveCallback callback; - VOIDSTAR closure; -{ - GenLegalClosure cl; - int ff, ft; - int ignoreCheck = (flags & F_IGNORE_CHECK) != 0; - - cl.cb = callback; - cl.cl = closure; - GenPseudoLegal(board, flags, epfile, GenLegalCallback, (VOIDSTAR) &cl); - - if (!ignoreCheck && - CheckTest(board, flags, -1, -1, -1, -1, FALSE)) return TRUE; - - /* Generate castling moves */ - for (ff = 4; ff >= 3; ff-- /*ics wild 1*/) { - if ((flags & F_WHITE_ON_MOVE) && - (flags & F_WHITE_KCASTLE_OK) && - board[0][ff] == WhiteKing && - board[0][ff + 1] == EmptySquare && - board[0][ff + 2] == EmptySquare && - board[0][6] == EmptySquare && - board[0][7] == WhiteRook && - (ignoreCheck || - (!CheckTest(board, flags, 0, ff, 0, ff + 1, FALSE) && - !CheckTest(board, flags, 0, ff, 0, ff + 2, FALSE)))) { - - callback(board, flags, - ff==4 ? WhiteKingSideCastle : WhiteKingSideCastleWild, - 0, ff, 0, ff + 2, closure); - } - if ((flags & F_WHITE_ON_MOVE) && - (flags & F_WHITE_QCASTLE_OK) && - board[0][ff] == WhiteKing && - board[0][ff - 1] == EmptySquare && - board[0][ff - 2] == EmptySquare && - board[0][1] == EmptySquare && - board[0][0] == WhiteRook && - (ignoreCheck || - (!CheckTest(board, flags, 0, ff, 0, ff - 1, FALSE) && - !CheckTest(board, flags, 0, ff, 0, ff - 2, FALSE)))) { - - callback(board, flags, - ff==4 ? WhiteQueenSideCastle : WhiteQueenSideCastleWild, - 0, ff, 0, ff - 2, closure); - } - if (!(flags & F_WHITE_ON_MOVE) && - (flags & F_BLACK_KCASTLE_OK) && - board[7][ff] == BlackKing && - board[7][ff + 1] == EmptySquare && - board[7][ff + 2] == EmptySquare && - board[7][6] == EmptySquare && - board[7][7] == BlackRook && - (ignoreCheck || - (!CheckTest(board, flags, 7, ff, 7, ff + 1, FALSE) && - !CheckTest(board, flags, 7, ff, 7, ff + 2, FALSE)))) { - - callback(board, flags, - ff==4 ? BlackKingSideCastle : BlackKingSideCastleWild, - 7, ff, 7, ff + 2, closure); - } - if (!(flags & F_WHITE_ON_MOVE) && - (flags & F_BLACK_QCASTLE_OK) && - board[7][ff] == BlackKing && - board[7][ff - 1] == EmptySquare && - board[7][ff - 2] == EmptySquare && - board[7][1] == EmptySquare && - board[7][0] == BlackRook && - (ignoreCheck || - (!CheckTest(board, flags, 7, ff, 7, ff - 1, FALSE) && - !CheckTest(board, flags, 7, ff, 7, ff - 1, FALSE)))) { - - callback(board, flags, - ff==4 ? BlackQueenSideCastle : BlackQueenSideCastleWild, - 7, ff, 7, ff - 2, closure); - } - } - - /* PUSH Fabien */ - - /* generate all potential FRC castling moves (KxR), ignoring flags */ - - if ((flags & F_WHITE_ON_MOVE) != 0) { - - for (ff = 1; ff < 7; ff++) { - if (board[0][ff] == WhiteKing) { - for (ft = 0; ft < 8; ft++) { - if (board[0][ft] == WhiteRook) { - callback(board, flags, - (ft > ff) ? WhiteHSideCastleFR : WhiteASideCastleFR, - 0, ff, 0, ft, closure); - } - } - } - } - - } else { - - for (ff = 1; ff < 7; ff++) { - if (board[7][ff] == BlackKing) { - for (ft = 0; ft < 8; ft++) { - if (board[7][ft] == BlackRook) { - callback(board, flags, - (ft > ff) ? BlackHSideCastleFR : BlackASideCastleFR, - 7, ff, 7, ft, closure); - } - } - } - } - } - - /* POP Fabien */ - - return FALSE; -} - - -typedef struct { - int rking, fking; - int check; -} CheckTestClosure; - - -extern void CheckTestCallback P((Board board, int flags, ChessMove kind, - int rf, int ff, int rt, int ft, - VOIDSTAR closure)); - - -void CheckTestCallback(board, flags, kind, rf, ff, rt, ft, closure) - Board board; - int flags; - ChessMove kind; - int rf, ff, rt, ft; - VOIDSTAR closure; -{ - register CheckTestClosure *cl = (CheckTestClosure *) closure; - - if (rt == cl->rking && ft == cl->fking) cl->check++; -} - - -/* If the player on move were to move from (rf, ff) to (rt, ft), would - he leave himself in check? Or if rf == -1, is the player on move - in check now? enPassant must be TRUE if the indicated move is an - e.p. capture. The possibility of castling out of a check along the - back rank is not accounted for (i.e., we still return nonzero), as - this is illegal anyway. Return value is the number of times the - king is in check. */ -int CheckTest(board, flags, rf, ff, rt, ft, enPassant) - Board board; - int flags; - int rf, ff, rt, ft, enPassant; -{ - CheckTestClosure cl; - ChessSquare king = flags & F_WHITE_ON_MOVE ? WhiteKing : BlackKing; - ChessSquare captured = EmptySquare; - /* Suppress warnings on uninitialized variables */ - - if (rf >= 0) { - if (enPassant) { - captured = board[rf][ft]; - board[rf][ft] = EmptySquare; - } else { - captured = board[rt][ft]; - } - board[rt][ft] = board[rf][ff]; - board[rf][ff] = EmptySquare; - } - - /* For compatibility with ICS wild 9, we scan the board in the - order a1, a2, a3, ... b1, b2, ..., h8 to find the first king, - and we test only whether that one is in check. */ - cl.check = 0; - for (cl.fking = 0; cl.fking <= 7; cl.fking++) - for (cl.rking = 0; cl.rking <= 7; cl.rking++) { - if (board[cl.rking][cl.fking] == king) { - GenPseudoLegal(board, flags ^ F_WHITE_ON_MOVE, -1, - CheckTestCallback, (VOIDSTAR) &cl); - goto undo_move; /* 2-level break */ - } - } - - undo_move: - - if (rf >= 0) { - board[rf][ff] = board[rt][ft]; - if (enPassant) { - board[rf][ft] = captured; - board[rt][ft] = EmptySquare; - } else { - board[rt][ft] = captured; - } - } - - return cl.check; -} - - -extern void LegalityTestCallback P((Board board, int flags, ChessMove kind, - int rf, int ff, int rt, int ft, - VOIDSTAR closure)); - -void LegalityTestCallback(board, flags, kind, rf, ff, rt, ft, closure) - Board board; - int flags; - ChessMove kind; - int rf, ff, rt, ft; - VOIDSTAR closure; -{ - register LegalityTestClosure *cl = (LegalityTestClosure *) closure; - - if (rf == cl->rf && ff == cl->ff && rt == cl->rt && ft == cl->ft) - cl->kind = kind; -} - -ChessMove LegalityTest(board, flags, epfile, rf, ff, rt, ft, promoChar) - Board board; - int flags, epfile; - int rf, ff, rt, ft, promoChar; -{ - LegalityTestClosure cl; - - cl.rf = rf; - cl.ff = ff; - cl.rt = rt; - cl.ft = ft; - cl.kind = IllegalMove; - GenLegal(board, flags, epfile, LegalityTestCallback, (VOIDSTAR) &cl); - if (promoChar != NULLCHAR && promoChar != 'x') { - if (cl.kind == WhitePromotionQueen || cl.kind == BlackPromotionQueen) { - cl.kind = - PromoCharToMoveType((flags & F_WHITE_ON_MOVE) != 0, promoChar); - } else { - cl.kind = IllegalMove; - } - } - return cl.kind; -} - -typedef struct { - int count; -} MateTestClosure; - -extern void MateTestCallback P((Board board, int flags, ChessMove kind, - int rf, int ff, int rt, int ft, - VOIDSTAR closure)); - -void MateTestCallback(board, flags, kind, rf, ff, rt, ft, closure) - Board board; - int flags; - ChessMove kind; - int rf, ff, rt, ft; - VOIDSTAR closure; -{ - register MateTestClosure *cl = (MateTestClosure *) closure; - - cl->count++; -} - -/* Return MT_NONE, MT_CHECK, MT_CHECKMATE, or MT_STALEMATE */ -int MateTest(board, flags, epfile) - Board board; - int flags, epfile; -{ - MateTestClosure cl; - int inCheck; - - cl.count = 0; - inCheck = GenLegal(board, flags, epfile, MateTestCallback, (VOIDSTAR) &cl); - if (cl.count > 0) { - return inCheck ? MT_CHECK : MT_NONE; - } else { - return inCheck ? MT_CHECKMATE : MT_STALEMATE; - } -} - - -extern void DisambiguateCallback P((Board board, int flags, ChessMove kind, - int rf, int ff, int rt, int ft, - VOIDSTAR closure)); - -void DisambiguateCallback(board, flags, kind, rf, ff, rt, ft, closure) - Board board; - int flags; - ChessMove kind; - int rf, ff, rt, ft; - VOIDSTAR closure; -{ - register DisambiguateClosure *cl = (DisambiguateClosure *) closure; - - if ((cl->pieceIn == EmptySquare || cl->pieceIn == board[rf][ff]) && - (cl->rfIn == -1 || cl->rfIn == rf) && - (cl->ffIn == -1 || cl->ffIn == ff) && - (cl->rtIn == -1 || cl->rtIn == rt) && - (cl->ftIn == -1 || cl->ftIn == ft)) { - - cl->count++; - cl->piece = board[rf][ff]; - cl->rf = rf; - cl->ff = ff; - cl->rt = rt; - cl->ft = ft; - cl->kind = kind; - } -} - -void Disambiguate(board, flags, epfile, closure) - Board board; - int flags, epfile; - DisambiguateClosure *closure; -{ - int illegal = 0; - closure->count = 0; - closure->rf = closure->ff = closure->rt = closure->ft = 0; - closure->kind = ImpossibleMove; - GenLegal(board, flags, epfile, DisambiguateCallback, (VOIDSTAR) closure); - if (closure->count == 0) { - /* See if it's an illegal move due to check */ - illegal = 1; - GenLegal(board, flags|F_IGNORE_CHECK, epfile, DisambiguateCallback, - (VOIDSTAR) closure); - if (closure->count == 0) { - /* No, it's not even that */ - return; - } - } - if (closure->promoCharIn != NULLCHAR && closure->promoCharIn != 'x') { - if (closure->kind == WhitePromotionQueen - || closure->kind == BlackPromotionQueen) { - closure->kind = - PromoCharToMoveType((flags & F_WHITE_ON_MOVE) != 0, - closure->promoCharIn); - } else { - closure->kind = IllegalMove; - } - } - closure->promoChar = ToLower(PieceToChar(PromoPiece(closure->kind))); - if (closure->promoChar == 'x') closure->promoChar = NULLCHAR; - if (closure->count > 1) { - closure->kind = AmbiguousMove; - } - if (illegal) { - /* Note: If more than one illegal move matches, but no legal - moves, we return IllegalMove, not AmbiguousMove. Caller - can look at closure->count to detect this. - */ - closure->kind = IllegalMove; - } -} - - -typedef struct { - /* Input */ - ChessSquare piece; - int rf, ff, rt, ft; - /* Output */ - ChessMove kind; - int rank; - int file; - int either; -} CoordsToAlgebraicClosure; - -extern void CoordsToAlgebraicCallback P((Board board, int flags, - ChessMove kind, int rf, int ff, - int rt, int ft, VOIDSTAR closure)); - -void CoordsToAlgebraicCallback(board, flags, kind, rf, ff, rt, ft, closure) - Board board; - int flags; - ChessMove kind; - int rf, ff, rt, ft; - VOIDSTAR closure; -{ - register CoordsToAlgebraicClosure *cl = - (CoordsToAlgebraicClosure *) closure; - - if (rt == cl->rt && ft == cl->ft && - board[rf][ff] == cl->piece) { - if (rf == cl->rf) { - if (ff == cl->ff) { - cl->kind = kind; /* this is the move we want */ - } else { - cl->file++; /* need file to rule out this move */ - } - } else { - if (ff == cl->ff) { - cl->rank++; /* need rank to rule out this move */ - } else { - cl->either++; /* rank or file will rule out this move */ - } - } - } -} - -/* Convert coordinates to normal algebraic notation. - promoChar must be NULLCHAR or 'x' if not a promotion. -*/ -ChessMove CoordsToAlgebraic(board, flags, epfile, - rf, ff, rt, ft, promoChar, out) - Board board; - int flags, epfile; - int rf, ff, rt, ft; - int promoChar; - char out[MOVE_LEN]; -{ - ChessSquare piece; - ChessMove kind; - char *outp = out; - CoordsToAlgebraicClosure cl; - - if (rf == DROP_RANK) { - /* Bughouse piece drop */ - *outp++ = ToUpper(PieceToChar((ChessSquare) ff)); - *outp++ = '@'; - *outp++ = ft + 'a'; - *outp++ = rt + '1'; - *outp = NULLCHAR; - return (flags & F_WHITE_ON_MOVE) ? WhiteDrop : BlackDrop; - } - - if (promoChar == 'x') promoChar = NULLCHAR; - piece = board[rf][ff]; - switch (piece) { - case WhitePawn: - case BlackPawn: - kind = LegalityTest(board, flags, epfile, rf, ff, rt, ft, promoChar); - if (kind == IllegalMove && !(flags&F_IGNORE_CHECK)) { - /* Keep short notation if move is illegal only because it - leaves the player in check, but still return IllegalMove */ - kind = LegalityTest(board, flags|F_IGNORE_CHECK, epfile, - rf, ff, rt, ft, promoChar); - if (kind == IllegalMove) break; - kind = IllegalMove; - } - /* Pawn move */ - *outp++ = ff + 'a'; - if (ff == ft) { - /* Non-capture; use style "e5" */ - *outp++ = rt + '1'; - } else { - /* Capture; use style "exd5" */ - *outp++ = 'x'; - *outp++ = ft + 'a'; - *outp++ = rt + '1'; - } - /* Use promotion suffix style "=Q" */ - if (promoChar != NULLCHAR && promoChar != 'x') { - *outp++ = '='; - *outp++ = ToUpper(promoChar); - } - *outp = NULLCHAR; - return kind; - - - case WhiteKing: - case BlackKing: - /* Fabien moved code: FRC castling first (if KxR), wild castling second */ - /* Code added by Tord: FRC castling. */ - if((piece == WhiteKing && board[rt][ft] == WhiteRook) || - (piece == BlackKing && board[rt][ft] == BlackRook)) { - if(ft > ff) strcpy(out, "O-O"); else strcpy(out, "O-O-O"); - return LegalityTest(board, flags, epfile, - rf, ff, rt, ft, promoChar); - } - /* End of code added by Tord */ - /* Test for castling or ICS wild castling */ - /* Use style "O-O" (oh-oh) for PGN compatibility */ - else if (rf == rt && - rf == ((piece == WhiteKing) ? 0 : 7) && - ((ff == 4 && (ft == 2 || ft == 6)) || - (ff == 3 && (ft == 1 || ft == 5)))) { - switch (ft) { - case 1: - case 6: - strcpy(out, "O-O"); - break; - case 2: - case 5: - strcpy(out, "O-O-O"); - break; - } - /* This notation is always unambiguous, unless there are - kings on both the d and e files, with "wild castling" - possible for the king on the d file and normal castling - possible for the other. ICS rules for wild 9 - effectively make castling illegal for either king in - this situation. So I am not going to worry about it; - I'll just generate an ambiguous O-O in this case. - */ - return LegalityTest(board, flags, epfile, - rf, ff, rt, ft, promoChar); - } - - /* else fall through */ - - default: - /* Piece move */ - cl.rf = rf; - cl.ff = ff; - cl.rt = rt; - cl.ft = ft; - cl.piece = piece; - cl.kind = IllegalMove; - cl.rank = cl.file = cl.either = 0; - GenLegal(board, flags, epfile, - CoordsToAlgebraicCallback, (VOIDSTAR) &cl); - - 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, epfile, - CoordsToAlgebraicCallback, (VOIDSTAR) &cl); - if (cl.kind == IllegalMove) break; - cl.kind = IllegalMove; - } - - /* Style is "Nf3" or "Nxf7" if this is unambiguous, - else "Ngf3" or "Ngxf7", - else "N1f3" or "N5xf7", - else "Ng1f3" or "Ng5xf7". - */ - *outp++ = ToUpper(PieceToChar(piece)); - - if (cl.file || (cl.either && !cl.rank)) { - *outp++ = ff + 'a'; - } - if (cl.rank) { - *outp++ = rf + '1'; - } - - if(board[rt][ft] != EmptySquare) - *outp++ = 'x'; - - *outp++ = ft + 'a'; - *outp++ = rt + '1'; - *outp = NULLCHAR; - return cl.kind; - - case EmptySquare: - /* Moving a nonexistent piece */ - break; - } - - /* Not a legal move, even ignoring check. - If there was a piece on the from square, - use style "Ng1g3" or "Ng1xe8"; - if there was a pawn or nothing (!), - use style "g1g3" or "g1xe8". Use "x" - if a piece was on the to square, even - a piece of the same color. - */ - outp = out; - if (piece != EmptySquare && piece != WhitePawn && piece != BlackPawn) { - *outp++ = ToUpper(PieceToChar(piece)); - } - *outp++ = ff + 'a'; - *outp++ = rf + '1'; - if (board[rt][ft] != EmptySquare) *outp++ = 'x'; - *outp++ = ft + 'a'; - *outp++ = rt + '1'; - /* Use promotion suffix style "=Q" */ - if (promoChar != NULLCHAR && promoChar != 'x') { - *outp++ = '='; - *outp++ = ToUpper(promoChar); - } - *outp = NULLCHAR; - - return IllegalMove; -} +/* + * moves.c - Move generation and checking + * $Id: moves.c,v 2.1 2003/10/27 19:21:00 mann Exp $ + * + * Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts. + * Enhancements Copyright 1992-95 Free Software Foundation, Inc. + * + * The following terms apply to Digital Equipment Corporation's copyright + * interest in XBoard: + * ------------------------------------------------------------------------ + * All Rights Reserved + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, + * provided that the above copyright notice appear in all copies and that + * both that copyright notice and this permission notice appear in + * supporting documentation, and that the name of Digital not be + * used in advertising or publicity pertaining to distribution of the + * software without specific, written prior permission. + * + * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING + * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL + * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR + * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, + * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS + * SOFTWARE. + * ------------------------------------------------------------------------ + * + * The following terms apply to the enhanced version of XBoard distributed + * by the Free Software Foundation: + * ------------------------------------------------------------------------ + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * ------------------------------------------------------------------------ + */ + +#include "config.h" + +#include +#if HAVE_STRING_H +# include +#else /* not HAVE_STRING_H */ +# include +#endif /* not HAVE_STRING_H */ +#include "common.h" +#include "backend.h" +#include "moves.h" +#include "parser.h" + +int WhitePiece P((ChessSquare)); +int BlackPiece P((ChessSquare)); +int SameColor P((ChessSquare, ChessSquare)); + +extern char initialRights[BOARD_SIZE]; /* [HGM] all rights enabled, set in InitPosition */ + + +int WhitePiece(piece) + ChessSquare piece; +{ + return (int) piece >= (int) WhitePawn && (int) piece < (int) BlackPawn; +} + +int BlackPiece(piece) + ChessSquare piece; +{ + return (int) piece >= (int) BlackPawn && (int) piece < (int) EmptySquare; +} + +int SameColor(piece1, piece2) + ChessSquare piece1, piece2; +{ + return ((int) piece1 >= (int) WhitePawn && /* [HGM] can be > King ! */ + (int) piece1 < (int) BlackPawn && + (int) piece2 >= (int) WhitePawn && + (int) piece2 < (int) BlackPawn) + || ((int) piece1 >= (int) BlackPawn && + (int) piece1 < (int) EmptySquare && + (int) piece2 >= (int) BlackPawn && + (int) piece2 < (int) EmptySquare); +} + +ChessSquare PromoPiece(moveType) + ChessMove moveType; +{ + switch (moveType) { + default: + return EmptySquare; + case WhitePromotionQueen: + return WhiteQueen; + case BlackPromotionQueen: + return BlackQueen; + case WhitePromotionRook: + return WhiteRook; + case BlackPromotionRook: + return BlackRook; + case WhitePromotionBishop: + return WhiteBishop; + case BlackPromotionBishop: + return BlackBishop; + case WhitePromotionKnight: + return WhiteKnight; + case BlackPromotionKnight: + return BlackKnight; + case WhitePromotionKing: + return WhiteKing; + case BlackPromotionKing: + return BlackKing; +#ifdef FAIRY + case WhitePromotionChancellor: + return WhiteFairyRook; + case BlackPromotionChancellor: + return BlackFairyRook; + case WhitePromotionArchbishop: + return WhiteFairyBishop; + case BlackPromotionArchbishop: + return BlackFairyBishop; +#endif + } +} + +ChessMove PromoCharToMoveType(whiteOnMove, promoChar) + int whiteOnMove; + int promoChar; +{ + if (whiteOnMove) { + switch (promoChar) { + case 'n': + case 'N': + return WhitePromotionKnight; + case 'b': + case 'B': + return WhitePromotionBishop; + case 'r': + case 'R': + return WhitePromotionRook; +#ifdef FAIRY + case 'a': + case 'A': + return WhitePromotionArchbishop; + case 'c': + case 'C': + return WhitePromotionChancellor; +#endif + case 'q': + case 'Q': + return WhitePromotionQueen; + case 'k': + case 'K': + return WhitePromotionKing; + case NULLCHAR: + default: + return NormalMove; + } + } else { + switch (promoChar) { + case 'n': + case 'N': + return BlackPromotionKnight; + case 'b': + case 'B': + return BlackPromotionBishop; + case 'r': + case 'R': + return BlackPromotionRook; +#ifdef FAIRY + case 'a': + case 'A': + return BlackPromotionArchbishop; + case 'c': + case 'C': + return BlackPromotionChancellor; +#endif + case 'q': + case 'Q': + return BlackPromotionQueen; + case 'k': + case 'K': + return BlackPromotionKing; + case NULLCHAR: + default: + return NormalMove; + } + } +} + +char pieceToChar[] = { + 'P', 'N', 'B', 'R', +#ifdef FAIRY + 'A', 'C', 'F', 'H', 'E', 'W', 'D', 'O', 'G', 'M', +#endif + 'Q', 'K', 'p', 'n', 'b', 'r', +#ifdef FAIRY + 'a', 'c', 'f', 'h', 'e', 'w', 'd', 'o', 'g', 'm', +#endif + 'q', 'k', 'x' + }; + +char PieceToChar(p) + ChessSquare p; +{ + return pieceToChar[(int) p]; +} + +ChessSquare CharToPiece(c) + int c; +{ switch (c) { + default: + case 'x': return EmptySquare; + case 'P': return WhitePawn; + case 'R': return WhiteRook; + case 'N': return WhiteKnight; + case 'B': return WhiteBishop; + case 'Q': return WhiteQueen; + case 'K': return WhiteKing; + case 'p': return BlackPawn; + case 'r': return BlackRook; + case 'n': return BlackKnight; + case 'b': return BlackBishop; + case 'q': return BlackQueen; + case 'k': return BlackKing; +#ifdef FAIRY + case 'A': return WhiteCardinal; + case 'C': return WhiteMarshall; + case 'F': return WhiteFairyPawn; + case 'H': return WhiteFairyKnight; + case 'E': return WhiteFairyBishop; + case 'W': return WhiteFairyRook; + case 'D': return WhiteFairyCardinal; + case 'O': return WhiteFairyMarshall; + case 'G': return WhiteFairyQueen; + case 'M': return WhiteFairyKing; + + case 'a': return BlackCardinal; + case 'c': return BlackMarshall; + case 'f': return BlackFairyPawn; + case 'h': return BlackFairyKnight; + case 'e': return BlackFairyBishop; + case 'w': return BlackFairyRook; + case 'd': return BlackFairyCardinal; + case 'o': return BlackFairyMarshall; + case 'g': return BlackFairyQueen; + case 'm': return BlackFairyKing; + +#endif + } +} + +void CopyBoard(to, from) + Board to, from; +{ + int i, j; + + for (i = 0; i < BOARD_HEIGHT; i++) + for (j = 0; j < BOARD_WIDTH; j++) + to[i][j] = from[i][j]; +} + +int CompareBoards(board1, board2) + Board board1, board2; +{ + int i, j; + + for (i = 0; i < BOARD_HEIGHT; i++) + for (j = 0; j < BOARD_WIDTH; j++) { + if (board1[i][j] != board2[i][j]) + return FALSE; + } + return TRUE; +} + + +/* Call callback once for each pseudo-legal move in the given + position, except castling moves. A move is pseudo-legal if it is + legal, or if it would be legal except that it leaves the king in + check. In the arguments, epfile is EP_NONE if the previous move + was not a double pawn push, or the file 0..7 if it was, or + EP_UNKNOWN if we don't know and want to allow all e.p. captures. + Promotion moves generated are to Queen only. +*/ +void GenPseudoLegal(board, flags, epfile, callback, closure) + Board board; + int flags; + int epfile; + MoveCallback callback; + VOIDSTAR closure; +{ + int rf, ff; + int i, j, d, s, fs, rs, rt, ft, m; + + for (rf = 0; rf < BOARD_HEIGHT; rf++) + for (ff = 0; ff < BOARD_WIDTH; ff++) { + if (flags & F_WHITE_ON_MOVE) { + if (!WhitePiece(board[rf][ff])) continue; + } else { + if (!BlackPiece(board[rf][ff])) continue; + } + m = 0; + switch (board[rf][ff]) { + case EmptySquare: + default: + /* can't happen ([HGM] except for faries...) */ + break; + + case WhitePawn: +#ifdef FAIRY + if(gameInfo.variant == VariantXiangqi) { + /* [HGM] capture and move straight ahead in Xiangqi */ + if (rf < BOARD_HEIGHT-1 && + !SameColor(board[rf][ff], board[rf + 1][ff]) ) { + callback(board, flags, NormalMove, + rf, ff, rf + 1, ff, closure); + } + /* and move sideways when across the river */ + for (s = -1; s <= 1; s += 2) { + if (rf >= BOARD_HEIGHT>>1 && + ff + s >= 0 && ff + s < BOARD_WIDTH && + !WhitePiece(board[rf][ff+s]) ) { + callback(board, flags, NormalMove, + rf, ff, rf, ff+s, closure); + } + } + break; + } +#endif + if (rf < BOARD_HEIGHT-1 && board[rf + 1][ff] == EmptySquare) { + callback(board, flags, + rf == BOARD_HEIGHT-2 ? WhitePromotionQueen : NormalMove, + rf, ff, rf + 1, ff, closure); + } + if (rf == 1 && board[2][ff] == EmptySquare && + gameInfo.variant != VariantShatranj && /* [HGM] */ + board[3][ff] == EmptySquare ) { + callback(board, flags, NormalMove, + rf, ff, 3, ff, closure); + } + for (s = -1; s <= 1; s += 2) { + if (rf < BOARD_HEIGHT-1 && ff + s >= 0 && ff + s < BOARD_WIDTH && + ((flags & F_KRIEGSPIEL_CAPTURE) || + BlackPiece(board[rf + 1][ff + s]))) { + callback(board, flags, + rf == BOARD_HEIGHT-2 ? WhitePromotionQueen : NormalMove, + rf, ff, rf + 1, ff + s, closure); + } + if (rf == BOARD_HEIGHT-4) { + if (ff + s >= 0 && ff + s < BOARD_WIDTH && + (epfile == ff + s || epfile == EP_UNKNOWN) && + board[BOARD_HEIGHT-4][ff + s] == BlackPawn && + board[BOARD_HEIGHT-3][ff + s] == EmptySquare) { + callback(board, flags, WhiteCapturesEnPassant, + rf, ff, 5, ff + s, closure); + } + } + } + break; + + case BlackPawn: +#ifdef FAIRY + if(gameInfo.variant == VariantXiangqi) { + /* [HGM] capture straight ahead in Xiangqi */ + if (rf > 0 && !SameColor(board[rf][ff], board[rf - 1][ff]) ) { + callback(board, flags, NormalMove, + rf, ff, rf - 1, ff, closure); + } + /* and move sideways when across the river */ + for (s = -1; s <= 1; s += 2) { + if (rf < BOARD_HEIGHT>>1 && + ff + s >= 0 && ff + s < BOARD_WIDTH && + !BlackPiece(board[rf][ff+s]) ) { + callback(board, flags, NormalMove, + rf, ff, rf, ff+s, closure); + } + } + break; + } +#endif + if (rf > 0 && board[rf - 1][ff] == EmptySquare) { + callback(board, flags, + rf == 1 ? BlackPromotionQueen : NormalMove, + rf, ff, rf - 1, ff, closure); + } + if (rf == BOARD_HEIGHT-2 && board[BOARD_HEIGHT-3][ff] == EmptySquare && + gameInfo.variant != VariantShatranj && /* [HGM] */ + board[BOARD_HEIGHT-4][ff] == EmptySquare) { + callback(board, flags, NormalMove, + rf, ff, BOARD_HEIGHT-4, ff, closure); + } + for (s = -1; s <= 1; s += 2) { + if (rf > 0 && ff + s >= 0 && ff + s < BOARD_WIDTH && + ((flags & F_KRIEGSPIEL_CAPTURE) || + WhitePiece(board[rf - 1][ff + s]))) { + callback(board, flags, + rf == 1 ? BlackPromotionQueen : NormalMove, + rf, ff, rf - 1, ff + s, closure); + } + if (rf == 3) { + if (ff + s >= 0 && ff + s < BOARD_WIDTH && + (epfile == ff + s || epfile == EP_UNKNOWN) && + board[3][ff + s] == WhitePawn && + board[2][ff + s] == EmptySquare) { + callback(board, flags, BlackCapturesEnPassant, + rf, ff, 2, ff + s, closure); + } + } + } + break; + + case WhiteKnight: + case BlackKnight: + mounted: + for (i = -1; i <= 1; i += 2) + for (j = -1; j <= 1; j += 2) + for (s = 1; s <= 2; s++) { + rt = rf + i*s; + ft = ff + j*(3-s); + if (rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) continue; + if (SameColor(board[rf][ff], board[rt][ft])) continue; + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + } + break; +#ifdef FAIRY + case WhiteFairyMarshall: + case BlackFairyMarshall: + for (d = 0; d <= 1; d++) + for (s = -1; s <= 1; s += 2) { + m = 0; + for (i = 1;; i++) { + rt = rf + (i * s) * d; + ft = ff + (i * s) * (1 - d); + if (rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) break; + if (m == 0 && board[rt][ft] == EmptySquare) + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + if (m == 1 && board[rt][ft] != EmptySquare && + !SameColor(board[rf][ff], board[rt][ft]) ) + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + if (board[rt][ft] != EmptySquare && m++) break; + } + } + break; + + case WhiteFairyRook: + case BlackFairyRook: + for (d = 0; d <= 1; d++) + for (s = -1; s <= 1; s += 2) + rt = rf + s * d; + ft = ff + s * (1 - d); + if (!(rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) + && !SameColor(board[rf][ff], board[rt][ft])) + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + break; + + case WhiteFairyBishop: + case BlackFairyBishop: + /* [HGM] support Shatranj pieces */ + for (rs = -1; rs <= 1; rs += 2) + for (fs = -1; fs <= 1; fs += 2) { + rt = rf + 2 * rs; + ft = ff + 2 * fs; + if (!(rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) + && !SameColor(board[rf][ff], board[rt][ft])) + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + } + break; + + case WhiteCardinal: + case BlackCardinal: + m++; +#endif + case WhiteBishop: + case BlackBishop: + for (rs = -1; rs <= 1; rs += 2) + for (fs = -1; fs <= 1; fs += 2) + for (i = 1;; i++) { + rt = rf + (i * rs); + ft = ff + (i * fs); + if (rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) break; + if (SameColor(board[rf][ff], board[rt][ft])) break; + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + if (board[rt][ft] != EmptySquare) break; + } + if(m) goto mounted; + break; + +#ifdef FAIRY + case WhiteMarshall: + case BlackMarshall: + m++; +#endif + case WhiteRook: + case BlackRook: + for (d = 0; d <= 1; d++) + for (s = -1; s <= 1; s += 2) + for (i = 1;; i++) { + rt = rf + (i * s) * d; + ft = ff + (i * s) * (1 - d); + if (rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) break; + if (SameColor(board[rf][ff], board[rt][ft])) break; + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + if (board[rt][ft] != EmptySquare) break; + } + if(m) goto mounted; + break; + + case WhiteQueen: + case BlackQueen: + for (rs = -1; rs <= 1; rs++) + for (fs = -1; fs <= 1; fs++) { + if (rs == 0 && fs == 0) continue; + for (i = 1;; i++) { + rt = rf + (i * rs); + ft = ff + (i * fs); + if (rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) break; + if (SameColor(board[rf][ff], board[rt][ft])) break; + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + if (board[rt][ft] != EmptySquare) break; + } + } + break; + +#ifdef FAIRY + case WhiteFairyPawn: + case BlackFairyPawn: + /* [HGM] support Shatranj pieces */ + for (rs = -1; rs <= 1; rs += 2) + for (fs = -1; fs <= 1; fs += 2) { + rt = rf + rs; + ft = ff + fs; + if (rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) break; + if (!SameColor(board[rf][ff], board[rt][ft])) + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + } + break; + + case WhiteFairyKing: + case BlackFairyKing: +#endif + case WhiteKing: + case BlackKing: + for (i = -1; i <= 1; i++) + for (j = -1; j <= 1; j++) { + if (i == 0 && j == 0) continue; + rt = rf + i; + ft = ff + j; + if (rt < 0 || rt >= BOARD_HEIGHT || ft < 0 || ft >= BOARD_WIDTH) continue; + if (SameColor(board[rf][ff], board[rt][ft])) continue; + callback(board, flags, NormalMove, + rf, ff, rt, ft, closure); + } + break; + } + } +} + + +typedef struct { + MoveCallback cb; + VOIDSTAR cl; +} GenLegalClosure; + +extern void GenLegalCallback P((Board board, int flags, ChessMove kind, + int rf, int ff, int rt, int ft, + VOIDSTAR closure)); + +void GenLegalCallback(board, flags, kind, rf, ff, rt, ft, closure) + Board board; + int flags; + ChessMove kind; + int rf, ff, rt, ft; + VOIDSTAR closure; +{ + register GenLegalClosure *cl = (GenLegalClosure *) closure; + + if (!(flags & F_IGNORE_CHECK) && + CheckTest(board, flags, rf, ff, rt, ft, + kind == WhiteCapturesEnPassant || + kind == BlackCapturesEnPassant)) return; + if (flags & F_ATOMIC_CAPTURE) { + if (board[rt][ft] != EmptySquare || + kind == WhiteCapturesEnPassant || kind == BlackCapturesEnPassant) { + int r, f; + ChessSquare king = (flags & F_WHITE_ON_MOVE) ? WhiteKing : BlackKing; + if (board[rf][ff] == king) return; + for (r = rt-1; r <= rt+1; r++) { + for (f = ft-1; f <= ft+1; f++) { + if (r >= 0 && r < BOARD_HEIGHT && f >= 0 && f < BOARD_WIDTH && + board[r][f] == king) return; + } + } + } + } + cl->cb(board, flags, kind, rf, ff, rt, ft, cl->cl); +} + + +typedef struct { + int rf, ff, rt, ft; + ChessMove kind; +} LegalityTestClosure; + + +/* Like GenPseudoLegal, but (1) include castling moves, (2) unless + F_IGNORE_CHECK is set in the flags, omit moves that would leave the + king in check, and (3) if F_ATOMIC_CAPTURE is set in the flags, omit + moves that would destroy your own king. The CASTLE_OK flags are + true if castling is not yet ruled out by a move of the king or + rook. Return TRUE if the player on move is currently in check and + F_IGNORE_CHECK is not set. [HGM] add castlingRights parameter */ +int GenLegal(board, flags, epfile, castlingRights, callback, closure) + Board board; + int flags; + int epfile; + char castlingRights[]; + MoveCallback callback; + VOIDSTAR closure; +{ + GenLegalClosure cl; + int ff, ft; + int ignoreCheck = (flags & F_IGNORE_CHECK) != 0; + + cl.cb = callback; + cl.cl = closure; + GenPseudoLegal(board, flags, epfile, GenLegalCallback, (VOIDSTAR) &cl); + + if (!ignoreCheck && + CheckTest(board, flags, -1, -1, -1, -1, FALSE)) return TRUE; + + /* Generate castling moves */ + 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) && + board[0][ff] == WhiteKing && + board[0][ff + 1] == EmptySquare && + board[0][ff + 2] == EmptySquare && + board[0][BOARD_WIDTH-3] == EmptySquare && + board[0][BOARD_WIDTH-2] == EmptySquare && + board[0][BOARD_WIDTH-1] == WhiteRook && + castlingRights[0] >= 0 && /* [HGM] check rights */ + ( castlingRights[2] == ff || castlingRights[6] == ff ) && + (ignoreCheck || + (!CheckTest(board, flags, 0, ff, 0, ff + 1, FALSE) && + !CheckTest(board, flags, 0, ff, 0, BOARD_WIDTH-3, FALSE) && + !CheckTest(board, flags, 0, ff, 0, ff + 2, FALSE)))) { + + callback(board, flags, + ff==4 ? WhiteKingSideCastle : WhiteKingSideCastleWild, + 0, ff, 0, ff + ((BOARD_WIDTH+2)>>2), closure); + } + if ((flags & F_WHITE_ON_MOVE) && + (flags & F_WHITE_QCASTLE_OK) && + board[0][ff] == WhiteKing && + board[0][ff - 1] == EmptySquare && + board[0][ff - 2] == EmptySquare && + board[0][2] == EmptySquare && + board[0][1] == EmptySquare && + board[0][0] == WhiteRook && + castlingRights[1] >= 0 && /* [HGM] check rights */ + ( castlingRights[2] == ff || castlingRights[6] == ff ) && + (ignoreCheck || + (!CheckTest(board, flags, 0, ff, 0, ff - 1, FALSE) && + !CheckTest(board, flags, 0, ff, 0, 3, FALSE) && + !CheckTest(board, flags, 0, ff, 0, ff - 2, FALSE)))) { + + callback(board, flags, + ff==BOARD_WIDTH>>1 ? WhiteQueenSideCastle : WhiteQueenSideCastleWild, + 0, ff, 0, ff - ((BOARD_WIDTH+2)>>2), closure); + } + if (!(flags & F_WHITE_ON_MOVE) && + (flags & F_BLACK_KCASTLE_OK) && + board[BOARD_HEIGHT-1][ff] == BlackKing && + board[BOARD_HEIGHT-1][ff + 1] == EmptySquare && + board[BOARD_HEIGHT-1][ff + 2] == EmptySquare && + board[BOARD_HEIGHT-1][BOARD_WIDTH-3] == EmptySquare && + board[BOARD_HEIGHT-1][BOARD_WIDTH-2] == EmptySquare && + board[BOARD_HEIGHT-1][BOARD_WIDTH-1] == BlackRook && + castlingRights[3] >= 0 && /* [HGM] check rights */ + ( castlingRights[5] == ff || castlingRights[7] == ff ) && + (ignoreCheck || + (!CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff + 1, FALSE) && + !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, BOARD_WIDTH-3, FALSE) && + !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff + 2, FALSE)))) { + + callback(board, flags, + ff==BOARD_WIDTH>>1 ? BlackKingSideCastle : BlackKingSideCastleWild, + BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff + ((BOARD_WIDTH+2)>>2), closure); + } + if (!(flags & F_WHITE_ON_MOVE) && + (flags & F_BLACK_QCASTLE_OK) && + board[BOARD_HEIGHT-1][ff] == BlackKing && + board[BOARD_HEIGHT-1][ff - 1] == EmptySquare && + board[BOARD_HEIGHT-1][ff - 2] == EmptySquare && + board[BOARD_HEIGHT-1][2] == EmptySquare && + board[BOARD_HEIGHT-1][1] == EmptySquare && + board[BOARD_HEIGHT-1][0] == BlackRook && + castlingRights[4] >= 0 && /* [HGM] check rights */ + ( castlingRights[5] == ff || castlingRights[7] == ff ) && + (ignoreCheck || + (!CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff - 1, FALSE) && + !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, 3, FALSE) && + !CheckTest(board, flags, BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff - 1, FALSE)))) { + + callback(board, flags, + ff==BOARD_WIDTH>>1 ? BlackQueenSideCastle : BlackQueenSideCastleWild, + BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ff - ((BOARD_WIDTH+2)>>2), closure); + } + } + + /* PUSH Fabien */ + + /* generate all potential FRC castling moves (KxR), ignoring flags */ + /* [HGM] Tord! Help requested! */ + + if ((flags & F_WHITE_ON_MOVE) != 0) { + + for (ff = 1; ff < BOARD_WIDTH-1; ff++) { + if (board[0][ff] == WhiteKing) { + for (ft = 0; ft < BOARD_WIDTH; ft++) { + if (board[0][ft] == WhiteRook) { + callback(board, flags, + (ft > ff) ? WhiteHSideCastleFR : WhiteASideCastleFR, + 0, ff, 0, ft, closure); + } + } + } + } + + } else { + + for (ff = 1; ff < BOARD_WIDTH-1; ff++) { + if (board[BOARD_HEIGHT-1][ff] == BlackKing) { + for (ft = 0; ft < BOARD_WIDTH; ft++) { + if (board[BOARD_HEIGHT-1][ft] == BlackRook) { + callback(board, flags, + (ft > ff) ? BlackHSideCastleFR : BlackASideCastleFR, + BOARD_HEIGHT-1, ff, BOARD_HEIGHT-1, ft, closure); + } + } + } + } + } + + /* POP Fabien */ + + return FALSE; +} + + +typedef struct { + int rking, fking; + int check; +} CheckTestClosure; + + +extern void CheckTestCallback P((Board board, int flags, ChessMove kind, + int rf, int ff, int rt, int ft, + VOIDSTAR closure)); + + +void CheckTestCallback(board, flags, kind, rf, ff, rt, ft, closure) + Board board; + int flags; + ChessMove kind; + int rf, ff, rt, ft; + VOIDSTAR closure; +{ + register CheckTestClosure *cl = (CheckTestClosure *) closure; + + if (rt == cl->rking && ft == cl->fking) cl->check++; +} + + +/* If the player on move were to move from (rf, ff) to (rt, ft), would + he leave himself in check? Or if rf == -1, is the player on move + in check now? enPassant must be TRUE if the indicated move is an + e.p. capture. The possibility of castling out of a check along the + back rank is not accounted for (i.e., we still return nonzero), as + this is illegal anyway. Return value is the number of times the + king is in check. */ +int CheckTest(board, flags, rf, ff, rt, ft, enPassant) + Board board; + int flags; + int rf, ff, rt, ft, enPassant; +{ + CheckTestClosure cl; + ChessSquare king = flags & F_WHITE_ON_MOVE ? WhiteKing : BlackKing; + ChessSquare captured = EmptySquare; + /* Suppress warnings on uninitialized variables */ + + if (rf >= 0) { + if (enPassant) { + captured = board[rf][ft]; + board[rf][ft] = EmptySquare; + } else { + captured = board[rt][ft]; + } + board[rt][ft] = board[rf][ff]; + board[rf][ff] = EmptySquare; + } + + /* For compatibility with ICS wild 9, we scan the board in the + order a1, a2, a3, ... b1, b2, ..., h8 to find the first king, + and we test only whether that one is in check. */ + cl.check = 0; + for (cl.fking = 0; cl.fking < BOARD_WIDTH; cl.fking++) + for (cl.rking = 0; cl.rking < BOARD_HEIGHT; cl.rking++) { + if (board[cl.rking][cl.fking] == king) { + GenPseudoLegal(board, flags ^ F_WHITE_ON_MOVE, -1, + CheckTestCallback, (VOIDSTAR) &cl); + goto undo_move; /* 2-level break */ + } + } + + undo_move: + + if (rf >= 0) { + board[rf][ff] = board[rt][ft]; + if (enPassant) { + board[rf][ft] = captured; + board[rt][ft] = EmptySquare; + } else { + board[rt][ft] = captured; + } + } + + return cl.check; +} + + +extern void LegalityTestCallback P((Board board, int flags, ChessMove kind, + int rf, int ff, int rt, int ft, + VOIDSTAR closure)); + +void LegalityTestCallback(board, flags, kind, rf, ff, rt, ft, closure) + Board board; + int flags; + ChessMove kind; + int rf, ff, rt, ft; + VOIDSTAR closure; +{ + register LegalityTestClosure *cl = (LegalityTestClosure *) closure; + + if (rf == cl->rf && ff == cl->ff && rt == cl->rt && ft == cl->ft) + cl->kind = kind; +} + +ChessMove LegalityTest(board, flags, epfile, castlingRights, rf, ff, rt, ft, promoChar) + Board board; + int flags, epfile; + int rf, ff, rt, ft, promoChar; + char castlingRights[]; +{ + LegalityTestClosure cl; + + cl.rf = rf; + cl.ff = ff; + cl.rt = rt; + cl.ft = ft; + cl.kind = IllegalMove; + GenLegal(board, flags, epfile, castlingRights, LegalityTestCallback, (VOIDSTAR) &cl); + if (promoChar != NULLCHAR && promoChar != 'x') { + if (cl.kind == WhitePromotionQueen || cl.kind == BlackPromotionQueen) { + cl.kind = + PromoCharToMoveType((flags & F_WHITE_ON_MOVE) != 0, promoChar); + } else { + cl.kind = IllegalMove; + } + } + return cl.kind; +} + +typedef struct { + int count; +} MateTestClosure; + +extern void MateTestCallback P((Board board, int flags, ChessMove kind, + int rf, int ff, int rt, int ft, + VOIDSTAR closure)); + +void MateTestCallback(board, flags, kind, rf, ff, rt, ft, closure) + Board board; + int flags; + ChessMove kind; + int rf, ff, rt, ft; + VOIDSTAR closure; +{ + register MateTestClosure *cl = (MateTestClosure *) closure; + + cl->count++; +} + +/* Return MT_NONE, MT_CHECK, MT_CHECKMATE, or MT_STALEMATE */ +int MateTest(board, flags, epfile, castlingRights) + Board board; + int flags, epfile; + char castlingRights[]; +{ + MateTestClosure cl; + int inCheck; + + cl.count = 0; + inCheck = GenLegal(board, flags, epfile, castlingRights, MateTestCallback, (VOIDSTAR) &cl); + if (cl.count > 0) { + return inCheck ? MT_CHECK : MT_NONE; + } else { + return inCheck ? MT_CHECKMATE : MT_STALEMATE; + } +} + + +extern void DisambiguateCallback P((Board board, int flags, ChessMove kind, + int rf, int ff, int rt, int ft, + VOIDSTAR closure)); + +void DisambiguateCallback(board, flags, kind, rf, ff, rt, ft, closure) + Board board; + int flags; + ChessMove kind; + int rf, ff, rt, ft; + VOIDSTAR closure; +{ + register DisambiguateClosure *cl = (DisambiguateClosure *) closure; + + if ((cl->pieceIn == EmptySquare || cl->pieceIn == board[rf][ff]) && + (cl->rfIn == -1 || cl->rfIn == rf) && + (cl->ffIn == -1 || cl->ffIn == ff) && + (cl->rtIn == -1 || cl->rtIn == rt) && + (cl->ftIn == -1 || cl->ftIn == ft)) { + + cl->count++; + cl->piece = board[rf][ff]; + cl->rf = rf; + cl->ff = ff; + cl->rt = rt; + cl->ft = ft; + cl->kind = kind; + } +} + +void Disambiguate(board, flags, epfile, closure) + Board board; + int flags, epfile; + DisambiguateClosure *closure; +{ + int illegal = 0; + closure->count = 0; + closure->rf = closure->ff = closure->rt = closure->ft = 0; + closure->kind = ImpossibleMove; + GenLegal(board, flags, epfile, initialRights, DisambiguateCallback, (VOIDSTAR) closure); + if (closure->count == 0) { + /* See if it's an illegal move due to check */ + illegal = 1; + GenLegal(board, flags|F_IGNORE_CHECK, epfile, initialRights, DisambiguateCallback, + (VOIDSTAR) closure); + if (closure->count == 0) { + /* No, it's not even that */ + return; + } + } + if (closure->promoCharIn != NULLCHAR && closure->promoCharIn != 'x') { + if (closure->kind == WhitePromotionQueen + || closure->kind == BlackPromotionQueen) { + closure->kind = + PromoCharToMoveType((flags & F_WHITE_ON_MOVE) != 0, + closure->promoCharIn); + } else { + closure->kind = IllegalMove; + } + } + closure->promoChar = ToLower(PieceToChar(PromoPiece(closure->kind))); + if (closure->promoChar == 'x') closure->promoChar = NULLCHAR; + if (closure->count > 1) { + closure->kind = AmbiguousMove; + } + if (illegal) { + /* Note: If more than one illegal move matches, but no legal + moves, we return IllegalMove, not AmbiguousMove. Caller + can look at closure->count to detect this. + */ + closure->kind = IllegalMove; + } +} + + +typedef struct { + /* Input */ + ChessSquare piece; + int rf, ff, rt, ft; + /* Output */ + ChessMove kind; + int rank; + int file; + int either; +} CoordsToAlgebraicClosure; + +extern void CoordsToAlgebraicCallback P((Board board, int flags, + ChessMove kind, int rf, int ff, + int rt, int ft, VOIDSTAR closure)); + +void CoordsToAlgebraicCallback(board, flags, kind, rf, ff, rt, ft, closure) + Board board; + int flags; + ChessMove kind; + int rf, ff, rt, ft; + VOIDSTAR closure; +{ + register CoordsToAlgebraicClosure *cl = + (CoordsToAlgebraicClosure *) closure; + + if (rt == cl->rt && ft == cl->ft && + board[rf][ff] == cl->piece) { + if (rf == cl->rf) { + if (ff == cl->ff) { + cl->kind = kind; /* this is the move we want */ + } else { + cl->file++; /* need file to rule out this move */ + } + } else { + if (ff == cl->ff) { + cl->rank++; /* need rank to rule out this move */ + } else { + cl->either++; /* rank or file will rule out this move */ + } + } + } +} + +/* Convert coordinates to normal algebraic notation. + promoChar must be NULLCHAR or 'x' if not a promotion. +*/ +ChessMove CoordsToAlgebraic(board, flags, epfile, + rf, ff, rt, ft, promoChar, out) + Board board; + int flags, epfile; + int rf, ff, rt, ft; + int promoChar; + char out[MOVE_LEN]; +{ + ChessSquare piece; + ChessMove kind; + char *outp = out; + CoordsToAlgebraicClosure cl; + + if (rf == DROP_RANK) { + /* Bughouse piece drop */ + *outp++ = ToUpper(PieceToChar((ChessSquare) ff)); + *outp++ = '@'; + *outp++ = ft + 'a'; + if(rt+ONE <= '9') + *outp++ = rt + ONE; + else { *outp++ = (rt+ONE-'0')/10 + '0';*outp++ = (rt+ONE-'0')%10 + '0'; } + *outp = NULLCHAR; + return (flags & F_WHITE_ON_MOVE) ? WhiteDrop : BlackDrop; + } + + if (promoChar == 'x') promoChar = NULLCHAR; + piece = board[rf][ff]; + switch (piece) { + case WhitePawn: + case BlackPawn: + kind = LegalityTest(board, flags, epfile, initialRights, rf, ff, rt, ft, promoChar); + if (kind == IllegalMove && !(flags&F_IGNORE_CHECK)) { + /* Keep short notation if move is illegal only because it + leaves the player in check, but still return IllegalMove */ + kind = LegalityTest(board, flags|F_IGNORE_CHECK, epfile, initialRights, + rf, ff, rt, ft, promoChar); + if (kind == IllegalMove) break; + kind = IllegalMove; + } + /* Pawn move */ + *outp++ = ff + 'a'; + if (ff == ft && board[rt][ft] == EmptySquare) { /* [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 ) + *outp++ = 'x'; /* [HGM] Xiangqi has sideway noncaptures across river! */ + *outp++ = ft + 'a'; + if(rt+ONE <= '9') + *outp++ = rt + ONE; + else { *outp++ = (rt+ONE-'0')/10 + '0';*outp++ = (rt+ONE-'0')%10 + '0'; } + } + /* Use promotion suffix style "=Q" */ + if (promoChar != NULLCHAR && promoChar != 'x') { + *outp++ = '='; + *outp++ = ToUpper(promoChar); + } + *outp = NULLCHAR; + return kind; + + + case WhiteKing: + case BlackKing: + /* Fabien moved code: FRC castling first (if KxR), wild castling second */ + /* Code added by Tord: FRC castling. */ + if((piece == WhiteKing && board[rt][ft] == WhiteRook) || + (piece == BlackKing && board[rt][ft] == BlackRook)) { + if(ft > ff) strcpy(out, "O-O"); else strcpy(out, "O-O-O"); + return LegalityTest(board, flags, epfile, initialRights, + rf, ff, rt, ft, promoChar); + } + /* End of code added by Tord */ + /* Test for castling or ICS wild castling */ + /* Use style "O-O" (oh-oh) for PGN compatibility */ + else if (rf == rt && + rf == ((piece == WhiteKing) ? 0 : BOARD_HEIGHT-1) && + ((ff == BOARD_WIDTH>>1 && (ft == 2 || ft == BOARD_WIDTH-2)) || + (ff == (BOARD_WIDTH-1)>>1 && (ft == 1 || ft == BOARD_WIDTH-3)))) { + if(ft==1 || ft==BOARD_WIDTH-2) + strcpy(out, "O-O"); + else + strcpy(out, "O-O-O"); + + /* This notation is always unambiguous, unless there are + kings on both the d and e files, with "wild castling" + possible for the king on the d file and normal castling + possible for the other. ICS rules for wild 9 + effectively make castling illegal for either king in + this situation. So I am not going to worry about it; + I'll just generate an ambiguous O-O in this case. + */ + return LegalityTest(board, flags, epfile, initialRights, + rf, ff, rt, ft, promoChar); + } + + /* else fall through */ + default: + /* Piece move */ + cl.rf = rf; + cl.ff = ff; + cl.rt = rt; + cl.ft = ft; + cl.piece = piece; + cl.kind = IllegalMove; + cl.rank = cl.file = cl.either = 0; + GenLegal(board, flags, epfile, initialRights, + CoordsToAlgebraicCallback, (VOIDSTAR) &cl); + + 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, epfile, initialRights, + CoordsToAlgebraicCallback, (VOIDSTAR) &cl); + if (cl.kind == IllegalMove) break; + cl.kind = IllegalMove; + } + + /* Style is "Nf3" or "Nxf7" if this is unambiguous, + else "Ngf3" or "Ngxf7", + else "N1f3" or "N5xf7", + else "Ng1f3" or "Ng5xf7". + */ + *outp++ = ToUpper(PieceToChar(piece)); + + if (cl.file || (cl.either && !cl.rank)) { + *outp++ = ff + 'a'; + } + if (cl.rank) { + if(rf+ONE <= '9') + *outp++ = rf + ONE; + else { *outp++ = (rf+ONE-'0')/10 + '0';*outp++ = (rf+ONE-'0')%10 + '0'; } + } + + if(board[rt][ft] != EmptySquare) + *outp++ = 'x'; + + *outp++ = ft + 'a'; + if(rt+ONE <= '9') + *outp++ = rt + ONE; + else { *outp++ = (rt+ONE-'0')/10 + '0';*outp++ = (rt+ONE-'0')%10 + '0'; } + *outp = NULLCHAR; + return cl.kind; + +#ifdef FAIRY + /* [HGM] Always long notation for fairies, don't know how they move */ + case WhiteFairyRook: + case BlackFairyRook: + case WhiteFairyKnight: + case BlackFairyKnight: + case WhiteFairyQueen: + case BlackFairyQueen: +#endif + case EmptySquare: + /* Moving a nonexistent piece */ + break; + } + + /* Not a legal move, even ignoring check. + If there was a piece on the from square, + use style "Ng1g3" or "Ng1xe8"; + if there was a pawn or nothing (!), + use style "g1g3" or "g1xe8". Use "x" + if a piece was on the to square, even + a piece of the same color. + */ + outp = out; + if (piece != EmptySquare && piece != WhitePawn && piece != BlackPawn) { + *outp++ = ToUpper(PieceToChar(piece)); + } + *outp++ = ff + 'a'; + if(rf+ONE <= '9') + *outp++ = rf + ONE; + else { *outp++ = (rf+ONE-'0')/10 + '0';*outp++ = (rf+ONE-'0')%10 + '0'; } + if (board[rt][ft] != EmptySquare) *outp++ = 'x'; + *outp++ = ft + 'a'; + if(rt+ONE <= '9') + *outp++ = rt + ONE; + else { *outp++ = (rt+ONE-'0')/10 + '0';*outp++ = (rt+ONE-'0')%10 + '0'; } + /* Use promotion suffix style "=Q" */ + if (promoChar != NULLCHAR && promoChar != 'x') { + *outp++ = '='; + *outp++ = ToUpper(promoChar); + } + *outp = NULLCHAR; + + return IllegalMove; +} + +