def coro(): gamemodel = GameModel(TimeModel(1, 0)) player0tup = (LOCAL, Human, (WHITE, "w"), "w") player1tup = (LOCAL, Human, (BLACK, "b"), "b") def on_game_end(game, state, event): event.set() event = asyncio.Event() gamemodel.connect("game_ended", on_game_end, event) def on_players_changed(game): # fill fools mate moves to players move queue p0 = game.players[0] p0.move_queue.put_nowait(Move(newMove(F2, F3))) p0.move_queue.put_nowait(Move(newMove(G2, G4))) p1 = gamemodel.players[1] p1.move_queue.put_nowait(Move(newMove(E7, E5))) p1.move_queue.put_nowait(Move(newMove(D8, H4))) gamemodel.connect("players_changed", on_players_changed) create_task(self.games_persp.generalStart(gamemodel, player0tup, player1tup)) # waiting for game end ... yield from event.wait() fen = "rnb1kbnr/pppp1ppp/8/4p3/6Pq/5P2/PPPPP2P/RNBQKBNR w KQkq - 1 3" self.assertEqual(gamemodel.boards[-1].board.asFen(), fen) # Now save our game to pychess.pgn self.games_persp.saveGamePGN(gamemodel)
def startClicked(self, button): color = self.widgets["colorDock"].get_child().get_active() if color == 2: color = random.choice([WHITE, BLACK]) opp = self.widgets["opponentDock"].get_child() tree_iter = opp.get_active_iter() if tree_iter is not None: model = opp.get_model() engine = model[tree_iter][1] opponent = self.widgets["opponentDock"].get_child().get_active() difficulty = int(self.widgets["skillSlider"].get_value()) gamemodel = GameModel(TimeModel(5 * 60, 0)) name = conf.get("firstName") player0tup = (LOCAL, Human, (color, name), name) if opponent == 0: name = conf.get("secondName") player1tup = (LOCAL, Human, (1 - color, name), name) else: engine = discoverer.getEngineByName(engine) name = discoverer.getName(engine) player1tup = (ARTIFICIAL, discoverer.initPlayerEngine, (engine, 1 - color, difficulty, variants[NORMALCHESS], 5 * 60, 0), name) perspective = perspective_manager.get_perspective("games") if color == WHITE: create_task(perspective.generalStart(gamemodel, player0tup, player1tup)) else: create_task(perspective.generalStart(gamemodel, player1tup, player0tup))
def discover(self): self.pre_discover() def count(self_, name, engine, wentwell): if not wentwell: print("count() not went well on engine", name) self.engines.remove(engine) self.toBeRechecked[name][1] = True if all([elem[1] for elem in self.toBeRechecked.values()]): self.engines.sort(key=lambda x: x["name"]) self.emit("all_engines_discovered") createStoryTextAppEvent("all_engines_discovered") self.connect("engine_discovered", count, True) self.connect("engine_failed", count, False) if self.toBeRechecked: self.emit("discovering_started", self.toBeRechecked.keys()) self.connect("all_engines_discovered", self.save) for engine, done in self.toBeRechecked.values(): if not done: create_task(self.__discoverE(engine)) else: self.emit("all_engines_discovered") createStoryTextAppEvent("all_engines_discovered")
def putMessage(self, message): def answer(message): try: data = (urlopen( "https://www.pandorabots.com/pandora/talk?botid=8d034368fe360895", urlencode({ "message": message, "botcust2": "x" }).encode("utf-8"), ).read().decode("utf-8")) except IOError as err: log.warning( "Couldn't answer message from online bot: '%s'" % err, extra={"task": self.defname}, ) return sstring = "<b>DMPGirl:</b>" estring = "<br>" answer = data[data.find(sstring) + len(sstring):data.find(estring, data.find(sstring))] self.emit("offer", Offer(CHAT_ACTION, answer)) @asyncio.coroutine def get_answer(message): loop = asyncio.get_event_loop() future = loop.run_in_executor(None, answer, message) yield from future create_task(get_answer(message))
def onHelperConnectionError(self, connection, error): if self.helperconn is not None: dialog = Gtk.MessageDialog(mainwindow(), type=Gtk.MessageType.QUESTION, buttons=Gtk.ButtonsType.YES_NO) dialog.set_markup(_("Guest logins disabled by FICS server")) text = "PyChess can maintain users status and games list only if it changes\n\ 'open', 'gin' and 'availinfo' user variables.\n\ Do you enable to set these variables on?" dialog.format_secondary_text(text) response = dialog.run() dialog.destroy() self.helperconn.cancel() self.helperconn.close() self.helperconn = None set_user_vars = response == Gtk.ResponseType.YES @asyncio.coroutine def coro(): yield from self.main_connected_event.wait() self.connection.start_helper_manager(set_user_vars) create_task(coro())
def discover(self): self.pre_discover() def count(self_, name, engine, wentwell): if not wentwell: print("cout not wentwell on engine", name) self.engines.remove(engine) self.toBeRechecked[name][1] = True if all([elem[1] for elem in self.toBeRechecked.values()]): self.engines.sort(key=lambda x: x["name"]) self.emit("all_engines_discovered") createStoryTextAppEvent("all_engines_discovered") self.connect("engine_discovered", count, True) self.connect("engine_failed", count, False) if self.toBeRechecked: self.emit("discovering_started", self.toBeRechecked.keys()) self.connect("all_engines_discovered", self.save) for engine, done in self.toBeRechecked.values(): if not done: create_task(self.__discoverE(engine)) else: self.emit("all_engines_discovered") createStoryTextAppEvent("all_engines_discovered")
def onGamePreview(self, adm, ficsgame): log.debug("Archived panel onGamePreview: %s" % ficsgame) timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc) gamemodel = ICGameModel(self.connection, ficsgame, timemodel) # The players need to start listening for moves IN this method if they # want to be noticed of all moves the FICS server sends us from now on. # Hence the lazy loading is skipped. wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer player0tup = (REMOTE, ICPlayer, (gamemodel, wplayer.name, -1, WHITE, wplayer.long_name(), wplayer.getRatingByGameType(ficsgame.game_type)), wplayer.long_name()) player1tup = (REMOTE, ICPlayer, (gamemodel, bplayer.name, -1, BLACK, bplayer.long_name(), bplayer.getRatingByGameType(ficsgame.game_type)), bplayer.long_name()) perspective = perspective_manager.get_perspective("games") create_task( perspective.generalStart( gamemodel, player0tup, player1tup, (StringIO(ficsgame.board.pgn), pgn, 0, -1))) gamemodel.connect("game_started", self.on_game_start, ficsgame)
def row_activated(self, widget, path, col): rec, ply = self.get_record(path) if rec is None: return # Enable unfinished games to continue from newgamedialog if rec["Result"] not in UNDOABLE_STATES: newGameDialog.EnterNotationExtension.run() model = self.persp.chessfile.loadToModel(rec) text = pgn.save(StringIO(), model) newGameDialog.EnterNotationExtension.sourcebuffer.set_text(text) return self.gamemodel = GameModel() variant = rec["Variant"] if variant: self.gamemodel.tags["Variant"] = variant # Lichess exports study .pgn without White and Black tags wp = "" if rec["White"] is None else rec["White"] bp = "" if rec["Black"] is None else rec["Black"] p0 = (LOCAL, Human, (WHITE, wp), wp) p1 = (LOCAL, Human, (BLACK, bp), bp) self.persp.chessfile.loadToModel(rec, -1, self.gamemodel) self.gamemodel.endstatus = (self.gamemodel.status if self.gamemodel.status in UNDOABLE_STATES else None) self.gamemodel.status = WAITING_TO_START perspective_manager.activate_perspective("games") perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(self.gamemodel, p0, p1))
def start(self): def coro(): self.emit("game_started") while True: player0, player1 = yield from self.curplayer.make_move() if isinstance(player0, SetupMove): # print(player0.cord0, player0.cord1, player1) new_board = self.boards[-1].move(player0, player1) self.moves.append(player0) self.boards.append(new_board) self.emit("game_changed", self.ply) elif player0 == "SETUP": # print("SETUP", player0, player1) self.emit("game_ended", 0) self.boards = [self.variant(setup=player1)] self.variations = [self.boards] self.emit("game_loaded", 0) self.emit("game_started") self.emit("game_changed", 0) elif player0 == "CLOSE": # print("CLOSE") break create_task(coro())
def on_close_clicked(self, button): @asyncio.coroutine def coro(): altpath = getEngineDataPrefix() if pgn.scoutfish_path is None and conf.get("download_scoutfish"): binary = "https://github.com/pychess/scoutfish/releases/download/20170627/%s" % pgn.scoutfish filename = yield from download_file_async(binary) if filename is not None: dest = shutil.move(filename, os.path.join(altpath, pgn.scoutfish)) os.chmod(dest, stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE) pgn.scoutfish_path = dest if pgn.chess_db_path is None and conf.get("download_chess_db"): binary = "https://github.com/pychess/chess_db/releases/download/20170627/%s" % pgn.parser filename = yield from download_file_async(binary) if filename is not None: dest = shutil.move(filename, os.path.join(altpath, pgn.parser)) os.chmod(dest, stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE) pgn.chess_db_path = dest if TimeSeal.timestamp_path is None and conf.get("download_timestamp"): binary = "http://download.chessclub.com.s3.amazonaws.com/timestamp/%s" % TimeSeal.timestamp filename = yield from download_file_async(binary) if filename is not None: dest = shutil.move(filename, os.path.join(altpath, TimeSeal.timestamp)) os.chmod(dest, stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE) TimeSeal.timestamp_path = dest create_task(coro()) self.window.emit("delete-event", None)
def start_endgame_from(pieces): fen = create_fen(pieces) timemodel = TimeModel(0, 0) gamemodel = LearnModel(timemodel) gamemodel.set_learn_data(ENDGAME, pieces) player_name = conf.get("firstName") p0 = (LOCAL, Human, (WHITE, player_name), player_name) engine = discoverer.getEngineByName(discoverer.getEngineLearn()) ponder_off = True engine_name = discoverer.getName(engine) p1 = (ARTIFICIAL, discoverer.initPlayerEngine, (engine, BLACK, 20, variants[NORMALCHESS], 60, 0, 0, ponder_off), engine_name) def restart_analyzer(gamemodel): create_task(gamemodel.restart_analyzer(HINT)) gamemodel.connect("learn_success", restart_analyzer) def on_game_started(gamemodel): perspective.activate_panel("annotationPanel") create_task(gamemodel.start_analyzer(HINT, force_engine=discoverer.getEngineLearn())) gamemodel.connect("game_started", on_game_started) perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(gamemodel, p0, p1, loaddata=(StringIO(fen), fen_loader, 0, -1)))
def on_game_started(gamemodel, name, color): perspective.activate_panel("annotationPanel") create_task( gamemodel.start_analyzer(HINT, force_engine=discoverer.getEngineLearn())) gamemodel.players[1 - color].name = name gamemodel.emit("players_changed")
def do_startup(self): Gtk.Application.do_startup(self) if self.purge_recent: items = recent_manager.get_items() for item in items: uri = item.get_uri() if item.get_application_info("pychess"): recent_manager.remove_item(uri) self.git_rev = "" self.initGlade(self.log_viewer) self.addPerspectives() self.handleArgs(self.chess_file) if self.version_check: create_task(checkversion()) self.loaded_cids = {} self.saved_cids = {} self.terminated_cids = {} log.info("PyChess %s %s git %s" % (VERSION_NAME, VERSION, self.git_rev)) log.info("Command line args: '%s'" % self.chess_file) log.info("Platform: %s" % platform.platform()) log.info("Python version: %s.%s.%s" % sys.version_info[0:3]) log.info("Pyglib version: %s.%s.%s" % GLib.pyglib_version) log.info("Gtk version: %s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()))
def startClicked(self, button): color = self.widgets["colorDock"].get_child().get_active() if color == 2: color = random.choice([WHITE, BLACK]) opp = self.widgets["opponentDock"].get_child() tree_iter = opp.get_active_iter() if tree_iter is not None: model = opp.get_model() engine = model[tree_iter][1] opponent = self.widgets["opponentDock"].get_child().get_active() difficulty = int(self.widgets["skillSlider"].get_value()) gamemodel = GameModel(TimeModel(5 * 60, 0)) name = conf.get("firstName") player0tup = (LOCAL, Human, (color, name), name) if opponent == 0: name = conf.get("secondName") player1tup = (LOCAL, Human, (1 - color, name), name) else: engine = discoverer.getEngineByName(engine) name = discoverer.getName(engine) player1tup = (ARTIFICIAL, discoverer.initPlayerEngine, (engine, 1 - color, difficulty, variants[NORMALCHESS], 5 * 60, 0), name) perspective = perspective_manager.get_perspective("games") if color == WHITE: create_task( perspective.generalStart(gamemodel, player0tup, player1tup)) else: create_task( perspective.generalStart(gamemodel, player1tup, player0tup))
def anal_combo_set_value(combobox, value, show_arrow_check, analyzer_type): engine = discoverer.getEngineByMd5(value) if engine is None: combobox.set_active(0) # This return saves us from the None-engine being used # in later code -Jonas Thiem return else: try: index = list(discoverer.getAnalyzers()).index(engine) except ValueError: index = 0 combobox.set_active(index) from pychess.widgets.gamewidget import widgets perspective = perspective_manager.get_perspective("games") for gmwidg in perspective.gamewidgets: spectators = gmwidg.gamemodel.spectators md5 = engine.get('md5') if analyzer_type in spectators and \ spectators[analyzer_type].md5 != md5: gmwidg.gamemodel.remove_analyzer(analyzer_type) create_task(gmwidg.gamemodel.start_analyzer(analyzer_type)) if not widgets[show_arrow_check].get_active(): gmwidg.gamemodel.pause_analyzer(analyzer_type)
def do_startup(self): Gtk.Application.do_startup(self) if self.purge_recent: items = recent_manager.get_items() for item in items: uri = item.get_uri() if item.get_application_info("pychess"): recent_manager.remove_item(uri) self.git_rev = "" self.initGlade(self.log_viewer) self.addPerspectives() self.handleArgs(self.chess_file) create_task(checkversion()) self.loaded_cids = {} self.saved_cids = {} self.terminated_cids = {} log.info("PyChess %s %s git %s" % (VERSION_NAME, VERSION, self.git_rev)) log.info("Command line args: '%s'" % self.chess_file) log.info("Platform: %s" % platform.platform()) log.info("Python version: %s.%s.%s" % sys.version_info[0:3]) log.info("Pyglib version: %s.%s.%s" % GLib.pyglib_version) log.info("Gtk version: %s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()))
def onObserveGameCreated(self, bm, ficsgame): log.debug("FICS.onObserveGameCreated: %s" % ficsgame) timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc) gamemodel = ICGameModel(self.connection, ficsgame, timemodel) gamemodel.connect("game_started", self.onGameModelStarted, ficsgame) # The players need to start listening for moves IN this method if they # want to be noticed of all moves the FICS server sends us from now on wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer player0tup = ( REMOTE, ICPlayer, ( gamemodel, wplayer.name, ficsgame.gameno, WHITE, wplayer.long_name(), wplayer.getRatingForCurrentGame(), ), wplayer.long_name(), ) player1tup = ( REMOTE, ICPlayer, ( gamemodel, bplayer.name, ficsgame.gameno, BLACK, bplayer.long_name(), bplayer.getRatingForCurrentGame(), ), bplayer.long_name(), ) perspective = perspective_manager.get_perspective("games") create_task( perspective.generalStart( gamemodel, player0tup, player1tup, (StringIO(ficsgame.board.pgn), pgn, 0, -1), )) if ficsgame.relation == IC_POS_OBSERVING_EXAMINATION: if 1: # int(self.connection.lvm.variablesBackup["kibitz"]) == 0: self.connection.cm.whisper( _("You have to set kibitz on to see bot messages here.")) self.connection.fm.finger(bplayer.name) self.connection.fm.finger(wplayer.name) elif ficsgame.relation == IC_POS_EXAMINATING: gamemodel.examined = True if not self.connection.ICC: allob = "allob " + str(ficsgame.gameno) gamemodel.connection.client.run_command(allob)
def load(self, persp): self.persp = persp self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.tv = Gtk.TreeView() renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_("Title"), renderer, text=1) self.tv.append_column(column) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_("Source"), renderer, text=2) self.tv.append_column(column) renderer = Gtk.CellRendererProgress() column = Gtk.TreeViewColumn(_("Progress"), renderer, text=3, value=4) column.set_expand(True) self.tv.append_column(column) renderer = Gtk.CellRendererPixbuf() column = Gtk.TreeViewColumn(_("Reset"), renderer, icon_name=5) column.set_name(COLUMN_ROW_RESET) self.tv.append_column(column) self.tv.connect("row-activated", self.row_activated) def on_progress_updated(solving_progress, key, progress): for i, row in enumerate(self.store): if row[0] == key: progress_ratio_string, percent, reset_icon = self._compute_progress_info(progress) treeiter = self.store.get_iter(Gtk.TreePath(i)) self.store[treeiter][3] = progress_ratio_string self.store[treeiter][4] = percent self.store[treeiter][5] = reset_icon solving_progress.connect("progress_updated", on_progress_updated) self.store = Gtk.ListStore(str, str, str, str, int, str) @asyncio.coroutine def coro(): for file_name, title, author in entries: progress = solving_progress.get(file_name) progress_ratio_string, percent, reset_icon = self._compute_progress_info(progress) self.store.append([file_name, title, author, progress_ratio_string, percent, reset_icon]) yield from asyncio.sleep(0) create_task(coro()) self.tv.set_model(self.store) self.tv.get_selection().set_mode(Gtk.SelectionMode.BROWSE) self.tv.set_cursor(conf.get("learncombo%s" % learn_category_id)) scrollwin = Gtk.ScrolledWindow() scrollwin.add(self.tv) scrollwin.show_all() self.box.pack_start(scrollwin, True, True, 0) self.box.show_all() return self.box
def setOptionInitialBoard(self, model): @asyncio.coroutine def coro(): yield from self.ready_moves_event.wait() # We don't use the optionQueue here, as set board prints a whole lot of # stuff. Instead we just call it. self.setBoardList(model.boards[:], model.moves[:]) create_task(coro())
def learn_success(gamemodel): gamemodel.scores = {} chessfile.loadToModel(rec, -1, gamemodel) progress = lessons_solving_progress[gamemodel.source] progress[gamemodel.current_index] = 1 lessons_solving_progress[gamemodel.source] = progress if "FEN" in gamemodel.tags: create_task(gamemodel.restart_analyzer(HINT))
def loadPgnAndRun(data): if data in [None, '']: return False perspective = perspective_manager.get_perspective("games") p0 = (LOCAL, Human, (WHITE, _("White")), _("White")) p1 = (LOCAL, Human, (BLACK, _("Black")), _("Black")) create_task(perspective.generalStart(GameModel(), p0, p1, (StringIO(data), enddir['pgn'], 0, -1))) return True
def on_subprocess(self, action, param): proc = SubProcess("python", [ os.path.expanduser("~") + "/pychess/lib/pychess/Players/PyChess.py", ]) create_task(self.parse_line(proc)) print("xboard", file=proc) print("protover 2", file=proc)
def start_puzzle_game(gamemodel, filename, records, index, rec, from_lesson=False): gamemodel.set_learn_data(PUZZLE, filename, index, len(records), from_lesson=from_lesson) engine = discoverer.getEngineByName(discoverer.getEngineLearn()) ponder_off = True color = gamemodel.boards[0].color w_name = "" if rec["White"] is None else rec["White"] b_name = "" if rec["Black"] is None else rec["Black"] player_name = conf.get("firstName") engine_name = discoverer.getName(engine) if rec["Event"].startswith("Lichess Practice"): w_name = player_name if color == WHITE else engine_name b_name = engine_name if color == WHITE else player_name opp_name = engine_name if rec["Event"].startswith("Lichess Practice") else b_name if color == WHITE: p0 = (LOCAL, Human, (WHITE, w_name), w_name) p1 = (ARTIFICIAL, discoverer.initPlayerEngine, (engine, BLACK, 20, variants[NORMALCHESS], 20, 0, 0, ponder_off), b_name) else: p0 = (ARTIFICIAL, discoverer.initPlayerEngine, (engine, WHITE, 20, variants[NORMALCHESS], 20, 0, 0, ponder_off), w_name) p1 = (LOCAL, Human, (BLACK, b_name), b_name) def on_game_started(gamemodel, name, color): perspective.activate_panel("annotationPanel") create_task(gamemodel.start_analyzer(HINT, force_engine=discoverer.getEngineLearn())) gamemodel.players[1 - color].name = name gamemodel.emit("players_changed") gamemodel.connect("game_started", on_game_started, opp_name, color) def goal_checked(gamemodle): if gamemodel.reason == PRACTICE_GOAL_REACHED: if from_lesson: progress = lessons_solving_progress[gamemodel.source] else: progress = puzzles_solving_progress[gamemodel.source] progress[gamemodel.current_index] = 1 if from_lesson: lessons_solving_progress[gamemodel.source] = progress else: puzzles_solving_progress[gamemodel.source] = progress gamemodel.connect("goal_checked", goal_checked) gamemodel.variant.need_initial_board = True gamemodel.status = WAITING_TO_START perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(gamemodel, p0, p1))
def setBoard(self, board, search=True): def coro(): if self.engineIsAnalyzing: self.__stop_analyze() yield from asyncio.sleep(0.1) self.setBoardList([board], []) if search: self.__sendAnalyze(self.mode == INVERSE_ANALYZING) create_task(coro())
def coro(): def on_all_engines_discovered(discoverer, event): event.set() event = asyncio.Event() discoverer.connect("all_engines_discovered", on_all_engines_discovered, event) create_task(dd.start()) yield from event.wait()
def start(self): assert not self.subproc if sys.platform == "win32": args = ["-t", self.host] else: args = ["-i10", self.host] self.subproc = SubProcess(shutil.which("ping"), args, env={"LANG": "en"}) create_task(self.subproc.start()) self.conid1 = self.subproc.connect("line", self.__handleLines) self.conid2 = self.subproc.connect("died", self.__handleDead)
def load(self, persp): self.persp = persp self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) self.tv = Gtk.TreeView() renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_("Title"), renderer, text=1) self.tv.append_column(column) renderer = Gtk.CellRendererText() column = Gtk.TreeViewColumn(_("Source"), renderer, text=2) self.tv.append_column(column) renderer = Gtk.CellRendererProgress() column = Gtk.TreeViewColumn(_("Progress"), renderer, text=3, value=4) self.tv.append_column(column) self.tv.connect("row-activated", self.row_activated) def on_progress_updated(solving_progress, key, progress): for i, row in enumerate(self.store): if row[0] == key: solved = progress.count(1) percent = 0 if not solved else round((solved * 100.) / len(progress)) treeiter = self.store.get_iter(Gtk.TreePath(i)) self.store[treeiter][3] = "%s / %s" % (solved, len(progress)) self.store[treeiter][4] = percent puzzles_solving_progress.connect("progress_updated", on_progress_updated) self.store = Gtk.ListStore(str, str, str, str, int) @asyncio.coroutine def coro(): for file_name, title, author in PUZZLES: progress = puzzles_solving_progress.get(file_name) solved = progress.count(1) percent = 0 if not solved else round((solved * 100.) / len(progress)) self.store.append([file_name, title, author, "%s / %s" % (solved, len(progress)), percent]) yield from asyncio.sleep(0) create_task(coro()) self.tv.set_model(self.store) self.tv.get_selection().set_mode(Gtk.SelectionMode.BROWSE) self.tv.set_cursor(conf.get("learncombo%s" % PUZZLE)) scrollwin = Gtk.ScrolledWindow() scrollwin.add(self.tv) scrollwin.show_all() self.box.pack_start(scrollwin, True, True, 0) self.box.show_all() return self.box
def start(self): if self.finished: self.close() # let dialog window draw itself yield from asyncio.sleep(0.1) create_task(self.all_whatcher()) create_task(self.discovered_whatcher()) self.discoverer.discover()
async def coro(): def on_all_engines_discovered(discoverer, event): event.set() event = asyncio.Event() discoverer.connect("all_engines_discovered", on_all_engines_discovered, event) create_task(dd.start()) await event.wait()
def loadFileAndRun(uri): parts = splitUri(uri) uri = parts[1] if len(parts) == 2 else parts[0] loader = enddir[uri[uri.rfind(".") + 1:]] timemodel = TimeModel(0, 0) gamemodel = GameModel(timemodel) white_name = _("White") black_name = _("Black") p0 = (LOCAL, Human, (WHITE, white_name), white_name) p1 = (LOCAL, Human, (BLACK, black_name), black_name) perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(gamemodel, p0, p1, (uri, loader, 0, -1)))
def on_invanalyzer_check_toggled(check): self.widgets["inv_analyzers_vbox"].set_sensitive(check.get_active()) perspective = perspective_manager.get_perspective("games") if len(perspective.gamewidgets) != 0: if check.get_active(): for gmwidg in perspective.gamewidgets: create_task(gmwidg.gamemodel.restart_analyzer(SPY)) if not widgets["spy_mode"].get_active(): gmwidg.gamemodel.pause_analyzer(SPY) else: for gmwidg in perspective.gamewidgets: gmwidg.gamemodel.remove_analyzer(SPY)
def on_analyzer_check_toggled(check): self.widgets["analyzers_vbox"].set_sensitive(check.get_active()) from pychess.widgets.gamewidget import widgets perspective = perspective_manager.get_perspective("games") if len(perspective.gamewidgets) != 0: if check.get_active(): for gmwidg in perspective.gamewidgets: create_task(gmwidg.gamemodel.restart_analyzer(HINT)) if not widgets["hint_mode"].get_active(): gmwidg.gamemodel.pause_analyzer(HINT) else: for gmwidg in perspective.gamewidgets: gmwidg.gamemodel.remove_analyzer(HINT)
def loadFileAndRun(uri): parts = splitUri(uri) uri = parts[1] if len(parts) == 2 else parts[0] loader = enddir[uri[uri.rfind(".") + 1:]] timemodel = TimeModel(0, 0) gamemodel = GameModel(timemodel) white_name = _("White") black_name = _("Black") p0 = (LOCAL, Human, (WHITE, white_name), white_name) p1 = (LOCAL, Human, (BLACK, black_name), black_name) perspective = perspective_manager.get_perspective("games") create_task( perspective.generalStart(gamemodel, p0, p1, (uri, loader, 0, -1)))
def onConnectClicked(self, button): self.canceled = False self.widgets["messagePanel"].hide() if self.widgets["logOnAsGuest"].get_active(): username = self.widgets["nameEntry"].get_text() password = "" else: username = self.widgets["nameEntry"].get_text() password = self.widgets["passEntry"].get_text() if port: ports = (port, ) else: ports = self.widgets["portsEntry"].get_text() ports = list(map(int, re.findall("\d+", ports))) if 5000 not in ports: ports.append(5000) if 23 not in ports: ports.append(23) alternate_host = self.widgets["hostEntry"].get_text() timeseal = self.widgets["timesealCheck"].get_active() self.showConnecting() self.host = (host if host is not None else alternate_host if alternate_host else "freechess.org") self.connection = FICSMainConnection(self.host, ports, timeseal, username, password) for signal, callback in ( ("connected", self.onConnected), ("error", self.onConnectionError), ("connectingMsg", self.showMessage), ): self.cids[self.connection].append( self.connection.connect(signal, callback)) self.main_connected_event = asyncio.Event() self.connection_task = create_task(self.connection.start()) # guest users are rather limited on ICC (helper connection is useless) if self.host not in ("localhost", "127.0.0.1", "chessclub.com"): self.helperconn = FICSHelperConnection(self.connection, self.host, ports, timeseal) self.helperconn.connect("error", self.onHelperConnectionError) @asyncio.coroutine def coro(): yield from self.main_connected_event.wait() yield from self.helperconn.start() self.helperconn_task = create_task(coro())
def onPlayGameCreated(self, bm, ficsgame): log.debug("FICS.onPlayGameCreated: %s" % ficsgame) for message in self.messages: message.dismiss() del self.messages[:] if self.connection.ICC: for button in self.quick_seek_buttons: button.set_active(False) timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc) gamemodel = ICGameModel(self.connection, ficsgame, timemodel) gamemodel.connect("game_started", self.onGameModelStarted, ficsgame) wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer # We start if wplayer.name.lower() == self.connection.getUsername().lower(): player0tup = (LOCAL, Human, (WHITE, wplayer.long_name(), wplayer.name, wplayer.getRatingForCurrentGame()), wplayer.long_name()) player1tup = (REMOTE, ICPlayer, (gamemodel, bplayer.name, ficsgame.gameno, BLACK, bplayer.long_name(), bplayer.getRatingForCurrentGame()), bplayer.long_name()) # She starts else: player1tup = (LOCAL, Human, (BLACK, bplayer.long_name(), bplayer.name, bplayer.getRatingForCurrentGame()), bplayer.long_name()) player0tup = (REMOTE, ICPlayer, (gamemodel, wplayer.name, ficsgame.gameno, WHITE, wplayer.long_name(), wplayer.getRatingForCurrentGame()), wplayer.long_name()) perspective = perspective_manager.get_perspective("games") if not ficsgame.board.fen: create_task( perspective.generalStart(gamemodel, player0tup, player1tup)) else: create_task( perspective.generalStart( gamemodel, player0tup, player1tup, (StringIO(ficsgame.board.fen), fen, 0, -1)))
def putMove(self, board1, move, board2): """ Sends the engine the last move made (for spectator engines). @param board1: The current board @param move: The last move made @param board2: The board before the last move was made """ def coro(): if self.engineIsAnalyzing: self.__stop_analyze() yield from asyncio.sleep(0.1) self.setBoardList([board1], []) if not self.analyzing_paused: self.__sendAnalyze(self.mode == INVERSE_ANALYZING) create_task(coro())
def game_ended(self, game): if game in self: if not game.move_queue.empty(): async def coro(game): # we have to give a chance to ICPlayer # to process the latest move(style12) message # and remove game from game list panel also await asyncio.sleep(0) game = self[game] self.emit("FICSGameEnded", game) del self[game] create_task(coro(game)) else: game = self[game] self.emit("FICSGameEnded", game) del self[game]
def onPlayGameCreated(self, bm, ficsgame): log.debug("FICS.onPlayGameCreated: %s" % ficsgame) for message in self.messages: message.dismiss() del self.messages[:] if self.connection.ICC: for button in self.quick_seek_buttons: button.set_active(False) timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc) gamemodel = ICGameModel(self.connection, ficsgame, timemodel) gamemodel.connect("game_started", self.onGameModelStarted, ficsgame) wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer # We start if wplayer.name.lower() == self.connection.getUsername().lower(): player0tup = (LOCAL, Human, (WHITE, wplayer.long_name(), wplayer.name, wplayer.getRatingForCurrentGame()), wplayer.long_name()) player1tup = (REMOTE, ICPlayer, ( gamemodel, bplayer.name, ficsgame.gameno, BLACK, bplayer.long_name(), bplayer.getRatingForCurrentGame()), bplayer.long_name()) # She starts else: player1tup = (LOCAL, Human, (BLACK, bplayer.long_name(), bplayer.name, bplayer.getRatingForCurrentGame()), bplayer.long_name()) player0tup = (REMOTE, ICPlayer, ( gamemodel, wplayer.name, ficsgame.gameno, WHITE, wplayer.long_name(), wplayer.getRatingForCurrentGame()), wplayer.long_name()) perspective = perspective_manager.get_perspective("games") if not ficsgame.board.fen: create_task(perspective.generalStart(gamemodel, player0tup, player1tup)) else: create_task(perspective.generalStart(gamemodel, player0tup, player1tup, ( StringIO(ficsgame.board.fen), fen, 0, -1)))
def onConnectClicked(self, button): self.canceled = False self.widgets["messagePanel"].hide() if self.widgets["logOnAsGuest"].get_active(): username = self.widgets["nameEntry"].get_text() password = "" else: username = self.widgets["nameEntry"].get_text() password = self.widgets["passEntry"].get_text() if port: ports = (port, ) else: ports = self.widgets["portsEntry"].get_text() ports = list(map(int, re.findall("\d+", ports))) if 5000 not in ports: ports.append(5000) if 23 not in ports: ports.append(23) alternate_host = self.widgets["hostEntry"].get_text() timeseal = self.widgets["timesealCheck"].get_active() self.showConnecting() self.host = host if host is not None else alternate_host if alternate_host else "freechess.org" self.connection = FICSMainConnection(self.host, ports, timeseal, username, password) for signal, callback in (("connected", self.onConnected), ("error", self.onConnectionError), ("connectingMsg", self.showMessage)): self.cids[self.connection].append(self.connection.connect(signal, callback)) self.main_connected_event = asyncio.Event() self.connection_task = create_task(self.connection.start()) # guest users are rather limited on ICC (helper connection is useless) if self.host not in ("localhost", "127.0.0.1", "chessclub.com"): self.helperconn = FICSHelperConnection(self.connection, self.host, ports, timeseal) self.helperconn.connect("error", self.onHelperConnectionError) @asyncio.coroutine def coro(): yield from self.main_connected_event.wait() yield from self.helperconn.start() self.helperconn_task = create_task(coro())
def onKibitzMessage(self, cm, name, gameno, text): @asyncio.coroutine def coro(): if not self.gmwidg_ready.is_set(): yield from self.gmwidg_ready.wait() if gameno != self.ficsgame.gameno: return self.emit("message_received", name, text) self.kibitz_task = create_task(coro())
def start_lesson_game(gamemodel, filename, chessfile, records, index, rec): gamemodel.set_learn_data(LESSON, filename, index, len(records)) # Lichess doesn't export some study data to .pgn like # Orientation, Analysis mode, Chapter pinned comment, move hint comments, general fail comment if filename.startswith("lichess_study_beta-lichess-practice-checkmating-with-a-knight-and-bishop"): if index in (4, 6, 8, 9): gamemodel.tags["Orientation"] = "White" print(index, '[Orientation "White"]') color = gamemodel.boards[0].color player_name = conf.get("firstName") w_name = player_name if color == WHITE else "PyChess" b_name = "PyChess" if color == WHITE else player_name p0 = (LOCAL, Human, (WHITE, w_name), w_name) p1 = (LOCAL, Human, (BLACK, b_name), b_name) def learn_success(gamemodel): gamemodel.scores = {} chessfile.loadToModel(rec, -1, gamemodel) progress = lessons_solving_progress[gamemodel.source] progress[gamemodel.current_index] = 1 lessons_solving_progress[gamemodel.source] = progress if "FEN" in gamemodel.tags: create_task(gamemodel.restart_analyzer(HINT)) gamemodel.connect("learn_success", learn_success) def on_game_started(gamemodel): perspective.activate_panel("annotationPanel") if "FEN" in gamemodel.tags: create_task(gamemodel.start_analyzer(HINT, force_engine=discoverer.getEngineLearn())) gamemodel.connect("game_started", on_game_started) gamemodel.status = WAITING_TO_START perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(gamemodel, p0, p1))
def createRematch(gamemodel): """ If gamemodel contains only LOCAL or ARTIFICIAL players, this starts a new game, based on the info in gamemodel """ if gamemodel.timed: secs = gamemodel.timemodel.intervals[0][WHITE] gain = gamemodel.timemodel.gain moves = gamemodel.timemodel.moves else: secs = 0 gain = 0 moves = 0 newgamemodel = GameModel(TimeModel(secs, gain), variant=gamemodel.variant) wp = gamemodel.players[WHITE] bp = gamemodel.players[BLACK] if wp.__type__ == LOCAL: player1tup = (wp.__type__, wp.__class__, (BLACK, repr(wp)), repr(wp)) if bp.__type__ == LOCAL: player0tup = (bp.__type__, bp.__class__, (WHITE, repr(wp)), repr(bp)) else: engine = discoverer.getEngineByMd5(bp.md5) player0tup = (ARTIFICIAL, discoverer.initPlayerEngine, (engine, WHITE, bp.strength, gamemodel.variant, secs, gain, moves), repr(bp)) else: player0tup = (bp.__type__, bp.__class__, (WHITE, repr(bp)), repr(bp)) engine = discoverer.getEngineByMd5(wp.md5) player1tup = (ARTIFICIAL, discoverer.initPlayerEngine, (engine, BLACK, wp.strength, gamemodel.variant, secs, gain), repr(wp)) perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(newgamemodel, player0tup, player1tup))
def row_activated(self, widget, path, col): rec, ply = self.get_record(path) if rec is None: return self.gamemodel = GameModel() variant = rec["Variant"] if variant: self.gamemodel.tags["Variant"] = variant # Lichess exports study .pgn without White and Black tags wp = "" if rec["White"] is None else rec["White"] bp = "" if rec["Black"] is None else rec["Black"] p0 = (LOCAL, Human, (WHITE, wp), wp) p1 = (LOCAL, Human, (BLACK, bp), bp) self.persp.chessfile.loadToModel(rec, -1, self.gamemodel) self.gamemodel.endstatus = self.gamemodel.status if self.gamemodel.status in UNDOABLE_STATES else None self.gamemodel.status = WAITING_TO_START perspective_manager.activate_perspective("games") perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(self.gamemodel, p0, p1))
def onGamePreview(self, adm, ficsgame): log.debug("Archived panel onGamePreview: %s" % ficsgame) timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc) gamemodel = ICGameModel(self.connection, ficsgame, timemodel) # The players need to start listening for moves IN this method if they # want to be noticed of all moves the FICS server sends us from now on. # Hence the lazy loading is skipped. wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer player0tup = (REMOTE, ICPlayer, ( gamemodel, wplayer.name, -1, WHITE, wplayer.long_name(), wplayer.getRatingByGameType(ficsgame.game_type)), wplayer.long_name()) player1tup = (REMOTE, ICPlayer, ( gamemodel, bplayer.name, -1, BLACK, bplayer.long_name(), bplayer.getRatingByGameType(ficsgame.game_type)), bplayer.long_name()) perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(gamemodel, player0tup, player1tup, ( StringIO(ficsgame.board.pgn), pgn, 0, -1))) gamemodel.connect("game_started", self.on_game_start, ficsgame)
def onObserveGameCreated(self, bm, ficsgame): log.debug("FICS.onObserveGameCreated: %s" % ficsgame) timemodel = TimeModel(ficsgame.minutes * 60, ficsgame.inc) gamemodel = ICGameModel(self.connection, ficsgame, timemodel) gamemodel.connect("game_started", self.onGameModelStarted, ficsgame) # The players need to start listening for moves IN this method if they # want to be noticed of all moves the FICS server sends us from now on wplayer, bplayer = ficsgame.wplayer, ficsgame.bplayer player0tup = (REMOTE, ICPlayer, ( gamemodel, wplayer.name, ficsgame.gameno, WHITE, wplayer.long_name(), wplayer.getRatingForCurrentGame()), wplayer.long_name()) player1tup = (REMOTE, ICPlayer, ( gamemodel, bplayer.name, ficsgame.gameno, BLACK, bplayer.long_name(), bplayer.getRatingForCurrentGame()), bplayer.long_name()) perspective = perspective_manager.get_perspective("games") create_task(perspective.generalStart(gamemodel, player0tup, player1tup, ( StringIO(ficsgame.board.pgn), pgn, 0, -1))) if ficsgame.relation == IC_POS_OBSERVING_EXAMINATION: if 1: # int(self.connection.lvm.variablesBackup["kibitz"]) == 0: self.connection.cm.whisper(_( "You have to set kibitz on to see bot messages here.")) self.connection.fm.finger(bplayer.name) self.connection.fm.finger(wplayer.name) elif ficsgame.relation == IC_POS_EXAMINATING: gamemodel.examined = True if not self.connection.ICC: allob = 'allob ' + str(ficsgame.gameno) gamemodel.connection.client.run_command(allob)
def on_game_started(self, gamemodel, gmwidg): # offline lectures can reuse same gamemodel/gamewidget # to show several examples inside the same lecture if gamemodel.offline_lecture: gmwidg.clearMessages() # Rotate to human player boardview = gmwidg.board.view if gamemodel.players[1].__type__ == LOCAL: if gamemodel.players[0].__type__ != LOCAL: boardview.rotation = math.pi if isinstance(gamemodel, LearnModel): if gamemodel.orientation == BLACK: boardview.rotation = math.pi else: boardview.rotation = 0 # Play set-up sound preferencesDialog.SoundTab.playAction("gameIsSetup") # Connect player offers to infobar for player in gamemodel.players: if player.__type__ == LOCAL: self.offer_cids[gamemodel][player] = player.connect( "offer", self.offer_callback, gamemodel, gmwidg) # Start analyzers if any if not gamemodel.isEngine2EngineGame(): create_task(gamemodel.start_analyzer(HINT)) create_task(gamemodel.start_analyzer(SPY)) if not conf.get("hint_mode"): gamemodel.pause_analyzer(HINT) if not conf.get("spy_mode"): gamemodel.pause_analyzer(SPY) return False
def setUp(self): widgets = uistuff.GladeWidgets("PyChess.glade") gamewidget.setWidgets(widgets) perspective_manager.set_widgets(widgets) self.games_persp = Games() perspective_manager.add_perspective(self.games_persp) self.learn_persp = Learn() self.learn_persp.create_toolbuttons() perspective_manager.add_perspective(self.learn_persp) perspective_manager.current_perspective = self.learn_persp dd = DiscovererDialog(discoverer) self.dd_task = create_task(dd.start())