def terminarBMT(self, bmt_lista, nombre): """ Si se estan creando registros para el entrenamiento BMT (Best move Training), al final hay que grabarlos @param bmt_lista: lista a grabar @param nombre: nombre del entrenamiento """ if bmt_lista and len(bmt_lista) > 0: bmt = BMT.BMT(self.configuracion.ficheroBMT) dbf = bmt.leerDBF(False) reg = dbf.baseRegistro() reg.ESTADO = "0" reg.NOMBRE = nombre reg.EXTRA = "" reg.TOTAL = len(bmt_lista) reg.HECHOS = 0 reg.PUNTOS = 0 reg.MAXPUNTOS = bmt_lista.maxPuntos() reg.FINICIAL = Util.dtos(Util.hoy()) reg.FFINAL = "" reg.SEGUNDOS = 0 reg.BMT_LISTA = Util.var2blob(bmt_lista) reg.HISTORIAL = Util.var2blob([]) reg.REPE = 0 reg.ORDEN = 0 dbf.insertarReg(reg, siReleer=False) bmt.cerrar()
def compruebaCambioCarpetas(configuracion): usrdata = configuracion.carpeta def haz(original, nueva): original = os.path.join(usrdata, original) nueva = os.path.join(usrdata, nueva) if os.path.isfile(original) and not os.path.isfile(nueva): shutil.move(original, nueva) haz("Mate positions in GM gamesB.tdb", "Checkmates in GM gamesB.tdb") haz("From Uwe Auerswald's CollectionB.tdb", "Tactics by Uwe AuerswaldB.tdb") if os.path.isfile("dataDB/dataDB.pkd"): os.remove("dataDB/dataDB.pkd") # cambios de ficheros gm gmConvert(configuracion) # cambios en dic entmaquina dic = Util.recuperaDIC(configuracion.ficheroEntMaquina) if dic: liAperturasFavoritas = dic.get("APERTURASFAVORITAS", []) if liAperturasFavoritas: for npos, x in enumerate(liAperturasFavoritas): if type(x) == tuple: liAperturasFavoritas[npos] = x[0] Util.guardaDIC(dic, configuracion.ficheroEntMaquina) # Dic -> DicSQL dicDisk(configuracion) # Fichero potencia ficheroPotencia(configuracion)
def limpiaTemporal(self): try: dirTmp = os.path.join(self.carpeta, "tmp") for f in Util.listdir(dirTmp): Util.borraFichero(os.path.join(dirTmp, f)) except: pass
def guardaDIC(self): dic = {} dic["SIBLANCAS"] = self.rbBlancas.isChecked() libro = self.cb.valor() dic["NOMLIBRO"] = None if libro is None else libro.nombre dic["RR"] = self.cbRR.valor() dic["RJ"] = self.chRJ.valor() Util.guardaVar(self.configuracion.ficheroTrainBooks, dic)
def aceptar(self): if not self.fichero: return me = QTUtil2.unMomento(self) # Creamos el pgn fichTemporal = self.wParent.damePGNtemporal() # Creamos la linea de ordenes if VarGen.isWindows: exe = 'EnginesWindows/polyglot/polyglot.exe' else: exe = 'EnginesLinux/polyglot/polyglot' li = [os.path.abspath(exe), 'make-book', "-pgn", fichTemporal, "-bin", self.fichero] Util.borraFichero(self.fichero) maxPly = self.sbMaxPly.valor() minGame = self.sbMinGame.valor() minScore = self.sbMinScore.valor() onlyWhite = self.chbOnlyWhite.valor() onlyBlack = self.chbOnlyBlack.valor() uniform = self.chbUniform.valor() if maxPly: li.append("-max-ply") li.append("%d" % maxPly) if minGame and minGame != 3: li.append("-min-game") li.append("%d" % minGame) if minScore: li.append("-min-score") li.append("%d" % minScore) if onlyBlack: li.append("-only-black") if onlyWhite: li.append("-only-white") if uniform: li.append("-uniform") # Ejecutamos process = subprocess.Popen(li, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) # Mostramos el resultado txt = process.stdout.read() if os.path.isfile(self.fichero): txt += "\n" + _X(_("Book created : %1"), self.fichero) me.final() QTUtil2.mensaje(self, txt) Util.borraFichero(fichTemporal) nombre = os.path.basename(self.fichero)[:-4] b = Books.Libro("P", nombre, self.fichero, False) self.listaLibros.nuevo(b) fvar = self.configuracion.ficheroBooks self.listaLibros.guardaVar(fvar) self.accept()
def polyglot(self): recno = self.grid.recno() if recno < 0: return reg = self.lista[recno] # Pedimos el fichero a generar fbin = QTUtil2.salvaFichero(self, _("Polyglot book"), reg["NOMBRE"] + ".bin", _("Polyglot book") + " (*.bin)") if not fbin: return me = QTUtil2.unMomento(self) # Determinamos el fichero de trabajo plTMP = "deleteme_%d.pgn" n = 0 while True: fichTMP = plTMP % n if Util.existeFichero(fichTMP): n += 1 else: break # Creamos el fichero de trabajo f = open(fichTMP, "wb") for pv in reg["LISTA"]: f.write('[Result "1/2-1/2"]\n') p = Partida.Partida() p.leerPV(pv) f.write(p.pgnBase() + " 1/2-1/2\n\n") f.close() # Ejecutamos if VarGen.isWindows: exe = 'EnginesWindows/polyglot/polyglot.exe' else: exe = 'EnginesLinux/polyglot/polyglot' li = [os.path.abspath(exe), 'make-book', "-pgn", fichTMP, "-bin", fbin, "-max-ply", "99", "-min-game", "1", "-uniform"] Util.borraFichero(fbin) process = subprocess.Popen(li, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) me.final() # Mostramos el resultado txt = process.stdout.read() if os.path.isfile(fbin): txt += "\n" + _X(_("Book created : %1"), fbin) QTUtil2.mensaje(self, txt) Util.borraFichero(fichTMP)
def temas(self): siHay = len(self.liTemas) > 0 menu = QTVarios.LCMenu(self) if siHay: mr = menu.submenu(_("Open"), Iconos.Recuperar()) ponMenuTemas(mr, self.liTemas, "r") menu.separador() if self.temaActual: menu.opcion("grabar", _("Save") + " " + self.temaActual["NOMBRE"], Iconos.Grabar()) menu.separador() menu.opcion("grabarComo", _("Save as"), Iconos.GrabarComo()) menu.separador() if siHay: mr = menu.submenu(_("Remove"), Iconos.Borrar()) ico = Iconos.PuntoNegro() for n, uno in enumerate(self.liTemas): if uno: mr.opcion("b%d" % n, uno["NOMBRE"], ico) mr.separador() resp = menu.lanza() if resp is None: return elif resp == "grabar": self.grabarTema(self.temaActual) elif resp == "grabarComo": tema = self.grabarTema({}) self.liTemas.append(tema) elif resp.startswith("r"): num = int(resp[1:]) tema = self.liTemas[num] self.temaActual = tema self.confTablero.leeTema(tema.get("TEXTO", "")) if "BASE" in tema: self.confTablero.leeBase(tema["BASE"]) self.ponTema(tema) elif resp.startswith("b"): num = int(resp[1:]) tema = self.liTemas[num] if QTUtil2.pregunta(self, _X(_("Delete %1?"), tema["NOMBRE"])): if self.temaActual == tema: self.temaActual = {} del self.liTemas[num] fichero = self.configuracion.ficheroTemas li = [] for tema in self.liTemas: if tema: li.append(tema) Util.guardaVar(fichero, li)
def changeFolder(nueva): if nueva: if os.path.abspath(nueva) == os.path.abspath(LCBASEFOLDER): return changeFolder(None) f = open(LCFILEFOLDER, "wb") f.write(nueva) f.close() else: Util.borraFichero(LCFILEFOLDER)
def wav(self): carpeta = Util.recuperaVar(self.confich) fichero = QTUtil2.leeFichero(self, carpeta, "wav") if fichero: carpeta = os.path.dirname(fichero) Util.guardaVar(self.confich, carpeta) if self.taller.leeWAV(fichero): self.mesa.ponCentesimas(self.taller.centesimas) else: QTUtil2.mensError(self, _("It is impossible to read this file, it is not compatible.")) self.ponBaseTB()
def leeSTS(self): li = [] Util.creaCarpeta(self.carpetaSTS) for x in Util.listdir(self.carpetaSTS, siUnicode=True): if x.lower().endswith(".sts"): fich = os.path.join(self.carpetaSTS, x) st = os.stat(fich) li.append((x, st.st_ctime, st.st_mtime)) sorted(li, key=lambda x: x[2], reverse=True) # por ultima modificacin y al reves return li
def grabar(self): carpeta = Util.recuperaVar(self.confich) filtro = _("File") + " wav (*.wav)" fichero = QTUtil2.salvaFichero(self, _("Save wav"), carpeta, filtro, siConfirmarSobreescritura=True) if fichero: carpeta = os.path.dirname(fichero) Util.guardaVar(self.confich, carpeta) f = open(fichero, "wb") f.write(self.taller.wav) f.close() self.ponBaseTB()
def getVideoItem(self, id, url=None, title=None, subtitle=None, summary=None, duration=None, thumb=None): """ Get the VideoItem for a highlight video, either by assembling the data we already have, or fetching more from mlb.com """ # (year, month, day, content_id) = (id[:4], id[4:6], id[6:8], id[8:]) # subtitle = None #"posted %s/%s/%s" % (month, day, year) xml = None if None in [url, title, subtitle, summary, duration, thumb]: xurl = C["URL"]["GAME_DETAIL"] % (id[-3], id[-2], id[-1], id) xml = XML.ElementFromURL(xurl, headers={"Referer": Util.getURLRoot(xurl)}) if url is None: # TODO this seems fragile. investigate another way. for scenario in [ "FLASH_1000K_640X360", "MLB_FLASH_1000K_PROGDNLD", "MLB_FLASH_1000K_STREAM_VPP", "FLASH_800K_640X360", "MLB_FLASH_800K_PROGDNLD", "MLB_FLASH_800K_STREAM_VPP", "FLASH_400K_600X338" ]: url = Util.XPathSelectOne(xml, 'url[@playback_scenario="' + scenario + '"]') if url is not None: break else: # couldn't find a URL return if duration is None: duration_string = Util.XPathSelectOne(xml, 'duration') if duration_string is not None: duration = int(Util.parseDuration(duration_string)) * 1000 if title is None: title = Util.XPathSelectOne(xml, 'headline') if subtitle is None: date = isodate.parse_datetime(Util.XPathSelectOne(xml, '//@date')) # Log(date.astimezone(datetime.datetime.now().tzinfo)) # subtitle = date.strftime("%a, %d %b %Y %H:%M:%S %Z") subtitle = date.strftime("%A, %B %d") if summary is None: summary = re.sub("^\s*(\d+\.){2}\d+\:", "", str(Util.XPathSelectOne(xml, 'big-blurb'))) if thumb is None: thumb = Util.XPathSelectOne(xml, 'thumbnailScenarios/thumbnailScenario[@type="3"]') if url[:7] == "rtmp://": # pass clip as an empty string to prevent an exception return RTMPVideoItem(url, clip="", title=title, subtitle=subtitle, summary=summary, duration=duration, thumb=thumb) else: return VideoItem(url, title, subtitle=subtitle, summary=summary, duration=duration, thumb=thumb)
def aceptar(self): self.dic = self.creaDic() Util.guardaDIC(self.dic, self.configuracion.ficheroEntMaquina) # Info para el gestor, sin grabar dr = self.dic["RIVAL"] dr["CM"] = self.rival dr["TIPO"] = self.rivalTipo self.guardarVideo() self.accept()
def finPartida(self): if self.finExit: fichero = sys.argv[1] if os.path.dirname(fichero).lower() == "tmp": Util.borraFichero(fichero) self.procesador.procesarAccion(k_terminar) self.procesador.pararMotores() self.procesador.quitaKibitzers() sys.exit(0) else: self.quitaCapturas() self.procesador.inicio()
def cambioRival(self): dic = PantallaEntMaq.cambioRival(self.pantalla, self.configuracion, self.reinicio) if dic: Util.guardaDIC(dic, self.configuracion.ficheroEntMaquina) for k, v in dic.iteritems(): self.reinicio[k] = v siBlancas = dic["SIBLANCAS"] self.siAtras = dic["ATRAS"] if self.siAtras: self.pantalla.ponToolBar( ( k_mainmenu, k_rendirse, k_atras, k_reiniciar, k_aplazar, k_configurar, k_utilidades )) else: self.pantalla.ponToolBar(( k_mainmenu, k_rendirse, k_reiniciar, k_aplazar, k_configurar, k_utilidades )) self.rmRival = None self.nAjustarFuerza = dic["AJUSTAR"] dr = dic["RIVAL"] rival = dr["CM"] r_t = dr["TIEMPO"] * 100 # Se guarda en decimas -> milesimas r_p = dr["PROFUNDIDAD"] if r_t <= 0: r_t = None if r_p <= 0: r_p = None if r_t is None and r_p is None and not dic["SITIEMPO"]: r_t = 1000 dr["RESIGN"] = self.resignPTS self.xrival = self.procesador.creaGestorMotor(rival, r_t, r_p, self.nAjustarFuerza != kAjustarMejor) self.xrival.siBlancas = not siBlancas rival = self.xrival.nombre jugador = self.configuracion.jugador bl, ng = jugador, rival if not siBlancas: bl, ng = ng, bl self.pantalla.cambiaRotulosReloj(bl, ng) # self.ponPiezasAbajo( siBlancas ) self.ponRotuloBasico() self.ponPiezasAbajo(siBlancas) if siBlancas != self.siJugamosConBlancas: self.siJugamosConBlancas = siBlancas self.siRivalConBlancas = not siBlancas self.siguienteJugada()
def exportar(self): dr = self.configuracion.leeVariables("PCOLORES") dirBase = dr["DIRBASE"] if dr else "" fich = QTUtil2.salvaFichero(self, _("Colors"), dirBase, "*.lktheme1", True) if fich: dr["DIRBASE"] = os.path.dirname(fich) self.configuracion.escVariables("PCOLORES", dr) if not fich.lower().endswith("lktheme1"): fich += ".lktheme1" tema = {} tema["TEXTO"] = self.confTablero.grabaTema() tema["BASE"] = self.confTablero.grabaBase() Util.guardaVar(fich, tema)
def entrenar(self, fil=None, col=None): if len(self.lista) == 0: return if fil is None: fil = self.grid.recno() # Ultimo entrenamiento dicPar = Util.recuperaVar(self.ficheroParam) if dicPar is None: jugamos = "BLANCAS" repeticiones = 5 else: jugamos = dicPar["JUGAMOS"] repeticiones = dicPar["REPETICIONES"] if not ((col is None) or (col.clave == "NOMBRE")): jugamos = col.clave # Datos liGen = [(None, None)] liJ = [(_("White"), "BLANCAS"), (_("Black"), "NEGRAS"), (_("White & Black"), "AMBOS")] config = FormLayout.Combobox(_("Play with"), liJ) liGen.append(( config, jugamos )) liR = [( _("Undefined"), 0 )] for x in range(4): liR.append((str(x + 1), x + 1)) for x in range(5, 105, 5): liR.append((str(x), x)) config = FormLayout.Combobox(_("Model"), liR) liGen.append(( config, repeticiones )) # Editamos resultado = FormLayout.fedit(liGen, title=_("Train"), parent=self, anchoMinimo=360, icon=Iconos.Entrenar()) if resultado is None: return accion, liResp = resultado jugamos = liResp[0] repeticiones = liResp[1] dicPar = {} dicPar["JUGAMOS"] = jugamos dicPar["REPETICIONES"] = repeticiones Util.guardaVar(self.ficheroParam, dicPar) self.resultado = (self.listaAperturasStd, self.ficheroDatos, self.lista, fil, jugamos, repeticiones) self.accept()
def finalEntrenamiento(self): liHisto = self.db["HISTO"] if not liHisto: liHisto = [] dicActual = {"FINICIAL": Util.hoy(), "FFINAL": None, "SECONDS": 0.0, "POS": self.numPosiciones(), "ERRORS": 0} liHisto.insert(0, dicActual) liHisto[0]["FFINAL"] = Util.hoy() liHisto[0]["SECONDS"] = self.db["SECONDS"] liHisto[0]["ERRORS"] = self.db["ERRORS"] liHisto[0]["REFERENCE"] = self.db["REFERENCE"] self.db["HISTO"] = liHisto self.db["POSACTIVE"] = None
def listaTraducciones(self): li = [] dlang = "Locale" for uno in Util.listdir(dlang): fini = os.path.join(dlang, uno, "lang.ini") if os.path.isfile(fini): try: dic = Util.iniBase8dic(fini) if "NAME" in dic: li.append((uno, dic["NAME"], dic.get( "%", "100"))) except: pass li = sorted(li, key=lambda lng: lng[0]) return li
def guardarVideo(self): dic = {} pos = self.pos() dic["_POSICION_"] = "%d,%d" % (pos.x(), pos.y()) tam = self.size() dic["_SIZE_"] = "%d,%d" % (tam.width(), tam.height()) dic["SHOW_TABLERO"] = self.siShowTablero dic["NARROWS"] = self.nArrows dic["SITOP"] = self.siTop Util.guardaDIC(dic, self.ficheroVideo)
def gridDato(self, grid, fila, oColumna): col = oColumna.clave key = self.liHistorico[fila] reg = self.historico[key] if col == "FECHA": fecha = reg[col] return Util.localDate(fecha) elif col == "MPUNTOS": mpuntos = reg["MPUNTOS"] return "%0.2f" % mpuntos elif col == "MTIEMPOS": mtiempos = reg["MTIEMPOS"] return "%0.2f" % mtiempos elif col == "MOTOR": return reg["MOTOR"] elif col == "SEGUNDOS": tiempo = int(reg["TIEMPOJUGADA"] / 1000) return "%d" % tiempo elif col == "PRUEBAS": nfens = len(reg["LIFENS"]) return "%d" % nfens elif col == "FNS": fns = reg.get("FNS", None) if fns: return os.path.basename(fns) else: return _("Default")
def gridDato(self, grid, fila, oColumna): col = oColumna.clave reg = self.historico[fila] if col == "FECHA": return Util.localDateT(reg.FECHA) elif col == "SEGUNDOS": return "%.02f" % reg.SEGUNDOS
def empezar(self): liR = [] if self.fns and Util.existeFichero(self.fns): fns = self.fns.lower() li = [] if fns.endswith(".pgn"): f = open(fns, "rb") for linea in f: if linea.startswith("[FEN "): li.append(linea[6:].split('"')[0]) f.close() else: # se supone que es un fichero de fens f = open(fns, "rb") for linea in f: linea = linea.strip() if linea[0].isalnum() and \ linea[-1].isdigit() and \ ( (" w " in linea) or (" b " in linea) ) and \ linea.count("/") == 7: li.append(linea) f.close() if len(li) >= self.pruebas: liR = random.sample(li, self.pruebas) else: self.fns = "" if not liR: liR = PantallaPotencia.leeVariasLineasMFN(self.pruebas) # liR = liFens w = WDailyTest(self, liR, self.motor, self.segundos, self.fns) w.exec_() self.calcListaHistorico() self.ghistorico.refresh()
def grabar(self): if len(self.dicPtes) == 0: return dic = self.dicPtes self.dicPtes = {} # Creamos una tabla de trabajo dbf = SQLDBF.DBF(self.conexion, self.tablaDatos, "") for k, uno in dic.items(): reg = SQLDBF.Almacen() reg.XPV = uno.xpv() reg.PV = uno.pv() reg.NAG = uno.nag() reg.ADV = uno.adv() reg.COMMENT = uno.comment() reg.POS = uno.pos() reg.FEN = uno.fen() reg.MARK = uno.mark() reg.GRAPHICS = uno.graphics() reg.XDATA = Util.var2blob(uno.xdata()) if uno.rowid() is None: id = dbf.insertarSoloReg(reg) uno.rowid(id) else: dbf.modificarROWID(uno.rowid(), reg) dbf.cerrar()
def importar(self): # import os # ntema = 0 # self.liTemas = [] # for carpeta in ("1","a","b"): # sc = 1 # ps = 0 # for fich in os.listdir("/tmp/rp/%s"%carpeta): # tema = Util.recuperaVar( "/tmp/rp/%s/%s"%(carpeta,fich) ) # tema["NOMBRE"] = fich[:-9] # tema["SECCION"] = "%s-%d"%(carpeta,sc) # ps += 1 # if ps == 12: # ps =0 # sc += 1 # self.ponTema(tema) # self.confTablero.png64Thumb( base64.b64encode(self.tablero.thumbnail(64)) ) # tema["TEXTO"] = self.confTablero.grabaTema() # tema["BASE"] = self.confTablero.grabaBase() # self.liTemas.append(tema) # fichero = self.configuracion.ficheroTemas # Util.guardaVar( fichero, self.liTemas ) dr = self.configuracion.leeVariables("PCOLORES") dirBase = dr["DIRBASE"] if dr else "" fich = QTUtil2.leeFichero(self, dirBase, "lktheme1") if fich: dr["DIRBASE"] = os.path.dirname(fich) self.configuracion.escVariables("PCOLORES", dr) tema = Util.recuperaVar(fich) self.ponTema(tema)
def terminarTest(self): self.paraHumano() self.xtutor.terminar() t = 0 for x in self.liPuntos: t += x mpuntos = t * 1.0 / self.nFens t = 0.0 for x in self.liTiempos: t += x mtiempos = t * 1.0 / self.nFens hoy = Util.hoy() fecha = "%d%02d%02d" % ( hoy.year, hoy.month, hoy.day ) datos = {} datos["FECHA"] = hoy datos["MOTOR"] = self.xtutor.clave datos["TIEMPOJUGADA"] = self.xtutor.motorTiempoJugada datos["LIFENS"] = self.liFens datos["LIPV"] = self.liPV datos["MPUNTOS"] = mpuntos datos["MTIEMPOS"] = mtiempos datos["FNS"] = self.fns self.historico[fecha] = datos self.lbColor.ponTexto("") self.lbJuego.ponTexto("") mens = "<h3>%s : %0.2f</h3><h3>%s : %0.2f</h3>" % (_("Points lost"), mpuntos, _("Time in seconds"), mtiempos ) QTUtil2.mensaje(self, mens, _("Result"), siResalta=False) self.accept()
def limpia(self, nombre): self.elo = 0 self.eloNC = 1600 self.michelo = 1600 self.micheloNC = 1600 self.fics = 1200 self.ficsNC = 1200 self.fide = 1600 self.fideNC = 1600 self.grupos.limpia() self.id = Util.creaID() self.jugador = nombre self.dirSalvados = "" self.dirPGN = "" self.dirJS = "" self.liTrasteros = [] self.salvarGanados = False self.salvarPerdidos = False self.salvarAbandonados = False self.salvarFichero = "" self.siActivarCapturas = False self.siActivarInformacion = False self.siAtajosRaton = False self.showCandidates = False self.salvarCSV = "" self.rival = self.buscaRival(self.rivalInicial)
def rutinaDatos(recno): dic = {} dbf.goto(recno) for clave in dbf.liCampos: dic[clave] = getattr(dbf.reg, clave) dic["PGN"] = Util.blob2var(dic["PGN"]) return dic
def nuevo(self): wav = None nombre = "" while True: w = WEdicionSonido(self, _("New"), wav=wav, maxTime=600000, nombre=nombre) resp = w.exec_() if resp: centesimas = w.centesimas if not centesimas: return nombre = w.nombre().strip() if not nombre: QTUtil2.mensError(self, _("Name missing")) continue reg = Util.Almacen() reg.nombre = nombre reg.centesimas = centesimas reg.id = Util.nuevoID() reg.wav = w.wav reg.ordenVista = (self.liSonidos[-1].ordenVista + 1) if self.liSonidos else 1 self.db[reg.id] = reg self.liSonidos.append(reg) self.grid.refresh() return
def getNewName(self, title, previous=""): name = previous while True: liGen = [(None, None)] liGen.append(( _("Name") + ":", name )) resultado = FormLayout.fedit(liGen, title=title, parent=self, anchoMinimo=460, icon=Iconos.TutorialesCrear()) if resultado is None: return None accion, liResp = resultado name = liResp[0].strip() if not name: return None name = Util.validNomFichero(name) ok = True for k in self.bookGuide.getOtras(): if k.lower() == name.lower(): QTUtil2.mensError(self, _("This name is repeated, please select other")) ok = False break if ok: return name
def linea_bloque(self, pos): alm = Util.Almacen() alm.fen, alm.bm, alm.sol, alm.pgn, alm.dif = self.li_bloque[pos].split( "|") alm.max_time = (int(alm.dif)**2) * 5 + 120 return alm
def genera(self): num = self.PUZZLES # Determinamos la lista de fens, teniendo en cuenta el peso asociado a cada fichero lif = [] wt = 0 for f, w, d, h in self.filesw: lif0 = [] for fich in self.listaFicheros(f): q = codecs.open(fich, "r", "latin-1", 'ignore') for linea in q: linea = linea.strip() if linea and "|" in linea: lif0.append(linea) q.close() if d and d <= h: d -= 1 lif0 = lif0[d:h] lif.append([w, lif0]) wt += w t = 0 for li in lif: li[0] = int(li[0] * num / wt) t += li[0] t -= self.PUZZLES n = 0 while t: lif[0][n] += 1 t -= 1 n += 1 if n == len(lif): n = 0 liFNS = [] for li in lif: n = li[0] lif0 = li[1] if len(lif0) < n: n = len(lif0) lir = lif0[:n] for x in lir: liFNS.append(x) self.db["LIFNS"] = liFNS self.liFNS = liFNS numPuzzles = len(liFNS) # Deteminamos la lista indice con el orden de cada fen en liFNS liJUMPS = self.JUMPS li = [None] * (len(liJUMPS) * 2 * numPuzzles) # Creamos un list muy grande, mayor del que vamos a usar def busca(desde, salto): if salto == 0: for x in range(desde, len(li)): if li[x] is None: return x li.extend([None] * 1000) return busca(desde, salto) else: while salto: desde = busca(desde + 1, 0) salto -= 1 return desde for x in range(numPuzzles): n = busca(0, 0) li[n] = x for m in liJUMPS: n = busca(n + 1, int(m)) li[n] = x liBase = [] for x in li: if x is not None: liBase.append(x) liOrder = [] liNueva = liBase[:] for repeat in self.REPEAT: if repeat == 0: # Original liNueva = liBase[:] elif repeat == 1: liNueva = liBase[:] random.shuffle(liNueva) else: liNueva = liNueva[:] liOrder.extend(liNueva) self.db["ORDER"] = liOrder self.liOrder = liOrder self.db["POSACTIVE"] = 0 self.db["SHOWTEXT"] = self.SHOWTEXT self.db["POINTVIEW"] = self.POINTVIEW self.db["REFERENCE"] = self.REFERENCE # 6.3d---------------+ liHisto = self.db["HISTO"] if not liHisto: liHisto = [] dicActual = {"FINICIAL": Util.hoy(), "FFINAL": None, "SECONDS": 0.0, "POS": self.numPosiciones(), "ERRORS": 0, "PUZZLES": self.PUZZLES, "FILESW": self.filesw, "JUMPS": self.JUMPS, "REPEAT": self.REPEAT, "SHOWTEXT": self.SHOWTEXT, "PENALIZATION": self.PENALIZATION} liHisto.insert(0, dicActual) self.db["HISTO"] = liHisto #6.3d---------------+ #7.0---------------+ self.db["SECONDS"] = 0.0 self.db["ERRORS"] = 0 #7.0---------------+ self.db.pack()
def read(self): obj = Util.restore_pickle(self.file) return [] if obj is None else obj
def __init__(self, user): self.carpetaBase = active_folder() self.carpetaUsers = os.path.join(self.carpetaBase, "users") if user: Util.create_folder(self.carpetaUsers) self.carpeta = os.path.join(self.carpetaUsers, str(user.number)) Util.create_folder(self.carpeta) else: Util.create_folder(self.carpetaBase) self.carpeta = self.carpetaBase self.carpeta_config = os.path.join(self.carpeta, "__Config__") Util.create_folder(self.carpeta_config) self.carpeta_results = os.path.join(self.carpeta, "Results") Util.create_folder(self.carpeta_results) self.user = user self.set_folders() self.is_main = user == "" or user is None self.version = "" self.x_id = Util.new_id() self.x_player = "" self.x_save_folder = "" self.x_save_pgn_folder = "" self.x_save_lcsb = "" self.x_translator = "" self.x_style = "WindowsVista" self.x_tutor_view = POS_TUTOR_HORIZONTAL self.x_show_effects = False self.x_pieces_speed = 100 self.x_save_tutor_variations = True self.x_mouse_shortcuts = False self.x_show_candidates = False self.x_captures_activate = True self.x_info_activate = False self.x_default_tutor_active = True self.x_elo = 0 self.x_michelo = 1600 self.x_fics = 1200 self.x_fide = 1600 self.x_lichess = 1600 self.x_digital_board = "" self.x_menu_play = MENU_PLAY_BOTH self.x_opacity_tool_board = 10 self.x_position_tool_board = "T" self.x_director_icon = False self.x_direct_graphics = False self.colores_nags_defecto() self.x_sizefont_infolabels = 10 self.x_pgn_selbackground = None self.x_pgn_headerbackground = None self.x_pgn_width = 400 self.x_pgn_fontpoints = 11 self.x_pgn_rowheight = 28 self.x_pgn_withfigurines = True self.x_pgn_english = False self.x_autopromotion_q = False self.x_font_family = "" self.x_menu_points = 11 self.x_menu_bold = False self.x_tb_fontpoints = 11 self.x_tb_bold = False self.x_tb_icons = toolbutton_int(Qt.ToolButtonTextUnderIcon) self.x_cursor_thinking = True self.x_save_won = False self.x_save_lost = False self.x_save_unfinished = False self.x_save_csv = "" self.x_save_pgn = "" self.x_rival_inicial = "rocinante" if Code.is_linux else "irina" self.tutor_inicial = "stockfish" self.x_tutor_clave = self.tutor_inicial self.x_tutor_multipv = 10 # 0: maximo self.x_tutor_difpoints = 10 self.x_tutor_difporc = 0 self.x_tutor_mstime = 3000 self.x_tutor_depth = 0 self.x_sound_beep = False self.x_sound_our = False self.x_sound_move = False self.x_sound_results = False self.x_interval_replay = 1400 self.x_engine_notbackground = False self.x_check_for_update = False self.x_carpeta_gaviota = self.carpeta_gaviota_defecto() # Editable directamente en su código self.x_captures_showall = True self.x_counts_showall = True self.palette = {} self.perfomance = Perfomance() self.li_favoritos = None self.liPersonalidades = [] self.relee_engines() self.rival = self.buscaRival(self.x_rival_inicial) self.tutor = self.buscaTutor(self.tutor_inicial) if self.tutor.key != self.x_tutor_clave: self.x_tutor_clave = self.tutor.key
def base_inicio(self, dic_var): self.reinicio = dic_var self.cache = dic_var.get("cache", {}) self.game_type = GT_AGAINST_ENGINE self.human_is_playing = False self.plays_instead_of_me_option = True self.state = ST_PLAYING self.is_analyzing = False self.summary = { } # numJugada : "a"ccepted, "s"ame, "r"ejected, dif points, time used self.with_summary = dic_var.get("SUMMARY", False) is_white = dic_var["ISWHITE"] self.human_side = is_white self.is_engine_side_white = not is_white self.conf_engine = dic_var["RIVAL"].get("CM", None) self.lirm_engine = [] self.next_test_resign = 0 self.resign_limit = -99999 # never self.aperturaObl = self.aperturaStd = None self.fen = dic_var["FEN"] if self.fen: cp = Position.Position() cp.read_fen(self.fen) self.game.set_position(cp) self.game.pending_opening = False else: if dic_var["OPENING"]: self.aperturaObl = Opening.JuegaOpening( dic_var["OPENING"].a1h8) self.primeroBook = False # la opening es obligatoria self.bookR = dic_var.get("BOOKR", None) if self.bookR: self.bookRdepth = dic_var.get("BOOKRDEPTH", 0) self.bookR.polyglot() self.bookRR = dic_var.get("BOOKRR", "mp") elif dic_var["RIVAL"].get("TYPE", None) in (SelectEngines.MICGM, SelectEngines.MICPER): if self.conf_engine.book: self.bookR = Books.Book("P", self.conf_engine.book, self.conf_engine.book, True) self.bookR.polyglot() self.bookRR = "mp" self.bookRdepth = 0 self.bookP = dic_var.get("BOOKP", None) if self.bookP: self.bookPdepth = dic_var.get("BOOKPDEPTH", 0) self.bookP.polyglot() self.is_tutor_enabled = ( Code.dgtDispatch is None) and self.configuration.x_default_tutor_active self.main_window.set_activate_tutor(self.is_tutor_enabled) self.hints = dic_var["HINTS"] self.ayudas_iniciales = self.hints # Se guarda para guardar el PGN self.nArrows = dic_var.get("ARROWS", 0) n_box_height = dic_var.get("BOXHEIGHT", 24) self.thoughtOp = dic_var.get("THOUGHTOP", -1) self.thoughtTt = dic_var.get("THOUGHTTT", -1) self.continueTt = dic_var.get("CONTINUETT", False) self.nArrowsTt = dic_var.get("ARROWSTT", 0) self.chance = dic_var.get("2CHANCE", True) if self.nArrowsTt != 0 and self.hints == 0: self.nArrowsTt = 0 self.with_takeback = dic_var.get("TAKEBACK", True) self.tutor_con_flechas = self.nArrowsTt > 0 and self.hints > 0 self.tutor_book = Books.BookGame(Code.tbook) mx = max(self.thoughtOp, self.thoughtTt) if mx > -1: self.set_hight_label3(n_box_height) dr = dic_var["RIVAL"] rival = dr["CM"] if dr["TYPE"] == SelectEngines.ELO: r_t = 0 r_p = rival.fixed_depth self.nAjustarFuerza = ADJUST_BETTER else: r_t = dr["ENGINE_TIME"] * 100 # Se guarda en decimas -> milesimas r_p = dr["ENGINE_DEPTH"] self.nAjustarFuerza = dic_var.get("ADJUST", ADJUST_BETTER) if not self.xrival: # reiniciando is not None if r_t <= 0: r_t = None if r_p <= 0: r_p = None if r_t is None and r_p is None and not dic_var["WITHTIME"]: r_t = 1000 self.xrival = self.procesador.creaManagerMotor( rival, r_t, r_p, self.nAjustarFuerza != ADJUST_BETTER) if self.nAjustarFuerza != ADJUST_BETTER: self.xrival.maximizaMultiPV() self.resign_limit = dic_var["RESIGN"] self.game.add_tag("Event", _("Play against an engine")) player = self.configuration.nom_player() other = self.xrival.name w, b = (player, other) if self.human_side else (other, player) self.game.add_tag("White", w) self.game.add_tag("Black", b) self.siBookAjustarFuerza = self.nAjustarFuerza != ADJUST_BETTER self.xrival.is_white = self.is_engine_side_white self.siTiempo = dic_var["WITHTIME"] if self.siTiempo: self.maxSegundos = dic_var["MINUTES"] * 60.0 self.segundosJugada = dic_var["SECONDS"] self.segExtra = dic_var.get("MINEXTRA", 0) * 60.0 self.zeitnot = dic_var.get("ZEITNOT", 0) self.vtime = { WHITE: Util.Timer(self.maxSegundos), BLACK: Util.Timer(self.maxSegundos) } if self.segExtra: self.vtime[self.human_side].ponSegExtra(self.segExtra) time_control = "%d" % int(self.maxSegundos) if self.segundosJugada: time_control += "+%d" % self.segundosJugada self.game.add_tag("TimeControl", time_control) if self.segExtra: self.game.add_tag( "TimeExtra" + "White" if self.human_side else "Black", "%d" % self.segExtra) self.pon_toolbar() self.main_window.activaJuego(True, self.siTiempo) self.set_dispatcher(self.player_has_moved) self.set_position(self.game.last_position) self.show_side_indicator(True) if self.ayudas_iniciales: self.ponAyudasEM() else: self.remove_hints(siQuitarAtras=False) self.put_pieces_bottom(is_white) self.ponRotuloBasico() self.set_label2("") if self.nAjustarFuerza != ADJUST_BETTER: pers = Personalities.Personalities(None, self.configuration) label = pers.label(self.nAjustarFuerza) if label: self.game.add_tag("Strength", label) self.ponCapInfoPorDefecto() self.pgnRefresh(True) rival = self.xrival.name player = self.configuration.x_player bl, ng = player, rival if self.is_engine_side_white: bl, ng = ng, bl active_clock = max(self.thoughtOp, self.thoughtTt) > -1 if self.siTiempo: tp_bl = self.vtime[True].etiqueta() tp_ng = self.vtime[False].etiqueta() self.main_window.ponDatosReloj(bl, tp_bl, ng, tp_ng) active_clock = True self.refresh() else: self.main_window.base.change_player_labels(bl, ng) if active_clock: self.main_window.start_clock(self.set_clock, 400) self.main_window.set_notify(self.mueve_rival_base) self.is_analyzed_by_tutor = False self.game.tag_timestart() self.check_boards_setposition()
def leeRegAllRecno(self, recno): raw = self.leeAllRecno(recno) alm = Util.Almacen() for campo in self.liCamposAll: setattr(alm, campo, raw[campo]) return alm, raw
def procesa_game(self): self.pon_estado(ST_PLAYING) # Configuración self.fen_inicial = self.torneo.fenNorman() # Cerramos los motores anteriores si los hay Code.list_engine_managers.close_all() if self.torneo.adjudicator_active(): conf_engine = Code.configuration.buscaRival( self.torneo.adjudicator()) self.xadjudicator = EngineManager.EngineManager(self, conf_engine) self.xadjudicator.options(self.torneo.adjudicator_time() * 1000, 0, False) self.xadjudicator.remove_multipv() else: self.xadjudicator = None self.next_control = 0 self.max_segundos = self.tournament_game.minutos * 60.0 self.segundos_jugada = self.tournament_game.segundos_jugada # abrimos motores rival = { WHITE: self.torneo.buscaHEngine(self.tournament_game.hwhite), BLACK: self.torneo.buscaHEngine(self.tournament_game.hblack) } for side in (WHITE, BLACK): self.lb_player[side].set_text(rival[side].key) self.vtime = {} self.book = {} self.bookRR = {} self.xengine = {} for side in (WHITE, BLACK): rv = rival[side] self.xengine[side] = EngineManager.EngineManager(self, rv) self.xengine[side].options(rv.time * 1000, rv.depth, False) self.xengine[side].set_gui_dispatch(self.gui_dispatch) self.vtime[side] = Util.Timer(self.max_segundos) bk = rv.book if bk == "*": bk = self.torneo.book() if bk == "-": # Puede que el torneo tenga "-" bk = None if bk: self.book[side] = Books.Book("P", bk, bk, True) self.book[side].polyglot() else: self.book[side] = None self.bookRR[side] = rv.bookRR self.game = Game.Game(fen=self.fen_inicial) self.pgn.game = self.game self.lbRotulo3.altoFijo(32) self.board.disable_all() self.board.set_position(self.game.last_position) self.grid_pgn.refresh() for side in (WHITE, BLACK): ot = self.vtime[side] eti, eti2 = ot.etiquetaDif2() self.pon_reloj_side(side, eti, eti2) while self.state == ST_PAUSE or self.play_next_move(): if self.state == ST_PAUSE: QTUtil.refresh_gui() time.sleep(0.1) if self.is_closed: break for side in (WHITE, BLACK): self.xengine[side].terminar() if not self.is_closed: if self.game_finished(): self.save_game_done()
def inicio(self, datosMotor, minutos, segundos, siCompetitivo, aplazamiento=None): self.tipoJuego = kJugMicElo self.resultado = None self.siJuegaHumano = False self.estado = kJugando self.siCompetitivo = siCompetitivo self.puestoResultado = False # Problema doble asignacion de ptos Thomas if aplazamiento: siBlancas = aplazamiento["SIBLANCAS"] else: siBlancas = self.determinaColor(datosMotor) self.siJugamosConBlancas = siBlancas self.siRivalConBlancas = not siBlancas self.rmRival = None self.liRMrival = [] self.noMolestar = 0 self.resignPTS = -1000 self.siTutorActivado = False self.pantalla.ponActivarTutor(False) self.ayudasPGN = self.ayudas = 0 self.tiempo = {} self.maxSegundos = minutos * 60 self.segundosJugada = segundos # -Aplazamiento 1/2-------------------------------------------------- if aplazamiento: self.partida.recuperaDeTexto(aplazamiento["JUGADAS"]) self.datosMotor = self.engineAplazado(aplazamiento["ALIAS"], aplazamiento["BASEELO"]) self.tiempo[True] = Util.Timer(aplazamiento["TIEMPOBLANCAS"]) self.tiempo[False] = Util.Timer(aplazamiento["TIEMPONEGRAS"]) self.maxSegundos = aplazamiento["MAXSEGUNDOS"] self.segundosJugada = aplazamiento["SEGUNDOSJUGADA"] self.partida.asignaApertura() else: self.datosMotor = datosMotor self.tiempo[True] = Util.Timer(self.maxSegundos) self.tiempo[False] = Util.Timer(self.maxSegundos) cbook = self.datosMotor.book if self.datosMotor.book else VarGen.tbook self.book = Books.Libro("P", cbook, cbook, True) self.book.polyglot() elo = self.datosMotor.elo self.maxMoveBook = elo / 200 if 0 <= elo <= 1700 else 9999 eloengine = self.datosMotor.elo eloplayer = self.configuracion.miceloActivo(siCompetitivo) self.whiteElo = eloplayer if siBlancas else eloengine self.blackElo = eloplayer if not siBlancas else eloengine self.xrival = self.procesador.creaGestorMotor(self.datosMotor, None, None, siMultiPV=self.datosMotor.multiPV > 0) self.pteToolRendirse = False if not self.siCompetitivo: self.pteToolRendirse = True self.maxPlyRendirse = 6 elif self.siJugamosConBlancas: self.pteToolRendirse = True self.maxPlyRendirse = 1 else: self.maxPlyRendirse = 0 if aplazamiento and self.partida.numJugadas() > self.maxPlyRendirse: self.pteToolRendirse = False self.ponToolBar() self.pantalla.activaJuego(True, True, siAyudas=False) self.ponMensajero(self.mueveHumano) self.ponPosicion(self.partida.ultPosicion) self.ponPiezasAbajo(siBlancas) self.quitaAyudas(True, siQuitarAtras=siCompetitivo) self.mostrarIndicador(True) nbsp = " " * 3 txt = "%s:%+d%s%s:%+d%s%s:%+d" % (_("Win"), self.datosMotor.pgana, nbsp, _("Draw"), self.datosMotor.ptablas, nbsp, _("Loss"), self.datosMotor.ppierde) self.ponRotulo1("<center>%s</center>" % txt) self.ponRotulo2("") self.pgnRefresh(True) self.ponCapInfoPorDefecto() # -Aplazamiento 2/2-------------------------------------------------- if aplazamiento: self.mueveJugada(kMoverFinal) self.siPrimeraJugadaHecha = True else: self.siPrimeraJugadaHecha = False tpBL = self.tiempo[True].etiqueta() tpNG = self.tiempo[False].etiqueta() self.rival = rival = self.datosMotor.alias + " (%d)" % self.datosMotor.elo jugador = self.configuracion.jugador + " (%d)" % self.configuracion.miceloActivo(siCompetitivo) bl, ng = jugador, rival if self.siRivalConBlancas: bl, ng = ng, bl self.pantalla.ponDatosReloj(bl, tpBL, ng, tpNG) self.refresh() self.ponPosicionDGT() if not self.siJugamosConBlancas: mensaje = _("Press the continue button to start.") self.mensajeEnPGN(mensaje) self.siguienteJugada()
def inicio(self, dic, aplazamiento=None, siPrimeraJugadaHecha=False): if aplazamiento: dic = aplazamiento["EMDIC"] self.reinicio = dic self.tipoJuego = kJugEntMaq self.resultado = None self.siJuegaHumano = False self.estado = kJugando self.timekeeper = Util.Timekeeper() self.summary = {} self.siSummary = dic.get("SUMMARY", False) siBlancas = dic["SIBLANCAS"] self.siJugamosConBlancas = siBlancas self.siRivalConBlancas = not siBlancas self.siAtras = True self.rmRival = None self.liRMrival = [] self.aperturaStd = Apertura.AperturaPol(1) self.pensando(True) self.pantalla.ponActivarTutor(False) self.ayudas = 0 self.ayudasPGN = 0 cmrival = self.configuracion.buscaRival("irina", None) self.xrival = self.procesador.creaGestorMotor(cmrival, None, 2) self.rival_name = dic["RIVAL"] self.xrival.set_option("Personality", self.rival_name) if not dic["FASTMOVES"]: self.xrival.set_option("Max Time", "5") self.xrival.set_option("Min Time", "1") self.xrival.nombre = _F(self.rival_name) self.xrival.siBlancas = self.siRivalConBlancas self.siPrimeraJugadaHecha = siPrimeraJugadaHecha self.siTiempo = dic["SITIEMPO"] if self.siTiempo: self.maxSegundos = dic["MINUTOS"] * 60.0 self.segundosJugada = dic["SEGUNDOS"] self.segExtra = dic.get("MINEXTRA", 0) * 60.0 self.tiempo = {} self.tiempo[True] = Util.Timer(self.maxSegundos) self.tiempo[False] = Util.Timer(self.maxSegundos) self.pensando(False) # -Aplazamiento 1/2-------------------------------------------------- if aplazamiento: self.partida.recuperaDeTexto(aplazamiento["JUGADAS"]) self.partida.pendienteApertura = aplazamiento["PENDIENTEAPERTURA"] self.partida.apertura = None if aplazamiento["APERTURA"] is None else self.listaAperturasStd.dic[ aplazamiento["APERTURA"]] self.siTiempo = aplazamiento["SITIEMPO"] if self.siTiempo: self.maxSegundos = aplazamiento["MAXSEGUNDOS"] self.segundosJugada = aplazamiento["SEGUNDOSJUGADA"] self.tiempo = {} self.tiempo[True] = Util.Timer(aplazamiento["TIEMPOBLANCAS"]) self.tiempo[False] = Util.Timer(aplazamiento["TIEMPONEGRAS"]) if self.segExtra: self.tiempo[self.siJugamosConBlancas].ponSegExtra(self.segExtra) self.siPrimeraJugadaHecha = False li = [k_cancelar, k_rendirse, k_atras, k_reiniciar, k_aplazar, k_peliculaPausa, k_configurar, k_utilidades] self.pantalla.ponToolBar(li) self.pantalla.activaJuego(True, self.siTiempo) self.ponMensajero(self.mueveHumano) self.ponPosicion(self.partida.ultPosicion) self.mostrarIndicador(True) self.quitaAyudas(True, siQuitarAtras=False) self.ponPiezasAbajo(siBlancas) imagen = getattr(Iconos, "pm%s" % self.rival_name) self.pantalla.base.lbRotulo1.ponImagen(imagen()) self.pantalla.base.lbRotulo1.show() self.ponCapInfoPorDefecto() self.pgnRefresh(True) # -Aplazamiento 2/2-------------------------------------------------- if aplazamiento or "MOVE" in dic: self.mueveJugada(kMoverFinal) if self.siTiempo: self.siPrimeraJugadaHecha = False tpBL = self.tiempo[True].etiqueta() tpNG = self.tiempo[False].etiqueta() jugador = self.configuracion.jugador bl, ng = jugador, self.rival_name if self.siRivalConBlancas: bl, ng = ng, bl self.pantalla.ponDatosReloj(bl, tpBL, ng, tpNG) self.refresh() self.ponPosicionDGT() self.siguienteJugada()
def nuevaCopia(self, ntarea): tarea = copy.copy(self.tarea(ntarea)) tarea._id = Util.str_id() return self.nuevaTarea(tarea, ntarea + 1)
def setFichero(self, file): self.close() self._fichero = file if file is not None else Code.configuration.ficheroRecursos if not Util.exist_file(self._fichero): Util.file_copy(Code.path_resource("IntFiles", "recursos.dbl"), self._fichero)
def inicio(self, dbwashing, washing, engine): self.dbwashing = dbwashing self.washing = washing self.engine = engine self.tipoJuego = kJugWashingCreate self.resultado = None self.siJuegaHumano = False self.estado = kJugando self.timekeeper = Util.Timekeeper() siBlancas = self.engine.color self.siJugamosConBlancas = siBlancas self.siRivalConBlancas = not siBlancas self.siCompetitivo = True self.apertura = Apertura.AperturaPol(30, self.engine.elo) self.siTutorActivado = True self.siAnalizando = False # self.pantalla.ponActivarTutor(self.siTutorActivado) rival = self.configuracion.buscaRival(self.engine.clave) self.xrival = self.procesador.creaGestorMotor(rival, None, None) self.xrival.siBlancas = self.siRivalConBlancas self.rmRival = None self.tmRival = 15.0 * 60.0 * engine.elo / 3000.0 self.xtutor.maximizaMultiPV() self.siAnalizadoTutor = False self.pantalla.activaJuego(True, False, False) self.quitaAyudas() li = [k_mainmenu, k_reiniciar, k_atras] self.pantalla.ponToolBar(li) self.ponMensajero(self.mueveHumano) self.ponPosicion(self.partida.ultPosicion) self.mostrarIndicador(True) self.ponPiezasAbajo(siBlancas) self.ponRotulo1( "%s: %s\n%s: %s\n %s: %s" % (_("Rival"), self.engine.nombre, _("Task"), self.engine.lbState(), _("Tutor"), self.xtutor.nombre)) self.ponRotuloDatos() self.ponCapInfoPorDefecto() self.pgnRefresh(True) game = dbwashing.restoreGame(engine) if game: if not game.siTerminada(): self.partida = game self.ponteAlFinal() self.pantalla.base.pgnRefresh() self.ponPosicionDGT() self.siguienteJugada()
def aceptar(self): if not self.fichero: return # Creamos el pgn fichTemporal = self.wParent.damePGNtemporal(self) if not fichTemporal: return me = QTUtil2.unMomento(self) # Creamos la linea de ordenes if VarGen.isWindows: exe = 'Engines/Windows/_tools/polyglot/polyglot.exe' else: exe = 'Engines/Linux/_tools/polyglot/polyglot' li = [ os.path.abspath(exe), 'make-book', "-pgn", fichTemporal, "-bin", self.fichero ] Util.borraFichero(self.fichero) maxPly = self.sbMaxPly.valor() minGame = self.sbMinGame.valor() minScore = self.sbMinScore.valor() onlyWhite = self.chbOnlyWhite.valor() onlyBlack = self.chbOnlyBlack.valor() uniform = self.chbUniform.valor() if maxPly: li.append("-max-ply") li.append("%d" % maxPly) if minGame and minGame != 3: li.append("-min-game") li.append("%d" % minGame) if minScore: li.append("-min-score") li.append("%d" % minScore) if onlyBlack: li.append("-only-black") if onlyWhite: li.append("-only-white") if uniform: li.append("-uniform") # Ejecutamos process = subprocess.Popen(li, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) # Mostramos el resultado txt = process.stdout.read() if os.path.isfile(self.fichero): txt += "\n" + _X(_("Book created : %1"), self.fichero) me.final() QTUtil2.mensaje(self, txt) Util.borraFichero(fichTemporal) nombre = os.path.basename(self.fichero)[:-4] b = Books.Libro("P", nombre, self.fichero, False) self.listaLibros.nuevo(b) fvar = self.configuracion.ficheroBooks self.listaLibros.guardaVar(fvar) self.accept()
def menu_run(self, resp): if resp: if type(resp) == str: if resp == "gm": self.entrenaGM() elif resp.startswith("mate"): self.jugarMate(int(resp[-1])) elif resp == "bmt": self.bmt() elif resp.startswith("resistance"): self.resistance(resp[10:]) elif resp in ["find_all_moves_rival", "find_all_moves_player"]: self.find_all_moves(resp == "find_all_moves_player") elif resp == "dailytest": self.dailyTest() elif resp == "potencia": self.potencia() elif resp == "visualiza": self.visualiza() elif resp == "anotar": self.anotar() elif resp == "train_book": self.train_book() elif resp == "endings_gtb": self.gaviota_endings() elif resp.startswith("tactica|"): nada, tipo, name, carpeta, ini = resp.split("|") self.tacticas(tipo, name, carpeta, ini) elif resp.startswith("remtactica|"): nada, carpeta, name = resp.split("|") self.tacticaRemove(carpeta, name) elif resp.startswith("puente_"): self.puente(int(resp[7:])) elif resp.startswith("horses_"): test = int(resp[7]) icl, icn, tit = self.horsesDef[test] icon = Code.todasPiezas.icono(icl, icn) self.horses(test, tit, icon) elif resp.startswith("ep_"): um = self.procesador.unMomento() entreno = os.path.realpath(resp[3:]) titentreno = Util.relative_path(entreno, Code.folder_root) # if "/" in entreno: # dicTraining = TrListas.dicTraining() # titentreno = "" # for x in entreno[:-4].split("/")[1:]: # titentreno += dicTraining.get(x, x) + "/" # titentreno = titentreno[:-1] with Util.OpenCodec(entreno) as f: todo = f.read().strip() liEntrenamientos = todo.split("\n") nPosiciones = len(liEntrenamientos) um.final() if nPosiciones == 0: return elif nPosiciones == 1: pos = 1 jump = False else: db = UtilSQL.DictSQL(self.configuration.ficheroTrainings) data = db[entreno] jump = False tipo = "s" if data is None: posUltimo = 1 elif type(data) == int: posUltimo = data else: posUltimo = data["POSULTIMO"] jump = data["SALTA"] tipo = data["TYPE"] resp = WCompetitionWithTutor.numPosicion( self.procesador.main_window, titentreno, nPosiciones, posUltimo, jump, tipo ) if resp is None: db.close() return pos, tipo, jump = resp db[entreno] = {"POSULTIMO": pos, "SALTA": jump, "TYPE": tipo} db.close() if tipo.startswith("r"): if tipo == "rk": random.seed(pos) random.shuffle(liEntrenamientos) self.procesador.entrenaPos(pos, nPosiciones, titentreno, liEntrenamientos, entreno, jump) elif resp == "learnPGN": self.learnPGN() elif resp == "playGame": self.procesador.play_game() elif resp.startswith("map_"): nada, mapa = resp.split("_") self.procesador.trainingMap(mapa) elif resp == "transsiberian": self.procesador.showRoute() elif resp == "everest": self.everest() elif resp.startswith("tol_"): self.turn_on_lights(resp[4:]) elif resp == "washing_machine": self.washing_machine() elif resp == "captures": self.captures() elif resp == "counts": self.counts() elif resp == "15mate": self.mate15() elif resp == "coordinates_blocks": self.coordinates_blocks() elif resp == "coordinates_basic": self.coordinates_basic() else: if resp <= -100: self.menu = None # ya que puede cambiar y la etiqueta es diferente mem = Memory.Memoria(self.procesador) mem.lanza(abs(resp) - 100)
def recuperaDIC(self): return Util.recuperaVar(self.configuracion.ficheroTrainBooks)
def carpeta_gaviota_defecto(self): return Util.relative_path(Code.path_resource("Gaviota"))
def save(self): dicW = {} dicW["CURRENT"] = self.current dicW["DIC"] = {iso: reg._save() for iso, reg in self.dic.iteritems()} return Util.var2blob(dicW)
def reset(self, depth=None): self.close() Util.borraFichero(self.nomFichero) self._conexion = sqlite3.connect(self.nomFichero) self.depth, self.riniFen = self.checkTable(depth) self.cursor = self._conexion.cursor()
def create_menu_tactics(self, menu, xopcion): menu.separador() menu_tactics = menu.submenu(_("Tactics"), Iconos.Training_Tactics()) # Posiciones de entrenamiento -------------------------------------------------------------------------- self.menuFNS(menu_tactics, _("Training positions"), xopcion) menu_tactics.separador() # Tacticas --------------------------------------------------------------------------------------------- menu_t = menu_tactics.submenu(_("Learn tactics by repetition"), Iconos.Tacticas()) nico = Util.Rondo(Iconos.Amarillo(), Iconos.Naranja(), Iconos.Verde(), Iconos.Azul(), Iconos.Magenta()) dicTraining = TrListas.dicTraining() def trTraining(txt): return dicTraining.get(txt, txt) def menu_tacticas(submenu, tipo, carpeta_base, lista): if os.path.isdir(carpeta_base): for entry in os.scandir(carpeta_base): if entry.is_dir(): carpeta = entry.path ini = os.path.join(carpeta, "Config.ini") if os.path.isfile(ini): name = entry.name xopcion( submenu, "tactica|%s|%s|%s|%s" % (tipo, name, carpeta, ini), trTraining(name), nico.otro(), ) menu_t.separador() lista.append((carpeta, name)) else: submenu1 = submenu.submenu(entry.name, nico.otro()) menu_tacticas(submenu1, tipo, carpeta, lista) return lista menu_tacticas(menu_t, TACTICS_BASIC, Code.path_resource("Tactics"), []) lista = [] carpetaTacticasP = self.configuration.folder_tactics() if os.path.isdir(carpetaTacticasP): submenu1 = menu_t.submenu(_("Personal tactics"), nico.otro()) lista = menu_tacticas(submenu1, TACTICS_PERSONAL, carpetaTacticasP, lista) if lista: ico = Iconos.Delete() menub = menu_t.submenu(_("Remove"), ico) for carpeta, name in lista: xopcion(menub, "remtactica|%s|%s" % (carpeta, name), trTraining(name), ico) menu_tactics.separador() xopcion(menu_tactics, "bmt", _("Find best move"), Iconos.BMT()) menu_tactics.separador() xopcion(menu_tactics, "dailytest", _("Your daily test"), Iconos.DailyTest()) menu_tactics.separador() xopcion(menu_tactics, "potencia", _("Determine your calculating power"), Iconos.Potencia()) menu_tactics.separador() # TOL menu_tactics.separador() menu2 = menu_tactics.submenu(_("Turn on the lights"), Iconos.TOL()) menu.separador() menu3 = menu2.submenu(_("Memory mode"), Iconos.TOL()) xopcion(menu3, "tol_uned_easy", "%s (%s)" % (_("UNED chess school"), _("Initial")), Iconos.Uned()) menu3.separador() xopcion(menu3, "tol_uned", "%s (%s)" % (_("UNED chess school"), _("Complete")), Iconos.Uned()) menu3.separador() xopcion(menu3, "tol_uwe_easy", "%s (%s)" % (_("Uwe Auerswald"), _("Initial")), Iconos.Uwe()) menu3.separador() xopcion(menu3, "tol_uwe", "%s (%s)" % (_("Uwe Auerswald"), _("Complete")), Iconos.Uwe()) menu2.separador() menu3 = menu2.submenu(_("Calculation mode"), Iconos.Calculo()) xopcion(menu3, "tol_uned_easy_calc", "%s (%s)" % (_("UNED chess school"), _("Initial")), Iconos.Uned()) menu3.separador() xopcion(menu3, "tol_uned_calc", "%s (%s)" % (_("UNED chess school"), _("Complete")), Iconos.Uned()) menu3.separador() xopcion(menu3, "tol_uwe_easy_calc", "%s (%s)" % (_("Uwe Auerswald"), _("Initial")), Iconos.Uwe()) menu3.separador() xopcion(menu3, "tol_uwe_calc", "%s (%s)" % (_("Uwe Auerswald"), _("Complete")), Iconos.Uwe()) menu2.separador() xopcion(menu2, "tol_oneline", _("Turn on lights in one line"), Iconos.TOLline())
def tg_training(self): w = WBG_Training.WTraining(self, self.tree.dicValoracion, self.tree.dicVentaja) w.exec_() if not w.siAceptado: return um = QTUtil2.unMomento(self) dic = w.resultado() siBlancas = dic["SIWHITE"] tactica = Tacticas.BaseTactica() menuname = dic["NAME"] depth = dic["DEPTH"] reValW, reVenW = dic["WHITE"] reValB, reVenB = dic["BLACK"] dicVal = {True: reValW, False: reValB} dicVen = {True: reVenW, False: reVenB} siAddOpening = dic["ADDSTD"] if siAddOpening: listaAperturasStd = AperturasStd.ap tactica.SHOWTEXT = [0 if siAddOpening else 1, ] # Leemos todas las lineas=listas de movimientos liT = self.bookGuide.allLines() # Se calcula el nombre de la carpeta name = self.bookGuide.name restDir = name nomDir = os.path.join(VarGen.configuracion.dirPersonalTraining, "Tactics", restDir) nomIni = os.path.join(nomDir, "Config.ini") if os.path.isfile(nomIni): dic = Util.ini8dic(nomIni) n = 1 while True: if "TACTIC%d" % n in dic: if "MENU" in dic["TACTIC%d" % n]: if dic["TACTIC%d" % n]["MENU"].upper() == menuname.upper(): break else: break n += 1 else: break nomTactic = "TACTIC%d" % n else: nomDirTac = os.path.join(VarGen.configuracion.dirPersonalTraining, "Tactics") Util.creaCarpeta(nomDirTac) Util.creaCarpeta(nomDir) nomTactic = "TACTIC1" dic = {} nomFNS = os.path.join(nomDir, nomTactic + ".fns") # Se crea el fichero con los puzzles f = codecs.open(nomFNS, "w", "utf-8", 'ignore') setPr = set() set_fathers_removed = set() for nline, liMVbase in enumerate(liT): if siBlancas: liMV = liMVbase[1:] else: liMV = liMVbase[2:] if not liMV: continue fenBase = liMV[0].fenBase() numJG = 1 pgn = "" if not siBlancas: pgn += "%d..." % numJG numJG += 1 colorAct = siBlancas if len(liMV) > depth: liMV = liMV[:depth] for mv in liMV: mas = "" if mv.adv() in dicVen[colorAct] or \ mv.nag() in dicVal[colorAct] or \ mv.father in set_fathers_removed: set_fathers_removed.add(mv) continue if colorAct == siBlancas: liBrothers = mv.brothers() for mv1 in liBrothers: if mv1.adv() in dicVen[colorAct] or \ mv1.nag() in dicVal[colorAct]: continue mas += "(%s)" % mv1.pgnEN() if colorAct: pgn += " %d." % numJG numJG += 1 pgn += " " + mv.pgnEN() if mas: pgn += " " + mas colorAct = not colorAct k = fenBase + pgn if k not in setPr: txt = "" if siAddOpening: opening = listaAperturasStd.asignaAperturaListaMoves(liMVbase[1:]) if opening: txt += "%s: %s<br>" % (_("Opening"), opening) txt += mv.comment() f.write("%s|%s|%s\n" % (fenBase, txt, pgn)) setPr.add(k) f.close() # Se crea el fichero de control dic[nomTactic] = d = {} d["MENU"] = menuname d["FILESW"] = "%s.fns:100" % nomTactic d["PUZZLES"] = str(tactica.PUZZLES) for field in ("JUMPS", "REPEAT", "PENALIZATION", "SHOWTEXT"): d[field] = tactica.comas2texto(field) Util.dic8ini(nomIni, dic) self.procesador.entrenamientos.rehaz() um.final() QTUtil2.mensaje(self, _X(_("Tactic training %1 created."), menuname) + "<br>" + _X(_("You can access this training from menu Trainings-Learn tactics by repetition-%1"), name))
def leerPGNs(self, ficheros, dlTmp): erroneos = duplicados = importados = n = 0 t1 = time.time() - 0.7 # para que empiece enseguida next_n = random.randint(100, 200) self.dbSTAT.massive_append_set(True) # fich_erroneos = "UsrData/fich_erroneos.pgn" codec = Util.file_encoding(ficheros[0]) sicodec = codec not in ("utf-8", "ascii") liRegs = [] stRegs = set() nRegs = 0 conexion = self._conexion cursor = self._cursor sql = "insert into games (XPV,EVENT,SITE,DATE,WHITE,BLACK,RESULT,ECO,WHITEELO,BLACKELO,PGN,PLIES) values (?,?,?,?,?,?,?,?,?,?,?,?);" liCabs = self.liCamposBase[:-1] # all except PLIES PGN, TAGS liCabs.append("PLYCOUNT") for fichero in ficheros: dlTmp.pon_titulo(os.path.basename(fichero)) with LCEngine.PGNreader(fichero, self.depthStat()) as fpgn: for n, (pgn, pv, dCab, raw, liFens) in enumerate(fpgn, 1): if not pv: erroneos += 1 else: fen = dCab.get("FEN", None) if fen and fen != ControlPosicion.FEN_INICIAL: erroneos += 1 else: xpv = pv2xpv(pv) if xpv in stRegs: dup = True else: cursor.execute( "SELECT COUNT(*) FROM games WHERE XPV = ?", (xpv, )) num = cursor.fetchone()[0] dup = num > 0 if dup: duplicados += 1 else: stRegs.add(xpv) if sicodec: for k, v in dCab.iteritems(): dCab[k] = unicode(v, encoding=codec, errors="ignore") if pgn: pgn = unicode(pgn, encoding=codec, errors="ignore") if raw: # si no tiene variantes ni comentarios, se graba solo las tags que faltan liRTags = [(k, v) for k, v in dCab.iteritems() if k not in liCabs ] # k is always upper if liRTags: pgn = {} pgn["RTAGS"] = liRTags else: pgn = None event = dCab.get("EVENT", "") site = dCab.get("SITE", "") date = dCab.get("DATE", "") white = dCab.get("WHITE", "") black = dCab.get("BLACK", "") result = dCab.get("RESULT", "") eco = dCab.get("ECO", "") whiteelo = dCab.get("WHITEELO", "") blackelo = dCab.get("BLACKELO", "") plies = (pv.count(" ") + 1) if pv else 0 if pgn: pgn = Util.var2blob(pgn) reg = (xpv, event, site, date, white, black, result, eco, whiteelo, blackelo, pgn, plies) self.dbSTAT.append_fen(pv, result, liFens) liRegs.append(reg) nRegs += 1 importados += 1 if nRegs == 10000: cursor.executemany(sql, liRegs) liRegs = [] stRegs = set() conexion.commit() if n == next_n: if time.time() - t1 > 0.8: if not dlTmp.actualiza( erroneos + duplicados + importados, erroneos, duplicados, importados): break t1 = time.time() next_n = n + random.randint(100, 500) if liRegs: cursor.executemany(sql, liRegs) conexion.commit() dlTmp.actualiza(erroneos + duplicados + importados, erroneos, duplicados, importados) dlTmp.ponSaving() self.dbSTAT.massive_append_set(False) self.dbSTAT.commit() conexion.commit() dlTmp.ponContinuar()
def write(self): Util.save_pickle(self.file, self._list)
def new(self): recno = self.ghistorico.recno() if recno >= 0: key = self.liHistorico[recno] reg = self.historico[key] sitePre = reg["SITE"] intervaloPre = reg["INTERVAL"] intervaloPorPiezaPre = reg["INTERVALPIECE"] esatacadaPre = reg["ISATTACKED"] esatacantePre = reg["ISATTACKING"] posicionPre = reg["POSITION"] colorPre = reg["COLOR"] else: recno = 0 sitePre = None intervaloPre = 3 intervaloPorPiezaPre = True esatacadaPre = False esatacantePre = False posicionPre = False colorPre = False # Datos liGen = [(None, None)] # # Site f = open(self.path_bloque) liData = [x.split("|") for x in f.read().split("\n")] f.close() liSites = [] sitePreNum = -1 for n, uno in enumerate(liData): site = uno[0] if site: if sitePre and site == sitePre: sitePreNum = n liSites.append((site, n)) liSites = sorted(liSites, key=lambda st: st[0]) config = FormLayout.Combobox(_("Site"), liSites) if sitePreNum == -1: sitePreNum = liSites[0][0] liGen.append((config, sitePreNum)) liGen.append((None, None)) # # Intervals liGen.append((None, _("Seconds of every glance") + ":")) liGen.append((FormLayout.Spinbox(_("Seconds"), 1, 100, 50), intervaloPre)) liTypes = ((_("By piece"), True), (_("Fixed"), False)) config = FormLayout.Combobox(_("Type"), liTypes) liGen.append((config, intervaloPorPiezaPre)) liGen.append((None, None)) liGen.append((None, _("Ask for") + ":")) liGen.append((_("Position") + ":", posicionPre)) liGen.append((_("Square color") + ":", colorPre)) liGen.append((_("Is attacked?") + ":", esatacadaPre)) liGen.append((_("Is attacking?") + ":", esatacantePre)) resultado = FormLayout.fedit(liGen, title=_("Configuration"), parent=self, icon=Iconos.Gafas(), anchoMinimo=360) if resultado: accion, liGen = resultado siteNum, \ intervalo, intervaloPorPieza, \ posicion, color, esatacada, esatacante = liGen dicdatos = {} f = dicdatos["DATE"] = Util.hoy() dicdatos["FENS"] = liData[siteNum][1:] dicdatos["SITE"] = liData[siteNum][0] dicdatos["INTERVAL"] = intervalo dicdatos["INTERVALPIECE"] = intervaloPorPieza dicdatos["ISATTACKED"] = esatacada dicdatos["ISATTACKING"] = esatacante dicdatos["POSITION"] = posicion dicdatos["COLOR"] = color dicdatos["ERRORS"] = 0 dicdatos["TIME"] = 0 dicdatos["LEVEL"] = 1 key = Util.dtosext(f) self.historico[key] = dicdatos self.liHistorico.insert(0, key) self.ghistorico.refresh() self.ghistorico.gotop() self.work(recno)
def append(self, valor): k = str(Util.today()) self.__setitem__(k, valor) self.regKeys = self.keys(True, True)
def blankPartida(self): hoy = Util.hoy() liTags = [ ["Date", "%d.%02d.%02d" % (hoy.year, hoy.month, hoy.day)], ] return Partida.PartidaCompleta(liTags=liTags)
def nombre(self): self.test_bmi2() if self._nombre: return self._nombre return Util.primeraMayuscula(self.carpeta) + " " + self.version
def carpeta_gaviota(self): if not Util.exist_file( os.path.join(self.x_carpeta_gaviota, "kbbk.gtb.cp4")): self.x_carpeta_gaviota = self.carpeta_gaviota_defecto() self.graba() return self.x_carpeta_gaviota
def __init__(self, procesador, titulo): super().__init__(parent=procesador.pantalla, titulo=titulo, icono=Iconos.Libre(), extparam="entMaquina") self.configuracion = procesador.configuracion self.procesador = procesador self.personalidades = Personalidades.Personalidades( self, self.configuracion) self.motores = Motores.Motores(self.configuracion) # Toolbar liAcciones = [ (_("Accept"), Iconos.Aceptar(), self.aceptar), None, (_("Cancel"), Iconos.Cancelar(), self.cancelar), None, (_("Configurations"), Iconos.Configurar(), self.configuraciones), None, ] tb = Controles.TBrutina(self, liAcciones) # Tab tab = Controles.Tab() def nuevoG(): lyG = Colocacion.G() lyG.filaActual = 0 return lyG gbStyle = """ QGroupBox { font: bold 16px; background-color: #F2F2EC;/*qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #E0E0E0, stop: 1 #FFFFFF);*/ border: 1px solid gray; border-radius: 3px; margin-top: 5ex; /* leave space at the top for the title */ } QGroupBox::title { subcontrol-origin: margin; subcontrol-position: top center; /* position at the top center */ padding: 0 3px; } """ def _label(lyG, txt, ly, rutinaCHB=None, siCheck=False): gb = Controles.GB(self, txt, ly) if rutinaCHB: gb.conectar(rutinaCHB) elif siCheck: gb.setCheckable(True) gb.setChecked(False) gb.setStyleSheet(gbStyle) lyG.controlc(gb, lyG.filaActual, 0) lyG.filaActual += 1 return gb # TAB General lyG = nuevoG() # Blancas o negras self.rbBlancas = Controles.RB(self, "").activa() self.rbBlancas.setIcon( QTVarios.fsvg2ico("Pieces/Chessicons/wp.svg", 64)) self.rbNegras = Controles.RB(self, "") self.rbNegras.setIcon(QTVarios.fsvg2ico("Pieces/Chessicons/bp.svg", 64)) self.rbRandom = Controles.RB(self, _("Random")) hbox = Colocacion.H().relleno().control( self.rbBlancas).espacio(30).control( self.rbNegras).espacio(30).control(self.rbRandom).relleno() _label(lyG, _("Select color"), hbox) # Motores liDepths = [("--", 0)] for x in range(1, 31): liDepths.append((str(x), x)) # # Rival self.rival = self.configuracion.rivalInicial self.rivalTipo = Motores.INTERNO self.btRival = Controles.PB(self, "", self.cambiaRival, plano=False) self.edRtiempo = Controles.ED(self).tipoFloat().anchoMaximo(50) self.cbRdepth = Controles.CB(self, liDepths, 0).capturaCambiado(self.cambiadoDepth) lbTiempoSegundosR = Controles.LB2P(self, _("Time")) lbNivel = Controles.LB2P(self, _("Depth")) # # Ajustar rival liAjustes = self.personalidades.listaAjustes(True) self.cbAjustarRival = Controles.CB(self, liAjustes, kAjustarMejor).capturaCambiado( self.ajustesCambiado) lbAjustarRival = Controles.LB2P(self, _("Set strength")) btAjustarRival = Controles.PB(self, _("Personality"), self.cambiaPersonalidades, plano=True).ponIcono(Iconos.Mas(), tamIcon=16) # Resign lbResign = Controles.LB2P(self, _("Resign/draw by engine")) liResign = ((_("Very early"), -100), (_("Early"), -300), (_("Average"), -500), (_("Late"), -800), (_("Very late"), -1000), (_("Never"), -9999999)) self.cbResign = Controles.CB(self, liResign, -800) lyH1 = Colocacion.H().control(self.btRival).espacio(20) lyH1.control(lbTiempoSegundosR).control(self.edRtiempo) lyH1.control(lbNivel).control(self.cbRdepth).relleno() lyH2 = Colocacion.H().control(lbAjustarRival).control( self.cbAjustarRival).control(btAjustarRival).relleno() lyH3 = Colocacion.H().control(lbResign).control( self.cbResign).relleno() ly = Colocacion.V().otro(lyH1).otro(lyH2).otro(lyH3) _label(lyG, _("Opponent"), ly) gb = Controles.GB(self, "", lyG) tab.nuevaTab(gb, _("Basic configuration")) # TAB Ayudas lbAyudas = Controles.LB2P(self, _("Available hints")) self.sbAyudas = Controles.SB(self, 7, 0, 999).tamMaximo(50) self.cbAtras = Controles.CHB(self, _("Takeback"), True) self.cbChance = Controles.CHB(self, _("Second chance"), True) btTutorChange = Controles.PB(self, _("Tutor change"), self.tutorChange, plano=False).ponIcono(Iconos.Tutor(), tamIcon=16) 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)) lb = Controles.LB(self, _("It is showed") + ":") self.cbThoughtTt = Controles.CB(self, liThinks, -1) self.cbContinueTt = Controles.CHB( self, _("The tutor thinks while you think"), True) lbBoxHeight = Controles.LB2P(self, _("Box height")) self.sbBoxHeight = Controles.SB(self, 7, 0, 999).tamMaximo(50) ly1 = Colocacion.H().control(lb).control(self.cbThoughtTt).relleno() ly2 = Colocacion.H().control(lbBoxHeight).control( self.sbBoxHeight).relleno() ly = Colocacion.V().otro(ly1).control( self.cbContinueTt).espacio(16).otro(ly2).relleno() gbThoughtTt = Controles.GB(self, _("Thought of the tutor"), ly) gbThoughtTt.setStyleSheet(gbStyle) lb = Controles.LB(self, _("It is showed") + ":") self.cbThoughtOp = Controles.CB(self, liThinks, -1) lbArrows = Controles.LB2P(self, _("Arrows to show")) self.sbArrows = Controles.SB(self, 7, 0, 999).tamMaximo(50) ly1 = Colocacion.H().control(lb).control(self.cbThoughtOp).relleno() ly2 = Colocacion.H().control(lbArrows).control(self.sbArrows).relleno() ly = Colocacion.V().otro(ly1).otro(ly2).relleno() gbThoughtOp = Controles.GB(self, _("Thought of the opponent"), ly) gbThoughtOp.setStyleSheet(gbStyle) self.chbSummary = Controles.CHB( self, _("Save a summary when the game is finished in the main comment"), False) lyH1 = Colocacion.H().relleno() lyH1.control(lbAyudas).control(self.sbAyudas).relleno() lyH1.control(self.cbAtras).relleno() lyH1.control(self.cbChance).relleno() lyH1.control(btTutorChange).relleno() # lyV1 = Colocacion.V().control(gbThoughtOp) lyH3 = Colocacion.H().relleno() lyH3.control(gbThoughtOp).relleno() lyH3.control(gbThoughtTt).relleno() ly = Colocacion.V().otro(lyH1).otro(lyH3).control( self.chbSummary).margen(16) gb = Controles.GB(self, "", ly) tab.nuevaTab(gb, _("Help configuration")) # TAB Tiempo lyG = nuevoG() self.edMinutos, self.lbMinutos = QTUtil2.spinBoxLB( self, 15, 0, 999, maxTam=50, etiqueta=_("Total minutes")) self.edSegundos, self.lbSegundos = QTUtil2.spinBoxLB( self, 6, -999, 999, maxTam=54, etiqueta=_("Seconds added per move")) self.edMinExtra, self.lbMinExtra = QTUtil2.spinBoxLB( self, 0, -999, 999, maxTam=70, etiqueta=_("Extra minutes for the player")) self.edZeitnot, self.lbZeitnot = QTUtil2.spinBoxLB( self, 0, -999, 999, maxTam=54, etiqueta=_("Zeitnot: alarm sounds when remaining seconds")) lyH1 = Colocacion.H() lyH1.control(self.lbMinutos).control(self.edMinutos).espacio(30) lyH1.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(lyH1).otro(lyH2).otro(lyH3) self.chbTiempo = _label(lyG, _("Time"), ly, siCheck=True) gb = Controles.GB(self, "", lyG) tab.nuevaTab(gb, _("Time")) # TAB Initial moves lyG = nuevoG() # Posicion self.btPosicion = Controles.PB(self, " " * 5 + _("Change") + " " * 5, self.posicionEditar).ponPlano(False) self.fen = "" 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")) hbox = Colocacion.H().relleno().control(self.btPosicionQuitar).control( self.btPosicion).control(self.btPosicionPegar).relleno() _label(lyG, _("Start position"), hbox) # Aperturas self.btApertura = Controles.PB(self, " " * 5 + _("Undetermined") + " " * 5, self.editarApertura).ponPlano(False) self.bloqueApertura = None self.btAperturasFavoritas = Controles.PB( self, "", self.aperturasFavoritas).ponIcono(Iconos.Favoritos()) self.btAperturasQuitar = Controles.PB( self, "", self.aperturasQuitar).ponIcono(Iconos.Motor_No()) hbox = Colocacion.H().relleno().control( self.btAperturasQuitar).control(self.btApertura).control( self.btAperturasFavoritas).relleno() _label(lyG, _("Opening"), hbox) # Libros fvar = self.configuracion.ficheroBooks self.listaLibros = Books.ListaLibros() self.listaLibros.recuperaVar(fvar) # Comprobamos que todos esten accesibles self.listaLibros.comprueba() li = [(x.nombre, x) for x in self.listaLibros.lista] libInicial = li[0][1] if li else None self.cbBooks = QTUtil2.comboBoxLB(self, li, libInicial) self.btNuevoBook = Controles.PB(self, "", self.nuevoBook, plano=True).ponIcono(Iconos.Mas(), tamIcon=16) self.chbBookMandatory = Controles.CHB(self, _("Mandatory"), False) # Respuesta rival li = ( (_("Selected by the player"), "su"), (_("Uniform random"), "au"), (_("Proportional random"), "ap"), (_("Always the highest percentage"), "mp"), ) self.cbBooksRR = QTUtil2.comboBoxLB(self, li, "mp") self.lbBooksRR = Controles.LB2P(self, _("Opponent's move")) hbox = Colocacion.H().relleno().control(self.cbBooks).control( self.btNuevoBook).control(self.chbBookMandatory).relleno() hboxRR = Colocacion.H().relleno().control(self.lbBooksRR).control( self.cbBooksRR).relleno() hboxV = Colocacion.V().otro(hbox).otro(hboxRR) self.chbBook = _label(lyG, _("Book"), hboxV, siCheck=True) ly = Colocacion.V().otro(lyG).relleno() gb = Controles.GB(self, "", ly) tab.nuevaTab(gb, _("Initial moves")) layout = Colocacion.V().control(tb).control(tab).relleno().margen(3) self.setLayout(layout) self.liAperturasFavoritas = [] self.btAperturasFavoritas.hide() dic = Util.recuperaDIC(self.configuracion.ficheroEntMaquina) if not dic: dic = {} self.muestraDic(dic) self.ajustesCambiado() # self.ayudasCambiado() self.ponRival() self.recuperarVideo()
def piezas_gaviota(self): if Util.exist_file( os.path.join(self.carpeta_gaviota(), "kbbkb.gtb.cp4")): return 5 return 4
def dbdatos(self): return Util.DicSQL(self.fichero, tabla=self.nombre)