def choose_move(self, board): # In order to check visits over duration of function start_num = self.num_alphabeta start_time = time.time() # Query opening book if option set if self.use_book: with open_reader("data/performance.bin") as reader: try: entry = reader.weighted_choice(board) time.sleep(1) print( "After considering {} options from the entry book, {} was selected by {} AlphaBetaAI." .format(sum(1 for _ in reader.find_all(board)), entry.move, "White" if self.is_white else "Black")) self.time += time.time() - start_time reader.close() return entry.move except IndexError: reader.close() # init values = [] best_value = float('-inf') alpha = float('-inf') beta = float('inf') # I am not sure if clearing maintains optimality self.transposition_table.clear() # randomize moves to allow variance moves = list(board.legal_moves) random.seed() random.shuffle(moves) for move in moves: board.push(move) # Get move value and add to list new_val = self.min_value(board, self.depth, alpha, beta) values.append(new_val) # Update if new max best_value = max(best_value, new_val) alpha = max(alpha, new_val) board.pop() # Print and return results print("After searching {} nodes, {} was selected by {} AlphaBetaAI.". format(self.num_alphabeta - start_num, moves[values.index(best_value)], "White" if self.is_white else "Black")) self.time += time.time() - start_time return moves[values.index(best_value)]
def __init__(self, board, is_player_white): self.board = board self.is_ai_white = not is_player_white with open_reader('data/opening.bin') as reader: self.opening_moves = [ str(entry.move()) for entry in reader.find_all(board) ]
def __init__(self, board, is_player_white): self.board = board self.is_ai_white = not is_player_white with open_reader('C:/Users/vinit/PycharmProjects/CHESSAIPROJECT/ai project/data/opening.bin') as reader: self.opening_moves = [ str(entry.move) for entry in reader.find_all(board) ]
def get_move_from_opennings(self, board): if not ENABLE_OPENING_BOOK: return with open_reader("data/opennings/bookfish.bin") as reader: try: entry = reader.choice(board) print(entry.move(), entry.weight, entry.learn) return entry.move() except: return None
def __init__(self, board, is_player_white): self.board = board self.is_ai_white = not is_player_white with open_reader( './data/opening.bin' ) as reader: #here for given board states reader.find_all(board) gives the opening moves self.opening_moves = [ str(entry.move) for entry in reader.find_all(board) ] print(self.opening_moves)
def _get_book_move(self, step): bfp = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data', 'polyglot', 'Performance.bin') with book.open_reader(bfp) as reader: es = reader.find_all(self.env.board) actions = np.asarray([e.move().uci() for e in es]) action = None if len(actions) > 0: if step == 1: action = np.random.choice(actions) else: action = actions[0] return action
async def move(self, ctx, move=''): player = self.white if self.white.turn == True else self.black if str(ctx.message.author) == str(player.username): try: move = ctx.message.content[9:] self.board.push_san(move) self.genBoardImg() await ctx.message.channel.send(file=discord.File("board.png")) self.swapTurns() if self.black.username == "engine": with open_reader('gamebook/games.bin') as reader: opening_moves = [ str(entry.move) for entry in reader.find_all(self.board) ] if opening_moves: choice = random.randint(0, len(opening_moves) // 2) move = chess.Move.from_uci(opening_moves[choice]) move = chess.Move.from_uci(str(move)) self.board.push(move) self.genBoardImg() self.swapTurns() await ctx.message.channel.send( file=discord.File("board.png")) else: print("\n I am thinking...\n") pool = multiprocessing.Pool() #move = pool.map(chessai.alphaBetaRoot(3,self.board,True), range(23)) move = chessai.alphaBetaRoot(3, self.board, True) move = chess.Move.from_uci(str(move)) self.board.push(move) self.genBoardImg() self.swapTurns() await ctx.message.channel.send( file=discord.File("board.png")) if self.board.is_game_over() or self.board.is_checkmate(): await ctx.message.channel.send("[*] Game Over.") self.white = None self.black = None self.board = chess.Board() except ValueError: await ctx.message.channel.send("[!] WARNING: Invalid move!") else: await ctx.message.channel.send("Not {}'s turn!".format( ctx.message.author))
def recommend_move(): """ Recommend move using by looking up polyglot opening book. If not in book then use stockfish engine. """ try: with polyglot.open_reader( "./data/polyglot/performance.bin") as reader: main_entry = reader.find(board) recom_move = main_entry.move() except IndexError: engine = uci.popen_engine("./Stockfish/src/stockfish") engine.uci() engine.position(board) # Gets tuple of bestmove and ponder move. best_move = engine.go(movetime=ENGINE_MOVETIME) recom_move = best_move[0] engine.quit() return recom_move
def __init__(self, call_if_ready, call_to_inform, opening_book): super(Analyzer, self).__init__() if opening_book: self.opening_book = polyglot.open_reader(opening_book) else: self.opening_book = None self.debug = False self.set_default_values() self.board = chess.Board() self.is_working = threading.Event() self.is_working.clear() self.is_conscious = threading.Condition() self.termination = threading.Event() self.termination.clear() self._call_if_ready = call_if_ready self._call_to_inform = call_to_inform self._bestmove = chess.Move.null()
def __call__(self): with opening.open_reader("data/performance.bin") as book: moves = [entry.move for entry in book.find_all(self.chess.board)] if moves and self.opening_book: if self.variation: shuffle(moves) phi = lambda x: 1 / (1 + exp(-x)) - 0.5 move = moves[0] self.chess(move) sleep(1) print(f""" OPENING MODE MOVE: {move} """) return move, phi(self.chess.util) t = time() moves = self.chess.legal_moves() if len(list(moves)) == 1: move = list(moves)[0] self.chess(move) return move, self.chess.utility() alpha = float('-inf') beta = float('inf') result = None boards = sorted( ((copy(self.chess)(move), False, move) for move in moves), key=lambda x: x[0].util, reverse=self.chess.turn()) self.count = 0 if self.chess.turn(): value = float('-inf') for board, urgent, move in boards: self.count += 1 alphabeta_result = self.alphabeta(board, urgent, 1, alpha, beta) if value <= alphabeta_result: value = alphabeta_result result = move alpha = max(value, alpha) if alpha >= beta: break else: value = float('inf') for board, urgent, move in boards: self.count += 1 alphabeta_result = self.alphabeta(board, urgent, 1, alpha, beta) if value >= alphabeta_result: value = alphabeta_result result = move beta = min(value, beta) if alpha >= beta: break if result is None: move = 'RESIGN' else: move = result.uci().upper() timer = round(time() - t, 1) print(f""" MOVE: {move} UTIL: {round(value, 3)} TIME: {timer} s NODE: {self.count} ONCE: {round(timer/self.count*1e3, 3)} ms""") self.chess(result) return result, value
def opening_move(board, book_path): try: return bookloader.open_reader(book_path).find(board).move except IndexError: return None
def choose_move(self, board): # Query opening book if option set if self.use_book: with open_reader("data/performance.bin") as reader: try: entry = reader.weighted_choice(board) time.sleep(1) print( "After considering {} options from the entry book, {} was selected by {} MinimaxAI." .format(sum(1 for _ in reader.find_all(board)), entry.move, "White" if self.is_white else "Black")) reader.close() return entry.move except IndexError: reader.close() self.moves += 1 moves = list(board.legal_moves) random.seed() random.shuffle(moves) # init best_move = moves[0] self.start = time.time() self.transposition_max.clear() self.transposition_min.clear() print("---------------------------------") # iterate through depths, likely will not be surpassed for i in range(1, 20): # iteration init values = [] best_value = float('-inf') alpha = float('-inf') beta = float('inf') for move in moves: board.push(move) # Get move value and add to list new_val = self.min_value(board, i, alpha, beta) values.append(new_val) # Update if new max best_value = max(best_value, new_val) alpha = max(alpha, new_val) board.pop() # If time limit reached, return if time.time() - self.start > self.time_limit: print("---------------------------------") self.total_depth += i - 1 return best_move # If not reached, update best move best_move = moves[values.index(best_value)] print("At depth {}, the best move is {}".format(i, best_move)) print("---------------------------------") return best_move