def __init__(self, carpeta):
dicTraining = TrListas.dicTraining()
def trTraining(txt):
return dicTraining.get(txt, txt)
self.tr = trTraining
self.name = trTraining(os.path.basename(carpeta))
self.read(carpeta)
def __init__(self, carpeta):
dicTraining = TrListas.dicTraining()
def trTraining(txt):
return dicTraining.get(txt, txt)
self.tr = trTraining
self.name = trTraining(os.path.basename(carpeta))
self.read(carpeta)
def basadoEn(self):
fich = self.configNivel.fichero[:-4]
li = fich.split("/" if "/" in fich else "\\")
d = TrListas.dicTraining()
base = li[1]
txt = d.get(base, _F(base))
if len(li) == 3:
fich = li[2]
txt += ", " + d.get(fich, _F(fich))
return txt
def lanza(self, siFavoritos=True):
self.comprueba()
liFavoritos = None
if siFavoritos:
liFav = self.procesador.configuracion.liFavoritos
if liFav:
li = []
for elem in liFav:
if elem in self.dicMenu:
li.append(self.dicMenu[elem])
liFavoritos = li
if liFavoritos:
menu = self.menuFavoritos(liFavoritos)
else:
menu = self.menu
resp = menu.lanza()
if resp:
if type(resp) == str:
if resp == "menu_global":
self.lanza(False)
elif resp == "gm":
self.entrenaGM()
elif resp.startswith("mate"):
self.jugarMate(int(resp[-1]))
elif resp == "bmt":
self.bmt()
elif resp == "polyglot":
self.entrenaBooks()
elif resp.startswith("resistance"):
self.resistance(resp[10:])
elif resp in ["j60_rival", "j60_jugador"]:
self.jugar60(resp == "j60_jugador")
elif resp == "aperturas":
self.aperturas()
elif resp == "dailytest":
self.dailyTest()
elif resp == "potencia":
self.potencia()
elif resp == "visualiza":
self.visualiza()
elif resp.startswith("tactica|"):
nada, tipo, nombre, carpeta, ini = resp.split("|")
self.tacticas(tipo, nombre, carpeta, ini)
elif resp.startswith("remtactica|"):
nada, carpeta, nombre = resp.split("|")
self.tacticaRemove(carpeta, nombre)
elif resp.startswith("puente_"):
self.puente(int(resp[7:]))
elif resp.startswith("horses_"):
test = int(resp[7])
icl, icn, tit = self.horsesDef[test]
icon = VarGen.todasPiezas.icono(icl, icn)
self.horses(test, tit, icon)
elif resp.startswith("ep_"):
um = self.procesador.unMomento()
entreno = resp[3:].replace("\\", "/")
if "/" in entreno:
dicTraining = TrListas.dicTraining()
titentreno = ""
for x in entreno[:-4].split("/")[1:]:
titentreno += dicTraining.get(x, x) + "/"
titentreno = titentreno[:-1]
with Util.OpenCodec(entreno) as f:
todo = f.read().strip()
liEntrenamientos = todo.split("\n")
nPosiciones = len(liEntrenamientos)
um.final()
if nPosiciones == 0:
return
elif nPosiciones == 1:
pos = 1
jump = False
else:
db = Util.DicSQL(self.configuracion.ficheroTrainings)
posUltimo = db[entreno]
if posUltimo is None:
posUltimo = 1
resp = DatosNueva.numPosicion(self.procesador.pantalla,
titentreno, nPosiciones,
posUltimo)
if resp is None:
return
pos, tipo, jump = resp
db.close()
if tipo.startswith("r"):
if tipo == "rk":
random.seed(pos)
random.shuffle(liEntrenamientos)
self.procesador.entrenaPos(pos, nPosiciones, titentreno,
liEntrenamientos, entreno, jump)
elif resp == "learnPGN":
self.learnPGN()
elif resp == "playPGN":
self.playPGN()
elif resp == "lucaselo":
self.procesador.lucaselo(False)
elif resp == "micelo":
self.procesador.micelo(False)
elif resp.startswith("fics"):
self.procesador.ficselo(False, int(resp[4:]))
elif resp.startswith("fide"):
self.procesador.fideelo(False, int(resp[4:]))
elif resp.startswith("map_"):
nada, mapa = resp.split("_")
self.procesador.trainingMap(mapa)
elif resp == "transsiberian":
self.procesador.showRoute()
elif resp == "everest":
self.everest()
elif resp.startswith("tol_"):
self.turn_on_lights(resp[4:])
elif resp == "washing_machine":
self.washing_machine()
else:
if resp <= -100:
self.menu = None # ya que puede cambiar y la etiqueta es diferente
mem = Memoria.Memoria(self.procesador)
mem.lanza(abs(resp) - 100)
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 inicio(self, posEntreno, numEntrenos, titEntreno, liEntrenos, siTutorActivado=None, jump=False):
if hasattr(self, "reiniciando"):
if self.reiniciando:
return
self.reiniciando = True
if siTutorActivado is None:
siTutorActivado = (VarGen.dgtDispatch is None) and self.configuracion.tutorActivoPorDefecto
self.posEntreno = posEntreno
self.guardaPosicion(posEntreno)
self.numEntrenos = numEntrenos
self.titEntreno = titEntreno
self.liEntrenos = liEntrenos
self.jump = jump
self.liHistorico = [self.posEntreno]
self.ayudas = 99999
fenInicial = self.liEntrenos[self.posEntreno - 1].strip()
self.fenInicial = fenInicial
self.rivalPensando = False
self.dicEtiquetasPGN = None
# Dirigido
etiDirigido = ""
self.siDirigido = False
self.siDirigidoSeguir = None
self.siDirigidoVariantes = False
siPartidaOriginal = False
if "|" in fenInicial:
li = fenInicial.split("|")
fenInicial = li[0]
if fenInicial.endswith(" 0"):
fenInicial = fenInicial[:-1] + "1"
nli = len(li)
if nli >= 2:
etiDirigido = li[1]
# # Solucion
if nli >= 3:
solucion = li[2]
if solucion:
self.dicDirigidoFen = PGN.leeEntDirigido(fenInicial, solucion)
self.siDirigido = self.dicDirigidoFen and len(self.dicDirigidoFen) > 0
## Partida original
if nli >= 4:
if nli > 4:
txt = "|".join(li[3:])
else:
txt = li[3]
txt = txt.replace("]", "]\n").replace(" [", "[")
pgn = PGN.UnPGN()
pgn.leeTexto(txt)
partida = pgn.partida
siEstaFen = False
njug = partida.numJugadas()
for n in range(njug - 1, -1, -1):
jg = partida.jugada(n)
if jg.posicion.fen() == fenInicial:
siEstaFen = True
if n + 1 != njug:
partida.liJugadas = partida.liJugadas[:n + 1]
partida.ultPosicion = jg.posicion.copia()
break
if siEstaFen:
siPartidaOriginal = True
self.partida = partida
self.pgn.partida = partida
self.dicEtiquetasPGN = pgn.dic
# if etiDirigido:
# etiDirigido += "<br>"
# for k, v in pgn.dic.iteritems():
# if k.upper() != "FEN":
# if etiDirigido:
# etiDirigido += "<br>"
# etiDirigido += "%s: <b>%s</b>"%(k,v)
cp = ControlPosicion.ControlPosicion()
cp.leeFen(fenInicial)
self.fen = fenInicial
siBlancas = cp.siBlancas
if not siPartidaOriginal:
self.partida.reset(cp)
self.partida.pendienteApertura = False
self.tipoJuego = kJugEntPos
self.siJuegaHumano = False
self.estado = kJugando
self.siJuegaPorMi = True
self.siJugamosConBlancas = siBlancas
self.siRivalConBlancas = not siBlancas
self.liVariantes = []
self.rmRival = None
self.siTutorActivado = siTutorActivado
self.pantalla.ponActivarTutor(self.siTutorActivado)
self.ayudasPGN = 0
liOpciones = [k_mainmenu, k_cambiar, k_reiniciar, k_atras]
if self.dicEtiquetasPGN:
liOpciones.append(k_pgnInformacion)
if self.numEntrenos > 1:
liOpciones.append(k_anterior)
liOpciones.append(k_siguiente)
liOpciones.extend((k_configurar, k_utilidades))
self.liOpcionesToolBar = liOpciones
self.pantalla.ponToolBar(liOpciones)
self.pantalla.activaJuego(True, False, siAyudas=False)
self.pantalla.quitaAyudas(False, False)
self.ponMensajero(self.mueveHumano)
self.ponPosicion(self.partida.ultPosicion)
self.mostrarIndicador(True)
self.ponPiezasAbajo(siBlancas)
titulo = "<b>%s</b>" % TrListas.dicTraining().get(self.titEntreno, self.titEntreno)
if etiDirigido:
titulo += "<br>%s" % etiDirigido
self.ponRotulo1(titulo)
self.ponRotulo2("%d / %d" % (posEntreno, numEntrenos))
self.pgnRefresh(True)
QTUtil.xrefreshGUI()
self.xrival = self.procesador.creaGestorMotor(self.configuracion.tutor, self.configuracion.tiempoTutor, None)
self.siAnalizadoTutor = False
self.ponPosicionDGT()
if siPartidaOriginal:
# self.ponteAlFinal()
self.repiteUltimaJugada()
self.reiniciando = False
self.rivalPensando = False
self.siguienteJugada()
def inicio(self,
posEntreno,
numEntrenos,
titEntreno,
liEntrenos,
siTutorActivado=None,
jump=False):
if hasattr(self, "reiniciando"):
if self.reiniciando:
return
self.reiniciando = True
if siTutorActivado is None:
siTutorActivado = (VarGen.dgtDispatch is None
) and self.configuracion.tutorActivoPorDefecto
self.posEntreno = posEntreno
self.guardaPosicion(posEntreno)
self.numEntrenos = numEntrenos
self.titEntreno = titEntreno
self.liEntrenos = liEntrenos
self.jump = jump
self.liHistorico = [self.posEntreno]
self.ayudas = 99999
fenInicial = self.liEntrenos[self.posEntreno - 1].strip()
self.fenInicial = fenInicial
self.rivalPensando = False
self.dicEtiquetasPGN = None
# Dirigido
etiDirigido = ""
self.siDirigido = False
self.siDirigidoSeguir = None
self.siDirigidoVariantes = False
siPartidaOriginal = False
if "|" in fenInicial:
li = fenInicial.split("|")
fenInicial = li[0]
if fenInicial.endswith(" 0"):
fenInicial = fenInicial[:-1] + "1"
nli = len(li)
if nli >= 2:
etiDirigido = li[1]
# # Solucion
if nli >= 3:
solucion = li[2]
if solucion:
self.dicDirigidoFenM2 = PGN.leeEntDirigidoM2(
fenInicial, solucion)
self.siDirigido = len(self.dicDirigidoFenM2) > 0
# Partida original
if nli >= 4:
if nli > 4:
txt = "|".join(li[3:])
else:
txt = li[3]
txt = txt.replace("]", "]\n").replace(" [", "[")
pgn = PGN.UnPGN()
pgn.leeTexto(txt)
partida = pgn.partida
siEstaFen = False
njug = partida.numJugadas()
for n in range(njug - 1, -1, -1):
jg = partida.jugada(n)
if jg.posicion.fen() == fenInicial:
siEstaFen = True
if n + 1 != njug:
partida.liJugadas = partida.liJugadas[:n +
1]
partida.ultPosicion = jg.posicion.copia()
break
if siEstaFen:
siPartidaOriginal = True
self.partida = partida
self.pgn.partida = partida
self.dicEtiquetasPGN = pgn.dic
# if etiDirigido:
# etiDirigido += "<br>"
# for k, v in pgn.dic.iteritems():
# if k.upper() != "FEN":
# if etiDirigido:
# etiDirigido += "<br>"
# etiDirigido += "%s: <b>%s</b>"%(k,v)
cp = ControlPosicion.ControlPosicion()
cp.leeFen(fenInicial)
self.fen = fenInicial
siBlancas = cp.siBlancas
if not siPartidaOriginal:
self.partida.reset(cp)
self.partida.pendienteApertura = False
self.tipoJuego = kJugEntPos
self.siJuegaHumano = False
self.estado = kJugando
self.siJuegaPorMi = True
self.siJugamosConBlancas = siBlancas
self.siRivalConBlancas = not siBlancas
self.liVariantes = []
self.rmRival = None
self.siTutorActivado = siTutorActivado
self.pantalla.ponActivarTutor(self.siTutorActivado)
self.ayudasPGN = 0
liOpciones = [k_mainmenu, k_cambiar, k_reiniciar, k_atras]
if self.dicEtiquetasPGN:
liOpciones.append(k_pgnInformacion)
liOpciones.extend((k_configurar, k_utilidades))
if self.numEntrenos > 1:
liOpciones.extend((k_anterior, k_siguiente))
self.liOpcionesToolBar = liOpciones
self.pantalla.ponToolBar(liOpciones)
self.pantalla.activaJuego(True, False, siAyudas=False)
self.pantalla.quitaAyudas(False, False)
self.ponMensajero(self.mueveHumano)
self.ponPosicion(self.partida.ultPosicion)
self.mostrarIndicador(True)
self.ponPiezasAbajo(siBlancas)
titulo = "<b>%s</b>" % TrListas.dicTraining().get(
self.titEntreno, self.titEntreno)
if etiDirigido:
titulo += "<br>%s" % etiDirigido
self.ponRotulo1(titulo)
self.ponRotulo2("%d / %d" % (posEntreno, numEntrenos))
self.pgnRefresh(True)
QTUtil.xrefreshGUI()
if self.xrival is None:
self.xrival = self.procesador.creaGestorMotor(
self.configuracion.tutor, self.configuracion.tiempoTutor,
self.configuracion.depthTutor)
self.siAnalizadoTutor = False
self.ponPosicionDGT()
if siPartidaOriginal:
# self.ponteAlFinal()
self.repiteUltimaJugada()
self.reiniciando = False
self.rivalPensando = False
self.siguienteJugada()
def create_menu_tactics(self, menu, xopcion):
menu.separador()
menu_tactics = menu.submenu(_("Tactics"), Iconos.Training_Tactics())
# Posiciones de entrenamiento --------------------------------------------------------------------------
self.menuFNS(menu_tactics, _("Training positions"), xopcion)
menu_tactics.separador()
# Tacticas ---------------------------------------------------------------------------------------------
menu_t = menu_tactics.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 menu_tacticas(submenu, tipo, carpeta_base, lista):
if os.path.isdir(carpeta_base):
for entry in os.scandir(carpeta_base):
if entry.is_dir():
carpeta = entry.path
ini = os.path.join(carpeta, "Config.ini")
if os.path.isfile(ini):
name = entry.name
xopcion(
submenu,
"tactica|%s|%s|%s|%s" %
(tipo, name, carpeta, ini),
trTraining(name),
nico.otro(),
)
menu_t.separador()
lista.append((carpeta, name))
else:
submenu1 = submenu.submenu(entry.name, nico.otro())
menu_tacticas(submenu1, tipo, carpeta, lista)
return lista
menu_tacticas(menu_t, TACTICS_BASIC, Code.path_resource("Tactics"), [])
lista = []
carpetaTacticasP = self.configuration.folder_tactics()
if os.path.isdir(carpetaTacticasP):
submenu1 = menu_t.submenu(_("Personal tactics"), nico.otro())
lista = menu_tacticas(submenu1, TACTICS_PERSONAL, carpetaTacticasP,
lista)
if lista:
ico = Iconos.Delete()
menub = menu_t.submenu(_("Remove"), ico)
for carpeta, name in lista:
xopcion(menub, "remtactica|%s|%s" % (carpeta, name),
trTraining(name), ico)
menu_tactics.separador()
xopcion(menu_tactics, "bmt", _("Find best move"), Iconos.BMT())
menu_tactics.separador()
xopcion(menu_tactics, "dailytest", _("Your daily test"),
Iconos.DailyTest())
menu_tactics.separador()
xopcion(menu_tactics, "potencia",
_("Determine your calculating power"), Iconos.Potencia())
menu_tactics.separador()
# TOL
menu_tactics.separador()
menu2 = menu_tactics.submenu(_("Turn on the lights"), Iconos.TOL())
menu.separador()
menu3 = menu2.submenu(_("Memory mode"), Iconos.TOL())
xopcion(menu3, "tol_uned_easy",
"%s (%s)" % (_("UNED chess school"), _("Initial")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uned",
"%s (%s)" % (_("UNED chess school"), _("Complete")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uwe_easy",
"%s (%s)" % (_("Uwe Auerswald"), _("Initial")), Iconos.Uwe())
menu3.separador()
xopcion(menu3, "tol_uwe",
"%s (%s)" % (_("Uwe Auerswald"), _("Complete")), Iconos.Uwe())
menu2.separador()
menu3 = menu2.submenu(_("Calculation mode"), Iconos.Calculo())
xopcion(menu3, "tol_uned_easy_calc",
"%s (%s)" % (_("UNED chess school"), _("Initial")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uned_calc",
"%s (%s)" % (_("UNED chess school"), _("Complete")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uwe_easy_calc",
"%s (%s)" % (_("Uwe Auerswald"), _("Initial")), Iconos.Uwe())
menu3.separador()
xopcion(menu3, "tol_uwe_calc",
"%s (%s)" % (_("Uwe Auerswald"), _("Complete")), Iconos.Uwe())
menu2.separador()
xopcion(menu2, "tol_oneline", _("Turn on lights in one line"),
Iconos.TOLline())
def inicio(self,
pos_training,
num_trainings,
title_training,
li_trainings,
is_tutor_enabled=None,
is_automatic_jump=False):
if hasattr(self, "reiniciando"):
if self.reiniciando:
return
self.reiniciando = True
if is_tutor_enabled is None:
is_tutor_enabled = (Code.dgtDispatch is None
) and self.configuracion.x_default_tutor_active
self.pos_training = pos_training
self.save_pos(pos_training)
self.num_trainings = num_trainings
self.title_training = title_training
self.li_trainings = li_trainings
self.is_automatic_jump = is_automatic_jump
self.li_histo = [self.pos_training]
self.ayudas = 99999
self.line_fns = FNSLine.FNSLine(self.li_trainings[self.pos_training -
1])
self.game_obj = self.line_fns.game_obj
self.pos_obj = 0
self.is_rival_thinking = False
cp = self.line_fns.position
is_white = cp.is_white
if self.line_fns.with_game_original():
self.game = self.line_fns.game_original
else:
self.game.set_position(cp)
if self.game_obj:
self.game.set_first_comment(self.game_obj.first_comment, True)
self.game.pending_opening = False
self.game_type = GT_POSITIONS
self.human_is_playing = False
self.state = ST_PLAYING
self.plays_instead_of_me_option = True
self.is_human_side_white = is_white
self.is_engine_side_white = not is_white
self.rm_rival = None
self.is_tutor_enabled = is_tutor_enabled
self.main_window.ponActivarTutor(self.is_tutor_enabled)
self.ayudas_iniciales = 0
li_options = [TB_CLOSE, TB_CHANGE, TB_REINIT, TB_TAKEBACK]
li_options.append(TB_PGN_LABELS)
li_options.extend((TB_CONFIG, TB_UTILITIES))
if self.num_trainings > 1:
li_options.extend((TB_PREVIOUS, TB_NEXT))
self.li_options_toolbar = li_options
self.main_window.pon_toolbar(li_options)
self.main_window.activaJuego(True, False, siAyudas=False)
self.main_window.quitaAyudas(False, False)
self.set_dispatcher(self.mueve_humano)
self.setposition(self.game.last_position)
self.mostrarIndicador(True)
self.ponPiezasAbajo(is_white)
titulo = "<b>%s</b>" % TrListas.dicTraining().get(
self.title_training, self.title_training)
if self.line_fns.label:
titulo += "<br>%s" % self.line_fns.label
self.ponRotulo1(titulo)
self.ponRotulo2("%d / %d" % (pos_training, num_trainings))
self.pgnRefresh(True)
QTUtil.refresh_gui()
if self.xrival is None:
self.xrival = self.procesador.creaGestorMotor(
self.configuracion.tutor, self.configuracion.x_tutor_mstime,
self.configuracion.x_tutor_depth)
self.is_analyzed_by_tutor = False
self.dgt_setposition()
if self.line_fns.with_game_original():
self.repiteUltimaJugada()
self.reiniciando = False
self.is_rival_thinking = False
self.siguiente_jugada()
def start(self, pos_training, num_trainings, title_training, li_trainings, is_tutor_enabled=None, is_automatic_jump=False):
if hasattr(self, "reiniciando"):
if self.reiniciando:
return
self.reiniciando = True
if is_tutor_enabled is None:
is_tutor_enabled = (Code.dgtDispatch is None) and self.configuration.x_default_tutor_active
self.pos_training = pos_training
self.save_pos(pos_training)
self.num_trainings = num_trainings
self.title_training = title_training
self.li_trainings = li_trainings
self.is_automatic_jump = is_automatic_jump
self.li_histo = [self.pos_training]
self.hints = 99999
self.line_fns = FNSLine.FNSLine(self.li_trainings[self.pos_training - 1])
self.game_obj = self.line_fns.game_obj
self.pos_obj = 0
self.is_rival_thinking = False
cp = self.line_fns.position
is_white = cp.is_white
if self.line_fns.with_game_original():
self.game = self.line_fns.game_original
else:
self.game.set_position(cp)
if self.game_obj:
self.game.set_first_comment(self.game_obj.first_comment, True)
self.game.pending_opening = False
self.game_type = GT_POSITIONS
self.human_is_playing = False
self.state = ST_PLAYING
self.plays_instead_of_me_option = True
self.human_side = is_white
self.is_engine_side_white = not is_white
self.rm_rival = None
self.is_tutor_enabled = is_tutor_enabled
self.main_window.set_activate_tutor(self.is_tutor_enabled)
self.ayudas_iniciales = 0
li_options = [TB_CLOSE, TB_CHANGE, TB_REINIT, TB_TAKEBACK]
li_options.append(TB_PGN_LABELS)
li_options.extend((TB_CONFIG, TB_UTILITIES))
if self.num_trainings > 1:
li_options.extend((TB_PREVIOUS, TB_NEXT))
self.li_options_toolbar = li_options
self.main_window.pon_toolbar(li_options)
self.main_window.activaJuego(True, False, siAyudas=False)
self.main_window.remove_hints(False, False)
self.set_dispatcher(self.player_has_moved)
self.set_position(self.game.last_position)
self.show_side_indicator(True)
self.put_pieces_bottom(is_white)
titulo = "<b>%s</b>" % TrListas.dicTraining().get(self.title_training, self.title_training)
if self.line_fns.label:
titulo += "<br>%s" % self.line_fns.label
self.set_label1(titulo)
self.set_label2("%d / %d" % (pos_training, num_trainings))
self.pgnRefresh(True)
QTUtil.refresh_gui()
if self.xrival is None:
self.xrival = self.procesador.creaManagerMotor(self.configuration.tutor, self.configuration.x_tutor_mstime, self.configuration.x_tutor_depth)
player = self.configuration.nom_player()
other = _("the engine")
w, b = (player, other) if self.human_side else (other, player)
self.game.set_tag("White", w)
self.game.set_tag("Black", b)
self.is_analyzed_by_tutor = False
self.continueTt = not self.configuration.x_engine_notbackground
self.check_boards_setposition()
if self.line_fns.with_game_original():
self.repiteUltimaJugada()
self.reiniciando = False
self.is_rival_thinking = False
self.is_analyzing = False
self.play_next_move()
def lanza(self, siFavoritos=True):
self.comprueba()
liFavoritos = None
if siFavoritos:
liFav = self.procesador.configuracion.liFavoritos
if liFav:
li = []
for elem in liFav:
if elem in self.dicMenu:
li.append(self.dicMenu[elem])
liFavoritos = li
if liFavoritos:
menu = self.menuFavoritos(liFavoritos)
else:
menu = self.menu
resp = menu.lanza()
if resp:
siStr = type(resp) == type("")
if siStr:
if resp == "menu_global":
self.lanza(False)
elif resp == "gm":
self.entrenaGM()
elif resp.startswith("mate"):
self.jugarMate(int(resp[-1]))
elif resp == "bmt":
self.bmt()
elif resp == "polyglot":
self.entrenaBooks()
elif resp.startswith("boxing"):
self.boxing(resp[6:])
elif resp in ["j60_rival", "j60_jugador"]:
self.jugar60(resp == "j60_jugador")
elif resp == "aperturas":
self.aperturas()
elif resp == "dailytest":
self.dailyTest()
elif resp == "potencia":
self.potencia()
elif resp == "visualiza":
self.visualiza()
elif resp.startswith("tactica|"):
nada, tipo, nombre, carpeta, ini = resp.split("|")
self.tacticas(tipo, nombre, carpeta, ini)
elif resp.startswith("remtactica|"):
nada, carpeta, nombre = resp.split("|")
self.tacticaRemove(carpeta, nombre)
elif resp.startswith("puente_"):
self.puente(int(resp[7:]))
elif resp.startswith("horses_"):
test = int(resp[7])
icl, icn, tit = self.horsesDef[test]
icon = VarGen.todasPiezas.icono(icl, icn)
self.horses(test, tit, icon)
elif resp.startswith("ep_"):
um = self.procesador.unMomento()
entreno = resp[3:].replace("\\", "/")
if "/" in entreno:
dicTraining = TrListas.dicTraining()
titentreno = ""
for x in entreno[:-4].split("/")[1:]:
titentreno += dicTraining.get(x, x) + "/"
titentreno = titentreno[:-1]
f = PGNreader.openCodec(entreno)
todo = f.read().strip()
f.close()
liEntrenamientos = todo.split("\n")
nPosiciones = len(liEntrenamientos)
um.final()
if nPosiciones == 0:
return
elif nPosiciones == 1:
pos = 1
jump = False
else:
db = Util.DicSQL(self.configuracion.ficheroTrainings)
posUltimo = db[entreno]
if posUltimo is None:
posUltimo = 1
resp = DatosNueva.numPosicion(self.procesador.pantalla,
titentreno, nPosiciones, posUltimo)
if resp is None:
return
pos, tipo, jump = resp
db.close()
if tipo.startswith( "r" ):
if tipo == "rk":
random.seed(pos)
random.shuffle(liEntrenamientos)
self.procesador.entrenaPos(pos, nPosiciones, titentreno, liEntrenamientos, entreno, jump)
elif resp == "learnPGN":
self.learnPGN()
elif resp == "lucaselo":
self.procesador.lucaselo(False)
elif resp == "micelo":
self.procesador.micelo(False)
elif resp.startswith("fics"):
self.procesador.ficselo(False, int(resp[4:]))
elif resp.startswith("fide"):
self.procesador.fideelo(False, int(resp[4:]))
elif resp.startswith("map_"):
nada, mapa = resp.split("_")
self.procesador.trainingMap(mapa)
else:
if resp <= -100:
self.menu = None # ya que puede cambiar y la etiqueta es diferente
mem = Memoria.Memoria(self.procesador)
mem.lanza(abs(resp) - 100)
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 creaMenu(self):
dicMenu = {}
menu = QTVarios.LCMenu(self.parent)
talpha = Controles.TipoLetra("Chess Alpha 2",
self.configuracion.x_menu_points + 4)
def xopcion(menu, key, texto, icono, is_disabled=False):
if "KP" in texto:
k2 = texto.index("K", 2)
texto = texto[:k2] + texto[k2:].lower()
menu.opcion(key, texto, icono, is_disabled, tipoLetra=talpha)
else:
menu.opcion(key, texto, icono, is_disabled)
dicMenu[key] = (self.menu_run, texto, icono, is_disabled)
# 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, 8):
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 menu_tacticas(submenu, tipo, carpeta_base, lista):
if os.path.isdir(carpeta_base):
for entry in os.scandir(carpeta_base):
if entry.is_dir():
carpeta = entry.path
ini = os.path.join(carpeta, "Config.ini")
if os.path.isfile(ini):
name = entry.name
xopcion(
submenu,
"tactica|%s|%s|%s|%s" %
(tipo, name, carpeta, ini),
trTraining(name),
nico.otro(),
)
menu1.separador()
lista.append((carpeta, name))
else:
submenu1 = submenu.submenu(entry.name, nico.otro())
menu_tacticas(submenu1, tipo, carpeta, lista)
return lista
menu_tacticas(menu1, TACTICS_BASIC, Code.path_resource("Tactics"), [])
lista = []
carpetaTacticasP = os.path.join(self.configuracion.dirPersonalTraining,
"Tactics")
if os.path.isdir(carpetaTacticasP):
submenu1 = menu1.submenu(_("Personal tactics"), nico.otro())
lista = menu_tacticas(submenu1, TACTICS_PERSONAL, carpetaTacticasP,
lista)
if lista:
ico = Iconos.Delete()
menub = menu1.submenu(_("Remove"), ico)
for carpeta, name in lista:
xopcion(menub, "remtactica|%s|%s" % (carpeta, name),
trTraining(name), ico)
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())
menu.separador()
menu3 = menu2.submenu(_("Memory mode"), Iconos.TOL())
xopcion(menu3, "tol_uned_easy",
"%s (%s)" % (_("UNED chess school"), _("Initial")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uned",
"%s (%s)" % (_("UNED chess school"), _("Complete")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uwe_easy",
"%s (%s)" % (_("Uwe Auerswald"), _("Initial")), Iconos.Uwe())
menu3.separador()
xopcion(menu3, "tol_uwe",
"%s (%s)" % (_("Uwe Auerswald"), _("Complete")), Iconos.Uwe())
menu2.separador()
menu3 = menu2.submenu(_("Calculation mode"), Iconos.Calculo())
xopcion(menu3, "tol_uned_easy_calc",
"%s (%s)" % (_("UNED chess school"), _("Initial")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uned_calc",
"%s (%s)" % (_("UNED chess school"), _("Complete")),
Iconos.Uned())
menu3.separador()
xopcion(menu3, "tol_uwe_easy_calc",
"%s (%s)" % (_("Uwe Auerswald"), _("Initial")), Iconos.Uwe())
menu3.separador()
xopcion(menu3, "tol_uwe_calc",
"%s (%s)" % (_("Uwe Auerswald"), _("Complete")), Iconos.Uwe())
# Washing
menu2.separador()
xopcion(menu2, "tol_oneline", _("In one line"), Iconos.TOLline())
menu1.separador()
xopcion(menu1, "washing_machine", _("The Washing Machine"),
Iconos.WashingMachine())
# Cebras ---------------------------------------------------------------------------------------------------
menu.separador()
# menu1 = menu.submenu(_("Resources for zebras"), Iconos.Cebra())
menu2 = menu.submenu(_("Check your memory on a chessboard"),
Iconos.Memoria())
mem = Memoria.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.separador()
menu2 = menu.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.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.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.separador()
menu2 = menu.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.separador()
xopcion(menu, "potencia", _("Determine your calculating power"),
Iconos.Potencia())
menu.separador()
menu2 = menu.submenu(_("Learn a game"), Iconos.School())
xopcion(menu2, "learnPGN", _("Memorizing their moves"),
Iconos.LearnGame())
menu2.separador()
xopcion(menu2, "playGame", _("Playing against"), Iconos.Law())
menu.separador()
xopcion(menu, "visualiza", _("The board at a glance"), Iconos.Gafas())
menu.separador()
menu2 = menu.submenu(_("Coordinates"), Iconos.Coordinates())
xopcion(menu2, "coordinates_basic", _("Basic"), Iconos.West())
menu2.separador()
xopcion(menu2, "coordinates_blocks", _("By blocks"), Iconos.Blocks())
menu.separador()
xopcion(menu, "anotar", _("Writing down moves of a game"),
Iconos.Write())
menu.separador()
xopcion(menu, "captures", _("Captures and threats in a game"),
Iconos.Captures())
menu.separador()
xopcion(menu, "counts", _("Count moves"), Iconos.Count())
menu.separador()
xopcion(menu, "15mate", _("Mate in 1½"), Iconos.Mate15())
menu.separador()
xopcion(menu, "endings_gtb", _("Endings with Gaviota Tablebases"),
Iconos.Finales())
return menu, dicMenu
