X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmove.cpp;h=8cc0c004dac94bd27171ddefab6ce77d0baedce2;hp=7504615d6d670c5ee0e7279ca90c57aa06bd6b27;hb=ad1f28bc1c1c5426fb8ab246f5d43ad57002b4d5;hpb=462a39ec496a94cf3f05ca60b4ddcc31150904ac

diff --git a/src/move.cpp b/src/move.cpp
index 7504615d..8cc0c004 100644
--- a/src/move.cpp
+++ b/src/move.cpp
@@ -25,7 +25,7 @@
 
 #include "move.h"
 #include "movegen.h"
-#include "search.h"
+#include "position.h"
 
 using std::string;
 
@@ -38,7 +38,7 @@ namespace {
 /// 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.
+/// Chess960 mode. Instead internally Move is coded as "king captures rook".
 
 const string move_to_uci(Move m, bool chess960) {
 
@@ -52,14 +52,11 @@ const string move_to_uci(Move m, bool chess960) {
   if (m == MOVE_NULL)
       return "0000";
 
-  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_castle(m) && !chess960)
+      to = from + (square_file(to) == FILE_H ? Square(2) : -Square(2));
 
   if (move_is_promotion(m))
-      promotion = char(tolower(piece_type_to_char(move_promotion_piece(m))));
+      promotion = char(tolower(piece_type_to_char(promotion_piece_type(m))));
 
   return square_to_string(from) + square_to_string(to) + promotion;
 }
@@ -71,73 +68,67 @@ const string move_to_uci(Move m, bool chess960) {
 
 Move move_from_uci(const Position& pos, const string& str) {
 
-  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;
+  for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
+      if (str == move_to_uci(ml.move(), pos.is_chess960()))
+          return ml.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
+/// that the move is a legal move for 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));
-
-  MoveStack mlist[MAX_MOVES];
-  Square 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";
+  assert(move_is_ok(m));
+
+  Bitboard attackers;
+  bool ambiguousMove, ambiguousFile, ambiguousRank;
+  Square sq, from = move_from(m);
+  Square to = move_to(m);
+  PieceType pt = piece_type(pos.piece_on(from));
+  string san;
+
+  if (move_is_castle(m))
+      san = (move_to(m) < move_from(m) ? "O-O-O" : "O-O");
   else
   {
       if (pt != PAWN)
       {
           san = piece_type_to_char(pt);
 
-          // Collect all legal moves of piece type 'pt' with destination 'to'
-          MoveStack* last = generate<MV_LEGAL>(pos, mlist);
-          int f = 0, r = 0, cnt = 0;
+          // 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;
 
-          for (MoveStack* cur = mlist; cur != last; cur++)
-              if (   move_to(cur->move) == to
-                  && pos.type_of_piece_on(move_from(cur->move)) == pt)
-              {
-                  cnt++;
+          while (attackers)
+          {
+              sq = pop_1st_bit(&attackers);
 
-                  if (square_file(move_from(cur->move)) == square_file(from))
-                      f++;
+              if (square_file(sq) == square_file(from))
+                  ambiguousFile = true;
 
-                  if (square_rank(move_from(cur->move)) == square_rank(from))
-                      r++;
-              }
+              if (square_rank(sq) == square_rank(from))
+                  ambiguousRank = true;
 
-          assert(cnt > 0 && f > 0 && r > 0);
+              ambiguousMove = true;
+          }
 
-          // Disambiguation if we have more then one piece with destination 'to'
-          if (cnt > 1)
+          if (ambiguousMove)
           {
-              if (f == 1)
+              if (!ambiguousFile)
                   san += file_to_char(square_file(from));
-              else if (r == 1)
+              else if (!ambiguousRank)
                   san += rank_to_char(square_rank(from));
               else
                   san += square_to_string(from);
@@ -157,7 +148,7 @@ const string move_to_san(Position& pos, Move m) {
       if (move_is_promotion(m))
       {
           san += '=';
-          san += piece_type_to_char(move_promotion_piece(m));
+          san += piece_type_to_char(promotion_piece_type(m));
       }
   }