diff --git a/repo/js/日志分析工具/README.md b/repo/js/日志分析工具/README.md
index 7151149cf..0bb9a7ac5 100644
--- a/repo/js/日志分析工具/README.md
+++ b/repo/js/日志分析工具/README.md
@@ -1,348 +1,305 @@
-# BetterGI 日志分析工具
-
-一个用于分析 Better Genshin Impact 自动化工具日志的网页工具，支持拖放操作、多种显示模式和丰富的快捷键功能。
-
-**在线地址**: https://this-fish.github.io/Read_BetterGI_Log/index.html
-
-## 🌟 核心功能
-
-### 日志解析
-- 📁 **拖放分析** - 直接拖拽日志文件到页面即可分析
-- 📱 **移动端支持** - 手机/平板设备专用上传界面
-- 🔄 **多文件合并** - 自动按时间顺序合并多个日志文件
-- ⏰ **智能时间解析** - 自动处理跨日日志和时间推算
-
-### 数据可视化
-- 📊 **详细统计** - 复活次数、重试次数、卡死点坐标等完整数据
-- 🎯 **坐标追踪** - 查看死亡前最近的X/Y轴坐标
-- ⚡ **实时高亮** - 鼠标悬停行高亮，清晰指示当前查看行
-- 🌓 **主题切换** - 自动/手动切换亮色/暗色主题(00:00~06:30时自动暗色主题)
-
-### 交互功能
-- ⌨️ **丰富快捷键** - 20+个快捷键覆盖所有操作
-- 🔍 **智能筛选** - 按任务名称关键字筛选显示
-- 📈 **数据聚焦** - 隐藏零统计任务，专注问题分析
-- 📤 **导出分享** - 静态模式方便截图和分享分析结果
-
-## 🚀 快速开始
-
-### 基本使用
-1. **打开工具** - 访问上述在线地址或订阅此脚本后打开你BGI所安裝的目錄/User/JsScript/日志分析工具/index.html
-2. **上传日志** - 拖放BetterGI日志文件（文件名以`better-genshin-impact`开头）
- - BetterGI日志文件所在位置如下
-   - C:\你BGI所安裝的目錄\BetterGI\log
-   - 或使用BGI打開目錄
-   - <img width="905" height="599" alt="QQ_1759765939508" src="https://github.com/user-attachments/assets/615087a5-eead-4eb8-8028-4bfe74d9b8ff" />
-
-3. **查看分析** - 工具自动解析并显示统计信息
-
-### 移动设备使用
-1. 点击"选择日志文件"按钮
-2. 选择日志文件后自动解析
-3. 使用底部功能按钮控制显示选项
-
-## ⌨️ 快捷键大全
-
-### 显示控制
-| 快捷键 | 功能说明 | 状态指示 |
-|--------|----------|----------|
-| `T` | 切换时间列显示/隐藏 | 右下角提示 |
-| `Y` | 切换统计列显示/隐藏 | 右下角提示 |
-| `U` | 切换表格格式（新版/旧版） | 右下角提示 |
-| `I` | 切换拾取物列显示/隐藏 | 右下角提示 |
-| `J` | 隐藏/显示零统计任务 | 右下角提示 |
-| `H` | 任务名称关键字筛选 | 左上角提示 |
-| `P` | 进入/退出导出模式 | 左上角提示 |
-
-### 视图操作
-| 快捷键 | 功能说明 |
-|--------|----------|
-| `~` | 切换亮色/暗色主题 |
-| `R` | 重置所有弹窗位置 |
-| `W` | 页面上滚 |
-| `S` | 页面下滚 |
-| `Alt + F` | 切换全屏模式 |
-| `.` | 新标签页打开工具 |
-| `Alt + L` | 显示/隐藏功能按钮区 |
-
-### 实用计算工具
-| 快捷键 | 功能说明 |
-|--------|----------|
-| `6` | 计算原神下次60体力时间 |
-| `7` | 计算原神下次40体力时间 |
-| `8` | 计算遊戲體力体力下次到指定体力时间輸入(現在体力,目標体力,体力cd) |
-| `9` | 计算时间距离现在多久 |
-| `右2` | 计算日期+3天 |
-| `右3` | 计算两个时间点间隔 |
-| `右5` | 计算N天后的日期 |
-| `右7` | 计算原神下次120体力时间 |
-| `右8` | 计算HH.MM后的时间 |
-| `右9` | 计算时间+46小时后 |
-
-## 📊 数据列说明
-
-### 基本信息
-- **任务名称** - 地图追踪任务或脚本名称
-- **开始时间** - 任务开始执行的时间
-- **结束时间** - 任务完成或中断的时间  
-- **耗时** - 任务执行总时长
-
-### 统计指标
-- **复活次数** - 前往七天神像复活的次数（红色≥2次）。
-  - **小数-0.9表示**：当前角色血量过低、返回七天神像回血
-- **重试次数** - 路线重试次数（红色≥2次）
-  - **注意**：当只有重试次数而无卡死或复活时，任务名称会变为红色
-- **疑似卡死** - 卡死脱离尝试次数（可查看坐标）
-- **过远跳过** - 距离过远跳过的路径点（红色≥2次）
-- **战斗超时** - 战斗超时次数（红色≥1次）
-- **传送失败** - 传送失败重试次数（红色≥3次）
-
-### 交互功能
-- **悬停查看** - 鼠标悬停统计数字显示详细信息
-- **双击重置** - 双击单元格重置弹窗位置
-- **点击固定** - 点击单元格固定/取消固定弹窗
-
-## 🎯 高级功能
-
-### H键 - 任务筛选模式
-```
-输入格式：关键词1,关键词2,关键词3
-示例：蒙德,璃月,稻妻
-```
-- 多关键字逗号分隔
-- 支持部分匹配（不区分大小写）
-- 筛选时自动隐藏所有拾取物行
-- 左上角显示当前筛选状态
-
-### J键 - 零统计任务隐藏
-- 自动隐藏所有異常统计值为零的任务
-- 帮助聚焦有问题任务
-- 与筛选模式协同工作
-
-### P键 - 导出静态模式
-- 所有弹窗内容内联显示
-- 方便截图和保存分享
-- 使用浏览器"另存为"功能导出
-
-## 🎨 界面说明
-
-### 表格格式
-**旧版格式**（默认）
-- 单行显示完整任务信息
-- 适合详细数据分析
-
-**新版格式(BGI現版格式)**（按U切换）
-- 任务信息分两行显示
-- 适合快速浏览
-
-### 特殊事件检测
-工具自动检测并标记以下种特殊事件，按错误类型分类：
-
-| 事件类型 | 颜色标记 | 事件说明 | 
-|----------|----------|----------|
-| **自动恢复事件** | | |
-| 自动吃药恢复 | 🟢 绿色 | 自动处理红血状态 |
-| 自动领取派遣任务 | 🟠 橙色 | 正常功能执行 |
-| **暂停与中断事件** | | |
-| 快捷键暂停 | 🟣 粉色 | 用户手动暂停 |
-| 窗口焦点异常 | 🟣 粉色 | 游戏窗口失去焦点 |
-| 切换区域失败 | 🟣 粉色 | 游戏区域切换失败 |
-| **用户配置错误** | 🔧 | |
-| 路径文件丢失 | 🔴 红色 | 配置文件缺失 |
-| 未匹配战斗脚本 | 🔴 红色 | 战斗脚本配置错误 |
-| 战斗策略错误 | 🔴 红色 | 策略脚本语法错误 |
-| 缺少元素采集角色 | 🔴 红色 | 队伍缺少对应元素角色 |
-| 缺少纳西妲角色 | 🔴 红色 | 队伍缺少纳西妲角色 |
-| **BGI运行时错误** | 🐛 | |
-| 队伍角色识别失败 | 🔴 红色 | 角色识别功能异常 |
-| 未能返回主界面 | 🔴 红色 | 界面导航失败 |
-| 切换队伍失败 | 🔴 红色 | 队伍切换功能异常 |
-| 自动重启bgi | 🔴 红色 | 调度器任务出现未预期的异常，自动重启bgi |
-| **网络与地图问题** | 🌐 | |
-| 打开地图失败 | 🔴 红色 | 地图功能异常 |
-| 传送点不存在 | 🔴 红色 | 传送点识别问题 |
-| 识别大地图失败 | 🔴 红色 | 地图定位失败 |
-| **用户主动操作** | 👤 | |
-| 脚本异常结束 | 🔴 红色 | 任务被异常中断 |
-
-**计数显示**：同一事件多次发生时会显示次数，如"快捷键暂停 (3)"
-
-## 📱 移动端适配
-
-### 专用界面
-- 触摸友好的大按钮设计
-- 自适应屏幕尺寸的布局
-- 简化的操作流程
-
-### 功能按钮区
-6个核心功能按钮：
-1. 🌓 主题切换
-2. ⏰ 时间列控制
-3. 📊 统计列控制
-4. 📦 拾取物控制
-5. 📤 导出模式
-6. 🔍 异常任务筛选
-
-## 🔧 技术规格
-
-### 支持格式
-- **日志版本**: BetterGI 0.51.0+
-- **文件命名**: `better-genshin-impact` 开头
-- **日期识别**: 自动从文件名解析日期
-- **编码支持**: UTF-8 文本格式
-
-### 性能特性
-- 💾 客户端本地处理，无数据上传
-- 📈 虚拟滚动支持大数据量
-- 🔄 实时响应式布局
-
-## ❓ 常见问题
-
-### 数据解析问题
-**Q: 为什么有些任务显示"进行中"？**  
-A: 日志中任务没有正常结束记录，可能是脚本被中断。
-
-**Q: 坐标信息为什么有时缺失？**  
-A: 只有在卡死或复活前有坐标记录时才会显示。
-
-**Q: 时间显示异常怎么办？**  
-A: 工具会自动处理跨日情况，如仍有问题请检查日志完整性。
-
-### 功能使用问题
-**Q: 如何分享分析结果？**  
-A: 使用P键进入导出模式，然后用浏览器"另存为"保存HTML文件。或截图分享
-
-**Q: 筛选模式如何退出？**  
-A: 再次按下H键即可退出筛选模式。
-
-**Q: 弹窗位置乱了怎么办？**  
-A: 按R键重置所有弹窗位置，或双击单元格重置单个弹窗。
-
-### 移动端问题
-**Q: 手机上传文件失败？**  
-A: 确保文件命名格式是`better-genshin-impact日期.log`。
-
-**Q: 移动端按钮显示不全？**  
-A: 横屏模式可获得更好体验。
-
-## 📋 更新日志
-### 20251006
-  - 增加錯誤&其他訊息
-    - 当前获取焦点的窗口不是原神，暂停
-
-### 20251003
-- ❌ 新增错误检测
- - 调度器任务出现未预期的异常，自动重启bgi
-   - 錯誤過多導至 bgi 自动重启
-### 20251001
-- 修正 筛选模式配置组名匹配時，沒有隱藏 整組都是0異常的配置組
-- 修正 筛选模式配置组名匹配時，舊版UI沒有隱藏0異常任務行的的拾取物
-- 條正 筛选模式時+只显示異常任務行，切換表格格式後沒有只显示 筛选關鍵字匹配的異常任務行
-
-### 20250930
-- 优化配置组摺叠功能
-  - 在配置组資訊固定在頂部時，點擊摺疊配置組，會自動將該配置組滾動到頂部位置
-  - 确保在点击配置组标题时，被折叠的配置组始终滚动到页面最顶部位置。
-- 改善性能
-  - 节流和防抖：对滚动和调整大小事件使用节流和防抖
-  - 批量DOM操作：减少重排重绘
-  - 缓存DOM查询：避免重复查询
-  - 使用requestAnimationFrame：优化动画性能
-  - 减少事件监听器：优化事件处理
-  - 错误处理：添加try-catch防止崩溃
-- 筛选功能修改
-  - 配置组名匹配 → 显示整个配置组
-  - 配置组名不匹配但有任务匹配 → 显示配置组+匹配的任务
-  - 配置组名和任务都不匹配 → 隐藏整个配置组
-
-### 20250929
-- 增加快捷鍵
-  - 快捷鍵6，計算下次60體力恢復時間
-  - 快捷鍵8，計算下次指定體力恢復時間
-- 队伍角色行增加顯示行走位、生存位資訊
-  - 行走位、生存位資訊(僅供參考)
-- 調整部份UI
-  - 配置組資訊始終顯示在頂部
-
-### 2025-09-27
-- 🎨 UI优化调整
-  - 表头悬浮位置更贴近顶部
-  - 功能按钮区域增加边距
-  - 修复折叠展开箭头显示问题
-- 👥 配置组增加队伍角色显示
-  - 显示该组运行时识别到的队伍角色组合
-
-### 2025-09-25  
-- 🔍 新增任务筛选功能（H键）
-  - 按任务名称关键字筛选显示
-  - 多关键词逗号分隔
-  - 筛选模式隐藏拾取物行
-- 🔄 状态持久化优化
-  - 第二次读档保留各功能状态
-- ❌ 新增错误检测
-  - "未能返回主界面"错误识别
-
-### 2025-09-23
-- ❌ 新增错误检测
-  - 选项列表不存在传送点重试
-  - 识别大地图位置失败
-  - 切换区域失败
-
-### 2025-09-21
-- ❌ 新增错误检测
-  - 窗口焦点异常恢复
-  - 队伍角色识别失败  
-  - 打开大地图失败
-- 🔢 多次异常显示次数
-  - 如：快捷键暂停 (2)
-
-### 2025-09-06
-- ❌ 新增错误检测
-  - 切换队伍失败提示
-
-### 2025-09-05  
-- ❌ 新增错误检测
-  - 未匹配到任何战斗脚本
-
-### 2025-08-31
-- 🎨 彩色事件标记系统
-  - 战斗策略错误检测
-  - 缺少元素角色提示
-  - 路径文件丢失警告
-  - 自动吃药事件标记
-
-### 2025-08-30
-- 📍 坐标捕获增强
-  - 补充精确接近目标点坐标
-- 🎨 暗色模式优化
-  - 修复任务名称红色显示条件
-
-### 2025-08-23
-- 📱 移动端功能增强
-  - 专用功能按钮区
-  - Alt+L显示控制快捷键
-- ✅ 导出模式确认操作
-  - Enter确认，ESC取消
-
-### 2025-08-21
-- 🔍 J键零统计任务隐藏
-- 📱 移动设备完整支持
-- 🎯 行高亮交互优化
-
-### 2025-08-20
-- 📍 死亡坐标追踪功能
-- 🪟 弹窗交互体验优化
-
-*更早版本包含基础日志解析和显示功能*
-
-## 📞 技术支持
-
-### 注意事项
-- 🔒 工具完全在浏览器本地运行，无数据上传
-- 📝 仅支持BetterGI官方格式日志文件
-- ⚠️ 分析结果仅供参考，不保证100%准确
-
----
-
-*最后更新: 2025-09-27*  
-*适配 BetterGI 0.51.0+ 版本*
+# BetterGI 日志分析工具
+
+一个用于分析 Better Genshin Impact 自动化工具日志的网页工具，支持拖放操作、多种显示模式和丰富的快捷键功能。
+
+**在线地址**: https://this-fish.github.io/Read_BetterGI_Log/index.html
+
+## 🌟 核心功能
+
+### 日志解析
+- 📁 **拖放分析** - 直接拖拽日志文件到页面即可分析
+- 📱 **移动端支持** - 手机/平板设备专用上传界面
+- 🔄 **多文件合并** - 自动按时间顺序合并多个日志文件
+- ⏰ **智能时间解析** - 自动处理跨日日志和时间推算
+
+### 数据可视化
+- 📊 **详细统计** - 复活次数、重试次数、卡死点坐标等完整数据
+- 🎯 **坐标追踪** - 查看死亡前最近的X/Y轴坐标
+- ⚡ **实时高亮** - 鼠标悬停行高亮，清晰指示当前查看行
+- 🌓 **主题切换** - 自动/手动切换亮色/暗色主题(00:00~06:30时自动暗色主题)
+
+### 交互功能
+- ⌨️ **丰富快捷键** - 20+个快捷键覆盖所有操作
+- 🔍 **智能筛选** - 按任务名称关键字筛选显示
+- 📈 **数据聚焦** - 隐藏零统计任务，专注问题分析
+- 📤 **导出分享** - 静态模式方便截图和分享分析结果
+
+## 🚀 快速开始
+
+### 基本使用
+1. **打开工具** - 访问上述在线地址
+2. **上传日志** - 拖放BetterGI日志文件（文件名以`better-genshin-impact`开头）
+ - BetterGI日志文件所在位置如下
+   - C:\你BGI所安裝的目錄\BetterGI\log
+   - 或使用BGI打開目錄
+   - <img width="905" height="599" alt="QQ_1759765939508" src="https://github.com/user-attachments/assets/615087a5-eead-4eb8-8028-4bfe74d9b8ff" />
+
+3. **查看分析** - 工具自动解析并显示统计信息
+
+### 移动设备使用
+1. 点击"选择日志文件"按钮
+2. 选择日志文件后自动解析
+3. 使用底部功能按钮控制显示选项
+
+## ⌨️ 快捷键大全
+
+### 显示控制
+| 快捷键 | 功能说明 | 状态指示 |
+|--------|----------|----------|
+| `T` | 切换时间列显示/隐藏 | 右下角提示 |
+| `Y` | 切换统计列显示/隐藏 | 右下角提示 |
+| `U` | 切换表格格式（新版/旧版） | 右下角提示 |
+| `I` | 切换拾取物列显示/隐藏 | 右下角提示 |
+| `J` | 隐藏/显示零统计任务 | 右下角提示 |
+| `H` | 任务名称关键字筛选 | 左上角提示 |
+| `P` | 进入/退出导出模式 | 左上角提示 |
+| `[` | 进入/退出自由编辑网页模式 | 无 |
+
+### 视图操作
+| 快捷键 | 功能说明 |
+|--------|----------|
+| `~` | 切换亮色/暗色主题 |
+| `R` | 重置所有弹窗位置 |
+| `W` | 页面上滚 |
+| `S` | 页面下滚 |
+| `G` | 打开/关闭配置组导航 |
+| `Alt + F` | 切换全屏模式 |
+| `.` | 新标签页打开工具 |
+| `Alt + L` | 显示/隐藏功能按钮区 |
+| `F2` | 快速打开上传文件 |
+
+### 计算工具
+| 快捷键 | 功能说明 |
+|--------|----------|
+| `6` | 计算原神下次60体力时间 |
+| `7` | 计算原神下次40体力时间 |
+| `8` | 计算自訂體力时间（輸入:現在體力,目標體力,體力CD分鐘） |
+| `9` | 计算时间距离现在多久 |
+| `右2` | 计算日期+3天 |
+| `右3` | 计算两个时间点间隔 |
+| `右5` | 计算N天后的日期 |
+| `右7` | 计算原神下次120体力时间 |
+| `右8` | 计算HH.MM后的时间 |
+| `右9` | 计算时间+46小时后 |
+| `M` | 统计指定拾取物拾取数量 | 
+
+### 排序与筛选
+| 快捷键 | 功能说明 |
+|--------|----------|
+| `Alt + I` | 切换拾取物显示顺序（按数量合并/按拾取顺序） |
+| `O` | 排序指定拾取物的拾取效率 |
+| 点击"开始时间"旁边的排序按钮 | 切换按读取顺序/按时间排序 |
+| `ESC` | 在快速导航/筛选模式中退出 |
+| `H`（在筛选模式中） | 退出筛选模式 |
+
+### 鼠标操作
+| 操作 | 功能说明 |
+|------|----------|
+| 点击配置组标题 | 折叠/展开该配置组 |
+| 点击坐标单元格 | 固定/取消固定坐标弹窗 |
+| 双击坐标单元格 | 重置弹窗位置到单元格中间 |
+| 拖拽弹窗标题栏 | 移动弹窗位置（拖拽时自动固定） |
+| 点击弹窗关闭按钮(×) | 关闭弹窗 |
+
+## 📊 数据列说明
+
+### 基本信息
+- **任务名称** - 地图追踪任务或脚本名称
+- **开始时间** - 任务开始执行的时间
+- **结束时间** - 任务完成或中断的时间  
+- **耗时** - 任务执行总时长
+
+### 统计指标
+- **复活次数** - 前往七天神像复活的次数（红色≥2次）。
+  - **小数-0.9表示**：当前角色血量过低、返回七天神像回血
+- **重试次数** - 路线重试次数（红色≥2次）
+  - **注意**：当只有重试次数而无卡死或复活时，任务名称会变为红色
+- **疑似卡死** - 卡死脱离尝试次数（可查看坐标）
+- **过远跳过** - 距离过远跳过的路径点（红色≥2次）
+- **战斗超时** - 战斗超时次数（红色≥1次）
+- **传送失败** - 传送失败重试次数（红色≥3次）
+
+### 交互功能
+- **悬停查看** - 鼠标悬停统计数字显示详细信息
+- **双击重置** - 双击单元格重置弹窗位置
+- **点击固定** - 点击单元格固定/取消固定弹窗
+
+## 🎯 高级功能
+
+### H键 - 任务筛选模式
+```
+输入格式：关键词1,关键词2,关键词3
+示例：蒙德,璃月,稻妻
+```
+- 多关键字逗号分隔
+- 支持部分匹配（不区分大小写）
+- 筛选时自动隐藏所有拾取物行
+- 左上角显示当前筛选状态
+
+### J键 - 零统计任务隐藏
+- 自动隐藏所有異常统计值为零的任务
+- 帮助聚焦有问题任务
+- 与筛选模式协同工作
+
+### P键 - 导出静态模式
+- 所有弹窗内容内联显示
+- 方便截图和保存分享
+- 使用浏览器"另存为"功能导出
+
+### G键 - 配置组导航功能
+
+- **快速访问** - 按G键或点击右上角「📋 导航」按钮打开导航面板
+- **智能搜索** - 输入配置组名称关键词实时筛选匹配项
+- **精准跳转** - 点击搜索结果直接滚动到对应配置组位置
+- **便捷控制** - 点击右上角开关按钮或按ESC键关闭导航
+
+#### 操作指引
+1. **开启导航** - 按 `G` 键或点击页面右上角「📋 导航」按钮
+2. **搜索目标** - 在搜索框输入配置组名称（支持部分匹配）
+3. **快速跳转** - 从搜索结果列表中选择要查看的配置组
+4. **关闭面板** - 点击右上角导航开关或按 `ESC` 键退出
+
+**提示**：导航面板右上角设有开关按钮，可随时点击关闭，方便快捷操作。
+
+
+## 🎨 界面说明
+
+### 表格格式
+**旧版格式**（默认）
+- 单行显示完整任务信息
+- 适合详细数据分析
+
+**新版格式(BGI現版格式)**（按U切换）
+- 任务信息分两行显示
+- 适合快速浏览
+
+### 特殊事件检测
+工具自动检测并标记以下种特殊事件，按错误类型分类：
+
+| 事件类型 | 颜色标记 | 事件说明 | 
+|----------|----------|----------|
+| **自动恢复事件** | | |
+| 自动吃药恢复 | 🟢 绿色 | 自动处理红血状态 |
+| 自动领取派遣任务 | 🟠 橙色 | 正常功能执行 |
+| **暂停与中断事件** | | |
+| 快捷键暂停 | 🟣 粉色 | 用户手动暂停 |
+| 窗口焦点异常 | 🟣 粉色 | 游戏窗口失去焦点 |
+| 切换区域失败 | 🟣 粉色 | 游戏区域切换失败 |
+| **用户配置错误** | 🔧 | |
+| 路径文件丢失 | 🔴 红色 | 配置文件缺失 |
+| 未匹配战斗脚本 | 🔴 红色 | 战斗脚本配置错误 |
+| 战斗策略错误 | 🔴 红色 | 策略脚本语法错误 |
+| 缺少元素采集角色 | 🔴 红色 | 队伍缺少对应元素角色 |
+| 缺少纳西妲角色 | 🔴 红色 | 队伍缺少纳西妲角色 |
+| **BGI运行时错误** | 🐛 | |
+| 队伍角色识别失败 | 🔴 红色 | 角色识别功能异常 |
+| 未能返回主界面 | 🔴 红色 | 界面导航失败 |
+| 切换队伍失败 | 🔴 红色 | 队伍切换功能异常 |
+| 自动重启bgi | 🔴 红色 | 调度器任务出现未预期的异常，自动重启bgi |
+| **网络与地图问题** | 🌐 | |
+| 打开地图失败 | 🔴 红色 | 地图功能异常 |
+| 传送点不存在 | 🔴 红色 | 传送点识别问题 |
+| 识别大地图失败 | 🔴 红色 | 地图定位失败 |
+| **用户主动操作** | 👤 | |
+| 脚本异常结束 | 🔴 红色 | 任务被异常中断 |
+| **其他** |  | |
+| 缺少脚本指定角色 | 藍紫色 | 路徑中的简易策略脚本存在着隊伍中沒有的角色的提示 |
+
+
+
+**计数显示**：同一事件多次发生时会显示次数，如"快捷键暂停 (3)"
+
+## 📱 移动端适配
+
+### 专用界面
+- 触摸友好的大按钮设计
+- 自适应屏幕尺寸的布局
+- 简化的操作流程
+
+### 功能按钮区
+6个核心功能按钮：
+1. 🌓 主题切换
+2. ⏰ 时间列控制
+3. 📊 统计列控制
+4. 📦 拾取物控制
+5. 📤 导出模式
+6. 🔍 异常任务筛选
+
+## 🔧 技术规格
+
+### 支持格式
+- **日志版本**: BetterGI 0.54.0
+- **文件命名**: `better-genshin-impact` 开头
+- **日期识别**: 自动从文件名解析日期
+- **编码支持**: UTF-8 文本格式
+
+### 性能特性
+- 💾 客户端本地处理，无数据上传
+- 📈 虚拟滚动支持大数据量
+- 🔄 实时响应式布局
+
+## ❓ 常见问题
+
+### 数据解析问题
+**Q: 为什么有些任务显示"进行中"？**  
+A: 日志中任务没有正常结束记录，可能是脚本被中断。
+
+**Q: 坐标信息为什么有时缺失？**  
+A: 只有在卡死或复活前有坐标记录时才会显示。
+
+**Q: 时间显示异常怎么办？**  
+A: 工具会自动处理跨日情况，如仍有问题请检查日志完整性。
+
+### 功能使用问题
+**Q: 如何分享分析结果？**  
+A: 使用P键进入导出模式，然后用浏览器"另存为"保存HTML文件。或截图分享
+
+**Q: 筛选模式如何退出？**  
+A: 再次按下H键即可退出筛选模式。
+
+**Q: 弹窗位置乱了怎么办？**  
+A: 按R键重置所有弹窗位置，或双击单元格重置单个弹窗。
+
+### 移动端问题
+**Q: 手机上传文件失败？**  
+A: 确保文件命名格式是`better-genshin-impact日期.log`。
+
+**Q: 移动端按钮显示不全？**  
+A: 横屏模式可获得更好体验。
+
+## 📋 更新日志
+# 20260118
+  - 更新部份BGI_0.55.0關鍵字&部份腳本關鍵字
+# 20260113
+ - 新增 茶包版部份運行路徑時資訊
+   - 网络恢复中...
+   - 自动吃药
+   - 疑似卡死
+### 20260111
+ - 新增 队伍角色增加赶路位显示
+ - 修正 部份带皮肤的行走位 生存位 赶路位不能正常显示问题
+### 20260105
+ - 队伍資訊增加 是否開啟旋转索敌模式
+### 20251230
+ - 终点坐标异常 時,过远跳过+1方便篩選時顯示
+ - 增加 [ 快捷鍵 - 自由编辑网页
+### 20251228
+ - 補充游泳检测相關提示
+### 20251226
+ - 修復篩選後出現的配置組的總時長沒有「秒」的情況。
+ - 修復按鈕上傳時，沒顯示 导航 功能
+ - 增加F2快捷鍵 - 快速上傳文件
+
+*更早版本包含基础日志解析和显示功能及其他功能*
+
+## 📞 技术支持
+
+### 注意事项
+- 🔒 工具完全在浏览器本地运行，无数据上传
+- 📝 仅之支持简体模式下所输出的BetterGI日志档
+- ⚠️ 分析结果仅供参考，不保证100%准确
+
+---
+
+*最后更新: 2026-01-13*  
+*适配 BetterGI 0.54.0+ 版本*
\ No newline at end of file
diff --git a/repo/js/日志分析工具/index.html b/repo/js/日志分析工具/index.html
index 10970510d..711a5449d 100644
--- a/repo/js/日志分析工具/index.html
+++ b/repo/js/日志分析工具/index.html
@@ -1,101 +1,3 @@
-<!-- 
-    適用於BetterGI 0.51.0
-    20250820新增了看死亡前最近的XY軸 
-    20250821
-        修正當有卡死與复活同時存在次數時，复活顯示不出XY軸 
-        新增
-            新增行高亮、鼠標移到表格行時高亮、提示當前在看哪一行
-            按T鍵隱藏或顯示 开始时间&结束时间
-            按Y鍵隱藏或顯示 复活次数、重试次数、疑似卡死次数、过远跳过、战斗超时、传送失败
-            按U鍵切換表格格式（旧版/新版）
-            按I鍵隱藏或顯示 拾取物列
-            雙擊顯示數字的复战斗超时/疑似卡死次数/复活次数格時、重置該格生成的小視窗位置
-            按P進入導出模式，顯示战斗超时/疑似卡死次数/复活次数小視窗詳細、方便分享
-                導出模式中再次按P退出導出模式
-            手機版可选择日志文件上傳
-            当按下J键时，所有统计列（复活次数、重试次数、疑似卡死、过远跳过、战斗超时、传送失败）
-                都为0或空的任务行 或 配置組 会被隐藏或显示，方便用户专注于有问题的任务。
-    20250823
-        导出模式快捷键支持：按P键进入导出模式后，现在支持使用Enter键确认操作，ESC键取消操作
-        移动设备界面控制：新增Alt+L快捷键，可在电脑设备上显示/隐藏移动设备专用的上传功能区
-        移动设备功能按钮：为移动设备添加专用功能按钮区，包含主题切换、列显示控制、导出模式等常用功能
-    20250830
-        捕获坐标信息修改：補充精确接近目标点
-        修正暗色模式時、只有重试次数有數字時，任务名称不顯示紅色字體的問題
-    20250831
-        增加錯誤&其他訊息
-            地图追踪战斗策略錯誤：".*"
-            队伍缺少 X 元素採集角色
-            队伍缺少纳西妲
-            路徑文件丟失
-            自动吃药
-    20250905
-        增加錯誤&其他訊息
-            未匹配到任何战斗脚本
-    20250906
-        增加錯誤&其他訊息
-            切换队伍失败，无法执行此路径！请检查配置组中的地图追踪配置！
-    20250921
-        增加錯誤&其他訊息
-            当前获取焦点的窗口不是原神，尝试恢复窗口
-            队伍角色识别失败
-            打开大地图失败
-        多次異常，顯示錯誤次數
-            例如：快捷键暂停 (2)
-    20250923
-        增加錯誤&其他訊息
-            选项列表不存在传送点  重试
-            识别大地图位置失败
-            切换区域失败
-    20250925
-        按H键，输入的任务名称关键字，根据任务名称匹配关键词来显示或隐藏整个任务
-            多个关键词以","分割
-        H键筛选模式時 与 J键隐藏异常为空的任务行時 不显示 所有拾取物
-        增加錯誤&其他訊息
-            执行地图追踪时候发生错误: "未能返回主界面"
-        第二次讀檔時保留各功能狀態，優化用戶體驗
-    20250927
-        調整部份UI
-            表头悬浮更貼近頂部
-            功能按钮區域增加上下邊距
-        修復摺疊或展開時，箭头顯示錯誤問題
-        配置組增加顯示該組運行時隊伍角色
-            隊伍角色與任務資訊始終顯示在頂部
-            隊伍角色行在篩選模式與導出模式下置中顯示
-    20250929
-        增加快捷鍵
-            快捷鍵6，計算下次60體力恢復時間
-            快捷鍵8，計算下次指定體力恢復時間
-        队伍角色行增加行走位、生存位資訊
-            行走位、生存位資訊(僅供參考)
-        調整部份UI
-            配置組資訊始終顯示在頂部
-    20250930
-        优化配置组摺叠功能
-            在配置组資訊固定在頂部時，點擊摺疊配置組，會自動將該配置組滾動到頂部位置
-            确保在点击配置组标题时，被折叠的配置组始终滚动到页面最顶部位置。
-        改善性能
-            节流和防抖：对滚动和调整大小事件使用节流和防抖
-            批量DOM操作：减少重排重绘
-            缓存DOM查询：避免重复查询
-            使用requestAnimationFrame：优化动画性能
-            减少事件监听器：优化事件处理
-            错误处理：添加try-catch防止崩溃
-        筛选功能修改
-            配置组名匹配 → 显示整个配置组
-            配置组名不匹配但有任务匹配 → 显示配置组+匹配的任务
-            配置组名和任务都不匹配 → 隐藏整个配置组
-    20251001
-        修正 筛选模式配置组名匹配時，沒有隱藏 整組都是0異常的配置組
-        修正 筛选模式配置组名匹配時，舊版UI沒有隱藏0異常任務行的的拾取物
-        條正 筛选模式時+只显示異常任務行，切換表格格式後沒有只显示 筛选關鍵字匹配的異常任務行
-    20251003
-        增加錯誤&其他訊息
-            调度器任务出现未预期的异常，自动重启bgi
-    20251006
-        增加錯誤&其他訊息
-        当前获取焦点的窗口不是原神，暂停
--->
 <!DOCTYPE html>
 <html lang="zh-CN">
 
@@ -103,6 +5,7 @@
     <meta charset="UTF-8">
     <title>日志分析工具</title>
     <style>
+        /* 基础样式 */
         html,
         body {
             background: #f8f9fa;
@@ -119,6 +22,7 @@
             flex-direction: column;
         }
 
+        /* 拖放区域样式 */
         #dropZone {
             flex: 1;
             display: flex;
@@ -145,6 +49,7 @@
             align-items: flex-start;
         }
 
+        /* 表格样式 */
         table {
             border-collapse: collapse;
             width: 100%;
@@ -161,11 +66,8 @@
         th {
             background-color: #888;
             position: sticky;
-            /* top: 0; */
             top: -20px;
-            /* 固定在页面顶部 */
             z-index: 1;
-            /* 确保表头在内容上方 */
         }
 
         tr:nth-child(odd) {
@@ -176,209 +78,12 @@
             background-color: #f9f9f9;
         }
 
+        /* 颜色样式 */
         .red {
             color: red;
             font-weight: bold;
         }
 
-        /* 新增折叠相关样式 */
-        .group-header {
-            cursor: pointer;
-            display: flex;
-            align-items: flex-start;
-            /* 改为flex-start确保内容顶部对齐 */
-            padding: 10px;
-            background-color: #e7e7e7;
-            border-radius: 4px;
-            margin: 5px 0;
-        }
-
-        .group-header:hover {
-            background-color: #bdbebf;
-        }
-
-        /* 修改箭头相关样式 */
-        .arrow {
-            display: inline-block;
-            margin-right: 10px;
-            /* margin-top: 25px; */
-            margin-top: 12.5px;
-            /* 与标题文字对齐 */
-            transition: transform 0.2s;
-            transform: rotate(0deg);
-            /* 默认向右（折叠状态） */
-        }
-
-        .arrow.collapsed {
-            transform: rotate(90deg);
-            /* 展开时向下 */
-        }
-
-        .group-container {
-            margin-left: 20px;
-            border-left: 2px solid #dee2e6;
-            padding-left: 10px;
-            margin-bottom: 0;
-        }
-
-        .collapsible {
-            display: block;
-        }
-
-        .collapsible.collapsed {
-            display: none;
-        }
-
-        /* 暗色主题样式 */
-        body.dark-theme {
-            background-color: #121212;
-            color: #ffffff;
-        }
-
-        body.dark-theme #dropZone {
-            border-color: #666;
-            background-color: #1e1e1e;
-        }
-
-        body.dark-theme table {
-            border-color: #444;
-        }
-
-        body.dark-theme th,
-        body.dark-theme td {
-            border-color: #444;
-        }
-
-        body.dark-theme th {
-            background-color: #888;
-        }
-
-        body.dark-theme tr:nth-child(odd) {
-            background-color: #2a2a2a;
-        }
-
-        body.dark-theme tr:nth-child(even) {
-            background-color: #1e1e1e;
-        }
-
-        body.dark-theme .group-header {
-            background-color: #333;
-            color: #ffffff;
-        }
-
-        body.dark-theme .group-header:hover {
-            background-color: #444;
-        }
-
-        body.dark-theme .red {
-            color: #ff6666;
-        }
-
-        /* 弹窗样式 */
-        .coord-popup {
-            display: none;
-            position: fixed;
-            background-color: #f9f9f9;
-            border: 1px solid #ccc;
-            border-radius: 5px;
-            box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
-            z-index: 10000;
-            max-width: 250px;
-            font-size: 14px;
-            cursor: default;
-            user-select: text;
-        }
-
-        .coord-popup.visible {
-            display: block;
-        }
-
-        .coord-popup-header {
-            background-color: #eee;
-            padding: 8px 12px;
-            border-bottom: 1px solid #ccc;
-            cursor: move;
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-        }
-
-        .coord-popup-title {
-            font-weight: bold;
-        }
-
-        .coord-popup .close-btn {
-            cursor: pointer;
-            font-size: 18px;
-            color: #999;
-            padding: 0 5px;
-        }
-
-        .coord-popup .close-btn:hover {
-            color: #000;
-        }
-
-        .coord-popup-content {
-            padding: 10px;
-            max-height: 300px;
-            overflow-y: auto;
-        }
-
-        .coord-popup .coord-item {
-            margin: 5px 0;
-            padding: 3px 0;
-            border-bottom: 1px dashed #ddd;
-            cursor: text;
-        }
-
-        .coord-popup .coord-item:last-child {
-            border-bottom: none;
-        }
-
-        /* 暗色主题下的弹窗样式 */
-        body.dark-theme .coord-popup {
-            background-color: #333;
-            border: 1px solid #666;
-            color: #fff;
-        }
-
-        body.dark-theme .coord-popup-header {
-            background-color: #444;
-            border-bottom: 1px solid #555;
-        }
-
-        body.dark-theme .coord-popup .close-btn {
-            color: #ccc;
-        }
-
-        body.dark-theme .coord-popup .close-btn:hover {
-            color: #fff;
-        }
-
-        body.dark-theme .coord-popup .coord-item {
-            border-bottom: 1px dashed #555;
-        }
-
-        /* 单元格固定状态指示器 */
-        .coords-cell.pinned::after {
-            content: "📌";
-            margin-left: 5px;
-            font-size: 12px;
-        }
-
-        /* 修改单元格光标样式 */
-        .coords-cell {
-            position: relative;
-            /* 默认使用箭头光标 */
-            cursor: default;
-        }
-
-        /* 当单元格有数字时使用手指光标 */
-        .coords-cell.has-coords {
-            cursor: pointer;
-        }
-
-        /* 新增提示文本样式 */
         .dispatch-alert {
             color: orange;
             font-weight: bold;
@@ -394,44 +99,41 @@
             font-weight: bold;
         }
 
+        .purple-alert {
+            color: #8c8cff;
+            font-weight: bold;
+        }
+
         .strategy-error {
             color: red;
-            /* 战斗策略错误 */
             font-weight: bold;
         }
 
         .element-missing {
             color: red;
-            /* 缺少元素采集角色 */
             font-weight: bold;
         }
 
         .nahida-missing {
             color: red;
-            /* 缺少纳西妲 */
             font-weight: bold;
         }
 
         .file-missing {
             color: red;
-            /* 文件丢失 */
             font-weight: bold;
         }
 
         .auto-potion {
             color: #32CD32;
-            /* 自动吃药 */
             font-weight: bold;
         }
 
-        /* 在CSS样式中添加战斗脚本错误样式 */
         .combat-script-error {
             color: red;
-            /* 战斗脚本设置错误 */
             font-weight: bold;
         }
 
-        /* 新增红色任务名称样式 */
         .task-name-red {
             color: red;
             font-weight: bold;
@@ -442,96 +144,106 @@
             font-weight: bold;
         }
 
-        /* 新增弹窗样式 */
-        .battle-popup {
-            display: none;
-            position: fixed;
-            background-color: #f9f9f9;
-            border: 1px solid #ccc;
-            border-radius: 5px;
-            box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
-            z-index: 10000;
-            max-width: 250px;
-            max-height: 400px;
-            font-size: 14px;
-            cursor: default;
-            user-select: text;
-            overflow: auto;
-        }
-
-        .battle-popup.visible {
-            display: block;
-        }
-
-        .battle-popup-header {
-            background-color: #eee;
-            padding: 8px 12px;
-            border-bottom: 1px solid #ccc;
-            cursor: move;
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            position: sticky;
-            top: 0;
-        }
-
-        .battle-popup-title {
+        .picks-bold {
             font-weight: bold;
         }
 
-        .battle-popup .close-btn {
+        /* 折叠组样式 */
+        .group-header {
             cursor: pointer;
-            font-size: 18px;
-            color: #999;
-            padding: 0 5px;
-        }
-
-        .battle-popup .close-btn:hover {
-            color: #000;
-        }
-
-        .battle-popup-content {
+            display: flex;
+            align-items: flex-start;
             padding: 10px;
-            max-height: 300px;
-            overflow-y: auto;
-        }
-
-        .battle-popup .battle-item {
+            background-color: #e7e7e7;
+            border-radius: 4px;
             margin: 5px 0;
-            padding: 3px 0;
-            border-bottom: 1px dashed #ddd;
+            position: sticky;
+            top: -20px;
+            z-index: 20;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+        }
+
+        .group-header:hover {
+            background-color: #bdbebf;
+        }
+
+        .group-header h2 {
+            margin: 0;
+            padding: 10px 0;
+            font-size: 18px;
+        }
+
+        .arrow {
+            display: inline-block;
+            margin-right: 10px;
+            margin-top: 12.5px;
+            transition: transform 0.2s;
+            transform: rotate(0deg);
+        }
+
+        .arrow.collapsed {
+            transform: rotate(90deg);
+        }
+
+        .group-container {
+            margin-left: 20px;
+            border-left: 2px solid #dee2e6;
+            padding-left: 10px;
+            margin-bottom: 0;
+            position: relative;
+        }
+
+        .collapsible {
+            display: block;
+        }
+
+        .collapsible.collapsed {
+            display: none;
+        }
+
+        /* 表头固定样式 */
+        .sticky-header {
+            position: sticky;
+            top: 40px;
+            z-index: 3;
+        }
+
+        /* 队伍角色样式 */
+        .team-roles-row {
+            background-color: #888 !important;
+            border-bottom: 1px solid #ddd;
+            position: sticky;
+            top: 20px;
+            z-index: 4;
+            font-size: 14px;
+        }
+
+        .team-roles-content {
             font-family: monospace;
+            color: #333;
+            font-weight: bolder;
         }
 
-        .battle-popup .battle-item:last-child {
-            border-bottom: none;
+        .team-role-line {
+            line-height: 1.4;
         }
 
-        /* 暗色主题下的弹窗样式 */
-        body.dark-theme .battle-popup {
-            background-color: #333;
-            border: 1px solid #666;
-            color: #fff;
+        /* 单元格交互样式 */
+        .coords-cell {
+            position: relative;
+            cursor: default;
         }
 
-        body.dark-theme .battle-popup-header {
-            background-color: #444;
-            border-bottom: 1px solid #555;
+        .coords-cell.has-coords {
+            cursor: pointer;
         }
 
-        body.dark-theme .battle-popup .close-btn {
-            color: #ccc;
+        .coords-cell.pinned::after {
+            content: "📌";
+            margin-left: 5px;
+            font-size: 12px;
         }
 
-        body.dark-theme .battle-popup .close-btn:hover {
-            color: #fff;
-        }
-
-        body.dark-theme .battle-popup .battle-item {
-            border-bottom: 1px dashed #555;
-        }
-
-        /* 单元格样式 */
         .has-battle-events {
             cursor: pointer;
             position: relative;
@@ -543,85 +255,38 @@
             font-size: 12px;
         }
 
-        /* 无事件时不可点击 */
         .no-events {
             cursor: default !important;
         }
 
-        /* 新增：时间列隐藏状态样式 */
-        .time-columns-hidden .column-start-time,
-        .time-columns-hidden .column-end-time {
-            display: none;
-        }
-
-        /* 新增：时间列显示状态指示器 */
-        .time-toggle-indicator {
-            position: fixed;
-            bottom: 10px;
-            right: 10px;
-            background-color: rgba(0, 0, 0, 0.7);
-            color: white;
-            padding: 5px 10px;
-            border-radius: 5px;
-            font-size: 12px;
-            z-index: 1000;
-            opacity: 0;
-            transition: opacity 0.5s;
-        }
-
-        .time-toggle-indicator.visible {
-            opacity: 1;
-        }
-
-        /* 新增：统计列隐藏状态样式 */
-        .stats-columns-hidden .column-revive,
-        .stats-columns-hidden .column-retry,
-        .stats-columns-hidden .column-retry-detail,
-        .stats-columns-hidden .column-too-far-skip,
-        .stats-columns-hidden .column-timeout,
-        .stats-columns-hidden .column-teleport {
-            display: none;
-        }
-
-        /* 新增：统计列显示状态指示器 */
-        .stats-toggle-indicator {
-            position: fixed;
-            bottom: 60px;
-            right: 10px;
-            background-color: rgba(0, 0, 0, 0.7);
-            color: white;
-            padding: 5px 10px;
-            border-radius: 5px;
-            font-size: 12px;
-            z-index: 1000;
-            opacity: 0;
-            transition: opacity 0.5s;
+        /* 行高亮样式 */
+        tr.highlighted {
+            background-color: #e6f7ff !important;
         }
 
+        /* 旧版格式特殊样式 */
         .legacy-format .group-header {
-            /* 移除sticky定位 */
-            position: static;
+            position: sticky;
+            top: -20px;
+            z-index: 20;
             background-color: #e7e7e7;
-            padding: 10px;
             margin: 5px 0;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
         }
 
-        body.dark-theme .legacy-format .group-header {
-            background-color: #333;
-        }
-
-        /* 确保旧版格式下表头位置正确 */
         .legacy-format .sticky-header {
+            position: sticky;
             top: 40px;
+            z-index: 3;
         }
 
-        /* 對於舊版格式的特殊調整 */
-        .legacy-format .sticky-header {
-            top: 40px;
+        .legacy-format .team-roles-row {
+            position: sticky;
+            top: 20px;
+            z-index: 4;
         }
 
         .legacy-format .main-row-name {
-            /* 移除粗体 */
             font-weight: normal;
             background-color: #f0f0f0;
         }
@@ -638,91 +303,288 @@
             font-weight: normal;
         }
 
-        /* 暗色主题下的新版表格样式 */
-        body.dark-theme .legacy-format .main-row-name {
-            background-color: #2a2a2a;
+        /* 弹窗样式 */
+        .coord-popup,
+        .battle-popup {
+            display: none;
+            position: fixed;
+            background-color: #f9f9f9;
+            border: 1px solid #ccc;
+            border-radius: 5px;
+            box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
+            z-index: 10000;
+            max-width: 250px;
+            font-size: 14px;
+            cursor: default;
+            user-select: text;
         }
 
-        body.dark-theme .legacy-format .sub-row {
-            background-color: #1e1e1e;
+        .coord-popup.visible,
+        .battle-popup.visible {
+            display: block;
         }
 
-        body.dark-theme .legacy-format .ignore-sort {
-            background-color: #333;
+        .coord-popup-header,
+        .battle-popup-header {
+            background-color: #eee;
+            padding: 8px 12px;
+            border-bottom: 1px solid #ccc;
+            cursor: move;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
         }
 
-        /* 标题跟随页面功能 */
-        .sticky-title {
-            position: sticky;
-            top: 0;
-            background-color: #e7e7e7;
-            z-index: 100;
-            padding: 10px;
-            margin: -10px -10px 10px -10px;
-            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
-        }
-
-        body.dark-theme .sticky-title {
-            background-color: #1e1e1e;
-            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.3);
-        }
-
-        /* 拾取物粗体样式 */
-        .picks-bold {
+        .coord-popup-title,
+        .battle-popup-title {
             font-weight: bold;
         }
 
-        /* 行高亮样式 */
-        tr.highlighted {
-            background-color: #e6f7ff !important;
-            /* 白色模式下的淡蓝色 */
+        .close-btn {
+            cursor: pointer;
+            font-size: 18px;
+            color: #999;
+            padding: 0 5px;
         }
 
-        body.dark-theme tr.highlighted {
-            background-color: #3a3a3a !important;
-            /* 黑色模式下的中灰色 */
-        }
-
-        /* 新增：帮助提示样式 */
-        .help-indicator {
-            position: fixed;
-            bottom: 20px;
-            right: 20px;
-            padding: 10px 15px;
-            border-radius: 8px;
-            font-size: 14px;
-            z-index: 1000;
-            opacity: 0;
-            transition: opacity 0.5s;
-            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);
-        }
-
-        .help-indicator.visible {
-            opacity: 1;
-        }
-
-        /* 默认亮色主题下的帮助提示样式 */
-        .help-indicator {
-            background-color: #000;
-            color: #fff;
-        }
-
-        /* 暗色主题下的帮助提示样式 */
-        body.dark-theme .help-indicator {
-            background-color: #fff;
+        .close-btn:hover {
             color: #000;
         }
 
-        /* 新增：拾取物列隐藏状态样式 */
-        .picks-columns-hidden .column-picks {
+        .coord-popup-content,
+        .battle-popup-content {
+            padding: 10px;
+            max-height: 300px;
+            overflow-y: auto;
+        }
+
+        .coord-popup .coord-item,
+        .battle-popup .battle-item {
+            margin: 5px 0;
+            padding: 3px 0;
+            border-bottom: 1px dashed #ddd;
+        }
+
+        .coord-popup .coord-item:last-child,
+        .battle-popup .battle-item:last-child {
+            border-bottom: none;
+        }
+
+        /* 移动设备上传区域 */
+        #fileUploadContainer {
+            display: none;
+            flex-direction: column;
+            gap: 15px;
+            padding: 15px;
+            border: 2px dashed #ccc;
+            border-radius: 8px;
+            background-color: #f9f9f9;
+            margin: 10px;
+            align-items: center;
+        }
+
+        #fileUploadBtn {
+            padding: 12px 24px;
+            background-color: #4CAF50;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+            transition: background-color 0.3s;
+            width: 100%;
+            max-width: 300px;
+        }
+
+        #fileUploadBtn:hover {
+            background-color: #45a049;
+        }
+
+        #fileInput {
             display: none;
         }
 
-        /* 调整指示器位置 */
-        .stats-toggle-indicator#picksToggleIndicator {
-            bottom: 60px;
+        /* 移动设备控制按钮 */
+        #mobileControls {
+            display: flex;
+            flex-wrap: wrap;
+            justify-content: center;
+            margin: 8px 0px;
+            gap: 8px;
+            width: 100%;
         }
 
+        .control-btn {
+            padding: 8px 12px;
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            background-color: #f0f0f0;
+            cursor: pointer;
+            font-size: 14px;
+            transition: all 0.3s;
+            flex: 1;
+            min-width: 80px;
+            text-align: center;
+        }
+
+        .control-btn.active {
+            background-color: #4CAF50;
+            color: white;
+            border-color: #4CAF50;
+            font-weight: bold;
+        }
+
+        .control-btn:nth-child(1).active {
+            background-color: #ff9800;
+            border-color: #ff9800;
+        }
+
+        .control-btn:nth-child(2).active {
+            background-color: #2196F3;
+            border-color: #2196F3;
+        }
+
+        .control-btn:nth-child(3).active {
+            background-color: #2196F3;
+            border-color: #2196F3;
+        }
+
+        .control-btn:nth-child(4).active {
+            background-color: #2196F3;
+            border-color: #2196F3;
+        }
+
+        .control-btn:nth-child(5).active {
+            background-color: #9C27B0;
+            border-color: #9C27B0;
+        }
+
+        .control-btn:nth-child(6).active {
+            background-color: #f44336;
+            border-color: #f44336;
+        }
+
+        .control-btn:nth-child(7).active {
+            background-color: #FF9800;
+            border-color: #FF9800;
+        }
+
+        .control-btn:nth-child(8).active {
+            background-color: #4CAF50;
+            border-color: #4CAF50;
+            color: white;
+        }
+
+        /* 快速导航菜单 */
+        .quick-nav {
+            position: fixed;
+            top: 60px;
+            right: 10px;
+            background: rgba(255, 255, 255, 0.95);
+            border: 1px solid #ccc;
+            border-radius: 8px;
+            padding: 10px;
+            overflow-y: auto;
+            z-index: 1000;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);
+            display: none;
+            flex-direction: column;
+            min-width: 250px;
+            max-width: 300px;
+            max-height: 70vh;
+        }
+
+        .quick-nav.visible {
+            display: flex;
+        }
+
+        .quick-nav-header {
+            font-weight: bold;
+            margin-bottom: 8px;
+            padding-bottom: 5px;
+            border-bottom: 1px solid #ddd;
+            text-align: center;
+            font-size: 14px;
+        }
+
+        .quick-nav-item {
+            padding: 6px 8px;
+            margin: 2px 0;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 12px;
+            transition: background-color 0.2s;
+            word-break: break-word;
+        }
+
+        .quick-nav-item:hover {
+            background-color: #e0e0e0;
+        }
+
+        .quick-nav-item.active {
+            background-color: #4CAF50;
+            color: white;
+        }
+
+        .quick-nav-search {
+            width: 100%;
+            padding: 6px;
+            margin-bottom: 8px;
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            font-size: 12px;
+            box-sizing: border-box;
+        }
+
+        .quick-nav-toggle {
+            position: fixed;
+            top: 10px;
+            right: 10px;
+            background: rgba(255, 255, 255, 0.95);
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            padding: 8px 12px;
+            cursor: pointer;
+            z-index: 1001;
+            font-size: 14px;
+            box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+            transition: all 0.3s;
+            display: none;
+        }
+
+        .quick-nav-toggle:hover {
+            background: rgba(255, 255, 255, 1);
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+        }
+
+        #quickNavTotalTime {
+            font-size: 12px;
+            color: #333;
+            padding: 6px 8px;
+            text-align: center;
+            border-bottom: 1px solid #ddd;
+            background-color: #f5f5f5;
+            flex-shrink: 0;
+            /* 防止被壓縮 */
+        }
+
+        #quickNavTotalTimeValue {
+            font-weight: bold;
+            color: #333;
+        }
+
+        /* 暗色主題下的樣式 */
+        body.dark-theme #quickNavTotalTime {
+            background-color: #333;
+            color: #ffffff;
+            border-bottom-color: #555;
+        }
+
+        body.dark-theme #quickNavTotalTimeValue {
+            color: #ffffff;
+        }
+
+        /* 状态指示器 */
         .mode-indicator {
             position: fixed;
             top: 10px;
@@ -736,49 +598,74 @@
             display: none;
         }
 
-        .static-mode .mode-indicator {
-            display: block;
-            background-color: rgba(76, 175, 80, 0.8);
-        }
-
-        /* 静态模式下弹窗的样式 */
-        .static-mode .coord-popup,
-        .static-mode .battle-popup {
-            display: block !important;
-            position: static !important;
-            margin: 10px 0;
-            box-shadow: none;
-            max-width: 100%;
-            max-height: none;
-        }
-
-        .static-mode .coord-popup-header,
-        .static-mode .battle-popup-header {
-            cursor: default;
-            background-color: #e0e0e0;
-            /* color: #333; */
-        }
-
-        .static-mode .close-btn {
+        .filter-indicator {
+            position: fixed;
+            top: 10px;
+            left: 10px;
+            background-color: rgba(255, 165, 0, 0.9);
+            color: white;
+            padding: 8px 12px;
+            border-radius: 4px;
+            font-size: 14px;
+            z-index: 10000;
             display: none;
+            max-width: 300px;
+            word-wrap: break-word;
         }
 
-        .static-mode .coords-cell,
-        .static-mode .has-battle-events {
-            cursor: default;
+        .filter-indicator.visible {
+            display: block;
         }
 
-        .static-mode .coords-cell.pinned::after,
-        .static-mode .has-battle-events.pinned::after {
-            content: "";
+        .filter-indicator .filter-keywords {
+            font-weight: bold;
+            color: #ffeb3b;
         }
 
-        /* 当筛选提示显示时，静态模式提示向右移动更多 */
-        .filter-indicator.visible~.mode-indicator.static-mode {
-            left: calc(var(--filter-indicator-width) + 20px);
+        .time-toggle-indicator,
+        .stats-toggle-indicator {
+            position: fixed;
+            bottom: 10px;
+            right: 10px;
+            background-color: rgba(0, 0, 0, 0.7);
+            color: white;
+            padding: 5px 10px;
+            border-radius: 5px;
+            font-size: 12px;
+            z-index: 1000;
+            opacity: 0;
+            transition: opacity 0.5s;
         }
 
-        /* 提示框样式 */
+        .time-toggle-indicator.visible,
+        .stats-toggle-indicator.visible {
+            opacity: 1;
+        }
+
+        .help-indicator {
+            position: fixed;
+            bottom: 20px;
+            right: 20px;
+            padding: 10px 15px;
+            border-radius: 8px;
+            font-size: 14px;
+            z-index: 1000;
+            opacity: 0;
+            transition: opacity 0.5s;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.2);
+            background-color: #000;
+            color: #fff;
+            pointer-events: none;
+            /* 隐藏后不接受鼠标事件 */
+            user-select: none;
+            /* 禁止选择文本 */
+        }
+
+        .help-indicator.visible {
+            opacity: 1;
+        }
+
+        /* 弹窗和自定义提示 */
         .custom-alert {
             position: fixed;
             top: 50%;
@@ -835,120 +722,143 @@
             display: none;
         }
 
-        body.dark-theme .custom-alert {
-            background-color: #333;
-            color: #fff;
-        }
-
-        body.dark-theme .custom-alert h3 {
-            color: #fff;
-        }
-
-        /* 新增移动设备上传按钮样式 */
-        #fileUploadContainer {
-            display: flex;
-            flex-direction: column;
-            gap: 15px;
-            padding: 15px;
-            border: 2px dashed #ccc;
-            border-radius: 8px;
-            background-color: #f9f9f9;
-            margin: 10px;
-            align-items: center;
-        }
-
-        #fileUploadBtn {
-            padding: 12px 24px;
-            background-color: #4CAF50;
-            color: white;
-            border: none;
-            border-radius: 4px;
-            cursor: pointer;
-            font-size: 16px;
-            transition: background-color 0.3s;
-            width: 100%;
-            max-width: 300px;
-        }
-
-        #fileUploadBtn:hover {
-            background-color: #45a049;
-        }
-
-        /* 功能按钮区域 */
-        #mobileControls {
-            display: flex;
-            flex-wrap: wrap;
-            justify-content: center;
-            margin: 8px 0px;
-            gap: 8px;
-            width: 100%;
-        }
-
-        .control-btn {
-            padding: 8px 12px;
-            border: 1px solid #ccc;
-            border-radius: 4px;
-            background-color: #f0f0f0;
-            cursor: pointer;
-            font-size: 14px;
-            transition: all 0.3s;
-            flex: 1;
-            min-width: 80px;
-            text-align: center;
-        }
-
-        .control-btn.active {
-            background-color: #4CAF50;
-            color: white;
-            border-color: #4CAF50;
-            font-weight: bold;
-        }
-
-
-        .control-btn:nth-child(1).active {
-            background-color: #ff9800;
-            border-color: #ff9800;
-        }
-
-        /* 主题切换 */
-        .control-btn:nth-child(2).active {
-            background-color: #2196F3;
-            border-color: #2196F3;
-        }
-
-        /* 时间列 */
-        .control-btn:nth-child(3).active {
-            background-color: #2196F3;
-            border-color: #2196F3;
-        }
-
-        /* 统计列 */
-        .control-btn:nth-child(4).active {
-            background-color: #2196F3;
-            border-color: #2196F3;
-        }
-
-        /* 拾取物列 */
-        .control-btn:nth-child(5).active {
-            background-color: #9C27B0;
-            border-color: #9C27B0;
-        }
-
-        /* 导出模式 */
-        .control-btn:nth-child(6).active {
-            background-color: #f44336;
-            border-color: #f44336;
-        }
-
-        /* 异常任务 */
-
-
-
-        #fileInput {
+        /* 显示/隐藏状态类 */
+        .time-columns-hidden .column-start-time,
+        .time-columns-hidden .column-end-time {
             display: none;
         }
 
-        /* 暗色主题适配 */
+        .stats-columns-hidden .column-revive,
+        .stats-columns-hidden .column-retry,
+        .stats-columns-hidden .column-retry-detail,
+        .stats-columns-hidden .column-too-far-skip,
+        .stats-columns-hidden .column-timeout,
+        .stats-columns-hidden .column-teleport {
+            display: none;
+        }
+
+        .picks-columns-hidden .column-picks {
+            display: none;
+        }
+
+        .static-mode .mode-indicator {
+            display: block;
+        }
+
+        .static-mode .coord-popup,
+        .static-mode .battle-popup {
+            display: block !important;
+            position: static !important;
+            margin: 10px 0;
+            box-shadow: none;
+            max-width: 100%;
+            max-height: none;
+        }
+
+        .static-mode .coord-popup-header,
+        .static-mode .battle-popup-header {
+            cursor: default;
+            background-color: #e0e0e0;
+        }
+
+        .static-mode .close-btn {
+            display: none;
+        }
+
+        .static-mode .coords-cell,
+        .static-mode .has-battle-events {
+            cursor: default;
+        }
+
+        .static-mode .coords-cell.pinned::after,
+        .static-mode .has-battle-events.pinned::after {
+            content: "";
+        }
+
+        /* 暗色主题 */
+        body.dark-theme {
+            background-color: #121212;
+            color: #ffffff;
+        }
+
+        body.dark-theme #dropZone {
+            border-color: #666;
+            background-color: #1e1e1e;
+        }
+
+        body.dark-theme table {
+            border-color: #444;
+        }
+
+        body.dark-theme th,
+        body.dark-theme td {
+            border-color: #444;
+        }
+
+        body.dark-theme th {
+            background-color: #888;
+        }
+
+        body.dark-theme tr:nth-child(odd) {
+            background-color: #2a2a2a;
+        }
+
+        body.dark-theme tr:nth-child(even) {
+            background-color: #1e1e1e;
+        }
+
+        body.dark-theme .group-header {
+            background-color: #333;
+            color: #ffffff;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+        }
+
+        body.dark-theme .group-header:hover {
+            background-color: #444;
+        }
+
+        body.dark-theme .red {
+            color: #ff6666;
+        }
+
+        body.dark-theme .coord-popup {
+            background-color: #333;
+            border: 1px solid #666;
+            color: #fff;
+        }
+
+        body.dark-theme .coord-popup-header {
+            background-color: #444;
+            border-bottom: 1px solid #555;
+        }
+
+        body.dark-theme .close-btn {
+            color: #ccc;
+        }
+
+        body.dark-theme .close-btn:hover {
+            color: #fff;
+        }
+
+        body.dark-theme .coord-popup .coord-item {
+            border-bottom: 1px dashed #555;
+        }
+
+        body.dark-theme .battle-popup {
+            background-color: #333;
+            border: 1px solid #666;
+            color: #fff;
+        }
+
+        body.dark-theme .battle-popup-header {
+            background-color: #444;
+            border-bottom: 1px solid #555;
+        }
+
+        body.dark-theme .battle-popup .battle-item {
+            border-bottom: 1px dashed #555;
+        }
+
         body.dark-theme #fileUploadContainer {
             background-color: #2a2a2a;
             border-color: #555;
@@ -960,73 +870,96 @@
             border-color: #555;
         }
 
-        /* 移动设备检测 */
-        @media (max-width: 0px),
-        (pointer: coarse) {
-            #fileUploadContainer {
-                display: flex !important;
-            }
+        body.dark-theme .quick-nav {
+            background: rgba(50, 50, 50, 0.95);
+            border-color: #666;
+            color: #fff;
         }
 
-        /* 电脑设备默认隐藏 */
-        #fileUploadContainer {
-            display: none;
+        body.dark-theme .quick-nav-header {
+            border-bottom-color: #666;
         }
 
-        /* 电脑设备显示控制 */
-        #fileUploadContainer.visible {
-            display: flex;
+        body.dark-theme .quick-nav-item:hover {
+            background-color: #555;
         }
 
-        /* 新增：移动设备功能按钮响应式样式 */
-        @media (max-width: 768px),
-        (pointer: coarse) {
-            #mobileControls {
-                flex-wrap: wrap;
-                max-height: 88px;
-                /* 限制最多两行高度 */
-                overflow: hidden;
-                gap: 4px;
-                /* 减小按钮间距 */
-            }
-
-            .control-btn {
-                flex: 0 0 calc(24% - 6px);
-                /* 每行显示2个按钮，考虑间隙 */
-                min-width: calc(24% - 6px);
-                font-size: 12px;
-                /* 减小字体大小 */
-                padding: 6px 8px;
-                /* 调整内边距 */
-                margin: 2px;
-                /* 减小外边距 */
-            }
-
-            /* 确保按钮文本不会换行 */
-            .control-btn {
-                white-space: nowrap;
-                overflow: hidden;
-                text-overflow: ellipsis;
-            }
+        body.dark-theme .quick-nav-search {
+            background-color: #333;
+            border-color: #666;
+            color: #fff;
         }
 
-        /* 超小屏幕优化（宽度小于400px） */
-        @media (max-width: 400px) {
-            #mobileControls {
-                max-height: 80px;
-                /* 进一步减小高度 */
-                gap: 2px;
-            }
-
-            .control-btn {
-                flex: 0 0 calc(24% - 4px);
-                min-width: calc(24% - 4px);
-                font-size: 11px;
-                padding: 4px 6px;
-            }
+        body.dark-theme .quick-nav-toggle {
+            background: rgba(50, 50, 50, 0.95);
+            border-color: #666;
+            color: #fff;
         }
 
-        /* 新增移动设备样式 */
+        body.dark-theme .quick-nav-toggle:hover {
+            background: rgba(50, 50, 50, 1);
+        }
+
+        body.dark-theme .filter-indicator {
+            background-color: rgba(255, 140, 0, 0.9);
+            color: #fff;
+        }
+
+        body.dark-theme .filter-indicator .filter-keywords {
+            color: #fff59d;
+        }
+
+        body.dark-theme .mode-indicator {
+            background-color: rgba(56, 142, 60, 0.8);
+        }
+
+        body.dark-theme .custom-alert {
+            background-color: #333;
+            color: #fff;
+        }
+
+        body.dark-theme .custom-alert h3 {
+            color: #fff;
+        }
+
+        body.dark-theme .legacy-format .group-header {
+            background-color: #333;
+        }
+
+        body.dark-theme .legacy-format .main-row-name {
+            background-color: #2a2a2a;
+        }
+
+        body.dark-theme .legacy-format .sub-row {
+            background-color: #1e1e1e;
+        }
+
+        body.dark-theme .legacy-format .ignore-sort {
+            background-color: #333;
+        }
+
+        body.dark-theme .team-roles-row {
+            background-color: #888 !important;
+        }
+
+        body.dark-theme .team-roles-content {
+            color: #ffffff;
+        }
+
+        body.dark-theme .team-role-line {
+            color: #ffffff;
+        }
+
+        body.dark-theme tr.highlighted {
+            background-color: #3a3a3a !important;
+        }
+
+        body.dark-theme .help-indicator {
+            background-color: #fff;
+            color: #000;
+        }
+
+        /* 移动设备响应式 */
         @media (max-width: 0px),
         (pointer: coarse) {
             body {
@@ -1052,396 +985,183 @@
                 padding: 6px 4px;
             }
 
-            /* 移动设备上传按钮样式 */
             #fileUploadContainer {
                 display: block;
-                text-align: center;
-                margin: 15px;
-                padding: 15px;
-                border: 2px dashed #ccc;
-                border-radius: 8px;
-                background-color: #f9f9f9;
             }
 
-            #fileUploadBtn {
-                padding: 12px 24px;
-                background-color: #4CAF50;
-                color: white;
-                border: none;
-                border-radius: 4px;
-                cursor: pointer;
-                font-size: 16px;
-                transition: background-color 0.3s;
+            #mobileControls {
+                flex-wrap: wrap;
+                max-height: 88px;
+                overflow: hidden;
+                gap: 4px;
             }
 
-            #fileUploadBtn:hover {
-                background-color: #45a049;
+            .control-btn {
+                flex: 0 0 calc(24% - 6px);
+                min-width: calc(24% - 6px);
+                font-size: 12px;
+                padding: 6px 8px;
+                margin: 2px;
+                white-space: nowrap;
+                overflow: hidden;
+                text-overflow: ellipsis;
             }
 
-            #fileInput {
-                display: none;
+            .quick-nav {
+                top: 50px;
+                right: 5px;
+                left: auto;
+                max-width: calc(100vw - 20px);
+            }
+
+            .quick-nav-toggle {
+                top: 5px;
+                right: 5px;
+                padding: 6px 10px;
+                font-size: 12px;
             }
         }
 
-        /* 非移动设备默认隐藏上传区域 */
-        #fileUploadContainer {
-            display: none;
-            /* 默认隐藏 */
-            text-align: center;
-            margin-top: 20px;
-            padding: 15px;
-            border: 2px dashed #ccc;
-            border-radius: 8px;
-            background-color: #f9f9f9;
+        @media (max-width: 400px) {
+            #mobileControls {
+                max-height: 80px;
+                gap: 2px;
+            }
+
+            .control-btn {
+                flex: 0 0 calc(24% - 4px);
+                min-width: calc(24% - 4px);
+                font-size: 11px;
+                padding: 4px 6px;
+            }
         }
 
-        /* 添加零统计任务显示状态指示器样式 */
-        .stats-toggle-indicator#zeroStatsToggleIndicator {
-            bottom: 160px;
+        /* 显示控制类 */
+        #fileUploadContainer.visible {
+            display: flex;
         }
 
-        /* 新增：上传区域显示控制 */
         #fileUploadContainer.hidden {
             display: none !important;
         }
 
-        /* 移动设备样式 */
-        @media (max-width: 0px),
-        (pointer: coarse) {
-            #fileUploadContainer {
-                display: block !important;
-                /* 移动设备强制显示 */
-            }
-        }
-
-        /* 电脑设备显示时的样式 */
-        #fileUploadContainer.visible {
-            display: block;
-        }
-
-        /* 暗色主题适配 */
-        body.dark-theme #fileUploadContainer {
-            background-color: #2a2a2a;
-            border-color: #555;
-        }
-
-        /* 新增：篩選狀態提示樣式 */
-        .filter-indicator {
-            position: fixed;
-            top: 10px;
-            left: 10px;
-            background-color: rgba(255, 165, 0, 0.9);
-            color: white;
-            padding: 8px 12px;
-            border-radius: 4px;
-            font-size: 14px;
-            z-index: 10000;
-            display: none;
-            max-width: 300px;
-            word-wrap: break-word;
-        }
-
         .filter-indicator.visible {
             display: block;
         }
 
-        .filter-indicator .filter-keywords {
-            font-weight: bold;
-            color: #ffeb3b;
+        .time-toggle-indicator.visible {
+            opacity: 1;
         }
 
-        /* 暗色主题适配 */
-        body.dark-theme .filter-indicator {
-            background-color: rgba(255, 140, 0, 0.9);
-            color: #fff;
+        .stats-toggle-indicator.visible {
+            opacity: 1;
         }
 
-        body.dark-theme .filter-indicator .filter-keywords {
-            color: #fff59d;
+        .help-indicator.visible {
+            opacity: 1;
         }
 
-        body.dark-theme .mode-indicator {
-            background-color: rgba(56, 142, 60, 0.8);
+        .quick-nav-toggle {
+            display: none;
         }
 
-        /* 任務篩選 */
-        .control-btn:nth-child(7).active {
-            background-color: #FF9800;
-            border-color: #FF9800;
+        .static-mode .mode-indicator {
+            display: block;
         }
 
-        .header-content {
-            flex: 1;
-            /* 占据剩余空间 */
-            display: flex;
-            flex-direction: column;
-            /* 垂直排列 */
+        /* 特殊布局调整 */
+        .filter-indicator.visible~.mode-indicator.static-mode {
+            left: calc(var(--filter-indicator-width) + 20px);
         }
 
-        /* 队伍角色显示样式 */
-        .team-roles {
-            margin-top: -20px;
-            padding: 8px;
-            /* background-color: #f8f8f8; */
-            border-radius: 4px;
-            /* border-left: 3px solid #4CAF50; */
-            font-size: 14px;
-        }
-
-        .team-role {
-            /* margin: 3px 0; */
-            /* padding: 2px 5px; */
-            font-family: monospace;
-            color: #555;
-        }
-
-        body.dark-theme .team-role {
-            color: #ccc;
-        }
-
-        /* 隊伍角色行樣式 - 修改後 */
-        .team-roles-row {
-            background-color: #f0f0f0 !important;
-            border-bottom: 1px solid #ddd;
-            position: sticky;
-            top: -20px;
-            z-index: 4;
-            font-size: 14px;
-        }
-
-        /* 修正暗色模式下队伍角色行的背景色 */
-        body.dark-theme .team-roles-row {
-            background-color: #888 !important;
-            /* border-bottom-color: #444; */
-            color: #ffffff;
-        }
-
-        /* 确保队伍角色行的颜色与任务名称一致 */
-        .team-roles-content {
-            /* padding: 8px; */
-            font-family: monospace;
-            color: #333;
-            font-weight: bolder;
-            /* 亮色模式下的字体颜色，与任务名称一致 */
-        }
-
-        .team-role-line {
-            /* margin: 3px 0; */
-            /* padding: 2px 0; */
-            line-height: 1.4;
-        }
-
-        body.dark-theme .team-role-line {
-            color: #ffffff;
-        }
-
-        /* 调整表头位置，为队伍角色行留出空间 */
-        .sticky-header {
-            position: sticky;
-            top: 40px;
-            /* 根据队伍角色行高度调整 */
-            z-index: 3;
-        }
-
-
-
-        /* 对于旧版格式的特殊调整 */
-        .legacy-format .team-roles-row {
-            top: -20px;
-            /* 统一为0px */
-        }
-
-        body.dark-theme .team-roles-content {
-            color: #ffffff;
-            /* 暗色模式下的字体颜色，与任务名称一致 */
-        }
-
-        /* 确保任务信息行在队伍角色行之下 */
-        .group-container table {
-            position: relative;
-            /* 移除可能的额外边距 */
-        }
-
-        /* 隊伍角色行樣式 - 修改後 */
-        .team-roles-row {
-            background-color: #888 !important;
-            border-bottom: 1px solid #ddd;
-            position: sticky;
-            top: -20px;
-            /* 固定在頂部，在表頭上方 */
-            z-index: 4;
-            /* 確保在表頭上方 */
-            font-size: 14px;
-        }
-
-        /* 确保配置组标题不会覆盖队伍角色行 */
-        .group-header {
-            position: relative;
-            z-index: 5;
-            /* 高于队伍角色行 */
-        }
-
-        /* 表头样式 */
-        th.sticky-header {
-            position: sticky;
-            top: 20px;
-            /* 初始值為0，由JS動態設置 */
-            z-index: 3;
-        }
-
-        /* 当body有static-mode或filter-mode类时，队伍角色行居中 */
         body.static-mode .team-role-line,
         body.filter-mode .team-role-line {
             text-align: center;
         }
 
-        /* 默认状态 */
         .team-role-line {
             text-align: left;
         }
 
-        /* 配置组标题固定样式 */
-        .group-header {
-            position: sticky;
-            top: -20px;
-            z-index: 20;
-            background-color: #e7e7e7;
-            margin: 5px 0;
-            transition: background-color 0.3s;
+        /* 快速导航内部布局 */
+        #quickNavItems {
+            flex: 1;
+            overflow-y: auto;
+            overflow-x: hidden;
+            padding: 5px 0;
         }
 
-        /* 暗色主题下的配置组标题固定样式 */
-        body.dark-theme .group-header {
-            background-color: #333;
+        .quick-nav-header,
+        .quick-nav-search {
+            flex-shrink: 0;
         }
 
-        /* 确保配置组容器在折叠状态下不会占用空间 */
-        .group-container.collapsed {
-            display: none;
+        /* 确保两个输入框之间有适当间距 */
+        #quickNavExclude {
+            margin-bottom: 8px;
         }
 
-        /* 确保配置组标题在折叠状态下仍然可见但内容隐藏 */
-        .group-header.collapsed {
-            position: sticky;
-            top: -20px;
-            z-index: 20;
+        /* 新增：確保在新版和舊版格式下排序按鈕樣式一致 */
+        .sort-btn {
+            position: absolute;
+            right: 5px;
+            top: 50%;
+            transform: translateY(-50%);
+            font-size: 10px;
+            padding: 2px 5px;
+            cursor: pointer;
+            border-radius: 3px;
+            min-width: 20%;
+            text-align: center;
         }
 
-        /* 调整表头位置，确保在配置组标题下方 */
-        .sticky-header {
-            position: sticky;
-            /* top: 60px; */
-            top: 40px;
-            /* 根据配置组标题高度调整 */
-            z-index: 3;
+        /* 針對新版格式的排序按鈕 */
+        table:not(.legacy-format) .sort-btn {
+            position: absolute;
+            right: 5px;
+            top: 50%;
+            transform: translateY(-50%);
+            font-size: 10px;
+            padding: 2px 5px;
+            cursor: pointer;
+            border-radius: 3px;
+            color: #333;
+            min-width: 20%;
+            text-align: center;
+            background-color: rgba(0, 0, 0, 0);
+            border: 1px solid rgba(0, 0, 0, 0);
+            font-family: inherit;
         }
 
-        /* 队伍角色行位置调整 */
-        .team-roles-row {
-            position: sticky;
-            /* top: 40px; */
-            top: 20px;
-            /* 在配置组标题下方，表头上方 */
-            z-index: 4;
+        /* 針對舊版格式的排序按鈕 */
+        .legacy-format .sort-btn {
+            position: absolute;
+            right: 5px;
+            top: 50%;
+            transform: translateY(-50%);
+            font-size: 10px;
+            padding: 2px 5px;
+            cursor: pointer;
+            border-radius: 3px;
+            color: #333;
+            min-width: 20%;
+            text-align: center;
+            background-color: rgba(0, 0, 0, 0);
+            border: 1px solid rgba(0, 0, 0, 0);
+            font-family: inherit;
         }
 
-        /* 对于旧版格式的特殊调整 */
-        .legacy-format .sticky-header {
-            /* top: 60px; */
-            top: 40px;
+        /* 暗色主題下的排序按鈕樣式 */
+        body.dark-theme .sort-btn {
+            color: #fff;
         }
 
-        .legacy-format .team-roles-row {
-            /* top: 40px; */
-            top: 40px;
+        body.dark-theme table:not(.legacy-format) .sort-btn {
+            color: #fff;
         }
 
-        /* 确保配置组标题有足够的视觉层次 */
-        .group-header h2 {
-            margin: 0;
-            padding: 10px 0;
-            font-size: 18px;
-        }
-
-        /* 为配置组容器添加顶部内边距，确保内容不被固定标题遮挡 */
-        .group-container {
-            margin-left: 20px;
-            border-left: 2px solid #dee2e6;
-            padding-left: 10px;
-            position: relative;
-        }
-
-        /* 当有多个配置组时，确保后续配置组标题能够正确推走前一个 */
-        .group-container:not(:first-child) .group-header {
-            top: -20px;
-            /* 所有配置组标题都固定在页面顶部，滚动时会依次替换 */
-        }
-
-        /* 为配置组标题添加阴影，增强视觉层次 */
-        .group-header {
-            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-            border-radius: 4px;
-        }
-
-        body.dark-theme .group-header {
-            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
-        }
-
-        /* 旧版格式的配置组标题固定样式 */
-        .legacy-format .group-header {
-            position: sticky;
-            top: -20px;
-            z-index: 20;
-            background-color: #e7e7e7;
-            margin: 5px 0;
-            transition: background-color 0.3s;
-        }
-
-        /* 暗色主题下的旧版格式配置组标题固定样式 */
-        body.dark-theme .legacy-format .group-header {
-            background-color: #333;
-        }
-
-        /* 确保旧版格式配置组标题在折叠状态下也保持固定 */
-        .legacy-format .group-header.collapsed {
-            position: sticky;
-            top: -20px;
-            z-index: 20;
-        }
-
-        /* 调整旧版格式表头位置，确保在配置组标题下方 */
-        .legacy-format .sticky-header {
-            position: sticky;
-            /* top: 60px; */
-            top: 40px;
-            /* 根据配置组标题高度调整 */
-            z-index: 3;
-        }
-
-        /* 旧版格式队伍角色行位置调整 */
-        .legacy-format .team-roles-row {
-            position: sticky;
-            top: 20px;
-            /* 在配置组标题下方，表头上方 */
-            z-index: 4;
-        }
-
-        /* 为旧版格式配置组标题添加阴影，增强视觉层次 */
-        .legacy-format .group-header {
-            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-            border-radius: 4px;
-        }
-
-        body.dark-theme .legacy-format .group-header {
-            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
-        }
-
-        /* 确保旧版格式配置组容器有足够的顶部内边距 */
-        .legacy-format .group-container {
-            margin-left: 20px;
-            border-left: 2px solid #dee2e6;
-            padding-left: 10px;
-            position: relative;
+        body.dark-theme .legacy-format .sort-btn {
+            color: #fff;
         }
     </style>
 </head>
@@ -1471,9 +1191,11 @@
                 <button class="control-btn" data-key="84">时间列</button>
                 <button class="control-btn" data-key="89">统计列</button>
                 <button class="control-btn" data-key="73">拾取物列</button>
+                <!-- <button class="control-btn" data-key="79">拾取效率</button> -->
                 <button class="control-btn" data-key="80">导出模式</button>
                 <button class="control-btn" data-key="74">异常任务</button>
                 <button class="control-btn" data-key="72">任務篩選</button>
+                <button class="control-btn" data-key="77">统计拾取物</button>
             </div>
         </div>
     </div>
@@ -1494,14 +1216,31 @@
     <!-- 新增：统计列显示状态指示器 -->
     <div class="stats-toggle-indicator" id="statsToggleIndicator"></div>
     <!-- 新增：表格格式显示状态指示器 -->
-    <div class="stats-toggle-indicator" id="formatToggleIndicator" style="bottom: 110px;"></div>
+    <div class="stats-toggle-indicator" id="formatToggleIndicator"></div>
     <!-- 在HTML中添加拾取物列显示状态指示器 -->
-    <div class="stats-toggle-indicator" id="picksToggleIndicator" style="bottom: 60px;"></div>
+    <div class="stats-toggle-indicator" id="picksToggleIndicator"></div>
     <!-- 在HTML中添加零统计任务显示状态指示器 -->
-    <div class="stats-toggle-indicator" id="zeroStatsToggleIndicator" style="bottom: 160px;"></div>
+    <div class="stats-toggle-indicator" id="zeroStatsToggleIndicator"></div>
     <!-- 新增：帮助提示指示器 -->
     <div class="help-indicator" id="helpIndicator">按 0 键查看说明</div>
 
+    <!-- 快速导航切换按钮 -->
+    <div class="quick-nav-toggle" id="quickNavToggle" style="display: none;">📋 导航</div>
+
+    <!-- 快速导航菜单 -->
+    <div class="quick-nav" id="quickNav">
+        <div class="quick-nav-header">配置组导航</div>
+        <input type="text" class="quick-nav-search" id="quickNavSearch" placeholder="搜索配置组...">
+        <!-- 新增排除输入框 -->
+        <input type="text" class="quick-nav-search" id="quickNavExclude" placeholder="排除配置组...">
+        <!-- 新增：总时长显示 -->
+        <div id="quickNavTotalTime"
+            style="padding: 5px 8px; font-size: 12px; color: #666; border-bottom: 1px solid #ddd; text-align: center;">
+            总时长: <span id="quickNavTotalTimeValue">0</span>
+        </div>
+        <div id="quickNavItems"></div>
+    </div>
+
     <script>
         // 全局变量
         let lastValidTime = null;
@@ -1522,6 +1261,15 @@
         let isAdjustingTableHeader = false;
         let lastAdjustmentTime = 0;
         const ADJUSTMENT_THROTTLE = 100; // 100ms节流
+        let currentExcludeText = ''; // 保存当前的排除文本
+
+        // 在全局变量区域添加拾取效率相关变量
+        let currentPickEfficiencyItem = null; // 当前计算的拾取物
+        let isPickEfficiencyMode = false; // 是否处于拾取效率模式
+
+        let picksSortByCount = true; // true: 按数量排序, false: 按拾取顺序
+        let currentSortState = 0; // 0:读取顺序, 1:时间排序, 2:耗时升序, 3:耗时降序
+
 
         // 自定义确认对话框
         function showCustomConfirm(title, message) {
@@ -1737,6 +1485,7 @@
 
             // 确保初始状态没有这些类名
             document.body.classList.remove('static-mode', 'filter-mode');
+            hideQuickNavToggle(); // 确保快速导航初始状态是隐藏的
         };
 
         // 初始化功能按钮状态
@@ -1747,9 +1496,11 @@
                 84: timeColumnsVisible,  // 时间列
                 89: statsColumnsVisible, // 统计列
                 73: picksColumnsVisible, // 拾取物列
+                // 79: isPickEfficiencyMode, // 拾取效率模式（新增）
                 80: isStaticMode,        // 导出模式
                 74: hideZeroStatsTasks,  // 异常任务
-                72: isFilterMode         // 任務篩選
+                72: isFilterMode,         // 任務篩選
+                77: false                // 统计拾取物（新增）
             };
 
             // 更新按钮显示状态
@@ -1758,6 +1509,12 @@
 
         // 处理功能按钮点击
         function handleControlButtonClick(keyCode) {
+            // 对于统计按钮，直接调用函数
+            if (keyCode === 77) {
+                countPickups();
+                return;
+            }
+
             // 模拟键盘事件
             const event = new KeyboardEvent('keydown', {
                 keyCode: keyCode,
@@ -1788,6 +1545,9 @@
                 case 73: // 拾取物列
                     isActive = picksColumnsVisible;
                     break;
+                // case 79: // O 键 - 拾取效率
+                //     isActive = isPickEfficiencyMode;
+                //     break;
                 case 80: // 导出模式
                     isActive = isStaticMode;
                     break;
@@ -1797,8 +1557,11 @@
                 case 72: // 任務篩選
                     isActive = isFilterMode;
                     break;
-                case 85: // 表格格式切换
-                    isActive = useLegacyFormat;
+                // case 85: // 表格格式切换
+                //     isActive = useLegacyFormat;
+                //     break;
+                case 77: // 统计拾取物（新增）- 始终为false，只是占位符
+                    isActive = false;
                     break;
             }
 
@@ -1901,11 +1664,12 @@
                 setTimeout(() => {
                     debouncedAdjustTableHeader();
                 }, 150);
-
                 // 标记已有日志数据
                 hasLogData = true;
+                showQuickNavToggle();
             } catch (e) {
                 document.getElementById('dropZone').innerHTML = `<div class="error">解析失败：${e.message}</div>`;
+                hideQuickNavToggle();
             }
         }
 
@@ -1955,9 +1719,14 @@
             // 添加filter-mode类到body
             document.body.classList.add('filter-mode');
 
-            // 應用篩選
+            //应用筛选
             applyTaskFilter();
 
+            // 如果零统计隐藏已启用，额外应用零统计筛选
+            if (hideZeroStatsTasks) {
+                toggleZeroStatsTasksInFilterMode();
+            }
+
             // 顯示篩選提示
             showFilterIndicator();
 
@@ -1981,6 +1750,22 @@
                 toggleZeroStatsTasksNormal(); // 使用非筛选模式版本
             }
 
+            // 如果处于拾取效率模式，重新应用拾取效率计算
+            if (isPickEfficiencyMode) {
+                // 重新应用拾取效率模式，这会隐藏拾取物汇总行
+                applyPickEfficiency();
+            } else {
+                // 不在拾取效率模式下，确保拾取物汇总行正确显示
+                const tables = document.querySelectorAll('table');
+                tables.forEach(table => {
+                    const summaryRows = table.querySelectorAll('.summary-row');
+                    summaryRows.forEach(row => {
+                        // 只有在非拾取效率模式下才显示汇总行
+                        row.style.display = '';
+                    });
+                });
+            }
+
             // 隐藏筛选提示
             hideFilterIndicator();
 
@@ -2011,9 +1796,6 @@
                     row.style.display = 'none';
                 });
 
-
-
-
                 // 第一步：检查配置组名是否匹配关键字
                 const groupMatchesKeyword = currentFilterKeywords.some(keyword =>
                     groupName.toLowerCase().includes(keyword.toLowerCase())
@@ -2155,6 +1937,7 @@
             // 筛选后调整表头位置
             setTimeout(() => {
                 adjustTableHeaderPosition();
+                refreshQuickNav();
             }, 50);
         }
 
@@ -2170,12 +1953,17 @@
                     teamRolesRow.style.display = '';
                 }
 
-                // 显示所有行，包括拾取物行
+                // 显示所有行，但根据拾取效率模式状态处理拾取物行
                 const rows = table.querySelectorAll('tr');
                 rows.forEach(row => {
                     if (!row.querySelector('th')) {
                         if (row.classList.contains('summary-row')) {
-                            row.style.display = hideZeroStatsTasks ? 'none' : '';
+                            // 在拾取效率模式下隐藏拾取物汇总行
+                            if (isPickEfficiencyMode) {
+                                row.style.display = 'none';
+                            } else {
+                                row.style.display = hideZeroStatsTasks ? 'none' : '';
+                            }
                         } else {
                             row.style.display = '';
                         }
@@ -2189,6 +1977,7 @@
             // 重新调整表头位置
             setTimeout(() => {
                 adjustTableHeaderPosition();
+                refreshQuickNav();
             }, 50);
         }
 
@@ -2311,11 +2100,252 @@
                 }
                 // 标记已有日志数据
                 hasLogData = true;
+                showQuickNavToggle();
             } catch (e) {
                 dropZone.innerHTML = `<div class="error">解析失败：${e.message}</div>`;
+                hideQuickNavToggle();
             }
         });
 
+        function setupSortButtons() {
+            // 时间排序按钮
+            document.querySelectorAll('.sort-btn').forEach(btn => {
+                // 移除旧的事件监听器
+                const newBtn = btn.cloneNode(true);
+                btn.parentNode.replaceChild(newBtn, btn);
+
+                newBtn.addEventListener('click', function (e) {
+                    e.stopPropagation();
+
+                    const table = this.closest('table');
+                    const isLegacy = table.closest('.legacy-format') !== null;
+                    const tbody = table.querySelector('tbody');
+
+                    if (!tbody) return;
+
+                    // 切换排序状态
+                    // 如果当前是耗时排序，切换到时间排序
+                    // 否则在读取顺序和时间排序之间切换
+                    if (currentSortState === 2 || currentSortState === 3) {
+                        currentSortState = 1; // 切换到时间排序
+                    } else {
+                        currentSortState = currentSortState === 0 ? 1 : 0; // 在0和1之间切换
+                    }
+
+                    // 应用排序
+                    applySorting(tbody, isLegacy);
+
+                    // 更新按钮状态
+                    updateSortButtons();
+                });
+            });
+
+            function applySorting(tbody, isLegacy) {
+                if (isLegacy) {
+                    sortLegacyTableByAll(tbody);
+                } else {
+                    sortNormalTableByAll(tbody);
+                }
+            }
+
+            function sortNormalTableByAll(tbody) {
+                const rows = Array.from(tbody.querySelectorAll('tr[data-original-index]'));
+                if (rows.length <= 1) return;
+
+                rows.sort((a, b) => {
+                    if (currentSortState === 0) {
+                        // 读取顺序
+                        const indexA = parseInt(a.getAttribute('data-original-index') || 0);
+                        const indexB = parseInt(b.getAttribute('data-original-index') || 0);
+                        return indexA - indexB;
+                    } else if (currentSortState === 1) {
+                        // 时间排序：最近的在前
+                        const timeA = parseInt(a.getAttribute('data-start-timestamp') || 0);
+                        const timeB = parseInt(b.getAttribute('data-start-timestamp') || 0);
+                        return timeB - timeA;
+                    } else {
+                        // 获取耗时秒数
+                        const durationA = parseDurationToSeconds(a.querySelector('td:nth-child(4)').textContent);
+                        const durationB = parseDurationToSeconds(b.querySelector('td:nth-child(4)').textContent);
+
+                        if (currentSortState === 2) {
+                            // 耗时升序（小到大）
+                            return durationA - durationB;
+                        } else {
+                            // 耗时降序（大到小）
+                            return durationB - durationA;
+                        }
+                    }
+                });
+
+                // 重新插入
+                const fragment = document.createDocumentFragment();
+                rows.forEach(row => fragment.appendChild(row));
+
+                // 保存並重新組裝
+                const headerRow = tbody.querySelector('.team-roles-row');
+                const summaryRow = tbody.querySelector('.summary-row');
+
+                while (tbody.firstChild) tbody.removeChild(tbody.firstChild);
+                if (headerRow) tbody.appendChild(headerRow);
+                tbody.appendChild(fragment);
+                if (summaryRow) tbody.appendChild(summaryRow);
+            }
+
+            function sortLegacyTableByAll(tbody) {
+                console.log('sortLegacyTableByAll called');
+
+                if (!tbody) return;
+
+                // 获取所有任务ID
+                const taskMap = new Map();
+                const taskRows = tbody.querySelectorAll('tr[data-task-id]');
+
+                // 收集每个任务的所有行
+                taskRows.forEach(row => {
+                    const taskId = row.getAttribute('data-task-id');
+                    if (taskId) {
+                        if (!taskMap.has(taskId)) {
+                            taskMap.set(taskId, []);
+                        }
+                        taskMap.get(taskId).push(row);
+                    }
+                });
+
+                // 获取主行用于排序
+                const mainRows = Array.from(tbody.querySelectorAll('.main-row-name'))
+                    .map(cell => {
+                        const tr = cell.closest('tr');
+                        return tr && tr.hasAttribute('data-task-id') ? tr : null;
+                    })
+                    .filter(tr => tr !== null);
+
+                if (mainRows.length <= 1) return;
+
+                // 排序主行
+                mainRows.sort((a, b) => {
+                    if (currentSortState === 0) {
+                        const indexA = parseInt(a.getAttribute('data-original-index') || 0);
+                        const indexB = parseInt(b.getAttribute('data-original-index') || 0);
+                        return indexA - indexB;
+                    } else if (currentSortState === 1) {
+                        const timeA = parseInt(a.getAttribute('data-start-timestamp') || 0);
+                        const timeB = parseInt(b.getAttribute('data-start-timestamp') || 0);
+                        return timeB - timeA;
+                    } else {
+                        // 获取耗时秒数
+                        const durationA = parseDurationToSeconds(a.querySelector('td:nth-child(4)').textContent);
+                        const durationB = parseDurationToSeconds(b.querySelector('td:nth-child(4)').textContent);
+
+                        if (currentSortState === 2) {
+                            return durationA - durationB;
+                        } else {
+                            return durationB - durationA;
+                        }
+                    }
+                });
+
+                // 创建文档片段
+                const fragment = document.createDocumentFragment();
+
+                // 获取并保存非任务行
+                const headerRow = tbody.querySelector('.team-roles-row');
+                const summaryRow = tbody.querySelector('.summary-row');
+
+                // 清空tbody
+                while (tbody.firstChild) {
+                    tbody.removeChild(tbody.firstChild);
+                }
+
+                // 添加表头行
+                if (headerRow) {
+                    tbody.appendChild(headerRow);
+                }
+
+                // 按排序后的顺序添加任务行
+                mainRows.forEach(mainRow => {
+                    const taskId = mainRow.getAttribute('data-task-id');
+                    if (taskId && taskMap.has(taskId)) {
+                        const rows = taskMap.get(taskId);
+                        rows.forEach(row => {
+                            fragment.appendChild(row);
+                        });
+                    }
+                });
+
+                // 添加排序后的任务行
+                tbody.appendChild(fragment);
+
+                // 添加汇总行
+                if (summaryRow) {
+                    tbody.appendChild(summaryRow);
+                }
+            }
+
+            // 耗时排序按钮
+            document.querySelectorAll('.duration-sort-btn').forEach(btn => {
+                const newBtn = btn.cloneNode(true);
+                btn.parentNode.replaceChild(newBtn, btn);
+
+                newBtn.addEventListener('click', function (e) {
+                    e.stopPropagation();
+
+                    const table = this.closest('table');
+                    const isLegacy = table.closest('.legacy-format') !== null;
+                    const tbody = table.querySelector('tbody');
+
+                    if (!tbody) return;
+
+                    // 切换排序状态
+                    // 如果当前是时间排序或读取顺序，切换到耗时升序
+                    // 否则在耗时升序和耗时降序之间切换
+                    if (currentSortState === 0 || currentSortState === 1) {
+                        currentSortState = 2; // 切换到耗时升序
+                    } else if (currentSortState === 2) {
+                        currentSortState = 3; // 切换到耗时降序
+                    } else {
+                        currentSortState = 2; // 从耗时降序回到耗时升序
+                    }
+
+                    // 应用排序
+                    applySorting(tbody, isLegacy);
+
+                    // 更新按钮状态
+                    updateSortButtons();
+                });
+            });
+        }
+
+        function updateSortButtons() {
+            // 更新时间排序按钮
+            document.querySelectorAll('.sort-btn').forEach(btn => {
+                if (currentSortState === 0) {
+                    btn.textContent = '↓';
+                    btn.title = '读取顺序';
+                } else if (currentSortState === 1) {
+                    btn.textContent = '↑';
+                    btn.title = '时间排序（最近的在前）';
+                } else {
+                    btn.textContent = '↕';
+                    btn.title = '点击切换排序';
+                }
+            });
+
+            // 更新耗时排序按钮
+            document.querySelectorAll('.duration-sort-btn').forEach(btn => {
+                if (currentSortState === 2) {
+                    btn.textContent = '↑';
+                    btn.title = '耗时升序（小到大）';
+                } else if (currentSortState === 3) {
+                    btn.textContent = '↓';
+                    btn.title = '耗时降序（大到小）';
+                } else {
+                    btn.textContent = '↕';
+                    btn.title = '点击切换排序';
+                }
+            });
+        }
+
         // 修改坐标弹窗事件处理函数
         function setupCoordPopups() {
             const coordsCells = document.querySelectorAll('.coords-cell');
@@ -2331,6 +2361,8 @@
             let lastClickTime = 0;
             let clickTimeout = null;
 
+            setupSortButtons();
+
             // 定位弹窗函数
             const positionPopup = (popup, cell) => {
                 // 如果已有位置记录，使用记录的位置
@@ -2714,24 +2746,19 @@
                 });
             });
 
+            // // 添加拾取效率按钮事件处理
+            // const efficiencyButtons = document.querySelectorAll('.pick-efficiency-btn');
+            // efficiencyButtons.forEach(btn => {
+            //     btn.addEventListener('click', function (e) {
+            //         e.stopPropagation();
+            //         togglePickEfficiencyMode();
+            //     });
+            // });
+
             // 窗口大小变化时使用防抖
             window.addEventListener('resize', debouncedAdjustTableHeader);
         }
 
-        // 文件处理流程
-        async function processFiles(files) {
-            return files
-                .map(file => ({
-                    file, // 保留原始File对象
-                    date: parseDateFromFileName(file.name)
-                }))
-                .sort((a, b) => a.date - b.date) // 按日期从新到新排序
-                .map(entry => ({
-                    file: entry.file, // 直接传递File对象
-                    date: entry.date
-                }));
-        }
-
         // 从文件名解析日期
         function parseDateFromFileName(fileName) {
             const match = fileName.match(/(\d{4})(\d{2})(\d{2})/);
@@ -2745,6 +2772,28 @@
             return new Date(0); // 无效日期置前
         }
 
+        // 在文件解析成功后显示导航按钮
+        function showQuickNavToggle() {
+            const quickNavToggle = document.getElementById('quickNavToggle');
+            if (quickNavToggle && hasLogData) {
+                quickNavToggle.style.display = 'block'; // 改为block显示
+            }
+        }
+
+        // 在文件解析失败或没有数据时隐藏导航按钮
+        function hideQuickNavToggle() {
+            const quickNavToggle = document.getElementById('quickNavToggle');
+            if (quickNavToggle) {
+                quickNavToggle.style.display = 'none'; // 确保隐藏
+            }
+
+            // 同时隐藏快速导航菜单
+            const quickNav = document.getElementById('quickNav');
+            if (quickNav) {
+                quickNav.classList.remove('visible');
+            }
+        }
+
         // 日志解析逻辑
         function parseLog(content, fileDate) {
             const lines = content.split('\n');
@@ -2764,6 +2813,7 @@
             // 任务级别的角色统计
             let survivalWeights = new Map(); //  生存位权重
             let walkWeights = new Map(); // 行走位权重
+            let dashWeights = new Map(); // 新增：赶路位权重
             let lastSwitchedRole = null; // 记录最近切换的角色
             let pendingSurvivalAction = false; // 标记有生存位动作待处理
             let nahidaCollect = false; // 纳西妲采集标记
@@ -2784,7 +2834,8 @@
                 // 检测采集动作
                 if (line.includes('执行 "纳西妲" 长按E转圈拾取')) {
                     nahidaCollect = true;
-                } else if (line.includes('使用枫原万叶长E拾取掉落物')) {
+                } else if (line.includes('使用枫原万叶长E拾取掉落物') || line.includes('使用 枫原万叶-长E 拾取掉落物') || line.includes('使用 琴-长E 拾取掉落物')) {
+                    // 配置0.52 战后琴拾取 聚材料命令 關鍵字更改來排除採集動作
                     kazuhaCollect = true;
                 }
 
@@ -2793,6 +2844,25 @@
                     pendingSurvivalAction = true;
                 }
 
+                // 新增：检测赶路位指令
+                if (line.includes('自动赶路："') && line.includes('赶路')) {
+                    const dashMatch = line.match(/自动赶路："(.+?)" 赶路/);
+                    if (dashMatch && currentGroup && currentTask) {
+                        const dashRoleName = dashMatch[1];
+
+                        // 记录最近的赶路角色，用于排除行走位权重
+                        currentTask.recentDashRole = dashRoleName;
+                        // // 从行走位权重中移除该角色的权重，确保它不会被选为行走位
+                        // walkWeights.delete(dashRoleName);
+
+                        // 给赶路位较高的权重（比行走位高，比生存位技能低）
+                        let dashWeightToAdd = 15; // 赶路位权重值
+
+                        // 更新赶路位权重
+                        const currentDashWeight = dashWeights.get(dashRoleName) || 0;
+                        dashWeights.set(dashRoleName, currentDashWeight + dashWeightToAdd);
+                    }
+                }
 
                 // 检测成功切换角色
                 if (line.includes('成功切换角色:"')) {
@@ -2804,9 +2874,16 @@
                         let survivalWeightToAdd = 0;
                         let walkWeightToAdd = 0;
 
+                        // 新增：检查最近是否有赶路操作
+                        const hasRecentDash = currentTask.recentDashRole === roleName;
+
                         // 采集相关的切换 - 给负权重确保排除
                         if (nahidaCollect || kazuhaCollect) {
                         }
+                        // 如果是赶路位角色的切换，不给行走位权重
+                        else if (hasRecentDash) {
+                            // 赶路位切换不计入行走位权重
+                        }
                         // 生存位技能后的切换 - 高权重
                         else if (pendingSurvivalAction) {
                             survivalWeightToAdd = WEIGHTS.SURVIVAL_AFTER_SKILL;
@@ -2859,7 +2936,11 @@
                         tasks: [],
                         picks: new Map(),
                         lastActive: null,
-                        teamRoles: new Set()  // 新增：存储不同的队伍角色组合
+                        teamRoles: new Set(),
+                        survivalRoles: [], // 生存位
+                        walkRoles: [],     // 行走位
+                        dashRoles: [],      // 新增：赶路位
+                        hasRotationTargeting: false  // 新增：旋转索敌标记
                     };
                     group.lastActive = parseTime(prevLine, fileDate);
                     parsingContext.activeGroups.set(groupName, group);
@@ -2886,36 +2967,62 @@
                     if (group) {
                         group.endTime = parseTime(prevLine, fileDate);
 
-                        // 汇总配置组的角色信息
-                        const groupSurvivalRoles = new Map();
-                        const groupWalkRoles = new Map();
-
+                        // 检查配置组是否只有跳过的任务
+                        let hasValidTasks = false;
                         group.tasks.forEach(task => {
-                            // 汇总生存位 - 只取每个任务的主要生存位
-                            if (task.survivalRoles && task.survivalRoles.length > 0) {
-                                const mainSurvivalRole = task.survivalRoles[0];
-                                const count = groupSurvivalRoles.get(mainSurvivalRole) || 0;
-                                groupSurvivalRoles.set(mainSurvivalRole, count + 1);
-                            }
-
-                            // 汇总行走位 - 只取每个任务的主要行走位
-                            if (task.walkRoles && task.walkRoles.length > 0) {
-                                const mainWalkRole = task.walkRoles[0];
-                                const count = groupWalkRoles.get(mainWalkRole) || 0;
-                                groupWalkRoles.set(mainWalkRole, count + 1);
+                            // 检查任务是否有实际执行内容
+                            if (hasTaskActualContent(task)) {
+                                hasValidTasks = true;
                             }
                         });
 
-                        // 确定最终的配置组角色
-                        // 生存位：取出现次数最多的一个
-                        const sortedSurvival = Array.from(groupSurvivalRoles.entries())
-                            .sort((a, b) => b[1] - a[1]);
-                        group.survivalRoles = sortedSurvival.length > 0 ? [sortedSurvival[0][0]] : [];
+                        // 如果没有有效任务，标记为跳过
+                        if (!hasValidTasks) {
+                            group.skipped = true;
+                        } else {
+                            // 汇总配置组的角色信息
+                            const groupSurvivalRoles = new Map();
+                            const groupWalkRoles = new Map();
+                            const groupDashRoles = new Map(); // 新增：赶路位汇总
 
-                        // 行走位：取出现次数最多的一个
-                        const sortedWalk = Array.from(groupWalkRoles.entries())
-                            .sort((a, b) => b[1] - a[1]);
-                        group.walkRoles = sortedWalk.length > 0 ? [sortedWalk[0][0]] : [];
+                            group.tasks.forEach(task => {
+                                // 汇总生存位 - 只取每个任务的主要生存位
+                                if (task.survivalRoles && task.survivalRoles.length > 0) {
+                                    const mainSurvivalRole = task.survivalRoles[0];
+                                    const count = groupSurvivalRoles.get(mainSurvivalRole) || 0;
+                                    groupSurvivalRoles.set(mainSurvivalRole, count + 1);
+                                }
+
+                                // 汇总行走位 - 只取每个任务的主要行走位
+                                if (task.walkRoles && task.walkRoles.length > 0) {
+                                    const mainWalkRole = task.walkRoles[0];
+                                    const count = groupWalkRoles.get(mainWalkRole) || 0;
+                                    groupWalkRoles.set(mainWalkRole, count + 1);
+                                }
+                                // 汇总赶路位 - 只取每个任务的主要赶路位
+                                if (task.dashRoles && task.dashRoles.length > 0) {
+                                    const mainDashRole = task.dashRoles[0];
+                                    const count = groupDashRoles.get(mainDashRole) || 0;
+                                    groupDashRoles.set(mainDashRole, count + 1);
+                                }
+                            });
+
+                            // 确定最终的配置组角色
+                            // 生存位：取出现次数最多的一个
+                            const sortedSurvival = Array.from(groupSurvivalRoles.entries())
+                                .sort((a, b) => b[1] - a[1]);
+                            group.survivalRoles = sortedSurvival.length > 0 ? [sortedSurvival[0][0]] : [];
+
+                            // 行走位：取出现次数最多的一个
+                            const sortedWalk = Array.from(groupWalkRoles.entries())
+                                .sort((a, b) => b[1] - a[1]);
+                            group.walkRoles = sortedWalk.length > 0 ? [sortedWalk[0][0]] : [];
+
+                            // 赶路位：取出现次数最多的一个
+                            const sortedDash = Array.from(groupDashRoles.entries())
+                                .sort((a, b) => b[1] - a[1]);
+                            group.dashRoles = sortedDash.length > 0 ? [sortedDash[0][0]] : [];
+                        }
 
                         parsingContext.allGroups.push(group);
                         parsingContext.activeGroups.delete(match[1]);
@@ -2943,6 +3050,11 @@
                         }
                     }
 
+                    // 檢測旋轉索敵
+                    if (line.includes('敌人位置: (') && line.includes('血量高度:')) {
+                        currentGroup.hasRotationTargeting = true;
+                    }
+
                     // 检测自动战斗开始
                     if (line.includes('执行 "自动战斗"')) {
                         battleCount++;
@@ -2955,10 +3067,11 @@
                     // match = line.match(/→ 开始执行(?:地图|路径)追踪任务: "(.+?)"|assets\/(.+?\.json)|当前钓鱼点: (.+)/);
                     // match = line.match(/→ 开始执行(?:地图|路径)追踪任务: "(.+?)"|assets\/(.+?\.json)|当前钓鱼点: (.+)|→ 开始执行JS脚本: "(.+?)"/);
                     // match = line.match(/→ 开始执行(?:地图|路径)追踪任务: "(.+?)"|开始购买NPC: "(.+?)"|当前钓鱼点: (.+)|→ 开始执行JS脚本: "(.+?)"/);
-                    match = line.match(/→ 开始执行(?:地图|路径)追踪任务: "(.+?)"|开始购买NPC: "(.+?)"|assets\/(.+?\.json)|当前钓鱼点: (.+)|→ 开始执行JS脚本: "(.+?)"/);
+                    // match = line.match(/→ 开始执行(?:地图|路径)追踪任务: "(.+?)"|开始购买NPC: "(.+?)"|assets\/(.+?\.json)|当前钓鱼点: (.+)|→ 开始执行JS脚本: "(.+?)"|→ 开始执行键鼠脚本: "(.+?)"/);
+                    match = line.match(/→ 开始执行(?:地图|路径)追踪任务: "(.+?)"|assets\/(.+?\.json)|→ 开始执行JS脚本: "(.+?)"|→ 开始执行键鼠脚本: "(.+?)"/);
                     if (match) {
                         // const taskName = match[1] || match[2] || match[3] || match[4];
-                        const taskName = match[1] || match[2] || match[3] || match[4] || match[5];
+                        const taskName = match[1] || match[2] || match[3] || match[4];
                         const task = {
                             name: taskName,
                             startTime: parseTime(prevLine, fileDate),
@@ -2977,7 +3090,10 @@
                             maxBattleCount: 0, // 记录最大战斗次数
                             specialAlerts: new Map(), // 修改：使用Map而不是数组，用于计数特殊事件
                             survivalRoles: [], // 新增：生存位角色
-                            walkRoles: []      // 新增：行走位角色
+                            walkRoles: [],      // 新增：行走位角色
+                            dashRoles: [],      // 新增：赶路位角色
+                            recentDashRole: null, // 新增：最近的赶路角色，用于排除行走位权重
+                            skipped: false // 新增跳过标记
                         };
                         currentGroup.tasks.push(task);
                         parsingContext.activeTasks.set(task.name, task);
@@ -3031,9 +3147,21 @@
                                 }
                             }
 
+                            // 确定赶路位：取权重最高的角色（只考虑正权重）
+                            let finalDashRole = null;
+                            if (dashWeights.size > 0) {
+                                const sortedDash = Array.from(dashWeights.entries())
+                                    .filter(([role, weight]) => weight > 0)
+                                    .sort((a, b) => b[1] - a[1]);
+                                if (sortedDash.length > 0) {
+                                    finalDashRole = sortedDash[0][0];
+                                }
+                            }
+
                             // 保存到任务
                             task.survivalRoles = finalSurvivalRole ? [finalSurvivalRole] : [];
                             task.walkRoles = finalWalkRole ? [finalWalkRole] : [];
+                            task.dashRoles = finalDashRole ? [finalDashRole] : []; // 新增：保存赶路位
 
                             // 调试输出
                             // console.log(`任务 ${task.name} 生存位权重:`, Array.from(survivalWeights.entries()));
@@ -3048,11 +3176,17 @@
                             // 重置角色计数
                             survivalWeights.clear();
                             walkWeights.clear();
+                            dashWeights.clear();
                             lastSwitchedRole = null;
                             pendingSurvivalAction = false;
                             nahidaCollect = false;
                             kazuhaCollect = false;
 
+                            // 重置赶路角色标记
+                            if (currentTask) {
+                                currentTask.recentDashRole = null;
+                            }
+
                             // 更新当前任务
                             currentTask = currentGroup.tasks.length > 0 ? currentGroup.tasks[currentGroup.tasks.length - 1] : null;
                         }
@@ -3060,6 +3194,20 @@
 
                     // 统计信息
                     if (currentTask) {
+                        // 检测任务跳过信息
+                        if (line.includes("任务已到禁止执行时段，将跳过")) {
+                            currentTask.skipped = true;
+                            // 记录跳过信息到特殊事件
+                            // const message = line.trim();
+                            // const type = 'abnormal-alert';
+                            // if (currentTask.specialAlerts.has(message)) {
+                            //     const existing = currentTask.specialAlerts.get(message);
+                            //     existing.count++;
+                            // } else {
+                            //     currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            // }
+                        }
+
                         // 更新最大战斗次数
                         if (battleCount > currentTask.maxBattleCount) {
                             currentTask.maxBattleCount = battleCount;
@@ -3093,9 +3241,11 @@
                             currentTask.faults.teleport = parseInt(RegExp.$1);
                         // if (line.includes("重试一次路线")) currentTask.faults.retry++;
                         if (line.includes("记录恢复点位，地图追踪将到达上次点位之前将跳过走路之外的操作")) currentTask.faults.retry++;
-                        if (line.includes("疑似卡死，尝试脱离...")) {
+                        if (line.includes("疑似卡死，尝试脱离...") || line.includes("疑似卡死，尝试随机脱离...") || line.includes("尝试朝向上一个节点")) {
                             currentTask.faults.retryDetail++;
-
+                            if (line.includes("尝试朝向上一个节点")) {
+                                currentTask.faults.retryDetail = currentTask.faults.retryDetail - 0.9;
+                            }
                             // 使用最近捕获的坐标
                             if (lastCoordForStuck) {
                                 if (!currentTask.faults.coords) {
@@ -3110,8 +3260,20 @@
                         if (line.includes("距离过远") && /\(\d+\.?\d*,\d+\.?\d*\)->\(\d+\.?\d*,\d+\.?\d*\)=\d+\.?\d*，跳过路径点/)
                             currentTask.faults.too_far_skip++;
 
+                        if (line.includes("，重试多次后仍然失败，放弃此路径点！")) {
+                            const message = '路径识别失败，放弃路径';
+                            const type = 'abnormal-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
                         // 战斗超时事件
-                        if (line.includes("战斗超时")) {
+                        // if (line.includes("战斗超时")) {
+                        if (line.includes("战斗超时结束") || line.includes("旋转次数达到上限，战斗结束")) {
                             currentTask.faults.timeout++;
                             // 记录超时事件对应的战斗序号
                             currentTask.timeoutEvents.push(battleCount);
@@ -3170,7 +3332,7 @@
                         }
 
                         // 2. 自动吃药
-                        if (line.includes('检测到红血且不在CD，自动吃药')) {
+                        if (line.includes('检测到红血且不在CD，自动吃药') || line.includes('自动吃药："发现红血" 使用小道具')) {
                             const message = '自动吃药';
                             const type = 'auto-potion';
                             if (currentTask.specialAlerts.has(message)) {
@@ -3194,7 +3356,7 @@
                         }
 
                         // 4. 文件找不到
-                        if (line.includes('"Could not find file')) {
+                        if (line.includes('"Could not find file') || line.includes('"Could not find a part of the path')) {
                             const message = '路径文件丢失';
                             const type = 'file-missing';
                             if (currentTask.specialAlerts.has(message)) {
@@ -3221,7 +3383,7 @@
                         }
 
                         // 6. 战斗脚本设置错误
-                        if (line.includes('执行脚本时发生异常: "未匹配到任何战斗脚本"')) {
+                        if (line.includes('执行脚本时发生异常: "未匹配到任何战斗脚本"') || line.includes('执行地图追踪时候发生错误: "未匹配到任何战斗脚本"')) {
                             const message = '未匹配到任何战斗脚本';
                             const type = 'combat-script-error';
                             if (currentTask.specialAlerts.has(message)) {
@@ -3283,8 +3445,8 @@
                             }
                         }
 
-                        //10.5
-                        if (line.includes("当前获取焦点的窗口不是原神，暂停")) {
+                        //10.1
+                        if (line.includes("当前获取焦点的窗口不是原神，暂停") || (line.includes("当前获取焦点的窗口为: ") && line.includes("，不是原神，暂停"))) {
                             const message = '窗口焦点异常，暂停';
                             const type = 'pause-alert';
                             if (currentTask.specialAlerts.has(message)) {
@@ -3295,6 +3457,18 @@
                             }
                         }
 
+                        //10.2
+                        if (line.includes("多次尝试未恢复，尝试最小化后激活窗口！")) {
+                            const message = '窗口焦点异常，最小化重试';
+                            const type = 'pause-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
                         // 11. 队伍角色识别失败
                         if (line.includes("队伍角色识别失败")) {
                             const message = '队伍角色识别失败';
@@ -3320,7 +3494,7 @@
                         }
 
                         // 13. 选项列表不存在传送点  重试
-                        if (line.includes("选项列表不存在传送点  重试")) {
+                        if (line.includes("选项列表不存在传送点  重试") || line.includes("传送点未激活或不存在  重试")) {
                             const message = '传送点不存在';
                             const type = 'abnormal-alert';
                             if (currentTask.specialAlerts.has(message)) {
@@ -3382,7 +3556,222 @@
                             }
                         }
 
-                        // 99. 此追踪脚本未正常走完！
+                        // 18. 任务启动失败：当前存在正在运行中的独立任务，请不要重复执行任务！
+                        if (line.includes('任务启动失败：当前存在正在运行中的独立任务，请不要重复执行任务！')) {
+                            const message = '任务启动失败';
+                            const type = 'abnormal-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 19. 简易策略脚本要求的角色不存在！队伍中需要存在下面角色中的一个或多个：".*"
+                        if (line.includes('简易策略脚本要求的角色不存在！队伍中需要存在下面角色中的一个或多个："')) {
+                            const match = line.match(/简易策略脚本要求的角色不存在！队伍中需要存在下面角色中的一个或多个："(.+?)"/);
+                            if (match) {
+                                const message = `缺少脚本指定角色："${match[1]}"`;
+                                const type = 'purple-alert';
+                                if (currentTask.specialAlerts.has(message)) {
+                                    const existing = currentTask.specialAlerts.get(message);
+                                    existing.count++;
+                                } else {
+                                    currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                                }
+                            }
+                        }
+
+                        // 20. 队伍切换失败
+                        if (line.startsWith('队伍切换失败')) {
+                            const message = '队伍切换失败';
+                            const type = 'abnormal-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 21.没有找到四叶印
+                        if (line.startsWith('没有找到四叶印')) {
+                            const message = '没有找到四叶印';
+                            const type = 'purple-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 22.未识别到具体路径，取上次点位
+                        // if (line.startsWith('未识别到具体路径，取上次点位')) {
+                        //     const message = '地圖识别錯誤，取上次点位';
+                        //     const type = 'pause-alert';
+                        //     if (currentTask.specialAlerts.has(message)) {
+                        //         const existing = currentTask.specialAlerts.get(message);
+                        //         existing.count++;
+                        //     } else {
+                        //         currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                        //     }
+                        // }
+
+                        // 23.未识别到具体路径，打开地图计算中心点
+                        // if (line.startsWith('未识别到具体路径，打开地图计算中心点')) {
+                        //     const message = '地圖识别錯誤，打开地图计算中心点';
+                        //     const type = 'pause-alert';
+                        //     if (currentTask.specialAlerts.has(message)) {
+                        //         const existing = currentTask.specialAlerts.get(message);
+                        //         existing.count++;
+                        //     } else {
+                        //         currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                        //     }
+                        // }
+
+                        // 24.鋤地一條龍1.10.0(强制黑芙)
+                        if (line.startsWith('上条路线识别到白芙，开始强制切换黑芙')) {
+                            const message = '强制切换黑芙';
+                            const type = 'purple-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 25.鋤地一條龍(检测到冻结，尝试挣脱)
+                        if (line.startsWith('检测到冻结，尝试挣脱')) {
+                            const message = '冻结挣脱';
+                            const type = 'purple-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 26.鋤地一條龍(检测到烹饪界面，尝试脱离)
+                        if (line.startsWith('检测到烹饪界面，尝试脱离')) {
+                            const message = '脱离烹饪界面';
+                            const type = 'purple-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 27.鋤地一條龍(坐标获取异常，不记录运行数据)
+                        if (line.includes('坐标获取异常，不记录运行数据') ||
+                            (line.includes('出现异常') && line.includes('不记录cd'))) {
+                            const message = '终点坐标异常，不记录';
+                            const type = 'abnormal-alert';
+                            currentTask.faults.too_far_skip++;
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 28.調時(设置时间到 HH 点 MM 分)
+                        // if (line.includes("设置时间到") && line.includes("点") && line.includes("分")) {
+                        //     const match = line.match(/设置时间到 (\d+) 点 (\d+) 分/);
+                        //     if (match) {
+                        //         const hour = match[1];
+                        //         const minute = match[2];
+                        //         const message = `调时至${hour}时${minute}分`;
+                        //         const type = 'purple-alert';
+                        //         if (currentTask.specialAlerts.has(message)) {
+                        //             const existing = currentTask.specialAlerts.get(message);
+                        //             existing.count++;
+                        //         } else {
+                        //             currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                        //         }
+                        //     }
+                        // }
+
+                        // 29. 采集cd管理(进行食材加工)
+                        if (line.match(/正在前往.*进行食材加工/)) {
+                            const message = '进行食材加工';
+                            const type = 'purple-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 30. 战斗过程检测到游泳，前往七天神像重试
+                        if (line.includes('游泳检测：尝试回到战斗地点')) {
+                            const message = '战斗时游泳，回战斗地点';
+                            const type = 'purple-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 31. 战斗过程检测到游泳，前往七天神像重试
+                        if (line.includes('战斗过程检测到游泳，前往七天神像重试')) {
+                            const message = '战斗时游泳，回七天神像';
+                            const type = 'abnormal-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 997. 检测到空月祝福界面，自动点击
+                        if (line.includes('检测到空月祝福界面，自动点击')) {
+                            const message = '领取空月祝福';
+                            const type = 'purple-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // LCB版
+                        // 900. 网络恢复中...
+                        if (line.includes('网络恢复中...')) {
+                            const message = '网络恢复中...';
+                            const type = 'purple-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 998. 用户取消，终止运行
+                        if (line.includes('用户取消，终止运行') || line.includes('取消自动任务')) {
+                            const message = '用户终止运行';
+                            const type = 'abnormal-alert';
+                            if (currentTask.specialAlerts.has(message)) {
+                                const existing = currentTask.specialAlerts.get(message);
+                                existing.count++;
+                            } else {
+                                currentTask.specialAlerts.set(message, { type: type, count: 1 });
+                            }
+                        }
+
+                        // 999. 此追踪脚本未正常走完！
                         if (line.includes('此追踪脚本未正常走完！')) {
                             const message = '脚本未正常走完';
                             const type = 'abnormal-alert';
@@ -3394,11 +3783,42 @@
                             }
                         }
 
-                        const pickMatch = line.match(/交互或拾取："(.+?)"/);
+                        const pickPatterns = [
+                            /交互或拾取："(.+?)"/,          // 原有模式
+                            /尝试钓取 "(.+?)"/,             // 釣魚模式
+                            /拉扯结束/                       // 釣魚結束標記
+                        ];
 
-                        if (pickMatch) {
-                            currentTask.picks.set(pickMatch[1], (currentTask.picks.get(pickMatch[1]) || 0) + 1);
-                            currentGroup.picks.set(pickMatch[1], (currentGroup.picks.get(pickMatch[1]) || 0) + 1);
+                        let pickMatchResult = null;
+                        let pickItemName = null;
+
+                        // 使用配置的模式進行匹配
+                        for (const pattern of pickPatterns) {
+                            const match = line.match(pattern);
+                            if (match) {
+                                pickMatchResult = match;
+
+                                // 提取拾取物名稱
+                                // 如果有捕獲組（.*），使用捕獲組內容作為拾取物
+                                // 如果沒有捕獲組，使用整個匹配字符串作為拾取物
+                                if (match.length > 1 && match[1]) {
+                                    pickItemName = match[1];
+                                } else {
+                                    pickItemName = match[0];
+                                }
+
+                                break; // 匹配到一個模式就停止
+                            }
+                        }
+                        if (pickItemName) {
+                            currentTask.picks.set(pickItemName, (currentTask.picks.get(pickItemName) || 0) + 1);
+                            currentGroup.picks.set(pickItemName, (currentGroup.picks.get(pickItemName) || 0) + 1);
+
+                            // 新增：記錄拾取順序
+                            if (!currentTask.pickSequence) {
+                                currentTask.pickSequence = [];
+                            }
+                            currentTask.pickSequence.push(pickItemName);
                         }
                     }
                 }
@@ -3406,6 +3826,58 @@
             });
         }
 
+        // 清理任务名称：提取纯文件名（不含路径和扩展名）
+        function getFileNameWithoutExtension(fullPath) {
+            // 先提取文件名（不含路径）
+            const fileName = fullPath.split('\\').pop(); // 按反斜杠分割取最后一部分
+
+            // 再去掉扩展名
+            // const nameWithoutExt = fileName.replace(/\.\w+$/, '');
+            // 只移除特定的扩展名，如 .json
+            const nameWithoutExt = fileName.replace(/\.(json|txt|xml|jpg|png)$/i, '');
+
+            return nameWithoutExt;
+        }
+
+        // 新增函数：检查任务是否有实际执行内容
+        function hasTaskActualContent(task) {
+            // 如果有任何统计信息不为0，说明有实际执行
+            if (task.faults.revive > 0 ||
+                task.faults.teleport > 0 ||
+                task.faults.retry > 0 ||
+                task.faults.retryDetail > 0 ||
+                task.faults.too_far_skip > 0 ||
+                task.faults.timeout > 0) {
+                return true;
+            }
+
+            // 如果有拾取物，说明有实际执行
+            if (task.picks && task.picks.size > 0) {
+                return true;
+            }
+
+            // 如果有特殊事件（除了跳过相关的），说明有实际执行
+            if (task.specialAlerts && task.specialAlerts.size > 0) {
+                for (let [message, alertInfo] of task.specialAlerts) {
+                    // 排除跳过相关的消息
+                    if (!message.includes('跳过') && !message.includes('禁止执行时段')) {
+                        return true;
+                    }
+                }
+            }
+
+            // 如果任务持续时间超过很短的时间（比如10秒），说明可能有实际执行
+            if (task.startTime && task.endTime) {
+                const duration = (task.endTime.getTime() - task.startTime.getTime()) / 1000;
+                if (duration > -1) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        // 在 finalizeParsing 函数中过滤掉跳过的配置组
         function finalizeParsing() {
             // 处理未完成任务
             parsingContext.activeTasks.forEach(task => {
@@ -3417,9 +3889,25 @@
                 group.endTime = group.tasks.length > 0
                     ? group.tasks[group.tasks.length - 1].startTime
                     : group.startTime;
+
+                // 检查配置组是否只有跳过的任务
+                let hasValidTasks = false;
+                group.tasks.forEach(task => {
+                    if (hasTaskActualContent(task)) {
+                        hasValidTasks = true;
+                    }
+                });
+
+                if (!hasValidTasks) {
+                    group.skipped = true;
+                }
+
                 parsingContext.allGroups.push(group);
             });
 
+            // 过滤掉跳过的配置组
+            parsingContext.allGroups = parsingContext.allGroups.filter(group => !group.skipped);
+
             return parsingContext.allGroups.sort((a, b) =>
                 (b.endTime || b.startTime) - (a.endTime || a.startTime)
             );
@@ -3554,37 +4042,6 @@
             }
         }
 
-        // 切換全屏模式
-        function changeFullScreen() {
-            // 判断当前是否全屏
-            if (!document.fullscreenElement) {
-                // 进入全屏（兼容不同浏览器）
-                const element = document.documentElement;
-                if (element.requestFullscreen) {
-                    element.requestFullscreen().catch(err => {
-                        console.error(`全屏请求错误: ${err.message}`);
-                    });
-                } else if (element.mozRequestFullScreen) { // Firefox
-                    element.mozRequestFullScreen();
-                } else if (element.webkitRequestFullscreen) { // Chrome/Safari
-                    element.webkitRequestFullscreen();
-                } else if (element.msRequestFullscreen) { // IE/Edge
-                    element.msRequestFullscreen();
-                }
-            } else {
-                // 退出全屏（兼容不同浏览器）
-                if (document.exitFullscreen) {
-                    document.exitFullscreen();
-                } else if (document.mozCancelFullScreen) { // Firefox
-                    document.mozCancelFullScreen();
-                } else if (document.webkitExitFullscreen) { // Chrome/Safari
-                    document.webkitExitFullscreen();
-                } else if (document.msExitFullscreen) { // IE/Edge
-                    document.msExitFullscreen();
-                }
-            }
-        }
-
         // HTML生成逻辑
         function generateHTML(groups) {
             if (useLegacyFormat) {
@@ -3623,33 +4080,55 @@
                         // 添加角色類型標注
                         const roleNotes = [];
 
-                        // 檢查行走位
+                        // 檢查行走位 - 改为模糊匹配
                         if (group.walkRoles && group.walkRoles.length > 0) {
                             const walkRoleNames = roleStr.split(',').map(r => r.trim());
                             const foundWalkRoles = group.walkRoles.filter(walkRole =>
-                                walkRoleNames.includes(walkRole)
+                                walkRoleNames.some(roleName =>
+                                    roleName.includes(walkRole) || walkRole.includes(roleName)
+                                )
                             );
                             if (foundWalkRoles.length > 0) {
                                 roleNotes.push(`行走位:${foundWalkRoles.join(',')}`);
                             }
                         }
 
-                        // 檢查生存位
+                        // 檢查生存位 - 改为模糊匹配
                         if (group.survivalRoles && group.survivalRoles.length > 0) {
                             const survivalRoleNames = roleStr.split(',').map(r => r.trim());
                             const foundSurvivalRoles = group.survivalRoles.filter(survivalRole =>
-                                survivalRoleNames.includes(survivalRole)
+                                survivalRoleNames.some(roleName =>
+                                    roleName.includes(survivalRole) || survivalRole.includes(roleName)
+                                )
                             );
                             if (foundSurvivalRoles.length > 0) {
                                 roleNotes.push(`生存位:${foundSurvivalRoles.join(',')}`);
                             }
                         }
 
+                        // 檢查赶路位（新增）- 改为模糊匹配
+                        if (group.dashRoles && group.dashRoles.length > 0) {
+                            const dashRoleNames = roleStr.split(',').map(r => r.trim());
+                            const foundDashRoles = group.dashRoles.filter(dashRole =>
+                                dashRoleNames.some(roleName =>
+                                    roleName.includes(dashRole) || dashRole.includes(roleName)
+                                )
+                            );
+                            if (foundDashRoles.length > 0) {
+                                roleNotes.push(`赶路位:${foundDashRoles.join(',')}`);
+                            }
+                        }
+
                         // 如果有標注，添加到顯示文本
                         if (roleNotes.length > 0) {
                             displayText += `   (${roleNotes.join(' ')})`;
                         }
 
+                        // 旋轉索敵
+                        if (group.hasRotationTargeting) {
+                            displayText += ` (旋转索敌)`;
+                        }
+
                         return `<div class="team-role-line">${displayText}</div>`;
                     }).join('')}
                                 </div>
@@ -3657,25 +4136,36 @@
                         </tr>`;
                 }
 
-                // 添加表頭行到thead
+                // 修改表头，在拾取物列添加效率按钮
                 html += `
                     <tr class="sticky-header">
                         <th data-sort-type="string">任务名称</th>
-                        <th class="column-start-time">开始时间</th>
+                        <th class="column-start-time">
+                            开始时间 
+                            <btn class="sort-btn" style="font-size:15px;padding:1px 4px;margin-left:3px;cursor:pointer;" 
+                                    title="点击切换排序（默认：读取顺序）">↓</btn>
+                        </th>
                         <th class="column-end-time">结束时间</th>
-                        <th data-sort-type="number">耗时</th>
+                        <th data-sort-type="number">
+                            耗时 
+                            <btn class="duration-sort-btn" style="font-size:15px;padding:1px 4px;margin-left:3px;cursor:pointer;" 
+                                title="点击切换排序">↕</btn>
+                        </th>
                         <th class="column-revive">复活次数</th>
                         <th class="column-retry">重试次数</th>
                         <th class="column-retry-detail">疑似卡死</th>
                         <th class="column-too-far-skip">过远跳过</th>
                         <th class="column-timeout">战斗超时</th>
                         <th class="column-teleport">传送失败</th>
-                        <th class="column-picks">拾取物</th>
+                        <th class="column-picks">
+                            拾取物 
+                            <!--<button class="pick-efficiency-btn" style="margin-left:5px;padding:2px 6px;font-size:12px;cursor:pointer;" title="计算拾取效率">⚡</button>-->
+                        </th>
                     </tr>
                 </thead>
                 <tbody>`;
 
-                group.tasks.forEach(task => {
+                group.tasks.forEach((task, taskIndex) => {
 
                     const hasCoords = task.faults.coords && task.faults.coords.length > 0;
 
@@ -3788,6 +4278,17 @@
                         }
                     }
 
+                    // 格式化retry值：整数显示整数，小数显示两位小数
+                    let retryDetail = '';
+                    if (task.faults.retryDetail !== 0) {
+                        if (Number.isInteger(task.faults.retryDetail)) {
+                            retryDetail = task.faults.retryDetail;
+                        } else {
+                            // 确保小数部分有两位
+                            retryDetail = task.faults.retryDetail.toFixed(2);
+                        }
+                    }
+
                     // 计算任务耗时
                     const duration = calculateDuration(task.startTime, task.endTime);
 
@@ -3795,7 +4296,7 @@
                     const cellClass = hasCoords ? 'coords-cell has-coords' : 'coords-cell';
 
                     // 生成拾取物显示文本
-                    let picksText = formatPicks(task.picks);
+                    let picksText = formatPicks(task.picks, task.pickSequence, true);
 
                     // 按顺序添加提示文本
                     const alerts = [];
@@ -3818,8 +4319,8 @@
                     }
 
                     html += `
-                <tr>
-                    <td class="${shouldHighlight ? 'task-name-red' : ''}">${task.name}</td>
+                <tr data-original-index="${taskIndex}" data-start-timestamp="${task.startTime ? task.startTime.getTime() : 0}"">
+                    <td class="${shouldHighlight ? 'task-name-red' : ''}">${getFileNameWithoutExtension(task.name)}</td>
                     <td class="column-start-time">${formatDateTime(task.startTime)}</td>
                     <td class="column-end-time">${task.endTime ? formatDateTime(task.endTime) : '进行中'}</td>
                     <td class="${shouldHighlight ? 'duration-red' : ''}">${duration}</td>
@@ -3829,7 +4330,7 @@
                     </td>
                     <td class="column-retry ${task.faults.retry >= 2 ? 'red' : ''}">${task.faults.retry == 0 ? '' : task.faults.retry}</td>
                     <td class="column-retry-detail ${cellClass} ${task.faults.retryDetail >= 2 ? '' : ''}">
-                        ${task.faults.retryDetail == 0 ? '' : task.faults.retryDetail}
+                        ${retryDetail}
                         ${coordPopupHTML}
                     </td>
                     <td class="column-too-far-skip ${task.faults.too_far_skip >= 2 ? 'red' : 'red'}">${task.faults.too_far_skip == 0 ? '' : task.faults.too_far_skip}</td>
@@ -3889,33 +4390,55 @@
                         // 添加角色類型標注
                         const roleNotes = [];
 
-                        // 檢查行走位
+                        // 檢查行走位 - 改为模糊匹配
                         if (group.walkRoles && group.walkRoles.length > 0) {
                             const walkRoleNames = roleStr.split(',').map(r => r.trim());
                             const foundWalkRoles = group.walkRoles.filter(walkRole =>
-                                walkRoleNames.includes(walkRole)
+                                walkRoleNames.some(roleName =>
+                                    roleName.includes(walkRole) || walkRole.includes(roleName)
+                                )
                             );
                             if (foundWalkRoles.length > 0) {
                                 roleNotes.push(`行走位:${foundWalkRoles.join(',')}`);
                             }
                         }
 
-                        // 檢查生存位
+                        // 檢查生存位 - 改为模糊匹配
                         if (group.survivalRoles && group.survivalRoles.length > 0) {
                             const survivalRoleNames = roleStr.split(',').map(r => r.trim());
                             const foundSurvivalRoles = group.survivalRoles.filter(survivalRole =>
-                                survivalRoleNames.includes(survivalRole)
+                                survivalRoleNames.some(roleName =>
+                                    roleName.includes(survivalRole) || survivalRole.includes(roleName)
+                                )
                             );
                             if (foundSurvivalRoles.length > 0) {
                                 roleNotes.push(`生存位:${foundSurvivalRoles.join(',')}`);
                             }
                         }
 
+                        // 檢查赶路位（新增）- 改为模糊匹配
+                        if (group.dashRoles && group.dashRoles.length > 0) {
+                            const dashRoleNames = roleStr.split(',').map(r => r.trim());
+                            const foundDashRoles = group.dashRoles.filter(dashRole =>
+                                dashRoleNames.some(roleName =>
+                                    roleName.includes(dashRole) || dashRole.includes(roleName)
+                                )
+                            );
+                            if (foundDashRoles.length > 0) {
+                                roleNotes.push(`赶路位:${foundDashRoles.join(',')}`);
+                            }
+                        }
+
                         // 如果有標注，添加到顯示文本
                         if (roleNotes.length > 0) {
                             displayText += `   (${roleNotes.join(' ')})`;
                         }
 
+                        // 旋轉索敵
+                        if (group.hasRotationTargeting) {
+                            displayText += ` (旋转索敌)`;
+                        }
+
                         return `<div class="team-role-line">${displayText}</div>`;
                     }).join('')}
                                 </div>
@@ -3926,9 +4449,17 @@
                 html += `
                     <tr class="sticky-header">
                         <th data-sort-type="string">任务名称</th>
-                        <th class="column-start-time" data-sort-type="date">开始时间</th>
+                        <th class="column-start-time">
+                            开始时间 
+                            <btn class="sort-btn" style="font-size:15px;padding:1px 4px;margin-left:3px;cursor:pointer;" 
+                                title="点击切换排序（默认：读取顺序）">↓</btn>
+                        </th>
                         <th class="column-end-time" data-sort-type="date">结束时间</th>
-                        <th data-sort-type="number">耗时</th>
+                        <th data-sort-type="number">
+                            耗时 
+                            <btn class="duration-sort-btn" style="font-size:15px;padding:1px 4px;margin-left:3px;cursor:pointer;" 
+                                title="点击切换排序">↕</btn>
+                        </th>
                         <th class="column-revive" data-sort-type="number">复活次数</th>
                         <th class="column-retry" data-sort-type="number">重试次数</th>
                         <th class="column-retry-detail" data-sort-type="number">疑似卡死</th>
@@ -4052,11 +4583,22 @@
                         }
                     }
 
+                    // 格式化retry值：整数显示整数，小数显示两位小数
+                    let retryDetail = '';
+                    if (task.faults.retryDetail !== 0) {
+                        if (Number.isInteger(task.faults.retryDetail)) {
+                            retryDetail = task.faults.retryDetail;
+                        } else {
+                            // 确保小数部分有两位
+                            retryDetail = task.faults.retryDetail.toFixed(2);
+                        }
+                    }
+
                     // 计算任务耗时
                     const duration = calculateDuration(task.startTime, task.endTime);
 
                     // 生成拾取物显示文本
-                    let picksText = formatPicks(task.picks);
+                    let picksText = formatPicks(task.picks, task.pickSequence, true);
 
                     // 按顺序添加提示文本
                     const alerts = [];
@@ -4079,8 +4621,8 @@
                     }
 
                     html += `
-                <tr data-task-id="group-${index}-task-${taskIndex}">
-                    <td class="main-row-name ${shouldHighlight ? 'task-name-red' : ''}" rowspan="2">${task.name}</td>
+                <tr data-task-id="group-${index}-task-${taskIndex}" data-original-index="${taskIndex}" data-start-timestamp="${task.startTime ? task.startTime.getTime() : 0}"> 
+                    <td class="main-row-name ${shouldHighlight ? 'task-name-red' : ''}" rowspan="2">${getFileNameWithoutExtension(task.name)}</td>
                     <td class="column-start-time">${formatDateTime(task.startTime)}</td>
                     <td class="column-end-time">${task.endTime ? formatDateTime(task.endTime) : '进行中'}</td>
                     <td class="${shouldHighlight ? 'duration-red' : ''}">${duration}</td>
@@ -4090,7 +4632,7 @@
                     </td>
                     <td class="column-retry ${task.faults.retry >= 2 ? 'red' : ''}">${task.faults.retry == 0 ? '' : task.faults.retry}</td>
                     <td class="column-retry-detail ${cellClass} ${task.faults.retryDetail >= 2 ? '' : ''}">
-                        ${task.faults.retryDetail == 0 ? '' : task.faults.retryDetail}
+                        ${retryDetail}
                         ${coordPopupHTML}
                     </td>
                     <td class="column-too-far-skip ${task.faults.too_far_skip >= 2 ? 'red' : 'red'}">${task.faults.too_far_skip == 0 ? '' : task.faults.too_far_skip}</td>
@@ -4187,13 +4729,72 @@
             debouncedAdjustTableHeader();
         }
 
-        // 格式化拾取物
-        function formatPicks(picks) {
-            if (picks.size === 0) return '无';
-            return Array.from(picks.entries())
-                .sort((a, b) => b[1] - a[1]) // 按数量从多到少排序
-                .map(([item, count]) => `${item} (${count})`)
-                .join(', ');
+        // 修改格式化拾取物的函数，支持两种显示方式
+        function formatPicks(picks, pickSequence, excludeItems = false) {
+            if (!picks || picks.size === 0) return '无';
+
+            // 需要排除的物品列表
+            // const excludeList = ['小怪', '精英'];
+            const excludeList = [];
+
+            // 过滤函数
+            const shouldExclude = (item) => {
+                if (!excludeItems) return false;
+                return excludeList.some(excluded => item.includes(excluded)); // 包含匹配
+                // return excludeList.includes(item); // 完全相等
+            };
+
+            if (picksSortByCount) {
+                // 按数量从多到少排序（合并统计）
+                const entries = Array.from(picks.entries());
+
+                // 如果需要排除，过滤掉排除的物品
+                const filteredEntries = excludeItems
+                    ? entries.filter(([item, count]) => !shouldExclude(item))
+                    : entries;
+
+                if (filteredEntries.length === 0) return '无';
+
+                return filteredEntries
+                    .sort((a, b) => b[1] - a[1])
+                    .map(([item, count]) => `${item} (${count})`)
+                    .join(', ');
+            } else {
+                // 按拾取顺序显示（不合并，重复的单独显示）
+                if (!pickSequence || pickSequence.length === 0) return '无';
+
+                // 如果需要排除，过滤掉排除的物品
+                const filteredSequence = excludeItems
+                    ? pickSequence.filter(item => !shouldExclude(item))
+                    : pickSequence;
+
+                if (filteredSequence.length === 0) return '无';
+
+                return filteredSequence.join(', ');
+            }
+        }
+
+        // 添加切换拾取物显示顺序的函数
+        function togglePicksSortOrder() {
+            picksSortByCount = !picksSortByCount;
+
+            // 刷新HTML以应用新的排序方式
+            refreshHTML();
+
+            // 显示状态提示
+            showPicksSortOrderIndicator();
+        }
+
+        // 添加显示拾取物排序状态提示的函数
+        function showPicksSortOrderIndicator() {
+            const indicator = document.getElementById('picksToggleIndicator');
+            indicator.textContent = `拾取物显示: ${picksSortByCount ? '按数量合并' : '按拾取顺序'}`;
+            indicator.classList.add('visible');
+
+            // 2秒后隐藏提示
+            setTimeout(() => {
+                indicator.classList.remove('visible');
+            }, 2000);
         }
 
         // 新增：更新时间列的显示状态
@@ -4288,6 +4889,10 @@
             const currentFilterMode = isFilterMode;
             currentFilterKeywords = [...currentFilterKeywords];
 
+            const currentPickEfficiencyMode = isPickEfficiencyMode; // 保存拾取效率模式状态
+            currentPickEfficiencyItem = currentPickEfficiencyItem; // 保存当前计算的物品
+            const currentPicksSortByCount = picksSortByCount; // 新增：保存拾取物排序状态
+
             dropZone.innerHTML = generateHTML(result);
             setupCoordPopups();
 
@@ -4342,9 +4947,13 @@
             // 设置行高亮效果
             setupRowHighlight();
 
+            // 重置排序状态为读取顺序
+            currentSortState = 0;
+
             // 动态调整表头位置 - 添加这行
             setTimeout(() => {
                 adjustTableHeaderPosition();
+                setupSortButtons();
 
                 dropZone.scrollTop = 0;
             }, 200); // 延迟100ms确保DOM完全渲染
@@ -4354,10 +4963,25 @@
             isFilterMode = currentFilterMode;
             currentFilterKeywords = currentFilterKeywords;
 
+            isPickEfficiencyMode = currentPickEfficiencyMode;
+            currentPickEfficiencyItem = currentPickEfficiencyItem;
+            picksSortByCount = currentPicksSortByCount; // 新增：恢复拾取物排序状态
+
             // 应用筛选状态
             if (isFilterMode) {
                 applyTaskFilter();
                 showFilterIndicator();
+
+                // 如果在筛选模式下且不在拾取效率模式，确保拾取物行隐藏
+                if (!isPickEfficiencyMode) {
+                    const tables = document.querySelectorAll('table');
+                    tables.forEach(table => {
+                        const summaryRows = table.querySelectorAll('.summary-row');
+                        summaryRows.forEach(row => {
+                            row.style.display = 'none';
+                        });
+                    });
+                }
             }
 
             // 应用异常任务显示状态
@@ -4374,6 +4998,23 @@
                 }, 150);
             }
 
+            // 重新应用拾取效率模式
+            if (isPickEfficiencyMode && currentPickEfficiencyItem) {
+                setTimeout(() => {
+                    // 在拾取效率模式下隐藏拾取物汇总行
+                    const tables = document.querySelectorAll('table');
+                    tables.forEach(table => {
+                        const summaryRows = table.querySelectorAll('.summary-row');
+                        summaryRows.forEach(row => {
+                            row.style.display = 'none';
+                        });
+                    });
+
+                    applyPickEfficiency();
+                    // updateButtonState(79);
+                }, 150);
+            }
+
             // 重新生成HTML后，根据当前模式设置body类名
             if (isStaticMode) {
                 document.body.classList.add('static-mode');
@@ -4386,6 +5027,9 @@
             } else {
                 document.body.classList.remove('filter-mode');
             }
+
+            // 更新快速导航
+            updateQuickNavItems();
         }
 
         // 修改adjustTableHeaderPosition函数
@@ -4554,6 +5198,28 @@
             };
         }
 
+        // 添加键盘快捷键来打开快速导航（例如 Ctrl+G）
+        document.addEventListener('keydown', function (e) {
+            // 如果正在搜索框中输入，不触发快捷键
+            const searchInput = document.getElementById('quickNavSearch');
+            if (searchInput && document.activeElement === searchInput) {
+                // 只允许ESC键在搜索框中工作
+                if (e.keyCode === 27) { // ESC
+                    hideQuickNav();
+                    e.preventDefault();
+                }
+                return; // 其他快捷键在搜索时不触发
+            }
+
+            // 打开快速导航
+            if (e.keyCode === 71) { // G 鍵
+                e.preventDefault();
+                if (hasLogData) {
+                    toggleQuickNav();
+                }
+            }
+        });
+
         // 監聽鍵盤按下
         document.onkeydown = function (e) {
             var keyNum = e;       // // 使用事件对象而不是 window.event
@@ -4629,6 +5295,7 @@
                 help_text += "Y   切换统计列显示/隐藏\n";
                 help_text += "U   切换表格格式(新旧版)\n";
                 help_text += "I   切换拾取物列显示/隐藏\n";
+                help_text += "Alt+I 切换拾取物显示顺序(数量/拾取顺序)\n";
                 help_text += "J   隐藏/显示所有统计为0的任务\n";
                 help_text += "P   进入/退出导出模式\n";
                 help_text += "~   切换亮色/暗色主题\n";
@@ -4760,6 +5427,14 @@
 
                 toggleTaskFilter();
                 e.preventDefault();
+            } else if (keyNum.keyCode == 73 && keyNum.altKey) { // Alt + I - 切换拾取物显示顺序
+                if (!hasLogData) {
+                    e.preventDefault();
+                    return;
+                }
+
+                togglePicksSortOrder();
+                e.preventDefault();
             } else if (keyNum.keyCode == 73) { // I键 - 切换拾取物列显示（仅旧版格式）
                 // if (!useLegacyFormat) {
                 picksColumnsVisible = !picksColumnsVisible;
@@ -4794,8 +5469,41 @@
                 }
 
 
+                e.preventDefault();
+            } else if (keyNum.keyCode == 79) { // O 键 - 拾取效率计算
+                if (!hasLogData) {
+                    e.preventDefault();
+                    return;
+                }
+
+                togglePickEfficiencyMode();
+                e.preventDefault();
+            } else if (keyNum.keyCode == 77) { // M 键 - 统计拾取物
+                if (!hasLogData) {
+                    e.preventDefault();
+                    return;
+                }
+
+                countPickups();
+                e.preventDefault();
+            } else if (keyNum.keyCode == 113) { // F2 鍵 - 快速上傳文件
+                // 防止在輸入框中觸發
+                const activeElement = document.activeElement;
+                const tagName = activeElement.tagName.toLowerCase();
+                if (tagName === 'input' || tagName === 'textarea') {
+                    return; // 讓輸入框正常處理按鍵
+                }
+
+                // 直接觸發文件選擇對話框
+                document.getElementById('fileInput').click();
+                e.preventDefault();
+            } else if (keyNum.keyCode == 219) { // [ 鍵 - 自由编辑网页
+                // 防止在輸入框中觸發
+                "true" === document.body.getAttribute("contenteditable") ? (document.body.setAttribute("contenteditable", false), alert("关闭自由编辑网页！")) : (document.body.setAttribute("contenteditable", true), alert("启用自由编辑网页！"))
                 e.preventDefault();
             }
+
+
             // 在每个快捷键处理完后，更新对应的按钮状态
             if ([192, 84, 89, 73, 80, 74].includes(keyNum.keyCode)) {
                 // 稍等片刻再更新，确保状态变量已经改变
@@ -4805,6 +5513,380 @@
             }
         }
 
+        // 统计拾取物函数
+        function countPickups() {
+            if (!hasLogData) {
+                return;
+            }
+
+            // 获取用户输入，默认值为战狂,游医,教官,流放者
+            const input = prompt(
+                "请输入要统计的拾取物名称（多个用逗号分隔）\n例如：战狂,游医,教官,流放者\n\n匹配规则：包含关键字即计数",
+                "战狂,游医,教官,流放者"
+            );
+
+            if (input === null || input.trim() === '') {
+                return; // 用户取消或输入为空
+            }
+
+            const itemsToCount = input.split(',')
+                .map(item => item.trim())
+                .filter(item => item.length > 0);
+
+            if (itemsToCount.length === 0) {
+                alert("请输入有效的拾取物名称！");
+                return;
+            }
+
+            // 统计总数
+            let totalCount = 0;
+            const itemCounts = {};
+
+            // 初始化每个物品的计数器
+            itemsToCount.forEach(item => {
+                itemCounts[item] = 0;
+            });
+
+            // 获取所有拾取物单元格（排除汇总行）
+            const pickCells = document.querySelectorAll('.column-picks');
+
+            pickCells.forEach(cell => {
+                // 检查单元格是否可见
+                const row = cell.closest('tr');
+                if (row && row.style.display === 'none') {
+                    return; // 跳过隐藏的行
+                }
+
+                // 检查单元格是否在隐藏的配置组中
+                const container = cell.closest('.group-container');
+                if (container && container.style.display === 'none') {
+                    return; // 跳过隐藏的配置组
+                }
+
+                // 检查是否是汇总行（所有拾取物行）
+                if (row.classList.contains('summary-row')) {
+                    return; // 跳过汇总行
+                }
+
+                // 获取拾取物文本
+                const text = cell.textContent.trim();
+                if (text === '无' || text === '') {
+                    return; // 跳过无拾取物的单元格
+                }
+
+                // 解析拾取物文本 - 包含匹配
+                if (picksSortByCount) {
+                    // 按数量合并模式："物品A (2), 物品B (3)"
+                    const regex = /([^(]+?)\s*\((\d+)\)/g;
+                    let match;
+                    while ((match = regex.exec(text)) !== null) {
+                        const itemName = match[1].trim();
+                        const count = parseInt(match[2]);
+
+                        // 检查是否包含任一统计项（包含匹配）
+                        itemsToCount.forEach(targetItem => {
+                            if (itemName.includes(targetItem)) {
+                                itemCounts[targetItem] += count;
+                                totalCount += count;
+                            }
+                        });
+                    }
+                } else {
+                    // 按拾取顺序模式："物品A, 物品B, 物品A"
+                    const items = text.split(',').map(item => item.trim());
+                    items.forEach(itemName => {
+                        // 检查是否包含任一统计项（包含匹配）
+                        itemsToCount.forEach(targetItem => {
+                            if (itemName.includes(targetItem)) {
+                                itemCounts[targetItem] += 1;
+                                totalCount += 1;
+                            }
+                        });
+                    });
+                }
+            });
+
+            // 构建结果显示文本
+            let resultText = `总计: ${totalCount}个\n\n详细统计:\n`;
+
+            // 按数量从多到少排序
+            const sortedItems = Object.entries(itemCounts)
+                .sort((a, b) => b[1] - a[1])
+                .filter(([_, count]) => count > 0);
+
+            if (sortedItems.length > 0) {
+                sortedItems.forEach(([item, count]) => {
+                    resultText += `${item}: ${count}个\n`;
+                });
+            } else {
+                resultText += "未找到包含指定关键字的拾取物";
+            }
+
+            // 显示结果
+            alert(resultText);
+        }
+
+        // 切换拾取效率模式
+        function togglePickEfficiencyMode() {
+            if (isPickEfficiencyMode) {
+                // 退出拾取效率模式
+                exitPickEfficiencyMode();
+            } else {
+                // 进入拾取效率模式
+                enterPickEfficiencyMode();
+            }
+        }
+
+        // 进入拾取效率模式
+        function enterPickEfficiencyMode() {
+            const input = prompt("请输入要计算效率的拾取物名称（多个关键字用逗号分隔，例如：甜甜花,薄荷）");
+
+            if (input === null) {
+                // 用户取消输入
+                return;
+            }
+
+            const itemNames = input.split(',')
+                .map(name => name.trim())
+                .filter(name => name.length > 0);
+
+            if (itemNames.length === 0) {
+                alert("请输入有效的拾取物名称！");
+                return;
+            }
+
+            currentPickEfficiencyItem = itemNames;
+            isPickEfficiencyMode = true;
+
+            // 应用拾取效率计算和排序
+            applyPickEfficiency();
+
+            // 更新按钮状态
+            // updateButtonState(79); // 假设使用 O 键（79）
+        }
+
+        // 修改退出拾取效率模式函数，确保正确恢复
+        function exitPickEfficiencyMode() {
+            isPickEfficiencyMode = false;
+            currentPickEfficiencyItem = null;
+
+            // 刷新页面恢复原始状态
+            refreshHTML();
+
+            // 如果在筛选模式下，确保拾取物行保持隐藏
+            if (isFilterMode) {
+                const tables = document.querySelectorAll('table');
+                tables.forEach(table => {
+                    const summaryRows = table.querySelectorAll('.summary-row');
+                    summaryRows.forEach(row => {
+                        row.style.display = 'none';
+                    });
+                });
+            }
+
+            // 隐藏状态提示
+            const indicator = document.getElementById('picksToggleIndicator');
+            indicator.classList.remove('visible');
+
+            // 更新按钮状态
+            // updateButtonState(79);
+        }
+
+        // 修改 applyPickEfficiency 函数，确保排除拾取物汇总行
+        function applyPickEfficiency() {
+            if (!currentPickEfficiencyItem) return;
+
+            const tables = document.querySelectorAll('table');
+
+            tables.forEach(table => {
+                const container = table.closest('.group-container');
+
+                // 隐藏拾取物汇总行
+                const summaryRows = table.querySelectorAll('.summary-row');
+                summaryRows.forEach(row => {
+                    row.style.display = 'none';
+                });
+
+                // 选择所有任务行，排除表头、队伍角色行和汇总行
+                const rows = Array.from(table.querySelectorAll('tr:not(.sticky-header):not(.team-roles-row):not(.summary-row):not(.ignore-sort)'));
+
+                // 为每行计算拾取效率
+                const rowsWithEfficiency = rows.map(row => {
+                    const durationCell = row.querySelector('td:nth-child(4)'); // 耗时列
+                    const picksCell = row.querySelector('.column-picks'); // 拾取物列
+
+                    let efficiency = Infinity; // 默认效率为无穷大（没有该拾取物）
+                    let itemCount = 0;
+                    let originalDurationHtml = durationCell ? durationCell.innerHTML : '';
+
+                    if (durationCell && picksCell) {
+                        const durationText = durationCell.textContent;
+                        const picksText = picksCell.innerHTML;
+
+                        // 解析耗时（转换为秒）
+                        const durationInSeconds = parseDurationToSeconds(durationText);
+
+                        // 查找指定拾取物的数量（支持多个关键词）
+                        itemCount = findItemCount(picksText, currentPickEfficiencyItem);
+
+                        // 计算效率：秒/个
+                        if (itemCount > 0 && durationInSeconds > 0) {
+                            efficiency = durationInSeconds / itemCount;
+                        }
+                    }
+
+                    return {
+                        row: row,
+                        efficiency: efficiency,
+                        itemCount: itemCount,
+                        durationText: durationCell ? durationCell.textContent : '',
+                        originalDurationHtml: originalDurationHtml
+                    };
+                });
+
+                // 按效率排序（效率高的排在前面）
+                rowsWithEfficiency.sort((a, b) => {
+                    // 有拾取物的排在前面
+                    if (a.itemCount > 0 && b.itemCount === 0) return -1;
+                    if (a.itemCount === 0 && b.itemCount > 0) return 1;
+                    if (a.itemCount === 0 && b.itemCount === 0) return 0;
+
+                    // 都有的按效率排序（效率高的排前面）
+                    return a.efficiency - b.efficiency;
+                });
+
+                // 重新排列行
+                const tbody = table.querySelector('tbody');
+
+                // 先移除所有任务行（保留表头、队伍角色行和汇总行）
+                rows.forEach(row => {
+                    row.remove();
+                });
+
+                // 添加排序后的行
+                rowsWithEfficiency.forEach(item => {
+                    // 更新耗时显示
+                    const durationCell = item.row.querySelector('td:nth-child(4)');
+                    if (durationCell && item.itemCount > 0) {
+                        const efficiencyText = formatEfficiencyText(item.efficiency, item.itemCount);
+                        durationCell.innerHTML = `${item.durationText}<br><small style="color:#666;font-size:12px;">${efficiencyText}</small>`;
+                    } else if (durationCell) {
+                        // 恢复原始显示
+                        durationCell.innerHTML = item.originalDurationHtml;
+                    }
+
+                    tbody.appendChild(item.row);
+                });
+            });
+
+            // 显示状态提示
+            showPickEfficiencyIndicator();
+        }
+
+        // 解析耗时字符串为秒数
+        function parseDurationToSeconds(durationText) {
+            if (!durationText || durationText === '进行中') return 0;
+
+            let totalSeconds = 0;
+
+            // 匹配天、小时、分钟、秒
+            const dayMatch = durationText.match(/(\d+)天/);
+            const hourMatch = durationText.match(/(\d+)小时/);
+            const minuteMatch = durationText.match(/(\d+)分钟/);
+            const secondMatch = durationText.match(/(\d+(?:\.\d+)?)秒/);
+
+            if (dayMatch) totalSeconds += parseInt(dayMatch[1]) * 24 * 60 * 60;
+            if (hourMatch) totalSeconds += parseInt(hourMatch[1]) * 60 * 60;
+            if (minuteMatch) totalSeconds += parseInt(minuteMatch[1]) * 60;
+            if (secondMatch) totalSeconds += parseFloat(secondMatch[1]);
+
+            return totalSeconds;
+        }
+
+        // 修改 findItemCount 函数，支持包含关键字的匹配
+        function findItemCount(picksHtml, itemNames) {
+            // 将HTML转换为文本进行搜索
+            const tempDiv = document.createElement('div');
+            tempDiv.innerHTML = picksHtml;
+            const picksText = tempDiv.textContent || tempDiv.innerText || '';
+
+            // 如果拾取物文本包含"无"，直接返回0
+            if (picksText.includes('无')) return 0;
+
+            let totalCount = 0;
+
+            // 檢查是否為按拾取顺序模式（文本中沒有括號和數字）
+            const isSequenceMode = !picksHtml.includes('(') && picksText.includes(',');
+
+            if (isSequenceMode) {
+                // 按拾取顺序模式：直接統計關鍵字出現次數
+                const items = picksText.split(',').map(item => item.trim());
+
+                items.forEach(item => {
+                    // 檢查物品名稱是否包含任一關鍵字
+                    const matchesAnyKeyword = itemNames.some(keyword =>
+                        item.toLowerCase().includes(keyword.toLowerCase())
+                    );
+
+                    if (matchesAnyKeyword) {
+                        totalCount += 1; // 每個匹配的物品計為1
+                    }
+                });
+            } else {
+                // 按數量合併模式：使用原有的邏輯
+                // 分割拾取物（按逗号分割）
+                const pickItems = picksText.split(',');
+
+                pickItems.forEach(item => {
+                    const trimmedItem = item.trim();
+
+                    // 检查物品名称是否包含任一关键字
+                    const matchesAnyKeyword = itemNames.some(keyword =>
+                        trimmedItem.toLowerCase().includes(keyword.toLowerCase())
+                    );
+
+                    if (matchesAnyKeyword) {
+                        // 提取数量 - 匹配括号中的数字
+                        const countMatch = trimmedItem.match(/\((\d+)\)/);
+                        if (countMatch) {
+                            totalCount += parseInt(countMatch[1]);
+                        } else {
+                            // 如果沒有括號，默認計為1
+                            totalCount += 1;
+                        }
+                    }
+                });
+            }
+
+            return totalCount;
+        }
+
+        // 转义正则表达式特殊字符
+        function escapeRegExp(string) {
+            return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }
+
+        // 格式化效率文本
+        function formatEfficiencyText(efficiency, itemCount) {
+            if (efficiency === Infinity) return '';
+
+            const secondsPerItem = Math.round(efficiency * 10) / 10; // 保留一位小数
+            return `${secondsPerItem}秒/1个`;
+        }
+
+        // 显示拾取效率状态提示
+        function showPickEfficiencyIndicator() {
+            const indicator = document.getElementById('picksToggleIndicator');
+            const keywordsText = Array.isArray(currentPickEfficiencyItem)
+                ? currentPickEfficiencyItem.join(', ')
+                : currentPickEfficiencyItem;
+
+            indicator.textContent = `拾取效率: ${keywordsText} (按O退出)`;
+            indicator.classList.add('visible');
+
+            // 不自动隐藏，直到用户退出模式
+        }
+
         // 添加显示状态提示函数
         function showZeroStatsToggleIndicator() {
             const indicator = document.getElementById('zeroStatsToggleIndicator');
@@ -4840,6 +5922,11 @@
             showZeroStatsToggleIndicator();
             // 更新按钮状态
             updateButtonState(74);
+
+            // 切换后刷新导航
+            setTimeout(() => {
+                refreshQuickNav();
+            }, 50);
         }
 
         // 修改筛选模式下的零统计筛选函数
@@ -5568,8 +6655,482 @@
             }
         }
 
+        // 快速导航功能
+        let quickNavVisible = false;
+        let currentSearchText = ''; // 保存当前的搜索文本
 
+        // 初始化快速导航
+        function initQuickNav() {
+            const quickNavToggle = document.getElementById('quickNavToggle');
+            const quickNav = document.getElementById('quickNav');
+            const quickNavSearch = document.getElementById('quickNavSearch');
+            const quickNavExclude = document.getElementById('quickNavExclude'); // 新增
+
+            if (!quickNavToggle || !quickNav) return;
+
+            // 设置输入框的placeholder提示
+            if (quickNavSearch) {
+                quickNavSearch.placeholder = "搜索配置组... (多个关键词用,分割)";
+            }
+
+            if (quickNavExclude) {
+                quickNavExclude.placeholder = "排除配置组... (多个关键词用,分割)";
+            }
+
+            // 切换按钮点击事件
+            quickNavToggle.addEventListener('click', function (e) {
+                e.stopPropagation();
+                toggleQuickNav();
+            });
+
+            // 搜索功能
+            if (quickNavSearch) {
+                quickNavSearch.addEventListener('keydown', function (e) {
+                    e.stopPropagation();
+                    if (e.keyCode === 27) { // ESC
+                        hideQuickNav();
+                        e.preventDefault();
+                    }
+                });
+
+                quickNavSearch.addEventListener('input', function (e) {
+                    currentSearchText = this.value;
+                    filterQuickNavItems(currentSearchText, currentExcludeText);
+                });
+            }
+
+            // 排除输入框功能
+            if (quickNavExclude) {
+                quickNavExclude.addEventListener('keydown', function (e) {
+                    e.stopPropagation();
+                    if (e.keyCode === 27) { // ESC
+                        hideQuickNav();
+                        e.preventDefault();
+                    }
+                });
+
+                quickNavExclude.addEventListener('input', function (e) {
+                    currentExcludeText = this.value;
+                    filterQuickNavItems(currentSearchText, currentExcludeText);
+                });
+            }
+
+            // 点击外部关闭
+            document.addEventListener('click', function (e) {
+                if (quickNavVisible && !quickNav.contains(e.target) && !quickNavToggle.contains(e.target)) {
+                    hideQuickNav();
+                }
+            });
+
+            // 设置悬停提示
+            setupQuickNavTooltips();
+        }
+
+        // 切换快速导航显示状态
+        function toggleQuickNav() {
+            if (quickNavVisible) {
+                hideQuickNav();
+            } else {
+                showQuickNav();
+            }
+        }
+
+        // 显示快速导航
+        function showQuickNav() {
+            const quickNav = document.getElementById('quickNav');
+            if (!quickNav) return;
+
+            // 更新导航项
+            updateQuickNavItems();
+
+            quickNav.classList.add('visible');
+            quickNavVisible = true;
+
+            // 恢复搜索文本和排除文本
+            const searchInput = document.getElementById('quickNavSearch');
+            const excludeInput = document.getElementById('quickNavExclude');
+
+            if (searchInput) {
+                searchInput.value = currentSearchText;
+                searchInput.focus();
+            }
+
+            if (excludeInput) {
+                excludeInput.value = currentExcludeText;
+            }
+
+            // 如果有搜索或排除文本，重新应用筛选
+            if (currentSearchText || currentExcludeText) {
+                filterQuickNavItems(currentSearchText, currentExcludeText);
+            }
+        }
+
+        // 隐藏快速导航
+        function hideQuickNav() {
+            const quickNav = document.getElementById('quickNav');
+            if (!quickNav) return;
+
+            quickNav.classList.remove('visible');
+            quickNavVisible = false;
+
+            // 注意：不再清空搜索框，保留搜索文本
+        }
+
+        // 更新快速导航项 - 只显示当前可见的配置组和纯配置组名
+        function updateQuickNavItems() {
+            const quickNavItems = document.getElementById('quickNavItems');
+            if (!quickNavItems) return;
+
+            quickNavItems.innerHTML = '';
+
+            const groups = document.querySelectorAll('.group-container');
+            let hasVisibleGroups = false;
+            let totalDurationSeconds = 0; // 新增：用于累计总时长（秒）
+
+            groups.forEach((group, index) => {
+                // 检查配置组是否可见
+                if (group.style.display === 'none') {
+                    return; // 跳过隐藏的配置组
+                }
+
+                const groupHeader = group.querySelector('.group-header h2');
+                if (!groupHeader) return;
+
+                // 从完整标题中提取纯配置组名称
+                const fullTitle = groupHeader.textContent.trim();
+                const groupName = extractGroupName(fullTitle);
+
+                const groupId = `group-container-${index}`;
+
+                group.id = groupId; // 确保组有ID
+
+                const navItem = document.createElement('div');
+                navItem.className = 'quick-nav-item';
+                navItem.textContent = groupName;
+                navItem.setAttribute('data-group-id', groupId);
+                navItem.setAttribute('data-full-title', fullTitle); // 保存完整标题用于悬停提示
+
+                navItem.addEventListener('click', function () {
+                    scrollToGroup(groupId);
+                    // 注意：不再自动隐藏导航
+                });
+
+                quickNavItems.appendChild(navItem);
+                hasVisibleGroups = true;
+
+                // 新增：累加总时长
+                const durationInSeconds = extractDurationFromTitle(fullTitle);
+                totalDurationSeconds += durationInSeconds;
+            });
+
+            // 新增：更新总时长显示
+            updateTotalDurationDisplay(totalDurationSeconds);
+
+            // 如果没有可见的配置组，显示提示
+            if (!hasVisibleGroups) {
+                const noResults = document.createElement('div');
+                noResults.className = 'quick-nav-item no-results';
+                noResults.textContent = '没有可见的配置组';
+                noResults.style.cursor = 'default';
+                noResults.style.color = '#999';
+                noResults.style.fontStyle = 'italic';
+                quickNavItems.appendChild(noResults);
+
+                // 新增：如果没有可见配置组，总时长显示为0
+                updateTotalDurationDisplay(0);
+            }
+        }
+
+        // 从完整标题中提取纯配置组名称
+        function extractGroupName(fullTitle) {
+            // 示例完整标题: "配置組：自動釣魚　下 (2025/05/23 07:19:45 - 2025/05/23 09:34:18) 耗时2小时14分钟33秒"
+            // 目标: "自動釣魚　下"
+
+            // 方法1: 使用正则表达式匹配"配置組："之后，"("之前的部分
+            const match = fullTitle.match(/配置組：([^(]+)/);
+            if (match && match[1]) {
+                return match[1].trim();
+            }
+
+            // 方法2: 如果正则失败，使用字符串分割
+            if (fullTitle.startsWith('配置組：')) {
+                const withoutPrefix = fullTitle.substring(4); // 去掉"配置組："
+                const bracketIndex = withoutPrefix.indexOf(' (');
+                if (bracketIndex !== -1) {
+                    return withoutPrefix.substring(0, bracketIndex).trim();
+                }
+                return withoutPrefix.trim();
+            }
+
+            // 如果都不行，返回原文本
+            return fullTitle;
+        }
+
+        // 滚动到指定配置组
+        function scrollToGroup(groupId) {
+            const group = document.getElementById(groupId);
+            if (!group) return;
+
+            const dropZone = document.getElementById('dropZone');
+            if (!dropZone) return;
+
+            // 计算目标位置（考虑固定表头）
+            const groupRect = group.getBoundingClientRect();
+            const dropZoneRect = dropZone.getBoundingClientRect();
+            const targetScrollTop = dropZone.scrollTop + groupRect.top - dropZoneRect.top - 60; // 调整为60px偏移
+
+            // 平滑滚动
+            dropZone.scrollTo({
+                top: targetScrollTop,
+                behavior: 'smooth'
+            });
+
+            // 高亮目标组
+            highlightGroup(group);
+        }
+
+        // 高亮目标配置组
+        function highlightGroup(group) {
+            // 移除之前的高亮
+            document.querySelectorAll('.group-container').forEach(g => {
+                g.style.boxShadow = '';
+                g.style.transition = 'box-shadow 0.3s ease';
+            });
+
+            // 添加新高亮
+            group.style.boxShadow = '0 0 0 3px #4CAF50';
+
+            // 3秒后移除高亮
+            setTimeout(() => {
+                group.style.boxShadow = '';
+            }, 3000);
+        }
+
+        // 筛选导航项 - 使用纯配置组名进行筛选
+        function filterQuickNavItems(searchText, excludeText) {
+            const navItems = document.querySelectorAll('.quick-nav-item');
+
+            // 处理包含关键词：分割并清理
+            const includeKeywords = searchText
+                ? searchText.split(',').map(keyword => keyword.trim().toLowerCase()).filter(keyword => keyword.length > 0)
+                : [];
+
+            // 处理排除关键词：分割并清理
+            const excludeKeywords = excludeText
+                ? excludeText.split(',').map(keyword => keyword.trim().toLowerCase()).filter(keyword => keyword.length > 0)
+                : [];
+
+            let hasMatches = false;
+            let totalDurationSeconds = 0; // 新增：用于累计总时长（秒）
+
+            navItems.forEach(item => {
+                // 跳过"没有可见的配置组"提示
+                if (item.textContent === '没有可见的配置组') {
+                    item.style.display = 'none';
+                    return;
+                }
+
+                // 使用显示的纯配置组名进行筛选
+                const displayText = item.textContent.toLowerCase();
+
+                // 包含条件：如果搜索关键词为空，或者配置组名包含任意一个搜索关键词
+                let matchesInclude = true;
+                if (includeKeywords.length > 0) {
+                    matchesInclude = includeKeywords.some(keyword => displayText.includes(keyword));
+                }
+
+                // 排除条件：如果排除关键词为空，或者配置组名不包含任何排除关键词
+                let matchesExclude = true;
+                if (excludeKeywords.length > 0) {
+                    matchesExclude = !excludeKeywords.some(keyword => displayText.includes(keyword));
+                }
+
+                // 同时满足包含和排除条件
+                if (matchesInclude && matchesExclude) {
+                    item.style.display = 'block';
+                    hasMatches = true;
+
+                    // 新增：获取该配置组的时长并累加
+                    const fullTitle = item.getAttribute('data-full-title');
+                    if (fullTitle) {
+                        const durationInSeconds = extractDurationFromTitle(fullTitle);
+                        totalDurationSeconds += durationInSeconds;
+                    }
+                } else {
+                    item.style.display = 'none';
+                }
+            });
+
+            // 更新总时长显示
+            updateTotalDurationDisplay(totalDurationSeconds);
+
+            // 更新提示信息，显示当前的过滤条件
+            const quickNavItems = document.getElementById('quickNavItems');
+            let noResults = quickNavItems.querySelector('.no-results');
+
+            if (!hasMatches && !noResults) {
+                noResults = document.createElement('div');
+                noResults.className = 'quick-nav-item no-results';
+
+                let message = '没有找到匹配的配置组';
+                if (includeKeywords.length > 0 && excludeKeywords.length > 0) {
+                    message = `没有找到包含 [${includeKeywords.join(', ')}] 且排除 [${excludeKeywords.join(', ')}] 的配置组`;
+                } else if (includeKeywords.length > 0) {
+                    message = `没有找到包含 [${includeKeywords.join(', ')}] 的配置组`;
+                } else if (excludeKeywords.length > 0) {
+                    message = `没有找到排除 [${excludeKeywords.join(', ')}] 的配置组`;
+                }
+
+                noResults.textContent = message;
+                noResults.style.cursor = 'default';
+                noResults.style.color = '#999';
+                noResults.style.fontStyle = 'italic';
+                quickNavItems.appendChild(noResults);
+            } else if (hasMatches && noResults) {
+                noResults.remove();
+            }
+        }
+
+        // 新增：从配置组标题中提取时长（秒）
+        function extractDurationFromTitle(fullTitle) {
+            // 示例标题格式："配置組：自動釣魚　下 (2025/05/23 07:19:45 - 2025/05/23 09:34:18) 耗时2小时14分钟33秒"
+            // 或 "配置組：鋤JS-精英 (2025/12/26 04:20:24 - 2025/12/26 08:08:24) 耗时3小时48分钟"
+            const durationMatch = fullTitle.match(/耗时(.+)$/);
+
+            if (durationMatch) {
+                const durationText = durationMatch[1].trim();
+
+                // 處理沒有"秒"的情況 - 添加"0秒"
+                let textToParse = durationText;
+                if (!textToParse.includes('秒')) {
+                    textToParse += '0秒';
+                }
+
+                return parseDurationToSeconds(textToParse);
+            }
+
+            return 0;
+        }
+
+        // 新增：更新总时长显示
+        function updateTotalDurationDisplay(totalSeconds) {
+            const totalTimeValueElement = document.getElementById('quickNavTotalTimeValue');
+            if (totalTimeValueElement) {
+                const formattedDuration = formatDuration(totalSeconds);
+                totalTimeValueElement.textContent = formattedDuration;
+            }
+        }
+
+        // 刷新导航可见项 - 在筛选或隐藏操作后调用
+        function refreshQuickNav() {
+            if (quickNavVisible) {
+                updateQuickNavItems();
+                // 重新应用当前的搜索和排除筛选
+                if (currentSearchText || currentExcludeText) {
+                    filterQuickNavItems(currentSearchText, currentExcludeText);
+                }
+            }
+        }
+
+        // 在页面加载时初始化快速导航
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', initQuickNav);
+        } else {
+            initQuickNav();
+        }
+
+        function setupQuickNavTooltips() {
+            const quickNavItems = document.getElementById('quickNavItems');
+            if (!quickNavItems) return;
+
+            // 创建提示框元素
+            const tooltip = document.createElement('div');
+            tooltip.id = 'quickNavTooltip';
+            tooltip.style.cssText = `
+        position: fixed;
+        display: none;
+        background: rgba(0, 0, 0, 0.9);
+        color: white;
+        padding: 12px;
+        border-radius: 6px;
+        font-size: 12px;
+        line-height: 1.4;
+        z-index: 1002;
+        pointer-events: none;
+        max-width: 300px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+        white-space: pre-line;
+        border: 1px solid #555;
+    `;
+            document.body.appendChild(tooltip);
+
+            // 暗色主题适配
+            if (document.body.classList.contains('dark-theme')) {
+                tooltip.style.background = 'rgba(50, 50, 50, 0.95)';
+                tooltip.style.borderColor = '#777';
+            }
+
+            // 事件委托处理悬停
+            quickNavItems.addEventListener('mouseover', function (e) {
+                const target = e.target;
+                if (target.classList.contains('quick-nav-item')) {
+                    const fullTitle = target.getAttribute('data-full-title');
+                    if (fullTitle) {
+                        // 解析完整标题，提取配置组名和时间信息
+                        const parsedInfo = parseGroupTitle(fullTitle);
+                        tooltip.innerHTML = formatTooltipContent(parsedInfo);
+                        tooltip.style.display = 'block';
+                    }
+                }
+            });
+
+            quickNavItems.addEventListener('mousemove', function (e) {
+                if (tooltip.style.display === 'block') {
+                    // 定位在鼠标左侧
+                    const x = e.clientX - tooltip.offsetWidth - 10;
+                    const y = e.clientY;
+
+                    tooltip.style.left = Math.max(10, x) + 'px';
+                    tooltip.style.top = y + 'px';
+                }
+            });
+
+            quickNavItems.addEventListener('mouseout', function (e) {
+                if (e.target.classList.contains('quick-nav-item')) {
+                    tooltip.style.display = 'none';
+                }
+            });
+        }
+
+        // 解析配置组标题
+        function parseGroupTitle(fullTitle) {
+            // 示例格式: "配置組：CD-甜甜花 (2025/10/19 19:27:00 - 2025/10/19 19:37:21) 耗时10分钟21秒"
+            const groupNameMatch = fullTitle.match(/配置組：([^(]+)/);
+            const timeRangeMatch = fullTitle.match(/\(([^)]+)\)/);
+            const durationMatch = fullTitle.match(/耗时(.+)$/);
+
+            return {
+                groupName: groupNameMatch ? groupNameMatch[1].trim() : fullTitle,
+                timeRange: timeRangeMatch ? timeRangeMatch[1] : '',
+                duration: durationMatch ? durationMatch[1] : ''
+            };
+        }
+
+        // 格式化提示框内容
+        function formatTooltipContent(parsedInfo) {
+            let content = '';
+            if (parsedInfo.groupName) {
+                content += `<div style="font-weight: bold; margin-bottom: 5px;">${parsedInfo.groupName}</div>`;
+            }
+            if (parsedInfo.timeRange) {
+                content += `<div style="color: #ccc; margin-bottom: 3px;">(${parsedInfo.timeRange})</div>`;
+            }
+            if (parsedInfo.duration) {
+                content += `<div style="color: #aaa; font-size: 11px;">耗时${parsedInfo.duration}</div>`;
+            }
+            return content;
+        }
     </script>
 </body>
 
-</html>
+</html>
\ No newline at end of file