def comprobar(self):
self.paraReloj()
self.ponToolBar([self.cancelar])
for wm in self.liwm:
wm.deshabilita()
um = QTUtil2.analizando(self)
self.liAnalisis = []
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.fen)
jg = Jugada.Jugada()
siError = False
totalPuntos = 0
factor = 1
previo = 100
for wm in self.liwm:
desde, hasta, coronacion = wm.resultado()
if desde:
cpNue = cp.copia()
siBien, mensaje = cpNue.mover(desde, hasta, coronacion)
wm.siCorrecto(siBien)
if not siBien:
wm.ponError(_("Invalid move"))
siError = True
break
jg = Jugada.Jugada()
jg.ponDatos(cp, cpNue, desde, hasta, coronacion)
mrm, pos = self.xtutor.analizaJugada(jg, self.xtutor.motorTiempoJugada)
jg.analisis = mrm, pos
self.liAnalisis.append(jg)
rm = mrm.liMultiPV[pos]
rj = mrm.liMultiPV[0]
dif = rj.puntosABS() - rm.puntosABS()
if dif >= 100:
puntos = 0
else:
puntos = 100 - dif
wm.ponPuntos(puntos)
cp = cpNue
totalPuntos += int(puntos * factor * previo / 100)
previo = puntos * previo / 100
factor *= 2
else:
break
um.final()
self.btConsultar.show()
if not siError:
self.lbTiempo.ponTexto("<h2>%s: %d %s</h2>" % (_("Result"), totalPuntos, _("pts")))
self.historico.append(Util.hoy(), totalPuntos, self.xtutor.clave, int(self.xtutor.motorTiempoJugada / 1000),
self.min_min, self.min_max, self.linea, self.ref)
self.ponToolBar([self.terminar])
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
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
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 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
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):
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
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
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 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 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
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
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
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()
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
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
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
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
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 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
def recupera(self, reg):
for atr in dir(reg):
if atr.startswith("_") and not atr.startswith("__"):
if atr == "_jg":
self._jg = Jugada.Jugada()
self._jg.recuperaDeTexto(reg._jg)
else:
valor = getattr(reg, atr)
setattr(self, atr, valor)
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)
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
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
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()
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)
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()
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)
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
def recuperaDeTexto(self, txt):
li = txt.split("|")
self.iniPosicion = ControlPosicion.ControlPosicion().leeFen(li[0])
self.ultPosicion = ControlPosicion.ControlPosicion().leeFen(li[1])
nJG = int(li[2])
self.liJugadas = []
for n in range(nJG):
jg = Jugada.Jugada()
jg.recuperaDeTexto(li[n + 3])
self.liJugadas.append(jg)
if len(li) > nJG + 3:
self.firstComment = li[nJG + 3]
else:
self.firstComment = ""
self.siEmpiezaConNegras = not self.iniPosicion.siBlancas
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
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
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
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()
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)
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=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
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 leeTexto(self, texto):
game = PGNreader.read1Game(texto)
if game.erroneo:
return False
cp = ControlPosicion.ControlPosicion()
cp.leeFen(game.fen)
p = Partida.Partida(cp)
p.firstComment = game.moves.firstComment
for mv in game.moves.liMoves:
cpBase = ControlPosicion.ControlPosicion()
cpBase.leeFen(mv.fenPrev)
cpActual = ControlPosicion.ControlPosicion()
cpActual.leeFen(mv.fen)
jg = Jugada.Jugada()
jg.ponDatos(cpBase, cpActual, mv.desde, mv.hasta, mv.coronacion)
if mv.criticas:
li = []
for una in mv.criticas:
if una:
if una.isdigit():
li.append(una)
elif una[0] == "$":
una = una[1:]
if una:
li.append(una)
elif una[0] in "?!":
jg.criticaDirecta = una
jg.critica = " ".join(li)
if mv.comentarios:
jg.comentario = "\n".join(mv.comentarios)
if mv.variantes:
li = []
for una in mv.variantes:
li.append(una.toPGN())
jg.variantes = "\n\n".join(li)
p.append_jg(jg)
if game.moves:
p.ultPosicion = cpActual if game.moves.liMoves else cp.copia()
self.partida = p
self.dic = game.labels
self.siError = False
self.texto = texto
return True
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
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
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
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
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.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()
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()
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
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
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
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
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
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
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
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