chess_engine 0.0.2 → 0.0.5

data/lib/chess_engine/cli.rb

@@ -1,105 +0,0 @@
-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.filename}\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["./saved_games/*.yaml"].map { |filename| filename[/\.\/saved_games\/(.+)\.yaml/, 1] }
-      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("./saved_games/#{filename}.yaml"))
-    end
-
-    def save?
-      return false if @game.filename && File.exists?("./saved_games/#{@game.filename}.yaml") &&
-                      YAML::dump(@game) == File.read("./saved_games/#{@game.filename}.yaml")
-      choice = get_input("Do you want to save the game? (y/n): ", /^[yn]$/i)
-      choice == "y" ? true : false
-    end
-
-    def save
-      @game.filename ||= get_input("Enter the game name: ", /[^\/\>\<\|\:\&]+/)
-      game = YAML::dump(@game)
-      File.open("./saved_games/#{@game.filename}.yaml", "w") { |file| file.write(game) }
-    end
-  end
-end
-
-ChessEngine::CLI.new

data/lib/chess_engine/game.rb

@@ -1,148 +0,0 @@
-require_relative "board"
-require_relative "validator"
-require_relative "move"
-
-module ChessEngine
-  class InvalidMove < StandardError; end
-
-  class Game
-    attr_accessor :filename
-    attr_reader :current_color
-    include MoveValidator
-
-    def initialize
-      @board = Board.new
-      @board.set_default
-      @current_color = :white
-      @last_piece = nil
-      @filename = 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

@@ -1,19 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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