// ==UserScript==

// @name Linuxdo活跃

// @namespace http://tampermonkey.net/

// @version 2.0.0

// @description Linuxdo小助手（可控制开关）

// @author Cressida

// @match https://linux.do/*

// @grant GM_setValue

// @grant GM_getValue

// @run-at document-idle

// ==/UserScript==

(function () {

'use strict';

// ==================== 常量定义 ====================

/** 默认配置参数 */

const DEFAULT_CONFIG = {

scrollInterval: 300, // 滚动间隔(毫秒)

scrollStep: 880, // 每次滚动的像素

waitForElement: 2000, // 找不到评论的最大等待时间(毫秒)

waitingTime: 1000 // 看完评论等待时间(毫秒)

};

/** 速度滑块配置 */

const SPEED_SLIDER_CONFIG = {

min: 0.1,

max: 5.0,

step: 0.1,

default: 1.0

};

/** 元素选择器配置 */

const SELECTORS = {

chatButton: 'li.chat-header-icon',

chatLink: 'a[href="/chat"]',

headerButtons: '.header-buttons',

headerIcons: '.d-header-icons',

headerDropdown: 'ul.header-dropdown-toggle',

header: 'header.d-header',

commentList: 'html.desktop-view.not-mobile-device.text-size-normal.no-touch.discourse-no-touch',

rawLinks: '.raw-link'

};

/** 存储键名 */

const STORAGE_KEYS = {

enabled: 'linuxdoHelperEnabled',

baseConfig: 'linuxdoHelperBaseConfig',

speedRatio: 'linuxdoHelperSpeedRatio',

visitedLinks: 'visitedLinks'

};

/** 页面URL */

const URLS = {

newPosts: 'https://linux.do/new'

};

/** 元素等待超时时间（毫秒） */

const ELEMENT_WAIT_TIMEOUT = 2000;

// ==================== 配置管理 ====================

/** 基础配置（用于速度比例计算） */

let baseConfig = null;

/**

* 获取基础配置（从存储中读取，如果没有则使用默认值）

* @returns {Object} 基础配置对象

*/

function getBaseConfig() {

const savedConfig = GM_getValue(STORAGE_KEYS.baseConfig, null);

return savedConfig ? savedConfig : { ...DEFAULT_CONFIG };

}

/**

* 保存基础配置

* @param {Object} newConfig - 新的基础配置

*/

function saveBaseConfig(newConfig) {

GM_setValue(STORAGE_KEYS.baseConfig, newConfig);

baseConfig = newConfig;

}

/**

* 获取速度比例

* @returns {number} 速度比例（0.1 - 5.0）

*/

function getSpeedRatio() {

return GM_getValue(STORAGE_KEYS.speedRatio, SPEED_SLIDER_CONFIG.default);

}

/**

* 保存速度比例

* @param {number} ratio - 速度比例

*/

function saveSpeedRatio(ratio) {

GM_setValue(STORAGE_KEYS.speedRatio, ratio);

}

/**

* 获取实际使用的配置（基础配置 × 速度比例）

* @returns {Object} 计算后的配置对象

*/

function getConfig() {

if (!baseConfig) {

baseConfig = getBaseConfig();

}

const ratio = getSpeedRatio();

return {

scrollInterval: Math.round(baseConfig.scrollInterval / ratio),

scrollStep: Math.round(baseConfig.scrollStep * ratio),

waitForElement: Math.round(baseConfig.waitForElement / ratio),

waitingTime: Math.round(baseConfig.waitingTime / ratio)

};

}

// 初始化基础配置

baseConfig = getBaseConfig();

// ==================== 开关状态管理 ====================

/**

* 获取助手开关状态

* @returns {boolean} 是否启用

*/

function getSwitchState() {

return GM_getValue(STORAGE_KEYS.enabled, false);

}

/**

* 切换助手开关状态

*/

function toggleSwitch() {

const currentState = getSwitchState();

const newState = !currentState;

GM_setValue(STORAGE_KEYS.enabled, newState);

if (newState) {

// 启用时跳转到新帖子页面

window.location.href = URLS.newPosts;

}

console.log(`Linuxdo助手已${newState ? '启用' : '禁用'}`);

}

// ==================== UI 组件创建 ====================

/**

* 创建SVG图标元素

* @param {string} iconHref - 图标引用（如 '#play' 或 '#pause'）

* @returns {SVGElement} SVG元素

*/

function createSVGIcon(iconHref) {

const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');

svg.setAttribute('class', 'fa d-icon d-icon-rocket svg-icon prefix-icon svg-string');

svg.setAttribute('xmlns', 'http://www.w3.org/2000/svg');

const use = document.createElementNS('http://www.w3.org/2000/svg', 'use');

use.setAttribute('href', iconHref);

svg.appendChild(use);

return svg;

}

/**

* 创建控制开关按钮

* @returns {HTMLElement} 开关按钮的 li 元素

*/

function createSwitchButton() {

const iconLi = document.createElement('li');

iconLi.className = 'header-dropdown-toggle';

const iconLink = document.createElement('a');

iconLink.href = '#';

iconLink.className = 'btn no-text icon btn-flat';

iconLink.tabIndex = 0;

const isEnabled = getSwitchState();

iconLink.title = isEnabled ? '停止Linuxdo助手' : '启动Linuxdo助手';

const svg = createSVGIcon(isEnabled ? '#pause' : '#play');

iconLink.appendChild(svg);

iconLi.appendChild(iconLink);

// 点击事件处理

iconLink.addEventListener('click', (e) => {

e.preventDefault();

e.stopPropagation();

toggleSwitch();

// 更新按钮状态

const newState = getSwitchState();

const use = svg.querySelector('use');

use.setAttribute('href', newState ? '#pause' : '#play');

iconLink.title = newState ? '停止Linuxdo助手' : '启动Linuxdo助手';

iconLink.classList.toggle('active', newState);

// 更新悬浮滑块显示状态

updateFloatingSliderVisibility();

});

return iconLi;

}

/**

* 查找聊天按钮元素

* @returns {Promise<HTMLElement|null>} 聊天按钮元素或null

*/

async function findChatButton() {

try {

// 尝试等待聊天按钮出现

const chatButton = await Promise.race([

waitForElement(SELECTORS.chatButton),

new Promise((_, reject) =>

setTimeout(() => reject(new Error('timeout')), ELEMENT_WAIT_TIMEOUT)

)

]).catch(() => null);

if (chatButton) {

return chatButton;

}

} catch (e) {

// 等待失败，继续尝试直接查找

}

// 直接查找聊天按钮

return document.querySelector(SELECTORS.chatButton) ||

document.querySelector(SELECTORS.chatLink)?.closest('li');

}

/**

* 查找备用插入位置

* @returns {HTMLElement|null} 备用位置元素或null

*/

function findFallbackInsertPosition() {

return document.querySelector(SELECTORS.headerButtons) ||

document.querySelector(SELECTORS.headerIcons) ||

document.querySelector(SELECTORS.headerDropdown)?.parentElement;

}

/**

* 将开关按钮插入到页面中

* @param {HTMLElement} buttonElement - 开关按钮元素

*/

function insertSwitchButton(buttonElement) {

// 优先插入到聊天按钮旁边

const chatButton = document.querySelector(SELECTORS.chatButton);

if (chatButton?.parentNode) {

chatButton.parentNode.insertBefore(buttonElement, chatButton.nextSibling);

return;

}

// 备用方案：插入到其他header按钮位置

const fallbackPosition = findFallbackInsertPosition();

if (fallbackPosition?.parentNode) {

fallbackPosition.parentNode.insertBefore(buttonElement, fallbackPosition.nextSibling);

return;

}

// 最后方案：插入到header中

const header = document.querySelector(SELECTORS.header) || document.querySelector('header');

if (header) {

const headerList = header.querySelector('ul') || header.querySelector('nav');

if (headerList) {

headerList.appendChild(buttonElement);

} else {

header.insertBefore(buttonElement, header.firstChild);

}

} else {

console.log("【错误】未找到按钮插入位置！");

}

}

/**

* 创建并插入开关图标到页面

*/

async function createSwitchIcon() {

const switchButton = createSwitchButton();

await findChatButton(); // 等待聊天按钮加载

insertSwitchButton(switchButton);

}

/**

* 创建悬浮速度滑块

* @returns {HTMLElement} 滑块容器元素

*/

function createFloatingSpeedSlider() {

// 如果已存在，先移除

const existingSlider = document.getElementById('linuxdo-speed-slider');

if (existingSlider) {

existingSlider.remove();

}

// 创建容器

const container = document.createElement('div');

container.id = 'linuxdo-speed-slider';

container.style.cssText = `

position: fixed;

bottom: 20px;

right: 20px;

background: white;

border-radius: 8px;

padding: 16px;

box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);

z-index: 9999;

min-width: 200px;

display: ${getSwitchState() ? 'block' : 'none'};

`;

// 创建标签

const label = document.createElement('div');

label.textContent = '阅读速度';

label.style.cssText = 'font-size: 14px; color: #333; font-weight: 500; margin-bottom: 10px;';

container.appendChild(label);

// 创建滑块容器

const sliderWrapper = document.createElement('div');

sliderWrapper.style.cssText = 'display: flex; align-items: center; gap: 12px;';

// 创建滑块

const slider = document.createElement('input');

slider.type = 'range';

slider.min = SPEED_SLIDER_CONFIG.min;

slider.max = SPEED_SLIDER_CONFIG.max;

slider.step = SPEED_SLIDER_CONFIG.step;

slider.value = getSpeedRatio();

slider.style.cssText = `

flex: 1;

height: 6px;

border-radius: 3px;

background: #ddd;

outline: none;

cursor: pointer;

`;

// 创建数值显示

const valueDisplay = document.createElement('span');

valueDisplay.textContent = getSpeedRatio().toFixed(1) + 'x';

valueDisplay.style.cssText = 'min-width: 45px; text-align: right; font-size: 14px; color: #666; font-weight: 500;';

// 滑块值变化事件

slider.addEventListener('input', () => {

const ratio = parseFloat(slider.value);

valueDisplay.textContent = ratio.toFixed(1) + 'x';

saveSpeedRatio(ratio);

// 如果正在滚动，立即应用新速度

restartScrolling();

});

// 组装元素

sliderWrapper.appendChild(slider);

sliderWrapper.appendChild(valueDisplay);

container.appendChild(sliderWrapper);

document.body.appendChild(container);

return container;

}

/**

* 更新悬浮滑块的显示状态

*/

function updateFloatingSliderVisibility() {

const slider = document.getElementById('linuxdo-speed-slider');

if (slider) {

slider.style.display = getSwitchState() ? 'block' : 'none';

}

}

// ==================== DOM 工具函数 ====================

/**

* 等待指定元素出现在页面中

* @param {string} selector - CSS选择器

* @returns {Promise<HTMLElement>} 找到的元素

*/

function waitForElement(selector) {

return new Promise((resolve, reject) => {

// 先尝试直接查找

const element = document.querySelector(selector);

if (element) {

resolve(element);

return;

}

// 使用MutationObserver监听DOM变化

const observer = new MutationObserver(() => {

const element = document.querySelector(selector);

if (element) {

observer.disconnect();

resolve(element);

}

});

observer.observe(document.body, {

childList: true,

subtree: true

});

// 超时处理

setTimeout(() => {

observer.disconnect();

console.log("【错误】未找到元素：", selector);

reject(new Error('未找到：' + selector));

}, getConfig().waitForElement);

});

}

/**

* 获取页面中的原始链接列表

* @returns {Array<Object>} 链接对象数组，包含index、href、text

*/

function getRawLinks() {

const linkElements = document.querySelectorAll(SELECTORS.rawLinks);

return Array.from(linkElements)

.map((element, index) => ({

index: index + 1,

href: element.href,

text: element.textContent.trim()

}))

.filter(link => link.href);

}

// ==================== 核心功能 ====================

/** 当前运行的滚动定时器引用 */

let currentScrollInterval = null;

/** 当前评论元素引用 */

let currentCommentElement = null;

/**

* 加载并跳转到新页面

* @param {Array<Object>} links - 可用链接列表

*/

function loadPage(links) {

if (!getSwitchState()) {

return;

}

const visitedLinks = JSON.parse(

localStorage.getItem(STORAGE_KEYS.visitedLinks) || '[]'

);

const unvisitedLinks = links.filter(

link => !visitedLinks.includes(link.href)

);

// 如果没有未访问的链接，跳转到新帖子页面

if (unvisitedLinks.length === 0) {

window.location.href = URLS.newPosts;

console.log("去看最新帖子");

return;

}

// 随机选择一个未访问的链接

const randomIndex = Math.floor(Math.random() * unvisitedLinks.length);

const selectedLink = unvisitedLinks[randomIndex];

// 记录已访问

visitedLinks.push(selectedLink.href);

localStorage.setItem(STORAGE_KEYS.visitedLinks, JSON.stringify(visitedLinks));

// 跳转

window.location.href = selectedLink.href;

}

/**

* 停止当前滚动

*/

function stopScrolling() {

if (currentScrollInterval) {

clearInterval(currentScrollInterval);

currentScrollInterval = null;

}

currentCommentElement = null;

}

/**

* 滚动评论区域并自动跳转

* @param {HTMLElement} commentElement - 评论容器元素

*/

function scrollComment(commentElement) {

// 停止之前的滚动

stopScrolling();

// 保存当前评论元素引用

currentCommentElement = commentElement;

// 记录开始等待链接的时间

let linkWaitStartTime = null;

// 获取最新配置

const config = getConfig();

const scrollInterval = setInterval(() => {

// 每次滚动时重新获取配置，确保速度改变立即生效

const currentConfig = getConfig();

// 滚动

commentElement.scrollTop += currentConfig.scrollStep;

commentElement.dispatchEvent(new Event('scroll'));

// 检查是否有链接

const links = getRawLinks();

if (links.length > 0) {

// 记录开始等待的时间

if (linkWaitStartTime === null) {

linkWaitStartTime = Date.now();

}

// 计算已等待时间（毫秒）

const waitedTime = Date.now() - linkWaitStartTime;

if (waitedTime >= currentConfig.waitingTime) {

stopScrolling();

loadPage(links);

}

} else {

// 没有链接时重置等待时间

linkWaitStartTime = null;

}

}, config.scrollInterval);

// 保存 interval 引用

currentScrollInterval = scrollInterval;

}

/**

* 重新启动滚动（用于速度改变时立即生效）

*/

function restartScrolling() {

if (currentCommentElement) {

scrollComment(currentCommentElement);

}

}

/**

* 启动自动滚动功能

*/

async function startAutoScroll() {

try {

const commentElement = await waitForElement(SELECTORS.commentList);

console.log('找到评论列表元素:', commentElement);

scrollComment(commentElement);

} catch (error) {

console.error('启动自动滚动失败:', error);

}

}

// ==================== 主程序入口 ====================

/**

* 主初始化函数

*/

async function main() {

// 创建控制开关按钮

await createSwitchIcon();

// 创建悬浮速度滑块

createFloatingSpeedSlider();

// 如果助手未启用，不执行后续操作

if (!getSwitchState()) {

return;

}

// 启动自动滚动

startAutoScroll();

}

// 页面加载完成后执行

if (document.readyState === 'complete') {

main();

} else {

window.addEventListener('load', main);

}

})();