git.sesse.net Git - stockfish/blob - src/move.cpp

   1 /*
   2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
   4   Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
   5
   6   Stockfish is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   Stockfish is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include <cassert>
  21 #include <cstring>
  22 #include <iomanip>
  23 #include <string>
  24 #include <sstream>
  25
  26 #include "move.h"
  27 #include "movegen.h"
  28 #include "position.h"
  29
  30 using std::string;
  31
  32 namespace {
  33   const string time_string(int milliseconds);
  34   const string score_string(Value v);
  35 }
  36
  37
  38 /// move_to_uci() converts a move to a string in coordinate notation
  39 /// (g1f3, a7a8q, etc.). The only special case is castling moves, where we
  40 /// print in the e1g1 notation in normal chess mode, and in e1h1 notation in
  41 /// Chess960 mode. Instead internally Move is coded as "king captures rook".
  42
  43 const string move_to_uci(Move m, bool chess960) {
  44
  45   Square from = move_from(m);
  46   Square to = move_to(m);
  47   string promotion;
  48
  49   if (m == MOVE_NONE)
  50       return "(none)";
  51
  52   if (m == MOVE_NULL)
  53       return "0000";
  54
  55   if (move_is_castle(m) && !chess960)
  56       to = from + (square_file(to) == FILE_H ? Square(2) : -Square(2));
  57
  58   if (move_is_promotion(m))
  59       promotion = char(tolower(piece_type_to_char(promotion_piece_type(m))));
  60
  61   return square_to_string(from) + square_to_string(to) + promotion;
  62 }
  63
  64
  65 /// move_from_uci() takes a position and a string representing a move in
  66 /// simple coordinate notation and returns an equivalent Move if any.
  67 /// Moves are guaranteed to be legal.
  68
  69 Move move_from_uci(const Position& pos, const string& str) {
  70
  71   for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
  72       if (str == move_to_uci(ml.move(), pos.is_chess960()))
  73           return ml.move();
  74
  75   return MOVE_NONE;
  76 }
  77
  78
  79 /// move_to_san() takes a position and a move as input, where it is assumed
  80 /// that the move is a legal move for the position. The return value is
  81 /// a string containing the move in short algebraic notation.
  82
  83 const string move_to_san(Position& pos, Move m) {
  84
  85   if (m == MOVE_NONE)
  86       return "(none)";
  87
  88   if (m == MOVE_NULL)
  89       return "(null)";
  90
  91   assert(move_is_ok(m));
  92
  93   Bitboard attackers;
  94   bool ambiguousMove, ambiguousFile, ambiguousRank;
  95   Square sq, from = move_from(m);
  96   Square to = move_to(m);
  97   PieceType pt = piece_type(pos.piece_on(from));
  98   string san;
  99
 100   if (move_is_castle(m))
 101       san = (move_to(m) < move_from(m) ? "O-O-O" : "O-O");
 102   else
 103   {
 104       if (pt != PAWN)
 105       {
 106           san = piece_type_to_char(pt);
 107
 108           // Disambiguation if we have more then one piece with destination 'to'
 109           // note that for pawns is not needed because starting file is explicit.
 110           attackers = pos.attackers_to(to) & pos.pieces(pt, pos.side_to_move());
 111           clear_bit(&attackers, from);
 112           ambiguousMove = ambiguousFile = ambiguousRank = false;
 113
 114           while (attackers)
 115           {
 116               sq = pop_1st_bit(&attackers);
 117
 118               if (square_file(sq) == square_file(from))
 119                   ambiguousFile = true;
 120
 121               if (square_rank(sq) == square_rank(from))
 122                   ambiguousRank = true;
 123
 124               ambiguousMove = true;
 125           }
 126
 127           if (ambiguousMove)
 128           {
 129               if (!ambiguousFile)
 130                   san += file_to_char(square_file(from));
 131               else if (!ambiguousRank)
 132                   san += rank_to_char(square_rank(from));
 133               else
 134                   san += square_to_string(from);
 135           }
 136       }
 137
 138       if (pos.move_is_capture(m))
 139       {
 140           if (pt == PAWN)
 141               san += file_to_char(square_file(from));
 142
 143           san += 'x';
 144       }
 145
 146       san += square_to_string(to);
 147
 148       if (move_is_promotion(m))
 149       {
 150           san += '=';
 151           san += piece_type_to_char(promotion_piece_type(m));
 152       }
 153   }
 154
 155   // The move gives check? We don't use pos.move_gives_check() here
 156   // because we need to test for a mate after the move is done.
 157   StateInfo st;
 158   pos.do_move(m, st);
 159   if (pos.in_check())
 160       san += pos.is_mate() ? "#" : "+";
 161   pos.undo_move(m);
 162
 163   return san;
 164 }
 165
 166
 167 /// pretty_pv() creates a human-readable string from a position and a PV.
 168 /// It is used to write search information to the log file (which is created
 169 /// when the UCI parameter "Use Search Log" is "true").
 170
 171 const string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]) {
 172
 173   const int64_t K = 1000;
 174   const int64_t M = 1000000;
 175   const int startColumn = 28;
 176   const size_t maxLength = 80 - startColumn;
 177   const string lf = string("\n") + string(startColumn, ' ');
 178
 179   StateInfo state[PLY_MAX_PLUS_2], *st = state;
 180   Move* m = pv;
 181   string san;
 182   std::stringstream s;
 183   size_t length = 0;
 184
 185   // First print depth, score, time and searched nodes...
 186   s << std::setw(2) << depth
 187     << std::setw(8) << score_string(score)
 188     << std::setw(8) << time_string(time);
 189
 190   if (pos.nodes_searched() < M)
 191       s << std::setw(8) << pos.nodes_searched() / 1 << "  ";
 192   else if (pos.nodes_searched() < K * M)
 193       s << std::setw(7) << pos.nodes_searched() / K << "K  ";
 194   else
 195       s << std::setw(7) << pos.nodes_searched() / M << "M  ";
 196
 197   // ...then print the full PV line in short algebraic notation
 198   while (*m != MOVE_NONE)
 199   {
 200       san = move_to_san(pos, *m);
 201       length += san.length() + 1;
 202
 203       if (length > maxLength)
 204       {
 205           length = san.length() + 1;
 206           s << lf;
 207       }
 208       s << san << ' ';
 209
 210       pos.do_move(*m++, *st++);
 211   }
 212
 213   // Restore original position before to leave
 214   while (m != pv) pos.undo_move(*--m);
 215
 216   return s.str();
 217 }
 218
 219
 220 namespace {
 221
 222   const string time_string(int millisecs) {
 223
 224     const int MSecMinute = 1000 * 60;
 225     const int MSecHour   = 1000 * 60 * 60;
 226
 227     int hours = millisecs / MSecHour;
 228     int minutes =  (millisecs % MSecHour) / MSecMinute;
 229     int seconds = ((millisecs % MSecHour) % MSecMinute) / 1000;
 230
 231     std::stringstream s;
 232
 233     if (hours)
 234         s << hours << ':';
 235
 236     s << std::setfill('0') << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
 237     return s.str();
 238   }
 239
 240
 241   const string score_string(Value v) {
 242
 243     std::stringstream s;
 244
 245     if (v >= VALUE_MATE - 200)
 246         s << "#" << (VALUE_MATE - v + 1) / 2;
 247     else if (v <= -VALUE_MATE + 200)
 248         s << "-#" << (VALUE_MATE + v) / 2;
 249     else
 250         s << std::setprecision(2) << std::fixed << std::showpos << float(v) / PawnValueMidgame;
 251
 252     return s.str();
 253   }
 254 }