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 leeGuion(self, nomGuion, siFenInicial):
li = self.dbGuiones.get(nomGuion, TabVisual.Guion())
self.guion = TabVisual.Guion()
if li:
self.tablero.dicMovibles = {}
# self.tableroOwner.borraMovibles()
self.tablero.crea()
for reg in li:
if reg._registro:
tp, id, a1h8 = reg._registro
tarea, fila = self.creaTareaBase(tp, id, a1h8, -1)
if tarea is None:
continue
tarea.recupera(reg)
if hasattr(reg, "_bloqueDatos"):
sc = tarea.itemSC()
sc.bloqueDatos = reg._bloqueDatos
sc.update()
sc.setVisible(False)
tarea.marcado(False)
else:
tarea = self.guion.recuperaReg(reg)
tarea._marcado = False
if siFenInicial:
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.fenInicial)
self.tablero.ponPosicionBase(cp)
self.tablero.activaTodas()
self.nomGuion = nomGuion
def __init__(self, procesador):
self.pantalla = procesador.pantalla
self.tablero = self.pantalla.tablero
self.procesador = procesador
fmt = "./IntFiles/Mate/mate1.lst"
with open(fmt) as f:
li = [linea for linea in f.read().split("\n") if linea.strip()]
linea = random.choice(li)
li = linea.split("|")
uno = random.choice(li)
fen, mv0 = uno.split(",")
fen += " w - - 1 1"
LCEngine.setFen(fen)
liMv = LCEngine.getExMoves()
self.liMovs = []
for mv in liMv:
if mv.mate():
self.liMovs.append(mv.movimiento())
self.cp = ControlPosicion.ControlPosicion()
self.cp.leeFen(fen)
self.iniTime = time.time()
self.siBlancas = " w " in fen
self.tablero.bloqueaRotacion(False)
self.tablero.ponMensajero(self.mueveHumano)
self.tablero.ponPosicion(self.cp)
self.tablero.ponerPiezasAbajo(self.siBlancas)
self.tablero.activaColor(self.siBlancas)
self.tablero.ponIndicador(self.siBlancas)
def __init__(self, moveOwner, fen, dbCache):
self.moveOwner = moveOwner
self.dbCache = dbCache
if not moveOwner:
self.nivel = 0
cp = ControlPosicion.ControlPosicion()
cp.leeFen(fen)
self.partidaBase = Partida.Partida(cp)
else:
self.nivel = self.moveOwner.listaMovesPadre.nivel + 1
self.partidaBase = self.moveOwner.partida.copia()
self.fenM2 = self.partidaBase.ultPosicion.fenM2()
dicCache = self.dbCache[self.fenM2]
ml = MotorInterno.MotorInterno()
ml.ponFen(self.fenM2 + " 0 1")
ml.calculaEstado()
liMov = ml.listaMovimientos()
liMov.sort(key=lambda x: x.pv())
liMoves = []
for mov in liMov:
um = UnMove(self, mov, dicCache)
liMoves.append(um)
self.liMoves = liMoves
self.liMovesInicial = liMoves[:]
self.liAnalisis = dicCache.get("ANALISIS", []) if dicCache else []
# self.analisisActivo
# self.dicAnalisis
self.ponAnalisisActivo(dicCache.get("ANALISIS_ACTIVO", None) if dicCache else None)
def siguiente_posicion(self):
num_lineas_posicion = len(self.li_lineas_posicion)
while True:
random_pos = random.randint(0, num_lineas_posicion-1)
if random_pos not in self.st_randoms:
self.st_randoms.add(random_pos)
break
self.fen, self.result, self.pgn_result, self.pgn, self.difficult = self.li_lineas_posicion[random_pos].strip().split("|")
self.difficult = int(self.difficult)
self.cp = ControlPosicion.ControlPosicion()
self.cp.leeFen(self.fen)
self.siBlancas = " w " in self.fen
self.tablero.bloqueaRotacion(False)
self.tablero.ponMensajero(self.mueveHumano)
self.tablero.ponPosicion(self.cp)
self.tablero.ponerPiezasAbajo(self.siBlancas)
self.tablero.activaColor(self.siBlancas)
self.tablero.ponIndicador(self.siBlancas)
self.intentos = 0
self.max_intentos = (self.difficult+1)/2+4
self.iniTime = time.time()
self.savePosition()
def __init__(self, moveOwner, fen, dbCache):
self.moveOwner = moveOwner
self.dbCache = dbCache
if not moveOwner:
self.nivel = 0
cp = ControlPosicion.ControlPosicion()
cp.leeFen(fen)
self.partidaBase = Partida.Partida(cp)
else:
self.nivel = self.moveOwner.listaMovesPadre.nivel + 1
self.partidaBase = self.moveOwner.partida.copia()
self.fenM2 = self.partidaBase.ultPosicion.fenM2()
dicCache = self.dbCache[self.fenM2]
LCEngine.setFen(self.fenM2 + " 0 1")
liMov = [xpv[1:] for xpv in LCEngine.getMoves()]
liMov.sort()
liMoves = []
for pv in liMov:
um = UnMove(self, pv, dicCache)
liMoves.append(um)
self.liMoves = liMoves
self.liMovesInicial = liMoves[:]
self.liAnalisis = dicCache.get("ANALISIS", []) if dicCache else []
# self.analisisActivo
# self.dicAnalisis
self.ponAnalisisActivo(dicCache.get("ANALISIS_ACTIVO", None) if dicCache else None)
def leeLibros(self, liLibros, fen, masTitulo, siPV):
if not fen:
return []
posicion = ControlPosicion.ControlPosicion()
posicion.leeFen(fen)
p = Polyglot()
ico = "w" if posicion.siBlancas else "b"
icoL = "l"
liResp = []
for libro in liLibros:
liResp.append((None, libro.nombre + masTitulo, icoL))
li = p.lista(libro.path, fen)
if li:
total = 0
for entry in li:
total += entry.weight
for entry in li:
pv = entry.pv()
w = entry.weight
pc = w * 100.0 / total if total else "?"
pgn = posicion.pgnSP(pv[:2], pv[2:4], pv[4:])
liResp.append((pv if siPV else None,
"%-5s -%7.02f%% -%7d" % (pgn, pc, w), ico))
else:
liResp.append((None, _("No result"), "c"))
return liResp
def inicio(self, route):
GestorRoutes.inicio(self, route)
ending = self.route.get_ending()
if "|" in ending:
self.is_guided = True
self.t4 = None
self.fen, label, pv = ending.split("|")
self.liPV = pv.split(" ")
self.posPV = 0
else:
self.is_guided = False
self.t4 = LibChess.T4()
self.fen = ending + " - - 0 1"
self.rivalPensando = False
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.fen)
siBlancas = cp.siBlancas
self.partida.reset(cp)
self.partida.pendienteApertura = False
self.warnings = 0
self.max_warnings = 5
self.siJuegaHumano = False
self.estado = kJugando
self.siJugamosConBlancas = siBlancas
self.siRivalConBlancas = not siBlancas
self.pantalla.ponActivarTutor(False)
self.quitaAyudas(True)
self.ayudasPGN = 0
liOpciones = [k_mainmenu, k_ayuda]
self.pantalla.ponToolBar(liOpciones)
self.pantalla.activaJuego(True, False, siAyudas=False)
self.pantalla.quitaAyudas(True)
self.ponMensajero(self.mueveHumano)
self.ponPosicion(self.partida.ultPosicion)
self.mostrarIndicador(True)
self.ponPiezasAbajo(siBlancas)
self.ponWarnings()
self.pgnRefresh(True)
QTUtil.xrefreshGUI()
self.ponPosicionDGT()
if self.is_guided:
self.ponRotulo1("<b>%s</b>" % label)
self.siguienteJugada()
def siguiente(self):
resp = self.sts.siguientePosicion(self.work)
if resp:
self.ngroup, self.nfen, self.elem = resp
if not self.hideBoard:
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.elem.fen)
self.tablero.ponPosicion(cp)
self.xengine.ponGuiDispatch(self.dispatch)
xpt, xa1h8 = self.elem.bestA1H8()
self.tablero.quitaFlechas()
self.tablero.creaFlechaTmp(xa1h8[:2], xa1h8[2:], False)
if not self.playing:
return
t0 = time.time()
mrm = self.xengine.analiza(self.elem.fen)
t1 = time.time() - t0
if mrm:
rm = mrm.mejorMov()
if rm:
mov = rm.movimiento()
if mov:
if not self.hideBoard:
self.tablero.creaFlechaTmp(rm.desde, rm.hasta,
True)
self.sts.setResult(self.work, self.ngroup, self.nfen,
mov, t1)
self.grid.refresh()
else:
self.tb.setAccionVisible(self.pause, False)
self.tb.setAccionVisible(self.run, False)
self.playing = False
QTUtil.refreshGUI()
def almListaJugadas(self, fen):
li = self.book.lista(self.path, fen)
posicion = ControlPosicion.ControlPosicion()
posicion.leeFen(fen)
total = 0
maxim = 0
for entry in li:
w = entry.weight
total += w
if w > maxim:
maxim = w
listaJugadas = []
for entry in li:
alm = Util.Almacen()
pv = entry.pv()
w = entry.weight
alm.desde, alm.hasta, alm.coronacion = pv[:2], pv[2:4], pv[4:]
alm.pgn = posicion.pgnSP(alm.desde, alm.hasta, alm.coronacion)
alm.fen = fen
alm.porc = "%0.02f%%" % (w * 100.0 / total, ) if total else ""
alm.weight = w
listaJugadas.append(alm)
return listaJugadas
def paste(self, texto):
cp = ControlPosicion.ControlPosicion()
try:
if "." in texto or '"' in texto:
unpgn = PGN.UnPGN()
unpgn.leeTexto(texto)
if unpgn.siError:
return
self.bloqueApertura = None
self.posicApertura = None
self.fen = unpgn.dic.get("FEN", None)
dic = self.creaDic()
dic["PARTIDA"] = unpgn.partida.guardaEnTexto()
dic["liPGN"] = unpgn.listaCabeceras()
dic["FEN"] = self.fen
dic["SIBLANCASABAJO"] = unpgn.partida.ultPosicion.siBlancas
self.reiniciar(dic)
else:
cp.leeFen(str(texto))
self.fen = cp.fen()
self.bloqueApertura = None
self.posicApertura = None
self.reiniciar()
except:
pass
def setPosicion(self, partida, njg, numTab=None):
if partida is None:
return
jg = partida.jugada(njg)
self.partida = partida
self.njg = njg
next = self.cb_nextmove.valor()
if jg:
if njg == 0:
pv = partida.pv_hasta(njg) if next else ""
else:
pv = partida.pv_hasta(njg if next else njg - 1)
posicion = jg.posicion if next else jg.posicionBase
else:
posicion = ControlPosicion.ControlPosicion().posInicial()
pv = ""
for ntab, (tipo, tab) in enumerate(self.liTabs):
if ntab == 0:
p = Partida.Partida()
p.leerPV(pv)
tab.setData(p.pgnHTML(siFigurines=self.configuracion.figurinesPGN), posicion)
else:
data = pv if tipo == "dbase" else posicion
if numTab is not None:
if ntab != numTab:
continue
if ntab > 1:
tab.setData(data)
tab.start()
def presentacion(self, siEmpezar=True):
self.siPresentacion = siEmpezar
if not siEmpezar:
self.cpu.stop()
self.tablero.ponerPiezasAbajo(True)
self.tablero.activaMenuVisual(True)
self.tablero.ponPosicion(self.posicionInicial)
self.tablero.setToolTip("")
self.tablero.bloqueaRotacion(False)
else:
self.tablero.bloqueaRotacion(True)
self.tablero.activaMenuVisual(False)
self.tablero.setToolTip("")
logo = ControlPosicion.ControlPosicion()
logo.logo()
# self.cpu.ponPosicion(logo)
# hx = self.cpu.duerme(2.0)
# Presentacion.basico( self, hx )
# Presentacion.partidaDia(self, hx)
self.tablero.activaMenuVisual(True)
Presentacion.GestorChallenge101(self)
def iniciaConUsuario(self, user):
self.user = user
self.web = "https://lucaschess.pythonanywhere.com"
self.blog = "https://lucaschess.blogspot.com"
self.liOpcionesInicio = [k_terminar, k_play, k_entrenamiento, k_competir,
k_tools, k_opciones, k_informacion] # Lo incluimos aqui porque sino no lo lee, en caso de aplazada
self.configuracion = Configuracion.Configuracion(user)
self.configuracion.start(self.version)
VarGen.configuracion = self.configuracion
AperturasStd.reset()
VarGen.todasPiezas = Piezas.TodasPiezas()
self.gestor = None
self.teclaPanico = 32 # necesario
self.siPrimeraVez = True
self.siPresentacion = False # si esta funcionando la presentacion
self.posicionInicial = ControlPosicion.ControlPosicion()
self.posicionInicial.posInicial()
self.xrival = None
self.xtutor = None # creaTutor lo usa asi que hay que definirlo antes
self.xanalyzer = None # cuando se juega GestorEntMaq y el tutor danzando a toda maquina, se necesita otro diferente
self.replay = None
self.replayBeep = None
self.liKibitzersActivas = []
def MoverInicio(self):
if self.usoNormal:
self.posHistoria = -1
posicion = ControlPosicion.ControlPosicion().posInicial()
else:
self.posJugada = -1
posicion = self.partida.iniPosicion
self.tablero.ponPosicion(posicion)
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 __init__(self, owner, liFens, motor, segundos, fns):
super(WDailyTest, self).__init__(owner, _("Your daily test"),
Iconos.DailyTest(), "nivel")
self.procesador = owner.procesador
self.configuracion = self.procesador.configuracion
if motor.startswith("*"):
motor = motor[1:]
confMotor = self.configuracion.buscaTutor(motor, "mcbrain")
self.xtutor = self.procesador.creaGestorMotor(confMotor,
segundos * 1000, None)
self.xtutor.maximizaMultiPV()
self.historico = owner.historico
# Tablero
confTablero = self.configuracion.confTablero("NIVEL", 48)
self.liFens = liFens
self.nFens = len(self.liFens)
self.juego = 0
self.liPuntos = []
self.liPV = []
self.liTiempos = []
self.fns = fns
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
self.tablero.ponMensajero(self.mueveHumano)
# Rotulos informacion
self.lbColor = Controles.LB(self, "").ponWrap().anchoMinimo(200)
self.lbJuego = Controles.LB(self, "").alinCentrado()
# Tool bar
liAcciones = (
# ( _( "Start" ), Iconos.Empezar(), "empezar" ),
(_("Analysis"), Iconos.Tutor(), "analizar"),
(_("Cancel"), Iconos.Cancelar(), "cancelar"),
(_("Continue"), Iconos.Pelicula_Seguir(), "seguir"),
(_("Resign"), Iconos.Abandonar(), "abandonar"),
)
self.tb = Controles.TB(self, liAcciones)
lyT = Colocacion.V().control(self.tablero).relleno()
lyV = Colocacion.V().control(self.lbJuego).relleno().control(
self.lbColor).relleno(2)
lyTV = Colocacion.H().otro(lyT).otro(lyV)
ly = Colocacion.V().control(self.tb).otro(lyTV)
self.setLayout(ly)
self.posicion = ControlPosicion.ControlPosicion()
self.recuperarVideo()
self.siguienteJugada()
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 reiniciar(self):
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.fen)
self.partida.reset(cp)
self.estado = kJugando
self.ponteAlFinal()
self.ponRevision(False)
self.siSeguirJugando = False
self.siguienteJugada()
def inicia():
cp = ControlPosicion.ControlPosicion()
cp.posInicial()
pvActual = ""
for pv in pvBase.split(" "):
cp.moverPV(pv)
pvActual += " " + pv
f.write("%s|%s|%s\n" % (pv2xpv(pvActual.strip()), pv, cp.fen()))
return cp
def limpiaTableroOwner(self):
self.tableroOwner.borraMovibles()
for n in range(len(self.guion)):
self.ponMarcadoOwner(n, False)
self.guion.borraItemTareaOwner(n)
self.g_guion.refresh()
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.fenInicial)
self.tableroOwner.ponPosicionBase(cp)
def recuperaDeTexto(self, txt):
li = txt.split(VarGen.XSEP)
def xL(num):
return li[num] == "S"
self.posicionBase = ControlPosicion.ControlPosicion()
self.posicion = ControlPosicion.ControlPosicion()
self.posicionBase.leeFen(li[0])
self.posicion.leeFen(li[1])
self.desde = li[2]
self.hasta = li[3]
self.coronacion = li[4]
self.siJaque = xL(5)
self.siJaqueMate = xL(6)
self.siAhogado = xL(7)
self.siTablasRepeticion = xL(8)
self.siTablasFaltaMaterial = xL(9)
self.siTablas50 = xL(10)
self.siApertura = xL(11)
self.pgnBase = li[12]
self.siAbandono = li[13]
self.variantes = li[14]
self.comentario = li[15]
self.critica = li[16]
self.siDesconocido = xL(17)
if len(li) > 18 and li[18]:
try:
self.analisis = cPickle.loads(str(li[18].replace("#&", "\n")))
except:
pass
if len(li) > 19 and li[19]:
self.criticaDirecta = li[19]
if not (self.criticaDirecta[0] in "!?"):
self.criticaDirecta = ""
if len(li) > 20:
self.siTablasAcuerdo = xL(20)
self.liMovs = [("b", self.hasta), ("m", self.desde, self.hasta)]
if self.posicion.liExtras:
self.liMovs.extend(self.posicion.liExtras)
def pgn(self):
if not self._pgn:
pv = self._pv
d, h, c = pv[:2], pv[2:4], pv[4:]
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self._father.fen())
self._pgn = cp.pgnSP(d, h, c)
cp.mover(d, h, c)
self._fen = cp.fen()
return self._pgn
def factorDistancia(self):
nummoves = 0
distancia = 0.0
for line in self.lines:
d, n = line.distancia_moves()
nummoves += n
distancia += d
base_dist = ControlPosicion.distancia("a1", "a4")
return (distancia / nummoves) / base_dist
def miraListaJugadas(self, fen):
posicion = ControlPosicion.ControlPosicion()
posicion.leeFen(fen)
listaJugadas = []
for pv in self.dicActual.keys():
desde, hasta, coronacion = pv[:2], pv[2:4], pv[4:]
pgn = posicion.pgnSP(desde, hasta, coronacion)
listaJugadas.append((pv, desde, hasta, coronacion, pgn))
return listaJugadas
def posicionPegar(self):
texto = QTUtil.traePortapapeles()
if texto:
cp = ControlPosicion.ControlPosicion()
try:
cp.leeFen(texto.strip())
self.fen = cp.fen()
if self.fen == ControlPosicion.FEN_INICIAL:
self.fen = ""
self.muestraPosicion()
except:
pass
def lanzaVariantesNumero(self, resp):
if resp == -1:
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.fen)
self.partida.reset(cp)
else:
self.partida.recuperaDeTexto(self.liVariantes[resp][1])
self.estado = kJugando
self.siDirigidoVariantes = True
self.siDirigido = True
self.ponteAlFinal()
self.siguienteJugada()
def reinicio(self, dbop):
self.dbop = dbop
self.tipoJuego = kJugOpeningLines
self.training = self.dbop.training()
self.liTrainPositions = self.training["LITRAINPOSITIONS"]
self.trposition = self.liTrainPositions[0]
self.tm = 0
for game in self.liTrainPositions:
for tr in game["TRIES"]:
self.tm += tr["TIME"]
self.liMensBasic = [
"%s: %d" % (_("Moves"), len(self.liTrainPositions)),
]
self.siAyuda = False
self.siSaltoAutomatico = True
cp = ControlPosicion.ControlPosicion()
cp.leeFen(self.trposition["FENM2"] + " 0 1")
self.partida = Partida.Partida(iniPosicion=cp)
self.ayudas = 9999 # Para que analice sin problemas
self.siJugamosConBlancas = self.training["COLOR"] == "WHITE"
self.siRivalConBlancas = not self.siJugamosConBlancas
self.pantalla.ponToolBar((k_mainmenu, k_ayuda, k_configurar))
self.pantalla.activaJuego(True, False, siAyudas=False)
self.ponMensajero(self.mueveHumano)
self.ponPosicion(cp)
self.mostrarIndicador(True)
self.quitaAyudas()
self.ponPiezasAbajo(self.siJugamosConBlancas)
self.pgnRefresh(True)
self.ponCapInfoPorDefecto()
self.estado = kJugando
self.ponPosicionDGT()
self.quitaInformacion()
self.errores = 0
self.ini_time = time.time()
self.muestraInformacion()
self.siguienteJugada()
def dameMovimiento(self, father, pv):
mv = UnMove(self, father)
xpv = father.xpv() + LCEngine.pv2xpv(pv)
mv.xpv(xpv)
mv.pv(pv)
cp = ControlPosicion.ControlPosicion()
cp.leeFen(father.fen())
cp.moverPV(pv)
mv.fen(cp.fen())
self.ultPos += 1
mv.pos(self.ultPos)
father.addChildren(mv)
self.pteGrabar(mv)
return mv
def reset(self, iniPosicion=None):
self.liJugadas = []
self.pendienteApertura = True
self.apertura = None
self.siEmpiezaConNegras = False
if iniPosicion:
self.iniPosicion = iniPosicion.copia()
self.siEmpiezaConNegras = not self.iniPosicion.siBlancas
else:
self.iniPosicion = ControlPosicion.ControlPosicion()
self.iniPosicion.posInicial()
self.ultPosicion = self.iniPosicion.copia()
