X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmove.cpp;h=41d1603771a7b4d7d29daa019c23667deff99272;hp=2a74aef1ad2378bad5ab1889de2f8c441f7abef2;hb=9c7e2c8f9d3eba45c20529ad0624e6de10fc7b83;hpb=c2c185423b13b0227c86009c6006e48e8d258896 diff --git a/src/move.cpp b/src/move.cpp index 2a74aef1..41d16037 100644 --- a/src/move.cpp +++ b/src/move.cpp @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -18,24 +18,22 @@ */ #include -#include #include -#include "move.h" #include "movegen.h" #include "position.h" using std::string; /// move_to_uci() converts a move to a string in coordinate notation -/// (g1f3, a7a8q, etc.). The only special case is castling moves, where we -/// print in the e1g1 notation in normal chess mode, and in e1h1 notation in -/// Chess960 mode. Instead internally Move is coded as "king captures rook". +/// (g1f3, a7a8q, etc.). The only special case is castling moves, where we print +/// in the e1g1 notation in normal chess mode, and in e1h1 notation in chess960 +/// mode. Internally castle moves are always coded as "king captures rook". const string move_to_uci(Move m, bool chess960) { - Square from = move_from(m); - Square to = move_to(m); + Square from = from_sq(m); + Square to = to_sq(m); string promotion; if (m == MOVE_NONE) @@ -44,21 +42,23 @@ const string move_to_uci(Move m, bool chess960) { if (m == MOVE_NULL) return "0000"; - if (move_is_castle(m) && !chess960) - to = from + (file_of(to) == FILE_H ? Square(2) : -Square(2)); + if (is_castle(m) && !chess960) + to = make_square(to > from ? FILE_G : FILE_C, rank_of(from)); - if (move_is_promotion(m)) - promotion = char(tolower(piece_type_to_char(promotion_piece_type(m)))); + if (is_promotion(m)) + promotion = char(tolower(piece_type_to_char(promotion_type(m)))); return square_to_string(from) + square_to_string(to) + promotion; } /// move_from_uci() takes a position and a string representing a move in -/// simple coordinate notation and returns an equivalent Move if any. -/// Moves are guaranteed to be legal. +/// simple coordinate notation and returns an equivalent legal Move if any. -Move move_from_uci(const Position& pos, const string& str) { +Move move_from_uci(const Position& pos, string& str) { + + if (str.length() == 5) // Junior could send promotion piece in uppercase + str[4] = char(tolower(str[4])); for (MoveList ml(pos); !ml.end(); ++ml) if (str == move_to_uci(ml.move(), pos.is_chess960())) @@ -68,9 +68,8 @@ Move move_from_uci(const Position& pos, const string& str) { } -/// move_to_san() takes a position and a move as input, where it is assumed -/// that the move is a legal move for the position. The return value is -/// a string containing the move in short algebraic notation. +/// move_to_san() takes a position and a legal Move as input and returns its +/// short algebraic notation representation. const string move_to_san(Position& pos, Move m) { @@ -80,17 +79,17 @@ const string move_to_san(Position& pos, Move m) { if (m == MOVE_NULL) return "(null)"; - assert(move_is_ok(m)); + assert(pos.move_is_legal(m)); Bitboard attackers; bool ambiguousMove, ambiguousFile, ambiguousRank; - Square sq, from = move_from(m); - Square to = move_to(m); - PieceType pt = type_of(pos.piece_on(from)); string san; + Square from = from_sq(m); + Square to = to_sq(m); + PieceType pt = type_of(pos.piece_on(from)); - if (move_is_castle(m)) - san = (move_to(m) < move_from(m) ? "O-O-O" : "O-O"); + if (is_castle(m)) + san = to_sq(m) < from_sq(m) ? "O-O-O" : "O-O"; else { if (pt != PAWN) @@ -99,20 +98,20 @@ const string move_to_san(Position& pos, Move m) { // Disambiguation if we have more then one piece with destination 'to' // note that for pawns is not needed because starting file is explicit. - attackers = pos.attackers_to(to) & pos.pieces(pt, pos.side_to_move()); - clear_bit(&attackers, from); + attackers = pos.attackers_to(to) & pos.pieces(pos.side_to_move(), pt); + attackers ^= from; ambiguousMove = ambiguousFile = ambiguousRank = false; while (attackers) { - sq = pop_1st_bit(&attackers); + Square sq = pop_1st_bit(&attackers); - if (file_of(sq) == file_of(from)) - ambiguousFile = true; - - if (rank_of(sq) == rank_of(from)) - ambiguousRank = true; + // Pinned pieces are not included in the possible sub-set + if (!pos.pl_move_is_legal(make_move(sq, to), pos.pinned_pieces())) + continue; + ambiguousFile |= file_of(sq) == file_of(from); + ambiguousRank |= rank_of(sq) == rank_of(from); ambiguousMove = true; } @@ -120,14 +119,16 @@ const string move_to_san(Position& pos, Move m) { { if (!ambiguousFile) san += file_to_char(file_of(from)); + else if (!ambiguousRank) san += rank_to_char(rank_of(from)); + else san += square_to_string(from); } } - if (pos.move_is_capture(m)) + if (pos.is_capture(m)) { if (pt == PAWN) san += file_to_char(file_of(from)); @@ -137,20 +138,17 @@ const string move_to_san(Position& pos, Move m) { san += square_to_string(to); - if (move_is_promotion(m)) - { - san += '='; - san += piece_type_to_char(promotion_piece_type(m)); - } + if (is_promotion(m)) + san += string("=") + piece_type_to_char(promotion_type(m)); } - // The move gives check? We don't use pos.move_gives_check() here - // because we need to test for a mate after the move is done. - StateInfo st; - pos.do_move(m, st); - if (pos.in_check()) - san += pos.is_mate() ? "#" : "+"; - pos.undo_move(m); + if (pos.move_gives_check(m, CheckInfo(pos))) + { + StateInfo st; + pos.do_move(m, st); + san += MoveList(pos).size() ? "+" : "#"; + pos.undo_move(m); + } return san; }