bettergi-scripts-list/repo/js/AAA-Artifacts-Bulk-Supply/main.js
紅葉琥珀 2df64f1b5c
追加支持开关的至冬盗罐行者路线(默认关闭请自行开启) (#3822)
* 新增至冬罐罐额外路线(激活+收尾)的独立开关,默认关闭

- 在设置里新增两个默认关闭的勾选项:至冬额外激活、至冬额外收尾(方便后续用户跑联机)
- 勾选收尾即自动连带激活(先触发调查点冷却,再拾取狗粮)
- 并同样受联机狗粮、急速模式、每日冷却的控制

* 新增至冬额外路线资源文件

- 激活:至冬额外激活(调查点冷却触发,不拾取)
- 执行:至冬旧基捷城西/东/东北/西南 共 4 条盗罐者拾取路线
- 供上一提交新增的至冬独立开关调用

* fix: 对齐「所有额外」A/B 分轨理念:至冬全量与所有额外一致仅 A 线跑。

* AAA狗粮联机团购:同步至 v2.7.4

- 同步main.js 团购核心逻辑
- 新增「至冬罐罐」独立开关与至冬罐罐路线
- 刷新各地点路线资源,新增 RecognitionObject 识别图与 targetItems
- 补全 README 使用说明(功能原理 / 配置 / 运行原理 / 常见问题)
2026-11-11 11:12:02 +08:00

1657 lines
63 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 artifactPartyName = settings.artifactPartyName || "狗粮";//狗粮队伍名称
let combatPartyName = settings.combatPartyName;//清怪队伍名称
let minIntervalTime = settings.fastMode
? 10
: (parseInt(settings.minIntervalTime) || 1);
let maxWaitingTime = settings.maxWaitingTime || 0;//最大额外等待时间(分钟)
let forceAlternate = settings.forceAlternate;//强制交替
let onlyActivate = settings.onlyActivate;//只运行激活额外和收尾
let snezhnayaActivate = settings.snezhnayaActivate;//至冬额外激活开关
let snezhnayaExecute = settings.snezhnayaExecute;//至冬额外执行开关
let decomposeMode = settings.decomposeMode || "保留";//狗粮分解模式
let keep4Star = settings.keep4Star;//保留四星
let autoSalvage = settings.autoSalvage;//启用自动分解
let notify = settings.notify;//启用通知
let accountName = settings.accountName || "默认账户";//账户名
let tmThreshold = +settings.TMthreshold || 0.9;//拾取阈值
let pickup_Mode = settings.pickup_Mode || "模板匹配拾取";//拾取模式:模板匹配拾取(脚本自行识别) / bgi原版拾取(BetterGI自动拾取触发器)
//文件路径
const DeleteButtonRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/DeleteButton.png"));
const AutoAddButtonRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/AutoAddButton.png"));
const ConfirmButtonRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/ConfirmButton.png"));
const DestroyButtonRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/DestoryButton.png"));
const MidDestroyButtonRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/DestoryButton.png"), 900, 600, 500, 300);
const decomposeRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/decompose.png"));
const quickChooseRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/quickChoose.png"));
const confirmRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/confirm.png"));
const doDecomposeRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/doDecompose.png"));
const doDecompose2Ro = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/doDecompose2.png"));
const outdatedRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/ConfirmButton.png"), 760, 700, 100, 100);
const scrollRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/拾取滚轮.png"), 1017, 496, 1093 - 581, 581 - 496);
const normalPathA = settings.fastMode ? "" : "assets/ArtifactsPath/普通98点1号线";
const normalPathB = settings.fastMode ? "" : "assets/ArtifactsPath/普通98点2号线";
const extraPath = settings.fastMode ? "" : "assets/ArtifactsPath/额外";
const snezhnayaPath = settings.fastMode ? "" : "assets/ArtifactsPath/额外/至冬额外";//至冬额外基路径
const snezhnayaActivatePath = snezhnayaPath + "/激活";//至冬额外激活
const snezhnayaExecutePath = snezhnayaPath + "/执行";//至冬额外执行
//初始化变量
let artifactExperienceDiff = 0;
let moraDiff = 0;
let state = {};
let record = {};
let CDInfo = [];
let failcount = 0;
let autoSalvageCount = 0;
let furinaState = "unknown";
let commands = []; // 命令数组(全局变量)
let targetItems;
let pickupDelay = 100;
let timeMove = 1000;
let findFInterval = (+settings.findFInterval || 100);
if (findFInterval < 16) {
findFInterval = 16;
}
if (findFInterval > 200) {
findFInterval = 200;
}
let lastRoll = new Date();
let checkDelay = Math.round(findFInterval / 2);
let timeMoveUp = Math.round(timeMove * 0.45);
let timeMoveDown = Math.round(timeMove * 0.55);
let rollingDelay = 25;
let gameRegion;
let lastsettimeTime = 0;
(async function () {
setGameMetrics(1920, 1080, 1);
dispatcher.AddTrigger(new RealtimeTimer("AutoSkip"));
if (pickup_Mode === "bgi原版拾取") {
// bgi原版拾取模式:物品拾取由 BetterGI AutoPick 实时触发器完成,
// 触发器由 setActivatePickUp 跟随 activatePickUp 开关启停(关闭时清空并恢复 AutoSkip)
log.info("拾取模式:bgi原版拾取(由 BetterGI AutoPick 触发器完成拾取)");
}
targetItems = await loadTargetItems();
state.activatePickUp = false;
{
//校验自定义配置,从未打开过自定义配置时进行警告
if (!settings.accountName) {
for (let i = 0; i < 15; i++) {
log.warn("你从来没有打开过自定义配置,请仔细阅读readme后使用");
await sleep(1000);
}
}
}
//预处理
await readRecord(accountName);//读取记录文件
const epochTime = new Date('1970-01-01T20:00:00.000Z');
const now = new Date();
state.runningRoute = Math.floor((now - epochTime) / (24 * 60 * 60 * 1000)) % 2 === 0 ? 'A' : 'B';//根据日期奇偶数确定普通路线
state.currentParty = "";
state.cancel = false;
log.info(`今日运行${state.runningRoute}号线`);
if (state.runnedToday) {
await readCDInfo(accountName);
} else {
await readCDInfo("重置cd信息");
}
await writeCDInfo(accountName);
//更新日期信息
record.lastRunDate = new Date(Date.now() - 4 * 60 * 60 * 1000)
.toLocaleDateString('zh-CN', { timeZone: 'Asia/Shanghai', year: 'numeric', month: '2-digit', day: '2-digit' })
.replace(/\//g, '/');
await writeRecord(accountName);
//运行前按自定义配置清理狗粮
if (settings.decomposeMode === "分解(经验瓶)") {
await processArtifacts(21);
} else {
artifactExperienceDiff -= await processArtifacts(21);
}
moraDiff -= await mora();
//执行普通路线,直到预定激活开始时间
log.info("开始执行普通路线");
await runNormalPath(true);
if (state.cancel) return;
//执行激活路线
log.info("开始执行激活路线");
await runActivatePath();
if (state.cancel) return;
//执行剩余普通路线
log.info("开始执行剩余普通路线");
await runNormalPath(false);
if (state.cancel) return;
if (!onlyActivate || state.runningEndingAndExtraRoute != "收尾额外A") {
//执行收尾和额外路线
await runEndingAndExtraPath();
if (state.cancel) return;
}
//切回黑芙
if (settings.furina) {
await pathingScript.runFile('assets/furina/强制黑芙.json');
}
//运行后按自定义配置清理狗粮
artifactExperienceDiff += await processArtifacts(21);
moraDiff += await mora();
log.info(`狗粮路线获取摩拉: ${moraDiff}`);
log.info(`狗粮路线获取狗粮经验: ${artifactExperienceDiff}`);
// ========== 主流程末尾:替换原来的“修改records”区块 ==========
const todayKey = `日期:${record.lastRunDate},运行收尾路线${record.lastRunEndingRoute}`;
let merged = false;
// 先扫描数组,找同一天同收尾路线
for (let i = 0; i < record.records.length; i++) {
const line = record.records[i];
if (line && line.startsWith(todayKey)) {
// 解析原记录的经验、摩拉
const match = line.match(/狗粮经验(-?\d+),摩拉(-?\d+)/);
if (match) {
const oldExp = Number(match[1]);
const oldMora = Number(match[2]);
// 累加并取正
const newExp = Math.max(0, oldExp + artifactExperienceDiff);
const newMora = Math.max(0, oldMora + moraDiff);
record.records[i] = `${todayKey},狗粮经验${newExp},摩拉${newMora}`;
merged = true;
log.info(`检测到同日记录,已合并更新:经验 ${newExp},摩拉 ${newMora}`);
}
break; // 同一天只可能有一条,找到就停
}
}
// 如果没找到同一天,再走原来的“整体后移插新记录”逻辑
if (!merged) {
for (let i = record.records.length - 1; i > 0; i--) {
record.records[i] = record.records[i - 1];
}
record.records[0] = `${todayKey},狗粮经验${Math.max(0, artifactExperienceDiff)},摩拉${Math.max(0, moraDiff)}`;
}
// 通知与写盘保持不变
if (settings.notify) {
notification.Send(`${todayKey},狗粮经验${Math.max(0, artifactExperienceDiff)},摩拉${Math.max(0, moraDiff)}`);
}
await writeRecord(accountName);
// 只有当配置了autoOnline时才生成命令文件
if (settings.autoOnline && settings.autoOnline.trim()) {
await generateCommandFile();
} else {
log.info(`未配置autoOnline,跳过命令文件生成`);
}
})();
// 生成命令文件
async function generateCommandFile() {
try {
// 初始化命令数组
commands = [];
// 获取游戏账户名(从autoOnline配置中提取)
let gameAccount = "";
if (settings.autoOnline) {
const autoOnlineParts = settings.autoOnline.split('-');
if (autoOnlineParts.length >= 1) {
gameAccount = autoOnlineParts[0].trim();
}
}
// 如果是收尾额外A且配置了autoOnline,添加上线命令
if (state.runningEndingAndExtraRoute === "收尾额外A" && settings.autoOnline) {
const autoOnlineParts = settings.autoOnline.split('-');
if (autoOnlineParts.length >= 3) {
const username = autoOnlineParts[0].trim();
const uid = autoOnlineParts[1].trim();
const room = autoOnlineParts[2].trim();
const notHost = false;
commands.push({
"command": "online",
"params": {
"username": username,
"uid": uid,
"room": room,
"notHost": notHost
}
});
log.info(`添加上线命令: ${username}-${uid}-${room}`);
} else {
log.warn(`autoOnline配置格式不正确,需要至少包含游戏名称-UID-目标房间`);
}
}
// 添加收益报告命令
commands.push({
"command": "report-gain",
"params": {
"gameAccount": gameAccount,
"expGain": Math.max(0, artifactExperienceDiff),
"moraGain": Math.max(0, moraDiff)
}
});
log.info(`添加收益报告命令: gameAccount=${gameAccount}, expGain=${Math.max(0, artifactExperienceDiff)}, moraGain=${Math.max(0, moraDiff)}`);
// 根据命令数组生成命令对象
const commandData = {
"mojiang-command": true
};
commands.forEach((cmd, index) => {
if (index === 0) {
commandData["command"] = cmd.command;
commandData["params"] = cmd.params;
} else {
commandData[`command*${'*'.repeat(index - 1)}`] = cmd.command;
commandData[`params*${'*'.repeat(index - 1)}`] = cmd.params;
}
});
// 转换为JSON字符串
const jsonString = JSON.stringify(commandData, null, 2);
// 写入command.json文件
await file.writeText('command.json', jsonString, false);
log.info(`成功生成命令文件: command.json`);
} catch (error) {
log.error(`生成命令文件失败: ${error.message}`);
}
}
async function readRecord(configuredAccountName) {
/* ---------- 文件名合法性校验 ---------- */
const illegalCharacters = /[\\/:*?"<>|]/;
const reservedNames = [
"CON", "PRN", "AUX", "NUL",
"COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
"LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"
];
let finalAccountName = configuredAccountName;
if (configuredAccountName === "" ||
configuredAccountName.startsWith(" ") ||
configuredAccountName.endsWith(" ") ||
illegalCharacters.test(configuredAccountName) ||
reservedNames.includes(configuredAccountName.toUpperCase()) ||
configuredAccountName.length > 255
) {
log.error(`账户名 "${configuredAccountName}" 不合法,将使用默认值`);
finalAccountName = "默认账户";
await sleep(5000);
} else {
log.info(`账户名 "${configuredAccountName}" 合法`);
}
accountName = finalAccountName;
/* ---------- 读取记录文件 ---------- */
const recordFolderPath = "records/";
const recordFilePath = `records/${finalAccountName}.txt`;
const filesInSubFolder = file.ReadPathSync(recordFolderPath);
let fileExists = false;
for (const filePath of filesInSubFolder) {
if (filePath === `records\\${finalAccountName}.txt`) {
fileExists = true;
break;
}
}
/* ---------- 初始化记录对象 ---------- */
record = {
lastRunDate: "1970/01/01",
lastActivateTime: new Date("1970-01-01T20:00:00.000Z"),
lastRunEndingRoute: "收尾额外A",
records: new Array(1000).fill(""),
version: ""
};
let recordIndex = 0;
if (fileExists) {
log.info(`记录文件 ${recordFilePath} 存在`);
} else {
log.warn(`无记录文件,将使用默认数据`);
return;
}
const content = await file.readText(recordFilePath);
const lines = content.split("\n");
/* ---------- 逐行解析 ---------- */
for (const rawLine of lines) {
const line = rawLine.trim();
if (!line) continue;
/* 运行完成日期 */
if (line.startsWith("上次运行日期:")) {
record.lastRunDate = line.slice("上次运行日期:".length).trim();
}
/* 结束时间 / 激活收尾额外A时间(视为同一含义) */
let timeStr = null;
if (line.startsWith("上次结束时间:")) {
timeStr = line.slice("上次结束时间:".length).trim();
} else if (line.startsWith("上次激活收尾路线时间:")) {
timeStr = line.slice("上次激活收尾路线时间:".length).trim();
}
if (timeStr) {
const d = new Date(timeStr);
if (!isNaN(d.getTime())) {
record.lastActivateTime = d; // 保持 Date 对象
}
}
/* 收尾路线 */
if (line.startsWith("上次运行收尾路线:")) {
record.lastRunEndingRoute = line.slice("上次运行收尾路线:".length).trim();
}
if (record.lastRunEndingRoute !== "收尾额外B") {
record.lastRunEndingRoute = "收尾额外A";
}
if (line.startsWith("日期") && recordIndex < record.records.length) {
record.records[recordIndex++] = line;
}
}
log.info(`上次运行日期: ${record.lastRunDate}`);
log.info(`上次激活路线开始时间: ${record.lastActivateTime.toLocaleString()}`);
/* ---------- 读取 manifest 版本 ---------- */
try {
const manifest = JSON.parse(await file.readText("manifest.json"));
record.version = manifest.version;
log.info(`当前版本为${record.version}`);
} catch (err) {
log.error("读取或解析 manifest.json 失败:", err);
}
/* ---------- 判断今日是否运行(北京时间 04:00 分界,手动拼接 UTC 20 点) ---------- */
if (record.lastRunDate) {
const [y, m, d] = record.lastRunDate.split('/').map(Number);
// 1. 用 UTC 构造记录日期 00:00:00
const recordUtc = Date.UTC(y, m - 1, d); // 毫秒
// 2. 减 24 小时得到“前一天”
const prevUtc = recordUtc - 24 * 60 * 60 * 1000;
// 3. 从毫秒时间戳里取出 UTC 年月日
const prev = new Date(prevUtc);
const yy = prev.getUTCFullYear();
const mm = prev.getUTCMonth() + 1; // 1-based
const dd = prev.getUTCDate();
// 4. 严格按模板字符串拼成合法日期
const lastRun4AM = new Date(
`${yy}-${String(mm).padStart(2, '0')}-${String(dd).padStart(2, '0')}T20:00:00.000Z`
).getTime();
//log.info(`lastRun4AM = ${new Date(lastRun4AM).toISOString()}`);
const now = Date.now(); // 当前毫秒时间戳
//log.info(`时间差为 ${now - lastRun4AM} ms`);
if (now - lastRun4AM < 24 * 60 * 60 * 1000) {
log.info("今日已经运行过狗粮");
state.runnedToday = true;
} else {
state.runnedToday = false;
}
if (record.lastActivateTime.getTime() - lastRun4AM > 0 && state.runnedToday) {
log.info("今日已经运行过激活路线");
state.activatedToday = true;
} else {
state.activatedToday = false;
}
}
/* ---------- 计算下次可激活时间 ---------- */
if (record.lastRunEndingRoute === "收尾额外B") {
state.aimActivateTime = record.lastActivateTime;
log.info("上次运行的是收尾额外B,可直接开始激活路线");
} else if (!state.activatedToday) {
state.aimActivateTime = new Date(
record.lastActivateTime.getTime() +
24 * 60 * 60 * 1000 +
minIntervalTime * 60 * 1000
);
log.info(`上次运行的是收尾额外A,预计在 ${state.aimActivateTime.toLocaleString()} 开始激活路线`);
} else {
state.aimActivateTime = record.lastActivateTime;
log.info(` 今日已经开始过激活路线,直接开始激活路线`);
}
}
async function writeRecord(accountName) {
if (state.cancel) return;
const recordFilePath = `records/${accountName}.txt`;
const lines = [
`上次运行日期: ${record.lastRunDate}`,
`上次激活收尾路线时间: ${record.lastActivateTime.toISOString()}`,
`上次运行收尾路线: ${record.lastRunEndingRoute}`,
...record.records.filter(Boolean)
];
const content = lines.join('\n');
try {
await file.writeText(recordFilePath, content, false);
log.info(`记录已写入 ${recordFilePath}`);
} catch (e) {
log.error(`写入 ${recordFilePath} 失败:`, e);
}
}
async function processArtifacts(times = 1) {
await genshin.returnMainUi();
await sleep(500);
let result = 0;
try {
if (settings.decomposeMode === "销毁(摩拉)") {
result = await destroyArtifacts(times);
} else {
result = await decomposeArtifacts();
}
} catch (error) {
log.error(`处理狗粮分解时发生异常: ${error.message}`);
}
await genshin.returnMainUi();
return result;
async function decomposeArtifacts() {
keyPress("B");
if (await findAndClick(outdatedRo, true, 1500)) {
log.info("检测到过期物品弹窗,处理");
await sleep(1000);
}
let type = "圣遗物";
await findAndClick([`assets/RecognitionObject/背包界面/${type}1.png`, `assets/RecognitionObject/背包界面/${type}2.png`])
await sleep(500);
if (!await findAndClick(decomposeRo)) {
await genshin.returnMainUi();
return 0;
}
await sleep(1000);
// 识别已储存经验(1570-880-1650-930)
let digits = await numberTemplateMatch("assets/已储存经验数字", 1573, 885, 74, 36);
let initialValue = 0;
if (digits >= 0) {
initialValue = digits;
log.info(`已储存经验识别成功: ${initialValue}`);
} else {
log.warn(`在指定区域未识别到有效数字: ${initialValue}`);
}
let firstNumber = 0;
let firstNumber2 = 0;
if (settings.keep4Star) {
if (!await findAndClick(quickChooseRo)) {
await genshin.returnMainUi();
return 0;
}
moveMouseTo(960, 540);
await sleep(1000);
// 点击“确认选择”按钮
if (!await findAndClick(confirmRo)) {
await genshin.returnMainUi();
return 0;
}
await sleep(1000);
let match = await numberTemplateMatch("assets/分解数量数字", 100, 885, 200, 50);
match = (match - 1000) / 10000;
if (match >= 0) {
firstNumber = match;
log.info(`1-4星总数量: ${firstNumber}`);
} else {
log.info("识别失败");
}
keyPress("VK_ESCAPE");
await sleep(500);
if (!await findAndClick(decomposeRo)) {
await genshin.returnMainUi();
return 0;
}
await sleep(500);
}
if (!await findAndClick(quickChooseRo)) {
await genshin.returnMainUi();
return 0;
}
moveMouseTo(960, 540);
await sleep(1000);
if (settings.keep4Star) {
await click(370, 370);//取消选择四星
await sleep(1000);
}
// 点击“确认选择”按钮
if (!await findAndClick(confirmRo)) {
await genshin.returnMainUi();
return 0;
}
await sleep(2000);
let match2 = await numberTemplateMatch("assets/分解数量数字", 100, 885, 200, 50);
match2 = (match2 - 1000) / 10000;
if (match2 >= 0) {
firstNumber2 = match2
log.info(`分解总数是: ${firstNumber2}`);
} else {
log.info("识别失败");
}
//识别当前总经验
if (settings.notify) {
notification.Send(`当前经验如图`);
}
// 当前总经验(1470-880-205-70)
let digits2 = await numberTemplateMatch("assets/分解可获得经验数字", 1469, 899, 180, 37, 0.95, 0.85, 5, 1);
let newValue = 0;
if (digits2 >= 0) {
newValue = digits2
log.info(`当前总经验识别成功: ${newValue}`);
} else {
log.warn(`在指定区域未识别到有效数字: ${newValue}`);
}
if (settings.decomposeMode === "分解(经验瓶)") {
log.info(`用户选择了分解,执行分解`);
// 根据用户配置,分解狗粮
await sleep(1000);
// 点击分解按钮
if (!await findAndClick(doDecomposeRo)) {
await genshin.returnMainUi();
return 0;
}
await sleep(500);
// 4. "进行分解"按钮// 点击进行分解按钮
if (!await findAndClick(doDecompose2Ro)) {
await genshin.returnMainUi();
return 0;
}
await sleep(1000);
// 5. 关闭确认界面
await click(1340, 755);
await sleep(1000);
}
else {
log.info(`用户未选择分解,不执行分解`);
}
// 7. 计算分解获得经验=总经验-上次剩余
let resinExperience = Math.max(newValue - initialValue, 0);
log.info(`分解可获得经验: ${resinExperience}`);
let fourStarNum = firstNumber - firstNumber2;
if (settings.keep4Star) {
log.info(`保留的四星数量: ${fourStarNum}`);
}
let resultExperience = resinExperience;
if (resultExperience === 0) {
resultExperience = initialValue;
}
let result = resultExperience;
await genshin.returnMainUi();
return result;
}
async function destroyArtifacts(times = 1) {
await genshin.returnMainUi();
await sleep(250);
keyPress("B");
if (await findAndClick(outdatedRo)) {
log.info("检测到过期物品弹窗,处理");
await sleep(1000);
}
let type = "圣遗物";
await findAndClick([`assets/RecognitionObject/背包界面/${type}1.png`, `assets/RecognitionObject/背包界面/${type}2.png`])
try {
for (let i = 0; i < times; i++) {
// 点击摧毁
if (!await findAndClick(DeleteButtonRo)) {
await genshin.returnMainUi();
return;
}
await sleep(600);
// 点击自动添加
if (!await findAndClick(AutoAddButtonRo)) {
await genshin.returnMainUi();
return;
}
await sleep(900);
click(150, 150);
await sleep(300);
click(150, 220);
await sleep(300);
click(150, 300);
if (!settings.keep4Star) {
await sleep(300);
click(150, 370);
}
// 点击快捷放入
if (!await findAndClick(ConfirmButtonRo)) {
await genshin.returnMainUi();
return;
}
await sleep(600);
// 点击摧毁
if (!await findAndClick(DestroyButtonRo)) {
await genshin.returnMainUi();
return;
}
await sleep(600);
// 弹出页面点击摧毁
if (!await findAndClick(MidDestroyButtonRo)) {
await genshin.returnMainUi();
return;
}
await sleep(600);
click(960, 1000);// 点击空白处
await sleep(1000);
}
} catch (ex) {
log.info("背包里的圣遗物已摧毁完毕,提前结束")
} finally {
await genshin.returnMainUi();
}
}
}
async function mora() {
let result = 0;
let tryTimes = 0;
while (result === 0 && tryTimes < 3) {
await genshin.returnMainUi();
await sleep(100);
log.info("开始尝试识别摩拉");
keyPress("B");
await sleep(1500);
let type = "养成道具";
await findAndClick([`assets/RecognitionObject/背包界面/${type}1.png`, `assets/RecognitionObject/背包界面/${type}2.png`])
let moraRes = 0;
await sleep(1000);
if (settings.notify) {
notification.Send(`当前摩拉如图`);
}
const moraRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/mora.png"));
const gameRegion = captureGameRegion();
let moraX = 336;
let moraY = 1004;
try {
const result = gameRegion.find(moraRo);
if (result.isExist()) {
moraX = result.x;
moraY = result.y;
}
} catch (err) {
} finally {
gameRegion.dispose();
}
moraRes = await numberTemplateMatch("assets/背包摩拉数字", moraX, moraY, 300, 40, 0.95, 0.85, 10);
if (moraRes >= 0) {
log.info(`成功识别到摩拉数值: ${moraRes}`);
result = moraRes;
} else {
log.warn("未能识别到摩拉数值。");
}
await sleep(500);
tryTimes++;
await genshin.returnMainUi();
}
return result;
}
//切换队伍
async function switchPartyIfNeeded(partyName) {
if (!partyName) {
await genshin.returnMainUi();
return;
}
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();
}
}
/**
* 递归读取目录下所有文件
* @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;
}
//读取cd信息
async function readCDInfo(accountName) {
const CDInfoFolderPath = 'CDInfo/';
const CDInfoFilePath = `CDInfo/${accountName}.json`;
const filesInSubFolder = file.ReadPathSync(CDInfoFolderPath);
let fileExists = false;
for (const filePath of filesInSubFolder) {
if (filePath === `CDInfo\\${accountName}.json`) {
fileExists = true;
break;
}
}
if (fileExists) {
try {
const raw = await file.readText(CDInfoFilePath);
const parsed = JSON.parse(raw);
if (Array.isArray(parsed) && parsed.every(item => typeof item === 'string')) {
CDInfo = parsed;
} else {
log.warn('文件内容异常,使用默认状态');
CDInfo = [];
}
} catch (e) {
log.error(`读取或解析 ${CDInfoFilePath} 失败:`, e);
CDInfo = [];
}
} else {
CDInfo = [];
}
}
//更新cd信息
async function writeCDInfo(accountName) {
if (state.cancel) return;
const CDInfoFilePath = `CDInfo/${accountName}.json`;
await file.writeText(CDInfoFilePath, JSON.stringify(CDInfo), false);
}
/**
* 设置是否激活拾取(bgi原版拾取模式下同步启停 BetterGI AutoPick 实时触发器)
* - 开启(true):添加 AutoPick 触发器,保留 AutoSkip
* - 关闭(false):清除所有实时触发后重新开启 AutoSkip,防止 AutoPick 在非拾取路线误拾取
* 模板匹配拾取模式下无额外操作
*/
function setActivatePickUp(value) {
state.activatePickUp = value;
if (pickup_Mode !== "bgi原版拾取") return;
if (value) {
dispatcher.AddTrigger(new RealtimeTimer("AutoPick"));
} else {
dispatcher.clearAllTriggers();
dispatcher.AddTrigger(new RealtimeTimer("AutoSkip"));
}
}
//运行普通路线
async function runNormalPath(doStop) {
if (settings.fastMode) { return; }
furinaState = "unknown";
if (state.cancel) return;
const routeMap = { A: normalPathA, B: normalPathB };
const normalPath = routeMap[state.runningRoute];
const normalCombatPath = normalPath + "/清怪";
const normalExecutePath = normalPath + "/执行";
if (combatPartyName) {
log.info("填写了清怪队伍,执行清怪路线");
await runPaths(normalCombatPath, combatPartyName, doStop, "black");
}
setActivatePickUp(true);
await runPaths(normalExecutePath, artifactPartyName, doStop, "white");
setActivatePickUp(false);
}
async function runActivatePath() {
//furinaState = "unknown";
if (state.cancel) return;
if (!state.activatedToday) {
log.info("今日未执行过激活路线");
//判断收尾路线并更新record
if (new Date() >= state.aimActivateTime || record.lastRunEndingRoute === "收尾额外B") {
state.runningEndingAndExtraRoute = "收尾额外A";
} else {
state.runningEndingAndExtraRoute = "收尾额外B";
}
record.lastRunEndingRoute = state.runningEndingAndExtraRoute;
record.lastActivateTime = new Date();
await writeRecord(accountName);
} else {
log.info("今日执行过激活路线");
state.runningEndingAndExtraRoute = record.lastRunEndingRoute;
}
if (settings.fastMode) { return; }
let endingPath = state.runningEndingAndExtraRoute === "收尾额外A"
? "assets/ArtifactsPath/优先收尾路线"
: "assets/ArtifactsPath/替补收尾路线";
if (forceAlternate) {
endingPath = state.runningRoute === "A"
? "assets/ArtifactsPath/优先收尾路线"
: "assets/ArtifactsPath/替补收尾路线";
}
if (onlyActivate) {
log.warn("勾选了联机狗粮,将只激活,不执行收尾和额外路线");
endingPath = state.runningEndingAndExtraRoute === "收尾额外A"
? "assets/ArtifactsPath/联机收尾/优先收尾路线"
: "assets/ArtifactsPath/联机收尾/替补收尾路线";
if (forceAlternate) {
endingPath = state.runningRoute === "A"
? "assets/ArtifactsPath/优先收尾路线"
: "assets/ArtifactsPath/替补收尾路线";
}
}
const endingActivatePath = endingPath + "/激活";
const endingCombatPath = endingPath + "/清怪";
const endingPreparePath = endingPath + "/准备";
let extraPath = state.runningEndingAndExtraRoute === "收尾额外A"
? "assets/ArtifactsPath/额外/所有额外"
: "assets/ArtifactsPath/额外/仅12h额外";
const extraActivatePath = extraPath + "/激活";
const extraCombatPath = extraPath + "/清怪";
const extraPreparePath = extraPath + "/准备";
if (!settings.fastMode) {
if (!forceAlternate && state.runningEndingAndExtraRoute === "收尾额外A") {
await runPaths(endingActivatePath, "", false);
}
await runPaths(extraActivatePath, "", false);
await runPaths(endingPreparePath, "", false);
await runPaths(extraPreparePath, "", false);
if (combatPartyName) {
log.info("填写了清怪队伍,执行清怪路线");
await runPaths(extraCombatPath, combatPartyName, false, "black");
await runPaths(endingCombatPath, combatPartyName, false, "black");
}
if ((snezhnayaActivate || snezhnayaExecute) && state.runningEndingAndExtraRoute === "收尾额外A") {
log.info("启用至冬额外激活路线,开始执行激活");
await runPaths(snezhnayaActivatePath, "", false);
}
}
}
async function runEndingAndExtraPath() {
furinaState = "unknown";
if (state.cancel) return;
let endingPath = state.runningEndingAndExtraRoute === "收尾额外A"
? "assets/ArtifactsPath/优先收尾路线"
: "assets/ArtifactsPath/替补收尾路线";
if (forceAlternate) {
endingPath = state.runningRoute === "A"
? "assets/ArtifactsPath/优先收尾路线"
: "assets/ArtifactsPath/替补收尾路线";
}
if (onlyActivate) {
endingPath = state.runningEndingAndExtraRoute === "收尾额外A"
? "assets/ArtifactsPath/联机收尾/优先收尾路线"
: "assets/ArtifactsPath/联机收尾/替补收尾路线";
}
let extraPath = state.runningEndingAndExtraRoute === "收尾额外A"
? "assets/ArtifactsPath/额外/所有额外"
: "assets/ArtifactsPath/额外/仅12h额外";
endingPath = endingPath + "/执行";
extraPath = extraPath + "/执行";
if (settings.fastMode) {
log.info("启用了急速模式,直接运行高铁路线");
endingPath = state.runningEndingAndExtraRoute === "收尾额外A"
? "assets/ArtifactsPath/高铁/高铁1号线"
: "assets/ArtifactsPath/高铁/高铁2号线";
if (forceAlternate) {
endingPath = state.runningRoute === "A"
? "assets/ArtifactsPath/高铁/高铁1号线"
: "assets/ArtifactsPath/高铁/高铁2号线";
}
extraPath = "";
}
setActivatePickUp(true);
await runPaths(endingPath, artifactPartyName, false, "white");
await runPaths(extraPath, artifactPartyName, false, "white");
if (!settings.fastMode && snezhnayaExecute && state.runningEndingAndExtraRoute === "收尾额外A") {
log.info("启用至冬额外执行路线,开始执行收尾");
setActivatePickUp(true);
await runPaths(snezhnayaExecutePath, artifactPartyName, false, "white");
}
setActivatePickUp(false);
}
async function runPaths(folderFilePath, PartyName, doStop, furinaRequirement = "") {
if (state.cancel) return;
if (folderFilePath === "") {
return;
}
// 路线目录按配置可选,目录不存在时直接跳过,不让 ReadPathSync 产生无意义的异常日志
if (!file.IsFolder(folderFilePath)) {
return;
}
let Paths = await readFolder(folderFilePath, "json");
let furinaChecked = false;
for (let i = 0; i < Paths.length; i++) {
let skiprecord = false;
if (state.cancel) return;
if (new Date() >= state.aimActivateTime && doStop) {
log.info("已经到达预定时间");
break;
} else if ((new Date() >= (state.aimActivateTime - minIntervalTime * 60 * 1000)) && doStop) {
log.info(`即将到达预定时间,等待${state.aimActivateTime - new Date() + 1000}毫秒`);
await sleep(state.aimActivateTime - new Date() + 1000)
break;
}
const Path = Paths[i];
let success = true;
// 如果 CDInfo 数组中已存在该文件名,则跳过
if (CDInfo.includes(Path.fullPath)) {
log.info(`路线${Path.fullPath}今日已运行,跳过`);
continue;
}
if (PartyName != state.currentParty && PartyName) {
//如果与当前队伍不同,尝试切换队伍,并更新队伍
await switchPartyIfNeeded(PartyName);
state.currentParty = PartyName;
furinaState = "unknown";
}
if (settings.furina && !furinaChecked) {
furinaChecked = true;
if (furinaRequirement === "white") {
log.info("勾选了芙宁娜选项,正在强制切换芙宁娜状态为白芙");
log.warn("非必要请尽量不要勾选该选项");
await pathingScript.runFile('assets/furina/强制白芙.json');
furinaState = "white";
} else if (furinaRequirement === "black") {
log.info("勾选了芙宁娜选项,正在强制切换芙宁娜状态为黑芙");
log.warn("非必要请尽量不要勾选该选项");
await pathingScript.runFile('assets/furina/强制黑芙.json');
furinaState = "black";
}
}
if (settings.autoSalvage && autoSalvageCount >= 4) {
autoSalvageCount = 0;
if (settings.decomposeMode === "分解(经验瓶)") {
artifactExperienceDiff += await processArtifacts(1);
} else {
await processArtifacts(1);
}
} else {
autoSalvageCount++;
}
const pathInfo = await parsePathing(Path.fullPath);
let pathRes;
try {
log.info(`当前进度:${Path.fileName}为${folderFilePath}第${i + 1}/${Paths.length}个`);
pathRes = await runPath(Path.fullPath, null);
await sleep(1);
} catch (error) {
skiprecord = true;
log.error(`执行路径文件时发生错误:${error.message}`);
if (error.message === "A task was canceled.") {
log.warn("任务取消");
state.cancel = true;
}
success = false;
break;
}
if (pathRes !== undefined && typeof pathRes.success === 'boolean') {
// 新版本BGI:直接使用返回值判定路线是否成功
if (pathRes.success) {
log.info("路线运行成功");
} else {
log.error(`路线运行失败:${pathRes.message}`);
failcount++;
skiprecord = true;
await sleep(5000);
}
} else if (pathInfo.ok) {
// 旧版本BGI:静默回退到坐标校验
await genshin.returnMainUi();
await sleep(500);
const maxAttempts = 3;
let attempts = 0;
while (attempts < maxAttempts) {
try {
const cur = await genshin.getPositionFromMap(pathInfo.map_name);
const dist = Math.hypot(cur.x - pathInfo.x, cur.y - pathInfo.y);
if (dist < 50) break; // 成功跳出
attempts++;
log.warn(
`路线 ${Path.fileName} 第 ${attempts} 次检测失败 ` +
`(距离 ${dist.toFixed(2)}) —— ` +
`当前(${cur.x.toFixed(2)}, ${cur.y.toFixed(2)}) ` +
`目标(${pathInfo.x.toFixed(2)}, ${pathInfo.y.toFixed(2)})`
);
if (attempts === maxAttempts) {
failcount++;
skiprecord = true;
await sleep(5000);
break;
}
await sleep(1000);
} catch (err) {
log.error(`发生错误:${err.message}`);
skiprecord = true;
break;
}
}
}
if (!skiprecord) {
CDInfo = [...new Set([...CDInfo, Path.fullPath])];
await writeCDInfo(accountName);
}
}
if (doStop && new Date() < state.aimActivateTime) {
const maxWaitMs = settings.maxWaitingTime * 60 * 1000;
const needWaitMs = state.aimActivateTime - new Date();
if (needWaitMs <= maxWaitMs && needWaitMs > 0) {
log.info(`等待 ${needWaitMs} 毫秒到达预定时间`);
await sleep(needWaitMs);
}
}
}
async function parsePathing(pathFilePath) {
try {
const raw = await file.readText(pathFilePath);
const json = JSON.parse(raw);
// 只要 positions 不是数组就直接失败
if (!Array.isArray(json.positions)) {
log.error("文件positions字段异常");
return { ok: false };
}
// 从 info.map_name 读取,不存在时兜底为 "Teyvat"
const map_name =
typeof json.info?.map_name === 'string' && json.info.map_name.trim() !== ''
? json.info.map_name
: 'Teyvat';
// 从后往前找第一个 type !== "orientation" 的点
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'
) {
return {
ok: true,
x: p.x,
y: p.y,
map_name,
};
}
}
return { ok: false };
} catch (err) {
log.error(`解析路径文件失败: ${err.message}`);
return { ok: false };
}
}
// fakeLog 函数,使用方法:将本函数放在主函数前,调用时请务必使用await,否则可能出现v8白框报错
//在js开头处伪造该js结束运行的日志信息,如 await fakeLog("js脚本", true, true, 0);
//在js结尾处伪造该js开始运行的日志信息,如 await fakeLog("js脚本", true, false, 2333);
//duration项目仅在伪造结束信息时有效,且无实际作用,可以任意填写,当你需要在日志中输出特定值时才需要,单位为毫秒
//在调用地图追踪前伪造该地图追踪开始运行的日志信息,如 await fakeLog(`地图追踪.json`, false, true, 0);
//在调用地图追踪后伪造该地图追踪结束运行的日志信息,如 await fakeLog(`地图追踪.json`, false, false, 0);
//如此便可以在js运行过程中伪造地图追踪的日志信息,可以在日志分析等中查看
async function fakeLog(name, isJs, isStart, duration) {
await sleep(10);
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);
}
}
async function runPath(fullPath, targetItemPath = null) {
let settimeInterval = 10 * 60 * 1000;
if (settings.setTimeMode && settings.setTimeMode != "不调节时间" && (((new Date() - lastsettimeTime) > settimeInterval))) {
if (settings.setTimeMode === "尽量调为白天") {
await pathingScript.runFile("assets/调为白天.json");
} else {
await pathingScript.runFile("assets/调为夜晚.json");
}
lastsettimeTime = new Date();
}
state = state || {}; // 若已存在则保持原引用,否则新建空对象
state.running = true;
/* ---------- 主任务 ---------- */
const pathingTask = (async () => {
log.info(`开始执行路线: ${fullPath}`);
await fakeLog(fullPath, false, true, 0);
let runRes;
try {
runRes = await pathingScript.runFile(fullPath);
} catch (error) {
log.error(`执行路线 ${fullPath} 时发生错误:${error.message}`);
runRes = undefined;
}
await fakeLog(fullPath, false, false, 0);
state.running = false;
return runRes;
})();
/* ---------- 伴随任务 ---------- */
const pickupTask = (async () => {
if (state.activatePickUp) {
// bgi原版拾取模式下 recognizeAndInteract 内部仅交互"调查"(拾取由 BGI AutoPick 完成)
await recognizeAndInteract();
}
})();
const errorProcessTask = (async () => {
const revivalRo1 = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/revival.png"));
let errorCheckCount = 9;
while (state.running) {
await sleep(100);
errorCheckCount++;
if (errorCheckCount > 50) {
errorCheckCount = 0;
//log.info("尝试识别并点击复苏按钮");
if (await findAndClick(revivalRo1, true, 2, 3)) {
log.info("识别到复苏按钮,点击复苏");
}
}
}
})();
/* ---------- 并发等待 ---------- */
const results = await Promise.allSettled([pathingTask, pickupTask, errorProcessTask]);
// 返回地图追踪执行结果(旧版本BGI无返回值时返回 undefined)
return results[0].status === "fulfilled" ? results[0].value : undefined;
}
//加载拾取物图片
async function loadTargetItems() {
const targetItemPath = 'assets/targetItems'; // 固定目录
const items = await readFolder(targetItemPath, "png");
// 统一预加载模板
for (const it of items) {
it.template = file.ReadImageMatSync(it.fullPath);
it.itemName = it.fileName.replace(/\.png$/i, '');
}
return items;
}
// 定义一个函数用于拾取
async function recognizeAndInteract() {
//log.info("调试-开始执行图像识别与拾取任务");
let lastcenterYF = 0;
let lastItemName = "";
let fIcontemplate = file.ReadImageMatSync('assets/F_Dialogue.png');
let mainUITemplate = file.ReadImageMatSync("assets/MainUI.png");
let thisMoveUpTime = 0;
let lastMoveDown = 0;
gameRegion = captureGameRegion();
// 原版拾取模式:物品拾取由 BetterGI AutoPick 完成,脚本维持交互循环但仅交互"调查"
const pickTargetItems = pickup_Mode === "bgi原版拾取"
? targetItems.filter(it => it.itemName === "调查")
: targetItems;
//主循环
while (state.running) {
gameRegion.dispose();
gameRegion = captureGameRegion();
let centerYF = await findFIcon();
if (!centerYF) {
// 原版拾取模式下不执行滚轮动作(拾取由 BetterGI AutoPick 完成)
if (pickup_Mode !== "bgi原版拾取" && new Date() - lastRoll >= 200) {
lastRoll = new Date();
if (await hasScroll()) {
await keyMouseScript.runFile(`assets/滚轮下翻.json`);
}
}
continue;
}
//log.info(`调试-成功找到f图标,centerYF为${centerYF}`);
let foundTarget = false;
let itemName = await performTemplateMatch(centerYF);
if (itemName) {
//log.info(`调试-识别到物品${itemName}`);
if (Math.abs(lastcenterYF - centerYF) <= 20 && lastItemName === itemName) {
//log.info("调试-相同物品名和相近y坐标,本次不拾取");
await sleep(2 * pickupDelay);
lastcenterYF = -20;
lastItemName = null;
} else {
keyPress("F");
log.info(`交互或拾取:"${itemName}"`);
lastcenterYF = centerYF;
lastItemName = itemName;
await sleep(pickupDelay);
}
} else {
// 识别失败:等待一帧,让出事件循环,避免同步紧密循环饿死 pathingTask
await sleep(checkDelay);
/*
log.info("识别失败,尝试截图");
await refreshTargetItems(centerYF);
lastItemName = "";
*/
}
if (!foundTarget && pickup_Mode !== "bgi原版拾取") {
// 原版拾取模式下不执行滚轮动作(拾取由 BetterGI AutoPick 完成)
//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) {
try {
let result;
let itemName = null;
for (const targetItem of pickTargetItems) {
//log.info(`正在尝试匹配${targetItem.itemName}`);
const cnLen = Math.min([...targetItem.itemName].filter(c => c >= '\u4e00' && c <= '\u9fff').length, 5);
const recognitionObject = RecognitionObject.TemplateMatch(
targetItem.template,
1219,
centerYF - 15,
12 + 28 * cnLen + 2,
30
);
recognitionObject.Threshold = tmThreshold;
recognitionObject.InitTemplate();
result = gameRegion.find(recognitionObject);
if (result.isExist()) {
itemName = targetItem.itemName;
break;
}
}
return itemName;
} catch (error) {
log.error(`模板匹配时发生异常: ${error.message}`);
return null;
}
}
async function findFIcon() {
let recognitionObject = RecognitionObject.TemplateMatch(fIcontemplate, 1102, 335, 34, 400);
recognitionObject.Threshold = 0.95;
recognitionObject.InitTemplate();
try {
let result = gameRegion.find(recognitionObject);
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;
}
}
/**
* 在指定区域内,用 0-9 的 PNG 模板做「多阈值 + 非极大抑制」数字识别,
* 最终把检测到的数字按左右顺序拼成一个整数返回。
*
* @param {string} numberPngFilePath - 存放 0.png ~ 9.png 的文件夹路径(不含文件名)
* @param {number} x - 待识别区域的左上角 x 坐标,默认 0
* @param {number} y - 待识别区域的左上角 y 坐标,默认 0
* @param {number} w - 待识别区域的宽度,默认 1920
* @param {number} h - 待识别区域的高度,默认 1080
* @param {number} maxThreshold - 模板匹配起始阈值,默认 0.95(最高可信度)
* @param {number} minThreshold - 模板匹配最低阈值,默认 0.8(最低可信度)
* @param {number} splitCount - 在 maxThreshold 与 minThreshold 之间做几次等间隔阈值递减,默认 3
* @param {number} maxOverlap - 非极大抑制时允许的最大重叠像素,默认 2;只要 x 或 y 方向重叠大于该值即视为重复框
*
* @returns {number} 识别出的整数;若没有任何有效数字框则返回 -1
*
* @example
* const mora = await numberTemplateMatch('摩拉数字', 860, 70, 200, 40);
* if (mora >= 0) console.log(`当前摩拉:${mora}`);
*/
async function numberTemplateMatch(
numberPngFilePath,
x = 0, y = 0, w = 1920, h = 1080,
maxThreshold = 0.95,
minThreshold = 0.8,
splitCount = 3,
maxOverlap = 2
) {
let ros = [];
for (let i = 0; i <= 9; i++) {
ros[i] = RecognitionObject.TemplateMatch(
file.ReadImageMatSync(`${numberPngFilePath}/${i}.png`), x, y, w, h);
}
function setThreshold(roArr, newThreshold) {
for (let i = 0; i < roArr.length; i++) {
roArr[i].Threshold = newThreshold;
roArr[i].InitTemplate();
}
}
const gameRegion = captureGameRegion();
const allCandidates = [];
/* 1. splitCount 次等间隔阈值递减 */
for (let k = 0; k < splitCount; k++) {
const curThr = maxThreshold - (maxThreshold - minThreshold) * k / Math.max(splitCount - 1, 1);
setThreshold(ros, curThr);
/* 2. 0-9 每个模板跑一遍,所有框都收 */
for (let digit = 0; digit <= 9; digit++) {
const res = gameRegion.findMulti(ros[digit]);
if (res.count === 0) continue;
for (let i = 0; i < res.count; i++) {
const box = res[i];
allCandidates.push({
digit: digit,
x: box.x,
y: box.y,
w: box.width,
h: box.height,
thr: curThr
});
}
}
}
gameRegion.dispose();
/* 3. 无结果提前返回 -1 */
if (allCandidates.length === 0) {
return -1;
}
/* 4. 非极大抑制(必须 x、y 两个方向重叠都 > maxOverlap 才视为重复) */
const adopted = [];
for (const c of allCandidates) {
let overlap = false;
for (const a of adopted) {
const xOverlap = Math.max(0, Math.min(c.x + c.w, a.x + a.w) - Math.max(c.x, a.x));
const yOverlap = Math.max(0, Math.min(c.y + c.h, a.y + a.h) - Math.max(c.y, a.y));
if (xOverlap > maxOverlap && yOverlap > maxOverlap) {
overlap = true;
break;
}
}
if (!overlap) {
adopted.push(c);
//log.info(`在 [${c.x},${c.y},${c.w},${c.h}] 找到数字 ${c.digit},匹配阈值=${c.thr}`);
}
}
/* 5. 按 x 排序,拼整数;仍无有效框时返回 -1 */
if (adopted.length === 0) return -1;
adopted.sort((a, b) => a.x - b.x);
return adopted.reduce((num, item) => num * 10 + item.digit, 0);
}
/**
* 通用找图/找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) {
const gameRegion = captureGameRegion();
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 {
gameRegion.dispose();
}
await sleep(interval); // 没找到时等待
}
// 3. 按需返回
return retType === 0 ? !!found : (found || null);
} catch (error) {
log.error(`执行通用识图时出现错误:${error.message}`);
return retType === 0 ? false : null;
}
}
/**
* 判断当前是否存在拾取滚轮图标
* @param {number} maxDuration 最大允许耗时(毫秒)
*/
async function hasScroll(maxDuration = 10) {
const start = Date.now();
let dodispose = false;
while (Date.now() - start < maxDuration) {
if (!gameRegion) {
gameRegion = captureGameRegion();
dodispose = true;
}
try {
const result = gameRegion.find(scrollRo);
if (result.isExist()) return true;
} catch (error) {
log.error(`识别图像时发生异常: ${error.message}`);
return false; // 一旦出现异常直接退出,不再重试
}
await sleep(checkDelay); // 识别间隔
if (dodispose) {
gameRegion.dispose();
dodispose = false; // 已经释放,标记避免重复 dispose
}
}
/* 超时仍未识别到,返回失败 */
return false;
}