661 lines
22 KiB
Python
661 lines
22 KiB
Python
from functools import cache
|
|
import importlib
|
|
from typing import Literal
|
|
|
|
from core.basic.property import CharacterInfo
|
|
from core.basic.skill import Skill
|
|
|
|
from core.basic.equipment import get_equipment, EquEffect, Equ
|
|
|
|
# from core.basic.equipment import equipments
|
|
# from core.basic.skill import Skill, ActiveSkill, PassiveSkill
|
|
from .formula import 增幅计算, 强化技攻, 武器强化计算, 精通计算, 获取基础属性, 耳环计算, 左右计算, 锻造计算
|
|
from .roleinfo import CharacterEquipInfo, get_key_by_value
|
|
# from .property import 精通计算, 角色基础, CharacterInfo
|
|
|
|
class Jade:
|
|
ElementIncrease:float
|
|
'''属性增幅'''
|
|
AttackP:float
|
|
'''攻击强化%'''
|
|
SkillAttack:float
|
|
'''技能攻击力%'''
|
|
|
|
def __init__(self) -> None:
|
|
self.ElementIncrease = 0.0
|
|
self.AttackP = 0.0
|
|
self.SkillAttack = 0.0
|
|
|
|
class Character:
|
|
# region 角色属性
|
|
|
|
STR: float
|
|
"""力量"""
|
|
|
|
INT: float
|
|
"""智力"""
|
|
|
|
Spirit: float
|
|
"""精神"""
|
|
|
|
Vitality: float
|
|
"""体力"""
|
|
|
|
AtkP: float
|
|
"""物理攻击力"""
|
|
|
|
PAtkP: float
|
|
"""物理攻击力%"""
|
|
|
|
AtkM: float
|
|
"""魔法攻击力"""
|
|
PAtkM: float
|
|
"""魔法攻击力%"""
|
|
|
|
AtkI: float
|
|
"""独立攻击力"""
|
|
PAtkI: float
|
|
"""独立攻击力%"""
|
|
|
|
ElementA: dict[str, float]
|
|
"""属性攻击"""
|
|
|
|
ElementIncrease: float
|
|
"""属性增幅"""
|
|
|
|
ElementDB: dict[str, float]
|
|
"""属性强化数值"""
|
|
|
|
ElementR: dict[str, float]
|
|
"""属性抗性数值"""
|
|
|
|
CriticalM: float
|
|
"""魔法暴击"""
|
|
|
|
CriticalP: float
|
|
"""物理暴击"""
|
|
|
|
SkillAttack: float
|
|
"""技能攻击力"""
|
|
|
|
SpeedA: float
|
|
"""攻击速度"""
|
|
|
|
SpeedM: float
|
|
"""移动速度"""
|
|
|
|
SpeedR: float
|
|
"""施放速度"""
|
|
|
|
Hit: float
|
|
"""命中率"""
|
|
|
|
Abnormal: dict[str, bool]
|
|
"""敌人异常状态"""
|
|
|
|
MonsterInfo: dict[str, float]
|
|
|
|
JadeInfo: 'Jade'
|
|
"""辟邪玉加成"""
|
|
|
|
Buffer: float
|
|
"""增益量"""
|
|
|
|
BufferP: float
|
|
"""增益量%"""
|
|
|
|
Attack: float
|
|
"""攻击强化"""
|
|
|
|
AttackP: float
|
|
"""攻击强化%"""
|
|
|
|
# endregion
|
|
|
|
skills: list['Skill'] = []
|
|
# """技能列表"""
|
|
skills_dict: dict[str, 'Skill'] = {}
|
|
# """技能名字对应技能"""
|
|
equVersion: str = '0'
|
|
"""装备版本"""
|
|
charEquipInfo: dict[str, 'CharacterEquipInfo']
|
|
"""装备打造信息"""
|
|
equ_effect: list['EquEffect'] = []
|
|
"""装备效果列表"""
|
|
|
|
# region 角色属性
|
|
buffer: bool = False
|
|
# endregion
|
|
|
|
# region 职业属性
|
|
实际名称: str = ''
|
|
名称: str = ''
|
|
角色: str = ''
|
|
角色类型: str = ''
|
|
职业: str = ''
|
|
武器选项: list[str] = []
|
|
输出类型选项: list[str] = []
|
|
防具精通属性: list[str] = []
|
|
|
|
输出类型: str = '物理百分比'
|
|
|
|
# endregion
|
|
|
|
def __init__(self, equVersion) -> None:
|
|
self.equVersion = equVersion
|
|
# self.equs = get_equ(self.equVersion)
|
|
self.STR = 0
|
|
self.INT = 0
|
|
self.Spirit = 0
|
|
self.Vitality = 0
|
|
self.AtkP = 0
|
|
self.AtkM = 0
|
|
self.AtkI = 0
|
|
self.PAtkP = 1.0
|
|
self.PAtkM = 1.0
|
|
self.PAtkI = 1.0
|
|
self.ElementA = {
|
|
'火': False,
|
|
'冰': False,
|
|
'光': False,
|
|
'暗': False,
|
|
}
|
|
self.ElementDB = {
|
|
'火': 0,
|
|
'冰': 0,
|
|
'光': 0,
|
|
'暗': 0,
|
|
}
|
|
self.ElementR = {
|
|
'火': 0,
|
|
'冰': 0,
|
|
'光': 0,
|
|
'暗': 0,
|
|
}
|
|
self.Abnormal = {
|
|
'出血': False,
|
|
'灼伤': False,
|
|
'感电': False,
|
|
'中毒': False,
|
|
}
|
|
self.CriticalM = 0
|
|
self.CriticalP = 0
|
|
self.SkillAttack = 1
|
|
self.SpeedA = 0
|
|
self.SpeedM = 0
|
|
self.SpeedR = 0
|
|
self.HitP = 0
|
|
self.Hit = 0
|
|
self.MonsterInfo = {
|
|
'DefenseP': 0,
|
|
'DefenseM': 0,
|
|
'火抗': 0,
|
|
'冰抗': 0,
|
|
'光抗': 0,
|
|
'暗抗': 0,
|
|
}
|
|
self.Buffer = 0
|
|
self.BufferP = 1.0
|
|
self.Attack = 0
|
|
self.AttackP = 1.0
|
|
self.ElementIncrease = 1.0
|
|
self.equs = {}
|
|
self.JadeInfo = Jade()
|
|
self.equ_effect = []
|
|
pass
|
|
|
|
# region 角色属性设置
|
|
def SetBaseStatus(self) -> None:
|
|
"""设角色基础属性"""
|
|
# 角色四维
|
|
temp = 获取基础属性(self.角色, self.职业)
|
|
for index, i in enumerate([get_key_by_value(i) for i in ['力量', '体力', '智力', '精神']]):
|
|
setattr(self, i, temp[index])
|
|
# 角色属性抗性
|
|
pass
|
|
# 角色异常抗性
|
|
pass
|
|
|
|
def SetStatus(
|
|
self,
|
|
力量=0,
|
|
智力=0,
|
|
力智=0,
|
|
体力=0,
|
|
精神=0,
|
|
体精=0,
|
|
四维=0,
|
|
物攻=0,
|
|
魔攻=0,
|
|
独立=0,
|
|
三攻=0,
|
|
技攻=0,
|
|
全属强=0,
|
|
火强=0,
|
|
冰强=0,
|
|
光强=0,
|
|
暗强=0,
|
|
全属抗=0,
|
|
火抗=0,
|
|
冰抗=0,
|
|
光抗=0,
|
|
暗抗=0,
|
|
火属性攻击=False,
|
|
冰属性攻击=False,
|
|
光属性攻击=False,
|
|
暗属性攻击=False,
|
|
移速=0,
|
|
攻速=0,
|
|
施放=0,
|
|
命中=0,
|
|
命中率=0,
|
|
物暴=0,
|
|
魔暴=0,
|
|
攻击强化=0,
|
|
攻击强化P=0,
|
|
增益量=0,
|
|
增益量P=0,
|
|
**kwargs,
|
|
) -> None:
|
|
"""设置角色属性"""
|
|
allowed_kwargs = {
|
|
'STR',
|
|
'INT',
|
|
'AtkP',
|
|
'AtkM',
|
|
'AtkI',
|
|
'PAtkP',
|
|
'PAtkM',
|
|
'PAtkI',
|
|
'PATKIPDamage',
|
|
'PDamageC',
|
|
'PSTR',
|
|
'PINT',
|
|
'PDamageB',
|
|
'ElementA',
|
|
'ElementDB',
|
|
'ElementR',
|
|
'CriticalMP',
|
|
'CriticalM',
|
|
'CriticalPP',
|
|
'CriticalP',
|
|
'EquipmentSkillAttack',
|
|
'SkillAttack',
|
|
'SpeedA',
|
|
'SpeedM',
|
|
'SpeedR',
|
|
'HitP',
|
|
'Hit',
|
|
'Attack',
|
|
'AttackP',
|
|
'Buffer',
|
|
'BufferP',
|
|
'Spirit',
|
|
'Vitality'
|
|
}
|
|
for key in kwargs:
|
|
if key not in allowed_kwargs:
|
|
raise ValueError(f'Invalid keyword argument: {key}')
|
|
self.STR += 力量 + kwargs.get('STR', 0) + 四维 + 力智
|
|
self.INT += 智力 + kwargs.get('INT', 0) + 四维 + 力智
|
|
self.Spirit += 精神 + kwargs.get('Spirit', 0) + 四维 + 体精
|
|
self.Vitality += 体力 + kwargs.get('Vitality', 0) + 四维 + 体精
|
|
self.AtkP += 物攻 + kwargs.get('AtkP', 0) + 三攻
|
|
self.AtkM += 魔攻 + kwargs.get('AtkM', 0) + 三攻
|
|
self.AtkI += 独立 + kwargs.get('AtkI', 0) + 三攻
|
|
self.PAtkP *= kwargs.get('PAtkP', 1.0)
|
|
self.PAtkM *= kwargs.get('PAtkM', 1.0)
|
|
self.PAtkI *= kwargs.get('PAtkI', 1.0)
|
|
for elem in ['火', '冰', '光', '暗']:
|
|
self.ElementA[elem] = kwargs.get(f'{elem}属性攻击', False) or kwargs.get('ElementA', {}).get(elem, False) or self.ElementA[elem]
|
|
self.ElementDB[elem] += kwargs.get(f'{elem}强', 0) + kwargs.get('ElementDB', {}).get(elem, 0) + kwargs.get('全属强', 0)
|
|
self.ElementR[elem] += kwargs.get(f'{elem}抗', 0) + kwargs.get('ElementR', {}).get(elem, 0) + kwargs.get('全属抗', 0)
|
|
self.CriticalM += kwargs.get('CriticalM', 0) + 魔暴
|
|
self.CriticalP += kwargs.get('CriticalP', 0) + 物暴
|
|
self.SkillAttack += (1 + 技攻) * (1 + kwargs.get('SkillAttack', 0))
|
|
self.SpeedA += 攻速 + kwargs.get('SpeedA', 0)
|
|
self.SpeedM += 移速 + kwargs.get('SpeedM', 0)
|
|
self.SpeedR += 施放 + kwargs.get('SpeedR', 0)
|
|
self.HitP += 命中率 + kwargs.get('HitP', 0)
|
|
self.Hit += 命中 + kwargs.get('Hit', 0)
|
|
self.Attack += 攻击强化 + kwargs.get('Attack', 0)
|
|
self.AttackP += 攻击强化P + kwargs.get('AttackP', 1.0)
|
|
self.Buffer += 增益量 + kwargs.get('Buffer', 0)
|
|
self.BufferP += 增益量P + kwargs.get('BufferP', 0)
|
|
pass
|
|
|
|
def AddSkillLv(self, min: int, max: int, lv: int, type=-1) -> None:
|
|
"""
|
|
增加技能等级
|
|
type: -1 全部, 0 被动, 1 主动
|
|
"""
|
|
for skill in self.skills:
|
|
if min <= skill.requiredLv <= max:
|
|
if type == -1 or skill.type == type:
|
|
skill.AddLv(lv, self)
|
|
|
|
def SetSkillCD(self, min=1, max=100, cd=0, exclude=[50, 85, 100]) -> None:
|
|
"""
|
|
设置技能CD
|
|
type: -1 全部, 0 被动, 1 主动
|
|
"""
|
|
for skill in self.skills:
|
|
if min <= skill.requiredLv <= max and skill.damage and skill.requiredLv not in exclude:
|
|
skill.CDR *= 1 - cd
|
|
|
|
def GetSkillByName(self, name) -> Skill:
|
|
"""通过技能名获取技能"""
|
|
return self.skills_dict.get(name, None)
|
|
|
|
def GetSkillByID(self, id: str) -> Skill:
|
|
skill = list(filter(lambda x: str(x.id) == id, self.skills))
|
|
"""通过技能ID获取技能"""
|
|
return skill[0] if len(skill) > 0 else None
|
|
|
|
def GetSkillNames(self, type: Literal['active', 'passive', 'all'] = 'all', damage: Literal[True, False, 'all'] = 'all') -> list[str]:
|
|
"""获取技能名字"""
|
|
return [skill.name for skill in self.skills if (type == 'all' or skill.type == type) and (damage == 'all' or skill.damage == damage)]
|
|
|
|
# endregion
|
|
|
|
# region 计算相关
|
|
def SetDetail(self, info: dict[str, dict]) -> None:
|
|
self.charEquipInfo = {}
|
|
"""打造信息导入"""
|
|
for key in info['equips']:
|
|
# 导入部位打造信息、装备信息、贴膜信息
|
|
self.charEquipInfo[key] = CharacterEquipInfo(info['equips'][key], self.equVersion, key)
|
|
"""辟邪玉"""
|
|
self.jadeInfo = {}
|
|
for key in info.get('jades', {}):
|
|
self.jadeInfo[key] = info['jades'][key]
|
|
"""时装"""
|
|
"""杂项"""
|
|
|
|
def getInfo(self):
|
|
"""返回到前端信息"""
|
|
info = {}
|
|
info['role'] = self.role
|
|
info['alter'] = self.name
|
|
info['equVersion'] = self.equVersion
|
|
info['name'] = self.nameCN
|
|
info['weapons'] = self.武器选项
|
|
skillInfo = []
|
|
for skill in self.skills:
|
|
skillInfo.append(
|
|
{
|
|
'id': skill.id,
|
|
'name': skill.name,
|
|
'icon': skill.icon,
|
|
'type': skill.type,
|
|
# 'SPCost': skill.SPCost,
|
|
'learnLv': skill.learnLv,
|
|
'masterLv': skill.masterLv,
|
|
'maxLearnLv': skill.calculate_lv(),
|
|
'maxLv': skill.maxLv,
|
|
# 'TPCost': 0 if not skill.hasTP else skill.TPCost,
|
|
# "masterTPLv":0 if not skill.hasTP else skill.masterTPLv,
|
|
# 'maxTPLv': 0 if not skill.hasTP else skill.TPLearnMax,
|
|
'position': skill.position,
|
|
}
|
|
)
|
|
info['skills'] = skillInfo
|
|
equs = []
|
|
suits = []
|
|
for i in get_equipment(self.equVersion).equs:
|
|
equs.append(i.__dict__)
|
|
for i in get_equipment(self.equVersion).suits:
|
|
suits.append(i.__dict__)
|
|
info['equips'] = equs
|
|
info['suits'] = suits
|
|
enchats = []
|
|
emblems = []
|
|
return info
|
|
|
|
def getBasicInos(self):
|
|
res = []
|
|
attrs = []
|
|
if self.输出类型.includes('物理'):
|
|
attrs = ['STR', 'PSTR', 'AtkP', 'PAtkP', 'CriticalPP', 'CriticalP']
|
|
if self.输出类型.includes('魔法'):
|
|
attrs = ['INT', 'PINT', 'AtkM', 'PAtkM', 'CriticalMP', 'CriticalM']
|
|
for attr in attrs + ['PDamage', 'PDamageC', 'PDamageB', 'SpeedA', 'SpeedM', 'SpeedR']:
|
|
temp = getattr(CharacterInfo, attr)
|
|
res.append(
|
|
{
|
|
'name': temp.name,
|
|
'value': temp.value(getattr(self, attr)),
|
|
'icon': temp.icon,
|
|
}
|
|
)
|
|
keys = ['火', '冰', '光', '暗']
|
|
for index in range(0, 4):
|
|
temp = getattr(CharacterInfo, f'ElementDB{index}')
|
|
res.append(
|
|
{
|
|
'name': temp.name,
|
|
'value': temp.value(getattr(self, 'ElementDB')[keys[index]]),
|
|
'icon': temp.icon,
|
|
}
|
|
)
|
|
temp = getattr(CharacterInfo, f'ElementR{index}')
|
|
res.append(
|
|
{
|
|
'name': temp.name,
|
|
'value': temp.value(getattr(self, 'ElementR')[keys[index]]),
|
|
'icon': temp.icon,
|
|
}
|
|
)
|
|
return res
|
|
|
|
def calc_init(self, setInfo: dict[str, dict]):
|
|
# 打造信息导入
|
|
self.SetDetail(setInfo)
|
|
# 技能等级设置
|
|
self.SetSkills(setInfo.get('skills', {}))
|
|
pass
|
|
|
|
def SetSkills(self, skills: dict[str, dict]):
|
|
"""设置技能等级"""
|
|
for key in skills:
|
|
skill = self.GetSkillByID(key)
|
|
if skill is not None:
|
|
skill.lv = skills[key].get('lv', 0)
|
|
pass
|
|
|
|
def load_skills(self):
|
|
pass
|
|
|
|
def calc_suits(self):
|
|
"""套装效果统计"""
|
|
suitInfo = {}
|
|
equs = get_equipment(self.equVersion)
|
|
# 设置装备和获取对应的套装属性
|
|
for part in self.charEquipInfo.keys():
|
|
# 当前部位的打造
|
|
cur = self.charEquipInfo[part]
|
|
# 当前部位适用调试后的属性
|
|
partEqu = equs.equ_dict.get(cur.id).adapt(cur.adaptation)
|
|
# 设置当前部位的装备
|
|
self.charEquipInfo[part].equInfo = equs.equ_dict.get(cur.id)
|
|
# 套装属性设置
|
|
for suit in partEqu.suit:
|
|
if suitInfo.get(suit, None) is None:
|
|
suitInfo[suit] = {
|
|
'point': 0,
|
|
'count': 0,
|
|
}
|
|
if partEqu.Point == 0:
|
|
suitInfo[suit]['count'] += 1
|
|
else:
|
|
suitInfo[suit]['point'] += partEqu.Point
|
|
# 取得点数最高的套装
|
|
max_point_suit = max((suit for suit in suitInfo if suitInfo[suit]['point'] > 0), key=lambda suit: suitInfo[suit]['point'], default=None)
|
|
# 处理没有点数的老套装
|
|
zero_point_suits = [suit for suit in suitInfo if suitInfo[suit]['point'] == 0]
|
|
suits = zero_point_suits + ([max_point_suit] if max_point_suit is not None else [])
|
|
suits_effect = []
|
|
for suit in suits:
|
|
if suitInfo[suit]['point'] == 0:
|
|
suits_effect += [i.id for i in equs.get_suit_info(suit, 0, suitInfo[suit]['count'])]
|
|
else:
|
|
suits_effect += [i.id for i in equs.get_suit_info(suit, suitInfo[suit]['point'], 0)]
|
|
return suits_effect
|
|
|
|
def calc_basic(self):
|
|
"""计算基础属性:防具精通、增幅、强化等"""
|
|
# 防具精通跟随装备品级
|
|
for part in ['上衣', '头肩', '下装', '腰带', '鞋']:
|
|
cur = self.charEquipInfo[part]
|
|
equ = cur.equInfo
|
|
reinforce = self.charEquipInfo[part].reinforce
|
|
value = 精通计算(115, equ.rarity, reinforce, equ.itemDetailType, self.防具类型)
|
|
for key in self.防具精通属性:
|
|
key = get_key_by_value(key)
|
|
setattr(self, key, getattr(self, key) + value)
|
|
# 115增幅强化品级固定史诗
|
|
for part in self.charEquipInfo.keys():
|
|
cur = self.charEquipInfo[part]
|
|
# 增幅
|
|
if cur.reinforceType == 1:
|
|
# 增幅四维
|
|
value = 增幅计算(115, '史诗', cur.reinforce)
|
|
self.SetStatus(STR=value, INT=value, Spirit=value, Vitality=value)
|
|
# 增幅技攻计算
|
|
value = 强化技攻(cur.reinforce, cur.reinforceType, part)
|
|
self.SetStatus(SkillAttack=value)
|
|
# 武器强化、武器锻造、特殊装备强化额外效果计算
|
|
if part == '武器':
|
|
# 锻造独立计算
|
|
value = 锻造计算(115, '史诗', cur.refine)
|
|
self.SetStatus(AtkI = value)
|
|
# 传世武器强化系数取所有武器的最高的1.12
|
|
if cur.equInfo.categorize == '传世武器':
|
|
value = 武器强化计算(115, '史诗', cur.reinforce,cur.equInfo.itemDetailType,'物理',1.12)
|
|
self.SetStatus(AtkP=value, AtkM=value)
|
|
else:
|
|
# 强化计算
|
|
value = 武器强化计算(115, '史诗', cur.reinforce, cur.equInfo.itemDetailType, '物理')
|
|
self.SetStatus(AtkP=value)
|
|
value = 武器强化计算(115, '史诗', cur.reinforce, cur.equInfo.itemDetailType, '魔法')
|
|
self.SetStatus(AtkM=value)
|
|
pass
|
|
if part == '耳环':
|
|
value = 耳环计算(115, '史诗', cur.reinforce)
|
|
self.SetStatus(AtkM=value, AtkP=value,AtkI=value)
|
|
pass
|
|
if part in ['辅助装备', '魔法石']:
|
|
value = 左右计算(115, '史诗', cur.reinforce)
|
|
self.SetStatus(STR=value, INT=value, Spirit=value, Vitality=value)
|
|
pass
|
|
pass
|
|
|
|
def calc_jade(self):
|
|
"""计算辟邪玉效果"""
|
|
pass
|
|
|
|
def calc(self, setInfo: dict[str, dict]):
|
|
funcs = []
|
|
suits = []
|
|
self.calc_init(setInfo)
|
|
# self.SetDetail(setInfo)
|
|
# 角色基础属性
|
|
self.SetBaseStatus()
|
|
# 辟邪玉计算
|
|
# 精通、增幅、强化计算
|
|
self.calc_basic()
|
|
# 单件效果计算
|
|
# 套装效果列表
|
|
suits_effect = self.calc_suits()
|
|
effects = get_equipment(self.equVersion).funs
|
|
for effect in suits_effect:
|
|
func = effects.suit_func_list.get(str(effect), None)
|
|
func(self)
|
|
# 徽章计算
|
|
# 附魔计算
|
|
|
|
# 技能计算
|
|
skillInfos = []
|
|
for i in self.skills:
|
|
if i.damage and i.lv > 0:
|
|
temp = i.skillInfo()
|
|
skillInfos.append({
|
|
"name":i.name,
|
|
"icon":i.icon,
|
|
"lv":i.lv,
|
|
"data":temp[0],
|
|
"ratio":temp[1],
|
|
"cd":temp[2],
|
|
})
|
|
ratios = self.calc_damage_ration()
|
|
ratio_char_skill = ratios[0] * ratios[1] * ratios[2] * ratios[3] * ratios[4] * ratios[5] * ratios[6] * ratios[7] * ratios[8] * ratios[9] / 10000
|
|
ratuio_equ_skill = ratios[0] * ratios[1] * ratios[3] * ratios[4] * ratios[6] * ratios[7] * ratios[8] * ratios[9] / 10000
|
|
for i in skillInfos:
|
|
i["damage"] = ratio_char_skill * i["data"] * i["ratio"]
|
|
for i in self.equ_effect:
|
|
skillInfos.append({
|
|
"name": i.name,
|
|
"icon": i.icon,
|
|
"lv": 0,
|
|
"data": i.data,
|
|
"ratio": 10.0,
|
|
"cd": i.cd,
|
|
"damage": ratuio_equ_skill * i.data * 10,
|
|
})
|
|
return {
|
|
"skills": skillInfos
|
|
}
|
|
# 技能影响角色的属性，如属强、抗性等
|
|
|
|
def calc_damage_ration(self):
|
|
"""计算最终属性"""
|
|
# 计算最终属性
|
|
# 力/智 攻击力 攻击力%(特效不吃这部分)
|
|
attrs = []
|
|
if self.输出类型 == '物理百分比':
|
|
attrs.extend(['STR', 'AtkP','PAtkP'])
|
|
if self.输出类型 == '魔法百分比':
|
|
attrs.extend(['INT', 'AtkM','PAtkM'])
|
|
if self.输出类型 == '物理固伤':
|
|
attrs.extend(['STR', 'AtkI', 'PAtkI'])
|
|
if self.输出类型 == '魔法固伤':
|
|
attrs.extend(['INT', 'AtkI', 'PAtkI'])
|
|
# 力智系数
|
|
ratio_0 : float = getattr(self, attrs[0]) / 250 + 1
|
|
# 物理/魔法/独立攻击力
|
|
ratio_1 : float = getattr(self, attrs[1])
|
|
# 技能 物理/魔法/独立攻击力%
|
|
ratio_2 : float = getattr(self, attrs[2])
|
|
# 属强系数
|
|
ratio_3 = max(self.ElementDB.values()) * 0.0045 + 1.05
|
|
# 暴击系数
|
|
ratio_4 = 1.5
|
|
# BUFF系数
|
|
ratio_5 = self.buff
|
|
# 技攻系数
|
|
ratio_6 = self.SkillAttack + self.JadeInfo.SkillAttack
|
|
# 攻击强化
|
|
ratio_7 = 1 + self.Attack * (self.AttackP + self.JadeInfo.AttackP)
|
|
# 防御系数
|
|
monster_defense = 506109
|
|
ratio_8 = (1 - monster_defense / (monster_defense + 200 * 100))
|
|
# 杂项 斗神、宠物技能、队友增幅等(技能的属性增幅归属到这部分，因为会加成到特效部分，修复后修改为技能攻击力计算)
|
|
ratio_9 = 1.0 * self.ElementIncrease
|
|
return (ratio_0, ratio_1, ratio_2, ratio_3, ratio_4, ratio_5, ratio_6, ratio_7, ratio_8, ratio_9)
|
|
|
|
# endregion
|
|
|
|
|
|
def createCharacter(alter: str, equVersion: str = '0'):
|
|
character: Character = None
|
|
module_name = 'core.character.' + alter
|
|
if equVersion is None or equVersion == '':
|
|
equVersion = '0'
|
|
try:
|
|
character = importlib.import_module(module_name).classChange(equVersion)
|
|
except Exception as ex:
|
|
print(ex)
|
|
print('create character ' + module_name + ' error.')
|
|
pass
|
|
return character
|