from PublicReference.equipment.equ_list import * from PublicReference.equipment.称号 import * from PublicReference.equipment.宠物 import * from PublicReference.equipment.辟邪玉 import * from PublicReference.equipment.武器融合 import * from PublicReference.equipment.冒险家名望 import * from PublicReference.choise.选项设置 import * from PublicReference.choise.细节选项 import * from PublicReference.common import * from PublicReference.utils.uniqueCode import get_mac_address import operator from PublicReference.utils.common import format_range, to_percent 等级 = 100 class 技能: 名称 = '' 备注 = '' 所在等级 = 0 等级上限 = 0 等级 = 0 基础等级 = 0 等级溢出 = 0 自定义描述 = 0 学习间隔 = 1 等级精通 = 60 基础等级 = 0 关联技能 = ['无'] 关联技能2 = ['无'] 关联技能3 = ['无'] 非关联技能 = ['无'] 非关联技能2 = ['无'] 非关联技能3 = ['无'] 冷却关联技能 = ['无'] 冷却关联技能2 = ['无'] 冷却关联技能3 = ['无'] 非冷却关联技能 = ['无'] 非冷却关联技能2 = ['无'] 非冷却关联技能3 = ['无'] 版本 = 装备版本 def 等级加成(self, x): if self.等级 != 0: if self.等级 + x > self.等级上限: self.等级 = self.等级上限 if self.基础等级 != self.等级上限 and self.关联技能 != ['无']: self.等级溢出 = 1 else: self.等级 += x def 基础等级计算(self): pass class 主动技能(技能): # 只扩展了技能的三条属性，第一条技能hit默认1,2、3条hit默认为0，需要手动赋值 # 如果需要继续扩展，可以在各自职业类内继承后自行扩展，同时需要重写下等效百分比函数 # 固伤在填写基础及成长的时候需要注意，技能面板/独立得到的成长及数值需要*100 基础 = 0.0 成长 = 0.0 攻击次数 = 1.0 基础2 = 0.0 成长2 = 0.0 攻击次数2 = 0.0 基础3 = 0.0 成长3 = 0.0 攻击次数3 = 0.0 CD = 0.0 TP成长 = 0.0 TP上限 = 0 TP等级 = 0 是否主动 = 1 是否有伤害 = 1 恢复 = 1.0 倍率 = 1.0 被动倍率 = 1.0 基础释放次数 = 0 演出时间 = 0 是否有护石 = 0 护石选项 = ['魔界'] def 等效百分比(self, 武器类型): if self.等级 == 0: return 0 else: return int( (self.攻击次数 * (self.基础 + self.成长 * self.等级) + self.攻击次数2 * (self.基础2 + self.成长2 * self.等级) + self.攻击次数3 * (self.基础3 + self.成长3 * self.等级)) * (1 + self.TP成长 * self.TP等级) * self.倍率) def 等效CD(self, 武器类型, 输出类型): return round(self.CD / self.恢复 * 武器冷却惩罚(武器类型, 输出类型, self.版本), 1) def 基础等级计算(self): if self.基础等级 == 0: # 契约等级+5 self.基础等级 = min(int((等级 + 5 - self.所在等级) / self.学习间隔 + 1), self.等级精通) class 被动技能(技能): 是否主动 = 0 是否有伤害 = 0 关联技能 = ['所有'] def 基础等级计算(self): if self.基础等级 == 0: # 契约等级+5 self.基础等级 = min(int((等级 + 5 - self.所在等级) / self.学习间隔 + 1), self.等级精通) 符文效果选项 = [ '无', trans('{攻击}+5%,CD+3%'), 'CD-4%', trans('{攻击}+3%'), trans('{攻击}-3%,CD-6%'), trans('{攻击}+3%,CD+2%'), 'CD-3%', trans('{攻击}+2%'), trans('{攻击}-2%,CD-4%'), trans('{攻击}+2%,CD+1%'), 'CD-2%', trans('{攻击}+1%'), trans('{攻击}-1%,CD-3%'), trans('{攻击}+6%,CD+4%'), 'CD-5%', trans('{攻击}+4%'), trans('{攻击}-4%,CD-7%') ] 刀魂之卡赞数据 = [ 0, 31, 40, 48, 58, 67, 79, 90, 103, 116, 131, 145, 161, 178, 194, 212, 230, 250, 270, 292, 313 ] class 角色属性(属性): # region 属性变量 职业分类 = '输出' 主BUFF = 1.0 系统奶系数 = 0 系统奶基数 = 0 年宠技能 = False 白兔子技能 = False 斗神之吼秘药 = False 称号触发 = False 屏蔽三觉 = False 超卓之心等级 = 1 觉醒之抉择技能 = '' 物理攻击力 = 65 魔法攻击力 = 65 独立攻击力 = 1045 火属性强化 = 13 冰属性强化 = 13 光属性强化 = 13 暗属性强化 = 13 进图物理攻击力 = 0 进图魔法攻击力 = 0 进图独立攻击力 = 0 进图属强 = 0 # 红阵，远古记忆 -1表示没有该技能 远古记忆 = -1 刀魂之卡赞 = -1 百分比力智 = 0.0 百分比三攻 = 0.0 伤害增加 = 0.0 黄字 = 0.0 # 冲突属性 附加伤害 = 0.0 属性附加 = 0.0 暴击伤害 = 0.0 暴伤 = 0.0 # 冲突属性 最终伤害 = 0.0 技能攻击力 = 1.0 技能攻击力累加 = 0.0 # 技能攻击力显示 = 1.0 持续伤害 = 0.0 加算冷却缩减 = 0.0 百分比减防 = 0.0 固定减防 = 0 词条提升率 = [0] * 6 词条选择 = [] # 队友增幅系数 队友增幅系数 = 1.0 防御输入 = 0 火抗输入 = 0 冰抗输入 = 0 光抗输入 = 0 暗抗输入 = 0 攻击速度 = 0.00 移动速度 = 0.00 施放速度 = 0.00 命中率 = 0.0 回避率 = 0.0 物理暴击率 = 0.00 魔法暴击率 = 0.00 自适应选项 = [0] * 2 自适应描述 = ['无'] * 2 时间输入 = 0 次数输入 = [] 宠物次数 = [] 技能切装 = [] 装备切装 = [] 开启切装 = 0 切装修正 = [] 转甲选项 = 0 希洛克武器词条 = 0 武器词条触发 = 0 # 0英雄 1传说 角色熟练度 = 0 # 0 1 2 3 4 5 6 技能栏空位 = 6 # 0数学期望 1黄字+35% 2暴伤+35% 3白字+35% 4终伤+35% 5三攻+35% 命运的抉择 = 0 # 0数学期望 123456 天命无常 = 0 # 0数学期望 1 HP高于70% 2 HP在70~30% 3 HP低于30% 悲剧的残骸 = 0 # 0数学期望 1 5%属性附加 2 10%技能攻击力 3 15%技能攻击力 先知者的预言 = 0 # 0无霸体状态 1 霸体状态 2 无伤状态 贫瘠沙漠的遗产 = 1 # 0数学期望 1 7效果 2 77效果 3 777效果 幸运三角 = 0 # 0过充电状态 1过负荷状态 擎天战甲 = 0 # 0.00~1.00 持续伤害计算比例 = 0 # 0 120+ 1 120-100 2 100-80 3 80-60 4 60-40 5 40- 军神的隐秘遗产 = 0 # 0太极天帝剑：阳 1太极天帝剑：阴 太极天帝剑 = 0 # 0绿色生命的面容：无 1绿色生命的面容：阴暗面 绿色生命的面容 = 1 # 0噙毒手套：中毒 1噙毒手套：未中毒 噙毒手套 = 0 攻击属性 = 0 产物升级 = 0 # 是否为图内状态 状态 = 0 # 是否为输出装备描述 装备描述 = 0 # 辟邪玉属性 附加伤害增加增幅 = 1.0 属性附加伤害增加增幅 = 1.0 技能伤害增加增幅 = 1.0 暴击伤害增加增幅 = 1.0 伤害增加增幅 = 1.0 最终伤害增加增幅 = 1.0 力量智力增加增幅 = 1.0 物理魔法攻击力增加增幅 = 1.0 所有属性强化增加 = 1.0 # 0武器，1首饰，2特殊，3防具 变换词条 = [ # 原词条类型，原词条数值，可洗最小值，可洗最大值，择优不考虑觉醒 [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0] ] 计算自适应 = 1 # 计算自适应方式 = 0 输出提升率 = 0 def getskillinfo(self): return self.技能栏 # endregion # region 词条属性 def 附加伤害加成(self, x, 可变=0, 辟邪玉加成=1): if self.装备描述 == 1: return trans('{附加伤害} +$value
', value=to_percent(x)) else: self.附加伤害 += self.附加伤害增加增幅 * x if 辟邪玉加成 == 1 else x if 可变 > 0: self.变换词条[可变 - 1] = [ 3, round(x * 100), round(x * 100) + (2 if 可变 > 1 else 4), round(x * 100) + (8 if 可变 > 1 else 16) ] return '' def 三攻固定加成(self, x=0, y=0, z=0): if self.装备描述 == 1: return trans('{物攻/魔攻/独立} +$value
', value=x) else: if y == 0 or z == 0: y = x z = x self.物理攻击力 += x self.魔法攻击力 += y self.独立攻击力 += z return '' def 力智固定加成(self, x=0, y=0): if self.装备描述 == 1: return trans('{力量、智力} +$value
', value=x) else: if y == 0: y = x self.力量 += x self.智力 += y return '' def 持续伤害加成(self, x): if self.装备描述 == 1: return trans('{持续伤害} +$value
', value=to_percent(x)) else: self.持续伤害 += x return '' def 属性附加加成(self, x): if self.装备描述 == 1: return trans('{属性附加伤害} +$value
', value=to_percent(x)) else: self.属性附加 += self.属性附加伤害增加增幅 * x return '' def 技能攻击力加成(self, x, 辟邪玉加成=1,适用累加=1): if self.装备描述 == 1: return trans('{技能攻击力} +$value
', value=to_percent(x)) if 适用累加 == 0: self.技能攻击力 *= 1 + self.技能伤害增加增幅 * x if 辟邪玉加成 == 1 else x else: self.技能攻击力累加 += x if self.技能攻击力累加 <= 2: self.技能攻击力 *= 1 + self.技能伤害增加增幅 * x if 辟邪玉加成 == 1 else x else: self.技能攻击力 *= 1 + (self.技能伤害增加增幅*(2+x-self.技能攻击力累加)+self.技能攻击力累加-2) if self.技能攻击力累加 - x < 2 or 辟邪玉加成 == 1 else x return '' def 暴击伤害加成(self, x, 可变=0, 辟邪玉加成=1): if self.装备描述 == 1: return trans('{暴击伤害} +$value
', value=to_percent(x)) else: self.暴击伤害 += self.暴击伤害增加增幅 * x if 辟邪玉加成 == 1 else x if 可变 > 0: self.变换词条[可变 - 1] = [ 4, round(x * 100), round(x * 100) + (2 if 可变 > 1 else 4), round(x * 100) + (8 if 可变 > 1 else 16) ] return '' def 伤害增加加成(self, x, 可变=0, 辟邪玉加成=1): if self.装备描述 == 1: return trans('{伤害增加} +$value
', value=to_percent(x)) else: self.伤害增加 += self.伤害增加增幅 * x if 辟邪玉加成 == 1 else x if 可变 > 0: self.变换词条[可变 - 1] = [ 2, round(x * 100), round(x * 100) + (2 if 可变 > 1 else 4), round(x * 100) + (8 if 可变 > 1 else 16) ] return '' def 最终伤害加成(self, x, 可变=0, 辟邪玉加成=1): if self.装备描述 == 1: return trans('{最终伤害} +$value
', value=to_percent(x)) else: self.最终伤害 += self.最终伤害增加增幅 * x if 辟邪玉加成 == 1 else x if 可变 > 0: self.变换词条[可变 - 1] = [ 5, round(x * 100), round(x * 100) + (2 if 可变 > 1 else 4), round(x * 100) + (8 if 可变 > 1 else 16) ] return '' def 百分比力智加成(self, x, 可变=0, 辟邪玉加成=1): if self.装备描述 == 1: return trans('{力量、智力} +$value
', value=to_percent(x)) else: self.百分比力智 += self.力量智力增加增幅 * x if 辟邪玉加成 == 1 else x if 可变 > 0: self.变换词条[可变 - 1] = [ 0, round(x * 100), round(x * 100) + (2 if 可变 > 1 else 4), round(x * 100) + (8 if 可变 > 1 else 16) ] return '' def 百分比三攻加成(self, x, 可变=0, 辟邪玉加成=1): if self.装备描述 == 1: return trans('{物攻、魔攻、独立} +$value
', value=to_percent(x)) else: self.百分比三攻 += self.物理魔法攻击力增加增幅 * x if 辟邪玉加成 == 1 else x if 可变 > 0: self.变换词条[可变 - 1] = [ 1, round(x * 100), round(x * 100) + (2 if 可变 > 1 else 4), round(x * 100) + (8 if 可变 > 1 else 16) ] return '' def 火属性强化加成(self, x, 辟邪玉加成=1): if self.装备描述 == 1: return trans("{火属性强化} +$value
", value=x) else: if self.状态 == 0: self.火属性强化 += self.所有属性强化增加 * x if 辟邪玉加成 == 1 else x else: self.火属性强化 += int(self.所有属性强化增加 * x) return '' def 冰属性强化加成(self, x, 辟邪玉加成=1): if self.装备描述 == 1: return trans("{冰属性强化} +$value
", value=x) else: if self.状态 == 0: self.冰属性强化 += self.所有属性强化增加 * x if 辟邪玉加成 == 1 else x else: self.冰属性强化 += int(self.所有属性强化增加 * x) return '' def 光属性强化加成(self, x, 辟邪玉加成=1): if self.装备描述 == 1: return trans("{光属性强化} +$value
", value=x) else: if self.状态 == 0: self.光属性强化 += self.所有属性强化增加 * x if 辟邪玉加成 == 1 else x else: self.光属性强化 += int(self.所有属性强化增加 * x) return '' def 暗属性强化加成(self, x, 辟邪玉加成=1): if self.装备描述 == 1: return trans("{暗属性强化} +$value
", value=x) else: if self.状态 == 0: self.暗属性强化 += self.所有属性强化增加 * x if 辟邪玉加成 == 1 else x else: self.暗属性强化 += int(self.所有属性强化增加 * x) return '' def 所有属性强化加成(self, x, 辟邪玉加成=1): if self.装备描述 == 1: return trans("{所有属性强化} +$value
", value=x) else: if self.状态 == 0: temp = self.所有属性强化增加 * x if 辟邪玉加成 == 1 else x else: temp = int(self.所有属性强化增加 * x) self.所有属性强化(temp) return '' def 攻击速度增加(self, x): if self.装备描述 == 1: return trans("{攻击速度} +$value
", value=to_percent(x, 2)) else: self.攻击速度 += x return '' def 移动速度增加(self, x): if self.装备描述 == 1: return trans("{移动速度} +$value
", value=to_percent(x, 2)) else: self.移动速度 += x return '' def 施放速度增加(self, x): if self.装备描述 == 1: return trans("{释放速度} +$value
", value=to_percent(x, 2)) else: self.施放速度 += x return '' def 命中率增加(self, x): if self.装备描述 == 1: return trans("{命中率} +$value
", value=to_percent(x, 1)) else: self.命中率 += x return '' def 物理暴击率增加(self, x): if self.装备描述 == 1: return trans("{物理暴击率} +$value
", value=to_percent(x)) else: self.物理暴击率 += x return '' def 魔法暴击率增加(self, x): if self.装备描述 == 1: return trans("{魔法暴击率} +$value
", value=to_percent(x)) else: self.魔法暴击率 += x return '' def 技能等级加成(self, 加成类型, minLv, maxLv, lv, 可变=0): lv = int(lv) if self.装备描述 == 1: label = trans('技能等级' if 加成类型 == '所有' else '主动技能等级') if minLv == maxLv: return ("Lv{} {}+{}
").format(minLv, label, lv) return ("Lv{}-{} {}+{}
").format(minLv, maxLv, label, lv) else: if self.远古记忆 > 0: if minLv <= 15 and maxLv >= 15: self.远古记忆 = min(20, self.远古记忆 + lv) if self.刀魂之卡赞 > 0: if minLv <= 5 and maxLv >= 5: self.刀魂之卡赞 = min(20, self.刀魂之卡赞 + lv) for i in self.技能栏: if i.所在等级 >= minLv and i.所在等级 <= maxLv: if 加成类型 == '所有': i.等级加成(lv) else: if i.是否主动 == 1: i.等级加成(lv) if 可变 > 0: self.变换词条[可变 - 1] = [ 6, 2, 14 + (2 if 可变 > 1 else 4), 14 + (8 if 可变 > 1 else 16) ] return '' def 武器装扮等级加成(self, Lv, lv): lv = int(lv) for i in self.技能栏: if i.所在等级 == Lv and i.是否主动 == 1 and i.名称 not in [ "念兽龙虎啸", "风雷啸", "圣灵符文", "神圣之光" ]: i.等级加成(lv) def 技能冷却缩减(self, min, max, x): if self.装备描述 == 1: label = trans('技能') if min == max: return ("Lv{} {}CD -{}
").format(min, label, to_percent(x)) else: return ("Lv{}-{} {}CD -{}
").format(min, max, label, to_percent(x)) else: for i in self.技能栏: if i.所在等级 >= min and i.所在等级 <= max: if i.是否有伤害 == 1: i.CD *= (1 - x) return '' def 技能恢复加成(self, min, max, x): if self.装备描述 == 1: label = trans('技能恢复') if min == max: return "Lv{} {}+{}%
".format(min, label, round(x * 100)) else: return "Lv{}-{} {}+{}%
".format(min, max, label, round(x * 100)) else: for i in self.技能栏: if i.所在等级 >= min and i.所在等级 <= max: if i.是否有伤害 == 1: i.恢复 += x return '' def 进图属强加成(self, x, 辟邪玉加成=1): if self.装备描述 == 1: return trans('{进图属性强化} +$value
', value=x) else: self.进图属强 += int(self.所有属性强化增加 * x if 辟邪玉加成 == 1 else x) return '' def 技能倍率加成(self, lv, x): if self.装备描述 == 1: return trans("Lv$level {技能攻击力} +$value
", level=lv, value=to_percent(x)) else: for i in self.技能栏: if i.所在等级 == lv: if i.是否有伤害 == 1: i.倍率 *= (1 + x * self.技能伤害增加增幅) return '' def 单技能修改(self, 名称, 倍率, CD): if self.装备描述 == 1: tem = "" if 倍率 != 1: tem += trans("[{$name}]{攻击力} +$value
", name=名称, value=to_percent(倍率 - 1)) if CD != 1: tem += trans("[{$name}]{CD} +$value
", name=名称, value=to_percent(CD - 1)) return tem else: for i in self.技能栏: if i.是否有伤害 == 1: if i.名称 == 名称: i.倍率 *= 倍率 i.CD *= CD return '' def 所有属性强化(self, x): self.火属性强化 += x self.冰属性强化 += x self.光属性强化 += x self.暗属性强化 += x # endregion # region 面板计算 def 防具精通计算(self, i): temp = equ.get_equ_by_name(self.装备栏[i]) if temp.等级 == 100: if temp.所属套装 != '智慧产物': return 精通计算(temp.等级, temp.品质, self.强化等级[i], 部位列表[i]) else: return 精通计算(temp.等级, temp.品质, self.改造等级[i], 部位列表[i]) elif temp.等级 > 85: 计算等级 = temp.等级 if temp.所属套装 == '兵法之神': if self.装备检查('过往时光的轮回'): 计算等级 = 100 return 精通计算(计算等级, temp.品质, self.强化等级[i], 部位列表[i]) else: 计算等级 = temp.等级 if temp.所属套装 == '战术之王的御敌': if self.装备检查('战术之王的战术指挥棒'): 计算等级 = 100 elif temp.所属套装 == '魔战无双': if self.装备检查('聚魔漩涡'): 计算等级 = 100 x = 精通计算(计算等级, temp.品质, self.强化等级[i], 部位列表[i]) if self.转甲选项 == 1: return round(x, 2) else: return round(0.4 * x, 2) def 站街力量(self): return int(self.力量) def 站街智力(self): return int(self.智力) def 面板力量(self): return (self.力量 + int((self.力量 - self.基础力量) * self.系统奶系数 + self.系统奶基数) + self.进图力量) * (1 + self.百分比力智) def 面板智力(self): return (self.智力 + int((self.智力 - self.基础智力) * self.系统奶系数 + self.系统奶基数) + self.进图智力) * (1 + self.百分比力智) def 站街物理攻击力倍率(self): 站街物理攻击倍率 = 1.0 for i in self.技能栏: try: 站街物理攻击倍率 *= i.物理攻击力倍率(self.武器类型) except: pass return 站街物理攻击倍率 def 站街魔法攻击力倍率(self): 站街魔法攻击倍率 = 1.0 for i in self.技能栏: try: 站街魔法攻击倍率 *= i.魔法攻击力倍率(self.武器类型) except: pass return 站街魔法攻击倍率 def 站街独立攻击力倍率(self): 站街独立攻击倍率 = 1.0 for i in self.技能栏: try: 站街独立攻击倍率 *= i.独立攻击力倍率(self.武器类型) except: pass return 站街独立攻击倍率 def 站街物理攻击力(self): return self.物理攻击力 * self.站街物理攻击力倍率() def 站街魔法攻击力(self): return self.魔法攻击力 * self.站街魔法攻击力倍率() def 站街独立攻击力(self): return self.独立攻击力 * self.站街独立攻击力倍率() def 面板物理攻击力(self): 面板物理攻击 = (self.物理攻击力 + self.进图物理攻击力) * (1 + self.百分比三攻) * ( 1 + self.年宠技能 * 0.10 + self.斗神之吼秘药 * 0.12 + self.白兔子技能 * 0.20) for i in self.技能栏: try: 面板物理攻击 *= i.物理攻击力倍率进图(self.武器类型) except: pass return 面板物理攻击 * self.站街物理攻击力倍率() def 面板魔法攻击力(self): 面板魔法攻击 = (self.魔法攻击力 + self.进图魔法攻击力) * (1 + self.百分比三攻) * ( 1 + self.年宠技能 * 0.10 + self.斗神之吼秘药 * 0.12 + self.白兔子技能 * 0.20) for i in self.技能栏: try: 面板魔法攻击 *= i.魔法攻击力倍率进图(self.武器类型) except: pass return 面板魔法攻击 * self.站街魔法攻击力倍率() def 面板独立攻击力(self): 面板独立攻击 = (self.独立攻击力 + self.进图独立攻击力) * (1 + self.百分比三攻) for i in self.技能栏: try: 面板独立攻击 *= i.独立攻击力倍率进图(self.武器类型) except: pass return 面板独立攻击 * self.站街独立攻击力倍率() def 面板系数计算(self): if self.类型 == '物理百分比': return int((self.面板力量() / 250 + 1) * (self.物理攻击力 + self.进图物理攻击力) * (1 + self.百分比三攻)) elif self.类型 == '魔法百分比': return int((self.面板智力() / 250 + 1) * (self.魔法攻击力 + self.进图魔法攻击力) * (1 + self.百分比三攻)) elif self.类型 == '物理固伤': return int((self.面板力量() / 250 + 1) * (self.独立攻击力 + self.进图独立攻击力) * (1 + self.百分比三攻)) elif self.类型 == '魔法固伤': return int((self.面板智力() / 250 + 1) * (self.独立攻击力 + self.进图独立攻击力) * (1 + self.百分比三攻)) def 力智计算(self): return max(self.面板力量(), self.面板智力()) # endregion # region 输出计算 def 加算冷却计算(self): for i in self.技能栏: if i.是否有伤害 == 1: i.CD *= (1 - self.加算冷却缩减) def CD倍率计算(self): for i in self.技能栏: if i.冷却关联技能 != ['无']: if i.冷却关联技能 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.CD *= i.CD缩减倍率(self.武器类型) else: for k in i.冷却关联技能: self.技能栏[self.技能序号[k]].CD *= i.CD缩减倍率(self.武器类型) if i.非冷却关联技能 != ['无']: if i.非冷却关联技能 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.CD /= i.CD缩减倍率(self.武器类型) else: for k in i.非冷却关联技能: self.技能栏[self.技能序号[k]].CD /= i.CD缩减倍率(self.武器类型) if i.冷却关联技能2 != ['无']: if i.冷却关联技能2 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.CD *= i.CD缩减倍率2(self.武器类型) else: for k in i.冷却关联技能2: self.技能栏[self.技能序号[k]].CD *= i.CD缩减倍率2(self.武器类型) if i.非冷却关联技能2 != ['无']: if i.非冷却关联技能2 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.CD /= i.CD缩减倍率2(self.武器类型) else: for k in i.非冷却关联技能2: self.技能栏[self.技能序号[k]].CD /= i.CD缩减倍率2(self.武器类型) if i.冷却关联技能3 != ['无']: if i.冷却关联技能3 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.CD *= i.CD缩减倍率3(self.武器类型) else: for k in i.冷却关联技能3: self.技能栏[self.技能序号[k]].CD *= i.CD缩减倍率3(self.武器类型) if i.非冷却关联技能3 != ['无']: if i.非冷却关联技能3 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.CD /= i.CD缩减倍率3(self.武器类型) else: for k in i.非冷却关联技能3: self.技能栏[self.技能序号[k]].CD /= i.CD缩减倍率3(self.武器类型) def 被动倍率计算(self): if self.远古记忆 > 0: self.进图智力 += self.远古记忆 * 15 if self.刀魂之卡赞 > 0: self.进图力量 += 刀魂之卡赞数据[self.刀魂之卡赞] self.进图智力 += 刀魂之卡赞数据[self.刀魂之卡赞] for i in self.技能栏: i.被动倍率 = 1 for i in self.技能栏: if i.关联技能 != ['无']: if i.关联技能 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 *= i.加成倍率(self.武器类型) else: for k in i.关联技能: self.技能栏[self.技能序号[k]].被动倍率 *= i.加成倍率(self.武器类型) if i.非关联技能 != ['无']: if i.非关联技能 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 /= i.加成倍率(self.武器类型) else: for k in i.非关联技能: self.技能栏[self.技能序号[k]].被动倍率 /= i.加成倍率(self.武器类型) if i.关联技能2 != ['无']: if i.关联技能2 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 *= i.加成倍率2(self.武器类型) else: for k in i.关联技能2: self.技能栏[self.技能序号[k]].被动倍率 *= i.加成倍率2(self.武器类型) if i.非关联技能2 != ['无']: if i.非关联技能2 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 /= i.加成倍率2(self.武器类型) else: for k in i.非关联技能2: self.技能栏[self.技能序号[k]].被动倍率 /= i.加成倍率2(self.武器类型) if i.关联技能3 != ['无']: if i.关联技能3 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 *= i.加成倍率3(self.武器类型) else: for k in i.关联技能3: self.技能栏[self.技能序号[k]].被动倍率 *= i.加成倍率3(self.武器类型) if i.非关联技能3 != ['无']: if i.非关联技能3 == ['所有']: for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 /= i.加成倍率3(self.武器类型) else: for k in i.非关联技能3: self.技能栏[self.技能序号[k]].被动倍率 /= i.加成倍率3(self.武器类型) def 属性倍率计算(self): # 火、冰、光、暗 self.属性倍率组 = [] self.属性倍率组.append(1.05 + 0.0045 * int(self.火属性强化 - self.火抗输入)) self.属性倍率组.append(1.05 + 0.0045 * int(self.冰属性强化 - self.冰抗输入)) self.属性倍率组.append(1.05 + 0.0045 * int(self.光属性强化 - self.光抗输入)) self.属性倍率组.append(1.05 + 0.0045 * int(self.暗属性强化 - self.暗抗输入)) if self.攻击属性 == 0: self.属性倍率 = max(self.属性倍率组) elif self.攻击属性 == 1: self.属性倍率 = self.属性倍率组[0] elif self.攻击属性 == 2: self.属性倍率 = self.属性倍率组[1] elif self.攻击属性 == 3: self.属性倍率 = self.属性倍率组[2] elif self.攻击属性 == 4: self.属性倍率 = self.属性倍率组[3] def 伤害指数计算(self): 防御 = max(self.防御输入 - self.固定减防, 0) * (1 - self.百分比减防) 基准倍率 = 1.5 * self.主BUFF * (1 - 防御 / (防御 + 200 * 等级)) # 避免出现浮点数取整BUG self.伤害增加 += 0.00000001 self.属性倍率计算() # if sum(self.自适应选项) != 0: if self.计算自适应 == 1: self.自适应计算() # self.希洛克武器提升() 面板 = self.面板系数计算() 增伤倍率 = 1 + int(self.伤害增加 * 100) / 100 增伤倍率 *= 1 + self.暴击伤害 增伤倍率 *= 1 + self.最终伤害 增伤倍率 *= self.技能攻击力 增伤倍率 *= 1 + self.持续伤害 * self.持续伤害计算比例 增伤倍率 *= 1 + self.附加伤害 + self.属性附加 * self.属性倍率 self.伤害指数 = 面板 * self.属性倍率 * 增伤倍率 * 基准倍率 / 100 * self.队友增幅系数 # 7.8日,伤害数据压缩 self.伤害指数 /= 1000 def 伤害计算(self, x=0): if 切装模式 == 1 and self.切装判断(): temp = self.装备替换() A = temp[0].数据计算(1, 1) # 身上装备计算 B = temp[1].数据计算(1, 0) # 切装装备计算 self.预处理() for i in range(len(self.技能栏)): self.技能栏[i] = deepcopy(temp[self.技能切装[i]].技能栏[i]) C = [] 总伤害 = 0 for i in range(len(A)): C.append(A[i] if (self.技能切装[int(i / 4)] == 0) else B[i]) if i % 4 == 1: 总伤害 += C[i] if x == 0: return 总伤害 else: for i in range(int(len(A) / 4)): if 总伤害 != 0: C[i * 4 + 3] = C[i * 4 + 1] / 总伤害 * 100 else: C[i * 4 + 3] = 0 return C else: self.技能切装 = [0] * len(self.技能栏) # if self.计算自适应 == 1: # self.择优拷贝 = deepcopy(self) # self.择优拷贝.计算自适应 = 0 return self.数据计算(x) def 技能释放次数解析(self, 技能释放次数): for i in range(len(self.技能栏)): if '/CD' in self.次数输入[i]: 技能释放次数[i] = eval(self.次数输入[i].replace('/CD', str(技能释放次数[i]))) if type(self.宠物次数[i]) == type('str'): self.宠物次数[i] = eval(self.宠物次数[i].replace( 'num', str(技能释放次数[i]))) return 技能释放次数 def 技能释放次数计算(self): 技能释放次数 = [] for i in self.技能栏: if i.是否有伤害 == 1: s = self.次数输入[self.技能序号[i.名称]] if '/CD' in s: 技能释放次数.append( int((self.时间输入 - i.演出时间) / i.等效CD(self.武器类型, self.类型)) + 1 + i.基础释放次数) else: 技能释放次数.append(round(float(s), 2)) else: 技能释放次数.append(0) return self.技能释放次数解析(技能释放次数) def 技能单次伤害计算(self, y): # y切装标记 技能单次伤害 = [] for i in self.技能栏: if i.是否有伤害 == 1 and self.技能切装[self.技能序号[i.名称]] != y: 技能单次伤害.append(i.等效百分比(self.武器类型) * self.伤害指数 * i.被动倍率) else: 技能单次伤害.append(0) return 技能单次伤害 def 技能总伤害计算(self, a, b): # a次数 b单次伤害 技能总伤害 = [] for i in self.技能栏: index = self.技能序号[i.名称] if i.是否有伤害 == 1 and a[index] != 0: 技能总伤害.append(a[index] * b[index] * ( 1 + self.白兔子技能 * 0.20 + self.年宠技能 * 0.10 * self.宠物次数[index] / a[index] # 宠物技能占比 = 宠物次数 / 释放次数 + self.斗神之吼秘药 * 0.12)) else: 技能总伤害.append(0) return 技能总伤害 def 数据返回(self, x, a, b): # a次数 b伤害 总伤害 = sum(b) if x == 0: # 伤害数据，用于排序 return 总伤害 elif x == 1: # 详细数据，用于展示 四个数据一组 # 0次数 1总伤害 2平均伤害 3占比 data = [] for i in range(len(self.技能栏)): data.append(a[i]) data.append(b[i]) if a[i] != 0: data.append(b[i] / a[i]) else: data.append(b[i]) if 总伤害 != 0: data.append(b[i] / 总伤害 * 100) else: data.append(0) return data def 数据计算(self, x=0, y=-1): self.预处理() # 初步计算 技能释放次数 = self.技能释放次数计算() 技能单次伤害 = self.技能单次伤害计算(y) 技能总伤害 = self.技能总伤害计算(技能释放次数, 技能单次伤害) # 返回结果 return self.数据返回(x, 技能释放次数, 技能总伤害) def 装备词条计算(self): # 初始化 以防和自选冲突 self.变换词条 = [ # 原词条类型，原词条数值，可洗最小值，可洗最大值，择优不考虑觉醒 [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0] ] if 调试开关 == 0: for i in range(12): temp = equ.get_equ_by_name(self.装备栏[i]) temp.城镇属性(self) temp.变换属性(self) if temp.所属套装 == '智慧产物' and self.产物升级 == 1: temp.产物升级(self) # 添加可洗属性 for i in self.套装栏: equ.get_suit_by_name(i).城镇属性(self) # print(self.变换词条) # 进图触发属强向下取整 self.状态 = 1 for i in range(12): equ.get_equ_by_name(self.装备栏[i]).进图属性(self) for i in self.套装栏: equ.get_suit_by_name(i).进图属性(self) self.状态 = 0 self.黑鸦词条扣除() # print(self.黑鸦词条) # 冲突属性计算 self.伤害增加加成(self.黄字) self.暴击伤害加成(self.暴伤) def 预处理(self): self.装备属性计算() self.三觉屏蔽1() self.所有属性强化(self.进图属强) self.CD倍率计算() self.加算冷却计算() self.被动倍率计算() self.三觉屏蔽2() self.伤害指数计算() def 装备属性计算(self): self.装备基础() self.装备词条计算() def 其它属性计算(self): for i in range(12): equ.get_equ_by_name(self.装备栏[i]).其它属性(self) for i in self.套装栏: equ.get_suit_by_name(i).其它属性(self) # endregion # region 择优相关 def 词条提示上下限计算(self, 词条范围, 词条数值): 词条提升率 = [[0, 0]] * 6 if 0 in 词条范围: # 百分比力智 最高提升 = 0 x = self.面板系数计算() self.百分比力智加成(词条数值[0]) 最高提升 = round(self.面板系数计算() / x - 1, 8) self.百分比力智加成(-词条数值[0]) 最低提升 = 0 self.百分比力智加成(self.择优极限[0] - 词条数值[0]) x = self.面板系数计算() self.百分比力智加成(词条数值[0]) 最低提升 = round(self.面板系数计算() / x - 1, 8) self.百分比力智加成(-self.择优极限[0]) 词条提升率[0] = [最低提升, 最高提升] if 1 in 词条范围: 最高提升 = 0 x = 1 + self.百分比三攻 self.百分比三攻加成(词条数值[1]) 最高提升 = round((1 + self.百分比三攻) / x - 1, 8) self.百分比三攻加成(-词条数值[1]) 最低提升 = 0 self.百分比三攻加成(self.择优极限[1] - 词条数值[1]) x = 1 + self.百分比三攻 self.百分比三攻加成(词条数值[1]) 最低提升 = round((1 + self.百分比三攻) / x - 1, 8) self.百分比三攻加成(-self.择优极限[1]) 词条提升率[1] = [最低提升, 最高提升] if 2 in 词条范围: 最高提升 = 0 x = 1 + int(self.伤害增加 * 100) / 100 self.伤害增加加成(词条数值[2]) 最高提升 = round((1 + int(self.伤害增加 * 100) / 100) / x - 1, 8) self.伤害增加加成(-词条数值[2]) 最低提升 = 0 self.伤害增加加成(self.择优极限[2] - 词条数值[2]) x = 1 + int(self.伤害增加 * 100) / 100 self.伤害增加加成(词条数值[2]) 最低提升 = round((1 + int(self.伤害增加 * 100) / 100) / x - 1, 8) self.伤害增加加成(-self.择优极限[2]) 词条提升率[2] = [最低提升, 最高提升] if 3 in 词条范围: 最高提升 = 0 x = 1 + self.附加伤害 + self.属性附加 * self.属性倍率 self.附加伤害加成(词条数值[3]) 最高提升 = round((1 + self.附加伤害 + self.属性附加 * self.属性倍率) / x - 1, 8) self.附加伤害加成(-词条数值[3]) 最低提升 = 0 self.附加伤害加成(self.择优极限[3] - 词条数值[3]) x = 1 + self.附加伤害 + self.属性附加 * self.属性倍率 self.附加伤害加成(词条数值[3]) 最低提升 = round((1 + self.附加伤害 + self.属性附加 * self.属性倍率) / x - 1, 8) self.附加伤害加成(-self.择优极限[3]) 词条提升率[3] = [最低提升, 最高提升] if 4 in 词条范围: 最高提升 = 0 x = 1 + self.暴击伤害 self.暴击伤害加成(词条数值[4]) 最高提升 = round((1 + self.暴击伤害) / x - 1, 8) self.暴击伤害加成(-词条数值[4]) 最低提升 = 0 self.暴击伤害加成(self.择优极限[4] - 词条数值[4]) x = 1 + self.暴击伤害 self.暴击伤害加成(词条数值[4]) 最低提升 = round((1 + self.暴击伤害) / x - 1, 8) self.暴击伤害加成(-self.择优极限[4]) 词条提升率[4] = [最低提升, 最高提升] if 5 in 词条范围: 最高提升 = 0 x = 1 + self.最终伤害 self.最终伤害加成(词条数值[5]) 最高提升 = round((1 + self.最终伤害) / x - 1, 8) self.最终伤害加成(-词条数值[5]) 最低提升 = 0 self.最终伤害加成(self.择优极限[5] - 词条数值[5]) x = 1 + self.最终伤害 self.最终伤害加成(词条数值[5]) 最低提升 = round((1 + self.最终伤害) / x - 1, 8) self.最终伤害加成(-self.择优极限[5]) 词条提升率[5] = [最低提升, 最高提升] return 词条提升率 def 词条修改(self, x): self.百分比力智加成(x) self.百分比三攻加成(x) self.伤害增加加成(x) self.附加伤害加成(x) self.暴击伤害加成(x) self.最终伤害加成(x) def 基础提升率计算(self): 词条基数 = [ 250 + self.力智计算(), 1 + self.百分比三攻, 100 * (1 + self.伤害增加), 1 + self.附加伤害 + self.属性附加 * self.属性倍率, 1 + self.暴击伤害, 1 + self.最终伤害, ] self.词条修改(0.01) 词条提升后数值 = [ 250 + self.力智计算(), 1 + self.百分比三攻, 100 * (1 + self.伤害增加), 1 + self.附加伤害 + self.属性附加 * self.属性倍率, 1 + self.暴击伤害, 1 + self.最终伤害, ] self.词条修改(-0.01) return [词条基数, 词条提升后数值] def 词条提升率计算(self, 词条范围, 词条数值, y=0): 词条提升率 = [0] * 6 if 0 in 词条范围: # 百分比力智 x = self.面板系数计算() self.百分比力智加成(词条数值[0]) 词条提升率[0] = round(self.面板系数计算() / x - 1, 8) self.百分比力智加成(-词条数值[0]) if 1 in 词条范围: # 百分比三攻 x = 1 + self.百分比三攻 self.百分比三攻加成(词条数值[1]) 词条提升率[1] = round((1 + self.百分比三攻) / x - 1, 8) self.百分比三攻加成(-词条数值[1]) if 2 in 词条范围: # 伤害增加 x = 1 + int(self.伤害增加 * 100) / 100 self.伤害增加加成(词条数值[2]) 词条提升率[2] = round((1 + int(self.伤害增加 * 100) / 100) / x - 1, 8) self.伤害增加加成(-词条数值[2]) if 3 in 词条范围: # 附加伤害 x = 1 + self.附加伤害 + self.属性附加 * self.属性倍率 self.附加伤害加成(词条数值[3]) 词条提升率[3] = round((1 + self.附加伤害 + self.属性附加 * self.属性倍率) / x - 1, 8) self.附加伤害加成(-词条数值[3]) if 4 in 词条范围: # 暴击伤害 x = 1 + self.暴击伤害 self.暴击伤害加成(词条数值[4]) 词条提升率[4] = round((1 + self.暴击伤害) / x - 1, 8) self.暴击伤害加成(-词条数值[4]) if 5 in 词条范围: # 最终伤害 x = 1 + self.最终伤害 self.最终伤害加成(词条数值[5]) 词条提升率[5] = round((1 + self.最终伤害) / x - 1, 8) self.最终伤害加成(-词条数值[5]) if y == 1: self.词条提升率 = copy(词条提升率) # for k in range(6): # if 词条提升率[k] == max(词条提升率): # 词条属性列表[k].加成属性(self, 词条数值[k]) # return k tem = [] 最小词条 = 0 for k in range(6): if 词条提升率[k] == max(词条提升率): # 词条属性列表[k].加成属性(self, 词条数值[k]) tem.append(k) 待排序提升率 = [] for i in tem: 待排序提升率.append([i, self.择优极限[i]]) 待排序提升率.sort(key=lambda x: round(x[1], 2), reverse=False) self.择优极限 = [round(self.择优极限[i] - 词条数值[i], 3) for i in range(6)] 最小词条 = 待排序提升率[0][0] 词条属性列表[最小词条].加成属性(self, 词条数值[最小词条]) return 最小词条 def 自适应计算(self, x=0): # print(self.计算自适应方式) if self.黑鸦武器择优模式 == 0: self.择优词条 = [[round(self.变换词条[0][3] / 100, 2)] * 6, [round(self.变换词条[1][3] / 100, 2)] * 6, [round(self.变换词条[2][3] / 100, 2)] * 6, [round(self.变换词条[3][3] / 100, 2)] * 6, [0.1] * 6, [0.05] * 6, [0.08, 0.08, 0.07, 0.08, 0, 0.08], [0, 0.05, 0.05, 0, 0.05, 0]] else: self.择优词条 = [[round(0.16, 2)] * 6, [round(self.变换词条[1][3] / 100, 2)] * 6, [round(self.变换词条[2][3] / 100, 2)] * 6, [round(self.变换词条[3][3] / 100, 2)] * 6, [0.1] * 6, [0.05] * 6, [0.08, 0.08, 0.07, 0.08, 0, 0.08], [0, 0.05, 0.05, 0, 0.05, 0]] self.是否择优 = self.词条是否择优() self.择优结果 = [[0, 0]] * len(self.择优词条) # print(self.择优词条) # self.是否择优 = self.词条是否择优() # print(self.是否择优) # print(self.计算自适应方式) # if self.计算自适应方式 == 0: # self.贪心自适应() # else: # self.全局自适应() if self.输出提升率 != 0: self.择优提升率计算() else: try: self.全局自适应() except Exception as error: logger.error(error) self.贪心自适应() for i in range(len(self.择优结果)): # 词条属性列表[self.择优结果[i][0]].加成属性(self,self.择优结果[i][1]) if i < 4: self.黑鸦词条[i].append("") if self.择优结果[i][1] != 0: self.黑鸦词条[i][4] = ( trans("觉醒Lv+2 ") if i == 0 and self.择优结果[i][1] == 0.16 else '') + trans( 黑鸦武器属性列表[self.择优结果[i][0]].描述) + '+' + str( round(self.择优结果[i][1] * 100)) + '%' if i == 4: if self.是否择优[i] == 0: self.词条提升率 = [0] * 6 else: self.词条选择.clear() self.词条选择.append(self.择优结果[i][0]) if i == 5: if self.是否择优[i] != 0: self.词条选择.append(self.择优结果[i][0]) if i == 6: self.自适应描述[0] = '{}%{}'.format( int(self.择优结果[i][1] * 100), trans(词条属性列表[self.择优结果[i][0]].描述)) if i == 7: self.自适应描述[1] = '{}%{}'.format( int(self.择优结果[i][1] * 100), trans(词条属性列表[self.择优结果[i][0]].描述)) def 计算择优范围(self, d): index = [] for i in range(6): if d[i] != 0: index.append(i) if len(index) == 0: index.append(0) return index def 择优提升率计算(self): up = self.基础提升率计算() data_array = [[0 for i in range(6)] for i in range(8)] for i in range(8): for j in range(6): data_array[i][j] = self.择优词条[i][j] * ( up[1][j] - up[0][j]) * self.是否择优[i] * 100 try: self.全局自适应() except: self.贪心自适应() k = [up[0][0], up[0][1], up[0][2], up[0][3], up[0][4], up[0][5]] k[self.择优结果[0][0]] += data_array[0][self.择优结果[0][0]] k[self.择优结果[1][0]] += data_array[1][self.择优结果[1][0]] k[self.择优结果[2][0]] += data_array[2][self.择优结果[2][0]] k[self.择优结果[3][0]] += data_array[3][self.择优结果[3][0]] k[self.择优结果[4][0]] += data_array[4][self.择优结果[4][0]] k[self.择优结果[5][0]] += data_array[5][self.择优结果[5][0]] k[self.择优结果[6][0]] += data_array[6][self.择优结果[6][0]] k[self.择优结果[7][0]] += data_array[7][self.择优结果[7][0]] max_data = k[0] * k[1] * int(k[2]) * k[3] * k[4] * k[5] rangelist = [self.计算择优范围(i) for i in data_array] path = './详细数据' if not os.path.exists(path): os.makedirs(path) result_path = os.path.join( path, '{}-{}.csv'.format(self.实际名称, time.strftime('%m-%d-%H-%M-%S'))) wf = open(result_path, 'w', encoding='gbk') wf.write('黑鸦武器,黑鸦戒指,黑鸦左槽,黑鸦下装,残香10%,残香5%,宠物装备,光环,系数,伤害\n') increase_counter(ga_category="carry详细功能使用", name="输出择优数据") for a1 in rangelist[0]: for a2 in rangelist[1]: for a3 in rangelist[2]: for a4 in rangelist[3]: for a5 in rangelist[4]: for a6 in rangelist[5]: for a7 in rangelist[6]: for a8 in rangelist[7]: k = [ up[0][0], up[0][1], up[0][2], up[0][3], up[0][4], up[0][5] ] k[a1] += data_array[0][a1] k[a2] += data_array[1][a2] k[a3] += data_array[2][a3] k[a4] += data_array[3][a4] k[a5] += data_array[4][a5] k[a6] += data_array[5][a6] k[a7] += data_array[6][a7] k[a8] += data_array[7][a8] rate = k[0] * k[1] * int( k[2] ) * k[3] * k[4] * k[5] / max_data damage = int(rate * self.输出提升率) wf.write( '{},{},{},{},{},{},{},{},{:.8},{}\n' .format( '无' if len(rangelist[0]) == 1 else 词条属性列表[a1].描述, '无' if len(rangelist[1]) == 1 else 词条属性列表[a2].描述, '无' if len(rangelist[2]) == 1 else 词条属性列表[a3].描述, '无' if len(rangelist[3]) == 1 else 词条属性列表[a4].描述, '无' if len(rangelist[4]) == 1 else 词条属性列表[a5].描述, '无' if len(rangelist[5]) == 1 else 词条属性列表[a6].描述, '无' if len(rangelist[6]) == 1 else 词条属性列表[a7].描述, '无' if len(rangelist[7]) == 1 else 词条属性列表[a8].描述, rate, damage)) os.startfile(result_path) def 全局自适应(self): x = 6 y = 8 data_array = ((ctypes.c_double * x) * (y + 1))() # 提升值数组 index = (ctypes.c_int * y)() # 索引 up = self.基础提升率计算() # 第一行为词条基础 for j in range(x): data_array[0][j] = up[0][j] # 后续8行为可选词条 for i in range(y): for j in range(x): data_array[i + 1][j] = self.择优词条[i][j] * ( up[1][j] - up[0][j]) * self.是否择优[i] * 100 preferred.cal_index(data_array, byref(index)) for i in range(y): if self.是否择优[i] != 0: self.择优结果[i] = [index[i], self.择优词条[i][index[i]]] 词条属性列表[self.择优结果[i][0]].加成属性(self, self.择优结果[i][1]) def 贪心自适应(self): # self.全局自适应() # return # self.择优词条 = [ # [round(self.变换词条[0][3]/100,2)]*6, # [round(self.变换词条[1][3]/100,2)]*6, # [round(self.变换词条[2][3]/100,2)]*6, # [round(self.变换词条[3][3]/100,2)]*6, # [0.1]*6, # [0.05]*6, # [0.07,0,0.07,0.08,0,0,0], # [0,0.05,0.05,0,0.05,0,0] # ] self.择优范围 = [] for item in self.择优词条: 词条数值 = item 计算范围 = [] for i in range(6): if 词条数值[i] != 0: 计算范围.append(i) self.择优范围.append(计算范围) 贪心排序 = [] 自由择优 = [] 条件择优 = [] 条件择优结果 = [] count = 1 self.择优极限 = [0] * 6 for i in range(len(self.择优词条)): if self.是否择优[i] == 1: 词条数目 = len(list(filter(lambda x: x != 0, self.择优词条[i]))) 贪心排序.append([count, max(self.择优词条[i]), 词条数目]) self.择优极限 = [ round(self.择优极限[j] + self.择优词条[i][j], 3) for j in range(6) ] if 词条数目 == 6: 自由择优.append(count) else: 条件择优.append(count) # 说明存在非全部择优的情况 count += 1 # 贪心排序 = [ # [1,round(self.变换词条[0][3]/100,2),6], # [2,round(self.变换词条[1][3]/100,2),6], # [3,round(self.变换词条[2][3]/100,2),6], # [4,round(self.变换词条[3][3]/100,2),6], # [5,0.1,6], # [6,0.05,6], # [7,0.08,3], # [8,0.05,3] # ] 贪心排序.sort(key=lambda x: round(x[1], 2), reverse=True) 贪心排序.sort(key=lambda x: int(x[2]), reverse=True) # print(self.择优词条) # print(条件择优) # self.自适应1 = 0 # self.自适应2 = 0 # if self.自适应选项[0] !=0: # self.自适应1 = 1 # if self.自适应选项[1] !=0: # self.自适应2 = 1 # self.择优极限 = [0]*6 # for item in 贪心排序: # self.择优极限累计(item[0]) # print(self.择优极限) for item in 贪心排序: 条件择优结果 = [] # 每次择优完计算非完全择优的每一个最高最低收益 for temp in 条件择优: if self.是否择优[temp - 1] == 1: 词条数值 = self.择优词条[temp - 1] 上下限 = self.词条提示上下限计算(self.择优范围[temp - 1], 词条数值) 下限提升最高 = max([上下限[i][0] for i in range(len(上下限))]) index = 0 # tem = [] 待排序提升率 = [] for i in range(6): if 上下限[i][0] == 下限提升最高: # tem.append(i) 待排序提升率.append([i, self.择优极限[i]]) 待排序提升率.sort(key=lambda x: round(x[1], 2), reverse=False) index = 待排序提升率[0][0] del 上下限[index] if 下限提升最高 >= max([上下限[i][1] for i in range(len(上下限))]): self.是否择优[temp - 1] = 0 词条属性列表[index].加成属性(self, 词条数值[index]) # 条件择优结果.append('{}%{}'.format(int(词条数值[index] * 100), 词条属性列表[index].描述)) self.择优极限 = [ round(self.择优极限[i] - 词条数值[i], 3) for i in range(6) ] self.择优结果[temp - 1] = [index, 词条数值[index]] # else: # 条件择优结果.append('') # else: # 条件择优结果.append('') # for i in range(len(条件择优)): # if 条件择优结果[i]!='': # self.自适应描述[i]= 条件择优结果[i] self.择优计算(item[0]) def 择优计算(self, index): for i in range(1, 5): if index == i and self.是否择优[index - 1] != 0: 词条数值 = self.择优词条[index - 1] res = self.词条提升率计算(self.择优范围[index - 1], 词条数值) self.择优结果[index - 1] = [res, 词条数值[res]] # self.黑鸦词条[i-1].append("") # self.黑鸦词条[i-1][4] = 黑鸦武器属性列表[res].描述 +'+' +str(self.变换词条[i-1][3])+'%' # print(self.黑鸦词条) return # 残香词条1-10% if index == 5: if self.是否择优[index - 1] != 0: # self.词条选择.clear() 词条数值 = self.择优词条[index - 1] res = self.词条提升率计算(self.择优范围[index - 1], 词条数值, 1) self.择优结果[index - 1] = [res, 词条数值[res]] # self.词条选择.append(res) # print(self.词条选择) return # 残香词条2 if index == 6: if self.是否择优[index - 1] != 0: 词条数值 = self.择优词条[index - 1] res = self.词条提升率计算(self.择优范围[index - 1], self.择优词条[index - 1]) self.择优结果[index - 1] = [res, 词条数值[res]] # self.词条选择.append(self.词条提升率计算(self.择优范围[index-1], self.择优词条[index-1])) return # 宠物红色装备词条 if index == 7: if self.是否择优[index - 1] != 0: # 宠物 词条数值 = self.择优词条[index - 1] res = self.词条提升率计算(self.择优范围[index - 1], 词条数值) self.择优结果[index - 1] = [res, 词条数值[res]] # self.自适应描述[0] = '{}%{}'.format(int(词条数值[res] * 100), 词条属性列表[res].描述) self.是否择优[index - 1] = 0 return # 光环词条 if index == 8: if self.是否择优[index - 1] != 0: # 光环 词条数值 = self.择优词条[index - 1] res = self.词条提升率计算(self.择优范围[index - 1], 词条数值) self.择优结果[index - 1] = [res, 词条数值[res]] # self.自适应描述[1] = '{}%{}'.format(5, 词条属性列表[res].描述) self.是否择优[index - 1] = 0 return def 词条是否择优(self): temp = [0] * 8 for i in range(4): if self.黑鸦词条[i][0] == 1 and self.变换词条[i][1] != 0: temp[i] = 1 # 残香词条1-10% if self.希洛克武器词条 != 0: temp[4] = 1 if self.希洛克武器词条 == 1 and self.武器词条触发 == 1: temp[5] = 1 if self.自适应选项[0] != 0: temp[6] = 1 if self.自适应选项[1] != 0: temp[7] = 1 return temp def 自适应输出(self): temp = '' if self.自适应选项[0] != 0: # 宠物 temp += trans('{宠物}:$value', value=self.自适应描述[0]) if self.自适应选项[1] != 0: # 光环 if temp != '': temp += '|' temp += trans('{光环}:$value', value=self.自适应描述[1]) return temp def 黑鸦词条扣除(self): for i in range(4): self.黑鸦词条[i].append("") if self.黑鸦词条[i][0] != 0 and self.变换词条[i][1] != 0: self.黑鸦词条变更(self.变换词条[i], -1) if self.黑鸦词条[i][0] == 2 and self.变换词条[i][1]: temp = [ self.黑鸦词条[i][1], (14 if self.变换词条[i][0] == 6 else self.变换词条[i][1]) + self.黑鸦词条[i][2], 0, 0 ] self.黑鸦词条变更(temp, 1) self.黑鸦词条[i][4] = 黑鸦武器属性列表[temp[0]].描述 + '+' + str( (14 if self.变换词条[i][0] == 6 else self.变换词条[i][1]) + self.黑鸦词条[i][2]) + ('' if temp[0] == 6 else '%') if self.黑鸦词条[i][0] == 3 and self.变换词条[i][1]: self.黑鸦词条[i][4] = "" temp = [6, 2, 0, 0] self.黑鸦词条变更([6, 2, 0, 0]) self.黑鸦词条[i][4] += 黑鸦武器属性列表[temp[0]].描述 + '+' + '2' self.黑鸦词条[i][4] += '
' temp = [self.黑鸦词条[i][1], self.黑鸦词条[i][2], 0, 0] self.黑鸦词条变更(temp, 1) self.黑鸦词条[i][4] += 黑鸦武器属性列表[temp[0]].描述 + '+' + str( self.黑鸦词条[i][2]) + '%' if self.黑鸦词条[0][0] == 1 and self.黑鸦武器择优模式 == 1 and self.变换词条[0][1] != 0: self.技能等级加成('所有', 50, 50, 2) self.技能等级加成('所有', 85, 85, 2) self.技能等级加成('所有', 100, 100, 2) def 黑鸦词条变更(self, 变换词条, 增减=1): # print(变换词条) if 变换词条[0] == 6: 黑鸦武器属性列表[变换词条[0]].加成属性(self, 增减 * 变换词条[1]) else: 黑鸦武器属性列表[变换词条[0]].加成属性(self, 增减 * 变换词条[1] / 100) # endregion # region 功能函数 def 装备检查(self, 装备名称): for i in self.装备栏: if i == 装备名称: return True return False def 切装判断(self): for i in self.装备切装: if i != '无': return True return False def 装备替换(self): Q = deepcopy(self) P = deepcopy(self) temp = list(P.装备栏) for i in range(12): if P.装备切装[i] != '无': temp[i] = P.装备切装[i] P.装备栏 = tuple(temp) P.适用套装计算() P.武器类型 = equ.get_equ_by_name(P.装备栏[11]).类型 P.力量 += P.切装修正[0] P.智力 += P.切装修正[1] P.物理攻击力 += P.切装修正[2] P.魔法攻击力 += P.切装修正[3] P.独立攻击力 += P.切装修正[4] P.所有属性强化加成(P.切装修正[5]) return [Q, P] def 三觉屏蔽1(self): if self.屏蔽三觉 == True: for i in self.技能栏: if i.所在等级 >= 95: if i.所在等级 == 95 and i.是否主动 == 0: self.超卓之心等级 = i.等级 - 3 else: i.倍率 = 0 def 三觉屏蔽2(self): if self.屏蔽三觉 == True: temp = None for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 *= 1.045 + 0.005 * self.超卓之心等级 if j.所在等级 == 100: temp = j self.技能栏[self.技能序号[self.觉醒之抉择技能]].被动倍率 *= 1.1 + 0.05 * temp.等级 # endregion class 角色窗口(窗口): def __init__(self): super().__init__() # region 界面分页 def 界面(self): count = 0 for i in self.角色属性A.技能栏: if i.是否有伤害 == 1: count += 1 self.窗口高度 = max(55 + 30 * count, 680) self.setFixedSize(1120, 680) self.输出背景图片 = QPixmap(trans('./ResourceFiles/img/输出背景.png')) self.职业存档 = [] super().界面() def 界面1(self): super().界面1() # increase_counter(ga_category="carry界面", name="界面/选择/打造") for i in 称号列表: self.称号.addItem(trans(i.显示名称), i.名称) for i in 宠物列表: self.宠物.addItem(trans(i.显示名称), i.名称) 标签 = QLabel(trans('装备条件设置'), self.main_frame1) 标签.move(940, 5) 标签.resize(170, 20) 标签.setAlignment(Qt.AlignCenter) 标签.setStyleSheet(标签样式) self.装备条件选择.clear() self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems(['角色熟练度：英雄', '角色熟练度：传说']) self.装备条件选择.append(MyQComboBox(self.main_frame1)) for i in range(0, 7): self.装备条件选择[-1].addItem(trans('{技能栏空位}：$value', value=i)) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems( trans([ '命运的抉择：数学期望', '命运的抉择：黄字+10%', '命运的抉择：暴伤+10%', '命运的抉择：终伤+10%', '命运的抉择：三攻+10%', '命运的抉择：技攻+10%' ])) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems( trans([ '骰子：数学期望', '骰子：1点', '骰子：2点', '骰子：3点', '骰子：4点', '骰子：5点', '骰子：6点' ])) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems( trans([ '悲剧的残骸：数学期望', '悲剧的残骸：HP高于70%', '悲剧的残骸：HP70-30%', '悲剧的残骸：HP低于30%' ])) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems( trans( ['先知者预言：数学期望', '先知者预言：属白+5%', '先知者预言：技攻+10%', '先知者预言：技攻+15%'])) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems( trans(['贫瘠沙漠的遗产：无', '贫瘠沙漠的遗产：霸体', '贫瘠沙漠的遗产：无伤'])) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems( trans(['幸运三角：数学期望', '幸运三角：7效果', '幸运三角：77效果', '幸运三角：777效果'])) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems(['擎天战甲：过充电状态', '擎天战甲：过负荷状态']) self.装备条件选择.append(MyQComboBox(self.main_frame1)) for i in range(101): self.装备条件选择[-1].addItem(trans('{持续伤害适用}$value%', value=100 - i)) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems( trans([ '军神的隐秘遗产：120%以上', '军神的隐秘遗产：120-100%', '军神的隐秘遗产：100-80%', '军神的隐秘遗产：80-60%', '军神的隐秘遗产：60-40%', '军神的隐秘遗产：40%以下' ])) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems(['太极天帝剑：阳', '太极天帝剑：阴']) self.装备条件选择.append(MyQComboBox(self.main_frame1)) self.装备条件选择[-1].addItems(['{噙毒手套}：中毒', '{噙毒手套}：未中毒']) # self.装备条件选择.append(MyQComboBox(self.main_frame1)) # self.装备条件选择[-1].addItems(['绿色生命的面容：无', '绿色生命的面容：阴暗面']) for i in range(len(self.装备条件选择)): self.装备条件选择[i].resize(170, 20) self.装备条件选择[i].move(940, 30 + 28 * i) self.百变怪选项 = QCheckBox(trans('百变怪'), self.main_frame1) self.百变怪选项.move(660, 613) self.百变怪选项.resize(80, 24) self.百变怪选项.setToolTip('{}'.format( trans("仅在极速模式和套装模式下生效"))) self.百变怪选项.setStyleSheet(复选框样式) self.计算模式选择 = MyQComboBox(self.main_frame1) self.计算模式选择.addItems(['计算模式：极速模式', '计算模式：套装模式', '计算模式：单件模式']) self.计算模式选择.move(750, 613) self.计算模式选择.resize(235, 24) self.计算模式选择.setStyleSheet(下拉框样式) self.计算模式选择.setToolTip('{}'.format( trans( '极速模式：533和3332(散搭) (不含智慧产物)

套装模式：533、3332(散搭)和3233(双防具) (不含智慧产物)

单件模式：所有组合 (不含百变怪)' ))) self.最大使用线程数 = thread_num # 一键修正按钮添加 一键站街修正名称 = trans(['站街力智', '站街三攻', '站街属强']) for i in range(len(一键站街修正名称)): 名称 = QLabel(一键站街修正名称[i], self.main_frame1) 名称.setAlignment(Qt.AlignCenter) 名称.move(940 + i * 57, 394) 名称.resize(52, 25) 名称.setStyleSheet(标签样式) self.一键站街设置输入.append(QLineEdit(self.main_frame1)) self.一键站街设置输入[i].setAlignment(Qt.AlignCenter) self.一键站街设置输入[i].setStyleSheet(输入框样式) self.一键站街设置输入[i].resize(52, 22) self.一键站街设置输入[i].move(940 + i * 57, 424) 一键修正按钮 = QPushButton(trans('一键修正面板细节'), self.main_frame1) 一键修正按钮.clicked.connect(lambda state: self.一键修正(0)) 一键修正按钮.move(940, 450) 一键修正按钮.resize(166, 25) 一键修正按钮.setStyleSheet(按钮样式) # self.单套择优方式选项 = MyQComboBox(self.main_frame1) # self.单套择优方式选项.move(940, 30 + 28 * 12) # self.单套择优方式选项.resize(170,20) # self.单套择优方式选项.addItem('单套择优方式：局部择优') # self.单套择优方式选项.addItem('单套择优方式：全局择优') # self.单套择优方式选项.setToolTip('排行榜及自选采用局部择优方式\n该选项仅适用于查看详情\n局部择优与全局择优大多数情况下一致\n少数情况下会有0.1%不到的差距') x = 1006 y = 485 宽度 = 100 高度 = 20 间隔 = 4 self.红色宠物装备 = QCheckBox(trans('宠物装备择优'), self.main_frame1) self.红色宠物装备.move(x, y) self.红色宠物装备.resize(宽度, 高度) self.红色宠物装备.setStyleSheet(复选框样式) self.红色宠物装备.setToolTip('{}'.format( trans('7%黄字,8%力智,8%白字,8%三攻取最高值'))) self.红色宠物装备.stateChanged.connect(lambda state: self.下拉框禁用( self.红色宠物装备, self.细节选项输入[0][11], 下拉框样式_detail)) self.光环自适应 = QCheckBox(trans('光环词条择优'), self.main_frame1) self.光环自适应.move(x, y + (高度 + 间隔) * 1) self.光环自适应.resize(宽度, 高度) self.光环自适应.setStyleSheet(复选框样式) self.光环自适应.setToolTip('{}'.format( trans('5%黄字，5%暴伤，5%三攻取最高值'))) self.光环自适应.stateChanged.connect(lambda state: self.下拉框禁用( self.光环自适应, self.细节选项输入[1][13], 下拉框样式_detail)) self.禁用存档 = QCheckBox(trans('禁用自动存档'), self.main_frame1) self.禁用存档.move(x, y + (高度 + 间隔) * 2) self.禁用存档.resize(宽度, 高度) self.禁用存档.setStyleSheet(复选框样式) self.神话排名选项 = QCheckBox(trans('神话排名模式'), self.main_frame1) self.神话排名选项.move(x, y + (高度 + 间隔) * 3) self.神话排名选项.resize(宽度, 高度) self.神话排名选项.setToolTip('{}'.format( trans('仅显示有神话的组合，且每件神话装备只会出现一次'))) self.神话排名选项.setStyleSheet(复选框样式) self.显示选项 = QCheckBox(trans('亿为单位显示'), self.main_frame1) self.显示选项.move(x, y + (高度 + 间隔) * 4) self.显示选项.resize(宽度, 高度) self.显示选项.setStyleSheet(复选框样式) x = 910 y = 485 宽度 = 90 高度 = 20 间隔 = 4 重置按钮 = QPushButton(trans('全局重置'), self.main_frame1) 重置按钮.clicked.connect(lambda state: self.全局重置()) 重置按钮.move(x, y) 重置按钮.resize(宽度, 高度) 重置按钮.setStyleSheet(按钮样式) self.线程数选择 = MyQComboBox(self.main_frame1) self.线程数选择.move(x, y + (高度 + 间隔) * 1) self.线程数选择.resize(宽度, 高度) for i in range(thread_num, 0, -1): self.线程数选择.addItem(trans('{进程}:$value', value=i)) if thread_num > 1: self.线程数选择.setCurrentIndex(1) self.存档选择 = MyQComboBox(self.main_frame1) self.存档选择.move(x, y + (高度 + 间隔) * 2) self.存档选择.resize(宽度, 高度) self.存档选择.currentIndexChanged.connect(lambda state: self.存档更换()) self.智慧产物限制 = MyQComboBox(self.main_frame1) self.智慧产物限制.move(x, y + (高度 + 间隔) * 3) self.智慧产物限制.resize(宽度, 高度) for i in range(1, 12): self.智慧产物限制.addItem(trans('改造≤$件').format(i)) self.智慧产物限制.setCurrentIndex(2) self.智慧产物限制.setToolTip('{}'.format( trans('不计智慧产物武器以及轮回SS'))) self.攻击属性选项 = MyQComboBox(self.main_frame1) self.攻击属性选项.move(x, y + (高度 + 间隔) * 4) self.攻击属性选项.resize(宽度, 高度) self.攻击属性选项.addItems(format_range('攻击属性:{}', ['全', '火', '冰', '光', '暗'])) def 界面2(self): # 第二个布局界面 # increase_counter(ga_category="carry界面", name="技能/符文/药剂") # 技能等级、TP、次数输入、宠物次数 self.BUFF输入 = QLineEdit(self.main_frame2) self.时间输入 = MyQComboBox(self.main_frame2) self.护石栏 = [] for i in range(3): self.护石栏.append(MyQComboBox(self.main_frame2)) self.符文 = [] self.符文效果 = [] self.觉醒选择状态 = 2 self.等级调整 = [] self.TP输入 = [] self.次数输入 = [] self.宠物次数 = [] self.奶量buff输入 = [] if 切装模式 == 1: self.技能切装 = [] count = 0 for i in self.角色属性A.技能栏: i.等级 = i.基础等级 self.等级调整.append(MyQComboBox(self.main_frame2)) self.等级调整[count].currentIndexChanged.connect( lambda state, index=count: self.等级调整标注(index)) count += 1 if i.是否有伤害 == 1 and i.TP上限 != 0: self.TP输入.append(MyQComboBox(self.main_frame2)) else: self.TP输入.append('') if i.是否有伤害 == 1: self.次数输入.append(MyQComboBox(self.main_frame2)) self.宠物次数.append(MyQComboBox(self.main_frame2)) if 切装模式 == 1: temp = QCheckBox(self.main_frame2) temp.setStyleSheet(复选框样式) # temp.setStyleSheet("QCheckBox:{background-color:transparent}") self.技能切装.append(temp) else: self.次数输入.append('') self.宠物次数.append('') if 切装模式 == 1: self.技能切装.append('') for i in self.角色属性A.技能栏: 序号 = self.角色属性A.技能序号[i.名称] if i.所在等级 == 50 or i.所在等级 == 85: for j in range(i.等级上限 - i.基础等级 + 1): self.等级调整[序号].addItem(str(j)) else: for j in range(-i.基础等级, i.等级上限 - i.基础等级 + 1): self.等级调整[序号].addItem(str(j)) if i.是否有伤害 == 1 and i.TP上限 != 0: for j in range(i.TP上限 + 1): self.TP输入[序号].addItem(str(j)) if i.是否有伤害 == 1: self.次数输入[序号].setMaxVisibleItems(15) self.次数输入[序号].addItem('/CD') self.宠物次数[序号].setMaxVisibleItems(15) for j in range(11): self.次数输入[序号].addItem(str(j)) self.宠物次数[序号].addItem(str(j)) self.次数输入[序号].addItem('填写') self.次数输入[序号].activated.connect( lambda state, index=序号: self.次数输入填写(index)) self.宠物次数[序号].addItem('填写') self.宠物次数[序号].activated.connect( lambda state, index=序号: self.宠物次数填写(index)) # 三觉强化选择 self.一觉遮罩透明度 = QGraphicsOpacityEffect() self.一觉遮罩透明度.setOpacity(0.5) self.二觉遮罩透明度 = QGraphicsOpacityEffect() self.二觉遮罩透明度.setOpacity(0.0) 横坐标 = 10 纵坐标 = 0 横坐标偏移量 = 60 纵坐标偏移量 = 30 词条框宽度 = 48 行高 = 20 counter = 0 for i in trans(["契约满级", "等级调整", "TP等级", "释放次数", "宠物次数"]): x = QLabel(i, self.main_frame2) x.move(横坐标 + 横坐标偏移量 - 30 + 50 * counter, 纵坐标 + 5) x.setStyleSheet(标签样式) counter += 1 纵坐标 += 20 skill_sort = self.技能列表显示排序(self.角色属性A.技能栏) for i in skill_sort: if i.是否有伤害 == 1: x = QLabel(self.main_frame2) x.setPixmap(self.技能图片[self.角色属性A.技能序号[i.名称]]) x.resize(28, 28) tempstr = trans( '{$name}
', name=i.名称) if i.备注 is not None and i.备注 != '': tempstr += trans('{$value}
', value=i.备注) else: tempstr += '' tempstr += trans('{所在等级}：$level
', level=i.所在等级) tempstr += trans('{等级上限}：$limit', limit=i.等级上限) if i.是否主动 == 1: tempstr += trans('
{百分比}：$value%', value=int(i.等效百分比(self.角色属性A.武器类型))) if i.TP上限 != 0: tempstr += trans('
{TP成长}：$value', value=to_percent(i.TP成长)) tempstr += trans('
{TP上限}：$value', value=i.TP上限) tempstr += '' x.setToolTip(tempstr) x.move(横坐标, 纵坐标 + 7) 横坐标 += 40 x = QLabel('Lv' + str(i.基础等级), self.main_frame2) x.resize(40, 28) x.move(横坐标, 纵坐标 + 7) x.setStyleSheet(标签样式) 横坐标 += 40 self.等级调整[self.角色属性A.技能序号[i.名称]].resize(词条框宽度, 行高) self.等级调整[self.角色属性A.技能序号[i.名称]].move(横坐标, 纵坐标 + 10) 横坐标 -= 80 纵坐标 += 纵坐标偏移量 横坐标 = 横坐标 + 80 + 50 纵坐标 = 30 for i in skill_sort: if i.是否有伤害 == 1: if i.TP上限 != 0: self.TP输入[self.角色属性A.技能序号[i.名称]].resize(词条框宽度, 行高) self.TP输入[self.角色属性A.技能序号[i.名称]].move(横坐标, 纵坐标) 纵坐标 += 纵坐标偏移量 横坐标 = 横坐标 + 50 纵坐标 = 30 for i in skill_sort: if i.是否有伤害 == 1: self.次数输入[self.角色属性A.技能序号[i.名称]].resize(词条框宽度, 行高) self.次数输入[self.角色属性A.技能序号[i.名称]].move(横坐标, 纵坐标) self.宠物次数[self.角色属性A.技能序号[i.名称]].resize(词条框宽度, 行高) self.宠物次数[self.角色属性A.技能序号[i.名称]].move(横坐标 + 50, 纵坐标) if 切装模式 == 1: self.技能切装[self.角色属性A.技能序号[i.名称]].move( 横坐标 + 55 + 词条框宽度, 纵坐标 + 5) 纵坐标 += 纵坐标偏移量 横坐标 = 横坐标 + 130 纵坐标 = 20 for i in skill_sort: if i.是否有伤害 == 0: x = QLabel(self.main_frame2) x.setPixmap(self.技能图片[self.角色属性A.技能序号[i.名称]]) x.resize(28, 28) tempstr = trans( '{$name}
', name=i.名称) if i.备注 is not None and i.备注 != '': tempstr += trans('{$value}
', value=i.备注) else: tempstr += '' tempstr += trans('{所在等级}：$level
', level=i.所在等级) tempstr += trans('{等级上限}：$limit', limit=i.等级上限) tempstr += '' x.setToolTip(tempstr) x.move(横坐标, 纵坐标 + 7) 横坐标 += 40 x = QLabel('Lv' + str(i.基础等级), self.main_frame2) x.resize(40, 28) x.move(横坐标, 纵坐标 + 7) x.setStyleSheet(标签样式) 横坐标 += 40 self.等级调整[self.角色属性A.技能序号[i.名称]].resize(词条框宽度, 行高) self.等级调整[self.角色属性A.技能序号[i.名称]].move(横坐标, 纵坐标 + 10) 横坐标 -= 80 纵坐标 += 纵坐标偏移量 x = 横坐标 + 20 y = 纵坐标 + 60 self.觉醒选择 = QLabel(self.main_frame2) self.觉醒选择.setPixmap(QPixmap('./ResourceFiles/img/觉醒选择.png')) self.觉醒选择.resize(120, 100) self.觉醒选择.move(x, y - 20) self.BUFF = QLabel(self.main_frame2) self.BUFF.setPixmap( QPixmap('./ResourceFiles/' + self.角色属性A.实际名称 + "/技能/BUFF.png")) self.BUFF.resize(28, 28) self.BUFF.move(x - 2, y - 40) self.BUFF.setToolTip( trans('{最高值参考}：$value', value=to_percent(self.角色属性A.主BUFF - 1))) self.BUFF输入.setText(str('%.1f' % ((self.角色属性A.主BUFF - 1) * 100))) self.BUFF输入.resize(50, 25) self.BUFF输入.move(x + 38, y - 38) self.BUFF输入.setStyleSheet(输入框样式) self.BUFF输入.setAlignment(Qt.AlignCenter) self.一觉图片 = QLabel(self.main_frame2) self.一觉图片.setPixmap(self.技能图片[self.一觉序号]) self.一觉图片.resize(28, 28) self.一觉图片.move(x + 7, y + 8) self.二觉图片 = QLabel(self.main_frame2) self.二觉图片.setPixmap(self.技能图片[self.二觉序号]) self.二觉图片.resize(28, 28) self.二觉图片.move(x + 52, y + 8) self.一觉遮罩 = QPushButton(self.main_frame2) self.一觉遮罩.resize(38, 50) self.一觉遮罩.move(x + 2, y + 5) self.一觉遮罩.setStyleSheet( "QPushButton{background-color:rgb(0,0,0);border:1px;border-radius:3px;}" ) self.一觉遮罩.setGraphicsEffect(self.一觉遮罩透明度) self.一觉遮罩.clicked.connect(lambda state, index=1: self.强化觉醒选择(index)) self.二觉遮罩 = QPushButton(self.main_frame2) self.二觉遮罩.resize(38, 50) self.二觉遮罩.move(x + 47, y + 5) self.二觉遮罩.setStyleSheet( "QPushButton{background-color:rgb(0,0,0);border:1px;border-radius:3px;}" ) self.二觉遮罩.setGraphicsEffect(self.二觉遮罩透明度) self.二觉遮罩.clicked.connect(lambda state, index=2: self.强化觉醒选择(index)) for i in range(3): self.护石栏[i].addItems(self.护石选项) self.护石类型选项 = [] for i in range(9): self.符文.append(MyQComboBox(self.main_frame2)) self.符文[i].addItems(self.符文选项) self.符文效果.append(MyQComboBox(self.main_frame2)) self.符文效果[i].addItems(符文效果选项) 横坐标 = 480 纵坐标 = 20 行高 = 18 x = QLabel(trans("{护石}Ⅰ"), self.main_frame2) x.move(横坐标, 纵坐标) x.setStyleSheet(标签样式) y = MyQComboBox(self.main_frame2) y.move(横坐标 + 65, 纵坐标) y.resize(65, 行高) self.护石类型选项.append(y) 纵坐标 += 21 self.护石栏[0].move(横坐标, 纵坐标) self.护石栏[0].resize(130, 行高) self.护石栏[0].currentIndexChanged.connect( lambda state, index=0: self.护石类型选项更新(index)) 纵坐标 += 25 for i in range(3): tempstr = trans("{符文}$value{选择}：", value=i + 1) x = QLabel(tempstr, self.main_frame2) x.move(横坐标, 纵坐标) x.setStyleSheet(标签样式) 纵坐标 += 21 self.符文[i].move(横坐标, 纵坐标) self.符文[i].resize(130, 行高) self.符文[i].activated.connect( lambda state, index=i: self.符文技能更改(index)) 纵坐标 += 21 self.符文效果[i].move(横坐标, 纵坐标) self.符文效果[i].resize(130, 行高) self.符文效果[i].activated.connect( lambda state, index=i: self.符文效果更改(index)) 纵坐标 += 25 横坐标 = 650 纵坐标 = 20 x = QLabel(trans("{护石}Ⅱ"), self.main_frame2) x.move(横坐标, 纵坐标) x.setStyleSheet(标签样式) y = MyQComboBox(self.main_frame2) y.move(横坐标 + 65, 纵坐标) y.resize(65, 行高) self.护石类型选项.append(y) 纵坐标 += 21 self.护石栏[1].move(横坐标, 纵坐标) self.护石栏[1].resize(130, 行高) self.护石栏[1].currentIndexChanged.connect( lambda state, index=1: self.护石类型选项更新(index)) 纵坐标 += 25 for i in range(3, 6): tempstr = trans("{符文}$value{选择}：", value=i + 1) x = QLabel(tempstr, self.main_frame2) x.move(横坐标, 纵坐标) x.setStyleSheet(标签样式) 纵坐标 += 21 self.符文[i].move(横坐标, 纵坐标) self.符文[i].resize(130, 行高) 纵坐标 += 21 self.符文效果[i].move(横坐标, 纵坐标) self.符文效果[i].resize(130, 行高) 纵坐标 += 25 横坐标 = 820 纵坐标 = 20 x = QLabel(trans("{护石}Ⅲ"), self.main_frame2) x.move(横坐标, 纵坐标) x.setStyleSheet(标签样式) y = MyQComboBox(self.main_frame2) y.move(横坐标 + 65, 纵坐标) y.resize(65, 行高) self.护石类型选项.append(y) 纵坐标 += 21 self.护石栏[2].move(横坐标, 纵坐标) self.护石栏[2].resize(130, 行高) self.护石栏[2].currentIndexChanged.connect( lambda state, index=2: self.护石类型选项更新(index)) 纵坐标 += 25 for i in range(6, 9): tempstr = trans("{符文}$value{选择}：", value=i + 1) x = QLabel(tempstr, self.main_frame2) x.move(横坐标, 纵坐标) x.setStyleSheet(标签样式) 纵坐标 += 21 self.符文[i].move(横坐标, 纵坐标) self.符文[i].resize(130, 行高) 纵坐标 += 21 self.符文效果[i].move(横坐标, 纵坐标) self.符文效果[i].resize(130, 行高) 纵坐标 += 25 for i in range(3): self.护石类型选项[i].addItem('魔界') self.护石类型选项[i].addItem('圣痕') self.护石类型选项[i].currentIndexChanged.connect( lambda state, index=i: self.护石描述更新(index)) self.复选框列表 = [] self.复选框列表list = [] for i in 选项设置列表: if (觉醒开关 == 0 or "·" not in self.初始属性.实际名称) and i.名称 == '屏蔽三觉': continue self.复选框列表.append(QCheckBox(trans(i.名称), self.main_frame2)) self.复选框列表list.append(i.名称) 奶量buff力智label = QLabel(trans("奶量buff力智"), self.main_frame2) 奶量buff力智label.setStyleSheet(标签样式) 奶量buff力智label.setAlignment(Qt.AlignCenter) 偏移 = (35 if self.初始属性.远古记忆 != -1 else 0) + (35 if self.初始属性.刀魂之卡赞 != -1 else 0) + 35 奶量buff力智label.move(970, 24 + counter * 80 + 10 + 偏移) 奶量buff力智输入框 = QLineEdit(self.main_frame2) 奶量buff力智输入框.setStyleSheet(文本框样式黄) 奶量buff力智输入框.move(1050, 21 + counter * 80 + 10 + 偏移) 奶量buff力智输入框.resize(50, 20) self.奶量buff输入.append(奶量buff力智输入框) 奶量buff三攻label = QLabel(trans("奶量buff三攻"), self.main_frame2) 奶量buff三攻label.setStyleSheet(标签样式) 奶量buff三攻label.setAlignment(Qt.AlignCenter) 奶量buff三攻label.move(970, 24 + counter * 80 + 40 + 偏移) 奶量buff三攻输入框 = QLineEdit(self.main_frame2) 奶量buff三攻输入框.setStyleSheet(文本框样式黄) 奶量buff三攻输入框.move(1050, 15 + counter * 80 + 45 + 偏移) 奶量buff三攻输入框.resize(50, 20) self.奶量buff输入.append(奶量buff三攻输入框) counter = 0 for i in self.复选框列表: i.setStyleSheet(复选框样式) i.resize(125, 20) i.move(980, 10 + counter * 24) if counter < 7 and 调试开关 == 0: i.setChecked(True) counter += 1 sign = 0 if self.初始属性.远古记忆 != -1: i = QLabel(self.main_frame2) i.setPixmap(QPixmap('./ResourceFiles/img/远古记忆.png')) i.resize(28, 28) i.move(1000, 15 + counter * 24) self.远古记忆 = MyQComboBox(self.main_frame2) self.远古记忆.currentIndexChanged.connect( lambda state, index=100: self.等级调整标注(index)) for i in range(12): self.远古记忆.addItem(str(i)) self.远古记忆.resize(50, 20) self.远古记忆.move(1035, 19 + counter * 24) sign = 30 if self.初始属性.刀魂之卡赞 != -1: i = QLabel(self.main_frame2) i.setPixmap(QPixmap('./ResourceFiles/img/刀魂之卡赞.png')) i.resize(28, 28) i.move(1000, 15 + sign + counter * 24) self.刀魂之卡赞 = MyQComboBox(self.main_frame2) self.刀魂之卡赞.currentIndexChanged.connect( lambda state, index=200: self.等级调整标注(index)) for i in range(12): self.刀魂之卡赞.addItem(str(i)) self.刀魂之卡赞.resize(50, 20) self.刀魂之卡赞.move(1035, 19 + sign + counter * 24) x = QLabel(trans("{攻击目标}："), self.main_frame2) x.move(660, self.height() - 62) x.resize(70, 20) x.setStyleSheet(标签样式) self.攻击目标 = MyQComboBox(self.main_frame2) for i in 攻击目标: self.攻击目标.addItem(i[0]) self.攻击目标.move(730, self.height() - 63) self.攻击目标.resize(110, 20) x = QLabel(trans("{时间输入}："), self.main_frame2) x.move(850, self.height() - 62) x.resize(70, 20) x.setStyleSheet(标签样式) self.时间输入.addItems( ['1', '10', '15', '20', '25', '30', '45', '50', '60']) self.时间输入.setEditable(True) self.时间输入.move(920, self.height() - 63) self.时间输入.resize(50, 20) self.技能存档选择 = MyQComboBox(self.main_frame2) self.技能存档选择.move(990, self.height() - 105) self.技能存档选择.resize(110, 20) self.技能存档选择.currentIndexChanged.connect(lambda state: self.技能存档更换()) self.计算按钮2 = QPushButton(trans('开始计算'), self.main_frame2) self.计算按钮2.clicked.connect(lambda state: self.计算()) self.计算按钮2.move(990, self.height() - 70) self.计算按钮2.resize(110, 30) self.计算按钮2.setStyleSheet(按钮样式) def 界面3(self): # increase_counter(ga_category="carry界面", name="基础/细节/修正") # 第三个布局界面 self.属性设置输入 = [] self.细节选项输入 = [] self.列名称 = [] self.行名称 = [] 名称 = QLabel(trans(表头名称1), self.main_frame3) 名称.setAlignment(Qt.AlignCenter) 名称.setStyleSheet(标签样式) 名称.resize(80, 25) 名称.move(10, 文本框间隔) m = -1 for i in 列名称1: m += 1 名称 = QLabel(trans(i), self.main_frame3) 名称.setAlignment(Qt.AlignCenter) 名称.setStyleSheet(标签样式) if i == "选项": 名称.resize(文本框宽度 * 2 + 5, 25) else: 名称.resize(文本框宽度, 25) 名称.move(95 + m * (文本框宽度 + 5), 文本框间隔) self.列名称.append(i) n = -1 for j in 行名称1.keys(): n += 1 名称 = QLabel(trans(j), self.main_frame3) 名称.setAlignment(Qt.AlignCenter) if 行名称1[j] == 1: 名称.setStyleSheet(标签样式_2) else: 名称.setStyleSheet(标签样式) 名称.resize(80, 25) 名称.move(10, 文本框间隔 + 30 + n * 30) self.行名称.append(j) m = -1 for i in 列名称1: m += 1 templist = [] n = -1 for j in 行名称1.keys(): n += 1 if i == "选项": templist.append(MyQComboBox(self.main_frame3)) templist[n].resize(文本框宽度 * 2 + 5, 22) templist[n].setStyleSheet(下拉框样式_detail) if 行1选项[j][0] != -1: templist[n].addItem('无') for s_id in 行1选项[j]: templist[n].addItem(细节选项列表[s_id].描述) else: templist[n].setDisabled(True) else: templist.append(QLineEdit(self.main_frame3)) if 行名称1[j] == 1: templist[n].setStyleSheet(文本框样式黄) else: templist[n].setStyleSheet(文本框样式白) templist[n].resize(文本框宽度, 22) templist[n].setAlignment(Qt.AlignCenter) templist[n].move(95 + m * (文本框宽度 + 5), 文本框间隔 + 30 + n * 30 + 2) if i == "选项": self.细节选项输入.append(templist) else: self.属性设置输入.append(templist) 名称 = QLabel(trans(表头名称2), self.main_frame3) 名称.setAlignment(Qt.AlignCenter) 名称.setStyleSheet(标签样式) 名称.resize(80, 25) 名称.move(160 + (len(列名称1) + 1) * 文本框宽度, 文本框间隔) m = -1 for i in 列名称2: m += 1 名称 = QLabel(trans(i), self.main_frame3) 名称.setAlignment(Qt.AlignCenter) 名称.setStyleSheet(标签样式) if i == "技能": 名称.resize(155, 25) elif i == "选项": 名称.resize(文本框宽度 * 2 + 5, 25) else: 名称.resize(文本框宽度, 25) 名称.move(245 + (len(列名称1) + 1) * 文本框宽度 + m * (文本框宽度 + 5), 文本框间隔) self.列名称.append(trans(i)) if i == "选项": m += 1 n = -1 for j in 行名称2.keys(): n += 1 名称 = QLabel(trans(j), self.main_frame3) 名称.setAlignment(Qt.AlignCenter) if 行名称2[j] == 1: 名称.setStyleSheet(标签样式_2) else: 名称.setStyleSheet(标签样式) 名称.resize(80, 25) 名称.move(160 + (len(列名称1) + 1) * 文本框宽度, 文本框间隔 + 30 + n * 30) self.行名称.append(trans(j)) count = len(self.细节选项输入) m = -1 for i in 列名称2: m += 1 templist = [] n = -1 for j in 行名称2.keys(): n += 1 if i == "选项": templist.append(MyQComboBox(self.main_frame3)) templist[n].resize(文本框宽度 * 2 + 5, 22) templist[n].setStyleSheet(下拉框样式_detail) if 行2选项[j][0] != -1: templist[n].addItem('无') templist[n].setPlaceholderText("增伤词条选择") templist[n].currentIndexChanged.connect( lambda state, index=templist[n]: self.细节增伤选项颜色更新( index)) for s_id in 行2选项[j]: templist[n].addItem(细节选项列表[s_id].描述) else: templist[n].setDisabled(True) elif i == "技能": templist.append(MyQComboBox(self.main_frame3)) templist[n].resize(155, 22) templist[n].setStyleSheet(下拉框样式_detail) cur = 行2技能[j][0] if cur == -1: templist[n].setDisabled(True) pass elif cur in [100, 999]: templist[n].addItem('无') if cur == 999: skills = [ i.名称 for i in self.角色属性A.技能栏 if i.所在等级 <= 85 ] else: skills = [ i.名称 for i in self.角色属性A.技能栏 if i.所在等级 <= 70 and i.所在等级 not in [48, 50] ] if self.角色属性A.实际名称 == '极诣·黑暗武士': skills.append('幽魂剑') if self.角色属性A.实际名称 == '知源·缔造者': skills.append('末日虫洞') for skill_name in skills: templist[n].addItem( trans('{$name}Lv+1', name=skill_name), skill_name + "Lv+1") else: templist[n].addItem('无') for s_id in 行2技能[j]: templist[n].addItem(细节选项列表[s_id].描述) else: templist.append(QLineEdit(self.main_frame3)) if 行名称2[j] == 1: templist[n].setStyleSheet(文本框样式黄) else: templist[n].setStyleSheet(文本框样式白) templist[n].resize(文本框宽度, 22) templist[n].setAlignment(Qt.AlignCenter) templist[n].move( 245 + (len(列名称1) + 1) * 文本框宽度 + m * (文本框宽度 + 5), 文本框间隔 + 30 + n * 30 + 2) if i in ["选项", "技能"]: self.细节选项输入.append(templist) m += 1 else: self.属性设置输入.append(templist) self.修正列表名称 = [ trans('力智') + '%', trans('三攻') + '%', trans('黄字'), trans('白字'), trans('属白'), trans('暴伤'), trans('终伤'), trans('技攻') ] 距离 = 30 templist = [] for i in range(len(self.修正列表名称)): 名称 = QLabel(self.修正列表名称[i], self.main_frame3) 名称.setAlignment(Qt.AlignCenter) 名称.setStyleSheet(标签样式) 名称.resize(50, 25) 名称.move(距离 + i * 55, 570) templist.append(QLineEdit(self.main_frame3)) templist[i].setAlignment(Qt.AlignCenter) templist[i].setStyleSheet(文本框样式白) templist[i].resize(50, 22) templist[i].move(距离 + i * 55, 610) self.属性设置输入.append(templist) count = 0 self.时装选项 = [] for i in ['头部', '帽子', '脸部', '胸部', '上衣', '腰带', '下装', '鞋']: 名称 = QLabel(trans(i), self.main_frame3) 名称.setAlignment(Qt.AlignCenter) 名称.setStyleSheet(标签样式) 名称.resize(50, 25) 名称.move(520 + count * 55, 570) self.时装选项.append(MyQComboBox(self.main_frame3)) self.时装选项[count].setStyleSheet(下拉框样式_detail) self.时装选项[count].addItems(['高级', '节日', '稀有', '神器']) self.时装选项[count].resize(50, 22) self.时装选项[count].move(520 + count * 55, 610) self.时装选项[count].currentIndexChanged.connect( lambda state, index=count: self.时装选项更新(index)) count += 1 self.时装选项.append(MyQComboBox(self.main_frame3)) self.时装选项[8].setStyleSheet(下拉框样式_detail) self.时装选项[8].addItems([ trans('高级套装') + '[8]', trans('节日套装') + '[8]', trans('稀有套装') + '[8]', trans('神器套装') + '[8]' ]) self.时装选项[8].resize(100, 22) self.时装选项[8].move(990, 570) self.时装选项[8].currentIndexChanged.connect( lambda state, index=8: self.时装选项更新(index)) self.计算按钮3 = QPushButton(trans('开始计算'), self.main_frame3) self.计算按钮3.clicked.connect(lambda state: self.计算()) self.计算按钮3.move(990, 610) self.计算按钮3.resize(110, 30) self.计算按钮3.setStyleSheet(按钮样式) def 界面5(self): # increase_counter(ga_category="carry界面", name="自选装备计算") # 第五个布局 标签 = QLabel(trans('单件选择'), self.main_frame5) 标签.setAlignment(Qt.AlignCenter) 标签.setStyleSheet(标签样式) 标签.resize(240, 25) 标签.move(70, 20) 标签 = QLabel(trans('锁定'), self.main_frame5) 标签.setAlignment(Qt.AlignCenter) 标签.setStyleSheet(标签样式) 标签.resize(70, 25) 标签.move(10, 20) self.图片显示 = [] count = 0 self.自选装备 = [] self.自选装备结果 = [] if 切装模式 == 1: self.装备切装 = [] self.切装修正属性 = [] self.装备锁定 = [] for i in 部位列表: 锁定选择 = QCheckBox(trans(i), self.main_frame5) 锁定选择.setStyleSheet(复选框样式) 锁定选择.resize(70, 22) 锁定选择.move(10, 50 + 30 * count) self.装备锁定.append(锁定选择) combo = MyQComboBox(self.main_frame5) combo.resize(220, 22) combo.move(90, 50 + 30 * count) combo.currentIndexChanged.connect( lambda state, index=count: self.自选装备更改(index)) if 切装模式 == 1: temp = QCheckBox(self.main_frame5) temp.setStyleSheet(复选框样式) self.装备切装.append(temp) self.装备切装[count].move(320, 55 + 30 * count) for j in equ.get_equ_list(): if j.部位 == i: if i == '武器': if j.类型 in self.角色属性A.武器选项: combo.addItem(j.名称) else: combo.addItem(j.名称) self.自选装备.append(combo) count += 1 if 切装模式 == 1: num = 0 for i in trans(['力量', '智力', '物攻', '魔攻', '独立', '属强']): 标签 = QLabel(i, self.main_frame5) 标签.setAlignment(Qt.AlignCenter) 标签.setStyleSheet(标签样式) 标签.resize(45, 25) 标签.move(30 + 50 * num, 60 + 30 * count) self.切装修正属性.append(QLineEdit(self.main_frame5)) self.切装修正属性[num].setAlignment(Qt.AlignCenter) self.切装修正属性[num].setStyleSheet(输入框样式) self.切装修正属性[num].resize(45, 22) self.切装修正属性[num].move(30 + 50 * num, 85 + 30 * count) num += 1 self.计算标识 = 1 横坐标 = 355 标签 = QLabel(trans('批量选择'), self.main_frame5) 标签.setAlignment(Qt.AlignCenter) 标签.setStyleSheet(标签样式) 标签.resize(160, 25) 标签.move(横坐标, 20) 套装类型 = ['防具', '首饰', '特殊', '上链左', '镯下右', '环鞋指'] count = 0 self.自选套装 = [] for i in 套装类型: 套装名称 = [] combo = MyQComboBox(self.main_frame5) for j in equ.get_suit_list(): if j.名称 not in 套装名称 and j.类型 == i: 套装名称.append(j.名称) combo.addItem(j.名称) combo.resize(160, 22) combo.move(横坐标, 50 + 30 * count) combo.activated.connect( lambda state, index=count: self.自选套装更改(index)) self.自选套装.append(combo) count += 1 self.神话部位选项 = MyQComboBox(self.main_frame5) self.神话部位选项.addItems(['神话部位：无', '神话部位：上衣', '神话部位：手镯', '神话部位：耳环']) self.神话部位选项.resize(160, 22) self.神话部位选项.move(横坐标, 50 + 30 * count) self.神话部位选项.activated.connect(lambda state: self.神话部位更改()) count += 1 self.改造套装 = MyQComboBox(self.main_frame5) for n in equ.get_equ_list(): try: self.改造套装.addItem(n.关联套装) except: pass self.改造套装.resize(160, 22) self.改造套装.move(横坐标, 50 + 30 * count) self.改造套装.activated.connect(lambda state: self.改造套装更改()) count += 1 self.转甲选项 = QCheckBox(trans('85SS转甲'), self.main_frame5) self.转甲选项.resize(80, 22) self.转甲选项.move(横坐标 + 40, 50 + 30 * count) self.转甲选项.setChecked(True) self.转甲选项.setStyleSheet(复选框样式) self.转甲选项.stateChanged.connect(lambda state: self.自选计算(1)) count += 1 # 一键修正按钮添加 一键站街修正名称 = trans(['站街力智', '站街三攻', '站街属强']) for i in range(len(一键站街修正名称)): 名称 = QLabel(一键站街修正名称[i], self.main_frame5) 名称.setAlignment(Qt.AlignCenter) 名称.move(横坐标 - 5 + i * 57, 50 + 30 * count) 名称.resize(52, 25) 名称.setStyleSheet(标签样式) self.一键站街设置输入.append(QLineEdit(self.main_frame5)) self.一键站街设置输入[i + 3].setAlignment(Qt.AlignCenter) self.一键站街设置输入[i + 3].setStyleSheet(输入框样式) self.一键站街设置输入[i + 3].resize(52, 22) self.一键站街设置输入[i + 3].move(横坐标 - 5 + i * 57, 80 + 30 * count) count += 2 一键修正按钮 = QPushButton(trans('一键修正面板细节'), self.main_frame5) 一键修正按钮.clicked.connect(lambda state: self.一键修正(1)) 一键修正按钮.move(横坐标 - 5, 50 + 30 * count) 一键修正按钮.resize(165, 25) 一键修正按钮.setStyleSheet(按钮样式) 标签 = QLabel(trans('辟邪玉提升率(理论值仅供参考)'), self.main_frame5) 标签.setAlignment(Qt.AlignCenter) 标签.setStyleSheet(标签样式) 标签.resize(200, 25) 标签.move(525, 20) self.辟邪玉提升率1 = [] self.辟邪玉提升率2 = [] count = 0 for i in 辟邪玉列表: if i.名称 != '无': if i.最大值 != 1: temp = trans(i.名称) + '+' + str(i.最大值) + '%' else: temp = trans(i.名称) + '+' + str(i.最大值) self.辟邪玉提升率1.append(QLabel(temp, self.main_frame5)) self.辟邪玉提升率1[count].setAlignment(Qt.AlignCenter) self.辟邪玉提升率1[count].setStyleSheet(标签样式) self.辟邪玉提升率1[count].resize(180, 25) self.辟邪玉提升率1[count].move(520, 50 + 30 * count) self.辟邪玉提升率2.append(QLabel('0.00%', self.main_frame5)) self.辟邪玉提升率2[count].setAlignment(Qt.AlignCenter) self.辟邪玉提升率2[count].setStyleSheet(标签样式) self.辟邪玉提升率2[count].resize(60, 25) self.辟邪玉提升率2[count].move(710, 50 + 30 * count) count += 1 初始x = 805 初始y = 20 图片显示 = QLabel(self.main_frame5) 图片显示.setPixmap(self.输出背景图片) 图片显示.setAlignment(Qt.AlignTop) 图片显示.resize(268, 546) 图片显示.move(初始x, 初始y + 11) 人物 = QLabel(self.main_frame5) 图片 = QPixmap('./ResourceFiles/' + self.角色属性A.实际名称 + "/人物.png") 人物.setPixmap(图片) 人物.move(初始x + 90 + int(45 - 图片.width() / 2), 初始y + 40) 人物.resize(90, 90) 人物.setAlignment(Qt.AlignTop) 偏移量 = 187 x坐标 = [ 32, 0, 0, 32, 0, 偏移量, 偏移量 + 32, 偏移量 + 32, 偏移量, 偏移量, 偏移量 + 32, 32 ] y坐标 = [0, 0, 32, 32, 64, 0, 0, 32, 64, 32, 64, 64] for i in range(12): self.图片显示.append(QLabel(self.main_frame5)) self.图片显示[i].setMovie( equ.get_img_by_name(self.自选装备[i].currentData())) self.图片显示[i].resize(26, 26) self.图片显示[i].move(初始x + 10 + x坐标[i], 初始y + 31 + y坐标[i]) self.图片显示[i].setAlignment(Qt.AlignCenter) self.面板显示 = [] for i in range(18): self.面板显示.append(QLabel(self.main_frame5)) self.面板布局设置(self.面板显示, 1) self.词条显示 = [] for i in range(12): self.词条显示.append(QLabel(self.main_frame5)) j = 312 + 初始y for i in self.词条显示: i.setStyleSheet("QLabel{font-size:12px;color:rgb(104,213,237)}") i.move(5 + 初始x, j) i.resize(180, 17) i.setAlignment(Qt.AlignLeft) j += 17 self.总伤害 = QLabel(self.main_frame5) self.总伤害.setStyleSheet("QLabel{color:rgb(255,255,255);font-size:25px}") self.总伤害.resize(250, 36) self.总伤害.move(10 + 初始x, 520 + 初始y) self.总伤害.setAlignment(Qt.AlignCenter) self.套装名称显示 = [] for i in range(13): self.套装名称显示.append(QLabel(self.main_frame5)) self.套装名称显示[i].move(114 + 初始x, 128 + 180 + 17 * i + 初始y) self.套装名称显示[i].resize(150, 18) self.套装名称显示[i].setAlignment(Qt.AlignCenter) self.打造显示 = [] for i in range(13): self.打造显示.append(QLabel(self.main_frame5)) self.打造显示[i].move(-100, -100) 自选计算按钮 = QPushButton(trans('查看详情'), self.main_frame5) 自选计算按钮.clicked.connect(lambda state: self.自选计算()) 自选计算按钮.move(995, 610) 自选计算按钮.resize(80, 28) 自选计算按钮.setStyleSheet(按钮样式) self.基准值 = [] 设置基准值 = QPushButton(trans('设为基准'), self.main_frame5) 设置基准值.clicked.connect(lambda state: self.基准值设置()) 设置基准值.move(900, 610) 设置基准值.resize(80, 28) 设置基准值.setStyleSheet(按钮样式) 清空基准值 = QPushButton(trans('清空基准'), self.main_frame5) 清空基准值.clicked.connect(lambda state: self.基准值设置(1)) 清空基准值.move(805, 610) 清空基准值.resize(80, 28) 清空基准值.setStyleSheet(按钮样式) self.对比格式 = QCheckBox(trans('数值对比'), self.main_frame5) self.对比格式.stateChanged.connect(lambda state: self.自选计算(1)) self.对比格式.move(615, 612) self.对比格式.resize(70, 24) self.对比格式.setStyleSheet(复选框样式) if 多语言开关 == 0: 名望设置 = QPushButton(trans('名望细节'), self.main_frame5) 名望设置.clicked.connect(lambda _: self.名望设置()) 名望设置.move(710, 610) 名望设置.resize(80, 28) 名望设置.setStyleSheet(按钮样式) def 名望设置(self): increase_counter(ga_category="carry详细功能使用", name="名望") def createClient(): store.set("/fame/temp/property", self) # 设置图标和背景 临时做法 store.const("/app/window/icon", self.icon) store.const("/app/window/background_image", self.主背景图片) store.watch("/fame/event/changed", lambda _, : self.自选计算(1)) client = 名望窗口() client.初始化() return client DefaultDialogRegister.showDialog("base_fame({})".format(type(self)), createClient, self) def 自选装备更改(self, index=0): try: self.图片显示[index].setMovie( equ.get_img_by_name(self.自选装备[index].currentData())) except: pass if self.初始属性.职业分类 == '输出': if self.当前页面 == 5 and self.计算标识 == 1: self.自选计算(1) else: if self.当前页面 == 4 and self.计算标识 == 1: self.自选计算(1) def 自选套装更改(self, index): self.计算标识 = 0 name = self.自选套装[index].currentData() for i in range(11): if self.装备锁定[i].isChecked(): continue x = -1 for j in equ.get_equ_list(): if j.部位 == 部位列表[i]: x += 1 if j.所属套装2 == name: self.自选装备[i].setCurrentIndex(x) break elif j.所属套装 == name and j.品质 != '神话': self.自选装备[i].setCurrentIndex(x) break self.计算标识 = 1 self.自选计算(1) def 界面6(self): # increase_counter(ga_category="carry界面", name="辟邪玉/希洛克/黑鸦/奥兹玛") 横坐标 = 10 纵坐标 = 0 标签 = QLabel(trans('辟邪玉计算 （鼠标悬停查看算法）'), self.main_frame6) 标签.setStyleSheet(标签样式 + 'QLabel{font-size:13px;}') 标签.resize(290, 20) 标签.move(横坐标 + 10, 纵坐标) 标签.setAlignment(Qt.AlignCenter) temp = '{}

'.format( trans('假定基础伤害为100，词条1=50%，词条2=50%：')) temp += trans('5%黄字增幅，佩戴前：200，佩戴后：205
') temp += trans('暴伤终伤白字属白力智三攻同上，黄字向下取整
') temp += trans('技攻辟邪玉加成等级技攻(歧路腰类)
不加成具体技能技攻(歧路鞋类)

') temp += trans( '3%技攻增幅，佩戴前：100*1.5*1.5=225
佩戴后：100*1.515*1.515=229.5225

' ) # temp += '附加、最终、百分力智增幅：宠物相关词条不享受加成
' temp += trans('属强增幅：唤醒(13)婚房(8)药剂和技能属强不享受加成
') temp += trans('进图触发属强单独计算向下取整

') temp += '{}'.format( trans( '属白增幅分对应属性，计算器未作区分
双属性附加(星之海)需手动计算并在第三页修正

计算方式仅供参考，请以实际游戏为准！' )) 标签.setToolTip(temp) self.辟邪玉选择 = [] self.辟邪玉数值 = [] for i in range(4): x = MyQComboBox(self.main_frame6) for j in 辟邪玉列表: x.addItem(j.名称) x.resize(200, 20) x.move(横坐标, 纵坐标 + (i + 1) * 25) x.currentIndexChanged.connect( lambda state, index=i: self.辟邪玉数值选项更新(index)) self.辟邪玉选择.append(x) y = MyQComboBox(self.main_frame6) y.resize(80, 20) y.move(横坐标 + 220, 纵坐标 + (i + 1) * 25) self.辟邪玉数值.append(y) 标签 = QLabel(trans('黑鸦遴选词条'), self.main_frame6) 标签.setStyleSheet(标签样式 + 'QLabel{font-size:13px;}') 标签.resize(300, 20) 标签.move(横坐标 + 10, 纵坐标 + 330 - 20) 标签.setAlignment(Qt.AlignCenter) 名称 = trans(['武　　器', '戒　　指', '辅助装备', '下　　装']) self.黑鸦词条 = [] for i in range(4): x = QLabel(名称[i], self.main_frame6) x.setStyleSheet(标签样式 + 'QLabel{font-size:13px;};text-align: justify;') # x.setStyleSheet('text-align: justify') x.resize(55, 20) x.move(横坐标, 纵坐标 - 145 + (i + 20) * 25 - 20) tem = [] tem.append(MyQComboBox(self.main_frame6)) tem[-1].setStyleSheet(下拉框样式) if i == 0: tem[0].addItems(['无', '计算最高', '自选数值', '自选数值-觉醒']) tem[0].resize(91, 20) tem[0].move(横坐标 + 60, 纵坐标 - 20 + 25 * (i + 15) - 20) tem[0].currentIndexChanged.connect( lambda state, index=i: self.黑鸦词条更新(index)) else: tem[0].addItems(['无', '计算最高', '自选数值']) tem[0].resize(91, 20) tem[0].move(横坐标 + 60, 纵坐标 - 20 + 25 * (i + 15) - 20) tem[0].currentIndexChanged.connect( lambda state, index=i: self.黑鸦词条更新(index)) tem.append(MyQComboBox(self.main_frame6)) tem[-1].setStyleSheet(下拉框样式) tem[1].resize(70, 20) tem[1].move(横坐标 + 161, 纵坐标 - 20 + 25 * (i + 15) - 20) # if i > 0: for item in 词条属性列表: tem[1].addItem(item.描述) # else: # for item in 黑鸦武器属性列表: # tem[1].addItem(item.描述) # tem[1].currentIndexChanged.connect(lambda state:self.黑鸦武器词条更新()) # tem[1].currentIndexChanged.connect(lambda state: self.希洛克武器词条更新()) tem.append(MyQComboBox(self.main_frame6)) tem[-1].setStyleSheet(下拉框样式) tem[2].resize(60, 20) tem[2].move(横坐标 + 241, 纵坐标 - 20 + 25 * (i + 15) - 20) if i > 0: for item in range(1, 5): tem[2].addItem("+" + str(item * 2) + '%') else: for item in range(1, 5): tem[2].addItem("+" + str(item * 4) + '%') self.黑鸦词条.append(tem) self.黑鸦词条更新(i) # tem[1].currentIndexChanged.connect(lambda state: self.希洛克武器词条更新()) self.武器择优模式 = MyQComboBox(self.main_frame6) self.武器择优模式.addItems(['武器默认择优词条', '武器默认择优觉醒']) self.武器择优模式.resize(151, 20) self.武器择优模式.move(横坐标, 纵坐标 - 20 + 25 * (4 + 15) - 20) # self.武器择优模式.setStyleSheet(复选框样式) # self.武器择优模式.setChecked(False) self.守门人全属强 = QCheckBox(trans(' 守门人全属强\n 自动补正'), self.main_frame6) self.守门人全属强.resize(120, 30) self.守门人全属强.move(横坐标 + 181, 纵坐标 + 291 - 15) self.守门人全属强.setStyleSheet(复选框样式) self.守门人全属强.setChecked(False) self.守门人全属强.setEnabled(False) self.守门人全属强.setStyleSheet(复选框样式) self.守门人全属强.setToolTip( trans("计算时自动替换细节页的附魔勋章为全属强方案
") + trans('自带单属强职业不可使用
') + trans('守门人属强：全属强+30*3
') + trans( '武器：全属强+13（若原附魔为龙珠时不替换）
首饰：全属强+28*3(25*3站街修正属强自行-9)
') + trans('辅助装备：全属强+12
魔法石：全属强+30
勋章：全属强+7
宠物附魔：三攻+60') ) self.智慧产物升级 = QCheckBox(trans('智慧产物升级'), self.main_frame6) self.智慧产物升级.resize(140, 20) self.智慧产物升级.move(横坐标 + 161, 纵坐标 - 19 + 25 * (4 + 15) - 20) self.智慧产物升级.setStyleSheet(复选框样式) self.智慧产物升级.setChecked(False) 横坐标 = 横坐标 + 320 纵坐标 = 0 标签 = QLabel(trans('希洛克相关'), self.main_frame6) 标签.setStyleSheet(标签样式 + 'QLabel{font-size:13px;}') 标签.resize(300, 20) 标签.move(横坐标 - 310, 纵坐标 + 135 - 10) 标签.setAlignment(Qt.AlignCenter) 名称 = trans(['奈克斯', '暗杀者', '卢克西', '守门人', '洛多斯']) self.希洛克套装按钮 = [] self.希洛克单件按钮 = [] self.希洛克遮罩透明度 = [] self.希洛克装备图标 = [] self.希洛克选择状态 = [0] * 15 count = 0 for i in 名称: self.希洛克套装按钮.append(QPushButton(i, self.main_frame6)) self.希洛克套装按钮[count].setStyleSheet(按钮样式) self.希洛克套装按钮[count].resize(50, 22) self.希洛克套装按钮[count].move(横坐标 - 320, 纵坐标 + 160 + 3 + count * 32 - 10) self.希洛克套装按钮[count].clicked.connect( lambda state, index=(count + 1) * 100: self.希洛克选择(index)) for j in range(3): 序号 = count * 3 + j 图片 = QLabel(self.main_frame6) 图片.setPixmap( QPixmap('./ResourceFiles/img/希洛克/' + str(序号) + '.png')) 图片.resize(28, 28) 图片.move(横坐标 - 260 + j * 30, 纵坐标 + 160 + count * 32 - 10) self.希洛克装备图标.append(图片) self.希洛克遮罩透明度.append(QGraphicsOpacityEffect()) self.希洛克遮罩透明度[序号].setOpacity(0.5) self.希洛克单件按钮.append(QPushButton(self.main_frame6)) self.希洛克单件按钮[序号].setStyleSheet( "background-color: rgb(0, 0, 0)") self.希洛克单件按钮[序号].resize(28, 28) self.希洛克单件按钮[序号].move(横坐标 - 260 + j * 30, 纵坐标 + 160 + count * 32 - 10) self.希洛克单件按钮[序号].setGraphicsEffect(self.希洛克遮罩透明度[序号]) self.希洛克单件按钮[序号].clicked.connect( lambda state, index=序号: self.希洛克选择(index)) count += 1 self.守门人属强 = MyQComboBox(self.main_frame6) for i in range(7): self.守门人属强.addItem(trans('{守门人属强}：$value', value=15 + i * 5)) self.守门人属强.resize(120, 20) self.守门人属强.setCurrentIndex(3) self.守门人属强.move(横坐标 - 139, 纵坐标 + 93 + 3 + count * 32 - 10) self.守门人属强.activated.connect( lambda state, index=序号: self.守门人属强选项(index)) self.希洛克武器词条 = [] count += 1 self.希洛克武器词条.append(MyQComboBox(self.main_frame6)) self.希洛克武器词条[0].addItems(['武器词条：无', '自适应最高值', '自选词条数值']) self.希洛克武器词条[0].resize(120, 20) self.希洛克武器词条[0].move(横坐标 - 139, 纵坐标 - 32 + count * 32 - 10) self.希洛克武器词条[0].currentIndexChanged.connect( lambda state: self.希洛克武器词条更新()) for i in range(1, 3): count += 1 self.希洛克武器词条.append(MyQComboBox(self.main_frame6)) self.希洛克武器词条[-1].setStyleSheet(下拉框样式) for k in 词条属性列表: self.希洛克武器词条[i].addItem(k.描述) self.希洛克武器词条[i].resize(72, 20) self.希洛克武器词条[i].move(横坐标 - 139, 纵坐标 - 32 + count * 32 - 10) count -= 2 for i in range(3, 5): count += 1 self.希洛克武器词条.append(MyQComboBox(self.main_frame6)) self.希洛克武器词条[-1].setStyleSheet(下拉框样式) for k in [3, 4, 5]: self.希洛克武器词条[i].addItem(str(k * (5 - i)) + '%') self.希洛克武器词条[i].resize(43, 20) self.希洛克武器词条[i].move(横坐标 - 62, 纵坐标 - 32 + count * 32 - 10) for i in range(1, 5): self.希洛克武器词条[-1].setStyleSheet(下拉框样式) self.希洛克武器词条[i].setEnabled(False) # self.希洛克武器词条[i].setStyleSheet(下拉框样式) 纵向偏移 = 335 标签 = QLabel(trans('奥兹玛相关'), self.main_frame6) 标签.setStyleSheet(标签样式 + 'QLabel{font-size:13px;}') 标签.resize(300, 20) 标签.move(横坐标 - 310 - 5, 纵坐标 + 135 - 10 + 纵向偏移) 标签.setAlignment(Qt.AlignCenter) 名称 = trans(['阿斯特罗斯', '贝利亚斯', '雷德梅恩', '罗什巴赫', '泰玛特']) self.奥兹玛套装按钮 = [] self.奥兹玛单件按钮 = [] self.奥兹玛遮罩透明度 = [] self.奥兹玛装备图标 = [] self.奥兹玛选择状态 = [0] * 25 count = 0 for i in 名称: self.奥兹玛套装按钮.append(QPushButton(i, self.main_frame6)) self.奥兹玛套装按钮[count].setStyleSheet(按钮样式) self.奥兹玛套装按钮[count].resize(75, 22) self.奥兹玛套装按钮[count].move(横坐标 - 320 - 5, 纵坐标 + 160 + 3 + count * 32 - 10 + 纵向偏移) self.奥兹玛套装按钮[count].clicked.connect( lambda state, index=(count + 1) * 100: self.奥兹玛选择(index)) for j in range(5): 序号 = count * 5 + j 图片 = QLabel(self.main_frame6) 图片.setPixmap( QPixmap('./ResourceFiles/img/奥兹玛/' + str(序号) + '.png')) 图片.resize(28, 28) 图片.move(横坐标 - 260 + j * 30 + 20 - 5, 纵坐标 + 160 + count * 32 - 10 + 纵向偏移) self.奥兹玛装备图标.append(图片) self.奥兹玛遮罩透明度.append(QGraphicsOpacityEffect()) self.奥兹玛遮罩透明度[序号].setOpacity(0.5) self.奥兹玛单件按钮.append(QPushButton(self.main_frame6)) self.奥兹玛单件按钮[序号].setStyleSheet( "background-color: rgb(0, 0, 0)") self.奥兹玛单件按钮[序号].resize(28, 28) self.奥兹玛单件按钮[序号].move(横坐标 - 260 + j * 30 + 20 - 5, 纵坐标 + 160 + count * 32 - 10 + 纵向偏移) self.奥兹玛单件按钮[序号].setGraphicsEffect(self.奥兹玛遮罩透明度[序号]) self.奥兹玛单件按钮[序号].clicked.connect( lambda state, index=序号: self.奥兹玛选择(index)) count += 1 self.阿斯特罗斯选项 = [] for i in range(5): self.阿斯特罗斯选项.append(MyQComboBox(self.main_frame6)) self.阿斯特罗斯选项[i].addItem('70.75.80') self.阿斯特罗斯选项[i].addItem('40.45.60') self.阿斯特罗斯选项[i].addItem('20.25.35') self.阿斯特罗斯选项[i].resize(60 + 15, 20) self.阿斯特罗斯选项[i].setCurrentIndex(0) self.阿斯特罗斯选项[i].move(横坐标 - 139 + 60 - 15, 纵坐标 + 160 + 3 - 10 + 纵向偏移 + i * 32) self.阿斯特罗斯选项显示(0) self.计算按钮3 = QPushButton(trans('开始计算'), self.main_frame6) self.计算按钮3.clicked.connect(lambda state: self.计算()) self.计算按钮3.move(990, self.height() - 70) self.计算按钮3.resize(110, 30) self.计算按钮3.setStyleSheet(按钮样式) # endregion # region 界面函数 # 第二页 def 输出时间变化(self): 输出时间变化提示 = QMessageBox(QMessageBox.Question, "提示", "切换输出时间请检查技能次数是否为/CD,否则计算结果不发生变化") 输出时间变化提示.setWindowIcon(self.icon) 输出时间变化提示.exec_() pass def 技能列表显示排序(self, skill): temp = deepcopy(skill) temp.sort(key=operator.attrgetter('所在等级')) return temp def 次数输入填写(self, x): if self.次数输入[x].currentIndex() == 12: self.次数输入[x].setEditable(True) self.次数输入[x].clearEditText() self.次数输入[x].setStyleSheet(下拉框样式) elif self.次数输入[x].currentIndex() == 13: temp = self.次数输入[x].currentText() self.次数输入[x].removeItem(13) self.次数输入[x].setCurrentIndex(12) self.次数输入[x].setEditable(True) self.次数输入[x].clearEditText() self.次数输入[x].setStyleSheet(下拉框样式) self.次数输入[x].setCurrentText(temp) else: self.次数输入[x].setEditable(False) def 宠物次数填写(self, x): if self.宠物次数[x].currentIndex() == 11: self.宠物次数[x].setEditable(True) self.宠物次数[x].clearEditText() self.宠物次数[x].setStyleSheet(下拉框样式) elif self.宠物次数[x].currentIndex() == 12: temp = self.宠物次数[x].currentText() self.宠物次数[x].removeItem(12) self.宠物次数[x].setCurrentIndex(11) self.宠物次数[x].setEditable(True) self.宠物次数[x].clearEditText() self.宠物次数[x].setStyleSheet(下拉框样式) self.宠物次数[x].setCurrentText(temp) else: self.宠物次数[x].setEditable(False) def 护石描述更新(self, x): try: self.护石栏[x].setToolTip('' + self.初始属性.技能栏[ self.初始属性.技能序号[self.护石选项[self.护石栏[x].currentIndex()]]].护石描述( self.护石类型选项[x].currentIndex()) + '') except: self.护石栏[x].setToolTip('暂缺') def 护石类型选项更新(self, x): self.护石类型选项[x].clear() if self.护石栏[x].currentData() != '无': try: self.护石类型选项[x].addItems( trans(self.初始属性.技能栏[self.初始属性.技能序号[self.护石选项[ self.护石栏[x].currentIndex()]]].护石选项)) self.护石类型选项[x].setCurrentIndex( len(self.初始属性.技能栏[self.初始属性.技能序号[self.护石选项[ self.护石栏[x].currentIndex()]]].护石选项) - 1) except: self.护石类型选项[x].addItem('魔界') self.护石类型选项[x].addItem('圣痕') self.护石栏[x].setCurrentIndex(0) else: self.护石类型选项[x].addItem('魔界') self.护石类型选项[x].addItem('圣痕') def 符文技能更改(self, i): if i == 0: for i in range(1, 9): self.符文[i].setCurrentIndex(self.符文[0].currentIndex()) else: self.符文[i + 3].setCurrentIndex(self.符文[i].currentIndex()) self.符文[i + 6].setCurrentIndex(self.符文[i].currentIndex()) def 符文效果更改(self, i): self.符文效果[i + 3].setCurrentIndex(self.符文效果[i].currentIndex()) self.符文效果[i + 6].setCurrentIndex(self.符文效果[i].currentIndex()) def 等级调整标注(self, index): 警告 = "技能等级调整指调整学习等级(非实际等级)
一般用于修正天空下装技能，一二觉时装切装
其余等级加成会自动计算，请勿手动调整" if index < 100: try: x = int(self.等级调整[index].currentText()) except: x = 1 if x > 0: self.等级调整[index].setStyleSheet(下拉框样式_warn) if x > 1: QMessageBox.information(self, "警告", 警告) if x < 0: self.等级调整[index].setStyleSheet(下拉框样式_down) if x == 0: self.等级调整[index].setStyleSheet(下拉框样式) elif index == 100: try: x = int(self.远古记忆.currentText()) except: x = 11 if x == 11: self.远古记忆.setStyleSheet(下拉框样式_warn) if x < 10: self.远古记忆.setStyleSheet(下拉框样式_down) if x == 10: self.远古记忆.setStyleSheet(下拉框样式) elif index == 200: try: x = int(self.刀魂之卡赞.currentText()) except: x = 11 if x == 11: self.刀魂之卡赞.setStyleSheet(下拉框样式_warn) if x < 10: self.刀魂之卡赞.setStyleSheet(下拉框样式_down) if x == 10: self.刀魂之卡赞.setStyleSheet(下拉框样式) def 加载护石(self, 属性): for k in range(3): if self.护石栏[k].currentData() != '无': try: 属性.技能栏[self.角色属性A.技能序号[self.护石选项[ self.护石栏[k].currentIndex()]]].装备护石() except: 属性.技能栏[self.角色属性A.技能序号[self.护石选项[ self.护石栏[k].currentIndex()]]].装备护石( self.护石类型选项[k].currentIndex()) 属性.护石第一栏 = self.护石选项[self.护石栏[0].currentIndex()] 属性.护石第二栏 = self.护石选项[self.护石栏[1].currentIndex()] 属性.护石第三栏 = self.护石选项[self.护石栏[2].currentIndex()] for i in range(9): if self.符文[i].currentData() != '无' and self.符文效果[i].currentData( ) != '无': for j in self.符文效果[i].currentData().split(','): if trans('攻击') in j: 属性.技能栏[self.角色属性A.技能序号[self.符文选项[ self.符文[i].currentIndex()]]].倍率 *= 1 + int( j.replace(trans('攻击'), '').replace('%', '')) / 100 if 'CD' in j: 属性.技能栏[self.角色属性A.技能序号[self.符文选项[ self.符文[i].currentIndex()]]].CD *= 1 + int( j.replace('CD', '').replace('%', '')) / 100 # 第三页 def 细节增伤选项颜色更新(self, index): if index.currentIndex() <= 0: index.setStyleSheet(下拉框样式_warn) else: index.setStyleSheet(下拉框样式_detail) pass # 第五页 def 阿斯特罗斯选项显示(self, n): for i in range(5): if i < n: self.阿斯特罗斯选项[i].setEnabled(True) else: self.阿斯特罗斯选项[i].setEnabled(False) def 守门人属强选项(self, x): if self.守门人属强.currentIndex() != 3: self.守门人全属强.setEnabled(False) self.守门人全属强.setChecked(False) self.守门人全属强.setStyleSheet(复选框样式) else: number = sum(self.希洛克选择状态[9:11]) if self.角色属性A.职业 not in ('冰结师', '鬼泣', '死灵术士', '气功师', '忍者', '暗枪士'): if number == 3: self.守门人全属强.setEnabled(True) self.守门人全属强.setChecked(True) self.守门人全属强.setStyleSheet(复选框样式) def 希洛克武器词条更新(self): if self.希洛克武器词条[0].currentIndex() != 2: for i in range(1, 5): self.希洛克武器词条[i].setEnabled(False) else: for i in range(1, 5): self.希洛克武器词条[i].setEnabled(True) def 黑鸦词条更新(self, index): if self.黑鸦词条[index][0].currentIndex() < 2: for i in range(1, 3): self.黑鸦词条[index][i].setEnabled(False) else: for i in range(1, 3): self.黑鸦词条[index][i].setEnabled(True) def 时装选项更新(self, index): if index == 8: count = 0 for i in self.时装选项: if count != 8: i.setCurrentIndex(self.时装选项[8].currentIndex()) count += 1 return else: 力量, 智力, 属强 = 0, 0, 0 套装字典 = {'高级': 0, '节日': 0, '稀有': 0, '神器': 0} for i in range(8): 套装字典[self.时装选项[i].currentData()] = 套装字典.get( self.时装选项[i].currentData(), 0) + 1 # 套装属性 神器 = 套装字典['神器'] 稀有 = 套装字典['稀有'] + 神器 if 套装字典['高级'] >= 3: 力量 += 10 智力 += 10 if 稀有 >= 3 and 神器 < 3: 力量 += 40 智力 += 40 if 套装字典['神器'] >= 3: 力量 += 50 智力 += 50 if 套装字典['高级'] >= 8: 力量 += 10 智力 += 10 if 套装字典['节日'] >= 8: 力量 += 25 智力 += 25 if 稀有 >= 8 and 神器 < 8: 力量 += 40 智力 += 40 属强 += 6 if 套装字典['神器'] >= 8: 力量 += 50 智力 += 50 属强 += 10 数据 = [45, 45, 55, 65] 智力 += 数据[self.时装选项[0].currentIndex()] # 头部 智力 += 数据[self.时装选项[1].currentIndex()] # 帽子 力量 += 数据[self.时装选项[7].currentIndex()] # 鞋子 数据 = [45, 45, 55, 65] 力量 += 数据[self.时装选项[5].currentIndex()] # 腰带 数据 = [0, 6, 0, 0] 属强 += 数据[self.时装选项[4].currentIndex()] # 上衣 数据 = [0, 20, 0, 0] 智力 += 数据[self.时装选项[6].currentIndex()] # 下装 力量 += 数据[self.时装选项[6].currentIndex()] # 下装 self.属性设置输入[6][16].setText(str(max(力量, 智力))) self.属性设置输入[8][16].setText(str(属强 if 属强 != 0 else '')) # 通用 def 下拉框禁用(self, a, b, c=下拉框样式): if a.isChecked(): b.setStyleSheet(c) b.setEnabled(False) else: b.setStyleSheet(c) b.setEnabled(True) # endregion # region 计算相关 def 奥兹玛选择(self, index, x=0): super().奥兹玛选择(index, x) self.阿斯特罗斯选项显示(sum(self.奥兹玛选择状态[0:5])) def 希洛克属性计算(self, 属性, x=0): # 0表示计算属性 1表示计算描述 return 希洛克.希洛克属性_输出(属性, self.希洛克选择状态, self.守门人属强.currentIndex(), x) def 奥兹玛属性计算(self, 属性, x=0): # 0表示计算属性 1表示计算描述 阿斯特罗斯选项 = [] for i in range(sum(self.奥兹玛选择状态[:5])): 阿斯特罗斯选项.append(self.阿斯特罗斯选项[i].currentIndex()) return 奥兹玛.奥兹玛属性_输出(属性, self.奥兹玛选择状态, 阿斯特罗斯选项, x) def 自选计算(self, x=0): if x == 0: self.保存配置(self.存档位置) self.关闭排行窗口() self.排行数据.clear() self.角色属性A = deepcopy(self.初始属性) if x == 0: self.输入属性(self.角色属性A) else: self.输入属性(self.角色属性A, 1) if self.是否计算 != 1: self.click_window(1) return 装备 = [] for index in range(len(self.自选装备)): 装备.append(self.自选装备[index].currentData()) temp = deepcopy(self.初始属性) temp.穿戴装备计算套装(装备) 套装 = temp.套装栏 if x != 0: 伤害列表 = [] for i in range(len(辟邪玉列表)): temp = deepcopy(self.初始属性) self.输入属性(temp, 100 + i) temp.穿戴装备(装备, 套装) 伤害列表.append(temp.伤害计算(0)) 提升率 = [] for i in range(1, len(伤害列表)): if 伤害列表[0] != 0: 提升率.append(伤害列表[i] / 伤害列表[0] - 1) else: 提升率.append(0) 提升率排序 = copy(提升率) 提升率排序.sort(reverse=True) for i in range(len(提升率)): temp = str('%.2f' % (提升率[i] * 100)) + '%' self.辟邪玉提升率2[i].setText(temp) x = 提升率排序.index(提升率[i]) / len(提升率) * 10 - 2 y = 1 / (1 + math.exp(-x)) if SkinVersion == 'None': 颜色 = (0, 0, 0) else: 颜色 = (int(255 - 80 * y), int(245 - 100 * y), int(0 + 150 * y)) self.辟邪玉提升率1[i].setStyleSheet( 'QLabel{font-size:12px;color:rgb' + str(颜色) + '}') self.辟邪玉提升率2[i].setStyleSheet( 'QLabel{font-size:12px;color:rgb' + str(颜色) + '}') self.角色属性A = deepcopy(self.初始属性) self.输入属性(self.角色属性A) C = self.站街计算(装备, 套装) B = deepcopy(self.角色属性A) B.穿戴装备(装备, 套装) B.其它属性计算() 总伤害数值 = B.伤害计算(0) if len(self.基准值) != 0: self.总伤害.setText(self.百分比输出(总伤害数值, self.基准值[0])) else: self.总伤害.setText(self.格式化输出(str(int(总伤害数值)))) tempstr = self.装备描述计算(B) 图片列表 = self.获取装备图片(装备) for i in range(12): self.图片显示[i].setToolTip(tempstr[i]) self.图片显示[i].setMovie(图片列表[i]) self.面板显示设置(self.面板显示, B, C) self.打造显示设置(self.打造显示, B, 1) 词条数值 = self.词条显示计算(B) 词条解释 = self.词条显示计算(B, 1) for i in range(0, len(词条数值)): if i == 5 and B.技能攻击力累加 > 2: self.词条显示[i].setStyleSheet( "QLabel{font-size:12px;color:red}") self.词条显示[i].setText(词条数值[i]) self.词条显示[i].setToolTip('' + 词条解释[i] + '') for i in self.套装名称显示: i.setText('') self.套装显示设置(self.套装名称显示, B) # 更新人物名望(角色属性=B, 人物设置=self) if x == 0: self.排行数据.append(装备 + [0] + 套装 + ['无']) self.输出界面(0) def 站街计算(self, 装备名称, 套装名称): C = deepcopy(self.角色属性A) C.穿戴装备(装备名称, 套装名称) if 调试开关 == 0: for i in C.装备栏: equ.get_equ_by_name(i).城镇属性(C) for i in C.套装栏: equ.get_suit_by_name(i).城镇属性(C) C.装备基础() C.被动倍率计算() return C # endregion # region 读档存档 def 载入旧版json(self, path='set', page=[0, 1, 2, 3, 4, 5]): filepath = './ResourceFiles/{}/{}'.format(self.角色属性A.实际名称, path) if 0 in page: # 第一页(装备/选择/打造) try: filename = 'page_1.json' set_data = {} with open(os.path.join(filepath, filename), encoding='utf-8') as fp: set_data = json.load(fp) fp.close() try: store.set("/{type}/data/title", set_data['称号']) except Exception as error: logger.error(error) try: store.set("/{type}/data/pet", set_data['称号']) except Exception as error: logger.error(error) try: store.set("/{type}/data/compute_mode", set_data['计算模式']) except Exception as error: logger.error(error) try: store.set('/{type}/data/ditto_checked', set_data["百变怪"]) except Exception as error: logger.error(error) try: store.set("/{type}/data/pet_equip_adaptive", set_data['宠物装备择优']) except Exception as error: logger.error(error) try: store.set("/{type}/data/aura_adaptive", set_data['光环词条择优']) except Exception as error: logger.error(error) try: store.set("/{type}/data/myth_top_checked", set_data['神话排名勾选']) except Exception as error: logger.error(error) try: store.set("/{type}/data/damage_unit", set_data['亿为单位显示']) except Exception as error: logger.error(error) try: store.set("/{type}/data/thread_count", set_data['线程数量']) except Exception as error: logger.error(error) try: store.set("/{type}/data/attack_elemental", set_data['攻击属性']) except Exception as error: logger.error(error) try: store.set("/{type}/data/remodel_limit", set_data['改造数量']) except Exception as error: logger.error(error) try: store.set("/{type}/data/equip_checked", set_data['装备勾选']) except Exception as error: logger.error(error) try: store.set("/{type}/data/equip_forges", set_data['装备打造']) except Exception as error: logger.error(error) try: store.set("/{type}/data/equip_conditions", set_data['装备条件']) except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 1 in page: # 第二页(技能/符文/药剂) try: filename = 'page_2.json' set_data = {} with open(os.path.join(filepath, filename), encoding='utf-8') as fp: set_data = json.load(fp) fp.close() try: store.set("/{type}/data/buff_input", set_data['BUFF输入']) except Exception as error: logger.error(error) try: store.set("/{type}/data/time_input", set_data['时间输入']) except Exception as error: logger.error(error) try: store.set("/{type}/data/awakening_binding", set_data['觉醒选择']) except Exception as error: logger.error(error) try: if '远古记忆' in set_data: store.set("/{type}/data/ancient_memory", set_data['远古记忆']) except Exception as error: logger.error(error) try: if '刀魂之卡赞' in set_data: store.set("/{type}/data/kazan", set_data['刀魂之卡赞']) except Exception as error: logger.error(error) try: store.set("/{type}/data/talismans", set_data['护石栏']) except Exception as error: logger.error(error) try: store.set("/{type}/data/talisman_types", set_data['护石类型']) except Exception as error: logger.error(error) try: store.set("/{type}/data/runes_skills", set_data['符文技能']) except Exception as error: logger.error(error) try: store.set("/{type}/data/runes_effects", set_data['符文效果']) except Exception as error: logger.error(error) try: store.set("/{type}/data/consumables", set_data['药剂勾选']) except Exception as error: logger.error(error) try: skills = {} 技能选项 = set_data['技能选项'] for key in 技能选项.keys(): 技能 = 技能选项[key] skill = {'level': 技能['等级'], 'count': 技能['次数']} if 'TP' in 技能: skill['tp'] = 技能['TP'] if '宠物' in 技能: skill['pet'] = 技能['宠物'] if '切装' in 技能: skill['switch'] = 技能['切装'] skills[key] = skill store.set("/{type}/data/skill", skills) except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 2 in page: # 第三页(基础/细节/修正) try: filename = 'page_3.json' set_data = {} with open(os.path.join(filepath, filename), encoding='utf-8') as fp: set_data = json.load(fp) fp.close() try: store.set("/{type}/data/avatar", set_data['时装选项']) except Exception as error: logger.error(error) try: store.set("/{type}/data/detail_values", set_data['细节数值']) except Exception as error: logger.error(error) try: store.set("/{type}/data/detail_options", set_data['细节选项']) except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 3 in page: # 第四页(神话属性修正) try: filename = 'page_4.json' set_data = {} with open(os.path.join(filepath, filename), encoding='utf-8') as fp: set_data = json.load(fp) fp.close() try: store.set("/{type}/data/myth_properties", set_data['神话属性修正']) except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 4 in page: # 第五页(辟邪玉/希洛克/黑鸦/奥兹玛) try: filename = 'page_5.json' set_data = {} with open(os.path.join(filepath, filename), encoding='utf-8') as fp: set_data = json.load(fp) fp.close() try: store.set("/{type}/data/remodel_upgrade", set_data['智慧产物升级']) except Exception as error: logger.error(error) try: store.set("/{type}/data/weapon_adaptive_mode", set_data['武器择优模式']) except Exception as error: logger.error(error) try: store.set("/{type}/data/nameless_elemental_value", set_data['守门人属强']) except Exception as error: logger.error(error) try: store.set("/{type}/data/jude_effects", set_data['辟邪玉效果']) except Exception as error: logger.error(error) try: store.set("/{type}/data/jude_values", set_data['辟邪玉数值']) except Exception as error: logger.error(error) try: store.set("/{type}/data/astaroth_options", set_data['阿斯特罗斯选项']) except Exception as error: logger.error(error) try: store.set('/{type}/data/black_purgatory', set_data['黑鸦选择']) except Exception as error: logger.error(error) try: store.set('/{type}/data/siroco', set_data['希洛克选择']) except Exception as error: logger.error(error) try: store.set('/{type}/data/ozma', set_data['奥兹玛选择']) except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 5 in page: # 第六页(自选装备计算) try: filename = 'page_6.json' set_data = {} with open(os.path.join(filepath, filename), encoding='utf-8') as fp: set_data = json.load(fp) fp.close() try: store.set("/{type}/data/self_select/equips", [set_data['自选装备']]) store.set("/{type}/data/self_select/column_index", 0) except Exception as error: logger.error(error) try: store.set("/{type}/data/self_select/locked", set_data['装备锁定']) except Exception as error: logger.error(error) except Exception as error: logger.error(error) # 职业存档 try: filename = 'char.json' set_data = {} with open(os.path.join(filepath, filename), encoding='utf-8') as fp: set_data = json.load(fp) fp.close() store.set("/{type}/data/character_sets", set_data) except Exception as error: logger.error(error) pass def 载入json(self, path='set', page=[0, 1, 2, 3, 4, 5]): filepath = './ResourceFiles/{}/{}'.format(self.角色属性A.实际名称, path) filename = os.path.join(filepath, "store.json") if os.path.exists(filename): try: set_data = {} with open(filename, encoding='utf-8') as fp: set_data = json.load(fp) fp.close() store.imports(set_data) except Exception as error: logger.error(error) else: self.载入旧版json(path, page) if 0 in page: # 第一页(装备/选择/打造) try: try: self.称号.setCurrentIndex(store.get("/{type}/data/title", 0)) except Exception as error: logger.error(error) try: self.宠物.setCurrentIndex(store.get("/{type}/data/pet", 0)) except Exception as error: logger.error(error) try: self.计算模式选择.setCurrentIndex( store.get("/{type}/data/compute_mode", 0)) except Exception as error: logger.error(error) try: self.百变怪选项.setChecked( store.get("/{type}/data/ditto_checked", False)) except Exception as error: logger.error(error) try: self.红色宠物装备.setChecked( store.get("/{type}/data/pet_equip_adaptive", True)) except Exception as error: logger.error(error) try: self.光环自适应.setChecked( store.get("/{type}/data/aura_adaptive", True)) except Exception as error: logger.error(error) try: self.神话排名选项.setChecked( store.get("/{type}/data/myth_top_checked", True)) except Exception as error: logger.error(error) try: self.显示选项.setChecked( store.get("/{type}/data/damage_unit", True)) except Exception as error: logger.error(error) try: self.线程数选择.setCurrentIndex( store.get("/{type}/data/thread_count")) except Exception as error: logger.error(error) try: self.攻击属性选项.setCurrentIndex( store.get("/{type}/data/attack_elemental")) except Exception as error: logger.error(error) try: self.智慧产物限制.setCurrentIndex( store.get("/{type}/data/remodel_limit")) except Exception as error: logger.error(error) try: self.批量选择(0) num = 0 data = store.get("/{type}/data/equip_checked") for i in data: if i == 1: self.装备图标点击事件(num, 1) num += 1 except Exception as error: logger.error(error) try: num = 0 data = store.get("/{type}/data/equip_forges") for i in data: self.装备打造选项[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: num = 0 data = store.get("/{type}/data/equip_conditions") for i in data: self.装备条件选择[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 1 in page: # 第二页(技能/符文/药剂) try: try: self.BUFF输入.setText(store.get("/{type}/data/buff_input")) except Exception as error: logger.error(error) try: 时间 = store.get("/{type}/data/time_input", '25') if int(时间) < 10: self.时间输入.setCurrentIndex(int(时间)) else: self.时间输入.setCurrentText(str(时间)) except Exception as error: logger.error(error) try: self.强化觉醒选择(store.get("/{type}/data/awakening_binding")) except Exception as error: logger.error(error) try: if self.初始属性.远古记忆 != -1: self.远古记忆.setCurrentIndex( store.get("/{type}/data/ancient_memory")) except Exception as error: logger.error(error) try: if self.初始属性.刀魂之卡赞 != -1: self.刀魂之卡赞.setCurrentIndex( store.get("/{type}/data/kazan")) except Exception as error: logger.error(error) try: num = 0 data = store.get("/{type}/data/talismans") for i in data: self.护石栏[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: num = 0 data = store.get("/{type}/data/talisman_types") for i in data: self.护石类型选项[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: num = 0 data = store.get("/{type}/data/runes_skills") for i in data: self.符文[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: num = 0 data = store.get("/{type}/data/runes_effects") for i in data: self.符文效果[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: num = 0 data = store.get("/{type}/data/consumables") for i in data: self.复选框列表[num].setChecked(i) num += 1 except Exception as error: logger.error(error) try: skills = store.get("/{type}/data/skill") for i in skills: try: 序号 = self.角色属性A.技能序号[i] self.设置技能选项(序号, skills[i]) except Exception as error: logger.error(error) except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 2 in page: # 第三页(基础/细节/修正) try: try: num = 0 data = store.get("/{type}/data/avatar") for i in data: self.时装选项[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/detail_values") x = 0 for i in data: y = 0 for j in i: self.属性设置输入[x][y].setText(j) y += 1 x += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/detail_options") x = 0 for i in data: y = 0 for j in i: self.细节选项输入[x][y].setCurrentIndex(j) y += 1 x += 1 except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 3 in page: # 第四页(神话属性修正) try: data = store.get("/{type}/data/myth_properties") num = 0 for i in data: self.神话属性选项[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) if 4 in page: # 第五页(辟邪玉/希洛克/黑鸦/奥兹玛) try: try: self.智慧产物升级.setChecked( store.get("/{type}/data/remodel_upgrade")) except Exception as error: logger.error(error) try: self.武器择优模式.setCurrentIndex( store.get("/{type}/data/weapon_adaptive_mode")) except Exception as error: logger.error(error) try: self.守门人属强.setCurrentIndex( store.get("/{type}/data/nameless_elemental_value")) except Exception as error: logger.error(error) try: data = store.get("/{type}/data/weapon_fusion", [0] * 5) num = 0 for i in data: self.希洛克武器词条[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/jude_effects") num = 0 for i in data: self.辟邪玉选择[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/jude_values") num = 0 for i in data: self.辟邪玉数值[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/astaroth_options", []) num = 0 for i in data: self.阿斯特罗斯选项[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/black_purgatory") x = 0 for i in data: y = 0 for j in i: self.黑鸦词条[x][y].setCurrentIndex(j) y += 1 x += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/siroco", []) self.希洛克选择(0, 1) num = 0 for i in data: if i == 1: self.希洛克选择(num) num += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/ozma", []) self.奥兹玛选择(0, 1) num = 0 for i in data: if i == 1: self.奥兹玛选择(num) num += 1 except Exception as error: logger.error(error) except Exception as error: logger.error(error) if 5 in page: # 第六页(自选装备计算) try: try: data = store.get("/{type}/data/self_select/equips", [[]]) column_index = store.get( "/{type}/data/self_select/column_index", 0) data = data[column_index] num = 0 for i in data: self.自选装备[num].setCurrentIndex(i) num += 1 except Exception as error: logger.error(error) try: data = store.get("/{type}/data/self_select/locked") num = 0 for i in data: self.装备锁定[num].setChecked(i) num += 1 except Exception as error: logger.error(error) except Exception as error: logger.error(error) # 职业存档 try: data = store.get("/{type}/data/character_set", []) for i in self.职业存档: try: key = i[0] if key not in data: continue # 复选框 if i[2] == 0: i[1].setChecked(data[key]) # 下拉框 elif i[2] == 1: i[1].setCurrentIndex(data[key]) # 文本框 elif i[2] == 2: i[1].setText(data[key]) except Exception as error: logger.error(error) except Exception as error: logger.error(error) def 载入配置(self, path='set'): filepath = './ResourceFiles/{}/{}/'.format(self.角色属性A.实际名称, path) if os.path.exists(os.path.join( filepath, "page_1.json")) or os.path.exists( os.path.join(filepath, "store.json")): self.载入json(path) return else: # 如果不存在任何存档则载入重置存档 self.载入json(path='reset') def isIntSeriously(self, number): result = False try: n = float(number) # 判断是否是整数并且是否小于10 if n.is_integer() and str(number).count('.') == 0 and n <= 10: result = True except: pass return result def 设置技能选项(self, 序号, info): try: self.等级调整[序号].setCurrentIndex(info['level']) except: pass try: self.TP输入[序号].setCurrentIndex(info['tp']) except: pass try: if info['count'] == '/CD': self.次数输入[序号].setCurrentIndex(0) elif self.isIntSeriously(info['count']): self.次数输入[序号].setCurrentIndex(int(info['count']) + 1) else: self.次数输入[序号].setCurrentIndex(12) self.次数输入[序号].setEditable(True) self.次数输入[序号].clearEditText() self.次数输入[序号].setCurrentText(info['count']) self.次数输入[序号].setStyleSheet(下拉框样式) except: pass try: if self.isIntSeriously(info['pet']): self.宠物次数[序号].setCurrentIndex(int(info['pet'])) else: self.宠物次数[序号].setCurrentIndex(11) self.宠物次数[序号].setEditable(True) self.宠物次数[序号].clearEditText() self.宠物次数[序号].setCurrentText(info['pet']) self.宠物次数[序号].setStyleSheet(下拉框样式) except: pass if 切装模式 == 1: try: self.技能切装[序号].setChecked(info['switch']) except: pass def 获取技能选项(self, 序号): info = {} try: info['level'] = self.等级调整[序号].currentIndex() except: info['level'] = 0 try: info['tp'] = self.TP输入[序号].currentIndex() except: info['tp'] = 0 try: info['count'] = self.次数输入[序号].currentText() except: info['count'] = '0' try: info['pet'] = self.宠物次数[序号].currentText() except: info['pet'] = '0' if 切装模式 == 1: try: info['switch'] = self.技能切装[序号].isChecked() except: info['switch'] = False return info def exports_store(self, page=[0, 1, 2, 3, 4, 5]): if 0 in page: # 第一页(装备/选择/打造) try: store.set("/{type}/data/title", self.称号.currentIndex()) store.set("/{type}/data/pet", self.宠物.currentIndex()) store.set("/{type}/memory/title", self.称号.currentData()) store.set('/{type}/memory/pet', self.宠物.currentData()) store.set("/{type}/data/compute_mode", self.计算模式选择.currentIndex()) store.set("/{type}/data/ditto_checked", self.百变怪选项.isChecked()) store.set("/{type}/data/pet_equip_adaptive", self.红色宠物装备.isChecked()) store.set("/{type}/data/aura_adaptive", self.光环自适应.isChecked()) store.set("/{type}/data/myth_top_checked", self.神话排名选项.isChecked()) store.set("/{type}/data/damage_unit", self.显示选项.isChecked()) store.set("/{type}/data/thread_count", self.线程数选择.currentIndex()) store.set("/{type}/data/attack_elemental", self.攻击属性选项.currentIndex()) store.set("/{type}/data/remodel_limit", self.智慧产物限制.currentIndex()) store.set("/{type}/data/equip_checked", self.装备选择状态) store.set("/{type}/data/equip_forges", [i.currentIndex() for i in self.装备打造选项]) store.set("/{type}/data/equip_conditions", [i.currentIndex() for i in self.装备条件选择]) except Exception as error: logger.error(error) if 1 in page: # 第二页(技能/符文/药剂) try: store.set("/{type}/data/buff_input", self.BUFF输入.text()) store.set("/{type}/data/time_input", self.时间输入.currentText()) store.set("/{type}/data/awakening_binding", self.觉醒选择状态) if self.初始属性.远古记忆 != -1: store.set("/{type}/data/ancient_memory", self.远古记忆.currentIndex()) if self.初始属性.刀魂之卡赞 != -1: store.set("/{type}/data/kazan", self.刀魂之卡赞.currentIndex()) store.set("/{type}/data/talismans", [i.currentIndex() for i in self.护石栏]) store.set("/{type}/data/talisman_types", [i.currentIndex() for i in self.护石类型选项]) store.set("/{type}/memory/talisman_types", [i.currentData() for i in self.护石类型选项]) store.set("/{type}/data/runes_skills", [i.currentIndex() for i in self.符文]) store.set("/{type}/data/runes_effects", [i.currentIndex() for i in self.符文效果]) store.set("/{type}/data/consumables", [i.isChecked() for i in self.复选框列表]) skills = {} for i in self.角色属性A.技能栏: 序号 = self.角色属性A.技能序号[i.名称] skill = self.获取技能选项(序号) skills[i.名称] = skill store.set("/{type}/data/skill", skills) except Exception as error: logger.error(error) if 2 in page: # 第三页(基础/细节/修正) try: store.set("/{type}/data/avatar", [i.currentIndex() for i in self.时装选项]) store.set("/{type}/data/detail_values", [[j.text() for j in i] for i in self.属性设置输入]) store.set("/{type}/data/detail_options", [[j.currentIndex() for j in i] for i in self.细节选项输入]) except Exception as error: logger.error(error) if 3 in page: # 第四页(神话属性修正) try: store.set("/{type}/data/myth_properties", [i.currentIndex() for i in self.神话属性选项]) except Exception as error: logger.error(error) try: store.set("/{type}/data/remodel_properties", [i.currentIndex() for i in self.改造产物选项]) except Exception as error: logger.error(error) if 4 in page: # 第五页(辟邪玉/希洛克/黑鸦) try: store.set("/{type}/data/remodel_upgrade", self.智慧产物升级.isChecked()) store.set("/{type}/data/weapon_adaptive_mode", self.武器择优模式.currentIndex()) store.set("/{type}/data/nameless_elemental_value", self.守门人属强.currentIndex()) store.set("/{type}/data/weapon_fusion", [i.currentIndex() for i in self.希洛克武器词条]) store.set("/{type}/data/jude_effects", [i.currentIndex() for i in self.辟邪玉选择]) store.set("/{type}/data/jude_values", [i.currentIndex() for i in self.辟邪玉数值]) store.set("/{type}/data/astaroth_options", [i.currentIndex() for i in self.阿斯特罗斯选项]) store.set('/{type}/data/black_purgatory', [[j.currentIndex() for j in i] for i in self.黑鸦词条]) store.set('/{type}/data/siroco', self.希洛克选择状态) store.set('/{type}/data/ozma', self.奥兹玛选择状态) except Exception as error: logger.error(error) if 5 in page: # 第六页(自选装备计算) try: data = store.get("/{type}/data/self_select/equips", []) column_index = 0 length = len(self.自选装备) while column_index >= len(data): data.append([0] * length) data[column_index] = [i.currentIndex() for i in self.自选装备] store.set("/{type}/data/self_select/equips", data) store.set("/{type}/memory/equips", [i.currentData() for i in self.自选装备]) store.set("/{type}/data/self_select/equips", data) store.set('/{type}/data/self_select/column_index', column_index) store.set("/{type}/data/self_select/locked", [i.isChecked() for i in self.装备锁定]) except Exception as error: logger.error(error) # 职业存档 try: set_data = {} for i in self.职业存档: # 复选框 if i[2] == 0: set_data[i[0]] = i[1].isChecked() # 下拉框 elif i[2] == 1: set_data[i[0]] = i[1].currentIndex() # 文本框 elif i[2] == 2: set_data[i[0]] = i[1].text() store.set("/{type}/data/character_set", set_data) except Exception as error: logger.error(error) def 保存json(self, path='set', page=[0, 1, 2, 3, 4, 5], store=None): if store is None: from PublicReference.utils.storex import store self.exports_store(page) try: filepath = './ResourceFiles/{}/{}/store.json'.format( self.角色属性A.实际名称, path) set_data = store.exports( lambda i: str.startswith(i, "/carry/data")) with open(filepath, "w", encoding='utf-8') as fp: json.dump(set_data, fp, ensure_ascii=False, indent=4) fp.close() except Exception as error: logger.error(error) def 保存配置(self, path='set'): if self.禁用存档.isChecked(): return if self.技能存档位置 != '全局存档': self.保存json(path=self.技能存档位置, store=Store()) self.保存json(path) # endregion # region 一键修正 def 一键修正(self, x=0): increase_counter(ga_category="carry详细功能使用", name="一键修正") if x == 0: if self.组合计算(2) == 0: QMessageBox.information(self, "错误", "请勾选齐全身上穿戴的装备") return if self.组合计算(2) > 1: QMessageBox.information(self, "错误", "请勿勾选身上未穿戴的装备") return self.修正套装计算(x) self.角色属性B = deepcopy(self.初始属性) self.角色属性B.技能栏 = deepcopy(self.初始属性.技能栏) self.输入属性(self.角色属性B) self.角色属性B.穿戴装备计算套装(self.有效穿戴组合[0]) for i in self.角色属性B.装备栏: equ.get_equ_by_name(i).城镇属性(self.角色属性B) for i in self.角色属性B.套装栏: equ.get_suit_by_name(i).城镇属性(self.角色属性B) self.角色属性B.装备基础() self.角色属性B.被动倍率计算() self.面板修正(self.角色属性B.类型, x * 3) def 面板修正(self, 类型, x): 数据 = [] 原始数据 = [] 名称 = ['力智', '三攻', '属强'] for i in range(3): try: if self.一键站街设置输入[i + x].text() != '': 数据.append(int(self.一键站街设置输入[i + x].text())) else: 数据.append(0) except: QMessageBox.information(self, "错误", 名称[i] + "输入格式错误，已重置为空") self.一键站街设置输入[i + x].setText('') 数据.append(0) if sum(数据) == 0: return if 数据[0] != 0 and 数据[1] == 0: QMessageBox.information(self, "错误", "请输入三攻") return for i in range(5): if self.属性设置输入[i][15].text() != '': 原始数据.append(int(self.属性设置输入[i][15].text())) else: 原始数据.append(0) if 数据[1] != 0: if 类型 == '物理百分比': self.物理百分比修正(数据[0] if 数据[0] != 0 else int(self.角色属性B.站街力量()), 数据[1], 原始数据[0], 原始数据[2]) elif 类型 == '魔法百分比': self.魔法百分比修正(数据[0] if 数据[0] != 0 else int(self.角色属性B.站街智力()), 数据[1], 原始数据[1], 原始数据[3]) elif 类型 == '物理固伤': self.物理固伤修正(数据[0] if 数据[0] != 0 else int(self.角色属性B.站街力量()), 数据[1], 原始数据[0], 原始数据[4]) elif 类型 == '魔法固伤': self.魔法固伤修正(数据[0] if 数据[0] != 0 else int(self.角色属性B.站街智力()), 数据[1], 原始数据[1], 原始数据[4]) if 数据[2] != 0: self.属强修正(数据[2]) self.click_window(2) QMessageBox.information( self, "自动修正计算完毕", "仅对站街修正进行了修改，使面板与输入一致
请自行核对其它页面 非力智三攻属强 条目") def 力量一键修正(self, 输入力智, 修正力量2): 修正前力量 = self.角色属性B.力量 if self.初始属性.实际名称 == '黑暗武士': self.角色属性B.力量 = 输入力智 / self.角色属性B.技能栏[ self.角色属性B.技能序号['次元融合']].力智倍率() 修正力量 = int(输入力智 / self.角色属性B.技能栏[self.角色属性B.技能序号['次元融合']].力智倍率() + 1) - int(修正前力量) else: self.角色属性B.力量 = 输入力智 修正力量 = 输入力智 - int(修正前力量) self.属性设置输入[0][15].setText(str(int(修正力量 + 修正力量2))) def 智力一键修正(self, 输入力智, 修正智力2): 修正前智力 = self.角色属性B.智力 if self.初始属性.实际名称 == '黑暗武士': self.角色属性B.智力 = 输入力智 / self.角色属性B.技能栏[ self.角色属性B.技能序号['次元融合']].力智倍率() 修正智力 = int(输入力智 / self.角色属性B.技能栏[self.角色属性B.技能序号['次元融合']].力智倍率() + 1) - int(修正前智力) else: self.角色属性B.智力 = 输入力智 修正智力 = 输入力智 - int(修正前智力) self.属性设置输入[1][15].setText(str(int(修正智力 + 修正智力2))) def 物攻一键修正(self, 输入力智, 输入三攻, 修正物理攻击力2): 修正前物理攻击力 = self.角色属性B.物理攻击力 站街物理攻击倍率 = self.角色属性B.站街物理攻击力倍率() j = round(输入三攻 / 站街物理攻击倍率, 0) 站街实际三攻 = int(j) for k in range(int(j) - 2, int(j) + 3): self.角色属性B.物理攻击力 = float(k) 验证物理攻击力1 = int(self.角色属性B.站街物理攻击力()) self.角色属性B.物理攻击力 = float(k + 1) 验证物理攻击力2 = int(self.角色属性B.站街物理攻击力()) if 验证物理攻击力1 <= 输入三攻 and 验证物理攻击力2 > 输入三攻: 站街实际三攻 = float(k) 修正物理攻击力 = 站街实际三攻 - 修正前物理攻击力 self.属性设置输入[2][15].setText(str(int(修正物理攻击力 + 修正物理攻击力2))) def 魔攻一键修正(self, 输入力智, 输入三攻, 修正魔法攻击力2): 修正前魔法攻击力 = self.角色属性B.魔法攻击力 站街魔法攻击倍率 = self.角色属性B.站街魔法攻击力倍率() j = round(输入三攻 / 站街魔法攻击倍率, 0) 站街实际三攻 = int(j) for k in range(int(j) - 2, int(j) + 3): self.角色属性B.魔法攻击力 = float(k) 验证魔法攻击力1 = int(self.角色属性B.站街魔法攻击力()) self.角色属性B.魔法攻击力 = float(k + 1) 验证魔法攻击力2 = int(self.角色属性B.站街魔法攻击力()) if 验证魔法攻击力1 <= 输入三攻 and 验证魔法攻击力2 > 输入三攻: 站街实际三攻 = float(k) 修正魔法攻击力 = 站街实际三攻 - 修正前魔法攻击力 self.属性设置输入[3][15].setText(str(int(修正魔法攻击力 + 修正魔法攻击力2))) def 独立一键修正(self, 输入力智, 输入三攻, 修正独立攻击力2): 修正前独立攻击力 = self.角色属性B.独立攻击力 站街独立攻击倍率 = self.角色属性B.站街独立攻击力倍率() j = round(输入三攻 / 站街独立攻击倍率, 0) 站街实际三攻 = int(j) for k in range(int(j) - 2, int(j) + 3): self.角色属性B.独立攻击力 = float(k) 验证独立攻击力1 = int(self.角色属性B.站街独立攻击力()) self.角色属性B.独立攻击力 = float(k + 1) 验证独立攻击力2 = int(self.角色属性B.站街独立攻击力()) if 验证独立攻击力1 <= 输入三攻 and 验证独立攻击力2 > 输入三攻: 站街实际三攻 = float(k) 修正独立攻击力 = 站街实际三攻 - 修正前独立攻击力 self.属性设置输入[4][15].setText(str(int(修正独立攻击力 + 修正独立攻击力2))) def 物理百分比修正(self, 输入力智, 输入三攻, 修正力量2, 修正物理攻击力2): self.力量一键修正(输入力智, 修正力量2) self.物攻一键修正(输入力智, 输入三攻, 修正物理攻击力2) def 魔法百分比修正(self, 输入力智, 输入三攻, 修正智力2, 修正魔法攻击力2): self.智力一键修正(输入力智, 修正智力2) self.魔攻一键修正(输入力智, 输入三攻, 修正魔法攻击力2) def 物理固伤修正(self, 输入力智, 输入三攻, 修正力量2, 修正独立攻击力2): self.力量一键修正(输入力智, 修正力量2) self.独立一键修正(输入力智, 输入三攻, 修正独立攻击力2) def 魔法固伤修正(self, 输入力智, 输入三攻, 修正智力2, 修正独立攻击力2): self.智力一键修正(输入力智, 修正智力2) self.独立一键修正(输入力智, 输入三攻, 修正独立攻击力2) def 属强修正(self, 输入属强): try: 站街火强 = self.角色属性B.火属性强化加成() + self.角色属性B.火属性强化 except: 站街火强 = self.角色属性B.火属性强化 try: 站街冰强 = self.角色属性B.冰属性强化加成() + self.角色属性B.冰属性强化 except: 站街冰强 = self.角色属性B.冰属性强化 try: 站街光强 = self.角色属性B.光属性强化加成() + self.角色属性B.光属性强化 except: 站街光强 = self.角色属性B.光属性强化 try: 站街暗强 = self.角色属性B.暗属性强化加成() + self.角色属性B.暗属性强化 except: 站街暗强 = self.角色属性B.暗属性强化 if self.属性设置输入[5][15].text() != '': 修改前 = float(self.属性设置输入[5][15].text()) else: 修改前 = 0 修正前属强 = int(max(站街火强, 站街冰强, 站街光强, 站街暗强)) for k in range(-2, 3): temp = int((输入属强 + k - 修正前属强) / self.角色属性B.所有属性强化增加) y = 修正前属强 + temp * self.角色属性B.所有属性强化增加 if int(y) == 输入属强: break 修改后 = temp + 修改前 self.属性设置输入[5][15].setText(str(int(修改后))) # endregion # region 输出界面 def 词条显示计算(self, 属性, x=0): 属白换算 = 属性.属性倍率 * 属性.属性附加 tempstr = [] # temp = ''.format(self.辟邪玉显示()) if x == 0: label = "{}：{}" tempstr.append(label.format(trans("黄字"), to_percent(属性.伤害增加, 1))) # 0 tempstr.append(label.format(trans("暴伤"), to_percent(属性.暴击伤害, 1))) # 1 tempstr.append(label.format(trans("白字"), to_percent(属性.附加伤害, 1))) # 2 tempstr.append(label.format(trans("属白"), to_percent(属性.属性附加, 1))) # 3 tempstr.append(label.format(trans("终伤"), to_percent(属性.最终伤害, 1))) # 4 tempstr.append( label.format(trans("技攻"), to_percent(属性.技能攻击力 - 1, 1))) # 5 tempstr.append(label.format(trans("三攻"), to_percent(属性.百分比三攻, 1))) # 6 tempstr.append(label.format(trans("力智"), to_percent(属性.百分比力智, 1))) # 7 tempstr.append(label.format(trans('持续'), to_percent(属性.持续伤害, 1))) # 8 tempstr.append(label.format(trans("攻速"), to_percent(属性.攻击速度, 1))) # 9 tempstr.append(label.format(trans("施放"), to_percent(属性.施放速度, 1))) # 10 tempstr.append(label.format(trans('移速'), to_percent(属性.移动速度, 1))) # 11 if 属白换算 != 0: tempstr[2] += '|{}'.format(to_percent(属白换算 + 属性.附加伤害, 1)) tempstr[3] += '|{}'.format(to_percent(属白换算, 1)) else: label = "{} +{}" tempstr.append( trans('攻击时,额外增加$的伤害增加量').format(to_percent(属性.伤害增加, 1))) # 0 tempstr.append( trans('暴击时,额外增加$的伤害增加量').format(to_percent(属性.暴击伤害, 1))) # 1 tempstr.append(trans('攻击时,附加$的伤害').format(to_percent(属性.附加伤害, 1))) # 2 tempstr.append( trans('攻击时,附加$的属性伤害').format(to_percent(属性.属性附加, 1))) # 3 tempstr.append(label.format(trans("最终伤害"), to_percent(属性.最终伤害, 1))) # 4 tempstr.append( label.format(trans("技能攻击力"), to_percent(属性.技能攻击力 - 1, 1))) # 5 tempstr.append( label.format(trans("物理、魔法、独立攻击力"), to_percent(属性.百分比三攻, 1))) # 6 tempstr.append( label.format(trans("力量、智力"), to_percent(属性.百分比力智, 1))) # 7 tempstr.append( trans('发生持续伤害X秒,伤害量为对敌人增加造成伤害的$').format(to_percent( 属性.持续伤害, 1))) # 8 tempstr.append(label.format(trans("攻击速度"), to_percent(属性.攻击速度, 1))) # 9 tempstr.append(label.format(trans("施放速度"), to_percent(属性.施放速度, 1))) # 10 tempstr.append(label.format(trans("移动速度"), to_percent(属性.移动速度, 1))) # 11 # 为防止部分**对显示造成误解，暂不在词条后显示加成 # date = {2:属性.附加伤害增加增幅, # 3:属性.属性附加伤害增加增幅, # 5:属性.技能伤害增加增幅, # 1:属性.暴击伤害增加增幅, # 0:属性.伤害增加增幅, # 4:属性.最终伤害增加增幅, # 7:属性.力量智力增加增幅, # 6:属性.物理魔法攻击力增加增幅} # for i in date.keys(): # if date[i] != 1.0: # x = date[i] - 1 # y = ' +{}%' if x > 0 else ' {}%' # if i in [2, 3] and '|' in tempstr[i]: # y = y.replace(' ', '') # tempstr[i] += temp + '{}'.format(y.format(round(x * 100, 1))) return tempstr def 面板布局设置(self, 面板显示, x=0): 初始x = 0 const = 128 + 19 # self.main_frame5 if x == 1: 初始x += 805 const += 31 count = 0 # 站街力量 站街物攻 进图力量 进图物攻 for i in [0, 1, 4, 5, 6]: 面板显示[i].move(20 + 初始x, const + count * 18) count += 1 count = 0 # 站街力量 站街物攻 进图力量 进图物攻 # for i in [9, 10, 0, 1]: # 面板显示[i].move(20 + 初始x, const + count * 18) # count += 1 # count = 0 # 站街智力 站街魔攻 进图智力 进图魔攻 for i in [2, 3]: 面板显示[i].move(150 + 初始x, const + count * 18) count += 1 # 独立 # 面板显示[4].move(150 + 初始x, const + count * 18) count = 6 面板显示[7].move(20 + 初始x, const + 6 * 18) 面板显示[8].move(150 + 初始x, const + 6 * 18) 面板显示[9].move(20 + 初始x, const + 7 * 18 - 5) 面板显示[10].move(150 + 初始x, const + 7 * 18 - 5) # 进图属强 for i in range(len(面板显示) - 1): 面板显示[i].resize(100, 18) 面板显示[i].setAlignment(Qt.AlignRight) if i in [7, 8, 9, 10]: 面板显示[i].setAlignment(Qt.AlignCenter) if i == 4: 面板显示[i].resize(155, 18) 面板显示[5].resize(230, 18) 面板显示[6].resize(230, 18) 面板显示[11].resize(230, 18) 面板显示[11].move(20 + 初始x, const + 5 * 18) 面板显示[11].setAlignment(Qt.AlignLeft) # 面板显示[7].resize(100, 72) # 面板显示[7].move(175 + 初始x, const + count * 18 - 75) # 面板显示[7].setAlignment(Qt.AlignCenter) # 面板显示[7].setStyleSheet('QLabel{font-size:12px}') def 面板显示设置(self, 显示, 进图, 站街): 显示[0].setText( '{} {}'. format(str(int(站街.站街力量())), str(int(进图.面板力量())))) 显示[0].setStyleSheet("QLabel{font-size:12px;}") 显示[1].setText( '{} {}'. format(str(int(站街.站街物理攻击力())), str(int(进图.面板物理攻击力())))) 显示[1].setStyleSheet("QLabel{font-size:12px;}") 显示[2].setText( '{} {}'. format(str(int(站街.站街智力())), str(int(进图.面板智力())))) 显示[2].setStyleSheet("QLabel{font-size:12px;}") 显示[3].setText( '{} {}'. format(str(int(站街.站街魔法攻击力())), str(int(进图.面板魔法攻击力())))) 显示[3].setStyleSheet("QLabel{font-size:12px;}") 显示[4].setText( '{} {} {}'.format(str(int(站街.站街独立攻击力())), str(int(进图.面板独立攻击力())), get_mac_address()[0:8])) 显示[4].setStyleSheet("QLabel{font-size:12px;}") 显示[5].setText( ('' + trans('火') + '({})' + trans('冰') + '({})' + trans('光') + '({})' + trans('暗') + '({})').format( int(站街.火属性强化), int(站街.冰属性强化), int(站街.光属性强化), int(站街.暗属性强化))) 显示[5].setStyleSheet("QLabel{font-size:12px;}") 显示[6].setText( ('' + trans('火') + '({})' + trans('冰') + '({})' + trans('光') + '({})' + trans('暗') + '({})').format( int(进图.火属性强化), int(进图.冰属性强化), int(进图.光属性强化), int(进图.暗属性强化))) 显示[6].setStyleSheet("QLabel{font-size:12px;}") 辟邪玉词条 = self.辟邪玉显示(1) for i in range(len(辟邪玉词条)): 显示[7 + i].setText(辟邪玉词条[i]) 显示[7 + i].setStyleSheet("QLabel{font-size:12px;}") 显示[11].setText("{}".format( get_mac_address()[0:8])) 显示[11].setStyleSheet("QLabel{font-size:15px;}") # 显示[0].setText(str(int(进图.面板力量()))) # 显示[1].setText(str(int(进图.面板物理攻击力()))) # 显示[2].setText(str(int(进图.面板智力()))) # 显示[3].setText(str(int(进图.面板魔法攻击力()))) # # 独立攻击力 # tempstr = '{} '.format(int( # 站街.站街独立攻击力())) # tempstr += '{}'.format(int(进图.面板独立攻击力())) # 显示[4].setText(tempstr) # # 属性强化 # tempstr = '' # # if 进图.所有属性强化增加 != 1.0: # # x = 进图.所有属性强化增加 - 1 # # y = ' +{}%' if x > 0 else ' {}%' # # tempstr += '{}'.format(self.辟邪玉显示(), y.format(round(x * 100, 1))) # 显示[5].setText('{}{}'.format(int(进图.火属性强化), tempstr)) # 显示[6].setText('{}{}'.format(int(进图.冰属性强化), tempstr)) # 显示[7].setText('{}{}'.format(int(进图.光属性强化), tempstr)) # 显示[8].setText('{}{}'.format(int(进图.暗属性强化), tempstr)) # 显示[9].setText(str(int(站街.站街力量()))) # 显示[10].setText(str(int(站街.站街物理攻击力()))) # 显示[11].setText(str(int(站街.站街智力()))) # 显示[12].setText(str(int(站街.站街魔法攻击力()))) # 显示[13].setText(str(int(站街.火属性强化))) # 显示[14].setText(str(int(站街.冰属性强化))) # 显示[15].setText(str(int(站街.光属性强化))) # 显示[16].setText(str(int(站街.暗属性强化))) # 显示[17].setText(self.辟邪玉显示(1)) def 辟邪玉显示(self, x=0): temp = '' num = 0 list = [] for i in range(4): k = self.辟邪玉选择[i].currentIndex() if k > 0: list.append('{} {}'.format( trans(辟邪玉列表[k].简称), '' if self.辟邪玉数值[i].currentText() == '+0' else self.辟邪玉数值[i].currentText())) num += 1 辟邪玉颜色 = 颜色[{4: '史诗', 3: '传说', 2: '神器', 1: '稀有'}.get(num, '稀有')] if x == 0: return 辟邪玉颜色 else: if num == 0: return '' else: for i in range(num): list[i] = '{}'.format( 辟邪玉颜色, list[i]) return list def 套装显示设置(self, 显示, 属性): count = 0 显示[count].setText(trans(self.称号.currentData())) 显示[count].setStyleSheet( "QLabel{font-size:12px;color:rgb(255,255,255)}") 显示[count].setToolTip(self.称号描述()) count += 1 显示[count].setText(trans(self.宠物.currentData())) 显示[count].setStyleSheet( "QLabel{font-size:12px;color:rgb(255,255,255)}") 显示[count].setToolTip(self.宠物描述()) count += 1 神话所在套装 = [] for i in range(11): temp = equ.get_equ_by_name(属性.装备栏[i]) if temp.品质 == '神话': 神话所在套装.append(temp.所属套装) # 套装属性合并 套装 = [] 套装件数 = [] 套装属性 = [] 套装名称 = 属性.套装栏 for i in range(len(套装名称)): temp = 套装名称[i].split('[')[0] if temp not in 套装: 套装.append(temp) 套装件数.append([]) 套装属性.append('') if len(套装名称[i].split('[')) > 1: 件数 = 套装名称[i].split('[')[1].split(']')[0] 套装件数[套装.index(temp)].append(件数) 套装属性[套装.index( temp )] += '' + 套装名称[ i] + '
' + equ.get_suit_by_name(套装名称[i]).装备描述( self.角色属性B)[:-4] + '
' # 自适应属性 if sum(self.角色属性A.自适应选项) != 0: 套装.append(self.角色属性A.自适应输出()) 套装件数.append([]) 套装属性.append('') tempstr = '' 武器词条属性 = trans(['力智', '三攻', '黄字', '白字', '暴伤', '终伤']) if self.希洛克武器词条[0].currentIndex() == 1: tempstr += trans("{残香}：$value+10%", value=武器词条属性[self.角色属性A.词条选择[0]]) if sum(self.希洛克选择状态) == 3: tempstr += "|{}+5%".format(武器词条属性[self.角色属性A.词条选择[1]]) 套装.append(tempstr) 套装件数.append([]) 套装属性.append('') # 显示套装 for i in range(len(套装)): if len(套装件数[i]) > 0: 显示[count].setText(trans(套装[i]) + '[' + str(max(套装件数[i])) + ']') else: 显示[count].setText(trans(套装[i])) if 套装[i] in 神话所在套装: 显示[count].setStyleSheet( "QLabel{font-size:12px;color:rgb(226,150,146)}") else: 显示[count].setStyleSheet( "QLabel{font-size:12px;color:rgb(255,255,255)}") 显示[count].setToolTip(套装属性[i][:-4]) count += 1 try: # 显示黑鸦词条 黑鸦部位 = trans(['武器', '戒指', '辅助装备', '下装']) for i in range(4): if 属性.黑鸦词条[i][4] != '': 显示[count].setText(黑鸦部位[i] + ':' + 属性.黑鸦词条[i][4].replace('
', ' ')) 显示[count].setStyleSheet( "QLabel{font-size:12px;color:rgb(255,255,255)}") count += 1 except Exception as error: logger.error(error) pass def 打造显示设置(self, 显示, 属性, x=0): 初始x = 10 初始y = 31 pox_y2 = 11 # self.main_frame5 if x == 1: 初始x += 805 初始y += 20 + pox_y2 偏移量 = 187 x坐标 = [ 32, 0, 0, 32, 0, 偏移量, 偏移量 + 32, 偏移量 + 32, 偏移量, 偏移量, 偏移量 + 32, 32 ] y坐标 = [0, 0, 32, 32, 64, 0, 0, 32, 64, 32, 64, 64] temp = [] for i in range(12): 装备 = equ.get_equ_by_name(属性.装备栏[i]) 打造状态 = 显示[i] if 装备.所属套装 != '智慧产物': 打造状态.setText('+' + str(属性.强化等级[i])) if 属性.是否增幅[i] == 1: 打造状态.setStyleSheet( "QLabel{color:rgb(228,88,169);font-size:12px;font-weight:Bold}" ) temp.append('增幅+{} {}'.format(属性.强化等级[i], 装备.名称)) else: 打造状态.setStyleSheet( "QLabel{color:rgb(25,199,234);font-size:12px;font-weight:Bold}" ) temp.append('强化+{} {}'.format(属性.强化等级[i], 装备.名称)) else: 打造状态.setText('+' + str(属性.改造等级[i])) 打造状态.setStyleSheet( "QLabel{color:rgb(249,141,62);font-size:12px;font-weight:Bold;}" ) temp.append('改造+{} {}'.format(属性.改造等级[i], 装备.名称)) 打造状态.move(初始x + x坐标[i] + 13, 初始y + y坐标[i] - 8 - pox_y2) 打造状态.resize(21, 10) 装备 = equ.get_equ_by_name(属性.装备栏[11]) if 装备.所属套装 != '智慧产物' and 属性.武器锻造等级 != 0: 打造状态 = 显示[12] 打造状态.setText('+' + str(属性.武器锻造等级)) 打造状态.setStyleSheet( "QLabel{color:rgb(232,104,24);font-size:12px;font-weight:Bold}" ) 打造状态.move(初始x + x坐标[11] + 13, 初始y + y坐标[11] + 20 - pox_y2) temp[11] += '(锻造+{})'.format(属性.武器锻造等级) 打造状态.resize(21, 10) return temp def 格式化输出(self, 数字文本, x=0): if x == 1: 返回值 = str('%.2f' % round(int(数字文本) / 100000000, 2)) elif self.显示选项.isChecked(): 返回值 = str('%.2f' % round(int(数字文本) / 100000000, 2)) + '亿' else: 返回值 = '' for i in range(len(数字文本)): if len(数字文本) % 3 == 2 and i % 3 == 2: 返回值 += ',' if len(数字文本) % 3 == 1 and i % 3 == 1: 返回值 += ',' if len(数字文本) % 3 == 0 and i % 3 == 0: if i != 0: 返回值 += ',' 返回值 += str(数字文本[i]) return 返回值 def 称号描述(self): temp = '' temp += '' + \ trans(self.称号.currentData()) + '
' temp += 称号列表[self.称号.currentIndex()].装备描述(self.角色属性B)[:-4] temp += '' return temp def 宠物描述(self): temp = '' temp += '' + self.宠物.currentText( ) + '
' temp += 宠物列表[self.宠物.currentIndex()].装备描述(self.角色属性B)[:-4] temp += '' return temp def 装备描述计算(self, 属性): tempstr = [] 数量 = sum(self.希洛克选择状态) 武器词条属性 = ['力智', '三攻', '黄字', '白字', '暴伤', '终伤'] 希洛克 = self.希洛克属性计算(属性, 1) 奥兹玛 = self.奥兹玛属性计算(属性, 1) for i in range(12): 装备 = equ.get_equ_by_name(属性.装备栏[i]) # 名称 tempstr.append( trans( '{$name}', color=颜色[装备.品质], name=装备.名称)) # 等级 品质 类型 部位 tempstr[i] += trans('
Lv$level {$rarity} {$type}({$part})', level=装备.等级, rarity=装备.品质, type=装备.类型, part=装备.部位) # 套装 if 装备.所属套装 != '无': if 装备.所属套装 != '智慧产物': y = 装备.所属套装 else: y = 装备.所属套装2 else: y = '' if y != '': tempstr[i] += trans( '
{$value} {套装}', value=y) # 精通描述 if i < 5: x = 属性.防具精通计算(i) y = trans('
{精通}:') for n in 属性.防具精通属性: y += trans(n) + ' ' tempstr[i] += y + '+' + str(x) # 打造描述 if 装备.所属套装 != '智慧产物': # 强化描述 if 属性.强化等级[i] != 0: if i == 8: tempstr[i] += trans( '
+$value {强化}：', value=属性.强化等级[i]) tempstr[i] += trans('{三攻} + $value', value=耳环计算(装备.等级, 装备.品质, 属性.强化等级[i])) if i in [9, 10]: tempstr[i] += trans( '
+$value {强化}：', value=属性.强化等级[i]) tempstr[i] += trans('{四维} + $value', value=左右计算(装备.等级, 装备.品质, 属性.强化等级[i])) if i == 11: tempstr[i] += trans( '
+$value {强化}：', value=属性.强化等级[i]) tempstr[i] += trans('{物理攻击力} + $value', value=武器计算(装备.等级, 装备.品质, 属性.强化等级[i], 装备.类型, '物理')) tempstr[i] += trans( '
+$value {强化}：', value=属性.强化等级[i]) tempstr[i] += trans('{魔法攻击力} + $value', value=武器计算(装备.等级, 装备.品质, 属性.强化等级[i], 装备.类型, '魔法')) # 锻造描述 if i == 11 and 属性.武器锻造等级 != 0: tempstr[i] += trans( '
+$value {锻造} ', value=属性.武器锻造等级) tempstr[i] += trans('{独立攻击力} + $value', value=锻造计算(装备.等级, 装备.品质, 属性.武器锻造等级)) # 增幅描述 if 属性.是否增幅[i] == 1: if tempstr[i] != '': tempstr[i] += '
' value = 增幅计算(装备.等级, 装备.品质, 属性.强化等级[i], 属性.增幅版本) tempstr[i] += trans("+$value {增幅}：", value=属性.强化等级[i]) if '物理' in 属性.类型 or '力量' in 属性.类型: tempstr[i] += trans('异次元力量') else: tempstr[i] += trans('异次元智力') tempstr[i] += ' +{}'.format(value) # 遴选描述 if tempstr[i] != '': tempstr[i] += '
' if i == 2 and 属性.黑鸦词条[3][0] != 0 and 属性.变换词条[3][1] != 0: tempstr[i] += 装备.装备描述_变换属性(属性)[:-4] + "
" tempstr[i] += 属性.黑鸦词条[3][4] # 下装 elif i == 7 and 属性.黑鸦词条[1][0] != 0 and 属性.变换词条[1][1] != 0: tempstr[i] += 装备.装备描述_变换属性(属性)[:-4] + "
" tempstr[i] += 属性.黑鸦词条[1][4] # 戒指 elif i == 9 and 属性.黑鸦词条[2][0] != 0 and 属性.变换词条[2][1] != 0: tempstr[i] += 装备.装备描述_变换属性(属性)[:-4] + "
" tempstr[i] += 属性.黑鸦词条[2][4] # 辅助 elif i == 11 and 属性.黑鸦词条[0][0] != 0 and 属性.变换词条[0][1] != 0: tempstr[i] += 装备.装备描述_变换属性(属性)[:-4] + "
" tempstr[i] += 属性.黑鸦词条[0][4] # 武器 else: tempstr[i] += 装备.装备描述(属性)[:-4] # 希洛克描述 if i in [2, 7, 9]: if 希洛克[i] != '': tempstr[i] += trans( '
{希洛克融合属性}：
') tempstr[i] += 希洛克[i] # 奥兹玛描述 if i in [1, 3, 4, 6, 10]: if 奥兹玛[i] != '': tempstr[i] += trans( '
{奥兹玛融合属性}：
') tempstr[i] += 奥兹玛[i] # 希洛克武器描述 if self.希洛克武器词条[0].currentIndex() > 0 and i == 11: tempstr[i] += trans( '
{希洛克融合属性}：
') if self.希洛克武器词条[0].currentIndex() == 1: tempstr[i] += trans("{属性1}：{$value} +10%
", value=武器词条属性[属性.词条选择[0]]) if 数量 == 3: tempstr[i] += trans("{属性2}：{$value} +5%
", value=武器词条属性[属性.词条选择[1]]) else: tempstr[i] += trans( "{属性1}：{$a} +$b%
", a=武器词条属性[self.希洛克武器词条[1].currentIndex()], b=(self.希洛克武器词条[3].currentIndex() + 3) * 2) if 数量 == 3: tempstr[i] += trans( "{属性2}：{$a} +$b%
", a=武器词条属性[self.希洛克武器词条[2].currentIndex()], b=(self.希洛克武器词条[4].currentIndex() + 3) * 1) if tempstr[i].endswith('
'): tempstr[i] = tempstr[i][:-4] tempstr[i] += '' return tempstr def 百分比输出(self, A, B): if B == 0: return self.格式化输出(str(int(A))) temp1 = A - B temp2 = round((A / B - 1) * 100, 2) if self.对比格式.isChecked(): if temp1 == 0: return '无变化' elif temp1 > 0: return '+' + self.格式化输出( str(int(temp1)), 1) + ' (' + str( '%.2f' % abs(temp2)) + '%)' else: return '' + self.格式化输出( str(int(temp1)), 1) + ' (' + str( '%.2f' % abs(temp2)) + '%)' else: if temp2 == 0: return '无变化' elif temp2 > 0: return '+' + str( '%.2f' % temp2) + '%' else: return '' + str( '%.2f' % temp2) + '%' def 被动技能描述(self, i): tempstr = '' if self.角色属性B.技能栏[i].所在等级 != 100 or self.角色属性B.技能栏[i].是否主动 == 0: if self.角色属性B.技能栏[i].等级 > 0: if self.角色属性B.技能栏[i].自定义描述 == 1: tempstr += '' + trans( self.角色属性B.技能栏[i].名称) + '
' tempstr += self.角色属性B.技能栏[i].技能描述(self.角色属性B.武器类型) else: 不适用于title = trans('({不适用于}：') if self.角色属性B.技能栏[i].关联技能 != [ '无' ] and self.角色属性B.技能栏[i].加成倍率(self.角色属性B.武器类型) != 1: 加成倍率key = '{加成倍率}：$value
' 关联技能title = trans('{关联技能}：') tempstr += trans( '{$value}
', value=self.角色属性B.技能栏[i].名称) tempstr += trans( 加成倍率key, value=to_percent( self.角色属性B.技能栏[i].加成倍率(self.角色属性B.武器类型) - 1, 2)) tempstr += 关联技能title for j in self.角色属性B.技能栏[i].关联技能: tempstr += trans(j) if j != self.角色属性B.技能栏[i].关联技能[-1]: tempstr += ',' if self.角色属性B.技能栏[i].非关联技能 != ['无']: tempstr += 不适用于title for j in self.角色属性B.技能栏[i].非关联技能: tempstr += trans(j) if j != self.角色属性B.技能栏[i].非关联技能[-1]: tempstr += ',' tempstr += ')' if self.角色属性B.技能栏[i].关联技能2 != ['无']: tempstr += "
" + trans( 加成倍率key, value=to_percent( self.角色属性B.技能栏[i].加成倍率2(self.角色属性B.武器类型) - 1, 2)) tempstr += 关联技能title for k in self.角色属性B.技能栏[i].关联技能2: tempstr += trans(k) if k != self.角色属性B.技能栏[i].关联技能2[-1]: tempstr += ',' if self.角色属性B.技能栏[i].非关联技能2 != ['无']: tempstr += 不适用于title for j in self.角色属性B.技能栏[i].非关联技能2: tempstr += trans(j) if j != self.角色属性B.技能栏[i].非关联技能2[-1]: tempstr += ',' tempstr += ')' if self.角色属性B.技能栏[i].关联技能3 != ['无']: tempstr += "
" + trans( 加成倍率key, value=to_percent( self.角色属性B.技能栏[i].加成倍率3(self.角色属性B.武器类型) - 1, 2)) tempstr += 关联技能title for l in self.角色属性B.技能栏[i].关联技能3: tempstr += trans(l) if l != self.角色属性B.技能栏[i].关联技能3[-1]: tempstr += ',' if self.角色属性B.技能栏[i].非关联技能3 != ['无']: tempstr += 不适用于title for j in self.角色属性B.技能栏[i].非关联技能3: tempstr += trans(j) if j != self.角色属性B.技能栏[i].非关联技能3[-1]: tempstr += ',' tempstr += ')' if self.角色属性B.技能栏[i].冷却关联技能 != [ '无' ] and self.角色属性B.技能栏[i].CD缩减倍率(self.角色属性B.武器类型) != 1: 冷却关联title = trans('{冷却关联技能}：') 冷却缩减key = "{冷却缩减}：$value
" if tempstr == '': tempstr += trans( '{$value}
', value=self.角色属性B.技能栏[i].名称) else: tempstr += '
' tempstr += trans( 冷却缩减key, value=to_percent( 1 - self.角色属性B.技能栏[i].CD缩减倍率(self.角色属性B.武器类型), 2)) tempstr += 冷却关联title for j in self.角色属性B.技能栏[i].冷却关联技能: tempstr += trans(j) if j != self.角色属性B.技能栏[i].冷却关联技能[-1]: tempstr += ',' if self.角色属性B.技能栏[i].非冷却关联技能 != ['无']: tempstr += 不适用于title for j in self.角色属性B.技能栏[i].非冷却关联技能: tempstr += trans(j) if j != self.角色属性B.技能栏[i].非冷却关联技能[-1]: tempstr += ',' tempstr += ')' if self.角色属性B.技能栏[i].冷却关联技能2 != ['无']: tempstr += trans( 冷却缩减key, value=to_percent( 1 - self.角色属性B.技能栏[i].CD缩减倍率2(self.角色属性B.武器类型), 2)) tempstr += 冷却关联title for j in self.角色属性B.技能栏[i].冷却关联技能2: tempstr += trans(j) if j != self.角色属性B.技能栏[i].冷却关联技能2[-1]: tempstr += ',' if self.角色属性B.技能栏[i].非冷却关联技能2 != ['无']: tempstr += 不适用于title for j in self.角色属性B.技能栏[i].非冷却关联技能2: tempstr += trans(j) if j != self.角色属性B.技能栏[i].非冷却关联技能2[-1]: tempstr += ',' tempstr += ')' if self.角色属性B.技能栏[i].冷却关联技能3 != ['无']: tempstr += trans( 冷却缩减key, value=to_percent( 1 - self.角色属性B.技能栏[i].CD缩减倍率3(self.角色属性B.武器类型), 2)) tempstr += 冷却关联title for j in self.角色属性B.技能栏[i].冷却关联技能3: tempstr += trans(j) if j != self.角色属性B.技能栏[i].冷却关联技能3[-1]: tempstr += ',' if self.角色属性B.技能栏[i].非冷却关联技能3 != ['无']: tempstr += 不适用于title for j in self.角色属性B.技能栏[i].非冷却关联技能3: tempstr += trans(j) if j != self.角色属性B.技能栏[i].非冷却关联技能3[-1]: tempstr += ',' tempstr += ')' return tempstr def 输出界面(self, index, name=''): # 调试模式下 index为-1 flag = 1 if index < 0: flag = 0 index = 0 武器名称 = '' for i in equ.get_equ_list(): if i.类型 == self.角色属性A.武器选项[0]: 武器名称 = i.名称 break #调试模式默认图标显示 self.排行数据.append([ '撒旦：沸腾之怒', '贝利亚尔：毁灭之种', '亚蒙：谎言之力', '亚巴顿：绝望地狱', '巴尔：堕落之魂', '白象之庇护', '四叶草之初心', '红兔之祝福', '军神的心之所念', '军神的遗书', '军神的庇护宝石', 武器名称, 0, '噩梦：地狱之路[2]', '噩梦：地狱之路[3]', '噩梦：地狱之路[5]', '幸运三角[2]', '幸运三角[3]', '军神的隐秘遗产[2]', '军神的隐秘遗产[3]', '无' ]) pdata = {} 装备名称 = self.排行数据[index][0:12] 套装名称 = self.排行数据[index][13:-1] 百变怪 = self.排行数据[index][-1] self.角色属性B = deepcopy(self.角色属性A) self.角色属性B.穿戴装备(装备名称, 套装名称) #C为站街属性 C = self.站街计算(装备名称, 套装名称) if flag == 1: self.角色属性B.其它属性计算() 词条提升率计算 = deepcopy(self.角色属性B) 统计详情 = self.角色属性B.伤害计算(1) # self.角色属性B.计算自适应方式 = 0 # 最大输出界面限制 if len(self.输出窗口列表) >= 10: del self.输出窗口列表[0] 输出窗口 = QWidget() 输出窗口.setStyleSheet('''QToolTip { background-color: black; color: white; border: 0px } QLabel { font-size:12px; }''') 输出窗口.setFixedSize(788, 546) pox_y = 18 pox_y2 = 11 temp = '' if name == '': temp += trans('详细数据') + ' 仅供参考 带节奏死个🐎' + ' ' + get_mac_address() # if self.角色属性A.计算自适应方式 == 1: # temp+= ' - 全局择优' # else: # temp+= ' - 局部择优' else: temp += name # temp += "装备版本："+self.角色属性A.版本 + " 增幅版本：" + self.角色属性A.增幅版本 输出窗口.setWindowTitle(temp) 输出窗口.setWindowIcon(self.icon) QLabel(输出窗口).setPixmap(self.输出背景图片) 人物 = QLabel(输出窗口) 图片 = QPixmap('./ResourceFiles/' + self.角色属性A.实际名称 + "/人物.png") 人物.setPixmap(图片) 人物.move(90 + int(45 - 图片.width() / 2), 40 - pox_y2) 人物.resize(90, 90) 人物.setAlignment(Qt.AlignTop) excel = [] for i in range(len(self.角色属性B.技能栏)): excel.append(统计详情[i * 4 + 1]) excel.sort() 面板显示 = [] for i in range(18): 面板显示.append(QLabel(输出窗口)) self.面板布局设置(面板显示) self.面板显示设置(面板显示, self.角色属性B, C) j = 312 pdata['词条'] = self.词条显示计算(self.角色属性B) 词条解释 = self.词条显示计算(self.角色属性B, 1) for i in range(0, len(pdata['词条'])): templab = QLabel(输出窗口) templab.setText(pdata['词条'][i]) if i == 5 and self.角色属性B.技能攻击力累加 > 2: templab.setStyleSheet( "QLabel{font-size:12px;color:red}") else: templab.setStyleSheet( "QLabel{font-size:12px;color:rgb(104,213,237)}") templab.move(7, j - pox_y2) templab.resize(180, 17) templab.setAlignment(Qt.AlignLeft) templab.setToolTip('' + 词条解释[i] + '') j += 17 位置 = 308 间隔 = 17 套装名称显示 = [] for i in range(16): 套装名称显示.append(QLabel(输出窗口)) 套装名称显示[i].move(114, 位置 - pox_y2 + 间隔 * i) 套装名称显示[i].resize(150, 18) 套装名称显示[i].setAlignment(Qt.AlignCenter) 套装名称显示[i].setText('') self.套装显示设置(套装名称显示, self.角色属性B) 实际技能等级 = [] 技能等效CD = [] for i in self.角色属性B.技能栏: 实际技能等级.append(i.等级) if i.是否有伤害 == 1: 技能等效CD.append(i.等效CD(self.角色属性B.武器类型, self.角色属性B.类型)) else: 技能等效CD.append(0) 总伤害数值 = 0 count = 0 for i in range(len(self.角色属性B.技能栏)): if 统计详情[i * 4 + 1] != 0: count += 1 self.行高 = 32 伤害列表 = [] for i in range(len(self.角色属性B.技能栏)): 伤害列表.append(统计详情[i * 4 + 1]) 总伤害数值 += 统计详情[i * 4 + 1] 伤害列表.sort(reverse=True) try: self.exports_store() 更新人物名望() # TODO: 重新布局 总名望 = store.get("/fame/temp_result") 名望详情 = store.get("/fame/temp_result/detail") if 总名望 > 0: dmi = ((总伤害数值 / 1e8) / pow((总名望 / (1e4) - 0.5), 3)) templabel = QLabel(输出窗口) templabel.setText("{} ({})".format(总名望, round(dmi, 2))) templabel.setStyleSheet( "QLabel{font-size:12px;color:rgb(255,255,255)}") templabel.move(130, 110) templabel.resize(100, 42) templabel.setToolTip( '系数计算公式:dmi = ((总伤害数值 / 1e8) / pow((总名望 / (1e4) - 0.5), 3))
' + str(名望详情)) except Exception as e: logger.error(e) if len(self.基准值) != 0: 显示模式 = 1 else: 显示模式 = 0 main = 技能详情(输出窗口, self, 统计详情, excel, 实际技能等级, 技能等效CD, 显示模式, count) pdata['技能'] = main.data main.setGeometry(277, 36 - pox_y, 498, 455) # region 被动详情 num = 0 for i in range(len(self.角色属性B.技能栏)): # Will修改 tempstr = self.被动技能描述(i) if tempstr != '': tempstr += '' 被动数据 = QLabel(输出窗口) 被动数据.setPixmap(self.技能图片[i]) 被动数据.setToolTip(tempstr) 被动数据.move(293 + num * 40, 500 - pox_y) 被动等级 = QLabel(输出窗口) 被动等级.setText('Lv.' + str(实际技能等级[i])) 被动等级.move(293 - 6 + num * 40, 480 - pox_y) 被动等级.resize(40, 28) if 实际技能等级[i] != 0: 被动等级.setStyleSheet( "QLabel{font-size:12px;color:rgb(255,255,255)}") else: 被动等级.setStyleSheet( "QLabel{font-size:12px;color:rgb(255,0,0)}") 被动等级.setAlignment(Qt.AlignCenter) num += 1 if self.角色属性B.远古记忆 > 0: 被动数据 = QLabel(输出窗口) 被动数据.setPixmap((QPixmap('./ResourceFiles/img/远古记忆.png'))) tempstr = trans( '{远古记忆}
{智力}+$value', value=self.角色属性B.远古记忆 * 15) 被动数据.setToolTip(tempstr) 被动数据.move(293 + num * 40, 500 - pox_y) 被动等级 = QLabel(输出窗口) 被动等级.setText('Lv.' + str(self.角色属性B.远古记忆)) 被动等级.move(293 - 6 + num * 40, 480 - pox_y) 被动等级.resize(40, 28) 被动等级.setAlignment(Qt.AlignCenter) 被动等级.setStyleSheet("QLabel{font-size:12px;color:rgb(255,255,255)}") num += 1 if self.角色属性B.刀魂之卡赞 > 0: 被动数据 = QLabel(输出窗口) 被动数据.setPixmap((QPixmap('./ResourceFiles/img/刀魂之卡赞.png'))) tempstr = trans( '{刀魂之卡赞}
{力量、智力}+$value', value=刀魂之卡赞数据[self.角色属性B.刀魂之卡赞]) 被动数据.setToolTip(tempstr) 被动数据.move(293 + num * 40, 500 - pox_y) 被动等级 = QLabel(输出窗口) 被动等级.setText('Lv.' + str(self.角色属性B.刀魂之卡赞)) 被动等级.move(293 - 6 + num * 40, 480 - pox_y) 被动等级.resize(40, 28) 被动等级.setAlignment(Qt.AlignCenter) 被动等级.setStyleSheet("QLabel{font-size:12px;color:rgb(255,255,255)}") num += 1 # endregion 总伤害 = QLabel(输出窗口) 总伤害.setStyleSheet("QLabel{color:rgb(255,255,255);font-size:25px}") if 显示模式 == 1: 总伤害.setText(self.百分比输出(总伤害数值, self.基准值[0])) else: 总伤害.setText(self.格式化输出(str(int(总伤害数值)))) 总伤害.resize(250, 36) 总伤害.move(10, 520 - pox_y2) 总伤害.setAlignment(Qt.AlignCenter) 初始x = 10 初始y = 31 图片列表 = self.获取装备图片(self.排行数据[index]) 偏移量 = 187 x坐标 = [ 32, 0, 0, 32, 0, 偏移量, 偏移量 + 32, 偏移量 + 32, 偏移量, 偏移量, 偏移量 + 32, 32 ] y坐标 = [0, 0, 32, 32, 64, 0, 0, 32, 64, 32, 64, 64] tempstr = self.装备描述计算(self.角色属性B) for i in range(12): 装备图标 = QLabel(输出窗口) 装备图标.setMovie(图片列表[i]) 装备图标.resize(26, 26) 装备图标.move(初始x + x坐标[i], 初始y + y坐标[i] - pox_y2) 装备图标.setAlignment(Qt.AlignCenter) if self.角色属性B.装备栏[i] == 百变怪: 图标遮罩 = QLabel(输出窗口) 图标遮罩.setStyleSheet("QLabel{background-color:rgba(0,0,0,0.5)}") 图标遮罩.resize(26, 26) 图标遮罩.move(初始x + x坐标[i], 初始y + y坐标[i] - pox_y2) 图标遮罩.setToolTip(tempstr[i]) else: 装备图标.setToolTip(tempstr[i]) 打造显示 = [] for i in range(13): 打造显示.append(QLabel(输出窗口)) 打造显示[i].move(-100, -100) temp = self.打造显示设置(打造显示, self.角色属性B) pdata['名称'] = self.角色属性A.实际名称 pdata['装备'] = temp if 多语言开关 == 0: label = QLabel(输出窗口) label.setText(get_mac_address()) label.setStyleSheet( f'QLabel{{font-size:15px;{make_watermark_qt_color_string(watermark_surrounding_backgroud_color_detail)};font-weight:bolder}}' ) label.move(290, 540 - pox_y) butten = QtWidgets.QPushButton(trans('输出技能数据'), 输出窗口) butten.clicked.connect( lambda state, d=deepcopy(pdata): self.输出数据(d)) butten.move(676, 540 - pox_y) butten.setStyleSheet(按钮样式) butten.resize(90, 21) 词条提升率计算.输出提升率 = 总伤害数值 butten = QtWidgets.QPushButton(trans('输出择优数据'), 输出窗口) butten.clicked.connect(lambda state: 词条提升率计算.伤害计算(0)) butten.move(575, 540 - pox_y) butten.setStyleSheet(按钮样式) butten.resize(90, 21) 输出显示 = MainWindow(输出窗口) self.输出窗口列表.append(输出显示) 输出显示.show() def 输出数据(self, d): try: increase_counter(ga_category="carry详细功能使用", name="输出技能数据") path = './详细数据' if not os.path.exists(path): os.makedirs(path) count = max(len(d['装备']), len(d['词条']), len(d['技能'])) rows = [] for i in range(count): t = d['词条'][i].split('：') if i < len(d['词条']) else [] rows.append([ (str(d['装备'][i]) if i < len(d['装备']) else ''), (str(t[0][-2] + t[0][-1]) if i < len(d['词条']) else ''), (str(t[1]) if i < len(d['词条']) else ''), '', (str(d['技能'][i][0]) if i < len(d['技能']) else ''), (str(d['技能'][i][1]) if i < len(d['技能']) else ''), (str(d['技能'][i][2]) if i < len(d['技能']) else ''), (str(d['技能'][i][3]) if i < len(d['技能']) else ''), (str(d['技能'][i][4]) if i < len(d['技能']) else ''), (str(d['技能'][i][5]) if i < len(d['技能']) else ''), (str(d['技能'][i][6]) if i < len(d['技能']) else ''), (str(d['技能'][i][7]) if i < len(d['技能']) else ''), ]) result_path = os.path.join( path, '{}-{}.csv'.format(d['名称'], time.strftime('%m-%d-%H-%M-%S'))) result = open(result_path, 'w', encoding='gbk') result.write( "装备,词条类型,词条数值,,技能名称,技能等级,技能CD,技能次数,总伤害,平均伤害,伤害占比,技能倍率\n") for row in rows: result.write(','.join(row) + '\n') result.close() os.startfile(result_path) except Exception as error: pass # endregion # region 输入属性 def 输入属性(self, 属性, x=0): i = self.攻击目标.currentIndex() 属性.防御输入 = 攻击目标[i][1] 属性.火抗输入 = 攻击目标[i][2] 属性.冰抗输入 = 攻击目标[i][3] 属性.光抗输入 = 攻击目标[i][4] 属性.暗抗输入 = 攻击目标[i][5] if self.初始属性.远古记忆 != -1: 属性.远古记忆 = self.远古记忆.currentIndex() if self.初始属性.刀魂之卡赞 != -1: 属性.刀魂之卡赞 = self.刀魂之卡赞.currentIndex() 属性.自适应选项 = copy([(1 if self.红色宠物装备.isChecked() else 0), (1 if self.光环自适应.isChecked() else 0)]) # 属性.计算自适应方式 = self.单套择优方式选项.currentIndex() if self.转甲选项.isChecked(): 属性.转甲选项 = 1 else: 属性.转甲选项 = 0 for j in [self.等级调整, self.TP输入, self.次数输入, self.宠物次数]: for i in j: if i != '' and i.currentIndex() == -1: i.setCurrentIndex(0) for i in 属性.技能栏: i.等级 = i.基础等级 + int(self.等级调整[self.角色属性A.技能序号[i.名称]].currentData()) if i.是否有伤害 == 1: if i.TP上限 != 0: i.TP等级 = int( self.TP输入[self.角色属性A.技能序号[i.名称]].currentData()) if x == 0: self.辟邪玉属性计算(属性) elif x >= 100: y = x - 100 辟邪玉列表[y].当前值 = 辟邪玉列表[y].最大值 辟邪玉列表[y].穿戴属性(属性) if sum(self.希洛克选择状态) == 3: 属性.武器词条触发 = 1 if self.希洛克武器词条[0].currentIndex() == 1: 属性.希洛克武器词条 = 1 elif self.希洛克武器词条[0].currentIndex() == 2: 词条属性列表[self.希洛克武器词条[1].currentIndex()].加成属性( 属性, (self.希洛克武器词条[3].currentIndex() + 3) * 0.02) if 属性.武器词条触发 == 1: 词条属性列表[self.希洛克武器词条[2].currentIndex()].加成属性( 属性, (self.希洛克武器词条[4].currentIndex() + 3) * 0.01) try: 属性.时间输入 = int(float(self.时间输入.currentText())) except: 属性.时间输入 = 25 属性.次数输入.clear() 属性.宠物次数.clear() 属性.装备切装.clear() 属性.技能切装.clear() self.是否计算 = 1 for i in self.角色属性A.技能栏: 序号 = self.角色属性A.技能序号[i.名称] if i.是否有伤害 == 1: s = self.次数输入[序号].currentText() s = s.replace('，', ',').replace('（', '(').replace('）', ')') try: if eval(s.replace('/CD', '1')) >= 0: 属性.次数输入.append(s) except Exception as e: logger.error(e) QMessageBox.information(self, "错误", "“{}”技能次数输入错误，请重新输入".format(i.名称)) self.是否计算 = 0 break s = self.宠物次数[序号].currentText().replace('，', ',').replace( '（', '(').replace('）', ')') try: if eval(s.replace('num', '1')) >= 0: 属性.宠物次数.append(s) except: QMessageBox.information(self, "错误", "“{}”宠物次数输入错误，请重新输入".format(i.名称)) self.是否计算 = 0 break if 切装模式 == 1: if self.技能切装[序号].isChecked(): 属性.技能切装.append(1) else: 属性.技能切装.append(0) else: 属性.次数输入.append('0') 属性.宠物次数.append('0') 属性.技能切装.append(0) if 切装模式 == 1: for i in range(12): if self.装备切装[i].isChecked(): 属性.装备切装.append(self.自选装备[i].currentData()) else: 属性.装备切装.append('无') for i in range(len(self.复选框列表)): if self.复选框列表[i].isChecked(): 选项设置列表[选项设置序号[self.复选框列表list[i]]].适用效果(属性) count = 0 count2 = 0 for i in equ.get_equ_list(): if i.品质 == '神话': i.属性1选择 = self.神话属性选项[count * 4 + 0].currentIndex() i.属性2选择 = self.神话属性选项[count * 4 + 1].currentIndex() i.属性3选择 = self.神话属性选项[count * 4 + 2].currentIndex() i.属性4选择 = self.神话属性选项[count * 4 + 3].currentIndex() count += 1 if i.所属套装 == '智慧产物': i.属性1选择 = self.改造产物选项[count2 * 4 + 0].currentIndex() i.属性2选择 = self.改造产物选项[count2 * 4 + 1].currentIndex() i.属性3选择 = self.改造产物选项[count2 * 4 + 2].currentIndex() i.属性4选择 = self.改造产物选项[count2 * 4 + 3].currentIndex() count2 += 1 属性.攻击属性 = self.攻击属性选项.currentIndex() 称号列表[self.称号.currentIndex()].城镇属性(属性) if 属性.称号触发: 称号列表[self.称号.currentIndex()].触发属性(属性) 宠物列表[self.宠物.currentIndex()].城镇属性(属性) self.加载护石(属性) for i in range(12): 属性.是否增幅[i] = self.装备打造选项[i].currentIndex() 属性.强化等级[i] = self.装备打造选项[i + 12].currentIndex() 属性.改造等级[i] = self.装备打造选项[i + 24].currentIndex() 属性.武器锻造等级 = self.装备打造选项[36].currentIndex() 属性.类型 = self.装备打造选项[37].currentData() try: 属性.主BUFF = float(self.BUFF输入.text()) / 100 + 1 except: QMessageBox.information(self, "错误", "BUFF数值输入错误,已设置为默认数值") self.BUFF输入.setText(str('%.1f' % ((self.角色属性A.主BUFF - 1) * 100))) try: if self.觉醒选择状态 == 1: 属性.觉醒之抉择技能 = 属性.技能栏[self.一觉序号].名称 elif self.觉醒选择状态 == 2: 属性.觉醒之抉择技能 = 属性.技能栏[self.二觉序号].名称 if self.角色属性A.屏蔽三觉 == True: 属性.技能栏[self.三觉序号].关联技能 = ['无'] else: if self.角色属性A.技能栏[self.三觉序号].是否有伤害 == 1 and str( 属性.次数输入[self.三觉序号]) == '0': 属性.技能栏[self.三觉序号].关联技能 = ['无'] else: 属性.技能栏[self.三觉序号].关联技能 = [属性.觉醒之抉择技能] except: pass 属性.角色熟练度 = self.装备条件选择[0].currentIndex() 属性.技能栏空位 = self.装备条件选择[1].currentIndex() 属性.命运的抉择 = self.装备条件选择[2].currentIndex() 属性.天命无常 = self.装备条件选择[3].currentIndex() 属性.悲剧的残骸 = self.装备条件选择[4].currentIndex() 属性.先知者的预言 = self.装备条件选择[5].currentIndex() 属性.贫瘠沙漠的遗产 = self.装备条件选择[6].currentIndex() 属性.幸运三角 = self.装备条件选择[7].currentIndex() 属性.擎天战甲 = self.装备条件选择[8].currentIndex() 属性.持续伤害计算比例 = 1 - 0.01 * self.装备条件选择[9].currentIndex() 属性.军神的隐秘遗产 = self.装备条件选择[10].currentIndex() 属性.太极天帝剑 = self.装备条件选择[11].currentIndex() 属性.噙毒手套 = self.装备条件选择[12].currentIndex() # 属性.绿色生命的面容 = self.装备条件选择[12].currentIndex() 属性.产物升级 = 1 if self.智慧产物升级.isChecked() else 0 属性.黑鸦武器择优模式 = self.武器择优模式.currentIndex() 属性.黑鸦词条 = [] for i in range(4): temp = [ self.黑鸦词条[i][0].currentIndex(), self.黑鸦词条[i][1].currentIndex(), ((2 if i > 0 else 4)) * (self.黑鸦词条[i][2].currentIndex() + 1), 0 ] 属性.黑鸦词条.append(temp) self.希洛克属性计算(属性) self.奥兹玛属性计算(属性) self.基础属性(属性) def 基础属性(self, 属性): if 切装模式 == 1: 属性.切装修正.clear() 名称 = ['力量', '智力', '物攻', '魔攻', '独立', '属强'] num = 0 for i in self.切装修正属性: try: if i.text() != '': 属性.切装修正.append(int(i.text())) else: 属性.切装修正.append(0) except: QMessageBox.information(self, "错误", 名称[num] + " 切装修正输入格式错误，已重置为空") i.setText('') 属性.切装修正.append(0) num += 1 for i in range(len(self.列名称) - 3): for j in range(len(行名称1)): if self.属性设置输入[i][j].text() != '': try: float(self.属性设置输入[i][j].text()) except: QMessageBox.information( self, "错误", self.行名称[(j + len(行名称1)) if i >= len(列名称1) else j] + "：" + self.列名称[i] + " 输入格式错误，已重置为空") self.属性设置输入[i][j].setText('') temp = [] num = len(self.列名称) - 3 for j in range(len(self.属性设置输入[num])): if self.属性设置输入[num][j].text() != '': try: temp.append(float(self.属性设置输入[num][j].text()) / 100) if temp[-1] > 1 or temp[-1] < -0.2: QMessageBox.information( self, "错误", self.修正列表名称[j] + " 输入数值超出[-20,100]，已重置为空") temp[-1] = 0.0 self.属性设置输入[num][j].setText('') except: temp.append(0.0) QMessageBox.information(self, "错误", self.修正列表名称[j] + " 输入格式错误，已重置为空") self.属性设置输入[num][j].setText('') else: temp.append(0.0) 属性.百分比力智加成(temp[0]) 属性.百分比三攻加成(temp[1]) 属性.伤害增加加成(temp[2]) 属性.附加伤害加成(temp[3]) 属性.属性附加加成(temp[4]) 属性.暴击伤害加成(temp[5]) 属性.最终伤害加成(temp[6]) 属性.技能攻击力加成(temp[7]) for i in [0, 6, 9]: for j in range(17): if self.属性设置输入[i][j].text() != '': if i == 0 and j in [1, 5, 10, 16]: 属性.进图力量 += float(self.属性设置输入[i][j].text()) else: 属性.力量 += float(self.属性设置输入[i][j].text()) for i in [1, 6, 9]: for j in range(17): if self.属性设置输入[i][j].text() != '': if i == 1 and j in [1, 5, 10, 16]: 属性.进图智力 += float(self.属性设置输入[i][j].text()) else: 属性.智力 += float(self.属性设置输入[i][j].text()) for i in [2, 7, 10]: for j in range(17): if self.属性设置输入[i][j].text() != '': if i == 2 and j in [1, 5, 10, 16]: 属性.进图物理攻击力 += float(self.属性设置输入[i][j].text()) else: 属性.物理攻击力 += float(self.属性设置输入[i][j].text()) for i in [3, 7, 10]: for j in range(17): if self.属性设置输入[i][j].text() != '': if i == 3 and j in [1, 5, 10, 16]: 属性.进图魔法攻击力 += float(self.属性设置输入[i][j].text()) else: 属性.魔法攻击力 += float(self.属性设置输入[i][j].text()) for i in [4, 7, 10]: for j in range(17): if self.属性设置输入[i][j].text() != '': if i == 4 and j in [1, 5, 10, 16]: 属性.进图独立攻击力 += float(self.属性设置输入[i][j].text()) else: 属性.独立攻击力 += float(self.属性设置输入[i][j].text()) for i in [5, 8]: for j in range(17): if self.属性设置输入[i][j].text() != '': if i == 5 and j in [1, 5, 10, 16]: 属性.进图属强 += float(self.属性设置输入[i][j].text()) elif i == 5 and j == 3: # 3为婚房不吃辟邪玉 属性.所有属性强化(float(self.属性设置输入[i][j].text())) else: 属性.所有属性强化加成(float(self.属性设置输入[i][j].text())) for i in self.细节选项输入: for j in i: if j.isEnabled(): if j.currentData() not in ['', '无']: try: 细节选项列表[细节选项序号[j.currentData()]].效果(属性) except: for k in 属性.技能栏: if j.currentData() == k.名称 + 'Lv+1': k.等级加成(1) break if self.奶量buff输入[0].text() not in ['', '无']: # print(属性.力量) 属性.进图力量 += int(self.奶量buff输入[0].text()) 属性.进图智力 += int(self.奶量buff输入[0].text()) # print(属性.力量) if self.奶量buff输入[1].text() not in ['', '无']: 属性.进图物理攻击力 += int(self.奶量buff输入[1].text()) 属性.进图魔法攻击力 += int(self.奶量buff输入[1].text()) 属性.进图独立攻击力 += int(self.奶量buff输入[1].text()) # 守门人全属强方案 if self.守门人全属强.isChecked(): if self.属性设置输入[0][14].text() != '': 属性.力量 -= float(self.属性设置输入[0][14].text()) if self.属性设置输入[1][14].text() != '': 属性.智力 -= float(self.属性设置输入[1][14].text()) if self.属性设置输入[2][14].text() != '': 属性.物理攻击力 -= float(self.属性设置输入[2][14].text()) if self.属性设置输入[3][14].text() != '': 属性.魔法攻击力 -= float(self.属性设置输入[3][14].text()) if self.属性设置输入[4][14].text() != '': 属性.独立攻击力 -= float(self.属性设置输入[4][14].text()) if self.属性设置输入[5][7].text() != '': 属性.所有属性强化加成(-(float(self.属性设置输入[5][7].text()))) if self.属性设置输入[5][14].text() != '': 属性.所有属性强化加成(-(float(self.属性设置输入[5][14].text()))) for j in range(5, 10): if self.属性设置输入[6][j].text() != '': 属性.力量 -= float(self.属性设置输入[6][j].text()) 属性.智力 -= float(self.属性设置输入[6][j].text()) if self.属性设置输入[7][j].text() != '': 属性.物理攻击力 -= float(self.属性设置输入[7][j].text()) 属性.魔法攻击力 -= float(self.属性设置输入[7][j].text()) 属性.独立攻击力 -= float(self.属性设置输入[7][j].text()) if self.属性设置输入[8][j].text() != '': 属性.所有属性强化加成(-(float(self.属性设置输入[8][j].text()))) 属性.物理攻击力 += 60 属性.魔法攻击力 += 60 属性.独立攻击力 += 60 属性.所有属性强化加成(int(28 * 3 + 12 + 30 + 7)) # 龙珠时附魔不替换 if self.属性设置输入[7][11].text() == '' or self.属性设置输入[8][11].text( ) == '': if self.属性设置输入[6][11].text() != '': 属性.力量 -= float(self.属性设置输入[6][11].text()) 属性.智力 -= float(self.属性设置输入[6][11].text()) if self.属性设置输入[7][11].text() != '': 属性.物理攻击力 -= float(self.属性设置输入[7][11].text()) 属性.魔法攻击力 -= float(self.属性设置输入[7][11].text()) 属性.独立攻击力 -= float(self.属性设置输入[7][11].text()) if self.属性设置输入[8][11].text() != '': 属性.所有属性强化加成(-(float(self.属性设置输入[8][11].text()))) # 武器全属强为13 属性.所有属性强化加成(int(13)) # endregion