bchess 0.1.1

data/lib/bchess/piece.rb

@@ -0,0 +1,133 @@
+module Bchess
+  class Piece
+    attr_reader :color, :column, :row
+
+    include BoardHelpers
+    include FieldBetweenHelpers
+
+    def initialize(color, column, row)
+      @color = color
+      @column = column
+      @row = row
+    end
+
+    def to_s
+      name + field(column, row)
+    end
+
+    def moved
+      false
+    end
+
+    def name
+      raise Exception.new("Should be defined in subclass")
+    end
+
+    def at?(dcolumn, drow)
+      column == dcolumn && row == drow
+    end
+
+    def move(dcolumn, drow)
+      @column = dcolumn
+      @row = drow
+    end
+
+    def can_make_move?(info, board)
+      row = to_row(info[:row])
+      column = to_column(info[:column])
+
+      board.at(column, row)&.color != color &&
+      kind_of?(info[:piece_type]) &&
+      info[:piece_color] == color &&
+      can_move_or_take?(column, row, board) &&
+      additional_info?(info[:additional_info])
+    end
+
+    def can_move_or_take?(column, row, board)
+      clear_path?(column, row, board) &&
+      (
+        can_move?(column, row) ||
+        can_take?(column, row, board) ||
+        can_en_passant?(column, row, board)
+      ) && valid_position_after?(column, row, board)
+    end
+
+    def clear_path?(column, row, board)
+      fields_between(column, row).none?{|f| board.at(*f)}
+    end
+
+    def can_move?(column, row)
+      can_move_to_field?(column, row)
+    end
+
+    def can_take?(column, row, board, en_passant = false)
+      can_take_on_field?(column, row) && (!!board.at(column, row) || en_passant)
+    end
+
+    def can_en_passant?(column, row, board)
+      board.en_passant == field(column, row) && can_take?(column, row, board, true)
+    end
+
+    def valid_position_after?(dcolumn, drow, board)
+      fen = board.write_fen
+
+      helper_board = Bchess::Board.new(fen)
+      helper_board.read_fen
+      helper_piece = helper_board.at(column, row)
+      helper_board.move(helper_piece, dcolumn, drow, Bchess::Queen) # TODO
+    end
+
+    def additional_info?(info)
+      info.nil? || to_column(info) == column || to_row(info) == row
+    end
+
+    def can_move_to_field?(dcolumn, drow)
+      !(column == dcolumn && drow == row) &&
+      (0..7).include?(dcolumn) && (0..7).include?(drow)
+    end
+
+    def can_take_on_field?(dcolumn, drow)
+      can_move_to_field?(dcolumn, drow)
+    end
+
+    def can_be_promoted?
+      false
+    end
+
+    def valid?
+      (0..7).include?(column) && (0..7).include?(row)
+    end
+
+    def by_line(dcolumn, drow, range)
+      same_row?(drow) && (column - dcolumn).abs <= range  ||
+      same_column?(dcolumn) && (row - drow).abs <= range
+    end
+
+    def by_diagonal(dcolumn, drow, range)
+      same_diagonal?(dcolumn, drow) &&
+        (column - dcolumn).abs <= range
+    end
+
+    def white?
+      color == Bchess::WHITE
+    end
+
+    def black?
+      color == Bchess::BLACK
+    end
+
+    private
+
+    def same_row?(drow)
+      row == drow
+    end
+
+    def same_column?(dcolumn)
+      column == dcolumn
+    end
+
+    def same_diagonal?(dcolumn, drow)
+     (column - dcolumn).abs == (row - drow).abs
+    end
+  end
+end

data/lib/bchess/queen.rb

@@ -0,0 +1,21 @@
+module Bchess
+  class Queen < Piece
+    QUEEN_REACH = 7
+
+    def initiialize(*args)
+      super(args)
+    end
+
+    def name
+      'Q'
+    end
+
+    def can_move_to_field?(dcolumn, drow)
+      super &&
+        (
+          by_line(dcolumn, drow, QUEEN_REACH) ||
+          by_diagonal(dcolumn, drow,  QUEEN_REACH)
+      )
+    end
+  end
+end

data/lib/bchess/rook.rb

@@ -0,0 +1,25 @@
+module Bchess
+  class Rook < Piece
+    ROOK_REACH = 7
+
+    attr_accessor :moved
+
+    def initiialize(*args)
+      super(args)
+      @moved = false
+    end
+
+    def name
+      'R'
+    end
+
+    def move(dcolumn, drow)
+      super(dcolumn, drow)
+      @moved = true
+    end
+
+    def can_move_to_field?(dcolumn, drow)
+      super && by_line(dcolumn, drow, ROOK_REACH)
+    end
+  end
+end

data/lib/bchess/version.rb

@@ -0,0 +1,3 @@
+module Bchess
+  VERSION = "0.1.1"
+end

data/lib/pgn/game.rb

@@ -0,0 +1,18 @@
+module Bchess
+  module PGN
+    class Game
+      attr_accessor :header, :body, :moves
+
+      def initialize(parsed_game)
+        @header = Bchess::PGN::GameHeader.new(parsed_game.elements.first)
+        @body = Bchess::PGN::GameBody.new(parsed_game.elements.last)
+      end
+
+      def convert_body_to_moves
+        body.extract_moves
+        @moves = body.moves
+        true
+      end
+    end
+  end
+end

data/lib/pgn/game_body.rb

@@ -0,0 +1,111 @@
+module Bchess
+  module PGN
+    class GameBody
+      attr_reader :body, :moves, :board
+
+      include BoardHelpers
+
+      C_COLUMN = 2
+      G_COLUMN = 6
+
+      WHITE_ROW = 0
+      BLACK_ROW = 7
+
+      def initialize(body)
+        @body = body
+        @board = Bchess::Board.new
+        @moves = []
+      end
+
+      def extract_moves
+        @board.read_fen
+
+        body.elements&.each do |move|
+          if is_castle?(move)
+            move_info = extract_castle(move)
+          elsif is_move?(move)
+            move_info = extract_move(move)
+          else
+            next
+          end
+
+          board.move(*move_info.values)
+          @moves << move_info
+        end
+      end
+
+      def extract_move(move)
+        move_text = move.text_value
+        info = return_move_information(move_text)
+
+        piece = get_moving_piece(board, info)
+        {
+          piece: piece,
+          column: to_column(info[:column]),
+          row: to_row(info[:row]),
+          promoted_piece: info[:promoted_piece]
+        }
+      end
+
+      private
+
+      def get_moving_piece(board, info)
+        pieces = board.get_possible_pieces(info)
+
+        if pieces.size != 1
+          raise Bchess::InvalidMoveException.new("Too many or too few pieces to make move: #{info} : #{pieces.size}")
+        end
+
+        pieces.first
+      end
+
+      def extract_castle(move)
+        move_text = move.text_value
+        info = return_move_information(move_text, true)
+
+        if C_COLUMN == move_text.split('-').size
+          column = G_COLUMN
+          row = is_white?(info) ? WHITE_ROW : BLACK_ROW
+        else
+          column = C_COLUMN
+          row = is_white?(info) ? WHITE_ROW : BLACK_ROW
+        end
+
+        {
+          piece: board.king(info[:piece_color]),
+          column: column,
+          row: row,
+          promoted_piece: false
+        }
+      end
+
+      def return_move_information(move_text,castle=false)
+        Bchess::PGN::MoveInfoParser.new(move_text, castle).parse_move_string
+      end
+
+      def is_move?(move)
+        move.kind_of?(Sexp::PMove)
+      end
+
+      def is_castle?(move)
+        move.kind_of?(Sexp::PCastle)
+      end
+
+      def is_comment?(move)
+        move.kind_of?(Sexp::PCommentWithBracket)
+      end
+
+      def is_variation?(move)
+        move.kind_of?(Sexp::PVariation)
+      end
+
+      def is_white?(info)
+        Bchess::WHITE == info[:piece_color]
+      end
+
+      def promotion?(info)
+        info[:promoted_piece]
+      end
+    end
+  end
+end

data/lib/pgn/game_header.rb

@@ -0,0 +1,55 @@
+module Bchess
+  module PGN
+    class GameHeader
+      attr_reader :header, :player_white, :player_black
+
+      def initialize(header)
+        @header = header
+      end
+
+      def player_white
+        @player_white ||= values["White"]
+      end
+
+      def player_black
+        @player_black ||= values["Black"]
+      end
+
+      def elo_white
+        @elo_white ||= values["WhiteElo"]
+      end
+
+      def elo_black
+        @elo_black ||= values["BlackElo"]
+      end
+
+      def event
+        @event ||= values["Event"]
+      end
+
+      def site
+        @site ||= values["Site"]
+      end
+
+      def date
+        @date ||= values["Date"]
+      end
+
+      def round
+        @round ||= values["Round"]
+      end
+
+      def eco
+        @eco ||= values["Eco"]
+      end
+
+      def result
+        @result ||= values["Result"]
+      end
+
+      def values
+        @values ||= header.create_value_hash
+      end
+    end
+  end
+end

data/lib/pgn/move_info_parser.rb

@@ -0,0 +1,106 @@
+module Bchess
+  module PGN
+    class MoveInfoParser
+      attr_accessor :info, :move, :castle, :move_string
+
+      CHECK = "+"
+      TAKE = "x"
+      TAKE_2 = ":"
+      MATE = "#"
+      PROMOTION = "="
+
+      def initialize(move, castle)
+        @move = move
+        @castle = castle
+      end
+
+      def parse_move_string
+        info = {}
+        info.merge!(extract_promotion)
+        move_split = @move.split('.')
+
+        info.merge!(basic_move_data(move_split))
+        return info if @castle
+
+        move_string.tr!('+x:#', '')
+        info.merge!(additional_info(move_string))
+      end
+
+      private
+
+      def additional_info(move_string)
+        {
+          piece_type: extract_piece_type(move_string),
+          column: extract_column(move_string),
+          row: extract_row(move_string),
+          additional_info: extract_additional_info(move_string)
+        }
+      end
+
+      def extract_piece_type(move_string)
+        if 2 == move_string.size || move_string.size && pawn_taking?(move_string)
+          Bchess::Pawn
+        else
+          get_piece_from_letter(move_string[0])
+        end
+      end
+
+      def pawn_taking?(move_string)
+        move_string[0].ord >= 'a'.ord && move_string[0].ord <= 'h'.ord
+      end
+
+      def extract_column(move_string)
+        move_string[move_string.size - 2]
+      end
+
+      def extract_row(move_string)
+        move_string[move_string.size - 1]
+      end
+
+      def extract_additional_info(move_string)
+        if (3 == move_string.size) && pawn_taking?(move_string)
+          move_string[0]
+        elsif (4 == move_string.size)
+          move_string[1]
+        end
+      end
+
+      def extract_promotion
+        promotion = @move.split(PROMOTION)
+
+        if promotion.size == 2
+          @move = promotion.first
+          { promoted_piece: get_piece_from_letter(promotion.last[0]) }
+        else
+          {}
+        end
+      end
+
+      def basic_move_data(move_split)
+        @move_string = move_split.last.strip
+
+        raise InvalidMoveException.new("Wrong move description") if move_string.size < 2
+        color = move_split.size == 2 ? Bchess::WHITE : Bchess::BLACK
+        number = move_split.first.strip if move_split.size == 2
+        {
+          piece_color: color,
+          move_number:  number,
+          check:  move_string.include?(CHECK),
+          take: move_string.include?(TAKE) || move_string.include?(TAKE_2),
+          mate: move_string.include?(MATE),
+        }
+      end
+
+
+      def get_piece_from_letter(letter)
+        {
+          "K" => Bchess::King,
+          "Q" => Bchess::Queen,
+          "R" => Bchess::Rook,
+          "B" => Bchess::Bishop,
+          "N" => Bchess::Knight
+        }[letter]
+      end
+    end
+  end
+end