X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmove.cpp;h=0a620781ce1be0a85eb9929bbf60691b504a7f42;hp=63800d7f83bde58caf67f7a91f1fc2ad25d65120;hb=b21a5e2f0638a55daeaa98ba95afc6c016ea0b6e;hpb=c97104e8540b72ee2c6c9c13d3773d2c0f9ec32f

diff --git a/src/move.cpp b/src/move.cpp
index 63800d7f..0a620781 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 Marco Costalba
+  Copyright (C) 2008-2010 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
@@ -17,137 +17,247 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
+#include <cstring>
+#include <iomanip>
+#include <string>
+#include <sstream>
 
 #include "move.h"
-#include "piece.h"
-#include "position.h"
-#include "ucioption.h"
+#include "movegen.h"
+#include "search.h"
 
+using std::string;
 
-////
-//// Functions
-////
+namespace {
+  const string time_string(int milliseconds);
+  const string score_string(Value v);
+}
 
-/// 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 move_from_string(const Position& pos, const std::string& str) {
+/// 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.
 
-  Square from, to;
-  Piece piece;
-  Color us = pos.side_to_move();
+const string move_to_uci(Move m, bool chess960) {
 
-  if (str.length() < 4)
-      return MOVE_NONE;
+  Square from = move_from(m);
+  Square to = move_to(m);
+  string promotion;
 
-  // 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_NONE)
+      return "(none)";
 
-  // Find the moving piece
-  piece = pos.piece_on(from);
+  if (m == MOVE_NULL)
+      return "0000";
 
-  // 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_short_castle(m) && !chess960)
+      return from == SQ_E1 ? "e1g1" : "e8g8";
+
+  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(promotion_piece_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.
+
+Move move_from_uci(const Position& pos, const string& str) {
 
-  if (piece == king_of_color(us))
+  MoveStack mlist[MAX_MOVES];
+  MoveStack* last = generate<MV_LEGAL>(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));
+
+  Bitboard attackers;
+  bool ambiguousMove, ambiguousFile, ambiguousRank;
+  Square sq, from = move_from(m);
+  Square to = move_to(m);
+  PieceType pt = pos.type_of_piece_on(from);
+  string san;
+
+  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) == rook_of_color(us))
-          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) != rook_of_color(us))
-              s += delta;
-
-          return (relative_rank(us, s) == RANK_1 ? make_castle_move(from, s) : MOVE_NONE);
+          san = piece_type_to_char(pt);
+
+          // 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);
+          ambiguousMove = ambiguousFile = ambiguousRank = false;
+
+          while (attackers)
+          {
+              sq = pop_1st_bit(&attackers);
+
+              if (square_file(sq) == square_file(from))
+                  ambiguousFile = true;
+
+              if (square_rank(sq) == square_rank(from))
+                  ambiguousRank = true;
+
+              ambiguousMove = true;
+          }
+
+          if (ambiguousMove)
+          {
+              if (!ambiguousFile)
+                  san += file_to_char(square_file(from));
+              else if (!ambiguousRank)
+                  san += rank_to_char(square_rank(from));
+              else
+                  san += square_to_string(from);
+          }
+      }
+
+      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(promotion_piece_type(m));
       }
   }
-  else if (piece == pawn_of_color(us))
-  {
-      // 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_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);
+
+  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 string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]) {
+
+  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, ' ');
 
-const std::string move_to_string(Move move) {
+  StateInfo state[PLY_MAX_PLUS_2], *st = state;
+  Move* m = pv;
+  string san;
+  std::stringstream s;
+  size_t length = 0;
 
-  std::string str;
-  Square from = move_from(move);
-  Square to = move_to(move);
+  // 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 (move == MOVE_NONE)
-      str = "(none)";
-  else if (move == MOVE_NULL)
-      str = "0000";
+  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 (!Chess960)
-      {
-          if (move_is_short_castle(move))
-              return (from == SQ_E1 ? "e1g1" : "e8g8");
+      san = move_to_san(pos, *m);
+      length += san.length() + 1;
 
-          if (move_is_long_castle(move))
-              return (from == SQ_E1 ? "e1c1" : "e8c8");
+      if (length > maxLength)
+      {
+          length = san.length() + 1;
+          s << lf;
       }
-      str = square_to_string(from) + square_to_string(to);
-      if (move_promotion(move))
-          str += piece_type_to_char(move_promotion(move), false);
+      s << san << ' ';
+
+      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) {
+  const string time_string(int millisecs) {
 
-  return os << move_to_string(m);
-}
+    const int MSecMinute = 1000 * 60;
+    const int MSecHour   = 1000 * 60 * 60;
 
+    int hours = millisecs / MSecHour;
+    int minutes =  (millisecs % MSecHour) / MSecMinute;
+    int seconds = ((millisecs % MSecHour) % MSecMinute) / 1000;
 
-/// move_is_ok(), for debugging.
+    std::stringstream s;
 
-bool move_is_ok(Move m) {
+    if (hours)
+        s << hours << ':';
 
-  return square_is_ok(move_from(m)) && square_is_ok(move_to(m));
+    s << std::setfill('0') << 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
+        s << std::setprecision(2) << std::fixed << std::showpos << float(v) / PawnValueMidgame;
+
+    return s.str();
+  }
 }