chess_validator 0.2.19 → 0.2.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 293d47ecb588b6f6654cf76c014d242980c74f4c0f9b155d9b19e656bf7fcac6
-  data.tar.gz: 4a3b4ce1c0c0013514474f3cfa6a62bf6088581cbbb6ec0b2723b2c0b9421140
+  metadata.gz: d61b299ea0d6ec07579ccb0b6d34ec50a7d5835960ae866469f653c4f7d43d06
+  data.tar.gz: cbc0f79075fa4f497b2ac8128864acab023da94a74e68efcfe87ff0c4d4950b5
 SHA512:
-  metadata.gz: cbe22e6fdb5bb096f8ca66ec790d7f21d5e1077e1ac8cffd6074742277cb17a91c47b5a0ce6ecc27dc2227111fbac0b888eb1394c98b8b57d07af6814c156699
-  data.tar.gz: a99822336ff54cac4d82797e7d73288ccb1d6954870b2c1c23e4a0b8fe5c3d92289be5f13b8405ce82401469e83cd983d08c38565477106b7c8e8df1c9faff8b
+  metadata.gz: 952a4c3df07b35e8ef83ee10e72b5488c6cb57a4c09f2e3b1d56de1a37a2024545d7d682812b7497fa6884994453616933437872ac4db47554afec12586c97e5
+  data.tar.gz: d86e7337b4e0616b7dc8bf67aef635e87ddec04fe96d4a395ccfc118c45255f1edade66acc98e42c9a6d6672c2e04247ef712e1a6e576e999156b08eca7dd627

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
 

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_notation] if defended_sets[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]
+            end
+          end
+        end
+
+        defended_sets[fen_notation] = 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.19
+  version: 0.2.23
 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: []