chess 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1b122a9e2e4ddaf1384bb4436f27d657c0691fd
-  data.tar.gz: 806cded3d3289d7766774e898315634698bd94e4
+  metadata.gz: 72831c5ff5567709d9ce1e377c98d7867b35b611
+  data.tar.gz: 0af6a358a253414ad636d9fec050eb1dd5ccfbc9
 SHA512:
-  metadata.gz: 8613eb5ba2e25085ac2988f8184e4ad2b961e26846c1bc62aade2a7d1bc28162a904c921ce3b6d46f52a03a4b9fc5cc12cc7d01edc0fb75ab11eb68c7ef9aa48
-  data.tar.gz: 0e57bca085a33d11f4ebc0690cfa04da76472cb432b2b96a35d01c27c65e035794f154c8c317a3632e239c0622827a52410f938f036def5ff6a0096adaf792b7
+  metadata.gz: cf1c0fc216c2e2a76e978b96c4e668eed29d23eef23606280075b58d42a717b27d1fdfe50c1dae6961ffac71d4272ada39c6a3f8a8e2b69d5b16a33c24114abe
+  data.tar.gz: 3544641ba2184d3965574c912472defad0e49020c650ae9f2a342683dddd02b81ced292156c3828d987b6001f5e8993a252c4950bc56bd965de827d5f858e03e

data/.gitignore

@@ -1,5 +1,7 @@
 *.gem
 .bundle
+.yardoc/
+doc/
 ext/chess
 ext/Makefile
 ext/*.bundle

data/README.md

@@ -0,0 +1,44 @@
+# Chess
+
+A fast Ruby library to play chess with Ruby. This library is quite fast
+because rappresent the game situations with bitboards. In addition, the move
+generator is written in C as a Ruby extension.
+
+## Requirements
+
+*   Ruby 1.9 or higher
+
+## Installation
+
+    gem install chess
+
+## Usage
+
+    require 'chess'
+    g = Chess::Game.new
+    until g.over?
+      begin
+        print "Give me a #{g.active_player} move: "
+        input = gets.chop
+        break if input == 'quit'
+        g << input
+        puts g
+        puts g.moves.last
+      rescue Chess::IllegalMoveError => e
+        puts 'Illegal move!'
+      end
+    end
+    puts g.status
+
+**Documentation** is available [here](http://pioz.github.com/chess).
+
+## Questions or problems?
+
+If you have any issues please add an [issue on
+GitHub](https://github.com/pioz/chess/issues) or fork the project and send a
+pull request.
+
+## Copyright
+
+Copyright (c) 2017 [Enrico Pilotto (@pioz)](https://github.com/pioz). See
+[LICENSE](https://github.com/pioz/chess/blob/master/LICENSE) for details.

data/Rakefile

@@ -1,12 +1,11 @@
 require 'bundler/gem_tasks'
 
-require 'rdoc/task'
-Rake::RDocTask.new do |rd|
-  rd.title = 'Chess'
-  rd.main = 'README.rdoc'
-  rd.rdoc_dir = 'doc'
-  rd.rdoc_files.include('README.rdoc', 'lib/**/*.rb', 'ext/*.c')
-  rd.generator = 'darkfish'
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+ t.files = ['lib/**/*.rb', 'ext/*.c']
+ t.options << '-rREADME.md'
+ t.options << '--title=Chess'
+ t.options << '-mmarkdown'
 end
 
 require 'rake/testtask'

data/chess.gemspec

@@ -24,5 +24,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'bundler', '~> 1.14'
   s.add_development_dependency 'rake', '~> 12.0'
   s.add_development_dependency 'minitest', '~> 5.10'
-  s.add_development_dependency 'rdoc', '~> 5.1'
+  s.add_development_dependency 'yard', '~> 0.9'
 end

data/ext/bitboard.c

@@ -73,12 +73,15 @@ const bboard AVOID_WRAP[8] =
 };
 
 // Bitboard getters
+
+// Given file and rank returns the square (0..63).
 int
 square (int file, int rank)
 {
   return 8 * rank + file;
 }
 
+// Given a bitboard returns the first square (0..63) with a piece.
 int
 square2 (bboard b)
 {
@@ -91,6 +94,7 @@ square2 (bboard b)
   return pos;
 }
 
+// Returns the array and its size (n) with pieces in the bitboard.
 void
 squares (bboard b, int *array, int *n)
 {
@@ -103,29 +107,36 @@ squares (bboard b, int *array, int *n)
       }
 }
 
+// Given a square returns the corresponding file.
 int
 file (int square)
 {
   return square & 7;
 }
 
+// Given a square returns the corresponding rank.
 int rank (int square)
 {
   return square >> 3;
 }
 
+// Given a bitboard and a square (0..63) returns a bitboard copy with square set
+// to 1.
 bboard
 get (bboard b, int square)
 {
   return b & (1ULL << square);
 }
 
+// Given a bitboard, a file and a rank returns a bitboard copy with square set
+// to 1.
 bboard
 get2 (bboard b, int file, int rank)
 {
   return b & (1ULL << (8 * rank + file));
 }
 
+// Print the bitboard.
 void
 print_bitboard (bboard b)
 {
@@ -139,24 +150,28 @@ print_bitboard (bboard b)
 
 // Bitboard manipulations
 
+// Returns true if the bitboard has only one bit equals to 1.
 bboard
 has_only_one_one (bboard b)
 {
   return b && !(b & (b-1));
 }
 
+// Returns true if the bitboard has only bits equals to 1 in the white squares.
 bboard
 only_white_squares (bboard b)
 {
   return !((b ^ WHITE_SQUARES) & b);
 }
 
+// Returns true if the bitboard has only bits equals to 1 in the black squares.
 bboard
 only_black_squares (bboard b)
 {
   return !((b ^ BLACK_SQUARES) & b);
 }
 
+// Returns the horizontally mirrored bitboard.
 bboard
 mirror_horizontal (bboard b)
 {
@@ -169,6 +184,7 @@ mirror_horizontal (bboard b)
   return b;
 }
 
+// Returns the vertically mirrored bitboard.
 bboard
 mirror_vertical (bboard b)
 {
@@ -180,6 +196,7 @@ mirror_vertical (bboard b)
   return b;
 }
 
+// Returns the left rotated bitboard.
 bboard
 rotate_left (bboard b, int s)
 {
@@ -188,6 +205,7 @@ rotate_left (bboard b, int s)
   return s > 0 ? b << s : b >> -s;
 }
 
+// Returns the right rotated bitboard.
 bboard
 rotate_right (bboard b, int s)
 {
@@ -196,6 +214,8 @@ rotate_right (bboard b, int s)
   return s > 0 ? b >> s : b << -s;
 }
 
+// Given a generator, a propagator and a direction returns the bitboard with
+// occluded squares setted to 1.
 bboard
 occluded_fill (bboard gen, bboard pro, int dir)
 {
@@ -209,12 +229,14 @@ occluded_fill (bboard gen, bboard pro, int dir)
    return gen;
 }
 
+// Returns the shifted bitboard.
 bboard
 shift_one (bboard b, int dir)
 {
   return rotate_left (b, DIR[dir]) & AVOID_WRAP[dir];
 }
 
+// Returns the bitboard with sliding attacks.
 bboard
 sliding_attacks (bboard slider, bboard propagator, int dir)
 {
@@ -223,6 +245,7 @@ sliding_attacks (bboard slider, bboard propagator, int dir)
 }
 
 // Pre-calculators
+
 void
 precalculate_xray_attack_white_pawn (bboard xray[64])
 {
@@ -281,6 +304,7 @@ precalculate_all_xray ()
 }
 
 // XRay generators
+
 bboard
 xray_white_pawn (bboard occupied_square, int square)
 {

data/ext/board.c

@@ -7,6 +7,7 @@
 
 #include "board.h"
 
+// Initialize the board
 void
 init_board (Board *board)
 {
@@ -32,6 +33,7 @@ init_board (Board *board)
   set_occupied (board);
 }
 
+// Set helpers bitboards (white pieces, black pieces, occupied squares).
 void
 set_occupied (Board *board)
 {
@@ -50,6 +52,7 @@ set_occupied (Board *board)
   board->occupied = board->pieces[WHITE] | board->pieces[BLACK];
 }
 
+// Board to string.
 char*
 print_board (Board *board)
 {
@@ -72,6 +75,7 @@ print_board (Board *board)
   return s;
 }
 
+// Given a square returns its color (white is 0, black is 1).
 int
 get_color (Board *board, int square)
 {
@@ -85,6 +89,7 @@ get_color (Board *board, int square)
     return -1;
 }
 
+// Given a piece returns the piece's bitboard.
 bboard*
 get_piece_bitboard (Board *board, char piece)
 {
@@ -107,12 +112,15 @@ get_piece_bitboard (Board *board, char piece)
     }
 }
 
+// Given a square (0..63) retuns the piece's bitboard in that square.
 bboard*
 get_bitboard (Board *board, int square)
 {
   return get_piece_bitboard (board, board->placement[square]);
 }
 
+// Returns the bitboard with the xray that start from square. If only_attack use
+// only pawns attack squares.
 bboard
 xray (Board *board, int from, bool only_attack)
 {
@@ -140,7 +148,8 @@ xray (Board *board, int from, bool only_attack)
     }
 }
 
-// All xray of color pieces
+
+// Returns the bitboard with all the xray that start from the color pieces.
 bboard
 all_xray (Board *board, int color, bool only_attack)
 {
@@ -155,13 +164,15 @@ all_xray (Board *board, int color, bool only_attack)
   return x;
 }
 
-// All xray of color pieces with friends square removed
+// Returns the bitboard with all the xray that start from the color pieces with
+// friend squares removed.
 bboard
-all_xray_friend (Board *board, int color, bool only_attack)
+all_xray_without_friends (Board *board, int color, bool only_attack)
 {
   return all_xray (board, color, only_attack) & ~board->pieces[color];
 }
 
+// Returns a new board with the piece in square position removed.
 void
 remove_piece (Board *board, int square, Board *new_board)
 {
@@ -174,7 +185,8 @@ remove_piece (Board *board, int square, Board *new_board)
     }
 }
 
-// return the squares of pieces as piece that can capture in to
+// Returns the squares of the same pieces of color and its size that can capture
+// the square. If piece_filter consider only that kind of pieces.
 int
 same_pieces_that_can_capture_a_square (Board *board, int color, int square, int *pieces, char piece_filter)
 {
@@ -195,13 +207,15 @@ same_pieces_that_can_capture_a_square (Board *board, int color, int square, int
   return index;
 }
 
+// Returns true if square can be captured from color pieces.
 bool
 capture (Board *board, int color, int square)
 {
-  return all_xray_friend (board, color, FALSE) & (1ULL << square) ? TRUE : FALSE;
+  return all_xray_without_friends (board, color, FALSE) & (1ULL << square) ? TRUE : FALSE;
 }
 
-// If there is a piece that can capture the to square without put its king in check return true
+// Returns true if there is a piece that can capture the square without put its
+// king in check.
 bool
 pieces_can_safe_capture (Board *board, int color, int square)
 {
@@ -209,20 +223,22 @@ pieces_can_safe_capture (Board *board, int color, int square)
   return same_pieces_that_can_capture_a_square (board, color, square, pieces, 0) > 0;
 }
 
+// Returns true if the king color is in check.
 bool
 king_in_check (Board *board, int color)
 {
-  return all_xray_friend (board, !color, TRUE) & board->king[color] ? TRUE : FALSE;
+  return all_xray_without_friends (board, !color, TRUE) & board->king[color] ? TRUE : FALSE;
 }
 
-// Assumes that king is in check
+// Returns true if the king color is in check. Assumes that the king is in
+// check.
 bool
 king_in_checkmate (Board *board, int color)
 {
   int king_square = square2 (board->king[color]);
   bboard king = xray_king (king_square) & ~board->pieces[color];
   Board board_without_king;
-  remove_piece (board, king_square, &board_without_king); // King cant be auto-shielded xray
+  remove_piece (board, king_square, &board_without_king); // King can't be auto-shielded xray
   bboard attackers = all_xray (&board_without_king, !color, TRUE);
   // If king can move return false
   if (king & ~attackers)
@@ -237,7 +253,8 @@ king_in_checkmate (Board *board, int color)
   if (pieces_can_safe_capture (board, color, attacker))
     return FALSE;
   // Test if there is an en passant capture
-  if (have_en_passant2 (board, attacker))
+  if (have_en_passant (board, attacker + 1, board->en_passant) ||
+      have_en_passant (board, attacker - 1, board->en_passant))
     return FALSE;
   // Test if attack can be shielded
   bboard slide = EMPTY_BOARD;
@@ -249,7 +266,7 @@ king_in_checkmate (Board *board, int color)
         break;
     }
   bboard attack = xray (board, attacker, TRUE) & slide;
-  bboard defend = all_xray_friend (board, color, FALSE);
+  bboard defend = all_xray_without_friends (board, color, FALSE);
   bboard shield = attack & defend;
   if (shield)
     {
@@ -263,6 +280,7 @@ king_in_checkmate (Board *board, int color)
   return TRUE;
 }
 
+// Returns true if the color pieces are in stale.
 bool
 stalemate (Board *board, int color)
 {
@@ -285,6 +303,7 @@ stalemate (Board *board, int color)
   return TRUE;
 }
 
+// Returns true if there are insufficient material to make a checkmate.
 bool
 insufficient_material (Board *board)
 {
@@ -310,15 +329,40 @@ insufficient_material (Board *board)
           || (only_black_squares(board->bishops[WHITE]) && only_black_squares(board->bishops[BLACK])))
         return TRUE;
     }
+  // TODO more bishops on same color square
   return FALSE;
 }
 
+// Returns true if on the board there are only the two kings.
+bool
+only_kings (Board *board)
+{
+  return !board->pawns[WHITE]   && !board->pawns[BLACK] &&
+         !board->rooks[WHITE]   && !board->rooks[BLACK] &&
+         !board->knights[WHITE] && !board->knights[BLACK] &&
+         !board->bishops[WHITE] && !board->bishops[BLACK] &&
+         !board->queens[WHITE]  && !board->queens[BLACK];
+}
+
+// Returns true if fifty move rule is available.
 bool
 fifty_move_rule (Board *board)
 {
   return board->halfmove_clock >= 50;
 }
 
+// Returns true if the move from-to can not promote the pawn.
+bool
+invalid_promotion (Board *board, int from, int to)
+{
+  if (toupper (board->placement[from]) != 'P')
+    return TRUE;
+  if ((board->active_color ? 0xffffffffffffff00 : 0x00ffffffffffffff) & (1ULL << to))
+    return TRUE;
+  return FALSE;
+}
+
+// Returns true if the move from-to is pseudo legal.
 bool
 pseudo_legal_move (Board *board, int from, int to)
 {
@@ -336,7 +380,9 @@ pseudo_legal_move (Board *board, int from, int to)
   return x & (1ULL << to) ? TRUE : FALSE;
 }
 
-void
+// Returns true if the move piece-dis-to is legal. Returns also [from, to]
+// coordinate (0..63). Pseudo legal move check included.
+bool
 get_coord (Board *board, char piece, const char *disambiguating, const char *to_coord, char promote_in, int *from, int *to)
 {
   int count = 0;
@@ -355,10 +401,10 @@ get_coord (Board *board, char piece, const char *disambiguating, const char *to_
             {
               file = square_to_file (i);
               rank = square_to_rank (i);
-              if (!strcmp (disambiguating, "")
-                || disambiguating[0] == file
-                || disambiguating[0] == rank
-                || (disambiguating[0] == file && disambiguating[1] == rank))
+              if (!disambiguating
+                  || disambiguating[0] == file
+                  || disambiguating[0] == rank
+                  || (disambiguating[0] == file && disambiguating[1] == rank))
                 {
                   Board new_board;
                   if (try_move (board, i, *to, promote_in, &new_board, 0, 0))
@@ -371,14 +417,23 @@ get_coord (Board *board, char piece, const char *disambiguating, const char *to_
         }
     }
   if (count != 1)
-    *from = *to = 0;
+    {
+      *from = *to = 0;
+      return FALSE;
+    }
   // For compatibility: if pawn capture a file disambiguating is required
-  else if (piece == 'P' && !strcmp (disambiguating, ""))
-    if (square_to_file (*from) != square_to_file (*to))
+  if (piece == 'P' && !disambiguating && square_to_file (*from) != square_to_file (*to))
+    {
       *from = *to = 0;
+      return FALSE;
+    }
+  return TRUE;
 }
 
-// This function do not consider castling, this is handled separately.
+// Returns true if the move from-to can be performed. Returns also the short
+// algebraic chess notation of the move and the captured piece if occured.
+// Assume that the move is pseudo legal. Do not consider castling, this is
+// handled separately.
 bool
 try_move (Board *board, int from, int to, char promote_in, Board *new_board, char **move_done, char *capture)
 {
@@ -403,10 +458,7 @@ try_move (Board *board, int from, int to, char promote_in, Board *new_board, cha
   new_board->placement[from] = 0;
   // Promotion check
   if (require_a_promotion (new_board))
-    {
-      if (!promote (new_board, to, promote_in))
-        return FALSE;
-    }
+    promote (new_board, to, promote_in);
   else
     promote_in = 0;
   // Set occupied pieces in new board
@@ -420,6 +472,7 @@ try_move (Board *board, int from, int to, char promote_in, Board *new_board, cha
   return TRUE;
 }
 
+// Returns the short algebraic chess notation of the move from-to.
 char*
 get_notation (Board *board, int from, int to, int capture, int ep, char promotion, int check, int checkmate)
 {
@@ -506,6 +559,7 @@ get_notation (Board *board, int from, int to, int capture, int ep, char promotio
   return notation;
 }
 
+// Returns the fen string that rappresent the board.
 char*
 to_fen (Board *board)
 {