bettergi-scripts-list/repo/js/ArtifactsGroupPurchasing/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

2483 lines
101 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.

const runExtra = settings.runExtra || false;
const runExtraSnezhnaya = settings.runExtraSnezhnaya || false;
const useAllTargetImages = settings.useAllTargetImages === true || settings.useAllTargetImages === "true";
const leaveTeamRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/leaveTeam.png"));
const scrollRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/拾取滚轮.png"), 1017, 496, 1093 - 581, 581 - 496);
const kick2pRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/kickButton.png"), 1520, 277, 230, 120);
const kick3pRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/kickButton.png"), 1520, 400, 230, 120);
const kick4pRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/kickButton.png"), 1520, 527, 230, 120);
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 = 50;
let state;
let gameRegion;
let TMthreshold = +settings.TMthreshold || 0.9;
let doRunExtra = false;
let expGain = 0;
let moraGain = 0;
let skipRunning = false;
let crashType = null; // 记录炸车类型
let rideTime = new Date().toISOString(); // 记录上车时间
let enteredPlayers = []; // 记录已进入的玩家(全局变量)
let commands = []; // 命令数组(全局变量)
let runnedEnding = false;
let onlineRecord = {
lastRunTime: new Date(0).toISOString(),
todayRecords: []
};
let skipLog = false;
(async function () {
setGameMetrics(1920, 1080, 1);
dispatcher.AddTrigger(new RealtimeTimer("AutoSkip"));
// 读取运行记录
await readOnlineRecord();
await genshin.tpToStatueOfTheSeven();
await switchPartyIfNeeded(settings.partyName);
targetItems = await loadTargetItems();
if (settings.groupMode === "手动进入后运行") {
if (settings.runExtra || settings.runExtraSnezhnaya) {
expGain = await processArtifacts();
moraGain = await mora();
} else {
skipLog = true;
}
await genshin.clearPartyCache();
await runGroupPurchasing(runExtra);
} else {
if (settings.groupMode === "按照下列配置自动进入并运行") {
//直接使用自定义配置
} else {
//使用json文件覆写自定义配置
const jsonPath = "匹配信息.json";
try {
const jsonStr = file.ReadTextSync(jsonPath);
const jsonConfig = JSON.parse(jsonStr);
log.info(`成功读取并解析JSON配置文件: ${jsonPath}`);
// 设置yourIndex
if (jsonConfig.myPosition) {
settings.yourIndex = jsonConfig.myPosition;
log.info(`从JSON配置中设置yourIndex为: ${settings.yourIndex}`);
}
// 生成runningOrder(固定为"1",只给第一个人跑)
if (jsonConfig.teamMembers && Array.isArray(jsonConfig.teamMembers)) {
const sortedMembers = jsonConfig.teamMembers.sort((a, b) => parseInt(a.position) - parseInt(b.position));
const runningOrder = "1"; // 固定为"1",只给第一个人跑
settings.runningOrder = runningOrder;
log.info(`从JSON配置中设置runningOrder为: ${settings.runningOrder}`);
// 设置每个位置的UID和Name
sortedMembers.forEach(member => {
const pos = member.position;
settings[`p${pos}UID`] = member.uid;
settings[`p${pos}Name`] = member.username;
log.info(`设置${pos}号玩家: ${member.username} (${member.uid})`);
});
}
} catch (error) {
log.error(`读取或解析JSON配置文件失败: ${error.message}`);
throw new Error(`JSON配置文件错误: ${error.message}`);
}
}
//解析与输出自定义配置
const raw = settings.runningOrder || "1234";
if (!/^[1-4]+$/.test(raw)) {
throw new Error('runningOrder 只能由 1-4 的数字组成,检测到非法字符。');
}
if (new Set(raw).size !== raw.length) {
throw new Error('runningOrder 中出现了重复数字。');
}
const enteringIndex = raw.split('').map(Number);
const msg = '将依次进入' + enteringIndex.map(i => `${i}号`).join(',') + '的世界';
log.info(msg);
const yourIndex = Number(settings.yourIndex);
if (!yourIndex || yourIndex < 1 || yourIndex > 4) {
throw new Error('yourIndex 必须是 1-4 之间的数字。');
}
const pos = enteringIndex.indexOf(yourIndex) + 1; // 第几个执行
log.info(`你的序号是${yourIndex}号,将在第${pos}个执行`);
// 统一收益计算:只有房主才执行processArtifacts和mora
if (yourIndex === 1) {
expGain = await processArtifacts();
moraGain = await mora();
} else {
log.info(`不是房主(yourIndex=${yourIndex}),跳过processArtifacts和mora计算`);
skipLog = true;
}
// 按 runningOrder 依次进入世界并执行联机收尾
for (const idx of enteringIndex) {
if (skipRunning) {
break;
}
await genshin.clearPartyCache();
if (settings.usingCharacter) { await sleep(1000); keyPress(`${settings.usingCharacter}`); }
//构造加入idx号世界的autoEnter的settings
let autoEnterSettings;
if (idx === yourIndex) {
settings.forceGroupNumber = 1;//将房主强制指定为房主
// 1. 先收集真实存在的白名单
const permits = {};
let permitIndex = 1;
for (const otherIdx of [1, 2, 3, 4]) {
if (otherIdx !== yourIndex) {
const pName = settings[`p${otherIdx}Name`];
if (pName) { // 过滤掉空/undefined
permits[`nameToPermit${permitIndex}`] = pName;
permitIndex++;
}
}
}
// 2. 用真正写进去的人数作为 maxEnterCount
autoEnterSettings = {
enterMode: "等待他人进入",
permissionMode: "白名单",
timeout: 10,
maxEnterCount: Object.keys(permits).length
};
Object.assign(autoEnterSettings, permits);
enteredPlayers = [];
log.info(`等待他人进入自己世界,目标人数:${autoEnterSettings.maxEnterCount}`);
notification.send(`等待他人进入自己世界,目标人数:${autoEnterSettings.maxEnterCount}`);
} else {
settings.forceGroupNumber = 0;//取消强制指定
// 构造队员配置
autoEnterSettings = {
enterMode: "进入他人世界",
enteringUID: settings[`p${idx}UID`],
timeout: 10,
};
log.info(`将要进入序号${idx},uid为${settings[`p${idx}UID`]}的世界`);
notification.send(`将要进入序号${idx},uid为${settings[`p${idx}UID`]},名称为${settings[`p${idx}Name`]}的世界`);
}
let attempts = 0;
let enterSuccess = false;
while (attempts < 5) {
attempts++;
enterSuccess = await autoEnter(autoEnterSettings);
//队员加入后要检查房主名称
if (autoEnterSettings.enterMode === "进入他人世界" && attempts != 5) {
if (enterSuccess && await checkP1Name(settings[`p${idx}Name`])) {
notification.send(`成功进入序号${idx},uid为${settings[`p${idx}UID`]},名称为${settings[`p${idx}Name`]}的世界`);
break;
} else if (!enterSuccess) {
log.error(`尝试加入序号${idx},uid为${settings[`p${idx}UID`]},名称为${settings[`p${idx}Name`]}的世界失败`);
break;
} else {
//进入了错误的世界,退出世界并重新加入,最后一次不检查
await sleep(1000);
let leaveAttempts = 0;
while (leaveAttempts < 10) {
leaveAttempts++;
if (await getPlayerSign() === 0) {
break;
}
await keyPress("F2");
await sleep(1000);
await findAndClick(leaveTeamRo);
await sleep(1000);
keyPress("VK_ESCAPE");
await waitForMainUI(true);
await genshin.returnMainUi();
}
}
} else {
break;
}
}
//执行对应的联机狗粮
await runGroupPurchasing(false);
settings.forceGroupNumber = 0;//解除强制指定
}
//如果勾选了额外路线(联机收尾额外 或 至冬额外),且本次自动运行当过房主成功进人,在结束后再执行一次额外路线
//runExtra 形参只控制「前执行」分支;「至冬」分支读的是模块级 runExtraSnezhnaya
if ((settings.runExtra || settings.runExtraSnezhnaya) && doRunExtra) {
await runGroupPurchasing(runExtra);
}
}
// 传送回神像失败不应中断后续收尾
try {
await genshin.tpToStatueOfTheSeven();
} catch (e) {
log.warn(`传送回神像失败,跳过:${e.message}`);
}
try {
if (skipRunning && !runnedEnding) {
log.info(`本次运行启用并触发了强迫症模式,且未完成收尾路线需要重新上线`);
await sleep(10000);
// 处理运行记录和重新上线
await handleOnlineRecordAndReonline(true, crashType);
return;
}
if (!skipLog && !crashType) {
expGain = await processArtifacts() - expGain;
moraGain = await mora() - moraGain;
// 获取游戏账户名
let gameAccount = "";
try {
const jsonPath = "匹配信息.json";
const jsonStr = file.ReadTextSync(jsonPath);
const jsonConfig = JSON.parse(jsonStr);
gameAccount = jsonConfig.onlineInfo?.gameName || "";
} catch (error) {
log.error(`读取匹配信息.json失败: ${error.message}`);
}
// 使用Math.max确保收益非负
expGain = Math.max(0, expGain);
moraGain = Math.max(0, moraGain);
log.info(`${gameAccount}可获得${expGain}经验`);
notification.send(`${gameAccount}可获得${expGain}经验`);
log.info(`${gameAccount}获得${moraGain}摩拉`);
notification.send(`${gameAccount}获得${moraGain}摩拉`);
// 添加收益报告命令到全局数组
commands.push({
"command": "report-gain",
"params": {
"gameAccount": gameAccount,
"expGain": expGain,
"moraGain": moraGain
}
});
log.info(`添加收益报告命令: gameAccount=${gameAccount}, expGain=${expGain}, moraGain=${moraGain}`);
} else {
if (crashType) {
log.info(`跳过收益报告:炸车情况(类型:${crashType})`);
} else {
log.info(`跳过收益报告:手动模式未勾选runExtra或非房主`);
}
}
// 处理运行记录和重新上线
await handleOnlineRecordAndReonline(false);
} catch (error) {
log.error(`运行结束部分发生异常: ${error.message}`);
} finally {
// 无论是否发生异常或炸车,都要生成命令文件
await generateCommandFile();
}
})();
async function checkP1Name(p1Name) {
//log.info("禁用了房主名称校验,直接视为通过");
//强制禁用房主检测
return true;
}
/**
* 群收尾 / 额外路线统一入口
*
*/
async function runGroupPurchasing(runExtra) {
// ===== 1. 读取配置 =====
const p1EndingRoute = settings.p1EndingRoute || "枫丹高塔";
const p2EndingRoute = "度假村";
const p3EndingRoute = "智障厅";
const p4EndingRoute = "踏鞴砂";
const forceGroupNumber = settings.forceGroupNumber || 0;
// ===== 2. 图标模板 =====
const kickAllRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/kickAll.png"));
const confirmKickRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/confirmKick.png"));
// ===== 3. 初始化变量 =====
let _infoPoints = null;
let running = true;
// ===== 4. 主流程 =====
log.info("开始识别队伍编号");
let groupNumBer = await getPlayerSign();
if (groupNumBer !== 0) log.info(`在队伍中编号为${groupNumBer}`);
else log.info(`不处于联机模式或识别异常`);
if (forceGroupNumber != 0) {
groupNumBer = forceGroupNumber;
log.info(`将自己在队伍中的编号强制指定为${groupNumBer}`);
}
if (groupNumBer === 1) {
log.info("是1p,检测当前总人数");
const totalNumber = await findTotalNumber();
// 强迫症模式触发后直接踢人,跳过所有其他操作
if (skipRunning) {
log.info(`强迫症模式已触发,直接执行踢出所有人操作`);
notification.send(`强迫症模式已触发,直接执行踢出所有人操作`);
} else {
await waitForReady(totalNumber);
if (skipRunning) {
log.info(`强迫症模式启用中,队友不齐或未及时到位,跳过所有路线直接踢人`);
notification.send(`强迫症模式启用中,队友不齐或未及时到位,跳过所有路线直接踢人`);
} else {
let kickFailed = false; // 标记是否出现人数异常,一旦异常后续不再踢人
const expectedNumbers = { 2: 4, 3: 3, 4: 2 }; // 存储各阶段的预期人数
for (let i = 1; i <= totalNumber; i++) {
await runEndingPath(i, false);
// 执行第2、3、4组路线后,如果设置了preKick,则踢人
if (expectedNumbers.hasOwnProperty(i)) {
if (settings.preKick && !kickFailed) {
// 调用findTotalNumber()获取当前人数
const currentTotalNumber = await findTotalNumber();
const expectedNumber = expectedNumbers[i];
// 检查是否符合预期人数
const shouldKick = currentTotalNumber === expectedNumber;
// 只有人数不符合预期时才通知
if (currentTotalNumber !== expectedNumber) {
const errorMsg = `执行${i}P路线后与预期人数不符,当前人数:${currentTotalNumber},预期人数:${expectedNumber}`;
log.error(errorMsg);
notification.error(errorMsg);
kickFailed = true;
}
// 执行踢人逻辑
if (shouldKick && !kickFailed) {
log.info(`执行${i}P路线后,踢出对应占位号`);
await findAndClick(kick2pRo);
await sleep(500);
await findAndClick(confirmKickRo);
}
// 无论是否踢人,都返回主界面
await genshin.returnMainUi();
}
}
await runEndingPath(i, true);
}
}
}
// 最后的踢出所有人操作(强迫症模式触发时也会执行)
let kickAttempts = 0;
while (kickAttempts < 10) {
kickAttempts++;
await genshin.returnMainUi();
await keyPress("F2");
await sleep(500);
await findAndClick(kickAllRo);
await sleep(500);
await findAndClick(confirmKickRo);
await waitForMainUI(true);
await genshin.returnMainUi();
if (await getPlayerSign() === 0) {
await genshin.returnMainUi();
break;
}
await genshin.returnMainUi();
await sleep(10000);
}
} else if (groupNumBer > 1) {
await goToTarget(groupNumBer);
let start = new Date();
while (new Date() - start < 90 * 60 * 1000) {
// 界面稳定时才判定是否已退出世界
if (await isMainUI() && await getPlayerSign() === 0) {
break;
}
if (await waitForMainUI(false, 10 * 60 * 1000)) {
await waitForMainUI(true);
log.info("未处于单人界面,继续等待")
await genshin.returnMainUi();
}
}
if (new Date() - start >= 90 * 60 * 1000) {
log.warn("超时仍未回到主界面,主动退出");
}
let leaveAttempts = 0;
while (leaveAttempts < 10) {
if (await getPlayerSign() === 0) {
break;
}
await keyPress("F2");
await sleep(1000);
await findAndClick(leaveTeamRo);
await waitForMainUI(true);
await genshin.returnMainUi();
}
} else if (groupNumBer === 0) {
if (runExtra) {
log.info("请确保联机收尾已结束,将开始运行额外路线");
await runExtraPath("前执行");
}
if (runExtraSnezhnaya) {
log.info("请确保联机收尾已结束,将开始运行至冬额外路线");
await runExtraPath("至冬");
}
if (!runExtra && !runExtraSnezhnaya) {
log.warn("处于单人模式,不执行任何路线");
}
} else {
log.warn("角色编号识别异常")
}
running = false;
/**
* 等待所有队友(2P/3P/4P)就位
* @param {number} totalNumber 联机总人数(包含自己)
* @param {number} timeOut 最长等待毫秒
*/
async function waitForReady(totalNumber, timeOut = 300000) {
// 实际需要检测的队友编号:2 ~ totalNumber
const needCheck = totalNumber - 1; // 队友人数
const readyFlags = new Array(needCheck).fill(false); // 下标 0 代表 2P,1 代表 3P …
const startTime = Date.now();
while (Date.now() - startTime < timeOut) {
let allReady = true;
await genshin.returnMainUi();
await keyPress("M"); // 打开多人地图/界面
await sleep(2000); // 给 UI 一点加载时间
for (let i = 0; i < needCheck; i++) {
// 已就绪的队友跳过
if (readyFlags[i]) continue;
const playerIndex = i + 2; // 2P/3P/4P
const ready = await checkReady(playerIndex);
if (ready) {
log.info(`玩家 ${playerIndex}P 已就绪`);
readyFlags[i] = true;
} else {
allReady = false; // 还有没就绪的
}
}
if (allReady) {
log.info("所有队友已就绪");
if (settings.runDebug) await sleep(10000);
return true;
}
// 每轮检测后稍等,防止刷屏
await sleep(500);
}
log.warn("等待队友就绪超时");
if (!settings.disableStrictMode) {
skipRunning = true;
crashType = "waitForPlayersArrive"; // 情况2:房主超时未等到所有队员到达预期坐标
doRunExtra = false;
}
return false;
}
async function checkReady(i) {
try {
/* 1. 先把地图移到目标点位(point 来自 info.json) */
const point = await getPointByPlayer(i);
if (!point) return false;
// 把路径封装在函数内部
const map = {
2: "assets/RecognitionObject/2pInBigMap.png",
3: "assets/RecognitionObject/3pInBigMap.png",
4: "assets/RecognitionObject/4pInBigMap.png"
};
const tplPath = map[i];
if (!tplPath) {
log.error(`无效玩家编号: ${i}`);
return null;
}
const template = file.ReadImageMatSync(tplPath);
const recognitionObj = RecognitionObject.TemplateMatch(template, 0, 0, 1920, 1080);
if (await findAndClick(recognitionObj, false, 2000)) await sleep(1000);
await genshin.moveMapTo(Math.round(point.x), Math.round(point.y));
/* 3. 屏幕坐标 → 地图坐标(图标)*/
const mapZoomLevel = 2.0;
const mapScaleFactor = 2.361;
/* 计算距离的内置函数 */
function calculateDistance(iconScreenX, iconScreenY, center) {
const iconMapX = (960 - iconScreenX) * mapZoomLevel / mapScaleFactor + center.x;
const iconMapY = (540 - iconScreenY) * mapZoomLevel / mapScaleFactor + center.y;
const dx = iconMapX - point.x;
const dy = iconMapY - point.y;
return Math.sqrt(dx * dx + dy * dy);
}
/* 1. 第一次:使用目标点位作为中心点 */
await genshin.setBigMapZoomLevel(mapZoomLevel);
await sleep(500);
const pos1 = await getPlayerIconPos(i);
if (!pos1 || !pos1.found) return false;
let dist = calculateDistance(pos1.x, pos1.y, { x: point.x, y: point.y });
log.info(`玩家 ${i}P 第1次检查(目标点位中心): 距离 ${dist.toFixed(2)} m`);
if (dist <= 20) return true;
/* 2-4次:使用屏幕中心点坐标 */
for (let attempt = 2; attempt <= 4; attempt++) {
if (attempt > 2) {
await sleep(500);
}
await genshin.setBigMapZoomLevel(mapZoomLevel);
const pos = await getPlayerIconPos(i);
if (!pos || !pos.found) return false;
try {
dist = calculateDistance(pos.x, pos.y, genshin.getPositionFromBigMap());
log.info(`玩家 ${i}P 第${attempt}次检查(屏幕中心点): 距离 ${dist.toFixed(2)} m`);
if (dist <= 20) return true;
} catch (e) {
log.warn(`玩家 ${i}P 第${attempt}次检查失败: ${e.message}`);
}
}
/* 第5次:兜底逻辑 - 只有3p需要进行额外检查 */
if (i === 3) {
log.info(`玩家 ${i}P 4次检查均未通过,开始第5次兜底检查(坐标范围)`);
try {
// 加载模板图片
const topRightTemplate = file.ReadImageMatSync('assets/RecognitionObject/右上角.png');
const bottomLeftTemplate = file.ReadImageMatSync('assets/RecognitionObject/左下角.png');
// 模板匹配查找两张图片
const topRightRO = RecognitionObject.TemplateMatch(topRightTemplate, 0, 0, 1920, 1080);
const bottomLeftRO = RecognitionObject.TemplateMatch(bottomLeftTemplate, 0, 0, 1920, 1080);
const gameRegion = captureGameRegion();
const topRightRes = gameRegion.find(topRightRO);
const bottomLeftRes = gameRegion.find(bottomLeftRO);
gameRegion.dispose();
// 检查是否找到两张图片
if (!topRightRes.isExist() || !bottomLeftRes.isExist()) {
log.warn(`玩家 ${i}P 第5次检查失败: 未找到右上角.png或左下角.png`);
return false;
}
// 获取玩家图标位置
await genshin.setBigMapZoomLevel(mapZoomLevel);
const playerPos = await getPlayerIconPos(i);
if (!playerPos || !playerPos.found) {
log.warn(`玩家 ${i}P 第5次检查失败: 未找到玩家图标`);
return false;
}
// 计算矩形范围
const rectLeft = Math.min(topRightRes.x, bottomLeftRes.x);
const rectTop = Math.min(topRightRes.y, bottomLeftRes.y);
const rectRight = Math.max(topRightRes.x, bottomLeftRes.x);
const rectBottom = Math.max(topRightRes.y, bottomLeftRes.y);
// 检查玩家图标是否在矩形范围内
const playerX = playerPos.x;
const playerY = playerPos.y;
const isInRect = playerX >= rectLeft && playerX <= rectRight && playerY >= rectTop && playerY <= rectBottom;
if (isInRect) {
log.info(`玩家 ${i}P 第5次检查(坐标范围)成功: 玩家图标在指定矩形范围内`);
return true;
} else {
log.info(`玩家 ${i}P 第5次检查(坐标范围)失败: 玩家图标不在指定矩形范围内`);
log.info(`矩形范围: 左=${rectLeft}, 上=${rectTop}, 右=${rectRight}, 下=${rectBottom}`);
log.info(`玩家位置: x=${playerX}, y=${playerY}`);
}
} catch (e) {
log.warn(`玩家 ${i}P 第5次检查失败: ${e.message}`);
}
}
log.info(`玩家 ${i}P 所有检查均未通过`);
return false;
} catch (error) {
log.error(error.message);
return false;
}
}
/**
* 根据玩家编号返回该路线在 assets/info.json 中记录的点位坐标
* @param {number} playerIndex 1 | 2 | 3 | 4
* @returns {{x:number,y:number}|null}
*/
async function getPointByPlayer(playerIndex) {
// 1. 只读一次:第一次调用时加载并缓存
if (_infoPoints === null) {
try {
const jsonStr = file.ReadTextSync('assets/info.json');
_infoPoints = JSON.parse(jsonStr);
if (!Array.isArray(_infoPoints)) {
log.error('assets/info.json 不是数组格式');
_infoPoints = []; // 防止后续再读
return null;
}
} catch (err) {
log.error(`读取或解析 assets/info.json 失败: ${err.message}`);
_infoPoints = [];
return null;
}
}
// 2. 外部已准备好的路线名称映射
const routeMap = {
1: p1EndingRoute,
2: p2EndingRoute,
3: p3EndingRoute,
4: p4EndingRoute
};
const routeName = routeMap[playerIndex];
if (!routeName) {
log.error(`无效玩家编号: ${playerIndex}`);
return null;
}
// 3. 遍历缓存数组
for (let i = 0; i < _infoPoints.length; i++) {
const p = _infoPoints[i];
if (p && p.name === routeName) {
return { x: p.position.x, y: p.position.y };
}
}
log.warn(`在 info.json 中找不到 name 为 "${routeName}" 的点`);
return null;
}
/**
* 根据玩家编号获取 2/3/4P 图标在屏幕上的坐标
* @param {number} playerIndex 2 | 3 | 4
* @param {number} timeout 最长查找毫秒,默认 2000
* @returns {Promise<{x:number,y:number,width:number,height:number,found:boolean}|null>}
* found=true 时坐标有效;未找到/取消/异常返回 null
*/
async function getPlayerIconPos(playerIndex, timeout = 2000) {
// 把路径封装在函数内部
const map = {
2: "assets/RecognitionObject/2pInBigMap.png",
3: "assets/RecognitionObject/3pInBigMap.png",
4: "assets/RecognitionObject/4pInBigMap.png"
};
const tplPath = map[playerIndex];
if (!tplPath) {
log.error(`无效玩家编号: ${playerIndex}`);
return null;
}
const template = file.ReadImageMatSync(tplPath);
const recognitionObj = RecognitionObject.TemplateMatch(template, 0, 0, 1920, 1080); // 全屏查找,可自行改区域
const start = Date.now();
while (Date.now() - start < timeout) {
let gameRegion = null;
try {
gameRegion = captureGameRegion();
const res = gameRegion.find(recognitionObj);
if (res.isExist()) {
log.info(`${playerIndex}P,在屏幕上的坐标为(${res.x + 10},${res.y + 10})`);//图标大小为20*20
return {
x: res.x + 10,
y: res.y + 10,
found: true
};
}
} catch (e) {
log.error(`模板匹配异常: ${e.message}`);
return null;
} finally {
if (gameRegion) gameRegion.dispose();
}
await sleep(100);
}
return null;
}
/**
* 根据玩家编号执行执行路线的全部 JSON 文件
* @param {number} i 1 | 2 | 3 | 4
*/
async function runEndingPath(i, isAfterKick = false) {
const routeMap = {
1: p1EndingRoute,
2: p2EndingRoute,
3: p3EndingRoute,
4: p4EndingRoute
};
const folderName = routeMap[i];
if (!folderName) {
log.error(`无效玩家编号: ${i}`);
return;
}
const folderPath = `assets/ArtifactsPath/${folderName}/${isAfterKick ? '后执行' : '前执行'}`;
const files = await readFolder(folderPath, ".json");
if (files.length === 0) {
log.warn(`文件夹 ${folderPath} 下未找到任何 JSON 路线文件`);
return;
}
runnedEnding = true;
if (!settings.runDebug) {
for (const { fullPath } of files) {
await runPath(fullPath, 1);
}
log.info(`${folderName} 的全部路线已完成`);
} else {
log.info("当前为调试模式,跳过执行路线");
}
}
/**
* 执行额外路线
*/
async function runExtraPath(folderName = "前执行") {
const folderPath = `assets/ArtifactsPath/额外/${folderName}`;
const files = await readFolder(folderPath, ".json");
if (files.length === 0) {
log.warn(`文件夹 ${folderPath} 下未找到任何 JSON 路线文件`);
return;
}
if (skipRunning) {
log.info(`强迫症模式启用中,队友不齐或未及时到位,跳过所有路线`);
notification.send(`强迫症模式启用中,队友不齐或未及时到位,跳过所有路线`);
await sleep(10000);
return;
}
if (!settings.runDebug) {
for (const { fullPath } of files) {
await runPath(fullPath, 1);
}
log.info(`额外 的全部路线已完成`);
} else {
log.info("当前为调试模式,跳过执行路线");
}
}
/**
* 根据玩家编号执行占位路线的全部 JSON 文件
* @param {number} i 1 | 2 | 3 | 4
*/
async function goToTarget(i) {
const routeMap = {
1: p1EndingRoute,
2: p2EndingRoute,
3: p3EndingRoute,
4: p4EndingRoute
};
const folderName = routeMap[i];
if (!folderName) {
log.error(`无效玩家编号: ${i}`);
return;
}
const folderPath = `assets/ArtifactsPath/${folderName}/占位`;
const files = await readFolder(folderPath, ".json");
if (files.length === 0) {
log.warn(`文件夹 ${folderPath} 下未找到任何 JSON 路线文件`);
}
for (const { fullPath } of files) {
await runPath(fullPath, 1);
}
try {
const pos = await genshin.getPositionFromMap();
const dist = Math.hypot(pos.x - 2297.3, pos.y + 823.8);
if (dist && dist < 100) {
log.warn("仍然在七天神像附近,尝试重跑至多一次");
for (const { fullPath } of files) {
await runPath(fullPath, 1);
}
}
} catch (error) {
}
log.info(`${folderName} 的全部路线已完成`);
}
}
/**
* 自动联机脚本(整体打包为一个函数)
* @param {Object} autoEnterSettings 配置对象
* enterMode: "进入他人世界" | "等待他人进入"
* enteringUID: string | null
* permissionMode: "无条件通过" | "白名单"
* nameToPermit1/2/3: string | null
* timeout: 分钟
* maxEnterCount: number
*/
async function autoEnter(autoEnterSettings) {
// ===== 配置解析 =====
const enterMode = autoEnterSettings.enterMode || "进入他人世界";
const enteringUID = autoEnterSettings.enteringUID;
const permissionMode = autoEnterSettings.permissionMode || "无条件通过";
const timeout = +autoEnterSettings.timeout || 10;
const maxEnterCount = +autoEnterSettings.maxEnterCount || 3;
// 白名单
const targetList = [];
[autoEnterSettings.nameToPermit1, autoEnterSettings.nameToPermit2, autoEnterSettings.nameToPermit3]
.forEach(v => v && targetList.push(v));
// ===== 模板 / 路径 =====
const enterUIDRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/enterUID.png"));
const searchRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/search.png"));
const requestEnterRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/requestEnter.png"));
const requestEnter2Ro = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/requestEnter.png"), 1480, 300, 280, 600);
const yUIRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/yUI.png"));
const allowEnterRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/allowEnter.png"));
const targetsPath = "targets";
// ===== 状态 =====
let enterCount = 0;
let targetsRo = [];
let success = false;
// 倒计时7s;静默期间循环仍在按 Y 接人,有新的同意就重置倒计时。
const COUNT_SETTLE_MS = 7000;
let lastAcceptAt = 0; // 最近一次同意成功的时刻
// ===== 初始化 =====
setGameMetrics(1920, 1080, 1);
const start = new Date();
log.info(`当前模式为:${enterMode}`);
// 加载目标 PNG(按 baseName 从长到短排序,避免短名称先匹配)
// 忽略以"备注"结尾的图片
const targetPngs = await readFolder(targetsPath, ".png");
for (const f of targetPngs) {
const baseName = f.fileName.replace(/\.png$/i, '');
// 跳过以"备注"结尾的图片
if (baseName.endsWith("备注")) {
log.info(`跳过备注图片: ${baseName}`);
continue;
}
const mat = file.ReadImageMatSync(f.fullPath);
const ro = RecognitionObject.TemplateMatch(mat, 664, 481, 1355 - 668, 588 - 484);
targetsRo.push({ ro, baseName });
}
targetsRo.sort((a, b) => b.baseName.length - a.baseName.length);
log.info(`加载完成共 ${targetsRo.length} 个目标`);
const selectedTargets = useAllTargetImages
? mapAllTemplatesToClosestNames(targetList, targetsRo)
: selectClosestTemplates(targetList, targetsRo);
log.info(useAllTargetImages ? "放人模板匹配使用全部图片" : "放人模板匹配使用白名单名称最相似图片");
// ===== 主循环 =====
const totalTime = timeout * 60 * 1000;
let checkPoints = [false, false, false, false, false]; // 使用数组标记检查状态,分别对应20%、40%、60%、80%、90%时间点
let metExpectedCount = false; // 标记是否已成功达到预期人数并正常退出
while (new Date() - start < totalTime) {
if (enterMode === "进入他人世界") {
const playerSign = await getPlayerSign();
await sleep(500);
if (playerSign > 1) {
log.info(`加入成功,队伍编号 ${playerSign}`);
success = true;
break;
} else if (playerSign === -1) {
log.warn("队伍编号识别异常,尝试按0p处理");
}
log.info('不处于多人世界,开始尝试加入');
await genshin.returnMainUi(); await sleep(500);
if (!enteringUID) { log.error('未填写有效 UID'); break; }
await keyPress("F2"); await sleep(2000);
if (!await findAndClick(enterUIDRo)) { await genshin.returnMainUi(); continue; }
await sleep(1000); inputText(enteringUID);
await sleep(1000);
if (!await findAndClick(searchRo)) { await genshin.returnMainUi(); continue; }
await sleep(500);
if (!await confirmSearchResult()) { await genshin.returnMainUi(); log.warn("无搜索结果"); continue; }
await sleep(500);
if (!await findAndClick(requestEnterRo)) { await genshin.returnMainUi(); continue; }
const memberWaitMs = 3200 + Math.floor(Math.random() * 1001);
await waitForMainUI(true, memberWaitMs);
} else { // 等待他人进入
const playerSign = await getPlayerSign();
if (playerSign > 1) {
log.warn("处于他人世界,先尝试退出");
let leaveAttempts = 0;
while (leaveAttempts < 10) {
if (await getPlayerSign() === 0) {
break;
}
await keyPress("F2");
await sleep(1000);
await findAndClick(leaveTeamRo);
await sleep(1000);
keyPress("VK_ESCAPE");
await waitForMainUI(true);
await genshin.returnMainUi();
}
}
// 检查时间点,触发额外检测
const elapsed = new Date() - start;
const timePoints = [0.2, 0.4, 0.6, 0.8, 0.9];
for (let i = 0; i < timePoints.length; i++) {
const point = timePoints[i];
if (!checkPoints[i] && elapsed >= totalTime * point) {
checkPoints[i] = true;
log.info(`达到超时时间的 ${point * 100}%,额外进行一次检测`);
enterCount = maxEnterCount; // 强制触发检测
break;
}
}
// 继续执行,不在这里结束循环,由统一检查部分处理
if (await isYUI()) keyPress("VK_ESCAPE"); await sleep(500);
await genshin.returnMainUi();
keyPress("Y"); await sleep(250);
if (await isYUI()) {
log.info("处于 Y 界面,开始识别");
let attempts = 0;
while (attempts++ < 5) {
if (permissionMode === "无条件通过") {
if (await findAndClick(allowEnterRo)) {
doRunExtra = true;
await waitForMainUI(true, 20 * 1000);
enterCount++;
lastAcceptAt = Date.now();
break;
}
} else {
const recognition = await recognizeRequest();
const result = recognition.result;
if (result) {
if (await findAndClick(allowEnterRo)) {
await waitForMainUI(true, 20 * 1000);
enterCount++;
lastAcceptAt = Date.now();
enteredPlayers = [...new Set([...enteredPlayers, result])];
log.info(`${recognition.method}允许 ${result} 加入`);
notification.send(`${recognition.method}允许 ${result} 加入`);
doRunExtra = true;
if (await isYUI()) { keyPress("VK_ESCAPE"); await sleep(500); await genshin.returnMainUi(); }
break;
} else {
if (await isYUI()) { keyPress("VK_ESCAPE"); await sleep(500); await genshin.returnMainUi(); }
}
}
}
await sleep(500);
}
if (await isYUI()) { keyPress("VK_ESCAPE"); await genshin.returnMainUi(); }
}
if (enterCount >= maxEnterCount) {
// 最后一次同意后静默 7s 数一次人数(静默期间继续接人,有新的同意就重新计时)
const quietMs = Date.now() - lastAcceptAt;
if (quietMs >= COUNT_SETTLE_MS) {
const totalNumber = await findTotalNumber();
if (totalNumber === maxEnterCount + 1) {
notification.send(`已达到预定人数:${maxEnterCount + 1}`);
metExpectedCount = true;
break;
} else {
// 按实际人数回填计数,上限为 maxEnterCount - 1
enterCount = Math.min(Math.max(0, totalNumber - 1), maxEnterCount - 1);
}
}
}
}
}
if (!metExpectedCount && new Date() - start >= timeout * 60 * 1000) {
if (enterMode === "进入他人世界") {
log.warn("队员超时未能进入房主世界");
notification.error(`队员超时未能进入房主世界`);
if (!settings.disableStrictMode) {
skipRunning = true;
crashType = "playerTimeoutEnterWorld"; // 情况3:队员超时未能进入房主世界
doRunExtra = false;
}
} else {
log.warn("超时未达到预定人数");
notification.error(`超时未达到预定人数`);
if (!settings.disableStrictMode) {
skipRunning = true;
crashType = "waitForExpectedPlayers"; // 情况1:房主超时未等到预期人数
doRunExtra = false;
}
}
}
async function confirmSearchResult() {
for (let i = 0; i < 4; i++) {
const gameRegion = captureGameRegion();
const res = gameRegion.find(requestEnter2Ro);
gameRegion.dispose();
if (res.isExist()) return false;
if (i < 4) await sleep(250);
}
return true;
}
async function isYUI() {
for (let i = 0; i < 5; i++) {
const gameRegion = captureGameRegion();
const res = gameRegion.find(yUIRo);
gameRegion.dispose();
if (res.isExist()) return true;
await sleep(250);
}
return false;
}
async function recognizeRequest() {
try {
const gameRegion = captureGameRegion();
const matched = [];
for (const { ro, targetName, nameSimilarity } of selectedTargets) {
if (gameRegion.find(ro).isExist()) {
matched.push({ name: targetName, nameSimilarity });
}
}
gameRegion.dispose();
if (matched.length > 0) {
// 同时匹配到多张图片时,优先选择名称相似度更高且尚未进入的目标
matched.sort((a, b) => b.nameSimilarity - a.nameSimilarity);
const candidate = matched.find(item =>
targetList.includes(item.name) && !enteredPlayers.includes(item.name)
);
if (candidate) {
log.info(`模板匹配选择 ${candidate.name},文件名相似度约 ${(candidate.nameSimilarity * 100).toFixed(1)}%`);
return { method: '模板匹配', result: candidate.name };
}
}
} catch { }
try {
const gameRegion = captureGameRegion();
const resList = gameRegion.findMulti(RecognitionObject.ocr(664, 481, 1355 - 668, 588 - 484));
gameRegion.dispose();
let hit = null;
for (const res of resList) {
const txt = res.text.trim();
if (targetList.includes(txt)) { hit = txt; break; }
}
if (!hit) resList.forEach(r => log.warn(`识别到"${r.text.trim()}",不在白名单`));
return { method: 'OCR识别', result: hit };
} catch { return { method: '无', result: null }; }
}
// 为每个白名单名称选择文件名最相近的模板,避免依赖完全一致的文件名
function selectClosestTemplates(names, templates) {
const pairs = [];
for (const targetName of names) {
for (let i = 0; i < templates.length; i++) {
pairs.push({
targetName,
templateIndex: i,
nameSimilarity: stringSimilarity(targetName, templates[i].baseName)
});
}
}
pairs.sort((a, b) =>
b.nameSimilarity - a.nameSimilarity || a.templateIndex - b.templateIndex
);
const usedNames = new Set();
const usedTemplates = new Set();
const selected = [];
for (const pair of pairs) {
if (usedNames.has(pair.targetName) || usedTemplates.has(pair.templateIndex)) continue;
usedNames.add(pair.targetName);
usedTemplates.add(pair.templateIndex);
selected.push({
...templates[pair.templateIndex],
targetName: pair.targetName,
nameSimilarity: pair.nameSimilarity
});
log.info(`白名单 ${pair.targetName} 使用模板 ${templates[pair.templateIndex].baseName},文件名相似度 ${(pair.nameSimilarity * 100).toFixed(1)}%`);
}
return selected;
}
// 全部图片模式:每张图片都参与匹配,但将其归属到文件名最相近的白名单名称
function mapAllTemplatesToClosestNames(names, templates) {
return templates.map(template => {
let targetName = null;
let nameSimilarity = 0;
for (const name of names) {
const similarity = stringSimilarity(name, template.baseName);
if (similarity > nameSimilarity) {
targetName = name;
nameSimilarity = similarity;
}
}
return { ...template, targetName, nameSimilarity };
});
}
// 使用归一化编辑距离计算两个名称的相似度,结果范围为 0-1
function stringSimilarity(left, right) {
const a = [...String(left || '').toLocaleLowerCase().replace(/\s+/g, '')];
const b = [...String(right || '').toLocaleLowerCase().replace(/\s+/g, '')];
if (a.join('') === b.join('')) return 1;
if (!a.length || !b.length) return 0;
const previous = Array.from({ length: b.length + 1 }, (_, i) => i);
for (let i = 1; i <= a.length; i++) {
const current = [i];
for (let j = 1; j <= b.length; j++) {
current[j] = a[i - 1] === b[j - 1]
? previous[j - 1]
: Math.min(previous[j - 1], previous[j], current[j - 1]) + 1;
}
for (let j = 0; j <= b.length; j++) previous[j] = current[j];
}
return 1 - previous[b.length] / Math.max(a.length, b.length);
}
return success;
}
//切换队伍
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();
}
}
/**
* 通用找图/找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;
}
}
//等待主界面状态
async function waitForMainUI(requirement, timeOut = 60 * 1000) {
log.info(`等待至多${timeOut}毫秒`)
const startTime = Date.now();
let logcount = 0;
while (Date.now() - startTime < timeOut) {
const mainUIState = await isMainUI();
logcount++;
if (mainUIState === requirement) return true;
const elapsed = Date.now() - startTime;
const min = Math.floor(elapsed / 60000);
const sec = Math.floor((elapsed % 60000) / 1000);
const ms = elapsed % 1000;
if (logcount >= 50) {
logcount = 0;
log.info(`已等待 ${min}分 ${sec}秒 ${ms}毫秒`);
}
await sleep(200);
}
log.error("超时仍未到达指定状态");
return false;
}
//检查是否在主界面
async function isMainUI() {
// 修改后的图像路径
const imagePath = "assets/RecognitionObject/MainUI.png";
// 修改后的识别区域(左上角区域)
const xMin = 0;
const yMin = 0;
const width = 150; // 识别区域宽度
const height = 150; // 识别区域高度
let template = file.ReadImageMatSync(imagePath);
let recognitionObject = RecognitionObject.TemplateMatch(template, xMin, yMin, width, height);
// 尝试次数设置为 5 次
const maxAttempts = 5;
let attempts = 0;
while (attempts < maxAttempts) {
try {
let gameRegion = captureGameRegion();
let result = gameRegion.find(recognitionObject);
gameRegion.dispose();
if (result.isExist()) {
//log.info("处于主界面");
return true; // 如果找到图标,返回 true
}
} catch (error) {
log.error(`识别图像时发生异常: ${error.message}`);
return false; // 发生异常时返回 false
}
attempts++; // 增加尝试次数
await sleep(250); // 每次检测间隔 250 毫秒
}
return false; // 如果尝试次数达到上限或取消,返回 false
}
//获取联机世界的当前玩家标识
async function getPlayerSign() {
let attempts = 0;
while (attempts < 10) {
attempts++;
const picDic = {
"0P": "assets/RecognitionObject/0P.png",
"1P": "assets/RecognitionObject/1P.png",
"2P": "assets/RecognitionObject/2P.png",
"3P": "assets/RecognitionObject/3P.png",
"4P": "assets/RecognitionObject/4P.png"
}
await genshin.returnMainUi();
await sleep(500);
const p0Ro = RecognitionObject.TemplateMatch(file.ReadImageMatSync(picDic["0P"]), 200, 10, 400, 70);
p0Ro.Threshold = 0.95;
p0Ro.InitTemplate();
const p1Ro = RecognitionObject.TemplateMatch(file.ReadImageMatSync(picDic["1P"]), 200, 10, 400, 70);
p1Ro.Threshold = 0.95;
p1Ro.InitTemplate();
const p2Ro = RecognitionObject.TemplateMatch(file.ReadImageMatSync(picDic["2P"]), 200, 10, 400, 70);
p2Ro.Threshold = 0.95;
p2Ro.InitTemplate();
const p3Ro = RecognitionObject.TemplateMatch(file.ReadImageMatSync(picDic["3P"]), 200, 10, 400, 70);
p3Ro.Threshold = 0.95;
p3Ro.InitTemplate();
const p4Ro = RecognitionObject.TemplateMatch(file.ReadImageMatSync(picDic["4P"]), 200, 10, 400, 70);
p4Ro.Threshold = 0.95;
p4Ro.InitTemplate();
moveMouseTo(1555, 860); // 移走鼠标,防止干扰识别
const gameRegion = captureGameRegion();
// 当前页面模板匹配
let p0 = gameRegion.Find(p0Ro);
let p1 = gameRegion.Find(p1Ro);
let p2 = gameRegion.Find(p2Ro);
let p3 = gameRegion.Find(p3Ro);
let p4 = gameRegion.Find(p4Ro);
gameRegion.dispose();
if (p0.isExist()) { log.info("识别结果为0P"); return 0; }
if (p1.isExist()) { log.info("识别结果为1P"); return 1; }
if (p2.isExist()) { log.info("识别结果为2P"); return 2; }
if (p3.isExist()) { log.info("识别结果为3P"); return 3; }
if (p4.isExist()) { log.info("识别结果为4P"); return 4; }
await genshin.returnMainUi();
await sleep(250);
}
log.warn("超时仍未识别到队伍编号");
return -1;
}
async function findTotalNumber() {
await genshin.returnMainUi();
await sleep(1000);
await keyPress("F2");
await sleep(2000);
// 使用全局定义的模板
moveMouseTo(1555, 860); // 防止鼠标干扰
const gameRegion = captureGameRegion();
await sleep(200);
let count = 1; // 先算上自己
// 依次匹配 2P
if (gameRegion.Find(kick2pRo).isExist()) {
log.info("发现 2P");
count++;
}
// 依次匹配 3P
if (gameRegion.Find(kick3pRo).isExist()) {
log.info("发现 3P");
count++;
}
// 依次匹配 4P
if (gameRegion.Find(kick4pRo).isExist()) {
log.info("发现 4P");
count++;
}
gameRegion.dispose();
log.info(`当前联机世界玩家总数(含自己):${count}`);
return count;
}
// 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);
}
}
/**
* 递归读取目录下所有文件
* @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;
}
async function runPath(fullPath, targetItemPath) {
state = { running: true };
/* ---------- 主任务 ---------- */
const pathingTask = (async () => {
await genshin.returnMainUi();
log.info(`开始执行路线: ${fullPath}`);
await fakeLog(fullPath, false, true, 0);
await pathingScript.runFile(fullPath);
await fakeLog(fullPath, false, false, 0);
state.running = false;
})();
/* ---------- 伴随任务 ---------- */
const pickupTask = (async () => {
await recognizeAndInteract();
})();
const errorProcessTask = (async () => {
const revivalRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/复苏.png"));
const readingRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/readingUI.png"), 72, 22, 133 - 72, 79 - 22);
const dialogueRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/dialogueUI.png"), 187, 26, 233 - 130, 69);
let errorCheckCount = 9;
while (state.running) {
await sleep(100);
errorCheckCount++;
if (errorCheckCount > 50) {
errorCheckCount = 0;
if (await findAndClick(revivalRo, true, 2, 3)) {
log.info("识别到复苏按钮,点击复苏");
errorCheckCount = 50;
}
if (await findAndClick(readingRo, false, 2, 3)) {
log.info("识别到阅读界面,esc脱离");
await genshin.returnMainUi();
errorCheckCount = 50;
}
if (await findAndClick(dialogueRo, false, 2, 3)) {
log.info("识别到对话界面,点击进行对话");
click(960, 540);
errorCheckCount = 50;
}
}
}
})();
/* ---------- 并发等待 ---------- */
await Promise.allSettled([pathingTask, pickupTask, errorProcessTask]);
}
//加载拾取物图片
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();
//主循环
while (state.running) {
gameRegion.dispose();
gameRegion = captureGameRegion();
let centerYF = await findFIcon();
if (!centerYF) {
if (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 {
/*
log.info("识别失败,尝试截图");
await refreshTargetItems(centerYF);
lastItemName = "";
*/
}
if (!foundTarget) {
//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 targetItems) {
//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;
}
}
async function processArtifacts() {
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 outDatedRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/RecognitionObject/ConfirmButton.png"), 760, 700, 100, 100);
await genshin.returnMainUi();
await sleep(500);
let result = 0;
try {
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 enterAttempts = 0;
await sleep(500);
while (enterAttempts < 10) {
const type = "圣遗物";
const clicked = await findAndClick([
`assets/RecognitionObject/背包界面/${type}1.png`,
`assets/RecognitionObject/背包界面/${type}2.png`,
`assets/RecognitionObject/背包界面/${type}3.png`
]);
if (clicked) break; // 找到并点击成功就退出循环
keyPress("E");
await sleep(750);
enterAttempts++;
await genshin.returnMainUi();
await sleep(100);
keyPress("B");
}
if (enterAttempts >= 10) {
log.warn("尝试十次未能成功进入背包界面");
notification.Send("尝试十次未能成功进入背包界面");
await genshin.returnMainUi();
return 0;
}
if (!await findAndClick(decomposeRo)) {
await genshin.returnMainUi();
return 0;
}
await sleep(1000);
// 识别已储存经验(1570-880-1650-930)
const digits = await numberTemplateMatch("assets/已储存经验数字", 1573, 885, 74, 36);
let initialValue = 0;
if (digits >= 0) {
initialValue = digits;
log.info(`已储存经验识别成功: ${initialValue}`);
} else {
log.warn(`在指定区域未识别到有效数字: ${initialValue}`);
}
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(2000);
// 当前总经验(1470-880-205-70)
const 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}`);
}
// 7. 计算分解获得经验=总经验-上次剩余
const resinExperience = Math.max(newValue - initialValue, 0);
log.info(`分解可获得经验: ${resinExperience}`);
let resultExperience = resinExperience;
if (resultExperience === 0) {
resultExperience = initialValue;
}
const result = resultExperience;
await genshin.returnMainUi();
return result;
}
}
async function mora() {
let result = 0;
let tryTimes = 0;
while (result === 0 && tryTimes < 3) {
log.info("开始尝试识别摩拉");
let enterAttempts = 0;
await genshin.returnMainUi();
await sleep(100);
keyPress("B");
await sleep(500);
while (enterAttempts < 10) {
const type = "养成道具";
const clicked = await findAndClick([
`assets/RecognitionObject/背包界面/${type}1.png`,
`assets/RecognitionObject/背包界面/${type}2.png`,
`assets/RecognitionObject/背包界面/${type}3.png`
]);
if (clicked) break; // 找到并点击成功就退出循环
keyPress("E");
await sleep(750);
enterAttempts++;
await genshin.returnMainUi();
await sleep(100);
keyPress("B");
}
if (enterAttempts >= 10) {
log.warn("尝试十次未能成功进入背包界面");
notification.Send("尝试十次未能成功进入背包界面");
await genshin.returnMainUi();
return 0;
}
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;
}
/**
* 在指定区域内,用 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);
}
/**
* 判断当前是否存在拾取滚轮图标
* @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;
}
// 读取运行记录
async function readOnlineRecord() {
// 从匹配信息.json中获取gameName作为记录文件名
let gameName = "联机记录";
try {
const jsonPath = "匹配信息.json";
const jsonStr = file.ReadTextSync(jsonPath);
const jsonConfig = JSON.parse(jsonStr);
gameName = jsonConfig.onlineInfo?.gameName || "联机记录";
} catch (error) {
log.warn(`读取匹配信息.json失败,使用默认记录文件名: ${error.message}`);
}
const recordFilePath = `records/${gameName}.json`;
try {
const recordStr = await file.readText(recordFilePath);
const record = JSON.parse(recordStr);
// 检查是否同一天(北京时间凌晨4点分界)
const lastRunTime = new Date(record.lastRunTime);
const now = new Date();
const isSameDay = isSameDayBeijing(lastRunTime, now);
if (!isSameDay) {
log.info(`上次运行时间与当前时间不在同一天,清空记录`);
onlineRecord = {
lastRunTime: new Date(0).toISOString(),
todayRecords: []
};
} else {
onlineRecord = record;
log.info(`成功读取运行记录,上次运行时间: ${onlineRecord.lastRunTime}`);
log.info(`今日运行记录数: ${onlineRecord.todayRecords.length}`);
}
} catch (error) {
log.warn(`读取运行记录文件失败: ${error.message},使用默认信息`);
onlineRecord = {
lastRunTime: new Date(0).toISOString(),
todayRecords: []
};
}
}
// 写入运行记录
async function writeOnlineRecord(isCrash) {
try {
// 读取匹配信息.json
const jsonPath = "匹配信息.json";
const jsonStr = file.ReadTextSync(jsonPath);
const jsonConfig = JSON.parse(jsonStr);
// 保留原始的notHost值,不强制修正
const isHost = parseInt(jsonConfig.myPosition) === 1;
const correctedOnlineInfo = {
...jsonConfig.onlineInfo
};
// 构造本次运行记录
const record = {
onlineInfo: correctedOnlineInfo,
isCrash: isCrash,
isHost: isHost,
endTime: new Date().toISOString()
};
// 添加到今日记录
onlineRecord.todayRecords.push(record);
onlineRecord.lastRunTime = new Date().toISOString();
// 使用匹配信息中的gameName作为记录文件名
const gameName = jsonConfig.onlineInfo?.gameName || "联机记录";
const recordFilePath = `records/${gameName}.json`;
await file.writeText(recordFilePath, JSON.stringify(onlineRecord, null, 2), false);
log.info(`成功写入运行记录文件: ${recordFilePath}`);
log.info(`本次运行${isCrash ? '炸车' : '正常结束'},结束时间: ${record.endTime}`);
log.info(`本次运行${isHost ? '是房主' : '不是房主'},记录的notHost值为: ${correctedOnlineInfo.notHost}`);
} catch (error) {
log.error(`写入运行记录文件失败: ${error.message}`);
}
}
// 处理运行记录和重新上线
async function handleOnlineRecordAndReonline(isCrash, crashType = null) {
// 写入本次运行记录到文件
await writeOnlineRecord(isCrash);
await sleep(1000);
// 如果是炸车,直接重新上线
if (isCrash) {
// autoReonline 为 0 时不上线,但仍上报炸车信息
const autoReonline = parseInt(settings.autoReonline) || 0;
if (autoReonline === 0) {
log.info(`重上线为0仅运行一次即停,炸车不再上线,仅上报炸车信息。想确保当上房主,请填大于 0 的值`);
await generateReonlineCommand(null, true, crashType, true);
return;
}
log.info(`炸车后重新上线,不消耗次数`);
// 读取匹配信息.json,保留 notHost 设置
let crashOnlineInfo = null;
try {
const jsonPath = "匹配信息.json";
const jsonStr = file.ReadTextSync(jsonPath);
const jsonConfig = JSON.parse(jsonStr);
crashOnlineInfo = jsonConfig.onlineInfo;
} catch (error) {
log.error(`炸车后读取匹配信息.json失败: ${error.message}`);
}
// 保留用户的 notHost 设置,无设置时默认 false(与正常路径一致)
if (crashOnlineInfo) {
crashOnlineInfo.notHost = crashOnlineInfo.notHost === true;
}
await generateReonlineCommand(crashOnlineInfo, true, crashType);
return;
}
// 读取匹配信息.json,获取本次的onlineInfo
let onlineInfo = null;
let jsonConfig = null;
try {
const jsonPath = "匹配信息.json";
const jsonStr = file.ReadTextSync(jsonPath);
jsonConfig = JSON.parse(jsonStr);
onlineInfo = jsonConfig.onlineInfo;
} catch (error) {
log.error(`读取匹配信息.json失败: ${error.message}`);
return;
}
// 正常结束,检查是否需要重新上线
const autoReonline = parseInt(settings.autoReonline) || 0;
// 计算正常运行的次数(不包含炸车的记录)
const normalRunCount = onlineRecord.todayRecords.filter(record => !record.isCrash).length;
log.info(`今日正常运行次数: ${normalRunCount},预定重新上线次数: ${autoReonline}`);
// 检查是否所有运行记录(不含炸车)均未当过房主
const hasBeenHost = onlineRecord.todayRecords.some(record =>
!record.isCrash && record.isHost
);
log.info(`今日是否当过房主: ${hasBeenHost}`);
// 条件1:运行次数未达标
const needReonlineByCount = normalRunCount < autoReonline;
// 条件2:未当过房主
const needReonlineByHost = !hasBeenHost;
// 停止重新上线的条件:达到预定次数且当过房主
const shouldStopReonline = normalRunCount >= autoReonline && hasBeenHost;
if (shouldStopReonline) {
log.info(`今日上线次数已达到预定次数且当过房主,不再重新上线`);
// 如果settings.afterOneDragon存在,单独启动该一条龙
if (settings.afterOneDragon) {
await generateOneDragonCommand(settings.afterOneDragon);
}
} else if (autoReonline > 0) {
log.info(`满足重新上线条件:${needReonlineByCount ? '次数未达标' : ''} ${needReonlineByCount && needReonlineByHost ? '且' : ''} ${needReonlineByHost ? '未当过房主' : ''}`);
let reonlineInfo = { ...onlineInfo };
// 根据用户明确的逻辑设置notHost
// 1. 如果上次上线勾选了不当房主,继续使用不当房主上线
if (onlineInfo.notHost) {
reonlineInfo.notHost = true;
log.info(`上次上线勾选了不当房主,继续使用不当房主上线`);
}
// 2. 如果当过了房主,则使用勾选不当房主
else if (hasBeenHost) {
reonlineInfo.notHost = true;
log.info(`今日已当过房主,使用勾选不当房主上线`);
}
// 3. 如果没当过房主,且匹配信息中没有勾选不当房主,则继续使用不勾选不当房主上线
else {
reonlineInfo.notHost = false;
log.info(`今日未当过房主,且上次未勾选不当房主,继续使用不勾选不当房主上线`);
}
// 生成重新上线命令
await generateReonlineCommand(reonlineInfo, false, null);
} else {
log.info(`autoReonline为0,不执行自动重新上线`);
// 如果settings.afterOneDragon存在,单独启动该一条龙
if (settings.afterOneDragon) {
await generateOneDragonCommand(settings.afterOneDragon);
}
}
}
// 生成重新上线命令(只添加到数组,不写入文件)
async function generateReonlineCommand(onlineInfo = null, isCrash = false, crashType = null, skipReonline = false) {
try {
// 如果没有提供onlineInfo,则从匹配信息.json中读取
if (!onlineInfo) {
const jsonPath = "匹配信息.json";
const jsonStr = file.ReadTextSync(jsonPath);
const jsonConfig = JSON.parse(jsonStr);
onlineInfo = jsonConfig.onlineInfo;
}
// 初始化命令数组
if (!commands || !Array.isArray(commands)) {
commands = [];
}
// 如果是炸车
if (isCrash) {
// 情况2:房主超时未等到所有队员到达预期坐标 - 无需报告,直接上线和启动等待一条龙
if (crashType === "waitForPlayersArrive") {
// 仅上报模式:情况2 不生成炸车报告,无内容可写
if (skipReonline) {
log.info(`仅上报模式:情况2 无炸车报告,跳过上线命令`);
return;
}
// 添加上线指令
commands.push({
"command": "online",
"params": {
"username": onlineInfo.gameName,
"uid": onlineInfo.uid,
"room": onlineInfo.targetRoom,
"notHost": onlineInfo.notHost
}
});
// 添加启动等待一条龙指令(如果存在)
if (settings.waitingOneDragon) {
commands.push({
"command": "start-dragon",
"params": {
"dragonName": settings.waitingOneDragon
}
});
log.info(`添加启动一条龙指令: ${settings.waitingOneDragon}`);
}
log.info(`情况2炸车,直接上线和启动一条龙`);
}
// 其他情况:需要报告炸车信息、上线、启动等待一条龙
else {
// 读取完整的匹配信息.json,获取teamMembers
let jsonConfig = null;
let teamMembers = [];
try {
const jsonPath = "匹配信息.json";
const jsonStr = file.ReadTextSync(jsonPath);
jsonConfig = JSON.parse(jsonStr);
teamMembers = jsonConfig.teamMembers || [];
} catch (error) {
log.error(`读取匹配信息.json失败: ${error.message}`);
}
// 构造crashInfo
let crashInfo = {
"crashType": crashType || "超时",
"rideTime": rideTime,
"rideMembers": teamMembers,
"reporter": {
"username": onlineInfo.gameName,
"uid": onlineInfo.uid,
"position": jsonConfig ? jsonConfig.myPosition : "1"
}
};
if (crashType === "waitForExpectedPlayers") {
// 情况1:房主超时未等到预期人数
crashInfo.myPosition = jsonConfig ? jsonConfig.myPosition : "1";
crashInfo.enteredPlayers = enteredPlayers || [];
// 计算未进入的玩家:从teamMembers中排除自己(房主)和已进入的玩家
const allPlayerNames = teamMembers
.filter(m => m.position !== "1") // 排除房主(位置1)
.map(m => m.username);
const enteredPlayerNames = enteredPlayers || [];
crashInfo.notEnteredPlayers = allPlayerNames.filter(name => !enteredPlayerNames.includes(name));
log.info(`炸车报告 - 已进入玩家: ${crashInfo.enteredPlayers.join(', ') || '无'}`);
log.info(`炸车报告 - 未进入玩家: ${crashInfo.notEnteredPlayers.join(', ') || '无'}`);
} else if (crashType === "waitForPlayersArrive") {
// 情况2:房主超时未等到所有队员到达预期坐标
crashInfo.myPosition = jsonConfig ? jsonConfig.myPosition : "1";
crashInfo.enteredPlayers = [];
crashInfo.notEnteredPlayers = [onlineInfo.gameName];
} else {
// 情况3:队员超时未能进入房主世界
crashInfo.myPosition = jsonConfig ? jsonConfig.myPosition : "1";
crashInfo.enteredPlayers = [];
crashInfo.notEnteredPlayers = [];
}
// 添加炸车报告指令
commands.push({
"command": "report-crash",
"params": {
"crashInfo": crashInfo,
"rideIdentifier": onlineInfo.rideIdentifier || ""
}
});
// 仅上报模式:炸车报告已生成,跳过上线和一条龙命令
if (skipReonline) {
log.info(`仅上报模式:已生成炸车报告,跳过上线和一条龙命令`);
return;
}
// 添加上线指令
commands.push({
"command": "online",
"params": {
"username": onlineInfo.gameName,
"uid": onlineInfo.uid,
"room": onlineInfo.targetRoom,
"notHost": onlineInfo.notHost
}
});
// 添加启动等待一条龙指令(如果存在)
if (settings.waitingOneDragon) {
commands.push({
"command": "start-dragon",
"params": {
"dragonName": settings.waitingOneDragon
}
});
log.info(`添加启动一条龙指令: ${settings.waitingOneDragon}`);
}
log.info(`添加炸车报告指令`);
}
}
// 正常结束且settings.waitingOneDragon存在,上线,启动等待一条龙
else if (settings.waitingOneDragon) {
commands.push({
"command": "online",
"params": {
"username": onlineInfo.gameName,
"uid": onlineInfo.uid,
"room": onlineInfo.targetRoom,
"notHost": onlineInfo.notHost
}
});
commands.push({
"command": "start-dragon",
"params": {
"dragonName": settings.waitingOneDragon
}
});
log.info(`添加启动一条龙指令: ${settings.waitingOneDragon}`);
}
// 正常结束且settings.waitingOneDragon不存在,只上线
else {
commands.push({
"command": "online",
"params": {
"username": onlineInfo.gameName,
"uid": onlineInfo.uid,
"room": onlineInfo.targetRoom,
"notHost": onlineInfo.notHost
}
});
}
log.info(`游戏名称: ${onlineInfo.gameName}`);
log.info(`UID: ${onlineInfo.uid}`);
log.info(`目标房间: ${onlineInfo.targetRoom}`);
log.info(`是否不当房主: ${onlineInfo.notHost}`);
if (isCrash) {
if (crashType === "waitForPlayersArrive") {
log.info(`情况2炸车,直接上线和启动一条龙`);
} else {
log.info(`添加了炸车报告指令`);
}
} else if (settings.waitingOneDragon) {
log.info(`启动一条龙: ${settings.waitingOneDragon}`);
}
} catch (error) {
log.error(`生成重新上线命令失败: ${error.message}`);
}
}
// 生成启动一条龙命令(只添加到数组,不写入文件)
async function generateOneDragonCommand(dragonName) {
try {
// 初始化命令数组
if (!commands || !Array.isArray(commands)) {
commands = [];
}
// 添加启动一条龙指令到数组
commands.push({
"command": "start-dragon",
"params": {
"dragonName": dragonName
}
});
log.info(`添加启动一条龙指令: ${dragonName}`);
} catch (error) {
log.error(`生成启动一条龙命令失败: ${error.message}`);
}
}
// 统一构建并写入命令文件
async function generateCommandFile() {
try {
// 如果命令数组为空,不生成文件
if (!commands || !Array.isArray(commands) || commands.length === 0) {
log.info(`命令数组为空,不生成命令文件`);
return;
}
// 根据命令数组生成命令对象
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`);
log.info(`命令数量: ${commands.length}`);
// 输出所有命令信息
commands.forEach((cmd, index) => {
log.info(`命令${index + 1}: ${cmd.command}`);
});
} catch (error) {
log.error(`生成命令文件失败: ${error.message}`);
}
}
// 判断两个时间是否为同一天(北京时间凌晨4点分界)
function isSameDayBeijing(date1, date2) {
const offset = 8 * 60 * 60 * 1000; // 北京时间UTC+8的偏移量
const boundary = 4 * 60 * 60 * 1000; // 凌晨4点
const time1 = date1.getTime() + offset;
const time2 = date2.getTime() + offset;
const day1 = Math.floor((time1 - boundary) / (24 * 60 * 60 * 1000));
const day2 = Math.floor((time2 - boundary) / (24 * 60 * 60 * 1000));
return day1 === day2;
}