物价局计算.py

# -*- mode: python ; coding: utf-8 -*-
import json
import numpy
import re
import requests
import time
from bs4 import BeautifulSoup


def 材料定价计算(输入, 精英材料编号列表, 精英材料名列表, 精英材料图片列表, 其他物品信息列表):
    龙门币价值 = 输入[0]
    EXP价值 = 输入[1]
    赤金价值 = 输入[2]
    合成玉价值 = 输入[3]
    价值 = 输入[4]
    精英材料副产品产出概率 = 输入[5]
    技巧概要副产品产出概率 = 输入[6]
    基建材料副产品产出概率 = 输入[7]
    基备选集合 = 输入[8]
    换算活动代币 = 输入[9]
    固源岩单独定价 = 输入[10]
    装置单独定价 = 输入[11]
    瑕光加工T5精英材料 = 输入[12]
    瑕光加工T4精英材料 = 输入[13]
    瑕光加工T3精英材料 = 输入[14]
    瑕光加工T2精英材料 = 输入[15]
    九色鹿加工T3精英材料 = 输入[16]
    九色鹿加工T2精英材料 = 输入[17]
    九色鹿加工技巧概要 = 输入[18]
    九色鹿加工基建材料 = 输入[19]

    游戏基建数据 = json.load(open('游戏基建数据.json'))
    游戏物品数据 = json.load(open('游戏物品数据.json'))
    游戏关卡数据 = json.load(open('游戏关卡数据.json'))
    采购价格数据 = json.load(open('采购价格.json', encoding="utf-8"))
    企鹅物流自动掉落数据 = json.load(open('企鹅物流自动掉落数据.json'))
    活动名称 = "当前无活动"
    商店表格 = None
    try:
        PRTS首页 = "https://prts.wiki/w/首页"
        B = BeautifulSoup(requests.get(PRTS首页).text, "html.parser").find_all("b")
        for b in B:
            if "「" in b.text and "生息演算" not in b.text:
                活动名称 = re.findall(r'\「(.*?)\」', b.text)[0]
                break
        PRTS活动网址 = "https://prts.wiki/w/" + 活动名称

        # 找到含有指定字符串的表格
        全部表格 = BeautifulSoup(requests.get(PRTS活动网址).text, "html.parser").find_all("table")
        for 表格 in 全部表格:
            if "可兑换道具" in 表格.text:
                商店表格 = 表格
                break
    except: pass

    # 按照配方构筑加工矩阵
    # 加工T5获得T5精英材料矩阵 = numpy.eye(len(精英材料编号列表[4]))
    加工T5获得T4精英材料矩阵 = numpy.zeros((len(精英材料编号列表[3]), len(精英材料编号列表[4])))
    # 加工T5获得T3精英材料矩阵 = numpy.zeros((len(精英材料编号列表[2]), len(精英材料编号列表[4])))
    # 加工T5获得T2精英材料矩阵 = numpy.zeros((len(精英材料编号列表[1]), len(精英材料编号列表[4])))
    # 加工T5获得T1精英材料矩阵 = numpy.zeros((len(精英材料编号列表[0]), len(精英材料编号列表[4])))
    # 加工T4获得T5精英材料矩阵 = numpy.zeros((len(精英材料编号列表[4]), len(精英材料编号列表[3])))
    # 加工T4获得T4精英材料矩阵 = numpy.eye(len(精英材料编号列表[3]))
    加工T4获得T3精英材料矩阵 = numpy.zeros((len(精英材料编号列表[2]), len(精英材料编号列表[3])))
    # 加工T4获得T2精英材料矩阵 = numpy.zeros((len(精英材料编号列表[1]), len(精英材料编号列表[3])))
    # 加工T4获得T1精英材料矩阵 = numpy.zeros((len(精英材料编号列表[0]), len(精英材料编号列表[3])))
    # 加工T3获得T5精英材料矩阵 = numpy.zeros((len(精英材料编号列表[4]), len(精英材料编号列表[1])))
    # 加工T3获得T4精英材料矩阵 = numpy.zeros((len(精英材料编号列表[3]), len(精英材料编号列表[1])))
    加工T3获得T3精英材料矩阵 = numpy.vstack((numpy.eye(len(精英材料编号列表[1])), numpy.zeros((len(精英材料编号列表[2]) - len(精英材料编号列表[1]), len(精英材料编号列表[1])))))
    加工T3获得T2精英材料矩阵 = numpy.zeros((len(精英材料编号列表[1]), len(精英材料编号列表[1])))
    # 加工T3获得T1精英材料矩阵 = numpy.zeros((len(精英材料编号列表[0]), len(精英材料编号列表[1])))
    # 加工T2获得T5精英材料矩阵 = numpy.zeros((len(精英材料编号列表[4]), len(精英材料编号列表[1])))
    # 加工T2获得T4精英材料矩阵 = numpy.zeros((len(精英材料编号列表[3]), len(精英材料编号列表[1])))
    加工T2获得T3精英材料矩阵 = numpy.zeros((len(精英材料编号列表[2]), len(精英材料编号列表[1])))
    加工T2获得T2精英材料矩阵 = numpy.eye(len(精英材料编号列表[1]))
    加工T2获得T1精英材料矩阵 = numpy.zeros((len(精英材料编号列表[0]), len(精英材料编号列表[1])))

    for 配方 in 游戏基建数据['workshopFormulas']:
        if 游戏基建数据['workshopFormulas'][配方]['formulaType'] == 'F_EVOLVE':
            if 游戏基建数据['workshopFormulas'][配方]['itemId'] in 精英材料编号列表[4]:
                for 材料 in 游戏基建数据['workshopFormulas'][配方]['costs']:
                    加工T5获得T4精英材料矩阵[精英材料编号列表[3].index(材料['id']), 精英材料编号列表[4].index(游戏基建数据['workshopFormulas'][配方]['itemId'])] -= 材料['count']
            elif 游戏基建数据['workshopFormulas'][配方]['itemId'] in 精英材料编号列表[3]:
                for 材料 in 游戏基建数据['workshopFormulas'][配方]['costs']:
                    加工T4获得T3精英材料矩阵[精英材料编号列表[2].index(材料['id']), 精英材料编号列表[3].index(游戏基建数据['workshopFormulas'][配方]['itemId'])] -= 材料['count']
            elif 游戏基建数据['workshopFormulas'][配方]['itemId'] in 精英材料编号列表[2]:
                for 材料 in 游戏基建数据['workshopFormulas'][配方]['costs']:
                    加工T3获得T2精英材料矩阵[精英材料编号列表[1].index(材料['id']), 精英材料编号列表[2].index(游戏基建数据['workshopFormulas'][配方]['itemId'])] -= 材料['count']
            elif 游戏基建数据['workshopFormulas'][配方]['itemId'] in 精英材料编号列表[1]:
                for 材料 in 游戏基建数据['workshopFormulas'][配方]['costs']:
                    加工T2获得T1精英材料矩阵[精英材料编号列表[0].index(材料['id']), 精英材料编号列表[1].index(游戏基建数据['workshopFormulas'][配方]['itemId'])] -= 材料['count']

    # 处理副产品
    # 获取副产品权重
    T4精英材料权重 = 精英材料编号列表[3].copy()
    for 副产品 in 游戏基建数据['workshopFormulas'][游戏物品数据['items'][精英材料编号列表[4][0]]['buildingProductList'][0]['formulaId']]['extraOutcomeGroup']:
        for 序号, 权重 in enumerate(T4精英材料权重):
            if 权重 == 副产品['itemId']:
                T4精英材料权重[序号] = 副产品['weight']
                break
    T4精英材料总权重 = numpy.sum(T4精英材料权重)
    T3精英材料权重 = 精英材料编号列表[2].copy()
    for 副产品 in 游戏基建数据['workshopFormulas'][游戏物品数据['items'][精英材料编号列表[3][0]]['buildingProductList'][0]['formulaId']]['extraOutcomeGroup']:
        for 序号, 权重 in enumerate(T3精英材料权重):
            if 权重 == 副产品['itemId']:
                T3精英材料权重[序号] = 副产品['weight']
                break
    T3精英材料总权重 = numpy.sum(T3精英材料权重)
    T2精英材料权重 = 精英材料编号列表[1].copy()
    for 副产品 in 游戏基建数据['workshopFormulas'][游戏物品数据['items'][精英材料编号列表[2][0]]['buildingProductList'][0]['formulaId']]['extraOutcomeGroup']:
        for 序号, 权重 in enumerate(T2精英材料权重):
            if 权重 == 副产品['itemId']:
                T2精英材料权重[序号] = 副产品['weight']
                break
    T2精英材料总权重 = numpy.sum(T2精英材料权重)
    T1精英材料权重 = 精英材料编号列表[0].copy()
    for 副产品 in 游戏基建数据['workshopFormulas'][游戏物品数据['items'][精英材料编号列表[1][0]]['buildingProductList'][0]['formulaId']]['extraOutcomeGroup']:
        for 序号, 权重 in enumerate(T1精英材料权重):
            if 权重 == 副产品['itemId']:
                T1精英材料权重[序号] = 副产品['weight']
                break
    T1精英材料总权重 = numpy.sum(T1精英材料权重)

    # 将副产品计算进加工矩阵中
    for 配方序号 in range(len(精英材料编号列表[4])):
        for 副产品序号 in range(len(精英材料编号列表[3])):
            加工T5获得T4精英材料矩阵[副产品序号, 配方序号] += T4精英材料权重[副产品序号] / T4精英材料总权重 * 精英材料副产品产出概率[0]
    for 配方序号 in range(len(精英材料编号列表[3])):
        for 副产品序号 in range(len(精英材料编号列表[2])):
            加工T4获得T3精英材料矩阵[副产品序号, 配方序号] += T3精英材料权重[副产品序号] / T3精英材料总权重 * 精英材料副产品产出概率[1]
    for 配方序号 in range(len(精英材料编号列表[1])):
        for 副产品序号 in range(len(精英材料编号列表[1])):
            加工T3获得T2精英材料矩阵[副产品序号, 配方序号] += T2精英材料权重[副产品序号] / T2精英材料总权重 * 精英材料副产品产出概率[2]
        if 九色鹿加工T3精英材料:
            for 副产品序号 in range(len(精英材料编号列表[2])):
                加工T3获得T3精英材料矩阵[副产品序号, 配方序号] += T3精英材料权重[副产品序号] / T3精英材料总权重 * (1 - 精英材料副产品产出概率[2]) * 2 / 81
    for 配方序号 in range(len(精英材料编号列表[0])):
        for 副产品序号 in range(len(精英材料编号列表[0])):
            加工T2获得T1精英材料矩阵[副产品序号, 配方序号] += T1精英材料权重[副产品序号] / T1精英材料总权重 * 精英材料副产品产出概率[3]
        if 九色鹿加工T2精英材料:
            for 副产品序号 in range(len(精英材料编号列表[2])):
                加工T2获得T3精英材料矩阵[副产品序号, 配方序号] += T3精英材料权重[副产品序号] / T3精英材料总权重 * (1 - 精英材料副产品产出概率[3]) * 2 / 81

    # 加工T5精英材料矩阵 = numpy.vstack((加工T5获得T5精英材料矩阵, 加工T5获得T4精英材料矩阵, 加工T5获得T3精英材料矩阵, 加工T5获得T2精英材料矩阵, 加工T5获得T1精英材料矩阵))
    # 加工T4精英材料矩阵 = numpy.vstack((加工T4获得T5精英材料矩阵, 加工T4获得T4精英材料矩阵, 加工T4获得T3精英材料矩阵, 加工T4获得T2精英材料矩阵, 加工T4获得T1精英材料矩阵))
    # 加工T3精英材料矩阵 = numpy.vstack((加工T3获得T5精英材料矩阵, 加工T3获得T4精英材料矩阵, 加工T3获得T3精英材料矩阵, 加工T3获得T2精英材料矩阵, 加工T3获得T1精英材料矩阵))
    # 加工T2精英材料矩阵 = numpy.vstack((加工T2获得T5精英材料矩阵, 加工T2获得T4精英材料矩阵, 加工T2获得T3精英材料矩阵, 加工T2获得T2精英材料矩阵, 加工T2获得T1精英材料矩阵))
    # 总加工矩阵 = numpy.hstack((加工T5精英材料矩阵, 加工T4精英材料矩阵, 加工T3精英材料矩阵, 加工T2精英材料矩阵))

    # 从解包文件中获取关卡信息
    主线关卡信息列表 = [[], [], []]
    插曲别传关卡信息列表 = [[], [], []]
    技巧概要关卡信息列表 = [[], [], [], [], [], []]
    Sidestory关卡信息列表 = [[], [], []]
    故事集关卡信息列表 = [[], [], []]
    当前活动关卡信息列表 = [[], [], []]

    for 关卡 in 游戏关卡数据['stages']:
        if 游戏关卡数据['stages'][关卡]['difficulty'] == 'NORMAL':  # 不考虑突袭
            if (游戏关卡数据['stages'][关卡]['stageType'] == 'MAIN' and not 游戏关卡数据['stages'][关卡]['isStoryOnly']
                    and not 游戏关卡数据['stages'][关卡]['apCost'] == 0 and not 游戏关卡数据['stages'][关卡]['zoneId'] == 'main_14'):
                主线关卡信息列表[0].append(关卡)
                主线关卡信息列表[1].append(游戏关卡数据['stages'][关卡]['apCost'])
                # 主线关卡信息列表[2].append(游戏关卡数据['stages'][关卡]['goldGain'] * 1.2)
                折算产出龙门币 = 游戏关卡数据['stages'][关卡]['goldGain'] * 1.2
                if 换算活动代币: 折算产出龙门币 += 游戏关卡数据['stages'][关卡]['apCost'] * 10
                主线关卡信息列表[2].append(折算产出龙门币)
            if 游戏关卡数据['stages'][关卡]['zoneId'] == 'weekly_6':
                技巧概要关卡信息列表[0].append(关卡)
                技巧概要关卡信息列表[1].append(游戏关卡数据['stages'][关卡]['apCost'])
                # 技巧概要关卡信息列表[2].append(游戏关卡数据['stages'][关卡]['goldGain'] * 1.2)
                折算产出龙门币 = 游戏关卡数据['stages'][关卡]['goldGain'] * 1.2
                if 换算活动代币: 折算产出龙门币 += 游戏关卡数据['stages'][关卡]['apCost'] * 10
                技巧概要关卡信息列表[2].append(折算产出龙门币)
                技巧概要关卡信息列表[3].append(0)
                技巧概要关卡信息列表[4].append(0)
                技巧概要关卡信息列表[5].append(0)
            elif 游戏关卡数据['stages'][关卡]['stageType'] == 'ACTIVITY':
                if 游戏关卡数据['stages'][关卡]['zoneId'] in ['act10d5_zone1', 'act13d0_zone1', 'act10d5_zone1']\
                        or 游戏关卡数据['stages'][关卡]['zoneId'][-10:] == 'mini_zone1':
                    故事集关卡信息列表[0].append(关卡)
                    故事集关卡信息列表[1].append(游戏关卡数据['stages'][关卡]['apCost'])
                    折算产出龙门币 = 游戏关卡数据['stages'][关卡]['goldGain'] * 1.2
                    if 换算活动代币: 折算产出龙门币 += 游戏关卡数据['stages'][关卡]['apCost'] * 10
                    故事集关卡信息列表[2].append(折算产出龙门币)
                    if 游戏关卡数据['stageValidInfo'][关卡]['startTs'] < time.time() < 游戏关卡数据['stageValidInfo'][关卡]['endTs']:
                        当前活动关卡信息列表[0].append(关卡)
                        当前活动关卡信息列表[1].append(游戏关卡数据['stages'][关卡]['apCost'])
                        折算产出龙门币 = 游戏关卡数据['stages'][关卡]['goldGain'] * 1.2
                        if 换算活动代币: 折算产出龙门币 += 游戏关卡数据['stages'][关卡]['apCost'] * 10
                        当前活动关卡信息列表[2].append(折算产出龙门币)
                elif 游戏关卡数据['stages'][关卡]['zoneId'].endswith('_zone1') and not 游戏关卡数据['stages'][关卡]['apCost'] == 0:
                    Sidestory关卡信息列表[0].append(关卡)
                    Sidestory关卡信息列表[1].append(游戏关卡数据['stages'][关卡]['apCost'])
                    折算产出龙门币 = 游戏关卡数据['stages'][关卡]['goldGain'] * 1.2
                    if 换算活动代币: 折算产出龙门币 += 游戏关卡数据['stages'][关卡]['apCost'] * 20
                    Sidestory关卡信息列表[2].append(折算产出龙门币)
                    插曲别传关卡信息列表[0].append(关卡 + '_perm')
                    插曲别传关卡信息列表[1].append(游戏关卡数据['stages'][关卡]['apCost'])
                    插曲别传关卡信息列表[2].append(游戏关卡数据['stages'][关卡]['goldGain'] * 1.2)
                    if 游戏关卡数据['stages'][关卡]['zoneId'].endswith('sre_zone1'):
                        Sidestory关卡信息列表[0].append(关卡 + '_rep')
                        Sidestory关卡信息列表[1].append(游戏关卡数据['stages'][关卡]['apCost'])
                        折算产出龙门币 = 游戏关卡数据['stages'][关卡]['goldGain'] * 1.2
                        if 换算活动代币: 折算产出龙门币 += 游戏关卡数据['stages'][关卡]['apCost'] * 20
                        Sidestory关卡信息列表[2].append(折算产出龙门币)
                    if 游戏关卡数据['stageValidInfo'][关卡]['startTs'] < time.time() < 游戏关卡数据['stageValidInfo'][关卡]['endTs']:
                        当前活动关卡信息列表[0].append(关卡)
                        当前活动关卡信息列表[1].append(游戏关卡数据['stages'][关卡]['apCost'])
                        折算产出龙门币 = 游戏关卡数据['stages'][关卡]['goldGain'] * 1.2
                        if 换算活动代币: 折算产出龙门币 += 游戏关卡数据['stages'][关卡]['apCost'] * 20
                        当前活动关卡信息列表[2].append(折算产出龙门币)

    关卡列表 = 技巧概要关卡信息列表[0] + 主线关卡信息列表[0] + 插曲别传关卡信息列表[0]
    关卡折算理智消耗列表 = 技巧概要关卡信息列表[1] + 主线关卡信息列表[1] + 插曲别传关卡信息列表[1]
    关卡折算产出龙门币列表 = 技巧概要关卡信息列表[2] + 主线关卡信息列表[2] + 插曲别传关卡信息列表[2]
    if 基备选集合 == '当前开放关卡':
        关卡列表 += 当前活动关卡信息列表[0]
        关卡折算理智消耗列表 += 当前活动关卡信息列表[1]
        关卡折算产出龙门币列表 += 当前活动关卡信息列表[2]
    elif 基备选集合 == '全部历史关卡':
        关卡列表 += Sidestory关卡信息列表[0] + 故事集关卡信息列表[0]
        关卡折算理智消耗列表 += Sidestory关卡信息列表[1] + 故事集关卡信息列表[1]
        关卡折算产出龙门币列表 += Sidestory关卡信息列表[2] + 故事集关卡信息列表[2]

    # 从企鹅物流中获取关卡产物数据
    关卡样本容量列表 = [0] * len(关卡列表)
    关卡掉落EXP列表 = [0] * len(关卡列表)
    关卡掉落赤金列表 = [0] * len(关卡列表)
    关卡T4精英材料矩阵 = numpy.zeros((len(精英材料编号列表[3]), len(关卡列表)))
    关卡T3精英材料矩阵 = numpy.zeros((len(精英材料编号列表[2]), len(关卡列表)))
    关卡T2精英材料矩阵 = numpy.zeros((len(精英材料编号列表[1]), len(关卡列表)))
    关卡T1精英材料矩阵 = numpy.zeros((len(精英材料编号列表[0]), len(关卡列表)))
    for 产物数据 in 企鹅物流自动掉落数据['matrix']:
        if 产物数据['stageId'] in 关卡列表:
            if 产物数据['times'] > 关卡样本容量列表[关卡列表.index(产物数据['stageId'])]:
                关卡样本容量列表[关卡列表.index(产物数据['stageId'])] = 产物数据['times']
            if 产物数据['itemId'] == '3003':
                关卡掉落赤金列表[关卡列表.index(产物数据['stageId'])] = 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['itemId'] == '2001':
                关卡掉落EXP列表[关卡列表.index(产物数据['stageId'])] = 200 * 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['itemId'] == '2002':
                关卡掉落EXP列表[关卡列表.index(产物数据['stageId'])] = 400 * 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['itemId'] == '2003':
                关卡掉落EXP列表[关卡列表.index(产物数据['stageId'])] = 1000 * 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['itemId'] == '2004':
                关卡掉落EXP列表[关卡列表.index(产物数据['stageId'])] = 2000 * 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['itemId'] in 精英材料编号列表[3]:
                关卡T4精英材料矩阵[精英材料编号列表[3].index(产物数据['itemId']), 关卡列表.index(产物数据['stageId'])] = 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['itemId'] in 精英材料编号列表[2]:
                关卡T3精英材料矩阵[精英材料编号列表[2].index(产物数据['itemId']), 关卡列表.index(产物数据['stageId'])] = 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['itemId'] in 精英材料编号列表[1]:
                关卡T2精英材料矩阵[精英材料编号列表[1].index(产物数据['itemId']), 关卡列表.index(产物数据['stageId'])] = 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['itemId'] in 精英材料编号列表[0]:
                关卡T1精英材料矩阵[精英材料编号列表[0].index(产物数据['itemId']), 关卡列表.index(产物数据['stageId'])] = 产物数据['quantity'] / 产物数据['times']
            elif 产物数据['stageId'] in 技巧概要关卡信息列表[0]:
                if 产物数据['itemId'] == '3301':
                    技巧概要关卡信息列表[3][技巧概要关卡信息列表[0].index(产物数据['stageId'])] = 产物数据['quantity'] / 产物数据['times']
                elif 产物数据['itemId'] == '3302':
                    技巧概要关卡信息列表[4][技巧概要关卡信息列表[0].index(产物数据['stageId'])] = 产物数据['quantity'] / 产物数据['times']
                elif 产物数据['itemId'] == '3303':
                    技巧概要关卡信息列表[5][技巧概要关卡信息列表[0].index(产物数据['stageId'])] = 产物数据['quantity'] / 产物数据['times']

    # 落叶逐火关卡修正
    # if 基备选集合 == '全部历史关卡':
    #     关卡样本容量列表[关卡列表.index('act24side_01')] = 17706
    #     关卡折算产出龙门币列表[关卡列表.index('act24side_01')] += (71003 * 2 + 35609 * 3 + 10566 * 5 + 1744 * 10) / 40 * 7923 / 20044 * 2000 / 17706
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30033'), 关卡列表.index('act24side_01')] = (71003 * 2 + 35609 * 3 + 10566 * 5 + 1744 * 10) / 40 * 3650 / 20044 / 17706
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30063'), 关卡列表.index('act24side_01')] = (71003 * 2 + 35609 * 3 + 10566 * 5 + 1744 * 10) / 40 * 4050 / 20044 / 17706
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('31063'), 关卡列表.index('act24side_01')] = (71003 * 2 + 35609 * 3 + 10566 * 5 + 1744 * 10) / 40 * 4421 / 20044 / 17706
    #     关卡样本容量列表[关卡列表.index('act24side_02')] = 8534
    #     关卡折算产出龙门币列表[关卡列表.index('act24side_02')] += (34275 * 2 + 16893 * 3 + 5242 * 5 + 841 * 10) / 40 * 7923 / 20044 * 2000 / 8534
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30033'), 关卡列表.index('act24side_02')] = (34275 * 2 + 16893 * 3 + 5242 * 5 + 841 * 10) / 40 * 3650 / 20044 / 8534
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30063'), 关卡列表.index('act24side_02')] = (34275 * 2 + 16893 * 3 + 5242 * 5 + 841 * 10) / 40 * 4050 / 20044 / 8534
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('31063'), 关卡列表.index('act24side_02')] = (34275 * 2 + 16893 * 3 + 5242 * 5 + 841 * 10) / 40 * 4421 / 20044 / 8534
    #     关卡样本容量列表[关卡列表.index('act24side_03')] = 15897
    #     关卡折算产出龙门币列表[关卡列表.index('act24side_03')] += (63658 * 2 + 31941 * 3 + 9510 * 5 + 1550 * 10) / 40 * 7923 / 20044 * 2000 / 15897
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30033'), 关卡列表.index('act24side_03')] = (63658 * 2 + 31941 * 3 + 9510 * 5 + 1550 * 10) / 40 * 3650 / 20044 / 15897
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30063'), 关卡列表.index('act24side_03')] = (63658 * 2 + 31941 * 3 + 9510 * 5 + 1550 * 10) / 40 * 4050 / 20044 / 15897
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('31063'), 关卡列表.index('act24side_03')] = (63658 * 2 + 31941 * 3 + 9510 * 5 + 1550 * 10) / 40 * 4421 / 20044 / 15897
    #     关卡样本容量列表[关卡列表.index('act24side_04')] = 32213
    #     关卡折算产出龙门币列表[关卡列表.index('act24side_04')] += (100107 * 2 + 51202 * 3 + 25958 * 5 + 41883 * 10 + 3171 * 20) / 40 * 7923 / 20044 * 2000 / 32213
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30033'), 关卡列表.index('act24side_04')] = (100107 * 2 + 51202 * 3 + 25958 * 5 + 41883 * 10 + 3171 * 20) / 40 * 3650 / 20044 / 32213
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30063'), 关卡列表.index('act24side_04')] = (100107 * 2 + 51202 * 3 + 25958 * 5 + 41883 * 10 + 3171 * 20) / 40 * 4050 / 20044 / 32213
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('31063'), 关卡列表.index('act24side_04')] = (100107 * 2 + 51202 * 3 + 25958 * 5 + 41883 * 10 + 3171 * 20) / 40 * 4421 / 20044 / 32213
    #     关卡样本容量列表[关卡列表.index('act24side_05')] = 28133
    #     关卡折算产出龙门币列表[关卡列表.index('act24side_05')] += (86773 * 2 + 45181 * 3 + 22518 * 5 + 36634 * 10 + 2803 * 20) / 40 * 7923 / 20044 * 2000 / 28133
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30033'), 关卡列表.index('act24side_05')] = (86773 * 2 + 45181 * 3 + 22518 * 5 + 36634 * 10 + 2803 * 20) / 40 * 3650 / 20044 / 28133
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30063'), 关卡列表.index('act24side_05')] = (86773 * 2 + 45181 * 3 + 22518 * 5 + 36634 * 10 + 2803 * 20) / 40 * 4050 / 20044 / 28133
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('31063'), 关卡列表.index('act24side_05')] = (86773 * 2 + 45181 * 3 + 22518 * 5 + 36634 * 10 + 2803 * 20) / 40 * 4421 / 20044 / 28133
    #     关卡样本容量列表[关卡列表.index('act24side_06')] = 163809
    #     关卡折算产出龙门币列表[关卡列表.index('act24side_06')] += (261364 * 2 + 507782 * 3 + 212700 * 5 + 81932 * 10 + 147480 * 20) / 40 * 7923 / 20044 * 2000 / 163809
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30033'), 关卡列表.index('act24side_06')] = (261364 * 2 + 507782 * 3 + 212700 * 5 + 81932 * 10 + 147480 * 20) / 40 * 3650 / 20044 / 163809
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30063'), 关卡列表.index('act24side_06')] = (261364 * 2 + 507782 * 3 + 212700 * 5 + 81932 * 10 + 147480 * 20) / 40 * 4050 / 20044 / 163809
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('31063'), 关卡列表.index('act24side_06')] = (261364 * 2 + 507782 * 3 + 212700 * 5 + 81932 * 10 + 147480 * 20) / 40 * 4421 / 20044 / 163809
    #     关卡样本容量列表[关卡列表.index('act24side_07')] = 355145
    #     关卡折算产出龙门币列表[关卡列表.index('act24side_07')] += (565410 * 2 + 1102374 * 3 + 461599 * 5 + 176884 * 10 + 319914 * 20) / 40 * 7923 / 20044 * 2000 / 355145
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30033'), 关卡列表.index('act24side_07')] = (565410 * 2 + 1102374 * 3 + 461599 * 5 + 176884 * 10 + 319914 * 20) / 40 * 3650 / 20044 / 355145
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30063'), 关卡列表.index('act24side_07')] = (565410 * 2 + 1102374 * 3 + 461599 * 5 + 176884 * 10 + 319914 * 20) / 40 * 4050 / 20044 / 355145
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('31063'), 关卡列表.index('act24side_07')] = (565410 * 2 + 1102374 * 3 + 461599 * 5 + 176884 * 10 + 319914 * 20) / 40 * 4421 / 20044 / 355145
    #     关卡样本容量列表[关卡列表.index('act24side_08')] = 4375478
    #     关卡折算产出龙门币列表[关卡列表.index('act24side_08')] += (6983549 * 2 + 13566401 * 3 + 5683864 * 5 + 2187946 * 10 + 3937498 * 20) / 40 * 7923 / 20044 * 2000 / 4375478
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30033'), 关卡列表.index('act24side_08')] = (6983549 * 2 + 13566401 * 3 + 5683864 * 5 + 2187946 * 10 + 3937498 * 20) / 40 * 3650 / 20044 / 4375478
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('30063'), 关卡列表.index('act24side_08')] = (6983549 * 2 + 13566401 * 3 + 5683864 * 5 + 2187946 * 10 + 3937498 * 20) / 40 * 4050 / 20044 / 4375478
    #     关卡T3精英材料矩阵[精英材料编号列表[2].index('31063'), 关卡列表.index('act24side_08')] = (6983549 * 2 + 13566401 * 3 + 5683864 * 5 + 2187946 * 10 + 3937498 * 20) / 40 * 4421 / 20044 / 4375478

    # 生成降维矩阵
    定价材料列表 = 精英材料编号列表[2]
    单独定价材料序号列表 = []
    if 装置单独定价: 单独定价材料序号列表.append(精英材料名列表[1].index('装置'))
    if 固源岩单独定价: 单独定价材料序号列表.append(精英材料名列表[1].index('固源岩'))
    矩阵甲 = -加工T4获得T3精英材料矩阵
    矩阵戊 = 加工T2获得T3精英材料矩阵
    for 序号, 行列号 in enumerate(单独定价材料序号列表):
        定价材料列表.append(精英材料编号列表[1][行列号])
        矩阵甲 = numpy.vstack((矩阵甲, numpy.zeros((1, len(精英材料编号列表[3])))))
        矩阵戊 = numpy.vstack((矩阵戊, 加工T2获得T2精英材料矩阵[行列号]))
    矩阵乙 = numpy.eye(len(定价材料列表))
    矩阵丙 = numpy.delete(加工T3获得T3精英材料矩阵, 单独定价材料序号列表, axis=1)
    矩阵丁 = numpy.delete(加工T3获得T2精英材料矩阵, 单独定价材料序号列表, axis=1)
    矩阵己 = numpy.delete(加工T2获得T2精英材料矩阵, 单独定价材料序号列表, axis=0)
    for 序号, 行列号 in enumerate(单独定价材料序号列表):
        矩阵丙 = numpy.vstack((矩阵丙, 矩阵丁[行列号]))
    矩阵丁 = numpy.delete(矩阵丁, 单独定价材料序号列表, axis=0)
    矩阵庚 = -numpy.dot(矩阵丙, numpy.linalg.inv(矩阵丁))
    计数器 = 0
    for 序号 in range(len(矩阵丁)+len(单独定价材料序号列表)):
        if 序号 in 单独定价材料序号列表:
            矩阵庚 = numpy.insert(矩阵庚, 序号, 矩阵乙[:, 计数器-len(单独定价材料序号列表)], axis=1)
            矩阵乙 = numpy.delete(矩阵乙, 计数器-len(单独定价材料序号列表), axis=1)
            计数器 += 1
    降维矩阵 = numpy.hstack((矩阵甲, 矩阵乙, 矩阵庚, numpy.dot(numpy.dot(numpy.dot(矩阵丙, numpy.linalg.inv(矩阵丁)), 矩阵己) - 矩阵戊, numpy.linalg.inv(加工T2获得T1精英材料矩阵))))

    # 基关卡候选范围过滤
    关卡总数 = len(关卡列表)
    for 序号 in range(关卡总数):
        if 关卡样本容量列表[关卡总数-序号-1] < 300:   # 删除样本容量过少的关卡
            del 关卡列表[关卡总数-序号-1]
            del 关卡样本容量列表[关卡总数-序号-1]
            del 关卡折算理智消耗列表[关卡总数-序号-1]
            del 关卡折算产出龙门币列表[关卡总数-序号-1]
            del 关卡掉落EXP列表[关卡总数-序号-1]
            del 关卡掉落赤金列表[关卡总数-序号-1]
            关卡T4精英材料矩阵 = numpy.delete(关卡T4精英材料矩阵, 关卡总数-序号-1, axis=1)
            关卡T3精英材料矩阵 = numpy.delete(关卡T3精英材料矩阵, 关卡总数-序号-1, axis=1)
            关卡T2精英材料矩阵 = numpy.delete(关卡T2精英材料矩阵, 关卡总数-序号-1, axis=1)
            关卡T1精英材料矩阵 = numpy.delete(关卡T1精英材料矩阵, 关卡总数-序号-1, axis=1)
        else:
            # 考虑加工消耗的龙门币
            if not 瑕光加工T4精英材料:
                关卡折算产出龙门币列表[关卡总数-序号-1] += sum(关卡T4精英材料矩阵.T[关卡总数-序号-1]) * 300
            if not 瑕光加工T3精英材料:
                该关卡掉落T2精英材料数量列表 = numpy.dot(numpy.linalg.inv(加工T3获得T2精英材料矩阵), 关卡T2精英材料矩阵[:, 关卡总数-序号-1])
                关卡折算产出龙门币列表[关卡总数-序号-1] += sum(该关卡掉落T2精英材料数量列表) * 200
                for 单独序号, 行列号 in enumerate(单独定价材料序号列表):
                    关卡折算产出龙门币列表[关卡总数-序号-1] -= 该关卡掉落T2精英材料数量列表[行列号] * 200
            if not 瑕光加工T2精英材料:
                该关卡掉落T1折算T2精英材料数量列表 = numpy.dot(numpy.linalg.inv(numpy.dot(加工T2获得T1精英材料矩阵, 加工T3获得T2精英材料矩阵)), 关卡T1精英材料矩阵[:, 关卡总数-序号-1])
                关卡折算产出龙门币列表[关卡总数-序号-1] += sum(numpy.dot(numpy.linalg.inv(加工T2获得T1精英材料矩阵), 关卡T1精英材料矩阵[:, 关卡总数-序号-1])) * 100
                if not 瑕光加工T3精英材料:
                    关卡折算产出龙门币列表[关卡总数 - 序号 - 1] -= sum(该关卡掉落T1折算T2精英材料数量列表) * 200
                    for 单独序号, 行列号 in enumerate(单独定价材料序号列表):
                        关卡折算产出龙门币列表[关卡总数-序号-1] += 该关卡掉落T1折算T2精英材料数量列表[行列号] * 200

            # 在理智中去掉龙门币、EXP和赤金的价值
            关卡折算理智消耗列表[关卡总数-序号-1] -= (关卡折算产出龙门币列表[关卡总数-序号-1] * 龙门币价值
                                             + 关卡掉落EXP列表[关卡总数-序号-1] * EXP价值
                                             + 关卡掉落赤金列表[关卡总数-序号-1] * 赤金价值)

    for 序号 in range(len(技巧概要关卡信息列表[0])):
        技巧概要关卡信息列表[1][序号] -= 技巧概要关卡信息列表[2][序号] * 龙门币价值

    # 对关卡精英化材料矩阵进行降维
    关卡精英材料矩阵 = numpy.vstack((关卡T4精英材料矩阵, 关卡T3精英材料矩阵, 关卡T2精英材料矩阵, 关卡T1精英材料矩阵))
    降维关卡精英材料矩阵 = numpy.dot(降维矩阵, 关卡精英材料矩阵)

    # 建立初始定价矩阵
    定价矩阵 = 0.01 * numpy.eye(len(定价材料列表))
    定价关卡折算理智消耗向量 = numpy.empty(0)
    定价关卡列表 = []
    for 材料序号 in range(len(定价材料列表)):
        关卡序号 = numpy.argmax(降维关卡精英材料矩阵[材料序号])
        定价矩阵[:, 材料序号] = 降维关卡精英材料矩阵[:, 关卡序号]
        定价关卡列表.append(关卡列表[关卡序号])
        定价关卡折算理智消耗向量 = numpy.append(定价关卡折算理智消耗向量, 关卡折算理智消耗列表[关卡序号])

    # 迭代定价关卡列表并计算T3精英材料价值
    定价精英材料价值向量 = numpy.dot(定价关卡折算理智消耗向量, numpy.linalg.inv(定价矩阵))
    服从价值判别的关卡数量 = 0
    迭代次数 = 0
    更新定价关卡列表 = []
    新定价关卡 = str()
    while 服从价值判别的关卡数量 < len(关卡列表) and 新定价关卡 not in 更新定价关卡列表 and 迭代次数 < 700:
        服从价值判别的关卡数量 = 0
        for 序号, 关卡 in enumerate(关卡列表):
            if numpy.dot(降维关卡精英材料矩阵[:, 序号], 定价精英材料价值向量) - 关卡折算理智消耗列表[序号] > 1e-6:
                更新定价关卡列表.append(新定价关卡)
                定价矩阵[:, numpy.argmax(降维关卡精英材料矩阵[:, 序号])] = 降维关卡精英材料矩阵[:, 序号]
                定价关卡列表[numpy.argmax(降维关卡精英材料矩阵[:, 序号])] = 关卡
                定价关卡折算理智消耗向量[numpy.argmax(降维关卡精英材料矩阵[:, 序号])] = 关卡折算理智消耗列表[序号]
                定价精英材料价值向量 = numpy.dot(定价关卡折算理智消耗向量, numpy.linalg.inv(定价矩阵))
                新定价关卡 = 关卡
                迭代次数 += 1
                break
            else: 服从价值判别的关卡数量 += 1

    # 确定精英材料价值
    T4精英材料价值向量 = numpy.dot(定价精英材料价值向量, 矩阵甲)
    T5精英材料价值向量 = -numpy.dot(T4精英材料价值向量, 加工T5获得T4精英材料矩阵)
    T3精英材料价值向量 = 定价精英材料价值向量
    T2精英材料价值向量 = -numpy.dot(numpy.dot(定价精英材料价值向量, 矩阵丙), numpy.linalg.inv(矩阵丁))
    for 序号 in enumerate(单独定价材料序号列表):
        T3精英材料价值向量 = numpy.delete(T3精英材料价值向量, -1, axis=0)
    T1精英材料价值向量 = numpy.dot(numpy.dot(定价精英材料价值向量, numpy.dot(numpy.dot(矩阵丙, numpy.linalg.inv(矩阵丁)), 矩阵己) - 矩阵戊), numpy.linalg.inv(加工T2获得T1精英材料矩阵))
    if not 瑕光加工T4精英材料: T4精英材料价值向量 += numpy.ones(len(精英材料编号列表[3])) * 300 * 龙门币价值
    if not 瑕光加工T5精英材料: T5精英材料价值向量 += numpy.ones(len(精英材料编号列表[4])) * 400 * 龙门币价值
    if not 瑕光加工T3精英材料:
        T2精英材料价值向量 += numpy.dot(numpy.ones(len(T2精英材料价值向量)) * 200 * 龙门币价值, numpy.linalg.inv(矩阵丁))
        T1精英材料价值向量 -= 200 * 龙门币价值 * numpy.dot(numpy.dot(numpy.dot(numpy.ones(len(矩阵丁)), numpy.linalg.inv(矩阵丁)), 矩阵己), numpy.linalg.inv(加工T2获得T1精英材料矩阵))
    for 序号 in range(len(T2精英材料价值向量)+len(单独定价材料序号列表)):
        if 序号 in 单独定价材料序号列表:
            T2精英材料价值向量 = numpy.insert(T2精英材料价值向量, 序号, 定价精英材料价值向量[单独定价材料序号列表.index(序号)-len(单独定价材料序号列表)])
    if not 瑕光加工T2精英材料: T1精英材料价值向量 += 100 * 龙门币价值 * numpy.dot(numpy.ones(len(精英材料编号列表[0])), numpy.linalg.inv(加工T2获得T1精英材料矩阵))

    因果价值 = 2 * numpy.dot(T3精英材料价值向量, T3精英材料权重) / T3精英材料总权重 / 81

    if 九色鹿加工技巧概要:
        for 序号 in range(len(技巧概要关卡信息列表[0])):
            技巧概要关卡信息列表[1][序号] -= (1 - 技巧概要副产品产出概率) * (2 * 技巧概要关卡信息列表[4][序号] + (5 + 2 * 技巧概要副产品产出概率) * 技巧概要关卡信息列表[3][序号] / 3) * 因果价值 / 3

    技巧概要卷3价值列表 = []
    for 序号 in range(len(技巧概要关卡信息列表[0])):
        技巧概要卷3价值列表.append(技巧概要关卡信息列表[1][序号] / (技巧概要关卡信息列表[5][序号] + 技巧概要关卡信息列表[4][序号] * (1 + 技巧概要副产品产出概率) / 3 + 技巧概要关卡信息列表[3][序号] * (1 + 技巧概要副产品产出概率) * (1 + 技巧概要副产品产出概率) / 9))

    精英材料价值向量 = [T1精英材料价值向量, T2精英材料价值向量, T3精英材料价值向量, T4精英材料价值向量, T5精英材料价值向量]
    精英材料价值排序表 = []
    for 等级 in range(5):
        精英材料价值排序表.append([{序号: i + 1 for i, 序号 in enumerate(sorted(精英材料价值向量[等级], reverse=True))}[序号] for 序号 in 精英材料价值向量[等级]])  # 性价比排名

    碳素组价值 = 价值[6] * 12 - 龙门币价值 * 200 / (1 - 基建材料副产品产出概率 / 2)
    if 九色鹿加工基建材料: 碳素组价值 += 因果价值 * 4
    碳素组价值 = max(碳素组价值, 0)
    碳素价值1 = 价值[6] * 8 - 龙门币价值 * 200 / (1 - 基建材料副产品产出概率 / 2)
    if 九色鹿加工基建材料: 碳素价值1 += 因果价值 * 2
    碳素价值2 = (1 + 基建材料副产品产出概率) * 碳素组价值 / 3
    if 九色鹿加工基建材料: 碳素价值2 += 因果价值 * (1 - 基建材料副产品产出概率 / 2) * 4 / 3
    # 碳素价值2 = 价值[6] * 12 * 基建材料副产品产出概率 / 3 - 龙门币价值 * 200 * (1 + 基建材料副产品产出概率) / (1 - 基建材料副产品产出概率 / 2) / 3
    # if 九色鹿加工技巧概要: 碳素价值2 += 因果价值 * 8 / 3
    碳素价值 = max(碳素价值1, 碳素价值2, 0)
    碳价值1 = 价值[6] * 4 - 龙门币价值 * 200 / (1 - 基建材料副产品产出概率 / 2)
    if 九色鹿加工基建材料: 碳价值1 += 因果价值
    碳价值2 = (1 + 基建材料副产品产出概率) * 碳素价值 / 3
    if 九色鹿加工基建材料: 碳价值2 += 因果价值 * (1 - 基建材料副产品产出概率 / 2) * 2 / 3
    # 碳价值2 = 价值[6] * 12 * 基建材料副产品产出概率 * 基建材料副产品产出概率 / 9 - 龙门币价值 * 200 * (1 + 基建材料副产品产出概率) * (1 + 基建材料副产品产出概率) / (1 - 基建材料副产品产出概率 / 2) / 9
    # if 九色鹿加工技巧概要: 碳价值2 += 因果价值 * (14 + 2 * 基建材料副产品产出概率) / 9
    碳价值 = max(碳价值1, 碳价值2, 0)

    # 确定其他物品价值
    其他物品信息列表[3][0] = 龙门币价值
    其他物品信息列表[3][1] = EXP价值 * 200
    其他物品信息列表[3][2] = EXP价值 * 400
    其他物品信息列表[3][3] = EXP价值 * 1000
    其他物品信息列表[3][4] = EXP价值 * 2000
    其他物品信息列表[3][5] = 赤金价值
    其他物品信息列表[3][6] = 合成玉价值
    其他物品信息列表[3][7] = 价值[0]
    其他物品信息列表[3][8] = 价值[1]
    其他物品信息列表[3][9] = 价值[2]
    其他物品信息列表[3][12] = numpy.min(技巧概要卷3价值列表)
    其他物品信息列表[3][11] = 其他物品信息列表[3][12] * (1 + 技巧概要副产品产出概率) / 3
    if 九色鹿加工技巧概要: 其他物品信息列表[3][11] += 因果价值 * (1 - 技巧概要副产品产出概率) * 2 / 3
    其他物品信息列表[3][10] = 其他物品信息列表[3][11] * (1 + 技巧概要副产品产出概率) / 3
    if 九色鹿加工技巧概要: 其他物品信息列表[3][10] += 因果价值 * (1 - 技巧概要副产品产出概率) / 3
    其他物品信息列表[3][13] = 碳价值
    其他物品信息列表[3][14] = 碳素价值
    其他物品信息列表[3][17] = 价值[3]
    其他物品信息列表[3][15] = 价值[4]
    其他物品信息列表[3][16] = 价值[5]
    其他物品信息列表[3][18] = 价值[6]

    # 性价比计算
    信用性价比表 = [[], [], [], [], []]
    for 序号, 材料名 in enumerate(精英材料名列表[0]+精英材料名列表[1]+其他物品信息列表[1]):
        if 材料名 in 采购价格数据["信用"].keys():
            信用性价比表[0].append((精英材料图片列表[0]+精英材料图片列表[1]+其他物品信息列表[0])[序号])   # 图片
            信用性价比表[1].append(材料名)   # 材料名
            if 材料名 in 精英材料名列表[0]: 信用性价比表[2].append(0)   # 材料等级
            elif 材料名 in 精英材料名列表[1]: 信用性价比表[2].append(1)
            else: 信用性价比表[2].append(其他物品信息列表[2][序号-len(精英材料图片列表[0]+精英材料图片列表[1])])
            信用性价比表[3].append(numpy.hstack((T1精英材料价值向量, T2精英材料价值向量, 其他物品信息列表[3]))[序号] / eval(采购价格数据["信用"][材料名]) + 序号 * 1e-8)  # 性价比
    信用性价比表[4] = [{序号: i+1 for i, 序号 in enumerate(sorted(信用性价比表[3], reverse=True))}[序号] for 序号 in 信用性价比表[3]]  # 性价比排名

    资质凭证性价比表 = [[[], [], [], [], []], [[], [], [], [], []], [[], [], [], [], []]]
    for 阶段 in range(3):
        for 序号, 材料名 in enumerate(精英材料名列表[2]+其他物品信息列表[1]):
            if 材料名 in 采购价格数据[f"资质凭证阶段{阶段+1}"].keys():
                资质凭证性价比表[阶段][0].append((精英材料图片列表[2]+其他物品信息列表[0])[序号])   # 图片
                资质凭证性价比表[阶段][1].append(材料名)   # 材料名
                if 材料名 in 精英材料名列表[2]: 资质凭证性价比表[阶段][2].append(2)   # 材料等级
                else: 资质凭证性价比表[阶段][2].append(其他物品信息列表[2][序号-len(精英材料名列表[2])])
                资质凭证性价比表[阶段][3].append(numpy.hstack((T3精英材料价值向量, 其他物品信息列表[3]))[序号] / eval(采购价格数据[f"资质凭证阶段{阶段+1}"][材料名]) + 序号 * 1e-8)  # 性价比
        资质凭证性价比表[阶段][4] = [{序号: i+1 for i, 序号 in enumerate(sorted(资质凭证性价比表[阶段][3], reverse=True))}[序号] for 序号 in 资质凭证性价比表[阶段][3]]  # 性价比排名

    高级凭证性价比表 = [[], [], [], [], []]
    for 序号, 材料名 in enumerate(精英材料名列表[3] + 其他物品信息列表[1]):
        if 材料名 in 采购价格数据["高级凭证"].keys():
            高级凭证性价比表[0].append((精英材料图片列表[3]+其他物品信息列表[0])[序号])   # 图片
            高级凭证性价比表[1].append(材料名)   # 材料名
            if 材料名 in 精英材料名列表[3]: 高级凭证性价比表[2].append(3)   # 材料等级
            else: 高级凭证性价比表[2].append(其他物品信息列表[2][序号-len(精英材料名列表[3])])
            高级凭证性价比表[3].append(numpy.hstack((T4精英材料价值向量, 其他物品信息列表[3]))[序号] / eval(采购价格数据["高级凭证"][材料名]) + 序号 * 1e-8)  # 性价比
    高级凭证性价比表[4] = [{序号: i+1 for i, 序号 in enumerate(sorted(高级凭证性价比表[3], reverse=True))}[序号] for 序号 in 高级凭证性价比表[3]]  # 性价比排名

    寻访参数模型性价比表 = [[], [], [], [], []]
    for 序号, 材料名 in enumerate(精英材料名列表[0]+精英材料名列表[1]+精英材料名列表[2]+精英材料名列表[3]):
        if 材料名 in 采购价格数据["寻访参数模型"].keys():
            寻访参数模型性价比表[0].append((精英材料图片列表[0]+精英材料图片列表[1]+精英材料图片列表[2]+精英材料图片列表[3])[序号])   # 图片
            寻访参数模型性价比表[1].append(材料名)   # 材料名
            if 材料名 in 精英材料名列表[0]: 寻访参数模型性价比表[2].append(0)   # 材料等级
            elif 材料名 in 精英材料名列表[1]: 寻访参数模型性价比表[2].append(1)
            elif 材料名 in 精英材料名列表[2]: 寻访参数模型性价比表[2].append(2)
            else: 寻访参数模型性价比表[2].append(3)
            寻访参数模型性价比表[3].append(numpy.hstack((T1精英材料价值向量, T2精英材料价值向量, T3精英材料价值向量, T4精英材料价值向量))[序号] / eval(采购价格数据["寻访参数模型"][材料名]))  # 性价比
    寻访参数模型性价比表[4] = [{序号: i+1 for i, 序号 in enumerate(sorted(寻访参数模型性价比表[3], reverse=True))}[序号] for 序号 in 寻访参数模型性价比表[3]]  # 性价比排名

    情报凭证性价比表 = [[], [], [], [], []]
    for 序号, 材料名 in enumerate(精英材料名列表[3]+其他物品信息列表[1]):
        if 材料名 in 采购价格数据["情报凭证"].keys():
            情报凭证性价比表[0].append((精英材料图片列表[3]+其他物品信息列表[0])[序号])   # 图片
            情报凭证性价比表[1].append(材料名)   # 材料名
            if 材料名 in 精英材料名列表[3]: 情报凭证性价比表[2].append(3)   # 材料等级
            else: 情报凭证性价比表[2].append(其他物品信息列表[2][序号-len(精英材料名列表[3])])
            情报凭证性价比表[3].append(numpy.hstack((T4精英材料价值向量, 其他物品信息列表[3]))[序号] / eval(采购价格数据["情报凭证"][材料名]) + 序号 * 1e-8)  # 性价比
    情报凭证性价比表[4] = [{序号: i+1 for i, 序号 in enumerate(sorted(情报凭证性价比表[3], reverse=True))}[序号] for 序号 in 情报凭证性价比表[3]]  # 性价比排名

    # 如果找到目标表格
    活动商店 = {}
    if 商店表格:
        # 提取表头
        表头 = [header.text.strip() for header in 商店表格.find_all("th")]
        阶段 = ""
        # 提取表格数据
        for 行 in 商店表格.find_all("tr"):
            行数据 = {}
            格数据 = 行.find_all(["th", "td"])
            for i in range(len(表头)):
                行数据[表头[i]] = 格数据[i].text.strip() if i < len(格数据) else ""
            if 行数据:
                if 行数据[""] == "金色阶段":
                    阶段 = "金色阶段"
                    活动商店[阶段] = {}
                elif 行数据[""] == "紫色阶段":
                    阶段 = "紫色阶段"
                    活动商店[阶段] = {}
                elif 行数据[""] == "灰色阶段":
                    阶段 = "灰色阶段"
                    活动商店[阶段] = {}
                可兑换道具分割 = 行数据["可兑换道具"].split("×")
                if 可兑换道具分割[0] in 精英材料名列表[1]+精英材料名列表[2]+精英材料名列表[3]+精英材料名列表[4]+其他物品信息列表[1]:
                    if len(可兑换道具分割) == 1:
                        活动商店[阶段][行数据["可兑换道具"]] = str(行数据["单价"])
                    elif len(可兑换道具分割) == 2:
                        活动商店[阶段][可兑换道具分割[0]] = str(行数据["单价"]) + "/" + 可兑换道具分割[1]
        with open("活动商店数据.json", "w", encoding="utf-8") as jsonfile:
            json.dump(活动商店, jsonfile, ensure_ascii=False, indent=4)

    活动代币性价比表 = []
    for 阶段序号, 活动商店阶段 in enumerate(活动商店.keys()):
        活动代币性价比表.append([[], [], [], [], []])
        for 材料序号, 材料名 in enumerate(精英材料名列表[1]+精英材料名列表[2]+精英材料名列表[3]+精英材料名列表[4]+其他物品信息列表[1]):
            if 材料名 in 活动商店[活动商店阶段].keys():
                活动代币性价比表[阶段序号][0].append((精英材料图片列表[1]+精英材料图片列表[2]+精英材料图片列表[3]+精英材料图片列表[4]+其他物品信息列表[0])[材料序号])   # 图片
                活动代币性价比表[阶段序号][1].append(材料名)   # 材料名
                if 材料名 in 精英材料名列表[1]: 活动代币性价比表[阶段序号][2].append(1)   # 材料等级
                elif 材料名 in 精英材料名列表[2]: 活动代币性价比表[阶段序号][2].append(2)
                elif 材料名 in 精英材料名列表[3]: 活动代币性价比表[阶段序号][2].append(3)
                elif 材料名 in 精英材料名列表[4]: 活动代币性价比表[阶段序号][2].append(4)
                else: 活动代币性价比表[阶段序号][2].append(其他物品信息列表[2][材料序号-len(精英材料图片列表[1]+精英材料图片列表[2]+精英材料图片列表[3]+精英材料图片列表[4])])
                活动代币性价比表[阶段序号][3].append(numpy.hstack((T2精英材料价值向量, T3精英材料价值向量, T4精英材料价值向量, T5精英材料价值向量, 其他物品信息列表[3]))[材料序号] / eval(活动商店[活动商店阶段][材料名]) + 材料序号 * 1e-8)  # 性价比
                活动代币性价比表[阶段序号][4] = [{序号: i+1 for i, 序号 in enumerate(sorted(活动代币性价比表[阶段序号][3], reverse=True))}[序号] for 序号 in 活动代币性价比表[阶段序号][3]]  # 性价比排名

    return 定价关卡列表, 精英材料价值排序表, 精英材料价值向量, 信用性价比表, 资质凭证性价比表, 高级凭证性价比表, 寻访参数模型性价比表, 情报凭证性价比表, 活动代币性价比表