bettergi-scripts-list/repo/js/七圣召唤七日历练全自动/main.js

1213 lines
44 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.

import { reportEffiency, queryEffiency, retryFailedReports } from "./effiency.js"
const defaultReplacementMap = {
监: "盐",
卵: "卯",
刻睛: "刻晴",
};
// 存储挑战玩家信息
let textArray = [];
let skipNum = 0;
let allStrategy = {};
let fallbackStrategyList = [];
const strategyRunRecordFile = "牌组策略/各策略胜败记录.json";
let strategyRunRecord = {};
let minFallbackStrategyScore = 0.25;
const DEFAULT_STRATEGY = "雷神柯莱刻晴";
/**
* 查找模板图片并拖动到指定位置
* @param {string} templatePath - 模板图片路径
* @param {number} targetX - 拖动目标位置X坐标
* @param {number} targetY - 拖动目标位置Y坐标
* @param {number} [maxAttempts=3] - 最大尝试次数
* @returns {Promise<boolean>} 是否成功完成拖动
*/
async function dragTemplateToPosition(templatePath, targetX, targetY, maxAttempts = 3) {
// 创建模板识别对象
const templateRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync(templatePath));
await sleep(200);
moveMouseTo(100, 50);//避免鼠标遮挡
await sleep(200);
for (let attempt = 0; attempt < maxAttempts; attempt++) {
try {
// 捕获游戏区域并查找模板
const captureRegion = captureGameRegion();
let foundRegion = captureRegion.find(templateRo);
captureRegion.dispose();
if (foundRegion.isEmpty()) {
log.warn(`第 ${attempt + 1} 次尝试: 未找到模板图片 ${templatePath}`);
if (attempt < maxAttempts - 1) {
await sleep(1000); // 等待1秒后重试
continue;
} else {
log.error(`所有尝试失败: 未找到模板图片 ${templatePath}`);
return false;
}
}
log.info(`找到模板图片,位置: (${foundRegion.x}, ${foundRegion.y}),开始拖动到 (${targetX}, ${targetY})`);
await sleep(300);
moveMouseTo(200, 100);//重置鼠标位置
leftButtonDown();
await sleep(500);
moveMouseTo(foundRegion.x, foundRegion.y);
await sleep(500);
moveMouseTo(targetX, targetY);
await sleep(500);
leftButtonUp();
await sleep(500);
moveMouseTo(50, 50);//移动鼠标位置,避免检测失败
await sleep(400);
const ro2 = captureGameRegion();
foundRegion = ro2.Find(templateRo);
ro2.dispose();
log.info(`模板图片拖动后位置: (${foundRegion.x}, ${foundRegion.y})`);
if( Math.abs(foundRegion.x - targetX) < 3 && Math.abs(foundRegion.y - targetY ) < 3) {
log.info("拖动操作完成");
return true;
}
} catch (error) {
log.error(`第 ${attempt + 1} 次尝试时发生错误: ${error}`);
if (attempt < maxAttempts - 1) {
await sleep(1000);
}
}
}
return false;
}
// 切换到指定的队伍
async function switchCardTeam(Name, shareCode) {
let captureRegion = captureGameRegion();
let teamName = captureRegion.find(RecognitionObject.ocr(1305, 793, 206, 46));
captureRegion.dispose();
log.info("当前牌组名称: {text}", teamName.text);
async function selectTargetTeam(targetTeam) {
moveMouseTo(100, 200);
leftButtonDown();
// 不能一次移动太多,否则会丢拖动
for (let i = 1; i <= 9; i++) {
await sleep(50);
moveMouseTo(200 * i, 200);
}
await sleep(200);
leftButtonUp();
await sleep(1000);
captureRegion = captureGameRegion();
const ocrResults = [];
for (let i = 0; i < 4; i++) {
let x = 135 + 463 * i;
let res = captureRegion.find(RecognitionObject.ocr(x, 762, 230, 46));
let correctedText = res.text.trim();
for (let [wrongChar, correctChar] of Object.entries(defaultReplacementMap)) {
correctedText = correctedText.replace(new RegExp(wrongChar, "g"), correctChar);
}
if (correctedText === targetTeam) {
log.info("切换至牌组: {text}", correctedText);
res.click();
await sleep(500);
break;
} else {
ocrResults.push(correctedText);
}
}
captureRegion.dispose();
if (ocrResults.length === 4) {
log.error(`找不到目标牌组{0} (OCR结果: {1})。如果OCR结果中有误识别的字符,请使用字形简单的牌组名`, targetTeam, ocrResults.join(', '));
return false;
}
return true;
}
if (teamName.text != Name || settings.overwritePartyName == Name) {
click(1312, 812); //点击队伍名称的糟糕UI
await sleep(1000);
await selectTargetTeam(Name);
} else {
return true;
}
async function stopNow() {
await sleep(1000);
click(1795, 465); // 点空白处以便立即终止延时对话框
await sleep(1000);
}
let userDefault = false;
if (Name !== settings.defaultPartyName && shareCode) {
captureRegion = captureGameRegion();
let res = captureRegion.find(RecognitionObject.ocr(1140, 732, 83, 55));
captureRegion.dispose();
if (res.text === "确认") {
res.click();
} else {
click(731, 998); // 编辑牌组
}
await sleep(800);
click(1756, 48); // ... 按钮
await sleep(200);
click(1546, 178); // 使用分享码
await sleep(500);
click(960, 520); // 输入区域
await sleep(1000);
log.info("输入分享码 {0}", shareCode);
await inputText(shareCode);
await sleep(500);
click(1166, 750); // 导入
await stopNow();
click(1720, 1020); // 保存
await stopNow();
captureRegion = captureGameRegion();
res = captureRegion.find(RecognitionObject.ocr(770, 516, 381, 43));
captureRegion.dispose();
if (res.text.includes("无法出战")) {
log.error(res.text);
userDefault = true;
await sleep(500);
click(1162, 760); // 保存修改
await stopNow();
}
click(1843, 46); // 关闭
await sleep(1000);
}
if (userDefault) {
log.info("分享码导入的牌组无法出战,切换到默认牌组: {0}", settings.defaultPartyName);
const switchDefault = await selectTargetTeam(settings.defaultPartyName);
if (! switchDefault) {
log.error("切换到默认牌组失败,本次打牌无法继续");
keyPress("ESCAPE");
await sleep(1000);
return false;
}
}
click(1164, 1016); // 选择
await sleep(4000); // 等待"出战牌组"的强制延时框消失
return !userDefault;
}
/**
* 判断任务是否已刷新
* @param {string} filePath - 存储最后完成时间的文件路径
* @param {object} options - 配置选项
* @param {string} [options.refreshType] - 刷新类型: 'hourly'|'daily'|'weekly'|'monthly'|'custom'
* @param {number} [options.customHours] - 自定义小时数(用于'custom'类型)
* @param {number} [options.dailyHour=4] - 每日刷新的小时(0-23)
* @param {number} [options.weeklyDay=1] - 每周刷新的星期(0-6, 0是周日)
* @param {number} [options.weeklyHour=4] - 每周刷新的小时(0-23)
* @param {number} [options.monthlyDay=1] - 每月刷新的日期(1-31)
* @param {number} [options.monthlyHour=4] - 每月刷新的小时(0-23)
* @returns {Promise<boolean>} - 是否已刷新
*/
async function isTaskRefreshed(filePath, options = {}) {
const {
refreshType = "hourly", // 默认每小时刷新
customHours = 24, // 自定义刷新小时数默认24
dailyHour = 4, // 每日刷新默认凌晨4点
weeklyDay = 1, // 每周刷新默认周一(0是周日)
weeklyHour = 4, // 每周刷新默认凌晨4点
monthlyDay = 1, // 每月刷新默认第1天
monthlyHour = 4, // 每月刷新默认凌晨4点
} = options;
try {
// 读取文件内容
let content = await file.readText(filePath);
const lastTime = new Date(content);
const nowTime = new Date();
let shouldRefresh = false;
switch (refreshType) {
case "hourly": // 每小时刷新
shouldRefresh = nowTime - lastTime >= 3600 * 1000;
break;
case "daily": // 每天固定时间刷新
// 检查是否已经过了当天的刷新时间
const todayRefresh = new Date(nowTime);
todayRefresh.setHours(dailyHour, 0, 0, 0);
// 如果当前时间已经过了今天的刷新时间,检查上次完成时间是否在今天刷新之前
if (nowTime >= todayRefresh) {
shouldRefresh = lastTime < todayRefresh;
} else {
// 否则检查上次完成时间是否在昨天刷新之前
const yesterdayRefresh = new Date(todayRefresh);
yesterdayRefresh.setDate(yesterdayRefresh.getDate() - 1);
shouldRefresh = lastTime < yesterdayRefresh;
}
break;
case "weekly": // 每周固定时间刷新
// 获取本周的刷新时间
const thisWeekRefresh = new Date(nowTime);
// 计算与本周指定星期几的差值
const dayDiff = (thisWeekRefresh.getDay() - weeklyDay + 7) % 7;
thisWeekRefresh.setDate(thisWeekRefresh.getDate() - dayDiff);
thisWeekRefresh.setHours(weeklyHour, 0, 0, 0);
// 如果当前时间已经过了本周的刷新时间
if (nowTime >= thisWeekRefresh) {
shouldRefresh = lastTime < thisWeekRefresh;
} else {
// 否则检查上次完成时间是否在上周刷新之前
const lastWeekRefresh = new Date(thisWeekRefresh);
lastWeekRefresh.setDate(lastWeekRefresh.getDate() - 7);
shouldRefresh = lastTime < lastWeekRefresh;
}
break;
case "monthly": // 每月固定时间刷新
// 获取本月的刷新时间
const thisMonthRefresh = new Date(nowTime);
// 设置为本月指定日期的凌晨
thisMonthRefresh.setDate(monthlyDay);
thisMonthRefresh.setHours(monthlyHour, 0, 0, 0);
// 如果当前时间已经过了本月的刷新时间
if (nowTime >= thisMonthRefresh) {
shouldRefresh = lastTime < thisMonthRefresh;
} else {
// 否则检查上次完成时间是否在上月刷新之前
const lastMonthRefresh = new Date(thisMonthRefresh);
lastMonthRefresh.setMonth(lastMonthRefresh.getMonth() - 1);
shouldRefresh = lastTime < lastMonthRefresh;
}
break;
case "custom": // 自定义小时数刷新
shouldRefresh = nowTime - lastTime >= customHours * 3600 * 1000;
break;
default:
throw new Error(`未知的刷新类型: ${refreshType}`);
}
// 如果文件内容无效或不存在,视为需要刷新
if (!content || isNaN(lastTime.getTime())) {
await file.writeText(filePath, "");
shouldRefresh = true;
}
if (shouldRefresh) {
// notification.send(`七圣召唤七日历练周期已经刷新,执行脚本`);
return true;
} else {
log.info(`七圣召唤七日历练未刷新`);
return false;
}
} catch (error) {
// 如果文件不存在,创建新文件并返回true(视为需要刷新)
const createResult = await file.writeText(filePath, "");
if (createResult) {
log.info("创建新时间记录文件成功,执行脚本");
return true;
} else throw new Error(`创建新文件失败`);
}
}
//检查挑战结果
async function checkChallengeResults() {
const region1 = RecognitionObject.ocr(785, 200, 380, 270); // 结果区域
const region2 = RecognitionObject.ocr(1520, 170, 160, 40); // 退出位置
let capture = captureGameRegion();
let res1 = capture.find(region1);
capture.dispose();
let success = false;
log.info(`结果识别:${res1.text}`);
if (res1.text.includes("对局失败")) {
log.info("对局失败");
await sleep(1000);
click(754, 915); //退出挑战
await sleep(4000);
await autoConversation();
} else if (res1.text.includes("对局胜利")) {
log.info("对局胜利");
await sleep(1000);
click(754, 915); //退出挑战
await sleep(4000);
await autoConversation();
success = true;
} else {
log.info("挑战异常中断,对局失败");
await sleep(1000);
click(960, 540);
await sleep(500);
click(960, 540);
await sleep(500);
click(1860, 50); //点击齿轮图标
await sleep(1000);
let ro2 = captureGameRegion();
let res2 = ro2.find(region2);
ro2.dispose();
if (res2.text.includes("设置")) click(1600, 260); //点击退出-选项4
else click(1600, 200); //点击退出-选项3
await sleep(1000);
click(1180, 756); //点击确认
await sleep(6000);
click(754, 915); //退出挑战
await sleep(4000);
await autoConversation();
success = null;
}
await sleep(1000);
return success;
}
//通过f和空格自动对话,对话标志消失时停止
async function autoConversation() {
await sleep(500); //点击后等待一段时间避免误判
const talkRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/talkSymbol.png"));
let talkTime = 0;
let talkTimes = 0;
log.info("准备开始对话");
//最多10次对话
while (talkTime < 30) {
let ro = captureGameRegion();
let talk = ro.find(talkRo);
ro.dispose();
if (talk.isExist()) {
await sleep(300);
keyPress("VK_SPACE");
await sleep(300);
keyPress("F");
talkTimes++;
await sleep(1500);
} else if (talkTimes) {
log.info("对话结束");
return;
}
talkTime++;
await sleep(1200);
}
throw new Error("对话时间超时");
}
//检测传送结束
async function tpEndDetection() {
const region = RecognitionObject.ocr(1690, 230, 75, 350); // 队伍名称区域
let tpTime = 0;
await sleep(500); //点击传送后等待一段时间避免误判
//最多30秒传送时间
while (tpTime < 300) {
let capture = captureGameRegion();
let res = capture.find(region);
capture.dispose();
if (!res.isEmpty()) {
log.info("传送完成");
await sleep(1200); //传送结束后有僵直
return;
}
tpTime++;
await sleep(100);
}
throw new Error("传送时间超时");
}
// 打开地图,查看玩家位置,并前往相应位置
const cardPlayerRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/cardPlayer.png"));
const detectCardPlayer = async () => {
// 定义要检测的6个点位及对应的处理函数
const matchedPoints = [];
const checkPoints = [
{ x: 1475, y: 730, action: async () => await gotoTable1() }, // 1号桌
{ x: 1680, y: 780, action: async () => await gotoTable2() }, // 2号桌
{ x: 1645, y: 575, action: async () => await gotoTable3() }, // 3号桌
{ x: 1460, y: 360, action: async () => await gotoTable4() }, // 4号桌
{ x: 1550, y: 0, action: async () => await gotoTable5() }, // 包间1
{ x: 1130, y: 520, action: async () => await gotoTable6() }, // 包间2
];
keyPress("M");
await sleep(1200);
await genshin.setBigMapZoomLevel(1.0); //放大地图
await sleep(300);
const mapAligned = await dragTemplateToPosition("assets/dragToVerify.png", // 模板图片路径
1449, // 目标X坐标
988, // 目标Y坐标
3 // 最大尝试次数
);
if (!mapAligned) {
keyPress("ESCAPE");
await sleep(1500);
log.warn("地图定位失败,保留待挑战名单并重试");
return false;
}
// 获取游戏区域截图
const captureRegion = captureGameRegion();
try {
for (let i = 0; i < checkPoints.length; i++) {
const point = checkPoints[i];
const cropRegion = captureRegion.DeriveCrop(point.x, point.y, 160, 160);
try {
if (!cropRegion.Find(cardPlayerRo).IsEmpty()) {
matchedPoints.push({ point, number: i + 1 });
}
} finally {
cropRegion.dispose();
}
}
} finally {
captureRegion.dispose();
}
keyPress("ESCAPE");
await sleep(1500);
// 地图识别失败不能作为周常已完成的依据。
if (matchedPoints.length === 0) {
log.warn("未在任何检测点找到玩家,保留待挑战名单并重试");
return false;
}
const selected = matchedPoints[skipNum % matchedPoints.length];
log.info(`在点位${selected.number}找到玩家,执行对应操作`);
await selected.point.action();
return true;
};
//获取挑战对象名称
async function getRemainingChallengeGuests() {
// 清空数组
textArray = [];
// 四个固定位置坐标
const positions = [
{ x: 450, y: 620 },
{ x: 760, y: 620 },
{ x: 1070, y: 620 },
{ x: 1380, y: 620 },
];
// 截取区域大小
const width = 240;
const height = 56;
await sleep(500);
keyPress("F6");
await sleep(1000);
click(300, 370); //点击七日历练
await sleep(1000);
// 获取游戏区域截图
const captureRegion = captureGameRegion();
// 遍历四个位置进行OCR识别
for (const pos of positions) {
// 创建OCR识别区域
const ocrRo = RecognitionObject.ocr(pos.x, pos.y, width, height); //挑战者名字区域
const ocrRo2 = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/completed.png"), pos.x, pos.y + 60, width, height + 80);
// 在指定区域进行OCR识别
const result = captureRegion.find(ocrRo);
let res2 = captureRegion.find(ocrRo2);
if (!result.isEmpty() && result.text) {
// 存储识别结果和对应位置
if (res2.isExist()) {
let correctedText = result.text.trim();
for (let [wrongChar, correctChar] of Object.entries(defaultReplacementMap)) {
correctedText = correctedText.replace(new RegExp(wrongChar, "g"), correctChar);
}
log.info(`识别到文本: ${correctedText} 位置: (${pos.x}, ${pos.y})`);
textArray.push({
text: correctedText.trim(),
x: pos.x + width / 2, // 点击中心位置
y: pos.y + height / 2,
});
}
} else {
log.warn(`位置 (${pos.x}, ${pos.y}) 未识别到文本`);
}
}
captureRegion.dispose();
log.info(`剩余挑战人数:${textArray.length}`);
keyPress("ESCAPE");
await sleep(1000);
}
// 计算两个字符串的相似度(允许最多一个字的差异)
function isTextMatch(target, source) {
// 如果完全匹配直接返回true
if (target === source) return true;
// 如果长度不同,直接不匹配
if (target.length !== source.length) return false;
let diffCount = 0;
for (let i = 0; i < target.length; i++) {
if (target[i] !== source[i]) {
diffCount++;
if (diffCount > 1) {
return false;
}
}
}
return true;
}
// 扫描所有带有分享码的牌组策略
function scanCardStrategy() {
const allFilesRaw = file.ReadPathSync("牌组策略");
let strategyMap = {};
for (const filePath of allFilesRaw) {
if (filePath.endsWith(".txt")) {
const content = file.readTextSync(filePath);
let shareCode = null;
for (const line of content.split("\n")) {
const trimmedLine = line.trim();
if (trimmedLine.startsWith("//") && trimmedLine.includes("shareCode=")) {
const parts = trimmedLine.split("=");
if (parts[1]) {
shareCode = parts.slice(1, parts.length).join("=");
break;
}
}
}
if (shareCode) {
const fileName = filePath.split("\\").slice(-1)[0];
const baseName = fileName.split(".").slice(0, -1).join(".");
log.debug("baseName={0}, shareCode={1}", baseName, shareCode);
strategyMap[baseName] = { shareCode: shareCode, content: content };
} else {
log.warn("策略文件中未找到有效的shareCode: {0}", filePath);
}
}
}
return strategyMap;
}
function updateRunRecord(charName, strategyName, win) {
if (!strategyRunRecord[charName]) {
strategyRunRecord[charName] = {};
}
if (!strategyRunRecord[charName][strategyName]) {
strategyRunRecord[charName][strategyName] = { win: 0, fail: 0 };
}
if (win === true) {
strategyRunRecord[charName][strategyName].win++;
} else if (win === false) {
strategyRunRecord[charName][strategyName].fail++;
} // else : do nothing when null
file.writeTextSync(strategyRunRecordFile, JSON.stringify(strategyRunRecord, null, 2), false);
}
function sortAndFilterStrategy(charName) {
const atLeastOne = [DEFAULT_STRATEGY];
if (! settings.useFallbackStrategy) {
return atLeastOne;
}
const toBeCheck = [...atLeastOne, ...fallbackStrategyList];
const charRecord = strategyRunRecord[charName];
if (!charRecord) {
return toBeCheck;
}
const scores = {};
for (const strategyName of toBeCheck) {
const data = charRecord[strategyName];
if (!data) {
scores[strategyName] = 0.5; // 未尝试过的策略
continue;
}
if (data.win === 0 && data.fail === 1) {
scores[strategyName] = 0.3; // 仅失败过一次,再给点机会
} else {
const total = data.win + data.fail;
if (total === 0) {
scores[strategyName] = 0.5;
} else {
scores[strategyName] = data.win / total;
}
}
}
const sortedScores = Object.entries(scores).sort((a, b) => b[1] - a[1]); // 分数从大到小
log.debug(`${charName}的各策略胜率分数: ${JSON.stringify(sortedScores)}`);
const sortedKeys = sortedScores.filter((entry) => entry[1] >= minFallbackStrategyScore).map((entry) => entry[0]);;
return sortedKeys;
}
// 辅助函数:数组随机打乱(Fisher-Yates Shuffle)
function shuffleArray(array) {
const arr = [...array];
for (let i = arr.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
[arr[i], arr[j]] = [arr[j], arr[i]];
}
return arr;
}
/**
* 上报策略效率数据(含重试机制)
* @param {string} charName 角色名称
* @param {string} strategyName 策略名称
* @param {boolean} success 对战是否成功
* @param {number} duration 耗时
*/
async function reportEfficiencyIfEnabled(charName, strategyName, success, duration) {
// 1. 条件检查:未启用云端统计,duration为0或挑战异常中断时,直接跳过
if (!settings.enableCloudStatistic || !duration || success === null) {
return;
}
await reportEffiency(charName, strategyName, success, duration);
}
// 在桌子旁寻找牌手打牌
async function searchCharAndPlayCards() {
middleButtonClick();
await sleep(800);
moveMouseBy(0, 1030);
await sleep(800);
moveMouseBy(0, 1030);
await sleep(1000);
let charName = "";
let charIndex = -1;
let charOcrPos = null;
// 补报待上传的记录。不加await以利用角色行动时间,避免占用时长
if (settings.enableCloudStatistic) {
retryFailedReports();
}
// 在桌子旁选一个牌手:此时不在乎选到谁(保持和原有逻辑一致)
const captureRegion = captureGameRegion();
const ocrRo = RecognitionObject.ocr(1210, 440, 150, 195);
const results = captureRegion.findMulti(ocrRo);
captureRegion.dispose();
for (const res of results) {
const resText = res.text.trim();
// 在存储的文本数组中查找匹配项
charIndex = textArray.findIndex((item) => isTextMatch(item.text, resText));
if (charIndex !== -1) {
charOcrPos = res;
charName = textArray[charIndex].text;
log.info(`找到文本: ${resText} (匹配到牌手: ${charName})`);
break;
} else {
log.debug("resText={0} 无任何匹配牌手", resText);
}
}
if (charName === "") {
log.warn(`在牌桌旁未找到可对战牌手 (剩余: ${textArray.map(item => item.text).join(", ")})`);
skipNum++;
return false;
}
// 调度策略进行打牌
let success = false;
let duration = 0;
// 尝试角色专用策略
const strategy = allStrategy[charName];
if (strategy) {
log.info("使用角色专用策略与{0}对战", charName);
[success, duration] = await Playcards(strategy, settings.overwritePartyName, charOcrPos);
await reportEfficiencyIfEnabled(charName, charName, success, duration);
}
if (success) {
skipNum = 0;
textArray.splice(charIndex, 1);
return true;
}
// 若无专用策略或专用策略对战失败,开启备用/云端策略调度
let sortedStrategy = [];
const cloudStrategySet = new Set(); // 用于记录哪些策略来自云端
if (settings.useFallbackStrategy && settings.enableCloudStatistic) {
let cloudStrategies = [];
try {
log.info("查询对手{0}的云端策略信息", charName);
const cloudRes = await queryEffiency(charName);
// 仅保留存在于 fallbackStrategyList 中的策略或默认策略
if (cloudRes && cloudRes.success && Array.isArray(cloudRes.data)) {
cloudStrategies = cloudRes.data
.map((item) => item && item.task_config)
.filter((name) => name && (fallbackStrategyList.includes(name) || name === DEFAULT_STRATEGY));
}
} catch (err) {
if (err.message && err.message.includes("JS HTTP权限")) {
log.error("请在调度器通用设置中启用JS HTTP权限");
} else {
log.error("查询云端策略失败: {0}", err);
}
}
// 判断云端是否返回了有效策略
if (cloudStrategies.length > 0) {
// 纯粹使用云端返回的策略列表
sortedStrategy = [...cloudStrategies];
log.info("成功获取{1}个{0}的云端策略: {2}", sortedStrategy.length, charName, sortedStrategy.join(", "));
} else {
// 仅当云端策略为空时,回退到 sortAndFilterStrategy (否则云端知道的必败策略还是会被本地使用)
log.warn("未获取到{0}的有效云端策略,回退使用本地策略排序", charName);
sortedStrategy = sortAndFilterStrategy(charName);
log.info("{0}共有{1}个分数≥{2}的可用策略", charName, sortedStrategy.length, minFallbackStrategyScore);
}
} else {
// 未启用云端统计/备用策略时,直接走本地逻辑
sortedStrategy = sortAndFilterStrategy(charName);
log.info("{0}共有{1}个分数≥{2}的可用策略", charName, sortedStrategy.length, minFallbackStrategyScore);
}
for (const strategyName of sortedStrategy) {
if (success) {
break; // 对战成功时跳出循环
}
// 重新寻找角色文本位置,避免上一次牌局结束后文本位置发生变动
const captureRegion = captureGameRegion();
const refreshedResults = captureRegion.findMulti(ocrRo);
captureRegion.dispose();
charOcrPos = null;
for (const ocrPos of refreshedResults) {
let correctedText = ocrPos.text.trim();
for (let [wrongChar, correctChar] of Object.entries(defaultReplacementMap)) {
correctedText = correctedText.replace(new RegExp(wrongChar, "g"), correctChar);
}
if (correctedText === charName) {
charOcrPos = ocrPos;
break;
}
}
if (charOcrPos === null) {
log.error("在牌桌旁未识别到{0}的可交互文本,无法打牌", charName);
skipNum++;
return false;
}
// 开始对战,接收 success 和 duration
const partyName = (strategyName === DEFAULT_STRATEGY) ? settings.defaultPartyName : settings.overwritePartyName;
log.info("使用{1}与{2}对战", strategyName, charName);
[success, duration] = await Playcards(allStrategy[strategyName], partyName, charOcrPos);
// 向云端汇报统计数据
await reportEfficiencyIfEnabled(charName, strategyName, success, duration);
// 仍然更新本地记录,以便用户随时能切换回本地模式
updateRunRecord(charName, strategyName, success);
}
// 只有获胜才移除牌手,失败时保留名单并轮换到下一张牌桌。
if (success) {
skipNum = 0;
textArray.splice(charIndex, 1);
} else {
log.warn("与{0}对战未成功,保留待挑战名单", charName);
skipNum++;
}
return success;
}
/**
* 在指定区域内查找并点击指定文字
* @param {string} targetText - 要点击的目标文字
* @param {number} x - 识别区域的左上角X坐标
* @param {number} y - 识别区域的左上角Y坐标
* @param {number} width - 识别区域的宽度
* @param {number} height - 识别区域的高度
* @param {object} options - 可选参数
* @param {boolean} options.trimText - 是否对OCR结果进行trim处理,默认true
* @param {boolean} options.clickCenter - 是否点击文字区域中心,默认true
* @param {number} options.retryCount - 重试次数,默认1(不重试)
* @param {number} options.retryInterval - 重试间隔(毫秒),默认500
* @returns {Promise<boolean>} 是否找到并点击了文字
*/
async function clickTextInRegion(targetText, x, y, width, height, options = {}) {
const {
trimText = true,
clickCenter = true,
retryCount = 1,
retryInterval = 500
} = options;
for (let attempt = 0; attempt <= retryCount; attempt++) {
try {
// 获取游戏区域截图
const captureRegion = captureGameRegion();
// 创建OCR识别对象,限定识别区域
const ocrRo = RecognitionObject.ocr(x, y, width, height);
// 在限定区域内进行OCR识别
const results = captureRegion.findMulti(ocrRo);
captureRegion.dispose();
// 遍历OCR结果
for (let i = 0; i < results.count; i++) {
const res = results[i];
let detectedText = res.text;
// 可选:去除前后空白字符
if (trimText) {
detectedText = detectedText.trim();
}
// 检查是否匹配目标文字
if (detectedText === targetText) {
log.info(`找到目标文字: "${targetText}",位置: (${res.x}, ${res.y}, ${res.width}, ${res.height})`);
if (clickCenter) {
// 点击文字区域中心
keyDown("VK_LMENU");
await sleep(500);
res.click();
await sleep(100);
keyUp("VK_LMENU");
log.info(`已点击文字中心: "${targetText}"`);
} else {
// 点击文字区域的左上角
res.clickTo(0, 0);
log.info(`已点击文字偏移位置: "${targetText}"`);
}
return true;
}
}
// 如果当前尝试未找到,且还有重试机会,则等待后重试
if (attempt < retryCount) {
log.info(`第${attempt + 1}次尝试未找到文字"${targetText}",${retryInterval}ms后重试...`);
await sleep(retryInterval);
}
} catch (error) {
log.error(`点击文字"${targetText}"时发生错误: ${error.message}`);
if (attempt < retryCount) {
await sleep(retryInterval);
}
}
}
log.info(`未找到文字: "${targetText}",已尝试${retryCount + 1}次`);
return false;
}
//函数:打开地图前往猫尾酒馆
async function gotoTavern() {
const tavernRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/tavern.png"));
const adventurersRo = RecognitionObject.TemplateMatch(file.ReadImageMatSync("assets/AdventurersGuild.png"));
await genshin.returnMainUi();
await sleep(1000);
await genshin.moveMapTo(-867, 2281, "蒙德");
//放大地图
await genshin.setBigMapZoomLevel(1.0);
await sleep(400);
click(1000, 645); //猫尾酒馆
await sleep(600);
let region = captureGameRegion();
let tavern = region.find(tavernRo);
const clickIcon = tavern.isExist() ? tavern : region.find(adventurersRo);
region.dispose();
if (clickIcon.isExist()) {
clickIcon.click();
await sleep(500);
} else {
throw new Error("未能找到猫尾酒馆");
}
click(1707, 1010); //确认传送
await sleep(1000);
await tpEndDetection();
}
async function waitOrCheckMaxCoin(wait_time_ms) {
const startTime = new Date().getTime();
while (new Date().getTime() - startTime < wait_time_ms) {
let captureRegion = captureGameRegion();
let result = captureRegion.find(RecognitionObject.ocr(578, 600, 763, 41));
// 道具已达到容量上限,无法获取对应奖励且挑战目标无法完成,是否继续进行挑战
if (!result.isEmpty() && result.text.includes("道具已达到容量上限")) {
let coin = "?";
let result2 = captureRegion.find(RecognitionObject.ocr(916, 530, 89, 41));
if (!result2.isEmpty()) {
coin = result2.text.trim();
}
click(733, 730); //点击取消
await sleep(1000);
click(1860, 250); //点击右上角X,退出打牌对话界面
captureRegion.dispose();
throw new Error(`幸运牌币${coin},已达到容量上限,无法获取对应奖励且挑战目标无法完成`);
}
captureRegion.dispose();
await sleep(1000);
// 无break,以确保牌币未满时延时行为与此前一致
}
}
// true和false对应打牌成功或失败
async function Playcards(strategy, teamName, pos) {
// 点击存储的位置
keyDown("VK_LMENU");
await sleep(500);
pos.click();
await sleep(500);
keyUp("VK_LMENU");
await sleep(800); //略微俯视,避免名字出现在选项框附近,导致错误点击
moveMouseBy(0, 1030);
await sleep(1000);
await autoConversation();
log.info("对话完成");
await sleep(1500);
const success = await switchCardTeam(teamName, strategy.shareCode);
if (!success) {
keyPress("ESCAPE");
await sleep(2000);
return [false, 0]; // 切换队伍失败,返回失败与0耗时
}
click(1610, 900); //点击挑战
await waitOrCheckMaxCoin(8000);
const startTime = Date.now();
await dispatcher.runTask(new SoloTask("AutoGeniusInvokation", { strategy: strategy.content }));
const duration = Number(((Date.now() - startTime) / 1000).toFixed(2));
await sleep(3000);
const win = await checkChallengeResults();
return [win, duration];
}
//前往一号桌
async function gotoTable1() {
log.info(`前往1号桌`);
if(settings.teamName){
keyPress("4");
await keyMouseScript.runFile(`assets/gotoTable1.json`);
}
else{
keyDown("d");
await sleep(1500);
keyUp("d");
keyDown("w");
await sleep(400);
keyUp("w");
keyDown("d");
keyDown("w");
await sleep(1200);
keyUp("d");
keyUp("w");
await sleep(700);
}
}
//前往二号桌
async function gotoTable2() {
log.info(`前往2号桌`);
if(settings.teamName){
keyPress("4");
await keyMouseScript.runFile(`assets/gotoTable2.json`);
}
else{
keyDown("d");
await sleep(1500);
keyUp("d");
keyDown("w");
await sleep(400);
keyUp("w");
keyDown("d");
keyDown("w");
await sleep(1200);
keyUp("d");
keyUp("w");
keyDown("s");
await sleep(700);
keyUp("s");
await sleep(700);
}
}
//前往三号桌
async function gotoTable3() {
log.info(`前往3号桌`);
if(settings.teamName){
keyPress("4");
await keyMouseScript.runFile(`assets/gotoTable3.json`);
}
else{
keyDown("w");
await sleep(2000);
keyUp("w");
keyDown("d");
await sleep(5000);
keyUp("d");
keyDown("a");
await sleep(1500);
keyUp("a");
await sleep(700);
}
}
//前往四号桌
async function gotoTable4() {
log.info(`前往4号桌`);
if(settings.teamName){
keyPress("4");
await keyMouseScript.runFile(`assets/gotoTable4.json`);
}
else{
keyDown("w");
await sleep(2000);
keyUp("w");
keyDown("d");
await sleep(5000);
keyUp("d");
keyDown("a");
await sleep(1500);
keyUp("a");
keyDown("d");
await sleep(200);
keyUp("d");
keyDown("w");
await sleep(2000);
keyUp("w");
await sleep(700);
}
}
//前往一号包间
async function gotoTable5() {
log.info(`前往1号包间`);
if(settings.teamName){
keyPress("4");
await keyMouseScript.runFile(`assets/gotoTable5.json`);
}
else{
keyDown("w");
await sleep(2500);
keyUp("w");
keyDown("d");
await sleep(200);
keyUp("d");
await sleep(500);
keyPress("ESCAPE");
await sleep(1500);
keyPress("ESCAPE");
await sleep(1500);
keyDown("w");
await sleep(5900);
keyUp("w");
await sleep(700);
}
}
//前往二号包间
async function gotoTable6() {
log.info(`前往2号包间`);
if(settings.teamName){
keyPress("4");
await keyMouseScript.runFile(`assets/gotoTable6.json`);
}
else{
await sleep(1500);
keyDown("d");
await sleep(1500);
keyUp("d");
keyDown("w");
keyDown("d");
await sleep(4000);
keyUp("d");
keyUp("w");
keyDown("a");
await sleep(1500);
keyUp("a");
keyDown("w");
await sleep(3000);
keyPress("VK_SPACE");
await sleep(1000);
keyUp("w");
keyDown("s");
await sleep(1000);
keyPress("VK_SPACE");
await sleep(700);
keyUp("s");
await sleep(500);
}
}
async function main() {
//主流程
const nowTime = new Date();
log.info(`前往猫尾酒馆`);
await gotoTavern();
await getRemainingChallengeGuests();
allStrategy = scanCardStrategy();
try {
strategyRunRecord = JSON.parse(file.readTextSync(strategyRunRecordFile));
} catch (error) {
log.debug("读取策略运行记录失败");
}
if (settings.useFallbackStrategy) {
fallbackStrategyList = Object.keys(allStrategy).filter((key) => {
return /^(\d+)\./.test(key);
});
fallbackStrategyList.sort((a, b) => {
return parseInt(a) - parseInt(b);
});
log.info("已启用{0}个备用策略: {1}", fallbackStrategyList.length, fallbackStrategyList.join(", "));
try {
const scoreInSetting = parseFloat(settings.minFallbackStrategyScore || -1);
if (scoreInSetting < 0 || scoreInSetting > 1) {
throw new RangeError("无效的输入值范围");
}
minFallbackStrategyScore = scoreInSetting;
} catch (error) {
log.warn("未设置备用策略胜率阈值或阈值无效,使用默认值{0}", minFallbackStrategyScore);
}
} else {
log.info("未启用备用策略");
}
let mapMisses = 0;
for (let i = 0; i < 21; i++) {
//循环兜底,避免角色未到达指定位置
if (textArray.length === 0) break;
if (i > 0) await gotoTavern();
if (!await detectCardPlayer()) {
skipNum = 0;
if (++mapMisses >= 3) break;
continue;
}
mapMisses = 0;
await searchCharAndPlayCards();
// 对局结束后以七日历练的实际状态更新名单,避免提前结束。
await genshin.returnMainUi();
await getRemainingChallengeGuests();
}
await genshin.returnMainUi();
await getRemainingChallengeGuests();
if (textArray.length > 0) {
const message = `打牌尚未完成,剩余${textArray.length}人:${textArray.map(item => item.text).join("、")};未写入本周完成记录,请检查地图识别或打牌策略后重试`;
log.warn(message);
notification.send(message);
throw new Error(message);
}
log.info("打牌完成,剩余挑战人数:0");
notification.send("打牌完成,剩余挑战人数:0");
// 仅在七日历练确认全部完成后更新最后完成时间。
await file.writeText("assets/weekly.txt", nowTime.toISOString());
}
(async function () {
const refresh = {
refreshType: "weekly",
weeklyDay: 1, // 周一
weeklyHour: 4, // 凌晨4点
};
if (!settings.defaultPartyName || !settings.overwritePartyName || settings.defaultPartyName == settings.overwritePartyName) {
log.error("需要在JS脚本配置中设置两个牌组且名称不能相同");
return;
}
if (await isTaskRefreshed("assets/weekly.txt", refresh)) {
await genshin.returnMainUi();
if(settings.teamName)await genshin.switchParty(settings.teamName);
await main();
}
})();