chess 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e8d9bcf7754e4c8e0d2b1d4d01c582e0e7b528f
+  data.tar.gz: 6c8c63bd47574c15439dc41ce39203b9aaaf4d01
+SHA512:
+  metadata.gz: cf55d121ea3c0f8d32a146506730f03a277526cdcbf34a2e9a06ca98332354162a5c76ded3d5fbf239a3f7ac150e482e8b7a867fff7ee0359aeac72c97c8915e
+  data.tar.gz: c642b34d64cd9358b1649b03a1197c32850f8620248ee2584a5d3b192284129731a7bd08ca5b26ff96241fbd05d46939208044134a898792ef54ba4a840e63df

data/README.rdoc

@@ -5,6 +5,10 @@ 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
@@ -13,13 +17,13 @@ move generator is written in C as a Ruby extension.
 
   require 'chess'
   g = Chess::Game.new
-  while (!g.over?)
+  until g.over?
     begin
       print "Give me a #{g.active_player} move: "
       input = gets.chop
       break if input == 'quit'
       g << input
-      puts g.board
+      puts g
       puts g.moves.last
     rescue Chess::IllegalMoveError => e
       puts 'Illegal move!'

data/Rakefile

@@ -6,7 +6,7 @@ Rake::RDocTask.new do |rd|
   rd.main = 'README.rdoc'
   rd.rdoc_dir = 'doc'
   rd.rdoc_files.include('README.rdoc', 'lib/**/*.rb', 'ext/*.c')
-  rd.options << '-f' << 'horo'
+  #rd.options << '-f' << 'horo'
 end
 
 require 'rake/testtask'

data/ext/board.c

@@ -408,10 +408,7 @@ try_move (Board *board, int from, int to, char promote_in, Board *new_board, cha
   if (require_a_promotion (new_board))
     {
       if (!promote (new_board, to, promote_in))
-        {
-          free (new_board);
-          return 0;
-        }
+        return FALSE;
     }
   else
     promote_in = 0;

data/ext/chess.c

@@ -18,7 +18,7 @@ VALUE board_klass;
 VALUE
 game_alloc (VALUE class)
 {
-  Game *g = init_game (g);
+  Game *g = init_game ();
   return Data_Wrap_Struct (class, 0, free_game, g);
   // VALUE tdata = Data_Wrap_Struct (class, 0, free_game, g);
   // rb_obj_call_init (tdata, 0, 0);
@@ -83,8 +83,8 @@ game_move (VALUE self, VALUE rb_piece, VALUE rb_disambiguating, VALUE rb_to_coor
  * 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>.
+ * +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.
  * This method returns a string that represents the short algebraic chess notation of the move or raise an IllegalMoveError if the move is illegal.
  */
@@ -120,8 +120,8 @@ game_move2 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
  *      +-------------------------
  *         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.
+ * +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.
  * This method returns a string that represents the short algebraic chess notation of the move or raise an IllegalMoveError if the move is illegal.
  */
@@ -140,6 +140,45 @@ game_move3 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in)
     rb_raise (illegal_move_error, "Illegal move");
 }
 
+/*
+ * 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+.
+ */
+VALUE
+game_resign (VALUE self, VALUE color)
+{
+  Game *g;
+  Data_Get_Struct (self, Game, g);
+  const char *c;
+  if (TYPE (color) == T_SYMBOL)
+    c = rb_id2name (SYM2ID (color));
+  else
+    c = StringValuePtr (color);
+  if (strcmp (c, "black") == 0)
+    g->result = WHITE_WON;
+  else if (strcmp (c, "white") == 0)
+    g->result = BLACK_WON;
+  return Qnil;
+}
+
+/*
+ * call-seq: draw
+ *
+ * The game result is set to draw.
+ */
+VALUE
+game_draw (VALUE self)
+{
+  Game *g;
+  Data_Get_Struct (self, Game, g);
+  g->result = DRAW;
+  return Qnil;
+}
+
 /*
  * call-seq: [n]
  *
@@ -160,10 +199,10 @@ game_boards (VALUE self, VALUE index)
 /*
  * call-seq: current
  *
- * Returns the current Board of the Game.
+ * Returns the current Board of the Game (the current chess position of the game).
  */
 VALUE
-game_last_board (VALUE self)
+game_current_board (VALUE self)
 {
   Game *g;
   Data_Get_Struct (self, Game, g);
@@ -225,8 +264,8 @@ game_threefold_repetition (VALUE self)
  *
  * Returns the result of the game:
  * *:: game in progress;
- * 1-0:: white wins;
- * 0-1:: black wins;
+ * 1-0:: white won;
+ * 0-1:: black won;
  * 1/2-1/2:: draw
  */
 VALUE
@@ -289,19 +328,59 @@ game_rollback (VALUE self)
   return self;
 }
 
+/*
+ * call-seq: to_s
+ *
+ * Current board to string.
+ */
+VALUE
+game_to_s (VALUE self)
+{
+  Game *g;
+  Data_Get_Struct (self, Game, g);
+  Board *b = get_board (g, g->current-1);
+  char *s = print_board (b);
+  VALUE rb_s = rb_str_new2 (s);
+  free (s);
+  return rb_s;
+}
+
 // Board
 
 /*
- * call-seq: [square]
+ * call-seq: placement { |piece, index| block }
  *
- * Return the piece in +square+ of the board.
+ * 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.
  */
 VALUE
-board_get_piece_at (VALUE self, VALUE square)
+board_placement (VALUE self)
 {
   Board *board;
   Data_Get_Struct (self, Board, board);
-  return CHR2FIX (board->placement[NUM2INT (square)]);
+  int i;
+  char piece[2];
+  piece[1] = '\0';
+  if (!rb_block_given_p ())
+    {
+      VALUE placement = rb_ary_new ();
+      for (i = 0; i < 64; i++)
+        {
+          piece[0] = board->placement[i];
+          rb_ary_push (placement, rb_str_new2 (piece));
+        }
+      return placement;
+    }
+  else
+    {
+      for (i = 0; i < 64; i++)
+        {
+          piece[0] = board->placement[i];
+          rb_yield_values (2, rb_str_new2 (piece), INT2FIX (i));
+        }
+      return self;
+    }
 }
 
 /*
@@ -475,8 +554,10 @@ Init_chess ()
   rb_define_method (game, "move", game_move, 4);
   rb_define_method (game, "move2", game_move2, 3);
   rb_define_method (game, "move3", game_move3, 3);
+  rb_define_method (game, "resign", game_resign, 1);
+  rb_define_method (game, "draw", game_draw, 0);
   rb_define_method (game, "[]", game_boards, 1);
-  rb_define_method (game, "board", game_last_board, 0);
+  rb_define_method (game, "current", game_current_board, 0);
   rb_define_method (game, "moves", game_moves, 0);
   rb_define_method (game, "full_moves", game_full_moves, 0);
   rb_define_method (game, "threefold_repetition?", game_threefold_repetition, 0);
@@ -484,6 +565,8 @@ Init_chess ()
   rb_define_method (game, "size", game_size, 0);
   rb_define_method (game, "each", game_each, 0);
   rb_define_method (game, "rollback!", game_rollback, 0);
+  rb_define_method (game, "to_s", game_to_s, 0);
+  rb_define_alias (game, "board", "current");
 
   /*
    * This class rappresents a chess board.
@@ -491,7 +574,7 @@ Init_chess ()
    * This ensures a fast library.
    */
   board_klass = rb_define_class_under (chess, "Board", rb_cObject);
-  rb_define_method (board_klass, "[]", board_get_piece_at, 1);
+  rb_define_method (board_klass, "placement", board_placement, 0);
   rb_define_method (board_klass, "check?", board_king_in_check, 0);
   rb_define_method (board_klass, "checkmate?", board_king_in_checkmate, 0);
   rb_define_method (board_klass, "stalemate?", board_stalemate, 0);

data/ext/chess.h

@@ -15,8 +15,10 @@ VALUE game_set_fen (VALUE self, VALUE fen);
 VALUE game_move (VALUE self, VALUE rb_piece, VALUE rb_disambiguating, VALUE rb_to_coord, VALUE rb_promote_in);
 VALUE game_move2 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in);
 VALUE game_move3 (VALUE self, VALUE rb_from, VALUE rb_to, VALUE rb_promote_in);
+VALUE game_resign (VALUE self, VALUE color);
+VALUE game_draw (VALUE self);
 VALUE game_boards (VALUE self, VALUE index);
-VALUE game_board (VALUE self);
+VALUE game_current_board (VALUE self);
 VALUE game_moves (VALUE self);
 VALUE game_full_moves (VALUE self);
 VALUE game_threefold_repetition (VALUE self);
@@ -24,11 +26,11 @@ VALUE game_result (VALUE self);
 VALUE game_size (VALUE self);
 VALUE game_each (VALUE self);
 VALUE game_rollback (VALUE self);
-
+VALUE game_to_s (VALUE self);
 
 // Board
 
-VALUE board_get_piece_at (VALUE self, VALUE square);
+VALUE board_placement (VALUE self);
 VALUE board_king_in_check (VALUE self);
 VALUE board_king_in_checkmate (VALUE self);
 VALUE board_stalemate (VALUE self);

data/ext/common.c

@@ -59,10 +59,10 @@ result_to_s (unsigned short int r)
   char *s = (char *) malloc (8);
   switch (r)
     {
-    case WHITE_WINS:
+    case WHITE_WON:
       strcpy (s, "1-0");
       break;
-    case BLACK_WINS:
+    case BLACK_WON:
       strcpy (s, "0-1");
       break;
     case DRAW:
@@ -100,7 +100,7 @@ en_passant_to_s (short int en_passant)
   return s;
 }
 
-bool
+int
 compare (const void *a, const void *b)
 {
   return strcmp (*(const char **) a, *(const char **) b);

data/ext/common.h

@@ -90,12 +90,12 @@
 #define BLACK_SHORT_CASTLING 3
 #define BLACK_LONG_CASTLING 4
 
-#define WHITE_WINS 0
-#define BLACK_WINS 1
+#define WHITE_WON 0
+#define BLACK_WON 1
 #define DRAW 2
 #define IN_PROGRESS 3
 
-typedef int bool;
+typedef unsigned short bool;
 
 char square_to_file (int square);
 char square_to_rank (int square);
@@ -105,6 +105,6 @@ char* ft_to_full_move (int from, int to, char promote_in);
 char* result_to_s (unsigned short int r);
 char* castling_to_s (short int castling);
 char* en_passant_to_s (short int en_passant);
-bool compare (const void * a, const void * b);
+int compare (const void *a, const void *b);
 
 #endif

data/ext/game.c

@@ -138,9 +138,14 @@ rollback (Game *g)
 bool
 threefold_repetition (Game *g)
 {
+  if (g->current < 6) // Minimum moves to get a threefold repetition
+    return FALSE;
   char placement[65];
+  char turn;
   char *fen, *castling, *ep;
-  char* s[g->current];
+  char* s[g->current + 1];
+  s[0] = (char *) malloc (80);
+  strcpy (s[0], "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -");
   int i, j;
   bool found = FALSE;
   for (i = 0; i < g->current; i++)
@@ -149,16 +154,17 @@ threefold_repetition (Game *g)
       for (j = 0; fen[j] != ' '; j++)
         placement[j] = fen[j];
       placement[j] = '\0';
-      s[i] = (char *) malloc (80);
+      s[i+1] = (char *) malloc (80);
+      turn = g->boards[i]->active_color ? 'b' : 'w';
       castling = castling_to_s (g->boards[i]->castling);
       ep = en_passant_to_s (g->boards[i]->en_passant);
-      sprintf (s[i], "%s %s %s", placement, castling, ep);
+      sprintf (s[i+1], "%s %c %s %s", placement, turn, castling, ep);
       free (fen);
       free (castling);
       free (ep);
     }
-  qsort (s, g->current, sizeof (char *), compare);
-  for (i = 0; i < g->current-2; i++)
+  qsort (s, g->current + 1, sizeof (char *), compare);
+  for (i = 0; i < g->current - 1; i++)
     {
       if (strcmp (s[i], s[i+1]) == 0 && strcmp (s[i], s[i+2]) == 0)
         {
@@ -167,16 +173,25 @@ threefold_repetition (Game *g)
         }
       free (s[i]);
     }
+  free (s[g->current]);
   free (s[g->current-1]);
-  free (s[g->current-2]);
   return found;
 }
 
+/*
+ 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.
+ 3. Castling availability. If neither side can castle, this is "-".
+ 4. En passant target square in algebraic notation. If there's no en passant target square, this is "-".
+ 5. Halfmove clock: this is the number of halfmoves since the last pawn advance or capture.
+ 6. Fullmove number: the number of the full move. It starts at 1, and is incremented after black's move.
+*/
 void
 set_fen (Game *g, const char *fen)
 {
   Board *board = NEW_BOARD;
-  int i = 0, j, k, pos, square;
+  int i = 0, j, k, square;
   char *pch;
   char *s = (char *) malloc (strlen (fen));
   strcpy (s, fen);

data/lib/chess/game.rb

@@ -17,14 +17,27 @@ module Chess
       pgn = Chess::Pgn.new(file)
       game = Chess::Game.new
       pgn.moves.each { |m| game.move(m) }
+      if !game.over?
+        case pgn.result
+        when '1-0'
+          game.resign(:black)
+        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
+        end
+      end
       return game
     end
 
     # Creates a new game from a FEN string.
-    # *Warning*: this game do not have history before the FEN placement.
     # May be raise an InvalidFenFormatError.
+    # *Warning*: 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+)$/
+      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
         game.set_fen!(fen)
         return game
@@ -72,24 +85,40 @@ module Chess
     # Returns the status of the game.
     # Possible states are:
     # * +in_progress+:: the game is in progress.
-    # * +white_wins+:: white player checkmate the black king.
-    # * +black_wins+:: black player checkmate the white king.
-    # * +stalemate+:: draw for stalemate
+    # * +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.
     def status
       case self.result
       when '*'
         return :in_progress
       when '1-0'
-        return :white_wins
+        if self.board.checkmate?
+          return :white_won
+        else
+          return :white_won_resign
+        end
       when '0-1'
-        return :black_wins
+        if self.board.checkmate?
+          return :black_won
+        else
+          return :black_won_resign
+        end
       when '1/2-1/2'
         if self.board.stalemate?
           return :stalemate
         elsif self.board.insufficient_material?
           return :insufficient_material
+        elsif self.board.fifty_rule_move?
+          return :fifty_rule_move
+        elsif self.threefold_repetition?
+          return :threefold_repetition
         end
       end
       return :unknown
@@ -111,28 +140,28 @@ module Chess
     private
 
     # 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: '' }
     def expand_move(m)
-      if match = m.match(/^(R|N|B|Q|K)?([a-h]?[1-8]?)(?:x)?([a-h][1-8])(?:=?(R|N|B|Q))?(?:ep)?(?:\+|\#)?$/)
+      if match = m.match(/^([RNBQK])?([a-h]?[1-8]?)(?:x)?([a-h][1-8])(?:=?([RrNnBbQq]))?(?:ep)?(?:\+|\#)?$/)
         expand = {
-          :name => match[1] || 'P',    # Piece name (P|R|N|B|Q|K)
-          :dis => match[2],            # Disambiguating move
-          :to => match[3],             # Move to
-          :promotion => match[4].to_s, # Promote with
+          name: match[1] || 'P',    # Piece name [RNBQK]
+          dis: match[2],            # Disambiguating move
+          to: match[3],             # Move to
+          promotion: match[4].to_s, # Promote with
         }
         expand[:from] = match[2] if match[2] && match[2].size == 2
         return expand
-      elsif m =~ /^(0|O)-(0|O)(\+|\#)?$/
+      elsif m =~ /^([0O])-([0O])([\+#])?$/
         if self.board.active_color # black king short castling
-          return { :name => 'K', :dis => '', :from => 'e8', :to => 'g8', :promotion => '' }
+          return { name: 'K', dis: '', from: 'e8', to: 'g8', promotion: '' }
         else # white king short castling
-          return { :name => 'K', :dis => '', :from => 'e1', :to => 'g1', :promotion => '' }
+          return { name: 'K', dis: '', from: 'e1', to: 'g1', promotion: '' }
         end
-      elsif m =~ /^(0|O)-(0|O)-(0|O)(\+|\#)?$/
+      elsif m =~ /^([0O])-([0O])-([0O])([\+#])?$/
         if self.board.active_color # black king long castling
-          return { :name => 'K', :dis => '', :from => 'e8', :to => 'c8', :promotion => '' }
+          return { name: 'K', dis: '', from: 'e8', to: 'c8', promotion: '' }
         else # white king long castling
-          return { :name => 'K', :dis => '', :from => 'e1', :to => 'c1', :promotion => '' }
+          return { name: 'K', dis: '', from: 'e1', to: 'c1', promotion: '' }
         end
       end
       raise BadNotationError.new(m)