RubyShogi 0.1

data/lib/ruby_shogi/cmd.rb

@@ -0,0 +1,188 @@
+##
+# RubyShogi, a Shogi Engine
+# Author: Toni Helminen
+# License: GPLv3
+##
+
+module RubyShogi
+
+class Cmd
+	attr_accessor :engine, :random_mode
+
+	def initialize
+		@random_mode = false
+		@tokens = RubyShogi::Tokens.new(ARGV)
+		@fen = nil
+	end
+	
+	def name
+		puts "#{RubyShogi::NAME} v#{RubyShogi::VERSION} by #{RubyShogi::AUTHOR}"
+	end
+	
+	def randommode
+		@random_mode = true
+	end
+	
+	def peek_argint(defval)
+		val = @tokens.peek(1)
+		if val != nil && val.match(/\d+/)
+			@tokens.forward
+			defval = @tokens.cur.to_i
+		end
+		defval
+	end
+		
+	def mbench
+		suite(peek_argint(4))
+	end
+	
+	def perft
+		p = RubyShogi::Perft.new(@fen)
+		p.perft(peek_argint(5))
+	end
+	
+	def randperft
+		n = peek_argint(3)
+		n.times do |i|
+			p = RubyShogi::Perft.new
+			puts "#{i} / ..."
+			p.randperft(2)
+		end
+	end
+	
+	def suite
+		p = RubyShogi::Perft.new
+		p.suite(peek_argint(5))
+	end
+	
+	def bench
+		e = RubyShogi::Engine.new(random_mode: @random_mode)
+		e.bench
+	end
+	
+	def stats
+		n, val = 100, @tokens.peek(1)
+		if val != nil && val.match(/\d+/)
+			@tokens.forward
+			n = val.to_i
+		end
+		e = RubyShogi::Engine.new("falcon", random_mode: @random_mode)
+		e.board.use_fen(@fen) if @fen != nil
+		e.stats(n)
+	end
+	
+	def tactics
+		RubyShogi::Tactics.run
+	end
+	
+	def fen
+		@tokens.go_next
+		@fen = @tokens.cur
+	end
+	
+	def list
+		board = RubyShogi::Board.new
+		board.fen(@fen)
+		mgen = board.mgen_generator
+		moves = mgen.generate_moves
+		moves.each_with_index { |b, i| puts "> #{i}: #{b.move_str}" }
+	end
+
+	def test
+		b = RubyShogi::Board.new
+		#b.startpos
+		#b.fen("lnsgkgsnl/2r4b1/ppppp+Pp1p/7p1/9/9/PPPPP1PPP/1B5R1/LNSGKGSNL[P] w 1 5")
+		#b.fen("9/3k5/7+P1/8P/9/9/6P2/R3K4/1NSG1GSNL[PPPPPPPPPNNBRLLSSGGppppppbl] w 19 100")
+		#      +P8/9/8L/L3k3R/1KP6/9/3s5/2S6/1+n1g4+B[PPPPPPPPPNBRLLSGpppppppnnsgg] b
+		#		b.fen("5K3/2+P6/6+P2/9/4k4/9/9/9/9[PPPPPPPPPNNBRLLSSGGpppppppnnbrllssgg] w 67 185")
+		#b.fen("8+r/5K3/9/9/9/9/k8/9/9[-] w 24 1")
+		b.fen("2+P+P+P4/8P/3k3+P1/1+b2P1p2/3p2Pp1/2p5l/+p3+p3p/1p+l+p5/+p4K2+p[NNRSSGGnnbrllssgg] b 1 ")
+		b.print_board
+		mgen = b.mgen_generator
+		mgen.generate_moves
+		mgen.print_move_list
+	end
+	
+	def print_numbers
+		s = ""
+		9.times do |y|
+			9.times do |x|
+				i = (8 - y) * 9 + x
+				s << "#{i}"
+				s << (i < 10 ? "  " : " ")
+			end
+			s << "\n"
+		end
+		puts "~~~ Table Numbers ~~~"
+		puts s
+	end
+	
+	def rubybench
+		RubyShogi::Bench.go
+	end
+
+	def xboard
+		xboard = RubyShogi::Xboard.new(@random_mode)
+		xboard.go
+	end
+	
+	def profile
+		require 'ruby-prof'
+		result = RubyProf.profile do
+			e = RubyShogi::Engine.new(random_mode: @random_mode)
+			e.bench
+		end
+		printer = RubyProf::FlatPrinter.new(result)
+		printer.print(STDOUT)
+	end
+	
+	def help
+		puts "Usage: ruby shuriken_ruby.rb [OPTION]... [PARAMS]..."
+		puts "###"
+		puts "-help: This Help"
+		puts "-xboard: Enter Xboard Mode"
+		puts "-tactics: Run Tactics"
+		puts "-name: Print Name Tactics"
+		puts "-rubybench: Benchmark Ruby"
+		puts "-bench: Benchmark ShurikenShogi Engine"
+		puts "-mbench: Benchmark ShurikenShogi Movegen"
+		puts "-perft [NUM]: Run Perft"
+		puts "-profile: Profile ShurikenShogi"
+		puts "-randommode: Activate Random Mode"
+		puts "-fen [FEN]: Set Fen"
+		puts "-stats [NUM]: Statistical Analysis"
+		puts "-list: List Moves"
+		puts "-numbers: Board Numbers"
+	end
+
+	def args
+		help && return if ARGV.length < 1
+		while @tokens.ok?
+			case @tokens.cur
+			when "-xboard" then xboard and return # enter xboard mode
+			when "-rubybench" then rubybench
+			when "-bench" then bench
+			when "-mbench" then mbench
+			when "-stats" then stats
+			when "-variant" then variant
+			when "-randommode" then randommode
+			when "-tactics" then tactics
+			when "-test" then test
+			when "-name" then name
+			when "-fen" then fen
+			when "-profile" then profile
+			when "-perft" then perft
+			when "-randperft" then randperft
+			when "-suite" then suite
+			when "-numbers" then print_numbers
+			when "-help" then help
+			else
+				puts "RubyShogi Error: Unknown Command: '#{@tokens.cur}'"
+				return
+			end
+			@tokens.forward
+		end
+	end
+end # class Cmd
+
+end # module RubyShogi

data/lib/ruby_shogi/engine.rb

@@ -0,0 +1,276 @@
+##
+# RubyShogi, a Shogi Engine
+# Author: Toni Helminen
+# License: GPLv3
+##
+
+module RubyShogi
+
+class Engine
+	attr_accessor :board, :random_mode, :gameover, :move_now, :debug, :time, :movestogo, :printinfo
+
+	INF = 1000
+	MATERIAL_SCALE = 0.01
+	RESULT_DRAW      = 1
+	RESULT_BLACK_WIN = 2
+	RESULT_WHITE_WIN = 4
+	
+	def initialize(random_mode: false)
+		init_mate_bonus
+		@board = RubyShogi::Board.new
+		@random_mode = random_mode
+		@history = RubyShogi::History.new
+		@board.startpos
+		@printinfo = true
+		@time = 10 # seconds
+		@movestogo = 40
+		@stop_time = 0
+		@stop_search = false
+		@nodes = 0
+		@move_now = false
+		@debug = false
+		@gameover = false
+	end
+	
+	def init_mate_bonus
+		@mate_bonus = [1] * 100
+		(0..20).each { |i| @mate_bonus[i] += 20 - i }
+		@mate_bonus[0] = 50
+		@mate_bonus[1] = 40
+		@mate_bonus[2] = 30
+		@mate_bonus[3] = 25
+	end
+		
+	def history_reset
+		@history.reset
+	end
+		
+	def history_remove
+		@board = @history.remove
+	end
+	
+	def history_undo
+		@board = @history.undo
+	end
+				
+	def print_move_list(moves)
+		moves.each_with_index { |board, i| puts "#{i} / #{board.move_str} / #{board.score}" }
+	end
+	
+	def move_list
+		mgen = @board.mgen_generator
+		moves = mgen.generate_moves
+		moves.each_with_index { |board, i| puts "#{i} / #{board.move_str} / #{board.score}" }
+	end
+	
+	def make_move?(move)
+		mgen = @board.mgen_generator
+		moves = mgen.generate_moves
+		moves.each do |board|
+			if board.move_str == move
+				@history.add(board)
+				@board = board
+				return true
+			end
+		end
+		puts "illegal move: #{move}"
+		false
+	end
+	
+	def print_score(moves, depth, started)
+		return unless @printinfo
+		moves = moves.sort_by(&:score).reverse
+		best = moves[0]
+		n = (100 * (Time.now - started)).to_i
+		puts " #{depth}     #{(best.score).to_i}     #{n}     #{@nodes}     #{best.move_str}"
+	end
+	
+	def search_moves_w(cur, depth, total = 0)
+		@nodes += 1
+		@stop_search = Time.now > @stop_time || total > 90
+		return 0 if @stop_search
+		return MATERIAL_SCALE * cur.material if depth < 1
+		mgen = RubyShogi::MgenWhite.new(cur)
+		moves = mgen.generate_moves
+		if moves.length == 0 # assume mate
+			return mgen.checks_b? ? 0.1 * @mate_bonus[total] * -INF + rand : 1
+		end
+		search_moves_b(moves.sample, depth - 1, total + 1)
+	end
+	
+	def search_moves_b(cur, depth, total = 0)
+		@nodes += 1
+		@stop_search = Time.now > @stop_time || total > 90
+		return 0 if @stop_search
+		return MATERIAL_SCALE * cur.material if depth < 1
+		mgen = RubyShogi::MgenBlack.new(cur)
+		moves = mgen.generate_moves
+		if moves.length == 0 # assume mate
+			return mgen.checks_w? ? 0.1 * @mate_bonus[total] * INF + rand : 1
+		end 
+		search_moves_w(moves.sample, depth - 1, total + 1)
+	end
+	
+	def search(moves)
+		now = Time.now
+		time4print = 0.5
+		divv = @movestogo < 10 ? 20 : 30
+		@stop_time = now + (@time / divv)
+		depth = 2
+		while true
+			moves.each do |board|
+				puts "> #{@nodes} / #{board.move_str}" if  @debug 
+				next if board.nodetype == 2
+				depth = 3 + rand(20)
+				board.score += board.wtm ? search_moves_w(board, depth, 0) : search_moves_b(board, depth, 0)
+				if Time.now > @stop_time || @move_now
+					print_score(moves, depth, now)
+					return
+				end
+			end
+			if Time.now - now > time4print
+				now = Time.now
+				print_score(moves, depth, now)
+			end
+		end
+	end
+	
+	def draw_moves(moves)
+		moves.each do | board |
+			if @history.is_draw?(board)
+				board.nodetype, board.score = 2, 0
+			end
+		end
+	end
+	
+	def hash_moves(moves)
+		moves.each { |board| board.create_hash }
+	end
+	
+	def game_status(mgen, moves)
+		if moves.length == 0
+			if @board.wtm && mgen.checks_b?(@board.find_white_king)
+				return RubyShogi::Engine::RESULT_BLACK_WIN
+			elsif !@board.wtm && mgen.checks_w?(@board.find_black_king)
+				return RubyShogi::Engine::RESULT_WHITE_WIN
+			end
+			return RubyShogi::Engine::RESULT_DRAW
+		end
+		@board.create_hash
+		if @history.is_draw?(@board, 3) || @board.material_draw?
+			return RubyShogi::Engine::RESULT_DRAW
+		end
+		0
+	end
+	
+	def jishogi?
+		if @board.jishogi?
+			w = @board.count_jishogi_w
+			b = @board.count_jishogi_b
+			if w >= 24 && b < 24
+				puts "1-0 {White wins by Jishogi}"
+				return true
+			elsif w < 24 && b >= 24
+				puts "0-1 {Black wins by Jishogi}"
+				return true
+			else
+				puts "1/2-1/2 {Draw by Impasse}"
+				return true
+			end
+		end
+		false
+	end
+	
+	def is_gameover?(mgen, moves)
+		@board.create_hash
+		return true if jishogi?
+		if @board.fullmoves > 900
+			puts "1/2-1/2 {Draw by Max Moves}"
+			return true
+		end
+		if @history.is_draw?(@board, 3)
+			puts "1/2-1/2 {Draw by Sennichite}"
+			return true
+		end
+		if moves.length == 0
+			if @board.wtm && mgen.checks_b?(@board.find_white_king)
+				puts "0-1 {Black mates}"
+				return true
+			elsif !@board.wtm && mgen.checks_w?(@board.find_black_king)
+				puts "1-0 {White mates}"
+				return true
+			end
+		end
+		false
+	end
+
+	def bench
+		t = Time.now
+		@time = 500
+		think
+		diff = Time.now - t
+		puts "= #{@nodes} nodes | #{diff.round(3)} s | #{(@nodes/diff).to_i} nps"
+	end
+	
+	def think
+		@nodes = 0
+		@move_now = false
+		board = @board
+		mgen = @board.mgen_generator
+		moves = mgen.generate_moves
+		hash_moves(moves)
+		draw_moves(moves)
+		func = -> { board.wtm ? moves.sort_by(&:score).reverse : moves.sort_by(&:score) }
+		@gameover = is_gameover?(mgen, moves)
+		return if @gameover
+		if @random_mode
+			@board = moves.sample
+		else
+			search(moves)
+			moves = func.call
+			#print_move_list(moves)
+			@board = moves[0]
+		end
+		print_move_list(moves) if @debug
+		@history.add(@board)
+		@board.move_str
+	end
+	
+	def print_score_stats(results)
+		wscore = results[RubyShogi::Engine::RESULT_WHITE_WIN]
+		bscore = results[RubyShogi::Engine::RESULT_BLACK_WIN]
+		draws = results[RubyShogi::Engine::RESULT_DRAW]
+		total = wscore + bscore + draws
+		printf("[ Score: %i - %i - %i [%.2f] %i ]\n", wscore, bscore, draws, (wscore + 0.5 * draws) / total, total)
+	end
+	
+	def stats(rounds = 10)
+		@nodes = 0
+		@move_now = false
+		board = @board
+		results = [0] * 5
+		puts "Running stats ..."
+		rounds.times do |n| 
+			@board = board
+			@history.reset
+			while true
+				mgen = @board.mgen_generator
+				moves = mgen.generate_moves
+				hash_moves(moves)
+				draw_moves(moves)
+				status = game_status(mgen, moves)
+				@board = moves.sample
+				@history.add(@board)
+				if status != 0
+					results[status] += 1
+					break
+				end
+			end
+			print_score_stats(results) if (n + 1) % 2 == 0 && n + 1 < rounds
+		end
+		puts "="
+		print_score_stats(results)
+	end
+end # class Engine
+
+end # module RubyShogi