+++ /dev/null
-/*
- * moves.c - Move generation and checking
- * $Id$
- *
- * 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 <stdio.h>
-#if HAVE_STRING_H
-# include <string.h>
-#else /* not HAVE_STRING_H */
-# include <strings.h>
-#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);
-}
-
-
-/* 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;
- 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);
- }
- }
-
- 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;
-}
-
-
-typedef struct {
- int rf, ff, rt, ft;
- ChessMove kind;
-} LegalityTestClosure;
-
-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:
- /* Test for castling or ICS wild castling */
- /* Use style "O-O" (oh-oh) for PGN compatibility */
- 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;
-}
projects / xboard.git / blobdiff