chess 0.0.1.dummy → 0.0.1

data/ext/game.h

@@ -0,0 +1,42 @@
+/*
+ * chess - a fast library to play chess in Ruby
+ *
+ * Copyright (c) 2011-2012, Enrico Pilotto <enrico@megiston.it>
+ * This code is under LICENSE LGPLv3
+ */
+
+#ifndef GAME_H
+#define GAME_H
+
+#define NEW_GAME (Game*) malloc (sizeof (Game))
+
+#define BUFFER_SIZE 1024
+
+#include "common.h"
+#include "board.h"
+
+typedef struct
+{
+  Board* boards[BUFFER_SIZE];
+  char* moves[BUFFER_SIZE];
+  char* full_moves[BUFFER_SIZE];
+  int current;
+  unsigned short result;
+} Game;
+
+
+#include "special.h"
+
+void init_chess_library ();
+Game* init_game ();
+void free_game (Game *g);
+Board* current_board (Game *g);
+Board* get_board (Game *g, int index);
+char* current_move (Game *g);
+char* current_full_move (Game *g);
+bool apply_move (Game *g, int from, int to, char promote_in);
+void rollback (Game *g);
+bool threefold_repetition (Game *g);
+void set_fen (Game *g, const char *fen);
+
+#endif

data/ext/special.c

@@ -0,0 +1,191 @@
+/*
+ * chess - a fast library to play chess in Ruby
+ *
+ * Copyright (c) 2011-2012, Enrico Pilotto <enrico@megiston.it>
+ * This code is under LICENSE LGPLv3
+ */
+
+#include "special.h"
+
+void
+update_castling (Board *board, int from)
+{
+  switch (from)
+    {
+    case A1:
+      board->castling ^= board->castling & 0x0100;
+      break;
+    case E1:
+      board->castling ^= board->castling & 0x1100;
+      break;
+    case H1:
+      board->castling ^= board->castling & 0x1000;
+      break;
+    case A8:
+      board->castling ^= board->castling & 0x0001;
+      break;
+    case E8:
+      board->castling ^= board->castling & 0x0011;
+      break;
+    case H8:
+      board->castling ^= board->castling & 0x0010;
+      break;
+    }
+}
+
+int
+castling_type (Board *board, int from, int to)
+{
+  if (from == E1 && to == G1)
+    {
+      if (!(board->castling & 0x1000)
+        || (board->occupied & 0x60)
+        || capture (board, BLACK, E1)
+        || capture (board, BLACK, F1)
+        || capture (board, BLACK, G1))
+        return 0;
+      return WHITE_SHORT_CASTLING;
+    }
+  if (from == E1 && to == C1)
+    {
+      if (!(board->castling & 0x0100)
+        || (board->occupied & 0x0E)
+        || capture (board, BLACK, E1)
+        || capture (board, BLACK, D1)
+        || capture (board, BLACK, C1))
+        return 0;
+      return WHITE_LONG_CASTLING;
+    }
+  if (from == E8 && to == G8)
+    {
+      if (!(board->castling & 0x0010)
+        || (board->occupied & 0x6000000000000000)
+        || capture (board, WHITE, E8)
+        || capture (board, WHITE, F8)
+        || capture (board, WHITE, G8))
+        return 0;
+      return BLACK_SHORT_CASTLING;
+    }
+  if (from == E8 && to == C8)
+    {
+      if (!(board->castling & 0x0001)
+        || (board->occupied & 0x0E00000000000000)
+        || capture (board, WHITE, E8)
+        || capture (board, WHITE, D8)
+        || capture (board, WHITE, C8))
+        return 0;
+      return BLACK_LONG_CASTLING;
+    }
+  return 0;
+}
+
+char*
+castling (Board *board, int castling_type, Board *new_board)
+{
+  char *move;
+  switch (castling_type)
+    {
+    case WHITE_SHORT_CASTLING:
+      memcpy (new_board, board, sizeof (Board));
+      new_board->king[WHITE] ^= 0x50;
+      new_board->rooks[WHITE] ^= 0xa0;
+      new_board->placement[E1] = 0;
+      new_board->placement[F1] = 'R';
+      new_board->placement[G1] = 'K';
+      new_board->placement[H1] = 0;
+      new_board->castling ^= new_board->castling & 0x1100;
+      move = (char *) malloc (5);
+      strcpy (move, "O-O");
+      break;
+    case WHITE_LONG_CASTLING:
+      memcpy (new_board, board, sizeof (Board));
+      new_board->king[WHITE] ^= 0x14;
+      new_board->rooks[WHITE] ^= 0x09;
+      new_board->placement[E1] = 0;
+      new_board->placement[D1] = 'R';
+      new_board->placement[C1] = 'K';
+      new_board->placement[A1] = 0;
+      new_board->castling ^= new_board->castling & 0x1100;
+      move = (char *) malloc (7);
+      strcpy (move, "O-O-O");
+      break;
+    case BLACK_SHORT_CASTLING:
+      memcpy (new_board, board, sizeof (Board));
+      new_board->king[BLACK] ^= 0x5000000000000000;
+      new_board->rooks[BLACK] ^= 0xa000000000000000;
+      new_board->placement[E8] = 0;
+      new_board->placement[F8] = 'r';
+      new_board->placement[G8] = 'k';
+      new_board->placement[H8] = 0;
+      new_board->castling ^= new_board->castling & 0x0011;
+      move = (char *) malloc (5);
+      strcpy (move, "O-O");
+      break;
+    case BLACK_LONG_CASTLING:
+      memcpy (new_board, board, sizeof (Board));
+      new_board->king[BLACK] ^= 0x1400000000000000;
+      new_board->rooks[BLACK] ^= 0x0900000000000000;
+      new_board->placement[E8] = 0;
+      new_board->placement[D8] = 'r';
+      new_board->placement[C8] = 'k';
+      new_board->placement[A8] = 0;
+      new_board->castling ^= new_board->castling & 0x0011;
+      move = (char *) malloc (7);
+      strcpy (move, "O-O-O");
+      break;
+    default:
+      return 0;
+    }
+  set_occupied (new_board);
+  return move;
+}
+
+void
+update_en_passant (Board *board, int from, int to)
+{
+  if (board->placement[to] == 'P' && from >= A2 && from <= H2 && to == from + 16)
+    board->en_passant = to - 8;
+  else if (board->placement[to] == 'p' && from >= A7 && from <= H7 && to == from - 16)
+    board->en_passant = to + 8;
+  else
+    board->en_passant = -1;
+}
+
+int
+have_en_passant (Board *board, int from, int to)
+{
+  if (board->placement[from] == 'P' && to == board->en_passant
+      && (from == to - 7 || from == to - 9))
+    return to - 8;
+  else if (board->placement[from] == 'p' && to == board->en_passant
+      && (from == to + 7 || from == to + 9))
+    return to + 8;
+  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);
+}
+
+bool
+require_a_promotion (Board *board)
+{
+  return ((board->pawns[WHITE] | board->pawns[BLACK]) & 0xff000000000000ff) ? TRUE : FALSE;
+}
+
+bool
+promote (Board *board, int square, char promote_in)
+{
+  if (board->active_color)
+    promote_in = tolower (promote_in);
+  else
+    promote_in = toupper (promote_in);
+  *(get_bitboard (board, square)) ^= 1ULL << square;
+  bboard *bb = get_piece_bitboard (board, promote_in);
+  if (!bb) return FALSE;
+  *(bb) ^= 1ULL << square;
+  board->placement[square] = promote_in;
+  return TRUE;
+}

data/ext/special.h

@@ -0,0 +1,23 @@
+/*
+ * chess - a fast library to play chess in Ruby
+ *
+ * Copyright (c) 2011-2012, Enrico Pilotto <enrico@megiston.it>
+ * This code is under LICENSE LGPLv3
+ */
+
+#ifndef SPECIAL_H
+#define SPECIAL_H
+
+#include "common.h"
+#include "board.h"
+
+void update_castling (Board *board, int from);
+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);
+
+#endif

data/lib/chess.rb

@@ -1,7 +1,5 @@
-require "chess/version"
-
-module Chess
-  def hello
-    puts 'World'
-  end
-end
+require 'chess/exceptions'
+require 'chess/game'
+require 'chess/gnuchess'
+require 'chess/pgn'
+require 'chess/version'

data/lib/chess/exceptions.rb

@@ -0,0 +1,31 @@
+module Chess
+
+  # This exception will be raised when an invalid short algebraic chess notation string is passed to the Game#move function.
+  class BadNotationError < StandardError
+    # :nodoc:
+    # Create a new exception.
+    def initialize(notation)
+      super("The notation '#{notation}' is invalid")
+    end
+  end
+
+  # This exception will be raised when a malformed PGN file is loaded.
+  class InvalidPgnFormatError < StandardError
+    # :nodoc:
+    # Create a new exception.
+    def initialize(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.
+    def initialize(fen_string)
+      super("Invalid FEN string: '#{fen_string}'")
+    end
+  end
+
+end
+

data/lib/chess/game.rb

@@ -0,0 +1,142 @@
+require File.join(File.dirname(__FILE__), '../../ext/chess')
+
+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.
+    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.
+    def self.load_pgn(file)
+      pgn = Chess::Pgn.new(file)
+      game = Chess::Game.new
+      pgn.moves.each { |m| game.move(m) }
+      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.
+    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
+        game.set_fen!(fen)
+        return game
+      else
+        raise InvalidFenFormatError.new(fen)
+      end
+    end
+
+    # Make a move. This add a new Board in the Storyboard.
+    # The parameter +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>.
+    # 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.
+    def move(m)
+      begin
+        expand = expand_move(m)
+        if expand[:from]
+          move2(expand[:from], expand[:to], expand[:promotion])
+        else
+          super(expand[:name], expand[:dis], expand[:to], expand[:promotion])
+        end
+      rescue IllegalMoveError => e
+        raise IllegalMoveError.new("Illegal move '#{m}'\n#{self.to_s}")
+      end
+    end
+    alias :move= :move
+    alias :<< :move
+
+    # Make the array of moves.
+    def moves=(moves)
+      moves.each { |m| move(m) }
+    end
+
+    # Returns +:white+ if the active player is the white player, +:black+ otherwise.
+    def active_player
+      self.board.active_color ? :black : :white
+    end
+
+    # Returns +:white+ if the inactive player is the white player, +:black+ otherwise.
+    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_wins+:: white player checkmate the black king.
+    # * +black_wins+:: black player checkmate the white king.
+    # * +stalemate+:: draw for stalemate
+    # * +insufficient_material+:: draw for insufficient material to checkmate.
+    # * +unknown+:: something went wrong.
+    def status
+      case self.result
+      when '*'
+        return :in_progress
+      when '1-0'
+        return :white_wins
+      when '0-1'
+        return :black_wins
+      when '1/2-1/2'
+        if self.board.stalemate?
+          return :stalemate
+        elsif self.board.insufficient_material?
+          return :insufficient_material
+        end
+      end
+      return :unknown
+    end
+
+    # Returns +true+ if the game is over
+    def over?
+      return self.result != '*'
+    end
+
+    # Returns the PGN rappresenting the game.
+    def pgn
+      pgn = Chess::Pgn.new
+      pgn.moves = self.moves
+      pgn.result = self.result
+      return pgn
+    end
+
+    private
+
+    # Expand the short algebraic chess notation string +m+ in a hash like this:
+    #     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)?(?:\+|\#)?$/)
+        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
+        }
+        expand[:from] = match[2] if match[2] && match[2].size == 2
+        return expand
+      elsif m =~ /^(0|O)-(0|O)(\+|\#)?$/
+        if self.board.active_color # black king short castling
+          return { :name => 'K', :dis => '', :from => 'e8', :to => 'g8', :promotion => '' }
+        else # white king short castling
+          return { :name => 'K', :dis => '', :from => 'e1', :to => 'g1', :promotion => '' }
+        end
+      elsif m =~ /^(0|O)-(0|O)-(0|O)(\+|\#)?$/
+        if self.board.active_color # black king long castling
+          return { :name => 'K', :dis => '', :from => 'e8', :to => 'c8', :promotion => '' }
+        else # white king long castling
+          return { :name => 'K', :dis => '', :from => 'e1', :to => 'c1', :promotion => '' }
+        end
+      end
+      raise BadNotationError.new(m)
+    end
+
+  end
+end

data/lib/chess/gnuchess.rb

@@ -0,0 +1,93 @@
+module Chess
+
+  # Use Gnuchess to I.A. <em>(Only a draft)</em>
+  # To use this module, extend a game object with Chess::Gnuchess
+  #
+  #    g = Chess::Game.new
+  #    g.extend Chess::Gnuchess
+  #    g.gnuchess_move
+  #    puts g
+  module Gnuchess
+
+    # Make a move using Gnuchess engine. This add a new Board in the Game.
+    # Return the next move calculated by Gnuchess.
+    # Gnuchess must be installed!
+    def gnuchess_move
+      pipe = IO.popen('gnuchess -x', 'r+')
+      begin
+        pipe.write("depth 1\n")
+        pipe.write("force\n")
+        self.full_moves.each do |m|
+          pipe.write(m + "\n")
+        end
+        pipe.write("go\n")
+        while line = pipe.gets
+          raise IllegalMoveError if line.include?('Invalid move')
+          match = line.match(/My move is : ([a-h][1-8][a-h][1-8])/)
+          return self.move(match[1]) if match
+        end
+      ensure
+        pipe.write("quit\n")
+        pipe.close
+      end
+    end
+
+    # :nodoc:
+    def gen_pgn(file_to_save, moves = [])
+      done = false
+      pipe = IO.popen('gnuchess', 'r+')
+      begin
+        pipe.write("depth 1\n")
+        pipe.write("force\n")
+        pipe.write("name chess.rb\n")
+        moves.each do |move|
+          pipe.write("#{move}\n")
+        end
+        while(!done)
+          pipe.write("go\n")
+          while line = pipe.gets
+            if line =~ /My move is : /
+              break
+            elsif line =~ / : resign/
+              break
+            elsif line =~ / : 1-0 {White mates}/
+              done = :white_wins
+              break
+            elsif line =~ / : 0-1 {Black mates}/
+              done = :black_wins
+              break
+            elsif m = line.match(/1\/2-1\/2 {(.*?)}/)
+              case m[1]
+              when 'Stalemate'
+                done = :stalemate
+              when 'Draw by repetition'
+                done = :repetition
+              when 'Draw by fifty-move rule'
+                done = :fifty_move_rule
+              when 'Draw by insufficient material'
+                done = :insufficient_material
+              end
+              break
+            end
+          end
+        end
+        dir = File.dirname(file_to_save)
+        name = File.basename(file_to_save)
+        pipe.write("pgnsave #{File.join(dir, done.to_s, name)}\n")
+      ensure
+        pipe.write("quit\n")
+        pipe.close
+      end
+    end
+
+    private
+
+    # Return true if Gnuchess is installed, false otherwise.
+    def self.gnuchess_installed?
+      system('which gnuchess >& /dev/null')
+      $?.exitstatus == 0
+    end
+  end
+
+end
+