diff --git a/StarRailUID/starrailuid_charinfo/__init__.py b/StarRailUID/starrailuid_charinfo/__init__.py index ee9c1c6..c4511fb 100644 --- a/StarRailUID/starrailuid_charinfo/__init__.py +++ b/StarRailUID/starrailuid_charinfo/__init__.py @@ -7,7 +7,7 @@ from gsuid_core.sv import SV from gsuid_core.bot import Bot from gsuid_core.models import Event -from .cal_damage import cal_info +from .cal_damage import cal, cal_info from .to_card import api_to_card from ..utils.convert import get_uid from ..utils.sr_prefix import PREFIX @@ -40,10 +40,10 @@ async def send_damage_msg(bot: Bot, ev: Event): if isinstance(char_data, str): return await bot.send(char_data) im_list = [] - im = await cal_info(char_data) + im = await cal(char_data) for info_im in im: - con = f"{info_im['name']}" - con = f"{con} 暴击伤害{info_im['damagelist'][0]} 期望伤害{info_im['damagelist'][1]} 满配辅助末日兽伤害{info_im['damagelist'][2]}" + con = f"{info_im[0]}" + con = f"{con} 暴击伤害{info_im[1]} 期望伤害{info_im[2]} 满配辅助末日兽伤害{info_im[3]}" im_list.append(con) await bot.send(im_list) return None diff --git a/StarRailUID/starrailuid_charinfo/damage/AvatarDamage/AvatarDamage.py b/StarRailUID/starrailuid_charinfo/damage/AvatarDamage/AvatarDamage.py index 95ad8f1..6472470 100644 --- a/StarRailUID/starrailuid_charinfo/damage/AvatarDamage/AvatarDamage.py +++ b/StarRailUID/starrailuid_charinfo/damage/AvatarDamage/AvatarDamage.py @@ -633,14 +633,1324 @@ class Danhengil(BaseAvatar): logger.info(skill_info_list) return skill_info_list +class Argenti(BaseAvatar): + Buff: BaseAvatarBuff + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 1: + self.eidolon_attribute['CriticalDamageBase'] = 0.4 + if self.avatar_rank >= 2: + self.eidolon_attribute['AttackAddedRatio'] = 0.4 + if self.avatar_rank >= 6: + self.eidolon_attribute['Ultra_PhysicalResistancePenetration'] = 0.3 + + def extra_ability(self): + self.extra_ability_attribute['AllDamageAddedRatio'] = 0.15 + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + talent_cc_add = self.Skill_num('Talent', 'Talent') + attribute_bonus['CriticalChanceBase'] = talent_cc_add * 10 + attribute_bonus.get('CriticalChanceBase', 0) + if self.avatar_rank >= 4: + attribute_bonus['CriticalDamageBase'] = 0.08 + attribute_bonus.get('CriticalDamageBase', 0) + attribute_bonus['CriticalChanceBase'] = talent_cc_add * 2 + attribute_bonus.get('CriticalChanceBase', 0) + + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算战技伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '战技', 'damagelist': damagelist2}) + + # 计算大招1伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '终结技(90耗能)', 'damagelist': damagelist3}) + + # 计算大招2伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra1') + damagelist4 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist4[2] += damage3 + # 计算大招2额外伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra_add') + damagelist5 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist5[0] = damagelist5[0] * 6 + damagelist4[0] + damagelist5[1] = damagelist5[1] * 6 + damagelist4[1] + damagelist5[2] = damagelist5[2] * 6 + damagelist4[2] + skill_info_list.append({'name': '强化终结技(180耗能)', 'damagelist': damagelist5}) + return skill_info_list + +class Clara(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 2: + self.eidolon_attribute['AttackAddedRatio'] = 0.2 + + def extra_ability(self): + logger.info('额外能力') + logger.info('史瓦罗的反击造成的伤害提高30%') + self.extra_ability_attribute['TalentDmgAdd'] = 0.3 + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算战技伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '战技', 'damagelist': damagelist2}) + + # 计算反击伤害 + skill_multiplier = self.Skill_num('Talent', 'Talent') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '反击', 'damagelist': damagelist3}) + + # 计算强化反击伤害 + skill_multiplier = self.Skill_num('Talent', 'Talent') + self.Skill_num('Ultra', 'Talent1') + damagelist4 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist4[2] += damage3 + skill_info_list.append({'name': '强化反击', 'damagelist': damagelist4}) + + return skill_info_list + +class Silverwolf(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 6: + self.extra_ability_attribute['AllDamageAddedRatio'] = 1 + + def extra_ability(self): + logger.info('额外能力') + logger.info('战技降抗') + logger.info('战技使目标全属性抗性降低的效果额外降低3%') + enemy_status_resistance = self.Skill_num('BPSkill', 'BPSkill_D') + 0.03 + self.extra_ability_attribute[ + 'QuantumResistancePenetration' + ] = enemy_status_resistance + logger.info('终结技降防') + ultra_defence = self.Skill_num('Ultra', 'Ultra_D') + logger.info('天赋降防') + talent_defence = self.Skill_num('Talent', 'Talent') + ignore_defence = ultra_defence + talent_defence + self.extra_ability_attribute['ignore_defence'] = ignore_defence + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算战技伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '战技', 'damagelist': damagelist2}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + if self.avatar_rank >= 4: + skill_multiplier += 1 + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '终结技', 'damagelist': damagelist3}) + + return skill_info_list + +class Kafka(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 1: + self.extra_ability_attribute['DOTDmgAdd'] = 0.3 + if self.avatar_rank >= 2: + self.extra_ability_attribute['DOTDmgAdd'] = 0.55 + + def extra_ability(self): + pass + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算战技伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '战技', 'damagelist': damagelist2}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '终结技', 'damagelist': damagelist3}) + + # 计算持续伤害 + skill_multiplier = self.Skill_num('Ultra', 'DOT') + if self.avatar_rank >= 6: + skill_multiplier += 1.56 + damagelist4 = await calculate_damage( + base_attr, + attribute_bonus, + 'DOT', + 'DOT', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist4[2] += damage3 + skill_info_list.append({'name': '单次持续伤害', 'damagelist': damagelist4}) + + # 计算追加攻击伤害 + skill_multiplier = self.Skill_num('Talent', 'Talent') + damagelist5 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist5[2] += damage3 + skill_info_list.append({'name': '追加攻击', 'damagelist': damagelist5}) + + return skill_info_list + +class Blade(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + + if self.avatar_rank >= 2: + self.eidolon_attribute['CriticalChanceBase'] = 0.15 + if self.avatar_rank >= 4: + self.eidolon_attribute['HPAddedRatio'] = 0.4 + + def extra_ability(self): + logger.info('额外能力') + logger.info('天赋施放的追加攻击伤害提高20%') + self.extra_ability_attribute['TalentDmgAdd'] = 0.2 + logger.info('战技加伤') + self.extra_ability_attribute['AllDamageAddedRatio'] = self.Skill_num('BPSkill', 'BPSkill') + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算强化普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal1') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + + skill_multiplier = self.Skill_num('Normal', 'Normal1_HP') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + 1, + ) + damagelist3[0] += damagelist2[0] + damagelist3[1] += damagelist2[1] + damagelist3[2] += damagelist2[2] + skill_info_list.append({'name': '无间剑树', 'damagelist': damagelist3}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + damagelist4 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist4[2] += damage3 + + skill_multiplier = self.Skill_num('Ultra', 'Ultra_HP') + if self.avatar_rank >= 1: + skill_multiplier += 0.9 + damagelist5 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + 1, + ) + damagelist5[0] += damagelist4[0] + damagelist5[1] += damagelist4[1] + damagelist5[2] += damagelist4[2] + skill_info_list.append({'name': '终结技', 'damagelist': damagelist5}) + + # 计算追加攻击伤害 + skill_multiplier = self.Skill_num('Talent', 'Talent') + damagelist6 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist6[2] += damage3 + + skill_multiplier = self.Skill_num('Talent', 'Talent_HP') + damagelist7 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + 1, + ) + damagelist7[0] += damagelist6[0] + damagelist7[1] += damagelist6[1] + damagelist7[2] += damagelist6[2] + if self.avatar_rank >= 6: + hp = base_attr['hp'] * (1 + attribute_bonus['HPAddedRatio']) + attribute_bonus['HPDelta'] + damage_add = hp * 0.5 + damagelist7[0] += damage_add + damagelist7[1] += damage_add + damagelist7[2] += damage_add + skill_info_list.append({'name': '追加攻击', 'damagelist': damagelist7}) + + return skill_info_list + +class Fuxuan(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 1: + self.eidolon_attribute['CriticalDamageBase'] = 0.3 + + def extra_ability(self): + logger.info('符玄战技【穷观阵】属性加成') + self.extra_ability_attribute['CriticalChanceBase'] = self.Skill_num('BPSkill', 'BPSkill_CC') + self.extra_ability_attribute['HPAddedRatio'] = self.Skill_num('BPSkill', 'BPSkill_HP') + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal_HP') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + 1, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra_HP') + if self.avatar_rank >= 6: + skill_multiplier += 1.2 + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + 1, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '终结技', 'damagelist': damagelist2}) + + return skill_info_list + +class Yanqing(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 4: + self.eidolon_attribute['IceResistancePenetration'] = 0.15 + + def extra_ability(self): + logger.info('额外能力') + logger.info('触发暴击时, 速度提高10%') + self.extra_ability_attribute['SpeedAddedRatio'] = 0.1 + logger.info('【智剑连心】增益') + critical_damage_base_t = self.Skill_num('Talent', 'Talent_CD') + critical_damage_base_u = self.Skill_num('Ultra', 'Ultra_CD') + self.extra_ability_attribute['CriticalDamageBase'] = ( + critical_damage_base_t + critical_damage_base_u + ) + critical_chance_base = self.Skill_num('Talent', 'Talent_CC') + self.extra_ability_attribute['CriticalChanceBase'] = ( + critical_chance_base + 0.6 + ) + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算战技伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '战技', 'damagelist': damagelist2}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '终结技', 'damagelist': damagelist3}) + + # 计算附加伤害 + skill_multiplier = self.Skill_num('Talent', 'Talent') + if self.avatar_rank >= 1: + skill_multiplier += 0.9 + else: + skill_multiplier += 0.3 + damagelist4 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist4[2] += damage3 + skill_info_list.append({'name': '附加伤害', 'damagelist': damagelist4}) + + return skill_info_list + +class Himeko(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 1: + self.eidolon_attribute['SpeedAddedRatio'] = 0.1 + if self.avatar_rank >= 2: + self.eidolon_attribute['AllDamageAddedRatio'] = 0.15 + + def extra_ability(self): + logger.info('额外能力') + logger.info('战技对灼烧状态下的敌方目标造成的伤害提高20%。') + self.extra_ability_attribute['BPSkillDmgAdd'] = 0.2 + logger.info('若当前生命值百分比大于等于80%, 则暴击率提高15%。') + self.extra_ability_attribute['CriticalChanceBase'] = 0.15 + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算战技伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '战技', 'damagelist': damagelist2}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '终结技', 'damagelist': damagelist3}) + + # 计算追加攻击伤害 + skill_multiplier = self.Skill_num('Talent', 'Talent') + damagelist4 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist4[2] += damage3 + skill_info_list.append({'name': '追加攻击', 'damagelist': damagelist4}) + + return skill_info_list + +class Qingque(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 1: + self.eidolon_attribute['UltraDmgAdd'] = 0.1 + + def extra_ability(self): + logger.info('额外能力') + logger.info('施放强化普攻后, 青雀的速度提高10%, 持续1回合。') + self.extra_ability_attribute['SpeedAddedRatio'] = 0.1 + logger.info('默认4层战技加伤害') + all_damage_added_ratio = self.Skill_num('BPSkill', 'BPSkill') + 0.1 + self.extra_ability_attribute['AllDamageAddedRatio'] = ( + all_damage_added_ratio * 4 + ) + logger.info('默认暗杠加攻') + self.extra_ability_attribute['AttackAddedRatio'] = self.Skill_num('Talent', 'Talent') + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算杠上开花伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal1') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '杠上开花！', 'damagelist': damagelist2}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '终结技', 'damagelist': damagelist3}) + + return skill_info_list + +class Jingliu(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 1: + self.eidolon_attribute['CriticalDamageBase'] = 0.24 + if self.avatar_rank >= 2: + self.eidolon_attribute['BPSkill1DmgAdd'] = 0.8 + if self.avatar_rank >= 4: + self.eidolon_attribute['BPSkill1AttackAddedRatio'] = 0.3 + self.eidolon_attribute['UltraAttackAddedRatio'] = 0.3 + if self.avatar_rank >= 6: + self.eidolon_attribute['Ultra_CriticalDamageBase'] = 0.5 + self.eidolon_attribute['BPSkill1_CriticalDamageBase'] = 0.5 + + def extra_ability(self): + logger.info('额外能力') + logger.info('【转魄】状态下, 终结技造成的伤害提高20%。') + logger.info('【转魄】状态下, 暴击率提高。') + logger.info('【转魄】状态下, 攻击力提高。') + self.extra_ability_attribute['UltraDmgAdd'] = 0.2 + critical_chance_base = self.Skill_num('Talent', 'Talent_CC') + self.extra_ability_attribute[ + 'Ultra_CriticalChanceBase' + ] = critical_chance_base + self.extra_ability_attribute[ + 'BPSkill1_CriticalChanceBase' + ] = critical_chance_base + attack_added_ratio = self.Skill_num('Talent', 'Talent_atk') + self.extra_ability_attribute[ + 'BPSkill1AttackAddedRatio' + ] = attack_added_ratio + self.extra_ability_attribute[ + 'UltraAttackAddedRatio' + ] = attack_added_ratio + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算战技伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '战技', 'damagelist': damagelist2}) + + # 计算寒川映月伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill1') + if self.avatar_rank >= 1: + skill_multiplier += 1 + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill1', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '寒川映月', 'damagelist': damagelist3}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + if self.avatar_rank >= 1: + skill_multiplier += 1 + damagelist4 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist4[2] += damage3 + skill_info_list.append({'name': '终结技', 'damagelist': damagelist4}) + + return skill_info_list + +class Topaz(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + if self.avatar_rank >= 1: + self.eidolon_attribute['Talent_CriticalDamageBase'] = 0.5 + if self.avatar_rank >= 6: + self.eidolon_attribute['Talent1_FireResistancePenetration'] = 0.1 + + def extra_ability(self): + logger.info('额外能力') + logger.info('托帕和账账对拥有火属性弱点的敌方目标造成的伤害提高15%。') + self.extra_ability_attribute['AllDamageAddedRatio'] = 0.15 + logger.info('涨幅惊人暴击伤害提高') + self.extra_ability_attribute[ + 'Talent1_CriticalDamageBase' + ] = self.Skill_num('Ultra', 'Ultra_CD') + logger.info('【负债证明】状态,使其受到的追加攻击伤害提高') + self.extra_ability_attribute['TalentDmgAdd'] = self.Skill_num( + 'BPSkill', 'BPSkill_add' + ) + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算账账伤害 + skill_multiplier = self.Skill_num('Talent', 'Talent') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '账账', 'damagelist': damagelist2}) + + # 计算强化账账伤害 + skill_multiplier = self.Skill_num('Talent', 'Talent') + self.Skill_num('Ultra', 'Talent1') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Talent', + 'Talent1', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '强化账账', 'damagelist': damagelist3}) + + return skill_info_list + +class Guinaifen(BaseAvatar): + Buff: BaseAvatarBuff + + def __init__( + self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] + ): + super().__init__(char=char, skills=skills) + self.eidolon_attribute: Dict[str, float] = {} + self.extra_ability_attribute: Dict[str, float] = {} + self.eidolons() + self.extra_ability() + + def Technique(self): + pass + + def eidolons(self): + pass + + def extra_ability(self): + self.extra_ability_attribute['AllDamageAddedRatio'] = 0.2 + if self.avatar_rank >= 6: + self.extra_ability_attribute['DmgRatio'] = ( + self.Skill_num('Talent', 'Talent') * 4 + ) + else: + self.extra_ability_attribute['DmgRatio'] = ( + self.Skill_num('Talent', 'Talent') * 3 + ) + + async def getdamage( + self, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + damage1, damage2, damage3 = await calculate_damage( + base_attr, + attribute_bonus, + 'fujia', + 'fujia', + 'Thunder', + 0.44, + self.avatar_level, + ) + + skill_info_list = [] + # 计算普攻伤害 + skill_multiplier = self.Skill_num('Normal', 'Normal') + damagelist1 = await calculate_damage( + base_attr, + attribute_bonus, + 'Normal', + 'Normal', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist1[2] += damage3 + skill_info_list.append({'name': '普攻', 'damagelist': damagelist1}) + + # 计算战技伤害 + skill_multiplier = self.Skill_num('BPSkill', 'BPSkill') + damagelist2 = await calculate_damage( + base_attr, + attribute_bonus, + 'BPSkill', + 'BPSkill', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist2[2] += damage3 + skill_info_list.append({'name': '战技', 'damagelist': damagelist2}) + + # 计算终结技伤害 + skill_multiplier = self.Skill_num('Ultra', 'Ultra') + damagelist3 = await calculate_damage( + base_attr, + attribute_bonus, + 'Ultra', + 'Ultra', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist3[2] += damage3 + skill_info_list.append({'name': '终结技', 'damagelist': damagelist3}) + + # 计算持续伤害 + skill_multiplier = self.Skill_num('BPSkill', 'DOT') + if self.avatar_rank >= 2: + skill_multiplier += 0.4 + damagelist4 = await calculate_damage( + base_attr, + attribute_bonus, + 'DOT', + 'DOT', + self.avatar_element, + skill_multiplier, + self.avatar_level, + ) + damagelist4[2] += damage3 + skill_info_list.append({'name': '单次持续伤害', 'damagelist': damagelist4}) + + return skill_info_list + class AvatarDamage: @classmethod def create( cls, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill] ): + if char.id_ == 1210: + return Guinaifen(char, skills) + if char.id_ == 1302: + return Argenti(char, skills) + if char.id_ == 1112: + return Topaz(char, skills) + if char.id_ == 1005: + return Kafka(char, skills) + if char.id_ == 1201: + return Qingque(char, skills) + if char.id_ == 1212: + return Jingliu(char, skills) + if char.id_ == 1107: + return Clara(char, skills) + if char.id_ == 1205: + return Blade(char, skills) + if char.id_ == 1003: + return Himeko(char, skills) + if char.id_ == 1209: + return Yanqing(char, skills) if char.id_ == 1102: return Seele(char, skills) + if char.id_ == 1208: + return Fuxuan(char, skills) + if char.id_ == 1006: + return Silverwolf(char, skills) if char.id_ == 1204: return JingYuan(char, skills) if char.id_ == 1004: diff --git a/StarRailUID/starrailuid_charinfo/damage/Excel/SkillData.json b/StarRailUID/starrailuid_charinfo/damage/Excel/SkillData.json index ea2086d..c324246 100644 --- a/StarRailUID/starrailuid_charinfo/damage/Excel/SkillData.json +++ b/StarRailUID/starrailuid_charinfo/damage/Excel/SkillData.json @@ -316,7 +316,6 @@ } }, "1208": { - "Normal": [0, 0, 0, 0, 0, 0, 0, 0, 0], "Normal_HP": [ 0.2500000004656613, 0.3000000005587935, 0.3500000006519258, 0.4000000007450581, 0.4500000008381903, 0.5000000000931323, @@ -336,7 +335,6 @@ 0.120000000372529, 0.126000000372529, 0.132000000372529, 0.138000000372529, 0.144000000372529, 0.150000000372529 ], - "Ultra": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], "Ultra_HP": [ 0.600000000372529, 0.640000000372529, 0.680000000372529, 0.720000000372529, 0.760000000372529, 0.800000000372529, @@ -344,13 +342,6 @@ 1.000000000372529, 1.040000000372529, 1.080000000372529, 1.120000000372529, 1.160000000372529, 1.200000000372529 ], - "Talent": [ - 0.220000000372529, 0.242000000372529, 0.264000000372529, - 0.286000000372529, 0.308000000372529, 0.330000000372529, - 0.357500000372529, 0.385000000372529, 0.412500000372529, - 0.440000000372529, 0.462000000372529, 0.484000000372529, - 0.506000000372529, 0.528000000372529, 0.550000000372529 - ], "Maze": [20], "Ultra_Use": [135], "skillList": { @@ -573,7 +564,7 @@ "BPSkill1": [ 1.2500000005122274, 1.3750000006705523, 1.500000000828877, 1.625000000558794, 1.750000000214204, 1.875000000372529, - 0.031250000745058, 2.187500000419095, 2.343750000860302, + 2.031250000745058, 2.187500000419095, 2.343750000860302, 2.500000000232831, 2.6250000003911555, 2.75000000054948, 2.875000000707805, 3.00000000086613, 3.12500000093132 ], @@ -613,7 +604,7 @@ 0.8000000007450581, 0.9000000008381903, 1.0000000000931323, 1.1000000001862645, 1.2000000002793968, 1.3000000002793968 ], - "BPSkill": [ + "Talent": [ 0.7500000005122274, 0.8250000006705523, 0.900000000828877, 0.975000000558794, 1.050000000214204, 1.125000000372529, 1.218750000745058, 1.312500000419095, 1.406250000860302, @@ -643,6 +634,55 @@ ], "Maze": [20], "Ultra_Use": [140], + "skillList": { + "Normal": ["attack", "普攻", 1, "Talent", "Normal"], + "Talent": ["attack", "账账", 1, "Talent", "Talent"], + "Talent1": ["attack", "强化账账", 1, "Talent", "Talent"] + } + }, + "1302": { + "Normal": [ + 0.5000000004656613, 0.6000000005587935, 0.7000000006519258, + 0.8000000007450581, 0.9000000008381903, 1.0000000000931323, + 1.1000000001862645, 1.2000000002793968, 1.3000000002793968 + ], + "BPSkill": [ + 0.5500000005122274, 0.6050000002142042, 0.6600000006146729, + 0.7150000003166497, 0.7700000007171184, 0.8250000004190952, + 0.89375000144355, 0.962500001071021, 1.0312500004656613, + 1.1000000000931323, 1.154999999795109, 1.2100000001955777, + 1.2649999998975545, 1.3200000002980232, 1.375 + ], + "Ultra": [ + 1.0200000000186265, 1.0879999995231628, 1.1559999997261912, + 1.2239999999292195, 1.2920000001322478, 1.3600000003352761, + 1.4450000000651926, 1.530000000493601, 1.6150000002235174, + 1.7000000006519258, 1.7680000001564622, 1.8360000003594905, + 1.9040000005625188, 1.9720000007655472, 2.040000000037253 + ], + "Ultra1": [ + 1.6800000006332994, 1.792000000597909, 1.9040000005625188, + 2.015999999595806, 2.1279999995604157, 2.2400000002235174, + 2.3800000003539026, 2.5200000004842877, 2.660000000614673, + 2.800000000745058, 2.912000000709668, 3.023999999742955, + 3.1359999997075647, 3.2479999996721745, 3.360000000335276 + ], + "Ultra_add": [ + 0.5700000005308539, 0.6080000000074506, 0.6460000001825392, + 0.6840000003576279, 0.7220000005327165, 0.7600000007078052, + 0.80750000057742, 0.8550000004470348, 0.9025000010151416, + 0.9500000008847564, 0.9880000003613532, 1.0259999996051192, + 1.0639999997802079, 1.1019999999552965, 1.1400000001303852 + ], + "Talent": [ + 0.010000000009313226, 0.011500000255182385, 0.012999999802559614, + 0.014500000048428774, 0.015999999595806003, 0.017499999841675162, + 0.019375000149011612, 0.02125000045634806, 0.02312500006519258, + 0.0249999996740371, 0.02649999991990626, 0.027999999467283487, + 0.029499999713152647, 0.030999999959021807, 0.032500000204890966 + ], + "Maze": [20], + "Ultra_Use": [180], "skillList": { "Normal": ["attack", "普攻", 1, "Talent", "Normal"], "BPSkill": ["attack", "账账", 1, "Talent", "BPSkill"], diff --git a/StarRailUID/starrailuid_charinfo/damage/Excel/weapon_effect.json b/StarRailUID/starrailuid_charinfo/damage/Excel/weapon_effect.json index 17c1461..dd6120a 100644 --- a/StarRailUID/starrailuid_charinfo/damage/Excel/weapon_effect.json +++ b/StarRailUID/starrailuid_charinfo/damage/Excel/weapon_effect.json @@ -91,6 +91,14 @@ ] } }, + "23018": { + "Param": { + "r_dmg": [ + 0.0036000001709908247, 0.00419999985024333, 0.004800000227987766, + 0.005399999907240272, 0.005999999586492777 + ] + } + }, "20002": { "Param": { "a_dmg": [ diff --git a/StarRailUID/starrailuid_charinfo/damage/Role.py b/StarRailUID/starrailuid_charinfo/damage/Role.py index 4f56f1d..6924b65 100644 --- a/StarRailUID/starrailuid_charinfo/damage/Role.py +++ b/StarRailUID/starrailuid_charinfo/damage/Role.py @@ -1,5 +1,5 @@ from typing import Dict - +import copy from gsuid_core.logger import logger from .utils import merge_attribute @@ -13,20 +13,25 @@ async def calculate_damage( element: str, skill_multiplier: float, level: int, + is_hp = 0, ): logger.info(f'Skill Multiplier: {skill_multiplier}') logger.info(f'Skill Type: {skill_type}') logger.info(f'Level: {level}') # logger.info(f'attribute_bonus: {attribute_bonus}') - - attribute_bonus = apply_attribute_bonus( - attribute_bonus, skill_type, add_skill_type + + add_attr_bonus = copy.deepcopy(attribute_bonus) + + add_attr_bonus = apply_attribute_bonus( + add_attr_bonus, skill_type, add_skill_type ) - merged_attr = await merge_attribute(base_attr, attribute_bonus) + merged_attr = await merge_attribute(base_attr, add_attr_bonus) # logger.info(f'merged_attr: {merged_attr}') - - attack = merged_attr.get('attack', 0) + if is_hp == 1: + attack = merged_attr.get('hp', 0) + else: + attack = merged_attr.get('attack', 0) logger.info(f'Attack: {attack}') damage_reduction = calculate_damage_reduction(level) @@ -110,21 +115,21 @@ async def calculate_damage( def apply_attribute_bonus( - attribute_bonus: Dict[str, float], + add_attr_bonus: Dict[str, float], skill_type: str, add_skill_type: str, ): # Apply attribute bonuses to attack and status probability - for attr in attribute_bonus: + for attr in add_attr_bonus: if 'AttackAddedRatio' in attr and attr.split('AttackAddedRatio')[ 0 ] in (skill_type, add_skill_type): - attribute_bonus['AttackAddedRatio'] += attribute_bonus[attr] + add_attr_bonus['AttackAddedRatio'] += add_attr_bonus[attr] if 'StatusProbabilityBase' in attr and attr.split( 'StatusProbabilityBase' )[0] in (skill_type, add_skill_type): - attribute_bonus['StatusProbabilityBase'] += attribute_bonus[attr] - return attribute_bonus + add_attr_bonus['StatusProbabilityBase'] += add_attr_bonus[attr] + return add_attr_bonus def calculate_damage_reduction(level: int): diff --git a/StarRailUID/starrailuid_charinfo/damage/Weapon/Weapon.py b/StarRailUID/starrailuid_charinfo/damage/Weapon/Weapon.py index 4f74fe8..425bf6f 100644 --- a/StarRailUID/starrailuid_charinfo/damage/Weapon/Weapon.py +++ b/StarRailUID/starrailuid_charinfo/damage/Weapon/Weapon.py @@ -1,9 +1,9 @@ import json -from typing import Dict from pathlib import Path +from typing import Dict -from ..Base.WeaponBase import BaseWeapon from ..Base.model import DamageInstanceWeapon +from ..Base.WeaponBase import BaseWeapon path = Path(__file__).parent.parent with Path.open(path / 'Excel' / 'weapon_effect.json', encoding='utf-8') as f: @@ -1668,10 +1668,10 @@ class Thisbodyisasword(BaseWeapon): ) resistance_penetration = attribute_bonus.get( - 'AllResistancePenetration', 0 + 'AllDamageResistancePenetration', 0 ) attribute_bonus[ - 'AllResistancePenetration' + 'AllDamageResistancePenetration' ] = resistance_penetration + ( weapon_effect['23014']['Param']['ResistancePenetration'][ self.weapon_rank - 1 @@ -1747,11 +1747,41 @@ class WorrisomeBlissf(BaseWeapon): ) return attribute_bonus +# 片刻，留在眼底 +class AnInstanceBeforeAGaze(BaseWeapon): + weapon_base_attributes: Dict + + def __init__(self, weapon: DamageInstanceWeapon): + super().__init__(weapon) + + async def check(self): + # 当装备者施放终结技时，根据装备者的能量上限，提高装备者终结技造成的伤害：每点能量提高0.36%，最多计入180点。 + return True + + async def weapon_ability( + self, + Ultra_Use: float, + base_attr: Dict[str, float], + attribute_bonus: Dict[str, float], + ): + if await self.check(): + critical_chance_base = attribute_bonus.get('UltraDmgAdd', 0) + attribute_bonus['UltraDmgAdd'] = ( + critical_chance_base + + ( + weapon_effect['23018']['Param']['r_dmg'][ + self.weapon_rank - 1 + ] + ) + * Ultra_Use + ) + return attribute_bonus class Weapon: @classmethod def create(cls, weapon: DamageInstanceWeapon): if weapon.id_ in [ + 23018, 23011, 23007, 21005, @@ -1812,6 +1842,8 @@ class Weapon: 23014, 23016, ]: + if weapon.id_ == 23018: + return AnInstanceBeforeAGaze(weapon) if weapon.id_ == 23016: return WorrisomeBlissf(weapon) if weapon.id_ == 23012: diff --git a/StarRailUID/starrailuid_charinfo/damage/utils.py b/StarRailUID/starrailuid_charinfo/damage/utils.py index 67f569f..35482d7 100644 --- a/StarRailUID/starrailuid_charinfo/damage/utils.py +++ b/StarRailUID/starrailuid_charinfo/damage/utils.py @@ -37,3 +37,38 @@ async def merge_attribute( logger.info(f'未知的属性加成: {attribute}, 采用覆盖模式') merged_attr[attribute] = attribute_bonus[attribute] return merged_attr + +def merge_attribute_dam( + base_attr: Dict[str, float], attribute_bonus: Dict[str, float] +) -> Dict[str, float]: + merged_attr = base_attr.copy() + for attribute, value in attribute_bonus.items(): + if attribute.endswith('Delta'): + attr = attribute.split('Delta')[0].lower() + if attr in merged_attr: + merged_attr[attr] += value + else: + merged_attr[attribute] = attribute_bonus[attribute] + elif attribute.endswith('AddedRatio'): + attr = attribute.split('AddedRatio')[0].lower() + if attr in merged_attr: + merged_attr[attr] += base_attr[attr] * value + else: + merged_attr[attribute] = attribute_bonus[attribute] + elif attribute in [ + 'ignore_defence', + 'Atk_buff', + 'Normal_buff', + 'shield_added_ratio', + ]: + merged_attr[attribute] = base_attr.get(attribute, 0) + value + elif attribute.endswith( + ('ResistancePenetration', 'DmgAdd', 'DmgRatio') + ): + merged_attr[attribute] = base_attr.get(attribute, 0) + value + elif attribute.endswith('Base'): + merged_attr[attribute] = base_attr.get(attribute, 0) + value + else: + logger.info(f'未知的属性加成: {attribute}, 采用覆盖模式') + merged_attr[attribute] = attribute_bonus[attribute] + return merged_attr \ No newline at end of file diff --git a/StarRailUID/starrailuid_charinfo/draw_char_img.py b/StarRailUID/starrailuid_charinfo/draw_char_img.py index 8d7f766..d9c2a4f 100644 --- a/StarRailUID/starrailuid_charinfo/draw_char_img.py +++ b/StarRailUID/starrailuid_charinfo/draw_char_img.py @@ -3,7 +3,7 @@ import math import textwrap from pathlib import Path from typing import Dict, Union - +import copy from PIL import Image, ImageDraw from gsuid_core.logger import logger from gsuid_core.utils.image.convert import convert_img @@ -11,7 +11,7 @@ from gsuid_core.utils.image.image_tools import draw_text_by_line from .to_data import api_to_dict from ..utils.error_reply import CHAR_HINT -from .cal_damage import cal, cal_char_info +from .cal_damage import cal, cal_char_info, cal_info from ..utils.fonts.first_world import fw_font_28 from ..utils.excel.read_excel import light_cone_ranks from ..utils.map.name_covert import name_to_avatar_id, alias_to_char_name @@ -38,7 +38,7 @@ from ..utils.fonts.starrail_fonts import ( sr_font_38, ) -Excel_path = Path(__file__).parent / 'effect' +Excel_path = Path(__file__).parent / 'damage' with Path.open(Excel_path / 'Excel' / 'SkillData.json', encoding='utf-8') as f: skill_dict = json.load(f) @@ -100,8 +100,9 @@ async def draw_char_img(char_data: Dict, sr_uid: str, msg: str): char = await cal_char_info(char_data) damage_len = 0 if str(char.char_id) in skill_dict: - skill_list = skill_dict[str(char.char_id)]['skillList'] - damage_len = len(skill_list) + damage_data = copy.deepcopy(char_data) + damage_list = await cal_info(damage_data) + damage_len = len(damage_list) bg_height = 0 if damage_len > 0: bg_height = 48 * (1 + damage_len) + 48 @@ -360,7 +361,7 @@ async def draw_char_img(char_data: Dict, sr_uid: str, msg: str): weapon_bg = Image.open(TEXT_PATH / 'weapon_bg.png') weapon_id = char.equipment['equipmentID'] weapon_img = Image.open(WEAPON_PATH / f'{weapon_id}.png').resize( - (190, 180) + (170, 180) ) weapon_bg.paste(weapon_img, (20, 90), weapon_img) weapon_bg_draw = ImageDraw.Draw(weapon_bg) @@ -610,7 +611,7 @@ async def draw_char_img(char_data: Dict, sr_uid: str, msg: str): if damage_len > 0: damage_title_img = Image.open(TEXT_PATH / 'base_info_pure.png') char_info.paste(damage_title_img, (0, 2028), damage_title_img) - damage_list = await cal(char_data) + # damage_list = await cal(char_data) # 写伤害 char_img_draw.text( (55, 2048), @@ -655,12 +656,12 @@ async def draw_char_img(char_data: Dict, sr_uid: str, msg: str): ) char_img_draw.text( (55, 2048 + damage_num * 48), - f'{damage_info[0]}', + f'{damage_info["name"]}', white_color, sr_font_26, 'lm', ) - damage1 = math.floor(damage_info[1]) # type: ignore + damage1 = math.floor(damage_info['damagelist'][0]) # type: ignore char_img_draw.text( (370, 2048 + damage_num * 48), f'{damage1}', @@ -668,7 +669,7 @@ async def draw_char_img(char_data: Dict, sr_uid: str, msg: str): sr_font_26, 'lm', ) - damage2 = math.floor(damage_info[2]) # type: ignore + damage2 = math.floor(damage_info['damagelist'][1]) # type: ignore char_img_draw.text( (560, 2048 + damage_num * 48), f'{damage2}', @@ -676,7 +677,7 @@ async def draw_char_img(char_data: Dict, sr_uid: str, msg: str): sr_font_26, 'lm', ) - damage3 = math.floor(damage_info[3]) # type: ignore + damage3 = math.floor(damage_info['damagelist'][2]) # type: ignore char_img_draw.text( (750, 2048 + damage_num * 48), f'{damage3}', diff --git a/StarRailUID/utils/map/data/AvatarRelicScore.json b/StarRailUID/utils/map/data/AvatarRelicScore.json index 381f160..4820797 100644 --- a/StarRailUID/utils/map/data/AvatarRelicScore.json +++ b/StarRailUID/utils/map/data/AvatarRelicScore.json @@ -502,5 +502,41 @@ "StatusProbabilityBase": 1.0, "StatusResistanceBase": 0.0, "AttributeAddedRatio": 1 + }, + { + "role": "托帕&账账", + "HPDelta": 0.0, + "HPAddedRatio": 0.0, + "AttackDelta": 0.75, + "AttackAddedRatio": 0.75, + "DefenceDelta": 0.0, + "DefenceAddedRatio": 0.0, + "SpeedDelta": 0.75, + "CriticalChanceBase": 1, + "CriticalDamageBase": 1, + "BreakDamageAddedRatioBase": 0.0, + "HealRatio": 0, + "SPRatio": 0.5, + "StatusProbabilityBase": 0.0, + "StatusResistanceBase": 0.0, + "AttributeAddedRatio": 1 + }, + { + "role": "银枝", + "HPDelta": 0.0, + "HPAddedRatio": 0.0, + "AttackDelta": 0.75, + "AttackAddedRatio": 0.75, + "DefenceDelta": 0.0, + "DefenceAddedRatio": 0.0, + "SpeedDelta": 0.75, + "CriticalChanceBase": 1, + "CriticalDamageBase": 1, + "BreakDamageAddedRatioBase": 0.0, + "HealRatio": 0, + "SPRatio": 0.5, + "StatusProbabilityBase": 0.0, + "StatusResistanceBase": 0.0, + "AttributeAddedRatio": 1 } ] \ No newline at end of file diff --git a/StarRailUID/utils/map/data/char_alias.json b/StarRailUID/utils/map/data/char_alias.json index 27c22b7..4a8c703 100644 --- a/StarRailUID/utils/map/data/char_alias.json +++ b/StarRailUID/utils/map/data/char_alias.json @@ -113,6 +113,12 @@ "卢卡", "铁臂卢卡", "熔锤镇的卢卡" + ], + "1112": [ + "托帕&账账", + "托帕", + "账账", + "账账启动器" ], "1201": [ "青雀", @@ -160,12 +166,18 @@ "1211": [ "白露", "衔药龙女" + ], + "1212": [ + "镜流" ], "1213": [ "丹恒•饮月", "饮月君", "饮月", "龙丹" + ], + "1302": [ + "银枝" ], "8000": [ "开拓者", @@ -417,6 +429,10 @@ "23007": [ "雨一直下" ], + "23016": [ + "烦恼着，幸福着", + "烦恼着幸福着" + ], "23008": [ "棺的回响" ], @@ -438,6 +454,11 @@ ], "23015": [ "比阳光更明亮的" + ], + "23018": [ + "片刻，留在眼底", + "片刻留在眼底", + "留在眼底" ], "24000": [ "记一位星神的陨落",