def shown_changed(self, board, shown):
self.openings = getOpenings(self.board.model.getBoardAtPly(shown))
self.openings.sort(lambda a, b: sum(b[1:]) - sum(a[1:]))
self.board.bluearrow = None
self.store.clear()
if not self.openings and self.sw.get_child() == self.tv:
self.sw.remove(self.tv)
label = gtk.Label(_("In this position,\nthere is no book move."))
label.set_property("yalign", 0.1)
self.sw.add_with_viewport(label)
self.sw.get_child().set_shadow_type(gtk.SHADOW_NONE)
self.sw.show_all()
return
if self.openings and self.sw.get_child() != self.tv:
self.sw.remove(self.sw.get_child())
self.sw.add(self.tv)
i = 0
for move, wins, draws, loses in self.openings:
games = wins + draws + loses
if not games: continue
wins, draws, loses = \
map(lambda x: x/float(games), (wins, draws, loses))
b = self.board.model.getBoardAtPly(shown)
if conf.get("figuresInNotation", False):
move = toFAN(b, parseSAN(b, move))
else:
move = toSAN(b, parseSAN(b, move), True)
self.store.append([move, str(games), (wins, draws, loses)])
def test_validate(self):
"""Testing validate move in Sittuyin variant"""
board = SittuyinBoard(setup=FEN0)
print(board)
# no promotion if we have Met (queen)
self.assertTrue(validate(board, parseAN(board, 'f4f3')))
self.assertTrue(validate(board, parseAN(board, 'b2b1')))
self.assertTrue(validate(board, parseAN(board, 'b2c1')))
self.assertFalse(validate(board, parseAN(board, 'b2b2f')))
self.assertFalse(validate(board, parseAN(board, 'b2a1f')))
self.assertFalse(validate(board, parseAN(board, 'f4f3f')))
self.assertFalse(validate(board, parseAN(board, 'b2b1f')))
self.assertFalse(validate(board, parseAN(board, 'b2c1f')))
board = SittuyinBoard(setup=FEN1)
print(board)
# but (optional) promotion if we don't have Met (queen)
self.assertTrue(validate(board, parseAN(board, 'b2b2f')))
self.assertTrue(validate(board, parseSAN(board, 'b2=f')))
self.assertEqual(parseAN(board, 'b2b2f'), parseSAN(board, 'b2=f'))
self.assertTrue(validate(board, parseAN(board, 'b2a1f')))
self.assertTrue(validate(board, parseSAN(board, 'a1=f')))
self.assertEqual(parseAN(board, 'b2a1f'), parseSAN(board, 'a1=f'))
self.assertTrue(validate(board, parseAN(board, 'b2c1')))
self.assertTrue(validate(board, parseAN(board, 'f4f3')))
self.assertFalse(validate(board, parseAN(board, 'f4f3f')))
self.assertFalse(validate(board, parseAN(board, 'b2b2')))
self.assertFalse(validate(board, parseAN(board, 'b2b1f')))
self.assertFalse(validate(board, parseAN(board, 'b2c1f')))
def shown_changed (self, board, shown):
self.openings = getOpenings(self.board.model.getBoardAtPly(shown))
self.openings.sort(lambda a, b: sum(b[1:])-sum(a[1:]))
self.board.bluearrow = None
self.store.clear()
if not self.openings and self.sw.get_child() == self.tv:
self.sw.remove(self.tv)
label = gtk.Label(_("In this position,\nthere is no book move."))
label.set_property("yalign",0.1)
self.sw.add_with_viewport(label)
self.sw.get_child().set_shadow_type(gtk.SHADOW_NONE)
self.sw.show_all()
return
if self.openings and self.sw.get_child() != self.tv:
self.sw.remove(self.sw.get_child())
self.sw.add(self.tv)
i = 0
for move, wins, draws, loses in self.openings:
games = wins+draws+loses
if not games: continue
wins, draws, loses = \
map(lambda x: x/float(games), (wins, draws, loses))
b = self.board.model.getBoardAtPly(shown)
if conf.get("figuresInNotation", False):
move = toFAN(b, parseSAN(b, move))
else:
move = toSAN(b, parseSAN(b, move), True)
self.store.append ([move, str(games), (wins,draws,loses)])
def test_getstatus2(self):
"""Testing bare white king is not draw in Atomic variant"""
board = AtomicBoard(setup=FEN3)
self.assertTrue(not validate(board, parseSAN(board, 'Kxg7')))
self.assertTrue(not validate(board, parseSAN(board, 'Kg8')))
self.assertTrue(not validate(board, parseSAN(board, 'Kh7')))
print(board)
self.assertEqual(getStatus(board), (DRAW, DRAW_STALEMATE))
def test_getstatus2(self):
"""Testing bare white king is not draw in Atomic variant"""
board = AtomicBoard(setup=FEN3)
self.assertTrue(not validate(board, parseSAN(board, 'Kxg7')))
self.assertTrue(not validate(board, parseSAN(board, 'Kg8')))
self.assertTrue(not validate(board, parseSAN(board, 'Kh7')))
print(board)
self.assertEqual(getStatus(board), (DRAW, DRAW_STALEMATE))
def test_validate(self):
"""Testing validate move in Crazyhouse variant"""
board = CrazyhouseBoard(setup=FEN0)
print(board)
# Drop can save mate
self.assertTrue(validate(board, parseSAN(board, 'R@b8')))
self.assertTrue(validate(board, parseSAN(board, 'Ka7')))
self.assertTrue(validate(board, parseSAN(board, 'Kb7')))
self.assertTrue(not validate(board, parseSAN(board, 'P@b8')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb8')))
def test_validate1(self):
"""Testing castling rights lose in explosion in Atomic variant"""
board = AtomicBoard(setup=FEN1)
board = board.move(parseSAN(board, 'Nxa7'))
print(board)
# Rook exploded, no O-O-O anymore!
self.assertTrue(validate(board, parseSAN(board, 'b6')))
self.assertTrue(not validate(board, parseSAN(board, 'a6')))
self.assertTrue(not validate(board, parseSAN(board, 'Rb8')))
self.assertTrue(not validate(board, parseSAN(board, 'O-O-O')))
def test_validate2(self):
"""Testing explode king vs mate in Atomic variant"""
board = AtomicBoard(setup=FEN1)
board = board.move(parseSAN(board, 'Nc7+'))
print(board)
# King explosion takes precedence over mate!
self.assertTrue(validate(board, parseSAN(board, 'Qxd2')))
self.assertTrue(validate(board, parseSAN(board, 'Qxf2')))
self.assertTrue(not validate(board, parseSAN(board, 'Qxb2')))
self.assertTrue(not validate(board, parseSAN(board, 'Qe4+')))
def test_validate1(self):
"""Testing castling rights lose in explosion in Atomic variant"""
board = AtomicBoard(setup=FEN1)
board = board.move(parseSAN(board, 'Nxa7'))
print(board)
# Rook exploded, no O-O-O anymore!
self.assertTrue(validate(board, parseSAN(board, 'b6')))
self.assertTrue(not validate(board, parseSAN(board, 'a6')))
self.assertTrue(not validate(board, parseSAN(board, 'Rb8')))
self.assertTrue(not validate(board, parseSAN(board, 'O-O-O')))
def test_validate(self):
"""Testing validate move in Crazyhouse variant"""
board = CrazyhouseBoard(setup=FEN0)
print(board)
# Drop can save mate
self.assertTrue(validate(board, parseSAN(board, 'R@b8')))
self.assertTrue(validate(board, parseSAN(board, 'Ka7')))
self.assertTrue(validate(board, parseSAN(board, 'Kb7')))
self.assertTrue(not validate(board, parseSAN(board, 'P@b8')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb8')))
def test_validate2(self):
"""Testing explode king vs mate in Atomic variant"""
board = AtomicBoard(setup=FEN1)
board = board.move(parseSAN(board, 'Nc7+'))
print(board)
# King explosion takes precedence over mate!
self.assertTrue(validate(board, parseSAN(board, 'Qxd2')))
self.assertTrue(validate(board, parseSAN(board, 'Qxf2')))
self.assertTrue(not validate(board, parseSAN(board, 'Qxb2')))
self.assertTrue(not validate(board, parseSAN(board, 'Qe4+')))
def test_validate(self):
"""Testing validate move in Sittuyin variant"""
board = SittuyinBoard(setup=FEN0)
print(board)
self.assertTrue(validate(board, parseAN(board, 'f4f3')))
self.assertTrue(validate(board, parseAN(board, 'b2b1')))
self.assertTrue(validate(board, parseAN(board, 'b2c1')))
# no promotion if we have Met (queen)
self.assertFalse(validate(board, parseAN(board, 'b2b2f')))
self.assertFalse(validate(board, parseAN(board, 'b2a1f')))
self.assertFalse(validate(board, parseAN(board, 'f4f3f')))
self.assertFalse(validate(board, parseAN(board, 'b2b1f')))
self.assertFalse(validate(board, parseAN(board, 'b2c1f')))
board = SittuyinBoard(setup=FEN1)
print(board)
# but (optional) promotion if we don't have Met (queen)
self.assertFalse(validate(board, parseAN(board, 'b2b2f')))
self.assertFalse(validate(board, parseSAN(board, 'b2=f')))
self.assertEqual(parseAN(board, 'b2b2f'), parseSAN(board, 'b2=f'))
self.assertTrue(validate(board, parseAN(board, 'b2a1f')))
self.assertTrue(validate(board, parseSAN(board, 'a1=f')))
self.assertEqual(parseAN(board, 'b2a1f'), parseSAN(board, 'a1=f'))
self.assertTrue(validate(board, parseAN(board, 'b2c1')))
self.assertTrue(validate(board, parseAN(board, 'f4f3')))
self.assertFalse(validate(board, parseAN(board, 'f4f3f')))
self.assertFalse(validate(board, parseAN(board, 'b2b2')))
self.assertFalse(validate(board, parseAN(board, 'b2b1f')))
self.assertFalse(validate(board, parseAN(board, 'b2c1f')))
board = SittuyinBoard(setup=FEN2)
print(board)
# simple pawn move can give check
self.assertTrue(validate(board, parseAN(board, 'd6d7')))
# pawn can promote in place
self.assertTrue(validate(board, parseAN(board, 'd6d6f')))
# pawn promotion move can't give check
self.assertFalse(validate(board, parseAN(board, 'd6c7f')))
self.assertFalse(validate(board, parseAN(board, 'd6e7f')))
board = SittuyinBoard(setup=FEN3)
print(board)
self.assertTrue(validate(board, parseAN(board, 'd6d7')))
# last pawn being enywhere can promote
self.assertTrue(validate(board, parseAN(board, 'd6d6f')))
self.assertTrue(validate(board, parseAN(board, 'd6c7f')))
self.assertTrue(validate(board, parseAN(board, 'd6c5f')))
self.assertTrue(validate(board, parseAN(board, 'd6e5f')))
# pawn promotion move can't give check
self.assertFalse(validate(board, parseAN(board, 'd6e7f')))
def test_san_promotion_ambiguity(self):
"""Testing Sittuyin promotion SAN parser"""
board = SittuyinBoard(setup=FEN6)
print(board)
self.assertNotEqual(parseAN(board, 'd4c3f'), parseSAN(board, 'c3=f'))
self.assertEqual(parseAN(board, 'b4c3f'), parseSAN(board, 'c3=f'))
board = SittuyinBoard(setup=FEN7)
print(board)
self.assertNotEqual(parseAN(board, 'f5e6f'), parseSAN(board, 'e6=f'))
self.assertEqual(parseAN(board, 'd5e6f'), parseSAN(board, 'e6=f'))
def makeMove (self, board1, move, board2):
if board2 and self.gamemodel.inControl:
self.connection.bm.sendMove (toAN (board2, move))
item = self.queue.get(block=True)
try:
if item == "del":
raise PlayerIsDead
if item == "int":
raise TurnInterrupt
ply, sanmove = item
if ply < board1.ply:
# This should only happen in an observed game
board1 = self.gamemodel.getBoardAtPly(max(ply-1, 0))
log.debug("ICPlayer.makemove: id(self)=%d self=%s from queue got: ply=%d sanmove=%s\n" % \
(id(self), self, ply, sanmove))
try:
move = parseSAN (board1, sanmove)
log.debug("ICPlayer.makemove: id(self)=%d self=%s parsed move=%s\n" % \
(id(self), self, move))
except ParsingError, e:
raise
return move
def makeMove(self, board1, move, board2):
log.debug("ICPlayer.makemove: id(self)=%d self=%s move=%s board1=%s board2=%s" % \
(id(self), self, move, board1, board2))
if board2 and not self.gamemodel.isObservationGame():
# TODO: Will this work if we just always use CASTLE_SAN?
cn = CASTLE_KK
if board2.variant == FISCHERRANDOMCHESS:
cn = CASTLE_SAN
self.connection.bm.sendMove(toAN(board2, move, castleNotation=cn))
item = self.queue.get(block=True)
try:
if item == "del":
raise PlayerIsDead
if item == "int":
raise TurnInterrupt
ply, sanmove = item
if ply < board1.ply:
# This should only happen in an observed game
board1 = self.gamemodel.getBoardAtPly(max(ply - 1, 0))
log.debug("ICPlayer.makemove: id(self)=%d self=%s from queue got: ply=%d sanmove=%s" % \
(id(self), self, ply, sanmove))
try:
move = parseSAN(board1, sanmove)
log.debug("ICPlayer.makemove: id(self)=%d self=%s parsed move=%s" % \
(id(self), self, move))
except ParsingError as e:
raise
return move
finally:
log.debug("ICPlayer.makemove: id(self)=%d self=%s returning move=%s" % \
(id(self), self, move))
self.okqueue.put("ok")
def test_getstatus1(self):
"""Testing bare black king is not draw in Atomic variant"""
board = AtomicBoard(setup=FEN2)
board = board.move(parseSAN(board, 'Qxc2'))
print(board)
self.assertEqual(getStatus(board), (BLACKWON, WON_KINGEXPLODE))
def makeMove(self, board1, move, board2):
log.debug("ICPlayer.makemove: id(self)=%d self=%s move=%s board1=%s board2=%s" % \
(id(self), self, move, board1, board2))
if board2 and not self.gamemodel.isObservationGame():
# TODO: Will this work if we just always use CASTLE_SAN?
castle_notation = CASTLE_KK
if board2.variant == FISCHERRANDOMCHESS:
castle_notation = CASTLE_SAN
self.connection.bm.sendMove(toAN(board2, move, castleNotation=castle_notation))
item = self.queue.get(block=True)
try:
if item == "del":
raise PlayerIsDead
if item == "int":
raise TurnInterrupt
ply, sanmove = item
if ply < board1.ply:
# This should only happen in an observed game
board1 = self.gamemodel.getBoardAtPly(max(ply - 1, 0))
log.debug("ICPlayer.makemove: id(self)=%d self=%s from queue got: ply=%d sanmove=%s" % \
(id(self), self, ply, sanmove))
try:
move = parseSAN(board1, sanmove)
log.debug("ICPlayer.makemove: id(self)=%d self=%s parsed move=%s" % \
(id(self), self, move))
except ParsingError as err:
raise
return move
finally:
log.debug("ICPlayer.makemove: id(self)=%d self=%s returning move=%s" % \
(id(self), self, move))
self.okqueue.put("ok")
def test1(self):
"""Testing both king goes to 8.row draw in racingkings variant"""
board = RacingKingsBoard(setup=FEN)
board = board.move(parseSAN(board, 'Kh8'))
print(board)
# White king reached 8th row, but this is not a win
# because black can reach 8th row also with hes next move
self.assertEqual(getStatus(board), (RUNNING, UNKNOWN_REASON))
self.assertTrue(validate(board, parseSAN(board, 'Kb8')))
self.assertTrue(not validate(board, parseSAN(board, 'Kd8')))
board = board.move(parseSAN(board, 'Kb8'))
print(board)
self.assertEqual(getStatus(board), (DRAW, DRAW_KINGSINEIGHTROW))
def test_getstatus1(self):
"""Testing bare black king is not draw in Atomic variant"""
board = AtomicBoard(setup=FEN2)
board = board.move(parseSAN(board, 'Qxc2'))
print(board)
self.assertEqual(getStatus(board), (BLACKWON, WON_KINGEXPLODE))
def test_check_evasions(self):
"""Testing check evasions in Crazyhouse variant"""
board = CrazyhouseBoard(setup=FEN1)
print(board)
# invalid drop
self.assertTrue(validate(board, parseSAN(board, 'Q@b1')))
self.assertTrue(validate(board, parseSAN(board, 'Q@c1')))
self.assertTrue(validate(board, parseSAN(board, 'Kxb2')))
self.assertTrue(not validate(board, parseSAN(board, 'P@b1')))
self.assertTrue(not validate(board, parseSAN(board, 'P@c1')))
evasions = [move for move in genCheckEvasions(board.board)]
self.assertTrue(parseSAN(board, 'Q@b1').move in evasions)
self.assertTrue(parseSAN(board, 'Q@c1').move in evasions)
self.assertTrue(parseSAN(board, 'Kxb2').move in evasions)
self.assertTrue(parseSAN(board, 'P@b1').move not in evasions)
self.assertTrue(parseSAN(board, 'P@c1').move not in evasions)
def test_check_evasions(self):
"""Testing check evasions in Crazyhouse variant"""
board = CrazyhouseBoard(setup=FEN1)
print(board)
# invalid drop
self.assertTrue(validate(board, parseSAN(board, 'Q@b1')))
self.assertTrue(validate(board, parseSAN(board, 'Q@c1')))
self.assertTrue(validate(board, parseSAN(board, 'Kxb2')))
self.assertTrue(not validate(board, parseSAN(board, 'P@b1')))
self.assertTrue(not validate(board, parseSAN(board, 'P@c1')))
evasions = [move for move in genCheckEvasions(board.board)]
self.assertTrue(parseSAN(board, 'Q@b1').move in evasions)
self.assertTrue(parseSAN(board, 'Q@c1').move in evasions)
self.assertTrue(parseSAN(board, 'Kxb2').move in evasions)
self.assertTrue(parseSAN(board, 'P@b1').move not in evasions)
self.assertTrue(parseSAN(board, 'P@c1').move not in evasions)
def selection_changed (self, widget, *args):
iter = self.tv.get_selection().get_selected()[1]
if iter == None:
self.board.bluearrow = None
return
else: sel = self.tv.get_model().get_path(iter)[0]
move = parseSAN (
self.board.model.boards[self.board.shown], self.openings[sel][0] )
self.board.bluearrow = move.cords
def selection_changed(self, widget, *args):
iter = self.tv.get_selection().get_selected()[1]
if iter == None:
self.board.bluearrow = None
return
else:
sel = self.tv.get_model().get_path(iter)[0]
move = parseSAN(self.board.model.boards[self.board.shown],
self.openings[sel][0])
self.board.bluearrow = move.cords
def makeMove(self, board1, move, board2):
log.debug(
"ICPlayer.makemove: id(self)=%d self=%s move=%s board1=%s board2=%s"
% (id(self), self, move, board1, board2))
if board2 and not self.gamemodel.isObservationGame():
# TODO: Will this work if we just always use CASTLE_SAN?
castle_notation = CASTLE_KK
if board2.variant == FISCHERRANDOMCHESS:
castle_notation = CASTLE_SAN
self.connection.bm.sendMove(
toAN(board2, move, castleNotation=castle_notation))
item = yield from self.gamemodel.ficsgame.queue.get()
try:
if item == "del":
raise PlayerIsDead
gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms = item
self.gamemodel.onBoardUpdate(gameno, ply, curcol, lastmove, fen,
wname, bname, wms, bms)
if curcol == self.color and ply == self.gamemodel.ply:
item = yield from self.gamemodel.ficsgame.queue.get()
if item == "del":
raise PlayerIsDead
gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms = item
self.gamemodel.onBoardUpdate(gameno, ply, curcol, lastmove,
fen, wname, bname, wms, bms)
if self.turn_interrupt:
self.turn_interrupt = False
raise TurnInterrupt
if ply < board1.ply:
# This should only happen in an observed game
board1 = self.gamemodel.getBoardAtPly(max(ply - 1, 0))
log.debug(
"ICPlayer.makemove: id(self)=%d self=%s from queue got: ply=%d sanmove=%s"
% (id(self), self, ply, lastmove))
try:
move = parseSAN(board1, lastmove)
log.debug(
"ICPlayer.makemove: id(self)=%d self=%s parsed move=%s" %
(id(self), self, move))
except ParsingError:
raise
return move
finally:
log.debug(
"ICPlayer.makemove: id(self)=%d self=%s returning move=%s" %
(id(self), self, move))
def test_validate(self):
"""Testing validate move in Losers variant"""
board = LosersBoard(setup=FEN0)
print(board)
self.assertTrue(validate(board, parseSAN(board, 'Kxa7')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb8')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb7')))
board = LosersBoard(setup=FEN1)
print(board)
self.assertTrue(not validate(board, parseSAN(board, 'Kxa7')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb8')))
self.assertTrue(validate(board, parseSAN(board, 'Kb7')))
board = LosersBoard(setup=FEN2)
print(board)
self.assertTrue(not validate(board, parseSAN(board, 'Kxb7')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb8')))
self.assertTrue(validate(board, parseSAN(board, 'Rxb7')))
def test_validate(self):
"""Testing validate move in Suicide variant"""
board = SuicideBoard(setup=FEN0)
print(board)
self.assertTrue(validate(board, parseSAN(board, 'Kxa7')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb8')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb7')))
board = SuicideBoard(setup=FEN1)
print(board)
self.assertTrue(validate(board, parseSAN(board, 'Kxa7')))
self.assertTrue(validate(board, parseSAN(board, 'Kxb8')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb7')))
board = SuicideBoard(setup=FEN2)
print(board)
self.assertTrue(not validate(board, parseSAN(board, 'Ka7')))
self.assertTrue(not validate(board, parseSAN(board, 'Kb8')))
self.assertTrue(validate(board, parseSAN(board, 'Kxb7')))
board = SuicideBoard(setup=FEN3)
print(board)
self.assertTrue(validate(board, parseSAN(board, 'Ked2')))
def makeMove(self, board1, move, board2):
log.debug("ICPlayer.makemove: id(self)=%d self=%s move=%s board1=%s board2=%s" % (
id(self), self, move, board1, board2))
if board2 and not self.gamemodel.isObservationGame():
# TODO: Will this work if we just always use CASTLE_SAN?
castle_notation = CASTLE_KK
if board2.variant == FISCHERRANDOMCHESS:
castle_notation = CASTLE_SAN
self.connection.bm.sendMove(toAN(board2, move, castleNotation=castle_notation))
item = yield from self.gamemodel.ficsgame.queue.get()
try:
if item == "del":
raise PlayerIsDead
gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms = item
self.gamemodel.onBoardUpdate(gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms)
if curcol == self.color and ply == self.gamemodel.ply:
item = yield from self.gamemodel.ficsgame.queue.get()
if item == "del":
raise PlayerIsDead
gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms = item
self.gamemodel.onBoardUpdate(gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms)
if self.turn_interrupt:
self.turn_interrupt = False
raise TurnInterrupt
if ply < board1.ply:
# This should only happen in an observed game
board1 = self.gamemodel.getBoardAtPly(max(ply - 1, 0))
log.debug("ICPlayer.makemove: id(self)=%d self=%s from queue got: ply=%d sanmove=%s" % (
id(self), self, ply, lastmove))
try:
move = parseSAN(board1, lastmove)
log.debug("ICPlayer.makemove: id(self)=%d self=%s parsed move=%s" % (
id(self), self, move))
except ParsingError:
raise
return move
finally:
log.debug("ICPlayer.makemove: id(self)=%d self=%s returning move=%s" % (id(self), self, move))
def makeMove(self, board1, move, board2):
log.debug(
"ICPlayer.makemove: id(self)=%d self=%s move=%s board1=%s board2=%s"
% (id(self), self, move, board1, board2))
if board2 and not self.gamemodel.isObservationGame():
# TODO: Will this work if we just always use CASTLE_SAN?
castle_notation = CASTLE_KK
if board2.variant == FISCHERRANDOMCHESS:
castle_notation = CASTLE_SAN
self.connection.bm.sendMove(
toAN(board2, move, castleNotation=castle_notation))
# wait for fics to send back our move we made
item = yield from self.move_queue.get()
log.debug("ICPlayer.makeMove: fics sent back the move we made")
item = yield from self.move_queue.get()
try:
if item == "end":
log.debug("ICPlayer.makeMove got: end")
raise GameEnded
elif item == "del":
log.debug("ICPlayer.makeMove got: del")
raise PlayerIsDead
elif item == "stm":
log.debug("ICPlayer.makeMove got: stm")
self.turn_interrupt = False
raise TurnInterrupt
elif item == "fen":
log.debug("ICPlayer.makeMove got: fen")
self.turn_interrupt = False
raise TurnInterrupt
elif item == "pass":
log.debug("ICPlayer.makeMove got: pass")
self.pass_interrupt = False
raise PassInterrupt
gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms = item
log.debug("ICPlayer.makeMove got: %s %s %s %s" %
(gameno, ply, curcol, lastmove))
self.gamemodel.onBoardUpdate(gameno, ply, curcol, lastmove, fen,
wname, bname, wms, bms)
if self.turn_interrupt:
self.turn_interrupt = False
raise TurnInterrupt
if self.pass_interrupt:
self.pass_interrupt = False
raise PassInterrupt
if ply < board1.ply:
# This should only happen in an observed game
board1 = self.gamemodel.getBoardAtPly(max(ply - 1, 0))
log.debug(
"ICPlayer.makemove: id(self)=%d self=%s from queue got: ply=%d sanmove=%s"
% (id(self), self, ply, lastmove))
try:
move = parseSAN(board1, lastmove)
log.debug(
"ICPlayer.makemove: id(self)=%d self=%s parsed move=%s" %
(id(self), self, move))
except ParsingError:
raise
return move
finally:
log.debug(
"ICPlayer.makemove: id(self)=%d self=%s returning move=%s" %
(id(self), self, move))
def test_validate(self):
"""Testing validate move in Sittuyin variant"""
board = SittuyinBoard(setup=FEN0)
print(board)
# no promotion if we have Met (queen)
self.assertTrue(validate(board, parseSAN(board, 'f4f3')))
self.assertTrue(validate(board, parseSAN(board, 'b2b1')))
self.assertTrue(validate(board, parseSAN(board, 'bxc1')))
self.assertTrue(not validate(board, parseSAN(board, 'f4f3f')))
self.assertTrue(not validate(board, parseSAN(board, 'b2b2f')))
self.assertTrue(not validate(board, parseSAN(board, 'b2b1f')))
self.assertTrue(not validate(board, parseSAN(board, 'bxc1f')))
board = SittuyinBoard(setup=FEN1)
print(board)
# but (optional) promotion if we don't have Met (queen)
self.assertTrue(validate(board, parseSAN(board, 'f4f3f')))
self.assertTrue(validate(board, parseSAN(board, 'b2b2f')))
self.assertTrue(validate(board, parseSAN(board, 'b2b1')))
self.assertTrue(validate(board, parseSAN(board, 'bxc1')))
self.assertTrue(validate(board, parseSAN(board, 'f4f3')))
self.assertTrue(not validate(board, parseSAN(board, 'b2b2')))
self.assertTrue(not validate(board, parseSAN(board, 'b2b1f')))
self.assertTrue(not validate(board, parseSAN(board, 'bxc1f')))
def test_getstatus4(self):
"""Testing possible move into check when king touch saves the king"""
board = AtomicBoard(setup=FEN5)
print(board)
self.assertTrue(validate(board, parseSAN(board, 'Kg5')))
def test_getstatus4(self):
"""Testing possible move into check when king touch saves the king"""
board = AtomicBoard(setup=FEN5)
print(board)
self.assertTrue(validate(board, parseSAN(board, 'Kg5')))
def load (file):
files = []
inTags = False
for line in file:
if FILESMAX and len(files) > FILESMAX: break
line = line.lstrip()
if not line: continue
elif line.startswith("%"): continue
if line.startswith("["):
if not inTags:
files.append(["",""])
inTags = True
files[-1][0] += line
else:
inTags = False
files[-1][1] += line
history = History(False)
max = str(len(files))
start = time()
for i, myFile in enumerate(files):
number = str(i).rjust(len(max))
procent = ("%.1f%%" % (i/float(len(files))*100)).rjust(4)
if i == 0:
estimation = "N/A etr"
speed = "N/A g/s"
else:
s = round((time()-start)/i*(len(files)-i))
estimation = ("%d:%02d etr" % (s / 60, s % 60)).rjust(5)
speed = "%.2f g/s" % (i/(time()-start))
print "%s/%s: %s - %s (%s)" % (number, max, procent, estimation, speed)
try:
tags = dict(tagre.findall(myFile[0]))
if not tags["Result"] in ("1/2-1/2", "1-0", "0-1"):
continue
moves = comre.sub("", myFile[1])
moves = stripBrackets(moves)
moves = movre.findall(moves+" ")
if moves[-1] in ("*", "1/2-1/2", "1-0", "0-1"):
del moves[-1]
except:
# Could not parse game
continue
mcatch = []
if MAXMOVES: moves = moves[:MAXMOVES]
for move in moves:
try:
m = parseSAN(history,move)
except:
continue
epd = fen(history[-1])
res = resultDic[tags["Result"]]
if epd.endswith("b"): res = 2-res
history.add(m, False)
yield epd, toSAN(history[-2], history[-1], history.moves[-1]), res
mcatch.append(m)
history.reset(False)
for move in mcatch:
movePool.add(move)
del mcatch[:]
def makeMove(self, board1, move, board2):
log.debug("ICPlayer.makemove: id(self)=%d self=%s move=%s board1=%s board2=%s" % (
id(self), self, move, board1, board2))
if board2 and not self.gamemodel.isObservationGame():
# TODO: Will this work if we just always use CASTLE_SAN?
castle_notation = CASTLE_KK
if board2.variant == FISCHERRANDOMCHESS:
castle_notation = CASTLE_SAN
self.connection.bm.sendMove(toAN(board2, move, castleNotation=castle_notation))
# wait for fics to send back our move we made
item = yield from self.move_queue.get()
log.debug("ICPlayer.makeMove: fics sent back the move we made")
item = yield from self.move_queue.get()
try:
if item == "end":
log.debug("ICPlayer.makeMove got: end")
raise GameEnded
elif item == "del":
log.debug("ICPlayer.makeMove got: del")
raise PlayerIsDead
elif item == "stm":
log.debug("ICPlayer.makeMove got: stm")
self.turn_interrupt = False
raise TurnInterrupt
elif item == "fen":
log.debug("ICPlayer.makeMove got: fen")
self.turn_interrupt = False
raise TurnInterrupt
elif item == "pass":
log.debug("ICPlayer.makeMove got: pass")
self.pass_interrupt = False
raise PassInterrupt
gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms = item
log.debug("ICPlayer.makeMove got: %s %s %s %s" % (gameno, ply, curcol, lastmove))
self.gamemodel.onBoardUpdate(gameno, ply, curcol, lastmove, fen, wname, bname, wms, bms)
if self.turn_interrupt:
self.turn_interrupt = False
raise TurnInterrupt
if self.pass_interrupt:
self.pass_interrupt = False
raise PassInterrupt
if ply < board1.ply:
# This should only happen in an observed game
board1 = self.gamemodel.getBoardAtPly(max(ply - 1, 0))
log.debug("ICPlayer.makemove: id(self)=%d self=%s from queue got: ply=%d sanmove=%s" % (
id(self), self, ply, lastmove))
try:
move = parseSAN(board1, lastmove)
log.debug("ICPlayer.makemove: id(self)=%d self=%s parsed move=%s" % (
id(self), self, move))
except ParsingError:
raise
return move
finally:
log.debug("ICPlayer.makemove: id(self)=%d self=%s returning move=%s" % (id(self), self, move))
def test_paresSAN(self):
"""Testing parseSAN with unambiguous notations variants"""
self.board.board.applyFen("7B/8/8/8/8/8/8/B7 w - - 0 1")
self.assertEqual(repr(parseSAN(self.board, 'Ba1b2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'Bh8b2')), 'h8b2')
self.assertEqual(repr(parseSAN(self.board, 'Bab2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'Bhb2')), 'h8b2')
self.assertEqual(repr(parseSAN(self.board, 'B1b2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'B8b2')), 'h8b2')
self.board.board.applyFen("7B/8/8/8/8/8/1b6/B7 w - - 0 1")
self.assertEqual(repr(parseSAN(self.board, 'Ba1xb2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'Bh8xb2')), 'h8b2')
self.assertEqual(repr(parseSAN(self.board, 'Baxb2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'Bhxb2')), 'h8b2')
self.assertEqual(repr(parseSAN(self.board, 'B1xb2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'B8xb2')), 'h8b2')
def test_validate(self):
"""Testing validate move in Placement variant"""
board = PlacementBoard(setup=FEN0)
print(board)
# only drop moves to base line allowed
self.assertTrue(validate(board, parseSAN(board, 'K@a1')))
self.assertTrue(validate(board, parseSAN(board, 'K@b1')))
self.assertTrue(validate(board, parseSAN(board, 'K@h1')))
self.assertTrue(not validate(board, parseSAN(board, 'K@a2')))
self.assertTrue(not validate(board, parseSAN(board, 'K@a3')))
self.assertTrue(not validate(board, parseSAN(board, 'K@a8')))
self.assertTrue(not validate(board, parseSAN(board, 'b4')))
board = PlacementBoard(setup=FEN1)
print(board)
# only drop moves to base line allowed
self.assertTrue(validate(board, parseSAN(board, 'K@a8')))
self.assertTrue(validate(board, parseSAN(board, 'K@b8')))
self.assertTrue(validate(board, parseSAN(board, 'K@h8')))
self.assertTrue(not validate(board, parseSAN(board, 'K@a7')))
self.assertTrue(not validate(board, parseSAN(board, 'K@a6')))
self.assertTrue(not validate(board, parseSAN(board, 'K@a1')))
self.assertTrue(not validate(board, parseSAN(board, 'b5')))
board = PlacementBoard(setup=FEN2)
print(board)
# bishops have to be placed on opposite colored fields
self.assertTrue(validate(board, parseSAN(board, 'B@a1')))
self.assertTrue(validate(board, parseSAN(board, 'B@b1')))
self.assertTrue(validate(board, parseSAN(board, 'B@c1')))
self.assertTrue(validate(board, parseSAN(board, 'B@g1')))
self.assertTrue(validate(board, parseSAN(board, 'N@a1')))
self.assertTrue(validate(board, parseSAN(board, 'N@c1')))
self.assertTrue(validate(board, parseSAN(board, 'N@g1')))
self.assertTrue(not validate(board, parseSAN(board, 'N@b1')))
board = PlacementBoard(setup=FEN3)
print(board)
# bishops have to be placed on opposite colored fields
self.assertTrue(validate(board, parseSAN(board, 'B@b1')))
self.assertTrue(validate(board, parseSAN(board, 'N@c1')))
self.assertTrue(validate(board, parseSAN(board, 'N@g1')))
self.assertTrue(not validate(board, parseSAN(board, 'B@c1')))
self.assertTrue(not validate(board, parseSAN(board, 'B@g1')))
self.assertTrue(not validate(board, parseSAN(board, 'N@b1')))
def test_paresSAN(self):
"""Testing parseSAN with unambiguous notations variants"""
self.board.board.applyFen("7B/8/8/8/8/8/8/B7 w - - 0 1")
self.assertEqual(repr(parseSAN(self.board, 'Ba1b2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'Bh8b2')), 'h8b2')
self.assertEqual(repr(parseSAN(self.board, 'Bab2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'Bhb2')), 'h8b2')
self.assertEqual(repr(parseSAN(self.board, 'B1b2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'B8b2')), 'h8b2')
self.board.board.applyFen("7B/8/8/8/8/8/1b6/B7 w - - 0 1")
self.assertEqual(repr(parseSAN(self.board, 'Ba1xb2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'Bh8xb2')), 'h8b2')
self.assertEqual(repr(parseSAN(self.board, 'Baxb2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'Bhxb2')), 'h8b2')
self.assertEqual(repr(parseSAN(self.board, 'B1xb2')), 'a1b2')
self.assertEqual(repr(parseSAN(self.board, 'B8xb2')), 'h8b2')
