shurikenengine 0.31

data/lib/shuriken/eval_caparandom.rb

@@ -0,0 +1,110 @@
+##
+# Shuriken, a Ruby chess variant engine
+# Author: Toni Helminen
+# License: GPLv3
+##
+
+module Shuriken
+
+module EvalCaparandom
+	MATERIAL_SCORE = {
+		1 => 1,
+		2 => 3,
+		3 => 3,
+		4 => 5,
+		5 => 9,
+		6 => 6,
+		7 => 8,
+		8 => 8
+	}
+	
+	CENTRAL_BONUS_X = [1,2,3,4,5,5,4,3,2,1].freeze
+	CENTRAL_BONUS_Y = [1,2,3,4,4,3,2,1].freeze
+	
+	CENTRAL_SCORE = {
+		1 => 0.5,
+		2 => 5,
+		3 => 5,
+		4 => 3,
+		5 => 2,
+		6 => 0.2,
+		7 => 3,
+		8 => 3
+	}
+	
+	EVAL_PST_MG = []
+
+	def EvalCaparandom.init
+		return if EVAL_PST_MG.length > 0
+		7.times do |i|
+			arr = []
+			79.times do |j|
+				score = 0.1 * (MATERIAL_SCORE[i + 1] + 2 * CENTRAL_SCORE[i + 1] * (CENTRAL_BONUS_X[j % 10 ] + CENTRAL_BONUS_Y[j / 10]))
+				arr.push(score)
+			end
+			EVAL_PST_MG.push(arr)
+		end
+		EVAL_PST_MG.freeze
+	end
+	
+	def EvalCaparandom.eval(board)
+		score = 0
+		board.brd.each_with_index do |p, i|
+			score += case p
+				when 1 then
+					EVAL_PST_MG[0][i]
+				when 2 then
+					EVAL_PST_MG[1][i]
+				when 3 then
+					EVAL_PST_MG[2][i]
+				when 4 then
+					EVAL_PST_MG[3][i]
+				when 5 then
+					EVAL_PST_MG[4][i]
+				when 6 then
+					EVAL_PST_MG[5][i]
+				when 7 then
+					EVAL_PST_MG[6][i]
+				when 8 then
+					EVAL_PST_MG[7][i]
+				when -1 then
+					-EVAL_PST_MG[0][board.flip_coord(i)]
+				when -2 then
+					-EVAL_PST_MG[1][board.flip_coord(i)]
+				when -3 then
+					-EVAL_PST_MG[2][board.flip_coord(i)]
+				when -4 then
+					-EVAL_PST_MG[3][board.flip_coord(i)]
+				when -5 then
+					-EVAL_PST_MG[4][board.flip_coord(i)]
+				when -6 then
+					-EVAL_PST_MG[5][board.flip_coord(i)]
+				when -7 then
+					-EVAL_PST_MG[6][board.flip_coord(i)]
+				when -8 then
+					-EVAL_PST_MG[7][board.flip_coord(i)]
+				else
+					0
+				end
+		end
+		#score += 0.05 * rand()
+		0.01 * score
+	end
+	
+	def EvalCaparandom.material(board)
+		score = 0
+		board.brd.each do |p|
+			score += case p
+				when 1..8 then
+					MATERIAL_SCORE[p]
+				when -8..-1 then
+					-MATERIAL_SCORE[-p]
+				else
+					0
+				end
+		end
+		score
+	end
+end # module EvalCaparandom
+
+end # module Shuriken

data/lib/shuriken/falcon_moves.rb

@@ -0,0 +1,40 @@
+##
+# Shuriken, a Ruby chess variant engine
+# Author: Toni Helminen
+# License: GPLv3
+##
+
+module Shuriken
+
+module FalconMoves
+	MOVES = []
+	
+	def FalconMoves.init
+		return if MOVES.length > 0
+		[
+			[[1,  0], [1,  1]],
+			[[1,  0], [1,  -1]],
+			[[-1, 0], [-1, 1]],
+			[[-1, 0], [-1, -1]],
+			[[0,  1], [1,  1]],
+			[[0,  1], [-1, 1]],
+			[[0, -1], [-1, -1]],
+			[[0, -1], [1, -1]]
+		].each do | o |
+			s, d = o[0], o[1]
+			# ssd,dss,sds,dsd,dds,sdd
+			MOVES.push(s + s + d)
+			MOVES.push(d + d + s)
+			MOVES.push(d + s + s)
+			MOVES.push(s + d + d)
+			MOVES.push(s + d + s)
+			MOVES.push(d + s + d)
+		end
+		MOVES.freeze
+		if false
+			MOVES.each { | q | puts ">> #{q}" }
+		end
+	end
+end # module FalconMoves
+
+end # module Shuriken

data/lib/shuriken/fen.rb

@@ -0,0 +1,52 @@
+##
+# Shuriken, a Ruby chess variant engine
+# Author: Toni Helminen
+# License: GPLv3
+##
+
+module Shuriken
+
+module Fen
+	# RR NN BB Q C K A
+	def Fen.make_caparandom_pos
+		s = "." * 10
+		put_piece = -> { i = rand(10); i = rand(10) while s[i] != "."; i }
+
+		king = rand(1..8)
+		l_rook = rand(king)
+		r_rook = king + 1 + rand([1, 9 - (king + 1)].max)
+		s[king] = "k"
+		s[l_rook] = "r"
+		s[r_rook] = "r"
+		
+		fail if r_rook == king || l_rook == king
+		#puts "> #{king}> #{l_rook}> #{r_rook}"
+		
+		wb = put_piece.()
+		s[wb] = "b"
+		
+		bb = rand(10)
+		while s[bb] != "." || bb % 2 == wb % 2 
+			bb = rand(10) 
+		end
+		s[bb] = "b"
+
+		%|acnnq|.each_char { |p| s[put_piece.()] = p }
+
+		pieces = s
+		
+		s += "/" + "p" * 10
+		s << "/10" * 4
+		s << "/" + "P" * 10
+		s << "/" + pieces.upcase
+		s << " w "
+		s << ("A".ord + r_rook).chr
+		s << ("A".ord + l_rook).chr
+		s << ("a".ord + r_rook).chr
+		s << ("a".ord + l_rook).chr
+		s << " - 0"
+		s
+	end
+end # module Fen
+
+end # module Shuriken<

data/lib/shuriken/history.rb

@@ -0,0 +1,60 @@
+##
+# Shuriken, a Ruby chess variant engine
+# Author: Toni Helminen
+# License: GPLv3
+##
+
+module Shuriken
+
+class History
+	def initialize
+		reset
+	end
+
+	def reset
+		@data = []
+		@pos = -1
+	end
+	
+	def debug
+		puts "@pos: #{@pos} .. @data: #{@data.length}"
+	end
+	
+	def remove
+		if @pos > 1
+			board = @data[@pos - 2]
+			@pos -= 2
+			return board
+		end
+		@data.last
+	end
+
+	def undo
+		if @pos > 0
+			board = @data[@pos - 1]
+			@pos -= 1
+			return board
+		end
+		@data.last
+	end
+	
+	def add(board)
+		@data.push(board)
+		@pos += 1
+	end
+	
+	def is_draw?(board, repsn = 2)
+		len, hash = @data.length, board.hash
+		i, n, reps = len - 1, 0, 0
+		return true if board.r50 >= 99
+		while i > 0
+			break if n >= 100 
+			reps += 1 if hash == @data[i].hash
+			n, i = n + 1, i - 1
+			return true if reps >= repsn
+		end
+		false
+	end
+end # class History
+
+end # module Shuriken

data/lib/shuriken/mgen_caparandom.rb

@@ -0,0 +1,181 @@
+##
+# Shuriken, a Ruby chess variant engine
+# Author: Toni Helminen
+# License: GPLv3
+##
+
+module Shuriken
+
+class MgenCaparandom
+	ROOK_MOVES = [[1, 0], [0, 1], [-1, 0], [0, -1]].freeze
+	BISHOP_MOVES = [[1, 1], [-1, 1], [1, -1], [-1, -1]].freeze
+	KING_MOVES = (ROOK_MOVES + BISHOP_MOVES).freeze
+	KNIGHT_MOVES = [[1, 2], [-1, 2], [1, -2], [-1, -2], [2, 1], [-2, 1], [2, -1], [-2, -1]].freeze
+
+	MOVE_TYPE_CASTLING = 1
+	MOVE_TYPE_PROMO = 2
+	MOVE_TYPE_EP = 5
+
+	attr_accessor :pseudo_moves, :only_captures
+	
+	def initialize(board)
+		@board, @moves = board, []
+		@x_gen, @y_gen, @from_gen = 0, 0, 0 # move generation
+		@x_checks, @y_checks = 0, 0 # checks
+		@pseudo_moves = false # 3x speed up
+		@only_captures = false # generate only captures
+		@promotion_to = @board.variant == "falcon" ? [2, 3, 4, 5, 9] : [2, 3, 4, 5, 7, 8]
+		@promotion_to.freeze
+	end
+
+	##
+	# Utils
+	##
+	
+	def print_move_list
+		i = 0
+		@moves.each do |board|
+			i += 1
+			puts "#{i}: #{board.move_str}"
+		end
+	end
+	
+	def is_on_board?(x, y)	
+		(x >= 0 && x <= 9 && y >= 0 && y <= 7) ? true : false
+	end
+	
+	def good_coord?(i)
+		(i >= 0 && i <= 79) ? true : false
+	end
+
+	def y_coord(n)
+		n / 10
+	end
+	
+	def x_coord(n)
+		n % 10 
+	end
+
+	##
+	# Checks
+	##
+	
+	def pawn_checks_w?(here)
+		[-1, 1].each do |dir|
+			px, py = @x_checks + dir, @y_checks + 1
+			return true if is_on_board?(px, py) && px + py * 10 == here
+		end
+		false
+	end
+	
+	def pawn_checks_b?(here)
+		[-1, 1].each do |dir|
+			px, py = @x_checks + dir, @y_checks - 1
+			return true if is_on_board?(px, py) && px + py * 10 == here
+		end
+		false
+	end
+
+	def slider_checks_to?(slider, here)
+		slider.each do |jmp|
+			px, py = @x_checks, @y_checks
+			while true do
+				px, py = px + jmp[0], py + jmp[1]
+				to = px + py * 10
+				break if ! is_on_board?(px, py)
+				return true if to == here
+				break if ! @board.empty?(to)
+			end
+		end
+		false
+	end
+	
+	def jump_checks_to?(jumps, here)
+		jumps.each do |jmp|
+			px, py = @x_checks + jmp[0], @y_checks + jmp[1]
+			to = px + py * 10
+			return true if is_on_board?(px, py) && to == here
+		end
+		false
+	end
+	
+	def any_black_checks_here?(no_checks)
+		no_checks.each { |square| return true if checks_b?(square) }
+		false
+	end
+	
+	def any_white_checks_here?(no_checks)
+		no_checks.each { |square| return true if checks_w?(square) }
+		false
+	end
+	
+	def falcon_checks?(here)
+		Shuriken::FalconMoves::MOVES.each do |mv|
+			px1, py1 = @x_checks + mv[0], @y_checks + mv[1]
+			to1 = px1 + 10 * py1
+			px2, py2 = px1 + mv[2], py1 + mv[3]
+			to2 = px2 + 10 * py2
+			px3, py3 = px2 + mv[4], py2 + mv[5]
+			to3 = px3 + 10 * py3
+			return true if (is_on_board?(px1, py1) && @board.empty?(to1) && is_on_board?(px2, py2) && @board.empty?(to2) \
+					&& is_on_board?(px3, py3) && to3 == here)
+		end
+		false
+	end
+
+	def checks_w?(here)
+		80.times do |i|
+			@x_checks, @y_checks = x_coord(i), y_coord(i)
+			case @board.brd[i]
+			when 1
+				return true if pawn_checks_w?(here)
+			when 2
+				return true if jump_checks_to?(KNIGHT_MOVES, here)
+			when 3
+				return true if slider_checks_to?(BISHOP_MOVES, here)
+			when 4
+				return true if slider_checks_to?(ROOK_MOVES, here)
+			when 5
+				return true if slider_checks_to?(ROOK_MOVES + BISHOP_MOVES, here)
+			when 6
+				return true if jump_checks_to?(KING_MOVES, here)
+			when 7
+				return true if jump_checks_to?(KNIGHT_MOVES, here) || slider_checks_to?(BISHOP_MOVES, here)
+			when 8
+				return true if jump_checks_to?(KNIGHT_MOVES, here) || slider_checks_to?(ROOK_MOVES, here)
+			when 9
+				return true if falcon_checks?(here)
+			end
+		end
+		false
+	end
+
+	def checks_b?(here)
+		80.times do | i |
+			@x_checks, @y_checks = x_coord(i), y_coord(i)
+			case @board.brd[i]
+			when -1
+				return true if pawn_checks_b?(here)
+			when -2
+				return true if jump_checks_to?(KNIGHT_MOVES, here)
+			when -3
+				return true if slider_checks_to?(BISHOP_MOVES, here)
+			when -4
+				return true if slider_checks_to?(ROOK_MOVES, here)
+			when -5
+				return true if slider_checks_to?(ROOK_MOVES + BISHOP_MOVES, here)
+			when -6
+				return true if jump_checks_to?(KING_MOVES, here)
+			when -7
+				return true if jump_checks_to?(KNIGHT_MOVES, here) || slider_checks_to?(BISHOP_MOVES, here)
+			when -8
+				return true if jump_checks_to?(KNIGHT_MOVES, here) || slider_checks_to?(ROOK_MOVES, here)
+			when -9
+				return true if falcon_checks?(here)
+			end
+		end
+		false
+	end
+end # class MgenCaparandom
+
+end # module Shuriken