chessmate 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6be20b4d6b07a0f81f64db1d90580456b3f9c8cfc516ede8a669139f473640d5
-  data.tar.gz: fc4eee51ad0a83400cc605c111a012ca37b02f54cf9eafb4dc3b9b054c72a917
+  metadata.gz: 332ee0002250b755f4e40ba2555e71b3f1bb1fd878a78ee796272710a52e573e
+  data.tar.gz: 4704b9a6ae98589f5737ebd1a80f4dd75dcbdc8c90bfef2dd7bac0c4f6b926c7
 SHA512:
-  metadata.gz: 77431e006f69ea5c8aaa3788d2faaa8a08e919dc6462c6e621f7086d60ca5589dc2ceea3b3f056e6ae57ff6931425be7d912c87da886a416cdff55055b7efd0e
-  data.tar.gz: 9081e8d1c6f7d846c4f9a95696e981c9e18c0683ff4c39830a1853b80982b15f19787b6f690192e72dc311db14aa227f63411e400fa5825444299de4ffe2f588
+  metadata.gz: '06902d36017ad152fcf830da34e710f7fcde12ce009a71ce95ea883eee5e07d32ad3b98a7abe907046d39f8f55a1532ea42ed6ea6face6bf778286bfa7ffac36'
+  data.tar.gz: b2df6ef5de229691765377a3cdef36c8e4c733f6fb4869dd811a0861417fc0a0b68964915d41f0cab52a8e21773006672b703af45566af388f112873d0b3411e

data/lib/chessmate.rb

@@ -1,226 +1,285 @@
+# frozen_string_literal: true
+
 class ChessMate
-	require 'helpers/notation_parser'
-	require 'pieces/pawn'
-	require 'pieces/rook'
-	require 'pieces/bishop'
-	require 'pieces/knight'
-	require 'pieces/queen'
-	require 'pieces/king'
-	
-	attr_reader :board, :turn, :in_check
-
-	def initialize(board=nil,turn=nil)
-		if board.nil?
-			@board = 
-					[
-					['BR', 'BN', 'BB', 'BQ', 'BK', 'BB', 'BN', 'BR'],
-					['BP', 'BP', 'BP', 'BP', 'BP', 'BP', 'BP', 'BP'],
-					[nil, nil, nil, nil, nil, nil, nil, nil],
-					[nil, nil, nil, nil, nil, nil, nil, nil],
-					[nil, nil, nil, nil, nil, nil, nil, nil],
-					[nil, nil, nil, nil, nil, nil, nil, nil],
-					['WP', 'WP', 'WP', 'WP', 'WP', 'WP', 'WP', 'WP'],
-					['WR', 'WN', 'WB', 'WQ', 'WK', 'WB', 'WN', 'WR']
-					]
-		else
-			@board = board
-		end
-
-		if turn.nil?
-			@turn = 1
-		else
-			@turn = turn
-		end
-
-		@in_check = {
-			"white": false,
-			"black": false
-		}
-	end	
-
-	def update(orig, dest=nil)
-		orig_y = orig[0]
-		orig_x = orig[1]
-		dest_y = dest[0]
-		dest_x = dest[1]
-		piece_type = @board[orig_y][orig_x]
-
-		# Hacky way of doing this. Will fail for en passant and castling.
-		@board[orig_y][orig_x] = nil
-		@board[dest_y][dest_x] = piece_type
-
-		@turn += 1
-	end
-
-	def in_check?(board=nil)
-		board = board.nil? ? @board : board
-		wk_coords = bk_coords = nil
-
-		board.each_with_index do |row, y|
-			if row.include?("WK") 
-				wk_coords = [y, row.index("WK")]
-			end
-			if row.include?("BK") 
-				bk_coords = [y, row.index("BK")]
-			end
-		end
-
-		if wk_coords.nil? || bk_coords.nil?
-			return { "white": false, "black": false }
-		end
-
-		wk_pos = NotationParser.encode_notation(wk_coords)
-		bk_pos = NotationParser.encode_notation(bk_coords)
-
-		white_in_check = black_in_check = false
-		board.each_with_index do |row, y|
-			row.each_with_index do |col, x|
-				if !col.nil?
-					piece_pos = NotationParser.encode_notation([y,x])
-					if col[0] == "W"
-						if move(piece_pos, bk_pos, true)
-							black_in_check = true
-						end
-					elsif col[0] == "B"
-						if move(piece_pos, wk_pos, true)
-							white_in_check = true
-						end
-					end
-				end
-			end
-		end
-
-		{ "white": white_in_check, "black": black_in_check }
-		
-	end
-
-	def move(orig, dest, test=false, test_board=nil)
-		orig_pos = NotationParser.parse_notation(orig)
-		dest_pos = NotationParser.parse_notation(dest)
-
-		if orig_pos.nil? || dest_pos.nil?
-			return false
-		end
-
-		orig_y = orig_pos[0]
-		orig_x = orig_pos[1]
-
-		piece = @board[orig_y][orig_x]
-		piece_type = piece[1]
-
-		if piece[0].downcase() == "w"
-			piece_color = :white
-		elsif piece[0].downcase() == "b"
-			piece_color = :black
-		else
-			piece_color = nil
-		end
-
-		valid_move = nil
-		board = test_board.nil? ? @board : test_board
-		case piece_type
-		when "P"
-			valid_move = Pawn.move_is_valid?(orig_pos,dest_pos,board)
-		when "R"
-			valid_move = Rook.move_is_valid?(orig_pos,dest_pos,board)
-		when "B"
-			valid_move = Bishop.move_is_valid?(orig_pos,dest_pos,board)
-		when "N"
-			valid_move = Knight.move_is_valid?(orig_pos,dest_pos,board)
-		when "Q"
-			valid_move = Queen.move_is_valid?(orig_pos,dest_pos,board)
-		when "K"
-			valid_move = King.move_is_valid?(orig_pos,dest_pos,board)
-		else
-			valid_move = false
-		end
-
-		if !test
-			@in_check = self.in_check?
-			in_check_after_move = in_check_after_move?(orig_pos,dest_pos)
-		end
-
-		if valid_move && !test && !in_check_after_move
-			self.update(orig_pos, dest_pos)
-		end 
-
-		valid_move && !@in_check[piece_color] && !in_check_after_move
-	end
-
-	def in_check_after_move?(orig, dest)
-		test_board = @board.map(&:dup)
-		
-		orig_y = orig[0]
-		orig_x = orig[1]
-		dest_y = dest[0]
-		dest_x = dest[1]
-		piece = test_board[orig_y][orig_x]
-
-		# Hacky way of doing this. Will fail for en passant and castling.
-		test_board[orig_y][orig_x] = nil
-		test_board[dest_y][dest_x] = piece
-
-		piece_color = piece[0]
-		king = piece_color + "K"
-
-		king_coords = nil
-		test_board.each_with_index do |row, y|
-			if row.include?(king) 
-				king_coords = [y, row.index(king)]
-			end
-		end
-
-		if king_coords.nil?
-			return false
-		end
-
-		king_pos = NotationParser.encode_notation(king_coords)
-
-		test_board.each_with_index do |row, y|
-			row.each_with_index do |col, x|
-				if !col.nil? && col[0] != piece_color
-					piece_pos = NotationParser.encode_notation([y,x])
-					if move(piece_pos, king_pos, true, test_board)
-						return true
-					end
-				end
-			end
-		end
-
-		false
-	end
-
-	def any_valid_moves?(color)
-		test_board = @board.map(&:dup)
-
-		test_board.each_with_index do |row, orig_y|
-			row.each_with_index do |col, orig_x|
-				if !col.nil? && col[0] == color
-					orig_pos = NotationParser.encode_notation([orig_y,orig_x])
-					8.times do |dest_x|
-						8.times do |dest_y|
-							dest_pos = NotationParser.encode_notation([dest_y, dest_x])
-							if move(orig_pos, dest_pos, true)
-								if !in_check_after_move?([orig_y,orig_x],[dest_y,dest_x])
-									return true
-								end	
-							end
-						end
-					end
-				end
-			end
-		end
-
-		false
-	end
-
-	def checkmate?(color)
-		piece_color = color.downcase == "w" ? :white : :black
-		!any_valid_moves?(color) && in_check?[piece_color]
-	end
-
-	def draw?(color)
-		piece_color = color.downcase == "w" ? :white : :black
-		!any_valid_moves?(color) && in_check?[piece_color] == false
-	end
-end
+  require 'helpers/notation_parser'
+  require 'pieces/pawn'
+  require 'pieces/rook'
+  require 'pieces/bishop'
+  require 'pieces/knight'
+  require 'pieces/queen'
+  require 'pieces/king'
+
+  attr_reader :board, :turn, :in_check, :promotable, :en_passant, :castling
+
+  def initialize(board = nil, turn = nil)
+    @board = if board.nil?
+               [
+                 %w[BR BN BB BQ BK BB BN BR],
+                 %w[BP BP BP BP BP BP BP BP],
+                 [nil, nil, nil, nil, nil, nil, nil, nil],
+                 [nil, nil, nil, nil, nil, nil, nil, nil],
+                 [nil, nil, nil, nil, nil, nil, nil, nil],
+                 [nil, nil, nil, nil, nil, nil, nil, nil],
+                 %w[WP WP WP WP WP WP WP WP],
+                 %w[WR WN WB WQ WK WB WN WR]
+               ]
+             else
+               board
+             end
+
+    @turn = if turn.nil?
+              1
+            else
+              turn
+            end
+
+    @promotable = nil
+    @en_passant = { white: nil, black: nil }
+    @castling = {
+      white: {
+        kingside: true,
+        queenside: true
+      },
+      black: {
+        kingside: true,
+        queenside: true
+      }
+    }
+    @in_check = { "white": false, "black": false }
+  end
+
+  def update(orig, dest = nil)
+    orig_y = orig[0]
+    orig_x = orig[1]
+    dest_y = dest[0]
+    dest_x = dest[1]
+    piece_type = @board[orig_y][orig_x]
+    opposite_color = piece_type[0] == 'W' ? :black : :white
+    direction = opposite_color == :white ? -1 : 1
+
+    if piece_type[1] == 'P' && @en_passant[opposite_color] == [dest_y + direction, dest_x]
+      en_passant = true
+      en_passant_coords = [@en_passant[opposite_color][0], @en_passant[opposite_color][1]]
+    end
+
+    if piece_type[1] == 'K' && (orig_x - dest_x).abs == 2
+      castle = true
+      old_rook_x_position = orig_x < dest_x ? 7 : 0
+      new_rook_x_position = orig_x < dest_x ? 5 : 3
+    end
+
+    @board[en_passant_coords[0]][en_passant_coords[1]] = nil if en_passant
+    if castle
+      @board[orig_y][old_rook_x_position] = nil
+      @board[orig_y][new_rook_x_position] = piece_type[0] + 'R'
+    end
+
+    @board[orig_y][orig_x] = nil
+    @board[dest_y][dest_x] = piece_type
+
+    @turn += 1
+  end
+
+  def in_check?(board = nil)
+    board = board.nil? ? @board : board
+    wk_coords = bk_coords = nil
+
+    board.each_with_index do |row, y|
+      wk_coords = [y, row.index('WK')] if row.include?('WK')
+      bk_coords = [y, row.index('BK')] if row.include?('BK')
+    end
+
+    wk_pos = NotationParser.encode_notation(wk_coords) if wk_coords
+    bk_pos = NotationParser.encode_notation(bk_coords) if bk_coords
+
+    white_in_check = black_in_check = false
+    board.each_with_index do |row, y|
+      row.each_with_index do |col, x|
+        next if col.nil?
+
+        piece_pos = NotationParser.encode_notation([y, x])
+        if col[0] == 'W' && bk_pos
+          black_in_check = true if move(piece_pos, bk_pos, true)
+        elsif col[0] == 'B' && wk_pos
+          white_in_check = true if move(piece_pos, wk_pos, true)
+        end
+      end
+    end
+
+    { "white": white_in_check, "black": black_in_check }
+  end
+
+  def move(orig, dest, test = false, test_board = nil)
+    orig_pos = NotationParser.parse_notation(orig)
+    dest_pos = NotationParser.parse_notation(dest)
+
+    return false if orig_pos.nil? || dest_pos.nil?
+
+    orig_y = orig_pos[0]
+    orig_x = orig_pos[1]
+
+    piece = @board[orig_y][orig_x]
+    piece_type = piece[1]
+
+    piece_color = if piece[0].downcase == 'w'
+                    :white
+                  elsif piece[0].downcase == 'b'
+                    :black
+                  end
+
+    @en_passant[piece_color] = nil if @en_passant[piece_color]
+
+    board = test_board.nil? ? @board : test_board
+    valid_move = case piece_type
+                 when 'P'
+                   Pawn.move_is_valid?(orig_pos, dest_pos, board, @en_passant)
+                 when 'R'
+                   Rook.move_is_valid?(orig_pos, dest_pos, board)
+                 when 'B'
+                   Bishop.move_is_valid?(orig_pos, dest_pos, board)
+                 when 'N'
+                   Knight.move_is_valid?(orig_pos, dest_pos, board)
+                 when 'Q'
+                   Queen.move_is_valid?(orig_pos, dest_pos, board)
+                 when 'K'
+                   King.move_is_valid?(orig_pos, dest_pos, board, @castling)
+                 else
+                   false
+                 end
+
+    unless test
+      @in_check = in_check?
+      in_check_after_move = in_check_after_move?(orig_pos, dest_pos)
+      if valid_move
+        case piece_type
+        when 'P'
+          @en_passant[piece_color] = dest_pos if (orig_pos[0] - dest_pos[0]).abs > 1
+        when 'K'
+          @castling[piece_color].keys.each do |direction|
+            @castling[piece_color][direction] = false
+          end
+        when 'R'
+          if [0, 7].include?(orig_x)
+            direction = orig_x == 7 ? :kingside : :queenside
+            @castling[piece_color][direction] = false
+          end
+        end
+      end
+    end
+
+    if valid_move && !test && !in_check_after_move
+      update(orig_pos, dest_pos)
+      @promotable = dest_pos if piece_type == 'P' && promote?(dest_pos)
+    end
+
+    valid_move && !@in_check[piece_color] && !in_check_after_move
+  end
+
+  def in_check_after_move?(orig, dest)
+    test_board = @board.map(&:dup)
+
+    orig_y = orig[0]
+    orig_x = orig[1]
+    dest_y = dest[0]
+    dest_x = dest[1]
+    piece = test_board[orig_y][orig_x]
+    piece_type = test_board[orig_y][orig_x]
+    opposite_color = piece_type[0] == 'W' ? :black : :white
+    direction = opposite_color == :white ? -1 : 1
+
+    if piece_type[1] == 'P' && @en_passant[opposite_color] == [dest_y + direction, dest_x]
+      en_passant = true
+      en_passant_coords = [@en_passant[opposite_color][0], @en_passant[opposite_color][1]]
+    end
+
+    test_board[en_passant_coords[0]][en_passant_coords[1]] = nil if en_passant
+
+    test_board[orig_y][orig_x] = nil
+    test_board[dest_y][dest_x] = piece_type
+
+    piece_color = piece[0]
+    king = piece_color + 'K'
+
+    king_coords = nil
+    test_board.each_with_index do |row, y|
+      king_coords = [y, row.index(king)] if row.include?(king)
+    end
+
+    return false if king_coords.nil?
+
+    king_pos = NotationParser.encode_notation(king_coords)
+
+    test_board.each_with_index do |row, y|
+      row.each_with_index do |col, x|
+        next unless !col.nil? && col[0] != piece_color
+
+        piece_pos = NotationParser.encode_notation([y, x])
+        return true if move(piece_pos, king_pos, true, test_board)
+      end
+    end
+
+    false
+  end
+
+  def any_valid_moves?(color)
+    test_board = @board.map(&:dup)
+
+    test_board.each_with_index do |row, orig_y|
+      row.each_with_index do |col, orig_x|
+        next unless !col.nil? && col[0] == color
+
+        orig_pos = NotationParser.encode_notation([orig_y, orig_x])
+        8.times do |dest_x|
+          8.times do |dest_y|
+            dest_pos = NotationParser.encode_notation([dest_y, dest_x])
+            next unless move(orig_pos, dest_pos, true)
+            return true unless in_check_after_move?([orig_y, orig_x], [dest_y, dest_x])
+          end
+        end
+      end
+    end
+
+    false
+  end
+
+  def checkmate?(color)
+    piece_color = color.downcase == 'w' ? :white : :black
+    !any_valid_moves?(color) && in_check?[piece_color]
+  end
+
+  def draw?(color)
+    piece_color = color.downcase == 'w' ? :white : :black
+    !any_valid_moves?(color) && in_check?[piece_color] == false
+  end
+
+  def promote?(square)
+    square_y = square[0]
+    square_x = square[1]
+    piece = @board[square_y][square_x][0]
+    promote_column = piece.downcase == 'w' ? 0 : 7
+    promote_column == square_y
+  end
+
+  def promote!(square, piece)
+    square_y = square[0]
+    square_x = square[1]
+
+    old_piece = @board[square_y][square_x]
+    return nil if old_piece.nil? || !promote?(square)
+
+    case piece.downcase
+    when 'rook'
+      piece_type = 'R'
+    when 'knight'
+      piece_type = 'N'
+    when 'bishop'
+      piece_type = 'B'
+    when 'queen'
+      piece_type = 'Q'
+    else
+      return nil
+    end
+
+    @board[square_y][square_x] = old_piece[0] + piece_type
+  end
+end