chess 0.1.3 → 0.1.4

data/ext/board.h

@@ -43,7 +43,7 @@ bboard* get_piece_bitboard (Board *board, char piece);
 bboard* get_bitboard (Board *board, int square);
 bboard xray (Board *board, int from, bool only_attack);
 bboard all_xray (Board *board, int color, bool only_attack);
-bboard all_xray_friend (Board *board, int color, bool only_attack);
+bboard all_xray_without_friends (Board *board, int color, bool only_attack);
 void remove_piece (Board *board, int square, Board *new_board);
 int same_pieces_that_can_capture_a_square (Board *board, int color, int square, int *pieces, char piece_filter);
 bool capture (Board *board, int color, int square);
@@ -52,9 +52,11 @@ bool king_in_check (Board *board, int color);
 bool king_in_checkmate (Board *board, int color);
 bool stalemate (Board *board, int color);
 bool insufficient_material (Board *board);
+bool only_kings (Board *board);
 bool fifty_move_rule (Board *board);
+bool invalid_promotion (Board *board, int from, int to);
 bool pseudo_legal_move (Board *board, int from, int to);
-void get_coord (Board *board, char piece, const char* disambiguating, const char *to_coord, char promote_in, int *from, int *to);
+bool get_coord (Board *board, char piece, const char* disambiguating, const char *to_coord, char promote_in, int *from, int *to);
 bool try_move (Board *board, int from, int to, char promote_in, Board *new_board, char **move_done, char *capture);
 char* get_notation (Board *board, int from, int to, int capture, int ep, char promotion, int check, int checkmate);
 char* to_fen (Board *board);

data/ext/chess.c

@@ -26,13 +26,12 @@ game_alloc (VALUE class)
 }
 
 /*
- * call-seq: set_fen!(fen)
- *
- * Set the game position with a FEN string.
- *
- * Parameters are:
- * +fen+:: the FEN (Forsyth–Edwards Notation) string notation used to set the
- *         game position.
+ * @overload set_fen!(fen)
+ *   Set the game position by FEN string.
+ *   @param [String] fen The FEN (Forsyth–Edwards Notation) string notation used
+ *     to set the game position.
+ *   @return [Game] Returns `self` with position of the pieces corresponding to
+ *     the FEN string.
  */
 VALUE
 game_set_fen (VALUE self, VALUE fen)
@@ -44,32 +43,30 @@ game_set_fen (VALUE self, VALUE fen)
 }
 
 /*
- * call-seq: move(piece, disambiguating, to_coord, promote_in)
- *
- * Make a move. This add a new Board in the Game.
- *
- * Parameters are:
- * +piece+:: the character of the moving piece <em>('P', 'R', 'N', 'B', 'Q', 'K')</em>.
- * +disambiguating+:: when two (or more) identical pieces can move to the same
- *                    square, the moving piece is uniquely identified by
- *                    specifying the piece's letter, followed by (in descending
- *                    order of preference):
- *                    * the file of departure (if they differ); or
- *                    * the rank of departure (if the files are the same but
- *                      the ranks differ); or
- *                    * both the rank and file (if neither alone is
- *                      sufficient to identify the piece—which occurs only in
- *                      rare cases where one or more pawns have promoted,
- *                      resulting in a player having three or more identical
- *                      pieces able to reach the same square).
- *                    Keep blank if no needed.
- * +to_coord+:: the square where the moving piece will <em>('a1', 'a2', ... , 'h7', 'h8')</em>.
- * +promote_in+:: the character of promotion piece <em>('R', 'N', 'B', 'Q')</em>.
- *                If no promotion occured, this param will be ignored. If no
- *                value is passed, 'Q' is the default.
- *
- * This method returns a string that represents the short algebraic chess
- * notation of the move or raise an IllegalMoveError if the move is illegal.
+ * @overload move(piece, disambiguating, to_coord, promote_in)
+ *   Make a move.
+ *   @note This add a new {Board} in the {Game}.
+ *   @param [String] piece The character of the moving piece _('P', 'R', 'N',
+ *     'B', 'Q', 'K')_.
+ *   @param [String] disambiguating When two (or more) identical pieces can move
+ *     to the same square, the moving piece is uniquely identified by specifying
+ *     the piece's letter, followed by (in descending order of preference):
+ *
+ *     * the file of departure (if they differ);
+ *     * the rank of departure (if the files are the same but the ranks differ);
+ *     * both the rank and file (if neither alone is sufficient to identify the
+ *       piece—which occurs only in rare cases where one or more pawns have
+ *       promoted, resulting in a player having three or more identical pieces
+ *       able to reach the same square).
+ *     Keep `nil` if no needed.
+ *   @param [String] to_coord The square where the moving piece will _('a1',
+ *     'a2', ... , 'h7', 'h8')_.
+ *   @param [String] promote_in The character of promotion piece _('R', 'N',
+ *     'B', 'Q')_. If not `nil` and no promotion occured raise an
+ *     {IllegalMoveError}. If `nil`, _'Q'_ is the default.
+ *   @return [String] Returns a string that represents the short algebraic chess
+ *     notation of the move.
+ *   @raise [IllegalMoveError]
  */
 VALUE
 game_move (VALUE self, VALUE rb_piece, VALUE rb_disambiguating, VALUE rb_to_coord, VALUE rb_promote_in)
@@ -78,34 +75,33 @@ game_move (VALUE self, VALUE rb_piece, VALUE rb_disambiguating, VALUE rb_to_coor
   Data_Get_Struct (self, Game, g);
   Board *board = current_board (g);
   char piece = StringValuePtr (rb_piece)[0];
-  char *disambiguating = StringValuePtr (rb_disambiguating);
+  char *disambiguating = rb_disambiguating == Qnil ? NULL : StringValuePtr (rb_disambiguating);
   char *to_coord = StringValuePtr (rb_to_coord);
-  char promote_in = StringValuePtr (rb_promote_in)[0];
+  char promote_in = rb_promote_in == Qnil ? '\0' : StringValuePtr (rb_promote_in)[0];
   int from, to;
-  get_coord (board, piece, disambiguating, to_coord, promote_in, &from, &to);
-  // printf ("From: %d, To: %d, Promo: %c\n", from , to , promote_in);
-  if (pseudo_legal_move (board, from, to) && apply_move (g, from, to, promote_in))
+  if (
+    get_coord (board, piece, disambiguating, to_coord, promote_in, &from, &to) &&
+    apply_move (g, from, to, promote_in)
+  )
     return rb_str_new2 (current_move (g));
   else
     rb_raise (illegal_move_error, "Illegal move");
 }
 
 /*
- * call-seq: move2(from, to, promote_in)
- *
- * Make a move. This add a new Board in the Game.
- *
- * Parameters are:
- * +from+:: the 2 character string representing the starting square of the
- *          moving piece <em>('a1', 'a2', ... , 'h7', 'h8')</em>.
- * +to+:: the 2 character string representing the ending square of the moving
- *        piece <em>('a1', 'a2', ... , 'h7', 'h8')</em>.
- * +promote_in+:: the character of promotion piece <em>('R', 'N', 'B', 'Q')</em>.
- *                If no promotion occured, this param will be ignored. If no
- *                value is passed, 'Q' is the default.
- *
- * This method returns a string that represents the short algebraic chess
- * notation of the move or raise an IllegalMoveError if the move is illegal.
+ * @overload move2(from, to, promote_in)
+ *   Make a move.
+ *   @note This add a new {Board} in the {Game}.
+ *   @param [String] from The 2 character string representing the starting
+ *     square of the moving piece _('a1', 'a2', ... , 'h7', 'h8')_.
+ *   @param [String] to The 2 character string representing the ending square of
+ *     the moving piece _('a1', 'a2', ... , 'h7', 'h8')_.
+ *   @param [String] promote_in The character of promotion piece _('R', 'N',
+ *     'B', 'Q')_. If not `nil` and no promotion occured raise an
+ *     {IllegalMoveError}. If `nil`, _'Q'_ is the default.
+ *   @return [String] Returns a string that represents the short algebraic chess
+ *     notation of the move.
+ *   @raise [IllegalMoveError]
  */
 VALUE
 game_move2 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
@@ -115,7 +111,7 @@ game_move2 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
   Board *board = current_board (g);
   int from = coord_to_square (StringValuePtr (rb_from));
   int to = coord_to_square (StringValuePtr (rb_to));
-  char promote_in = StringValuePtr (rb_promote_in)[0];
+  char promote_in = rb_promote_in == Qnil ? '\0' : StringValuePtr (rb_promote_in)[0];
   if (pseudo_legal_move (board, from, to) && apply_move (g, from, to, promote_in))
     return rb_str_new2 (current_move (g));
   else
@@ -123,32 +119,33 @@ game_move2 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
 }
 
 /*
- * call-seq: move3(from, to, promote_in)
- *
- * Make a move. This add a new Board in the Game.
- *
- * Each square on the chessboard is represented by an integer according to the
- * following scheme:
- *    8 | 56 57 58 59 60 61 62 63
- *    7 | 48 49 50 51 52 53 54 55
- *    6 | 40 41 42 43 44 45 46 47
- *    5 | 32 33 34 35 36 37 38 39
- *    4 | 24 25 26 27 28 29 30 31
- *    3 | 16 17 18 19 20 21 22 23
- *    2 |  8  9 10 11 12 13 14 15
- *    1 |  0  1  2  3  4  5  6  7
- *      +-------------------------
- *         a  b  c  d  e  f  g  h
- *
- * Parameters are:
- * +from+:: the integer representing the starting square of the moving piece.
- * +to+:: the integer representing the ending square of the moving piece.
- * +promote_in+:: the character of promotion piece <em>('R', 'N', 'B', 'Q')</em>.
- *                If no promotion occured, this param will be ignored. If no
- *                value is passed, 'Q' is the default.
- *
- * This method returns a string that represents the short algebraic chess
- * notation of the move or raise an IllegalMoveError if the move is illegal.
+ * @overload move3(from, to, promote_in)
+ *   Make a move.
+ *   Each square on the chessboard is represented by an integer according to the
+ *   following scheme:
+ *
+ *       8 | 56 57 58 59 60 61 62 63
+ *       7 | 48 49 50 51 52 53 54 55
+ *       6 | 40 41 42 43 44 45 46 47
+ *       5 | 32 33 34 35 36 37 38 39
+ *       4 | 24 25 26 27 28 29 30 31
+ *       3 | 16 17 18 19 20 21 22 23
+ *       2 |  8  9 10 11 12 13 14 15
+ *       1 |  0  1  2  3  4  5  6  7
+ *         +-------------------------
+ *            a  b  c  d  e  f  g  h
+ *
+ *   @note This add a new {Board} in the {Game}.
+ *   @param [Integer] from The integer representing the starting square of the
+ *     moving piece.
+ *   @param [Integer] to The integer representing the ending square of the
+ *     moving piece.
+ *   @param [String] promote_in The character of promotion piece _('R', 'N',
+ *     'B', 'Q')_. If not `nil` and no promotion occured raise an
+ *     {IllegalMoveError}. If `nil`, _'Q'_ is the default.
+ *   @return [String] Returns a string that represents the short algebraic chess
+ *     notation of the move.
+ *   @raise [IllegalMoveError]
  */
 VALUE
 game_move3 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
@@ -158,7 +155,7 @@ game_move3 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
   Board *board = current_board (g);
   int from = FIX2INT (rb_from);
   int to = FIX2INT (rb_to);
-  char promote_in = StringValuePtr (rb_promote_in)[0];
+  char promote_in = rb_promote_in == Qnil ? '\0' : StringValuePtr (rb_promote_in)[0];
   if (pseudo_legal_move (board, from, to) && apply_move (g, from, to, promote_in))
     return rb_str_new2 (current_move (g));
   else
@@ -166,14 +163,12 @@ game_move3 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
 }
 
 /*
- * call-seq: resign(color)
- *
- * The game result is set to '1-0' if +color+ is "black", otherwise is set to
- * '0-1' if color is "white".
- *
- * Parameters are:
- * +color+:: the color of the player who resigns the game; it can be +:white+ or
- *           +:black+.
+ * @overload resign(color)
+ *   The game result is set to '1-0' if `color` is _black_, otherwise is set to
+ *   '0-1' if color is _white_.
+ *   @param [String,Symbol] color The color of the player who resigns the game;
+ *     it can be `:white` or `:black`.
+ *   @return [nil]
  */
 VALUE
 game_resign (VALUE self, VALUE color)
@@ -193,9 +188,9 @@ game_resign (VALUE self, VALUE color)
 }
 
 /*
- * call-seq: draw
- *
- * The game result is set to draw.
+ * @overload draw
+ *   The game result is set to draw.
+ *   @return [nil]
  */
 VALUE
 game_draw (VALUE self)
@@ -207,10 +202,10 @@ game_draw (VALUE self)
 }
 
 /*
- * call-seq: [n]
- *
- * Returns the +n+-th Board of the Game or +nil+ if the +n+-th Board does not
- * exist.
+ * @overload [](n)
+ *   Returns the `n`-th {Board} of the {Game} or `nil` if the `n`-th {Board}
+ *   does not exist.
+ *   @return [Board]
  */
 VALUE
 game_boards (VALUE self, VALUE index)
@@ -225,10 +220,10 @@ game_boards (VALUE self, VALUE index)
 }
 
 /*
- * call-seq: current
- *
- * Returns the current Board of the Game (the current chess position of the
- * game).
+ * @overload current
+ *   Returns the current {Board} of the {Game} (the current chess position of
+ *   the game).
+ *   @return [Board]
  */
 VALUE
 game_current_board (VALUE self)
@@ -239,9 +234,9 @@ game_current_board (VALUE self)
 }
 
 /*
- * call-seq: moves
- *
- * Returns the array with all moves done <em>(es: Nc3)</em>.
+ * @overload moves
+ *   Returns the array with all moves done _(es: Nc3)_.
+ *   @return [Array<String>]
  */
 VALUE
 game_moves (VALUE self)
@@ -255,9 +250,10 @@ game_moves (VALUE self)
 }
 
 /*
- * call-seq: coord_moves
- *
- * Returns the array with all moves done in coordinate chess notation <em>(es: b1c3)</em>.
+ * @overload coord_moves
+ *   Returns the array with all moves done in coordinate chess notation _(es:
+ *   b1c3)_.
+ *   @return [Array<String>]
  */
 VALUE
 game_coord_moves (VALUE self)
@@ -271,7 +267,8 @@ game_coord_moves (VALUE self)
 }
 
 /*
- * :nodoc:
+ * @overload full_moves
+ *   @deprecated Use {#coord_moves} instead.
  */
 VALUE
 game_full_moves (VALUE self)
@@ -281,10 +278,9 @@ game_full_moves (VALUE self)
 }
 
 /*
- * call-seq: threefold_repetition?
- *
- * Returns +true+ if a player can claim draw by the threefold repetition rule,
- * +false+ otherwise.
+ * @overload threefold_repetition?
+ *   Returns `true` if a player can claim draw by the threefold repetition rule,
+ *   `false` otherwise.
  */
 VALUE
 game_threefold_repetition (VALUE self)
@@ -298,13 +294,14 @@ game_threefold_repetition (VALUE self)
 }
 
 /*
- * call-seq: result
- *
- * Returns the result of the game:
- * *:: game in progress;
- * 1-0:: white won;
- * 0-1:: black won;
- * 1/2-1/2:: draw
+ * @overload result
+ *   Returns the result of the game.
+ *   @return [String] Returns the result of the game:
+ *
+ *     * `*`: game in progress;
+ *     * `1-0`: white won;
+ *     * `0-1`: black won;
+ *     * `1/2-1/2`: draw.
  */
 VALUE
 game_result (VALUE self)
@@ -318,9 +315,9 @@ game_result (VALUE self)
 }
 
 /*
- * call-seq: size
- *
- * Returns the number of moves done.
+ * @overload size
+ *   Returns the number of moves done.
+ *   @return [Integer]
  */
 VALUE
 game_size (VALUE self)
@@ -331,11 +328,13 @@ game_size (VALUE self)
 }
 
 /*
- * call-seq: each { |board, move, coord_move, index| block }
- *
- * Calls +block+ once for each +board+ in self, passing that
- * +board+, +move+, +coord_move+ and +index+ as parameters. Return self.
- * If no block is given, the array of game moves is returned instead.
+ * @overload each
+ *   Cycle the {Game}.
+ *   @yield [board, move, coord_move, index]
+ *     Calls `block` once for each {Board} in `self`, passing that
+ *     `board`, `move`, `coord_move` and `index` as parameters.
+ *   @return [Game] Returns `self` if a block is given.
+ *   @return [Array<String>] Returns the array of game moves if no block is given.
  */
 VALUE
 game_each (VALUE self)
@@ -354,9 +353,9 @@ game_each (VALUE self)
 }
 
 /*
- * call-seq: rollback!
- *
- * Rollback last move.
+ * @overload rollback!
+ *   Rollback last move.
+ *   @return [Game] Returns `self` with last move cancelled.
  */
 VALUE
 game_rollback (VALUE self)
@@ -368,9 +367,9 @@ game_rollback (VALUE self)
 }
 
 /*
- * call-seq: to_s
- *
- * Current board to string.
+ * @overload to_s
+ *   Current {Board} to string.
+ *   @return [String]
  */
 VALUE
 game_to_s (VALUE self)
@@ -387,11 +386,13 @@ game_to_s (VALUE self)
 // Board
 
 /*
- * call-seq: placement { |piece, index| block }
- *
- * Calls +block+ once for each square in the board, passing the
- * +piece+ in the square and the +index+ as parameters. Return self.
- * If no block is given, the array of pieces is returned instead.
+ * @overload placement
+ *   Cycle the {Board} squares.
+ *   @yield [piece, index]
+ *     Calls `block` once for each square in the {Board}, passing the `piece` in
+ *     the square and the `index` as parameters.
+ *   @return [Board] Returns `self` if a block is given.
+ *   @return [Array<String>] Returns the array of pieces if no block is given.
  */
 VALUE
 board_placement (VALUE self)
@@ -420,27 +421,27 @@ board_placement (VALUE self)
 }
 
 /*
- * call-seq: [square]
- *
- * Returns the piece on the +square+ of the chessboard. If there is no piece or
- * the square is not valid return +nil+.
- *
- * Each square on the chessboard is represented by an integer according to the
- * following scheme:
- *    8 | 56 57 58 59 60 61 62 63
- *    7 | 48 49 50 51 52 53 54 55
- *    6 | 40 41 42 43 44 45 46 47
- *    5 | 32 33 34 35 36 37 38 39
- *    4 | 24 25 26 27 28 29 30 31
- *    3 | 16 17 18 19 20 21 22 23
- *    2 |  8  9 10 11 12 13 14 15
- *    1 |  0  1  2  3  4  5  6  7
- *      +-------------------------
- *         a  b  c  d  e  f  g  h
- *
- * Parameters are:
- * +square+:: the square of the board. Can be an integer between 0 and 63 or a
- *            string like 'a2', 'c5'...
+ * @overload [](square)
+ *   Returns the piece on the `square` of the chessboard. If there is no piece
+ *   or the square is not valid return `nil`.
+ *   Each square on the chessboard is represented by an integer according to the
+ *   following scheme:
+ *
+ *       8 | 56 57 58 59 60 61 62 63
+ *       7 | 48 49 50 51 52 53 54 55
+ *       6 | 40 41 42 43 44 45 46 47
+ *       5 | 32 33 34 35 36 37 38 39
+ *       4 | 24 25 26 27 28 29 30 31
+ *       3 | 16 17 18 19 20 21 22 23
+ *       2 |  8  9 10 11 12 13 14 15
+ *       1 |  0  1  2  3  4  5  6  7
+ *         +-------------------------
+ *            a  b  c  d  e  f  g  h
+ *
+ *   @param [Integer,String] square The square of the {Board}. Can be an integer
+ *     between 0 and 63 or a string like 'a2', 'c5'...
+ *   @return [String] The symbol that identify the piece _('P', 'R', 'N', 'B',
+ *     'Q', 'K')_. Upcase for a white piece, downcase for a black piece.
  */
 VALUE
 board_get_piece (VALUE self, VALUE square)
@@ -460,10 +461,9 @@ board_get_piece (VALUE self, VALUE square)
 }
 
 /*
- * call-seq: check?
- *
- * Returns +true+ if the king of the color that has the turn is in check,
- * +false+ otherwise.
+ * @overload check?
+ *   Returns `true` if the king of the color that has the turn is in check,
+ *   `false` otherwise.
  */
 VALUE
 board_king_in_check (VALUE self)
@@ -477,10 +477,9 @@ board_king_in_check (VALUE self)
 }
 
 /*
- * call-seq: checkmate?
- *
- * Returns +true+ if the king of the color that has the turn is in checkmate,
- * +false+ otherwise.
+ * @overload checkmate?
+ *   Returns `true` if the king of the color that has the turn is in checkmate,
+ *   `false` otherwise.
  */
 VALUE
 board_king_in_checkmate (VALUE self)
@@ -494,10 +493,9 @@ board_king_in_checkmate (VALUE self)
 }
 
 /*
- * call-seq: stalemate?
- *
- * Returns +true+ if the pieces of the color that has the turn are in stalemate,
- * +false+ otherwise.
+ * @overload stalemate?
+ *   Returns `true` if the pieces of the color that has the turn are in
+ *   stalemate, `false` otherwise.
  */
 VALUE
 board_stalemate (VALUE self)
@@ -511,10 +509,9 @@ board_stalemate (VALUE self)
 }
 
 /*
- * call-seq: insufficient_material?
- *
- * Returns +true+ if the board has insufficient material to checkmate, +false+
- * otherwise.
+ * @overload insufficient_material?
+ *   Returns `true` if the board has insufficient material to checkmate, `false`
+ *   otherwise.
  */
 VALUE
 board_insufficient_material (VALUE self)
@@ -528,10 +525,25 @@ board_insufficient_material (VALUE self)
 }
 
 /*
- * call-seq: fifty_move_rule?
- *
- * Returns +true+ if a player can claim draw by the fifty-move rule, +false+
- * otherwise.
+ * @overload only_kings?
+ *   Returns `true` if on the board there are only the two kings, `false`
+ *   otherwise.
+ */
+VALUE
+board_only_kings (VALUE self)
+{
+  Board *board;
+  Data_Get_Struct (self, Board, board);
+  if (only_kings (board))
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+/*
+ * @overload fifty_move_rule?
+ *   Returns `true` if a player can claim draw by the fifty-move rule, `false`
+ *   otherwise.
  */
 VALUE
 board_fifty_move_rule (VALUE self)
@@ -545,9 +557,10 @@ board_fifty_move_rule (VALUE self)
 }
 
 /*
- * call-seq: active_color
- *
- * Returns the active color: +false+ means white turn, +true+ means black turn.
+ * @overload active_color
+ *   Returns the active color: `false` means white turn, `true` means black
+ *   turn.
+ *   @return [Boolean]
  */
 VALUE
 board_active_color (VALUE self)
@@ -561,11 +574,11 @@ board_active_color (VALUE self)
 }
 
 /*
- * call-seq: halfmove_clock
- *
- * Returns the halfmove clock that is the number of halfmoves since the last
- * pawn advance or capture. This is used to determine if a draw can be claimed
- * under the fifty-move rule.
+ * @overload halfmove_clock
+ *   Returns the halfmove clock that is the number of halfmoves since the last
+ *   pawn advance or capture. This is used to determine if a draw can be claimed
+ *   under the fifty-move rule.
+ *   @return [Integer]
  */
 VALUE
 board_halfmove_clock (VALUE self)
@@ -576,10 +589,10 @@ board_halfmove_clock (VALUE self)
 }
 
 /*
- * call-seq: fullmove_number
- *
- * Returns the fullmove number: the number of the full move. It starts at 1, and
- * is incremented after black's move.
+ * @overload fullmove_number
+ *   Returns the fullmove number: the number of the full move. It starts at 1,
+ *   and * is incremented after black's move.
+ *   @return [Integer]
  */
 VALUE
 board_fullmove_number (VALUE self)
@@ -590,9 +603,9 @@ board_fullmove_number (VALUE self)
 }
 
 /*
- * call-seq: to_fen
- *
- * Return the FEN string of the board.
+ * @overload to_fen
+ *   Returns the FEN string of the board.
+ *   @return [String]
  */
 VALUE
 board_to_fen (VALUE self)
@@ -606,9 +619,9 @@ board_to_fen (VALUE self)
 }
 
 /*
- * call-seq: to_s
- *
- * Board to string.
+ * @overload to_s
+ *   {Board} to string.
+ *   @return [String]
  */
 VALUE
 board_to_s (VALUE self)
@@ -630,6 +643,8 @@ Init_chess ()
   VALUE chess = rb_define_module ("Chess");
 
   /*
+   * Document-class: Chess::CGame
+   *
    * This class rappresents a collection of boards of a single chess game.
    */
   VALUE game = rb_define_class_under (chess, "CGame", rb_cObject);
@@ -654,6 +669,8 @@ Init_chess ()
   rb_define_alias (game, "board", "current");
 
   /*
+   * Document-class: Chess::Board
+   *
    * This class rappresents a chess board.
    * The rappresentation of the board use _bitboards_ where each bit represents
    * a game position or state, designed for optimization of speed and/or memory
@@ -667,6 +684,7 @@ Init_chess ()
   rb_define_method (board_klass, "checkmate?", board_king_in_checkmate, 0);
   rb_define_method (board_klass, "stalemate?", board_stalemate, 0);
   rb_define_method (board_klass, "insufficient_material?", board_insufficient_material, 0);
+  rb_define_method (board_klass, "only_kings?", board_only_kings, 0);
   rb_define_method (board_klass, "fifty_rule_move?", board_fifty_move_rule, 0);
   rb_define_method (board_klass, "active_color", board_active_color, 0);
   rb_define_method (board_klass, "halfmove_clock", board_halfmove_clock, 0);
@@ -675,6 +693,8 @@ Init_chess ()
   rb_define_method (board_klass, "to_s", board_to_s, 0);
 
   /*
+   * Document-class: Chess::IllegalMoveError
+   *
    * This exception will be raised when making an illegal move.
    */
   illegal_move_error = rb_define_class_under (chess, "IllegalMoveError", rb_eStandardError);