checkers/checkers.rb

#!/usr/bin/ruby

EMPTY = 0
TEAM_1 = 1
TEAM_2 = 2
TEAM_1_MAN = ' w '
TEAM_1_KING = ' W '
TEAM_2_MAN = ' b '
TEAM_2_KING = ' B '
BOARD_EMPTY = ' _ '
BOARD_SIZE = 8

class Board
	attr :stats, true

	def initialize()
		@board = Array.new(BOARD_SIZE) {|i| Array.new(BOARD_SIZE, BOARD_EMPTY)}
		@stats = {TEAM_1 => {}, TEAM_2 => {}}
	end

	def setup()
		0.step(BOARD_SIZE) {|i|
		       	peice = (i < 3 ? TEAM_1_MAN : TEAM_2_MAN)	
			if [0,2,6].include? i
				start = 1
			elsif [1,5,7].include? i
				start = 0
			else
				next
			end
			start.step(BOARD_SIZE-1,2) {|j|
				@board[i][j] = peice
			}
		}
		@stats[TEAM_1]['count'] = 12
		@stats[TEAM_2]['count'] = 12
	end

	def set(x, y, thing)
		@board[y][x] = thing
	end

	def get(x, y)
		@board[y][x]
	end

	def to_s()
		str = '  '
		0.step(BOARD_SIZE-1) {|i|
			str += ' ' + i.to_s + ' '
		}
		str += "\n"
		i = 0;
		@board.each {|row|
			str += ('A'.ord + i).chr + ' '
			i += 1
			row.each {|cell| 
				str += cell
			} 
			str += "\n"
		}
		str += 'TEAM_1: ' + @stats[TEAM_1]['count'].to_s + ' -- TEAM_2: ' + @stats[TEAM_2]['count'].to_s  + "\n" 
		return str
	end

	def piece_team(piece)
		if piece == TEAM_1_MAN or piece == TEAM_1_KING
			return TEAM_1
		elsif piece == TEAM_2_MAN or piece == TEAM_2_KING
			return TEAM_2
		else
			return EMPTY
		end
	end

	def empty?(x, y)
		return @board[y][x] == BOARD_EMPTY
	end

	def valid_coords(x, y)
		return (x >= 0 and x < BOARD_SIZE and y >= 0 and y < BOARD_SIZE)
	end

	def gen_moves(x, y, x_mod, y_mod)
		moves = []
		for xm in x_mod
			new_x = x + xm
			for ym in y_mod
				new_y = y + ym
				if valid_coords(new_x, new_y) and empty?(new_x, new_y)
					moves += [[new_x, new_y]]
				end
			end
		end
		return moves
	end

	# function to chart path of jumps
	# merging them together
	# only returns full paths
	#
	# base case: no jumps avail, return path
	# jumps avail: do all and merge and return
	def gen_jumps(path, x, y, team, x_mod, y_mod)
		jumps = []
		for xm in x_mod
			new_x = x + xm
			for ym in y_mod
				new_y = y + ym
				if valid_coords(new_x, new_y) and piece?(new_x, new_y) and team != team(new_x, new_y)
					final_x = new_x + xm
					final_y = new_y + ym
					if (valid_coords(final_x, final_y) and empty?(final_x, final_y))
						jumps += gen_jumps(path + [[final_x, final_y]], final_x, final_y, team, x_mod, y_mod)
					end
				end
			end
		end

		if jumps == []
			if path == []
				return []
			else 
				return [path]
			end
		else
			return jumps
		end
	end

	def piece?(x, y)
		return !empty?(x, y)
	end

	def team(x, y)
		if piece?(x, y)
			if @board[y][x] == TEAM_1_MAN or @board[y][x] == TEAM_1_KING
				return TEAM_1
			else
				return TEAM_2
			end
		end
		return EMPTY
	end

	def opposite_team(team)
		return (team == TEAM_1 ? TEAM_2 : TEAM_1)
	end

	def man?(x, y)
		return (@board[y][x] == TEAM_1_MAN or @board[y][x] == TEAM_2_MAN)
	end
	
	def king?(x, y)
		return (@board[y][x] == TEAM_1_KING or @board[y][x] == TEAM_2_KING)
	end

	def piece_valid_moves(x, y, team)
		moves = []
		if piece_team(@board[y][x]) == team
			direction = [1]
			if king?(x, y)
				direction = [-1, 1]
			elsif team == TEAM_2 
				direction = [-1]
			end

			moves = gen_moves(x, y, [-1,1], direction)
			moves += gen_jumps([], x, y, team, [-1, 1], direction)
		end
		return moves
	end

	def dup() 
		b = Board.new
		for x in 0..(BOARD_SIZE-1)
			for y in 0..(BOARD_SIZE-1)
				b.set(x, y, get(x, y))
			end
		end
		b.stats[TEAM_1] = @stats[TEAM_1].dup
		b.stats[TEAM_2] = @stats[TEAM_2].dup
		return b
	end

	def between(c1, c2)
		return [ c2[0] + (c1[0]-c2[0])/2, c2[1] + (c1[1]-c2[1])/2 ]
	end

	def move_piece(c1, c2)
		piece = get(c1[0], c1[1])
		set(c1[0], c1[1], BOARD_EMPTY)
		set(c2[0], c2[1], piece)
		if team(c2[0], c2[1]) == TEAM_1 and c2[1] == BOARD_SIZE-1
			set(c2[0], c2[1], TEAM_1_KING)
		elsif (team(c2[0], c2[1]) == TEAM_2 and c2[1] == 0)
			set(c2[0], c2[1], TEAM_2_KING)
		end
	end


	# doesnt validate
	def do_move(x, y, move, team)
		if move[0].is_a?(Array)
			# jump
			move.each { |jump|
				enemy = between([x,y], jump)
				set(enemy[0], enemy[1], BOARD_EMPTY)
				@stats[opposite_team(team)]['count'] -= 1
				move_piece([x,y], jump)
			}
		else
			# move
			move_piece([x,y], move) 
		end
	end	


	def gen_next_move_boards(team)
		boards = []
		for x in 0..(BOARD_SIZE-1)
			for y in 0..(BOARD_SIZE-1)
				if piece?(x, y) and team(x,y) == team
					moves = piece_valid_moves(x, y, team(x, y))
					moves.each { |move|
						board = dup()
						board.do_move(x, y, move, team(x, y))
						boards.push(board)
					}
				end
			end
		end
		return boards
	end

	def search(team)
		@top_depth = 100
		search_do(team, @top_depth)
	end

	def search_do(team, depth, percent)
		if depth == 0
			puts "DONE"
			return {TEAM_1 => @stats[TEAM_1]['count'], TEAM_2 => @stats[TEAM_2]['count']}
		end

		max = @stats[team]['count']
		min = 0

		if team == TEAM_1
			puts depth.to_s + ": TEAM_1's turn:"
		else
			puts depth.to_s + ": TEAM_2's turn:"
		end
		puts to_s #moves[0].to_s
		if @stats[TEAM_1]['count'] == 0
			puts "TEAM_2 WON!"
		elsif @stats[TEAM_2]['count'] == 0
			puts "TEAM_1 WON!"
		else
			moves = gen_next_move_boards(team)
			if moves == []
				puts "NO MOVES AVAILABLE?"
			else
				item_percent = percent/moves.length
        results = moves[0].search_do(opposite_team(team), depth -1, item_percent)
        if item_percent >= 0.1
          # UM WE NEED PERCENT SO FAR
        end
				if results[opposite_team(team)] == 0
					return {team => max, opposite_team(team) => 0}
				elsif results[team] == max
					return {team => max, opposite_team(team) => results[opposite_team(team)]}
				else
					if results[team] > min
						min = results[team]
					end
				end
			end
		end
	end
end