X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmove.cpp;h=12d6127a2fc4111872a051f8889f89498ff3551e;hp=5ef64fe4b5c0f8c14864887f976b386294dc4a0d;hb=9069193125b753fe8d4c77ca690b5d1b907d848c;hpb=00d9fe8af09891e82d66f88c48b513d6a7326f2a diff --git a/src/move.cpp b/src/move.cpp index 5ef64fe4..12d6127a 100644 --- a/src/move.cpp +++ b/src/move.cpp @@ -23,130 +23,284 @@ //// #include -#include +#include +#include +#include +#include #include "move.h" -#include "piece.h" -#include "position.h" +#include "movegen.h" +#include "search.h" + +using std::string; + +//// +//// Local definitions +//// + +namespace { + + enum Ambiguity { + AMBIGUITY_NONE, AMBIGUITY_FILE, AMBIGUITY_RANK, AMBIGUITY_BOTH + }; + + Ambiguity move_ambiguity(const Position& pos, Move m); + const string time_string(int milliseconds); + const string score_string(Value v); +} //// //// Functions //// -/// move_from_string() takes a position and a string as input, and attempts to -/// convert the string to a move, using simple coordinate notation (g1f3, -/// a7a8q, etc.). In order to correctly parse en passant captures and castling -/// moves, we need the position. This function is not robust, and expects that -/// the input move is legal and correctly formatted. +/// 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. -Move move_from_string(const Position& pos, const std::string& str) { +const std::string move_to_uci(Move m, bool chess960) { - Square from, to; - Piece piece; - Color us = pos.side_to_move(); + std::string promotion; + Square from = move_from(m); + Square to = move_to(m); - if (str.length() < 4) - return MOVE_NONE; + if (m == MOVE_NONE) + return "(none)"; - // Read the from and to squares - from = square_from_string(str.substr(0, 2)); - to = square_from_string(str.substr(2, 4)); + if (m == MOVE_NULL) + return "0000"; - // Find the moving piece - piece = pos.piece_on(from); + if (move_is_short_castle(m) && !chess960) + return from == SQ_E1 ? "e1g1" : "e8g8"; - // If the string has more than 4 characters, try to interpret the 5th - // character as a promotion - if (type_of_piece(piece) == PAWN && str.length() > 4) - { - switch (tolower(str[4])) { - case 'n': - return make_promotion_move(from, to, KNIGHT); - case 'b': - return make_promotion_move(from, to, BISHOP); - case 'r': - return make_promotion_move(from, to, ROOK); - case 'q': - return make_promotion_move(from, to, QUEEN); - } - } + if (move_is_long_castle(m) && !chess960) + return from == SQ_E1 ? "e1c1" : "e8c8"; + + if (move_is_promotion(m)) + promotion = char(tolower(piece_type_to_char(move_promotion_piece(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 (piece == piece_of_color_and_type(us, KING)) +Move move_from_uci(const Position& pos, const std::string& str) { + + MoveStack mlist[MOVES_MAX]; + MoveStack* last = generate(pos, mlist); + + for (MoveStack* cur = mlist; cur != last; cur++) + if (str == move_to_uci(cur->move, pos.is_chess960())) + return cur->move; + + return MOVE_NONE; +} + + +/// move_to_san() takes a position and a move as input, where it is assumed +/// that the move is a legal move from the position. The return value is +/// a string containing the move in short algebraic notation. + +const string move_to_san(Position& pos, Move m) { + + assert(pos.is_ok()); + assert(move_is_ok(m)); + + string san; + Square from = move_from(m); + Square to = move_to(m); + PieceType pt = type_of_piece(pos.piece_on(from)); + + if (m == MOVE_NONE) + return "(none)"; + + if (m == MOVE_NULL) + return "(null)"; + + if (move_is_long_castle(m)) + san = "O-O-O"; + else if (move_is_short_castle(m)) + san = "O-O"; + else { - // Is this a castling move? A king move is assumed to be a castling - // move if the destination square is occupied by a friendly rook, or - // if the distance between the source and destination squares is more - // than 1. - if (pos.piece_on(to) == piece_of_color_and_type(us, ROOK)) - return make_castle_move(from, to); - - else if (square_distance(from, to) > 1) + if (pt != PAWN) { - // This is a castling move, but we have to translate it to the - // internal "king captures rook" representation. - SquareDelta delta = (to > from ? DELTA_E : DELTA_W); - Square s = from + delta; - while (relative_rank(us, s) == RANK_1 && pos.piece_on(s) != piece_of_color_and_type(us, ROOK)) - s += delta; - - return (relative_rank(us, s) == RANK_1 ? make_castle_move(from, s) : MOVE_NONE); + san += piece_type_to_char(pt); + + switch (move_ambiguity(pos, m)) { + case AMBIGUITY_NONE: + break; + case AMBIGUITY_FILE: + san += file_to_char(square_file(from)); + break; + case AMBIGUITY_RANK: + san += rank_to_char(square_rank(from)); + break; + case AMBIGUITY_BOTH: + san += square_to_string(from); + break; + default: + assert(false); + } + } + + if (pos.move_is_capture(m)) + { + if (pt == PAWN) + san += file_to_char(square_file(from)); + + san += 'x'; + } + san += square_to_string(to); + + if (move_is_promotion(m)) + { + san += '='; + san += piece_type_to_char(move_promotion_piece(m)); } } - else if (piece == piece_of_color_and_type(us, PAWN)) - { - // En passant move? We assume that a pawn move is an en passant move - // without further testing if the destination square is epSquare. - if (to == pos.ep_square()) - return make_ep_move(from, to); - } - return make_move(from, to); + + // The move gives check ? We don't use pos.move_is_check() here + // because we need to test for mate after the move is done. + StateInfo st; + pos.do_move(m, st); + if (pos.is_check()) + san += pos.is_mate() ? "#" : "+"; + pos.undo_move(m); + + return san; } -/// move_to_string() 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. +/// pretty_pv() creates a human-readable string from a position and a PV. +/// It is used to write search information to the log file (which is created +/// when the UCI parameter "Use Search Log" is "true"). -const std::string move_to_string(Move move, bool chess960) { +const string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]) { - std::string str; - Square from = move_from(move); - Square to = move_to(move); + const int64_t K = 1000; + const int64_t M = 1000000; + const int startColumn = 28; + const size_t maxLength = 80 - startColumn; + const string lf = string("\n") + string(startColumn, ' '); - if (move == MOVE_NONE) - str = "(none)"; - else if (move == MOVE_NULL) - str = "0000"; + StateInfo state[PLY_MAX_PLUS_2], *st = state; + Move* m = pv; + std::stringstream s; + string san; + size_t length = 0; + + // First print depth, score, time and searched nodes... + s << std::setw(2) << depth + << std::setw(8) << score_string(score) + << std::setw(8) << time_string(time); + + if (pos.nodes_searched() < M) + s << std::setw(8) << pos.nodes_searched() / 1 << " "; + else if (pos.nodes_searched() < K * M) + s << std::setw(7) << pos.nodes_searched() / K << " K "; else + s << std::setw(7) << pos.nodes_searched() / M << " M "; + + // ...then print the full PV line in short algebraic notation + while (*m != MOVE_NONE) { - if (move_is_short_castle(move) && !chess960) - return (from == SQ_E1 ? "e1g1" : "e8g8"); + san = move_to_san(pos, *m); + length += san.length() + 1; - if (move_is_long_castle(move) && !chess960) - return (from == SQ_E1 ? "e1c1" : "e8c8"); + if (length > maxLength) + { + length = san.length() + 1; + s << lf; + } + s << san << ' '; - str = square_to_string(from) + square_to_string(to); - if (move_is_promotion(move)) - str += char(tolower(piece_type_to_char(move_promotion_piece(move)))); + pos.do_move(*m++, *st++); } - return str; + + // Restore original position before to leave + while (m != pv) pos.undo_move(*--m); + + return s.str(); } -/// Overload the << operator, to make it easier to print moves. +namespace { -std::ostream& operator << (std::ostream& os, Move m) { + Ambiguity move_ambiguity(const Position& pos, Move m) { - bool chess960 = (os.iword(0) != 0); // See set960() - return os << move_to_string(m, chess960); -} + MoveStack mlist[MOVES_MAX], *last; + Move candidates[8]; + Square from = move_from(m); + Square to = move_to(m); + Piece pc = pos.piece_on(from); + int matches = 0, f = 0, r = 0; + + // If there is only one piece 'pc' then move cannot be ambiguous + if (pos.piece_count(pos.side_to_move(), type_of_piece(pc)) == 1) + return AMBIGUITY_NONE; + // Collect all legal moves of piece 'pc' with destination 'to' + last = generate(pos, mlist); + for (MoveStack* cur = mlist; cur != last; cur++) + if (move_to(cur->move) == to && pos.piece_on(move_from(cur->move)) == pc) + candidates[matches++] = cur->move; -/// move_is_ok(), for debugging. + if (matches == 1) + return AMBIGUITY_NONE; -bool move_is_ok(Move m) { + for (int i = 0; i < matches; i++) + { + if (square_file(move_from(candidates[i])) == square_file(from)) + f++; - return square_is_ok(move_from(m)) && square_is_ok(move_to(m)); + if (square_rank(move_from(candidates[i])) == square_rank(from)) + r++; + } + + return f == 1 ? AMBIGUITY_FILE : r == 1 ? AMBIGUITY_RANK : AMBIGUITY_BOTH; + } + + + const string time_string(int millisecs) { + + const int MSecMinute = 1000 * 60; + const int MSecHour = 1000 * 60 * 60; + + std::stringstream s; + s << std::setfill('0'); + + int hours = millisecs / MSecHour; + int minutes = (millisecs - hours * MSecHour) / MSecMinute; + int seconds = (millisecs - hours * MSecHour - minutes * MSecMinute) / 1000; + + if (hours) + s << hours << ':'; + + s << std::setw(2) << minutes << ':' << std::setw(2) << seconds; + return s.str(); + } + + + const string score_string(Value v) { + + std::stringstream s; + + if (v >= VALUE_MATE - 200) + s << "#" << (VALUE_MATE - v + 1) / 2; + else if (v <= -VALUE_MATE + 200) + s << "-#" << (VALUE_MATE + v) / 2; + else + { + float floatScore = float(v) / float(PawnValueMidgame); + if (v >= 0) + s << '+'; + + s << std::setprecision(2) << std::fixed << floatScore; + } + return s.str(); + } }