def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self,
setup=self.asymmetricrandom_start(),
lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def testAttackedAndNotProtected(self):
""" Testing what recognize the algorithm """
board = Board(setup=True)
dsa = DecisionSupportAlgorithm()
dsa.set_foe_as_bot()
dsa.enableDisableAlgo(True)
moves = ((cordDic["e2"], cordDic["e4"]), (cordDic["d7"],
cordDic["d5"]))
for cord0, cord1 in moves:
board = board.move(Move(Cord(cord0), Cord(cord1), board))
coordinate_attacked = dsa._DecisionSupportAlgorithm__apply_algorithm(
board, WHITE,
dsa._DecisionSupportAlgorithm__attacked_and_not_protected)
# Not protected
self.assertEqual([Cord("e4", color="R")], coordinate_attacked)
coordinate_attacked = dsa._DecisionSupportAlgorithm__apply_algorithm(
board, BLACK,
dsa._DecisionSupportAlgorithm__attacked_and_not_protected)
# protected by Queen
self.assertEqual([], coordinate_attacked)
board = board.move(Move(Cord(E4), Cord(E5), board))
coordinate_attacked = dsa._DecisionSupportAlgorithm__apply_algorithm(
board, WHITE,
dsa._DecisionSupportAlgorithm__attacked_and_not_protected)
self.assertEqual([], coordinate_attacked)
def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self,
setup=self.asymmetricrandom_start(),
lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def __init__(self, setup=True):
fen = SETUPSTART if setup is True else setup
# add all kind if piece to holdings (except king)
parts = fen.split()
parts[0] += "/prnsqPRNSQ"
fen = " ".join(parts)
Board.__init__(self, setup=fen)
self._ply = 0
def __init__(self, setup=True):
fenstr = SETUPSTART if setup is True else setup
# add all kind if piece to holdings
parts = fenstr.split()
parts[0] += "/prnsqkPRNSQK"
fenstr = " ".join(parts)
Board.__init__(self, setup=fenstr)
self._ply = 0
def __init__(self, setup=True):
fen = SETUPSTART if setup is True else setup
# add all kind if piece to holdings (except king)
parts = fen.split()
parts[0] += "/prnsqPRNSQ"
fen = " ".join(parts)
Board.__init__(self, setup=fen)
self._ply = 0
def loadToModel(self, gameno, position=-1, model=None, quick_parse=True):
if not model:
model = GameModel()
model.tags['Event'] = self._getTag(gameno, 'Event')
model.tags['Site'] = self._getTag(gameno, 'Site')
model.tags['Date'] = self._getTag(gameno, 'Date')
model.tags['Round'] = self._getTag(gameno, 'Round')
model.tags['White'], model.tags['Black'] = self.get_player_names(
gameno)
model.tags['WhiteElo'] = self._getTag(gameno, 'WhiteElo')
model.tags['BlackElo'] = self._getTag(gameno, 'BlackElo')
model.tags['Result'] = reprResult[self.get_result(gameno)]
model.tags['ECO'] = self._getTag(gameno, "ECO")
fenstr = self._getTag(gameno, "FEN")
variant = self._getTag(gameno, "Variant")
if variant and ("fischer" in variant.lower() or "960" in variant):
from pychess.Variants.fischerandom import FRCBoard
model.variant = FischerRandomChess
model.boards = [FRCBoard(fenstr)]
else:
if fenstr:
model.boards = [Board(fenstr)]
else:
model.boards = [Board(setup=True)]
del model.moves[:]
model.status = WAITING_TO_START
model.reason = UNKNOWN_REASON
error = None
if quick_parse:
movstrs = self._getMoves(gameno)
for i, mstr in enumerate(movstrs):
if position != -1 and model.ply >= position:
break
try:
move = parseAny(model.boards[-1], mstr)
except ParsingError, e:
notation, reason, boardfen = e.args
ply = model.boards[-1].ply
if ply % 2 == 0:
moveno = "%d." % (i / 2 + 1)
else:
moveno = "%d..." % (i / 2 + 1)
errstr1 = _(
"The game can't be read to end, because of an error parsing move %(moveno)s '%(notation)s'."
) % {
'moveno': moveno,
'notation': notation
}
errstr2 = _("The move failed because %s.") % reason
error = LoadingError(errstr1, errstr2)
break
model.moves.append(move)
model.boards.append(model.boards[-1].move(move))
def __onReadyForMoves(self, self_):
self.returnQueue.put("ready")
self.readyMoves = True
self._newGame()
# If we are an analyzer, this signal was already called in a different
# thread, so we can safely block it.
if self.mode in (ANALYZING, INVERSE_ANALYZING):
if not self.board:
self.board = Board(setup=True)
self.putMove(self.board, None, None)
def __init__(self, setup=True, lboard=None):
fenstr = SETUPSTART if setup is True else setup
# add all kind of pieces to holdings
parts = fenstr.split()
parts[0] += "/prnsqkPRNSQK"
fenstr = " ".join(parts)
if lboard is not None:
Board.__init__(self, setup=fenstr, lboard=lboard)
else:
Board.__init__(self, setup=fenstr)
self._ply = 0
def testAll(self):
board = Board(setup=True)
dsa = DecisionSupportAlgorithm()
dsa.set_foe_as_bot()
dsa.enableDisableAlgo(True)
moves = ((cordDic["e2"], cordDic["e4"]), (cordDic["d7"],
cordDic["d5"]))
for cord0, cord1 in moves:
board = board.move(Move(Cord(cord0), Cord(cord1), board))
board.printPieces()
# Not protected
self.assertEqual(
set([
Cord("a1", color="Y"),
Cord("h1", color="Y"),
Cord("e4", color="R")
]), set(dsa.calculate_coordinate_in_danger(board, WHITE)))
# protected by Queen, so no danger
self.assertEqual(set([Cord("a8", color="Y"),
Cord("h8", color="Y")]),
set(dsa.calculate_coordinate_in_danger(board, BLACK)))
# pawn go forward, no danger
board = board.move(Move(Cord(E4), Cord(E5), board))
self.assertEqual(
set([
Cord("a1", color="Y"),
Cord("h1", color="Y"),
Cord("e5", color="Y")
]), set(dsa.calculate_coordinate_in_danger(board, WHITE)))
# Should not recognize king
board_king = Board(setup=True)
dsa_king = DecisionSupportAlgorithm()
dsa_king.set_foe_as_bot()
dsa_king.enableDisableAlgo(True)
moves = ((cordDic["e2"], cordDic["e4"]),
(cordDic["f7"], cordDic["f5"]), (cordDic["d1"],
cordDic["h5"]))
for cord0, cord1 in moves:
board_king = board_king.move(
Move(Cord(cord0), Cord(cord1), board_king))
# board_king.printPieces()
self.assertEqual(
set([
Cord("a8", color="Y"),
Cord("h8", color="Y"),
Cord("f5", color="Y")
]), set(dsa.calculate_coordinate_in_danger(board_king, BLACK)))
def test2(self):
""" Test analyzing in promotion situations """
board = Board('5k2/PK6/8/8/8/6P1/6P1/8 w - - 1 48')
self.analyzerA.setBoardList([board],[])
self.analyzerI.setBoardList([board],[])
self._testLine(self.engineA, self.analyzerA, board,
"9. 1833 23 43872584 a8=Q+ Kf7 Qa2+ Kf6 Qd2 Kf5 g4+",
['a8=Q+','Kf7','Qa2+','Kf6','Qd2','Kf5','g4+'], 1833, "9.")
self._testLine(self.engineI, self.analyzerI, board.switchColor(),
"10. -1883 59 107386433 Kf7 a8=Q Ke6 Qa6+ Ke5 Qd6+ Kf5",
['Kf7','a8=Q','Ke6','Qa6+','Ke5','Qd6+','Kf5'], -1883, "10.")
def test2(self):
""" Test analyzing in promotion situations """
board = Board('5k2/PK6/8/8/8/6P1/6P1/8 w - - 1 48')
self.analyzerA.setBoardList([board],[])
self.analyzerI.setBoardList([board],[])
self._testLine(self.engineA, self.analyzerA, board,
"9. 1833 23 43872584 a8=Q+ Kf7 Qa2+ Kf6 Qd2 Kf5 g4+",
['a8=Q+','Kf7','Qa2+','Kf6','Qd2','Kf5','g4+'], 1833, "9.")
self._testLine(self.engineI, self.analyzerI, board.switchColor(),
"10. -1883 59 107386433 Kf7 a8=Q Ke6 Qa6+ Ke5 Qd6+ Kf5",
['Kf7','a8=Q','Ke6','Qa6+','Ke5','Qd6+','Kf5'], -1883, "10.")
def on_selection_changed(self, selection):
iter = selection.get_selected()[1]
if iter == None:
self.gamemodel.boards = [Board(FEN_EMPTY)]
del self.gamemodel.moves[:]
self.boardview.shown = 0
self.boardview.redraw_canvas()
return
sel = self.list.get_model().get_path(iter)[0]
if sel == self.lastSel: return
self.lastSel = sel
self.boardview.animationLock.acquire()
try:
try:
self.chessfile.loadToModel(sel, -1, self.gamemodel)
except LoadingError as e:
d = Gtk.MessageDialog(type=Gtk.MessageType.WARNING,
buttons=Gtk.ButtonsType.OK,
message_format=e.args[0])
d.format_secondary_text(e.args[1])
d.connect("response", lambda d, a: d.hide())
d.show()
self.boardview.lastMove = None
self.boardview._shown = self.gamemodel.lowply
last = self.gamemodel.ply
finally:
self.boardview.animationLock.release()
self.boardview.redraw_canvas()
self.boardview.shown = last
self.shown_changed(self.boardview, last)
def on_selection_changed(self, selection):
model, iter = selection.get_selected()
if iter is None:
self.gamemodel.boards = [Board(FEN_EMPTY)]
del self.gamemodel.moves[:]
self.boardview.shown = 0
self.boardview.redrawCanvas()
return
path = self.persp.gamelist.get_model().get_path(iter)
rec, ply = self.persp.gamelist.get_record(path)
if rec is None:
return
try:
self.persp.chessfile.loadToModel(rec, -1, self.gamemodel)
except LoadingError as err:
dialogue = Gtk.MessageDialog(mainwindow(),
type=Gtk.MessageType.WARNING,
buttons=Gtk.ButtonsType.OK,
message_format=err.args[0])
if len(err.args) > 1:
dialogue.format_secondary_text(err.args[1])
dialogue.connect("response", lambda dialogue, a: dialogue.hide())
dialogue.show()
self.boardview.lastMove = None
self.boardview._shown = self.gamemodel.lowply
self.boardview.redrawCanvas()
self.boardview.shown = ply if ply > 0 else self.persp.gamelist.ply
def test1(self):
""" Testing Board.move() on frc castling in non frc game """
board = Board(setup=True)
moves = ((D2, D4), (G8, F6), (C2, C4), (G7, G6), (G2, G3), (F8, G7), (F1, G2), (E8, H8))
for cord0, cord1 in moves:
print(cord0, cord1)
board = board.move(Move(Cord(cord0), Cord(cord1), board))
board.printPieces()
self.assertIsNone(board[Cord(E8)])
self.assertIsNone(board[Cord(H8)])
self.assertEqual(board[Cord(G8)].piece, Piece(BLACK, KING).piece)
self.assertEqual(board[Cord(F8)].piece, Piece(BLACK, ROOK).piece)
def record_move(board: Board, move: Move, game_id: int):
most_recent_move = _get_most_recent_move(game_id)
move_state = MoveState()
move_state.set_state_from_prev_move(most_recent_move)
move_state.post_move_fen = board.asFen()
move_state.set_move(toSAN(board, move))
add_move_state_to_database(move_state)
def on_selection_changed(self, selection):
model, iter = selection.get_selected()
if iter is None:
self.gamemodel.boards = [Board(FEN_EMPTY)]
del self.gamemodel.moves[:]
self.boardview.shown = 0
self.boardview.redrawCanvas()
return
path = self.gamelist.get_model().get_path(iter)
gameno = self.gamelist.get_gameno(path)
self.boardview.animation_lock.acquire()
try:
try:
self.gamelist.chessfile.loadToModel(gameno, -1, self.gamemodel)
except LoadingError as err:
dialogue = Gtk.MessageDialog(type=Gtk.MessageType.WARNING,
buttons=Gtk.ButtonsType.OK,
message_format=err.args[0])
if len(err.args) > 1:
dialogue.format_secondary_text(err.args[1])
dialogue.connect("response",
lambda dialogue, a: dialogue.hide())
dialogue.show()
self.boardview.lastMove = None
self.boardview._shown = self.gamemodel.lowply
finally:
self.boardview.animation_lock.release()
self.boardview.redrawCanvas()
self.boardview.shown = self.gamelist.ply
def test1(self):
""" Test analyzing in forced mate situations """
board = Board('B1n1n1KR/1r5B/6R1/2b1p1p1/2P1k1P1/1p2P2p/1P2P2P/3N1N2 w - - 0 1')
self.analyzerA.setBoardList([board],[])
self.analyzerI.setBoardList([board],[])
self._testLine(self.engineA, self.analyzerA, board,
"1. Mat1 0 1 Bxb7#",
['Bxb7#'], MATE_VALUE, "1.")
# Notice, in the opposite situation there is no forced mate. Black can
# do Bxe3 or Ne7+, but we just emulate a stupid analyzer not
# recognizing this.
self._testLine(self.engineI, self.analyzerI, board.switchColor(),
"10. -Mat 2 35 64989837 Bd4 Bxb7#",
['Bd4','Bxb7#'], -MATE_VALUE, "10.")
def test1(self):
""" Test analyzing in forced mate situations """
board = Board(
'B1n1n1KR/1r5B/6R1/2b1p1p1/2P1k1P1/1p2P2p/1P2P2P/3N1N2 w - - 0 1')
self.analyzerA.setBoardList([board], [])
self.analyzerI.setBoardList([board], [])
self._testLine(self.engineA, self.analyzerA, board,
"1. Mat1 0 1 Bxb7#", ['Bxb7#'], MATE_VALUE, "1.")
# Notice, in the opposite situation there is no forced mate. Black can
# do Bxe3 or Ne7+, but we just emulate a stupid analyzer not
# recognizing this.
self._testLine(self.engineI, self.analyzerI, board.switchColor(),
"10. -Mat 2 35 64989837 Bd4 Bxb7#",
['Bd4', 'Bxb7#'], -MATE_VALUE, "10.")
def __init__(self, subprocess, color, protover, md5):
ProtocolEngine.__init__(self, subprocess, color, protover, md5)
self.ids = {}
self.options = {}
self.optionsToBeSent = {}
self.wtime = 60000
self.btime = 60000
self.incr = 0
self.moves = 0
self.timeHandicap = 1
self.moveLock = RLock()
# none of the following variables should be changed or used in a
# condition statement without holding the above self.moveLock
self.ponderOn = False
self.pondermove = None
self.ignoreNext = False
self.waitingForMove = False
self.needBestmove = False
self.readyForStop = False # keeps track of whether we already sent a 'stop' command
self.multipvSetting = conf.get("multipv",
1) # MultiPV option sent to the engine
self.multipvExpected = 1 # Number of PVs expected (limited by number of legal moves)
self.commands = collections.deque()
self.gameBoard = Board(
setup=True) # board at the end of all moves played
self.board = Board(setup=True) # board to send the engine
self.uciPosition = "startpos"
self.uciPositionListsMoves = False
self.analysis = [None]
self.returnQueue = Queue()
self.line_cid = self.engine.connect("line", self.parseLine)
self.died_cid = self.engine.connect("died", self.__die)
self.invalid_move = None
self.cids = [
self.connect("readyForOptions", self.__onReadyForOptions_before),
self.connect_after("readyForOptions", self.__onReadyForOptions),
self.connect_after("readyForMoves", self.__onReadyForMoves),
]
def __init__(self, subprocess, color, protover, md5):
ProtocolEngine.__init__(self, subprocess, color, protover, md5)
self.ids = {}
self.options = {}
self.optionsToBeSent = {}
self.wtime = 60000
self.btime = 60000
self.incr = 0
self.moves = 0
self.timeHandicap = 1
self.ponderOn = False
self.pondermove = None
self.ignoreNext = False
self.waitingForMove = False
self.needBestmove = False
self.bestmove_event = asyncio.Event()
self.readyForStop = (
False) # keeps track of whether we already sent a 'stop' command
self.multipvSetting = 1 # MultiPV option sent to the engine
self.multipvExpected = (
1) # Number of PVs expected (limited by number of legal moves)
self.commands = collections.deque()
self.gameBoard = Board(
setup=True) # board at the end of all moves played
self.board = Board(setup=True) # board to send the engine
self.uciPosition = "startpos"
self.uciPositionListsMoves = False
self.analysis = [None]
self.analysis_depth = None
self.queue = asyncio.Queue()
self.parse_line_task = create_task(self.parseLine(self.engine))
self.died_cid = self.engine.connect(
"died", lambda e: self.queue.put_nowait("die"))
self.invalid_move = None
self.cids = [
self.connect_after("readyForOptions", self.__onReadyForOptions),
self.connect_after("readyForMoves", self.__onReadyForMoves),
]
def __onReadyForMoves (self, self_):
# If we are an analyzer, this signal was already called in a different
# thread, so we can safely block it.
if self.mode in (ANALYZING, INVERSE_ANALYZING):
if not self.board:
self.board = Board(setup=True)
self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
self.readyMoves = True
semisynced(lambda s:None)(self)
def _get_board(request: WSGIRequest) -> Board:
""" This will eventually be fleshed out into accessing the Database """
game_id = request.GET.get("game_id")
most_recent_move = _get_most_recent_move(game_id)
most_recent_move.refresh_from_db()
game_board = Board(setup=most_recent_move.post_move_fen)
return game_board
def figure_out_previously_moved_pieces(request: WSGIRequest) -> JsonResponse:
game_id = request.GET.get("game_id")
opponent_color = WHITE if request.GET.get(
"player_color") == WHITE_STR else BLACK
most_recent_move = _get_most_recent_move(game_id)
old_board = Board(setup=most_recent_move.pre_move_fen)
old_move = _convert_SAN_str_to_move(most_recent_move.move_algebraic,
old_board)
current_board = old_board.move(old_move)
from_coord, to_coord = _move_to_board_location(old_move)
pieces_moved = [{"from_coord": from_coord, "to_coord": to_coord}]
pieces_moved += _check_for_castle(old_move, opponent_color)
return JsonResponse({
"moves": pieces_moved,
"winner": check_if_game_over(board, game_id)
})
def onSelectionChanged(self, selection):
iter = selection.get_selected()[1]
if iter == None:
self.gamemodel.boards = [Board(FEN_EMPTY)]
del self.gamemodel.moves[:]
self.boardview.shown = 0
self.boardview.redrawCanvas()
return
path = self.list.get_model().get_path(iter)
indices = path.get_indices()
sel = indices[0]
if sel == self.last_sel:
return
self.last_sel = sel
self.boardview.animation_lock.acquire()
try:
try:
self.chessfile.loadToModel(sel, -1, self.gamemodel)
except LoadingError as err:
dialogue = Gtk.MessageDialog(type=Gtk.MessageType.WARNING, \
buttons=Gtk.ButtonsType.OK, \
message_format=err.args[0])
dialogue.format_secondary_text(err.args[1])
dialogue.connect("response",
lambda dialogue, a: dialogue.hide())
dialogue.show()
if self.gamemodel.variant.variant == NORMALCHESS:
radiobutton = self.widgets["playNormalRadio"]
radiobutton.set_active(True)
else:
radiobutton = self.widgets["playVariant1Radio"]
radiobutton.set_active(True)
conf.set("ngvariant1", self.gamemodel.variant.variant)
radiobutton.set_label("%s" % self.gamemodel.variant.name)
if self.gamemodel.tags.get("TimeControl"):
radiobutton = self.widgets["blitzRadio"]
radiobutton.set_active(True)
conf.set("ngblitz min", self.gamemodel.timemodel.minutes)
conf.set("ngblitz gain", self.gamemodel.timemodel.gain)
else:
radiobutton = self.widgets["notimeRadio"]
radiobutton.set_active(True)
self.boardview.lastMove = None
self.boardview._shown = self.gamemodel.lowply
last = self.gamemodel.ply
finally:
self.boardview.animation_lock.release()
self.boardview.redrawCanvas()
self.boardview.shown = last
self.shownChanged(self.boardview, last)
def __init__(self, subprocess, color, protover, md5):
ProtocolEngine.__init__(self, subprocess, color, protover, md5)
self.ids = {}
self.options = {}
self.optionsToBeSent = {}
self.wtime = 60000
self.btime = 60000
self.incr = 0
self.timeHandicap = 1
self.moveLock = RLock()
# none of the following variables should be changed or used in a
# condition statement without holding the above self.moveLock
self.ponderOn = False
self.pondermove = None
self.ignoreNext = False
self.waitingForMove = False
self.needBestmove = False
self.readyForStop = False # keeps track of whether we already sent a 'stop' command
self.multipvSetting = conf.get("multipv", 1
) # MultiPV option sent to the engine
self.multipvExpected = 1 # Number of PVs expected (limited by number of legal moves)
self.commands = collections.deque()
self.gameBoard = Board(setup=True) # board at the end of all moves played
self.board = Board(setup=True) # board to send the engine
self.uciPosition = "startpos"
self.uciPositionListsMoves = False
self.analysis = [None]
self.returnQueue = Queue()
self.line_cid = self.engine.connect("line", self.parseLine)
self.died_cid = self.engine.connect("died", self.__die)
self.invalid_move = None
self.cids = [
self.connect("readyForOptions", self.__onReadyForOptions_before),
self.connect_after("readyForOptions", self.__onReadyForOptions),
self.connect_after("readyForMoves", self.__onReadyForMoves),
]
def __onReadyForMoves (self, self_):
self.returnQueue.put("ready")
self.readyMoves = True
self._newGame()
# If we are an analyzer, this signal was already called in a different
# thread, so we can safely block it.
if self.mode in (ANALYZING, INVERSE_ANALYZING):
if not self.board:
self.board = Board(setup=True)
self.putMove(self.board, None, None)
def __init__(self, subprocess, color, protover, md5):
ProtocolEngine.__init__(self, subprocess, color, protover, md5)
self.ids = {}
self.options = {}
self.optionsToBeSent = {}
self.wtime = 60000
self.btime = 60000
self.incr = 0
self.moves = 0
self.timeHandicap = 1
self.ponderOn = False
self.pondermove = None
self.ignoreNext = False
self.waitingForMove = False
self.needBestmove = False
self.bestmove_event = asyncio.Event()
self.readyForStop = False # keeps track of whether we already sent a 'stop' command
self.multipvSetting = 1 # MultiPV option sent to the engine
self.multipvExpected = 1 # Number of PVs expected (limited by number of legal moves)
self.commands = collections.deque()
self.gameBoard = Board(setup=True) # board at the end of all moves played
self.board = Board(setup=True) # board to send the engine
self.uciPosition = "startpos"
self.uciPositionListsMoves = False
self.analysis = [None]
self.analysis_depth = None
self.queue = asyncio.Queue()
self.parse_line_task = asyncio.async(self.parseLine(self.engine))
self.died_cid = self.engine.connect("died", lambda e: self.queue.put_nowait("die"))
self.invalid_move = None
self.cids = [
self.connect_after("readyForOptions", self.__onReadyForOptions),
self.connect_after("readyForMoves", self.__onReadyForMoves),
]
def testNotProtected(self):
board = Board(setup=True)
dsa = DecisionSupportAlgorithm()
dsa.set_foe_as_bot()
dsa.enableDisableAlgo(True)
# at the start of the game, only the two towers are not protected by other pieces
coordinate_not_protected = dsa._DecisionSupportAlgorithm__apply_algorithm(
board, WHITE, dsa._DecisionSupportAlgorithm__not_protected)
self.assertEqual(set([Cord("a1", color="Y"),
Cord("h1", color="Y")]),
set(coordinate_not_protected))
board = board.move(
Move(Cord(cordDic["e2"]), Cord(cordDic["e4"]), board))
coordinate_not_protected = dsa._DecisionSupportAlgorithm__apply_algorithm(
board, WHITE, dsa._DecisionSupportAlgorithm__not_protected)
# the pawn moved to e4 is now not protected
self.assertEqual(
set([
Cord("a1", color="Y"),
Cord("h1", color="Y"),
Cord("e4", color="Y")
]), set(coordinate_not_protected))
board = board.move(
Move(Cord(cordDic["d7"]), Cord(cordDic["d5"]), board))
# the black pawn attack the white pawn, it is not notProtected that will detect this case,
# only the two towers are not protected
coordinate_not_protected = dsa._DecisionSupportAlgorithm__apply_algorithm(
board, WHITE, dsa._DecisionSupportAlgorithm__not_protected)
self.assertEqual(set([Cord("a1", color="Y"),
Cord("h1", color="Y")]),
set(coordinate_not_protected))
def __init__(self, setup=True, lboard=None):
if setup is True:
fenstr = SETUPSTART
elif isinstance(setup, str):
fenstr = setup
# add all kind of pieces to holdings
parts = fenstr.split()
if parts[0].endswith("]"):
placement, holdings = parts[0].split("[")
for piece in HOLDINGS:
if piece not in holdings:
parts[0] = placement + HOLDINGS
fenstr = " ".join(parts)
break
else:
parts[0] += HOLDINGS
fenstr = " ".join(parts)
if lboard is not None:
Board.__init__(self, setup=fenstr, lboard=lboard)
else:
Board.__init__(self, setup=fenstr)
self._ply = 0
def walk(node, path):
if node.prev is None:
# initial game board
if variant == "Fischerandom":
board = FRCBoard(setup=node.asFen(), lboard=node)
elif variant == "Atomic":
board = AtomicBoard(setup=node.asFen(), lboard=node)
elif variant == "Crazyhouse":
board = CrazyhouseBoard(setup=node.asFen(), lboard=node)
elif variant == "Wildcastle":
board = WildcastleBoard(setup=node.asFen(), lboard=node)
elif variant == "Suicide":
board = SuicideBoard(setup=node.asFen(), lboard=node)
elif variant == "Losers":
board = LosersBoard(setup=node.asFen(), lboard=node)
elif variant == "Kingofthehill":
board = KingOfTheHillBoard(setup=node.asFen(), lboard=node)
else:
board = Board(setup=node.asFen(), lboard=node)
else:
move = Move(node.lastMove)
try:
board = node.prev.pieceBoard.move(move, lboard=node)
except:
raise LoadingError(
_("Invalid move."),
"%s%s" % (move_count(node, black_periods=True), move))
if node.next is None:
model.variations.append(path + [board])
else:
walk(node.next, path + [board])
for child in node.children:
if isinstance(child, list):
if len(child) > 1:
# non empty variation, go walk
walk(child[1], list(path))
else:
if not self.has_emt:
self.has_emt = child.find("%emt") >= 0
if not self.has_eval:
self.has_eval = child.find("%eval") >= 0
def test2(self):
""" Test analyzing in promotion situations """
board = Board('5k2/PK6/8/8/8/6P1/6P1/8 w - - 1 48')
self.analyzerA.setBoardList([board], [])
self.analyzerI.setBoardList([board], [])
async def coro():
await self._testLine(
self.engineA, self.analyzerA, board,
"9. 1833 23 43872584 a8=Q+ Kf7 Qa2+ Kf6 Qd2 Kf5 g4+", 94,
['a8=Q+', 'Kf7', 'Qa2+', 'Kf6', 'Qd2', 'Kf5', 'g4+'], 1833,
"9.", "190750365")
await self._testLine(
self.engineI, self.analyzerI, board.switchColor(),
"10. -1883 59 107386433 Kf7 a8=Q Ke6 Qa6+ Ke5 Qd6+ Kf5",
94, ['Kf7', 'a8=Q', 'Ke6', 'Qa6+', 'Ke5', 'Qd6+', 'Kf5'],
-1883, "10.", "182010903")
self.loop.run_until_complete(coro())
def on_selection_changed(self, selection):
iter = selection.get_selected()[1]
if iter == None:
self.gamemodel.boards = [Board(FEN_EMPTY)]
del self.gamemodel.moves[:]
self.boardview.shown = 0
self.boardview.redraw_canvas()
return
sel = self.list.get_model().get_path(iter)[0]
if sel == self.lastSel: return
self.lastSel = sel
self.boardview.animationLock.acquire()
try:
try:
self.chessfile.loadToModel(sel, -1, self.gamemodel)
except LoadingError, e:
#TODO: Pressent this a little nicer
print e
self.boardview.lastMove = None
self.boardview._shown = self.gamemodel.lowply
last = self.gamemodel.ply
def __init__ (self, setup=False):
if setup is True:
Board.__init__(self, setup=PAWNSPASSEDSTART)
else:
Board.__init__(self, setup=setup)
def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=SUICIDESTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def __init__ (self, setup=False):
if setup is True:
Board.__init__(self, setup=self.shuffle_start())
else:
Board.__init__(self, setup=setup)
def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=PAWNSPASSEDSTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def __init__ (self, setup=False):
if setup is True:
Board.__init__(self, setup=ROOKODDSSTART)
else:
Board.__init__(self, setup=setup)
def __init__ (self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=KNIGHTODDSSTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
blackdarkbishops += 1
blacklightbishops = blacklightbishops > 0 and (blacklightbishops-1) or 0
break
tmp = ''.join(black) + '/pppppppp/8/8/8/8/PPPPPPPP/' + \
''.join(white).upper() + ' w - - 0 1'
return tmp
class AsymmetricRandomChess:
__desc__ = \
_("FICS wild/4: http://www.freechess.org/Help/HelpFiles/wild.html\n" +
"* Randomly chosen pieces (two queens or three rooks possible)\n" +
"* Exactly one king of each color\n" +
"* Pieces placed randomly behind the pawns, SUBJECT TO THE CONSTRAINT THAT THE BISHOPS ARE BALANCED\n" +
"* No castling\n" +
"* Black's arrangement DOES NOT mirrors white's")
name = _("Asymmetric Random")
cecp_name = "unknown"
board = AsymmetricRandomBoard
need_initial_board = True
standard_rules = True
variant_group = VARIANTS_SHUFFLE
if __name__ == '__main__':
Board = AsymmetricRandomBoard(True)
for i in range(10):
print Board.asymmetricrandom_start()
def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=PLACEMENTSTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=UPSIDEDOWNSTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
(whitelightbishops != blacklightbishops):
bishopindex = blackbishoprandomindexstack.pop()
for index, piece in RandomEnumeratePieces(black):
if piece != 'b':
if ((blackdarkbishops > whitedarkbishops) and (bishopindex % 2 == 1) and (index % 2 == 0)):
black[bishopindex] = piece
black[index] = 'b'
blacklightbishops += 1
blackdarkbishops = blackdarkbishops > 0 and (
blackdarkbishops - 1) or 0
break
elif ((blacklightbishops > whitelightbishops) and
(bishopindex % 2 == 0) and (index % 2 == 1)):
black[bishopindex] = piece
black[index] = 'b'
blackdarkbishops += 1
blacklightbishops = blacklightbishops > 0 and (
blacklightbishops - 1) or 0
break
tmp = ''.join(black) + '/pppppppp/8/8/8/8/PPPPPPPP/' + \
''.join(white).upper() + ' w - - 0 1'
return tmp
if __name__ == '__main__':
Board = AsymmetricRandomBoard(True)
for i in range(10):
print(Board.asymmetricrandom_start())
def random_start(self):
tmp = random.sample(('r', 'n', 'b', 'q') * 16, 7)
tmp.append('k')
random.shuffle(tmp)
tmp = ''.join(tmp)
tmp = tmp + '/pppppppp/8/8/8/8/PPPPPPPP/' + tmp.upper() + ' w - - 0 1'
return tmp
class RandomChess:
__desc__ = _(
"FICS wild/3: http://www.freechess.org/Help/HelpFiles/wild.html\n" +
"* Randomly chosen pieces (two queens or three rooks possible)\n" +
"* Exactly one king of each color\n" +
"* Pieces placed randomly behind the pawns\n" + "* No castling\n" +
"* Black's arrangement mirrors white's")
name = _("Random")
cecp_name = "unknown"
board = RandomBoard
need_initial_board = True
standard_rules = True
variant_group = VARIANTS_SHUFFLE
if __name__ == '__main__':
Board = RandomBoard(True)
for i in range(10):
print Board.random_start()
Board.__init__(self, setup=self.shuffle_start(), lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def shuffle_start(self):
tmp = ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r']
random.shuffle(tmp)
tmp = ''.join(tmp)
tmp = tmp + '/pppppppp/8/8/8/8/PPPPPPPP/' + tmp.upper() + ' w - - 0 1'
return tmp
class ShuffleChess:
__desc__ = _("xboard nocastle: http://home.hccnet.nl/h.g.muller/engine-intf.html#8\n" +
"FICS wild/2: http://www.freechess.org/Help/HelpFiles/wild.html\n" +
"* Random arrangement of the pieces behind the pawns\n" +
"* No castling\n" +
"* Black's arrangement mirrors white's")
name = _("Shuffle")
cecp_name = "nocastle"
board = ShuffleBoard
need_initial_board = True
standard_rules = True
variant_group = VARIANTS_SHUFFLE
if __name__ == '__main__':
Board = ShuffleBoard(True)
for i in range(10):
print(Board.shuffle_start())
def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=WILDCASTLESTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
"* Exactly one king of each color\n" +
"* Pieces placed randomly behind the pawns\n" +
"* No castling\n" +
"* Black's arrangement mirrors white's")
name = _("Random")
cecp_name = "unknown"
need_initial_board = True
standard_rules = True
variant_group = VARIANTS_SHUFFLE
def __init__ (self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=self.random_start(), lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def random_start(self):
tmp = random.sample(('r', 'n', 'b', 'q')*16, 7)
tmp.append('k')
random.shuffle(tmp)
tmp = ''.join(tmp)
tmp = tmp + '/pppppppp/8/8/8/8/PPPPPPPP/' + tmp.upper() + ' w - - 0 1'
return tmp
if __name__ == '__main__':
Board = RandomBoard(True)
for i in range(10):
print(Board.random_start())
def __init__ (self, setup=False):
if setup is True:
Board.__init__(self, setup=self.asymmetricrandom_start())
else:
Board.__init__(self, setup=setup)
def __init__(self, setup=False, lboard=None):
if setup == True:
Board.__init__(self, setup=self.shuffle_start(), lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
"* Randomly chosen pieces (two queens or three rooks possible)\n" +
"* Exactly one king of each color\n" +
"* Pieces placed randomly behind the pawns\n" + "* No castling\n" +
"* Black's arrangement mirrors white's")
name = _("Random")
cecp_name = "unknown"
need_initial_board = True
standard_rules = True
variant_group = VARIANTS_SHUFFLE
def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=self.random_start(), lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def random_start(self):
back_rank = random.sample(('r', 'n', 'b', 'q') * 16, 7)
back_rank.append('k')
random.shuffle(back_rank)
fen = ''.join(back_rank)
fen = fen + '/pppppppp/8/8/8/8/PPPPPPPP/' + fen.upper() + ' w - - 0 1'
# return tmp
if __name__ == '__main__':
Board = RandomBoard(True)
for i in range(10):
print(Board.random_start())
class CECPEngine(ProtocolEngine):
def __init__(self, subprocess, color, protover, md5):
ProtocolEngine.__init__(self, subprocess, color, protover, md5)
self.features = {
"ping": 0,
"setboard": 0,
"playother": 0,
"san": 0,
"usermove": 0,
"time": 1,
"draw": 1,
"sigint": 0,
"sigterm": 0,
"reuse": 0,
"analyze": 0,
"myname": ', '.join(self.defname),
"variants": None,
"colors": 1,
"ics": 0,
"name": 0,
"pause": 0,
"nps": 0,
"debug": 0,
"memory": 0,
"smp": 0,
"egt": '',
"option": '',
"exclude": 0,
"done": None,
}
self.supported_features = [
"ping", "setboard", "san", "usermove", "time", "draw", "sigint",
"analyze", "myname", "variants", "colors", "pause", "done", "egt",
"debug", "smp", "memory", "option"
]
self.options = {}
self.options["Ponder"] = {"name": "Ponder",
"type": "check",
"default": False}
self.name = None
self.board = Board(setup=True)
# if self.engineIsInNotPlaying == True, engine is in "force" mode,
# i.e. not thinking or playing, but still verifying move legality
self.engineIsInNotPlaying = False
self.engineIsAnalyzing = False
self.movenext = False
self.waitingForMove = False
self.readyForMoveNowCommand = False
self.timeHandicap = 1
self.lastping = 0
self.lastpong = 0
self.queue = asyncio.Queue()
self.parse_line_task = asyncio.async(self.parseLine(self.engine))
self.died_cid = self.engine.connect("died", lambda e: self.queue.put_nowait("die"))
self.invalid_move = None
self.optionQueue = []
self.undoQueue = []
self.ready_moves_event = asyncio.Event()
self.cids = [
self.connect_after("readyForOptions", self.__onReadyForOptions),
self.connect_after("readyForMoves", self.__onReadyForMoves),
]
# Starting the game
def prestart(self):
print("xboard", file=self.engine)
if self.protover == 1:
# start a new game (CECPv1 engines):
print("new", file=self.engine)
# we are now ready for options:
self.emit("readyForOptions")
elif self.protover == 2:
# start advanced protocol initialisation:
print("protover 2", file=self.engine)
# we don't start a new game for CECPv2 here,
# we will do it after feature accept/reject is completed.
def start(self, event=None):
asyncio.async(self.__startBlocking(event))
@asyncio.coroutine
def __startBlocking(self, event):
if self.protover == 1:
self.emit("readyForMoves")
return_value = "ready"
if self.protover == 2:
try:
return_value = yield from asyncio.wait_for(self.queue.get(), TIME_OUT_SECOND)
if return_value == "not ready":
return_value = yield from asyncio.wait_for(self.queue.get(), TIME_OUT_SECOND)
# Gaviota sends done=0 after "xboard" and after "protover 2" too
if return_value == "not ready":
return_value = yield from asyncio.wait_for(self.queue.get(), TIME_OUT_SECOND)
self.emit("readyForOptions")
self.emit("readyForMoves")
except asyncio.TimeoutError:
log.warning("Got timeout error", extra={"task": self.defname})
raise PlayerIsDead
except:
log.warning("Unknown error", extra={"task": self.defname})
raise PlayerIsDead
else:
if return_value == "die":
raise PlayerIsDead
assert return_value == "ready" or return_value == "del"
if event is not None:
event.set()
def __onReadyForOptions(self, self_):
# We always want post turned on so the Engine Output sidebar can
# show those things -Jonas Thiem
print("post", file=self.engine)
for command in self.optionQueue:
print(command, file=self.engine)
def __onReadyForMoves(self, self_):
if self.mode in (ANALYZING, INVERSE_ANALYZING):
# workaround for crafty not sending analysis after it has found a mating line
# http://code.google.com/p/pychess/issues/detail?id=515
if "crafty" in self.features["myname"].lower():
print("noise 0", file=self.engine)
self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
self.ready_moves_event.set()
self.readyMoves = True
# Ending the game
def end(self, status, reason):
self.parse_line_task.cancel()
if self.engine.handler_is_connected(self.died_cid):
self.engine.disconnect(self.died_cid)
if self.handler_is_connected(self.analyze_cid):
self.disconnect(self.analyze_cid)
for cid in self.cids:
if self.handler_is_connected(cid):
self.disconnect(cid)
self.board = None
if self.connected:
# We currently can't fillout the comment "field" as the repr strings
# for reasons and statuses lies in Main.py
# Creating Status and Reason class would solve this
if status == DRAW:
print("result 1/2-1/2 {?}", file=self.engine)
elif status == WHITEWON:
print("result 1-0 {?}", file=self.engine)
elif status == BLACKWON:
print("result 0-1 {?}", file=self.engine)
else:
print("result * {?}", file=self.engine)
if reason == WON_ADJUDICATION:
self.queue.put_nowait("invalid")
# Make sure the engine exits and do some cleaning
self.kill(reason)
def kill(self, reason):
""" Kills the engine, starting with the 'quit' command, then sigterm and
eventually sigkill.
Returns the exitcode, or if engine have already been killed, returns
None """
if self.connected:
self.connected = False
try:
try:
print("quit", file=self.engine)
self.queue.put_nowait("del")
self.engine.terminate()
except OSError as err:
# No need to raise on a hang up error, as the engine is dead
# anyways
if err.errno == 32:
log.warning("Hung up Error", extra={"task": self.defname})
return err.errno
else:
raise
finally:
# Clear the analyzed data, if any
self.emit("analyze", [])
# Send the player move updates
def setBoard(self, board):
self.setBoardList([board], [])
self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
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
"""
self.setBoardList([board1], [])
self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
@asyncio.coroutine
def makeMove(self, board1, move, board2):
""" Gets a move from the engine (for player engines).
@param board1: The current board
@param move: The last move made
@param board2: The board before the last move was made
@return: The move the engine decided to make
"""
log.debug("makeMove: move=%s self.movenext=%s board1=%s board2=%s self.board=%s" % (
move, self.movenext, board1, board2, self.board), extra={"task": self.defname})
assert self.readyMoves
if self.board == board1 or not board2 or self.movenext:
self.board = board1
self.__tellEngineToPlayCurrentColorAndMakeMove()
self.movenext = False
else:
self.board = board1
self.__usermove(board2, move)
if self.engineIsInNotPlaying:
self.__tellEngineToPlayCurrentColorAndMakeMove()
self.waitingForMove = True
self.readyForMoveNowCommand = True
# Parse outputs
status = yield from self.queue.get()
if status == "not ready":
log.warning(
"Engine seems to be protover=2, but is treated as protover=1",
extra={"task": self.defname})
status = yield from self.queue.get()
if status == "ready":
status = yield from self.queue.get()
if status == "invalid":
raise InvalidMove
if status == "del":
raise PlayerIsDead("Killed by foreign forces")
if status == "int":
raise TurnInterrupt
self.waitingForMove = False
self.readyForMoveNowCommand = False
assert isinstance(status, Move), status
return status
def updateTime(self, secs, opsecs):
if self.features["time"]:
print("time %s" % int(secs * 100 * self.timeHandicap),
file=self.engine)
print("otim %s" % int(opsecs * 100), file=self.engine)
# Standard options
def setOptionAnalyzing(self, mode):
self.mode = mode
def setOptionInitialBoard(self, model):
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[:])
asyncio.async(coro())
def setBoardList(self, boards, moves):
# Notice: If this method is to be called while playing, the engine will
# need 'new' and an arrangement similar to that of 'pause' to avoid
# the current thought move to appear
if self.mode not in (ANALYZING, INVERSE_ANALYZING):
self.__tellEngineToStopPlayingCurrentColor()
self.__setBoard(boards[0])
self.board = boards[-1]
for board, move in zip(boards[:-1], moves):
self.__usermove(board, move)
if self.mode in (ANALYZING, INVERSE_ANALYZING):
self.board = boards[-1]
if self.mode == INVERSE_ANALYZING:
self.board = self.board.switchColor()
# The called of setBoardList will have to repost/analyze the
# analyzer engines at this point.
def setOptionVariant(self, variant):
if self.features["variants"] is None:
log.warning("setOptionVariant: engine doesn't support variants",
extra={"task": self.defname})
return
if variant in variants.values() and not variant.standard_rules:
assert variant.cecp_name in self.features["variants"], \
"%s doesn't support %s variant" % (self, variant.cecp_name)
self.optionQueue.append("variant %s" % variant.cecp_name)
# Strength system #
# Strength Depth Ponder Time handicap #
# 1 1 o 1,258% #
# 2 2 o 1,584% #
# 3 3 o 1.995% #
# #
# 19 o x 79,43% #
# 20 o x o #
def setOptionStrength(self, strength, forcePonderOff):
self.strength = strength
if strength <= 19:
self.__setTimeHandicap(0.01 * 10**(strength / 10.))
if strength <= 18:
self.__setDepth(strength)
# Crafty ofers 100 skill levels
if "crafty" in self.features["myname"].lower() and strength <= 19:
self.optionQueue.append("skill %s" % strength * 5)
self.__setPonder(strength >= 19 and not forcePonderOff)
if strength == 20:
if "gaviota" in self.features["egt"]:
self.optionQueue.append("egtpath gaviota %s" % conf.get(
"egtb_path", ""))
else:
self.optionQueue.append("random")
def __setDepth(self, depth):
self.optionQueue.append("sd %d" % depth)
def __setTimeHandicap(self, timeHandicap):
self.timeHandicap = timeHandicap
def __setPonder(self, ponder):
if ponder:
self.optionQueue.append("hard")
else:
self.optionQueue.append("hard")
self.optionQueue.append("easy")
def setOptionTime(self, secs, gain, moves):
# Notice: In CECP we apply time handicap in updateTime, not in
# setOptionTime.
minutes = int(secs / 60)
secs = int(secs % 60)
mins = str(minutes)
if secs:
mins += ":" + str(secs)
self.optionQueue.append("level %s %s %d" % (moves, mins, gain))
# Option handling
def setOption(self, key, value):
""" Set an option, which will be sent to the engine, after the
'readyForOptions' signal has passed.
If you want to know the possible options, you should go to
engineDiscoverer or use the getOption, getOptions and hasOption
methods, while you are in your 'readyForOptions' signal handler """
if self.readyMoves:
log.warning(
"Options set after 'readyok' are not sent to the engine",
extra={"task": self.defname})
if key == "cores":
self.optionQueue.append("cores %s" % value)
elif key == "memory":
self.optionQueue.append("memory %s" % value)
elif key.lower() == "ponder":
self.__setPonder(value == 1)
else:
self.optionQueue.append("option %s=%s" % (key, value))
# Interacting with the player
def pause(self):
""" Pauses engine using the "pause" command if available. Otherwise put
engine in force mode. By the specs the engine shouldn't ponder in
force mode, but some of them do so anyways. """
log.debug("pause: self=%s" % self, extra={"task": self.defname})
self.engine.pause()
return
def resume(self):
log.debug("resume: self=%s" % self, extra={"task": self.defname})
self.engine.resume()
return
def hurry(self):
log.debug("hurry: self.waitingForMove=%s self.readyForMoveNowCommand=%s" % (
self.waitingForMove, self.readyForMoveNowCommand), extra={"task": self.defname})
if self.waitingForMove and self.readyForMoveNowCommand:
self.__tellEngineToMoveNow()
self.readyForMoveNowCommand = False
def spectatorUndoMoves(self, moves, gamemodel):
log.debug("spectatorUndoMoves: moves=%s gamemodel.ply=%s gamemodel.boards[-1]=%s self.board=%s" % (
moves, gamemodel.ply, gamemodel.boards[-1], self.board), extra={"task": self.defname})
for i in range(moves):
print("undo", file=self.engine)
self.board = gamemodel.boards[-1]
def playerUndoMoves(self, moves, gamemodel):
log.debug("playerUndoMoves: moves=%s gamemodel.ply=%s gamemodel.boards[-1]=%s self.board=%s" % (
moves, gamemodel.ply, gamemodel.boards[-1], self.board), extra={"task": self.defname})
if gamemodel.curplayer != self and moves % 2 == 1:
# Interrupt if we were searching, but should no longer do so
self.queue.put_nowait("int")
self.__tellEngineToStopPlayingCurrentColor()
for i in range(moves):
print("undo", file=self.engine)
if gamemodel.curplayer == self:
self.board = gamemodel.boards[-1]
self.__tellEngineToPlayCurrentColorAndMakeMove()
else:
self.board = None
# Offer handling
def offer(self, offer):
if offer.type == DRAW_OFFER:
if self.features["draw"]:
print("draw", file=self.engine)
else:
self.emit("accept", offer)
def offerError(self, offer, error):
if self.features["draw"]:
# We don't keep track if engine draws are offers or accepts. We just
# Always assume they are accepts, and if they are not, we get this
# error and emit offer instead
if offer.type == DRAW_OFFER and error == ACTION_ERROR_NONE_TO_ACCEPT:
self.emit("offer", Offer(DRAW_OFFER))
# Internal
def __usermove(self, board, move):
if self.features["usermove"]:
self.engine.write("usermove ")
if self.features["san"]:
print(toSAN(board, move), file=self.engine)
else:
castle_notation = CASTLE_KK
if board.variant == FISCHERRANDOMCHESS:
castle_notation = CASTLE_SAN
print(
toAN(board,
move,
short=True,
castleNotation=castle_notation),
file=self.engine)
def __tellEngineToMoveNow(self):
if self.features["sigint"]:
self.engine.sigint()
print("?", file=self.engine)
def __tellEngineToStopPlayingCurrentColor(self):
print("force", file=self.engine)
self.engineIsInNotPlaying = True
def __tellEngineToPlayCurrentColorAndMakeMove(self):
self.__printColor()
print("go", file=self.engine)
self.engineIsInNotPlaying = False
def __sendAnalyze(self, inverse=False):
if inverse and self.board.board.opIsChecked():
# Many engines don't like positions able to take down enemy
# king. Therefore we just return the "kill king" move
# automaticaly
self.emit("analyze", [([toAN(
self.board, getMoveKillingKing(self.board))], MATE_VALUE - 1, "")])
return
def stop_analyze():
if self.engineIsAnalyzing:
print("exit", file=self.engine)
# Some engines (crafty, gnuchess) doesn't respond to exit command
# we try to force them to stop with an empty board fen
print("setboard 8/8/8/8/8/8/8/8 w - - 0 1", file=self.engine)
self.engineIsAnalyzing = False
print("post", file=self.engine)
print("analyze", file=self.engine)
self.engineIsAnalyzing = True
loop = asyncio.get_event_loop()
loop.call_later(conf.get("max_analysis_spin", 3), stop_analyze)
def __printColor(self):
if self.features["colors"]: # or self.mode == INVERSE_ANALYZING:
if self.board.color == WHITE:
print("white", file=self.engine)
else:
print("black", file=self.engine)
def __setBoard(self, board):
if self.features["setboard"]:
self.__tellEngineToStopPlayingCurrentColor()
fen = board.asFen(enable_bfen=False)
if self.mode == INVERSE_ANALYZING:
fen_arr = fen.split()
if not self.board.board.opIsChecked():
if fen_arr[1] == "b":
fen_arr[1] = "w"
else:
fen_arr[1] = "b"
fen = " ".join(fen_arr)
print("setboard %s" % fen, file=self.engine)
else:
# Kludge to set black to move, avoiding the troublesome and now
# deprecated "black" command. - Equal to the one xboard uses
self.__tellEngineToStopPlayingCurrentColor()
if board.color == BLACK:
print("a2a3", file=self.engine)
print("edit", file=self.engine)
print("#", file=self.engine)
for color in WHITE, BLACK:
for y_loc, row in enumerate(board.data):
for x_loc, piece in row.items():
if not piece or piece.color != color:
continue
sign = reprSign[piece.sign]
cord = repr(Cord(x_loc, y_loc))
print(sign + cord, file=self.engine)
print("c", file=self.engine)
print(".", file=self.engine)
# Parsing
@asyncio.coroutine
def parseLine(self, proc):
while True:
line = yield from wait_signal(proc, 'line')
if not line:
break
else:
line = line[1]
if line[0:1] == "#":
# Debug line which we shall ignore as specified in CECPv2 specs
continue
# log.debug("__parseLine: line=\"%s\"" % line.strip(), extra={"task":self.defname})
parts = whitespaces.split(line.strip())
if parts[0] == "pong":
self.lastpong = int(parts[1])
continue
# Illegal Move
if parts[0].lower().find("illegal") >= 0:
log.warning("__parseLine: illegal move: line=\"%s\", board=%s" % (
line.strip(), self.board), extra={"task": self.defname})
if parts[-2] == "sd" and parts[-1].isdigit():
print("depth", parts[-1], file=self.engine)
continue
# A Move (Perhaps)
if self.board:
if parts[0] == "move":
movestr = parts[1]
# Old Variation
elif d_plus_dot_expr.match(parts[0]) and parts[1] == "...":
movestr = parts[2]
else:
movestr = False
if movestr:
self.waitingForMove = False
self.readyForMoveNowCommand = False
if self.engineIsInNotPlaying:
# If engine was set in pause just before the engine sent its
# move, we ignore it. However the engine has to know that we
# ignored it, and thus we step it one back
log.info("__parseLine: Discarding engine's move: %s" %
movestr,
extra={"task": self.defname})
print("undo", file=self.engine)
continue
else:
try:
move = parseAny(self.board, movestr)
except ParsingError:
self.invalid_move = movestr
log.info(
"__parseLine: ParsingError engine move: %s %s"
% (movestr, self.board),
extra={"task": self.defname})
self.end(WHITEWON if self.board.color == BLACK else
BLACKWON, WON_ADJUDICATION)
continue
if validate(self.board, move):
self.board = None
self.queue.put_nowait(move)
continue
else:
self.invalid_move = movestr
log.info(
"__parseLine: can't validate engine move: %s %s"
% (movestr, self.board),
extra={"task": self.defname})
self.end(WHITEWON if self.board.color == BLACK else
BLACKWON, WON_ADJUDICATION)
continue
# Analyzing
if self.engineIsInNotPlaying:
if parts[:4] == ["0", "0", "0", "0"]:
# Crafty doesn't analyze until it is out of book
print("book off", file=self.engine)
continue
match = anare.match(line)
if match:
depth, score, moves = match.groups()
if "mat" in score.lower() or "#" in moves:
# Will look either like -Mat 3 or Mat3
scoreval = MATE_VALUE
if score.startswith('-'):
scoreval = -scoreval
else:
scoreval = int(score)
mvstrs = movere.findall(moves)
if mvstrs:
self.emit("analyze", [(mvstrs, scoreval, depth.strip())])
continue
# Offers draw
if parts[0:2] == ["offer", "draw"]:
self.emit("accept", Offer(DRAW_OFFER))
continue
# Resigns
if parts[0] == "resign" or \
(parts[0] == "tellics" and parts[1] == "resign"): # buggy crafty
# Previously: if "resign" in parts,
# however, this is too generic, since "hint", "bk",
# "feature option=.." and possibly other, future CECPv2
# commands can validly contain the word "resign" without this
# being an intentional resign offer.
self.emit("offer", Offer(RESIGNATION))
continue
# if parts[0].lower() == "error":
# continue
# Tell User Error
if parts[0] == "tellusererror":
# We don't want to see our stop analyzer hack as an error message
if "8/8/8/8/8/8/8/8" in "".join(parts[1:]):
continue
# Create a non-modal non-blocking message dialog with the error:
dlg = Gtk.MessageDialog(parent=None,
flags=0,
type=Gtk.MessageType.WARNING,
buttons=Gtk.ButtonsType.CLOSE,
message_format=None)
# Use the engine name if already known, otherwise the defname:
displayname = self.name
if not displayname:
displayname = self.defname
# Compose the dialog text:
dlg.set_markup(GObject.markup_escape_text(_(
"The engine %s reports an error:") % displayname) + "\n\n" +
GObject.markup_escape_text(" ".join(parts[1:])))
# handle response signal so the "Close" button works:
dlg.connect("response", lambda dlg, x: dlg.destroy())
dlg.show_all()
continue
# Tell Somebody
if parts[0][:4] == "tell" and \
parts[0][4:] in ("others", "all", "ics", "icsnoalias"):
log.info("Ignoring tell %s: %s" %
(parts[0][4:], " ".join(parts[1:])))
continue
if "feature" in parts:
# Some engines send features after done=1, so we will iterate after done=1 too
done1 = False
# We skip parts before 'feature', as some engines give us lines like
# White (1) : feature setboard=1 analyze...e="GNU Chess 5.07" done=1
parts = parts[parts.index("feature"):]
for i, pair in enumerate(parts[1:]):
# As "parts" is split with no thoughs on quotes or double quotes
# we need to do some extra handling.
if pair.find("=") < 0:
continue
key, value = pair.split("=", 1)
if key not in self.features:
continue
if value.startswith('"') and value.endswith('"'):
value = value[1:-1]
# If our pair was unfinished, like myname="GNU, we search the
# rest of the pairs for a quotating mark.
elif value[0] == '"':
rest = value[1:] + " " + " ".join(parts[2 + i:])
j = rest.find('"')
if j == -1:
log.warning("Missing endquotation in %s feature",
extra={"task": self.defname})
value = rest
else:
value = rest[:j]
elif value.isdigit():
value = int(value)
if key in self.supported_features:
print("accepted %s" % key, file=self.engine)
else:
print("rejected %s" % key, file=self.engine)
if key == "done":
if value == 1:
done1 = True
continue
elif value == 0:
log.info("Adds %d seconds timeout" % TIME_OUT_SECOND,
extra={"task": self.defname})
# This'll buy you some more time
self.queue.put_nowait("not ready")
break
if key == "smp" and value == 1:
self.options["cores"] = {"name": "cores",
"type": "spin",
"default": 1,
"min": 1,
"max": 64}
elif key == "memory" and value == 1:
self.options["memory"] = {"name": "memory",
"type": "spin",
"default": 32,
"min": 1,
"max": 4096}
elif key == "option" and key != "done":
option = self.__parse_option(value)
self.options[option["name"]] = option
else:
self.features[key] = value
if key == "myname" and not self.name:
self.setName(value)
if done1:
# Start a new game before using the engine:
# (CECPv2 engines)
print("new", file=self.engine)
# We are now ready for play:
self.emit("readyForOptions")
self.emit("readyForMoves")
self.queue.put_nowait("ready")
# A hack to get better names in protover 1.
# Unfortunately it wont work for now, as we don't read any lines from
# protover 1 engines. When should we stop?
if self.protover == 1:
if self.defname[0] in ''.join(parts):
basis = self.defname[0]
name = ' '.join(itertools.dropwhile(
lambda part: basis not in part, parts))
self.features['myname'] = name
if not self.name:
self.setName(name)
def __parse_option(self, option):
if " -check " in option:
name, value = option.split(" -check ")
return {"type": "check", "name": name, "default": bool(int(value))}
elif " -spin " in option:
name, value = option.split(" -spin ")
defv, minv, maxv = value.split()
return {"type": "spin",
"name": name,
"default": int(defv),
"min": int(minv),
"max": int(maxv)}
elif " -slider " in option:
name, value = option.split(" -slider ")
defv, minv, maxv = value.split()
return {"type": "spin",
"name": name,
"default": int(defv),
"min": int(minv),
"max": int(maxv)}
elif " -string " in option:
name, value = option.split(" -string ")
return {"type": "text", "name": name, "default": value}
elif " -file " in option:
name, value = option.split(" -file ")
return {"type": "text", "name": name, "default": value}
elif " -path " in option:
name, value = option.split(" -path ")
return {"type": "text", "name": name, "default": value}
elif " -combo " in option:
name, value = option.split(" -combo ")
choices = list(map(str.strip, value.split("///")))
default = ""
for choice in choices:
if choice.startswith("*"):
index = choices.index(choice)
default = choice[1:]
choices[index] = default
break
return {"type": "combo",
"name": name,
"default": default,
"choices": choices}
elif " -button" in option:
pos = option.find(" -button")
return {"type": "button", "name": option[:pos]}
elif " -save" in option:
pos = option.find(" -save")
return {"type": "button", "name": option[:pos]}
elif " -reset" in option:
pos = option.find(" -reset")
return {"type": "button", "name": option[:pos]}
# Info
def canAnalyze(self):
assert self.ready, "Still waiting for done=1"
return self.features["analyze"]
def maxAnalysisLines(self):
return 1
def requestMultiPV(self, setting):
return 1
def isAnalyzing(self):
return self.mode in (ANALYZING, INVERSE_ANALYZING)
def __repr__(self):
if self.name:
return self.name
return self.features["myname"]
def __init__ (self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=THEBANSTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def __init__(self, subprocess, color, protover, md5):
ProtocolEngine.__init__(self, subprocess, color, protover, md5)
self.features = {
"ping": 0,
"setboard": 0,
"playother": 0,
"san": 0,
"usermove": 0,
"time": 1,
"draw": 1,
"sigint": 0,
"sigterm": 0,
"reuse": 0,
"analyze": 0,
"myname": ', '.join(self.defname),
"variants": None,
"colors": 1,
"ics": 0,
"name": 0,
"pause": 0,
"nps": 0,
"debug": 0,
"memory": 0,
"smp": 0,
"egt": '',
"option": '',
"exclude": 0,
"done": None,
}
self.supported_features = [
"ping", "setboard", "san", "usermove", "time", "draw", "sigint",
"analyze", "myname", "variants", "colors", "pause", "done", "egt",
"debug", "smp", "memory", "option"
]
self.options = {}
self.options["Ponder"] = {"name": "Ponder",
"type": "check",
"default": False}
self.name = None
self.board = Board(setup=True)
# if self.engineIsInNotPlaying == True, engine is in "force" mode,
# i.e. not thinking or playing, but still verifying move legality
self.engineIsInNotPlaying = False
self.engineIsAnalyzing = False
self.movenext = False
self.waitingForMove = False
self.readyForMoveNowCommand = False
self.timeHandicap = 1
self.lastping = 0
self.lastpong = 0
self.queue = asyncio.Queue()
self.parse_line_task = asyncio.async(self.parseLine(self.engine))
self.died_cid = self.engine.connect("died", lambda e: self.queue.put_nowait("die"))
self.invalid_move = None
self.optionQueue = []
self.undoQueue = []
self.ready_moves_event = asyncio.Event()
self.cids = [
self.connect_after("readyForOptions", self.__onReadyForOptions),
self.connect_after("readyForMoves", self.__onReadyForMoves),
]
def __init__ (self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=PAWNSPASSEDSTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
Board.__init__(self, setup=self.shuffle_start())
else:
Board.__init__(self, setup=setup)
def shuffle_start(self):
tmp = ['r', 'n', 'b', 'q', 'k', 'b', 'n', 'r']
random.shuffle(tmp)
tmp = ''.join(tmp)
tmp = tmp + '/pppppppp/8/8/8/8/PPPPPPPP/' + tmp.upper() + ' w - - 0 1'
return tmp
class ShuffleChess:
__desc__ = _("xboard nocastle: http://tim-mann.org/xboard/engine-intf.html#8\n" +
"FICS wild/2: http://www.freechess.org/Help/HelpFiles/wild.html\n" +
"* Random arrangement of the pieces behind the pawns\n" +
"* No castling\n" +
"* Black's arrangement mirrors white's")
name = _("Shuffle")
cecp_name = "nocastle"
board = ShuffleBoard
need_initial_board = True
standard_rules = True
variant_group = VARIANTS_SHUFFLE
if __name__ == '__main__':
Board = ShuffleBoard(True)
for i in range(10):
print Board.shuffle_start()
def __init__(self, setup=False, lboard=None):
if setup is True:
Board.__init__(self, setup=KAMBODIANSTART, lboard=lboard)
else:
Board.__init__(self, setup=setup, lboard=lboard)
def random_start(self):
tmp = random.sample(('r', 'n', 'b', 'q')*16, 7)
tmp.append('k')
random.shuffle(tmp)
tmp = ''.join(tmp)
tmp = tmp + '/pppppppp/8/8/8/8/PPPPPPPP/' + tmp.upper() + ' w - - 0 1'
return tmp
class RandomChess:
__desc__ = _("FICS wild/3: http://www.freechess.org/Help/HelpFiles/wild.html\n" +
"* Randomly chosen pieces (two queens or three rooks possible)\n" +
"* Exactly one king of each color\n" +
"* Pieces placed randomly behind the pawns\n" +
"* No castling\n" +
"* Black's arrangement mirrors white's")
name = _("Random")
cecp_name = "unknown"
board = RandomBoard
need_initial_board = True
standard_rules = True
variant_group = VARIANTS_SHUFFLE
if __name__ == '__main__':
Board = RandomBoard(True)
for i in range(10):
print Board.random_start()
def __init__(self, setup=False):
if setup is True:
Board.__init__(self, setup=self.random_start())
else:
Board.__init__(self, setup=setup)
class UCIEngine (ProtocolEngine):
def __init__ (self, subprocess, color, protover, md5):
ProtocolEngine.__init__(self, subprocess, color, protover, md5)
self.ids = {}
self.options = {}
self.optionsToBeSent = {}
self.wtime = 60000
self.btime = 60000
self.incr = 0
self.timeHandicap = 1
self.moveLock = RLock()
# none of the following variables should be changed or used in a
# condition statement without holding the above self.moveLock
self.ponderOn = False
self.pondermove = None
self.ignoreNext = False
self.waitingForMove = False
self.needBestmove = False
self.readyForStop = False # keeps track of whether we already sent a 'stop' command
self.multipvSetting = conf.get("multipv", 1) # MultiPV option sent to the engine
self.multipvExpected = 1 # Number of PVs expected (limited by number of legal moves)
self.commands = collections.deque()
self.gameBoard = Board(setup=True) # board at the end of all moves played
self.board = Board(setup=True) # board to send the engine
self.uciPosition = "startpos"
self.uciPositionListsMoves = False
self.analysis = [ None ]
self.returnQueue = Queue()
self.engine.connect("line", self.parseLines)
self.engine.connect("died", self.__die)
self.connect("readyForOptions", self.__onReadyForOptions_before)
self.connect_after("readyForOptions", self.__onReadyForOptions)
self.connect_after("readyForMoves", self.__onReadyForMoves)
def __die (self, subprocess):
self.returnQueue.put("die")
#===========================================================================
# Starting the game
#===========================================================================
def prestart (self):
print("uci", file=self.engine)
def start (self):
if self.mode in (ANALYZING, INVERSE_ANALYZING):
t = Thread(target=self.__startBlocking,
name=fident(self.__startBlocking))
t.daemon = True
t.start()
else:
self.__startBlocking()
def __startBlocking (self):
r = self.returnQueue.get()
if r == 'die':
raise PlayerIsDead
assert r == "ready" or r == 'del'
#self.emit("readyForOptions")
#self.emit("readyForMoves")
def __onReadyForOptions_before (self, self_):
self.readyOptions = True
def __onReadyForOptions (self, self_):
if self.mode in (ANALYZING, INVERSE_ANALYZING):
if self.hasOption("Ponder"):
self.setOption('Ponder', False)
if self.hasOption("MultiPV") and self.multipvSetting > 1:
self.setOption('MultiPV', self.multipvSetting)
for option, value in self.optionsToBeSent.items():
if isinstance(value, bool):
value = str(value).lower()
print("setoption name %s value %s" % (option, str(value)), file=self.engine)
print("isready", file=self.engine)
def __onReadyForMoves (self, self_):
self.returnQueue.put("ready")
self.readyMoves = True
self._newGame()
# If we are an analyzer, this signal was already called in a different
# thread, so we can safely block it.
if self.mode in (ANALYZING, INVERSE_ANALYZING):
self._searchNow()
#===========================================================================
# Ending the game
#===========================================================================
def end (self, status, reason):
# UCI doens't care about reason, so we just kill
self.kill(reason)
def kill (self, reason):
""" Kills the engine, starting with the 'stop' and 'quit' commands, then
trying sigterm and eventually sigkill.
Returns the exitcode, or if engine have already been killed, the
method returns None """
if self.connected:
self.connected = False
try:
try:
print("stop", file=self.engine)
print("quit", file=self.engine)
self.returnQueue.put("del")
return self.engine.gentleKill()
except OSError as e:
# No need to raise on a hang up error, as the engine is dead
# anyways
if e.errno == 32:
log.warning("Hung up Error", extra={"task":self.defname})
return e.errno
else: raise
finally:
# Clear the analyzed data, if any
self.emit("analyze", [])
#===========================================================================
# Send the player move updates
#===========================================================================
def _moveToUCI (self, board, move):
cn = CASTLE_KK
if board.variant == FISCHERRANDOMCHESS:
cn = CASTLE_KR
return toAN(board, move, short=True, castleNotation=cn)
def _recordMove (self, board1, move, board2):
if self.gameBoard == board1:
return
if not board2:
if board1.variant == NORMALCHESS and board1.asFen() == FEN_START:
self.uciPosition = "startpos"
else:
self.uciPosition = "fen " + board1.asFen()
self.uciPositionListsMoves = False
if move:
if not self.uciPositionListsMoves:
self.uciPosition += " moves"
self.uciPositionListsMoves = True
self.uciPosition += " " + self._moveToUCI(board2, move)
self.board = self.gameBoard = board1
if self.mode == INVERSE_ANALYZING:
self.board = self.gameBoard.switchColor()
def _recordMoveList (self, model, ply=None):
self._recordMove(model.boards[0], None, None)
if ply is None:
ply = model.ply
for board1, move, board2 in zip(model.boards[1:ply+1], model.moves, model.boards[0:ply]):
self._recordMove(board1, move, board2)
def setBoard (self, board):
log.debug("setBoardAtPly: board=%s" % board, extra={"task":self.defname})
self._recordMove(board, None, None)
if not self.readyMoves:
return
self._searchNow()
def putMove (self, board1, move, board2):
log.debug("putMove: board1=%s move=%s board2=%s self.board=%s" % \
(board1, move, board2, self.board), extra={"task":self.defname})
self._recordMove(board1, move, board2)
if not self.readyMoves:
return
self._searchNow()
def makeMove (self, board1, move, board2):
log.debug("makeMove: move=%s self.pondermove=%s board1=%s board2=%s self.board=%s" % \
(move, self.pondermove, board1, board2, self.board), extra={"task":self.defname})
assert self.readyMoves
with self.moveLock:
self._recordMove(board1, move, board2)
self.waitingForMove = True
ponderhit = False
if board2 and self.pondermove and move == self.pondermove:
ponderhit = True
elif board2 and self.pondermove:
self.ignoreNext = True
print("stop", file=self.engine)
self._searchNow(ponderhit=ponderhit)
# Parse outputs
try:
r = self.returnQueue.get()
if r == "del":
raise PlayerIsDead
if r == "int":
with self.moveLock:
self.pondermove = None
self.ignoreNext = True
self.needBestmove = True
self.hurry()
raise TurnInterrupt
return r
finally:
with self.moveLock:
self.waitingForMove = False
# empty the queue of any moves received post-undo/TurnInterrupt
self.returnQueue.queue.clear()
def updateTime (self, secs, opsecs):
if self.color == WHITE:
self.wtime = int(secs*1000*self.timeHandicap)
self.btime = int(opsecs*1000)
else:
self.btime = int(secs*1000*self.timeHandicap)
self.wtime = int(opsecs*1000)
#===========================================================================
# Standard options
#===========================================================================
def setOptionAnalyzing (self, mode):
self.mode = mode
if self.mode == INVERSE_ANALYZING:
self.board = self.gameBoard.switchColor()
def setOptionInitialBoard (self, model):
log.debug("setOptionInitialBoard: self=%s, model=%s" % \
(self, model), extra={"task":self.defname})
self._recordMoveList(model)
def setOptionVariant (self, variant):
if variant == FischerRandomChess:
assert self.hasOption("UCI_Chess960")
self.setOption("UCI_Chess960", True)
elif self.hasOption("UCI_Variant") and not variant.standard_rules:
self.setOption("UCI_Variant", variant.cecp_name)
def setOptionTime (self, secs, gain):
self.wtime = int(max(secs*1000*self.timeHandicap, 1))
self.btime = int(max(secs*1000*self.timeHandicap, 1))
self.incr = int(gain*1000*self.timeHandicap)
def setOptionStrength (self, strength, forcePonderOff):
self.strength = strength
if self.hasOption('UCI_LimitStrength') and strength <= 18:
self.setOption('UCI_LimitStrength', True)
if self.hasOption('UCI_Elo'):
self.setOption('UCI_Elo', 150 * strength)
# Stockfish offers 20 skill levels
if self.hasOption('Skill Level') and strength <= 19:
self.setOption('Skill Level', strength)
if ((not self.hasOption('UCI_Elo')) and (not self.hasOption('Skill Level'))) or strength <= 19:
self.timeHandicap = th = 0.01 * 10**(strength/10.)
self.wtime = int(max(self.wtime*th, 1))
self.btime = int(max(self.btime*th, 1))
self.incr = int(self.incr*th)
if self.hasOption('Ponder'):
self.setOption('Ponder', strength >= 19 and not forcePonderOff)
if self.hasOption('GaviotaTbPath') and strength == 20:
self.setOption('GaviotaTbPath', conf.get("egtb_path", ""))
#===========================================================================
# Interacting with the player
#===========================================================================
def pause (self):
log.debug("pause: self=%s" % self, extra={"task":self.defname})
self.engine.pause()
return
if self.board.color == self.color or \
self.mode != NORMAL or self.pondermove:
self.ignoreNext = True
print("stop", file=self.engine)
def resume (self):
log.debug("resume: self=%s" % self, extra={"task":self.defname})
self.engine.resume()
return
if self.mode == NORMAL:
if self.board.color == self.color:
self._searchNow()
elif self.ponderOn and self.pondermove:
self._startPonder()
else:
self._searchNow()
def hurry (self):
log.debug("hurry: self.waitingForMove=%s self.readyForStop=%s" % \
(self.waitingForMove, self.readyForStop), extra={"task":self.defname})
# sending this more than once per move will crash most engines
# so we need to send only the first one, and then ignore every "hurry" request
# after that until there is another outstanding "position..go"
with self.moveLock:
if self.waitingForMove and self.readyForStop:
print("stop", file=self.engine)
self.readyForStop = False
def playerUndoMoves (self, moves, gamemodel):
log.debug("playerUndoMoves: moves=%s gamemodel.ply=%s gamemodel.boards[-1]=%s self.board=%s" % \
(moves, gamemodel.ply, gamemodel.boards[-1], self.board), extra={"task":self.defname})
self._recordMoveList(gamemodel)
if (gamemodel.curplayer != self and moves % 2 == 1) or \
(gamemodel.curplayer == self and moves % 2 == 0):
# Interrupt if we were searching but should no longer do so, or
# if it is was our move before undo and it is still our move after undo
# since we need to send the engine the new FEN in makeMove()
log.debug("playerUndoMoves: putting 'int' into self.returnQueue=%s" % \
self.returnQueue.queue, extra={"task":self.defname})
self.returnQueue.put("int")
def spectatorUndoMoves (self, moves, gamemodel):
log.debug("spectatorUndoMoves: moves=%s gamemodel.ply=%s gamemodel.boards[-1]=%s self.board=%s" % \
(moves, gamemodel.ply, gamemodel.boards[-1], self.board), extra={"task":self.defname})
self._recordMoveList(gamemodel)
if self.readyMoves:
self._searchNow()
#===========================================================================
# Offer handling
#===========================================================================
def offer (self, offer):
if offer.type == DRAW_OFFER:
self.emit("decline", offer)
else:
self.emit("accept", offer)
#===========================================================================
# Option handling
#===========================================================================
def setOption (self, key, value):
""" Set an option, which will be sent to the engine, after the
'readyForOptions' signal has passed.
If you want to know the possible options, you should go to
engineDiscoverer or use the getOption, getOptions and hasOption
methods, while you are in your 'readyForOptions' signal handler """
if self.readyMoves:
log.warning("Options set after 'readyok' are not sent to the engine", extra={"task":self.defname})
self.optionsToBeSent[key] = value
self.ponderOn = key=="Ponder" and value is True
def getOption (self, option):
assert self.readyOptions
if option in self.options:
return self.options[option]["default"]
return None
def getOptions (self):
assert self.readyOptions
return copy(self.options)
def hasOption (self, key):
assert self.readyOptions
return key in self.options
#===========================================================================
# Internal
#===========================================================================
def _newGame (self):
print("ucinewgame", file=self.engine)
def _searchNow (self, ponderhit=False):
log.debug("_searchNow: self.needBestmove=%s ponderhit=%s self.board=%s" % \
(self.needBestmove, ponderhit, self.board), extra={"task":self.defname})
with self.moveLock:
commands = []
if ponderhit:
commands.append("ponderhit")
elif self.mode == NORMAL:
commands.append("position %s" % self.uciPosition)
if self.strength <= 3:
commands.append("go depth %d" % self.strength)
else:
commands.append("go wtime %d winc %d btime %d binc %d" % \
(self.wtime, self.incr, self.btime, self.incr))
else:
print("stop", file=self.engine)
if self.mode == INVERSE_ANALYZING:
if self.board.board.opIsChecked():
# Many engines don't like positions able to take down enemy
# king. Therefore we just return the "kill king" move
# automaticaly
self.emit("analyze", [([getMoveKillingKing(self.board)], MATE_VALUE-1, "")])
return
commands.append("position fen %s" % self.board.asFen())
else:
commands.append("position %s" % self.uciPosition)
#commands.append("go infinite")
move_time = int(conf.get("max_analysis_spin", 3))*1000
commands.append("go movetime %s" % move_time)
if self.hasOption("MultiPV") and self.multipvSetting > 1:
self.multipvExpected = min(self.multipvSetting, legalMoveCount(self.board))
else:
self.multipvExpected = 1
self.analysis = [None] * self.multipvExpected
if self.needBestmove:
self.commands.append(commands)
log.debug("_searchNow: self.needBestmove==True, appended to self.commands=%s" % \
self.commands, extra={"task":self.defname})
else:
for command in commands:
print(command, file=self.engine)
if getStatus(self.board)[1] != WON_MATE: # XXX This looks fishy.
self.needBestmove = True
self.readyForStop = True
def _startPonder (self):
uciPos = self.uciPosition
if not self.uciPositionListsMoves:
uciPos += " moves"
print("position", uciPos, \
self._moveToUCI(self.board, self.pondermove), file=self.engine)
print("go ponder wtime", self.wtime, \
"winc", self.incr, "btime", self.btime, "binc", self.incr, file=self.engine)
#===========================================================================
# Parsing from engine
#===========================================================================
def parseLines (self, engine, lines):
for line in lines:
self.__parseLine(line)
def __parseLine (self, line):
if not self.connected: return
parts = line.split()
if not parts: return
#---------------------------------------------------------- Initializing
if parts[0] == "id":
self.ids[parts[1]] = " ".join(parts[2:])
if parts[1] == "name":
self.setName(self.ids["name"])
return
if parts[0] == "uciok":
self.emit("readyForOptions")
return
if parts[0] == "readyok":
self.emit("readyForMoves")
return
#------------------------------------------------------- Options parsing
if parts[0] == "option":
dic = {}
last = 1
varlist = []
for i in range (2, len(parts)+1):
if i == len(parts) or parts[i] in OPTKEYS:
key = parts[last]
value = " ".join(parts[last+1:i])
if "type" in dic and dic["type"] in TYPEDIC:
value = TYPEDIC[dic["type"]](value)
if key == "var":
varlist.append(value)
elif key == "type" and value == "string":
dic[key] = "text"
else:
dic[key] = value
last = i
if varlist:
dic["choices"] = varlist
self.options[dic["name"]] = dic
return
#---------------------------------------------------------------- A Move
if self.mode == NORMAL and parts[0] == "bestmove":
with self.moveLock:
self.needBestmove = False
self.__sendQueuedGo()
if self.ignoreNext:
log.debug("__parseLine: line='%s' self.ignoreNext==True, returning" % \
line.strip(), extra={"task":self.defname})
self.ignoreNext = False
self.readyForStop = True
return
if not self.waitingForMove:
log.warning("__parseLine: self.waitingForMove==False, ignoring move=%s" % \
parts[1], extra={"task":self.defname})
self.pondermove = None
return
self.waitingForMove = False
try:
move = parseAny(self.board, parts[1])
except ParsingError as e:
self.end(WHITEWON if self.board.color == BLACK else BLACKWON, WON_ADJUDICATION)
return
if not validate(self.board, move):
# This is critical. To avoid game stalls, we need to resign on
# behalf of the engine.
log.error("__parseLine: move=%s didn't validate, putting 'del' in returnQueue. self.board=%s" % \
(repr(move), self.board), extra={"task":self.defname})
self.end(WHITEWON if self.board.color == BLACK else BLACKWON, WON_ADJUDICATION)
return
self._recordMove(self.board.move(move), move, self.board)
log.debug("__parseLine: applied move=%s to self.board=%s" % \
(move, self.board), extra={"task":self.defname})
if self.ponderOn:
self.pondermove = None
# An engine may send an empty ponder line, simply to clear.
if len(parts) == 4:
# Engines don't always check for everything in their
# ponders. Hence we need to validate.
# But in some cases, what they send may not even be
# correct AN - specially in the case of promotion.
try:
pondermove = parseAny(self.board, parts[3])
except ParsingError:
pass
else:
if validate(self.board, pondermove):
self.pondermove = pondermove
self._startPonder()
self.returnQueue.put(move)
log.debug("__parseLine: put move=%s into self.returnQueue=%s" % \
(move, self.returnQueue.queue), extra={"task":self.defname})
return
#----------------------------------------------------------- An Analysis
if self.mode != NORMAL and parts[0] == "info" and "pv" in parts:
multipv = 1
if "multipv" in parts:
multipv = int(parts[parts.index("multipv")+1])
scoretype = parts[parts.index("score")+1]
if scoretype in ('lowerbound', 'upperbound'):
score = None
else:
score = int(parts[parts.index("score")+2])
if scoretype == 'mate':
# print >> self.engine, "stop"
if score != 0:
sign = score/abs(score)
score = sign*MATE_VALUE
movstrs = parts[parts.index("pv")+1:]
try:
moves = listToMoves (self.board, movstrs, AN, validate=True, ignoreErrors=False)
except ParsingError as e:
# ParsingErrors may happen when parsing "old" lines from
# analyzing engines, which haven't yet noticed their new tasks
log.debug("__parseLine: Ignored (%s) from analyzer: ParsingError%s" % \
(' '.join(movstrs),e), extra={"task":self.defname})
return
if "depth" in parts:
depth = parts[parts.index("depth")+1]
else:
depth = ""
if multipv <= len(self.analysis):
self.analysis[multipv - 1] = (moves, score, depth)
self.emit("analyze", self.analysis)
return
#----------------------------------------------- An Analyzer bestmove
if self.mode != NORMAL and parts[0] == "bestmove":
with self.moveLock:
log.debug("__parseLine: processing analyzer bestmove='%s'" % \
line.strip(), extra={"task":self.defname})
self.needBestmove = False
self.__sendQueuedGo(sendlast=True)
return
# Stockfish complaining it received a 'stop' without a corresponding 'position..go'
if line.strip() == "Unknown command: stop":
with self.moveLock:
log.debug("__parseLine: processing '%s'" % line.strip(), extra={"task":self.defname})
self.ignoreNext = False
self.needBestmove = False
self.readyForStop = False
self.__sendQueuedGo()
return
#* score
#* cp <x>
# the score from the engine's point of view in centipawns.
#* mate <y>
# mate in y moves, not plies.
# If the engine is getting mated use negative values for y.
#* lowerbound
# the score is just a lower bound.
#* upperbound
# the score is just an upper bound.
def __sendQueuedGo (self, sendlast=False):
""" Sends the next position...go or ponderhit command set which was queued (if any).
sendlast -- If True, send the last position-go queued rather than the first,
and discard the others (intended for analyzers)
"""
with self.moveLock:
if len(self.commands) > 0:
if sendlast:
commands = self.commands.pop()
self.commands.clear()
else:
commands = self.commands.popleft()
for command in commands:
print(command, file=self.engine)
self.needBestmove = True
self.readyForStop = True
log.debug("__sendQueuedGo: sent queued go=%s" % commands, extra={"task":self.defname})
#===========================================================================
# Info
#===========================================================================
def maxAnalysisLines (self):
try:
return int(self.options["MultiPV"]["max"])
except (KeyError, ValueError):
return 1 # Engine does not support the MultiPV option
def requestMultiPV (self, n):
multipvMax = self.maxAnalysisLines()
n = min(n, multipvMax)
if n != self.multipvSetting:
conf.set("multipv", n)
with self.moveLock:
self.multipvSetting = n
print("stop", file=self.engine)
print("setoption name MultiPV value", n, file=self.engine)
self._searchNow()
return n
def __repr__ (self):
if self.name:
return self.name
if "name" in self.ids:
return self.ids["name"]
return ', '.join(self.defname)