全站通知：
Widget:面板计算器
刷
历
编
跳到导航
跳到搜索
密探信息
<script>
(window.RLQ = window.RLQ || []).push([
["jquery"],
function () {
$(function () {
// 初始
roleData = JSON.parse(document.getElementById('RoleNumValue').innerHTML);
starStoneData = JSON.parse(document.getElementById('StarStoneValue').innerHTML);
StarStoneGroupData = JSON.parse(document.getElementById('StarStoneGroup').innerHTML);
StoneGroupData = StarStoneGroupData.Group;
StoneComboData = StarStoneGroupData.Combo;
console.info(roleData);
console.info(starStoneData);
console.info(StoneGroupData);
nowSelectRoleData;
HP_BF_SliderMax = 100;
ATK_BF_SliderMax = 100;
clickUpdate = true;
awakeOver = false;
drawPageContent();
ResetRoleList();
ResetDrawStoneComboButton();
ResetPayPoint();
DrawStarStoneOption();
Job_Switck();
MainCalculation();
awakeOver = true;
})
}
])
var roleData; var starStoneData; var StarStoneGroupData; var StoneGroupData; var StoneComboData; var nowSelectRoleData; var HP_BF_SliderMax; var ATK_BF_SliderMax; var clickUpdate; var awakeOver;
// 绘制画面 ================================================================
// 定义函数来绘制页面内容
function drawPageContent() {
// 获取页面中的计算父元素
var DrawTargetParent = document.querySelector('.DrawTarget');
// 如果找到计算父元素
if (DrawTargetParent) {
// 设置计算父元素的innerHTML，插入所需的HTML内容
DrawTargetParent.style.display = "block";
console.info(`初始化更新-更新完成`);
} else {
console.info(`初始化更新-未找到`);
}
}
// 按键更新 ================================================================
// 职业更新
function Job_Switck() {
console.info(`职业修改`);
var selectedJob = document.getElementById('jobSwitch').value; // 获取所选职业名称
ResetRoleList(selectedJob);
Role_Switch();
if (clickUpdate == false) MainCalculation();
}
// 角色更新
function Role_Switch() {
console.info(`角色修改`);
var selectedRoleName = document.getElementById('roleSelect').value; // 获取所选角色名称
// 使用find方法查找roleName为所选角色名称的元素
var foundElement = roleData.find(function (element) {
return element.roleName === selectedRoleName;
});
if (foundElement) {
document.getElementById('roleJob').textContent = foundElement.roleJob; // 将角色名称设置为工作列表的值
console.log(`打印匹配到的角色: ` + foundElement.roleJob); // 打印匹配到的角色的 roleJob
} else {
console.log('未找到匹配的角色');
document.getElementById('roleSelect').value = roleData[0].roleName;
Role_Switch();
return;
}
let nowRoleName = document.getElementById('roleSelect').value;
nowSelectRoleData = roleData.find(function (role) {
return role.roleName === nowRoleName;
});
console.log(`获取角色json:${nowSelectRoleData}`);
console.info(nowSelectRoleData);
var lbfRange = document.getElementById('lifeBF-Range');
var abfRange = document.getElementById('atkBF-Range');
$('#show-portrait').html();
$('#show-portrait-2').html();
// 选择 data-name 属性为 getName 的内容添加到 id 为 gacha_get_box 的块中去
$('#show-portrait').append($("[data-name='" + selectedRoleName + "']").eq(0).html());
$('#show-portrait-2').append($("[data-name='" + selectedRoleName + "']").eq(1).html());
if (nowSelectRoleData.isSSR == 'TRUE') {
HP_BF_SliderMax = 2600;
ATK_BF_SliderMax = 500;
} else {
HP_BF_SliderMax = 1820;
ATK_BF_SliderMax = 350;
}
// 最大值更新
lbfRange.max = Math.ceil(HP_BF_SliderMax / 25) * 25;
abfRange.max = Math.ceil(ATK_BF_SliderMax / 5) * 5;
ResetStarStoneList(0);
ResetDrawStoneComboButton();
StoneGroupState();
// 输入框内容更新
UpdateBFInput('lifeBF');
UpdateBFInput('atkBF');
InputOver();
}
// 输入完成
function InputOver() {
if (clickUpdate == true && awakeOver == true) MainCalculation();
}
function levelChanged() {
if (document.getElementById("roleRealLevel").value == 1) {
document.getElementById("roleLevel").value = 4;
document.getElementById("rolePower").textContent = "+15";
}
else if (document.getElementById("roleRealLevel").value == 2) {
document.getElementById("roleLevel").value = 5;
document.getElementById("rolePower").textContent = "+17";
}
InputOver();
}
//主计算
function MainCalculation() {
// 获取 属性
let roleAttributeValue = document.getElementById('roleAttribute').textContent;
// 角色白值等级
let levelValue = parseInt(document.getElementById('roleLevel').value);
let levelHP = nowSelectRoleData.Level_HP[levelValue - 1];
let levelATK = nowSelectRoleData.Level_ATK[levelValue - 1];
// 角色阶段 (重复碎片提升 命座.jpg)
let payValue = parseInt(document.getElementById('rolePay').value);
let payHP = 0;
let payATK = 0;
// 星级(化极)
let starLevel = GetPayPointValue();
let starLevelValue;
if (starLevel >= 6) {
starLevelValue = 0.35;
} else if (starLevel >= 5) {
starLevelValue = 0.25;
} else {
starLevelValue = (starLevel - 1) * 0.05;
}
starLevelValue = parseFloat(starLevelValue.toFixed(6));
// 生命/攻击蝶
let lifeBF = parseInt(document.getElementById('lifeBF').value);
let atkBF = parseInt(document.getElementById('atkBF').value);
console.log(nowSelectRoleData);
let step = 1; // 步骤计数器
let forLength = Math.min(payValue, 20);
for (let i = 0; i < forLength; i++) {
if (step % 2 === 1) {
// 奇数步骤，增加 payHP
payHP += nowSelectRoleData.Pay_HP[parseInt(step / 2)]; // 使用取模操作防止索引超出数组范围
} else {
// 偶数步骤，增加 payATK
payATK += nowSelectRoleData.Pay_ATK[parseInt(step / 2) - 1]; // 使用取模操作防止索引超出数组范围
}
console.log(`${payHP} ${payATK} ${step}`);
step++; // 增加步骤计数器
}
let getStone1 = GetStoneJsonData(1);
let star1Lv = parseInt(document.getElementById(`StarStone1-LvInput`).value);
let getStone2 = GetStoneJsonData(2);
let star2Lv = parseInt(document.getElementById(`StarStone2-LvInput`).value);
let getStone3 = GetStoneJsonData(3);
let star3Lv = parseInt(document.getElementById(`StarStone3-LvInput`).value);
console.info(getStone1, getStone2, getStone3);
let starOffHpNum = StarStoneValueCombine(getStone1.HP_Value, star1Lv, getStone2.HP_Value, star2Lv, getStone3
.HP_Value, star3Lv);
let starOffHpPer = StarStoneValueCombine(getStone1.HP_Percent, star1Lv, getStone2.HP_Percent, star2Lv, getStone3
.HP_Percent, star3Lv);
let starOffAtkNum = StarStoneValueCombine(getStone1.ATK_Value, star1Lv, getStone2.ATK_Value, star2Lv, getStone3
.ATK_Value, star3Lv);
let starOffAtkPer = StarStoneValueCombine(getStone1.ATK_Percent, star1Lv, getStone2.ATK_Percent, star2Lv,
getStone3.ATK_Percent, star3Lv);
let groupData = DetectionStoneGroup([getStone1.StoneName, getStone2.StoneName, getStone3.StoneName]);
let groutLv = 5 - Math.max(getStone1.Level ? getStone1.Level : 1, getStone2.Level ? getStone2.Level : 1,
getStone3.Level ? getStone3.Level : 1);
let starGroupOffHpNum = 0;
let starGroupOffHpPer = 0;
let starGroupOffAtkNum = 0;
let starGroupOffAtkPer = 0;
let lvOfAtkPer = levelValue >= 2 ? 0.05 : 0;
let lvOfHpPer = levelValue >= 4 ? 0.05 : 0;
groupData.forEach(function (groupAdd) {
let data = groupAdd.values[groutLv];
console.log(groupAdd.valueType + `` + data);
switch (groupAdd.valueType) {
case '生命值':
starGroupOffHpNum += Number(data);
break;
case '生命率':
starGroupOffHpPer += Number(data);
break;
case '攻击值':
starGroupOffAtkNum += Number(data);
break;
case '攻击率':
starGroupOffAtkPer += Number(data);
break;
default:
break;
}
});
document.getElementById('TestShow1').textContent =
`角色名称：${nowSelectRoleData.roleName} |职业：${nowSelectRoleData.roleJob} |属性：${roleAttributeValue}`;
let hpAdd = payHP + lifeBF + starOffHpNum + starGroupOffHpNum;
let hpPer = parseFloat((starLevelValue + starOffHpPer + starGroupOffHpPer + lvOfAtkPer).toFixed(6));
let hpOutput = parseFloat(((levelHP + hpAdd) * (1 + hpPer)).toFixed(6));
// document.getElementById('TestH1').textContent = `白值：${levelHP}`;
// document.getElementById('TestH2').textContent = `加算| 氪金：${payHP} |生命蝶：${lifeBF} |星石提供：${starOffHpNum}|星石羁绊提供：${starGroupOffHpNum}`;
// document.getElementById('TestH3').textContent = `乘算| 化极：${starLevelValue} |星石提供：${starOffHpPer}|星石羁绊提供：${starGroupOffHpPer}|修为提供${lvOfAtkPer}`;
document.getElementById('TestH4').textContent = `${hpOutput}`;
document.getElementById('outputLife1').value = Math.floor(`${hpOutput}`);
console.log(
`白值：${levelHP}\n加算| 氪金：${payHP} |生命蝶：${lifeBF} |星石提供：${starOffHpNum}|星石羁绊提供：${starGroupOffHpNum}\n乘算| 化极：${starLevelValue} |星石提供：${starOffHpPer}|星石羁绊提供：${starGroupOffHpPer}|修为提供${lvOfAtkPer}\nX=${hpAdd}|Y=${hpPer} （白值：+x）*（1+y%）=${hpOutput}`
)
let atkAdd = payATK + atkBF + starOffAtkNum + starGroupOffAtkNum;
let atkPer = parseFloat((starLevelValue + starOffAtkPer + starGroupOffAtkPer + lvOfHpPer).toFixed(6));
let atkOutput = parseFloat(((levelATK + atkAdd) * (1 + atkPer)).toFixed(6));
// document.getElementById('TestA1').textContent = `白值：${levelATK}`;
// document.getElementById('TestA2').textContent = `加算| 氪金：${payATK} |攻击蝶：${atkBF} |星石提供：${starOffAtkNum}|星石羁绊提供：${starGroupOffAtkNum}`;
// document.getElementById('TestA3').textContent = `乘算| 化极：${starLevelValue} |星石提供：${starOffAtkPer}|星石羁绊提供：${starGroupOffAtkPer}|修为提供${lvOfHpPer}`;
document.getElementById('TestA4').textContent = `${atkOutput}`;
document.getElementById('outputAtk1').value = Math.floor(`${atkOutput}`);
console.log(
`白值：${levelATK}\n加算| 氪金：${payATK} |攻击蝶：${atkBF} |星石提供：${starOffAtkNum}|星石羁绊提供：${starGroupOffAtkNum}\n乘算| 化极：${starLevelValue} |星石提供：${starOffAtkPer}|星石羁绊提供：${starGroupOffAtkPer}|修为提供${lvOfHpPer}\nX=${atkAdd}|Y=${atkPer} （白值：+x）*（1+y%）=${atkOutput}`
)
}
// 辅助方法 ================================================================
// json查询 ================================================================
// 获取星石数据
function GetStoneJsonData(selectIndex) {
// 获取石头的当前选项
let value = document.getElementById(`StarStone${selectIndex}`).value;
// 寻找是否存在
let getStone = starStoneData.find(function (stone) {
// console.log(`${stone.StoneName}-${stone.Level} ${value}`);
return `${stone.StoneName}-${stone.Level}` === value;
});
// 若空 返回空数组 否则 返回该数据
if (getStone === undefined) return [];
return getStone;
}
// 角色 ================================================================
// 根据传入的职业重新绘制角色列表
function ResetRoleList(type) {
// 获取下拉菜单元素
var selectMenu = document.getElementById('roleSelect');
var beforeSeleRole = selectMenu.value; // 获取原来所选角色
var beforeSeleJob = document.getElementById('roleJob').value; // 获取原来所选职业
// 清空原有选项
selectMenu.innerHTML = ;
// 定义函数用于创建并添加选项
function addOption(roleName) {
// 创建一个新的 <option> 元素
var option = document.createElement('option');
// 设置 <option> 的 value 和文本内容为角色名称
option.value = roleName;
option.text = roleName;
// 将 <option> 添加到下拉菜单中
selectMenu.appendChild(option);
}
// 遍历 roleData 数组
roleData.forEach(function (role) {
// 如果 type 不是破军、龙盾、岐黄、神纪或诡道之一，或者角色的 roleJob 与 type 相同
if (!['破军', '龙盾', '岐黄', '神纪', '诡道'].includes(type) || role.roleJob === type) {
// 添加角色选项
addOption(role.roleName);
}
});
if (beforeSeleJob == type) {
document.getElementById('roleSelect').value = beforeSeleRole;
Role_Switch();
}
}
function GetPayPointValue() {
rolePay = document.getElementById('rolePay');
rolePayLvShow = document.getElementById('rolePayLvShow');
if (parseInt(rolePay.value) <= 20) {
return Math.floor(rolePay.value / 5 + 1 - 0.1);
} else if (rolePay.value == 21) {
return 5;
} else if (rolePay.value == 22) {
return 6;
} else if (rolePay.value == 23) {
return 1;
} else if (rolePay.value == 24) {
return 2;
} else if (rolePay.value == 25) {
return 3;
} else if (rolePay.value == 26) {
return 4;
}
}
// 更新氪金节点
function ResetPayPoint() {
let value = GetPayPointValue();
if (value >= 6) {
document.getElementById('rolePayLvShow').textContent = `觉醒`;
} else {
document.getElementById('rolePayLvShow').textContent = value + `星`;
}
InputOver();
}
// 星石 ================================================================
// 初始时 绘制星石下拉菜单的内容 等级
function DrawStarStoneOption() {
const selectElements = [document.getElementById('StarStone1-LvInput'), document.getElementById(
'StarStone2-LvInput'), document.getElementById('StarStone3-LvInput')];
for (let i = 0; i < selectElements.length; i++) {
let count = 1;
selectElements[i].innerHTML = ;
selectElements[i].add(new Option(0, 0));
for (let j = 0; j < 6; j++) {
for (let k = 1; k <= 10; k++) {
selectElements[i].add(new Option(j * 10 + k, count));
count++;
}
if (count == 0) {} else if (j < 5) {
selectElements[i].add(new Option((j + 1) * 10 + '突破', count));
}
count++;
}
}
}
// 根据传入的信息重新绘制星石列表
// 互斥方法:
// 将其他下拉菜单中选择项排除
// 互斥规则:
// 1 未选择不可被排除
// 2 更新的元素不变化
function ResetStarStoneList(inputIndex) {
// console.info(`重置-星石列表`);
// 缓存下拉列表的元素
const selectElements = GetStoneElements();
// 缓存丢弃列表
const discardedItems = selectElements.map((element) => element.value.split('-')[0]);
console.log(`丢弃列表` + discardedItems);
// 遍历所有 select 元素
for (let i = 0; i < selectElements.length; i++) {
// 本次修改的 select 不更新
if (i == inputIndex - 1) continue;
// 获取当前选择值
let previousSelectValue = selectElements[i].value;
// 清空下拉选项
selectElements[i].innerHTML = ;
// 新建一个未选择
selectElements[i].add(new Option('未选择', '未选择'));
// 遍历 石头数据 数组
starStoneData.forEach((starData) => {
if (CanAddOptions(starData, discardedItems, i + 1)) {
// 设置显示名称(加上紫/蓝 后缀)
let OptionName = starData.StoneName;
switch (starData.Level) {
case 1:
break;
case 2:
OptionName += '(紫)';
break;
case 3:
OptionName += '(蓝)';
break;
default:
break;
}
// 新建选项
let option = new Option(OptionName, `${starData.StoneName}-${starData.Level}`);
// 选项加上class(橙/紫/蓝 颜色)
option.classList.add(`star-${starData.Level}`);
// 选项加入下拉菜单中
selectElements[i].add(option);
}
console.groupEnd();
});
// console.group(`查询值`);
// 遍历所有选项
for (let j = 0; j < selectElements[i].options.length; j++) {
// 检查选项的值是否与目标值相同
if (selectElements[i].options[j].value == previousSelectValue) selectElements[i].value =
previousSelectValue;
// console.info(`${selectElements[i].options[j].value} 和 ${previousSelectValue} 是否相等${selectElements[i].options[j].value == previousSelectValue}`);
}
// console.groupEnd();
}
// 查询是否可以加入
function CanAddOptions(compareStarData, blackList, elementIndex) {
//console.group(`检测石头[${compareStarData.StoneName}]`);
// 当获取到的石头数据 存在职业限制
if (compareStarData.Job_Limit != undefined) {
if (compareStarData.Job_Limit.length > 0) {
//console.log(`石头[${compareStarData.StoneName}]存在职业限制`);
// 遍历 选择的数据 若与当前选择的职业相符合 返回真
for (let i = 0; i < compareStarData.Job_Limit.length; i++) {
if (compareStarData.Job_Limit[i] == nowSelectRoleData.roleJob) {
//console.info(`当前对比的石头[${compareStarData.StoneName}]限制职业[${compareStarData.Job_Limit[i]}] 当前选择的职业[${nowSelectRoleData.roleJob}] 可以增加`);
return true;
}
}
//console.info(`当前对比的石头[${compareStarData.StoneName}]限制职业,不可增加`);
return false;
} else {
//console.log(`石头[${compareStarData.StoneName}]没有职业限制职业1`);
}
} else {
//console.log(`石头[${compareStarData.StoneName}]没有职业限制职业222`);
}
// 对比和原本值一致
if (compareStarData === blackList[elementIndex]) {
//console.log(`石头[${compareStarData.StoneName}]和原先值一致 输出`);
return true;
} else {
for (let j = 0; j < blackList.length; j++) {
//console.log(`石头[${compareStarData.StoneName}]检测互斥[${blackList[j]}] ${compareStarData == blackList[j]}`);
if (compareStarData == blackList[j]) {
return false;
}
}
}
return true;
}
if (inputIndex != 0 && clickUpdate == true) {
MainCalculation();
}
}
// 获取三个石头的元素
function GetStoneElements() {
return [document.getElementById('StarStone1'), document.getElementById('StarStone2'), document.getElementById(
'StarStone3')];
}
// 三个星石的数值合并
function StarStoneValueCombine(...args) {
// console.log('数组参数:', args);
let cacheValue = 0;
for (let i = 0; i < args.length; i += 2) {
if (args[i] === undefined) continue;
if (args[i].length < 65) continue;
if (args[i + 1] == 0) continue;
cacheValue += parseFloat(args[i][parseInt(args[i + 1]) - 1]);
}
// console.log('返回值:', cacheValue);
return parseFloat(cacheValue.toFixed(6));
}
// 更新星石输入信息
function UpdateStarInput(index, UpdateIsInput = true) {
var inputValue = document.getElementById(`StarStone${index}-LvInput`);
var sliderValue = document.getElementById(`StarStone${index}-LvRange`);
// 将输入值转换为整数数值
inputValue.value = parseInt(inputValue.value, 10);
if (UpdateIsInput) {
// 限制输入值的范围为0到65之间
inputValue.value = Math.max(0, Math.min(inputValue.value, 65));
sliderValue.value = inputValue.value;
} else {
inputValue.value = sliderValue.value;
}
InputOver();
}
// 星石组合
function ResetDrawStoneComboButton() {}
// 星石羁绊 ================================================================
// 检测石头羁绊
function DetectionStoneGroup(inputNames) {
// 所有凑够羁绊的组
let matchingGroups = [];
// 循环所有羁绊组
for (let i = 0; i < StoneGroupData.length; i++) {
// 获取当前羁绊需求表
let stoneNames = StoneGroupData[i].StoneNames;
// 检查 羁绊需求 的所有元素是否都在inputNames中存在
let allNamesFound = stoneNames.every(function (name) {
return inputNames.includes(name);
});
// 如果stoneNames中的所有元素都在inputNames中存在，则将该GroupData元素添加到匹配数组中
if (allNamesFound) {
matchingGroups.push(StoneGroupData[i]);
}
}
// console.log(`羁绊获取`);
// console.log(matchingGroups);
return matchingGroups; // 返回匹配的GroupData元素数组
}
// 重新绘制星石组合的内容
function ResetDrawStoneComboButton() {
getJob = nowSelectRoleData.roleJob;
console.info(`当前选择角色的职业为${getJob}`);
let GroupBox = document.getElementById('StoneComboBox');
// 清空组合内的内容
GroupBox.innerHTML = ;
// 创建一个 元素
let i_Element = document.createElement('i');
i_Element.className = 'StoneCombo-Button';
// GroupBox.appendChild(i_Element);
// 遍历 组合 塞入
StoneComboData.forEach(function (ComboData) {
const showValue = ComboData.StoneComboNames.join('+');
let btn = addButton(showValue);
let canSelect = false;
// 石头黑名单 =====
// console.info(`石头黑名单开始`);
// 创建一个空数组来存储不重复的职业
let uniqueJobs = [];
// 遍历 StoneNames 数组中的每个石头
ComboData.StoneComboNames.forEach(function (stoneName) {
// console.info(stoneName);
// 从名称获取数据，获取黑名单
let stoneData = starStoneData.find(function (stone) {
return stone.StoneName === stoneName;
});
// console.log(stoneData);
// console.log(stoneData.Job_Limit);
if (stoneData.Job_Limit != undefined)
// 遍历 Limit 数组
stoneData.Job_Limit.forEach(function (_limit) {
// 检查是否已经包含在不重复的职业数组中，如果没有则添加
if (!uniqueJobs.includes(_limit)) {
uniqueJobs.push(_limit);
}
});
});
// console.info(`获取到所有黑名单职业`);
// console.info(uniqueJobs);
// 如果限制列表存在限制 那么只有当出现在黑名单中，才可以添加
if (uniqueJobs.length > 0) {
uniqueJobs.forEach(function (job) {
if (getJob == job) {
canSelect = true;
console.log(`${getJob}出现在黑名单中，可以添加`);
return; // 在这里使用 return 跳出当前循环
// 禁止添加
}
});
} else {
canSelect = true;
}
if (!canSelect) {
btn.disabled = true;
// 添加一个额外的类
btn.classList.add('btn-disabled');
}
});
addButton('清除选择');
function addButton(btn) {
// 创建一个新的按钮元素
let GroupBtn = document.createElement('button'); // 设置按钮的 class
GroupBtn.className = 'StoneCombo-Button';
// 设置按钮的 id
GroupBtn.id = btn;
// 设置按钮的文本内容
GroupBtn.innerHTML = btn;
// 绑定点击事件
GroupBtn.onclick = function () {
// 直接获取被点击按钮的 id
let buttonId = this.id;
console.log('点击的按钮的id是：' + buttonId);
StoneGroupSelect(buttonId);
};
GroupBox.appendChild(GroupBtn);
return GroupBtn;
}
}
// 选择组合
function StoneGroupSelect(getId) {
var StoneGroup_Parts;
if (getId == '清除选择' || getId == 'remove') {
getId = 'remove';
StoneGroup_Parts = ['未选择', '未选择', '未选择'];
} else {
// 使用split方法拆分字符串
StoneGroup_Parts = getId.split('+');
if (StoneGroup_Parts.length < 3) StoneGroup_Parts.push('未选择');
}
console.log(`输出要更新的组合` + StoneGroup_Parts); // 输出: ["紫薇", "天相"]
var buttons = document.querySelectorAll('.StoneCombo-Button');
buttons.forEach(function (button) {
button.classList.remove('pressed');
});
var targetButton = document.getElementById(getId);
if (targetButton != undefined) {
targetButton.classList.toggle('pressed');
}
let stoneEnems = GetStoneElements();
for (let i = 0; i < stoneEnems.length; i++) {
if (StoneGroup_Parts[i] != '未选择') StoneGroup_Parts[i] += `-1`;
stoneEnems[i].value = StoneGroup_Parts[i];
}
InputOver();
}
// 组合状态(是否可用)
function StoneGroupState() {
var GroupBox = document.getElementById('StoneComboBox');
var buttonsInGroupBox = GroupBox.querySelectorAll('button');
console.info(buttonsInGroupBox);
buttonsInGroupBox.forEach(function (button) {
let jobs = button.value.split('+');
for (let i = 0; i < jobs.length; i++) {}
});
}
// 蝶 ================================================================
// 更新蝶输入信息
function UpdateBFInput(idName) {
var cacheValue = document.getElementById(idName).value;
// 获取最大值
if (idName == 'lifeBF') {
var maxValue = HP_BF_SliderMax;
// 设置为25的倍数
cacheValue = Math.ceil(cacheValue / 25) * 25;
} else if (idName == 'atkBF') {
var maxValue = ATK_BF_SliderMax;
// 设置为25的倍数
cacheValue = Math.ceil(cacheValue / 5) * 5;
}
// 设置在0到最大值之间
cacheValue = Math.max(0, Math.min(maxValue, cacheValue));
// 输入框更新
document.getElementById(`${idName}-Range`).value = cacheValue;
}
// 更新蝶滑条
function UpdateBFSlider(idName) {
var sliderValue = document.getElementById(idName + `-Range`).value;
// 获取最大值
if (idName == 'lifeBF') {
var maxValue = HP_BF_SliderMax;
} else if (idName == 'atkBF') {
var maxValue = ATK_BF_SliderMax;
}
// 设置在0到最大值之间
sliderValue = Math.max(0, Math.min(maxValue, sliderValue));
// 输入框更新
document.getElementById(idName).value = sliderValue;
}
// 最终结果=（初始值+x）*（1+y%）
// x=蝶+[星石值]+[星石套装值]+ (加or减)[节点属性] // 蝶(直接数值) 星石(暂置空) 节点属性
// y = 1+化极+星石+星石套装
</script>
沪公网安备 31011002002714 号