mirror of
https://github.com/yoimiya-kokomi/miao-plugin.git
synced 2024-11-25 01:21:55 +00:00
578 lines
15 KiB
JavaScript
578 lines
15 KiB
JavaScript
import fs from 'fs'
|
||
import lodash from 'lodash'
|
||
import Format from './Format.js'
|
||
import { Character } from './models.js'
|
||
|
||
import { eleBaseDmg, eleMap, attrMap } from './calc/calc-meta.js'
|
||
import { Mastery } from './calc/mastery.js'
|
||
|
||
let Calc = {
|
||
|
||
async getCharCalcRule (name) {
|
||
const _path = process.cwd()
|
||
const cfgPath = `${_path}/plugins/miao-plugin/resources/meta/character/${name}/calc.js`
|
||
|
||
let details; let buffs = []; let defParams = {}; let defDmgIdx = -1; let mainAttr = 'atk,cpct,cdmg'; let enemyName = '小宝'
|
||
if (fs.existsSync(cfgPath)) {
|
||
let fileData = await import(`file://${cfgPath}`)
|
||
details = fileData.details || false
|
||
buffs = fileData.buffs || []
|
||
defParams = fileData.defParams || {}
|
||
if (fileData.defDmgIdx) {
|
||
defDmgIdx = fileData.defDmgIdx
|
||
}
|
||
if (fileData.mainAttr) {
|
||
mainAttr = fileData.mainAttr
|
||
}
|
||
if (fileData.enemyName) {
|
||
enemyName = fileData.enemyName
|
||
}
|
||
}
|
||
|
||
if (details) {
|
||
return { details, buffs, defParams, defDmgIdx, mainAttr, enemyName }
|
||
}
|
||
return false
|
||
},
|
||
|
||
// 获取基础属性
|
||
attr (profile) {
|
||
let ret = {}
|
||
let { attr } = profile
|
||
|
||
ret.dataSource = profile.dataSource || 'miao'
|
||
|
||
// 基础属性
|
||
lodash.forEach('atk,def,hp'.split(','), (key) => {
|
||
ret[key] = {
|
||
base: attr[`${key}Base`] * 1 || 0,
|
||
plus: attr[key] * 1 - attr[`${key}Base`] * 1 || 0,
|
||
pct: 0
|
||
}
|
||
})
|
||
|
||
lodash.forEach('mastery,recharge'.split(','), (key) => {
|
||
ret[key] = {
|
||
base: attr[key] * 1 || 0,
|
||
plus: 0,
|
||
pct: 0
|
||
}
|
||
})
|
||
|
||
lodash.forEach({ cRate: 'cpct', cDmg: 'cdmg', hInc: 'heal' }, (val, key) => {
|
||
ret[val] = {
|
||
base: attr[key] * 1 || 0,
|
||
plus: 0,
|
||
pct: 0,
|
||
inc: 0
|
||
}
|
||
})
|
||
|
||
lodash.forEach('dmg,phy'.split(','), (key) => {
|
||
ret[key] = {
|
||
base: attr[key + 'Bonus'] * 1 || 0,
|
||
plus: 0,
|
||
pct: 0
|
||
}
|
||
})
|
||
|
||
// 技能属性记录
|
||
lodash.forEach('a,a2,a3,e,q'.split(','), (key) => {
|
||
ret[key] = {
|
||
pct: 0, // 倍率加成
|
||
multi: 0, // 独立倍率乘区加成
|
||
|
||
plus: 0, // 伤害值提高
|
||
dmg: 0, // 伤害提高
|
||
cpct: 0, // 暴击提高
|
||
cdmg: 0, // 爆伤提高
|
||
|
||
def: 0, // 防御降低
|
||
ignore: 0 // 无视防御
|
||
}
|
||
})
|
||
|
||
ret.enemy = {
|
||
def: 0, // 降低防御
|
||
ignore: 0, // 无视防御
|
||
phy: 0 // 物理防御
|
||
}
|
||
|
||
ret.shield = {
|
||
base: 100, // 基础
|
||
plus: 0, // 护盾强效
|
||
inc: 100 // 吸收倍率
|
||
}
|
||
|
||
let char = Character.get(profile)
|
||
ret.weapon = profile.weapon
|
||
ret.weaponType = char.weaponType
|
||
ret.element = eleMap[char.elem.toLowerCase()]
|
||
ret.refine = (profile.weapon.affix * 1 - 1) || 0
|
||
|
||
ret.multi = 0
|
||
|
||
ret.zf = 0
|
||
ret.rh = 0
|
||
ret.gd = 0
|
||
ret.ks = 0
|
||
|
||
ret.kx = 0
|
||
ret.fykx = 0
|
||
|
||
return ret
|
||
},
|
||
|
||
// 获取天赋数据
|
||
talent (profile, char) {
|
||
let ret = {}
|
||
|
||
let talentData = profile.talent || {}
|
||
|
||
lodash.forEach(['a', 'e', 'q'], (key) => {
|
||
let td = talentData[key] || {}
|
||
let lv = td.level_current * 1 || 1
|
||
|
||
let map = {}
|
||
|
||
lodash.forEach(char.talent[key].tables, (tr) => {
|
||
let val = tr.values[lv - 1]
|
||
val = val.replace(/[^\x00-\xff]/g, '').trim()
|
||
let valArr = []; let valArr2 = []
|
||
lodash.forEach(val.split('/'), (v, idx) => {
|
||
let valNum = 0
|
||
lodash.forEach(v.split('+'), (v) => {
|
||
v = v.split('*')
|
||
let v1 = v[0].replace('%', '').trim()
|
||
valNum += v1 * (v[1] || 1)
|
||
valArr2.push(v1)
|
||
})
|
||
valArr.push(valNum)
|
||
})
|
||
|
||
if (isNaN(valArr[0])) {
|
||
map[tr.name] = false
|
||
} else if (valArr.length === 1) {
|
||
map[tr.name] = valArr[0]
|
||
} else {
|
||
map[tr.name] = valArr
|
||
}
|
||
map[tr.name + '2'] = valArr2
|
||
})
|
||
ret[key] = map
|
||
})
|
||
return ret
|
||
},
|
||
|
||
getDs (attr, meta, params) {
|
||
return {
|
||
...meta,
|
||
attr,
|
||
params,
|
||
refine: attr.refine,
|
||
weaponType: attr.weaponType,
|
||
weapon: attr.weapon,
|
||
element: eleMap[attr.element] || attr.element,
|
||
calc (ds) {
|
||
return (ds.base || 0) + (ds.plus || 0) + ((ds.base || 0) * (ds.pct || 0) / 100)
|
||
}
|
||
}
|
||
},
|
||
|
||
calcAttr ({ originalAttr, buffs, meta, params = {}, incAttr = '', reduceAttr = '', talent = '' }) {
|
||
let attr = lodash.merge({}, originalAttr)
|
||
let msg = []
|
||
|
||
if (incAttr && attrMap[incAttr]) {
|
||
let aCfg = attrMap[incAttr]
|
||
attr[incAttr][aCfg.type] += aCfg.val
|
||
}
|
||
if (reduceAttr && attrMap[reduceAttr]) {
|
||
let aCfg = attrMap[reduceAttr]
|
||
attr[reduceAttr][aCfg.type] -= aCfg.val
|
||
}
|
||
|
||
lodash.forEach(buffs, (buff) => {
|
||
let ds = Calc.getDs(attr, meta, params)
|
||
|
||
ds.currentTalent = talent
|
||
|
||
// 如果存在rule，则进行计算
|
||
if (buff.check && !buff.check(ds)) {
|
||
return
|
||
}
|
||
if (buff.cons) {
|
||
if (ds.cons * 1 < buff.cons * 1) {
|
||
return
|
||
}
|
||
}
|
||
|
||
let title = buff.title
|
||
|
||
if (buff.mastery) {
|
||
let mastery = Math.max(0, attr.mastery.base + attr.mastery.plus)
|
||
// let masteryNum = 2.78 * mastery / (mastery + 1400) * 100;
|
||
buff.data = buff.data || {}
|
||
lodash.forEach(buff.mastery.split(','), (key) => {
|
||
buff.data[key] = Mastery.getMultiple(key, mastery)
|
||
// buff.data[key] = masteryNum;
|
||
})
|
||
}
|
||
|
||
lodash.forEach(buff.data, (val, key) => {
|
||
if (lodash.isFunction(val)) {
|
||
val = val(ds)
|
||
}
|
||
|
||
title = title.replace(`[${key}]`, Format.comma(val, 1))
|
||
// 技能提高
|
||
let tRet = /^(a|a2|a3|e|q)(Def|Ignore|Dmg|Plus|Pct|Cpct|Cdmg|Multi)$/.exec(key)
|
||
if (tRet) {
|
||
attr[tRet[1]][tRet[2].toLowerCase()] += val * 1 || 0
|
||
return
|
||
}
|
||
let aRet = /^(hp|def|atk|mastery|cpct|cdmg|heal|recharge|dmg|phy|shield)(Plus|Pct|Inc)?$/.exec(key)
|
||
if (aRet) {
|
||
attr[aRet[1]][aRet[2] ? aRet[2].toLowerCase() : 'plus'] += val * 1 || 0
|
||
return
|
||
}
|
||
if (key === 'enemyDef') {
|
||
attr.enemy.def += val * 1 || 0
|
||
return
|
||
}
|
||
|
||
if (['zf', 'rh', 'kx', 'gd', 'ks', 'fykx'].includes(key)) {
|
||
attr[key] += val * 1 || 0
|
||
}
|
||
})
|
||
msg.push(title)
|
||
})
|
||
|
||
return {
|
||
attr, msg
|
||
}
|
||
},
|
||
|
||
async weapon (weaponName) {
|
||
const _path = process.cwd()
|
||
const cfgPath = `${_path}/plugins/miao-plugin/resources/meta/weapons/calc.js`
|
||
|
||
let weapons = {}
|
||
if (fs.existsSync(cfgPath)) {
|
||
let fileData = await import(`file://${cfgPath}`)
|
||
weapons = fileData.weapons || {}
|
||
}
|
||
|
||
let weaponCfg = weapons[weaponName] || []
|
||
if (lodash.isPlainObject(weaponCfg)) {
|
||
weaponCfg = [weaponCfg]
|
||
}
|
||
|
||
lodash.forEach(weaponCfg, (ds) => {
|
||
if (!/：/.test(ds.title)) {
|
||
ds.title = `${weaponName}：${ds.title}`
|
||
}
|
||
if (ds.refine) {
|
||
ds.data = ds.data || {}
|
||
lodash.forEach(ds.refine, (r, key) => {
|
||
ds.data[key] = ({ refine }) => r[refine] * (ds.buffCount || 1)
|
||
})
|
||
}
|
||
})
|
||
|
||
return weaponCfg
|
||
},
|
||
|
||
async reliquaries (sets) {
|
||
const _path = process.cwd()
|
||
const cfgPath = `${_path}/plugins/miao-plugin/resources/meta/reliquaries/calc.js`
|
||
|
||
let buffs = {}
|
||
if (fs.existsSync(cfgPath)) {
|
||
let fileData = await import(`file://${cfgPath}`)
|
||
buffs = fileData.buffs || {}
|
||
}
|
||
|
||
let setMap = {}
|
||
|
||
lodash.forEach(sets, (set) => {
|
||
if (set && set.set) {
|
||
let name = set.set
|
||
setMap[name] = (setMap[name] || 0) + 1
|
||
}
|
||
})
|
||
|
||
let retBuffs = []
|
||
|
||
lodash.forEach(setMap, (count, setName) => {
|
||
if (count >= 2 && buffs[setName + 2]) {
|
||
retBuffs.push(buffs[setName + 2])
|
||
}
|
||
if (count >= 4 && buffs[setName + 4]) {
|
||
retBuffs.push(buffs[setName + 4])
|
||
}
|
||
})
|
||
return retBuffs
|
||
},
|
||
|
||
getDmgFn ({ ds, attr, profile, enemyLv, showDetail = false }) {
|
||
let { calc } = ds
|
||
|
||
let dmgFn = function (pctNum = 0, talent = false, ele = false, basicNum = 0, mode = 'talent') {
|
||
let { atk, dmg, phy, cdmg, cpct } = attr
|
||
// 攻击区
|
||
let atkNum = calc(atk)
|
||
|
||
// 倍率独立乘区
|
||
let multiNum = attr.multi / 100
|
||
|
||
// 增伤区
|
||
let dmgNum = (1 + dmg.base / 100 + dmg.plus / 100)
|
||
|
||
if (ele === 'phy') {
|
||
dmgNum = (1 + phy.base / 100 + phy.plus / 100)
|
||
}
|
||
|
||
// console.log({ base: Format.comma(dmg.base, 2), plus: Format.comma(dmg.plus, 2) })
|
||
|
||
let cpctNum = cpct.base / 100 + cpct.plus / 100
|
||
|
||
// 爆伤区
|
||
let cdmgNum = cdmg.base / 100 + cdmg.plus / 100
|
||
|
||
let enemyDef = attr.enemy.def / 100
|
||
let enemyIgnore = attr.enemy.ignore / 100
|
||
|
||
let plusNum = 0
|
||
|
||
if (talent && attr[talent]) {
|
||
pctNum = pctNum / 100
|
||
|
||
let ds = attr[talent]
|
||
|
||
pctNum += ds.pct / 100
|
||
dmgNum += ds.dmg / 100
|
||
cpctNum += ds.cpct / 100
|
||
cdmgNum += ds.cdmg / 100
|
||
enemyDef += ds.def / 100
|
||
enemyIgnore += ds.ignore / 100
|
||
multiNum += ds.multi / 100
|
||
plusNum += ds.plus
|
||
}
|
||
|
||
// 防御区
|
||
let lv = profile.lv
|
||
let defNum = (lv + 100) / ((lv + 100) + (enemyLv + 100) * (1 - enemyDef) * (1 - enemyIgnore))
|
||
|
||
// 抗性区
|
||
let kx = attr.kx
|
||
if (talent === 'fy') {
|
||
kx = attr.fykx
|
||
}
|
||
kx = 10 - (kx || 0)
|
||
let kNum = 0.9
|
||
if (kx >= 0) {
|
||
kNum = (100 - kx) / 100
|
||
} else {
|
||
kNum = 1 - kx / 200
|
||
}
|
||
|
||
// 反应区
|
||
let eleNum = 1; let eleBase = 0
|
||
|
||
if (ele === 'ks' || ele === 'gd') {
|
||
eleBase = eleBaseDmg[lv] || 0
|
||
}
|
||
|
||
if (ele === 'phy') {
|
||
// do nothing
|
||
} else if (ele) {
|
||
eleNum = Mastery.getBasePct(ele, attr.element)
|
||
|
||
if (attr[ele]) {
|
||
eleNum = eleNum * (1 + attr[ele] / 100)
|
||
}
|
||
}
|
||
|
||
cpctNum = Math.max(0, Math.min(1, cpctNum))
|
||
if (cpctNum === 0) {
|
||
cdmgNum = 0
|
||
}
|
||
|
||
let ret = {}
|
||
if (mode === 'basic') {
|
||
ret = {
|
||
dmg: basicNum * dmgNum * (1 + cdmgNum) * defNum * kNum * eleNum,
|
||
avg: basicNum * dmgNum * (1 + cpctNum * cdmgNum) * defNum * kNum * eleNum
|
||
}
|
||
} else if (eleBase) {
|
||
ret = {
|
||
avg: eleBase * kNum * eleNum
|
||
}
|
||
} else {
|
||
// 计算最终伤害
|
||
ret = {
|
||
dmg: (atkNum * pctNum * (1 + multiNum) + plusNum) * dmgNum * (1 + cdmgNum) * defNum * kNum * eleNum,
|
||
avg: (atkNum * pctNum * (1 + multiNum) + plusNum) * dmgNum * (1 + cpctNum * cdmgNum) * defNum * kNum * eleNum
|
||
}
|
||
}
|
||
|
||
if (showDetail) {
|
||
console.log(attr, { atkNum, pctNum, multiNum, plusNum, dmgNum, cpctNum, cdmgNum, defNum, eleNum, kNum }, ret)
|
||
}
|
||
|
||
return ret
|
||
}
|
||
|
||
dmgFn.basic = function (basicNum = 0, talent = false, ele = false) {
|
||
return dmgFn(0, talent, ele, basicNum, 'basic')
|
||
}
|
||
|
||
dmgFn.heal = function (num) {
|
||
if (showDetail) {
|
||
console.log(num, calc(attr.heal), attr.heal.inc)
|
||
}
|
||
return {
|
||
avg: num * (1 + calc(attr.heal) / 100 + attr.heal.inc / 100)
|
||
}
|
||
}
|
||
|
||
dmgFn.shield = function (num) {
|
||
return {
|
||
avg: num * (calc(attr.shield) / 100) * (attr.shield.inc / 100)
|
||
}
|
||
}
|
||
dmgFn.ks = function () {
|
||
return dmgFn(0, 'fy', 'ks')
|
||
}
|
||
|
||
return dmgFn
|
||
},
|
||
|
||
async calcData ({ profile, char, enemyLv = 91, mode = 'profile', dmgIdx = 0 }) {
|
||
let charCalcData = await Calc.getCharCalcRule(char.name)
|
||
|
||
if (!charCalcData) {
|
||
return false
|
||
}
|
||
let talent = Calc.talent(profile, char)
|
||
|
||
let meta = {
|
||
cons: profile.cons * 1,
|
||
talent
|
||
}
|
||
|
||
let { buffs, details, defParams, mainAttr, defDmgIdx, enemyName } = charCalcData
|
||
|
||
defParams = defParams || {}
|
||
|
||
let originalAttr = Calc.attr(profile)
|
||
|
||
let weaponBuffs = await Calc.weapon(profile.weapon.name)
|
||
let reliBuffs = await Calc.reliquaries(profile.artis)
|
||
buffs = lodash.concat(buffs, weaponBuffs, reliBuffs)
|
||
|
||
lodash.forEach(buffs, (buff) => {
|
||
buff.sort = lodash.isUndefined(buff.sort) ? 1 : buff.sort
|
||
})
|
||
|
||
buffs = lodash.sortBy(buffs, ['sort'])
|
||
|
||
let { msg } = Calc.calcAttr({ originalAttr, buffs, meta, params: defParams || {} })
|
||
|
||
let ret = []; let detailMap = []; let dmgRet = []; let dmgDetail = {}
|
||
|
||
lodash.forEach(details, (detail, detailSysIdx) => {
|
||
if (lodash.isFunction(detail)) {
|
||
let { attr } = Calc.calcAttr({ originalAttr, buffs, meta })
|
||
let ds = lodash.merge({ talent }, Calc.getDs(attr, meta))
|
||
detail = detail({ ...ds, attr, profile })
|
||
}
|
||
let params = lodash.merge({}, defParams, detail.params || {})
|
||
let { attr } = Calc.calcAttr({ originalAttr, buffs, meta, params, talent: detail.talent || '' })
|
||
if (detail.check && !detail.check(Calc.getDs(attr, meta, params))) {
|
||
return
|
||
}
|
||
if (detail.cons && meta.cons * 1 < detail.cons * 1) {
|
||
return
|
||
}
|
||
let ds = lodash.merge({ talent }, Calc.getDs(attr, meta, params))
|
||
|
||
let dmg = Calc.getDmgFn({ ds, attr, profile, enemyLv, showDetail: detail.showDetail })
|
||
let basicDmgRet
|
||
|
||
if (detail.dmg) {
|
||
basicDmgRet = detail.dmg(ds, dmg)
|
||
detail.userIdx = detailMap.length
|
||
detailMap.push(detail)
|
||
ret.push({
|
||
title: detail.title,
|
||
...basicDmgRet
|
||
})
|
||
}
|
||
})
|
||
|
||
if (mode === 'dmg') {
|
||
let detail
|
||
if (dmgIdx && detailMap[dmgIdx - 1]) {
|
||
detail = detailMap[dmgIdx - 1]
|
||
} else if (!lodash.isUndefined(defDmgIdx) && details[defDmgIdx]) {
|
||
detail = details[defDmgIdx]
|
||
} else {
|
||
detail = detailMap[0]
|
||
}
|
||
|
||
dmgDetail = {
|
||
title: detail.title,
|
||
userIdx: detail.userIdx,
|
||
basicRet: lodash.merge({}, ret[detail.userIdx]),
|
||
attr: []
|
||
}
|
||
|
||
mainAttr = mainAttr.split(',')
|
||
let params = lodash.merge({}, defParams, detail.params || {})
|
||
let basicDmg = dmgDetail.basicRet
|
||
lodash.forEach(mainAttr, (reduceAttr) => {
|
||
dmgDetail.attr.push(attrMap[reduceAttr])
|
||
let rowData = []
|
||
lodash.forEach(mainAttr, (incAttr) => {
|
||
if (incAttr === reduceAttr) {
|
||
rowData.push({ type: 'na' })
|
||
return
|
||
}
|
||
let { attr } = Calc.calcAttr({
|
||
originalAttr,
|
||
buffs,
|
||
meta,
|
||
params,
|
||
incAttr,
|
||
reduceAttr,
|
||
talent: detail.talent || ''
|
||
})
|
||
let ds = lodash.merge({ talent }, Calc.getDs(attr, meta, params))
|
||
let dmg = Calc.getDmgFn({ ds, attr, profile, enemyLv })
|
||
if (detail.dmg) {
|
||
let dmgCalcRet = detail.dmg(ds, dmg)
|
||
rowData.push({
|
||
type: dmgCalcRet.avg === basicDmg.avg ? 'avg' : (dmgCalcRet.avg > basicDmg.avg ? 'gt' : 'lt'),
|
||
...dmgCalcRet
|
||
})
|
||
}
|
||
})
|
||
dmgRet.push(rowData)
|
||
})
|
||
}
|
||
|
||
return {
|
||
ret,
|
||
msg,
|
||
dmgRet,
|
||
enemyName,
|
||
dmgCfg: dmgDetail
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
export default Calc
|