chess 0.1.3 → 0.1.4

data/ext/chess.h

@@ -36,6 +36,7 @@ VALUE board_king_in_check (VALUE self);
 VALUE board_king_in_checkmate (VALUE self);
 VALUE board_stalemate (VALUE self);
 VALUE board_insufficient_material (VALUE self);
+VALUE board_only_kings (VALUE self);
 VALUE board_fifty_move_rule (VALUE self);
 VALUE board_active_color (VALUE self);
 VALUE board_halfmove_clock (VALUE self);

data/ext/common.c

@@ -7,24 +7,28 @@
 
 #include "common.h"
 
+// Given a square returns the file.
 char
 square_to_file (int square)
 {
   return (square % 8) + 97;
 }
 
+// Given a square returns the rank.
 char
 square_to_rank (int square)
 {
   return (square / 8) + 49;
 }
 
+// Given a coordinate (a1) returns the square (0..63).
 int
 coord_to_square (const char *coord)
 {
   return 8 * ((coord[1] | ' ') - 49) + ((coord[0] | ' ') - 97);
 }
 
+// Given a square (0..63) returns the coordinate (a1).
 char*
 square_to_coord (int square)
 {
@@ -35,6 +39,8 @@ square_to_coord (int square)
   return s;
 }
 
+// Given a move from-to returns the coordinated (a2a1) with promotion syntax if
+// occured (a2a1=Q).
 char*
 ft_to_coord_move (int from, int to, char promote_in)
 {
@@ -53,6 +59,7 @@ ft_to_coord_move (int from, int to, char promote_in)
   return s;
 }
 
+// Given the result int returns the corresponding string.
 char*
 result_to_s (unsigned short int r)
 {
@@ -75,6 +82,7 @@ result_to_s (unsigned short int r)
   return s;
 }
 
+// Given the castling int returns the corresponding FEN string.
 char*
 castling_to_s (short int castling)
 {
@@ -89,6 +97,7 @@ castling_to_s (short int castling)
   return s;
 }
 
+// Given the en passant int returns the corresponding FEN string.
 char*
 en_passant_to_s (short int en_passant)
 {
@@ -100,6 +109,7 @@ en_passant_to_s (short int en_passant)
   return s;
 }
 
+// Compare two strings.
 int
 compare (const void *a, const void *b)
 {

data/ext/game.c

@@ -9,6 +9,7 @@
 
 static Board STARTING_BOARD;
 
+// Initialize the library.
 void
 init_chess_library ()
 {
@@ -16,6 +17,7 @@ init_chess_library ()
   precalculate_all_xray ();
 }
 
+// Initialize the Game struct.
 Game*
 init_game ()
 {
@@ -25,7 +27,7 @@ init_game ()
   return g;
 }
 
-// Free memory of a game
+// Free memory of a game.
 void
 free_game (Game *g)
 {
@@ -38,6 +40,7 @@ free_game (Game *g)
   free (g);
 }
 
+// Returns the last board of the game.
 Board*
 current_board (Game *g)
 {
@@ -46,6 +49,8 @@ current_board (Game *g)
   return &STARTING_BOARD;
 }
 
+// Returns the board at i-th position. If i is negative returns the starting
+// board. NULL if i is out of bounds.
 Board*
 get_board (Game *g, int index)
 {
@@ -56,6 +61,7 @@ get_board (Game *g, int index)
   return NULL;
 }
 
+// Returns the last move done.
 char*
 current_move (Game *g)
 {
@@ -64,6 +70,7 @@ current_move (Game *g)
   return 0;
 }
 
+// Returns the last move done in coordinate format.
 char*
 current_coord_move (Game *g)
 {
@@ -72,11 +79,13 @@ current_coord_move (Game *g)
   return 0;
 }
 
+// Returns true if the move from-to is legal. Add the new board on the game.
 bool
 apply_move (Game *g, int from, int to, char promote_in)
 {
-  if (g->result != IN_PROGRESS) return FALSE;
+  if (g->result != IN_PROGRESS && g->result != DRAW) return FALSE;
   Board *board = current_board (g);
+  if (promote_in && invalid_promotion (board, from, to)) return FALSE;
   Board *new_board = NEW_BOARD;
   char capture = 0;
   char *move_done = castling (board, castling_type (board, from, to), new_board);
@@ -113,7 +122,7 @@ apply_move (Game *g, int from, int to, char promote_in)
       else
         strcat (move_done, "+");
     }
-  // Test insufficient material
+  // Set game result to DRAW if insufficient material
   else if (insufficient_material (new_board))
     g->result = DRAW;
   // Test stalemate
@@ -122,6 +131,7 @@ apply_move (Game *g, int from, int to, char promote_in)
   return TRUE;
 }
 
+// Rollback last move.
 void
 rollback (Game *g)
 {
@@ -135,6 +145,7 @@ rollback (Game *g)
     }
 }
 
+// Returns true if a player can claim draw by the threefold repetition rule.
 bool
 threefold_repetition (Game *g)
 {
@@ -179,6 +190,7 @@ threefold_repetition (Game *g)
 }
 
 /*
+ * Set the game position by FEN string.
  A FEN string is composed of 6 parts separated by " " (space).
  1. Piece placement (from white's perspective).
  2. Active color. "w" means white moves next, "b" means black.
@@ -335,6 +347,8 @@ set_fen (Game *g, const char *fen)
   free (s);
 }
 
+
+
 ///////////////////////////////////
 // MAIN (only for internal test) //
 ///////////////////////////////////
@@ -353,54 +367,57 @@ main ()
 
       // 1. e4 a6 2. Bc4 a5 3. Qh5 a4 4. Qxf7#
       board = current_board (g);
-      get_coord (board, 'P', "e", "e4", 0, &from, &to);
+      get_coord (board, 'P', NULL, "e4", '\0', &from, &to);
       pseudo_legal_move (board, from, to);
       apply_move (g, from, to, 0);
       fen = to_fen (board);
       free (fen);
 
       board = current_board (g);
-      get_coord (board, 'P', "a", "a6", 0, &from, &to);
+      get_coord (board, 'P', NULL, "a6", '\0', &from, &to);
       pseudo_legal_move (board, from, to);
-      apply_move (g, from, to, 0);
+      apply_move (g, from, to, '\0');
       fen = to_fen (current_board (g));
       free (fen);
 
       board = current_board (g);
-      get_coord (board, 'B', "", "c4", 0, &from, &to);
+      get_coord (board, 'B', NULL, "c4", '\0', &from, &to);
       pseudo_legal_move (board, from, to);
-      apply_move (g, from, to, 0);
+      apply_move (g, from, to, '\0');
       fen = to_fen (current_board (g));
       free (fen);
 
       board = current_board (g);
-      get_coord (board, 'P', "a", "a5", 0, &from, &to);
+      get_coord (board, 'P', NULL, "a5", '\0', &from, &to);
       pseudo_legal_move (board, from, to);
-      apply_move (g, from, to, 0);
+      apply_move (g, from, to, '\0');
       fen = to_fen (current_board (g));
       free (fen);
 
       board = current_board (g);
-      get_coord (board, 'Q', "", "h5", 0, &from, &to);
+      get_coord (board, 'Q', NULL, "h5", '\0', &from, &to);
       pseudo_legal_move (board, from, to);
-      apply_move (g, from, to, 0);
+      apply_move (g, from, to, '\0');
       fen = to_fen (current_board (g));
       free (fen);
 
       board = current_board (g);
-      get_coord (board, 'P', "a", "a4", 0, &from, &to);
+      get_coord (board, 'P', NULL, "a4", '\0', &from, &to);
       pseudo_legal_move (board, from, to);
-      apply_move (g, from, to, 0);
+      apply_move (g, from, to, '\0');
       fen = to_fen (current_board (g));
       free (fen);
 
       board = current_board (g);
-      get_coord (board, 'Q', "", "f7", 0, &from, &to);
+      get_coord (board, 'Q', NULL, "f7", '\0', &from, &to);
       pseudo_legal_move (board, from, to);
-      apply_move (g, from, to, 0);
+      apply_move (g, from, to, '\0');
       fen = to_fen (current_board (g));
       free (fen);
 
+      // board = current_board (g);
+      // printf("%s\n", print_board (board));
+
       free_game (g);
     }
   return 0;

data/ext/special.c

@@ -7,6 +7,7 @@
 
 #include "special.h"
 
+// Update the board castling bits (FEN style).
 void
 update_castling (Board *board, int from)
 {
@@ -33,6 +34,8 @@ update_castling (Board *board, int from)
     }
 }
 
+// Returns the castling type for the move from-to. If not a castling move
+// returns 0.
 int
 castling_type (Board *board, int from, int to)
 {
@@ -79,6 +82,9 @@ castling_type (Board *board, int from, int to)
   return 0;
 }
 
+// Returns the short algebraic chess notation and the new board of a castling
+// type move. Assume that the castling move is legal. Equivalent of
+// Game#apply_move but for a castling move.
 char*
 castling (Board *board, int castling_type, Board *new_board)
 {
@@ -140,6 +146,7 @@ castling (Board *board, int castling_type, Board *new_board)
   return move;
 }
 
+// Update the board en passant bits (FEN style).
 void
 update_en_passant (Board *board, int from, int to)
 {
@@ -151,6 +158,8 @@ update_en_passant (Board *board, int from, int to)
     board->en_passant = -1;
 }
 
+// Returns the position (0..63) "behind" the pawn that can perform a en passant
+// capture. 0 if en passant is not available.
 int
 have_en_passant (Board *board, int from, int to)
 {
@@ -163,19 +172,16 @@ have_en_passant (Board *board, int from, int to)
   return 0;
 }
 
-int
-have_en_passant2 (Board *board, int to)
-{
-  return have_en_passant (board, to + 1, board->en_passant) || have_en_passant (board, to - 1, board->en_passant);
-}
-
+// Returns true if a pawn must be promoted (a pawn is on the edges).
 bool
 require_a_promotion (Board *board)
 {
   return ((board->pawns[WHITE] | board->pawns[BLACK]) & 0xff000000000000ff) ? TRUE : FALSE;
 }
 
-bool
+// Perform the promotion of the piece on the square (transform the piece in the
+// promoted piece). If promote_in is invalid promote in a Queen.
+void
 promote (Board *board, int square, char promote_in)
 {
   if (board->active_color)
@@ -191,9 +197,6 @@ promote (Board *board, int square, char promote_in)
         promote_in = 'Q';
     }
   *(get_bitboard (board, square)) ^= 1ULL << square;
-  bboard *bb = get_piece_bitboard (board, promote_in);
-  if (!bb) return FALSE;
-  *(bb) ^= 1ULL << square;
+  *(get_piece_bitboard (board, promote_in)) ^= 1ULL << square;
   board->placement[square] = promote_in;
-  return TRUE;
 }

data/ext/special.h

@@ -16,8 +16,7 @@ int castling_type (Board *board, int from, int to);
 char* castling (Board *board, int castling_type, Board *new_board);
 void update_en_passant (Board *board, int from, int to);
 int have_en_passant (Board *board, int from, int to);
-int have_en_passant2 (Board *board, int to);
 bool require_a_promotion (Board *board);
-bool promote (Board *board, int square, char promote_in);
+void promote (Board *board, int square, char promote_in);
 
 #endif

data/lib/chess/exceptions.rb

@@ -1,30 +1,27 @@
 module Chess
 
   # This exception will be raised when an invalid short algebraic chess notation
-  # string is passed to the Game#move function.
+  # string is passed to the {Game#move} function.
   class BadNotationError < StandardError
-    # :nodoc:
-    # Create a new exception.
+    # @param [String] notation The invalid notation.
     def initialize(notation)
-      super("The notation '#{notation}' is invalid")
+      super("Invalid notation '#{notation}'")
     end
   end
 
   # This exception will be raised when a malformed PGN file is loaded.
   class InvalidPgnFormatError < StandardError
-    # :nodoc:
-    # Create a new exception.
+    # @param [String] filename The PGN filename
     def initialize(filename)
-      super("Invalid PGN file: '#{filename}'")
+      super("Invalid PGN file '#{filename}'")
     end
   end
 
   # This exception will be raised when an invalid FEN string is used.
   class InvalidFenFormatError < StandardError
-    # :nodoc:
-    # Create a new exception.
+    # @param [String] fen_string The FEN string.
     def initialize(fen_string)
-      super("Invalid FEN string: '#{fen_string}'")
+      super("Invalid FEN string '#{fen_string}'")
     end
   end
 

data/lib/chess/game.rb

@@ -5,16 +5,19 @@ module Chess
   # This class rappresents a chess game.
   class Game < CGame
 
-    # Create a new game. If an array of moves is provided, the moves will be performed.
-    #
-    # May be raise an IllegalMoveError or BadNotationError.
+    # @param [Array<String>] moves If an array of moves is provided, the moves will be performed.
+    # @raise [IllegalMoveError]
+    # @raise [BadNotationError]
     def initialize(moves = [])
       moves.each { |m| move(m) }
     end
 
     # Creates a new game from a file in PGN format.
-    #
-    # May be raise an InvalidPgnFormatError or IllegalMoveError or BadNotationError.
+    # @param [String] file The path of the PGN to laod.
+    # @return [Game]
+    # @raise [InvalidPgnFormatError]
+    # @raise [IllegalMoveError]
+    # @raise [BadNotationError]
     def self.load_pgn(file)
       pgn = Chess::Pgn.new(file)
       game = Chess::Game.new
@@ -26,20 +29,17 @@ module Chess
         when '0-1'
           game.resign(:white)
         when '1/2-1/2'
-          if game.board.insufficient_material? || game.board.stalemate? ||
-            game.threefold_repetition? || game.board.fifty_rule_move?
-            game.draw
-          end
+          game.draw
         end
       end
       return game
     end
 
     # Creates a new game from a FEN string.
-    #
-    # May be raise an InvalidFenFormatError.
-    #
-    # *Warning*: this game do not have history before the FEN placement.
+    # @param [String] fen The FEN string to laod.
+    # @return [Game]
+    # @raise [InvalidFenFormatError]
+    # @note This game do not have history before the FEN placement.
     def self.load_fen(fen)
       if fen =~ /^((?:[PRNBQKprnbqk1-8]{1,8}\/){7}[RNBQKPrnbqkp1-8]{1,8})\s(w|b)\s(K?Q?k?q?|-)\s([a-h][1-8]|-)\s(\d+)\s(\d+)$/
         game = Chess::Game.new
@@ -50,19 +50,17 @@ module Chess
       end
     end
 
-    # Make a move. This add a new Board in the Storyboard.
+    # Make a move.
+    # @note This add a new {Board} in the {Game}.
+    # @param [String] m Represents the short algebraic chess notation string of
+    #   the move. `m` can be also _from_square_ plus _to_square_ _('e2e4', ...,
+    #   'b1c3')_ (coordinate chess notation).
+    # @return [String] Returns a string that represents the short algebraic
+    #   chess notation of the move.
     #
-    # Parameters are:
-    # +m+:: represents the short algebraic chess notation string of the move.
-    #       +m+ can be <em>from_square</em> plus <em>to_square</em>
-    #       <em>('e2e4', ..., 'b1c3')</em> (coordinate chess notation).
-    #
-    # This method returns a string that represents the short algebraic chess
-    # notation of the move.
-    #
-    # Raise an IllegalMoveError if the move is illegal.
-    # Raise an BadNotationError if the short algebraic chess notation is
-    # malformed.
+    # @raise {IllegalMoveError} if the move is illegal.
+    # @raise {BadNotationError} if the short algebraic chess notation is
+    #   malformed.
     def move(m)
       begin
         expand = expand_move(m)
@@ -72,40 +70,50 @@ module Chess
           super(expand[:name], expand[:dis], expand[:to], expand[:promotion])
         end
       rescue IllegalMoveError
-        raise IllegalMoveError.new("Illegal move '#{m}'\n#{self.active_player} turn\n#{self.to_s}")
+        if ENV['DEBUG']
+          raise IllegalMoveError.new("Illegal move '#{m}'\nStatus: #{self.status}\nPlayer turn #{self.active_player}\n#{self.to_s}")
+        else
+          raise IllegalMoveError.new("Illegal move '#{m}'")
+        end
       end
     end
     alias :move= :move
     alias :<< :move
 
     # Make the array of moves.
+    # @param [Array<String>] moves The array of moves to performe.
     def moves=(moves)
       moves.each { |m| move(m) }
     end
 
-    # Returns +:white+ if the active player is the white player, +:black+ otherwise.
+    # Returns `:white` if the active player is the white player, `:black`
+    # otherwise.
+    # @return [Symbol]
     def active_player
       self.board.active_color ? :black : :white
     end
 
-    # Returns +:white+ if the inactive player is the white player, +:black+ otherwise.
+    # Returns `:white` if the inactive player is the white player, `:black`
+    # otherwise.
+    # @return [Symbol]
     def inactive_player
       self.board.active_color ? :white : :black
     end
 
     # Returns the status of the game.
-    #
     # Possible states are:
-    # * +in_progress+:: the game is in progress.
-    # * +white_won+:: white player has won with a checkmate.
-    # * +black_won+:: black player has won with a checkmate.
-    # * +white_won_resign+:: white player has won for resign.
-    # * +black_won_resign+:: black player has won for resign.
-    # * +stalemate+:: draw for stalemate.
-    # * +insufficient_material+:: draw for insufficient material to checkmate.
-    # * +fifty_rule_move+:: draw for fifty rule move.
-    # * +threefold_repetition+:: draw for threefold_repetition.
-    # * +unknown+:: something went wrong.
+    #
+    # * `in_progress`: the game is in progress.
+    # * `white_won`: white player has won with a checkmate.
+    # * `black_won`: black player has won with a checkmate.
+    # * `white_won_resign`: white player has won for resign.
+    # * `black_won_resign`: black player has won for resign.
+    # * `stalemate`: draw for stalemate.
+    # * `insufficient_material`: draw for insufficient material to checkmate.
+    # * `fifty_rule_move`: draw for fifty rule move.
+    # * `threefold_repetition`: draw for threefold_repetition.
+    # * `unknown`: something went wrong.
+    # @return [String]
     def status
       case self.result
       when '*'
@@ -136,12 +144,13 @@ module Chess
       return :unknown
     end
 
-    # Returns +true+ if the game is over
+    # Returns `true` if the game is over.
     def over?
       return self.result != '*'
     end
 
     # Returns the PGN rappresenting the game.
+    # @return [String]
     def pgn
       pgn = Chess::Pgn.new
       pgn.moves = self.moves
@@ -151,34 +160,41 @@ module Chess
 
     private
 
-    # Expand the short algebraic chess notation string +m+ in a hash like this:
+    # Expand the short algebraic chess notation string `m` in a hash like this:
     #
-    #     Ngxe2 ==> { name: 'N', dis: 'g', from: nil, to: 'e2', promotion: '' }
+    #     Ngxe2 ==> { name: 'N', dis: 'g', from: nil, to: 'e2', promotion: nil }
     def expand_move(m)
-      if match = m.match(/^([RNBQK])?([a-h]?[1-8]?)(?:x)?([a-h][1-8])(?:=?([RrNnBbQq]))?(?:ep)?(?:\+|\#)?$/)
+      if match = m.match(Chess::MOVE_REGEXP)
         expand = {
           name: match[1] || 'P',    # Piece name [RNBQK]
           dis: match[2],            # Disambiguating move
           to: match[3],             # Move to
-          promotion: match[4].to_s, # Promote with
+          promotion: match[4],      # Promote with
         }
         expand[:from] = match[2] if match[2] && match[2].size == 2
         return expand
-      elsif m =~ /^([0O])-([0O])([\+#])?$/
+      elsif m =~ SHORT_CASTLING_REGEXP
         if self.board.active_color # black king short castling
-          return { name: 'K', dis: '', from: 'e8', to: 'g8', promotion: '' }
+          return { name: 'K', dis: nil, from: 'e8', to: 'g8', promotion: nil }
         else # white king short castling
-          return { name: 'K', dis: '', from: 'e1', to: 'g1', promotion: '' }
+          return { name: 'K', dis: nil, from: 'e1', to: 'g1', promotion: nil }
         end
-      elsif m =~ /^([0O])-([0O])-([0O])([\+#])?$/
+      elsif m =~ LONG_CASTLING_REGEXP
         if self.board.active_color # black king long castling
-          return { name: 'K', dis: '', from: 'e8', to: 'c8', promotion: '' }
+          return { name: 'K', dis: nil, from: 'e8', to: 'c8', promotion: nil }
         else # white king long castling
-          return { name: 'K', dis: '', from: 'e1', to: 'c1', promotion: '' }
+          return { name: 'K', dis: nil, from: 'e1', to: 'c1', promotion: nil }
         end
       end
       raise BadNotationError.new(m)
     end
 
   end
+
+  private
+
+  MOVE_REGEXP = /^([RNBQK])?([a-h]|[1-8]|[a-h][1-8])?(?:x)?([a-h][1-8])(?:=?([RrNnBbQq]))?(?:ep)?(?:\+|\#)?$/
+  SHORT_CASTLING_REGEXP = /^([0O])-([0O])([\+#])?$/
+  LONG_CASTLING_REGEXP = /^([0O])-([0O])-([0O])([\+#])?$/
+
 end