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)
asyncio.async(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 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 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)
asyncio. async (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 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 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 start_puzzle_from(filename):
chessfile = PGNFile(protoopen(addDataPrefix("lectures/%s" % filename)))
chessfile.limit = 1000
importer = PgnImport(chessfile)
chessfile.init_tag_database(importer)
records, plys = chessfile.get_records()
rec = records[random.randrange(0, len(records))]
timemodel = TimeModel(0, 0)
gamemodel = GameModel(timemodel)
gamemodel.set_practice_game()
gamemodel.practice = ("puzzle", filename)
chessfile.loadToModel(rec, 0, gamemodel)
# TODO: change colors according to FEN!
name = rec["White"]
p0 = (LOCAL, Human, (WHITE, name), name)
engine = discoverer.getEngineByName(stockfish_name)
name = rec["Black"]
ponder_off = True
p1 = (ARTIFICIAL, discoverer.initPlayerEngine,
(engine, BLACK, 20, variants[NORMALCHESS], 60, 0, 0,
ponder_off), name)
def fix_name(gamemodel, name):
asyncio. async (gamemodel.start_analyzer(HINT,
force_engine=stockfish_name))
gamemodel.players[1].name = name
gamemodel.emit("players_changed")
gamemodel.connect("game_started", fix_name, name)
gamemodel.variant.need_initial_board = True
gamemodel.status = WAITING_TO_START
perspective = perspective_manager.get_perspective("games")
asyncio. async (perspective.generalStart(gamemodel, p0, p1))
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))
