Beispiel #1
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        if self.siJuegaHumano:
            self.paraHumano()
        else:
            self.sigueHumano()
            return False

        movimiento = desde + hasta

        # 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
        if coronacion:
            movimiento += coronacion

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

        if siBien:
            self.movimientosPiezas(jg.liMovs)
            self.masJugada(jg, True)
            self.error = ""
            self.siguienteJugada()
            return True
        else:
            self.sigueHumano()
            self.error = mens
            return False
Beispiel #2
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        # Peon coronando
        if not coronacion and self.partida.ultPosicion.siPeonCoronando(desde, hasta):
            coronacion = self.tablero.peonCoronando(self.partida.ultPosicion.siBlancas)
            if coronacion is None:
                return False

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

        if siBien:

            self.movimientosPiezas(jg.liMovs)

            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg, True)
            self.error = ""

            if self.siJuegaMotor and not self.partida.siEstaTerminada():
                self.siJuegaMotor = False
                self.desactivaTodas()
                self.juegaRival()
                self.siJuegaMotor = True  # Como juega por mi pasa por aqui, para que no se meta en un bucle infinito

            self.siguienteJugada()
            return True
        else:
            self.error = mens
            return False
Beispiel #3
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        if not coronacion and self.partida.ultPosicion.siPeonCoronando(desde, hasta):
            coronacion = self.tablero.peonCoronando(self.partida.ultPosicion.siBlancas)
            if coronacion is None:
                return False

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

        if siBien:
            self.partida.append_jg(jg)
            if self.partida.siTerminada():
                jg.siJaqueMate = jg.siJaque
                jg.siAhogado = not jg.siJaque
            resp = self.partida.si3repetidas()
            if resp:
                jg.siTablasRepeticion = True
            elif self.partida.ultPosicion.movPeonCap >= 100:
                jg.siTablas50 = True
            elif self.partida.ultPosicion.siFaltaMaterial():
                jg.siTablasFaltaMaterial = True
            self.tablero.ponPosicion(jg.posicion)
            self.tablero.ponFlechaSC(jg.desde, jg.hasta)

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

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

        if siBien:

            self.movimientosPiezas(jg.liMovs)

            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg)
            self.error = ""
            if self.siJuegaMotor:
                self.siJuegaMotor = False
                self.desactivaTodas()
                self.juegaRival()
                self.siJuegaMotor = True  # Como juega por mi pasa por aqui, para que no se meta en un bucle infinito

            self.siguienteJugada()
            return True
        else:
            self.error = mens
            return False
Beispiel #5
0
    def leerPV(self, pvBloque):
        posicion = self.ultPosicion
        pv = []
        for mov in pvBloque.split(" "):
            if len(mov) >= 4 and mov[0] in "abcdefgh" and mov[1] in "12345678" and mov[2] in "abcdefgh" and mov[
                3] in "12345678":
                pv.append(mov)
            else:
                break

        siB = self.siBlancas

        for mov in pv:
            desde = mov[:2]
            hasta = mov[2:4]
            if len(mov) == 5:
                coronacion = mov[4]
                if siB:
                    coronacion = coronacion.upper()
            else:
                coronacion = None
            siBien, mens, jg = Jugada.dameJugada(posicion, desde, hasta, coronacion)
            if siBien:
                self.liJugadas.append(jg)
                posicion = jg.posicion
            siB = not siB
        self.ultPosicion = posicion
        return self
Beispiel #6
0
    def leerLIPV(self, lipv):
        posicion = self.ultPosicion
        pv = []
        for mov in lipv:
            if len(mov) >= 4 and mov[0] in "abcdefgh" and mov[1] in "12345678" and mov[2] in "abcdefgh" \
                    and mov[3] in "12345678":
                pv.append(mov)
            else:
                break

        siB = self.siBlancas

        for mov in pv:
            desde = mov[:2]
            hasta = mov[2:4]
            if len(mov) == 5:
                coronacion = mov[4]
                if siB:
                    coronacion = coronacion.upper()
            else:
                coronacion = None
            siBien, mens, jg = Jugada.dameJugada(posicion, desde, hasta, coronacion)
            if siBien:
                self.liJugadas.append(jg)
                posicion = jg.posicion
            siB = not siB
        self.ultPosicion = posicion
        return self
    def mueveHumano(self, desde, hasta, coronacion=None):
        jg = self.checkMueveHumano(desde, hasta, coronacion)
        if not jg:
            return False

        movimiento = jg.movimiento()
        self.addTime()

        siAnalisis = False

        siElegido = False

        if self.apertura:
            fenBase = self.fenUltimo()
            if self.apertura.compruebaHumano(fenBase, desde, hasta):
                siElegido = True
            else:
                self.apertura = None

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

        self.analizaFinal()  # tiene que acabar siempre
        if not siElegido:
            rmUser, n = self.mrmTutor.buscaRM(movimiento)
            if not rmUser:
                rmUser = self.xtutor.valora(self.partida.ultPosicion, desde, hasta, jg.coronacion)
                if not rmUser:
                    self.sigueHumanoAnalisis()
                    return False
                self.mrmTutor.agregaRM(rmUser)
            siAnalisis = True
            pointsBest, pointsUser = self.mrmTutor.difPointsBest(movimiento)
            if (pointsBest - pointsUser) > 0:
                if not jg.siJaqueMate:
                    tutor = Tutor.Tutor(self, self, jg, desde, hasta, False)
                    if tutor.elegir(True):
                        self.reponPieza(desde)
                        desde = tutor.desde
                        hasta = tutor.hasta
                        coronacion = tutor.coronacion
                        siBien, mens, jgTutor = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
                        if siBien:
                            jg = jgTutor
                            self.addHint()
                    del tutor

        self.movimientosPiezas(jg.liMovs)

        if siAnalisis:
            rm, nPos = self.mrmTutor.buscaRM(jg.movimiento())
            if rm:
                jg.analisis = self.mrmTutor, nPos

        self.partida.ultPosicion = jg.posicion
        self.masJugada(jg, True)
        self.error = ""
        self.siguienteJugada()
        return True
Beispiel #8
0
    def mueveRival(self, desde, hasta, coronacion):

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion
            if not self.siTutorActivado:
                self.siAnalizadoTutor = False
            else:

                if not self.siDirigido:
                    self.analizaTutor()  # Que analice antes de activar humano, para que no tenga que esperar
                    self.siAnalizadoTutor = True

            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            self.error = ""

            if self.siDirigido and ( self.partida.ultPosicion.fen() not in self.dicDirigidoFen ):
                self.lineaTerminadaOpciones()

            return True
        else:
            self.error = mens
            return False
Beispiel #9
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        self.siJuegaHumano = True  # necesario para el check
        jg = self.checkMueveHumano(desde, hasta, coronacion)
        if not jg:
            return False

        self.partida.ultPosicion = jg.posicion
        self.partida.append_jg(jg)
        if self.siAyuda:
            self.tablero.quitaFlechas()
        self.movimientosPiezas(jg.liMovs, False)
        if self.siTerminada():
            self.siguienteMate()
            return

        self.numMov += 1
        if self.numMov == self.mate:
            self.repiteMate(True, True)
            return

        # Juega rival con depth 3
        rm = self.xrival.juega()
        desde = rm.desde
        hasta = rm.hasta
        coronacion = rm.coronacion

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        self.partida.ultPosicion = jg.posicion
        self.partida.append_jg(jg)
        self.ponFlechaSC(jg.desde, jg.hasta)
        self.movimientosPiezas(jg.liMovs, False)
        if self.siTerminada():
            self.repiteMate(True, True)
            return
        self.activaColor(True)  # Caso en que hay coronacion, sino no se activa la dama
Beispiel #10
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        if self.siJuegaHumano:
            self.paraHumano()
        else:
            self.sigueHumano()
            return False

        movimiento = desde + hasta

        # 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
        if coronacion:
            movimiento += coronacion

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

        if siBien:
            self.movimientosPiezas(jg.liMovs)
            self.masJugada(jg, True)
            self.error = ""
            self.siguienteJugada()
            return True
        else:
            self.sigueHumano()
            self.error = mens
            return False
Beispiel #11
0
 def mueveRival(self, desde, hasta, coronacion):
     siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                          hasta, coronacion)
     self.partida.ultPosicion = jg.posicion
     self.masJugada(jg, False)
     self.movimientosPiezas(jg.liMovs, True)
     self.error = ""
    def mueveRival(self, respMotor):
        desde = respMotor.desde
        hasta = respMotor.hasta

        coronacion = respMotor.coronacion

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion

            if self.siApertura or not self.siTutorActivado:
                self.siAnalizadoTutor = False
            else:
                self.analizaTutor(
                )  # Que analice antes de activar humano, para que no tenga que esperar
                self.siAnalizadoTutor = True
            self.error = ""
            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            return True
        else:
            self.error = mens
            return False
Beispiel #13
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        if not coronacion and self.partida.ultPosicion.siPeonCoronando(desde, hasta):
            coronacion = self.tablero.peonCoronando(self.partida.ultPosicion.siBlancas)
            if coronacion is None:
                return False

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

        if siBien:
            self.partida.liJugadas.append(jg)
            self.partida.ultPosicion = jg.posicion
            if self.partida.siTerminada():
                jg.siJaqueMate = jg.siJaque
                jg.siAhogado = not jg.siJaque
            resp = self.partida.si3repetidas()
            if resp:
                jg.siTablasRepeticion = True
            elif self.partida.ultPosicion.movPeonCap >= 100:
                jg.siTablas50 = True
            elif self.partida.ultPosicion.siFaltaMaterial():
                jg.siTablasFaltaMaterial = True
            self.tablero.ponPosicion(jg.posicion)
            self.tablero.ponFlechaSC(jg.desde, jg.hasta)

            self.siguienteJugada()
            return True
        else:
            return False
    def juegaRival(self):
        self.pensando(True)
        self.desactivaTodas()

        desde = hasta = coronacion = ""
        siEncontrada = False

        if self.apertura:
            siEncontrada, desde, hasta, coronacion = self.apertura.juegaMotor(self.fenUltimo())
            if not siEncontrada:
                self.apertura = None

        if siEncontrada:
            self.rmRival = XMotorRespuesta.RespuestaMotor("Apertura", self.siRivalConBlancas)
            self.rmRival.desde = desde
            self.rmRival.hasta = hasta
            self.rmRival.coronacion = coronacion

        else:
            self.rmRival = self.xrival.juegaTiempo(self.tmRival, self.tmRival, 0)

        self.pensando(False)

        siBien, self.error, jg = Jugada.dameJugada(self.partida.ultPosicion, self.rmRival.desde, self.rmRival.hasta, self.rmRival.coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)
            return True
        else:
            return False
Beispiel #15
0
    def mueveRival(self, desde, hasta, coronacion):

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion
            if not self.siTutorActivado:
                self.siAnalizadoTutor = False
            else:

                fenM2 = self.partida.ultPosicion.fenM2()
                if not (fenM2 in self.dicDirigidoFenM2):
                    self.analizaTutor(
                    )  # Que analice antes de activar humano, para que no tenga que esperar
                    self.siAnalizadoTutor = True

            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            self.error = ""

            return True
        else:
            self.error = mens
            return False
Beispiel #16
0
    def juegaRival(self):
        if self.is_opening:
            pv = self.liPVopening[self.posOpening]
            self.posOpening += 1
            if self.posOpening == len(self.liPVopening):
                self.is_opening = False
        else:
            fen = self.partida.ultPosicion.fen()
            pv = None
            if self.book:
                pv = self.book.eligeJugadaTipo(fen, "au")
                if not pv:
                    self.book = None
            if not pv:
                if self.partida.ultPosicion.totalPiezas() <= 4:
                    t4 = LibChess.T4()
                    pv = t4.best_move(fen)
                    t4.close()
                if not pv:
                    pv = self.engine.play(fen)

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, pv[:2],
                                             pv[2:4], pv[4:])
        self.masJugada(jg, False)
        self.movimientosPiezas(jg.liMovs, True)
        self.siguienteJugada()
Beispiel #17
0
    def siguienteJugada(self):
        if self.estado == kFinJuego:
            return False

        self.estado = kJugando

        siBlancas = self.partida.siBlancas()
        self.colorJugando = siBlancas

        if self.compruebaFinal():
            return False

        self.ponIndicador(siBlancas)
        self.refresh()

        self.relojStart(siBlancas)

        siEncontrada = False
        analisis = None
        bk = self.book[siBlancas]
        if bk:
            siEncontrada, desde, hasta, coronacion = self.eligeJugadaBook(
                bk, self.bookRR[siBlancas])
            if not siEncontrada:
                self.book[siBlancas] = None

        if not siEncontrada:
            xrival = self.xmotor[siBlancas]
            tiempoBlancas = self.tiempo[True].tiempoPendiente
            tiempoNegras = self.tiempo[False].tiempoPendiente
            segundosJugada = xrival.motorTiempoJugada
            if self.siTerminar:
                return False
            mrm = xrival.juegaTiempoTorneo(tiempoBlancas, tiempoNegras,
                                           segundosJugada)
            if mrm is None:
                return False
            rm = mrm.mejorMov()
            desde = rm.desde
            hasta = rm.hasta
            coronacion = rm.coronacion
            analisis = mrm, 0

        self.relojStop(siBlancas)
        if self.siTerminar:
            return False

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)
        if not jg:
            return False
        if analisis:
            jg.analisis = analisis
            jg.critica = ""
        self.masJugada(jg)
        self.movimientosPiezas(jg.liMovs, True)

        return not self.siTerminar
Beispiel #18
0
    def mueveRival(self):
        si_obligatorio = self.partida.numJugadas() <= self.plies_mandatory
        si_pensar = True
        fenM2 = self.partida.ultPosicion.fenM2()
        moves = self.dicFENm2.get(fenM2, set())
        if si_obligatorio:
            nmoves = len(moves)
            if nmoves == 0:
                si_obligatorio = False
            else:
                move = self.dbop.get_cache_engines(self.keyengine, self.time,
                                                   fenM2)
                if move is None:
                    if self.book:
                        move_book = self.book.eligeJugadaTipo(
                            self.partida.ultPosicion.fen(), "au")
                        if move_book in list(moves):
                            move = move_book
                    if move is None:
                        move = random.choice(list(moves))
                    self.dbop.set_cache_engines(self.keyengine, self.time,
                                                fenM2, move)
                desde, hasta, coronacion = move[:2], move[2:4], move[4:]
                si_pensar = False

        if si_pensar:
            move = None
            if self.book:
                move = self.book.eligeJugadaTipo(
                    self.partida.ultPosicion.fen(), "mp")
            if move is None:
                move = self.dbop.get_cache_engines(self.keyengine, self.time,
                                                   fenM2)
            if move is None:
                rmRival = self.xrival.juegaPartida(self.partida)
                move = rmRival.movimiento()
                self.dbop.set_cache_engines(self.keyengine, self.time, fenM2,
                                            move)
            desde, hasta, coronacion = move[:2], move[2:4], move[4:]
            if si_obligatorio:
                if move not in moves:
                    move = list(moves)[0]
                    desde, hasta, coronacion = move[:2], move[2:4], move[4:]

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion

            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            self.error = ""

            return True
        else:
            self.error = mens
            return False
Beispiel #19
0
    def mueveHumano(self, desde, hasta, coronacion=None):

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

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)
        if not siBien:
            return False

        self.partida.ultPosicion = jg.posicion
        self.partida.liJugadas.append(jg)
        if self.siAyuda:
            self.tablero.quitaFlechas()
        self.movimientosPiezas(jg.liMovs, False)
        if self.siTerminada():
            self.siguienteMate()
            return

        self.numMov += 1
        if self.numMov == self.mate:
            self.repiteMate(True, True)
            return

        # Juega rival con depth 3
        rm = self.xrival.juega()
        desde = rm.desde
        hasta = rm.hasta
        coronacion = rm.coronacion

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)
        self.partida.ultPosicion = jg.posicion
        self.partida.liJugadas.append(jg)
        self.ponFlechaSC(jg.desde, jg.hasta)
        self.movimientosPiezas(jg.liMovs, False)
        if self.siTerminada():
            self.repiteMate(True, True)
            return
        self.activaColor(
            True)  # Caso en que hay coronacion, sino no se activa la dama
Beispiel #20
0
 def juegaRival(self):
     if not self.siTerminada():
         self.pensando(True)
         rm = self.xrival.juega(nAjustado=self.xrival.nAjustarFuerza)
         if rm.desde:
             siBien, self.error, jg = Jugada.dameJugada(self.partida.ultPosicion, rm.desde, rm.hasta, rm.coronacion)
             self.masJugada(jg)
             self.movimientosPiezas(jg.liMovs)
             self.partida.ultPosicion = jg.posicion
         self.pensando(False)
Beispiel #21
0
    def siguienteJugada(self):
        if self.estado == kFinJuego:
            return False

        self.estado = kJugando

        siBlancas = self.partida.siBlancas()
        self.colorJugando = siBlancas

        if self.compruebaFinal():
            return False

        self.ponIndicador(siBlancas)
        self.refresh()

        self.relojStart(siBlancas)

        siEncontrada = False
        analisis = None
        bk = self.book[siBlancas]
        if bk:
            siEncontrada, desde, hasta, coronacion = self.eligeJugadaBook(bk, self.bookRR[siBlancas])
            if not siEncontrada:
                self.book[siBlancas] = None

        if not siEncontrada:
            xrival = self.xmotor[siBlancas]
            tiempoBlancas = self.tiempo[True].tiempoPendiente
            tiempoNegras = self.tiempo[False].tiempoPendiente
            segundosJugada = xrival.motorTiempoJugada
            if self.siTerminar:
                return False
            mrm = xrival.juegaTiempoTorneo(tiempoBlancas, tiempoNegras, segundosJugada)
            if mrm is None:
                return False
            rm = mrm.mejorMov()
            desde = rm.desde
            hasta = rm.hasta
            coronacion = rm.coronacion
            analisis = mrm, 0

        self.relojStop(siBlancas)
        if self.siTerminar:
            return False

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if not jg:
            return False
        if analisis:
            jg.analisis = analisis
            jg.critica = ""
        self.masJugada(jg)
        self.movimientosPiezas(jg.liMovs, True)

        return not self.siTerminar
    def juegaRival(self):
        self.pensando(True)
        self.desactivaTodas()

        self.relojStart(False)

        desde = hasta = coronacion = ""
        siEncontrada = False

        if self.aperturaStd:
            siEncontrada, desde, hasta, coronacion = self.aperturaStd.juegaMotor(
                self.fenUltimo())
            if not siEncontrada:
                self.aperturaStd = None

        if siEncontrada:
            self.rmRival = XMotorRespuesta.RespuestaMotor(
                "Apertura", self.siRivalConBlancas)
            self.rmRival.desde = desde
            self.rmRival.hasta = hasta
            self.rmRival.coronacion = coronacion

        else:
            self.timekeeper.start()
            if self.siTiempo:
                tiempoBlancas = self.tiempo[True].tiempoPendiente
                tiempoNegras = self.tiempo[False].tiempoPendiente

                self.rmRival = self.xrival.juegaTiempo(tiempoBlancas,
                                                       tiempoNegras,
                                                       self.segundosJugada)
                if self.estado == kFinJuego:
                    return True

            else:
                self.rmRival = self.xrival.juega()
            self.setSummary("TIMERIVAL", self.timekeeper.stop())

        self.relojStop(False)
        self.pensando(False)

        self.liRMrival.append(self.rmRival)

        siBien, self.error, jg = Jugada.dameJugada(self.partida.ultPosicion,
                                                   self.rmRival.desde,
                                                   self.rmRival.hasta,
                                                   self.rmRival.coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)
            return True
        else:
            return False
    def mueveHumano(self, desde, hasta, coronacion=None):
        jg = self.checkMueveHumano(desde, hasta, coronacion)
        if not jg:
            return False
        siMirarTutor = self.siTutorActivado
        movimiento = jg.movimiento()
        coronacion = jg.coronacion

        if self.siApertura:
            if self.apertura.compruebaHumano(self.fenUltimo(), desde, hasta):
                siMirarTutor = False

        if siMirarTutor:
            if not self.siAnalizadoTutor:
                self.analizaTutor()
                self.siAnalizadoTutor = True
            if self.mrmTutor is None:
                self.sigueHumano()
                return False
            if self.mrmTutor.mejorMovQue(movimiento):
                self.refresh()
                if not jg.siJaqueMate:
                    tutor = Tutor.Tutor(self, self, jg, desde, hasta, False)

                    if self.siApertura:
                        liApPosibles = self.listaAperturasStd.listaAperturasPosibles(
                            self.partida)
                    else:
                        liApPosibles = None

                    if tutor.elegir(self.ayudas > 0,
                                    liApPosibles=liApPosibles):
                        if self.ayudas > 0:  # doble entrada a tutor.
                            self.reponPieza(desde)
                            self.ayudas -= 1
                            desde = tutor.desde
                            hasta = tutor.hasta
                            coronacion = tutor.coronacion
                            siBien, mens, jgTutor = Jugada.dameJugada(
                                self.partida.ultPosicion, desde, hasta,
                                coronacion)
                            if siBien:
                                jg = jgTutor
                    elif self.configuracion.guardarVariantesTutor:
                        tutor.ponVariantes(jg,
                                           1 + self.partida.numJugadas() / 2)

                    del tutor

        self.movimientosPiezas(jg.liMovs)
        self.partida.ultPosicion = jg.posicion
        self.masJugada(jg, True)
        self.siguienteJugada()
        return True
Beispiel #24
0
    def mueveHumano(self, desde, hasta, coronacion=None):

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

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if not siBien:
            return False

        self.partida.ultPosicion = jg.posicion
        self.partida.liJugadas.append(jg)
        if self.siAyuda:
            self.tablero.quitaFlechas()
        self.movimientosPiezas(jg.liMovs, False)
        if self.siTerminada():
            self.siguienteMate()
            return

        self.numMov += 1
        if self.numMov == self.mate:
            self.repiteMate(True, True)
            return

        # Juega rival con depth 3
        rm = self.xrival.juega()
        desde = rm.desde
        hasta = rm.hasta
        coronacion = rm.coronacion

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        self.partida.ultPosicion = jg.posicion
        self.partida.liJugadas.append(jg)
        self.ponFlechaSC(jg.desde, jg.hasta)
        self.movimientosPiezas(jg.liMovs, False)
        if self.siTerminada():
            self.repiteMate(True, True)
            return
        self.activaColor(True)  # Caso en que hay coronacion, sino no se activa la dama
Beispiel #25
0
    def pgnInformacion(self):
        posJugada, jg = self.jugadaActiva()
        if jg:
            fen = jg.posicionBase.fen()
            lista = self.libro.miraListaJugadas(fen)

            siEditar = True
            if len(lista) > 0:
                resp = PantallaBooks.saltaJugadaBooks(self, lista, jg)
                if resp is None:
                    return
                siEditar = resp[0] is None
            if siEditar:
                Gestor.Gestor.pgnInformacion(self)
            else:
                # Eliminamos todas las jugadas desde esta hasta el final
                numpos = jg.numpos
                self.partida.liJugadas = self.partida.liJugadas[:numpos]
                if self.partida.numJugadas() == 0:
                    self.aciertos = 0
                    self.movimientos = 0
                    self.partida.ultPosicion = self.partida.iniPosicion
                else:
                    jg = self.partida.last_jg()
                    self.aciertos = jg.aciertos
                    self.movimientos = jg.movimientos
                    self.partida.ultPosicion = jg.posicion
                self.ponRotulo2(self.txtAciertos())
                self.partida.pendienteApertura = True

                # realizamos el movimiento
                desde, hasta, coronacion = resp
                siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion,
                                                     desde, hasta, coronacion)
                self.movimientosPiezas(jg.liMovs, False)
                self.partida.ultPosicion = jg.posicion
                self.tablero.ponPosicion(jg.posicion)
                self.pantalla.base.pgnRefresh()
                self.ponRevision(False)

                self.listaJugadas = lista

                self.ponVariantes(jg)

                self.masJugada(jg, True)

                # refrescamos
                self.refresh()

                # siguienteJugada
                self.estado = kJugando
                self.siguienteJugada()
Beispiel #26
0
    def mueveHumano(self, desde, hasta, coronacion=""):
        if self.cpActual.siPeonCoronando(desde, hasta):
            coronacion = self.tablero.peonCoronando(self.cpActual.siBlancas)
            if coronacion is None:
                return
        else:
            coronacion = ""

        siBien, mens, jg = Jugada.dameJugada(self.cpActual, desde, hasta, coronacion)

        if siBien:
            pv = desde + hasta + coronacion
            self.winBookGuide.seleccionaPV(pv)
Beispiel #27
0
    def pgnInformacion(self, fila, clave):
        posJugada, jg = self.pgn.jugada(fila, clave)
        if jg:
            fen = jg.posicionBase.fen()
            lista = self.libro.miraListaJugadas(fen)

            siEditar = True
            if len(lista) > 0:
                resp = PantallaBooks.saltaJugadaBooks(self, lista, jg)
                if resp is None:
                    return
                siEditar = resp[0] is None
            if siEditar:
                Gestor.Gestor.pgnInformacion(self, fila, clave)
            else:
                # Eliminamos todas las jugadas desde esta hasta el final
                numpos = jg.numpos
                self.partida.liJugadas = self.partida.liJugadas[:numpos]
                if self.partida.numJugadas() == 0:
                    self.aciertos = 0
                    self.movimientos = 0
                    self.partida.ultPosicion = self.partida.iniPosicion
                else:
                    jg = self.partida.liJugadas[-1]
                    self.aciertos = jg.aciertos
                    self.movimientos = jg.movimientos
                    self.partida.ultPosicion = jg.posicion
                self.ponRotulo2(self.txtAciertos())
                self.partida.pendienteApertura = True

                # realizamos el movimiento
                desde, hasta, coronacion = resp
                siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
                self.movimientosPiezas(jg.liMovs, False)
                self.partida.ultPosicion = jg.posicion
                self.tablero.ponPosicion(jg.posicion)
                self.pantalla.base.pgnRefresh()
                self.ponRevision(False)

                self.listaJugadas = lista

                self.ponVariantes(jg)

                self.masJugada(jg, True)

                # refrescamos
                self.refresh()

                # siguienteJugada
                self.estado = kJugando
                self.siguienteJugada()
Beispiel #28
0
    def mueveRival(self, desde, hasta, coronacion):
        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion

            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            self.error = ""

            return True
        else:
            self.error = mens
            return False
Beispiel #29
0
    def mueveHumano(self, desde, hasta):

        if self.cpActual.siPeonCoronando(desde, hasta):
            coronacion = self.tablero.peonCoronando(self.cpActual.siBlancas)
            if coronacion is None:
                return
        else:
            coronacion = ""

        siBien, mens, jg = Jugada.dameJugada(self.cpActual, desde, hasta, coronacion)

        if siBien:
            pv = desde + hasta + coronacion
            self.winBookGuide.seleccionaPV(pv)
Beispiel #30
0
    def mueveHumano(self, desde, hasta, coronacion=None):

        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, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)

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

        siEncontrado = False
        if coronacion is None:
            coronacion = ""
        for pv, jdesde, jhasta, jcoronacion, jpgn in self.listaJugadas:
            if desde == jdesde and hasta == jhasta and coronacion == jcoronacion:
                siEncontrado = True
                break

        if not siEncontrado:
            self.menuAyuda()
            self.sigueHumano()
            return False

        self.ultPV = desde + hasta + coronacion
        self.ponRotulo2(self.txtAciertos())

        self.movimientosPiezas(jg.liMovs)

        self.partida.ultPosicion = jg.posicion
        self.masJugada(jg, True)
        self.error = ""
        self.siguienteJugada()
        return True
Beispiel #31
0
 def dameJugadasTXT(self, posicionBase, siGM):
     li = []
     dRepeticiones = {}
     for gmPartida in self.liGMPartidas:
         move = gmPartida.move(self.ply)
         if move:
             if move not in dRepeticiones:
                 dRepeticiones[move] = [len(li), 1]
                 desde, hasta, coronacion = move[:2], move[2:4], move[4:]
                 siBien, mens, jg = Jugada.dameJugada(posicionBase, desde, hasta, coronacion)
                 li.append([desde, hasta, coronacion, gmPartida.rotuloBasico(siGM), jg.pgnSP()])
             else:
                 dRepeticiones[move][1] += 1
                 pos = dRepeticiones[move][0]
                 li[pos][3] = _("%d games") % dRepeticiones[move][1]
     return li
Beispiel #32
0
 def dameJugadasTXT(self, posicionBase, siGM):
     li = []
     dRepeticiones = {}
     for gmPartida in self.liGMPartidas:
         move = gmPartida.move(self.ply)
         if move:
             if move not in dRepeticiones:
                 dRepeticiones[move] = [len(li), 1]
                 desde, hasta, coronacion = move[:2], move[2:4], move[4:]
                 siBien, mens, jg = Jugada.dameJugada(posicionBase, desde, hasta, coronacion)
                 li.append([desde, hasta, coronacion, gmPartida.rotuloBasico(siGM), jg.pgnSP()])
             else:
                 dRepeticiones[move][1] += 1
                 pos = dRepeticiones[move][0]
                 li[pos][3] = _("%d games") % dRepeticiones[move][1]
     return li
Beispiel #33
0
    def ayuda(self):
        if self.siJuegaHumano:
            self.paraHumano()
        else:
            return
        self.tablero.ponPosicion(self.partida.ultPosicion)

        main = self.listaJugadas[0][4]
        saux = False
        paux = 0

        for n, jug in enumerate(self.listaJugadas):
            opacity = p = jug[4]
            simain = p == main
            if not simain:
                if not saux:
                    paux = p
                    saux = True
                opacity = 1.0 if p == paux else max(p, 0.25)
            self.tablero.creaFlechaMulti(jug[0] + jug[1],
                                         siMain=simain,
                                         opacidad=opacity)

        resp = PantallaBooks.eligeJugadaBooks(self.pantalla,
                                              self.listaJugadas,
                                              self.siJugamosConBlancas,
                                              siSelectSiempre=False)
        self.tablero.quitaFlechas()
        if resp is None:
            self.sumar_aciertos = False
            self.sigueHumano()
            return

        desde, hasta, coronacion = resp
        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)
        self.movimientos += 1

        self.ponRotulo2(self.txtAciertos())

        self.movimientosPiezas(jg.liMovs)

        self.partida.ultPosicion = jg.posicion
        self.masJugada(jg, True)
        self.error = ""
        self.sumar_aciertos = True
        self.siguienteJugada()
Beispiel #34
0
    def mueveRival(self, move):
        desde = move[:2]
        hasta = move[2:4]
        coronacion = move[4:]

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion
            self.error = ""

            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            return True
        else:
            self.error = mens
            return False
    def mueveHumano(self, desde, hasta, coronacion=""):
        cpActual = self.partida.jugada(self.posJugada).posicion if self.posJugada >= 0 else self.partida.iniPosicion
        if cpActual.siPeonCoronando(desde, hasta):
            coronacion = self.tablero.peonCoronando(cpActual.siBlancas)
            if coronacion is None:
                return

        siBien, mens, jg = Jugada.dameJugada(cpActual, desde, hasta, coronacion)

        if siBien:
            partida = Partida.Partida()
            partida.leeOtra(self.partida)

            if self.posJugada < self.partida.numJugadas()-1:
                partida.liJugadas = partida.liJugadas[:self.posJugada+1]
            partida.append_jg(jg)
            self.panelOpening.mueveHumano(partida)
Beispiel #36
0
    def mueveHumano(self, desde, hasta, coronacion=None):

        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, jg = Jugada.dameJugada(self.partida.ultPosicion, desde,
                                             hasta, coronacion)

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

        if siBien:

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

            if self.siApertura:
                self.siApertura = self.apertura.compruebaHumano(
                    self.fenUltimo(), desde, hasta)

            self.movimientosPiezas(jg.liMovs)

            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg, True)
            self.error = ""
            self.siguienteJugada()
            return True
        else:
            self.sigueHumano()
            self.error = mens
            return False
Beispiel #37
0
    def mueveHumano(self, desde, hasta, coronacion=None):

        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, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)

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

        siEncontrado = False
        if coronacion is None:
            coronacion = ""
        for pv, jdesde, jhasta, jcoronacion, jpgn in self.listaJugadas:
            if desde == jdesde and hasta == jhasta and coronacion == jcoronacion:
                siEncontrado = True
                break

        if not siEncontrado:
            self.menuAyuda()
            self.sigueHumano()
            return False

        self.ultPV = desde + hasta + coronacion
        self.ponRotulo2(self.txtAciertos())

        self.movimientosPiezas(jg.liMovs)

        self.partida.ultPosicion = jg.posicion
        self.masJugada(jg, True)
        self.error = ""
        self.siguienteJugada()
        return True
Beispiel #38
0
    def mueveHumano(self, desde, hasta, coronacion=None):

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

        siBien, mens, jgNueva = Jugada.dameJugada(self.posicionBase, desde, hasta, coronacion)

        if siBien:

            self.movimientosPiezas(jgNueva.liMovs)
            self.w.tablero.ponFlechaSC(jgNueva.desde, jgNueva.hasta)
            self.analizaJugada(jgNueva)
            return True
        else:
            return False
Beispiel #39
0
    def mueveRival(self, respMotor):
        desde = respMotor.desde
        hasta = respMotor.hasta

        coronacion = respMotor.coronacion

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion

            self.error = ""
            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            return True
        else:
            self.error = mens
            return False
Beispiel #40
0
    def mueveHumano(self, desde, hasta, coronacion=None):

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

        siBien, mens, jgNueva = Jugada.dameJugada(self.posicionBase, desde, hasta, coronacion)

        if siBien:

            self.movimientosPiezas(jgNueva.liMovs)
            self.w.tablero.ponFlechaSC(jgNueva.desde, jgNueva.hasta)
            self.analizaJugada(jgNueva)
            return True
        else:
            return False
Beispiel #41
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        self.tablero.desactivaTodas()

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

        siBien, mens, jg = Jugada.dameJugada(self.posicion, desde, hasta, coronacion)
        if siBien:
            self.tablero.ponPosicion(jg.posicion)
            self.tablero.ponFlechaSC(desde, hasta)
            self.hechaJugada(jg)
        else:
            self.ponJuego()
            return False
        return True
Beispiel #42
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        self.tablero.desactivaTodas()

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

        siBien, mens, jg = Jugada.dameJugada(self.posicion, desde, hasta, coronacion)
        if siBien:
            self.tablero.ponPosicion(jg.posicion)
            self.tablero.ponFlechaSC(desde, hasta)
            self.hechaJugada(jg)
        else:
            self.ponJuego()
            return False
        return True
Beispiel #43
0
    def mueveRival(self, respMotor):
        desde = respMotor.desde
        hasta = respMotor.hasta

        coronacion = respMotor.coronacion

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion
            self.ponVariantes(jg)

            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            self.error = ""

            return True
        else:
            self.error = mens
            return False
Beispiel #44
0
    def mueveHumano(self, desde, hasta, coronacion=None):

        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, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)

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

        if siBien:

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

            if self.siApertura:
                self.siApertura = self.apertura.compruebaHumano(self.fenUltimo(), desde, hasta)

            self.movimientosPiezas(jg.liMovs)

            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg, True)
            self.error = ""
            self.siguienteJugada()
            return True
        else:
            self.sigueHumano()
            self.error = mens
            return False
    def mueveHumano(self, desde, hasta, coronacion=None):
        self.paraHumano()

        movimiento = desde + hasta

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

        siBien, mens, self.jg = Jugada.dameJugada(self.posicion, desde, hasta, coronacion)
        if siBien:
            self.tablero.ponPosicion(self.jg.posicion)
            self.tablero.ponFlechaSC(desde, hasta)
            self.calculaTiempoPuntos()
        else:
            self.sigueHumano()
Beispiel #46
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        self.tablero.desactivaTodas()

        movimiento = desde + hasta

        posicion = self.partida.jugada(self.posCurrent).posicion if self.posCurrent >= 0 else self.partida.ultPosicion

        # 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, jg = Jugada.dameJugada(posicion, desde, hasta, coronacion)
        if siBien:
            self.nuevaJugada(jg)
        else:
            self.actualizaPosicion()
Beispiel #47
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        self.tablero.desactivaTodas()

        movimiento = desde + hasta

        posicion = self.partida.jugada(self.posCurrent).posicion if self.posCurrent >= 0 else self.partida.ultPosicion

        # 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, jg = Jugada.dameJugada(posicion, desde, hasta, coronacion)
        if siBien:
            self.nuevaJugada(jg)
        else:
            self.actualizaPosicion()
Beispiel #48
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        self.paraHumano()

        movimiento = desde + hasta

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

        siBien, mens, self.jg = Jugada.dameJugada(self.posicion, desde, hasta, coronacion)
        if siBien:
            self.tablero.ponPosicion(self.jg.posicion)
            self.tablero.ponFlechaSC(desde, hasta)
            self.calculaTiempoPuntos()
        else:
            self.sigueHumano()
Beispiel #49
0
    def mueveRival(self, respMotor):
        desde = respMotor.desde
        hasta = respMotor.hasta

        coronacion = respMotor.coronacion

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if siBien:
            self.partida.ultPosicion = jg.posicion

            if self.siApertura or not self.siTutorActivado:
                self.siAnalizadoTutor = False
            else:
                self.analizaTutor()  # Que analice antes de activar humano, para que no tenga que esperar
                self.siAnalizadoTutor = True
            self.error = ""
            self.masJugada(jg, False)
            self.movimientosPiezas(jg.liMovs, True)

            return True
        else:
            self.error = mens
            return False
Beispiel #50
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
Beispiel #51
0
    def mueveHumano(self, desde, hasta, coronacion=None):

        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, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)

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

        siEncontrado = False
        actpeso = 0
        if coronacion is None:
            coronacion = ""
        for jdesde, jhasta, jcoronacion, jpgn, peso in self.listaJugadas:
            if desde == jdesde and hasta == jhasta and coronacion == jcoronacion:
                siEncontrado = True
                actpeso = peso
                break

        if siEncontrado and self.jugJugador:  # si el jugador busca elegir el maximo
            maxpeso = 0.0
            for jdesde, jhasta, jcoronacion, jpgn, peso in self.listaJugadas:
                if peso > maxpeso:
                    maxpeso = peso
            if actpeso < maxpeso:
                siEncontrado = False

        if not siEncontrado:
            self.tablero.ponPosicion(self.partida.ultPosicion)
            self.tablero.activaColor(self.siJugamosConBlancas)
            resp = PantallaBooks.eligeJugadaBooks(self.pantalla, self.listaJugadas, self.siJugamosConBlancas)
            if resp is None:
                resp = self.listaJugadas[0][:3]

            desde, hasta, coronacion = resp

            siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        else:
            self.aciertos += actpeso
        self.movimientos += 1

        self.ponRotulo2(self.txtAciertos())

        self.movimientosPiezas(jg.liMovs)

        self.partida.ultPosicion = jg.posicion
        self.masJugada(jg, True)
        self.error = ""
        self.siguienteJugada()
        return True
Beispiel #52
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        if self.siJuegaHumano:
            self.paraHumano()
        else:
            self.sigueHumano()
            return False

        movimiento = desde + hasta

        # 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
        if coronacion:
            movimiento += coronacion

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

        siAnalisis = False

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

        if siBien:
            siElegido = False

            if self.book and self.bookMandatory:
                fen = self.fenUltimo()
                listaJugadas = self.book.miraListaJugadas(fen)
                if listaJugadas:
                    li = []
                    for apdesde, aphasta, apcoronacion, nada, nada1 in listaJugadas:
                        mx = apdesde + aphasta + apcoronacion
                        if mx.strip().lower() == movimiento:
                            siElegido = True
                            break
                        li.append((apdesde, aphasta, False))
                    if not siElegido:
                        self.tablero.ponFlechasTmp(li)
                        self.sigueHumano()
                        return False

            if not siElegido and self.siApertura:
                fenBase = self.fenUltimo()
                if self.siAperturaStd:
                    if self.apertura.compruebaHumano(fenBase, desde, hasta):
                        siElegido = True
                    else:
                        if self.apertura.activa:
                            apdesde, aphasta = self.apertura.desdeHastaActual(fenBase)

                            self.tablero.ponFlechasTmp(((apdesde, aphasta, False),))
                            self.sigueHumano()
                            return False
                if not siElegido and self.apertura and self.apertura.compruebaHumano(fenBase, desde, hasta):
                    siElegido = True

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

            if not siElegido and self.siTutorActivado:
                self.analizaTutorFinal()
                rmUser, n = self.mrmTutor.buscaRM(movimiento)
                if not rmUser:
                    rmUser = self.xtutor.valora(self.partida.ultPosicion, desde, hasta, coronacion)
                    if not rmUser:
                        return False
                    self.mrmTutor.agregaRM(rmUser)
                siAnalisis = True
                pointsBest, pointsUser = self.mrmTutor.difPointsBest(movimiento)
                self.setSummary("POINTSBEST", pointsBest)
                self.setSummary("POINTSUSER", pointsUser)
                if (pointsBest-pointsUser)>0:
                    if not jg.siJaqueMate:
                        siTutor = True
                        if self.chance:
                            num = self.mrmTutor.numMejorMovQue(movimiento)
                            if num:
                                rmTutor = self.mrmTutor.rmBest()
                                rmUser, n = self.mrmTutor.buscaRM(movimiento)
                                menu = QTVarios.LCMenu(self.pantalla)
                                submenu = menu.submenu(_("There are %d best moves") % num, Iconos.Motor())
                                submenu.opcion("tutor", "%s (%s)" % (_("Show tutor"), rmTutor.abrTextoBase()), Iconos.Tutor())
                                submenu.separador()
                                submenu.opcion("try", _("Try again"), Iconos.Atras())
                                submenu.separador()
                                submenu.opcion("user", "%s (%s)" % (_("Select my move"), rmUser.abrTextoBase()),
                                               Iconos.Player())
                                self.pantalla.cursorFueraTablero()
                                resp = menu.lanza()
                                if resp == "try":
                                    self.sigueHumano()
                                    return False
                                elif resp == "user":
                                    siTutor = False
                                elif resp != "tutor":
                                    self.sigueHumano()
                                    return False
                        if siTutor:
                            tutor = Tutor.Tutor(self, self, jg, desde, hasta, False)

                            if self.siApertura:
                                liApPosibles = self.listaAperturasStd.listaAperturasPosibles(self.partida)
                            else:
                                liApPosibles = None

                            if tutor.elegir(self.ayudas > 0, liApPosibles=liApPosibles):
                                if self.ayudas > 0:  # doble entrada a tutor.
                                    self.reponPieza(desde)
                                    self.ayudas -= 1
                                    desde = tutor.desde
                                    hasta = tutor.hasta
                                    coronacion = tutor.coronacion
                                    siBien, mens, jgTutor = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta,
                                                                              coronacion)
                                    if siBien:
                                        jg = jgTutor
                                        self.setSummary("SELECTTUTOR", True)
                            if self.configuracion.guardarVariantesTutor:
                                tutor.ponVariantes(jg, 1 + self.partida.numJugadas() / 2)

                            del tutor

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

            self.setSummary( "TIMEUSER", self.timekeeper.stop() )
            self.relojStop(True)

            if self.siApertura and self.siAperturaStd:
                self.siApertura = self.apertura.activa

            self.movimientosPiezas(jg.liMovs)

            if siAnalisis:
                rm, nPos = self.mrmTutor.buscaRM(jg.movimiento())
                if rm:
                    jg.analisis = self.mrmTutor, nPos

            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg, True)
            self.error = ""
            self.siguienteJugada()
            return True
        else:
            self.error = mens
            self.sigueHumano()
            return False
Beispiel #53
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        if self.siJuegaHumano:
            self.paraHumano()
        else:
            self.sigueHumano()
            return False

        movimiento = desde + hasta

        # 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
        if coronacion:
            movimiento += coronacion

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

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

        if siBien:
            siMirarTutor = self.siTutorActivado

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

            if siMirarTutor:
                fen = self.partida.ultPosicion.fen()
                if self.siDirigido and (fen in self.dicDirigidoFen):
                    liOpciones = self.dicDirigidoFen[fen]
                    if len(liOpciones) > 1:
                        self.guardaVariantes()
                    liMovs = []
                    siEsta = False
                    posMain = None
                    for siMain, jg1 in liOpciones:
                        mv = jg1.movimiento()
                        if siMain:
                            posMain = mv[:2]

                        if mv.lower() == movimiento.lower():
                            if self.siDirigidoVariantes:
                                siEsta = True
                            else:
                                siEsta = siMain
                            if siEsta:
                                break
                        liMovs.append((jg1.desde, jg1.hasta, siMain))

                    if not siEsta:
                        self.ponPosicion(self.partida.ultPosicion)
                        if posMain and posMain != movimiento[:2]:
                            self.tablero.markPosition(posMain)
                        else:
                            self.tablero.ponFlechasTmp(liMovs)
                        self.sigueHumano()
                        return False

                else:
                    if not self.siAnalizadoTutor:
                        self.analizaTutor()
                    if self.mrmTutor.mejorMovQue(movimiento):
                        if not jg.siJaqueMate:
                            tutor = Tutor.Tutor(self, self, jg, desde, hasta, False)

                            if tutor.elegir(True):
                                self.reponPieza(desde)
                                desde = tutor.desde
                                hasta = tutor.hasta
                                coronacion = tutor.coronacion
                                siBien, mens, jgTutor = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta,
                                                                          coronacion)
                                if siBien:
                                    jg = jgTutor

                            del tutor
                self.mrmTutor = None

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

            self.movimientosPiezas(jg.liMovs)

            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg, True)
            self.error = ""

            self.siguienteJugada()
            return True
        else:
            self.sigueHumano()
            self.error = mens
            return False
Beispiel #54
0
    def mueveHumano(self, desde, hasta, coronacion=None):

        if self.siJuegaHumano:
            self.paraHumano()
        else:
            self.sigueHumano()
            return False

        movimiento = desde + hasta

        # 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
        if coronacion:
            movimiento += coronacion

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

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

        if siBien:

            siMirarTutor = self.siTutorActivado

            if self.siApertura:
                if self.apertura.compruebaHumano(self.fenUltimo(), desde, hasta):
                    siMirarTutor = False

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

            if siMirarTutor:
                if not self.siAnalizadoTutor:
                    self.analizaTutor()
                    self.siAnalizadoTutor = True
                if self.mrmTutor is None:
                    self.sigueHumano()
                    return False
                if self.mrmTutor.mejorMovQue(movimiento):
                    self.refresh()
                    if not jg.siJaqueMate:
                        tutor = Tutor.Tutor(self, self, jg, desde, hasta, False)

                        if self.siApertura:
                            liApPosibles = self.listaAperturasStd.listaAperturasPosibles(self.partida)
                        else:
                            liApPosibles = None

                        if tutor.elegir(self.ayudas > 0, liApPosibles=liApPosibles):
                            if self.ayudas > 0:  # doble entrada a tutor.
                                self.reponPieza(desde)
                                self.ayudas -= 1
                                desde = tutor.desde
                                hasta = tutor.hasta
                                coronacion = tutor.coronacion
                                siBien, mens, jgTutor = Jugada.dameJugada(
                                    self.partida.ultPosicion, desde, hasta, coronacion
                                )
                                if siBien:
                                    jg = jgTutor
                        elif self.configuracion.guardarVariantesTutor:
                            tutor.ponVariantes(jg, 1 + self.partida.numJugadas() / 2)

                        del tutor

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

            self.movimientosPiezas(jg.liMovs)

            self.partida.ultPosicion = jg.posicion
            self.masJugada(jg, True)
            self.error = ""
            self.siguienteJugada()
            return True
        else:
            self.error = mens
            self.sigueHumano()
            return False
Beispiel #55
0
    def mueveHumano(self, desde, hasta, coronacion=None):
        if desde == hasta:
            return False

        if self.siJuegaHumano:
            self.paraHumano()
        else:
            self.sigueHumano()
            return False

        movimiento = desde + hasta

        # 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
        if coronacion:
            movimiento += coronacion

        siBien, mens, jg = Jugada.dameJugada(self.partida.ultPosicion, desde, hasta, coronacion)
        if not siBien:
            self.ponPosicion(self.partida.ultPosicion)
            self.sigueHumano()
            return False

        fen = self.partida.ultPosicion.fen()
        if fen in self.dicDirigidoFen:
            liOpciones = self.dicDirigidoFen[fen]
            if len(liOpciones) > 1:
                self.guardaVariantes()
            liMovs = []
            siEsta = False
            siPenalizar = True
            posMain = None
            for siMain, jg1 in liOpciones:
                mv = jg1.movimiento()
                if siMain:
                    posMain = mv[:2]
                if mv.lower() == movimiento.lower():
                    siEsta = siMain if self.siPenalizable else True
                    siPenalizar = False
                    if siEsta:
                        break
                liMovs.append((jg1.desde, jg1.hasta, siMain))

            if not siEsta:
                self.tactica.nuevoError()
                self.ponPosicion(self.partida.ultPosicion)
                if posMain and posMain != movimiento[:2]:
                    self.tablero.markPosition(posMain)
                else:
                    self.tablero.ponFlechasTmp(liMovs)

                self.sigueHumano()
                if siPenalizar:
                    self.ponPenalizacion()
                return False

        if not self.siSeguirJugando:
            segundos = time.time() - self.iniReloj
            self.tactica.masSegundos(segundos)
        self.movimientosPiezas(jg.liMovs)

        self.partida.ultPosicion = jg.posicion
        self.masJugada(jg, True)
        self.error = ""
        self.siguienteJugada()
        return True
Beispiel #56
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