chessmate 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f042254ab0fe6dc50c0213638d69d171f375ab391dfca12e299b2de32ef28600
-  data.tar.gz: 8b21d6530f391a31f13242305d855f5a04cedc670d8ea8eb6d11b297b144d517
+  metadata.gz: 6be20b4d6b07a0f81f64db1d90580456b3f9c8cfc516ede8a669139f473640d5
+  data.tar.gz: fc4eee51ad0a83400cc605c111a012ca37b02f54cf9eafb4dc3b9b054c72a917
 SHA512:
-  metadata.gz: 90a11d0a8bcb5f1f2b95d0533f314c6288a2629fb8c2b7254017af75af5f78d5a010a838aba431bf4369700470feb9b25dc7168180fd7a8cbf6fcf6dc3372c5c
-  data.tar.gz: 49066fb580c9ce0900e433162e61bc9f5967ec6abc2467aba4551242fee1391f70774db4371d72d46142426702768e2683b89cbb4500b9e6c5e2ad37fd554cb6
+  metadata.gz: 77431e006f69ea5c8aaa3788d2faaa8a08e919dc6462c6e621f7086d60ca5589dc2ceea3b3f056e6ae57ff6931425be7d912c87da886a416cdff55055b7efd0e
+  data.tar.gz: 9081e8d1c6f7d846c4f9a95696e981c9e18c0683ff4c39830a1853b80982b15f19787b6f690192e72dc311db14aa227f63411e400fa5825444299de4ffe2f588

data/lib/chessmate.rb

@@ -0,0 +1,226 @@
+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

data/lib/helpers/notation_parser.rb

@@ -0,0 +1,24 @@
+module NotationParser
+	def self.parse_notation(square)
+		col = square[0].downcase().ord - 97 
+		row = 7 - ( square[1].to_i - 1 )
+
+		if col >= 0 && col < 8 && row >= 0 && row < 8
+			[row,col]
+		else
+			return nil
+		end
+	end
+
+	def self.encode_notation(coords)
+		row, col = coords
+
+		if col >= 0 && col < 8 && row >= 0 && row < 8
+			col = (col + 97).chr
+			row = (8 - row).to_s
+			return col + row
+		else
+			return nil
+		end
+	end
+end

data/lib/pieces/bishop.rb

@@ -0,0 +1,12 @@
+require 'pieces/piece'
+
+class Bishop < Piece
+	def self.move_is_valid?(orig, dest, board)
+		not_obstructed = !self.is_obstructed?(orig, dest, board)
+
+		not_obstructed && 
+		( !self.destination_occupied?(dest, board) || self.is_capturable?(orig, dest, board) ) &&
+		(orig[0] - dest[0]).abs == (orig[1] - dest[1]).abs 
+	end
+	
+end

data/lib/pieces/king.rb

@@ -0,0 +1,9 @@
+require 'pieces/piece'
+
+class King < Piece
+	def self.move_is_valid?(orig, dest, board)
+		(orig[0] - dest[0]).abs <= 1 && (orig[1] - dest[1]).abs <= 1 &&
+		( !self.destination_occupied?(dest, board) || self.is_capturable?(orig, dest, board) )
+	end
+	
+end

data/lib/pieces/knight.rb

@@ -0,0 +1,12 @@
+require 'pieces/piece'
+
+class Knight < Piece
+	def self.move_is_valid?(orig, dest, board)
+		x_offset = (orig[0] - dest[0]).abs
+		y_offset = (orig[1] - dest[1]).abs
+
+		( !self.destination_occupied?(dest, board) || self.is_capturable?(orig, dest, board) )  && 
+		(x_offset == 2 && y_offset == 1) || (x_offset == 1 && y_offset == 2)
+	end
+	
+end

data/lib/pieces/pawn.rb

@@ -0,0 +1,34 @@
+require 'pieces/piece'
+
+class Pawn < Piece
+	def self.move_is_valid?(orig, dest, board)
+		orig_y = orig[0]
+		orig_x = orig[1]
+		dest_y = dest[0]
+		dest_x = dest[1]
+		piece_type = board[orig_y][orig_x]
+		piece_color = piece_type[0].downcase()
+
+		if piece_color == "w"
+			direction = 1
+		elsif piece_color == "b"
+			direction = -1
+		else
+			return false
+		end
+
+		if self.is_capturable?(orig,dest,board) && 
+			 (orig_x - dest_x).abs == 1 && 
+			 (orig_y - dest_y) * direction == 1
+			return true
+		end
+
+		not_obstructed = !self.is_obstructed?(orig, dest, board)
+	
+		basic_move = ( (orig_y - dest_y) * direction == 1 && orig_x == dest_x )
+		move_double_on_first_turn = ( orig_y - dest_y == (2 * direction) ) && ( orig_x == dest_x )
+
+		move_double_on_first_turn && not_obstructed || basic_move
+	end
+	
+end

data/lib/pieces/piece.rb

@@ -0,0 +1,76 @@
+class Piece
+	def self.is_obstructed?(orig, dest, board)
+		orig_y = orig[0]
+		orig_x = orig[1]
+		dest_y = dest[0]
+		dest_x = dest[1]
+
+		if orig_y == dest_y
+
+			direction = orig_x > dest_x ? 1 : -1
+			( (orig_x - dest_x).abs - 1 ).times do |x|
+				test_pos = orig_x - (x * direction) - direction
+				if !board[orig_y][test_pos].nil?
+					return true
+				end
+			end
+			return false
+
+		elsif orig_x == dest_x
+
+			direction = orig_y > dest_y ? 1 : -1
+			( (orig_y - dest_y).abs - 1 ).times do |y|
+				test_pos = orig_y - (y * direction) - direction
+				if !board[test_pos][orig_x].nil?
+					return true
+				end
+			end
+
+			return false
+
+		elsif (orig_y - dest_y).abs == (orig_x - dest_x).abs
+			
+			x_direction = orig_x > dest_x ? 1 : -1
+			y_direction = orig_y > dest_y ? 1 : -1
+
+			( (orig_y - dest_y).abs - 1 ).times do |v|
+				test_y_pos = orig_y - (v * y_direction) - y_direction
+				test_x_pos = orig_x - (v * x_direction) - x_direction
+				if !board[test_y_pos][test_x_pos].nil?
+					return true
+				end
+			end
+
+			return false
+
+		else
+			return nil
+		end
+	end
+
+	def self.is_capturable?(orig, dest, board)
+		orig_y = orig[0]
+		orig_x = orig[1]
+		dest_y = dest[0]
+		dest_x = dest[1]
+		orig_piece = board[orig_y][orig_x]
+		dest_piece = board[dest_y][dest_x]
+
+		if orig_piece && dest_piece
+			orig_piece_color = orig_piece[0]
+			dest_piece_color = dest_piece[0]
+		else
+			return false
+		end
+
+		orig_piece_color != dest_piece_color
+
+	end
+
+	def self.destination_occupied?(dest, board)
+		dest_y = dest[0]
+		dest_x = dest[1]
+
+		!board[dest_y][dest_x].nil?
+	end
+end

data/lib/pieces/queen.rb

@@ -0,0 +1,17 @@
+require 'pieces/piece'
+
+class Queen < Piece
+		def self.move_is_valid?(orig, dest, board)
+
+		not_obstructed = !self.is_obstructed?(orig, dest, board)
+
+		not_obstructed && 
+		( !self.destination_occupied?(dest, board) || self.is_capturable?(orig, dest, board) ) &&
+		(
+			(orig[0] - dest[0]).abs == (orig[1] - dest[1]).abs ||
+			orig[0] == dest[0] || orig[1] == dest[1]
+		)
+		
+	end
+	
+end

data/lib/pieces/rook.rb

@@ -0,0 +1,16 @@
+require 'pieces/piece'
+
+class Rook < Piece
+	def self.move_is_valid?(orig, dest, board)
+
+		not_obstructed = !self.is_obstructed?(orig, dest, board)
+
+		not_obstructed && 
+		( !self.destination_occupied?(dest, board) || self.is_capturable?(orig, dest, board) ) &&
+		(
+			orig[0] == dest[0] || orig[1] == dest[1]
+		)
+		
+	end
+	
+end