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 "search.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.
  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_short_castle(m) && !chess960)
  56       return from == SQ_E1 ? "e1g1" : "e8g8";
  57
  58   if (move_is_long_castle(m) && !chess960)
  59       return from == SQ_E1 ? "e1c1" : "e8c8";
  60
  61   if (move_is_promotion(m))
  62       promotion = char(tolower(piece_type_to_char(move_promotion_piece(m))));
  63
  64   return square_to_string(from) + square_to_string(to) + promotion;
  65 }
  66
  67
  68 /// move_from_uci() takes a position and a string representing a move in
  69 /// simple coordinate notation and returns an equivalent Move.
  70
  71 Move move_from_uci(const Position& pos, const string& str) {
  72
  73   MoveStack mlist[MAX_MOVES];
  74   MoveStack* last = generate<MV_LEGAL>(pos, mlist);
  75
  76   for (MoveStack* cur = mlist; cur != last; cur++)
  77       if (str == move_to_uci(cur->move, pos.is_chess960()))
  78           return cur->move;
  79
  80   return MOVE_NONE;
  81 }
  82
  83
  84 /// move_to_san() takes a position and a move as input, where it is assumed
  85 /// that the move is a legal move from the position. The return value is
  86 /// a string containing the move in short algebraic notation.
  87
  88 const string move_to_san(Position& pos, Move m) {
  89
  90   assert(pos.is_ok());
  91   assert(move_is_ok(m));
  92
  93   MoveStack mlist[MAX_MOVES];
  94   Square from = move_from(m);
  95   Square to = move_to(m);
  96   PieceType pt = pos.type_of_piece_on(from);
  97   string san;
  98
  99   if (m == MOVE_NONE)
 100       return "(none)";
 101
 102   if (m == MOVE_NULL)
 103       return "(null)";
 104
 105   if (move_is_long_castle(m))
 106       san = "O-O-O";
 107   else if (move_is_short_castle(m))
 108       san = "O-O";
 109   else
 110   {
 111       if (pt != PAWN)
 112       {
 113           san = piece_type_to_char(pt);
 114
 115           // Collect all legal moves of piece type 'pt' with destination 'to'
 116           MoveStack* last = generate<MV_LEGAL>(pos, mlist);
 117           int f = 0, r = 0;
 118
 119           for (MoveStack* cur = mlist; cur != last; cur++)
 120               if (   move_to(cur->move) == to
 121                   && pos.type_of_piece_on(move_from(cur->move)) == pt)
 122               {
 123                   if (square_file(move_from(cur->move)) == square_file(from))
 124                       f++;
 125
 126                   if (square_rank(move_from(cur->move)) == square_rank(from))
 127                       r++;
 128               }
 129
 130           assert(f > 0 && r > 0);
 131
 132           // Disambiguation if we have more then one piece with destination 'to'
 133           if (f == 1 && r > 1)
 134               san += file_to_char(square_file(from));
 135           else if (f > 1 && r == 1)
 136               san += rank_to_char(square_rank(from));
 137           else if (f > 1 && r > 1)
 138               san += square_to_string(from);
 139       }
 140
 141       if (pos.move_is_capture(m))
 142       {
 143           if (pt == PAWN)
 144               san += file_to_char(square_file(from));
 145
 146           san += 'x';
 147       }
 148
 149       san += square_to_string(to);
 150
 151       if (move_is_promotion(m))
 152       {
 153           san += '=';
 154           san += piece_type_to_char(move_promotion_piece(m));
 155       }
 156   }
 157
 158   // The move gives check? We don't use pos.move_is_check() here
 159   // because we need to test for a mate after the move is done.
 160   StateInfo st;
 161   pos.do_move(m, st);
 162   if (pos.is_check())
 163       san += pos.is_mate() ? "#" : "+";
 164   pos.undo_move(m);
 165
 166   return san;
 167 }
 168
 169
 170 /// pretty_pv() creates a human-readable string from a position and a PV.
 171 /// It is used to write search information to the log file (which is created
 172 /// when the UCI parameter "Use Search Log" is "true").
 173
 174 const string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]) {
 175
 176   const int64_t K = 1000;
 177   const int64_t M = 1000000;
 178   const int startColumn = 28;
 179   const size_t maxLength = 80 - startColumn;
 180   const string lf = string("\n") + string(startColumn, ' ');
 181
 182   StateInfo state[PLY_MAX_PLUS_2], *st = state;
 183   Move* m = pv;
 184   string san;
 185   std::stringstream s;
 186   size_t length = 0;
 187
 188   // First print depth, score, time and searched nodes...
 189   s << std::setw(2) << depth
 190     << std::setw(8) << score_string(score)
 191     << std::setw(8) << time_string(time);
 192
 193   if (pos.nodes_searched() < M)
 194       s << std::setw(8) << pos.nodes_searched() / 1 << "  ";
 195   else if (pos.nodes_searched() < K * M)
 196       s << std::setw(7) << pos.nodes_searched() / K << "K  ";
 197   else
 198       s << std::setw(7) << pos.nodes_searched() / M << "M  ";
 199
 200   // ...then print the full PV line in short algebraic notation
 201   while (*m != MOVE_NONE)
 202   {
 203       san = move_to_san(pos, *m);
 204       length += san.length() + 1;
 205
 206       if (length > maxLength)
 207       {
 208           length = san.length() + 1;
 209           s << lf;
 210       }
 211       s << san << ' ';
 212
 213       pos.do_move(*m++, *st++);
 214   }
 215
 216   // Restore original position before to leave
 217   while (m != pv) pos.undo_move(*--m);
 218
 219   return s.str();
 220 }
 221
 222
 223 namespace {
 224
 225   const string time_string(int millisecs) {
 226
 227     const int MSecMinute = 1000 * 60;
 228     const int MSecHour   = 1000 * 60 * 60;
 229
 230     int hours = millisecs / MSecHour;
 231     int minutes =  (millisecs % MSecHour) / MSecMinute;
 232     int seconds = ((millisecs % MSecHour) % MSecMinute) / 1000;
 233
 234     std::stringstream s;
 235
 236     if (hours)
 237         s << hours << ':';
 238
 239     s << std::setfill('0') << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
 240     return s.str();
 241   }
 242
 243
 244   const string score_string(Value v) {
 245
 246     std::stringstream s;
 247
 248     if (v >= VALUE_MATE - 200)
 249         s << "#" << (VALUE_MATE - v + 1) / 2;
 250     else if (v <= -VALUE_MATE + 200)
 251         s << "-#" << (VALUE_MATE + v) / 2;
 252     else
 253         s << std::setprecision(2) << std::fixed << std::showpos << float(v) / PawnValueMidgame;
 254
 255     return s.str();
 256   }
 257 }