예제 #1
0
	def update(self, game_state):
		# relative
		bc = board_chunk(game_state)
		bc.gen_relative(game_state.this_move[0], game_state.this_move[1])

		if bc.has_corner():
			self.tables_corner.update(game_state, bc)
		elif bc.has_side():
			self.tables_side.update(game_state, bc)
		else:
			self.tables_open.update(game_state, bc)

		# absolute
		bc = board_chunk(game_state)
		bc.gen_absolute(game_state.this_move[0], game_state.this_move[1])

		if bc.has_corner():
			self.tables_corner.update(game_state, bc)
		elif bc.has_side():
			self.tables_side.update(game_state, bc)
		else:
			self.tables_open.update(game_state, bc)
예제 #2
0
	def get_best_move(self, game_state, color):
		# pass if the other player does
		if (
			game_state != None and
			game_state.last_move != None and
			game_state.last_move[-4:] == "PASS"
		):
			return color + ":PASS"

		# get the scores for each move
		best_move = False
		best_score = -100

		# check each absolute chunk (9 of them, each with 9 states) for the
		# whole board, and check the relative chunk for the last move to
		# decide where the next move should be
	
		# absolute chunks
		for i in xrange(0, game_state.size/game_state.chunk_size_absolute):
			for j in xrange(0,
				game_state.size/game_state.chunk_size_absolute
			):
				move_changed = False

				# get the chunk
				bc = board_chunk(game_state)
				bc.gen_absolute(
					i*game_state.chunk_size_absolute,
					j*game_state.chunk_size_absolute
				)

				# corner chunk
				if bc.has_corner():
					(lbest_move,lbest_score) = self.__get_chunk_best(
						game_state, color, bc, self.tables_corner
					)
					if lbest_score > best_score:
						best_move = lbest_move
						best_score = lbest_score
						move_changed = True
				# side chunk
				elif bc.has_side():
					(lbest_move,lbest_score) = self.__get_chunk_best(
						game_state, color, bc, self.tables_side
					)
					if lbest_score > best_score:
						best_move = lbest_move
						best_score = lbest_score
						move_changed = True
				# open chunk
				else:
					(lbest_move,lbest_score) = self.__get_chunk_best(
						game_state, color, bc, self.tables_open
					)
					if lbest_score > best_score:
						best_move = lbest_move
						best_score = lbest_score
						move_changed = True

				if move_changed:
					# translate move to be back in the real position rather than
					# relative to the translation
					bc.untranslate()
					best_move = bc.get_absolute_position(
						best_move[0], best_move[1]
					)

					# if the move is an illegal move, just choose a random move
					# with liberties
					while game_state.board[best_move[1]][best_move[0]] != ".":
						rx = random.randrange(0, game_state.size)
						ry = random.randrange(0, game_state.size)

						if game_state.board[ry][rx] == ".":
							game_state.board[ry][rx] = color
							libs = game_state.count_liberties(rx,ry)[1]
							game_state.board[ry][rx] = "."
							if libs != 0:
								best_move = (rx,ry)
								best_score = -100

		# relative chunk
		if game_state.this_move != None:
			(x,y) = game_state.this_move
			bc = board_chunk(game_state)
			bc.gen_relative(x,y)

			# corner chunk
			if bc.has_corner():
				(lbest_move,lbest_score) = self.__get_chunk_best(
					game_state, color, bc, self.tables_corner
				)
			# side chunk
			elif bc.has_side():
				(lbest_move,lbest_score) = self.__get_chunk_best(
					game_state, color, bc, self.tables_side
				)
			# open chunk
			else:
				(lbest_move,lbest_score) = self.__get_chunk_best(
					game_state, color, bc, self.tables_open
				)

			# update if necessary
			if lbest_score > best_score:
				best_score = lbest_score
				best_move = lbest_move

				bc.untranslate()
				best_move = bc.get_absolute_position(
					best_move[0], best_move[1]
				)

		return best_move