Genshin-bots/StarRailUID
1
0
Fork 0
mirror of https://github.com/baiqwerdvd/StarRailUID.git synced 2025-05-07 12:43:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

完成4个丰饶角色治疗量计算，添加计算模块同协光锥

Browse Source
This commit is contained in:
a376148946 2023-10-21 16:46:05 +08:00
parent ce8c6c487d
commit 779329be43
25 changed files with 1580 additions and 5919 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
StarRailUID/starrailuid_charinfo/__init__.py
View File

@ -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, cal_info
from .cal_damage import cal_info
from .to_card import api_to_card
from ..utils.convert import get_uid
from ..utils.sr_prefix import PREFIX
@ -22,33 +22,6 @@ sv_get_char_info = SV('sr面板查询', priority=10)
sv_get_sr_original_pic = SV('sr查看面板原图', priority=5)
sv_char_damage_cal = SV('sr伤害计算')
@sv_char_damage_cal.on_prefix(f'{PREFIX}伤害计算')
async def send_damage_msg(bot: Bot, ev: Event):
msg = ''.join(re.findall('[\u4e00-\u9fa5 ]', ev.text))
if not msg:
return None
await bot.logger.info('开始执行[角色伤害计算]')
# 获取uid
sr_uid = await get_uid(bot, ev)
if sr_uid is None:
return await bot.send(UID_HINT)
await bot.logger.info(f'[角色伤害计算]uid: {sr_uid}')
char_name = ' '.join(re.findall('[\u4e00-\u9fa5]+', msg))
char_data = await get_char_data(sr_uid, char_name)
if isinstance(char_data, str):
return await bot.send(char_data)
im_list = []
im = await cal(char_data)
for info_im in im:
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
@sv_get_char_info.on_prefix(f'{PREFIX}查询')
async def send_char_info(bot: Bot, ev: Event):
im = await _get_char_info(bot, ev, ev.text)

23
StarRailUID/starrailuid_charinfo/cal_damage.py
View File

@ -1,16 +1,9 @@
import json
from pathlib import Path
from typing import Dict, List, Union
from .effect.Role import RoleInstance
from .mono.Character import Character
from .damage.Avatar import AvatarInstance
Excel_path = Path(__file__).parent / 'effect'
with Path.open(Excel_path / 'Excel' / 'SkillData.json', encoding='utf-8') as f:
skill_dict = json.load(f)
async def cal_char_info(char_data: Dict):
char: Character = Character(char_data)
await char.get_equipment_info()
@ -18,22 +11,6 @@ async def cal_char_info(char_data: Dict):
await char.get_relic_info()
return char
async def cal(char_data: Dict):
char = await cal_char_info(char_data)
skill_info_list: List[List[Union[str, float]]] = []
if str(char.char_id) in skill_dict:
skill_list = skill_dict[str(char.char_id)]['skillList']
skill_list = skill_list.keys()
for skill_type in skill_list:
role = RoleInstance(char)
im_tmp = await role.cal_damage(skill_type)
skill_info_list.append(im_tmp)
return skill_info_list
return '角色伤害计算未完成'
async def cal_info(char_data: Dict):
char = await cal_char_info(char_data)
avatar = AvatarInstance(char)

558
StarRailUID/starrailuid_charinfo/damage/AvatarDamage/AvatarDamage.py
View File

@ -3,7 +3,7 @@ from typing import Dict, List
from gsuid_core.logger import logger
from ..Role import calculate_damage
from ..Role import calculate_damage, calculate_shield, calculate_heal
from ..Base.AvatarBase import BaseAvatar, BaseAvatarBuff
from ..Base.model import DamageInstanceSkill, DamageInstanceAvatar
@ -1285,9 +1285,19 @@ class Fuxuan(BaseAvatar):
self.avatar_level,
1,
)
damagelist2[2] += damage3
damagelist2[2] += damage2
skill_info_list.append({'name': '终结技', 'damagelist': damagelist2})
# 计算终结技治疗
damagelist3 = await calculate_heal(
base_attr,
attribute_bonus,
'Ultra',
0.05,
133,
)
skill_info_list.append({'name': '终结技治疗', 'damagelist': damagelist3})
return skill_info_list
class Yanqing(BaseAvatar):
@ -1919,18 +1929,560 @@ class Guinaifen(BaseAvatar):
skill_info_list.append({'name': '单次持续伤害', 'damagelist': damagelist4})
return skill_info_list
class Gepard(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):
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')
skill_num = self.Skill_num('Ultra', 'Ultra_G')
damagelist3 = await calculate_shield(
base_attr,
attribute_bonus,
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '终结技(护盾)', 'damagelist': damagelist3})
return skill_info_list
class Luocha(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['AttackAddedRatio'] = 0.2
if self.avatar_rank >= 6:
self.eidolon_attribute['ResistancePenetration'] = 0.2
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('Ultra', 'Ultra')
damagelist2 = await calculate_damage(
base_attr,
attribute_bonus,
'Ultra',
'Ultra',
self.avatar_element,
skill_multiplier,
self.avatar_level,
)
damagelist2[2] += damage3
skill_info_list.append({'name': '终结技', 'damagelist': damagelist2})
# 计算战技治疗
skill_multiplier = self.Skill_num('BPSkill', 'BPSkill')
skill_num = self.Skill_num('BPSkill', 'BPSkill_G')
damagelist3 = await calculate_heal(
base_attr,
attribute_bonus,
'BPSkill',
skill_multiplier,
skill_num,
1,
)
skill_info_list.append({'name': '战技治疗量', 'damagelist': damagelist3})
if self.avatar_rank >= 2:
add_attr_bonus = copy.deepcopy(attribute_bonus)
add_attr_bonus['HealRatioBase'] = add_attr_bonus.get('HealRatioBase', 0) + 0.3
damagelist4 = await calculate_heal(
base_attr,
add_attr_bonus,
'BPSkill',
skill_multiplier,
skill_num,
1,
)
skill_info_list.append({'name': '战技治疗量(生命<50%)(2魂)', 'damagelist': damagelist4})
damagelist5 = await calculate_shield(
base_attr,
attribute_bonus,
0.18,
240,
1,
)
skill_info_list.append({'name': '战技护盾量(生命>50%)(2魂)', 'damagelist': damagelist5})
# 计算天赋治疗量
skill_multiplier = self.Skill_num('Talent', 'Talent')
skill_num = self.Skill_num('Talent', 'Talent_G')
damagelist6 = await calculate_heal(
base_attr,
attribute_bonus,
'BPSkill',
skill_multiplier,
skill_num,
1,
)
skill_info_list.append({'name': '天赋治疗量', 'damagelist': damagelist6})
# 计算技能树额外能力治疗量
damagelist7 = await calculate_heal(
base_attr,
attribute_bonus,
'BPSkill',
0.07,
93,
1,
)
skill_info_list.append({'name': '技能树治疗量', 'damagelist': damagelist7})
return skill_info_list
class Bailu(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['HealRatioBase'] = 0.15
if self.avatar_rank >= 4:
self.eidolon_attribute['AllDamageAddedRatio'] = 0.3
def extra_ability(self):
self.extra_ability_attribute['HPAddedRatio'] = 0.10
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')
skill_num = self.Skill_num('BPSkill', 'BPSkill_G')
damagelist2 = await calculate_heal(
base_attr,
attribute_bonus,
'BPSkill',
skill_multiplier,
skill_num,
)
heal_num = damagelist2[0]
for i in range(1, 3):
beilv = 1 - (i * 0.15)
damagelist2[0] = damagelist2[0] + heal_num * beilv
skill_info_list.append({'name': '战技治疗量', 'damagelist': damagelist2})
# 计算终结技治疗量
skill_multiplier = self.Skill_num('Ultra', 'Ultra')
skill_num = self.Skill_num('Ultra', 'Ultra_G')
damagelist3 = await calculate_heal(
base_attr,
attribute_bonus,
'Ultra',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '终结技治疗量', 'damagelist': damagelist3})
# 计算天赋生息治疗量
skill_multiplier = self.Skill_num('Talent', 'Talent')
skill_num = self.Skill_num('Talent', 'Talent_G')
damagelist4 = await calculate_heal(
base_attr,
attribute_bonus,
'Talent',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '天赋[生息]治疗量', 'damagelist': damagelist4})
# 计算天赋复活治疗量
skill_multiplier = self.Skill_num('Talent', 'Talent1')
skill_num = self.Skill_num('Talent', 'Talent1_G')
damagelist5 = await calculate_heal(
base_attr,
attribute_bonus,
'Talent',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '天赋[复活]治疗量', 'damagelist': damagelist5})
return skill_info_list
class Lynx(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['HealRatioBase'] = 0.2
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_multiplier = self.Skill_num('BPSkill', 'BPSkill_HP')
skill_num = self.Skill_num('BPSkill', 'BPSkill_HP_G')
if self.avatar_rank >= 6:
skill_multiplier += 0.06
hp = base_attr['hp'] * (1 + attribute_bonus['HPAddedRatio']) + attribute_bonus['HPDelta']
hp_add = hp * skill_multiplier + skill_num
attribute_bonus['HPDelta'] = attribute_bonus.get('HPDelta', 0) + hp_add
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('BPSkill', 'BPSkill')
skill_num = self.Skill_num('BPSkill', 'BPSkill_G')
damagelist2 = await calculate_heal(
base_attr,
attribute_bonus,
'BPSkill',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '战技治疗量', 'damagelist': damagelist2})
damagelist3 = []
damagelist3.append(hp_add)
skill_info_list.append({'name': '[求生反应]生命上限', 'damagelist': damagelist3})
# 计算终结技治疗量
skill_multiplier = self.Skill_num('Ultra', 'Ultra')
skill_num = self.Skill_num('Ultra', 'Ultra_G')
damagelist4 = await calculate_heal(
base_attr,
attribute_bonus,
'Ultra',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '终结技治疗量', 'damagelist': damagelist4})
# 计算天赋治疗量
skill_multiplier = self.Skill_num('Talent', 'Talent')
skill_num = self.Skill_num('Talent', 'Talent_G')
damagelist5 = await calculate_heal(
base_attr,
attribute_bonus,
'Talent',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '天赋缓回治疗量', 'damagelist': damagelist5})
# 计算天赋求生反应治疗量
skill_multiplier = self.Skill_num('Talent', 'Talent1') + self.Skill_num('Talent', 'Talent')
skill_num = self.Skill_num('Talent', 'Talent1_G') + self.Skill_num('Talent', 'Talent_G')
damagelist6 = await calculate_heal(
base_attr,
attribute_bonus,
'Talent',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '天赋[求生反应]缓回治疗量', 'damagelist': damagelist6})
return skill_info_list
class Natasha(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['HealRatioBase'] = 0.1 + 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
if self.avatar_rank >= 6:
damagelist_add = await calculate_damage(
base_attr,
attribute_bonus,
'Normal',
'Normal',
self.avatar_element,
0.4,
self.avatar_level,
1,
)
damagelist1[0] += damagelist_add[0]
damagelist1[1] += damagelist_add[1]
damagelist1[2] += damagelist_add[2]
skill_info_list.append({'name': '普攻', 'damagelist': damagelist1})
# 计算战技治疗
skill_multiplier = self.Skill_num('BPSkill', 'BPSkill')
skill_num = self.Skill_num('BPSkill', 'BPSkill_G')
damagelist2 = await calculate_heal(
base_attr,
attribute_bonus,
'BPSkill',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '战技治疗量', 'damagelist': damagelist2})
# 计算战技缓回治疗量
skill_multiplier = self.Skill_num('BPSkill', 'BPSkill1')
skill_num = self.Skill_num('BPSkill', 'BPSkill1_G')
damagelist3 = await calculate_heal(
base_attr,
attribute_bonus,
'BPSkill',
skill_multiplier,
skill_num,
)
skill_info_list.append({'name': '战技缓回治疗量', 'damagelist': damagelist3})
# 计算终结技治疗量
skill_multiplier = self.Skill_num('Ultra', 'Ultra')
skill_num = self.Skill_num('Ultra', 'Ultra_G')
damagelist4 = await calculate_heal(
base_attr,
attribute_bonus,
'Ultra',
skill_multiplier,
skill_num,
)
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_ == 1105:
return Natasha(char, skills)
if char.id_ == 1110:
return Lynx(char, skills)
if char.id_ == 1211:
return Bailu(char, skills)
if char.id_ == 1203:
return Luocha(char, skills)
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_ == 1104:
return Gepard(char, skills)
if char.id_ == 1005:
return Kafka(char, skills)
if char.id_ == 1201:

291
StarRailUID/starrailuid_charinfo/damage/Excel/SkillData.json
View File

@ -27,12 +27,7 @@
0.9200000008568168, 0.9600000008940697, 1
],
"Maze": [20],
"Ultra_Use": [120],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
"Ultra_Use": [120]
},
"1204": {
"Normal": [
@ -64,13 +59,7 @@
7.920000000372529, 8.250000000372529
],
"Maze": [20],
"Ultra_Use": [130],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"Talent": ["attack", "10层神君", 1, "Talent", "Talent"]
}
"Ultra_Use": [130]
},
"1107": {
"Normal": [
@ -101,13 +90,7 @@
1.840000000372529, 1.920000000372529, 2.000000000372529
],
"Maze": [20],
"Ultra_Use": [130],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Talent": ["attack", "反击", 1, "Talent", "Talent"],
"Talent1": ["attack", "强化反击", 1, "Talent", "Ultra"]
}
"Ultra_Use": [130]
},
"1213": {
"Normal": [
@ -153,14 +136,7 @@
0.115000000372529, 0.120000000372529, 0.125000000372529
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 2, "Normal", "Normal"],
"Normal1": ["attack", "瞬华", 3, "Normal", "Normal"],
"Normal2": ["attack", "天矢阴", 5, "Normal", "Normal"],
"Normal3": ["attack", "盘拏耀跃", 7, "Normal", "Normal"],
"Ultra": ["attack", "终结技", 3, "Ultra", "Ultra"]
}
"Ultra_Use": [140]
},
"1006": {
"Normal": [
@ -204,12 +180,7 @@
0.088000000372529, 0.096000000372529, 0.100000000372529
],
"Maze": [20],
"Ultra_Use": [110],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
"Ultra_Use": [110]
},
"1005": {
"Normal": [
@ -246,14 +217,7 @@
1.694000000372529, 1.792000000372529, 1.890000000372529
],
"Maze": [20],
"Ultra_Use": [110],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"DOT": ["attack", "单次持续伤害", 1, "DOT", "Ultra"],
"Talent": ["attack", "追加攻击", 1, "Talent", "Talent"]
}
"Ultra_Use": [110]
},
"1205": {
"Normal": [
@ -307,13 +271,7 @@
1.265000000372529, 1.320000000372529, 1.375000000372529
],
"Maze": [20],
"Ultra_Use": [110],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"Normal1": ["attack", "无间剑树", 1, "Normal", "Normal"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"Talent": ["attack", "追加攻击", 1, "Talent", "Talent"]
}
"Ultra_Use": [110]
},
"1208": {
"Normal_HP": [
@ -343,11 +301,7 @@
1.120000000372529, 1.160000000372529, 1.200000000372529
],
"Maze": [20],
"Ultra_Use": [135],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
"Ultra_Use": [135]
},
"1104": {
"Normal": [
@ -373,12 +327,7 @@
150, 240, 308, 375, 420, 465, 499, 533, 566, 600, 634, 668, 701, 735, 769
],
"Maze": [20],
"Ultra_Use": [110],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["defence", "终结技(护盾)", 1, "Ultra", "Ultra"]
}
"Ultra_Use": [110]
},
"1209": {
"Normal": [
@ -429,13 +378,7 @@
0.3450000008568168, 0.3600000008940697, 0.3750000008940697
],
"Maze": [20],
"Ultra_Use": [120],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"Talent": ["attack", "附加伤害", 1, "Talent", "Talent"]
}
"Ultra_Use": [120]
},
"1004": {
"Normal": [
@ -465,12 +408,7 @@
0.6900000008568168, 0.7200000008940697, 0.7500000008940697
],
"Maze": [20],
"Ultra_Use": [120],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 3, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
"Ultra_Use": [120]
},
"1003": {
"Normal": [
@ -500,13 +438,7 @@
1.6100000008568168, 1.6800000008940697, 1.7500000008940697
],
"Maze": [20],
"Ultra_Use": [120],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"Talent": ["attack", "追加攻击", 1, "Talent", "Talent"]
}
"Ultra_Use": [120]
},
"1201": {
"Normal": [
@ -541,12 +473,7 @@
0.8280000008568168, 0.8640000008940697, 0.9000000008940697
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"Normal1": ["attack", "杠上开花！", 1, "Normal", "Normal"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
"Ultra_Use": [140]
},
"1212": {
"Normal": [
@ -590,13 +517,7 @@
2.0700000008568168, 2.1600000008940697, 2.2500000008940697
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"BPSkill1": ["attack", "寒川映月", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
"Ultra_Use": [140]
},
"1112": {
"Normal": [
@ -633,12 +554,7 @@
0.30000000086613, 0.31250000093132
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 1, "Talent", "Normal"],
"Talent": ["attack", "账账", 1, "Talent", "Talent"],
"Talent1": ["attack", "强化账账", 1, "Talent", "Talent"]
}
"Ultra_Use": [140]
},
"1302": {
"Normal": [
@ -682,12 +598,7 @@
0.029499999713152647, 0.030999999959021807, 0.032500000204890966
],
"Maze": [20],
"Ultra_Use": [180],
"skillList": {
"Normal": ["attack", "普攻", 1, "Talent", "Normal"],
"BPSkill": ["attack", "账账", 1, "Talent", "BPSkill"],
"Talent1": ["attack", "强化账账", 1, "Talent", "Talent"]
}
"Ultra_Use": [180]
},
"1210": {
"Normal": [
@ -724,12 +635,168 @@
0.07899999944493175, 0.08199999993667006, 0.08499999972991645
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"DOT": ["attack", "每段灼烧", 1, "DOT", "BPSkill"]
}
"Ultra_Use": [140]
},
"1203": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000000931323, 1.2000000001862645, 1.3000000002793968
],
"BPSkill_G": [200, 320, 410, 500, 560, 620, 665, 710, 755, 800, 845, 890, 935, 980, 1025],
"BPSkill": [
0.40000000037252903, 0.42500000004656613, 0.45000000041909516,
0.47500000009313226, 0.5000000004656613, 0.5200000004842877,
0.5400000005029142, 0.5600000005215406, 0.5800000005401671,
0.6000000005587935, 0.62000000057742, 0.6400000005960464,
0.6600000006146729, 0.6800000006332994, 0.7000000006519258
],
"Ultra": [
1.2000000001862645, 1.2800000002607703, 1.3600000003352761,
1.440000000409782, 1.5200000004842877, 1.6000000005587935,
1.7000000006519258, 1.800000000745058, 1.9000000008381903,
2, 2.080000000074506, 2.1600000001490116,
2.2400000002235174, 2.3200000002980232, 2.400000000372529
],
"Talent": [
0.12000000011175871, 0.12749999994412065, 0.13499999977648258,
0.14250000030733645, 0.1500000001396984, 0.15599999972619116,
0.16200000001117587, 0.16799999959766865, 0.17399999988265336,
0.18000000016763806, 0.18599999975413084, 0.19200000003911555,
0.19799999962560833, 0.20399999991059303, 0.21000000019557774
],
"Talent_G": [60, 96, 123, 150, 168, 186, 200, 213, 227, 240, 254, 267, 281, 294, 308],
"Maze": [20],
"Ultra_Use": [100]
},
"1211": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000000931323, 1.2000000001862645, 1.3000000002793968
],
"BPSkill": [
0.07799999951384962, 0.08287500101141632, 0.08775000041350722,
0.09262500051409006, 0.09749999991618097, 0.10140000027604401,
0.10529999993741512, 0.10919999959878623, 0.11309999995864928,
0.11699999962002039, 0.12090000067837536, 0.12480000033974648,
0.1287000000011176, 0.13260000036098063, 0.13650000002235174
],
"BPSkill_G": [78, 124, 159, 195, 218, 241, 259, 276, 294, 312, 329, 347, 364, 382, 399],
"Ultra": [
0.09000000008381903, 0.09562500030733645, 0.10125000053085387,
0.10687500075437129, 0.11250000027939677, 0.11699999962002039,
0.12150000035762787, 0.12599999969825149, 0.13050000043585896,
0.13499999977648258, 0.13949999981559813, 0.14399999985471368,
0.14849999989382923, 0.15299999993294477, 0.15749999997206032
],
"Ultra_G": [90, 144, 185, 225, 252, 279, 299, 320, 340, 360, 380, 400, 420, 441, 461],
"Talent": [
0.035999999614432454, 0.038249999983236194, 0.04050000035203993,
0.04275000072084367, 0.04499999969266355, 0.04680000012740493,
0.048599999863654375, 0.05040000029839575, 0.0522000000346452,
0.05399999977089465, 0.055800000205636024, 0.05759999994188547,
0.05939999967813492, 0.061200000112876296, 0.06299999984912574
],
"Talent_G": [36, 57, 74, 90, 101, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184],
"Talent1": [
0.12000000011175871, 0.12749999994412065, 0.13499999977648258,
0.14250000030733645, 0.1500000001396984, 0.15599999972619116,
0.16200000001117587, 0.16799999959766865, 0.17399999988265336,
0.18000000016763806, 0.18599999975413084, 0.19200000003911555,
0.19799999962560833, 0.20399999991059303, 0.21000000019557774
],
"Talent1_G": [120, 192, 246, 300, 336, 372, 399, 426, 453, 480, 507, 534, 561, 588, 615],
"Maze": [20],
"Ultra_Use": [100]
},
"1110": {
"Normal_HP": [
0.2500000004656613, 0.3000000005587935, 0.3500000006519258,
0.4000000007450581, 0.4500000008381903, 0.5000000000931323,
0.5500000001862645, 0.6000000002793968, 0.6500000002793968
],
"BPSkill": [
0.0800000000745058, 0.08499999972991645, 0.09000000008381903,
0.09499999973922968, 0.10000000009313226, 0.10399999981746078,
0.1079999995417893, 0.11199999996460974, 0.11599999968893826,
0.12000000011175871, 0.12399999983608723, 0.12799999956041574,
0.1319999999832362, 0.1359999997075647, 0.14000000013038516
],
"BPSkill_G": [80, 128, 164, 200, 224, 248, 266, 284, 302, 320, 338, 356, 374, 392, 410],
"BPSkill_HP": [
0.05000000004656613, 0.05250000022351742, 0.054999999701976776,
0.057499999878928065, 0.060000000055879354, 0.06250000023283064,
0.06562500027939677, 0.0687500003259629, 0.07187500107102096,
0.07499999972060323, 0.07749999989755452, 0.0800000000745058,
0.0825000002514571, 0.08499999972991645, 0.08749999990686774
],
"BPSkill_HP_G": [50, 80, 103, 125, 140, 155, 166, 178, 189, 200, 211, 222, 234, 245, 256],
"Ultra": [
0.09000000008381903, 0.09562500030733645, 0.10125000053085387,
0.10687500075437129, 0.11250000027939677, 0.11699999962002039,
0.12150000035762787, 0.12599999969825149, 0.13050000043585896,
0.13499999977648258, 0.13949999981559813, 0.14399999985471368,
0.14849999989382923, 0.15299999993294477, 0.15749999997206032
],
"Ultra_G": [90, 144, 185, 225, 252, 279, 299, 320, 340, 360, 380, 400, 420, 441, 461],
"Talent": [
0.02399999974295497, 0.02549999998882413, 0.026999999536201358,
0.028499999782070518, 0.030000000027939677, 0.03120000008493662,
0.03240000014193356, 0.0336000001989305, 0.034800000255927444,
0.035999999614432454, 0.037199999671429396, 0.03839999972842634,
0.03959999978542328, 0.04080000054091215, 0.04199999989941716
],
"Talent_G": [24, 38, 49, 60, 67, 74, 80, 85, 91, 96, 101, 107, 112, 118, 123],
"Talent1": [
0.030000000027939677, 0.03187500103376806, 0.033750000642612576,
0.035625000251457095, 0.037499999860301614, 0.03899999940767884,
0.04050000035203993, 0.04199999989941716, 0.04350000014528632,
0.04499999969266355, 0.04649999993853271, 0.04799999948590994,
0.0494999997317791, 0.05099999997764826, 0.05250000022351742
],
"Talent1_G": [30, 48, 62, 75, 84, 93, 100, 107, 113, 120, 127, 134, 140, 147, 154],
"Maze": [20],
"Ultra_Use": [100]
},
"1105": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000000931323, 1.2000000001862645, 1.3000000002793968
],
"BPSkill": [
0.07000000006519258, 0.07437500054948032, 0.07875000033527613,
0.08312500012107193, 0.08749999990686774, 0.09100000001490116,
0.09450000012293458, 0.09799999953247607, 0.10150000033900142,
0.1049999997485429, 0.10849999985657632, 0.11199999996460974,
0.11550000007264316, 0.11899999948218465, 0.12250000028871
],
"BPSkill_G": [70, 112, 144, 175, 196, 217, 233, 249, 264, 280, 296, 312, 327, 343, 359],
"BPSkill1": [
0.04799999948590994, 0.05099999997764826, 0.05399999977089465,
0.056999999564141035, 0.060000000055879354, 0.06240000016987324,
0.06480000028386712, 0.06719999969936907, 0.06959999981336296,
0.07199999992735684, 0.07440000004135072, 0.0768000001553446,
0.07919999957084656, 0.08160000038333237, 0.08399999979883432
],
"BPSkill1_G": [48, 77, 98, 120, 134, 149, 160, 170, 181, 192, 203, 214, 224, 235, 246],
"Ultra": [
0.09199999994598329, 0.09775000042282045, 0.10350000020116568,
0.1092499999795109, 0.11499999975785613, 0.11959999985992908,
0.12419999996200204, 0.128800000064075, 0.13340000016614795,
0.13799999956972897, 0.14260000037029386, 0.14719999977387488,
0.15180000057443976, 0.1563999999780208, 0.16100000008009374
],
"Ultra_G": [92, 147, 189, 230, 258, 285, 306, 327, 247, 368, 389, 409, 430, 451, 472],
"Talent": [
0.25000000023283064, 0.27499999990686774, 0.3000000002793968,
0.32499999995343387, 0.3500000003259629, 0.375,
0.4062500004656613, 0.43750000023283064, 0.46875000069849193,
0.5000000004656613, 0.5250000001396984, 0.5500000005122274,
0.5750000001862645, 0.6000000005587935, 0.6250000002328306
],
"Maze": [20],
"Ultra_Use": [100]
}
}

86
StarRailUID/starrailuid_charinfo/damage/Excel/weapon_effect.json
View File

@ -367,6 +367,92 @@
]
}
},
"23008": {
"Param": {
"speed": [
12, 14, 16, 18, 20
]
}
},
"20019": {
"Param": {
"speed": [
12, 14, 16, 18, 20
]
}
},
"23017": {
"Param": {
"AttackAddedRatio": [
0.02399999974295497, 0.027999999467283487, 0.031999999890103936,
0.035999999614432454, 0.0400000000372529
]
}
},
"21000": {
"Param": {
"Ultra_HealRatioBase": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
]
}
},
"21014": {
"Param": {
"StatusResistance": [
0.33000000030733645, 0.3600000003352761, 0.3900000003632158,
0.4200000003911555, 0.45000000041909516
],
"HealRatioBase": [
0.1500000001396984, 0.18000000016763806, 0.21000000019557774,
0.24000000022351742, 0.2700000002514571
]
}
},
"21032": {
"Param": {
"AttackAddedRatio": [
0.10000000009313226, 0.12499999976716936, 0.1500000001396984,
0.17499999981373549, 0.20000000018626451
],
"CriticalDamage": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
]
}
},
"20005": {
"Param": {
"AttackAddedRatio": [
0.0800000000745058, 0.09000000008381903, 0.10000000009313226,
0.11000000010244548, 0.12000000011175871
]
}
},
"22001": {
"Param": {
"HealRatioBase": [
0.1600000001490116, 0.1900000001769513, 0.22000000020489097,
0.25000000023283064, 0.2800000002607703
]
}
},
"20001": {
"Param": {
"HealRatioBase": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
]
}
},
"21011": {
"Param": {
"AllDamageAddedRatio": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
]
}
},
"21010": {
"Param": {
"AllDamageAddedRatio": [

59
StarRailUID/starrailuid_charinfo/damage/Role.py
View File

@ -4,7 +4,66 @@ from gsuid_core.logger import logger
from .utils import merge_attribute
async def calculate_heal(
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
skill_type: str,
skill_multiplier: float,
skill_num: float,
is_atk = 0,
):
add_attr_bonus = copy.deepcopy(attribute_bonus)
merged_attr = await merge_attribute(base_attr, add_attr_bonus)
if is_atk == 1:
hp = merged_attr.get('attack', 0)
else:
hp = merged_attr.get('hp', 0)
logger.info(f'生命: {hp}')
# 检查是否有治疗量加成
heal_ratio_base = merged_attr.get('HealRatioBase', 0)
for attr in merged_attr:
if '_HealRatioBase' in attr and attr.split('_')[0] in (skill_type):
heal_ratio_base += merged_attr[attr]
heal_ratio = heal_ratio_base + 1
logger.info(f'治疗量加成: {heal_ratio}')
heal_num = (
hp * skill_multiplier + skill_num
) * heal_ratio
skill_info_list = [heal_num]
return skill_info_list
async def calculate_shield(
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
skill_multiplier: float,
skill_num: float,
is_atk = 0,
):
add_attr_bonus = copy.deepcopy(attribute_bonus)
merged_attr = await merge_attribute(base_attr, add_attr_bonus)
if is_atk == 1:
defence = merged_attr.get('attack', 0)
else:
defence = merged_attr.get('defence', 0)
logger.info(f'防御力: {defence}')
# 检查是否有护盾加成
shield_added_ratio = merged_attr.get('shield_added_ratio', 0)
shield_added = shield_added_ratio + 1
logger.info(f'护盾加成: {shield_added}')
defence_num = (
defence * skill_multiplier + skill_num
) * shield_added
skill_info_list = [defence_num]
return skill_info_list
async def calculate_damage(
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],

848
StarRailUID/starrailuid_charinfo/damage/Weapon/Weapon.py
View File

@ -1777,188 +1777,672 @@ class AnInstanceBeforeAGaze(BaseWeapon):
)
return attribute_bonus
# 时节不居
class TimeWaitsforNoOne(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 当装备者对我方目标提供治疗时，记录治疗量。当任意我方目标施放攻击后，根据记录治疗量的36%，对随机1个受到攻击的敌方目标造成基于装备者属性的附加伤害
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 棺的回响
class EchoesoftheCoffin(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 当装备者施放终结技后，使我方全体速度提高12点，持续1回合。
return True
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
if await self.check():
speed_delta = attribute_bonus.get('SpeedDelta', 0)
attribute_bonus['SpeedDelta'] = (
speed_delta
+ (
weapon_effect['23008']['Param']['speed'][
self.weapon_rank - 1
]
)
)
return attribute_bonus
# 惊魂夜
class NightofFright(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 当装备者为我方目标提供治疗时，使该目标的攻击力提高2.3%，该效果最多叠加5层
return True
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
if await self.check():
attack_added_ratio = attribute_bonus.get('AttackAddedRatio', 0)
attribute_bonus['AttackAddedRatio'] = (
attack_added_ratio
+ (
weapon_effect['23017']['Param']['AttackAddedRatio'][
self.weapon_rank - 1
]
)
* 5
)
return attribute_bonus
# 一场术后对话
class PostOpConversation(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 在施放终结技时治疗量提高12%。
return True
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
if await self.check():
Ultra_HealRatioBase = attribute_bonus.get('Ultra_HealRatioBase', 0)
attribute_bonus['Ultra_HealRatioBase'] = (
Ultra_HealRatioBase
+ (
weapon_effect['21000']['Param']['Ultra_HealRatioBase'][
self.weapon_rank - 1
]
)
)
return attribute_bonus
# 同一种心情
class SharedFeeling(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 在施放战技时为我方全体恢复2点能量。
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 此时恰好
class PerfectTiming(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 使装备者的治疗量提高，提高数值等同于效果抵抗的33%，最多使治疗量提高15%。
return True
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
if await self.check():
StatusResistance = attribute_bonus.get('StatusResistance', 0)
HealRatioBase_maxadd = weapon_effect['21000']['Param']['HealRatioBase'][self.weapon_rank - 1]
HealRatioBaseadd = StatusResistance * weapon_effect['21000']['Param']['StatusResistance'][self.weapon_rank - 1]
HealRatioBase = attribute_bonus.get('HealRatioBase', 0)
attribute_bonus['HealRatioBase'] = HealRatioBase + min(HealRatioBaseadd, HealRatioBase_maxadd)
return attribute_bonus
# 等价交换
class QuidProQuo(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 随机为1个当前能量百分比小于50%的我方其他目标恢复8点能量。
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 暖夜不会漫长
class WarmthShortensColdNights(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 施放普攻或战技后，为我方全体回复等同于各自生命上限2%的生命值。
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 嘿，我在这儿
class HeyOverHere(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 当装备者施放战技时，治疗量提高16%，持续2回合。
return True
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
if await self.check():
HealRatioBase = attribute_bonus.get('HealRatioBase', 0)
attribute_bonus['HealRatioBase'] = (
HealRatioBase
+ (
weapon_effect['22001']['Param']['HealRatioBase'][
self.weapon_rank - 1
]
)
)
return attribute_bonus
# 物穰
class Cornucopia(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 装备者施放战技和终结技时，治疗量提高12%。
return True
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
if await self.check():
Ultra_HealRatioBase = attribute_bonus.get('Ultra_HealRatioBase', 0)
attribute_bonus['Ultra_HealRatioBase'] = (
Ultra_HealRatioBase
+ (
weapon_effect['20001']['Param']['HealRatioBase'][
self.weapon_rank - 1
]
)
)
BPSkill_HealRatioBase = attribute_bonus.get('BPSkill_HealRatioBase', 0)
attribute_bonus['BPSkill_HealRatioBase'] = (
BPSkill_HealRatioBase
+ (
weapon_effect['20001']['Param']['HealRatioBase'][
self.weapon_rank - 1
]
)
)
return attribute_bonus
# 嘉果
class FineFruit(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 战斗开始时，立即为我方全体恢复6点能量。
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 蕃息
class Multiplication(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 战斗开始时，立即为我方全体恢复6点能量。
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 但战斗还未结束
class ButtheBattleIsnotOver(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 当装备者施放战技后，使下一个行动的我方【其他目标】造成的伤害提高30%
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 记忆中的模样
class MemoriesofthePast(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 装备者施放攻击后，额外恢复4点能量
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 与行星相会
class PlanetaryRendezvous(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 当我方目标造成与装备者相同属性的伤害时，造成的伤害提高12%。
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
all_damage_added_ratio = attribute_bonus.get('AllDamageAddedRatio', 0)
attribute_bonus['AllDamageAddedRatio'] = (
all_damage_added_ratio
+ (
weapon_effect['21011']['Param']['AllDamageAddedRatio'][
self.weapon_rank - 1
]
)
)
return attribute_bonus
# 舞！舞！舞！
class DanceDanceDance(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 当装备者施放终结技后，我方全体行动提前16%。
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 过往未来
class PastandFuture(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 使下一个行动的我方【其他目标】造成的伤害提高16%
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 镂月裁云之意
class CarvetheMoonWeavetheClouds(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 在战斗开始时以及当装备者回合开始时，随机生效1个效果
# 使我方全体攻击力提高10%
# 使我方全体暴击伤害提高12%
# 暂时固定只算攻击
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
AttackAddedRatio = attribute_bonus.get('AttackAddedRatio', 0)
attribute_bonus['AttackAddedRatio'] = (
AttackAddedRatio
+ (
weapon_effect['21032']['Param']['AttackAddedRatio'][
self.weapon_rank - 1
]
)
)
return attribute_bonus
# 齐颂
class Chorus(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 进入战斗后，使我方全体的攻击力提高8%
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
AttackAddedRatio = attribute_bonus.get('AttackAddedRatio', 0)
attribute_bonus['AttackAddedRatio'] = (
AttackAddedRatio
+ (
weapon_effect['20005']['Param']['AttackAddedRatio'][
self.weapon_rank - 1
]
)
)
return attribute_bonus
# 轮契
class MeshingCogs(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 使装备者施放攻击或受到攻击后，额外恢复4点能量
pass
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
return attribute_bonus
# 调和
class Mediation(BaseWeapon):
weapon_base_attributes: Dict
def __init__(self, weapon: DamageInstanceWeapon):
super().__init__(weapon)
async def check(self):
# 当装备者施放终结技后，使我方全体速度提高12点，持续1回合。
return True
async def weapon_ability(
self,
Ultra_Use: float,
base_attr: Dict[str, float],
attribute_bonus: Dict[str, float],
):
if await self.check():
speed_delta = attribute_bonus.get('SpeedDelta', 0)
attribute_bonus['SpeedDelta'] = (
speed_delta
+ (
weapon_effect['20019']['Param']['speed'][
self.weapon_rank - 1
]
)
)
return attribute_bonus
class Weapon:
@classmethod
def create(cls, weapon: DamageInstanceWeapon):
if weapon.id_ in [
23018,
23011,
23007,
21005,
21019,
21026,
21033,
24000,
23002,
23009,
23015,
21012,
21006,
21013,
21027,
21020,
21034,
23000,
23010,
23001,
21003,
23012,
24001,
21024,
21017,
20014,
20007,
21010,
21031,
20000,
23006,
23004,
24003,
22000,
21029,
21022,
21015,
21008,
21001,
23005,
24002,
21030,
21023,
21016,
21009,
21002,
20017,
20010,
20003,
20016,
20009,
20002,
20018,
20011,
20004,
20020,
20013,
20006,
23014,
23016,
]:
if weapon.id_ == 23018:
return AnInstanceBeforeAGaze(weapon)
if weapon.id_ == 23016:
return WorrisomeBlissf(weapon)
if weapon.id_ == 23012:
return SleepLiketheDead(weapon)
if weapon.id_ == 23014:
return Thisbodyisasword(weapon)
if weapon.id_ == 20006:
return DataBank(weapon)
if weapon.id_ == 20013:
return Passkey(weapon)
if weapon.id_ == 20020:
return Sagacity(weapon)
if weapon.id_ == 20004:
return Void(weapon)
if weapon.id_ == 20011:
return Loop(weapon)
if weapon.id_ == 20018:
return HiddenShadow(weapon)
if weapon.id_ == 20002:
return CollapsingSky(weapon)
if weapon.id_ == 20009:
return ShatteredHome(weapon)
if weapon.id_ == 20016:
return MutualDemise(weapon)
if weapon.id_ == 20003:
return Amber(weapon)
if weapon.id_ == 20010:
return Defense(weapon)
if weapon.id_ == 20017:
return Pioneering(weapon)
if weapon.id_ == 21002:
return DayOneofMyNewLife(weapon)
if weapon.id_ == 21009:
return LandausChoice(weapon)
if weapon.id_ == 21016:
return TrendoftheUniversalMarket(weapon)
if weapon.id_ == 21023:
return WeAreWildfire(weapon)
if weapon.id_ == 21030:
return ThisIsMe(weapon)
if weapon.id_ == 24002:
return TextureofMemories(weapon)
if weapon.id_ == 23005:
return MomentofVictory(weapon)
if weapon.id_ == 23011:
return SheAlreadyShutHerEyes(weapon)
if weapon.id_ == 21001:
return GoodNightandSleepWell(weapon)
if weapon.id_ == 21008:
return EyesofthePrey(weapon)
if weapon.id_ == 21015:
return ResolutionShinesAsPearlsofSweat(weapon)
if weapon.id_ == 21022:
return Fermata(weapon)
if weapon.id_ == 21029:
return WeWillMeetAgain(weapon)
if weapon.id_ == 22000:
return BeforetheTutorialMissionStarts(weapon)
if weapon.id_ == 24003:
return SolitaryHealing(weapon)
if weapon.id_ == 23004:
return IntheNameoftheWorld(weapon)
if weapon.id_ == 23006:
return PatienceIsAllYouNeed(weapon)
if weapon.id_ == 23007:
return IncessantRain(weapon)
if weapon.id_ == 21005:
return TheMolesWelcomeYou(weapon)
if weapon.id_ == 21019:
return UndertheBlueSky(weapon)
if weapon.id_ == 21026:
return WoofWalkTime(weapon)
if weapon.id_ == 21033:
return NowheretoRun(weapon)
if weapon.id_ == 24000:
return OntheFallofanAeon(weapon)
if weapon.id_ == 23002:
return SomethingIrreplaceable(weapon)
if weapon.id_ == 23009:
return TheUnreachableSide(weapon)
if weapon.id_ == 23015:
return BrighterThantheSun(weapon)
if weapon.id_ == 21012:
return ASecretVow(weapon)
if weapon.id_ == 21006:
return TheBirthoftheSelf(weapon)
if weapon.id_ == 21013:
return MaketheWorldClamor(weapon)
if weapon.id_ == 21020:
return GeniusesRepose(weapon)
if weapon.id_ == 21027:
return SeriousnessofBreakfast(weapon)
if weapon.id_ == 21034:
return TodayIsAnotherPeacefulDay(weapon)
if weapon.id_ == 23000:
return NightontheMilkyWay(weapon)
if weapon.id_ == 23010:
return BeforeDawn(weapon)
if weapon.id_ == 24001:
return CruisingintheStellarSea(weapon)
if weapon.id_ == 23001:
return IntheNight(weapon)
if weapon.id_ == 21003:
return OnlySilenceRemains(weapon)
if weapon.id_ == 21024:
return RiverFlowsinSpring(weapon)
if weapon.id_ == 20014:
return Adversarial(weapon)
if weapon.id_ == 20007:
return DartingArrow(weapon)
if weapon.id_ == 21010:
return Swordplay(weapon)
if weapon.id_ == 21031:
return ReturntoDarkness(weapon)
if weapon.id_ == 20000:
return Arrows(weapon)
raise ValueError(f'未知武器id: {weapon.id_}')
raise ValueError(f'不支持的武器种类: {weapon.id_}')
if weapon.id_ == 20019:
return Mediation(weapon)
if weapon.id_ == 20012:
return MeshingCogs(weapon)
if weapon.id_ == 20005:
return Chorus(weapon)
if weapon.id_ == 21032:
return CarvetheMoonWeavetheClouds(weapon)
if weapon.id_ == 21025:
return PastandFuture(weapon)
if weapon.id_ == 21018:
return DanceDanceDance(weapon)
if weapon.id_ == 21011:
return PlanetaryRendezvous(weapon)
if weapon.id_ == 21004:
return MemoriesofthePast(weapon)
if weapon.id_ == 23003:
return ButtheBattleIsnotOver(weapon)
if weapon.id_ == 20015:
return Multiplication(weapon)
if weapon.id_ == 20008:
return FineFruit(weapon)
if weapon.id_ == 20001:
return Cornucopia(weapon)
if weapon.id_ == 22001:
return HeyOverHere(weapon)
if weapon.id_ == 21028:
return WarmthShortensColdNights(weapon)
if weapon.id_ == 21021:
return QuidProQuo(weapon)
if weapon.id_ == 21014:
return PerfectTiming(weapon)
if weapon.id_ == 21007:
return SharedFeeling(weapon)
if weapon.id_ == 21000:
return PostOpConversation(weapon)
if weapon.id_ == 23017:
return NightofFright(weapon)
if weapon.id_ == 23008:
return EchoesoftheCoffin(weapon)
if weapon.id_ == 23013:
return TimeWaitsforNoOne(weapon)
if weapon.id_ == 23018:
return AnInstanceBeforeAGaze(weapon)
if weapon.id_ == 23016:
return WorrisomeBlissf(weapon)
if weapon.id_ == 23012:
return SleepLiketheDead(weapon)
if weapon.id_ == 23014:
return Thisbodyisasword(weapon)
if weapon.id_ == 20006:
return DataBank(weapon)
if weapon.id_ == 20013:
return Passkey(weapon)
if weapon.id_ == 20020:
return Sagacity(weapon)
if weapon.id_ == 20004:
return Void(weapon)
if weapon.id_ == 20011:
return Loop(weapon)
if weapon.id_ == 20018:
return HiddenShadow(weapon)
if weapon.id_ == 20002:
return CollapsingSky(weapon)
if weapon.id_ == 20009:
return ShatteredHome(weapon)
if weapon.id_ == 20016:
return MutualDemise(weapon)
if weapon.id_ == 20003:
return Amber(weapon)
if weapon.id_ == 20010:
return Defense(weapon)
if weapon.id_ == 20017:
return Pioneering(weapon)
if weapon.id_ == 21002:
return DayOneofMyNewLife(weapon)
if weapon.id_ == 21009:
return LandausChoice(weapon)
if weapon.id_ == 21016:
return TrendoftheUniversalMarket(weapon)
if weapon.id_ == 21023:
return WeAreWildfire(weapon)
if weapon.id_ == 21030:
return ThisIsMe(weapon)
if weapon.id_ == 24002:
return TextureofMemories(weapon)
if weapon.id_ == 23005:
return MomentofVictory(weapon)
if weapon.id_ == 23011:
return SheAlreadyShutHerEyes(weapon)
if weapon.id_ == 21001:
return GoodNightandSleepWell(weapon)
if weapon.id_ == 21008:
return EyesofthePrey(weapon)
if weapon.id_ == 21015:
return ResolutionShinesAsPearlsofSweat(weapon)
if weapon.id_ == 21022:
return Fermata(weapon)
if weapon.id_ == 21029:
return WeWillMeetAgain(weapon)
if weapon.id_ == 22000:
return BeforetheTutorialMissionStarts(weapon)
if weapon.id_ == 24003:
return SolitaryHealing(weapon)
if weapon.id_ == 23004:
return IntheNameoftheWorld(weapon)
if weapon.id_ == 23006:
return PatienceIsAllYouNeed(weapon)
if weapon.id_ == 23007:
return IncessantRain(weapon)
if weapon.id_ == 21005:
return TheMolesWelcomeYou(weapon)
if weapon.id_ == 21019:
return UndertheBlueSky(weapon)
if weapon.id_ == 21026:
return WoofWalkTime(weapon)
if weapon.id_ == 21033:
return NowheretoRun(weapon)
if weapon.id_ == 24000:
return OntheFallofanAeon(weapon)
if weapon.id_ == 23002:
return SomethingIrreplaceable(weapon)
if weapon.id_ == 23009:
return TheUnreachableSide(weapon)
if weapon.id_ == 23015:
return BrighterThantheSun(weapon)
if weapon.id_ == 21012:
return ASecretVow(weapon)
if weapon.id_ == 21006:
return TheBirthoftheSelf(weapon)
if weapon.id_ == 21013:
return MaketheWorldClamor(weapon)
if weapon.id_ == 21020:
return GeniusesRepose(weapon)
if weapon.id_ == 21027:
return SeriousnessofBreakfast(weapon)
if weapon.id_ == 21034:
return TodayIsAnotherPeacefulDay(weapon)
if weapon.id_ == 23000:
return NightontheMilkyWay(weapon)
if weapon.id_ == 23010:
return BeforeDawn(weapon)
if weapon.id_ == 24001:
return CruisingintheStellarSea(weapon)
if weapon.id_ == 23001:
return IntheNight(weapon)
if weapon.id_ == 21003:
return OnlySilenceRemains(weapon)
if weapon.id_ == 21024:
return RiverFlowsinSpring(weapon)
if weapon.id_ == 20014:
return Adversarial(weapon)
if weapon.id_ == 20007:
return DartingArrow(weapon)
if weapon.id_ == 21010:
return Swordplay(weapon)
if weapon.id_ == 21031:
return ReturntoDarkness(weapon)
if weapon.id_ == 20000:
return Arrows(weapon)
raise ValueError(f'未知武器id: {weapon.id_}')

35
StarRailUID/starrailuid_charinfo/damage/utils.py
View File

@ -37,38 +37,3 @@ 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

58
StarRailUID/starrailuid_charinfo/draw_char_img.py
View File

@ -661,30 +661,40 @@ async def draw_char_img(char_data: Dict, sr_uid: str, msg: str):
sr_font_26,
'lm',
)
damage1 = math.floor(damage_info['damagelist'][0]) # type: ignore
char_img_draw.text(
(370, 2048 + damage_num * 48),
f'{damage1}',
white_color,
sr_font_26,
'lm',
)
damage2 = math.floor(damage_info['damagelist'][1]) # type: ignore
char_img_draw.text(
(560, 2048 + damage_num * 48),
f'{damage2}',
white_color,
sr_font_26,
'lm',
)
damage3 = math.floor(damage_info['damagelist'][2]) # type: ignore
char_img_draw.text(
(750, 2048 + damage_num * 48),
f'{damage3}',
white_color,
sr_font_26,
'lm',
)
if len(damage_info['damagelist']) == 3:
damage1 = math.floor(damage_info['damagelist'][0]) # type: ignore
char_img_draw.text(
(370, 2048 + damage_num * 48),
f'{damage1}',
white_color,
sr_font_26,
'lm',
)
damage2 = math.floor(damage_info['damagelist'][1]) # type: ignore
char_img_draw.text(
(560, 2048 + damage_num * 48),
f'{damage2}',
white_color,
sr_font_26,
'lm',
)
damage3 = math.floor(damage_info['damagelist'][2]) # type: ignore
char_img_draw.text(
(750, 2048 + damage_num * 48),
f'{damage3}',
white_color,
sr_font_26,
'lm',
)
else:
damage = math.floor(damage_info['damagelist'][0]) # type: ignore
char_img_draw.text(
(560, 2048 + damage_num * 48),
f'{damage}',
white_color,
sr_font_26,
'lm',
)
if char_change == 1:
char_img_draw.text(

562
StarRailUID/starrailuid_charinfo/effect/Avatar/Avatar.py
View File

@ -1,562 +0,0 @@
from typing import Dict, List
from gsuid_core.logger import logger
from ..Base.AvatarBase import BaseAvatar, BaseAvatarBuff
from ..Base.model import DamageInstanceSkill, DamageInstanceAvatar
class Seele(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['SpeedAddedRatio'] = 0.25
if self.avatar_rank >= 1:
self.eidolon_attribute['CriticalChanceBase'] = 0.15
if self.avatar_rank >= 2:
self.eidolon_attribute['SpeedAddedRatio'] = 0.5
def extra_ability(self):
# 额外能力 割裂 抗性穿透提高20
self.extra_ability_attribute['QuantumResistancePenetration'] = 0.2
class JingYuan(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['NormalDmgAdd'] = 0.2
self.eidolon_attribute['BPSkillDmgAdd'] = 0.2
self.eidolon_attribute['UltraDmgAdd'] = 0.2
if self.avatar_rank >= 6:
self.eidolon_attribute['Talent_DmgRatio'] = 0.288
def extra_ability(self):
logger.info('额外能力')
logger.info('【神君】下回合的攻击段数大于等于6段, 则其下回合的暴击伤害提高25%。')
self.extra_ability_attribute['CriticalDamageBase'] = 0.25
logger.info('施放战技后, 暴击率提升10%')
self.extra_ability_attribute['CriticalChanceBase'] = 0.1
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['Talent1SkillAdd'] = self.Skill_num(
'Talent', 'Talent'
)
self.extra_ability_attribute['TalentDmgAdd'] = 0.3
self.extra_ability_attribute['UltraDmgAdd'] = 0.3
class Danhengil(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['Atk_buff'] = 1
if self.avatar_rank >= 4:
self.eidolon_attribute['Normal_buff'] = 4
if self.avatar_rank >= 6:
self.extra_ability_attribute[
'Normal3_ImaginaryResistancePenetration'
] = 0.6
def extra_ability(self):
logger.info('额外能力')
logger.info('对拥有虚数属性弱点的敌方目标造成伤害时, 暴击伤害提高24%。')
self.extra_ability_attribute['CriticalDamageBase'] = 0.24
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 >= 4:
self.extra_ability_attribute['UltraSkillAdd'] = 1
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.BPSkill_num('BPSkill_D') + 0.03
self.extra_ability_attribute[
'QuantumResistancePenetration'
] = enemy_status_resistance
logger.info('终结技降防')
ultra_defence = self.Ultra_num('Ultra_D')
logger.info('天赋降防')
talent_defence = self.Talent()
ignore_defence = ultra_defence + talent_defence
self.extra_ability_attribute['ignore_defence'] = ignore_defence
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
if self.avatar_rank >= 6:
self.extra_ability_attribute['DOTSkillAdd'] = 1.56
def extra_ability(self):
pass
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 >= 1:
self.eidolon_attribute['UltraHpSkillAdd'] = 0.9
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
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
if self.avatar_rank >= 6:
self.eidolon_attribute['UltraHpSkillAdd'] = 1.2
def extra_ability(self):
logger.info('符玄战技【穷观阵】属性加成')
self.extra_ability_attribute['CriticalChanceBase'] = self.BPSkill_num(
'BPSkill_CC'
)
self.extra_ability_attribute['HPAddedRatio'] = self.BPSkill_num(
'BPSkill_HP'
)
class Gepard(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):
pass
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):
self.eidolon_attribute['TalentSkillAdd'] = 0.3
if self.avatar_rank >= 1:
self.eidolon_attribute['TalentSkillAdd'] = 0.9
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.Talent_num('Talent_CD')
critical_damage_base_u = self.Ultra_num('Ultra_CD')
self.extra_ability_attribute['CriticalDamageBase'] = (
critical_damage_base_t + critical_damage_base_u
)
critical_chance_base = self.Talent_num('Talent_CC')
self.extra_ability_attribute['CriticalChanceBase'] = (
critical_chance_base + 0.6
)
class Welt(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['NormalSkillAdd'] = (
self.Skill_num('Normal', 'Normal') * 0.5
)
self.eidolon_attribute['BPSkillSkillAdd'] = (
self.Skill_num('BPSkill', 'BPSkill') * 0.8
)
def extra_ability(self):
logger.info('额外能力')
logger.info('施放终结技时, 有100%基础概率使目标受到的伤害提高12%, 持续2回合。')
logger.info('对被弱点击破的敌方目标造成的伤害提高20')
self.extra_ability_attribute['AllDamageAddedRatio'] = 0.32
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
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.BPSkill() + 0.1
self.extra_ability_attribute['AllDamageAddedRatio'] = (
all_damage_added_ratio * 4
)
logger.info('默认暗杠加攻')
self.extra_ability_attribute['AttackAddedRatio'] = self.Talent()
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
self.extra_ability_attribute['UltraSkillAdd'] = 1
self.extra_ability_attribute['BPSkill1SkillAdd'] = 1
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.Talent_num('Talent_CC')
self.extra_ability_attribute[
'Ultra_CriticalChanceBase'
] = critical_chance_base
self.extra_ability_attribute[
'BPSkill1_CriticalChanceBase'
] = critical_chance_base
attack_added_ratio = self.Talent_num('Talent_atk')
self.extra_ability_attribute[
'BPSkill1AttackAddedRatio'
] = attack_added_ratio
self.extra_ability_attribute[
'UltraAttackAddedRatio'
] = attack_added_ratio
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):
self.extra_ability_attribute['Talent1SkillAdd'] = self.Skill_num(
'Ultra', 'Talent1'
)
logger.info('额外能力')
logger.info('托帕和账账对拥有火属性弱点的敌方目标造成的伤害提高15%。')
self.extra_ability_attribute['AllDamageAddedRatio'] = 0.15
logger.info('涨幅惊人暴击伤害提高')
self.extra_ability_attribute[
'Talent1_CriticalDamageBase'
] = self.Ultra_num('Ultra_CD')
logger.info('【负债证明】状态,使其受到的追加攻击伤害提高')
self.extra_ability_attribute['TalentDmgAdd'] = self.BPSkill_num(
'BPSkill_add'
)
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):
if self.avatar_rank >= 2:
self.eidolon_attribute['DOTSkillAdd'] = 0.4
def extra_ability(self):
self.extra_ability_attribute['AllDamageAddedRatio'] = 0.2
if self.avatar_rank >= 6:
self.extra_ability_attribute['DmgRatio'] = (
self.Talent_num('Talent') * 4
)
else:
self.extra_ability_attribute['DmgRatio'] = (
self.Talent_num('Talent') * 3
)
class Avatar:
@classmethod
def create(
cls, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill]
):
if char.id_ == 1112:
return Topaz(char, skills)
if char.id_ == 1212:
return Jingliu(char, skills)
if char.id_ == 1201:
return Qingque(char, skills)
if char.id_ == 1003:
return Himeko(char, skills)
if char.id_ == 1004:
return Welt(char, skills)
if char.id_ == 1209:
return Yanqing(char, skills)
if char.id_ == 1104:
return Gepard(char, skills)
if char.id_ == 1208:
return Fuxuan(char, skills)
if char.id_ == 1205:
return Blade(char, skills)
if char.id_ == 1005:
return Kafka(char, skills)
if char.id_ == 1006:
return Silverwolf(char, skills)
if char.id_ == 1213:
return Danhengil(char, skills)
if char.id_ == 1102:
return Seele(char, skills)
if char.id_ == 1204:
return JingYuan(char, skills)
if char.id_ == 1107:
return Clara(char, skills)
if char.id_ == 1210:
return Guinaifen(char, skills)
raise Exception('不支持的角色')

0
StarRailUID/starrailuid_charinfo/effect/Avatar/__init__.py
View File

195
StarRailUID/starrailuid_charinfo/effect/Base/AvatarBase.py
View File

@ -1,195 +0,0 @@
import json
from pathlib import Path
from abc import abstractmethod
from typing import List, Union
import msgspec
from msgspec import Struct
from .SkillBase import BaseSkills
from ....utils.excel.model import AvatarPromotionConfig
from .model import DamageInstanceSkill, DamageInstanceAvatar
path = Path(__file__).parent.parent
with Path.open(path / 'Excel' / 'SkillData.json', encoding='utf-8') as f:
skill_dict = json.load(f)
class BaseAvatarAttribute(Struct):
attack: float
defence: float
hp: float
speed: float
CriticalChanceBase: float
CriticalDamageBase: float
BaseAggro: float
def items(self):
return [
('attack', self.attack),
('defence', self.defence),
('hp', self.hp),
('speed', self.speed),
('CriticalChanceBase', self.CriticalChanceBase),
('CriticalDamageBase', self.CriticalDamageBase),
('BaseAggro', self.BaseAggro),
]
class BaseAvatarBuff:
@classmethod
def create(
cls, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill]
):
cls.extra_ability_id = []
if char.extra_ability:
for extra_ability in char.extra_ability:
cls.extra_ability_id.append(extra_ability['extraAbilityId'])
return cls
@abstractmethod
async def Technique(self):
...
@abstractmethod
async def eidolons(self):
...
@abstractmethod
async def extra_ability(self):
...
class BaseAvatar:
def __init__(
self, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill]
):
self.Skill = BaseSkills.create(char=char, skills=skills)
self.Buff = BaseAvatarBuff.create(char=char, skills=skills)
self.avatar_id = char.id_
self.avatar_level = char.level
self.avatar_rank = char.rank
self.avatar_element = char.element
self.avatar_promotion = char.promotion
self.avatar_attribute_bonus = char.attribute_bonus
self.avatar_extra_ability = char.extra_ability
self.avatar_attribute = self.get_attribute()
def get_attribute(self):
promotion = AvatarPromotionConfig.Avatar[str(self.avatar_id)][
str(self.avatar_promotion)
]
return BaseAvatarAttribute(
# 攻击力
attack=(
promotion.AttackBase.Value
+ promotion.AttackAdd.Value * (self.avatar_level - 1)
),
# 防御力
defence=(
promotion.DefenceBase.Value
+ promotion.DefenceAdd.Value * (self.avatar_level - 1)
),
# 血量
hp=(
promotion.HPBase.Value
+ promotion.HPAdd.Value * (self.avatar_level - 1)
),
# 速度
speed=promotion.SpeedBase.Value,
# 暴击率
CriticalChanceBase=promotion.CriticalChance.Value,
# 暴击伤害
CriticalDamageBase=promotion.CriticalDamage.Value,
# 嘲讽
BaseAggro=promotion.BaseAggro.Value,
)
def Skill_Info(self, skill_type: str):
skill_info = skill_dict[str(self.avatar_id)]['skillList'][skill_type]
return msgspec.convert(skill_info, type=List[Union[str, int]])
def Skill_num(self, skill: Union[str, int], skill_type: str):
skill_level = 0
if skill == 'Normal':
skill_level = self.Skill.Normal_.level - 1
if skill == 'BPSkill':
skill_level = self.Skill.BPSkill_.level - 1
if skill == 'Ultra':
skill_level = self.Skill.Ultra_.level - 1
if skill == 'Talent':
skill_level = self.Skill.Talent_.level - 1
skill_info = skill_dict[str(self.avatar_id)][skill_type][skill_level]
return msgspec.convert(skill_info, type=float)
def Normalnum(self, skill_type: str):
skill_info = skill_dict[str(self.avatar_id)][skill_type][
self.Skill.Normal_.level - 1
]
return msgspec.convert(skill_info, type=float)
def Normal(self):
skill_info = skill_dict[str(self.avatar_id)]['Normal'][
self.Skill.Normal_.level - 1
]
return msgspec.convert(skill_info, type=float)
def BPSkill(self):
skill_info = skill_dict[str(self.avatar_id)]['BPSkill'][
self.Skill.BPSkill_.level - 1
]
return msgspec.convert(skill_info, type=float)
def Ultra(self):
skill_info = skill_dict[str(self.avatar_id)]['Ultra'][
self.Skill.Ultra_.level - 1
]
return msgspec.convert(skill_info, type=float)
def Maze(self):
skill_info = skill_dict[str(self.avatar_id)]['Maze'][
self.Skill.Maze_.level - 1
]
return msgspec.convert(skill_info, type=float)
def Talent(self):
skill_info = skill_dict[str(self.avatar_id)]['Talent'][
self.Skill.Talent_.level - 1
]
return msgspec.convert(skill_info, type=float)
def BPSkill_num(self, skill_type: str):
skill_info = skill_dict[str(self.avatar_id)][skill_type][
self.Skill.BPSkill_.level - 1
]
return msgspec.convert(skill_info, type=float)
def Ultra_num(self, skill_type: str):
skill_info = skill_dict[str(self.avatar_id)][skill_type][
self.Skill.Ultra_.level - 1
]
return msgspec.convert(skill_info, type=float)
def Talent_num(self, skill_type: str):
skill_info = skill_dict[str(self.avatar_id)][skill_type][
self.Skill.Talent_.level - 1
]
return msgspec.convert(skill_info, type=float)
def Talent_add(self):
if self.avatar_id in [1102]:
skill_info = skill_dict[str(self.avatar_id)]['Talent'][
self.Skill.Talent_.level - 1
]
return msgspec.convert(skill_info, type=float)
if self.avatar_id in [1205]:
skill_info = skill_dict[str(self.avatar_id)]['BPSkill'][
self.Skill.BPSkill_.level - 1
]
return msgspec.convert(skill_info, type=float)
return 0.0
def Ultra_Use(self):
skill_info = skill_dict[str(self.avatar_id)]['Ultra_Use'][0]
return msgspec.convert(skill_info, type=float)

93
StarRailUID/starrailuid_charinfo/effect/Base/RelicBase.py
View File

@ -1,93 +0,0 @@
from typing import Dict
from abc import abstractmethod
from gsuid_core.logger import logger
from .model import DamageInstanceRelic
from ....utils.map.SR_MAP_PATH import RelicSetSkill
class SingleRelic:
def __init__(self, relic: DamageInstanceRelic):
self.raw_relic = relic
self.relic_id = relic.relicId
self.set_id = relic.SetId
self.relic_type = relic.Type
self.relic_level = relic.Level
self.relic_attribute_bonus: Dict[str, float] = {}
def get_attribute_(self):
# MainAffix
if self.raw_relic.MainAffix.Property in self.relic_attribute_bonus:
self.relic_attribute_bonus[
self.raw_relic.MainAffix.Property
] += self.raw_relic.MainAffix.Value
else:
self.relic_attribute_bonus[
self.raw_relic.MainAffix.Property
] = self.raw_relic.MainAffix.Value
# SubAffix
if self.raw_relic.SubAffixList:
for sub_affix in self.raw_relic.SubAffixList:
sub_affix_property = sub_affix.Property
value = sub_affix.Value
if sub_affix_property in self.relic_attribute_bonus:
self.relic_attribute_bonus[sub_affix_property] += value
else:
self.relic_attribute_bonus[sub_affix_property] = value
class BaseRelicSetSkill:
setId: int
pieces2: bool = False
pieces4: bool = False
def __init__(self, set_id: int, count: int):
self.setId = set_id
if count >= 2:
self.pieces2 = True
logger.info(f'Relic {set_id} 2 pieces set activated')
if count == 4:
self.pieces4 = True
logger.info(f'Relic {set_id} 4 pieces set activated')
self.relicSetAttribute = self.set_skill_property_ability()
@abstractmethod
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
...
@abstractmethod
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
战斗加成属性, 与 set_skill_property() 互斥
"""
...
def set_skill_property_ability(self):
set_property = ''
set_value = 0
relic_set_attribute: Dict[str, float] = {}
if self.pieces2:
status_add = RelicSetSkill.RelicSet[str(self.setId)]['2']
if status_add:
set_property = status_add.Property
set_value = status_add.Value
if set_property != '':
relic_set_attribute[set_property] = (
relic_set_attribute.get(set_property, 0) + set_value
)
if self.pieces4:
status_add = RelicSetSkill.RelicSet[str(self.setId)]['4']
if status_add:
set_property = status_add.Property
set_value = status_add.Value
if set_property != '':
relic_set_attribute[set_property] = (
relic_set_attribute.get(set_property, 0) + set_value
)
return relic_set_attribute

45
StarRailUID/starrailuid_charinfo/effect/Base/SkillBase.py
View File

@ -1,45 +0,0 @@
import json
from typing import List
from pathlib import Path
from .model import DamageInstanceSkill, DamageInstanceAvatar
path = Path(__file__).parent.parent
with Path.open(path / 'Excel' / 'SkillData.json', encoding='utf-8') as f:
skill_dict = json.load(f)
class SingleSkill:
def __init__(self, skill: DamageInstanceSkill):
self.id = skill.skillId
self.level = skill.skillLevel
class BaseSkills:
Normal_: SingleSkill
BPSkill_: SingleSkill
Ultra_: SingleSkill
Maze_: SingleSkill
Talent_: SingleSkill
@classmethod
def create(
cls, char: DamageInstanceAvatar, skills: List[DamageInstanceSkill]
):
for skill in skills:
skill_attack_type = skill.skillAttackType
if skill_attack_type == 'Normal':
cls.Normal_ = SingleSkill(skill)
elif skill_attack_type == 'BPSkill':
cls.BPSkill_ = SingleSkill(skill)
elif skill_attack_type == 'Ultra':
cls.Ultra_ = SingleSkill(skill)
elif skill_attack_type == 'Maze':
cls.Maze_ = SingleSkill(skill)
elif skill_attack_type == '':
cls.Talent_ = SingleSkill(skill)
else:
raise ValueError(
f'Unknown skillAttackType: {skill_attack_type}'
)
return cls

78
StarRailUID/starrailuid_charinfo/effect/Base/WeaponBase.py
View File

@ -1,78 +0,0 @@
from typing import Dict
from abc import abstractmethod
from msgspec import Struct
from .model import DamageInstanceWeapon
from ....utils.excel.model import EquipmentPromotionConfig
from ....utils.map.SR_MAP_PATH import EquipmentID2AbilityProperty
class BaseWeaponAttribute(Struct):
hp: float
attack: float
defence: float
def items(self):
return [
('hp', self.hp),
('attack', self.attack),
('defence', self.defence),
]
class BaseWeapon:
def __init__(self, weapon: DamageInstanceWeapon):
self.weapon_id = weapon.id_
self.weapon_level = weapon.level
self.weapon_rank = weapon.rank
self.weapon_promotion = weapon.promotion
self.weapon_base_attribute = self.get_attribute()
self.weapon_attribute: Dict[str, float] = {}
self.get_attribute()
self.weapon_property_ability()
@abstractmethod
async def weapon_ability(self, base_attr: Dict, attribute_bonus: Dict):
"""
战斗加成属性, 与 weapon_property_ability() 互斥
"""
...
def weapon_property_ability(self):
"""
面板加成属性, 与 weapon_ability() 互斥
"""
ability_property = EquipmentID2AbilityProperty[str(self.weapon_id)]
equip_ability_property = ability_property[str(self.weapon_rank)]
for equip_ability in equip_ability_property:
property_type = equip_ability['PropertyType']
value = equip_ability['Value']['Value']
if property_type in self.weapon_attribute:
self.weapon_attribute[property_type] += value
else:
self.weapon_attribute[property_type] = value
@abstractmethod
async def check(self):
...
def get_attribute(self):
promotion = EquipmentPromotionConfig.Equipment[str(self.weapon_id)][
str(self.weapon_promotion)
]
return BaseWeaponAttribute(
hp=(
promotion.BaseHP.Value
+ promotion.BaseHPAdd.Value * (self.weapon_level - 1)
),
attack=(
promotion.BaseAttack.Value
+ promotion.BaseAttackAdd.Value * (self.weapon_level - 1)
),
defence=(
promotion.BaseDefence.Value
+ promotion.BaseDefenceAdd.Value * (self.weapon_level - 1)
),
)

103
StarRailUID/starrailuid_charinfo/effect/Base/model.py
View File

@ -1,103 +0,0 @@
from typing import List, Union
import msgspec
from msgspec import Struct, field
class DamageInstanceSkill(Struct):
skillId: int
skillName: str
skillEffect: str
skillAttackType: str
skillLevel: int
class DamageInstanceRelicSubAffix(Struct):
SubAffixID: int
Property: str
Name: str
Cnt: int
Step: int
Value: float
class DamageInstanceRelicMainAffix(Struct):
AffixID: int
Property: str
Name: str
Value: float
class DamageInstanceRelic(Struct):
relicId: int
relicName: str
SetId: int
SetName: str
Type: int
MainAffix: DamageInstanceRelicMainAffix
SubAffixList: Union[List[DamageInstanceRelicSubAffix], None]
Level: int = 0
class DamageInstanceWeapon(Struct):
id_: str = field(name='id')
level: int
rank: int
promotion: int
class AttributeBounsStatusAdd(Struct):
property: str
name: str
value: float
class DamageInstanceAvatarAttributeBouns(Struct):
attributeBonusId: int
attributeBonusLevel: int
statusAdd: AttributeBounsStatusAdd
class DamageInstanceAvatar(Struct):
id_: str = field(name='id')
level: int
rank: int
element: str
promotion: int
attribute_bonus: Union[List[DamageInstanceAvatarAttributeBouns], None]
extra_ability: Union[List, None]
class DamageInstance:
avatar: DamageInstanceAvatar
weapon: DamageInstanceWeapon
relic: List[DamageInstanceRelic]
skill: List[DamageInstanceSkill]
def __init__(self, char):
self.avatar = DamageInstanceAvatar(
id_=char.char_id,
level=char.char_level,
rank=char.char_rank,
element=char.char_element,
promotion=char.char_promotion,
attribute_bonus=msgspec.convert(
char.attribute_bonus,
Union[List[DamageInstanceAvatarAttributeBouns], None],
),
extra_ability=msgspec.convert(
char.extra_ability, Union[List, None]
),
)
self.weapon = DamageInstanceWeapon(
id_=char.equipment['equipmentID'],
level=char.equipment['equipmentLevel'],
rank=char.equipment['equipmentRank'],
promotion=char.equipment['equipmentPromotion'],
)
self.relic = []
for relic in char.char_relic:
self.relic.append(msgspec.convert(relic, DamageInstanceRelic))
self.skill = []
for skill in char.char_skill:
self.skill.append(msgspec.convert(skill, DamageInstanceSkill))

695
StarRailUID/starrailuid_charinfo/effect/Excel/SkillData.json
View File

@ -1,695 +0,0 @@
{
"1102": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"BPSkill": [
1.1000000000931323, 1.2100000001955777, 1.3200000002980232,
1.4300000004004687, 1.5400000005029142, 1.6500000006053597,
1.7875000005587935, 1.9250000005122274, 2.0625000002328306,
2.2000000001862645, 2.31000000028871, 2.4200000003911555,
2.530000000493601, 2.6400000005960464, 2.750000000698492
],
"Ultra": [
2.5500000005122274, 2.7200000006705523, 2.890000000828877,
3.0600000000558794, 3.230000000214204, 3.400000000372529,
3.612500000745058, 3.825000000419095, 4.037499999860302,
4.250000000232831, 4.4200000003911555, 4.59000000054948,
4.760000000707805, 4.93000000086613, 5.100000000093132
],
"Talent": [
0.40000000037252903, 0.44000000040978193, 0.48000000044703484,
0.5200000004842877, 0.5600000005215406, 0.6000000005587935,
0.6500000006053597, 0.7000000006519258, 0.7500000006984919,
0.8000000007450581, 0.840000000782311, 0.8800000008195639,
0.9200000008568168, 0.9600000008940697, 1
],
"Maze": [20],
"Ultra_Use": [120],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
},
"1204": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"BPSkill": [
0.5000000004656613, 0.5500000004656613, 0.6000000005587935,
0.6500000005587935, 0.7000000006519258, 0.7500000006519258,
0.8000000007450581, 0.8500000007450581, 0.9000000008381903,
0.9500000008381903, 1.0000000000931323, 1.0500000000931323,
1.1000000001862645, 1.1500000001862645, 1.2000000002793968,
1.2500000002793968
],
"Ultra": [
1.2000000002793968, 1.2800000002793968, 1.3600000002793968,
1.4400000002793968, 1.5200000002793968, 1.6000000002793968,
1.6800000002793968, 1.7600000002793968, 1.8400000002793968,
1.9200000002793968, 2.0000000002793968, 2.0800000002793968,
2.1600000002793968, 2.2400000002793968, 2.3200000002793968,
2.4000000002793968
],
"Talent": [
3.300000000372529, 3.63000000372529, 3.960000000372529, 4.290000000372529,
4.620000000372529, 4.495000000372529, 5.363000000372529,
5.775000000372529, 6.188000000372529, 6.600000000372529,
6.930000000372529, 7.260000000372529, 7.590000000372529,
7.920000000372529, 8.250000000372529
],
"Maze": [20],
"Ultra_Use": [130],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"Talent": ["attack", "10层神君", 1, "Talent", "Talent"]
}
},
"1107": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"BPSkill": [
0.6000000004656613, 0.6600000004656613, 0.7200000005587935,
0.7800000005587935, 0.8400000006519258, 0.9000000006519258,
0.9600000007450581, 1.0200000007450581, 1.0800000008381903,
1.1400000008381903, 1.2000000000931323, 1.2600000000931323,
1.3200000001862645, 1.3800000001862645, 1.4400000002793968,
1.5000000002793968
],
"Talent1": [
0.9600000002793968, 1.0240000002793968, 1.0880000002793968,
1.1520000002793968, 1.2160000002793968, 1.2800000002793968,
1.3600000002793968, 1.4400000002793968, 1.5200000002793968,
1.6000000002793968, 1.6640000002793968, 1.7280000002793968,
1.7920000002793968, 1.1850000002793968, 1.9200000002793968
],
"Talent": [
0.800000000372529, 0.880000000372529, 0.960000000372529,
1.040000000372529, 1.120000000372529, 1.200000000372529,
1.300000000372529, 1.400000000372529, 1.500000000372529,
1.600000000372529, 1.680000000372529, 1.760000000372529,
1.840000000372529, 1.920000000372529, 2.000000000372529
],
"Maze": [20],
"Ultra_Use": [130],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Talent": ["attack", "反击", 1, "Talent", "Talent"],
"Talent1": ["attack", "强化反击", 1, "Talent", "Ultra"]
}
},
"1213": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968, 1.3000000002793968
],
"Normal1": [
1.3000000004656613, 1.5600000005587935, 1.8200000006519258,
2.0800000007450581, 2.3400000008381903, 2.6000000000931323,
2.8600000001862645, 3.1200000002793968, 3.3800000002793968
],
"Normal2": [
1.9000000004656613, 2.2800000005587935, 2.6600000006519258,
3.0400000007450581, 3.4200000008381903, 3.8000000000931323,
4.1800000001862645, 4.5600000002793968, 4.9400000002793968
],
"Normal3": [
2.5000000004656613, 3.0000000005587935, 3.5000000006519258,
4.0000000007450581, 4.5000000008381903, 5.0000000000931323,
5.5000000001862645, 6.0000000002793968, 6.5000000002793968
],
"BPSkill": [
0.0600000004656613, 0.0660000004656613, 0.0720000005587935,
0.0780000005587935, 0.0840000006519258, 0.0900000006519258,
0.0975000007450581, 0.1050000007450581, 0.1125000008381903,
0.1200000008381903, 0.1260000000931323, 0.1320000000931323,
0.1380000001862645, 0.1440000001862645, 0.1500000002793968,
0.1560000002793968
],
"Ultra": [
1.8000000002793968, 1.9200000002793968, 2.0400000002793968,
2.1600000002793968, 2.2800000002793968, 2.4000000002793968,
2.5500000002793968, 2.7000000002793968, 2.8500000002793968,
3.0000000002793968, 3.1200000002793968, 3.2400000002793968,
3.3600000002793968, 3.4800000002793968, 3.6000000002793968
],
"Talent": [
0.050000000372529, 0.055000000372529, 0.060000000372529,
0.065000000372529, 0.070000000372529, 0.075000000372529,
0.081300000372529, 0.087500000372529, 0.093800000372529,
0.100000000372529, 0.105000000372529, 0.110000000372529,
0.115000000372529, 0.120000000372529, 0.125000000372529
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 2, "Normal", "Normal"],
"Normal1": ["attack", "瞬华", 3, "Normal", "Normal"],
"Normal2": ["attack", "天矢阴", 5, "Normal", "Normal"],
"Normal3": ["attack", "盘拏耀跃", 7, "Normal", "Normal"],
"Ultra": ["attack", "终结技", 3, "Ultra", "Ultra"]
}
},
"1006": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"BPSkill": [
0.9800000004656613, 1.0790000004656613, 1.1760000005587935,
1.2740000005587935, 1.3720000006519258, 1.4700000006519258,
1.5925000007450581, 1.7150000007450581, 1.8375000008381903,
1.9600000008381903, 2.0580000000931323, 2.1560000000931323,
2.2540000001862645, 2.3520000001862645, 2.4500000002793968
],
"BPSkill_D": [
0.075000000372529, 0.077500000372529, 0.080000000372529,
0.082500000372529, 0.085000000372529, 0.087500000372529,
0.090600000372529, 0.093800000372529, 0.096900000372529,
0.100000000372529, 0.102500000372529, 0.105000000372529,
0.107500000372529, 0.110000000372529, 0.112500000372529
],
"Ultra": [
2.280000000372529, 2.432000000372529, 2.584000000372529,
2.736000000372529, 2.888000000372529, 3.040000000372529,
3.230000000372529, 3.420000000372529, 3.610000000372529,
3.800000000372529, 3.952000000372529, 4.104000000372529,
4.256000000372529, 4.408000000372529, 4.560000000372529
],
"Ultra_D": [
0.360000000372529, 0.369000000372529, 0.378000000372529,
0.387000000372529, 0.396000000372529, 0.405000000372529,
0.416300000372529, 0.427500000372529, 0.438800000372529,
0.450000000372529, 0.459000000372529, 0.468000000372529,
0.477000000372529, 0.486000000372529, 0.495000000372529
],
"Talent": [
0.040000000372529, 0.044000000372529, 0.048000000372529,
0.052000000372529, 0.056000000372529, 0.040000000372529,
0.060000000372529, 0.065000000372529, 0.070000000372529,
0.075000000372529, 0.080000000372529, 0.084000000372529,
0.088000000372529, 0.096000000372529, 0.100000000372529
],
"Maze": [20],
"Ultra_Use": [110],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
},
"1005": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"BPSkill": [
0.8000000004656613, 0.8800000004656613, 0.9600000005587935,
1.0400000005587935, 1.1200000006519258, 1.2000000006519258,
1.3000000007450581, 1.4000000007450581, 1.5000000008381903,
1.6000000008381903, 1.6800000000931323, 1.7600000000931323,
1.8400000001862645, 1.9200000001862645, 2.0000000002793968
],
"Ultra": [
0.480000000372529, 0.512000000372529, 0.544000000372529,
0.576000000372529, 0.608000000372529, 0.640000000372529,
0.680000000372529, 0.720000000372529, 0.760000000372529,
0.800000000372529, 0.832000000372529, 0.864000000372529,
0.896000000372529, 0.928000000372529, 0.960000000372529
],
"DOT": [
1.1600000004656613, 1.2688000004656613, 1.3775000005587935,
1.4863000005587935, 1.5950000006519258, 1.7581000006519258,
1.9756000007450581, 2.2475000007450581, 2.5738000008381903,
2.9000000008381903, 3.0414000000931323, 3.1828000000931323,
3.3241000001862645, 3.4655000001862645, 3.6069000002793968
],
"Talent": [
0.420000000372529, 0.518000000372529, 0.616000000372529,
0.714000000372529, 0.812000000372529, 0.910000000372529,
1.032500000372529, 1.155000000372529, 1.277500000372529,
1.400000000372529, 1.498000000372529, 1.596000000372529,
1.694000000372529, 1.792000000372529, 1.890000000372529
],
"Maze": [20],
"Ultra_Use": [110],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"DOT": ["attack", "单次持续伤害", 1, "DOT", "Ultra"],
"Talent": ["attack", "追加攻击", 1, "Talent", "Talent"]
}
},
"1205": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968, 1.3000000002793968
],
"Normal1": [
0.2000000004656613, 0.2400000005587935, 0.2800000006519258,
0.3200000007450581, 0.3600000008381903, 0.4000000000931323,
0.4400000001862645, 0.4800000002793968, 0.5200000002793968
],
"Normal1_HP": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968, 1.3000000002793968
],
"BPSkill": [
0.1200000004656613, 0.1480000004656613, 0.1760000005587935,
0.204000000372529, 0.232000000372529, 0.260000000372529,
0.295000000372529, 0.330000000372529, 0.365000000372529,
0.400000000372529, 0.428000000372529, 0.456000000372529,
0.484000000372529, 0.512000000372529, 0.540000000372529
],
"Ultra": [
0.240000000372529, 0.256000000372529, 0.272000000372529,
0.288000000372529, 0.304000000372529, 0.320000000372529,
0.340000000372529, 0.360000000372529, 0.380000000372529,
0.400000000372529, 0.416000000372529, 0.432000000372529,
0.448000000372529, 0.464000000372529, 0.480000000372529
],
"Ultra_HP": [
1.500000000372529, 1.540000000372529, 1.580000000372529,
1.620000000372529, 1.660000000372529, 1.700000000372529,
1.750000000372529, 1.800000000372529, 1.850000000372529,
1.900000000372529, 1.940000000372529, 1.980000000372529,
2.020000000372529, 2.060000000372529, 2.100000000372529
],
"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
],
"Talent_HP": [
0.550000000372529, 0.605000000372529, 0.660000000372529,
0.715000000372529, 0.770000000372529, 0.825000000372529,
0.893800000372529, 0.962500000372529, 1.031300000372529,
1.100000000372529, 1.155000000372529, 1.210000000372529,
1.265000000372529, 1.320000000372529, 1.375000000372529
],
"Maze": [20],
"Ultra_Use": [110],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"Normal1": ["attack", "无间剑树", 1, "Normal", "Normal"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"Talent": ["attack", "追加攻击", 1, "Talent", "Talent"]
}
},
"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,
0.5500000001862645, 0.6000000002793968, 0.6500000002793968
],
"BPSkill_HP": [
0.0300000004656613, 0.0330000004656613, 0.0360000005587935,
0.039000000372529, 0.042000000372529, 0.045000000372529,
0.048800000372529, 0.052500000372529, 0.056300000372529,
0.060000000372529, 0.063000000372529, 0.066000000372529,
0.069000000372529, 0.072000000372529, 0.075000000372529
],
"BPSkill_CC": [
0.0600000004656613, 0.0660000004656613, 0.0720000005587935,
0.078000000372529, 0.084000000372529, 0.090000000372529,
0.097500000372529, 0.105000000372529, 0.112500000372529,
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,
0.850000000372529, 0.900000000372529, 0.950000000372529,
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": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
},
"1104": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968, 1.3000000002793968
],
"BPSkill": [
1.0000000004656613, 1.1000000004656613, 1.2000000005587935,
1.300000000372529, 1.400000000372529, 1.500000000372529,
1.625000000372529, 1.750000000372529, 1.875000000372529,
2.000000000372529, 2.100000000372529, 2.200000000372529,
2.300000000372529, 2.400000000372529, 2.500000000372529
],
"Ultra": [
0.300000000372529, 0.318800000372529, 0.337500000372529,
0.356300000372529, 0.375000000372529, 0.390000000372529,
0.405000000372529, 0.420000000372529, 0.435000000372529,
0.450000000372529, 0.465000000372529, 0.480000000372529,
0.495000000372529, 0.510000000372529, 0.525000000372529
],
"Ultra_G": [
150, 240, 308, 375, 420, 465, 499, 533, 566, 600, 634, 668, 701, 735, 769
],
"Maze": [20],
"Ultra_Use": [110],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["defence", "终结技(护盾)", 1, "Ultra", "Ultra"]
}
},
"1209": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"BPSkill": [
1.1000000000931323, 1.2100000001955777, 1.3200000002980232,
1.4300000004004687, 1.5400000005029142, 1.6500000006053597,
1.7875000005587935, 1.9250000005122274, 2.0625000002328306,
2.2000000001862645, 2.31000000028871, 2.4200000003911555,
2.530000000493601, 2.6400000005960464, 2.750000000698492
],
"Ultra": [
2.1000000005122274, 2.2400000006705523, 2.380000000828877,
2.5200000000558794, 2.660000000214204, 2.800000000372529,
2.975000000745058, 3.150000000419095, 3.332499999860302,
3.500000000232831, 3.6400000003911555, 3.78000000054948,
3.920000000707805, 4.06000000086613, 4.200000000093132
],
"Ultra_CD": [
0.3000000005122274, 0.3200000006705523, 0.340000000828877,
0.3600000000558794, 0.380000000214204, 0.400000000372529,
0.425000000745058, 0.450000000419095, 0.474999999860302,
0.500000000232831, 0.5200000003911555, 0.54000000054948,
0.560000000707805, 0.58000000086613, 0.600000000093132
],
"Talent": [
0.25000000037252903, 0.27500000040978193, 0.30000000044703484,
0.3250000004842877, 0.3500000005215406, 0.3750000005587935,
0.4063000006053597, 0.4375000006519258, 0.4688000006984919,
0.5000000007450581, 0.525000000782311, 0.5500000008195639,
0.5750000008568168, 0.6000000008940697, 0.6250000008940697
],
"Talent_CC": [
0.15000000037252903, 0.15500000040978193, 0.16000000044703484,
0.1650000004842877, 0.1700000005215406, 0.1750000005587935,
0.1813000006053597, 0.1875000006519258, 0.1938000006984919,
0.2000000007450581, 0.205000000782311, 0.2100000008195639,
0.2150000008568168, 0.2200000008940697, 0.2250000008940697
],
"Talent_CD": [
0.15000000037252903, 0.16500000040978193, 0.18000000044703484,
0.1950000004842877, 0.2100000005215406, 0.2250000005587935,
0.2438000006053597, 0.2625000006519258, 0.2813000006984919,
0.3000000007450581, 0.315000000782311, 0.3300000008195639,
0.3450000008568168, 0.3600000008940697, 0.3750000008940697
],
"Maze": [20],
"Ultra_Use": [120],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"Talent": ["attack", "附加伤害", 1, "Talent", "Talent"]
}
},
"1004": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"BPSkill": [
1.0800000000931323, 1.1880000001955777, 1.2960000002980232,
1.4040000004004687, 1.5120000005029142, 1.6200000006053597,
1.7550000005587935, 1.8900000005122274, 2.0550000002328306,
2.1600000001862645, 2.26800000028871, 2.3760000003911555,
2.484000000493601, 2.5920000005960464, 2.700000000698492
],
"Ultra": [
0.9000000005122274, 0.9600000006705523, 1.020000000828877,
1.0800000000558794, 1.140000000214204, 1.200000000372529,
1.275000000745058, 1.350000000419095, 1.424999999860302,
1.500000000232831, 1.5600000003911555, 1.62000000054948,
1.680000000707805, 1.74000000086613, 1.800000000093132
],
"Talent": [
0.30000000037252903, 0.33000000040978193, 0.36000000044703484,
0.3900000004842877, 0.4200000005215406, 0.4500000005587935,
0.4875000006053597, 0.525000006519258, 0.5625000006984919,
0.6000000007450581, 0.63000000782311, 0.6600000008195639,
0.6900000008568168, 0.7200000008940697, 0.7500000008940697
],
"Maze": [20],
"Ultra_Use": [120],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 3, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
},
"1003": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"BPSkill": [
1.0000000000931323, 1.1000000001955777, 1.2000000002980232,
1.3000000004004687, 1.4000000005029142, 1.5000000006053597,
1.6250000005587935, 1.7500000005122274, 1.8750000002328306,
2.0000000001862645, 2.10000000028871, 2.2000000003911555,
2.300000000493601, 2.4000000005960464, 2.500000000698492
],
"Ultra": [
1.3800000005122274, 1.4720000006705523, 1.564000000828877,
1.6560000000558794, 1.748000000214204, 1.840000000372529,
1.955000000745058, 2.070000000419095, 2.185000000860302,
2.300000000232831, 2.3920000003911555, 2.48400000054948,
2.596000000707805, 2.66800000086613, 2.76000000093132
],
"Talent": [
0.70000000037252903, 0.77000000040978193, 0.84000000044703484,
0.9100000004842877, 0.9800000005215406, 1.0500000005587935,
1.1375000006053597, 1.225000006519258, 1.312500006984919,
1.4000000007450581, 1.47000000782311, 1.5400000008195639,
1.6100000008568168, 1.6800000008940697, 1.7500000008940697
],
"Maze": [20],
"Ultra_Use": [120],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"Talent": ["attack", "追加攻击", 1, "Talent", "Talent"]
}
},
"1201": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968
],
"Normal1": [
1.2000000000931323, 1.4400000001955777, 1.6800000002980232,
1.9200000004004687, 2.1600000005029142, 2.4000000006053597,
2.6450000005587935, 2.8800000005122274, 3.1200000002328306
],
"BPSkill": [
0.14000000037252903, 0.15400000040978193, 0.16800000044703484,
0.1820000004842877, 0.1960000005215406, 0.2100000005587935,
0.2275000006053597, 0.2450000006519258, 0.2625000006984919,
0.2800000007450581, 0.294000000782311, 0.3080000008195639,
0.3220000008568168, 0.3360000008940697, 0.3500000008940697
],
"Ultra": [
1.2000000005122274, 1.2800000006705523, 1.360000000828877,
1.440000000558794, 1.520000000214204, 1.600000000372529,
1.700000000745058, 1.800000000419095, 1.900000000860302,
2.000000000232831, 2.0800000003911555, 2.16000000054948,
2.240000000707805, 2.32000000086613, 2.40000000093132
],
"Talent": [
0.36000000037252903, 0.39600000040978193, 0.43200000044703484,
0.4680000004842877, 0.5040000005215406, 0.5400000005587935,
0.5850000006053597, 0.6300000006519258, 0.6750000006984919,
0.7200000007450581, 0.756000000782311, 0.7920000008195639,
0.8280000008568168, 0.8640000008940697, 0.9000000008940697
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"Normal1": ["attack", "杠上开花！", 1, "Normal", "Normal"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
},
"1212": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968, 1.3000000002793968
],
"BPSkill": [
1.0000000005122274, 1.1000000006705523, 1.200000000828877,
1.300000000558794, 1.400000000214204, 1.500000000372529,
1.630000000745058, 1.750000000419095, 1.880000000860302,
2.000000000232831, 2.1000000003911555, 2.20000000054948,
2.300000000707805, 2.40000000086613, 2.50000000093132
],
"BPSkill1": [
1.2500000005122274, 1.3750000006705523, 1.500000000828877,
1.625000000558794, 1.750000000214204, 1.875000000372529,
2.031250000745058, 2.187500000419095, 2.343750000860302,
2.500000000232831, 2.6250000003911555, 2.75000000054948,
2.875000000707805, 3.00000000086613, 3.12500000093132
],
"Ultra": [
1.8000000005122274, 1.9200000006705523, 2.040000000828877,
2.160000000558794, 2.280000000214204, 2.400000000372529,
2.550000000745058, 2.700000000419095, 2.850000000860302,
3.000000000232831, 3.1200000003911555, 3.24000000054948,
3.360000000707805, 3.48000000086613, 3.60000000093132
],
"Talent_CC": [
0.40000000037252903, 0.41000000040978193, 0.42000000044703484,
0.4300000004842877, 0.4400000005215406, 0.4500000005587935,
0.4625000006053597, 0.4750000006519258, 0.4875000006984919,
0.5000000007450581, 0.510000000782311, 0.5200000008195639,
0.5300000008568168, 0.5400000008940697, 0.5500000008940697
],
"Talent_atk": [
0.90000000037252903, 0.99000000040978193, 1.08000000044703484,
1.1700000004842877, 1.2600000005215406, 1.3500000005587935,
1.4625000006053597, 1.5750000006519258, 1.6875000006984919,
1.8000000007450581, 1.890000000782311, 1.9800000008195639,
2.0700000008568168, 2.1600000008940697, 2.2500000008940697
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"BPSkill1": ["attack", "寒川映月", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"]
}
},
"1112": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000001862645, 1.2000000002793968, 1.3000000002793968
],
"BPSkill": [
0.7500000005122274, 0.8250000006705523, 0.900000000828877,
0.975000000558794, 1.050000000214204, 1.125000000372529,
1.218750000745058, 1.312500000419095, 1.406250000860302,
1.500000000232831, 1.575000000391155, 1.65000000054948, 1.725000000707805,
1.80000000086613, 1.87500000093132
],
"BPSkill_add": [
0.2500000005122274, 0.2750000006705523, 0.300000000828877,
0.325000000558794, 0.350000000214204, 0.375000000372529,
0.406250000745058, 0.437500000419095, 0.468750000860302,
0.500000000232831, 0.5250000003911555, 0.55000000054948,
0.575000000707805, 0.60000000086613, 0.62500000093132
],
"Talent1": [
0.7500000005122274, 0.8250000006705523, 0.900000000828877,
0.975000000558794, 1.050000000214204, 1.125000000372529,
1.218750000745058, 1.312500000419095, 1.406250000860302,
1.500000000232831, 1.575000000391155, 1.65000000054948, 1.725000000707805,
1.80000000086613, 1.87500000093132
],
"Ultra_CD": [
0.1250000005122274, 0.13750000006705523, 0.150000000828877,
0.162500000558794, 0.175000000214204, 0.187500000372529,
0.203125000745058, 0.218750000419095, 0.234375000860302,
0.250000000232831, 0.262500000391155, 0.27500000054948, 0.287500000707805,
0.30000000086613, 0.31250000093132
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 1, "Talent", "Normal"],
"BPSkill": ["attack", "账账", 1, "Talent", "BPSkill"],
"Talent1": ["attack", "强化账账", 1, "Talent", "Talent"]
}
},
"1210": {
"Normal": [
0.5000000004656613, 0.6000000005587935, 0.7000000006519258,
0.8000000007450581, 0.9000000008381903, 1.0000000000931323,
1.1000000000931323, 1.2000000001862645, 1.3000000002793968
],
"BPSkill": [
0.6000000005587935, 0.6600000006146729, 0.7200000006705523,
0.7800000007264316, 0.840000000782311, 0.9000000008381903,
0.9750000005587935, 1.0500000000465661, 1.1249999997671694,
1.2000000001862645, 1.2600000002421439, 1.3200000002980232,
1.3800000003539026, 1.440000000409782, 1.5000000004656613
],
"DOT": [
0.8390400004573166, 0.9229800018947572, 1.0069200003053993,
1.0908600010443479, 1.1748000003863126, 1.3007100007962435,
1.4685900008771569, 1.6784400006290525, 1.9302600014489144,
2.182080000638962, 2.2912020003423095, 2.400324000744149,
2.5094460004474968, 2.6185680008493364, 2.727690001251176
],
"Ultra": [
0.7200000006705523, 0.7680000001564622, 0.8160000003408641,
0.8640000005252659, 0.9120000007096678, 0.9600000008940697,
1.0200000000186265, 1.0800000000745058, 1.1400000001303852,
1.2000000001862645, 1.2479999996721745, 1.2959999998565763,
1.3440000000409782, 1.39200000022538, 1.440000000409782
],
"Talent": [
0.0400000000372529, 0.04299999983049929, 0.04599999962374568,
0.04899999941699207, 0.05199999990873039, 0.054999999701976776,
0.058750000316649675, 0.06250000023283064, 0.06625000014901161,
0.07000000006519258, 0.07299999985843897, 0.07599999965168536,
0.07899999944493175, 0.08199999993667006, 0.08499999972991645
],
"Maze": [20],
"Ultra_Use": [140],
"skillList": {
"Normal": ["attack", "普攻", 1, "Normal", "Normal"],
"BPSkill": ["attack", "战技", 1, "BPSkill", "BPSkill"],
"Ultra": ["attack", "终结技", 1, "Ultra", "Ultra"],
"DOT": ["attack", "每段灼烧", 1, "DOT", "BPSkill"]
}
}
}

469
StarRailUID/starrailuid_charinfo/effect/Excel/weapon_effect.json
View File

@ -1,469 +0,0 @@
{
"23001": {
"Param": {
"CriticalChance": [
0.18000000016763806, 0.21000000019557774, 0.24000000022351742,
0.2700000002514571, 0.3000000002793968
],
"a_dmg": [
0.060000000055879354, 0.07000000006519258, 0.0800000000745058,
0.09000000008381903, 0.10000000009313226
],
"e_dmg": [
0.060000000055879354, 0.07000000006519258, 0.0800000000745058,
0.09000000008381903, 0.10000000009313226
],
"q_crit_dmg": [
0.12000000011175871, 0.14000000013038516, 0.1600000001490116,
0.18000000016763806, 0.20000000018626451
]
},
"AbilityProperty": [
0.18000000016763806, 0.21000000019557774, 0.24000000022351742,
0.2700000002514571, 0.3000000002793968
]
},
"21003": {
"Param": {
"CriticalChance": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
]
}
},
"24001": {
"Param": {
"CriticalChance": [
0.0800000000745058, 0.10000000009313226, 0.12000000011175871,
0.14000000013038516, 0.1600000001490116
],
"AttackAddedRatio": [
0.20000000018626451, 0.25000000023283064, 0.3000000002793968,
0.3500000003259629, 0.40000000037252903
]
},
"AbilityProperty": [
0.0800000000745058, 0.10000000009313226, 0.12000000011175871,
0.14000000013038516, 0.1600000001490116
]
},
"21024": {
"Param": {
"SpeedAddedRatio": [
0.0800000000745058, 0.09000000008381903, 0.10000000009313226,
0.11000000010244548, 0.12000000011175871
],
"AllDamageAddedRatio": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
]
}
},
"21017": {
"Param": {
"a_dmg": [
0.24000000022351742, 0.3000000002793968, 0.3600000003352761,
0.4200000003911555, 0.48000000044703484
],
"e_dmg": [
0.24000000022351742, 0.3000000002793968, 0.3600000003352761,
0.4200000003911555, 0.48000000044703484
]
}
},
"23010": {
"Param": {
"CriticalDamageBase": [
0.36000000022351742, 0.4200000002793968, 0.4800000003352761,
0.5400000003911555, 0.60000000044703484
],
"e_dmg": [
0.18000000022351742, 0.2100000002793968, 0.2400000003352761,
0.2700000003911555, 0.30000000044703484
],
"r_dmg": [
0.18000000022351742, 0.2100000002793968, 0.2400000003352761,
0.2700000003911555, 0.30000000044703484
],
"t_dmg": [
0.48000000022351742, 0.5600000002793968, 0.6400000003352761,
0.7200000003911555, 0.80000000044703484
]
}
},
"20002": {
"Param": {
"a_dmg": [
0.20000000022351742, 0.2500000002793968, 0.3000000003352761,
0.3500000003911555, 0.40000000044703484
],
"e_dmg": [
0.20000000022351742, 0.2500000002793968, 0.3000000003352761,
0.3500000003911555, 0.40000000044703484
]
}
},
"21006": {
"Param": {
"t_dmg": [
0.48000000022351742, 0.6000000002793968, 0.7200000003352761,
0.8400000003911555, 0.96000000044703484
]
}
},
"21012": {
"Param": {
"AllDamageAddedRatio": [
0.40000000022351742, 0.5000000002793968, 0.6000000003352761,
0.7000000003911555, 0.80000000044703484
]
}
},
"20011": {
"Param": {
"AllDamageAddedRatio": [
0.24000000022351742, 0.3000000002793968, 0.3600000003352761,
0.4200000003911555, 0.48000000044703484
]
}
},
"20004": {
"Param": {
"StatusProbability": [
0.20000000022351742, 0.2500000002793968, 0.3000000003352761,
0.3500000003911555, 0.40000000044703484
]
}
},
"20020": {
"Param": {
"A3_AttackAddedRatio": [
0.24000000022351742, 0.3000000002793968, 0.3600000003352761,
0.4200000003911555, 0.48000000044703484
]
}
},
"21013": {
"Param": {
"r_dmg": [
0.32000000022351742, 0.4000000002793968, 0.4800000003352761,
0.5600000003911555, 0.64000000044703484
]
}
},
"20006": {
"Param": {
"r_dmg": [
0.28000000022351742, 0.3500000002793968, 0.4200000003352761,
0.4900000003911555, 0.56000000044703484
]
}
},
"20014": {
"Param": {
"SpeedAddedRatio": [
0.10000000009313226, 0.12000000011175871, 0.14000000013038516,
0.1600000001490116, 0.18000000016763806
]
}
},
"20007": {
"Param": {
"AttackAddedRatio": [
0.24000000022351742, 0.3000000002793968, 0.3600000003352761,
0.4200000003911555, 0.48000000044703484
]
}
},
"23000": {
"Param": {
"AttackAddedRatio": [
0.09000000022351742, 0.1050000002793968, 0.1200000003352761,
0.1350000003911555, 0.15000000044703484
],
"AllDamageAddedRatio": [
0.30000000022351742, 0.3500000002793968, 0.4000000003352761,
0.4500000003911555, 0.50000000044703484
]
}
},
"21001": {
"Param": {
"AllDamageAddedRatio": [
0.12000000022351742, 0.1500000002793968, 0.1800000003352761,
0.2100000003911555, 0.24000000044703484
]
}
},
"23011": {
"Param": {
"AllDamageAddedRatio": [
0.09000000022351742, 0.1050000002793968, 0.1200000003352761,
0.1350000003911555, 0.15000000044703484
]
}
},
"23005": {
"Param": {
"DefenceAddedRatio": [
0.2400000000745058, 0.28000000009313226, 0.32000000011175871,
0.36000000013038516, 0.4000000001490116
]
}
},
"20003": {
"Param": {
"DefenceAddedRatio": [
0.1600000000745058, 0.20000000009313226, 0.24000000011175871,
0.28000000013038516, 0.3200000001490116
]
}
},
"21022": {
"Param": {
"AllDamageAddedRatio": [
0.16000000022351742, 0.2050000002793968, 0.2400000003352761,
0.2850000003911555, 0.32000000044703484
]
}
},
"21015": {
"Param": {
"ignore_defence": [
0.12000000022351742, 0.1300000002793968, 0.1400000003352761,
0.1500000003911555, 0.16000000044703484
]
}
},
"23004": {
"Param": {
"AllDamageAddedRatio": [
0.2400000000745058, 0.28000000009313226, 0.32000000011175871,
0.36000000013038516, 0.4000000001490116
],
"A2_StatusProbability": [
0.18000000022351742, 0.2100000002793968, 0.2400000003352761,
0.2700000003911555, 0.30000000044703484
],
"A2_AttackAddedRatio": [
0.2400000000745058, 0.28000000009313226, 0.32000000011175871,
0.36000000013038516, 0.4000000001490116
]
}
},
"23007": {
"Param": {
"DmgRatio": [
0.12000000022351742, 0.1400000002793968, 0.1600000003352761,
0.1800000003911555, 0.20000000044703484
],
"CriticalChance": [
0.12000000022351742, 0.1400000002793968, 0.1600000003352761,
0.1800000003911555, 0.20000000044703484
]
}
},
"23006": {
"Param": {
"SpeedAddedRatio": [
0.04800000022351742, 0.0560000002793968, 0.0640000003352761,
0.0720000003911555, 0.0800000044703484
],
"AllDamageAddedRatio": [
0.2400000000745058, 0.28000000009313226, 0.32000000011175871,
0.36000000013038516, 0.4000000001490116
]
}
},
"21020": {
"Param": {
"AttackAddedRatio": [
0.16000000022351742, 0.2050000002793968, 0.2400000003352761,
0.2850000003911555, 0.32000000044703484
],
"CriticalDamageBase": [
0.24000000022351742, 0.3000000002793968, 0.3600000003352761,
0.4200000003911555, 0.48000000044703484
]
}
},
"23015": {
"Param": {
"AttackAddedRatio": [
0.18000000022351742, 0.2150000002793968, 0.2400000003352761,
0.2750000003911555, 0.30000000044703484
],
"CriticalChance": [
0.18000000022351742, 0.2100000002793968, 0.2400000003352761,
0.2700000003911555, 0.30000000044703484
]
}
},
"20016": {
"Param": {
"CriticalChance": [
0.12000000022351742, 0.1500000002793968, 0.1800000003352761,
0.2100000003911555, 0.24000000044703484
]
}
},
"21005": {
"Param": {
"AttackAddedRatio": [
0.12000000022351742, 0.1500000002793968, 0.1800000003352761,
0.2100000003911555, 0.24000000044703484
]
}
},
"21019": {
"Param": {
"AttackAddedRatio": [
0.16000000022351742, 0.200000002793968, 0.2400000003352761,
0.2850000003911555, 0.32000000044703484
],
"CriticalChance": [
0.12000000022351742, 0.1500000002793968, 0.1800000003352761,
0.2100000003911555, 0.24000000044703484
]
}
},
"23009": {
"Param": {
"CriticalChance": [
0.18000000022351742, 0.2100000002793968, 0.2400000003352761,
0.2700000003911555, 0.30000000044703484
],
"HPAddedRatio": [
0.18000000022351742, 0.2100000002793968, 0.2400000003352761,
0.2700000003911555, 0.30000000044703484
],
"AllDamageAddedRatio": [
0.2400000000745058, 0.28000000009313226, 0.32000000011175871,
0.36000000013038516, 0.4000000001490116
]
}
},
"21034": {
"Param": {
"AllDamageAddedRatio": [
0.0020000022351742, 0.0025000002793968, 0.0030000003352761,
0.0035000003911555, 0.0040000044703484
]
}
},
"20009": {
"Param": {
"AllDamageAddedRatio": [
0.2000000000745058, 0.25000000009313226, 0.30000000011175871,
0.35000000013038516, 0.4100000001490116
]
}
},
"21010": {
"Param": {
"AllDamageAddedRatio": [
0.0800000000745058, 0.10000000009313226, 0.12000000011175871,
0.14000000013038516, 0.1600000001490116
]
}
},
"21033": {
"Param": {
"AllDamageAddedRatio": [
0.2400000000745058, 0.28000000009313226, 0.32000000011175871,
0.36000000013038516, 0.4000000001490116
],
"AttackAddedRatio": [
0.2400000000745058, 0.28000000009313226, 0.32000000011175871,
0.36000000013038516, 0.4000000001490116
]
}
},
"23014": {
"Param": {
"AllDamageAddedRatio": [
0.1400000000745058, 0.16400000009313226, 0.19000000011175871,
0.21400000013038516, 0.2400000001490116
],
"ResistancePenetration": [
0.1200000000745058, 0.14000000009313226, 0.16000000011175871,
0.18000000013038516, 0.2000000001490116
]
}
},
"23002": {
"Param": {
"AllDamageAddedRatio": [
0.2400000000745058, 0.28000000009313226, 0.32000000011175871,
0.36000000013038516, 0.4000000001490116
]
}
},
"21026": {
"Param": {
"AllDamageAddedRatio": [
0.16000000011175871, 0.2000000001396984, 0.24000000016763806,
0.28000000019557774, 0.32000000022351742
],
"AttackAddedRatio": [
0.1000000000745058, 0.12500000009313226, 0.15000000011175871,
0.17500000013038516, 0.2000000001490116
]
}
},
"24000": {
"Param": {
"AllDamageAddedRatio": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
],
"AttackAddedRatio": [
0.0800000000745058, 0.10000000009313226, 0.12000000011175871,
0.14000000013038516, 0.1600000001490116
]
}
},
"21027": {
"Param": {
"AllDamageAddedRatio": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
],
"AttackAddedRatio": [
0.04000000011175871, 0.0500000001396984, 0.06000000016763806,
0.07000000019557774, 0.08000000022351742
]
}
},
"23012": {
"Param": {
"CriticalChance": [
0.36000000011175871, 0.4200000001396984, 0.48000000016763806,
0.54000000019557774, 0.60000000022351742
]
}
},
"23016": {
"Param": {
"CriticalDamageBase": [
0.12000000011175871, 0.14000000013038516, 0.1600000001490116,
0.18000000016763806, 0.20000000018626451
],
"TalentDmgAdd": [
0.30000000011175871, 0.3500000001396984, 0.40000000016763806,
0.45000000019557774, 0.50000000022351742
]
}
},
"21031": {
"enable": false
},
"20000": {
"Param": {
"CriticalChance": [
0.12000000011175871, 0.1500000001396984, 0.18000000016763806,
0.21000000019557774, 0.24000000022351742
]
}
}
}

742
StarRailUID/starrailuid_charinfo/effect/Relic/Relic.py
View File

@ -1,742 +0,0 @@
from collections import Counter
from typing import Dict, List, Union
from gsuid_core.logger import logger
from ..utils import merge_attribute
from ..Base.model import DamageInstanceRelic
from ..Base.RelicBase import SingleRelic, BaseRelicSetSkill
class Relic101(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
在战斗开始时
"""
logger.info('Relic101 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
pass
return attribute_bonus
class Relic102(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
无
"""
logger.info('Relic102 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
a_dmg = attribute_bonus.get('NormalDmgAdd', 0)
attribute_bonus['NormalDmgAdd'] = a_dmg + 0.10000000018626451
return attribute_bonus
class Relic103(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
战斗中生效:装备者提供的护盾量提高
"""
logger.info('Relic103 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
shield_added_ratio = attribute_bonus.get('shield_added_ratio', 0)
attribute_bonus['shield_added_ratio'] = (
shield_added_ratio + 0.20000000018626451
)
return attribute_bonus
class Relic104(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者施放终结技
"""
logger.info('Relic104 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
critical_damage_base = attribute_bonus.get('CriticalDamageBase', 0)
attribute_bonus['CriticalDamageBase'] = (
critical_damage_base + 0.25000000023283064
)
return attribute_bonus
class Relic105(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
施放攻击或受到攻击时, 默认叠满
"""
logger.info('Relic105 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
attack_added_ratio = attribute_bonus.get('AttackAddedRatio', 0)
attribute_bonus['AttackAddedRatio'] = (
attack_added_ratio + 0.05000000004656613 * 5
)
return attribute_bonus
class Relic106(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
无
"""
logger.info('Relic106 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
pass
return attribute_bonus
class Relic107(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
TODO: 检查是否是火属性伤害
"""
logger.info('Relic107 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4:
e_dmg = attribute_bonus.get('BPSkillDmgAdd', 0)
attribute_bonus['BPSkillDmgAdd'] = e_dmg + 0.12000000011175871
if self.pieces4 and await self.check(base_attr, attribute_bonus):
fire_added_ratio = attribute_bonus.get('FireAddedRatio', 0)
attribute_bonus['FireAddedRatio'] = (
fire_added_ratio + 0.12000000011175871
)
return attribute_bonus
class Relic108(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者对敌方目标造成伤害
目标拥有量子属性弱点
"""
logger.info('Relic108 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
logger.info(attribute_bonus)
ignore_defence = attribute_bonus.get('ignore_defence', 0)
attribute_bonus['ignore_defence'] = (
ignore_defence + 0.10000000009313226 * 2
)
return attribute_bonus
class Relic109(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
TODO: 检查是否释放战技
"""
logger.info('Relic109 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
logger.info(attribute_bonus)
attack_added_ratio = attribute_bonus.get('AttackAddedRatio', 0)
attribute_bonus['AttackAddedRatio'] = (
attack_added_ratio + 0.20000000018626451
)
return attribute_bonus
class Relic110(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者施放终结技
"""
logger.info('Relic110 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
logger.info('ModifyActionDelay')
return attribute_bonus
class Relic111(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
self._count = count
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者击破敌方目标弱点
"""
logger.info('Relic111 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
logger.info('ModifySPNew')
return attribute_bonus
class Relic112(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
self._count = count
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者对陷入负面效果的敌方目标造成伤害
对陷入禁锢状态的敌方目标造成伤害
"""
logger.info('Relic111 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
logger.info('对陷入负面效果的敌方目标造成伤害')
critical_chance_base = attribute_bonus.get('CriticalChanceBase', 0)
attribute_bonus['CriticalChanceBase'] = (
critical_chance_base + 0.10000000009313226
)
if self.pieces4 and await self.check(base_attr, attribute_bonus):
logger.info('对陷入禁锢状态的敌方目标造成伤害')
critical_damage_base = attribute_bonus.get('CriticalDamageBase', 0)
attribute_bonus['CriticalDamageBase'] = (
critical_damage_base + 0.20000000018626451
)
return attribute_bonus
class Relic113(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
self._count = count
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
当装备者受到攻击或被我方目标消耗生命值后, 暴击率提高8%, 持续2回合, 该效果最多叠加2层。
"""
logger.info('Relic113 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
logger.info('当装备者受到攻击或被我方目标消耗生命值后')
critical_chance_base = attribute_bonus.get('CriticalChanceBase', 0)
attribute_bonus['CriticalChanceBase'] = (
critical_chance_base + 0.08000000009313226 * 2
)
return attribute_bonus
class Relic114(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
self._count = count
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
当装备者对我方目标施放终结技时, 我方全体速度提高12%, 持续1回合, 该效果无法叠加。
"""
logger.info('Relic114 check success')
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces4 and await self.check(base_attr, attribute_bonus):
speed_added_ratio = attribute_bonus.get('SpeedAddedRatio', 0)
attribute_bonus['SpeedAddedRatio'] = (
speed_added_ratio + 0.12000000011175871
)
return attribute_bonus
class Relic301(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者的速度大于等于120
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['speed'] >= 120:
logger.info('Relic306 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
attack_added_ratio = attribute_bonus.get('AttackAddedRatio', 0)
attribute_bonus['AttackAddedRatio'] = (
attack_added_ratio + 0.12000000011175871
)
return attribute_bonus
class Relic302(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者的速度大于等于120
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['speed'] >= 120:
logger.info('Relic306 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
attack_added_ratio = attribute_bonus.get('AttackAddedRatio', 0)
attribute_bonus['AttackAddedRatio'] = (
attack_added_ratio + 0.0800000000745058
)
return attribute_bonus
class Relic303(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
# 提高装备者等同于当前效果命中25%的攻击力,最多提高25%
return True
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
attack_added_ratio = attribute_bonus.get('AttackAddedRatio', 0)
merged_attr = await merge_attribute(base_attr, attribute_bonus)
status_probability = merged_attr.get('StatusProbabilityBase', 0)
# 提高装备者等同于当前效果命中25%的攻击力,最多提高25%
attribute_bonus['AttackAddedRatio'] = attack_added_ratio + min(
0.25000000023283064, status_probability / 0.25
)
return attribute_bonus
class Relic304(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
备者的效果命中大于等于50%
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['StatusResistanceBase'] >= 0.5000000004656613:
logger.info('Relic306 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
defence_added_ratio = attribute_bonus.get('DefenceAddedRatio', 0)
attribute_bonus['DefenceAddedRatio'] = (
defence_added_ratio + 0.1500000001396984
)
return attribute_bonus
class Relic305(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者的暴击伤害大于等于120%
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['CriticalDamageBase'] >= 1.2000000001862645:
logger.info('Relic306 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
critical_chance_base = attribute_bonus.get('CriticalChanceBase', 0)
attribute_bonus['CriticalChanceBase'] = (
critical_chance_base + 0.6000000005587935
)
return attribute_bonus
class Relic306(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者当前暴击率大于等于50%
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['CriticalChanceBase'] >= 0.5:
logger.info('Relic306 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
q_dmg = attribute_bonus.get('UltraDmgAdd', 0)
attribute_bonus['UltraDmgAdd'] = q_dmg + 0.1500000001396984
a3_dmg = attribute_bonus.get('TalentDmgAdd', 0)
attribute_bonus['TalentDmgAdd'] = a3_dmg + 0.1500000001396984
return attribute_bonus
class Relic307(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者的速度大于等于145
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['speed'] >= 145:
logger.info('Relic306 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
break_damage_added_ratio_base = attribute_bonus.get(
'BreakDamageAddedRatioBase', 0
)
attribute_bonus['BreakDamageAddedRatioBase'] = (
break_damage_added_ratio_base + 0.20000000018626451
)
return attribute_bonus
class Relic308(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
装备者的速度大于等于120
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['speed'] >= 120:
logger.info('Relic306 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
logger.info('ModifyActionDelay')
return attribute_bonus
class Relic309(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
当装备者的当前暴击率大于等于70%时, 普攻和战技造成的伤害提高20%。
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['CriticalChanceBase'] >= 0.7:
logger.info('Relic309 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
a_dmg = attribute_bonus.get('NormalDmgAdd', 0)
attribute_bonus['NormalDmgAdd'] = a_dmg + 0.20000000018626451
a2_dmg = attribute_bonus.get('BPSkillDmgAdd', 0)
attribute_bonus['BPSkillDmgAdd'] = a2_dmg + 0.20000000018626451
return attribute_bonus
class Relic310(BaseRelicSetSkill):
def __init__(self, set_id: int, count: int):
super().__init__(set_id, count)
async def check(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
"""
当装备者的效果抵抗大于等于30%时, 我方全体暴击伤害提高10%。
"""
merged_attr = await merge_attribute(base_attr, attribute_bonus)
if merged_attr['StatusResistanceBase'] >= 0.3:
logger.info('Relic310 check success')
return True
return False
async def set_skill_ability(
self, base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
if self.pieces2 and await self.check(base_attr, attribute_bonus):
critical_damage_base = attribute_bonus.get('CriticalDamageBase', 0)
attribute_bonus['CriticalDamageBase'] = (
critical_damage_base + 0.10000000018626451
)
return attribute_bonus
class RelicSet:
HEAD: SingleRelic
HAND: SingleRelic
BODY: SingleRelic
FOOT: SingleRelic
NECK: SingleRelic
OBJECT: SingleRelic
Unknow: SingleRelic
SetSkill: List[
Union[
Relic101,
Relic102,
Relic103,
Relic104,
Relic105,
Relic106,
Relic107,
Relic108,
Relic109,
Relic110,
Relic111,
Relic112,
Relic113,
Relic114,
Relic301,
Relic302,
Relic303,
Relic304,
Relic305,
Relic306,
Relic307,
Relic308,
Relic309,
Relic310,
]
]
def create(self, relic_list: List[DamageInstanceRelic]):
set_id_list: List[int] = []
for relic in relic_list:
set_id_list.append(relic.SetId)
if relic.Type == 1:
self.HEAD = SingleRelic(relic)
elif relic.Type == 2:
self.HAND = SingleRelic(relic)
elif relic.Type == 3:
self.BODY = SingleRelic(relic)
elif relic.Type == 4:
self.FOOT = SingleRelic(relic)
elif relic.Type == 5:
self.NECK = SingleRelic(relic)
elif relic.Type == 6:
self.OBJECT = SingleRelic(relic)
else:
self.Unknow = SingleRelic(relic)
self.set_id_counter = Counter(set_id_list).most_common()
self.check_set()
self.get_attribute()
return self
def get_attribute(self):
for item in self.__dict__:
if type(self.__dict__[item]) == SingleRelic:
itme__: SingleRelic = self.__dict__[item]
itme__.get_attribute_()
def check_set(self):
self.SetSkill = []
for item in self.set_id_counter:
set_id = item[0]
count = item[1]
if set_id == 101:
self.SetSkill.append(Relic101(set_id, count))
elif set_id == 102:
self.SetSkill.append(Relic102(set_id, count))
elif set_id == 103:
self.SetSkill.append(Relic103(set_id, count))
elif set_id == 104:
self.SetSkill.append(Relic104(set_id, count))
elif set_id == 105:
self.SetSkill.append(Relic105(set_id, count))
elif set_id == 106:
self.SetSkill.append(Relic106(set_id, count))
elif set_id == 107:
self.SetSkill.append(Relic107(set_id, count))
elif set_id == 108:
self.SetSkill.append(Relic108(set_id, count))
elif set_id == 109:
self.SetSkill.append(Relic109(set_id, count))
elif set_id == 110:
self.SetSkill.append(Relic110(set_id, count))
elif set_id == 111:
self.SetSkill.append(Relic111(set_id, count))
elif set_id == 112:
self.SetSkill.append(Relic112(set_id, count))
elif set_id == 113:
self.SetSkill.append(Relic113(set_id, count))
elif set_id == 114:
self.SetSkill.append(Relic114(set_id, count))
elif set_id == 301:
self.SetSkill.append(Relic301(set_id, count))
elif set_id == 302:
self.SetSkill.append(Relic302(set_id, count))
elif set_id == 303:
self.SetSkill.append(Relic303(set_id, count))
elif set_id == 304:
self.SetSkill.append(Relic304(set_id, count))
elif set_id == 305:
self.SetSkill.append(Relic305(set_id, count))
elif set_id == 306:
self.SetSkill.append(Relic306(set_id, count))
elif set_id == 307:
self.SetSkill.append(Relic307(set_id, count))
elif set_id == 308:
self.SetSkill.append(Relic308(set_id, count))
elif set_id == 309:
self.SetSkill.append(Relic309(set_id, count))
elif set_id == 310:
self.SetSkill.append(Relic310(set_id, count))
else:
raise Exception(f'Unknow SetId: {set_id}')

0
StarRailUID/starrailuid_charinfo/effect/Relic/__init__.py
View File

534
StarRailUID/starrailuid_charinfo/effect/Role.py
View File

@ -1,534 +0,0 @@
import json
from pathlib import Path
from typing import List, Union
from gsuid_core.logger import logger
from .Avatar.Avatar import Avatar
from .Weapon.Weapon import Weapon
from .utils import merge_attribute
from ..mono.Character import Character
from .Base.model import DamageInstance
from .Relic.Relic import RelicSet, SingleRelic
Excel_path = Path(__file__).parent
with Path.open(Excel_path / 'Excel' / 'SkillData.json', encoding='utf-8') as f:
skill_dict = json.load(f)
class RoleInstance:
def __init__(self, raw_data: Character):
self.raw_data = DamageInstance(raw_data)
self.avatar = Avatar.create(self.raw_data.avatar, self.raw_data.skill)
self.weapon = Weapon.create(self.raw_data.weapon)
self.relic_set = RelicSet().create(self.raw_data.relic)
self.base_attr = self.cal_role_base_attr()
self.attribute_bonus: dict[str, float] = {}
self.cal_relic_attr_add()
self.cal_avatar_attr_add()
self.cal_avatar_eidolon_add()
self.cal_weapon_attr_add()
def cal_role_base_attr(self):
logger.info('cal_role_base_attr')
base_attr: dict[str, float] = {}
avatar_attribute = self.avatar.avatar_attribute
for attr_name, attr_value in avatar_attribute.items():
if attr_name in base_attr:
base_attr[attr_name] += attr_value
else:
base_attr[attr_name] = attr_value
weapon_attribute = self.weapon.weapon_base_attribute
for attr_name, attr_value in weapon_attribute.items():
if attr_name in base_attr:
base_attr[attr_name] += attr_value
else:
base_attr[attr_name] = attr_value
return base_attr
def cal_relic_attr_add(self):
# 单件属性
for relic_type in self.relic_set.__dict__:
if type(self.relic_set.__dict__[relic_type]) == SingleRelic:
relic: SingleRelic = self.relic_set.__dict__[relic_type]
for attribute in relic.relic_attribute_bonus:
if attribute in self.attribute_bonus:
self.attribute_bonus[
attribute
] += relic.relic_attribute_bonus[attribute]
else:
self.attribute_bonus[
attribute
] = relic.relic_attribute_bonus[attribute]
# 套装面板加成属性
for set_skill in self.relic_set.SetSkill:
for attribute in set_skill.relicSetAttribute:
if attribute in self.attribute_bonus:
self.attribute_bonus[
attribute
] += set_skill.relicSetAttribute[attribute]
else:
self.attribute_bonus[
attribute
] = set_skill.relicSetAttribute[attribute]
def cal_avatar_attr_add(self):
attribute_bonus = self.avatar.avatar_attribute_bonus
if attribute_bonus:
for bonus in attribute_bonus:
status_add = bonus.statusAdd
bonus_property = status_add.property
value = status_add.value
if bonus_property in self.attribute_bonus:
self.attribute_bonus[bonus_property] += value
else:
self.attribute_bonus[bonus_property] = value
def cal_avatar_eidolon_add(self):
for attribute in self.avatar.eidolon_attribute:
if attribute in self.attribute_bonus:
self.attribute_bonus[
attribute
] += self.avatar.eidolon_attribute[attribute]
else:
self.attribute_bonus[
attribute
] = self.avatar.eidolon_attribute[attribute]
for attribute in self.avatar.extra_ability_attribute:
if attribute in self.attribute_bonus:
self.attribute_bonus[
attribute
] += self.avatar.extra_ability_attribute[attribute]
else:
self.attribute_bonus[
attribute
] = self.avatar.extra_ability_attribute[attribute]
def cal_weapon_attr_add(self):
for attribute in self.weapon.weapon_attribute:
if attribute in self.attribute_bonus:
self.attribute_bonus[
attribute
] += self.weapon.weapon_attribute[attribute]
else:
self.attribute_bonus[attribute] = self.weapon.weapon_attribute[
attribute
]
async def cal_damage(self, skill_type: str):
logger.info('base_attr')
logger.info(self.base_attr)
logger.info('attribute_bonus')
logger.info(self.attribute_bonus)
logger.info(skill_type)
# 技能区
skill_info = self.avatar.Skill_Info(skill_type)
skill_multiplier = self.avatar.Skill_num(skill_info[4], skill_type)
# 检查是否有对某一个技能的倍率加成
for attr in self.attribute_bonus:
if attr.__contains__('SkillAdd'):
skill_name = attr.split('SkillAdd')[0]
if skill_name in (skill_type, skill_info[3]):
logger.info(
f'{skill_name}对{skill_type}有{self.attribute_bonus[attr]}倍率加成'
)
skill_multiplier = (
skill_multiplier + self.attribute_bonus[attr]
)
logger.info(f'技能区总: {skill_multiplier}')
# 检查武器战斗生效的buff
logger.info('检查武器战斗生效的buff')
Ultra_Use = self.avatar.Ultra_Use()
logger.info('Ultra_Use')
logger.info(Ultra_Use)
self.attribute_bonus = await self.weapon.weapon_ability(
Ultra_Use, self.base_attr, self.attribute_bonus
)
logger.info(self.attribute_bonus)
logger.info('检查遗器套装战斗生效的buff')
for set_skill in self.relic_set.SetSkill:
self.attribute_bonus = await set_skill.set_skill_ability(
self.base_attr, self.attribute_bonus
)
if self.attribute_bonus is None:
raise Exception('attribute_bonus is None')
logger.info(self.attribute_bonus)
# 检查是否有对某一个技能的属性加成
logger.info('检查是否有对某一个技能的属性加成')
for attr in self.attribute_bonus:
# 攻击加成
if attr.__contains__('AttackAddedRatio'):
attr_name = attr.split('AttackAddedRatio')[0]
if attr_name in (skill_type, skill_info[3]):
attack_added_ratio = self.attribute_bonus.get(
'AttackAddedRatio', 0
)
self.attribute_bonus['AttackAddedRatio'] = (
attack_added_ratio + self.attribute_bonus[attr]
)
# 效果命中加成
if attr.__contains__('StatusProbabilityBase'):
attr_name = attr.split('StatusProbabilityBase')[0]
if attr_name in (skill_type, skill_info[3]):
status_probability = self.attribute_bonus.get(
'StatusProbabilityBase', 0
)
self.attribute_bonus['StatusProbabilityBase'] = (
status_probability + self.attribute_bonus[attr]
)
merged_attr = await merge_attribute(
self.base_attr, self.attribute_bonus
)
logger.info(f'{merged_attr}')
skill_info_list = []
# 技能类型为攻击
if skill_info[0] == 'attack':
if isinstance(skill_info[2], str):
raise Exception('skill_info[2] is str')
skill_multiplier = skill_multiplier / skill_info[2]
logger.info(f'技能区单段: {skill_multiplier}')
if self.raw_data.avatar.id_ == 1004:
if self.raw_data.avatar.rank >= 6 and skill_type == 'BPSkill':
skill_info[2] = skill_info[2] + 1
multiplier_add = self.avatar.Talent()
skill_multiplier = skill_multiplier + multiplier_add
if (
self.raw_data.avatar.id_ == 1201
and self.raw_data.avatar.rank >= 4
and skill_type == 'Normal'
):
skill_info[2] = skill_info[2] + 1
attack = merged_attr.get('attack', 0)
if self.raw_data.avatar.id_ == 1104:
# 杰帕德天赋加攻
defence = merged_attr['defence']
attack = attack + (defence * 0.35)
logger.info(f'攻击力: {attack}')
damage_add = 0
hp_multiplier = 0
hp_num = 0
if self.raw_data.avatar.id_ in [1205, 1208]:
hp_num = merged_attr['hp']
skill_type_hp = skill_type + '_HP'
if skill_type_hp in skill_dict[str(self.raw_data.avatar.id_)]:
hp_multiplier = self.avatar.Skill_num(
skill_info[4], skill_type_hp
)
else:
hp_multiplier = 0
for attr in self.attribute_bonus:
if attr.__contains__('HpSkillAdd'):
skill_name = attr.split('HpSkillAdd')[0]
if skill_name in (skill_type, skill_info[3]):
logger.info(
f'{skill_name}对{skill_type}有{self.attribute_bonus[attr]}倍率加成'
)
hp_multiplier = (
hp_multiplier + self.attribute_bonus[attr]
)
if skill_type == 'Talent':
if (
self.raw_data.avatar.rank >= 6
and self.raw_data.avatar.id_ == 1205
):
damage_add = hp_num * 0.5
attack = (skill_multiplier * attack) + (hp_multiplier * hp_num)
skill_multiplier = 1
logger.info(f'混伤区: {attack}')
logger.info(f'额外伤害: {damage_add}')
# 模拟 同属性弱点 同等级 的怪物
# 韧性条减伤
enemy_damage_reduction = 0.1
damage_reduction = 1 - enemy_damage_reduction
logger.info(f'韧性区: {damage_reduction}')
# 抗性区
enemy_status_resistance = 0.0
for attr in merged_attr:
if attr.__contains__('ResistancePenetration'):
# 检查是否有某一属性的抗性穿透
attr_name = attr.split('ResistancePenetration')[0]
if attr_name in (self.avatar.avatar_element, 'AllDamage'):
logger.info(f'{attr_name}属性有{merged_attr[attr]}穿透加成')
enemy_status_resistance += merged_attr[attr]
# 检查是否有某一技能属性的抗性穿透
if attr_name.__contains__('_'):
skill_name = attr_name.split('_')[0]
skillattr_name = attr_name.split('_')[1]
if skill_name in (
skill_type,
skill_info[3],
) and skillattr_name in (
self.avatar.avatar_element,
'AllDamage',
):
enemy_status_resistance += merged_attr[attr]
logger.info(
f'{skill_name}对{skillattr_name}属性有{merged_attr[attr]}穿透加成'
)
resistance_area = 1.0 - (0 - enemy_status_resistance)
logger.info(f'抗性区: {resistance_area}')
# 防御区
# 检查是否有 ignore_defence
logger.info('检查是否有 ignore_defence')
ignore_defence = 1.0
for attr in merged_attr:
if attr == 'ignore_defence':
ignore_defence = 1 - merged_attr[attr]
break
logger.info(f'ignore_defence {ignore_defence}')
enemy_defence = (
self.avatar.avatar_level * 10 + 200
) * ignore_defence
defence_multiplier = (self.avatar.avatar_level * 10 + 200) / (
self.avatar.avatar_level * 10 + 200 + enemy_defence
)
logger.info(f'防御区: {defence_multiplier}')
# 增伤区
# TODO: 这里计算只考虑了希儿,需要重写 injury_area = self.avatar.Talent_add()
injury_area = self.avatar.Talent_add()
# 检查是否有对某一个技能的伤害加成
logger.info('检查是否有对某一个技能的伤害加成')
for attr in merged_attr:
if attr.__contains__('DmgAdd'):
attr_name = attr.split('DmgAdd')[0]
if attr_name in (skill_type, skill_info[3]):
logger.info(
f'{attr} 对 {skill_type} 有 {merged_attr[attr]} 伤害加成'
)
injury_area += merged_attr[attr]
# 检查有无符合属性的伤害加成
logger.info('检查球有无符合属性的伤害加成')
element_area = 0
for attr in merged_attr:
if attr.__contains__('AddedRatio'):
attr_name = attr.split('AddedRatio')[0]
if attr_name in (self.avatar.avatar_element, 'AllDamage'):
logger.info(
f'{attr} 对 {self.avatar.avatar_element} '
f'有 {merged_attr[attr]} 伤害加成'
)
if attr_name == self.avatar.avatar_element:
element_area += merged_attr[attr]
injury_area += merged_attr[attr]
injury_area += 1
logger.info(f'增伤区: {injury_area}')
# 易伤区
logger.info('检查是否有易伤加成')
damage_ratio = merged_attr.get('DmgRatio', 0)
# 检查是否有对特定技能的易伤加成
# Talent_DmgRatio
for attr in merged_attr:
if attr.__contains__('_DmgRatio'):
skill_name = attr.split('_')[0]
if skill_name in (skill_type, skill_info[3]):
logger.info(
f'{attr} 对 {skill_type} 有 {merged_attr[attr]} 易伤加成'
)
damage_ratio += merged_attr[attr]
damage_ratio = damage_ratio + 1
logger.info(f'易伤: {damage_ratio}')
# 爆伤区
if skill_type == 'DOT':
critical_damage_base = 0.0
else:
logger.info('检查是否有爆伤加成')
logger.info(f'{merged_attr}')
critical_damage_base = merged_attr.get('CriticalDamageBase', 0)
# 检查是否有对特定技能的爆伤加成
# Ultra_CriticalChance
for attr in merged_attr:
if attr.__contains__('_CriticalDamageBase'):
skill_name = attr.split('_')[0]
if skill_name in (skill_type, skill_info[3]):
logger.info(
f'{attr} 对 {skill_type} 有 '
f'{merged_attr[attr]} 爆伤加成'
)
critical_damage_base += merged_attr[attr]
critical_damage = critical_damage_base + 1
logger.info(f'暴伤: {critical_damage}')
# 暴击区
logger.info('检查是否有暴击加成')
critical_chance_base = merged_attr['CriticalChanceBase']
# 检查是否有对特定技能的爆伤加成
# Ultra_CriticalChance
for attr in merged_attr:
if attr.__contains__('_CriticalChance'):
skill_name = attr.split('_')[0]
if skill_name in (skill_type, skill_info[3]):
logger.info(
f'{attr} 对 {skill_type} 有 '
f'{merged_attr[attr]} 暴击加成'
)
critical_chance_base += merged_attr[attr]
critical_chance_base = min(1, critical_chance_base)
logger.info(f'暴击: {critical_chance_base}')
# 期望伤害
qiwang_damage = (critical_chance_base * critical_damage_base) + 1
logger.info(f'暴击期望: {qiwang_damage}')
damage_cd_z = 0.0
damage_qw_z = 0.0
damage_tz_z = 0.0
attack_tz = 0.0
injury_add = 0.0
critical_damage_add = 0
for i in range(1, skill_info[2] + 1):
injury_add = 0
critical_damage_add = 0
if self.raw_data.avatar.id_ == 1213:
injury_add = self.avatar.Talent()
critical_damage_add = self.avatar.BPSkill()
normal_buff = merged_attr.get('Normal_buff', 0)
if i >= 4:
normal_buff = min(4, int(normal_buff + (i - 3)))
if normal_buff >= 1:
critical_damage_add = normal_buff * critical_damage_add
atk_buff = merged_attr.get('Atk_buff', 0)
atk_buff = min(10, int((i - 1) * (atk_buff + 1)))
injury_add = atk_buff * injury_add
qiwang_damage = (
critical_chance_base
* (critical_damage_base + critical_damage_add)
) + 1
damage_cd = (
attack
* skill_multiplier
* damage_ratio
* (injury_area + injury_add)
* defence_multiplier
* resistance_area
* damage_reduction
* (critical_damage + critical_damage_add)
+ damage_add
)
damage_cd_z += damage_cd
damage_qw = (
attack
* skill_multiplier
* damage_ratio
* (injury_area + injury_add)
* defence_multiplier
* resistance_area
* damage_reduction
* qiwang_damage
+ damage_add
)
damage_qw_z += damage_qw
attr_value_tz: float = self.base_attr.get('attack', 0)
attribute_atk = self.attribute_bonus.get('AttackDelta', 0)
attack_tz = (
attr_value_tz
+ attr_value_tz
* (
1
+ self.attribute_bonus.get('AttackAddedRatio', 0)
+ 2.144
)
+ attribute_atk
)
if self.raw_data.avatar.id_ in [1205, 1208]:
attack_tz = (skill_multiplier * attack_tz) + (
hp_multiplier * hp_num
)
injury_add_tz = 0
if self.avatar.avatar_element == 'Imaginary':
injury_add_tz = 0.12
damage_tz = (
attack_tz
* skill_multiplier
* damage_ratio
* (injury_area + injury_add + injury_add_tz + 2.326)
* defence_multiplier
* resistance_area
* damage_reduction
* (critical_damage + critical_damage_add + 1.594)
* 10
+ damage_add
)
damage_tz_z += damage_tz
if (
self.raw_data.avatar.id_ == 1003
and self.raw_data.avatar.rank >= 6
):
damage_cd_z = damage_cd_z * 1.8
damage_qw_z = damage_qw_z * 1.8
damage_tz_z = damage_tz_z * 1.8
if self.avatar.avatar_element == 'Thunder':
element_area = 0
damage_tz_fj = (
attack_tz
* 0.44
* damage_ratio
* (injury_area + injury_add + 2.326 + element_area)
* defence_multiplier
* resistance_area
* damage_reduction
* (critical_damage + critical_damage_add + 1.594)
* 10
)
damage_tz_z += damage_tz_fj
skill_info_list: List[Union[str, float]] = []
skill_info_list.append(skill_info[1])
skill_info_list.append(damage_cd_z)
skill_info_list.append(damage_qw_z)
skill_info_list.append(damage_tz_z)
logger.info(
f'{skill_info[1]} 暴击伤害: {damage_cd_z} 期望伤害{damage_qw_z}'
)
# 技能类型为防御
if skill_info[0] == 'defence':
defence = merged_attr['defence']
logger.info(f'防御力: {defence}')
defence_multiplier = 0
# 获取技能提供的固定护盾值
if skill_type == 'Normal':
defence_multiplier = self.avatar.Normalnum('Normal_G')
elif skill_type == 'BPSkill':
defence_multiplier = self.avatar.BPSkill_num('BPSkill_G')
elif skill_type == 'Ultra':
defence_multiplier = self.avatar.Ultra_num('Ultra_G')
elif skill_type == 'Talent':
defence_multiplier = self.avatar.Talent_num('Talent_G')
# 检查是否有护盾加成
shield_added_ratio = merged_attr.get('shield_added_ratio', 0)
shield_added = shield_added_ratio + 1
logger.info(f'护盾加成: {shield_added}')
defence_num = (
defence * skill_multiplier + defence_multiplier
) * shield_added
skill_info_list: List[Union[str, float]] = []
skill_info_list.append(skill_info[1])
skill_info_list.append(defence_num)
skill_info_list.append(defence_num)
skill_info_list.append(defence_num)
return skill_info_list

1931
StarRailUID/starrailuid_charinfo/effect/Weapon/Weapon.py
View File

File diff suppressed because it is too large Load Diff

0
StarRailUID/starrailuid_charinfo/effect/Weapon/__init__.py
View File

0
StarRailUID/starrailuid_charinfo/effect/__init__.py
View File

65
StarRailUID/starrailuid_charinfo/effect/utils.py
View File

@ -1,65 +0,0 @@
from typing import Dict
async def merge_attribute(
base_attr: Dict[str, float], attribute_bonus: Dict[str, float]
):
# hp attack defence need base_value and add_value
merged_attr: Dict[str, float] = {}
attr_list = ['attack', 'defence', 'hp', 'speed']
for attribute in attribute_bonus:
if (
attribute.__contains__('Attack')
or attribute.__contains__('Defence')
or attribute.__contains__('HP')
or attribute.__contains__('Speed')
):
if attribute.__contains__('Delta'):
attr = attribute.split('Delta')[0].lower()
if attr in attr_list:
attr_value = merged_attr.get(attr, 0)
merged_attr[attr] = attr_value + attribute_bonus[attribute]
elif attribute.__contains__('AddedRatio'):
attr = attribute.split('AddedRatio')[0].lower()
if attr in attr_list:
attr_value = merged_attr.get(attr, 0)
merged_attr[attr] = attr_value + base_attr[attr] * (
1 + attribute_bonus[attribute]
)
else:
raise Exception(f'attribute error {attribute}')
elif attribute.__contains__('Base'):
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
elif attribute.__contains__('AddedRatio'):
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
elif attribute.__contains__('DmgAdd'):
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
elif attribute.__contains__('DmgRatio'):
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
elif attribute == 'ignore_defence':
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
elif attribute.__contains__('ResistancePenetration'):
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
elif attribute == 'Atk_buff':
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
elif attribute == 'Normal_buff':
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
elif attribute == 'shield_added_ratio':
attr_value = base_attr.get(attribute, 0)
merged_attr[attribute] = attr_value + attribute_bonus[attribute]
else:
continue
for attr in base_attr:
merged_value = merged_attr.get(attr, 0)
if merged_value == 0:
merged_attr[attr] = base_attr[attr]
return merged_attr