☰

POE2 Trade ST工具箱

自动转换简繁中文（页面转简体，输入转繁体）- stomtian

  1. // ==UserScript==
  2. // @name         POE2 Trade ST工具箱
  3. // @namespace    http://tampermonkey.net/
  4. // @version      2.3.2
  5. // @description  自动转换简繁中文（页面转简体，输入转繁体）- stomtian
  6. // @author       stomtian
  7. // @match        https://www.pathofexile.com/trade*
  8. // @match        https://pathofexile.com/trade*
  9. // @grant        GM_getValue
  10. // @grant        GM_setValue
  11. // @grant        unsafeWindow
  12. // @license      MIT
  13. // @require      https://cdn.jsdelivr.net/npm/opencc-js@1.0.5/dist/umd/full.min.js
  14. // @run-at       document-end
  15. // @noframes     true
  16. // ==/UserScript==
  17.     
  18. (function() {
  19.     'use strict';
  20.     
  21.     console.log('POE2 Trade ST工具箱已加载');
  22.     
  23.     const STATE = {
  24.         pageSimplified: GM_getValue('pageSimplified', true),
  25.         inputTraditional: GM_getValue('inputTraditional', true),
  26.         originalTexts: new WeakMap(),
  27.         configs: GM_getValue('savedConfigs', {}),  // 保存的配置
  28.         autoLoadEnabled: GM_getValue('autoLoadEnabled', false),  // 自动加载开关
  29.         matchedCards: [], // 添加匹配的卡片列表
  30.         currentMatchIndex: -1, // 添加当前匹配索引
  31.         showOnlyMatched: GM_getValue('showOnlyMatched', false), // 添加新的状态
  32.         searchPresets: GM_getValue('searchPresets', {}) // 添加预设关键词存储
  33.     };
  34.     
  35.     const CUSTOM_DICT = [
  36.         ['回覆', '回復'],
  37.         ['恢覆', '恢復'],
  38.     ];
  39.     
  40.     const CONFIG = {
  41.         maxAttempts: 50,
  42.         checkInterval: 100,
  43.         inputSelector: 'input[type="text"]:not(#config-name):not(#config-category), textarea',
  44.         textSelector: '.search-bar, .search-advanced-pane, .results-container, .resultset',
  45.         excludeSelector: 'script, style, input, textarea, select, .converter-controls'
  46.     };
  47.     
  48.     function waitForElement(selector) {
  49.         /**
  50.          * 等待指定选择器的元素出现在页面上
  51.          * @param {string} selector - CSS选择器
  52.          * @returns {Promise} - 当元素出现时解析的Promise
  53.          */
  54.         return new Promise(resolve => {
  55.             // 如果元素已经存在，立即解析
  56.             if (document.querySelector(selector)) {
  57.                 resolve();
  58.                 return;
  59.             }
  60.     
  61.             // 创建观察器监听DOM变化
  62.             const observer = new MutationObserver(() => {
  63.                 try {
  64.                     if (document.querySelector(selector)) {
  65.                         observer.disconnect();
  66.                         resolve();
  67.                     }
  68.                 } catch (error) {
  69.                     console.debug('等待元素时出错:', error);
  70.                 }
  71.             });
  72.     
  73.             // 开始观察DOM变化
  74.             observer.observe(document.body, {
  75.                 childList: true,
  76.                 subtree: true
  77.             });
  78.         });
  79.     }
  80.     
  81.     function waitForOpenCC() {
  82.         /**
  83.          * 等待OpenCC库加载完成
  84.          * @returns {Promise} - 当OpenCC可用时解析的Promise
  85.          */
  86.         return new Promise((resolve, reject) => {
  87.             // 如果OpenCC已经加载，立即解析
  88.             if (typeof window.OpenCC !== 'undefined') {
  89.                 resolve(window.OpenCC);
  90.                 return;
  91.             }
  92.     
  93.             let attempts = 0;
  94.             const maxAttempts = CONFIG.maxAttempts;
  95.             const checkInterval = CONFIG.checkInterval;
  96.  
  97.             // 定期检查OpenCC是否已加载
  98.             const checkOpenCC = setInterval(() => {
  99.                 attempts++;
  100.  
  101.                 if (typeof window.OpenCC !== 'undefined') {
  102.                     clearInterval(checkOpenCC);
  103.                     resolve(window.OpenCC);
  104.                     return;
  105.                 }
  106.     
  107.                 // 超过最大尝试次数后放弃
  108.                 if (attempts >= maxAttempts) {
  109.                     clearInterval(checkOpenCC);
  110.                     reject(new Error('加载OpenCC超时'));
  111.                 }
  112.             }, checkInterval);
  113.         });
  114.     }
  115.     
  116.     function createConverters(OpenCC) {
  117.         /**
  118.          * 创建简繁转换器
  119.          * @param {Object} OpenCC - OpenCC库对象
  120.          * @returns {Object} - 包含简体到繁体和繁体到简体的转换器
  121.          */
  122.         try {
  123.             // 创建简体到繁体的转换器（输入转换用）
  124.         const toTraditional = OpenCC.ConverterFactory(
  125.             OpenCC.Locale.from.cn,
  126.             OpenCC.Locale.to.tw.concat([CUSTOM_DICT])
  127.         );
  128.     
  129.             // 创建繁体到简体的转换器（页面转换用）
  130.         const toSimplified = OpenCC.ConverterFactory(
  131.             OpenCC.Locale.from.tw,
  132.             OpenCC.Locale.to.cn
  133.         );
  134.     
  135.         return { toTraditional, toSimplified };
  136.         } catch (error) {
  137.             console.error('创建转换器时出错:', error);
  138.             // 返回空转换器，避免脚本崩溃
  139.             return {
  140.                 toTraditional: text => text,
  141.                 toSimplified: text => text
  142.             };
  143.         }
  144.     }
  145.     
  146.     function createInputHandler(converter) {
  147.         /**
  148.          * 创建输入处理函数，用于将输入文本转换为繁体中文
  149.          * @param {Object} converter - 文本转换器对象
  150.          * @returns {Function} - 处理输入事件的函数
  151.          */
  152.         return function handleInput(e) {
  153.             try {
  154.                 // 检查是否需要进行转换
  155.                 if (!e?.target || !STATE.inputTraditional) return;
  156.  
  157.             // 如果输入框标记了不需要转换，则直接返回
  158.                 if (e.target.dataset?.noConvert === 'true') return;
  159.  
  160.                 // 检查输入值是否存在
  161.                 const text = e.target.value;
  162.                 if (!text) return;
  163.     
  164.                 // 保存当前光标位置
  165.             const cursorPosition = e.target.selectionStart;
  166.     
  167.                 // 使用requestAnimationFrame优化性能
  168.             requestAnimationFrame(() => {
  169.                 try {
  170.                         // 转换文本
  171.                     const convertedText = converter.toTraditional(text);
  172.  
  173.                         // 如果转换前后文本相同，则不需要更新
  174.                     if (text === convertedText) return;
  175.     
  176.                         // 更新输入框的值
  177.                     e.target.value = convertedText;
  178.     
  179.                         // 恢复光标位置
  180.                     if (typeof cursorPosition === 'number') {
  181.                         e.target.setSelectionRange(cursorPosition, cursorPosition);
  182.                     }
  183.     
  184.                         // 触发输入事件，确保其他监听器能够接收到更新
  185.                     e.target.dispatchEvent(new Event('input', {
  186.                         bubbles: true,
  187.                         cancelable: true
  188.                     }));
  189.                     } catch (error) {
  190.                         console.debug('转换输入文本时出错:', error);
  191.                     }
  192.             });
  193.             } catch (error) {
  194.                 console.debug('处理输入事件时出错:', error);
  195.             }
  196.         };
  197.     }
  198.     
  199.     function convertPageText(converter, forceRestore = false) {
  200.         /**
  201.          * 转换页面上的文本内容（简繁转换）
  202.          * @param {Object} converter - 文本转换器对象
  203.          * @param {boolean} forceRestore - 是否强制恢复原始文本
  204.          */
  205.         // 如果不需要简体化且不是强制恢复，则直接返回
  206.         if (!STATE.pageSimplified && !forceRestore) return;
  207.     
  208.         try {
  209.             // 查找需要处理的元素
  210.             const elements = document.querySelectorAll(CONFIG.textSelector);
  211.             if (!elements.length) return;
  212.     
  213.             // 处理每个根元素
  214.             elements.forEach(root => {
  215.                 try {
  216.                     // 创建TreeWalker遍历文本节点
  217.                     const walker = document.createTreeWalker(
  218.                         root,
  219.                         NodeFilter.SHOW_TEXT,
  220.                         {
  221.                             acceptNode: function(node) {
  222.                                 // 过滤空文本节点
  223.                                     if (!node.textContent.trim()) return NodeFilter.FILTER_REJECT;
  224.     
  225.                                 // 检查父节点
  226.                                     const parent = node.parentNode;
  227.                                     if (!parent) return NodeFilter.FILTER_REJECT;
  228.     
  229.                                 // 排除特定元素内的文本
  230.                                     if (parent.closest?.(CONFIG.excludeSelector)) {
  231.                                         return NodeFilter.FILTER_REJECT;
  232.                                     }
  233.     
  234.                                     return NodeFilter.FILTER_ACCEPT;
  235.                             }
  236.                         }
  237.                     );
  238.     
  239.                     // 遍历并处理每个文本节点
  240.                     let node;
  241.                     while (node = walker.nextNode()) {
  242.                             const text = node.textContent.trim();
  243.                             if (!text) continue;
  244.     
  245.                         // 保存原始文本（如果尚未保存）
  246.                             if (!STATE.originalTexts.has(node)) {
  247.                                 STATE.originalTexts.set(node, text);
  248.                             }
  249.     
  250.                         // 根据当前状态进行转换或恢复
  251.                             if (STATE.pageSimplified) {
  252.                                 const convertedText = converter.toSimplified(text);
  253.                                 if (text !== convertedText) {
  254.                                     node.textContent = convertedText;
  255.                                 }
  256.                             } else {
  257.                                 const originalText = STATE.originalTexts.get(node);
  258.                                 if (originalText && node.textContent !== originalText) {
  259.                                     node.textContent = originalText;
  260.                                 }
  261.                             }
  262.                     }
  263.                 } catch (error) {
  264.                     console.debug('处理文本节点时出错:', error);
  265.                 }
  266.             });
  267.         } catch (error) {
  268.             console.debug('转换页面文本时出错:', error);
  269.         }
  270.     }
  271.     
  272.     function attachInputListener(handleInput) {
  273.         /**
  274.          * 为页面上的输入元素添加转换事件监听器
  275.          * @param {Function} handleInput - 输入处理函数
  276.          */
  277.         try {
  278.             const inputElements = document.querySelectorAll(CONFIG.inputSelector);
  279.             if (!inputElements.length) return;
  280.     
  281.             inputElements.forEach(element => {
  282.                 try {
  283.                     // 排除已处理的元素和搜索框
  284.                     if (element?.dataset?.hasConverter || element?.dataset?.isSearchInput) {
  285.                         return;
  286.                     }
  287.  
  288.                     // 添加输入事件监听器
  289.                     element.addEventListener('input', handleInput);
  290.  
  291.                     // 标记元素已添加转换器
  292.                     element.dataset.hasConverter = 'true';
  293.                 } catch (error) {
  294.                     console.debug('为输入元素添加事件监听器时出错:', error);
  295.                 }
  296.             });
  297.         } catch (error) {
  298.             console.debug('查找输入元素时出错:', error);
  299.         }
  300.     }
  301.     
  302.     function createObserver(handleInput, converter) {
  303.         /**
  304.          * 创建DOM变化观察器，监听页面变化并处理新添加的元素
  305.          * @param {Function} handleInput - 输入处理函数
  306.          * @param {Object} converter - 文本转换器对象
  307.          * @returns {MutationObserver} - 配置好的观察器实例
  308.          */
  309.         return new MutationObserver(mutations => {
  310.                 let needsTextConversion = false;
  311.     
  312.                 for (const mutation of mutations) {
  313.                 // 跳过没有新增节点的变化
  314.                     if (!mutation.addedNodes.length) continue;
  315.     
  316.                 // 检查是否有新的输入元素
  317.                 const hasNewInputs = Array.from(mutation.addedNodes)
  318.                     .some(node => {
  319.                         try {
  320.                             // 检查节点是否包含输入元素
  321.                             return node.nodeType === Node.ELEMENT_NODE &&
  322.                                    node.querySelectorAll?.(CONFIG.inputSelector)?.length > 0;
  323.                             } catch (error) {
  324.                             console.debug('检查新节点时出错:', error);
  325.                                 return false;
  326.                             }
  327.                         });
  328.     
  329.                 // 如果有新的输入元素，为它们添加事件监听器
  330.                         if (hasNewInputs) {
  331.                             attachInputListener(handleInput);
  332.                         }
  333.     
  334.                 // 标记需要进行文本转换
  335.                         needsTextConversion = true;
  336.                 }
  337.     
  338.             // 如果需要文本转换，延迟执行以确保DOM已完全更新
  339.                 if (needsTextConversion) {
  340.                     setTimeout(() => convertPageText(converter), 100);
  341.                 }
  342.         });
  343.     }
  344.     
  345.     function createConfigModal() {
  346.         const modalHtml = `
  347.             <div id="config-modal" style="display: none; position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%);
  348.                 background: #1a1a1a; padding: 20px; border-radius: 8px; z-index: 10000; min-width: 600px; color: #fff;">
  349.                 <div style="display: flex; justify-content: space-between; margin-bottom: 15px;">
  350.                     <h3 style="margin: 0;">ST工具箱</h3>
  351.                     <button id="close-config-modal" style="background: none; border: none; color: #fff; cursor: pointer;">✕</button>
  352.                 </div>
  353.     
  354.                 <!-- 标签栏 -->
  355.                 <div style="display: flex; gap: 10px; margin-bottom: 15px; border-bottom: 1px solid #444; padding-bottom: 10px;">
  356.                     <button id="tab-configs" class="modal-tab active" style="padding: 8px 20px; background: #4a90e2; border: none; color: #fff; cursor: pointer; border-radius: 4px; transition: all 0.2s;">配置管理</button>
  357.                     <button id="tab-presets" class="modal-tab" style="padding: 8px 20px; background: #3d3d3d; border: none; color: #fff; cursor: pointer; border-radius: 4px; transition: all 0.2s;">预设关键词</button>
  358.                     <button id="tab-settings" class="modal-tab" style="padding: 8px 20px; background: #3d3d3d; border: none; color: #fff; cursor: pointer; border-radius: 4px; transition: all 0.2s;">设置</button>
  359.                     <button id="tab-contact" class="modal-tab" style="padding: 8px 20px; background: #3d3d3d; border: none; color: #fff; cursor: pointer; border-radius: 4px; transition: all 0.2s;">联系我</button>
  360.                 </div>
  361.     
  362.                 <!-- 配置管理面板 -->
  363.                 <div id="panel-configs" class="panel" style="display: block;">
  364.                     <div style="padding: 15px; background: #2d2d2d; border-radius: 4px;">
  365.                         <div style="margin-bottom: 15px;">
  366.                             <input type="text" id="config-name" placeholder="配置名称"
  367.                                 style="padding: 5px; margin-right: 10px; background: #3d3d3d; border: 1px solid #444; color: #fff; width: 200px;">
  368.                             <div class="custom-select" style="display: inline-block; position: relative; width: 150px; margin-right: 10px;">
  369.                                 <input type="text" id="config-category" placeholder="选择或输入分类"
  370.                                     style="padding: 5px; background: #3d3d3d; border: 1px solid #444; color: #fff; width: 100%; cursor: pointer;">
  371.                                 <div id="category-dropdown" style="display: none; position: absolute; top: 100%; left: 0; width: 100%;
  372.                                     background: #3d3d3d; border: 1px solid #444; border-top: none; max-height: 200px; overflow-y: auto; z-index: 1000;">
  373.                                 </div>
  374.                             </div>
  375.                             <button id="save-config" style="padding: 5px 10px; background: #4a90e2; border: none; color: #fff; cursor: pointer; border-radius: 3px;">
  376.                                 保存当前配置
  377.                             </button>
  378.                         </div>
  379.                         <div id="category-tabs" style="margin-bottom: 15px; border-bottom: 1px solid #444; padding-bottom: 10px;"></div>
  380.                         <div id="config-list" style="max-height: 300px; overflow-y: auto;">
  381.                         </div>
  382.                     </div>
  383.                 </div>
  384.     
  385.                 <!-- 设置面板 -->
  386.                 <div id="panel-settings" class="panel" style="display: none;">
  387.                     <div style="padding: 15px; background: #2d2d2d; border-radius: 4px;">
  388.                         <!-- 功能开关 -->
  389.                         <div style="margin-bottom: 20px;">
  390.                             <div style="font-weight: bold; margin-bottom: 10px; color: #4a90e2;">功能开关</div>
  391.                             <div style="display: flex; gap: 10px;">
  392.                                 <button id="toggle-page-simplified" style="flex: 1; padding: 8px 15px; background: ${STATE.pageSimplified ? '#4a90e2' : '#3d3d3d'}; border: none; color: #fff; cursor: pointer; border-radius: 3px; transition: background-color 0.2s; text-align: center;">
  393.                                     ${STATE.pageSimplified ? '✓ 页面简体' : '✗ 页面简体'}
  394.                                 </button>
  395.                                 <button id="toggle-input-traditional" style="flex: 1; padding: 8px 15px; background: ${STATE.inputTraditional ? '#4a90e2' : '#3d3d3d'}; border: none; color: #fff; cursor: pointer; border-radius: 3px; transition: background-color 0.2s; text-align: center;">
  396.                                     ${STATE.inputTraditional ? '✓ 输入繁体' : '✗ 输入繁体'}
  397.                                 </button>
  398.                                 <button id="toggle-auto-load" style="flex: 1; padding: 8px 15px; background: ${STATE.autoLoadEnabled ? '#4a90e2' : '#3d3d3d'}; border: none; color: #fff; cursor: pointer; border-radius: 3px; transition: background-color 0.2s; text-align: center;">
  399.                                     ${STATE.autoLoadEnabled ? '✓ 自动加载' : '✗ 自动加载'}
  400.                                 </button>
  401.                             </div>
  402.                         </div>
  403.     
  404.                         <!-- 配置导入导出 -->
  405.                         <div style="margin-top: 20px;">
  406.                             <div style="font-weight: bold; margin-bottom: 10px; color: #4a90e2;">配置导入导出</div>
  407.                             <div style="display: flex; gap: 10px;">
  408.                                 <button id="export-configs" style="flex: 1; padding: 8px 15px; background: #27ae60; border: none; color: #fff; cursor: pointer; border-radius: 3px;">导出配置</button>
  409.                                 <button id="import-configs" style="flex: 1; padding: 8px 15px; background: #e67e22; border: none; color: #fff; cursor: pointer; border-radius: 3px;">导入配置</button>
  410.                                 <input type="file" id="import-file" accept=".json" style="display: none;">
  411.                             </div>
  412.                         </div>
  413.                     </div>
  414.                 </div>
  415.  
  416.                 <!-- 预设关键词面板 -->
  417.                 <div id="panel-presets" class="panel" style="display: none;">
  418.                     <div style="padding: 15px; background: #2d2d2d; border-radius: 4px;">
  419.                         <div style="margin-bottom: 15px; display: flex; justify-content: flex-end;">
  420.                             <button id="add-preset" style="padding: 8px 20px; background: #4a90e2; border: none; color: #fff; cursor: pointer; border-radius: 4px; transition: all 0.2s;">
  421.                                 添加预设
  422.                             </button>
  423.                         </div>
  424.                         <div id="preset-list" style="max-height: 400px; overflow-y: auto;">
  425.                         </div>
  426.                     </div>
  427.                 </div>
  428.                 <!-- 联系我面板 -->
  429.                 <div id="panel-contact" class="panel" style="display: none;">
  430.                     <div style="padding: 15px; background: #2d2d2d; border-radius: 4px;">
  431.                         <div style="text-align: center; padding: 20px;">
  432.                             <div style="font-size: 18px; color: #4a90e2; margin-bottom: 15px;">欢迎加入POE2 ST工具箱交流群</div>
  433.                             <div style="font-size: 24px; color: #FFD700; margin-bottom: 15px;">QQ群：858024457</div>
  434.                             <div style="color: #999; font-size: 14px;">
  435.                                 欢迎各位流亡者加入交流群，反馈使用问题，提出建议！
  436.                             </div>
  437.                         </div>
  438.                     </div>
  439.                 </div>
  440.             </div>
  441.  
  442.             <!-- 预设编辑弹窗 -->
  443.             <div id="preset-edit-modal" style="display: none; position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%);
  444.                 background: #1a1a1a; padding: 20px; border-radius: 8px; z-index: 10002; width: 800px; color: #fff; box-shadow: 0 0 20px rgba(0, 0, 0, 0.5);">
  445.                 <div style="display: flex; justify-content: space-between; margin-bottom: 15px;">
  446.                     <h3 style="margin: 0;" id="preset-edit-title">添加预设</h3>
  447.                     <button id="close-preset-edit" style="background: none; border: none; color: #fff; cursor: pointer; font-size: 20px;">✕</button>
  448.                 </div>
  449.                 <div style="margin-bottom: 15px;">
  450.                     <div style="margin-bottom: 10px;">
  451.                         <label style="display: block; margin-bottom: 5px;">预设名称</label>
  452.                         <input type="text" id="preset-name" style="width: 100%; padding: 8px; background: #2d2d2d; border: 1px solid #444; color: #fff; border-radius: 4px;">
  453.                     </div>
  454.                     <div>
  455.                         <label style="display: block; margin-bottom: 5px;">关键词（用;分隔）</label>
  456.                         <textarea id="preset-keywords" style="width: 100%; height: 200px; padding: 8px; background: #2d2d2d; border: 1px solid #444; color: #fff; border-radius: 4px; resize: vertical; font-family: monospace;"></textarea>
  457.                     </div>
  458.                 </div>
  459.                 <div style="display: flex; justify-content: flex-end; gap: 10px;">
  460.                     <button id="cancel-preset-edit" style="padding: 8px 20px; background: #3d3d3d; border: none; color: #fff; cursor: pointer; border-radius: 4px;">
  461.                         取消
  462.                     </button>
  463.                     <button id="save-preset" style="padding: 8px 20px; background: #4a90e2; border: none; color: #fff; cursor: pointer; border-radius: 4px;">
  464.                         保存
  465.                     </button>
  466.                 </div>
  467.             </div>
  468.  
  469.             <!-- 添加遮罩层 -->
  470.             <div id="preset-edit-overlay" style="display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; background: rgba(0, 0, 0, 0.7); z-index: 10001;"></div>
  471.         </div>
  472.     `;
  473.     
  474.         document.body.insertAdjacentHTML('beforeend', modalHtml);
  475.     
  476.         // 添加遮罩
  477.         const overlay = document.createElement('div');
  478.         overlay.id = 'config-modal-overlay';
  479.         overlay.style.cssText = `
  480.             display: none;
  481.             position: fixed;
  482.             top: 0;
  483.             left: 0;
  484.             width: 100%;
  485.             height: 100%;
  486.             background: rgba(0, 0, 0, 0.5);
  487.             z-index: 9999;
  488.         `;
  489.         document.body.appendChild(overlay);
  490.     
  491.         // 添加样式
  492.         const style = document.createElement('style');
  493.         style.textContent = `
  494.             .modal-tab.active {
  495.                 background: #4a90e2 !important;
  496.             }
  497.             .modal-tab:hover {
  498.                 background: #357abd !important;
  499.             }
  500.             .panel {
  501.                 transition: opacity 0.3s ease;
  502.             }
  503.             #config-list::-webkit-scrollbar {
  504.                 width: 8px;
  505.             }
  506.             #config-list::-webkit-scrollbar-track {
  507.                 background: #1a1a1a;
  508.             }
  509.             #config-list::-webkit-scrollbar-thumb {
  510.                 background: #444;
  511.                 border-radius: 4px;
  512.             }
  513.             #config-list::-webkit-scrollbar-thumb:hover {
  514.                 background: #555;
  515.             }
  516.         `;
  517.         document.head.appendChild(style);
  518.     
  519.         setupConfigModalEvents();
  520.         updateConfigList();
  521.         setupCategoryDropdown();
  522.     }
  523.     
  524.     function setupCategoryDropdown() {
  525.         const categoryInput = document.getElementById('config-category');
  526.         const dropdown = document.getElementById('category-dropdown');
  527.         let isDropdownVisible = false;
  528.     
  529.         function updateDropdown() {
  530.             const categories = Object.keys(STATE.configs);
  531.             const inputValue = categoryInput.value.toLowerCase();
  532.     
  533.             dropdown.innerHTML = '';
  534.     
  535.             categories
  536.                 .filter(category => category.toLowerCase().includes(inputValue))
  537.                 .forEach(category => {
  538.                     const item = document.createElement('div');
  539.                     item.className = 'dropdown-item';
  540.                     item.textContent = category;
  541.                     item.onclick = () => {
  542.                         categoryInput.value = category;
  543.                         hideDropdown();
  544.                     };
  545.                     dropdown.appendChild(item);
  546.                 });
  547.     
  548.             if (categories.length === 0) {
  549.                 const item = document.createElement('div');
  550.                 item.className = 'dropdown-item';
  551.                 item.textContent = '无已有分类';
  552.                 item.style.color = '#666';
  553.                 dropdown.appendChild(item);
  554.             }
  555.         }
  556.     
  557.         function showDropdown() {
  558.             updateDropdown();
  559.             dropdown.style.display = 'block';
  560.             isDropdownVisible = true;
  561.         }
  562.     
  563.         function hideDropdown() {
  564.             dropdown.style.display = 'none';
  565.             isDropdownVisible = false;
  566.         }
  567.     
  568.         categoryInput.addEventListener('focus', showDropdown);
  569.         categoryInput.addEventListener('input', updateDropdown);
  570.     
  571.         // 点击外部区域时隐藏下拉列表
  572.         document.addEventListener('click', (e) => {
  573.             const isClickInside = categoryInput.contains(e.target) || dropdown.contains(e.target);
  574.             if (!isClickInside && isDropdownVisible) {
  575.                 hideDropdown();
  576.             }
  577.         });
  578.     
  579.         // 阻止事件冒泡，避免点击下拉列表时触发外部点击事件
  580.         dropdown.addEventListener('click', (e) => {
  581.             e.stopPropagation();
  582.         });
  583.     }
  584.     
  585.     function setupConfigModalEvents() {
  586.         const modal = document.getElementById('config-modal');
  587.         const overlay = document.getElementById('config-modal-overlay');
  588.         const closeBtn = document.getElementById('close-config-modal');
  589.         const saveBtn = document.getElementById('save-config');
  590.         const togglePageBtn = document.getElementById('toggle-page-simplified');
  591.         const toggleInputBtn = document.getElementById('toggle-input-traditional');
  592.         const toggleAutoLoadBtn = document.getElementById('toggle-auto-load');
  593.         const exportBtn = document.getElementById('export-configs');
  594.         const importBtn = document.getElementById('import-configs');
  595.         const importFile = document.getElementById('import-file');
  596.         const tabConfigs = document.getElementById('tab-configs');
  597.         const tabSettings = document.getElementById('tab-settings');
  598.         const tabPresets = document.getElementById('tab-presets'); 
  599.         const tabContact = document.getElementById('tab-contact');
  600.         const panelConfigs = document.getElementById('panel-configs');
  601.         const panelSettings = document.getElementById('panel-settings');
  602.         const panelPresets = document.getElementById('panel-presets');
  603.         const panelContact = document.getElementById('panel-contact');
  604.         const savePresetBtn = document.getElementById('save-preset');
  605.  
  606.         const addPresetBtn = document.getElementById('add-preset');
  607.         const presetEditModal = document.getElementById('preset-edit-modal');
  608.         const presetEditOverlay = document.getElementById('preset-edit-overlay');
  609.         const closePresetEdit = document.getElementById('close-preset-edit');
  610.         const cancelPresetEdit = document.getElementById('cancel-preset-edit');
  611.         const presetEditTitle = document.getElementById('preset-edit-title');
  612.  
  613.         // 标签切换函数
  614.         function switchTab(activeTab) {
  615.             // 重置所有标签和面板
  616.             [tabConfigs, tabSettings, tabPresets, tabContact].forEach(tab => {
  617.                 tab.classList.remove('active');
  618.                 tab.style.background = '#3d3d3d';
  619.             });
  620.             [panelConfigs, panelSettings, panelPresets, panelContact].forEach(panel => {
  621.                 panel.style.display = 'none';
  622.             });
  623.  
  624.             // 激活选中的标签和面板
  625.             activeTab.classList.add('active');
  626.             activeTab.style.background = '#4a90e2';
  627.             
  628.             // 显示对应的面板
  629.             if (activeTab === tabConfigs) {
  630.                 panelConfigs.style.display = 'block';
  631.             } else if (activeTab === tabSettings) {
  632.                 panelSettings.style.display = 'block';
  633.             } else if (activeTab === tabPresets) {
  634.                 panelPresets.style.display = 'block';
  635.                 updatePresetList();
  636.             } else if (activeTab === tabContact) {
  637.                 panelContact.style.display = 'block';
  638.             }
  639.         }
  640.  
  641.         // 标签切换事件
  642.         tabConfigs.addEventListener('click', () => switchTab(tabConfigs));
  643.         tabSettings.addEventListener('click', () => switchTab(tabSettings));
  644.         tabPresets.addEventListener('click', () => switchTab(tabPresets));
  645.         tabContact.addEventListener('click', () => switchTab(tabContact));
  646.         
  647.         // 初始化显示配置管理标签
  648.         switchTab(tabConfigs);
  649.  
  650.         closeBtn.addEventListener('click', () => {
  651.             modal.style.display = 'none';
  652.             overlay.style.display = 'none';
  653.         });
  654.     
  655.         overlay.addEventListener('click', () => {
  656.             modal.style.display = 'none';
  657.             overlay.style.display = 'none';
  658.         });
  659.     
  660.         togglePageBtn.addEventListener('click', () => {
  661.             STATE.pageSimplified = !STATE.pageSimplified;
  662.             GM_setValue('pageSimplified', STATE.pageSimplified);
  663.             togglePageBtn.textContent = STATE.pageSimplified ? '✓ 页面简体' : '✗ 页面简体';
  664.             togglePageBtn.style.backgroundColor = STATE.pageSimplified ? '#4a90e2' : '#3d3d3d';
  665.             convertPageText(window.converter, true);
  666.         });
  667.     
  668.         toggleInputBtn.addEventListener('click', () => {
  669.             STATE.inputTraditional = !STATE.inputTraditional;
  670.             GM_setValue('inputTraditional', STATE.inputTraditional);
  671.             toggleInputBtn.textContent = STATE.inputTraditional ? '✓ 输入繁体' : '✗ 输入繁体';
  672.             toggleInputBtn.style.backgroundColor = STATE.inputTraditional ? '#4a90e2' : '#3d3d3d';
  673.         });
  674.     
  675.         toggleAutoLoadBtn.addEventListener('click', () => {
  676.             STATE.autoLoadEnabled = !STATE.autoLoadEnabled;
  677.             GM_setValue('autoLoadEnabled', STATE.autoLoadEnabled);
  678.             toggleAutoLoadBtn.textContent = STATE.autoLoadEnabled ? '✓ 自动加载' : '✗ 自动加载';
  679.             toggleAutoLoadBtn.style.backgroundColor = STATE.autoLoadEnabled ? '#4a90e2' : '#3d3d3d';
  680.         });
  681.     
  682.         saveBtn.addEventListener('click', saveCurrentConfig);
  683.     
  684.         // 修改导出配置
  685.         exportBtn.addEventListener('click', () => {
  686.             const configData = {
  687.                 version: '2.0.0',
  688.                 configs: {},
  689.                 searchPresets: STATE.searchPresets
  690.             };
  691.  
  692.             // 复制配置，但不包含 timestamp
  693.             Object.keys(STATE.configs).forEach(category => {
  694.                 configData.configs[category] = {};
  695.                 Object.keys(STATE.configs[category]).forEach(name => {
  696.                     configData.configs[category][name] = {
  697.                         url: STATE.configs[category][name].url
  698.                     };
  699.                 });
  700.             });
  701.             
  702.             const blob = new Blob([JSON.stringify(configData, null, 2)], { type: 'application/json' });
  703.             const url = URL.createObjectURL(blob);
  704.             const a = document.createElement('a');
  705.             a.href = url;
  706.             a.download = `poe2_trade_configs_${new Date().toISOString().slice(0,10)}.json`;
  707.             document.body.appendChild(a);
  708.             a.click();
  709.             document.body.removeChild(a);
  710.             URL.revokeObjectURL(url);
  711.         });
  712.     
  713.         // 导入配置按钮点击
  714.         importBtn.addEventListener('click', () => {
  715.             importFile.click();
  716.         });
  717.     
  718.         // 处理文件导入
  719.         importFile.addEventListener('change', (e) => {
  720.             const file = e.target.files[0];
  721.             if (!file) return;
  722.     
  723.             const reader = new FileReader();
  724.             reader.onload = (event) => {
  725.                 try {
  726.                     const importedData = JSON.parse(event.target.result);
  727.                     
  728.                     // 验证导入的数据
  729.                     if (!importedData.version || (!importedData.configs && !importedData.searchPresets)) {
  730.                         throw new Error('无效的配置文件格式');
  731.                     }
  732.     
  733.                     // 确认导入
  734.                     if (confirm(`确定要导入这些配置吗？\n这将会覆盖同名的现有配置和预设关键词。`)) {
  735.                         // 合并配置
  736.                         if (importedData.configs) {
  737.                             Object.keys(importedData.configs).forEach(category => {
  738.                                 if (!STATE.configs[category]) {
  739.                                     STATE.configs[category] = {};
  740.                                 }
  741.                                 Object.assign(STATE.configs[category], importedData.configs[category]);
  742.                             });
  743.                             GM_setValue('savedConfigs', STATE.configs);
  744.                             updateConfigList();
  745.                         }
  746.  
  747.                         // 合并预设关键词
  748.                         if (importedData.searchPresets) {
  749.                             Object.assign(STATE.searchPresets, importedData.searchPresets);
  750.                             GM_setValue('searchPresets', STATE.searchPresets);
  751.                             updatePresetList();
  752.                         }
  753.  
  754.                         alert('配置导入成功！');
  755.                     }
  756.                 } catch (error) {
  757.                     alert('导入失败：' + error.message);
  758.                 }
  759.                 
  760.                 // 清除文件选择，允许重复导入同一个文件
  761.                 importFile.value = '';
  762.             };
  763.             reader.readAsText(file);
  764.         });
  765.     
  766.         // 添加预设标签切换事件
  767.         tabPresets.addEventListener('click', () => {
  768.             tabPresets.classList.add('active');
  769.             tabConfigs.classList.remove('active');
  770.             tabSettings.classList.remove('active');
  771.             tabConfigs.style.background = '#3d3d3d';
  772.             tabSettings.style.background = '#3d3d3d';
  773.             panelConfigs.style.display = 'none';
  774.             panelSettings.style.display = 'none';
  775.             panelPresets.style.display = 'block';
  776.             updatePresetList();
  777.         });
  778.     
  779.         // 添加保存预设事件
  780.         savePresetBtn.addEventListener('click', saveSearchPreset);
  781.  
  782.         function closePresetEditModal() {
  783.             presetEditModal.style.display = 'none';
  784.             presetEditOverlay.style.display = 'none';
  785.         }
  786.  
  787.         // 打开预设编辑弹窗
  788.         addPresetBtn.addEventListener('click', () => {
  789.             presetEditModal.style.display = 'block';
  790.             presetEditOverlay.style.display = 'block';
  791.             presetEditTitle.textContent = '添加预设';
  792.             document.getElementById('preset-name').value = '';
  793.             document.getElementById('preset-keywords').value = '';
  794.             document.getElementById('preset-name').dataset.editMode = 'false';
  795.         });
  796.  
  797.         // 关闭预设编辑弹窗
  798.         [closePresetEdit, cancelPresetEdit, presetEditOverlay].forEach(btn => {
  799.             btn.addEventListener('click', closePresetEditModal);
  800.         });
  801.  
  802.         // 添加预设名称和关键词输入框的事件处理
  803.         const presetNameInput = document.getElementById('preset-name');
  804.         const presetKeywordsInput = document.getElementById('preset-keywords');
  805.  
  806.         // 标记这些输入框不需要转换
  807.         presetNameInput.dataset.noConvert = 'true';
  808.         presetKeywordsInput.dataset.noConvert = 'true';
  809.  
  810.         // 移除原有的输入转换处理
  811.         [presetNameInput, presetKeywordsInput].forEach(input => {
  812.             const oldInput = input.cloneNode(true);
  813.             input.parentNode.replaceChild(oldInput, input);
  814.         });
  815.     }
  816.     
  817.     // 修改 saveCurrentConfig 函数
  818.     function saveCurrentConfig() {
  819.         const name = document.getElementById('config-name').value.trim();
  820.         const category = document.getElementById('config-category').value.trim();
  821.  
  822.         if (!name) {
  823.             alert('请输入配置名称');
  824.             return;
  825.         }
  826.  
  827.         if (!category) {
  828.             alert('请输入分类名称');
  829.             return;
  830.         }
  831.  
  832.         if (!STATE.configs[category]) {
  833.             STATE.configs[category] = {};
  834.         }
  835.  
  836.         STATE.configs[category][name] = {
  837.             url: window.location.href
  838.         };
  839.  
  840.         GM_setValue('savedConfigs', STATE.configs);
  841.         updateConfigList();
  842.  
  843.         document.getElementById('config-name').value = '';
  844.         document.getElementById('config-category').value = '';
  845.     }
  846.     
  847.     function updateConfigList() {
  848.         const configList = document.getElementById('config-list');
  849.         const categoryTabs = document.getElementById('category-tabs');
  850.         configList.innerHTML = '';
  851.         categoryTabs.innerHTML = '';
  852.     
  853.         // 获取所有分类
  854.         const categories = Object.keys(STATE.configs);
  855.     
  856.         // 如果没有配置，显示提示信息
  857.         if (categories.length === 0) {
  858.             configList.innerHTML = '<div style="text-align: center; color: #666;">暂无保存的配置</div>';
  859.             return;
  860.         }
  861.     
  862.         // 创建标签
  863.         categories.forEach((category, index) => {
  864.             const tabButton = document.createElement('button');
  865.             tabButton.textContent = category;
  866.             tabButton.style.cssText = `
  867.                 background: ${index === 0 ? '#4a90e2' : '#3d3d3d'};
  868.                 border: none;
  869.                 color: #fff;
  870.                 padding: 5px 15px;
  871.                 cursor: pointer;
  872.                 border-radius: 3px;
  873.                 transition: background-color 0.2s;
  874.                 margin-right: 10px;
  875.             `;
  876.             tabButton.dataset.category = category;
  877.             tabButton.title = '双击删除分类';
  878.     
  879.             tabButton.addEventListener('click', (e) => {
  880.                 document.querySelectorAll('#category-tabs button[data-category]').forEach(btn => {
  881.                     btn.style.backgroundColor = '#3d3d3d';
  882.                 });
  883.                 tabButton.style.backgroundColor = '#4a90e2';
  884.                 showCategoryConfigs(category);
  885.             });
  886.     
  887.             tabButton.addEventListener('dblclick', (e) => {
  888.                 e.stopPropagation();
  889.                 deleteCategory(category);
  890.             });
  891.     
  892.             categoryTabs.appendChild(tabButton);
  893.         });
  894.     
  895.         // 默认显示第一个分类的配置
  896.         showCategoryConfigs(categories[0]);
  897.     }
  898.     
  899.     function deleteCategory(category) {
  900.         /**
  901.          * 删除指定的配置类别及其所有配置
  902.          * @param {string} category - 要删除的配置类别
  903.          */
  904.         try {
  905.             // 检查类别是否存在
  906.             if (!STATE.configs[category]) {
  907.                 console.warn(`类别不存在: ${category}`);
  908.                 return;
  909.             }
  910.  
  911.             // 获取该类别下的配置数量
  912.         const configCount = Object.keys(STATE.configs[category]).length;
  913.  
  914.             // 确认删除操作
  915.         if (confirm(`确定要删除分类 "${category}" 及其包含的 ${configCount} 个配置吗？`)) {
  916.                 // 删除类别
  917.             delete STATE.configs[category];
  918.  
  919.                 // 保存更新后的配置
  920.             GM_setValue('savedConfigs', STATE.configs);
  921.  
  922.                 // 更新配置列表显示
  923.             updateConfigList();
  924.  
  925.                 console.log(`已删除类别: ${category} (包含 ${configCount} 个配置)`);
  926.             }
  927.         } catch (error) {
  928.             console.error('删除类别时出错:', error);
  929.         }
  930.     }
  931.     
  932.     function showCategoryConfigs(category) {
  933.         /**
  934.          * 显示指定类别的所有配置
  935.          * @param {string} category - 配置类别
  936.          */
  937.         try {
  938.             // 获取配置列表容器
  939.         const configList = document.getElementById('config-list');
  940.             if (!configList) {
  941.                 console.warn('无法找到配置列表容器');
  942.                 return;
  943.             }
  944.  
  945.             // 清空当前列表
  946.         configList.innerHTML = '';
  947.  
  948.             // 获取指定类别的配置
  949.         const configs = STATE.configs[category];
  950.             if (!configs || Object.keys(configs).length === 0) {
  951.                 const emptyMessage = document.createElement('div');
  952.                 emptyMessage.textContent = '该分类下没有配置';
  953.                 emptyMessage.style.padding = '10px';
  954.                 emptyMessage.style.color = '#999';
  955.                 configList.appendChild(emptyMessage);
  956.                 return;
  957.             }
  958.  
  959.             // 遍历并显示每个配置
  960.         Object.entries(configs).forEach(([name, data]) => {
  961.                 // 创建配置项容器
  962.             const configItem = document.createElement('div');
  963.             configItem.style.cssText = `
  964.                 display: grid;
  965.                 grid-template-columns: 1fr auto auto auto;
  966.                 align-items: center;
  967.                 padding: 8px;
  968.                 margin: 5px 0;
  969.                 background: #3d3d3d;
  970.                 border-radius: 4px;
  971.                 gap: 10px;
  972.             `;
  973.     
  974.                 // 创建配置名称元素
  975.             const nameSpan = document.createElement('span');
  976.             nameSpan.textContent = name;
  977.             nameSpan.style.cssText = `
  978.                 overflow: hidden;
  979.                 text-overflow: ellipsis;
  980.                 white-space: nowrap;
  981.             `;
  982.     
  983.                 // 创建读取按钮
  984.             const loadBtn = document.createElement('button');
  985.             loadBtn.textContent = '读取';
  986.             loadBtn.style.cssText = `
  987.                 background: #4a90e2;
  988.                 border: none;
  989.                 color: #fff;
  990.                 padding: 3px 12px;
  991.                 cursor: pointer;
  992.                 border-radius: 3px;
  993.                 transition: background-color 0.2s;
  994.             `;
  995.                 loadBtn.onclick = () => {
  996.                     loadConfig(data.url);
  997.                 };
  998.     
  999.                 // 创建更新按钮
  1000.             const updateBtn = document.createElement('button');
  1001.             updateBtn.textContent = '更新';
  1002.             updateBtn.style.cssText = `
  1003.                 background: #27ae60;
  1004.                 border: none;
  1005.                 color: #fff;
  1006.                 padding: 3px 12px;
  1007.                 cursor: pointer;
  1008.                 border-radius: 3px;
  1009.                 transition: background-color 0.2s;
  1010.             `;
  1011.             updateBtn.onclick = (e) => {
  1012.                 e.stopPropagation();
  1013.                 updateConfig(category, name);
  1014.             };
  1015.     
  1016.                 // 创建删除按钮
  1017.             const deleteBtn = document.createElement('button');
  1018.             deleteBtn.textContent = '删除';
  1019.             deleteBtn.style.cssText = `
  1020.                 background: #e74c3c;
  1021.                 border: none;
  1022.                 color: #fff;
  1023.                 padding: 3px 12px;
  1024.                 cursor: pointer;
  1025.                 border-radius: 3px;
  1026.                 transition: background-color 0.2s;
  1027.             `;
  1028.             deleteBtn.onclick = (e) => {
  1029.                 e.stopPropagation();
  1030.                 deleteConfig(category, name);
  1031.             };
  1032.     
  1033.                 // 添加所有元素到配置项
  1034.             configItem.appendChild(nameSpan);
  1035.             configItem.appendChild(loadBtn);
  1036.             configItem.appendChild(updateBtn);
  1037.             configItem.appendChild(deleteBtn);
  1038.  
  1039.                 // 添加配置项到列表
  1040.             configList.appendChild(configItem);
  1041.         });
  1042.         } catch (error) {
  1043.             console.error('显示配置列表时出错:', error);
  1044.         }
  1045.     }
  1046.     
  1047.     function loadConfig(url) {
  1048.         /**
  1049.          * 加载指定URL的配置
  1050.          * @param {string} url - 要加载的配置URL
  1051.          */
  1052.         try {
  1053.             if (!url) {
  1054.                 console.warn('加载配置失败: URL为空');
  1055.                 return;
  1056.             }
  1057.  
  1058.             // 导航到指定URL
  1059.         window.location.href = url;
  1060.             console.log('正在加载配置:', url);
  1061.         } catch (error) {
  1062.             console.error('加载配置时出错:', error);
  1063.         }
  1064.     }
  1065.     
  1066.     function deleteConfig(category, name) {
  1067.         /**
  1068.          * 删除指定类别和名称的配置
  1069.          * @param {string} category - 配置类别
  1070.          * @param {string} name - 配置名称
  1071.          */
  1072.         try {
  1073.             // 确认删除操作
  1074.         if (confirm(`确定要删除配置 "${name}" 吗？`)) {
  1075.                 // 删除指定配置
  1076.                 if (STATE.configs[category] && STATE.configs[category][name]) {
  1077.             delete STATE.configs[category][name];
  1078.  
  1079.                     // 如果类别下没有配置了，删除整个类别
  1080.             if (Object.keys(STATE.configs[category]).length === 0) {
  1081.                 delete STATE.configs[category];
  1082.             }
  1083.  
  1084.                     // 保存更新后的配置
  1085.             GM_setValue('savedConfigs', STATE.configs);
  1086.  
  1087.                     // 更新配置列表显示
  1088.             updateConfigList();
  1089.  
  1090.                     console.log(`已删除配置: ${category}/${name}`);
  1091.                 } else {
  1092.                     console.warn(`配置不存在: ${category}/${name}`);
  1093.                 }
  1094.             }
  1095.         } catch (error) {
  1096.             console.error('删除配置时出错:', error);
  1097.         }
  1098.     }
  1099.     
  1100.     function createConfigButton() {
  1101.         const floatingButton = document.createElement('div');
  1102.         floatingButton.style.cssText = `
  1103.             position: fixed;
  1104.             right: 20px;
  1105.             top: 50%;
  1106.             transform: translateY(-50%);
  1107.             width: 50px;
  1108.             height: 50px;
  1109.             background: linear-gradient(135deg, #3c3c28 0%, #2a2a1c 100%);
  1110.             border-radius: 25px;
  1111.             display: flex;
  1112.             align-items: center;
  1113.             justify-content: center;
  1114.             cursor: pointer;
  1115.             color: #ffd700;
  1116.             font-weight: bold;
  1117.             font-family: 'Fontin SmallCaps', Arial, sans-serif;
  1118.             font-size: 18px;
  1119.             box-shadow: 0 0 20px rgba(0,0,0,0.5),
  1120.                         inset 0 0 8px rgba(255, 215, 0, 0.3),
  1121.                         0 0 30px rgba(255, 215, 0, 0.2);
  1122.             border: 1px solid rgba(255, 215, 0, 0.4);
  1123.             z-index: 9998;
  1124.             transition: all 0.3s ease;
  1125.             user-select: none;
  1126.             touch-action: none;
  1127.             text-shadow: 0 0 10px rgba(255, 215, 0, 0.6);
  1128.             animation: normalGlowing 2s ease-in-out infinite;
  1129.         `;
  1130.         floatingButton.textContent = 'ST';
  1131.         floatingButton.title = 'ST工具箱 (按住可拖动)';
  1132.     
  1133.         // 添加悬停效果
  1134.         floatingButton.addEventListener('mouseenter', () => {
  1135.             if (!isDragging) {
  1136.                 floatingButton.style.transform = 'scale(1.1)';
  1137.                 floatingButton.style.boxShadow = `
  1138.                     0 0 25px rgba(0,0,0,0.5),
  1139.                     inset 0 0 12px rgba(255, 215, 0, 0.5),
  1140.                     0 0 40px rgba(255, 215, 0, 0.3)
  1141.                 `;
  1142.                 floatingButton.style.color = '#ffe44d';
  1143.                 floatingButton.style.textShadow = '0 0 15px rgba(255, 215, 0, 0.8)';
  1144.                 floatingButton.style.border = '1px solid rgba(255, 215, 0, 0.6)';
  1145.                 floatingButton.style.animation = 'none';
  1146.     
  1147.                 if (isHidden) {
  1148.                     showButton();
  1149.                 }
  1150.             }
  1151.         });
  1152.     
  1153.         floatingButton.addEventListener('mouseleave', () => {
  1154.             if (!isDragging) {
  1155.                 floatingButton.style.transform = 'scale(1)';
  1156.                 floatingButton.style.boxShadow = `
  1157.                     0 0 20px rgba(0,0,0,0.5),
  1158.                     inset 0 0 8px rgba(255, 215, 0, 0.3),
  1159.                     0 0 30px rgba(255, 215, 0, 0.2)
  1160.                 `;
  1161.                 floatingButton.style.color = '#ffd700';
  1162.                 floatingButton.style.textShadow = '0 0 10px rgba(255, 215, 0, 0.6)';
  1163.                 floatingButton.style.border = '1px solid rgba(255, 215, 0, 0.4)';
  1164.                 floatingButton.style.animation = 'normalGlowing 2s ease-in-out infinite';
  1165.     
  1166.                 checkAndHideButton();
  1167.             }
  1168.         });
  1169.     
  1170.         // 添加拖拽功能
  1171.         let isDragging = false;
  1172.         let startX, startY;
  1173.         let lastX = GM_getValue('floatingButtonX', window.innerWidth - 70);
  1174.         let lastY = GM_getValue('floatingButtonY', window.innerHeight / 2);
  1175.         let dragDistance = 0;
  1176.         let mouseDownTime = 0;
  1177.         let isHidden = false;
  1178.     
  1179.         function dragStart(e) {
  1180.             isDragging = true;
  1181.             dragDistance = 0;
  1182.             mouseDownTime = Date.now();
  1183.             const rect = floatingButton.getBoundingClientRect();
  1184.             startX = e.clientX - rect.left;
  1185.             startY = e.clientY - rect.top;
  1186.             floatingButton.style.transition = 'none';
  1187.             floatingButton.style.transform = 'scale(1)';
  1188.         }
  1189.     
  1190.         function drag(e) {
  1191.             if (!isDragging) return;
  1192.             e.preventDefault();
  1193.     
  1194.             const x = e.clientX - startX;
  1195.             const y = e.clientY - startY;
  1196.     
  1197.             // 计算拖动距离
  1198.             const dx = x - lastX;
  1199.             const dy = y - lastY;
  1200.             dragDistance += Math.sqrt(dx * dx + dy * dy);
  1201.     
  1202.             // 限制拖动范围，添加边距防止完全贴边
  1203.             const margin = 20; // 边距
  1204.             const maxX = window.innerWidth - floatingButton.offsetWidth - margin;
  1205.             const maxY = window.innerHeight - floatingButton.offsetHeight - margin;
  1206.             const minX = margin;
  1207.             const minY = margin;
  1208.     
  1209.             lastX = Math.max(minX, Math.min(x, maxX));
  1210.             lastY = Math.max(minY, Math.min(y, maxY));
  1211.     
  1212.             floatingButton.style.left = lastX + 'px';
  1213.             floatingButton.style.top = lastY + 'px';
  1214.             floatingButton.style.right = 'auto';
  1215.         }
  1216.     
  1217.         function dragEnd(e) {
  1218.             if (!isDragging) return;
  1219.     
  1220.             const dragDuration = Date.now() - mouseDownTime;
  1221.             isDragging = false;
  1222.             floatingButton.style.transition = 'all 0.3s ease';
  1223.     
  1224.             // 保存位置
  1225.             GM_setValue('floatingButtonX', lastX);
  1226.             GM_setValue('floatingButtonY', lastY);
  1227.     
  1228.             // 如果拖动距离小于5像素且时间小于200ms，则认为是点击
  1229.             if (dragDistance < 5 && dragDuration < 200) {
  1230.                 document.getElementById('config-modal').style.display = 'block';
  1231.                 document.getElementById('config-modal-overlay').style.display = 'block';
  1232.             }
  1233.         }
  1234.     
  1235.         function checkAndHideButton() {
  1236.             const threshold = 20; // 距离边缘多少像素时触发隐藏
  1237.             const buttonWidth = floatingButton.offsetWidth;
  1238.             const buttonHeight = floatingButton.offsetHeight;
  1239.             const buttonRight = lastX + buttonWidth;
  1240.             const buttonBottom = lastY + buttonHeight;
  1241.             const windowWidth = window.innerWidth;
  1242.             const windowHeight = window.innerHeight;
  1243.     
  1244.             // 检查各个边缘
  1245.             if (buttonRight > windowWidth - threshold) {
  1246.                 // 右边缘
  1247.                 hideButton('right');
  1248.             } else if (lastX < threshold) {
  1249.                 // 左边缘
  1250.                 hideButton('left');
  1251.             } else if (lastY < threshold) {
  1252.                 // 上边缘
  1253.                 hideButton('top');
  1254.             } else if (buttonBottom > windowHeight - threshold) {
  1255.                 // 下边缘
  1256.                 hideButton('bottom');
  1257.             }
  1258.         }
  1259.     
  1260.         function hideButton(direction) {
  1261.             isHidden = true;
  1262.             floatingButton.style.transition = 'all 0.3s ease';
  1263.     
  1264.             // 添加金光动画
  1265.             floatingButton.style.animation = 'none';
  1266.             floatingButton.offsetHeight; // 触发重绘
  1267.             floatingButton.style.animation = 'glowing 1.5s ease-in-out infinite';
  1268.             floatingButton.style.background = 'linear-gradient(135deg, #5a5a42 0%, #3a3a2c 100%)';
  1269.     
  1270.             switch (direction) {
  1271.                 case 'right':
  1272.                     floatingButton.style.transform = 'translateY(-50%) translateX(60%)';
  1273.                     floatingButton.style.borderRadius = '25px 0 0 25px';
  1274.                     break;
  1275.                 case 'left':
  1276.                     floatingButton.style.transform = 'translateY(-50%) translateX(-60%)';
  1277.                     floatingButton.style.borderRadius = '0 25px 25px 0';
  1278.                     break;
  1279.                 case 'top':
  1280.                     floatingButton.style.transform = 'translateX(-50%) translateY(-60%)';
  1281.                     floatingButton.style.borderRadius = '0 0 25px 25px';
  1282.                     break;
  1283.                 case 'bottom':
  1284.                     floatingButton.style.transform = 'translateX(-50%) translateY(60%)';
  1285.                     floatingButton.style.borderRadius = '25px 25px 0 0';
  1286.                     break;
  1287.             }
  1288.         }
  1289.     
  1290.         function showButton() {
  1291.             isHidden = false;
  1292.             floatingButton.style.transition = 'all 0.3s ease';
  1293.             floatingButton.style.animation = 'normalGlowing 2s ease-in-out infinite';
  1294.             floatingButton.style.background = 'linear-gradient(135deg, #3c3c28 0%, #2a2a1c 100%)';
  1295.             floatingButton.style.transform = 'scale(1)';
  1296.             floatingButton.style.borderRadius = '25px';
  1297.         }
  1298.     
  1299.         // 添加金光动画样式
  1300.         const glowingStyle = document.createElement('style');
  1301.         glowingStyle.textContent = `
  1302.             @keyframes normalGlowing {
  1303.                 0% {
  1304.                     box-shadow: 0 0 20px rgba(0,0,0,0.5),
  1305.                                 inset 0 0 8px rgba(255, 215, 0, 0.3),
  1306.                                 0 0 30px rgba(255, 215, 0, 0.2);
  1307.                     border-color: rgba(255, 215, 0, 0.4);
  1308.                     color: #ffd700;
  1309.                     text-shadow: 0 0 10px rgba(255, 215, 0, 0.6);
  1310.                 }
  1311.                 50% {
  1312.                     box-shadow: 0 0 25px rgba(0,0,0,0.5),
  1313.                                 inset 0 0 12px rgba(255, 215, 0, 0.4),
  1314.                                 0 0 40px rgba(255, 215, 0, 0.3),
  1315.                                 0 0 60px rgba(255, 215, 0, 0.2);
  1316.                     border-color: rgba(255, 215, 0, 0.5);
  1317.                     color: #ffe44d;
  1318.                     text-shadow: 0 0 15px rgba(255, 215, 0, 0.7);
  1319.                 }
  1320.                 100% {
  1321.                     box-shadow: 0 0 20px rgba(0,0,0,0.5),
  1322.                                 inset 0 0 8px rgba(255, 215, 0, 0.3),
  1323.                                 0 0 30px rgba(255, 215, 0, 0.2);
  1324.                     border-color: rgba(255, 215, 0, 0.4);
  1325.                     color: #ffd700;
  1326.                     text-shadow: 0 0 10px rgba(255, 215, 0, 0.6);
  1327.                 }
  1328.             }
  1329.     
  1330.             @keyframes glowing {
  1331.                 0% {
  1332.                     box-shadow: 0 0 20px rgba(0,0,0,0.5),
  1333.                                 inset 0 0 8px rgba(255, 215, 0, 0.5),
  1334.                                 0 0 30px rgba(255, 215, 0, 0.4),
  1335.                                 0 0 50px rgba(255, 215, 0, 0.2);
  1336.                     border-color: rgba(255, 215, 0, 0.6);
  1337.                     color: #ffd700;
  1338.                     text-shadow: 0 0 15px rgba(255, 215, 0, 0.8);
  1339.                 }
  1340.                 50% {
  1341.                     box-shadow: 0 0 30px rgba(0,0,0,0.6),
  1342.                                 inset 0 0 20px rgba(255, 215, 0, 0.8),
  1343.                                 0 0 60px rgba(255, 215, 0, 0.6),
  1344.                                 0 0 100px rgba(255, 215, 0, 0.4),
  1345.                                 0 0 150px rgba(255, 215, 0, 0.2);
  1346.                     border-color: rgba(255, 223, 0, 1);
  1347.                     color: #ffe44d;
  1348.                     text-shadow: 0 0 25px rgba(255, 215, 0, 1),
  1349.                                 0 0 35px rgba(255, 215, 0, 0.7),
  1350.                                 0 0 45px rgba(255, 215, 0, 0.4);
  1351.                 }
  1352.                 100% {
  1353.                     box-shadow: 0 0 20px rgba(0,0,0,0.5),
  1354.                                 inset 0 0 8px rgba(255, 215, 0, 0.5),
  1355.                                 0 0 30px rgba(255, 215, 0, 0.4),
  1356.                                 0 0 50px rgba(255, 215, 0, 0.2);
  1357.                     border-color: rgba(255, 215, 0, 0.6);
  1358.                     color: #ffd700;
  1359.                     text-shadow: 0 0 15px rgba(255, 215, 0, 0.8);
  1360.                 }
  1361.             }
  1362.         `;
  1363.         document.head.appendChild(glowingStyle);
  1364.     
  1365.         // 监听窗口大小变化
  1366.         window.addEventListener('resize', () => {
  1367.             if (!isDragging) {
  1368.                 const margin = 20;
  1369.                 const maxX = window.innerWidth - floatingButton.offsetWidth - margin;
  1370.                 const maxY = window.innerHeight - floatingButton.offsetHeight - margin;
  1371.                 const minX = margin;
  1372.                 const minY = margin;
  1373.     
  1374.                 lastX = Math.max(minX, Math.min(lastX, maxX));
  1375.                 lastY = Math.max(minY, Math.min(lastY, maxY));
  1376.     
  1377.                 floatingButton.style.left = lastX + 'px';
  1378.                 floatingButton.style.top = lastY + 'px';
  1379.             }
  1380.         });
  1381.     
  1382.         floatingButton.addEventListener('mousedown', dragStart);
  1383.         document.addEventListener('mousemove', drag);
  1384.         document.addEventListener('mouseup', dragEnd);
  1385.     
  1386.         // 恢复上次保存的位置或使用默认位置
  1387.         const margin = 20;
  1388.         const maxX = window.innerWidth - 70 - margin;
  1389.         const maxY = window.innerHeight / 2;
  1390.         const minX = margin;
  1391.         const minY = margin;
  1392.     
  1393.         lastX = Math.max(minX, Math.min(GM_getValue('floatingButtonX', maxX), maxX));
  1394.         lastY = Math.max(minY, Math.min(GM_getValue('floatingButtonY', maxY), maxY));
  1395.     
  1396.         floatingButton.style.right = 'auto';
  1397.         floatingButton.style.top = lastY + 'px';
  1398.         floatingButton.style.left = lastX + 'px';
  1399.         floatingButton.style.transform = 'scale(1)';
  1400.         floatingButton.style.transform = 'scale(1)';
  1401.     
  1402.         return floatingButton;
  1403.     }
  1404.     
  1405.     function createControls() {
  1406.         const floatingButton = createConfigButton();
  1407.         document.body.appendChild(floatingButton);
  1408.  
  1409.         // 创建搜索框但不立即显示
  1410.         createSearchBox();
  1411.  
  1412.         // 添加快捷键监听
  1413.         document.addEventListener('keydown', (e) => {
  1414.             if (e.altKey && !e.ctrlKey && !e.shiftKey && e.key.toLowerCase() === 'f') {
  1415.                 e.preventDefault(); // 阻止默认行为
  1416.                 toggleSearchBox();
  1417.             }
  1418.         });
  1419.     }
  1420.  
  1421.     // 切换搜索框显示状态
  1422.     function toggleSearchBox() {
  1423.         const searchBox = document.querySelector('.search-box-container');
  1424.         if (searchBox) {
  1425.             searchBox.style.display = searchBox.style.display === 'none' ? 'flex' : 'none';
  1426.             if (searchBox.style.display === 'flex') {
  1427.                 // 当显示搜索框时，自动聚焦到输入框
  1428.                 const searchInput = searchBox.querySelector('input');
  1429.                 if (searchInput) {
  1430.                     searchInput.focus();
  1431.                 }
  1432.             }
  1433.         }
  1434.     }
  1435.  
  1436.     // 创建搜索框
  1437.     function createSearchBox(handleInput) {
  1438.         const searchBoxContainer = document.createElement('div');
  1439.         searchBoxContainer.className = 'search-box-container';
  1440.         searchBoxContainer.style.cssText = `
  1441.             position: fixed;
  1442.             top: 10px;
  1443.             left: 20px;
  1444.             z-index: 9999;
  1445.             background: rgba(28, 28, 28, 0.95);
  1446.             padding: 15px 10px 10px;
  1447.             border-radius: 8px;
  1448.             box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
  1449.             border: 1px solid #444;
  1450.             display: none;
  1451.             flex-direction: column;
  1452.             gap: 8px;
  1453.         `;
  1454.  
  1455.         const searchRow = document.createElement('div');
  1456.         searchRow.style.cssText = `
  1457.             display: flex;
  1458.             gap: 8px;
  1459.             align-items: center;
  1460.         `;
  1461.  
  1462.         const navigationRow = document.createElement('div');
  1463.         navigationRow.style.cssText = `
  1464.             display: flex;
  1465.             gap: 8px;
  1466.             align-items: center;
  1467.         `;
  1468.  
  1469.         // 创建搜索输入框
  1470.         const searchInput = document.createElement('input');
  1471.         searchInput.type = 'text';
  1472.         searchInput.placeholder = '输入关键词(用;分隔)';
  1473.         searchInput.dataset.isSearchInput = 'true';
  1474.         searchInput.style.cssText = `
  1475.             width: 250px;
  1476.             padding: 5px 10px;
  1477.             border: 1px solid #666;
  1478.             border-radius: 4px;
  1479.             background: #2d2d2d;
  1480.             color: #fff;
  1481.         `;
  1482.  
  1483.         // 添加搜索事件
  1484.         searchInput.addEventListener('input', (e) => {
  1485.             if (!e?.target?.value) return;
  1486.  
  1487.             // 如果页面是繁体模式，则将输入转换为繁体
  1488.             if (!STATE.pageSimplified) {
  1489.                 const cursorPosition = e.target.selectionStart;
  1490.                 const text = e.target.value;
  1491.  
  1492.                 requestAnimationFrame(() => {
  1493.                     try {
  1494.                         const convertedText = window.converter.toTraditional(text);
  1495.                         if (text === convertedText) return;
  1496.  
  1497.                         e.target.value = convertedText;
  1498.  
  1499.                         if (typeof cursorPosition === 'number') {
  1500.                             e.target.setSelectionRange(cursorPosition, cursorPosition);
  1501.                         }
  1502.                     } catch (error) {}
  1503.                 });
  1504.             }
  1505.         });
  1506.  
  1507.         const searchButton = document.createElement('button');
  1508.         searchButton.textContent = '搜索';
  1509.         searchButton.style.cssText = `
  1510.             padding: 5px 15px;
  1511.             background: #4a90e2;
  1512.             border: none;
  1513.             border-radius: 4px;
  1514.             color: #fff;
  1515.             cursor: pointer;
  1516.             transition: background 0.2s;
  1517.         `;
  1518.  
  1519.         // 添加预设下拉框
  1520.         const presetSelectContainer = document.createElement('div');
  1521.         presetSelectContainer.style.cssText = `
  1522.             position: relative;
  1523.             width: 120px;
  1524.         `;
  1525.  
  1526.         const presetInput = document.createElement('input');
  1527.         presetInput.readOnly = true;
  1528.         presetInput.placeholder = '选择预设';
  1529.         presetInput.style.cssText = `
  1530.             width: 100%;
  1531.             padding: 5px;
  1532.             background: #2d2d2d;
  1533.             border: 1px solid #666;
  1534.             border-radius: 4px;
  1535.             color: #fff;
  1536.             cursor: pointer;
  1537.         `;
  1538.  
  1539.         // 修改预设选择框的样式
  1540.         const presetDropdown = document.createElement('div');
  1541.         presetDropdown.style.cssText = `
  1542.             display: none;
  1543.             position: absolute;
  1544.             top: 100%;
  1545.             left: 0;
  1546.             width: 200px;
  1547.             max-height: 300px;
  1548.             overflow-y: auto;
  1549.             background: #2d2d2d;
  1550.             border: 1px solid #666;
  1551.             border-radius: 4px;
  1552.             z-index: 10000;
  1553.             margin-top: 4px;
  1554.             padding-top: 30px; // 为搜索框留出空间
  1555.             color: #fff; // 添加默认文字颜色
  1556.         `;
  1557.  
  1558.         // 添加预设搜索框
  1559.         const presetSearchInput = document.createElement('input');
  1560.         presetSearchInput.type = 'text';
  1561.         presetSearchInput.placeholder = '搜索预设...';
  1562.         presetSearchInput.style.cssText = `
  1563.             position: absolute;
  1564.             top: 0;
  1565.             left: 0;
  1566.             width: calc(100% - 16px);
  1567.             margin: 8px;
  1568.             padding: 4px 8px;
  1569.             background: #3d3d3d;
  1570.             border: 1px solid #666;
  1571.             border-radius: 3px;
  1572.             color: #fff;
  1573.             font-size: 12px;
  1574.         `;
  1575.  
  1576.         // 阻止搜索框的点击事件冒泡，避免关闭下拉框
  1577.         presetSearchInput.addEventListener('click', (e) => {
  1578.             e.stopPropagation();
  1579.         });
  1580.  
  1581.         // 添加搜索框的输入事件
  1582.         presetSearchInput.addEventListener('input', (e) => {
  1583.             const searchText = e.target.value.toLowerCase();
  1584.             const options = presetDropdown.querySelectorAll('.preset-option');
  1585.             options.forEach(option => {
  1586.                 const name = option.querySelector('span').textContent.toLowerCase();
  1587.                 if (name.includes(searchText)) {
  1588.                     option.style.display = '';
  1589.                 } else {
  1590.                     option.style.display = 'none';
  1591.                 }
  1592.             });
  1593.         });
  1594.  
  1595.         presetDropdown.appendChild(presetSearchInput);
  1596.  
  1597.         // 添加滚动条样式
  1598.         const styleSheet = document.createElement('style');
  1599.         styleSheet.textContent = `
  1600.             .preset-dropdown::-webkit-scrollbar {
  1601.                 width: 8px;
  1602.             }
  1603.             .preset-dropdown::-webkit-scrollbar-track {
  1604.                 background: #1a1a1a;
  1605.             }
  1606.             .preset-dropdown::-webkit-scrollbar-thumb {
  1607.                 background: #444;
  1608.                 border-radius: 4px;
  1609.             }
  1610.             .preset-dropdown::-webkit-scrollbar-thumb:hover {
  1611.                 background: #555;
  1612.             }
  1613.         `;
  1614.         document.head.appendChild(styleSheet);
  1615.  
  1616.         let selectedPresets = new Set();
  1617.  
  1618.         // 修改预设选项的样式
  1619.         function updatePresetOptions() {
  1620.             // 保留搜索框
  1621.             presetDropdown.innerHTML = '';
  1622.             presetDropdown.appendChild(presetSearchInput);
  1623.             presetSearchInput.value = ''; // 清空搜索框
  1624.  
  1625.             // 创建分隔线
  1626.             const createDivider = () => {
  1627.                 const divider = document.createElement('div');
  1628.                 divider.style.cssText = `
  1629.                     height: 1px;
  1630.                     background: #666;
  1631.                     margin: 5px 0;
  1632.                 `;
  1633.                 return divider;
  1634.             };
  1635.  
  1636.             // 创建预设选项
  1637.             const createPresetOption = (name, keywords, isSelected) => {
  1638.                 const option = document.createElement('div');
  1639.                 option.className = 'preset-option'; // 添加类名以便搜索
  1640.                 option.style.cssText = `
  1641.                     padding: 6px 10px;
  1642.                     cursor: pointer;
  1643.                     display: flex;
  1644.                     align-items: center;
  1645.                     gap: 8px;
  1646.                     transition: all 0.2s;
  1647.                     color: #fff;
  1648.                     ${isSelected ? 'background: #2a4a6d;' : ''}
  1649.                 `;
  1650.  
  1651.                 const checkbox = document.createElement('input');
  1652.                 checkbox.type = 'checkbox';
  1653.                 checkbox.checked = isSelected;
  1654.                 checkbox.style.cssText = `
  1655.                     margin: 0;
  1656.                     cursor: pointer;
  1657.                 `;
  1658.  
  1659.                 const label = document.createElement('span');
  1660.                 label.textContent = name;
  1661.                 label.style.cssText = `
  1662.                     flex: 1;
  1663.                     overflow: hidden;
  1664.                     text-overflow: ellipsis;
  1665.                     white-space: nowrap;
  1666.                     color: #fff;
  1667.                 `;
  1668.  
  1669.                 option.appendChild(checkbox);
  1670.                 option.appendChild(label);
  1671.  
  1672.                 option.addEventListener('mouseover', () => {
  1673.                     option.style.backgroundColor = isSelected ? '#2a5a8d' : '#3d3d3d';
  1674.                 });
  1675.  
  1676.                 option.addEventListener('mouseout', () => {
  1677.                     option.style.backgroundColor = isSelected ? '#2a4a6d' : 'transparent';
  1678.                 });
  1679.  
  1680.                 option.addEventListener('click', (e) => {
  1681.                     e.stopPropagation();
  1682.                     checkbox.checked = !checkbox.checked;
  1683.                     if (checkbox.checked) {
  1684.                         selectedPresets.add(name);
  1685.                     } else {
  1686.                         selectedPresets.delete(name);
  1687.                     }
  1688.                     updateSelectedPresets();
  1689.                     // 重新渲染预设列表以更新顺序
  1690.                     updatePresetOptions();
  1691.                 });
  1692.  
  1693.                 return option;
  1694.             };
  1695.  
  1696.             // 获取所有预设并分类
  1697.             const selectedOptions = [];
  1698.             const unselectedOptions = [];
  1699.             
  1700.             Object.entries(STATE.searchPresets).forEach(([name, keywords]) => {
  1701.                 const isSelected = selectedPresets.has(name);
  1702.                 const option = createPresetOption(name, keywords, isSelected);
  1703.                 
  1704.                 if (isSelected) {
  1705.                     selectedOptions.push(option);
  1706.                 } else {
  1707.                     unselectedOptions.push(option);
  1708.                 }
  1709.             });
  1710.  
  1711.             // 添加已选择的预设
  1712.             if (selectedOptions.length > 0) {
  1713.                 const selectedTitle = document.createElement('div');
  1714.                 selectedTitle.style.cssText = `
  1715.                     padding: 5px 10px;
  1716.                     color: #999;
  1717.                     font-size: 12px;
  1718.                     background: #262626;
  1719.                 `;
  1720.                 selectedTitle.textContent = '已选择的预设';
  1721.                 presetDropdown.appendChild(selectedTitle);
  1722.                 
  1723.                 selectedOptions.forEach(option => presetDropdown.appendChild(option));
  1724.             }
  1725.  
  1726.             // 添加未选择的预设
  1727.             if (selectedOptions.length > 0 && unselectedOptions.length > 0) {
  1728.                 presetDropdown.appendChild(createDivider());
  1729.             }
  1730.  
  1731.             if (unselectedOptions.length > 0) {
  1732.                 if (selectedOptions.length > 0) {
  1733.                     const unselectedTitle = document.createElement('div');
  1734.                     unselectedTitle.style.cssText = `
  1735.                         padding: 5px 10px;
  1736.                         color: #999;
  1737.                         font-size: 12px;
  1738.                         background: #262626;
  1739.                     `;
  1740.                     unselectedTitle.textContent = '未选择的预设';
  1741.                     presetDropdown.appendChild(unselectedTitle);
  1742.                 }
  1743.                 
  1744.                 unselectedOptions.forEach(option => presetDropdown.appendChild(option));
  1745.             }
  1746.         }
  1747.  
  1748.         function updateSelectedPresets() {
  1749.             if (selectedPresets.size === 0) {
  1750.                 presetInput.value = '';
  1751.                 presetInput.placeholder = '选择预设';
  1752.             } else {
  1753.                 const names = Array.from(selectedPresets).join(', ');
  1754.                 presetInput.value = names;
  1755.                 presetInput.placeholder = '';
  1756.             }
  1757.         }
  1758.  
  1759.         function applySelectedPresets() {
  1760.             if (selectedPresets.size === 0) return;
  1761.  
  1762.             const keywords = Array.from(selectedPresets)
  1763.                 .map(name => STATE.searchPresets[name])
  1764.                 .join(';');
  1765.  
  1766.             searchInput.value = keywords;
  1767.  
  1768.             // 手动触发输入转换
  1769.             if (!STATE.pageSimplified) {
  1770.                 try {
  1771.                     const convertedText = window.converter.toTraditional(keywords);
  1772.                     if (keywords !== convertedText) {
  1773.                         searchInput.value = convertedText;
  1774.                     }
  1775.                 } catch (error) {}
  1776.             }
  1777.  
  1778.             // 触发搜索
  1779.             performSearch();
  1780.             // 清空选择
  1781.             selectedPresets.clear();
  1782.             updateSelectedPresets();
  1783.         }
  1784.  
  1785.         // 点击输入框时显示/隐藏下拉框
  1786.         presetInput.addEventListener('click', (e) => {
  1787.             e.stopPropagation();
  1788.             const isVisible = presetDropdown.style.display === 'block';
  1789.             presetDropdown.style.display = isVisible ? 'none' : 'block';
  1790.             if (!isVisible) {
  1791.                 updatePresetOptions();
  1792.                 // 聚焦搜索框
  1793.                 setTimeout(() => {
  1794.                     presetSearchInput.focus();
  1795.                 }, 0);
  1796.             }
  1797.         });
  1798.  
  1799.         // 点击其他地方时隐藏下拉框
  1800.         document.addEventListener('click', () => {
  1801.             presetDropdown.style.display = 'none';
  1802.         });
  1803.  
  1804.         // 添加搜索事件
  1805.         const performSearch = () => {
  1806.             // 获取所有预设关键词
  1807.             const presetKeywords = Array.from(selectedPresets)
  1808.                 .map(name => STATE.searchPresets[name])
  1809.                 .join(';');
  1810.  
  1811.             // 获取输入框关键词
  1812.             const inputKeywords = searchInput.value.trim();
  1813.  
  1814.             // 合并关键词
  1815.             const combinedKeywords = [presetKeywords, inputKeywords]
  1816.                 .filter(k => k) // 过滤掉空字符串
  1817.                 .join(';');
  1818.  
  1819.             // 如果页面是繁体模式，则将关键词转换为繁体
  1820.             let searchKeywords = combinedKeywords;
  1821.             if (!STATE.pageSimplified) {
  1822.                 try {
  1823.                     searchKeywords = window.converter.toTraditional(combinedKeywords);
  1824.                 } catch (error) {
  1825.                     console.error('转换繁体失败:', error);
  1826.                 }
  1827.             }
  1828.  
  1829.             // 使用;或;作为分隔符
  1830.             const keywords = searchKeywords.toLowerCase().split(/[;；]/);
  1831.             // 过滤掉空字符串
  1832.             const filteredKeywords = keywords.filter(k => k.trim());
  1833.             
  1834.             if (!filteredKeywords.length) {
  1835.                 clearHighlights();
  1836.                 matchCounter.textContent = '';
  1837.                 return;
  1838.             }
  1839.             searchAndHighlight(filteredKeywords, matchCounter);
  1840.         };
  1841.  
  1842.         searchInput.addEventListener('keyup', (e) => {
  1843.             if (e.key === 'Enter') {
  1844.                 performSearch();
  1845.             }
  1846.         });
  1847.  
  1848.         searchButton.addEventListener('click', performSearch);
  1849.  
  1850.         // 添加导航按钮
  1851.         const prevButton = document.createElement('button');
  1852.         prevButton.textContent = '上一个';
  1853.         prevButton.style.cssText = `
  1854.             padding: 5px 15px;
  1855.             background: #2d2d2d;
  1856.             border: 1px solid #666;
  1857.             border-radius: 4px;
  1858.             color: #fff;
  1859.             cursor: pointer;
  1860.             transition: background 0.2s;
  1861.             flex: 1;
  1862.         `;
  1863.  
  1864.         const nextButton = document.createElement('button');
  1865.         nextButton.textContent = '下一个';
  1866.         nextButton.style.cssText = `
  1867.             padding: 5px 15px;
  1868.             background: #2d2d2d;
  1869.             border: 1px solid #666;
  1870.             border-radius: 4px;
  1871.             color: #fff;
  1872.             cursor: pointer;
  1873.             transition: background 0.2s;
  1874.             flex: 1;
  1875.         `;
  1876.  
  1877.         const matchCounter = document.createElement('span');
  1878.         matchCounter.className = 'search-counter';
  1879.         matchCounter.style.cssText = `
  1880.             color: #fff;
  1881.             font-size: 12px;
  1882.             padding: 0 10px;
  1883.             min-width: 60px;
  1884.             text-align: center;
  1885.         `;
  1886.  
  1887.         // 添加导航事件
  1888.         prevButton.addEventListener('click', () => {
  1889.             navigateHighlight('prev');
  1890.         });
  1891.  
  1892.         nextButton.addEventListener('click', () => {
  1893.             navigateHighlight('next');
  1894.         });
  1895.  
  1896.         // 添加hover效果
  1897.         [searchButton, prevButton, nextButton].forEach(button => {
  1898.             button.addEventListener('mouseover', () => {
  1899.                 button.style.background = button === searchButton ? '#357abd' : '#3d3d3d';
  1900.             });
  1901.             button.addEventListener('mouseout', () => {
  1902.                 button.style.background = button === searchButton ? '#4a90e2' : '#2d2d2d';
  1903.             });
  1904.         });
  1905.  
  1906.         // 组装界面
  1907.         presetSelectContainer.appendChild(presetInput);
  1908.         presetSelectContainer.appendChild(presetDropdown);
  1909.  
  1910.         searchRow.appendChild(presetSelectContainer);
  1911.         searchRow.appendChild(searchInput);
  1912.         searchRow.appendChild(searchButton);
  1913.  
  1914.         navigationRow.appendChild(prevButton);
  1915.         navigationRow.appendChild(matchCounter);
  1916.         navigationRow.appendChild(nextButton);
  1917.  
  1918.         searchBoxContainer.appendChild(searchRow);
  1919.         searchBoxContainer.appendChild(navigationRow);
  1920.  
  1921.         // 添加选项行
  1922.         const optionsRow = document.createElement('div');
  1923.         optionsRow.style.cssText = `
  1924.             display: flex;
  1925.             gap: 8px;
  1926.             align-items: center;
  1927.             padding: 0 5px;
  1928.         `;
  1929.  
  1930.         const showOnlyMatchedLabel = document.createElement('label');
  1931.         showOnlyMatchedLabel.style.cssText = `
  1932.             display: flex;
  1933.             align-items: center;
  1934.             gap: 5px;
  1935.             color: #fff;
  1936.             font-size: 12px;
  1937.             cursor: pointer;
  1938.         `;
  1939.  
  1940.         const showOnlyMatchedCheckbox = document.createElement('input');
  1941.         showOnlyMatchedCheckbox.type = 'checkbox';
  1942.         showOnlyMatchedCheckbox.checked = STATE.showOnlyMatched;
  1943.         showOnlyMatchedCheckbox.style.cssText = `
  1944.             margin: 0;
  1945.             cursor: pointer;
  1946.         `;
  1947.  
  1948.         showOnlyMatchedLabel.appendChild(showOnlyMatchedCheckbox);
  1949.         showOnlyMatchedLabel.appendChild(document.createTextNode('只显示匹配项'));
  1950.  
  1951.         showOnlyMatchedCheckbox.addEventListener('change', (e) => {
  1952.             STATE.showOnlyMatched = e.target.checked;
  1953.             GM_setValue('showOnlyMatched', STATE.showOnlyMatched);
  1954.             if (STATE.matchedCards.length > 0) {
  1955.                 updateCardVisibility();
  1956.             }
  1957.         });
  1958.  
  1959.         optionsRow.appendChild(showOnlyMatchedLabel);
  1960.         searchBoxContainer.insertBefore(optionsRow, navigationRow);
  1961.  
  1962.         document.body.appendChild(searchBoxContainer);
  1963.  
  1964.         // 添加关闭按钮
  1965.         const closeButton = document.createElement('button');
  1966.         closeButton.textContent = '×';
  1967.         closeButton.style.cssText = `
  1968.             position: absolute;
  1969.             top: -10px;
  1970.             right: -10px;
  1971.             width: 20px;
  1972.             height: 20px;
  1973.             line-height: 1;
  1974.             padding: 0;
  1975.             background: #2d2d2d;
  1976.             border: 1px solid #666;
  1977.             border-radius: 50%;
  1978.             color: #999;
  1979.             font-size: 16px;
  1980.             font-weight: bold;
  1981.             cursor: pointer;
  1982.             display: flex;
  1983.             align-items: center;
  1984.             justify-content: center;
  1985.             transition: all 0.2s;
  1986.             z-index: 10000;
  1987.             box-shadow: 0 0 5px rgba(0, 0, 0, 0.3);
  1988.         `;
  1989.  
  1990.         closeButton.addEventListener('mouseover', () => {
  1991.             closeButton.style.color = '#fff';
  1992.             closeButton.style.background = '#3d3d3d';
  1993.             closeButton.style.borderColor = '#999';
  1994.         });
  1995.  
  1996.         closeButton.addEventListener('mouseout', () => {
  1997.             closeButton.style.color = '#999';
  1998.             closeButton.style.background = '#2d2d2d';
  1999.             closeButton.style.borderColor = '#666';
  2000.         });
  2001.  
  2002.         closeButton.addEventListener('click', () => {
  2003.             searchBoxContainer.style.display = 'none';
  2004.             clearHighlights();
  2005.             searchInput.value = '';
  2006.             matchCounter.textContent = '';
  2007.             // 不清除选择的预设
  2008.         });
  2009.  
  2010.         searchBoxContainer.insertBefore(closeButton, searchBoxContainer.firstChild);
  2011.  
  2012.         // 添加键盘快捷键
  2013.         document.addEventListener('keydown', (e) => {
  2014.             if (e.key === 'F3' || (e.ctrlKey && e.key === 'g')) {
  2015.                 e.preventDefault();
  2016.                 if (e.shiftKey) {
  2017.                     navigateHighlight('prev');
  2018.                 } else {
  2019.                     navigateHighlight('next');
  2020.                 }
  2021.             }
  2022.         });
  2023.  
  2024.         // 在搜索框显示时更新预设选项
  2025.         const originalToggleSearchBox = toggleSearchBox;
  2026.         toggleSearchBox = function() {
  2027.             const searchBox = document.querySelector('.search-box-container');
  2028.             if (searchBox) {
  2029.                 const isCurrentlyHidden = searchBox.style.display === 'none';
  2030.                 if (isCurrentlyHidden) {
  2031.                     updatePresetOptions();
  2032.                     // 不清除选择的预设
  2033.                     updateSelectedPresets();
  2034.                 }
  2035.                 searchBox.style.display = isCurrentlyHidden ? 'flex' : 'none';
  2036.                 if (isCurrentlyHidden) {
  2037.                     const searchInput = searchBox.querySelector('input[type="text"]');
  2038.                     if (searchInput) {
  2039.                         searchInput.focus();
  2040.                     }
  2041.                 }
  2042.             }
  2043.         };
  2044.  
  2045.         return updatePresetOptions;
  2046.     }
  2047.  
  2048.     // 清除所有高亮
  2049.     function clearHighlights() {
  2050.         const highlights = document.querySelectorAll('.st-highlight');
  2051.         highlights.forEach(highlight => {
  2052.             const parent = highlight.parentNode;
  2053.             parent.replaceChild(document.createTextNode(highlight.textContent), highlight);
  2054.         });
  2055.  
  2056.         // 清除所有高亮样式
  2057.         document.querySelectorAll('.current-highlight, .matched-card').forEach(card => {
  2058.             card.classList.remove('current-highlight', 'matched-card');
  2059.         });
  2060.  
  2061.         // 重置导航状态
  2062.         STATE.matchedCards = [];
  2063.         STATE.currentMatchIndex = -1;
  2064.  
  2065.         // 恢复所有卡片的可见性
  2066.         const allCards = document.querySelectorAll('.row[data-id]');
  2067.         allCards.forEach(card => {
  2068.             card.style.display = '';
  2069.         });
  2070.     }
  2071.  
  2072.     // 修改 searchAndHighlight 函数中的关键词处理部分
  2073.     function escapeRegExp(string) {
  2074.         return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  2075.     }
  2076.  
  2077.     function searchAndHighlight(keywords, matchCounter) {
  2078.         clearHighlights();
  2079.  
  2080.         const itemCards = document.querySelectorAll('.row[data-id]');
  2081.         STATE.matchedCards = [];
  2082.         let hasMatch = false;
  2083.  
  2084.         // 预处理关键词，处理特殊字符和通配符
  2085.         const processedKeywords = keywords.map(keyword => {
  2086.             keyword = keyword.trim();
  2087.             
  2088.             // 处理带条件的通配符
  2089.             // 匹配模式：(&>2) 或 (&>=2) 或 (&<2) 或 (&<=2) 或 (&=2)
  2090.             // 或带加号的版本：+(&>2) 等
  2091.             const conditionalPattern = /(\(?&(>=|<=|>|<|=)(\d+)\)?)/;
  2092.             if (conditionalPattern.test(keyword)) {
  2093.                 const match = keyword.match(conditionalPattern);
  2094.                 const fullMatch = match[0];
  2095.                 const operator = match[2];
  2096.                 const targetNum = parseInt(match[3]);
  2097.                 
  2098.                 // 将关键词分成前后两部分
  2099.                 const [before, after] = keyword.split(fullMatch);
  2100.                 
  2101.                 // 构建正则表达式和验证函数
  2102.                 const numPattern = '(\\d+)';
  2103.                 const beforePattern = before ? escapeRegExp(before) : '';
  2104.                 const afterPattern = after ? escapeRegExp(after) : '';
  2105.                 
  2106.                 return {
  2107.                     pattern: beforePattern + numPattern + afterPattern,
  2108.                     validate: (foundNum) => {
  2109.                         const num = parseInt(foundNum);
  2110.                         switch(operator) {
  2111.                             case '>': return num > targetNum;
  2112.                             case '>=': return num >= targetNum;
  2113.                             case '<': return num < targetNum;
  2114.                             case '<=': return num <= targetNum;
  2115.                             case '=': return num === targetNum;
  2116.                             default: return false;
  2117.                         }
  2118.                     }
  2119.                 };
  2120.             }
  2121.             
  2122.             // 处理简单通配符
  2123.             if (keyword.includes('&')) {
  2124.                 // 处理带加号的通配符
  2125.                 if (keyword.includes('+&')) {
  2126.                     keyword = escapeRegExp(keyword).replace(/\\\+&/g, '\\+[0-9]+');
  2127.                 } else {
  2128.                     // 处理不带加号的通配符
  2129.                     keyword = escapeRegExp(keyword).replace(/&/g, '[0-9]+');
  2130.                 }
  2131.             } else {
  2132.                 // 处理其他特殊字符
  2133.                 keyword = escapeRegExp(keyword).replace(/\\\+/g, '[+＋]');
  2134.             }
  2135.             
  2136.             return { pattern: keyword };
  2137.         }).filter(k => k);
  2138.  
  2139.         itemCards.forEach(card => {
  2140.             const cardText = card.textContent;
  2141.             const matches = processedKeywords.map(keyword => {
  2142.                 if (!keyword.validate) {
  2143.                     // 简单模式匹配
  2144.                     const regex = new RegExp(keyword.pattern, 'i');
  2145.                     return regex.test(cardText);
  2146.                 } else {
  2147.                     // 条件模式匹配
  2148.                     const regex = new RegExp(keyword.pattern, 'i');
  2149.                     const match = cardText.match(regex);
  2150.                     if (!match) return false;
  2151.                     
  2152.                     // 提取数字并验证条件
  2153.                     const foundNum = match[1];
  2154.                     return keyword.validate(foundNum);
  2155.                 }
  2156.             });
  2157.             const allMatch = matches.every(match => match);
  2158.  
  2159.             if (allMatch) {
  2160.                 hasMatch = true;
  2161.                 STATE.matchedCards.push(card);
  2162.                 highlightKeywords(card, processedKeywords.map(k => k.pattern));
  2163.             } else if (STATE.showOnlyMatched) {
  2164.                 card.style.display = 'none';
  2165.             }
  2166.         });
  2167.  
  2168.         if (!hasMatch) {
  2169.             alert('未找到匹配的结果');
  2170.             if (matchCounter) {
  2171.                 matchCounter.textContent = '0/0';
  2172.             }
  2173.         } else {
  2174.             STATE.currentMatchIndex = 0;
  2175.             updateHighlightNavigation();
  2176.             updateCardVisibility();
  2177.         }
  2178.     }
  2179.  
  2180.     // 修改 highlightKeywords 函数
  2181.     function highlightKeywords(element, patterns) {
  2182.         const walker = document.createTreeWalker(
  2183.             element,
  2184.             NodeFilter.SHOW_TEXT,
  2185.             {
  2186.                 acceptNode: function(node) {
  2187.                     if (node.parentNode.nodeName === 'SCRIPT' ||
  2188.                         node.parentNode.nodeName === 'STYLE' ||
  2189.                         node.parentNode.classList.contains('st-highlight')) {
  2190.                         return NodeFilter.FILTER_REJECT;
  2191.                     }
  2192.  
  2193.                     const text = node.textContent;
  2194.                     const containsAnyKeyword = patterns.some(pattern => {
  2195.                         const regex = new RegExp(pattern, 'i');
  2196.                         return regex.test(text);
  2197.                     });
  2198.  
  2199.                     return containsAnyKeyword ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
  2200.                 }
  2201.             }
  2202.         );
  2203.  
  2204.         const nodes = [];
  2205.         let node;
  2206.         while (node = walker.nextNode()) {
  2207.             nodes.push(node);
  2208.         }
  2209.  
  2210.         nodes.forEach(textNode => {
  2211.             let text = textNode.textContent;
  2212.             let tempText = text;
  2213.  
  2214.             patterns.forEach(pattern => {
  2215.                 const regex = new RegExp(`(${pattern})`, 'gi');
  2216.                 if (regex.test(text)) {
  2217.                     tempText = tempText.replace(regex, (match) => {
  2218.                         return `<span class="st-highlight">${match}</span>`;
  2219.                     });
  2220.                 }
  2221.             });
  2222.  
  2223.             if (tempText !== text) {
  2224.                 const tempDiv = document.createElement('div');
  2225.                 tempDiv.innerHTML = tempText;
  2226.                 const fragment = document.createDocumentFragment();
  2227.                 while (tempDiv.firstChild) {
  2228.                     fragment.appendChild(tempDiv.firstChild);
  2229.                 }
  2230.                 textNode.parentNode.replaceChild(fragment, textNode);
  2231.             }
  2232.         });
  2233.     }
  2234.  
  2235.     // 更新高亮导航
  2236.     function updateHighlightNavigation() {
  2237.         const matchCounter = document.querySelector('.search-counter');
  2238.         if (!matchCounter) return;
  2239.  
  2240.         // 更新计数器
  2241.         matchCounter.textContent = `${STATE.currentMatchIndex + 1}/${STATE.matchedCards.length}`;
  2242.  
  2243.         // 移除之前的当前高亮
  2244.         document.querySelectorAll('.current-highlight, .matched-card').forEach(card => {
  2245.             card.classList.remove('current-highlight', 'matched-card');
  2246.         });
  2247.  
  2248.         // 添加新的当前高亮
  2249.         const currentCard = STATE.matchedCards[STATE.currentMatchIndex];
  2250.         if (currentCard) {
  2251.             currentCard.classList.add('current-highlight');
  2252.             // 滚动到当前卡片
  2253.             currentCard.scrollIntoView({
  2254.                 behavior: 'smooth',
  2255.                 block: 'center'
  2256.             });
  2257.         }
  2258.     }
  2259.  
  2260.     // 导航到上一个/下一个高亮
  2261.     function navigateHighlight(direction) {
  2262.         if (STATE.matchedCards.length === 0) return;
  2263.  
  2264.         if (direction === 'next') {
  2265.             STATE.currentMatchIndex = (STATE.currentMatchIndex + 1) % STATE.matchedCards.length;
  2266.         } else {
  2267.             STATE.currentMatchIndex = (STATE.currentMatchIndex - 1 + STATE.matchedCards.length) % STATE.matchedCards.length;
  2268.         }
  2269.  
  2270.         updateHighlightNavigation();
  2271.     }
  2272.  
  2273.     // 修改样式
  2274.     const style = document.createElement('style');
  2275.     style.textContent = `
  2276.         .current-highlight {
  2277.             background-color: rgba(255, 215, 0, 0.3) !important;
  2278.         }
  2279.         .matched-card {
  2280.             background-color: rgba(255, 215, 0, 0.1) !important;
  2281.         }
  2282.         .st-highlight {
  2283.             background-color: #ffd700;
  2284.             color: #000;
  2285.             border-radius: 2px;
  2286.             padding: 0 2px;
  2287.         }
  2288.     `;
  2289.     document.head.appendChild(style);
  2290.     
  2291.     function watchSearchResults(converter) {
  2292.         let lastUrl = location.href;
  2293.         const urlObserver = setInterval(() => {
  2294.             if (location.href !== lastUrl) {
  2295.                 lastUrl = location.href;
  2296.                 STATE.originalTexts = new WeakMap();
  2297.                 setTimeout(() => {
  2298.                     convertPageText(converter);
  2299.                 }, 500);
  2300.             }
  2301.         }, 100);
  2302.     
  2303.         // 监视搜索结果变化
  2304.         const resultObserver = new MutationObserver((mutations) => {
  2305.             let needsConversion = false;
  2306.             for (const mutation of mutations) {
  2307.                 if (mutation.type === 'childList' || mutation.type === 'characterData') {
  2308.                     needsConversion = true;
  2309.                     break;
  2310.                 }
  2311.             }
  2312.             if (needsConversion) {
  2313.                 setTimeout(() => convertPageText(converter), 100);
  2314.             }
  2315.         });
  2316.     
  2317.         const resultsContainer = document.querySelector('.results-container');
  2318.         if (resultsContainer) {
  2319.             resultObserver.observe(resultsContainer, {
  2320.                 childList: true,
  2321.                 subtree: true,
  2322.                 characterData: true
  2323.             });
  2324.         }
  2325.     }
  2326.     
  2327.     function findReactInstance(element) {
  2328.         const key = Object.keys(element).find(key => key.startsWith('__reactFiber$'));
  2329.         return key ? element[key] : null;
  2330.     }
  2331.     
  2332.     function findLoadMoreHandler() {
  2333.         const loadMoreBtn = document.querySelector('.load-more-btn');
  2334.         if (!loadMoreBtn) {
  2335.             console.log('未找到加载更多按钮');
  2336.             return null;
  2337.         }
  2338.     
  2339.         // 尝试获取React实例
  2340.         const instance = findReactInstance(loadMoreBtn);
  2341.         if (!instance) {
  2342.             console.log('未找到React实例');
  2343.             return null;
  2344.         }
  2345.     
  2346.         // 遍历查找onClick处理函数
  2347.         let current = instance;
  2348.         while (current) {
  2349.             if (current.memoizedProps && current.memoizedProps.onClick) {
  2350.                 return current.memoizedProps.onClick;
  2351.             }
  2352.             current = current.return;
  2353.         }
  2354.     
  2355.         console.log('未找到onClick处理函数');
  2356.         return null;
  2357.     }
  2358.     
  2359.     function clickLoadMoreIfExists() {
  2360.         // 使用正确的选择器
  2361.         const loadMoreBtn = document.querySelector('.btn.load-more-btn');
  2362.         if (!loadMoreBtn) {
  2363.             console.log('未找到加载更多按钮');
  2364.             return false;
  2365.         }
  2366.     
  2367.         const results = document.querySelectorAll('.resultset, .trade-result, [class*="result-item"]');
  2368.         const currentResultCount = results.length;
  2369.     
  2370.         if (currentResultCount >= 100) {
  2371.             return false;
  2372.         }
  2373.     
  2374.         try {
  2375.             // 尝试多种方式触发点击
  2376.             // 1. 原生点击
  2377.             loadMoreBtn.click();
  2378.     
  2379.             // 2. 模拟鼠标事件序列
  2380.             ['mousedown', 'mouseup', 'click'].forEach(eventType => {
  2381.                 const event = new MouseEvent(eventType, {
  2382.                     bubbles: true,
  2383.                     cancelable: true,
  2384.                     buttons: 1
  2385.                 });
  2386.                 loadMoreBtn.dispatchEvent(event);
  2387.             });
  2388.     
  2389.             // 3. 尝试点击内部的span
  2390.             const spanInButton = loadMoreBtn.querySelector('span');
  2391.             if (spanInButton) {
  2392.                 spanInButton.click();
  2393.                 ['mousedown', 'mouseup', 'click'].forEach(eventType => {
  2394.                     const event = new MouseEvent(eventType, {
  2395.                         bubbles: true,
  2396.                         cancelable: true,
  2397.                         buttons: 1
  2398.                     });
  2399.                     spanInButton.dispatchEvent(event);
  2400.                 });
  2401.             }
  2402.     
  2403.             // 4. 使用 HTMLElement 的 click 方法
  2404.             HTMLElement.prototype.click.call(loadMoreBtn);
  2405.     
  2406.             return true;
  2407.         } catch (error) {
  2408.             console.log('触发加载更多时出错:', error);
  2409.             return false;
  2410.         }
  2411.     }
  2412.     
  2413.     function autoLoadAllResults() {
  2414.         let attempts = 0;
  2415.         const maxAttempts = 20;
  2416.         let lastResultCount = 0;
  2417.     
  2418.         function tryLoadMore() {
  2419.             const results = document.querySelectorAll('.resultset');
  2420.             const currentResultCount = results.length;
  2421.     
  2422.             if (currentResultCount >= 100 || attempts >= maxAttempts ||
  2423.                 (currentResultCount === lastResultCount && attempts > 0)) {
  2424.                 return;
  2425.             }
  2426.     
  2427.             if (clickLoadMoreIfExists()) {
  2428.                 lastResultCount = currentResultCount;
  2429.                 attempts++;
  2430.                 // 修改加载更多的处理方式
  2431.                 setTimeout(() => {
  2432.                     // 确保新内容加载后计算DPS
  2433.                     const newResults = document.querySelectorAll('.row[data-id]').length;
  2434.                     if (newResults > currentResultCount) {
  2435.                         calculateDPS();
  2436.                     }
  2437.                     tryLoadMore();
  2438.                 }, 1000);
  2439.             }
  2440.         }
  2441.     
  2442.         setTimeout(tryLoadMore, 1000);
  2443.     }
  2444.     
  2445.     // 检查URL是否是搜索结果页面
  2446.     function isSearchResultPage() {
  2447.         const isPOE2Trade = window.location.href.includes('pathofexile.com/trade2/search/poe2');
  2448.         const hasResults = document.querySelector('.results-container, .trade-results, .search-results, [class*="results"]') !== null;
  2449.         return isPOE2Trade && hasResults;
  2450.     }
  2451.     
  2452.     // 将这些函数移到init函数外部
  2453.             function createDPSPanel() {
  2454.                 const panel = document.createElement('div');
  2455.                 panel.id = 'dps-sort-panel';
  2456.                 panel.style.cssText = `
  2457.                     position: fixed;
  2458.                     right: 20px;
  2459.                     top: 50%;
  2460.                     transform: translateY(-50%);
  2461.                     background: rgba(28, 28, 28, 0.95);
  2462.                     padding: 8px;
  2463.                     border-radius: 6px;
  2464.                     box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
  2465.                     border: 1px solid #444;
  2466.                     width: 200px; // 增加宽度以适应价格显示
  2467.                     max-height: 60vh;
  2468.                     z-index: 9997;
  2469.                     display: none;
  2470.                 `;
  2471.  
  2472.                 // 添加标题
  2473.                 const title = document.createElement('div');
  2474.                 title.style.cssText = `
  2475.                     font-weight: bold;
  2476.                     color: #FFD700;
  2477.                     margin-bottom: 6px;
  2478.                     padding-bottom: 3px;
  2479.                     border-bottom: 1px solid #444;
  2480.                     display: flex;
  2481.                     justify-content: space-between;
  2482.                     align-items: center;
  2483.                     cursor: pointer;
  2484.                     font-size: 14px;
  2485.                     user-select: none;
  2486.                     height: 18px;
  2487.                 `;
  2488.                 
  2489.                 // 添加展开/收起指示器
  2490.                 const indicator = document.createElement('span');
  2491.                 indicator.textContent = '▼';
  2492.                 indicator.style.marginRight = '3px';
  2493.                 indicator.style.fontSize = '10px';
  2494.                 indicator.id = 'integrated-panel-indicator';
  2495.                 
  2496.                 const titleText = document.createElement('span');
  2497.                 titleText.textContent = 'DPS';
  2498.                 
  2499.                 const titleLeft = document.createElement('div');
  2500.                 titleLeft.style.display = 'flex';
  2501.                 titleLeft.style.alignItems = 'center';
  2502.                 titleLeft.appendChild(indicator);
  2503.                 titleLeft.appendChild(titleText);
  2504.  
  2505.                 title.appendChild(titleLeft);
  2506.  
  2507.                 // 添加关闭按钮
  2508.                 const closeBtn = document.createElement('button');
  2509.                 closeBtn.textContent = '×';
  2510.                 closeBtn.style.cssText = `
  2511.                     background: none;
  2512.                     border: none;
  2513.                     color: #999;
  2514.                     font-size: 20px;
  2515.                     cursor: pointer;
  2516.                     padding: 0 5px;
  2517.                 `;
  2518.                 closeBtn.onclick = (e) => {
  2519.                     e.stopPropagation();
  2520.                     panel.style.display = 'none';
  2521.                 };
  2522.                 title.appendChild(closeBtn);
  2523.  
  2524.                 // 添加内容容器
  2525.                 const content = document.createElement('div');
  2526.                 content.id = 'dps-sort-content';
  2527.                 content.style.cssText = `
  2528.                     max-height: calc(60vh - 35px);
  2529.                     overflow-y: auto;
  2530.                     transition: max-height 0.3s ease-out;
  2531.                     padding-right: 2px;
  2532.                 `;
  2533.  
  2534.                 // 添加展开/收起功能
  2535.                 let isExpanded = true;
  2536.                 title.onclick = () => {
  2537.                     isExpanded = !isExpanded;
  2538.                     content.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  2539.                     content.style.overflow = isExpanded ? 'auto' : 'hidden';
  2540.                     indicator.textContent = isExpanded ? '▼' : '▶';
  2541.  
  2542.             // 调整护盾面板位置
  2543.             const shieldPanel = document.getElementById('shield-sort-panel');
  2544.             if (shieldPanel) {
  2545.                 if (isExpanded) {
  2546.                     shieldPanel.style.transform = 'translateY(calc(-50% + 200px))';
  2547.                 } else {
  2548.                     shieldPanel.style.transform = 'translateY(calc(-50% + 50px))';
  2549.                 }
  2550.             }
  2551.                 };
  2552.  
  2553.                 // 添加滚动条样式
  2554.                 const style = document.createElement('style');
  2555.                 style.textContent = `
  2556.                     #dps-sort-content::-webkit-scrollbar {
  2557.                         width: 6px;
  2558.                     }
  2559.                     #dps-sort-content::-webkit-scrollbar-track {
  2560.                         background: #1a1a1a;
  2561.                     }
  2562.                     #dps-sort-content::-webkit-scrollbar-thumb {
  2563.                         background: #444;
  2564.                         border-radius: 3px;
  2565.                     }
  2566.                     #dps-sort-content::-webkit-scrollbar-thumb:hover {
  2567.                         background: #555;
  2568.                     }
  2569.                     .dps-item {
  2570.                         padding: 4px 8px;
  2571.                         margin: 1px 0;
  2572.                         background: #2d2d2d;
  2573.                         border-radius: 3px;
  2574.                         cursor: pointer;
  2575.                         transition: background 0.2s;
  2576.                         display: flex;
  2577.                         justify-content: space-between;
  2578.                         align-items: center;
  2579.                         gap: 8px;
  2580.                         font-size: 13px;
  2581.                         white-space: nowrap;
  2582.                         user-select: none;
  2583.                         line-height: 1.2;
  2584.                     }
  2585.                     .dps-item:hover {
  2586.                         background: #3d3d3d;
  2587.                     }
  2588.                     .dps-item:last-child {
  2589.                         margin-bottom: 0;
  2590.                     }
  2591.                     .dps-value {
  2592.                         color: #FFD700;
  2593.                         font-weight: bold;
  2594.                     }
  2595.                     .price-value {
  2596.                         color: #8acdff;
  2597.                         font-size: 12px;
  2598.                         text-align: right;
  2599.                     }
  2600.                 `;
  2601.  
  2602.                 panel.appendChild(title);
  2603.                 panel.appendChild(content);
  2604.                 document.head.appendChild(style);
  2605.                 document.body.appendChild(panel);
  2606.  
  2607.                 return panel;
  2608.             }
  2609.  
  2610.     // 将convertCurrencyText函数移到全局作用域
  2611.                 function convertCurrencyText(currencyText) {
  2612.         if (!currencyText) return '';
  2613.                     if (currencyText.includes('Exalted') || currencyText.includes('exalted')) return 'E';
  2614.                     if (currencyText.includes('Divine') || currencyText.includes('divine')) return 'D';
  2615.                     if (currencyText.includes('Chaos') || currencyText.includes('chaos')) return 'C';
  2616.                     if (currencyText.includes('崇高')) return 'E';
  2617.                     if (currencyText.includes('神圣')) return 'D';
  2618.                     if (currencyText.includes('混沌')) return 'C';
  2619.                     return currencyText; // 其他货币保持原样
  2620.                 }
  2621.  
  2622.     function updateDPSPanel() {
  2623.         try {
  2624.             console.log('Updating DPS panel...');
  2625.             
  2626.             // 获取或创建面板
  2627.             const panel = document.getElementById('integrated-sort-panel') || createIntegratedPanel();
  2628.                 const content = document.getElementById('dps-sort-content');
  2629.             if (!content) {
  2630.                 console.error('DPS sort content not found');
  2631.                 return;
  2632.             }
  2633.  
  2634.             // 清空现有内容
  2635.             content.innerHTML = '';
  2636.             
  2637.             // 清除可能存在的旧数据属性
  2638.             content.removeAttribute('data-shield-content');
  2639.             content.removeAttribute('data-evasion-content');
  2640.             content.removeAttribute('data-armour-content');
  2641.             content.removeAttribute('data-defence-content');
  2642.  
  2643.                 const items = document.querySelectorAll('.row[data-id]');
  2644.                 const dpsData = [];
  2645.  
  2646.                 items.forEach(item => {
  2647.                     const dpsDisplay = item.querySelector('.dps-display');
  2648.                     if (dpsDisplay) {
  2649.                         const dps = parseInt(dpsDisplay.textContent.replace('DPS: ', ''));
  2650.                         // 修改价格获取逻辑
  2651.                         const priceElement = item.querySelector('.price [data-field="price"]');
  2652.                         let price = '未标价';
  2653.                         if (priceElement) {
  2654.                             const amount = priceElement.querySelector('span:not(.price-label):not(.currency-text)');
  2655.                             const currencyText = priceElement.querySelector('.currency-text');
  2656.                             if (amount && currencyText) {
  2657.                                 // 获取数量和转换后的货币类型
  2658.                                 const amountText = amount.textContent.trim();
  2659.                                 const currency = currencyText.querySelector('span')?.textContent || currencyText.textContent;
  2660.                                 const simpleCurrency = convertCurrencyText(currency);
  2661.                                 price = `${amountText}${simpleCurrency}`;
  2662.                             }
  2663.                         }
  2664.  
  2665.                         dpsData.push({
  2666.                             dps,
  2667.                             price,
  2668.                             element: item
  2669.                         });
  2670.                     }
  2671.                 });
  2672.  
  2673.             // 如果没有DPS数据，隐藏DPS选项卡
  2674.             const dpsTab = panel.querySelector('[data-tab="dps"]');
  2675.             if (dpsData.length === 0) {
  2676.                 if (dpsTab) dpsTab.style.display = 'none';
  2677.  
  2678.                 // 如果护盾选项卡也是隐藏的，则隐藏整个面板
  2679.                 const shieldTab = panel.querySelector('[data-tab="shield"]');
  2680.                 const evasionTab = panel.querySelector('[data-tab="evasion"]');
  2681.                 const armourTab = panel.querySelector('[data-tab="armour"]');
  2682.                 const defenceTab = panel.querySelector('[data-tab="defence"]');
  2683.                 
  2684.                 // 检查是否所有选项卡都隐藏了
  2685.                 if ((shieldTab && shieldTab.style.display === 'none') &&
  2686.                     (evasionTab && evasionTab.style.display === 'none') &&
  2687.                     (armourTab && armourTab.style.display === 'none') &&
  2688.                     (defenceTab && defenceTab.style.display === 'none')) {
  2689.                     panel.style.display = 'none';
  2690.                 }
  2691.                 // 移除自动切换到护盾选项卡的代码，保留当前选项卡状态
  2692.                 return;
  2693.             } else {
  2694.                 // 有DPS数据，确保DPS选项卡可见
  2695.                 if (dpsTab) dpsTab.style.display = '';
  2696.             }
  2697.  
  2698.                 // 按DPS从高到低排序
  2699.                 dpsData.sort((a, b) => b.dps - a.dps);
  2700.  
  2701.                 // 更新面板内容
  2702.                 dpsData.forEach(({dps, price, element}) => {
  2703.                     const dpsItem = document.createElement('div');
  2704.                     dpsItem.className = 'dps-item';
  2705.                     
  2706.                     // 创建DPS显示
  2707.                     const dpsText = document.createElement('span');
  2708.                     dpsText.className = 'dps-value';
  2709.                     dpsText.textContent = dps.toString();
  2710.                     
  2711.                     // 创建价格显示
  2712.                     const priceText = document.createElement('span');
  2713.                     priceText.className = 'price-value';
  2714.                     priceText.textContent = price;
  2715.                     
  2716.                     // 添加到DPS项
  2717.                     dpsItem.appendChild(dpsText);
  2718.                     dpsItem.appendChild(priceText);
  2719.                     
  2720.                     dpsItem.onclick = () => {
  2721.                         element.scrollIntoView({ behavior: 'smooth', block: 'center' });
  2722.                         // 添加高亮效果
  2723.                         element.style.transition = 'background-color 0.3s';
  2724.                         element.style.backgroundColor = 'rgba(255, 215, 0, 0.2)';
  2725.                         setTimeout(() => {
  2726.                             element.style.backgroundColor = '';
  2727.                         }, 1500);
  2728.                     };
  2729.                     content.appendChild(dpsItem);
  2730.                 });
  2731.  
  2732.                 panel.style.display = 'block';
  2733.         } catch (error) {
  2734.             console.error('Error updating DPS panel:', error);
  2735.         }
  2736.             }
  2737.  
  2738.             function calculateDPS() {
  2739.                 console.log('Calculating DPS...'); // 添加调试日志
  2740.                 const items = document.querySelectorAll('.row[data-id]');
  2741.                 console.log('Found items:', items.length); // 添加调试日志
  2742.                 
  2743.                 items.forEach(item => {
  2744.                     // 查找已有的DPS显示，如果存在则跳过
  2745.                     if (item.querySelector('.dps-display')) return;
  2746.  
  2747.                     // 获取元素伤害
  2748.                     const edamageSpan = item.querySelector('span[data-field="edamage"]');
  2749.                     if (!edamageSpan) return;
  2750.  
  2751.                     // 初始化伤害值
  2752.                     let minTotal = 0;
  2753.                     let maxTotal = 0;
  2754.  
  2755.                     // 获取所有元素伤害值
  2756.                     const damages = {
  2757.                         fire: edamageSpan.querySelector('.colourFireDamage'),
  2758.                         lightning: edamageSpan.querySelector('.colourLightningDamage'),
  2759.                         cold: edamageSpan.querySelector('.colourColdDamage')
  2760.                     };
  2761.  
  2762.                     // 处理每种元素伤害
  2763.                     Object.values(damages).forEach(dmg => {
  2764.                         if (dmg) {
  2765.                             const [min, max] = dmg.textContent.split('-').map(Number);
  2766.                             if (!isNaN(min) && !isNaN(max)) {
  2767.                                 minTotal += min;
  2768.                                 maxTotal += max;
  2769.                             }
  2770.                         }
  2771.                     });
  2772.  
  2773.                     // 获取元素增伤
  2774.                     let elementInc = 1;
  2775.                     const elementIncSpan = item.querySelector('span[data-field="stat.explicit.stat_387439868"]');
  2776.                     if (elementIncSpan) {
  2777.                         const incMatch = elementIncSpan.textContent.match(/(\d+)%/);
  2778.                         if (incMatch) {
  2779.                             elementInc = 1 + (parseInt(incMatch[1]) / 100);
  2780.                         }
  2781.                     }
  2782.  
  2783.                     // 获取攻击速度
  2784.                     let aps = 1;
  2785.                     const apsSpan = item.querySelector('span[data-field="aps"]');
  2786.                     if (apsSpan) {
  2787.                         let apsValue = apsSpan.querySelector('.colourDefault');
  2788.                         if (!apsValue) {
  2789.                             apsValue = apsSpan.querySelector('.colourAugmented');
  2790.                         }
  2791.                         if (apsValue) {
  2792.                             aps = parseFloat(apsValue.textContent) || 1;
  2793.                         }
  2794.                     }
  2795.  
  2796.                     // 计算DPS
  2797.                     const dps = ((minTotal + maxTotal) / 2) * elementInc * aps;
  2798.                     console.log('minTotal:', minTotal);
  2799.                     console.log('maxTotal:', maxTotal);
  2800.                     console.log('elementInc:', elementInc);
  2801.                     console.log('aps:', aps);
  2802.                     console.log('dps:', dps);
  2803.  
  2804.                     // 创建DPS显示元素
  2805.                     const dpsDisplay = document.createElement('span');
  2806.                     dpsDisplay.className = 'dps-display';
  2807.                     dpsDisplay.style.cssText = `
  2808.                         color: #FFD700;
  2809.                         font-weight: bold;
  2810.                         margin-left: 10px;
  2811.                     `;
  2812.                     dpsDisplay.textContent = `DPS: ${Math.round(dps)}`;
  2813.  
  2814.                     // 将DPS显示添加到元素伤害后面
  2815.                     edamageSpan.appendChild(dpsDisplay);
  2816.                 });
  2817.  
  2818.                 // 更新DPS排序面板
  2819.                 updateDPSPanel();
  2820.             }
  2821.  
  2822.             // 创建一个防抖函数来避免过于频繁的计算
  2823.             function debounce(func, wait) {
  2824.                 let timeout;
  2825.                 return function executedFunction(...args) {
  2826.                     const later = () => {
  2827.                         clearTimeout(timeout);
  2828.                         func(...args);
  2829.                     };
  2830.                     clearTimeout(timeout);
  2831.                     timeout = setTimeout(later, wait);
  2832.                 };
  2833.             }
  2834.  
  2835.     async function init() {
  2836.         /**
  2837.          * 初始化脚本，设置转换器、观察器和UI元素
  2838.          */
  2839.         try {
  2840.             // 等待页面完全加载
  2841.             await new Promise(resolve => setTimeout(resolve, 100));
  2842.  
  2843.             // 等待OpenCC库加载
  2844.             const OpenCC = await waitForOpenCC();
  2845.             console.log('OpenCC已加载');
  2846.  
  2847.             // 创建转换器
  2848.             const converter = createConverters(OpenCC);
  2849.             window.converter = converter;
  2850.  
  2851.             // 创建输入处理函数
  2852.             const handleInput = createInputHandler(converter);
  2853.  
  2854.             // 为现有输入元素添加事件监听器
  2855.             attachInputListener(handleInput);
  2856.  
  2857.             // 创建观察器监听DOM变化
  2858.             const observer = createObserver(handleInput, converter);
  2859.             observer.observe(document.body, {
  2860.                 childList: true,
  2861.                 subtree: true
  2862.             });
  2863.  
  2864.             // 创建控制面板
  2865.             createControls();
  2866.  
  2867.             // 创建配置按钮
  2868.             createConfigButton();
  2869.  
  2870.             // 创建配置模态框
  2871.             createConfigModal();
  2872.  
  2873.             // 设置配置模态框事件
  2874.             setupConfigModalEvents();
  2875.  
  2876.             // 创建搜索框
  2877.             createSearchBox(handleInput);
  2878.  
  2879.             // 如果启用了页面简体化，转换页面文本
  2880.             if (STATE.pageSimplified) {
  2881.                 convertPageText(converter);
  2882.             }
  2883.  
  2884.             // 监视搜索结果
  2885.             watchSearchResults(converter);
  2886.  
  2887.             // 定期转换页面文本
  2888.             setInterval(() => {
  2889.                 if (STATE.pageSimplified) {
  2890.                     convertPageText(converter);
  2891.                 }
  2892.             }, 1000);
  2893.  
  2894.             // 使用防抖包装calculateDPS和calculateShield
  2895.             const debouncedCalculateDPS = debounce(calculateDPS, 200);
  2896.             const debouncedCalculateShield = debounce(calculateShield, 200);
  2897.             const debouncedCalculateEvasion = debounce(calculateEvasion, 200);
  2898.             const debouncedCalculateArmour = debounce(calculateArmour, 200);
  2899.             const debouncedCalculateDefence = debounce(calculateDefence, 200);
  2900.  
  2901.             // 同时计算DPS、护盾、闪避、护甲和总防御的防抖函数
  2902.             const debouncedCalculate = debounce(() => {
  2903.                 calculateDPS();
  2904.                 calculateShield();
  2905.                 calculateEvasion();
  2906.                 calculateArmour();
  2907.                 calculateDefence();
  2908.             }, 200);
  2909.             
  2910.             // 监听搜索按钮点击事件
  2911.             const setupSearchButtonListener = () => {
  2912.                 // 使用MutationObserver监听搜索按钮的出现
  2913.                 const searchBtnObserver = new MutationObserver((mutations, observer) => {
  2914.                     const searchBtn = document.querySelector('.controls-center .search-btn');
  2915.                     if (searchBtn) {
  2916.                         console.log('搜索按钮已找到，添加点击事件监听器');
  2917.                         searchBtn.addEventListener('click', () => {
  2918.                             console.log('搜索按钮被点击，触发计算...');
  2919.                             // 延迟执行计算，确保搜索结果已加载
  2920.                             setTimeout(() => {
  2921.                                 debouncedCalculate();
  2922.                             }, 1000);
  2923.                         });
  2924.                         observer.disconnect(); // 找到按钮后停止观察
  2925.                     }
  2926.                 });
  2927.                 
  2928.                 // 开始观察文档
  2929.                 searchBtnObserver.observe(document.body, {
  2930.                     childList: true,
  2931.                     subtree: true
  2932.                 });
  2933.                 
  2934.                 // 立即检查一次，以防按钮已经存在
  2935.                 const searchBtn = document.querySelector('.controls-center .search-btn');
  2936.                 if (searchBtn) {
  2937.                     console.log('搜索按钮已存在，添加点击事件监听器');
  2938.                     searchBtn.addEventListener('click', () => {
  2939.                         console.log('搜索按钮被点击，触发计算...');
  2940.                         // 延迟执行计算，确保搜索结果已加载
  2941.                         setTimeout(() => {
  2942.                             debouncedCalculate();
  2943.                         }, 1000);
  2944.                     });
  2945.                 }
  2946.             };
  2947.             
  2948.             // 设置搜索按钮监听器
  2949.             setupSearchButtonListener();
  2950.  
  2951.             // 创建一个更强大的观察器来监视DOM变化
  2952.             const resultsObserver = new MutationObserver((mutations) => {
  2953.                 let hasNewContent = false;
  2954.                 mutations.forEach(mutation => {
  2955.                     // 检查是否有新的结果项被添加
  2956.                     if (mutation.type === 'childList' && 
  2957.                         mutation.addedNodes.length > 0 &&
  2958.                         Array.from(mutation.addedNodes).some(node => 
  2959.                             node.nodeType === 1 && // 元素节点
  2960.                             (node.classList?.contains('row') || node.querySelector?.('.row[data-id]'))
  2961.                         )) {
  2962.                         hasNewContent = true;
  2963.                     }
  2964.                 });
  2965.  
  2966.                 if (hasNewContent) {
  2967.                     console.log('New content detected, calculating DPS, Shield, Evasion and Armour...'); // 添加调试日志
  2968.                     // 使用延时确保DOM完全更新
  2969.                     setTimeout(() => {
  2970.                         debouncedCalculate();
  2971.                     }, 300);
  2972.                 }
  2973.             });
  2974.  
  2975.             // 观察整个结果容器及其子元素
  2976.             const resultsContainer = document.querySelector('.results-container');
  2977.             if (resultsContainer) {
  2978.                 resultsObserver.observe(resultsContainer, {
  2979.                     childList: true,
  2980.                     subtree: true,
  2981.                     attributes: true,
  2982.                     characterData: true
  2983.                 });
  2984.  
  2985.                 // 同时观察父元素，以防结果容器被替换
  2986.                 if (resultsContainer.parentNode) {
  2987.                     resultsObserver.observe(resultsContainer.parentNode, {
  2988.                         childList: true
  2989.                     });
  2990.                 }
  2991.             }
  2992.  
  2993.             // 添加滚动事件监听器
  2994.             window.addEventListener('scroll', () => {
  2995.                 // 检查是否滚动到底部附近
  2996.                 if ((window.innerHeight + window.scrollY) >= document.body.offsetHeight - 1000) {
  2997.                     debouncedCalculate();
  2998.                 }
  2999.             });
  3000.  
  3001.             // 将函数添加到window对象，以便其他地方可以调用
  3002.             window.calculateDPS = calculateDPS;
  3003.             window.calculateShield = calculateShield;
  3004.             window.calculateEvasion = calculateEvasion;
  3005.             window.calculateArmour = calculateArmour;
  3006.             window.calculateDefence = calculateDefence;
  3007.             window.debouncedCalculateDPS = debouncedCalculateDPS;
  3008.             window.debouncedCalculateShield = debouncedCalculateShield;
  3009.             window.debouncedCalculateEvasion = debouncedCalculateEvasion;
  3010.             window.debouncedCalculateArmour = debouncedCalculateArmour;
  3011.             window.debouncedCalculateDefence = debouncedCalculateDefence;
  3012.             window.debouncedCalculate = debouncedCalculate;
  3013.  
  3014.             // 监听URL变化
  3015.             let lastUrl = location.href;
  3016.             const urlCheckInterval = setInterval(() => {
  3017.                 const currentUrl = location.href;
  3018.                 if ((currentUrl !== lastUrl || currentUrl.includes('pathofexile.com/trade2/search/poe2')) && STATE.autoLoadEnabled) {
  3019.                     lastUrl = currentUrl;
  3020.                     setTimeout(() => {
  3021.                         if (isSearchResultPage()) {
  3022.                             autoLoadAllResults();
  3023.                         }
  3024.                     }, 100);
  3025.                 }
  3026.             }, 100);
  3027.     
  3028.             // 初始检查
  3029.             setTimeout(() => {
  3030.                 if (isSearchResultPage() && STATE.autoLoadEnabled) {
  3031.                     autoLoadAllResults();
  3032.                 }
  3033.             }, 100);
  3034.     
  3035.             // 延迟初始计算，确保页面元素已加载
  3036.             setTimeout(() => {
  3037.                 // 初始计算DPS和护盾
  3038.                 calculateDPS();
  3039.             calculateShield();
  3040.                 calculateEvasion();
  3041.                 calculateArmour();
  3042.                 calculateDefence();
  3043.  
  3044.                 // 如果没有找到物品，设置重试
  3045.                 const retryCalculation = () => {
  3046.                     const items = document.querySelectorAll('.row[data-id]');
  3047.                     if (items.length > 0) {
  3048.                         console.log('重试计算，找到物品数量:', items.length);
  3049.                 calculateDPS();
  3050.                 calculateShield();
  3051.                         calculateEvasion();
  3052.                         calculateArmour();
  3053.                         calculateDefence();
  3054.                     } else {
  3055.                         console.log('未找到物品，500ms后重试...');
  3056.                         setTimeout(retryCalculation, 500);
  3057.                     }
  3058.                 };
  3059.  
  3060.                 // 如果初始计算没有找到物品，启动重试机制
  3061.                 const items = document.querySelectorAll('.row[data-id]');
  3062.                 if (items.length === 0) {
  3063.                     console.log('初始计算未找到物品，启动重试机制');
  3064.                     setTimeout(retryCalculation, 500);
  3065.                 }
  3066.             }, 500);
  3067.  
  3068.         } catch (error) {
  3069.             console.error('初始化时出错:', error);
  3070.         }
  3071.     }
  3072.     
  3073.     // 修改 updateConfig 函数
  3074.     function updateConfig(category, name) {
  3075.         if (confirm(`确定要用当前页面更新配置 "${name}" 吗？`)) {
  3076.             STATE.configs[category][name] = {
  3077.                 url: window.location.href
  3078.             };
  3079.             GM_setValue('savedConfigs', STATE.configs);
  3080.             updateConfigList();
  3081.         }
  3082.     }
  3083.     
  3084.     // 添加预设关键词相关函数
  3085.     function saveSearchPreset() {
  3086.         const nameInput = document.getElementById('preset-name');
  3087.         const keywordsInput = document.getElementById('preset-keywords');
  3088.         const name = nameInput.value.trim();
  3089.         const keywords = keywordsInput.value.trim();
  3090.         const saveBtn = document.getElementById('save-preset');
  3091.  
  3092.         if (!name || !keywords) {
  3093.             alert('请输入预设名称和关键词');
  3094.             return;
  3095.         }
  3096.  
  3097.         // 检查是否在编辑模式
  3098.         if (nameInput.dataset.editMode === 'true') {
  3099.             const originalName = nameInput.dataset.originalName;
  3100.             // 如果名称改变了，删除旧的预设
  3101.             if (originalName !== name) {
  3102.                 delete STATE.searchPresets[originalName];
  3103.             }
  3104.             // 清除编辑模式标记
  3105.             delete nameInput.dataset.editMode;
  3106.             delete nameInput.dataset.originalName;
  3107.             saveBtn.textContent = '保存预设';
  3108.         } else if (STATE.searchPresets[name] && !confirm(`预设 "${name}" 已存在，是否覆盖？`)) {
  3109.             return;
  3110.         }
  3111.  
  3112.         STATE.searchPresets[name] = keywords;
  3113.         GM_setValue('searchPresets', STATE.searchPresets);
  3114.         updatePresetList();
  3115.  
  3116.         nameInput.value = '';
  3117.         keywordsInput.value = '';
  3118.     }
  3119.  
  3120.     function updatePresetList() {
  3121.         const presetList = document.getElementById('preset-list');
  3122.         presetList.innerHTML = '';
  3123.  
  3124.         Object.entries(STATE.searchPresets).forEach(([name, keywords]) => {
  3125.             const presetItem = document.createElement('div');
  3126.             presetItem.style.cssText = `
  3127.                 display: grid;
  3128.                 grid-template-columns: 1fr auto auto;
  3129.                 align-items: center;
  3130.                 padding: 8px;
  3131.                 margin: 5px 0;
  3132.                 background: #3d3d3d;
  3133.                 border-radius: 4px;
  3134.                 gap: 10px;
  3135.             `;
  3136.  
  3137.             const nameSpan = document.createElement('span');
  3138.             nameSpan.textContent = name;  // 只显示预设名称
  3139.             nameSpan.title = keywords;    // 将关键词设置为提示文本
  3140.             nameSpan.style.cssText = `
  3141.                 overflow: hidden;
  3142.                 text-overflow: ellipsis;
  3143.                 white-space: nowrap;
  3144.                 cursor: help;  // 添加提示光标
  3145.             `;
  3146.  
  3147.             const editBtn = document.createElement('button');
  3148.             editBtn.textContent = '编辑';
  3149.             editBtn.style.cssText = `
  3150.                 background: #27ae60;
  3151.                 border: none;
  3152.                 color: #fff;
  3153.                 padding: 3px 12px;
  3154.                 cursor: pointer;
  3155.                 border-radius: 3px;
  3156.             `;
  3157.             editBtn.onclick = () => {
  3158.                 const presetEditModal = document.getElementById('preset-edit-modal');
  3159.                 const presetEditOverlay = document.getElementById('preset-edit-overlay');
  3160.                 const presetEditTitle = document.getElementById('preset-edit-title');
  3161.                 const nameInput = document.getElementById('preset-name');
  3162.                 const keywordsInput = document.getElementById('preset-keywords');
  3163.  
  3164.                 presetEditTitle.textContent = '编辑预设';
  3165.                 nameInput.value = name;
  3166.                 keywordsInput.value = keywords;
  3167.                 nameInput.dataset.editMode = 'true';
  3168.                 nameInput.dataset.originalName = name;
  3169.  
  3170.                 presetEditModal.style.display = 'block';
  3171.                 presetEditOverlay.style.display = 'block';
  3172.             };
  3173.  
  3174.             const deleteBtn = document.createElement('button');
  3175.             deleteBtn.textContent = '删除';
  3176.             deleteBtn.style.cssText = `
  3177.                 background: #e74c3c;
  3178.                 border: none;
  3179.                 color: #fff;
  3180.                 padding: 3px 12px;
  3181.                 cursor: pointer;
  3182.                 border-radius: 3px;
  3183.             `;
  3184.             deleteBtn.onclick = () => {
  3185.                 if (confirm(`确定要删除预设 "${name}" 吗？`)) {
  3186.                     delete STATE.searchPresets[name];
  3187.                     GM_setValue('searchPresets', STATE.searchPresets);
  3188.                     updatePresetList();
  3189.                 }
  3190.             };
  3191.  
  3192.             presetItem.appendChild(nameSpan);
  3193.             presetItem.appendChild(editBtn);
  3194.             presetItem.appendChild(deleteBtn);
  3195.             presetList.appendChild(presetItem);
  3196.         });
  3197.     }
  3198.     
  3199.     setTimeout(init, 2000);
  3200.  
  3201.     // 在clearHighlights函数后添加
  3202.     function updateCardVisibility() {
  3203.         const allCards = document.querySelectorAll('.row[data-id]');
  3204.         
  3205.         if (STATE.showOnlyMatched) {
  3206.             // 如果启用了"只显示匹配项"，隐藏所有非匹配卡片
  3207.             allCards.forEach(card => {
  3208.                 if (STATE.matchedCards.includes(card)) {
  3209.                     card.style.display = '';
  3210.                 } else {
  3211.                     card.style.display = 'none';
  3212.                 }
  3213.             });
  3214.         } else {
  3215.             // 如果禁用了"只显示匹配项"，显示所有卡片
  3216.             allCards.forEach(card => {
  3217.                 card.style.display = '';
  3218.             });
  3219.         }
  3220.     }
  3221.  
  3222.     // 计算护盾值
  3223.     function calculateShield() {
  3224.         console.log('Calculating Shield...');
  3225.         const items = document.querySelectorAll('.row[data-id]');
  3226.         console.log('Found items:', items.length);
  3227.         
  3228.         let processedCount = 0;
  3229.         let successCount = 0;
  3230.  
  3231.         items.forEach((item, index) => {
  3232.             try {
  3233.             // 如果已经计算过护盾值，则跳过
  3234.                 if (item.querySelector('.shield-display')) {
  3235.                     processedCount++;
  3236.                     return;
  3237.                 }
  3238.  
  3239.             // 1. 获取符文孔数量
  3240.             const socketsDiv = item.querySelector('.sockets');
  3241.                 if (!socketsDiv) {
  3242.                     console.debug(`Item ${index}: No sockets div found`);
  3243.                     return;
  3244.                 }
  3245.             
  3246.             // 修改符文孔数量的获取逻辑
  3247.             let numSockets = 0;
  3248.             for (let i = 1; i <= 6; i++) { // 假设最多6个符文孔
  3249.                 if (socketsDiv.classList.contains(`numSockets${i}`)) {
  3250.                     numSockets = i;
  3251.                     break;
  3252.                 }
  3253.             }
  3254.                 if (numSockets === 0) {
  3255.                     // 尝试其他方式获取符文孔数量
  3256.                     const socketText = socketsDiv.textContent.trim();
  3257.                     if (socketText) {
  3258.                         numSockets = socketText.length;
  3259.                     } else {
  3260.                         numSockets = 1; // 默认值
  3261.                     }
  3262.                     console.debug(`Item ${index}: Using alternative socket count: ${numSockets}`);
  3263.                 }
  3264.  
  3265.             // 2. 获取能量护盾值
  3266.             const esSpan = item.querySelector('span[data-field="es"]');
  3267.                 if (!esSpan) {
  3268.                     console.debug(`Item ${index}: No ES span found`);
  3269.                     return;
  3270.                 }
  3271.  
  3272.                 const esValue = esSpan.querySelector('.colourAugmented, .colourDefault');
  3273.                 if (!esValue) {
  3274.                     console.debug(`Item ${index}: No ES value found`);
  3275.                     return;
  3276.                 }
  3277.             
  3278.             const totalES = parseInt(esValue.textContent);
  3279.                 if (isNaN(totalES)) {
  3280.                     console.debug(`Item ${index}: Invalid ES value: ${esValue.textContent}`);
  3281.                     return;
  3282.                 }
  3283.  
  3284.             // 3. 获取当前品质
  3285.             let currentQuality = 0;
  3286.             const qualitySpan = item.querySelector('span[data-field="quality"]');
  3287.             if (qualitySpan) {
  3288.                 const qualityMatch = qualitySpan.textContent.match(/\+(\d+)%/);
  3289.                 if (qualityMatch) {
  3290.                     currentQuality = parseInt(qualityMatch[1]);
  3291.                 }
  3292.             }
  3293.             // 计算品质差值
  3294.             const qualityDiff = 20 - currentQuality;
  3295.  
  3296.             // 4. 获取护盾增加百分比
  3297.             let esInc = 0;
  3298.  
  3299.                 // 定义可能包含护盾增加的词缀ID列表
  3300.                 const possibleESIncIds = [
  3301.                     'stat.explicit.stat_4015621042',  // 原有ID
  3302.                     'stat.explicit.stat_1999113824',  // 增加闪避与能量护盾
  3303.                     'stat.explicit.stat_2866361420',  // 增加能量护盾
  3304.                     'stat.explicit.stat_2511217560',  // 增加最大能量护盾
  3305.                     'stat.explicit.stat_3489782002',  // 增加能量护盾和魔力
  3306.                     'stat.explicit.stat_3321629045'   // 增加护甲与能量护盾
  3307.                 ];
  3308.  
  3309.                 // 遍历所有可能的词缀ID
  3310.                 for (const statId of possibleESIncIds) {
  3311.                     const statSpan = item.querySelector(`span[data-field="${statId}"]`);
  3312.                     if (statSpan) {
  3313.                         // 检查词缀文本是否包含"能量护盾"或"Energy Shield"
  3314.                         const statText = statSpan.textContent;
  3315.                         if (statText.includes('能量护盾') || statText.includes('Energy Shield')) {
  3316.                             // 提取百分比数值
  3317.                             const incMatch = statText.match(/(\d+)%/);
  3318.                 if (incMatch) {
  3319.                                 esInc += parseInt(incMatch[1]);
  3320.                                 console.debug(`Found ES increase: ${incMatch[1]}% from stat ${statId}`);
  3321.                             }
  3322.                         }
  3323.                     }
  3324.                 }
  3325.  
  3326.                 // 通用方法：查找所有包含"能量护盾"或"Energy Shield"的显式词缀
  3327.                 const allExplicitStats = item.querySelectorAll('span[data-field^="stat.explicit.stat_"]');
  3328.                 allExplicitStats.forEach(statSpan => {
  3329.                     // 检查是否已经在上面的特定ID列表中处理过
  3330.                     const statId = statSpan.getAttribute('data-field');
  3331.                     if (!possibleESIncIds.includes(statId)) {
  3332.                         const statText = statSpan.textContent;
  3333.                         // 检查是否包含能量护盾相关文本和百分比增加
  3334.                         if ((statText.includes('能量护盾') || statText.includes('Energy Shield')) &&
  3335.                             statText.includes('%') &&
  3336.                             (statText.includes('增加') || statText.includes('increased'))) {
  3337.                             const incMatch = statText.match(/(\d+)%/);
  3338.                             if (incMatch) {
  3339.                                 esInc += parseInt(incMatch[1]);
  3340.                                 console.debug(`Found additional ES increase: ${incMatch[1]}% from stat ${statId}`);
  3341.                                 // 将新发现的ID添加到列表中，以便将来使用
  3342.                                 possibleESIncIds.push(statId);
  3343.                             }
  3344.                         }
  3345.                     }
  3346.                 });
  3347.  
  3348.             // 5. 获取已插入的符文提供的增益和数量
  3349.             let insertedRuneBonus = 0;
  3350.             let insertedRuneCount = 0;
  3351.             let esRuneInc = 0; // 新增：专门用于记录护盾符文的增益
  3352.  
  3353.             // 获取符文增益 - 能量护盾增加
  3354.             const esRuneStatSpan = item.querySelector('span[data-field="stat.rune.stat_3523867985"]');
  3355.             if (esRuneStatSpan) {
  3356.                 const runeMatch = esRuneStatSpan.textContent.match(/(\d+)%/);
  3357.                 if (runeMatch) {
  3358.                     insertedRuneBonus = parseInt(runeMatch[1]);
  3359.                     insertedRuneCount = insertedRuneBonus / 20;
  3360.                 }
  3361.             }
  3362.  
  3363.             // 获取符文增益 - 能量护盾百分比增加
  3364.             const esIncRuneStatSpan = item.querySelector('span[data-field="stat.rune.stat_2866361420"]');
  3365.             if (esIncRuneStatSpan) {
  3366.                 const esIncRuneMatch = esIncRuneStatSpan.textContent.match(/(\d+)%/);
  3367.                 if (esIncRuneMatch) {
  3368.                     esRuneInc = parseInt(esIncRuneMatch[1]);
  3369.                 }
  3370.             }
  3371.  
  3372.             // 6. 计算可用的符文孔位增益
  3373.             let availableRuneBonus = 0;
  3374.             // 计算剩余可用的孔数
  3375.             const remainingSlots = numSockets - insertedRuneCount;
  3376.             availableRuneBonus = remainingSlots * 20;
  3377.  
  3378.             // 7. 计算基础护盾
  3379.             // 当前护盾 = 基础护盾 * (1 + 当前品质/100) * (1 + (已插入符文增益 + 装备增益 + 护盾符文增益)/100)
  3380.             const baseES = Math.round(totalES / (1 + currentQuality/100) / (1 + (insertedRuneBonus + esInc + esRuneInc)/100));
  3381.  
  3382.             // 8. 计算最大可能护盾（考虑品质提升和剩余符文孔）
  3383.             // 最大护盾 = 基础护盾 * (1 + (当前品质 + 品质差值)/100) * (1 + (装备增益 + 已插入符文增益 + 可用符文增益)/100)
  3384.             const maxES = Math.round(baseES * (1 + (currentQuality + qualityDiff)/100) * (1 + (esInc + insertedRuneBonus + availableRuneBonus)/100));
  3385.  
  3386.             // 创建护盾显示元素
  3387.             const shieldDisplay = document.createElement('span');
  3388.             shieldDisplay.className = 'shield-display';
  3389.             shieldDisplay.style.cssText = `
  3390.                 color: #6495ED;
  3391.                 font-weight: bold;
  3392.                 margin-left: 10px;
  3393.             `;
  3394.             shieldDisplay.textContent = `总护盾: ${maxES}`;
  3395.  
  3396.             // 将护盾显示添加到能量护盾后面
  3397.             esSpan.appendChild(shieldDisplay);
  3398.  
  3399.                 successCount++;
  3400.                 processedCount++;
  3401.  
  3402.             // 添加调试信息
  3403.                 console.debug(`Item ${index} Shield calculation:`, {
  3404.                 totalES,
  3405.                 currentQuality,
  3406.                 qualityDiff,
  3407.                 esInc,
  3408.                 insertedRuneBonus,
  3409.                 insertedRuneCount,
  3410.                 numSockets,
  3411.                 availableRuneBonus,
  3412.                 baseES,
  3413.                 maxES
  3414.             });
  3415.             } catch (error) {
  3416.                 console.error(`Error calculating shield for item ${index}:`, error);
  3417.             }
  3418.         });
  3419.  
  3420.         console.log(`Shield calculation completed: ${successCount} successful, ${processedCount} processed out of ${items.length} items`);
  3421.  
  3422.         // 更新护盾排序面板
  3423.         updateShieldPanel();
  3424.     }
  3425.  
  3426.     // 创建护盾排序面板
  3427.     function createShieldPanel() {
  3428.         const panel = document.createElement('div');
  3429.         panel.id = 'shield-sort-panel';
  3430.         panel.style.cssText = `
  3431.             position: fixed;
  3432.             right: 20px;
  3433.             top: 50%;
  3434.             transform: translateY(calc(-50% + 200px));
  3435.             background: rgba(28, 28, 28, 0.95);
  3436.             padding: 8px;
  3437.             border-radius: 6px;
  3438.             box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
  3439.             border: 1px solid #444;
  3440.             width: 180px;
  3441.             max-height: 60vh;
  3442.             z-index: 9997;
  3443.             display: none;
  3444.         `;
  3445.  
  3446.         // 添加标题
  3447.         const title = document.createElement('div');
  3448.         title.style.cssText = `
  3449.             font-weight: bold;
  3450.             color: #8acdff;
  3451.             margin-bottom: 6px;
  3452.             padding-bottom: 3px;
  3453.             border-bottom: 1px solid #444;
  3454.             display: flex;
  3455.             justify-content: space-between;
  3456.             align-items: center;
  3457.             cursor: pointer;
  3458.             font-size: 14px;
  3459.             user-select: none;
  3460.             height: 18px;
  3461.         `;
  3462.         
  3463.         // 添加展开/收起指示器
  3464.         const indicator = document.createElement('span');
  3465.         indicator.textContent = '▼';
  3466.         indicator.style.marginRight = '3px';
  3467.         indicator.style.fontSize = '10px';
  3468.         indicator.id = 'integrated-panel-indicator';
  3469.         
  3470.         const titleText = document.createElement('span');
  3471.         titleText.textContent = 'ES';
  3472.         
  3473.         const titleLeft = document.createElement('div');
  3474.         titleLeft.style.display = 'flex';
  3475.         titleLeft.style.alignItems = 'center';
  3476.         titleLeft.appendChild(indicator);
  3477.         titleLeft.appendChild(titleText);
  3478.  
  3479.         title.appendChild(titleLeft);
  3480.  
  3481.         // 添加关闭按钮
  3482.         const closeBtn = document.createElement('button');
  3483.         closeBtn.textContent = '×';
  3484.         closeBtn.style.cssText = `
  3485.             background: none;
  3486.             border: none;
  3487.             color: #999;
  3488.             font-size: 20px;
  3489.             cursor: pointer;
  3490.             padding: 0 5px;
  3491.         `;
  3492.         closeBtn.onclick = (e) => {
  3493.             e.stopPropagation();
  3494.             panel.style.display = 'none';
  3495.         };
  3496.         title.appendChild(closeBtn);
  3497.  
  3498.         // 添加内容容器
  3499.         const content = document.createElement('div');
  3500.         content.id = 'shield-sort-content';
  3501.         content.style.cssText = `
  3502.             max-height: calc(60vh - 35px);
  3503.             overflow-y: auto;
  3504.             transition: max-height 0.3s ease-out;
  3505.             padding-right: 2px;
  3506.         `;
  3507.  
  3508.         // 添加展开/收起功能
  3509.         let isExpanded = true;
  3510.         title.onclick = () => {
  3511.             isExpanded = !isExpanded;
  3512.             content.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  3513.             content.style.overflow = isExpanded ? 'auto' : 'hidden';
  3514.             indicator.textContent = isExpanded ? '▼' : '▶';
  3515.         };
  3516.  
  3517.         // 添加组件到面板
  3518.         panel.appendChild(title);
  3519.         panel.appendChild(content);
  3520.  
  3521.         // 添加到文档
  3522.         document.body.appendChild(panel);
  3523.  
  3524.         console.log('Shield panel created successfully');
  3525.         return panel;
  3526.     }
  3527.  
  3528.     // 更新护盾排序面板
  3529.     function updateShieldPanel() {
  3530.         try {
  3531.             console.log('Updating shield panel...');
  3532.  
  3533.             // 获取或创建面板
  3534.             const panel = document.getElementById('integrated-sort-panel') || createIntegratedPanel();
  3535.             const content = document.getElementById('shield-sort-content');
  3536.             if (!content) {
  3537.                 console.error('Shield sort content not found');
  3538.                 return;
  3539.             }
  3540.  
  3541.             // 清空现有内容
  3542.             content.innerHTML = '';
  3543.  
  3544.             // 清除可能存在的旧数据属性
  3545.             content.removeAttribute('data-armour-content');
  3546.             content.removeAttribute('data-evasion-content');
  3547.             content.removeAttribute('data-dps-content');
  3548.             content.removeAttribute('data-defence-content');
  3549.  
  3550.             // 获取所有物品
  3551.             const items = document.querySelectorAll('.row[data-id]');
  3552.             const shieldData = [];
  3553.  
  3554.             // 收集护盾数据
  3555.             items.forEach(item => {
  3556.                 const shieldDisplay = item.querySelector('.shield-display');
  3557.                 if (shieldDisplay) {
  3558.                     const shield = parseInt(shieldDisplay.textContent.replace('总护盾: ', ''));
  3559.                     
  3560.                     // 获取价格
  3561.                     const priceElement = item.querySelector('.price [data-field="price"]');
  3562.                     let price = '未标价';
  3563.                     if (priceElement) {
  3564.                         const amount = priceElement.querySelector('span:not(.price-label):not(.currency-text)');
  3565.                         const currencyText = priceElement.querySelector('.currency-text');
  3566.                         if (amount && currencyText) {
  3567.                             const amountText = amount.textContent.trim();
  3568.                             const currency = currencyText.querySelector('span')?.textContent || currencyText.textContent;
  3569.                             // 使用全局的convertCurrencyText函数
  3570.                             const simpleCurrency = convertCurrencyText(currency);
  3571.                             price = `${amountText}${simpleCurrency}`;
  3572.                         }
  3573.                     }
  3574.  
  3575.                     shieldData.push({
  3576.                         shield,
  3577.                         price,
  3578.                         element: item
  3579.                     });
  3580.                 }
  3581.             });
  3582.  
  3583.             console.log(`Found ${shieldData.length} items with shield data`);
  3584.  
  3585.             // 如果没有护盾数据，隐藏护盾选项卡
  3586.             const shieldTab = panel.querySelector('[data-tab="shield"]');
  3587.             if (shieldData.length === 0) {
  3588.                 if (shieldTab) shieldTab.style.display = 'none';
  3589.  
  3590.                 // 如果DPS选项卡也是隐藏的，则隐藏整个面板
  3591.                 const dpsTab = panel.querySelector('[data-tab="dps"]');
  3592.                 const evasionTab = panel.querySelector('[data-tab="evasion"]');
  3593.                 const armourTab = panel.querySelector('[data-tab="armour"]');
  3594.                 const defenceTab = panel.querySelector('[data-tab="defence"]');
  3595.                 
  3596.                 // 检查是否所有选项卡都隐藏了
  3597.                 if ((dpsTab && dpsTab.style.display === 'none') &&
  3598.                     (evasionTab && evasionTab.style.display === 'none') &&
  3599.                     (armourTab && armourTab.style.display === 'none') &&
  3600.                     (defenceTab && defenceTab.style.display === 'none')) {
  3601.                     panel.style.display = 'none';
  3602.                 }
  3603.                 // 移除自动切换到护盾选项卡的代码，保留当前选项卡状态
  3604.                 return;
  3605.             } else {
  3606.                 // 有护盾数据，确保护盾选项卡可见
  3607.                 if (shieldTab) shieldTab.style.display = '';
  3608.             }
  3609.  
  3610.             // 按护盾值从高到低排序
  3611.             shieldData.sort((a, b) => b.shield - a.shield);
  3612.  
  3613.             // 更新面板内容
  3614.             shieldData.forEach(({shield, price, element}) => {
  3615.                 const shieldItem = document.createElement('div');
  3616.                 shieldItem.className = 'dps-item'; // 复用DPS项的样式
  3617.  
  3618.                 // 创建护盾显示
  3619.                 const shieldText = document.createElement('span');
  3620.                 shieldText.className = 'shield-value'; // 使用护盾专用的样式
  3621.                 shieldText.textContent = shield.toString();
  3622.  
  3623.                 // 创建价格显示
  3624.                 const priceText = document.createElement('span');
  3625.                 priceText.className = 'price-value';
  3626.                 priceText.textContent = price;
  3627.  
  3628.                 // 添加到护盾项
  3629.                 shieldItem.appendChild(shieldText);
  3630.                 shieldItem.appendChild(priceText);
  3631.  
  3632.                 // 添加点击事件
  3633.                 shieldItem.onclick = () => {
  3634.                     element.scrollIntoView({ behavior: 'smooth', block: 'center' });
  3635.                     // 添加高亮效果
  3636.                     element.style.transition = 'background-color 0.3s';
  3637.                     element.style.backgroundColor = 'rgba(138, 205, 255, 0.2)';
  3638.                     setTimeout(() => {
  3639.                         element.style.backgroundColor = '';
  3640.                     }, 1500);
  3641.                 };
  3642.  
  3643.                 content.appendChild(shieldItem);
  3644.             });
  3645.  
  3646.             // 显示面板
  3647.             panel.style.display = 'block';
  3648.             console.log('Shield panel updated successfully');
  3649.         } catch (error) {
  3650.             console.error('Error updating shield panel:', error);
  3651.         }
  3652.     }
  3653.  
  3654.     // 辅助函数：安全地查询选择器
  3655.     function safeQuerySelector(element, selector) {
  3656.         try {
  3657.             return element.querySelector(selector);
  3658.         } catch (error) {
  3659.             console.error(`Error querying selector "${selector}":`, error);
  3660.             return null;
  3661.         }
  3662.     }
  3663.  
  3664.     // 创建整合面板，包含总防御、DPS、护盾、闪避和护甲五个选项卡
  3665.     function createIntegratedPanel() {
  3666.         // 检查是否已存在面板
  3667.         let panel = document.getElementById('integrated-sort-panel');
  3668.         if (panel) return panel;
  3669.         
  3670.         panel = document.createElement('div');
  3671.         panel.id = 'integrated-sort-panel';
  3672.         panel.style.cssText = `
  3673.             position: fixed;
  3674.             right: 20px;
  3675.             top: 50%;
  3676.             transform: translateY(-50%);
  3677.             background: rgba(28, 28, 28, 0.95);
  3678.             padding: 8px;
  3679.             border-radius: 6px;
  3680.             box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
  3681.             border: 1px solid #444;
  3682.             width: 180px;
  3683.             max-height: 60vh;
  3684.             z-index: 9997;
  3685.             display: none;
  3686.         `;
  3687.  
  3688.         // 创建标题栏
  3689.         const titleBar = document.createElement('div');
  3690.         titleBar.style.cssText = `
  3691.             display: flex;
  3692.             justify-content: space-between;
  3693.             align-items: center;
  3694.             margin-bottom: 6px;
  3695.             padding-bottom: 3px;
  3696.             border-bottom: 1px solid #444;
  3697.             font-size: 13px;
  3698.             user-select: none;
  3699.             height: 18px;
  3700.         `;
  3701.         
  3702.         // 创建选项卡容器
  3703.         const tabsContainer = document.createElement('div');
  3704.         tabsContainer.style.cssText = `
  3705.             display: flex;
  3706.             gap: 4px;
  3707.             flex-wrap: nowrap;
  3708.         `;
  3709.         
  3710.         // 创建总防御选项卡（默认激活）
  3711.         const defenceTab = document.createElement('div');
  3712.         defenceTab.textContent = 'DEF';
  3713.         defenceTab.className = 'sort-tab active';
  3714.         defenceTab.dataset.tab = 'defence';
  3715.         defenceTab.style.cssText = `
  3716.             color: #9370DB;
  3717.             font-weight: bold;
  3718.             cursor: pointer;
  3719.             padding: 0 3px;
  3720.             font-size: 12px;
  3721.         `;
  3722.         
  3723.         // 创建DPS选项卡
  3724.         const dpsTab = document.createElement('div');
  3725.         dpsTab.textContent = 'DPS';
  3726.         dpsTab.className = 'sort-tab';
  3727.         dpsTab.dataset.tab = 'dps';
  3728.         dpsTab.style.cssText = `
  3729.             color: #FFD700;
  3730.             font-weight: bold;
  3731.             cursor: pointer;
  3732.             padding: 0 3px;
  3733.             opacity: 0.6;
  3734.             font-size: 12px;
  3735.         `;
  3736.         
  3737.         // 创建护盾选项卡
  3738.         const shieldTab = document.createElement('div');
  3739.         shieldTab.textContent = 'ES';
  3740.         shieldTab.className = 'sort-tab';
  3741.         shieldTab.dataset.tab = 'shield';
  3742.         shieldTab.style.cssText = `
  3743.             color: #8acdff;
  3744.             font-weight: bold;
  3745.             cursor: pointer;
  3746.             padding: 0 3px;
  3747.             opacity: 0.6;
  3748.             font-size: 12px;
  3749.         `;
  3750.         
  3751.         // 创建闪避选项卡
  3752.         const evasionTab = document.createElement('div');
  3753.         evasionTab.textContent = 'EV';
  3754.         evasionTab.className = 'sort-tab';
  3755.         evasionTab.dataset.tab = 'evasion';
  3756.         evasionTab.style.cssText = `
  3757.             color: #7FFF00;
  3758.             font-weight: bold;
  3759.             cursor: pointer;
  3760.             padding: 0 3px;
  3761.             opacity: 0.6;
  3762.             font-size: 12px;
  3763.         `;
  3764.         
  3765.         // 创建护甲选项卡
  3766.         const armourTab = document.createElement('div');
  3767.         armourTab.textContent = 'AR';
  3768.         armourTab.className = 'sort-tab';
  3769.         armourTab.dataset.tab = 'armour';
  3770.         armourTab.style.cssText = `
  3771.             color: #FF6347;
  3772.             font-weight: bold;
  3773.             cursor: pointer;
  3774.             padding: 0 3px;
  3775.             opacity: 0.6;
  3776.             font-size: 12px;
  3777.         `;
  3778.         
  3779.         // 添加选项卡到容器
  3780.         tabsContainer.appendChild(defenceTab);
  3781.         tabsContainer.appendChild(dpsTab);
  3782.         tabsContainer.appendChild(shieldTab);
  3783.         tabsContainer.appendChild(evasionTab);
  3784.         tabsContainer.appendChild(armourTab);
  3785.         
  3786.         // 创建展开/收起指示器
  3787.         const indicator = document.createElement('span');
  3788.         indicator.textContent = '▼';
  3789.         indicator.style.marginRight = '3px';
  3790.         indicator.style.fontSize = '10px';
  3791.         indicator.id = 'integrated-panel-indicator';
  3792.         
  3793.         // 创建左侧容器
  3794.         const titleLeft = document.createElement('div');
  3795.         titleLeft.style.cssText = `
  3796.             display: flex;
  3797.             align-items: center;
  3798.         `;
  3799.         titleLeft.appendChild(indicator);
  3800.         titleLeft.appendChild(tabsContainer);
  3801.         
  3802.         // 添加关闭按钮
  3803.         const closeBtn = document.createElement('button');
  3804.         closeBtn.textContent = '×';
  3805.         closeBtn.style.cssText = `
  3806.             background: none;
  3807.             border: none;
  3808.             color: #999;
  3809.             font-size: 20px;
  3810.             cursor: pointer;
  3811.             padding: 0 5px;
  3812.         `;
  3813.         closeBtn.onclick = (e) => {
  3814.             e.stopPropagation();
  3815.             panel.style.display = 'none';
  3816.         };
  3817.         
  3818.         // 组装标题栏
  3819.         titleBar.appendChild(titleLeft);
  3820.         titleBar.appendChild(closeBtn);
  3821.         
  3822.         // 创建内容容器
  3823.         const contentContainer = document.createElement('div');
  3824.         contentContainer.style.cssText = `
  3825.             position: relative;
  3826.         `;
  3827.         
  3828.         // 创建总防御内容
  3829.         const defenceContent = document.createElement('div');
  3830.         defenceContent.id = 'defence-sort-content';
  3831.         defenceContent.className = 'sort-content active';
  3832.         defenceContent.style.cssText = `
  3833.             max-height: calc(60vh - 35px);
  3834.             overflow-y: auto;
  3835.             transition: max-height 0.3s ease-out, opacity 0.3s ease-out;
  3836.             padding-right: 2px;
  3837.         `;
  3838.         
  3839.         // 创建DPS内容
  3840.         const dpsContent = document.createElement('div');
  3841.         dpsContent.id = 'dps-sort-content';
  3842.         dpsContent.className = 'sort-content';
  3843.         dpsContent.style.cssText = `
  3844.             max-height: calc(60vh - 35px);
  3845.             overflow-y: auto;
  3846.             transition: max-height 0.3s ease-out, opacity 0.3s ease-out;
  3847.             padding-right: 2px;
  3848.             display: none;
  3849.         `;
  3850.         
  3851.         // 创建护盾内容
  3852.         const shieldContent = document.createElement('div');
  3853.         shieldContent.id = 'shield-sort-content';
  3854.         shieldContent.className = 'sort-content';
  3855.         shieldContent.style.cssText = `
  3856.             max-height: calc(60vh - 35px);
  3857.             overflow-y: auto;
  3858.             transition: max-height 0.3s ease-out, opacity 0.3s ease-out;
  3859.             padding-right: 2px;
  3860.             display: none;
  3861.         `;
  3862.         
  3863.         // 创建闪避内容
  3864.         const evasionContent = document.createElement('div');
  3865.         evasionContent.id = 'evasion-sort-content';
  3866.         evasionContent.className = 'sort-content';
  3867.         evasionContent.style.cssText = `
  3868.             max-height: calc(60vh - 35px);
  3869.             overflow-y: auto;
  3870.             transition: max-height 0.3s ease-out, opacity 0.3s ease-out;
  3871.             padding-right: 2px;
  3872.             display: none;
  3873.         `;
  3874.         
  3875.         // 创建护甲内容
  3876.         const armourContent = document.createElement('div');
  3877.         armourContent.id = 'armour-sort-content';
  3878.         armourContent.className = 'sort-content';
  3879.         armourContent.style.cssText = `
  3880.             max-height: calc(60vh - 35px);
  3881.             overflow-y: auto;
  3882.             transition: max-height 0.3s ease-out, opacity 0.3s ease-out;
  3883.             padding-right: 2px;
  3884.             display: none;
  3885.         `;
  3886.         
  3887.         // 添加内容到容器
  3888.         contentContainer.appendChild(defenceContent);
  3889.         contentContainer.appendChild(dpsContent);
  3890.         contentContainer.appendChild(shieldContent);
  3891.         contentContainer.appendChild(evasionContent);
  3892.         contentContainer.appendChild(armourContent);
  3893.         
  3894.         // 添加展开/收起功能
  3895.         let isExpanded = true;
  3896.         indicator.onclick = (e) => {
  3897.             e.stopPropagation();
  3898.             isExpanded = !isExpanded;
  3899.             defenceContent.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  3900.             dpsContent.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  3901.             shieldContent.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  3902.             evasionContent.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  3903.             armourContent.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  3904.             defenceContent.style.overflow = isExpanded ? 'auto' : 'hidden';
  3905.             dpsContent.style.overflow = isExpanded ? 'auto' : 'hidden';
  3906.             shieldContent.style.overflow = isExpanded ? 'auto' : 'hidden';
  3907.             evasionContent.style.overflow = isExpanded ? 'auto' : 'hidden';
  3908.             armourContent.style.overflow = isExpanded ? 'auto' : 'hidden';
  3909.             indicator.textContent = isExpanded ? '▼' : '▶';
  3910.         };
  3911.  
  3912.         // 添加选项卡切换功能
  3913.         defenceTab.onclick = () => {
  3914.             defenceTab.classList.add('active');
  3915.             dpsTab.classList.remove('active');
  3916.             shieldTab.classList.remove('active');
  3917.             evasionTab.classList.remove('active');
  3918.             armourTab.classList.remove('active');
  3919.             defenceContent.style.display = 'block';
  3920.             dpsContent.style.display = 'none';
  3921.             shieldContent.style.display = 'none';
  3922.             evasionContent.style.display = 'none';
  3923.             armourContent.style.display = 'none';
  3924.             defenceTab.style.opacity = '1';
  3925.             dpsTab.style.opacity = '0.6';
  3926.             shieldTab.style.opacity = '0.6';
  3927.             evasionTab.style.opacity = '0.6';
  3928.             armourTab.style.opacity = '0.6';
  3929.         };
  3930.         
  3931.         dpsTab.onclick = () => {
  3932.             dpsTab.classList.add('active');
  3933.             defenceTab.classList.remove('active');
  3934.             shieldTab.classList.remove('active');
  3935.             evasionTab.classList.remove('active');
  3936.             armourTab.classList.remove('active');
  3937.             dpsContent.style.display = 'block';
  3938.             defenceContent.style.display = 'none';
  3939.             shieldContent.style.display = 'none';
  3940.             evasionContent.style.display = 'none';
  3941.             armourContent.style.display = 'none';
  3942.             dpsTab.style.opacity = '1';
  3943.             defenceTab.style.opacity = '0.6';
  3944.             shieldTab.style.opacity = '0.6';
  3945.             evasionTab.style.opacity = '0.6';
  3946.             armourTab.style.opacity = '0.6';
  3947.         };
  3948.         
  3949.         shieldTab.onclick = () => {
  3950.             shieldTab.classList.add('active');
  3951.             defenceTab.classList.remove('active');
  3952.             dpsTab.classList.remove('active');
  3953.             evasionTab.classList.remove('active');
  3954.             armourTab.classList.remove('active');
  3955.             shieldContent.style.display = 'block';
  3956.             defenceContent.style.display = 'none';
  3957.             dpsContent.style.display = 'none';
  3958.             evasionContent.style.display = 'none';
  3959.             armourContent.style.display = 'none';
  3960.             shieldTab.style.opacity = '1';
  3961.             defenceTab.style.opacity = '0.6';
  3962.             dpsTab.style.opacity = '0.6';
  3963.             evasionTab.style.opacity = '0.6';
  3964.             armourTab.style.opacity = '0.6';
  3965.         };
  3966.         
  3967.         evasionTab.onclick = () => {
  3968.             evasionTab.classList.add('active');
  3969.             defenceTab.classList.remove('active');
  3970.             dpsTab.classList.remove('active');
  3971.             shieldTab.classList.remove('active');
  3972.             armourTab.classList.remove('active');
  3973.             evasionContent.style.display = 'block';
  3974.             defenceContent.style.display = 'none';
  3975.             dpsContent.style.display = 'none';
  3976.             shieldContent.style.display = 'none';
  3977.             armourContent.style.display = 'none';
  3978.             evasionTab.style.opacity = '1';
  3979.             defenceTab.style.opacity = '0.6';
  3980.             dpsTab.style.opacity = '0.6';
  3981.             shieldTab.style.opacity = '0.6';
  3982.             armourTab.style.opacity = '0.6';
  3983.         };
  3984.         
  3985.         armourTab.onclick = () => {
  3986.             armourTab.classList.add('active');
  3987.             defenceTab.classList.remove('active');
  3988.             dpsTab.classList.remove('active');
  3989.             shieldTab.classList.remove('active');
  3990.             evasionTab.classList.remove('active');
  3991.             armourContent.style.display = 'block';
  3992.             defenceContent.style.display = 'none';
  3993.             dpsContent.style.display = 'none';
  3994.             shieldContent.style.display = 'none';
  3995.             evasionContent.style.display = 'none';
  3996.             armourTab.style.opacity = '1';
  3997.             defenceTab.style.opacity = '0.6';
  3998.             dpsTab.style.opacity = '0.6';
  3999.             shieldTab.style.opacity = '0.6';
  4000.             evasionTab.style.opacity = '0.6';
  4001.         };
  4002.  
  4003.         // 添加滚动条样式
  4004.         const style = document.createElement('style');
  4005.         style.textContent = `
  4006.             #dps-sort-content::-webkit-scrollbar,
  4007.             #shield-sort-content::-webkit-scrollbar,
  4008.             #evasion-sort-content::-webkit-scrollbar,
  4009.             #armour-sort-content::-webkit-scrollbar {
  4010.                 width: 6px;
  4011.             }
  4012.             #dps-sort-content::-webkit-scrollbar-track,
  4013.             #shield-sort-content::-webkit-scrollbar-track,
  4014.             #evasion-sort-content::-webkit-scrollbar-track {
  4015.                 background: #1a1a1a;
  4016.             }
  4017.             #dps-sort-content::-webkit-scrollbar-thumb,
  4018.             #shield-sort-content::-webkit-scrollbar-thumb,
  4019.             #evasion-sort-content::-webkit-scrollbar-thumb {
  4020.                 background: #444;
  4021.                 border-radius: 3px;
  4022.             }
  4023.             #dps-sort-content::-webkit-scrollbar-thumb:hover,
  4024.             #shield-sort-content::-webkit-scrollbar-thumb:hover,
  4025.             #evasion-sort-content::-webkit-scrollbar-thumb:hover {
  4026.                 background: #555;
  4027.             }
  4028.             .dps-item {
  4029.                     padding: 4px 8px;
  4030.                     margin: 1px 0;
  4031.                     background: #2d2d2d;
  4032.                     border-radius: 3px;
  4033.                     cursor: pointer;
  4034.                     transition: background 0.2s;
  4035.                     display: flex;
  4036.                     justify-content: space-between;
  4037.                     align-items: center;
  4038.                     gap: 8px;
  4039.                     font-size: 13px;
  4040.                     white-space: nowrap;
  4041.                     user-select: none;
  4042.                     line-height: 1.2;
  4043.             }
  4044.             .dps-item:hover {
  4045.                 background: #3d3d3d;
  4046.             }
  4047.             .dps-item:last-child {
  4048.                 margin-bottom: 0;
  4049.             }
  4050.             .dps-value {
  4051.                 color: #FFD700;
  4052.                 font-weight: bold;
  4053.             }
  4054.             .shield-value {
  4055.                 color: #8acdff;
  4056.                 font-weight: bold;
  4057.             }
  4058.             .evasion-value {
  4059.                 color: #7FFF00;
  4060.                 font-weight: bold;
  4061.             }
  4062.             .price-value {
  4063.                 color: #8acdff;
  4064.                 font-size: 12px;
  4065.                 text-align: right;
  4066.             }
  4067.         `;
  4068.  
  4069.         // 组装面板
  4070.         panel.appendChild(titleBar);
  4071.         panel.appendChild(contentContainer);
  4072.         document.head.appendChild(style);
  4073.         document.body.appendChild(panel);
  4074.  
  4075.         console.log('Integrated panel created successfully');
  4076.         return panel;
  4077.     }
  4078.  
  4079.     // 计算闪避值
  4080.     function calculateEvasion() {
  4081.         console.log('Calculating Evasion...');
  4082.         const items = document.querySelectorAll('.row[data-id]');
  4083.         console.log('Found items:', items.length);
  4084.  
  4085.         let processedCount = 0;
  4086.         let successCount = 0;
  4087.  
  4088.         items.forEach((item, index) => {
  4089.             try {
  4090.                 // 如果已经计算过闪避值，则跳过
  4091.                 if (item.querySelector('.evasion-display')) {
  4092.                     processedCount++;
  4093.                     return;
  4094.                 }
  4095.  
  4096.                 // 1. 获取符文孔数量
  4097.                 const socketsDiv = item.querySelector('.sockets');
  4098.                 if (!socketsDiv) {
  4099.                     console.debug(`Item ${index}: No sockets div found`);
  4100.                     return;
  4101.                 }
  4102.  
  4103.                 // 修改符文孔数量的获取逻辑
  4104.                 let numSockets = 0;
  4105.                 for (let i = 1; i <= 6; i++) { // 假设最多6个符文孔
  4106.                     if (socketsDiv.classList.contains(`numSockets${i}`)) {
  4107.                         numSockets = i;
  4108.                         break;
  4109.                     }
  4110.                 }
  4111.                 if (numSockets === 0) {
  4112.                     // 尝试其他方式获取符文孔数量
  4113.                     const socketText = socketsDiv.textContent.trim();
  4114.                     if (socketText) {
  4115.                         numSockets = socketText.length;
  4116.                     } else {
  4117.                         numSockets = 1; // 默认值
  4118.                     }
  4119.                     console.debug(`Item ${index}: Using alternative socket count: ${numSockets}`);
  4120.                 }
  4121.  
  4122.                 // 2. 获取闪避值
  4123.                 const evasionSpan = item.querySelector('span[data-field="ev"]');
  4124.                 if (!evasionSpan) {
  4125.                     console.debug(`Item ${index}: No Evasion span found`);
  4126.                     return;
  4127.                 }
  4128.  
  4129.                 const evasionValue = evasionSpan.querySelector('.colourAugmented, .colourDefault');
  4130.                 if (!evasionValue) {
  4131.                     console.debug(`Item ${index}: No Evasion value found`);
  4132.                     return;
  4133.                 }
  4134.  
  4135.                 const totalEvasion = parseInt(evasionValue.textContent);
  4136.                 if (isNaN(totalEvasion)) {
  4137.                     console.debug(`Item ${index}: Invalid Evasion value: ${evasionValue.textContent}`);
  4138.                     return;
  4139.                 }
  4140.  
  4141.                 // 3. 获取当前品质
  4142.                 let currentQuality = 0;
  4143.                 const qualitySpan = item.querySelector('span[data-field="quality"]');
  4144.                 if (qualitySpan) {
  4145.                     const qualityMatch = qualitySpan.textContent.match(/\+(\d+)%/);
  4146.                     if (qualityMatch) {
  4147.                         currentQuality = parseInt(qualityMatch[1]);
  4148.                     }
  4149.                 }
  4150.                 // 计算品质差值
  4151.                 const qualityDiff = 20 - currentQuality;
  4152.  
  4153.                 // 4. 获取闪避增加百分比
  4154.                 let evasionInc = 0;
  4155.  
  4156.                 // 定义可能包含闪避增加的词缀ID列表
  4157.                 const possibleEvasionIncIds = [
  4158.                     'stat.explicit.stat_1999113824',  // 增加闪避与能量护盾
  4159.                     'stat.explicit.stat_2144192051',  // 增加闪避
  4160.                     'stat.explicit.stat_3489782002',  // 增加闪避和生命
  4161.                     'stat.explicit.stat_3321629045'   // 增加护甲与闪避
  4162.                 ];
  4163.  
  4164.                 // 遍历所有可能的词缀ID
  4165.                 for (const statId of possibleEvasionIncIds) {
  4166.                     const statSpan = item.querySelector(`span[data-field="${statId}"]`);
  4167.                     if (statSpan) {
  4168.                         // 检查词缀文本是否包含"闪避"或"Evasion"
  4169.                         const statText = statSpan.textContent;
  4170.                         if (statText.includes('闪避') || statText.includes('Evasion')) {
  4171.                             // 提取百分比数值
  4172.                             const incMatch = statText.match(/(\d+)%/);
  4173.                             if (incMatch) {
  4174.                                 evasionInc += parseInt(incMatch[1]);
  4175.                                 console.debug(`Found Evasion increase: ${incMatch[1]}% from stat ${statId}`);
  4176.                             }
  4177.                         }
  4178.                     }
  4179.                 }
  4180.  
  4181.                 // 通用方法：查找所有包含"闪避"或"Evasion"的显式词缀
  4182.                 const allExplicitStats = item.querySelectorAll('span[data-field^="stat.explicit.stat_"]');
  4183.                 allExplicitStats.forEach(statSpan => {
  4184.                     // 检查是否已经在上面的特定ID列表中处理过
  4185.                     const statId = statSpan.getAttribute('data-field');
  4186.                     if (!possibleEvasionIncIds.includes(statId)) {
  4187.                         const statText = statSpan.textContent;
  4188.                         // 检查是否包含闪避相关文本和百分比增加
  4189.                         if ((statText.includes('闪避') || statText.includes('Evasion')) &&
  4190.                             statText.includes('%') &&
  4191.                             (statText.includes('增加') || statText.includes('increased'))) {
  4192.                             const incMatch = statText.match(/(\d+)%/);
  4193.                             if (incMatch) {
  4194.                                 evasionInc += parseInt(incMatch[1]);
  4195.                                 console.debug(`Found additional Evasion increase: ${incMatch[1]}% from stat ${statId}`);
  4196.                                 // 将新发现的ID添加到列表中，以便将来使用
  4197.                                 possibleEvasionIncIds.push(statId);
  4198.                             }
  4199.                         }
  4200.                     }
  4201.                 });
  4202.  
  4203.                 // 5. 获取已插入的符文提供的增益和数量
  4204.                 let insertedRuneBonus = 0;
  4205.                 let insertedRuneCount = 0;
  4206.                 let evasionRuneInc = 0; // 专门用于记录闪避符文的增益
  4207.  
  4208.                 // 获取符文增益 - 闪避增加
  4209.                 const evasionRuneStatSpan = item.querySelector('span[data-field="stat.rune.stat_3523867985"]');
  4210.                 if (evasionRuneStatSpan) {
  4211.                     const runeMatch = evasionRuneStatSpan.textContent.match(/(\d+)%/);
  4212.                     if (runeMatch) {
  4213.                         insertedRuneBonus = parseInt(runeMatch[1]);
  4214.                         insertedRuneCount = insertedRuneBonus / 20;
  4215.                     }
  4216.                 }
  4217.  
  4218.                 // 获取符文增益 - 闪避百分比增加
  4219.                 const evasionIncRuneStatSpan = item.querySelector('span[data-field="stat.rune.stat_2866361420"]');
  4220.                 if (evasionIncRuneStatSpan) {
  4221.                     const evasionIncRuneMatch = evasionIncRuneStatSpan.textContent.match(/(\d+)%/);
  4222.                     if (evasionIncRuneMatch) {
  4223.                         evasionRuneInc = parseInt(evasionIncRuneMatch[1]);
  4224.                     }
  4225.                 }
  4226.  
  4227.                 // 6. 计算可用的符文孔位增益
  4228.                 let availableRuneBonus = 0;
  4229.                 // 计算剩余可用的孔数
  4230.                 const remainingSlots = numSockets - insertedRuneCount;
  4231.                 availableRuneBonus = remainingSlots * 20;
  4232.  
  4233.                 // 7. 计算基础闪避
  4234.                 // 当前闪避 = 基础闪避 * (1 + 当前品质/100) * (1 + (已插入符文增益 + 装备增益 + 闪避符文增益)/100)
  4235.                 const baseEvasion = Math.round(totalEvasion / (1 + currentQuality/100) / (1 + (insertedRuneBonus + evasionInc + evasionRuneInc)/100));
  4236.  
  4237.                 // 8. 计算最大可能闪避（考虑品质提升和剩余符文孔）
  4238.                 // 最大闪避 = 基础闪避 * (1 + (当前品质 + 品质差值)/100) * (1 + (装备增益 + 已插入符文增益 + 可用符文增益)/100)
  4239.                 const maxEvasion = Math.round(baseEvasion * (1 + (currentQuality + qualityDiff)/100) * (1 + (evasionInc + insertedRuneBonus + availableRuneBonus)/100));
  4240.  
  4241.                 // 创建闪避显示元素
  4242.                 const evasionDisplay = document.createElement('span');
  4243.                 evasionDisplay.className = 'evasion-display';
  4244.                 evasionDisplay.style.cssText = `
  4245.                     color: #32CD32;
  4246.                     font-weight: bold;
  4247.                     margin-left: 10px;
  4248.                 `;
  4249.                 evasionDisplay.textContent = `总闪避: ${maxEvasion}`;
  4250.  
  4251.                 // 将闪避显示添加到闪避后面
  4252.                 evasionSpan.appendChild(evasionDisplay);
  4253.  
  4254.                 successCount++;
  4255.                 processedCount++;
  4256.  
  4257.                 // 添加调试信息
  4258.                 console.debug(`Item ${index} Evasion calculation:`, {
  4259.                     totalEvasion,
  4260.                     currentQuality,
  4261.                     qualityDiff,
  4262.                     evasionInc,
  4263.                     insertedRuneBonus,
  4264.                     insertedRuneCount,
  4265.                     numSockets,
  4266.                     availableRuneBonus,
  4267.                     baseEvasion,
  4268.                     maxEvasion
  4269.                 });
  4270.             } catch (error) {
  4271.                 console.error(`Error calculating evasion for item ${index}:`, error);
  4272.             }
  4273.         });
  4274.  
  4275.         console.log(`Evasion calculation completed: ${successCount} successful, ${processedCount} processed out of ${items.length} items`);
  4276.  
  4277.         // 更新闪避排序面板
  4278.         updateEvasionPanel();
  4279.     }
  4280.  
  4281.     // 创建闪避排序面板
  4282.     function createEvasionPanel() {
  4283.         const panel = document.createElement('div');
  4284.         panel.id = 'evasion-sort-panel';
  4285.         panel.style.cssText = `
  4286.             position: fixed;
  4287.             right: 20px;
  4288.             top: 50%;
  4289.             transform: translateY(calc(-50% + 400px));
  4290.             background: rgba(28, 28, 28, 0.95);
  4291.             padding: 8px;
  4292.             border-radius: 6px;
  4293.             box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
  4294.             border: 1px solid #444;
  4295.             width: 180px;
  4296.             max-height: 60vh;
  4297.             z-index: 9997;
  4298.             display: none;
  4299.         `;
  4300.  
  4301.         // 添加标题
  4302.         const title = document.createElement('div');
  4303.         title.style.cssText = `
  4304.             font-weight: bold;
  4305.             color: #7FFF00;
  4306.             margin-bottom: 6px;
  4307.             padding-bottom: 3px;
  4308.             border-bottom: 1px solid #444;
  4309.             display: flex;
  4310.             justify-content: space-between;
  4311.             align-items: center;
  4312.             cursor: pointer;
  4313.             font-size: 14px;
  4314.             user-select: none;
  4315.             height: 18px;
  4316.         `;
  4317.  
  4318.         // 添加展开/收起指示器
  4319.         const indicator = document.createElement('span');
  4320.         indicator.textContent = '▼';
  4321.         indicator.style.marginRight = '3px';
  4322.         indicator.style.fontSize = '10px';
  4323.         indicator.id = 'integrated-panel-indicator';
  4324.  
  4325.         const titleText = document.createElement('span');
  4326.         titleText.textContent = 'EV';
  4327.  
  4328.         const titleLeft = document.createElement('div');
  4329.         titleLeft.style.display = 'flex';
  4330.         titleLeft.style.alignItems = 'center';
  4331.         titleLeft.appendChild(indicator);
  4332.         titleLeft.appendChild(titleText);
  4333.  
  4334.         title.appendChild(titleLeft);
  4335.  
  4336.         // 添加关闭按钮
  4337.         const closeBtn = document.createElement('button');
  4338.         closeBtn.textContent = '×';
  4339.         closeBtn.style.cssText = `
  4340.             background: none;
  4341.             border: none;
  4342.             color: #999;
  4343.             font-size: 20px;
  4344.             cursor: pointer;
  4345.             padding: 0 5px;
  4346.         `;
  4347.         closeBtn.onclick = (e) => {
  4348.             e.stopPropagation();
  4349.             panel.style.display = 'none';
  4350.         };
  4351.         title.appendChild(closeBtn);
  4352.  
  4353.         // 添加内容容器
  4354.         const content = document.createElement('div');
  4355.         content.id = 'evasion-sort-content';
  4356.         content.style.cssText = `
  4357.             max-height: calc(60vh - 35px);
  4358.             overflow-y: auto;
  4359.             transition: max-height 0.3s ease-out;
  4360.             padding-right: 2px;
  4361.         `;
  4362.  
  4363.         // 添加展开/收起功能
  4364.         let isExpanded = true;
  4365.         title.onclick = () => {
  4366.             isExpanded = !isExpanded;
  4367.             content.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  4368.             content.style.overflow = isExpanded ? 'auto' : 'hidden';
  4369.             indicator.textContent = isExpanded ? '▼' : '▶';
  4370.         };
  4371.  
  4372.         // 添加组件到面板
  4373.         panel.appendChild(title);
  4374.         panel.appendChild(content);
  4375.  
  4376.         // 添加到文档
  4377.         document.body.appendChild(panel);
  4378.  
  4379.         console.log('Evasion panel created successfully');
  4380.         return panel;
  4381.     }
  4382.  
  4383.     // 更新闪避排序面板
  4384.     function updateEvasionPanel() {
  4385.         try {
  4386.             console.log('Updating evasion panel...');
  4387.  
  4388.             // 获取或创建面板
  4389.             const panel = document.getElementById('integrated-sort-panel') || createIntegratedPanel();
  4390.             const content = document.getElementById('evasion-sort-content');
  4391.             if (!content) {
  4392.                 console.error('Evasion sort content not found');
  4393.                 return;
  4394.             }
  4395.  
  4396.             // 清空现有内容
  4397.             content.innerHTML = '';
  4398.  
  4399.             // 清除可能存在的旧数据属性
  4400.             content.removeAttribute('data-armour-content');
  4401.             content.removeAttribute('data-shield-content');
  4402.             content.removeAttribute('data-dps-content');
  4403.             content.removeAttribute('data-defence-content');
  4404.  
  4405.             // 获取所有物品
  4406.             const items = document.querySelectorAll('.row[data-id]');
  4407.             const evasionData = [];
  4408.  
  4409.             // 收集闪避数据
  4410.             items.forEach(item => {
  4411.                 const evasionDisplay = item.querySelector('.evasion-display');
  4412.                 if (evasionDisplay) {
  4413.                     const evasion = parseInt(evasionDisplay.textContent.replace('总闪避: ', ''));
  4414.  
  4415.                     // 获取价格
  4416.                     const priceElement = item.querySelector('.price [data-field="price"]');
  4417.                     let price = '未标价';
  4418.                     if (priceElement) {
  4419.                         const amount = priceElement.querySelector('span:not(.price-label):not(.currency-text)');
  4420.                         const currencyText = priceElement.querySelector('.currency-text');
  4421.                         if (amount && currencyText) {
  4422.                             const amountText = amount.textContent.trim();
  4423.                             const currency = currencyText.querySelector('span')?.textContent || currencyText.textContent;
  4424.                             // 使用全局的convertCurrencyText函数
  4425.                             const simpleCurrency = convertCurrencyText(currency);
  4426.                             price = `${amountText}${simpleCurrency}`;
  4427.                         }
  4428.                     }
  4429.  
  4430.                     evasionData.push({
  4431.                         evasion,
  4432.                         price,
  4433.                         element: item
  4434.                     });
  4435.                 }
  4436.             });
  4437.  
  4438.             console.log(`Found ${evasionData.length} items with evasion data`);
  4439.  
  4440.             // 如果没有闪避数据，隐藏闪避选项卡
  4441.             const evasionTab = panel.querySelector('[data-tab="evasion"]');
  4442.             if (evasionData.length === 0) {
  4443.                 if (evasionTab) evasionTab.style.display = 'none';
  4444.  
  4445.                 // 如果其他选项卡也是隐藏的，则隐藏整个面板
  4446.                 const dpsTab = panel.querySelector('[data-tab="dps"]');
  4447.                 const shieldTab = panel.querySelector('[data-tab="shield"]');
  4448.                 const armourTab = panel.querySelector('[data-tab="armour"]');
  4449.                 const defenceTab = panel.querySelector('[data-tab="defence"]');
  4450.                 
  4451.                 // 检查是否所有选项卡都隐藏了
  4452.                 if ((dpsTab && dpsTab.style.display === 'none') &&
  4453.                     (shieldTab && shieldTab.style.display === 'none') &&
  4454.                     (armourTab && armourTab.style.display === 'none') &&
  4455.                     (defenceTab && defenceTab.style.display === 'none')) {
  4456.                     panel.style.display = 'none';
  4457.                 }
  4458.                 // 移除自动切换到其他选项卡的代码，保留当前选项卡状态
  4459.                 return;
  4460.             } else {
  4461.                 // 有闪避数据，确保闪避选项卡可见
  4462.                 if (evasionTab) evasionTab.style.display = '';
  4463.             }
  4464.  
  4465.             // 按闪避值从高到低排序
  4466.             evasionData.sort((a, b) => b.evasion - a.evasion);
  4467.  
  4468.             // 更新面板内容
  4469.             evasionData.forEach(({evasion, price, element}) => {
  4470.                 const evasionItem = document.createElement('div');
  4471.                 evasionItem.className = 'dps-item'; // 复用DPS项的样式
  4472.  
  4473.                 // 创建闪避显示
  4474.                 const evasionText = document.createElement('span');
  4475.                 evasionText.className = 'evasion-value'; // 使用闪避专用的样式
  4476.                 evasionText.textContent = evasion.toString();
  4477.  
  4478.                 // 创建价格显示
  4479.                 const priceText = document.createElement('span');
  4480.                 priceText.className = 'price-value';
  4481.                 priceText.textContent = price;
  4482.                 
  4483.                 // 添加到闪避项
  4484.                 evasionItem.appendChild(evasionText);
  4485.                 evasionItem.appendChild(priceText);
  4486.                 
  4487.                 // 添加点击事件
  4488.                 evasionItem.onclick = () => {
  4489.                     element.scrollIntoView({ behavior: 'smooth', block: 'center' });
  4490.                     // 添加高亮效果
  4491.                     element.style.transition = 'background-color 0.3s';
  4492.                     element.style.backgroundColor = 'rgba(127, 255, 0, 0.2)';
  4493.                     setTimeout(() => {
  4494.                         element.style.backgroundColor = '';
  4495.                     }, 1500);
  4496.                 };
  4497.  
  4498.                 content.appendChild(evasionItem);
  4499.             });
  4500.  
  4501.             // 显示面板
  4502.             panel.style.display = 'block';
  4503.             console.log('Evasion panel updated successfully');
  4504.         } catch (error) {
  4505.             console.error('Error updating evasion panel:', error);
  4506.         }
  4507.     }
  4508.  
  4509.     // 计算护甲值
  4510.     function calculateArmour() {
  4511.         console.log('Calculating Armour...');
  4512.         const items = document.querySelectorAll('.row[data-id]');
  4513.         console.log('Found items:', items.length);
  4514.  
  4515.         let processedCount = 0;
  4516.         let successCount = 0;
  4517.  
  4518.         items.forEach((item, index) => {
  4519.             try {
  4520.                 // 如果已经计算过护甲值，则跳过
  4521.                 if (item.querySelector('.armour-display')) {
  4522.                     processedCount++;
  4523.                     return;
  4524.                 }
  4525.  
  4526.                 // 1. 获取符文孔数量
  4527.                 const socketsDiv = item.querySelector('.sockets');
  4528.                 if (!socketsDiv) {
  4529.                     console.debug(`Item ${index}: No sockets div found`);
  4530.                     return;
  4531.                 }
  4532.  
  4533.                 // 修改符文孔数量的获取逻辑
  4534.                 let numSockets = 0;
  4535.                 for (let i = 1; i <= 6; i++) { // 假设最多6个符文孔
  4536.                     if (socketsDiv.classList.contains(`numSockets${i}`)) {
  4537.                         numSockets = i;
  4538.                         break;
  4539.                     }
  4540.                 }
  4541.                 if (numSockets === 0) {
  4542.                     // 尝试其他方式获取符文孔数量
  4543.                     const socketText = socketsDiv.textContent.trim();
  4544.                     if (socketText) {
  4545.                         numSockets = socketText.length;
  4546.                     } else {
  4547.                         numSockets = 1; // 默认值
  4548.                     }
  4549.                     console.debug(`Item ${index}: Using alternative socket count: ${numSockets}`);
  4550.                 }
  4551.  
  4552.                 // 2. 获取护甲值
  4553.                 const armourSpan = item.querySelector('span[data-field="ar"]');
  4554.                 if (!armourSpan) {
  4555.                     console.debug(`Item ${index}: No Armour span found`);
  4556.                     return;
  4557.                 }
  4558.  
  4559.                 const armourValue = armourSpan.querySelector('.colourAugmented, .colourDefault');
  4560.                 if (!armourValue) {
  4561.                     console.debug(`Item ${index}: No Armour value found`);
  4562.                     return;
  4563.                 }
  4564.  
  4565.                 const totalArmour = parseInt(armourValue.textContent);
  4566.                 if (isNaN(totalArmour)) {
  4567.                     console.debug(`Item ${index}: Invalid Armour value: ${armourValue.textContent}`);
  4568.                     return;
  4569.                 }
  4570.  
  4571.                 // 3. 获取当前品质
  4572.                 let currentQuality = 0;
  4573.                 const qualitySpan = item.querySelector('span[data-field="quality"]');
  4574.                 if (qualitySpan) {
  4575.                     const qualityMatch = qualitySpan.textContent.match(/\+(\d+)%/);
  4576.                     if (qualityMatch) {
  4577.                         currentQuality = parseInt(qualityMatch[1]);
  4578.                     }
  4579.                 }
  4580.                 // 计算品质差值
  4581.                 const qualityDiff = 20 - currentQuality;
  4582.  
  4583.                 // 4. 获取护甲增加百分比
  4584.                 let armourInc = 0;
  4585.  
  4586.                 // 定义可能包含护甲增加的词缀ID列表
  4587.                 const possibleArmourIncIds = [
  4588.                     'stat.explicit.stat_3321629045',  // 增加护甲与能量护盾
  4589.                     'stat.explicit.stat_2866361420',  // 增加护甲
  4590.                     'stat.explicit.stat_2511217560',  // 增加最大护甲
  4591.                     'stat.explicit.stat_3489782002'   // 增加护甲和生命
  4592.                 ];
  4593.  
  4594.                 // 遍历所有可能的词缀ID
  4595.                 for (const statId of possibleArmourIncIds) {
  4596.                     const statSpan = item.querySelector(`span[data-field="${statId}"]`);
  4597.                     if (statSpan) {
  4598.                         // 检查词缀文本是否包含"护甲"或"Armour"
  4599.                         const statText = statSpan.textContent;
  4600.                         if (statText.includes('护甲') || statText.includes('Armour')) {
  4601.                             // 提取百分比数值
  4602.                             const incMatch = statText.match(/(\d+)%/);
  4603.                             if (incMatch) {
  4604.                                 armourInc += parseInt(incMatch[1]);
  4605.                                 console.debug(`Found Armour increase: ${incMatch[1]}% from stat ${statId}`);
  4606.                             }
  4607.                         }
  4608.                     }
  4609.                 }
  4610.  
  4611.                 // 通用方法：查找所有包含"护甲"或"Armour"的显式词缀
  4612.                 const allExplicitStats = item.querySelectorAll('span[data-field^="stat.explicit.stat_"]');
  4613.                 allExplicitStats.forEach(statSpan => {
  4614.                     // 检查是否已经在上面的特定ID列表中处理过
  4615.                     const statId = statSpan.getAttribute('data-field');
  4616.                     if (!possibleArmourIncIds.includes(statId)) {
  4617.                         const statText = statSpan.textContent;
  4618.                         // 检查是否包含护甲相关文本和百分比增加
  4619.                         if ((statText.includes('护甲') || statText.includes('Armour')) &&
  4620.                             statText.includes('%') &&
  4621.                             (statText.includes('增加') || statText.includes('increased'))) {
  4622.                             const incMatch = statText.match(/(\d+)%/);
  4623.                             if (incMatch) {
  4624.                                 armourInc += parseInt(incMatch[1]);
  4625.                                 console.debug(`Found additional Armour increase: ${incMatch[1]}% from stat ${statId}`);
  4626.                                 // 将新发现的ID添加到列表中，以便将来使用
  4627.                                 possibleArmourIncIds.push(statId);
  4628.                             }
  4629.                         }
  4630.                     }
  4631.                 });
  4632.  
  4633.                 // 5. 获取已插入的符文提供的增益和数量
  4634.                 let insertedRuneBonus = 0;
  4635.                 let insertedRuneCount = 0;
  4636.                 let armourRuneInc = 0; // 专门用于记录护甲符文的增益
  4637.  
  4638.                 // 获取符文增益 - 护甲增加
  4639.                 const armourRuneStatSpan = item.querySelector('span[data-field="stat.rune.stat_3523867985"]');
  4640.                 if (armourRuneStatSpan) {
  4641.                     const runeMatch = armourRuneStatSpan.textContent.match(/(\d+)%/);
  4642.                     if (runeMatch) {
  4643.                         insertedRuneBonus = parseInt(runeMatch[1]);
  4644.                         insertedRuneCount = insertedRuneBonus / 20;
  4645.                     }
  4646.                 }
  4647.  
  4648.                 // 获取符文增益 - 护甲百分比增加
  4649.                 const armourIncRuneStatSpan = item.querySelector('span[data-field="stat.rune.stat_2866361420"]');
  4650.                 if (armourIncRuneStatSpan) {
  4651.                     const armourIncRuneMatch = armourIncRuneStatSpan.textContent.match(/(\d+)%/);
  4652.                     if (armourIncRuneMatch) {
  4653.                         armourRuneInc = parseInt(armourIncRuneMatch[1]);
  4654.                     }
  4655.                 }
  4656.  
  4657.                 // 6. 计算可用的符文孔位增益
  4658.                 let availableRuneBonus = 0;
  4659.                 // 计算剩余可用的孔数
  4660.                 const remainingSlots = numSockets - insertedRuneCount;
  4661.                 availableRuneBonus = remainingSlots * 20;
  4662.  
  4663.                 // 7. 计算基础护甲
  4664.                 // 当前护甲 = 基础护甲 * (1 + 当前品质/100) * (1 + (已插入符文增益 + 装备增益 + 护甲符文增益)/100)
  4665.                 const baseArmour = Math.round(totalArmour / (1 + currentQuality/100) / (1 + (insertedRuneBonus + armourInc + armourRuneInc)/100));
  4666.  
  4667.                 // 8. 计算最大可能护甲（考虑品质提升和剩余符文孔）
  4668.                 // 最大护甲 = 基础护甲 * (1 + (当前品质 + 品质差值)/100) * (1 + (装备增益 + 已插入符文增益 + 可用符文增益)/100)
  4669.                 const maxArmour = Math.round(baseArmour * (1 + (currentQuality + qualityDiff)/100) * (1 + (armourInc + insertedRuneBonus + availableRuneBonus)/100));
  4670.  
  4671.                 // 创建护甲显示元素
  4672.                 const armourDisplay = document.createElement('span');
  4673.                 armourDisplay.className = 'armour-display';
  4674.                 armourDisplay.style.cssText = `
  4675.                     color: #CD853F;
  4676.                     font-weight: bold;
  4677.                     margin-left: 10px;
  4678.                 `;
  4679.                 armourDisplay.textContent = `总护甲: ${maxArmour}`;
  4680.  
  4681.                 // 将护甲显示添加到护甲后面
  4682.                 armourSpan.appendChild(armourDisplay);
  4683.  
  4684.                 successCount++;
  4685.                 processedCount++;
  4686.  
  4687.                 // 添加调试信息
  4688.                 console.debug(`Item ${index} Armour calculation:`, {
  4689.                     totalArmour,
  4690.                     currentQuality,
  4691.                     qualityDiff,
  4692.                     armourInc,
  4693.                     insertedRuneBonus,
  4694.                     insertedRuneCount,
  4695.                     numSockets,
  4696.                     availableRuneBonus,
  4697.                     baseArmour,
  4698.                     maxArmour
  4699.                 });
  4700.             } catch (error) {
  4701.                 console.error(`Error calculating armour for item ${index}:`, error);
  4702.             }
  4703.         });
  4704.  
  4705.         console.log(`Armour calculation completed: ${successCount} successful, ${processedCount} processed out of ${items.length} items`);
  4706.  
  4707.         // 更新护甲排序面板
  4708.         updateArmourPanel();
  4709.     }
  4710.  
  4711.     // 创建护甲排序面板
  4712.     function createArmourPanel() {
  4713.         const panel = document.createElement('div');
  4714.         panel.id = 'armour-sort-panel';
  4715.         panel.style.cssText = `
  4716.             position: fixed;
  4717.             right: 20px;
  4718.             top: 50%;
  4719.             transform: translateY(calc(-50% + 600px));
  4720.             background: rgba(28, 28, 28, 0.95);
  4721.             padding: 8px;
  4722.             border-radius: 6px;
  4723.             box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
  4724.             border: 1px solid #444;
  4725.             width: 180px;
  4726.             max-height: 60vh;
  4727.             z-index: 9997;
  4728.             display: none;
  4729.         `;
  4730.  
  4731.         // 添加标题
  4732.         const title = document.createElement('div');
  4733.         title.style.cssText = `
  4734.             font-weight: bold;
  4735.             color: #FF6347;
  4736.             margin-bottom: 6px;
  4737.             padding-bottom: 3px;
  4738.             border-bottom: 1px solid #444;
  4739.             display: flex;
  4740.             justify-content: space-between;
  4741.             align-items: center;
  4742.             cursor: pointer;
  4743.             font-size: 14px;
  4744.             user-select: none;
  4745.             height: 18px;
  4746.         `;
  4747.  
  4748.         // 添加展开/收起指示器
  4749.         const indicator = document.createElement('span');
  4750.         indicator.textContent = '▼';
  4751.         indicator.style.marginRight = '3px';
  4752.         indicator.style.fontSize = '10px';
  4753.         indicator.id = 'integrated-panel-indicator';
  4754.  
  4755.         const titleText = document.createElement('span');
  4756.         titleText.textContent = 'AR';
  4757.  
  4758.         const titleLeft = document.createElement('div');
  4759.         titleLeft.style.display = 'flex';
  4760.         titleLeft.style.alignItems = 'center';
  4761.         titleLeft.appendChild(indicator);
  4762.         titleLeft.appendChild(titleText);
  4763.  
  4764.         title.appendChild(titleLeft);
  4765.  
  4766.         // 添加关闭按钮
  4767.         const closeBtn = document.createElement('button');
  4768.         closeBtn.textContent = '×';
  4769.         closeBtn.style.cssText = `
  4770.             background: none;
  4771.             border: none;
  4772.             color: #999;
  4773.             font-size: 20px;
  4774.             cursor: pointer;
  4775.             padding: 0 5px;
  4776.         `;
  4777.         closeBtn.onclick = (e) => {
  4778.             e.stopPropagation();
  4779.             panel.style.display = 'none';
  4780.         };
  4781.         title.appendChild(closeBtn);
  4782.  
  4783.         // 添加内容容器
  4784.         const content = document.createElement('div');
  4785.         content.id = 'armour-sort-content';
  4786.         content.style.cssText = `
  4787.             max-height: calc(60vh - 35px);
  4788.             overflow-y: auto;
  4789.             transition: max-height 0.3s ease-out;
  4790.             padding-right: 2px;
  4791.         `;
  4792.  
  4793.         // 添加展开/收起功能
  4794.         let isExpanded = true;
  4795.         title.onclick = () => {
  4796.             isExpanded = !isExpanded;
  4797.             content.style.maxHeight = isExpanded ? 'calc(60vh - 35px)' : '0';
  4798.             content.style.overflow = isExpanded ? 'auto' : 'hidden';
  4799.             indicator.textContent = isExpanded ? '▼' : '▶';
  4800.         };
  4801.  
  4802.         // 添加组件到面板
  4803.         panel.appendChild(title);
  4804.         panel.appendChild(content);
  4805.  
  4806.         // 添加到文档
  4807.         document.body.appendChild(panel);
  4808.  
  4809.         console.log('Armour panel created successfully');
  4810.         return panel;
  4811.     }
  4812.  
  4813.     // 更新护甲排序面板
  4814.     function updateArmourPanel() {
  4815.         try {
  4816.             console.log('Updating armour panel...');
  4817.  
  4818.             // 获取或创建面板
  4819.             const panel = document.getElementById('integrated-sort-panel') || createIntegratedPanel();
  4820.             const content = document.getElementById('armour-sort-content');
  4821.             if (!content) {
  4822.                 console.error('Armour sort content not found');
  4823.                 return;
  4824.             }
  4825.  
  4826.             // 清空现有内容
  4827.             content.innerHTML = '';
  4828.  
  4829.             // 获取所有物品
  4830.             const items = document.querySelectorAll('.row[data-id]');
  4831.             const armourData = [];
  4832.  
  4833.             // 收集护甲数据
  4834.             items.forEach(item => {
  4835.                 const armourDisplay = item.querySelector('.armour-display');
  4836.                 if (armourDisplay) {
  4837.                     const armour = parseInt(armourDisplay.textContent.replace('总护甲: ', ''));
  4838.  
  4839.                     // 获取价格
  4840.                     const priceElement = item.querySelector('.price [data-field="price"]');
  4841.                     let price = '未标价';
  4842.                     if (priceElement) {
  4843.                         const amount = priceElement.querySelector('span:not(.price-label):not(.currency-text)');
  4844.                         const currencyText = priceElement.querySelector('.currency-text');
  4845.                         if (amount && currencyText) {
  4846.                             const amountText = amount.textContent.trim();
  4847.                             const currency = currencyText.querySelector('span')?.textContent || currencyText.textContent;
  4848.                             // 使用全局的convertCurrencyText函数
  4849.                             const simpleCurrency = convertCurrencyText(currency);
  4850.                             price = `${amountText}${simpleCurrency}`;
  4851.                         }
  4852.                     }
  4853.  
  4854.                     armourData.push({
  4855.                         armour,
  4856.                         price,
  4857.                         element: item
  4858.                     });
  4859.                 }
  4860.             });
  4861.  
  4862.             console.log(`Found ${armourData.length} items with armour data`);
  4863.  
  4864.             // 如果没有护甲数据，隐藏护甲选项卡
  4865.             const armourTab = panel.querySelector('[data-tab="armour"]');
  4866.             if (armourData.length === 0) {
  4867.                 if (armourTab) armourTab.style.display = 'none';
  4868.  
  4869.                 // 如果其他选项卡也是隐藏的，则隐藏整个面板
  4870.                 const dpsTab = panel.querySelector('[data-tab="dps"]');
  4871.                 const shieldTab = panel.querySelector('[data-tab="shield"]');
  4872.                 const evasionTab = panel.querySelector('[data-tab="evasion"]');
  4873.                 const defenceTab = panel.querySelector('[data-tab="defence"]');
  4874.                 
  4875.                 // 检查是否所有选项卡都隐藏了
  4876.                 if ((dpsTab && dpsTab.style.display === 'none') &&
  4877.                     (shieldTab && shieldTab.style.display === 'none') &&
  4878.                     (evasionTab && evasionTab.style.display === 'none') &&
  4879.                     (defenceTab && defenceTab.style.display === 'none')) {
  4880.                     panel.style.display = 'none';
  4881.                 }
  4882.                 // 移除自动切换到其他选项卡的代码，保留当前选项卡状态
  4883.                 return;
  4884.             } else {
  4885.                 // 有护甲数据，确保护甲选项卡可见
  4886.                 if (armourTab) armourTab.style.display = '';
  4887.             }
  4888.  
  4889.             // 按护甲值从高到低排序
  4890.             armourData.sort((a, b) => b.armour - a.armour);
  4891.  
  4892.             // 更新面板内容
  4893.             armourData.forEach(({armour, price, element}) => {
  4894.                 const armourItem = document.createElement('div');
  4895.                 armourItem.className = 'dps-item'; // 复用DPS项的样式
  4896.  
  4897.                 // 创建护甲显示
  4898.                 const armourText = document.createElement('span');
  4899.                 armourText.className = 'armour-value'; // 使用护甲专用的样式
  4900.                 armourText.textContent = armour.toString();
  4901.  
  4902.                 // 创建价格显示
  4903.                 const priceText = document.createElement('span');
  4904.                 priceText.className = 'price-value';
  4905.                 priceText.textContent = price;
  4906.  
  4907.                 // 添加到护甲项
  4908.                 armourItem.appendChild(armourText);
  4909.                 armourItem.appendChild(priceText);
  4910.  
  4911.                 // 添加点击事件
  4912.                 armourItem.onclick = () => {
  4913.                     element.scrollIntoView({ behavior: 'smooth', block: 'center' });
  4914.                     // 添加高亮效果
  4915.                     element.style.transition = 'background-color 0.3s';
  4916.                     element.style.backgroundColor = 'rgba(255, 99, 71, 0.2)';
  4917.                     setTimeout(() => {
  4918.                         element.style.backgroundColor = '';
  4919.                     }, 1500);
  4920.                 };
  4921.  
  4922.                 content.appendChild(armourItem);
  4923.             });
  4924.  
  4925.             // 显示面板
  4926.             panel.style.display = 'block';
  4927.             console.log('Armour panel updated successfully');
  4928.         } catch (error) {
  4929.             console.error('Error updating armour panel:', error);
  4930.         }
  4931.     }
  4932.  
  4933.     // 计算总防御值（护盾+闪避+护甲）
  4934.     function calculateDefence() {
  4935.         console.log('Calculating Defence...');
  4936.         const items = document.querySelectorAll('.row[data-id]');
  4937.         console.log('Found items:', items.length);
  4938.         
  4939.         let processedCount = 0;
  4940.         let successCount = 0;
  4941.         
  4942.         items.forEach((item, index) => {
  4943.             try {
  4944.                 // 如果已经计算过总防御值，则跳过
  4945.                 if (item.querySelector('.defence-display')) {
  4946.                     processedCount++;
  4947.                     return;
  4948.                 }
  4949.  
  4950.                 // 获取护盾、闪避和护甲值
  4951.                 let totalDefence = 0;
  4952.                 
  4953.                 // 获取护盾值
  4954.                 const shieldDisplay = item.querySelector('.shield-display');
  4955.                 if (shieldDisplay) {
  4956.                     const shield = parseInt(shieldDisplay.textContent.replace('总护盾: ', ''));
  4957.                     if (!isNaN(shield)) {
  4958.                         totalDefence += shield;
  4959.                     }
  4960.                 }
  4961.                 
  4962.                 // 获取闪避值
  4963.                 const evasionDisplay = item.querySelector('.evasion-display');
  4964.                 if (evasionDisplay) {
  4965.                     const evasion = parseInt(evasionDisplay.textContent.replace('总闪避: ', ''));
  4966.                     if (!isNaN(evasion)) {
  4967.                         totalDefence += evasion;
  4968.                     }
  4969.                 }
  4970.                 
  4971.                 // 获取护甲值
  4972.                 const armourDisplay = item.querySelector('.armour-display');
  4973.                 if (armourDisplay) {
  4974.                     const armour = parseInt(armourDisplay.textContent.replace('总护甲: ', ''));
  4975.                     if (!isNaN(armour)) {
  4976.                         totalDefence += armour;
  4977.                     }
  4978.                 }
  4979.  
  4980.                 // 创建总防御显示元素
  4981.                 const defenceDisplay = document.createElement('span');
  4982.                 defenceDisplay.className = 'defence-display';
  4983.                 defenceDisplay.style.cssText = `
  4984.                     color: #9370DB;
  4985.                     font-weight: bold;
  4986.                     margin-left: 5px;
  4987.                     font-size: 14px;
  4988.                     background-color: rgba(147, 112, 219, 0.1);
  4989.                     padding: 1px 4px;
  4990.                     border-radius: 3px;
  4991.                 `;
  4992.                 defenceDisplay.textContent = `DEF: ${totalDefence}`;
  4993.  
  4994.                 // 将总防御显示添加到装备名称旁边
  4995.                 const itemHeader = item.querySelector('.itemHeader');
  4996.                 if (itemHeader) {
  4997.                     // 找到装备名称元素
  4998.                     const itemName = itemHeader.querySelector('.itemName');
  4999.                     if (itemName) {
  5000.                         // 添加到装备名称后面
  5001.                         itemName.appendChild(defenceDisplay);
  5002.                     } else {
  5003.                         // 如果找不到装备名称，直接添加到itemHeader
  5004.                         itemHeader.appendChild(defenceDisplay);
  5005.                     }
  5006.                 } else {
  5007.                     // 如果找不到itemHeader，尝试添加到其他位置
  5008.                     const esSpan = item.querySelector('span[data-field="es"]');
  5009.                     const evSpan = item.querySelector('span[data-field="ev"]');
  5010.                     const arSpan = item.querySelector('span[data-field="ar"]');
  5011.                     
  5012.                     if (esSpan) {
  5013.                         esSpan.appendChild(defenceDisplay);
  5014.                     } else if (evSpan) {
  5015.                         evSpan.appendChild(defenceDisplay);
  5016.                     } else if (arSpan) {
  5017.                         arSpan.appendChild(defenceDisplay);
  5018.                     }
  5019.                 }
  5020.                 
  5021.                 successCount++;
  5022.                 processedCount++;
  5023.  
  5024.                 // 添加调试信息
  5025.                 console.debug(`Item ${index} Defence calculation: ${totalDefence}`);
  5026.             } catch (error) {
  5027.                 console.error(`Error calculating defence for item ${index}:`, error);
  5028.             }
  5029.         });
  5030.  
  5031.         console.log(`Defence calculation completed: ${successCount} successful, ${processedCount} processed out of ${items.length} items`);
  5032.  
  5033.         // 更新总防御排序面板
  5034.         updateDefencePanel();
  5035.     }
  5036.  
  5037.     // 更新总防御排序面板
  5038.     function updateDefencePanel() {
  5039.         try {
  5040.             console.log('Updating defence panel...');
  5041.             
  5042.             // 获取或创建面板
  5043.             const panel = document.getElementById('integrated-sort-panel') || createIntegratedPanel();
  5044.             const content = document.getElementById('defence-sort-content');
  5045.             if (!content) {
  5046.                 console.error('Defence sort content not found');
  5047.                 return;
  5048.             }
  5049.  
  5050.             // 清空现有内容
  5051.             content.innerHTML = '';
  5052.             
  5053.             // 清除可能存在的旧数据属性
  5054.             content.removeAttribute('data-shield-content');
  5055.             content.removeAttribute('data-evasion-content');
  5056.             content.removeAttribute('data-armour-content');
  5057.             content.removeAttribute('data-dps-content');
  5058.  
  5059.             // 获取所有物品
  5060.             const items = document.querySelectorAll('.row[data-id]');
  5061.             const defenceData = [];
  5062.  
  5063.             // 收集总防御数据
  5064.             items.forEach(item => {
  5065.                 const defenceDisplay = item.querySelector('.defence-display');
  5066.                 if (defenceDisplay) {
  5067.                     const defence = parseInt(defenceDisplay.textContent.replace('DEF: ', ''));
  5068.                     
  5069.                     // 获取价格
  5070.                     const priceElement = item.querySelector('.price [data-field="price"]');
  5071.                     let price = '未标价';
  5072.                     if (priceElement) {
  5073.                         const amount = priceElement.querySelector('span:not(.price-label):not(.currency-text)');
  5074.                         const currencyText = priceElement.querySelector('.currency-text');
  5075.                         if (amount && currencyText) {
  5076.                             const amountText = amount.textContent.trim();
  5077.                             const currency = currencyText.querySelector('span')?.textContent || currencyText.textContent;
  5078.                             // 使用全局的convertCurrencyText函数
  5079.                             const simpleCurrency = convertCurrencyText(currency);
  5080.                             price = `${amountText}${simpleCurrency}`;
  5081.                         }
  5082.                     }
  5083.  
  5084.                     defenceData.push({
  5085.                         defence,
  5086.                         price,
  5087.                         element: item
  5088.                     });
  5089.                 }
  5090.             });
  5091.  
  5092.             console.log(`Found ${defenceData.length} items with defence data`);
  5093.  
  5094.             // 如果没有总防御数据，隐藏总防御选项卡
  5095.             const defenceTab = panel.querySelector('[data-tab="defence"]');
  5096.             if (defenceData.length === 0) {
  5097.                 if (defenceTab) defenceTab.style.display = 'none';
  5098.                 
  5099.                 // 如果其他选项卡也是隐藏的，则隐藏整个面板
  5100.                 const dpsTab = panel.querySelector('[data-tab="dps"]');
  5101.                 const shieldTab = panel.querySelector('[data-tab="shield"]');
  5102.                 const evasionTab = panel.querySelector('[data-tab="evasion"]');
  5103.                 const armourTab = panel.querySelector('[data-tab="armour"]');
  5104.                 
  5105.                 // 检查是否所有选项卡都隐藏了
  5106.                 if ((dpsTab && dpsTab.style.display === 'none') && 
  5107.                     (shieldTab && shieldTab.style.display === 'none') &&
  5108.                     (evasionTab && evasionTab.style.display === 'none') &&
  5109.                     (armourTab && armourTab.style.display === 'none')) {
  5110.                     panel.style.display = 'none';
  5111.                 }
  5112.                 // 移除自动切换到其他选项卡的代码，保留当前选项卡状态
  5113.                 return;
  5114.             } else {
  5115.                 // 有总防御数据，确保总防御选项卡可见
  5116.                 if (defenceTab) defenceTab.style.display = '';
  5117.             }
  5118.  
  5119.             // 按总防御值从高到低排序
  5120.             defenceData.sort((a, b) => b.defence - a.defence);
  5121.  
  5122.             // 更新面板内容
  5123.             defenceData.forEach(({defence, price, element}) => {
  5124.                 const defenceItem = document.createElement('div');
  5125.                 defenceItem.className = 'dps-item'; // 复用DPS项的样式
  5126.                 
  5127.                 // 创建总防御显示
  5128.                 const defenceText = document.createElement('span');
  5129.                 defenceText.className = 'defence-value';
  5130.                 defenceText.textContent = defence.toString();
  5131.                 
  5132.                 // 创建价格显示
  5133.                 const priceText = document.createElement('span');
  5134.                 priceText.className = 'price-value';
  5135.                 priceText.textContent = price;
  5136.                 
  5137.                 // 添加到总防御项
  5138.                 defenceItem.appendChild(defenceText);
  5139.                 defenceItem.appendChild(priceText);
  5140.                 
  5141.                 // 添加点击事件
  5142.                 defenceItem.onclick = () => {
  5143.                     element.scrollIntoView({ behavior: 'smooth', block: 'center' });
  5144.                     // 添加高亮效果
  5145.                     element.style.transition = 'background-color 0.3s';
  5146.                     element.style.backgroundColor = 'rgba(147, 112, 219, 0.2)';
  5147.                     setTimeout(() => {
  5148.                         element.style.backgroundColor = '';
  5149.                     }, 1500);
  5150.                 };
  5151.  
  5152.                 content.appendChild(defenceItem);
  5153.             });
  5154.  
  5155.             // 显示面板
  5156.             panel.style.display = 'block';
  5157.             console.log('Defence panel updated successfully');
  5158.         } catch (error) {
  5159.             console.error('Error updating defence panel:', error);
  5160.         }
  5161.     }
  5162. })();

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址