bchess 0.1.1

data/lib/bchess/game.rb

@@ -0,0 +1,21 @@
+module Bchess
+  class Game
+    attr_reader :fen, :board, :moves
+
+    def initialize(fen='')
+      @fen = fen
+      @board = Board.new(fen)
+      @moves = []
+    end
+
+    def add_move(move)
+      moves << move
+    end
+
+    def validate_game
+      moves.all? do |move|
+        board.execute(move)
+      end
+    end
+  end
+end

data/lib/bchess/helpers/board_helpers.rb

@@ -0,0 +1,43 @@
+module Bchess
+  module BoardHelpers
+    def field(column, row)
+      (column+97).chr + (row+1).to_s
+    end
+
+    def invalid_data?(piece, column, row)
+      piece.nil? || !(0..7).include?(column) || !(0..7).include?(row)
+    end
+
+    def castle_detected?(piece, column)
+      piece.kind_of?(Bchess::King) && piece.column == 4 && (column - piece.column).abs == 2
+    end
+
+    def promotion_detected?(piece, row)
+      piece.kind_of?(Bchess::Pawn) && (row == 0 || row == 7)
+    end
+
+    def en_passant_detected?(piece, column, row)
+      piece.kind_of?(Bchess::Pawn) && piece.row != row && piece.column != column && at(column, row).nil? && piece.can_take_on_field?(column, row)
+    end
+
+    def pawn_long_move_detected?(piece, row)
+      piece.kind_of?(Bchess::Pawn) && (piece.row - row).abs == 2
+    end
+
+    def kings_present?
+      !!king(Bchess::WHITE) && !!king(Bchess::BLACK)
+    end
+
+    def to_row(row)
+      row.to_i - 1
+    end
+
+    def to_column(column)
+      column.bytes.first - 97
+    end
+
+    def field(column, row)
+      (column+97).chr + (row+1).to_s
+    end
+  end
+end

data/lib/bchess/helpers/castle_helpers.rb

@@ -0,0 +1,58 @@
+module CastleHelpers
+  def castle(piece, column, row)
+    validate_castle(piece, column)
+    update_castles_after_king_move(piece.color)
+    execute_castle(piece, column, row)
+  end
+
+  def validate_castle(piece, column)
+    !piece.moved && !rook_moved?(piece, column) && fen_allows?(piece,column)
+  end
+
+  def execute_castle(piece, column, row)
+    piece.move(column, row)
+    lngth = @short_castle ? 2 : 3
+    @castling_rook = castling_rook(piece, column)
+    @castling_rook.move((@castling_rook.column - lngth).abs, row)
+  end
+
+  def white_castle(column)
+    if short_castle?(column)
+      @short_castle = true
+      at(7,0)
+    else
+      @short_castle = false
+      at(0,0)
+    end
+  end
+
+  def black_castle(column)
+    if short_castle?(column)
+      @short_castle = true
+      at(7,7)
+    else
+      @short_castle = false
+      at(0,7)
+    end
+  end
+
+  def rook_moved?(piece, column)
+    castling_rook(piece, column)&.moved
+  end
+
+  def castling_rook(piece, column)
+    select_rook(piece, column)
+  end
+
+  def select_rook(piece, column)
+    if piece.row == 0
+      white_castle(column)
+    elsif piece.row == 7
+      black_castle(column)
+    end
+  end
+
+  def short_castle?(column)
+    column == 6
+  end
+end

data/lib/bchess/helpers/en_passant_helpers.rb

@@ -0,0 +1,22 @@
+module EnPassantHelpers
+  def validate_en_passant(piece, column, row)
+    #TODO
+    true
+  end
+
+  def execute_en_passant(piece, row, column)
+    piece.move(row, column)
+    remove_old_piece(*remove_en_passant(piece, *transform_field(@en_passant)), piece.color)
+  end
+
+  def remove_en_passant(piece, column, row)
+    direction = piece.color == Bchess::WHITE ? 1 : -1
+    [column, row - direction]
+  end
+
+  def long_pawn_move(piece, column, row)
+    piece.move(column, row)
+    direction = piece.color == Bchess::WHITE ? 1 : -1
+    @en_passant = field(column, (row + piece.row)/2 - direction)
+  end
+end

data/lib/bchess/helpers/fen_helpers.rb

@@ -0,0 +1,141 @@
+module Bchess
+  module FenHelpers
+    def fen_hash
+      {
+        'k': {klass: Bchess::King, color: Bchess::BLACK},
+        'q': {klass: Bchess::Queen, color: Bchess::BLACK},
+        'r': {klass: Bchess::Rook, color: Bchess::BLACK},
+        'b': {klass: Bchess::Bishop, color: Bchess::BLACK},
+        'n': {klass: Bchess::Knight, color: Bchess::BLACK},
+        'p': {klass: Bchess::Pawn, color: Bchess::BLACK},
+        'K': {klass: Bchess::King, color: Bchess::WHITE},
+        'Q': {klass: Bchess::Queen, color: Bchess::WHITE},
+        'R': {klass: Bchess::Rook, color: Bchess::WHITE},
+        'B': {klass: Bchess::Bishop, color: Bchess::WHITE},
+        'N': {klass: Bchess::Knight, color: Bchess::WHITE},
+        'P': {klass: Bchess::Pawn, color: Bchess::WHITE},
+      }
+    end
+
+    def write_fen
+      result = ''
+      7.downto(0) do |i|
+        line_pieces = pieces.select{ |p| p.row == i }
+        one_line = create_fen_line(line_pieces)
+        result << one_line
+        result << '/' unless i == 0
+      end
+      result.concat(additional_info)
+    end
+
+    def create_fen_line(pieces)
+      line = ''
+      counter = 0
+
+      0.upto(7) do |i|
+        piece = pieces.select{ |p| p.column == i }.first
+        if !!piece
+          if counter > 0
+            line.concat(counter.to_s)
+            counter = 0
+            line.concat(to_fen(piece))
+          else
+            line.concat(to_fen(piece))
+          end
+        else
+          counter += 1
+        end
+      end
+      line.concat(counter.to_s) if counter > 0
+      line
+    end
+
+    def set_pieces(board)
+      pieces.clear
+      board.split("/").each_with_index do |line, index|
+        column = 0
+        line.each_char do |char|
+          if char.to_i != 0
+            column += char.to_i - 1
+          else
+            pieces << fen_hash[char.to_sym][:klass].new(fen_hash[char.to_sym][:color], column, 7-index)
+          end
+          column += 1
+        end
+      end
+    end
+
+    def fen_allows?(piece, column)
+      if piece.color == Bchess::WHITE
+        if column == 6
+          castles.chars.include?('k')
+        else
+          castles.chars.include?('q')
+        end
+      else
+        if column == 6
+          castles.chars.include?('K')
+        else
+          castles.chars.include?('Q')
+        end
+      end
+    end
+
+    def to_fen(piece)
+      fen_hash.key({ :klass => piece.class, :color => piece.color }).to_s
+    end
+
+    def change_halfmove_clock(piece)
+      if piece.kind_of?(Bchess::Pawn)
+        @halfmove_clock = 0
+      else
+        @halfmove_clock = halfmove_clock + 1
+      end
+    end
+
+    def update_castles_after_move(piece)
+      if piece == Bchess::King
+        update_castles_after_king_move(piece.color)
+      elsif piece == Bchess::Rook
+        update_castles_after_rook_move(piece)
+      end
+      @castles = '-' if @castles == ''
+    end
+
+    def update_castles_after_king_move(color)
+      if color == Bchess::WHITE
+        @castles.gsub!('K', '').gsub!('Q', '')
+      else
+        @castles.gsub!('k', '').gsub!('q', '')
+      end
+    end
+
+    def change_move_number
+      @move_number = move_number + 1
+    end
+
+    def set_to_move(fen_colors)
+      @to_move = fen_colors == 'w' ? Bchess::WHITE : Bchess::BLACK
+    end
+
+    def set_castles(fen_castles)
+      @castles = fen_castles
+    end
+
+    def set_en_passant(fen_en_passant)
+      @en_passant = fen_en_passant
+    end
+
+    def set_halfmove_clock(fen_halfmove_clock)
+      @halfmove_clock = fen_halfmove_clock.to_i
+    end
+
+    def set_move_number(fen_move_number)
+      @move_number = fen_move_number.to_i
+    end
+
+    def additional_info
+      " #{to_move} #{castles} #{en_passant} #{halfmove_clock} #{move_number}"
+    end
+  end
+end

data/lib/bchess/helpers/field_between_helpers.rb

@@ -0,0 +1,50 @@
+module FieldBetweenHelpers
+  def row_fields(dcolumn, drow)
+    smaller, bigger = [column, dcolumn].sort
+    (smaller+1..bigger-1).map{|c| [c, row] }
+  end
+
+  def column_fields(dcolumn, drow)
+    smaller, bigger = [row, drow].sort
+    (smaller+1..bigger-1).map{|r| [column, r] }
+  end
+
+  def diagonal_fields(dcolumn, drow)
+    fields = []
+    if dcolumn > column
+      if drow > row
+        (dcolumn - column - 1).times do |i|
+          fields << [dcolumn-(i+1), drow-(i+1)]
+        end
+      else
+        (dcolumn - column - 1).times do |i|
+          fields << [dcolumn-(i+1), drow+(i+1)]
+        end
+      end
+    else
+      if drow > row
+        (column - dcolumn - 1).times do |i|
+          fields << [dcolumn+(i+1), drow-(i+1)]
+        end
+      else
+        (column - dcolumn - 1).times do |i|
+          fields << [dcolumn+(i+1), drow+(i+1)]
+        end
+      end
+    end
+    fields
+  end
+
+  def fields_between(dcolumn, drow)
+    return [] unless can_move_to_field?(dcolumn, drow)
+    if same_row?(drow)
+      row_fields(dcolumn, drow)
+    elsif same_column?(dcolumn)
+      column_fields(dcolumn, drow)
+    elsif same_diagonal?(dcolumn, drow)
+      diagonal_fields(dcolumn, drow)
+    else
+      []
+    end
+  end
+end

data/lib/bchess/helpers/validations.rb

@@ -0,0 +1,16 @@
+module Validations
+  def validate_move
+    if !valid_position?
+      read_fen
+      false
+    else
+      @fen = write_fen
+      true
+    end
+  end
+
+  def valid_position?
+    kings_present? &&
+      !king_attacked(just_moved)
+  end
+end

data/lib/bchess/king.rb

@@ -0,0 +1,30 @@
+module Bchess
+  class King < Piece
+
+    KINGS_REACH = 1
+
+    attr_reader :moved
+
+    def initiialize(*args)
+      super(args)
+      @moved = false
+    end
+
+    def name
+      'K'
+    end
+
+    def move(dcolumn, drow)
+      super(dcolumn, drow)
+      @moved = true
+    end
+
+    def can_move_to_field?(dcolumn, drow)
+      super &&
+        (
+          by_line(dcolumn, drow, KINGS_REACH) ||
+          by_diagonal(dcolumn, drow, KINGS_REACH)
+      )
+    end
+  end
+end

data/lib/bchess/knight.rb

@@ -0,0 +1,27 @@
+module Bchess
+  class Knight < Piece
+
+    def initiialize(*args)
+      super(args)
+    end
+
+    def name
+      'N'
+    end
+
+    def can_move_to_field?(dcolumn, drow)
+      super && by_jump(dcolumn, drow)
+    end
+
+    def fields_between(column, row)
+      []
+    end
+
+    private
+
+    def by_jump(dcolumn, drow)
+      (row - drow).abs + (column - dcolumn).abs == 3 &&
+        (row - drow).abs != 3 && (column - dcolumn).abs != 3
+    end
+  end
+end

data/lib/bchess/pawn.rb

@@ -0,0 +1,54 @@
+module Bchess
+  class Pawn < Piece
+
+    def initiialize(*args)
+      super(args)
+    end
+
+    def name
+      ''
+    end
+
+    def valid?
+      super && pawn_position?
+    end
+
+    def can_move_to_field?(dcolumn, drow)
+      super &&
+        pawn_move(dcolumn, drow)
+    end
+
+    def can_take_on_field?(dcolumn, drow)
+      direction = white? ? 1 : -1
+      by_diagonal(dcolumn, drow, 1) && (drow - row) == direction
+    end
+
+    private
+
+    def pawn_move(dcolumn, drow)
+      row_diff?(dcolumn, drow) &&
+        direction_kept?(dcolumn, drow) &&
+        column_kept?(dcolumn, column)
+    end
+
+    def column_kept?(dcolumn, column)
+      column == dcolumn
+    end
+
+    def direction_kept?(dcolumn, drow)
+      white? ? drow > row : row > drow
+    end
+
+    def row_diff?(dcolumn, drow)
+      (row - drow).abs <= (starting_position? ? 2 : 1)
+    end
+
+    def starting_position?
+      row == (white? ? 1 : 6)
+    end
+
+    def pawn_position?
+      (1..6).include?(row)
+    end
+  end
+end