def find_mate(boardFEN): #Should only be used if mate is possible board = chess.Board(boardFEN) engine = chess.engine.SimpleEngine.popen_uci(engine_name("stockfish")) info = engine.analyse(board, chess.engine.Limit( depth=20)) #Limit the possible checkmate found to be under 20 moves board_states = [] #List of every board state in FEN notation during mate board_states.append(boardFEN) game = chess.pgn.Game() game.setup(boardFEN) x = 0 if not (info["score"].is_mate()): engine.quit() return None #The score given is not a mate, therefore, the function cannot return a mate. Therefore, it returns None for i in info["pv"]: #Loop through every move and add them to the lists if x == 0: node = game.add_main_variation( i) #If first loop, create the main line found by engine x = x + 1 else: node = node.add_main_variation( i) #Add to the main line if not first loop board.push(i) board_states.append( board.fen()) #Add the FEN board state after the move was made engine.quit() return game
def main(): train_data = [] for x in range(num_games): print("Starting game:" + str(x)) board = chess.Board() while not board.is_game_over() and board.fullmove_number < 20: legal_moves = board.legal_moves data = [] if board.turn == chess.BLACK: for move in legal_moves: board.push(move) # Estimate moves info = engine.analyse( board, chess.engine.Limit(time=0.0100, depth=6)) board.pop() data.append((move, str(info["score"]))) train_data.append(([to_X(board)], to_Y(data))) # Make best move result = engine.play(board, chess.engine.Limit(time=0.100)) board.push(result.move) # Make random move # board.push(random.choice(data)[0]) if (x + 1) % 96 == 0: train_data_formatted = split_data(train_data) model.fit([train_data_formatted[0]], [train_data_formatted[1]], epochs=1050, batch_size=32, callbacks=callbacks, verbose=2) train_data = [] model.save("checkpoints/" + model_name + datetime.now().strftime("D%d-H%H-M%M") + ".h5") model.save("models/" + model_name + ".h5") engine.quit()
def main(w_strat='fit_alphabeta', b_strat='fit_alphabeta'): engine = chess.engine.SimpleEngine.popen_uci('../Stockfish/src/stockfish') try: print(f"Opened engine {engine.id.get('name')}") game = Game(engine) board = chess.variant.RacingKingsBoard() print(f"Playing {w_strat} vs {b_strat}") while True: strategy = w_strat if board.turn else b_strat m = make_move(game, board, strategy) t = "WHITE" if board.turn else "BLACK" print(f"Move: {t} {m}") # print("States eval {}".format(node_counts[-1])) board.push(m) print(board) if board.is_variant_draw() or board.is_game_over(): break if board.is_variant_draw(): result = '1/2-1/2' else: result = board.result() print(f"Game over: {w_strat} {result} {b_strat}") finally: engine.quit()
def main(): board = chess.Board() engine = chess.engine.SimpleEngine.popen_uci("/usr/games/stockfish") #engine = chess.engine.SimpleEngine.popen_uci("~/.local/lib/python3.7/site-packages/stockfish") #create test matrix positions = create_colormap() positions[6][4] = 0 positions[4][4] = 1 print(board) print("\n") move = decode_move(board, positions) board.push(move) print(board) result = engine.play(board, chess.engine.Limit(time=0.5)) board.push(result.move) print("\n") print(board) engine.quit() print("\nTesting board novelty functions") print("first") print(previous_board(board, 2, 1)) print("initial") print(previous_board(board, 2, 0)) print("original") print(board)
def play_game(ws): board = generate_board(10) ws.send(json.dumps({"player": "random", "type": "player"})) engine = chess.engine.SimpleEngine.popen_uci("/usr/bin/stockfish") for state in board.states: analysis = engine.analyse(board, chess.engine.Limit(time=MOVE_GAP / 3)) ws.send( json.dumps({ "pieces": state, "score": analysis.score.white().score(), "type": "update" })) ws.send(json.dumps({"player": "nonrandom", "type": "player"})) while not board.is_game_over(claim_draw=True): result = engine.play(board, chess.engine.Limit(time=MOVE_GAP)) analysis = engine.analyse(board, chess.engine.Limit(time=MOVE_GAP)) print("score is:", analysis.score, "fen is", board.fen()) board.push(result.move) ws.send( json.dumps({ "pieces": board.get_pieces(), "score": analysis.score.white().score(), "type": "update" })) if board.is_checkmate(): ws.send(json.dumps({"winner": not board.turn(), "type": "winner"})) else: ws.send(json.dumps({"winner": None, "type": "winner"})) engine.quit()
def main(): ser = serial.Serial('/dev/ttyACM0', 9600) engine = chess.engine.SimpleEngine.popen_uci("/usr/games/stockfish") board = chess.Board() print("----- GAME START -----\n") while not board.is_game_over(): result = engine.play(board, chess.engine.Limit(time=0.500)) print(result.move) arduino_move = result.move.uci() print(type(arduino_move.encode())) ser.write(arduino_move.encode()) board.push(result.move) print("AI Move\n") print(board) print(" ") user_choice = input("User Move: ") board = check_input(user_choice, board) engine.quit()
def best_move(): fen = request.args.get('fen', '') if fen in cache: return cache[fen] board = chess.Board(fen) if board.is_game_over(): return {} engine = chess.engine.SimpleEngine.popen_uci("/usr/bin/stockfish") result = engine.play(board, chess.engine.Limit(time=1.00)) move = result.move san = board.san(move) board.push(move) # Commiting the move to the board # Analyze (NEW). Not activated. TODO #info = engine.analyse(board, chess.engine.Limit(time=0.5)) #score = info["score"] #mate_score = score.is_mate() #if score.is_mate(): # eval = f"{score.white().mate()}#" #else: # eval = f"{score.white().score()}" engine.quit() result = {"san": san, "fen": board.fen()} cache[fen] = result return result
def read_window_break_if_closed(engine): button, value = window.Read() if button == sg.WIN_CLOSED: # if user closes window engine.quit() sys.exit() return button, value
def process_curent_game(session): board = chess.Board() engine = chess.engine.SimpleEngine.popen_uci("engine/stockfish") limit = chess.engine.Limit(time=2) local_opponents_last_move = None while True: try: cur_games = berserk.clients.Games(session).get_ongoing() except: continue if not cur_games: break else: cur_game = cur_games[0] if cur_game['isMyTurn']: remote_last_move = cur_game['lastMove'] if not remote_last_move: my_move = engine.play(board, limit).move.uci() board.push_uci(my_move) screen_utils.field.move(my_move, cur_game['color']) elif remote_last_move != local_opponents_last_move: local_opponents_last_move = remote_last_move board.push_uci(remote_last_move) my_move = engine.play(board, limit).move.uci() board.push_uci(my_move) screen_utils.field.move(my_move, cur_game['color']) engine.quit()
def main(opponent=chess.BLACK): try: engine = chess.engine.SimpleEngine.popen_uci('Stockfish/src/stockfish') print(f"Opened engine {engine.id.get('name')}") game = Game(engine, opponent=opponent) board = chess.variant.RacingKingsBoard() import pdb pdb.set_trace() while True: m = make_move(board, game, opponent) t = "WHITE" if board.turn else "BLACK" print(f"Move: {t} {m}") board.push(m) print(board) if board.is_game_over(): break print( f"Game over: {board.result()} " f"({'stockfish' if opponent==chess.WHITE else 'agent'} v {'stockfish' if opponent==chess.BLACK else 'agent'})" ) finally: engine.quit()
def main(): counter = positions_db.count_not_evaluated_positions() print('Number of not yet evaluated positions: {0}'.format(counter)) if not counter: print('Nothing to do, quiting.') return engine = chess.engine.SimpleEngine.popen_uci(engine_path()) engine.configure({'Threads': 6}) while True: record = positions_db.get_not_evaluated_position() if record is None: break position_id, fen = record (score, bestmove, is_bestmove_capture, is_bestmove_check, is_check) = evaluate_position(engine, fen) positions_db.update_position_evaluation( position_id, score, bestmove, is_bestmove_capture, is_bestmove_check, is_check) engine.quit()
def chess_moves_publishing(boards): pub = rospy.Publisher('chess_next_moves', String, queue_size=10) rospy.init_node('chess_moves', anonymous=True) while not board.is_game_over(): while not rospy.is_shutdown(): result = engine.play(boards, chess.engine.Limit(time=0.100)) next_move = str(result.move) recipient_square = boards.piece_at(squares_integers[next_move[2:]]) boards.push(result.move) pieceCount = update_piece_count(boards) if (recipient_square is None): rospy.loginfo(next_move) pub.publish(next_move) else: rospy.loginfo(next_move + 's') pieceCount -= 1 pub.publish(next_move + 's') rospy.sleep(235) print(pieceCount) generate_human_move(pieceCount) rospy.sleep(5) engine.quit()
def display_results(num_illegal_moves, first_illegal_move, total_black_moves, final_illegal_moves, winners, bot_arr, comp_arr, num, args): z = np.array(first_illegal_move) curated_first_illegal = z[z != -1] n_without_illegal = z.shape[0] - curated_first_illegal.shape[0] move_evals = eval_moves(bot_arr, comp_arr) with open('bot_scores.pkl', 'wb') as f: pickle.dump(bot_arr, f) with open('comp_scores.pkl', 'wb') as f: pickle.dump(comp_arr, f) print(f'Analyzed {num + 1} games...') print('On average, ChePT made:') print(f'\t\t\t{int(np.mean(total_black_moves))} moves per game.') print(f'\t\t\tFirst illegal move on move {int(np.mean(curated_first_illegal))}.') print(f'\t\t\t{int(np.mean(num_illegal_moves))} attempted illegal moves per game.') print(f'\t\t\t{int(np.mean(final_illegal_moves))} final illegal moves per game.') print('') print(f'ChePT had {n_without_illegal} games with no illegal moves.') attempt_percent = np.round(np.mean(np.array(num_illegal_moves) / np.array(total_black_moves)) * 100, 3) final_percent = np.round(np.mean(np.array(final_illegal_moves) / np.array(total_black_moves)) * 100, 3) print(f'ChePT attempts to make an illegal move {attempt_percent}% of the time') print(f'ChePT finally makes an illegal move {final_percent}% of the time') n_bot_wins = np.sum(np.array(winners) == 'BOT') n_draws = np.sum(np.array(winners) == 'DRAW') print(f'\nChePT managed to win {n_bot_wins} games.') print(f'ChePT managed to draw {n_draws} games.') results = {'Number of games': num + 1, 'Number of moves': int(np.mean(total_black_moves)), 'First illegal move': int(np.mean(curated_first_illegal)), 'Attempted illegal moves': int(np.mean(num_illegal_moves)), 'Games without illegal moves': n_without_illegal, 'Final illegal moves': int(np.mean(final_illegal_moves)), 'Percent attempted illegal moves': float(attempt_percent), 'Percent final illegal moves': float(final_percent), 'Wins': int(n_bot_wins), 'Draws': int(n_draws), 'Average move evaluation': float(move_evals['full_avg']), 'Average early game move evaluation': float(move_evals['early_avg']), 'Average mid game move evaluation': float(move_evals['mid_avg']), 'Average late game move evaluation': float(move_evals['late_avg'])} save_results(results, args) engine.quit()
def test_uci(python='python3', protocol='uci'): def new_engine(): #python = '/usr/local/bin/python3' d = pathlib.Path(__file__).parent if protocol == 'uci': args = [python, '-u', str(d / 'uci.py')] return chess.engine.SimpleEngine.popen_uci(args, debug=True) else: args = [python, '-u', str(d / 'xboard.py')] return chess.engine.SimpleEngine.popen_xboard(args, debug=True) limits = [ chess.engine.Limit(time=1), chess.engine.Limit(nodes=1000), chess.engine.Limit(white_clock=1, black_clock=1), chess.engine.Limit( white_clock=1, black_clock=1, white_inc=1, black_inc=1, remaining_moves=2) ] for limit in limits: engine = new_engine() board = chess.Board() while not board.is_game_over() and len(board.move_stack) < 3: result = engine.play(board, limit) board.push(result.move) engine.quit()
def get(self): ret_dict = {} parser = reqparse.RequestParser() parser.add_argument('fen', type=str) parser.add_argument('svg', type=str) args = parser.parse_args() engine = chess.engine.SimpleEngine.popen_uci(stockfish_path) board = chess.Board(fen=args['fen']) info = engine.analyse(board, chess.engine.Limit(time=0.100)) next_move_limit = chess.engine.Limit(time=2.0) next_move = engine.play(board, next_move_limit) engine.quit() ret_dict = { 'current_score': str(info["score"]), 'next_move_suggestion': str(next_move.move), 'next_move_suggestions': str(next_move.info), 'board_before': str(board), } if ('svg' in args and args['svg'] == '1'): ret_dict['svg'] = chess.svg.board(board=board, lastmove=next_move.move) return ret_dict
def main(args): before = datetime.now() # Initialize remaining_work = Value('i', args.npositions) finished_work = Value('i', 0) position_lock = Lock() # Check if the engine supports FRC engine = chess.engine.SimpleEngine.popen_uci(args.engine) supports_frc = 'UCI_Chess960' in engine.options engine.quit() # Start generating data with all threads training_files = [] processes = [] parts = os.path.splitext(args.output) for pid in range(0, args.nthreads): training_file = parts[0] + '_' + str(pid) + parts[1] training_files.append(training_file) process_args = (pid, training_file, remaining_work, finished_work, position_lock, supports_frc, args) processes.append(Process(target=process_func, args=process_args)) processes[pid].start() # Handle progress output while True: time.sleep(PROGRESS_INTERVAL) position_lock.acquire() pos_generated = finished_work.value position_lock.release() print(f'\r{pos_generated}/{args.npositions}', end='') if pos_generated == args.npositions: break print('\n') # Wait for all threads to exit for p in processes: p.join() # Merge data from all threads into one file if args.format == 'plain': with open(args.output, 'w') as wfd: for f in training_files: with open(f, 'r') as fd: shutil.copyfileobj(fd, wfd) else: with open(args.output, 'wb') as wfd: for f in training_files: with open(f, 'rb') as fd: shutil.copyfileobj(fd, wfd) for f in training_files: os.remove(f) after = datetime.now() print(f'Time: {after-before}')
def run(self, reduced: Callable, square_filter: Callable, echo: int = 1, depth: int = 20) -> pd.DataFrame: engine = self.engine_maker() result = pd.DataFrame(columns=[ 'SideThatMoved', 'SideToMove', 'Score', 'PovScore', 'HalfMoveConfiguration', 'FEN', 'LastWhiteMove', 'LastBlackMove', 'ViewForWhite', 'ViewForBlack', 'Zeros', 'ZerosWithEcho' ]) for curr_move in range(0, len(self.moves)): bm_offset = (curr_move + 1) % 2 adjusted_wm = (curr_move // 2) * 2 adjusted_bm = curr_move - bm_offset side = bool( bm_offset) # white: 1, black: 0, same as in python-chess if not self.first_move_by_white: adjusted_wm, adjusted_bm = adjusted_bm, adjusted_wm # not tested! last_white_move = self.moves[adjusted_wm] last_black_move = self.moves[ adjusted_bm] if adjusted_bm > -1 else None white = self.msw(range(adjusted_wm - (echo * 2), adjusted_wm + 1), chess.WHITE, square_filter) black = self.msb(range(adjusted_bm - (echo * 2), adjusted_bm + 1), chess.BLACK, square_filter) zeros_white = reduced( self.msz(range(curr_move, curr_move + 1), chess.WHITE, square_filter).result) zeros_black = reduced( self.msz(range(curr_move, curr_move + 1), chess.BLACK, square_filter).result) reduced_white = reduced(white.result) reduced_black = reduced(black.result) # would be nice if engine.analyse could be made to run async/in parallel current_board = white.board if side else black.board score = engine.analyse(current_board, chess.engine.Limit(depth=depth))['score'] result.loc[curr_move] = [ 'White' if side else 'Black', 'Black' if side else 'White', int(score.pov(chess.WHITE).__str__()), int(score.pov(score.turn).__str__()), (curr_move, adjusted_wm, adjusted_bm), current_board.fen(), last_white_move, last_black_move, reduced_white, reduced_black, cda.countZeros(np.logical_or(zeros_white, zeros_black)), cda.countZeros(np.logical_or(reduced_white, reduced_black)) ] engine.quit( ) # This is important, otherwise we leak opened file objects! return result
def report(): moves = request.args.get('moves', '').split(',') engine = chess.engine.SimpleEngine.popen_uci("/usr/bin/stockfish") analyzer = Analyzer(moves, engine) result = jsonify({ "moves": [analyzer.analyzeIndex(index) for index in range(len(moves))] }) engine.quit() return result
def compare_model(time, stockfish=True): if stockfish: engine = chess.engine.SimpleEngine.popen_uci( "/home/albb762/chessai/stockfish/Linux/stockfish_10_x64") engine.configure({'Skill Level': 1}) first = 0 second = 0 draw = 0 for i in range(time): print(i) flag = 'stockfish' board = chess.Board() if random.randint(0, 1): board, _ = v.play_one_step(board) battle = 'model vs stockfish:' flag = 'model' while True: if not board.is_game_over(): if stockfish: result = engine.play( board, chess.engine.Limit(time=0.00100, depth=1)) board.push(result.move) else: board.push(random.choice(list(board.legal_moves))) else: break if not board.is_game_over(): board, _ = v.play_one_step(board) else: break res = board.result() if flag == 'stockfish': if '1-0' == res: first += 1 if '0-1' == res: second += 1 if '1/2-1/2' == res: draw += 1 if flag == 'model': if '1-0' == res: second += 1 if '0-1' == res: first += 1 if '1/2-1/2' == res: draw += 1 if stockfish: print('stockfish vs model : ', first, second, draw) else: print('random vs model : ', first, second, draw) engine.quit()
def make_move(psg_board, window, move_str, line, engine): if move_str == '0-0': move_str = castling_short(move_str, psg_board, window) elif move_str == '0-0-0': move_str = castling_long(move_str, psg_board, window) # en passante elif 'ep' in move_str: if board.turn: move_str = move_str[0:4] enemy_pawn = move_str[2] + str(int(move_str[3]) - 1) make_move_gui(move_str[0:2] + enemy_pawn, psg_board, window) make_move_gui(enemy_pawn + move_str[2:4], psg_board, window) else: move_str = move_str[0:4] enemy_pawn = move_str[2] + str(int(move_str[3]) + 1) make_move_gui(move_str[0:2] + enemy_pawn, psg_board, window) make_move_gui(enemy_pawn + move_str[2:4], psg_board, window) elif '=' in move_str: move_str = promotion(move_str, psg_board, window) else: make_move_gui(move_str, psg_board, window) move = chess.Move.from_uci(move_str) if not (board.is_legal(move) != board.is_castling(move)): if board.turn: sg.Popup(f'ERROR: {line} is not a legal move from white.\n') else: sg.Popup(f'ERROR: {line} is not a legal move from black.\n') engine.quit() sys.exit() board.push(move) analyzed_score = engine.analyse(board, chess.engine.Limit(time=0.2)) score = analyzed_score.get('score') depth = analyzed_score.get('depth') window.FindElement('_score_').Update( f'Score of your board is {score} with a analyzed depth of {depth}.', append=True) window.FindElement('_movelist_').Update(line + '\n', append=True) best_move = engine.play(board, chess.engine.Limit(time=0.2)).move window.FindElement('_best_move_').Update( f'{best_move} with a analyzed depth of {depth}.', append=True) if (board.is_checkmate()): sg.Popup('Checkmate!', board.result(), 'Thank you for playing', title='Game Over!') engine.quit() sys.exit() if (board.is_check()): sg.Popup('Check')
def stockfish_move(self, turn="w"): fen = self.convert_board_to_FEN(turn=turn) root_moves = [chess.Move.from_uci(mv) for mv in self.legal_moves(turn)] engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_DIR) board = chess.Board(fen) result = engine.play(board, chess.engine.Limit(time=0.5, depth=1), root_moves=root_moves) engine.quit() return str(result.move)
def expertChoice(self): engine = chess.engine.SimpleEngine.popen_uci( "C:\WinBoard-4.8.0\Stockfish\stockfish_20090216_x64_bmi2.exe") result = engine.play(self.board, chess.engine.Limit(time=0.01)) engine.quit() action = 1 if result != None and result.move != None: action = self.moveToAction[result.move.uci()] return action
def eng_choose(legmoves, board, lim): # global args # if board.fullmove_number < 10 and args.polyglot_book != "": # opc = opening_choice(board, args.polyglot_book) # if opc is not None: # return opc engine = chess.engine.SimpleEngine.popen_uci("stockfish") moves = eng_rate(legmoves, board, engine, lim) engine.quit() return moves[0][0]
def find_move(self): """ Calculate the best move according to Stockfish """ self.enginePath = self.pathField.text() self.time = float(self.engineTime.text()) engine = chess.engine.SimpleEngine.popen_uci(self.enginePath) result = engine.play(self.board, chess.engine.Limit(time=self.time)) self.engineResult.setText(str(result.move)) engine.quit() return result.move
def stockfish_score(self, turn="w"): fen = self.convert_board_to_FEN(turn) root_moves = [chess.Move.from_uci(mv) for mv in self.legal_moves(turn)] engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_DIR) board = chess.Board(fen) info = engine.analyse(board, chess.engine.Limit(time=0.5, depth=1), root_moves=root_moves) engine.quit() score = info.get("score") return score.white(), score.black()
async def game(board: str): """ Calculate next move based on current board """ b = chess.Board(board) engine = chess.engine.SimpleEngine.popen_uci("/usr/games/stockfish") result = engine.play(b, chess.engine.Limit(time=0.5)) b.push(result.move) engine.quit() return b.fen()
def test_stockfish_features(): engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) f = features.Stockfish10(chess.STARTING_FEN, engine) assert f.features() == { "best_mate": None, "best_move": "b1c3", "best_pv": "['b1c3', 'd7d5', 'd2d4', 'c7c6', 'c1f4', 'e7e6', 'e2e3']", "best_score": 115, } engine.quit()
def engine_analyze_position(): engine = chess.engine.SimpleEngine.popen_uci( "C:\Program Files (x86)\Tarrasch\Engines\stockfish_11_x64.exe") engine.configure({"Hash": 2048, "Threads": 8}) board = chess.Board( "r1b1k1nr/p1q1ppbp/2pp2p1/2p5/4PP2/2NP1N2/PPP3PP/R1BQ1RK1 b kq - 0 8") info = engine.analyse(board, chess.engine.Limit(depth=40)) print("Score:", info["score"]) # Score: PovScore(Mate(+1), WHITE) engine.quit()
def main(): engine = chess.engine.SimpleEngine.popen_uci( "stockfish10/Windows/stockfish_10_x64.exe") X = [] Y = [] pgn = open("datasets/ficsgamesdb_2018_CvC_nomovetimes_51973.pgn") state_limit = 60 games = 300 evaluation_time = 1 start = time.time() print(f"Parsing {games} games.") for i in range(games): game = chess.pgn.read_game(pgn) board = game.board() states = 0 print("Game:", i + 1, f"({game.headers['Event']})") for next_node in game.mainline_moves(): evaluation = engine.analyse( board, chess.engine.Limit(time=evaluation_time)) score = sigmoid( (2 * int(board.turn) - 1) * (evaluation['score'].relative.score(mate_score=1000000))) X.append(get_bit_map(board)) Y.append(score) states += 1 board.push(next_node) if states >= state_limit: break end = time.time() print("States:", states) hours, rem = divmod(end - start, 3600) minutes, seconds = divmod(rem, 60) print( f"Time Elapsed:", "{:0>2}:{:0>2}:{:05.2f}".format(int(hours), int(minutes), seconds)) engine.quit() print("Dataset created") print("Samples:", len(X), "Labels:", len(Y)) print("Dumping to JSON") with open('data.json', 'w') as outfile: json.dump([X, Y], outfile)
def from_df(cls, df): engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH) feature_rows = [] with click.progressbar(tuple(df.itertuples()), label=cls.__name__) as rows: for row in rows: feature_instance = cls.from_row(row, engine) feature_rows.append(feature_instance.features()) engine.quit() return pd.DataFrame(feature_rows)