bettergi-scripts-list/repo/js/采集cd管理/main.js
汐 0c970be672
重构锄地与狗粮脚本并完善配置文档 (#3603)
* 锄地添加新路线

* 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 内部锚点链接;
  - 保留“琪零”和“芽一”等原有名称。
2026-09-02 21:26:12 +08:00

3822 lines
No EOL
151 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// 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; // 任何异常都回退到原始日志
}
}