chess_engine 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 715d471484b4e74f3ea03d4a5efc6b206ae414626ecdf7c31dea440579237ff5
-  data.tar.gz: be335d9dc761bef96bb75056d0ea83fcd16456e851ce802ae07e8fc4ed30632e
+  metadata.gz: 96485fa28f530a602da170422a2b08b757a674bef18cc89d995f620b91c9d4f0
+  data.tar.gz: b9d5e4ba5d7e632bc9db2906667deee9c4b807e76371eff33022c3a9c88f5fc4
 SHA512:
-  metadata.gz: 6233ac39dcaa5153f4284cde217842295bcc336bcfb2764a6bbb96d5695f18c252a1a61ebc764b35de4e37cae0dc758069c44271b21d1cfcfed43a86a4d0492b
-  data.tar.gz: 6873b7022d9a44a392f3cc5eb71af17c27baead9aa4fc7d7353f653bacbac8773be384676d9e58990f2a35f3fbe632952c7a74b92d840287a4e111ede4f7397a
+  metadata.gz: 2eca066e4f4ad8c4afd56f82a580a40e7568f187ca4e68a1c914fab1ae3d16c48bf75e28fe8a9b8992bcb44db51618aa016440112be590b12b81f7e7cbe75b7d
+  data.tar.gz: 8f20a87cd9d933ce5cd5b945937d7d3d208edf476633d4e0236f63ed25c262630161f01f5581d227ea8c893eb50bd8f308debe78021213fca11a8d0e0082d912

data/lib/chess_engine/board.rb

@@ -0,0 +1,95 @@
+require_relative "piece"
+require "colorize"
+
+module ChessEngine
+  class Board
+    def initialize
+      @board = Array.new(8) { Array.new(8) { nil } }
+    end
+
+    def set_default
+      [[:white, 0, 1], [:black, 7, 6]].each do |color, row1, row2|
+        ["Rook", "Knight", "Elephant", "Queen", "King", "Elephant", "Knight", "Rook"].each.with_index do |class_name, column|
+          self[column, row1] = Module.const_get("ChessEngine::#{class_name}").new(color)
+        end
+
+        0.upto(7) do |column|
+          self[column, row2] = Pawn.new(color)
+        end
+      end
+    end
+
+    def [](column, row)
+      @board[column][row]
+    end
+
+    def []=(column, row, piece)
+      @board[column][row] = piece
+    end
+
+    def at(coordinates)
+      return nil unless self.exists_at?(coordinates)
+      @board[coordinates[0]][coordinates[1]]
+    end
+
+    def set_at(coordinates, piece)
+      @board[coordinates[0]][coordinates[1]] = piece
+    end
+
+    def exists_at?(coordinates)
+      coordinates.all? { |c| c.between?(0, 7) }
+    end
+
+    def to_s
+      string = ""
+      colors = [[:default, :light_white].cycle, [:light_white, :default].cycle].cycle
+
+      7.downto(0) do |row|
+        string += "#{row + 1} "
+        colors_cycle = colors.next
+
+        0.upto(7) do |column|
+          piece = self[column, row]
+          string += piece.nil? ? " " : piece.symbol
+          string += " "
+          string[-2..-1] = string[-2..-1].colorize(background: colors_cycle.next)
+        end
+        string += "\n"
+      end
+
+      string += "  a b c d e f g h"
+      string
+    end
+
+    def move_piece(from, to)
+      piece = self.at(from)
+      self.set_at(from, nil)
+      self.set_at(to, piece)
+    end
+
+    def pieces(color)
+      @board.flatten.compact.select { |piece| piece.color == color }
+    end
+
+    def Board.coordinates_list
+      list = []
+      (0..7).each do |x|
+        (0..7).each { |y| list << [x, y]}
+      end
+      list
+    end
+
+    def king_coords(color)
+      Board.coordinates_list.find do |coord|
+        at(coord) && at(coord).king? && at(coord).color == color
+      end
+    end
+
+    def piece_coordinates(color)
+      Board.coordinates_list.select do |coord|
+        piece = at(coord)
+        !piece.nil? && piece.color == color
+      end
+    end
+  end
+end

data/lib/chess_engine/cli.rb

@@ -0,0 +1,106 @@
+require_relative "game"
+require_relative "input"
+require "yaml"
+
+
+module ChessEngine
+  class NoGamesError < StandardError; end
+
+  class CLI
+    include Input
+
+    def initialize
+      begin
+        mode = get_input("\nChoose the game mode:\n1. New game\n2. Continue\nEnter your choice (1 or 2): ", /^[12]$/)
+        @game = mode == "1" ? Game.new : choose_game
+      rescue NoGamesError => e
+        puts "#{e.message}. Try again"
+        retry
+      end
+      play
+      save if save?
+    end
+
+    private
+
+    def play
+      until @game.over?
+        puts "\n#{@game.name}\n#{@game.draw}"
+        declare_check if @game.check?
+        begin
+          promotion if @game.needs_promotion?
+          print "#{@game.current_color.to_s.capitalize}'s move (e. g. \"e2e4\" or \"exit\" or \"000\"/\"00\" (for castling)): "
+          move = gets.chomp.gsub(/\s+/, " ")
+          case move
+          when /^[oOоО0]{2}$/ #matches cyrillic letters
+            @game.castling(:short)
+          when /^[oOоО0]{3}$/
+            @game.castling(:long)
+          when /^[a-h][1-8][a-h][1-8]$/i
+            @game.move(move)
+          when /^exit$/i
+            return
+          else
+            raise InvalidMove, "Incorrect input"
+          end
+        rescue InvalidMove => e
+          puts "#{e.message}. Try again"
+          retry
+        end
+      end
+      game_over
+    end
+
+    def promotion
+      pieces = ["Queen", "Rook", "Knight", "Elephant"]
+      choice = get_input(
+        "Pawn promotion. Choose the new piece:\n1. Queen\n2. Rook\n3. Knight\n4. Elephant",
+        /^[1-4]$/, "Input must be a single digit"
+      )
+      @game.promotion(pieces[choice - 1])
+    end
+
+    def declare_check
+      puts "#{@game.current_color.to_s.capitalize} player is given a check"
+    end
+
+    def declare_checkmate
+      puts "#{@game.current_color.to_s.capitalize} player got mated!"
+    end
+
+    def game_over
+      puts @game.draw
+      if @game.check?
+        declare_checkmate
+      else
+        puts "Stalemate!"
+      end
+    end
+
+    def choose_game
+      saved_names = Dir[File.join(CLI.dirname, "/*.yaml")].map { |filename| File.basename(filename, ".yaml") }
+      raise NoGamesError, "You have no saved games" if saved_names.empty?
+      puts "\nSaved games (#{saved_names.size}):"
+      saved_names.each { |name| puts name }
+      filename = get_input("Enter the name of the game that you want to continue: ",
+        nil, "Such game doesn't exist, try again") { |input| saved_names.include?(input) }
+      return YAML::load(File.read(File.join(CLI.dirname, "#{filename}.yaml")))
+    end
+
+    def save?
+      choice = get_input("Do you want to save the game? (y/n): ", /^[yn]$/i)
+      choice == "y" ? true : false
+    end
+
+    def save
+      @game.name ||= get_input("Enter the game name: ", /[^\/\>\<\|\:\&]+/)
+      game = YAML::dump(@game)
+      Dir.mkdir(CLI.dirname) unless File.exists?(CLI.dirname)
+      File.open(File.join(CLI.dirname, "#{@game.name}.yaml"), "w") { |file| file.write(game) }
+    end
+
+    def CLI.dirname
+      File.join(Dir.home, "./.chess_engine")
+    end
+  end
+end

data/lib/chess_engine/game.rb

@@ -0,0 +1,148 @@
+require_relative "board"
+require_relative "validator"
+require_relative "move"
+
+module ChessEngine
+  class InvalidMove < StandardError; end
+
+  class Game
+    attr_accessor :name
+    attr_reader :current_color
+    include MoveValidator
+
+    def initialize
+      @board = Board.new
+      @board.set_default
+      @current_color = :white
+      @last_piece = nil
+      @name = nil
+      @promotion_coord = false
+    end
+
+    def move(string)
+      from, to = Game.string_to_move(string)
+      piece = @board.at(from)
+      raise InvalidMove, "Game is over" if over?
+      raise InvalidMove, "#{@current_color} player should execute pawn promotion first" if needs_promotion?
+      raise InvalidMove, "Empty square is chosen" if piece.nil?
+      raise InvalidMove, "This is not your piece" unless piece.color == @current_color
+      raise InvalidMove, "Invalid move" unless valid_moves(from).include?(to)
+      move = Move.new(@board, from, to)
+      move.commit
+      if king_attacked?
+        move.rollback
+        raise InvalidMove, "Fatal move"
+      end
+
+      @last_piece = piece
+      piece.moves_count += 1
+      @promotion_coord = to and return if piece.pawn? && [7, 0].include?(to[1])
+      next_player
+    end
+
+    def [](str)
+      letters = ("a".."h").to_a
+      return nil unless /[a-h][1-8]/.match?(str)
+      @board.at([letters.find_index(str[0]), str[1].to_i - 1])
+    end
+
+    def draw
+      @board.to_s
+    end
+
+    def promotion(class_name)
+      unless ["rook", "knight", "elephant", "queen"].include?(class_name.downcase)
+        raise InvalidMove, "Invalid promotion"
+      end
+      @board.set_at(@promotion_coord, Module.const_get("ChessEngine::#{class_name.capitalize}").new(@current_color))
+      @promotion_coord = nil
+      next_player
+    end
+
+    def castling(length)
+      row = @current_color == :white ? 0 : 7
+      king = @board.at([4, row])
+      if length == :short
+        rook = @board.at([7, row])
+        line = [5, 6]
+        moves = [Move.new(@board, [4, row], [6, row]),
+          Move.new(@board, [7, row], [5, row])]
+      else
+        rook = @board.at([0, row])
+        line = [1, 2, 3]
+        moves = [Move.new(@board, [4, row], [2, row]),
+          Move.new(@board, [0, row], [3, row])]
+      end
+      raise InvalidMove, "Invalid castling" unless
+        king && rook && king.moves_count == 0 && rook.moves_count == 0 &&
+        line.all? { |x| @board.at([x, row]).nil? }
+
+      moves.each { |move| move.commit }
+      if king_attacked?
+        moves.each { |move| move.rollback }
+        raise InvalidMove, "Fatal move"
+      end
+      @last_piece = nil
+      next_player
+    end
+
+    def over?
+      @board.piece_coordinates(@current_color).all? do |coord|
+        safe_moves(coord).empty?
+      end
+    end
+
+    def needs_promotion?
+      !!@promotion_coord
+    end
+
+    def check?
+      king_attacked?
+    end
+
+    private
+
+    def king_attacked?
+      king_coords = @board.king_coords(@current_color)
+      [[1, 1], [-1, 1], [-1, -1], [1, -1]].each do |move|
+        next_coords = relative_coords(king_coords, move)
+        piece = @board.at(next_coords)
+        return true if piece && piece.color != @current_color && (piece.pawn? || piece.king?)
+        edge_coords = repeated_move(king_coords, move).last
+        piece = edge_coords.nil? ? nil : @board.at(edge_coords)
+        return true if piece && piece.beats_diagonally?
+      end
+      [[1, 0], [-1, 0], [0, 1], [0, -1]].each do |move|
+        next_coords = relative_coords(king_coords, move)
+        piece = @board.at(next_coords)
+        return true if piece && piece.king?
+        edge_coords = repeated_move(king_coords, move).last
+        piece = edge_coords.nil? ? nil : @board.at(edge_coords)
+        return true if !piece.nil? && piece.beats_straight?
+      end
+      [[1, 2], [2, 1], [1, -2], [-2, 1],
+      [-1, 2], [2, -1], [-1, -2], [-2, -1]].each do |move|
+        coords = relative_coords(king_coords, move)
+        piece = valid_move?(coords) ? @board.at(coords) : nil
+        return true if !piece.nil? && piece.knight?
+      end
+      false
+    end
+
+    def Game.string_to_move(string)
+      string = string.gsub(/\s+/, "").downcase
+      raise InvalidMove, "Input must look like \"e2 e4\" or \"a6b5\"" unless /^[a-h][1-8][a-h][1-8]$/.match?(string)
+      letters = ("a".."h").to_a
+      [[letters.find_index(string[0]), string[1].to_i - 1],
+       [letters.find_index(string[2]), string[3].to_i - 1]]
+    end
+
+    def opposite_color
+      @current_color == :white ? :black : :white
+    end
+
+    def next_player
+      @current_color = opposite_color
+    end
+  end
+end

data/lib/chess_engine/input.rb

@@ -0,0 +1,19 @@
+module Input
+  class Incorrect < StandardError; end
+
+  def get_input(input_message, regex = nil, err_message = "Incorrect input, try again")
+    begin
+      print input_message
+      input = gets.chomp
+      if block_given?
+        raise Input::Incorrect unless yield(input)
+      else
+        raise Input::Incorrect unless regex.match?(input)
+      end
+    rescue
+      puts err_message
+      retry
+    end
+    input
+  end
+end

data/lib/chess_engine/move.rb

@@ -0,0 +1,35 @@
+module ChessEngine
+  class Move
+    def initialize(board, from, to)
+      @board = board
+      @from = from
+      @to = to
+      @original_squares = []
+      @original_squares << {coord: from, piece: board.at(from)}
+      @original_squares << {coord: to, piece: board.at(to)}
+      if en_passant?
+        @en_passant_coord = [to[0], from[1]]
+        @original_squares << {coord: @en_passant_coord, piece: board.at(@en_passant_coord)}
+      end
+    end
+
+    def commit
+      if en_passant?
+        @board.set_at(@en_passant_coord, nil)
+      end
+      @board.move_piece(@from, @to)
+    end
+
+    def rollback
+      @original_squares.each do |square|
+        @board.set_at(square[:coord], square[:piece])
+      end
+    end
+
+    private
+
+    def en_passant?
+      @board.at(@from).pawn? && @from[0] != @to[0] && @board.at(@to).nil?
+    end
+  end
+end

data/lib/chess_engine/piece.rb

@@ -0,0 +1,97 @@
+module ChessEngine
+  class Piece
+    attr_reader :symbol, :color
+    attr_accessor :moves_count
+
+    def initialize(color)
+      @color = color
+      @moves_count = 0
+    end
+
+    def inspect
+      "#{self.class}:#{@color}"
+    end
+
+    def beats_diagonally?
+      elephant? || queen?
+    end
+
+    def beats_straight?
+      rook? || queen?
+    end
+
+    ["knight", "king", "pawn", "rook", "queen", "elephant"].each do |piece|
+      define_method(:"#{piece}?") do
+        self.class.to_s == "ChessEngine::#{piece.capitalize}"
+      end
+    end
+  end
+
+  class Elephant < Piece
+    def initialize(color)
+      super
+      @symbol = (@color == :black) ? "\u25B2" : "\u25B3"
+    end
+
+    def moves
+      [[1, 1], [1, -1], [-1, 1], [-1, -1]]
+    end
+  end
+
+  class King < Piece
+    def initialize(color)
+      super
+      @symbol = (@color == :black) ? "\u265A" : "\u2654"
+    end
+
+    def moves
+      [[0, 1], [0, -1], [1, 0], [-1, 0],
+      [1, 1], [1, -1], [-1, 1], [-1, -1]]
+    end
+  end
+
+  class Knight < Piece
+    def initialize(color)
+      super
+      @symbol = (@color == :black) ? "\u265E" : "\u2658"
+    end
+
+    def moves
+      [[1, 2], [2, 1], [1, -2], [-2, 1],
+      [-1, 2], [2, -1], [-1, -2], [-2, -1]]
+    end
+  end
+
+  class Pawn < Piece
+    attr_reader :direction
+
+    def initialize(color)
+      super
+      @symbol = (@color == :black) ? "\u265F" : "\u2659"
+      @direction = (@color == :white) ? 1 : -1
+    end
+  end
+
+  class Queen < Piece
+    def initialize(color)
+      super
+      @symbol = (@color == :black) ? "\u265B" : "\u2655"
+    end
+
+    def moves
+      [[0, 1], [0, -1], [1, 0], [-1, 0],
+      [1, 1], [1, -1], [-1, 1], [-1, -1]]
+    end
+  end
+
+  class Rook < Piece
+    def initialize(color)
+      super
+      @symbol = (@color == :black) ? "\u265C" : "\u2656"
+    end
+
+    def moves
+      [[1, 0], [0, 1], [-1, 0], [0, -1]]
+    end
+  end
+end

data/lib/chess_engine/validator.rb

@@ -0,0 +1,87 @@
+module ChessEngine
+  module MoveValidator
+    def safe_moves(from)
+      valid_moves(from).reject { |move| fatal_move?(from, move) }
+    end
+
+    def valid_moves(from)
+      piece = @board.at(from)
+      if piece.king? || piece.knight?
+        piece.moves.map do |move|
+          to = relative_coords(from, move)
+          to if valid_move?(to)
+        end.compact
+      elsif piece.pawn?
+        pawn_valid_moves(from)
+      else
+        valid_moves_recursive(from)
+      end
+    end
+
+    def valid_moves_recursive(from)
+      piece = @board.at(from)
+      piece.moves.inject([]) do |valid_moves, move|
+        valid_moves.push(*repeated_move(from, move))
+      end
+    end
+
+    def repeated_move(from, move, valid_moves = [])
+      coordinates = relative_coords(from, move)
+      return valid_moves unless valid_move?(coordinates)
+      return valid_moves << coordinates unless @board.at(coordinates).nil?
+      repeated_move(coordinates, move, valid_moves << coordinates)
+    end
+
+    def relative_coords(from, move)
+      [from[0] + move[0], from[1] + move[1]]
+    end
+
+    def valid_move?(coordinates)
+      if @board.exists_at?(coordinates)
+        piece = @board.at(coordinates)
+        return (piece.nil? || piece.color != @current_color)
+      end
+      return false
+    end
+
+    def fatal_move?(from, to)
+      is_fatal = false
+      move = Move.new(@board, from, to)
+      move.commit
+      is_fatal = true if king_attacked?
+      move.rollback
+      is_fatal
+    end
+
+    def pawn_valid_moves(from)
+      pawn = @board.at(from)
+      direction = pawn.direction
+      moves = []
+      next_coords = relative_coords(from, [0, direction])
+      jump_coords = relative_coords(from, [0, direction * 2])
+      take_coords = [relative_coords(from, [1, direction]),
+        relative_coords(from, [-1, direction])]
+      if @board.exists_at?(next_coords) && @board.at(next_coords).nil?
+        moves << next_coords
+        moves << jump_coords unless pawn.moves_count > 0 || @board.at(jump_coords)
+      end
+      take_coords.each do |coords|
+        moves << coords if @board.at(coords) && @board.at(coords).color != pawn.color
+      end
+      en_passant_coords(from) ? moves << en_passant_coords(from) : moves
+    end
+
+    def en_passant_coords(from)
+      pawn = @board.at(from)
+      [1, -1].each do |x|
+        next_coords = [from[0] + x, from[1]]
+        next_piece = @board.at(next_coords)
+        if next_piece.class == Pawn && next_piece == @last_piece &&
+          next_piece.moves_count == 1 && from[1].between?(3, 4)
+            return [from[0] + x, from[1] + pawn.direction]
+        end
+      end
+      nil
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chess_engine
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Anikeev Gennadiy
@@ -20,6 +20,13 @@ extra_rdoc_files: []
 files:
 - bin/chess_engine
 - lib/chess_engine.rb
+- lib/chess_engine/board.rb
+- lib/chess_engine/cli.rb
+- lib/chess_engine/game.rb
+- lib/chess_engine/input.rb
+- lib/chess_engine/move.rb
+- lib/chess_engine/piece.rb
+- lib/chess_engine/validator.rb
 - spec/board_spec.rb
 - spec/game_helper.rb
 - spec/game_spec.rb