def start(discoverer):
atexit.register(SubProcess.finishAllSubprocesses)
pgnfile, gameno = queryGameno(sys.argv[1])
analyzer = queryAnalyzer(discoverer.getAnalyzers())
secs = queryTime()
name1, name2 = pgnfile.get_player_names(gameno)
print("%s will now analyze the game between %s and %s with %d seconds per move." % \
(discoverer.getName(analyzer), name1, name2, secs))
print()
global game, values
values = {}
game = GameModel()
game.setPlayers([DummyPlayer(), DummyPlayer()])
analyzer = discoverer.initAnalyzerEngine(analyzer, ANALYZING, game.variant)
analyzer.connect('analyze', onAnalyze)
game.spectators[HINT] = analyzer
game.loadAndStart(sys.argv[1], pgn, gameno, -1)
def cb():
if game.ply == game.lowply:
on_finish()
return False
check_blund()
return True
glib.timeout_add_seconds(secs, cb)
def start(discoverer):
atexit.register(SubProcess.finishAllSubprocesses)
pgnfile, gameno = queryGameno(sys.argv[1])
analyzer = queryAnalyzer(discoverer.getAnalyzers())
secs = queryTime()
name1, name2 = pgnfile.get_player_names(gameno)
print("%s will now analyze the game between %s and %s with %d seconds per move." % \
(discoverer.getName(analyzer), name1, name2, secs))
print()
global game, values
values = {}
game = GameModel()
game.setPlayers([DummyPlayer(), DummyPlayer()])
analyzer = discoverer.initAnalyzerEngine(analyzer, ANALYZING, game.variant)
analyzer.connect('analyze', onAnalyze)
game.spectators[HINT] = analyzer
game.loadAndStart(sys.argv[1], pgn, gameno, -1)
def cb():
if game.ply == game.lowply:
on_finish()
return False
check_blund()
return True
GLib.timeout_add_seconds(secs, cb)
def runGame():
a, b = findMatch()
if a == None:
print("All games have now been played. Here are the final scores:")
printResults()
mainloop.quit()
return
current[0] = a
current[1] = b
game = GameModel(TimeModel(minutes * 60, 0))
game.connect('game_started', cb_gamestarted)
game.connect('game_ended', cb_gameended)
p0 = discoverer.initPlayerEngine(engines[a],
WHITE,
8,
variants[NORMALCHESS],
secs=minutes * 60,
incr=0,
forcePonderOff=True)
p1 = discoverer.initPlayerEngine(engines[b],
BLACK,
8,
variants[NORMALCHESS],
secs=minutes * 60,
incr=0,
forcePonderOff=True)
game.setPlayers([p0, p1])
game.start()
def do(discoverer):
game = GameModel(TimeModel(60,0))
#game.connect('game_started', cb_gamestarted2)
game.connect('game_ended', lambda *a: mainloop.quit())
p0 = discoverer.initPlayerEngine(discoverer.getEngines()['rybka'], WHITE, 7, variants[NORMALCHESS], 60)
p1 = discoverer.initPlayerEngine(discoverer.getEngines()['gnuchess'], BLACK, 7, variants[NORMALCHESS], 60)
game.setPlayers([p0,p1])
game.start()
def setPlayers(self, players):
GameModel.setPlayers(self, players)
if self.players[WHITE].icrating:
self.tags["WhiteElo"] = self.players[WHITE].icrating
if self.players[BLACK].icrating:
self.tags["BlackElo"] = self.players[BLACK].icrating
if (self.connection.username == self.ficsplayers[WHITE].name) and self.ficsplayers[WHITE].isGuest():
self.tags["White"] += " (Player)"
self.emit("players_changed")
if (self.connection.username == self.ficsplayers[BLACK].name) and self.ficsplayers[BLACK].isGuest():
self.tags["Black"] += " (Player)"
self.emit("players_changed")
def runGame():
a, b = findMatch()
if a == None:
print("All games have now been played. Here are the final scores:")
printResults()
mainloop.quit()
return
current[0] = a
current[1] = b
game = GameModel(TimeModel(minutes*60,0))
game.connect('game_started', cb_gamestarted)
game.connect('game_ended', cb_gameended)
p0 = discoverer.initPlayerEngine(engines[a], WHITE, 8, variants[NORMALCHESS], secs=minutes*60, incr=0, forcePonderOff=True)
p1 = discoverer.initPlayerEngine(engines[b], BLACK, 8, variants[NORMALCHESS], secs=minutes*60, incr=0, forcePonderOff=True)
game.setPlayers([p0,p1])
game.start()
def setPlayers(self, players):
GameModel.setPlayers(self, players)
if self.players[WHITE].icrating:
self.tags["WhiteElo"] = self.players[WHITE].icrating
if self.players[BLACK].icrating:
self.tags["BlackElo"] = self.players[BLACK].icrating
def setPlayers (self, players):
GameModel.setPlayers(self, players)
if self.players[WHITE].icrating:
self.tags["WhiteElo"] = self.players[WHITE].icrating
if self.players[BLACK].icrating:
self.tags["BlackElo"] = self.players[BLACK].icrating
class CECPTests(unittest.TestCase):
def setUp(self):
self.engine = discoverer.getEngineByName("PyChess.py")
def test(self):
""" Play PyChess-PyChess 1 min variant games """
if sys.platform == "win32":
from asyncio.windows_events import ProactorEventLoop
loop = ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
for vari in PYCHESS_VARIANTS:
variant = variants[vari]
def coro():
self.p0 = yield from discoverer.initEngine(
self.engine, WHITE, False)
self.p1 = yield from discoverer.initEngine(
self.engine, BLACK, False)
loop.run_until_complete(coro())
def optionsCallback(engine):
engine.setOptionVariant(variant)
engine.setOptionStrength(1, False)
engine.setOptionTime(60, 0, 0)
self.p0.connect("readyForOptions", optionsCallback)
self.p1.connect("readyForOptions", optionsCallback)
@asyncio.coroutine
def coro(variant):
self.game = GameModel(TimeModel(60, 0), variant)
self.game.setPlayers([self.p0, self.p1])
def on_game_end(game, state, event):
event.set()
event = asyncio.Event()
self.game.connect("game_ended", on_game_end, event)
self.p0.prestart()
self.p1.prestart()
if self.game.variant.need_initial_board:
for player in self.game.players:
player.setOptionInitialBoard(self.game)
print(variant.name)
self.game.start()
yield from event.wait()
pgn = StringIO()
print(save(pgn, self.game))
self.assertIsNone(self.p0.invalid_move)
self.assertIsNone(self.p1.invalid_move)
loop.run_until_complete(coro(variant))
class CECPTests(unittest.TestCase):
def setUp(self):
self.engine = discoverer.getEngineByName("PyChess.py")
def test(self):
""" Play PyChess-PyChess 1 min variant games """
if sys.platform == "win32":
from asyncio.windows_events import ProactorEventLoop
loop = ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.SelectorEventLoop()
asyncio.set_event_loop(loop)
loop = asyncio.get_event_loop()
loop.set_debug(enabled=True)
for vari in PYCHESS_VARIANTS:
variant = variants[vari]
def coro():
self.p0 = yield from discoverer.initEngine(self.engine, WHITE, False)
self.p1 = yield from discoverer.initEngine(self.engine, BLACK, False)
loop.run_until_complete(coro())
def optionsCallback(engine):
engine.setOptionVariant(variant)
engine.setOptionStrength(1, False)
engine.setOptionTime(60, 0, 0)
self.p0.connect("readyForOptions", optionsCallback)
self.p1.connect("readyForOptions", optionsCallback)
def coro(variant):
self.game = GameModel(TimeModel(60, 0), variant)
self.game.setPlayers([self.p0, self.p1])
def on_game_end(game, state, event):
event.set()
event = asyncio.Event()
self.game.connect("game_ended", on_game_end, event)
self.p0.prestart()
self.p1.prestart()
if self.game.variant.need_initial_board:
for player in self.game.players:
player.setOptionInitialBoard(self.game)
print(variant.name)
self.game.start()
yield from event.wait()
pgn = StringIO()
print(save(pgn, self.game))
self.assertIsNone(self.p0.invalid_move)
self.assertIsNone(self.p1.invalid_move)
loop.run_until_complete(coro(variant))
def setPlayers(self, players):
if [player.__type__ for player in players] == [REMOTE, REMOTE]:
self.inControl = False
GameModel.setPlayers(self, players)
def setPlayers (self, players):
if [player.__type__ for player in players] == [REMOTE, REMOTE]:
self.inControl = False
GameModel.setPlayers(self, players)
