Пример #1
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
Пример #2
0
    def mueveHumano(self, desde, hasta, coronacion=""):
        jgUsu = self.checkMueveHumano(desde, hasta, coronacion)
        if not jgUsu:
            return False

        self.tiempo += time.time() - self.iniTiempo

        jgObj = self.partidaObj.jugada(self.posJugadaObj)

        siAnalizaJuez = True
        if self.book:
            fen = self.fenUltimo()
            siBookUsu = self.book.compruebaHumano(fen, desde, hasta)
            siBookObj = self.book.compruebaHumano(fen, jgObj.desde,
                                                  jgObj.hasta)
            if siBookUsu and siBookObj:
                if jgObj.movimiento() != jgUsu.movimiento():
                    bmove = _("book move")
                    comentario = "%s: %s %s<br>%s: %s %s" % (
                        self.nombreObj, jgObj.pgnSP(), bmove,
                        self.configuracion.jugador, jgUsu.pgnSP(), bmove)
                    w = PantallaJuicio.MensajeF(self.pantalla, comentario)
                    w.mostrar()
                siAnalizaJuez = False
            else:
                siAnalizaJuez = True
                if not siBookObj:
                    self.book = None

        analisis = None
        comentario = None

        if siAnalizaJuez:
            um = QTUtil2.analizando(self.pantalla)
            mrm = self.analizaMinimo(3000)
            posicion = self.partida.ultPosicion

            rmUsu, nada = mrm.buscaRM(jgUsu.movimiento())
            rmObj, posObj = mrm.buscaRM(jgObj.movimiento())

            analisis = mrm, posObj
            um.final()

            w = PantallaJuicio.WJuicio(self, self.xanalyzer, self.nombreObj,
                                       posicion, mrm, rmObj, rmUsu, analisis)
            w.exec_()

            analisis = w.analisis
            dpts = w.difPuntos()
            self.puntos += dpts
            self.ponPuntos()

            comentarioUsu = " %s" % (rmUsu.abrTexto())
            comentarioObj = " %s" % (rmObj.abrTexto())

            comentarioPuntos = "%s = %d %+d %+d = %d" % (
                _("Points"), self.puntos - dpts, rmUsu.puntosABS(),
                -rmObj.puntosABS(), self.puntos)

            comentario = "%s: %s %s\n%s: %s %s\n%s" % (
                self.nombreObj,
                jgObj.pgnSP(), comentarioObj, self.configuracion.jugador,
                jgUsu.pgnSP(), comentarioUsu, comentarioPuntos)

        self.analizaFinal()

        self.masJugada(True, analisis, comentario)
        self.siguienteJugada()
        return True
Пример #3
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
Пример #4
0
    def mueve_humano(self, from_sq, to_sq, promotion=""):
        jgUsu = self.checkmueve_humano(from_sq, to_sq, promotion)
        if not jgUsu:
            return False

        self.vtime += time.time() - self.iniTiempo

        jgObj = self.partidaObj.move(self.posJugadaObj)

        siAnalizaJuez = True
        if self.book:
            fen = self.fenUltimo()
            siBookUsu = self.book.check_human(fen, from_sq, to_sq)
            siBookObj = self.book.check_human(fen, jgObj.from_sq, jgObj.to_sq)
            if siBookUsu and siBookObj:
                if jgObj.movimiento() != jgUsu.movimiento():
                    bmove = _("book move")
                    comment = "%s: %s %s<br>%s: %s %s" % (
                        self.nombreObj,
                        jgObj.pgn_translated(),
                        bmove,
                        self.configuracion.x_player,
                        jgUsu.pgn_translated(),
                        bmove,
                    )
                    w = PantallaJuicio.MensajeF(self.main_window, comment)
                    w.mostrar()
                siAnalizaJuez = False
            else:
                siAnalizaJuez = True
                if not siBookObj:
                    self.book = None

        analisis = None
        comment = None

        if siAnalizaJuez:
            um = QTUtil2.analizando(self.main_window)
            pvUsu = jgUsu.movimiento()
            pvObj = jgObj.movimiento()
            mrm = self.analizaMinimo(pvUsu, pvObj)
            position = self.game.last_position

            rmUsu, nada = mrm.buscaRM(pvUsu)
            rmObj, posObj = mrm.buscaRM(pvObj)

            analisis = mrm, posObj
            um.final()

            w = PantallaJuicio.WJuicio(self, self.xanalyzer, self.nombreObj, position, mrm, rmObj, rmUsu, analisis)
            w.exec_()

            analisis = w.analysis
            if w.siAnalisisCambiado:
                self.siSave = True
            dpts = w.difPuntos()
            self.puntos += dpts

            dptsMax = w.difPuntosMax()
            self.puntosMax += dptsMax

            comentarioUsu = " %s" % (rmUsu.abrTexto())
            comentarioObj = " %s" % (rmObj.abrTexto())

            comentarioPuntos = "%s = %d %+d %+d = %d" % (
                _("Points"),
                self.puntos - dpts,
                rmUsu.centipawns_abs(),
                -rmObj.centipawns_abs(),
                self.puntos,
            )
            comment = "%s: %s %s\n%s: %s %s\n%s" % (
                self.nombreObj,
                jgObj.pgn_translated(),
                comentarioObj,
                self.configuracion.x_player,
                jgUsu.pgn_translated(),
                comentarioUsu,
                comentarioPuntos,
            )
            self.ponPuntos()

        self.analizaFinal()

        self.add_move(True, analisis, comment)
        self.siguiente_jugada()
        return True
Пример #5
0
    def mueveHumano(self, desde, hasta, coronacion=""):
        if self.siJuegaHumano:
            self.paraHumano()
        else:
            self.sigueHumano()
            return False

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

        siBien, mens, jgUsu = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)

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

        if self.siTeclaPanico:
            self.sigueHumano()
            return False

        jgObj = self.partidaObj.jugada(self.posJugadaObj)

        analisis = None
        comentario = None

        siBookUsu = False
        siBookObj = False

        comentarioUsu = ""
        comentarioObj = ""
        comentarioPuntos = ""

        siAnalizaJuez = True
        if self.book:
            fen = self.fenUltimo()
            siBookUsu = self.book.compruebaHumano(fen, desde, hasta)
            siBookObj = self.book.compruebaHumano(fen, jgObj.desde, jgObj.hasta)
            if siBookUsu:
                comentarioUsu = _( "book move")
            if siBookObj:
                comentarioObj = _( "book move")
            if siBookUsu and siBookObj:
                if jgObj.movimiento() == jgUsu.movimiento():
                    comentario = "%s: %s" % (_("Same book move"), jgObj.pgnSP())
                else:
                    bmove = _("book move")
                    comentario = "%s: %s %s\n%s: %s %s" % (self.nombreObj, jgObj.pgnSP(), bmove,
                                                                self.configuracion.jugador, jgUsu.pgnSP(), bmove)
                QTUtil2.mensajeTemporal(self.pantalla, comentario, 2)
                siAnalizaJuez = False
            else:
                siAnalizaJuez = True
                if not siBookObj:
                    self.book = None

        if siAnalizaJuez:
            um = QTUtil2.analizando(self.pantalla)
            mrm = self.analizaMinimo(5000)
            posicion = self.partida.ultPosicion

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

            rmObj, posObj = mrm.buscaRM(jgObj.movimiento())
            if rmObj is None:
                self.analizaFinal()
                rmObj = self.xtutor.valora(posicion, jgObj.desde, jgObj.hasta, jgObj.coronacion)
                posObj = mrm.agregaRM(rmObj)
                self.analizaInicio()

            analisis = mrm, posObj
            um.final()

            w = PantallaJuicio.WJuicio(self, self.xtutor, self.nombreObj, posicion, mrm, rmObj, rmUsu, analisis)
            w.exec_()

            analisis = w.analisis
            dpts = w.difPuntos()
            self.puntos += dpts
            self.ponPuntos()

            comentarioUsu += " %s"%(rmUsu.abrTexto())
            comentarioObj += " %s"%(rmObj.abrTexto())

            comentarioPuntos = "%s = %d %+d %+d = %d"%(_("Points"), self.puntos-dpts, rmUsu.puntosABS(),
                                                            -rmObj.puntosABS(), self.puntos)

            comentario = "%s: %s %s\n%s: %s %s\n%s"%( self.nombreObj, jgObj.pgnSP(), comentarioObj,
                                                  self.configuracion.jugador, jgUsu.pgnSP(), comentarioUsu,
                                                  comentarioPuntos )

        self.analizaFinal()

        self.masJugada(True, comentario, analisis)
        self.siguienteJugada()
        return True
Пример #6
0
    def mueveHumano(self, desde, hasta, coronacion=""):
        jgUsu = self.checkMueveHumano(desde, hasta, coronacion)
        if not jgUsu:
            return False

        jgObj = self.partidaObj.jugada(self.posJugadaObj)

        analisis = None
        comentario = None

        siBookUsu = False
        siBookObj = False

        comentarioUsu = ""
        comentarioObj = ""
        comentarioPuntos = ""

        siAnalizaJuez = jgUsu.movimiento() != jgObj.movimiento()
        if self.book:
            fen = self.fenUltimo()
            siBookUsu = self.book.compruebaHumano(fen, desde, hasta)
            siBookObj = self.book.compruebaHumano(fen, jgObj.desde,
                                                  jgObj.hasta)
            if siBookUsu:
                comentarioUsu = _("book move")
            if siBookObj:
                comentarioObj = _("book move")
            if siBookUsu and siBookObj:
                if jgObj.movimiento() != jgUsu.movimiento():
                    # comentario = "%s: %s" % (_("Same book move"), jgObj.pgnSP())
                    # else:
                    bmove = _("book move")
                    comentario = "%s: %s %s\n%s: %s %s" % (
                        self.nombreObj, jgObj.pgnSP(), bmove,
                        self.configuracion.jugador, jgUsu.pgnSP(), bmove)
                    w = PantallaJuicio.MensajeF(self.pantalla, comentario)
                    w.mostrar()
                siAnalizaJuez = False
            else:
                if not siBookObj:
                    self.book = None

        if siAnalizaJuez:
            um = QTUtil2.analizando(self.pantalla)
            if not self.continueTt:
                self.analizaInicio()
            mrm = self.analizaMinimo(5000)
            posicion = self.partida.ultPosicion

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

            rmObj, posObj = mrm.buscaRM(jgObj.movimiento())
            if rmObj is None:
                self.analizaFinal()
                rmObj = self.xtutor.valora(posicion, jgObj.desde, jgObj.hasta,
                                           jgObj.coronacion)
                posObj = mrm.agregaRM(rmObj)
                self.analizaInicio()

            analisis = mrm, posObj
            um.final()

            w = PantallaJuicio.WJuicio(self, self.xtutor, self.nombreObj,
                                       posicion, mrm, rmObj, rmUsu, analisis)
            w.exec_()

            analisis = w.analisis
            dpts = w.difPuntos()

            self.puntos += dpts
            self.ponPuntos()

            comentarioUsu += " %s" % (rmUsu.abrTexto())
            comentarioObj += " %s" % (rmObj.abrTexto())

            comentarioPuntos = "%s = %d %+d %+d = %d" % (
                _("Points"), self.puntos - dpts, rmUsu.puntosABS(),
                -rmObj.puntosABS(), self.puntos)

            comentario = "%s: %s %s\n%s: %s %s\n%s" % (
                self.nombreObj,
                jgObj.pgnSP(), comentarioObj, self.configuracion.jugador,
                jgUsu.pgnSP(), comentarioUsu, comentarioPuntos)

        self.analizaFinal()

        self.masJugada(True, comentario, analisis)
        self.siguienteJugada()
        return True
Пример #7
0
    def mueveHumano(self, desde, hasta, coronacion=""):
        jgUsu = self.checkMueveHumano(desde, hasta, coronacion)
        if not jgUsu:
            return False

        self.tiempo += time.time() - self.iniTiempo

        jgObj = self.partidaObj.jugada(self.posJugadaObj)
        fen = self.fenUltimo()

        siAnalizaJuez = True
        if self.book:
            siBookUsu = self.book.compruebaHumano(fen, desde, hasta)
            siBookObj = self.book.compruebaHumano(fen, jgObj.desde,
                                                  jgObj.hasta)
            if siBookUsu and siBookObj:
                if jgObj.movimiento() != jgUsu.movimiento():
                    bmove = _("book move")
                    comentario = "%s: %s %s<br>%s: %s %s" % (
                        self.nombreObj, jgObj.pgnSP(), bmove,
                        self.configuracion.jugador, jgUsu.pgnSP(), bmove)
                    w = PantallaJuicio.MensajeF(self.pantalla, comentario)
                    w.mostrar()
                siAnalizaJuez = False
            else:
                siAnalizaJuez = True
                if not siBookObj:
                    self.book = None

        analisis = None
        comentario = None

        if siAnalizaJuez:
            posicion = self.partida.ultPosicion
            saved = fen in self.dic_analysis
            if saved:
                rmObj, posObj, analisis, mrm = self.dic_analysis[fen]
            else:
                if self.continueTt:
                    um = QTUtil2.analizando(self.pantalla)
                    mrm = self.analizaMinimo(
                        5000) if self.continueTt else self.mrm
                    um.final()
                else:
                    self.analizaNoContinuoFinal()
                    mrm = self.mrm
                rmObj, posObj = mrm.buscaRM(jgObj.movimiento())
                analisis = mrm, posObj
                self.dic_analysis[fen] = [rmObj, posObj, analisis, mrm]

            rmUsu, posUsu = mrm.buscaRM(jgUsu.movimiento())
            if rmUsu is None:
                um = QTUtil2.analizando(self.pantalla)
                self.analizaFinal()
                rmUsu = self.xanalyzer.valora(posicion, desde, hasta,
                                              coronacion)
                mrm.agregaRM(rmUsu)
                self.analizaInicio()
                um.final()

            w = PantallaJuicio.WJuicio(self,
                                       self.xanalyzer,
                                       self.nombreObj,
                                       posicion,
                                       mrm,
                                       rmObj,
                                       rmUsu,
                                       analisis,
                                       siCompetitivo=False)
            w.exec_()

            if not saved:
                analisis = w.analisis
                self.dic_analysis[fen][2] = analisis

            dpts = w.difPuntos()
            self.puntos += dpts
            self.ponPuntos()

            if posUsu != posObj:
                comentarioUsu = " %s" % (rmUsu.abrTexto())
                comentarioObj = " %s" % (rmObj.abrTexto())

                comentarioPuntos = "%s = %d %+d %+d = %d" % (
                    _("Points"), self.puntos - dpts, rmUsu.puntosABS(),
                    -rmObj.puntosABS(), self.puntos)
                comentario = "%s: %s %s\n%s: %s %s\n%s" % (
                    self.nombreObj,
                    jgObj.pgnSP(), comentarioObj, self.configuracion.jugador,
                    jgUsu.pgnSP(), comentarioUsu, comentarioPuntos)
        if not self.continueTt:
            self.terminaNoContinuo()

        self.analizaFinal()

        self.masJugada(True, analisis, comentario)

        self.siguienteJugada()
        return True
Пример #8
0
    def mueve_humano(self, from_sq, to_sq, promotion=""):
        jgUsu = self.checkmueve_humano(from_sq, to_sq, promotion)
        if not jgUsu:
            return False

        jgObj = self.partidaObj.move(self.posJugadaObj)

        analisis = None
        comment = None

        comentarioUsu = ""
        comentarioObj = ""

        siAnalizaJuez = jgUsu.movimiento() != jgObj.movimiento()
        if self.book:
            fen = self.fenUltimo()
            siBookUsu = self.book.check_human(fen, from_sq, to_sq)
            siBookObj = self.book.check_human(fen, jgObj.from_sq, jgObj.to_sq)
            if siBookUsu:
                comentarioUsu = _("book move")
            if siBookObj:
                comentarioObj = _("book move")
            if siBookUsu and siBookObj:
                if jgObj.movimiento() != jgUsu.movimiento():
                    # comment = "%s: %s" % (_("Same book move"), jgObj.pgn_translated())
                    # else:
                    bmove = _("book move")
                    comment = "%s: %s %s\n%s: %s %s" % (
                        self.nombreObj,
                        jgObj.pgn_translated(),
                        bmove,
                        self.configuracion.x_player,
                        jgUsu.pgn_translated(),
                        bmove,
                    )
                    w = PantallaJuicio.MensajeF(self.main_window, comment)
                    w.mostrar()
                siAnalizaJuez = False
            else:
                if not siBookObj:
                    self.book = None

        if siAnalizaJuez:
            um = QTUtil2.analizando(self.main_window)
            if not self.continueTt:
                self.analizaInicio()
            mrm = self.analizaMinimo(5000)
            position = self.game.last_position

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

            rmObj, posObj = mrm.buscaRM(jgObj.movimiento())
            if rmObj is None:
                self.analizaFinal()
                rmObj = self.xtutor.valora(position, jgObj.from_sq,
                                           jgObj.to_sq, jgObj.promotion)
                posObj = mrm.agregaRM(rmObj)
                self.analizaInicio()

            analisis = mrm, posObj
            um.final()

            w = PantallaJuicio.WJuicio(self, self.xtutor, self.nombreObj,
                                       position, mrm, rmObj, rmUsu, analisis)
            w.exec_()

            analisis = w.analysis
            dpts = w.difPuntos()

            self.puntos += dpts
            self.ponPuntos()

            comentarioUsu += " %s" % (rmUsu.abrTexto())
            comentarioObj += " %s" % (rmObj.abrTexto())

            comentarioPuntos = "%s = %d %+d %+d = %d" % (
                _("Points"),
                self.puntos - dpts,
                rmUsu.centipawns_abs(),
                -rmObj.centipawns_abs(),
                self.puntos,
            )

            comment = "%s: %s %s\n%s: %s %s\n%s" % (
                self.nombreObj,
                jgObj.pgn_translated(),
                comentarioObj,
                self.configuracion.x_player,
                jgUsu.pgn_translated(),
                comentarioUsu,
                comentarioPuntos,
            )

        self.analizaFinal()

        self.add_move(True, comment, analisis)
        self.siguiente_jugada()
        return True
Пример #9
0
    def mueve_humano(self, from_sq, to_sq, promotion=""):
        jgUsu = self.checkmueve_humano(from_sq, to_sq, promotion)
        if not jgUsu:
            return False

        self.vtime += time.time() - self.iniTiempo

        jgObj = self.partidaObj.move(self.posJugadaObj)
        fen = self.fenUltimo()

        siAnalizaJuez = True
        if self.book:
            siBookUsu = self.book.check_human(fen, from_sq, to_sq)
            siBookObj = self.book.check_human(fen, jgObj.from_sq, jgObj.to_sq)
            if siBookUsu and siBookObj:
                if jgObj.movimiento() != jgUsu.movimiento():
                    bmove = _("book move")
                    comment = "%s: %s %s<br>%s: %s %s" % (
                        self.nombreObj,
                        jgObj.pgn_translated(),
                        bmove,
                        self.configuracion.x_player,
                        jgUsu.pgn_translated(),
                        bmove,
                    )
                    w = PantallaJuicio.MensajeF(self.main_window, comment)
                    w.mostrar()
                siAnalizaJuez = False
            else:
                siAnalizaJuez = True
                if not siBookObj:
                    self.book = None

        analisis = None
        comment = None

        if siAnalizaJuez:
            position = self.game.last_position
            saved = fen in self.dic_analysis
            if saved:
                rmObj, posObj, analisis, mrm = self.dic_analysis[fen]
            else:
                if self.continueTt:
                    um = QTUtil2.analizando(self.main_window)
                    mrm = self.analizaMinimo(5000) if self.continueTt else self.mrm
                    um.final()
                else:
                    self.analizaNoContinuoFinal()
                    mrm = self.mrm
                rmObj, posObj = mrm.buscaRM(jgObj.movimiento())
                analisis = mrm, posObj
                self.dic_analysis[fen] = [rmObj, posObj, analisis, mrm]

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

            w = PantallaJuicio.WJuicio(
                self, self.xanalyzer, self.nombreObj, position, mrm, rmObj, rmUsu, analisis, siCompetitivo=False
            )
            w.exec_()

            if not saved:
                analisis = w.analysis
                self.dic_analysis[fen][2] = analisis

            dpts = w.difPuntos()
            self.puntos += dpts
            self.ponPuntos()

            if posUsu != posObj:
                comentarioUsu = " %s" % (rmUsu.abrTexto())
                comentarioObj = " %s" % (rmObj.abrTexto())

                comentarioPuntos = "%s = %d %+d %+d = %d" % (
                    _("Points"),
                    self.puntos - dpts,
                    rmUsu.centipawns_abs(),
                    -rmObj.centipawns_abs(),
                    self.puntos,
                )
                comment = "%s: %s %s\n%s: %s %s\n%s" % (
                    self.nombreObj,
                    jgObj.pgn_translated(),
                    comentarioObj,
                    self.configuracion.x_player,
                    jgUsu.pgn_translated(),
                    comentarioUsu,
                    comentarioPuntos,
                )
        if not self.continueTt:
            self.terminaNoContinuo()

        self.analizaFinal()

        self.add_move(True, analisis, comment)

        self.siguiente_jugada()
        return True