自动挂机看知到MOOC，自动切换下一节，支持屏蔽弹窗题目，可调倍数播放，采用AI辅助答题，支持章节测试等，可以自动答题，可线路选择，默认静音等，解除各类功能限制，开放自定义参数，本脚本仅供个人研究学习使用，专注于为大学生减轻网课学习的操作负担，助力从繁琐的网课任务中高效脱身，让时间真正掌握在自己手中。同时，配备人性化操作界面，设计简洁直观，贴合用户使用习惯，让学习辅助过程更轻松便捷。请勿用于非法用途，产生一切法律责任用户自行承担。
// ==UserScript==
// @name 超强智慧树网课助手，完全免费，使用AI辅助，拥有超全题库，自动提交，支持视频，，可章节测试，自动挂机，防清进度，超高正确率
// @namespace mx
// @version 1.1.2
// @description 自动挂机看知到MOOC，自动切换下一节，支持屏蔽弹窗题目，可调倍数播放，采用AI辅助答题，支持章节测试等，可以自动答题，可线路选择，默认静音等，解除各类功能限制，开放自定义参数，本脚本仅供个人研究学习使用，专注于为大学生减轻网课学习的操作负担，助力从繁琐的网课任务中高效脱身，让时间真正掌握在自己手中。同时，配备人性化操作界面，设计简洁直观，贴合用户使用习惯，让学习辅助过程更轻松便捷。请勿用于非法用途，产生一切法律责任用户自行承担。
// @author mx
// @match *://*.zhihuishu.com/*
// @connect cx.icodef.com
// @connect tk.mixuelo.cc
// @run-at document-end
// @grant unsafeWindow
// @grant GM_xmlhttpRequest
// @grant GM_setClipboard
// @grant GM_setValue
// @grant GM_getValue
// @license MIT
// @icon https://scriptcat.org/api/v2/users/165553/avatar
// ==/UserScript==
// 设置修改后，需要刷新或重新打开网课页面才会生效
var setting = {
// 5E3 == 5000，科学记数法，表示毫秒数
time: 5E3 // 默认响应速度为5秒，不建议小于3秒
, token: '' // token可以增加并发次数，用来打码，采集题库奖励
// 1代表开启，0代表关闭
, video: 1 // 视频支持课程、见面课，默认开启
, work: 1 // 自动答题功能，支持章测试、考试，高准确率，默认开启
, jump: 1 // 自动切换视频，支持课程、见面课，默认开启
// 仅开启video时，修改此处才会生效
, line: '流畅' // 视频播放的默认线路，可选参数：['高清', '流畅', '校内']，默认'流畅'
, vol: '0' // 默认音量的百分数，设定范围：[0,100]，'0'为静音，默认'0'
, speed: '1.5' // 进度统计速率，高倍率可以快速完成任务点，设定范围：(0,+∞)，默认'1.5'倍
// 上方参数支持在页面改动，下方参数仅支持代码处修改
, que: 1 // 屏蔽视频时间点对应的节试题，取消屏蔽则自动切换为模拟点击关闭弹题，默认开启
, danmu: 0 // 见面课弹幕，关闭后在网页中无法手动开启，默认关闭
, habit: '0' // 限制视频挂机时长，单位是分钟，如需挂机习惯分，可以修改参数为'30'，默认不限制
// 仅开启work时，修改此处才会生效
, none: 1 // 无匹配答案时执行默认操作，默认开启
, hide: 0 // 不加载答案搜索提示框，键盘↑和↓可以临时移除和加载，默认关闭
// 内部使用的属性
, queue: [] // 答题队列
, curs: [] // 课程信息
, loop: null // 循环定时器
, lose: 0 // 失败题目数
, num: 0 // 当前题目索引
, small: 0 // 小题索引
, max: 999 // 最大题目数
, shouldNavigateNext: false // 导航标记，只有成功答题后才设置为true，设置为较大值避免触发"答题已完成"
},
_self = (typeof unsafeWindow !== 'undefined') ? unsafeWindow : window,
url = location.pathname,
$ = _self.jQuery || top.jQuery || window.jQuery,
xhr = _self.XMLHttpRequest,
_host = "http://tk.mixuelo.cc",
API_BASE_URL = (() => {
const baseUrl = "tk.mixuelo.cc/api.php";
const protocol = window.location.protocol;
if (protocol === 'https:') {
return "https://" + baseUrl;
} else {
return "http://" + baseUrl;
}
})();
setting.notice = '公告栏';
GM_xmlhttpRequest({
method: 'GET',
url: 'http://cx.icodef.com/update?s=wyn3',
timeout: setting.time,
onload: function (xhr) {
if (xhr.status == 200) {
var obj = $.parseJSON(xhr.responseText) || {};
setting.notice = obj.injection;
document.querySelector('#cx-notice').innerHTML = setting.notice;
}
},
ontimeout: function () {
setting.loop && setting.div.children('div:eq(0)').html(setting.over + '服务器超时，正在重试...');
}
});
String.prototype.toCDB = function () {
return this.replace(/\s/g, '').replace(/[\uff01-\uff5e]/g, function (str) {
return String.fromCharCode(str.charCodeAt(0) - 65248);
}).replace(/[“”]/g, '"').replace(/[‘’]/g, "'").replace(/。/g, '.');
};
// setting.time += Math.ceil(setting.time * Math.random()) - setting.time / 2;
setting.queue = setting.curs = [];
setting.loop = null;
if (!$) {
} else if (url.match('/videoList')) {
$.tmDialog.alert({ content: '2.X版本已取消支持旧版界面', title: '智慧树网课助手提示' });
} else if (url == '/videoStudy.html') {
setting.habit *= 6E4;
setting.video && hookVideo(_self.vjsComponent, 1);
setting.video && initZhihuishuVideoControl();
setting.jump && setInterval(checkToNext, setting.time);
} else if (url == '/portals_h5/2clearning.html') {
setting.video && hookVideo(_self.vjsComponent, 2);
setting.video && initZhihuishuVideoControl();
setting.jump && setInterval(checkToNext, setting.time);
} else if (url == '/live/vod_room.html') {
setting.video && hookVideo(_self.vjsComponent);
setting.video && initZhihuishuVideoControl();
setting.jump && setInterval(checkToNext, setting.time, 1);
} else if (location.hostname.match('examh5')) {
setTimeout(relieveLimit, 100, document);
if (location.hash.match(/dohomework|doexamination/) && setting.work) beforeFind();
} else if (location.hostname.match('hiexam')) {
// 智慧树考试页面
setTimeout(relieveLimit, 100, document);
// 初始化智慧树界面系统
setTimeout(initZhihuishuUI, 1000);
// 删除setting.work检查，默认进入页面就自动答题
logger('检测到智慧树考试页面，准备初始化自动答题功能', 'green');
setTimeout(initZhihuishuOriginalAnswering, 2000);
// 自动启动答题功能
setTimeout(() => {
if (checkZhsAnswerPage()) {
logger('自动启动答题功能', 'green');
zhsProcessQuestions();
}
}, 5000);
$(window).on('hashchange', function () {
setting.work && location.reload();
});
} else if (location.hostname.match('hike')) {
setTimeout(relieveLimit, 100, document);
logger('🎬 检测到智慧树视频学习页面，初始化视频控制功能', 'green');
logger(`🔍 当前页面URL: ${location.href}`, 'blue');
logger(`🔍 当前域名: ${location.hostname}`, 'blue');
logger('🎬 智慧树视频助手开始初始化...', 'green');
// 初始化视频专用控制面板
setTimeout(() => {
logger('🎬 开始初始化视频专用控制面板...', 'blue');
initZhihuishuVideoUI();
}, 1000);
// 初始化视频自动播放功能
setTimeout(() => {
logger('🎬 开始初始化视频自动播放功能...', 'blue');
initZhihuishuVideoControl();
logger('🎬 视频自动播放功能已启动', 'blue');
}, 2000);
// 监听视频播放状态，实现自动下一个视频
setTimeout(() => {
logger('🎬 开始初始化视频自动下一个功能...', 'blue');
initVideoAutoNext();
}, 3000);
} else if (url.match('exerciseList') && setting.work) {
logger('检测到智慧树练习页面', 'green');
setTimeout(initZhsConfigSystem, 1000);
// 设置XMLHttpRequest hook来拦截API响应
_self.XMLHttpRequest = function () {
var ajax = new XMLHttpRequest();
ajax.onload = function () {
if (this.status != 200 || !this.responseURL.match('getDoQuestSingle')) return;
try {
var obj = JSON.parse(this.responseText).rt;
logger('拦截到智慧树题目API响应', 'green');
logger(`题目ID: ${obj.questionId}`, 'blue');
logger(`题目类型: ${obj.questionName} (ID: ${obj.questionTypeId})`, 'blue');
// 处理题目内容
if (obj.content) {
// 移除答题停止检查 - 默认总是答题
// if (localStorage.getItem('GPTJsSetting.work') !== 'true') {
// logger('答题已停止，跳过API拦截处理', 'red');
// return;
// }
var questionText = obj.content.replace(/<[^>]*>/g, '').trim();
logger(`题目内容: ${questionText.substring(0, 100)}...`, 'blue');
// 调用题库API获取答案
zhsGetAnswerFromAPI(questionText, obj.questionTypeId, obj.questionOptionList);
}
} catch (e) {
logger('处理智慧树API响应时出错: ' + e.message, 'red');
}
};
return ajax;
};
setInterval(function () {
if (setting.queue.length > 0) {
var element = setting.queue.shift();
if (element) {
try {
// 多种点击方式
if (element.click) {
element.click();
} else if ($ && $(element).length > 0) {
$(element).trigger('click');
}
logger('点击队列中的选项', 'blue');
} catch (e) {
logger('点击选项失败: ' + e.message, 'red');
}
}
}
}, 1E3);
// 修复自动导航逻辑 - 只有在明确成功答题后才导航
setting.jump && setInterval(function () {
// 检查答题状态 - 只有在答题开启时才自动点击下一题
const isAutoAnswerEnabled = localStorage.getItem('GPTJsSetting.work') === 'true';
if (!isAutoAnswerEnabled) {
return; // 答题已关闭，不自动点击下一题
}
// 检查是否有待处理的答题队列
if (setting.queue.length > 0) {
return; // 还有答题任务在处理，不自动跳题
}
// 检查是否有明确的导航标记（只有成功答题后才设置）
if (!setting.shouldNavigateNext) {
return; // 没有导航标记，不自动跳题
}
var nextBtn = document.querySelector('.Topicswitchingbtn');
if (nextBtn && nextBtn.textContent.includes('下一题')) {
nextBtn.click();
logger('🔄 自动导航到下一题', 'blue');
// 清除导航标记，避免重复导航
setting.shouldNavigateNext = false;
}
}, setting.time);
} else if (url.match('/sourceLearning')) {
setting.video && hookVideo(_self.vjsComponent, 3);
setting.jump && setInterval(checkToNext, setting.time, $('.source-file-item'));
} else if (url == '/shareCourse/questionDetailPage') {
setTimeout(relieveLimit, 100, document);
$('textarea[oncut]').each(function () {
setTimeout(relieveLimit, 100, this);
});
if ($("#myAnswerInfo_div2 .option-zan").attr("islike") == 0) {
$("#myAnswerInfo_div2 .option-zan").click();
}
}
function hookVideo(Hooks, tip) {
// _self.PlayerUtil.debugMode = true;
_self.vjsComponent = function () {
var config = arguments[0],
options = config.options,
line = $.map(options.sourceSrc.lines, function (value) {
return value.lineName.replace('标准', '高清');
}),
vol = setting.vol > 100 ? 100 : setting.vol,
rate = tip == 3 ? [1, 1.25, 1.5, 2, 2.5, 3] : [1, 1.25, 1.5];
vol = Math.round(vol) / 100;
options.volume = vol > 0 ? vol : 0;
options.autostart = true;
setting.speed = setting.speed > 0 ? +setting.speed : 1;
options.rate = $.inArray(setting.speed, rate) < 0 ? options.rate : setting.speed;
tip && config.callback.playbackRate(setting.speed);
options.chooseLine = $.inArray(setting.line, line) + 1 || options.chooseLine + 1;
options.src = options.sourceSrc.lines[--options.chooseLine].lineUrl || options.src;
if (!setting.danmu) {
config.defOptions.control.danmuBtn = false;
delete options.control.danmuBtn;
}
Hooks.apply(this, arguments);
config.player.on('loadstart', function () {
this.loop(true);
this.play();
$('.speedBox span').text('X ' + setting.speed);
});
};
$(document).on('click', '.definiLines b', function () {
setting.line = ({ xiaonei: '校内', line1gq: '高清', line1bq: '流畅' })[this.classList[0]];
}).on('mouseup click', function () {
setting.vol = _self.PlayerStarter.playerArray[0].player.cache_.volume * 100;
}).on('click', '.speedList div', function () {
setting.speed = $(this).attr('rate');
});
if (tip != 1) return;
setting.tip = setting.habit && setInterval(totalTime, setting.time);
setInterval(doTest, 1E3);
_self.XMLHttpRequest = setting.que ? function () {
var ajax = new xhr(),
open = ajax.open;
ajax.open = function (method, url) {
if (url.match('/loadVideoPointerInfo')) method = 'OPTIONS';
return open.apply(this, arguments);
};
return ajax;
} : xhr;
}
function totalTime() {
var player = _self.PlayerStarter.playerArray[0].player;
setting.habit -= player.paused() ? 0 : setting.time;
if (setting.habit >= 0) return;
clearInterval(setting.tip);
player.pause();
$.getScript('//cdn.jsdelivr.net/gh/sentsin/layer/dist/layer.js', function () {
_self.layer.open({
content: '已达到挂机限制时间', title: '智慧树网课助手提示', end: function () {
setting.habit = 0;
}
});
});
}
function checkToNext(tip) {
if (setting.habit < 0) return;
var $tip = $('.video, .lessonItem');
if ($('.current_play .time_icofinish').length) {
$tip.slice($tip.index($('.current_play')) + 1).not(':has(.time_icofinish)').eq(0).click();
} else if ($('.lessonItemActive .finish').length) {
// _self.PlayerStarter.playerArray[0].callback.playerNext();
$tip.slice($tip.index($('.lessonItemActive')) + 1).not(':has(.finish)').eq(0).click();
} else if (tip == 1) {
$('.current_player:contains("100%") + li').click();
// $('.finish_tishi').hasClass('disNo') || console.log('签到已完成');
} else if ($('.settleOn .finish').length) {
tip.slice(tip.index($('.settleOn')) + 1).not(':has(.finish)').eq(0).find('.file-name').click();
}
}
function doTest() {
if (!$('.dialog-test').length) {
} else if (setting.queue.length) {
$(setting.queue.shift()).parent().click();
} else if (!$('.answer').length) {
$('.topic-item').eq(0).click();
} else if (!$('.right').length) {
var tip = $('.answer span').text().match(/[A-Z]/g) || [];
if (tip.length == 1) return $('.topic-option-item:contains(' + tip[0] + ')').click();
$('.topic-option-item').each(function () {
$.inArray($(this).text().slice(0, 1), tip) < 0 == $(this).hasClass('active') && setting.queue.push(this);
});
} else if ($('.btn-next:enabled').length) {
$('.btn-next:enabled').click();
} else {
$('.dialog-test .btn').click();
_self.PlayerStarter.playerArray[0].player.play();
}
}
function relieveLimit(doc) {
if (!doc.oncut && !doc.onselectstart) return setTimeout(relieveLimit, 100, doc);
doc.oncontextmenu = doc.onpaste = doc.oncopy = doc.oncut = doc.onselectstart = null;
}
function beforeFind() {
_self.XMLHttpRequest = function () {
var ajax = new xhr();
ajax.onload = function (e) {
if (this.status != 200 || !this.responseURL.match(/doHomework|doExam/)) return;
var obj = JSON.parse(this.responseText);
collectData(obj.rt.examBase);
};
return ajax;
};
setting.div = $(
'<div style="border: 2px dashed rgb(0, 85, 68); width: 330px; position: fixed; top: 0; left: 0; z-index: 99999; background-color: rgba(70, 196, 38, 0.6); overflow-x: auto;">' +
'<span style="font-size: medium;"></span>' +
'<div style="font-size: medium;">正在搜索答案...</div>' +
'<div id="cx-notice" style="border-top: 1px solid #000;border-bottom: 1px solid #000;margin: 4px 0px;overflow: hidden;">' + setting.notice + '</div>' +
'<button style="margin-right: 10px;">暂停答题</button>' +
'<button style="margin-right: 10px;">重新查询</button>' +
'<button style="margin-right: 10px;">折叠面板</button>' +
'<button style="display: none;">未作答题目</button>' +
'<form style="margin: 2px 0;">' +
'<label style="font-weight: bold; color: red;">自定义答题范围：</label>' +
'<input name="num" type="number" min="1" placeholder="开始" style="width: 60px;" disabled>' +
'<span> ~ </span>' +
'<input name="max" type="number" min="1" placeholder="结束" style="width: 60px;" disabled>' +
'</form>' +
'<div style="max-height: 300px; overflow-y: auto;">' +
'<table border="1" style="font-size: 12px;">' +
'<thead>' +
'<tr>' +
'<th style="width: 30px; min-width: 30px; font-weight: bold; text-align: center;">题号</th>' +
'<th style="width: 60%; min-width: 130px; font-weight: bold; text-align: center;">题目（点击可复制）</th>' +
'<th style="min-width: 130px; font-weight: bold; text-align: center;">答案（点击可复制）</th>' +
'</tr>' +
'</thead>' +
'<tfoot style="display: none;">' +
'<tr>' +
'<th colspan="3" style="font-weight: bold; text-align: center;">答案提示框 已折叠</th>' +
'</tr>' +
'</tfoot>' +
'<tbody>' +
'<tr>' +
'<td colspan="3" style="display: none;"></td>' +
'</tr>' +
'</tbody>' +
'</table>' +
'</div>' +
'</div>'
).appendTo('body').on('click', 'button, td', function () {
var len = $(this).prevAll('button').length;
if (this.nodeName == 'TD') {
$(this).prev().length && GM_setClipboard($(this).text());
} else if (len === 0) {
if (setting.loop) {
clearInterval(setting.loop);
delete setting.loop;
len = [false, '已暂停搜索', '继续答题'];
} else {
setting.loop = setInterval(findAnswer, setting.time);
len = [true, '正在搜索答案...', '暂停答题'];
}
setting.div.find('input').attr('disabled', len[0]);
setting.div.children('div:eq(0)').html(function () {
return $(this).data('html') || len[1];
}).removeData('html');
$(this).html(len[2]);
} else if (len == 1) {
location.reload();
} else if (len == 2) {
setting.div.find('tbody, tfoot').toggle();
} else if (len == 3) {
var $li = $('.el-scrollbar__wrap li'),
$tip = $li.filter('.white, .yellow').eq(0);
$tip.click().length ? setting.div.children('div:last').scrollTop(function () {
var $tr = $('tbody tr', this).has('td:nth-child(1):contains(' + $tip.text() + ')');
if (!$tr.length) return arguments[1];
return $tr.offset().top - $tr.parents('table').offset().top; // $tr[0].offsetTop
}) : $(this).hide();
} else if (len == 4) {
setting.tk_num++;
GM_setValue('tk_num_1', setting.tk_num);
setting.tk_num = GM_getValue('tk_num_1');
console.log(setting.tk_num);
parent.location.reload();
}
}).on('change', 'input', function () {
setting[this.name] = this.value.match(/^\d+$/) ? parseInt(this.value) - 1 : -1;
if (!this.value) setting[this.name] = this.name == 'num' ? 0 : undefined;
}).detach(setting.hide ? '*' : 'html');
setting.type = {
单选题: 1,
多选题: 2,
填空题: 3,
问答题: 4,
'分析题/解答题/计算题/证明题': 5,
'阅读理解（选择）/完型填空': 9,
判断题: 14
};
setting.lose = setting.num = setting.small = 0;
$(document).keydown(function (event) {
if (event.keyCode == 38) {
setting.div.detach();
} else if (event.keyCode == 40) {
setting.div.appendTo('body');
}
});
setting.loop = setInterval(findAnswer, setting.time, true);
setInterval(function () {
$(setting.queue.shift()).parent().click();
}, 1E3);
}
function findAnswer(tip) {
if (setting.queue.length) {
return;
} else if (tip && !$('.answerCard').length) {
return setting.div.children('div:eq(0)').data('html', '非自动答题页面').siblings('button:eq(0)').click();
} else if (setting.max < 0 || setting.num < 0) {
return setting.div.children('div:eq(0)').data('html', '范围参数应为 <font color="red">正整数</font>').siblings('button:eq(0)').click();
} else if (setting.num >= $('.subject_stem').length || setting.num > setting.max) {
// setting.div.children('button:eq(3)').toggle(!!setting.lose);
tip = setting.lose ? '共有 <font color="red">' + setting.lose + '</font> 道题目待完善（已深色标注）' : '答题已完成';
return setting.div.children('div:eq(0)').data('html', tip).siblings('button:eq(0), form').hide().click();
} else if (!setting.curs.length) {
setting.curs = $('.infoList span').map(function () {
return $(this).text().trim();
});
if (!setting.curs.length) return;
}
var $TiMu = $('.subject_stem').eq(setting.num).parent(),
$dom = $TiMu.find('.smallStem_describe').eq(setting.small).children('div').slice(1, -1),
question = filterStyle($dom) || filterStyle($TiMu.find('.subject_describe')),
type = $TiMu.find('.subject_type').text().match(/【(.+)】|$/)[1];
type = type ? setting.type[type] || 0 : -1;
GM_xmlhttpRequest({
method: 'POST',
url: 'http://cx.icodef.com/wyn-nb?v=4',
headers: {
'Content-type': 'application/x-www-form-urlencoded',
'Authorization': setting.token,
},
data: 'question=' + encodeURIComponent(question),
timeout: setting.time,
onload: function (xhr) {
if (!setting.loop) {
} else if (xhr.status == 200) {
var obj = $.parseJSON(xhr.responseText.replace(/^操作数据失败！/, '')) || {};
obj.answer = obj.data;
if (obj.code) {
setting.div.children('div:eq(0)').text('正在搜索答案...');
var answer = obj.answer.replace(/&/g, '&').replace(/<([^i])/g, '<$1');
obj.answer = /^http/.test(answer) ? '<img src="' + obj.answer + '">' : obj.answer;
$(
'<tr>' +
'<td style="text-align: center;">' + $TiMu.find('.subject_num').text().trim().replace('.', '') + '</td>' +
'<td title="点击可复制">' + (question.match('<img') ? question : question.replace(/&/g, '&').replace(/</g, '<')) + '</td>' +
'<td title="点击可复制">' + (/^http/.test(answer) ? obj.answer : '') + answer + '</td>' +
'</tr>'
).appendTo(setting.div.find('tbody')).css('background-color', function () {
$dom = $dom.length ? $dom.closest('.examPaper_subject') : $TiMu;
if (fillAnswer($dom, obj, type)) return '';
setting.div.children('button:eq(3)').show();
return 'rgba(0, 150, 136, 0.6)';
});
setting.small = ++setting.small < $TiMu.find('.smallStem_describe').length ? setting.small : (setting.num++, 0);
} else {
setting.div.children('div:eq(0)').html(obj.answer || '服务器繁忙，正在重试...');
}
setting.div.children('span').html(obj.msg || '');
} else if (xhr.status == 403) {
var html = xhr.responseText.indexOf('{') ? '请求过于频繁，建议稍后再试' : $.parseJSON(xhr.responseText).answer;
setting.div.children('div:eq(0)').data('html', html).siblings('button:eq(0)').click();
} else {
setting.div.children('div:eq(0)').text('服务器异常，正在重试...');
}
},
ontimeout: function () {
setting.loop && setting.div.children('div:eq(0)').text('服务器超时，正在重试...');
}
});
}
function fillAnswer($TiMu, obj, type) {
var $div = $TiMu.find('.nodeLab'),
str = String(obj.answer).toCDB() || new Date().toString(),
answer = str.split(/#|\x01|\|/),
state = setting.lose;
// $div.find(':radio:checked').prop('checked', false);
obj.code > 0 && $div.each(function () {
var $input = $('input', this)[0],
tip = filterStyle('.node_detail', this).toCDB() || new Date().toString();
if (tip.match(/^(正确|是|对|√|T|ri)$/)) {
answer.join().match(/(^|,)(正确|是|对|√|T|ri)(,|$)/) && setting.queue.push($input);
} else if (tip.match(/^(错误|否|错|×|F|wr)$/)) {
answer.join().match(/(^|,)(错误|否|错|×|F|wr)(,|$)/) && setting.queue.push($input);
} else if (type == 2) {
Boolean($.inArray(tip, answer) + 1 || str.indexOf(tip) + 1) == $input.checked || setting.queue.push($input);
} else {
$.inArray(tip, answer) + 1 && setting.queue.push($input);
}
});
if (setting.queue.length) {
} else if (/^(1|2|14)$/.test(type)) {
var $input = $div.find('input');
// 删除随机选择功能，避免意外的随机答题
$input.is(':checked') || setting.lose++;
} else if (/^[3-5]$/.test(type)) {
answer = String(obj.answer).split(/#|\x01|\|/);
str = $TiMu.find('textarea').each(function (index) {
index = (obj.code > 0 && answer[index]) || '';
this.value = index.trim();
// if (this.value == this._value) return true;
this.dispatchEvent(new Event('input'));
this.dispatchEvent(new Event('blur'));
}).length;
(obj.code > 0 && answer.length == str) || setting.none || setting.lose++;
} else {
setting.none || setting.lose++;
}
return state == setting.lose;
}
function collectData(obj, data) {
setting.data = data = {};
data.id = obj.id;
data.name = obj.name;
data.course = obj.courseName;
data.chapter = obj.toChapter || obj.explain;
data.timu = [];
$.each(obj.workExamParts, function () {
$.each(this.questionDtos, function () {
if (this.questionOptions) return pushData(this, data.timu);
$.each(this.questionChildrens, function () {
pushData(this, data.timu);
});
});
});
GM_xmlhttpRequest({
method: 'POST',
url: 'http://cx.icodef.com/report/zhs',
headers: {
'Content-type': 'application/x-www-form-urlencoded',
'Authorization': setting.token,
},
data: 'data=' + encodeURIComponent(JSON.stringify(data))
});
}
function pushData(obj, arr) {
arr.push({
id: obj.id,
question: filterStyle('<p>' + obj.name + '</p>'),
option: $.map(obj.questionOptions, function (val) {
return filterStyle('<p>' + val.content + '</p>');
}),
key: $.map(obj.questionOptions, function (val) {
return val.id;
}).join(),
type: obj.questionType.id
});
}
function logger(message, color) {
// 过滤掉详细的调试信息，只保留核心答题信息
const debugKeywords = [
'🔍 调试：',
'🔍调试：',
'调试：',
'找到',
'个子元素',
'个.optionUl容器',
'个role',
'optionContent:',
'radioLabel:',
'radio[',
'题目容器HTML:',
'个role="radio"元素',
'个role="radiogroup"',
'开始填充答案',
'题目类型:',
'答案分割结果:',
'尝试选择选项',
'成功点击选项',
'处理答案:',
'📝 开始处理当前题目',
'📋 题目内容:',
'📝 选项数量:',
'📋 选项内容:',
'📝 开始重新处理题目',
'📚 发送题库API请求到',
'选项匹配:',
'🎯 开始选择答案:',
'✅ 选择最佳匹配选项',
'✅ 题目处理成功，准备自动下一题',
'🔄 自动导航到下一题',
'🔄 已自动跳转到下一题',
'拦截到智慧树题目API响应',
'题目ID:',
'开始调用题库API查询答案',
'发送题库API请求',
'使用API Key:',
'题库API状态:',
'当前配置状态:',
'已开启AI答题功能，准备获取AI答案',
'🤖 答案来源:',
'点击队列中的选项',
'设置导航标记，等待定时器处理'
];
const shouldFilter = debugKeywords.some(keyword => message.includes(keyword));
if (shouldFilter) {
// 调试信息完全不显示，直接返回
return;
}
const colors = {
'red': '#F56C6C',
'green': '#67C23A',
'blue': '#409EFF',
'orange': '#E6A23C',
'purple': '#9C27B0',
'yellow': '#F7BA2A',
'pink': '#EB7CD0'
};
const style = `color: ${colors[color] || '#000000'}; font-weight: bold;`;
console.log(`%c[智慧树助手] ${message}`, style);
// 同时输出到界面日志窗口
addToUILog(message, color);
}
function addToUILog(message, color) {
const logContainer = document.getElementById('zhs-log-container');
if (!logContainer) return;
const colors = {
'red': '#F56C6C',
'green': '#67C23A',
'blue': '#409EFF',
'orange': '#E6A23C',
'purple': '#9C27B0',
'yellow': '#F7BA2A',
'pink': '#EB7CD0'
};
// 简化消息内容，提取关键信息
let displayMessage = message;
// 简化API请求信息
if (message.includes('发送题库API请求')) {
displayMessage = '📚 正在查询题库...';
} else if (message.includes('AI成功返回答案')) {
const answerMatch = message.match(/答案:\s*(.+)/);
if (answerMatch) {
displayMessage = `🤖 AI答案: ${answerMatch[1]}`;
}
} else if (message.includes('开始重新处理题目')) {
displayMessage = '🔄 开始处理题目';
} else if (message.includes('题目内容:')) {
const contentMatch = message.match(/题目内容:\s*(.+)/);
if (contentMatch) {
displayMessage = `📝 ${contentMatch[1].substring(0, 50)}${contentMatch[1].length > 50 ? '...' : ''}`;
}
}
const logEntry = document.createElement('div');
logEntry.className = 'gpt-message';
logEntry.style.cssText = `
margin: 6px 0 !important;
padding: 6px 10px !important;
border-radius: 6px !important;
font-size: 12px !important;
line-height: 1.4 !important;
color: ${colors[color] || '#333'} !important;
background: rgba(${color === 'green' ? '103, 194, 58' : color === 'red' ? '245, 108, 108' : '64, 158, 255'}, 0.1) !important;
border-left: 3px solid ${colors[color] || '#409EFF'} !important;
word-wrap: break-word !important;
`;
const timestamp = new Date().toLocaleTimeString('zh-CN', { hour12: false });
logEntry.innerHTML = `<span style="opacity: 0.6; font-size: 10px;">[${timestamp}]</span> ${displayMessage}`;
logContainer.appendChild(logEntry);
// 自动滚动到底部
logContainer.scrollTop = logContainer.scrollHeight;
// 限制日志条数，避免内存占用过多
const maxLogs = 50;
while (logContainer.children.length > maxLogs) {
logContainer.removeChild(logContainer.firstChild);
}
}
function initZhihuishuUI() {
logger('初始化智慧树界面系统', 'blue');
if (document.getElementById('zhs-control-panel')) {
logger('智慧树界面已存在，跳过创建', 'orange');
return;
}
createZhihuishuControlPanel();
createZhihuishuLogWindow();
addZhihuishuKeyboardShortcuts();
initZhsConfigSystem();
initZhsPanelState();
logger('智慧树界面系统初始化完成', 'green');
}
function createZhihuishuControlPanel() {
if (document.getElementById('zhs-control-panel')) {
logger('控制面板已存在，跳过创建', 'orange');
return;
}
const panel = document.createElement('div');
panel.id = 'zhs-control-panel';
panel.className = 'gpt-box';
panel.style.cssText = `
position: fixed !important;
top: 80px !important;
right: 10px !important;
width: 320px !important;
background: rgba(255, 255, 255, 0.98) !important;
border-radius: 12px !important;
box-shadow: 0 8px 32px rgba(64, 158, 255, 0.2) !important;
z-index: 2147483647 !important;
font-family: "Microsoft YaHei", sans-serif !important;
transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1) !important;
cursor: default !important;
transform: none !important;
margin: 0 !important;
border: 2px solid #409EFF !important;
max-height: 500px !important;
overflow: hidden !important;
`;
const shouldHide = localStorage.getItem('ZhsJsSetting.hideBox') === 'true';
const initialDisplay = shouldHide ? 'none' : 'block';
panel.style.display = initialDisplay;
const isExpanded = localStorage.getItem('ZhsJsSetting.panelExpanded') !== 'false';
const contentDisplay = isExpanded ? 'block' : 'none';
panel.innerHTML = `
<!-- 控制面板标题栏 - 可点击展开/收起 -->
<div class="gpt-box-header" onclick="toggleZhsPanel()" style="
background: linear-gradient(135deg, #409EFF 0%, #66b3ff 100%) !important;
color: white !important;
padding: 15px 18px !important;
border-radius: 10px 10px ${isExpanded ? '0 0' : '10px 10px'} !important;
cursor: pointer !important;
user-select: none !important;
display: flex !important;
justify-content: space-between !important;
align-items: center !important;
transition: all 0.3s ease !important;
box-shadow: 0 2px 8px rgba(64, 158, 255, 0.3) !important;
" onmouseover="this.style.background='linear-gradient(135deg, #66b3ff 0%, #409EFF 100%)'" onmouseout="this.style.background='linear-gradient(135deg, #409EFF 0%, #66b3ff 100%)'">
<div style="display: flex; align-items: center; gap: 10px;">
<img src="https://mx.mixuelo.cc/index/pengzi/images/思考2.gif" style="width: 20px; height: 20px;" alt="logo">
<span style="font-weight: 600; font-size: 15px;">智慧树助手</span>
</div>
<div style="display: flex; align-items: center; gap: 8px;">
<span id="zhs-expand-btn" style="
font-size: 14px;
transition: transform 0.3s ease;
transform: rotate(${isExpanded ? '180deg' : '0deg'});
">▼</span>
<button onclick="event.stopPropagation(); document.getElementById('zhs-control-panel').style.display='none'" title="隐藏面板" style="
background: rgba(255, 255, 255, 0.2) !important;
border: none !important;
border-radius: 6px !important;
padding: 6px 10px !important;
color: white !important;
cursor: pointer !important;
font-size: 12px !important;
transition: all 0.3s !important;
" onmouseover="this.style.background='rgba(255,255,255,0.3)'" onmouseout="this.style.background='rgba(255,255,255,0.2)'">✕</button>
</div>
</div>
<!-- 控制面板内容 - 标签切换模式 -->
<div id="zhs-panel-content" style="
background: white !important;
border-radius: 0 0 10px 10px !important;
display: ${contentDisplay} !important;
overflow: hidden !important;
">
<!-- 标签导航 -->
<div id="zhs-tab-nav" style="
display: flex;
background: #f8f9fa;
border-bottom: 1px solid #e9ecef;
padding: 0;
">
<button class="zhs-tab-btn active" data-tab="main" style="
flex: 1;
padding: 12px 8px;
border: none;
background: #409EFF;
color: white;
cursor: pointer;
font-size: 13px;
font-weight: 500;
transition: all 0.3s;
border-radius: 0;
">🏠 主面板</button>
<button class="zhs-tab-btn" data-tab="ai" style="
flex: 1;
padding: 12px 8px;
border: none;
background: transparent;
color: #666;
cursor: pointer;
font-size: 13px;
font-weight: 500;
transition: all 0.3s;
border-radius: 0;
">🤖 AI助手</button>
<button class="zhs-tab-btn" data-tab="tutorial" style="
flex: 1;
padding: 12px 8px;
border: none;
background: transparent;
color: #666;
cursor: pointer;
font-size: 13px;
font-weight: 500;
transition: all 0.3s;
border-radius: 0;
">📖 教程</button>
</div>
<!-- 标签内容区 - 修复自适应大小，不需要滚动条 -->
<div id="zhs-tab-content" style="
height: auto;
overflow: visible;
padding: 0;
">
<!-- 主面板内容 -->
<div id="zhs-tab-main" class="zhs-tab-panel active" style="
padding: 18px;
display: block;
">
<!-- 自动答题开关已删除 - 更多设置区域已有答题方式配置 -->
<!-- API Key 配置 -->
<div style="margin-bottom: 15px; padding: 10px; background: #f8f9fa; border-radius: 8px; ">
<div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">
<span style="font-weight: 500; color: #409EFF; font-size: 13px;">🔑 API配置</span>
</div>
<div style="display: flex; gap: 5px; margin-bottom: 8px;">
<input type="text" id="zhs-api-key-input" placeholder="请输入题库API Key" style="
flex: 1;
padding: 6px 8px;
border: 1px solid #ddd;
border-radius: 4px;
background: white;
color: #333;
font-size: 12px;
box-sizing: border-box;
" value="${localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || ''}">
<button id="zhs-save-key-btn" style="
padding: 6px 10px;
background: #409EFF;
color: white;
border: none;
border-radius: 4px;
cursor: pointer;
font-weight: 500;
font-size: 11px;
white-space: nowrap;
transition: all 0.3s;
" onmouseover="this.style.background='#337ecc'" onmouseout="this.style.background='#409EFF'">保存</button>
</div>
<div style="display: flex; gap: 5px;">
<button id="zhs-more-settings-btn" style="
flex: 1;
padding: 6px 10px;
background: #67C23A;
color: white;
border: none;
border-radius: 4px;
cursor: pointer;
font-weight: 500;
font-size: 11px;
transition: all 0.3s;
" onmouseover="this.style.background='#5daf34'" onmouseout="this.style.background='#67C23A'">更多设置</button>
<a href="http://tk.mixuelo.cc" target="_blank" style="
flex: 1;
padding: 6px 10px;
background: #E6A23C;
color: white;
border: none;
border-radius: 4px;
cursor: pointer;
font-weight: 500;
font-size: 11px;
text-decoration: none;
text-align: center;
transition: all 0.3s;
display: flex;
align-items: center;
justify-content: center;
" onmouseover="this.style.background='#d4941e'" onmouseout="this.style.background='#E6A23C'">🍯 蜜雪官网</a>
</div>
<div id="zhs-save-key-msg" style="
font-size: 11px;
margin-top: 5px;
padding: 5px 8px;
border-radius: 4px;
display: none;
transition: all 0.3s;
"></div>
<div style="font-size: 11px; color: #666; margin-top: 5px;">
💡 输入有效的API Key以使用题库功能
</div>
<!-- 更多设置区域 - 修复功能开关无效问题 -->
<div id="zhs-more-settings" style="
display: none;
margin: 10px 0;
padding: 10px;
background: #f8f9fa;
border-radius: 8px;
border: 1px solid #e0e0e0;">
<div style="
display: grid;
grid-template-columns: 1fr 1fr;
gap: 8px;
font-size: 12px;">
<div style="display: flex; align-items: center; gap: 5px;">
<input type="checkbox" id="GPTJsSetting.useTiku" ${localStorage.getItem('GPTJsSetting.useTiku') === 'true' ? 'checked' : ''}>
<label for="GPTJsSetting.useTiku" style="cursor: pointer;">题库答题</label>
</div>
<div style="display: flex; align-items: center; gap: 5px;">
<input type="checkbox" id="GPTJsSetting.useBackupTiku" ${localStorage.getItem('GPTJsSetting.useBackupTiku') === 'true' ? 'checked' : ''}>
<label for="GPTJsSetting.useBackupTiku" style="cursor: pointer;">备用题库</label>
</div>
<div style="display: flex; align-items: center; gap: 5px;">
<input type="checkbox" id="GPTJsSetting.useAI" ${localStorage.getItem('GPTJsSetting.useAI') === 'true' ? 'checked' : ''}>
<label for="GPTJsSetting.useAI" style="cursor: pointer;">AI答题</label>
</div>
<div style="display: flex; align-items: center; gap: 5px;">
<input type="checkbox" id="GPTJsSetting.autoSubmit" ${localStorage.getItem('GPTJsSetting.autoSubmit') === 'true' ? 'checked' : ''}>
<label for="GPTJsSetting.autoSubmit" style="cursor: pointer;">自动提交</label>
</div>
<div style="display: flex; align-items: center; gap: 5px;">
<input type="checkbox" id="GPTJsSetting.showAnswer" ${localStorage.getItem('GPTJsSetting.showAnswer') !== 'false' ? 'checked' : ''}>
<label for="GPTJsSetting.showAnswer" style="cursor: pointer;">显示答案</label>
</div>
</div>
<div style="margin-top: 10px;">
<label for="GPTJsSetting.model" style="color: #555; font-size: 12px;">AI模型:</label>
<select id="GPTJsSetting.model" style="
width: 100%;
padding: 4px;
border: 1px solid #ddd;
border-radius: 4px;
margin-top: 5px;
font-size: 12px;">
<option value="gpt-3.5-turbo-16k" ${localStorage.getItem('GPTJsSetting.model') === 'gpt-3.5-turbo-16k' ? 'selected' : ''}>GPT-3.5-Turbo</option>
<option value="gpt-4o-mini" ${localStorage.getItem('GPTJsSetting.model') === 'gpt-4o-mini' ? 'selected' : ''}>GPT-4o-Mini</option>
<option value="gpt-4" ${localStorage.getItem('GPTJsSetting.model') === 'gpt-4' ? 'selected' : ''}>GPT-4</option>
<option value="deepseek-chat" ${localStorage.getItem('GPTJsSetting.model') === 'deepseek-chat' ? 'selected' : ''}>DeepSeek</option>
<option value="glm-4-flash" ${localStorage.getItem('GPTJsSetting.model') === 'glm-4-flash' ? 'selected' : ''}>智谱GLM-4</option>
</select>
</div>
</div>
</div>
<!-- 操作按钮 - 删除开始答题按钮，默认自动答题 -->
<div style="display: flex; gap: 5px; margin-bottom: 10px;">
<button id="zhs-stop-answer" style="
flex: 1;
padding: 8px;
background: #F56C6C;
color: white;
border: none;
border-radius: 4px;
cursor: pointer;
font-weight: 500;
font-size: 12px;
transition: all 0.3s;
" onmouseover="this.style.background='#f45454'" onmouseout="this.style.background='#F56C6C'">停止答题</button>
<button id="zhs-show-log" style="
flex: 1;
padding: 8px;
background: #409EFF;
color: white;
border: none;
border-radius: 4px;
cursor: pointer;
font-weight: 500;
font-size: 12px;
transition: all 0.3s;
" onmouseover="this.style.background='#337ecc'" onmouseout="this.style.background='#409EFF'">显示日志</button>
</div>
<!-- 状态信息 -->
<div style="font-size: 11px; color: #666; text-align: center; padding: 5px; background: #f0f9ff; border-radius: 4px; ">
💡 进入页面自动开始答题，无需手动启动
</div>
</div>
<!-- AI助手面板内容 - 完全重新设计，确保可点击和输入，修复事件冲突 -->
<div id="zhs-tab-ai" class="zhs-tab-panel" style="
padding: 15px;
display: none;
background: white;
border-radius: 8px;
position: relative;
z-index: 1000;
pointer-events: auto;
overflow: visible;
height: auto;
" onmousedown="event.stopPropagation();" onclick="event.stopPropagation();">
<!-- AI模型选择 -->
<div style="margin-bottom: 18px;">
<label style="display: block; margin-bottom: 8px; font-size: 13px; font-weight: 500; color: #333;">选择模型:</label>
<select id="zhs-ai-model" style="
width: 100%;
padding: 8px 10px;
border: 1px solid #ddd;
border-radius: 4px;
font-size: 13px;
background: white;
cursor: pointer;
outline: none;
box-sizing: border-box;
position: relative;
z-index: 1001;
" onfocus="this.style.borderColor='#409EFF'" onblur="this.style.borderColor='#ddd'" onmousedown="event.stopPropagation();" onclick="event.stopPropagation();">
<option value="DeepSeek-Chat">DeepSeek-Chat (推荐)</option>
<option value="gpt-3.5-turbo">GPT-3.5-Turbo</option>
<option value="gpt-4">GPT-4</option>
<option value="claude-3">Claude-3</option>
</select>
</div>
<!-- AI问答区 -->
<div style="margin-bottom: 18px;">
<label style="display: block; margin-bottom: 8px; font-size: 13px; font-weight: 500; color: #333;">输入问题:</label>
<textarea id="zhs-ai-question" placeholder="请输入您的问题..." style="
width: 100%;
height: 60px;
padding: 8px;
border: 1px solid #ddd;
border-radius: 4px;
font-size: 13px;
resize: vertical;
font-family: inherit;
outline: none;
box-sizing: border-box;
background: white;
position: relative;
z-index: 1001;
" onfocus="this.style.borderColor='#409EFF'" onblur="this.style.borderColor='#ddd'" onmousedown="event.stopPropagation();" onclick="event.stopPropagation();"></textarea>
</div>
<button style="
width: 100%;
background: #409EFF;
color: white;
border: none;
padding: 8px 16px;
border-radius: 4px;
cursor: pointer;
font-size: 13px;
font-weight: 500;
margin-bottom: 15px;
outline: none;
box-sizing: border-box;
position: relative;
z-index: 1001;
" onmouseover="this.style.background='#337ecc'" onmouseout="this.style.background='#409EFF'" onmousedown="event.stopPropagation();" onclick="event.stopPropagation(); zhsAskAI();">获取答案</button>
<!-- AI回答区 -->
<div style="margin-bottom: 18px;">
<label style="display: block; margin-bottom: 8px; font-size: 13px; font-weight: 500; color: #333;">AI回答:</label>
<div id="zhs-ai-answer" style="
min-height: 60px;
padding: 8px;
border: 1px solid #ddd;
border-radius: 4px;
font-size: 13px;
background: #f8f9fa;
color: #666;
line-height: 1.5;
box-sizing: border-box;
position: relative;
z-index: 1000;
" onmousedown="event.stopPropagation();" onclick="event.stopPropagation();">AI助手已准备就绪，请输入您的问题...</div>
</div>
<button style="
width: 100%;
background: #67C23A;
color: white;
border: none;
padding: 8px 16px;
border-radius: 4px;
cursor: pointer;
font-size: 13px;
font-weight: 500;
outline: none;
box-sizing: border-box;
position: relative;
z-index: 1001;
" onmouseover="this.style.background='#5daf34'" onmouseout="this.style.background='#67C23A'" onmousedown="event.stopPropagation();" onclick="event.stopPropagation(); zhsCopyAnswer();">复制答案</button>
</div>
<div id="zhs-tab-tutorial" class="zhs-tab-panel" style="
padding: 18px;
display: none;
">
<div style="text-align: center; margin-bottom: 20px;">
<div style="font-size: 48px; margin-bottom: 10px;">📖</div>
<h3 style="margin: 0 0 8px 0; color: #409EFF; font-size: 16px;">使用教程</h3>
<p style="margin: 0; color: #666; font-size: 12px;">快速上手指南</p>
</div>
<div style="font-size: 13px; line-height: 1.6; color: #333;">
<div style="margin-bottom: 15px; padding: 12px; background: #fff3cd; border-radius: 8px; border-left: 4px solid #ffc107;">
<strong style="color: #856404;">⚠️ 免责声明</strong><br>
本脚本仅供学习交流使用，请勿用于商业用途。使用本脚本所产生的一切后果由用户自行承担，开发者不承担任何责任。请在遵守相关法律法规和学校规定的前提下使用。
</div>
<div style="margin-bottom: 15px;">
<strong style="color: #409EFF;">🚀 快速开始：</strong><br>
1. 点击"配置"按钮设置API Key<br>
2. 开启"自动答题"开关<br>
3. 脚本将自动处理题目
</div>
<div style="margin-bottom: 15px;">
<strong style="color: #409EFF;">⚙️ 功能说明：</strong><br>
• 题库API：优先使用题库答案<br>
• AI答题：智能分析题目内容<br>
• 状态指示：红绿方块显示答题结果
</div>
<div style="margin-bottom: 15px;">
<strong style="color: #409EFF;">⌨️ 快捷键：</strong><br>
• F9：显示/隐藏控制面板<br>
• F10：显示/隐藏日志窗口<br>
• Ctrl+Shift+S：手动启动答题
</div>
<div style="margin-bottom: 15px;">
<strong style="color: #409EFF;">💡 使用建议：</strong><br>
• 建议配置API Key以提高准确率<br>
• 遇到问题可刷新页面重试<br>
• 合理使用，避免过度依赖
</div>
<!-- 技术支持已删除 - 根据用户要求 -->
</div>
</div>
</div>
</div>
`;
document.body.appendChild(panel);
// 添加标签切换功能
addZhsTabSwitchListeners();
// 添加事件监听器
addZhihuishuPanelEventListeners();
// 初始化AI助手面板事件监听器
initAIAssistantListeners();
// 添加拖拽功能
makeZhihuishuPanelDraggable(panel);
// 初始化面板展开状态
initPanelExpandState();
}
// 初始化面板展开状态
function initPanelExpandState() {
const content = document.getElementById('zhs-panel-content');
const expandBtn = document.getElementById('zhs-expand-btn');
if (!content || !expandBtn) {
console.error('面板元素未找到');
return;
}
// 读取保存的展开状态，默认为收起
const isExpanded = localStorage.getItem('ZhsJsSetting.panelExpanded') === 'true';
if (isExpanded) {
content.style.display = 'block';
expandBtn.classList.add('expanded');
expandBtn.textContent = '▲';
} else {
expandBtn.classList.remove('expanded');
expandBtn.textContent = '▼';
}
}
// 添加标签切换功能 - 修复AI助手与教程按钮无法切换的问题
function addZhsTabSwitchListeners() {
// 等待DOM加载完成后再添加事件监听器
setTimeout(() => {
const tabButtons = document.querySelectorAll('.zhs-tab-btn');
const tabPanels = document.querySelectorAll('.zhs-tab-panel');
if (tabButtons.length === 0 || tabPanels.length === 0) {
console.log('标签元素未找到，跳过标签切换功能');
return;
}
tabButtons.forEach(button => {
button.addEventListener('click', function () {
const targetTab = this.getAttribute('data-tab');
// 移除所有按钮的active类
tabButtons.forEach(btn => {
btn.classList.remove('active');
btn.style.background = 'transparent';
btn.style.color = '#666';
});
// 隐藏所有面板
tabPanels.forEach(panel => {
panel.classList.remove('active');
panel.style.display = 'none';
});
// 激活当前按钮
this.classList.add('active');
this.style.background = '#409EFF';
this.style.color = 'white';
// 显示对应面板
const targetPanel = document.getElementById(`zhs-tab-${targetTab}`);
if (targetPanel) {
targetPanel.classList.add('active');
targetPanel.style.display = 'block';
}
logger(`切换到${this.textContent}标签`, 'blue');
});
});
logger('标签切换功能已初始化', 'green');
}, 100);
}
function initAIAssistantListeners() {
setTimeout(() => {
// 获取答案按钮
const getAnswerBtn = document.querySelector('#zhs-tab-ai button');
if (getAnswerBtn) {
// 移除内联事件，添加事件监听器
getAnswerBtn.removeAttribute('onclick');
getAnswerBtn.addEventListener('click', function (e) {
e.preventDefault();
e.stopPropagation();
zhsAskAI();
});
logger('AI助手获取答案按钮事件已绑定', 'green');
}
// 复制答案按钮
const copyBtn = document.querySelector('#zhs-tab-ai button:last-child');
if (copyBtn && copyBtn.textContent.includes('复制')) {
copyBtn.removeAttribute('onclick');
copyBtn.addEventListener('click', function (e) {
e.preventDefault();
e.stopPropagation();
zhsCopyAnswer();
});
logger('AI助手复制答案按钮事件已绑定', 'green');
}
const questionInput = document.getElementById('zhs-ai-question');
if (questionInput) {
questionInput.addEventListener('click', function (e) {
e.stopPropagation();
});
questionInput.addEventListener('focus', function (e) {
e.stopPropagation();
});
logger('AI助手输入框事件已绑定', 'green');
}
const modelSelect = document.getElementById('zhs-ai-model');
if (modelSelect) {
modelSelect.addEventListener('click', function (e) {
e.stopPropagation();
});
modelSelect.addEventListener('change', function (e) {
e.stopPropagation();
});
logger('AI助手模型选择框事件已绑定', 'green');
}
}, 200);
}
function zhsAskAI() {
const questionInput = document.getElementById('zhs-ai-question');
const modelSelect = document.getElementById('zhs-ai-model');
const answerDiv = document.getElementById('zhs-ai-answer');
if (!questionInput || !modelSelect || !answerDiv) {
logger('❌ AI助手DOM元素获取失败', 'red');
return;
}
const question = questionInput.value.trim();
const model = modelSelect.value;
logger(`🤖 用户输入: "${question}", 选择模型: "${model}"`, 'blue');
if (!question) {
answerDiv.textContent = '请输入问题';
logger('⚠️ 用户未输入问题', 'orange');
return;
}
const userKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || '';
if (!userKey) {
answerDiv.textContent = 'Key不存在，请前往蜜雪激活';
logger('⚠️ Key不存在，请前往蜜雪激活', 'orange');
return;
}
answerDiv.textContent = '正在思考中...';
logger('🤖 AI助手开始处理问题...', 'blue');
zhsGetAIAnswer(question, '问答题')
.then(answer => {
logger(`🤖 AI返回答案: "${answer}"`, 'green');
answerDiv.textContent = answer || '抱歉，无法获取答案';
// logger('🤖 AI助手回答完成，UI已更新', 'green');
})
.catch(error => {
logger(`🤖 AI助手回答失败: ${error}`, 'red');
answerDiv.textContent = `错误: ${error}`;
});
}
// 复制AI助手答案到剪贴板
function zhsCopyAnswer() {
const answerDiv = document.getElementById('zhs-ai-answer');
if (!answerDiv) {
logger('⚠️ 未找到AI答案区域', 'orange');
return;
}
const answer = answerDiv.textContent.trim();
if (!answer || answer === 'AI助手已准备就绪，请输入您的问题...' || answer === '正在思考中...') {
logger('⚠️ 没有可复制的答案', 'orange');
return;
}
// 复制到剪贴板
if (navigator.clipboard && window.isSecureContext) {
navigator.clipboard.writeText(answer).then(() => {
logger('✅ 答案已复制到剪贴板', 'green');
}).catch(err => {
logger('❌ 复制失败: ' + err, 'red');
});
} else {
// 降级方案：使用传统的复制方法
const textArea = document.createElement('textarea');
textArea.value = answer;
document.body.appendChild(textArea);
textArea.select();
try {
document.execCommand('copy');
logger('✅ 答案已复制到剪贴板', 'green');
} catch (err) {
logger('❌ 复制失败: ' + err, 'red');
}
document.body.removeChild(textArea);
}
}
function toggleZhsPanel() {
const content = document.getElementById('zhs-panel-content');
const expandBtn = document.getElementById('zhs-expand-btn');
if (!content || !expandBtn) {
console.error('面板元素未找到');
return;
}
// 检查当前状态
const isHidden = content.style.display === 'none';
if (isHidden) {
content.style.display = 'block';
if (expandBtn) {
expandBtn.style.transform = 'rotate(180deg)';
}
localStorage.setItem('ZhsJsSetting.panelExpanded', 'true');
logger('控制面板已展开', 'blue');
} else {
content.style.display = 'none';
if (expandBtn) {
expandBtn.style.transform = 'rotate(0deg)';
}
localStorage.setItem('ZhsJsSetting.panelExpanded', 'false');
logger('控制面板已收起', 'blue');
}
}
function toggleZhsLogWindow() {
const logWindow = document.getElementById('zhs-log-window');
if (logWindow) {
if (logWindow.style.display === 'none') {
logWindow.style.display = 'block';
localStorage.setItem('ZhsJsSetting.hideLogWindow', 'false');
logger('日志窗口已显示', 'blue');
} else {
logWindow.style.display = 'none';
localStorage.setItem('ZhsJsSetting.hideLogWindow', 'true');
logger('日志窗口已隐藏', 'blue');
}
}
}
function clearZhsLog() {
const logContainer = document.getElementById('zhs-log-container');
if (logContainer) {
logContainer.innerHTML = '';
logger('日志已清空', 'blue');
}
}
if (typeof unsafeWindow !== 'undefined') {
unsafeWindow.toggleZhsPanel = toggleZhsPanel;
unsafeWindow.toggleZhsLogWindow = toggleZhsLogWindow;
unsafeWindow.clearZhsLog = clearZhsLog;
unsafeWindow.zhsAskAI = zhsAskAI;
unsafeWindow.zhsCopyAnswer = zhsCopyAnswer;
} else {
window.toggleZhsPanel = toggleZhsPanel;
window.toggleZhsLogWindow = toggleZhsLogWindow;
window.clearZhsLog = clearZhsLog;
window.zhsAskAI = zhsAskAI;
window.zhsCopyAnswer = zhsCopyAnswer;
}
// 初始化复选框状态
function initCheckboxStates() {
// 自动答题开关已删除 - 更多设置区域已有答题方式配置
// 自动播放视频开关
const autoVideoToggle = document.getElementById('zhs-auto-video');
if (autoVideoToggle) {
autoVideoToggle.checked = localStorage.getItem('ZhsJsSetting.video') === 'true';
}
// 自动切换下一节开关
const autoJumpToggle = document.getElementById('zhs-auto-jump');
if (autoJumpToggle) {
autoJumpToggle.checked = localStorage.getItem('ZhsJsSetting.jump') === 'true';
}
// AI智能答题开关
const useAIToggle = document.getElementById('zhs-use-ai');
if (useAIToggle) {
useAIToggle.checked = localStorage.getItem('ZhsJsSetting.useAI') === 'true' ||
localStorage.getItem('GPTJsSetting.useAI') === 'true';
}
// 自动提交开关
const autoSubmitToggle = document.getElementById('zhs-auto-submit');
if (autoSubmitToggle) {
autoSubmitToggle.checked = localStorage.getItem('ZhsJsSetting.autoSubmit') === 'true' ||
localStorage.getItem('GPTJsSetting.autoSubmit') === 'true';
}
// 题库答题开关
const mainDatabaseToggle = document.getElementById('zhs-main-database');
if (mainDatabaseToggle) {
mainDatabaseToggle.checked = localStorage.getItem('ZhsJsSetting.useTiku') === 'true' ||
localStorage.getItem('GPTJsSetting.useTiku') === 'true';
}
// 更多设置区域的复选框状态初始化 - 修复默认状态
const useTikuCheckbox = document.getElementById('GPTJsSetting.useTiku');
if (useTikuCheckbox) {
useTikuCheckbox.checked = localStorage.getItem('GPTJsSetting.useTiku') === 'true';
}
const useBackupTikuCheckbox = document.getElementById('GPTJsSetting.useBackupTiku');
if (useBackupTikuCheckbox) {
useBackupTikuCheckbox.checked = false; // 备用题库功能已删除
}
const useAICheckbox = document.getElementById('GPTJsSetting.useAI');
if (useAICheckbox) {
useAICheckbox.checked = localStorage.getItem('GPTJsSetting.useAI') === 'true';
}
const autoSubmitCheckbox = document.getElementById('GPTJsSetting.autoSubmit');
if (autoSubmitCheckbox) {
autoSubmitCheckbox.checked = localStorage.getItem('GPTJsSetting.autoSubmit') === 'true';
}
const showAnswerCheckbox = document.getElementById('GPTJsSetting.showAnswer');
if (showAnswerCheckbox) {
showAnswerCheckbox.checked = localStorage.getItem('GPTJsSetting.showAnswer') === 'true';
}
const modelSelect = document.getElementById('GPTJsSetting.model');
if (modelSelect) {
modelSelect.value = localStorage.getItem('GPTJsSetting.model') || 'gpt-3.5-turbo-16k';
}
logger('复选框状态已初始化', 'blue');
}
// 初始化面板状态
function initZhsPanelState() {
// 延迟执行，确保DOM元素已创建
setTimeout(() => {
const isExpanded = localStorage.getItem('ZhsJsSetting.panelExpanded') === 'true';
const content = document.getElementById('zhs-panel-content');
const expandBtn = document.getElementById('zhs-expand-btn');
if (!content || !expandBtn) {
console.error('面板元素未找到，无法初始化状态');
return;
}
if (isExpanded) {
content.style.display = 'block';
expandBtn.classList.add('expanded');
expandBtn.textContent = '▲';
} else {
content.style.display = 'none';
expandBtn.classList.remove('expanded');
expandBtn.textContent = '▼';
}
// 初始化复选框状态
initCheckboxStates();
}, 100);
}
// 添加题目状态指示器
function addQuestionStatusIndicator(questionNumber, status, details = {}) {
const statusContainer = document.getElementById('zhs-status-indicators');
if (!statusContainer) return;
// 移除已存在的相同题目指示器
const existingIndicator = document.getElementById(`zhs-status-${questionNumber}`);
if (existingIndicator) {
existingIndicator.remove();
}
// 创建新的状态指示器 - 修复颜色显示问题
const indicator = document.createElement('div');
indicator.id = `zhs-status-${questionNumber}`;
// 根据状态设置颜色
let backgroundColor, title;
if (status === 'success') {
backgroundColor = '#67C23A'; // 绿色
title = '答题成功';
} else if (status === 'failed') {
backgroundColor = '#F56C6C'; // 红色
title = '答题失败';
} else {
backgroundColor = '#E6A23C'; // 橙色
title = '处理中';
}
indicator.style.cssText = `
width: 24px;
height: 24px;
border-radius: 4px;
display: flex;
align-items: center;
justify-content: center;
font-size: 12px;
font-weight: bold;
color: white;
cursor: pointer;
transition: all 0.3s ease;
margin: 2px;
background: ${backgroundColor};
`;
indicator.textContent = questionNumber;
indicator.title = title;
// 点击显示详细信息
indicator.addEventListener('click', () => {
showQuestionDetails(questionNumber, status, details);
});
statusContainer.appendChild(indicator);
}
// 显示题目详细信息
function showQuestionDetails(questionNumber, status, details) {
const detailsHtml = `
<div style="
position: fixed;
top: 50%;
left: 50%;
transform: translate(-50%, -50%);
background: white;
border-radius: 10px;
box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
padding: 20px;
max-width: 500px;
max-height: 400px;
overflow-y: auto;
z-index: 2147483647;
" id="zhs-question-details">
<div style="
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 15px;
padding-bottom: 10px;
border-bottom: 1px solid #e9ecef;
">
<h3 style="margin: 0; color: #409EFF;">第${questionNumber}题详情</h3>
<button onclick="document.getElementById('zhs-question-details').remove()" style="
background: none;
border: none;
font-size: 18px;
cursor: pointer;
color: #999;
">×</button>
</div>
<div style="margin-bottom: 10px;">
<strong>状态：</strong>
<span style="color: ${status === 'success' ? '#67C23A' : '#F56C6C'};">
${status === 'success' ? '✅ 答题成功' : '❌ 答题失败'}
</span>
</div>
${details.question ? `<div style="margin-bottom: 10px;"><strong>题目：</strong>${details.question}</div>` : ''}
${details.type ? `<div style="margin-bottom: 10px;"><strong>类型：</strong>${details.type}</div>` : ''}
${details.options ? `<div style="margin-bottom: 10px;"><strong>选项：</strong>${details.options}</div>` : ''}
${details.answer ? `<div style="margin-bottom: 10px;"><strong>答案：</strong>${details.answer}</div>` : ''}
${details.selected ? `<div style="margin-bottom: 10px;"><strong>已选：</strong>${details.selected}</div>` : ''}
${details.error ? `<div style="margin-bottom: 10px; color: #F56C6C;"><strong>错误：</strong>${details.error}</div>` : ''}
</div>
`;
// 移除已存在的详情窗口
const existingDetails = document.getElementById('zhs-question-details');
if (existingDetails) {
existingDetails.remove();
}
document.body.insertAdjacentHTML('beforeend', detailsHtml);
}
function getCurrentQuestionNumber() {
const questionNumberMatch = document.body.textContent.match(/第\s*(\d+)\s*题|(\d+)\.\s*【|题目\s*(\d+)/);
if (questionNumberMatch) {
return parseInt(questionNumberMatch[1] || questionNumberMatch[2] || questionNumberMatch[3]);
}
if (typeof setting !== 'undefined' && setting.num !== undefined) {
return setting.num + 1;
}
const processedQuestions = document.querySelectorAll('.question-status-indicator').length;
return processedQuestions + 1;
}
function getQuestionText(questionElement) {
let questionText = '';
const questionContentDiv = questionElement.find('.questionContent');
if (questionContentDiv.length > 0) {
const spans = questionContentDiv.find('p span');
if (spans.length > 0) {
let spanTexts = [];
let seenTexts = new Set(); // 用于去重
spans.each(function () {
const spanText = $(this).text().trim();
if (spanText && !spanText.match(/^[A-D]\./) && spanText.length > 0) {
if (!seenTexts.has(spanText)) {
spanTexts.push(spanText);
seenTexts.add(spanText);
}
}
});
questionText = spanTexts.join('').trim();
logger(`🔍 getQuestionText从.questionContent p span获取: ${questionText.substring(0, 50)}...`, 'blue');
}
}
if (!questionText) {
const paragraphs = questionElement.find('p').not('.optionUl p, .el-radio p');
paragraphs.each(function () {
const text = $(this).text().trim();
if (!text.match(/^[一二三四五六七八九十]、.*?题/) &&
!text.match(/^[A-D]\./) &&
text.length > 10) {
questionText = text;
return false; // 找到题目内容后跳出
}
});
}
if (!questionText) {
const questionSelectors = [
'.questionTit',
'.question-text',
'.subject_stem',
'.question-content',
'.question-title'
];
for (const selector of questionSelectors) {
const element = questionElement.find(selector);
if (element.length > 0) {
questionText = element.text().trim();
if (questionText.length > 10) {
break;
}
}
}
}
// 如果还是没找到，使用原来的简化逻辑作为最后备选
if (!questionText) {
questionText = questionElement.find('p, div').first().text().trim();
}
return questionText || '未获取到题目内容';
}
function zhsVerifyAPIKey(key) {
return new Promise((resolve, reject) => {
if (!key || key.trim() === '') {
reject('Key不能为空');
return;
}
const API_BASE_URL = (() => {
const baseUrl = "tk.mixuelo.cc/api.php";
const protocol = window.location.protocol;
if (protocol === 'https:') {
return "https://" + baseUrl;
} else {
return "http://" + baseUrl;
}
})();
GM_xmlhttpRequest({
url: API_BASE_URL + "?act=verify_key",
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded"
},
data: "key=" + encodeURIComponent(key),
onload: function (response) {
try {
const result = JSON.parse(response.responseText);
if (result.code === 1) {
// 验证成功，保存key
localStorage.setItem('GPTJsSetting.key', key);
localStorage.setItem('tiku_key', key);
resolve({ success: true, message: result.msg || 'Key验证成功' });
} else {
// 验证失败
resolve({ success: false, message: result.msg || 'Key验证失败' });
}
} catch (e) {
resolve({ success: false, message: '响应解析失败: ' + e.message });
}
},
onerror: function (error) {
reject('网络错误');
},
ontimeout: function () {
reject('请求超时');
}
});
});
}
function createZhihuishuLogWindow() {
if (document.getElementById('zhs-log-window')) {
return;
}
const shouldHide = localStorage.getItem('ZhsJsSetting.hideLogBox') === 'true';
const initialDisplay = shouldHide ? 'none' : 'block';
const logWindow = document.createElement('div');
logWindow.id = 'zhs-log-window';
logWindow.className = 'gpt-box';
logWindow.style.cssText = `
position: fixed !important;
top: 80px !important;
right: 370px !important;
width: 350px !important;
max-height: 500px !important;
background: rgba(255, 255, 255, 0.95) !important;
border-radius: 10px !important;
box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37) !important;
backdrop-filter: blur(4px) !important;
-webkit-backdrop-filter: blur(4px) !important;
border: 1px solid rgba(255, 255, 255, 0.18) !important;
z-index: 2147483645 !important;
font-family: "Microsoft YaHei", sans-serif !important;
transition: all 0.3s ease !important;
cursor: move !important;
transform: none !important;
margin: 0 !important;
display: ${initialDisplay} !important;
`;
logWindow.innerHTML = `
<div class="gpt-box-header" style="
cursor: move;
padding: 5px 0;
margin-bottom: 10px;
border-bottom: 1px solid #eee;
display: flex;
justify-content: space-between;
align-items: center;
background: #409EFF !important;
color: white !important;
border-radius: 10px 10px 0 0 !important;
padding: 10px 15px !important;
">
<div class="gpt-box-title" style="
font-weight: bold;
color: white;
font-size: 14px;
display: flex;
align-items: center;
gap: 8px;
">
📋 答题日志
</div>
<div class="gpt-box-actions" style="
display: flex;
gap: 8px;
">
<button onclick="clearZhsLog()" title="清空日志" style="
background: rgba(255, 255, 255, 0.2) !important;
border: none !important;
border-radius: 4px !important;
padding: 4px 8px !important;
color: white !important;
cursor: pointer !important;
font-size: 12px !important;
transition: all 0.3s !important;
" onmouseover="this.style.background='rgba(255,255,255,0.3)'" onmouseout="this.style.background='rgba(255,255,255,0.2)'">清空</button>
<button onclick="document.getElementById('zhs-log-window').style.display='none'" title="隐藏日志" style="
background: rgba(255, 255, 255, 0.2) !important;
border: none !important;
border-radius: 4px !important;
padding: 4px 8px !important;
color: white !important;
cursor: pointer !important;
font-size: 12px !important;
transition: all 0.3s !important;
" onmouseover="this.style.background='rgba(255,255,255,0.3)'" onmouseout="this.style.background='rgba(255,255,255,0.2)'">隐藏</button>
</div>
</div>
<!-- 题目状态指示器区域 - 红色/绿色正方形数字 -->
<div id="zhs-question-status" style="
padding: 10px 15px;
border-bottom: 1px solid #e9ecef;
background: white;
">
<div style="font-size: 12px; color: #666; margin-bottom: 8px; font-weight: 500;">题目状态：</div>
<div id="zhs-status-indicators" style="
display: flex;
flex-wrap: wrap;
gap: 6px;
min-height: 30px;
align-items: flex-start;
"></div>
</div>
<!-- 详细日志区域 -->
<div class="gpt-messages-container" style="
max-height: 250px !important;
overflow-y: auto !important;
padding: 10px 15px !important;
font-size: 11px !important;
line-height: 1.4 !important;
color: #333 !important;
font-family: 'Microsoft YaHei', sans-serif !important;
word-wrap: break-word !important;
background: white !important;
" id="zhs-log-container"></div>
`;
document.body.appendChild(logWindow);
// 添加拖拽功能
makeZhihuishuLogWindowDraggable(logWindow);
}
// 清空日志函数
function clearZhsLog() {
const logContainer = document.getElementById('zhs-log-container');
const statusIndicators = document.getElementById('zhs-status-indicators');
if (logContainer) {
logContainer.innerHTML = '';
logger('📝 日志已清空', 'blue');
}
if (statusIndicators) {
statusIndicators.innerHTML = '';
}
}
// 题目状态管理器 - 集成到日志窗口中
const questionStatusManager = {
questions: new Map(),
// 添加或更新题目状态
updateQuestionStatus(questionNumber, status, details = {}) {
// 保存题目信息
this.questions.set(questionNumber, {
number: questionNumber,
status: status, // 'success', 'failed', 'pending'
question: details.question || '',
answer: details.answer || '',
selectedOptions: details.selectedOptions || '',
timestamp: new Date(),
...details
});
// 更新UI显示
this.updateStatusIndicator(questionNumber, status, details);
},
// 更新状态指示器UI - 集成到日志窗口
updateStatusIndicator(questionNumber, status, details = {}) {
const statusIndicators = document.getElementById('zhs-status-indicators');
if (!statusIndicators) {
logger('⚠️ 未找到日志窗口中的状态指示器容器', 'orange');
return;
}
// 移除已存在的指示器
const existingIndicator = document.getElementById(`zhs-status-${questionNumber}`);
if (existingIndicator) {
existingIndicator.remove();
}
// 创建新的状态指示器
const indicator = document.createElement('div');
indicator.id = `zhs-status-${questionNumber}`;
indicator.className = 'question-status-indicator';
const backgroundColor = status === 'success' ? '#67C23A' :
status === 'failed' ? '#F56C6C' : '#E6A23C';
indicator.style.cssText = `
width: 28px;
height: 28px;
background: ${backgroundColor};
color: white;
display: flex;
align-items: center;
justify-content: center;
border-radius: 4px;
font-size: 12px;
font-weight: bold;
cursor: pointer;
transition: all 0.3s;
margin: 2px;
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
user-select: none;
`;
indicator.textContent = questionNumber;
indicator.title = `第${questionNumber}题 - 点击查看详情`;
// 悬停效果
indicator.onmouseover = function () {
this.style.transform = 'scale(1.1)';
this.style.boxShadow = '0 4px 8px rgba(0,0,0,0.2)';
};
indicator.onmouseout = function () {
this.style.transform = 'scale(1)';
this.style.boxShadow = '0 2px 4px rgba(0,0,0,0.1)';
};
// 点击显示详情
indicator.addEventListener('click', () => {
this.showQuestionDetail(questionNumber);
});
// 按题目编号顺序插入
const indicators = statusIndicators.querySelectorAll('.question-status-indicator');
let inserted = false;
for (const existingIndicator of indicators) {
const existingNumber = parseInt(existingIndicator.textContent);
if (questionNumber < existingNumber) {
statusIndicators.insertBefore(indicator, existingIndicator);
inserted = true;
break;
}
}
if (!inserted) {
statusIndicators.appendChild(indicator);
}
logger(`📊 题目${questionNumber}状态已更新: ${status}`, status === 'success' ? 'green' : status === 'failed' ? 'red' : 'orange');
},
// 显示题目详情
showQuestionDetail(questionNumber) {
const questionData = this.questions.get(questionNumber);
if (!questionData) {
logger(`未找到第${questionNumber}题的数据`, 'orange');
return;
}
// 移除已存在的详情窗口
const existingDetail = document.getElementById('question-detail-modal');
if (existingDetail) {
existingDetail.remove();
}
const modal = document.createElement('div');
modal.id = 'question-detail-modal';
modal.style.cssText = `
position: fixed;
top: 0;
left: 0;
width: 100%;
height: 100%;
background: rgba(0, 0, 0, 0.5);
z-index: 2147483648;
display: flex;
align-items: center;
justify-content: center;
`;
const statusText = {
'success': '✅ 成功',
'failed': '❌ 失败',
'pending': '⏳ 进行中'
};
modal.innerHTML = `
<div style="
background: white;
border-radius: 10px;
padding: 20px;
max-width: 500px;
max-height: 80vh;
overflow-y: auto;
box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
border: 2px solid #409EFF;
">
<div style="
background: linear-gradient(135deg, #409EFF 0%, #36A3F7 100%);
color: white;
padding: 10px 15px;
border-radius: 6px;
margin: -20px -20px 15px -20px;
display: flex;
justify-content: space-between;
align-items: center;
">
<span style="font-weight: 500;">题目详情 - 第${questionNumber}题</span>
<button onclick="this.parentElement.parentElement.parentElement.remove()" style="
background: rgba(255, 255, 255, 0.2);
border: none;
color: white;
padding: 4px 8px;
border-radius: 4px;
cursor: pointer;
">×</button>
</div>
<div style="margin-bottom: 15px;">
<div style="font-weight: 500; color: #333; margin-bottom: 5px;">题目编号：</div>
<div style="color: #666;">第${questionNumber}题</div>
</div>
<div style="margin-bottom: 15px;">
<div style="font-weight: 500; color: #333; margin-bottom: 5px;">题目内容：</div>
<div style="color: #666; line-height: 1.4; word-break: break-word;">${questionData?.question || '暂无题目内容'}</div>
</div>
<div style="margin-bottom: 15px;">
<div style="font-weight: 500; color: #333; margin-bottom: 5px;">选择选项：</div>
<div style="color: #666;">${questionData?.selectedOptions || questionData?.answer || '暂无答案'}</div>
</div>
<div style="margin-bottom: 15px;">
<div style="font-weight: 500; color: #333; margin-bottom: 5px;">答题状态：</div>
<div style="color: #666;">${statusText[questionData?.status] || questionData?.status || '未知状态'}</div>
</div>
<div>
<div style="font-weight: 500; color: #333; margin-bottom: 5px;">处理时间：</div>
<div style="color: #666;">${questionData?.timestamp ? questionData.timestamp.toLocaleString() : '暂无时间'}</div>
</div>
</div>
`;
document.body.appendChild(modal);
// 点击模态框外部关闭
modal.addEventListener('click', function (e) {
if (e.target === modal) {
modal.remove();
}
});
// 5秒后自动关闭
setTimeout(() => {
if (modal.parentElement) {
modal.remove();
}
}, 5000);
}
};
function addZhihuishuPanelEventListeners() {
const panelHeader = document.querySelector('#zhs-control-panel .gpt-box-header');
if (panelHeader) {
panelHeader.addEventListener('click', function (e) {
// 防止事件冒泡
e.stopPropagation();
toggleZhsPanel();
});
}
const autoVideoToggle = document.getElementById('zhs-auto-video');
if (autoVideoToggle) {
autoVideoToggle.addEventListener('change', (e) => {
setting.video = e.target.checked;
updateToggleStyle(e.target);
logger(`自动播放视频已${setting.video ? '开启' : '关闭'}`, setting.video ? 'green' : 'orange');
});
}
// 播放倍速选择
const speedSelect = document.getElementById('zhs-video-speed');
if (speedSelect) {
speedSelect.addEventListener('change', (e) => {
setting.speed = e.target.value;
logger(`播放倍速设置为 ${setting.speed}x`, 'blue');
});
}
// 音量滑块
const volumeSlider = document.getElementById('zhs-volume');
const volumeDisplay = document.getElementById('zhs-volume-display');
if (volumeSlider && volumeDisplay) {
volumeSlider.addEventListener('input', (e) => {
setting.vol = e.target.value;
volumeDisplay.textContent = `${setting.vol}%`;
});
volumeSlider.addEventListener('change', (e) => {
logger(`音量设置为 ${setting.vol}%`, 'blue');
});
}
// API Key输入框
const apiKeyInput = document.getElementById('zhs-api-key-input');
if (apiKeyInput) {
apiKeyInput.addEventListener('input', (e) => {
const key = e.target.value.trim();
localStorage.setItem('GPTJsSetting.key', key);
localStorage.setItem('tiku_key', key); // 同步到tiku_key
if (key) {
logger('API Key已更新: ' + key.substring(0, 3) + '***' + key.substring(key.length - 3), 'green');
} else {
logger('API Key已清空', 'orange');
}
});
}
const stopAnswerBtn = document.getElementById('zhs-stop-answer');
if (stopAnswerBtn) {
stopAnswerBtn.addEventListener('click', () => {
const isCurrentlyWorking = localStorage.getItem('GPTJsSetting.work') === 'true';
if (isCurrentlyWorking) {
// 当前正在答题，执行停止操作
setting.work = false;
localStorage.setItem('GPTJsSetting.work', 'false');
localStorage.setItem('ZhsJsSetting.work', 'false');
logger('🛑 停止自动答题', 'red');
// 清除所有答题相关的定时器
if (setting.loop) {
clearInterval(setting.loop);
setting.loop = null;
}
// 清空答题队列
setting.queue = [];
logger('🛑 已清空答题队列', 'blue');
setting.shouldNavigateNext = false;
zhsStopAllAutoActions();
stopAnswerBtn.textContent = '开始答题';
stopAnswerBtn.style.background = '#67C23A';
stopAnswerBtn.onmouseover = function () { this.style.background = '#5daf34'; };
stopAnswerBtn.onmouseout = function () { this.style.background = '#67C23A'; };
logger('✅ 所有自动化操作已停止，可手动操作', 'green');
logger('💡 点击"开始答题"按钮可重新开始自动答题', 'blue');
} else {
setting.work = true;
localStorage.setItem('GPTJsSetting.work', 'true');
localStorage.setItem('ZhsJsSetting.work', 'true');
logger('🚀 重新开始自动答题', 'green');
stopAnswerBtn.textContent = '停止答题';
stopAnswerBtn.style.background = '#F56C6C';
stopAnswerBtn.onmouseover = function () { this.style.background = '#f45454'; };
stopAnswerBtn.onmouseout = function () { this.style.background = '#F56C6C'; };
setTimeout(() => {
if (checkZhsAnswerPage()) {
logger('🎯 重新启动答题功能', 'green');
zhsProcessQuestions();
}
}, 1000);
}
});
}
const moreSettingsBtn = document.getElementById('zhs-more-settings-btn');
const moreSettings = document.getElementById('zhs-more-settings');
let isSettingsVisible = false;
if (moreSettingsBtn && moreSettings) {
moreSettingsBtn.addEventListener('click', () => {
isSettingsVisible = !isSettingsVisible;
moreSettings.style.display = isSettingsVisible ? 'block' : 'none';
moreSettingsBtn.textContent = isSettingsVisible ? '隐藏设置' : '设置';
});
}
const showLogBtn = document.getElementById('zhs-show-log');
if (showLogBtn) {
showLogBtn.addEventListener('click', () => {
const logWindow = document.getElementById('zhs-log-window');
if (logWindow) {
logWindow.style.display = logWindow.style.display === 'none' ? 'block' : 'none';
showLogBtn.textContent = logWindow.style.display === 'none' ? '显示日志' : '隐藏日志';
}
});
}
const tutorialBtn = document.getElementById('zhs-tutorial-btn');
if (tutorialBtn) {
tutorialBtn.addEventListener('click', () => {
const tutorialContent = `🌳 智慧树助手使用教程
📋 基本功能：
• 进入页面自动开始答题，无需手动启动
• 支持题库API、AI答题多种模式
• 实时显示答题状态和结果
🔧 配置说明：
• API配置：输入题库API Key并保存
• 更多设置：可开启/关闭各种答题模式
• AI模型：可选择不同的AI模型
⌨️ 快捷键：
• F9：显示/隐藏控制面板
• F10：显示/隐藏日志窗口
• Ctrl+Shift+S：手动启动答题
📊 状态指示器：
• 绿色方块：答题成功
• 红色方块：答题失败或跳过
• 点击方块可查看详细信息
💡 注意事项：
• 请合理使用，遵守学习规范
• 建议配置API Key以提高准确率
• 如遇问题可刷新页面重新开始`;
const modal = document.createElement('div');
modal.style.cssText = `
position: fixed;
top: 0;
left: 0;
width: 100%;
height: 100%;
background: rgba(0,0,0,0.5);
z-index: 2147483648;
display: flex;
align-items: center;
justify-content: center;
`;
modal.innerHTML = `
<div style="
background: white;
border-radius: 10px;
padding: 20px;
max-width: 500px;
max-height: 80vh;
overflow-y: auto;
box-shadow: 0 4px 12px rgba(0,0,0,0.15);
">
<div style="
font-weight: bold;
font-size: 16px;
color: #409EFF;
margin-bottom: 15px;
text-align: center;
">智慧树助手使用教程</div>
<div style="
white-space: pre-line;
line-height: 1.6;
color: #333;
font-size: 13px;
">${tutorialContent}</div>
<div style="text-align: center; margin-top: 20px;">
<button onclick="this.parentElement.parentElement.parentElement.remove()" style="
padding: 8px 20px;
background: #409EFF;
color: white;
border: none;
border-radius: 4px;
cursor: pointer;
font-size: 13px;
">关闭</button>
</div>
</div>
`;
document.body.appendChild(modal);
// 点击背景关闭
modal.addEventListener('click', (e) => {
if (e.target === modal) {
modal.remove();
}
});
});
}
const clearLogBtn = document.getElementById('zhs-clear-log');
if (clearLogBtn) {
clearLogBtn.addEventListener('click', () => {
const logContainer = document.getElementById('zhs-log-container');
if (logContainer) {
logContainer.innerHTML = '';
logger('日志已清空', 'blue');
}
});
}
const saveKeyBtn = document.getElementById('zhs-save-key-btn');
if (saveKeyBtn) {
saveKeyBtn.addEventListener('click', () => {
const key = document.getElementById('zhs-api-key-input').value.trim();
const saveKeyMsg = document.getElementById('zhs-save-key-msg');
if (!key) {
saveKeyMsg.innerText = '请输入Key！';
saveKeyMsg.style.backgroundColor = '#f44336';
saveKeyMsg.style.color = 'white';
saveKeyMsg.style.display = 'block';
setTimeout(() => {
saveKeyMsg.style.display = 'none';
}, 3000);
return;
}
saveKeyMsg.innerText = '正在验证Key...';
saveKeyMsg.style.backgroundColor = '#2196F3';
saveKeyMsg.style.color = 'white';
saveKeyMsg.style.display = 'block';
saveKeyBtn.disabled = true;
saveKeyBtn.innerText = '验证中...';
zhsVerifyAPIKey(key).then(result => {
if (result.success) {
localStorage.setItem('GPTJsSetting.key', key);
localStorage.setItem('tiku_key', key);
saveKeyMsg.innerText = 'API Key 保存成功！';
saveKeyMsg.style.backgroundColor = '#4CAF50';
logger('API Key 保存成功！', 'green');
} else {
saveKeyMsg.innerText = 'Key不存在，请前往蜜雪激活';
saveKeyMsg.style.backgroundColor = '#f44336';
logger('Key不存在，请前往蜜雪激活', 'red');
}
}).catch(error => {
saveKeyMsg.innerText = '验证失败: ' + error;
saveKeyMsg.style.backgroundColor = '#f44336';
logger('Key验证出错: ' + error, 'red');
}).finally(() => {
saveKeyBtn.disabled = false;
saveKeyBtn.innerText = '保存验证';
setTimeout(() => {
saveKeyMsg.style.display = 'none';
}, 3000);
});
});
}
// 最小化按钮
const minimizeBtn = document.getElementById('zhs-minimize-btn');
const panelContent = document.getElementById('zhs-panel-content');
if (minimizeBtn && panelContent) {
minimizeBtn.addEventListener('click', () => {
const isMinimized = panelContent.style.display === 'none';
panelContent.style.display = isMinimized ? 'block' : 'none';
minimizeBtn.textContent = isMinimized ? '−' : '+';
});
}
// 关闭按钮
const closeBtn = document.getElementById('zhs-close-btn');
if (closeBtn) {
closeBtn.addEventListener('click', () => {
const panel = document.getElementById('zhs-control-panel');
if (panel) {
panel.style.display = 'none';
}
});
}
// 绑定更多设置区域的事件监听器
bindMoreSettingsEventListeners();
}
function bindMoreSettingsEventListeners() {
const useTikuCheckbox = document.getElementById('GPTJsSetting.useTiku');
if (useTikuCheckbox) {
useTikuCheckbox.checked = localStorage.getItem('GPTJsSetting.useTiku') === 'true';
useTikuCheckbox.addEventListener('change', (e) => {
const isChecked = e.target.checked;
localStorage.setItem('GPTJsSetting.useTiku', isChecked.toString());
localStorage.setItem('ZhsJsSetting.useTiku', isChecked.toString());
setting.useTiku = isChecked;
logger(`题库答题已${isChecked ? '开启' : '关闭'}`, isChecked ? 'green' : 'orange');
});
}
const useBackupTikuCheckbox = document.getElementById('GPTJsSetting.useBackupTiku');
if (useBackupTikuCheckbox) {
useBackupTikuCheckbox.addEventListener('change', (e) => {
logger('备用题库功能已删除，请使用主题库或AI答题', 'orange');
e.target.checked = false; // 强制关闭
});
}
const useAICheckbox = document.getElementById('GPTJsSetting.useAI');
if (useAICheckbox) {
useAICheckbox.checked = localStorage.getItem('GPTJsSetting.useAI') === 'true';
useAICheckbox.addEventListener('change', (e) => {
const isChecked = e.target.checked;
localStorage.setItem('GPTJsSetting.useAI', isChecked.toString());
localStorage.setItem('ZhsJsSetting.useAI', isChecked.toString());
setting.useAI = isChecked;
logger(`AI自动答题已${isChecked ? '开启' : '关闭'}`, isChecked ? 'green' : 'orange');
});
}
// 自动提交开关
const autoSubmitCheckbox = document.getElementById('GPTJsSetting.autoSubmit');
if (autoSubmitCheckbox) {
// 设置初始状态
autoSubmitCheckbox.checked = localStorage.getItem('GPTJsSetting.autoSubmit') === 'true';
autoSubmitCheckbox.addEventListener('change', (e) => {
const isChecked = e.target.checked;
localStorage.setItem('GPTJsSetting.autoSubmit', isChecked.toString());
localStorage.setItem('ZhsJsSetting.autoSubmit', isChecked.toString());
setting.autoSubmit = isChecked;
logger(`自动提交已${isChecked ? '开启' : '关闭'}`, isChecked ? 'green' : 'orange');
});
}
// 显示答案开关
const showAnswerCheckbox = document.getElementById('GPTJsSetting.showAnswer');
if (showAnswerCheckbox) {
// 设置初始状态
showAnswerCheckbox.checked = localStorage.getItem('GPTJsSetting.showAnswer') !== 'false';
showAnswerCheckbox.addEventListener('change', (e) => {
const isChecked = e.target.checked;
localStorage.setItem('GPTJsSetting.showAnswer', isChecked.toString());
localStorage.setItem('ZhsJsSetting.showAnswer', isChecked.toString());
setting.showAnswer = isChecked;
logger(`显示答案已${isChecked ? '开启' : '关闭'}`, isChecked ? 'green' : 'orange');
});
}
// AI模型选择
const modelSelect = document.getElementById('GPTJsSetting.model');
if (modelSelect) {
// 设置初始状态
const savedModel = localStorage.getItem('GPTJsSetting.model') || 'gpt-3.5-turbo-16k';
modelSelect.value = savedModel;
modelSelect.addEventListener('change', (e) => {
const selectedModel = e.target.value;
localStorage.setItem('GPTJsSetting.model', selectedModel);
localStorage.setItem('ZhsJsSetting.model', selectedModel);
setting.model = selectedModel;
logger(`AI模型已切换为: ${selectedModel}`, 'blue');
});
}
logger('更多设置区域事件监听器绑定完成', 'blue');
}
// 更新开关样式
function updateToggleStyle(toggle) {
const slider = toggle.nextElementSibling;
const knob = slider.querySelector('span');
if (toggle.checked) {
slider.style.backgroundColor = '#4CAF50';
knob.style.left = '29px';
} else {
slider.style.backgroundColor = '#ccc';
knob.style.left = '3px';
}
}
function makeZhihuishuPanelDraggable(panel) {
let isDragging = false;
let dragOffsetX, dragOffsetY;
function savePosition() {
if (panel) {
const rect = panel.getBoundingClientRect();
const position = {
left: rect.left,
top: rect.top
};
localStorage.setItem('zhs-panel-position', JSON.stringify(position));
}
}
function loadPosition() {
if (panel) {
try {
const savedPosition = localStorage.getItem('zhs-panel-position');
if (savedPosition) {
const position = JSON.parse(savedPosition);
panel.style.setProperty('left', position.left + 'px', 'important');
panel.style.setProperty('top', position.top + 'px', 'important');
panel.style.setProperty('right', 'auto', 'important');
}
} catch (err) {
console.error('无法恢复面板位置', err);
}
}
}
// 使用事件捕获阶段，确保先捕获事件 - 完全修复AI助手面板事件冲突问题
panel.addEventListener('mousedown', function (e) {
// 完全禁止在AI助手面板内拖拽
if (e.target.closest('#zhs-tab-ai')) {
e.stopPropagation();
return false;
}
// 完全禁止在标签内容区域拖拽
if (e.target.closest('.zhs-tab-content')) {
e.stopPropagation();
return false;
}
// 扩展交互元素检测 - 确保所有可交互元素都不触发拖动
const interactiveElements = ['BUTTON', 'INPUT', 'TEXTAREA', 'SELECT', 'OPTION', 'A', 'LABEL'];
// 检查元素标签
if (interactiveElements.includes(e.target.tagName)) {
e.stopPropagation();
return false;
}
// 检查是否点击了交互元素的子元素
for (const tag of interactiveElements) {
if (e.target.closest(tag.toLowerCase())) {
e.stopPropagation();
return false;
}
}
// 只有点击标题栏才允许拖动
const header = panel.querySelector('.gpt-box-header');
if (!header || (!header.contains(e.target) && !e.target.classList.contains('gpt-box-header'))) {
return false;
}
isDragging = true;
dragOffsetX = e.clientX - panel.getBoundingClientRect().left;
dragOffsetY = e.clientY - panel.getBoundingClientRect().top;
// 拖动时禁用过渡效果 - 关键优化点
panel.style.setProperty('transition', 'none', 'important');
// 确保拖动时面板在最顶层
panel.style.setProperty('z-index', '2147483647', 'important');
// 拖动时改变视觉效果
panel.style.setProperty('box-shadow', '0 12px 48px rgba(0, 0, 0, 0.4)', 'important');
panel.style.setProperty('opacity', '0.95', 'important');
// 防止选中文本 - 只在确实需要拖动时才阻止事件
e.preventDefault();
e.stopPropagation();
}, true);
// 使用顶层文档的mousemove事件
document.addEventListener('mousemove', function (e) {
if (isDragging) {
const newLeft = e.clientX - dragOffsetX;
const newTop = e.clientY - dragOffsetY;
// 确保不超出屏幕边界
const maxX = window.innerWidth - panel.offsetWidth;
const maxY = window.innerHeight - panel.offsetHeight;
// 使用!important确保样式不被覆盖 - 关键优化点
panel.style.setProperty('left', Math.max(0, Math.min(newLeft, maxX)) + 'px', 'important');
panel.style.setProperty('top', Math.max(0, Math.min(newTop, maxY)) + 'px', 'important');
panel.style.setProperty('right', 'auto', 'important');
panel.style.setProperty('bottom', 'auto', 'important');
// 防止事件传播
e.preventDefault();
}
}, true);
document.addEventListener('mouseup', function (e) {
if (isDragging) {
isDragging = false;
// 恢复过渡效果和视觉样式 - 关键优化点
panel.style.setProperty('transition', 'all 0.3s ease', 'important');
panel.style.setProperty('box-shadow', '0 4px 12px rgba(0, 0, 0, 0.15)', 'important');
panel.style.setProperty('opacity', '1', 'important');
// 防止事件传播
e.stopPropagation();
// 保存位置到localStorage
savePosition();
}
}, true);
// 页面加载时恢复位置
setTimeout(loadPosition, 1000);
}
// 使智慧树日志窗口可拖拽 - 优化性能，修复卡顿问题
function makeZhihuishuLogWindowDraggable(logWindow) {
let isDragging = false;
let currentX = 0;
let currentY = 0;
let initialX = 0;
let initialY = 0;
let xOffset = 0;
let yOffset = 0;
let animationId = null;
const header = logWindow.querySelector('div:first-child');
header.style.cursor = 'move';
header.style.userSelect = 'none'; // 防止文本选择
// 优化事件监听器
header.addEventListener('mousedown', dragStart, { passive: false });
function dragStart(e) {
// 排除按钮和其他交互元素
if (e.target.tagName === 'BUTTON' || e.target.closest('button')) {
return;
}
e.preventDefault();
e.stopPropagation();
initialX = e.clientX - xOffset;
initialY = e.clientY - yOffset;
isDragging = true;
// 添加全局事件监听器
document.addEventListener('mousemove', dragMove, { passive: false });
document.addEventListener('mouseup', dragEnd, { passive: false });
// 添加视觉反馈
logWindow.style.opacity = '0.8';
logWindow.style.zIndex = '2147483647';
}
function dragMove(e) {
if (!isDragging) return;
e.preventDefault();
// 使用requestAnimationFrame优化性能
if (animationId) {
cancelAnimationFrame(animationId);
}
animationId = requestAnimationFrame(() => {
currentX = e.clientX - initialX;
currentY = e.clientY - initialY;
xOffset = currentX;
yOffset = currentY;
// 使用transform3d启用硬件加速
logWindow.style.transform = `translate3d(${currentX}px, ${currentY}px, 0)`;
});
}
function dragEnd() {
if (!isDragging) return;
isDragging = false;
// 移除全局事件监听器
document.removeEventListener('mousemove', dragMove);
document.removeEventListener('mouseup', dragEnd);
// 恢复视觉状态
logWindow.style.opacity = '1';
logWindow.style.zIndex = '2147483645';
// 清理动画帧
if (animationId) {
cancelAnimationFrame(animationId);
animationId = null;
}
}
}
// 添加智慧树键盘快捷键
function addZhihuishuKeyboardShortcuts() {
document.addEventListener('keydown', (e) => {
// F9 显示/隐藏控制面板
if (e.key === 'F9' || e.keyCode === 120) {
e.preventDefault();
const panel = document.getElementById('zhs-control-panel');
if (panel) {
panel.style.display = panel.style.display === 'none' ? 'block' : 'none';
logger(`控制面板已${panel.style.display === 'none' ? '隐藏' : '显示'}`, 'blue');
}
}
// F10 显示/隐藏日志窗口
if (e.key === 'F10' || e.keyCode === 121) {
e.preventDefault();
const logWindow = document.getElementById('zhs-log-window');
if (logWindow) {
logWindow.style.display = logWindow.style.display === 'none' ? 'block' : 'none';
logger(`日志窗口已${logWindow.style.display === 'none' ? '隐藏' : '显示'}`, 'blue');
}
}
// Ctrl+Shift+S 开始答题
if (e.ctrlKey && e.shiftKey && e.key === 'S') {
e.preventDefault();
logger('快捷键启动答题', 'green');
initZhihuishuExam();
}
});
}
// 智慧树原始答题系统初始化
function initZhihuishuOriginalAnswering() {
logger('初始化智慧树原始答题系统', 'blue');
// 初始化队列和变量
setting.queue = setting.queue || [];
setting.curs = setting.curs || [];
setting.type = {
单选题: 1,
多选题: 2,
填空题: 3,
问答题: 4,
'分析题/解答题/计算题/证明题': 5,
'阅读理解（选择）/完型填空': 9,
判断题: 14
};
setting.lose = setting.num = setting.small = 0;
// 设置正确的XMLHttpRequest钩子（用于考试页面和练习页面）
_self.XMLHttpRequest = function () {
var ajax = new XMLHttpRequest();
ajax.onload = function (e) {
// 处理考试数据
if (this.status == 200 && this.responseURL.match(/doHomework|doExam/)) {
try {
var obj = JSON.parse(this.responseText);
if (obj.rt && obj.rt.examBase) {
logger('获取到考试数据，开始处理题目', 'green');
zhsCollectData(obj.rt.examBase);
}
} catch (e) {
logger('解析考试数据失败: ' + e, 'red');
}
}
// 处理智慧树练习页面的题目数据
if (this.status == 200 && this.responseURL.match('getDoQuestSingle')) {
try {
var obj = JSON.parse(this.responseText).rt;
logger('拦截到智慧树题目API响应', 'green');
logger(`题目ID: ${obj.questionId}`, 'blue');
logger(`题目类型: ${obj.questionName} (ID: ${obj.questionTypeId})`, 'blue');
// 处理题目内容
if (obj.content) {
var questionText = obj.content.replace(/<[^>]*>/g, '').trim();
logger(`题目内容: ${questionText.substring(0, 100)}...`, 'blue');
// 调用题库API获取答案
zhsGetAnswerFromAPI(questionText, obj.questionTypeId, obj.questionOptionList);
}
} catch (e) {
logger('处理智慧树API响应时出错: ' + e.message, 'red');
}
}
};
return ajax;
};
// 启动答题队列处理
setInterval(function () {
if (setting.queue.length > 0) {
const element = setting.queue.shift();
if (element && element.parentElement) {
element.parentElement.click();
logger('点击队列中的选项', 'blue');
}
}
}, 1000);
// 启动答题循环
setting.loop = setInterval(zhsFindAnswer, setting.time, true);
logger('智慧树答题系统初始化完成', 'green');
}
// 智慧树收集考试数据
function zhsCollectData(examBase) {
logger('开始收集智慧树考试数据', 'blue');
// 存储考试基础信息
setting.examBase = examBase;
setting.curs = [];
// 获取课程信息
$('.infoList span').each(function () {
setting.curs.push($(this).text().trim());
});
logger(`收集到课程信息: ${setting.curs.length} 项`, 'blue');
logger('考试数据收集完成，开始答题流程', 'green');
}
// 检查是否为智慧树答题页面 - 修复视频页面误识别问题
function checkZhsAnswerPage() {
// 首先排除视频页面
const url = window.location.href;
const isVideoPage = url.includes('hike.zhihuishu.com') ||
url.includes('sourceLearning') ||
url.includes('videoList');
if (isVideoPage) {
logger('检测到视频页面，不启动答题功能', 'blue');
return false;
}
// 检查URL特征 - 只检查明确的答题页面
const isZhsExamUrl = url.includes('zhihuishu.com') &&
(url.includes('hiexam') || url.includes('homework') || url.includes('test') || url.includes('exam'));
// 检查页面元素特征 - 智慧树答题页面的特有元素
const hasZhsElements = $('.answerCard').length > 0 || // 答题卡
$('.optionUl').length > 0 || // 选项列表
$('.subject_stem').length > 0 || // 题目主体
$('.examPaper_subject').length > 0 || // 考试题目
$('.TiMu').length > 0 || // 题目容器
$('[class*="option"]').length > 0 || // 选项元素
$('[class*="question"]').length > 0; // 题目元素
// 检查页面标题 - 更精确的标题检测
const hasZhsTitle = (document.title.includes('智慧树') &&
(document.title.includes('考试') || document.title.includes('作业'))) ||
document.title.includes('答题');
const isAnswerPage = isZhsExamUrl || (hasZhsElements && hasZhsTitle);
if (isAnswerPage) {
logger('检测到智慧树答题页面，页面验证通过', 'green');
} else {
logger('页面检测结果：URL=' + isZhsExamUrl + ', 元素=' + hasZhsElements + ', 标题=' + hasZhsTitle, 'blue');
}
return isAnswerPage;
}
// 全局停止所有自动化操作函数
function zhsStopAllAutoActions() {
// 停止自动答题
setting.work = 0;
localStorage.setItem('GPTJsSetting.work', 'false');
logger('🛑 停止自动答题', 'red');
// 清除所有答题相关的定时器
if (setting.loop) {
clearInterval(setting.loop);
setting.loop = null;
logger('🛑 已清除答题定时器', 'blue');
}
// 清空答题队列
setting.queue = [];
logger('🛑 已清空答题队列', 'blue');
// 清除可能存在的其他定时器
if (window.zhsNavigationTimer) {
clearTimeout(window.zhsNavigationTimer);
window.zhsNavigationTimer = null;
logger('🛑 已清除导航定时器', 'blue');
}
// 停止所有自动导航行为
logger('🛑 已停止所有自动导航行为', 'blue');
// 提示用户
logger('✅ 所有自动化操作已停止，可手动操作', 'green');
}
function zhsProcessQuestions() {
logger('🚀 启动智慧树专用题目处理逻辑', 'green');
logger('自动答题功能已启用，开始处理题目', 'green');
let questionElements = [];
const optionContainers = $('.optionUl');
if (optionContainers.length > 0) {
const questionContainer = optionContainers.first().closest('div, section, article').first();
if (questionContainer.length > 0) {
questionElements = [questionContainer];
logger(`找到 ${questionElements.length} 个智慧树题目容器（基于optionUl）`, 'green');
}
}
else if ($('.TiMu').length > 0) {
questionElements = $('.TiMu');
logger(`找到 ${questionElements.length} 个.TiMu题目元素`, 'green');
}
else if ($('.examPaper_subject').length > 0) {
questionElements = $('.examPaper_subject');
logger(`找到 ${questionElements.length} 个.examPaper_subject题目元素`, 'green');
}
else if ($('[class*="question"]').length > 0) {
questionElements = $('[class*="question"]');
logger(`找到 ${questionElements.length} 个question相关题目元素`, 'green');
}
else {
logger('❌ 未找到任何题目元素，页面可能还在加载中', 'red');
setTimeout(() => zhsProcessQuestions(), 3000);
return;
}
if (questionElements.length > 0) {
logger(`✅ 开始处理 ${questionElements.length} 道题目`, 'green');
zhsProcessSingleQuestion(0, questionElements);
}
}
function zhsProcessSingleQuestion(index, questionElements) {
if (localStorage.getItem('GPTJsSetting.work') === 'false') {
logger('用户手动停止答题，跳过当前题目', 'red');
return;
}
const currentOptionContainer = $('.optionUl').first();
const currentQuestionContainer = currentOptionContainer.length > 0 ?
currentOptionContainer.closest('div, section, article').first() : $();
if (currentQuestionContainer.length === 0) {
logger('❌ 未找到当前题目容器，可能已完成所有题目', 'red');
return;
}
logger(`📝 开始处理当前题目`, 'blue');
// 提取题目信息
const questionData = zhsExtractQuestionData(currentQuestionContainer);
if (!questionData.question || questionData.question.length < 10) {
logger(`❌ 题目数据提取失败或内容过短，尝试重新提取`, 'red');
// 尝试使用更简单的方法重新提取题目内容
const fallbackQuestionText = getQuestionText(currentQuestionContainer);
if (fallbackQuestionText && fallbackQuestionText.length > 10) {
questionData.question = fallbackQuestionText;
logger(`✅ 使用备用方法成功提取题目: ${fallbackQuestionText.substring(0, 50)}...`, 'green');
} else {
logger(`❌ 备用方法也无法提取题目，跳过`, 'red');
// 尝试导航到下一题
setTimeout(() => {
if (zhsNavigateToNext()) {
setTimeout(() => zhsProcessSingleQuestion(0, []), 3000);
}
}, 2000);
return;
}
}
// 移除已作答检查 - 根据用户要求，总是重新答题
// 用户要求：不判断已作答的，就算作答了，要会重新答题，根据获取的答案进行填充选项
// const radioGroupCheck = currentQuestionContainer.find('[role="radiogroup"]');
// const checkedRadio = radioGroupCheck.find('[role="radio"][aria-checked="true"]');
// if (checkedRadio.length > 0) {
// logger(`✅ 当前题目已作答，导航到下一题`, 'green');
// setTimeout(() => {
// if (zhsNavigateToNext()) {
// setTimeout(() => zhsProcessSingleQuestion(0, []), 3000);
// }
// }, 1000);
// return;
// }
logger(`📝 开始重新处理题目（忽略已作答状态）`, 'blue');
// 使用四级优先级获取答案
zhsGetAnswerWithPriority(questionData).then(answer => {
// 检查是否手动停止答题
if (localStorage.getItem('GPTJsSetting.work') === 'false') {
logger('用户手动停止答题，跳过答案处理', 'red');
return;
}
if (answer) {
logger(`✅ 获取到答案: ${answer}`, 'green');
// 选择答案
const success = zhsSelectAnswer(currentQuestionContainer, answer);
if (success) {
logger(`✅ 题目处理成功，准备自动下一题`, 'green');
// 等待一段时间让选择生效，然后自动导航到下一题
setTimeout(() => {
if (localStorage.getItem('GPTJsSetting.work') === 'true') {
const navigated = zhsNavigateToNext();
if (navigated) {
logger(`🔄 已自动跳转到下一题`, 'blue');
// 等待页面加载后继续处理下一题
setTimeout(() => {
if (localStorage.getItem('GPTJsSetting.work') === 'true') {
zhsProcessSingleQuestion(0, []);
}
}, 3000);
} else {
logger(`✅ 已完成所有题目或到达最后一题，停止自动答题`, 'green');
// 停止自动答题，避免无限循环
localStorage.setItem('GPTJsSetting.work', 'false');
}
}
}, 1500);
} else {
logger(`⚠️ 答案选择失败，自动跳转到下一题`, 'orange');
// 即使答案选择失败，也自动跳转到下一题
setTimeout(() => {
if (localStorage.getItem('GPTJsSetting.work') === 'true') {
const navigated = zhsNavigateToNext();
if (navigated) {
logger(`🔄 已自动跳转到下一题`, 'blue');
// 等待页面加载后继续处理下一题
setTimeout(() => {
if (localStorage.getItem('GPTJsSetting.work') === 'true') {
zhsProcessSingleQuestion(0, []);
}
}, 3000);
} else {
logger(`✅ 已完成所有题目或到达最后一题，停止自动答题`, 'green');
localStorage.setItem('GPTJsSetting.work', 'false');
}
}
}, 1500);
}
} else {
logger(`⚠️ 未获取到答案，自动跳转到下一题`, 'orange');
// 即使未获取到答案，也自动跳转到下一题
setTimeout(() => {
if (localStorage.getItem('GPTJsSetting.work') === 'true') {
const navigated = zhsNavigateToNext();
if (navigated) {
logger(`🔄 已自动跳转到下一题`, 'blue');
// 等待页面加载后继续处理下一题
setTimeout(() => {
if (localStorage.getItem('GPTJsSetting.work') === 'true') {
zhsProcessSingleQuestion(0, []);
}
}, 3000);
} else {
logger(`✅ 已完成所有题目或到达最后一题，停止自动答题`, 'green');
localStorage.setItem('GPTJsSetting.work', 'false');
}
}
}, 1500);
}
}).catch(error => {
logger(`❌ 题目处理出错: ${error}`, 'red');
// 尝试导航到下一题
setTimeout(() => {
const navigated = zhsNavigateToNext();
if (navigated) {
setTimeout(() => zhsProcessSingleQuestion(0, []), 3000);
} else {
logger(`❌ 导航失败，停止自动答题避免无限循环`, 'red');
localStorage.setItem('GPTJsSetting.work', 'false');
}
}, 2000);
});
}
function cleanTextContent(textString) {
if (!textString) return null;
let cleaned = textString.replace(/<(?!img).*?>/g, "");
cleaned = cleaned
.replace(/\s+/g, ' ')
.replace(/^\s+/, '')
.replace(/\s+$/, '');
return cleaned;
}
function formatQuestionText(questionText) {
if (!questionText) return null;
// 先进行基础清理
let formatted = cleanTextContent(questionText);
// 额外处理针对问题特有的格式
formatted = formatted
.replace(/^\d+[\.、]/, '') // 移除题号
.replace(/^\s*[\(（【\[]?\s*(单选题|多选题|判断题|填空题|简答题|论述题|分析题)[\s\.\:：,，]*[\d\.]*分?[\)）\]\】]?\s*/i, '') // 移除题目类型信息
.replace(/\(\s*\d+\.\d+\s*分\s*\)/g, '') // 移除分数信息
.replace(/（\s*\d+\.\d+\s*分\s*）/g, '') // 移除分数信息
.trim();
return formatted;
}
// 重新设计的题目数据提取函数 - 基于实际DOM结构
function zhsExtractQuestionData(questionElement) {
const questionData = {
question: '',
type: '',
options: [],
element: questionElement
};
try {
// 调试：输出题目容器的基本信息
// logger(`🔍 调试：题目容器HTML: ${questionElement.html().substring(0, 200)}...`, 'blue');
// 1. 提取题目类型 - 使用role属性和文本匹配
const allElements = questionElement.find('*');
let questionType = '';
// logger(`🔍 调试：找到 ${allElements.length} 个子元素`, 'blue');
allElements.each(function (index) {
const text = $(this).text().trim();
// 查找 "1.【单选题】 (0.5分)" 格式
const typeMatch = text.match(/\d+\.\s*【(.+?)】.*?\(\d+\.?\d*分\)/);
if (typeMatch) {
questionType = typeMatch[1];
// logger(`🔍 调试：找到题目类型: "${questionType}" 在元素: ${$(this).prop('tagName')}`, 'green');
return false; // 跳出each循环
}
});
questionData.type = questionType;
// 2. 提取纯净的题目内容 - 修复题目内容获取错误
// 优先从class="questionContent"下的p标签里的span内容获取
let questionText = '';
// 方法1：查找class="questionContent"下的p标签里的span内容（用户要求的正确方式）
const questionContentDiv = questionElement.find('.questionContent');
if (questionContentDiv.length > 0) {
const spans = questionContentDiv.find('p span');
if (spans.length > 0) {
// 提取所有span的文本内容并合并，避免重复
let spanTexts = [];
let seenTexts = new Set(); // 用于去重
spans.each(function () {
const spanText = $(this).text().trim();
if (spanText && !spanText.match(/^[A-D]\./) && spanText.length > 0) {
// 避免重复添加相同的文本
if (!seenTexts.has(spanText)) {
spanTexts.push(spanText);
seenTexts.add(spanText);
}
}
});
questionText = spanTexts.join('').trim();
logger(`🔍 从.questionContent p span获取题目内容: ${questionText.substring(0, 50)}...`, 'green');
}
}
// 方法2：如果没找到，尝试查找p标签，但排除选项区域内的p标签
if (!questionText) {
const paragraphs = questionElement.find('p').not('.optionUl p, .el-radio p');
paragraphs.each(function () {
const text = $(this).text().trim();
// 跳过题目类型行和短文本，选择最可能的题目内容
if (!text.match(/^[一二三四五六七八九十]、.*?题/) &&
!text.match(/^[A-D]\./) &&
text.length > 10) {
questionText = text;
return false; // 找到题目内容后跳出
}
});
}
// 方法3：如果还没找到，尝试查找其他可能的题目容器
if (!questionText) {
const questionSelectors = [
'.questionTit', // 添加对questionTit的支持（作为备选）
'.question-text',
'.subject_stem',
'.question-content',
'.stem',
'.title'
];
for (const selector of questionSelectors) {
const element = questionElement.find(selector).first();
if (element.length > 0) {
questionText = element.text().trim();
break;
}
}
}
// 方法4：如果仍然没找到，尝试从所有文本中提取题目
if (!questionText || questionText.length < 10) {
const allText = questionElement.text();
// 查找题目编号后的内容，如"1.【单选题】 (1分) 题目内容"
const questionMatch = allText.match(/\d+\.\s*【.+?】\s*\(.+?\)\s*(.+?)(?=\s*[A-D]\.|$)/);
if (questionMatch && questionMatch[1]) {
questionText = questionMatch[1].trim();
logger(`🔍 从完整文本中提取题目: ${questionText.substring(0, 50)}...`, 'green');
}
}
questionText = questionText
.replace(/\s+/g, ' ') // 合并多个空格
.trim();
questionData.question = questionText;
const optionContainer = questionElement.find('.optionUl');
if (optionContainer.length > 0) {
const radioGroup = optionContainer.find('[role="radiogroup"]');
// logger(`🔍 调试：找到 ${radioGroup.length} 个role="radiogroup"`, 'blue');
if (radioGroup.length > 0) {
const radioElements = radioGroup.find('[role="radio"]');
// logger(`🔍 调试：找到 ${radioElements.length} 个role="radio"元素`, 'blue');
radioElements.each(function (index) {
// 查找.optionContent元素，这是智慧树选项内容的实际容器
const optionContent = $(this).find('.optionContent');
let optionText = '';
if (optionContent.length > 0) {
optionText = optionContent.text().trim();
// logger(`🔍 调试：radio[${index}] optionContent: "${optionText}"`, 'blue');
} else {
// 备用方案：从el-radio__label中提取文本
const radioLabel = $(this).find('.el-radio__label');
if (radioLabel.length > 0) {
optionText = radioLabel.text().trim();
// 移除选项字母前缀（如"A. "）
optionText = optionText.replace(/^[A-Z]\.\s*/, '').trim();
// logger(`🔍 调试：radio[${index}] radioLabel: "${optionText}"`, 'blue');
}
}
if (optionText && optionText.length > 0) {
questionData.options.push(optionText);
// logger(`🔍 调试：添加选项: "${optionText}"`, 'green');
}
});
}
}
if (questionData.type === '判断题' && questionData.options.length === 0) {
questionData.options = ['正确', '错误'];
}
// 5. 记录提取结果（简化日志输出）
logger(`📋 题目内容: ${questionData.question}`, 'blue');
logger(`🏷️ 题目类型: ${questionData.type}`, 'blue');
logger(`📝 选项数量: ${questionData.options.length}`, 'blue');
if (questionData.options.length > 0) {
logger(`📋 选项内容: ${questionData.options.join(' | ')}`, 'blue');
}
} catch (error) {
logger(`❌ 题目数据提取失败: ${error.message}`, 'red');
}
return questionData;
}
// 四级优先级答题机制 - 根据用户设置决定使用哪些方式
function zhsGetAnswerWithPriority(questionData) {
return new Promise((resolve, reject) => {
// 检查是否手动停止答题
if (localStorage.getItem('GPTJsSetting.work') === 'false') {
reject('用户手动停止答题');
return;
}
// 获取用户设置
const useTiku = localStorage.getItem('GPTJsSetting.useTiku') === 'true';
const useBackupTiku = localStorage.getItem('GPTJsSetting.useBackupTiku') === 'true';
const useAI = localStorage.getItem('GPTJsSetting.useAI') === 'true';
// 随机答题功能已删除 - 根据用户要求完全删除随机选择功能
// 获取用户配置的 key
let userKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || '';
// 第一优先级：主题库API
if (useTiku && userKey) {
// 为题库API提供纯净的题目内容
const tikuQuestionData = {
question: questionData.question,
type: questionData.type,
options: questionData.options
};
getZhihuishuAnswer(tikuQuestionData).then(answer => {
// 检查是否手动停止答题
if (localStorage.getItem('GPTJsSetting.work') === 'false') {
reject('用户手动停止答题');
return;
}
if (answer && answer !== '暂无答案') {
logger(`📚 题库API成功返回答案: ${answer}`, 'green');
logger(`📚 答案来源: 主题库API (tk.mixuelo.cc)`, 'blue');
resolve(answer);
return;
}
logger(`📚 主题库API未返回有效答案，尝试备用题库...`, 'orange');
// 主题库失败，尝试下一优先级
tryBackupTiku();
}).catch((error) => {
logger(`📚 主题库API调用失败: ${error}`, 'red');
tryBackupTiku();
});
} else {
tryBackupTiku();
}
// 第二优先级：备用题库API
function tryBackupTiku() {
// 移除答题停止检查 - 默认总是答题
// if (localStorage.getItem('GPTJsSetting.work') !== 'true') {
// reject('答题已停止');
// return;
// }
if (useBackupTiku && userKey) {
// 备用题库使用与主题库相同的数据格式
const backupQuestionData = {
question: questionData.question,
type: questionData.type,
options: questionData.options
};
// 这里可以调用备用题库API
// 暂时跳过，直接尝试AI
tryAI();
} else {
tryAI();
}
}
// 第三优先级：AI答题
function tryAI() {
// 移除答题停止检查 - 默认总是答题
// if (localStorage.getItem('GPTJsSetting.work') !== 'true') {
// reject('答题已停止');
// return;
// }
if (useAI && userKey) {
// 为AI构建完整的题目信息（题型+题目+选项）- 修复AI没有收到选项信息的问题
let aiQuestionText = '';
if (questionData.type) {
aiQuestionText += questionData.type + ': ';
}
aiQuestionText += questionData.question;
// 添加选项信息
if (questionData.options && questionData.options.length > 0) {
aiQuestionText += '\n选项：\n';
questionData.options.forEach((option, index) => {
const optionLabel = String.fromCharCode(65 + index); // A, B, C, D
// 修复选项信息传递问题 - 确保提取实际的选项文本
const optionText = option.content ? option.content.replace(/<[^>]*>/g, '').trim() :
option.text ? option.text.trim() :
(typeof option === 'string' ? option : String(option));
aiQuestionText += `${optionLabel}. ${optionText}\n`;
});
}
logger(`🤖 发送给AI的完整题目信息: ${aiQuestionText.substring(0, 200)}...`, 'blue');
zhsGetAIAnswer(aiQuestionText, questionData.type)
.then(answer => {
// 移除答题停止检查 - 默认总是答题
// if (localStorage.getItem('GPTJsSetting.work') !== 'true') {
// reject('答题已停止');
// return;
// }
if (answer && answer !== '暂无答案' && answer.trim() !== '') {
logger(`🤖 AI成功返回答案: ${answer}`, 'green');
logger(`🤖 答案来源: AI答题系统`, 'blue');
resolve(answer);
return;
}
logger(`🤖 AI未返回有效答案，跳过当前题目`, 'orange');
// AI失败，不再使用随机答题，直接跳过
reject('AI答题失败，无法获取答案');
})
.catch((error) => {
logger(`🤖 AI答题调用失败: ${error}`, 'red');
reject('AI答题失败: ' + error);
});
} else {
reject('AI答题功能未开启');
}
}
// 随机答题功能已删除 - 根据用户要求完全删除随机选择功能
});
}
function zhsSelectAnswer(questionElement, answer) {
try {
logger(`🎯 开始选择答案: ${answer}`, 'green');
// 查找radiogroup中的radio元素 - 使用role属性
const radioGroup = questionElement.find('[role="radiogroup"]');
if (radioGroup.length === 0) {
logger(`❌ 未找到role="radiogroup"元素`, 'red');
return false;
}
const radioElements = radioGroup.find('[role="radio"]');
let bestMatch = { element: null, score: 0, reason: '' };
radioElements.each(function () {
const $radio = $(this);
const optionText = $radio.attr('aria-label') || $radio.text().trim();
if (!optionText) return;
// 清理选项文本
const cleanOption = optionText.replace(/^[A-Z]\.\s*/, '').trim();
let matchScore = 0;
let matchReason = '';
// 1. 精确匹配
if (cleanOption === answer) {
matchScore = 100;
matchReason = '精确匹配';
}
// 2. 包含匹配
else if (cleanOption.includes(answer) || answer.includes(cleanOption)) {
matchScore = 80;
matchReason = '包含匹配';
}
// 3. 关键词匹配
else {
const answerWords = answer.split(/\s+/);
const optionWords = cleanOption.split(/\s+/);
let commonWords = 0;
answerWords.forEach(word => {
if (word.length > 1 && optionWords.some(optWord => optWord.includes(word) || word.includes(optWord))) {
commonWords++;
}
});
if (commonWords > 0) {
matchScore = (commonWords / Math.max(answerWords.length, optionWords.length)) * 60;
matchReason = `关键词匹配(${commonWords}个)`;
}
}
if (matchScore > bestMatch.score) {
bestMatch = { element: $radio, score: matchScore, reason: matchReason };
}
logger(`选项匹配: "${cleanOption}" -> 得分: ${matchScore.toFixed(1)}, 原因: ${matchReason}`, 'blue');
});
// 选择最佳匹配的选项
if (bestMatch.element && bestMatch.score > 30) {
logger(`✅ 选择最佳匹配选项，得分: ${bestMatch.score.toFixed(1)}, 原因: ${bestMatch.reason}`, 'green');
bestMatch.element.click();
// 额外尝试点击内部的radio元素
setTimeout(() => {
const innerRadio = bestMatch.element.find('radio').first();
if (innerRadio.length > 0) {
innerRadio.click();
}
}, 100);
// 添加成功状态指示器 - 修复questionData未定义错误
const questionNumber = getCurrentQuestionNumber();
const actualQuestionText = getQuestionText(questionElement) || '题目内容获取失败';
addQuestionStatusIndicator(questionNumber, 'success', {
question: actualQuestionText,
answer: answer,
selected: bestMatch.optionText || '已选择',
type: '单选题'
});
return true;
} else {
logger(`❌ 未找到匹配的选项，最高得分: ${bestMatch.score.toFixed(1)}`, 'red');
// 添加失败状态指示器 - 修复questionData未定义错误
const questionNumber = getCurrentQuestionNumber();
const actualQuestionText = getQuestionText(questionElement) || '题目内容获取失败';
addQuestionStatusIndicator(questionNumber, 'failed', {
question: actualQuestionText,
answer: answer,
error: '未找到选项或，已经答题',
type: '单选题'
});
return false;
}
} catch (error) {
logger(`❌ 选择答案失败: ${error.message}`, 'red');
return false;
}
}
function zhsNavigateToNext() {
try {
// 首先检查答题状态 - 只有在答题开启时才自动导航
const isAutoAnswerEnabled = localStorage.getItem('GPTJsSetting.work') === 'true';
if (!isAutoAnswerEnabled) {
logger(`🛑 自动答题已关闭，停止自动导航`, 'orange');
return false;
}
// 查找"下一题"按钮 - 使用文本匹配和实际HTML元素
let nextButton = $('*:contains("下一题")').filter(function () {
return $(this).text().trim() === '下一题';
});
// 如果没找到，尝试其他选择器
if (nextButton.length === 0) {
nextButton = $('button:contains("下一题"), div:contains("下一题"), span:contains("下一题")').filter(function () {
return $(this).text().trim() === '下一题';
});
}
if (nextButton.length > 0 && nextButton.is(':visible')) {
logger(`🔄 自动导航到下一题`, 'blue');
nextButton.click();
return true;
} else {
logger(`⚠️ 未找到"下一题"按钮或按钮不可见`, 'orange');
return false;
}
} catch (error) {
logger(`❌ 导航到下一题失败: ${error.message}`, 'red');
return false;
}
}
function zhsFindAnswer(tip) {
if (setting.queue.length) {
return;
}
// 移除自动答题功能检查 - 默认总是答题
// if (!setting.work) {
// // 静默返回，不输出日志避免干扰
// return;
// }
// 智慧树使用API拦截方式，不需要DOM检测
// 这个函数主要用于处理队列中的点击操作和状态检查
// 检查是否在智慧树答题页面
if (tip && !location.href.includes('zhihuishu.com')) {
return;
}
// 智慧树的题目通过API拦截处理，这里只处理基本状态
// 不再输出"答题已完成"，避免误导用户
// 如果有待处理的点击队列，优先处理
if (setting.queue.length > 0) {
return;
}
// 检查是否有下一题按钮需要点击
const nextBtn = document.querySelector('.Topicswitchingbtn');
if (nextBtn && nextBtn.textContent.includes('下一题') && setting.queue.length === 0) {
// 让自动跳转逻辑处理，这里不重复处理
return;
}
}
// 智慧树填充答案函数
function zhsFillAnswer($TiMu, obj, type) {
const $div = $TiMu.find('.nodeLab');
const str = String(obj.answer).toCDB() || new Date().toString();
const answer = str.split(/#|\x01|\|/);
const state = setting.lose;
logger(`开始填充答案，题目类型: ${type}，答案: ${obj.answer}`, 'blue');
obj.code > 0 && $div.each(function () {
const $input = $('input', this)[0];
if (!$input) return;
const tip = filterStyle('.node_detail', this).toCDB() || new Date().toString();
if (tip.match(/^(正确|是|对|√|T|ri)$/)) {
answer.join().match(/(^|,)(正确|是|对|√|T|ri)(,|$)/) && setting.queue.push($input);
} else if (tip.match(/^(错误|否|错|×|F|wr)$/)) {
answer.join().match(/(^|,)(错误|否|错|×|F|wr)(,|$)/) && setting.queue.push($input);
} else if (type == 2) { // 多选题
Boolean($.inArray(tip, answer) + 1 || str.indexOf(tip) + 1) == $input.checked || setting.queue.push($input);
} else { // 单选题
$.inArray(tip, answer) + 1 && setting.queue.push($input);
}
});
if (setting.queue.length) {
logger(`已添加 ${setting.queue.length} 个选项到点击队列`, 'green');
return true;
} else if (/^(1|2|14)$/.test(type)) {
const $input = $div.find('input');
if (!$input.is(':checked')) {
setting.lose++;
logger('❌ 未找到匹配的选项', 'red');
return false;
}
} else if (/^[3-5]$/.test(type)) { // 填空题/简答题
const answers = String(obj.answer).split(/#|\x01|\|/);
let filled = 0;
$TiMu.find('textarea').each(function (index) {
const answerText = (obj.code > 0 && answers[index]) || '';
if (answerText) {
this.value = answerText.trim();
this.dispatchEvent(new Event('input'));
this.dispatchEvent(new Event('blur'));
filled++;
}
});
if (obj.code > 0 && filled > 0) {
logger(`已填充 ${filled} 个文本框`, 'green');
return true;
} else if (!setting.none) {
setting.lose++;
logger('填空题答案填充失败', 'red');
return false;
}
} else {
if (!setting.none) {
setting.lose++;
logger('未知题型，无法处理', 'red');
return false;
}
}
return true;
}
// 智慧树考试页面初始化（备用）- 已禁用，使用新的zhsProcessQuestions系统
function initZhihuishuExam() {
logger('备用初始化系统已禁用，使用主要的zhsProcessQuestions系统', 'blue');
// 直接调用主要的处理系统，避免冲突
zhsProcessQuestions();
}
// 开始智慧树自动答题 - 已禁用，使用新的zhsProcessQuestions系统
function startZhihuishuAutoAnswer() {
logger('旧的自动答题系统已禁用，使用主要的zhsProcessQuestions系统', 'blue');
// 直接调用主要的处理系统，避免冲突
zhsProcessQuestions();
}
// 查找智慧树题目
function findZhihuishuQuestions() {
// 智慧树考试页面的题目通常在特定的容器中
const questionContainers = [];
// 方法1：查找包含题目和选项的完整容器
const questionBlocks = document.querySelectorAll('.question-block, .exam-question, [class*="question-container"]');
if (questionBlocks.length > 0) {
logger(`找到 ${questionBlocks.length} 个题目块容器`, 'blue');
return Array.from(questionBlocks);
}
// 方法2：通过选项列表反推题目容器
const optionLists = document.querySelectorAll('.optionUl');
if (optionLists.length > 0) {
logger(`通过选项列表找到 ${optionLists.length} 道题目`, 'blue');
optionLists.forEach((optionList) => {
// 查找包含题目和选项的父容器
let container = optionList.parentElement;
// 向上查找，直到找到包含题目文本的容器
while (container && container !== document.body) {
const questionText = container.querySelector('p, .question-text, .stem');
if (questionText && questionText.textContent.trim().length > 10) {
questionContainers.push(container);
break;
}
container = container.parentElement;
}
// 如果没找到合适的容器，使用选项列表的父元素
if (!questionContainers.includes(container) && optionList.parentElement) {
questionContainers.push(optionList.parentElement);
}
});
return questionContainers;
}
// 方法3：查找所有可能的题目容器
const selectors = [
'.subject_stem', // 题目主体
'.question-item', // 题目项
'[class*="question"]', // 包含question的类名
'.exam-item', // 考试项目
'.test-item' // 测试项目
];
for (const selector of selectors) {
const elements = document.querySelectorAll(selector);
if (elements.length > 0 && elements.length < 50) { // 合理的题目数量
logger(`使用选择器 "${selector}" 找到 ${elements.length} 个题目`, 'blue');
return Array.from(elements).filter(el => el.textContent.trim().length > 5);
}
}
// 方法4：如果都没找到，尝试分析页面结构
logger('尝试分析页面结构查找题目', 'orange');
const allElements = document.querySelectorAll('div, section, article');
const potentialQuestions = [];
allElements.forEach(el => {
// 查找包含选项列表的元素
const hasOptions = el.querySelector('.optionUl, .el-radio-group, input[type="radio"]');
// 查找包含题目文本的元素
const hasQuestionText = el.querySelector('p') && el.textContent.trim().length > 20;
if (hasOptions && hasQuestionText && !potentialQuestions.includes(el)) {
potentialQuestions.push(el);
}
});
if (potentialQuestions.length > 0) {
logger(`通过页面结构分析找到 ${potentialQuestions.length} 个潜在题目`, 'blue');
return potentialQuestions;
}
logger('未找到任何题目容器', 'red');
return [];
}
// 处理智慧树题目 - 已禁用，使用新的zhsProcessQuestions系统
function processZhihuishuQuestion(index, questionContainers) {
logger('旧的题目处理系统已禁用，使用主要的zhsProcessQuestions系统', 'blue');
// 直接调用主要的处理系统，避免冲突
return;
}
// 点击智慧树下一题按钮
function clickNextQuestionButton() {
try {
// 首先检查答题状态 - 只有在答题开启时才点击下一题
const isAutoAnswerEnabled = localStorage.getItem('GPTJsSetting.work') === 'true';
if (!isAutoAnswerEnabled) {
logger(`🛑 自动答题已关闭，停止点击下一题按钮`, 'orange');
return false;
}
// 智慧树下一题按钮的多种可能选择器
const nextButtonSelectors = [
'.Topicswitchingbtn:contains(下一题)', // 原始智慧树助手使用的选择器
'.next-btn', // 通用下一题按钮
'.btn-next', // 另一种下一题按钮
'[class*="next"]', // 包含next的类名
'button:contains(下一题)', // 包含"下一题"文本的按钮
'a:contains(下一题)', // 包含"下一题"文本的链接
'.nextDiv a', // 下一题区域的链接
'.jb_btn:contains(下一题)' // 特定样式的下一题按钮
];
let nextButton = null;
// 尝试找到下一题按钮
for (const selector of nextButtonSelectors) {
if (selector.includes(':contains(')) {
// 对于包含:contains的选择器，需要特殊处理
const baseSelector = selector.split(':contains(')[0];
const containsText = selector.match(/:contains\((.+?)\)/)[1];
const elements = document.querySelectorAll(baseSelector);
for (const element of elements) {
if (element.textContent.includes(containsText)) {
nextButton = element;
break;
}
}
} else {
nextButton = document.querySelector(selector);
}
if (nextButton) {
logger(`找到下一题按钮，使用选择器: ${selector}`, 'blue');
break;
}
}
if (nextButton) {
// 检查按钮是否可点击
if (nextButton.disabled || nextButton.style.display === 'none' ||
nextButton.style.visibility === 'hidden') {
logger('下一题按钮不可点击，跳过', 'orange');
return false;
}
// 点击下一题按钮
nextButton.click();
logger('成功点击下一题按钮', 'green');
return true;
} else {
logger('未找到下一题按钮，可能已是最后一题', 'orange');
// 尝试查找提交按钮
const submitSelectors = [
'.submit-btn',
'.btn-submit',
'[class*="submit"]',
'button:contains(提交)',
'a:contains(提交)',
'.submitDiv button',
'.jb_btn:contains(提交)'
];
for (const selector of submitSelectors) {
let submitButton = null;
if (selector.includes(':contains(')) {
const baseSelector = selector.split(':contains(')[0];
const containsText = selector.match(/:contains\((.+?)\)/)[1];
const elements = document.querySelectorAll(baseSelector);
for (const element of elements) {
if (element.textContent.includes(containsText)) {
submitButton = element;
break;
}
}
} else {
submitButton = document.querySelector(selector);
}
if (submitButton) {
logger(`找到提交按钮，准备提交: ${selector}`, 'blue');
setTimeout(() => {
submitButton.click();
logger('已点击提交按钮', 'green');
}, 2000);
return true;
}
}
return false;
}
} catch (error) {
logger(`点击下一题按钮时出错: ${error}`, 'red');
return false;
}
}
// 解析智慧树题目
function parseZhihuishuQuestion(container) {
try {
// 查找题目文本
let questionText = '';
// 首先尝试查找题目文本，排除选项区域
const questionSelectors = [
'p:not(.optionUl p):not(.el-radio p)', // p标签但不在选项区域内
'.question-text',
'.subject_stem',
'.question-content',
'.stem',
'.title'
];
for (const selector of questionSelectors) {
const questionElements = container.querySelectorAll(selector);
for (const questionElement of questionElements) {
const text = questionElement.textContent.trim();
// 确保不是选项文本，且有足够长度
if (text && text.length > 10 && !text.match(/^[A-D]\./) &&
!questionElement.closest('.optionUl') &&
!questionElement.closest('.el-radio')) {
questionText = text;
break;
}
}
if (questionText) break;
}
// 如果还没找到题目文本，尝试从容器的直接文本内容获取
if (!questionText) {
const allText = container.textContent.trim();
const lines = allText.split('\n').map(line => line.trim()).filter(line => line);
// 查找最可能是题目的行
for (const line of lines) {
// 跳过明显的选项行、标题行、分数行等
if (!line.match(/^[A-D]\./) &&
!line.match(/^\d+\.\s*【/) &&
!line.match(/总分|题目数|分数/) &&
!line.match(/^[一二三四五六七八九十]+、/) &&
line.length > 15 && line.length < 200) {
questionText = line;
break;
}
}
}
// 查找选项 - 改进的选项查找逻辑
const options = [];
// 方法1：查找标准的智慧树选项结构
const optionContainers = container.querySelectorAll('.optionUl');
if (optionContainers.length > 0) {
logger(`找到 ${optionContainers.length} 个选项容器`, 'blue');
optionContainers.forEach(optionContainer => {
const optionElements = optionContainer.querySelectorAll('.el-radio, label[role="radio"]');
optionElements.forEach((element, index) => {
const optionContent = element.querySelector('.optionContent');
const radioInput = element.querySelector('input[type="radio"]');
let optionText = '';
if (optionContent) {
optionText = optionContent.textContent.trim();
} else {
// 尝试其他方式获取选项文本
const spans = element.querySelectorAll('span');
for (const span of spans) {
const text = span.textContent.trim();
if (text && !text.match(/^[A-D]\.?$/) && text.length > 1) {
optionText = text;
break;
}
}
// 如果还是没找到，使用整个元素的文本
if (!optionText) {
optionText = element.textContent.trim();
}
}
// 清理选项文本，移除选项标签
optionText = optionText.replace(/^[A-D]\.?\s*/, '').trim();
// 进一步清理，移除多余的空白和特殊字符
optionText = optionText.replace(/\s+/g, ' ').trim();
if (optionText && optionText.length > 0 && optionText.length < 500) {
options.push({
text: optionText,
value: radioInput ? radioInput.value : `option_${index}`,
element: element,
input: radioInput
});
logger(`解析到选项 ${String.fromCharCode(65 + index)}: ${optionText.substring(0, 30)}...`, 'blue');
}
});
});
}
// 方法2：如果没找到选项，尝试直接查找radio输入
if (options.length === 0) {
const radioInputs = container.querySelectorAll('input[type="radio"]');
if (radioInputs.length > 0) {
logger(`通过radio输入找到 ${radioInputs.length} 个选项`, 'blue');
radioInputs.forEach((radioInput, index) => {
const label = radioInput.closest('label') || radioInput.parentElement;
let optionText = '';
if (label) {
optionText = label.textContent.trim();
optionText = optionText.replace(/^[A-D]\.?\s*/, '').trim();
if (optionText && optionText.length > 0 && optionText.length < 500) {
options.push({
text: optionText,
value: radioInput.value || `option_${index}`,
element: label,
input: radioInput
});
}
}
});
}
}
// 判断题目类型
let questionType = 0; // 默认单选题
if (questionText.includes('多选') || questionText.includes('多项选择')) {
questionType = 1; // 多选题
} else if (questionText.includes('判断') || questionText.includes('对错') ||
options.some(opt =>
opt.text.includes('正确') || opt.text.includes('错误') ||
opt.text.includes('对') || opt.text.includes('错') ||
opt.text.includes('是') || opt.text.includes('否')
)) {
questionType = 3; // 判断题
} else if (questionText.includes('填空') || questionText.includes('空白')) {
questionType = 2; // 填空题
}
const result = {
question: questionText,
type: questionType,
options: options,
container: container
};
logger(`题目解析完成 - 题目: "${questionText.substring(0, 50)}...", 选项数: ${options.length}, 类型: ${questionType}`, 'green');
return result;
} catch (error) {
logger(`解析题目时出错: ${error}`, 'red');
return null;
}
}
// 获取智慧树答案
function getZhihuishuAnswer(questionData) {
return new Promise((resolve, reject) => {
var userKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || setting.token || '';
if (!userKey) {
logger('未设置API Key，无法调用题库API', 'orange');
resolve(null);
return;
}
// 构建题目文本，包含选项 - 修复选项数据格式问题
let questionWithOptions = questionData.question;
var optionsText = '';
if (questionData.options.length > 0) {
optionsText = questionData.options.map(function (option, index) {
var label = String.fromCharCode(65 + index); // A, B, C, D...
// 处理选项可能是字符串或对象的情况
var optionText = typeof option === 'string' ? option : (option.text || option);
return label + '.' + optionText;
}).join('\n');
}
// 题型映射
var typeMapping = {
0: '单选题',
1: '单选题',
2: '多选题',
3: '填空题',
4: '问答题',
14: '判断题'
};
var mappedType = typeMapping[questionData.type] || '单选题';
// 构建请求数据
var requestData = "key=" + encodeURIComponent(userKey) +
"&question=" + encodeURIComponent(questionData.question) +
"&type=" + encodeURIComponent(mappedType);
if (optionsText) {
requestData += "&options=" + encodeURIComponent(optionsText);
}
logger('📚 发送题库API请求到 tk.mixuelo.cc...', 'blue');
const API_BASE_URL = (() => {
const baseUrl = "tk.mixuelo.cc/api.php";
const protocol = window.location.protocol;
if (protocol === 'https:') {
return "https://" + baseUrl;
} else {
return "http://" + baseUrl;
}
})();
GM_xmlhttpRequest({
method: "POST",
url: API_BASE_URL + "?act=query",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
"Cookie": "PHPSESSID=th9rcnfi47nl9fhjsjrcbmvq01"
// 添加Cookie头部，API Key通过data参数传递
},
data: requestData,
timeout: 30000, // 修复主题库查询问题 - 增加超时时间到30秒
onload: function (response) {
try {
logger(`📚 题库API响应状态: ${response.status}`, 'blue');
logger(`📚 题库API响应内容: ${response.responseText.substring(0, 200)}...`, 'blue');
if (response.status === 200) {
var result = JSON.parse(response.responseText);
if (result.code === 1 && result.data && result.data.trim() !== '') {
logger(`📚 题库API成功返回答案: ${result.data}`, 'green');
resolve(result.data);
} else {
logger(`📚 题库API返回错误: ${result.msg || result.message || '未知错误'}`, 'orange');
resolve(null);
}
} else {
logger(`📚 题库API请求失败，状态码: ${response.status}`, 'red');
resolve(null);
}
} catch (e) {
logger(`📚 解析题库API响应失败: ${e.message}`, 'red');
logger(`📚 原始响应内容: ${response.responseText}`, 'red');
resolve(null);
}
},
onerror: function (error) {
logger(`📚 题库API请求网络错误: ${error}`, 'red');
resolve(null);
},
ontimeout: function () {
logger('📚 题库API请求超时（30秒）', 'red');
resolve(null);
}
});
});
}
// 选择智慧树选项
function selectZhihuishuOption(questionData, answer) {
try {
const answerText = answer.toLowerCase().trim();
let selectedCount = 0;
// 遍历选项寻找匹配
questionData.options.forEach((option, index) => {
// 修复选项文本获取问题 - 支持多种数据结构
const optionText = (option.content || option.text || option || '').toString().replace(/<[^>]*>/g, '').toLowerCase().trim();
let shouldSelect = false;
// 判断题特殊处理
if (questionData.type === 3) {
if ((answerText.includes('正确') || answerText.includes('对') || answerText.includes('是') || answerText.includes('√') || answerText.includes('t')) &&
(optionText.includes('正确') || optionText.includes('对') || optionText.includes('是') || optionText.includes('√'))) {
shouldSelect = true;
} else if ((answerText.includes('错误') || answerText.includes('错') || answerText.includes('否') || answerText.includes('×') || answerText.includes('f')) &&
(optionText.includes('错误') || optionText.includes('错') || optionText.includes('否') || optionText.includes('×'))) {
shouldSelect = true;
}
} else {
// 其他题型：检查答案是否包含选项内容
if (answerText.includes(optionText) || optionText.includes(answerText)) {
shouldSelect = true;
}
// 检查选项标签匹配 (A, B, C, D)
const optionLabel = String.fromCharCode(65 + index);
if (answerText.includes(optionLabel.toLowerCase()) || answerText.includes(optionLabel)) {
shouldSelect = true;
}
}
if (shouldSelect) {
// 检查选项是否已经被选中 - 修复重复选择导致的匹配失败问题
const isAlreadySelected = option.input && option.input.checked;
if (isAlreadySelected) {
// 修复日志显示选项文本问题
const displayText = (option.content || option.text || option || '').toString().replace(/<[^>]*>/g, '').trim();
logger(`选项 ${String.fromCharCode(65 + index)} 已被选中: ${displayText}`, 'blue');
selectedCount++;
} else {
clickZhihuishuOption(option);
selectedCount++;
// 修复日志显示选项文本问题
const displayText = (option.content || option.text || option || '').toString().replace(/<[^>]*>/g, '').trim();
logger(`选择了选项 ${String.fromCharCode(65 + index)}: ${displayText}`, 'green');
}
// 单选题只选择一个选项
if (questionData.type === 0) {
return;
}
}
});
if (selectedCount === 0) {
// 检查是否所有选项都已经被选中
const alreadySelectedCount = questionData.options.filter(option => option.input && option.input.checked).length;
if (alreadySelectedCount > 0) {
logger(`💡 题目已有 ${alreadySelectedCount} 个选项被选中，无需重复选择`, 'blue');
// 添加成功状态指示器，因为题目实际上已经完成
const questionNumber = getCurrentQuestionNumber();
const actualQuestionText = getQuestionText(document.querySelector('.questionContent')) || '题目内容获取失败';
const selectedOptions = questionData.options
.filter(option => option.input && option.input.checked)
.map((option) => {
const displayText = (option.content || option.text || option || '').toString().replace(/<[^>]*>/g, '').trim();
return `${String.fromCharCode(65 + questionData.options.indexOf(option))}. ${displayText}`;
})
.join(', ');
addQuestionStatusIndicator(questionNumber, 'success', {
question: actualQuestionText,
answer: answer,
selected: selectedOptions,
type: questionData.type === 0 ? '单选题' : questionData.type === 1 ? '多选题' : '其他',
error: '题目已完成，无需重复选择'
});
} else {
logger('❌ 未找到匹配的选项', 'red');
logger('💡 提示: 请检查答案格式或题库数据准确性', 'blue');
// 添加失败状态指示器
const questionNumber = getCurrentQuestionNumber();
const actualQuestionText = getQuestionText(document.querySelector('.questionContent')) || '题目内容获取失败';
addQuestionStatusIndicator(questionNumber, 'failed', {
question: actualQuestionText,
answer: answer,
error: '未找到选项或，已经答题',
type: questionData.type === 0 ? '单选题' : questionData.type === 1 ? '多选题' : '其他'
});
}
}
} catch (error) {
logger(`❌ 选择选项时出错: ${error}`, 'red');
logger('💡 提示: 请检查页面结构或刷新页面重试', 'blue');
}
}
// 点击智慧树选项
function clickZhihuishuOption(option) {
try {
// 尝试多种点击方式
if (option.input) {
// 方式1：直接点击radio input
option.input.click();
} else if (option.element) {
// 方式2：点击选项元素
option.element.click();
}
// 方式3：触发change事件
if (option.input) {
option.input.checked = true;
const event = new Event('change', { bubbles: true });
option.input.dispatchEvent(event);
}
// 修复选项文本显示问题
const displayText = (option.content || option.text || option || '').toString().replace(/<[^>]*>/g, '').trim();
logger(`成功点击选项: ${displayText.substring(0, 20)}...`, 'green');
} catch (error) {
logger(`点击选项失败: ${error}`, 'red');
}
}
// 随机选择功能已删除 - 根据用户要求完全删除随机选择功能
// 初始化视频专用UI - 简化版控制面板，只包含视频相关功能
function initZhihuishuVideoUI() {
logger('🎬 开始初始化视频页面专用控制面板', 'blue');
// 防止重复创建
if (document.getElementById('zhs-video-control-panel')) {
logger('🎬 视频控制面板已存在，跳过创建', 'orange');
return;
}
try {
const panel = document.createElement('div');
panel.id = 'zhs-video-control-panel';
// 创建标题栏
const header = document.createElement('div');
header.style.cssText = `
background: #409EFF;
color: white;
padding: 12px 15px;
border-radius: 8px 8px 0 0;
font-weight: 500;
display: flex;
align-items: center;
cursor: move;
`;
const logo = document.createElement('img');
logo.src = 'https://mx.mixuelo.cc/index/pengzi/images/思考2.gif';
logo.style.cssText = 'width: 20px; height: 20px; margin-right: 8px;';
const title = document.createElement('span');
title.textContent = '智慧树视频助手';
header.appendChild(logo);
header.appendChild(title);
// 创建内容区域
const content = document.createElement('div');
content.style.cssText = 'padding: 15px;';
// 视频控制区域
const videoControl = document.createElement('div');
videoControl.style.cssText = 'margin-bottom: 15px;';
videoControl.innerHTML = `
<label style="display: block; margin-bottom: 8px; font-weight: 500; color: #333;">🎬 视频控制</label>
<div style="display: flex; gap: 8px; margin-bottom: 8px;">
<label style="display: flex; align-items: center; font-size: 12px; cursor: pointer;">
<input type="checkbox" id="zhs-auto-video" style="margin-right: 5px;">
自动播放视频
</label>
</div>
<div style="display: flex; gap: 8px;">
<label style="display: flex; align-items: center; font-size: 12px; cursor: pointer;">
<input type="checkbox" id="zhs-auto-next" style="margin-right: 5px;">
自动下一个视频
</label>
</div>
`;
// 播放速度区域
const speedControl = document.createElement('div');
speedControl.style.cssText = 'margin-bottom: 15px;';
speedControl.innerHTML = `
<label style="display: block; margin-bottom: 8px; font-weight: 500; color: #333;">⚡ 播放速度</label>
<select id="zhs-video-speed" style="
width: 100%;
padding: 6px 8px;
border: 1px solid #ddd;
border-radius: 4px;
font-size: 12px;
">
<option value="0.5">0.5x</option>
<option value="1" selected>1.0x</option>
<option value="1.25">1.25x</option>
<option value="1.5">1.5x</option>
<option value="2">2.0x</option>
</select>
`;
// 状态显示区域
const statusArea = document.createElement('div');
statusArea.style.cssText = `
background: #f8f9fa;
padding: 8px;
border-radius: 4px;
font-size: 12px;
color: #666;
`;
statusArea.innerHTML = '<div id="zhs-video-status">等待视频加载...</div>';
// 组装面板
content.appendChild(videoControl);
content.appendChild(speedControl);
content.appendChild(statusArea);
panel.appendChild(header);
panel.appendChild(content);
// 设置面板样式
panel.style.cssText = `
position: fixed;
top: 20px;
right: 20px;
width: 280px;
background: white;
border: 1px solid #e0e0e0;
border-radius: 8px;
box-shadow: 0 4px 12px rgba(0,0,0,0.15);
z-index: 10000;
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
font-size: 13px;
`;
document.body.appendChild(panel);
logger('🎬 视频控制面板已创建并添加到页面', 'green');
// 初始化事件监听
setTimeout(() => {
initVideoControlEvents();
logger('🎬 视频控制事件已初始化', 'green');
}, 100);
// 使面板可拖拽
setTimeout(() => {
makeVideoPanelDraggable(panel);
logger('🎬 视频面板拖拽功能已启用', 'green');
}, 200);
} catch (error) {
logger(`🎬 视频控制面板创建失败: ${error.message}`, 'red');
}
}
// 初始化视频控制事件
function initVideoControlEvents() {
logger('🎬 开始初始化视频控制事件', 'blue');
try {
// 自动播放视频开关
const autoVideoToggle = document.getElementById('zhs-auto-video');
if (autoVideoToggle) {
autoVideoToggle.checked = localStorage.getItem('ZhsJsSetting.video') === 'true';
autoVideoToggle.addEventListener('change', (e) => {
const isChecked = e.target.checked;
localStorage.setItem('ZhsJsSetting.video', isChecked.toString());
setting.video = isChecked;
logger(`🎬 自动播放视频已${isChecked ? '开启' : '关闭'}`, isChecked ? 'green' : 'orange');
updateVideoStatus(`自动播放: ${isChecked ? '开启' : '关闭'}`);
});
logger('🎬 自动播放视频开关已初始化', 'green');
} else {
logger('🎬 未找到自动播放视频开关元素', 'orange');
}
// 自动下一个视频开关
const autoNextToggle = document.getElementById('zhs-auto-next');
if (autoNextToggle) {
// 默认开启自动下一个视频功能
autoNextToggle.checked = localStorage.getItem('ZhsJsSetting.jump') !== 'false';
localStorage.setItem('ZhsJsSetting.jump', autoNextToggle.checked.toString());
setting.jump = autoNextToggle.checked;
autoNextToggle.addEventListener('change', (e) => {
const isChecked = e.target.checked;
localStorage.setItem('ZhsJsSetting.jump', isChecked.toString());
setting.jump = isChecked;
logger(`🎬 自动下一个视频已${isChecked ? '开启' : '关闭'}`, isChecked ? 'green' : 'orange');
updateVideoStatus(`自动下一个: ${isChecked ? '开启' : '关闭'}`);
});
logger('🎬 自动下一个视频开关已初始化', 'green');
} else {
logger('🎬 未找到自动下一个视频开关元素', 'orange');
}
// 播放速度选择
const speedSelect = document.getElementById('zhs-video-speed');
if (speedSelect) {
speedSelect.addEventListener('change', (e) => {
const speed = parseFloat(e.target.value);
setVideoSpeed(speed);
logger(`🎬 视频播放速度设置为: ${speed}x`, 'blue');
updateVideoStatus(`播放速度: ${speed}x`);
});
logger('🎬 播放速度选择已初始化', 'green');
} else {
logger('🎬 未找到播放速度选择元素', 'orange');
}
// 初始化状态显示
updateVideoStatus('视频控制面板已就绪');
} catch (error) {
logger(`🎬 视频控制事件初始化失败: ${error.message}`, 'red');
}
}
// 使视频面板可拖拽
function makeVideoPanelDraggable(panel) {
let isDragging = false;
let currentX;
let currentY;
let initialX;
let initialY;
let xOffset = 0;
let yOffset = 0;
const header = panel.querySelector('div:first-child');
header.addEventListener('mousedown', dragStart);
document.addEventListener('mousemove', drag);
document.addEventListener('mouseup', dragEnd);
function dragStart(e) {
if (e.target.tagName === 'INPUT' || e.target.tagName === 'SELECT') return;
initialX = e.clientX - xOffset;
initialY = e.clientY - yOffset;
if (e.target === header || header.contains(e.target)) {
isDragging = true;
panel.style.cursor = 'grabbing';
}
}
function drag(e) {
if (isDragging) {
e.preventDefault();
currentX = e.clientX - initialX;
currentY = e.clientY - initialY;
xOffset = currentX;
yOffset = currentY;
panel.style.transform = `translate(${currentX}px, ${currentY}px)`;
}
}
function dragEnd() {
initialX = currentX;
initialY = currentY;
isDragging = false;
panel.style.cursor = 'move';
}
}
// 更新视频状态显示
function updateVideoStatus(status) {
const statusDiv = document.getElementById('zhs-video-status');
if (statusDiv) {
statusDiv.textContent = status;
}
}
// 设置视频播放速度
function setVideoSpeed(speed) {
const videos = document.querySelectorAll('video');
videos.forEach(video => {
video.playbackRate = speed;
});
}
// 初始化视频自动下一个功能
function initVideoAutoNext() {
logger('🎬 初始化视频自动下一个功能', 'blue');
// 监听视频播放结束事件
const checkVideoEnd = () => {
const videos = document.querySelectorAll('video');
videos.forEach(video => {
if (!video.hasAttribute('data-auto-next-listener')) {
video.setAttribute('data-auto-next-listener', 'true');
video.addEventListener('ended', () => {
if (setting.jump) {
logger('🎬 视频播放结束，准备自动下一个', 'green');
updateVideoStatus('视频播放结束，准备跳转...');
setTimeout(goToNextVideo, 2000);
}
});
logger(`🎬 已为视频添加播放结束监听器`, 'green');
}
});
};
// 定期检查新的视频元素
setInterval(checkVideoEnd, 3000);
checkVideoEnd();
// 额外的检测机制：监听任务点状态变化
const checkTaskStatus = () => {
// 检查当前任务是否已完成（出现icon-finish）
const currentActiveItem = document.querySelector('.file-item.active');
if (currentActiveItem) {
const hasFinishIcon = currentActiveItem.querySelector('.icon-finish');
if (hasFinishIcon && setting.jump) {
logger('🎬 检测到当前任务已完成，准备自动下一个', 'green');
updateVideoStatus('任务已完成，准备跳转...');
setTimeout(goToNextVideo, 3000);
}
}
};
// 定期检查任务状态
setInterval(checkTaskStatus, 5000);
logger('🎬 视频自动下一个功能已启动', 'green');
}
// 跳转到下一个视频 - 根据icon-finish元素判断
function goToNextVideo() {
try {
logger('开始查找下一个未完成的视频任务', 'blue');
// 查找所有视频任务项（包含icon-video的元素）
const videoItems = document.querySelectorAll('.file-item');
let nextVideoItem = null;
// 遍历所有任务项，找到第一个没有icon-finish的视频任务
for (const item of videoItems) {
const hasVideoIcon = item.querySelector('.icon-video');
const hasFinishIcon = item.querySelector('.icon-finish');
// 如果是视频任务且没有完成标记
if (hasVideoIcon && !hasFinishIcon) {
nextVideoItem = item;
break;
}
}
if (nextVideoItem) {
const fileName = nextVideoItem.querySelector('.file-name')?.textContent || '未知';
const fileId = nextVideoItem.id.replace('file_', '');
logger(`找到下一个未完成的视频: ${fileName} (ID: ${fileId})`, 'green');
// 点击跳转到下一个视频
nextVideoItem.click();
updateVideoStatus(`正在跳转到: ${fileName}`);
// 记录跳转信息
setTimeout(() => {
logger(`已跳转到视频: ${fileName}`, 'green');
updateVideoStatus(`当前视频: ${fileName}`);
}, 2000);
} else {
// 没有找到未完成的视频，查找未完成的文档任务
for (const item of videoItems) {
const hasDocIcon = item.querySelector('.icon-doc');
const hasFinishIcon = item.querySelector('.icon-finish');
if (hasDocIcon && !hasFinishIcon) {
nextVideoItem = item;
break;
}
}
if (nextVideoItem) {
const fileName = nextVideoItem.querySelector('.file-name')?.textContent || '未知';
logger(`所有视频已完成，跳转到下一个文档任务: ${fileName}`, 'blue');
nextVideoItem.click();
updateVideoStatus(`跳转到文档: ${fileName}`);
} else {
logger('所有任务已完成！', 'green');
updateVideoStatus('所有任务已完成');
}
}
} catch (error) {
logger(`自动下一个视频失败: ${error.message}`, 'red');
updateVideoStatus('自动下一个失败');
}
}
// 智慧树视频控制初始化
function initZhihuishuVideoControl() {
logger('🎬 初始化智慧树视频控制系统', 'blue');
// 延迟执行，等待页面加载完成
setTimeout(() => {
startZhihuishuVideoControl();
}, 2000);
// 定期检查新的视频元素
setInterval(() => {
startZhihuishuVideoControl();
}, 10000);
logger('🎬 视频控制系统监听器已启动', 'green');
}
// 开始智慧树视频控制
function startZhihuishuVideoControl() {
try {
// 查找视频元素
const videoElements = findZhihuishuVideoElements();
if (videoElements.length > 0) {
logger(`发现 ${videoElements.length} 个视频元素，开始处理`, 'green');
videoElements.forEach((video, index) => {
processZhihuishuVideo(video, index);
});
}
// 查找iframe中的视频
const iframes = document.querySelectorAll('iframe');
iframes.forEach((iframe, index) => {
try {
const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
if (iframeDoc) {
const iframeVideos = iframeDoc.querySelectorAll('video');
if (iframeVideos.length > 0) {
logger(`在iframe ${index + 1} 中发现 ${iframeVideos.length} 个视频`, 'blue');
iframeVideos.forEach((video, videoIndex) => {
processZhihuishuVideo(video, `iframe-${index}-${videoIndex}`);
});
}
}
} catch (e) {
// 跨域iframe无法访问，忽略错误
}
});
} catch (error) {
logger(`视频控制出错: ${error}`, 'red');
}
}
// 查找智慧树视频元素
function findZhihuishuVideoElements() {
const selectors = [
'video', // 直接的video标签
'.video-player video', // 视频播放器中的video
'.player-container video', // 播放器容器中的video
'[class*="video"] video', // 包含video类名的容器中的video
'.vjs-tech', // Video.js技术层
];
let videos = [];
for (const selector of selectors) {
const elements = document.querySelectorAll(selector);
if (elements.length > 0) {
videos = Array.from(elements);
logger(`使用选择器 "${selector}" 找到 ${elements.length} 个视频`, 'blue');
break;
}
}
return videos;
}
// 处理智慧树视频
function processZhihuishuVideo(video, index) {
try {
if (!video || video.zhsProcessed) {
return; // 避免重复处理
}
logger(`处理第 ${index + 1} 个视频元素`, 'blue');
// 标记已处理
video.zhsProcessed = true;
// 设置视频属性
setupZhihuishuVideoProperties(video);
// 自动播放
if (setting.video) {
autoPlayZhihuishuVideo(video, index);
}
// 监听视频事件
setupZhihuishuVideoEvents(video, index);
} catch (error) {
logger(`处理视频 ${index + 1} 时出错: ${error}`, 'red');
}
}
// 设置智慧树视频属性
function setupZhihuishuVideoProperties(video) {
try {
// 设置音量
const volume = parseFloat(setting.vol) / 100;
video.volume = volume;
// 设置静音
video.muted = setting.vol == '0';
// 设置倍速
const speed = parseFloat(setting.speed);
if (speed > 0 && speed <= 16) {
video.playbackRate = speed;
logger(`视频倍速设置为: ${speed}x`, 'blue');
}
// 其他属性设置
video.controls = true; // 显示控制条
video.preload = 'auto'; // 预加载
logger(`视频属性设置完成 - 音量: ${volume}, 倍速: ${speed}x, 静音: ${video.muted}`, 'blue');
} catch (error) {
logger(`设置视频属性时出错: ${error}`, 'red');
}
}
// 自动播放智慧树视频
function autoPlayZhihuishuVideo(video, index) {
try {
// 尝试播放视频
const playPromise = video.play();
if (playPromise !== undefined) {
playPromise.then(() => {
logger(`视频 ${index + 1} 开始播放，倍速: ${setting.speed}x`, 'green');
}).catch(error => {
logger(`视频 ${index + 1} 自动播放失败: ${error.message}`, 'orange');
// 尝试用户交互后播放
setTimeout(() => {
video.play().then(() => {
logger(`视频 ${index + 1} 延迟播放成功`, 'green');
}).catch(e => {
logger(`视频 ${index + 1} 延迟播放也失败: ${e.message}`, 'red');
});
}, 1000);
});
} else {
logger(`视频 ${index + 1} 播放方法不支持Promise`, 'orange');
}
} catch (error) {
logger(`播放视频 ${index + 1} 时出错: ${error}`, 'red');
}
}
// 设置智慧树视频事件监听
function setupZhihuishuVideoEvents(video, index) {
try {
// 播放事件
video.addEventListener('play', () => {
logger(`视频 ${index + 1} 开始播放`, 'green');
});
// 暂停事件
video.addEventListener('pause', () => {
logger(`视频 ${index + 1} 暂停播放`, 'orange');
// 如果设置了自动播放，尝试继续播放
if (setting.video && !video.ended) {
setTimeout(() => {
video.play().catch(e => {
logger(`重新播放视频 ${index + 1} 失败: ${e.message}`, 'red');
});
}, 2000);
}
});
// 结束事件
video.addEventListener('ended', () => {
logger(`视频 ${index + 1} 播放完成`, 'green');
});
// 错误事件
video.addEventListener('error', (e) => {
logger(`视频 ${index + 1} 播放错误: ${e.message || '未知错误'}`, 'red');
});
// 时间更新事件（用于显示进度）
video.addEventListener('timeupdate', () => {
if (video.duration > 0) {
const progress = (video.currentTime / video.duration * 100).toFixed(1);
// 每10%显示一次进度，避免日志过多
if (progress % 10 < 0.1) {
logger(`视频 ${index + 1} 播放进度: ${progress}%`, 'blue');
}
}
});
// 加载完成事件
video.addEventListener('loadeddata', () => {
logger(`视频 ${index + 1} 数据加载完成，时长: ${video.duration.toFixed(1)}秒`, 'blue');
});
} catch (error) {
logger(`设置视频事件监听时出错: ${error}`, 'red');
}
}
function hookHiexam() {
var ajax = new xhr();
ajax.onload = function () {
if (this.status != 200 || !this.responseURL.match('getDoQuestSingle')) return;
var obj = JSON.parse(this.responseText).rt;
$.each(obj.questionOptionList || [], function (index) {
var $input = $('.TitleOptions-div input')[index];
if (obj.questionTypeId == 1) {
this.isCorrect && setting.queue.push($input);
} else if (obj.questionTypeId == 2) {
this.isCorrect == $input.checked || setting.queue.push($input);
}
});
};
return ajax;
}
function filterStyle(dom, that) {
var $dom = $(dom, that).clone().find('style').remove().end();
return $dom.find('img[src]').replaceWith(function () {
return $('<p></p>').text('<img src="' + $(this).attr('src') + '">');
}).end().text().trim();
}
// 添加字符串转换方法
String.prototype.toCDB = function () {
return this.replace(/[\uff01-\uff5e]/g, function (a) {
return String.fromCharCode(a.charCodeAt(0) - 65248);
});
};
// 添加智慧树API Key配置界面样式
function addZhsConfigStyles() {
if (document.getElementById('zhs-config-styles')) return;
const style = document.createElement('style');
style.id = 'zhs-config-styles';
style.textContent = `
@keyframes slideIn {
from {
opacity: 0;
transform: translateX(30px);
}
to {
opacity: 1;
transform: translateX(0);
}
}
.zhs-config-panel::-webkit-scrollbar {
width: 6px;
}
.zhs-config-panel::-webkit-scrollbar-thumb {
background: #409EFF;
border-radius: 3px;
}
.zhs-config-panel::-webkit-scrollbar-track {
background: rgba(0, 0, 0, 0.1);
border-radius: 3px;
}
#zhs-control-panel::-webkit-scrollbar {
width: 6px;
}
#zhs-control-panel::-webkit-scrollbar-thumb {
background: #409EFF;
border-radius: 3px;
}
#zhs-control-panel::-webkit-scrollbar-track {
background: rgba(0, 0, 0, 0.1);
border-radius: 3px;
}
#zhs-log-window::-webkit-scrollbar {
width: 6px;
}
#zhs-log-window::-webkit-scrollbar-thumb {
background: #409EFF;
border-radius: 3px;
}
#zhs-log-window::-webkit-scrollbar-track {
background: rgba(0, 0, 0, 0.1);
border-radius: 3px;
}
.zhs-config-panel {
position: fixed !important;
top: 80px !important;
right: 10px !important;
width: 320px !important;
max-height: 500px !important;
overflow-y: auto !important;
background: rgba(255, 255, 255, 0.98) !important;
border-radius: 12px !important;
box-shadow: 0 8px 32px rgba(0, 0, 0, 0.2) !important;
z-index: 2147483647 !important;
padding: 20px !important;
font-family: "Microsoft YaHei", sans-serif !important;
transition: all 0.3s ease !important;
border: 2px solid #409EFF !important;
backdrop-filter: blur(10px) !important;
}
.zhs-config-header {
text-align: center !important;
margin-bottom: 20px !important;
color: #409EFF !important;
font-size: 18px !important;
font-weight: bold !important;
border-bottom: 2px solid #409EFF !important;
padding-bottom: 10px !important;
}
.zhs-config-section {
margin-bottom: 20px !important;
padding: 15px !important;
background: rgba(64, 158, 255, 0.05) !important;
border-radius: 8px !important;
border: 1px solid rgba(64, 158, 255, 0.2) !important;
}
.zhs-config-label {
display: block !important;
margin-bottom: 8px !important;
color: #333 !important;
font-weight: bold !important;
font-size: 14px !important;
}
.zhs-config-input {
width: 100% !important;
padding: 10px !important;
border: 2px solid #ddd !important;
border-radius: 6px !important;
font-size: 14px !important;
transition: border-color 0.3s ease !important;
box-sizing: border-box !important;
}
.zhs-config-input:focus {
outline: none !important;
border-color: #FC3D74 !important;
box-shadow: 0 0 0 3px rgba(252, 61, 116, 0.1) !important;
}
.zhs-config-button {
width: 100% !important;
padding: 12px !important;
background: linear-gradient(135deg, #409EFF, #337ecc) !important;
color: white !important;
border: none !important;
border-radius: 6px !important;
font-size: 14px !important;
font-weight: bold !important;
cursor: pointer !important;
transition: all 0.3s ease !important;
margin-top: 10px !important;
}
.zhs-config-button:hover {
background: linear-gradient(135deg, #337ecc, #2b6cb0) !important;
transform: translateY(-2px) !important;
box-shadow: 0 4px 12px rgba(64, 158, 255, 0.3) !important;
}
.zhs-config-message {
margin-top: 10px !important;
padding: 10px !important;
border-radius: 6px !important;
font-size: 13px !important;
font-weight: bold !important;
text-align: center !important;
transition: all 0.3s ease !important;
display: none !important;
}
.zhs-config-message.success {
background: #4CAF50 !important;
color: white !important;
}
.zhs-config-message.error {
background: #f44336 !important;
color: white !important;
}
.zhs-config-status {
text-align: center !important;
padding: 10px !important;
border-radius: 6px !important;
font-size: 13px !important;
font-weight: bold !important;
margin-bottom: 15px !important;
}
.zhs-config-status.configured {
background: rgba(76, 175, 80, 0.1) !important;
color: #4CAF50 !important;
border: 1px solid rgba(76, 175, 80, 0.3) !important;
}
.zhs-config-status.not-configured {
background: rgba(244, 67, 54, 0.1) !important;
color: #f44336 !important;
border: 1px solid rgba(244, 67, 54, 0.3) !important;
}
.zhs-config-close {
position: absolute !important;
top: 10px !important;
right: 15px !important;
background: none !important;
border: none !important;
font-size: 20px !important;
color: #FC3D74 !important;
cursor: pointer !important;
width: 30px !important;
height: 30px !important;
border-radius: 50% !important;
display: flex !important;
align-items: center !important;
justify-content: center !important;
transition: all 0.3s ease !important;
}
.zhs-config-close:hover {
background: rgba(252, 61, 116, 0.1) !important;
transform: rotate(90deg) !important;
}
.zhs-floating-button {
position: fixed !important;
bottom: 20px !important;
right: 20px !important;
width: 60px !important;
height: 60px !important;
background: linear-gradient(135deg, #409EFF, #337ecc) !important;
border-radius: 50% !important;
display: flex !important;
align-items: center !important;
justify-content: center !important;
color: white !important;
font-size: 24px !important;
cursor: pointer !important;
box-shadow: 0 4px 20px rgba(64, 158, 255, 0.4) !important;
transition: all 0.3s ease !important;
z-index: 2147483646 !important;
border: none !important;
}
.zhs-floating-button:hover {
transform: scale(1.1) !important;
box-shadow: 0 6px 25px rgba(64, 158, 255, 0.6) !important;
}
.zhs-status-indicator {
position: absolute !important;
top: -5px !important;
right: -5px !important;
width: 20px !important;
height: 20px !important;
border-radius: 50% !important;
border: 2px solid white !important;
font-size: 10px !important;
display: flex !important;
align-items: center !important;
justify-content: center !important;
}
.zhs-status-indicator.configured {
background: #4CAF50 !important;
}
.zhs-status-indicator.not-configured {
background: #f44336 !important;
animation: pulse 2s infinite !important;
}
@keyframes pulse {
0% { opacity: 1; }
50% { opacity: 0.5; }
100% { opacity: 1; }
}
`;
document.head.appendChild(style);
}
// 创建智慧树API Key配置界面
function createZhsConfigPanel() {
// 防止重复创建
if (document.getElementById('zhs-config-panel')) return;
// 添加样式
addZhsConfigStyles();
// 获取当前配置状态
const currentKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || '';
const isConfigured = !!currentKey;
// 创建配置面板
const panel = document.createElement('div');
panel.id = 'zhs-config-panel';
panel.className = 'zhs-config-panel';
panel.innerHTML = `
<button class="zhs-config-close" id="zhs-close-btn">×</button>
<div class="zhs-config-header">
🌟 智慧树助手配置
</div>
<div class="zhs-config-status ${isConfigured ? 'configured' : 'not-configured'}">
${isConfigured ? '✅ API Key 已配置' : '⚠️ 请配置 API Key'}
</div>
<div class="zhs-config-section">
<label class="zhs-config-label" for="zhs-api-key">
🔑 题库 API Key:
</label>
<input
type="text"
id="zhs-api-key"
class="zhs-config-input"
placeholder="请输入您的题库 API Key"
value="${currentKey}"
>
<button class="zhs-config-button" id="zhs-save-btn">
💾 保存并验证
</button>
<div id="zhs-config-message" class="zhs-config-message"></div>
</div>
<div class="zhs-config-section">
<label class="zhs-config-label">
🔑 题库API配置:
</label>
<div style="margin-bottom: 10px;">
<input type="text" id="zhs-api-key" placeholder="请输入题库API Key"
style="width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; font-size: 13px;"
value="${localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || ''}">
</div>
<div style="font-size: 12px; color: #999; background: rgba(252, 61, 116, 0.05); padding: 8px; border-radius: 4px; margin-bottom: 15px;">
<strong>💡 提示：</strong>请输入有效的题库API Key以使用题库功能
</div>
</div>
<div class="zhs-config-section">
<label class="zhs-config-label">
🚀 答题功能控制:
</label>
<div style="margin-bottom: 10px;">
<label style="display: flex; align-items: center; margin-bottom: 8px;">
<input type="checkbox" id="zhs-work" style="margin-right: 8px;" ${localStorage.getItem('GPTJsSetting.work') !== 'false' ? 'checked' : ''}>
<span style="font-size: 14px; font-weight: bold; color: #FC3D74;">自动答题功能</span>
</label>
</div>
<div style="font-size: 12px; color: #999; background: rgba(252, 61, 116, 0.05); padding: 8px; border-radius: 4px; margin-bottom: 15px;">
<strong>⚠️ 重要：</strong>关闭此选项将停止所有自动答题功能
</div>
</div>
<div class="zhs-config-section">
<label class="zhs-config-label">
🎯 答题优先级配置:
</label>
<div style="margin-bottom: 10px;">
<label style="display: flex; align-items: center; margin-bottom: 5px;">
<input type="checkbox" id="zhs-use-tiku" style="margin-right: 8px;" ${localStorage.getItem('GPTJsSetting.useTiku') === 'true' ? 'checked' : ''}>
<span style="font-size: 13px;">启用题库API（主要答题方式）</span>
</label>
<label style="display: flex; align-items: center; margin-bottom: 5px;">
<input type="checkbox" id="zhs-use-ai" style="margin-right: 8px;" ${localStorage.getItem('GPTJsSetting.useAI') === 'true' ? 'checked' : ''}>
<span style="font-size: 13px;">启用AI答题（题库API失败时使用）</span>
</label>
</div>
<div style="font-size: 12px; color: #999; background: rgba(252, 61, 116, 0.05); padding: 8px; border-radius: 4px;">
<strong>优先级顺序：</strong>主题库 → 备用题库 → AI答题
</div>
</div>
<div class="zhs-config-section">
<div style="font-size: 13px; color: #666; line-height: 1.5;">
<strong>📋 使用说明:</strong><br>
• 配置API Key后可自动获取正确答案<br>
• 支持多层备用方案确保答题连续性<br>
• 按F9或点击浮动按钮可快速打开配置<br>
• 所有配置将安全存储在本地浏览器中
</div>
</div>
<div class="zhs-config-section">
<div style="font-size: 12px; color: #999; text-align: center;">
智慧树自动答题助手 v2.0<br>
支持自动答题、视频播放等功能
</div>
</div>
`;
document.body.appendChild(panel);
setupZhsConfigPanelEvents(panel);
// 添加拖拽功能
makeZhsPanelDraggable(panel);
}
// 保存API Key
function saveZhsApiKey() {
const keyInput = document.getElementById('zhs-api-key');
const messageDiv = document.getElementById('zhs-config-message');
const key = keyInput.value.trim();
if (!key) {
showZhsMessage('请输入API Key！', 'error');
return;
}
// 显示验证中状态
showZhsMessage('正在验证API Key...', 'info');
// 发送验证请求
GM_xmlhttpRequest({
method: "POST",
url: API_BASE_URL + "?act=verify_key",
headers: {
"Content-Type": "application/x-www-form-urlencoded"
},
data: "key=" + encodeURIComponent(key),
timeout: 10000,
onload: function (response) {
try {
if (response.status === 200) {
const result = JSON.parse(response.responseText);
if (result.code === 1) {
// 验证成功，保存key
localStorage.setItem('GPTJsSetting.key', key);
localStorage.setItem('tiku_key', key);
showZhsMessage('✅ API Key 验证成功并已保存！', 'success');
logger('API Key 配置成功', 'green');
// 更新状态显示
updateZhsConfigStatus(true);
updateZhsFloatingButton();
} else {
showZhsMessage('❌ Key不存在，请前往蜜雪激活', 'error');
}
} else {
showZhsMessage('❌ 验证请求失败，状态码: ' + response.status, 'error');
}
} catch (e) {
showZhsMessage('❌ 验证响应解析失败: ' + e.message, 'error');
}
},
onerror: function () {
showZhsMessage('❌ 网络请求失败，请检查网络连接', 'error');
},
ontimeout: function () {
showZhsMessage('❌ 请求超时，请稍后重试', 'error');
}
});
}
// 立即声明全局函数（在HTML创建之前）
window.saveZhsApiKey = saveZhsApiKey;
function setupZhsConfigPanelEvents(panel) {
try {
// 保存按钮事件
const saveBtn = panel.querySelector('#zhs-save-btn');
if (saveBtn) {
saveBtn.addEventListener('click', function (e) {
e.preventDefault();
saveZhsApiKey();
});
}
// 关闭按钮事件
const closeBtn = panel.querySelector('#zhs-close-btn');
if (closeBtn) {
closeBtn.addEventListener('click', function (e) {
e.preventDefault();
closeZhsConfigPanel();
});
}
// 输入框回车事件
const keyInput = panel.querySelector('#zhs-api-key');
if (keyInput) {
keyInput.addEventListener('keypress', function (e) {
if (e.key === 'Enter') {
e.preventDefault();
saveZhsApiKey();
}
});
}
const apiKeyInput = panel.querySelector('#zhs-api-key');
if (apiKeyInput) {
apiKeyInput.addEventListener('input', function (e) {
const key = e.target.value.trim();
localStorage.setItem('GPTJsSetting.key', key);
localStorage.setItem('tiku_key', key); // 同步到tiku_key
if (key) {
logger('API Key已更新: ' + key.substring(0, 3) + '***' + key.substring(key.length - 3), 'green');
} else {
logger('API Key已清空', 'orange');
}
});
}
const workCheckbox = panel.querySelector('#zhs-work');
if (workCheckbox) {
workCheckbox.addEventListener('change', function (e) {
const isEnabled = e.target.checked;
localStorage.setItem('GPTJsSetting.work', isEnabled.toString());
setting.work = isEnabled ? 1 : 0; // 同步到setting对象
logger('自动答题功能已' + (isEnabled ? '开启' : '关闭'), isEnabled ? 'green' : 'red');
// 如果关闭了自动答题功能，显示提示
if (!isEnabled) {
showZhsMessage('⚠️ 自动答题功能已关闭，需要手动开启才能继续答题', 'warning');
} else {
showZhsMessage('✅ 自动答题功能已开启，系统将自动处理题目', 'success');
}
});
}
// 题库API配置事件
const useTikuCheckbox = panel.querySelector('#zhs-use-tiku');
if (useTikuCheckbox) {
useTikuCheckbox.addEventListener('change', function (e) {
localStorage.setItem('GPTJsSetting.useTiku', e.target.checked);
logger('题库API配置已更新: ' + e.target.checked, 'blue');
});
}
// AI答题配置事件
const useAICheckbox = panel.querySelector('#zhs-use-ai');
if (useAICheckbox) {
useAICheckbox.addEventListener('change', function (e) {
localStorage.setItem('GPTJsSetting.useAI', e.target.checked);
logger('AI答题配置已更新: ' + e.target.checked, 'blue');
});
}
logger('配置面板事件监听器设置完成', 'green');
} catch (e) {
logger(`设置配置面板事件监听器失败: ${e.message}`, 'red');
}
}
// 显示消息
function showZhsMessage(message, type) {
const messageDiv = document.getElementById('zhs-config-message');
if (!messageDiv) return;
messageDiv.textContent = message;
messageDiv.className = 'zhs-config-message ' + type;
messageDiv.style.display = 'block';
// 3秒后自动隐藏
setTimeout(() => {
messageDiv.style.display = 'none';
}, 3000);
}
// 更新配置状态显示
function updateZhsConfigStatus(isConfigured) {
const statusDiv = document.querySelector('.zhs-config-status');
if (statusDiv) {
statusDiv.className = `zhs-config-status ${isConfigured ? 'configured' : 'not-configured'}`;
statusDiv.textContent = isConfigured ? '✅ API Key 已配置' : '⚠️ 请配置 API Key';
}
}
// 关闭配置面板
function closeZhsConfigPanel() {
const panel = document.getElementById('zhs-config-panel');
if (panel) {
panel.remove();
}
}
// 立即声明全局函数
window.closeZhsConfigPanel = closeZhsConfigPanel;
// 使面板可拖拽
function makeZhsPanelDraggable(panel) {
let isDragging = false;
let currentX;
let currentY;
let initialX;
let initialY;
let xOffset = 0;
let yOffset = 0;
panel.addEventListener('mousedown', dragStart);
document.addEventListener('mousemove', drag);
document.addEventListener('mouseup', dragEnd);
function dragStart(e) {
// 排除所有交互元素，防止拖拽干扰正常交互
const interactiveElements = ['INPUT', 'BUTTON', 'TEXTAREA', 'SELECT', 'OPTION', 'A'];
if (interactiveElements.includes(e.target.tagName)) return;
// 排除具有特定ID的元素（AI助手面板内的所有元素）
if (e.target.id && (e.target.id.startsWith('zhs-ai-') || e.target.closest('#zhs-tab-ai'))) return;
// 只允许在标题栏或空白区域拖拽
const isHeaderArea = e.target.classList.contains('zhs-tab-header') ||
e.target.closest('.zhs-tab-header') ||
(e.target === panel && !e.target.closest('.zhs-tab-panel'));
if (!isHeaderArea) return;
initialX = e.clientX - xOffset;
initialY = e.clientY - yOffset;
if (e.target === panel || panel.contains(e.target)) {
isDragging = true;
panel.style.cursor = 'grabbing';
}
}
function drag(e) {
if (isDragging) {
e.preventDefault();
currentX = e.clientX - initialX;
currentY = e.clientY - initialY;
xOffset = currentX;
yOffset = currentY;
panel.style.transform = `translate(${currentX}px, ${currentY}px)`;
}
}
function dragEnd() {
initialX = currentX;
initialY = currentY;
isDragging = false;
panel.style.cursor = 'move';
}
}
// 智慧树题库API调用函数
function zhsGetAnswerFromAPI(questionText, questionType, optionList) {
try {
// 移除自动答题功能检查 - 默认总是答题
// if (localStorage.getItem('GPTJsSetting.work') !== 'true') {
// logger('自动答题功能已关闭，跳过当前题目', 'orange');
// return;
// }
var userKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || setting.token || '';
if (!userKey) {
logger('未设置API Key，无法调用题库API', 'orange');
// 启动备用方案
zhsHandleAPIFailure(questionText, questionType, optionList);
return;
}
logger('开始调用题库API查询答案...', 'blue');
// 构建选项文本
var optionsText = '';
if (optionList && optionList.length > 0) {
optionsText = optionList.map(function (option, index) {
var label = String.fromCharCode(65 + index); // A, B, C, D...
return label + '.' + option.content.replace(/<[^>]*>/g, '').trim();
}).join('\n');
}
// 题型映射
var typeMapping = {
1: '单选题',
2: '多选题',
3: '填空题',
4: '问答题',
14: '判断题'
};
var mappedType = typeMapping[questionType] || '单选题';
// 构建请求数据
var requestData = "key=" + encodeURIComponent(userKey) +
"&question=" + encodeURIComponent(questionText) +
"&type=" + encodeURIComponent(mappedType);
if (optionsText) {
requestData += "&options=" + encodeURIComponent(optionsText);
}
// 检查题库API是否开启
if (localStorage.getItem('GPTJsSetting.useTiku') !== 'true') {
logger('题库API已禁用，跳过题库查询', 'orange');
zhsHandleAPIFailure(questionText, questionType, optionList);
return;
}
const API_BASE_URL = (() => {
const baseUrl = "tk.mixuelo.cc/api.php";
const protocol = window.location.protocol;
if (protocol === 'https:') {
return "https://" + baseUrl;
} else {
return "http://" + baseUrl;
}
})();
logger('发送题库API请求...', 'blue');
logger(`使用API Key: ${userKey.substring(0, 8)}...`, 'blue');
logger(`题库API状态: ${localStorage.getItem('GPTJsSetting.useTiku')}`, 'blue');
logger(`请求URL: ${API_BASE_URL}?act=query`, 'blue');
logger(`请求数据: ${requestData.substring(0, 200)}...`, 'blue');
GM_xmlhttpRequest({
method: "POST",
url: API_BASE_URL + "?act=query",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
"Cookie": "PHPSESSID=th9rcnfi47nl9fhjsjrcbmvq01"
// 添加Cookie头部，API Key通过data参数传递
},
data: requestData,
timeout: 30000, // 修复主题库查询问题 - 统一超时时间到30秒
onload: function (response) {
try {
if (response.status === 200) {
var result = JSON.parse(response.responseText);
if (result.code === 1 && result.data) {
logger(`题库API返回答案: ${result.data}`, 'green');
const success = zhsProcessAnswer(result.data, questionType, optionList);
if (success) {
// 只在答题成功后添加状态指示器
const currentQuestionNum = getCurrentQuestionNumber();
addQuestionStatusIndicator(currentQuestionNum, 'success', {
question: questionText,
answer: result.data,
selectedOptions: result.data,
type: '题库答题'
});
}
} else {
logger(`题库API返回错误: ${result.msg || '未知错误'}`, 'orange');
// 添加失败状态指示器
const currentQuestionNum = getCurrentQuestionNumber();
addQuestionStatusIndicator(currentQuestionNum, 'failed', {
question: questionText,
answer: '题库API失败',
selectedOptions: '无',
type: '题库API错误'
});
// 启动备用方案
zhsHandleAPIFailure(questionText, questionType, optionList);
}
} else {
logger(`题库API请求失败，状态码: ${response.status}`, 'red');
// 添加失败状态指示器
const currentQuestionNum = getCurrentQuestionNumber();
addQuestionStatusIndicator(currentQuestionNum, 'failed', {
question: questionText,
answer: '题库API请求失败',
selectedOptions: '无',
type: `HTTP错误${response.status}`
});
// 启动备用方案
zhsHandleAPIFailure(questionText, questionType, optionList);
}
} catch (e) {
logger(`解析题库API响应失败: ${e.message}`, 'red');
// 启动备用方案
zhsHandleAPIFailure(questionText, questionType, optionList);
}
},
onerror: function () {
logger('题库API请求网络错误', 'red');
// 启动备用方案
zhsHandleAPIFailure(questionText, questionType, optionList);
},
ontimeout: function () {
logger('题库API请求超时（30秒）', 'red');
// 添加失败状态指示器
const currentQuestionNum = getCurrentQuestionNumber();
addQuestionStatusIndicator(currentQuestionNum, 'failed', {
question: questionText,
answer: '题库API超时',
selectedOptions: '无',
type: '网络超时'
});
// 启动备用方案
zhsHandleAPIFailure(questionText, questionType, optionList);
}
});
} catch (e) {
logger(`题库API调用异常: ${e.message}`, 'red');
// 启动备用方案
zhsHandleAPIFailure(questionText, questionType, optionList);
}
}
function zhsHandleAPIFailure(questionText, questionType, optionList) {
return new Promise((resolve, reject) => {
logger('启动答题备用方案...', 'orange');
// 调试：检查当前配置状态
const useAI = localStorage.getItem('GPTJsSetting.useAI');
// 随机答题功能已删除
logger(`当前配置状态: AI答题=${useAI}`, 'blue');
if (localStorage.getItem('GPTJsSetting.useAI') === 'true') {
logger('已开启AI答题功能，准备获取AI答案...', '#1890ff');
// 题型映射
var typeMapping = {
0: '单选题',
1: '单选题',
2: '多选题',
3: '填空题',
4: '问答题',
14: '判断题'
};
var typeName = typeMapping[questionType] || '单选题';
// 设置AI答题超时保护
var aiTimeout = setTimeout(() => {
logger('❌ AI答题系统响应超时', 'red');
logger('💡 提示: 请检查网络连接或AI服务状态', 'blue');
}, 30000); // 30秒超时
// 为AI构建完整的题目信息（题型+题目+选项）- 修复AI没有收到选项信息的问题
let aiQuestionText = '';
if (typeName) {
aiQuestionText += typeName + ': ';
}
aiQuestionText += questionText;
// 添加选项信息
if (optionList && optionList.length > 0) {
aiQuestionText += '\n选项：\n';
optionList.forEach((option, index) => {
const optionLabel = String.fromCharCode(65 + index); // A, B, C, D
// 修复选项信息传递问题 - 确保提取实际的选项文本
const optionText = option.content ? option.content.replace(/<[^>]*>/g, '').trim() :
option.text ? option.text.trim() :
(typeof option === 'string' ? option : String(option));
aiQuestionText += `${optionLabel}. ${optionText}\n`;
});
}
logger(`🤖 发送给AI的完整题目信息: ${aiQuestionText.substring(0, 200)}...`, 'blue');
logger(`🤖 题型: ${typeName}`, 'blue');
logger(`🤖 选项数量: ${optionList ? optionList.length : 0}`, 'blue');
if (optionList && optionList.length > 0) {
logger(`🤖 选项详情: ${JSON.stringify(optionList.slice(0, 2))}`, 'blue');
}
zhsGetAIAnswer(aiQuestionText, typeName)
.then(aiAnswer => {
clearTimeout(aiTimeout);
logger('AI成功回答，继续处理...', 'green');
const success = zhsProcessAnswer(aiAnswer, questionType, optionList);
if (success) {
logger('✅ AI答题成功，准备自动下一题', 'green');
// 只在答题成功后添加状态指示器
const currentQuestionNum = getCurrentQuestionNumber();
addQuestionStatusIndicator(currentQuestionNum, 'success', {
question: questionText,
answer: aiAnswer,
selectedOptions: aiAnswer,
type: 'AI答题'
});
// 设置导航标记并立即尝试导航
setting.shouldNavigateNext = true;
setTimeout(() => {
zhsContinueToNextQuestion();
}, 1500);
}
})
.catch(error => {
clearTimeout(aiTimeout);
logger('❌ AI回答失败: ' + error, 'red');
logger('💡 提示: 请检查AI配置或网络连接', 'blue');
// AI失败后不再使用随机答题，直接报错
const currentQuestionNum = getCurrentQuestionNumber();
addQuestionStatusIndicator(currentQuestionNum, 'failed', {
question: questionText,
answer: 'AI答题失败',
selectedOptions: '无',
type: 'AI答题失败'
});
});
} else {
// AI答题功能未开启
logger('❌ AI答题功能未开启，无法获取答案', 'red');
logger('💡 提示: 请在设置中开启AI答题功能', 'blue');
}
});
}
// 随机答题功能已删除 - 根据用户要求完全删除随机答题功能
function zhsHandleAPIFailureForOriginal(questionData) {
logger('启动原始答题系统备用方案...', 'orange');
// 第一备用方案：AI答题
if (localStorage.getItem('GPTJsSetting.useAI') === 'true') {
logger('已开启AI答题功能，准备获取AI答案...', '#1890ff');
// 题型映射
var typeMapping = {
0: '单选题',
1: '单选题',
2: '多选题',
3: '填空题',
4: '问答题',
14: '判断题'
};
var typeName = typeMapping[questionData.type] || '单选题';
// 设置AI答题超时保护
var aiTimeout = setTimeout(() => {
logger('AI答题系统响应超时，跳过当前题目', 'red');
logger('⚠️ 答案选择失败，不自动跳题，请手动处理', 'orange');
}, 30000); // 30秒超时
// 为AI构建完整的题目信息（题型+题目+选项）- 修复AI没有收到选项信息的问题
let aiQuestionText = '';
if (typeName) {
aiQuestionText += typeName + ': ';
}
aiQuestionText += questionData.question;
// 添加选项信息
if (questionData.options && questionData.options.length > 0) {
aiQuestionText += '\n选项：\n';
questionData.options.forEach((option, index) => {
const optionLabel = String.fromCharCode(65 + index); // A, B, C, D
// 修复选项信息传递问题 - 确保提取实际的选项文本
const optionText = option.content ? option.content.replace(/<[^>]*>/g, '').trim() :
option.text ? option.text.trim() :
(typeof option === 'string' ? option : String(option));
aiQuestionText += `${optionLabel}. ${optionText}\n`;
});
}
logger(`🤖 发送给AI的完整题目信息: ${aiQuestionText.substring(0, 200)}...`, 'blue');
zhsGetAIAnswer(aiQuestionText, typeName)
.then(aiAnswer => {
clearTimeout(aiTimeout);
logger('AI成功回答，继续处理...', 'green');
selectZhihuishuOption(questionData, aiAnswer);
})
.catch(error => {
clearTimeout(aiTimeout);
logger('AI回答失败: ' + error, 'red');
// AI失败，跳过当前题目
logger('⚠️ 答案选择失败，不自动跳题，请手动处理', 'orange');
});
} else {
// AI答题功能未开启，跳过当前题目
logger('⚠️ AI答题功能未开启，答案选择失败，不自动跳题，请手动处理', 'orange');
}
}
// 随机答题功能已删除 - 根据用户要求完全删除随机选择功能
function zhsGetAIAnswer(question, typeName) {
return new Promise((resolve, reject) => {
if (!question || question.trim() === '') {
reject('问题不能为空');
return;
}
// 获取选择的模型
const model = localStorage.getItem('GPTJsSetting.model') || 'gpt-3.5-turbo-16k';
// 获取用户配置的 key
let userKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || '';
// 检查key是否为空
if (!userKey) {
reject('Key不存在，请前往蜜雪激活');
return;
}
// 处理题目内容
let processedQuestion = question;
// 根据题型构建提示词 - 修复AI答题系统提示词问题
let systemPrompt = "你是一个专业的答题助手。";
if (typeName) {
systemPrompt += `这是一道${typeName}，请给出准确答案。`;
// 根据题型调整提示词
if (typeName.includes("单选题")) {
systemPrompt += "请直接给出正确选项的完整内容，不要返回选项字母（如A/B/C/D）。如果题目包含选项，请从给出的选项中选择正确答案。";
} else if (typeName.includes("多选题")) {
systemPrompt += "请直接给出所有正确选项的完整内容，用###分隔，不要返回选项字母。如果题目包含选项，请从给出的选项中选择正确答案。";
} else if (typeName.includes("判断题")) {
systemPrompt += "请直接回答'正确'或'错误'。";
} else if (typeName.includes("填空题")) {
systemPrompt += "请直接给出填空内容，无需额外说明。";
}
}
// 添加调试信息
// logger(`🤖 AI答题调试信息:`, 'blue');
// logger(` - 题型: ${typeName}`, 'blue');
// logger(` - 题目长度: ${processedQuestion.length}`, 'blue');
// logger(` - SystemPrompt: ${systemPrompt}`, 'blue');
// 设置超时时间
let requestTimedOut = false;
const timeoutId = setTimeout(() => {
requestTimedOut = true;
reject('请求超时，未收到响应');
}, 130000); // 130秒超时
try {
const API_BASE_URL = (() => {
const baseUrl = "tk.mixuelo.cc/api.php";
const protocol = window.location.protocol;
if (protocol === 'https:') {
return "https://" + baseUrl;
} else {
return "http://" + baseUrl;
}
})();
GM_xmlhttpRequest({
method: 'POST',
url: API_BASE_URL + '?act=aimodel',
headers: {
'Accept': 'application/json',
'Authorization': 'Bearer ' + userKey,
'Content-Type': 'application/x-www-form-urlencoded'
},
data: `key=${encodeURIComponent(userKey)}&model=${encodeURIComponent(model)}&question=${encodeURIComponent(processedQuestion)}&system=${encodeURIComponent(systemPrompt)}`,
timeout: 120000, // 120秒超时
onload: function (response) {
clearTimeout(timeoutId);
if (requestTimedOut) return;
try {
if (!response.responseText) {
resolve("");
return;
}
const result = JSON.parse(response.responseText);
if (response.status === 200) {
// 检查是否有错误信息
if (result.code === 1001) {
resolve("");
return;
}
// 处理成功响应
if (result.code === 1 && result.data) {
resolve(result.data);
} else {
resolve("");
}
} else {
resolve("");
}
} catch (e) {
resolve("");
}
},
onerror: function () {
clearTimeout(timeoutId);
if (requestTimedOut) return;
resolve("");
},
ontimeout: function () {
clearTimeout(timeoutId);
resolve("");
}
});
} catch (e) {
clearTimeout(timeoutId);
resolve("");
}
});
}
// 随机答案生成功能已删除 - 根据用户要求完全删除随机选择功能
// 处理题库API返回的答案
function zhsProcessAnswer(answer, questionType, optionList) {
try {
if (!optionList || optionList.length === 0) {
logger('没有选项列表，无法处理答案', 'orange');
return;
}
// 检查答案是否有效
if (!answer || typeof answer !== 'string') {
logger('答案无效，启动备用方案', 'orange');
logger('⚠️ 答案选择失败，不自动跳题，请手动处理', 'orange');
return;
}
// 清理答案文本
var cleanAnswer = answer.replace(/<[^>]*>/g, '').trim();
logger(`处理答案: ${cleanAnswer}`, 'blue');
// 处理"###"分隔的多个答案（用户示例格式）
var answerParts = cleanAnswer.split('###').map(part => part.trim()).filter(part => part.length > 0);
logger(`📝 答案分割结果: ${JSON.stringify(answerParts)} (共${answerParts.length}个答案)`, 'blue');
// 查找匹配的选项
var matchedOptions = [];
optionList.forEach(function (option, index) {
var optionText = option.content.replace(/<[^>]*>/g, '').trim();
var optionLabel = String.fromCharCode(65 + index); // A, B, C, D...
// 检查是否匹配任何一个答案部分
var isMatched = false;
for (var i = 0; i < answerParts.length; i++) {
var answerPart = answerParts[i];
// 多种匹配方式
if (answerPart.includes(optionText) ||
optionText.includes(answerPart) ||
answerPart.includes(optionLabel) ||
answerPart === optionText) {
isMatched = true;
break;
}
}
if (isMatched) {
matchedOptions.push({
index: index,
option: option,
label: optionLabel
});
logger(`✅ 找到匹配选项 ${optionLabel}: ${optionText}`, 'green');
}
});
// 执行选择
if (matchedOptions.length > 0) {
var successCount = 0;
matchedOptions.forEach(function (match) {
var success = zhsSelectOption(match.index, match.option);
if (success) {
successCount++;
}
});
if (successCount > 0) {
logger(`🎯 成功选择 ${successCount}/${matchedOptions.length} 个选项`, 'green');
logger(`📊 答题结果: 已选择选项 ${matchedOptions.map(m => m.label).join(', ')}`, 'blue');
// 只有在成功选择选项后才自动进行下一题
setTimeout(() => {
zhsContinueToNextQuestion();
}, 1500);
} else {
logger('❌ 选项选择失败，不自动跳题', 'red');
}
} else {
logger('❌ 未找到匹配的选项，启动备用方案', 'orange');
logger(`💡 提示: 答案"${cleanAnswer}"与选项不匹配`, 'blue');
// 随机选择功能已删除，跳过当前题目
logger('⚠️ 答案选择失败，不自动跳题，请手动处理', 'orange');
}
} catch (e) {
logger(`处理答案时出错: ${e.message}`, 'red');
// 随机选择功能已删除，跳过当前题目
logger('⚠️ 答案选择失败，不自动跳题，请手动处理', 'orange');
}
}
function zhsSelectOption(index, option, autoNext = false) {
try {
logger(`尝试选择选项 ${String.fromCharCode(65 + index)}: ${option.content ? option.content.replace(/<[^>]*>/g, '').trim() : option}`, 'blue');
// 多种选择器尝试，基于智慧树平台的实际结构
var selectors = [
'.TitleOptions-div input',
'.optionUl input',
'.el-radio input',
'.el-checkbox input',
'input[type="radio"]',
'input[type="checkbox"]',
'.option-item input',
'.question-option input'
];
var $input = null;
var $container = null;
// 尝试找到对应的输入元素
for (var i = 0; i < selectors.length; i++) {
var elements = document.querySelectorAll(selectors[i]);
if (elements && elements[index]) {
$input = elements[index];
$container = $input.closest('.TitleOptions-div, .optionUl, .el-radio, .el-checkbox, .option-item, .question-option');
logger(`使用选择器 ${selectors[i]} 找到选项`, 'green');
break;
}
}
if ($input) {
var clickSuccess = false;
try {
// 方法1: 直接点击输入元素
$input.click();
$input.checked = true;
logger(`成功点击选项 ${String.fromCharCode(65 + index)}`, 'green');
clickSuccess = true;
} catch (e) {
logger(`直接点击失败: ${e.message}`, 'orange');
}
if (!clickSuccess && $container) {
try {
// 方法2: 点击容器元素
$container.click();
logger(`点击容器成功选择选项 ${String.fromCharCode(65 + index)}`, 'green');
clickSuccess = true;
} catch (e) {
logger(`点击容器失败: ${e.message}`, 'orange');
}
}
if (!clickSuccess && $) {
try {
// 方法3: 使用jQuery
$($input).prop('checked', true).trigger('click').trigger('change');
if ($container) {
$($container).trigger('click');
}
logger(`使用jQuery选择选项 ${String.fromCharCode(65 + index)}`, 'green');
clickSuccess = true;
} catch (e) {
logger(`jQuery点击失败: ${e.message}`, 'orange');
}
}
if (!clickSuccess) {
try {
// 方法4: 事件模拟
var clickEvent = new MouseEvent('click', {
bubbles: true,
cancelable: true,
view: window
});
$input.dispatchEvent(clickEvent);
var changeEvent = new Event('change', { bubbles: true });
$input.dispatchEvent(changeEvent);
logger(`使用事件模拟选择选项 ${String.fromCharCode(65 + index)}`, 'green');
clickSuccess = true;
} catch (e) {
logger(`事件模拟失败: ${e.message}`, 'red');
}
}
// 添加到队列
if (setting.queue) {
setting.queue.push($input);
}
// 只有在autoNext为true时才自动跳转
if (autoNext && clickSuccess) {
setTimeout(() => {
zhsContinueToNextQuestion();
}, 1500);
}
return clickSuccess;
} else {
logger(`未找到选项 ${String.fromCharCode(65 + index)} 的输入元素`, 'orange');
return false;
}
} catch (e) {
logger(`选择选项时出错: ${e.message}`, 'red');
return false;
}
}
function zhsContinueToNextQuestion() {
try {
// 首先检查答题状态 - 只有在答题开启时才自动导航
const isAutoAnswerEnabled = localStorage.getItem('GPTJsSetting.work') === 'true';
if (!isAutoAnswerEnabled) {
logger(`🛑 自动答题已关闭，停止自动导航到下一题`, 'orange');
return false;
}
// 使用统一的导航标记机制，而不是直接导航
logger('设置导航标记，等待定时器处理', 'blue');
setting.shouldNavigateNext = true;
return true;
} catch (e) {
logger(`继续下一题时出错: ${e.message}`, 'red');
}
}
// 随机选择功能已删除 - 根据用户要求完全删除随机选择功能
// 创建浮动按钮
function createZhsFloatingButton() {
// 防止重复创建
if (document.getElementById('zhs-floating-button')) return;
const currentKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || '';
const isConfigured = !!currentKey;
const button = document.createElement('div');
button.id = 'zhs-floating-button';
button.className = 'zhs-floating-button';
button.innerHTML = '⚙️';
button.title = isConfigured ? 'API Key已配置 - 点击打开设置' : '请配置API Key - 点击打开设置';
// 添加状态指示器
const indicator = document.createElement('div');
indicator.className = `zhs-status-indicator ${isConfigured ? 'configured' : 'not-configured'}`;
indicator.innerHTML = isConfigured ? '✓' : '!';
button.appendChild(indicator);
// 点击事件
button.addEventListener('click', function () {
const panel = document.getElementById('zhs-config-panel');
if (panel) {
panel.remove();
} else {
createZhsConfigPanel();
}
});
document.body.appendChild(button);
}
// 更新浮动按钮状态
function updateZhsFloatingButton() {
const button = document.getElementById('zhs-floating-button');
const indicator = button ? button.querySelector('.zhs-status-indicator') : null;
if (button && indicator) {
const currentKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || '';
const isConfigured = !!currentKey;
button.title = isConfigured ? 'API Key已配置 - 点击打开设置' : '请配置API Key - 点击打开设置';
indicator.className = `zhs-status-indicator ${isConfigured ? 'configured' : 'not-configured'}`;
indicator.innerHTML = isConfigured ? '✓' : '!';
}
}
// 初始化智慧树配置系统
function initZhsConfigSystem() {
// 强制重新初始化 - 确保新配置生效
window.zhsConfigInitialized = true;
logger('初始化智慧树配置系统', 'blue');
// 检查API Key配置状态
const currentKey = localStorage.getItem('GPTJsSetting.key') || localStorage.getItem('tiku_key') || '';
if (currentKey) {
logger('检测到已配置的API Key: ' + currentKey.substring(0, 8) + '...', 'green');
} else {
logger('未检测到API Key配置，请配置后使用', 'orange');
}
// 初始化答题配置系统 - 修改默认配置：不开启题库答题，默认GPT-3.5-Turbo模型
// 只在首次初始化时设置默认值，保持用户的配置选择
const settingDefaults = {
'GPTJsSetting.useTiku': 'false', // 题库答题默认关闭
'GPTJsSetting.useBackupTiku': 'false', // 备用题库默认关闭
'GPTJsSetting.useAI': 'true', // AI答题默认开启
// 随机答题功能已删除
'GPTJsSetting.autoSubmit': 'false', // 自动提交默认关闭
'GPTJsSetting.showAnswer': 'true', // 显示答案默认开启
'GPTJsSetting.model': 'gpt-3.5-turbo-16k' // 默认GPT-3.5-Turbo模型
};
// 只在配置不存在时设置默认值，保持用户配置
Object.keys(settingDefaults).forEach(key => {
if (localStorage.getItem(key) === null) {
localStorage.setItem(key, settingDefaults[key]);
}
});
// 强制确保AI答题功能开启 - 修复用户配置中AI答题被关闭的问题
if (localStorage.getItem('GPTJsSetting.useAI') !== 'true') {
logger('检测到AI答题功能被禁用，强制启用AI答题功能', 'orange');
localStorage.setItem('GPTJsSetting.useAI', 'true');
}
// 删除强制启用题库API的逻辑，尊重用户配置
// 注释掉原来的强制启用逻辑
// if (localStorage.getItem('GPTJsSetting.useTiku') !== 'true') {
// logger('检测到题库API被禁用，强制启用题库API', 'orange');
// localStorage.setItem('GPTJsSetting.useTiku', 'true');
// }
// 强制默认开启自动答题功能 - 修复用户反馈的默认不答题问题
localStorage.setItem('GPTJsSetting.work', 'true');
localStorage.setItem('ZhsJsSetting.work', 'true');
setting.work = true;
logger('🚀 强制开启自动答题功能（默认行为）', 'green');
// 立即启动答题流程
setTimeout(() => {
if (checkZhsAnswerPage()) {
logger('🎯 检测到答题页面，立即启动自动答题', 'green');
zhsProcessQuestions();
}
}, 2000);
// 初始化设置项的UI状态
setTimeout(() => {
Object.keys(settingDefaults).forEach(key => {
const element = document.getElementById(key);
if (element) {
if (element.type === 'checkbox') {
element.checked = localStorage.getItem(key) === 'true';
element.addEventListener('change', () => {
localStorage.setItem(key, element.checked.toString());
});
} else if (element.tagName === 'SELECT') {
element.value = localStorage.getItem(key) || settingDefaults[key];
element.addEventListener('change', () => {
localStorage.setItem(key, element.value);
});
}
}
});
// 特别处理AI助手面板的模型选择
const aiModelSelect = document.getElementById('zhs-ai-model');
if (aiModelSelect) {
const savedModel = localStorage.getItem('GPTJsSetting.model') || 'DeepSeek-Chat';
aiModelSelect.value = savedModel;
aiModelSelect.addEventListener('change', (e) => {
const selectedModel = e.target.value;
localStorage.setItem('GPTJsSetting.model', selectedModel);
logger(`AI模型已切换为: ${selectedModel}`, 'blue');
});
logger(`AI助手模型选择已初始化: ${savedModel}`, 'green');
}
}, 1000);
// 移除重复的配置设置，避免覆盖用户配置
// 所有默认配置已在上面的settingDefaults中统一处理
logger('配置初始化完成，答题功能状态: ' + (setting.work ? '开启' : '关闭'), 'green');
// 显示答题优先级配置状态 - 实时检查
const workStatus = localStorage.getItem('GPTJsSetting.work') === 'true';
const useAI = localStorage.getItem('GPTJsSetting.useAI') === 'true';
const useTiku = localStorage.getItem('GPTJsSetting.useTiku') === 'true';
// 随机答题功能已删除
logger('✅ 完整配置状态检查:', 'blue');
logger(' - 自动答题功能: ' + workStatus, workStatus ? 'green' : 'red');
logger(' - 题库API: ' + useTiku, useTiku ? 'green' : 'red');
logger(' - AI答题: ' + useAI, useAI ? 'green' : 'red');
// 随机答题功能已删除
setting.none = 0;
setTimeout(() => {
const isAnswerPage = checkZhsAnswerPage();
if (isAnswerPage) {
logger('检测到智慧树答题页面，自动启动答题功能', 'blue');
// 自动启动答题，不需要手动点击按钮
setTimeout(() => {
zhsProcessQuestions();
}, 1000);
}
}, 2000);
if (!currentKey) {
setTimeout(() => {
logger('💡 提示：按F9或点击右下角设置按钮配置API Key', 'blue');
setTimeout(() => {
logger('⚠️ 重要：当前未配置API Key，无法进行自动答题！', 'red');
logger('🔧 配置方法：按F9键打开配置面板，输入API Key', 'orange');
setTimeout(() => {
const stillNoKey = !localStorage.getItem('GPTJsSetting.key') && !localStorage.getItem('tiku_key');
if (stillNoKey) {
logger('🚨 请使用新的控制面板配置API Key以获取正确答案', 'red');
logger('💡 按F9键打开控制面板进行配置', 'blue');
// createZhsConfigPanel(); // 已被新控制面板替代
}
}, 5000);
}, 3000);
}, 2000);
}
}