def __init__(self, clave, gestor):
self.procesador = gestor.procesador
self.xtutor = gestor.xtutor
self.clave = clave
self.autor = ""
self.version = ""
self.siUCI = False
self.siTutor = False
self.siDebug = False
self.exe = ""
self.motorProfundidad = None
self.motorTiempoJugada = None
self.ml = MotorInterno.MotorInterno()
dic = {
kMP_1: (self.ml.mp1, _("Monkey"), 7, Iconos.pmMonkey()),
kMP_2: (self.ml.mp2, _("Donkey"), 6, Iconos.pmDonkey()),
kMP_3: (self.ml.mp3, _("Bull"), 5, Iconos.pmBull()),
kMP_4: (self.ml.mp4, _("Wolf"), 4, Iconos.pmWolf()),
kMP_5: (self.ml.mp5, _("Lion"), 3, Iconos.pmLion()),
kMP_6: (self.ml.mp6, _("Rat"), 2, Iconos.pmRat()),
kMP_7: (self.ml.mp7, _("Snake"), 0, Iconos.pmSnake()),
}
self.funcion, txt, self.jugadasTutor, self.imagen = dic[clave]
self.nombre = txt
self.numJugada = 0
self.siListo = clave == kMP_7
if self.siListo:
self.siJuegaTutor = False
self.rmComparar = XMotorRespuesta.RespuestaMotor("listo", True)
self.rmComparar.mate = 0
self.rmComparar.puntos = -80
def juega(self, fen):
if self.apertura:
pv = self.book.eligeJugadaTipo(fen, "au")
if pv:
self.apertura -= 1
rmrival = XMotorRespuesta.RespuestaMotor("Apertura", "w" in fen)
rmrival.desde = pv[:2]
rmrival.hasta = pv[2:4]
rmrival.coronacion = pv[4:]
return rmrival
else:
self.apertura = 0
total = self.cromo.aleatorio + self.cromo.captura + self.cromo.esquivo + self.cromo.similar + self.cromo.bien
bola = random.randint(1, total)
if bola <= self.cromo.aleatorio:
return self.juega_aleatorio(fen)
bola -= self.cromo.aleatorio
if bola <= self.cromo.captura:
return self.juega_captura(fen)
bola -= self.cromo.captura
if bola <= self.cromo.esquivo:
return self.juega_esquivo(fen)
bola -= self.cromo.esquivo
if bola <= self.cromo.bien:
return self.juega_irina(fen)
else:
return self.juega_similar(fen)
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 valora(self, posicion, desde, hasta, coronacion):
self.testEngine()
posicionNueva = posicion.copia()
posicionNueva.mover(desde, hasta, coronacion)
fen = posicionNueva.fen()
if LCEngine.fenTerminado(fen):
# Par que llegue hasta aqui tiene que ser tablas
rm = XMotorRespuesta.RespuestaMotor("", posicion.siBlancas)
rm.sinInicializar = False
self.sinMovimientos = True
self.pv = desde+hasta+coronacion
self.desde = desde
self.hasta = hasta
self.coronacion = coronacion
return rm
mrm = self.motor.bestmove_fen(fen, self.motorTiempoJugada, self.motorProfundidad)
rm = mrm.mejorMov()
rm.cambiaColor(posicion)
mv = desde + hasta + (coronacion if coronacion else "")
rm.pv = mv + " " + rm.pv
rm.desde = desde
rm.hasta = hasta
rm.coronacion = coronacion if coronacion else ""
rm.siBlancas = posicion.siBlancas
return rm
def analizaJugada(self, jg, tiempo, depth=0, brDepth=5, brPuntos=50):
if not self.siIniMotor:
self.iniciarMotor()
resp = self.motor.mejorMovF(jg.posicionBase.fen(),
tiempo,
depth,
siReturnTxt=True)
if resp is None:
return None
mrm, txt = resp
mv = jg.movimiento()
if not mv:
return mrm, 0
rm, n = mrm.buscaRM(jg.movimiento())
if rm:
if n == 0:
mrm.miraBrilliancies(txt, brDepth, brPuntos)
return mrm, n
# No esta considerado, obliga a hacer el analisis de nuevo desde posicion
if jg.siJaqueMate or jg.siTablas():
rm = XMotorRespuesta.RespuestaMotor(self.nombre,
jg.posicionBase.siBlancas)
rm.desde = mv[:2]
rm.hasta = mv[2:4]
rm.coronacion = mv[4] if len(mv) == 5 else ""
rm.pv = mv
else:
posicion = jg.posicion
mrm1 = self.motor.mejorMovF(posicion.fen(), tiempo, depth)
if mrm1 and mrm1.liMultiPV:
rm = mrm1.liMultiPV[0]
rm.cambiaColor(posicion)
rm.pv = mv + " " + rm.pv
else:
rm = XMotorRespuesta.RespuestaMotor(self.nombre,
mrm1.siBlancas)
rm.pv = mv
rm.desde = mv[:2]
rm.hasta = mv[2:4]
rm.coronacion = mv[4] if len(mv) == 5 else ""
rm.siBlancas = jg.posicionBase.siBlancas
pos = mrm.agregaRM(rm)
return mrm, pos
def analizaJugadaPartida(self, partida, njg, tiempo, depth=0, brDepth=5, brPuntos=50,
stability=False, st_centipawns=0, st_depths=0, st_timelimit=0):
self.testEngine()
if stability:
mrm = self.motor.analysis_stable(partida, njg, tiempo, depth, True, st_centipawns, st_depths, st_timelimit)
else:
mrm = self.motor.bestmove_game_jg(partida, njg, tiempo, depth, is_savelines=True)
jg = partida.jugada(njg)
mv = jg.movimiento()
if not mv:
return mrm, 0
rm, n = mrm.buscaRM(mv)
if rm:
if n == 0:
mrm.miraBrilliancies(brDepth, brPuntos)
return mrm, n
# No esta considerado, obliga a hacer el analisis de nuevo desde posicion
if jg.siJaqueMate or jg.siTablas():
rm = XMotorRespuesta.RespuestaMotor(self.nombre, jg.posicionBase.siBlancas)
rm.desde = mv[:2]
rm.hasta = mv[2:4]
rm.coronacion = mv[4] if len(mv) == 5 else ""
rm.pv = mv
else:
posicion = jg.posicion
mrm1 = self.motor.bestmove_fen(posicion.fen(), tiempo, depth)
if mrm1 and mrm1.liMultiPV:
rm = mrm1.liMultiPV[0]
rm.cambiaColor(posicion)
rm.pv = mv + " " + rm.pv
else:
rm = XMotorRespuesta.RespuestaMotor(self.nombre, mrm1.siBlancas)
rm.pv = mv
rm.desde = mv[:2]
rm.hasta = mv[2:4]
rm.coronacion = mv[4] if len(mv) == 5 else ""
rm.siBlancas = jg.posicionBase.siBlancas
pos = mrm.agregaRM(rm)
return mrm, pos
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 analizaVariante(self, jg, tiempo, siBlancas):
self.testEngine()
mrm = self.motor.bestmove_fen(jg.posicion.fen(), tiempo, None)
if mrm.liMultiPV:
rm = mrm.liMultiPV[0]
# if siBlancas != jg.posicion.siBlancas:
# if rm.mate:
# rm.mate += +1 if rm.mate > 0 else -1
else:
rm = XMotorRespuesta.RespuestaMotor("", siBlancas)
return rm
def analizaVariante(self, jg, tiempo, siBlancas):
if not self.siIniMotor:
self.iniciarMotor()
mrm = self.motor.mejorMovF(jg.posicion.fen(), tiempo, None)
if mrm.liMultiPV:
rm = mrm.liMultiPV[0]
if siBlancas != jg.posicion.siBlancas:
if rm.mate:
rm.mate += +1 if rm.mate > 0 else -1
else:
rm = XMotorRespuesta.RespuestaMotor("", siBlancas)
return rm
def siguienteJugada(self):
if self.estado == kFinJuego:
return
self.estado = kJugando
self.siJuegaHumano = False
self.ponVista()
siBlancas = self.partida.ultPosicion.siBlancas
self.ponIndicador(siBlancas)
self.refresh()
fen = self.partida.ultPosicion.fen()
self.listaJugadas = self.miraListaJugadas(fen)
if not self.listaJugadas:
self.ponResultado()
return
siRival = siBlancas == self.siRivalConBlancas
if siRival:
self.desactivaTodas()
nli = len(self.listaJugadas)
if nli > 1:
pos = random.randint(0, nli - 1)
else:
pos = 0
pv, desde, hasta, coronacion, pgn = self.listaJugadas[pos]
self.ultPV = pv
self.rmRival = XMotorRespuesta.RespuestaMotor(
"Apertura", self.siRivalConBlancas)
self.rmRival.desde = desde
self.rmRival.hasta = hasta
self.rmRival.coronacion = coronacion
self.mueveRival(self.rmRival)
self.siguienteJugada()
else:
self.siJuegaHumano = True
self.activaColor(siBlancas)
def ajustaPlayer(self, mrm):
posicion = self.partida.ultPosicion
mi = MotorInterno.MotorInterno()
mi.ponFen(posicion.fen())
li = mi.dameMovimientos()
liOpciones = []
for rm in mrm.liMultiPV:
liOpciones.append((rm, "%s (%s)" % (posicion.pgnSP(
rm.desde, rm.hasta, rm.coronacion), rm.abrTexto())))
mv = rm.movimiento()
for x in range(len(li)):
if li[x].pv() == mv:
del li[x]
break
for mj in li:
rm = XMotorRespuesta.RespuestaMotor("", posicion.siBlancas)
pv = mj.pv()
rm.desde = pv[:2]
rm.hasta = pv[2:4]
rm.coronacion = pv[4:]
rm.puntos = None
liOpciones.append(
(rm, posicion.pgnSP(rm.desde, rm.hasta, rm.coronacion)))
if len(liOpciones) == 1:
return liOpciones[0][0]
menu = QTVarios.LCMenu(self.pantalla)
titulo = _("White") if posicion.siBlancas else _("Black")
icono = Iconos.Carpeta()
self.pantalla.cursorFueraTablero()
menu.opcion(None, titulo, icono)
menu.separador()
icono = Iconos.PuntoNaranja(
) if posicion.siBlancas else Iconos.PuntoNegro()
for rm, txt in liOpciones:
menu.opcion(rm, txt, icono)
while True:
resp = menu.lanza()
if resp:
return resp
def siguienteJugada(self):
self.muestraInformacion()
if self.estado == kFinJuego:
return
self.estado = kJugando
self.siJuegaHumano = False
self.ponVista()
siBlancas = self.partida.ultPosicion.siBlancas
self.ponIndicador(siBlancas)
self.refresh()
siRival = siBlancas == self.siRivalConBlancas
numJugadas = len(self.partida)
if numJugadas >= self.numPV:
self.partidaTerminada(True)
return
pv = self.liPV[numJugadas]
if siRival:
self.desactivaTodas()
self.rmRival = XMotorRespuesta.RespuestaMotor(
"Apertura", self.siRivalConBlancas)
self.rmRival.desde = pv[:2]
self.rmRival.hasta = pv[2:4]
self.rmRival.coronacion = pv[4:]
self.mueveRival(self.rmRival)
self.siguienteJugada()
else:
self.activaColor(siBlancas)
self.siJuegaHumano = True
if self.siAyuda:
self.muestraAyuda()
def siguienteJugada(self):
if self.estado == kFinJuego:
return
self.estado = kJugando
self.siJuegaHumano = False
self.ponVista()
siBlancas = self.partida.ultPosicion.siBlancas
if self.partida.numJugadas() > 0:
jgUltima = self.partida.last_jg()
if jgUltima:
if jgUltima.siJaqueMate:
self.ponResultado(kGanaRival if self.siJugamosConBlancas ==
siBlancas else kGanamos)
return
if jgUltima.siAhogado:
self.ponResultado(kTablas)
return
if jgUltima.siTablasRepeticion:
self.ponResultado(kTablasRepeticion)
return
if jgUltima.siTablas50:
self.ponResultado(kTablas50)
return
if jgUltima.siTablasFaltaMaterial:
self.ponResultado(kTablasFaltaMaterial)
return
if self.ayudas == 0:
if self.categoria.sinAyudasFinal:
self.quitaAyudas()
self.siTutorActivado = False
siRival = siBlancas == self.siRivalConBlancas
self.ponIndicador(siBlancas)
self.refresh()
if siRival:
self.pensando(True)
self.desactivaTodas()
siPensar = True
if self.siApertura:
siBien, desde, hasta, coronacion = self.apertura.juegaMotor(
self.fenUltimo())
if siBien:
self.rmRival = XMotorRespuesta.RespuestaMotor(
"Apertura", self.siRivalConBlancas)
self.rmRival.desde = desde
self.rmRival.hasta = hasta
self.rmRival.coronacion = coronacion
siPensar = False
else:
self.siApertura = False
if siPensar:
self.rmRival = self.xrival.juega()
self.pensando(False)
if self.mueveRival(self.rmRival):
self.siguienteJugada()
else:
self.siJuegaHumano = True
self.activaColor(siBlancas)
def juegaRival(self):
self.pensando(True)
self.desactivaTodas()
self.relojStart(False)
desde = hasta = coronacion = ""
siEncontrada = False
if self.aperturaObl:
siEncontrada, desde, hasta, coronacion = self.aperturaObl.juegaMotor(self.fenUltimo())
if not siEncontrada:
self.aperturaObl = None
if not siEncontrada and self.book:
if self.partida.ultPosicion.jugadas < self.maxMoveBook:
siEncontrada, desde, hasta, coronacion = self.eligeJugadaBook()
if not siEncontrada:
self.book = None
if not siEncontrada and self.aperturaStd:
siEncontrada, desde, hasta, coronacion = self.aperturaStd.juegaMotor(self.fenUltimo())
if not siEncontrada:
self.aperturaStd = None
if not siEncontrada and self.siBookAjustarFuerza:
siEncontrada, desde, hasta, coronacion = self.eligeJugadaBookAjustada() # libro de la personalidad
if not siEncontrada:
self.siBookAjustarFuerza = False
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,
nAjustado=self.nAjustarFuerza)
if self.estado == kFinJuego:
return True
if self.nAjustarFuerza == kAjustarPlayer:
self.rmRival = self.ajustaPlayer(self.rmRival)
else:
self.rmRival = self.xrival.juegaPartida(self.partida, nAjustado=self.nAjustarFuerza)
if self.nAjustarFuerza == kAjustarPlayer:
self.rmRival = self.ajustaPlayer(self.rmRival)
self.setSummary("TIMERIVAL", self.timekeeper.stop())
self.relojStop(False)
self.pensando(False)
self.liRMrival.append(self.rmRival)
if not (self.resignPTS < -1500): # then not ask for draw
if not self.valoraRMrival(self.siRivalConBlancas):
return True
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 siguienteJugada(self):
if self.estado == kFinJuego:
return
self.estado = kJugando
self.siJuegaHumano = False
self.ponVista()
siBlancas = self.partida.ultPosicion.siBlancas
numJugadas = self.partida.numJugadas()
if numJugadas > 0:
jgUltima = self.partida.last_jg()
if jgUltima:
if jgUltima.siJaqueMate:
self.ponResultado(kGanaRival if self.siJugamosConBlancas == siBlancas else kGanamos)
return
if jgUltima.siAhogado:
self.ponResultado(kTablas)
return
if jgUltima.siTablasRepeticion:
self.ponResultado(kTablasRepeticion)
return
if jgUltima.siTablas50:
self.ponResultado(kTablas50)
return
if jgUltima.siTablasFaltaMaterial:
self.ponResultado(kTablasFaltaMaterial)
return
siRival = siBlancas == self.siRivalConBlancas
self.ponIndicador(siBlancas)
self.refresh()
if siRival:
self.relojStart(False)
self.pensando(True)
self.desactivaTodas()
siEncontrada = False
if self.book:
if self.partida.ultPosicion.jugadas >= self.maxMoveBook:
self.book = None
else:
fen = self.fenUltimo()
pv = self.book.eligeJugadaTipo(fen, "ap")
if pv:
self.rmRival = XMotorRespuesta.RespuestaMotor("Apertura", self.siRivalConBlancas)
self.rmRival.desde = pv[:2]
self.rmRival.hasta = pv[2:4]
self.rmRival.coronacion = pv[4:]
siEncontrada = True
else:
self.book = None
if not siEncontrada:
tiempoBlancas = self.tiempo[True].tiempoPendiente
tiempoNegras = self.tiempo[False].tiempoPendiente
mrm = self.xrival.juegaTiempoTorneo(tiempoBlancas, tiempoNegras, self.segundosJugada)
if mrm is None:
self.pensando(False)
return False
self.rmRival = mrm.mejorMov()
self.relojStop(False)
self.pensando(False)
if self.mueveRival(self.rmRival):
self.liRMrival.append(self.rmRival)
if self.valoraRMrival(self.siRivalConBlancas):
self.siguienteJugada()
else:
self.ponResultado(kGanamos)
else:
self.relojStart(True)
self.siJuegaHumano = True
self.activaColor(siBlancas)
def siguienteJugada(self):
if self.estado == kFinJuego:
return
self.ponRotuloActual()
self.estado = kJugando
self.siJuegaHumano = False
self.ponVista()
siBlancas = self.partida.ultPosicion.siBlancas
if self.partida.numJugadas() > 0:
jgUltima = self.partida.last_jg()
if jgUltima:
if jgUltima.siJaqueMate:
siGanado = self.siJugamosConBlancas != siBlancas
if siGanado:
self.movimientos += 2001
self.finJuego(True)
self.guardarGanados(siGanado)
return
if jgUltima.siAhogado or jgUltima.siTablasRepeticion or jgUltima.siTablas50 or jgUltima.siTablasFaltaMaterial:
self.movimientos += 1001
self.finJuego(True)
self.guardarGanados(False)
return
siRival = siBlancas == self.siRivalConBlancas
self.ponIndicador(siBlancas)
self.refresh()
if siRival:
self.pensando(True)
self.desactivaTodas()
siPensar = True
puntosRivalPrevio = self.puntosRival
if self.siApertura:
siBien, desde, hasta, coronacion = self.apertura.juegaMotor(
self.fenUltimo())
if siBien:
self.rmRival = XMotorRespuesta.RespuestaMotor(
"Apertura", self.siRivalConBlancas)
self.rmRival.desde = desde
self.rmRival.hasta = hasta
self.rmRival.coronacion = coronacion
siPensar = False
if siPensar:
self.rmRival = self.xrival.juegaSegundos(self.segundos)
self.puntosRival = self.rmRival.puntosABS()
self.ponRotuloActual()
self.pensando(False)
if self.mueveRival(self.rmRival):
lostmovepoints = self.puntosRival - puntosRivalPrevio
if self.siBoxing and self.puntosRival > self.puntos:
if self.comprueba():
return
if self.siBoxing and self.maxerror and lostmovepoints > self.maxerror:
if self.comprueba():
return
self.siguienteJugada()
else:
self.siJuegaHumano = True
self.activaColor(siBlancas)
def siguienteJugada(self):
if self.estado == kFinJuego:
return
self.estado = kJugando
self.siJuegaHumano = False
self.ponVista()
siBlancas = self.partida.ultPosicion.siBlancas
numJugadas = self.partida.numJugadas()
if numJugadas > 0:
jgUltima = self.partida.last_jg()
if jgUltima:
if jgUltima.siJaqueMate:
self.ponResultado(kGanaRival if self.siJugamosConBlancas ==
siBlancas else kGanamos)
return
if jgUltima.siAhogado:
self.ponResultado(kTablas)
return
if jgUltima.siTablasRepeticion:
self.ponResultado(kTablasRepeticion)
return
if jgUltima.siTablas50:
self.ponResultado(kTablas50)
return
if jgUltima.siTablasFaltaMaterial:
self.ponResultado(kTablasFaltaMaterial)
return
siRival = siBlancas == self.siRivalConBlancas
self.ponIndicador(siBlancas)
self.refresh()
if siRival:
self.pensando(True)
self.desactivaTodas()
iniT = time.time()
siPensar = True
if self.siApertura:
dT, hT = 5, 5
siBien, desde, hasta, coronacion = self.apertura.juegaMotor(
self.fenUltimo())
if siBien:
self.rmRival = XMotorRespuesta.RespuestaMotor(
"Apertura", self.siRivalConBlancas)
self.rmRival.desde = desde
self.rmRival.hasta = hasta
self.rmRival.coronacion = coronacion
siPensar = False
if siPensar:
if self.siRivalInterno:
self.rmRival = self.xrival.juega()
dT, hT = 5, 15
else:
nJugadas = self.partida.numJugadas()
if nJugadas > 30:
tp = 300
else:
tp = 600
self.rmRival = self.xrival.juegaTiempo(
tp, tp, 0) # engloba juega + juega Tiempo
pts = self.rmRival.puntosABS()
if pts > 100:
dT, hT = 5, 15
else:
dT, hT = 10, 35
difT = time.time() - iniT
t = random.randint(dT * 10, hT * 10) * 0.01
if difT < t:
time.sleep(t - difT)
self.pensando(False)
if self.mueveRival(self.rmRival):
self.liRMrival.append(self.rmRival)
if self.valoraRMrival(self.siRivalConBlancas):
self.siguienteJugada()
else:
self.siJuegaHumano = True
self.activaColor(siBlancas)
def siguienteJugada(self):
if self.estado == kFinJuego:
return
self.estado = kJugando
self.siJuegaHumano = False
self.ponVista()
siBlancas = self.partida.siBlancas()
if self.partida.numJugadas() > 0:
jgUltima = self.partida.liJugadas[-1]
if jgUltima:
if jgUltima.siJaqueMate:
self.ponResultado(kGanaRival if self.siJugamosConBlancas ==
siBlancas else kGanamos)
return
if jgUltima.siAhogado:
self.ponResultado(kTablas)
return
if jgUltima.siTablasRepeticion:
self.ponResultado(kTablasRepeticion)
return
if jgUltima.siTablas50:
self.ponResultado(kTablas50)
return
if jgUltima.siTablasFaltaMaterial:
self.ponResultado(kTablasFaltaMaterial)
return
self.ponIndicador(siBlancas)
self.refresh()
siRival = siBlancas == self.siRivalConBlancas
if self.book:
self.testBook()
if siRival:
self.pensando(True)
self.desactivaTodas()
self.relojStart(False)
siEncontrada = False
if self.siApertura:
if self.partida.ultPosicion.jugadas >= self.maxMoveBook:
self.siApertura = False
else:
if self.siAperturaStd:
siEncontrada, desde, hasta, coronacion = self.apertura.juegaMotor(
self.fenUltimo())
else:
if self.book: # Sin apertura estandar, con apertura y libro
siEncontrada, desde, hasta, coronacion = self.eligeJugadaBook(
)
if siEncontrada:
self.siApertura = False # para que no haya problemas de busqueda futura, ya seguimos siempre el libro
if not siEncontrada: # Nada en el libro en su caso buscamos la apertura normal
if self.nAjustarFuerza:
siEncontrada, desde, hasta, coronacion = self.eligeJugadaBookAjustada(
)
if not siEncontrada and self.apertura:
siEncontrada, desde, hasta, coronacion = self.apertura.juegaMotor(
self.fenUltimo())
if not siEncontrada:
self.siApertura = False
if not siEncontrada and self.book: # Sin apertura y con libro
siEncontrada, desde, hasta, coronacion = self.eligeJugadaBook(
)
if siEncontrada:
self.rmRival = XMotorRespuesta.RespuestaMotor(
"Apertura", self.siRivalConBlancas)
self.rmRival.desde = desde
self.rmRival.hasta = hasta
self.rmRival.coronacion = coronacion
else:
self.siApertura = False
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,
nAjustado=self.nAjustarFuerza)
if self.estado == kFinJuego:
return
if self.nAjustarFuerza == kAjustarPlayer:
self.rmRival = self.ajustaPlayer(self.rmRival)
else:
if self.siRivalInterno:
self.rmRival = self.xrival.juega()
else:
self.rmRival = self.xrival.juegaPartida(
self.partida, nAjustado=self.nAjustarFuerza)
if self.nAjustarFuerza == kAjustarPlayer:
self.rmRival = self.ajustaPlayer(self.rmRival)
self.setSummary("TIMERIVAL", self.timekeeper.stop())
self.liRMrival.append(self.rmRival)
if not self.valoraRMrival(
): # def valoraRMrival specific, no es necesario pasar self.siRivalConBlancas
self.relojStop(False)
self.pensando(False)
return
self.relojStop(False)
self.pensando(False)
if self.estado != kFinJuego:
resp = self.mueveRival(self.rmRival)
if resp:
self.siguienteJugada()
else:
self.siJuegaHumano = True
self.analizaTutorInicio()
self.relojStart(True)
self.timekeeper.start()
self.activaColor(siBlancas)
