def seleccionaLibro(self):
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
menu = QTVarios.LCMenu(self)
rondo = QTVarios.rondoPuntos()
for book in list_books.lista:
menu.opcion(("x", book), book.name, rondo.otro())
menu.separador()
menu.opcion(("n", None), _("Install new book"), Iconos.Nuevo())
resp = menu.lanza()
if resp:
orden, book = resp
if orden == "x":
pass
elif orden == "n":
fbin = QTUtil2.leeFichero(self,
list_books.path,
"bin",
titulo=_("Polyglot book"))
if fbin:
list_books.path = os.path.dirname(fbin)
name = os.path.basename(fbin)[:-4]
book = Books.Book("P", name, fbin, True)
list_books.nuevo(book)
list_books.save_pickle(self.configuration.file_books)
else:
book = None
return book
def polyglot_install(self):
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
menu = QTVarios.LCMenu(self.main_window)
for book in list_books.lista:
if not Util.same_path(book.path, Code.tbook):
menu.opcion(("x", book), book.name, Iconos.Delete())
menu.separador()
menu.opcion(("n", None), _("Install new book"), Iconos.Nuevo())
resp = menu.lanza()
if resp:
orden, book = resp
if orden == "x":
if QTUtil2.pregunta(self.main_window,
_("Do you want to delete %s?") %
book.name):
list_books.borra(book)
list_books.save_pickle(self.configuration.file_books)
elif orden == "n":
fbin = QTUtil2.leeFichero(self.main_window,
list_books.path,
"bin",
titulo=_("Polyglot book"))
if fbin:
list_books.path = os.path.dirname(fbin)
name = os.path.basename(fbin)[:-4]
book = Books.Book("P", name, fbin, True)
list_books.nuevo(book)
list_books.save_pickle(self.configuration.file_books)
def importarPolyglot(self, game):
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
dicData = self.dbop.getconfig("IMPORT_POLYGLOT")
bookW = list_books.lista[0]
bookB = list_books.lista[0]
if dicData:
book = list_books.buscaLibro(dicData["BOOKW"])
if book:
bookW = book
book = list_books.buscaLibro(dicData["BOOKB"])
if book:
bookB = book
liGen = [FormLayout.separador]
li = [(bookx.name, bookx) for bookx in list_books.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 import_polyglot(self, game):
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
dicData = self.dbop.getconfig("IMPORT_POLYGLOT")
bookW = list_books.lista[0]
bookB = list_books.lista[0]
if dicData:
book = list_books.buscaLibro(dicData["BOOKW"])
if book:
bookW = book
book = list_books.buscaLibro(dicData["BOOKB"])
if book:
bookB = book
form = FormLayout.FormLayout(self,
_("Polyglot book"),
Iconos.Libros(),
anchoMinimo=360)
form.separador()
li = [(bookx.name, bookx) for bookx in list_books.lista]
form.combobox(_("Book that plays white side"), li, bookW)
form.separador()
form.combobox(_("Book that plays black side"), li, bookB)
form.separador()
resultado = form.run()
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.import_param_books(titulo, True)
if dicData:
depth, siWhite, onlyone, minMoves, excl_transpositions = (
dicData["DEPTH"], dicData["SIWHITE"], dicData["ONLYONE"],
dicData["MINMOVES"], dicData["EXCLTRANSPOSITIONS"])
self.dbop.import_polyglot(self, game, bookW, bookB, titulo, depth,
siWhite, onlyone, minMoves,
excl_transpositions)
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(_("Polyglot book"), Iconos.Book())
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
rondo = QTVarios.rondoPuntos()
for book in list_books.lista:
submenu.opcion(("book", book), book.name, rondo.otro())
submenu.separador()
submenu.opcion(("installbook", None), _("Install new book"),
Iconos.Nuevo())
menu.separador()
si_gaviota = True
si_index = True
for kib in self.kibitzers.lista:
if kib.tipo == Kibitzers.KIB_GAVIOTA:
si_gaviota = False
elif kib.tipo == Kibitzers.KIB_INDEXES:
si_index = False
if si_index:
menu.opcion(("index", None),
_("Indexes") + " - RodentII", Iconos.Camara())
menu.separador()
if si_gaviota:
menu.opcion(("gaviota", None), _("Gaviota Tablebases"),
Iconos.Finales())
resp = menu.lanza()
if resp:
orden, extra = resp
if orden == "engine":
self.nuevo_engine()
elif orden in "book":
num = self.kibitzers.nuevo_polyglot(extra)
self.goto(num)
elif orden == "gaviota":
num = self.kibitzers.nuevo_gaviota()
self.goto(num)
elif orden == "index":
num = self.kibitzers.nuevo_index()
self.goto(num)
elif orden in "installbook":
self.polyglot_install(list_books)
def __init__(self, w_parent):
QtWidgets.QDialog.__init__(self, w_parent)
self.w_parent = w_parent
self.file = ""
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.configuration = Code.configuration
fvar = self.configuration.file_books
self.list_books = Books.ListBooks()
self.list_books.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, manager, siEnVivo):
titulo = _("Consult a book")
icono = Iconos.Libros()
extparam = "treebook"
QTVarios.WDialogo.__init__(self, manager.main_window, titulo, icono,
extparam)
# Se lee la lista de libros1
self.list_books = Books.ListBooks()
self.fvar = manager.configuration.file_books
self.list_books.restore_pickle(self.fvar)
# Comprobamos que todos esten accesibles
self.list_books.check()
self.book = self.list_books.porDefecto()
# fens
fenActivo = manager.fenActivoConInicio() # Posicion en el board
fenUltimo = manager.last_fen()
self.siEnviar = siEnVivo and (fenActivo == fenUltimo)
self.listaMoves = ListaMoves(None, self.book, fenActivo)
self.infoMove = InfoMove(manager.board.is_white_bottom, 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()
anchoBoard = self.infoMove.board.width()
self.resize(600 - 278 + anchoBoard, anchoBoard + 30)
self.splitter.setSizes([296 - 278 + anchoBoard, 290])
for col, ancho in enumerate((100, 59, 87, 0, 38)):
self.wmoves.tree.setColumnWidth(col, ancho)
self.ponTitulo(self.book)
def massive_analysis_parameters(parent,
configuration,
siVariosSeleccionados,
siDatabase=False):
alm = read_dic_params(configuration)
# Datos
liGen = [SEPARADOR]
# # Tutor
li = configuration.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, 100):
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 = configuration.file_books
list_books = Books.ListBooks()
list_books.restore_pickle(fvar)
# Comprobamos que todos esten accesibles
list_books.check()
defecto = list_books.lista[0]
li = [("--", None)]
for book in list_books.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 analysis (if they exist)") + ":",
alm.delete_previous))
liGen.append(SEPARADOR)
liGen.append((_("Only selected games") + ":", siVariosSeleccionados))
liVar = form_variations(alm)
liBlunders, liBrilliancies = form_blunders_brilliancies(alm, configuration)
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(configuration.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 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:
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
self.book = list_books.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.configuration.buscaRival(self.keyengine)
self.xrival = self.procesador.creaManagerMotor(rival, self.time, None)
self.xrival.is_white = self.is_engine_side_white
self.xanalyzer.cambiaOpciones(
max(self.xtutor.motorTiempoJugada, self.time + 5.0), 0)
juez = self.configuration.buscaRival(
self.trainingEngines["ENGINE_CONTROL"])
self.xjuez = self.procesador.creaManagerMotor(
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.board.dbvisual_set_show_allways(False)
self.hints = 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.player_has_moved)
self.set_position(self.game.last_position)
self.show_side_indicator(True)
self.remove_hints()
self.put_pieces_bottom(self.is_human_side_white)
self.pgnRefresh(True)
self.ponCapInfoPorDefecto()
self.state = ST_PLAYING
self.check_boards_setposition()
self.errores = 0
self.ini_time = time.time()
self.muestraInformacion()
self.play_next_move()
def __init__(self, procesador):
w_parent = procesador.main_window
self.configuration = procesador.configuration
self.procesador = procesador
titulo = _("Training with a book")
icono = Iconos.Libros()
QTVarios.WDialogo.__init__(self, w_parent, titulo, icono, "bookstrain")
self.setMinimumWidth(450)
flb = Controles.TipoLetra(puntos=10)
# Variables antiguas
dic_data = self.restore()
# Toolbar
liAcciones = [(_("Accept"), Iconos.Aceptar(), self.aceptar), None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar), None]
tb = Controles.TBrutina(self, liAcciones)
# Side
self.rb_white = Controles.RB(self, _("White"))
self.rb_white.setChecked(dic_data.get(self.ISWHITE, True))
self.rb_black = Controles.RB(self, _("Black"))
self.rb_black.setChecked(not dic_data.get(self.ISWHITE, True))
hbox = Colocacion.H().relleno().control(
self.rb_white).espacio(10).control(self.rb_black).relleno()
gb_side = Controles.GB(self, _("Play with"), hbox).ponFuente(flb)
# Books
fvar = self.configuration.file_books
self.list_books = Books.ListBooks()
self.list_books.restore_pickle(fvar)
self.list_books.check()
li = [(x.name, x) for x in self.list_books.lista]
# Player
book_player = li[0][1] if li else None
nom_book_player = dic_data.get(self.BOOK_PLAYER)
if nom_book_player:
for nom, book in li:
if nom == nom_book_player:
book_player = book
break
self.cb_player = Controles.CB(self, li, book_player)
btNuevo = Controles.PB(self, "", self.nuevo,
plano=False).ponIcono(Iconos.Nuevo(),
icon_size=16)
btBorrar = Controles.PB(self, "", self.borrar,
plano=False).ponIcono(Iconos.Borrar(),
icon_size=16)
self.chb_highest = Controles.CHB(
self, _("Always the highest percentage"),
dic_data.get(self.ALWAYS_HIGHEST, False))
lybook = Colocacion.H().relleno().control(
self.cb_player).control(btNuevo).control(btBorrar).relleno()
ly_select = Colocacion.H().relleno().control(
self.chb_highest).relleno()
ly = Colocacion.V().otro(lybook).espacio(10).otro(ly_select)
gb_player = Controles.GB(self, _("Player's book"), ly).ponFuente(flb)
# Rival
book_rival = book_player
nom_book_rival = dic_data.get(self.BOOK_RIVAL)
if nom_book_rival:
for nom, book in li:
if nom == nom_book_rival:
book_rival = book
break
self.cb_rival = Controles.CB(self, li, book_rival)
li = (
(_("Selected by the player"), "su"),
(_("Uniform random"), "au"),
(_("Proportional random"), "ap"),
(_("Always the highest percentage"), "mp"),
)
self.cb_resp_rival = Controles.CB(self, li,
dic_data.get(self.RESP_RIVAL, "au"))
ly = Colocacion.V().controlc(self.cb_rival).espacio(10).controlc(
self.cb_resp_rival)
gb_rival = Controles.GB(self, _("Rival book"), ly).ponFuente(flb)
self.chb_showmenu = Controles.CHB(
self, _("Display a menu of alternatives if move is invalid"),
dic_data.get(self.SHOW_MENU, True))
vlayout = Colocacion.V()
vlayout.control(gb_side).espacio(5)
vlayout.control(gb_player).espacio(5)
vlayout.control(gb_rival).espacio(5)
vlayout.control(self.chb_showmenu).espacio(5)
vlayout.margen(20)
layout = Colocacion.V().control(tb).otro(vlayout).margen(3)
self.setLayout(layout)
self.restore_video()
def __init__(self, procesador, titulo, direct_option):
QTVarios.WDialogo.__init__(self, procesador.main_window, titulo, Iconos.Libre(), "entMaquina")
font = Controles.TipoLetra(puntos=procesador.configuration.x_menu_points)
self.direct_option = direct_option
self.setFont(font)
self.configuration = procesador.configuration
self.procesador = procesador
self.personalidades = Personalities.Personalities(self, self.configuration)
self.motores = SelectEngines.SelectEngines(self.configuration)
fvar = self.configuration.file_books
self.list_books = Books.ListBooks()
self.list_books.restore_pickle(fvar)
self.list_books.check()
li_books = [(x.name, x) for x in self.list_books.lista]
# Toolbar
li_acciones = [
(_("Accept"), Iconos.Aceptar(), self.aceptar),
None,
(_("Cancel"), Iconos.Cancelar(), self.cancelar),
None,
(_("Configurations"), Iconos.Configurar(), self.configurations),
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 options 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.margen(10)
return ly_g
gb_style = Common.gb_style()
def _label(ly_g, txt, xlayout, rutinaCHB=None, siCheck: object = False):
groupbox = Controles.GB(self, txt, xlayout)
if rutinaCHB:
groupbox.to_connect(rutinaCHB)
elif siCheck:
groupbox.setCheckable(True)
groupbox.setChecked(False)
groupbox.setStyleSheet(gb_style)
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.configuration.x_rival_inicial
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).capture_changes(self.change_time)
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).capture_changes(self.change_depth)
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.configuration.x_menu_points
)
lyV = Colocacion.V().espacio(20).control(self.btRival).espacio(20).control(self.gb_thinks)
_label(lyG, _("Opponent"), lyV)
# # Side
self.rb_white = Controles.RB(self, "").activa()
self.rb_white.setIcon(Iconos.PeonBlanco())
self.rb_white.setIconSize(QtCore.QSize(32, 32))
self.rb_black = Controles.RB(self, "")
self.rb_black.setIcon(Iconos.PeonNegro())
self.rb_black.setIconSize(QtCore.QSize(32, 32))
self.rbRandom = Controles.RB(self, _("Random"))
self.rbRandom.setFont(Controles.TipoLetra(puntos=14))
hbox = (
Colocacion.H().relleno().control(self.rb_white).espacio(30).control(self.rb_black).espacio(30).control(self.rbRandom).relleno()
)
_label(lyG, _("Side you play with"), hbox)
if self.configuration.x_digital_board:
self.chb_dgt = Controles.CHB(self, "%s: %s" % (_("Activate board"), self.configuration.x_digital_board), DGT.siON()).ponFuente(
Controles.TipoLetra(puntos=14)
)
lyH = Colocacion.H().control(self.chb_dgt)
_label(lyG, "", lyH)
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(), icon_size=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)
lbArrows = Controles.LB2P(self, _("Arrows with the best moves")).ponFuente(font)
self.sbArrowsTt = Controles.SB(self, 0, 0, 999).tamMaximo(50).ponFuente(font)
lyT1 = Colocacion.H().control(lbAyudas).control(self.cbAyudas).relleno()
lyT1.control(self.chbChance).relleno().control(btTutorChange)
lyT3 = Colocacion.H().control(lbThoughtTt).control(self.cbThoughtTt).relleno()
lyT3.control(lbArrows).control(self.sbArrowsTt)
ly = Colocacion.V().otro(lyT1).espacio(16).otro(lyT3).relleno()
self.gbTutor = Controles.GB(self, _("Activate the tutor's help"), ly)
self.gbTutor.setCheckable(True)
self.gbTutor.setStyleSheet(gb_style)
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, 0, 0, 999).tamMaximo(50).ponFuente(font)
ly = Colocacion.H().control(lb).control(self.cbThoughtOp).relleno()
ly.control(lbArrows).control(self.sbArrows)
gbThoughtOp = Controles.GB(self, _("Opponent's thought information"), ly)
gbThoughtOp.setStyleSheet(gb_style)
self.lbBoxHeight = Controles.LB2P(self, '%s ("%s")' % (_("Box height"), _("It is showed"))).ponFuente(font)
self.sbBoxHeight = Controles.SB(self, 0, 0, 999).tamMaximo(50).ponFuente(font)
lyBox = Colocacion.H().control(self.lbBoxHeight).control(self.sbBoxHeight).relleno()
ly = Colocacion.V().espacio(16).control(self.gbTutor).control(gbThoughtOp)
ly.espacio(16).otro(lyBox).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)
# Openings
self.btOpening = Controles.PB(self, " " * 5 + _("Undetermined") + " " * 5, self.editOpening).ponPlano(False).ponFuente(font)
self.opening_block = None
self.btOpeningsFavoritas = Controles.PB(self, "", self.preferred_openings).ponIcono(Iconos.Favoritos())
self.btOpeningsQuitar = Controles.PB(self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No())
hbox = Colocacion.H().relleno().control(self.btOpeningsQuitar).control(self.btOpening).control(self.btOpeningsFavoritas).relleno()
_label(lyG, _("Opening"), hbox)
# Libros
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(), icon_size=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(), icon_size=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.configuration.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).capture_changes(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(), icon_size=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, "").set_wrap()
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.li_preferred_openings = []
self.btOpeningsFavoritas.hide()
file = self.configuration.ficheroEntMaquina if self.direct_option else self.configuration.ficheroEntMaquinaPlay
if not os.path.isfile(file):
file = self.configuration.ficheroEntMaquina
dic = Util.restore_pickle(file)
if not dic:
dic = {}
self.restore_dic(dic)
self.ajustesCambiado()
# self.ayudasCambiado()
self.ponRival()
self.restore_video()
def __init__(self, procesador):
self.configuration = procesador.configuration
self.procesador = procesador
self.db_histo = UtilSQL.DictSQL(self.configuration.ficheroGMhisto)
self.opening_block = None
self.li_preferred_openings = []
w_parent = procesador.main_window
titulo = _("Play like a Grandmaster")
icono = Iconos.GranMaestro()
extparam = "gm"
QTVarios.WDialogo.__init__(self, w_parent, titulo, icono, extparam)
flb = Controles.TipoLetra(puntos=procesador.configuration.x_menu_points)
# 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.li_gm = GM.lista_gm()
gb_style = Common.gb_style()
li = [(x[0], x[1]) for x in self.li_gm]
li.insert(0, ("-", None))
self.cb_gm = QTUtil2.comboBoxLB(self, li, li[0][1] if len(self.li_gm) == 0 else li[1][1])
self.cb_gm.capture_changes(self.check_gm)
hbox = Colocacion.H().relleno().control(self.cb_gm).relleno()
gbGM = Controles.GB(self, _("Choose a Grandmaster"), hbox).ponFuente(flb)
gbGM.setStyleSheet(gb_style)
# Personales
self.li_personal = GM.lista_gm_personal(self.procesador.configuration.personal_training_folder)
if self.li_personal:
li = [(x[0], x[1]) for x in self.li_personal]
li.insert(0, ("-", None))
self.cbPersonal = QTUtil2.comboBoxLB(self, li, li[0][1])
self.cbPersonal.capture_changes(self.check_personal)
btBorrar = Controles.PB(self, "", self.borrarPersonal).ponIcono(Iconos.Borrar(), icon_size=24)
hbox = Colocacion.H().relleno().control(self.cbPersonal).control(btBorrar).relleno()
gb_personal = Controles.GB(self, _("Personal games"), hbox).ponFuente(flb)
gb_personal.setStyleSheet(gb_style)
# Color
self.rb_white = Controles.RB(self, _("White"), rutina=self.check_color)
self.rb_white.setFont(flb)
self.rb_white.activa(True)
self.rb_black = Controles.RB(self, _("Black"), rutina=self.check_color)
self.rb_black.setFont(flb)
self.rb_black.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.configuration.comboMotoresMultiPV10()
self.cbJmotor, self.lbJmotor = QTUtil2.comboBoxLB(self, self.liMotores, self.configuration.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).capture_changes(self.change_depth)
self.lbJdepth = Controles.LB2P(self, _("Depth"))
self.lbJshow = Controles.LB2P(self, _("Show rating"))
self.chbEvals = Controles.CHB(self, _("Show all evaluations"), False)
li_options = [(_("All moves"), None), (_("Moves are different"), True), (_("Never"), False)]
self.cbJshow = Controles.CB(self, li_options, 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")
self.li_adjudicator_controls = (
self.cbJmotor,
self.lbJmotor,
self.edJtiempo,
self.lbJtiempo,
self.lbJdepth,
self.cbJdepth,
self.lbJshow,
self.cbJshow,
self.lbJmultiPV,
self.cbJmultiPV,
self.chbEvals,
)
for control in self.li_adjudicator_controls:
control.setFont(flb)
# Inicial
self.edJugInicial, lbInicial = QTUtil2.spinBoxLB(self, 1, 1, 99, etiqueta=_("Initial move"), maxTam=40)
# Libros
fvar = self.configuration.file_books
self.list_books = Books.ListBooks()
self.list_books.restore_pickle(fvar)
# # Comprobamos que todos esten accesibles
self.list_books.check()
li = [(x.name, x) for x in self.list_books.lista]
li.insert(0, ("--", None))
self.cbBooks, lbBooks = QTUtil2.comboBoxLB(self, li, None, _("Bypass moves in the book"))
# Openings
self.btOpening = Controles.PB(self, " " * 5 + _("Undetermined") + " " * 5, self.aperturasEditar).ponPlano(False)
self.btOpeningsFavoritas = Controles.PB(self, "", self.preferred_openings).ponIcono(Iconos.Favoritos())
self.btOpeningsQuitar = Controles.PB(self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No())
hbox = Colocacion.H().control(self.btOpeningsQuitar).control(self.btOpening).control(self.btOpeningsFavoritas).relleno()
gbOpening = Controles.GB(self, _("Opening"), hbox)
# gbBasic
# # Color
hbox = Colocacion.H().relleno().control(self.rb_white).espacio(10).control(self.rb_black).relleno()
gbColor = Controles.GB(self, _("Play with"), hbox).ponFuente(flb)
gbColor.setStyleSheet(gb_style)
# Tiempo
ly1 = Colocacion.H().control(self.lbJmotor).control(self.cbJmotor).relleno().control(self.lbJshow).control(self.cbJshow)
ly2 = Colocacion.H().control(self.lbJtiempo).control(self.edJtiempo)
ly2.control(self.lbJdepth).control(self.cbJdepth).relleno().control(self.chbEvals)
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).to_connect(self.change_adjudicator)
self.gbJ.setStyleSheet(gb_style)
# 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().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"), 100, centered=True)
o_columns.nueva("PACIERTOS", _("Hints"), 90, centered=True)
o_columns.nueva("PUNTOS", _("Points accumulated"), 140, centered=True)
o_columns.nueva("ENGINE", _("Adjudicator"), 100, centered=True)
o_columns.nueva("RESUMEN", _("Game played"), 280)
self.grid = grid = Grid.Grid(self, o_columns, siSelecFilas=True, background=None)
self.grid.coloresAlternados()
self.register_grid(grid)
# Tabs
self.tab = Controles.Tab().set_position("S")
self.tab.nuevaTab(gbBasic, _("Basic"))
self.tab.nuevaTab(gbAdvanced, _("Advanced"))
self.tab.nuevaTab(self.grid, _("Track record"))
self.tab.setFont(flb)
# Cabecera
lyCab = Colocacion.H().control(gbGM)
if self.li_personal:
lyCab.control(gb_personal)
layout = Colocacion.V().control(tb).otro(lyCab).control(self.tab).margen(6)
self.setLayout(layout)
self.restore_dic()
self.change_adjudicator()
self.check_gm()
self.check_personal()
self.check_histo()
self.aperturaMuestra()
self.btOpeningsFavoritas.hide()
self.restore_video(anchoDefecto=750)
def analysis_parameters(parent,
configuration,
siModoAmpliado,
siTodosMotores=False):
alm = read_dic_params(configuration)
# Datos
li_gen = [SEPARADOR]
# # Tutor
if siTodosMotores:
li = configuration.ayudaCambioCompleto(alm.engine)
else:
li = configuration.ayudaCambioTutor()
li[0] = alm.engine
li_gen.append((_("Engine") + ":", li))
# # Time
li_gen.append(SEPARADOR)
config = FormLayout.Editbox(_("Duration of engine analysis (secs)"),
40,
tipo=float)
li_gen.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)
li_gen.append((config, alm.depth))
# Time+Depth
li_gen.append(("%s+%s:" % (_("Time"), _("Depth")), alm.timedepth))
# MultiPV
li_gen.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)
li_gen.append((config, alm.multiPV))
# Priority
li_gen.append(SEPARADOR)
config = FormLayout.Combobox(_("Process priority"),
Priorities.priorities.combo())
li_gen.append((config, alm.priority))
# Completo
if siModoAmpliado:
li_gen.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"
li_gen.append((config, color))
config = FormLayout.Editbox('<div align="right">' + _("Moves") +
"<br>" + _("By example:") +
" -5,8-12,14,19-",
rx="[0-9,\-,\,]*")
li_gen.append((config, ""))
fvar = configuration.file_books
list_books = Books.ListBooks()
list_books.restore_pickle(fvar)
# Comprobamos que todos esten accesibles
list_books.check()
li = [("--", None)]
defecto = list_books.lista[0] if alm.book_name else None
for book in list_books.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)
li_gen.append((config, defecto))
li_gen.append(SEPARADOR)
li_gen.append(
(_("Redo any existing prior analysis (if they exist)") + ":",
alm.delete_previous))
li_gen.append(
(_("Start from the end of the game") + ":", alm.from_last_move))
li_gen.append(SEPARADOR)
li_gen.append((_("Show graphics") + ":", alm.show_graphs))
liVar = form_variations(alm)
liBlunders, liBrilliancies = form_blunders_brilliancies(
alm, configuration)
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((li_gen, _("General options"), ""))
lista.append((liVar, _("Variations"), ""))
lista.append((liBlunders, _("Wrong moves"), ""))
lista.append((liBrilliancies, _("Brilliancies"), ""))
lista.append((liST, _("Stability control"), ""))
else:
lista = li_gen
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:
li_gen, liVar, liBlunders, liBrilliancies, liST = liResp
else:
li_gen = liResp
alm.engine = li_gen[0]
alm.vtime = int(li_gen[1] * 1000)
alm.depth = li_gen[2]
alm.timedepth = li_gen[3]
alm.multiPV = li_gen[4]
alm.priority = li_gen[5]
if siModoAmpliado:
color = li_gen[6]
alm.white = color != "BLACK"
alm.black = color != "WHITE"
alm.num_moves = li_gen[7]
alm.book = li_gen[8]
alm.book_name = alm.book.name if alm.book else None
alm.delete_previous = li_gen[9]
alm.from_last_move = li_gen[10]
alm.show_graphs = li_gen[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(configuration.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.configuration.tutor.key
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.configuration.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
if x in dic_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.configuration.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 key, cm in self.configuration.dic_engines.items():
li.append((cm.nombre_ext(), key))
li = sorted(li, key=operator.itemgetter(1))
li_ext = []
for x in range(16):
config = FormLayout.Combobox("%s %d" % (_("Engine"), x + 1), li)
key = ext_engines[x] if len(ext_engines) > x else ""
li_ext.append((config, key))
liLevels = [separador]
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
libooks = [(bookx.name, bookx) for bookx in list_books.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 = list_books.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 remove_worst(self):
form = FormLayout.FormLayout(self, _("Remove worst lines"),
Iconos.OpeningLines())
form.separador()
liJ = [(_("White"), "WHITE"), (_("Black"), "BLACK")]
form.combobox(_("Side"), liJ, "WHITE")
form.separador()
list_books = Books.ListBooks()
list_books.restore_pickle(self.configuration.file_books)
list_books.check()
libooks = [(bookx.name, bookx) for bookx in list_books.lista]
libooks.insert(0, ("--", None))
form.combobox(_("Book"), libooks, None)
form.separador()
form.float(_("Duration of engine analysis (secs)"),
float(self.configuration.x_tutor_mstime / 1000.0))
form.separador()
resultado = form.run()
if resultado:
color, book, segs = resultado[1]
ms = int(segs * 1000)
if ms == 0:
return
if book:
book.polyglot()
si_white = color == "WHITE"
dic = self.dbop.dicRepeFen(si_white)
mensaje = _("Move") + " %d/" + str(len(dic))
tmpBP = QTUtil2.BarraProgreso(self, _("Remove worst lines"), "",
len(dic))
xmanager = self.procesador.creaManagerMotor(
self.configuration.tutor, ms, 0, siMultiPV=False)
st_borrar = set()
ok = True
for n, fen in enumerate(dic, 1):
if tmpBP.is_canceled():
ok = False
break
tmpBP.inc()
tmpBP.mensaje(mensaje % n)
dic_a1h8 = dic[fen]
st_a1h8 = set(dic_a1h8.keys())
li = []
if book:
li_moves = book.get_list_moves(fen)
if li_moves:
# (from_sq, to_sq, promotion, "%-5s -%7.02f%% -%7d" % (pgn, pc, w), 1.0 * w / maxim))
li = [(m[0] + m[1] + m[2], m[4]) for m in li_moves
if m[0] + m[1] + m[2] in st_a1h8]
if li:
li.sort(key=lambda x: x[1], reverse=True)
st_ya = set(x[0] for x in li)
for a1h8 in st_a1h8:
if a1h8 not in st_ya:
li.append((a1h8, 0))
if len(li) == 0:
mrm = xmanager.analiza(fen)
for a1h8 in dic_a1h8:
rm, pos = mrm.buscaRM(a1h8)
li.append((a1h8, pos))
li.sort(key=lambda x: x[1])
for a1h8, pos in li[1:]:
for num_linea in dic_a1h8[a1h8]:
st_borrar.add(num_linea)
tmpBP.cerrar()
xmanager.terminar()
if ok:
li_borrar = list(st_borrar)
n = len(li_borrar)
if n:
self.dbop.removeLines(li_borrar, _("Remove worst lines"))
QTUtil2.message_bold(self, _("Removed %d lines") % n)
else:
QTUtil2.message_bold(self, _("Done"))
def __init__(self, w_parent, listaMotores, engine, siTorneo=False):
super(WEngine, self).__init__(w_parent)
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.key).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.depth, 0, 50)
lbTime = Controles.LB(self, _("Maximum seconds to think") + ": ")
self.sbTime = Controles.SB(self, engine.time, 0, 9999)
lbBook = Controles.LB(self, _("Opening book") + ": ")
fvar = Code.configuration.file_books
self.list_books = Books.ListBooks()
self.list_books.restore_pickle(fvar)
# # Comprobamos que todos esten accesibles
self.list_books.check()
li = [(x.name, x.path) for x in self.list_books.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(), icon_size=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, w_parent, nombre_torneo):
torneo = self.torneo = Tournament.Tournament(nombre_torneo)
titulo = nombre_torneo
icono = Iconos.Torneos()
extparam = "untorneo_v1"
QTVarios.WDialogo.__init__(self, w_parent, titulo, icono, extparam)
self.configuration = Code.configuration
# Datos
self.liEnActual = []
self.xjugar = None
self.liResult = None
self.last_change = Util.today()
self.li_results = []
# Toolbar
tb = Controles.TBrutina(self, icon_size=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-configuration --------------------------------------------------
w = QtWidgets.QWidget()
# Adjudicator
lb_resign = Controles.LB(
self, "%s (%s): " %
(_("Minimum centipawns to assign winner"), "0=%s" % _("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=%s" % _("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.configuration.comboMotoresMultiPV10()
self.cbJmotor, self.lbJmotor = QTUtil2.comboBoxLB(
self, self.liMotores, torneo.adjudicator(), _("Engine"))
self.edJtiempo = Controles.ED(self).tipoFloat(
torneo.adjudicator_time()).anchoFijo(50)
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.configuration.file_books
self.list_books = Books.ListBooks()
self.list_books.restore_pickle(fvar)
# Comprobamos que todos esten accesibles
self.list_books.check()
li = [(x.name, x.path) for x in self.list_books.lista]
li.insert(0, ("* " + _("None"), "-"))
self.cbBooks = Controles.CB(self, li, torneo.book())
btNuevoBook = Controles.PB(self, "", self.nuevoBook,
plano=False).ponIcono(Iconos.Nuevo(),
icon_size=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)
lb_slow = Controles.LB(self,
_("Slow down the movement of pieces") + ": ")
self.chb_slow = Controles.CHB(self, " ", self.torneo.slow_pieces())
# 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)
layout.controld(lb_slow, 7, 0).control(self.chb_slow, 7, 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,
icon_size=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,
icon_size=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,
(_("Save") + "(%s)" % _("Database"), Iconos.GrabarComo(),
self.gm_save_database),
None,
]
tbEnGt = Controles.TBrutina(self,
li_acciones,
icon_size=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.set_position("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()
