TalChess

# 前端
cd /front
npm i;
npm run dev;

# 引擎
cd /engine
pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple/
# 把引擎的数据集也下载进来
git clone https://gitee.com/Jifashi_619/tal_database.git
python main.py

send = {
        operator: 'get_fen_name',
        data:{
          fen,  // fen数据
            first, //第一步棋的走法 如e4
          step:'e5', //当前棋步 如e5
        }
}

return  {
    'code': 0,
    'message': '获取对局名称成功',
    'data': {
        'name': '意大利开局',
        'name_en': 'Italian Game',
    }
}

send = {
    operator: 'save_fen',
    data: {
        name, //开局名
        nameEn,//开局名En
        fen: 'fen', //fen
        step,//当前棋步 如 e4
        // 告诉引擎第一步棋是什么 引擎会决定存到哪个数据库里面e4 d4 other
        first: 'e4', // e4 d4 或者其他的值 按实际情况
    }
}

return {
    'code': 0,
    'message': '保存棋谱成功' // 前端根据code和message决定消息提醒类型是成功还是警告
}

send = {
    operator: 'analyze',
    data: {
        fen //fen
    },
}

return {
    fen,
    step,
    uci:'h2h3', // uci类型的棋步信息
    score:'+1.2' // 局面分
}

if self.is_leaf(node) is False:
    if color is evaluate.Color.WHITE:
        max_ucb = 0
        max_index = 0
        invalid = True
        for i in range(len(node.leaf)):
            # 已经到棋局尾声的节点就跳过
            if node.leaf[i].is_end is True:
                continue
            # 求最大值
            leaf_ucb = self.calc_UCB(node.leaf[i], num, color)
            # 无穷大就是最大
            if math.isinf(leaf_ucb):
                max_index = i
                break
            max_ucb = max_ucb if max_ucb > leaf_ucb else leaf_ucb
            max_index = max_index if max_ucb > leaf_ucb else max_index
            invalid = False
        if invalid is True:
            print('已经没有可用节点了')
            return invalid
        return self.select(node.leaf[max_index], num, color)

else:
    node, value = self.extend(node, num)
    self.backward(node, num, value)

def extend(node: Node, num: int) -> tuple:
        board = node.board
        legal_list = list(board.legal_moves)
        value = 0

        # 对每个节点按深度模拟一次
        for i in range(len(legal_list)):
            move = legal_list[i]
            temp_board = copy.deepcopy(board)
            temp_board.push(move)
            internal = chess_util.parse_internal_board_info(temp_board, temp_board.fen())
            get_value = chess_util.do_evaluate(temp_board, internal)
            if chess_util.get_current_color_by_fen(temp_board.fen()) is evaluate.Color.WHITE:
                value = value if value > get_value else value
            else:
                value = value if value < get_value else value
            node.leaf.append(Node(temp_board.fen(), move, node, value))
        return node, value

    def backward(self, node: Node, num: int, value: float) -> None:
        node.value += value
        node.times += num
        # 不是父节点就继续增加
        if node.parent is not None:
            return self.backward(node.parent, num, value)

@staticmethod
    def calc_UCB(node: Node, all_num: int, color: evaluate.Color) -> float:
        value: float = node.value
        n: int = node.times

        # 没访问过 ucb值是无穷大
        if n == 0 or all_num == 0:
            return float('inf')

        # 如果是复数则只保留实数部分
        if color == evaluate.Color.WHITE:
            res = value / n + cmath.sqrt(math.log(all_num) / n)
        else:
            res = value / n - cmath.sqrt(math.log(all_num) / n)
        return res.real

# 蒙特卡洛树搜索 分析
    def mct_search_analyze(self, fen: str):
        # 先创建初始局面
        root_board = chess.Board(fen)
        board = self.chess_util.parse_board(root_board)
        # 判断一进来就是棋局结束的特殊情况
        check = self.chess_util.check_board_status(root_board)
        if check['end'] is True:
            return None

        # 根节点
        root_node = Node(fen, None, None)
        color = self.chess_util.get_current_color_by_fen(fen)

        # 开始蒙特卡洛树搜索
        # 这里必须顺序执行 不能多线程! 也不一定
        for i in range(self.move):
            print("模拟[{}]次".format(i + 1))

            # 选择 如果已经到棋局尾声就跳出
            invalid = self.select(root_node, i, color)
            if invalid is True:
                print("已经全部模拟 跳出")
                break
        return self.get_best(root_node)