def __init__(self): if platform.system() == 'Darwin': self.engine = popen_engine(basepath + "/stockfish-osx") elif platform.system() == 'Linux': self.engine = popen_engine(basepath + "/stockfish-linux") elif platform.system() == 'Windows': self.engine = popen_engine(basepath + "/stockfish-windows")
def _init_engine(self): if platform.system() == "Linux": if platform.machine() == "armv7l": self.engine = uci.popen_engine("bin/stockfish-8-arm-rasp") else: self.engine = uci.popen_engine("bin/stockfish-9-popcnt") elif platform.system() == "Darwin": self.engine = uci.popen_engine("bin/stockfish") self.engine.uci() self.engine.ucinewgame()
def on_add(self): dialog = QFileDialog() dialog.setFilter(QDir.Executable | QDir.Files) filename = dialog.getOpenFileName(self, self.trUtf8('Select Engine'), None, '',QFileDialog.DontUseNativeDialog) if(filename): engine = Engine() engine.path = filename try: eng = popen_engine(filename) command = eng.uci(async_callback=True) command.result(timeout=1.5) engine.name = eng.name self.engines.append(engine) item = QListWidgetItem(engine.name) self.lstEngines.addItem(item) item.setSelected(True) print("I am quitting. I quit.") eng.quit() print("sine they have my stapler") #self.active_engine = engine except BaseException as e: print(e) finally: pass # todo: better error handling if # a non-chess engine is chosen
def __init__(self, config, engine=True, newmodel: bool = False): logging.debug('newmodel') logging.debug(newmodel) self.config = config self.engine = engine if self.engine: self.engine = uci.popen_engine( stockfish_command(config['stockfish']['update'])) self.engine.setoption({ 'Threads': config['stockfish']['threads'], 'Hash': config['stockfish']['memory'] }) self.engine.uci() self.infoHandler = uci.InfoHandler() self.engine.info_handlers.append(self.infoHandler) self.api = Api(config['api']['url'], config['api']['token']) # Set up mongodb self.client = MongoClient(config['db']['host']) self.db = self.client.irwin if config['db']['authenticate']: self.db.authenticate(config['db']['authentication']['username'], config['db']['authentication']['password'], mechanism='MONGODB-CR') # Irwin self.irwinEnv = IrwinEnv(config, self.db) self.irwin = Irwin(self.irwinEnv, newmodel)
async def __aenter__(self): """Starts a chess engine and prepares it for commands.""" # We make sure we aren't running in an async with statement self._check_not_in_awith() # We initialise the engine self.engine = uci.popen_engine(self.engine_path, setpgrp=True) # We set the difficulty await self.wait_for( self.engine.setoption( { "Skill Level": self.difficulty, "Threads": self.num_search_threads }, async_callback=True)) # We set the board position to the saved one await self.wait_for( self.engine.position(self.board, async_callback=True)) # We're longer in an async with statement self._in_with_statement = True return self
def start_engine(self): if self.engine is not None: self.engine.quit() self.engine = uci.popen_engine( os.path.join(self.binary_dir, "engine.exe")) self.engine.setoption({'Threads': self.get_option("threads")}) self.engine.uci() self.engine.ucinewgame()
def main(): global move_array game = True engine = uci.popen_engine('./Engine/stockfish_8_x64') engine.uci() while game: SCREEN.blit(BACKGROUND, (0, 512)) button("Reset", 50, 520, 100, 30, BUTTON_BACK, BUTTON_BACK, resetBoard) button("<<", 200, 520, 50, 30, BUTTON_BACK, BUTTON_BACK, toBeginning) button("<", 270, 520, 50, 30, BUTTON_BACK, BUTTON_BACK, oneBack) button(">", 340, 520, 50, 30, BUTTON_BACK, BUTTON_BACK, pushOne) button(">>", 410, 520, 50, 30, BUTTON_BACK, BUTTON_BACK, toEnd) for row in range(8): for column in range(8): if (row, column) not in move_array: if (row + column) % 2 == 0: SCREEN.blit(SQUARE_DARK, (row * 64, column * 64)) else: SCREEN.blit(SQUARE_LIGHT, (row * 64, column * 64)) for event in pygame.event.get(): if event.type == pygame.QUIT: game = False if event.type == pygame.MOUSEBUTTONUP: pos = pygame.mouse.get_pos() x_val, y_val = int(pos[0] / 64), 7 - (int(pos[1] / 64)) if y_val >= 0: move_array.append((x_val, y_val)) if len(move_array) == 1: SCREEN.blit(SQUARE_CLICKED, (move_array[0][0] * 64, (7 - move_array[0][1]) * 64)) if len(move_array) == 2: square_x = chess.square(move_array[0][0], move_array[0][1]) square_y = chess.square(move_array[1][0], move_array[1][1]) if (str(BOARD.piece_at(square_x)) == 'P' or str(BOARD.piece_at(square_x)) == 'p') \ and chess.file_index(square_x) != chess.file_index(square_y) and \ (chess.rank_index(square_y) == 0 or chess.rank_index(square_y) == 7): cur_move = chess.Move(square_x, square_y, promotion=5) else: cur_move = chess.Move(square_x, square_y) if cur_move in BOARD.legal_moves: BOARD.push(cur_move) engine_position = engine.position(BOARD) engine_moves = engine.go() BOARD.push(engine_moves[0]) else: move_array = [] updateBoard() pygame.display.flip() CLOCK.tick(30)
def get_engine_move(self,engine): settings = self.config[engine] engine_loc = settings.pop('Location') engine = uci.popen_engine(engine_loc) engine.position(self.board) move, ponder = engine.go(**settings) engine.terminate() settings['Location'] = engine_loc return move
def get_engine(engine_conf): e = uci.popen_engine(engine_conf.cmd, engine_cls=TrainEngine) e.uci() if engine_conf.options: e.setoption(engine_conf.options) e.isready() info_handler = uci.InfoHandler() e.info_handlers.append(info_handler) return e
def play_stockfish(board): eng = uci.popen_engine("/usr/games/stockfish") eng.uci() eng.position(board) m = eng.go(movetime=1000) eng.ucinewgame() # import ipdb; ipdb.set_trace() make_mouse_move(m[0].from_square, m[0].to_square) board.push_uci(m[0].uci()) print board
def __init__(self): if IS_WINDOWS: self.base_file_name = 'base.exe' else: self.base_file_name = './base' self.base_engine = uci.popen_engine(self.base_file_name) self.info_handler_base = uci.InfoHandler() self.base_engine.info_handlers.append(self.info_handler_base) self.base_engine.setoption({'Threads': '2'}) self.base_engine.setoption({'Hash': '2048'})
def lin_ex (n): # Run 1 move in n games sequentially for i in range(n): eng = uci.popen_engine("/usr/games/stockfish") eng.uci() eng.ucinewgame() board = chess.Board() eng.position(board) command = eng.go(movetime=1000, async_callback=True) command.result() eng.quit()
def __init__(self): self._color = os.environ.get('COLOR') == "white" self._game_id = os.environ.get('GAME_ID') self.bot_id = secrets.token_hex(nbytes=16) #TODO : connect from config file self._red = redis.StrictRedis(host='redis', db=3, port=6379, password='******') self._engine = uci.popen_engine("/usr/games/stockfish") self._board = Board()
def on_message(self, message): """ when we receive some message we want some message handler.. for this example i will just print message to console """ print "Client %s received a message : %s" % (self.id, message) # self.write_message('Server received: {}'.format(message)) board = Board(fen=message) engine = uci.popen_engine("/Users/jaco/code/bughouse/stockfish-7-mac/Mac/stockfish-7-64") engine.uci() engine.setoption({'Ponder': False}) engine.position(board) best_move = engine.go(wtime=60000, btime=60000) engine.quit() # print engine.options # options = OptionMap( # { # 'Syzygy50MoveRule': Option(name='Syzygy50MoveRule', type='check', default=True, min=None, max=None, # var=[]), # 'Ponder': Option(name='Ponder', type='check', default=False, min=None, max=None, var=[]), # 'Hash': Option(name='Hash', type='spin', default=16, min=1, max=1048576, var=[]), # 'Clear Hash': Option(name='Clear Hash', type='button', default='', min=None, max=None, var=[]), # 'SyzygyProbeLimit': Option(name='SyzygyProbeLimit', type='spin', default=6, min=0, max=6, # var=[]), # 'Write Debug Log': Option(name='Write Debug Log', type='check', default=False, min=None, # max=None, var=[]), # 'SyzygyProbeDepth': Option(name='SyzygyProbeDepth', type='spin', default=1, min=1, max=100, # var=[]), # 'Slow Mover': Option(name='Slow Mover', type='spin', default=84, min=10, max=1000, var=[]), # 'SyzygyPath': Option(name='SyzygyPath', type='string', default='<empty>', min=None, max=None, # var=[]), # 'UCI_Chess960': Option(name='UCI_Chess960', type='check', default=False, min=None, max=None, # var=[]), # 'Threads': Option(name='Threads', type='spin', default=1, min=1, max=128, var=[]), # 'Contempt': Option(name='Contempt', type='spin', default=0, min=-100, max=100, var=[]), # 'Skill Level': Option(name='Skill Level', type='spin', default=20, min=0, max=20, var=[]), # 'Move Overhead': Option(name='Move Overhead', type='spin', default=30, min=0, max=5000, var=[]), # 'Minimum Thinking Time': Option(name='Minimum Thinking Time', type='spin', default=20, min=0, # max=5000, var=[]), # 'nodestime': Option(name='nodestime', type='spin', default=0, min=0, max=10000, var=[]), # 'MultiPV': Option(name='MultiPV', type='spin', default=1, min=1, max=500, var=[]) # }) msg = { 'board': 'main', 'from': str(best_move.bestmove)[:2], 'to': str(best_move.bestmove)[-2:] } print 'replying {}'.format(msg) self.write_message(json.dumps(msg))
def init_engines(pars): info_handlers = [] uciEngines = [] for e in Engines: uciEngines.append(uci.popen_engine(e['file'])) for u in uciEngines: u.uci() u.setoption(Options) u.setoption(pars[uciEngines.index(u)]) u.isready() return uciEngines
def new(conf: ConfigWrapper): engine = uci.popen_engine(stockfish_command(conf['stockfish update'])) engine.setoption({ 'Threads': conf['stockfish threads'], 'Hash': conf['stockfish memory'] }) engine.uci() infoHandler = uci.InfoHandler() engine.info_handlers.append(infoHandler) return EngineTools(engine=engine, infoHandler=infoHandler)
def init_engines(pars): info_handlers = [] uciEngines = [] for e in Engines: uciEngines.append(uci.popen_engine(e['file'])) for e, u in enumerate(uciEngines): u.uci() u.setoption(Options) u.setoption(pars[e]) u.isready() return uciEngines
def restartEngine(self): if self.engine: self.engine.kill() self.engine = uci.popen_engine( stockfish_command(self.config['stockfish']['update'])) self.engine.setoption({ 'Threads': self.config['stockfish']['threads'], 'Hash': self.config['stockfish']['memory'] }) self.engine.uci() self.infoHandler = uci.InfoHandler() self.engine.info_handlers.append(self.infoHandler)
def par_ex (n): # Run 1 move in n games across n separate processes at the same time engs = [] commands = [] for i in range(n): eng = uci.popen_engine("/usr/games/stockfish") eng.uci() eng.ucinewgame() engs.append(eng) for i in range(n): board = chess.Board() engs[i].position(board) commands.append(engs[i].go(movetime=1000, async_callback=True)) for i in range(n): commands[i].result() engs[i].quit()
def initialize(self): # Caffe net setup net = caffe.Net(CAFFENET_DEPLOY_TXT, CAFFENET_MODEL_FILE, caffe.TEST) # Set up transformer for input data transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape}) transformer.set_transpose('data', (2,0,1)) transformer.set_mean('data', np.array([104.00698793, 116.66876762, 122.67891434])); transformer.set_raw_scale('data', 255) # the reference model operates on images in [0,255] range instead of [0,1] transformer.set_channel_swap('data', (2,1,0)) # the reference model has channels in BGR order instead of RGB net.blobs['data'].reshape(BATCH_SIZE, 3, 227, 227) self.board = pychess.Board() self.engine = pychess_uci.popen_engine(STOCKFISH_PATH) self.engine.uci() self.engine.setoption({"UCI_Chess960": True}) self.engine.info_handlers.append(pychess_uci.InfoHandler()) self.remap = {'bb': 'b', 'bk': 'k', 'bn': 'n', 'bp': 'p', 'bq': 'q', 'br': 'r', 'wb': 'B', 'wk': 'K', 'wn': 'N', 'wp': 'P', 'wq': 'Q', 'wr': 'R', None: None}
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, win, stockfish_path, stockfish_timeout=TIMEOUT_MS, stockfish_player=SFISH_WHITE): self.win = win self.board = pychess.Board() self.engine = pychess_uci.popen_engine(stockfish_path) self.engine.uci() self.engine.setoption({"UCI_Chess960": True}) self.stockfish_timeout = stockfish_timeout self.stockfish_player = stockfish_player self.tts_engine = pyttsx.init() self.tts_engine.setProperty("rate", 130) voices = self.tts_engine.getProperty("voices") self.tts_engine.setProperty("voice", voices[9].id) if self.stockfish_player == SFISH_WHITE: what_playing = "white" elif self.stockfish_player == SFISH_BLACK: what_playing = "black" else: what_playing = "both white and black" self.tts_engine.say("i am playing %s"%what_playing) self.tts_engine.runAndWait() self.engine.info_handlers.append(pychess_uci.InfoHandler())
def on_add(self): dialog = QFileDialog() dialog.setFilter(QDir.Executable | QDir.Files) filename = dialog.getOpenFileName(self, self.trUtf8('Select Engine'), None, '', QFileDialog.DontUseNativeDialog) if (filename): engine = Engine() engine.path = filename try: eng = popen_engine(filename) command = eng.uci(async_callback=True) command.result(timeout=1.5) engine.name = eng.name self.engines.append(engine) item = QListWidgetItem(engine.name) self.lstEngines.addItem(item) item.setSelected(True) eng.quit() #self.active_engine = engine except BaseException as e: print(e) finally: pass
def initialize(self): # Caffe net setup net = caffe.Net(CAFFENET_DEPLOY_TXT, CAFFENET_MODEL_FILE, caffe.TEST) # Set up transformer for input data transformer = caffe.io.Transformer( {'data': net.blobs['data'].data.shape}) transformer.set_transpose('data', (2, 0, 1)) transformer.set_mean( 'data', np.array([104.00698793, 116.66876762, 122.67891434])) transformer.set_raw_scale( 'data', 255 ) # the reference model operates on images in [0,255] range instead of [0,1] transformer.set_channel_swap('data', ( 2, 1, 0)) # the reference model has channels in BGR order instead of RGB net.blobs['data'].reshape(BATCH_SIZE, 3, 227, 227) self.board = pychess.Board() self.engine = pychess_uci.popen_engine(STOCKFISH_PATH) self.engine.uci() self.engine.setoption({"UCI_Chess960": True}) self.engine.info_handlers.append(pychess_uci.InfoHandler()) self.remap = { 'bb': 'b', 'bk': 'k', 'bn': 'n', 'bp': 'p', 'bq': 'q', 'br': 'r', 'wb': 'B', 'wk': 'K', 'wn': 'N', 'wp': 'P', 'wq': 'Q', 'wr': 'R', None: None }
from chess import uci from tornado.options import options engine = uci.popen_engine(options.path_to_engine) engine.uci() from .base import BaseHandler from .index import IndexHandler from .game import GameHandler
def __init__(self): # Open stockfish engine and run it self.engine = uci.popen_engine(STOCKFISH_PATH) self.engine.uci()
#!/usr/bin/env python3 from chess import Board from chess.uci import popen_engine from flask import Flask, jsonify, request import os MOVE_MS = 1 DEPTH = 2 engine = popen_engine('stockfish') engine.uci() app = Flask(__name__) @app.route('/find_move', methods=['POST']) def make_move(): req = request.get_json(force=True) try: board = Board(req['fen']) except (ValueError, KeyError): return '', 400 engine.ucinewgame() engine.position(board) best_move = engine.go(movetime=MOVE_MS, depth=DEPTH)[0] board.push(best_move) return jsonify({ 'best_move': best_move.uci(), })
def chess_plugin(client, channel, nick, message, cmd, args): """ Command for helga-chess. Usage: <bigjust> !chess board <helga> <url to dpaste.com> <bigjust> !chess newgame <helga> I chose black, white to move <helga> I chose white, e5 Between each move, the game is saved and persisted on file. board and move commands always assume latest game in the gamefile. Multiple games will be stored per channel/user in history. """ engine = uci.popen_engine(ENGINE) headers = OrderedDict() current_game = None game = load_game(channel) if not game: game = pgn.Game() board = game.end().board() if args[0] in ['newgame', 'move', 'board']: if args[0] == 'board': return 'http://localhost:8080/chess/{}/'.format(channel) if args[0] == 'move': if len(args) < 2: return 'usage: move e3e5' try: board.push(Move.from_uci(args[1])) except ValueError: return 'not a valid move. valid moves: {}'.format(', '.join( [str(move) for move in board.legal_moves])) engine.position(board) move = engine.go(movetime=THINK_TIME).bestmove client.msg(channel, 'my move: {}'.format(str(move))) board.push(move) if args[0] == 'newgame': # setup a new game, choose a random side, persist after # setup(), and possibly first move engine.ucinewgame() board = Board() engine.position(board) next_round, stockfish_level = next_game_stats(channel) bot_turn = randrange(2) if not bot_turn: # we're white headers.update({ 'White': NICK, 'Black': channel, }) best_move = engine.go(movetime=THINK_TIME).bestmove board.push(best_move) next_turn = 'Black' else: headers.update({ 'Black': NICK, 'White': channel, }) next_turn = 'White' now = datetime.datetime.now() headers.update({ 'Date': '{}.{}.{}'.format(now.year, now.month, now.day), 'Round': next_round, 'Event': stockfish_level, }) client.msg(channel, '{} to move'.format(next_turn)) # persist the game game = pgn.Game.from_board(board) game.headers = headers save_game(channel, game)
from chess import uci, Move, Board board = Board() engine = uci.popen_engine("/Users/ben/src/Stockfish/src/stockfish") while True: move = input("move: ") if move.startswith("fen "): board.set_fen(move[4:]) continue board.push(Move.from_uci(move)) engine.position(board) print(engine.go(depth=15))
def __init__(self, engine, parent = None): super(DialogEngineOptions,self).__init__(parent) self.setWindowTitle(self.trUtf8("UCI Engine Options: ")+engine.name) # first parse all options form uci response eng = popen_engine(engine.path) command = eng.uci(async_callback=True) command.result(timeout=1.5) # eng.options # create sorted shallow copy eng_opts = [] for key in eng.options: eng_opts.append(eng.options[key]) eng_opts.sort(key=lambda x: x.name) self.optionWidgets = [] grid = QGridLayout() count = len(eng.options) rowwidth = count/4 x = 0 y = 0 for opt in eng_opts: #opt = eng.options[key] # add a widget for that option depending on its type # we will ignore options where the name starts with UCI_ # or is one of the following: # Hash, NalimovPath, NalimovCache, Ponder, Ownbook, MultiPV # (see UCI protocol specification) # in addition: # - for internal engine also block 'Skill Level' (handled at other place via GUI) # - settings of button type (maybe implement later, but for now we just # save all settings, and send them to the views right before engine is # activated via switching to resp. game mode, and not while in this dialog if not opt.name.startswith('UCI_') and not \ (opt.name == 'Hash' or opt.name == 'NalimovPath' or \ opt.name == 'NalimovCache' or opt.name == 'Ponder' or \ opt.name == 'Ownbook' or opt.name =='MultiPV') and not \ (type(engine) == InternalEngine and opt.name == 'Skill Level') and \ not opt.type == 'button': if(y >= rowwidth): y = 0 x += 1 # crude way of adding spacing if(not y==0): grid.addWidget(QLabel(" "),x,y) y +=1 # label for option lbl = QLabel(opt.name) grid.addWidget(lbl,x,y) # actual widget for manipulating value if opt.type == 'spin': widget = QSpinBox() widget.setMinimum(opt.min) widget.setMaximum(opt.max) if(engine.exists_option_value(opt.name)): widget.setValue(engine.get_option_value(opt.name)) else: widget.setValue(opt.default) elif opt.type == 'check': widget = QCheckBox() if(engine.exists_option_value(opt.name)): widget.setChecked(engine.get_option_value(opt.name)) else: widget.setChecked(opt.default) elif opt.type == 'combo': widget = QComboBox() if(engine.exists_option_value(opt.name)): active_setting = engine.get_option_value(opt.name) else: active_setting = opt.default for idx,val in enumerate(opt.var): widget.addItem(val) if(val == active_setting): widget.setCurrentIndex(idx) #elif opt.type == 'button': # widget = QPushButton(opt.name) elif opt.type == 'string': widget = QLineEdit() if(engine.exists_option_value(opt.name)): active_setting = engine.get_option_value(opt.name) else: active_setting = opt.default widget.setText(active_setting) y += 1 grid.addWidget(widget,x,y) self.optionWidgets.append((opt,widget)) y+=1 #x+=1 # buttonBox = QDialogButtonBox(QDialogButtonBox.Ok| QDialogButtonBox.Cancel) vbox = QVBoxLayout() vbox.addLayout(grid) vbox.addWidget(self.HLine()) #vbox.addLayout(hbox) vbox.addWidget(buttonBox) eng.quit() self.setLayout(vbox) self.connect(buttonBox, SIGNAL("accepted()"),self, SLOT("accept()")) self.connect(buttonBox, SIGNAL("rejected()"),self, SLOT("reject()"))
def runMatches(): whiteEngine = False blackEngine = False engineDepth = 1 engineNodes = 1 engineMovetime = .0001 ai_type = getInput( "White: 1 console, 2 minimax, 3 MonteCarlo, 4 stockfish", default='4') if ai_type == '1': white = AI.ConsoleAI() elif ai_type == '2': white = AI.Minimax_AI(int(getInput("Minimax Depth", default=3))) elif ai_type == '3': white = AI.MonteCarlo() elif ai_type == '4': whiteEngine = True white = uci.popen_engine('engines/stockfish') white.uci() ai_type = getInput( "Black: 1 console, 2 minimax, 3 MonteCarlo, 4 stockfish", default='4') if ai_type == '1': black = AI.ConsoleAI() elif ai_type == '2': black = AI.Minimax_AI(int(input("Minimax Depth: "))) elif ai_type == '3': black = AI.MonteCarlo() elif ai_type == '4': blackEngine = True black = uci.popen_engine('engines/stockfish') black.uci() log = getInput("Logging?", default='n') logging = False if log == 'y': logging = True num_games = int(getInput("Number of games", default=10)) white_times = [] black_times = [] white_wins = 0 black_wins = 0 ties = 0 for i in range(num_games): print("Playing game:", str(i + 1) + '/' + str(num_games)) board = Board() while not board.is_stalemate() and not board.is_game_over(): # Get and play White's move start = timeit.default_timer() if whiteEngine: white.position(copy.deepcopy(board)) whiteMove = str( white.go(movetime=engineMovetime, depth=engineDepth, nodes=engineNodes)[0]) else: whiteMove = white.getMove(copy.deepcopy(board)) stop = timeit.default_timer() white_times.append(stop - start) board.push_uci(whiteMove) if logging: print("White Move:", whiteMove) printBoard(board) # check if game over if board.is_stalemate() or board.is_game_over(): break # Get and play Black's move start = timeit.default_timer() if blackEngine: black.position(copy.deepcopy(board)) blackMove = str( black.go(movetime=engineMovetime, depth=engineDepth, nodes=engineNodes)[0]) else: blackMove = black.getMove(copy.deepcopy(board)) stop = timeit.default_timer() black_times.append(stop - start) board.push_uci(blackMove) if logging: print("Black move:", blackMove) printBoard(board) print(board.result()) if board.result() == '1-0': white_wins += 1 elif board.result() == '0-1': black_wins += 1 else: ties += 1 print("======================================================") print("White:", str(white)) print("Average move time:", sum(white_times) / len(white_times)) print("Wins:", white_wins) print("======================================================") print("Black:", str(black)) print("Average move time:", sum(black_times) / len(black_times)) print("Wins:", black_wins) print("======================================================") print("Ties:", ties) print("======================================================")
def launchSf(locpars): sf = uci.popen_engine(engine) base = uci.popen_engine(engine) info_handler = uci.InfoHandler() info_handler1 = uci.InfoHandler() sf.info_handlers.append(info_handler) base.info_handlers.append(info_handler1) sf.setoption({'Clear Hash': True}) sf.setoption({'Hash': 1}) base.setoption({'Clear Hash': True}) base.setoption({'Hash': 1}) for p in locpars: sf.setoption({p[0]: p[1]}) sf.uci() sf.isready() sf.ucinewgame() base.uci() base.isready() base.ucinewgame() board = Board(chess960=False) # board.set_epd('5rk1/p1pr2bp/1p2b1p1/2q1p3/2P1P3/1P1P1PQ1/P5BP/2BR1R1K b - - 9 23') # opening, play, evals = pgn_prepare() # print(opening) # for move in opening: # board.push_san(move) # sf.position(board) diffs = 0 # diffs1 = [] # evs = [] for j in range(2): # i=0 try: while True: if board.turn == 1: pos = board sf.position(pos) pos.push(sf.go(depth=14)[0]) score = info_handler.info["score"][1].cp # print(info_handler.info["score"]) if info_handler.info["score"][1].mate is not None: break if pos.is_game_over(claim_draw=True) is True: break diffs += score else: pos = board base.position(pos) pos.push(base.go(depth=14)[0]) if info_handler1.info["score"][1].mate is not None: break if pos.is_game_over(claim_draw=True) is True: break # i=i+1 finally: break base.position(board) board.push(base.go(depth=12)[0]) print(diffs) sf.terminate() return diffs
def open_engine_process(self): self.modified_engine = uci.popen_engine(self.modified_file_name) self.info_handler_modified = uci.InfoHandler() self.modified_engine.info_handlers.append(self.info_handler_modified)
def __init__(self): self._engine = uci.popen_engine('stockfish') self._engine.uci()
#Next, I add the desired errors, and voila, it works! #This is inefficient, but I'm not in the mood to extend Keras #Tee-hee-heee training_dict["out"] += np.ravel(current_evals) #print training_dict["out"].shape, all_errors.shape, all_errors model.train_on_batch(training_dict) if __name__ == "__main__": usage = "usage katyushabinaryfile weightsfile positions" if len(argv) < 4: print usage exit(1) katyusha = None try: katyusha = uci.popen_engine(argv[1]) katyusha.uci() except e: print "error initializing engine" print e exit(1) weightsfile = argv[2] temp_npz_file = "temp_td_weights.npz" na.model.load_weights(weightsfile) na.save_as_npz(temp_npz_file) info_handler = uci.InfoHandler() katyusha.info_handlers.append(info_handler) katyusha.setoption({"Katyusha_Learning":True, "weightsfile":temp_npz_file}) pos_file = open(argv[3], "r") fen_arr = np.array([line.strip() for line in pos_file])
def set_up_engine(path=os.path.join(projdir, 'stockfish7')): engine = uci.popen_engine(path) engine.uci() return engine
#This is inefficient, but I'm not in the mood to extend Keras #Tee-hee-heee training_dict["out"] += np.ravel(current_evals) #print training_dict["out"].shape, all_errors.shape, all_errors model.train_on_batch(training_dict) if __name__ == "__main__": usage = "usage katyushabinaryfile weightsfile positions" if len(argv) < 4: print usage exit(1) katyusha = None try: katyusha = uci.popen_engine(argv[1]) katyusha.uci() except e: print "error initializing engine" print e exit(1) weightsfile = argv[2] temp_npz_file = "temp_td_weights.npz" na.model.load_weights(weightsfile) na.save_as_npz(temp_npz_file) info_handler = uci.InfoHandler() katyusha.info_handlers.append(info_handler) katyusha.setoption({ "Katyusha_Learning": True, "weightsfile": temp_npz_file
import chess from chess import uci from sys import argv, exit usage = "usage engine1 engine2" if len(argv) < 3: print usage exit(1) engine1, engine2 = None, None try: engine1, engine2 = uci.popen_engine(argv[1]), uci.popen_engine(argv[2]) engine1.uci() engine2.uci() engine1.info_handlers.append(uci.InfoHandler()) engine2.info_handlers.append(uci.InfoHandler()) except e: print e print "error opening engine binaries" print usage exit(1) def play_game(engine1, engine2): board = chess.Board() info1 = uci.InfoHandler() info2 = uci.InfoHandler() engine1.info_handlers.append(info1) engine2.info_handlers.append(info2) while not board.is_game_over(): engine1.position(board)
def parse_engine_json(jsonfile): obj = json.load(jsonfile) engine = uci.popen_engine("/home/benjamin/Katyusha/" + obj["binary"]) engine.setoption(obj["options"]) engine.description = obj["description"] return engine
def __init__(self): self.eng = uci.popen_engine("/usr/games/stockfish") self.eng.uci()