def terminar_bmt(self, bmt_lista, name): """ Si se estan creando registros para el entrenamiento BMT (Best move Training), al final hay que grabarlos @param bmt_lista: lista a grabar @param name: name del entrenamiento """ if bmt_lista and len(bmt_lista) > 0: bmt = BMT.BMT(self.configuration.ficheroBMT) dbf = bmt.read_dbf(False) reg = dbf.baseRegistro() reg.ESTADO = "0" reg.NOMBRE = name reg.EXTRA = "" reg.TOTAL = len(bmt_lista) reg.HECHOS = 0 reg.PUNTOS = 0 reg.MAXPUNTOS = bmt_lista.max_puntos() reg.FINICIAL = Util.dtos(Util.today()) reg.FFINAL = "" reg.SEGUNDOS = 0 reg.BMT_LISTA = Util.var2zip(bmt_lista) reg.HISTORIAL = Util.var2zip([]) reg.REPE = 0 reg.ORDEN = 0 dbf.insertarReg(reg, siReleer=False) bmt.cerrar()
def save_bmt(self, si_blunder, fen, mrm, pos_act, cl_game, txt_game): """ Se graba una position en un entrenamiento BMT @param si_blunder: si es blunder o brilliancie @param fen: position @param mrm: multirespuesta del engine @param pos_act: position de la position elegida en mrm @param cl_game: key de la game @param txt_game: la game completa en texto """ previa = 999999999 nprevia = -1 tniv = 0 game_bmt = Game.Game() cp = game_bmt.first_position cp.read_fen(fen) if len(mrm.li_rm) > 16: mrm_bmt = copy.deepcopy(mrm) if pos_act > 15: mrm_bmt.li_rm[15] = mrm_bmt.li_rm[pos_act] pos_act = 15 mrm_bmt.li_rm = mrm_bmt.li_rm[:16] else: mrm_bmt = mrm for n, rm in enumerate(mrm_bmt.li_rm): pts = rm.centipawns_abs() if pts != previa: previa = pts nprevia += 1 tniv += nprevia rm.nivelBMT = nprevia rm.siElegida = False rm.siPrimero = n == pos_act game_bmt.set_position(cp) game_bmt.read_pv(rm.pv) rm.txtPartida = game_bmt.save() bmt_uno = BMT.BMTUno(fen, mrm_bmt, tniv, cl_game) bmt_lista = self.bmt_listaBlunders if si_blunder else self.bmt_listaBrilliancies bmt_lista.nuevo(bmt_uno) bmt_lista.check_game(cl_game, txt_game)
def grabaBMT(self, siBlunder, fen, mrm, posAct, clpartida, txtPartida): """ Se graba una posicion en un entrenamiento BMT @param siBlunder: si es blunder o brilliancie @param fen: posicion @param mrm: multirespuesta del motor @param posAct: posicion de la posicion elegida en mrm @param clpartida: clave de la partida @param txtPartida: la partida completa en texto """ previa = 999999999 nprevia = -1 tniv = 0 partidaBMT = Partida.Partida() cp = partidaBMT.iniPosicion cp.leeFen(fen) if len(mrm.liMultiPV) > 16: mrmBMT = copy.deepcopy(mrm) if posAct > 15: mrmBMT.liMultiPV[15] = mrmBMT.liMultiPV[posAct] posAct = 15 mrmBMT.liMultiPV = mrmBMT.liMultiPV[:16] else: mrmBMT = mrm for n, rm in enumerate(mrmBMT.liMultiPV): pts = rm.puntosABS() if pts != previa: previa = pts nprevia += 1 tniv += nprevia rm.nivelBMT = nprevia rm.siElegida = False rm.siPrimero = n == posAct partidaBMT.reset(cp) partidaBMT.leerPV(rm.pv) rm.txtPartida = partidaBMT.guardaEnTexto() bmt_uno = BMT.BMT_Uno(fen, mrmBMT, tniv, clpartida) bmt_lista = self.bmt_listaBlunders if siBlunder else self.bmt_listaBrilliancies bmt_lista.nuevo(bmt_uno) bmt_lista.compruebaPartida(clpartida, txtPartida)
def xprocesa(self, game, tmp_bp): self.si_bmt_blunders = False self.si_bmt_brilliancies = False si_bp2 = hasattr( tmp_bp, "bp2" ) # Para diferenciar el analysis de una game que usa una progressbar unica del # analysis de muchas, que usa doble def gui_dispatch(xrm): return not tmp_bp.is_canceled() self.xmanager.set_gui_dispatch( gui_dispatch ) # Dispatch del engine, si esta puesto a 4 minutos por ejemplo que # compruebe si se ha indicado que se cancele. si_blunders = self.kblunders > 0 si_brilliancies = self.fnsbrilliancies or self.pgnbrilliancies or self.bmtbrilliancies if self.bmtblunders and self.bmt_listaBlunders is None: self.bmt_listaBlunders = BMT.BMTLista() if self.bmtbrilliancies and self.bmt_listaBrilliancies is None: self.bmt_listaBrilliancies = BMT.BMTLista() xlibro_aperturas = self.book is_white = self.white is_black = self.black if self.li_players: for x in ["BLACK", "WHITE"]: player = game.get_tag(x) if player: player = player.upper() si = False for uno in self.li_players: si_z = uno.endswith("*") si_a = uno.startswith("*") uno = uno.replace("*", "").strip().upper() if si_a: if player.endswith(uno): si = True if si_z: # form para poner si_a y si_z si = uno in player elif si_z: if player.startswith(uno): si = True elif uno == player: si = True if si: break if not si: if x == "BLACK": is_black = False else: is_white = False if not (is_white or is_black): return cl_game = Util.microsegundos_rnd() txt_game = game.save() si_poner_pgn_original_blunders = False si_poner_pgn_original_brilliancies = False n_jugadas = len(game) if self.li_selected: li_moves = self.li_selected else: li_moves = list(range(n_jugadas)) if xlibro_aperturas: li_borrar = [] for pos, njg in enumerate(li_moves): if tmp_bp.is_canceled(): self.xmanager.remove_gui_dispatch() return # # Si esta en el book move = game.move(njg) if xlibro_aperturas.get_list_moves(move.position_before.fen()): li_borrar.append(pos) continue else: break if li_borrar: li_borrar.reverse() for x in li_borrar: del li_moves[x] if self.from_last_move: li_moves.reverse() n_jugadas = len(li_moves) if si_bp2: tmp_bp.ponTotal(2, n_jugadas) else: tmp_bp.ponTotal(n_jugadas) for npos, njg in enumerate(li_moves): if tmp_bp.is_canceled(): self.xmanager.remove_gui_dispatch() return move = game.move(njg) if si_bp2: tmp_bp.pon(2, npos + 1) else: tmp_bp.pon(npos) if self.rut_dispatch_bp: self.rut_dispatch_bp(npos, n_jugadas, njg) if tmp_bp.is_canceled(): self.xmanager.remove_gui_dispatch() return # # Fin de game # if move.siJaqueMate or move.is_draw: # continue # # white y black white_move = move.position_before.is_white if white_move: if not is_white: continue else: if not is_black: continue # -# previos if self.delete_previous: move.analysis = None # -# Procesamos if move.analysis is None: resp = self.xmanager.analizaJugadaPartida( game, njg, self.vtime, depth=self.depth, brDepth=self.dpbrilliancies, brPuntos=self.ptbrilliancies, stability=self.stability, st_centipawns=self.st_centipawns, st_depths=self.st_depths, st_timelimit=self.st_timelimit, ) if not resp: self.xmanager.remove_gui_dispatch() return move.analysis = resp cp = move.position_before mrm, pos_act = move.analysis move.complexity = AnalysisIndexes.calc_complexity(cp, mrm) move.winprobability = AnalysisIndexes.calc_winprobability(cp, mrm) move.narrowness = AnalysisIndexes.calc_narrowness(cp, mrm) move.efficientmobility = AnalysisIndexes.calc_efficientmobility( cp, mrm) move.piecesactivity = AnalysisIndexes.calc_piecesactivity(cp, mrm) move.exchangetendency = AnalysisIndexes.calc_exchangetendency( cp, mrm) if si_blunders or si_brilliancies or self.with_variations or self.themes_lichess: rm = mrm.li_rm[pos_act] rm.ponBlunder(0) mj = mrm.li_rm[0] rm_pts = rm.centipawns_abs() dif = mj.centipawns_abs() - rm_pts mx = max(abs(mj.centipawns_abs()), abs(rm_pts)) dif_porc = int(dif * 100 / mx) if mx > 0 else 0 fen = move.position_before.fen() if self.with_variations: limite = self.alm.limit_include_variations if (limite == 0) or (dif >= limite): if not (self.alm.best_variation and dif == 0): move.analisis2variantes(self.alm, self.delete_previous) ok_blunder = dif >= self.kblunders if ok_blunder and self.kblunders_porc > 0: ok_blunder = dif_porc >= self.kblunders_porc if ok_blunder: rm.ponBlunder(dif) self.graba_tactic(game, njg, mrm, pos_act) if self.save_pgn(self.pgnblunders, mrm.name, game.dicTags(), fen, move, rm, mj): si_poner_pgn_original_blunders = True if self.bmtblunders: self.save_bmt(True, fen, mrm, pos_act, cl_game, txt_game) self.si_bmt_blunders = True if rm.level_brilliant(): move.add_nag(NAG_3) self.save_fns(self.fnsbrilliancies, fen) if self.save_pgn(self.pgnbrilliancies, mrm.name, game.dicTags(), fen, move, rm, None): si_poner_pgn_original_brilliancies = True if self.bmtbrilliancies: self.save_bmt(False, fen, mrm, pos_act, cl_game, txt_game) self.si_bmt_brilliancies = True else: nag, color = mrm.set_nag_color(self.configuration, rm) if nag: move.add_nag(nag) if self.themes_lichess and (mj.mate != 0 or dif > 0): move.assign_themes_lichess() # Ponemos el texto original en la ultima if si_poner_pgn_original_blunders and self.oriblunders: with open(self.pgnblunders, "at", encoding="utf-8", errors="ignore") as q: q.write("\n%s\n\n" % game.pgn()) if si_poner_pgn_original_brilliancies and self.oribrilliancies: with open(self.pgnbrilliancies, "at", encoding="utf-8", errors="ignore") as q: q.write("\n%s\n\n" % game.pgn()) self.xmanager.remove_gui_dispatch()
def xprocesa(self, dicPGN, partida, tmpBP, textoOriginal): """ Realiza el analisis @param dicPGN: etiquetas de cabecera de la partida @param partida: partida a analizar @param textoOriginal: texto de la partida, por si se graba la partida original """ self.siBMTblunders = False self.siBMTbrilliancies = False siBP2 = hasattr( tmpBP, "bp2" ) # Para diferenciar el analisis de una partida que usa una progressbar unica del # analisis de muchas, que usa doble def guiDispatch(rm): return not tmpBP.siCancelado() self.xgestor.ponGuiDispatch( guiDispatch ) # Dispatch del motor, si esta puesto a 4 minutos por ejemplo que # compruebe si se ha indicado que se cancele. siBlunders = self.kblunders > 0 siBrilliancies = self.fnsbrilliancies or self.pgnbrilliancies or self.bmtbrilliancies if self.bmtblunders and self.bmt_listaBlunders is None: self.bmt_listaBlunders = BMT.BMT_Lista() if self.bmtbrilliancies and self.bmt_listaBrilliancies is None: self.bmt_listaBrilliancies = BMT.BMT_Lista() xlibroAperturas = self.libroAperturas xblancas = self.blancas xnegras = self.negras if self.liJugadores: for x in ["BLACK", "WHITE"]: if x in dicPGN: jugador = dicPGN[x].upper() si = False for uno in self.liJugadores: siZ = uno.endswith("*") siA = uno.startswith("*") uno = uno.replace("*", "").strip().upper() if siA: if jugador.endswith(uno): si = True if siZ: # form para poner siA y siZ si = uno in jugador elif siZ: if jugador.startswith(uno): si = True elif uno == jugador: si = True if si: break if not si: if x == "BLACK": xnegras = False else: xblancas = False if not (xblancas or xnegras): return clpartida = Util.microsegundosRnd() txtPartida = partida.guardaEnTexto() siPonerPGNOriginalBlunders = False siPonerPGNOriginalBrilliancies = False nJugadas = len(partida) if self.listaElegidas: liJugadas = self.listaElegidas else: liJugadas = range(nJugadas) if xlibroAperturas: liBorrar = [] for pos, njg in enumerate(liJugadas): if tmpBP.siCancelado(): self.xgestor.quitaGuiDispatch() return # # Si esta en el libro jg = partida.jugada(njg) if xlibroAperturas.miraListaJugadas(jg.posicionBase.fen()): liBorrar.append(pos) continue else: break if liBorrar: liBorrar.reverse() for x in liBorrar: del liJugadas[x] if self.desdeelfinal: liJugadas.reverse() nJugadas = len(liJugadas) if siBP2: tmpBP.ponTotal(2, nJugadas) else: tmpBP.ponTotal(nJugadas) for npos, njg in enumerate(liJugadas): if tmpBP.siCancelado(): self.xgestor.quitaGuiDispatch() return jg = partida.jugada(njg) if siBP2: tmpBP.pon(2, npos + 1) else: tmpBP.pon(npos + 1) if self.rutDispatchBP: self.rutDispatchBP(npos, nJugadas, njg) if tmpBP.siCancelado(): self.xgestor.quitaGuiDispatch() return # # Fin de partida # if jg.siJaqueMate or jg.siTablas(): # continue # # blancas y negras siBlancas = jg.posicionBase.siBlancas if siBlancas: if not xblancas: continue else: if not xnegras: continue # -# previos if not self.siBorrarPrevio: if jg.analisis: continue # -# Procesamos resp = self.xgestor.analizaJugadaPartida( partida, njg, self.tiempo, depth=self.depth, brDepth=self.dpbrilliancies, brPuntos=self.ptbrilliancies, stability=self.stability, st_centipawns=self.st_centipawns, st_depths=self.st_depths, st_timelimit=self.st_timelimit) if not resp: self.xgestor.quitaGuiDispatch() return jg.analisis = resp cp = jg.posicionBase mrm = resp[0] jg.complexity = AnalisisIndexes.calc_complexity(cp, mrm) jg.winprobability = AnalisisIndexes.calc_winprobability(cp, mrm) jg.narrowness = AnalisisIndexes.calc_narrowness(cp, mrm) jg.efficientmobility = AnalisisIndexes.calc_efficientmobility( cp, mrm) jg.piecesactivity = AnalisisIndexes.calc_piecesactivity(cp, mrm) jg.exchangetendency = AnalisisIndexes.calc_exchangetendency( cp, mrm) if siBlunders or siBrilliancies or self.siVariantes: mrm, posAct = jg.analisis rm = mrm.liMultiPV[posAct] rm.ponBlunder(0) mj = mrm.liMultiPV[0] rm_pts = rm.puntosABS() dif = mj.puntosABS() - rm_pts fen = jg.posicionBase.fen() if self.siVariantes: limite = self.alm.limitemasvariantes if (limite == 0) or (dif >= limite): if not (self.alm.mejorvariante and dif == 0): jg.analisis2variantes(Partida.Partida(), self.alm, self.siBorrarPrevio) if dif >= self.kblunders: rm.ponBlunder(dif) self.grabaTactic(dicPGN, partida, njg, mrm, posAct) if self.grabaPGN(self.pgnblunders, mrm.nombre, dicPGN, fen, jg, rm, mj): siPonerPGNOriginalBlunders = True if self.bmtblunders: self.grabaBMT(True, fen, mrm, posAct, clpartida, txtPartida) self.siBMTblunders = True if rm.nivelBrillante(): jg.masCritica1_4("3") self.grabaFNS(self.fnsbrilliancies, fen) if self.grabaPGN(self.pgnbrilliancies, mrm.nombre, dicPGN, fen, jg, rm, None): siPonerPGNOriginalBrilliancies = True if self.bmtbrilliancies: self.grabaBMT(False, fen, mrm, posAct, clpartida, txtPartida) self.siBMTbrilliancies = True else: nag, color = mrm.setNAG_Color(self.configuracion, rm) if nag: jg.masCritica1_4(str(nag)) # Ponemos el texto original en la ultima if siPonerPGNOriginalBlunders and self.oriblunders: f = codecs.open(self.pgnblunders, "a", 'utf-8', 'ignore') f.write("\n%s\n\n" % textoOriginal) f.close() if siPonerPGNOriginalBrilliancies and self.oribrilliancies: f = codecs.open(self.pgnbrilliancies, "a", 'utf-8', 'ignore') f.write("\n%s\n\n" % textoOriginal) f.close() self.xgestor.quitaGuiDispatch()