예제 #1
0
 def __init__(self, board_control):
     self.queue = Queue()
     self.board_control = board_control
     self.board_control.connect(
         "action", lambda bc, action, param: self.queue.put(
             (action, param)))
     self.board_control.connect("piece_moved", self.piece_moved)
예제 #2
0
        class DummyTelnet():
            def __init__(self):
                self.Q = Queue()
                self.name = "dummytelnet"

            def putline(self, line):
                self.Q.put(line)

            def write(self, text):
                pass

            def readline(self):
                return self.Q.get_nowait()
예제 #3
0
    def __init__ (self, store, tv, boardview):
        Thread.__init__(self, name=fident(self.run))
        self.daemon = True
        # FIXME 'Advisor.name = ...' in Advisor.__init__ overwrites Thread.name
        Advisor.__init__(self, store, _("Endgame Table"), ENDGAME)
        self.egtb = EndgameTable()
        self.tv = tv
        self.boardview = boardview
        self.tooltip = _("The endgame table will show exact analysis when there are few pieces on the board.")
        # TODO: Show a message if tablebases for the position exist but are neither installed nor allowed.

        self.egtb.connect("scored", self.on_scored)
        self.queue = Queue()
        self.start()
예제 #4
0
    def __init__(self, timemodel=None, variant=NormalChess):
        GObject.GObject.__init__(self)
        Thread.__init__(self, name=fident(self.run))
        self.daemon = True
        self.variant = variant
        self.boards = [variant.board(setup=True)]

        self.moves = []
        self.scores = {}
        self.players = []

        self.gameno = None
        self.variations = [self.boards]

        self.status = WAITING_TO_START
        self.reason = UNKNOWN_REASON

        if timemodel is None:
            self.timemodel = TimeModel()
        else:
            self.timemodel = timemodel

        self.connections = defaultdict(list)  # mainly for IC subclasses

        now = datetime.datetime.now()
        self.tags = {
            "Event": _("Local Event"),
            "Site": _("Local Site"),
            "Round": 1,
            "Year": now.year,
            "Month": now.month,
            "Day": now.day,
            "Time": "%02d:%02d:00" % (now.hour, now.minute),
            "Result": "*",
        }

        self.endstatus = None
        self.timed = self.timemodel.secs != 0 or self.timemodel.gain != 0

        if self.timed:
            self.tags["TimeControl"] = \
                "%d+%d" % (self.timemodel.minutes*60, self.timemodel.gain)
            # Notice: tags["WhiteClock"] and tags["BlackClock"] are never set
            # on the gamemodel, but simply written or read during saving/
            # loading from pgn. If you want to know the time left for a player,
            # check the time model.

        # Keeps track of offers, so that accepts can be spotted
        self.offers = {}
        # True if the game has been changed since last save
        self.needsSave = False
        # The uri the current game was loaded from, or None if not a loaded game
        self.uri = None

        self.spectators = {}

        self.applyingMoveLock = RLock()
        self.undoLock = RLock()
        self.undoQueue = Queue()
예제 #5
0
class SetupPlayer:
    __type__ = LOCAL

    def __init__(self, board_control):
        self.queue = Queue()
        self.board_control = board_control
        self.board_control.connect(
            "action", lambda bc, action, param: self.queue.put(
                (action, param)))
        self.board_control.connect("piece_moved", self.piece_moved)

    def make_move(self):
        item = self.queue.get(block=True)
        return item

    def piece_moved(self, board, move, color):
        self.queue.put((SetupMove(move), color))
예제 #6
0
class DummyPlayer(Player):
    def __init__(self):
        Player.__init__(self)
        self.Q = Queue()
        self.__type__ = LOCAL

    def makeMove(self, board1, move, board2):
        r = self.Q.get()
        if r == "del": raise PlayerIsDead
        if r == "int": raise TurnInterrupt

    def undoMoves(self, moves, gamemodel):
        self.Q.put('int')

    def end(self, status, reason):
        self.Q.put('del')

    def kill(self, reason):
        self.Q.put('del')

    def pause(self):
        pass

    def resume(self):
        pass

    def offer(self, offer):
        self.emit('accept', offer)
예제 #7
0
    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),
        ]
예제 #8
0
 def __init__ (self, gmwidg, color, name, ichandle=None, icrating=None):
     Player.__init__(self)
     
     self.defname = "Human"
     self.board = gmwidg.board
     self.gmwidg = gmwidg
     self.gamemodel = self.board.view.model
     self.queue = Queue()
     self.color = color
     self.conid = [
         self.board.connect("piece_moved", self.piece_moved),
         self.board.connect("action", lambda b,action,param: self.emit_action(action, param))
     ]
     self.setName(name)
     self.ichandle = ichandle
     self.icrating = icrating
     
     if self.gamemodel.timed:
         self.gamemodel.timemodel.connect('zero_reached', self.zero_reached)
예제 #9
0
파일: Human.py 프로젝트: ME7ROPOLIS/pychess
    def __init__(self, gmwidg, color, name, ichandle=None, icrating=None):
        Player.__init__(self)

        self.defname = "Human"
        self.board = gmwidg.board
        self.gmwidg = gmwidg
        self.gamemodel = self.gmwidg.gamemodel
        self.queue = Queue()
        self.color = color

        self.board_cids = [
            self.board.connect("piece_moved", self.piece_moved),
            self.board.connect("action", self.emit_action)
        ]
        self.setName(name)
        self.ichandle = ichandle
        self.icrating = icrating

        if self.gamemodel.timed:
            self.timemodel_cid = self.gamemodel.timemodel.connect('zero_reached', self.zero_reached)
        self.cid = self.gamemodel.connect_after("game_terminated", self.on_game_terminated)
예제 #10
0
    def __init__(self,
                 gamemodel,
                 ichandle,
                 gameno,
                 color,
                 name,
                 icrating=None):
        Player.__init__(self)
        self.offers = {}
        self.queue = Queue()
        self.okqueue = Queue()
        self.setName(name)
        self.ichandle = ichandle
        self.icrating = icrating
        self.color = color
        self.gameno = gameno
        self.gamemodel = gamemodel

        # If some times later FICS creates another game with same wplayer,bplayer,gameno
        # this will change to False and boardUpdate messages will be ignored
        self.current = True

        self.connection = connection = self.gamemodel.connection
        self.connections = connections = defaultdict(list)
        connections[connection.bm].append(
            connection.bm.connect_after("boardUpdate", self.__boardUpdate))
        connections[connection.bm].append(
            connection.bm.connect_after("playGameCreated",
                                        self.__playGameCreated))
        connections[connection.bm].append(
            connection.bm.connect_after("obsGameCreated",
                                        self.__obsGameCreated))
        connections[connection.om].append(
            connection.om.connect("onOfferAdd", self.__onOfferAdd))
        connections[connection.om].append(
            connection.om.connect("onOfferRemove", self.__onOfferRemove))
        connections[connection.om].append(
            connection.om.connect("onOfferDeclined", self.__onOfferDeclined))
        connections[connection.cm].append(
            connection.cm.connect("privateMessage", self.__onPrivateMessage))
예제 #11
0
def cacheGladefile(filename):
    """ Gtk.Builder automatically caches the file, so we only need to use this
        file once """
    if filename not in cachedGlades:
        cachedGlades[filename] = Queue()
        def readit ():
            builder = Gtk.Builder()
            builder.set_translation_domain("pychess")
            builder.add_from_file(addDataPrefix("glade/%s" % filename))
            cachedGlades[filename].put(builder)
        t = Thread(target=readit, name=fident(readit))
        t.daemon = True
        t.start()
예제 #12
0
class DummyCECPAnalyzerEngine(GObject.GObject):
    __gsignals__ = {
        "line": (GObject.SignalFlags.RUN_FIRST, None, (object,)),
        "died": (GObject.SignalFlags.RUN_FIRST, None, ()),
    }
    def __init__(self):
        GObject.GObject.__init__(self)
        self.defname = 'Dummy'
        self.Q = Queue()
    def putline(self, line):
        self.emit('line', line)
    def write(self, text):
        if text.strip() == 'protover 2':
            self.emit('line', 'feature setboard=1 analyze=1 ping=1 draw=0 sigint=0 done=1')
        pass
    def readline(self):
        return self.Q.get()
예제 #13
0
class Publisher(Thread):
    """ Publisher can be used when a thread is often spitting out results,
        and you want to process these results in gtk as soon as possible.
        While waiting for gdk access, results will be stored, and depending on
        the send policy, either the entire list, or only the last item will be
        sent as an argument to the function specified in the __init__ """

    SEND_LIST, SEND_LAST = range(2)

    def __init__(self, func, thread_namer, sendPolicy):
        Thread.__init__(self, name=get_threadname(thread_namer))
        self.daemon = True
        self.queue = Queue()
        self.func = func
        self.sendPolicy = sendPolicy

    def run(self):
        while True:
            v = self.queue.get()
            if v == self.StopNow:
                break

            glock.acquire()
            try:
                l = [v]
                while True:
                    try:
                        v = self.queue.get_nowait()
                    except Empty:
                        break
                    else:
                        if v == self.StopNow:
                            break
                        l.append(v)

                if self.sendPolicy == self.SEND_LIST:
                    self.func(l)
                elif self.sendPolicy == self.SEND_LAST:
                    self.func(l[-1])
            finally:
                glock.release()

            if v == self.StopNow:
                break

    def put(self, task):
        self.queue.put(task)

    def _del(self):
        self.queue.put(self.StopNow)

    class StopNow(Exception):
        pass
예제 #14
0
class SetupPlayer:
    __type__ = LOCAL

    def __init__(self, board_control):
        self.queue = Queue()
        self.board_control = board_control
        self.board_control.connect("action", self.on_action)
        self.board_control.connect("piece_moved", self.piece_moved)

    def on_action(self, bc, action, param):
        self.queue.put((action, param))
        if action == "SETUP":
            # force both virtual player to make_move()
            self.queue.put((action, param))

    def make_move(self):
        item = self.queue.get(block=True)
        return item

    def piece_moved(self, board, move, color):
        self.queue.put((SetupMove(move), color))
예제 #15
0
 def _put(self, item):
     Queue._put(self, item)
     self.unfinished_tasks += 1
예제 #16
0
 def __init__(self):
     Player.__init__(self)
     self.Q = Queue()
     self.__type__ = LOCAL
예제 #17
0
 def __init__(self, func, thread_namer, sendPolicy):
     Thread.__init__(self, name=get_threadname(thread_namer))
     self.daemon = True
     self.queue = Queue()
     self.func = func
     self.sendPolicy = sendPolicy
예제 #18
0
파일: bookPanel.py 프로젝트: JKrame/pychess
class EndgameAdvisor(Advisor, Thread):
    def __init__(self, store, tv, boardview):
        Thread.__init__(self, name=fident(self.run))
        self.daemon = True
        # FIXME 'Advisor.name = ...' in Advisor.__init__ overwrites Thread.name
        Advisor.__init__(self, store, _("Endgame Table"), ENDGAME)
        self.egtb = EndgameTable()
        # If mate in # was activated by double click let egtb do the rest
        self.auto_activate = False
        self.tv = tv
        self.boardview = boardview
        self.tooltip = _(
            "The endgame table will show exact analysis when there are few pieces on the board."
        )
        # TODO: Show a message if tablebases for the position exist but are neither installed nor allowed.

        self.cid = self.egtb.connect("scored", self.on_scored)
        self.queue = Queue()
        self.start()

    class StopNow(Exception):
        pass

    def run(self):
        while True:
            v = self.queue.get()
            if v == self.StopNow:
                break
            elif v == self.board.board:
                self.egtb.scoreAllMoves(v)
            self.queue.task_done()

    def shownChanged(self, boardview, shown):
        m = boardview.model
        if m is None:
            return
        if m.isPlayingICSGame():
            return

        self.parent = self.empty_parent()
        self.board = m.getBoardAtPly(shown, boardview.shown_variation_idx)
        self.queue.put(self.board.board)

    def _del(self):
        self.egtb.disconnect(self.cid)
        try:
            self.queue.put_nowait(self.StopNow)
        except Full:
            log.warning("EndgameAdvisor.gamewidget_closed: Queue.Full")

    @idle_add
    def on_scored(self, w, ret):
        m = self.boardview.model
        if m.isPlayingICSGame():
            return

        board, endings = ret
        if board != self.board.board:
            return

        for move, result, depth in endings:
            if result == DRAW:
                result = (_("Draw"), 1, 0.5)
                details = ""
            elif (result == WHITEWON) ^ (self.board.color == WHITE):
                result = (_("Loss"), 1, 0.0)
                details = _("Mate in %d") % depth
            else:
                result = (_("Win"), 1, 1.0)
                details = _("Mate in %d") % depth
            self.store.append(self.parent, [(self.board, move, None), result,
                                            0, False, details, False, False])
        self.tv.expand_row(Gtk.TreePath(self.path), False)

        if self.auto_activate:
            path = None
            for i, row in enumerate(self.store):
                if row[4] == self.name:
                    path = Gtk.TreePath.new_from_indices((i, 0))
                    break
            if path is not None:
                self.row_activated(self.tv.get_model().get_iter(path),
                                   m,
                                   from_gui=False)

    def row_activated(self, iter, model, from_gui=True):
        if self.store.get_path(iter) != Gtk.TreePath(self.path):
            board, move, moves = self.store[iter][0]

            if from_gui:
                result = self.store[iter][1]
                if result is not None and result[2] != 0.5:
                    # double click on mate in #
                    self.auto_activate = True

            if board.board.next is None and not self.boardview.shownIsMainLine(
            ):
                model.add_move2variation(board, move,
                                         self.boardview.shown_variation_idx)
            else:
                model.add_variation(board, (move, ))
예제 #19
0
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.timeout = None

        self.returnQueue = Queue()
        self.engine.connect("line", self.parseLine)
        self.engine.connect("died", lambda e: self.returnQueue.put("del"))
        self.invalid_move = None

        self.funcQueue = Queue()
        self.optionQueue = []
        self.boardLock = RLock()
        self.undoQueue = []

        self.analysis_timer = None

        self.connect("readyForOptions", self.__onReadyForOptions_before)
        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.

            # set timeout for feature accept/reject:
            self.timeout = time.time() + TIME_OUT_FIRST

    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):
        if self.protover == 1:
            self.emit("readyForMoves")
        if self.protover == 2:
            try:
                r = self.returnQueue.get(True,
                                         max(self.timeout - time.time(), 0))
                if r == "not ready":
                    # The engine has sent done=0, and parseLine has added more
                    # time to self.timeout
                    r = self.returnQueue.get(
                        True, max(self.timeout - time.time(), 0))
                    # Gaviota sends done=0 after "xboard" and after "protover 2" too
                    if r == "not ready":
                        r = self.returnQueue.get(
                            True, max(self.timeout - time.time(), 0))
            except Empty:
                log.warning("Got timeout error", extra={"task": self.defname})
                self.emit("readyForOptions")
                self.emit("readyForMoves")
            else:
                if r == 'del':
                    raise PlayerIsDead
                assert r == "ready"

    def __onReadyForOptions_before(self, self_):
        self.readyOptions = True

    def __onReadyForOptions(self, self_):
        # This is no longer needed
        #self.timeout = time.time()

        # 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 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):
            # 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.readyMoves = True
        semisynced(lambda s: None)(self)

    #===========================================================================
    #    Ending the game
    #===========================================================================

    @semisynced
    def end(self, status, reason):
        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.returnQueue.put("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.returnQueue.put("del")
                    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", [])

                if self.analysis_timer is not None:
                    self.analysis_timer.cancel()
                    self.analysis_timer.join()

    #===========================================================================
    #    Send the player move updates
    #===========================================================================

    def setBoard(self, board):
        self.setBoardList([board], [])
        self.__sendAnalyze(self.mode == INVERSE_ANALYZING)

    @semisynced
    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)

    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
        self.boardLock.acquire()
        try:
            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()
        finally:
            self.boardLock.release()
        self.waitingForMove = True
        self.readyForMoveNowCommand = True

        # Parse outputs
        r = self.returnQueue.get()
        if r == "not ready":
            log.warning(
                "Engine seems to be protover=2, but is treated as protover=1",
                extra={"task": self.defname})
            r = self.returnQueue.get()
        if r == "ready":
            r = self.returnQueue.get()
        if r == "invalid":
            raise InvalidMove
        if r == "del":
            raise PlayerIsDead("Killed by foreign forces")
        if r == "int":
            raise TurnInterrupt

        self.waitingForMove = False
        self.readyForMoveNowCommand = False
        assert isinstance(r, Move), r
        return r

    @semisynced
    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):
        # We don't use the optionQueue here, as set board prints a whole lot of
        # stuff. Instead we just call it, and let semisynced handle the rest.
        self.setBoardList(model.boards[:], model.moves[:])

    @semisynced
    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
        self.boardLock.acquire()
        try:
            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.
        finally:
            self.boardLock.release()

    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):
        # Notice: In CECP we apply time handicap in updateTime, not in
        #         setOptionTime.

        minutes = int(secs / 60)
        secs = int(secs % 60)
        s = str(minutes)
        if secs:
            s += ":" + str(secs)

        self.optionQueue.append("level 0 %s %d" % (s, 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
    #===========================================================================

    @semisynced
    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

        if self.mode in (ANALYZING, INVERSE_ANALYZING):
            return
        if self.features["pause"]:
            print("pause", file=self.engine)
        elif self.board:
            self.__tellEngineToStopPlayingCurrentColor()
            self._blockTillMove()

    @semisynced
    def resume(self):
        log.debug("resume: self=%s" % self, extra={"task": self.defname})
        self.engine.resume()
        return

        if self.mode not in (ANALYZING, INVERSE_ANALYZING):
            if self.features["pause"]:
                print("features resume")
                print("resume", file=self.engine)
            elif self.board:
                print("go resume")
                self.__tellEngineToPlayCurrentColorAndMakeMove()

    @semisynced
    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

    @semisynced
    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]

    @semisynced
    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.returnQueue.put("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:
            cn = CASTLE_KK
            if board.variant == FISCHERRANDOMCHESS:
                cn = CASTLE_SAN
            print(toAN(board, move, short=True, castleNotation=cn),
                  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

        if self.analysis_timer is not None:
            self.analysis_timer.cancel()
            self.analysis_timer.join()

        self.analysis_timer = Timer(conf.get("max_analysis_spin", 3),
                                    stop_analyze)
        self.analysis_timer.start()

    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, row in enumerate(board.data):
                    for x, piece in enumerate(row):
                        if not piece or piece.color != color:
                            continue
                        sign = reprSign[piece.sign]
                        cord = repr(Cord(x, y))
                        print(sign + cord, file=self.engine)
                print("c", file=self.engine)
            print(".", file=self.engine)

    def _blockTillMove(self):
        saved_state = self.boardLock._release_save()
        log.debug("_blockTillMove(): acquiring self.movecon lock",
                  extra={"task": self.defname})
        self.movecon.acquire()
        log.debug("_blockTillMove(): self.movecon acquired",
                  extra={"task": self.defname})
        try:
            log.debug("_blockTillMove(): doing self.movecon.wait",
                      extra={"task": self.defname})
            self.movecon.wait()
        finally:
            log.debug("_blockTillMove(): releasing self.movecon..",
                      extra={"task": self.defname})
            self.movecon.release()
            self.boardLock._acquire_restore(saved_state)

    #===========================================================================
    #    Parsing
    #===========================================================================

    def parseLine(self, engine, line):
        if line[0:1] == "#":
            # Debug line which we shall ignore as specified in CECPv2 specs
            return

#        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])
            return

        # 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)
            return

        # 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:
                log.debug("__parseLine: acquiring self.boardLock",
                          extra={"task": self.defname})
                self.waitingForMove = False
                self.readyForMoveNowCommand = False
                self.boardLock.acquire()
                try:
                    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)
                        return
                    else:
                        try:
                            move = parseAny(self.board, movestr)
                        except ParsingError as e:
                            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)
                            return

                        if validate(self.board, move):
                            self.board = None
                            self.returnQueue.put(move)
                            return
                        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)
                            return
                finally:
                    log.debug("__parseLine(): releasing self.boardLock",
                              extra={"task": self.defname})
                    self.boardLock.release()
                    self.movecon.acquire()
                    self.movecon.notifyAll()
                    self.movecon.release()

        # 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)
                return

            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())])

                return

        # Offers draw
        if parts[0:2] == ["offer", "draw"]:
            self.emit("accept", Offer(DRAW_OFFER))
            return

        # 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))
            return

        #if parts[0].lower() == "error":
        #    return

        #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:]):
                return
            # 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()
            return

        # 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:])))
            return

        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 not key 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.timeout = time.time() + TIME_OUT_SECOND
                        self.returnQueue.put("not ready")
                        return

                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.returnQueue.put("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"]
예제 #20
0
 def __init__(self):
     self.Q = Queue()
     self.name = "dummytelnet"
예제 #21
0
 def __init__(self, board_control):
     self.queue = Queue()
     self.board_control = board_control
     self.board_control.connect("action", self.on_action)
     self.board_control.connect("piece_moved", self.piece_moved)
예제 #22
0
class EndgameAdvisor(Advisor, Thread):
    def __init__(self, store, tv, boardview):
        Thread.__init__(self, name=fident(self.run))
        self.daemon = True
        # FIXME 'Advisor.name = ...' in Advisor.__init__ overwrites Thread.name
        Advisor.__init__(self, store, _("Endgame Table"), ENDGAME)
        self.egtb = EndgameTable()
        self.tv = tv
        self.boardview = boardview
        self.tooltip = _(
            "The endgame table will show exact analysis when there are few pieces on the board."
        )
        # TODO: Show a message if tablebases for the position exist but are neither installed nor allowed.

        self.egtb.connect("scored", self.on_scored)
        self.queue = Queue()
        self.start()

    class StopNow(Exception):
        pass

    def run(self):
        while True:
            v = self.queue.get()
            if v == self.StopNow:
                break
            elif v == self.board.board:
                self.egtb.scoreAllMoves(v)
            self.queue.task_done()

    def shown_changed(self, boardview, shown):
        m = boardview.model
        if m.isPlayingICSGame():
            return

        self.parent = self.empty_parent()
        self.board = m.getBoardAtPly(shown, boardview.shownVariationIdx)
        self.queue.put(self.board.board)

    def gamewidget_closed(self, gamewidget):
        try:
            self.queue.put_nowait(self.StopNow)
        except Full:
            log.warning("EndgameAdvisor.gamewidget_closed: Queue.Full")

    @idle_add
    def on_scored(self, w, ret):
        m = self.boardview.model
        if m.isPlayingICSGame():
            return

        board, endings = ret
        if board != self.board.board:
            return

        for move, result, depth in endings:
            if result == DRAW:
                result = (_("Draw"), 1, 0.5)
                details = ""
            elif (result == WHITEWON) ^ (self.board.color == WHITE):
                result = (_("Loss"), 1, 0.0)
                details = _("Mate in %d") % depth
            else:
                result = (_("Win"), 1, 1.0)
                details = _("Mate in %d") % depth
            self.store.append(self.parent, [(self.board, move, None), result,
                                            0, False, details, False, False])
        self.tv.expand_row(Gtk.TreePath(self.path), False)
예제 #23
0
 def __init__(self):
     Queue.__init__(self)
     self.all_tasks_done = threading.Condition(self.mutex)
     self.unfinished_tasks = 0
예제 #24
0
    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.timeout = None

        self.returnQueue = Queue()
        self.engine.connect("line", self.parseLine)
        self.engine.connect("died", lambda e: self.returnQueue.put("del"))
        self.invalid_move = None

        self.funcQueue = Queue()
        self.optionQueue = []
        self.boardLock = RLock()
        self.undoQueue = []

        self.analysis_timer = None

        self.connect("readyForOptions", self.__onReadyForOptions_before)
        self.connect_after("readyForOptions", self.__onReadyForOptions)
        self.connect_after("readyForMoves", self.__onReadyForMoves)
예제 #25
0
class ICPlayer(Player):
    __type__ = REMOTE

    def __init__(self,
                 gamemodel,
                 ichandle,
                 gameno,
                 color,
                 name,
                 icrating=None):
        Player.__init__(self)
        self.offers = {}
        self.queue = Queue()
        self.okqueue = Queue()
        self.setName(name)
        self.ichandle = ichandle
        self.icrating = icrating
        self.color = color
        self.gameno = gameno
        self.gamemodel = gamemodel

        # If some times later FICS creates another game with same wplayer,bplayer,gameno
        # this will change to False and boardUpdate messages will be ignored
        self.current = True

        self.connection = connection = self.gamemodel.connection
        self.connections = connections = defaultdict(list)
        connections[connection.bm].append(
            connection.bm.connect_after("boardUpdate", self.__boardUpdate))
        connections[connection.bm].append(
            connection.bm.connect_after("playGameCreated",
                                        self.__playGameCreated))
        connections[connection.bm].append(
            connection.bm.connect_after("obsGameCreated",
                                        self.__obsGameCreated))
        connections[connection.om].append(
            connection.om.connect("onOfferAdd", self.__onOfferAdd))
        connections[connection.om].append(
            connection.om.connect("onOfferRemove", self.__onOfferRemove))
        connections[connection.om].append(
            connection.om.connect("onOfferDeclined", self.__onOfferDeclined))
        connections[connection.cm].append(
            connection.cm.connect("privateMessage", self.__onPrivateMessage))

    def getICHandle(self):
        return self.name

    @property
    def time(self):
        return self.gamemodel.timemodel.getPlayerTime(self.color)

    # Handle signals from the connection

    def __playGameCreated(self, bm, ficsgame):
        if self.gamemodel.ficsplayers[0] == ficsgame.wplayer and \
            self.gamemodel.ficsplayers[1] == ficsgame.bplayer and \
                self.gameno == ficsgame.gameno:
            log.debug(
                "ICPlayer.__playGameCreated: gameno reappeared: gameno=%s white=%s black=%s"
                % (ficsgame.gameno, ficsgame.wplayer.name,
                   ficsgame.bplayer.name))
            self.current = False

    def __obsGameCreated(self, bm, ficsgame):
        if self.gamemodel.ficsplayers[0] == ficsgame.wplayer and \
            self.gamemodel.ficsplayers[1] == ficsgame.bplayer and \
                self.gameno == ficsgame.gameno:
            log.debug(
                "ICPlayer.__obsGameCreated: gameno reappeared: gameno=%s white=%s black=%s"
                % (ficsgame.gameno, ficsgame.wplayer.name,
                   ficsgame.bplayer.name))
            self.current = False

    def __onOfferAdd(self, om, offer):
        if self.gamemodel.status in UNFINISHED_STATES and not self.gamemodel.isObservationGame(
        ):
            log.debug(
                "ICPlayer.__onOfferAdd: emitting offer: self.gameno=%s self.name=%s %s"
                % (self.gameno, self.name, offer))
            self.offers[offer.index] = offer
            self.emit("offer", offer)

    def __onOfferDeclined(self, om, offer):
        for offer_ in list(self.gamemodel.offers.keys()):
            if offer.type == offer_.type:
                offer.param = offer_.param
        log.debug("ICPlayer.__onOfferDeclined: emitting decline for %s" %
                  offer)
        self.emit("decline", offer)

    def __onOfferRemove(self, om, offer):
        if offer.index in self.offers:
            log.debug("ICPlayer.__onOfferRemove: emitting withdraw: \
                      self.gameno=%s self.name=%s %s" %
                      (self.gameno, self.name, offer))
            self.emit("withdraw", self.offers[offer.index])
            del self.offers[offer.index]

    def __onPrivateMessage(self, cm, name, title, isadmin, text):
        if name == self.ichandle:
            self.emit("offer", Offer(CHAT_ACTION, param=text))

    def __boardUpdate(self, bm, gameno, ply, curcol, lastmove, fen, wname,
                      bname, wms, bms):
        log.debug(
            "ICPlayer.__boardUpdate: id(self)=%d self=%s %s %s %s %d %d %s %s %d %d"
            % (id(self), self, gameno, wname, bname, ply, curcol, lastmove,
               fen, wms, bms))

        if gameno == self.gameno and len(
                self.gamemodel.players) >= 2 and self.current:
            # LectureBot allways uses gameno 1 for many games in one lecture
            # and wname == self.gamemodel.players[0].ichandle \
            # and bname == self.gamemodel.players[1].ichandle \
            log.debug(
                "ICPlayer.__boardUpdate: id=%d self=%s gameno=%s: this is my move"
                % (id(self), self, gameno))

            # In some cases (like lost on time) the last move is resent
            if ply <= self.gamemodel.ply:
                return

            if 1 - curcol == self.color and ply == self.gamemodel.ply + 1 and lastmove is not None:
                log.debug("ICPlayer.__boardUpdate: id=%d self=%s ply=%d: \
                          putting move=%s in queue" %
                          (id(self), self, ply, lastmove))
                self.queue.put((ply, lastmove))
                # Ensure the fics thread doesn't continue parsing, before the
                # game/player thread has received the move.
                # Specifically this ensures that we aren't killed due to end of
                # game before our last move is received
                self.okqueue.get(block=True)

    # Ending the game

    def __disconnect(self):
        if self.connections is None:
            return
        for obj in self.connections:
            for handler_id in self.connections[obj]:
                if obj.handler_is_connected(handler_id):
                    obj.disconnect(handler_id)
        self.connections = None

    def end(self, status, reason):
        self.__disconnect()
        self.queue.put("del")

    def kill(self, reason):
        self.__disconnect()
        self.queue.put("del")

    # Send the player move updates

    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:
                raise
            return move
        finally:
            log.debug(
                "ICPlayer.makemove: id(self)=%d self=%s returning move=%s" %
                (id(self), self, move))
            self.okqueue.put("ok")

    # Interacting with the player

    def pause(self):
        pass

    def resume(self):
        pass

    def setBoard(self, fen):
        # setBoard will currently only be called for ServerPlayer when starting
        # to observe some game. In this case FICS already knows how the board
        # should look, and we don't need to set anything
        pass

    def playerUndoMoves(self, movecount, gamemodel):
        log.debug(
            "ICPlayer.playerUndoMoves: id(self)=%d self=%s, undoing movecount=%d"
            % (id(self), self, movecount))
        # If current player has changed so that it is no longer us to move,
        # We raise TurnInterruprt in order to let GameModel continue the game
        if movecount % 2 == 1 and gamemodel.curplayer != self:
            self.queue.put("int")

    def resetPosition(self):
        """ Used in observed examined games f.e. when LectureBot starts another example"""
        self.queue.put("int")

    def putMessage(self, text):
        self.connection.cm.tellPlayer(self.ichandle, text)

    # Offer handling

    def offerRematch(self):
        if self.gamemodel.timed:
            minimum = int(self.gamemodel.timemodel.intervals[0][0]) / 60
            inc = self.gamemodel.timemodel.gain
        else:
            minimum = 0
            inc = 0
        self.connection.om.challenge(self.ichandle,
                                     self.gamemodel.ficsgame.game_type,
                                     minimum, inc,
                                     self.gamemodel.ficsgame.rated)

    def offer(self, offer):
        log.debug("ICPlayer.offer: self=%s %s" % (repr(self), offer))
        if offer.type == TAKEBACK_OFFER:
            # only 1 outstanding takeback offer allowed on FICS, so remove any of ours
            for index in list(self.offers.keys()):
                if self.offers[index].type == TAKEBACK_OFFER:
                    log.debug("ICPlayer.offer: del self.offers[%s] %s" %
                              (index, offer))
                    del self.offers[index]
        self.connection.om.offer(offer, self.gamemodel.ply)

    def offerDeclined(self, offer):
        log.debug("ICPlayer.offerDeclined: sending decline for %s" % offer)
        self.connection.om.decline(offer)

    def offerWithdrawn(self, offer):
        pass

    def offerError(self, offer, error):
        pass

    def observe(self):
        self.connection.client.run_command("observe %s" % self.ichandle)
예제 #26
0
class Human (Player):
    __type__ = LOCAL
    
    __gsignals__ = {
        "messageRecieved": (GObject.SignalFlags.RUN_FIRST, None, (str,)),
    }
    
    def __init__ (self, gmwidg, color, name, ichandle=None, icrating=None):
        Player.__init__(self)
        
        self.defname = "Human"
        self.board = gmwidg.board
        self.gmwidg = gmwidg
        self.gamemodel = self.board.view.model
        self.queue = Queue()
        self.color = color
        self.conid = [
            self.board.connect("piece_moved", self.piece_moved),
            self.board.connect("action", lambda b,action,param: self.emit_action(action, param))
        ]
        self.setName(name)
        self.ichandle = ichandle
        self.icrating = icrating
        
        if self.gamemodel.timed:
            self.gamemodel.timemodel.connect('zero_reached', self.zero_reached)
    
    #===========================================================================
    #    Handle signals from the board
    #===========================================================================
    
    def zero_reached (self, timemodel, color):
        if conf.get('autoCallFlag', False) and \
                self.gamemodel.status == RUNNING and \
                timemodel.getPlayerTime(1-self.color) <= 0:
            log.info('Automatically sending flag call on behalf of player %s.' % self.name)
            self.emit("offer", Offer(FLAG_CALL))
    
    def piece_moved (self, board, move, color):
        if color != self.color:
            return
        self.queue.put(move)
    
    def emit_action (self, action, param):
        # If there are two or more tabs open, we have to ensure us that it is
        # us who are in the active tab, and not the others
        if not self.gmwidg.isInFront(): return
        log.debug("Human.emit_action: self.name=%s, action=%s" % (self.name, action))
        
        # If there are two human players, we have to ensure us that it was us
        # who did the action, and not the others
        if self.gamemodel.players[1-self.color].__type__ == LOCAL:
            if action == HURRY_ACTION:
                if self.gamemodel.boards[-1].color == self.color:
                    return
            else:
                if self.gamemodel.boards[-1].color != self.color:
                    return
        self.emit("offer", Offer(action, param=param))
    
    #===========================================================================
    #    Send the player move updates
    #===========================================================================
    
    def makeMove (self, board1, move, board2):
        log.debug("Human.makeMove: move=%s, board1=%s board2=%s" % \
            (move, board1, board2))
        if self.board.view.premovePiece and self.board.view.premove0 and self.board.view.premove1 and \
            self.color == self.board.view.premovePiece.color:
            if validate(board1, Move(self.board.view.premove0, self.board.view.premove1, board1, promotion=self.board.view.premovePromotion)):
                log.debug("Human.makeMove: Setting move to premove %s %s" % \
                    (self.board.view.premove0, self.board.view.premove1))
                self.board.emit_move_signal(self.board.view.premove0, self.board.view.premove1, promotion=self.board.view.premovePromotion)
            # reset premove
            self.board.view.setPremove(None, None, None, None)
        self.gmwidg.setLocked(False)
        item = self.queue.get(block=True)
        self.gmwidg.setLocked(True)
        if item == "del":
            raise PlayerIsDead("Killed by foreign forces")
        if item == "int":
            log.debug("Human.makeMove: %s: raise TurnInterrupt" % self)
            raise TurnInterrupt
        return item
    
    #===========================================================================
    #    Ending the game
    #===========================================================================
    
    def end (self, status, reason):
        self.queue.put("del")
    
    def kill (self, reason):
        print("I am killed", self)
        for id in self.conid:
            if self.board.handler_is_connected(id):
                self.board.disconnect(id)
        self.queue.put("del")
    
    #===========================================================================
    #    Interacting with the player
    #===========================================================================
    
    def hurry (self):
        title = _("Your opponent asks you to hurry!")
        text = _("Generally this means nothing, as the game is time-based, but if you want to please your opponent, perhaps you should get going.")
        content = InfoBar.get_message_content(title, text, Gtk.STOCK_DIALOG_INFO)
        def response_cb (infobar, response, message):
            message.dismiss()
        message = InfoBarMessage(Gtk.MessageType.INFO, content, response_cb)
        message.add_button(InfoBarMessageButton(Gtk.STOCK_CLOSE, Gtk.ResponseType.CANCEL))
        self._show_message(message)
        
    def pause (self):
        self.gmwidg.setLocked(True)
    
    def resume (self):
        log.debug("Human.resume: %s" % (self))
        if self.board.view.model.curplayer == self:
            self.gmwidg.setLocked(False)
    
    def playerUndoMoves (self, movecount, gamemodel):
        log.debug("Human.playerUndoMoves:  movecount=%s self=%s" % (movecount, self))
        #If the movecount is odd, the player has changed, and we have to interupt
        if movecount % 2 == 1:
            # If it is no longer us to move, we raise TurnInterruprt in order to
            # let GameModel continue the game.
            if gamemodel.curplayer != self:
                log.debug("Human.playerUndoMoves: putting TurnInterrupt into self.queue")
                self.queue.put("int")
        
        # If the movecount is even, we have to ensure the board is unlocked.
        # This is because it might have been locked by the game ending, but
        # perhaps we have now undone some moves, and it is no longer ended.
        elif movecount % 2 == 0 and gamemodel.curplayer == self:
            log.debug("Human.playerUndoMoves: self=%s: calling gmwidg.setLocked" % (self))
            self.gmwidg.setLocked(False)
    
    def putMessage (self, text):
        self.emit("messageRecieved", text)
    
    def sendMessage (self, text):
        self.emit("offer", Offer(CHAT_ACTION, param=text))
    
    #===========================================================================
    #    Offer handling
    #===========================================================================
    
    def offer (self, offer):
        log.debug("Human.offer: self=%s %s" % (self, offer))
        assert offer.type in OFFER_MESSAGES
        
        if self.gamemodel.players[1-self.color].__type__ is LOCAL:
            self.emit("accept", offer)
            return
        
        heading, text, takes_param = OFFER_MESSAGES[offer.type]
        if takes_param:
            param = offer.param
            if offer.type == TAKEBACK_OFFER and \
                    self.gamemodel.players[1-self.color].__type__ is not REMOTE:
                param = self.gamemodel.ply - offer.param
            heading = heading % param
            text = text % param
        
        def response_cb (infobar, response, message):
            if response == Gtk.ResponseType.ACCEPT:
                self.emit("accept", offer)
            elif response == Gtk.ResponseType.NO:
                self.emit("decline", offer)
            message.dismiss()
        content = InfoBar.get_message_content(heading, text, Gtk.STOCK_DIALOG_QUESTION)
        message = InfoBarMessage(Gtk.MessageType.QUESTION, content, response_cb)
        message.add_button(InfoBarMessageButton(_("Accept"), Gtk.ResponseType.ACCEPT))
        message.add_button(InfoBarMessageButton(_("Decline"), Gtk.ResponseType.NO))
        message.add_button(InfoBarMessageButton(Gtk.STOCK_CLOSE, Gtk.ResponseType.CANCEL))
        self._show_message(message)
    
    def offerDeclined (self, offer):
        log.debug("Human.offerDeclined: self=%s %s" % (self, offer))
        assert offer.type in ACTION_NAMES
        heading = _("%s was declined by your opponent") % ACTION_NAMES[offer.type]
        text = _("Resend %s?" % ACTION_NAMES[offer.type].lower())
        content = InfoBar.get_message_content(heading, text, Gtk.STOCK_DIALOG_INFO)
        def response_cb (infobar, response, message):
            if response == Gtk.ResponseType.ACCEPT:
                self.emit("offer", offer)
            message.dismiss()
        message = InfoBarMessage(Gtk.MessageType.INFO, content, response_cb)
        message.add_button(InfoBarMessageButton(_("Resend"), Gtk.ResponseType.ACCEPT))
        message.add_button(InfoBarMessageButton(Gtk.STOCK_CLOSE, Gtk.ResponseType.CANCEL))
        self._show_message(message)
    
    def offerWithdrawn (self, offer):
        log.debug("Human.offerWithdrawn: self=%s %s" % (self, offer))
        assert offer.type in ACTION_NAMES
        heading = _("%s was withdrawn by your opponent") % ACTION_NAMES[offer.type]
        text = _("Your opponent seems to have changed their mind.")
        content = InfoBar.get_message_content(heading, text, Gtk.STOCK_DIALOG_INFO)
        def response_cb (infobar, response, message):
            message.dismiss()
        message = InfoBarMessage(Gtk.MessageType.INFO, content, response_cb)
        message.add_button(InfoBarMessageButton(Gtk.STOCK_CLOSE, Gtk.ResponseType.CANCEL))
        self._show_message(message)
    
    def offerError (self, offer, error):
        log.debug("Human.offerError: self=%s error=%s %s" % (self, error, offer))
        assert offer.type in ACTION_NAMES
        actionName = ACTION_NAMES[offer.type]
        if error == ACTION_ERROR_NONE_TO_ACCEPT:
            heading = _("Unable to accept %s") % actionName.lower()
            text = _("Probably because it has been withdrawn.")
        elif error == ACTION_ERROR_NONE_TO_DECLINE or \
             error == ACTION_ERROR_NONE_TO_WITHDRAW:
            # If the offer was not there, it has probably already been either
            # declined or withdrawn.
            return
        else:
            heading = _("%s returns an error") % actionName
            text = ERROR_MESSAGES[error]
        
        content = InfoBar.get_message_content(heading, text, Gtk.STOCK_DIALOG_WARNING)
        def response_cb (infobar, response, message):
            message.dismiss()
        message = InfoBarMessage(Gtk.MessageType.WARNING, content, response_cb)
        message.add_button(InfoBarMessageButton(Gtk.STOCK_CLOSE, Gtk.ResponseType.CANCEL))
        self._show_message(message)
    
    def _show_message (self, message):
        self.gmwidg.showMessage(message)
예제 #27
0
def TaskQueue():
    if hasattr(Queue, "task_done"):
        return Queue()
    return _TaskQueue()
예제 #28
0
 def __init__(self):
     GObject.GObject.__init__(self)
     self.defname = 'Dummy'
     self.Q = Queue()
예제 #29
0
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.parseLine)
        self.engine.connect("died", self.__die)
        self.invalid_move = None
        
        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
        if reason == WON_ADJUDICATION:
            self.returnQueue.put("invalid")
        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 == "invalid":
                raise InvalidMove
            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 == FischerandomBoard:
            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", [([toAN(self.board, 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 parseLine (self, engine, line):
        if not self.connected: return
        parts = line.split()
        if not parts: return
        #---------------------------------------------------------- Initializing
        if parts[0] == "id":
            if parts[1] == "name":
                self.ids[parts[1]] = " ".join(parts[2:])
                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
                
                movestr = parts[1]
                if not self.waitingForMove:
                    log.warning("__parseLine: self.waitingForMove==False, ignoring move=%s" % \
                        movestr, extra={"task":self.defname})
                    self.pondermove = None
                    return
                self.waitingForMove = False

                try:
                    move = parseAny(self.board, movestr)
                except ParsingError as e:
                    self.invalid_move = movestr
                    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.invalid_move = movestr
                    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:]

            if "depth" in parts:
                depth = parts[parts.index("depth")+1]
            else:
                depth = ""
                
            if multipv <= len(self.analysis):
                self.analysis[multipv - 1] = (movstrs, 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)