def read_line_fich(self, line):
        li = line.strip().split("|")
        self.fen, self.label, pgn_moves = li[0], li[1], li[2]

        p = Game.fen_game(self.fen, pgn_moves)
        self.pv = p.pv()
        self.limoves = self.pv.split(" ")

        nmoves = len(self.limoves)
        self.num_moves = int(len(self.limoves) / 2)
        if nmoves % 2 == 1:
            self.num_moves += 1
        return self
    def phase2(self, entry:os.DirEntry):
        db = LIBridge(entry.path)
        for x in range(len(db)):
            dato = db[x]
            dic = eval(dato)
            if "INIFEN" in dic:
                g = Game.Game(fen=dic["INIFEN"])
            else:
                g = Game.Game()
            g.set_tags(dic["LITAGS"])
            result = g.get_tag("Result")
            g.set_termination(dic["TERMINATION"], result if result else RESULT_UNKNOWN)
            li_moves = dic["MOVES"]
            current_position = g.last_position.copia()
            for dic_mv in li_moves:
                pv = dic_mv["MV"]
                position = current_position.copia()
                position.moverPV(pv)
                move = Move.Move(g, position_before=current_position, position=position, from_sq=pv[:2], to_sq=pv[2:4], promotion=pv[4:])
                if "VARIATIONS" in dic_mv:
                    li_varpgn = dic_mv["VARIATIONS"]
                    fen_base = current_position.fen()
                    for varpgn in li_varpgn:
                        gv = Game.fen_game(fen_base, varpgn)
                        if gv:
                            move.add_variation(gv)
                if "COMMENT" in dic_mv:
                    move.comment = dic_mv["COMMENT"]
                if "$NAGS" in dic_mv:
                    nags = dic_mv["$NAGS"]
                    for nag in nags.split(" "):
                        if nag.isdigit():
                            move.add_nag(int(nag))
                if "NAGS" in dic_mv:
                    nags = dic_mv["NAGS"]
                    for nag in nags.split(" "):
                        if nag in self.dic_cnags:
                            move.add_nag(self.dic_cnags[nag])
                if "MRM" in dic_mv:
                    mrm_pos =  dic_mv["MRM_POS"]
                    mrm_save = dic_mv["MRM"]
                    mrm = EngineResponse.MultiEngineResponse(None, True)
                    mrm.restore(mrm_save)
                    move.analysis = mrm, mrm_pos

                current_position = position.copia()
                g.add_move(move)
            print(dic)

        db.close()
    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()
Example #4
0
def edit_variation_moves(procesador,
                         window,
                         is_white_bottom,
                         fen,
                         linea_pgn,
                         titulo=None):
    game = Game.fen_game(fen, linea_pgn)
    xtutor = procesador.XTutor()
    procesador_variations = procesador.clonVariations(window,
                                                      xtutor,
                                                      is_competitive=False)

    manager_variations = ManagerVariations.ManagerVariations(
        procesador_variations)
    manager_variations.start(game, is_white_bottom, False, False)
    procesador_variations.manager = manager_variations

    if titulo is None:
        titulo = game.pgnBaseRAW()

    procesador_variations.main_window.show_variations(titulo)

    return manager_variations.valor()
Example #5
0
    def phase2(self, pb: QTUtil2.BarraProgreso1, entry: os.DirEntry):
        dest = entry.name

        name = ".".join(entry.name.split(".")[:-2])
        pb.ponRotulo(name)

        li = dest.split(".")
        dest = ".".join(li[:-2])
        path_dest = os.path.join(Code.configuration.folder_databases(),
                                 dest + ".lcdb")
        db_dest = DBgames.DBgames(path_dest)
        db_ori = LIVersion11(entry.path)
        total = len(db_ori)
        pb.ponTotal(total)
        for x in range(total):
            pb.pon(x + 1)
            if pb.is_canceled():
                break
            dic = db_ori[x]
            g = Game.Game(fen=dic.get("INIFEN"))
            g.set_tags(dic["LITAGS"])
            result = g.get_tag("Result")
            g.set_termination(dic["TERMINATION"],
                              result if result else RESULT_UNKNOWN)
            li_moves = dic["MOVES"]
            current_position = g.last_position.copia()
            for dic_mv in li_moves:
                pv = dic_mv["M"]
                position = current_position.copia()
                position.moverPV(pv)
                move = Move.Move(g,
                                 position_before=current_position,
                                 position=position,
                                 from_sq=pv[:2],
                                 to_sq=pv[2:4],
                                 promotion=pv[4:])
                if "VARIATIONS" in dic_mv:
                    li_varpgn = dic_mv["VARIATIONS"]
                    fen_base = current_position.fen()
                    for varpgn in li_varpgn:
                        gv = Game.fen_game(fen_base, varpgn)
                        if gv:
                            move.add_variation(gv)
                if "COMMENT" in dic_mv:
                    move.comment = dic_mv["COMMENT"]
                if "$NAGS" in dic_mv:
                    nags = dic_mv["$NAGS"]
                    for nag in nags.split(" "):
                        if nag.isdigit():
                            move.add_nag(int(nag))
                if "NAGS" in dic_mv:
                    nags = dic_mv["NAGS"]
                    for nag in nags.split(" "):
                        if nag in self.dic_cnags:
                            move.add_nag(self.dic_cnags[nag])
                if "AMRM" in dic_mv:
                    mrm_pos = dic_mv["APOS"]
                    mrm_save = dic_mv["AMRM"]
                    mrm = EngineResponse.MultiEngineResponse(None, True)
                    mrm.restore(mrm_save)
                    move.analysis = mrm, mrm_pos

                current_position = position.copia()
                g.add_move(move)

            db_dest.insert(g)
        db_ori.close()
        if pb.is_canceled():
            db_dest.close()
            return False

        db_dest.commit()
        db_dest.close()

        shutil.move(entry.path, entry.path + ".imported")
        return True