bettergi-scripts-list/repo/js/AutoHoeingOneDragon/main.js
this-Fish 43a3914627
chore: 锄地一条龙 補充更新版本號至 2.13.0 (#3610)
* Update monsterInfo.json

* Update version to 2.13.0 in manifest.json

* Enhance black Furina switching logic with map check

Added logic to check current map and teleport accordingly before running the black Furina script.

* Fix map_name check to prevent errors

Add null check for map_name before checking its contents.

* Add files via upload
2026-09-03 16:26:19 +08:00

2787 lines
No EOL
115 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.

//自定义配置变量预声明
let accountName;
let pickup_Mode;
let dumpers;
let findFInterval;
let checkDelay;
let rollingDelay;
let pickupDelay;
let timeMove;
let timeMoveUp;
let timeMoveDown;
let priorityTags;
let excludeTags;
let operationMode;
let efficiencyIndex;
let targetEliteNum;
let targetMonsterNum;
let curiosityFactor;
let ignoreRate;
let partyName;
let validateTeamMembers;
let groupSettings;
let groupTags;
// 全局状态变量
let coordCache = { X: 0, Y: 0 }; // 坐标缓存,供 ① ② ④ 复用
let needRefreshCoord = true; // 强制刷新坐标缓存
let coordCacheMapName;
let coordCacheMatchMethod;
let targetItems;
let shouldSwitchFurina = false;
let furinaDetectedMap = "";
let lastRollTime = new Date();
let blacklist = [];
let blacklistSet = new Set();
let state;
let pathings;
let localeTimeSupported;
let lastBuffTime = 0;
let currentFood = "";
let monsterInfoObject;
// 基础识别区域(基于 1920×1080 分辨率)
const SCREEN_WIDTH = 1920;
const SCREEN_HEIGHT = 1080;
const SCREEN_REGIONS = Object.freeze({
itemFull: [0, 0, SCREEN_WIDTH, SCREEN_HEIGHT],
frozen: [1379, 574, 84, 39],
revival: [755, 915, 362, 122],
cooking: [1547, 965, 268, 94],
whiteFurina: [1634, 967, 116, 103],
flying: [1657, 945, 101, 84],
dialogue: [1102, 335, 34, 400],
mainUi: [0, 0, 150, 150],
scroll: [1017, 496, 512, 85],
crystalFly: [0, 0, 450, 540],
revivalUi: [450, 200, 1000, 250]
});
// ① 启动与配置参数
const DEFAULT_ELITE_TARGET_NUM = 400;
const DEFAULT_MONSTER_TARGET_NUM = 2000;
const WARNING_DISPLAY_DELAY_MS = 5000;
const ACCOUNT_WARNING_INTERVAL_MS = 500;
// ② 路线预处理与组合选择参数
const DEFAULT_ROUTE_TIME_SECONDS = 60;
const ELITE_TARGET_RESERVE = 5;
const MONSTER_TARGET_RESERVE = 25;
const ELITE_SELECTION_MARGIN = 2;
const MONSTER_SELECTION_MARGIN = 5;
const MAX_ROUTE_SELECTION_ITERATIONS = 100;
const ELITE_TOLERANCE_DIVISOR = 20;
const MONSTER_TOLERANCE_DIVISOR = 4;
// ④ 路线执行、拾取与药品参数
const BUFF_COOLDOWN_MS = 300 * 1000;
const INVENTORY_ACTION_DELAY_MS = 300;
const PICKUP_CONFIRM_POLL_MS = 16;
const PICKUP_EMPTY_SCROLL_INTERVAL_MS = 200;
const PICKUP_DUPLICATE_Y_THRESHOLD = 20;
const PICKUP_DUPLICATE_DELAY_MS = 160;
const PICKUP_REGION = { x: 1219, yOffset: -15, width: 154, height: 30 };
const BACKPACK_OCR_REGION = { x: 560, y: 450, width: 800, height: 170 };
const ITEM_OCR_REGION = { x: 1210, yOffset: -30, width: 250, height: 60 };
const HEALTH_BAR_SAMPLE_REGION = { x: 815, y: 1005, width: 8, height: 8 };
const ITEM_OCR_MATCH_THRESHOLD = 0.75;
const HEALTH_BAR_GREEN_THRESHOLD = 14;
const HEALTH_BAR_YELLOW_THRESHOLD = 30;
const MEDICINE_CHECK_INTERVAL_MS = 25;
const MEDICINE_COUNT_WINDOW_MS = 60 * 1000;
const MEDICINE_CONFIRM_THRESHOLD = 3;
const MEDICINE_CONFIRM_WAIT_CYCLES = 10;
const ERROR_CHECK_INTERVAL_LOOPS = 5;
const COOKING_CHECK_INTERVAL_LOOPS = 100;
const ERROR_LOOP_DELAY_MS = 50;
const FREEZE_ESCAPE_PRESS_COUNT = 3;
const FREEZE_ESCAPE_INTERVAL_MS = 30;
const RECOVERY_DELAY_MS = 500;
const BACKPACK_CHECK_INTERVAL_CYCLES = 30;
const FAST_MATCH_TIMEOUT_MS = 2;
const FAST_MATCH_INTERVAL_MS = 3;
const MAIN_UI_CHECK_TIMEOUT_MS = 10;
// ④ 晶蝶与泥头车参数
const CRYSTALFLY_DISTANCE_ADVANTAGE = 500;
const CRYSTALFLY_MAX_CATCHER_DISTANCE = 2200;
const CRYSTALFLY_UI_DELAY_MS = 200;
const CRYSTALFLY_FIND_TIMEOUT_MS = 500;
const DUMPER_COOLDOWN_MS = 10 * 1000;
const DUMPER_MIN_TRIGGER_DISTANCE = 5;
const DUMPER_MAX_TRIGGER_DISTANCE = 30;
const DUMPER_POLL_CYCLES = 10;
const DUMPER_POLL_INTERVAL_MS = 50;
const REVIVAL_UI_CHECK_ATTEMPTS = 10;
const REVIVAL_UI_CHECK_INTERVAL_MS = 200;
const DUMPER_KEY_DELAY_MS = 400;
// ⑤ 路线校验与历史记录参数
const ROUTE_COORD_SAME_THRESHOLD = 5;
const ROUTE_COORD_END_THRESHOLD = 30;
const ROUTE_COMPLETION_UI_TIMEOUT_MS = 2000;
const RECONNECT_CHECK_TIMEOUT_MS = 300;
const RUN_RECORD_LIMIT = 7;
const PICKUP_HISTORY_LIMIT = 20;
// ⑥ 截图缓存与识别对象预加载
const GAME_REGION_CACHE_SIZE = 5; // 游戏区域截图缓存大小上限
const gameRegionManager = {
cache: [], // 缓存队列,保存近GAME_REGION_CACHE_SIZE张截图
lastCapture: new Date(),
isDisposing: false,
isCapturing: false
};
const itemFullRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/itemFull.png"), ...SCREEN_REGIONS.itemFull);
const frozenRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/解除冰冻.png"), ...SCREEN_REGIONS.frozen);
const revivalRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/复苏.png"), ...SCREEN_REGIONS.revival);
revivalRo.Threshold = 0.95;
revivalRo.InitTemplate();
const cookingRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/烹饪界面.png"), ...SCREEN_REGIONS.cooking);
cookingRo.Threshold = 0.95;
cookingRo.InitTemplate();
const whiteFurinaRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/白芙图标.png"), ...SCREEN_REGIONS.whiteFurina);
whiteFurinaRo.Threshold = 0.97;
whiteFurinaRo.InitTemplate();
const flyingRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/飞行状态.png"), ...SCREEN_REGIONS.flying);
flyingRo.Threshold = 0.97;
flyingRo.InitTemplate();
const fIconRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync('assets/F_Dialogue.png'), ...SCREEN_REGIONS.dialogue);
fIconRo.Threshold = 0.95;
fIconRo.InitTemplate();
const mainUIRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/MainUI.png"), ...SCREEN_REGIONS.mainUi);
const scrollRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/拾取滚轮.png"), ...SCREEN_REGIONS.scroll);
const imageMat = file.ReadImageMatSync("assets/三色血条.png");
const img = new ImageRegion(imageMat, 0, 0);
const revivalMedicineRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/复活药.png"));
(async function () {
//通用预处理
await loadConfig();
let switchPartyTask;
if (["运行锄地路线", "启用仅指定怪物模式"].includes(operationMode)) {
switchPartyTask = switchPartyIfNeeded(partyName);
}
if (settings.disableAsync && switchPartyTask) {
const switchSuccess = await switchPartyTask;
if (!switchSuccess) {
log.error("队伍切换失败,脚本终止");
return;
}
}
targetItems = await loadTargetItems();
localeTimeSupported = await checkLocaleTimeSupport();
dispatcher.AddTrigger(new RealtimeTimer("AutoSkip"));
await loadBlacklist(true);
await rotateWarnIfAccountEmpty();
if (operationMode === "启用仅指定怪物模式") {
await filterPathingsByTargetMonsters();
await updateRecords(pathings, accountName);
if (!settings.disableAsync) {
const switchSuccess = await switchPartyTask;
if (!switchSuccess) {
log.error("队伍切换失败,脚本终止");
return;
}
}
await processPathingsByGroup(pathings, accountName);
return;
} else {
//预处理路线并建立对象
pathings = await processPathings();
//按照用户配置标记路线
await markPathings(pathings, priorityTags, excludeTags);
//找出最优组合
await findBestRouteGroups(pathings, efficiencyIndex, targetEliteNum, targetMonsterNum);
//分配到不同路径组
await assignGroups(pathings, groupTags);
//根据操作模式选择不同的处理方式
if (operationMode === "调试路线分配") {
await printGroupSummary();
log.info("开始复制并输出地图追踪文件\n请前往js文件夹查看");
log.info(`交互或拾取:"调试路线分配"`);
await copyPathingsByGroup(pathings);
await updateRecords(pathings, accountName);
} else if (operationMode === "运行锄地路线") {
if (!settings.disableAsync) {
const switchSuccess = await switchPartyTask;
if (!switchSuccess) {
log.error("队伍切换失败,脚本终止");
return;
}
}
log.info("开始运行锄地路线");
await updateRecords(pathings, accountName);
await processPathingsByGroup(pathings, accountName);
} else {
log.info("强制刷新所有运行记录");
await initializeCdTime(pathings, "");
await updateRecords(pathings, accountName);
}
}
})();
/* ========================= ① 启动与配置 =========================
* 负责:读取/生成用户配置、检测本地时间格式、提示未打开自定义配置等
* 为后续所有模块提供经过校验的 settings 与全局常量
* ============================================================= */
/**
* 配置加载 / 创建函数
* 依赖全局变量:settings、accountName
* 1. 当 groupIndex 为"路径组一"时,把当前 UI 上的字段落盘到 settings/{accountName}.json;
* 2. 其它组则尝试读盘,失败就报错并 10s 后退出;
* 3. 无论读写,最终都把结果同步回全局 settings;
* 4. 若配置里出现"莫酱""汐酱"关键词,直接终止脚本。
*/
async function loadConfig() {
operationMode = settings.operationMode || "运行锄地路线";
accountName = settings.accountName || "默认账户";
if (operationMode !== '启用仅指定怪物模式') {
const FORBIDDEN = ['莫酱', '汐酱'];
/* -------- 1. 构造 10 个分组标签 + 其它字段的默认值 -------- */
const buildCfgObj = () => ({
tagsForGroup2: settings.tagsForGroup2 ?? '',
tagsForGroup3: settings.tagsForGroup3 ?? '',
tagsForGroup4: settings.tagsForGroup4 ?? '',
tagsForGroup5: settings.tagsForGroup5 ?? '',
tagsForGroup6: settings.tagsForGroup6 ?? '',
tagsForGroup7: settings.tagsForGroup7 ?? '',
tagsForGroup8: settings.tagsForGroup8 ?? '',
tagsForGroup9: settings.tagsForGroup9 ?? '',
tagsForGroup10: settings.tagsForGroup10 ?? '',
disableSelfOptimization: settings.disableSelfOptimization ?? false,
efficiencyIndex: settings.efficiencyIndex ?? 0.25,
curiosityFactor: settings.curiosityFactor ?? '0',
ignoreRate: settings.ignoreRate ?? -1,
targetEliteNum: settings.targetEliteNum ?? DEFAULT_ELITE_TARGET_NUM,
targetMonsterNum: settings.targetMonsterNum ?? 2000,
priorityTags: settings.priorityTags ?? '',
excludeTags: settings.excludeTags ?? '蕈兽,传奇,狭窄地形'
});
/* -------- 2. 关键词黑名单检查 -------- */
const checkForbidden = (cfgStr) => {
FORBIDDEN.forEach(word => {
if (cfgStr.includes(word)) {
log.error(`路线选择与分组配置中包含关键词(${word}),强制终止!`);
throw new Error('禁止以汐酱或莫酱作为关键词');
}
});
};
/* -------- 3. 主逻辑 -------- */
if (settings.groupIndex === '路径组一') {
const cfg = buildCfgObj();
const cfgStr = JSON.stringify(cfg, null, 2);
checkForbidden(cfgStr);
const filePath = `settings/${accountName}.json`;
file.writeText(filePath, cfgStr, false);
} else if (settings.groupIndex) {
let cfg;
try {
const raw = await file.readText(`settings/${accountName}.json`);
cfg = JSON.parse(raw);
} catch (e) {
log.error(`配置文件 settings/${accountName}.json 不存在或格式错误,请先在"路径组一"运行一次!`);
throw new Error('无可用的配置文件');
}
/* 把读到的字段同步回全局 settings */
for (const key in cfg) {
settings[key] = cfg[key];
}
} else {
log.error(`你没打开过自定义配置,请阅读readme并按要求配置后再运行`);
await sleep(10000);
log.warn("超时未退出,尝试以默认配置运行,但仍建议阅读文档后再运行")
}
}
//加载自定义配置
pickup_Mode = settings.pickup_Mode || "模板匹配拾取,拾取狗粮和怪物材料";
dumpers = settings.activeDumperMode
? settings.activeDumperMode.split(',').map(item => item.trim()).filter(Boolean).map(item => {
const num = Number(item);
return [1, 2, 3, 4].includes(num) ? { type: 'number', value: num }
: !isNaN(num) ? null
: { type: 'name', value: item };
}).filter(Boolean)
: [];
findFInterval = Math.max(16, Math.min(200, parseNumericSetting(settings.findFInterval, 100)));
checkDelay = Math.round(findFInterval / 2);
rollingDelay = parseNumericSetting(settings.rollingDelay, 32);
pickupDelay = parseNumericSetting(settings.pickupDelay, 100);
timeMove = parseNumericSetting(settings.timeMove, 1000);
timeMoveUp = Math.round(timeMove * 0.45);
timeMoveDown = Math.round(timeMove * 0.55);
settings.detectRevival = parseNonNegativeIntegerSetting(settings.detectRevival);
settings.detectHealthBar = parseNonNegativeIntegerSetting(settings.detectHealthBar);
priorityTags = (settings.priorityTags ?? '').split(",").map(tag => tag.trim()).filter(tag => tag.length > 0);
excludeTags = (settings.excludeTags ?? '').split(",").map(tag => tag.trim()).filter(tag => tag.length > 0);
if (!pickup_Mode.includes("模板匹配")) {
excludeTags.push("沙暴");
log.warn("拾取模式不是模板匹配,无法处理沙暴路线,自动排除所有沙暴路线");
}
efficiencyIndex = parseNumericSetting(settings.efficiencyIndex, 0.25);
let parsedElite = parseNumericSetting(settings.targetEliteNum, DEFAULT_ELITE_TARGET_NUM);
if (parsedElite === 0) parsedElite = DEFAULT_ELITE_TARGET_NUM;
targetEliteNum = Math.max(0, parsedElite) + ELITE_TARGET_RESERVE; // 预留漏怪
targetMonsterNum = Math.max(0, parseNumericSetting(settings.targetMonsterNum, DEFAULT_MONSTER_TARGET_NUM)) + MONSTER_TARGET_RESERVE; // 预留漏怪
curiosityFactor = parseNumericSetting(settings.curiosityFactor, 0);
ignoreRate = parseNumericSetting(settings.ignoreRate, -1);
partyName = settings.partyName ?? "";
validateTeamMembers = (settings.validateTeamMembers ?? '')
.split(',')
.map(name => name.trim())
.filter(name => name.length > 0);
groupSettings = Array.from({ length: 10 }, (_, i) =>
settings[`tagsForGroup${i + 1}`] ?? ''
);
groupTags = groupSettings.map(str =>
str.split(',').map(tag => tag.trim()).filter(Boolean)
);
}
/**
* 检测本机 toLocaleString() 是否能被 Date.parse 正确解析。
* 若解析失败,会连续输出 3 条警告并阻塞 5 秒,最后返回 false。
* @returns {boolean} true -> 本地时间可用
* false -> 只能退而用 UTC 时间
*/
async function checkLocaleTimeSupport() {
const localStr = new Date().toLocaleString();
const ok = !isNaN(Date.parse(localStr));
if (!ok) {
['当前设备本地时间格式无法解析',
'建议不要使用12小时时间制',
'已将记录改为使用 utc 时间'].forEach(t => log.warn(`${t}`));
await sleep(WARNING_DISPLAY_DELAY_MS);
}
return ok;
}
/**
* 自定义配置未启用警告
* 若 settings.accountName 为空,则在控制台滚动输出 5 次提示,
* 提醒用户先阅读 README 后再使用,防止因未配置导致后续逻辑异常。
* 依赖全局:settings、log、sleep
*/
async function rotateWarnIfAccountEmpty() {
if (!settings.accountName) {
for (let i = 0; i < 5; i++) {
let originalMessage = " 请先阅读js文件夹中的【README.md】后使用";
let offset = i % originalMessage.length;
let message = originalMessage.slice(-offset) + originalMessage.slice(0, -offset);
log.error(message);
await sleep(ACCOUNT_WARNING_INTERVAL_MS);
}
}
}
/* ========================= ② 路线预处理与策略计算 =========================
* 负责:解析路线 JSON → 计算怪物数量/收益/时间 → 按用户标签、优先级、排除词过滤
* 最终产出:已标记 selected + group 的最优路线集合
* ====================================================================== */
/**
* 路线预处理核心函数
* 1. 读取 assets/monsterInfo.json 建立怪物-收益映射表
* 2. 扫描 pathing/ 目录下所有 *.json 路线文件,反序列化 info.description
* 提取「预计用时」与「怪物清单」并计算普通/精英怪数量及对应摩拉收益
* 3. 根据 settings.ignoreRate 过滤高小怪占比路线
* 4. 若开启自我优化且存在历史运行时长,则对「预计用时」做削峰填谷取均值
* 返回已附加 {t, m, e, mora_m, mora_e, tags, map_name, ...} 的完整路径对象数组
* 依赖全局:settings、accountName、file、initializeCdTime、readFolder
*/
async function processPathings() {
// 读取怪物信息
const monsterInfoContent = await file.readText("assets/monsterInfo.json");
monsterInfoObject = JSON.parse(monsterInfoContent);
// 读取路径文件夹中的所有文件
log.info("开始读取路径文件");
let pathings = await readFolder("pathing", "json");
//加载路线cd信息
log.info("路径文件读取完成,开始加载cd信息");
await initializeCdTime(pathings, accountName);
// 定义解析 description 的函数
function parseDescription(desc) {
const routeInfo = {
time: DEFAULT_ROUTE_TIME_SECONDS,
monsterInfo: {}
};
// 正则表达式匹配预计用时
const timeMatch = desc.match(/预计用时([\d\.]+)秒/);
if (timeMatch) {
routeInfo.time = parseFloat(timeMatch[1]);
}
// 正则表达式匹配怪物信息
const monsterMatch = desc.match(/包含以下怪物:(.*?)。/);
if (monsterMatch) {
const monsterList = monsterMatch[1].split('、');
monsterList.forEach(monsterStr => {
if (!monsterStr) return; // 跳过空字符串(如末尾多余的顿号)
const parts = monsterStr.split('只');
if (parts.length < 2) return; // 缺少"只",格式不合法,跳过
const count = Math.ceil(parseFloat(parts[0].trim()) || 0);
const name = parts[1].trim();
if (name) routeInfo.monsterInfo[name] = count;
});
}
return routeInfo;
}
let index = 0;
const validPathings = [];
log.info("cd信息加载完成,开始处理路线详细信息");
// 遍历每个路径文件并处理
for (const pathing of pathings) {
index++;
pathing.index = index;
let parsedContent;
try {
const pathingContent = await file.readText(pathing.fullPath);
parsedContent = JSON.parse(pathingContent);
} catch (error) {
log.error(`读取或解析路线文件失败,跳过 ${pathing.fullPath}:${error.message}`);
continue;
}
if (!parsedContent.info || typeof parsedContent.info !== "object" ||
!Array.isArray(parsedContent.positions)) {
log.error(`路线文件结构无效,跳过 ${pathing.fullPath}:缺少 info 或 positions`);
continue;
}
const description = typeof parsedContent.info.description === "string"
? parsedContent.info.description
: "";
if (parsedContent.info.tags !== undefined && !Array.isArray(parsedContent.info.tags)) {
log.error(`路线文件标签格式无效,跳过 ${pathing.fullPath}:info.tags 必须为数组`);
continue;
}
pathing.tags = parsedContent.info.tags || [];
// 解析 description 获取预计用时和怪物信息
const routeInfo = parseDescription(description);
//pathing 对象的属性
pathing.t = routeInfo.time; // description 中有值则覆盖
pathing.monsterInfo = routeInfo.monsterInfo;
pathing.m = 0; // 普通怪物数量
pathing.e = 0; // 精英怪物数量
pathing.original_e = 0; // 原始精英数量(用于统计被忽略的)
pathing.mora_m = 0; // 普通怪物摩拉值
pathing.mora_e = 0; // 精英怪物摩拉值
// 处理怪物信息
for (const [monsterName, count] of Object.entries(routeInfo.monsterInfo)) {
const monster = monsterInfoObject.find(m => m.name === monsterName);
if (monster) {
if (monster.type === "普通") {
pathing.m += count; // 增加普通怪物数量
pathing.mora_m += count * 40.5 * monster.moraRate; // 增加普通怪物摩拉值
} else if (monster.type === "精英") {
pathing.e += count; // 增加精英怪物数量
pathing.mora_e += count * 200 * monster.moraRate; // 增加精英怪物摩拉值
pathing.original_e += count; // 记录原始精英数量
}
if (monster.moraRate > 1) {
pathing.tags.push('高收益');
if (monster.type === "精英") {
pathing.tags.push('精英高收益');
}
}
// 添加标签
if (monster.tags && monster.tags.length > 0) {
pathing.tags.push(...monster.tags);
}
}
}
// ===== 根据 ignoreRate 过滤 =====
if (ignoreRate >= 0) {
const protectTags = ['精英高收益', '高危', '传奇'];
const hasProtectTag = protectTags.some(tag => pathing.tags.includes(tag));
if (!hasProtectTag && pathing.e > 0) { // ① 先保证有精英
const ratio = pathing.m / pathing.e; // ② 再计算比例(e 已 > 0)
if (ratio > ignoreRate) { // ③ 比例达标才清零
pathing.e = 0;
pathing.mora_e = 0;
}
}
}
const allTags = [...new Set(groupTags.slice(1).flat())];
const textToMatch = (pathing.fullPath + " " + (description || ""));
allTags.forEach(tag => {
if (textToMatch.includes(tag)) {
pathing.tags.push(tag);
}
});
// 去除重复标签
pathing.tags = [...new Set(pathing.tags)];
// 处理 map_name 属性
pathing.map_name = parsedContent.info?.map_name || "Teyvat"; // 如果有 map_name,则使用其值,否则默认为 "Teyvat"
// 处理 map_match_method 属性
pathing.map_match_method = parsedContent.info?.map_match_method || ""; // 如果有 map_match_method,则使用其值,否则默认为空字符串
validPathings.push(pathing);
}
pathings = validPathings;
for (const pathing of pathings) {
if (!settings.disableSelfOptimization && pathing.records) {
// 好奇系数:全局已解析,此处仅做 0-1 边界限制
let cf = curiosityFactor;
if (cf < 0) cf = 0;
if (cf > 1) cf = 1;
// 2. 构造 7 条内部样本
const raw = Array.isArray(pathing.records) ? pathing.records.filter(v => v > 0) : [];
const pool = [];
for (let i = 0; i < RUN_RECORD_LIMIT; i++) {
pool.push(i < raw.length ? raw[i] : pathing.t * (1 - cf)); // 补齐时带好奇系数
}
// 3. 削峰填谷 → 均值
const copy = [...pool];
const max = Math.max(...copy);
const min = Math.min(...copy);
const maxIdx = copy.indexOf(max);
const minIdx = copy.indexOf(min);
if (maxIdx > -1) copy.splice(maxIdx, 1);
if (minIdx > -1 && copy.length) copy.splice(copy.indexOf(min), 1);
const avg = copy.reduce((a, b) => a + b, 0) / copy.length;
pathing.t = avg;
}
}
log.info("预处理阶段完成");
return pathings; // 返回处理后的 pathings 数组
}
/**
* 路线打标与过滤
* 1. 若路线文件名、已有标签或所含怪物名命中 excludeTags,置 unavailable
* 2. 命中 priorityTags 的路线打上 prioritized 标记,后续选路时会被优先保留
* 3. 最终给每条路线新增:
* available(bool)- 是否可参与后续选路
* prioritized(bool)- 是否优先保留
* 依赖:pathings、priorityTags、excludeTags
*/
async function markPathings(pathings, priorityTags, excludeTags) {
pathings.forEach(pathing => {
pathing.tags = pathing.tags || [];
pathing.monsterInfo = pathing.monsterInfo || {};
pathing.prioritized = false;
pathing.available = !excludeTags.some(excludeTag => {
const fullPathContainsExcludeTag = pathing.fullPath && pathing.fullPath.includes(excludeTag);
const tagsContainExcludeTag = pathing.tags.some(tag => tag.includes(excludeTag));
const monsterInfoContainsExcludeTag = Object.keys(pathing.monsterInfo).some(monsterName => monsterName.includes(excludeTag));
return fullPathContainsExcludeTag || tagsContainExcludeTag || monsterInfoContainsExcludeTag;
});
pathing.prioritized = priorityTags.some(priorityTag => {
const fullPathContainsPriorityTag = pathing.fullPath && pathing.fullPath.includes(priorityTag);
const tagsContainPriorityTag = pathing.tags.some(tag => tag.includes(priorityTag));
const monsterInfoContainsPriorityTag = Object.keys(pathing.monsterInfo).some(monsterName => monsterName.includes(priorityTag));
return fullPathContainsPriorityTag || tagsContainPriorityTag || monsterInfoContainsPriorityTag;
});
});
}
/**
* 最优路线组合生成器
* 1. 为每条可用路线计算精英收益效率 E1 与小怪收益效率 E2(含好奇系数修正)
* 2. 先按 E1 降序选够 targetEliteNum,再按 E2 降序补够 targetMonsterNum
* 3. 迭代微调精英门槛,并贪心剔除非优先路线,使总量恰好落在目标区间
* 4. 按 settings.sortMode 重排最终路线顺序,输出总精英/小怪/收益/用时
* 返回:pathings[] 各元素新增 selected(bool)及排序
* 依赖:pathings(已含 mora_e/mora_m/t/e/available/prioritized)
*/
async function findBestRouteGroups(pathings, efficiencyIndex, targetEliteNum, targetMonsterNum) {
log.info("开始根据配置寻找路线组合");
/* ========== 0. 原初始化不动 ========== */
let nextTargetEliteNum = targetEliteNum;
let iterationCount = 0;
let totalSelectedElites = 0;
let totalSelectedMonsters = 0;
let totalGainCombined = 0;
let totalTimeCombined = 0;
let maxE1 = -Infinity, maxE2 = -Infinity;
let minE1 = Infinity, minE2 = Infinity;
pathings.forEach(p => {
p.selected = false;
if (p.e !== 0) {
p.E1 = (efficiencyIndex * p.mora_e - p.t) / p.e;
} else {
p.E1 = null;
}
if (p.m !== 0) {
p.E2 = (efficiencyIndex * p.mora_m - p.t) / p.m;
} else {
p.E2 = null;
}
if (p.e !== 0) maxE1 = Math.max(maxE1, p.E1);
if (p.m !== 0) maxE2 = Math.max(maxE2, p.E2);
if (p.e !== 0) minE1 = Math.min(minE1, p.E1 ?? Infinity);
if (p.m !== 0) minE2 = Math.min(minE2, p.E2 ?? Infinity);
});
pathings.forEach(p => {
if (p.e === 0) {
p.E1 = minE1 - 1;
}
if (p.m === 0) {
p.E2 = minE2 - 1;
}
if (p.prioritized) {
p.E1 += (maxE1 - minE1 + 2);
p.E2 += (maxE2 - minE2 + 2);
}
});
/* ========== 1. 原两轮选择逻辑照搬,只是去掉“提前 break” ========== */
function selectRoutesByEliteTarget(targetEliteNum) {
pathings.forEach(p => p.selected = false);
totalSelectedElites = 0; totalSelectedMonsters = 0;
totalGainCombined = 0; totalTimeCombined = 0;
pathings.sort((a, b) => b.E1 - a.E1);
for (const p of pathings) {
if (p.e > 0 && p.available &&
(totalSelectedElites + p.e <= targetEliteNum + ELITE_SELECTION_MARGIN)) { // 留一点余量
p.selected = true;
totalSelectedElites += p.e;
totalSelectedMonsters += p.m;
totalGainCombined += p.mora_e + p.mora_m;
totalTimeCombined += p.t;
}
}
}
function selectRoutesByMonsterTarget(targetMonsterNum) {
pathings.sort((a, b) => b.E2 - a.E2);
for (const p of pathings) {
if (p.m > 0 && p.available && !p.selected &&
(totalSelectedMonsters + p.m < targetMonsterNum + MONSTER_SELECTION_MARGIN)) {
p.selected = true;
totalSelectedElites += p.e;
totalSelectedMonsters += p.m;
totalGainCombined += p.mora_m;
totalTimeCombined += p.t;
}
}
}
/* ========== 2. 迭代:直到“双达标”才停 ========== */
while (iterationCount < MAX_ROUTE_SELECTION_ITERATIONS) {
selectRoutesByEliteTarget(nextTargetEliteNum);
selectRoutesByMonsterTarget(targetMonsterNum);
// 总量达到目标,且超出量在当前迭代允许的范围内
if (totalSelectedElites >= targetEliteNum &&
totalSelectedElites <= targetEliteNum + iterationCount / ELITE_TOLERANCE_DIVISOR &&
totalSelectedMonsters >= targetMonsterNum &&
totalSelectedMonsters <= targetMonsterNum + iterationCount / MONSTER_TOLERANCE_DIVISOR) {
break;
}
// 只调精英目标:若当前选多了就降门槛,选少了就抬门槛
const eliteGap = targetEliteNum - totalSelectedElites;
nextTargetEliteNum += Math.round(0.7 * eliteGap); // 可正可负,自动收敛
iterationCount++;
}
/* ========== 3. 最小不可再减集合(贪心逆筛,不碰优先路线) ========== */
// 1. 只留非优先的已选路线,按E1升序、E2升序排(差的先删)
const selectedList = pathings
.filter(p =>
p.selected &&
!p.prioritized &&
!p.tags.includes('精英高收益')
)
.sort((a, b) => a.E1 - b.E1 || a.E2 - b.E2);
// 2. 试删
for (const p of selectedList) {
const newE = totalSelectedElites - p.e;
const newM = totalSelectedMonsters - p.m;
if (newE >= targetEliteNum && newM >= targetMonsterNum) {
//log.info("调试-删掉了一条路线")
p.selected = false;
totalSelectedElites = newE;
totalSelectedMonsters = newM;
totalGainCombined -= p.mora_e + p.mora_m;
totalTimeCombined -= p.t;
}
}
/* ========== 4. 小怪标签 & 排序 & 日志,保持原样 ========== */
pathings.forEach(p => {
// 1. 统一先删掉旧的小怪标签(不管之前有没有)
p.tags = p.tags.filter(t => t !== '小怪');
// 2. 按最新条件重新判断
if (p.selected && p.e === 0 &&
!p.tags.includes('传奇') && !p.tags.includes('高危')) {
p.tags.push('小怪');
}
});
switch (settings.sortMode) {
case "效率降序":
log.info("使用效率降序运行");
pathings.sort((a, b) => b.E1 - a.E1 || b.E2 - a.E2);
break;
case "高收益优先":
log.info("使用高收益优先运行");
pathings.sort((a, b) => {
const aHigh = a.tags.includes("高收益") ? 1 : 0;
const bHigh = b.tags.includes("高收益") ? 1 : 0;
return bHigh - aHigh || a.fileName.localeCompare(b.fileName); // 有标签的在前,同标签按文件名排序
});
break;
default:
log.info("使用原文件顺序运行");
pathings.sort((a, b) => a.fileName.localeCompare(b.fileName)); // 按文件名排序
}
log.info("路线组合结果如下:");
log.info(`总精英怪数量: ${totalSelectedElites.toFixed(0)}`);
log.info(`总普通怪数量: ${totalSelectedMonsters.toFixed(0)}`);
log.info(`总收益: ${(totalGainCombined - 5 * 200 - 25 * 40.5).toFixed(0)} 摩拉`);
const h = Math.floor(totalTimeCombined / 3600);
const m = Math.floor((totalTimeCombined % 3600) / 60);
const s = totalTimeCombined % 60;
log.info(`预计总用时: ${h} 时 ${m} 分 ${s.toFixed(0)} 秒`);
if (totalSelectedElites < targetEliteNum - ELITE_TARGET_RESERVE || totalSelectedMonsters < targetMonsterNum - MONSTER_TARGET_RESERVE || totalSelectedElites > targetEliteNum * 1.1) {
log.warn("警告,可能条件填写不合理,分配结果与目标存在较大差异");
await sleep(WARNING_DISPLAY_DELAY_MS);
}
}
/**
* 把已选路线分配到 10 个用户分组
* 规则:
* 1. 只处理 selected 的路线
* 2. 按 groupTags[1]~groupTags[9] 顺序匹配,命中即分到对应组(2-10)
* 3. 若均不匹配则默认分到组 1(groupTags[0] 作为兜底)
* 结果:pathing.group = 1..10,后续按组批量执行
* 依赖:pathings(已有 selected & tags)、groupTags
*/
async function assignGroups(pathings, groupTags) {
pathings.forEach(pathing => {
if (pathing.selected) {
pathing.group = 1;
for (let i = 1; i <= 9; i++) {
if (groupTags[i].some(tag => pathing.tags.includes(tag))) {
pathing.group = i + 1;
break;
}
}
}
});
}
/**
* 仅指定怪物模式入口
* 1. 解析用户填写的目标怪物字符串(中文逗号分隔)
* 2. 强制使用“路径组一”并构造空分组,避免后续数组越界
* 3. 调用 processPathings 取得全部路线对象
* 4. 逐路线在「文件名 + 描述」中全文匹配任一目标怪物关键字
* 结果:pathings[].selected = 是否命中;pathings[].group = 1 或 0
* 依赖:settings、file、processPathings、pathings(全局)
*/
async function filterPathingsByTargetMonsters() {
// 1. 日志 & 检查空值
if (settings.targetMonsters) {
log.info(`当前目标怪物信息:${settings.targetMonsters}`);
} else {
log.error(`当前目标怪物为空,请阅读readme后重新检查自定义配置`);
}
// 2. 拆分成数组
const targetMonsters = (settings.targetMonsters ?? "")
.split(",") // 中文逗号
.map(s => s.trim())
.filter(Boolean);
// 3. 固定用路径组一
settings.groupIndex = "路径组一";
// 4. 构造空分组,避免后续越界
// 5. 预处理拿到完整路线
pathings = await processPathings();
// 6. 逐路线匹配 description 与文件名
for (const p of pathings) {
let desc = '';
try {
const raw = await file.readText(p.fullPath);
desc = (JSON.parse(raw).info?.description || '');
} catch { /* 忽略读失败 */ }
const textToSearch = (p.fullPath || '') + ' ' + desc;
p.selected = targetMonsters.some(m => textToSearch.includes(m));
p.group = p.selected ? 1 : 0; // 选中→组1,否则组0
}
const selectedCount = pathings.filter(p => p.selected).length;
log.info(`目标怪物模式:共找到 ${selectedCount} 条相关路线`);
}
/* ========================= ③ 运行前配置与调试输出 =========================
* 负责:调试路线分配与配置结果输出
* 调试模式下导出各组统计与路线文件,供人工核对
* ====================================================================== */
/**
* 调试-分组汇总打印
* 仅统计 group=1..10 且 selected 的路线,累加精英数、小怪数、总收益与总时长
* 输出每组的路线条数、精英/小怪数量、预计收益(摩拉)与预计用时(时:分:秒)
* 用于“调试路线分配”模式快速核对各组工作量
* 将汇总结果写入 调试结果/路线分配结果.txt 文件
* 依赖全局:pathings
*/
async function printGroupSummary() {
// 创建结果字符串
let resultText = "路线分配结果汇总\n";
resultText += "=".repeat(50) + "\n\n";
// 统计所有选中的路线
const selectedPathings = pathings.filter(p => p.selected);
resultText += `总选中路线数: ${selectedPathings.length} 条\n\n`;
let totalElites = 0, totalMonsters = 0, totalGain = 0, totalTime = 0, totalIgnoredElites = 0;
for (let g = 1; g <= 10; g++) {
const groupPath = pathings.filter(p => p.group === g && p.selected);
if (groupPath.length === 0) continue; // 跳过空组
let elites = 0, monsters = 0, gain = 0, time = 0, ignoredElites = 0;
for (const p of groupPath) {
elites += p.e || 0;
monsters += p.m || 0;
gain += p.mora_e + p.mora_m || 0;
time += p.t || 0;
ignoredElites += (p.original_e || 0) - (p.e || 0);
}
// 累加到总计
totalElites += elites;
totalMonsters += monsters;
totalGain += gain;
totalTime += time;
totalIgnoredElites += ignoredElites;
const h = Math.floor(time / 3600);
const m = Math.floor((time % 3600) / 60);
const s = time % 60;
// 构建输出内容
const tagLine = g === 1 ? " 未能进入其他组的留在路径组一" : ` 选择的标签:【${settings[`tagsForGroup${g}`] || ''}】`;
const outputLines = [
`第${g}组 总计:`,
tagLine,
` 路线条数: ${groupPath.length}`,
` 精英怪数: ${elites.toFixed(0)}`,
` 被忽视精英数: ${ignoredElites.toFixed(0)}`,
` 小怪数 : ${monsters.toFixed(0)}`,
` 预计收益: ${gain.toFixed(0)} 摩拉`,
` 预计用时: ${h} 时 ${m} 分 ${s.toFixed(0)} 秒`,
"" // 空行
];
// 输出到控制台和结果文本
outputLines.forEach(line => {
if (line === "") {
// 空行不输出到控制台,但保留在结果文本中
resultText += "\n";
} else {
log.info(line);
resultText += line + "\n";
}
});
}
// 添加总计信息
const totalH = Math.floor(totalTime / 3600);
const totalM = Math.floor((totalTime % 3600) / 60);
const totalS = totalTime % 60;
resultText += "=".repeat(50) + "\n";
resultText += "总体统计:\n";
resultText += ` 总路线数: ${selectedPathings.length} 条\n`;
resultText += ` 总精英怪: ${totalElites.toFixed(0)}\n`;
resultText += ` 被忽视精英怪数: ${totalIgnoredElites.toFixed(0)}\n`;
resultText += ` 总小怪数: ${totalMonsters.toFixed(0)}\n`;
resultText += ` 总收益 : ${(totalGain - 5 * 200 - 25 * 40.5).toFixed(0)} 摩拉\n`;
resultText += ` 总用时 : ${totalH} 时 ${totalM} 分 ${totalS.toFixed(0)} 秒\n`;
resultText += "=".repeat(50) + "\n\n";
// 其他配置信息
resultText += "配置参数:\n";
resultText += ` 摩拉/耗时权衡因数: ${settings.efficiencyIndex ?? ''}\n`;
resultText += ` 好奇系数: ${settings.curiosityFactor ?? ''}\n`;
resultText += ` 忽略比例: ${settings.ignoreRate ?? ''}\n`;
resultText += ` 目标精英数: ${settings.targetEliteNum ?? ''}\n`;
resultText += ` 目标小怪数: ${settings.targetMonsterNum ?? ''}\n`;
resultText += ` 优先级标签: ${settings.priorityTags || ''}\n`;
resultText += ` 排除标签: ${settings.excludeTags || ''}\n\n`;
// 写入文件
const filePath = "调试结果/路线分配结果.txt";
try {
await file.writeText(filePath, resultText, false);
log.info(`路线分配结果已保存至: ${filePath}`);
} catch (error) {
log.error(`保存路线分配结果文件失败: ${error.message}`);
}
}
/**
* 调试-按组导出路线文件
* 仅复制被选中的路线(selected===true)到本地调试目录
* 输出结构:调试结果/group{1..10}/原相对路径/文件名.json
* 用于“调试路线分配”模式,人工核对各组最终路线清单
* 依赖:file 读写接口、pathings(已有 selected & group)
*/
async function copyPathingsByGroup(pathings) {
// 遍历 pathings 数组
for (const pathing of pathings) {
// 只处理 selected 为 true 的项
if (pathing.selected) {
// 读取文件内容
const content = await file.readText(pathing.fullPath);
// 构造目标路径
const groupFolder = `调试结果/group${pathing.group}`;
const targetPath = `${groupFolder}/${pathing.fullPath}`;
// 写入文件内容
await file.writeText(targetPath, content, false);
}
}
}
/* ========================= ④ 路线执行引擎 =========================
* 负责:单条路线的真正执行(地图追踪)、并发拾取、异常状态检测、泥头车放技能
* 通过 Promise.allSettled 并发跑主任务+拾取+异常监控+泥头车
* ============================================================== */
/**
* 单路线执行与并发监控
* 1. 前置处理:白芙切黑芙、吃料理buff、水下路线补螃蟹技能
* 2. 并发启动四个子任务:
* - pathingTask:真正执行地图追踪文件
* - pickupTask:模板匹配拾取物品
* - errorProcessTask:冻结/白芙/烹饪界面检测与脱困
* - blacklistTask:背包满时OCR识别并拉黑多余物品
* - dumperTask(可选):接近战斗坐标时自动切人放E
* 3. 全部子任务完成后返回,state.running 被置 false
* 依赖全局:settings、state、pathings、targetItems、dumpers、shouldSwitchFurina、lastBuffTime 等
*/
async function runPath(fullPath, map_name, pm, pe) {
//当需要切换芙宁娜形态时,执行一次强制黑芙
if (shouldSwitchFurina) {
shouldSwitchFurina = false;
// 检测到白芙的地图 和 即将执行的路线地图 不同 传送换图本身会重置形态
// 因此只有检测到白芙的地图和即将执行的路线地图相同,才需要传送切换
if(furinaDetectedMap === map_name) {
log.info("上条路线识别到白芙,开始强制切换黑芙")
// 使用保存的地图名判断
if (furinaDetectedMap && furinaDetectedMap.includes("Enkanomiya")) {
// 在渊下宫,传送到指定七天神像强制黑芙
await genshin.tpToStatueOfTheSeven();
} else {
// 使用强制黑芙脚本传送至渊下宫切换黑芙
await pathingScript.runFile("assets/强制黑芙.json");
}
}
furinaDetectedMap = "";
}
if (settings.eatBuff) {
if (new Date() - lastBuffTime > BUFF_COOLDOWN_MS) {
// 1. 数据预处理:分割、去空、去重
let res = settings.eatBuff
.split(',')
.map(item => item.trim())
.filter(item => item.length > 0)
.filter((item, index, arr) => arr.indexOf(item) === index);
// 无有效数据时提前返回
if (res.length === 0) {
log.error("无有效的食物配置");
return;
}
// 2. 优化排序:currentFood 置顶以减少筛选操作
if (currentFood && res.includes(currentFood)) {
res = [currentFood, ...res.filter(item => item !== currentFood)];
}
await genshin.returnMainUi();
keyPress("B");
let type = "食物"
await findAndClick([`assets/背包界面/${type}1.png`, `assets/背包界面/${type}2.png`]);
// 3. 遍历数组,逐项执行
for (const item of res) {
if (currentFood !== item) {
await sleep(INVENTORY_ACTION_DELAY_MS);
await findAndClick(['assets/筛选1.png', 'assets/筛选2.png']);
await findAndClick("assets/重置.png");
await sleep(INVENTORY_ACTION_DELAY_MS);
await findAndClick("assets/搜索.png");
await sleep(INVENTORY_ACTION_DELAY_MS);
await findAndClick("assets/搜索成功点击.png");
// 真正输入当前这一项
log.info(`搜索${item}`);
currentFood = item;
inputText(item);
await findAndClick("assets/确认筛选.png");
while (await findAndClick("assets/确认筛选.png", false, FAST_MATCH_TIMEOUT_MS, FAST_MATCH_INTERVAL_MS)) {
await sleep(PICKUP_CONFIRM_POLL_MS);
}
}
await findAndClick("assets/使用.png");
}
await genshin.returnMainUi();
lastBuffTime = new Date();
}
}
/* ===== 1. 取得当前路线对象 ===== */
let currentPathing = null;
for (let i = 0; i < pathings.length; i++) {
if (pathings[i].fullPath === fullPath) {
currentPathing = pathings[i];
break;
}
}
if (currentPathing.tags) {
if (currentPathing.tags.includes("水下")) {
log.info("当前路线为水下路线,检查螃蟹技能");
let skillRes = await findAndClick("assets/螃蟹技能图标.png", false, 1000);
if (!skillRes) {
log.info("识别到没有螃蟹技能,前往获取");
await pathingScript.runFile("assets/学习螃蟹技能.json");
}
}
}
/* ===== 2. 重排 targetItems:当前路线拾取过的提前 ===== */
const history = {};
if (targetItems && currentPathing && currentPathing.items && currentPathing.items.length) {
// 用对象当 Set 做 O(1) 查询
for (let i = 0; i < currentPathing.items.length; i++) {
history[currentPathing.items[i]] = true;
}
// 排序:命中历史 -> 提前,其余保持原序
targetItems.sort(function (a, b) {
const aHit = history[a.itemName] ? 1 : 0;
const bHit = history[b.itemName] ? 1 : 0;
return bHit - aHit; // 1 在前,0 在后
});
}
/* ===== 2.1 处理 onlyRelatedItems 配置 ===== */
if (settings.onlyRelatedItems && targetItems && currentPathing && currentPathing.monsterInfo) {
// 首先将所有图片的 enabled 记为 true
for (const it of targetItems) {
it.enabled = true;
}
// 将所有的怪物材料图片的 enabled 记为 false
for (const it of targetItems) {
if (it.isMonsterMaterial) {
it.enabled = false;
}
}
// 根据当前路线包含的怪物类型,找出这些怪物的 item 合并后去重
const monsterItems = new Set();
for (const [monsterName, count] of Object.entries(currentPathing.monsterInfo)) {
const monster = monsterInfoObject.find(m => m.name === monsterName);
if (monster && monster.item && monster.item.length > 0) {
monster.item.forEach(itemName => monsterItems.add(itemName));
}
}
// 将结果数组与图片的 itemName 进行对比,如果纯中文部分相同,则说明需要启用该怪物材料
for (const it of targetItems) {
if (it.isMonsterMaterial) {
const cnPart = it.itemName.replace(/[^\u4e00-\u9fa5]/g, '');
for (const monsterItem of monsterItems) {
const monsterCnPart = monsterItem.replace(/[^\u4e00-\u9fa5]/g, '');
if (cnPart === monsterCnPart) {
it.enabled = true;
break;
}
}
// 特别的,如果在历史中命中过,也视为相关,也改为 true
if (history[it.itemName]) {
it.enabled = true;
}
}
}
}
/* ===== 3. 原逻辑不变 ===== */
state = { running: true, currentPathing: currentPathing };
/* ---------- 主任务 ---------- */
const pathingTask = (async () => {
// 从 fullPath 中提取纯文件名(去掉路径和扩展名)
const fileName = fullPath.split(/[\\/]/).pop();
let doLogMonsterCount = true;
log.info(`开始执行路线: ${fileName}`);
await fakeLog(`${fileName}`, true);
// 晶蝶辅助传送
const catcherCoord = settings.useCrystalflyCatcher;
if (catcherCoord && currentPathing) {
try {
await genshin.returnMainUi();
needRefreshCoord = true;
const currentPos = await getCachedPosition(map_name, currentPathing.map_match_method);
const routeStartPosition = readRouteStartPosition(fullPath);
if (currentPos && !(currentPos.X === 0 && currentPos.Y === 0) && routeStartPosition) {
const usedCrystalfly = await crystalflyAssistedTeleport(currentPos, routeStartPosition);
if (usedCrystalfly) {
await genshin.tp(routeStartPosition.X, routeStartPosition.Y, map_name, false);
}
}
} catch (error) {
log.error(`晶蝶辅助传送获取坐标失败:${error.message}`);
}
}
needRefreshCoord = true;
let runRes;
try {
runRes = await pathingScript.runFile(fullPath);
} catch (error) {
log.error(`执行地图追踪出现错误${error.message}`);
runRes = undefined;
}
try {
await sleep(1);
} catch (e) {
doLogMonsterCount = false;
}
if (settings.logMonsterCount && doLogMonsterCount) {
const m = Math.floor(pm);
const e = Math.floor(pe);
const lines = [];
for (let i = 0; i < m; i++) lines.push('交互或拾取:"小怪"');
for (let i = 0; i < e; i++) lines.push('交互或拾取:"精英"');
if (lines.length) log.debug(lines.join('\n'));
}
await fakeLog(`${fileName}`, false);
state.running = false;
return runRes;
})();
/* ---------- 伴随任务 ---------- */
const pickupTask = (async () => {
if (pickup_Mode.includes("模板匹配")) {
await recognizeAndInteract();
}
// bgi原版拾取:拾取由 BetterGI AutoPick 实时触发器完成(见 processPathingsByGroup 中的 AddTrigger("AutoPick"))。
// BGI 原版拾取由 AutoPick 实时触发器处理,脚本不维护拾取历史。
})();
const eatMedecineTask = (async () => {
if (settings.detectRevival || settings.detectHealthBar) {
let eatRevivalMedecineCount = 0;
let eatHealthBarMedecineCount = 0;
let eatRevivalMedecineconfirmCount = 0;
let eatHealthBarMedecineconfirmCount = 0;
let countWindowStart = Date.now();
const adjustConfirmCount = (count, shouldIncrease) =>
Math.max(0, Math.min(MEDICINE_CONFIRM_THRESHOLD, count + (shouldIncrease ? 1 : -1)));
while (state.running) {
try { await sleep(MEDICINE_CHECK_INTERVAL_MS) } catch (e) { break; }
if (Date.now() - countWindowStart >= MEDICINE_COUNT_WINDOW_MS) {
eatRevivalMedecineCount = 0;
eatHealthBarMedecineCount = 0;
countWindowStart = Date.now();
}
let loopCount = 0;
while (state.running) {
try { await sleep(MEDICINE_CHECK_INTERVAL_MS) } catch (e) { break; }
loopCount++;
if (loopCount >= MEDICINE_CONFIRM_WAIT_CYCLES) {
break;
}
}
if (!await isMainUI(MAIN_UI_CHECK_TIMEOUT_MS)) continue;//不在主界面不判定吃药
let shouldTakeMedicineRes = await shouldTakeMedicine(settings.detectRevival && settings.detectRevival > 0, settings.detectHealthBar && settings.detectHealthBar > 0);
eatRevivalMedecineconfirmCount = adjustConfirmCount(
eatRevivalMedecineconfirmCount,
shouldTakeMedicineRes.shouldTake && shouldTakeMedicineRes.medicineType === "revival"
);
eatHealthBarMedecineconfirmCount = adjustConfirmCount(
eatHealthBarMedecineconfirmCount,
shouldTakeMedicineRes.shouldTake && shouldTakeMedicineRes.medicineType === "heal"
);
if (eatRevivalMedecineconfirmCount >= MEDICINE_CONFIRM_THRESHOLD) {
eatRevivalMedecineconfirmCount = 0;
if (eatRevivalMedecineCount < settings.detectRevival) {
keyPress("Z");
log.info(`交互或拾取:"使用复活料理"`);
eatRevivalMedecineCount++;
}
}
if (eatHealthBarMedecineconfirmCount >= MEDICINE_CONFIRM_THRESHOLD) {
eatHealthBarMedecineconfirmCount = 0;
if (eatHealthBarMedecineCount < settings.detectHealthBar) {
keyPress("Z");
log.info(`交互或拾取:"使用回血料理"`);
eatHealthBarMedecineCount++;
}
}
}
}
})();
const errorProcessTask = (async () => {
let errorProcessCount = 0;
while (state.running) {
if (errorProcessCount % ERROR_CHECK_INTERVAL_LOOPS === 0) {
//每约250毫秒进行一次冻结检测和白芙检测
if (await findAndClick(frozenRo, false, FAST_MATCH_TIMEOUT_MS, FAST_MATCH_INTERVAL_MS)) {
log.info("检测到冻结,尝试挣脱");
for (let m = 0; m < FREEZE_ESCAPE_PRESS_COUNT; m++) {
keyPress("VK_SPACE");
await sleep(FREEZE_ESCAPE_INTERVAL_MS);
}
continue;
}
if (!shouldSwitchFurina) {
if (await findAndClick(whiteFurinaRo, false, FAST_MATCH_TIMEOUT_MS, FAST_MATCH_INTERVAL_MS)) {
log.info("检测到白芙,本路线运行结束后切换芙宁娜形态");
shouldSwitchFurina = true;
furinaDetectedMap = map_name || ""; // 保存当前路线地图
continue;
}
}
if (await findAndClick(revivalRo, true, FAST_MATCH_TIMEOUT_MS, FAST_MATCH_INTERVAL_MS)) {
log.info("识别到复苏按钮,点击");
await sleep(RECOVERY_DELAY_MS);
continue;
}
}
if (errorProcessCount % COOKING_CHECK_INTERVAL_LOOPS === 0) {
//每约5000毫秒进行一次烹饪检测
if (await findAndClick(cookingRo, false, FAST_MATCH_TIMEOUT_MS, FAST_MATCH_INTERVAL_MS)) {
log.info("检测到烹饪界面,尝试脱离");
keyPress("VK_ESCAPE");
await sleep(RECOVERY_DELAY_MS);
continue;
}
}
errorProcessCount++;
await sleep(ERROR_LOOP_DELAY_MS);
}
})(map_name);
const blacklistTask = (async () => {
async function checkItemFull() {
const maxAttempts = 1;
let attempts = 0;
while (attempts < maxAttempts && state.running) {
try {
const result = (await getGameRegion()).find(itemFullRo);
if (result.isExist()) {
return true;
}
} catch (error) {
log.error(`识别图像时发生异常: ${error.message}`);
if (!state.running) break;
return false;
}
attempts++;
}
return false;
}
/**
* 计算匹配度:itemName中文部分在识别文本中出现的最长长度占总长度的比例
* @param {string} cnPart itemName的中文部分
* @param {string} ocrText OCR识别到的文本
* @returns {number} 0~1
*/
function calcMatchRatio(cnPart, ocrText) {
if (!cnPart || !ocrText) return 0;
const len = cnPart.length;
let maxMatch = 0;
// 滑动窗口找最长连续子串
for (let i = 0; i <= ocrText.length - len; i++) {
let match = 0;
for (let j = 0; j < len; j++) {
if (ocrText[i + j] === cnPart[j]) match++;
}
maxMatch = Math.max(maxMatch, match);
}
return maxMatch / len;
}
if (pickup_Mode.includes("模板匹配")) {
while (state.running) {
let sleepTimes = 0;
while (state.running && sleepTimes < BACKPACK_CHECK_INTERVAL_CYCLES) {
await sleep(ERROR_LOOP_DELAY_MS);
sleepTimes++;
}
if (!state.running) break;
if (await checkItemFull()) {
const { x: textX, y: textY, width: textWidth, height: textHeight } = BACKPACK_OCR_REGION;
let ocrText = null;
try {
const resList = (await getGameRegion()).findMulti(
RecognitionObject.ocr(textX, textY, textWidth, textHeight)
);
if (resList.count) {
let longest = resList[0];
for (let i = 1; i < resList.count; i++) {
if (resList[i].text.length > longest.text.length) longest = resList[i];
}
ocrText = longest.text.replace(/[^\u4e00-\u9fa5]/g, '');
}
} catch (e) {
log.error(`OCR异常: ${e.message}`);
}
if (ocrText) {
log.info(`识别到背包已满,识别到文本:${ocrText}`);
const ratioMap = new Map(); // itemName -> ratio
for (const targetItem of targetItems) {
const cnPart = targetItem.itemName.replace(/[^\u4e00-\u9fa5]/g, '');
const ratio = calcMatchRatio(cnPart, ocrText);
if (ratio > ITEM_OCR_MATCH_THRESHOLD) {
ratioMap.set(targetItem.itemName, ratio);
}
}
if (ratioMap.size > 0) {
// 找出最大匹配度
const maxRatio = Math.max(...ratioMap.values());
// 所有等于最大匹配度的项
const names = Array.from(ratioMap.entries())
.filter(([, r]) => r === maxRatio)
.map(([n]) => n)
.sort(); // 排序方便日志
log.warn(`以下物品匹配度最高且≥${ITEM_OCR_MATCH_THRESHOLD * 100}%(${(maxRatio * 100).toFixed(1)}%),加入黑名单:${names.join('、')}`);
for (const nm of names) {
if (!blacklistSet.has(nm)) {
blacklistSet.add(nm);
blacklist.push(nm);
}
}
await loadBlacklist(false);
}
}
}
}
}
})();
/* ---------- 泥头车任务 ---------- */
let dumperTask = null;
if (dumpers.length > 0) {
dumperTask = dumper(fullPath, map_name);
}
/* ---------- 并发等待 ---------- */
const results = await Promise.allSettled([
pathingTask,
pickupTask,
errorProcessTask,
blacklistTask,
eatMedecineTask,
dumperTask
].filter(Boolean));
// 返回地图追踪执行结果(旧版本BGI无返回值时返回 undefined)
return results[0].status === "fulfilled" ? results[0].value : undefined;
}
/**
* 模板匹配拾取主循环
* 持续识别屏幕 F 图标 → 根据物品名模板匹配 → 黑名单过滤 → 按键拾取
* 同时通过滚轮上下翻页扩大识别范围,避免漏捡
* 将本次拾取记录回写至当前路线对象,用于下次优先识别
* 依赖全局:state、targetItems、blacklistSet、pickupDelay、rollingDelay 等
*/
async function recognizeAndInteract() {
//log.info("调试-开始执行图像识别与拾取任务");
let lastcenterYF = 0;
let lastItemName = "";
let thisMoveUpTime = 0;
let lastMoveDown = 0;
let itemName;
//主循环
while (state.running) {
//log.info("调试-交互拾取进行中");
let centerYF = await findFIcon();
if (!centerYF) {
if (new Date() - lastRollTime >= PICKUP_EMPTY_SCROLL_INTERVAL_MS) {
lastRollTime = new Date();
if (await hasScroll()) {
await keyMouseScript.runFile(`assets/滚轮下翻.json`);
}
}
continue;
}
if (pickup_Mode.includes("模板匹配")) {
itemName = await performTemplateMatch(centerYF);
}
if (itemName) {
//log.info(`调试-识别到物品${itemName}`);
if (Math.abs(lastcenterYF - centerYF) <= PICKUP_DUPLICATE_Y_THRESHOLD && lastItemName === itemName) {
//log.info("调试-相同物品名和相近y坐标,本次不拾取");
await sleep(PICKUP_DUPLICATE_DELAY_MS);
lastcenterYF = -20;
lastItemName = null;
} else {
if (blacklistSet.has(itemName)) {
//log.warn(`识别到黑名单物品${itemName},不拾取`);
} else {
keyPress("F");
log.info(`交互或拾取:"${itemName}"`);
// 把本次拾取加入当前路线名单,保持最近的历史记录
if (state.currentPathing) {
state.currentPathing.items.push(itemName);
// 去重并保留最近记录
state.currentPathing.items = [...new Set(state.currentPathing.items)].slice(-PICKUP_HISTORY_LIMIT);
}
lastcenterYF = centerYF;
lastItemName = itemName;
await sleep(pickupDelay);
}
}
} else {
//log.warn("未识别到结果");
lastItemName = "";
}
//log.info(`调试-执行滚轮动作`);
const currentTime = new Date().getTime();
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);
}
async function performTemplateMatch(centerYF) {
let regionPerformTemplateMatch;
try {
regionPerformTemplateMatch = (await getGameRegion()).DeriveCrop(
PICKUP_REGION.x,
centerYF + PICKUP_REGION.yOffset,
PICKUP_REGION.width,
PICKUP_REGION.height
);
let firstMatch = null;
for (const it of targetItems) {
if (!it.enabled) continue;
if (regionPerformTemplateMatch.find(it.roi).isExist()) {
firstMatch = it;
break;
}
}
if (!firstMatch) return null;
if (!settings.disableSecondCheck) {
if (regionPerformTemplateMatch.find(firstMatch.roi).isExist()) {
return firstMatch.itemName;
}
return null;
} else {
return firstMatch.itemName;
}
} catch (e) {
log.error(`performTemplateMatch: ${e.message}`);
} finally {
regionPerformTemplateMatch?.dispose();
}
return null;
}
async function findFIcon() {
try {
let result = (await getGameRegion()).find(fIconRo);
if (result.isExist()) {
return Math.round(result.y + result.height / 2);
}
} catch (error) {
log.error(`识别图像时发生异常: ${error.message}`);
if (!state.running)
return null;
}
await sleep(checkDelay);
return null;
}
}
/**
* 读取路线的第一个有效坐标,供晶蝶辅助传送使用。
*/
function readRouteStartPosition(pathFilePath) {
try {
const raw = file.readTextSync(pathFilePath);
const json = JSON.parse(raw);
const firstPosition = Array.isArray(json.positions)
? json.positions.find(position =>
Number.isFinite(position?.x ?? position?.X) &&
Number.isFinite(position?.y ?? position?.Y))
: null;
if (firstPosition) {
return {
X: firstPosition.x ?? firstPosition.X,
Y: firstPosition.y ?? firstPosition.Y
};
}
log.error(`路线文件中未找到有效起点坐标:${pathFilePath}`);
} catch (error) {
log.error(`读取路线文件获取初始坐标失败:${error.message}`);
}
return null;
}
/**
* CrystalflyAssistedTeleport
* 根据晶蝶诱捕装置配置,判断是否需要使用传送功能
* @param {Object} currentPos - 当前角色坐标 {X, Y}
* @param {{X: number, Y: number}} routeStartPosition - 路线起点坐标
* 依赖全局:settings.useCrystalflyCatcher
*/
async function crystalflyAssistedTeleport(currentPos, routeStartPosition) {
const catcherCoord = settings.useCrystalflyCatcher;
const coordParts = catcherCoord.split(',');
if (coordParts.length !== 2) {
log.error(`晶蝶诱捕装置坐标格式错误:${catcherCoord},正确格式应为"X,Y"(中文逗号分隔)`);
return false;
}
const catcherX = parseFloat(coordParts[0].trim());
const catcherY = parseFloat(coordParts[1].trim());
if (isNaN(catcherX) || isNaN(catcherY)) {
log.error(`晶蝶诱捕装置坐标解析失败:${catcherCoord}`);
return false;
}
const currentDist = Math.sqrt(
Math.pow(currentPos.X - routeStartPosition.X, 2) +
Math.pow(currentPos.Y - routeStartPosition.Y, 2)
);
const catcherDist = Math.sqrt(
Math.pow(catcherX - routeStartPosition.X, 2) +
Math.pow(catcherY - routeStartPosition.Y, 2)
);
if (currentDist - catcherDist > CRYSTALFLY_DISTANCE_ADVANTAGE && catcherDist < CRYSTALFLY_MAX_CATCHER_DISTANCE) {
log.info(`启用晶蝶辅助传送,当前位置距离起点: ${currentDist.toFixed(1)},晶蝶装置距离起点: ${catcherDist.toFixed(1)}`);
keyPress("M");
await sleep(CRYSTALFLY_UI_DELAY_MS);
const crystalFlyRo = RecognitionObject.TemplateMatch(
file.ReadImageMatSync("assets/晶蝶装置.png"),
...SCREEN_REGIONS.crystalFly
);
crystalFlyRo.Threshold = 0.85;
const clicked = await findAndClick(crystalFlyRo, true, CRYSTALFLY_FIND_TIMEOUT_MS);
if (!clicked) {
log.warn("未找到晶蝶诱捕装置,取消辅助传送");
keyPress("VK_ESCAPE");
return false;
}
await sleep(CRYSTALFLY_UI_DELAY_MS);
keyPress("VK_ESCAPE");
await sleep(CRYSTALFLY_UI_DELAY_MS);
return true;
}
return false;
}
/**
* 泥头车自动放 E
* 读取当前路线坐标,若检测到即将进入战斗点(5-30 像素)且路线未使用按键 T,
* 则按 dumpers 列表循环切人放 E,CD 10 秒;若检测到复活界面则立即退出
* 返回前内部定义 isRevivalUI 用于自救
* 依赖全局:state、dumpers、lastDumperTimer、dumperCD
*/
async function dumper(pathFilePath, map_name) {
//log.info("开始泥头车");
let lastDumperTimer = 0;
const dumperCD = DUMPER_COOLDOWN_MS;
try {
const pathingContent = await file.readText(pathFilePath);
const parsedContent = JSON.parse(pathingContent);
const positions = parsedContent.positions;
// 初始化 disableDumper 为 false
let disableDumper = false;
// 初始化 fightPositions 数组
let fightPositions = [];
// 遍历 positions 数组
for (const pos of positions) {
// 检查 action_params 是否包含 keypress(T)
if (pos.action_params && pos.action_params.includes('keypress(T)')) {
disableDumper = true;
}
// 如果 action 是 "fight",则添加到 fightPositions
if (pos.action === "fight") {
fightPositions.push({
x: pos.x,
y: pos.y,
used: false
});
}
}
const info = parsedContent.info;
const map_match_method = info.map_match_method || "";
if (!disableDumper) {
while (state.running) {
//log.info("调试-泥头车循环");
let sleepTimes = 0;
while (state.running && sleepTimes < DUMPER_POLL_CYCLES) {
await sleep(DUMPER_POLL_INTERVAL_MS);
sleepTimes++;
}
if (!state.running) break;
await sleep(1);
if (await isMainUI() && !await findAndClick(flyingRo, false, FAST_MATCH_TIMEOUT_MS, FAST_MATCH_INTERVAL_MS)) {
//log.info("调试-获取坐标");
//在主界面才尝试获取坐标
let dumperDistance = 0;
try {
let shouldPressKeys = false;
const currentPosition = map_match_method && map_match_method !== ""
? await genshin.getPositionFromMapWithMatchingMethod(map_name, map_match_method)
: await genshin.getPositionFromMap(map_name);
if (!currentPosition) {
continue;
}
for (let i = 0; i < fightPositions.length; i++) {
const fightPos = fightPositions[i];
if (fightPos.used) {
continue;
}
const distance = Math.sqrt(
Math.pow(currentPosition.X - fightPos.x, 2) +
Math.pow(currentPosition.Y - fightPos.y, 2)
);
if (distance <= DUMPER_MAX_TRIGGER_DISTANCE) {
fightPositions[i].used = true;
}
if (distance > DUMPER_MIN_TRIGGER_DISTANCE && distance <= DUMPER_MAX_TRIGGER_DISTANCE) {
if ((new Date() - lastDumperTimer) > dumperCD) {
shouldPressKeys = true;
lastDumperTimer = new Date();
dumperDistance = distance;
}
}
}
if (shouldPressKeys) {
log.info(`距离下个战斗地点距离${dumperDistance.toFixed(2)},启用泥头车`);
for (const item of dumpers) {
if (item.type === 'number') {
log.info(`[泥头车]:尝试切换${item.value}号角色施放e技能`);
keyPress(String(item.value));
await sleep(DUMPER_KEY_DELAY_MS);
keyPress('e');
await sleep(DUMPER_KEY_DELAY_MS);
keyPress('e');
await sleep(DUMPER_KEY_DELAY_MS);
keyPress('e');
await sleep(DUMPER_KEY_DELAY_MS);
} else {
log.info(`[泥头车]:尝试使用角色[${item.value}]施放e技能`);
try {
await dispatcher.RunCombatScript("e,e,e", item.value);
} catch (error) {
log.warn("js调用简易策略异常");
}
}
}
for (let i = 0; i < REVIVAL_UI_CHECK_ATTEMPTS; i++) {
if (await isRevivalUI()) {
//检测到复苏界面时,退出复苏界面
keyPress("VK_ESCAPE");
await sleep(RECOVERY_DELAY_MS);
await genshin.returnMainUi();
} else {
break;
}
}
}
} catch (error) {
}
}
}
} else {
log.info("当前路线含有按键T,不启用泥头车");
}
} catch (error) {
log.error(`执行泥头车时出现异常: ${error.message}`);
}
//检查是否在复活界面
async function isRevivalUI() {
// 修改后的图像路径
const imagePath = "assets/RevivalUI.png";
// 修改后的识别区域(左上角区域)
const [xMin, yMin, width, height] = SCREEN_REGIONS.revivalUi;
let template = file.ReadImageMatSync(imagePath);
let recognitionObject = RecognitionObject.TemplateMatch(template, xMin, yMin, width, height);
// 尝试次数设置为 10 次
const maxAttempts = REVIVAL_UI_CHECK_ATTEMPTS;
let attempts = 0;
while (attempts < maxAttempts && state.running) {
try {
let result = (await getGameRegion()).find(recognitionObject);
if (result.isExist()) {
return true; // 如果找到图标,返回 true
}
} catch (error) {
log.error(`识别图像时发生异常: ${error.message}`);
return false; // 发生异常时返回 false
}
attempts++; // 增加尝试次数
await sleep(REVIVAL_UI_CHECK_INTERVAL_MS);
}
return false; // 如果尝试次数达到上限或取消,返回 false
}
}
/**
* 检查是否需要使用药品
* @param {boolean} useRevivalMedicine 是否检测复活药
* @param {boolean} useHealMedicine 是否检测回血药
* @returns {Object} 包含是否应该吃药以及药品种类的对象
* @returns {boolean} return.shouldTake 是否应该吃药
* @returns {string|null} return.medicineType 药品种类,可能的值:'revival'(复活药)、'heal'(回血药)、null(不需要吃药)
*/
async function shouldTakeMedicine(useRevivalMedicine = false, useHealMedicine = false) {
// 检测复活药逻辑
if (useRevivalMedicine) {
let res2 = (await getGameRegion()).find(revivalMedicineRo);
if (!res2.isEmpty()) {
return {
shouldTake: true,
medicineType: 'revival'
};
}
}
// 检测回血药逻辑
if (useHealMedicine) {
//识别血条类型
const { x, y, width, height } = HEALTH_BAR_SAMPLE_REGION;
let toCheckRegion = (await getGameRegion()).DeriveCrop(x, y, width, height);
let toCheckMat = toCheckRegion.SrcMat;
let ro = RecognitionObject.TemplateMatch(toCheckMat);
ro.use3Channels = true;
ro.Threshold = 0.4;
ro.InitTemplate();
try {
let res = img.find(ro);
if (!res.isEmpty()) {
let color;
if (res.x > HEALTH_BAR_YELLOW_THRESHOLD) {
color = "黄";
}
else if (res.x > HEALTH_BAR_GREEN_THRESHOLD) {
color = "绿";
}
else {
color = "红";
}
//log.info(`识别到血条颜色${color}`);
if (color === "红") {
return {
shouldTake: true,
medicineType: 'heal'
};
}
}
} catch (error) {
log.error(`识别血条时出现错误${error.message}`);
} finally {
toCheckRegion.dispose();
}
}
return {
shouldTake: false,
medicineType: null
};
}
/* ========================= ⑤ 批量调度与数据持久化 =========================
* 负责:按组依次执行路线、刷新时间(CD)判断、坐标偏差校验、运行耗时记录
* 把本次运行结果写回 records/{账户}.json 与黑名单文件
* ======================================================================= */
/**
* 批量调度与持久化主入口
* 1. 按用户选择的“路径组X”筛选路线,输出组内总计精英/小怪/收益/时长
* 2. 循环执行组内每条路线:CD未到则跳过;否则runPath()并记录真实耗时
* 3. 坐标偏差校验,失败≥1次且未禁用检查时放弃写入运行数据
* 4. 计算下次刷新时间(CD)并写回 records/{accountName}.json
* 依赖:settings、pathings、runPath、updateRecords、isTimeRestricted 等
*/
async function processPathingsByGroup(pathings, accountName) {
let lastX = 0;
let lastY = 0;
// 定义路径组名称到组号的映射(10 个)
const groupMapping = {
"路径组一": 1,
"路径组二": 2,
"路径组三": 3,
"路径组四": 4,
"路径组五": 5,
"路径组六": 6,
"路径组七": 7,
"路径组八": 8,
"路径组九": 9,
"路径组十": 10
};
// 从全局 settings 中获取用户选择的路径组名称
const selectedGroupName = settings.groupIndex || "路径组一"; // 默认值为 "路径组一"
// 将路径组名称映射到组号
const targetGroup = groupMapping[selectedGroupName];
// 初始化变量,用于标记当前路径是该组的第几个
let groupPathCount = 0;
// 获取该组的总路径数
const totalPathsInGroup = pathings.filter(pathing => pathing.group === targetGroup).length;
if (pickup_Mode === "bgi原版拾取") {
dispatcher.AddTrigger(new RealtimeTimer("AutoPick"));
rollingDelay = 160;
}
// 初始化统计变量
let totalElites = 0; // 总精英怪数量
let totalMonsters = 0; // 总小怪数量
let totalGain = 0; // 总收益
let totalEstimatedTime = 0; // 预计总时间
// 遍历 pathings 数组,计算当前组的总计精英怪数量、小怪数量、总计收益和预计总时间
for (const pathing of pathings) {
if (pathing.group === targetGroup) {
totalElites += pathing.e || 0; // 精英怪数量
totalMonsters += pathing.m || 0; // 小怪数量
totalGain += pathing.mora_e + pathing.mora_m || 0; // 收益
totalEstimatedTime += pathing.t || 0; // 预计时间
}
}
// 将预计总时间转换为时、分、秒表示
const hours = Math.floor(totalEstimatedTime / 3600);
const minutes = Math.floor((totalEstimatedTime % 3600) / 60);
const seconds = totalEstimatedTime % 60;
// 输出当前组的总计信息
log.info(`当前组 ${selectedGroupName} 的总计信息:`);
log.info(`精英怪数量: ${totalElites.toFixed(0)}`);
log.info(`小怪数量: ${totalMonsters.toFixed(0)}`);
if (settings.operationMode != "启用仅指定怪物模式") {
log.info(`预计收益: ${totalGain.toFixed(0)} 摩拉`);
}
log.info(`预计用时: ${hours} 时 ${minutes} 分 ${seconds.toFixed(0)} 秒`);
const groupStartTime = new Date();
let remainingEstimatedTime = totalEstimatedTime;
let skippedTime = 0;
// 遍历 pathings 数组
for (const pathing of pathings) {
// 检查路径是否属于指定的组
if (pathing.group === targetGroup) {
// 增加路径计数
groupPathCount++;
if (await isTimeRestricted(settings.timeRule, Math.ceil(pathing.t / 40))) {
break;
}
// 输出当前路径的序号信息
log.info(`开始处理第 ${targetGroup} 组第 ${groupPathCount}/${totalPathsInGroup} 个${pathing.fileName}`);
// 获取当前时间
const now = new Date();
// 检查 cdTime 是否晚于当前时间
const cdTime = new Date(pathing.cdTime);
if (cdTime > now) {
log.info(`该路线未刷新,跳过。`);
skippedTime += pathing.t;
remainingEstimatedTime -= pathing.t;
continue;
}
// 输出路径已刷新并开始处理的信息
log.info(`该路线已刷新,开始处理。`);
// 获取当前坐标作为起点参考
if (settings.enableCoordCheck) {
try {
await genshin.returnMainUi();
needRefreshCoord = true;
const miniMapPosition = await getCachedPosition(pathing.map_name, pathing.map_match_method);
if (miniMapPosition) {
lastX = miniMapPosition.X;
lastY = miniMapPosition.Y;
}
} catch (error) {
log.error(`获取坐标时发生错误:${error.message}`);
}
}
// 调用 runPath 函数处理路径
const pathRes = await runPath(pathing.fullPath, pathing.map_name, pathing.m, pathing.e);
try {
await sleep(1);
} catch (error) {
break;
}
const pathTime = new Date() - now;
remainingEstimatedTime -= pathing.t;
const actualUsedTime = (new Date() - groupStartTime) / 1000;
const predictRemainingTime = remainingEstimatedTime * actualUsedTime / (totalEstimatedTime - remainingEstimatedTime - skippedTime);
// 将预计剩余时间转换为时、分、秒表示
const remaininghours = Math.floor(predictRemainingTime / 3600);
const remainingminutes = Math.floor((predictRemainingTime % 3600) / 60);
const remainingseconds = predictRemainingTime % 60;
log.info(`当前进度:第 ${targetGroup} 组第 ${groupPathCount}/${totalPathsInGroup} 个 ${pathing.fileName}已完成,该组预计剩余: ${remaininghours} 时 ${remainingminutes} 分 ${remainingseconds.toFixed(0)} 秒`);
let fileEndX = 0, fileEndY = 0;
let coordAbnormal = false;
if (pathRes !== undefined && typeof pathRes.success === 'boolean') {
// 新版本BGI:直接使用返回值判定路线是否成功
if (pathRes.success) {
log.info("路线运行成功");
} else {
log.error(`路线运行失败:${pathRes.message}`);
notification.send(`路线${pathing.fileName}:路线未正常完成,不记录运行数据`);
continue;
}
} else if (settings.enableCoordCheck) {
// 旧版本BGI:静默回退到坐标校验
try {
const raw = file.readTextSync(pathing.fullPath);
const json = JSON.parse(raw);
if (Array.isArray(json.positions)) {
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') {
fileEndX = p.x;
fileEndY = p.y;
break;
}
}
}
} catch (e) { /* 读文件失败就留 0,0 继续走后面逻辑 */ }
try {
await genshin.returnMainUi();
const miniMapPosition = await getCachedPosition(pathing.map_name, pathing.map_match_method);
if (miniMapPosition) {
const diffX = Math.abs(lastX - miniMapPosition.X);
const diffY = Math.abs(lastY - miniMapPosition.Y);
const endDiffX = Math.abs(fileEndX - miniMapPosition.X);
const endDiffY = Math.abs(fileEndY - miniMapPosition.Y);
if ((diffX + diffY) < ROUTE_COORD_SAME_THRESHOLD ||
(endDiffX + endDiffY) > ROUTE_COORD_END_THRESHOLD) {
coordAbnormal = true;
}
}
} catch (error) {
log.error(`获取坐标时发生错误:${error.message}`);
coordAbnormal = true;
}
}
await genshin.returnMainUi();
let mainUiRes = await isMainUI(ROUTE_COMPLETION_UI_TIMEOUT_MS);
let reconnectRes = await findAndClick(["assets/确认.png", "assets/重新连接服务器.png"], true, RECONNECT_CHECK_TIMEOUT_MS);
if ((coordAbnormal && settings.enableCoordCheck) || !mainUiRes || reconnectRes) {
log.error("路线未正常完成、坐标获取异常或不处于主界面,不记录运行数据");
notification.send(`路线${pathing.fileName}:路线未正常完成、坐标获取异常或不处于主界面,不记录运行数据`);
continue;
}
// 所有成功条件通过后,才将本次运行时长写入历史记录
pathing.records = [...pathing.records, pathTime / 1000].slice(-RUN_RECORD_LIMIT);
// 计算下一个 UTC 时间的晚上 8 点(即北京时间凌晨四点)
let newCDTime = new Date(now);
newCDTime.setUTCHours(20, 0, 0, 0); // 设置为 UTC 时间的 20:00
if (newCDTime <= now) {
// 如果设置的时间小于等于当前时间,说明需要取下一个晚上 8 点
newCDTime.setUTCHours(20 + 24, 0, 0, 0); // 设置为下一个 UTC 时间的 20:00
}
if (pathing.m !== 0 && !pathing.tags.includes("传奇")) {
const nowPlus12h = new Date(now.getTime() + 12 * 3600 * 1000); // now + 12h
if (newCDTime < nowPlus12h) {
newCDTime = nowPlus12h;
}
}
// 更新路径的 cdTime
pathing.cdTime = newCDTime.toLocaleString();
if (!localeTimeSupported) pathing.cdTime = newCDTime.toISOString();
await updateRecords(pathings, accountName);
}
}
}
/**
* 初始化或更新路线CD与运行记录
* 读取 records/{accountName}.json:
* - 为每条路线赋予 cdTime(本地或UTC)与最近7次运行时长
* - 拾取历史仅保留最后20个不重复项
* 若记录文件缺失则初始化为7条-1
* 依赖:file、accountName、localeTimeSupported
*/
async function initializeCdTime(pathings, accountName) {
try {
const filePath = `records/${accountName}.json`;
const fileContent = await file.readText(filePath);
const cdTimeData = JSON.parse(fileContent);
pathings.forEach(pathing => {
let entry = null;
for (let i = 0; i < cdTimeData.length; i++) {
if (cdTimeData[i].fileName === pathing.fileName) {
entry = cdTimeData[i];
break;
}
}
// 读取 cdTime
pathing.cdTime = entry
? new Date(entry.cdTime).toLocaleString()
: new Date(0).toLocaleString();
if (!localeTimeSupported) pathing.cdTime = entry
? new Date(entry.cdTime).toISOString()
: new Date(0).toISOString();
// 确保当前 records 是数组
const current = Array.isArray(pathing.records) ? pathing.records : new Array(RUN_RECORD_LIMIT).fill(-1);
// 读取文件中的 records(若缺失则为空数组)
const loaded = (entry && Array.isArray(entry.records)) ? entry.records : [];
// 合并:文件中的 records(倒序最新在前)→ 追加到当前数组末尾
// 再整体倒序恢复正确顺序,截取最新 7 项
pathing.records = [...current, ...loaded.reverse()].slice(-RUN_RECORD_LIMIT);
// 读取历史拾取名单,只保留最后 20 个不重复
const rawItems = (entry && Array.isArray(entry.items)) ? entry.items : [];
pathing.items = [...new Set(rawItems)].slice(-PICKUP_HISTORY_LIMIT); // 去重 + 截断
});
} catch (error) {
// 文件不存在或解析错误,初始化运行记录与拾取历史
pathings.forEach(pathing => {
pathing.cdTime = new Date(0).toLocaleString();
pathing.records = new Array(RUN_RECORD_LIMIT).fill(-1);
pathing.items = [];
});
if (!localeTimeSupported) pathings.forEach(pathing => {
pathing.cdTime = new Date(0).toISOString();
pathing.records = new Array(RUN_RECORD_LIMIT).fill(-1);
pathing.items = [];
});
}
}
/**
* 回写运行记录
* 把当前 pathings 数组中的 cdTime、records、items、标签、预计用时
* 按文件名为主键写入 records/{accountName}.json(倒序,仅保留>0的时长)
* 供下次启动时 initializeCdTime() 加载
* 依赖:file、accountName
*/
async function updateRecords(pathings, accountName) {
try {
const filePath = `records/${accountName}.json`;
const cdTimeData = pathings.map(pathing => ({
fileName: pathing.fileName,
标签: pathing.tags,
预计用时: pathing.t.toFixed(2),
cdTime: pathing.cdTime,
records: [...pathing.records]
.reverse()
.filter(v => v > 0)
.map(v => Number(v.toFixed(2))),
items: pathing.items
}));
await file.writeText(filePath, JSON.stringify(cdTimeData, null, 2), false);
} catch (error) {
log.error(`更新 cdTime 时出错: ${error.message}`);
}
}
/**
* 黑名单加载/保存
* @param {boolean} merge true 时先与本地文件合并再去重;false 仅重写内存到磁盘
* 内存结构:blacklist 数组 + blacklistSet Set 用于O(1)查询
* 文件路径:blacklists/{accountName}.json
* 依赖:file、accountName、blacklist/blacklistSet
*/
async function loadBlacklist(merge = false) {
try {
if (merge) {
const raw = await file.readText(`blacklists/${accountName}.json`);
const arr = JSON.parse(raw);
blacklist = [...new Set([...blacklist, ...arr])];
}
blacklistSet.clear();
blacklist.forEach(item => blacklistSet.add(item));
} catch (err) {
log.error(`读取黑名单失败: ${err.message}`);
blacklist = [];
blacklistSet.clear();
}
await file.writeText(`blacklists/${accountName}.json`, JSON.stringify(blacklist, null, 2), false);
}
/* ========================= ⑥ 底层工具 =========================
* 负责:队伍切换、时间规则判断、模板匹配点击、OCR、日志伪造、目录递归读取等
* 供以上各模块随时调用
* =========================================================== */
/**
* 获取缓存的坐标,避免重复调用 getPositionFromMap
* 仅当 needRefreshCoord 为 true 时重新获取
*/
async function getCachedPosition(map_name, map_match_method) {
const cacheMapName = map_name || "Teyvat";
const cacheMatchMethod = map_match_method || "";
const cacheContextChanged = coordCacheMapName !== cacheMapName ||
coordCacheMatchMethod !== cacheMatchMethod;
if (needRefreshCoord || cacheContextChanged) {
try {
const pos = map_match_method && map_match_method !== ""
? await genshin.getPositionFromMapWithMatchingMethod(map_name, map_match_method)
: await genshin.getPositionFromMap(map_name);
if (pos && typeof pos.X === 'number' && typeof pos.Y === 'number'
&& !isNaN(pos.X) && !isNaN(pos.Y) && !(pos.X === 0 && pos.Y === 0)) {
coordCache = pos;
} else {
coordCache = { X: 0, Y: 0 };
}
log.info(`更新当前坐标为 ${coordCache.X},${coordCache.Y}`);
coordCacheMapName = cacheMapName;
coordCacheMatchMethod = cacheMatchMethod;
needRefreshCoord = false;
} catch (e) {
coordCache = { X: 0, Y: 0 };
log.info(`更新当前坐标为 ${coordCache.X},${coordCache.Y}`);
coordCacheMapName = cacheMapName;
coordCacheMatchMethod = cacheMatchMethod;
needRefreshCoord = false;
}
}
return coordCache;
}
/**
* 解析数值类型配置项
* @param {*} value 配置原始值(可能是字符串、数字、undefined、null)
* @param {number} defaultVal 默认值
* @returns {number} 若 value 为空字符串/undefined/null 或转换后为 NaN,返回 defaultVal;否则返回转换后的数值(包含 0)
*/
function parseNumericSetting(value, defaultVal) {
if (value === undefined || value === null || value === '') return defaultVal;
const n = Number(value);
return isNaN(n) ? defaultVal : n;
}
/**
* 解析非负整数配置项
* @param {*} value 配置原始值
* @returns {number} 有效的非负整数,否则返回 0
*/
function parseNonNegativeIntegerSetting(value) {
const n = Number(value);
return Number.isInteger(n) && n >= 0 ? n : 0;
}
/**
* 切换队伍
* @param {string} partyName 目标队伍名称,若为空则仅返回主界面
* @returns {Promise<boolean>} true 表示成功,false 表示失败
*/
async function switchPartyIfNeeded(partyName) {
if (!partyName) {
await genshin.returnMainUi();
return true;
}
// 如果没有配置队伍校验,使用原有逻辑
if (!validateTeamMembers || validateTeamMembers.length === 0) {
try {
log.info("正在尝试切换至" + partyName);
if (!await genshin.switchParty(partyName)) {
log.info("切换队伍失败,前往七天神像重试");
await genshin.tpToStatueOfTheSeven();
await genshin.switchParty(partyName);
}
} catch {
log.error("队伍切换失败,可能处于联机模式或其他不可切换状态");
notification.error(`队伍切换失败,可能处于联机模式或其他不可切换状态`);
await genshin.returnMainUi();
}
return true;
}
// 有队伍校验配置,执行校验逻辑
const maxRetries = 3;
let lastValidationResult = null;
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
log.info(`正在尝试切换至${partyName}(第${attempt}次)`);
if (!await genshin.switchParty(partyName)) {
log.info("切换队伍失败,前往七天神像重试");
await genshin.tpToStatueOfTheSeven();
await genshin.switchParty(partyName);
}
// 校验队伍成员
const validationResult = await validateTeamMembersInParty(validateTeamMembers);
lastValidationResult = validationResult;
if (validationResult.success) {
log.info("队伍校验通过:" + validationResult.currentTeam.join("、"));
return true;
} else {
const expectedStr = validateTeamMembers.join("、");
const actualStr = validationResult.currentTeam.join("、");
log.warn(`队伍${partyName}预期包含角色${expectedStr},实际包含角色${actualStr},与预期不符(第${attempt}次)`);
if (attempt < maxRetries) {
log.warn("将重新尝试切换队伍...");
await sleep(1000);
}
}
} catch (error) {
log.error(`队伍切换或校验异常(第${attempt}次):${error.message}`);
if (attempt < maxRetries) {
await sleep(1000);
}
}
}
// 3次重试后仍失败
const expectedStr = validateTeamMembers.join("、");
const actualStr = lastValidationResult?.currentTeam?.join("、") || "未知";
const errorMsg = `队伍${partyName}预期包含角色${expectedStr},实际包含角色${actualStr},与预期不符(已重试${maxRetries}次)`;
log.error(errorMsg);
notification.error(errorMsg);
return false;
}
/**
* 校验队伍成员是否都在当前队伍中
* @param {string[]} requiredMembers 需要校验的角色列表
* @returns {Promise<{success: boolean, currentTeam: string[], missing: string[]}>}
*/
async function validateTeamMembersInParty(requiredMembers) {
const avatars = Array.from(getAvatars?.() || []);
const missing = requiredMembers.filter(name => !avatars.includes(name));
return {
success: missing.length === 0,
currentTeam: avatars,
missing: missing
};
}
/**
* 判断当前是否位于主界面
* @param {number} [maxDuration=10] 最大允许耗时(毫秒)
* @returns {Promise<boolean>} 是否在主界面
*/
async function isMainUI(maxDuration = MAIN_UI_CHECK_TIMEOUT_MS) {
const start = Date.now();
while (Date.now() - start < maxDuration) {
try {
const result = (await getGameRegion()).find(mainUIRo);
if (result.isExist()) return true;
} catch (error) {
log.error(`识别图像时发生异常: ${error.message}`);
return false; // 一旦出现异常直接退出,不再重试
}
await sleep(checkDelay); // 识别间隔
}
/* 超时仍未识别到,返回失败 */
return false;
}
/**
* 判断当前是否存在拾取滚轮图标
* @param {number} [maxDuration=10] 最大允许耗时(毫秒)
* @returns {Promise<boolean>} 是否存在滚轮图标
*/
async function hasScroll(maxDuration = MAIN_UI_CHECK_TIMEOUT_MS) {
const start = Date.now();
while (Date.now() - start < maxDuration) {
try {
const result = (await getGameRegion()).find(scrollRo);
if (result.isExist()) return true;
} catch (error) {
log.error(`识别图像时发生异常: ${error.message}`);
return false; // 一旦出现异常直接退出,不再重试
}
await sleep(checkDelay); // 识别间隔
}
/* 超时仍未识别到,返回失败 */
return false;
}
/**
* 加载拾取物模板图片
* 根据 pickup_Mode 决定加载的目录:完整狗粮+材料 / 仅狗粮 / 其他
* @returns {Promise<Object[]|null>} 模板对象数组,加载失败返回 null
*/
async function loadTargetItems() {
let targetItemPath;
if (pickup_Mode === "模板匹配拾取,拾取狗粮和怪物材料") {
targetItemPath = "assets/targetItems/";
} else if (pickup_Mode === "模板匹配拾取,只拾取狗粮") {
targetItemPath = "assets/targetItems/其他/";
} else {
return null;
}
log.info("开始加载模板图片");
const items = await readFolder(targetItemPath, "png");
// 统一预加载模板
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);
it.enabled = true;
it.isMonsterMaterial = it.fullPath.includes('怪物掉落材料');
// 新增:解析括号中的阈值
const match = it.fullPath.match(/[((](.*?)[))]/); // 匹配英文或中文括号
let itsThreshold;
if (match) {
const val = parseFloat(match[1]);
itsThreshold = (!isNaN(val) && val >= 0 && val <= 1) ? val : 0.9;
} else {
itsThreshold = 0.9;
}
it.roi.Threshold = itsThreshold;
it.roi.InitTemplate();
} catch (error) { }
}
log.info("模板图片加载完成");
return items;
}
/**
* OCR 识别指定区域文本
* @param {number} centerYF 屏幕 Y 中心坐标(像素)
* @returns {Promise<string|null>} 识别到的最长文本,失败返回 null
*/
async function performOcr(centerYF) {
const { x: textX, yOffset, width: textWidth, height: textHeight } = ITEM_OCR_REGION;
const textY = centerYF + yOffset;
try {
const resList = (await getGameRegion()).findMulti(
RecognitionObject.ocr(textX, textY, textWidth, textHeight)
);
if (!resList.count) return null;
// 取最长串
let longest = resList[0];
for (let i = 1; i < resList.count; i++) {
if (resList[i].text.length > longest.text.length) longest = resList[i];
}
// 只要中文
return longest.text.replace(/[^\u4e00-\u9fa5]/g, '');
} catch (e) {
log.error(`OCR异常: ${e.message}`);
return null;
}
}
/**
* 递归读取目录下所有文件
* @param {string} folderPath 起始目录
* @param {string} [ext=''] 需要的文件后缀,空字符串表示不限制;例如 'json' 或 '.json' 均可
* @returns {Array<{fullPath:string, fileName:string, folderPathArray:string[]}>}
*/
async function readFolder(folderPath, ext = '') {
// 统一后缀格式:确保前面有一个点,且全小写
const targetExt = ext ? (ext.startsWith('.') ? ext : `.${ext}`).toLowerCase() : '';
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); // 子目录稍后处理
} else {
// 后缀过滤
if (targetExt) {
const fileExt = filePath.toLowerCase().slice(filePath.lastIndexOf('.'));
if (fileExt !== targetExt) continue;
}
const fileName = filePath.split('\\').pop();
const folderPathArray = filePath.split('\\').slice(0, -1);
files.push({ fullPath: filePath, fileName, folderPathArray });
}
}
// 保持同层顺序,reverse 后仍按原顺序入栈
folderStack.push(...subFolders.reverse());
}
return files;
}
/**
* 伪造 BetterGenshinImpact 的js/地图追踪日志
* 1. 执行地图追踪等任务时,输出日志来让日志分析可以看到地图追踪的信息。
* 2. 支持两种任务类型:JS 脚本 与 地图追踪任务(通过 isJs 切换)。
* 3. 支持可选耗时统计,仅在“结束”时拼接到日志中。
*
* 参数:
* @param {string} name 任务名称,会原样输出到日志里
* @param {boolean} isStart true → 开始日志;false → 结束日志
* @param {number} [duration=0] 耗时(毫秒),仅在结束日志中用到;为 0 时不显示耗时
* @param {boolean} [isJs=false] 任务类型:true 为 JS 脚本,false 为地图追踪任务
*
* 示例:
* // 地图追踪开始
* await fakeLog('采集路线', true);
*
* // JS 脚本结束,耗时 12.5 秒
* await fakeLog('自动钓鱼', false, 12500, true);
*/
async function fakeLog(name, isStart, duration = 0, isJs = false) {
await sleep(1);
const currentTime = Date.now();
/* ---------------- 时间格式化 ---------------- */
const t = new Date(currentTime);
const hh = String(t.getHours()).padStart(2, '0');
const mm = String(t.getMinutes()).padStart(2, '0');
const ss = String(t.getSeconds()).padStart(2, '0');
const msec = String(t.getMilliseconds()).padStart(3, '0');
const formattedTime = `${hh}:${mm}:${ss}.${msec}`;
/* ---------------- 耗时格式化(仅结束用) ---------------- */
const totalSec = duration / 1000;
const durationMinutes = Math.floor(totalSec / 60);
const durationSeconds = (totalSec % 60).toFixed(3);
/* ---------------- 四分支,输出与旧版完全一致 ---------------- */
if (isJs && isStart) {
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) {
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) {
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) {
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} timeRule - 时间规则字符串,格式如 "8, 8-11, 23:11-23:55"
* @param {number} [threshold=5] - 接近限制时间的阈值(分钟)
* @returns {Promise<boolean>} - 如果处于限制时间内或即将进入限制时间,则返回 true,否则返回 false
*/
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:59)
const h = Number(str);
return { h: isEnd ? h + 1 : h, m: 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;
}
}
log.info("不处于限制时间");
return false;
}
/**
* 通用找图/找RO并可选点击(支持单图片文件路径、单RO、图片文件路径数组、RO数组)
* @param {string|string[]|RecognitionObject|RecognitionObject[]} target
* @param {boolean} [doClick=true] 是否点击
* @param {number} [timeout=3000] 识别时间上限(ms)
* @param {number} [interval=50] 识别间隔(ms)
* @param {number} [retType=0] 0-返回布尔;1-返回 Region 结果
* @param {number} [preClickDelay=50] 点击前等待
* @param {number} [postClickDelay=50] 点击后等待
* @returns {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) {
try { await sleep(1); } catch (error) { break; }
// 依次尝试每一个 ro
for (const ro of ros) {
const res = (await getGameRegion()).find(ro);
if (!res.isEmpty()) { // 找到
found = res;
if (doClick) {
await sleep(preClickDelay);
res.click();
await sleep(postClickDelay);
}
break; // 成功即跳出 for
}
}
if (found) break; // 成功即跳出 while
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];
}
}