rubyknight 0.1.0

data/README

@@ -0,0 +1,4 @@
+RubyKnight
+==========
+
+RubyKnight is a very naive implementation of a chess library and engine.

data/Rakefile

@@ -0,0 +1,16 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "rubyknight"
+    s.executables = ["rubyknight","rubyknight-xboard"]
+    s.summary = "Naive chess library and engine written in ruby"
+    s.email = "chris@inarow.net"
+    s.homepage = "http://github.com/cdmoyer/RubyKnight"
+    s.description = "Naive chess library and engine written in ruby.  Includes rubyknight and rubyknight-xboard executables"
+    s.authors = ["Chris Moyer"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/TODO

@@ -0,0 +1 @@
+TODO: add castling to king moves (mark uncastling in move())

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/rubyknight

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require 'rubyknight'
+
+def time_it label
+	yield
+end
+
+module Enumerable
+	def rand
+		self[Kernel.rand(self.size)]
+	end
+end
+
+def displayb b, evaluator
+	puts "#{b.to_s}\n"
+	moves = b.gen_legal_moves
+	puts "Score: #{evaluator.eval_position}"
+#	puts "Moves: #{moves.size}"
+#	i=1
+#	moves.each do |m|
+#		print m.join(',')
+#		if i % 13 == 0 then print "\n"
+#		else print ' ' end
+#		i+=1
+#	end
+#	print "\n"
+	if moves.size == 0
+		puts "Checkmate, you lose."
+		Kernel.exit 0
+	end
+	print "Enter move [#{b.white_to_play? ? 'White' : 'Black'}]> "
+end
+
+Thread.abort_on_exception = true
+
+def play b, eval
+	moves = b.gen_legal_moves
+	if moves.size == 0
+		puts "Checkmate, you win!"	
+		Kernel.exit(0)
+	end
+	# move = moves.rand
+	@thinking = Thread.new { eval.think(b.white_to_play?) }
+	until eval.donethinking; sleep(1.2); end
+	move = eval.bestmove
+	b.cnotation_move "#{RubyKnight::Board.position_to_coord move[0]}#{RubyKnight::Board.position_to_coord move[1]}"
+end
+
+cplay = false
+b = RubyKnight::Board.new
+eval = RubyKnight::BoardEvaluator.new b
+displayb b, eval
+#['e2e4' , 'e7e5' , 'd2d3'].each do |move|
+#['e2e4','d7d5','e4e5','f7f5'].each do |move|
+$stdin.each do |move|
+	move.strip!
+	if move =~ /!([^ ]*)[ ]*(.*)/
+		case $1
+			when "quit" then Kernel.exit 
+			when "undo" then b.undo 2
+			when "play" 
+				cplay = !cplay
+				play(b, eval) if cplay
+			when "dump" 
+				File.open( $2, "w") { |f| f.write( b.dump) }
+				puts "dumped."
+			when "load" 
+				File.open( $2, "r") { |f| b.load( f.readlines.join) }
+				eval = RubyKnight::BoardEvaluator.new b
+				puts "loaded."
+			when "reset" 
+				b = RubyKnight::Board.new
+				eval = RubyKnight::BoardEvaluator.new b
+		end
+		displayb b,eval
+	else
+		begin
+			b.cnotation_move move
+			play(b,eval) if cplay
+		rescue RubyKnight::IllegalMoveException
+			print "Enter a real move! #{$!.to_s}\n"
+		end
+		displayb b,eval
+	end
+end
+

data/bin/rubyknight-xboard

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require 'rubyknight'
+
+confirm = false
+$stdout.sync=true
+$stderr.sync=true
+Thread.abort_on_exception = true
+
+def time_it label
+	yield
+end
+
+def logout msg
+	$stderr.print "Out:#{msg}\n"		
+	print "#{msg}\n"		
+end
+
+module Enumerable
+	def rand
+		self[Kernel.rand(self.size)]
+	end
+end
+
+
+def tocnote move
+	"#{RubyKnight::Board.position_to_coord move[0]}#{RubyKnight::Board.position_to_coord move[1]}"
+end
+
+def play b, eval
+	moves = b.gen_legal_moves
+	if moves.size == 0
+		puts "RESULT 1-0 {White Mates}"
+	end
+	thinking = Thread.new { eval.think(b.white_to_play?) }
+	until eval.donethinking; sleep(0.2); end
+	move = eval.bestmove
+	cnotation = tocnote move
+	b.cnotation_move cnotation
+	logout "move #{cnotation}"
+end
+
+b = RubyKnight::Board.new
+eval = RubyKnight::BoardEvaluator.new b
+$stdin.each do |move|
+	move.strip!
+	$stderr.print "In :#{move}\n"
+	case move	
+		when "xboard" then 
+			logout ""
+			logout "tellics set f5 1=1"
+		when "confirm_moves"
+			confirm = true	
+			logout "Will now confirm moves."	
+		when /.{0,1}new/
+			b = RubyKnight::Board.new
+			eval = RubyKnight::BoardEvaluator.new b
+			logout "tellics set 1 RubyKnight"
+		when /^protover/ then 
+			logout "feature sigint=0 sigterm=0 ping=1 done=1"	
+		when /^ping\s+(.*)/ then 
+			logout "pong #{$1}"	
+		when /^st/ then 
+		when /^level/ then 
+		when /^time/ then 
+		when /^otim/ then 
+		when "hard" then 
+		when "random" then 
+		when /^accepted/ then 
+			# ignore	
+		else		
+			move.gsub!(/\?/, '')	
+			begin
+				b.cnotation_move move
+				logout "Legal move: #{move}" if confirm
+				play(b,eval)
+			rescue RubyKnight::IllegalMoveException
+				logout "Illegal move: #{move}"
+			rescue	Exception=> e
+				puts e	
+			end
+	end
+end
+
+

data/doc/reference_sites.txt

@@ -0,0 +1,9 @@
+http://www.gamedev.net/reference/programming/features/chess1/
+http://chess.verhelst.org/
+http://www.maths.nott.ac.uk/personal/anw/G13GT1/compch.html
+http://www.tim-mann.org/chess.html
+http://www.byte.com/documents/s=8880/byt1062182594527/
+http://www.chessbrain.net/beowulf/theory.html
+
+Evaluation:
+http://www.rpi.edu/~mooner/Tutorial/evaluation.html

data/lib/rubyknight/evaluator.rb

@@ -0,0 +1,125 @@
+module RubyKnight
+	class BoardEvaluator
+		attr_reader :bestmoves, :donethinking
+		def initialize board
+			@b = board
+			@bestmoves, @bestscore, @donethinking = nil, 0, false
+		end
+
+		# Pick a random move from equal options
+		def bestmove
+			if @bestmoves
+				return @bestmoves[Kernel.rand(@bestmoves.size)]
+			end
+			nil
+		end
+
+		def think for_white
+			@bestmoves, @bestscore, @donethinking = nil, 0, false
+			clone = Marshal.load(Marshal.dump( @b))
+			clone.gen_legal_moves.each do |move|
+				newb = Marshal.load(Marshal.dump( clone))
+				newb.move move[0], move[1], move[2]
+				result = eval_position newb
+				if (for_white and result > @bestscore) or
+					   result < @bestscore or @bestmoves == nil
+					  @bestscore = result 
+					  @bestmoves = [move]
+				elsif result == @bestscore
+					@bestmoves << move	
+				end
+			end
+			@donethinking = true
+		end
+
+		# Return an int
+		# being the pawn advantage of white
+		def eval_position board=@b
+			material = time_it("eval_material") { eval_material(board)}
+			pawn_struct = time_it("eval_pawn_struct") { eval_pawn_struct(board)}
+			material + pawn_struct
+		end
+
+		def eval_pawn_struct board
+			advant = board.num_pieces(RubyKnight::Board::WPAWN) - 
+			         board.num_pieces(RubyKnight::Board::BPAWN)
+
+			wpawns, bpawns = get_pawn_array board
+			passed, isolated, doubled, chained = 0,0,0,0
+			(1..8).each do |rank|
+				w,wl,wr = wpawns[rank],wpawns[rank-1],wpawns[rank+1]
+				b,bl,br = bpawns[rank],bpawns[rank+1],bpawns[rank-1]
+
+				w.each {|c|passed+=1 if (b.size==0||c<b.min)&&(bl.size==0||c<=bl.min)&&(br.size==0||c<=br.min)}
+				b.each {|c|passed-=1 if (w.size==0||c>w.max)&&(wl.size==0||c>=wl.max)&&(wr.size==0||c>=wr.max)}
+
+				wchain = false
+				w.each { |c|
+					wl.each {|i| wchain = true if (c-i).abs <=1 }
+					wr.each {|i| wchain = true if (c-i).abs <=1 } unless wchain
+				}
+				bchain = false
+				b.each { |c|
+					bl.each {|i| bchain = true if (c-i).abs <= 1 }
+					br.each {|i| bchain = true if (c-i).abs <= 1 } unless bchain
+				}
+				#puts "rank=#{rank} wchain=#{wchain} bchain=#{bchain}"
+
+				isolated +=1 unless w.size>0 && wchain
+				isolated -=1 unless b.size>0 && bchain
+
+				chained +=1 if w.size>0 && wchain
+				chained -=1 if b.size>0 && bchain
+	
+				doubled -= 1 if w.size > 1
+				doubled += 1 if b.size > 1
+			end
+			
+			chained = if chained==0 then 0
+			          elsif chained > 0 then 1
+			          else -1 end
+			doubled = if doubled==0 then 0
+			          elsif doubled > 0 then 1
+			          else -1 end
+			#puts "#{advant} + #{passed} + #{doubled} + #{chained} - #{isolated}"
+			return advant + passed + doubled + chained - isolated
+		end
+
+		# make array of pawns[file][rank]
+		def get_pawn_array board
+			wpawns = Array.new(10)
+			bpawns = Array.new(10)
+			(0..9).each { |i| wpawns[i] = Array.new 0, 0}
+			(0..9).each { |i| bpawns[i] = Array.new 0, 0}
+			board.piece_positions(RubyKnight::Board::WPAWN).each \
+				{ |p| wpawns[(p%8)+1] << (p/8) }
+			board.piece_positions(RubyKnight::Board::BPAWN).each \
+				{ |p| bpawns[(p%8)+1] << (p/8) }
+			return wpawns, bpawns
+		end
+		
+
+		def eval_material board
+			q, r, b, n, p = 9, 5, 3, 3, 1
+			white = p * board.num_pieces(RubyKnight::Board::WPAWN) +
+	        		q * board.num_pieces(RubyKnight::Board::WQUEEN) +
+	        		r * board.num_pieces(RubyKnight::Board::WROOK) +
+	        		b * board.num_pieces(RubyKnight::Board::WBISHOP) +
+	        		n * board.num_pieces(RubyKnight::Board::WKNIGHT)
+			black = p * board.num_pieces(RubyKnight::Board::BPAWN) +
+	        		q * board.num_pieces(RubyKnight::Board::BQUEEN) +
+	        		r * board.num_pieces(RubyKnight::Board::BROOK) +
+	        		b * board.num_pieces(RubyKnight::Board::BBISHOP) +
+	        		n * board.num_pieces(RubyKnight::Board::BKNIGHT)
+		
+			white - black		
+		end
+
+		def time_it label
+			start = Time.now
+			res = yield
+			#puts "TIMING( '#{label}=>#{res}'): #{Time.now - start} seconds"
+			res
+		end
+	end
+end

data/lib/rubyknight/generator.rb

@@ -0,0 +1,333 @@
+def time_it label
+	start = Time.now
+	res = yield
+	puts "TIMING( '#{label}'): #{Time.now - start} seconds"
+	res
+end
+
+
+class RubyKnight::Board
+	def gen_legal_moves
+		moves = nil
+		time_it("gen_moves"){ moves = gen_moves(@to_play)}	
+		time_it("legal filtering"){ moves = prune_king_revealers(@to_play,moves)}
+		moves
+	end
+
+	# TODO: I am so slow, that I should die, probably in gen_moves
+	def prune_king_revealers player, moves
+		kpiece = player==WHITE ? WKING : BKING
+		moves.select do |to_try|
+			move to_try[0], to_try[1], to_try[2], false
+			next_moves = gen_moves @to_play
+			king, = bits_to_positions(@bitboards[kpiece])
+			ret = true
+			next_moves.each do |m|
+				if m[1] == king
+					ret = false		
+					break
+				end
+			end
+			undo 1
+			ret
+		end
+	end
+
+	# broken?
+	def prune_king_revealers_old player, moves
+		kpiece = player==WHITE ? WKING : BKING
+		piecemod = player==WHITE ? BPAWN : 0
+		moves.select do |to_try|
+			move to_try[0], to_try[1], to_try[2], false
+			king, = bits_to_positions(@bitboards[kpiece])
+			dead_king = false
+			rank = king / 8
+			file = king % 8
+			#check up and down for R or Q
+			[-8,-1,1,8].each do |inc|
+				limit = 8
+				trying = king + inc
+				while !dead_king and limit > 0 and
+		          	trying >= 0 and trying <= 63 and
+			      	(rank == (trying / 8) or
+				   	file == (trying % 8)) do
+					target = whats_at trying
+					if target
+					   if (target == (WROOK+piecemod) or
+					       target == (WQUEEN+piecemod))
+							dead_king = true
+					   end
+					   limit = 0
+					else
+						trying += inc
+						limit -= 1
+					end
+				end
+			end unless dead_king
+			#check diagonals for Q, B
+			[-9,-7,7,9].each do |inc|
+				limit = 8
+				trying = king + inc
+				rank = trying / 8
+				lastrank = king / 8
+				while !dead_king and limit > 0 and
+			      	trying >= 0 and trying <= 63 and
+			      	(lastrank - rank).abs == 1 do
+					target = whats_at trying
+					if target
+						if (target == (WBISHOP+piecemod) or
+						    target == (WQUEEN+piecemod))
+							dead_king = true
+						end
+						limit = 0
+					else
+						lastrank = rank
+						trying += inc
+						rank = trying / 8
+						limit -= 1
+					end
+				end
+			end unless dead_king
+			#check 2 P launch zones
+			#check 8 N attack spots
+			undo 1
+			!dead_king
+		end
+	end
+		
+	def gen_moves player
+		white = player==WHITE
+		if 1 
+		gen_pawn_moves(white) +
+	    gen_knight_moves(white) +
+		gen_rook_moves(white) +
+		gen_bishop_moves(white) +
+		gen_king_moves(white) +
+		gen_queen_moves(white)
+		else
+		time_it("gen_pawn") { gen_pawn_moves(white)} +
+		time_it("gen_knight") { gen_knight_moves(white)} +
+		time_it("gen_rook") { gen_rook_moves(white)} +
+		time_it("gen_bishop") { gen_bishop_moves(white)} +
+		time_it("gen_king") { gen_king_moves(white)} +
+		time_it("gen_queen") {gen_queen_moves(white)}
+		end
+	end
+
+	def different_colors white, piece
+		(white and !is_white piece) or
+		(!white and is_white piece)
+	end
+
+	def gen_rook_type_moves white, piece, start_limit = 8
+		moves = []
+		rank = piece / 8
+		file = piece % 8
+		[-8,-1,1,8].each do |inc|
+			limit = start_limit	
+			trying = piece + inc
+			while limit > 0 and
+		          trying >= 0 and trying <= 63 and
+			      (rank == (trying / 8) or
+				   file == (trying % 8)) do
+				target = whats_at trying
+				if !target
+					moves << [piece, trying]
+				elsif different_colors( white, target)
+					moves << [piece, trying]
+					break
+				else
+					break
+				end
+				trying += inc
+				limit -= 1
+			end
+		end
+		moves
+	end
+	
+	def gen_rook_moves white
+		moves = []
+		rooks = @bitboards[ white ? WROOK : BROOK]
+		bits_to_positions(rooks).each do |r|
+			moves += gen_rook_type_moves( white, r)
+		end
+		moves
+	end
+
+	def gen_bishop_type_moves white, piece, start_limit = 8
+		moves = []
+		[-9,-7,7,9].each do |inc|
+			limit = start_limit	
+			trying = piece + inc
+			rank = trying / 8
+			lastrank = piece / 8
+			while limit > 0 and
+			      trying >= 0 and trying <= 63 and
+			      (lastrank - rank).abs == 1 do
+				target = whats_at trying
+				if !target
+					moves << [piece, trying]
+				elsif different_colors( white, target)
+					moves << [piece, trying]
+					break
+				else
+					break
+				end
+				lastrank = rank
+				trying += inc
+				rank = trying / 8
+				limit -= 1
+			end
+		end
+		moves
+	end
+
+	def gen_bishop_moves white
+		moves = []
+		bishops = @bitboards[white ? WBISHOP : BBISHOP]
+		bits_to_positions(bishops).each do |r|
+			moves += gen_bishop_type_moves( white, r)
+		end
+		moves
+	end
+
+	def gen_queen_moves white
+		moves = []
+		queens = @bitboards[white ? WQUEEN : BQUEEN]
+		bits_to_positions(queens).each do |r|
+			moves += gen_rook_type_moves(white, r)
+			moves += gen_bishop_type_moves( white, r)
+		end
+		moves
+	end
+
+	# TODO: how much time is wasted with the each?  We'll never have
+	#  multiple kings, will we?
+	def gen_king_moves white
+		moves = []
+		kings = @bitboards[white ? WKING : BKING]
+		bits_to_positions(kings).each do |king|
+			moves += gen_rook_type_moves( white, king, 1)
+			moves += gen_bishop_type_moves( white, king, 1)
+			moves += gen_castle_moves( white, king)
+		end
+		moves
+	end
+
+	def gen_castle_moves white, king
+		color = white ? WHITE : BLACK
+		goodcastles = []
+		# kingside
+		if can_castle color, KINGSIDE
+			test = if white then [60,61,62]
+			       else [4,5,6] end
+			if !whats_at(test[1]) and !whats_at(test[2])
+				left = prune_king_revealers(@to_play,
+				           test.map {|dest| [test[0], dest]})
+				if left.size == 3 
+					goodcastles << [test[0],test[2]] 
+				end
+			end
+		end
+		# queenside
+		if can_castle color, QUEENSIDE
+			test = if white then [60,59,58]
+			       else [4,3,2] end
+			if !whats_at(test[1]) and !whats_at(test[2])
+				left = prune_king_revealers(@to_play,
+				           test.map {|dest| [test[0], dest]})
+				if left.size == 3 
+					goodcastles << [test[0],test[2]] 
+				end
+			end
+		end
+		goodcastles
+	end
+
+	def gen_knight_moves white
+		moves = []
+		knights = @bitboards[white ? WKNIGHT : BKNIGHT]
+		bits_to_positions(knights).each do |k|
+			[-17, -15, -10, -6, 6, 10, 15, 17].each do |m|
+				target = k+m
+				if target >= 0 and target <= 63 and
+				   ((target % 8) - (k % 8)).abs < 3
+					capture = whats_at target
+					if !capture or different_colors(white, capture)
+					   moves << [k, target]
+					end
+				end
+			end
+		end
+		moves
+	end
+	
+	def gen_pawn_moves white
+		pawns = @bitboards[white ? WPAWN : BPAWN]
+		if white
+			in_front_int = -8
+			second_rank_high = 56
+			second_rank_low = 47
+			two_away_int = -16
+			attack_left = -9
+			attack_right = -7
+			promote_low = -1
+			promote_high = 8
+			promotes = [WROOK, WQUEEN, WKNIGHT, WBISHOP]
+		else
+			in_front_int = 8
+			second_rank_high = 16
+			second_rank_low = 7
+			two_away_int = 16
+			attack_left = 7
+			attack_right = 9
+			promote_low = 55
+			promote_high = 64
+			promotes = [BROOK, BQUEEN, BKNIGHT, BBISHOP]
+		end
+		do_pawn = Proc.new do |p|
+			possible = []
+			in_front = whats_at( p + in_front_int)
+			#single step
+			if  !in_front
+				in_front_pos = p + in_front_int
+				possible << in_front_pos
+				if in_front_pos > promote_low and in_front_pos < promote_high
+					promotes.each { |piece| possible << [in_front_pos, piece] }
+				end
+			end
+			#double jump
+			if p < second_rank_high and p > second_rank_low and !in_front and
+			   !whats_at( p + two_away_int)
+				possible << ( p + two_away_int)
+			end
+			#captures
+			unless p % 8 == 0 # we're in the a file
+				ptarget = whats_at( p + attack_left)
+				if ptarget and different_colors(white, ptarget)
+					possible << ( p + attack_left)
+				end
+			end
+			unless p % 8 == 7 # we're in the h file
+				ptarget = whats_at( p + attack_right)
+				if ptarget and different_colors(white, ptarget)
+					possible << ( p + attack_right)
+				end
+			end
+			#check en-passat
+			if @bitboards[ENPASSANT] != 0 
+				passant = bits_to_positions( @bitboards[ENPASSANT]).first 
+				if (p + attack_right) == passant or (p + attack_left) == passant
+					possible << passant
+				end
+			end
+			possible.collect {|i| [p, *i]}
+		end
+		moves = []
+		bits_to_positions(pawns).each do |p|
+			moves += do_pawn.call(p)
+		end
+		moves
+	end
+end

data/lib/rubyknight.rb

@@ -0,0 +1,337 @@
+module RubyKnight
+	class IllegalMoveException < RuntimeError
+	end
+	
+	class Board
+		attr_reader :history, :WHITE, :BLACK, :to_play
+		
+		WHITE, BLACK = 0, 1
+		QUEENSIDE, KINGSIDE = 0, 1
+		WPAWN, WROOK, WBISHOP, WKNIGHT, WQUEEN, WKING = 0,1,2,3,4,5
+		BPAWN, BROOK, BBISHOP, BKNIGHT, BQUEEN, BKING = 6,7,8,9,10,11
+		WALL, BALL = 12, 13
+		ENPASSANT = 14
+		LAST_BOARD = CAN_CASTLE = 15
+
+		SYMBOLS = [ 'P','R','B','N','Q','K',
+		            'p','r','b','n','q','k']
+
+
+		def initialize
+			setup_start
+		end
+
+		def white_to_play?
+			@to_play == WHITE	
+		end
+
+		def dump
+			@bitboards[@bitboards.size] = @history
+			@bitboards[@bitboards.size] = @to_play
+			ret = Marshal.dump(@bitboards)
+			@bitboards.delete_at(@bitboards.size-1)
+			@bitboards.delete_at(@bitboards.size-1)
+			ret
+		end
+
+		def load dmp
+			@bitboards = Marshal.load( dmp)
+			@to_play = @bitboards.pop
+			@history = @bitboards.pop
+		end
+
+		def _undo
+			evt = @history.pop
+			return unless evt
+			place_piece evt.piece, evt.orig
+
+			if evt.promotion then unplace_piece evt.promotion, evt.dest
+			else unplace_piece evt.piece, evt.dest end
+
+			if evt.capture then place_piece evt.capture, evt.dest end
+
+			if last = @history.last
+				mark_enpassant last.piece, last.orig, last.dest
+			else
+				mark_enpassant nil,  nil, nil
+			end
+
+			# handle castling
+			@bitboards[CAN_CASTLE] = evt.can_castle
+			# are we castling?
+			if (evt.piece == WKING or evt.piece == BKING) and
+			   (evt.dest - evt.orig).abs == 2
+				# yes, we are
+				case evt.dest
+					when 62
+						move_piece WROOK, 61, 63	
+					when 58
+						move_piece WROOK, 59, 56	
+					when 2
+						move_piece BROOK, 3, 0	
+					when 6
+						move_piece BROOK, 5, 7
+				end
+			end
+
+			@to_play = if @to_play==WHITE then BLACK
+			           else WHITE end
+		end
+
+		def undo num = 1
+			num.times { _undo}
+		end
+
+		def setup_start
+			@to_play = WHITE
+			@bitboards = Array.new LAST_BOARD+1, 0
+			@bitboards[CAN_CASTLE] = 0x000F # 1111
+
+			@history = History.new
+			
+			place_piece WPAWN, *(48..55).to_a
+			place_piece WROOK, 56, 63
+			place_piece WKNIGHT, 57, 62
+			place_piece WBISHOP, 58, 61
+			place_piece WQUEEN, 59
+			place_piece WKING, 60
+
+			place_piece BPAWN, *(8..15).to_a
+			place_piece BROOK, 0, 7
+			place_piece BKNIGHT, 1, 6
+			place_piece BBISHOP, 2, 5
+			place_piece BQUEEN, 3
+			place_piece BKING, 4
+
+		end
+
+		def Board.coord_to_position coord
+			a, zero = 'a0'.unpack('cc')
+
+			file = coord[0]
+			rank = coord[1]
+
+			pos = ((8 - (rank.to_i - zero)) * 8) +\
+			      (file - a)
+
+		end
+
+		def Board.position_to_coord position
+			file = position % 8
+			rank = (8 - (position - file) / 8)
+			"#{(file + 97).chr}#{rank}"
+		end
+
+		def cnotation_move cnot
+			start, dest, promotion = cnotation_to_bits cnot
+			raise IllegalMoveException, "Unreadable move" unless start
+			move start, dest, promotion
+		end
+
+		def cnotation_to_bits cnot
+			if cnot =~ /([a-h][1-8])([a-h][1-8])([qrbnkp]{0,1})/
+				unless $3 == "" 
+					promotion = if @to_play = WHITE then 0
+					            else 6 end
+					promotion += 
+						case $3
+							when 'q' then WQUEEN
+							when 'p' then WPAWN
+							when 'r' then WROOK
+							when 'b' then WBISHOP
+							when 'n' then WKNIGHT
+							else
+								return false
+						end
+				else promotion = false end
+				[ Board.coord_to_position( $1), Board.coord_to_position( $2),
+				  promotion]		
+			else
+				false
+			end
+		end
+
+		def whats_at position
+			positionbit = (1 << position)
+			if @bitboards[WALL] & positionbit > 0
+				range = WPAWN..WKING
+			elsif @bitboards[BALL] & positionbit > 0
+				range = BPAWN..BKING
+			else 
+				return false
+			end
+
+			somethingthere = false
+			range.each do |piece|		
+				if (@bitboards[piece] & positionbit) > 0
+					somethingthere = piece
+					break 
+				end
+			end
+			somethingthere
+		end
+
+		def	to_s
+			out = ""
+			(0..63).each do |position|
+				somethingthere = whats_at position
+				if somethingthere then out << SYMBOLS[somethingthere]
+				else out << '.' end
+				out << "\n" if (position+1) % 8 == 0
+			end
+			out
+		end
+
+		def all_board_for piece
+			12 + (is_white(piece) ? 0 : 1)
+		end
+
+		def place_piece piece, *positions
+			positions.each do |position|
+				position = (1 << position)
+				@bitboards[piece] |= position
+				@bitboards[all_board_for(piece)] |= position
+			end
+		end
+
+		def unplace_piece piece, *positions
+			positions.each do |position|
+				position = ~(1 << position)
+				@bitboards[piece] &= position
+				@bitboards[all_board_for(piece)] &= position
+			end
+		end
+
+		def move_piece piece, orig, dest
+			unplace_piece piece, orig	
+			place_piece piece, dest
+		end
+
+		def is_white piece
+			piece <= WKING
+		end
+
+		def move orig, dest, promotion=nil, verify_legality = true
+			piece = whats_at(orig)
+
+			# Check Legality
+			 # Your piece?
+			unless piece and 
+				   ((is_white(piece) and @to_play == WHITE) or
+				    (!is_white(piece) and @to_play == BLACK))
+				raise IllegalMoveException, "Not your piece"
+			end
+
+			if verify_legality
+				legal_moves = gen_legal_moves
+				unless legal_moves.include? [orig, dest] or
+			       	   legal_moves.include? [orig, dest, promotion]
+					raise IllegalMoveException, "Invalid move"
+				end
+			end
+			
+			captured = whats_at(dest)
+			unplace_piece captured, dest if captured
+			move_piece piece, orig, dest
+
+			# handle castling
+			# are we castling?
+			if (piece == WKING or piece == BKING) and
+			   (dest - orig).abs == 2
+				# yes, we are
+				case dest
+					when 62
+						move_piece WROOK, 63, 61	
+					when 58
+						move_piece WROOK, 56, 59	
+					when 2
+						move_piece BROOK, 0, 3	
+					when 6
+						move_piece BROOK, 7, 5
+				end
+			end
+
+
+			# mark no-longer-possible castles
+			can_castle_was = @bitboards[CAN_CASTLE]
+			if piece == WKING 
+				@bitboards[CAN_CASTLE] &= ~(1|2)
+			elsif piece == WROOK and orig == 56
+				@bitboards[CAN_CASTLE] &= ~(1)
+			elsif piece == WROOK and orig == 63
+				@bitboards[CAN_CASTLE] &= ~(2)
+			elsif piece == BKING
+				@bitboards[CAN_CASTLE] &= ~(4|8)
+			elsif piece == BROOK and orig == 0
+				@bitboards[CAN_CASTLE] &= ~(4)
+			elsif piece == BROOK and orig == 7
+				@bitboards[CAN_CASTLE] &= ~(8)
+			end
+
+			if promotion
+				unplace_piece piece, dest	
+				place_piece promotion, dest
+			end	
+
+			mark_enpassant piece, orig, dest
+
+			@history << Event.new(piece, orig, dest, captured, 
+			                      promotion, can_castle_was)
+			@to_play = if @to_play==WHITE then BLACK
+			           else WHITE end
+		end
+
+		def mark_enpassant last_piece, last_orig, last_dest
+			if last_piece == WPAWN and last_orig > 47 and last_orig < 56 and
+				@bitboards[ENPASSANT] = ( 1 << last_orig+8)
+			elsif last_piece == BPAWN and last_orig > 7 and last_orig < 16 and
+				@bitboards[ENPASSANT] = ( 1 << last_orig+8)
+			else
+				@bitboards[ENPASSANT] = 0
+			end
+		end
+
+		def bits_to_positions bits
+			(0..63).select {|i| 1<<i & bits !=0}
+		end
+
+		def piece_positions piece
+			bits_to_positions(@bitboards[piece])
+		end
+
+		def num_pieces piece
+			bits_to_positions(@bitboards[piece]).size
+		end
+
+		def can_castle color, side
+			@bitboards[CAN_CASTLE] & (1 << ((color * 2)+side)) > 0
+		end
+	
+		class History < Array
+		end
+
+		class Event
+			attr_reader :piece, :orig, :dest, :capture, :promotion, :can_castle
+			def initialize piece, orig, dest, capture, 
+		 	               promotion=false, can_castle=0
+				@piece = piece
+				@orig = orig
+				@dest = dest
+				@capture = capture
+				@promotion = promotion
+				@can_castle = can_castle
+			end
+
+			def to_s
+				Board.position_to_coord(@orig) +\
+					Board.position_to_coord(@dest) +\
+					(@promotion ? Board.SYMBOLS[@promotion] : "")
+
+			end
+		end
+		
+	end
+end
+
+require "rubyknight/generator"
+require "rubyknight/evaluator"

data/profile-gen.rb

@@ -0,0 +1,8 @@
+require 'profile'
+
+load './board.rb'
+load "./#{ARGV[0]}"
+
+b = RubyKnight::Board.new
+
+b.gen_legal_moves

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: rubyknight
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Chris Moyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-02 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Naive chess library and engine written in ruby.  Includes rubyknight and rubyknight-xboard executables
+email: chris@inarow.net
+executables: 
+- rubyknight
+- rubyknight-xboard
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- TODO
+- VERSION
+- bin/rubyknight
+- bin/rubyknight-xboard
+- doc/reference_sites.txt
+- lib/rubyknight.rb
+- lib/rubyknight/evaluator.rb
+- lib/rubyknight/generator.rb
+- profile-gen.rb
+has_rdoc: true
+homepage: http://github.com/cdmoyer/RubyKnight
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Naive chess library and engine written in ruby
+test_files: []
+