def start_with_user(self, user):
self.user = user
self.li_opciones_inicio = [
TB_QUIT, TB_PLAY, TB_TRAIN, TB_COMPETE, TB_TOOLS, TB_OPTIONS,
TB_INFORMATION
] # Lo incluimos aqui porque sino no lo lee, en caso de aplazada
self.configuration = Configuration.Configuration(user)
self.configuration.start()
Code.configuration = self.configuration
Code.procesador = self
OpeningsStd.reset()
# Tras crear configuración miramos si hay Adjournments
self.test_opcion_Adjournments()
Code.todasPiezas = Piezas.TodasPiezas()
self.manager = None
self.siPrimeraVez = True
self.siPresentacion = False # si esta funcionando la presentacion
self.posicionInicial = Position.Position()
self.posicionInicial.set_pos_initial()
self.xrival = None
self.xtutor = None # creaTutor lo usa asi que hay que definirlo antes
self.xanalyzer = None # cuando se juega ManagerEntMaq y el tutor danzando a toda maquina,
# se necesita otro diferente
self.replay = None
self.replayBeep = None
def set_fen(self, fen):
if not fen or fen == FEN_INITIAL:
return self.set_position(None)
cp = Position.Position()
cp.read_fen(fen)
self.set_position(cp)
def siguiente_posicion(self):
num_lineas_posicion = len(self.li_lineas_posicion)
while True:
random_pos = random.randint(0, num_lineas_posicion - 1)
if not (random_pos in self.st_randoms):
self.st_randoms.add(random_pos)
break
self.fen, self.result, self.pgn_result, self.pgn, self.difficult = (
self.li_lineas_posicion[random_pos].strip().split("|"))
self.difficult = int(self.difficult)
self.cp = Position.Position()
self.cp.read_fen(self.fen)
self.is_white = " w " in self.fen
self.board.bloqueaRotacion(False)
self.board.set_dispatcher(self.player_has_moved)
self.board.set_position(self.cp)
self.board.ponerPiezasAbajo(self.is_white)
self.board.activate_side(self.is_white)
self.board.set_side_indicator(self.is_white)
self.intentos = 0
self.max_intentos = (self.difficult + 1) // 2 + 4
self.iniTime = time.time()
def setPosicion(self, game, njg, numTab=None):
if game is None:
return
move = game.move(njg)
self.game = game
self.njg = njg
next = self.cb_nextmove.valor()
if move:
if njg == 0:
pv = game.pv_hasta(njg) if next else ""
else:
pv = game.pv_hasta(njg if next else njg - 1)
position = move.position if next else move.position_before
else:
position = Position.Position().set_pos_initial()
pv = ""
for ntab, (tipo, tab) in enumerate(self.li_tabs):
if ntab == 0:
p = Game.Game()
p.read_pv(pv)
tab.setData(
p.pgn_html(
with_figurines=self.configuration.x_pgn_withfigurines),
position)
else:
data = pv if tipo == "dbase" else position
if numTab is not None:
if ntab != numTab:
continue
if ntab > 1:
tab.setData(data)
tab.start()
def __init__(self, moveOwner, fen, dbCache):
self.moveOwner = moveOwner
self.dbCache = dbCache
if not moveOwner:
self.nivel = 0
cp = Position.Position()
cp.read_fen(fen)
self.gameBase = Game.Game(cp)
else:
self.nivel = self.moveOwner.listaMovesPadre.nivel + 1
self.gameBase = self.moveOwner.game.copia()
self.fenm2 = self.gameBase.last_position.fenm2()
dicCache = self.dbCache[self.fenm2]
FasterCode.set_fen(self.fenm2 + " 0 1")
liMov = [xpv[1:] for xpv in FasterCode.get_moves()]
liMov.sort()
liMoves = []
for pv in liMov:
um = UnMove(self, pv, dicCache)
liMoves.append(um)
self.liMoves = liMoves
self.liMovesInicial = liMoves[:]
self.li_analysis = dicCache.get("ANALISIS", []) if dicCache else []
# self.analisisActivo
# self.dicAnalisis
self.ponAnalisisActivo(dicCache.get("ANALISIS_ACTIVO", None) if dicCache else None)
def posicionEditar(self):
cp = Position.Position()
cp.read_fen(self.fen)
resp = Voyager.voyager_position(self, cp)
if resp is not None:
self.fen = resp.fen()
self.muestraPosicion()
def check(self):
self.bt_check.hide()
cp = Position.Position()
cp.read_fen(self.mate15.fen)
first_move = self.mate15.move
cp.mover(first_move[:2], first_move[2:4], first_move[4:])
fen = cp.fen()
si_error = False
for pos, (move, resp) in enumerate(self.mate15.resp.items()):
cp.read_fen(fen)
cp.mover(move[:2], move[2:4], move[4:])
wm = self.li_lb_wm[pos][1]
mv_done = wm.movimiento()
if mv_done == resp:
wm.correcta()
else:
wm.error()
si_error = True
if si_error:
self.bt_check.show()
else:
tiempo = time.time() - self.time_base
self.lb_result.set_text('%s: %.1f"' % (_("Time"), tiempo))
self.lb_result.show()
self.mate15.append_try(tiempo)
self.db_mate15.save(self.mate15)
self.show_tb(self.terminar, self.seguir)
def __init__(self, line):
self.line = line # Se usa en ManagerEntPos
self.position = Position.Position()
self.label = ""
self.game_obj = None
self.game_original = None
self.read(line)
def set_position(self):
self.show_tb(self.terminar, self.restart)
self.lb_info.set_text("[%d] %s" % (self.mate15.pos + 1, self.mate15.info))
fen = self.mate15.fen
cp = Position.Position()
cp.read_fen(fen)
self.board.set_position(cp)
self.gb.show()
self.lb_first_move.set_text("%s: %s" % (_("First move"), cp.html(self.mate15.move)))
self.bt_check.show()
self.lb_result.hide()
li_moves = list(self.mate15.resp.keys())
n_moves = len(li_moves)
mv = self.mate15.move
cp.mover(mv[:2], mv[2:4], mv[4:])
for n, (lb, wm) in enumerate(self.li_lb_wm):
if n < n_moves:
lb.set_text(cp.html(li_moves[n]))
lb.show()
wm.limpia()
wm.show()
else:
wm.hide()
lb.hide()
self.gb.setEnabled(True)
self.li_lb_wm[0][1].activa()
self.time_base = time.time()
def read_key(self, key, order):
if not (key in self.db_data) and self.examples_auto:
cp = Position.Position()
lista = self.db_examples[key]
if lista:
d = {}
for mt, fen in lista:
cp.read_fen(fen)
d[fen] = {
"MATE": mt,
"XFEN": cp.label(),
"ORIGIN": "example"
}
self.db_data[key] = d
self.current_dicfen = self.db_data.get(key, {})
self.current_key = key
self.current_fen = None
self.current_listfen = list(self.current_dicfen.keys())
self.current_order = order
if order == "random":
random.shuffle(self.current_listfen)
elif order == "difficulty":
self.current_listfen.sort(key=lambda x: self.current_dicfen[x][
"MATE"] if self.current_dicfen[x]["MATE"] > 0 else 999)
return len(self.current_listfen)
def leeLibros(self, liLibros, fen, masTitulo, siPV):
if not fen:
return []
position = Position.Position()
position.read_fen(fen)
p = Polyglot()
ico = "w" if position.is_white else "b"
icoL = "l"
liResp = []
for book in liLibros:
liResp.append((None, book.name + masTitulo, icoL))
li = p.lista(book.path, fen)
if li:
total = 0
for entry in li:
total += entry.weight
for entry in li:
pv = entry.pv()
w = entry.weight
pc = w * 100.0 / total if total else "?"
pgn = position.pgn_translated(pv[:2], pv[2:4], pv[4:])
liResp.append((pv if siPV else None, "%-5s -%7.02f%% -%7d" % (pgn, pc, w), ico))
else:
liResp.append((None, _("No result"), "c"))
return liResp
def almListaJugadas(self, fen):
li = self.book.lista(self.path, fen)
position = Position.Position()
position.read_fen(fen)
total = 0
maxim = 0
for entry in li:
w = entry.weight
total += w
if w > maxim:
maxim = w
listaJugadas = []
for entry in li:
alm = Util.Record()
pv = alm.pv = entry.pv()
w = entry.weight
alm.from_sq, alm.to_sq, alm.promotion = pv[:2], pv[2:4], pv[4:]
alm.pgn = position.pgn_translated(alm.from_sq, alm.to_sq, alm.promotion)
alm.pgnRaw = position.pgn(alm.from_sq, alm.to_sq, alm.promotion)
alm.fen = fen
alm.porc = "%0.02f%%" % (w * 100.0 / total,) if total else ""
alm.weight = w
listaJugadas.append(alm)
return listaJugadas
def posicionEditar(self):
cp = Position.Position()
cp.read_fen(self.fen)
resp = Voyager.voyager_position(self, cp, wownerowner=self.procesador.main_window)
if resp is not None:
self.fen = resp.fen()
self.muestraPosicion()
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 __init__(self, wowner, configuration, path_lcbin):
self.title = os.path.basename(path_lcbin)[:-6]
QTVarios.WDialogo.__init__(self, wowner, self.title, Iconos.Book(), "polyglot")
self.configuration = configuration
self.path_lcbin = path_lcbin
self.owner = wowner
self.db_entries = DBPolyglot.DBPolyglot(path_lcbin)
self.pol_import = PolyglotImportExports.PolyglotImport(self)
self.pol_export = PolyglotImportExports.PolyglotExport(self)
self.li_moves = []
self.history = []
conf_board = configuration.config_board("WPOLYGLOT", 48)
self.board = Board.Board(self, conf_board)
self.board.crea()
self.board.set_dispatcher(self.mensajero)
self.with_figurines = configuration.x_pgn_withfigurines
o_columnas = Columnas.ListaColumnas()
delegado = Delegados.EtiquetaPOS(True, siLineas=False) if self.configuration.x_pgn_withfigurines else None
o_columnas.nueva("move", _("Move"), 80, centered=True, edicion=delegado, siEditable=False)
o_columnas.nueva("%", "%", 60, siDerecha=True, siEditable=False)
o_columnas.nueva("weight", _("Weight"), 60, siDerecha=True, edicion=Delegados.LineaTexto(siEntero=True))
o_columnas.nueva("score", _("Score"), 60, siDerecha=True, edicion=Delegados.LineaTexto(siEntero=True))
o_columnas.nueva("depth", _("Depth"), 60, siDerecha=True, edicion=Delegados.LineaTexto(siEntero=True))
o_columnas.nueva("learn", _("Learn"), 60, siDerecha=True, edicion=Delegados.LineaTexto(siEntero=True))
self.grid_moves = Grid.Grid(self, o_columnas, siEditable=True)
self.grid_moves.setMinimumWidth(self.grid_moves.anchoColumnas() + 20)
li_acciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Takeback"), Iconos.Atras(), self.takeback),
None,
(_("Voyager"), Iconos.Voyager32(), self.voyager),
None,
(_("Import"), Iconos.Import8(), self.pol_import.importar),
None,
(_("Create book"), Iconos.BinBook(), self.pol_export.exportar),
None,
)
self.tb = Controles.TBrutina(self, li_acciones)
ly2 = Colocacion.V().control(self.tb).control(self.grid_moves)
layout = Colocacion.H().control(self.board).otro(ly2)
self.setLayout(layout)
self.restore_video()
self.position = None
position = Position.Position()
position.set_pos_initial()
self.set_position(position, True)
def __init__(self, owner, liFens, engine, segundos, fns):
super(WDailyTest, self).__init__(owner, _("Your daily test"),
Iconos.DailyTest(), "nivel")
self.procesador = owner.procesador
self.configuration = self.procesador.configuration
if engine.startswith("*"):
engine = engine[1:]
confMotor = self.configuration.buscaTutor(engine)
self.xtutor = self.procesador.creaManagerMotor(confMotor,
segundos * 1000, None)
self.xtutor.maximizaMultiPV()
self.historico = owner.historico
# Board
config_board = self.configuration.config_board("LEVEL", 48)
self.liFens = liFens
self.nFens = len(self.liFens)
self.juego = 0
self.liPuntos = []
self.li_pv = []
self.li_tiempos = []
self.fns = fns
self.board = Board.Board(self, config_board)
self.board.crea()
self.board.set_dispatcher(self.player_has_moved)
# Rotulos informacion
self.lbColor = Controles.LB(self, "").set_wrap().anchoMinimo(200)
self.lbJuego = Controles.LB(self, "").align_center()
# Tool bar
li_acciones = (
# ( _( "Start" ), Iconos.Empezar(), "empezar" ),
(_("Analysis"), Iconos.Tutor(), "analizar"),
(_("Cancel"), Iconos.Cancelar(), "cancelar"),
(_("Continue"), Iconos.Pelicula_Seguir(), "seguir"),
(_("Resign"), Iconos.Abandonar(), "abandonar"),
)
self.tb = Controles.TB(self, li_acciones)
lyT = Colocacion.V().control(self.board).relleno()
lyV = Colocacion.V().control(self.lbJuego).relleno().control(
self.lbColor).relleno(2)
lyTV = Colocacion.H().otro(lyT).otro(lyV)
ly = Colocacion.V().control(self.tb).otro(lyTV)
self.setLayout(ly)
self.position = Position.Position()
self.restore_video()
self.play_next_move()
def MoverInicio(self):
if self.usoNormal:
self.posHistoria = -1
position = Position.Position().set_pos_initial()
else:
# self.colocatePartida(-1)
self.pos_move = -1
position = self.game.first_position
self.board.set_position(position)
def factorDistancia(self):
nummoves = 0
distancia = 0.0
for line in self.lines:
d, n = line.distancia_moves()
nummoves += n
distancia += d
base_dist = Position.distancia("a1", "a4")
return (distancia / nummoves) / base_dist
def __init__(self, owner, db_coordinates, is_white):
QTVarios.WDialogo.__init__(self, owner, _("Coordinates"),
Iconos.Blocks(), "runcoordinatesbasic")
self.configuration = Code.configuration
self.is_white = is_white
self.db_coordinates = db_coordinates
self.coordinates = None
self.current_score = 0
self.working = False
self.time_ini = None
conf_board = self.configuration.config_board(
"RUNCOORDINATESBASIC", self.configuration.size_base())
self.board = Board.BoardEstaticoMensaje(self, conf_board, None, 0.6)
self.board.crea()
self.board.bloqueaRotacion(True)
self.cp_initial = Position.Position()
self.cp_initial.set_pos_initial()
self.board.ponerPiezasAbajo(self.is_white)
self.board.set_position(self.cp_initial)
font = Controles.TipoLetra(puntos=26, peso=500)
lb_score_k = Controles.LB(self, _("Score")).ponFuente(font)
self.lb_score = Controles.LB(self).ponFuente(font)
li_acciones = (
(_("Close"), Iconos.MainMenu(), self.terminar),
None,
(_("Begin"), Iconos.Empezar(), self.begin),
(_("Continue"), Iconos.Pelicula_Seguir(), self.seguir),
)
self.tb = QTVarios.LCTB(self, li_acciones)
self.show_tb(self.terminar, self.begin)
ly_info = Colocacion.G()
ly_info.controlc(lb_score_k, 0, 0).controlc(self.lb_score, 1, 0)
ly_right = Colocacion.V().control(
self.tb).relleno().otro(ly_info).relleno()
w = QtWidgets.QWidget(self)
w.setLayout(ly_right)
w.setMinimumWidth(240)
ly_center = Colocacion.H().control(self.board).control(w).margen(3)
self.setLayout(ly_center)
self.restore_video()
self.adjustSize()
def insert(self, fen, mt):
cp = Position.Position()
cp.read_fen(fen)
key = cp.pzs_key()
fen_m2 = cp.fenm2()
self.read_key(key, "initial")
if fen_m2 not in self.current_dicfen:
self.current_dicfen[fen_m2] = {"MATE": mt, "XFEN": cp.label(), "ORIGIN": "manual"}
self.db_data[key] = self.current_dicfen
self.current_listfen.append(fen_m2)
return key, fen_m2
def posicionPegar(self):
texto = QTUtil.traePortapapeles()
if texto:
cp = Position.Position()
try:
cp.read_fen(texto.strip())
self.fen = cp.fen()
if self.fen == FEN_INITIAL:
self.fen = ""
self.muestraPosicion()
except:
pass
def reinicio(self, dbop):
self.dbop = dbop
self.game_type = GT_OPENING_LINES
self.training = self.dbop.training()
self.li_trainPositions = self.training["LITRAINPOSITIONS"]
self.trposition = self.li_trainPositions[0]
self.tm = 0
for game_info in self.li_trainPositions:
for tr in game_info["TRIES"]:
self.tm += tr["TIME"]
self.liMensBasic = [
"%s: %d" % (_("Moves"), len(self.li_trainPositions))
]
self.siAyuda = False
self.with_automatic_jump = True
cp = Position.Position()
cp.read_fen(self.trposition["FENM2"] + " 0 1")
self.game = Game.Game(ini_posicion=cp)
self.hints = 9999 # Para que analice sin problemas
self.is_human_side_white = self.training["COLOR"] == "WHITE"
self.is_engine_side_white = not self.is_human_side_white
self.main_window.pon_toolbar((TB_CLOSE, TB_HELP, TB_CONFIG))
self.main_window.activaJuego(True, False, siAyudas=False)
self.set_dispatcher(self.player_has_moved)
self.set_position(cp)
self.show_side_indicator(True)
self.remove_hints()
self.put_pieces_bottom(self.is_human_side_white)
self.pgnRefresh(True)
self.ponCapInfoPorDefecto()
self.state = ST_PLAYING
self.check_boards_setposition()
self.remove_info()
self.errores = 0
self.ini_time = time.time()
self.muestraInformacion()
self.play_next_move()
def import_lista(self, tipo, li_fens_mt):
cp = Position.Position()
self.db_data.set_faster_mode()
for fen, mt in li_fens_mt:
cp.read_fen(fen)
key = cp.pzs_key()
fen_m2 = cp.fenm2()
dic = self.db_data.get(key, {})
if fen_m2 in dic:
dic[fen_m2]["ORIGIN"] = tipo
else:
dic[fen_m2] = {"MATE": mt, "XFEN": cp.label(), "ORIGIN": tipo}
self.db_data[key] = dic
self.db_data.set_normal_mode()
def seguir(self):
fenIni, fenFin, liMV, info = self.owner.dameOtro()
self.liMV = liMV
self.fenIni = fenIni
self.fenFin = fenFin
# Boards
cpIni = Position.Position()
cpIni.read_fen(fenIni)
is_white = cpIni.is_white
self.boardIni.ponerPiezasAbajo(is_white)
self.boardIni.set_position(cpIni)
cpFin = Position.Position()
cpFin.read_fen(fenFin)
self.boardFin.ponerPiezasAbajo(is_white) # esta bien
self.boardFin.set_position(cpFin)
# Rotulo informacion
self.lbInformacion.set_text(self.textoLBInformacion(info, cpIni))
# Rotulo vtime
self.lbTiempo.set_text("")
for wm in self.liwm:
wm.limpia()
self.time_base = time.time()
self.btComprobar.show()
self.btSeguir.hide()
self.btCancelar.show()
self.btTerminar.hide()
self.liwm[0].activa()
def add_examples(self, key):
cp = Position.Position()
lista = self.db_examples[key]
if lista:
num_imported = 0
d = self.db_data.get(key, {})
for mt, fen_m2 in lista:
if fen_m2 not in d:
cp.read_fen(fen_m2)
d[fen_m2] = {"MATE": mt, "XFEN": cp.label(), "ORIGIN": "example"}
num_imported += 1
self.db_data[key] = d
return num_imported
else:
return 0
def preparaTest(self):
self.cpInicial = Position.Position()
self.cpInicial.read_fen("8/8/8/8/8/8/8/8 w - - 0 1")
squares = self.cpInicial.squares
self.baseUnica = self.test > 3
self.is_white = random.randint(1, 2) == 1
if self.test in (1, 4, 5):
celdas_ocupadas = []
elif self.test == 2: # 4 peones
celdas_ocupadas = [18, 21, 25, 27, 28, 30, 42, 45, 49, 51, 52, 54]
for a1 in ("c3", "c6", "f3", "f6"):
squares[a1] = "p" if self.is_white else "P"
elif self.test == 3: # levitt
ch = celdas_ocupadas = [27]
for li in FasterCode.dict_q[27]:
for x in li:
ch.append(x)
squares["d4"] = "q" if self.is_white else "Q"
self.camino = []
p, f, s = 0, 7, 1
for x in range(8):
li = list(range(p, f + s, s))
for t in range(7, -1, -1):
if li[t] in celdas_ocupadas:
del li[t]
self.camino.extend(li)
if s == 1:
s = -1
p += 15
f += 1
else:
s = +1
p += 1
f += 15
if self.test == 5: # empieza en e4
for n, x in enumerate(self.camino):
if x == 28:
del self.camino[n]
self.camino.insert(0, 28)
break
self.current_position = 0
self.celdas_ocupadas = celdas_ocupadas
def restore(self, btxt_save):
dic = Util.zip2var(btxt_save)
self.first_position = Position.Position()
self.first_position.read_fen(dic["first_position"])
self.first_comment = dic["first_comment"]
self.result = dic["result"]
self.termination = dic["termination"]
self.li_moves = []
cp = self.first_position.copia()
for save_jg in dic["li_moves"]:
move = Move.Move(self, position_before=cp)
move.restore(save_jg)
cp = move.position.copia()
self.li_moves.append(move)
self.assign_opening()
self.si3repetidas()
self.li_tags = dic.get("li_tags", [])
def recalcFenM2(self):
lilipv = [FasterCode.xpv_pv(xpv).split(" ") for xpv in self.li_xpv]
cp = Position.Position()
dicFENm2 = {}
if not lilipv and self.basePV:
lilipv.append(self.basePV.split(" "))
for lipv in lilipv:
FasterCode.set_init_fen()
for pv in lipv:
fen = FasterCode.get_fen()
cp.read_fen(fen)
fenm2 = cp.fenm2()
if not (fenm2 in dicFENm2):
dicFENm2[fenm2] = set()
dicFENm2[fenm2].add(pv)
FasterCode.make_move(pv)
return dicFENm2
def start(self, route):
ManagerRoutes.start(self, route)
tactica = self.route.get_tactic()
self.game_objetivo = Game.fen_game(tactica.fen, tactica.pgn)
self.is_rival_thinking = False
cp = Position.Position()
cp.read_fen(tactica.fen)
self.fen = tactica.fen
is_white = cp.is_white
self.game.set_position(cp)
self.game.pending_opening = False
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.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.set_label1("<b>%s</b>" % tactica.label)
self.set_label2(route.mens_tactic(False))
self.pgnRefresh(True)
QTUtil.refresh_gui()
self.check_boards_setposition()
self.play_next_move()
def set_position(self, first_position=None):
self.li_moves = []
self.opening = None
self.result = RESULT_UNKNOWN
self.termination = TERMINATION_UNKNOWN
self.rotuloTablasRepeticion = None
self.pending_opening = False
if first_position:
self.first_position = first_position.copia()
fen_inicial = self.first_position.fen()
es_inicial = self.pending_opening = fen_inicial == FEN_INITIAL
if not es_inicial:
self.set_tag("FEN", fen_inicial)
else:
self.first_position = Position.Position()
self.first_position.set_pos_initial()
self.pending_opening = True