def elo(self):
menu = QTVarios.LCMenu(self.pantalla)
menu.opcion("lucaselo", "%s (%d)" % (_("Lucas-Elo"), self.configuracion.elo), Iconos.Elo())
menu.separador()
if VarGen.isWindows or VarGen.isWine:
menu.opcion("micelo", "%s (%d)" % (_("Tourney-Elo"), self.configuracion.michelo), Iconos.EloTimed())
menu.separador()
fics = self.configuracion.fics
menuf = menu.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <= (fics - elo) <= 400):
menuf.opcion("fics%d" % (elo / 100,), "%d-%d" % (elo, elo + 99), rp.otro())
fide = self.configuracion.fide
menu.separador()
menuf = menu.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
rp = QTVarios.rondoPuntos()
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <= (fide - elo) <= 400):
menuf.opcion("fide%d" % (elo / 100,), "%d-%d" % (elo, elo + 99), rp.otro())
resp = menu.lanza()
if resp:
if resp == "lucaselo":
self.lucaselo(True)
elif resp == "micelo":
self.micelo(True)
elif resp.startswith("fics"):
self.ficselo(True, int(resp[4:]))
elif resp.startswith("fide"):
self.fideelo(True, int(resp[4:]))
def elo(self):
menu = QTVarios.LCMenu(self.pantalla)
menu.opcion("lucaselo", "%s (%d)" % (_("Lucas-Elo"), self.configuracion.elo), Iconos.Elo())
menu.separador()
if VarGen.isWindows or VarGen.isWine:
menu.opcion("micelo", "%s (%d)" % (_("Tourney-Elo"), self.configuracion.michelo), Iconos.EloTimed())
menu.separador()
fics = self.configuracion.fics
menuf = menu.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <= (fics - elo) <= 400):
menuf.opcion("fics%d" % (elo / 100,), "%d-%d" % (elo, elo + 99), rp.otro())
fide = self.configuracion.fide
menu.separador()
menuf = menu.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
rp = QTVarios.rondoPuntos()
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <= (fide - elo) <= 400):
menuf.opcion("fide%d" % (elo / 100,), "%d-%d" % (elo, elo + 99), rp.otro())
resp = menu.lanza()
if resp:
if resp == "lucaselo":
self.lucaselo(True)
elif resp == "micelo":
self.micelo(True)
elif resp.startswith("fics"):
self.ficselo(True, int(resp[4:]))
elif resp.startswith("fide"):
self.fideelo(True, int(resp[4:]))
def menucompete_savemenu(procesador, dic_data=None):
savemenu = SaveMenu(dic_data, procesador.menucompete_run)
savemenu.opcion(("competition", None), _("Competition with tutor"),
Iconos.NuevaPartida())
savemenu.separador()
submenu = savemenu.submenu(_("Elo-Rating"), Iconos.Elo())
submenu.opcion(
("lucaselo", 0),
"%s (%d)" % (_("Lucas-Elo"), procesador.configuration.x_elo),
Iconos.Elo())
submenu.separador()
submenu.opcion(
("micelo", 0),
"%s (%d)" % (_("Tourney-Elo"), procesador.configuration.x_michelo),
Iconos.EloTimed())
submenu.separador()
fics = procesador.configuration.x_fics
menuf = submenu.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <=
(fics - elo) <= 400):
menuf.opcion(("fics", elo / 100), "%d-%d" % (elo, elo + 99),
rp.otro())
submenu.separador()
fide = procesador.configuration.x_fide
menuf = submenu.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <=
(fide - elo) <= 400):
menuf.opcion(("fide", elo / 100), "%d-%d" % (elo, elo + 99),
rp.otro())
lichess = procesador.configuration.x_lichess
submenu.separador()
menuf = submenu.submenu("%s (%d)" % (_("Lichess-Elo"), lichess),
Iconos.Lichess())
rp = QTVarios.rondoPuntos()
for elo in range(800, 2700, 100):
if (elo == 800) or (0 <= (elo + 99 - lichess) <= 400 or 0 <=
(lichess - elo) <= 400):
menuf.opcion(("lichess", elo / 100), "%d-%d" % (elo, elo + 99),
rp.otro())
savemenu.separador()
submenu = savemenu.submenu(_("Singular moves"), Iconos.Singular())
submenu.opcion(("strenght101", 0), _("Calculate your strength"),
Iconos.Strength())
submenu.separador()
submenu.opcion(("challenge101", 0), _("Challenge 101"), Iconos.Wheel())
return savemenu
def utilidades(self):
menu = QTVarios.LCMenu(self)
submenu = menu.submenu(_("Analysis"), Iconos.Analizar())
submenu.opcion(self.ta_massive, _("Mass analysis"), Iconos.Analizar())
submenu.separador()
submenu.opcion(self.ta_remove, _("Delete all previous analysis"),
Iconos.Delete())
menu.separador()
lihistory = self.dbop.lihistory()
if lihistory:
submenu = menu.submenu(_("Backups"), Iconos.Copiar())
rondo = QTVarios.rondoPuntos()
for history in lihistory[:30]:
h = history
if len(h) > 70:
h = h[:70] + "..."
submenu.opcion(history, h, rondo.otro())
submenu.separador()
# submenu = menu.submenu(_("History of this session"), Iconos.Copiar())
resp = menu.lanza()
if resp:
if isinstance(resp, (str, unicode)):
if QTUtil2.pregunta(
self,
_("Are you sure you want to restore backup %s ?" %
("\n%s" % resp))):
um = QTUtil2.unMomento(self, _("Working..."))
self.dbop.rechistory(resp)
self.glines.refresh()
self.glines.gotop()
um.final()
else:
resp()
def seleccionaLibro(self):
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
for book in list_books.lista:
menu.opcion(("x", book), book.name, rondo.otro())
menu.separador()
menu.opcion(("n", None), _("Install new book"), Iconos.Nuevo())
resp = menu.lanza()
if resp:
orden, book = resp
if orden == "x":
pass
elif orden == "n":
fbin = QTUtil2.leeFichero(self,
list_books.path,
"bin",
titulo=_("Polyglot book"))
if fbin:
list_books.path = os.path.dirname(fbin)
name = os.path.basename(fbin)[:-4]
book = Books.Book("P", name, fbin, True)
list_books.nuevo(book)
list_books.save_pickle(self.configuration.file_books)
else:
book = None
return book
def tg_file(self):
menu = QTVarios.LCMenu(self)
lista = QTVarios.listaDB(self.configuracion, False)
if lista:
smenu = menu.submenu( _("Open another database"), Iconos.DatabaseC())
rp = QTVarios.rondoPuntos()
for fich in lista:
smenu.opcion(os.path.join(self.configuracion.carpeta, fich), _F(fich[:-4]), rp.otro())
smenu.separador()
menu.separador()
menu.opcion(self.tg_create,_("Create a new database"), Iconos.NuevaDB())
menu.separador()
submenu = menu.submenu(_("Import from"), Iconos.DatabaseCNew())
submenu.opcion(self.tg_importar_PGN, _("A PGN file"), Iconos.FichPGN())
submenu.separador()
submenu.opcion(self.tg_importar_DB, _("Other database"), Iconos.DatabaseC())
submenu.separador()
submenu.opcion(self.tg_importar_pks, _("A PKS file"), Iconos.JuegaSolo())
menu.separador()
submenu = menu.submenu(_("Export to"), Iconos.DatabaseMas())
submenu.opcion(self.tg_exportar_PGN, _("A PGN file"), Iconos.FichPGN())
submenu.separador()
submenu.opcion(self.tg_exportar_DB, _("Other database"), Iconos.DatabaseC())
menu.separador()
resp = menu.lanza()
if resp:
if type(resp) == str:
self.changeDBgames(resp)
else:
resp()
def changeFolder(self):
nof = _("New opening folder")
base = self.configuration.folder_base_openings
li = [x for x in os.listdir(base) if os.path.isdir(os.path.join(base, x))]
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
menu.opcion("", _("Home folder"), Iconos.Home())
menu.separador()
for x in li:
menu.opcion(x, x, rondo.otro())
menu.separador()
menu.opcion(":n", nof, Iconos.Nuevo())
if Code.is_windows:
menu.separador()
menu.opcion(":m", _("Direct maintenance"), Iconos.Configurar())
resp = menu.lanza()
if resp is not None:
if resp == ":m":
os.startfile(base)
return
elif resp == ":n":
name = ""
error = ""
while True:
li_gen = [FormLayout.separador]
li_gen.append((nof + ":", name))
if error:
li_gen.append(FormLayout.separador)
li_gen.append((None, error))
resultado = FormLayout.fedit(li_gen, title=nof, parent=self, icon=Iconos.OpeningLines(), anchoMinimo=460)
if resultado:
accion, liResp = resultado
name = liResp[0].strip()
if name:
path = os.path.join(base, name)
try:
os.mkdir(path)
except:
error = _("Unable to create this folder")
continue
if not os.path.isdir(path):
continue
break
else:
return
else:
path = os.path.join(base, resp)
path = Util.relative_path(path)
self.configuration.set_folder_openings(path)
self.configuration.graba()
self.listaOpenings = OpeningLines.ListaOpenings(self.configuration)
self.glista.refresh()
self.glista.gotop()
if len(self.listaOpenings) == 0:
self.wtrain.setVisible(False)
self.setWindowTitle(self.getTitulo())
def select(self):
if len(self.liVariantes) == 0:
return None
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
for num, variante in enumerate(self.liVariantes):
jg = variante.jugada(0)
menu.opcion(num, "%d. %s" % (num+1, jg.pgnBaseSP()), rondo.otro())
return menu.lanza()
def menu_groups(self, carpeta):
if Util.exist_folder(carpeta):
with os.scandir(carpeta) as it:
li = [entry.name for entry in it if entry.is_dir()]
if li:
rondo = QTVarios.rondoPuntos()
menu = QTVarios.LCMenu(self)
for direc in li:
menu.opcion(direc, direc, rondo.otro())
return menu.lanza()
def mousePressEvent(self, event):
Controles.EM.mousePressEvent(self, event)
if event.button() == QtCore.Qt.RightButton:
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
for txt, key in self.liCampos:
menu.opcion(key, txt, rondo.otro())
resp = menu.lanza()
if resp:
self.insertarTexto(resp)
def menu(self, parent):
menu = Controles.Menu(parent)
rp = QTVarios.rondoPuntos()
submenu = menu.submenu(_("Internal engines"), self.dicIconos[INTERNO])
for cm in self.liMotoresInternos:
clave = INTERNO, cm
texto = cm.nombre
icono = rp.otro()
elo = cm.elo
submenu.opcion(clave, "%s (%d)" % (texto, elo), icono)
menu.separador()
submenu = menu.submenu(_("External engines"), self.dicIconos[EXTERNO])
for cm in self.liMotoresExternos:
clave = EXTERNO, cm
texto = cm.clave
icono = rp.otro()
submenu.opcion(clave, texto, icono)
submenu.separador()
clave = EXTERNO, None
texto = _("Edition")
icono = Iconos.Mas()
submenu.opcion(clave, texto, icono)
menu.separador()
submenu = menu.submenu(_("GM engines"), self.dicIconos[MICGM])
for gm, li in self.dicMotoresGM.iteritems():
icono = rp.otro()
submenuGM = submenu.submenu(gm, icono)
for cm in li:
clave = MICGM, cm
texto = cm.alias.split(" ")[2]
submenuGM.opcion(clave, texto, icono)
submenuGM.separador()
menu.separador()
menu.opcion((MICPER, None), _("Tourney engines"), self.dicIconos[MICPER])
menu.separador()
submenu = menu.submenu(_("Engines with fixed elo"), self.dicIconos[FIXED])
li = self.dicMotoresFixedElo.keys()
li.sort()
for elo in li:
icono = rp.otro()
submenuElo = submenu.submenu(str(elo), icono)
lien = self.dicMotoresFixedElo[elo]
lien.sort(key=lambda x: x.nombre)
for cm in lien:
clave = FIXED, cm
texto = cm.nombre
submenuElo.opcion(clave, texto, icono)
submenuElo.separador()
return menu.lanza()
def menu(self, parent):
menu = Controles.Menu(parent)
rp = QTVarios.rondoPuntos()
submenu = menu.submenu(_("Internal engines"), self.dicIconos[INTERNO])
for cm in self.liMotoresInternos:
clave = INTERNO, cm
texto = cm.nombre
icono = rp.otro()
elo = cm.elo
submenu.opcion(clave, "%s (%d)" % (texto, elo), icono)
menu.separador()
submenu = menu.submenu(_("External engines"), self.dicIconos[EXTERNO])
for cm in self.liMotoresExternos:
clave = EXTERNO, cm
texto = cm.clave
icono = rp.otro()
submenu.opcion(clave, texto, icono)
submenu.separador()
clave = EXTERNO, None
texto = _("Edition")
icono = Iconos.Mas()
submenu.opcion(clave, texto, icono)
menu.separador()
submenu = menu.submenu(_("GM engines"), self.dicIconos[MICGM])
for gm, li in self.dicMotoresGM.iteritems():
icono = rp.otro()
submenuGM = submenu.submenu(gm, icono)
for cm in li:
clave = MICGM, cm
texto = cm.alias.split(" ")[2]
submenuGM.opcion(clave, texto, icono)
submenuGM.separador()
menu.separador()
menu.opcion(( MICPER, None), _("Tourney engines"), self.dicIconos[MICPER])
menu.separador()
submenu = menu.submenu(_("Engines with fixed elo"), self.dicIconos[FIXED])
li = self.dicMotoresFixedElo.keys()
li.sort()
for elo in li:
icono = rp.otro()
submenuElo = submenu.submenu(str(elo), icono)
lien = self.dicMotoresFixedElo[elo]
lien.sort(key=lambda x: x.nombre)
for cm in lien:
clave = FIXED, cm
texto = cm.nombre
submenuElo.opcion(clave, texto, icono)
submenuElo.separador()
return menu.lanza()
def menuCompetir(self):
menu = QTVarios.LCMenu(self.pantalla)
menu.opcion(("competition", None), _("Competition with tutor"), Iconos.NuevaPartida())
menu.separador()
submenu = menu.submenu(_("Elo-Rating"), Iconos.Elo())
submenu.opcion(("lucaselo",0), "%s (%d)" % (_("Lucas-Elo"), self.configuracion.elo), Iconos.Elo())
submenu.separador()
if VarGen.isWindows or VarGen.isWine:
submenu.opcion(("micelo",0), "%s (%d)" % (_("Tourney-Elo"), self.configuracion.michelo), Iconos.EloTimed())
submenu.separador()
fics = self.configuracion.fics
menuf = submenu.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <= (fics - elo) <= 400):
menuf.opcion(("fics", elo / 100), "%d-%d" % (elo, elo + 99), rp.otro())
submenu.separador()
fide = self.configuracion.fide
menuf = submenu.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <= (fide - elo) <= 400):
menuf.opcion(("fide", elo / 100), "%d-%d" % (elo, elo + 99), rp.otro())
menu.separador()
submenu = menu.submenu(_("Singular moves"), Iconos.Singular())
submenu.opcion(("strenght101", 0), _("Calculate your strength"), Iconos.Strength())
submenu.separador()
submenu.opcion(("challenge101",0), _("Challenge 101"), Iconos.Wheel())
resp = menu.lanza()
if resp:
tipo, rival = resp
if tipo == "competition":
self.competicion()
elif tipo == "lucaselo":
self.lucaselo(True)
elif tipo == "micelo":
self.micelo(True)
elif tipo == "fics":
self.ficselo(True, rival)
elif tipo == "fide":
self.fideelo(True, rival)
elif tipo == "challenge101":
Presentacion.GestorChallenge101(self)
elif tipo == "strenght101":
self.strenght101()
def history(self):
menu = QTVarios.LCMenu(self, puntos=9)
menu.setToolTip(_("To choose: <b>left button</b> <br>To erase: <b>right button</b>"))
rp = QTVarios.rondoPuntos()
for pos, txt in enumerate(self.history_list):
menu.opcion(pos, txt, rp.otro())
pos = menu.lanza()
if pos is not None:
if menu.siIzq:
self.file = self.history_list[pos]
self.show_file()
elif menu.siDer:
del self.history_list[pos]
def gridBotonDerecho(self, grid, fila, columna, modificadores):
alm = self.liMoves[fila]["alm"]
if not alm or len(alm.LIALMS) < 2:
return
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
for ralm in alm.LIALMS:
menu.opcion(ralm, Partida.pv_pgn(None, ralm.PV), rondo.otro())
menu.separador()
resp = menu.lanza()
if resp:
self.liMoves[fila]["pv"] = resp.PV
self.cambiaInfoMove()
def nuevo(self):
menu = QTVarios.LCMenu(self)
menu.opcion(("engine", None), _("Engine"), Iconos.Motor())
menu.separador()
submenu = menu.submenu(_("Polyglot book"), Iconos.Book())
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
rondo = QTVarios.rondoPuntos()
for book in list_books.lista:
submenu.opcion(("book", book), book.name, rondo.otro())
submenu.separador()
submenu.opcion(("installbook", None), _("Install new book"),
Iconos.Nuevo())
menu.separador()
si_gaviota = True
si_index = True
for kib in self.kibitzers.lista:
if kib.tipo == Kibitzers.KIB_GAVIOTA:
si_gaviota = False
elif kib.tipo == Kibitzers.KIB_INDEXES:
si_index = False
if si_index:
menu.opcion(("index", None),
_("Indexes") + " - RodentII", Iconos.Camara())
menu.separador()
if si_gaviota:
menu.opcion(("gaviota", None), _("Gaviota Tablebases"),
Iconos.Finales())
resp = menu.lanza()
if resp:
orden, extra = resp
if orden == "engine":
self.nuevo_engine()
elif orden in "book":
num = self.kibitzers.nuevo_polyglot(extra)
self.goto(num)
elif orden == "gaviota":
num = self.kibitzers.nuevo_gaviota()
self.goto(num)
elif orden == "index":
num = self.kibitzers.nuevo_index()
self.goto(num)
elif orden in "installbook":
self.polyglot_install(list_books)
def grid_right_button(self, grid, row, column, modificadores):
if self.siFilaTotales(row):
return
alm = self.liMoves[row]["rec"]
if not alm or len(alm.LIALMS) < 2:
return
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
for ralm in alm.LIALMS:
menu.opcion(ralm, Game.pv_pgn(None, ralm.PV), rondo.otro())
menu.separador()
resp = menu.lanza()
if resp:
self.actualizaPV(resp.PV)
def config(self):
menu = QTVarios.LCMenu(self)
smenu = menu.submenu(_("Change the unit of measurement"), Iconos.Measure())
is_miles = self.route.is_miles
dico = {True: Iconos.Aceptar(), False: Iconos.PuntoVerde()}
dkey = {True: None, False: "k"}
smenu.opcion(dkey[not is_miles], _("Kilometres"), dico[not is_miles], siDeshabilitado=not is_miles)
smenu.opcion(dkey[is_miles], _("Miles (internally works in km)"), dico[is_miles], siDeshabilitado=is_miles)
menu.separador()
smenu = menu.submenu(_("Tactics"), Iconos.Tacticas())
dkey = {True: None, False: "g"}
go_fast = self.route.go_fast
smenu.opcion(dkey[not go_fast], _("Stop after solve"), dico[not go_fast], siDeshabilitado=not go_fast)
smenu.opcion(dkey[go_fast], _("Jump to the next after solve"), dico[go_fast], siDeshabilitado=go_fast)
if self.route.km:
menu.separador()
menu.opcion("rst", _("Return to the starting point"), Iconos.Delete())
menu.separador()
smenu = menu.submenu(_("Change level"), Iconos.Modificar())
rondo = QTVarios.rondoPuntos()
level = self.route.level
for lv in range(1,6):
if lv != level:
smenu.opcion("l%d" % lv, "%s %d" % (_("Level"), lv), rondo.otro())
resp = menu.lanza()
if resp:
if resp == "rst":
if QTUtil2.pregunta(self, _("Are you sure?")):
self.route.reset()
else:
return
elif resp == "k":
self.route.change_measure()
elif resp == "g":
self.route.change_go_fast()
return
elif resp.startswith("l"):
if QTUtil2.pregunta(self, _("Change level") + "\n" + _("Are you sure?")):
self.route.write_with_level()
n = int(resp[1])
self.route.set_level(n)
self.reject()
train_train(self.procesador)
def tacticas(self, tipo, name, carpeta, ini):
dic_training = TrListas.dicTraining()
um = self.procesador.unMomento()
tacticas = Tactics.Tactics(tipo, name, carpeta, ini)
liMenus = tacticas.listaMenus()
if len(liMenus) == 0:
um.final()
return
nico = QTVarios.rondoPuntos()
if len(liMenus) > 1:
menu = QTVarios.LCMenu(self.parent)
menu.opcion(None, _SP(name), Iconos.Tacticas())
menu.separador()
dmenu = {}
for valor, lista in liMenus:
actmenu = menu
if len(lista) > 1:
t = ""
for x in range(len(lista) - 1):
t += "|%s" % lista[x]
if not (t in dmenu):
v_trad = dic_training.get(lista[x], lista[x])
dmenu[t] = actmenu.submenu(v_trad, nico.otro())
actmenu.separador()
actmenu = dmenu[t]
actmenu.opcion(valor, dic_training.get(lista[-1], lista[-1]),
nico.otro())
actmenu.separador()
um.final()
resp = menu.lanza()
else:
resp = liMenus[0][0]
if not resp:
um.final()
return
tactica = tacticas.eligeTactica(resp,
self.configuration.carpeta_results)
um.final()
if tactica:
self.entrenaTactica(tactica)
def importar(self):
menu = QTVarios.LCMenu(self)
lista = Code.configuration.comboMotores()
nico = QTVarios.rondoPuntos()
for name, key in lista:
menu.opcion(key, name, nico.otro())
resp = menu.lanza()
if not resp:
return
me = Code.configuration.buscaRival(resp)
w = WEngine(self, self.lista_motores, me)
if w.exec_():
self.lista_motores.append(me)
self.grid.refresh()
self.grid.gobottom(0)
self.grabar()
def change(self, event):
rondo = QTVarios.rondoPuntos()
menu = QTVarios.LCMenuPiezas(self)
dsubmenus = {"Q": [], "R": [], "B": [], "N": [], "P": [], "k": []}
for key in self.db.keylist(self.db.examples_auto, True):
dsubmenus[key[1]].append(key)
for key, li in dsubmenus.items():
if li:
submenu = menu.submenu("K" + key, rondo.otro())
for keymenu in li:
submenu.opcion(keymenu, keymenu, rondo.otro())
resp = menu.lanza()
if resp:
self.set_key(resp)
self.tablero.activaColor(self.game.last_position.is_white)
def tacticas(self, tipo, nombre, carpeta, ini):
um = self.procesador.unMomento()
tacticas = Tacticas.Tacticas(tipo, nombre, carpeta, ini)
liMenus = tacticas.listaMenus()
if len(liMenus) == 0:
um.final()
return
nico = QTVarios.rondoPuntos()
if len(liMenus) > 1:
menu = QTVarios.LCMenu(self.parent)
menu.opcion(None, _SP(nombre), Iconos.Tacticas())
menu.separador()
dmenu = {}
for valor, lista in liMenus:
actmenu = menu
if len(lista) > 1:
t = ""
for x in range(len(lista) - 1):
t += "|%s" % lista[x]
if t not in dmenu:
dmenu[t] = actmenu.submenu(_SP(lista[x]),
nico.otro())
actmenu.separador()
actmenu = dmenu[t]
actmenu.opcion(valor, _SP(lista[-1]), nico.otro())
actmenu.separador()
um.final()
resp = menu.lanza()
else:
resp = liMenus[0][0]
if not resp:
um.final()
return
tactica = tacticas.eligeTactica(resp)
um.final()
if tactica:
self.entrenaTactica(tactica)
def enImportar(self):
menu = QTVarios.LCMenu(self)
lista = VarGen.configuracion.comboMotoresCompleto()
nico = QTVarios.rondoPuntos()
for nombre, clave in lista:
menu.opcion(clave, nombre, nico.otro())
resp = menu.lanza()
if not resp:
return
me = Torneo.Engine()
me.ponHuella(self.torneo.liEngines())
me.leerConfigEngine(resp)
self.torneo.appendEngine(me)
self.gridEnginesAlias.refresh()
self.gridEnginesAlias.gobottom(0)
self.borraResult()
def enImportar(self):
menu = QTVarios.LCMenu(self)
lista = self.configuracion.comboMotoresCompleto()
nico = QTVarios.rondoPuntos()
for nombre, clave in lista:
menu.opcion(clave, nombre, nico.otro())
resp = menu.lanza()
if not resp:
return
me = Torneo.Engine()
me.ponHuella(self.torneo.liEngines())
me.leerConfigEngine(resp)
self.torneo.appendEngine(me)
self.gridEnginesAlias.refresh()
self.gridEnginesAlias.gobottom(0)
self.borraResult()
def tacticas(self, tipo, nombre, carpeta, ini):
um = self.procesador.unMomento()
tacticas = Tacticas.Tacticas(tipo, nombre, carpeta, ini)
liMenus = tacticas.listaMenus()
if len(liMenus) == 0:
um.final()
return
nico = QTVarios.rondoPuntos()
if len(liMenus) > 1:
menu = QTVarios.LCMenu(self.parent)
menu.opcion(None, _SP(nombre), Iconos.Tacticas())
menu.separador()
dmenu = {}
for valor, lista in liMenus:
actmenu = menu
if len(lista) > 1:
t = ""
for x in range(len(lista) - 1):
t += "|%s" % lista[x]
if t not in dmenu:
dmenu[t] = actmenu.submenu(_SP(lista[x]), nico.otro())
actmenu.separador()
actmenu = dmenu[t]
actmenu.opcion(valor, _SP(lista[-1]), nico.otro())
actmenu.separador()
um.final()
resp = menu.lanza()
else:
resp = liMenus[0][0]
if not resp:
um.final()
return
tactica = tacticas.eligeTactica(resp)
um.final()
if tactica:
self.entrenaTactica(tactica)
def importar(self):
menu = QTVarios.LCMenu(self)
lista = VarGen.configuracion.comboMotores()
nico = QTVarios.rondoPuntos()
for nombre, clave in lista:
menu.opcion(clave, nombre, nico.otro())
resp = menu.lanza()
if not resp:
return
cm = VarGen.configuracion.buscaRival(resp)
me = MotoresExternos.MotorExterno()
me.exe = cm.ejecutable()
me.alias = cm.clave
me.idName = cm.nombre
me.nombre = cm.nombre
me.clave = cm.clave
me.idAuthor = cm.autor
me.idInfo = ""
me.liOpciones = []
me.maxMultiPV = cm.maxMultiPV
me.multiPV = cm.multiPV
me.elo = cm.elo
me.leerUCI(me.exe)
for op in me.liOpciones:
for comando, valor in cm.liUCI:
if op.nombre == comando:
if op.tipo == "check":
op.valor = valor.lower() == "true"
elif op.tipo == "spin":
op.valor = int(valor)
else:
op.valor = valor
break
w = WMotor(self, self.listaMotores, me)
if w.exec_():
self.listaMotores.nuevo(me)
self.grid.refresh()
self.grid.gobottom(0)
self.grabar()
def import_examples(self):
rondo = QTVarios.rondoPuntos()
menu = QTVarios.LCMenuPiezas(self)
dsubmenus = {"Q": [], "R": [], "B": [], "N": [], "P": [], "k": []}
for key in self.db.keylist(examples=True, own=False):
dsubmenus[key[1]].append(key)
for key, li in dsubmenus.items():
if li:
submenu = menu.submenu("K" + key, rondo.otro())
for keymenu in li:
submenu.opcion(keymenu, keymenu, rondo.otro())
key = menu.lanza()
if key:
num = self.db.add_examples(key)
self.key = key
self.mensaje_import(num)
self.set_key(self.key)
self.tablero.activaColor(self.game.last_position.is_white)
def enImportar(self):
menu = QTVarios.LCMenu(self)
lista = self.configuracion.comboMotores()
nico = QTVarios.rondoPuntos()
for name, clave in lista:
menu.opcion(clave, name, nico.otro())
resp = menu.lanza()
if not resp:
return
me = Tournament.EngineTournament()
me.pon_huella(self.torneo)
me.read_exist_engine(resp)
self.torneo.save_engine(me)
self.gridEnginesAlias.refresh()
self.gridEnginesAlias.gobottom(0)
self.gridResults.refresh()
self.rotulos_tabs()
def creaMenu(self):
dicMenu = {}
menu = QTVarios.LCMenu(self.parent)
def xopcion(menu, clave, texto, icono, siDeshabilitado=False):
menu.opcion(clave, texto, icono, siDeshabilitado)
dicMenu[clave] = (clave, texto, icono, siDeshabilitado )
# Posiciones de entrenamiento --------------------------------------------------------------------------
self.menuFNS(menu, _("Training positions"), xopcion)
menu.separador()
# GM ---------------------------------------------------------------------------------------------------
xopcion(menu, "gm", _("Play like a grandmaster"), Iconos.GranMaestro())
menu.separador()
# Mate --------------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Training mates"), Iconos.Mate())
for mate in range(1, 5):
xopcion(menu1, "mate%d" % mate, _X(_("Mate in %1"), str(mate)), Iconos.PuntoAzul())
menu1.separador()
menu.separador()
# BMT -------------------------------------------------------------------------------------------
xopcion(menu, "bmt", _("Find best move"), Iconos.BMT())
menu.separador()
# Openings ------------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Openings"), Iconos.Aperturas())
# # Aperturas --------------------------------------------------------------------------------------------
xopcion(menu1, "aperturas", _("Learn openings by repetition"), Iconos.Apertura())
menu1.separador()
## Books ------------------------------------------------------------------------------------------------
xopcion(menu1, "polyglot", _("Training with a book"), Iconos.Libros())
menu.separador()
# DailyTest ------------------------------------------------------------------------------------------------
xopcion(menu, "dailytest", _("Your daily test"), Iconos.DailyTest())
menu.separador()
# Resistencia ------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Resistance Test"), Iconos.Resistencia())
nico = Util.Rondo(Iconos.Verde(), Iconos.Azul(), Iconos.Amarillo(), Iconos.Naranja())
xopcion(menu1, "boxing", _("Normal"), nico.otro())
xopcion(menu1, "boxingc", _("Blindfold chess"), nico.otro())
xopcion(menu1, "boxingp1", _("Hide only our pieces"), nico.otro())
xopcion(menu1, "boxingp2", _("Hide only opponent pieces"), nico.otro())
menu.separador()
# Tacticas ---------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Learn tactics by repetition"), Iconos.Tacticas())
nico = Util.Rondo(Iconos.Amarillo(), Iconos.Naranja(), Iconos.Verde(), Iconos.Azul(), Iconos.Magenta())
dicTraining = TrListas.dicTraining()
def trTraining(txt):
return dicTraining.get(txt, txt)
def menuTacticas(tipo, carpetaBase):
lista = []
if os.path.isdir(carpetaBase):
li = Util.listdir(carpetaBase)
for nombre in li:
carpeta = os.path.join(carpetaBase, nombre)
ini = os.path.join(carpeta, "Config.ini")
if os.path.isdir(carpeta) and os.path.isfile(ini):
xopcion(menu1, "tactica|%s|%s|%s|%s" % (tipo, nombre, carpeta, ini), trTraining(nombre),
nico.otro())
menu1.separador()
lista.append((carpeta, nombre))
return lista
menuTacticas("B", "Tactics")
carpetaTacticasP = os.path.join(self.configuracion.dirPersonalTraining, "Tactics")
lista = menuTacticas("P", carpetaTacticasP)
if lista:
ico = Iconos.Delete()
menub = menu1.submenu(_("Remove"), ico)
for carpeta, nombre in lista:
xopcion(menub, "remtactica|%s|%s" % (carpeta, nombre), trTraining(nombre), ico)
menu.separador()
# Maps ----------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Training on a map"), Iconos.Maps())
xopcion(menu1, "map_Africa", _("Africa map"), Iconos.Africa())
menu1.separador()
xopcion(menu1, "map_WorldMap", _("World map"), Iconos.WorldMap())
# Cebras ---------------------------------------------------------------------------------------------------
menu.separador()
menu1 = menu.submenu(_("Resources for zebras"), Iconos.Cebra())
menu2 = menu1.submenu(_("Check your memory on a chessboard"), Iconos.Memoria())
rival = self.configuracion.rival
mem = Memoria.Memoria(self.procesador)
for x in range(6):
cat = rival.categorias.numero(x)
txt = cat.nombre()
nm = mem.nivel(x)
if nm > -1:
txt += " %s %d" % (_("Level"), nm + 1)
xopcion(menu2, -100 - x, txt, cat.icono(), siDeshabilitado=not mem.siActiva(x))
menu1.separador()
menu2 = menu1.submenu(_("Find all moves"), Iconos.J60())
xopcion(menu2, "j60_rival", _("Opponent"), Iconos.PuntoNaranja())
xopcion(menu2, "j60_jugador", _("Player"), Iconos.PuntoAzul())
menu1.separador()
self.horsesDef = hd = {
1: ( "N", "Alpha", _("Basic test") ),
2: ( "p", "Fantasy", _("Four pawns test") ),
3: ( "Q", "Pirat", _("Jonathan Levitt test") ),
4: ( "n", "Spatial", _("Basic test") + ": a1" ),
5: ( "N", "Cburnett", _("Basic test") + ": e4" )
}
menu2 = menu1.submenu(_("Becoming a knight tamer"), self.procesador.tablero.piezas.icono("N"))
vicon = VarGen.todasPiezas.icono
icl, icn, tit = hd[1]
menu3 = menu2.submenu(tit, vicon(icl, icn))
xopcion(menu3, "horses_1", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[4]
xopcion(menu3, "horses_4", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[5]
xopcion(menu3, "horses_5", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[2]
xopcion(menu2, "horses_2", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[3]
xopcion(menu2, "horses_3", tit, vicon(icl, icn))
menu1.separador()
menu2 = menu1.submenu(_("Moves between two positions"), Iconos.Puente())
rp = QTVarios.rondoPuntos()
for x in range(1, 11):
xopcion(menu2, "puente_%d" % x, "%s %d" % (_("Level"), x), rp.otro())
menu1.separador()
xopcion(menu1, "potencia", _("Determine your calculating power"), Iconos.Potencia())
menu1.separador()
xopcion(menu1, "learnPGN", _("Learn a game"), Iconos.PGN())
menu1.separador()
xopcion(menu1, "visualiza", _("The board at a glance"), Iconos.Gafas())
# Ratings
menu.separador()
menu1 = menu.submenu(_("Training ratings"), Iconos.Elo())
xopcion(menu1, "lucaselo", "%s (%d)" % (_("Lucas-Elo"), self.configuracion.eloNC), Iconos.Elo())
menu1.separador()
xopcion(menu1, "micelo", "%s (%d)" % (_("Tourney-Elo"), self.configuracion.micheloNC), Iconos.EloTimed())
menu1.separador()
fics = self.configuracion.ficsNC
menuf = menu1.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <= (fics - elo) <= 400):
xopcion(menuf, "fics%d" % (elo / 100,), "%d-%d" % (elo, elo + 99), rp.otro())
menu1.separador()
fide = self.configuracion.fideNC
menuf = menu1.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
rp = QTVarios.rondoPuntos()
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <= (fide - elo) <= 400):
xopcion(menuf, "fide%d" % (elo / 100,), "%d-%d" % (elo, elo + 99), rp.otro())
return menu, dicMenu
def lanzaGUI(procesador):
"""
Lanzador del interfaz grafico de la aplicacion.
"""
# Comprobamos el lenguaje
app = QtGui.QApplication([])
liUsuarios = Usuarios.Usuarios().lista
usuario = None
if liUsuarios:
usuario = pideUsuario(liUsuarios)
if usuario is None:
return
user = str(usuario.numero) if usuario.numero else ""
else:
user = ""
activeFolder = Configuracion.activeFolder()
siPedirLenguaje = not os.path.isdir(activeFolder) or not os.listdir(
activeFolder)
procesador.iniciaConUsuario(user)
configuracion = procesador.configuracion
if usuario:
if not configuracion.jugador:
configuracion.jugador = usuario.nombre
configuracion.graba()
elif configuracion.jugador != usuario.nombre:
for usu in liUsuarios:
if usu.numero == usuario.numero:
usu.nombre = configuracion.jugador
Usuarios.Usuarios().guardaLista(liUsuarios)
# Comprobamos el lenguaje
if siPedirLenguaje and not configuracion.traductor:
if user:
confMain = Configuracion.Configuracion("")
ori = confMain.ficheroMExternos
confMain.lee()
confMain.limpia(usuario.nombre)
confMain.ponCarpetas(user)
confMain.graba()
procesador.configuracion = confMain
Util.copiaFichero(ori, confMain.carpeta)
else:
li = configuracion.listaTraducciones()
menu = QTVarios.LCMenu(None)
nico = QTVarios.rondoPuntos()
for k, nombre, porc, author in li:
rotulo = nombre
if porc != "100":
rotulo += " (%s%%)" % porc
menu.opcion(k, nombre, nico.otro())
resp = menu.lanza()
if resp:
configuracion.traductor = resp
configuracion.graba()
# Estilo
app.setStyle(QtGui.QStyleFactory.create(configuracion.estilo))
if configuracion.palette:
qpalette = QtGui.QPalette()
palette = configuracion.palette
def cl(tipo):
return QtGui.QColor(palette[tipo])
qpalette.setColor(QtGui.QPalette.Window, cl("Window"))
qpalette.setColor(QtGui.QPalette.WindowText, cl("WindowText"))
qpalette.setColor(QtGui.QPalette.Base, cl("Base"))
qpalette.setColor(QtGui.QPalette.Text, cl("Text"))
qpalette.setColor(QtGui.QPalette.AlternateBase, cl("AlternateBase"))
qpalette.setColor(QtGui.QPalette.ToolTipBase, cl("ToolTipBase"))
qpalette.setColor(QtGui.QPalette.ToolTipText, cl("ToolTipText"))
qpalette.setColor(QtGui.QPalette.Button, cl("Button"))
qpalette.setColor(QtGui.QPalette.ButtonText, cl("ButtonText"))
qpalette.setColor(QtGui.QPalette.BrightText, cl("BrightText"))
qpalette.setColor(QtGui.QPalette.Link, cl("Link"))
else:
qpalette = QtGui.QApplication.style().standardPalette()
app.setPalette(qpalette)
app.setEffectEnabled(QtCore.Qt.UI_AnimateMenu)
# QtGui.QFontDatabase.addApplicationFont('IntFiles/ChessAlpha2.ttf') # TODO
if configuracion.familia:
font = Controles.TipoLetra(configuracion.familia)
app.setFont(font)
VarGen.gc = QTUtil.GarbageCollector()
# Lanzamos la pantalla
procesador.iniciarGUI()
resp = app.exec_()
return resp
def menu(self, parent):
menu = QTVarios.LCMenu(parent)
rp = QTVarios.rondoPuntos(False)
rc = QTVarios.rondoColores(False)
submenu = menu.submenu(_("Internal engines"), self.dicIconos[INTERNO])
li_m_i = sorted(self.liMotoresInternos, key=lambda x: x.elo)
def haz(from_sq, to_sq, rotulo):
smn = None
for cm in li_m_i:
elo = cm.elo
if from_sq < elo <= to_sq:
if smn is None:
smn = submenu.submenu(rotulo, rc.otro())
clave = INTERNO, cm
texto = cm.name
icono = rp.otro()
smn.opcion(clave, "%s (%d)" % (texto, elo), icono)
haz(0, 1500, _("Up to 1500"))
haz(1500, 2000, "1500 - 2000")
haz(2000, 2500, "2000 - 2500")
haz(2500, 2750, "2500 - 2750")
haz(2750, 3000, "2750 - 3000")
haz(3000, 3500, _("Above 3000"))
menu.separador()
submenu = menu.submenu(_("External engines"), self.dicIconos[EXTERNO])
for cm in self.liMotoresExternos:
clave = EXTERNO, cm
texto = cm.clave
icono = rp.otro()
submenu.opcion(clave, texto, icono)
submenu.separador()
clave = EXTERNO, None
texto = _("Edition")
icono = Iconos.Mas()
submenu.opcion(clave, texto, icono)
menu.separador()
submenu = menu.submenu(_("GM engines"), self.dicIconos[MICGM])
for cm in self.liMotoresGM:
icono = rp.otro()
clave = MICGM, cm
texto = Util.primera_mayuscula(cm.name)
submenu.opcion(clave, texto, icono)
submenu.separador()
menu.separador()
menu.opcion((MICPER, None), _("Tourney engines"), self.dicIconos[MICPER])
menu.separador()
submenu = menu.submenu(_("Engines with fixed elo"), self.dicIconos[FIXED])
li = sorted(self.dict_engines_fixed_elo.keys())
for elo in li:
icono = rp.otro()
submenuElo = submenu.submenu(str(elo), icono)
lien = self.dict_engines_fixed_elo[elo]
lien.sort(key=lambda x: x.name)
for cm in lien:
clave = FIXED, cm
texto = cm.name
submenuElo.opcion(clave, texto, icono)
submenuElo.separador()
menu.separador()
menu1 = menu.submenu(_("Opponents for young players"), Iconos.RivalesMP())
for cm in self.liIrina:
menu1.opcion((IRINA, cm), cm.name, cm.icono)
menu.separador()
li_cortes = []
n = 19
pos = -1
for cm in self.liElo:
if n == 19:
li_cortes.append([])
pos += 1
n = 0
li_cortes[pos].append(cm)
n += 1
menu1 = menu.submenu(_("Lucas-Elo"), Iconos.Elo())
for li_corte in li_cortes:
from_sq = li_corte[0].elo
to_sq = li_corte[-1].elo
smenu = menu1.submenu("%d - %d" % (from_sq, to_sq), rc.otro())
for cm in li_corte:
smenu.opcion((ELO, cm), cm.name, rp.otro())
return menu.lanza()
def create_menu_basic(self, menu, xopcion):
menu.separador()
menu_basic = menu.submenu(_("Basics"), Iconos.Training_Basic())
menu2 = menu_basic.submenu(_("Check your memory on a chessboard"),
Iconos.Memoria())
mem = Memory.Memoria(self.procesador)
categorias = CompetitionWithTutor.Categorias()
for x in range(6):
cat = categorias.number(x)
txt = cat.name()
nm = mem.nivel(x)
if nm >= 0:
txt += " %s %d" % (_("Level"), nm + 1)
xopcion(menu2,
-100 - x,
txt,
cat.icono(),
is_disabled=not mem.is_active(x))
menu_basic.separador()
menu2 = menu_basic.submenu(_("Find all moves"), Iconos.FindAllMoves())
xopcion(menu2, "find_all_moves_rival", _("Opponent"),
Iconos.PuntoNaranja())
xopcion(menu2, "find_all_moves_player", _("Player"),
Iconos.PuntoAzul())
menu_basic.separador()
self.horsesDef = hd = {
1: ("N", "Alpha", _("Basic test")),
2: ("p", "Fantasy", _("Four pawns test")),
3: ("Q", "Pirat", _("Jonathan Levitt test")),
4: ("n", "Spatial", _("Basic test") + ": a1"),
5: ("N", "Cburnett", _("Basic test") + ": e4"),
}
menu2 = menu_basic.submenu(_("Becoming a knight tamer"),
Iconos.Knight())
vicon = Code.todasPiezas.icono
icl, icn, tit = hd[1]
menu3 = menu2.submenu(tit, vicon(icl, icn))
xopcion(menu3, "horses_1", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[4]
xopcion(menu3, "horses_4", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[5]
xopcion(menu3, "horses_5", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[2]
xopcion(menu2, "horses_2", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[3]
xopcion(menu2, "horses_3", tit, vicon(icl, icn))
menu_basic.separador()
menu2 = menu_basic.submenu(_("Moves between two positions"),
Iconos.Puente())
rp = QTVarios.rondoPuntos()
for x in range(1, 11):
xopcion(menu2, "puente_%d" % x, "%s %d" % (_("Level"), x),
rp.otro())
menu_basic.separador()
xopcion(menu_basic, "visualiza", _("The board at a glance"),
Iconos.Gafas())
menu_basic.separador()
menu2 = menu_basic.submenu(_("Coordinates"), Iconos.Coordinates())
xopcion(menu2, "coordinates_basic", _("Basic"), Iconos.West())
menu2.separador()
xopcion(menu2, "coordinates_blocks", _("By blocks"), Iconos.Blocks())
menu_basic.separador()
xopcion(menu_basic, "anotar", _("Writing down moves of a game"),
Iconos.Write())
def creaMenu(self):
dicMenu = {}
menu = QTVarios.LCMenu(self.parent)
def xopcion(menu, clave, texto, icono, siDeshabilitado=False):
menu.opcion(clave, texto, icono, siDeshabilitado)
dicMenu[clave] = (clave, texto, icono, siDeshabilitado)
# Posiciones de entrenamiento --------------------------------------------------------------------------
self.menuFNS(menu, _("Training positions"), xopcion)
menu.separador()
# GM ---------------------------------------------------------------------------------------------------
xopcion(menu, "gm", _("Play like a grandmaster"), Iconos.GranMaestro())
menu.separador()
# Mate --------------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Training mates"), Iconos.Mate())
for mate in range(1, 5):
xopcion(menu1, "mate%d" % mate, _X(_("Mate in %1"), str(mate)),
Iconos.PuntoAzul())
menu1.separador()
menu.separador()
# BMT -------------------------------------------------------------------------------------------
xopcion(menu, "bmt", _("Find best move"), Iconos.BMT())
menu.separador()
# Resistencia ------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Resistance Test"), Iconos.Resistencia())
nico = Util.Rondo(Iconos.Verde(), Iconos.Azul(), Iconos.Amarillo(),
Iconos.Naranja())
xopcion(menu1, "resistance", _("Normal"), nico.otro())
xopcion(menu1, "resistancec", _("Blindfold chess"), nico.otro())
xopcion(menu1, "resistancep1", _("Hide only our pieces"), nico.otro())
xopcion(menu1, "resistancep2", _("Hide only opponent pieces"),
nico.otro())
menu.separador()
# DailyTest ------------------------------------------------------------------------------------------------
xopcion(menu, "dailytest", _("Your daily test"), Iconos.DailyTest())
menu.separador()
# Tacticas ---------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Learn tactics by repetition"),
Iconos.Tacticas())
nico = Util.Rondo(Iconos.Amarillo(), Iconos.Naranja(), Iconos.Verde(),
Iconos.Azul(), Iconos.Magenta())
dicTraining = TrListas.dicTraining()
def trTraining(txt):
return dicTraining.get(txt, txt)
def menuTacticas(tipo, carpetaBase):
lista = []
if os.path.isdir(carpetaBase):
li = Util.listdir(carpetaBase)
for nombre in li:
carpeta = os.path.join(carpetaBase, nombre)
ini = os.path.join(carpeta, "Config.ini")
if os.path.isdir(carpeta) and os.path.isfile(ini):
xopcion(
menu1, "tactica|%s|%s|%s|%s" %
(tipo, nombre, carpeta, ini), trTraining(nombre),
nico.otro())
menu1.separador()
lista.append((carpeta, nombre))
return lista
menuTacticas("B", "Tactics")
carpetaTacticasP = os.path.join(self.configuracion.dirPersonalTraining,
"Tactics")
lista = menuTacticas("P", carpetaTacticasP)
if lista:
ico = Iconos.Delete()
menub = menu1.submenu(_("Remove"), ico)
for carpeta, nombre in lista:
xopcion(menub, "remtactica|%s|%s" % (carpeta, nombre),
trTraining(nombre), ico)
menu.separador()
# Openings ------------------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Openings"), Iconos.Aperturas())
# # Aperturas --------------------------------------------------------------------------------------------
xopcion(menu1, "aperturas", _("Learn openings by repetition"),
Iconos.Apertura())
menu1.separador()
# Books ------------------------------------------------------------------------------------------------
xopcion(menu1, "polyglot", _("Training with a book"), Iconos.Libros())
# Ratings
menu.separador()
menu1 = menu.submenu(_("Training ratings"), Iconos.Elo())
xopcion(menu1, "lucaselo",
"%s (%d)" % (_("Lucas-Elo"), self.configuracion.eloNC),
Iconos.Elo())
menu1.separador()
xopcion(menu1, "micelo",
"%s (%d)" % (_("Tourney-Elo"), self.configuracion.micheloNC),
Iconos.EloTimed())
menu1.separador()
fics = self.configuracion.ficsNC
menuf = menu1.submenu("%s (%d)" % (_("Fics-Elo"), fics), Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <=
(fics - elo) <= 400):
xopcion(menuf, "fics%d" % (elo / 100, ),
"%d-%d" % (elo, elo + 99), rp.otro())
menu1.separador()
fide = self.configuracion.fideNC
menuf = menu1.submenu("%s (%d)" % (_("Fide-Elo"), fide), Iconos.Fide())
rp = QTVarios.rondoPuntos()
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <=
(fide - elo) <= 400):
xopcion(menuf, "fide%d" % (elo / 100, ),
"%d-%d" % (elo, elo + 99), rp.otro())
menu.separador()
# Longs ----------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Long-term trainings"), Iconos.Longhaul())
# Maps
menu2 = menu1.submenu(_("Training on a map"), Iconos.Maps())
xopcion(menu2, "map_Africa", _("Africa map"), Iconos.Africa())
menu2.separador()
xopcion(menu2, "map_WorldMap", _("World map"), Iconos.WorldMap())
# Rail
menu1.separador()
xopcion(menu1, "transsiberian", _("Transsiberian Railway"),
Iconos.Train())
# Everest
menu1.separador()
xopcion(menu1, "everest", _("Expeditions to the Everest"),
Iconos.Trekking())
# TOL
menu1.separador()
menu2 = menu1.submenu(_("Turn on the lights"), Iconos.TOL())
xopcion(menu2, "tol_uned", _("UNED chess school"), Iconos.Uned())
menu2.separador()
xopcion(menu2, "tol_uwe", _("Uwe Auerswald"), Iconos.Uwe())
# Washing
menu1.separador()
xopcion(menu1, "washing_machine", _("The Washing Machine"),
Iconos.WashingMachine())
# Cebras ---------------------------------------------------------------------------------------------------
menu.separador()
menu1 = menu.submenu(_("Resources for zebras"), Iconos.Cebra())
menu2 = menu1.submenu(_("Check your memory on a chessboard"),
Iconos.Memoria())
rival = self.configuracion.rival
mem = Memoria.Memoria(self.procesador)
for x in range(6):
cat = rival.categorias.numero(x)
txt = cat.nombre()
nm = mem.nivel(x)
if nm > -1:
txt += " %s %d" % (_("Level"), nm + 1)
xopcion(menu2,
-100 - x,
txt,
cat.icono(),
siDeshabilitado=not mem.siActiva(x))
menu1.separador()
menu2 = menu1.submenu(_("Find all moves"), Iconos.J60())
xopcion(menu2, "j60_rival", _("Opponent"), Iconos.PuntoNaranja())
xopcion(menu2, "j60_jugador", _("Player"), Iconos.PuntoAzul())
menu1.separador()
self.horsesDef = hd = {
1: ("N", "Alpha", _("Basic test")),
2: ("p", "Fantasy", _("Four pawns test")),
3: ("Q", "Pirat", _("Jonathan Levitt test")),
4: ("n", "Spatial", _("Basic test") + ": a1"),
5: ("N", "Cburnett", _("Basic test") + ": e4")
}
menu2 = menu1.submenu(_("Becoming a knight tamer"),
self.procesador.tablero.piezas.icono("N"))
vicon = VarGen.todasPiezas.icono
icl, icn, tit = hd[1]
menu3 = menu2.submenu(tit, vicon(icl, icn))
xopcion(menu3, "horses_1", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[4]
xopcion(menu3, "horses_4", tit, vicon(icl, icn))
menu3.separador()
icl, icn, tit = hd[5]
xopcion(menu3, "horses_5", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[2]
xopcion(menu2, "horses_2", tit, vicon(icl, icn))
menu2.separador()
icl, icn, tit = hd[3]
xopcion(menu2, "horses_3", tit, vicon(icl, icn))
menu1.separador()
menu2 = menu1.submenu(_("Moves between two positions"),
Iconos.Puente())
rp = QTVarios.rondoPuntos()
for x in range(1, 11):
xopcion(menu2, "puente_%d" % x, "%s %d" % (_("Level"), x),
rp.otro())
menu1.separador()
xopcion(menu1, "potencia", _("Determine your calculating power"),
Iconos.Potencia())
menu1.separador()
menu2 = menu1.submenu(_("Learn a game"), Iconos.School())
xopcion(menu2, "learnPGN", _("Memorizing their moves"),
Iconos.LearnGame())
menu2.separador()
xopcion(menu2, "playPGN", _("Playing against"), Iconos.Law())
menu1.separador()
xopcion(menu1, "visualiza", _("The board at a glance"), Iconos.Gafas())
# menu2 = menu1.submenu(_("Endings with 3/4 pieces"), Iconos.Puente())
# xopcion(menu2, "end_t4-1", "%s %d"%(_("Level"), 1), Iconos.PuntoAzul())
# xopcion(menu2, "end_t4-2", "%s %d"%(_("Level"), 2), Iconos.PuntoMagenta())
return menu, dicMenu
def menu(self, parent):
menu = Controles.Menu(parent)
rp = QTVarios.rondoPuntos()
submenu = menu.submenu(_("Internal engines"), self.dicIconos[INTERNO])
for cm in self.liMotoresInternos:
clave = INTERNO, cm
texto = cm.nombre
icono = rp.otro()
elo = cm.elo
submenu.opcion(clave, "%s (%d)" % (texto, elo), icono)
menu.separador()
submenu = menu.submenu(_("External engines"), self.dicIconos[EXTERNO])
for cm in self.liMotoresExternos:
clave = EXTERNO, cm
texto = cm.clave
icono = rp.otro()
submenu.opcion(clave, texto, icono)
submenu.separador()
clave = EXTERNO, None
texto = _("Edition")
icono = Iconos.Mas()
submenu.opcion(clave, texto, icono)
menu.separador()
submenu = menu.submenu(_("GM engines"), self.dicIconos[MICGM])
for cm in self.liMotoresGM:
icono = rp.otro()
clave = MICGM, cm
texto = cm.nombre
submenu.opcion(clave, texto, icono)
submenu.separador()
menu.separador()
menu.opcion((MICPER, None), _("Tourney engines"),
self.dicIconos[MICPER])
menu.separador()
submenu = menu.submenu(_("Engines with fixed elo"),
self.dicIconos[FIXED])
li = self.dicMotoresFixedElo.keys()
li.sort()
for elo in li:
icono = rp.otro()
submenuElo = submenu.submenu(str(elo), icono)
lien = self.dicMotoresFixedElo[elo]
lien.sort(key=lambda x: x.nombre)
for cm in lien:
clave = FIXED, cm
texto = cm.nombre
submenuElo.opcion(clave, texto, icono)
submenuElo.separador()
menu.separador()
menu1 = menu.submenu(_("Opponents for young players"),
Iconos.RivalesMP())
for cm in self.liIrina:
menu1.opcion((IRINA, cm), cm.nombre, cm.icono)
menu.separador()
menu1 = menu.submenu(_("Lucas-Elo"), Iconos.Elo())
ico = QTVarios.rondoPuntos()
limenus = []
for x in range(1000, 2250, 250):
limenus.append(menu1.submenu("%d - %d" % (x, x + 250), ico.otro()))
for cm in self.liElo:
submenu = limenus[cm.elo / 250 - 4]
submenu.opcion((ELO, cm), cm.nombre, ico.otro())
return menu.lanza()
def menuPlay(self):
menu = QTVarios.LCMenu(self.pantalla)
menu.opcion(("free", None), _("Play against an engine of your choice"),
Iconos.Libre())
menu.separador()
menu.opcion(("competition", None), _("Competition"),
Iconos.NuevaPartida())
menu.separador()
submenu = menu.submenu(_("Elo-Rating"), Iconos.Elo())
submenu.opcion(("lucaselo", 0),
"%s (%d)" % (_("Lucas-Elo"), self.configuracion.elo),
Iconos.Elo())
submenu.separador()
submenu.opcion(
("micelo", 0),
"%s (%d)" % (_("Tourney-Elo"), self.configuracion.michelo),
Iconos.EloTimed())
submenu.separador()
fics = self.configuracion.fics
menuf = submenu.submenu("%s (%d)" % (_("Fics-Elo"), fics),
Iconos.Fics())
rp = QTVarios.rondoPuntos()
for elo in range(900, 2800, 100):
if (elo == 900) or (0 <= (elo + 99 - fics) <= 400 or 0 <=
(fics - elo) <= 400):
menuf.opcion(("fics", elo / 100), "%d-%d" % (elo, elo + 99),
rp.otro())
submenu.separador()
fide = self.configuracion.fide
menuf = submenu.submenu("%s (%d)" % (_("Fide-Elo"), fide),
Iconos.Fide())
for elo in range(1500, 2700, 100):
if (elo == 1500) or (0 <= (elo + 99 - fide) <= 400 or 0 <=
(fide - elo) <= 400):
menuf.opcion(("fide", elo / 100), "%d-%d" % (elo, elo + 99),
rp.otro())
menu.separador()
# Principiantes ----------------------------------------------------------------------------------------
menu1 = menu.submenu(_("Opponents for young players"),
Iconos.RivalesMP())
for name, trans, ico in QTVarios.list_irina():
menu1.opcion(("person", name), trans, ico)
menu1.separador()
menu2 = menu1.submenu(_("Albums of animals"), Iconos.Penguin())
albumes = Albums.AlbumesAnimales()
dic = albumes.list_menu()
anterior = None
for animal in dic:
siDeshabilitado = False
if anterior and not dic[anterior]:
siDeshabilitado = True
menu2.opcion(("animales", animal),
_F(animal),
Iconos.icono(animal),
siDeshabilitado=siDeshabilitado)
anterior = animal
menu1.separador()
menu2 = menu1.submenu(_("Albums of vehicles"), Iconos.Wheel())
albumes = Albums.AlbumesVehicles()
dic = albumes.list_menu()
anterior = None
for character in dic:
siDeshabilitado = False
if anterior and not dic[anterior]:
siDeshabilitado = True
menu2.opcion(("vehicles", character),
_F(character),
Iconos.icono(character),
siDeshabilitado=siDeshabilitado)
anterior = character
resp = menu.lanza()
if resp:
tipo, rival = resp
if tipo == "free":
self.procesarAccion(k_libre)
elif tipo == "competition":
self.competicion()
elif tipo == "lucaselo":
self.lucaselo(True)
elif tipo == "micelo":
self.micelo(True)
elif tipo == "fics":
self.ficselo(True, rival)
elif tipo == "fide":
self.fideelo(True, rival)
elif tipo == "person":
self.playPerson(rival)
elif tipo == "animales":
self.albumAnimales(rival)
elif tipo == "vehicles":
self.albumVehicles(rival)
def lanzaGUI(procesador):
"""
Lanzador del interfaz grafico de la aplicacion.
"""
# Comprobamos el lenguaje
app = QtGui.QApplication([])
liUsuarios = Usuarios.listaUsuarios()
if liUsuarios:
usuario = pideUsuario(liUsuarios)
if usuario is None:
return
user = str(usuario.numero) if usuario.numero else ""
else:
user = ""
activeFolder = Configuracion.activeFolder()
siPedirLenguaje = not os.path.isdir(activeFolder) or not os.listdir(activeFolder)
procesador.iniciaConUsuario(user)
configuracion = procesador.configuracion
# Comprobamos el lenguaje
if siPedirLenguaje and not configuracion.traductor:
if user:
confMain = Configuracion.Configuracion("")
ori = confMain.ficheroMExternos
confMain.lee()
confMain.limpia(usuario.nombre)
confMain.ponCarpetas(user)
confMain.graba()
procesador.configuracion = confMain
Util.copiaFichero(ori, confMain.carpeta)
else:
li = configuracion.listaTraducciones()
menu = QTVarios.LCMenu(None)
nico = QTVarios.rondoPuntos()
for k, nombre, porc in li:
rotulo = nombre
if porc != "100":
rotulo += " (%s%%)"%porc
menu.opcion(k, nombre, nico.otro())
resp = menu.lanza()
if resp:
configuracion.traductor = resp
configuracion.graba()
# Estilo
global stylename
styleName = configuracion.estilo
app.setStyle(QtGui.QStyleFactory.create(styleName))
app.setPalette(QtGui.QApplication.style().standardPalette())
app.setEffectEnabled(QtCore.Qt.UI_AnimateMenu)
if configuracion.familia:
font = Controles.TipoLetra(configuracion.familia)
app.setFont(font)
VarGen.gc = QTUtil.GarbageCollector()
# Lanzamos la pantalla
procesador.iniciarGUI()
resp = app.exec_()
Voice.runVoice.close()
return resp
