Beispiel #1
0
    def grid_doble_click(self, grid, fila, oColumna):
        game = self.partidaActual()
        if game:
            self.procesador.cambiaXAnalyzer()
            xanalyzer = self.procesador.xanalyzer
            move = game.move(-1)
            fenm2 = move.position_before.fenm2()
            dic = self.dbop.getfenvalue(fenm2)
            if "ANALISIS" in dic:
                mrm = dic["ANALISIS"]
                move.analysis = mrm, 0
            else:
                me = QTUtil2.mensEspera.inicio(self, _("Analyzing the move...."), position="ad")

                move.analysis = xanalyzer.analizaJugadaPartida(
                    game, len(game) - 1, xanalyzer.motorTiempoJugada, xanalyzer.motorProfundidad
                )
                me.final()
            Analisis.show_analysis(
                self.procesador,
                xanalyzer,
                move,
                self.pboard.tablero.is_white_bottom,
                9999,
                len(game) - 1,
                main_window=self,
            )

            dic = self.dbop.getfenvalue(fenm2)
            dic["ANALISIS"] = move.analysis[0]
            self.dbop.setfenvalue(fenm2, dic)
Beispiel #2
0
    def gridDobleClick(self, grid, fila, oColumna):
        partida = self.partidaActual()
        if partida:
            self.procesador.cambiaXAnalyzer()
            xanalyzer = self.procesador.xanalyzer
            jg = partida.jugada(-1)
            fenM2 = jg.posicionBase.fenM2()
            dic = self.dbop.getfenvalue(fenM2)
            if "ANALISIS" in dic:
                mrm = dic["ANALISIS"]
                jg.analisis = mrm, 0
            else:
                me = QTUtil2.mensEspera.inicio(self,
                                               _("Analyzing the move...."),
                                               posicion="ad")

                jg.analisis = xanalyzer.analizaJugadaPartida(
                    partida,
                    len(partida) - 1, xanalyzer.motorTiempoJugada,
                    xanalyzer.motorProfundidad)
                me.final()
            Analisis.muestraAnalisis(self.procesador,
                                     xanalyzer,
                                     jg,
                                     self.pboard.tablero.siBlancasAbajo,
                                     9999,
                                     len(partida) - 1,
                                     pantalla=self)

            dic = self.dbop.getfenvalue(fenM2)
            dic["ANALISIS"] = jg.analisis[0]
            self.dbop.setfenvalue(fenM2, dic)
Beispiel #3
0
    def analizar(self, position):

        move = self.liAnalisis[position]
        is_white = move.position_before.is_white
        Analisis.show_analysis(
            self.procesador, self.xtutor, move, is_white, 9999999, 1, main_window=self, must_save=False
        )
Beispiel #4
0
 def analizar(self):
     Analisis.muestraAnalisis(self.procesador,
                              self.xtutor,
                              self.jg,
                              self.posicion.siBlancas,
                              9999999,
                              1,
                              pantalla=self,
                              siGrabar=False)
Beispiel #5
0
 def analizar(self):
     xtutor = self.procesador.XTutor()
     Analisis.show_analysis(self.procesador,
                            xtutor,
                            self.move,
                            self.position.is_white,
                            9999999,
                            1,
                            main_window=self,
                            must_save=False)
Beispiel #6
0
    def analizar(self, posicion):

        jg = self.liAnalisis[posicion]
        siBlancas = jg.posicionBase.siBlancas
        Analisis.muestraAnalisis(self.procesador,
                                 self.xtutor,
                                 jg,
                                 siBlancas,
                                 9999999,
                                 1,
                                 pantalla=self,
                                 siGrabar=False)
Beispiel #7
0
    def analizaPosicion(self, fila, clave):
        if fila < 0:
            return

        jg, siBlancas, siUltimo, tam_lj, pos = self.dameJugadaEn(fila, clave)
        if not jg:
            return

        maxRecursion = 9999

        if not (hasattr(jg, "analisis") and jg.analisis):
            me = QTUtil2.mensEspera.inicio(self.pantalla, _("Analyzing the move...."), posicion="ad")
            mrm, pos = self.xanalyzer.analizaJugada(jg, self.xanalyzer.motorTiempoJugada, self.xanalyzer.motorProfundidad)
            jg.analisis = mrm, pos
            me.final()

        Analisis.muestraAnalisis(self.procesador, self.xanalyzer, jg, self.tablero.siBlancasAbajo, maxRecursion, pos)
        self.ponVista()
Beispiel #8
0
    def analiza(self, quien):
        if quien == "Tutor":
            rmTutor = self.listaRM[self.posRM][0]
            jg = self.partidaTutor.liJugadas[self.posTutor]
            pts = rmTutor.texto()
        else:
            jg = self.partidaUsuario.liJugadas[self.posUsuario]
            pts = self.rmUsuario.texto()

        Analisis.AnalisisVariantes(self.w, self.gestor.xtutor, jg, self.siBlancas, pts)
Beispiel #9
0
    def analiza(self, quien):
        if quien == "Tutor":
            rmTutor = self.list_rm[self.pos_rm][0]
            move = self.game_tutor.move(self.pos_tutor)
            pts = rmTutor.texto()
        else:
            move = self.partidaUsuario.move(self.posUsuario)
            pts = self.rmUsuario.texto()

        Analisis.AnalisisVariantes(self.w, self.gestor.xtutor, move, self.is_white, pts)
Beispiel #10
0
    def analizaPosicion(self, fila, key):
        if fila < 0:
            return

        move, is_white, siUltimo, tam_lj, pos = self.dameJugadaEn(fila, key)
        if not move:
            return

        max_recursion = 9999

        if not (hasattr(move, "analisis") and move.analysis):
            me = QTUtil2.mensEspera.inicio(self.main_window,
                                           _("Analyzing the move...."),
                                           position="ad")
            mrm, pos = self.xanalyzer.analyse_move(
                move, self.xanalyzer.motorTiempoJugada,
                self.xanalyzer.motorProfundidad)
            move.analysis = mrm, pos
            me.final()

        Analisis.show_analysis(self.procesador, self.xanalyzer, move,
                               self.tablero.is_white_bottom, max_recursion,
                               pos)
        self.put_view()
Beispiel #11
0
    def tw_massive(self):
        liSeleccionadas = self.grid.recnosSeleccionados()
        nSeleccionadas = len(liSeleccionadas)

        alm = PantallaAnalisisParam.paramAnalisisMasivo(self, self.configuracion, nSeleccionadas > 1, siDatabase=True)
        if alm:

            if alm.siVariosSeleccionados:
                nregs = nSeleccionadas
            else:
                nregs = self.dbGames.reccount()

            tmpBP = QTUtil2.BarraProgreso2(self, _("Mass analysis"), formato2="%p%")
            tmpBP.ponTotal(1, nregs)
            tmpBP.ponRotulo(1, _("Game"))
            tmpBP.ponRotulo(2, _("Moves"))
            tmpBP.mostrar()

            ap = Analisis.AnalizaPartida(self.procesador, alm, True)

            for n in range(nregs):

                if tmpBP.siCancelado():
                    break

                tmpBP.pon(1, n + 1)

                if alm.siVariosSeleccionados:
                    n = liSeleccionadas[n]

                partida = self.dbGames.leePartidaRecno(n)
                self.grid.goto(n, 0)

                ap.xprocesa(partida.dicTags(), partida, tmpBP, partida.pgn())

                self.dbGames.guardaPartidaRecno(n, partida)

            if not tmpBP.siCancelado():
                ap.terminar(True)

                liCreados = []
                liNoCreados = []

                if alm.tacticblunders:
                    if ap.siTacticBlunders:
                        liCreados.append(alm.tacticblunders)
                    else:
                        liNoCreados.append(alm.tacticblunders)

                for x in (alm.pgnblunders, alm.fnsbrilliancies, alm.pgnbrilliancies):
                    if x:
                        if Util.existeFichero(x):
                            liCreados.append(x)
                        else:
                            liNoCreados.append(x)

                if alm.bmtblunders:
                    if ap.siBMTblunders:
                        liCreados.append(alm.bmtblunders)
                    else:
                        liNoCreados.append(alm.bmtblunders)
                if alm.bmtbrilliancies:
                    if ap.siBMTbrilliancies:
                        liCreados.append(alm.bmtbrilliancies)
                    else:
                        liNoCreados.append(alm.bmtbrilliancies)
                if liCreados:
                    PantallaPGN.mensajeEntrenamientos(self, liCreados, liNoCreados)

            else:
                ap.terminar(False)

            tmpBP.cerrar()
Beispiel #12
0
 def mueveLibre(self):
     jg = self.partida.liJugadas[self.posMueve]
     pts = self.listaRM[self.grid.recno()].rm.texto()
     Analisis.AnalisisVariantes(self, self.xmotor, jg,
                                self.posicion.siBlancas, pts)
Beispiel #13
0
 def mueveLibre(self):
     move = self.game.move(self.posMueve)
     pts = self.list_rm[self.grid.recno()].rm.texto()
     Analisis.AnalisisVariantes(self, self.xengine, move,
                                self.position.is_white, pts)
Beispiel #14
0
 def analizar(self):
     Analisis.muestraAnalisis(self.procesador, self.xtutor, self.jg, self.posicion.siBlancas, 9999999, 1,
                              pantalla=self, siGrabar=False)
Beispiel #15
0
    def analizar(self, posicion):

        jg = self.liAnalisis[posicion]
        siBlancas = jg.posicionBase.siBlancas
        Analisis.muestraAnalisis(self.procesador, self.xtutor, jg, siBlancas, 9999999, 1, pantalla=self, siGrabar=False)