Space inflate move.cpp
authorMarco Costalba <mcostalba@gmail.com>
Thu, 30 Oct 2008 14:21:53 +0000 (15:21 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Sat, 1 Nov 2008 11:46:53 +0000 (12:46 +0100)
Also a little cleanup.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
src/move.cpp

index f23fcbe021796f086fe9cadf9fd5479f8f4f9773..492d93905348c44dc2a87bf6f0c41c16eaf91528 100644 (file)
 
 /// 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
+/// 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 move_from_string(const Position& pos, const std::string& str) {
+
   Square from, to;
   Piece piece;
   Color us = pos.side_to_move();
 
-  if(str.length() < 4) return MOVE_NONE;
+  if (str.length() < 4)
+      return MOVE_NONE;
 
-  // Read the from and to squares:
+  // Read the from and to squares
   from = square_from_string(str.substr(0, 2));
   to = square_from_string(str.substr(2, 4));
 
-  // Find the moving piece:
+  // Find the moving piece
   piece = pos.piece_on(from);
 
   // 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() >= 5) {
-    switch(str[4]) {
-    case 'n': case 'N': 
-      return make_promotion_move(from, to, KNIGHT);
-    case 'b': case 'B':
-      return make_promotion_move(from, to, BISHOP);
-    case 'r': case 'R':
-      return make_promotion_move(from, to, ROOK);
-    case 'q': case 'Q':
-      return make_promotion_move(from, to, QUEEN);
+  // 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(piece == king_of_color(us)) {
-    // 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) {
-      // 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;
-      for(s = from + delta;
-          relative_rank(us, s) == RANK_1 && pos.piece_on(s) != rook_of_color(us);
-          s += delta);
-      if(relative_rank(us, s) == RANK_1 && pos.piece_on(s) == rook_of_color(us))
-        return make_castle_move(from, s);
-    }
+  if (piece == king_of_color(us))
+  {
+      // 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)
+      {
+          // 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);
+      }
   }
-  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);
+  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);
 }
 
@@ -105,30 +110,28 @@ Move move_from_string(const Position &pos, const std::string &str) {
 /// Chess960 mode.
 
 const std::string move_to_string(Move move) {
-  std::string str;
 
-  if(move == MOVE_NONE)
-    str = "(none)";
-  else if(move == MOVE_NULL)
-    str = "0000";
-  else {
-    if(!Chess960) {
-      if(move_from(move) == SQ_E1 && move_is_short_castle(move)) {
-        str = "e1g1"; return str;
-      }
-      else if(move_from(move) == SQ_E1 && move_is_long_castle(move)) {
-        str = "e1c1"; return str;
-      }
-      if(move_from(move) == SQ_E8 && move_is_short_castle(move)) {
-        str = "e8g8"; return str;
-      }
-      else if(move_from(move) == SQ_E8 && move_is_long_castle(move)) {
-        str = "e8c8"; return str;
+  std::string str;
+  Square from = move_from(move);
+  Square to = move_to(move);
+
+  if (move == MOVE_NONE)
+      str = "(none)";
+  else if (move == MOVE_NULL)
+      str = "0000";
+  else
+  {
+      if (!Chess960)
+      {
+          if (move_is_short_castle(move))
+              return (from == SQ_E1 ? "e1g1" : "e8g8");
+
+          if (move_is_long_castle(move))
+              return (from == SQ_E1 ? "e1c1" : "e8c8");
       }
-    }
-    str = square_to_string(move_from(move)) + square_to_string(move_to(move));
-    if(move_promotion(move))
-      str += piece_type_to_char(move_promotion(move), false);
+      str = square_to_string(from) + square_to_string(to);
+      if (move_promotion(move))
+          str += piece_type_to_char(move_promotion(move), false);
   }
   return str;
 }
@@ -137,6 +140,7 @@ const std::string move_to_string(Move move) {
 /// Overload the << operator, to make it easier to print moves.
 
 std::ostream &operator << (std::ostream &os, Move m) {
+
   return os << move_to_string(m);
 }
 
@@ -144,5 +148,6 @@ std::ostream &operator << (std::ostream &os, Move m) {
 /// move_is_ok(), for debugging.
 
 bool move_is_ok(Move m) {
+
   return square_is_ok(move_from(m)) && square_is_ok(move_to(m));
 }