chess_rb 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa3d318cecdbf7ca433d3dbd4a05f865d6acd390
-  data.tar.gz: 0674fc6547bed63a77ad029af20815221f1731c7
+  metadata.gz: 1584e23695704e645f8088827c43f71e60c9ce07
+  data.tar.gz: 9ebf999832dee1ff44b892126e558bb1675369d6
 SHA512:
-  metadata.gz: 0fbc9bf5696a3b468989ee3b00b151f9e36ca6a84ab4a6e3249c3313e6e1ff2be8c25fdf9a5b63d9c4ed05f36600ba897fba4c7aea9daa25afc7d837068ae1eb
-  data.tar.gz: 7dc55e6ddb44420f5ff44c0abe1c5aced4243015ecfa195a5888bb3e8a232a4a1b29cb3eb636bf7ca7294493433b5b302857fd172f64cb3c06d10bbd3d927753
+  metadata.gz: cd5db4e7c13262c0076171467f2de6b16862fe844e1ab5f69b76a0776bc7b5562b71a8f2d059c2780f06f35aa7e0487f10962aa5400ae3201eeaff1937d7e49c
+  data.tar.gz: 9366f64fe308afc5e1d655cbf24a580b9702c8ff34e63cc2e19239486912f0916a42714079ef83b48ff6ad191ae52672c389993b834771573f93d967f23ed610

data/lib/chess_rb/move.rb

@@ -1,5 +1,5 @@
 class ChessRB::Move
-  FILE_TO_NUM = [nil, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
+  FILE_CONV = [nil, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
 
   attr_reader :to, :from, :promotion, :square, :san, :board
 
@@ -10,7 +10,7 @@ class ChessRB::Move
       @san = move
     end
 
-    if pos.is_a? String
+    if pos.is_a?(String)
       @board = ChessRB::Position.new pos
     else
       @board = pos
@@ -38,20 +38,19 @@ class ChessRB::Move
 
   # Returns true if move represents a queen-side castle, false otherwise.
   def queen_castle?
-
-    return valid? && ChessRB::Piece.new(@board.piece_on(@to)).type == 'k' &&
-      (from_file - to_file).abs == 3
+    return valid? && @board.piece_on(@from).type == 'K' &&
+      from_file - to_file == 2
   end
 
   # Returns true if move represents a king-side castle, false otherwise.
   def king_castle?
-    return valid? && ChessRB::Piece.new(@board.piece_on(@to)).type == 'k' &&
-     (from_file - to_file).abs == 2
+    return valid? && @board.piece_on(@from).type == 'K' &&
+      to_file - from_file == 2
   end
 
   # Returns true if move results in a capture, false otherwise.
   def capture?
-    return valid? && @board.piece_on(@to) != 0
+    return valid? && @board.piece_on(@to).desc != 'E'
   end
 
   # Returns the rank of a given square
@@ -61,26 +60,26 @@ class ChessRB::Move
 
   # Returns rank of this move's @to square
   def to_rank
-    return self.rank(@to)
+    return self.class.rank(@to)
   end
 
   # Returns rank of this move's @from square
   def from_rank
-    return self.rank(@from)
+    return self.class.rank(@from)
   end
 
   # Returns the file of a given square as a number (e.g., a = 1, b = 2, ...)
   def self.file(square)
-    return FILE_TO_NUM.index(square[0])
+    return FILE_CONV.index(square[0])
   end
 
   # Returns file of this move's @to square
   def to_file
-    return self.file(@to)
+    return self.class.file(@to)
   end
 
   # Returns file of this move's @from square
   def from_file
-    return self.file(@from)
+    return self.class.file(@from)
   end
 end

data/lib/chess_rb/notation.rb

@@ -1,7 +1,7 @@
 class ChessRB::Notation
   def self.square_to_algebraic(move)
     board = move.board
-    piece = ChessRB::Piece.new(board.piece_on(move.from))
+    piece = board.piece_on(move.from)
     san = ""
 
     raise ArgumentError.new "Invalid move and/or position" if !move.valid? ||
@@ -9,16 +9,17 @@ class ChessRB::Notation
 
 
     if move.queen_castle?
-      san = "O-O-O"
+      return "O-O-O"
     elsif move.king_castle?
-      san = "O-O"
+      return "O-O"
     else
-      if piece.type == 'p'
+      if piece.type == 'P'
         if move.capture?
-          san = file_to_char(move.from_file)
+          san = move.from[0]
         end
       else
         san += piece.type.upcase
+
         # test ambiguities
         # file
         # rank
@@ -34,13 +35,12 @@ class ChessRB::Notation
 
     san += "=#{move.promotion}" if move.promotion
 
-=begin
+    undo_info = board.piece_on(move.to)
     board.make_move(move)
     if (board.check?)
       san += board.mate? ? "#" : "+"
     end
-    board.undo_move(move)
-=end
+    board.undo_move(move, undo_info)
 
     return san
   end

data/lib/chess_rb/piece.rb

@@ -1,23 +1,25 @@
 class ChessRB::Piece
+  E = 0
   WP = 1; WN = 2; WLB = 3; WDB = 4; WR = 5; WQ = 6; WK = 7
   BP = 11; BN = 12; BLB = 13; BDB = 14; BR = 15; BQ = 16; BK = 17
 
-  attr_accessor :code
+  attr_reader :code, :desc
 
   def initialize(code)
     @code = code
+    @desc = ChessRB::Piece.constants.select{
+      |v| ChessRB::Piece.const_get(v) == code }[0].to_s
   end
 
   def type
-    self.to_desc[-1, 1]
+    self.desc[-1, 1]
   end
 
-  def to_desc
-    return ChessRB::Piece.constants.select{
-      |v| ChessRB::Piece.const_get(v) == @code }[0].to_s
+  def color
+    self.desc[0]
   end
 
-  def to_s(p, d)
+  def to_s(d)
     case @code
     when WP
       d ? "♟" : "♙"

data/lib/chess_rb/position.rb

@@ -1,3 +1,5 @@
+require 'matrix'
+
 class ChessRB::Position
   attr_accessor :fen
 
@@ -5,40 +7,172 @@ class ChessRB::Position
     @fen = fen
     @fen_components = fen.split(' ')
     @board = fen_to_board(fen)
+    @valid = valid?
+  end
+
+  def self.valid_square?(s)
+    i = s[0]; j = s[1]
+    return i.is_a?(Integer) && j.is_a?(Integer) &&
+      i >= 0 && i < 8 && j >= 0 && j < 8
   end
 
   # TODO
   def valid?
+    return @valid if !@valid.nil?
     return true
   end
 
+  # Returns 'w' or 'b' if it is white or black's move, respectively
+  def turn
+    return @fen_components[1]
+  end
+
   # Returns the piece code on the given square
   def piece_on(square)
-    file = ChessRB::Move.file(square)
-    rank = ChessRB::Move.rank(square)
-    return @board[8 - rank][file - 1]
+    if square.is_a?(String)
+      file = ChessRB::Move.file(square)
+      rank = ChessRB::Move.rank(square)
+      return ChessRB::Piece.new(@board[8 - rank][file - 1])
+    else
+      return ChessRB::Piece.new(@board[square[0]][square[1]])
+    end
   end
 
-  # TODO
+  def squares_with(piece)
+    squares = []
+    code = ChessRB::Piece.const_get(piece)
+
+    @board.each_with_index do |r , i|
+      r.each_with_index do |p, j|
+        if p == code
+          squares << [i, j]
+        end
+      end
+    end
+
+    return squares
+  end
+
+  # Returns if the current position is check, false otherwise
   def check?
+    raise RuntimeError "Invalid Position" if !valid?
+
+    t = turn().upcase
+    not_t = t == 'W' ? 'B' : 'W'
+    king_vector = Vector[*(squares_with(t + 'K')[0])]
+
+    # check pawn squares
+    pawn_vectors = t == 'W' ? [[-1, -1], [1, -1]] : [[-1, 1], [1, 1]]
+    pawn_vectors.each do |s|
+      s = (king_vector + Vector[*s]).to_a
+      next if !self.class.valid_square?(s)
+      return true if piece_on(s).desc == (not_t + 'P')
+    end
+
+    # check knight squares
+    knight_vectors = [[1,2], [-1,2], [1,-2], [-1,-2], [2,1], [-2,1], [2,-1],
+      [-2,-1]]
+    knight_vectors.each do |s|
+      s = (king_vector + Vector[*s]).to_a
+      next if !self.class.valid_square?(s)
+      return true if piece_on(s).desc == (not_t + 'N')
+    end
+
+    # check bishop/queen squares
+    diagonal_vectors = [[1, 1], [-1, 1], [1, -1], [-1, -1]]
+    diagonal_vectors.each do |v|
+      dist = 1
+      v = Vector[*v]
+      while dist < 8
+        current_vector = v * dist
+        current_square = (king_vector + current_vector).to_a
+
+        break if !self.class.valid_square?(current_square)
+
+        p = piece_on(current_square).desc
+        return true if p == (not_t + 'B') || p == (not_t + 'Q')
+        break if p != 'E'
+
+        dist += 1
+      end
+    end
 
+    # check rook/queen squares
+    straight_vectors = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+    straight_vectors.each do |v|
+      dist = 1
+      v = Vector[*v]
+      while dist < 8
+        current_vector = v * dist
+        current_square = (king_vector + current_vector).to_a
+
+        break if !self.class.valid_square?(current_square)
+
+        p = piece_on(current_square).desc
+        return true if p == (not_t + 'B') || p == (not_t + 'Q')
+        break if p != 'E'
+
+        dist += 1
+      end
+    end
+
+    return false
   end
 
-  # TODO
+  # Returns if the current position is checkmate, false otherwise
   def mate?
+    return false if !check?
+
+    t = turn().upcase
+    king_vector = Vector[*(squares_with(t + 'K')[0])]
+
+    around_vectors = [[1, 0], [0, 1], [-1, 0], [0, -1], [1, 1], [-1, 1],
+      [1, -1], [-1, -1]]
+    around_vectors.each do |v|
+      v = Vector[*v]
+      current_square = (king_vector + v).to_a
+      if !self.class.valid_square?(current_square) ||
+        piece_on(current_square).color == t
+
+        next
+      else
+        undo_code = piece_on(current_square).code
+        move(king_vector.to_a, current_square)
+        if !check?
+          undo(king_vector.to_a, current_square, undo_code)
+          return false
+        end
+        undo(king_vector.to_a, current_square, undo_code)
+      end
+    end
+
+    return true
+  end
+
+  def make_move(move)
+    move([8 - move.from_rank, move.from_file - 1],
+      [8 - move.to_rank, move.to_file - 1])
+
+    @fen_components[1] = @fen_components[1] == 'w' ? 'b' : 'w'
+  end
+
+  def undo_move(move, piece)
+    undo([8 - move.from_rank, move.from_file - 1],
+      [8 - move.to_rank, move.to_file - 1], piece.code)
 
+    @fen_components[1] = @fen_components[1] == 'w' ? 'b' : 'w'
   end
 
   def to_s(dark_background = true)
     str = ""
-    board.each_with_index do |r, i|
+    @board.each_with_index do |r, i|
       str += (8 - i).to_s + "║"
       r.each do |s|
         str += " "
         if s == 0
           str += "…"
         else
-          str += ChessRB::Piece.code_to_s(s, dark_background)
+          str += ChessRB::Piece.new(s).to_s(dark_background)
         end
       end
       str += "\n"
@@ -69,4 +203,14 @@ class ChessRB::Position
     end
     return board
   end
+
+  def move(from, to)
+    @board[to[0]][to[1]] = @board[from[0]][from[1]]
+    @board[from[0]][from[1]] = 0
+  end
+
+  def undo(from, to, code)
+    @board[from[0]][from[1]] = @board[to[0]][to[1]]
+    @board[to[0]][to[1]] = code
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chess_rb
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Sabar Dasgupta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-16 00:00:00.000000000 Z
+date: 2014-06-20 00:00:00.000000000 Z
 dependencies: []
 description: Chess functions written in Ruby
 email: sabar.dasgupta@gmail.com