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 procesa(self, orden):
key = orden.key
if key == KIBRUN_CONFIGURACION:
user = orden.dv["USER"]
self.configuracion = Configuracion.Configuracion(user)
self.configuracion.lee()
self.configuracion.leeConfTableros()
Code.configuracion = self.configuracion
AperturasStd.reset()
self.numkibitzer = orden.dv["NUMKIBITZER"]
kibitzers = Kibitzers.Kibitzers()
self.kibitzer = kibitzers.kibitzer(self.numkibitzer)
prioridad = self.kibitzer.prioridad
priorities = Priorities.priorities
if prioridad != priorities.normal:
self.prioridad = priorities.value(prioridad)
else:
self.prioridad = None
self.titulo = self.kibitzer.name
self.key_video = "Kibitzers%s" % self.kibitzer.huella
self.dic_video = self.configuracion.restore_video(self.key_video)
self.tipo = self.kibitzer.tipo
self.position_before = self.kibitzer.position_before
self.lanzaVentana()
elif key == KIBRUN_FEN:
self.fen, self.fenBase = orden.dv["FEN"].split("|")
fen = self.fenBase if self.position_before else self.fen
if self.tipo == KIB_THREATS:
li = fen.split(" ")
li[1] = "w" if li[1] == "b" else "b"
li[3] = "-" # Hay que tener cuidado con la captura al paso, stockfish crash.
fen = " ".join(li)
self.ventana.ponFen(fen)
elif key == KIBRUN_STOP:
self.ventana.stop()
elif key == KIBRUN_CLOSE:
self.ipc.close()
self.ventana.finalizar()
self.ventana.reject()
def run(user, file_tournament, file_work):
# sys.stderr = Util.Log("./bug.tournaments")
app = QtWidgets.QApplication([])
configuracion = Configuracion.Configuracion(user)
configuracion.lee()
configuracion.leeConfTableros()
configuracion.releeTRA()
Code.configuracion = configuracion
AperturasStd.reset()
Code.todasPiezas = Piezas.TodasPiezas()
app.setStyle(QtWidgets.QStyleFactory.create(configuracion.x_style))
QtWidgets.QApplication.setPalette(
QtWidgets.QApplication.style().standardPalette())
w = WTournamentRun.WTournamentRun(file_tournament, file_work)
w.show()
w.busca_trabajo()
def start_with_user(self, user):
self.user = user
self.li_opciones_inicio = [
TB_QUIT,
TB_PLAY,
TB_TRAIN,
TB_COMPETE,
TB_TOOLS,
TB_OPTIONS,
TB_INFORMATION,
] # Lo incluimos aqui porque sino no lo lee, en caso de aplazada
self.configuracion = Configuracion.Configuracion(user)
self.configuracion.start()
Code.configuracion = self.configuracion
Code.procesador = self
AperturasStd.reset()
# Tras crear configuración miramos si hay adjourns
self.test_opcion_adjourns()
Code.todasPiezas = Piezas.TodasPiezas()
self.gestor = None
self.siPrimeraVez = True
self.siPresentacion = False # si esta funcionando la presentacion
self.posicionInicial = Position.Position()
self.posicionInicial.set_pos_initial()
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
def asigna_OME(self, configuracion):
if self.siFenInicial():
aps = AperturasStd.ListaAperturasStd(configuracion, False, False)
aps.asignaApertura(self)
else:
for jg in self.liJugadas:
jg.siApertura = False
for jg in self.liJugadas:
if jg.siApertura:
jg.estadoOME = OPENING
else:
material = jg.posicionBase.valor_material()
jg.estadoOME = ENDGAME if material < 15 else MIDDLEGAME
def __init__(self, procesador):
self.procesador = procesador
self.ficheroDatos = procesador.configuracion.ficheroEntAperturas
self.ficheroParam = procesador.configuracion.ficheroEntAperturasPar
self.listaAperturasStd = AperturasStd.ListaAperturasStd(
procesador.configuracion, True, True)
self.lista = self.leer()
owner = procesador.pantalla
icono = Iconos.Apertura()
titulo = _("Learn openings by repetition")
extparam = "opentraining"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
# Toolbar
liAcciones = [(_("Close"), Iconos.MainMenu(), self.terminar), None,
(_("Train"), Iconos.Entrenar(), self.entrenar), None,
(_("New"), Iconos.TutorialesCrear(), self.nuevo), None,
(_("Modify"), Iconos.Modificar(), self.modificar), None,
(_("Remove"), Iconos.Borrar(), self.borrar), None,
(_("Copy"), Iconos.Copiar(), self.copiar), None,
(_("Up"), Iconos.Arriba(), self.arriba), None,
(_("Down"), Iconos.Abajo(), self.abajo), None,
("+" + _("Openings"), Iconos.Recuperar(),
self.masaperturas), None,
(_("Book"), Iconos.Libros(), self.polyglot,
_("Create a polyglot book")), None]
tb = Controles.TBrutina(self, liAcciones)
# Lista
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("NOMBRE", _("Name"), 240)
oColumnas.nueva("BLANCAS", _("White"), 120, siCentrado=True)
oColumnas.nueva("NEGRAS", _("Black"), 120, siCentrado=True)
oColumnas.nueva("AMBOS", _("White & Black"), 120, siCentrado=True)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True)
n = self.grid.anchoColumnas()
self.grid.setMinimumWidth(n + 20)
self.registrarGrid(self.grid)
self.grid.gotop()
# Layout
layout = Colocacion.V().control(tb).control(self.grid).margen(8)
self.setLayout(layout)
self.recuperarVideo(siTam=True)
self.siReverse = False
def resultado(self):
if self.partida.numJugadas() == 0:
return None
ap = self.partida.apertura
if ap is None:
ap = AperturasStd.AperturasStd(_("Unknown"))
ap.a1h8 = self.partida.pv()
else:
if not self.partida.last_jg().siApertura:
p = Partida.Partida()
p.leerPV(ap.a1h8)
ap.a1h8 = self.partida.pv()
ap.trNombre += " + %s" % (self.partida.pgnSP()[len(p.pgnSP()) + 1:],)
ap.pgn = self.partida.pgnSP()
return ap
def resultado(self):
if len(self.game) == 0:
return None
ap = self.game.opening
if ap is None:
ap = AperturasStd.AperturasStd(_("Unknown"))
ap.a1h8 = self.game.pv()
else:
if not self.game.last_jg().in_the_opening:
p = Game.Game()
p.read_pv(ap.a1h8)
ap.a1h8 = self.game.pv()
ap.trNombre += " + %s" % (
self.game.pgn_translated()[len(p.pgn_translated()) + 1:], )
ap.pgn = self.game.pgn_translated()
return ap
def leeBloques(self, liPV):
li = []
for pv in liPV:
p = Partida.Partida()
p.leerPV(pv)
self.listaAperturasStd.asignaApertura(p)
ap = p.apertura
if ap is None:
ap = AperturasStd.AperturasStd(_("Unknown"))
ap.a1h8 = pv
else:
ap.a1h8 = pv
ap.pgn = ap.pgn.replace(". ", ".")
nap = len(ap.pgn)
pgnSP = p.pgnSP()
if len(pgnSP) > nap:
ap.trNombre += " + %s" % (pgnSP[nap + 1:], )
ap.pgn = p.pgnSP()
li.append(ap)
return li
def leeBloques(self, liPV):
li = []
for pv in liPV:
p = Game.Game()
p.read_pv(pv)
p.assign_opening()
ap = p.opening
if ap is None:
ap = AperturasStd.AperturasStd(_("Unknown"))
ap.a1h8 = pv
else:
ap.a1h8 = pv
ap.pgn = ap.pgn.replace(". ", ".")
nap = len(ap.pgn)
pgn_translated = p.pgn_translated()
if len(pgn_translated) > nap:
ap.trNombre += " + %s" % (pgn_translated[nap + 1:], )
ap.pgn = p.pgn_translated()
li.append(ap)
return li
def generarStandard(self, ventana, siBasic):
oLista = AperturasStd.ListaAperturasStd(self.configuracion, True, True)
dic = oLista.dic
titulo = _("Openings")
tmpBP2 = QTUtil2.BarraProgreso2(ventana, titulo)
tf = len(dic)
tmpBP2.ponTotal(1, tf)
tmpBP2.ponRotulo(1, "1. " + _X(_("Reading %1"), titulo))
tmpBP2.ponTotal(2, tf)
tmpBP2.ponRotulo(2, "")
tmpBP2.mostrar()
liRegs = []
dRegs = {} # se guarda una lista con los pv, para determinar el padre
for nR, k in enumerate(oLista.dic):
tmpBP2.pon(1, nR)
tmpBP2.siCancelado()
ae = oLista.dic[k]
if siBasic and not ae.siBasic:
continue
liPV = ae.a1h8.split(" ")
ult = len(liPV) - 1
seqFather = ""
cp = ControlPosicion.ControlPosicion()
cp.posInicial()
for pos, pv in enumerate(liPV):
desde, hasta, coronacion = pv[:2], pv[2:4], pv[4:]
seq = seqFather + LCEngine.pv2xpv(pv)
cp.mover(desde, hasta, coronacion)
if seq not in dRegs:
reg = SQLDBF.Almacen()
reg.XPV = seq
reg.PV = pv
reg.FEN = cp.fen()
reg.COMMENT = ae.trNombre if pos == ult else ""
self.ultPos += 1
reg.POS = self.ultPos
liRegs.append(reg)
dRegs[seq] = reg
seqFather = seq
tmpBP2.ponRotulo(2, "2. " + _X(_("Converting %1"), titulo))
tmpBP2.ponTotal(2, len(liRegs))
select = "XPV,PV,COMMENT,FEN,POS"
dbf = SQLDBF.DBF(self.conexion, self.tablaDatos, select)
def dispatch(num):
tmpBP2.pon(2, num)
tmpBP2.siCancelado()
dbf.insertarLista(liRegs, dispatch)
dbf.cerrar()
tmpBP2.cerrar()
def asignaApertura(self, configuracion):
ap = AperturasStd.ListaAperturasStd(configuracion, False, False)
ap.asignaApertura(self)
def __init__(self, procesador, winBookGuide, dbGames, siMoves=True):
QtGui.QWidget.__init__(self)
self.winBookGuide = winBookGuide
self.dbGames = dbGames # <--setdbGames
self.bookGuide = winBookGuide.bookGuide
self.infoMove = None # <-- setInfoMove
self.wmoves = None # <-- setwmoves
self.fenM2 = None
self.liMoves = []
self.analisisMRM = None
self.siMoves = siMoves
self.procesador = procesador
self.configuracion = procesador.configuracion
self.leeConfig()
self.aperturasStd = AperturasStd.ListaAperturasStd(
self.configuracion, False, False)
self.siFigurinesPGN = self.configuracion.figurinesPGN
self.pvBase = ""
self.orden = ["games", False]
self.lbName = Controles.LB(
self, "").ponWrap().alinCentrado().ponColorFondoN(
"white", "#4E5A65").ponTipoLetra(puntos=10 if siMoves else 16)
if not siMoves:
self.lbName.hide()
# Grid
oColumnas = Columnas.ListaColumnas()
oColumnas.nueva("numero", _("N."), 35, siCentrado=True)
self.delegadoMove = Delegados.EtiquetaPGN(
True if self.siFigurinesPGN else None)
oColumnas.nueva("move", _("Move"), 60, edicion=self.delegadoMove)
dicTipos = {
"t": Iconos.pmTransposition(),
}
oColumnas.nueva("trans",
"",
24,
edicion=Delegados.PmIconosBMT(dicIconos=dicTipos))
oColumnas.nueva("analisis", _("Analysis"), 60, siDerecha=True)
oColumnas.nueva("games", _("Games"), 70, siDerecha=True)
oColumnas.nueva("pgames",
"% " + _("Games"),
70,
siDerecha=True,
siCentrado=True)
oColumnas.nueva("win", _("Win"), 70, siDerecha=True)
oColumnas.nueva("draw", _("Draw"), 70, siDerecha=True)
oColumnas.nueva("lost", _("Lost"), 70, siDerecha=True)
oColumnas.nueva("pwin", "% " + _("Win"), 60, siDerecha=True)
oColumnas.nueva("pdraw", "% " + _("Draw"), 60, siDerecha=True)
oColumnas.nueva("plost", "% " + _("Lost"), 60, siDerecha=True)
oColumnas.nueva("pdrawwin", "%% %s" % _("W+D"), 60, siDerecha=True)
oColumnas.nueva("pdrawlost", "%% %s" % _("L+D"), 60, siDerecha=True)
self.grid = Grid.Grid(self,
oColumnas,
xid="summary",
siSelecFilas=True)
self.grid.tipoLetra(puntos=self.configuracion.puntosPGN)
self.grid.ponAltoFila(self.configuracion.altoFilaPGN)
# ToolBar
liAcciones = [
(_("Close"), Iconos.MainMenu(), winBookGuide.terminar),
None,
(_("Start position"), Iconos.Inicio(), self.inicio),
None,
(_("Previous"), Iconos.AnteriorF(), self.anterior),
(_("Next"), Iconos.SiguienteF(), self.siguiente),
None,
(_("Analyze"), Iconos.Analizar(), self.analizar),
None,
(_("Rebuild"), Iconos.Reindexar(), self.reindexar),
None,
(_("Config"), Iconos.Configurar(), self.config),
None,
]
if siMoves:
liAcciones.append(
(_("Create a new guide based in these games") if siMoves else
_("Create"), Iconos.BookGuide(), self.createGuide))
liAcciones.append(None)
self.tb = Controles.TBrutina(self,
liAcciones,
tamIcon=20,
siTexto=not self.siMoves)
if self.siMoves:
self.tb.vertical()
layout = Colocacion.V().control(self.lbName)
if not self.siMoves:
layout.control(self.tb)
layout.control(self.grid)
if self.siMoves:
layout = Colocacion.H().control(self.tb).otro(layout)
layout.margen(1)
self.setLayout(layout)
self.qtColor = (QTUtil.qtColorRGB(221, 255, 221),
QTUtil.qtColorRGB(247, 247, 247),
QTUtil.qtColorRGB(255, 217, 217))
self.qtColorTotales = QTUtil.qtColorRGB(170, 170, 170)
def masaperturas(self):
w = AperturasPersonales(self.procesador, self)
w.exec_()
AperturasStd.reset()
self.listaAperturasStd = AperturasStd.apTrain
def tg_training(self):
w = WBG_Training.WTraining(self, self.tree.dicValoracion, self.tree.dicVentaja)
w.exec_()
if not w.siAceptado:
return
um = QTUtil2.unMomento(self)
dic = w.resultado()
siBlancas = dic["SIWHITE"]
tactica = Tacticas.BaseTactica()
menuname = dic["NAME"]
depth = dic["DEPTH"]
reValW, reVenW = dic["WHITE"]
reValB, reVenB = dic["BLACK"]
dicVal = {True: reValW, False: reValB}
dicVen = {True: reVenW, False: reVenB}
siAddOpening = dic["ADDSTD"]
if siAddOpening:
listaAperturasStd = AperturasStd.ListaAperturasStd(VarGen.configuracion, False, False)
tactica.SHOWTEXT = [0 if siAddOpening else 1, ]
# Leemos todas las lineas=listas de movimientos
liT = self.bookGuide.allLines()
# Se calcula el nombre de la carpeta
name = self.bookGuide.name
restDir = name
nomDir = os.path.join(VarGen.configuracion.dirPersonalTraining, "Tactics", restDir)
nomIni = os.path.join(nomDir, "Config.ini")
if os.path.isfile(nomIni):
dic = Util.ini8dic(nomIni)
n = 1
while True:
if "TACTIC%d" % n in dic:
if "MENU" in dic["TACTIC%d" % n]:
if dic["TACTIC%d" % n]["MENU"].upper() == menuname.upper():
break
else:
break
n += 1
else:
break
nomTactic = "TACTIC%d" % n
else:
nomDirTac = os.path.join(VarGen.configuracion.dirPersonalTraining, "Tactics")
Util.creaCarpeta(nomDirTac)
Util.creaCarpeta(nomDir)
nomTactic = "TACTIC1"
dic = {}
nomFNS = os.path.join(nomDir, nomTactic + ".fns")
# Se crea el fichero con los puzzles
f = codecs.open(nomFNS, "w", "utf-8", 'ignore')
setPr = set()
for nline, liMVbase in enumerate(liT):
if siBlancas:
liMV = liMVbase[1:]
else:
liMV = liMVbase[2:]
if not liMV:
continue
fenBase = liMV[0].fenBase()
numJG = 1
pgn = ""
if not siBlancas:
pgn += "%d..." % numJG
numJG += 1
colorAct = siBlancas
if len(liMV) > depth:
liMV = liMV[:depth]
for mv in liMV:
mas = ""
if mv.adv() in dicVen[colorAct] or \
mv.nag() in dicVal[colorAct]:
continue
if colorAct == siBlancas:
liBrothers = mv.brothers()
for mv1 in liBrothers:
mas += "(%s)" % mv1.pgnEN()
if colorAct:
pgn += " %d." % numJG
numJG += 1
pgn += " " + mv.pgnEN()
if mas:
pgn += " " + mas
colorAct = not colorAct
k = fenBase + pgn
if k not in setPr:
txt = ""
if siAddOpening:
opening = listaAperturasStd.asignaAperturaListaMoves(liMVbase[1:])
if opening:
txt += "%s: %s<br>" % (_("Opening"), opening)
txt += mv.comment()
f.write("%s|%s|%s\n" % (fenBase, txt, pgn))
setPr.add(k)
f.close()
# Se crea el fichero de control
dic[nomTactic] = d = {}
d["MENU"] = menuname
d["FILESW"] = "%s.fns:100" % nomTactic
d["PUZZLES"] = str(tactica.PUZZLES)
for field in ("JUMPS", "REPEAT", "PENALIZATION", "SHOWTEXT" ):
d[field] = tactica.comas2texto(field)
Util.dic8ini(nomIni, dic)
self.procesador.entrenamientos.rehaz()
um.final()
QTUtil2.mensaje(self, _X(_("Tactic training %1 created."), menuname) + "<br>" + \
_X(_("You can access this training from menu Trainings-Learn tactics by repetition-%1"),
name))
def __init__(self, owner, configuracion, bloqueApertura):
icono = Iconos.Apertura()
titulo = _("Select an opening")
extparam = "selectOpening"
QTVarios.WDialogo.__init__(self, owner, titulo, icono, extparam)
# Variables--------------------------------------------------------------------------
self.apStd = AperturasStd.ListaAperturasStd(configuracion, True, True)
self.configuracion = configuracion
self.partida = Partida.Partida()
self.bloqueApertura = bloqueApertura
self.liActivas = []
# Tablero
confTablero = configuracion.confTablero("APERTURAS", 32)
self.tablero = Tablero.Tablero(self, confTablero)
self.tablero.crea()
self.tablero.ponMensajero(self.mueveHumano)
# Current pgn
self.lbPGN = Controles.LB(self, "").ponWrap().ponTipoLetra(puntos=10,
peso=75)
# Movimiento
self.siMoviendoTiempo = False
lyBM, tbBM = QTVarios.lyBotonesMovimiento(self,
"",
siLibre=False,
tamIcon=24)
self.tbBM = tbBM
# Tool bar
tb = Controles.TBrutina(self)
tb.new(_("Accept"), Iconos.Aceptar(), self.aceptar)
tb.new(_("Cancel"), Iconos.Cancelar(), self.cancelar)
tb.new(_("Reinit"), Iconos.Reiniciar(), self.resetPartida)
tb.new(_("Takeback"), Iconos.Atras(), self.atras)
tb.new(_("Remove"), Iconos.Borrar(), self.borrar)
# Lista Aperturas
oColumnas = Columnas.ListaColumnas()
dicTipos = {
"b": Iconos.pmSun(),
"n": Iconos.pmPuntoAzul(),
"l": Iconos.pmNaranja()
}
oColumnas.nueva("TIPO",
"",
24,
edicion=Delegados.PmIconosBMT(dicIconos=dicTipos))
oColumnas.nueva("OPENING", _("Possible continuation"), 480)
self.grid = Grid.Grid(self, oColumnas, siSelecFilas=True, altoFila=32)
self.registrarGrid(self.grid)
# # Derecha
lyD = Colocacion.V().control(tb).control(self.grid)
gbDerecha = Controles.GB(self, "", lyD)
# # Izquierda
lyI = Colocacion.V().control(self.tablero).otro(lyBM).control(
self.lbPGN)
gbIzquierda = Controles.GB(self, "", lyI)
splitter = QtGui.QSplitter(self)
splitter.addWidget(gbIzquierda)
splitter.addWidget(gbDerecha)
self.registrarSplitter(splitter, "splitter")
# Completo
ly = Colocacion.H().control(splitter).margen(3)
self.setLayout(ly)
self.ponActivas()
self.resetPartida()
self.actualizaPosicion()
dic = {'_SIZE_': '916,444', 'SP_splitter': [356, 548]}
self.recuperarVideo(dicDef=dic)
def masaperturas(self):
w = AperturasPersonales(self.procesador, self)
w.exec_()
self.listaAperturasStd = AperturasStd.ListaAperturasStd(
self.procesador.configuracion, True, True)
