rb_chess 0.0.0

data/lib/rb_chess/fen_parser.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'pry-byebug'
+require_relative 'pieces/piece_constants'
+require_relative 'position'
+require_relative 'castling_rights'
+require_relative 'errors'
+
+# A class to parse Chess FEN notation
+module RbChess
+  class FENParser
+    include PieceConstants
+
+    BOARD_HEIGHT = 8
+    BOARD_WIDTH = 8
+
+    DEFAULT_NOTATION = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 0'
+    FEN_TOKEN_REGEX = /[pkqrbn\d]/i.freeze
+
+    ERROR_MESSAGES = {
+      invalid_token: 'Invalid FEN notation, token not valid',
+      invalid_board_width: "Invalid FEN notation, Board width is not equal to #{BOARD_WIDTH}",
+      invalid_board_height: "Invalid FEN notation, Board height not equal to #{BOARD_HEIGHT}"
+    }.freeze
+
+    def self.board_to_fen(board)
+      pieces = pieces_to_fen(board.pieces)
+      active = board.active_color == :white ? 'w' : 'b'
+      castling_rights = board.castling_rights.to_s
+      en_passant_pos = board.en_passant_square.nil? ? '-' : board.en_passant_square.to_s
+      halfmove = board.halfmove_clock.to_s
+      fullmove = board.fullmove_no.to_s
+
+      [pieces, active, castling_rights, en_passant_pos, halfmove, fullmove].join(' ')
+    end
+
+    def self.pieces_to_fen(pieces)
+      (0..7).map { |y| build_rank_fen(pieces, y) }.join('/')
+    end
+
+    def self.build_rank_fen(pieces, y)
+      rank = ''
+      no_of_consecutive_empty_cells = 0
+
+      0.upto(7) do |x|
+        piece = pieces.find { |piece| piece.position.y == y && piece.position.x == x }
+
+        if piece.nil?
+          no_of_consecutive_empty_cells += 1
+          rank += no_of_consecutive_empty_cells.to_s if x == (BOARD_WIDTH - 1)
+        else
+          rank += get_piece_letter(piece, no_of_consecutive_empty_cells)
+          no_of_consecutive_empty_cells = 0
+        end
+      end
+
+      rank
+    end
+
+    def self.get_piece_letter(piece, no_of_consecutive_empty_cells)
+      result = ''
+      result += no_of_consecutive_empty_cells.to_s if no_of_consecutive_empty_cells != 0
+
+      key = piece.class.name.split('::').last.to_sym
+      letter = PIECE_CLASS_TO_LETTER[key]
+      letter = piece.color == :white ? letter.upcase : letter
+      result + letter
+    end
+
+    def initialize(fen_notation = DEFAULT_NOTATION)
+      segments = fen_notation.split(' ')
+      raise ChessError unless segments.size == 6
+
+      @pieces = segments[0]
+      @active = segments[1]
+      @castling_rights = segments[2]
+      @en_passant_pos = segments[3]
+      @halfmove = segments[4]
+      @fullmove = segments[5]
+    end
+
+    def parse
+      {
+        pieces: parse_pieces,
+        active_color: active == 'w' ? :white : :black,
+        castling_rights: parse_castling_rights,
+        en_passant_square: en_passant_pos == '-' ? nil : Position.parse(en_passant_pos),
+        halfmove_clock: halfmove.to_i,
+        fullmove_no: fullmove.to_i
+      }
+    end
+
+    private
+
+    attr_reader :pieces, :active, :castling_rights, :en_passant_pos, :halfmove, :fullmove
+
+    def parse_castling_rights
+      res = CastlingRights.new
+
+      res.kingside[:white] = true if castling_rights.include?('K')
+      res.kingside[:black] = true if castling_rights.include?('k')
+      res.queenside[:white] = true if castling_rights.include?('Q')
+      res.queenside[:black] = true if castling_rights.include?('q')
+
+      res
+    end
+
+    def parse_pieces
+      ranks = pieces.split('/')
+      raise ChessError, ERROR_MESSAGES[:invalid_board_height] if ranks.length != BOARD_HEIGHT
+
+      ranks.each_with_index.reduce([]) { |res, (rank, y)| res.concat parse_rank_fen(rank, y) }
+    end
+
+    def parse_rank_fen(rank_fen, y)
+      tokens = rank_fen.split('')
+      pos = Position.new(y: y, x: -1)
+
+      pieces = tokens.reduce([]) do |res, token|
+        piece, pos = parse_token(token, pos)
+        res.push(piece)
+      end
+
+      raise ChessError, ERROR_MESSAGES[:invalid_board_width] if pos.x + 1 != BOARD_WIDTH
+
+      pieces.reject(&:nil?)
+    end
+
+    def parse_token(token, pos)
+      raise ChessError, ERROR_MESSAGES[:invalid_token] unless FEN_TOKEN_REGEX.match(token)
+
+      if is_integer? token
+        pos = pos.increment(x: token.to_i)
+        piece = nil
+      else
+        color = token.upcase == token ? :white : :black
+        piece_class = LETTER_TO_PIECE_CLASS[token.downcase.to_sym]
+
+        pos = pos.increment(x: 1)
+        piece = piece_class.new(color, pos)
+      end
+
+      [piece, pos]
+    end
+
+    def is_integer?(string)
+      /^\d+$/.match string
+    end
+  end
+end

data/lib/rb_chess/game.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'require_all'
+
+require_relative 'board'
+require_relative 'errors'
+require_rel 'game_modules'
+
+# A class to handle a chess game
+module RbChess
+  class Game
+    include MoveGenerator
+    include MoveParser
+    include MoveValidator
+
+    attr_reader :board
+
+    def initialize(fen: nil)
+      @board = Board.new(fen_notation: fen)
+      @starting_board = @board
+      @history = [].freeze
+      @repetitions_count = Hash.new(0) # for threefold repetition rule
+    end
+
+    def make_move(move)
+      raise ChessError, 'Game Over' if game_over?
+
+      move = parse_move move
+      raise ChessError, 'Cannot make move king in check' unless legal_move? move
+
+      @board = board.make_move move
+      @history = [*@history, move].freeze
+      update_repetitions_count
+    end
+
+    def winner
+      return unless checkmate?
+
+      current_player == :white ? :black : :white
+    end
+
+    def valid_move?(move)
+      move = parse_move move
+      legal_move? move
+    rescue ChessError
+      false
+    end
+
+    def all_moves
+      moves = board.player_pieces(current_player).reduce([]) do |res, piece|
+        res.concat moves_for_piece(piece, board)
+      end
+      moves.filter { |m| legal_move?(m) }.map(&:to_s)
+    end
+
+    def make_moves(moves)
+      moves.each { |m| make_move(m) }
+    end
+
+    def moves_at(pos)
+      moves_for_pos(pos, board).filter { |m| legal_move?(m) }.map(&:to_s)
+    end
+
+    def current_player
+      board.active_color
+    end
+
+    def stalemate?
+      no_moves?
+    end
+
+    def threefold?
+      repetitions_count.values.any? { |e| e >= 3 }
+    end
+
+    def fivefold?
+      repetitions_count.values.any? { |e| e >= 5 }
+    end
+
+    def seventy_five_moves?
+      board.halfmove_clock >= 150
+    end
+
+    def history
+      @history.map(&:to_s)
+    end
+
+    def fifty_moves?
+      board.halfmove_clock >= 100
+    end
+
+    def checkmate?
+      stalemate? && check?
+    end
+
+    def insufficient_material?
+      return true if board.pieces.size == 2 # only kings
+
+      return true if board.pieces.size == 3 &&
+                     board.pieces.any? { |p| p.is_a?(Knight) || p.is_a?(Bishop) }
+
+      if board.pieces.size == 4
+        bishops = board.pieces.select { |p| p.is_a? Bishop }
+        return bishops.length == 2 &&
+               bishops[0].position.square_type == bishops[1].position.square_type
+      end
+
+      false
+    end
+
+    def draw?
+      !checkmate? && (
+        stalemate? || fivefold? || insufficient_material? ||
+        seventy_five_moves?
+      )
+    end
+
+    def game_over?
+      checkmate? || draw?
+    end
+
+    def serialize
+      Marshal.dump(self)
+    end
+
+    def self.deserialize(data)
+      Marshal.load(data)
+    end
+
+    def as_json
+      data = {
+        moves: history,
+        starting_fen: starting_board.to_fen,
+        fen: board.to_fen
+      }
+      JSON.generate(data)
+    end
+
+    def self.from_json(json_data, with_history: false)
+      data = JSON.parse(json_data)
+      return new(fen: data['fen']) unless with_history
+
+      game = new(fen: data['starting_fen'])
+      game.make_moves data['moves']
+      game
+    end
+
+    private
+
+    def update_repetitions_count
+      # removes halfmove and fullmove since they are needed
+      board_fen = board.to_fen.split(' ').first(4).join(' ')
+      repetitions_count[board_fen] = repetitions_count[board_fen] + 1
+    end
+
+    def no_moves?
+      moves = board.player_pieces(current_player).reduce([]) do |res, piece|
+        res.concat moves_for_piece(piece, board)
+      end
+      moves.none? { |m| legal_move?(m) }
+    end
+
+    attr_reader :repetitions_count, :starting_board
+  end
+end

data/lib/rb_chess/game_modules/move_generator.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative '../position'
+require_relative '../pieces/piece_constants'
+require_relative '../move'
+
+# a module to generate moves for a piece
+module RbChess
+  module MoveGenerator
+    include PieceConstants
+
+    SPECIAL_MOVES = {
+      castle: :castle_moves,
+      en_passant: :en_passant_moves
+    }.freeze
+
+    def moves_for_pos(pos, board)
+      piece = board.piece_at pos
+      return [] unless piece&.color == board.active_color
+
+      moves_for_piece(piece, board)
+    end
+
+    def moves_for_piece(piece, board)
+      piece.move_sets.reduce([]) do |result, move_set|
+        move_set.increments.each do |increment|
+          result.concat(
+            gen_moves_for_increment(board, move_set, increment, piece)
+          )
+        end
+
+        result.concat gen_special_moves(board, move_set, piece)
+      end
+    end
+
+    private
+
+    def gen_moves_for_increment(board, move_set, increment, piece)
+      x, y = increment.values_at(:x, :y)
+      result = []
+
+      1.upto(move_set.repeat) do |factor|
+        new_pos = piece.position.increment(y: y * factor, x: x * factor)
+        break if new_pos.out_of_bounds? || blocked?(board, move_set, piece, new_pos)
+
+        removed = board.piece_at(new_pos).nil? ? nil : new_pos.to_s
+        from = piece.position.to_s
+        to = new_pos.to_s
+
+        if move_set.promotable && piece.can_promote?(new_pos)
+          result.concat promotion_moves(piece, from: from, to: to, removed: removed)
+        else
+          result << Move.new(from: from, to: to, removed: removed)
+        end
+
+        break unless removed.nil?
+      end
+
+      result
+    end
+
+    def promotion_moves(piece, from:, to:, removed:)
+      piece.promotion_pieces.map do |letter|
+        Move.new(from: from, to: to, removed: removed, promotion: letter)
+      end
+    end
+
+    def blocked?(board, move_set, piece, new_pos)
+      other_piece = board.piece_at new_pos
+      return true if other_piece.nil? && move_set.blocked_by.include?(:empty)
+
+      return true if other_piece && move_set.blocked_by.include?(:piece)
+
+      return true if other_piece&.color == piece.color && move_set.blocked_by.include?(:same)
+
+      return true if other_piece&.color != piece.color && move_set.blocked_by.include?(:enemy)
+
+      false
+    end
+
+    def gen_special_moves(board, move_set, piece)
+      result = []
+      move_set.special_moves.each do |sym|
+        result.concat send(SPECIAL_MOVES[sym], board, piece)
+      end
+
+      result.reject(&:nil?)
+    end
+
+    def castle_moves(board, piece)
+      [
+        kingside_castle_move(board, piece),
+        queenside_castle_move(board, piece)
+      ].reject(&:nil?)
+    end
+
+    def en_passant_moves(board, piece)
+      moves = [-1, 1].map do |x|
+        from = piece.position
+        to = piece.position.increment(y: piece.direction, x: x)
+        removed = piece.position.increment(x: x)
+        next nil unless board.en_passant_square == to
+
+        Move.new(from: from.to_s, to: to.to_s, removed: removed.to_s)
+      end
+
+      moves.reject(&:nil?)
+    end
+
+    def kingside_castle_move(board, piece)
+      return unless board.can_castle_kingside? piece.color
+
+      return unless kingside_castle_squares_available?(board, piece)
+
+      king_from = piece.position.to_s
+      king_to = piece.position.increment(x: 2).to_s
+      rook_from = piece.color == :white ? 'h1' : 'h8'
+      rook_to = piece.color == :white ? 'f1' : 'f8'
+
+      move = Move.new(from: king_from, to: king_to, castle: :kingside)
+      move.add_move(from: rook_from, to: rook_to)
+      move
+    end
+
+    def queenside_castle_move(board, piece)
+      return unless board.can_castle_queenside? piece.color
+
+      return unless queenside_castle_squares_available?(board, piece)
+
+      king_from = piece.position.to_s
+      king_to = piece.position.increment(x: -2).to_s
+      rook_from = piece.color == :white ? 'a1' : 'a8'
+      rook_to = piece.color == :white ? 'd1' : 'd8'
+
+      move = Move.new(from: king_from, to: king_to, castle: :queenside)
+      move.add_move(from: rook_from, to: rook_to)
+      move
+    end
+
+    def kingside_castle_squares_available?(board, piece)
+      positions = piece.color == :white ? %w[f1 g1] : %w[f8 g8]
+      positions.all? do |pos|
+        board.piece_at(pos).nil?
+      end
+    end
+
+    def queenside_castle_squares_available?(board, piece)
+      positions = piece.color == :white ? %w[b1 c1 d1] : %w[b8 c8 g8]
+      positions.all? do |pos|
+        board.piece_at(pos).nil?
+      end
+    end
+  end
+end

data/lib/rb_chess/game_modules/move_parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'move_generator'
+require_relative '../errors'
+
+module RbChess
+  module MoveParser
+    include MoveGenerator
+
+    MOVE_REGEX = /^(0-0)|(0-0-0)|(([a-h][1-8]){2}[qrbn]?)$/i.freeze
+
+    def parse_move(move)
+      raise ChessError, "Invalid move format cannot parse: #{move}" unless MOVE_REGEX.match move
+
+      castling_move?(move) ? castling_move(move) : normal_move(move)
+    end
+
+    def castling_move?(move)
+      /(0-0)|(0-0-0)/.match move
+    end
+
+    def castling_move(move)
+      pos = current_player == :white ? 'e1' : 'e8'
+      type = move == '0-0' ? :kingside : :queenside
+
+      moves = moves_for_pos(pos, board)
+      move = moves.find { |m| m.castle == type }
+
+      raise ChessError, "Invalid move, cannot castle #{type}" unless move
+
+      move
+    end
+
+    def normal_move(move_str)
+      _, pos, to, promotion = * /^(\w{2})(\w{2})(\w?)$/.match(move_str)
+      moves = moves_for_pos(pos, board)
+      move = moves.find { |m| m.to_s.downcase == move_str.downcase }
+      raise ChessError, "Invalid move: #{move}" unless move
+
+      move
+    end
+  end
+end

data/lib/rb_chess/game_modules/move_validator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'move_generator'
+
+module RbChess
+  module MoveValidator
+    include MoveGenerator
+
+    def legal_move?(move)
+      new_board = board.make_move move
+      is_check = check?(boardn: new_board, color: current_player)
+
+      return !is_check && legal_castle_move?(move) if move.castle
+
+      !is_check
+    end
+
+    def check?(boardn: board, color: current_player)
+      king = boardn.pieces.find { |piece| piece.is_a?(King) && piece.color == color }
+      king ? pos_attacked?(boardn, king.position, color) : false
+    end
+
+    def legal_castle_move?(move)
+      can_castle = move.castle == :kingside ? legal_kingside_castle_move? : legal_queenside_castle_move?
+      can_castle && !check?
+    end
+
+    def legal_kingside_castle_move?
+      positions = current_player == :white ? %w[f1 g1] : %w[f8 g8]
+      positions.none? { |pos| pos_attacked?(board, Position.parse(pos), current_player) }
+    end
+
+    def legal_queenside_castle_move?
+      positions = current_player == :white ? %w[b1 c1 d1] : %w[b8 c8 d8]
+      positions.none? { |pos| pos_attacked?(board, Position.parse(pos), current_player) }
+    end
+
+    def pos_attacked?(board, pos, color)
+      opponent_color = color == :white ? :black : :white
+      pieces = board.player_pieces(opponent_color)
+      moves = pieces.reduce([]) { |res, piece| res.concat moves_for_piece(piece, board) }
+      moves.any? do |move|
+        move.moved.any? { |hash| hash[:to] == pos }
+      end
+    end
+  end
+end

data/lib/rb_chess/letter_display.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'position'
+require_relative 'pieces/piece_constants'
+
+# A module to display chess board on console
+module RbChess
+  module LetterDisplay
+    include PieceConstants
+
+    COLUMN_LABELS = '   a b c d e f g h'
+    SEPARATOR = '  _________________'
+
+    def ascii
+      ranks = (0..7).map { |rank_no| rank_ascii(rank_no) }
+      result = [COLUMN_LABELS, SEPARATOR] + ranks + [SEPARATOR, COLUMN_LABELS]
+      result.join("\n")
+    end
+
+    private
+
+    def rank_ascii(rank_no)
+      result = (0..7).map do |file_no|
+        piece_ascii(rank_no, file_no)
+      end
+
+      result.unshift("#{8 - rank_no} ")
+      result.push(" #{8 - rank_no}")
+      result.join(' ')
+    end
+
+    def piece_ascii(rank_no, file_no)
+      pos = Position.new(y: rank_no, x: file_no)
+      piece = piece_at(pos)
+      return '-' if piece.nil?
+
+      key = piece.class.name.split('::').last.to_sym
+      result = PIECE_CLASS_TO_LETTER[key]
+      piece.color == :black ? result.downcase : result.upcase
+    end
+  end
+end

data/lib/rb_chess/move.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# A class to represent a chess move
+module RbChess
+  class Move
+    attr_reader :moved, :removed, :promotion, :castle
+
+    def initialize(from:, to:, removed: nil, promotion: nil, castle: nil)
+      @promotion = promotion
+      @castle = castle
+      @removed = Position.parse(removed) if removed
+      @moved = [{ from: Position.parse(from), to: Position.parse(to) }].freeze
+    end
+
+    def add_move(from:, to:)
+      @moved = [*moved, { from: Position.parse(from), to: Position.parse(to) }].freeze
+    end
+
+    def destination_for(from)
+      hash = moved.find { |hash| hash[:from] == from }
+      hash[:to]
+    end
+
+    def to_s
+      return '0-0' if castle == :kingside
+
+      return '0-0-0' if castle == :queenside
+
+      moves = moved.map { |hash| "#{hash[:from]}#{hash[:to]}#{promotion.to_s.upcase}" }
+      moves.join(',')
+    end
+  end
+end

data/lib/rb_chess/move_set.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true|
+
+# A class to represent info about how a piece moves on the body
+module RbChess
+  class MoveSet
+    attr_accessor :increments, :repeat, :blocked_by, :promotable, :special_moves
+
+    def initialize(increments:, repeat:, blocked_by: [], special_moves: [], promotable: false)
+      @increments = increments
+      @repeat = repeat
+      @blocked_by = blocked_by
+      @special_moves = special_moves
+      @promotable = promotable
+    end
+  end
+end

data/lib/rb_chess/pieces/bishop.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../move_set'
+require_relative 'piece'
+
+# A class to represent a bishop in a chess game
+module RbChess
+  class Bishop < Piece
+    attr_reader :move_sets
+
+    def initialize(color, position)
+      super
+      increments = [{ y: 1, x: 1 }, { y: -1, x: 1 }, { y: -1, x: -1 },
+                    { y: 1, x: -1 }]
+      @move_sets = [
+        MoveSet.new(
+          increments: increments,
+          repeat: Float::INFINITY,
+          blocked_by: [:same]
+        )
+      ]
+    end
+  end
+end

data/lib/rb_chess/pieces/king.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../move_set'
+require_relative 'piece'
+
+# A class to represent a kong in chess
+module RbChess
+  class King < Piece
+    attr_reader :move_sets
+
+    def initialize(color, position)
+      super
+      increments = [{ y: -1, x: -1 }, { y: 1, x: 1 }, { y: 1, x: -1 },
+                    { y: -1, x: 1 }, { y: 0, x: -1 }, { y: 0, x: 1 },
+                    { y: -1, x: 0 }, { y: 1, x: 0 }]
+      @move_sets = [
+        MoveSet.new(
+          increments: increments,
+          repeat: 1,
+          blocked_by: [:same],
+          special_moves: %i[castle]
+        )
+      ]
+    end
+  end
+end