X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmove.cpp;h=62ec7579659817cc6233700f0a44ea9c41f9b3f6;hp=4a9705446454d78298db32fec024985bb234f11b;hb=1b2af05ea69abffff432f7f20685e144bd24055e;hpb=2e2a4b4ea33fc0758067c5a83b9e6157fdf5d9a7

diff --git a/src/move.cpp b/src/move.cpp
index 4a970544..62ec7579 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-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2012 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,11 +17,10 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>
 #include <cassert>
-#include <cstring>
 #include <string>
 
-#include "move.h"
 #include "movegen.h"
 #include "position.h"
 
@@ -34,8 +33,8 @@ using std::string;
 
 const string move_to_uci(Move m, bool chess960) {
 
-  Square from = move_from(m);
-  Square to = move_to(m);
+  Square from = from_sq(m);
+  Square to = to_sq(m);
   string promotion;
 
   if (m == MOVE_NONE)
@@ -44,11 +43,11 @@ const string move_to_uci(Move m, bool chess960) {
   if (m == MOVE_NULL)
       return "0000";
 
-  if (move_is_castle(m) && !chess960)
-      to = from + (square_file(to) == FILE_H ? Square(2) : -Square(2));
+  if (is_castle(m) && !chess960)
+      to = from + (file_of(to) == FILE_H ? Square(2) : -Square(2));
 
-  if (move_is_promotion(m))
-      promotion = char(tolower(piece_type_to_char(promotion_piece_type(m))));
+  if (is_promotion(m))
+      promotion = char(tolower(piece_type_to_char(promotion_type(m))));
 
   return square_to_string(from) + square_to_string(to) + promotion;
 }
@@ -58,7 +57,10 @@ const string move_to_uci(Move m, bool chess960) {
 /// 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) {
+Move move_from_uci(const Position& pos, string str) {
+
+  // Some GUIs, like Junior, could send promotion in uppercase
+  std::transform(str.begin(), str.end(), str.begin(), tolower);
 
   for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
       if (str == move_to_uci(ml.move(), pos.is_chess960()))
@@ -80,17 +82,17 @@ const string move_to_san(Position& pos, Move m) {
   if (m == MOVE_NULL)
       return "(null)";
 
-  assert(move_is_ok(m));
+  assert(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));
+  Square sq, from = from_sq(m);
+  Square to = to_sq(m);
+  PieceType pt = type_of(pos.piece_moved(m));
   string san;
 
-  if (move_is_castle(m))
-      san = (move_to(m) < move_from(m) ? "O-O-O" : "O-O");
+  if (is_castle(m))
+      san = (to_sq(m) < from_sq(m) ? "O-O-O" : "O-O");
   else
   {
       if (pt != PAWN)
@@ -99,18 +101,22 @@ const string move_to_san(Position& pos, Move m) {
 
           // 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);
+          attackers = pos.attackers_to(to) & pos.pieces(pos.side_to_move(), pt);
+          attackers ^= from;
           ambiguousMove = ambiguousFile = ambiguousRank = false;
 
           while (attackers)
           {
               sq = pop_1st_bit(&attackers);
 
-              if (square_file(sq) == square_file(from))
+              // Pinned pieces are not included in the possible sub-set
+              if (!pos.pl_move_is_legal(make_move(sq, to), pos.pinned_pieces()))
+                  continue;
+
+              if (file_of(sq) == file_of(from))
                   ambiguousFile = true;
 
-              if (square_rank(sq) == square_rank(from))
+              if (rank_of(sq) == rank_of(from))
                   ambiguousRank = true;
 
               ambiguousMove = true;
@@ -119,38 +125,38 @@ const string move_to_san(Position& pos, Move m) {
           if (ambiguousMove)
           {
               if (!ambiguousFile)
-                  san += file_to_char(square_file(from));
+                  san += file_to_char(file_of(from));
               else if (!ambiguousRank)
-                  san += rank_to_char(square_rank(from));
+                  san += rank_to_char(rank_of(from));
               else
                   san += square_to_string(from);
           }
       }
 
-      if (pos.move_is_capture(m))
+      if (pos.is_capture(m))
       {
           if (pt == PAWN)
-              san += file_to_char(square_file(from));
+              san += file_to_char(file_of(from));
 
           san += 'x';
       }
 
       san += square_to_string(to);
 
-      if (move_is_promotion(m))
+      if (is_promotion(m))
       {
           san += '=';
-          san += piece_type_to_char(promotion_piece_type(m));
+          san += piece_type_to_char(promotion_type(m));
       }
   }
 
-  // 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);
+  if (pos.move_gives_check(m, CheckInfo(pos)))
+  {
+      StateInfo st;
+      pos.do_move(m, st);
+      san += MoveList<MV_LEGAL>(pos).size() ? "+" : "#";
+      pos.undo_move(m);
+  }
 
   return san;
 }