mirror of
https://github.com/babalae/bettergi-scripts-list.git
synced 2026-11-17 04:17:45 +00:00
* 锄地添加新路线 * 1 * 1 * 2 * Update settings.json * Update manifest.json * 3 * 重构锄地与狗粮脚本并完善配置文档 PR 描述 变更概述 本 PR 主要涉及 AutoHoeingOneDragon 和 AAA-Artifacts-Bulk-Supply 两个 JS 脚本,包含运行逻辑修复、代码结构整理、配置项调整及 README 重写。 AutoHoeingOneDragon - 重排 main.js 代码结构,按功能集中声明全局变量、常量和识别对象。 - 提取屏幕区域、识别阈值、延时、冷却时间和记录数量等常量。 - 修复 disableAsync 在非运行模式下错误等待不存在队伍切换任务的问题。 - 移除配队合理性校验及其强制终止逻辑,保留指定角色成员确认功能。 - 修复首次运行时拾取历史 items 未初始化的问题。 - 修复药品监控逻辑: - 识别到目标时确认计数增加; - 未识别到目标时确认计数减少; - 达到阈值后使用料理并清零; - 使用次数按分钟窗口重置; - 药品配置统一转换为非负整数,避免默认字符串 "0" 启动无效监控。 - 增加自定义路线逐文件读取和解析容错,损坏路线会记录错误并跳过。 - 调整路线组合迭代条件、目标余量、迭代上限和路线剔除逻辑。 - 修复路线结果判定和运行记录写入时机: - 优先使用宿主返回的 success; - 无返回值时按配置决定是否执行坐标校验; - 失败路线不更新 CD、不写入运行时长。 - 优化晶蝶辅助传送和坐标缓存逻辑。 - 修复非模板拾取模式下 onlyRelatedItems 遍历 null 的问题。 - 增加截图缓存上限、并发控制和旧截图释放逻辑。 - 修复模板匹配区域的资源释放和隐式全局变量问题。 - 删除无效变量、遗留代码和旧拾取历史注释代码。 - 修复单独填写小时限制时 8:59 无法匹配的问题。 - 统一处理路线标签、优先关键词和排除关键词中的空白字符。 AutoHoeingOneDragon 配置与文档 - 调整 settings.json 配置项顺序: - disableAsync 放入队伍相关配置; - logMonsterCount 放入运行辅助配置; - 自动优化配置放到目标数量及优先/排除关键词之后; - 路径组 5-10 配置保留在后部; - 移除 skipCheck 配置项。 - 重写 README,重新划分为功能与前提、快速上手、配队建议、进阶技巧、配置说明、运行逻辑、故障排查和交流等章节。 - 删除攻击性、嘲讽性、命令式及绝对化内容。 - 保留 QQ 群 1109232869 和相关项目介绍。 - 增加正常模式及仅指定怪物模式的最简配置。 - 增加配队建议、路线分组示例、精英路线狗粮收益说明和盗宝团好感任务使用方法。 - 增加 BetterGI 地图追踪 JSON 格式、自定义路线和自定义模板图片说明。 - 使用 <details> 折叠详细配置说明。 - 增加调试路线输出不会自动清除旧文件的故障排查说明。 - 增加宿主返回值、坐标校验和运行记录处理逻辑说明。 AAA-Artifacts-Bulk-Supply - 修复非法账户名回退逻辑,统一使用回退后的有效账户名读写记录和 CD 数据。 - 可选路线目录不存在时直接跳过,避免产生无意义的异常日志。 - 将“只激活收尾和额外路线,不执行”改名为“联机收尾模式”,并同步调整配置说明。 - 重写并扩展 README: - 增加快速开始和运行前提; - 增加稳定、急速、联机三种配置说明; - 增加配置格式限制; - 补充调查点收益、刷新机制、路线结构和运行时间线; - 修正 README 内部锚点链接; - 保留“琪零”和“芽一”等原有名称。
3822 lines
No EOL
151 KiB
JavaScript
3822 lines
No EOL
151 KiB
JavaScript
// 3.0.5
|
||
|
||
/* ===== 1. 自定义配置 ===== */
|
||
const timeMoveUp = Math.round((settings.timeMove || 1000) * 0.45);
|
||
const timeMoveDown = Math.round((settings.timeMove || 1000) * 0.55);
|
||
const accountName = settings.infoFileName || "默认账户";
|
||
const operationMode = settings.operationMode || "执行任务(若不存在索引文件则自动创建)";
|
||
let loopMode = 1; // 默认不循环
|
||
// ---- loopMode 配置迁移 ----
|
||
let rawLoop = settings.loopMode; // 新字段优先
|
||
if (rawLoop === undefined && settings.loopCollect !== undefined) {
|
||
rawLoop = settings.loopCollect; // 兼容旧字段
|
||
}
|
||
if (typeof rawLoop === 'boolean') {
|
||
loopMode = rawLoop ? 3 : 1; // true→全局循环(3),false→不循环(1)
|
||
// 写入兼容后的字符串,防止 UI 面板回显空白
|
||
settings.loopMode = rawLoop ? "全局循环" : "不循环";
|
||
} else if (typeof rawLoop === 'string') {
|
||
// 新配置存储的是中文,映射为数字
|
||
switch (rawLoop) {
|
||
case "不循环": loopMode = 1; break;
|
||
case "每组重试": loopMode = 2; break;
|
||
case "全局循环": loopMode = 3; break;
|
||
default: loopMode = 1;
|
||
}
|
||
} else {
|
||
loopMode = 1; // 默认不循环
|
||
}
|
||
const disableJsons = settings.disableJsons || "";
|
||
// 拾取模式:模板匹配拾取(JS自行识别,默认) / bgi原版拾取(由BetterGI AutoPick触发器拾取)
|
||
let pickup_Mode;
|
||
let processingIngredient = settings.processingIngredient;
|
||
let findFInterval = Math.max(16, Math.min(200, parseInt(settings.findFInterval) || 100));
|
||
let checkInterval = +settings.checkInterval || 50;
|
||
let groupCount;
|
||
/* ===== 2. 使用的模板和识别对象 ===== */
|
||
const mainUiRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/MainUI.png"), 0, 0, 150, 150);
|
||
const fullRoi = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/itemFull.png"), 0, 0, 1920, 1080);
|
||
const FiconRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/F_Dialogue.png"), 1102, 335, 34, 400);
|
||
FiconRo.Threshold = 0.9;
|
||
FiconRo.InitTemplate();
|
||
const frozenRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/解除冰冻.png"), 1379, 574, 1463 - 1379, 613 - 574);
|
||
const revivalRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/复苏.png"), 755, 915, 1117 - 755, 1037 - 915);
|
||
revivalRo.Threshold = 0.9;
|
||
revivalRo.InitTemplate();
|
||
const revival_2_Ro = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/复苏_联机.png"), 930, 1000, 100, 50);
|
||
revival_2_Ro.Threshold = 0.9;
|
||
revival_2_Ro.InitTemplate();
|
||
const scrollRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/拾取滚轮.png"), 1017, 496, 1093 - 581, 581 - 496);
|
||
|
||
/* ===== 3. 全局通用常量 ===== */
|
||
const targetItemPath = "assets/targetItems";
|
||
const recordFolder = "record";
|
||
const rollingDelay = 32;
|
||
const pickupDelay = 100;
|
||
const MAX_PICKUP_DAYS = 30;
|
||
const cookInterval = 95 * 60 * 1000;
|
||
const settimeInterval = 10 * 60 * 1000;
|
||
|
||
/* ===== 4. 全局通用变量 ===== */
|
||
let currentParty = '';
|
||
let targetItems = [];
|
||
let blacklist = [];
|
||
let blacklistSet = new Set();
|
||
let gameRegion;
|
||
let state = { running: true };
|
||
state.runPickupLog = []; // 本次路线运行中拾取/交互的物品明细
|
||
let routeRunCount = {}; // 全局路线执行次数记录 { routeName: count }
|
||
let pickupRecordFile;
|
||
let firstCook = true;
|
||
let firstsettime = true;
|
||
let lastCookTime = new Date();
|
||
let lastsettimeTime = new Date();
|
||
let lastMapName = "";
|
||
let disableArray = [];
|
||
if (disableJsons) {
|
||
let tmp = disableJsons.split(';');
|
||
for (let k = 0; k < tmp.length; k++) {
|
||
let s = tmp[k].trim();
|
||
if (s) disableArray[disableArray.length] = s;
|
||
}
|
||
}
|
||
let lastRoll = new Date();
|
||
let Foods = [];
|
||
let folderNames;
|
||
let partyNames;
|
||
let subFolderName;
|
||
let subFolderPath;
|
||
let recordFilePath;
|
||
// ===== 总运行限时(分钟)状态 =====
|
||
let scriptStartTime = Date.now(); // 脚本启动时间,作为总运行限时的起算点
|
||
let runtimeLimitReached = false; // 是否已达运行限时
|
||
|
||
/**
|
||
* 检测是否已达到总运行限时
|
||
* 读取 settings.maxRuntimeMinutes(0=不限时),从脚本启动起算;
|
||
* 由各阶段在完成任意路线后调用,超时返回 true 并一次性打印日志/通知
|
||
* @returns {boolean} 是否已超时
|
||
*/
|
||
function checkRuntimeLimit() {
|
||
const limit = parseInt(settings.maxRuntimeMinutes) || 0;
|
||
if (limit > 0 && Date.now() - scriptStartTime >= limit * 60000) {
|
||
if (!runtimeLimitReached) {
|
||
runtimeLimitReached = true;
|
||
log.info(`已达到总运行限时 ${limit} 分钟,结束脚本`);
|
||
notification.send(`已达到总运行限时 ${limit} 分钟,结束脚本`);
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
let name2Other;
|
||
let alias2Names;
|
||
const GAME_REGION_CACHE_SIZE = 5; // 游戏区域截图缓存大小上限
|
||
const gameRegionManager = {
|
||
cache: [], // 缓存队列,保存近GAME_REGION_CACHE_SIZE张截图
|
||
lastCapture: new Date(),
|
||
isDisposing: false,
|
||
isCapturing: false
|
||
};
|
||
|
||
/* ===== 5. 待定分区(后续手动分类) ===== */
|
||
let materialCdMap = {};
|
||
|
||
(async function () {
|
||
dispatcher.AddTrigger(new RealtimeTimer("AutoSkip"));
|
||
// ==================== 拾取模式 ====================
|
||
// 模板匹配拾取:JS 自行识别拾取(默认,产量记录完整)
|
||
// bgi原版拾取:由 BetterGI AutoPick 实时触发器完成拾取,JS 通过 dispatcher.getPickRecords() 取回拾取记录,
|
||
// 记录同样写入 runPickupLog,驱动 CD 计算、历史统计、每日拾取记录与优先材料扣减
|
||
pickup_Mode = settings.pickup_Mode || "模板匹配拾取";
|
||
if (pickup_Mode === "bgi原版拾取") {
|
||
dispatcher.AddTrigger(new RealtimeTimer("AutoPick"));
|
||
log.info("拾取模式:bgi原版拾取(由 BetterGI AutoPick 触发器完成拾取)");
|
||
}
|
||
// ==================== 构建 settings.json ====================
|
||
if (!await buildSettingsJson()) {
|
||
return;
|
||
}
|
||
// ==================== 初始化设置和记录文件 ====================
|
||
await initializeSetup();
|
||
|
||
// ==================== 优先级材料前置采集 ====================
|
||
await processPriorityItems();
|
||
|
||
// ==================== 一次性优先材料采集(优先级低于每日优先) ====================
|
||
if (!runtimeLimitReached) {
|
||
await processOneTimePriorityItems();
|
||
}
|
||
|
||
// ==================== 路径组循环 ====================
|
||
if (!runtimeLimitReached) {
|
||
await processPathGroups();
|
||
}
|
||
})();
|
||
|
||
/**
|
||
* 识别并交互函数
|
||
* 该函数会持续运行,识别游戏中的 F 图标并进行交互,同时处理背包满的情况
|
||
*
|
||
* @returns {Promise<void>} 无返回值,函数会一直运行直到 state.running 为 false
|
||
*
|
||
* @依赖全局变量:
|
||
* - gameRegion: 游戏区域对象
|
||
* - state: 状态对象,包含 running 标志和 runPickupLog 日志数组
|
||
* - blacklistSet: 黑名单集合,用于过滤不需要交互的物品
|
||
* - targetItems: 目标物品数组
|
||
* - lastRoll: 上次滚动时间
|
||
* - timeMoveUp: 向上移动时间
|
||
* - timeMoveDown: 向下移动时间
|
||
* - pickupDelay: 拾取延迟时间
|
||
* - rollingDelay: 滚动延迟时间
|
||
*
|
||
* @依赖辅助函数:
|
||
* - findFIcon: 寻找 F 图标函数
|
||
* - hasScroll: 检查是否存在拾取滚轮图标函数
|
||
* - performTemplateMatch: 执行模板匹配函数
|
||
* - checkItemFullAndOCR: 检查背包是否满并进行 OCR 识别函数
|
||
* - sleep: 延迟函数
|
||
*/
|
||
async function recognizeAndInteract() {
|
||
let lastcenterYF = 0, lastItemName = "", thisMoveUpTime = 0, lastMoveDown = 0;
|
||
let lastCheckItemFull = new Date();
|
||
let lastFreezeCheck = new Date();
|
||
let lastRevivalCheck = new Date();
|
||
let checkTask = null;
|
||
let freezeTask = null;
|
||
let revivalTask = null;
|
||
|
||
while (state.running) {
|
||
gameRegion = await getGameRegion();
|
||
|
||
// === 解除冰冻检测(每250毫秒) ===
|
||
if (new Date() - lastFreezeCheck > 250 && !freezeTask) {
|
||
lastFreezeCheck = new Date();
|
||
freezeTask = checkAndBreakFreeze();
|
||
}
|
||
|
||
// === 复苏检测(每500毫秒) ===
|
||
if (new Date() - lastRevivalCheck > 500 && !revivalTask) {
|
||
lastRevivalCheck = new Date();
|
||
revivalTask = checkAndClickRevival();
|
||
}
|
||
|
||
if (new Date() - lastCheckItemFull > 2500 && !checkTask) {
|
||
lastCheckItemFull = new Date();
|
||
checkTask = checkItemFullAndOCR();
|
||
}
|
||
|
||
const centerYF = await findFIcon();
|
||
|
||
if (!centerYF) {
|
||
if (new Date() - lastRoll >= 200) {
|
||
lastRoll = new Date();
|
||
if (await hasScroll()) {
|
||
await keyMouseScript.runFile(`assets/滚轮下翻.json`);
|
||
}
|
||
}
|
||
// 处理并发的冰冻检测
|
||
if (freezeTask) {
|
||
try { await freezeTask; }
|
||
catch (e) { log.error('冰冻检测异常:', e); }
|
||
finally { freezeTask = null; }
|
||
}
|
||
if (revivalTask) {
|
||
try { await revivalTask; }
|
||
catch (e) { log.error('复苏检测异常:', e); }
|
||
finally { revivalTask = null; }
|
||
}
|
||
if (checkTask) {
|
||
try { await checkTask; }
|
||
catch (e) { log.error('背包满检查异常:', e); }
|
||
finally { checkTask = null; }
|
||
}
|
||
continue;
|
||
}
|
||
let itemName = null;
|
||
itemName = await performTemplateMatch(centerYF);
|
||
if (itemName) {
|
||
if (Math.abs(lastcenterYF - centerYF) <= 20 && lastItemName === itemName) {
|
||
await sleep(160);
|
||
lastcenterYF = -20;
|
||
lastItemName = null;
|
||
if (checkTask) {
|
||
try { await checkTask; }
|
||
catch (e) { log.error('背包满检查异常:', e); }
|
||
finally { checkTask = null; }
|
||
}
|
||
continue;
|
||
}
|
||
if (!blacklistSet.has(itemName)) {
|
||
keyPress("F");
|
||
log.info(`交互或拾取:"${itemName}"`);
|
||
/* >>> 提到最前 begin >>> */
|
||
const idx = targetItems.findIndex(it => it.itemName === itemName);
|
||
if (idx > 0) {
|
||
const [it] = targetItems.splice(idx, 1);
|
||
targetItems.unshift(it);
|
||
}
|
||
/* <<< 提到最前 end <<< */
|
||
state.runPickupLog.push(itemName);
|
||
|
||
lastcenterYF = centerYF;
|
||
lastItemName = itemName;
|
||
await sleep(pickupDelay);
|
||
}
|
||
} else {
|
||
lastItemName = "";
|
||
}
|
||
const currentTime = Date.now();
|
||
if (currentTime - lastMoveDown > timeMoveUp) {
|
||
await keyMouseScript.runFile(`assets/滚轮下翻.json`);
|
||
if (thisMoveUpTime === 0) thisMoveUpTime = currentTime;
|
||
if (currentTime - thisMoveUpTime >= timeMoveDown) {
|
||
lastMoveDown = currentTime;
|
||
thisMoveUpTime = 0;
|
||
}
|
||
} else {
|
||
await keyMouseScript.runFile(`assets/滚轮上翻.json`);
|
||
}
|
||
await sleep(rollingDelay);
|
||
if (freezeTask) {
|
||
try { await freezeTask; }
|
||
catch (e) { log.error('冰冻检测异常:', e); }
|
||
finally { freezeTask = null; }
|
||
}
|
||
if (revivalTask) {
|
||
try { await revivalTask; }
|
||
catch (e) { log.error('复苏检测异常:', e); }
|
||
finally { revivalTask = null; }
|
||
}
|
||
if (checkTask) {
|
||
try { await checkTask; }
|
||
catch (e) { log.error('背包满检查异常:', e); }
|
||
finally { checkTask = null; }
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 启动拾取伴随任务(随路线执行并发运行,state.running 置 false 后结束)
|
||
* 根据拾取模式选择:
|
||
* - 模板匹配拾取:JS 自行识别拾取(recognizeAndInteract)
|
||
* - bgi原版拾取:轮询 dispatcher.getPickRecords() 取回 BetterGI 自动拾取的记录
|
||
* @returns {Promise<void>} 拾取任务 Promise,应在 state.running 置 false 后 await 其结束
|
||
*/
|
||
function startPickupTask() {
|
||
if (pickup_Mode === "bgi原版拾取") {
|
||
return pollPickRecordsTask();
|
||
}
|
||
return recognizeAndInteract();
|
||
}
|
||
|
||
/**
|
||
* 轮询取回 BetterGI 莫版拾取记录(bgi原版拾取模式专用)
|
||
* 拾取由 AutoPick 实时触发器完成,这里周期性调用 dispatcher.getPickRecords() 取回拾取历史,
|
||
* 写入 state.runPickupLog,与模板匹配拾取共用同一数据通道:
|
||
* 后续的 CD 计算(按材料取最晚刷新)、历史统计、每日拾取记录、优先材料扣减全部复用。
|
||
* 旧版 C# 无 getPickRecords 时通过可选链 + try 安全降级(不报错、不记录)。
|
||
* @returns {Promise<void>} 一直运行直到 state.running 为 false
|
||
*/
|
||
async function pollPickRecordsTask() {
|
||
// 启动时先取空一次拾取历史(取出即清空),防止上次运行残留记录混入本次统计
|
||
try {
|
||
dispatcher.getPickRecords?.();
|
||
} catch (e) { /* 旧版 C# 不支持 getPickRecords,忽略 */ }
|
||
while (state.running) {
|
||
try {
|
||
const records = dispatcher.getPickRecords?.() ?? [];
|
||
for (const r of records) {
|
||
state.runPickupLog.push(r.Name);
|
||
log.info(`交互或拾取:"${r.Name}"`);
|
||
}
|
||
} catch (e) {
|
||
break; // 旧版 C# 不支持 getPickRecords,降级停止轮询
|
||
}
|
||
await sleep(100);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 寻找 F 图标函数
|
||
* 在游戏区域中查找 F 图标,并返回其中心 Y 坐标
|
||
*
|
||
* @returns {Promise<number|null>} 返回 F 图标的中心 Y 坐标,如果未找到则返回 null
|
||
*
|
||
* @依赖全局变量:
|
||
* - gameRegion: 游戏区域对象
|
||
* - FiconRo: F 图标的识别对象
|
||
* - findFInterval: 识别间隔时间
|
||
*
|
||
* @依赖辅助函数:
|
||
* - sleep: 延迟函数
|
||
*/
|
||
async function findFIcon() {
|
||
try {
|
||
const r = gameRegion.find(FiconRo);
|
||
if (r.isExist()) return Math.round(r.y + r.height / 2);
|
||
} catch (e) {
|
||
log.error(`findFIcon:${e.message}`);
|
||
}
|
||
await sleep(findFInterval);
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 执行模板匹配函数
|
||
* 在指定的 Y 坐标位置,对不同宽度的区域进行模板匹配,识别物品名称
|
||
*
|
||
* @param {number} centerYF - F 图标的中心 Y 坐标
|
||
* @returns {Promise<string|null>} 返回识别到的物品名称,如果未识别到则返回 null
|
||
*
|
||
* @依赖全局变量:
|
||
* - gameRegion: 游戏区域对象
|
||
* - targetItems: 目标物品数组,包含物品的名称和识别对象
|
||
*
|
||
* @依赖辅助函数:
|
||
* 无
|
||
*/
|
||
async function performTemplateMatch(centerYF) {
|
||
/* 一次性切 6 种宽度(0-5 汉字) */
|
||
const regions = [];
|
||
for (let cn = 0; cn <= 6; cn++) { // 0~5 共 6 档
|
||
// 增加 20 像素,兼容化种匣的括号/种子后缀
|
||
const w = 12 + 28 * Math.min(cn, 5) + 2 + 20;
|
||
regions[cn] = gameRegion.DeriveCrop(1219, centerYF - 15, w, 30);
|
||
}
|
||
|
||
try {
|
||
let firstMatch = null;
|
||
for (const it of targetItems) {
|
||
const cnLen = Math.min(
|
||
[...it.itemName].filter(c => c >= '\u4e00' && c <= '\u9fff').length,
|
||
5
|
||
); // 0-5
|
||
|
||
if (regions[cnLen].find(it.roi).isExist()) {
|
||
firstMatch = it;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!firstMatch) return null;
|
||
|
||
if (!settings.disableSecondCheck) {
|
||
const cnLen = Math.min(
|
||
[...firstMatch.itemName].filter(c => c >= '\u4e00' && c <= '\u9fff').length,
|
||
5
|
||
);
|
||
if (regions[cnLen].find(firstMatch.roi).isExist()) {
|
||
return firstMatch.itemName;
|
||
}
|
||
return null;
|
||
} else {
|
||
return firstMatch.itemName;
|
||
}
|
||
} catch (e) {
|
||
log.error(`performTemplateMatch: ${e.message}`);
|
||
} finally {
|
||
regions.forEach(r => r.dispose());
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 检查是否为主界面函数
|
||
* 检查游戏是否处于主界面状态
|
||
*
|
||
* @returns {Promise<boolean>} 返回是否为主界面,true 表示是主界面,false 表示不是
|
||
*
|
||
* @依赖全局变量:
|
||
* - gameRegion: 游戏区域对象
|
||
* - mainUiRo: 主界面的识别对象
|
||
* - state: 状态对象,包含 running 标志
|
||
* - findFInterval: 识别间隔时间
|
||
*
|
||
* @依赖辅助函数:
|
||
* - sleep: 延迟函数
|
||
*/
|
||
async function isMainUI() {
|
||
for (let i = 0; i < 1 && state.running; i++) {
|
||
gameRegion = await getGameRegion();
|
||
try {
|
||
if (gameRegion.find(mainUiRo).isExist()) {
|
||
return true;
|
||
}
|
||
} catch (e) {
|
||
log.error(`isMainUI:${e.message}`);
|
||
}
|
||
await sleep(findFInterval);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 检测并挣脱冰冻状态
|
||
*/
|
||
async function checkAndBreakFreeze() {
|
||
try {
|
||
if (gameRegion.find(frozenRo).isExist()) {
|
||
log.info("检测到冻结,尝试挣脱");
|
||
for (let m = 0; m < 3; m++) {
|
||
keyPress("VK_SPACE");
|
||
await sleep(30);
|
||
}
|
||
}
|
||
} catch (error) {
|
||
// 忽略识别错误
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检测并点击复苏按钮
|
||
* 当角色死亡出现复苏界面时,自动点击复苏按钮
|
||
* @returns {Promise<boolean>} 是否检测到并点击了复苏按钮
|
||
*/
|
||
async function checkAndClickRevival() {
|
||
try {
|
||
const rg = await getGameRegion();
|
||
const roList = [revivalRo, revival_2_Ro];
|
||
for (const ro of roList) {
|
||
const res = rg.find(ro);
|
||
if (res.isExist()) {
|
||
log.info("检测到复苏按钮,点击");
|
||
res.click();
|
||
return true;
|
||
}
|
||
}
|
||
} catch (error) {
|
||
// 忽略识别错误
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 检查背包是否满并进行 OCR 识别函数
|
||
* 检查游戏背包是否已满,并通过 OCR 识别物品名称,将满的物品加入黑名单
|
||
*
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - gameRegion: 游戏区域对象
|
||
* - fullRoi: 背包满的识别对象
|
||
* - targetItems: 目标物品数组
|
||
* - blacklist: 黑名单数组
|
||
* - blacklistSet: 黑名单集合
|
||
*
|
||
* @依赖辅助函数:
|
||
* - loadBlacklist: 加载黑名单函数
|
||
*/
|
||
async function checkItemFullAndOCR() {
|
||
try {
|
||
if (!gameRegion.find(fullRoi).isExist()) return;
|
||
} catch (e) { return; }
|
||
const TEXT_X = 560, TEXT_Y = 450, TEXT_W = 800, TEXT_H = 170;
|
||
let ocrText = null;
|
||
try {
|
||
const list = gameRegion.findMulti(RecognitionObject.ocr(TEXT_X, TEXT_Y, TEXT_W, TEXT_H));
|
||
if (list.count) {
|
||
let longest = list[0];
|
||
for (let i = 1;
|
||
i < list.count;
|
||
i++) if (list[i].text.length > longest.text.length) longest = list[i];
|
||
ocrText = longest.text.replace(/[^\u4e00-\u9fa5]/g, '');
|
||
}
|
||
} catch (e) {
|
||
log.error(`OCR:${e.message}`);
|
||
} if (!ocrText) return;
|
||
log.info(`背包满OCR:${ocrText}`);
|
||
|
||
function calcMatchRatio(cnPart, txt) {
|
||
if (!cnPart || !txt) return 0;
|
||
const len = cnPart.length;
|
||
let maxMatch = 0;
|
||
for (let i = 0; i <= txt.length - len; i++) {
|
||
let match = 0;
|
||
for (let j = 0; j < len; j++) {
|
||
if (txt[i + j] === cnPart[j]) match++;
|
||
maxMatch = Math.max(maxMatch, match);
|
||
}
|
||
}
|
||
return maxMatch / len;
|
||
}
|
||
const ratioMap = new Map();
|
||
for (const it of targetItems) {
|
||
const candNames = [it.itemName, ...(it.otherName || [])];
|
||
let maxRatioThisItem = 0;
|
||
for (const name of candNames) {
|
||
const ratio = calcMatchRatio(name.replace(/[^\u4e00-\u9fa5]/g, ''), ocrText);
|
||
if (ratio > maxRatioThisItem) maxRatioThisItem = ratio;
|
||
}
|
||
if (maxRatioThisItem > 0.75) {
|
||
const oldMax = ratioMap.get(it.itemName) || 0;
|
||
if (maxRatioThisItem > oldMax) ratioMap.set(it.itemName, maxRatioThisItem);
|
||
}
|
||
}
|
||
if (ratioMap.size === 0) return;
|
||
const maxRatio = Math.max(...ratioMap.values());
|
||
const names = [...ratioMap.entries()].filter(([, r]) => r === maxRatio).map(([n]) => n).sort();
|
||
log.warn(`背包满,黑名单加入:${names.join('、')}(${(maxRatio * 100).toFixed(1)}%)`);
|
||
for (const n of names) {
|
||
blacklistSet.add(n);
|
||
blacklist.push(n);
|
||
}
|
||
await loadBlacklist(true);
|
||
}
|
||
|
||
/**
|
||
* 加载目标物品图片函数
|
||
* 加载指定路径下的目标物品图片,解析图片名称和阈值,并创建识别对象
|
||
*
|
||
* @returns {Promise<Array>} 返回加载的物品数组,每个物品包含模板、名称、识别对象等信息
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* - readFolder: 读取文件夹函数
|
||
*/
|
||
async function loadTargetItems() {
|
||
const targetItemPath = "assets/targetItems/";
|
||
|
||
const items = await readFolder(targetItemPath, false);
|
||
|
||
for (const it of items) {
|
||
try {
|
||
it.template = file.ReadImageMatSync(it.fullPath);
|
||
it.itemName = it.fileName.replace(/\.png$/i, '');
|
||
it.roi = RecognitionObject.TemplateMatch(it.template);
|
||
|
||
/* ---------- 1. 解析小括号阈值 ---------- */
|
||
const match = it.fullPath.match(/[((](.*?)[))]/);
|
||
const itsThreshold = (match => {
|
||
if (!match) return 0.9;
|
||
const v = parseFloat(match[1]);
|
||
return !isNaN(v) && v >= 0 && v <= 1 ? v : 0.9;
|
||
})(match);
|
||
it.roi.Threshold = itsThreshold;
|
||
it.roi.InitTemplate();
|
||
|
||
/* ---------- 2. 解析中括号内容 + 纯中文过滤 ---------- */
|
||
const otherNames = new Set();
|
||
|
||
// 一次性扫描完整路径里的所有 []
|
||
for (const m of it.fullPath.matchAll(/\[(.*?)\]/g)) {
|
||
const pure = (m[1] || '').replace(/[^\u4e00-\u9fff]/g, '').trim();
|
||
if (pure) otherNames.add(pure);
|
||
}
|
||
|
||
// 若 itemName 本身含非中文,也生成纯中文别名
|
||
const namePure = it.itemName.replace(/[^\u4e00-\u9fff]/g, '').trim();
|
||
if (namePure && namePure !== it.itemName) otherNames.add(namePure);
|
||
|
||
it.otherName = Array.from(otherNames);
|
||
|
||
} catch (error) {
|
||
log.error(`[loadTargetItems] ${it.fullPath}: ${error.message}`);
|
||
}
|
||
}
|
||
return items;
|
||
}
|
||
|
||
/**
|
||
* 加载黑名单函数
|
||
* 从文件中加载黑名单,并将其合并到内存中的黑名单数组和集合中
|
||
*
|
||
* @param {boolean} writeBack - 是否将黑名单写回文件
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - accountName: 账户名称
|
||
* - blacklist: 黑名单数组
|
||
* - blacklistSet: 黑名单集合
|
||
* - settings: 设置对象
|
||
* - disableArray: 禁用关键词数组
|
||
*
|
||
* @依赖辅助函数:
|
||
* 无
|
||
*/
|
||
async function loadBlacklist(writeBack) {
|
||
try {
|
||
const raw = await file.readText(`blacklists/${accountName}.json`);
|
||
blacklist = [...new Set([...blacklist, ...JSON.parse(raw)])];
|
||
} catch { /* 文件不存在就跳过 */ }
|
||
blacklistSet = new Set(blacklist);
|
||
|
||
// 仅把 blacklist 中的中文部分合并到内存中的 settings.disableJsons
|
||
const chineseParts = blacklist
|
||
.map(name => name.replace(/[^\u4e00-\u9fa5]/g, ''))
|
||
.filter(Boolean);
|
||
|
||
const existing = settings.disableJsons
|
||
? settings.disableJsons.split(';').map(s => s.trim()).filter(Boolean)
|
||
: [];
|
||
|
||
const merged = [...new Set([...existing, ...chineseParts])].sort().join(';');
|
||
settings.disableJsons = merged;
|
||
|
||
if (writeBack) {
|
||
await file.writeText(`blacklists/${accountName}.json`, JSON.stringify(blacklist, null, 2), false);
|
||
}
|
||
// 实时同步禁用关键词数组
|
||
disableArray = settings.disableJsons.split(';').map(s => s.trim()).filter(Boolean);
|
||
}
|
||
|
||
/**
|
||
* 伪造日志函数
|
||
* 用于在日志中伪造脚本或地图追踪的开始和结束信息
|
||
*
|
||
* @param {string} name - 脚本或地图追踪的名称
|
||
* @param {boolean} isJs - 是否为JS脚本
|
||
* @param {boolean} isStart - 是否为开始信息
|
||
* @param {number} duration - 持续时间(毫秒),仅在伪造结束信息时有效
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* - sleep: 延迟函数
|
||
*/
|
||
async function fakeLog(name, isJs, isStart, duration) {
|
||
await sleep(1);
|
||
const currentTime = Date.now();
|
||
// 参数检查
|
||
if (typeof name !== 'string') {
|
||
log.error("参数 'name' 必须是字符串类型!");
|
||
return;
|
||
}
|
||
if (typeof isJs !== 'boolean') {
|
||
log.error("参数 'isJs' 必须是布尔型!");
|
||
return;
|
||
}
|
||
if (typeof isStart !== 'boolean') {
|
||
log.error("参数 'isStart' 必须是布尔型!");
|
||
return;
|
||
}
|
||
if (typeof currentTime !== 'number' || !Number.isInteger(currentTime)) {
|
||
log.error("参数 'currentTime' 必须是整数!");
|
||
return;
|
||
}
|
||
if (typeof duration !== 'number' || !Number.isInteger(duration)) {
|
||
log.error("参数 'duration' 必须是整数!");
|
||
return;
|
||
}
|
||
|
||
// 将 currentTime 转换为 Date 对象并格式化为 HH:mm:ss.sss
|
||
const date = new Date(currentTime);
|
||
const hours = String(date.getHours()).padStart(2, '0');
|
||
const minutes = String(date.getMinutes()).padStart(2, '0');
|
||
const seconds = String(date.getSeconds()).padStart(2, '0');
|
||
const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
|
||
const formattedTime = `${hours}:${minutes}:${seconds}.${milliseconds}`;
|
||
|
||
// 将 duration 转换为分钟和秒,并保留三位小数
|
||
const durationInSeconds = duration / 1000; // 转换为秒
|
||
const durationMinutes = Math.floor(durationInSeconds / 60);
|
||
const durationSeconds = (durationInSeconds % 60).toFixed(3); // 保留三位小数
|
||
|
||
// 使用四个独立的 if 语句处理四种情况
|
||
if (isJs && isStart) {
|
||
// 处理 isJs = true 且 isStart = true 的情况
|
||
const logMessage = `正在伪造js开始的日志记录\n\n` +
|
||
`[${formattedTime}] [INF] BetterGenshinImpact.Service.ScriptService\n` +
|
||
`------------------------------\n\n` +
|
||
`[${formattedTime}] [INF] BetterGenshinImpact.Service.ScriptService\n` +
|
||
`→ 开始执行JS脚本: "${name}"`;
|
||
log.debug(logMessage);
|
||
}
|
||
if (isJs && !isStart) {
|
||
// 处理 isJs = true 且 isStart = false 的情况
|
||
const logMessage = `正在伪造js结束的日志记录\n\n` +
|
||
`[${formattedTime}] [INF] BetterGenshinImpact.Service.ScriptService\n` +
|
||
`→ 脚本执行结束: "${name}", 耗时: ${durationMinutes}分${durationSeconds}秒\n\n` +
|
||
`[${formattedTime}] [INF] BetterGenshinImpact.Service.ScriptService\n` +
|
||
`------------------------------`;
|
||
log.debug(logMessage);
|
||
}
|
||
if (!isJs && isStart) {
|
||
// 处理 isJs = false 且 isStart = true 的情况
|
||
const logMessage = `正在伪造地图追踪开始的日志记录\n\n` +
|
||
`[${formattedTime}] [INF] BetterGenshinImpact.Service.ScriptService\n` +
|
||
`------------------------------\n\n` +
|
||
`[${formattedTime}] [INF] BetterGenshinImpact.Service.ScriptService\n` +
|
||
`→ 开始执行地图追踪任务: "${name}"`;
|
||
log.debug(logMessage);
|
||
}
|
||
if (!isJs && !isStart) {
|
||
// 处理 isJs = false 且 isStart = false 的情况
|
||
const logMessage = `正在伪造地图追踪结束的日志记录\n\n` +
|
||
`[${formattedTime}] [INF] BetterGenshinImpact.Service.ScriptService\n` +
|
||
`→ 脚本执行结束: "${name}", 耗时: ${durationMinutes}分${durationSeconds}秒\n\n` +
|
||
`[${formattedTime}] [INF] BetterGenshinImpact.Service.ScriptService\n` +
|
||
`------------------------------`;
|
||
log.debug(logMessage);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取文件名函数
|
||
* 从文件路径中提取文件名
|
||
*
|
||
* @param {string} filePath - 文件路径
|
||
* @returns {string} 返回文件名
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* 无
|
||
*/
|
||
function basename(filePath) {
|
||
const lastSlashIndex = filePath.lastIndexOf('\\'); // 或者使用 '/',取决于你的路径分隔符
|
||
return filePath.substring(lastSlashIndex + 1);
|
||
}
|
||
|
||
/**
|
||
* 读取文件夹函数
|
||
* 递归读取文件夹及其子文件夹中的文件
|
||
*
|
||
* @param {string} folderPath - 文件夹路径
|
||
* @param {boolean} onlyJson - 是否只读取 JSON 文件
|
||
* @returns {Promise<Array>} 返回文件信息数组,每个元素包含文件路径、文件名等信息
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* 无
|
||
*/
|
||
async function readFolder(folderPath, onlyJson) {
|
||
const folderStack = [folderPath];
|
||
const files = [];
|
||
|
||
while (folderStack.length > 0) {
|
||
const currentPath = folderStack.pop();
|
||
const filesInSubFolder = file.ReadPathSync(currentPath); // 同步读取
|
||
const subFolders = [];
|
||
|
||
for (const filePath of filesInSubFolder) {
|
||
if (file.IsFolder(filePath)) {
|
||
subFolders.push(filePath);
|
||
continue;
|
||
}
|
||
|
||
if (filePath.endsWith('.js')) continue; // 跳过 js
|
||
|
||
// 仅 json 模式
|
||
if (onlyJson) {
|
||
if (!filePath.endsWith('.json')) continue;
|
||
|
||
let description = '';
|
||
try {
|
||
// 同步读文本,避免 async 传染
|
||
const txt = file.readTextSync(filePath);
|
||
const parsed = JSON.parse(txt);
|
||
description = parsed?.info?.description ?? '';
|
||
} catch {
|
||
/* 读盘或解析失败就留空串 */
|
||
}
|
||
|
||
const fileName = filePath.split('\\').pop();
|
||
const folderPathArray = filePath.split('\\').slice(0, -1);
|
||
|
||
files.push({
|
||
fullPath: filePath,
|
||
fileName,
|
||
folderPathArray,
|
||
description
|
||
});
|
||
continue;
|
||
}
|
||
|
||
const fileName = filePath.split('\\').pop();
|
||
const folderPathArray = filePath.split('\\').slice(0, -1);
|
||
files.push({ fullPath: filePath, fileName, folderPathArray });
|
||
}
|
||
|
||
// 子文件夹按原顺序入栈(深度优先)
|
||
folderStack.push(...subFolders.reverse());
|
||
}
|
||
|
||
return files;
|
||
}
|
||
|
||
/**
|
||
* 带缓存的配队切换函数
|
||
* 如果目标配队与 currentParty 一致则跳过;否则真正切换并更新 currentParty。
|
||
*
|
||
* @param {string} partyName - 期望切换到的配队名称
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - currentParty: 当前配队名称
|
||
*
|
||
* @依赖辅助函数:
|
||
* - genshin.returnMainUi: 返回主界面函数
|
||
* - genshin.switchParty: 切换配队函数
|
||
* - genshin.tpToStatueOfTheSeven: 传送到七天神像函数
|
||
*/
|
||
async function switchPartyIfNeeded(partyName) {
|
||
if (!partyName) { // 空名直接回主界面
|
||
await genshin.returnMainUi();
|
||
return;
|
||
}
|
||
|
||
if (partyName === currentParty) { // 缓存命中,跳过切换
|
||
await genshin.returnMainUi();
|
||
return;
|
||
}
|
||
|
||
/* 真正切换 */
|
||
try {
|
||
log.info(`正在尝试切换至配队「${partyName}」`);
|
||
let success = await genshin.switchParty(partyName);
|
||
if (!success) { // 第一次失败,去神像再试一次
|
||
log.info('切换失败,前往七天神像重试');
|
||
await genshin.tpToStatueOfTheSeven();
|
||
success = await genshin.switchParty(partyName);
|
||
}
|
||
|
||
if (success) { // 切换成功,更新缓存
|
||
currentParty = partyName;
|
||
log.info(`已切换至配队「${partyName}」并更新缓存`);
|
||
} else {
|
||
throw new Error('两次切换均失败');
|
||
}
|
||
} catch (e) {
|
||
log.error('队伍切换失败,可能处于联机模式或其他不可切换状态');
|
||
notification.error('队伍切换失败,可能处于联机模式或其他不可切换状态');
|
||
await genshin.returnMainUi();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检查当前时间是否处于限制时间内或即将进入限制时间
|
||
*
|
||
* @param {string} timeRule - 时间规则字符串,格式如 "8, 8-11, 23:11-23:55"
|
||
* @param {number} [threshold=5] - 接近限制时间的阈值(分钟)
|
||
* @returns {Promise<boolean>} - 如果处于限制时间内或即将进入限制时间,则返回 true,否则返回 false
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* - genshin.tpToStatueOfTheSeven: 传送到七天神像函数
|
||
* - sleep: 延迟函数
|
||
*/
|
||
async function isTimeRestricted(timeRule, threshold = 5) {
|
||
if (!timeRule) return false;
|
||
|
||
// 兼容中英文逗号、冒号
|
||
const ruleClean = timeRule
|
||
.replace(/,/g, ',')
|
||
.replace(/:/g, ':');
|
||
|
||
const now = new Date();
|
||
const currentHour = now.getHours();
|
||
const currentMinute = now.getMinutes();
|
||
const currentTotal = currentHour * 60 + currentMinute;
|
||
|
||
for (const seg of ruleClean.split(',').map(s => s.trim())) {
|
||
if (!seg) continue;
|
||
|
||
let startStr, endStr;
|
||
if (seg.includes('-')) {
|
||
[startStr, endStr] = seg.split('-').map(s => s.trim());
|
||
} else {
|
||
startStr = endStr = seg.trim();
|
||
}
|
||
|
||
const parseTime = (str, isEnd) => {
|
||
if (str.includes(':')) {
|
||
const [h, m] = str.split(':').map(Number);
|
||
return { h, m };
|
||
}
|
||
// 单独小时:start 8→8:00,end 8→8:59
|
||
const h = Number(str);
|
||
return { h, m: isEnd ? 59 : 0 };
|
||
};
|
||
|
||
const start = parseTime(startStr, false);
|
||
const end = parseTime(endStr, true);
|
||
|
||
const startTotal = start.h * 60 + start.m;
|
||
const endTotal = end.h * 60 + end.m;
|
||
|
||
const effectiveEnd = endTotal >= startTotal ? endTotal : endTotal + 24 * 60;
|
||
|
||
if (
|
||
(currentTotal >= startTotal && currentTotal < effectiveEnd) ||
|
||
(currentTotal + 24 * 60 >= startTotal && currentTotal + 24 * 60 < effectiveEnd)
|
||
) {
|
||
log.warn("处于限制时间内");
|
||
return true;
|
||
}
|
||
|
||
let nextStartTotal = startTotal;
|
||
if (nextStartTotal <= currentTotal) nextStartTotal += 24 * 60;
|
||
const waitMin = nextStartTotal - currentTotal;
|
||
if (waitMin > 0 && waitMin <= threshold) {
|
||
log.warn(`接近限制时间,等待 ${waitMin} 分钟`);
|
||
await genshin.tpToStatueOfTheSeven();
|
||
await sleep(waitMin * 60 * 1000);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 食材加工主函数,用于自动前往指定地点进行食材的加工
|
||
*
|
||
* 该函数会根据 Foods 数组中的食材名称,依次查找并制作对应的料食材
|
||
* 支持调味品类食材(直接在“食材加工”界面查找)
|
||
*
|
||
* @returns {Promise<void>} 无返回值,执行完所有加工流程后退出
|
||
*
|
||
* @依赖全局变量:
|
||
* - Foods: 要加工的食材数组
|
||
* - checkInterval: 食材加工中的识别间隔(毫秒)
|
||
*
|
||
* @依赖辅助函数:
|
||
* - findPNG: 查找图片函数
|
||
* - clickPNG: 点击图片函数
|
||
* - collectCraftedItems: 领取加工产物函数
|
||
* - handleCraftingError: 处理食材加工错误函数
|
||
* - doCraft: 执行食材加工流程函数
|
||
* - genshin.returnMainUi: 返回主界面函数
|
||
*/
|
||
async function ingredientProcessing() {
|
||
const targetFoods = [
|
||
"面粉", "兽肉", "鱼肉", "神秘的肉", "黑麦粉", "奶油", "熏禽肉",
|
||
"黄油", "火腿", "糖", "香辛料", "酸奶油", "蟹黄", "果酱",
|
||
"奶酪", "培根", "香肠"
|
||
];
|
||
if (Foods.length == 0) { log.error("未选择要加工的食材"); return; }
|
||
const taskList = Foods.map((name) => `${name}`).join(",");
|
||
const tasks = Foods.map((name) => ({
|
||
name,
|
||
done: false
|
||
}));
|
||
log.info(`本次加工食材:${taskList}`);
|
||
const stove = "蒙德炉子";
|
||
log.info(`正在前往${stove}进行食材加工`);
|
||
|
||
try {
|
||
let filePath = `assets/${stove}.json`;
|
||
await pathingScript.runFile(filePath);
|
||
} catch (error) {
|
||
log.error(`执行 ${stove} 路径时发生错误`);
|
||
return;
|
||
}
|
||
|
||
const res1 = await findPNG("交互烹饪锅");
|
||
if (res1) {
|
||
keyPress("F");
|
||
} else {
|
||
log.warn("烹饪按钮未找到,正在寻找……");
|
||
let attempts = 0;
|
||
const maxAttempts = 3;
|
||
let foundInRetry = false;
|
||
while (attempts < maxAttempts) {
|
||
log.info(`第${attempts + 1}次尝试寻找烹饪按钮`);
|
||
keyPress("W");
|
||
const res2 = await findPNG("交互烹饪锅");
|
||
if (res2) {
|
||
keyPress("F");
|
||
foundInRetry = true;
|
||
break;
|
||
} else {
|
||
attempts++;
|
||
await sleep(500);
|
||
}
|
||
}
|
||
if (!foundInRetry) {
|
||
log.error("多次未找到烹饪按钮,放弃");
|
||
return;
|
||
}
|
||
}
|
||
await clickPNG("食材加工");
|
||
|
||
|
||
|
||
/* ===== 2. 两轮扫描 ===== */
|
||
// 进入界面先领取一次
|
||
await collectCraftedItems();
|
||
|
||
let lastSuccess = true;
|
||
for (let i = 0; i < tasks.length; i++) {
|
||
if (!targetFoods.includes(tasks[i].name)) continue;
|
||
|
||
const retry = lastSuccess ? 5 : 1;
|
||
if (await clickPNG(`${tasks[i].name}1`, retry)) {
|
||
log.info(`${tasks[i].name}已找到`);
|
||
await doCraft(i, tasks);
|
||
tasks[i].done = true;
|
||
lastSuccess = true; // 记录成功
|
||
} else {
|
||
lastSuccess = false; // 记录失败
|
||
}
|
||
}
|
||
|
||
const remain1 = tasks.filter(t => !t.done).map(t => `${t.name}`).join(",") || "无";
|
||
log.info(`剩余待加工食材:${remain1}`);
|
||
|
||
if (remain1 === "无") {
|
||
log.info("所有食材均已加工完毕,跳过第二轮扫描");
|
||
await genshin.returnMainUi();
|
||
return;
|
||
}
|
||
|
||
const rg = await getGameRegion();
|
||
const foodItems = [];
|
||
try {
|
||
for (const flag of ['已加工0个', '已加工1个']) {
|
||
const mat = file.ReadImageMatSync(`assets/RecognitionObject/${flag}.png`);
|
||
const res = rg.findMulti(RecognitionObject.TemplateMatch(mat));
|
||
for (let k = 0; k < res.count; ++k) {
|
||
foodItems.push({ x: res[k].x, y: res[k].y });
|
||
}
|
||
mat.dispose();
|
||
}
|
||
} catch (error) {
|
||
log.error(error.message);
|
||
}
|
||
|
||
log.info(`识别到${foodItems.length}个加工中食材`);
|
||
|
||
for (const item of foodItems) {
|
||
click(item.x, item.y); await sleep(1 * checkInterval);
|
||
click(item.x, item.y); await sleep(3 * checkInterval);
|
||
|
||
for (let round = 0; round < 5; round++) {
|
||
const rg = await getGameRegion();
|
||
try {
|
||
let hit = false;
|
||
|
||
/* 直接扫 tasks,模板已挂在 task.ro */
|
||
for (const task of tasks) {
|
||
if (task.done) continue;
|
||
if (!targetFoods.includes(task.name)) continue;
|
||
|
||
/* 首次使用再加载,避免重复 IO */
|
||
if (!task.ro) {
|
||
task.ro = RecognitionObject.TemplateMatch(
|
||
file.ReadImageMatSync(`assets/RecognitionObject/${task.name}2.png`)
|
||
);
|
||
task.ro.Threshold = 0.9;
|
||
task.ro.InitTemplate();
|
||
}
|
||
|
||
if (!task.ro) {
|
||
log.warn(`${task.name}2.png 不存在,跳过识别`);
|
||
continue;
|
||
}
|
||
const res = rg.find(task.ro);
|
||
if (res.isExist()) {
|
||
log.info(`${task.name}已找到`);
|
||
await doCraft(tasks.indexOf(task), tasks);
|
||
task.done = true;
|
||
hit = true;
|
||
break; // 一轮只处理一个
|
||
}
|
||
}
|
||
|
||
if (hit) break; // 本轮已命中,跳出 round
|
||
} finally {
|
||
}
|
||
}
|
||
}
|
||
|
||
const remain = tasks.filter(t => !t.done).map(t => `${t.name}`).join(",") || "无";
|
||
log.info(`剩余待加工食材:${remain}`);
|
||
|
||
|
||
|
||
await genshin.returnMainUi();
|
||
}
|
||
|
||
/**
|
||
* 领取加工产物并处理相关提示
|
||
*
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - checkInterval: 食材加工中的识别间隔(毫秒)
|
||
*
|
||
* @依赖辅助函数:
|
||
* - clickPNG: 点击图片函数
|
||
* - findPNG: 查找图片函数
|
||
* - sleep: 延迟函数
|
||
*/
|
||
async function collectCraftedItems() {
|
||
if (await clickPNG("全部领取", 3)) {
|
||
let dowait = false;
|
||
await sleep(4 * checkInterval);
|
||
while (await findPNG("道具数量超过上限")) {
|
||
await sleep(checkInterval * 4);
|
||
log.info("识别到道具数量超过上限,等待消失");
|
||
dowait = true;
|
||
}
|
||
if (dowait) {
|
||
await sleep(10 * checkInterval)
|
||
}
|
||
await clickPNG("点击空白区域继续");
|
||
await findPNG("食材加工2");
|
||
await sleep(100);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理食材加工中的错误情况
|
||
*
|
||
* @param {string} errorType - 错误类型:队列已满、材料不足、已不能持有更多
|
||
* @param {string} itemName - 食材名称
|
||
* @param {boolean} removeFromList - 是否从Foods列表中移除该食材
|
||
* @returns {boolean} - 是否发生错误
|
||
*
|
||
* @依赖全局变量:
|
||
* - Foods: 要加工的食材数组
|
||
*
|
||
* @依赖辅助函数:
|
||
* - findPNG: 查找图片函数
|
||
* - clickPNG: 点击图片函数
|
||
* - sleep: 延迟函数
|
||
*/
|
||
async function handleCraftingError(errorType, itemName, removeFromList) {
|
||
if (await findPNG(errorType, 1)) {
|
||
log.warn(`检测到${itemName}${errorType},等待图标消失`);
|
||
while (await findPNG(errorType, 1)) {
|
||
log.warn(`检测到${itemName}${errorType},等待图标消失`);
|
||
await sleep(300);
|
||
}
|
||
if (await clickPNG("全部领取", 3)) {
|
||
await clickPNG("点击空白区域继续");
|
||
await findPNG("食材加工2");
|
||
await sleep(100);
|
||
}
|
||
if (removeFromList) {
|
||
const index = Foods.findIndex(f => f === itemName);
|
||
if (index !== -1) {
|
||
Foods.splice(index, 1);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 执行食材加工流程
|
||
*
|
||
* @param {number} index - 食材在tasks数组中的索引
|
||
* @param {Array} tasks - 任务数组
|
||
* @returns {boolean} - 是否加工成功
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* - clickPNG: 点击图片函数
|
||
* - findPNG: 查找图片函数
|
||
* - handleCraftingError: 处理食材加工错误函数
|
||
* - collectCraftedItems: 领取加工产物函数
|
||
* - sleep: 延迟函数
|
||
* - inputText: 输入文本函数
|
||
*/
|
||
async function doCraft(index, tasks) {
|
||
await clickPNG("制作");
|
||
await sleep(300);
|
||
|
||
/* ---------- 1. 队列已满 ---------- */
|
||
if (await handleCraftingError("队列已满", tasks[index].name, false)) {
|
||
return false;
|
||
}
|
||
|
||
/* ---------- 2. 材料不足 ---------- */
|
||
if (await handleCraftingError("材料不足", tasks[index].name, true)) {
|
||
return false;
|
||
}
|
||
|
||
/* ---------- 3. 正常加工流程 ---------- */
|
||
await findPNG("选择加工数量");
|
||
click(960, 460);
|
||
await sleep(800);
|
||
inputText(String(99));
|
||
|
||
log.info(`尝试制作${tasks[index].name} 99个`);
|
||
await clickPNG("确认加工");
|
||
await sleep(500);
|
||
|
||
/* ---------- 4. 已不能持有更多 ---------- */
|
||
if (await handleCraftingError("已不能持有更多", tasks[index].name, true)) {
|
||
return false;
|
||
}
|
||
|
||
await sleep(200);
|
||
/* 正常完成:仅领取,不移除 */
|
||
await collectCraftedItems();
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 计算默认效率值
|
||
*
|
||
* @param {Array} knownEff - 已知效率数组
|
||
* @param {string|number} percentile - 分位值设置
|
||
* @param {number} defaultThreshold - 默认阈值
|
||
* @returns {number} - 计算出的默认效率值
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* 无
|
||
*/
|
||
function calculateDefaultEfficiency(knownEff, percentile, defaultThreshold) {
|
||
if (knownEff.length === 0) {
|
||
return defaultThreshold;
|
||
} else {
|
||
const pct = Math.max(0, Math.min(1, percentile === "" ? 0.5 : Number(percentile)));
|
||
const idx = Math.ceil(pct * knownEff.length) - 1;
|
||
const percentileEff = knownEff[Math.max(0, idx)];
|
||
return Math.max(percentileEff, defaultThreshold);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理水下路线的螃蟹技能检查
|
||
*
|
||
* @param {string} mapName - 地图名称
|
||
* @param {string} filePath - 路径文件路径
|
||
* @param {string} lastMapName - 上一个地图名称
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* - findAndClick: 查找并点击函数
|
||
* - pathingScript.runFile: 运行路径脚本函数
|
||
*/
|
||
async function handleUnderwaterRoute(mapName, filePath, lastMapName) {
|
||
if (filePath.includes('枫丹水下')) {
|
||
log.info("当前路线为水下路线,检查螃蟹技能");
|
||
let skillRes = await findAndClick("assets/螃蟹技能图标.png", false, 1000);
|
||
if (!skillRes || lastMapName != mapName) {
|
||
log.info("识别到没有螃蟹技能或上一条路线处于其他地图,前往获取螃蟹技能");
|
||
|
||
if (mapName === "SeaOfBygoneEras") {
|
||
await pathingScript.runFile("assets/学习螃蟹技能2.json");
|
||
}
|
||
else {
|
||
await pathingScript.runFile("assets/学习螃蟹技能1.json");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理时间调节
|
||
*
|
||
* @param {Date} timeNow - 当前时间
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - settings: 设置对象
|
||
* - firstsettime: 是否首次调节时间
|
||
* - lastsettimeTime: 上次调节时间
|
||
* - settimeInterval: 时间调节间隔
|
||
*
|
||
* @依赖辅助函数:
|
||
* - pathingScript.runFile: 运行路径脚本函数
|
||
*/
|
||
async function handleTimeAdjustment(timeNow) {
|
||
if (settings.setTimeMode && settings.setTimeMode != "不调节时间" && (((timeNow - lastsettimeTime) > settimeInterval) || firstsettime)) {
|
||
firstsettime = false;
|
||
if (settings.setTimeMode === "尽量调为白天") {
|
||
await pathingScript.runFile("assets/调为白天.json");
|
||
} else {
|
||
await pathingScript.runFile("assets/调为夜晚.json");
|
||
}
|
||
lastsettimeTime = new Date();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理食材加工触发
|
||
*
|
||
* @param {Date} timeNow - 当前时间
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - Foods: 要加工的食材数组
|
||
* - firstCook: 是否首次加工
|
||
* - lastCookTime: 上次加工时间
|
||
* - cookInterval: 加工间隔
|
||
* - lastMapName: 上一个地图名称
|
||
*
|
||
* @依赖辅助函数:
|
||
* - ingredientProcessing: 食材加工主函数
|
||
*/
|
||
async function handleIngredientProcessing(timeNow) {
|
||
if (Foods.length != 0 && (((timeNow - lastCookTime) > cookInterval) || firstCook)) {
|
||
firstCook = false;
|
||
await ingredientProcessing();
|
||
lastCookTime = new Date();
|
||
lastMapName = "Teyvat";
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 执行采集路线
|
||
*
|
||
* @param {string} filePath - 路径文件路径
|
||
* @param {string} fileName - 文件名
|
||
* @param {Object} targetObj - 目标对象
|
||
* @param {Date} startTime - 开始时间
|
||
* @param {string} lastMapName - 上一个地图名称
|
||
* @param {Set} priorityItemSet - 优先材料集合
|
||
* @returns {Object} - 执行结果,包含 success、lastMapName 和 runPickupLog
|
||
*
|
||
* @依赖全局变量:
|
||
* - state: 状态对象,包含 running 标志和 runPickupLog 日志数组
|
||
* - materialCdMap: 材料CD映射表
|
||
*
|
||
* @依赖辅助函数:
|
||
* - recognizeAndInteract: 识别并交互函数
|
||
* - handleUnderwaterRoute: 处理水下路线函数
|
||
* - fakeLog: 模拟日志函数
|
||
* - isArrivedAtEndPoint: 检查是否到达终点函数
|
||
* - calculateRouteCD: 计算路线CD函数
|
||
*/
|
||
async function executeRoute(filePath, fileName, targetObj, startTime, lastMapName, priorityItemSet) {
|
||
state.running = true;
|
||
let runRes;
|
||
|
||
const raw = file.readTextSync(filePath);
|
||
const json = JSON.parse(raw);
|
||
|
||
// 检测是否为 schedule 文件(包含 schedule 和 tasks 字段)
|
||
if (json.schedule && json.tasks) {
|
||
log.info(`检测到 schedule 文件: ${fileName},使用 schedule 模式执行`);
|
||
const pickupTask = startPickupTask();
|
||
await executeSchedule(filePath);
|
||
state.running = false;
|
||
await pickupTask;
|
||
// 返回实际拾取日志(含一次性优先扣减等下游依赖),而非空数组
|
||
return { success: true, lastMapName: "", runPickupLog: state.runPickupLog, isSchedule: true };
|
||
}
|
||
|
||
const mapName = (json.info?.map_name && json.info.map_name.trim()) ? json.info.map_name : 'Teyvat';
|
||
await handleUnderwaterRoute(mapName, filePath, lastMapName);
|
||
lastMapName = mapName;
|
||
const pickupTask = startPickupTask();
|
||
|
||
try {
|
||
runRes = await pathingScript.runFile(filePath);
|
||
} catch (error) {
|
||
// 与 AAA狗粮批发、锄地一条龙保持一致:异常时置 undefined,由下方判定统一降级到坐标校验
|
||
log.error(`执行路线 ${filePath} 时发生错误:${error.message}`);
|
||
runRes = undefined;
|
||
}
|
||
state.running = false;
|
||
await pickupTask;
|
||
await fakeLog(fileName, false, false, 0);
|
||
|
||
/* 4-4 计算CD(掉落材料决定)*/
|
||
const timeDiff = new Date() - startTime;
|
||
let pathRes;
|
||
if (runRes !== undefined && typeof runRes.success === 'boolean') {
|
||
// 新版本BGI:直接使用返回值判定路线是否成功
|
||
if (runRes.success) {
|
||
log.info("路线运行成功");
|
||
} else {
|
||
log.error(`路线运行失败:${runRes.message}`);
|
||
}
|
||
pathRes = runRes.success;
|
||
} else {
|
||
// 旧版本BGI(无返回值):静默回退到坐标校验
|
||
pathRes = isArrivedAtEndPoint(filePath);
|
||
}
|
||
|
||
// >>> 仅当 >10s 才记录 history;若同时 pathRes === true 再更新 CD <<<
|
||
if (timeDiff > 10000) {
|
||
/* ---------- 1. 先写 history(无条件) ---------- */
|
||
const durationSec = Math.round(timeDiff / 1000);
|
||
const itemCounter = {};
|
||
state.runPickupLog.forEach(n => { itemCounter[n] = (itemCounter[n] || 0) + 1; });
|
||
if (!targetObj.history) targetObj.history = [];
|
||
targetObj.history.push({ items: itemCounter, durationSec });
|
||
if (targetObj.history.length > 7) targetObj.history = targetObj.history.slice(-7);
|
||
|
||
/* ---------- 2. 仅当 pathRes === true 才计算并更新 CD ---------- */
|
||
if (pathRes) {
|
||
/* 2-1 判定本次有没有优先材料 */
|
||
const hasPriority = state.runPickupLog.some(name => priorityItemSet.has(name));
|
||
let hitMaterials;
|
||
if (hasPriority) {
|
||
hitMaterials = [...new Set(state.runPickupLog.filter(n => priorityItemSet.has(n)))];
|
||
} else {
|
||
hitMaterials = [...new Set(state.runPickupLog)];
|
||
}
|
||
|
||
/* 2-2 按材料表取最晚 CD */
|
||
let latestCD = new Date(0);
|
||
hitMaterials.forEach(name => {
|
||
const cdType = materialCdMap[name] || "1次0点刷新";
|
||
const tmpDate = calculateRouteCD(cdType, startTime);
|
||
if (tmpDate > latestCD) latestCD = tmpDate;
|
||
});
|
||
|
||
/* 兜底:没有任何材料被识别到,按1次0点刷新 */
|
||
if (hitMaterials.length === 0) {
|
||
latestCD = calculateRouteCD("1次0点刷新", startTime);
|
||
}
|
||
|
||
targetObj.cdTime = latestCD.toISOString();
|
||
}
|
||
}
|
||
|
||
return { success: true, lastMapName, runPickupLog: state.runPickupLog, pathRes };
|
||
}
|
||
|
||
/**
|
||
* 优先历史拾取物排序
|
||
*
|
||
* @param {Array} targetItems - 目标物品数组
|
||
* @param {Map} cdMap - CD时间映射
|
||
* @param {string} fullName - 文件名
|
||
* @returns {Array} - 排序后的物品数组,历史上出现过的物品放在前面
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* 无
|
||
*/
|
||
function prioritizeHistoricalItems(targetItems, cdMap, fullName) {
|
||
// 0) 只有 history 里出现过的物品才需要前置
|
||
const historyItemSet = new Set();
|
||
const routeRec = cdMap.get(fullName);
|
||
if (routeRec?.history) {
|
||
routeRec.history.forEach(log => {
|
||
Object.keys(log.items).forEach(name => historyItemSet.add(name));
|
||
});
|
||
}
|
||
|
||
// 1) 把 targetItems 拆成「历史出现」+「未出现」两部分
|
||
const frontPart = [];
|
||
const backPart = [];
|
||
for (const it of targetItems) {
|
||
(historyItemSet.has(it.itemName) ? frontPart : backPart).push(it);
|
||
}
|
||
|
||
// 2) 合并后重新赋值,完成前置
|
||
return [...frontPart, ...backPart];
|
||
}
|
||
|
||
/**
|
||
* 扣除一次性优先采集材料的本次收入(全局收口)
|
||
* 在任意阶段(每日优先采集、一次性优先采集、路径组循环)完成路线后调用,
|
||
* 只要本次拾取日志/声明中命中了 settings.oneTimePriorityItems 中未清零的材料,
|
||
* 就会把剩余量扣减后直接写回 settings 对象(清零项自动删除,全部清零则置空串)。
|
||
*
|
||
* ⚠️ 注意:此功能依赖 JS 直接修改 settings 对象并持久化(settings.xxx = xxx)。
|
||
* 若该写回失效,说明 BGI 本体改动了对 settings 的注入/持久化机制,需同步适配。
|
||
*
|
||
* @param {string[]} correctedLog - 本次路线修正后的拾取日志(已按声明材料补充)
|
||
* @returns {void}
|
||
*/
|
||
function deductOneTimePriority(correctedLog) {
|
||
const raw = settings.oneTimePriorityItems;
|
||
if (!raw) return;
|
||
|
||
// ---- 解析当前剩余量 ----
|
||
const list = [];
|
||
const segments = String(raw).split('+').map(s => s.trim());
|
||
for (const seg of segments) {
|
||
const [itemName, countStr] = seg.split('*').map(s => s.trim());
|
||
if (itemName && countStr && !isNaN(Number(countStr))) {
|
||
list.push({ itemName, count: Number(countStr) });
|
||
}
|
||
}
|
||
if (list.length === 0) return;
|
||
|
||
// ---- 逐项统计本次命中(含别名双向展开,对同一日志项去重,与每日优先扣减逻辑一致)----
|
||
for (const task of list) {
|
||
// 三种命中关系合并,用 Set 对同一日志项去重,避免别名双向命中导致重复计数
|
||
const matched = new Set();
|
||
for (const name of correctedLog) {
|
||
// 1. 字面名相同
|
||
if (name === task.itemName) { matched.add(name); continue; }
|
||
// 2. 日志项是别名,其本名(们)含该字面名(多对一):别名→本名
|
||
const realNames = alias2Names.get(name) || [];
|
||
if (realNames.includes(task.itemName)) { matched.add(name); continue; }
|
||
// 3. 日志项是该字面名的别名(字面名是本名):本名→别名
|
||
const others = name2Other.get(task.itemName) || [];
|
||
if (others.includes(name)) { matched.add(name); continue; }
|
||
}
|
||
task.count = Math.max(0, task.count - matched.size);
|
||
}
|
||
|
||
// ---- 去空项并写回配置 ----
|
||
const remaining = list.filter(t => t.count > 0);
|
||
// 直接修改 settings 对象写回(见函数头注释的依赖说明)
|
||
settings.oneTimePriorityItems = remaining.map(t => `${t.itemName}*${t.count}`).join('+');
|
||
if (remaining.length < list.length) {
|
||
const cleared = list.filter(t => t.count <= 0).map(t => t.itemName);
|
||
log.info(`一次性优先材料已达标(清零):${cleared.join('、')}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 保存记录并清空日志
|
||
*
|
||
* @param {Map} cdMap - CD时间映射
|
||
* @param {string} recordFilePath - 记录文件路径
|
||
* @param {Array} runPickupLog - 运行拾取日志
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - state: 状态对象,包含 runPickupLog 日志数组
|
||
* - alias2Names: 别名到本名数组的映射
|
||
* - name2Other: 本名到别名数组的映射
|
||
*
|
||
* @依赖辅助函数:
|
||
* - appendDailyPickup: 追加每日拾取量函数
|
||
* - deductOneTimePriority: 扣除一次性优先材料收入函数
|
||
*/
|
||
async function saveRecordAndClearLog(cdMap, recordFilePath, runPickupLog) {
|
||
await file.writeText(
|
||
recordFilePath,
|
||
JSON.stringify(Array.from(cdMap.values()), null, 2)
|
||
);
|
||
await appendDailyPickup(runPickupLog);
|
||
// 全局扣减一次性优先材料(任何阶段拾取到都会在此自动扣除)
|
||
deductOneTimePriority(runPickupLog);
|
||
state.runPickupLog = [];
|
||
}
|
||
|
||
/**
|
||
* 根据路线路径选择合适的队伍
|
||
*
|
||
* @param {string} routePath - 路线路径
|
||
* @param {string} stage - 阶段名称
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - settings: 设置对象,包含路径组和队伍配置
|
||
* - groupCount: 路径组数量
|
||
*
|
||
* @依赖辅助函数:
|
||
* - switchPartyIfNeeded: 切换队伍函数
|
||
*/
|
||
async function selectPartyByRoutePath(routePath, stage) {
|
||
const fullPath = routePath; // 例:pathing/须弥/xxx.json
|
||
const folderName = fullPath.split(/\\|\//)[1]; // 索引 1 就是第二层
|
||
let targetParty = ''; // 最终要用的队伍名
|
||
|
||
for (let g = 1; g <= groupCount; g++) { // 遍历路径组
|
||
if (settings[`pathGroup${g}FolderName`] === folderName) { // 找到归属组
|
||
targetParty = settings[`pathGroup${g}PartyName`] || '';
|
||
break; // 命中即停
|
||
}
|
||
}
|
||
if (!targetParty) targetParty = settings.priorityItemsPartyName || ''; // 回退
|
||
if (targetParty) {
|
||
await switchPartyIfNeeded(targetParty);
|
||
log.info(`${stage}选用配队:${targetParty}(文件夹:${folderName})`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 计算路线CD时间
|
||
*
|
||
* @param {string} cdType - CD类型
|
||
* @param {Date} startTime - 开始时间
|
||
* @returns {Date} - 计算后的CD时间
|
||
*
|
||
* @依赖全局变量:
|
||
* 无
|
||
*
|
||
* @依赖辅助函数:
|
||
* 无
|
||
*/
|
||
function calculateRouteCD(cdType, startTime) {
|
||
let newTimestamp = new Date(startTime);
|
||
switch (cdType) {
|
||
case "1次0点刷新":
|
||
newTimestamp.setDate(newTimestamp.getDate() + 1);
|
||
newTimestamp.setHours(0, 0, 0, 0);
|
||
break;
|
||
case "2次0点刷新":
|
||
newTimestamp.setDate(newTimestamp.getDate() + 2);
|
||
newTimestamp.setHours(0, 0, 0, 0);
|
||
break;
|
||
case "3次0点刷新":
|
||
newTimestamp.setDate(newTimestamp.getDate() + 3);
|
||
newTimestamp.setHours(0, 0, 0, 0);
|
||
break;
|
||
case "4点刷新":
|
||
newTimestamp.setHours(4, 0, 0, 0);
|
||
if (newTimestamp <= startTime) newTimestamp.setDate(newTimestamp.getDate() + 1);
|
||
break;
|
||
case "12小时刷新":
|
||
newTimestamp = new Date(startTime.getTime() + 12 * 60 * 60 * 1000);
|
||
break;
|
||
case "24小时刷新":
|
||
newTimestamp = new Date(startTime.getTime() + 24 * 60 * 60 * 1000);
|
||
break;
|
||
case "46小时刷新":
|
||
newTimestamp = new Date(startTime.getTime() + 46 * 60 * 60 * 1000);
|
||
break;
|
||
case "每天一次":
|
||
const hour = startTime.getHours();
|
||
if (hour >= 4 && hour < 16) {
|
||
// 在 04:00 ~ 15:59 之间采集 → 第二天 04:00
|
||
newTimestamp.setHours(4, 0, 0, 0);
|
||
if (newTimestamp <= startTime) newTimestamp.setDate(newTimestamp.getDate() + 1);
|
||
} else {
|
||
// 在 16:00 ~ 03:59 之间采集 → 当前时间 + 12 小时
|
||
newTimestamp = new Date(startTime.getTime() + 12 * 60 * 60 * 1000);
|
||
}
|
||
break;
|
||
default:
|
||
newTimestamp = startTime;
|
||
break;
|
||
}
|
||
return newTimestamp;
|
||
}
|
||
|
||
/**
|
||
* 计算路线效率
|
||
*
|
||
* @param {Array} files - 路线文件数组
|
||
* @param {Map} cdMap - CD时间映射
|
||
* @param {Object} options - 配置选项
|
||
* @param {number} options.groupIndex - 路径组索引(路径组模式使用)
|
||
* @param {Set} options.priorityItemSet - 优先材料集合(优先采集模式使用)
|
||
* @param {Array} options.disableArray - 禁用关键词数组(优先采集模式使用)
|
||
* @param {boolean} options.isPriorityMode - 是否为优先采集模式
|
||
* @returns {void} 无返回值,直接修改 files 数组中的对象
|
||
*
|
||
* @依赖全局变量:
|
||
* - settings: 设置对象,包含效率计算相关配置
|
||
* - routeEfficiency: 路线效率对象
|
||
*
|
||
* @依赖辅助函数:
|
||
* - calculateDefaultEfficiency: 计算默认效率值函数
|
||
*/
|
||
function calculateRouteEfficiency(files, cdMap, options = {}) {
|
||
const { groupIndex, priorityItemSet, disableArray, isPriorityMode = false } = options;
|
||
|
||
if (isPriorityMode) {
|
||
// 优先采集模式:只计算优先材料的效率
|
||
for (const file of files) {
|
||
const fullName = file.fileName;
|
||
const rec = cdMap.get(fullName);
|
||
|
||
// 禁用关键词
|
||
let skip = false;
|
||
for (const kw of disableArray) {
|
||
if (file.fullPath.includes(kw)) { skip = true; break; }
|
||
}
|
||
if (skip) { file._priorityEff = -1; continue; }
|
||
|
||
// 材料相关检查
|
||
const pathHit = [...priorityItemSet].some(n => file.fullPath.includes(n));
|
||
const histHit = rec?.history?.some(log =>
|
||
Object.keys(log.items).some(name => priorityItemSet.has(name))
|
||
) ?? false;
|
||
let descHit = false;
|
||
if (file.description) {
|
||
descHit = [...priorityItemSet].some(kw => file.description.includes(kw));
|
||
}
|
||
if (!pathHit && !histHit && !descHit) {
|
||
file._priorityEff = -1;
|
||
continue;
|
||
}
|
||
|
||
// 解析路线声明(【】格式)
|
||
const dec = parseDeclaration(file.description);
|
||
|
||
// 计算仅看优先材料的分均效率
|
||
let eff = -2; // 未知标记
|
||
if (rec?.history && rec.history.length >= 3) {
|
||
const effList = rec.history.map(log => {
|
||
const mergedItems = { ...log.items, ...(dec.declaredMaterials || {}) };
|
||
const total = Object.entries(mergedItems)
|
||
.filter(([name]) => priorityItemSet.has(name))
|
||
.reduce((sum, [, cnt]) => sum + cnt, 0);
|
||
return (total / log.durationSec) * 60;
|
||
});
|
||
eff = effList.reduce((a, b) => a + b, 0) / effList.length;
|
||
} else if (dec.declaredDuration || dec.declaredMaterials) {
|
||
// 历史不足 3 条,但有声明:用声明时间 + 声明数量覆盖历史
|
||
const duration = dec.declaredDuration || rec?.history?.[0]?.durationSec || 60;
|
||
const mergedItems = { ...(rec?.history?.[0]?.items || {}), ...(dec.declaredMaterials || {}) };
|
||
const total = Object.entries(mergedItems)
|
||
.filter(([name]) => priorityItemSet.has(name))
|
||
.reduce((sum, [, cnt]) => sum + cnt, 0);
|
||
eff = (total / duration) * 60;
|
||
}
|
||
file._priorityEff = eff;
|
||
}
|
||
} else {
|
||
// 路径组模式:计算所有材料的效率,使用加权规则
|
||
// 0) 解析优先关键词
|
||
const priorityKeywords = settings.priorityTags
|
||
? settings.priorityTags.split(',').map(s => s.trim()).filter(Boolean)
|
||
: [];
|
||
|
||
// 1) 解析加权规则
|
||
const weightMap = new Map();
|
||
if (settings.weightedRule) {
|
||
settings.weightedRule
|
||
.split(',')
|
||
.map(s => s.trim())
|
||
.forEach(rule => {
|
||
const [item, wStr] = rule.split('*');
|
||
if (item && wStr) {
|
||
const w = Number(wStr);
|
||
weightMap.set(item, isNaN(w) ? 1 : w);
|
||
}
|
||
});
|
||
}
|
||
|
||
// 2) 先计算一次基础效率(未知路线先标 -1)
|
||
files.forEach(p => {
|
||
const fullName = basename(p.fullPath);
|
||
const obj = cdMap.get(fullName);
|
||
let avgEff = -1; // 先标记为"未知"
|
||
const dec = parseDeclaration(p.description);
|
||
|
||
if (obj && obj.history && obj.history.length >= 3) {
|
||
// 历史 ≥3 条:用历史时间,但声明中的材料数量覆盖历史
|
||
const effList = obj.history.map(log => {
|
||
const mergedItems = { ...log.items, ...(dec.declaredMaterials || {}) };
|
||
const total = Object.entries(mergedItems).reduce((sum, [name, cnt]) => {
|
||
const w = blacklistSet.has(name) ? 0 : (weightMap.get(name) ?? 1);
|
||
return sum + cnt * w;
|
||
}, 0);
|
||
return (total / log.durationSec) * 60;
|
||
});
|
||
avgEff = effList.reduce((a, b) => a + b, 0) / effList.length;
|
||
} else if (dec.declaredDuration || dec.declaredMaterials) {
|
||
// 历史不足 3 条,但有声明:用声明时间 + 声明数量覆盖历史
|
||
const duration = dec.declaredDuration || obj?.history?.[0]?.durationSec || 60;
|
||
const mergedItems = { ...(obj?.history?.[0]?.items || {}), ...(dec.declaredMaterials || {}) };
|
||
const total = Object.entries(mergedItems).reduce((sum, [name, cnt]) => {
|
||
const w = blacklistSet.has(name) ? 0 : (weightMap.get(name) ?? 1);
|
||
return sum + cnt * w;
|
||
}, 0);
|
||
avgEff = (total / duration) * 60;
|
||
}
|
||
p._efficiency = avgEff; // 已知路线存真实效率,未知路线存 -1
|
||
});
|
||
|
||
// 3) 计算默认效率(分位值 & 临界值 取最大)
|
||
const knownEff = files
|
||
.map(p => p._efficiency)
|
||
.filter(e => e >= 0) // 只保留已知路线
|
||
.sort((a, b) => a - b);
|
||
|
||
const userThreshold = Number(settings[`pathGroup${groupIndex}thresholdEfficiency`]) || 0;
|
||
const defaultEff = calculateDefaultEfficiency(knownEff, settings.defaultEffPercentile, userThreshold);
|
||
|
||
// 4) 把 -1 的未知路线替换成默认效率
|
||
files.forEach(p => {
|
||
if (p._efficiency === -1) p._efficiency = defaultEff;
|
||
});
|
||
|
||
// 5) 计算全局最大效率值(已含默认效率)
|
||
const maxEff = Math.max(...files.map(p => p._efficiency), 0);
|
||
|
||
// 6) 优先关键词加分
|
||
files.forEach(p => {
|
||
const fullName = basename(p.fullPath);
|
||
const obj = cdMap.get(fullName);
|
||
|
||
const itemHit = obj?.history?.some(log =>
|
||
Object.keys(log.items).some(item =>
|
||
priorityKeywords.some(key => item.includes(key))
|
||
)
|
||
);
|
||
const pathHit = priorityKeywords.some(key => p.fullPath.includes(key));
|
||
const descHit = priorityKeywords.some(key => (p.description || '').includes(key));
|
||
|
||
if (itemHit || pathHit || descHit) {
|
||
p._efficiency += maxEff + 1;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 把本次路线的掉落合并到“拾取记录.json”中同一天条目(不含 durationSec)
|
||
* @param {string[]} pickupLog 本次路线的 state.runPickupLog
|
||
*/
|
||
/**
|
||
* 追加每日拾取记录到文件
|
||
* 将本次路线运行的拾取物品记录追加到每日统计文件中,按 UTC+8 的 4 点划分日期
|
||
*
|
||
* @param {string[]} pickupLog - 本次路线运行拾取的物品名称数组
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - pickupRecordFile: 拾取记录文件路径
|
||
* - MAX_PICKUP_DAYS: 最大保留天数常量
|
||
*
|
||
* @依赖辅助函数:无
|
||
*/
|
||
async function appendDailyPickup(pickupLog) {
|
||
if (!pickupLog || !pickupLog.length) return;
|
||
|
||
let oldArr = [];
|
||
try {
|
||
const txt = await file.readText(pickupRecordFile);
|
||
if (txt) oldArr = JSON.parse(txt);
|
||
} catch (_) { /* 文件不存在或解析失败 */ }
|
||
|
||
// 统一按 UTC+8 的 4 点划分日期
|
||
const utc8_4am = new Date(Date.now() + 8 * 3600_000 - 4 * 3600_000);
|
||
const today = utc8_4am.toISOString().slice(0, 10); // "YYYY-MM-DD"
|
||
|
||
let todayItem = oldArr.find(e => e.date === today);
|
||
if (!todayItem) {
|
||
todayItem = { date: today, items: {} };
|
||
oldArr.push(todayItem);
|
||
}
|
||
|
||
const todayItems = todayItem.items;
|
||
pickupLog.forEach(name => {
|
||
todayItems[name] = (todayItems[name] || 0) + 1;
|
||
});
|
||
|
||
// 滑动窗口:只保留最新 MAX_PICKUP_DAYS 条
|
||
oldArr.sort((a, b) => b.date.localeCompare(a.date)); // 先排序
|
||
if (oldArr.length > MAX_PICKUP_DAYS) oldArr = oldArr.slice(0, MAX_PICKUP_DAYS); // 再截断
|
||
|
||
// 写盘 + 异常捕获
|
||
try {
|
||
await file.writeText(pickupRecordFile, JSON.stringify(oldArr, null, 2), false);
|
||
} catch (error) {
|
||
log.error(`appendDailyPickup 写盘失败: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 点击指定名称的 PNG 模板图片
|
||
* 从 assets/RecognitionObject/ 目录加载指定名称的图片模板,识别并点击
|
||
*
|
||
* @param {string} png - 图片文件名(不含扩展名)
|
||
* @param {number} [maxAttempts=20] - 最大重试次数
|
||
* @returns {Promise<boolean|Region>} 返回是否成功点击或 Region 结果
|
||
*
|
||
* @依赖全局变量:
|
||
* - checkInterval: 识别间隔时间
|
||
*
|
||
* @依赖辅助函数:
|
||
* - findAndClick: 通用找图并点击函数
|
||
*/
|
||
async function clickPNG(png, maxAttempts = 20) {
|
||
const pngRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync(`assets/RecognitionObject/${png}.png`));
|
||
pngRo.Threshold = 0.95;
|
||
pngRo.InitTemplate();
|
||
return await findAndClick(pngRo, true, maxAttempts * checkInterval, checkInterval);
|
||
}
|
||
|
||
/**
|
||
* 查找指定名称的 PNG 模板图片(不点击)
|
||
* 从 assets/RecognitionObject/ 目录加载指定名称的图片模板,识别但不点击
|
||
*
|
||
* @param {string} png - 图片文件名(不含扩展名)
|
||
* @param {number} [maxAttempts=20] - 最大重试次数
|
||
* @returns {Promise<boolean|Region>} 返回是否找到或 Region 结果
|
||
*
|
||
* @依赖全局变量:
|
||
* - checkInterval: 识别间隔时间
|
||
*
|
||
* @依赖辅助函数:
|
||
* - findAndClick: 通用找图并点击函数
|
||
*/
|
||
async function findPNG(png, maxAttempts = 20) {
|
||
const pngRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync(`assets/RecognitionObject/${png}.png`));
|
||
pngRo.Threshold = 0.95;
|
||
pngRo.InitTemplate();
|
||
return await findAndClick(pngRo, false, maxAttempts * checkInterval, checkInterval);
|
||
}
|
||
|
||
/**
|
||
* 通用找图/找RO并可选点击
|
||
* 支持单图片文件路径、单RO、图片文件路径数组、RO数组
|
||
*
|
||
* @param {string|string[]|RecognitionObject|RecognitionObject[]} target - 目标图片路径或识别对象
|
||
* @param {boolean} [doClick=true] - 是否点击
|
||
* @param {number} [timeout=3000] - 识别时间上限(毫秒)
|
||
* @param {number} [interval=50] - 识别间隔(毫秒)
|
||
* @param {number} [retType=0] - 返回类型:0-返回布尔;1-返回 Region 结果
|
||
* @param {number} [preClickDelay=50] - 点击前等待时间(毫秒)
|
||
* @param {number} [postClickDelay=50] - 点击后等待时间(毫秒)
|
||
* @returns {Promise<boolean|Region>} 根据 retType 返回是否成功或最终 Region
|
||
*
|
||
* @依赖全局变量:无
|
||
*
|
||
* @依赖辅助函数:无
|
||
*/
|
||
async function findAndClick(target,
|
||
doClick = true,
|
||
timeout = 3000,
|
||
interval = 50,
|
||
retType = 0,
|
||
preClickDelay = 50,
|
||
postClickDelay = 50) {
|
||
try {
|
||
// 1. 统一转成 RecognitionObject 数组
|
||
let ros = [];
|
||
if (Array.isArray(target)) {
|
||
ros = target.map(t =>
|
||
(typeof t === 'string')
|
||
? RecognitionObject.TemplateMatch(file.ReadImageMatSync(t))
|
||
: t
|
||
);
|
||
} else {
|
||
ros = [(typeof target === 'string')
|
||
? RecognitionObject.TemplateMatch(file.ReadImageMatSync(target))
|
||
: target];
|
||
}
|
||
|
||
const start = Date.now();
|
||
let found = null;
|
||
|
||
while (Date.now() - start <= timeout) {
|
||
const gameRegion = await getGameRegion();
|
||
try {
|
||
// 依次尝试每一个 ro
|
||
for (const ro of ros) {
|
||
const res = gameRegion.find(ro);
|
||
if (!res.isEmpty()) { // 找到
|
||
found = res;
|
||
if (doClick) {
|
||
await sleep(preClickDelay);
|
||
res.click();
|
||
await sleep(postClickDelay);
|
||
}
|
||
break; // 成功即跳出 for
|
||
}
|
||
}
|
||
if (found) break; // 成功即跳出 while
|
||
} finally {
|
||
}
|
||
await sleep(interval); // 没找到时等待
|
||
}
|
||
|
||
// 3. 按需返回
|
||
return retType === 0 ? !!found : (found || null);
|
||
|
||
} catch (error) {
|
||
log.error(`执行通用识图时出现错误:${error.message}`);
|
||
return retType === 0 ? false : null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取游戏区域截图,根据时间间隔决定是否重新捕获
|
||
*
|
||
* @param {number} [minInterval=17] - 最小截图间隔(毫秒),默认17ms(约60fps)
|
||
* @param {boolean} [asyncDispose=false] - 是否异步释放旧截图,默认false
|
||
* @returns {Promise<Object>} 游戏区域截图对象
|
||
*
|
||
* @description
|
||
* 使用 gameRegionManager 对象管理以下属性:
|
||
* - cache: 缓存队列,保存近5张截图
|
||
* - lastCapture: 上一次捕获游戏区域的时间戳
|
||
* - isDisposing: 标记是否正在释放旧截图,用于安全锁
|
||
* - isCapturing: 标记是否正在执行截图操作,用于全局锁
|
||
*/
|
||
async function getGameRegion(minInterval = 17, asyncDispose = false) {
|
||
async function disposeOldGameRegion() {
|
||
gameRegionManager.isDisposing = true;
|
||
try {
|
||
// 当缓存队列超过GAME_REGION_CACHE_SIZE个时,销毁最旧的截图
|
||
while (gameRegionManager.cache.length > GAME_REGION_CACHE_SIZE) {
|
||
const oldestRegion = gameRegionManager.cache.shift();
|
||
if (oldestRegion) {
|
||
oldestRegion.dispose();
|
||
}
|
||
}
|
||
} catch (error) {
|
||
log.error(`释放旧游戏区域截图失败: ${error.message}`);
|
||
} finally {
|
||
gameRegionManager.isDisposing = false;
|
||
}
|
||
}
|
||
|
||
// 等待其他任务完成截图
|
||
while (gameRegionManager.isCapturing) {
|
||
await sleep(1);
|
||
}
|
||
|
||
gameRegionManager.isCapturing = true;
|
||
try {
|
||
if (new Date() - gameRegionManager.lastCapture >= minInterval || gameRegionManager.cache.length === 0) {
|
||
while (gameRegionManager.isDisposing) {
|
||
await sleep(1);
|
||
}
|
||
gameRegionManager.lastCapture = new Date();
|
||
const newRegion = captureGameRegion();
|
||
gameRegionManager.cache.push(newRegion);
|
||
|
||
// 根据参数决定是否等待释放完成
|
||
if (asyncDispose) {
|
||
disposeOldGameRegion();
|
||
} else {
|
||
await disposeOldGameRegion();
|
||
}
|
||
}
|
||
} catch (error) {
|
||
log.error(`获取游戏区域截图失败: ${error.message}`);
|
||
} finally {
|
||
gameRegionManager.isCapturing = false;
|
||
// 返回最新的截图
|
||
return gameRegionManager.cache[gameRegionManager.cache.length - 1];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 判断当前人物是否已到达指定路线的终点
|
||
* 通过读取路线文件获取终点坐标,并与当前人物坐标进行曼哈顿距离比较
|
||
*
|
||
* @param {string} fullPath - 路线文件完整路径(.json)
|
||
* @returns {boolean} true = 已到达;false = 未到达/读文件失败/取坐标失败
|
||
*
|
||
* @依赖全局变量:无
|
||
*
|
||
* @依赖辅助函数:无
|
||
*/
|
||
function isArrivedAtEndPoint(fullPath) {
|
||
try {
|
||
if (settings.disableXYCheck) {
|
||
log.info("当前禁用了坐标校验,跳过坐标检查")
|
||
return true;
|
||
}
|
||
/* 1. 读路线文件,取终点坐标 */
|
||
const raw = file.readTextSync(fullPath);
|
||
const json = JSON.parse(raw);
|
||
if (!Array.isArray(json.positions)) return false;
|
||
|
||
let endX = 0, endY = 0;
|
||
for (let i = json.positions.length - 1; i >= 0; i--) {
|
||
const p = json.positions[i];
|
||
if (p.type !== 'orientation' &&
|
||
typeof p.x === 'number' &&
|
||
typeof p.y === 'number') {
|
||
endX = p.x;
|
||
endY = p.y;
|
||
break;
|
||
}
|
||
}
|
||
if (endX === 0 && endY === 0) return false; // 没找到有效点
|
||
|
||
/* 2. 取当前人物坐标與地图匹配方法 */
|
||
|
||
const mapName = (json.info?.map_name && json.info.map_name.trim()) ? json.info.map_name : 'Teyvat';
|
||
const map_match_method = json.info?.map_match_method || "";
|
||
|
||
let pos = null;
|
||
|
||
if (map_match_method && map_match_method !== "") {
|
||
try {
|
||
// 尝试使用传入的方法名称获取座标
|
||
pos = genshin.getPositionFromMapWithMatchingMethod(mapName, map_match_method, 3000);
|
||
} catch (e) {
|
||
// 若 map_match_method 不是合法的匹配方法,抛出例外时自动退回预设方法
|
||
log.warn(`无法使用匹配方法 "${map_match_method}",退回预设匹配模式`);
|
||
pos = genshin.getPositionFromMap(mapName, 3000);
|
||
}
|
||
} else {
|
||
// map_match_method 為空時直接使用預設方法
|
||
pos = genshin.getPositionFromMap(mapName, 3000);
|
||
}
|
||
|
||
const curX = pos.X;
|
||
const curY = pos.Y;
|
||
|
||
let pathres = Math.abs(endX - curX) + Math.abs(endY - curY) <= 30;
|
||
if (!pathres) {
|
||
log.warn(`距离预定终点${Math.abs(endX - curX) + Math.abs(endY - curY)}`);
|
||
log.warn(`距离异常,不记录数据`);
|
||
}
|
||
/* 3. 曼哈顿距离 ≤30 视为到达 */
|
||
return pathres;
|
||
} catch (error) {
|
||
/* 任何异常(读盘失败、解析失败、API 异常)都算“未到达” */
|
||
log.warn(`出现异常${error.message},不记录cd`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 判断当前是否存在拾取滚轮图标
|
||
* 在指定时间内持续检测游戏画面中是否存在拾取滚轮图标
|
||
*
|
||
* @param {number} [maxDuration=10] - 最大允许耗时(毫秒)
|
||
* @returns {Promise<boolean>} 返回是否检测到滚轮图标
|
||
*
|
||
* @依赖全局变量:
|
||
* - gameRegion: 游戏区域对象
|
||
* - scrollRo: 拾取滚轮识别对象
|
||
* - findFInterval: 识别间隔时间
|
||
*
|
||
* @依赖辅助函数:无
|
||
*/
|
||
async function hasScroll(maxDuration = 10) {
|
||
const start = Date.now();
|
||
while (Date.now() - start < maxDuration) {
|
||
gameRegion = await getGameRegion();
|
||
try {
|
||
const result = gameRegion.find(scrollRo);
|
||
if (result.isExist()) return true;
|
||
} catch (error) {
|
||
log.error(`识别图像时发生异常: ${error.message}`);
|
||
return false; // 一旦出现异常直接退出,不再重试
|
||
}
|
||
await sleep(findFInterval); // 识别间隔
|
||
}
|
||
/* 超时仍未识别到,返回失败 */
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 零基构建 settings.json 配置文件
|
||
* 扫描 pathing 目录下的文件夹,动态生成包含路径组配置的 settings.json 文件
|
||
*
|
||
* @returns {Promise<boolean>} 返回是否继续运行,仅刷新模式返回 false,否则返回 true
|
||
*
|
||
* @依赖全局变量:
|
||
* - settings: 用户设置对象
|
||
* - groupCount: 路径组数量
|
||
*
|
||
* @依赖辅助函数:无
|
||
*/
|
||
async function buildSettingsJson() {
|
||
const SETTINGS_FILE = `settings.json`;
|
||
const PATHINGS_ROOT = `pathing`;
|
||
|
||
/* 1. 扫描 pathing 下第一层目录 */
|
||
const filesInFolder = file.ReadPathSync(PATHINGS_ROOT);
|
||
const subFolders = []; // 用于存储第一层文件夹路径
|
||
for (const filePath of filesInFolder) {
|
||
if (file.IsFolder(filePath)) {
|
||
// 如果是文件夹,先存储到临时数组中
|
||
subFolders.push(filePath);
|
||
}
|
||
}
|
||
|
||
/* 2. 提取文件夹名称 */
|
||
const firstLevelDirs = subFolders
|
||
.map(folderPath => folderPath.replace(`${PATHINGS_ROOT}/`, '').replace(`${PATHINGS_ROOT}\\`, '')) // 去掉前缀 `pathing/` 或 `pathing\`
|
||
.filter(Boolean); // 去掉空字符串
|
||
|
||
let uniqueDirs = Array.from(new Set(firstLevelDirs)); // 去重
|
||
|
||
/* 4. 路径组数量 */
|
||
groupCount = Math.min(99, Math.max(1, parseInt(settings.groupCount || '3')));
|
||
|
||
/* 5. 硬编码构建全新 JSON */
|
||
const newSettings = [];
|
||
|
||
/* 5.1 最前端:onlyRefresh + groupCount */
|
||
newSettings.push(
|
||
{
|
||
name: "onlyRefresh",
|
||
type: "checkbox",
|
||
label: "勾选后仅刷新自定义配置,不运行"
|
||
},
|
||
{
|
||
name: "groupCount",
|
||
type: "input-text",
|
||
label: "需要生成几个路径组配置(1-99)",
|
||
default: "3"
|
||
},
|
||
{
|
||
name: "enableMoreSettings",
|
||
type: "checkbox",
|
||
label: "勾选后下次运行展开高级设置\n用于进行路线筛选和排序"
|
||
}
|
||
);
|
||
|
||
/* 5.2 操作模式 */
|
||
newSettings.push({
|
||
name: "operationMode",
|
||
type: "select",
|
||
label: "选择操作模式",
|
||
options: [
|
||
"执行任务(若不存在索引文件则自动创建)",
|
||
"重新生成索引文件(用于强制刷新CD)"
|
||
]
|
||
});
|
||
|
||
/* 5.2.0 拾取模式 */
|
||
newSettings.push({
|
||
name: "pickup_Mode",
|
||
type: "select",
|
||
label: "选择拾取模式\n【警告】「bgi原版拾取」依赖莫版BGI,在原版BGI下使用会导致物品计数功能失效",
|
||
options: [
|
||
"模板匹配拾取",
|
||
"bgi原版拾取"
|
||
],
|
||
default: "模板匹配拾取"
|
||
});
|
||
|
||
/* 5.2.1 循环模式 */
|
||
newSettings.push({
|
||
name: "loopMode",
|
||
type: "select",
|
||
label: "选择循环模式",
|
||
options: [
|
||
"不循环",
|
||
"每组重试",
|
||
"全局循环"
|
||
],
|
||
default: "不循环"
|
||
});
|
||
|
||
/* 5.3 固定尾部节点(原样照搬) */
|
||
newSettings.push(
|
||
{
|
||
"name": "timeRule",
|
||
"type": "input-text",
|
||
"label": "本地时间-不运行时段\n示例写法:\n 单个小时:8\n 连续区间:8-11 或 23:11-23:55(可省略分钟)\n 多项分隔:用中文逗号【,】\n规则:\n 只写小时:开始=整点,结束=59分;跨天自动识别\n 含分钟:按实际时分计算\n 提前10分钟结束并等待到限制时段开始\n留空=全天可运行"
|
||
},
|
||
{
|
||
"name": "infoFileName",
|
||
"type": "input-text",
|
||
"label": "输入用于存储信息的文件名,只在不同账号分别管理CD时填写"
|
||
},
|
||
{
|
||
"name": "priorityItems",
|
||
"type": "input-text",
|
||
"label": "优先采集材料,每天会尝试优先采集指定数量的目标物品,随后才执行路径组\n格式:材料名*数量,由加号+连接\n如萃凝晶*160+甜甜花*10"
|
||
},
|
||
{
|
||
"name": "oneTimePriorityItems",
|
||
"type": "input-text",
|
||
"label": "一次性优先采集材料,优先级低于每日优先采集,采完即止、不再按天重置\n采集到该材料时会自动扣减本配置,清零自动删除对应项\n格式:材料名*数量,由加号+连接\n如萃凝晶*160+甜甜花*10"
|
||
},
|
||
{
|
||
"name": "maxRuntimeMinutes",
|
||
"type": "input-text",
|
||
"label": "总运行限时(分钟),0=不限时\n从脚本启动开始计时,完成任意路线后检测,超时则结束脚本",
|
||
"default": "0"
|
||
},
|
||
{
|
||
"name": "priorityItemsPartyName",
|
||
"type": "input-text",
|
||
"label": "优先采集材料使用的备用配队名称\n在指定路线不存在对应文件夹指定的配队时使用"
|
||
},
|
||
{
|
||
"name": "disableJsons",
|
||
"type": "input-text",
|
||
"label": "填写需要禁用的路线的关键词,使用中文分号分隔\n文件路径含有相关关键词的路线会被禁用"
|
||
},
|
||
{
|
||
"name": "disableXYCheck",
|
||
"type": "checkbox",
|
||
"label": "勾选后跳过路线完成后的坐标校验\n【警告】运行卡死等未成功到达终点的路线也将进入cd"
|
||
},
|
||
{
|
||
"name": "findFInterval",
|
||
"type": "input-text",
|
||
"label": "识别间隔(毫秒)\n两次检测f图标之间等待时间",
|
||
"default": "100"
|
||
},
|
||
{
|
||
"name": "processingIngredient",
|
||
"type": "multi-checkbox",
|
||
"label": "要加工的食材种类",
|
||
"default": [],
|
||
"options": [
|
||
"面粉",
|
||
"兽肉",
|
||
"鱼肉",
|
||
"神秘的肉",
|
||
"黑麦粉",
|
||
"奶油",
|
||
"熏禽肉",
|
||
"黄油",
|
||
"火腿",
|
||
"糖",
|
||
"香辛料",
|
||
"酸奶油",
|
||
"蟹黄",
|
||
"果酱",
|
||
"奶酪",
|
||
"培根",
|
||
"香肠"
|
||
]
|
||
},
|
||
{
|
||
"name": "checkInterval",
|
||
"type": "input-text",
|
||
"label": "食材加工中的识别间隔(毫秒),设备反应较慢出现识别错误时适当调大",
|
||
"default": "50"
|
||
},
|
||
{
|
||
"name": "setTimeMode",
|
||
"type": "select",
|
||
"label": "尝试调节时间来获得移速加成\n队伍中含迪希雅、嘉明或塔利雅时选择白天\n队伍中含罗莎莉亚时选择夜晚",
|
||
"options": [
|
||
"不调节时间",
|
||
"尽量调为白天",
|
||
"尽量调为夜晚"
|
||
],
|
||
"default": "不调节时间"
|
||
},
|
||
{
|
||
"name": "disableSecondCheck",
|
||
"type": "checkbox",
|
||
"label": "禁用识别到物品后的二次校验,可能增加误捡概率",
|
||
"default": false
|
||
}
|
||
);
|
||
|
||
if (settings.enableMoreSettings) {
|
||
newSettings.push(
|
||
{
|
||
"name": "priorityTags",
|
||
"type": "input-text",
|
||
"label": "优先关键词,文件名或拾取材料含关键词的路线会被视为最高效率\n不同关键词使用【中文逗号】分隔"
|
||
},
|
||
{
|
||
"name": "sortMode",
|
||
"type": "select",
|
||
"label": "选择同组路线排序模式",
|
||
"options": [
|
||
"文件顺序,按在文件夹中位置顺序运行",
|
||
"优先最早刷新,将优先执行最早刷新的路线",
|
||
"优先最高效率,将优先执行最高分均拾取物的路线"
|
||
],
|
||
"default": "文件顺序,按在文件夹中位置顺序运行"
|
||
},
|
||
{
|
||
"name": "defaultEffPercentile",
|
||
"type": "input-text",
|
||
"label": "默认效率指数,范围0-1\n数值越大时,未知效率的路线被视作的默认效率越高",
|
||
"default": "0.5"
|
||
},
|
||
{
|
||
"name": "weightedRule",
|
||
"type": "input-text",
|
||
"label": "加权规则,允许将特定物品视为多倍计算效率\n黑名单物品将自动视为0\n格式如下:\n物品名称*权重\n使用【中文逗号】分隔\n如:甜甜花*2,树莓*0"
|
||
}
|
||
);
|
||
}
|
||
|
||
/* 5.4 路径组节点(整体移到最后) */
|
||
for (let g = 1; g <= groupCount; g++) {
|
||
/* 文件夹 */
|
||
newSettings.push({
|
||
name: `pathGroup${g}FolderName`,
|
||
type: "select",
|
||
label: `#############################################\n选择路径组${g}文件夹(pathing下第一层)`,
|
||
options: ["", ...uniqueDirs]
|
||
});
|
||
|
||
/* CD类型 */
|
||
newSettings.push({
|
||
name: `pathGroup${g}CdType`,
|
||
type: "select",
|
||
label: `选择路径组${g}CD类型,不选不运行该路径组`,
|
||
options: [
|
||
"",
|
||
"1次0点刷新",
|
||
"2次0点刷新",
|
||
"3次0点刷新",
|
||
"4点刷新",
|
||
"12小时刷新",
|
||
"24小时刷新",
|
||
"46小时刷新",
|
||
"每天一次"
|
||
]
|
||
});
|
||
|
||
/* 队伍名 */
|
||
newSettings.push({
|
||
name: `pathGroup${g}PartyName`,
|
||
type: "input-text",
|
||
label: `输入路径组${g}使用配队名称`
|
||
});
|
||
|
||
if (settings.enableMoreSettings) {
|
||
newSettings.push({
|
||
"name": `pathGroup${g}thresholdEfficiency`,
|
||
"type": "input-text",
|
||
"label": `路径组${g}临界效率\n分均拾取个数效率低于临界效率的路线会被排除`,
|
||
"default": "0"
|
||
});
|
||
}
|
||
}
|
||
|
||
/* 6. 一次性写入 & 日志 */
|
||
await file.writeText(SETTINGS_FILE, JSON.stringify(newSettings, null, 2), false);
|
||
log.info(`已全新生成 settings.json,共 ${groupCount} 个路径组配置。`);
|
||
log.info(`扫描到可供选择的文件夹:${uniqueDirs.join(' | ')}`);
|
||
|
||
// 仅刷新模式检查
|
||
if (settings.onlyRefresh) {
|
||
settings.onlyRefresh = false;
|
||
log.info(`刷新自定义配置`);
|
||
log.debug(`交互或拾取:"刷新自定义配置"`);
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 初始化设置和记录文件
|
||
* 读取用户设置,初始化全局变量,加载目标物品和黑名单,创建或更新索引文件
|
||
*
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - settings: 用户设置对象
|
||
* - groupCount: 路径组数量
|
||
* - folderNames: 文件夹名称数组
|
||
* - partyNames: 配队名称数组
|
||
* - accountName: 账户名称
|
||
* - recordFolder: 记录文件夹路径
|
||
* - subFolderName: 子文件夹名称
|
||
* - subFolderPath: 子文件夹路径
|
||
* - pickupRecordFile: 拾取记录文件路径
|
||
* - operationMode: 操作模式
|
||
* - targetItems: 目标物品数组
|
||
* - name2Other: 本名到别名数组的映射
|
||
* - alias2Names: 别名到本名数组的映射
|
||
* - state: 状态对象
|
||
* - recordFilePath: 记录文件路径
|
||
* - processingIngredient: 食材加工列表
|
||
* - Foods: 食材数组
|
||
* - materialCdMap: 材料CD映射表
|
||
*
|
||
* @依赖辅助函数:
|
||
* - loadTargetItems: 加载目标物品函数
|
||
* - loadBlacklist: 加载黑名单函数
|
||
* - fakeLog: 模拟日志函数
|
||
* - readFolder: 读取文件夹函数
|
||
* - basename: 获取文件基本名函数
|
||
*/
|
||
async function initializeSetup() {
|
||
/* ===== 读取新 settings ===== */
|
||
groupCount = Math.min(99, Math.max(1, parseInt(settings.groupCount || '3')));
|
||
folderNames = [];
|
||
partyNames = [];
|
||
for (let g = 1; g <= groupCount; g++) {
|
||
folderNames.push(settings[`pathGroup${g}FolderName`] || '');
|
||
partyNames.push(settings[`pathGroup${g}PartyName`] || '');
|
||
}
|
||
|
||
// 获取子文件夹路径
|
||
subFolderName = accountName;
|
||
subFolderPath = `${recordFolder}/${subFolderName}`;
|
||
pickupRecordFile = `${recordFolder}/${subFolderName}/拾取记录.json`;
|
||
|
||
// 读取子文件夹中的所有文件路径
|
||
const filesInSubFolder = file.ReadPathSync(subFolderPath);
|
||
|
||
// 检查优先顺序:record.json > record.txt
|
||
let indexDoExist = false;
|
||
let useJson = false;
|
||
for (const filePath of filesInSubFolder) {
|
||
const fileName = basename(filePath);
|
||
if (fileName === "record.json") {
|
||
indexDoExist = true;
|
||
useJson = true;
|
||
break;
|
||
}
|
||
if (fileName === "record.txt") {
|
||
indexDoExist = true;
|
||
useJson = false;
|
||
}
|
||
}
|
||
|
||
if (operationMode === "重新生成索引文件(用于强制刷新CD)") {
|
||
log.info("重新生成索引文件模式,将覆盖现有索引文件");
|
||
}
|
||
if (!indexDoExist) {
|
||
log.info("文件不存在,将尝试生成索引文件");
|
||
}
|
||
|
||
/* 禁用BGI原生拾取,强制模板匹配 */
|
||
targetItems = await loadTargetItems();
|
||
/* ===== 别名索引 ===== */
|
||
name2Other = new Map(); // 本名 → 别名数组
|
||
alias2Names = new Map(); // 别名 → 本名数组(支持多对一)
|
||
for (const it of targetItems) {
|
||
const aliases = it.otherName || [];
|
||
name2Other.set(it.itemName, aliases);
|
||
for (const a of aliases) {
|
||
if (!alias2Names.has(a)) alias2Names.set(a, []);
|
||
alias2Names.get(a).push(it.itemName); // 一个别名可指向多个本名
|
||
}
|
||
}
|
||
|
||
await loadBlacklist(true);
|
||
state.running = true;
|
||
|
||
await fakeLog("采集cd管理", true, false, 1000);
|
||
|
||
// 统一的 record.json 文件路径
|
||
recordFilePath = `${subFolderPath}/record.json`;
|
||
|
||
// 读取 pathing 文件夹下的所有 .json 文件
|
||
const pathingFolder = "pathing";
|
||
const files = await readFolder(pathingFolder, true);
|
||
const filePaths = files.map(file => file.fullPath);
|
||
|
||
// ① 先加载已有记录(整对象)
|
||
let recordArray = [];
|
||
if (indexDoExist && useJson) {
|
||
try { recordArray = JSON.parse(await file.readText(recordFilePath)); } catch (e) { }
|
||
} else if (indexDoExist && !useJson) {
|
||
try {
|
||
const txt = await file.readText(`${subFolderPath}/record.txt`);
|
||
txt.trim().split('\n').forEach(line => {
|
||
const [n, t] = line.trim().split('::');
|
||
if (n && t) recordArray.push({ fileName: n + '.json', cdTime: t });
|
||
});
|
||
} catch (e) { }
|
||
}
|
||
|
||
// ② 建 Map<fileName, 原对象> 确保 history 存在
|
||
const existMap = new Map(recordArray.map(it => [it.fileName, {
|
||
...it,
|
||
history: it.history || [] // 补空数组
|
||
}]));
|
||
|
||
// ③ 对 pathing 里存在的路线:只更新 cdTime,其余保留
|
||
const defaultTime = "1970/1/1 08:00:00";
|
||
for (const filePath of filePaths) {
|
||
const fileName = basename(filePath);
|
||
if (!fileName.endsWith('.json')) continue;
|
||
|
||
const old = existMap.get(fileName) || {};
|
||
const newCd = (indexDoExist &&
|
||
operationMode !== "重新生成索引文件(用于强制刷新CD)" &&
|
||
old.cdTime)
|
||
? old.cdTime
|
||
: defaultTime;
|
||
|
||
existMap.set(fileName, {
|
||
...old, // 保留所有旧字段
|
||
fileName,
|
||
cdTime: newCd,
|
||
history: old.history || [] // 确保有 history
|
||
});
|
||
}
|
||
|
||
// ④ 写回(含已消失的路线)
|
||
const writeResult = file.writeTextSync(recordFilePath,
|
||
JSON.stringify(Array.from(existMap.values()), null, 2));
|
||
|
||
if (writeResult) {
|
||
log.info(`信息已成功写入: ${recordFilePath}`);
|
||
} else {
|
||
log.error(`写入文件失败: ${recordFilePath}`);
|
||
}
|
||
|
||
// 初始化食材加工列表
|
||
try {
|
||
Foods = Array.from(processingIngredient);
|
||
} catch (e) { Foods = []; }
|
||
|
||
// 加载材料CD映射表
|
||
try {
|
||
const cdMapText = await file.readText('assets/materialCdMap.json');
|
||
const cdMapObj = JSON.parse(cdMapText);
|
||
materialCdMap = { ...cdMapObj['46h特产'], ...cdMapObj['12h素材'], ...cdMapObj['4点刷新'], ...cdMapObj['0点刷新'] };
|
||
log.info(`材料CD映射表加载完成,共 ${Object.keys(materialCdMap).length} 条记录`);
|
||
} catch (e) {
|
||
log.error(`加载材料CD映射表失败: ${e.message}`);
|
||
materialCdMap = {};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理优先级材料采集
|
||
* 解析用户设置的优先采集材料,计算路线效率,循环执行最高效率路线直到达标
|
||
*
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - settings: 用户设置对象
|
||
* - pickupRecordFile: 拾取记录文件路径
|
||
* - alias2Names: 别名到本名数组的映射
|
||
* - name2Other: 本名到别名数组的映射
|
||
* - subFolderName: 子文件夹名称
|
||
* - lastMapName: 上次地图名称
|
||
* - targetItems: 目标物品数组
|
||
* - disableArray: 禁用关键词数组
|
||
* - materialCdMap: 材料CD映射表
|
||
*
|
||
* @依赖辅助函数:
|
||
* - readFolder: 读取文件夹函数
|
||
* - isTimeRestricted: 判断时间是否受限函数
|
||
* - calculateRouteEfficiency: 计算路线效率函数
|
||
* - calculateDefaultEfficiency: 计算默认效率函数
|
||
* - selectPartyByRoutePath: 根据路线路径选择配队函数
|
||
* - handleIngredientProcessing: 处理食材加工函数
|
||
* - handleTimeAdjustment: 处理时间调整函数
|
||
* - fakeLog: 模拟日志函数
|
||
* - prioritizeHistoricalItems: 历史拾取物优先排序函数
|
||
* - executeRoute: 执行路线函数
|
||
* - saveRecordAndClearLog: 保存记录并清空日志函数
|
||
* - basename: 获取文件基本名函数
|
||
*/
|
||
async function processPriorityItems() {
|
||
if (settings.priorityItems) {
|
||
/* ---------- 1. 解析 ---------- */
|
||
const priorityList = [];
|
||
const segments = settings.priorityItems.split('+').map(s => s.trim());
|
||
for (const seg of segments) {
|
||
const [itemName, countStr] = seg.split('*').map(s => s.trim());
|
||
if (itemName && countStr && !isNaN(Number(countStr))) {
|
||
priorityList.push({ itemName, count: Number(countStr) });
|
||
}
|
||
}
|
||
log.info(`优先级材料解析完成: ${priorityList.map(e => `${e.itemName}*${e.count}`).join(', ')}`);
|
||
/* ===== 追加:扣除今日已拾取(UTC+8 0 点分界) ===== */
|
||
const utc8 = new Date(Date.now() + 8 * 3600_000); // 手动+8小时
|
||
const today = utc8.toISOString().slice(0, 10); // "YYYY-MM-DD"
|
||
let todayPicked = {}; // 今日已拾取数量
|
||
try {
|
||
const txt = await file.readText(pickupRecordFile);
|
||
if (txt) {
|
||
const arr = JSON.parse(txt);
|
||
const todayItem = arr.find(it => it.date === today);
|
||
if (todayItem) todayPicked = todayItem.items || {};
|
||
}
|
||
} catch (_) { /* 文件不存在或解析失败 */ }
|
||
|
||
/* 扣除今日已拾取:双向扣除 */
|
||
for (let i = priorityList.length - 1; i >= 0; i--) {
|
||
const task = priorityList[i];
|
||
let got = 0;
|
||
|
||
/* 1. 字面名(可能是别名)直接扣 */
|
||
got += todayPicked[task.itemName] || 0;
|
||
/* 2. 如果字面名是别名,把对应本名也扣一遍 */
|
||
const realNames = alias2Names.get(task.itemName) || []; // 现在是数组
|
||
|
||
for (const n of realNames) got += todayPicked[n] || 0;
|
||
|
||
/* 3. 如果字面名是本名,把所有别名再扣一遍 */
|
||
const others = name2Other.get(task.itemName) || [];
|
||
for (const a of others) got += todayPicked[a] || 0;
|
||
|
||
task.count -= got;
|
||
if (task.count <= 0) priorityList.splice(i, 1);
|
||
}
|
||
|
||
if (priorityList.length === 0) {
|
||
log.info("今日优先材料已达标,跳过优先采集阶段");
|
||
notification.send("今日优先材料已达标,跳过优先采集阶段");
|
||
}
|
||
/* ================================= */
|
||
|
||
/* ---------- 3. 主循环 ---------- */
|
||
while (priorityList.length > 0) {
|
||
const maxRunCount = 1;
|
||
|
||
/* 1. 先把用户填的字面名(可能是别名)全部弄进来 */
|
||
const priorityItemSet = new Set(priorityList.map(p => p.itemName));
|
||
|
||
/* 2. 双向扩:本名↔别名 */
|
||
for (const a of [...priorityItemSet]) { // 复制一份避免遍历过程中增长
|
||
// 2.1 如果 a 是“本名”,把它的所有别名加进来(原来就有的逻辑)
|
||
const others = name2Other.get(a) || [];
|
||
for (const o of others) priorityItemSet.add(o);
|
||
|
||
// 2.2 如果 a 是“别名”,把对应的本名加进来(新增反向)
|
||
const realName = alias2Names.get(a) || [];
|
||
for (const r of realName) priorityItemSet.add(r);
|
||
}
|
||
|
||
const pickedCounter = {};
|
||
priorityItemSet.forEach(n => pickedCounter[n] = 0);
|
||
/* ===== 剩余物品 ===== */
|
||
let remaining = priorityList.map(t => `${t.itemName}*${t.count}`).join(', ');
|
||
/* 4-1 扫描 + 读 record + 前置过滤(禁用/时间/材料相关)+ 计算效率 + CD后置排除 */
|
||
const allFiles = await readFolder('pathing', true);
|
||
const rawRecord = await file.readText(`record/${subFolderName}/record.json`);
|
||
let recordArray = [];
|
||
try { recordArray = JSON.parse(rawRecord); } catch { /* 空记录 */ }
|
||
const cdMap = new Map(recordArray.map(it => [it.fileName, it]));
|
||
const now = new Date();
|
||
/* 时间管制 */
|
||
if (await isTimeRestricted(settings.timeRule, 10)) { priorityList.length = 0; break; }
|
||
|
||
/* ---- 先算效率(不判CD)---- */
|
||
calculateRouteEfficiency(allFiles, cdMap, {
|
||
priorityItemSet,
|
||
disableArray,
|
||
isPriorityMode: true
|
||
});
|
||
|
||
/* ---- 用可运行路线算分位默认值 ---- */
|
||
const knownEff = allFiles
|
||
.filter(f => {
|
||
const rec = cdMap.get(f.fileName);
|
||
const nextCD = rec ? new Date(rec.cdTime) : new Date(0);
|
||
return f._priorityEff >= 0 && now > nextCD;
|
||
})
|
||
.map(f => f._priorityEff)
|
||
.sort((a, b) => a - b);
|
||
const defaultEff = calculateDefaultEfficiency(knownEff, settings.defaultEffPercentile, 1);
|
||
/* 回填未知 + 排除CD */
|
||
allFiles.forEach(f => {
|
||
if (f._priorityEff === -2) f._priorityEff = defaultEff;
|
||
const rec = cdMap.get(f.fileName);
|
||
const nextCD = rec ? new Date(rec.cdTime) : new Date(0);
|
||
if (now <= nextCD) f._priorityEff = -1;
|
||
});
|
||
|
||
if (priorityList.length === 0) break;
|
||
|
||
/* 4-2 只跑最高效率路线 */
|
||
const candidateRoutes = allFiles
|
||
.filter(f => {
|
||
return f._priorityEff >= 0 &&
|
||
(routeRunCount[f.fileName] || 0) < maxRunCount; // 未超过执行上限
|
||
})
|
||
.sort((a, b) => b._priorityEff - a._priorityEff);
|
||
if (candidateRoutes.length === 0 && priorityList.length > 0) {
|
||
log.info('已无可用优先路线(可能全部在CD),退出优先采集阶段');
|
||
notification.send('已无可用优先路线(可能全部在CD),退出优先采集阶段');
|
||
break;
|
||
}
|
||
const bestRoute = candidateRoutes[0];
|
||
const filePath = bestRoute.fullPath;
|
||
const fileName = basename(filePath).replace('.json', '');
|
||
const fullName = fileName + '.json';
|
||
const targetObj = cdMap.get(fullName);
|
||
const startTime = new Date();
|
||
|
||
/* ---------- 智能选队:按路线所在文件夹反查路径组 ---------- */
|
||
await selectPartyByRoutePath(bestRoute.fullPath, "优先采集阶段");
|
||
|
||
log.info(`当前进度:执行路线 ${fileName},剩余优先材料:${remaining}`);
|
||
|
||
let timeNow = new Date();
|
||
await handleIngredientProcessing(timeNow);
|
||
|
||
await handleTimeAdjustment(timeNow);
|
||
await fakeLog(fileName, false, true, 0);
|
||
|
||
// 优先采集模式不支持 schedule 任务,静默跳过
|
||
try {
|
||
const routeJson = JSON.parse(file.readTextSync(filePath));
|
||
if (routeJson.schedule && routeJson.tasks) {
|
||
continue;
|
||
}
|
||
} catch (e) { /* ignore */ }
|
||
|
||
routeRunCount[fullName] = (routeRunCount[fullName] || 0) + 1;
|
||
|
||
/* ========== 历史拾取物前置排序 ========== */
|
||
targetItems = prioritizeHistoricalItems(targetItems, cdMap, fullName);
|
||
/* ================================= */
|
||
|
||
/* ================================= */
|
||
const routeResult = await executeRoute(filePath, fileName, targetObj, startTime, lastMapName, priorityItemSet);
|
||
if (!routeResult.success) {
|
||
continue;
|
||
}
|
||
lastMapName = routeResult.lastMapName;
|
||
/* ===== 用声明材料数量修正拾取日志 ===== */
|
||
const correctedLog = correctPickupLogByDeclaration(routeResult.runPickupLog, bestRoute.fullPath);
|
||
/* ===================================== */
|
||
correctedLog.forEach(name => {
|
||
/* 就地展开:别名→本名数组,再把所有相关名称都计数 */
|
||
const realNames = alias2Names.get(name) || [name]; // 可能是多个本名
|
||
for (const rn of realNames) {
|
||
if (priorityItemSet.has(name) || priorityItemSet.has(rn)) {
|
||
pickedCounter[rn] = (pickedCounter[rn] || 0) + 1;
|
||
}
|
||
}
|
||
});
|
||
|
||
/* ===== 追加:立即把 pickedCounter 回写到 priorityList(双向扣减)===== */
|
||
for (const task of priorityList) {
|
||
let picked = 0;
|
||
|
||
/* 1. 字面名(可能是别名)直接扣 */
|
||
picked += pickedCounter[task.itemName] || 0;
|
||
|
||
/* 2. 别名→本名反向扣(多对一) */
|
||
const realNames = alias2Names.get(task.itemName) || [];
|
||
for (const rn of realNames) picked += pickedCounter[rn] || 0;
|
||
|
||
/* 3. 本名→别名顺向扣 */
|
||
const others = name2Other.get(task.itemName) || [];
|
||
for (const a of others) picked += pickedCounter[a] || 0;
|
||
|
||
task.count = Math.max(0, task.count - picked);
|
||
}
|
||
|
||
/* 倒序删除已达标项 */
|
||
for (let i = priorityList.length - 1; i >= 0; i--) {
|
||
if (priorityList[i].count <= 0) {
|
||
log.info(`优先材料已达标: ${priorityList[i].itemName}`);
|
||
priorityList.splice(i, 1);
|
||
}
|
||
}
|
||
|
||
/* ================================================ */
|
||
|
||
/* ---------- 3. 统一写文件 & 清空日志(用声明修正后的日志) ---------- */
|
||
await saveRecordAndClearLog(cdMap, recordFilePath, correctedLog);
|
||
if (priorityList.length <= 0) {
|
||
log.info('每日优先材料已达标,退出优先采集阶段');
|
||
notification.send('每日优先材料已达标,退出优先采集阶段');
|
||
}
|
||
|
||
// 完成任意路线后检查总运行限时,超时则结束整个脚本
|
||
if (checkRuntimeLimit()) {
|
||
priorityList.length = 0;
|
||
break;
|
||
}
|
||
}
|
||
await sleep(1000);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 处理一次性优先材料采集(优先级低于每日优先采集)
|
||
* 解析 settings.oneTimePriorityItems(当前剩余量,采完即止、不再按天重置),
|
||
* 计算路线效率,循环执行最高效率路线直到全部清零。
|
||
*
|
||
* 与每日优先不同:①不扣除今日已拾取(剩余量为持久化配置,跨运行累积);
|
||
* ②扣减不在本函数内做,而是统一由 saveRecordAndClearLog 内的
|
||
* deductOneTimePriority 全局收口——因此每日优先、路径组拾取到也会同步扣减。
|
||
* 本函数每轮从 settings.oneTimePriorityItems 重新读取剩余量,为空即结束。
|
||
*
|
||
* @returns {Promise<void>} 无返回值
|
||
*/
|
||
async function processOneTimePriorityItems() {
|
||
if (!settings.oneTimePriorityItems) return;
|
||
|
||
const maxRunCount = 1;
|
||
while (settings.oneTimePriorityItems) {
|
||
// 重新解析当前剩余量(已被全局扣减更新)
|
||
const list = [];
|
||
const segments = String(settings.oneTimePriorityItems).split('+').map(s => s.trim());
|
||
for (const seg of segments) {
|
||
const [itemName, countStr] = seg.split('*').map(s => s.trim());
|
||
if (itemName && countStr && !isNaN(Number(countStr))) {
|
||
list.push({ itemName, count: Number(countStr) });
|
||
}
|
||
}
|
||
if (list.length === 0) break;
|
||
|
||
/* 1. 目标集合(双向别名展开) */
|
||
const priorityItemSet = new Set(list.map(p => p.itemName));
|
||
for (const a of [...priorityItemSet]) {
|
||
const others = name2Other.get(a) || [];
|
||
for (const o of others) priorityItemSet.add(o);
|
||
const realName = alias2Names.get(a) || [];
|
||
for (const r of realName) priorityItemSet.add(r);
|
||
}
|
||
|
||
/* 2. 扫描 + 效率计算 + CD 排除 */
|
||
const allFiles = await readFolder('pathing', true);
|
||
const rawRecord = await file.readText(`record/${subFolderName}/record.json`);
|
||
let recordArray = [];
|
||
try { recordArray = JSON.parse(rawRecord); } catch { /* 空记录 */ }
|
||
const cdMap = new Map(recordArray.map(it => [it.fileName, it]));
|
||
const now = new Date();
|
||
if (await isTimeRestricted(settings.timeRule, 10)) break;
|
||
if (checkRuntimeLimit()) break;
|
||
|
||
calculateRouteEfficiency(allFiles, cdMap, {
|
||
priorityItemSet,
|
||
disableArray,
|
||
isPriorityMode: true
|
||
});
|
||
const knownEff = allFiles
|
||
.filter(f => {
|
||
const rec = cdMap.get(f.fileName);
|
||
const nextCD = rec ? new Date(rec.cdTime) : new Date(0);
|
||
return f._priorityEff >= 0 && now > nextCD;
|
||
})
|
||
.map(f => f._priorityEff)
|
||
.sort((a, b) => a - b);
|
||
const defaultEff = calculateDefaultEfficiency(knownEff, settings.defaultEffPercentile, 1);
|
||
allFiles.forEach(f => {
|
||
if (f._priorityEff === -2) f._priorityEff = defaultEff;
|
||
const rec = cdMap.get(f.fileName);
|
||
const nextCD = rec ? new Date(rec.cdTime) : new Date(0);
|
||
if (now <= nextCD) f._priorityEff = -1;
|
||
});
|
||
|
||
/* 3. 只跑最高效率路线 */
|
||
const candidateRoutes = allFiles
|
||
.filter(f => f._priorityEff >= 0 && (routeRunCount[f.fileName] || 0) < maxRunCount)
|
||
.sort((a, b) => b._priorityEff - a._priorityEff);
|
||
if (candidateRoutes.length === 0) {
|
||
log.info('已无可用一次性优先路线(可能全部在CD),退出一次性优先采集阶段');
|
||
notification.send('已无可用一次性优先路线(可能全部在CD),退出一次性优先采集阶段');
|
||
break;
|
||
}
|
||
const bestRoute = candidateRoutes[0];
|
||
const filePath = bestRoute.fullPath;
|
||
const fileName = basename(filePath).replace('.json', '');
|
||
const fullName = fileName + '.json';
|
||
const targetObj = cdMap.get(fullName);
|
||
const startTime = new Date();
|
||
|
||
await selectPartyByRoutePath(bestRoute.fullPath, "一次性优先采集阶段");
|
||
log.info(`当前进度:执行路线 ${fileName},剩余一次性优先材料:${list.map(t => `${t.itemName}*${t.count}`).join(', ')}`);
|
||
|
||
let timeNow = new Date();
|
||
await handleIngredientProcessing(timeNow);
|
||
await handleTimeAdjustment(timeNow);
|
||
await fakeLog(fileName, false, true, 0);
|
||
|
||
// 一次性优先采集同样不支持 schedule 任务,静默跳过(先计数,避免反复选中同一条 schedule 路线形成死循环)
|
||
routeRunCount[fullName] = (routeRunCount[fullName] || 0) + 1;
|
||
try {
|
||
const routeJson = JSON.parse(file.readTextSync(filePath));
|
||
if (routeJson.schedule && routeJson.tasks) continue;
|
||
} catch (e) { /* ignore */ }
|
||
|
||
targetItems = prioritizeHistoricalItems(targetItems, cdMap, fullName);
|
||
|
||
const routeResult = await executeRoute(filePath, fileName, targetObj, startTime, lastMapName, priorityItemSet);
|
||
if (!routeResult.success) continue;
|
||
lastMapName = routeResult.lastMapName;
|
||
|
||
const correctedLog = correctPickupLogByDeclaration(routeResult.runPickupLog, bestRoute.fullPath);
|
||
// saveRecordAndClearLog 内部会触发 deductOneTimePriority 全局扣减并写回配置
|
||
await saveRecordAndClearLog(cdMap, recordFilePath, correctedLog);
|
||
|
||
// 完成后检测是否超时(一次性阶段同样受总运行限时约束)
|
||
if (checkRuntimeLimit()) break;
|
||
}
|
||
await sleep(1000);
|
||
}
|
||
|
||
/**
|
||
* 处理路径组循环执行
|
||
* 按照用户设置的路径组配置,依次执行各路径组中的路线,支持多种排序模式和CD管理
|
||
*
|
||
* @returns {Promise<void>} 无返回值
|
||
*
|
||
* @依赖全局变量:
|
||
* - settings: 用户设置对象
|
||
* - groupCount: 路径组数量
|
||
* - folderNames: 文件夹名称数组
|
||
* - partyNames: 配队名称数组
|
||
* - recordFilePath: 记录文件路径
|
||
* - operationMode: 操作模式
|
||
* - lastMapName: 上次地图名称
|
||
* - disableArray: 禁用关键词数组
|
||
*
|
||
* @依赖辅助函数:
|
||
* - isTimeRestricted: 判断时间是否受限函数
|
||
* - readFolder: 读取文件夹函数
|
||
* - calculateRouteEfficiency: 计算路线效率函数
|
||
* - basename: 获取文件基本名函数
|
||
* - handleIngredientProcessing: 处理食材加工函数
|
||
* - handleTimeAdjustment: 处理时间调整函数
|
||
* - switchPartyIfNeeded: 按需切换配队函数
|
||
* - fakeLog: 模拟日志函数
|
||
* - executeRoute: 执行路线函数
|
||
* - isArrivedAtEndPoint: 判断是否到达终点函数
|
||
* - calculateRouteCD: 计算路线CD函数
|
||
* - saveRecordAndClearLog: 保存记录并清空日志函数
|
||
*/
|
||
async function processPathGroups() {
|
||
let loopattempts = 0;
|
||
const maxLoopAttempts = 2;
|
||
|
||
while (loopattempts < maxLoopAttempts && !runtimeLimitReached) {
|
||
loopattempts++;
|
||
if (await isTimeRestricted(settings.timeRule, 10)) break;
|
||
let i = 1;
|
||
while (i <= groupCount && !runtimeLimitReached) {
|
||
if (await isTimeRestricted(settings.timeRule, 10)) break;
|
||
const currentCdType = settings[`pathGroup${i}CdType`] || "";
|
||
if (!currentCdType) { i++; continue; }
|
||
|
||
const folder = folderNames[i - 1] || `路径组${i}`;
|
||
const targetFolder = `pathing/${folder} `;
|
||
|
||
log.info(`开始执行路径组${i} 文件夹:${folder}`);
|
||
notification.send(`开始执行路径组${i} 文件夹:${folder}`);
|
||
|
||
/* 运行期同样用 Map<fileName, 原对象> 只改 cdTime */
|
||
const rawRecord = await file.readText(recordFilePath);
|
||
let recordArray = JSON.parse(rawRecord);
|
||
const cdMap = new Map(recordArray.map(it => [it.fileName, it]));
|
||
|
||
const groupFiles = await readFolder(targetFolder, true);
|
||
|
||
if (operationMode === "执行任务(若不存在索引文件则自动创建)") {
|
||
const groupNumber = i;
|
||
await genshin.returnMainUi();
|
||
|
||
try {
|
||
/* ================== 提前计算分均效率(所有模式通用) ================== */
|
||
calculateRouteEfficiency(groupFiles, cdMap, { groupIndex: i });
|
||
switch (settings.sortMode) {
|
||
case "优先最早刷新,将优先执行最早刷新的路线":
|
||
groupFiles.sort((a, b) => {
|
||
const nameA = basename(a.fullPath);
|
||
const nameB = basename(b.fullPath);
|
||
const timeA = cdMap.has(nameA) ? new Date(cdMap.get(nameA).cdTime) : new Date(0);
|
||
const timeB = cdMap.has(nameB) ? new Date(cdMap.get(nameB).cdTime) : new Date(0);
|
||
return timeA - timeB; // 越早刷新越靠前
|
||
});
|
||
break;
|
||
|
||
case "优先最高效率,将优先执行最高分均拾取物的路线":
|
||
// 直接复用提前算好的 _efficiency
|
||
groupFiles.sort((a, b) => (b._efficiency || 0) - (a._efficiency || 0));
|
||
break;
|
||
|
||
default:
|
||
// 保持原有顺序,不做任何排序
|
||
break;
|
||
}
|
||
|
||
// ===================== 按 loopMode 分支 =====================
|
||
if (loopMode === 2) {
|
||
// ----- 每组重试:反复遍历组内路线直到没有任何路线被执行 -----
|
||
let anyExecuted = true;
|
||
while (anyExecuted && !runtimeLimitReached) {
|
||
anyExecuted = false;
|
||
// 检查时间管制
|
||
if (await isTimeRestricted(settings.timeRule, 10)) break;
|
||
|
||
for (const filePath of groupFiles) {
|
||
// 检查时间管制
|
||
if (await isTimeRestricted(settings.timeRule, 10)) {
|
||
break; // 跳出 for,外层 while 会再次检测并 break
|
||
}
|
||
|
||
const fileName = basename(filePath.fullPath).replace('.json', '');
|
||
const fullName = fileName + '.json';
|
||
const targetObj = cdMap.get(fullName);
|
||
const nextCD = targetObj ? new Date(targetObj.cdTime) : new Date(0);
|
||
const maxRunCount = 2; // loopMode=2 上限为2
|
||
const startTime = new Date();
|
||
|
||
if (startTime <= nextCD) {
|
||
continue; // CD未到,跳过
|
||
}
|
||
if ((routeRunCount[fullName] || 0) >= maxRunCount) {
|
||
continue; // 已达执行上限
|
||
}
|
||
|
||
// 禁用关键词检查
|
||
let doSkip = false;
|
||
for (const kw of disableArray) {
|
||
if (filePath.fullPath.includes(kw)) {
|
||
log.info(`路径文件 ${filePath.fullPath} 包含禁用关键词 "${kw}",跳过任务 ${fileName}`);
|
||
doSkip = true;
|
||
break;
|
||
}
|
||
}
|
||
if (doSkip) continue;
|
||
|
||
// ===== 临界效率过滤 =====
|
||
const routeEff = filePath._efficiency ?? 0;
|
||
const threshold = Number(settings[`pathGroup${i}thresholdEfficiency`]) || 0;
|
||
if (routeEff < threshold) {
|
||
log.info(`路线 ${fileName} 分均效率为 ${routeEff.toFixed(2)},低于设定的临界值 ${threshold},跳过`);
|
||
continue;
|
||
}
|
||
|
||
// ----- 执行前处理 -----
|
||
let timeNow = new Date();
|
||
await handleIngredientProcessing(timeNow);
|
||
await handleTimeAdjustment(timeNow);
|
||
await switchPartyIfNeeded(partyNames[groupNumber - 1]);
|
||
await fakeLog(fileName, false, true, 0);
|
||
|
||
/* ========== 历史拾取物前置排序 ========== */
|
||
targetItems = prioritizeHistoricalItems(targetItems, cdMap, fullName);
|
||
/* ======================================= */
|
||
|
||
log.info(`当前进度:执行路线 ${fileName},路径组${i} ${folder} 第 ${groupFiles.indexOf(filePath) + 1}/${groupFiles.length} 个`);
|
||
log.info(`当前路线分均效率为 ${(filePath._efficiency ?? 0).toFixed(2)}`);
|
||
|
||
state.runPickupLog = [];
|
||
// 路径组模式下,传入空的 priorityItemSet
|
||
const routeResult = await executeRoute(filePath.fullPath, fileName, targetObj, startTime, lastMapName, new Set());
|
||
if (!routeResult.success) {
|
||
continue;
|
||
}
|
||
lastMapName = routeResult.lastMapName;
|
||
|
||
try { await sleep(1); }
|
||
catch (error) { log.error(`发生错误: ${error}`); break; }
|
||
|
||
// >>> 仅当 >10s 才记录 history;若同时 pathRes === true 再更新 CD <<<
|
||
const endTime = new Date();
|
||
const timeDiff = endTime.getTime() - startTime.getTime();
|
||
if (timeDiff > 10000) {
|
||
if (routeResult.isSchedule) {
|
||
// Schedule 任务使用路径组配置的 CD 类型,未配置时默认"1次0点刷新"
|
||
const cdType = currentCdType || "1次0点刷新";
|
||
const newTimestamp = calculateRouteCD(cdType, startTime);
|
||
targetObj.cdTime = newTimestamp.toISOString();
|
||
log.info(`schedule任务CD信息已更新,下一次可用时间为 ${newTimestamp.toLocaleString()}`);
|
||
} else {
|
||
// executeRoute 内部已用返回值或坐标校验完成路线成败判定,此处直接复用
|
||
let pathRes = routeResult.pathRes;
|
||
if (pathRes) {
|
||
const newTimestamp = calculateRouteCD(currentCdType, startTime);
|
||
targetObj.cdTime = newTimestamp.toISOString();
|
||
log.info(`本任务cd信息已更新,下一次可用时间为 ${newTimestamp.toLocaleString()}`);
|
||
}
|
||
}
|
||
|
||
/* ---------- 3. 用声明材料数量修正拾取日志后统一写文件 ---------- */
|
||
const correctedLog = correctPickupLogByDeclaration(routeResult.runPickupLog, filePath.fullPath);
|
||
await saveRecordAndClearLog(cdMap, recordFilePath, correctedLog);
|
||
routeRunCount[fullName] = (routeRunCount[fullName] || 0) + 1;
|
||
|
||
// 标记本次有执行,继续 while 循环
|
||
anyExecuted = true;
|
||
|
||
// 完成任意路线后检查总运行限时,超时则结束脚本
|
||
if (checkRuntimeLimit()) break;
|
||
}
|
||
} // end for
|
||
|
||
// 如果因为时间管制跳出 for,则 while 也会检测到并退出
|
||
if (await isTimeRestricted(settings.timeRule, 10)) break;
|
||
} // end while
|
||
|
||
// 组内重试结束(无论是否全部达标,只要无更多可执行路线就退出)
|
||
log.info(`路径组${groupNumber} 执行完毕`);
|
||
|
||
} else {
|
||
for (const filePath of groupFiles) {
|
||
// 检查时间管制
|
||
if (await isTimeRestricted(settings.timeRule, 10)) break;
|
||
|
||
const fileName = basename(filePath.fullPath).replace('.json', '');
|
||
const fullName = fileName + '.json';
|
||
const targetObj = cdMap.get(fullName);
|
||
const nextCD = targetObj ? new Date(targetObj.cdTime) : new Date(0);
|
||
const maxRunCount = loopMode; // 1 或 3(但3通过全局跳转实现多次,这里单次上限仍为3,不影响)
|
||
const startTime = new Date();
|
||
|
||
if (startTime <= nextCD) {
|
||
if (loopMode !== 3) {
|
||
log.info(`当前任务 ${fileName} 未刷新,跳过任务`);
|
||
}
|
||
continue; // 跳过,不写回
|
||
}
|
||
if ((routeRunCount[fullName] || 0) >= maxRunCount) {
|
||
log.info(`当前任务 ${fileName} 已达执行上限,跳过`);
|
||
continue;
|
||
}
|
||
|
||
let doSkip = false;
|
||
for (const kw of disableArray) {
|
||
if (filePath.fullPath.includes(kw)) {
|
||
log.info(`路径文件 ${filePath.fullPath} 包含禁用关键词 "${kw}",跳过任务 ${fileName}`);
|
||
doSkip = true; break;
|
||
}
|
||
}
|
||
if (doSkip) continue;
|
||
|
||
// ===== 临界效率过滤 =====
|
||
const routeEff = filePath._efficiency ?? 0; // 提前算好的分均效率
|
||
const threshold = Number(settings[`pathGroup${i}thresholdEfficiency`]) || 0;
|
||
if (routeEff < threshold) {
|
||
log.info(`路线 ${fileName} 分均效率为 ${routeEff.toFixed(2)},低于设定的临界值 ${threshold},跳过`);
|
||
continue;
|
||
}
|
||
|
||
let timeNow = new Date();
|
||
await handleIngredientProcessing(timeNow);
|
||
|
||
await handleTimeAdjustment(timeNow);
|
||
|
||
await switchPartyIfNeeded(partyNames[groupNumber - 1]);
|
||
|
||
await fakeLog(fileName, false, true, 0);
|
||
|
||
/* ========== 历史拾取物前置排序 ========== */
|
||
targetItems = prioritizeHistoricalItems(targetItems, cdMap, fullName);
|
||
/* ======================================= */
|
||
|
||
log.info(`当前进度:执行路线 ${fileName},路径组${i} ${folder} 第 ${groupFiles.indexOf(filePath) + 1}/${groupFiles.length} 个`);
|
||
log.info(`当前路线分均效率为 ${(filePath._efficiency ?? 0).toFixed(2)}`);
|
||
|
||
state.runPickupLog = []; // 新路线开始前清空
|
||
// 路径组模式下,传入空的 priorityItemSet
|
||
const routeResult = await executeRoute(filePath.fullPath, fileName, targetObj, startTime, lastMapName, new Set());
|
||
if (!routeResult.success) {
|
||
continue;
|
||
}
|
||
lastMapName = routeResult.lastMapName;
|
||
|
||
try { await sleep(1); }
|
||
catch (error) { log.error(`发生错误: ${error}`); break; }
|
||
|
||
// >>> 仅当 >10s 才记录 history;若同时 pathRes === true 再更新 CD <<<
|
||
const endTime = new Date();
|
||
const timeDiff = endTime.getTime() - startTime.getTime();
|
||
if (timeDiff > 10000) {
|
||
/* ---------- 2. 仅当 pathRes === true 才计算并更新 CD ---------- */
|
||
if (routeResult.isSchedule) {
|
||
// Schedule 任务使用路径组配置的 CD 类型,未配置时默认"1次0点刷新"
|
||
const cdType = currentCdType || "1次0点刷新";
|
||
const newTimestamp = calculateRouteCD(cdType, startTime);
|
||
targetObj.cdTime = newTimestamp.toISOString();
|
||
log.info(`schedule任务CD信息已更新,下一次可用时间为 ${newTimestamp.toLocaleString()}`);
|
||
} else {
|
||
let pathRes = routeResult.pathRes;
|
||
if (pathRes) {
|
||
const newTimestamp = calculateRouteCD(currentCdType, startTime);
|
||
targetObj.cdTime = newTimestamp.toISOString();
|
||
log.info(`本任务cd信息已更新,下一次可用时间为 ${newTimestamp.toLocaleString()}`);
|
||
}
|
||
}
|
||
|
||
/* ---------- 3. 用声明材料数量修正拾取日志后统一写文件 ---------- */
|
||
const correctedLog = correctPickupLogByDeclaration(routeResult.runPickupLog, filePath.fullPath);
|
||
await saveRecordAndClearLog(cdMap, recordFilePath, correctedLog);
|
||
routeRunCount[fullName] = (routeRunCount[fullName] || 0) + 1;
|
||
|
||
// 完成任意路线后检查总运行限时,超时则结束脚本
|
||
if (checkRuntimeLimit()) { break; }
|
||
|
||
// ==== 全局循环(loopMode=3)跳回第一个组 ====
|
||
if (loopMode === 3) {
|
||
i = 0;
|
||
break; // 跳出 for,外层 while(i<=groupCount) 因 i=0 重新开始
|
||
} else {
|
||
log.info(`路径组${groupNumber} 执行完毕`);
|
||
}
|
||
}
|
||
} // end for
|
||
} // end else (loopMode !== 2)
|
||
|
||
} catch (error) {
|
||
log.error(`读取路径组文件时出错: ${error}`);
|
||
}
|
||
}
|
||
i++;
|
||
}
|
||
await sleep(1000);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 加载并处理子JS脚本,返回处理后的代码(不执行)
|
||
* @param {string} jsFilePath - 子脚本所在文件夹路径
|
||
* @returns {Object} { code: 处理后的代码字符串, basePath: 标准化后的基础路径, scriptName: 脚本名称 }
|
||
*/
|
||
function loadSubJS(jsFilePath) {
|
||
// ========== 1. 基础配置 ==========
|
||
const normalizedBasePath = jsFilePath
|
||
.replace(/[\\/]+/g, '/')
|
||
.replace(/\/+$/, '') + '/';
|
||
|
||
try {
|
||
// ========== 1.1 读取 manifest.json ==========
|
||
const manifestPath = `${normalizedBasePath}manifest.json`;
|
||
const manifestContent = file.readTextSync(manifestPath);
|
||
const manifest = JSON.parse(manifestContent);
|
||
|
||
// 获取入口文件名
|
||
const mainFileName = manifest.main || 'main.js';
|
||
const filePath = `${normalizedBasePath}${mainFileName}`;
|
||
|
||
// ========== 2. 读取子JS ==========
|
||
let rawCode = file.readTextSync(filePath);
|
||
|
||
// ========== 3. 替换API名称 ==========
|
||
const apiReplaceMap = {
|
||
'file.ReadPathSync': '_file_ReadPathSync',
|
||
'file.readTextSync': '_file_readTextSync',
|
||
'file.readText': '_file_readText',
|
||
'file.ReadImageMatSync': '_file_ReadImageMatSync',
|
||
'file.writeTextSync': '_file_writeTextSync',
|
||
'file.writeText': '_file_writeText',
|
||
'file.WriteImageSync': '_file_WriteImageSync',
|
||
'file.IsFolder': '_file_IsFolder',
|
||
'pathingScript.runFile': '_pathingScript_runFile',
|
||
'keyMouseScript.runFile': '_keyMouseScript_runFile'
|
||
};
|
||
Object.keys(apiReplaceMap).sort((a, b) => b.length - a.length).forEach(originalApi => {
|
||
const customApi = apiReplaceMap[originalApi];
|
||
// 构建大小写不敏感的正则表达式
|
||
// 将每个字符转换为可选大小写的形式,例如 "file" 变为 "[fF][iI][lL][eE]"
|
||
const caseInsensitiveApi = originalApi.split('').map(char => {
|
||
if (char.match(/[a-zA-Z]/)) {
|
||
return `[${char.toLowerCase()}${char.toUpperCase()}]`;
|
||
}
|
||
return char === '.' ? '\\.' : char;
|
||
}).join('');
|
||
const regex = new RegExp(`\\b(${caseInsensitiveApi})\\b`, 'g');
|
||
rawCode = rawCode.replace(regex, customApi);
|
||
});
|
||
|
||
// ========== 4. 处理脚本执行模式 ==========
|
||
// 将子脚本中的唯一外层 async IIFE 改为命名函数,并在最后 await 它
|
||
const trimmedCode = rawCode.trim();
|
||
const asyncIifeCount = (trimmedCode.match(/\(async function\s*\(/g) || []).length;
|
||
|
||
if (asyncIifeCount === 1) {
|
||
// 找到唯一的 async IIFE
|
||
const asyncIifeStart = trimmedCode.indexOf('(async function');
|
||
|
||
// 找到这个 IIFE 的结束位置(需要匹配括号)
|
||
let braceCount = 0;
|
||
let foundFirstBrace = false;
|
||
let iifeEnd = -1;
|
||
for (let i = asyncIifeStart; i < trimmedCode.length; i++) {
|
||
if (trimmedCode[i] === '{') {
|
||
braceCount++;
|
||
foundFirstBrace = true;
|
||
} else if (trimmedCode[i] === '}') {
|
||
braceCount--;
|
||
}
|
||
// 当找到配对的 } 后,再往后找 })();
|
||
if (foundFirstBrace && braceCount === 0) {
|
||
const nextChars = trimmedCode.substring(i, i + 5);
|
||
if (nextChars === '})();') {
|
||
iifeEnd = i + 5;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (asyncIifeStart >= 0 && iifeEnd > asyncIifeStart) {
|
||
const beforeIife = trimmedCode.substring(0, asyncIifeStart).trim();
|
||
const iifeCode = trimmedCode.substring(asyncIifeStart, iifeEnd);
|
||
const firstBrace = iifeCode.indexOf('{');
|
||
const lastBrace = iifeCode.lastIndexOf('}');
|
||
const iifeBody = iifeCode.substring(firstBrace + 1, lastBrace).trim();
|
||
const afterIife = trimmedCode.substring(iifeEnd).trim();
|
||
|
||
rawCode = `return (async function() {\n${beforeIife}\n${afterIife}\nasync function __subJsMain__() {\n${iifeBody}\n}\nawait __subJsMain__();\n})();`;
|
||
} else {
|
||
rawCode = `return (async function() {\n${rawCode}\n})();`;
|
||
}
|
||
} else {
|
||
// 没有或有多个 async IIFE,直接包裹整个脚本
|
||
rawCode = `return (async function() {\n${rawCode}\n})();`;
|
||
}
|
||
|
||
// ========== 5. 构建自定义API代码 ==========
|
||
const customApiLines = [
|
||
'"use strict";',
|
||
`const basePath = ${JSON.stringify(normalizedBasePath)};`,
|
||
'',
|
||
'function _joinPath(pathArg) {',
|
||
' if (typeof pathArg !== "string") return pathArg;',
|
||
' // 确保不会重复添加 basePath(大小写不敏感)',
|
||
' if (pathArg.toLowerCase().startsWith(basePath.toLowerCase())) return pathArg;',
|
||
' // 确保路径格式正确',
|
||
' const joined = basePath + pathArg.replace(/^[\\/]?/, "");',
|
||
' return joined.replace(/[\\/]+/g, "/");',
|
||
'}',
|
||
'',
|
||
'function _file_ReadPathSync(...args) {',
|
||
' try {',
|
||
' // 对输入路径参数添加 basePath 前缀',
|
||
' const processedArgs = args.map(arg => _joinPath(arg));',
|
||
' const results = file.ReadPathSync(...processedArgs);',
|
||
' const newResults = [];',
|
||
' if (results) {',
|
||
' for (const res of results) {',
|
||
' // 按正反斜杠划分路径,去空,去除base的部分,再重新构建',
|
||
' const pathParts = res.split(/[\\\\/]/).filter(part => part !== "");',
|
||
' const baseParts = basePath.split(/[\\\\/]/).filter(part => part !== "");',
|
||
' let processedParts = [];',
|
||
' let inBasePath = true;',
|
||
' ',
|
||
' for (const part of pathParts) {',
|
||
' if (inBasePath && baseParts.length > 0) {',
|
||
' if (part.toLowerCase() === baseParts[0].toLowerCase()) {',
|
||
' baseParts.shift();',
|
||
' } else {',
|
||
' inBasePath = false;',
|
||
' processedParts.push(part);',
|
||
' }',
|
||
' } else {',
|
||
' processedParts.push(part);',
|
||
' }',
|
||
' }',
|
||
' ',
|
||
' const processedRes = processedParts.join("\\\\");',
|
||
' newResults.push(processedRes);',
|
||
' }',
|
||
' }',
|
||
' return newResults;',
|
||
' } catch (e) {',
|
||
' log.error(`_file_ReadPathSync 执行失败:${e.message}`);',
|
||
' return [];',
|
||
' }',
|
||
'}',
|
||
'',
|
||
'async function _file_readText(...args) { return await file.readText(...args.map(arg => _joinPath(arg))); }',
|
||
'function _file_readTextSync(...args) { return file.readTextSync(...args.map(arg => _joinPath(arg))); }',
|
||
'function _file_WriteImageSync(...args) { return file.WriteImageSync(...args.map(arg => _joinPath(arg))); }',
|
||
'function _file_IsFolder(...args) { return file.IsFolder(...args.map(arg => _joinPath(arg))); }',
|
||
'function _pathingScript_runFile(...args) { return pathingScript.runFile(...args.map(arg => _joinPath(arg))); }',
|
||
'function _keyMouseScript_runFile(...args) { return keyMouseScript.runFile(...args.map(arg => _joinPath(arg))); }',
|
||
'',
|
||
'function _file_ReadImageMatSync(...args) {',
|
||
' try {',
|
||
' const processedArgs = args.map(arg => {',
|
||
' const j = _joinPath(arg);',
|
||
' return typeof j === "string" && !j.match(/\.(png|jpg|jpeg|bmp)$/i) ? j + ".png" : j;',
|
||
' });',
|
||
' const result = file.ReadImageMatSync(...processedArgs);',
|
||
' return result;',
|
||
' } catch (e) {',
|
||
' log.error(`_file_ReadImageMatSync 执行失败:${e.message}`);',
|
||
' throw e;',
|
||
' }',
|
||
'}',
|
||
'',
|
||
'function _file_writeText(filePath, content, append) { file.writeText(_joinPath(filePath), content, append); return true; }',
|
||
'function _file_writeTextSync(filePath, content, append = false) { file.writeTextSync(_joinPath(filePath), content, append); return true; }',
|
||
''
|
||
];
|
||
|
||
// ========== 6. 组合代码 ==========
|
||
let fullCode = [...customApiLines, ...rawCode.split('\n')].join('\n');
|
||
|
||
// ========== 7. 返回处理后的代码、路径信息和原始路径 ==========
|
||
return {
|
||
code: fullCode,
|
||
basePath: normalizedBasePath,
|
||
jsFilePath: jsFilePath
|
||
};
|
||
|
||
} catch (e) {
|
||
log.error(`loadSubJS执行失败:${e.message}\n错误堆栈:${e.stack}`);
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 在正确上下文中执行处理后的子脚本代码
|
||
* 使用 new Function 创建独立作用域,避免全局变量污染
|
||
* @param {Object} subJS - loadSubJS 返回的对象 { code, basePath, jsFilePath }
|
||
* @param {Object} settings - 传入的配置对象
|
||
* @returns {Promise<boolean>} 执行结果,true=成功,false=失败
|
||
*/
|
||
async function executeSubJS(subJS, settings) {
|
||
const logName = subJS.jsFilePath.split(/[\\/]/).filter(p => p).pop() || subJS.jsFilePath;
|
||
|
||
try {
|
||
log.info(`子js:${logName} 开始执行`);
|
||
|
||
// JavaScript 内置对象列表(需要排除)
|
||
const builtInSet = new Set([
|
||
'Object', 'Function', 'Array', 'String', 'Boolean', 'Number', 'Symbol', 'BigInt',
|
||
'Math', 'Date', 'RegExp', 'Error', 'JSON', 'Map', 'Set', 'WeakMap', 'WeakSet',
|
||
'Promise', 'Proxy', 'Reflect', 'ArrayBuffer', 'DataView', 'Int8Array', 'Uint8Array',
|
||
'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array',
|
||
'BigInt64Array', 'BigUint64Array', 'globalThis', 'console', 'setTimeout', 'setInterval',
|
||
'clearTimeout', 'clearInterval', 'parseInt', 'parseFloat', 'isNaN', 'isFinite',
|
||
'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent', 'eval',
|
||
'Infinity', 'NaN', 'undefined', 'settings'
|
||
]);
|
||
|
||
// 自动获取所有全局 API(排除内置对象,同时排除 settings 避免重复)
|
||
const apis = Object.keys(globalThis).filter(key => !builtInSet.has(key));
|
||
const values = apis.map(api => globalThis[api]);
|
||
|
||
// 创建隔离作用域的执行函数,将 settings 作为第一个参数注入
|
||
const execFunc = new Function('settings', ...apis, subJS.code);
|
||
|
||
const result = execFunc(settings, ...values);
|
||
|
||
// 如果返回的是 Promise,等待它完成
|
||
if (result && typeof result.then === 'function') {
|
||
await result;
|
||
}
|
||
|
||
log.info(`子js:${logName} 执行结束`);
|
||
return true;
|
||
} catch (e) {
|
||
log.error(`子js:${logName} 执行异常: ${e.message}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 执行 schedule 文件
|
||
* @param {string} schedulePath - schedule JSON 文件路径
|
||
* @returns {Promise<boolean>} 执行结果,true=全部成功,false=有任务失败
|
||
*/
|
||
async function executeSchedule(schedulePath) {
|
||
try {
|
||
log.info(`===== 开始执行 Schedule: ${schedulePath} =====`);
|
||
|
||
// 读取并解析 schedule 文件
|
||
let scheduleContent;
|
||
try {
|
||
scheduleContent = file.readTextSync(schedulePath);
|
||
} catch (e) {
|
||
log.error(`读取 schedule 文件失败: ${schedulePath}`);
|
||
log.error(`错误信息: ${e.message}`);
|
||
return false;
|
||
}
|
||
|
||
let scheduleData;
|
||
try {
|
||
scheduleData = JSON.parse(scheduleContent);
|
||
} catch (e) {
|
||
log.error(`解析 schedule 文件失败: ${schedulePath}`);
|
||
log.error(`错误信息: ${e.message}`);
|
||
return false;
|
||
}
|
||
|
||
const { schedule: actions, tasks } = scheduleData;
|
||
|
||
// 防御性检查
|
||
if (!actions || !Array.isArray(actions)) {
|
||
log.error('schedule 文件缺少 schedule 数组或格式不正确');
|
||
return false;
|
||
}
|
||
if (!tasks || !Array.isArray(tasks)) {
|
||
log.error('schedule 文件缺少 tasks 数组或格式不正确');
|
||
return false;
|
||
}
|
||
|
||
// 预加载所有任务
|
||
log.info(`预加载 ${tasks.length} 个任务...`);
|
||
const taskMap = new Map();
|
||
for (const task of tasks) {
|
||
// 检查任务配置完整性
|
||
if (!task.name || !task.filePath) {
|
||
log.error(`任务配置不完整,缺少 name 或 filePath: ${JSON.stringify(task)}`);
|
||
return false;
|
||
}
|
||
|
||
// 根据 type 字段判断任务类型(大小写不敏感)
|
||
const taskTypeRaw = (task.type || 'js').toLowerCase();
|
||
let taskType;
|
||
if (taskTypeRaw === 'js') {
|
||
taskType = 'subJS';
|
||
} else if (taskTypeRaw === 'autopathing') {
|
||
taskType = 'pathing';
|
||
} else if (taskTypeRaw === 'keymousescript') {
|
||
taskType = 'keyMouse';
|
||
} else {
|
||
log.error(`未知的任务类型: ${task.type}`);
|
||
return false;
|
||
}
|
||
|
||
const filePath = task.filePath;
|
||
log.info(`加载任务: ${task.name} (${filePath}, 类型: ${taskType})`);
|
||
|
||
let taskInfo;
|
||
if (taskType === 'subJS') {
|
||
taskInfo = loadSubJS(filePath);
|
||
} else {
|
||
taskInfo = { filePath: filePath, type: taskType };
|
||
}
|
||
|
||
taskMap.set(task.name, {
|
||
...task,
|
||
taskType: taskType,
|
||
taskInfo: taskInfo
|
||
});
|
||
}
|
||
log.info('所有任务加载完成');
|
||
|
||
// 存储正在运行的异步任务
|
||
const runningTasks = new Map();
|
||
|
||
// 按顺序执行 schedule 中的每个动作
|
||
for (const action of actions) {
|
||
// 检测任务终止标志
|
||
try { await sleep(1); } catch (e) {
|
||
log.info('检测到任务终止信号,停止执行');
|
||
return false;
|
||
}
|
||
|
||
const { action: actionType, task: taskName, count = 1 } = action;
|
||
|
||
if (actionType === 'start') {
|
||
// 查找任务配置
|
||
const taskConfig = taskMap.get(taskName);
|
||
if (!taskConfig) {
|
||
log.error(`未找到任务: ${taskName}`);
|
||
return false;
|
||
}
|
||
|
||
const { taskType, taskInfo, async: isAsync, settings } = taskConfig;
|
||
|
||
// 检查异步任务是否已在运行
|
||
if (isAsync && runningTasks.has(taskName)) {
|
||
log.warn(`任务 ${taskName} 正在执行中,不要重复启动`);
|
||
continue;
|
||
}
|
||
|
||
// 执行指定次数
|
||
for (let i = 0; i < count; i++) {
|
||
log.info(`执行任务: ${taskName} (第 ${i + 1}/${count} 次)`);
|
||
|
||
let executionPromise;
|
||
|
||
if (taskType === 'subJS') {
|
||
executionPromise = executeSubJS(taskInfo, settings);
|
||
} else if (taskType === 'pathing') {
|
||
executionPromise = pathingScript.runFile(taskInfo.filePath);
|
||
} else if (taskType === 'keyMouse') {
|
||
executionPromise = keyMouseScript.runFile(taskInfo.filePath);
|
||
} else {
|
||
log.error(`未知的任务类型: ${taskType}`);
|
||
return false;
|
||
}
|
||
|
||
if (isAsync) {
|
||
// 异步执行,不等待完成
|
||
runningTasks.set(taskName, executionPromise);
|
||
log.info(`任务 ${taskName} 已异步启动`);
|
||
} else {
|
||
// 同步执行,等待完成
|
||
const result = await executionPromise;
|
||
if (taskType === 'subJS' && !result) {
|
||
log.error(`任务 ${taskName} 执行失败`);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
} else if (actionType === 'wait') {
|
||
// 等待指定任务完成
|
||
if (runningTasks.has(taskName)) {
|
||
log.info(`等待任务完成: ${taskName}`);
|
||
const result = await runningTasks.get(taskName);
|
||
runningTasks.delete(taskName);
|
||
const taskConfig = taskMap.get(taskName);
|
||
if (taskConfig && taskConfig.taskType === 'subJS' && !result) {
|
||
log.error(`任务 ${taskName} 执行失败`);
|
||
return false;
|
||
}
|
||
log.info(`任务 ${taskName} 已完成`);
|
||
} else {
|
||
log.warn(`任务 ${taskName} 未在运行中,无需等待`);
|
||
}
|
||
} else {
|
||
log.error(`未知的 action 类型: ${actionType}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 等待所有剩余的异步任务完成
|
||
if (runningTasks.size > 0) {
|
||
log.info(`等待 ${runningTasks.size} 个异步任务完成...`);
|
||
const taskEntries = Array.from(runningTasks.entries());
|
||
const promises = taskEntries.map(([_, promise]) => promise);
|
||
const results = await Promise.all(promises);
|
||
for (let i = 0; i < taskEntries.length; i++) {
|
||
const [name, _] = taskEntries[i];
|
||
if (!results[i]) {
|
||
log.error(`异步任务 ${name} 执行失败`);
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
log.info(`===== Schedule 执行完成: ${schedulePath} =====`);
|
||
return true;
|
||
} catch (e) {
|
||
log.error(`执行 Schedule 失败: ${e.message}`);
|
||
log.error(`错误堆栈: ${e.stack}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从路线 description 中解析材料数量和时间
|
||
* 支持两种格式:
|
||
* 1. 【用时60秒,甜甜花*12,枫木*5】
|
||
* 2. 2个薄荷;3个日落果;11个蘑菇;(老格式,无时间)
|
||
* @param {string} description 路线 info.description
|
||
* @returns {{ declaredMaterials: Object|null, declaredDuration: number|null }}
|
||
*/
|
||
function parseDeclaration(description) {
|
||
try {
|
||
if (!description) return { declaredMaterials: null, declaredDuration: null };
|
||
|
||
let declaredDuration = null;
|
||
const declaredMaterials = {};
|
||
|
||
// 格式1: 【用时60秒,甜甜花*12】
|
||
const m = description.match(/【([^】]+)】/);
|
||
if (m) {
|
||
m[1].split(',').forEach(part => {
|
||
part = part.trim();
|
||
if (!part) return;
|
||
const tm = part.match(/^用时(\d+)秒$/);
|
||
if (tm) { declaredDuration = parseInt(tm[1]); return; }
|
||
const im = part.match(/^(.+)\*(\d+)$/);
|
||
if (im) { declaredMaterials[im[1].trim()] = parseInt(im[2]); }
|
||
});
|
||
} else {
|
||
// 格式2: 2个薄荷;3个日落果;(老格式,无时间信息)
|
||
const oldRe = /(\d+)个([^;\s]+)/g;
|
||
let match;
|
||
while ((match = oldRe.exec(description)) !== null) {
|
||
declaredMaterials[match[2].trim()] = parseInt(match[1]);
|
||
}
|
||
}
|
||
|
||
return { declaredMaterials: Object.keys(declaredMaterials).length > 0 ? declaredMaterials : null, declaredDuration };
|
||
} catch (e) {
|
||
return { declaredMaterials: null, declaredDuration: null };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 用路线声明材料数量修正拾取日志
|
||
* 声明中涉及的材料,其出现次数替换为声明值;未涉及的材料保留实际检测值
|
||
* 用于保证每日记录和优先扣减使用完整的产量,而非模板匹配漏检后的不完整数据
|
||
*
|
||
* @param {string[]} pickupLog - 原始拾取日志(模板匹配实际命中的结果)
|
||
* @param {string} routeFilePath - 路线 json 文件完整路径
|
||
* @returns {string[]} 修正后的拾取日志(声明材料按声明值,其余保留原始值)
|
||
*/
|
||
function correctPickupLogByDeclaration(pickupLog, routeFilePath) {
|
||
try {
|
||
const raw = file.readTextSync(routeFilePath);
|
||
const json = JSON.parse(raw);
|
||
const dec = parseDeclaration(json.info?.description || '');
|
||
if (!dec.declaredMaterials) return pickupLog;
|
||
|
||
const declaredSet = new Set(Object.keys(dec.declaredMaterials));
|
||
// 未在声明中涉及的材料,保留原始拾取值
|
||
const nonDeclared = pickupLog.filter(name => !declaredSet.has(name));
|
||
|
||
// 声明材料用声明值
|
||
const corrected = [...nonDeclared];
|
||
for (const [name, count] of Object.entries(dec.declaredMaterials)) {
|
||
for (let i = 0; i < count; i++) {
|
||
corrected.push(name);
|
||
}
|
||
}
|
||
return corrected;
|
||
} catch (e) {
|
||
return pickupLog; // 任何异常都回退到原始日志
|
||
}
|
||
} |