chess_engine 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b15851b7a37794b22b28cd86c5a79df19b682f8b8dbfe9c4e3d49ff461dc1bc7
+  data.tar.gz: dcaf7521f85bb9a629d9fc5a1cab10c380cd5eab759eeb0b1ffbaf8070dbb16f
+SHA512:
+  metadata.gz: b85b9135a9236f23558e77eb5f86ec987933b2776b4f0348730de0b141c301dca7968be94242f5b8b1ae1a22a9597316f664c1f9b4e36c1fbb9aec392ba66fc4
+  data.tar.gz: 1993ff33b65b1f035d5c985a9710f8558bf0e496f4fadfacc0974b358ed2c8a7c4f8393468b54c6846d05789cbb02ad9d6bb732c15792fe4902d205b65f92ccd

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'pry', '~> 0.12.2'
+gem 'rb-readline'
+gem 'colorize', '~> 0.8.1'

data/Gemfile.lock

@@ -0,0 +1,21 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    colorize (0.8.1)
+    method_source (0.9.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rb-readline (0.5.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  colorize (~> 0.8.1)
+  pry (~> 0.12.2)
+  rb-readline
+
+BUNDLED WITH
+   2.0.1

data/README.md

@@ -0,0 +1,26 @@
+# Command Line Chess
+This is my final Ruby project before moving to Rails framework. In this PvP game I've tried to apply all the stuff I have learned to this moment.
+
+### Features:
+* It works
+* You can make all the legal moves, including:
+  * Castling
+  * En passant
+  * Pawn promotion
+* The game detects and declares:
+  * Check
+  * Checkmate
+  * Stalemate
+* You can quit and save the game at almost every moment
+
+## How to start
+Here are the steps you need to make to play this game:
+1. Make sure that Ruby is installed on your machine
+2. Go to the main directory of the project
+3. Type `ruby lib/chess/cli.rb` in your command line
+
+## How to play
+* Trivial moves are made by typing in something like "e2e4" or `e3 f5` or even ` a 1 b 3 ` (whitespace doesn't matter)
+* Short castling is done by typing in `00`, `oo` or `OO`
+* Long castling is done by typing in `000`, `ooo` or `OOO`
+* To quit the game, type in "exit". You will be asked to save the game

data/chess_engine.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = "chess_engine"
+  s.summary = "Simple chess library that uses algebraic notation"
+  s.description = File.read(File.join(File.dirname(__FILE__), 'README.md'))
+  s.version = "0.0.1"
+  s.author = "Anikeev Gennadiy"
+  s.email = "genaydzhan70@gmail.com"
+  s.homepage = "https://github.com/anikeef/chess"
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.9'
+  s.files = Dir['**/**']
+  s.test_files = Dir["spec/*.rb"]
+  s.has_rdoc = false
+end

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,105 @@
+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

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

@@ -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