chess_validator 0.2.20 → 0.2.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3de54f3263072bf9eedb64289175b426d0f58913e2fedfbd4e1d733f85799c7d
-  data.tar.gz: d50b2bb51511e6e56c2e202c439a1f4dced1663b3296d12091345491b247b376
+  metadata.gz: 94df1700b50a798d45895b3d8b235fc6cd8abbe15736f36bbc97e1fe31da88e1
+  data.tar.gz: 6e0eab463eee127e30e55effeef21466cf71e9ac08be5c8f2f6b258112e723cb
 SHA512:
-  metadata.gz: c3bc01a8d88e626995ad7af4b5bd2bb6b35b2a66554b03c5772c217448042e240cd3ae4240632ea0cb43f469d395dfd4196666587c8a835a568f3995ab5bb89c
-  data.tar.gz: e602c545ef411549769616a7d0a602b86b2a5a03202f8a368ac6f6ba8a2c86b06501dd6381096fae20060652be9a8b360c27203fb411392b72e1ba11f0abc6c9
+  metadata.gz: '098971e3e410d7f62ec4bf11fb62ae9a3397322add2a7a40a508c24149e19680460d7e5a659add721e17acb84473308c79fc55d5be3d7fba4b3f9c8bf159ce13'
+  data.tar.gz: 7e0b9b6b18cbddbbc7fc25d2860a2830ea21c52d06254a2b3be28513ab391c8e7f10b0591b1a3c3471763d2c95e6d53940049e74e34d44a9c6870d445cb20ef1

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 != '/'

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

@@ -5,18 +5,56 @@ module ChessValidator
   class MoveLogic
     class << self
       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
+        @boards ||= {}
+      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 next_moves_for
+        @next_moves_for ||= {}
+      end
+
+      def occupied_square_sets
+        @occupied_square_sets ||= {}
+      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 +79,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 +149,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 +171,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 +191,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 +200,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 +309,47 @@ 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)
+        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]
+              puts 'hi'
+            end
+          end
+        end
+
+        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.20
+  version: 0.2.21
 platform: ruby
 authors:
 - Charles Ellison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-17 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