chess_engine 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96485fa28f530a602da170422a2b08b757a674bef18cc89d995f620b91c9d4f0
-  data.tar.gz: b9d5e4ba5d7e632bc9db2906667deee9c4b807e76371eff33022c3a9c88f5fc4
+  metadata.gz: ed27d3f266a1511e2db0726d00a983c73576324865e7c5b4aa6d936aa0934210
+  data.tar.gz: ced0a13a3ef74199cc0f74b1673ddf34260d3f53cba30af6321c24bc814c0f65
 SHA512:
-  metadata.gz: 2eca066e4f4ad8c4afd56f82a580a40e7568f187ca4e68a1c914fab1ae3d16c48bf75e28fe8a9b8992bcb44db51618aa016440112be590b12b81f7e7cbe75b7d
-  data.tar.gz: 8f20a87cd9d933ce5cd5b945937d7d3d208edf476633d4e0236f63ed25c262630161f01f5581d227ea8c893eb50bd8f308debe78021213fca11a8d0e0082d912
+  metadata.gz: dbea2e6b3f031712db02cb4a596bd8649b504b6127efb74ea139366e369d93d654847743167c995dc9fbfe26b00c12a8b564876ca011a0006a2274f7f8062f45
+  data.tar.gz: 42af13dabbc3f2d2204b0bcbd508122fec2096d80cb9ff2871aff82e4563e9c9f54a4000ebf634b230b477ad0d50a28423228aad8efb1889d357142e43b24d1b

data/lib/chess_engine/board.rb

@@ -2,11 +2,23 @@ require_relative "piece"
 require "colorize"
 
 module ChessEngine
+  ##
+  # This class provides a data structure for the chess board.
+  # It is responsible for storing information about pieces positions and moving
+  # them. It doesn't implement move validations and chess rules,
+  # so it is possible to make any moves at this level of abstraction.
+
   class Board
+    ##
+    # Creates an empty 8x8 board as a 2-dimensional array
+
     def initialize
       @board = Array.new(8) { Array.new(8) { nil } }
     end
 
+    ##
+    # Sets the initial board position according to the classic chess rules
+
     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|
@@ -19,27 +31,39 @@ module ChessEngine
       end
     end
 
-    def [](column, row)
-      @board[column][row]
-    end
+    ##
+    # Returns the piece string on the given position
+    # === Example
+    #   at([0, 0]) #=> Rook:white
+    #   at([3, 3]) #=> nil
 
-    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
 
+    ##
+    # Sets the board on given coordinates to +piece+
+
     def set_at(coordinates, piece)
       @board[coordinates[0]][coordinates[1]] = piece
     end
 
+    ##
+    # Checks if the values of +coordinates+ are between 0 and 7
+    # === Example
+    #   exists_at?([0, 0]) #=> true
+    #   exists_at?([8, -1]) #=> false
+
     def exists_at?(coordinates)
       coordinates.all? { |c| c.between?(0, 7) }
     end
 
+    ##
+    # Returns a string containing the board in printable format
+    # (uses colorize gem to paint the squares)
+
     def to_s
       string = ""
       colors = [[:default, :light_white].cycle, [:light_white, :default].cycle].cycle
@@ -61,23 +85,17 @@ module ChessEngine
       string
     end
 
+    ##
+    # Moves the value of +from+ coords to +to+ coords. Sets the value of +to+ to nil
+
     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
+    ##
+    # Returns the coordinates of the king of given +color+
 
     def king_coords(color)
       Board.coordinates_list.find do |coord|
@@ -85,11 +103,32 @@ module ChessEngine
       end
     end
 
+    ##
+    # Returns the array of coordinates where pieces of given +color+ a located
+
     def piece_coordinates(color)
       Board.coordinates_list.select do |coord|
         piece = at(coord)
         !piece.nil? && piece.color == color
       end
     end
+
+    private
+
+    def [](column, row)
+      @board[column][row]
+    end
+
+    def []=(column, row, piece)
+      @board[column][row] = piece
+    end
+
+    def Board.coordinates_list
+      list = []
+      (0..7).each do |x|
+        (0..7).each { |y| list << [x, y]}
+      end
+      list
+    end
   end
 end

data/lib/chess_engine/cli.rb

@@ -6,9 +6,15 @@ require "yaml"
 module ChessEngine
   class NoGamesError < StandardError; end
 
+  ##
+  # A Simple command line interface for the Chess Game
+
   class CLI
     include Input
 
+    ##
+    # Starts a new game session
+
     def initialize
       begin
         mode = get_input("\nChoose the game mode:\n1. New game\n2. Continue\nEnter your choice (1 or 2): ", /^[12]$/)

data/lib/chess_engine/game.rb

@@ -1,10 +1,15 @@
 require_relative "board"
-require_relative "validator"
+require_relative "move_validator"
 require_relative "move"
 
 module ChessEngine
   class InvalidMove < StandardError; end
 
+  ##
+  # This class provides all the rules for the chess game. It recognizes check,
+  # checkmate and stalemate. Move validations logic can be found in the
+  # MoveValidator module, which is included in this class
+
   class Game
     attr_accessor :name
     attr_reader :current_color
@@ -19,6 +24,21 @@ module ChessEngine
       @promotion_coord = false
     end
 
+    ##
+    # Accepts the move string in algebraic notation, e.g. "e2e4",
+    # and applies it to the board.
+    # Raises InvalidMove if:
+    # * Game is already over
+    # * Pawn promotion should be executed first
+    # * Empty square is chosen
+    # * Player tries to move piece of the opponent
+    # * Move is invalid (checks via the MoveValidator module)
+    # * Move is fatal (king is attacked after the move)
+    #
+    # After successfull move, the method changes the current player or
+    # goes into "A pawn needs promotion" state, which can be checked by
+    # #needs_promotion? method
+
     def move(string)
       from, to = Game.string_to_move(string)
       piece = @board.at(from)
@@ -40,18 +60,36 @@ module ChessEngine
       next_player
     end
 
+    ##
+    # Returns a piece (or nil if the square is empty) at given coordinates
+    # === Example
+    #   g = Game.new
+    #   g["e2"] #=> <Pawn ...>
+    #   g["e4"] #=> nil
+
     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
 
+    ##
+    # Returns the board in the nice-looking string
+
     def draw
       @board.to_s
     end
 
+    ##
+    # Accepts a string with name of the piece.
+    # Promotes a pawn and changes the current player.
+    # Raises InvalidMove if promotion is not needed or invalid +class_name+
+    # has been passed
+    # === Example
+    #   game.promotion("queen")
+
     def promotion(class_name)
-      unless ["rook", "knight", "elephant", "queen"].include?(class_name.downcase)
+      unless needs_promotion? && ["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))
@@ -59,6 +97,10 @@ module ChessEngine
       next_player
     end
 
+    ##
+    # Accepts a +length+ sybmol :short or :long. Ensures that castling is
+    # possible and commits appropriate moves. Otherwise, raises InvalidMove
+
     def castling(length)
       row = @current_color == :white ? 0 : 7
       king = @board.at([4, row])
@@ -86,16 +128,25 @@ module ChessEngine
       next_player
     end
 
+    ##
+    # Returns true if game is over
+
     def over?
       @board.piece_coordinates(@current_color).all? do |coord|
         safe_moves(coord).empty?
       end
     end
 
+    ##
+    # Checks if pawn promotion is needed
+
     def needs_promotion?
       !!@promotion_coord
     end
 
+    ##
+    # Returns true if current king is attacked
+
     def check?
       king_attacked?
     end
@@ -123,7 +174,7 @@ module ChessEngine
       [[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
+        piece = possible_move?(coords) ? @board.at(coords) : nil
         return true if !piece.nil? && piece.knight?
       end
       false

data/lib/chess_engine/move.rb

@@ -1,4 +1,7 @@
 module ChessEngine
+  ##
+  # This class is made to make move canceling easier if something goes wrong.
+
   class Move
     def initialize(board, from, to)
       @board = board
@@ -13,6 +16,9 @@ module ChessEngine
       end
     end
 
+    ##
+    # Applies the move to the board
+
     def commit
       if en_passant?
         @board.set_at(@en_passant_coord, nil)
@@ -20,6 +26,9 @@ module ChessEngine
       @board.move_piece(@from, @to)
     end
 
+    ##
+    # Moves pieces back and returns the board to the previous state
+
     def rollback
       @original_squares.each do |square|
         @board.set_at(square[:coord], square[:piece])

data/lib/chess_engine/{validator.rb → move_validator.rb}

@@ -1,15 +1,28 @@
 module ChessEngine
+  ##
+  # This module contains all the methods needed to check if
+  # some move is valid or not. It is included in the Game class and so uses
+  # some of its attributes: board, current_color and last_piece (for en passant only)
+
   module MoveValidator
+
+    ## Excludes from valid_moves all fatal moves
+
     def safe_moves(from)
       valid_moves(from).reject { |move| fatal_move?(from, move) }
     end
 
+    ##
+    # Returns an array of valid moves for a piece at the given position.
+    # Note: this method doesn't exclude moves that lead current king to be attacked
+    # (See +#safe_moves+ method)
+
     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)
+          to if possible_move?(to)
         end.compact
       elsif piece.pawn?
         pawn_valid_moves(from)
@@ -18,25 +31,34 @@ module ChessEngine
       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
+    ##
+    # Returns an array of coordinates that can be reached by recursively
+    # applying the given +move+, starting from the +from+ coordinates
+
+    private
 
     def repeated_move(from, move, valid_moves = [])
       coordinates = relative_coords(from, move)
-      return valid_moves unless valid_move?(coordinates)
+      return valid_moves unless possible_move?(coordinates)
       return valid_moves << coordinates unless @board.at(coordinates).nil?
       repeated_move(coordinates, move, valid_moves << coordinates)
     end
 
+    ##
+    # Returns coordinates that will be reached after applying the +move+,
+    # starting from the +from+ coordinates
+
     def relative_coords(from, move)
       [from[0] + move[0], from[1] + move[1]]
     end
 
-    def valid_move?(coordinates)
+    ##
+    # Returns true if:
+    # * The 8x8 board exists at given coordinates
+    # * Board at given coordinates is empty or it contains a piece with the same
+    #   color as the current_color
+
+    def possible_move?(coordinates)
       if @board.exists_at?(coordinates)
         piece = @board.at(coordinates)
         return (piece.nil? || piece.color != @current_color)
@@ -44,6 +66,9 @@ module ChessEngine
       return false
     end
 
+    ##
+    # Returns true if the current king is attacked after the given move
+
     def fatal_move?(from, to)
       is_fatal = false
       move = Move.new(@board, from, to)
@@ -83,5 +108,12 @@ module ChessEngine
       end
       nil
     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
   end
 end

data/spec/board_spec.rb

@@ -41,8 +41,8 @@ describe ChessEngine::Board do
     end
 
     it "moves piece between two points" do
-      expect(@board[4, 1]).to be_nil
-      expect(@board[4, 3].pawn?).to eq(true)
+      expect(@board.at([4, 1])).to be_nil
+      expect(@board.at([4, 3]).pawn?).to eq(true)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chess_engine
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Anikeev Gennadiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-14 00:00:00.000000000 Z
+date: 2019-05-26 00:00:00.000000000 Z
 dependencies: []
 description: This library provides all the rules of the chess game. Also it provides
   a command line interface with serialization features
@@ -25,8 +25,8 @@ files:
 - lib/chess_engine/game.rb
 - lib/chess_engine/input.rb
 - lib/chess_engine/move.rb
+- lib/chess_engine/move_validator.rb
 - lib/chess_engine/piece.rb
-- lib/chess_engine/validator.rb
 - spec/board_spec.rb
 - spec/game_helper.rb
 - spec/game_spec.rb
@@ -50,8 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Simple chess library that uses algebraic notation