chess_engine 0.0.1

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

data/lib/chess_engine.rb

@@ -0,0 +1 @@
+require_relative "chess_engine/game.rb"

data/spec/board_spec.rb

@@ -0,0 +1,70 @@
+require "./lib/chess_engine/board.rb"
+
+describe ChessEngine::Board do
+  before(:each) do
+    @board = ChessEngine::Board.new
+  end
+
+  describe "#initialize" do
+    it "creates empty board" do
+      expect(@board.instance_variable_get(:@board)).to eq(
+        [[nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil],
+        [nil, nil, nil, nil, nil, nil, nil, nil]])
+    end
+  end
+
+  describe "#to_s" do
+    it "converts empty board into string" do
+      expect(@board.to_s).to eq(
+        "8 \e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\n7 \e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\n6 \e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\n5 \e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\n4 \e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\n3 \e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\n2 \e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\n1 \e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\n  a b c d e f g h"
+      )
+    end
+
+    it "converts default board into string" do
+      @board.set_default
+      expect(@board.to_s).to eq(
+        "8 \e[0;39;49m♜ \e[0m\e[0;39;107m♞ \e[0m\e[0;39;49m▲ \e[0m\e[0;39;107m♛ \e[0m\e[0;39;49m♚ \e[0m\e[0;39;107m▲ \e[0m\e[0;39;49m♞ \e[0m\e[0;39;107m♜ \e[0m\n7 \e[0;39;107m♟ \e[0m\e[0;39;49m♟ \e[0m\e[0;39;107m♟ \e[0m\e[0;39;49m♟ \e[0m\e[0;39;107m♟ \e[0m\e[0;39;49m♟ \e[0m\e[0;39;107m♟ \e[0m\e[0;39;49m♟ \e[0m\n6 \e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\n5 \e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\n4 \e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\n3 \e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\e[0;39;107m  \e[0m\e[0;39;49m  \e[0m\n2 \e[0;39;49m♙ \e[0m\e[0;39;107m♙ \e[0m\e[0;39;49m♙ \e[0m\e[0;39;107m♙ \e[0m\e[0;39;49m♙ \e[0m\e[0;39;107m♙ \e[0m\e[0;39;49m♙ \e[0m\e[0;39;107m♙ \e[0m\n1 \e[0;39;107m♖ \e[0m\e[0;39;49m♘ \e[0m\e[0;39;107m△ \e[0m\e[0;39;49m♕ \e[0m\e[0;39;107m♔ \e[0m\e[0;39;49m△ \e[0m\e[0;39;107m♘ \e[0m\e[0;39;49m♖ \e[0m\n  a b c d e f g h"
+      )
+    end
+  end
+
+  describe "#move_piece" do
+    before(:each) do
+      @board.set_default
+      @board.move_piece([4, 1], [4, 3])
+    end
+
+    it "moves piece between two points" do
+      expect(@board[4, 1]).to be_nil
+      expect(@board[4, 3].pawn?).to eq(true)
+    end
+  end
+
+  describe "#exists_at?" do
+    it "returns true on valid positions" do
+      coord = []
+      (0..7).to_a.each { |x| coord += (0..7).to_a.map { |y| [x, y] } }
+      coord.each do |coordinates|
+        expect(@board.exists_at?(coordinates)).to eq(true)
+      end
+    end
+
+    it "returns false on negative values" do
+      [[-1, 5], [0, -2], [-1, 0], [-1, -1]].each do |coordinates|
+        expect(@board.exists_at?(coordinates)).to eq(false)
+      end
+    end
+
+    it "returns false on too big values" do
+      [[0, 8], [8, 3], [-1, 9], [8, 8]].each do |coordinates|
+        expect(@board.exists_at?(coordinates)).to eq(false)
+      end
+    end
+  end
+end

data/spec/game_helper.rb

@@ -0,0 +1,5 @@
+def execute_game(moves)
+  moves.each do |move|
+    @game.move(move)
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,79 @@
+require "./lib/chess_engine/game.rb"
+require "./spec/game_helper.rb"
+
+describe ChessEngine::Game do
+  before :each do
+    @game = ChessEngine::Game.new
+  end
+
+  describe "#move" do
+    it "raises an error if the empty square is chosen" do
+      expect { @game.move("e3e4") }.to raise_error(ChessEngine::InvalidMove, "Empty square is chosen")
+    end
+
+    it "raises an error if a player choses not his own piece" do
+      expect { @game.move("c7c6") }.to raise_error(ChessEngine::InvalidMove, "This is not your piece")
+    end
+
+    it "raises an error if invalid move is made" do
+      expect { @game.move("e2e5") }.to raise_error(ChessEngine::InvalidMove, "Invalid move")
+    end
+
+    it "raises an error if the move is fatal" do
+      execute_game(%w{a2a3 e7e6 a3a4 d8h4})
+      expect { @game.move("f2f3") }.to raise_error(ChessEngine::InvalidMove, "Fatal move")
+    end
+
+    it "makes correct moves" do
+      @game.move("e2e4")
+      expect(@game["e4"].pawn?).to eq(true)
+      expect(@game["e2"]).to be_nil
+    end
+
+    it "makes en passant" do
+      execute_game(%w{a2a4 h7h5 a4a5 b7b5 a5b6})
+      expect(@game["a5"]).to be_nil
+      expect(@game["b5"]).to be_nil
+      expect(@game["b6"].pawn?).to eq(true)
+      expect(@game["b6"].color).to eq(:white)
+    end
+  end
+
+  describe "#over?" do
+    it "recognizes the checkmate" do
+      execute_game(%w{f2f3 e7e6 g2g4 d8h4})
+      expect(@game.over?).to eq(true)
+    end
+
+    it "recognizes the stalemate" do
+      execute_game(%w{c2c4 h7h5 h2h4 a7a5 d1a4 a8a6 a4a5 a6h6 a5c7 f7f6 c7d7 e8f7 d7b7 d8d3 b7b8 d3h7 b8c8 f7g6 c8e6})
+      expect(@game.over?).to eq(true)
+    end
+  end
+
+  describe "#castling" do
+    it "plays with short and long castling" do
+      execute_game(%w{g1f3 b8a6 g2g3 b7b6 f1g2 c8b7 h2h3 c7c6})
+      @game.castling(:short)
+      expect(@game["g1"].king?).to eq(true)
+      expect(@game["f1"].rook?).to eq(true)
+      execute_game(%w{d8c7 h3h4})
+      @game.castling(:long)
+      expect(@game["c8"].king?).to eq(true)
+      expect(@game["d8"].rook?).to eq(true)
+    end
+  end
+
+  describe "#promotion" do
+    it "plays with promotion" do
+      expect(@game.needs_promotion?).to eq(false)
+      execute_game(%w{g2g4 h7h5 g1f3 h5g4 h2h4 g4g3 f1h3 g3g2 h1h2 g2g1})
+      expect(@game.needs_promotion?).to eq(true)
+      expect(@game.current_color).to eq(:black)
+      expect { @game.move("e2e4") }.to raise_error(ChessEngine::InvalidMove)
+      @game.promotion("Queen")
+      expect(@game["g1"].queen?).to eq(true)
+      expect(@game["g1"].color).to eq(:black)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end