def __init__(self, setup=False, lboard=None):
     if setup is True:
         Board.__init__(self,
                        setup=self.asymmetricrandom_start(),
                        lboard=lboard)
     else:
         Board.__init__(self, setup=setup, lboard=lboard)

 def __init__(self, setup=True):
     fen = SETUPSTART if setup is True else setup
     # add all kind if piece to holdings (except king)
     parts = fen.split()
     parts[0] += "/prnsqPRNSQ"
     fen = " ".join(parts)
     Board.__init__(self, setup=fen)
     self._ply = 0

 def __init__(self, setup=True):
     fenstr = SETUPSTART if setup is True else setup
     # add all kind if piece to holdings
     parts = fenstr.split()
     parts[0] += "/prnsqkPRNSQK"
     fenstr = " ".join(parts)
     Board.__init__(self, setup=fenstr)
     self._ply = 0

 def test2(self):
     """ Test analyzing in promotion situations """
     
     board = Board('5k2/PK6/8/8/8/6P1/6P1/8 w - - 1 48')
     self.analyzerA.setBoardList([board],[])
     self.analyzerI.setBoardList([board],[])
     
     self._testLine(self.engineA, self.analyzerA, board,
                    "9. 1833 23 43872584     a8=Q+ Kf7 Qa2+ Kf6 Qd2 Kf5 g4+",
                    ['a8=Q+','Kf7','Qa2+','Kf6','Qd2','Kf5','g4+'], 1833, "9.")
     
     self._testLine(self.engineI, self.analyzerI, board.switchColor(),
                    "10. -1883 59 107386433     Kf7 a8=Q Ke6 Qa6+ Ke5 Qd6+ Kf5",
                    ['Kf7','a8=Q','Ke6','Qa6+','Ke5','Qd6+','Kf5'], -1883, "10.")

 def test1(self):
     """ Test analyzing in forced mate situations """
     
     board = Board('B1n1n1KR/1r5B/6R1/2b1p1p1/2P1k1P1/1p2P2p/1P2P2P/3N1N2 w - - 0 1')
     self.analyzerA.setBoardList([board],[])
     self.analyzerI.setBoardList([board],[])
     
     self._testLine(self.engineA, self.analyzerA, board,
                    "1. Mat1 0 1     Bxb7#",
                    ['Bxb7#'], MATE_VALUE, "1.")
     
     # Notice, in the opposite situation there is no forced mate. Black can
     # do Bxe3 or Ne7+, but we just emulate a stupid analyzer not
     # recognizing this.
     self._testLine(self.engineI, self.analyzerI, board.switchColor(),
                    "10. -Mat 2 35 64989837     Bd4 Bxb7#",
                    ['Bd4','Bxb7#'], -MATE_VALUE, "10.")

 def __onReadyForMoves (self, self_):
     # If we are an analyzer, this signal was already called in a different
     # thread, so we can safely block it.
     if self.mode in (ANALYZING, INVERSE_ANALYZING):
         if not self.board:
             self.board = Board(setup=True)
         self.__sendAnalyze(self.mode == INVERSE_ANALYZING)
     
     self.readyMoves = True
     semisynced(lambda s:None)(self)

    def __init__(self, subprocess, color, protover, md5):
        ProtocolEngine.__init__(self, subprocess, color, protover, md5)

        self.ids = {}
        self.options = {}
        self.optionsToBeSent = {}

        self.wtime = 60000
        self.btime = 60000
        self.incr = 0
        self.timeHandicap = 1

        self.moveLock = RLock()
        # none of the following variables should be changed or used in a
        # condition statement without holding the above self.moveLock
        self.ponderOn = False
        self.pondermove = None
        self.ignoreNext = False
        self.waitingForMove = False
        self.needBestmove = False
        self.readyForStop = False  # keeps track of whether we already sent a 'stop' command
        self.multipvSetting = conf.get("multipv", 1
                                       )  # MultiPV option sent to the engine
        self.multipvExpected = 1  # Number of PVs expected (limited by number of legal moves)
        self.commands = collections.deque()

        self.gameBoard = Board(setup=True)  # board at the end of all moves played
        self.board = Board(setup=True)  # board to send the engine
        self.uciPosition = "startpos"
        self.uciPositionListsMoves = False
        self.analysis = [None]

        self.returnQueue = Queue()
        self.line_cid = self.engine.connect("line", self.parseLine)
        self.died_cid = self.engine.connect("died", self.__die)
        self.invalid_move = None

        self.cids = [
            self.connect("readyForOptions", self.__onReadyForOptions_before),
            self.connect_after("readyForOptions", self.__onReadyForOptions),
            self.connect_after("readyForMoves", self.__onReadyForMoves),
        ]

 def __onReadyForMoves (self, self_):
     self.returnQueue.put("ready")
     self.readyMoves = True
     self._newGame()
     
     # If we are an analyzer, this signal was already called in a different
     # thread, so we can safely block it.
     if self.mode in (ANALYZING, INVERSE_ANALYZING):
         if not self.board:
             self.board = Board(setup=True)
         self.putMove(self.board, None, None)

    def __init__(self, subprocess, color, protover, md5):
        ProtocolEngine.__init__(self, subprocess, color, protover, md5)

        self.ids = {}
        self.options = {}
        self.optionsToBeSent = {}

        self.wtime = 60000
        self.btime = 60000
        self.incr = 0
        self.moves = 0
        self.timeHandicap = 1

        self.ponderOn = False
        self.pondermove = None
        self.ignoreNext = False
        self.waitingForMove = False
        self.needBestmove = False
        self.bestmove_event = asyncio.Event()
        self.readyForStop = False  # keeps track of whether we already sent a 'stop' command
        self.multipvSetting = 1  # MultiPV option sent to the engine
        self.multipvExpected = 1  # Number of PVs expected (limited by number of legal moves)
        self.commands = collections.deque()

        self.gameBoard = Board(setup=True)  # board at the end of all moves played
        self.board = Board(setup=True)  # board to send the engine
        self.uciPosition = "startpos"
        self.uciPositionListsMoves = False
        self.analysis = [None]
        self.analysis_depth = None

        self.queue = asyncio.Queue()
        self.parse_line_task = asyncio.async(self.parseLine(self.engine))
        self.died_cid = self.engine.connect("died", lambda e: self.queue.put_nowait("die"))
        self.invalid_move = None

        self.cids = [
            self.connect_after("readyForOptions", self.__onReadyForOptions),
            self.connect_after("readyForMoves", self.__onReadyForMoves),
        ]

 def __init__(self, setup=False, lboard=None):
     if setup == True:
         Board.__init__(self, setup=self.shuffle_start(), lboard=lboard)
     else:
         Board.__init__(self, setup=setup, lboard=lboard)

class CECPEngine(ProtocolEngine):
    def __init__(self, subprocess, color, protover, md5):
        ProtocolEngine.__init__(self, subprocess, color, protover, md5)

        self.features = {
            "ping": 0,
            "setboard": 0,
            "playother": 0,
            "san": 0,
            "usermove": 0,
            "time": 1,
            "draw": 1,
            "sigint": 0,
            "sigterm": 0,
            "reuse": 0,
            "analyze": 0,
            "myname": ', '.join(self.defname),
            "variants": None,
            "colors": 1,
            "ics": 0,
            "name": 0,
            "pause": 0,
            "nps": 0,
            "debug": 0,
            "memory": 0,
            "smp": 0,
            "egt": '',
            "option": '',
            "exclude": 0,
            "done": None,
        }

        self.supported_features = [
            "ping", "setboard", "san", "usermove", "time", "draw", "sigint",
            "analyze", "myname", "variants", "colors", "pause", "done", "egt",
            "debug", "smp", "memory", "option"
        ]

        self.options = {}
        self.options["Ponder"] = {"name": "Ponder",
                                  "type": "check",
                                  "default": False}

        self.name = None

        self.board = Board(setup=True)

        # if self.engineIsInNotPlaying == True, engine is in "force" mode,
        # i.e. not thinking or playing, but still verifying move legality
        self.engineIsInNotPlaying = False
        self.engineIsAnalyzing = False
        self.movenext = False
        self.waitingForMove = False
        self.readyForMoveNowCommand = False
        self.timeHandicap = 1

        self.lastping = 0
        self.lastpong = 0

        self.queue = asyncio.Queue()
        self.parse_line_task = asyncio.async(self.parseLine(self.engine))
        self.died_cid = self.engine.connect("died", lambda e: self.queue.put_nowait("die"))
        self.invalid_move = None

        self.optionQueue = []
        self.undoQueue = []
        self.ready_moves_event = asyncio.Event()

        self.cids = [
            self.connect_after("readyForOptions", self.__onReadyForOptions),
            self.connect_after("readyForMoves", self.__onReadyForMoves),
        ]

    # Starting the game

    def prestart(self):
        print("xboard", file=self.engine)
        if self.protover == 1:
            # start a new game (CECPv1 engines):
            print("new", file=self.engine)

            # we are now ready for options:
            self.emit("readyForOptions")
        elif self.protover == 2:
            # start advanced protocol initialisation:
            print("protover 2", file=self.engine)

            # we don't start a new game for CECPv2 here,
            # we will do it after feature accept/reject is completed.

    def start(self, event=None):
        asyncio.async(self.__startBlocking(event))

    @asyncio.coroutine
    def __startBlocking(self, event):
        if self.protover == 1:
            self.emit("readyForMoves")
            return_value = "ready"

        if self.protover == 2:
#.........这里部分代码省略.........

 def __init__(self, setup=False, lboard=None):
     if setup is True:
         Board.__init__(self, setup=WILDCASTLESTART, lboard=lboard)
     else:
         Board.__init__(self, setup=setup, lboard=lboard)

                 "* Exactly one king of each color\n" +
                 "* Pieces placed randomly behind the pawns\n" +
                 "* No castling\n" +
                 "* Black's arrangement mirrors white's")
    name = _("Random")
    cecp_name = "unknown"
    need_initial_board = True
    standard_rules = True
    variant_group = VARIANTS_SHUFFLE

    def __init__ (self, setup=False, lboard=None):
        if setup is True:
            Board.__init__(self, setup=self.random_start(), lboard=lboard)
        else:
            Board.__init__(self, setup=setup, lboard=lboard)

    def random_start(self):        
        tmp = random.sample(('r', 'n', 'b', 'q')*16, 7)
        tmp.append('k')
        random.shuffle(tmp)
        tmp = ''.join(tmp)
        tmp = tmp + '/pppppppp/8/8/8/8/PPPPPPPP/' + tmp.upper() + ' w - - 0 1'
        
        return tmp


if __name__ == '__main__':
    Board = RandomBoard(True)
    for i in range(10):
        print(Board.random_start())

 def __init__(self, setup=False, lboard=None):
     if setup is True:
         Board.__init__(self, setup=UPSIDEDOWNSTART, lboard=lboard)
     else:
         Board.__init__(self, setup=setup, lboard=lboard)

 def __init__ (self, setup=False, lboard=None):
     if setup is True:
         Board.__init__(self, setup=PAWNSPASSEDSTART, lboard=lboard)
     else:
         Board.__init__(self, setup=setup, lboard=lboard)

class UCIEngine (ProtocolEngine):
    
    def __init__ (self, subprocess, color, protover, md5):
        ProtocolEngine.__init__(self, subprocess, color, protover, md5)
        
        self.ids = {}
        self.options = {}
        self.optionsToBeSent = {}
        
        self.wtime = 60000
        self.btime = 60000
        self.incr = 0
        self.timeHandicap = 1 
        
        self.moveLock = RLock()
        # none of the following variables should be changed or used in a
        # condition statement without holding the above self.moveLock
        self.ponderOn = False
        self.pondermove = None
        self.ignoreNext = False
        self.waitingForMove = False
        self.needBestmove = False
        self.readyForStop = False   # keeps track of whether we already sent a 'stop' command
        self.multipvSetting  = conf.get("multipv", 1)    # MultiPV option sent to the engine
        self.multipvExpected = 1    # Number of PVs expected (limited by number of legal moves)
        self.commands = collections.deque()
        
        self.gameBoard = Board(setup=True) # board at the end of all moves played
        self.board = Board(setup=True)     # board to send the engine
        self.uciPosition = "startpos"
        self.uciPositionListsMoves = False
        self.analysis = [ None ]
        
        self.returnQueue = Queue()
        self.engine.connect("line", self.parseLines)
        self.engine.connect("died", self.__die)
        
        self.connect("readyForOptions", self.__onReadyForOptions_before)
        self.connect_after("readyForOptions", self.__onReadyForOptions)
        self.connect_after("readyForMoves", self.__onReadyForMoves)
    
    def __die (self, subprocess):
        self.returnQueue.put("die")
    
    #===========================================================================
    #    Starting the game
    #===========================================================================
    
    def prestart (self):
        print("uci", file=self.engine)
    
    def start (self):
        if self.mode in (ANALYZING, INVERSE_ANALYZING):
            t = Thread(target=self.__startBlocking,
                       name=fident(self.__startBlocking))
            t.daemon = True
            t.start()
        else:
            self.__startBlocking()
    
    def __startBlocking (self):
        r = self.returnQueue.get()
        if r == 'die':
            raise PlayerIsDead
        assert r == "ready" or r == 'del'
        #self.emit("readyForOptions")
        #self.emit("readyForMoves")
    
    def __onReadyForOptions_before (self, self_):
        self.readyOptions = True
    
    def __onReadyForOptions (self, self_):
        if self.mode in (ANALYZING, INVERSE_ANALYZING):
            if self.hasOption("Ponder"):
                self.setOption('Ponder', False)
        
            if self.hasOption("MultiPV") and self.multipvSetting > 1:
                self.setOption('MultiPV', self.multipvSetting)
            
        for option, value in self.optionsToBeSent.items():
            if isinstance(value, bool):
                value = str(value).lower()
            print("setoption name %s value %s" % (option, str(value)), file=self.engine)
        
        print("isready", file=self.engine)
    
    def __onReadyForMoves (self, self_):
        self.returnQueue.put("ready")
        self.readyMoves = True
        self._newGame()
        
        # If we are an analyzer, this signal was already called in a different
        # thread, so we can safely block it.
        if self.mode in (ANALYZING, INVERSE_ANALYZING):
            self._searchNow()
    
    #===========================================================================
    #    Ending the game
    #===========================================================================
    
#.........这里部分代码省略.........

    def random_start(self):        
        tmp = random.sample(('r', 'n', 'b', 'q')*16, 7)
        tmp.append('k')
        random.shuffle(tmp)
        tmp = ''.join(tmp)
        tmp = tmp + '/pppppppp/8/8/8/8/PPPPPPPP/' + tmp.upper() + ' w - - 0 1'
        
        return tmp


class RandomChess:
    __desc__ = _("FICS wild/3: http://www.freechess.org/Help/HelpFiles/wild.html\n" +
                 "* Randomly chosen pieces (two queens or three rooks possible)\n" +
                 "* Exactly one king of each color\n" +
                 "* Pieces placed randomly behind the pawns\n" +
                 "* No castling\n" +
                 "* Black's arrangement mirrors white's")
    name = _("Random")
    cecp_name = "unknown"
    board = RandomBoard
    need_initial_board = True
    standard_rules = True
    variant_group = VARIANTS_SHUFFLE


if __name__ == '__main__':
    Board = RandomBoard(True)
    for i in range(10):
        print Board.random_start()

 def __init__ (self, setup=False, lboard=None):
     if setup is True:
         Board.__init__(self, setup=KNIGHTODDSSTART, lboard=lboard)
     else:
         Board.__init__(self, setup=setup, lboard=lboard)

 def __init__ (self, setup=False):
     if setup is True:
         Board.__init__(self, setup=PAWNSPASSEDSTART)
     else:
         Board.__init__(self, setup=setup)

                        blackdarkbishops += 1
                        blacklightbishops = blacklightbishops > 0 and (blacklightbishops-1) or 0
                        break
                    
        tmp = ''.join(black) + '/pppppppp/8/8/8/8/PPPPPPPP/' + \
              ''.join(white).upper() + ' w - - 0 1'
        
        return tmp


class AsymmetricRandomChess:
    __desc__ = \
        _("FICS wild/4: http://www.freechess.org/Help/HelpFiles/wild.html\n" +
          "* Randomly chosen pieces (two queens or three rooks possible)\n" +
          "* Exactly one king of each color\n" +
          "* Pieces placed randomly behind the pawns, SUBJECT TO THE CONSTRAINT THAT THE BISHOPS ARE BALANCED\n" +
          "* No castling\n" +
          "* Black's arrangement DOES NOT mirrors white's")
    name = _("Asymmetric Random")
    cecp_name = "unknown"
    board = AsymmetricRandomBoard
    need_initial_board = True
    standard_rules = True
    variant_group = VARIANTS_SHUFFLE


if __name__ == '__main__':
    Board = AsymmetricRandomBoard(True)
    for i in range(10):
        print Board.asymmetricrandom_start()