import importlib from copy import deepcopy from pyclbr import Function from typing import Dict, List, Union from uuid import uuid1 from utils.exception import ResponseException from core.basic.equipment import equipment, get_equ, get_global_data from core.basic.property import CharacterProperty from core.basic.skill import 主动技能, 技能, 被动技能 from core.equipment.avatar import 装扮套装, 装扮套装集合, 装扮集合 from core.equipment.emblems import get_emblems_setinfo from core.equipment.enchanting import get_enchanting_setinfo from core.equipment.jade import get_jade_setinfo from core.equipment.property import ( 增幅计算, 左右计算, 成长词条计算, 武器强化计算, 精通计算, 耳环计算, 获取基础属性, 获取属性抗性基础, 获取异常抗性基础, 辅助精通计算, 部位列表, 锻造四维, 锻造计算, ) from core.equipment.sundry import get_sundries_setinfo # from core.basic.enchanting import get_encfunc_by_id # from core.basic.emblems import get_embfunc_by_id # from core.basic.jade import get_jadefunc_by_id MAXEQULV = 105 class Character(CharacterProperty): 等级 = 110 # 辟邪玉属性 附加伤害增加增幅: float = 1.0 属性附加伤害增加增幅: float = 1.0 技能伤害增加增幅: float = 1.0 暴击伤害增加增幅: float = 1.0 伤害增加增幅: float = 1.0 最终伤害增加增幅: float = 1.0 力量智力增加增幅: float = 1.0 物理魔法攻击力增加增幅: float = 1.0 所有属性强化增幅: float = 1.0 version = "default" equVersion = "" bufferCarry = False 等级: int = 110 防御输入: int = 506109 防御系数: int = 1 火抗输入: int = 0 冰抗输入: int = 0 光抗输入: int = 0 暗抗输入: int = 0 打造详情: Dict[str, Dict[str, int]] = {} 装备栏: List[int] = [] # [装备id] 部位装备: Dict[str, int] = {} # {部位: 装备id} 部位附魔: Dict[str, Function] = {} # {部位: 附魔函数} 词条等级: Dict[str, List[int]] = {} # {部位: [等级1, 2, 3, 4]} 药剂: List[int] = [] # 需要职业自定义数据 实际名称 = "" 名称 = "" 角色 = "" 角色类型 = "" 职业 = "" 武器选项: List[str] = [] 输出类型选项: List[str] = [] 防具精通属性: List[str] = [] 排行类型 = "物理百分比" 适用属性 = "智力" 适用数值 = 0 类型 = "" 武器类型 = "" 防具类型 = "" 转职 = "" # 技能栏: List[技能 | 主动技能 | 被动技能] = [] # 技能序号: Dict[int, 技能 | 主动技能 | 被动技能] = {} 技能栏: List[Union[技能, 主动技能, 被动技能]] = [] 技能序号: Dict[str, int] = {} 自定义词条: Dict[int, List[int]] = {} buff: float = 1.00 hotkey: List[str] = [""] * 14 技能队列 = [] 护石技能 = [] 护石栏 = [] 符文 = [] skills_passive: Dict = {} 融合列表 = [] 武器融合 = [] 装扮栏: Dict[str, int] = {} 装扮选项: Dict[str, str] = {} # 职业技能特殊选项 individuation: Dict[str, int] = {} 技攻列表: Dict[str, List[float]] = {} 打造: Dict = {} 觉醒技能 = [] 冷却缩减 = 1.0 冷却恢复 = 0.0 tip_part: List[str] = [] trigger_set = {} eq_params = {} suits = [] 特性列表 = [] def __init__(self, equVersion="") -> None: self.equVersion = equVersion self.eq_params = {} # 计算变量 ########## self.__基础力量: int = 0 self.__基础智力: int = 0 self.__基础体力: int = 0 self.__基础精神: int = 0 self.进图力量: int = 0 self.进图智力: int = 0 self.__进图体力: int = 0 self.__进图精神: int = 0 self.__进图三攻: int = 0 self.__BUFF补正智力: int = 0 self.__BUFF补正体力: int = 0 self.__BUFF补正精神: int = 0 self.__力量: int = 0 self.__智力: int = 0 self.__体力: int = 0 self.__精神: int = 0 self.系统奶系数: float = 0.0 self.系统奶基数: float = 0.0 self.冷却缩减 = 1.0 self.冷却恢复 = 0 self.斗神宠物 = 1.0 # self.年宠技能 = False # self.白兔子技能 = False # self.斗神之吼秘药 = False self.辅助对象力智 = 5000 self.辅助对象三攻 = 3000 self.__物理攻击力: int = 65 self.__魔法攻击力: int = 65 self.__独立攻击力: int = 1134 self.__火属性强化: float = 13 self.__冰属性强化: float = 13 self.__光属性强化: float = 13 self.__暗属性强化: float = 13 # 旧词条 self.__百分比力智: float = 0.0 self.__百分比三攻: float = 0.0 self.__伤害增加: float = 0.0 self.__附加伤害: float = 0.0 self.__属性附加: float = 0.0 self.__暴击伤害: float = 0.0 self.__最终伤害: float = 0.0 self.技能攻击力: float = 1.0 self.__面板技能攻击力: float = 1.0 self.技能攻击力累加: float = 0.0 self.__持续伤害: float = 0.0 self.__加算冷却缩减: float = 0.0 self.__百分比减防: float = 0.0 self.__固定减防: int = 0 self.__buff固定力智: int = 0 self.__buff百分比力智: float = 1.0 self.__buff固定三攻: int = 0 self.__buff百分比三攻: float = 1.0 self.__觉醒固定力智: int = 0 self.__觉醒百分比力智: float = 1.0 self.__觉醒百分比力智Total: float = 1.0 # 其它词条 self.__攻击速度: float = 0.00 self.__攻击速度_其他: float = 0.00 self.__移动速度: float = 0.00 self.__施放速度: float = 0.00 self.__命中率: float = 0.0 self.__回避率: float = 0.0 self.__物理暴击率: float = 0.00 self.__魔法暴击率: float = 0.00 self.__火属性抗性: int = 0 self.__冰属性抗性: int = 0 self.__光属性抗性: int = 0 self.__暗属性抗性: int = 0 self.属强抗性倍率 = 1.0 # 新属性 self.__攻击强化: int = 0 self.__百分比攻击强化: float = 0.0 self.__buff量: int = 0 self.__百分比buff量: float = 0.0 self.__基础精通倍率: float = 1.0 self.伤害比例: Dict[str, float] = { "直伤": 1.0, "中毒": 0.0, "灼伤": 0.0, "感电": 0.0, "出血": 0.0, } self.伤害系数: Dict[str, float] = { "中毒": 1.0, "灼伤": 1.0, "感电": 1.0, "出血": 1.0, } self.特效 = [] self.__异常抗性: Dict[str, float] = {} self.__异常抗性_职业基础: Dict[str, float] = {} self.__指令效果: Dict[str, float] = {} self.__MP消耗量: float = 1.0 self.觉醒技能 = [] self.skills_passive = {} self.异常基础加成 = { "中毒": 1.1, "灼伤": 1.0, "感电": 1.05, "出血": 1.1, "灼伤破冰": 1.1, } self.异常结算加成 = { "中毒": 1.0, "灼伤": 1.0, "感电": 1.0, "出血": 1.0, "灼伤破冰": 1.0, } self.异常时间 = { # 基础持续时间 持续时间增加值 持续时间增加率 CD "中毒": [5, 0, 1.0, 99], "灼伤": [5, 0, 1.0, 99], "感电": [10, 0, 1.0, 99], "出血": [3, 0, 1.0, 99], "冰冻": [5, 0, 10, 99], } self.打造 = {} self.trigger_set = {} for item in 部位列表 + ("称号", "宠物"): self.打造[item] = { # 成长 "attack": [0] * 4, # 成长 "buffer": [0] * 4, # 强化 "强化四维": [0] * 4, # 增幅 "增幅四维": [0] * 4, # 攻击力 "强化攻击力": [0] * 3, # 独立,四维 "锻造加成": [0] * 2, "params": [[None]] * 4, "tips": [], } self.tip_part = [] if self.转职 == "": self.转职 = self.职业 # 设置基础属性 self.__设置基础属性() self.技攻列表 = {} def __设置基础属性(self): temp = 获取基础属性(self.角色, self.职业) self.__基础力量 = temp[0] self.__基础智力 = temp[1] self.__基础体力 = temp[2] self.__基础精神 = temp[3] self.__力量 = self.__基础力量 self.__智力 = self.__基础智力 self.__体力 = self.__基础体力 self.__精神 = self.__基础精神 temp = 获取属性抗性基础(self.角色, self.职业) self.__火属性抗性 += temp[0] self.__冰属性抗性 += temp[1] self.__光属性抗性 += temp[2] self.__暗属性抗性 += temp[3] temp = 获取异常抗性基础(self.角色, self.职业) 异常状态 = [ "出血", "中毒", "灼伤", "感电", "冰冻", "减速", "眩晕", "诅咒", "失明", "石化", "睡眠", "混乱", "束缚", ] for index in range(0, len(异常状态)): self.异常抗性加成(异常状态[index], temp[index], mode=0) def 职业特殊设置(self): pass # region 返回前端信息 def getinfo(self) -> Dict: info = {} info["alter"] = self.实际名称 info["version"] = self.version info["name"] = self.名称 info["character"] = self.职业 info["role"] = "buffer" if self.类型 == "辅助" else "delear" info["weapon_types"] = self.武器选项 info["carry_type_list"] = self.输出类型选项 info["armor"] = self.防具类型 info["armor_mastery"] = self.防具精通属性 info["buff_ratio"] = self.buff self.set_skill_info(info) self.set_individuation(info) dress_list = {} i = 0 for dress in 装扮集合: 部位 = dress.部位 if 部位 not in dress_list: dress_list[部位] = [] 选项集合 = dress.选项集合 if dress.部位 == "上衣": 选项集合 = 选项集合 + tuple(info["clothes_coat"]) elif dress.部位 == "下装": 选项集合 = 选项集合 + tuple(info["clothes_pants"]) data = {} data["id"] = i data["options"] = 选项集合 data["part"] = 部位 data["rarity"] = dress.品质 data["suit"] = dress.套装 data["name"] = "{品质}装扮{部位}".format(品质=dress.品质, 部位=dress.部位) i += 1 dress_list[部位].append(data) info["dress"] = dress_list info["enchanting"] = get_enchanting_setinfo(self) info["emblem"] = get_emblems_setinfo(self) info["jade"] = get_jade_setinfo() info["especificity"] = get_equ(self.equVersion).get_funs_info( "specificity", self ) info["asrahan"] = get_equ(self.equVersion).get_funs_info("asrahan", self) info["sundries"] = get_sundries_setinfo() for item in info["platinum"]: info["emblem"].append( { "id": item, "maxFame": 232, "position": ["辅助装备", "魔法石"], "props": item + " Lv+1" + " 四维 + 8", "type": "技能", "rarity": "白金", "rate": 2000, } ) return info def set_skills(self): pass def get_acitve_skill_detail( self, skill, temp_info, temp_char, weapon, ratio, skill_info ): if skill.是否有伤害: if len(skill.形态) == 0: skill.形态 = [""] if ( self.实际名称 == "elven_knight" and len(list(filter(lambda x: "6c" in x, skill.形态))) > 0 ): skill.形态 = list(filter(lambda x: "6c" in x, skill.形态)) for 形态 in skill.形态: original = 0 for i in ["直伤", "中毒", "灼伤", "感电", "出血"]: original += skill.等效百分比( char=temp_info, 武器类型=weapon, 形态=形态, 伤害类型=i ) skill_info["skills_active"].append( { "name": skill.名称, "need_level": skill.所在等级, "lv": skill.等级, "data": original * ratio * skill.被动倍率, "cd": skill.等效CD(武器类型=weapon, 输出类型=temp_info.类型, char=temp_info), "mode": 形态, "cost": skill.无色消耗, "tp": skill.TP等级, } ) if skill.是否有护石 == 1: temp = temp_char.get_skill_by_name(skill.名称) cp = 0 for i in ["直伤", "中毒", "灼伤", "感电", "出血"]: cp += temp.等效百分比( char=temp_char, 武器类型=weapon, 形态=形态, 伤害类型=i ) skill_info["skills_cp"].append( { "name": skill.名称, "need_level": skill.所在等级, "lv": skill.等级, "data": cp * ratio * temp.被动倍率, "cd": temp.等效CD(武器类型=weapon, 输出类型=temp_info.类型, char=temp_info), "original_data": original * ratio * skill.被动倍率, "original_cd": skill.等效CD( 武器类型=weapon, 输出类型=temp_info.类型, char=temp_info ), "mode": 形态, "cost": temp.无色消耗, "tp": skill.TP等级, } ) pass pass def get_passive_skill_detail(self, skill, temp_info): if temp_info.类型 == "物理百分比": 倍率 = skill.物理攻击力倍率(temp_info.武器类型) if 倍率 != 1: temp_info.skills_passive[skill.名称]["info"].append( { "type": "物理攻击力", "info": [round((倍率 - 1) * 100), "所有", ""], } ) 倍率 = skill.物理攻击力倍率进图(temp_info.武器类型) if 倍率 != 1: temp_info.skills_passive[skill.名称]["info"].append( { "type": "物理攻击力[进图]", "info": [round((倍率 - 1) * 100), "所有", ""], } ) elif temp_info.类型 == "魔法百分比": 倍率 = skill.魔法攻击力倍率(temp_info.武器类型) if 倍率 != 1: temp_info.skills_passive[skill.名称]["info"].append( { "type": "魔法攻击力", "info": [round((倍率 - 1) * 100), "所有", ""], } ) 倍率 = skill.魔法攻击力倍率进图(temp_info.武器类型) if 倍率 != 1: temp_info.skills_passive[skill.名称]["info"].append( { "type": "魔法攻击力[进图]", "info": [round((倍率 - 1) * 100), "所有", ""], } ) elif temp_info.类型 == "物理固伤" or temp_info.类型 == "魔法固伤": 倍率 = skill.独立攻击力倍率(temp_info.武器类型) if skill.名称 not in temp_info.skills_passive: return if 倍率 != 1: temp_info.skills_passive[skill.名称]["info"].append( { "type": "独立攻击力", "info": [round((倍率 - 1) * 100), "所有", ""], } ) 倍率 = skill.独立攻击力倍率进图(temp_info.武器类型) if skill.名称 not in temp_info.skills_passive: return if 倍率 != 1: temp_info.skills_passive[skill.名称]["info"].append( { "type": "独立攻击力[进图]", "info": [round((倍率 - 1) * 100), "所有", ""], } ) def 设置觉醒技能(self): self.觉醒技能 = [] for i in self.技能栏: if i.是否有伤害 == 1 and i.所在等级 in [50, 85, 100]: self.觉醒技能.append(i.名称) def getskillinfos(self): # 技能等级、技能TP for skill in self.技能栏: if skill.是否有伤害: skill.TP等级 = skill.TP上限 skill.等级 = skill.基础等级 # 宠物 self.加算冷却缩减(0.05) self.技能等级加成("所有", 1, 95, 1) # 光环 self.技能等级加成("所有", 1, 95, 1) # 至尊称号 self.技能等级加成("被动", 95, 95, 1) self.职业特殊设置() # 白金、时装、BUFF self.set_skills() for skill in self.技能栏: self.skills_passive[skill.名称] = { "info": [], "lv": skill.等级, "need_lv": skill.所在等级, } self.加算冷却计算() ratio = self.buff infos = [] for weapon in self.武器选项: temp_info = deepcopy(self) temp_char = deepcopy(self) temp_char.护石栏 = [] for skill in temp_char.技能栏: if skill.是否有伤害 and skill.是否有护石 == 1: temp_char.护石栏.append(skill.名称) skill.装备护石(char=self) temp_info.武器类型 = weapon temp_info.职业特殊计算() temp_info.被动倍率计算() if self.类型 == "物理百分比": ratio *= temp_info.站街物理攻击力倍率() * temp_info.进图物理攻击力倍率() elif self.类型 == "魔法百分比": ratio *= temp_info.站街魔法攻击力倍率() * temp_info.进图魔法攻击力倍率() elif self.类型 == "物理固伤": ratio *= temp_info.站街独立攻击力倍率() * temp_info.进图独立攻击力倍率() elif self.类型 == "魔法固伤": ratio *= temp_info.站街独立攻击力倍率() * temp_info.进图独立攻击力倍率() temp_info.CD倍率计算() temp_info.伤害指数计算() temp_char.武器类型 = weapon temp_char.职业特殊计算() temp_char.被动倍率计算() temp_char.CD倍率计算() temp_char.伤害指数计算() skill_info = { "weapon": weapon, "skills_active": [], "skills_passive": [], "skills_cp": [], "type": temp_info.类型, "buff": temp_info.buff, } for skill in temp_info.技能栏: self.get_acitve_skill_detail( skill, temp_info, temp_char, weapon, ratio, skill_info ) self.get_passive_skill_detail(skill, temp_info) for i in temp_info.skills_passive: skill = temp_info.skills_passive[i] if len(skill["info"]) > 0: for item in skill["info"]: skill_info["skills_passive"].append( { "name": i, "need_level": skill["need_lv"], "lv": temp_info.get_skill_by_name(i).等级, "data": item["info"][0], "type": item["type"], "remark": "{}{}".format( "、".join(item["info"][1].split(",")), "({}除外)".format( "、".join(item["info"][2].split(",")) ) if item["info"][2] != "无" and item["info"][2] != "" and item["info"][2] != 0 else "", ), } ) infos.append(skill_info) return infos def 基础属性加成( self, 物理攻击力=0.00, 魔法攻击力=0.00, 独立攻击力=0.00, 三攻=0, 力量=0.00, 智力=0, 力智=0, 体力=0, 精神=0, 体精=0, 四维=0, 物理暴击率=0.00, 魔法暴击率=0.00, 暴击率=0.00, 攻击速度=0.00, 施放速度=0.00, 移动速度=0.00, 三速=0.00, 火属性抗性=0, 光属性抗性=0, 冰属性抗性=0, 暗属性抗性=0, 所有属性抗性=0, 所有异常抗性=0, 所有职业异常抗性=0, 进图力量=0.00, 进图智力=0.00, **kwargs, ): self.__物理攻击力 += 物理攻击力 + 三攻 self.__魔法攻击力 += 魔法攻击力 + 三攻 self.__独立攻击力 += 独立攻击力 + 三攻 self.__力量 += 力量 + 力智 + 四维 self.__智力 += 智力 + 力智 + 四维 self.__体力 += 体力 + 体精 + 四维 self.__精神 += 精神 + 体精 + 四维 self.__物理暴击率 += float(物理暴击率) + float(暴击率) self.__魔法暴击率 += float(魔法暴击率) + float(暴击率) self.__攻击速度 += float(攻击速度) + float(三速) self.__施放速度 += float(施放速度) + float(三速) self.__移动速度 += float(移动速度) + float(三速) self.__火属性抗性 += 火属性抗性 + 所有属性抗性 self.__光属性抗性 += 光属性抗性 + 所有属性抗性 self.__冰属性抗性 += 冰属性抗性 + 所有属性抗性 self.__暗属性抗性 += 暗属性抗性 + 所有属性抗性 self.进图力量 += 进图力量 self.进图智力 += 进图智力 for 类型 in [ "中毒", "灼伤", "感电", "出血", "冰冻", "减速", "眩晕", "诅咒", "失明", "石化", "睡眠", "混乱", "束缚", ]: self.__异常抗性[类型] = self.__异常抗性.get(类型, 0.0) + 所有异常抗性 self.__异常抗性_职业基础[类型] = ( self.__异常抗性_职业基础.get(类型, 0.0) + 所有职业异常抗性 ) super().基础属性加成( 物理攻击力, 魔法攻击力, 独立攻击力, 三攻, 力量, 智力, 力智, 体力, 精神, 体精, 四维, 物理暴击率, 魔法暴击率, 暴击率, 攻击速度, 施放速度, 移动速度, 三速, 火属性抗性, 光属性抗性, 冰属性抗性, 暗属性抗性, 所有属性抗性, 所有异常抗性, 所有职业异常抗性, 进图力量, 进图智力, ) def set_skill_info( self, info, rune_except=[], clothes_pants=[], rune_start_lv=20 ) -> None: skillInfo = [] # 技能 rune = [] # 符文 talisman = [] # 护石 platinum = [] # 白金 clothes_coat = [] # 时装 for skill in self.技能栏: skill.等级 = skill.基础等级 skillInfo.append( { "name": skill.名称, "type": skill.是否有伤害, "need_level": skill.所在等级, "level_master": skill.等级精通, "level_max": skill.等级上限, "cooldown": 0 if not skill.是否有伤害 else ( skill.CD[skill.等级] if isinstance(skill.CD, list) else skill.CD ), "current_level": skill.基础等级, "data": 0 if not skill.是否有伤害 else skill.等效百分比(char=self), "tp_max": skill.TP上限 if skill.是否有伤害 else None, "tp_level": skill.TP等级 if skill.是否有伤害 else None, "mode": [] if not skill.是否有伤害 else skill.形态, } ) # 护石 if skill.是否有伤害 == 1 and skill.是否有护石 == 1: talisman.append(skill.名称) # 符文 if ( skill.所在等级 >= rune_start_lv and skill.所在等级 <= 80 and skill.所在等级 != 50 and ( skill.是否有伤害 == 1 or (skill.是否主动 == 1 and self.类型 == "辅助") ) and skill.名称 not in rune_except ): rune.append(skill.名称) # 白金 if ( skill.所在等级 >= 15 and skill.所在等级 <= 70 and skill.所在等级 not in [48, 50] ): platinum.append(skill.名称) # 时装 if skill.所在等级 <= 95: clothes_coat.append(skill.名称) if self.类型 == "辅助": talisman += self.护石技能 info["skills"] = skillInfo info["rune"] = rune info["talisman"] = talisman info["platinum"] = platinum info["clothes_coat"] = clothes_coat info["clothes_pants"] = clothes_pants def set_individuation(self, info) -> None: pass # endregion # region 词条属性 def set_eq_params(self, key, value): self.eq_params[key] = value def add_eq_params(self, key, value, default=0): self.eq_params[key] = self.eq_params.get(key, default) + value def multiply_eq_params(self, key, value, default=1): self.eq_params[key] = self.eq_params.get(key, default) * value def get_eq_params(self, key, default=0): return self.eq_params.get(key, default) def 基础精通加成(self, x: float) -> None: self.__基础精通倍率 *= 1 + x def 百分比防御减少(self, x: float) -> None: self.__百分比减防 += x def 固定防御减少(self, x: int) -> None: self.__固定减防 += x def 伤害类型转化(self, 类型1: str, 类型2: str, x: float) -> None: # 直伤 中毒 灼伤 感电 出血 # if self.伤害比例.get(类型1, 0.0) - x <= 0: # pass self.伤害比例[类型1] = max(self.伤害比例.get(类型1, 0.0) - x, 0) self.伤害比例[类型2] = self.伤害比例.get(类型2, 0.0) + x def 异常增伤(self, 类型: str, x: float) -> None: # 中毒 灼伤 感电 出血 self.伤害系数[类型] = self.伤害系数.get(类型, 1.0) + x def 异常抗性加成(self, 类型: str, x: float, mode: int = 1) -> None: # 中毒 灼伤 感电 出血 冰冻 减速 眩晕 诅咒 失明 石化 睡眠 混乱 束缚 if mode == 1: self.__异常抗性[类型] = self.__异常抗性.get(类型, 0.0) + x else: self.__异常抗性_职业基础[类型] = self.__异常抗性_职业基础.get(类型, 0.0) + x def 异常抗性获取(self, 类型: str, mode: int = 1) -> float: # mode = 1 显示抗性 mode = 0 装备加成抗性 return round( self.__异常抗性.get(类型, 0.0) + (self.__异常抗性_职业基础.get(类型, 0.0) if mode == 1 else 0.0), 4, ) def 属性攻击(self, 类型: str) -> None: pass def 所有异常抗性加成(self, x: float, mode: int = 1) -> None: for 类型 in [ "中毒", "灼伤", "感电", "出血", "冰冻", "减速", "眩晕", "诅咒", "失明", "石化", "睡眠", "混乱", "束缚", ]: self.异常抗性加成(类型, x, mode) def 指令效果加成(self, 类型: str, x: float) -> None: # 所有 消耗无色 不消耗无色 (觉醒技能默认除外) self.__指令效果[类型] = self.__指令效果.get(类型, 1.0) * (1 + x) def 指令技攻加成(self, x: float, min=1, max=100, exc=[], excName=[]) -> None: count = 0 for i in self.技能栏: if ( i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.手搓 and i.名称 not in excName ): count += 1 if i.是否有伤害 == 1: i.倍率 *= 1 + x * self.技能伤害增加增幅 if i.名称 == "鬼连斩": self.get_skill_by_name("鬼连斩：极").额外加成 /= ( 1 + x * self.技能伤害增加增幅 ) return count def MP消耗量加成(self, x: float) -> None: self.__MP消耗量 += x def 攻击强化加成(self, x: float) -> None: self.__攻击强化 += x def 百分比攻击强化加成(self, x: float) -> None: self.__百分比攻击强化 += x super().百分比攻击强化加成(x) def buff量加成(self, x: float) -> None: self.__buff量 += x def 辅助属性加成( self, buff固定力智=0, buff百分比力智=0.0, buff固定三攻=0, buff百分比三攻=0.0, 觉醒固定力智=0, 觉醒百分比力智=0.0, buff量=0, 百分比buff量=0.0, 觉醒百分比力智Total=0.0, ): self.__buff固定力智 += buff固定力智 self.__buff百分比力智 *= 1.0 + buff百分比力智 self.__buff固定三攻 += buff固定三攻 self.__buff百分比三攻 *= 1.0 + buff百分比三攻 self.__觉醒固定力智 += 觉醒固定力智 self.__觉醒百分比力智 *= 1.0 + 觉醒百分比力智 self.__觉醒百分比力智Total *= 1.0 + 觉醒百分比力智Total self.__buff量 += buff量 self.__百分比buff量 += 百分比buff量 super().辅助属性加成( buff固定力智, buff百分比力智, buff固定三攻, buff百分比三攻, 觉醒固定力智, 觉醒百分比力智, buff量, 百分比buff量, ) def 附加伤害加成(self, x: float, 辟邪玉加成=1) -> None: self.__附加伤害 += self.附加伤害增加增幅 * x if 辟邪玉加成 == 1 else x def 持续伤害加成(self, x: float) -> None: self.__持续伤害 += x def 属性附加加成(self, x: float) -> None: self.__属性附加 += self.属性附加伤害增加增幅 * x def 技能攻击力加成( self, x: float, 辟邪玉加成=1, 适用累加=1, part="", show=True ) -> None: if x != 0: self.技攻列表[part] = self.技攻列表.get(part, []) + [x] last = 0 if 辟邪玉加成 == 1: if 适用累加 == 0: last = self.技能伤害增加增幅 * x # self.技能攻击力 *= 1 + self.技能伤害增加增幅 * x else: if self.技能攻击力累加 > 2: # 累计已经大于2不再加成 # self.技能攻击力 *= 1 + x last = x elif ( self.技能攻击力累加 + x > 2 ): # 此次累计导致大于2，一部分加成，一部分不加成 overflow = self.技能攻击力累加 + x - 2 # 溢出部分 # self.技能攻击力 *= 1 + self.技能伤害增加增幅 * (x - overflow) + overflow last = self.技能伤害增加增幅 * (x - overflow) + overflow else: # 累计后仍小于等于2 # self.技能攻击力 *= 1 + self.技能伤害增加增幅 * x last = self.技能伤害增加增幅 * x self.技能攻击力累加 += x # 累计计算 else: last = x # self.技能攻击力 *= 1 + x self.技能攻击力 *= 1 + last self.__面板技能攻击力 *= 1 + (last if show else 0) # print(self.技攻列表) super().技能攻击力加成(x=x) def 暴击伤害加成(self, x: float, 辟邪玉加成=1) -> None: self.__暴击伤害 += self.暴击伤害增加增幅 * x if 辟邪玉加成 == 1 else x def 伤害增加加成(self, x: float, 辟邪玉加成=1) -> None: self.__伤害增加 += self.伤害增加增幅 * x if 辟邪玉加成 == 1 else x def 最终伤害加成(self, x: float, 辟邪玉加成=1) -> None: self.__最终伤害 += self.最终伤害增加增幅 * x if 辟邪玉加成 == 1 else x def 百分比力智加成(self, x: float, 辟邪玉加成=1) -> None: self.__百分比力智 += self.力量智力增加增幅 * x if 辟邪玉加成 == 1 else x def 百分比三攻加成(self, x: float, 辟邪玉加成=1) -> None: self.__百分比三攻 += self.物理魔法攻击力增加增幅 * x if 辟邪玉加成 == 1 else x def 火属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None: if mode == 0: self.__火属性强化 += self.所有属性强化增幅 * x if 辟邪玉加成 == 1 else x else: self.__火属性强化 += int(self.所有属性强化增幅 * x) def 冰属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None: if mode == 0: self.__冰属性强化 += self.所有属性强化增幅 * x if 辟邪玉加成 == 1 else x else: self.__冰属性强化 += int(self.所有属性强化增幅 * x) def 光属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None: if mode == 0: self.__光属性强化 += self.所有属性强化增幅 * x if 辟邪玉加成 == 1 else x else: self.__光属性强化 += int(self.所有属性强化增幅 * x) def 暗属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None: if mode == 0: self.__暗属性强化 += self.所有属性强化增幅 * x if 辟邪玉加成 == 1 else x else: self.__暗属性强化 += int(self.所有属性强化增幅 * x) def 所有属性强化加成( self, 所有属性强化: float = 0, 火属性强化: float = 0.00, 冰属性强化: float = 0.00, 光属性强化: float = 0.00, 暗属性强化: float = 0.00, 辟邪玉加成=1, mode=0, ) -> None: super().所有属性强化加成( 所有属性强化, 火属性强化, 冰属性强化, 光属性强化, 暗属性强化 ) 火属性强化 += 所有属性强化 冰属性强化 += 所有属性强化 光属性强化 += 所有属性强化 暗属性强化 += 所有属性强化 # if 火属性强化 > 0: self.火属性强化加成(火属性强化, 辟邪玉加成, mode) # if 冰属性强化 > 0: self.冰属性强化加成(冰属性强化, 辟邪玉加成, mode) # if 光属性强化 > 0: self.光属性强化加成(光属性强化, 辟邪玉加成, mode) # if 暗属性强化 > 0: self.暗属性强化加成(暗属性强化, 辟邪玉加成, mode) # if mode == 0: # temp = self.所有属性强化增幅 * 所有属性强化 if 辟邪玉加成 == 1 else 所有属性强化 # else: # temp = int(self.所有属性强化增幅 * 所有属性强化) # self.__所有属性强化(temp) # super().属性强化加成(所有属性强化=所有属性强化) def 火属性抗性加成(self, x: int) -> None: self.__火属性抗性 += x def 冰属性抗性加成(self, x: int) -> None: self.__冰属性抗性 += x def 光属性抗性加成(self, x: int) -> None: self.__光属性抗性 += x def 暗属性抗性加成(self, x: int) -> None: self.__暗属性抗性 += x def 所有属性抗性加成(self, x: int) -> None: self.火属性抗性加成(x) self.冰属性抗性加成(x) self.光属性抗性加成(x) self.暗属性抗性加成(x) def 攻击速度增加(self, x: float, part: str = "") -> None: if part != "武器" and part != "特性": self.__攻击速度 += x else: self.__攻击速度_其他 += x def 攻击速度(self) -> float: return self.__攻击速度 def 移动速度增加(self, x: float) -> None: self.__移动速度 += x def 施放速度增加(self, x: float) -> None: self.__施放速度 += x def 所有速度增加(self, x: float, part: str = "") -> None: if part != "武器" and part != "特性": self.__攻击速度 += x else: self.__攻击速度_其他 += x self.__移动速度 += x self.__施放速度 += x def 命中率增加(self, x: float) -> None: self.__命中率 += x def 回避率增加(self, x: float) -> None: self.__回避率 += x def 物理暴击率增加(self, x: float) -> None: self.__物理暴击率 += x def 魔法暴击率增加(self, x: float) -> None: self.__魔法暴击率 += x def 暴击率增加(self, x: float) -> None: self.物理暴击率增加(x) self.魔法暴击率增加(x) def buff技能等级加成(self, LV: int, lv: int) -> None: # LV级 buff技能等级 + lv pass def 特殊主动等级加成(self, Lv: int, lv: int) -> None: for i in self.技能栏: if ( i.所在等级 == Lv and i.是否主动 == 1 and i.名称 not in ["念兽：龙虎啸", "风雷啸", "圣灵符文", "神圣之光"] ): i.等级加成(lv, char=self) def 技能获取(self, min: int, max: int, exc=[]) -> None: temp = [] for i in self.技能栏: if ( i.所在等级 >= min and i.所在等级 <= max and i.是否主动 == 1 and i.名称 not in exc ): temp.append(i.名称) return temp def 技能等级加成( self, 加成类型: str, min: int, max: int, lv: int, exc=[], excName=[] ) -> None: for i in self.技能栏: if ( i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.名称 not in excName ): if 加成类型 == "所有": i.等级加成(lv, char=self) else: if (i.是否主动 == 1) == (加成类型 == "主动"): i.等级加成(lv, char=self) super().技能等级加成(加成类型, min, max, lv, exc) def 技能冷却缩减(self, min: int, max: int, x: float, exc=[], excName=[]) -> None: if min == 1 and max == 100: self.冷却缩减 *= 1 - x for i in self.技能栏: if ( i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.名称 not in excName ): if i.是否有伤害 == 1: i.CDR *= 1 - x def 无色技能加成(self, cost=0, x=0, min=1, max=100): # 不消耗无色的技能加成 if cost == 0: for skill in self.技能队列: if not (min == 1 and max == 100): lv = self.get_skill_by_name(skill["名称"]).所在等级 if lv < min or lv > max: continue if ( skill["名称"] == "神罚之锤" and self.实际名称 == "crusader_male_carry" ): skill["倍率"] *= ( 1 + x * self.get_skill_by_name("神罚之锤").非无色占比() ) elif skill["无色消耗"] == 0 and skill["名称"] != "鬼连斩：极": skill["倍率"] *= 1 + x pass if cost > 0: for skill in self.技能队列: if not (min == 1 and max == 100): lv = self.get_skill_by_name(skill["名称"]).所在等级 if lv < min or lv > max: continue if ( skill["名称"] == "神罚之锤" and self.实际名称 == "crusader_male_carry" ): skill["倍率"] *= ( 1 + x * self.get_skill_by_name("神罚之锤").无色占比() ) elif skill["无色消耗"] >= cost: skill["倍率"] *= 1 + x pass def 加算冷却缩减(self, x: float) -> None: self.__加算冷却缩减 += x def 技能恢复加成(self, min: int, max: int, x: float, exc=[], excName=[]) -> None: if min == 1 and max == 100: self.冷却恢复 += x for i in self.技能栏: if ( i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.名称 not in excName ): if i.是否有伤害 == 1: i.恢复 += x def 技能倍率加成( self, min: int, max: int, x: float, exc=[], type="all", excName=[], changeSkill=False, ) -> None: for i in self.技能栏: if ( i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.名称 not in excName ): if i.是否有伤害 == 1: if type == "all" or (type == "active" and i.是否主动 == 1): if changeSkill: i.倍率 *= 1 + x * self.技能伤害增加增幅 else: i.技攻 *= 1 + x * self.技能伤害增加增幅 def 单技能加成(self, 名称: str, 倍率=1.0, CD=1.0, lv=0) -> None: i = self.get_skill_by_name(名称) i.等级加成(lv, char=self) if i.是否有伤害 == 1: i.倍率 *= 倍率 i.CDR *= CD def __所有属性强化(self, x: float) -> None: self.__火属性强化 += x self.__冰属性强化 += x self.__光属性强化 += x self.__暗属性强化 += x def 斗神宠物加成(self, x: float) -> None: self.斗神宠物 += x # endregion # region 面板相关函数 # 基础力量智力(站街力量智力) def 站街力量(self) -> int: return int(self.__力量) def 站街智力(self) -> int: return int(self.__智力) def MP消耗倍率(self) -> float: return self.__MP消耗量 def 火属性强化(self) -> float: if self.check_fun_by_id(20045): return max( [ self.__火属性强化, self.__冰属性强化, self.__光属性强化, self.__暗属性强化, ] ) return self.__火属性强化 def 冰属性强化(self) -> float: if self.check_fun_by_id(20045): return max( [ self.__火属性强化, self.__冰属性强化, self.__光属性强化, self.__暗属性强化, ] ) return self.__冰属性强化 def 光属性强化(self) -> float: if self.check_fun_by_id(20045): return max( [ self.__火属性强化, self.__冰属性强化, self.__光属性强化, self.__暗属性强化, ] ) return self.__光属性强化 def 暗属性强化(self) -> float: if self.check_fun_by_id(20045): return max( [ self.__火属性强化, self.__冰属性强化, self.__光属性强化, self.__暗属性强化, ] ) return self.__暗属性强化 def 火属性抗性(self) -> float: return int(self.__火属性抗性 * self.属强抗性倍率) def 冰属性抗性(self) -> float: return int(self.__冰属性抗性 * self.属强抗性倍率) def 光属性抗性(self) -> float: return int(self.__光属性抗性 * self.属强抗性倍率) def 暗属性抗性(self) -> float: return int(self.__暗属性抗性 * self.属强抗性倍率) def 被动力智系数(self) -> float: return 0 # 新词条计算的力量智力 def 基础面板力量(self) -> float: return ( ( self.__力量 + int( (self.__力量 - self.__基础力量) * self.系统奶系数 + self.系统奶基数 ) ) + self.进图力量 ) * (1 + self.被动力智系数()) def 基础面板智力(self) -> float: return ( ( self.__智力 + int( (self.__智力 - self.__基础智力) * self.系统奶系数 + self.系统奶基数 ) ) + self.进图智力 ) * (1 + self.被动力智系数()) # 旧词条计算的力量智力(图内力量智力) def 面板力量(self) -> float: return (self.基础面板力量()) * (1 + self.__百分比力智) def 面板智力(self) -> float: return (self.基础面板智力()) * (1 + self.__百分比力智) # 站街生效的技能三攻倍率 def 站街物理攻击力倍率(self) -> float: 站街物理攻击倍率 = 1.0 for i in self.技能栏: if hasattr(i, "物理攻击力倍率"): 倍率 = i.物理攻击力倍率(self.武器类型) if 倍率 != 1 and 倍率 is not None: 站街物理攻击倍率 *= 倍率 return 站街物理攻击倍率 def 站街魔法攻击力倍率(self) -> float: 站街魔法攻击倍率 = 1.0 for i in self.技能栏: if hasattr(i, "魔法攻击力倍率"): 倍率 = i.魔法攻击力倍率(self.武器类型) if 倍率 != 1 and 倍率 is not None: 站街魔法攻击倍率 *= 倍率 return 站街魔法攻击倍率 def 站街独立攻击力倍率(self) -> float: 站街独立攻击倍率 = 1.0 for i in self.技能栏: if hasattr(i, "独立攻击力倍率"): 倍率 = i.独立攻击力倍率(self.武器类型) if 倍率 != 1 and 倍率 is not None: 站街独立攻击倍率 *= 倍率 return 站街独立攻击倍率 def 进图物理攻击力倍率(self) -> float: 进图物理攻击倍率 = 1.0 for i in self.技能栏: if hasattr(i, "物理攻击力倍率进图"): 倍率 = i.物理攻击力倍率进图(self.武器类型) if 倍率 != 1 and 倍率 is not None: 进图物理攻击倍率 *= 倍率 return 进图物理攻击倍率 def 进图魔法攻击力倍率(self) -> float: 进图魔法攻击倍率 = 1.0 for i in self.技能栏: if hasattr(i, "魔法攻击力倍率进图"): 倍率 = i.魔法攻击力倍率进图(self.武器类型) if 倍率 != 1 and 倍率 is not None: 进图魔法攻击倍率 *= 倍率 return 进图魔法攻击倍率 def 进图独立攻击力倍率(self) -> float: 进图独立攻击倍率 = 1.0 for i in self.技能栏: if hasattr(i, "独立攻击力倍率进图"): 倍率 = i.独立攻击力倍率进图(self.武器类型) if 倍率 != 1 and 倍率 is not None: 进图独立攻击倍率 *= 倍率 return 进图独立攻击倍率 # 站街三攻 def 站街物理攻击力(self) -> float: return self.__物理攻击力 * self.站街物理攻击力倍率() def 站街魔法攻击力(self) -> float: return self.__魔法攻击力 * self.站街魔法攻击力倍率() def 站街独立攻击力(self) -> float: return self.__独立攻击力 * self.站街独立攻击力倍率() # 新词条计算的三攻(旧词条需要额外乘百分比三攻) def 基础面板物理攻击力(self) -> float: 面板物理攻击 = self.__物理攻击力 + int(self.__进图三攻) for i in self.技能栏: 面板物理攻击 *= i.物理攻击力倍率进图(self.武器类型) return 面板物理攻击 * self.站街物理攻击力倍率() def 基础面板魔法攻击力(self) -> float: 面板魔法攻击 = self.__魔法攻击力 + int(self.__进图三攻) for i in self.技能栏: 面板魔法攻击 *= i.魔法攻击力倍率进图(self.武器类型) return 面板魔法攻击 * self.站街魔法攻击力倍率() def 基础面板独立攻击力(self) -> float: 面板独立攻击 = self.__独立攻击力 + int(self.__进图三攻) for i in self.技能栏: 面板独立攻击 *= i.独立攻击力倍率进图(self.武器类型) return 面板独立攻击 * self.站街独立攻击力倍率() # 图内显示的三攻(不参与伤害计算) def 面板物理攻击力(self) -> float: 面板物理攻击 = ( self.基础面板物理攻击力() * (1 + self.__百分比三攻) * (self.斗神宠物加成) ) return 面板物理攻击 def 面板魔法攻击力(self) -> float: 面板魔法攻击 = ( self.基础面板魔法攻击力() * (1 + self.__百分比三攻) * (self.斗神宠物加成) ) return 面板魔法攻击 def 面板独立攻击力(self) -> float: 面板独立攻击 = self.基础面板独立攻击力() * (1 + self.__百分比三攻) return 面板独立攻击 # endregion # region 其它函数 # def get_skill_by_name(self, name) -> 技能 | 主动技能 | 被动技能: def 部位是否穿戴(self, part): if self.部位装备.get(part, None) is None and part not in [ "光环", "武器装扮", "皮肤", "宠物装备-红", "宠物装备-绿", "宠物装备-蓝", "快捷装备", ]: return False else: return True def get_skill_by_name(self, name) -> Union[技能, 主动技能, 被动技能]: return self.技能栏[self.技能序号.get(name, 0)] def 已穿戴神话(self): for i in self.装备栏: temp = get_equ(self.equVersion).get_equ_by_id(i) if temp.品质 == "神话": return True return False def 传说词条等级之和(self): total = 0 for i in self.装备栏: temp = get_equ(self.equVersion).get_equ_by_id(i) if ( temp.等级 == 105 and temp.部位 not in ["称号", "宠物"] and temp.品质 == "传说" ): total += sum(self.词条等级.get(temp.部位, [0])) return total def 已传说装备数目(self): count = 0 for i in self.装备栏: temp = get_equ(self.equVersion).get_equ_by_id(i) if ( temp.等级 == 105 and temp.部位 not in ["称号", "宠物"] and temp.品质 == "传说" ): count += 1 return count def 穿戴低于105(self): for i in self.装备栏: temp = get_equ(self.equVersion).get_equ_by_id(i) if temp.等级 < 105 and temp.部位 not in ["称号", "宠物"]: return True return False def 获取强化等级(self, part=[]): num = 0 temp = part if len(temp) == 0: temp += 部位列表 for i in temp: num += self.打造详情.get(i, {}).get("cursed_number", 0) return num def 获取改造等级(self, part=[]): num = 0 temp = part if len(temp) == 0: temp += 部位列表 for i in temp: num += self.打造详情.get(i, {}).get("wisdom_number", 0) return num # endregion # 打造设置 def __打造设置(self, setinfo): self.打造详情 = setinfo for i in 部位列表 + ( "称号", "宠物", "光环", "武器装扮", "皮肤", "宠物装备-红", "宠物装备-绿", "宠物装备-蓝", "快捷装备", ): from core.equipment.enchanting import get_encfunc_by_id id = setinfo.get(i, {}).get("enchanting", 0) self.部位附魔[i] = get_encfunc_by_id(id) def 技能队列设置(self, setinfo): self.技能队列 = [] for item in setinfo: self.技能队列.append( { "名称": item["name"], "无色消耗": self.get_skill_by_name(item["name"]).无色消耗, "倍率": 1.0, "等级变化": 0, "CDR": 1.0, "恢复": 0, "形态": item.get("mode", ""), } ) def __药剂设置(self, setinfo): self.药剂 = setinfo def __怪物信息设置(self, id): from core.basic.monster import get_monster_data data = get_monster_data(str(id)) self.防御输入 = data["防御"] self.火抗输入 = data["火抗"] self.冰抗输入 = data["冰抗"] self.光抗输入 = data["光抗"] self.暗抗输入 = data["暗抗"] pass def __场景设置(self, id): from core.basic.monster import get_scene_data data = get_scene_data(str(id)) self.系统奶系数 = data["系统奶系数"] self.系统奶基数 = data["系统奶基数"] self.防御系数 = data["防御系数"] pass # 设置技能相关参数 def __skill_set(self, setinfo): for i in setinfo: k = self.get_skill_by_name(i["name"]) k.等级 = i["level"] k.TP等级 = i["tp"] k.手搓 = i["direct"] k.手搓指令数 = i["directNumber"] k.count = i["count"] # 设置装备选项参数 def __equ_chose_set(self, setinfo): get_equ(self.equVersion).set_func_chose(setinfo) # for i in setinfo: # equ.set_func_chose({i['id']: i['select']}) def hotkey_set(self, setinfo): self.hotkey = setinfo def __set_char(self, info): self.类型 = info["carry_type"] if self.类型 != "辅助" else self.类型 try: self.buff = info["buff_ratio"] / 100 + 1 except Exception: raise ResponseException("请在技能页设置buff倍率") self.护石栏 = info["talisman_set"] self.符文 = info["rune_set"] pass # 设置穿戴的装备 def __穿戴装备(self, idlist): self.装备栏 = [] self.部位装备 = {} idlist = sorted(idlist) for i in idlist: 装备 = get_equ(self.equVersion).get_equ_by_id(i) self.部位装备.update({装备.部位: i}) for k in self.部位装备.keys(): self.装备栏.append(self.部位装备[k]) def __穿戴装扮(self, info): self.装扮栏 = {} self.装扮选项 = {} for i in info: self.装扮栏[i] = info[i].get("id", 0) self.装扮选项[i] = info[i].get("option", 0) # print(len(self.装扮栏)) # region 伤害计算相关函数 def __计算前预处理(self): # 防止中途变更影响其他计算 self.__equ_chose_set(self.trigger_set) self.设置觉醒技能() self.职业特殊设置() self.__辟邪玉计算() self.护石计算() self.符文计算() self.装备属性计算() self.skills_passive = {} for i in self.技能栏: self.skills_passive[i.名称] = {"info": [], "lv": i.等级} self.职业特殊计算() if self.类型 != "辅助": self.CD倍率计算() self.加算冷却计算() self.被动倍率计算() self.伤害指数计算() def 适用数值计算(self): 进图智力 = 0 进图体力 = 0 进图精神 = 0 for skill in self.技能栏: if skill.是否启用: 结算 = skill.结算统计(self) if skill.站街生效: self.__智力 += 结算[2] self.__体力 += 结算[3] self.__精神 += 结算[4] else: 进图智力 += 结算[2] 进图体力 += 结算[3] 进图精神 += 结算[4] 进图 = 0 BUFF补正 = 0 if self.适用属性 == "体力": 进图 = self.__体力 + 进图体力 BUFF补正 = self.__BUFF补正体力 elif self.适用属性 == "精神": 进图 = self.__精神 + 进图精神 BUFF补正 = self.__BUFF补正精神 else: 进图 = self.__智力 + 进图智力 BUFF补正 = self.__BUFF补正智力 awake = self.get_skill_by_name("一次觉醒") buff = self.get_skill_by_name("BUFF") awake.适用数值 = 进图 awake.一觉力智 = self.__觉醒固定力智 awake.一觉力智per = self.__觉醒百分比力智 awake.一觉力智perTotal = self.__觉醒百分比力智Total buff.适用数值 = 进图 + BUFF补正 buff.BUFF力智per = self.__buff百分比力智 buff.BUFF力智 = self.__buff固定力智 buff.BUFF三攻per = self.__buff百分比三攻 buff.BUFF三攻 = self.__buff固定三攻 self.适用数值 = 进图 # print('copaosee:', self.适用数值, [ # self.__智力, self.__体力, self.__精神], 进图, BUFF补正) def 站街系数(self): if self.适用属性 == "体力": return self.__体力 elif self.适用属性 == "精神": return self.__精神 return self.__智力 def 提升率计算(self, 总数据): 力智合计 = 0 三攻合计 = 0 for i in 总数据: 力智合计 += i[0] 三攻合计 += i[1] x1 = ( ( self.辅助对象力智 + (self.辅助对象力智 - 950) * self.系统奶系数 + self.系统奶基数 ) / 250 + 1 ) * self.辅助对象三攻 x2 = ( ( self.辅助对象力智 + (self.辅助对象力智 - 950) * self.系统奶系数 + self.系统奶基数 + 力智合计 ) / 250 + 1 ) * (self.辅助对象三攻 + 三攻合计) return [ x2 / x1 * 100 * self.被动增伤倍率, int(self.站街系数()), 力智合计, 三攻合计, ] def BUFF量(self): return self.__buff量 * (1 + self.__百分比buff量) def 辅助计算(self): self.适用数值计算() data = {} data["无色消耗"] = 0 skills = {} values = [] CDR = [] for i in self.技能栏: rs = i.结算统计(self)[:2] cd = "-" if not i.是否主动 else i.等效CD() cd_p = "-" if not i.是否主动 else round(100 - i.等效CD() / i.CD * 100, 2) k = {} k["name"] = i.名称 k["data"] = rs if hasattr(i, "适用数值"): k["apply_status"] = i.适用数值 if sum(rs) > 0 or cd != "-": values.append(rs) skills[i.名称] = { "name": i.名称, "level": i.等级, "data": rs, "cd": cd, "cd_p": cd_p, } if i.是否主动: CDR.append( (i.名称,cd_p/100,cd) ) pass 结果 = self.提升率计算(values) data["total_data"] = 结果[0] data["buffer_addition"] = 结果 data["skills"] = skills data["CDR"] = CDR return data def 结果计算(self): if self.类型 == "辅助": return self.辅助计算() else: return self.伤害计算() def 职业特殊计算(self): pass def 伤害计算技能特殊处理(self, skill: 技能): pass def 异常系数计算(self, item, skill): cur = item pa = "" if item == "中毒": pa = "zd_rate" if item == "出血": pa = "cx_rate" if item == "感电": pa = "gd_rate" if item == "灼伤": pa = "zs_rate" if ( item == "灼伤" and "灼伤" in get_global_data("state_type", self.equVersion) and ( "冰冻" in get_global_data("get_state_type", self.equVersion) or ( "冰冻" in get_global_data("state_type", self.equVersion) and self.check_equ_by_name("永眠前的准备") ) ) ): pa = "zs_bd_rate" cur = "灼伤破冰" 保有率 = 0 异常基础加成 = 1.0 异常结算加成 = 1.0 装备加成异常结算 = 1.0 if pa == "zs_bd_rate": 保有率 = self.异常保有率计算(pa, cur) 异常基础加成 = 1.0 异常结算加成 = self.异常基础加成["灼伤破冰"] 装备加成异常结算 = self.异常结算加成.get(cur, 1.0) else: 保有率 = self.异常保有率计算(pa, cur) # 叠层处理 异常基础加成 = 1 + (self.异常基础加成.get(cur, 1.0) - 1) * get_global_data( pa, self.equVersion, 1.0 ) 异常结算加成 = 1.0 装备加成异常结算 = self.异常结算加成.get(cur, 1.0) 系数 = self.伤害系数.get(item, 0.0) * ( (1 - 保有率) * 异常基础加成 + 保有率 * 异常基础加成 * 异常结算加成 * 装备加成异常结算 ) return 系数 pass def 伤害计算(self): data = {} total_data = 0 skill_dict = {} # 无色消耗 = 0 CDR = [] for i in self.技能队列: k = self.get_skill_by_name(i["名称"]) if k.是否有伤害 == 1: temp = skill_dict.get(k.名称, {}) self.伤害计算技能特殊处理(k) if k.名称 not in data.keys(): temp["rate"] = k.被动倍率 if temp.get("cd", 0) > 0: temp["cd"] = ( k.等效CD( 武器类型=self.武器类型, 输出类型=self.类型, 额外CDR=i["CDR"], 额外恢复=i["恢复"], 形态=i["形态"], char=self ) + temp["cd"] * temp["count"] ) / (temp["count"] + 1) else: temp["cd"] = k.等效CD( 武器类型=self.武器类型, 输出类型=self.类型, 额外CDR=i["CDR"], 额外恢复=i["恢复"], 形态=i["形态"], char=self ) temp["mp"] = k.MP消耗( 武器类型=self.武器类型, 输出类型=self.类型, 额外倍率=self.__MP消耗量, char=self, ) temp["atk_rate"] = k.等效百分比( 武器类型=self.武器类型, 形态=i["形态"], char=self ) temp["cosume_cube_frag"] = k.无色消耗 temp["level"] = k.等级 temp["cd_o"] = k.CD[k.等级] if isinstance(k.CD, list) else k.CD temp["cd_unsave"] = ( (k.恢复 + i["恢复"]) if temp.get("cd_unsave", 1) == 1 else (temp.get("cd_unsave", 1) + k.恢复 + i["恢复"]) / 2 ) 直伤 = k.等效百分比( 武器类型=self.武器类型, 额外等级=i["等级变化"], 额外倍率=i["倍率"], 伤害类型="直伤", 形态=i["形态"], char=self, ) # 直伤处理：直伤伤害*比例*系数 damage = ( 直伤 * self.伤害指数 * k.被动倍率 * (self.伤害比例.get("直伤", 0.0)) / 100 ) for item in ["中毒", "灼伤", "感电", "出血"]: 系数 = self.异常系数计算(item, k) # 直伤转换的异常处理：直伤伤害*异常比例*异常系数 damage += ( 直伤 * self.伤害指数 * k.被动倍率 * (self.伤害比例.get(item, 0.0) * 系数) / 100 ) # 异常伤害处理：异常伤害*异常系数 damage += ( k.等效百分比( 武器类型=self.武器类型, 额外等级=i["等级变化"], 额外倍率=i["倍率"], 伤害类型=item, 形态=i["形态"], char=self, ) * self.伤害指数 * k.被动倍率 * 系数 / 100 ) total_data += damage temp["name"] = k.名称 temp["damage"] = temp.get("damage", 0) + round(damage,0) temp["count"] = temp.get("count", 0) + 1 skill_dict[k.名称] = temp # if k.名称 not in ['爆裂弹', '杀意波动', '万毒噬心诀', '神罚之锤']: # 无色消耗 += i['无色消耗'] # if k.CD > 1: # CDR.append( # (k.名称, round(1 - temp.get('cd', 0)/temp.get('cd_o', 0), 4))) data["skills_passive"] = {} for i in self.技能栏: if i.关联技能 != ["无"] or i.冷却关联技能 != ["无"]: temp = {} temp["lv"] = i.等级 temp["name"] = i.名称 data["skills_passive"][i.名称] = temp if skill_dict.get(i.名称, None) is not None: if (i.CD[k.等级] if isinstance(i.CD, list) else i.CD) > 1: temp = skill_dict.get(i.名称, {}) if temp.get("cd_o", 0) == 0: CDR.append((i.名称, 0, 0)) else: CDR.append( ( i.名称, round(1 - temp.get("cd", 0) / temp.get("cd_o", 0), 4), temp.get("cd", 0), ) ) pass data["skills"] = skill_dict data["total_data"] = round(total_data,0) # data['无色消耗'] = 无色消耗 data["CDR"] = CDR dps = 0 for temp in data["skills"]: skill = data["skills"][temp] try: dps += ( (skill["damage"] / skill["count"]) / skill["cd"] * skill["damage"] / total_data ) except Exception: pass data["dps"] = dps return data def 装备属性计算(self): self.套装统计() self.装备基础() self.__时装基础() self.__附魔计算() self.__杂项计算() self.__徽章计算() if self.类型 != "辅助": self.药剂计算() self.__装备词条计算() def __时装基础(self): 时装品级列表 = {} for 部位 in self.装扮栏: id = int(self.装扮栏[部位]) 时装 = 装扮集合[id] 时装.效果(角色=self, 选项=self.装扮选项[部位]) 时装品级列表[时装.套装] = 时装品级列表.get(时装.套装, 0) + 1 套装集合: List[装扮套装] = [] for 套装 in 装扮套装集合: 数量 = 时装品级列表.get(套装.名称, 0) if 数量 > 0: if 数量 >= 套装.所需数量: 查找 = len( [ i for i in 套装集合 if hasattr(i, "兼容于") and i.兼容于 == 套装.名称 and i.所需数量 == 套装.所需数量 ] ) if 查找 == 0: 套装集合.append(套装) else: if hasattr(套装, "兼容于") and 套装.兼容于 is not None: 数量 += 时装品级列表.get(套装.兼容于, 0) 时装品级列表[套装.兼容于] = 数量 时装品级列表.pop(套装.名称) for 套装 in 套装集合: 套装.效果(self) pass def __辟邪玉计算(self): if "jade" not in self.打造详情.keys(): return setinfo = self.打造详情["jade"] info = {} for i in ["jade_First", "jade_Second", "jade_Third", "jade_Fourth"]: if i + "_type" in setinfo.keys(): try: id = setinfo[i + "_type"] value = float(setinfo[i + "_value"]) except Exception: id = 0 value = 0 info[str(id)] = info.get(str(id), 0) + value from core.equipment.jade import get_jadefunc_by_id for id in info.keys(): func = get_jadefunc_by_id(int(id)) func(self, value=info.get(str(id), 0)) # 打印相关函数和效果 def 护石计算(self): for item in self.护石栏: try: if item is not None and item != "" and item != "无": self.get_skill_by_name(item).装备护石(char=self) except Exception: pass def 符文计算(self): for item in self.符文: if item is not None and item != "": skill_name: str = item[0:-1] type = item[-1] skill = self.get_skill_by_name(skill_name) if skill is not None and skill.名称 == skill_name: # 紫 if type == "1": skill.倍率 *= 1.04 # 红 if type == "2": skill.倍率 *= 1.06 skill.CDR *= 1.04 # 绿 if type == "3": skill.倍率 *= 0.96 skill.CDR *= 0.93 # 蓝 if type == "4": skill.CDR *= 0.95 else: print(f"skill not found {skill_name}") pass def __杂项计算(self, mode=0): if "others" not in self.打造详情.keys(): return setinfo = self.打造详情["others"] # 收集箱 try: from core.equipment.sundry import get_sundriesfunc_by_id func = get_sundriesfunc_by_id(setinfo["SJX_TYPE"]) # print(func) func(self, 0, False, setinfo["SJX_XY"], setinfo["SJX_SQ"]) except Exception: pass # 勋章 try: from core.equipment.sundry import get_sundriesfunc_by_id func = get_sundriesfunc_by_id(setinfo["XZ_TYPE"]) func( self, 0, False, setinfo.get("XZ_SHZ", 0), setinfo.get("XZ_QH", 0), setinfo.get("XZ_GS", 0), ) except Exception: pass # 勋章 - New # 老徽章选择为无 才生效 if int(setinfo.get("XZ_TYPE", 0)) == 0: try: from core.equipment.sundry import get_sundriesfunc_by_id func = get_sundriesfunc_by_id(27063) func( self, 0, False, setinfo.get("medal_quality", 0), setinfo.get("medal_lv", 0), [ setinfo.get("medal_gems_1", 0), setinfo.get("medal_gems_2", 0), setinfo.get("medal_gems_3", 0), setinfo.get("medal_gems_4", 0), ], 0.1, ) pass except Exception: pass for i in setinfo.keys(): if i.startswith("SJX") or i.startswith("XZ"): pass else: try: id = setinfo[i] from core.equipment.sundry import get_sundriesfunc_by_id func = get_sundriesfunc_by_id(id) # 站街 func(self) # 进图 func(self, mode=1) except Exception: pass def __徽章计算(self): idlist = [] for i in 部位列表 + ( "皮肤", "光环", "武器装扮", ): # ('皮肤', '光环', '武器装扮', ) if i in self.打造详情.keys() and self.部位是否穿戴(i): temp = self.打造详情[i] for j in ["socket_left", "socket_right"]: id = temp.get(j, 0) if id == 0: pass elif str(id).isdigit(): idlist.append(id) else: # 白金技能等级加成处理 id:技能名称 self.单技能加成(名称=id, lv=1) self.基础属性加成(四维=8) pass for i in idlist: from core.equipment.emblems import get_embfunc_by_id func = get_embfunc_by_id(i) func(self) # 打印相关函数和效果 # print('{}: {}'.format(func, func(self, text=TRUE))) def __附魔计算(self): for i in self.部位附魔.keys(): if self.部位是否穿戴(i): func = self.部位附魔[i] func(self, part=i) func(self, mode=1, part=i) # 打印相关函数和效果 # print('{}: {}: {}'.format(i, func, func(self, text=TRUE))) def 装备基础(self): # 移除不符合版本的装备，不参与后续计算 self.装备栏 = list( filter( lambda x: get_equ(self.equVersion).get_equ_by_id(x).名称 != "", self.装备栏, ) ) for id in self.装备栏: temp = get_equ(self.equVersion).get_equ_by_id(id) temp = get_equ(self.equVersion).get_equ_by_id( id, self.打造详情.get(temp.部位, {}).get("growth_sj", 0) > 0 ) if "甲" in temp.类型: self.__防具计算(temp) elif temp.类型 == "首饰": self.__首饰计算(temp) elif temp.类型 == "特殊装备": self.__特殊装备计算(temp) elif temp.部位 == "武器": self.武器计算(temp) elif temp.部位 in ["称号", "宠物"]: self.__称号宠物计算(temp) if temp.部位 not in ["称号", "宠物"]: self.__增幅计算(temp) pass # if temp.所属套装 != '智慧产物': # return 精通计算(temp.等级, temp.品质, self.打造详情.get(部位, {}).get('cursed_number', 0), 部位) # else: # return 精通计算(temp.等级, temp.品质, self.打造详情.get(部位, {}).get('wisdom_number', 0), 部位) def __防具计算(self, temp: equipment) -> None: self.基础属性加成(**temp.__dict__) 部位 = temp.部位 强化等级 = self.打造详情.get(部位, {}).get("cursed_number", 0) 力量 = 智力 = 体力 = 精神 = 0 if self.类型 == "辅助": if "智力" in self.防具精通属性: 智力 += 辅助精通计算( 110 if temp.神 else temp.等级, temp.品质, 强化等级, 部位, "智力" ) if "精神" in self.防具精通属性: 精神 += 辅助精通计算( 110 if temp.神 else temp.等级, temp.品质, 强化等级, 部位, "精神" ) if "体力" in self.防具精通属性: 体力 += 辅助精通计算( 110 if temp.神 else temp.等级, temp.品质, 强化等级, 部位, "体力" ) else: 精通数值 = 精通计算( 110 if temp.神 else temp.等级, temp.品质, 强化等级, 部位, self.防具类型 ) if "力量" in self.防具精通属性: 力量 += 精通数值 if "智力" in self.防具精通属性: 智力 += 精通数值 # if temp.等级 == 105: # if self.类型 == '辅助': # self.技能等级加成('主动', 30, 30, 1) # self.技能等级加成('主动', 50, 50, 1) self.基础属性加成(力量=力量, 智力=智力, 体力=体力, 精神=精神) def __增幅计算(self, temp: equipment) -> None: if self.打造详情.get(temp.部位, {}).get("cursed_type", 1) == 1: x = 增幅计算( min(temp.等级, MAXEQULV), temp.品质, self.打造详情.get(temp.部位, {}).get("cursed_number", 0), ) if self.类型 == "物理百分比" or self.类型 == "物理固伤": self.基础属性加成(力量=x) self.打造[temp.部位]["增幅四维"][0] = x elif self.类型 == "魔法百分比" or self.类型 == "魔法固伤": self.基础属性加成(智力=x) self.打造[temp.部位]["增幅四维"][1] = x elif self.类型 == "辅助": if self.适用属性 == "体力": self.基础属性加成(体力=x) self.打造[temp.部位]["增幅四维"][2] = x elif self.适用属性 == "精神": self.基础属性加成(精神=x) self.打造[temp.部位]["增幅四维"][3] = x else: self.基础属性加成(智力=x) self.打造[temp.部位]["增幅四维"][1] = x # if self.是否增幅[i] and temp.所属套装 != '智慧产物': # x = 增幅计算(temp.等级, temp.品质, self.强化等级[i]) def __称号宠物计算(self, temp: equipment) -> None: self.基础属性加成(**temp.__dict__) def __首饰计算(self, temp: equipment) -> None: self.基础属性加成(**temp.__dict__) # if temp.等级 == 105 and self.类型 == '辅助': # self.技能等级加成('主动', 30, 30, 1) # self.技能等级加成('主动', 50, 50, 1) def __特殊装备计算(self, temp: equipment) -> None: self.基础属性加成(**temp.__dict__) # if temp.等级 == 105 and self.类型 == '辅助': # self.技能等级加成('主动', 30, 30, 1) # self.技能等级加成('主动', 50, 50, 1) # if temp.品质 == '史诗' and temp.部位 == '魔法石': # self.技能等级加成('主动', 50, 50, 1) # 耳环 if temp.部位 == "耳环": # if temp.所属套装 != '智慧产物': x = 耳环计算( min(temp.等级, MAXEQULV), temp.品质, self.打造详情.get(temp.部位, {}).get("cursed_number", 0), ) self.打造["耳环"]["强化攻击力"] = [x] * 3 self.基础属性加成(三攻=x) # 辅助装备、魔法石 else: # if temp.所属套装 != '智慧产物': x = 左右计算( min(temp.等级, MAXEQULV), temp.品质, self.打造详情.get(temp.部位, {}).get("cursed_number", 0), ) if self.类型 == "辅助": self.打造[temp.部位]["强化四维"] = [x] * 4 else: self.打造[temp.部位]["强化四维"] = [x] * 2 self.基础属性加成(四维=x) def 武器计算(self, temp: equipment) -> None: self.基础属性加成(**temp.__dict__) self.武器类型 = temp.类型 # if temp.等级 == 105 and self.类型 == '辅助': # self.技能等级加成('主动', 30, 30, 3) # self.技能等级加成('主动', 50, 50, 4) # if temp.品质 == '史诗': # self.技能等级加成('主动', 50, 50, 1) # if temp.所属套装 != '智慧产物': info = self.打造详情.get(temp.部位, {}) # 暂时没有用110计算强化增幅的 物理攻击力 = 武器强化计算( min(temp.等级, MAXEQULV), temp.品质, info.get("cursed_number", 0), temp.类型, "物理", ) 魔法攻击力 = 武器强化计算( min(temp.等级, MAXEQULV), temp.品质, info.get("cursed_number", 0), temp.类型, "魔法", ) 独立攻击力 = 锻造计算( min(temp.等级, MAXEQULV), temp.品质, info.get("dz_number", 0) ) self.打造["武器"]["强化攻击力"] = [物理攻击力, 魔法攻击力, 0] self.打造["武器"]["锻造加成"][0] = 独立攻击力 四维 = 0 if self.类型 == "辅助": 四维 = 锻造四维(min(temp.等级, MAXEQULV), temp.品质, info.get("dz_number", 0)) self.打造["武器"]["锻造加成"][1] = 四维 self.基础属性加成( 物理攻击力=物理攻击力, 魔法攻击力=魔法攻击力, 独立攻击力=独立攻击力, 四维=四维, ) def 职业装备特殊计算(self) -> None: pass def 药剂计算(self, rate=1.0) -> None: from core.equipment.consumable import get_sundriesfunc_by_id for item in self.药剂: func = get_sundriesfunc_by_id(item) func(self, rate=rate, mode=0) func(self, rate=rate, mode=1) def 是否升级110(self, part): return self.词条等级[part][0] > 80 def 兼容数量统计(self, suit): equs = get_equ(self.equVersion) count = 0 for i in 部位列表: equ = equs.get_equ_by_id(self.部位装备.get(i, 0)) if len(equ.suits) < 2: continue if suit in equ.suits: count += 1 return count def 套装统计(self): suit = [] self.suits = [] equs = get_equ(self.equVersion) for i in 部位列表: equ = equs.get_equ_by_id(self.部位装备.get(i, 0)) if len(equ.suits) < 0: continue # 星辰百变 if len(equ.可选属性) > 0: if self.打造详情.get(i, {}).get("changeable", True): suit += equ.suits else: suit += equ.suits for i in self.融合列表: equ = equs.get_equ_by_id(i) if len(equ.suits) < 0: continue suit += equ.suits suit_count = {} for i in set(suit): suit_count[i] = suit.count(i) suits = [] compatibility = [] for i in suit_count: suitsInfo = list( filter( lambda x: x["suit_id"] == i and x["need_num"] <= suit_count[i], equs.suit_info, ) ) for j in suitsInfo: suits.append(j["id"]) compatibility += j["compatibility"] self.suits = list(set(suits) - set(compatibility)) self.suitInfo = [] for i in self.suits: temp = list(filter(lambda x: x["id"] == i, equs.suit_info))[0] self.suitInfo.append(f'{temp["name"]}[{temp["need_num"]}]') pass def __装备词条计算(self): # 攻击强化相关计算 for i in 部位列表: temp = [] equ = get_equ(self.equVersion).get_equ_by_id(self.部位装备.get(i, 0)) if equ.品质 == "传说": # limit = 80 # limit = 70 # for j in [ # "growth_cs_first", # "growth_cs_second", # "growth_cs_third", # "growth_cs_fourth", # ]: temp = [80] * 4 else: temp = [140]*4 # limit = 80 # growth_sj = self.打造详情.get(i, {}).get("growth_sj", 0) # if growth_sj > 0: # temp = [80 + growth_sj] * 4 # else: # for j in [ # "growth_first", # "growth_second", # "growth_third", # "growth_fourth", # ]: # temp.append(min(limit, self.打造详情.get(i, {}).get(j, 1))) # 锁定等级 常规武器升级锁神40 传说武器锁定70 for name in ["霜", "雨", "雷", "风", "焰", "失衡"]: if equ.名称.startswith(f"{name} :"): temp = [120] * 4 if equ.名称.startswith("跨越之忆"): temp = [70] * 4 # limit = 70 if get_equ(self.equVersion).get_equ_by_id( # self.部位装备.get(i, 0)).品质 == "传说" else 80 # for j in ["growth_first", "growth_second", "growth_third", "growth_fourth"]: # temp.append(min(limit, self.打造详情.get(i, {}).get(j, 1))) self.词条等级[i] = temp asrahan = False weapon = ( get_equ(self.equVersion).get_equ_by_id(self.部位装备.get("武器", 0)).名称 ) for index, name in enumerate(["雷", "风", "霜", "焰", "雨", "失衡"]): if weapon.startswith(f"{name} :") and self.asrahan.get("type", 0) == index: asrahan = True if weapon.startswith("跨越之忆") and self.asrahan.get("type", 0) in [0, 1, 2, 3, 4]: asrahan = True if asrahan: get_equ(self.equVersion).get_asrahan()( self, self.asrahan.get("type", 0), self.asrahan.get("lv", 0), self.asrahan.get("additional", 0), ) 武器融合词条 = self.武器融合.get(str(self.部位装备.get("武器", 0)), []) 成长词条组合 = get_equ(self.equVersion).get_damagelist_by_idlist( self.装备栏, self.自定义词条, self.融合列表, 武器融合词条 ) temp_params = {} for 部位, 序号, atk, buff, params, _type, index in 成长词条组合: if _type > 0: 等级 = self.词条等级[部位][序号] else: # 贴膜/融合 等级 = 1 attack = 成长词条计算(atk, 等级, self.equVersion) if ( get_equ(self.equVersion).get_equ_by_id(self.部位装备.get(部位, 0)).品质 == "传说" and 等级 > 60 ): attack += 10 * (等级 - 60) / 4 buffer = 成长词条计算(buff, 等级, self.equVersion) self.攻击强化加成(attack) self.辅助属性加成(buff量=buffer) # 装备打造 if _type > 0: self.打造[部位]["attack"][序号] = attack self.打造[部位]["buffer"][序号] = buffer self.打造[部位]["params"][序号] = [] temp_params[部位] = temp_params.get(部位, {}) temp_params[部位][str(序号)] = temp_params[部位].get(str(序号), []) params = [] if params is None else params for param in params: param = 成长词条计算(param, 等级, self.equVersion) if _type > 0: self.打造[部位]["params"][序号].append(param) temp_params[部位][str(序号)].append(param) # 词条效果相关计算 for func, 部位, 序号, index, _type, id, 融合石词条位置 in get_equ( self.equVersion ).get_func_list_by_idlist(self): if _type > 0: 等级 = self.词条等级[部位][序号] # 特性 elif _type == -2: 等级 = self.特性等级.get(str(index), 0) # 融合 elif _type == -3: 等级 = self.融合石等级.get(str(id),[0,0,0])[融合石词条位置] else: 等级 = 1 params = temp_params.get(部位, {}).get(str(序号), []) # print(部位, 序号, self.打造[部位]["params"][序号], index) params = [] if params == [None] else params # print(序号, params, index) # print(序号, params, 部位) res = func(self, mode=0, part=部位, lv=等级, params=params) # 进图效果 if res is not None: # print(res, type(res)) if isinstance(res,list): for i in res: self.打造[部位]["tips"].append(i) else: self.打造[部位]["tips"].append(res) if 部位 not in self.tip_part: self.tip_part.append(部位) for func, 部位, 序号, index, _type, id, 融合石词条位置 in get_equ( self.equVersion ).get_func_list_by_idlist(self): if _type > 0: 等级 = self.词条等级[部位][序号] # 特性 elif _type == -2: 等级 = self.特性等级.get(str(index), 0) # 融合 elif _type == -3: 等级 = self.融合石等级.get(str(id),[0,0,0])[融合石词条位置] else: 等级 = 1 params = temp_params.get(部位, {}).get(str(序号), []) # print(部位, 序号, self.打造[部位]["params"][序号], index) params = [] if params == [None] else params # print(序号, params, index) # print(序号, params, 部位) # func(self, part=部位, lv=等级, params=params) # 站街效果 res = func(self, mode=1, part=部位, lv=等级, params=params) # 进图效果 if res is not None: # print(res, type(res)) if isinstance(res,list): for i in res: self.打造[部位]["tips"].append(i) else: self.打造[部位]["tips"].append(res) if 部位 not in self.tip_part: self.tip_part.append(部位) # 打印相关函数和效果 # print('{}(lv.{}): {} {}'.format(部位, 等级, func, func(self, text=TRUE))) def check_fun_by_id(self, id): idList = get_equ(self.equVersion).get_func_list_by_idlist(self) return id in [index for _, _, _, index, _,_,_ in idList] def check_equ_by_name(self, name): id = get_equ(self.equVersion).get_equ_by_name(name).id return id > 0 and (id in self.装备栏 or id in self.融合列表) def check_fusion_upgrade(self, part): return self.打造详情.get(part, {}).get("fusion_upgrade", False) def 被动倍率计算(self): if self.__基础精通倍率 != 1: 基础精通 = self.get_skill_by_name("基础精通") if 基础精通.名称 == "基础精通": 基础精通.倍率 *= self.__基础精通倍率 for i in self.技能栏: i.被动倍率 = 1 for i in self.技能栏: for index in range(0, 4): index = "" if index == 0 else str(index) 关联技能 = getattr(i, "关联技能" + index, ["无"]) 非关联技能 = getattr(i, "非关联技能" + index, ["无"]) try: 加成倍率 = eval("i.加成倍率" + index + "(self.武器类型)") except Exception: 加成倍率 = 1.0 try: # print(i.名称, 加成倍率, eval("i.加成描述"+index+"(self.武器类型)")) if 加成倍率 != 1: self.skills_passive[i.名称]["info"].append( { "type": "倍率", "info": eval("i.加成描述" + index + "(self.武器类型)"), } ) except Exception: pass if 关联技能 != ["无"]: if 关联技能 == ["所有"]: for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 *= 加成倍率 else: # print(self.技能序号) for k in 关联技能: self.技能栏[self.技能序号[k]].被动倍率 *= 加成倍率 if 非关联技能 != ["无"]: if 非关联技能 == ["所有"]: for j in self.技能栏: if j.是否有伤害 == 1: j.被动倍率 /= 加成倍率 else: for k in 非关联技能: self.技能栏[self.技能序号[k]].被动倍率 /= 加成倍率 def 加算冷却计算(self): for i in self.技能栏: if i.是否有伤害 == 1: i.CDR *= 1 - self.__加算冷却缩减 def CD倍率计算(self): for i in self.技能栏: for index in range(0, 4): index = "" if index == 0 else str(index) 关联技能 = getattr(i, "冷却关联技能" + index, ["无"]) 非关联技能 = getattr(i, "非冷却关联技能" + index, ["无"]) 冷却类型 = getattr(i, "冷却类型" + index, 0) try: 加成倍率 = eval("i.CD缩减倍率" + index + "(self.武器类型)") except Exception: 加成倍率 = 1.0 try: if 加成倍率 != 1: self.skills_passive[i.名称]["info"].append( { "type": "CDR", "info": eval( "i.CD缩减描述" + index + "(self.武器类型)" ), } ) except Exception: pass if 关联技能 != ["无"]: if 关联技能 == ["所有"]: for j in self.技能栏: if j.是否有伤害 == 1: if 冷却类型 == 0: j.CDR *= 加成倍率 if 冷却类型 == 1: j.CDR_O *= 加成倍率 else: for k in 关联技能: if 冷却类型 == 0: self.技能栏[self.技能序号[k]].CDR *= 加成倍率 if 冷却类型 == 1: self.技能栏[self.技能序号[k]].CDR_O *= 加成倍率 if 非关联技能 != ["无"]: if 非关联技能 == ["所有"]: for j in self.技能栏: if j.是否有伤害 == 1: if 冷却类型 == 0: j.CDR /= 加成倍率 if 冷却类型 == 1: j.CDR_O /= 加成倍率 else: for k in 非关联技能: if 冷却类型 == 0: self.技能栏[self.技能序号[k]].CDR /= 加成倍率 if 冷却类型 == 1: self.技能栏[self.技能序号[k]].CDR_O /= 加成倍率 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.暗抗输入)) self.属性倍率 = max(self.属性倍率组) def __面板系数计算(self, mode=1): if self.类型 is None or self.类型 == "": self.类型 = self.输出类型选项[0] # 基础面板 不含百分比力智和百分比三攻 if mode == 0: if self.类型 == "物理百分比": return int((self.基础面板力量() / 250 + 1) * self.基础面板物理攻击力()) elif self.类型 == "魔法百分比": return int((self.基础面板智力() / 250 + 1) * self.基础面板魔法攻击力()) elif self.类型 == "物理固伤": return int((self.基础面板力量() / 250 + 1) * self.基础面板独立攻击力()) elif self.类型 == "魔法固伤": return int((self.基础面板智力() / 250 + 1) * self.基础面板独立攻击力()) # 旧版算法 不含斗神、宠物技能等 else: if self.类型 == "物理百分比": return int( (self.面板力量() / 250 + 1) * self.基础面板物理攻击力() * (1 + self.__百分比三攻) ) elif self.类型 == "魔法百分比": return int( (self.面板智力() / 250 + 1) * self.基础面板魔法攻击力() * (1 + self.__百分比三攻) ) elif self.类型 == "物理固伤": return int( (self.面板力量() / 250 + 1) * self.基础面板独立攻击力() * (1 + self.__百分比三攻) ) elif self.类型 == "魔法固伤": return int( (self.面板智力() / 250 + 1) * self.基础面板独立攻击力() * (1 + self.__百分比三攻) ) def 伤害指数计算(self): 防御 = max(self.防御输入 * self.防御系数 - self.__固定减防, 0) * ( 1 - self.__百分比减防 ) # 固定攻击方100级 基准倍率 = 1.5 * self.buff * (1 - 防御 / (防御 + 200 * 100)) self.__属性倍率计算() # 基础面板 不含百分比力智和百分比三攻 基础面板 = self.__面板系数计算(mode=0) 旧版面板 = self.__面板系数计算(mode=1) # 攻击强化显示改版 新 = self.__攻击强化 * (1 + self.__百分比攻击强化) * 0.01 # 攻击强化显示改版 旧 = ( 1 + int((self.__伤害增加 + 0.00000001) * 100) / 100 ) # 避免出现浮点数取整BUG 旧 *= 1 + self.__暴击伤害 旧 *= 1 + self.__最终伤害 旧 *= 1 + self.__持续伤害 旧 *= 1 + self.__附加伤害 + self.__属性附加 * self.属性倍率 self.伤害指数 = ( (新 * 基础面板 + 旧 * 旧版面板) * self.技能攻击力 * self.属性倍率 * 基准倍率 * self.斗神宠物 * ( 1.25 if "破招攻击" in get_global_data("attack_type", self.equVersion) else 1.0 ) ) # 7.8日,伤害数据压缩 self.伤害指数 /= 1000 def 基础属性修正(self, info): from core.util.toNum import str_to_num self.攻击强化加成(str_to_num(info.get("攻击强化", 0))) self.buff量加成(str_to_num(info.get("BUFF量", 0))) self.百分比攻击强化加成(str_to_num(info.get("攻击强化百分比", 0)) / 100) self.__百分比buff量 += str_to_num(info.get("BUFF量百分比", 0)) / 100 if self.类型 == "辅助": self.基础属性加成(四维=str_to_num(info.get("四维", 0))) else: self.基础属性加成( 进图力量=str_to_num(info.get("四维", 0)), 进图智力=str_to_num(info.get("四维", 0)), 体精=str_to_num(info.get("四维", 0)), 三攻=str_to_num(info.get("三攻", 0)), ) self.技能攻击力加成(str_to_num(info.get("技攻", 0)) / 100) self.基础属性加成( 火属性抗性=str_to_num(info.get("火抗", 0)), 光属性抗性=str_to_num(info.get("光抗", 0)), 冰属性抗性=str_to_num(info.get("冰抗", 0)), 暗属性抗性=str_to_num(info.get("暗抗", 0)), ) self.攻击速度增加(str_to_num(info.get("攻速", 0)) / 100) self.火属性强化加成(str_to_num(info.get("火强", 0))) self.光属性强化加成(str_to_num(info.get("光强", 0))) self.冰属性强化加成(str_to_num(info.get("冰强", 0))) self.暗属性强化加成(str_to_num(info.get("暗强", 0))) for 抗性 in [ "出血", "中毒", "灼伤", "感电", "冰冻", "减速", "眩晕", "诅咒", "失明", "石化", "睡眠", "混乱", "束缚", ]: self.异常抗性加成(抗性, str_to_num(info.get(抗性 + "抗性", 0)) / 100) self.MP消耗量加成(str_to_num(info.get("MP消耗量", 0)) / 100) self.set_eq_params( "skill_range", self.get_eq_params("skill_range") + str_to_num(info.get("技能范围Σ", 0)) / 100, ) # endregion def get_individuation(self, index): if index >= len(self.individuation): return 0 else: return 0 if self.individuation[index] is None else self.individuation[index] def calc_init(self, info, equipList: List[int] = []): # 获取打造数据 self.__打造设置(info.get("forge_set", {})) self.asrahan = info.get("asrahan", {}) # 设置职业信息 self.__set_char(info) self.__怪物信息设置(info.get("monster", 2)) self.__场景设置(info.get("scene", 1)) # 自定义词条部分 self.自定义词条 = info.get("customize", {}) # 时装设置 self.__穿戴装扮(info.get("dress_set", {})) # 获取装备列表 self.__穿戴装备(list(map(int, equipList))) # 获取技能数据 self.__skill_set(info.get("skill_set", {})) # 获取装备选项数据 self.trigger_set = info.get("trigger_set", {}) self.__equ_chose_set(self.trigger_set) # 药剂设置 self.__药剂设置(info.get("consumable_list", [])) self.hotkey_set(info.get("hotkey_set", [])) self.融合列表 = list(map(int, info.get("fusion_list", []))) self.武器融合 = info.get("merge", {}) self.特性列表 = [int(i) for i in list(info.get("specificity", {}).keys())] self.特性等级 = info.get("specificity", {}) self.融合石等级 = info.get("stone_set", {}) self.技能队列设置(info.get("skill_que", [])) self.individuation = info.get("individuation", []) self.基础属性修正( info.get( "corrections", { "BUFF量": 0, "BUFF量百分比": 0, "三攻": 0, "光强": 0, "光抗": 0, "冰强": 0, "冰抗": 0, "力智": 0, "四维": 0, "技攻": 0, "攻击强化": 0, "攻击强化百分比": 0, "攻速": 0, "暗强": 0, "暗抗": 0, "火强": 0, "火抗": 0, }, ) ) def jade_upgrade(self): temp = [] from core.equipment.jade import get_jade_setinfo, get_jadefunc_by_id num_range = [26001, 26020] if self.类型 == "辅助": num_range = [26011, 26206] for jade in get_jade_setinfo(): if jade["id"] > num_range[0] and jade["id"] <= num_range[1]: char = deepcopy(self) func = get_jadefunc_by_id(jade["id"]) func(char, value=jade["max"]) char.__计算前预处理() temp.append( { "id": jade["id"], "name": jade["props"] + " " + ("" if jade["max"] == 1 else ("+" + str(jade["max"]))) + jade["unit"], "damage": round(char.结果计算()["total_data"], 2), "order": jade["order"], } ) return temp def 异常保有率计算(self, pa, cur): if cur == "灼伤破冰": 冰冻CD = min( self.异常时间["冰冻"][3], get_global_data("bd_cd", self.equVersion) ) # 不带鞋子，内置3秒结算CD if not self.check_equ_by_name("信守誓约的步伐"): 冰冻CD = max(3, 冰冻CD) # 破韧后，原本的CD是多少就是多少 if get_global_data("control_state", self.equVersion): 冰冻CD = min( self.异常时间["冰冻"][3], 冰冻CD, get_global_data("bd_cd", self.equVersion), ) 灼伤 = self.异常时间["灼伤"] return max(1 - (2 * 冰冻CD + 1) / (4 * (灼伤[0] * 灼伤[2] + 灼伤[1])), 0) else: if self.get_eq_params(f"{cur}-结算") == 0: return 0 持续时间 = ( self.异常时间[cur][0] * self.异常时间[cur][2] + self.异常时间[cur][1] ) 异常CD = min( self.异常时间[cur][3], get_global_data(pa.split("_")[0] + "_cd", self.equVersion, 99), ) if self.check_equ_by_name("承诺誓约的腰带"): 异常CD = max(0.5, 异常CD) return max(1 - (2 * 异常CD + 1) / (4 * 持续时间), 0) def calc( self, setName: str = "set", equipList: List[int] = [], withJade=False, withSet=False, info=None, ): self.calc_init(info, equipList) jade = [] # cus = [] # merge = [] if withJade: jade = self.jade_upgrade() # if withCus and self.类型 != '辅助': # cus = self.cus_upgrade(CusPosition) # if withMerge and self.类型 != '辅助': # merge = self.merge_upgrade() self.__计算前预处理() temp = self.结果计算() calc_info = {} if self.类型 == "辅助": calc_info[self.适用属性] = self.站街系数() elif self.类型 == "物理百分比": calc_info["力量"] = self.基础面板力量() calc_info["物理攻击"] = self.站街物理攻击力() elif self.类型 == "魔法百分比": calc_info["智力"] = self.基础面板智力() calc_info["魔法攻击"] = self.站街魔法攻击力() elif self.类型 == "物理固伤": calc_info["力量"] = self.基础面板力量() calc_info["独立攻击"] = self.站街独立攻击力() elif self.类型 == "魔法固伤": calc_info["智力"] = self.基础面板智力() calc_info["独立攻击"] = self.站街独立攻击力() # print(suitInfo) calc_info["火"] = int(self.火属性强化()) calc_info["冰"] = int(self.冰属性强化()) calc_info["光"] = int(self.光属性强化()) calc_info["暗"] = int(self.暗属性强化()) calc_info["火抗"] = self.火属性抗性() calc_info["冰抗"] = self.冰属性抗性() calc_info["光抗"] = self.光属性抗性() calc_info["暗抗"] = self.暗属性抗性() for i in self.技能栏: 倍率 = i.独立攻击力倍率(self.武器类型) if i.名称 not in self.skills_passive: continue if 倍率 != 1: self.skills_passive[i.名称]["info"].append( { "type": "独立攻击力", "info": [round((倍率 - 1) * 100), "所有", ""], } ) 倍率 = i.魔法攻击力倍率(self.武器类型) if 倍率 != 1: self.skills_passive[i.名称]["info"].append( { "type": "魔法攻击力", "info": [round((倍率 - 1) * 100), "所有", ""], } ) 倍率 = i.物理攻击力倍率(self.武器类型) if 倍率 != 1: self.skills_passive[i.名称]["info"].append( { "type": "物理攻击力", "info": [round((倍率 - 1) * 100), "所有", ""], } ) 倍率 = i.独立攻击力倍率进图(self.武器类型) if i.名称 not in self.skills_passive: continue if 倍率 != 1: self.skills_passive[i.名称]["info"].append( { "type": "独立攻击力[进图]", "info": [round((倍率 - 1) * 100), "所有", ""], } ) 倍率 = i.魔法攻击力倍率进图(self.武器类型) if 倍率 != 1: self.skills_passive[i.名称]["info"].append( { "type": "魔法攻击力[进图]", "info": [round((倍率 - 1) * 100), "所有", ""], } ) 倍率 = i.物理攻击力倍率进图(self.武器类型) if 倍率 != 1: self.skills_passive[i.名称]["info"].append( { "type": "物理攻击力[进图]", "info": [round((倍率 - 1) * 100), "所有", ""], } ) buff = self.get_skill_by_name("BUFF") awake = self.get_skill_by_name("一次觉醒") skills_passive = {} for i in self.skills_passive.keys(): if len(self.skills_passive[i].get("info", [])) > 0: skills_passive[i] = self.skills_passive[i] result = { "id": uuid1().hex, "alter": self.实际名称, "name": self.名称, "role": "buffer" if self.类型 == "辅助" else "delear", "equips_forge": self.打造, "suits": self.suitInfo, "info": { # 站街 "站街": calc_info, # 词条 "properties": { # 攻击强化 "攻击强化": round(self.__攻击强化, 0), "buffer_power": round(self.BUFF量(), 0), "buffer_power_value": round(self.__buff量, 0), "buffer_power_per": round(self.__百分比buff量 * 100, 2), "技能攻击力": round(100 * (self.技能攻击力 - 1), 2), "面板技能攻击力": round(100 * (self.__面板技能攻击力 - 1), 2), "百分比攻击强化": round(self.__百分比攻击强化 * 100, 1), "MP消耗量": round(self.__MP消耗量 * 100 - 100, 2), "伤害比例": [ self.伤害比例.get("直伤", 1), self.伤害比例.get("中毒", 0), self.伤害比例.get("灼伤", 0), self.伤害比例.get("感电", 0), self.伤害比例.get("出血", 0), ], "伤害系数": [ self.伤害系数.get("直伤", 1), self.伤害系数.get("中毒", 1) - 1, self.伤害系数.get("灼伤", 1) - 1, self.伤害系数.get("感电", 1) - 1, self.伤害系数.get("出血", 1) - 1, ], "技能范围": self.get_eq_params("skill_range"), "技能范围∏": self.get_eq_params("skill_range_multi", 1), "保护罩": self.get_eq_params("protect") * (1 + self.get_eq_params("protect_max")), # '无色消耗': temp['无色消耗'], "apply_value": self.适用数值, "buff_level": buff.等级, "buff_name": buff.名称, "awake_level": awake.等级, "awake_name": awake.名称, "buff_intstr_per": self.__buff百分比力智, "buff_intstr": self.__buff固定力智, "buff_attack_per": self.__buff百分比三攻, "buff_attack": self.__buff固定三攻, "awake_intstr_per": self.__觉醒百分比力智, "awake_intstr": self.__觉醒固定力智, "攻击速度": self.__攻击速度, "其他攻击速度": self.__攻击速度_其他, "施放速度": self.__施放速度, "移动速度": self.__移动速度, "cdr": temp.get("CDR", []), "冷却缩减": self.冷却缩减 * (1 - self.__加算冷却缩减), "冷却恢复": self.冷却恢复, "defense": self.get_eq_params("defense"), "defense_ratio": self.get_eq_params("defense_ratio"), "hurted_ratio": self.get_eq_params("hurted_ratio"), "era": round( ( 1 - ( 1 - self.get_eq_params("defense") * (1 + self.get_eq_params("defense_ratio")) / ( 100000 + self.get_eq_params("defense") * (1 + self.get_eq_params("defense_ratio")) ) ) * (1 - self.get_eq_params("hurted_ratio")) ) * 100, 2, ), }, }, "total_data": temp["buffer_addition"] if "buffer_addition" in temp else [temp["total_data"], 0, 0, 0], "skills": temp["skills"], "skills_passive": skills_passive, "specificity": info.get("specificity", []), "jade": sorted(jade, key=lambda x: x["order"]), "talisman_set":info.get("talisman_set", []), "rune_set":info.get("rune_set", []), # "cus": cus, "tip_part": self.tip_part, } if withSet: result["forge_set"] = info["forge_set"] result["equips"] = list( map(lambda x: get_equ(self.equVersion).get_json(x), self.装备栏) ) result["merge_list"] = self.武器融合 result["fusion_list"] = self.融合列表 result["customize"] = info["customize"] for 抗性 in [ "出血", "中毒", "灼伤", "感电", "冰冻", "减速", "眩晕", "诅咒", "失明", "石化", "睡眠", "混乱", "束缚", ]: result["info"]["properties"][抗性 + "抗性"] = self.异常抗性获取(抗性) * 100 return result def createCharacter(alter: str, equVersion: str = "0"): character: Character = None module_name = "core.characters." + alter try: character = importlib.import_module(module_name).classChange(equVersion) except Exception as ex: print(ex) print("create character " + module_name + " error.") pass return character