def seleccionaLibro(self):
listaLibros = Books.ListaLibros()
listaLibros.restore_pickle(self.configuracion.ficheroBooks)
listaLibros.comprueba()
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
for book in listaLibros.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, listaLibros.path, "bin", titulo=_("Polyglot book"))
if fbin:
listaLibros.path = os.path.dirname(fbin)
name = os.path.basename(fbin)[:-4]
book = Books.Libro("P", name, fbin, True)
listaLibros.nuevo(book)
listaLibros.save_pickle(self.configuracion.ficheroBooks)
else:
book = None
return book
def importarPolyglot(self, game):
listaLibros = Books.ListaLibros()
listaLibros.restore_pickle(self.configuracion.ficheroBooks)
listaLibros.comprueba()
dicData = self.dbop.getconfig("IMPORT_POLYGLOT")
bookW = listaLibros.lista[0]
bookB = listaLibros.lista[0]
if dicData:
book = listaLibros.buscaLibro(dicData["BOOKW"])
if book:
bookW = book
book = listaLibros.buscaLibro(dicData["BOOKB"])
if book:
bookB = book
liGen = [FormLayout.separador]
li = [(bookx.name, bookx) for bookx in listaLibros.lista]
config = FormLayout.Combobox(_("Book that plays white side"), li)
liGen.append((config, bookW))
liGen.append(FormLayout.separador)
config = FormLayout.Combobox(_("Book that plays black side"), li)
liGen.append((config, bookB))
liGen.append(FormLayout.separador)
resultado = FormLayout.fedit(
liGen, title=_("Polyglot book"), parent=self, anchoMinimo=360, icon=Iconos.Libros()
)
if resultado:
accion, liResp = resultado
bookW, bookB = liResp
dicData = {"BOOKW": bookW.name, "BOOKB": bookB.name}
self.dbop.setconfig("IMPORT_POLYGLOT", dicData)
else:
return
bookW.polyglot()
bookB.polyglot()
titulo = bookW.name if bookW == bookB else "%s/%s" % (bookW.name, bookB.name)
dicData = self.importarLeeParam(titulo)
if dicData:
depth, siWhite, onlyone, minMoves = (
dicData["DEPTH"],
dicData["SIWHITE"],
dicData["ONLYONE"],
dicData["MINMOVES"],
)
self.dbop.importarPolyglot(self, game, bookW, bookB, titulo, depth, siWhite, onlyone, minMoves)
self.glines.refresh()
self.glines.gotop()
def nuevo(self):
menu = QTVarios.LCMenu(self)
menu.opcion(("engine", None), _("Engine"), Iconos.Motor())
menu.separador()
submenu = menu.submenu(_("Book polyglot"), Iconos.Book())
listaLibros = Books.ListaLibros()
listaLibros.restore_pickle(self.configuracion.ficheroBooks)
listaLibros.comprueba()
rondo = QTVarios.rondoPuntos()
for book in listaLibros.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(listaLibros)
def __init__(self, gestor, siEnVivo):
titulo = _("Consult a book")
icono = Iconos.Libros()
extparam = "treebook"
QTVarios.WDialogo.__init__(self, gestor.main_window, titulo, icono,
extparam)
# Se lee la lista de libros1
self.listaLibros = Books.ListaLibros()
self.fvar = gestor.configuracion.ficheroBooks
self.listaLibros.restore_pickle(self.fvar)
# Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
self.book = self.listaLibros.porDefecto()
# fens
fenActivo = gestor.fenActivoConInicio() # Posicion en el tablero
fenUltimo = gestor.fenUltimo()
self.siEnviar = siEnVivo and (fenActivo == fenUltimo)
self.listaMoves = ListaMoves(None, self.book, fenActivo)
self.infoMove = InfoMove(fenActivo)
self.wmoves = WMoves(self, self.siEnviar)
self.splitter = splitter = QtWidgets.QSplitter(self)
splitter.addWidget(self.infoMove)
splitter.addWidget(self.wmoves)
ly = Colocacion.H().control(splitter).margen(0)
self.setLayout(ly)
self.wmoves.tree.setFocus()
anchoTablero = self.infoMove.tablero.width()
self.resize(600 - 278 + anchoTablero, anchoTablero + 30)
self.splitter.setSizes([296 - 278 + anchoTablero, 290])
for col, ancho in enumerate((100, 59, 87, 0, 38)):
self.wmoves.tree.setColumnWidth(col, ancho)
self.ponTitulo(self.book)
def __init__(self, procesador, titulo, save_at_end):
QTVarios.WDialogo.__init__(self, procesador.main_window, titulo, Iconos.Libre(), "entMaquina")
font = Controles.TipoLetra(puntos=procesador.configuracion.x_menu_points)
self.save_at_end = save_at_end
self.setFont(font)
self.configuracion = procesador.configuracion
self.procesador = procesador
self.personalidades = Personalidades.Personalidades(self, self.configuracion)
self.motores = SelectEngines.SelectEngines(self.configuracion)
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("Configurations"), Iconos.Configurar(), self.configuraciones),
None,
]
tb = QTVarios.LCTB(self, li_acciones)
# Tab
tab = Controles.Tab()
tab.dispatchChange(self.cambiada_tab)
self.tab_advanced = 4 # está en la posición 4
self.tab_advanced_active = (
False
) # Para no tener que leer las opciones uci to_sq que no sean necesarias, afecta a gridNumDatos
def nueva_tab(layout, titulo):
ly = Colocacion.V()
ly.otro(layout)
ly.relleno()
w = QtWidgets.QWidget(self)
w.setLayout(ly)
w.setFont(font)
tab.nuevaTab(w, titulo)
def nuevoG():
ly_g = Colocacion.G()
ly_g.filaActual = 0
ly_g.setMargin(10)
return ly_g
gbStyle = """
QGroupBox {
font: bold 16px;
background-color: #F2F2EC;/*qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #E0E0E0, stop: 1 #FFFFFF);*/
border: 1px solid gray;
border-radius: 3px;
padding: 18px;
margin-top: 5ex; /* leave space at the top for the title */
}
QGroupBox::title {
subcontrol-origin: margin;
subcontrol-position: top left; /* position at the top center */
padding: 8px;
border: 1px solid gray;
}
"""
def _label(ly_g, txt, xlayout, rutinaCHB=None, siCheck: object = False):
groupbox = Controles.GB(self, txt, xlayout)
if rutinaCHB:
groupbox.conectar(rutinaCHB)
elif siCheck:
groupbox.setCheckable(True)
groupbox.setChecked(False)
groupbox.setStyleSheet(gbStyle)
groupbox.setMinimumWidth(640)
groupbox.setFont(font)
ly_g.controlc(groupbox, ly_g.filaActual, 0)
ly_g.filaActual += 1
return groupbox
# ##################################################################################################################################
# TAB General
# ##################################################################################################################################
lyG = nuevoG()
# # Motores
# ## Rival
self.rival = self.procesador.XTutor().confMotor
self.rivalTipo = SelectEngines.INTERNO
self.btRival = Controles.PB(self, "", self.cambiaRival, plano=False).ponFuente(font).altoFijo(48)
lbTiempoSegundosR = Controles.LB2P(self, _("Fixed time in seconds")).ponFuente(font)
self.edRtiempo = (
Controles.ED(self).tipoFloat().anchoMaximo(50).ponFuente(font).capturaCambiado(self.cambiadoTiempo)
)
bt_cancelar_tiempo = Controles.PB(self, "", rutina=self.cancelar_tiempo).ponIcono(Iconos.S_Cancelar())
ly_tiempo = Colocacion.H().control(self.edRtiempo).control(bt_cancelar_tiempo).relleno(1)
lb_depth = Controles.LB2P(self, _("Fixed depth")).ponFuente(font)
self.edRdepth = Controles.ED(self).tipoInt().anchoMaximo(50).ponFuente(font).capturaCambiado(self.cambiadoDepth)
bt_cancelar_depth = Controles.PB(self, "", rutina=self.cancelar_depth).ponIcono(Iconos.S_Cancelar())
ly_depth = Colocacion.H().control(self.edRdepth).control(bt_cancelar_depth).relleno(1)
ly = Colocacion.G()
ly.controld(lbTiempoSegundosR, 0, 0).otro(ly_tiempo, 0, 1)
ly.controld(lb_depth, 1, 0).otro(ly_depth, 1, 1)
self.gb_thinks = Controles.GB(self, _("Limits of engine thinking"), ly)
self.gb_thinks.setStyleSheet(
"""
QGroupBox {
font: bold %d;
background-color: #F2F2EC;/*qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #E0E0E0, stop: 1 #FFFFFF);*/
border: 1px solid gray;
border-radius: 3px;
padding: 18px;
margin-top: 5ex; /* leave space at the top for the title */
}
QGroupBox::title {
subcontrol-position: top center; /* position at the top center */
padding: 8px;
border: 1px solid gray;
}
"""
% procesador.configuracion.x_menu_points
)
lyV = Colocacion.V().espacio(20).control(self.btRival).espacio(20).control(self.gb_thinks)
_label(lyG, _("Opponent"), lyV)
# # Color
self.rbBlancas = Controles.RB(self, "").activa()
self.rbBlancas.setIcon(Iconos.PeonBlanco())
self.rbBlancas.setIconSize(QtCore.QSize(32, 32))
self.rbNegras = Controles.RB(self, "")
self.rbNegras.setIcon(Iconos.PeonNegro())
self.rbNegras.setIconSize(QtCore.QSize(32, 32))
self.rbRandom = Controles.RB(self, _("Random"))
self.rbRandom.setFont(Controles.TipoLetra(puntos=16))
hbox = (
Colocacion.H()
.relleno()
.control(self.rbBlancas)
.espacio(30)
.control(self.rbNegras)
.espacio(30)
.control(self.rbRandom)
.relleno()
)
_label(lyG, _("Side you play with"), hbox)
nueva_tab(lyG, _("Basic configuration"))
# ##################################################################################################################################
# TAB Ayudas
# ##################################################################################################################################
self.chbSummary = Controles.CHB(
self, _("Save a summary when the game is finished in the main comment"), False
).ponFuente(font)
self.chbTakeback = Controles.CHB(
self, _("Option takeback activated"), True
).ponFuente(font)
# # Tutor
lbAyudas = Controles.LB2P(self, _("Available hints")).ponFuente(font)
liAyudas = [(_("Maximum"), 999)]
for i in range(1, 21):
liAyudas.append((str(i), i))
for i in range(25, 51, 5):
liAyudas.append((str(i), i))
self.cbAyudas = Controles.CB(self, liAyudas, 999).ponFuente(font)
self.chbChance = Controles.CHB(self, _("Second chance"), True).ponFuente(font)
btTutorChange = (
Controles.PB(self, _("Tutor change"), self.tutorChange, plano=False)
.ponIcono(Iconos.Tutor(), tamIcon=16)
.ponFuente(font)
)
liThinks = [(_("Nothing"), -1), (_("Score"), 0)]
for i in range(1, 5):
liThinks.append(("%d %s" % (i, _("ply") if i == 1 else _("plies")), i))
liThinks.append((_("All"), 9999))
lbThoughtTt = Controles.LB(self, _("It is showed") + ":").ponFuente(font)
self.cbThoughtTt = Controles.CB(self, liThinks, -1).ponFuente(font)
self.chbContinueTt = Controles.CHB(self, _("The tutor thinks while you think"), True).ponFuente(font)
lbBoxHeight = Controles.LB2P(self, _("Box height")).ponFuente(font)
self.sbBoxHeight = Controles.SB(self, 7, 0, 999).tamMaximo(50).ponFuente(font)
lbArrows = Controles.LB2P(self, _("Arrows with the best moves")).ponFuente(font)
self.sbArrowsTt = Controles.SB(self, 3, 0, 999).tamMaximo(50).ponFuente(font)
lyT1 = Colocacion.H().control(lbAyudas).control(self.cbAyudas).relleno()
lyT1.control(self.chbChance).relleno().control(btTutorChange)
lyT2 = Colocacion.H().control(self.chbContinueTt).relleno()
lyT2.control(lbBoxHeight).control(self.sbBoxHeight).relleno()
lyT3 = Colocacion.H().control(lbThoughtTt).control(self.cbThoughtTt).relleno()
lyT3.control(lbArrows).control(self.sbArrowsTt)
ly = Colocacion.V().otro(lyT1).espacio(16).otro(lyT2).otro(lyT3).relleno()
self.gbTutor = Controles.GB(self, _("Activate the tutor's help"), ly)
self.gbTutor.setCheckable(True)
self.gbTutor.setStyleSheet(gbStyle)
lb = Controles.LB(self, _("It is showed") + ":").ponFuente(font)
self.cbThoughtOp = Controles.CB(self, liThinks, -1).ponFuente(font)
lbArrows = Controles.LB2P(self, _("Arrows to show")).ponFuente(font)
self.sbArrows = Controles.SB(self, 7, 0, 999).tamMaximo(50).ponFuente(font)
ly = Colocacion.H().control(lb).control(self.cbThoughtOp).relleno()
ly.control(lbArrows).control(self.sbArrows).relleno()
gbThoughtOp = Controles.GB(self, _("Opponent's thought information"), ly)
gbThoughtOp.setStyleSheet(gbStyle)
ly = Colocacion.V().espacio(16).control(self.gbTutor).control(gbThoughtOp)
ly.espacio(16).control(self.chbSummary).control(self.chbTakeback).margen(6)
nueva_tab(ly, _("Help configuration"))
# ##################################################################################################################################
# TAB Tiempo
# ##################################################################################################################################
lyG = nuevoG()
self.lbMinutos = Controles.LB(self, _("Total minutes") + ":").ponFuente(font)
self.edMinutos = Controles.ED(self).tipoFloat(10.0).ponFuente(font).anchoFijo(50)
self.edSegundos, self.lbSegundos = QTUtil2.spinBoxLB(
self, 6, -999, 999, maxTam=54, etiqueta=_("Seconds added per move"), fuente=font
)
self.edMinExtra, self.lbMinExtra = QTUtil2.spinBoxLB(
self, 0, -999, 999, maxTam=70, etiqueta=_("Extra minutes for the player"), fuente=font
)
self.edZeitnot, self.lbZeitnot = QTUtil2.spinBoxLB(
self, 0, -999, 999, maxTam=54, etiqueta=_("Zeitnot: alarm sounds when remaining seconds"), fuente=font
)
lyH = Colocacion.H()
lyH.control(self.lbMinutos).control(self.edMinutos).espacio(30)
lyH.control(self.lbSegundos).control(self.edSegundos).relleno()
lyH2 = Colocacion.H()
lyH2.control(self.lbMinExtra).control(self.edMinExtra).relleno()
lyH3 = Colocacion.H()
lyH3.control(self.lbZeitnot).control(self.edZeitnot).relleno()
ly = Colocacion.V().otro(lyH).otro(lyH2).otro(lyH3)
self.chbTiempo = _label(lyG, _("Activate the time control"), ly, siCheck=True)
nueva_tab(lyG, _("Time"))
# ##################################################################################################################################
# TAB Initial moves
# ##################################################################################################################################
lyG = nuevoG()
# Posicion
self.btPosicion = (
Controles.PB(self, " " * 5 + _("Change") + " " * 5, self.posicionEditar).ponPlano(False).ponFuente(font)
)
self.fen = ""
self.btPosicionQuitar = Controles.PB(self, "", self.posicionQuitar).ponIcono(Iconos.Motor_No()).ponFuente(font)
self.btPosicionPegar = (
Controles.PB(self, "", self.posicionPegar).ponIcono(Iconos.Pegar16()).ponToolTip(_("Paste FEN position"))
).ponFuente(font)
hbox = (
Colocacion.H()
.relleno()
.control(self.btPosicionQuitar)
.control(self.btPosicion)
.control(self.btPosicionPegar)
.relleno()
)
_label(lyG, _("Start position"), hbox)
# Aperturas
self.btApertura = (
Controles.PB(self, " " * 5 + _("Undetermined") + " " * 5, self.editarApertura)
.ponPlano(False)
.ponFuente(font)
)
self.bloqueApertura = None
self.btAperturasFavoritas = Controles.PB(self, "", self.aperturasFavoritas).ponIcono(Iconos.Favoritos())
self.btAperturasQuitar = Controles.PB(self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No())
hbox = (
Colocacion.H()
.relleno()
.control(self.btAperturasQuitar)
.control(self.btApertura)
.control(self.btAperturasFavoritas)
.relleno()
)
_label(lyG, _("Opening"), hbox)
# Libros
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.restore_pickle(fvar)
self.listaLibros.comprueba()
li_books = [(x.name, x) for x in self.listaLibros.lista]
libInicial = li_books[0][1] if li_books else None
li_resp_book = [
(_("Selected by the player"), "su"),
(_("Uniform random"), "au"),
(_("Proportional random"), "ap"),
(_("Always the highest percentage"), "mp"),
]
## Rival
self.cbBooksR = QTUtil2.comboBoxLB(self, li_books, libInicial).ponFuente(font)
self.btNuevoBookR = Controles.PB(self, "", self.nuevoBook, plano=True).ponIcono(Iconos.Mas(), tamIcon=16)
self.cbBooksRR = QTUtil2.comboBoxLB(self, li_resp_book, "mp").ponFuente(font)
self.lbDepthBookR = Controles.LB2P(self, _("Max depth")).ponFuente(font)
self.edDepthBookR = Controles.ED(self).ponFuente(font).tipoInt(0).anchoFijo(30)
hbox = (
Colocacion.H()
.control(self.cbBooksR)
.control(self.btNuevoBookR)
.relleno()
.control(self.cbBooksRR)
.relleno()
.control(self.lbDepthBookR)
.control(self.edDepthBookR)
)
self.chbBookR = _label(lyG, "%s: %s" % (_("Activate book"), _("Opponent")), hbox, siCheck=True)
## Player
self.cbBooksP = QTUtil2.comboBoxLB(self, li_books, libInicial).ponFuente(font)
self.btNuevoBookP = Controles.PB(self, "", self.nuevoBook, plano=True).ponIcono(Iconos.Mas(), tamIcon=16)
self.lbDepthBookP = Controles.LB2P(self, _("Max depth")).ponFuente(font)
self.edDepthBookP = Controles.ED(self).ponFuente(font).tipoInt(0).anchoFijo(30)
hbox = (
Colocacion.H()
.control(self.cbBooksP)
.control(self.btNuevoBookP)
.relleno()
.control(self.lbDepthBookP)
.control(self.edDepthBookP)
)
self.chbBookP = _label(
lyG, "%s: %s" % (_("Activate book"), self.configuracion.nom_player()), hbox, siCheck=True
)
nueva_tab(lyG, _("Initial moves"))
# ##################################################################################################################################
# TAB avanzada
# ##################################################################################################################################
lyG = nuevoG()
liAjustes = self.personalidades.listaAjustes(True)
self.cbAjustarRival = (
Controles.CB(self, liAjustes, ADJUST_BETTER).capturaCambiado(self.ajustesCambiado).ponFuente(font)
)
lbAjustarRival = Controles.LB2P(self, _("Set strength")).ponFuente(font)
self.btAjustarRival = (
Controles.PB(self, _("Personality"), self.cambiaPersonalidades, plano=True)
.ponIcono(Iconos.Mas(), tamIcon=16)
.ponFuente(font)
)
# ## Resign
lbResign = Controles.LB2P(self, _("Resign/draw by engine")).ponFuente(font)
liResign = (
(_("Very early"), -100),
(_("Early"), -300),
(_("Average"), -500),
(_("Late"), -800),
(_("Very late"), -1000),
(_("Never"), -9999999),
)
self.cbResign = Controles.CB(self, liResign, -800).ponFuente(font)
self.lb_path_engine = Controles.LB(self, "").ponWrap()
o_columns = Columnas.ListaColumnas()
o_columns.nueva("OPTION", _("UCI option"), 240, centered=True)
o_columns.nueva("VALUE", _("Value"), 200, centered=True, edicion=Delegados.MultiEditor(self))
self.grid_uci = Grid.Grid(self, o_columns, siEditable=True)
self.grid_uci.ponFuente(font)
self.register_grid(self.grid_uci)
lyH2 = (
Colocacion.H().control(lbAjustarRival).control(self.cbAjustarRival).control(self.btAjustarRival).relleno()
)
lyH3 = Colocacion.H().control(lbResign).control(self.cbResign).relleno()
ly = Colocacion.V().otro(lyH2).otro(lyH3).espacio(16).control(self.lb_path_engine).control(self.grid_uci)
_label(lyG, _("Opponent"), ly)
nueva_tab(lyG, _("Advanced"))
layout = Colocacion.V().control(tb).control(tab).relleno().margen(3)
self.setLayout(layout)
self.liAperturasFavoritas = []
self.btAperturasFavoritas.hide()
dic = Util.restore_pickle(self.configuracion.ficheroEntMaquina)
if not dic:
dic = {}
self.restore_dic(dic)
self.ajustesCambiado()
# self.ayudasCambiado()
self.ponRival()
self.restore_video()
def __init__(self, wParent):
QtWidgets.QDialog.__init__(self, wParent)
self.wParent = wParent
self.fichero = ""
self.setWindowTitle(_("Create a new book"))
self.setWindowIcon(Iconos.Libros())
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.Dialog
| QtCore.Qt.WindowTitleHint)
f = Controles.TipoLetra(puntos=9, peso=75)
self.configuracion = Code.configuracion
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.restore_pickle(fvar)
lbFichero = Controles.LB(self, _("Book to create") + ":").ponFuente(f)
self.btFichero = Controles.PB(self, "", self.buscaFichero,
False).anchoMinimo(450).ponFuente(f)
lbMaxPly = Controles.LB(self,
_("Maximum no. half moves (ply)") +
":").ponFuente(f)
self.sbMaxPly = Controles.SB(self, 0, 0, 999).tamMaximo(50)
lbMinGame = Controles.LB(self,
_("Minimum number of games") +
":").ponFuente(f)
self.sbMinGame = Controles.SB(self, 3, 1, 999).tamMaximo(50)
lbMinScore = Controles.LB(self, _("Minimum score") + ":").ponFuente(f)
self.sbMinScore = Controles.SB(self, 0, 0, 100).tamMaximo(50)
self.chbOnlyWhite = Controles.CHB(self, _("White only"),
False).ponFuente(f)
self.chbOnlyBlack = Controles.CHB(self, _("Black only"),
False).ponFuente(f)
self.chbUniform = Controles.CHB(self, _("Uniform distribution"),
False).ponFuente(f)
lyf = Colocacion.H().control(lbFichero).control(self.btFichero)
ly = Colocacion.G().margen(15)
ly.otroc(lyf, 0, 0, 1, 2)
ly.controld(lbMaxPly, 1, 0).control(self.sbMaxPly, 1, 1)
ly.controld(lbMinGame, 2, 0).control(self.sbMinGame, 2, 1)
ly.controld(lbMinScore, 3, 0).control(self.sbMinScore, 3, 1)
ly.controlc(self.chbOnlyWhite, 4, 0, 1, 2)
ly.controlc(self.chbOnlyBlack, 5, 0, 1, 2)
ly.controlc(self.chbUniform, 6, 0, 1, 2)
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), "aceptar"),
None,
(_("Cancel"), Iconos.Cancelar(), "cancelar"),
None,
]
tb = Controles.TB(self, li_acciones)
# Layout
layout = Colocacion.V().control(tb).otro(ly).margen(3)
self.setLayout(layout)
def __init__(self, wParent, nombre_torneo):
torneo = self.torneo = Tournament.Tournament(nombre_torneo)
titulo = nombre_torneo
icono = Iconos.Torneos()
extparam = "untorneo_v1"
QTVarios.WDialogo.__init__(self, wParent, titulo, icono, extparam)
self.configuracion = Code.configuracion
# Datos
self.liEnActual = []
self.xjugar = None
self.liResult = None
self.last_change = Util.today()
self.li_results = []
# Toolbar
tb = Controles.TBrutina(self, tamIcon=24)
tb.new(_("Close"), Iconos.MainMenu(), self.terminar)
tb.new(_("Launch a worker"), Iconos.Lanzamiento(), self.gm_launch)
# Tabs
self.tab = tab = Controles.Tab()
# Tab-configuracion --------------------------------------------------
w = QtWidgets.QWidget()
# Adjudicator
lb_resign = Controles.LB(
self, "%s (%s): " %
(_("Minimum centipawns to assign winner"), _("0=disable")))
self.ed_resign = Controles.ED(self).tipoInt(
torneo.resign()).anchoFijo(30)
bt_resign = Controles.PB(self, "", rutina=self.borra_resign).ponIcono(
Iconos.Reciclar())
# Draw-plys
lbDrawMinPly = Controles.LB(
self,
"%s (%s): " % (_("Minimum moves to assign draw"), _("0=disable")))
self.sbDrawMinPly = Controles.SB(self, torneo.drawMinPly(), 20, 1000)
# Draw-puntos
lb_draw_range = Controles.LB(
self,
_("Maximum centipawns to assign draw") + ": ")
self.ed_draw_range = Controles.ED(self).tipoInt(
torneo.drawRange()).anchoFijo(30)
bt_draw_range = Controles.PB(
self, "", rutina=self.borra_draw_range).ponIcono(Iconos.Reciclar())
# adjudicator
self.liMotores = self.configuracion.comboMotoresMultiPV10()
self.cbJmotor, self.lbJmotor = QTUtil2.comboBoxLB(
self, self.liMotores, torneo.adjudicator(), _("Engine"))
self.edJtiempo = Controles.ED(self).tipoFloat().ponFloat(
1.0).anchoFijo(50).ponFloat(torneo.adjudicator_time())
self.lbJtiempo = Controles.LB2P(self, _("Time in seconds"))
layout = Colocacion.G()
layout.controld(self.lbJmotor, 3, 0).control(self.cbJmotor, 3, 1)
layout.controld(self.lbJtiempo, 4, 0).control(self.edJtiempo, 4, 1)
self.gbJ = Controles.GB(self, _("Adjudicator"), layout)
self.gbJ.setCheckable(True)
self.gbJ.setChecked(torneo.adjudicator_active())
lbBook = Controles.LB(self, _("Opening book") + ": ")
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.restore_pickle(fvar)
# Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
li = [(x.name, x.path) for x in self.listaLibros.lista]
li.insert(0, ("* " + _("None"), "-"))
self.cbBooks = Controles.CB(self, li, torneo.book())
btNuevoBook = Controles.PB(self, "", self.nuevoBook,
plano=False).ponIcono(Iconos.Nuevo(),
tamIcon=16)
lyBook = Colocacion.H().control(
self.cbBooks).control(btNuevoBook).relleno()
lbBookDepth = Controles.LB(self,
_("Max depth of book (0=Maximum)") + ": ")
self.sbBookDepth = Controles.SB(self, torneo.bookDepth(), 0, 200)
# Posicion inicial
lbFEN = Controles.LB(self, _("Initial position") + ": ")
self.fen = torneo.fen()
self.btPosicion = Controles.PB(self, " " * 5 + _("Change") + " " * 5,
self.posicionEditar).ponPlano(False)
self.btPosicionQuitar = Controles.PB(
self, "", self.posicionQuitar).ponIcono(Iconos.Motor_No())
self.btPosicionPegar = (Controles.PB(self, "",
self.posicionPegar).ponIcono(
Iconos.Pegar16()).ponToolTip(
_("Paste FEN position")))
lyFEN = (Colocacion.H().control(self.btPosicionQuitar).control(
self.btPosicion).control(self.btPosicionPegar).relleno())
# Norman Pollock
lbNorman = Controles.LB(
self,
'%s(<a href="https://komodochess.com/pub/40H-pgn-utilities">?</a>): '
% _("Initial position from Norman Pollock openings database"),
)
self.chbNorman = Controles.CHB(self, " ", self.torneo.norman())
# Layout
layout = Colocacion.G()
ly_res = Colocacion.H().control(
self.ed_resign).control(bt_resign).relleno()
ly_dra = Colocacion.H().control(
self.ed_draw_range).control(bt_draw_range).relleno()
layout.controld(lb_resign, 0, 0).otro(ly_res, 0, 1)
layout.controld(lbDrawMinPly, 1, 0).control(self.sbDrawMinPly, 1, 1)
layout.controld(lb_draw_range, 2, 0).otro(ly_dra, 2, 1)
layout.controld(lbBook, 3, 0).otro(lyBook, 3, 1)
layout.controld(lbBookDepth, 4, 0).control(self.sbBookDepth, 4, 1)
layout.controld(lbFEN, 5, 0).otro(lyFEN, 5, 1)
layout.controld(lbNorman, 6, 0).control(self.chbNorman, 6, 1)
layoutV = Colocacion.V().relleno().otro(layout).control(
self.gbJ).relleno()
layoutH = Colocacion.H().relleno().otro(layoutV).relleno()
# Creamos
w.setLayout(layoutH)
tab.nuevaTab(w, _("Configuration"))
# Tab-engines --------------------------------------------------
self.splitterEngines = QtWidgets.QSplitter(self)
self.register_splitter(self.splitterEngines, "engines")
# TB
li_acciones = [
(_("New"), Iconos.TutorialesCrear(), self.enNuevo),
None,
(_("Modify"), Iconos.Modificar(), self.enModificar),
None,
(_("Remove"), Iconos.Borrar(), self.enBorrar),
None,
(_("Copy"), Iconos.Copiar(), self.enCopiar),
None,
(_("Import"), Iconos.MasDoc(), self.enImportar),
None,
]
tbEnA = Controles.TBrutina(self,
li_acciones,
tamIcon=16,
style=QtCore.Qt.ToolButtonTextBesideIcon)
# Grid engine
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 50, centered=True)
o_columns.nueva("ALIAS", _("Alias"), 209)
self.gridEnginesAlias = Grid.Grid(self,
o_columns,
siSelecFilas=True,
siSeleccionMultiple=True,
xid=GRID_ALIAS)
self.register_grid(self.gridEnginesAlias)
w = QtWidgets.QWidget()
ly = Colocacion.V().control(self.gridEnginesAlias).margen(0)
w.setLayout(ly)
self.splitterEngines.addWidget(w)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("CAMPO", _("Label"), 200, siDerecha=True)
o_columns.nueva("VALOR", _("Value"), 286)
self.gridEnginesValores = Grid.Grid(self,
o_columns,
siSelecFilas=False,
xid=GRID_VALUES)
self.register_grid(self.gridEnginesValores)
w = QtWidgets.QWidget()
ly = Colocacion.V().control(self.gridEnginesValores).margen(0)
w.setLayout(ly)
self.splitterEngines.addWidget(w)
self.splitterEngines.setSizes([250, 520]) # por defecto
w = QtWidgets.QWidget()
ly = Colocacion.V().control(tbEnA).control(self.splitterEngines)
w.setLayout(ly)
tab.nuevaTab(w, _("Engines"))
# Creamos
# Tab-games queued--------------------------------------------------
w = QtWidgets.QWidget()
# TB
li_acciones = [
(_("New"), Iconos.TutorialesCrear(), self.gm_crear_queued),
None,
(_("Remove"), Iconos.Borrar(), self.gm_borrar_queued),
None,
]
tbEnG = Controles.TBrutina(self,
li_acciones,
tamIcon=16,
style=QtCore.Qt.ToolButtonTextBesideIcon)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 50, centered=True)
o_columns.nueva("WHITE", _("White"), 190, centered=True)
o_columns.nueva("BLACK", _("Black"), 190, centered=True)
o_columns.nueva("TIME", _("Time"), 170, centered=True)
# o_columns.nueva("STATE", _("State"), 190, centered=True)
self.gridGamesQueued = Grid.Grid(self,
o_columns,
siSelecFilas=True,
siSeleccionMultiple=True,
xid=GRID_GAMES_QUEUED)
self.register_grid(self.gridGamesQueued)
# Layout
layout = Colocacion.V().control(tbEnG).control(self.gridGamesQueued)
# Creamos
w.setLayout(layout)
tab.nuevaTab(w, _("Games queued"))
# Tab-games terminados--------------------------------------------------
w = QtWidgets.QWidget()
# TB
li_acciones = [
(_("Remove"), Iconos.Borrar(), self.gm_borrar_finished),
None,
(_("Show"), Iconos.PGN(), self.gm_show_finished),
None,
(_("Save") + "(%s)" % _("PGN"), Iconos.GrabarComo(),
self.gm_save_pgn),
None,
]
tbEnGt = Controles.TBrutina(self,
li_acciones,
tamIcon=16,
style=QtCore.Qt.ToolButtonTextBesideIcon)
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 50, centered=True)
o_columns.nueva("WHITE", _("White"), 190, centered=True)
o_columns.nueva("BLACK", _("Black"), 190, centered=True)
o_columns.nueva("TIME", _("Time"), 170, centered=True)
o_columns.nueva("RESULT", _("Result"), 190, centered=True)
self.gridGamesFinished = Grid.Grid(self,
o_columns,
siSelecFilas=True,
siSeleccionMultiple=True,
xid=GRID_GAMES_FINISHED)
self.register_grid(self.gridGamesFinished)
# Layout
layout = Colocacion.V().control(tbEnGt).control(self.gridGamesFinished)
# Creamos
w.setLayout(layout)
tab.nuevaTab(w, _("Games finished"))
# Tab-resultado --------------------------------------------------
w = QtWidgets.QWidget()
# Grid
wh = _("W")
bl = _("B")
o_columns = Columnas.ListaColumnas()
o_columns.nueva("NUM", _("N."), 35, centered=True)
o_columns.nueva("ENGINE", _("Engine"), 120, centered=True)
o_columns.nueva("SCORE", _("Score") + "%", 50, centered=True)
o_columns.nueva("WIN", _("Wins"), 50, centered=True)
o_columns.nueva("DRAW", _("Draws"), 50, centered=True)
o_columns.nueva("LOST", _("Losses"), 50, centered=True)
o_columns.nueva("WIN-WHITE",
"%s %s" % (wh, _("Wins")),
60,
centered=True)
o_columns.nueva("DRAW-WHITE",
"%s %s" % (wh, _("Draws")),
60,
centered=True)
o_columns.nueva("LOST-WHITE",
"%s %s" % (wh, _("Losses")),
60,
centered=True)
o_columns.nueva("WIN-BLACK",
"%s %s" % (bl, _("Wins")),
60,
centered=True)
o_columns.nueva("DRAW-BLACK",
"%s %s" % (bl, _("Draws")),
60,
centered=True)
o_columns.nueva("LOST-BLACK",
"%s %s" % (bl, _("Losses")),
60,
centered=True)
o_columns.nueva("GAMES", _("Games"), 50, centered=True)
self.gridResults = Grid.Grid(self,
o_columns,
siSelecFilas=True,
xid=GRID_RESULTS)
self.register_grid(self.gridResults)
self.qtColor = {
"WHITE": QTUtil.qtColorRGB(255, 250, 227),
"BLACK": QTUtil.qtColorRGB(221, 255, 221),
"SCORE": QTUtil.qtColorRGB(170, 170, 170),
}
# Layout
layout = Colocacion.V().control(self.gridResults)
# Creamos
w.setLayout(layout)
tab.nuevaTab(w, _("Results"))
# Layout
# tab.setposition("W")
layout = Colocacion.V().control(tb).espacio(-3).control(tab).margen(2)
self.setLayout(layout)
self.restore_video(siTam=True, anchoDefecto=800, altoDefecto=430)
self.gridEnginesAlias.gotop()
self.ed_resign.setFocus()
self.muestraPosicion()
QtCore.QTimer.singleShot(5000, self.comprueba_cambios)
self.rotulos_tabs()
def paramAnalisisMasivo(parent, configuracion, siVariosSeleccionados, siDatabase=False):
alm = leeDicParametros(configuracion)
# Datos
liGen = [SEPARADOR]
# # Tutor
li = configuracion.ayudaCambioTutor()
li[0] = alm.engine
liGen.append((_("Engine") + ":", li))
liGen.append(SEPARADOR)
# # Time
config = FormLayout.Editbox(_("Duration of engine analysis (secs)"), 40, tipo=float)
liGen.append((config, alm.vtime / 1000.0))
# Depth
liDepths = [("--", 0)]
for x in range(1, 31):
liDepths.append((str(x), x))
config = FormLayout.Combobox(_("Depth"), liDepths)
liGen.append((config, alm.depth))
# Time+Depth
liGen.append(("%s+%s:" % (_("Time"), _("Depth")), alm.timedepth))
# MultiPV
liGen.append(SEPARADOR)
li = [(_("Default"), "PD"), (_("Maximum"), "MX")]
for x in (1, 3, 5, 10, 15, 20, 30, 40, 50, 75, 100, 150, 200):
li.append((str(x), str(x)))
config = FormLayout.Combobox(_("Number of moves evaluated by engine(MultiPV)"), li)
liGen.append((config, alm.multiPV))
liGen.append(SEPARADOR)
liJ = [(_("White"), "WHITE"), (_("Black"), "BLACK"), (_("White & Black"), "BOTH")]
config = FormLayout.Combobox(_("Analyze only color"), liJ)
if alm.white and alm.black:
color = "BOTH"
elif alm.black:
color = "BLACK"
elif alm.white:
color = "WHITE"
else:
color = "BOTH"
liGen.append((config, color))
liGen.append(('<div align="right">' + _("Only player moves") + ":<br>%s</div>" % _("(You can add multiple aliases separated by ; and wildcard * )"), ""))
fvar = configuracion.ficheroBooks
listaLibros = Books.ListaLibros()
listaLibros.restore_pickle(fvar)
# Comprobamos que todos esten accesibles
listaLibros.comprueba()
defecto = listaLibros.lista[0]
li = [("--", None)]
for book in listaLibros.lista:
if book.name == alm.book_name:
defecto = book
li.append((book.name, book))
config = FormLayout.Combobox(_("Do not scan the opening moves based on book"), li)
liGen.append((config, defecto))
liGen.append((_("Start from the end of the game") + ":", alm.from_last_move))
liGen.append(SEPARADOR)
liGen.append((_("Redo any existing prior analyses (if they exist)") + ":", alm.delete_previous))
liGen.append(SEPARADOR)
liGen.append((_("Only selected games") + ":", siVariosSeleccionados))
liVar = form_variations(alm)
liBlunders, liBrilliancies = formBlundersBrilliancies(alm, configuracion)
lista = []
lista.append((liGen, _("General options"), ""))
lista.append((liVar, _("Variations"), ""))
lista.append((liBlunders, _("Wrong moves"), ""))
lista.append((liBrilliancies, _("Brilliancies"), ""))
reg = Util.Record()
reg.form = None
def dispatchR(valor):
if reg.form is None:
if isinstance(valor, FormLayout.FormTabWidget):
reg.form = valor
reg.wtime = valor.getWidget(0, 1)
reg.wdepth = valor.getWidget(0, 2)
reg.wdt = valor.getWidget(0, 3)
elif isinstance(valor, FormLayout.FormWidget):
reg.form = valor
reg.wtime = valor.getWidget(1)
reg.wdepth = valor.getWidget(2)
reg.wdt = valor.getWidget(3)
else:
sender = reg.form.sender()
if not reg.wdt.isChecked():
if sender == reg.wtime:
if reg.wtime.textoFloat() > 0:
reg.wdepth.setCurrentIndex(0)
elif sender == reg.wdepth:
if reg.wdepth.currentIndex() > 0:
reg.wtime.ponFloat(0.0)
elif sender == reg.wdt:
if reg.wtime.textoFloat() > 0:
reg.wdepth.setCurrentIndex(0)
elif reg.wdepth.currentIndex() > 0:
reg.wtime.ponFloat(0.0)
QTUtil.refresh_gui()
resultado = FormLayout.fedit(lista, title=_("Mass analysis"), parent=parent, anchoMinimo=460, icon=Iconos.Opciones(), dispatch=dispatchR)
if resultado:
accion, liResp = resultado
liGen, liVar, liBlunders, liBrilliancies = liResp
alm.engine, vtime, alm.depth, alm.timedepth, alm.multiPV, color, cjug, alm.book, alm.from_last_move, alm.delete_previous, alm.siVariosSeleccionados = liGen
alm.vtime = int(vtime * 1000)
alm.white = color != "BLACK"
alm.black = color != "WHITE"
cjug = cjug.strip()
alm.li_players = cjug.upper().split(";") if cjug else None
alm.book_name = alm.book.name if alm.book else None
alm.kblunders, alm.tacticblunders, alm.pgnblunders, alm.oriblunders, alm.bmtblunders = liBlunders
alm.include_variations, alm.limiteinclude_variations, alm.best_variation, alm.info_variation, alm.si_pdt, alm.one_move_variation = liVar
alm.dpbrilliancies, alm.ptbrilliancies, alm.fnsbrilliancies, alm.pgnbrilliancies, alm.oribrilliancies, alm.bmtbrilliancies = liBrilliancies
dic = {}
for x in dir(alm):
if not x.startswith("__"):
dic[x.upper()] = getattr(alm, x)
Util.save_pickle(configuracion.file_param_analysis(), dic)
if not (alm.tacticblunders or alm.pgnblunders or alm.bmtblunders or alm.fnsbrilliancies or alm.pgnbrilliancies or alm.bmtbrilliancies or siDatabase):
QTUtil2.message_error(parent, _("No file was specified where to save results"))
return
return alm
else:
return None
def paramAnalisis(parent, configuracion, siModoAmpliado, siTodosMotores=False):
alm = leeDicParametros(configuracion)
# Datos
liGen = [SEPARADOR]
# # Tutor
if siTodosMotores:
li = configuracion.ayudaCambioCompleto(alm.engine)
else:
li = configuracion.ayudaCambioTutor()
li[0] = alm.engine
liGen.append((_("Engine") + ":", li))
# # Time
liGen.append(SEPARADOR)
config = FormLayout.Editbox(_("Duration of engine analysis (secs)"), 40, tipo=float)
liGen.append((config, alm.vtime / 1000.0))
# Depth
liDepths = [("--", 0)]
for x in range(1, 51):
liDepths.append((str(x), x))
config = FormLayout.Combobox(_("Depth"), liDepths)
liGen.append((config, alm.depth))
# Time+Depth
liGen.append(("%s+%s:" % (_("Time"), _("Depth")), alm.timedepth))
# MultiPV
liGen.append(SEPARADOR)
li = [(_("Default"), "PD"), (_("Maximum"), "MX")]
for x in (1, 3, 5, 10, 15, 20, 30, 40, 50, 75, 100, 150, 200):
li.append((str(x), str(x)))
config = FormLayout.Combobox(_("Number of moves evaluated by engine(MultiPV)"), li)
liGen.append((config, alm.multiPV))
# Priority
liGen.append(SEPARADOR)
config = FormLayout.Combobox(_("Process priority"), Priorities.priorities.combo())
liGen.append((config, alm.priority))
# Completo
if siModoAmpliado:
liGen.append(SEPARADOR)
liJ = [(_("White"), "WHITE"), (_("Black"), "BLACK"), (_("White & Black"), "BOTH")]
config = FormLayout.Combobox(_("Analyze only color"), liJ)
if alm.white and alm.black:
color = "BOTH"
elif alm.black:
color = "BLACK"
elif alm.white:
color = "WHITE"
else:
color = "BOTH"
liGen.append((config, color))
config = FormLayout.Editbox('<div align="right">' + _("Moves") + "<br>" + _("By example:") + " -5,8-12,14,19-", rx="[0-9,\-,\,]*")
liGen.append((config, ""))
fvar = configuracion.ficheroBooks
listaLibros = Books.ListaLibros()
listaLibros.restore_pickle(fvar)
# Comprobamos que todos esten accesibles
listaLibros.comprueba()
li = [("--", None)]
defecto = listaLibros.lista[0] if alm.book_name else None
for book in listaLibros.lista:
if alm.book_name == book.name:
defecto = book
li.append((book.name, book))
config = FormLayout.Combobox(_("Do not scan the opening moves based on book"), li)
liGen.append((config, defecto))
liGen.append(SEPARADOR)
liGen.append((_("Redo any existing prior analyses (if they exist)") + ":", alm.delete_previous))
liGen.append((_("Start from the end of the game") + ":", alm.from_last_move))
liGen.append(SEPARADOR)
liGen.append((_("Show graphics") + ":", alm.show_graphs))
liVar = form_variations(alm)
liBlunders, liBrilliancies = formBlundersBrilliancies(alm, configuracion)
liST = [SEPARADOR]
liST.append((_("Activate") + ":", alm.stability))
liST.append(SEPARADOR)
liST.append((FormLayout.Spinbox(_("Last depths to control same best move"), 2, 10, 40), alm.st_depths))
liST.append(SEPARADOR)
liST.append((FormLayout.Spinbox(_("Maximum difference among last evaluations"), 0, 99999, 60), alm.st_centipawns))
liST.append(SEPARADOR)
liST.append((FormLayout.Spinbox(_("Additional time limit"), 0, 99999, 60), alm.st_timelimit))
lista = []
lista.append((liGen, _("General options"), ""))
lista.append((liVar, _("Variations"), ""))
lista.append((liBlunders, _("Wrong moves"), ""))
lista.append((liBrilliancies, _("Brilliancies"), ""))
lista.append((liST, _("Stability control"), ""))
else:
lista = liGen
reg = Util.Record()
reg.form = None
def dispatchR(valor):
if reg.form is None:
if isinstance(valor, FormLayout.FormTabWidget):
reg.form = valor
reg.wtime = valor.getWidget(0, 1)
reg.wdepth = valor.getWidget(0, 2)
reg.wdt = valor.getWidget(0, 3)
elif isinstance(valor, FormLayout.FormWidget):
reg.form = valor
reg.wtime = valor.getWidget(1)
reg.wdepth = valor.getWidget(2)
reg.wdt = valor.getWidget(3)
else:
sender = reg.form.sender()
if not reg.wdt.isChecked():
if sender == reg.wtime:
if reg.wtime.textoFloat() > 0:
reg.wdepth.setCurrentIndex(0)
elif sender == reg.wdepth:
if reg.wdepth.currentIndex() > 0:
reg.wtime.ponFloat(0.0)
elif sender == reg.wdt:
if reg.wtime.textoFloat() > 0:
reg.wdepth.setCurrentIndex(0)
elif reg.wdepth.currentIndex() > 0:
reg.wtime.ponFloat(0.0)
QTUtil.refresh_gui()
resultado = FormLayout.fedit(lista, title=_("Analysis Configuration"), parent=parent, anchoMinimo=460, icon=Iconos.Opciones(), dispatch=dispatchR)
if resultado:
accion, liResp = resultado
if siModoAmpliado:
liGen, liVar, liBlunders, liBrilliancies, liST = liResp
else:
liGen = liResp
alm.engine = liGen[0]
alm.vtime = int(liGen[1] * 1000)
alm.depth = liGen[2]
alm.timedepth = liGen[3]
alm.multiPV = liGen[4]
alm.priority = liGen[5]
if siModoAmpliado:
color = liGen[6]
alm.white = color != "BLACK"
alm.black = color != "WHITE"
alm.num_moves = liGen[7]
alm.book = liGen[8]
alm.book_name = alm.book.name if alm.book else None
alm.delete_previous = liGen[9]
alm.from_last_move = liGen[10]
alm.show_graphs = liGen[11]
(alm.include_variations, alm.limit_include_variations, alm.best_variation, alm.info_variation, alm.si_pdt, alm.one_move_variation) = liVar
(alm.kblunders, alm.tacticblunders, alm.pgnblunders, alm.oriblunders, alm.bmtblunders) = liBlunders
(alm.dpbrilliancies, alm.ptbrilliancies, alm.fnsbrilliancies, alm.pgnbrilliancies, alm.oribrilliancies, alm.bmtbrilliancies) = liBrilliancies
(alm.stability, alm.st_depths, alm.st_centipawns, alm.st_timelimit) = liST
dic = {}
for x in dir(alm):
if not x.startswith("__"):
dic[x] = getattr(alm, x)
Util.save_pickle(configuracion.file_param_analysis(), dic)
return alm
else:
return None
def trainNewEngines(self):
training = self.dbop.trainingEngines()
color = "WHITE"
basepv = self.dbop.basePV
mandatory = basepv.count(" ") + 1 if len(basepv) > 0 else 0
control = 10
lost_points = 20
engine_control = self.configuracion.tutor.clave
engine_time = 5.0
num_engines = 20
key_engine = "alaric"
ext_engines = []
auto_analysis = True
ask_movesdifferent = False
times = [500, 1000, 2000, 4000, 8000]
books = ["", "", "", "", ""]
books_sel = ["", "", "", "", ""]
if training is not None:
color = training["COLOR"]
mandatory = training.get("MANDATORY", mandatory)
control = training.get("CONTROL", control)
lost_points = training.get("LOST_POINTS", lost_points)
engine_control = training.get("ENGINE_CONTROL", engine_control)
engine_time = training.get("ENGINE_TIME", engine_time)
num_engines = training.get("NUM_ENGINES", num_engines)
key_engine = training.get("KEY_ENGINE", key_engine)
ext_engines = training.get("EXT_ENGINES", ext_engines)
auto_analysis = training.get("AUTO_ANALYSIS", auto_analysis)
ask_movesdifferent = training.get("ASK_MOVESDIFFERENT", ask_movesdifferent)
times = training.get("TIMES", times)
books = training.get("BOOKS", books)
books_sel = training.get("BOOKS_SEL", books_sel)
separador = FormLayout.separador
li_gen = [separador]
liJ = [(_("White"), "WHITE"), (_("Black"), "BLACK")]
config = FormLayout.Combobox(_("Play with"), liJ)
li_gen.append((config, color))
li_gen.append((_("Mandatory moves") + ":", mandatory))
li_gen.append(separador)
li_gen.append((_("Moves until the control") + ":", control))
li_gen.append(separador)
li_gen.append((_("Maximum number of lost centipawns to pass control") + ":", lost_points))
li_gen.append(separador)
dic_engines = self.configuracion.dic_engines
li_engines = EnginesBunch.lista(dic_engines)
config = FormLayout.Spinbox(
"%s: %s" % (_("Automatic selection"), _("number of engines")), 0, len(li_engines), 50
)
li_gen.append((config, num_engines))
likeys = [(dic_engines[x].name, x) for x in li_engines]
config = FormLayout.Combobox("%s: %s" % (_("Automatic selection"), _("bunch of engines")), likeys)
li_gen.append((config, key_engine))
li_gen.append(separador)
config = FormLayout.Combobox(_("Engine that does the control"), self.configuracion.comboMotores())
li_gen.append((config, engine_control))
li_gen.append((_("Duration of analysis (secs)") + ":", float(engine_time)))
li_gen.append(separador)
li_gen.append((_("Automatic analysis") + ":", auto_analysis))
li_gen.append(separador)
li_gen.append((_("Ask when the moves are different from the line") + ":", ask_movesdifferent))
li = [("--", "")]
for clave, cm in self.configuracion.dic_engines.items():
li.append((cm.nombre_ext(), clave))
li = sorted(li, key=operator.itemgetter(1))
li_ext = []
for x in range(16):
config = FormLayout.Combobox("%s %d" % (_("Engine"), x + 1), li)
clave = ext_engines[x] if len(ext_engines) > x else ""
li_ext.append((config, clave))
liLevels = [separador]
listaLibros = Books.ListaLibros()
listaLibros.restore_pickle(self.configuracion.ficheroBooks)
listaLibros.comprueba()
libooks = [(bookx.name, bookx) for bookx in listaLibros.lista]
libooks.insert(0, ("--", None))
li_books_sel = (
("", ""),
(_("Uniform random"), "au"),
(_("Proportional random"), "ap"),
(_("Always the highest percentage"), "mp"),
)
for level in range(5):
n = level + 1
title = "%s %d" % (_("Level"), n)
# liLevels.append((None, title))
tm = times[level] / 1000.0 if len(times) > level else 0.0
liLevels.append(("%s. %s:" % (title, _("Time engines think in seconds")), tm))
bk = books[level] if len(books) > level else ""
book = listaLibros.buscaLibro(bk) if bk else None
config = FormLayout.Combobox(_("Book"), libooks)
liLevels.append((config, book))
config = FormLayout.Combobox(_("Book selection mode"), li_books_sel)
liLevels.append((config, books_sel[level]))
lista = []
lista.append((li_gen, _("Basic data"), ""))
lista.append((li_ext, _("Manual engine selection"), ""))
lista.append((liLevels, _("Levels"), ""))
resultado = FormLayout.fedit(lista, title=_("With engines"), parent=self, anchoMinimo=360, icon=Iconos.Study())
if resultado is None:
return
accion, liResp = resultado
selMotoresExt = []
li_gen, li_ext, liLevels = liResp
for key in li_ext:
if key:
selMotoresExt.append(key)
reg = {}
(
reg["COLOR"],
reg["MANDATORY"],
reg["CONTROL"],
reg["LOST_POINTS"],
reg["NUM_ENGINES"],
reg["KEY_ENGINE"],
reg["ENGINE_CONTROL"],
reg["ENGINE_TIME"],
reg["AUTO_ANALYSIS"],
reg["ASK_MOVESDIFFERENT"],
) = li_gen
reg["EXT_ENGINES"] = selMotoresExt
if (len(selMotoresExt) + reg["NUM_ENGINES"]) == 0:
reg["NUM_ENGINES"] = 1
times = []
books = []
books_sel = []
for x in range(5):
tm = int(liLevels[x * 3] * 1000)
bk = liLevels[x * 3 + 1]
bk_mode = liLevels[x * 3 + 2]
if tm:
times.append(tm)
books.append(bk.name if bk else "")
books_sel.append(bk_mode)
if len(times) == 0:
times.append(500)
books.append(None)
reg["TIMES"] = times
reg["BOOKS"] = books
reg["BOOKS_SEL"] = books_sel
self.dbop.createTrainingEngines(reg, self.procesador)
QTUtil2.message_bold(self, _("Created"))
def __init__(self, wParent, listaMotores, engine, siTorneo=False):
super(WEngine, self).__init__(wParent)
self.setWindowTitle(engine.version)
self.setWindowIcon(Iconos.Motor())
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint
| QtCore.Qt.Dialog
| QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowMinimizeButtonHint
| QtCore.Qt.WindowMaximizeButtonHint)
scrollArea = wgen_options_engine(self, engine)
self.motorExterno = engine
self.liMotores = listaMotores
self.siTorneo = siTorneo
# Toolbar
tb = QTUtil2.tbAcceptCancel(self)
lbAlias = Controles.LB2P(self, _("Alias"))
self.edAlias = Controles.ED(self, engine.clave).anchoMinimo(360)
lbNombre = Controles.LB2P(self, _("Name"))
self.edNombre = Controles.ED(self, engine.name).anchoMinimo(360)
lbInfo = Controles.LB(self, _("Information") + ": ")
self.emInfo = Controles.EM(self, engine.id_info,
siHTML=False).anchoMinimo(360).altoFijo(60)
lbElo = Controles.LB(self, "ELO: ")
self.sbElo = Controles.SB(self, engine.elo, 0, 4000)
lbExe = Controles.LB(
self, "%s: %s" % (_("File"), Util.relative_path(engine.path_exe)))
if siTorneo:
lbDepth = Controles.LB(self, _("Maximum depth") + ": ")
self.sbDepth = Controles.SB(self, engine.max_depth, 0, 50)
lbTime = Controles.LB(self, _("Maximum seconds to think") + ": ")
self.sbTime = Controles.SB(self, engine.max_time, 0, 9999)
lbBook = Controles.LB(self, _("Opening book") + ": ")
fvar = Code.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.restore_pickle(fvar)
# # Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
li = [(x.name, x.path) for x in self.listaLibros.lista]
li.insert(0, ("* " + _("None"), "-"))
li.insert(0, ("* " + _("Default"), "*"))
self.cbBooks = Controles.CB(self, li, engine.book)
btNuevoBook = Controles.PB(self, "", self.nuevoBook,
plano=False).ponIcono(Iconos.Nuevo(),
tamIcon=16)
# # Respuesta rival
li = (
(_("Uniform random"), "au"),
(_("Proportional random"), "ap"),
(_("Always the highest percentage"), "mp"),
)
self.cbBooksRR = QTUtil2.comboBoxLB(self, li, engine.bookRR)
lyBook = (Colocacion.H().control(lbBook).control(
self.cbBooks).control(
self.cbBooksRR).control(btNuevoBook).relleno())
lyDT = (Colocacion.H().control(lbDepth).control(
self.sbDepth).espacio(40).control(lbTime).control(
self.sbTime).relleno())
lyTorneo = Colocacion.V().otro(lyDT).otro(lyBook)
# Layout
ly = Colocacion.G()
ly.controld(lbAlias, 0, 0).control(self.edAlias, 0, 1)
ly.controld(lbNombre, 1, 0).control(self.edNombre, 1, 1)
ly.controld(lbInfo, 2, 0).control(self.emInfo, 2, 1)
ly.controld(lbElo, 3, 0).control(self.sbElo, 3, 1)
ly.control(lbExe, 4, 0, 1, 2)
if siTorneo:
ly.otro(lyTorneo, 5, 0, 1, 2)
layout = Colocacion.V().control(tb).espacio(30).otro(ly).control(
scrollArea)
self.setLayout(layout)
self.edAlias.setFocus()
def __init__(self, procesador):
self.configuracion = procesador.configuracion
self.procesador = procesador
self.dbHisto = UtilSQL.DictSQL(self.configuracion.ficheroGMhisto)
self.bloqueApertura = None
self.liAperturasFavoritas = []
wParent = procesador.main_window
titulo = _("Play like a Grandmaster")
icono = Iconos.GranMaestro()
extparam = "gm"
QTVarios.WDialogo.__init__(self, wParent, titulo, icono, extparam)
flb = Controles.TipoLetra(puntos=10)
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("One game"), Iconos.Uno(), self.unJuego),
None,
(_("Import"), Iconos.ImportarGM(), self.importar),
]
tb = Controles.TBrutina(self, li_acciones)
# Grandes maestros
self.liGM = GM.lista_gm()
li = [(x[0], x[1]) for x in self.liGM]
li.insert(0, ("-", None))
self.cbGM = QTUtil2.comboBoxLB(
self, li, li[0][1] if len(self.liGM) == 0 else li[1][1])
self.cbGM.capturaCambiado(self.compruebaGM)
hbox = Colocacion.H().relleno().control(self.cbGM).relleno()
gbGM = Controles.GB(self, _("Choose a Grandmaster"),
hbox).ponFuente(flb)
# Personales
self.liPersonal = GM.lista_gm_personal(
self.procesador.configuracion.dirPersonalTraining)
if self.liPersonal:
li = [(x[0], x[1]) for x in self.liPersonal]
li.insert(0, ("-", None))
self.cbPersonal = QTUtil2.comboBoxLB(self, li, li[0][1])
self.cbPersonal.capturaCambiado(self.compruebaP)
btBorrar = Controles.PB(self, "", self.borrarPersonal,
plano=False).ponIcono(Iconos.Borrar(),
tamIcon=16)
hbox = Colocacion.H().relleno().control(
self.cbPersonal).control(btBorrar).relleno()
gbPersonal = Controles.GB(self, _("Personal games"),
hbox).ponFuente(flb)
# Color
self.rbBlancas = Controles.RB(self,
_("White"),
rutina=self.check_color)
self.rbBlancas.activa(True)
self.rbNegras = Controles.RB(self, _("Black"), rutina=self.check_color)
self.rbNegras.activa(False)
# Contrario
self.chContrario = Controles.CHB(
self,
_("Choose the opponent's move, when there are multiple possible answers"
), False)
# Juez
liDepths = [("--", 0)]
for x in range(1, 31):
liDepths.append((str(x), x))
self.liMotores = self.configuracion.comboMotoresMultiPV10()
self.cbJmotor, self.lbJmotor = QTUtil2.comboBoxLB(
self, self.liMotores, self.configuracion.tutor_inicial,
_("Engine"))
self.edJtiempo = Controles.ED(self).tipoFloat().ponFloat(
1.0).anchoFijo(50)
self.lbJtiempo = Controles.LB2P(self, _("Time in seconds"))
self.cbJdepth = Controles.CB(self, liDepths,
0).capturaCambiado(self.cambiadoDepth)
self.lbJdepth = Controles.LB2P(self, _("Depth"))
self.lbJshow = Controles.LB2P(self, _("Show rating"))
self.chbEvals = Controles.CHB(self, _("Show all evaluations"), False)
liOptions = [(_("All moves"), None), (_("Moves are different"), True),
(_("Never"), False)]
self.cbJshow = Controles.CB(self, liOptions, True)
self.lbJmultiPV = Controles.LB2P(
self, _("Number of moves evaluated by engine(MultiPV)"))
li = [(_("Default"), "PD"), (_("Maximum"), "MX")]
for x in (1, 3, 5, 10, 15, 20, 30, 40, 50, 75, 100, 150, 200):
li.append((str(x), str(x)))
self.cbJmultiPV = Controles.CB(self, li, "PD")
# Inicial
self.edJugInicial, lbInicial = QTUtil2.spinBoxLB(
self, 1, 1, 99, etiqueta=_("Initial move"), maxTam=40)
# Libros
fvar = self.configuracion.ficheroBooks
self.listaLibros = Books.ListaLibros()
self.listaLibros.restore_pickle(fvar)
# # Comprobamos que todos esten accesibles
self.listaLibros.comprueba()
li = [(x.name, x) for x in self.listaLibros.lista]
li.insert(0, ("--", None))
self.cbBooks, lbBooks = QTUtil2.comboBoxLB(
self, li, None, _("Bypass moves in the book"))
# Aperturas
self.btApertura = Controles.PB(self,
" " * 5 + _("Undetermined") + " " * 5,
self.aperturasEditar).ponPlano(False)
self.btAperturasFavoritas = Controles.PB(
self, "", self.aperturasFavoritas).ponIcono(Iconos.Favoritos())
self.btAperturasQuitar = Controles.PB(
self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No())
hbox = (Colocacion.H().control(self.btAperturasQuitar).control(
self.btApertura).control(self.btAperturasFavoritas).relleno())
gbOpening = Controles.GB(self, _("Opening"), hbox)
# gbBasic
# # Color
hbox = Colocacion.H().relleno().control(
self.rbBlancas).espacio(10).control(self.rbNegras).relleno()
gbColor = Controles.GB(self, _("Play with"), hbox).ponFuente(flb)
# Tiempo
ly1 = (Colocacion.H().control(self.lbJmotor).control(
self.cbJmotor).control(self.lbJshow).control(
self.cbJshow).relleno())
ly2 = Colocacion.H().control(self.lbJtiempo).control(self.edJtiempo)
ly2.control(self.lbJdepth).control(self.cbJdepth).espacio(15).control(
self.chbEvals).relleno()
ly3 = Colocacion.H().control(self.lbJmultiPV).control(
self.cbJmultiPV).relleno()
ly = Colocacion.V().otro(ly1).otro(ly2).otro(ly3)
self.gbJ = Controles.GB(self, _("Adjudicator"),
ly).conectar(self.cambiaJuez)
# Opciones
vlayout = Colocacion.V().control(gbColor)
vlayout.espacio(5).control(self.gbJ)
vlayout.margen(20)
gbBasic = Controles.GB(self, "", vlayout)
gbBasic.setFlat(True)
# Opciones avanzadas
lyInicial = (Colocacion.H().control(lbInicial).control(
self.edJugInicial).relleno().control(lbBooks).control(
self.cbBooks).relleno())
vlayout = Colocacion.V().relleno().otro(lyInicial).control(gbOpening)
vlayout.espacio(5).control(self.chContrario).margen(20).relleno()
gbAdvanced = Controles.GB(self, "", vlayout)
gbAdvanced.setFlat(True)
# Historico
self.liHisto = []
o_columns = Columnas.ListaColumnas()
o_columns.nueva("FECHA", _("Date"), 80, centered=True)
o_columns.nueva("PACIERTOS", _("Hints"), 90, centered=True)
o_columns.nueva("PUNTOS", _("Points accumulated"), 120, centered=True)
o_columns.nueva("ENGINE", _("Adjudicator"), 100, centered=True)
o_columns.nueva("RESUMEN", _("Game played"), 150)
self.grid = grid = Grid.Grid(self,
o_columns,
siSelecFilas=True,
background=None)
self.grid.coloresAlternados()
self.register_grid(grid)
# Tabs
self.tab = Controles.Tab().setposition("S")
self.tab.nuevaTab(gbBasic, _("Basic"))
self.tab.nuevaTab(gbAdvanced, _("Advanced"))
self.tab.nuevaTab(self.grid, _("Track record"))
# Cabecera
lyCab = Colocacion.H().control(gbGM)
if self.liPersonal:
lyCab.control(gbPersonal)
layout = Colocacion.V().control(tb).otro(lyCab).control(
self.tab).margen(6)
self.setLayout(layout)
self.recuperaDic()
self.cambiaJuez()
self.compruebaGM()
self.compruebaP()
self.compruebaHisto()
self.aperturaMuestra()
self.btAperturasFavoritas.hide()
self.restore_video(anchoDefecto=450)
def reinicio(self, dbop):
self.dbop = dbop
self.dbop.open_cache_engines()
self.game_type = GT_OPENING_LINES
self.level = self.dbop.getconfig("ENG_LEVEL", 0)
self.numengine = self.dbop.getconfig("ENG_ENGINE", 0)
self.trainingEngines = self.dbop.trainingEngines()
self.auto_analysis = self.trainingEngines.get("AUTO_ANALYSIS", True)
self.ask_movesdifferent = self.trainingEngines.get(
"ASK_MOVESDIFFERENT", False)
liTimes = self.trainingEngines.get("TIMES")
if not liTimes:
liTimes = [500, 1000, 2000, 4000, 8000]
liBooks = self.trainingEngines.get("BOOKS")
if not liBooks:
liBooks = ["", "", "", "", ""]
liBooks_sel = self.trainingEngines.get("BOOKS_SEL")
if not liBooks_sel:
liBooks_sel = ["", "", "", "", ""]
liEngines = self.trainingEngines["ENGINES"]
num_engines_base = len(liEngines)
liEnginesExt = [
key for key in self.trainingEngines.get("EXT_ENGINES", [])
if not (key in liEngines)
]
num_engines = num_engines_base + len(liEnginesExt)
if self.numengine >= num_engines:
self.level += 1
self.numengine = 0
self.dbop.setconfig("ENG_LEVEL", self.level)
self.dbop.setconfig("ENG_ENGINE", 0)
num_levels = len(liTimes)
if self.level >= num_levels:
if QTUtil2.pregunta(
self.main_window, "%s.\n%s" %
(_("Training finished"), _("Do you want to reinit?"))):
self.dbop.setconfig("ENG_LEVEL", 0)
self.dbop.setconfig("ENG_ENGINE", 0)
self.reinicio(dbop)
return
self.time = liTimes[self.level]
nombook = liBooks[self.level]
if nombook:
listaLibros = Books.ListaLibros()
listaLibros.restore_pickle(self.configuracion.ficheroBooks)
self.book = listaLibros.buscaLibro(nombook)
if self.book:
self.book.polyglot()
self.book.mode = liBooks_sel[self.level]
if not self.book.mode:
self.book.mode = "mp"
else:
self.book = None
if self.numengine < num_engines_base:
self.keyengine = liEngines[self.numengine]
else:
self.keyengine = liEnginesExt[self.numengine - num_engines_base -
1]
self.plies_mandatory = self.trainingEngines["MANDATORY"]
self.plies_control = self.trainingEngines["CONTROL"]
self.plies_pendientes = self.plies_control
self.lost_points = self.trainingEngines["LOST_POINTS"]
self.is_human_side_white = self.trainingEngines["COLOR"] == "WHITE"
self.is_engine_side_white = not self.is_human_side_white
self.siAprobado = False
rival = self.configuracion.buscaRival(self.keyengine)
self.xrival = self.procesador.creaGestorMotor(rival, self.time, None)
self.xrival.is_white = self.is_engine_side_white
juez = self.configuracion.buscaRival(
self.trainingEngines["ENGINE_CONTROL"])
self.xjuez = self.procesador.creaGestorMotor(
juez, int(self.trainingEngines["ENGINE_TIME"] * 1000), None)
self.xjuez.anulaMultiPV()
self.li_info = [
"<b>%s</b>: %d/%d - %s" %
(_("Engine"), self.numengine + 1, num_engines, self.xrival.name),
'<b>%s</b>: %d/%d - %0.1f"' %
(_("Level"), self.level + 1, num_levels, self.time / 1000.0),
]
self.dicFENm2 = self.trainingEngines["DICFENM2"]
self.siAyuda = False
self.tablero.dbVisual_setShowAllways(False)
self.ayudas = 9999 # Para que analice sin problemas
self.game = Game.Game()
self.main_window.pon_toolbar((TB_CLOSE, TB_RESIGN, TB_REINIT))
self.main_window.activaJuego(True, False, siAyudas=False)
self.set_dispatcher(self.mueve_humano)
self.setposition(self.game.last_position)
self.mostrarIndicador(True)
self.quitaAyudas()
self.ponPiezasAbajo(self.is_human_side_white)
self.pgnRefresh(True)
self.ponCapInfoPorDefecto()
self.state = ST_PLAYING
self.dgt_setposition()
self.errores = 0
self.ini_time = time.time()
self.muestraInformacion()
self.siguiente_jugada()
