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 miraBuffer(self):
self.lock = True
li = self.buffer.split("\n")
if self.buffer.endswith("\n"):
self.buffer = ""
else:
self.buffer = li[-1]
li = li[:-1]
mrm = XMotorRespuesta.MRespuestaMotor("", " w " in self.fen)
mrm.dispatch("\n".join(li))
mrm.maxTiempo = None
mrm.maxProfundidad = 9999
mrm.ordena()
if mrm.liMultiPV:
rm = mrm.liMultiPV[0]
p = Partida.Partida(fen=self.fen)
p.leerPV(rm.pv)
li = p.pgnSP().split(" ")
if len(li) > 20:
li = li[:20]
self.em.ponHtml("[%02d] %s | %s" % (rm.depth, rm.abrTexto(), " ".join(li)))
self.lock = 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 __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 _mejorMov(self, maxTiempo, maxProfundidad, siBlancas):
env = "go"
if maxProfundidad:
env += " depth %d" % maxProfundidad
elif maxTiempo:
env += " movetime %d" % maxTiempo
msTiempo = 10000
if maxTiempo:
msTiempo = maxTiempo
elif maxProfundidad:
msTiempo = int(maxProfundidad * msTiempo / 3.0)
if self.guiDispatch:
li_resp, result = self.pwait_list_dispatch(env, "bestmove",
msTiempo)
else:
li_resp, result = self.pwait_list(env, "bestmove", msTiempo)
if not result:
return None
mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, siBlancas)
for linea in li_resp:
mrm.dispatch(linea)
mrm.maxTiempo = maxTiempo
mrm.maxProfundidad = maxProfundidad
mrm.ordena()
return mrm
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 _mejorMov(self, maxTiempo, maxProfundidad, siReturnTxt, siBlancas):
env = "go"
if maxProfundidad:
env += " depth %d" % maxProfundidad
elif maxTiempo:
env += " movetime %d" % maxTiempo
msTiempo = 10000
if maxTiempo:
msTiempo = maxTiempo
elif maxProfundidad:
msTiempo = int(maxProfundidad * msTiempo / 3.0)
resp = self.orden_bestmove(env, msTiempo)
if not resp:
return None
mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, siBlancas)
mrm.dispatch(resp, maxTiempo, maxProfundidad)
mrm.maxTiempo = maxTiempo
mrm.maxProfundidad = maxProfundidad
if siReturnTxt:
return mrm, resp
else:
return mrm
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 ac_inicio(self, partida):
self.lockAC = True
self.posicionPartida(partida)
self.siBlancas = partida.ultPosicion.siBlancas
self.connect(self, QtCore.SIGNAL("readyReadStandardOutput()"),
self.ac_lee)
self.mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, self.siBlancas)
self.flush()
self.escribe("go infinite")
self.waitForReadyRead(90)
self.lockAC = False
def _mejorMovInfinitoTiempo(self, maxTiempo, siBlancas):
busca = " @@ " # que no busque nada
resp = self.orden_infinito(busca, maxTiempo)
if not resp:
return None
mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, siBlancas)
mrm.dispatch(resp, maxTiempo, None)
mrm.maxTiempo = maxTiempo
mrm.maxProfundidad = None
return mrm
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 _mejorMovTiempo(self, fen, tiempoBlancas, tiempoNegras, tiempoJugada,
siBlancas):
env = "go wtime %d btime %d" % (tiempoBlancas, tiempoNegras)
if tiempoJugada:
env += " winc %d" % tiempoJugada
maxtiempo = tiempoBlancas if " w " in fen else tiempoNegras
resp = self.orden_bestmove(env, maxtiempo)
if not resp:
return None
mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, siBlancas)
mrm.dispatch(resp, None, None)
return mrm
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 _mejorMovInfinito(self, maxProfundidad, siBlancas):
busca = " depth %d " % maxProfundidad
tiempo = maxProfundidad * 2000
if maxProfundidad > 9:
tiempo += (maxProfundidad - 9) * 20000
resp = self.orden_infinito(busca, tiempo)
if not resp:
return None
mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, siBlancas)
mrm.dispatch(resp, None, maxProfundidad)
mrm.maxTiempo = None
mrm.maxProfundidad = maxProfundidad
return mrm
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 juega(self):
fen = self.procesador.gestor.partida.fenUltimo()
if self.jugadasTutor == 0:
siTutor = self.siJuegaTutor
mrm = self.xtutor.control(fen, 3)
rm = mrm.liMultiPV[0]
self.siJuegaTutor = self.rmComparar.siMejorQue(rm, 0, 0)
else:
self.numJugada += 1
siTutor = self.numJugada % self.jugadasTutor == 0
if siTutor:
mrm = self.xtutor.control(fen, 3)
else:
pv = self.funcion(fen)
mrm = XMotorRespuesta.MRespuestaMotor("interno", "w" in fen)
mrm.dispatch("bestmove " + pv, None, None)
return mrm.liMultiPV[0]
def pwait_list_dispatch(self, orden, txt_busca, maxtime):
self.put_line(orden)
ini = time.time()
tm_dispatch = ini
li = []
mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, self.is_white)
while time.time() - ini < maxtime:
if (time.time() - tm_dispatch) >= 1.0:
mrm.ordena()
rm = mrm.mejorMov()
if not self.guiDispatch(rm):
return li, False
tm_dispatch = time.time()
line = self.stdout.readline().strip()
if self.log:
self.log_write(line)
li.append(line)
mrm.dispatch(line)
if line.startswith(txt_busca):
return li, True
return li, False
def dispatch(self):
QtCore.QCoreApplication.processEvents(
QtCore.QEventLoop.ExcludeUserInputEvents)
if self.guiDispatch:
tm = time.time()
if tm - self.ultDispatch < self.minDispatch:
return True
self.ultDispatch = tm
mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, self.siBlancas)
if self._buffer.endswith("\n"):
b = self._buffer
else:
n = self._buffer.rfind("\n")
b = self._buffer[:-n + 1] if n > 1 else ""
mrm.dispatch(b)
mrm.ordena()
rm = mrm.mejorMov()
rm.whoDispatch = self.whoDispatch
if not self.guiDispatch(rm):
return False
return True
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 _mejorMov(self, maxTiempo, maxProfundidad, siBlancas):
env = "go"
if maxProfundidad:
env += " depth %d" % maxProfundidad
elif maxTiempo:
env += " movetime %d" % maxTiempo
msTiempo = 10000
if maxTiempo:
msTiempo = maxTiempo
elif maxProfundidad:
msTiempo = int(maxProfundidad * msTiempo / 3.0)
resp = self.orden_bestmove(env, msTiempo)
if not resp:
return None
mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, siBlancas)
for linea in resp.split("\n"):
mrm.dispatch(linea.strip())
mrm.maxTiempo = maxTiempo
mrm.maxProfundidad = maxProfundidad
mrm.ordena()
return mrm
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.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 miraBuffer(self):
if self.lock:
return
self.lock = True
li = self.buffer.split("\n")
if self.buffer.endswith("\n"):
self.buffer = ""
else:
self.buffer = li[-1]
li = li[:-1]
for linea in li:
if linea.startswith("info ") and " pv " in linea and " depth " in linea and "multipv" in linea:
n = linea.index("depth")
depth = int(linea[n:].split(" ")[1].strip())
n = linea.index("multipv")
multipv = int(linea[n:].split(" ")[1].strip())
if depth not in self.dicLineasDepth:
self.dicLineasDepth[depth] = {}
self.dicLineasDepth[depth][multipv] = linea.strip()
mxdepth = 0
liBorrar = []
for depth, lista in self.dicLineasDepth.iteritems():
if len(lista) == self.numMovesDepth:
if depth > mxdepth:
liBorrar.append(depth)
mxdepth = depth
if mxdepth:
mrm = XMotorRespuesta.MRespuestaMotor(self.cpu.titulo, self.siW)
for multipv, linea in self.dicLineasDepth[mxdepth].iteritems():
mrm.miraPV(linea)
mrm.ordena()
self.liData = mrm.liMultiPV
# Borramos hasta esa depth
for depth in liBorrar:
del self.dicLineasDepth[depth]
rm = mrm.liMultiPV[0]
self.lbDepth.ponTexto("%s: %d" % (_("Depth"), rm.depth))
partida = Partida.Partida(fen=self.fen)
partida.leerPV(rm.pv)
if partida.numJugadas():
self.tablero.quitaFlechas()
jg0 = partida.jugada(0)
self.tablero.ponPosicion(jg0.posicion)
tipo = "mt"
opacidad = 100
salto = (80 - 15) * 2 / (self.nArrows - 1) if self.nArrows > 1 else 1
cambio = max(30, salto)
for njg in range(min(partida.numJugadas(), self.nArrows)):
tipo = "ms" if tipo == "mt" else "mt"
jg = partida.jugada(njg)
self.tablero.creaFlechaMov(jg.desde, jg.hasta, tipo + str(opacidad))
if njg % 2 == 1:
opacidad -= cambio
cambio = salto
self.grid.refresh()
self.lock = False
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 miraBuffer(self):
if not self.siPlay:
return
self.lock = True
li = self.buffer.split("\n")
if self.buffer.endswith("\n"):
self.buffer = ""
else:
self.buffer = li[-1]
li = li[:-1]
mrm = XMotorRespuesta.MRespuestaMotor("", " w " in self.fen)
mrm.dispatch("\n".join(li))
mrm.ordena()
mrm.maxTiempo = None
mrm.maxProfundidad = 9999
if mrm.liMultiPV:
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.fen)
litxt = ['<table border="1" cellpadding="4" cellspacing="0" style="border-color: #ACA899">', ]
def tr(tp, mas=""):
litxt.append('<tr><th>%s</th><td align="right">%.01f%%</td><td>%s%s</td></tr>' % (tp[0], tp[1], mas, tp[2]))
tp = AnalisisIndexes.tp_gamestage(cp, mrm)
litxt.append('<tr><th>%s</th><td align="right">%d</td><td>%s</td></tr>' % (tp[0], tp[1], tp[2]))
pts = mrm.liMultiPV[0].puntosABS()
if pts:
w, b = _("White"), _("Black")
siW = "w" in self.fen
if pts > 0:
mas = w if siW else b
elif pts < 0:
mas = b if siW else w
mas += "-"
else:
mas = ""
tr(AnalisisIndexes.tp_winprobability(cp, mrm), mas)
tr(AnalisisIndexes.tp_complexity(cp, mrm))
tr(AnalisisIndexes.tp_efficientmobility(cp, mrm))
tr(AnalisisIndexes.tp_narrowness(cp, mrm))
tr(AnalisisIndexes.tp_piecesactivity(cp, mrm))
tr(AnalisisIndexes.tp_exchangetendency(cp, mrm))
tp = AnalisisIndexes.tp_positionalpressure(cp, mrm)
litxt.append('<tr><th>%s</th><td align="right">%dcp</td><td></td></tr>' % (tp[0], int(tp[1])))
tr(AnalisisIndexes.tp_materialasymmetry(cp, mrm))
# tr(AnalisisIndexes.tp_test1(cp, mrm))
# tr(AnalisisIndexes.tp_test2(cp, mrm))
# tr(AnalisisIndexes.tp_test3(cp, mrm))
# tr(AnalisisIndexes.tp_test4(cp, mrm))
# tr(AnalisisIndexes.tp_test5(cp, mrm))
litxt.append("</table>")
self.em.ponHtml("".join(litxt))
self.lock = False
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 reset(self):
self.get_lines()
self.mrm = XMotorRespuesta.MRespuestaMotor(self.nombre, self.is_white)
