chess_validator 0.2.18 → 0.2.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 202313773f05394e520671d1b1eeab59d276538e61d964bb9bd21597ce7042d7
-  data.tar.gz: 752963d28e3592b347f1db3c417e9db721615ddf188052191c92086b3f5fa42e
+  metadata.gz: bc464703452ec24fc25c8d122099e52b9788ef81df4d2a3acd2fca332d86c7b2
+  data.tar.gz: 11ca33717e5306eaf1538ecb65b55280bfd0c6f5f7b485cd78d540e36d72d726
 SHA512:
-  metadata.gz: 0cd85183d720a2465656083e73762239ffae92b3bf76642f295a409018c1f428cccda0f0fa56e36c706a4f98b5c3d62a14865c13294905392b14c397893ecb8b
-  data.tar.gz: 903adcb0813f761a5eaa293beac38d19091168f4bb3bb5f8f9fd49669471bf209df438301fb6ad49057f6fd6d0b0af54add121891ccfe63a4289c77f55e2ac69
+  metadata.gz: 4f4e734ca21f8022cf210effe194057edd9c4302574ce15dc3929858f0426d1992f32c0ab185bf38236ceb6b05fc380a1934589a575eb5278598e96c13826ec5
+  data.tar.gz: 2a60f66b946b0e8203c0c79cf8d772b483befbd82b1935ddfa959fe9c424d8056fba1aa5978dfcf6b9d0b7413840b0f85ddc58f22de7a90485b0c79f4e923c62

data/lib/board_logic.rb

@@ -3,9 +3,13 @@ require 'piece'
 module ChessValidator
   class BoardLogic
     def self.build_board(fen)
+      build_board_from_string(fen.board_string)
+    end
+
+    def self.build_board_from_string(board_string)
       board = {}
       square_index = 1
-      fen.board_string.chars.each do |char|
+      board_string.chars.each do |char|
         if empty_square?(char)
           square_index += char.to_i
         elsif char != '/'
@@ -23,7 +27,7 @@ module ChessValidator
       notation += handle_castle(previous_fen.castling, piece, board)
       notation += handle_en_passant(piece, move)
       notation += handle_half_move_clock(previous_fen, piece.piece_type, captured)
-      notation += piece.color == 'b' ? previous_fen.fullmove.next : previous_fen.fullmove
+      notation += piece.color == 'b' ? previous_fen.fullmove&.next.to_s : previous_fen.fullmove.to_s
       notation
     end
 
@@ -38,10 +42,10 @@ module ChessValidator
     def self.handle_castle(castling, piece, board)
       return castling if castling == '-'
       castling.delete!('K') if board[64].nil? || board[64].piece_type != 'R'
-      castling.delete!('K') if board[61].nil? || board[61].piece_type != 'K'
+      castling.delete!('KQ') if board[61].nil? || board[61].piece_type != 'K'
       castling.delete!('Q') if board[57].nil? || board[57].piece_type != 'R'
       castling.delete!('k') if board[8].nil? || board[8].piece_type != 'r'
-      castling.delete!('k') if board[5].nil? || board[5].piece_type != 'k'
+      castling.delete!('kq') if board[5].nil? || board[5].piece_type != 'k'
       castling.delete!('q') if board[1].nil? || board[1].piece_type != 'r'
       castling.size == 0 ? '-' : castling
     end

data/lib/engine.rb

@@ -32,6 +32,10 @@ module ChessValidator
       def result(fen_notation)
         GameLogic.find_game_result(fen_notation)
       end
+
+      def defended_pieces(fen_notatioin)
+        MoveLogic.defended_pieces_by_square(fen_notation)
+      end
     end
   end
 end

data/lib/move_logic.rb

@@ -4,19 +4,79 @@ require 'pgn'
 module ChessValidator
   class MoveLogic
     class << self
+      MAX_CACHE_SIZE = 1000
+
       def next_moves(fen)
-        board = BoardLogic.build_board(fen)
+        fen_notation = fen.to_s
+        return next_moves_for[fen_notation] if next_moves_for[fen_notation]
+
+        board = get_board(fen.to_s)
         pieces = []
+        
         board.values.each do |piece|
           if piece.color == fen.active
             load_move_data(board, piece, fen)
             pieces << piece if piece.valid_moves.size > 0
           end
         end
+        next_moves_for[fen_notation] = pieces
 
         pieces
       end
 
+      def boards
+        if @boards.nil? || @boards.size > MAX_CACHE_SIZE
+          @boards = {}
+        end
+
+        @boards
+      end
+
+      def next_moves_for
+        if @next_moves_for.nil? || @next_moves_for.size > MAX_CACHE_SIZE
+          @next_moves_for = {}
+        end
+
+        @next_moves_for
+      end
+
+      def occupied_square_sets
+        if @occupied_square_sets.nil? || @occupied_square_sets.size > MAX_CACHE_SIZE
+          @occupied_square_sets = {}
+        end
+
+        @occupied_square_sets
+      end
+
+      def defended_sets
+        if @defended_sets.nil? || @defended_sets.size > MAX_CACHE_SIZE
+          @defended_sets = {}
+        end
+
+        @defended_sets
+      end
+
+      def get_board(fen_string)
+        return boards[fen_string] if boards[fen_string]
+
+        board = BoardLogic.build_board_from_string(fen_string.split.first)
+        boards[fen_string] = board
+        board
+      end
+
+
+      def get_occupied_spaces(fen_string)
+        return occupied_square_sets[fen_string] if occupied_square_sets[fen_string]
+        board = get_board(fen_string)
+
+        occupied_spaces = []
+        board.values.each { |p| occupied_spaces << p.position }
+
+        occupied_square_sets[fen_string] = occupied_spaces
+        occupied_spaces
+      end
+
+
       def load_move_data(board, piece, fen)
         moves_for_piece(piece).each do |move|
           if valid_move?(piece, board, move, fen)
@@ -41,14 +101,13 @@ module ChessValidator
       end
 
       def valid_move?(piece, board, move, fen)
-        occupied_spaces = []
-        board.values.each { |p| occupied_spaces << p.position }
         case piece.piece_type.downcase
         when 'k'
-          handle_king(piece, board, move, fen, occupied_spaces)
+          handle_king(piece, board, move, fen) && valid_destination?(piece, board, move)
         when 'p'
           handle_pawn(piece, board, move, fen)
         else
+          occupied_spaces = get_occupied_spaces(fen.to_s)
           valid_move_path?(piece, move, occupied_spaces) &&
           valid_destination?(piece, board, move) &&
           king_will_be_safe?(piece, board, move)
@@ -112,10 +171,9 @@ module ChessValidator
       end
 
       def make_move(piece, move, fen_notation)
-        fen = PGN::FEN.new(fen_notation)
-        board = BoardLogic.build_board(fen)
+        board = get_board(fen_notation)
         new_board = with_next_move(piece, board, move)
-
+        fen = PGN::FEN.new(fen_notation)
         BoardLogic.to_fen_notation(new_board, fen, piece, move, board[INDEX_KEY[move]])
       end
 
@@ -135,16 +193,16 @@ module ChessValidator
       end
 
       def find_king_and_spaces(board, color)
-        occupied_spaces = []
         king = nil
-        board.values.each do |p|
+        occupied_spaces = board.values.map do |p|
           king = p if p.piece_type.downcase == 'k' && p.color == color
-          occupied_spaces << p.position
+          p.position
         end
+
         [king, occupied_spaces]
       end
 
-      def handle_king(king, board, move, fen, occupied_spaces)
+      def handle_king(king, board, move, fen)
         if (king.position[0].ord - move[0].ord).abs == 2
           empty_b_square = true
           if move[0] == 'c'
@@ -155,6 +213,8 @@ module ChessValidator
             castle_code = 'k'
             between = 'f' + move[1]
           end
+          occupied_spaces = get_occupied_spaces(fen.to_s)
+
           (fen.castling.include?(castle_code) && king.color == 'b' || fen.castling.include?(castle_code.upcase) && king.color == 'w') &&
           king_is_safe?(king.color, board, king.position, occupied_spaces) &&
           king_is_safe?(king.color, board, between, occupied_spaces) &&
@@ -162,7 +222,7 @@ module ChessValidator
           board.values.none? { |piece| [between, move].include?(piece.position) } &&
           empty_b_square
         else
-          valid_destination?(king, board, move) && king_will_be_safe?(king, board, move)
+          king_will_be_safe?(king, board, move)
         end
       end
 
@@ -271,6 +331,49 @@ module ChessValidator
         !(move_path & occupied_spaces).empty?
       end
 
+      def can_defend?(piece, board, position, fen)
+        case piece.piece_type.downcase
+        when 'k'
+          handle_king(piece, board, position, fen)
+        when 'p'
+          if piece.position[0] != position[0]
+             target_piece = find_piece(board, position)
+             valid = (target_piece && target_piece.color != piece.color) || position == fen.en_passant
+             valid && king_will_be_safe?(piece, board, position)
+          end
+        else
+          occupied_spaces = get_occupied_spaces(fen.to_s)
+          valid_move_path?(piece, position, occupied_spaces) && king_will_be_safe?(piece, board, position)
+        end
+      end
+
+      def defended_pieces_by_square(fen_notation)
+        return defended_sets[fen_notatioin] if defended_sets[fen_notatioin]
+
+        board = get_board(fen_notation)
+
+        fen = PGN::FEN.new(fen_notation)
+        space_index = {}
+        
+        pieces = board.values.map do |piece|
+          space_index[piece.position] = piece.piece_type + piece.color
+          piece
+        end
+        
+        defended = Hash.new([])
+
+        pieces.each do |piece|
+          moves_for_piece(piece).each do |move|
+            if space_index[move] && space_index[move][-1] == piece.color && can_defend?(piece, board, move, fen)
+              defended[move] += [piece]
+            end
+          end
+        end
+
+        defended_sets[fen_notatioin] = defended
+        defended
+      end
+
       def moves_for_piece(piece)
         case piece.piece_type.downcase
         when 'r'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chess_validator
 version: !ruby/object:Gem::Version
-  version: 0.2.18
+  version: 0.2.22
 platform: ruby
 authors:
 - Charles Ellison
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-16 00:00:00.000000000 Z
+date: 2020-01-22 00:00:00.000000000 Z
 dependencies: []
 description: 'Documentation: https://github.com/chadellison/chess_validator'
 email: chad.ellison0123@gmail.com
@@ -27,7 +27,7 @@ homepage: https://rubygems.org/search?utf8=%E2%9C%93&query=chess_validator
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -42,8 +42,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: A chess move validator
 test_files: []