예제 #1
0
 def entrenaGM(self):
     w = PantallaGM.WGM(self.procesador)
     if w.exec_():
         self.procesador.tipoJuego = kJugGM
         self.procesador.estado = kJugando
         self.procesador.gestor = GestorGM.GestorGM(self.procesador)
         self.procesador.gestor.inicio(w.record)
예제 #2
0
 def entrenaGM(self):
     w = PantallaGM.WGM(self.procesador)
     if w.exec_():
         self.procesador.game_type = GT_AGAINST_GM
         self.procesador.state = ST_PLAYING
         self.procesador.gestor = GestorGM.GestorGM(self.procesador)
         self.procesador.gestor.inicio(w.record)
    def piensaRival(self):
        self.rivalPensando = True
        pensarRival = True
        fen = self.partida.ultPosicion.fen()
        if self.siDirigido and self.siTutorActivado:
            my_last_fen = self.dicDirigidoFen.keys()[-1]
            if (fen in self.dicDirigidoFen) and (fen != my_last_fen):
                liOpciones = self.dicDirigidoFen[fen]
                if liOpciones:
                    liJugadas = []
                    for siMain, jg in liOpciones:
                        desde, hasta, coronacion = jg.desde, jg.hasta, jg.coronacion
                        if not self.siDirigidoVariantes:
                            if siMain:
                                liJugadas = []
                                break
                        rotulo = _("Main line") if siMain else ""
                        pgn = self.partida.ultPosicion.pgn(
                            desde, hasta, coronacion)
                        liJugadas.append(
                            (desde, hasta, coronacion, rotulo, pgn))
                    if len(liJugadas) > 1:
                        desde, hasta, coronacion = PantallaGM.eligeJugada(
                            self, liJugadas, False)
                    if len(liOpciones) > 1:
                        self.guardaVariantes()
                    pensarRival = False
            if pensarRival and self.siDirigidoSeguir is None:
                self.lineaTerminadaOpciones()
                self.rivalPensando = False
                return

        if pensarRival:
            self.pensando(True)
            self.desactivaTodas()

            self.rmRival = self.xrival.juega()

            self.pensando(False)
            desde, hasta, coronacion = self.rmRival.desde, self.rmRival.hasta, self.rmRival.coronacion

        if self.mueveRival(desde, hasta, coronacion):
            self.rivalPensando = False
            self.siguienteJugada()
        else:
            self.rivalPensando = False
예제 #4
0
    def piensaRival(self):
        self.rivalPensando = True
        pensarRival = True
        fen = self.partida.ultPosicion.fen()
        if self.siDirigido and self.siTutorActivado:
            if fen in self.dicDirigidoFen:
                liOpciones = self.dicDirigidoFen[fen]
                if liOpciones:
                    liJugadas = []
                    for siMain, jg in liOpciones:
                        desde, hasta, coronacion = jg.desde, jg.hasta, jg.coronacion
                        if not self.siDirigidoVariantes:
                            if siMain:
                                liJugadas = []
                                break
                        rotulo = _("Main line") if siMain else ""
                        pgn = self.partida.ultPosicion.pgn(desde, hasta, coronacion)
                        liJugadas.append((desde, hasta, coronacion, rotulo, pgn))
                    if len(liJugadas) > 1:
                        desde, hasta, coronacion = PantallaGM.eligeJugada(self, liJugadas, False)
                    if len(liOpciones) > 1:
                        self.guardaVariantes()
                    pensarRival = False
            if pensarRival and self.siDirigidoSeguir is None:
                if not self.lineaTerminadaOpciones():
                    self.rivalPensando = False
                    return

        if pensarRival:
            self.pensando(True)
            self.desactivaTodas()

            self.rmRival = self.xrival.juega()

            self.pensando(False)
            desde, hasta, coronacion = self.rmRival.desde, self.rmRival.hasta, self.rmRival.coronacion

        if self.mueveRival(desde, hasta, coronacion):
            self.rivalPensando = False
            self.siguienteJugada()
        else:
            self.rivalPensando = False
예제 #5
0
    def siguienteJugada(self):
        if self.estado == kFinJuego:
            return

        self.compruebaComentarios()

        self.estado = kJugando

        self.siJuegaHumano = False
        self.ponVista()

        siBlancas = self.partida.ultPosicion.siBlancas

        self.ponIndicador(siBlancas)
        self.refresh()

        if self.siTerminada():
            if not self.siSeguirJugando:
                self.finLinea()
            return

        siRival = siBlancas == self.siRivalConBlancas

        if siRival:
            fenM2 = self.partida.ultPosicion.fenM2()
            siPiensaRival = False
            if fenM2 in self.dicDirigidoFenM2:
                liOpciones = self.dicDirigidoFenM2[fenM2]
                if liOpciones:
                    liJugadas = []
                    siEncontradoMain = False
                    for siMain, jg in liOpciones:
                        desde, hasta, coronacion = jg.desde, jg.hasta, jg.coronacion
                        if self.siPenalizable and siMain:
                            siEncontradoMain = True
                            break
                        rotulo = _("Main line") if siMain else ""
                        pgn = self.partida.ultPosicion.pgn(
                            desde, hasta, coronacion)
                        liJugadas.append(
                            (desde, hasta, coronacion, rotulo, pgn))
                    if self.siPenalizable and not siEncontradoMain:
                        return self.finLinea()
                    if len(liJugadas) > 1 and not self.siPenalizable:
                        desde, hasta, coronacion = PantallaGM.eligeJugada(
                            self, liJugadas, False)
                    if len(liOpciones) > 1:
                        self.guardaVariantes()
                else:
                    if self.siSeguirJugando:
                        siPiensaRival = True
                    else:
                        return self.finLinea()
            else:
                if self.siSeguirJugando:
                    siPiensaRival = True
                else:
                    return self.finLinea()

            if siPiensaRival:
                self.pensando(True)
                self.desactivaTodas()

                self.rmRival = self.xrival.juega()

                self.pensando(False)
                desde, hasta, coronacion = self.rmRival.desde, self.rmRival.hasta, self.rmRival.coronacion

            if self.mueveRival(desde, hasta, coronacion):
                self.rivalPensando = False
                self.siguienteJugada()

        else:

            if not self.siSeguirJugando:
                fenM2 = self.partida.ultPosicion.fenM2()
                if fenM2 not in self.dicDirigidoFenM2:
                    return self.finLinea()

            self.siJuegaHumano = True
            self.activaColor(siBlancas)

            if not self.siSeguirJugando:
                self.iniReloj = time.time()
예제 #6
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        jgUsu = self.checkMueveHumano(desde, hasta, coronacion)
        if not jgUsu:
            return False

        movimiento = jgUsu.movimiento()
        posicion = self.partida.ultPosicion
        analisis = None

        isValid = self.motorGM.isValidMove(movimiento)

        analisis = None

        if not isValid:
            self.tablero.ponPosicion(posicion)
            self.tablero.activaColor(self.siJugamosConBlancas)
            liJugadas = self.motorGM.dameJugadasTXT(posicion, True)
            desdeGM, hastaGM, coronacionGM = PantallaGM.eligeJugada(
                self, liJugadas, True)
            siAnalizaJuez = self.siJuez
            if siAnalizaJuez:
                if self.book:
                    fen = self.fenUltimo()
                    siH = self.book.compruebaHumano(fen, desde, hasta)
                    siGM = self.book.compruebaHumano(fen, desdeGM, hastaGM)
                    if siGM and siH:
                        siAnalizaJuez = False
                    else:
                        self.book = False
        else:
            siAnalizaJuez = self.siJuez and self.mostrar is None  # None es ver siempre False no ver nunca True ver si diferentes
            desdeGM, hastaGM, coronacionGM = desde, hasta, coronacion

        siBien, mens, jgGM = Jugada.dameJugada(posicion, desdeGM, hastaGM,
                                               coronacionGM)
        movGM = jgGM.pgnSP()
        movUsu = jgUsu.pgnSP()

        if siAnalizaJuez:
            um = QTUtil2.analizando(self.pantalla)
            mrm = self.analizaMinimo(self.tiempo * 100)

            rmUsu, nada = mrm.buscaRM(jgUsu.movimiento())
            if rmUsu is None:
                self.analizaFinal()
                rmUsu = self.xtutor.valora(posicion, desde, hasta, coronacion)
                mrm.agregaRM(rmUsu)
                self.analizaInicio()

            rmGM, posGM = mrm.buscaRM(jgGM.movimiento())
            if rmGM is None:
                self.analizaFinal()
                rmGM = self.xtutor.valora(posicion, desdeGM, hastaGM,
                                          coronacionGM)
                posGM = mrm.agregaRM(rmGM)
                self.analizaInicio()

            um.final()

            analisis = mrm, posGM
            dpts = rmUsu.puntosABS() - rmGM.puntosABS()

            if self.mostrar is None or (self.mostrar == True and not isValid):
                w = PantallaJuicio.WJuicio(self,
                                           self.xtutor,
                                           self.nombreGM,
                                           posicion,
                                           mrm,
                                           rmGM,
                                           rmUsu,
                                           analisis,
                                           siCompetitivo=not self.showevals)
                w.exec_()

                rm, posGM = w.analisis[0].buscaRM(jgGM.movimiento())
                analisis = w.analisis[0], posGM

                dpts = w.difPuntos()

            self.puntos += dpts

            comentario0 = "<b>%s</b> : %s = %s<br>" % (
                self.configuracion.jugador, movUsu, rmUsu.texto())
            comentario0 += "<b>%s</b> : %s = %s<br>" % (self.nombreGM, movGM,
                                                        rmGM.texto())
            comentario1 = "<br><b>%s</b> = %+d<br>" % (_("Difference"), dpts)
            comentario2 = "<b>%s</b> = %+d<br>" % (_("Points accumulated"),
                                                   self.puntos)
            self.textoPuntuacion = comentario2
            self.ponRotuloSecundario()

            if not isValid:
                jgGM.comentario = (comentario0 + comentario1 +
                                   comentario2).replace("<b>", "").replace(
                                       "</b>", "").replace("<br>", "\n")

        self.analizaFinal()

        self.movimientosPiezas(jgGM.liMovs)

        self.partida.ultPosicion = jgGM.posicion
        jgGM.analisis = analisis
        self.masJugada(jgGM, True)
        self.error = ""
        self.siguienteJugada()
        return True
예제 #7
0
    def siguienteJugada(self):
        self.analizaTerminar()
        self.desactivaTodas()

        if self.estado == kFinJuego:
            return

        self.estado = kJugando

        self.siJuegaHumano = False
        self.ponVista()

        siBlancas = self.partida.ultPosicion.siBlancas

        if (self.partida.numJugadas() > 0) and self.motorGM.isFinished():
            self.ponResultado()
            return

        self.ponIndicador(siBlancas)
        self.refresh()

        siRival = siBlancas == self.siRivalConBlancas

        if self.jugInicial > 1:
            siJugInicial = (self.partida.numJugadas() / 2 +
                            1) <= self.jugInicial
        else:
            siJugInicial = False

        liAlternativas = self.motorGM.alternativas()
        nliAlternativas = len(liAlternativas)

        # Movimiento automatico
        if siJugInicial or self.onApertura or self.onBypassBook:
            siBuscar = True
            if self.onApertura:
                liPV = self.apertura.a1h8.split(" ")
                nj = self.partida.numJugadas()
                if len(liPV) > nj:
                    move = liPV[nj]
                    if move in liAlternativas:
                        siBuscar = False
                    else:
                        self.onApertura = False
                else:
                    self.onApertura = False

            if siBuscar:
                if self.onBypassBook:
                    liJugadas = self.bypassBook.miraListaJugadas(
                        self.fenUltimo())
                    liN = []
                    for desde, hasta, coronacion, pgn, peso in liJugadas:
                        move = desde + hasta + coronacion
                        if move in liAlternativas:
                            liN.append(move)
                    if liN:
                        siBuscar = False
                        nliAlternativas = len(liN)
                        if nliAlternativas > 1:
                            pos = random.randint(0, nliAlternativas - 1)
                            move = liN[pos]
                        else:
                            move = liN[0]
                    else:
                        self.onBypassBook = None

            if siBuscar:
                if siJugInicial:
                    siBuscar = False
                    if nliAlternativas > 1:
                        pos = random.randint(0, nliAlternativas - 1)
                        move = liAlternativas[pos]
                    elif nliAlternativas == 1:
                        move = liAlternativas[0]

            if not siBuscar:
                self.mueveRival(move)
                self.siguienteJugada()
                return

        if siRival:
            if nliAlternativas > 1:
                if self.jugContrario:
                    liJugadas = self.motorGM.dameJugadasTXT(
                        self.partida.ultPosicion, False)
                    desde, hasta, coronacion = PantallaGM.eligeJugada(
                        self, liJugadas, False)
                    move = desde + hasta + coronacion
                else:
                    pos = random.randint(0, nliAlternativas - 1)
                    move = liAlternativas[pos]
            else:
                move = liAlternativas[0]

            self.mueveRival(move)
            self.siguienteJugada()

        else:
            self.siJuegaHumano = True
            self.pensando(True)
            self.analizaInicio()
            self.activaColor(siBlancas)
            self.pensando(False)
예제 #8
0
    def mueve_humano(self, from_sq, to_sq, promotion=None):
        jgUsu = self.checkmueve_humano(from_sq, to_sq, promotion)
        if not jgUsu:
            return False

        movimiento = jgUsu.movimiento()
        position = self.game.last_position
        isValid = self.motorGM.isValidMove(movimiento)
        analisis = None

        if not isValid:
            self.tablero.setposition(position)
            self.tablero.activaColor(self.is_human_side_white)
            li_moves = self.motorGM.dameJugadasTXT(position, True)
            desdeGM, hastaGM, coronacionGM = PantallaGM.eligeJugada(self, li_moves, True)
            siAnalizaJuez = self.siJuez
            if siAnalizaJuez:
                if self.book:
                    fen = self.fenUltimo()
                    siH = self.book.check_human(fen, from_sq, to_sq)
                    siGM = self.book.check_human(fen, desdeGM, hastaGM)
                    if siGM and siH:
                        siAnalizaJuez = False
                    else:
                        self.book = False
        else:
            siAnalizaJuez = (
                self.siJuez and self.mostrar is None
            )  # None es ver siempre False no ver nunca True ver si diferentes
            if len(movimiento) == 5:
                promotion = movimiento[4].lower()
            desdeGM, hastaGM, coronacionGM = from_sq, to_sq, promotion

        siBien, mens, jgGM = Move.dameJugada(self.game, position, desdeGM, hastaGM, coronacionGM)
        movGM = jgGM.pgn_translated()
        movUsu = jgUsu.pgn_translated()

        if siAnalizaJuez:
            um = QTUtil2.analizando(self.main_window)
            mrm = self.analizaMinimo(self.vtime * 100)

            rmUsu, nada = mrm.buscaRM(jgUsu.movimiento())
            if rmUsu is None:
                um = QTUtil2.analizando(self.main_window)
                self.analizaFinal()
                rmUsu = self.xtutor.valora(position, from_sq, to_sq, promotion)
                mrm.agregaRM(rmUsu)
                self.analizaInicio()
                um.final()

            rmGM, pos_gm = mrm.buscaRM(jgGM.movimiento())
            if rmGM is None:
                self.analizaFinal()
                rmGM = self.xtutor.valora(position, desdeGM, hastaGM, coronacionGM)
                pos_gm = mrm.agregaRM(rmGM)
                self.analizaInicio()

            um.final()

            analisis = mrm, pos_gm
            dpts = rmUsu.centipawns_abs() - rmGM.centipawns_abs()

            if self.mostrar is None or ((self.mostrar is True) and not isValid):
                w = PantallaJuicio.WJuicio(
                    self,
                    self.xtutor,
                    self.nombreGM,
                    position,
                    mrm,
                    rmGM,
                    rmUsu,
                    analisis,
                    siCompetitivo=not self.showevals,
                )
                w.exec_()

                rm, pos_gm = w.analysis[0].buscaRM(jgGM.movimiento())
                analisis = w.analysis[0], pos_gm

                dpts = w.difPuntos()

            self.puntos += dpts

            comentario0 = "<b>%s</b> : %s = %s<br>" % (self.configuracion.x_player, movUsu, rmUsu.texto())
            comentario0 += "<b>%s</b> : %s = %s<br>" % (self.nombreGM, movGM, rmGM.texto())
            comentario1 = "<br><b>%s</b> = %+d<br>" % (_("Difference"), dpts)
            comentario2 = "<b>%s</b> = %+d<br>" % (_("Points accumulated"), self.puntos)
            self.textoPuntuacion = comentario2
            self.ponRotuloSecundario()

            if not isValid:
                jgGM.comment = (
                    (comentario0 + comentario1 + comentario2)
                    .replace("<b>", "")
                    .replace("</b>", "")
                    .replace("<br>", "\n")
                )

        self.analizaFinal()

        self.move_the_pieces(jgGM.liMovs)

        jgGM.analysis = analisis
        self.add_move(jgGM, True)
        self.error = ""
        self.siguiente_jugada()
        return True
예제 #9
0
    def siguiente_jugada(self):
        self.analizaTerminar()
        self.disable_all()

        if self.state == ST_ENDGAME:
            return

        self.state = ST_PLAYING

        self.human_is_playing = False
        self.put_view()

        is_white = self.game.last_position.is_white

        if (len(self.game) > 0) and self.motorGM.isFinished():
            self.put_result()
            return

        self.ponIndicador(is_white)
        self.refresh()

        siRival = is_white == self.is_engine_side_white

        if self.jugInicial > 1:
            siJugInicial = (len(self.game) / 2 + 1) <= self.jugInicial
        else:
            siJugInicial = False

        liAlternativas = self.motorGM.alternativas()
        nliAlternativas = len(liAlternativas)

        # Movimiento automatico
        if siJugInicial or self.onApertura or self.onBypassBook:
            siBuscar = True
            if self.onApertura:
                liPV = self.opening.a1h8.split(" ")
                nj = len(self.game)
                if len(liPV) > nj:
                    move = liPV[nj]
                    if move in liAlternativas:
                        siBuscar = False
                    else:
                        self.onApertura = False
                else:
                    self.onApertura = False

            if siBuscar:
                if self.onBypassBook:
                    li_moves = self.bypassBook.miraListaJugadas(self.fenUltimo())
                    liN = []
                    for from_sq, to_sq, promotion, pgn, peso in li_moves:
                        move = from_sq + to_sq + promotion
                        if move in liAlternativas:
                            liN.append(move)
                    if liN:
                        siBuscar = False
                        nliAlternativas = len(liN)
                        if nliAlternativas > 1:
                            pos = random.randint(0, nliAlternativas - 1)
                            move = liN[pos]
                        else:
                            move = liN[0]
                    else:
                        self.onBypassBook = None

            if siBuscar:
                if siJugInicial:
                    siBuscar = False
                    if nliAlternativas > 1:
                        pos = random.randint(0, nliAlternativas - 1)
                        move = liAlternativas[pos]
                    elif nliAlternativas == 1:
                        move = liAlternativas[0]

            if not siBuscar:
                self.mueve_rival(move)
                self.siguiente_jugada()
                return

        if siRival:
            if nliAlternativas > 1:
                if self.jugContrario:
                    li_moves = self.motorGM.dameJugadasTXT(self.game.last_position, False)
                    from_sq, to_sq, promotion = PantallaGM.eligeJugada(self, li_moves, False)
                    move = from_sq + to_sq + promotion
                else:
                    pos = random.randint(0, nliAlternativas - 1)
                    move = liAlternativas[pos]
            else:
                move = liAlternativas[0]

            self.mueve_rival(move)
            self.siguiente_jugada()

        else:
            self.human_is_playing = True
            self.pensando(True)
            self.analizaInicio()
            self.activaColor(is_white)
            self.pensando(False)
예제 #10
0
    def siguienteJugada(self):
        if self.estado == kFinJuego:
            return

        self.compruebaComentarios()

        self.estado = kJugando

        self.siJuegaHumano = False
        self.ponVista()

        siBlancas = self.partida.ultPosicion.siBlancas

        self.ponIndicador(siBlancas)
        self.refresh()

        if self.siTerminada():
            if not self.siSeguirJugando:
                self.finLinea()
            return

        siRival = siBlancas == self.siRivalConBlancas

        if siRival:
            fen = self.partida.ultPosicion.fen()
            siPiensaRival = False
            if fen in self.dicDirigidoFen:
                liOpciones = self.dicDirigidoFen[fen]
                if liOpciones:
                    liJugadas = []
                    siEncontradoMain = False
                    for siMain, jg in liOpciones:
                        desde, hasta, coronacion = jg.desde, jg.hasta, jg.coronacion
                        if self.siPenalizable and siMain:
                            siEncontradoMain = True
                            break
                        rotulo = _("Main line") if siMain else ""
                        pgn = self.partida.ultPosicion.pgn(desde, hasta, coronacion)
                        liJugadas.append((desde, hasta, coronacion, rotulo, pgn))
                    if self.siPenalizable and not siEncontradoMain:
                        return self.finLinea()
                    if len(liJugadas) > 1 and not self.siPenalizable:
                        desde, hasta, coronacion = PantallaGM.eligeJugada(self, liJugadas, False)
                    if len(liOpciones) > 1:
                        self.guardaVariantes()
                else:
                    if self.siSeguirJugando:
                        siPiensaRival = True
                    else:
                        return self.finLinea()
            else:
                if self.siSeguirJugando:
                    siPiensaRival = True
                else:
                    return self.finLinea()

            if siPiensaRival:
                self.pensando(True)
                self.desactivaTodas()

                self.rmRival = self.xrival.juega()

                self.pensando(False)
                desde, hasta, coronacion = self.rmRival.desde, self.rmRival.hasta, self.rmRival.coronacion

            if self.mueveRival(desde, hasta, coronacion):
                self.rivalPensando = False
                self.siguienteJugada()

        else:

            if not self.siSeguirJugando:
                fen = self.partida.ultPosicion.fen()
                if fen not in self.dicDirigidoFen:
                    return self.finLinea()

            self.siJuegaHumano = True
            self.activaColor(siBlancas)

            if not self.siSeguirJugando:
                self.iniReloj = time.time()
예제 #11
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        if self.siJuegaHumano:
            self.paraHumano()
        else:
            self.sigueHumano()
            return False

        movimiento = desde + hasta
        posicion = self.partida.ultPosicion
        analisis = None

        # Peon coronando
        if not coronacion and posicion.siPeonCoronando(desde, hasta):
            coronacion = self.tablero.peonCoronando(posicion.siBlancas)
            if coronacion is None:
                self.sigueHumano()
                return False
        if coronacion:
            movimiento += coronacion

        siBien, mens, jgUsu = Jugada.dameJugada(posicion, desde, hasta, coronacion)

        if not siBien:
            self.sigueHumano()
            self.error = mens
            return False

        isValid = self.motorGM.isValidMove(movimiento)

        analisis = None

        if not isValid:
            self.tablero.ponPosicion(posicion)
            self.tablero.activaColor(self.siJugamosConBlancas)
            liJugadas = self.motorGM.dameJugadasTXT(posicion, True)
            desdeGM, hastaGM, coronacionGM = PantallaGM.eligeJugada(self, liJugadas, True)
            siAnalizaJuez = self.siJuez
            if siAnalizaJuez:
                if self.book:
                    fen = self.fenUltimo()
                    siH = self.book.compruebaHumano(fen, desde, hasta)
                    siGM = self.book.compruebaHumano(fen, desdeGM, hastaGM)
                    if siGM and siH:
                        siAnalizaJuez = False
                    else:
                        self.book = False
        else:
            siAnalizaJuez = self.siJuez and self.mostrar is None  # None es ver siempre False no ver nunca True ver si diferentes
            desdeGM, hastaGM, coronacionGM = desde, hasta, coronacion

        siBien, mens, jgGM = Jugada.dameJugada(posicion, desdeGM, hastaGM, coronacionGM)
        movGM = jgGM.pgnSP()
        movUsu = jgUsu.pgnSP()

        if siAnalizaJuez:
            um = QTUtil2.analizando(self.pantalla)
            mrm = self.analizaMinimo(self.tiempo * 100)

            rmUsu, nada = mrm.buscaRM(jgUsu.movimiento())
            if rmUsu is None:
                self.analizaFinal()
                rmUsu = self.xtutor.valora(posicion, desde, hasta, coronacion)
                mrm.agregaRM(rmUsu)
                self.analizaInicio()

            rmGM, posGM = mrm.buscaRM(jgGM.movimiento())
            if rmGM is None:
                self.analizaFinal()
                rmGM = self.xtutor.valora(posicion, desdeGM, hastaGM, coronacionGM)
                posGM = mrm.agregaRM(rmGM)
                self.analizaInicio()

            um.final()

            analisis = mrm, posGM
            dpts = rmUsu.puntosABS() - rmGM.puntosABS()

            if self.mostrar is None or (self.mostrar == True and not isValid):
                w = PantallaJuicio.WJuicio(self, self.xtutor, self.nombreGM, posicion, mrm, rmGM, rmUsu, analisis)
                w.exec_()

                rm, posGM = w.analisis[0].buscaRM(jgGM.movimiento())
                analisis = w.analisis[0], posGM

                dpts = w.difPuntos()

            self.puntos += dpts

            comentario0 = "<b>%s</b> : %s = %s<br>" % (self.configuracion.jugador, movUsu, rmUsu.texto() )
            comentario0 += "<b>%s</b> : %s = %s<br>" % (self.nombreGM, movGM, rmGM.texto() )
            comentario1 = "<br><b>%s</b> = %+d<br>" % ( _("Difference"), dpts )
            comentario2 = "<b>%s</b> = %+d<br>" % ( _("Points accumulated"), self.puntos )
            self.textoPuntuacion = comentario2
            self.ponRotuloSecundario()

            if not isValid:
                jgGM.comentario = (comentario0 + comentario1 + comentario2).replace("<b>", "").replace("</b>", "").replace(
                    "<br>", "\n")

        self.analizaFinal()

        self.movimientosPiezas(jgGM.liMovs)

        self.partida.ultPosicion = jgGM.posicion
        jgGM.analisis = analisis
        self.masJugada(jgGM, True)
        self.error = ""
        self.siguienteJugada()
        return True
예제 #12
0
    def siguienteJugada(self):
        self.analizaTerminar()
        self.desactivaTodas()

        if self.estado == kFinJuego:
            return

        self.estado = kJugando

        self.siJuegaHumano = False
        self.ponVista()

        siBlancas = self.partida.ultPosicion.siBlancas

        if (self.partida.numJugadas() > 0) and self.motorGM.isFinished():
            self.ponResultado()
            return

        self.ponIndicador(siBlancas)
        self.refresh()

        siRival = siBlancas == self.siRivalConBlancas

        if self.jugInicial > 1:
            siJugInicial = (self.partida.numJugadas() / 2 + 1) <= self.jugInicial
        else:
            siJugInicial = False

        liAlternativas = self.motorGM.alternativas()
        nliAlternativas = len(liAlternativas)

        # Movimiento automatico
        if siJugInicial or self.onApertura or self.onBypassBook:
            siBuscar = True
            if self.onApertura:
                liPV = self.apertura.a1h8.split(" ")
                nj = self.partida.numJugadas()
                if len(liPV) > nj:
                    move = liPV[nj]
                    if move in liAlternativas:
                        siBuscar = False
                    else:
                        self.onApertura = False
                else:
                    self.onApertura = False

            if siBuscar:
                if self.onBypassBook:
                    liJugadas = self.bypassBook.miraListaJugadas(self.fenUltimo())
                    liN = []
                    for desde, hasta, coronacion, pgn, peso in liJugadas:
                        move = desde + hasta + coronacion
                        if move in liAlternativas:
                            liN.append(move)
                    if liN:
                        siBuscar = False
                        nliAlternativas = len(liN)
                        if nliAlternativas > 1:
                            pos = random.randint(0, nliAlternativas - 1)
                            move = liN[pos]
                        else:
                            move = liN[0]
                    else:
                        self.onBypassBook = None

            if siBuscar:
                if siJugInicial:
                    siBuscar = False
                    if nliAlternativas > 1:
                        pos = random.randint(0, nliAlternativas - 1)
                        move = liAlternativas[pos]
                    elif nliAlternativas == 1:
                        move = liAlternativas[0]

            if not siBuscar:
                self.mueveRival(move)
                self.siguienteJugada()
                return

        if siRival:
            if nliAlternativas > 1:
                if self.jugContrario:
                    liJugadas = self.motorGM.dameJugadasTXT(self.partida.ultPosicion, False)
                    desde, hasta, coronacion = PantallaGM.eligeJugada(self, liJugadas, False)
                    move = desde + hasta + coronacion
                else:
                    pos = random.randint(0, nliAlternativas - 1)
                    move = liAlternativas[pos]
            else:
                move = liAlternativas[0]

            self.mueveRival(move)
            self.siguienteJugada()

        else:
            self.siJuegaHumano = True
            self.pensando(True)
            self.analizaInicio()
            self.activaColor(siBlancas)
            self.pensando(False)