湖北省专业技术人员继续教育网络平台刷课脚本分享

(function() {
    'use strict';
    
    const PLATFORM = '湖北省专业技术人员继续教育网络平台';
    const VERSION = '2.8.0';
    const PREFIX = `[${PLATFORM}]`;
    
    console.log(`${PREFIX} 脚本 v${VERSION} 已加载`);
    
    const Config = {
        autoPlay: true,
        playbackRate: 2.0,
        autoNext: true,
        autoQuiz: true,
        preventTimeout: true,
        simulateActivity: true,
        checkInterval: 1800,
        activityInterval: 50000
    };
    
    const Utils = {
        log: function(...args) {
            console.log(PREFIX, ...args);
        },
        error: function(...args) {
            console.error(PREFIX, ...args);
        },
        warn: function(...args) {
            console.warn(PREFIX, ...args);
        },
        randomNum: function(min, max) {
            return Math.floor(Math.random() * (max - min + 1)) + min;
        },
        wait: function(ms) {
            return new Promise(resolve => setTimeout(resolve, ms));
        }
    };
    
    function initAntiCheatSystem() {
        Utils.log('正在初始化反作弊系统...');
        
        const originalAddEventListener = EventTarget.prototype.addEventListener;
        
        EventTarget.prototype.addEventListener = function(eventType, listener, options) {
            const forbiddenEvents = [
                'visibilitychange', 'pagehide', 'blur', 'focusout', 
                'mouseleave', 'mouseout'
            ];
            
            if (forbiddenEvents.includes(eventType)) {
                Utils.log(`成功拦截 ${eventType} 事件`);
                return function() {};
            }
            
            return originalAddEventListener.call(this, eventType, listener, options);
        };
        
        const hiddenProp = Object.getOwnPropertyDescriptor(Document.prototype, 'hidden');
        if (hiddenProp && hiddenProp.configurable) {
            Object.defineProperty(document, 'hidden', {
                get: () => false,
                configurable: false,
                enumerable: true
            });
        }
        
        const visibilityProp = Object.getOwnPropertyDescriptor(Document.prototype, 'visibilityState');
        if (visibilityProp && visibilityProp.configurable) {
            Object.defineProperty(document, 'visibilityState', {
                get: () => 'visible',
                configurable: false,
                enumerable: true
            });
        }
        
        Object.defineProperty(document, 'webkitHidden', {
            get: () => false,
            configurable: false,
            enumerable: true
        });
        
        Object.defineProperty(document, 'webkitVisibilityState', {
            get: () => 'visible',
            configurable: false,
            enumerable: true
        });
        
        window.onblur = null;
        window.onfocusout = null;
        
        document.addEventListener('visibilitychange', function(e) {
            e.stopImmediatePropagation();
            e.preventDefault();
            return false;
        }, true);
        
        Utils.log('反作弊系统初始化完成');
    }
    
    function locateVideoElement() {
        const videoSelectors = [
            'video',
            'video[src]',
            '.video-player video',
            '.course-video video',
            '#videoPlayer video',
            '.media-player video',
            '[id*="video"] video',
            '[class*="video"] video'
        ];
        
        for (const selector of videoSelectors) {
            const video = document.querySelector(selector);
            if (video) {
                return video;
            }
        }
        
        const iframes = document.querySelectorAll('iframe');
        for (const iframe of iframes) {
            try {
                const iframeDocument = iframe.contentDocument || iframe.contentWindow.document;
                const video = iframeDocument.querySelector('video');
                if (video) {
                    return video;
                }
            } catch (error) {
                continue;
            }
        }
        
        return null;
    }
    
    function setupVideoPlayer(video) {
        if (!video) {
            return;
        }
        
        Utils.log('正在配置视频播放器...');
        
        video.muted = false;
        video.volume = 1;
        
        if (Config.playbackRate > 1) {
            Object.defineProperty(video, 'playbackRate', {
                configurable: true,
                enumerable: true,
                get: function() {
                    return Config.playbackRate;
                },
                set: function(value) {
                    Utils.log(`检测到尝试设置播放速度为 ${value}x，已强制保持为 ${Config.playbackRate}x`);
                }
            });
        }
        
        video.addEventListener('pause', function(event) {
            if (Config.autoPlay && !video.ended) {
                Utils.log('视频被暂停，正在尝试恢复播放...');
                setTimeout(function() {
                    video.play().catch(function(error) {
                        Utils.error('自动播放失败:', error);
                    });
                }, 150);
            }
        });
        
        video.addEventListener('ended', function() {
            Utils.log('视频播放已结束');
            if (Config.autoNext) {
                Utils.log('准备自动切换到下一课');
                navigateToNextLesson();
            }
        });
        
        video.addEventListener('waiting', function() {
            Utils.log('视频正在缓冲中...');
        });
        
        video.addEventListener('error', function(event) {
            Utils.error('视频加载出错:', event);
        });
        
        if (Config.autoPlay && video.paused) {
            video.play().catch(function(error) {
                Utils.warn('初始自动播放失败:', error);
            });
        }
        
        Utils.log('视频播放器配置完成');
    }
    
    function navigateToNextLesson() {
        Utils.log('正在查找下一课按钮...');
        
        const nextButtonSelectors = [
            '.next-lesson',
            '.next-chapter',
            '.next-course',
            '#nextLesson',
            '#nextChapter',
            '[class*="next"]',
            '[id*="next"]',
            'button:has(span:contains("下一课"))',
            'button:has(span:contains("下一章"))',
            'a:has(span:contains("下一节"))'
        ];
        
        for (const selector of nextButtonSelectors) {
            const button = document.querySelector(selector);
            if (button && !button.disabled && button.offsetParent !== null) {
                Utils.log('找到下一课按钮，正在点击...');
                button.click();
                return;
            }
        }
        
        const lessonItems = document.querySelectorAll('.lesson-item, .chapter-item, .course-item, .video-item');
        for (let i = 0; i < lessonItems.length; i++) {
            const item = lessonItems[i];
            if (item.classList.contains('active') || 
                item.classList.contains('current') || 
                item.classList.contains('playing') ||
                item.classList.contains('selected')) {
                if (i + 1 < lessonItems.length) {
                    Utils.log('在课程列表中找到下一课');
                    lessonItems[i + 1].click();
                    return;
                }
            }
        }
        
        Utils.log('未找到下一课');
    }
    
    function autoCompleteQuiz() {
        if (!Config.autoQuiz) {
            return;
        }
        
        setInterval(function() {
            const quizContainer = document.querySelector(
                '.quiz-container, .test-container, .exam-container, .question-container, .exercise-container'
            );
            
            if (!quizContainer) {
                return;
            }
            
            const options = quizContainer.querySelectorAll(
                'input[type="radio"], input[type="checkbox"], .option, .choice, .answer-option'
            );
            
            if (options.length > 0) {
                Utils.log('检测到测验题目，正在自动作答...');
                
                const randomIndex = Utils.randomNum(0, options.length - 1);
                const selectedOption = options[randomIndex];
                
                if (selectedOption.tagName === 'INPUT') {
                    selectedOption.checked = true;
                } else {
                    selectedOption.click();
                }
                
                const submitButton = quizContainer.querySelector(
                    'button[type="submit"], .submit-btn, .confirm-btn, .finish-btn, [class*="submit"]'
                );
                
                if (submitButton) {
                    setTimeout(function() {
                        submitButton.click();
                        Utils.log('答案已提交');
                    }, 600);
                }
            }
        }, 2000);
    }
    
    function simulateUserActivity() {
        if (!Config.simulateActivity) {
            return;
        }
        
        const activities = [
            function() {
                const scrollAmount = Utils.randomNum(-25, 25);
                window.scrollBy(0, scrollAmount);
            },
            function() {
                const x = Utils.randomNum(0, window.innerWidth);
                const y = Utils.randomNum(0, window.innerHeight);
                const mouseMoveEvent = new MouseEvent('mousemove', {
                    clientX: x,
                    clientY: y,
                    bubbles: true,
                    cancelable: true
                });
                document.dispatchEvent(mouseMoveEvent);
            },
            function() {
                const keyDownEvent = new KeyboardEvent('keydown', {
                    key: 'Control',
                    bubbles: true,
                    cancelable: true
                });
                document.dispatchEvent(keyDownEvent);
            },
            function() {
                const x = Utils.randomNum(50, window.innerWidth - 50);
                const y = Utils.randomNum(50, window.innerHeight - 50);
                const clickEvent = new MouseEvent('click', {
                    clientX: x,
                    clientY: y,
                    bubbles: true,
                    cancelable: true
                });
                const targetElement = document.elementFromPoint(x, y);
                if (targetElement && !targetElement.closest('button') && !targetElement.closest('a')) {
                    targetElement.dispatchEvent(clickEvent);
                }
            },
            function() {
                window.dispatchEvent(new Event('resize'));
            }
        ];
        
        setInterval(function() {
            const activityIndex = Utils.randomNum(0, activities.length - 1);
            activities[activityIndex]();
            Utils.log('模拟用户活动');
        }, Config.activityInterval);
    }
    
    function preventTimeoutDetection() {
        if (!Config.preventTimeout) {
            return;
        }
        
        setInterval(function() {
            const timeoutWarning = document.querySelector(
                '.timeout-warning, .inactivity-warning, .idle-warning, [class*="timeout"], [class*="inactive"], [class*="idle"]'
            );
            
            if (timeoutWarning) {
                Utils.log('检测到超时警告，正在尝试解除...');
                const stayButton = timeoutWarning.querySelector('button, a');
                if (stayButton) {
                    stayButton.click();
                }
            }
            
            const video = locateVideoElement();
            if (video && video.paused && !video.ended) {
                video.play().catch(function() {});
            }
        }, 4000);
    }
    
    function monitorVideoElements() {
        setInterval(function() {
            const video = locateVideoElement();
            if (video) {
                setupVideoPlayer(video);
            }
        }, Config.checkInterval);
    }
    
    function initializeScript() {
        Utils.log('正在初始化脚本...');
        
        initAntiCheatSystem();
        monitorVideoElements();
        autoCompleteQuiz();
        simulateUserActivity();
        preventTimeoutDetection();
        
        Utils.log('脚本初始化完成！');
    }
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', initializeScript);
    } else {
        initializeScript();
    }
})();