def start(
self,
parent,
mensaje,
siCancelar=False,
siMuestraYa=True,
opacity=0.90,
physical_pos="c",
fixedSize=None,
titCancelar=None,
background=None,
pmImagen=None,
puntos=11,
conImagen=True,
):
# QTUtil.refresh_gui()
if self.me:
self.final()
if background is None:
background = "#D3E3EC"
self.me = MensEspera(parent, mensaje, siCancelar, siMuestraYa, opacity,
physical_pos, fixedSize, titCancelar, background,
pmImagen, puntos, conImagen)
QTUtil.refresh_gui()
return self
def show_dispatch(self, tp, rm):
if rm.time or rm.depth:
color_engine = "DarkBlue" if self.human_is_playing else "brown"
if rm.nodes:
nps = "/%d" % rm.nps if rm.nps else ""
nodes = " | %d%s" % (rm.nodes, nps)
else:
nodes = ""
seldepth = "/%d" % rm.seldepth if rm.seldepth else ""
li = [
'<span style="color:%s">%s' % (color_engine, rm.name),
'<b>%s</b> | <b>%d</b>%s | <b>%d"</b>%s' %
(rm.abrTextoBase(), rm.depth, seldepth, rm.time // 1000,
nodes),
]
pv = rm.pv
if tp < 999:
li1 = pv.split(" ")
if len(li1) > tp:
pv = " ".join(li1[:tp])
p = Game.Game(self.game.last_position)
p.read_pv(pv)
li.append(p.pgnBaseRAW())
self.set_label3("<br>".join(li) + "</span>")
QTUtil.refresh_gui()
def inicio(self, route):
GestorRoutes.inicio(self, route)
ending = self.route.get_ending()
if "|" in ending:
self.is_guided = True
self.t4 = None
self.fen, label, pv = ending.split("|")
self.liPV = pv.split(" ")
self.posPV = 0
else:
self.is_guided = False
self.t4 = LibChess.T4(self.configuracion)
self.fen = ending + " - - 0 1"
self.is_rival_thinking = False
cp = Position.Position()
cp.read_fen(self.fen)
is_white = cp.is_white
self.game.set_position(cp)
self.game.pending_opening = False
self.warnings = 0
self.max_warnings = 5
self.human_is_playing = False
self.state = ST_PLAYING
self.is_human_side_white = is_white
self.is_engine_side_white = not is_white
self.main_window.ponActivarTutor(False)
self.quitaAyudas(True)
self.ayudas_iniciales = 0
li_options = [TB_CLOSE, TB_HELP]
self.main_window.pon_toolbar(li_options)
self.main_window.activaJuego(True, False, siAyudas=False)
self.main_window.quitaAyudas(True)
self.set_dispatcher(self.mueve_humano)
self.setposition(self.game.last_position)
self.mostrarIndicador(True)
self.ponPiezasAbajo(is_white)
self.ponWarnings()
self.pgnRefresh(True)
QTUtil.refresh_gui()
self.dgt_setposition()
if self.is_guided:
self.ponRotulo1("<b>%s</b>" % label)
self.siguiente_jugada()
def mover(self):
w = self.width()
self.siMover = not self.siMover
self.setWindowFlags(QtCore.Qt.WindowCloseButtonHint | self.flags[self.siMover])
self.show()
QTUtil.refresh_gui()
self.resize(w, self.height())
def start(self, route):
ManagerRoutes.start(self, route)
ending = self.route.get_ending()
if "|" in ending:
self.is_guided = True
self.t4 = None
self.fen, label, pv = ending.split("|")
self.li_pv = pv.split(" ")
self.posPV = 0
else:
self.is_guided = False
self.t4 = LibChess.T4(self.configuration)
self.fen = ending + " - - 0 1"
self.is_rival_thinking = False
cp = Position.Position()
cp.read_fen(self.fen)
is_white = cp.is_white
self.game.set_position(cp)
self.game.pending_opening = False
self.warnings = 0
self.max_warnings = 5
self.human_is_playing = False
self.state = ST_PLAYING
self.human_side = is_white
self.is_engine_side_white = not is_white
self.main_window.set_activate_tutor(False)
self.remove_hints(True)
self.ayudas_iniciales = 0
li_options = [TB_CLOSE, TB_HELP]
self.main_window.pon_toolbar(li_options)
self.main_window.activaJuego(True, False, siAyudas=False)
self.main_window.remove_hints(True)
self.set_dispatcher(self.player_has_moved)
self.set_position(self.game.last_position)
self.show_side_indicator(True)
self.put_pieces_bottom(is_white)
self.ponWarnings()
self.pgnRefresh(True)
QTUtil.refresh_gui()
self.check_boards_setposition()
if self.is_guided:
self.set_label1("<b>%s</b>" % label)
self.play_next_move()
def ponContinuar(self):
self.btCancelarSeguir.set_text(_("Continue"))
self.btCancelarSeguir.to_connect(self.continuar)
self.btCancelarSeguir.ponFuente(self.fontB)
self.btCancelarSeguir.ponIcono(Iconos.Aceptar())
self.btCancelarSeguir.setDisabled(False)
QTUtil.refresh_gui()
def siguiente(self):
resp = self.sts.siguientePosicion(self.work)
if resp:
ngroup, self.nfen, self.elem = resp
if ngroup != self.ngroup:
self.calc_max()
self.grid.refresh()
self.ngroup = ngroup
if not self.playing:
return
t0 = time.time()
mrm = self.xengine.analiza(self.elem.fen)
t_dif = time.time() - t0
if mrm:
rm = mrm.mejorMov()
if rm:
mov = rm.movimiento()
if mov:
self.sts.setResult(self.work, self.ngroup, self.nfen,
mov, t_dif)
self.grid.refresh()
else:
self.sts.save()
self.calc_max()
self.grid.refresh()
self.tb.setAccionVisible(self.pause, False)
self.tb.setAccionVisible(self.run, False)
self.playing = False
QTUtil.refresh_gui()
def moving_tutor(self,
si_inicio=False,
n_saltar=0,
si_final=False,
is_base=False):
if n_saltar:
pos = self.pos_tutor + n_saltar
if 0 <= pos < self.max_tutor:
self.pos_tutor = pos
else:
return
elif si_inicio or is_base:
self.pos_tutor = 0
elif si_final:
self.pos_tutor = self.max_tutor - 1
if self.game_tutor.num_moves():
move = self.game_tutor.move(self.pos_tutor)
if is_base:
self.w.boardT.set_position(move.position_before)
else:
self.w.boardT.set_position(move.position)
self.w.boardT.put_arrow_sc(move.from_sq, move.to_sq)
self.w.boardT.escena.update()
self.w.update()
QTUtil.refresh_gui()
def run(self):
self.tb.setAccionVisible(self.pause, True)
self.tb.setAccionVisible(self.run, False)
QTUtil.refresh_gui()
self.playing = True
while self.playing:
self.siguiente()
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()
def micRecord(self):
self.pon_toolbar((self.ks_cancelmic, None, self.ks_stopmic))
self.siGrabando = True
self.is_canceled = False
self.mesa.ponCentesimas(0)
self.taller.micInicio()
iniTime = time.time()
while self.siGrabando:
self.taller.micGraba()
QTUtil.refresh_gui()
t = time.time() - iniTime
self.mesa.ponCentesimas(t * 100)
if t > self.maxTime:
break
self.siGrabando = False
self.taller.micFinal()
if self.is_canceled:
self.taller.limpiar()
self.mesa.ponCentesimas(0)
else:
self.mesa.ponCentesimas(self.taller.centesimas)
self.ponBaseTB()
def dispatch(self, is_total, valor, num_games):
if is_total:
self.bp.setRange(0, valor)
self.time_inicial = time.time()
self.total = valor
elif valor > 0:
self.bp.setValue(valor)
self.lbgames_readed.set_text("%s: %d" %
(_("Games read"), num_games))
tm = time.time() - self.time_inicial
tm1 = tm / valor
if self.invalid_prevision:
self.li_times.append(tm1)
self.test_invalid_prevision()
else:
previsto = int(tm1 * (self.total - valor))
minutos = previsto // 60
segundos = previsto % 60
lb_min = _("minutes") if minutos > 1 else _("minute")
self.lb_previsto.set_text("%s: %d %s %d %s" %
(_("Pending time"), minutos, lb_min,
segundos, _("seconds")))
QTUtil.refresh_gui()
return not self.is_canceled
def muestra_resultado(self):
self.state = ST_ENDGAME
self.disable_all()
self.human_is_playing = False
mensaje, beep, player_win = self.game.label_resultado_player(
self.human_side)
self.beepResultado(beep)
self.guardarGanados(player_win)
QTUtil.refresh_gui()
QTUtil2.message(self.main_window, mensaje)
li_options = [TB_CLOSE, TB_CONFIG, TB_UTILITIES]
if player_win:
li_options.insert(1, TB_REINIT)
self.main_window.pon_toolbar(li_options)
self.remove_hints()
self.autosave()
if player_win:
self.saveGame(True)
else:
self.cancelGame()
def voyager_position(wowner,
position,
si_esconde: bool = True,
wownerowner=None):
pos_ownerowner = None
pos = None
if si_esconde:
pos = QTUtil.escondeWindow(wowner)
if wownerowner:
pos_ownerowner = QTUtil.escondeWindow(wownerowner)
game = Game.Game(ini_posicion=position)
dlg = Voyager(wowner, False, game)
resp = dlg.resultado if dlg.exec_() else None
if si_esconde:
if wownerowner:
wownerowner.show()
wownerowner.move(pos_ownerowner)
QTUtil.refresh_gui()
time.sleep(0.01)
wowner.show()
wowner.move(pos)
QTUtil.refresh_gui()
time.sleep(0.01)
return resp
def cambios(self):
if hasattr(self, "form"):
li = self.form.get()
n = 1 if self.siNombre else 0
for arrow in self.liEjemplos:
regFlecha = arrow.bloqueDatos
if self.siNombre:
regFlecha.name = li[0]
regFlecha.forma = li[n]
regFlecha.tipo = li[n + 1]
regFlecha.color = li[n + 2]
regFlecha.colorinterior = li[n + 3]
# regFlecha.colorinterior2 = li[4]
regFlecha.opacity = (100.0 - float(li[n + 4])) / 100.0
regFlecha.redondeos = li[n + 5]
regFlecha.grosor = li[n + 6]
regFlecha.altocabeza = li[n + 7]
regFlecha.ancho = li[n + 8]
regFlecha.vuelo = li[n + 9]
regFlecha.descuelgue = li[n + 10]
regFlecha.destino = li[n + 11]
regFlecha.physical_pos.orden = li[n + 12]
arrow.physical_pos2xy() # posible cambio en destino
arrow.setOpacity(regFlecha.opacity)
arrow.setZValue(regFlecha.physical_pos.orden)
self.board.escena.update()
QTUtil.refresh_gui()
def seguir(self):
self.set_position()
self.lb_result.ponTexto("")
self.ed_moves.ponTexto("")
self.show_tb()
# Mostramos los movimientos según depth
depth = self.count.current_depth
if depth:
for x in range(depth):
move = self.count.game.move(self.count.current_posmove + x)
txt = move.pgnBaseSP()
self.board.pon_texto(txt, 0.9)
QTUtil.refresh_gui()
dif = depth - x
factor = 1.0 - dif * 0.1
if factor < 0.5:
factor = 0.5
time.sleep(2.6 * factor * factor)
self.board.pon_texto("", 0)
QTUtil.refresh_gui()
# Ponemos el toolbar
self.show_tb(self.check, self.terminar)
# Activamos capturas
self.gb_counts.setEnabled(True)
# Marcamos el tiempo
self.time_base = time.time()
self.ed_moves.setFocus()
def colocaCentrado(self, owner):
self.move(owner.x() + owner.width() / 2 - self.width() / 2,
owner.y() + owner.height() / 2 - self.height() / 2)
QTUtil.refresh_gui()
self.show()
QTUtil.refresh_gui()
return self
def start(self, dbwashing, washing, engine):
self.dbwashing = dbwashing
self.washing = washing
self.engine = engine
self.dbwashing.add_game()
self.game_type = GT_WASHING_REPLAY
self.human_is_playing = False
self.is_tutor_enabled = False
self.main_window.set_activate_tutor(False)
self.ayudas_iniciales = 0
self.main_window.activaJuego(True, False, siAyudas=False)
self.main_window.remove_hints(True, True)
self.set_dispatcher(self.player_has_moved)
self.show_side_indicator(True)
self.gameObj = self.dbwashing.restoreGame(self.engine)
self.numJugadasObj = self.gameObj.num_moves()
self.posJugadaObj = 0
li_options = [TB_CLOSE]
self.main_window.pon_toolbar(li_options)
self.errores = 0
self.book = Opening.OpeningPol(999, elo=engine.elo)
is_white = self.engine.color
self.human_side = is_white
self.is_engine_side_white = not is_white
self.set_position(self.game.last_position)
self.put_pieces_bottom(is_white)
self.set_label1(
"%s: %s\n%s: %s" %
(_("Rival"), self.engine.name, _("Task"), self.engine.lbState()))
self.pgnRefresh(True)
self.game.pending_opening = True
self.game.set_tag("Event", _("The Washing Machine"))
player = self.configuration.nom_player()
other = self.engine.name
w, b = (player, other) if self.human_side else (other, player)
self.game.set_tag("White", w)
self.game.set_tag("Black", b)
QTUtil.refresh_gui()
self.check_boards_setposition()
self.state = ST_PLAYING
self.play_next_move()
def cambiadoRM(self, fila):
self.um.set_pos_rm_active(fila)
self.lbPuntuacion.ponTexto(self.um.score_active())
self.lbPGN.ponTexto(self.um.pgn_active())
self.ponTablero()
self.owner.adjustSize()
QTUtil.refresh_gui()
def cambiadoRM(self, row):
self.um.set_pos_rm_active(row)
self.lbPuntuacion.set_text(self.um.score_active())
self.lbPGN.set_text(self.um.pgn_active())
self.ponBoard()
self.owner.adjustSize()
self.lbPGN.adjustSize()
QTUtil.refresh_gui()
def test_help(self):
QTUtil.refresh_gui()
self.board.remove_arrows()
if not self.chb_help.valor():
return
self.is_helped = True
fen = self.game.last_position.fen()
lif = [x[:2] for x in self.t4.best_mvs(fen)]
if lif:
self.board.put_arrow_scvar(lif, opacity=1.0)
def reinicia(self):
if self.reiniciando:
return
self.reiniciando = True
self.pointView = self.tactic.pointView()
self.with_automatic_jump = self.tactic.with_automatic_jump()
self.game_obj, game_base = self.tactic.work_read_position()
self.pos_obj = 0
cp = self.game_obj.first_position
is_white = cp.is_white
if self.pointView:
is_white = self.pointView == 1
self.is_human_side_white = is_white
self.is_engine_side_white = not is_white
if game_base:
self.game = game_base
else:
self.game.set_position(cp)
self.game_type = GT_TACTICS
self.human_is_playing = False
self.plays_instead_of_me_option = False
self.main_window.ponActivarTutor(False)
self.main_window.activaJuego(True, False, siAyudas=False)
self.main_window.quitaAyudas(True, True)
self.set_dispatcher(self.mueve_humano)
self.setposition(self.game.last_position)
self.mostrarIndicador(True)
self.ponPiezasAbajo(is_white)
li_opciones = [TB_CLOSE, TB_REINIT, TB_CONFIG]
self.main_window.pon_toolbar(li_opciones)
titulo = self.tactic.work_info(False)
self.ponRotulo1(titulo)
self.pgnRefresh(True)
QTUtil.refresh_gui()
self.dgt_setposition()
if game_base:
self.repiteUltimaJugada()
self.show_label_positions()
self.state = ST_PLAYING
self.reiniciando = False
self.siguiente_jugada()
def reinicia(self):
if self.reiniciando:
return
self.reiniciando = True
self.pointView = self.tactic.pointView()
self.with_automatic_jump = self.tactic.with_automatic_jump()
self.pos_obj = 0
cp = self.game_obj.first_position
is_white = cp.is_white
if self.pointView:
is_white = self.pointView == 1
self.human_side = is_white
self.is_engine_side_white = not is_white
if self.game_base:
self.game = self.game_base
else:
self.game.set_position(cp)
self.game_type = GT_TACTICS
self.human_is_playing = False
self.plays_instead_of_me_option = False
self.main_window.set_activate_tutor(False)
self.main_window.activaJuego(True, False, siAyudas=False)
self.main_window.remove_hints(True, True)
self.set_dispatcher(self.player_has_moved)
self.set_position(self.game.last_position)
self.show_side_indicator(True)
self.put_pieces_bottom(is_white)
li_opciones = [TB_CLOSE, TB_REINIT, TB_CONFIG]
self.main_window.pon_toolbar(li_opciones)
titulo = self.tactic.work_info(False)
self.set_label1(titulo)
self.pgnRefresh(True)
QTUtil.refresh_gui()
self.check_boards_setposition()
if self.game_base:
self.repiteUltimaJugada()
self.show_label_positions()
self.state = ST_PLAYING
self.reiniciando = False
self.num_bad_tries = 0
self.play_next_move()
def compruebaInput(self):
if not self.engine:
return
self.veces += 1
if self.veces == 3:
self.veces = 0
if self.siPlay:
mrm = self.engine.ac_estado()
rm = mrm.rmBest()
if rm and rm.depth > self.depth:
if mrm.li_rm:
cp = Position.Position()
cp.read_fen(self.fen)
self.liData = []
def tr(tp, mas=""):
self.liData.append((tp[0], "%.01f%%" % tp[1],
"%s%s" % (mas, tp[2])))
tp = AnalisisIndexes.tp_gamestage(cp, mrm)
self.liData.append((tp[0], "%d" % tp[1], tp[2]))
pts = mrm.li_rm[0].centipawns_abs()
mas = ""
if pts:
w, b = _("White"), _("Black")
siW = "w" in self.fen
if pts > 0:
mas = w if siW else b
elif pts < 0:
mas = b if siW else w
mas += "-"
tr(AnalisisIndexes.tp_winprobability(cp, mrm), mas)
tr(AnalisisIndexes.tp_complexity(cp, mrm))
tr(AnalisisIndexes.tp_efficientmobility(cp, mrm))
tr(AnalisisIndexes.tp_narrowness(cp, mrm))
tr(AnalisisIndexes.tp_piecesactivity(cp, mrm))
tr(AnalisisIndexes.tp_exchangetendency(cp, mrm))
tp = AnalisisIndexes.tp_positionalpressure(cp, mrm)
self.liData.append((tp[0], "%d" % int(tp[1]), ""))
tr(AnalisisIndexes.tp_materialasymmetry(cp, mrm))
self.grid.refresh()
self.grid.resizeRowsToContents()
QTUtil.refresh_gui()
self.cpu.compruebaInput()
def pon_resultado(self):
mensaje, beep, player_win = self.game.label_resultado_player(self.human_side)
QTUtil.refresh_gui()
QTUtil2.message(self.main_window, mensaje)
self.state = ST_ENDGAME
self.disable_all()
self.human_is_playing = False
self.disable_all()
self.refresh()
def inicio(self, dbwashing, washing, engine):
self.dbwashing = dbwashing
self.washing = washing
self.engine = engine
self.dbwashing.add_game()
self.game_type = GT_WASHING_REPLAY
self.human_is_playing = False
self.is_tutor_enabled = False
self.main_window.ponActivarTutor(False)
self.ayudas_iniciales = 0
self.main_window.activaJuego(True, False, siAyudas=False)
self.main_window.quitaAyudas(True, True)
self.set_dispatcher(self.mueve_humano)
self.mostrarIndicador(True)
self.partidaObj = self.dbwashing.restoreGame(self.engine)
self.numJugadasObj = self.partidaObj.num_moves()
self.posJugadaObj = 0
li_options = [TB_CLOSE]
self.main_window.pon_toolbar(li_options)
self.errores = 0
self.book = Apertura.AperturaPol(999, elo=engine.elo)
is_white = self.engine.color
self.is_human_side_white = is_white
self.is_engine_side_white = not is_white
self.setposition(self.game.last_position)
self.ponPiezasAbajo(is_white)
self.ponRotulo1(
"%s: %s\n%s: %s" %
(_("Rival"), self.engine.name, _("Task"), self.engine.lbState()))
self.pgnRefresh(True)
self.game.pending_opening = True
QTUtil.refresh_gui()
self.dgt_setposition()
self.state = ST_PLAYING
self.siguiente_jugada()
def actualiza(self, leidos, erroneos, duplicados, importados, workdone=0):
def pts(x):
return "{:,}".format(x).replace(",", ".")
self.lbLeidos.set_text(pts(leidos))
if self.siErroneos:
self.lbErroneos.set_text(pts(erroneos))
self.lbDuplicados.set_text(pts(duplicados))
self.lbImportados.set_text(pts(importados))
if self.siWorkDone:
self.lbWorkDone.set_text("%d%%" % int(workdone))
QTUtil.refresh_gui()
return not self.is_canceled
def adjudication(self):
self.pon_estado(ST_PAUSE)
QTUtil.refresh_gui()
menu = QTVarios.LCMenu(self)
menu.opcion(RESULT_DRAW, RESULT_DRAW, Iconos.Tablas())
menu.separador()
menu.opcion(RESULT_WIN_WHITE, RESULT_WIN_WHITE, Iconos.Blancas())
menu.separador()
menu.opcion(RESULT_WIN_BLACK, RESULT_WIN_BLACK, Iconos.Negras())
resp = menu.lanza()
if resp is not None:
self.game.set_termination(TERMINATION_ADJUDICATION, resp)
self.save_game_done()
def next_line_run(self):
li_options = [TB_CLOSE, TB_HELP, TB_REINIT]
self.main_window.pon_toolbar(li_options)
self.next_line()
QTUtil.refresh_gui()
self.dgt_setposition()
self.state = ST_PLAYING
self.siguiente_jugada()
def next_line_run(self):
li_options = [TB_CLOSE, TB_HELP, TB_REINIT]
self.main_window.pon_toolbar(li_options)
self.next_line()
QTUtil.refresh_gui()
self.check_boards_setposition()
self.state = ST_PLAYING
self.play_next_move()
