chess_validator 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 76c92b66d08e4f224ed65e0464616d2607bfb816c3549d094da30ac9329925fb
+  data.tar.gz: 2353327aa052a4b674fa6c9132fb73e71acad51610d89267e317de60ff7f5775
+SHA512:
+  metadata.gz: 818c1c112a6a59e40ff4ace6f0736c91f50359a4055e72d1f0053835817a6660b17cb09c9b7af757367ca40122f21f11d1b75296c3bbc4b76505044fea70480c
+  data.tar.gz: b0bcfe8bc32af31dd89643124d4f0bf33c9121ae5b485c57d1ecca6fb07d1bedb06d776c756f365dc691476c3f24e368a6b70bc7adc006587c5d9efc152fcb1c

data/lib/board_logic.rb

@@ -0,0 +1,24 @@
+require 'piece'
+
+module ChessValidator
+  class BoardLogic
+    def self.build_board(fen)
+      board = {}
+      square_index = 1
+      fen.to_s.split(' ').first.chars.each do |char|
+        if empty_square?(char)
+          square_index += char.to_i
+        elsif char != '/'
+          board[square_index] = Piece.new(char, square_index)
+          square_index += 1
+        end
+      end
+
+      board
+    end
+
+    def self.empty_square?(char)
+      ('1'..'8').include?(char)
+    end
+  end
+end

data/lib/chess_validator.rb

@@ -0,0 +1 @@
+require 'move_logic'

data/lib/constants/square_key.rb

@@ -0,0 +1,77 @@
+SQUARE_KEY = {
+  1 => 'a8', 2 => 'b8', 3 => 'c8', 4 => 'd8', 5 => 'e8', 6 => 'f8', 7 => 'g8', 8 => 'h8',
+  9 => 'a7', 10 => 'b7', 11 => 'c7', 12 => 'd7', 13 => 'e7', 14 => 'f7', 15 => 'g7', 16 => 'h7',
+  17 => 'a6', 18 => 'b6', 19 => 'c6', 20 => 'd6', 21 => 'e6', 22 => 'f6', 23 => 'g6', 24 => 'h6',
+  25 => 'a5', 26 => 'b5', 27 => 'c5', 28 => 'd5', 29 => 'e5', 30 => 'f5', 31 => 'g5', 32 => 'h5',
+  33 => 'a4', 34 => 'b4', 35 => 'c4', 36 => 'd4', 37 => 'e4', 38 => 'f4', 39 => 'g4', 40 => 'h4',
+  41 => 'a3', 42 => 'b3', 43 => 'c3', 44 => 'd3', 45 => 'e3', 46 => 'f3', 47 => 'g3', 48 => 'h3',
+  49 => 'a2', 50 => 'b2', 51 => 'c2', 52 => 'd2', 53 => 'e2', 54 => 'f2', 55 => 'g2', 56 => 'h2',
+  57 => 'a1', 58 => 'b1', 59 => 'c1', 60 => 'd1', 61 => 'e1', 62 => 'f1', 63 => 'g1', 64 => 'h1'
+}
+
+INDEX_KEY = {
+ "a8" => 1,
+ "b8" => 2,
+ "c8" => 3,
+ "d8" => 4,
+ "e8" => 5,
+ "f8" => 6,
+ "g8" => 7,
+ "h8" => 8,
+ "a7" => 9,
+ "b7" => 10,
+ "c7" => 11,
+ "d7" => 12,
+ "e7" => 13,
+ "f7" => 14,
+ "g7" => 15,
+ "h7" => 16,
+ "a6" => 17,
+ "b6" => 18,
+ "c6" => 19,
+ "d6" => 20,
+ "e6" => 21,
+ "f6" => 22,
+ "g6" => 23,
+ "h6" => 24,
+ "a5" => 25,
+ "b5" => 26,
+ "c5" => 27,
+ "d5" => 28,
+ "e5" => 29,
+ "f5" => 30,
+ "g5" => 31,
+ "h5" => 32,
+ "a4" => 33,
+ "b4" => 34,
+ "c4" => 35,
+ "d4" => 36,
+ "e4" => 37,
+ "f4" => 38,
+ "g4" => 39,
+ "h4" => 40,
+ "a3" => 41,
+ "b3" => 42,
+ "c3" => 43,
+ "d3" => 44,
+ "e3" => 45,
+ "f3" => 46,
+ "g3" => 47,
+ "h3" => 48,
+ "a2" => 49,
+ "b2" => 50,
+ "c2" => 51,
+ "d2" => 52,
+ "e2" => 53,
+ "f2" => 54,
+ "g2" => 55,
+ "h2" => 56,
+ "a1" => 57,
+ "b1" => 58,
+ "c1" => 59,
+ "d1" => 60,
+ "e1" => 61,
+ "f1" => 62,
+ "g1" => 63,
+ "h1" => 64
+}

data/lib/move_logic.rb

@@ -0,0 +1,366 @@
+require 'board_logic'
+require 'pgn'
+require 'pry'
+module ChessValidator
+  class MoveLogic
+    class << self
+      def find_next_moves(fen_notatioin)
+        fen = PGN::FEN.new(fen_notatioin)
+        next_moves(fen)
+      end
+
+      def find_next_moves_from_moves(moves)
+        fen = PGN::Game.new(moves).positions.last.to_fen
+        next_moves(fen)
+      end
+
+      def next_moves(fen)
+        board = BoardLogic.build_board(fen)
+        pieces = []
+        board.values.each do |piece|
+          if piece.color == fen.active
+            load_valid_moves(board, piece, fen)
+            pieces << piece
+          end
+        end
+
+        pieces
+      end
+
+      def load_valid_moves(board, piece, fen)
+        moves_for_piece(piece).each do |move|
+          piece.valid_moves << move if valid_move?(piece, board, move, fen)
+        end
+      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)
+        when 'p'
+          handle_pawn(piece, board, move, fen)
+        else
+          valid_move_path?(piece, move, occupied_spaces) &&
+          valid_destination?(piece, board, move) &&
+          king_will_be_safe?(piece, board, move)
+        end
+      end
+
+      def with_next_move(piece, board, move)
+        index = INDEX_KEY[move]
+        new_board = board.clone
+        new_piece = Piece.new(piece.piece_type, index)
+        new_board.delete(piece.square_index)
+        new_board[index] = new_piece
+        new_board = handle_castle(new_board, move) if castled?(piece, move)
+        new_board = handle_en_passant(new_board, piece.color, move) if en_passant?(piece, move, new_board[index])
+        new_board
+      end
+
+      def handle_en_passant(board, pawn_color, move)
+        if pawn_color == 'w'
+          index = INDEX_KEY[move[0] + '5']
+        else
+          index = INDEX_KEY[move[0] + '4']
+        end
+
+        board.delete(index)
+        board
+      end
+
+      def handle_castle(board, move)
+        case move
+        when 'c1'
+          board.delete(57)
+          board[60] = Piece.new('R', 60)
+        when 'g1'
+          board.delete(64)
+          board[62] = Piece.new('R', 62)
+        when 'c8'
+          board.delete(1)
+          board[4] = Piece.new('r', 4)
+        when 'g8'
+          board.delete(8)
+          board[6] = Piece.new('r', 6)
+        end
+
+        board
+      end
+
+      def castled?(piece, move)
+        piece.piece_type.downcase == 'k' && (piece.position[0].ord - move[0].ord).abs == 2
+      end
+
+      def en_passant?(piece, move, square)
+        piece.piece_type.downcase == 'p' && piece.position[0] != move[0] && !square
+      end
+
+      def king_will_be_safe?(piece, board, move)
+        new_board = with_next_move(piece, board, move)
+        occupied_spaces = []
+        king = nil
+        new_board.values.each do |p|
+          king = p if p.piece_type.downcase == 'k' && p.color == piece.color
+          occupied_spaces << p.position
+        end
+        king_is_safe?(king.color, new_board, king.position, occupied_spaces)
+      end
+
+      def handle_king(king, board, move, fen, occupied_spaces)
+        if (king.position[0].ord - move[0].ord).abs == 2
+          empty_b_square = true
+          if move[0] == 'c'
+            castle_code = 'q'
+            between = 'd' + move[1]
+            empty_b_square = empty_square?(board, 'b' + move[1])
+          else
+            castle_code = 'k'
+            between = 'f' + move[1]
+          end
+          (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) &&
+          king_is_safe?(king.color, board, move, occupied_spaces) &&
+          board.values.none? { |piece| [between, move].include?(piece.position) } &&
+          empty_b_square
+        else
+          valid_destination?(king, board, move) && king_is_safe?(king.color, board, move, occupied_spaces)
+        end
+      end
+
+      def king_is_safe?(king_color, board, king_position, occupied_spaces)
+        board.values.none? do |piece|
+          piece.color != king_color &&
+          moves_for_piece(piece).select do |move|
+            king_position == move && valid_move_path?(piece, king_position, occupied_spaces)
+          end.size > 0
+        end
+      end
+
+      def handle_pawn(piece, board, move, fen)
+        position = piece.position
+
+        if position[0] == move[0]
+          advance_pawn?(piece, board, move)
+        else
+          target_piece = find_piece(board, move)
+          (target_piece && target_piece.color != piece.color) || move == fen.en_passant
+        end
+      end
+
+      def advance_pawn?(pawn, board, move)
+        if (pawn.position[1].to_i - move[1].to_i).abs == 1
+          empty_square?(board, move)
+        else
+          occupied_spaces = []
+          board.values.each do |piece|
+            occupied_spaces << piece.position
+          end
+          valid_move_path?(pawn, move, occupied_spaces) && empty_square?(board, move)
+        end
+      end
+
+      def valid_destination?(piece, board, move)
+        target_piece = find_piece(board, move)
+        if target_piece
+          target_piece.color != piece.color
+        else
+          true
+        end
+      end
+
+      def find_piece(board, position)
+        board.values.detect { |piece| piece.position == position }
+      end
+
+      def empty_square?(board, move)
+        board.values.detect { |piece| piece.position == move }.nil?
+      end
+
+      def valid_move_path?(piece, move, occupied_spaces)
+        position = piece.position
+        if piece.piece_type.downcase == 'n'
+          true
+        elsif position[0] == move[0]
+          !collision?(piece.position, move, occupied_spaces, 1, 0)
+        elsif position[1] == move[1]
+          !collision?(piece.position, move, occupied_spaces, 0, 1)
+        else
+          !diagonal_collision?(piece.position, move, occupied_spaces)
+        end
+      end
+
+      def collision?(position, destination, occupied_spaces, i1, i2)
+        start_index = position[i1]
+        end_index = destination[i1]
+
+        if start_index > end_index
+          start_index = destination[i1]
+          end_index = position[i1]
+        end
+
+        occupied_spaces.select do |space|
+          space[i2] == position[i2] && space[i1] > start_index && space[i1] < end_index
+        end.size > 0
+      end
+
+      def diagonal_collision?(position, destination, occupied_spaces)
+        difference = (position[1].to_i - destination[1].to_i).abs - 1
+
+        horizontal_multiplyer = 1
+        horizontal_multiplyer = -1 if position[0] > destination[0]
+
+        vertical_multiplyer = 1
+        vertical_multiplyer = -1 if position[1] > destination[1]
+
+        move_path = []
+        difference.times do |n|
+          column = (position[0].ord + ((n + 1) * horizontal_multiplyer)).chr
+          row = (position[1].to_i + ((n + 1) * vertical_multiplyer)).to_s
+          move_path << column + row
+        end
+
+        !(move_path & occupied_spaces).empty?
+      end
+
+      def moves_for_piece(piece)
+        case piece.piece_type.downcase
+        when 'r'
+          moves_for_rook(piece.position)
+        when 'b'
+          moves_for_bishop(piece.position)
+        when 'q'
+          moves_for_queen(piece.position)
+        when 'k'
+          moves_for_king(piece.position)
+        when 'n'
+          moves_for_knight(piece.position)
+        when 'p'
+          moves_for_pawn(piece)
+        end
+      end
+
+      def moves_for_rook(position)
+        moves_horizontal(position) + moves_vertical(position)
+      end
+
+      def moves_for_bishop(position)
+        top_right = moves_diagonal('up', 'right', position)
+        top_left = moves_diagonal('up', 'left', position)
+        bottom_left = moves_diagonal('down', 'left', position)
+        bottom_right = moves_diagonal('down', 'right', position)
+
+        top_right + top_left + bottom_left + bottom_right
+      end
+
+      def moves_diagonal(vertical, horizontal, position)
+        column = position[0]
+        row = position[1]
+        possible_moves = []
+
+        while column >= 'a' && column <= 'h' && row >= '1' && row <= '8' do
+          column = horizontal == 'left' ? previous_char(column) : column.next
+          row = vertical == 'up' ? row.next : previous_char(row)
+          possible_moves << column + row
+        end
+        remove_out_of_bounds(possible_moves)
+      end
+
+      def previous_char(char)
+        (char.ord - 1).chr
+      end
+
+      def moves_for_queen(position)
+        moves_for_rook(position) + moves_for_bishop(position)
+      end
+
+      def spaces_near_king(position)
+        column = position[0].ord
+        row = position[1].to_i
+
+        moves = [
+          (column - 1).chr + row.to_s,
+          (column + 1).chr + row.to_s,
+          (column - 1).chr + (row - 1).to_s,
+          (column - 1).chr + (row + 1).to_s,
+          (column + 1).chr + (row - 1).to_s,
+          (column + 1).chr + (row + 1).to_s,
+          column.chr + (row + 1).to_s,
+          column.chr + (row - 1).to_s
+        ]
+      end
+
+      def moves_for_king(position)
+        castle_moves = [(position[0].ord - 2).chr + position[1], position[0].next.next + position[1]]
+        remove_out_of_bounds(spaces_near_king(position) + castle_moves)
+      end
+
+      def moves_for_knight(position)
+        column = position[0].ord
+        row = position[1].to_i
+
+        moves = [
+          (column - 2).chr + (row + 1).to_s,
+          (column - 2).chr + (row - 1).to_s,
+          (column + 2).chr + (row + 1).to_s,
+          (column + 2).chr + (row - 1).to_s,
+          (column - 1).chr + (row + 2).to_s,
+          (column - 1).chr + (row - 2).to_s,
+          (column + 1).chr + (row + 2).to_s,
+          (column + 1).chr + (row - 2).to_s
+        ]
+
+        remove_out_of_bounds(moves)
+      end
+
+      def remove_out_of_bounds(moves)
+        moves.select { |move| ('a'..'h').include?(move[0]) && ('1'..'8').include?(move[1..-1]) }
+      end
+
+      def moves_for_pawn(pawn)
+        column = pawn.position[0].ord
+        row = pawn.color == 'w' ? pawn.position[1].to_i + 1 : pawn.position[1].to_i - 1
+
+        moves = [
+          (column - 1).chr + row.to_s,
+          (column + 1).chr + row.to_s,
+          column.chr + row.to_s
+        ]
+
+        if pawn.color == 'w' && pawn.position[1] == '2' || pawn.color == 'b' && pawn.position[1] == '7'
+          two_forward = pawn.color == 'w' ? row + 1 : row - 1
+          moves << column.chr + two_forward.to_s
+        end
+        remove_out_of_bounds(moves)
+      end
+
+      def moves_horizontal(position)
+        possible_moves = []
+        column = 'a'
+        row = position[1]
+
+        8.times do
+          possible_moves << column + row unless column == position[0]
+          column = column.next
+        end
+
+        possible_moves
+      end
+
+      def moves_vertical(position)
+        possible_moves = []
+        column = position[0]
+        row = '1'
+
+        8.times do
+          possible_moves << column + row unless row == position[1]
+          row = row.next
+        end
+
+        possible_moves
+      end
+    end
+  end
+end

data/lib/piece.rb

@@ -0,0 +1,24 @@
+require_relative './constants/square_key'
+
+module ChessValidator
+  class Piece
+    attr_accessor :position, :piece_type, :color, :square_index, :valid_moves
+
+    def initialize(char, square_index)
+      @piece_type = char
+      @square_index = square_index
+      @color = get_color(char)
+      @position = get_position(square_index)
+      @enemy_targets = []
+      @valid_moves = []
+    end
+
+    def get_position(square_index)
+      SQUARE_KEY[square_index]
+    end
+
+    def get_color(char)
+      char == char.downcase ? 'b' : 'w'
+    end
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: chess_validator
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Charles Ellison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-17 00:00:00.000000000 Z
+dependencies: []
+description: 'Documentation: https://github.com/chadellison/chess_validator'
+email: chad.ellison0123@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/board_logic.rb
+- lib/chess_validator.rb
+- lib/constants/square_key.rb
+- lib/move_logic.rb
+- lib/piece.rb
+homepage: https://rubygems.org/search?utf8=%E2%9C%93&query=chess_validator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.3
+signing_key: 
+specification_version: 4
+summary: A chess move validator
+test_files: []