dnftools/dcalc
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Lv110版本源码上传

Browse Source
This commit is contained in:
西瓜°
2024-11-04 15:00:40 +08:00
parent a6dbccdead
commit e029da72e4
6642 changed files with 131203 additions and 136087 deletions
Download Patch File Download Diff File Expand all files Collapse all files
api/core/basic/__init__.py
View File
api/core/basic/buffer/character.py
+37
View File
@@ -0,0 +1,37 @@
from core.basic.character import Character
class Character(Character):
def 技能冷却缩减(self, min: int, max: int, x: float, exc=[],excName=[]) -> None:
if min == 1 and max == 100:
self.冷却缩减 *= (1-x)
for i in self.技能栏:
if i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.名称 not in excName:
if i.是否主动 == 1:
i.CDR *= (1 - x)
def 技能恢复加成(self, min: int, max: int, x: float, exc=[],excName=[]) -> None:
if min == 1 and max == 100:
self.冷却恢复 += x
for i in self.技能栏:
if i.所在等级 >= min and i.所在等级 <= max and i.所在等级 not in exc and i.名称 not in excName:
if i.是否主动 == 1:
i.恢复 += x
def 单技能加成(self, 名称: str, 倍率=1.0, CD=1.0, lv=0) -> None:
i = self.get_skill_by_name(名称)
i.等级加成(lv, char=self)
if i.是否主动 == 1:
i.CDR *= CD
def set_individuation(self, info):
info['char_optiopns'] = []
info['char_optiopns'].append({
"name": '三觉绑定：',
"option": ["一次觉醒","二次觉醒"]
})
def 职业特殊设置(self):
self.get_skill_by_name("三次觉醒").关联技能= [self.get_skill_by_name('一次觉醒').名称 if self.get_individuation(0) == 0 else self.get_skill_by_name('二次觉醒').名称]
pass
api/core/basic/buffer/property.py
+143
View File
@@ -0,0 +1,143 @@
from core.basic.property import CharacterProperty
from core.basic.skill import 技能
class Buffer(CharacterProperty):
def BUFF量():
return 0
def 辅助属性加成(self, buff固定力智=0, buff百分比力智=0.0, buff固定三攻=0, buff百分比三攻=0.0, 觉醒固定力智=0, 觉醒百分比力智=0.0, buff量=0, 百分比buff量=0.0):
pass
pass
class 辅助职业技能(技能):
名称 = ''
备注 = ''
所在等级 = 0
等级上限 = 0
学习间隔 = 3
等级 = 0
基础等级 = 0
是否主动 = 0
站街生效 = 0
等级溢出 = 0
是否启用 = 1
技能序号 = 0
是否有伤害 = 0
def 等级加成(self, x, char={}):
if self.等级 != 0:
if self.等级 + x > self.等级上限:
self.等级 = self.等级上限
if self.基础等级 != self.等级上限:
self.等级溢出 = 1
else:
self.等级 += int(x)
def 结算统计(self, context=None):
return [0, 0, 0, 0]
# 力智 三攻 智力 体精
class 辅助职业被动技能(辅助职业技能):
是否主动 = 0
进图加成 = 0
class 辅助职业主动技能(辅助职业技能):
是否主动 = 1
适用数值 = 0
CD = 0.0
CDR_O = 1.0
CDR = 1.0
恢复 = 1.0
手搓 = False
def 武器CD系数(self, 武器类型, 输出类型):
return 1.0
def 手搓CD(self):
cdr = 0
if self.手搓:
if self.所在等级 >= 15 and self.所在等级 <= 30:
cdr = 0.01 * self.手搓收益
if self.所在等级 >= 35 and self.所在等级 <= 70:
cdr = 0.02 * self.手搓收益
if self.所在等级 >= 75 and self.所在等级 <= 100:
cdr = 0.05 * self.手搓收益
if self.所在等级 in [50, 85, 100]:
cdr = 0.05 * self.手搓收益
return cdr
def 等效CD(self, **argv):
# 武器类型 输出类型 额外CDR 手搓收益 恢复
武器类型 = argv.get('武器类型', '')
输出类型 = argv.get('输出类型', '')
额外CDR = argv.get('额外CDR', 1.0)
# 手搓收益 = argv.get('手搓收益', 1.0)
面板显示 = argv.get('面板显示', False)
额外恢复 = argv.get('额外恢复', 0)
cdr = self.手搓CD()
return round(max(self.CD * self.CDR * 额外CDR / ((self.恢复 + 额外恢复) if not 面板显示 else 1) * (self.武器CD系数(武器类型, 输出类型) - (cdr if not 面板显示 else 0)), self.CD * 0.3)*self.CDR_O, 1)
class 辅助职业觉醒技能(辅助职业主动技能):
所在等级 = 50
等级精通 = 30
等级上限 = 50
等级精通 = 40
基础等级 = 14
一觉力智 = 0
一觉力智per = 1.0
一觉力智perTotal = 1.0
# 28 原力智 941 测试修改为 939
力智 = [0, 43, 57, 74, 91, 111, 131, 153, 176, 201, 228, 255, 284, 315, 346, 379, 414, 449, 487, 526, 567, 608, 651, 696, 741, 789, 838, 888,
939, 993, 1047, 1103, 1160, 1219, 1278, 1340, 1403, 1467, 1533, 1600, 1668, 1736, 1804, 1872, 1940, 2008, 2076, 2144, 2212, 2280, 2348]
def 结算统计(self, context: Buffer, compute_3rd_awake=False):
buffer_power = context.BUFF量()
三次觉醒 = context.get_skill_by_name("三次觉醒")
if not context.check_fun_by_id(20064) and not compute_3rd_awake and self.名称 in 三次觉醒.关联技能:
return [0] * 5
旧词条力智 = ((self.适用数值/750 + 1) *
(self.力智[self.等级] + self.一觉力智))*self.一觉力智per
新词条力智 = (((self.适用数值 + 5250) / 750 + 1) *
(buffer_power + 5000) * 0.000025 * self.力智[self.等级]) if buffer_power > 0 else 0
力智 = (旧词条力智 + 新词条力智)*self.一觉力智perTotal
return [力智, 0, 0, 0, 0]
# 力智、三攻、智力、体力、精神
class 辅助职业三觉技能(辅助职业主动技能):
所在等级 = 100
等级精通 = 30
等级上限 = 40
学习间隔 = 5
绑定一觉力智per = 1.08
绑定二觉力智per = 0.23
关联技能 = []
def 结算统计(self, context: Buffer):
awake = context.get_skill_by_name('一次觉醒')
if awake.是否启用:
values = awake.结算统计(context, True)
倍率 = self.加成倍率(awake.名称 in self.关联技能)
return [int(round(i * 倍率)) for i in values]
return [0] * 5
def 加成倍率(self, bind_awake):
if bind_awake:
return round(1.08 + self.等级 * 0.01, 2)
else:
return round(0.23 + self.等级 * 0.01, 2)
BUFF影响技能 = ['勇气祝福', '勇气圣歌', '荣誉祝福', '禁忌诅咒', '死命召唤']
api/core/basic/character.py
+3213
View File
File diff suppressed because it is too large Load Diff
api/core/basic/equipment.py
+789
View File
@@ -0,0 +1,789 @@
from copy import deepcopy
import importlib
import json
import os
import sys
from decimal import Decimal
from pyclbr import Function
from typing import Dict, List
from routers.database.db import Session,get_engine,EquData,EntryData,SuitData
try:
os.chdir(os.path.dirname(sys.argv[0]))
except Exception:
pass
def parse_to_number_list(info: str):
return [] if info == "" or info is None else [int(i) for i in info.split(",")]
def get_eq_info_data(version):
# equ_info = {}
# fileName = "./dataFiles/equ-data-{}.json".format(version)
# try:
# with open(fileName, encoding='utf-8') as fp:
# equ_info = json.load(fp)
# except Exception:
# with open("./dataFiles/equ-data-3.json", encoding='utf-8') as fp:
# equ_info = json.load(fp)
equ_info = {}
engine = get_engine(version)
with Session(bind=engine) as session:
for equ in session.query(EquData).all():
equ.可选属性 = parse_to_number_list(equ.可选属性)
equ.固有属性 = parse_to_number_list(equ.固有属性)
equ.成长属性 = parse_to_number_list(equ.成长属性)
equ.特性 = parse_to_number_list(equ.特性)
equ.suits = parse_to_number_list(equ.suits)
equ_info[str(equ.id)] = equ.__dict__
for i in list(filter(lambda x: x.startswith("_"), equ.__dict__.keys())):
del equ_info[str(equ.id)][i]
engine.dispose()
cus = []
for key in equ_info.keys():
if (('融合石' not in equ_info[key]["类型"]))and (len(equ_info[key]["可选属性"]) > 0):
cus.append(key)
for key in cus:
equ_info[str(100000+int(key))] = deepcopy(equ_info[key])
equ_info[str(100000+int(key))]["名称"] += " - 对照"
# equ_info[str(10000+int(key))]["order"] += 100000
return equ_info
def get_suit_info_data(version):
suit_info = []
engine = get_engine(version)
with Session(bind=engine) as session:
for suit in session.query(SuitData).all():
temp = suit.__dict__
for i in list(filter(lambda x: x.startswith("_"), suit.__dict__.keys())):
del temp[i]
if temp['compatibility'] is None:
temp['compatibility'] = []
else:
temp['compatibility'] = parse_to_number_list(
temp['compatibility'])
suit_info.append(temp)
pass
engine.dispose()
return suit_info
def get_entry_info_data(version):
# entry_info = {}
# fileName = "./dataFiles/entry-data-{}.json".format(version)
# try:
# with open(fileName, encoding='utf-8') as fp:
# entry_info = json.load(fp)
# except Exception:
# with open("./dataFiles/entry-data-0.json", encoding='utf-8') as fp:
# entry_info = json.load(fp)
entry_info = {}
engine = get_engine(version)
with Session(bind=engine) as session:
for entry in session.query(EntryData).all():
entry_info[str(entry.id)] = entry.__dict__
entry_info[str(entry.id)]["props"] = entry.props.split("<br/>")
entry_info[str(entry.id)]["additional"] = json.loads(entry.additional) if entry.additional != "" and entry.additional is not None else []
for i in list(filter(lambda x: x.startswith("_"), entry.__dict__.keys())):
del entry_info[str(entry.id)][i]
pass
engine.dispose()
# if int(version) == 0:
for item in entry_info:
props = entry_info[item]['props']
if len(entry_info[item]['additional']) > 0:
entry_info[item]["template"] = ("<br/>").join(entry_info[item]["props"])
entry_info[item]["params"] = entry_info[item]['additional']
props = ("<br/>").join(entry_info[item]["props"])
for index,param in enumerate(entry_info[item]['additional'][0]):
props = props.replace("{"+str(index)+"}",str(param))
entry_info[item]["props"] = props.split("<br/>")
else:
import re
res = re.findall(r'攻击强化[\s]\+\d+.?\d+%',
("<br/>").join(props).replace(",", ""))
if len(res) > 0:
params = []
template = ("<br/>").join(props).replace(",", "")
for index in range(0, len(res)):
temp = res[index].replace("攻击强化+", "攻击强化 +")
params.append(float(re.findall(r'\d+\.?\d*', temp)[0]))
template = template.replace(temp, '攻击强化 {'+str(index)+'}')
entry_info[item]["template"] = template
entry_info[item]["params"] = params
entry_info[item]["filter"] = entry_info[item].get("filter", None)
del entry_info[item]['additional']
return entry_info
class equipment:
名称 = ''
等级 = ''
品质 = ''
部位 = ''
类型 = ''
力量 = 0
智力 = 0
体力 = 0
精神 = 0
物理攻击力 = 0
魔法攻击力 = 0
独立攻击力 = 0
固有属性 = []
成长属性 = []
可选属性 = []
物理暴击率 = 0
魔法暴击率 = 0
神 = False
id = 0
suits = ''
def __init__(self, info={}):
# 读取json获取装备属性
self.__dict__.update(info)
# 计算防具转甲基础
if self.类型 in ['布甲', '皮甲', '轻甲', '重甲', '板甲']:
设置防具基础(self)
if self.部位 == "武器":
设置武器基础(self)
if self.类型 in ['首饰', '特殊装备']:
设置其他基础(self)
# def __iter__(self):
# yield from [getattr(self, i, 0) for i in ('物理攻击力', '魔法攻击力', '独立攻击力', '三攻', '力量', '智力', '力智', '体力', '精神', '体精', '四维', '物理暴击率', '魔法暴击率', '暴击率', '攻击速度', '施放速度', '移动速度', '三速')]
防具基础 = {
"105-史诗-上衣": (141, 141, 141, 141, 1597, 0),
"105-史诗-头肩": (132, 132, 132, 132, 1065, 0),
"105-史诗-下装": (141, 141, 141, 141, 1331, 0),
"105-史诗-鞋": (124, 124, 124, 124, 799, 0),
"105-史诗-腰带": (124, 124, 124, 124, 532, 0),
"105-神话-上衣": (142, 142, 142, 142, 1637, 0),
"105-传说-上衣": (140, 140, 140, 140, 1558, 0),
"105-传说-头肩": (132, 132, 132, 132, 1038, 0),
"105-传说-下装": (140, 140, 140, 140, 1298, 0),
"105-传说-鞋": (124, 124, 124, 124, 779, 0),
"105-传说-腰带": (124, 124, 124, 124, 519, 0),
"110-史诗-上衣": (142, 142, 142, 142, 1663, 0),
"110-史诗-头肩": (134, 134, 134, 134, 1109, 0),
"110-史诗-下装": (142, 142, 142, 142, 1386, 0),
"110-史诗-鞋": (125, 125, 125, 125, 832, 0),
"110-史诗-腰带": (125, 125, 125, 125, 554, 0),
}
武器基础 = {
"110-史诗-短剑": (0, 88, 0, 0, 1277, 1547, 864),
"110-史诗-太刀": (88, 133, 0, 0, 1277, 1411, 864),
"110-史诗-钝器": (133, 0, 0, 0, 1478, 1277, 864),
"110-史诗-巨剑": (88, 0, 0, 0, 1614, 1210, 864),
"110-史诗-光剑": (88, 0, 0, 0, 1251, 1210, 864),
"110-史诗-手套": (0, 88, 0, 0, 1277, 1547, 864),
"110-史诗-臂铠": (133, 0, 0, 0, 1614, 1210, 864),
"110-史诗-爪": (88, 44, 0, 0, 1344, 1344, 864),
"110-史诗-拳套": (88, 0, 0, 0, 1411, 1277, 864),
"110-史诗-东方棍": (88, 133, 0, 0, 1277, 1344, 864),
"110-史诗-左轮枪": (88, 0, 0, 0, 1362, 1145, 864),
"110-史诗-自动手枪": (0, 88, 0, 0, 955, 1400, 864),
"110-史诗-步枪": (88, 133, 0, 0, 1463, 1273, 864),
"110-史诗-手炮": (133, 0, 0, 0, 1591, 955, 864),
"110-史诗-手弩": (88, 88, 0, 0, 1145, 1273, 864),
"110-史诗-矛": (133, 0, 0, 0, 1614, 1143, 864),
"110-史诗-棍棒": (120, 120, 0, 0, 1452, 1210, 864),
"110-史诗-魔杖": (0, 133, 0, 0, 1210, 1478, 864),
"110-史诗-法杖": (0, 88, 0, 0, 1277, 1614, 864),
"110-史诗-扫把": (0, 88, 0, 0, 1344, 1478, 864),
"110-史诗-十字架": (0, 88, 106, 106, 1344, 1277, 864),
"110-史诗-念珠": (0, 133, 0, 0, 1210, 1547, 864),
"110-史诗-图腾": (133, 0, 0, 0, 1411, 1210, 864),
"110-史诗-镰刀": (88, 88, 0, 0, 1277, 1344, 864),
"110-史诗-战斧": (88, 0, 0, 0, 1614, 1143, 864),
"110-史诗-匕首": (133, 0, 0, 0, 1283, 1210, 864),
"110-史诗-双剑": (88, 0, 0, 0, 1474, 1076, 864),
"110-史诗-手杖": (0, 88, 0, 0, 1196, 1547, 864),
"110-史诗-苦无": (0, 133, 0, 0, 1133, 1478, 864),
"110-史诗-长枪": (133, 0, 0, 0, 1411, 1210, 864),
"110-史诗-战戟": (88, 0, 0, 0, 1614, 1143, 864),
"110-史诗-光枪": (88, 88, 0, 0, 1277, 1547, 864),
"110-史诗-暗矛": (88, 133, 0, 0, 1277, 1411, 864),
"110-史诗-长刀": (88, 88, 0, 0, 1452, 1210, 864),
"110-史诗-小太刀": (88, 44, 0, 0, 1344, 1344, 864),
"110-史诗-重剑": (88, 0, 0, 0, 1614, 1210, 864),
"110-史诗-源力剑": (0, 88, 0, 0, 1277, 1547, 864),
"110-史诗-神弦弓": (0, 0, 0, 106, 1344, 1277, 864),
"110-史诗-玄机弓": (88, 88, 0, 0, 1452, 1210, 864),
"105-史诗-短剑": (0, 85, 0, 0, 1222, 1480, 818),
"105-史诗-太刀": (85, 128, 0, 0, 1222, 1351, 818),
"105-史诗-钝器": (128, 0, 0, 0, 1416, 1222, 818),
"105-史诗-巨剑": (85, 0, 0, 0, 1544, 1158, 818),
"105-史诗-光剑": (85, 0, 0, 0, 1197, 1158, 818),
"105-史诗-手套": (0, 85, 0, 0, 1222, 1480, 818),
"105-史诗-臂铠": (128, 0, 0, 0, 1544, 1158, 818),
"105-史诗-爪": (85, 43, 0, 0, 1287, 1287, 818),
"105-史诗-拳套": (85, 0, 0, 0, 1351, 1222, 818),
"105-史诗-东方棍": (85, 128, 0, 0, 1222, 1287, 818),
"105-史诗-左轮枪": (85, 0, 0, 0, 1300, 1093, 818),
"105-史诗-自动手枪": (0, 85, 0, 0, 911, 1337, 818),
"105-史诗-步枪": (85, 128, 0, 0, 1397, 1214, 818),
"105-史诗-手炮": (128, 0, 0, 0, 1518, 911, 818),
"105-史诗-手弩": (85, 85, 0, 0, 1093, 1214, 818),
"105-史诗-矛": (128, 0, 0, 0, 1544, 1093, 818),
"105-史诗-棍棒": (114, 114, 0, 0, 1389, 1158, 818),
"105-史诗-魔杖": (0, 128, 0, 0, 1158, 1416, 818),
"105-史诗-法杖": (0, 85, 0, 0, 1222, 1544, 818),
"105-史诗-扫把": (0, 85, 0, 0, 1287, 1416, 818),
"105-史诗-十字架": (0, 85, 101, 101, 1287, 1222, 818),
"105-史诗-念珠": (0, 128, 0, 0, 1158, 1480, 818),
"105-史诗-图腾": (128, 0, 0, 0, 1351, 1158, 818),
"105-史诗-镰刀": (85, 85, 0, 0, 1222, 1287, 818),
"105-史诗-战斧": (85, 0, 0, 0, 1544, 1093, 818),
"105-史诗-匕首": (128, 0, 0, 0, 1224, 1158, 818),
"105-史诗-双剑": (85, 0, 0, 0, 1408, 1030, 818),
"105-史诗-手杖": (0, 85, 0, 0, 1141, 1480, 818),
"105-史诗-苦无": (0, 128, 0, 0, 1081, 1416, 818),
"105-史诗-长枪": (128, 0, 0, 0, 1351, 1158, 818),
"105-史诗-战戟": (85, 0, 0, 0, 1544, 1093, 818),
"105-史诗-光枪": (85, 85, 0, 0, 1222, 1480, 818),
"105-史诗-暗矛": (85, 128, 0, 0, 1222, 1351, 818),
"105-史诗-长刀": (85, 85, 0, 0, 1389, 1158, 818),
"105-史诗-小太刀": (85, 43, 0, 0, 1287, 1287, 818),
"105-史诗-重剑": (85, 0, 0, 0, 1544, 1158, 818),
"105-史诗-源力剑": (0, 85, 0, 0, 1222, 1480, 818),
"105-史诗-神弦弓": (0, 85, 0, 101, 1287, 1222, 818),
"105-史诗-玄机弓": (85, 85, 0, 0, 1389, 1158, 818),
# "105-史诗-神弦弓": (0, 0, 0, 101, 1287, 1222, 818),
# "105-史诗-玄机弓": (0, 0, 0, 101, 1287, 1222, 818),
"105-传说-短剑": (0, 81, 0, 0, 1167, 1412, 766),
"105-传说-太刀": (81, 0, 0, 0, 1167, 1289, 766),
"105-传说-钝器": (122, 0, 0, 0, 1351, 1167, 766),
"105-传说-巨剑": (81, 122, 0, 0, 1474, 1106, 766),
"105-传说-光剑": (81, 0, 0, 0, 1142, 1106, 766),
"105-传说-手套": (0, 81, 0, 0, 1167, 1412, 766),
"105-传说-臂铠": (122, 0, 0, 0, 1474, 1106, 766),
"105-传说-爪": (81, 41, 0, 0, 1229, 1229, 766),
"105-传说-拳套": (81, 0, 0, 0, 1289, 1167, 766),
"105-传说-东方棍": (81, 122, 0, 0, 1167, 1229, 766),
"105-传说-左轮枪": (81, 0, 0, 0, 1239, 1042, 766),
"105-传说-自动手枪": (0, 81, 0, 0, 868, 1274, 766),
"105-传说-步枪": (81, 122, 0, 0, 1331, 1157, 766),
"105-传说-手炮": (122, 0, 0, 0, 1448, 868, 766),
"105-传说-手弩": (81, 81, 0, 0, 1042, 1157, 766),
"105-传说-矛": (110, 110, 0, 0, 1327, 1106, 766),
"105-传说-棍棒": (122, 0, 0, 0, 1474, 1044, 766),
"105-传说-魔杖": (0, 122, 0, 0, 1106, 1351, 766),
"105-传说-法杖": (0, 81, 0, 0, 1167, 1474, 766),
"105-传说-扫把": (0, 81, 0, 0, 1229, 1351, 766),
"105-传说-十字架": (0, 81, 99, 99, 1229, 1167, 766),
"105-传说-念珠": (0, 122, 0, 0, 1106, 1412, 766),
"105-传说-图腾": (122, 0, 0, 0, 1289, 1106, 766),
"105-传说-镰刀": (81, 81, 0, 0, 1167, 1229, 766),
"105-传说-战斧": (81, 0, 0, 0, 1474, 1044, 766),
"105-传说-匕首": (122, 0, 0, 0, 1167, 1106, 766),
"105-传说-双剑": (81, 0, 0, 0, 1343, 982, 766),
"105-传说-手杖": (0, 81, 0, 0, 1087, 1412, 766),
"105-传说-苦无": (0, 122, 0, 0, 1030, 1351, 766),
"105-传说-长枪": (122, 0, 0, 0, 1289, 1106, 766),
"105-传说-战戟": (81, 0, 0, 0, 1474, 1044, 766),
"105-传说-光枪": (81, 81, 0, 0, 1167, 1412, 766),
"105-传说-暗矛": (81, 122, 0, 0, 1167, 1289, 766),
"105-传说-长刀": (81, 81, 0, 0, 1327, 1106, 766),
"105-传说-小太刀": (81, 41, 0, 0, 1229, 1229, 766),
"105-传说-重剑": (81, 0, 0, 0, 1474, 1106, 766),
"105-传说-源力剑": (0, 81, 0, 0, 1167, 1412, 766),
"105-传说-玄机弓": (0, 81, 0, 0, 1327, 1106, 766),
"110-史诗-强攻弩": (88, 0, 0, 0, 1614, 1210, 864),
"105-史诗-强攻弩": (85, 0, 0, 0, 1544, 1158, 818),
"105-传说-强攻弩": (81, 0, 0, 0, 1474, 1106, 766),
"110-史诗-妖影弓": (88, 88, 0, 0, 1277, 1344, 864),
"105-史诗-妖影弓": (85, 85, 0, 0, 1222, 1287, 818),
"105-传说-妖影弓": (81, 81, 0, 0, 1167, 1229, 766)
}
其他基础 = {
"110-史诗-项链": (100, 151, 100, 227, 0, 11159),
"110-史诗-戒指": (176, 176, 100, 100, 0, 4470),
"110-史诗-手镯": (151, 100, 227, 100, 0, 6706),
"110-史诗-辅助装备": (150, 150, 150, 150, 0, 0),
"110-史诗-魔法石": (175, 175, 175, 175, 0, 0),
"110-史诗-耳环": (175, 175, 175, 175, 0, 0),
"105-史诗-项链": (100, 150, 100, 222, 0, 10736),
"105-史诗-戒指": (173, 173, 100, 100, 0, 4294),
"105-史诗-手镯": (150, 100, 222, 100, 0, 6600),
"105-史诗-辅助装备": (149, 149, 149, 149, 0, 0),
"105-史诗-魔法石": (172, 172, 172, 172, 0, 0),
"105-史诗-耳环": (172, 172, 172, 172, 0, 0)
}
def 设置其他基础(装备):
b = 其他基础.get('{}-{}-{}'.format(110 if 装备.神 else 装备.等级, 装备.品质, 装备.部位),
(0, 0, 0, 0, 0))
attr = ['力量', '智力', '体力', '精神']
for i in range(len(attr)):
if (b[i] != 0):
setattr(装备, attr[i], round((b[i]) * Decimal(1.0)))
pass
def 设置武器基础(装备):
# 装备.力量 = {}
# 装备.智力 = {}
# 装备.体力 = {}
# 装备.精神 = {}
# 装备.物理攻击力 = {}
# 装备.魔法攻击力 = {}
# 装备.独立攻击力 = {}
b = 武器基础.get('{}-{}-{}'.format(110 if 装备.神 else 装备.等级, 装备.品质, 装备.类型),
(0, 0, 0, 0, 0, 0, 0, 0))
attr = ['力量', '智力', '体力', '精神', '物理攻击力', '魔法攻击力', '独立攻击力']
for i in range(len(attr)):
if (b[i] != 0):
setattr(装备, attr[i], round((b[i]) * Decimal(1.0)))
def 设置防具基础(装备):
b = 防具基础.get('{}-{}-{}'.format(110 if 装备.神 else 装备.等级,
装备.品质, 装备.部位), (0, 0, 0, 0))
attr = ['力量', '智力', '体力', '精神']
for j in range(len(attr)):
setattr(装备, attr[j], round((b[j]) * Decimal(1.0)))
# 词条计算优先级，默认为100，特殊需求手动设置优先级
priority = {
# 蓝拳CP-无色消耗
691: 0,
# 锁血上限
1248: 0, 1438: 0, 868: 0.5, 935: 0,
1620: 0,
# 无色结算顺序
20067: 2,
20069: 2,
1147: 1,
878: 998,
1102: 999,
1119: 1000,
1120: 1000,
1573: 1000,
1589: 1000,
1598: 1000,
1609: 1000,
1611: 1000,
1614: 1000,
1670: 1000,
1692: 1000,
# MP结算顺序
1183: 998,
1736: 998,
988: 999,
316: 998,
1588: 998,
1662: 998,
20029: 998,
20030: 998,
20022: 998,
# 属强结算
1275: 1999, 1034: 1999, 1035: 1999, 1036: 1999, 1037: 1999, 975: 3000, 976: 1999.5, 1252: 3001, 1250: 3002, 1251: 3002, 1430: 3002, 1458: 3002, 235: 3000, 1689: 3000, 20045: 3000,
# 异常赋予结算顺序
190: 1, 799: 1, 810: 1, 916: 1, 900: 1, 968: 1, 977: 1, 1228: 1, 1192: 1, 1184: 1, 1333: 1, 1334: 1, 1335: 1, 1337: 1, 1338: 1, 1315: 1, 1300: 1, 1310: 1, 598: 1, 873: 1, 995: 1, 996: 1, 952: 1, 940: 1, 942: 1, 943: 1, 793: 1, 794: 1, 795: 1, 796: 1, 797: 1, 1123: 1, 1071: 1, 1072: 1, 1073: 1, 1074: 1, 59: 1, 60: 1, 61: 1, 62: 1, 63: 1, 64: 1, 65: 1, 66: 1, 67: 1, 68: 1, 69: 1, 70: 1, 71: 1, 177: 1, 178: 1, 179: 1, 180: 1, 1213: 2, 1207: 2, 1011: 1, 919: 2, 920: 1, 1219: 1, 924: 1, 1053: 1, 892: 1, 1197: 1, 842: 1, 839: 1, 1210: 3, 1276: 101, 1294: 1, 1340: 3, 1341: 1, 1342: 2, 1356: 1, 1357: 1, 1358: 1, 1343: 3, 966: 3, 1363: 1, 1364: 1, 1365: 1, 1366: 1, 1221: 2, 992: 3,
1273: 1002, 1269: 4002, 1431: 4002, 1432: 4002, 1459: 4002, 1460: 4002, 1246: 4003, 198: 3000, 199: 3000, 203: 1, 204: 3000, 205: 3000, 1605: 4003, 1706: 3000, 1618: 4003, 1751: 3000, 1306: 3000, 20003: 4003,
# 睡眠结算顺序
934: 1, 1272: 1, 1271: 2004, 835: 2000, 305: 2000, 1746: 2000, 1591: 2000, 1592: 2000,
# CD耳环
991: 1000,
# 属性抗性
1297: 1999, 1316: 2000, 1317: 2000, 1239: 2000, 1253: 2000, 1148: 2000, 1387: 2000, 1256: 2000, 1257: 2000, 1012: 2000, 1013: 1999, 1014: 1999, 1015: 1999, 1016: 1999, 1002: 2000, 1028: 2000, 1029: 2000, 1030: 2000, 1031: 2000, 182: 3500, 342: 2000, 344: 3500, 350: 3500, 356: 3500, 301: 2000, 302: 2000, 303: 2000, 304: 2000, 352: 2000, 353: 2000, 354: 2000, 355: 2000, 1699: 2000, 1688: 2000,
851: 2000, 846: 2000, 844: 2000, 849: 2000, 1022: 2000, 1385: 2000, 1386: 2000,
# 睡眠
1132: 2000, 265: 2000, 351: 2000, 20011: 20000,
1566: 0, 1558: 3002, 1491: 1, 1492: 1, 1493: 1, 1494: 1, 1559: 4002, 1560: 4002, 1515: 2000, 1513: 2000, 1514: 2000,
1637: 2001,
# TP
1451: 2000,
1574: 2001, 1680: 2001
}
class equipment_list():
def __init__(self, version: str) -> None:
self.version = version
self.info = get_eq_info_data(version)
self.entry_info = get_entry_info_data(version)
self.suit_info = get_suit_info_data(version)
self.parts = set()
self.load_equ()
self.info_sj = deepcopy(self.info)
self.load_equ_sj()
def load_equ(self) -> None:
self.equ_list = {}
self.equ_id = {}
self.equ_tuple = ()
self.equ_id_tuple = ()
for k in self.info.keys():
temp = equipment(self.info[k])
i = int(k)
self.equ_list[i] = temp
self.equ_id[temp.名称] = i
self.equ_tuple += (temp, )
self.equ_id_tuple += (i, )
self.parts.add(temp.部位)
def load_equ_sj(self) -> None:
self.equ_list_sj = {}
self.equ_id_sj = {}
self.equ_tuple_sj = ()
self.equ_id_tuple_sj = ()
for k in self.info_sj.keys():
# 特殊处理，游戏中取的110装备基础，增幅等按照105装备等级计算
# if self.info_sj[k]["等级"] == 105 and self.info_sj[k]["品质"] == "史诗":
# self.info_sj[k]["等级"] = 110
if self.info_sj[k]["品质"] == "史诗":
self.info_sj[k]["神"] = True
info = self.info_sj[k]
temp = equipment(info)
attr = ['力量', '智力', '体力', '精神', '物理攻击力', '魔法攻击力', '独立攻击力']
for i in attr:
self.info_sj[k][i] = getattr(temp, i)
i = int(k)
self.equ_list_sj[i] = temp
self.equ_id_sj[temp.名称] = i
self.equ_tuple_sj += (temp, )
self.equ_id_tuple_sj += (i, )
self.parts.add(temp.部位)
def get_json(self, i):
temp = self.info[str(i)]
return {
"id": int(i),
"name": temp["名称"],
"icon": temp["icon"],
"part": temp["部位"],
'type': temp['类型'],
"stable": temp["固有属性"],
"alternative": temp["可选属性"] if "可选属性" in temp else [],
"order": temp["order"] if "order" in temp else 0,
"features": temp["特性"] if "特性" in temp else [],
"rarity": temp["品质"]
}
def get_equ_by_id(self, id, sj=False) -> equipment:
if sj:
return self.equ_list_sj.get(int(id), equipment())
else:
return self.equ_list.get(int(id), equipment())
def get_equ_by_name(self, name, sj=False) -> equipment:
return self.get_equ_by_id(self.equ_id.get(name, 0), sj)
def get_id_by_name(self, name) -> int:
return self.equ_id.get(name, 0)
def get_equ_list(self) -> List[equipment]:
return self.equ_tuple
def get_equ_id_list(self) -> List[int]:
return self.equ_id_tuple
def get_entry_atk_by_id(self, id) -> int:
return self.entry_info.get(str(id), {}).get('attack', 0)
def get_entry_buff_by_id(self, id) -> int:
return self.entry_info.get(str(id), {}).get('buff', 0)
def get_entry_params_by_id(self, id) -> int:
return self.entry_info.get(str(id), {}).get('params', [])
def get_entry_template_by_id(self, id) -> int:
return self.entry_info.get(str(id), {}).get('template', None)
def get_damagelist_by_idlist(self, idlist, customize: Dict[str, List[int]] = {}, fusion_list=[], merge: Dict[str, List[int]] = {}) -> List[tuple]:
damagelist = [] # (部位, 序号, 基础伤害,类型,index)
# 1 有成长 -1 无成长
# 序号说明
# 0~9 成长属性
# 10~19 固定属性
# 20~29 贴膜属性
# 30~39 词条融合
for id in idlist:
i = self.get_equ_by_id(id)
temp = []
if len(i.可选属性) > 0:
temp = customize.get(str(id), [])
num = 0
for k in i.成长属性 + temp:
damagelist.append((
i.部位,
num,
self.get_entry_atk_by_id(k),
self.get_entry_buff_by_id(k),
self.get_entry_params_by_id(k),
1,
k
)),
num += 1
pass
if i.部位 == "武器":
num = 30
for j in merge:
damagelist.append((
'武器',
num,
self.get_entry_atk_by_id(j),
self.get_entry_buff_by_id(j),
self.get_entry_params_by_id(j),
-1,
j
))
num += 1
for id in fusion_list:
i = self.get_equ_by_id(id)
temp = []
if len(i.可选属性) > 0:
temp = list(filter(lambda x:x>0,customize.get(str(id), [])))
num = 20
for k in i.固有属性 + temp:
damagelist.append((
i.部位,
num,
self.get_entry_atk_by_id(k),
self.get_entry_buff_by_id(k),
self.get_entry_params_by_id(k),
-1,
k
))
num += 1
return damagelist
def get_fusion_by_idlist(self, idlist) -> List[tuple]:
damagelist = [] # (部位, 序号, 基础伤害)
for id in idlist:
i = self.get_equ_by_id(id)
num = 0
for k in i.固有属性:
damagelist.append((
i.部位,
num,
self.get_entry_atk_by_id(k),
self.get_entry_buff_by_id(k)))
num += 1
pass
return damagelist
def set_func_chose(self, choseinfo) -> None:
try:
entry = importlib.import_module(
"core.equipment.entry_{}".format(self.version))
except Exception:
entry = importlib.import_module("core.equipment.entry_0")
variable_set = entry.variable_set
for i in choseinfo.keys():
id = int(i)
if id >= 20000 and id in variable_set.keys(): # 额外选项，参数设置
try:
variable_set[id](choseinfo[i])
except Exception:
pass
# else:
# id 错误
def get_func_by_id(self, id) -> Function:
try:
entry = importlib.import_module(
"core.equipment.entry_{}".format(self.version))
except Exception:
entry = importlib.import_module("core.equipment.entry_0")
entry_func_list = entry.entry_func_list
func_list = entry_func_list.get(int(id), entry_func_list[0])
return func_list
def get_func_list_by_idlist(self, char) -> List[Function]:
temp = []
for id in char.装备栏:
i = self.get_equ_by_id(id)
cus = []
if len(i.可选属性) > 0:
cus = char.自定义词条.get(str(id), [])
index = 0
for k in i.成长属性 + cus:
temp.append((k, i.部位, index, 1,id,0)) # 词条id 部位 部位序号(用于获取成长词条等级)
index += 1
index = 30
mer = char.武器融合.get(str(id), [])
for k in mer:
temp.append((k, i.部位, index, -1,id,0))
index += 1
index = 10
for k in i.固有属性:
temp.append((k, i.部位, index, -1,id,0)) # 词条id 部位 部位序号(非成长词条无序号)
index += 1
for id in char.融合列表:
i = self.get_equ_by_id(id)
index = 20
cus = []
if len(i.可选属性) > 0:
cus = list(filter(lambda x:x>0,char.自定义词条.get(str(id), [])))
for index2,k in enumerate(i.固有属性 + cus):
temp.append((k, i.部位, index, -3,id,index2)) # 词条id 部位 部位序号(非成长词条无序号)
index += 1
for id in char.特性列表:
# 类型 -2 特性
if id is not None and int(id) >= 20000:
temp.append((int(id), '', -1, -2,id,0))
for id in char.suits:
if id is not None and int(id) > 30000:
temp.append((id, '', -1, -1,id,0))
pass
# 词条优先级排序
temp.sort(key=(lambda x: priority.get(x[0], 100)))
funclist = []
for k, part, index, type,id,positon in temp:
funclist.append((
self.get_func_by_id(int(k)),
part,
index,
k,
type,
id,
positon
))
return funclist
def get_chose_set_info(self) -> List[tuple]:
try:
entry = importlib.import_module(
"core.equipment.entry_{}".format(self.version))
except Exception:
entry = importlib.import_module("core.equipment.entry_0")
entry_chose = entry.entry_chose
info = []
entry_chose.sort()
# for i in entry_func_list.keys():
# temp = entry_func_list[i]
# if len(temp) > 1:
# ctext = []
# for k in temp:
# ctext.append(k(text=True))
# info.append((i, ctext))
return info + entry_chose
def get_chose_set(self, mode=0, alter="") -> List[Dict]:
try:
entry = importlib.import_module(
"core.equipment.entry_{}".format(self.version))
except Exception:
entry = importlib.import_module("core.equipment.entry_0")
multi_select = entry.multi_select
if mode == 1:
setinfo = {}
defaule_set = {
"20000": [75],
"20042": [0],
"20074": [0],
"20113": [16],
"20165": [1],
"20183": [1],
"20189": [0],
"20194": [0],
"20216": [0],
"20253": [0],
"20351": [0, 2, 3, 6, 8],
"20813": [0],
"20814": [0],
"20840": [22],
"21050": [0],
"21127": [0],
"21261": [0],
"31283": [0, 2],
"31286": [3],
"31287": [3],
"31288": [3],
"31289": [4],
"31292": [30],
"31334": [5],
"20037": [5],
"31465": [0],
"20990": [6],
"20948": [0],
"31666": [10],
"30223": [0]
}
for i in self.get_chose_set_info():
if i[2] == "" or i[2] in alter:
setinfo[i[0]] = defaule_set.get(str(i[0]), [0])
else:
setinfo = []
for i in self.get_chose_set_info():
if i[2] == "" or i[2] in alter:
setinfo.append({
"id": i[0],
"selectList": i[1],
"multi-select": multi_select.get(i[0], True)
})
return setinfo
def get_asrahan(self):
try:
entry = importlib.import_module(
"core.equipment.entry_{}".format(self.version))
except Exception:
entry = importlib.import_module("core.equipment.entry_0")
return entry.asrahan_effect
def get_funs_info(self, type, char):
try:
entry = importlib.import_module(
"core.equipment.entry_{}".format(self.version))
except Exception:
entry = importlib.import_module("core.equipment.entry_0")
return entry.get_info(type, char)
def get_global_data(name="", version="0", defa=None):
try:
entry = importlib.import_module(
"core.equipment.entry_{}.params".format(version))
except Exception:
entry = importlib.import_module("core.equipment.entry_0.params")
if hasattr(entry, name):
attr = getattr(entry, name)
return attr() if attr.__class__.__name__ == "function" else attr
else:
return defa
# def set_equ_customize(self, customize):
# for key in customize.keys():
# self.get_equ_by_id(key).成长属性 = customize[key]
# print(self.get_equ_by_id(key).成长属性,customize[key])
global equ0
equ0 = equipment_list("0")
# equ1 = equipment_list("1")
# global equ1
# equ1 = equipment_list("1")
def get_equ(version="0"):
if version is None or version == "":
version = "0"
try:
temp = eval("equ{}".format(version))
except Exception:
temp = equ0
return temp
def reload_equ():
global equ0
equ0 = equipment_list("0")
api/core/basic/monster.py
+85
View File
@@ -0,0 +1,85 @@
monster_data = {
"0": {
"id": 0,
"name": "120沙袋(绿)",
"防御": 443243,
"火抗": 0,
"冰抗": 0,
"光抗": 0,
"暗抗": 0
},
"1": {
"id": 1,
"name": "130沙袋",
"防御": 506109,
"火抗": 0,
"冰抗": 0,
"光抗": 0,
"暗抗": 0
},
"2": {
"id": 2,
"name": "140巴卡尔",
"防御": 3025925,
"火抗": 20,
"冰抗": 20,
"光抗": 20,
"暗抗": 20
},
"3": {
"id": 3,
"name": "雾神“雾”",
"防御": 3025925,
"火抗": 20,
"冰抗": 20,
"光抗": 20,
"暗抗": 20
}
}
scene_data = {
"0": {
"id": 0,
"name": "修炼道场",
"防御系数": 1,
"系统奶系数": 0,
"系统奶基数": 0
},
"1": {
"id": 1,
"name": "巴卡尔攻坚战",
"防御系数": 40,
"系统奶系数": 3.08,
"系统奶基数": 3916
},
"2": {
"id": 2,
"name": "雾神攻坚战",
"防御系数": 80,
"系统奶系数": 3.08,
"系统奶基数": 3916
}
}
def get_monster_data(id):
return monster_data.get(str(id), {
"id": 2,
"name": "140巴卡尔",
"防御": 3025925,
"火抗": 20,
"冰抗": 20,
"光抗": 20,
"暗抗": 20
})
def get_scene_data(id):
return scene_data.get(str(id), {
"id": 1,
"name": "巴卡尔攻坚战",
"防御系数": 40,
"系统奶系数": 3.08,
"系统奶基数": 3916
})
api/core/basic/property.py
+316
View File
@@ -0,0 +1,316 @@
from typing import Union
from xmlrpc.client import Boolean
from core.basic.skill import 主动技能, 技能, 被动技能
class CharacterProperty:
评分: float = 0
类型: str
适用属性: str = "智力"
def 基础属性加成(self,
物理攻击力=0.00, 魔法攻击力=0.00, 独立攻击力=0.00, 三攻=0.00,
力量=0.00, 智力=0.00, 力智=0.00, 体力=0.00, 精神=0.00, 体精=0.00, 四维=0.00,
物理暴击率=0.00, 魔法暴击率=0.00, 暴击率=0.00,
攻击速度=0.00, 施放速度=0.00, 移动速度=0.00, 三速=0.00, 火属性抗性=0, 光属性抗性=0, 冰属性抗性=0, 暗属性抗性=0, 所有属性抗性=0, 所有异常抗性=0, 所有职业异常抗性=0, 进图力量=0.00, 进图智力=0.00, **kwargs):
物理攻击力 += 三攻
魔法攻击力 += 三攻
独立攻击力 += 三攻
力量 += 力智 + 四维 + 进图力量
智力 += 力智 + 四维 + 进图智力
体力 += 体精 + 四维
精神 += 体精 + 四维
物理暴击率 += 暴击率
魔法暴击率 += 暴击率
if (self.类型 == "辅助"):
if (self.适用属性 == '体力'):
if (体力 > 0):
self.评分 += 体力 * 15
elif (self.适用属性 == '精神'):
if (精神 > 0):
self.评分 += 精神 * 15
elif (self.适用属性 == '智力'):
if (智力 > 0):
self.评分 += 智力 * 15
elif (self.类型 == "物理百分比"):
if 力量 > 0:
self.评分 += 力量 * 5
if 物理攻击力 > 0:
self.评分 += 物理攻击力 * 10
if 物理暴击率 > 0:
self.评分 += 物理暴击率
elif (self.类型 == "魔法百分比"):
if 智力 > 0:
self.评分 += 智力 * 5
if 魔法攻击力 > 0:
self.评分 += 魔法攻击力 * 10
if 魔法暴击率 > 0:
self.评分 += 魔法暴击率
elif (self.类型 == "物理固伤"):
if 力量 > 0:
self.评分 += 力量 * 5
if 独立攻击力 > 0:
self.评分 += 独立攻击力 * 10
if 物理暴击率 > 0:
self.评分 += 物理暴击率
elif self.类型 == "魔法固伤":
if 智力 > 0:
self.评分 += 智力 * 5
if 独立攻击力 > 0:
self.评分 += 独立攻击力 * 10
if 魔法暴击率 > 0:
self.评分 += 魔法暴击率
pass
def 攻击强化加成(self, x=0):
if self.类型 != "辅助":
self.评分 += x * 1000
pass
def 百分比攻击强化加成(self, x=0.0):
if self.类型 != "辅助":
self.评分 = (self.评分 + 2000) * (1 + x * 1000)
def 技能攻击力加成(self, x=0, 辟邪玉加成=1, 适用累加=1, part='', show=True):
if self.类型 != "辅助":
self.评分 = (self.评分 + 2000) * (1 + x * 2000)
def 辅助属性加成(self, buff固定力智=0, buff百分比力智=0.0, buff固定三攻=0, buff百分比三攻=0.0, 觉醒固定力智=0, 觉醒百分比力智=0.0, buff量=0, 百分比buff量=0.0):
if self.类型 == '辅助':
self.评分 += buff固定力智
self.评分 *= 1.0 + buff百分比力智
self.评分 += buff固定三攻
self.评分 *= 1.0 + buff百分比三攻
self.评分 += 觉醒固定力智
self.评分 *= 1.0 + 觉醒百分比力智
self.评分 += buff量 / 100
self.评分 *= 1.0 + 百分比buff量
def 技能等级加成(self, 加成类型: str, min: int, max: int, lv: int, exc=[],excName=[]) -> None:
if self.类型 == "辅助":
if 加成类型 == '主动':
if min < 30 and max >= 30:
self.评分 += 2000 * (lv + 1)
if min <= 50 and max >= 50:
self.评分 += 1000 * (lv + 1)
if 加成类型 == '所有':
self.评分 += 1000 * (lv + 1)
self.评分 += 100 * (lv + 1)
pass
def 评分开始(self):
self.评分 = 0
def 评分结束(self):
评分 = self.评分
self.评分 = 0
return 评分
# def get_skill_by_name(self, name) -> 技能 | 主动技能 | 被动技能:
def get_skill_by_name(self, name) -> Union[技能, 主动技能, 被动技能]:
pass
def 已穿戴神话(self):
pass
def 穿戴低于105(self):
pass
def 获取强化等级(self, part=[]):
pass
def 获取改造等级(self, part=[]):
pass
def check_fun_by_id(self, id: int) -> Boolean:
pass
def check_equ_by_name(self, name: str) -> Boolean:
pass
# region 词条属性
def set_eq_params(self,key,value):
pass
def get_eq_params(self,key)-> float:
pass
def 基础精通加成(self, x: float) -> None:
pass
def 百分比防御减少(self, x: float) -> None:
pass
def 固定防御减少(self, x: int) -> None:
pass
def 伤害类型转化(self, 类型1: str, 类型2: str, x: float) -> None:
pass
def 异常增伤(self, 类型: str, x: float) -> None:
pass
def 异常抗性加成(self, 类型: str, x: float, mode: int = 1) -> None:
pass
def 异常抗性获取(self, 类型: str, mode: int = 1) -> float:
pass
def 属性攻击(self, 类型: str) -> None:
pass
def 所有异常抗性加成(self, x: float) -> None:
pass
def 条件技攻加成(self, 类型: str, x: float) -> None:
pass
def 条件冷却加成(self, 类型: str, x: float) -> None:
pass
def 条件冷却恢复加成(self, 类型: str, x: float) -> None:
pass
def 指令效果加成(self, 类型: str, x: float) -> None:
pass
def 指令技攻加成(self, x: float, min=1, max=100, exc=[50, 85, 100],excName=[]) -> None:
pass
def MP消耗量加成(self, x: float) -> None:
pass
def buff量加成(self, x: float) -> None:
pass
def 附加伤害加成(self, x: float, 辟邪玉加成=1) -> None:
pass
def 持续伤害加成(self, x: float) -> None:
pass
def 属性附加加成(self, x: float) -> None:
pass
def 暴击伤害加成(self, x: float, 辟邪玉加成=1) -> None:
pass
def 伤害增加加成(self, x: float, 辟邪玉加成=1) -> None:
pass
def 最终伤害加成(self, x: float, 辟邪玉加成=1) -> None:
pass
def 百分比力智加成(self, x: float, 辟邪玉加成=1) -> None:
pass
def 百分比三攻加成(self, x: float, 辟邪玉加成=1) -> None:
pass
def 火属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None:
pass
def 冰属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None:
pass
def 光属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None:
pass
def 暗属性强化加成(self, x: float, 辟邪玉加成=1, mode=0) -> None:
pass
def 所有属性强化加成(self, 所有属性强化=0, 火属性强化=0, 冰属性强化=0, 光属性强化=0, 暗属性强化=0, 辟邪玉加成=1, mode=0) -> None:
if self.类型 != '辅助':
光属性强化 += 所有属性强化
暗属性强化 += 所有属性强化
火属性强化 += 所有属性强化
冰属性强化 += 所有属性强化
self.评分 += max(光属性强化, 暗属性强化, 火属性强化, 冰属性强化) * 100
pass
def 火属性抗性加成(self, x: int) -> None:
pass
def 冰属性抗性加成(self, x: int) -> None:
pass
def 光属性抗性加成(self, x: int) -> None:
pass
def 暗属性抗性加成(self, x: int) -> None:
pass
def 所有属性抗性加成(self, x: int) -> None:
pass
def 攻击速度增加(self, x: float, part: str = '') -> None:
pass
def 攻击速度(self) -> float:
pass
def 移动速度增加(self, x: float) -> None:
pass
def 施放速度增加(self, x: float) -> None:
pass
def 所有速度增加(self, x: float, part: str = '') -> None:
pass
def 命中率增加(self, x: float) -> None:
pass
def 回避率增加(self, x: float) -> None:
pass
def 物理暴击率增加(self, x: float) -> None:
pass
def 魔法暴击率增加(self, x: float) -> None:
pass
def 暴击率增加(self, x: float) -> None:
pass
def buff技能等级加成(self, LV: int, lv: int) -> None:
pass
def 特殊主动等级加成(self, Lv: int, lv: int) -> None:
pass
def 技能获取(self, min: int, max: int, exc=[]) -> None:
pass
def 技能冷却缩减(self, min: int, max: int, x: float, exc=[],excName=[]) -> None:
pass
def 加算冷却缩减(self, x: float) -> None:
pass
def 技能恢复加成(self, min: int, max: int, x: float, exc=[],excName=[]) -> None:
pass
def 技能倍率加成(self, min: int, max: int, x: float, exc=[], type="all",excName=[],changeSkill = False) -> None:
pass
def 单技能加成(self, 名称: str, 倍率=1.0, CD=1.0, lv=0) -> None:
pass
def __所有属性强化(self, x: float) -> None:
pass
def 斗神宠物加成(self, x: float) -> None:
pass
# endregion
api/core/basic/skill.py
+278
View File
@@ -0,0 +1,278 @@
from core.equipment.property import 武器MP系数, 武器冷却惩罚
角色等级 = 110
class 技能:
名称 = ''
备注 = ''
所在等级 = 0
等级上限 = 0
等级 = 0
基础等级 = 0
等级溢出 = 0
自定义描述 = 0
学习间隔 = 1
等级精通 = 60
倍率 = 1.0
关联技能 = ['无']
关联技能1 = ['无']
关联技能2 = ['无']
关联技能3 = ['无']
非关联技能 = ['无']
非关联技能1 = ['无']
非关联技能2 = ['无']
非关联技能3 = ['无']
冷却关联技能 = ['无']
冷却关联技能1 = ['无']
冷却关联技能2 = ['无']
冷却关联技能3 = ['无']
冷却类型 = 0
冷却类型1 = 0
冷却类型2 = 0
冷却类型3 = 0
非冷却关联技能 = ['无']
非冷却关联技能1 = ['无']
非冷却关联技能2 = ['无']
非冷却关联技能3 = ['无']
MP = [0, 0]
手搓 = False
手搓收益 = 1.0
手搓指令数 = 0
无色消耗 = 0
技能栏位置 = -1
def 等级加成(self, x, char={}):
if self.等级 != 0:
if self.等级 + x > self.等级上限:
self.等级 = self.等级上限
# if self.基础等级 != self.等级上限 and self.关联技能 != ['无']:
# self.等级溢出 = 1
else:
self.等级 += int(x)
def TP等级加成(self, x, char={}):
pass
def 物理攻击力倍率(self, 武器类型):
return 1.0
def 魔法攻击力倍率(self, 武器类型):
return 1.0
def 独立攻击力倍率(self, 武器类型):
return 1.0
def 物理攻击力倍率进图(self, 武器类型):
return 1.0
def 魔法攻击力倍率进图(self, 武器类型):
return 1.0
def 独立攻击力倍率进图(self, 武器类型):
return 1.0
def MP消耗(self, **argv):
pass
def 基础等级计算(self):
if self.基础等级 == 0:
self.基础等级 = min(int((角色等级 + 5 - self.所在等级) / self.学习间隔 + 1),
self.等级精通)
def 加成倍率(self, 武器类型):
return 1.0
def 加成描述(self, 武器类型):
return [round((self.加成倍率(武器类型) - 1)*100, 1), ",".join(self.关联技能), ",".join(self.非关联技能)]
def 加成倍率1(self, 武器类型):
return 1.0
def 加成描述1(self, 武器类型):
return [round((self.加成倍率1(武器类型) - 1)*100, 1), ",".join(self.关联技能1), ",".join(self.非关联技能1)]
def 加成倍率2(self, 武器类型):
return 1.0
def 加成描述2(self, 武器类型):
return [round((self.加成倍率2(武器类型) - 1)*100, 1), ",".join(self.关联技能2), ",".join(self.非关联技能2)]
def 加成倍率3(self, 武器类型):
return 1.0
def 加成描述3(self, 武器类型):
return [round((self.加成倍率3(武器类型) - 1)*100, 1), ",".join(self.关联技能3), ",".join(self.非关联技能3)]
def CD缩减倍率(self, 武器类型):
return 1.0
def CD缩减描述(self, 武器类型):
return [round((1-self.CD缩减倍率(武器类型))*100, 1), ",".join(self.冷却关联技能), ",".join(self.非冷却关联技能)]
def CD缩减描述1(self, 武器类型):
return [round((1-self.CD缩减倍率1(武器类型))*100, 1), ",".join(self.冷却关联技能1), ",".join(self.非冷却关联技能1)]
def CD缩减倍率2(self, 武器类型):
return 1.0
def CD缩减描述2(self, 武器类型):
return [round((1-self.CD缩减倍率2(武器类型))*100, 1), ",".join(self.冷却关联技能2), ",".join(self.非冷却关联技能2)]
def CD缩减倍率3(self, 武器类型):
return 1.0
def CD缩减描述3(self, 武器类型):
return [round((1-self.CD缩减倍率3(武器类型))*100, 1), ",".join(self.冷却关联技能3), ",".join(self.非冷却关联技能3)]
class 主动技能(技能):
# 如果需要继续扩展，可以在各自职业类内继承后自行扩展，同时需要重写下等效百分比函数
# 固伤在填写基础及成长的时候需要注意，技能面板/独立得到的成长及数值需要*100
CD = 0.0
CDR = 1.0
CD固定缩减 = 0
CDR_O = 1.0
TP成长 = 0.0
TP上限 = 0
TP等级 = 0
是否主动 = 1
是否有伤害 = 1
恢复 = 1.0
倍率 = 1.0
技攻 = 1.0
被动倍率 = 1.0
基础施放次数 = 0
演出时间 = 0
是否有护石 = 0
武器倍率 = {}
形态 = []
国服特色 = 1.0
data0 = []
hit0 = 1
power0 = 1
感电data0 = []
感电hit0 = 0
感电power0 = 1
灼伤data0 = []
灼伤hit0 = 0
灼伤power0 = 1
中毒data0 = []
中毒hit0 = 0
中毒power0 = 1
出血data0 = []
出血hit0 = 0
出血power0 = 1
def __init__(self) -> None:
super().__init__()
# self.倍率 = 1.0
def TP等级加成(self, x, char={}):
if self.TP等级 != 0:
self.TP等级 = min(self.TP等级+x, self.TP上限+2)
def 形态变更(self, 形态, char):
if 形态 == '' and len(self.形态) > 0:
形态 = self.形态[0]
pass
def TP加成(self):
return 1 + self.TP成长 * self.TP等级
def 基础百分比(self, 类型, 等级):
if 类型 == '直伤':
name = ''
else:
name = 类型
百分比 = 0.0
for i in range(0, 8):
data = getattr(self, '{}data{}'.format(name, i), [])
if 等级 < len(data) and 等级 > 0:
hit = getattr(self, '{}hit{}'.format(name, i), 1)
power = getattr(self, '{}power{}'.format(name, i), 1)
百分比 += data[等级] * hit * power
return 百分比 * self.国服特色
def 武器百分比修正(self, 武器类型):
return self.武器倍率.get(武器类型, 1.0)
def 等效百分比(self, **argv):
# 武器类型 额外等级 额外倍率 伤害类型 形态
武器类型 = argv.get('武器类型', '')
额外等级 = argv.get('额外等级', 0)
额外倍率 = argv.get('额外倍率', 1.0)
伤害类型 = argv.get('伤害类型', '直伤')
形态 = argv.get('形态', '')
char = argv.get('char', {})
self.形态变更(形态, char)
等级 = min(self.等级 + 额外等级, self.等级上限)
if 等级 == 0:
return 0
百分比 = self.基础百分比(伤害类型, 等级)
return 百分比 * self.TP加成() * self.技攻 * self.倍率 * 额外倍率 * self.武器百分比修正(武器类型)
def 武器CD系数(self, 武器类型, 输出类型):
return 武器冷却惩罚(武器类型, 输出类型)
def 手搓CD(self):
cdr = 0
if self.手搓:
if self.所在等级 >= 15 and self.所在等级 <= 30:
cdr = 0.01 * self.手搓收益
if self.所在等级 >= 35 and self.所在等级 <= 70:
cdr = 0.02 * self.手搓收益
if self.所在等级 >= 75 and self.所在等级 <= 100:
cdr = 0.05 * self.手搓收益
if self.所在等级 in [50, 85, 100]:
cdr = 0.05 * self.手搓收益
return cdr
def 等效CD(self, **argv):
# 武器类型 输出类型 额外CDR 手搓收益 恢复
武器类型 = argv.get('武器类型', '')
输出类型 = argv.get('输出类型', '')
额外CDR = argv.get('额外CDR', 1.0)
# 手搓收益 = argv.get('手搓收益', 1.0)
面板显示 = argv.get('面板显示', False)
额外恢复 = argv.get('额外恢复', 0)
cdr = self.手搓CD()
形态 = argv.get('形态', '')
char = argv.get('char', {})
self.形态变更(形态, char)
return max(0,round(max(self.CD * self.CDR * 额外CDR / ((self.恢复 + 额外恢复) if not 面板显示 else 1) * (self.武器CD系数(武器类型, 输出类型) - (cdr if not 面板显示 else 0)), self.CD * 0.3) * self.CDR_O, 1) - self.CD固定缩减 / ((self.恢复 + 额外恢复) if not 面板显示 else 1) )
def MP消耗(self, **argv):
# 武器类型 输出类型 额外CDR 手搓收益 恢复=True
武器类型 = argv.get('武器类型', '')
输出类型 = argv.get('输出类型', '')
额外倍率 = argv.get('额外倍率', 1.0)
if self.MP is None:
self.MP = [0, 0]
if self.等级上限 > 1:
mpnum = int(self.MP[0] + (self.等级 - 1) *
(self.MP[1] - self.MP[0]) / (self.等级上限 - 1))
else:
mpnum = self.MP[0]
return round(mpnum * 武器MP系数(武器类型, 输出类型) * 额外倍率, 0)
class 被动技能(技能):
是否主动 = 0
是否有伤害 = 0
关联技能 = ['所有']