feat(docs): 更新隐私政策以支持IPv6功能

- 在隐私政策中添加IPv6连接测试和IPv6地址获取的信息。
- 更新相关条款以反映最新的隐私信息收集方式。

FAQ-en.md

@@ -34,7 +34,7 @@
 
 > **2. Patches will not be installed for games you do not own ❗**
 
-> **3. This tool is only for installing patches, not for installing games ❗ It only runs on Windows x64 systems ❗**
+> **3. This tool is only for installing patches, not for installing games ❗ It only runs on Windows 10/11 64-bit systems (other platforms or versions have not been tested) ❗**
 
 > **4. The tool requires administrator privileges to run ❗
 > Reason: To prevent installation issues caused by the game running, the tool will get game process information to close the game before starting ❗**

FAQ.md

@@ -31,7 +31,7 @@
 
 > **2. 尚未拥有的游戏将不会进行补丁安装 ❗**
 
-> **3. 本工具仅适用于补丁安装，不适用于安装游戏 ❗ 且仅限于在 Windows x64 系统上运行 ❗**
+> **3. 本工具仅适用于补丁安装，不适用于安装游戏 ❗ 且仅限于在 Windows 10/11 64位系统上运行（其他平台或版本未经测试）❗**
 
 > **4. 工具需要使用管理员权限运行 ❗
 > 原因：为了防止用户在没有关闭正在运行的游戏而影响本工具的安装效果，启用应用前会获取游戏进程信息从而关闭游戏 ❗**

PRIVACY.md

@@ -0,0 +1,91 @@
+# FRAISEMOE Addons Installer NEXT 隐私政策
+
+## 1. 引言
+
+本隐私政策旨在说明 FRAISEMOE Addons Installer NEXT（以下简称"本应用"）在使用过程中如何收集、使用和保护您的个人信息。我们致力于保护您的隐私，并确保您了解我们如何处理您的数据。
+
+## 2. 收集的信息
+
+本应用在运行过程中可能会收集或处理以下信息：
+
+### 2.1 系统信息
+- 程序版本号：用于检查更新和兼容性
+
+### 2.2 网络相关信息
+- **IP 地址、ISP 及地理位置**: 应用启动时，为获取云端配置，您的 IP 地址会被服务器记录。服务器可能会根据您的 IP 地址推断您的互联网服务提供商（ISP）和地理位置，这些信息仅用于用户数量、区域分布的统计和软件使用情况分析。当您使用 Cloudflare 加速功能时，您的 IP 地址也会被用于节点优选。
+- **下载统计信息**：用于监控下载进度和速度
+- **IPv6 连接测试**：应用会访问 testipv6.cn（test-ipv6.com 的中国大陆镜像网站）以判断软件是否支持 IPv6 连接
+- **IPv6 地址获取**：应用在测试 IPv6 功能时会请求 ipw.cn 获取您的公网 IPv6 地址，仅用于显示和连接测试目的
+
+### 2.3 文件信息
+- 游戏安装路径：用于识别已安装的游戏和安装补丁
+- 文件哈希值：用于验证文件完整性
+
+## 3. 信息使用
+
+我们收集的信息仅用于以下目的：
+
+### 3.1 功能实现
+- 游戏目录识别：识别已安装的游戏版本
+- 文件完整性验证：确保下载文件的完整性和安全性
+- 下载加速：通过 Cloudflare 优化下载速度
+
+### 3.2 服务改进
+- **应用更新**：检查应用版本并推送更新。
+- **使用情况分析**：通过统计IP地址、ISP和地理位置等信息，分析用户下载次数与软件使用情况，以帮助我们改进服务。您的所有信息都仅用于软件使用统计，不会用于其他特殊目的。
+- **错误报告**：收集错误信息以改进应用体验。
+
+## 4. 数据存储
+
+### 4.1 本地存储
+- 配置文件：保存在系统临时文件夹的 FRAISEMOE 子目录下
+- 临时下载文件：保存在系统临时文件夹中
+- 日志文件：记录程序运行日志
+
+### 4.2 网络传输
+所有网络请求均使用安全的 HTTPS 协议进行传输。
+
+## 5. 修改系统文件
+
+### 5.1 hosts 文件修改
+- 当您选择使用 Cloudflare 加速功能时，本应用会临时修改系统 hosts 文件
+- 修改前会自动创建备份（位于 %SystemRoot%\System32\drivers\etc\hosts.bak.FRAISEMOE Addons Installer NEXT）
+- 程序退出时会自动恢复原始 hosts 文件
+
+## 6. 第三方服务
+
+本应用使用以下第三方服务：
+
+### 6.1 Cloudflare
+- 本应用使用第三方开源项目 [CloudflareSpeedTest (CFST)](https://github.com/XIU2/CloudflareSpeedTest/) 为您提供 Cloudflare 加速功能。该优选服务由 CFST 项目提供，本项目及作者不负责其功能的实际维护。
+- 启用此功能时，CFST 将向 Cloudflare 的所有节点发送请求以测试延迟，此过程不可避免地会将您的 IP 地址提交至 Cloudflare。我们建议您遵循并查阅 Cloudflare 的相关用户协议和隐私政策。
+
+### 6.2 云端配置服务
+- 本应用启动时会从云端服务器获取配置信息（如下载链接等）。在此过程中，服务器会获取并统计您的IP地址、地理位置及ISP等信息，以用于软件使用情况分析。
+- 为确保通信安全和服务的稳定性，云端服务器设置了严格的 User-Agent 校验，仅允许本应用内置的特定 User-Agent 发出请求。非本应用指定的 User-Agent 将无法访问服务。
+
+## 7. 用户控制
+
+您对以下功能有完全的控制权：
+
+- 选择是否使用 Cloudflare 加速功能（需修改 hosts 文件）
+- 选择安装目录和需要安装的游戏版本
+- 选择是否终止可能冲突的进程
+
+## 8. 数据安全
+
+我们采取以下措施保护您的数据：
+
+- 本地配置文件不包含敏感个人信息
+- 网络请求使用安全的 HTTPS 协议
+- hosts 文件修改会在程序退出时自动恢复
+
+## 9. 联系我们
+
+如果您对本隐私政策有任何疑问或建议，请通过 GitHub 项目页面联系我们。
+
+## 10. 政策更新
+
+本隐私政策可能会根据应用功能的变化而更新。请定期查看最新版本。
+
+最后更新日期：2025年8月4日 

README-en.md

@@ -75,6 +75,7 @@ This project uses Git for version control. You can view the currently available
 1.  **Do not use modified applications**: The authors and developers are not responsible for any personal loss resulting from the use of applications from unknown or modified sources.
 2.  **Follow all rules**: Please strictly adhere to the rules in the [User Guide](https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/blob/master/FAQ.md) and this document. The authors and developers are not liable for any violations.
 3.  **Free and Open Source**: This application is free and open-source. If you obtained it through a paid channel, please request a refund immediately and take action to protect your rights.
+4.  **System Compatibility**: This application has been tested and works with Windows 10/11 64-bit systems. Other platforms or versions have not been tested.
 
 ---
 
@@ -87,6 +88,7 @@ This project uses Git for version control. You can view the currently available
 - [HTony03](https://github.com/HTony03): Provided support for refactoring, logic optimization, and feature implementation for parts of the original source code.
 - [钨鸮](https://github.com/ABSIDIA): Provided support for cloud resource storage.
 - [XIU2/CloudflareSpeedTest](https://github.com/XIU2/CloudflareSpeedTest): Provided core support for the IP optimization feature of this project.
+- [hosxy/aria2-fast](https://github.com/hosxy/aria2-fast): Provided a modified version of aria2c for improved download speed and performance.
 
 ## 📖 License
 

README.md

@@ -73,6 +73,7 @@
 1. 请勿使用经过二次修改的应用：若使用未知来源或修改后的应用导致个人利益受损，作者和开发人员不承担任何责任。
 2. 请遵循所有规则：请严格遵守 [使用须知文档](https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/blob/master/FAQ.md) 和本文档中的规则，如有违反，作者和开发人员不承担责任。
 3. 免费开源：本应用免费、开源，如有通过非免费途径获取，请立即向来源申请退款并积极维权。
+4. 系统兼容性：本应用已实测可兼容Windows 10/11 64位系统，其他平台或版本未经测试。
 
 ---
 
@@ -80,18 +81,13 @@
 
 - [ouyangqiqi](https://github.com/hyb-oyqq): 本仓库现维护者
 
-## 💡 注意事项
-
-1. 请勿使用经过二次修改的应用：若使用未知来源或修改后的应用导致个人利益受损，作者和开发人员不承担任何责任。
-2. 请遵循所有规则：请严格遵守 [使用须知文档](https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/blob/master/FAQ.md) 和本文档中的规则，如有违反，作者和开发人员不承担责任。
-3. 免费开源：本应用免费、开源，如有通过非免费途径获取，请立即向来源申请退款并积极维权。
-
 
 ## 🎉 特别鸣谢
 - [Yanam1Anna](https://github.com/Yanam1Anna): 本项目的原作者，提供了大量代码和资源。
 - [HTony03](https://github.com/HTony03)：对于原项目部分源码的重构、逻辑优化和功能实现提供了支持。
 - [钨鸮](https://github.com/ABSIDIA)：对于云端资源存储提供了支持。
 - [XIU2/CloudflareSpeedTest](https://github.com/XIU2/CloudflareSpeedTest)：为本项目提供了 IP 优选功能的核心支持。
+- [hosxy/aria2-fast](https://github.com/hosxy/aria2-fast)：提供了修改版aria2c，提高了下载速度和性能。
 
 ## 📖 协议
 

source/Main.py

@@ -1,9 +1,35 @@
 import sys
-from PySide6.QtWidgets import QApplication
+from PySide6.QtWidgets import QApplication, QMessageBox
 from main_window import MainWindow
+from core.privacy_manager import PrivacyManager
+from utils.logger import setup_logger
 
 if __name__ == "__main__":
+    # 初始化日志
+    logger = setup_logger("main")
+    logger.info("应用启动")
+    
     app = QApplication(sys.argv)
+    
+    # 初始化隐私协议管理器
+    try:
+        privacy_manager = PrivacyManager()
+    except Exception as e:
+        logger.error(f"初始化隐私协议管理器失败: {e}")
+        QMessageBox.critical(
+            None, 
+            "隐私协议加载错误", 
+            f"无法加载隐私协议管理器，程序将退出。\n\n错误信息：{e}"
+        )
+        sys.exit(1)
+    
+    # 显示隐私协议对话框
+    if not privacy_manager.show_privacy_dialog():
+        logger.info("用户未同意隐私协议，程序退出")
+        sys.exit(0)  # 如果用户不同意隐私协议，退出程序
+    
+    # 用户已同意隐私协议，继续启动程序
+    logger.info("隐私协议已同意，启动主程序")
     window = MainWindow()
     window.show()
     sys.exit(app.exec())

source/core/__init__.py

@@ -2,10 +2,26 @@ from .animations import MultiStageAnimations
 from .ui_manager import UIManager
 from .download_manager import DownloadManager
 from .debug_manager import DebugManager
+from .window_manager import WindowManager
+from .game_detector import GameDetector
+from .patch_manager import PatchManager
+from .config_manager import ConfigManager
+from .privacy_manager import PrivacyManager
+from .cloudflare_optimizer import CloudflareOptimizer
+from .download_task_manager import DownloadTaskManager
+from .extraction_handler import ExtractionHandler
 
 __all__ = [
     'MultiStageAnimations',
     'UIManager',
     'DownloadManager',
-    'DebugManager'
+    'DebugManager',
+    'WindowManager',
+    'GameDetector',
+    'PatchManager',
+    'ConfigManager',
+    'PrivacyManager',
+    'CloudflareOptimizer',
+    'DownloadTaskManager',
+    'ExtractionHandler'
 ] 

source/core/animations.py

@@ -185,6 +185,11 @@ class MultiStageAnimations(QObject):
             widget.setGraphicsEffect(effect)
             widget.move(widget.x(), self.canvas_height + 100)
             widget.show()
+            
+        # 禁用所有按钮，直到动画完成
+        self.ui.start_install_btn.setEnabled(False)
+        self.ui.uninstall_btn.setEnabled(False)
+        self.ui.exit_btn.setEnabled(False)
 
     def start_logo_animations(self):
         """启动Logo动画序列"""
@@ -337,6 +342,12 @@ class MultiStageAnimations(QObject):
     def start_animations(self):
         """启动完整动画序列"""
         self.clear_animations()
+        
+        # 确保按钮在动画开始时被禁用
+        self.ui.start_install_btn.setEnabled(False)
+        self.ui.uninstall_btn.setEnabled(False)
+        self.ui.exit_btn.setEnabled(False)
+        
         self.start_logo_animations()
 
     def clear_animations(self):

source/core/cloudflare_optimizer.py

@@ -0,0 +1,401 @@
+import os
+from urllib.parse import urlparse
+from PySide6 import QtWidgets
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtGui import QIcon, QPixmap
+
+from utils import msgbox_frame, resource_path
+from workers import IpOptimizerThread
+
+
+class CloudflareOptimizer:
+    """Cloudflare IP优化器，负责处理IP优化和Cloudflare加速相关功能"""
+    
+    def __init__(self, main_window, hosts_manager):
+        """初始化Cloudflare优化器
+        
+        Args:
+            main_window: 主窗口实例，用于访问UI和状态
+            hosts_manager: Hosts文件管理器实例
+        """
+        self.main_window = main_window
+        self.hosts_manager = hosts_manager
+        self.optimized_ip = None
+        self.optimized_ipv6 = None
+        self.optimization_done = False  # 标记是否已执行过优选
+        self.countdown_finished = False # 标记倒计时是否结束
+        self.optimizing_msg_box = None
+        self.optimization_cancelled = False
+        self.ip_optimizer_thread = None
+        self.ipv6_optimizer_thread = None
+        
+    def is_optimization_done(self):
+        """检查是否已完成优化
+        
+        Returns:
+            bool: 是否已完成优化
+        """
+        return self.optimization_done
+    
+    def is_countdown_finished(self):
+        """检查倒计时是否已完成
+        
+        Returns:
+            bool: 倒计时是否已完成
+        """
+        return self.countdown_finished
+        
+    def get_optimized_ip(self):
+        """获取优选的IP地址
+        
+        Returns:
+            str: 优选的IP地址，如果未优选则为None
+        """
+        return self.optimized_ip
+        
+    def get_optimized_ipv6(self):
+        """获取优选的IPv6地址
+        
+        Returns:
+            str: 优选的IPv6地址，如果未优选则为None
+        """
+        return self.optimized_ipv6
+
+    def start_ip_optimization(self, url):
+        """开始IP优化过程
+        
+        Args:
+            url: 用于优化的URL
+        """
+        # 创建取消状态标记
+        self.optimization_cancelled = False
+        self.countdown_finished = False
+        
+        # 检查是否启用了IPv6
+        use_ipv6 = False
+        if hasattr(self.main_window, 'config'):
+            use_ipv6 = self.main_window.config.get("ipv6_enabled", False)
+        
+        # 如果启用了IPv6，显示警告消息
+        if use_ipv6:
+            ipv6_warning = QtWidgets.QMessageBox(self.main_window)
+            ipv6_warning.setWindowTitle(f"IPv6优选警告 - {self.main_window.APP_NAME}")
+            ipv6_warning.setText("\nIPv6优选比IPv4耗时更长且感知不强（预计耗时10分钟以上），不建议使用。\n\n确定要同时执行IPv6优选吗？\n")
+            ipv6_warning.setIcon(QtWidgets.QMessageBox.Icon.Warning)
+            
+            # 设置图标
+            icon_path = resource_path(os.path.join("IMG", "ICO", "icon.png"))
+            if os.path.exists(icon_path):
+                pixmap = QPixmap(icon_path)
+                if not pixmap.isNull():
+                    ipv6_warning.setWindowIcon(QIcon(pixmap))
+            
+            yes_button = ipv6_warning.addButton("是", QtWidgets.QMessageBox.ButtonRole.YesRole)
+            no_button = ipv6_warning.addButton("否，仅使用IPv4", QtWidgets.QMessageBox.ButtonRole.NoRole)
+            cancel_button = ipv6_warning.addButton("取消优选", QtWidgets.QMessageBox.ButtonRole.RejectRole)
+            
+            ipv6_warning.setDefaultButton(no_button)
+            ipv6_warning.exec()
+            
+            if ipv6_warning.clickedButton() == cancel_button:
+                # 用户取消了优选
+                self.optimization_cancelled = True
+                return
+                
+            # 根据用户选择调整IPv6设置
+            if ipv6_warning.clickedButton() == no_button:
+                use_ipv6 = False
+                # 临时覆盖配置（不保存到文件）
+                if hasattr(self.main_window, 'config'):
+                    self.main_window.config["ipv6_enabled"] = False
+        
+        # 准备提示信息
+        optimization_msg = "\n正在优选Cloudflare IP，请稍候...\n\n"
+        if use_ipv6:
+            optimization_msg += "已启用IPv6支持，同时进行IPv4和IPv6优选。\n这可能需要10分钟以上，请耐心等待喵~\n"
+        else:
+            optimization_msg += "这可能需要5-10分钟，请耐心等待喵~\n"
+            
+        # 使用Cloudflare图标创建消息框
+        self.optimizing_msg_box = msgbox_frame(
+            f"通知 - {self.main_window.APP_NAME}",
+            optimization_msg
+        )
+        # 设置Cloudflare图标
+        cf_icon_path = resource_path("IMG/ICO/cloudflare_logo_icon.ico")
+        if os.path.exists(cf_icon_path):
+            cf_pixmap = QPixmap(cf_icon_path)
+            if not cf_pixmap.isNull():
+                self.optimizing_msg_box.setWindowIcon(QIcon(cf_pixmap))
+                self.optimizing_msg_box.setIconPixmap(cf_pixmap.scaled(64, 64, Qt.AspectRatioMode.KeepAspectRatio, 
+                                                             Qt.TransformationMode.SmoothTransformation))
+        
+        # 添加取消按钮
+        self.optimizing_msg_box.setStandardButtons(QtWidgets.QMessageBox.StandardButton.Cancel)
+        self.optimizing_msg_box.buttonClicked.connect(self._on_optimization_dialog_clicked)
+        self.optimizing_msg_box.setWindowModality(Qt.WindowModality.ApplicationModal)
+        
+        # 创建并启动优化线程
+        self.ip_optimizer_thread = IpOptimizerThread(url)
+        self.ip_optimizer_thread.finished.connect(self.on_ipv4_optimization_finished)
+        
+        # 如果启用IPv6，同时启动IPv6优化线程
+        if use_ipv6:
+            print("IPv6已启用，将同时优选IPv6地址")
+            self.ipv6_optimizer_thread = IpOptimizerThread(url, use_ipv6=True)
+            self.ipv6_optimizer_thread.finished.connect(self.on_ipv6_optimization_finished)
+            self.ipv6_optimizer_thread.start()
+            
+        # 启动IPv4优化线程
+        self.ip_optimizer_thread.start()
+        
+        # 显示消息框（非模态，不阻塞）
+        self.optimizing_msg_box.open()
+        
+    def _on_optimization_dialog_clicked(self, button):
+        """处理优化对话框按钮点击
+        
+        Args:
+            button: 被点击的按钮
+        """
+        if button.text() == "Cancel":  # 如果是取消按钮
+            # 标记已取消
+            self.optimization_cancelled = True
+            
+            # 停止优化线程
+            if hasattr(self, 'ip_optimizer_thread') and self.ip_optimizer_thread and self.ip_optimizer_thread.isRunning():
+                self.ip_optimizer_thread.stop()
+                
+            if hasattr(self, 'ipv6_optimizer_thread') and self.ipv6_optimizer_thread and self.ipv6_optimizer_thread.isRunning():
+                self.ipv6_optimizer_thread.stop()
+                
+            # 恢复主窗口状态
+            self.main_window.setEnabled(True)
+            self.main_window.ui.start_install_text.setText("开始安装")
+            
+            # 显示取消消息
+            QtWidgets.QMessageBox.information(
+                self.main_window,
+                f"已取消 - {self.main_window.APP_NAME}",
+                "\n已取消IP优选和安装过程。\n"
+            )
+            
+    def on_ipv4_optimization_finished(self, ip):
+        """IPv4优化完成后的处理
+        
+        Args:
+            ip: 优选的IP地址，如果失败则为空字符串
+        """
+        # 如果已经取消，则不继续处理
+        if hasattr(self, 'optimization_cancelled') and self.optimization_cancelled:
+            return
+            
+        self.optimized_ip = ip
+        print(f"IPv4优选完成，结果: {ip if ip else '未找到合适的IP'}")
+        
+        # 检查是否还有IPv6优化正在运行
+        if hasattr(self, 'ipv6_optimizer_thread') and self.ipv6_optimizer_thread and self.ipv6_optimizer_thread.isRunning():
+            print("等待IPv6优选完成...")
+            return
+        
+        # 所有优选都已完成，继续处理
+        self.optimization_done = True
+        self.countdown_finished = False  # 确保倒计时标志重置
+        
+        # 关闭提示框
+        if hasattr(self, 'optimizing_msg_box') and self.optimizing_msg_box:
+            if self.optimizing_msg_box.isVisible():
+                self.optimizing_msg_box.accept()
+            self.optimizing_msg_box = None
+        
+        # 处理优选结果
+        self._process_optimization_results()
+            
+    def on_ipv6_optimization_finished(self, ipv6):
+        """IPv6优化完成后的处理
+        
+        Args:
+            ipv6: 优选的IPv6地址，如果失败则为空字符串
+        """
+        # 如果已经取消，则不继续处理
+        if hasattr(self, 'optimization_cancelled') and self.optimization_cancelled:
+            return
+            
+        self.optimized_ipv6 = ipv6
+        print(f"IPv6优选完成，结果: {ipv6 if ipv6 else '未找到合适的IPv6'}")
+        
+        # 检查IPv4优化是否已完成
+        if hasattr(self, 'ip_optimizer_thread') and self.ip_optimizer_thread and self.ip_optimizer_thread.isRunning():
+            print("等待IPv4优选完成...")
+            return
+            
+        # 所有优选都已完成，继续处理
+        self.optimization_done = True
+        self.countdown_finished = False  # 确保倒计时标志重置
+        
+        # 关闭提示框
+        if hasattr(self, 'optimizing_msg_box') and self.optimizing_msg_box:
+            if self.optimizing_msg_box.isVisible():
+                self.optimizing_msg_box.accept()
+            self.optimizing_msg_box = None
+        
+        # 处理优选结果
+        self._process_optimization_results()
+    
+    def _process_optimization_results(self):
+        """处理优选的IP结果，显示相应提示"""
+        use_ipv6 = False
+        if hasattr(self.main_window, 'config'):
+            use_ipv6 = self.main_window.config.get("ipv6_enabled", False)
+            
+        # 判断优选结果
+        ipv4_success = bool(self.optimized_ip)
+        ipv6_success = bool(self.optimized_ipv6) if use_ipv6 else False
+        
+        # 临时启用窗口以显示对话框
+        self.main_window.setEnabled(True)
+        
+        hostname = urlparse(self.main_window.current_url).hostname if hasattr(self.main_window, 'current_url') else None
+        
+        if not ipv4_success and (not use_ipv6 or not ipv6_success):
+            # 两种IP都没有优选成功
+            msg_box = QtWidgets.QMessageBox(self.main_window)
+            msg_box.setWindowTitle(f"优选失败 - {self.main_window.APP_NAME}")
+            
+            fail_message = "\n未能找到合适的Cloudflare "
+            if use_ipv6:
+                fail_message += "IPv4和IPv6地址"
+            else:
+                fail_message += "IP地址"
+                
+            fail_message += "，将使用默认网络进行下载。\n\n10秒后自动继续..."
+            
+            msg_box.setText(fail_message)
+            msg_box.setIcon(QtWidgets.QMessageBox.Icon.Warning)
+            ok_button = msg_box.addButton("确定 (10)", QtWidgets.QMessageBox.ButtonRole.AcceptRole)
+            cancel_button = msg_box.addButton("取消安装", QtWidgets.QMessageBox.ButtonRole.RejectRole)
+            
+            # 创建计时器实现倒计时
+            countdown = 10
+            timer = QTimer(self.main_window)
+            
+            def update_countdown():
+                nonlocal countdown
+                countdown -= 1
+                ok_button.setText(f"确定 ({countdown})")
+                if countdown <= 0:
+                    timer.stop()
+                    if msg_box.isVisible():
+                        msg_box.accept()
+            
+            timer.timeout.connect(update_countdown)
+            timer.start(1000)  # 每秒更新一次
+            
+            # 显示对话框并等待用户响应
+            result = msg_box.exec()
+            
+            # 停止计时器
+            timer.stop()
+            
+            # 如果用户点击了取消安装
+            if msg_box.clickedButton() == cancel_button:
+                # 恢复主窗口状态
+                self.main_window.setEnabled(True)
+                self.main_window.ui.start_install_text.setText("开始安装")
+                return False
+                
+            # 用户点击了继续，重新禁用主窗口
+            self.main_window.setEnabled(False)
+            # 标记倒计时已完成
+            self.countdown_finished = True
+            return True
+        else:
+            # 至少有一种IP优选成功
+            success_message = ""
+            if ipv4_success:
+                success_message += f"IPv4: {self.optimized_ip}\n"
+                
+            if ipv6_success:
+                success_message += f"IPv6: {self.optimized_ipv6}\n"
+                
+            if hostname:
+                # 先清理可能存在的旧记录（只清理一次）
+                self.hosts_manager.clean_hostname_entries(hostname)
+                
+                success = False
+                
+                # 应用优选IP到hosts文件
+                if ipv4_success:
+                    success = self.hosts_manager.apply_ip(hostname, self.optimized_ip, clean=False) or success
+                    
+                # 如果启用IPv6并且找到了IPv6地址，也应用到hosts
+                if ipv6_success:
+                    success = self.hosts_manager.apply_ip(hostname, self.optimized_ipv6, clean=False) or success
+                
+                if success:
+                    msg_box = QtWidgets.QMessageBox(self.main_window)
+                    msg_box.setWindowTitle(f"成功 - {self.main_window.APP_NAME}")
+                    msg_box.setText(f"\n已将优选IP应用到hosts文件：\n{success_message}\n10秒后自动继续...")
+                    msg_box.setIcon(QtWidgets.QMessageBox.Icon.Information)
+                    ok_button = msg_box.addButton("确定 (10)", QtWidgets.QMessageBox.ButtonRole.AcceptRole)
+                    cancel_button = msg_box.addButton("取消安装", QtWidgets.QMessageBox.ButtonRole.RejectRole)
+                    
+                    # 创建计时器实现倒计时
+                    countdown = 10
+                    timer = QTimer(self.main_window)
+                    
+                    def update_countdown():
+                        nonlocal countdown
+                        countdown -= 1
+                        ok_button.setText(f"确定 ({countdown})")
+                        if countdown <= 0:
+                            timer.stop()
+                            if msg_box.isVisible():
+                                msg_box.accept()
+                    
+                    timer.timeout.connect(update_countdown)
+                    timer.start(1000)  # 每秒更新一次
+                    
+                    # 显示对话框并等待用户响应
+                    result = msg_box.exec()
+                    
+                    # 停止计时器
+                    timer.stop()
+                    
+                    # 如果用户点击了取消安装
+                    if msg_box.clickedButton() == cancel_button:
+                        # 恢复主窗口状态
+                        self.main_window.setEnabled(True)
+                        self.main_window.ui.start_install_text.setText("开始安装")
+                        return False
+                else:
+                    QtWidgets.QMessageBox.critical(
+                        self.main_window, 
+                        f"错误 - {self.main_window.APP_NAME}", 
+                        "\n修改hosts文件失败，请检查程序是否以管理员权限运行。\n"
+                    )
+                    # 恢复主窗口状态
+                    self.main_window.ui.start_install_text.setText("开始安装")
+                    return False
+                
+                # 用户点击了继续，重新禁用主窗口
+                self.main_window.setEnabled(False)
+                # 标记倒计时已完成
+                self.countdown_finished = True
+                
+            return True
+            
+    def stop_optimization(self):
+        """停止正在进行的IP优化"""
+        if hasattr(self, 'ip_optimizer_thread') and self.ip_optimizer_thread and self.ip_optimizer_thread.isRunning():
+            self.ip_optimizer_thread.stop()
+            self.ip_optimizer_thread.wait()
+            
+        if hasattr(self, 'ipv6_optimizer_thread') and self.ipv6_optimizer_thread and self.ipv6_optimizer_thread.isRunning():
+            self.ipv6_optimizer_thread.stop()
+            self.ipv6_optimizer_thread.wait()
+            
+        if hasattr(self, 'optimizing_msg_box') and self.optimizing_msg_box:
+            if self.optimizing_msg_box.isVisible():
+                self.optimizing_msg_box.accept()
+            self.optimizing_msg_box = None 

source/core/config_manager.py

@@ -0,0 +1,169 @@
+import json
+import webbrowser
+from PySide6.QtWidgets import QMessageBox
+
+from utils import load_config, save_config, msgbox_frame
+
+class ConfigManager:
+    """配置管理器，用于处理配置的加载、保存和获取云端配置"""
+    
+    def __init__(self, app_name, config_url, ua, debug_manager=None):
+        """初始化配置管理器
+        
+        Args:
+            app_name: 应用程序名称，用于显示消息框标题
+            config_url: 云端配置URL
+            ua: User-Agent字符串
+            debug_manager: 调试管理器实例，用于输出调试信息
+        """
+        self.app_name = app_name
+        self.config_url = config_url
+        self.ua = ua
+        self.debug_manager = debug_manager
+        self.cloud_config = None
+        self.config_valid = False
+        self.last_error_message = ""
+        
+    def _is_debug_mode(self):
+        """检查是否处于调试模式
+        
+        Returns:
+            bool: 是否处于调试模式
+        """
+        if hasattr(self.debug_manager, 'ui_manager') and hasattr(self.debug_manager.ui_manager, 'debug_action'):
+            return self.debug_manager.ui_manager.debug_action.isChecked()
+        return False
+    
+    def load_config(self):
+        """加载本地配置
+        
+        Returns:
+            dict: 加载的配置
+        """
+        return load_config()
+    
+    def save_config(self, config):
+        """保存配置
+        
+        Args:
+            config: 要保存的配置
+        """
+        save_config(config)
+    
+    def fetch_cloud_config(self, config_fetch_thread_class, callback=None):
+        """获取云端配置
+        
+        Args:
+            config_fetch_thread_class: 用于获取云端配置的线程类
+            callback: 获取完成后的回调函数，接受两个参数(data, error_message)
+        """
+        headers = {"User-Agent": self.ua}
+        debug_mode = self._is_debug_mode()
+        self.config_fetch_thread = config_fetch_thread_class(self.config_url, headers, debug_mode)
+        
+        # 如果提供了回调，使用它；否则使用内部的on_config_fetched方法
+        if callback:
+            self.config_fetch_thread.finished.connect(callback)
+        else:
+            self.config_fetch_thread.finished.connect(self.on_config_fetched)
+            
+        self.config_fetch_thread.start()
+    
+    def on_config_fetched(self, data, error_message):
+        """云端配置获取完成的回调处理
+        
+        Args:
+            data: 获取到的配置数据
+            error_message: 错误信息，如果有
+        """
+        debug_mode = self._is_debug_mode()
+        
+        if error_message:
+            # 标记配置无效
+            self.config_valid = False
+            
+            # 记录错误信息，用于按钮点击时显示
+            if error_message == "update_required":
+                self.last_error_message = "update_required"
+                msg_box = msgbox_frame(
+                    f"更新提示 - {self.app_name}",
+                    "\n当前版本过低，请及时更新。\n",
+                    QMessageBox.StandardButton.Ok,
+                )
+                msg_box.exec()
+                # 在浏览器中打开项目主页
+                webbrowser.open("https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/")
+                # 版本过低，应当显示"无法安装"
+                return {"action": "disable_button", "then": "exit"}
+                
+            elif "missing_keys" in error_message:
+                self.last_error_message = "missing_keys"
+                missing_versions = error_message.split(":")[1]
+                msg_box = msgbox_frame(
+                    f"配置缺失 - {self.app_name}",
+                    f'\n云端缺失下载链接，可能云服务器正在维护，不影响其他版本下载。\n当前缺失版本:"{missing_versions}"\n',
+                    QMessageBox.StandardButton.Ok,
+                )
+                msg_box.exec()
+                # 对于部分缺失，仍然允许使用，因为可能只影响部分游戏版本
+                self.config_valid = True
+                return {"action": "enable_button"}
+            else:
+                # 设置网络错误标记
+                self.last_error_message = "network_error"
+                
+                # 显示通用错误消息，只在debug模式下显示详细错误
+                error_msg = "访问云端配置失败，请检查网络状况或稍后再试。"
+                if debug_mode and "详细错误:" in error_message:
+                    msg_box = msgbox_frame(
+                        f"错误 - {self.app_name}",
+                        f"\n{error_message}\n",
+                        QMessageBox.StandardButton.Ok,
+                    )
+                else:
+                    msg_box = msgbox_frame(
+                        f"错误 - {self.app_name}",
+                        f"\n{error_msg}\n",
+                        QMessageBox.StandardButton.Ok,
+                    )
+                msg_box.exec()
+                
+                # 网络错误时应当显示"无法安装"
+                return {"action": "disable_button"}
+        else:
+            self.cloud_config = data
+            # 标记配置有效
+            self.config_valid = True
+            # 清除错误信息
+            self.last_error_message = ""
+            
+            if debug_mode:
+                print("--- Cloud config fetched successfully ---")
+                print(json.dumps(data, indent=2))
+                
+            # 获取配置成功，允许安装
+            return {"action": "enable_button"}
+    
+    def is_config_valid(self):
+        """检查配置是否有效
+        
+        Returns:
+            bool: 配置是否有效
+        """
+        return self.config_valid
+    
+    def get_cloud_config(self):
+        """获取云端配置
+        
+        Returns:
+            dict: 云端配置
+        """
+        return self.cloud_config
+    
+    def get_last_error(self):
+        """获取最后一次错误信息
+        
+        Returns:
+            str: 错误信息
+        """
+        return self.last_error_message 

source/core/debug_manager.py

@@ -15,6 +15,25 @@ class DebugManager:
         self.logger = None
         self.original_stdout = None
         self.original_stderr = None
+        self.ui_manager = None  # 添加ui_manager属性
+    
+    def set_ui_manager(self, ui_manager):
+        """设置UI管理器引用
+        
+        Args:
+            ui_manager: UI管理器实例
+        """
+        self.ui_manager = ui_manager
+    
+    def _is_debug_mode(self):
+        """检查是否处于调试模式
+        
+        Returns:
+            bool: 是否处于调试模式
+        """
+        if hasattr(self, 'ui_manager') and hasattr(self.ui_manager, 'debug_action'):
+            return self.ui_manager.debug_action.isChecked()
+        return False
     
     def toggle_debug_mode(self, checked):
         """切换调试模式
@@ -22,8 +41,14 @@ class DebugManager:
         Args:
             checked: 是否启用调试模式
         """
+        print(f"Toggle debug mode: {checked}")
         self.main_window.config["debug_mode"] = checked
         self.main_window.save_config(self.main_window.config)
+        
+        # 更新打开log文件按钮状态
+        if hasattr(self, 'ui_manager') and hasattr(self.ui_manager, 'open_log_action'):
+            self.ui_manager.open_log_action.setEnabled(checked)
+            
         if checked:
             self.start_logging()
         else:

source/core/download_manager.py

@@ -7,11 +7,14 @@ import re # Added for recursive search
 
 from PySide6 import QtWidgets, QtCore
 from PySide6.QtCore import Qt
-from PySide6.QtGui import QIcon, QPixmap
+from PySide6.QtGui import QIcon, QPixmap, QFont
 
 from utils import msgbox_frame, HostsManager, resource_path
-from data.config import APP_NAME, PLUGIN, GAME_INFO, UA, CONFIG_URL
+from data.config import APP_NAME, PLUGIN, GAME_INFO, UA, CONFIG_URL, DOWNLOAD_THREADS, DEFAULT_DOWNLOAD_THREAD_LEVEL
 from workers import IpOptimizerThread
+from core.cloudflare_optimizer import CloudflareOptimizer
+from core.download_task_manager import DownloadTaskManager
+from core.extraction_handler import ExtractionHandler
 
 class DownloadManager:
     def __init__(self, main_window):
@@ -21,14 +24,20 @@ class DownloadManager:
             main_window: 主窗口实例，用于访问UI和状态
         """
         self.main_window = main_window
+        self.main_window.APP_NAME = APP_NAME  # 为了让子模块能够访问APP_NAME
         self.selected_folder = ""
         self.download_queue = deque()
         self.current_download_thread = None
         self.hosts_manager = HostsManager()
-        self.optimized_ip = None
-        self.optimization_done = False # 标记是否已执行过优选
-        self.optimizing_msg_box = None
-    
+        
+        # 添加下载线程级别
+        self.download_thread_level = DEFAULT_DOWNLOAD_THREAD_LEVEL
+        
+        # 初始化子模块
+        self.cloudflare_optimizer = CloudflareOptimizer(main_window, self.hosts_manager)
+        self.download_task_manager = DownloadTaskManager(main_window, self.download_thread_level)
+        self.extraction_handler = ExtractionHandler(main_window)
+        
     def file_dialog(self):
         """显示文件夹选择对话框，选择游戏安装目录"""
         self.selected_folder = QtWidgets.QFileDialog.getExistingDirectory(
@@ -39,12 +48,19 @@ class DownloadManager:
                 self.main_window, f"通知 - {APP_NAME}", "\n未选择任何目录,请重新选择\n"
             )
             return
+        
+        # 将按钮文本设为安装中状态
+        self.main_window.ui.start_install_text.setText("正在安装")
+        
+        # 禁用整个主窗口，防止用户操作
+        self.main_window.setEnabled(False)
+        
         self.download_action()
 
     def get_install_paths(self):
         """获取所有游戏版本的安装路径"""
         # 使用改进的目录识别功能
-        game_dirs = self.main_window.identify_game_directories_improved(self.selected_folder)
+        game_dirs = self.main_window.game_detector.identify_game_directories_improved(self.selected_folder)
         install_paths = {}
         
         debug_mode = self.is_debug_mode()
@@ -58,12 +74,6 @@ class DownloadManager:
                 if debug_mode:
                     print(f"DEBUG: 使用识别到的游戏目录 {game}: {game_dir}")
                     print(f"DEBUG: 安装路径设置为: {install_path}")
-            else:
-                # 回退到原始路径计算方式
-                install_path = os.path.join(self.selected_folder, info["install_path"])
-                install_paths[game] = install_path
-                if debug_mode:
-                    print(f"DEBUG: 未识别到游戏目录 {game}, 使用默认路径: {install_path}")
                     
         return install_paths
 
@@ -159,14 +169,13 @@ class DownloadManager:
 
     def download_action(self):
         """开始下载流程"""
-        # 禁用开始安装按钮
-        self.main_window.set_start_button_enabled(False)
+        # 主窗口在file_dialog中已被禁用
         
         # 清空下载历史记录
         self.main_window.download_queue_history = []
         
         # 使用改进的目录识别功能
-        game_dirs = self.main_window.identify_game_directories_improved(self.selected_folder)
+        game_dirs = self.main_window.game_detector.identify_game_directories_improved(self.selected_folder)
         
         debug_mode = self.is_debug_mode()
         if debug_mode:
@@ -183,28 +192,141 @@ class DownloadManager:
                 f"目录错误 - {APP_NAME}", 
                 "\n未能识别到任何游戏目录。\n\n请确认您选择的是游戏的上级目录，并且该目录中包含NEKOPARA系列游戏文件夹。\n"
             )
+            # 恢复主窗口
+            self.main_window.setEnabled(True)
+            self.main_window.ui.start_install_text.setText("开始安装")
             return
-        
+            
         # 显示哈希检查窗口
         self.main_window.hash_msg_box = self.main_window.hash_manager.hash_pop_window(check_type="pre")
 
-        # 执行预检查
+        # 执行预检查，先判断哪些游戏版本已安装了补丁
         install_paths = self.get_install_paths()
         
         self.main_window.hash_thread = self.main_window.create_hash_thread("pre", install_paths)
-        self.main_window.hash_thread.pre_finished.connect(self.on_pre_hash_finished)
+        # 使用lambda连接，传递game_dirs参数
+        self.main_window.hash_thread.pre_finished.connect(
+            lambda updated_status: self.on_pre_hash_finished_with_dirs(updated_status, game_dirs)
+        )
         self.main_window.hash_thread.start()
-    
-    def on_pre_hash_finished(self, updated_status):
-        """哈希预检查完成后的处理
+        
+    def on_pre_hash_finished_with_dirs(self, updated_status, game_dirs):
+        """优化的哈希预检查完成处理，带有游戏目录信息
         
         Args:
             updated_status: 更新后的安装状态
+            game_dirs: 识别到的游戏目录
         """
         self.main_window.installed_status = updated_status
         if self.main_window.hash_msg_box and self.main_window.hash_msg_box.isVisible():
             self.main_window.hash_msg_box.accept()
             self.main_window.hash_msg_box = None
+            
+        debug_mode = self.is_debug_mode()
+        
+        # 临时启用窗口以显示选择对话框
+        self.main_window.setEnabled(True)
+        
+        # 获取可安装的游戏版本列表（尚未安装补丁的版本）
+        installable_games = []
+        already_installed_games = []
+        for game_version, game_dir in game_dirs.items():
+            if self.main_window.installed_status.get(game_version, False):
+                if debug_mode:
+                    print(f"DEBUG: {game_version} 已安装补丁，不需要再次安装")
+                already_installed_games.append(game_version)
+            else:
+                if debug_mode:
+                    print(f"DEBUG: {game_version} 未安装补丁，可以安装")
+                installable_games.append(game_version)
+        
+        # 显示状态消息
+        status_message = ""
+        if already_installed_games:
+            status_message += f"已安装补丁的游戏：\n{chr(10).join(already_installed_games)}\n\n"
+            
+        if not installable_games:
+            # 如果没有可安装的游戏
+            QtWidgets.QMessageBox.information(
+                self.main_window, 
+                f"信息 - {APP_NAME}", 
+                f"\n所有检测到的游戏都已安装补丁。\n\n{status_message}"
+            )
+            # 恢复主窗口
+            self.main_window.setEnabled(True)
+            self.main_window.ui.start_install_text.setText("开始安装")
+            return
+            
+        # 如果有可安装的游戏版本，让用户选择
+        from PySide6.QtWidgets import QInputDialog, QListWidget, QVBoxLayout, QDialog, QLabel, QPushButton, QAbstractItemView, QHBoxLayout
+        
+        # 创建自定义选择对话框
+        dialog = QDialog(self.main_window)
+        dialog.setWindowTitle("选择要安装的游戏")
+        dialog.resize(400, 300)
+        
+        layout = QVBoxLayout(dialog)
+        
+        # 先显示已安装补丁的游戏
+        if already_installed_games:
+            already_installed_label = QLabel("已安装补丁的游戏:", dialog)
+            already_installed_label.setFont(QFont(already_installed_label.font().family(), already_installed_label.font().pointSize(), QFont.Bold))
+            layout.addWidget(already_installed_label)
+            
+            already_installed_list = QLabel(chr(10).join(already_installed_games), dialog)
+            layout.addWidget(already_installed_list)
+            
+            # 添加一些间距
+            layout.addSpacing(10)
+        
+        # 添加"请选择你需要安装补丁的游戏"的标签
+        info_label = QLabel("请选择你需要安装补丁的游戏:", dialog)
+        info_label.setFont(QFont(info_label.font().family(), info_label.font().pointSize(), QFont.Bold))
+        layout.addWidget(info_label)
+        
+        # 添加列表控件
+        list_widget = QListWidget(dialog)
+        list_widget.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)  # 允许多选
+        for game in installable_games:
+            list_widget.addItem(game)
+        layout.addWidget(list_widget)
+        
+        # 添加全选按钮
+        select_all_btn = QPushButton("全选", dialog)
+        select_all_btn.clicked.connect(lambda: list_widget.selectAll())
+        layout.addWidget(select_all_btn)
+        
+        # 添加确定和取消按钮
+        buttons_layout = QHBoxLayout()
+        ok_button = QPushButton("确定", dialog)
+        cancel_button = QPushButton("取消", dialog)
+        buttons_layout.addWidget(ok_button)
+        buttons_layout.addWidget(cancel_button)
+        layout.addLayout(buttons_layout)
+        
+        # 连接按钮事件
+        ok_button.clicked.connect(dialog.accept)
+        cancel_button.clicked.connect(dialog.reject)
+        
+        # 显示对话框并等待用户选择
+        result = dialog.exec()
+        
+        if result != QDialog.DialogCode.Accepted or list_widget.selectedItems() == []:
+            # 用户取消或未选择任何游戏
+            self.main_window.setEnabled(True)
+            self.main_window.ui.start_install_text.setText("开始安装")
+            return
+            
+        # 获取用户选择的游戏
+        selected_games = [item.text() for item in list_widget.selectedItems()]
+        if debug_mode:
+            print(f"DEBUG: 用户选择了以下游戏进行安装: {selected_games}")
+            
+        # 过滤game_dirs，只保留选中的游戏
+        selected_game_dirs = {game: game_dirs[game] for game in selected_games if game in game_dirs}
+        
+        # 重新禁用窗口
+        self.main_window.setEnabled(False)
 
         # 获取下载配置
         config = self.get_download_url()
@@ -212,20 +334,81 @@ class DownloadManager:
             QtWidgets.QMessageBox.critical(
                 self.main_window, f"错误 - {APP_NAME}", "\n网络状态异常或服务器故障，请重试\n"
             )
-            # 重新启用开始安装按钮
-            self.main_window.set_start_button_enabled(True)
+            # 网络故障时，恢复主窗口
+            self.main_window.setEnabled(True)
+            self.main_window.ui.start_install_text.setText("开始安装")
             return
 
-        # 填充下载队列
-        self._fill_download_queue(config)
+        # 填充下载队列，传入选定的游戏目录
+        self._fill_download_queue(config, selected_game_dirs)
 
         # 如果没有需要下载的内容，直接进行最终校验
         if not self.download_queue:
             self.main_window.after_hash_compare()
             return
         
-        # 只有当有需要下载内容时才询问是否使用Cloudflare加速
-        # 询问用户是否使用Cloudflare加速
+        # 询问是否使用Cloudflare加速
+        self._show_cloudflare_option()
+
+    def _fill_download_queue(self, config, game_dirs):
+        """填充下载队列
+        
+        Args:
+            config: 包含下载URL的配置字典
+            game_dirs: 包含游戏文件夹路径的字典
+        """
+        # 清空现有队列
+        self.download_queue.clear()
+        
+        # 创建下载历史记录列表，用于跟踪本次安装的游戏
+        if not hasattr(self.main_window, 'download_queue_history'):
+            self.main_window.download_queue_history = []
+        
+        debug_mode = self.is_debug_mode()
+        if debug_mode:
+            print(f"DEBUG: 填充下载队列, 游戏目录: {game_dirs}")
+        
+        # 添加nekopara 1-4
+        for i in range(1, 5):
+            game_version = f"NEKOPARA Vol.{i}"
+            # 只处理game_dirs中包含的游戏版本(如果用户选择了特定版本)
+            if game_version in game_dirs and not self.main_window.installed_status.get(game_version, False):
+                url = config.get(f"vol{i}")
+                if not url: continue
+                
+                # 获取识别到的游戏文件夹路径
+                game_folder = game_dirs[game_version]
+                if debug_mode:
+                    print(f"DEBUG: 使用识别到的游戏目录 {game_version}: {game_folder}")
+                
+                _7z_path = os.path.join(PLUGIN, f"vol.{i}.7z")
+                plugin_path = os.path.join(PLUGIN, GAME_INFO[game_version]["plugin_path"])
+                self.download_queue.append((url, game_folder, game_version, _7z_path, plugin_path))
+                # 记录到下载历史
+                self.main_window.download_queue_history.append(game_version)
+
+        # 添加nekopara after
+        game_version = "NEKOPARA After"
+        # 只处理game_dirs中包含的游戏版本(如果用户选择了特定版本)
+        if game_version in game_dirs and not self.main_window.installed_status.get(game_version, False):
+            url = config.get("after")
+            if url:
+                # 获取识别到的游戏文件夹路径
+                game_folder = game_dirs[game_version]
+                if debug_mode:
+                    print(f"DEBUG: 使用识别到的游戏目录 {game_version}: {game_folder}")
+                
+                _7z_path = os.path.join(PLUGIN, "after.7z")
+                plugin_path = os.path.join(PLUGIN, GAME_INFO[game_version]["plugin_path"])
+                self.download_queue.append((url, game_folder, game_version, _7z_path, plugin_path))
+                # 记录到下载历史
+                self.main_window.download_queue_history.append(game_version)
+                
+    def _show_cloudflare_option(self):
+        """显示Cloudflare加速选择对话框"""
+        # 临时启用窗口以显示对话框
+        self.main_window.setEnabled(True)
+        
         msg_box = QtWidgets.QMessageBox(self.main_window)
         msg_box.setWindowTitle(f"下载优化 - {APP_NAME}")
         msg_box.setText("是否愿意通过Cloudflare加速来优化下载速度？\n\n这将临时修改系统的hosts文件，并需要管理员权限。\n如您的杀毒软件提醒有软件正在修改hosts文件，请注意放行。")
@@ -243,208 +426,45 @@ class DownloadManager:
         
         yes_button = msg_box.addButton("是，开启加速", QtWidgets.QMessageBox.ButtonRole.YesRole)
         no_button = msg_box.addButton("否，直接下载", QtWidgets.QMessageBox.ButtonRole.NoRole)
+        cancel_button = msg_box.addButton("取消安装", QtWidgets.QMessageBox.ButtonRole.RejectRole)
         
         msg_box.exec()
         
-        use_optimization = msg_box.clickedButton() == yes_button
-
-        if use_optimization and not self.optimization_done:
+        clicked_button = msg_box.clickedButton()
+        if clicked_button == cancel_button:
+            # 用户取消了安装，保持主窗口启用
+            self.main_window.setEnabled(True)
+            self.main_window.ui.start_install_text.setText("开始安装")
+            self.download_queue.clear()  # 清空下载队列
+            return
+        
+        # 用户点击了继续按钮，重新禁用主窗口
+        self.main_window.setEnabled(False)
+        
+        use_optimization = clicked_button == yes_button
+        
+        if use_optimization and not self.cloudflare_optimizer.is_optimization_done():
             first_url = self.download_queue[0][0]
-            self._start_ip_optimization(first_url)
+            # 保存当前URL供CloudflareOptimizer使用
+            self.main_window.current_url = first_url
+            # 使用CloudflareOptimizer进行IP优化
+            self.cloudflare_optimizer.start_ip_optimization(first_url)
+            # 等待CloudflareOptimizer的回调
+            # on_optimization_finished会被调用，然后决定是否继续
+            QtCore.QTimer.singleShot(100, self.check_optimization_status)
         else:
             # 如果用户选择不优化，或已经优化过，直接开始下载
             self.next_download_task()
     
-    def _fill_download_queue(self, config):
-        """填充下载队列
-        
-        Args:
-            config: 包含下载URL的配置字典
-        """
-        # 清空现有队列
-        self.download_queue.clear()
-        
-        # 创建下载历史记录列表，用于跟踪本次安装的游戏
-        if not hasattr(self.main_window, 'download_queue_history'):
-            self.main_window.download_queue_history = []
-            
-        # 获取所有识别到的游戏目录
-        game_dirs = self.main_window.identify_game_directories_improved(self.selected_folder)
-        
-        debug_mode = self.is_debug_mode()
-        if debug_mode:
-            print(f"DEBUG: 填充下载队列, 识别到的游戏目录: {game_dirs}")
-        
-        # 添加nekopara 1-4
-        for i in range(1, 5):
-            game_version = f"NEKOPARA Vol.{i}"
-            if not self.main_window.installed_status.get(game_version, False):
-                url = config.get(f"vol{i}")
-                if not url: continue
-                
-                # 确定游戏文件夹路径
-                if game_version in game_dirs:
-                    game_folder = game_dirs[game_version]
-                    if debug_mode:
-                        print(f"DEBUG: 使用识别到的游戏目录 {game_version}: {game_folder}")
-                else:
-                    # 回退到传统方式
-                    game_folder = os.path.join(self.selected_folder, f"NEKOPARA Vol. {i}")
-                    if debug_mode:
-                        print(f"DEBUG: 使用默认游戏目录 {game_version}: {game_folder}")
-                
-                _7z_path = os.path.join(PLUGIN, f"vol.{i}.7z")
-                plugin_path = os.path.join(PLUGIN, GAME_INFO[game_version]["plugin_path"])
-                self.download_queue.append((url, game_folder, game_version, _7z_path, plugin_path))
-                # 记录到下载历史
-                self.main_window.download_queue_history.append(game_version)
-
-        # 添加nekopara after
-        game_version = "NEKOPARA After"
-        if not self.main_window.installed_status.get(game_version, False):
-            url = config.get("after")
-            if url:
-                # 确定After的游戏文件夹路径
-                if game_version in game_dirs:
-                    game_folder = game_dirs[game_version]
-                    if debug_mode:
-                        print(f"DEBUG: 使用识别到的游戏目录 {game_version}: {game_folder}")
-                else:
-                    game_folder = os.path.join(self.selected_folder, "NEKOPARA After")
-                    if debug_mode:
-                        print(f"DEBUG: 使用默认游戏目录 {game_version}: {game_folder}")
-                
-                _7z_path = os.path.join(PLUGIN, "after.7z")
-                plugin_path = os.path.join(PLUGIN, GAME_INFO[game_version]["plugin_path"])
-                self.download_queue.append((url, game_folder, game_version, _7z_path, plugin_path))
-                # 记录到下载历史
-                self.main_window.download_queue_history.append(game_version)
-    
-    def _start_ip_optimization(self, url):
-        """开始IP优化过程
-        
-        Args:
-            url: 用于优化的URL
-        """
-        # 禁用退出按钮
-        self.main_window.ui.exit_btn.setEnabled(False)
-        
-        # 使用Cloudflare图标创建消息框
-        
-        self.optimizing_msg_box = msgbox_frame(
-            f"通知 - {APP_NAME}",
-            "\n正在优选Cloudflare IP，请稍候...\n\n这可能需要5-10分钟，请耐心等待喵~"
-        )
-        # 设置Cloudflare图标
-        cf_icon_path = resource_path("IMG/ICO/cloudflare_logo_icon.ico")
-        if os.path.exists(cf_icon_path):
-            cf_pixmap = QPixmap(cf_icon_path)
-            if not cf_pixmap.isNull():
-                self.optimizing_msg_box.setWindowIcon(QIcon(cf_pixmap))
-                self.optimizing_msg_box.setIconPixmap(cf_pixmap.scaled(64, 64, Qt.AspectRatioMode.KeepAspectRatio, 
-                                                                 Qt.TransformationMode.SmoothTransformation))
-        
-        # 我们不再提供"跳过"按钮
-        self.optimizing_msg_box.setStandardButtons(QtWidgets.QMessageBox.StandardButton.NoButton)
-        self.optimizing_msg_box.setWindowModality(Qt.WindowModality.ApplicationModal)
-        self.optimizing_msg_box.open()
-
-        # 创建并启动优化线程
-        self.ip_optimizer_thread = IpOptimizerThread(url)
-        self.ip_optimizer_thread.finished.connect(self.on_optimization_finished)
-        self.ip_optimizer_thread.start()
-    
-    def on_optimization_finished(self, ip):
-        """IP优化完成后的处理
-        
-        Args:
-            ip: 优选的IP地址，如果失败则为空字符串
-        """
-        self.optimized_ip = ip
-        self.optimization_done = True
-        
-        # 关闭提示框
-        if hasattr(self, 'optimizing_msg_box') and self.optimizing_msg_box:
-            if self.optimizing_msg_box.isVisible():
-                self.optimizing_msg_box.accept()
-            self.optimizing_msg_box = None
-
-        # 显示优选结果
-        if not ip:
-            msg_box = QtWidgets.QMessageBox(self.main_window)
-            msg_box.setWindowTitle(f"优选失败 - {APP_NAME}")
-            msg_box.setText("\n未能找到合适的Cloudflare IP，将使用默认网络进行下载。\n\n10秒后自动继续...")
-            msg_box.setIcon(QtWidgets.QMessageBox.Icon.Warning)
-            ok_button = msg_box.addButton("确定 (10)", QtWidgets.QMessageBox.ButtonRole.AcceptRole)
-            
-            # 创建计时器实现倒计时
-            countdown = 10
-            timer = QtCore.QTimer(self.main_window)
-            
-            def update_countdown():
-                nonlocal countdown
-                countdown -= 1
-                ok_button.setText(f"确定 ({countdown})")
-                if countdown <= 0:
-                    timer.stop()
-                    if msg_box.isVisible():
-                        msg_box.accept()
-            
-            timer.timeout.connect(update_countdown)
-            timer.start(1000)  # 每秒更新一次
-            
-            # 显示对话框，但不阻塞主线程
-            msg_box.open()
-            
-            # 连接关闭信号以停止计时器
-            msg_box.finished.connect(timer.stop)
+    def check_optimization_status(self):
+        """检查IP优化状态并继续下载流程"""
+        # 必须同时满足：优化已完成且倒计时已结束
+        if self.cloudflare_optimizer.is_optimization_done() and self.cloudflare_optimizer.is_countdown_finished():
+            self.next_download_task()
         else:
-            # 应用优选IP到hosts文件
-            if self.download_queue:
-                first_url = self.download_queue[0][0]
-                hostname = urlparse(first_url).hostname
-                
-                # 先清理可能存在的旧记录
-                self.hosts_manager.clean_hostname_entries(hostname)
-                
-                if self.hosts_manager.apply_ip(hostname, ip):
-                    msg_box = QtWidgets.QMessageBox(self.main_window)
-                    msg_box.setWindowTitle(f"成功 - {APP_NAME}")
-                    msg_box.setText(f"\n已将优选IP ({ip}) 应用到hosts文件。\n\n10秒后自动继续...")
-                    msg_box.setIcon(QtWidgets.QMessageBox.Icon.Information)
-                    ok_button = msg_box.addButton("确定 (10)", QtWidgets.QMessageBox.ButtonRole.AcceptRole)
-                    
-                    # 创建计时器实现倒计时
-                    countdown = 10
-                    timer = QtCore.QTimer(self.main_window)
-                    
-                    def update_countdown():
-                        nonlocal countdown
-                        countdown -= 1
-                        ok_button.setText(f"确定 ({countdown})")
-                        if countdown <= 0:
-                            timer.stop()
-                            if msg_box.isVisible():
-                                msg_box.accept()
-                    
-                    timer.timeout.connect(update_countdown)
-                    timer.start(1000)  # 每秒更新一次
-                    
-                    # 显示对话框，但不阻塞主线程
-                    msg_box.open()
-                    
-                    # 连接关闭信号以停止计时器
-                    msg_box.finished.connect(timer.stop)
-                else:
-                    QtWidgets.QMessageBox.critical(
-                        self.main_window, 
-                        f"错误 - {APP_NAME}", 
-                        "\n修改hosts文件失败，请检查程序是否以管理员权限运行。\n"
-                    )
-        
-        # 计时器结束或用户点击确定时，继续下载
-        QtCore.QTimer.singleShot(10000, self.next_download_task)
-
+            # 否则，继续等待100ms后再次检查
+            QtCore.QTimer.singleShot(100, self.check_optimization_status)
+                        
     def next_download_task(self):
         """处理下载队列中的下一个任务"""
         if not self.download_queue:
@@ -452,7 +472,7 @@ class DownloadManager:
             return
             
         # 检查下载线程是否仍在运行，以避免在手动停止后立即开始下一个任务
-        if self.current_download_thread and self.current_download_thread.isRunning():
+        if self.download_task_manager.current_download_thread and self.download_task_manager.current_download_thread.isRunning():
             return
         
         # 获取下一个下载任务并开始
@@ -477,89 +497,9 @@ class DownloadManager:
             print(f"DEBUG: 准备下载游戏 {game_version}")
             print(f"DEBUG: 游戏文件夹: {game_folder}")
             
-        # 获取游戏可执行文件路径
-        game_dirs = self.main_window.identify_game_directories_improved(self.selected_folder)
-        game_exe_exists = False
-        
-        if game_version in game_dirs:
-            game_dir = game_dirs[game_version]
-            # 游戏目录已经通过可执行文件验证了，可以直接认为存在
-            game_exe_exists = True
-            if debug_mode:
-                print(f"DEBUG: 游戏目录已验证: {game_dir}")
-                print(f"DEBUG: 游戏可执行文件存在: {game_exe_exists}")
-        else:
-            # 回退到传统方法检查游戏是否存在
-            # 尝试多种可能的文件名格式
-            expected_exe = GAME_INFO[game_version]["exe"]
-            traditional_folder = os.path.join(
-                self.selected_folder, 
-                GAME_INFO[game_version]["install_path"].split("/")[0]
-            )
-            
-            # 定义多种可能的可执行文件变体
-            exe_variants = [
-                expected_exe,                        # 标准文件名
-                expected_exe + ".nocrack",           # Steam加密版本
-                expected_exe.replace(".exe", ""),    # 无扩展名版本
-                expected_exe.replace("NEKOPARA", "nekopara").lower(),  # 全小写变体
-                expected_exe.lower(),                # 小写变体
-                expected_exe.lower() + ".nocrack",   # 小写变体的Steam加密版本
-            ]
-            
-            # 对于Vol.3可能有特殊名称
-            if "Vol.3" in game_version:
-                # 增加可能的卷3特定的变体
-                exe_variants.extend([
-                    "NEKOPARAVol3.exe", 
-                    "NEKOPARAVol3.exe.nocrack",
-                    "nekoparavol3.exe",
-                    "nekoparavol3.exe.nocrack",
-                    "nekopara_vol3.exe",
-                    "nekopara_vol3.exe.nocrack",
-                    "vol3.exe",
-                    "vol3.exe.nocrack"
-                ])
-            
-            # 检查所有可能的文件名
-            for exe_variant in exe_variants:
-                exe_path = os.path.join(traditional_folder, exe_variant)
-                if os.path.exists(exe_path):
-                    game_exe_exists = True
-                    if debug_mode:
-                        print(f"DEBUG: 找到游戏可执行文件: {exe_path}")
-                    break
-            
-            # 如果仍未找到，尝试递归搜索
-            if not game_exe_exists and os.path.exists(traditional_folder):
-                # 提取卷号或检查是否是After
-                vol_match = re.search(r"Vol\.(\d+)", game_version)
-                vol_num = None
-                if vol_match:
-                    vol_num = vol_match.group(1)
-                
-                is_after = "After" in game_version
-                
-                # 遍历游戏目录及其子目录
-                for root, dirs, files in os.walk(traditional_folder):
-                    for file in files:
-                        file_lower = file.lower()
-                        if file.endswith('.exe') or file.endswith('.exe.nocrack'):
-                            # 检查文件名中是否包含卷号或关键词
-                            if ((vol_num and (f"vol{vol_num}" in file_lower or 
-                                             f"vol.{vol_num}" in file_lower or 
-                                             f"vol {vol_num}" in file_lower)) or
-                                (is_after and "after" in file_lower)):
-                                game_exe_exists = True
-                                if debug_mode:
-                                    print(f"DEBUG: 通过递归搜索找到游戏可执行文件: {os.path.join(root, file)}")
-                                break
-                    if game_exe_exists:
-                        break
-            
-            if debug_mode:
-                print(f"DEBUG: 使用传统方法检查游戏目录: {traditional_folder}")
-                print(f"DEBUG: 游戏可执行文件存在: {game_exe_exists}")
+        # 游戏可执行文件已在填充下载队列时验证过，不需要再次检查
+        # 因为game_folder是从已验证的game_dirs中获取的
+        game_exe_exists = True
         
         # 检查游戏是否已安装
         if (
@@ -576,48 +516,18 @@ class DownloadManager:
         
         # 创建进度窗口并开始下载
         self.main_window.progress_window = self.main_window.create_progress_window()
-        self.start_download(url, _7z_path, game_version, game_folder, plugin_path)
-
-    def start_download(self, url, _7z_path, game_version, game_folder, plugin_path):
-        """启动下载线程
-        
-        Args:
-            url: 下载URL
-            _7z_path: 7z文件保存路径
-            game_version: 游戏版本名称
-            game_folder: 游戏文件夹路径
-            plugin_path: 插件路径
-        """
-        # 禁用退出按钮
-        self.main_window.ui.exit_btn.setEnabled(False)
         
+        # 从CloudflareOptimizer获取已优选的IP
+        self.optimized_ip = self.cloudflare_optimizer.get_optimized_ip()
         if self.optimized_ip:
             print(f"已为 {game_version} 获取到优选IP: {self.optimized_ip}")
         else:
             print(f"未能为 {game_version} 获取优选IP，将使用默认线路。")
 
-        # 创建并连接下载线程
-        self.current_download_thread = self.main_window.create_download_thread(url, _7z_path, game_version)
-        self.current_download_thread.progress.connect(self.main_window.progress_window.update_progress)
-        self.current_download_thread.finished.connect(
-            lambda success, error: self.on_download_finished(
-                success,
-                error,
-                url,
-                game_folder,
-                game_version,
-                _7z_path,
-                plugin_path,
-            )
-        )
-        
-        # 连接停止按钮
-        self.main_window.progress_window.stop_button.clicked.connect(self.current_download_thread.stop)
-        
-        # 启动线程和显示进度窗口
-        self.current_download_thread.start()
-        self.main_window.progress_window.exec()
+        # 使用DownloadTaskManager开始下载
+        self.download_task_manager.start_download(url, _7z_path, game_version, game_folder, plugin_path)
 
+    # 连接到主窗口中的下载完成处理函数
     def on_download_finished(self, success, error, url, game_folder, game_version, _7z_path, plugin_path):
         """下载完成后的处理
         
@@ -631,14 +541,19 @@ class DownloadManager:
             plugin_path: 插件路径
         """
         # 关闭进度窗口
-        if self.main_window.progress_window.isVisible():
+        if self.main_window.progress_window and self.main_window.progress_window.isVisible():
             self.main_window.progress_window.reject()
+            self.main_window.progress_window = None
 
         # 处理下载失败
         if not success:
             print(f"--- Download Failed: {game_version} ---")
             print(error)
             print("------------------------------------")
+            
+            # 临时启用窗口以显示对话框
+            self.main_window.setEnabled(True)
+            
             msg_box = QtWidgets.QMessageBox(self.main_window)
             msg_box.setWindowTitle(f"下载失败 - {APP_NAME}")
             msg_box.setText(f"\n文件获取失败: {game_version}\n错误: {error}\n\n是否重试？")
@@ -652,74 +567,76 @@ class DownloadManager:
 
             # 处理用户选择
             if clicked_button == retry_button:
+                # 重试，重新禁用窗口
+                self.main_window.setEnabled(False)
                 self.download_setting(url, game_folder, game_version, _7z_path, plugin_path)
             elif clicked_button == next_button:
+                # 继续下一个，重新禁用窗口
+                self.main_window.setEnabled(False)
                 self.next_download_task()
             else:
+                # 结束，保持窗口启用
                 self.on_download_stopped()
             return
 
-        # 下载成功，开始解压缩
-        self.main_window.hash_msg_box = self.main_window.hash_manager.hash_pop_window(check_type="extraction")
-        
-        # 创建并启动解压线程
-        self.main_window.extraction_thread = self.main_window.create_extraction_thread(
-            _7z_path, game_folder, plugin_path, game_version
-        )
-        self.main_window.extraction_thread.finished.connect(self.on_extraction_finished)
-        self.main_window.extraction_thread.start()
+        # 下载成功，使用ExtractionHandler开始解压缩
+        self.extraction_handler.start_extraction(_7z_path, game_folder, plugin_path, game_version)
+        # extraction_handler的回调会处理下一步操作
 
-    def on_extraction_finished(self, success, error_message, game_version):
-        """解压完成后的处理
+    def on_extraction_finished(self, continue_download):
+        """解压完成后的回调，决定是否继续下载队列
         
         Args:
-            success: 是否解压成功
-            error_message: 错误信息
-            game_version: 游戏版本
+            continue_download: 是否继续下载队列中的下一个任务
         """
-        # 关闭哈希检查窗口
-        if self.main_window.hash_msg_box and self.main_window.hash_msg_box.isVisible():
-            self.main_window.hash_msg_box.close()
-
-        # 处理解压结果
-        if not success:
-            QtWidgets.QMessageBox.critical(self.main_window, f"错误 - {APP_NAME}", error_message)
-            self.main_window.installed_status[game_version] = False
+        if continue_download:
+            # 继续下一个下载任务
+            self.next_download_task()
         else:
-            self.main_window.installed_status[game_version] = True
-        
-        # 继续下一个下载任务
-        self.next_download_task()
+            # 清空剩余队列并显示结果
+            self.download_queue.clear()
+            self.main_window.show_result()
 
     def on_download_stopped(self):
         """当用户点击停止按钮或选择结束时调用的函数"""
         # 停止IP优化线程
-        if hasattr(self, 'ip_optimizer_thread') and self.ip_optimizer_thread and self.ip_optimizer_thread.isRunning():
-            self.ip_optimizer_thread.stop()
-            self.ip_optimizer_thread.wait()
-            if hasattr(self, 'optimizing_msg_box') and self.optimizing_msg_box:
-                if self.optimizing_msg_box.isVisible():
-                    self.optimizing_msg_box.accept()
-                self.optimizing_msg_box = None
+        self.cloudflare_optimizer.stop_optimization()
 
         # 停止当前可能仍在运行的下载线程
-        if self.current_download_thread and self.current_download_thread.isRunning():
-            self.current_download_thread.stop()
-            self.current_download_thread.wait() # 等待线程完全终止
+        self.download_task_manager.stop_download()
             
         # 清空下载队列，因为用户决定停止
         self.download_queue.clear()
         
         # 确保进度窗口已关闭
-        if hasattr(self.main_window, 'progress_window') and self.main_window.progress_window.isVisible():
-            self.main_window.progress_window.reject()
+        if hasattr(self.main_window, 'progress_window') and self.main_window.progress_window:
+            if self.main_window.progress_window.isVisible():
+                self.main_window.progress_window.reject()
+            self.main_window.progress_window = None
 
-        # 可以在这里决定是否立即进行哈希比较或显示结果
+        # 退出应用程序
         print("下载已全部停止。")
-        self.main_window.setEnabled(True) # 恢复主窗口交互
         
-        # 重新启用退出按钮和开始安装按钮
-        self.main_window.ui.exit_btn.setEnabled(True)
-        self.main_window.set_start_button_enabled(True)
+        # 恢复主窗口状态
+        self.main_window.setEnabled(True)
+        self.main_window.ui.start_install_text.setText("开始安装")
         
-        self.main_window.show_result() 
+        # 显示取消安装的消息
+        QtWidgets.QMessageBox.information(
+            self.main_window,
+            f"已取消 - {APP_NAME}",
+            "\n已成功取消安装进程。\n"
+        )
+
+    # 以下方法委托给DownloadTaskManager
+    def get_download_thread_count(self):
+        """获取当前下载线程设置对应的线程数"""
+        return self.download_task_manager.get_download_thread_count()
+        
+    def set_download_thread_level(self, level):
+        """设置下载线程级别"""
+        return self.download_task_manager.set_download_thread_level(level)
+    
+    def show_download_thread_settings(self):
+        """显示下载线程设置对话框"""
+        return self.download_task_manager.show_download_thread_settings() 

source/core/download_task_manager.py

@@ -0,0 +1,221 @@
+from PySide6 import QtWidgets
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QRadioButton, QPushButton, QLabel, QButtonGroup, QHBoxLayout
+from PySide6.QtGui import QFont
+
+from data.config import DOWNLOAD_THREADS
+
+
+class DownloadTaskManager:
+    """下载任务管理器，负责管理下载任务和线程设置"""
+    
+    def __init__(self, main_window, download_thread_level="medium"):
+        """初始化下载任务管理器
+        
+        Args:
+            main_window: 主窗口实例，用于访问UI和状态
+            download_thread_level: 下载线程级别，默认为"medium"
+        """
+        self.main_window = main_window
+        self.APP_NAME = main_window.APP_NAME if hasattr(main_window, 'APP_NAME') else ""
+        self.current_download_thread = None
+        self.download_thread_level = download_thread_level
+    
+    def start_download(self, url, _7z_path, game_version, game_folder, plugin_path):
+        """启动下载线程
+        
+        Args:
+            url: 下载URL
+            _7z_path: 7z文件保存路径
+            game_version: 游戏版本名称
+            game_folder: 游戏文件夹路径
+            plugin_path: 插件路径
+        """
+        # 按钮在file_dialog中已设置为禁用状态
+        
+        # 创建并连接下载线程
+        self.current_download_thread = self.main_window.create_download_thread(url, _7z_path, game_version)
+        self.current_download_thread.progress.connect(self.main_window.progress_window.update_progress)
+        self.current_download_thread.finished.connect(
+            lambda success, error: self.main_window.download_manager.on_download_finished(
+                success,
+                error,
+                url,
+                game_folder,
+                game_version,
+                _7z_path,
+                plugin_path,
+            )
+        )
+        
+        # 连接停止按钮到download_manager的on_download_stopped方法
+        self.main_window.progress_window.stop_button.clicked.connect(self.main_window.download_manager.on_download_stopped)
+        
+        # 连接暂停/恢复按钮
+        self.main_window.progress_window.pause_resume_button.clicked.connect(self.toggle_download_pause)
+        
+        # 启动线程和显示进度窗口
+        self.current_download_thread.start()
+        self.main_window.progress_window.exec()
+
+    def toggle_download_pause(self):
+        """切换下载的暂停/恢复状态"""
+        if not self.current_download_thread:
+            return
+            
+        # 获取当前暂停状态
+        is_paused = self.current_download_thread.is_paused()
+        
+        if is_paused:
+            # 如果已暂停，则恢复下载
+            success = self.current_download_thread.resume()
+            if success:
+                self.main_window.progress_window.update_pause_button_state(False)
+        else:
+            # 如果未暂停，则暂停下载
+            success = self.current_download_thread.pause()
+            if success:
+                self.main_window.progress_window.update_pause_button_state(True)
+    
+    def get_download_thread_count(self):
+        """获取当前下载线程设置对应的线程数
+        
+        Returns:
+            int: 下载线程数
+        """
+        # 获取当前线程级别对应的线程数
+        thread_count = DOWNLOAD_THREADS.get(self.download_thread_level, DOWNLOAD_THREADS["medium"])
+        return thread_count
+        
+    def set_download_thread_level(self, level):
+        """设置下载线程级别
+        
+        Args:
+            level: 线程级别 (low, medium, high, extreme, insane)
+            
+        Returns:
+            bool: 设置是否成功
+        """
+        if level in DOWNLOAD_THREADS:
+            old_level = self.download_thread_level
+            self.download_thread_level = level
+            
+            # 只有非极端级别才保存到配置
+            if level not in ["extreme", "insane"]:
+                if hasattr(self.main_window, 'config'):
+                    self.main_window.config["download_thread_level"] = level
+                    self.main_window.save_config(self.main_window.config)
+                    
+            return True
+        return False
+    
+    def show_download_thread_settings(self):
+        """显示下载线程设置对话框"""
+        # 创建对话框
+        dialog = QDialog(self.main_window)
+        dialog.setWindowTitle(f"下载线程设置 - {self.APP_NAME}")
+        dialog.setMinimumWidth(350)
+        
+        layout = QVBoxLayout(dialog)
+        
+        # 添加说明标签
+        info_label = QLabel("选择下载线程数量（更多线程通常可以提高下载速度）：", dialog)
+        info_label.setWordWrap(True)
+        layout.addWidget(info_label)
+        
+        # 创建按钮组
+        button_group = QButtonGroup(dialog)
+        
+        # 添加线程选项
+        thread_options = {
+            "low": f"低速 - {DOWNLOAD_THREADS['low']}线程（慢慢来，不着急）",
+            "medium": f"中速 - {DOWNLOAD_THREADS['medium']}线程（快人半步）",
+            "high": f"高速 - {DOWNLOAD_THREADS['high']}线程（默认，推荐配置）",
+            "extreme": f"极速 - {DOWNLOAD_THREADS['extreme']}线程（如果你对你的网和电脑很自信的话）",
+            "insane": f"狂暴 - {DOWNLOAD_THREADS['insane']}线程（看看是带宽和性能先榨干还是牛牛先榨干）"
+        }
+        
+        radio_buttons = {}
+        
+        for level, text in thread_options.items():
+            radio = QRadioButton(text, dialog)
+            
+            # 选中当前使用的线程级别
+            if level == self.download_thread_level:
+                radio.setChecked(True)
+                
+            button_group.addButton(radio)
+            layout.addWidget(radio)
+            radio_buttons[level] = radio
+            
+        layout.addSpacing(10)
+        
+        # 添加按钮区域
+        btn_layout = QHBoxLayout()
+        
+        ok_button = QPushButton("确定", dialog)
+        cancel_button = QPushButton("取消", dialog)
+        
+        btn_layout.addWidget(ok_button)
+        btn_layout.addWidget(cancel_button)
+        
+        layout.addLayout(btn_layout)
+        
+        # 连接按钮事件
+        ok_button.clicked.connect(dialog.accept)
+        cancel_button.clicked.connect(dialog.reject)
+        
+        # 显示对话框
+        result = dialog.exec()
+        
+        # 处理结果
+        if result == QDialog.DialogCode.Accepted:
+            # 获取用户选择的线程级别
+            selected_level = None
+            for level, radio in radio_buttons.items():
+                if radio.isChecked():
+                    selected_level = level
+                    break
+                    
+            if selected_level:
+                # 为极速和狂暴模式显示警告
+                if selected_level in ["extreme", "insane"]:
+                    warning_result = QtWidgets.QMessageBox.warning(
+                        self.main_window,
+                        f"高风险警告 - {self.APP_NAME}",
+                        "警告！过高的线程数可能导致CPU负载过高或其他恶性问题！\n你确定要这么做吗？",
+                        QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
+                        QtWidgets.QMessageBox.StandardButton.No
+                    )
+                    
+                    if warning_result != QtWidgets.QMessageBox.StandardButton.Yes:
+                        return False
+                
+                success = self.set_download_thread_level(selected_level)
+                
+                if success:
+                    # 显示设置成功消息
+                    thread_count = DOWNLOAD_THREADS[selected_level]
+                    message = f"\n已成功设置下载线程为: {thread_count}线程\n"
+                    
+                    # 对于极速和狂暴模式，添加仅本次生效的提示
+                    if selected_level in ["extreme", "insane"]:
+                        message += "\n注意：极速/狂暴模式仅本次生效。软件重启后将恢复默认设置。\n"
+                    
+                    QtWidgets.QMessageBox.information(
+                        self.main_window,
+                        f"设置成功 - {self.APP_NAME}",
+                        message
+                    )
+                
+            return True
+            
+        return False 
+    
+    def stop_download(self):
+        """停止当前下载线程"""
+        if self.current_download_thread and self.current_download_thread.isRunning():
+            self.current_download_thread.stop()
+            self.current_download_thread.wait()  # 等待线程完全终止
+            return True
+        return False 

source/core/extraction_handler.py

@@ -0,0 +1,81 @@
+import os
+from PySide6 import QtWidgets
+from PySide6.QtWidgets import QMessageBox
+
+
+class ExtractionHandler:
+    """解压处理器，负责管理解压任务和结果处理"""
+    
+    def __init__(self, main_window):
+        """初始化解压处理器
+        
+        Args:
+            main_window: 主窗口实例，用于访问UI和状态
+        """
+        self.main_window = main_window
+        self.APP_NAME = main_window.APP_NAME if hasattr(main_window, 'APP_NAME') else ""
+        
+    def start_extraction(self, _7z_path, game_folder, plugin_path, game_version):
+        """开始解压任务
+        
+        Args:
+            _7z_path: 7z文件路径
+            game_folder: 游戏文件夹路径
+            plugin_path: 插件路径
+            game_version: 游戏版本名称
+        """
+        # 显示解压中的消息窗口
+        self.main_window.hash_msg_box = self.main_window.hash_manager.hash_pop_window(check_type="extraction")
+        
+        # 创建并启动解压线程
+        self.main_window.extraction_thread = self.main_window.create_extraction_thread(
+            _7z_path, game_folder, plugin_path, game_version
+        )
+        self.main_window.extraction_thread.finished.connect(self.on_extraction_finished)
+        self.main_window.extraction_thread.start()
+        
+    def on_extraction_finished(self, success, error_message, game_version):
+        """解压完成后的处理
+        
+        Args:
+            success: 是否解压成功
+            error_message: 错误信息
+            game_version: 游戏版本
+        """
+        # 关闭哈希检查窗口
+        if self.main_window.hash_msg_box and self.main_window.hash_msg_box.isVisible():
+            self.main_window.hash_msg_box.close()
+            self.main_window.hash_msg_box = None
+
+        # 处理解压结果
+        if not success:
+            # 临时启用窗口以显示错误消息
+            self.main_window.setEnabled(True)
+            
+            QtWidgets.QMessageBox.critical(self.main_window, f"错误 - {self.APP_NAME}", error_message)
+            self.main_window.installed_status[game_version] = False
+            
+            # 询问用户是否继续其他游戏的安装
+            reply = QtWidgets.QMessageBox.question(
+                self.main_window,
+                f"继续安装? - {self.APP_NAME}",
+                f"\n{game_version} 的补丁安装失败。\n\n是否继续安装其他游戏的补丁？\n",
+                QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No,
+                QtWidgets.QMessageBox.StandardButton.Yes
+            )
+            
+            if reply == QtWidgets.QMessageBox.StandardButton.Yes:
+                # 继续下一个，重新禁用窗口
+                self.main_window.setEnabled(False)
+                # 通知DownloadManager继续下一个下载任务
+                self.main_window.download_manager.on_extraction_finished(True)
+            else:
+                # 用户选择停止，保持窗口启用状态
+                self.main_window.ui.start_install_text.setText("开始安装")
+                # 通知DownloadManager停止下载队列
+                self.main_window.download_manager.on_extraction_finished(False)
+        else:
+            # 更新安装状态
+            self.main_window.installed_status[game_version] = True
+            # 通知DownloadManager继续下一个下载任务
+            self.main_window.download_manager.on_extraction_finished(True) 

source/core/game_detector.py

@@ -0,0 +1,311 @@
+import os
+import re
+
+class GameDetector:
+    """游戏检测器，用于识别游戏目录和版本"""
+    
+    def __init__(self, game_info, debug_manager=None):
+        """初始化游戏检测器
+        
+        Args:
+            game_info: 游戏信息字典，包含各版本的安装路径和可执行文件名
+            debug_manager: 调试管理器实例，用于输出调试信息
+        """
+        self.game_info = game_info
+        self.debug_manager = debug_manager
+        
+    def _is_debug_mode(self):
+        """检查是否处于调试模式
+        
+        Returns:
+            bool: 是否处于调试模式
+        """
+        if hasattr(self.debug_manager, 'ui_manager') and hasattr(self.debug_manager.ui_manager, 'debug_action'):
+            return self.debug_manager.ui_manager.debug_action.isChecked()
+        return False
+        
+    def identify_game_version(self, game_dir):
+        """识别游戏版本
+        
+        Args:
+            game_dir: 游戏目录路径
+            
+        Returns:
+            str: 游戏版本名称，如果不是有效的游戏目录则返回None
+        """
+        debug_mode = self._is_debug_mode()
+        
+        if debug_mode:
+            print(f"DEBUG: 尝试识别游戏版本: {game_dir}")
+            
+        # 先通过目录名称进行初步推测（这将作为递归搜索的提示）
+        dir_name = os.path.basename(game_dir).lower()
+        potential_version = None
+        vol_num = None
+        
+        # 提取卷号或判断是否是After
+        if "vol" in dir_name or "vol." in dir_name:
+            vol_match = re.search(r"vol(?:\.|\s*)?(\d+)", dir_name)
+            if vol_match:
+                vol_num = vol_match.group(1)
+                potential_version = f"NEKOPARA Vol.{vol_num}"
+                if debug_mode:
+                    print(f"DEBUG: 从目录名推测游戏版本: {potential_version}, 卷号: {vol_num}")
+        elif "after" in dir_name:
+            potential_version = "NEKOPARA After"
+            if debug_mode:
+                print(f"DEBUG: 从目录名推测游戏版本: NEKOPARA After")
+        
+        # 检查是否为NEKOPARA游戏目录
+        # 通过检查游戏可执行文件来识别游戏版本
+        for game_version, info in self.game_info.items():
+            # 尝试多种可能的可执行文件名变体
+            exe_variants = [
+                info["exe"],                         # 标准文件名
+                info["exe"] + ".nocrack",            # Steam加密版本
+                info["exe"].replace(".exe", ""),     # 无扩展名版本
+                info["exe"].replace("NEKOPARA", "nekopara").lower(),  # 全小写变体
+                info["exe"].lower(),                 # 小写变体
+                info["exe"].lower() + ".nocrack",    # 小写变体的Steam加密版本
+            ]
+            
+            # 对于Vol.3可能有特殊名称
+            if "Vol.3" in game_version:
+                # 增加可能的卷3特定的变体
+                exe_variants.extend([
+                    "NEKOPARAVol3.exe", 
+                    "NEKOPARAVol3.exe.nocrack",
+                    "nekoparavol3.exe",
+                    "nekoparavol3.exe.nocrack",
+                    "nekopara_vol3.exe",
+                    "nekopara_vol3.exe.nocrack",
+                    "vol3.exe",
+                    "vol3.exe.nocrack"
+                ])
+            
+            for exe_variant in exe_variants:
+                exe_path = os.path.join(game_dir, exe_variant)
+                if os.path.exists(exe_path):
+                    if debug_mode:
+                        print(f"DEBUG: 通过可执行文件确认游戏版本: {game_version}, 文件: {exe_variant}")
+                    return game_version
+        
+        # 如果没有直接匹配，尝试递归搜索
+        if potential_version:
+            # 从预测的版本中获取卷号或确认是否是After
+            is_after = "After" in potential_version
+            if not vol_num and not is_after:
+                vol_match = re.search(r"Vol\.(\d+)", potential_version)
+                if vol_match:
+                    vol_num = vol_match.group(1)
+            
+            # 递归搜索可执行文件
+            for root, dirs, files in os.walk(game_dir):
+                for file in files:
+                    file_lower = file.lower()
+                    if file.endswith('.exe') or file.endswith('.exe.nocrack'):
+                        # 检查文件名中是否包含卷号或关键词
+                        if ((vol_num and (f"vol{vol_num}" in file_lower or 
+                                         f"vol.{vol_num}" in file_lower or 
+                                         f"vol {vol_num}" in file_lower)) or
+                            (is_after and "after" in file_lower)):
+                            if debug_mode:
+                                print(f"DEBUG: 通过递归搜索确认游戏版本: {potential_version}, 文件: {file}")
+                            return potential_version
+        
+        # 如果仍然没有找到，基于目录名的推测返回结果
+        if potential_version:
+            if debug_mode:
+                print(f"DEBUG: 基于目录名返回推测的游戏版本: {potential_version}")
+            return potential_version
+            
+        if debug_mode:
+            print(f"DEBUG: 无法识别游戏版本: {game_dir}")
+            
+        return None
+    
+    def identify_game_directories_improved(self, selected_folder):
+        """改进的游戏目录识别，支持大小写不敏感和特殊字符处理
+        
+        Args:
+            selected_folder: 选择的上级目录
+            
+        Returns:
+            dict: 游戏版本到游戏目录的映射
+        """
+        debug_mode = self._is_debug_mode()
+        
+        if debug_mode:
+            print(f"--- 开始识别目录: {selected_folder} ---")
+            
+        game_paths = {}
+        
+        # 获取上级目录中的所有文件夹
+        try:
+            all_dirs = [d for d in os.listdir(selected_folder) if os.path.isdir(os.path.join(selected_folder, d))]
+            if debug_mode:
+                print(f"DEBUG: 找到以下子目录: {all_dirs}")
+        except Exception as e:
+            if debug_mode:
+                print(f"DEBUG: 无法读取目录 {selected_folder}: {str(e)}")
+            return {}
+        
+        for game, info in self.game_info.items():
+            expected_dir = info["install_path"].split("/")[0]  # 例如 "NEKOPARA Vol. 1"
+            expected_exe = info["exe"]  # 标准可执行文件名
+            
+            if debug_mode:
+                print(f"DEBUG: 搜索游戏 {game}, 预期目录: {expected_dir}, 预期可执行文件: {expected_exe}")
+            
+            # 尝试不同的匹配方法
+            found_dir = None
+            
+            # 1. 精确匹配
+            if expected_dir in all_dirs:
+                found_dir = expected_dir
+                if debug_mode:
+                    print(f"DEBUG: 精确匹配成功: {expected_dir}")
+            
+            # 2. 大小写不敏感匹配
+            if not found_dir:
+                for dir_name in all_dirs:
+                    if expected_dir.lower() == dir_name.lower():
+                        found_dir = dir_name
+                        if debug_mode:
+                            print(f"DEBUG: 大小写不敏感匹配成功: {dir_name}")
+                        break
+            
+            # 3. 更模糊的匹配（允许特殊字符差异）
+            if not found_dir:
+                # 准备用于模糊匹配的正则表达式模式
+                # 替换空格为可选空格或连字符，替换点为可选点
+                pattern_text = expected_dir.replace(" ", "[ -]?").replace(".", "\\.?")
+                pattern = re.compile(f"^{pattern_text}$", re.IGNORECASE)
+                
+                for dir_name in all_dirs:
+                    if pattern.match(dir_name):
+                        found_dir = dir_name
+                        if debug_mode:
+                            print(f"DEBUG: 模糊匹配成功: {dir_name} 匹配模式 {pattern_text}")
+                        break
+            
+            # 4. 如果还是没找到，尝试更宽松的匹配
+            if not found_dir:
+                vol_match = re.search(r"vol(?:\.|\s*)?(\d+)", expected_dir, re.IGNORECASE)
+                vol_num = None
+                if vol_match:
+                    vol_num = vol_match.group(1)
+                    if debug_mode:
+                        print(f"DEBUG: 提取卷号: {vol_num}")
+                
+                is_after = "after" in expected_dir.lower()
+                
+                for dir_name in all_dirs:
+                    dir_lower = dir_name.lower()
+                    
+                    # 对于After特殊处理
+                    if is_after and "after" in dir_lower:
+                        found_dir = dir_name
+                        if debug_mode:
+                            print(f"DEBUG: After特殊匹配成功: {dir_name}")
+                        break
+                        
+                    # 对于Vol特殊处理
+                    if vol_num:
+                        # 查找目录名中的卷号
+                        dir_vol_match = re.search(r"vol(?:\.|\s*)?(\d+)", dir_lower)
+                        if dir_vol_match and dir_vol_match.group(1) == vol_num:
+                            found_dir = dir_name
+                            if debug_mode:
+                                print(f"DEBUG: 卷号匹配成功: {dir_name} 卷号 {vol_num}")
+                            break
+            
+            # 如果找到匹配的目录，验证exe文件是否存在
+            if found_dir:
+                potential_path = os.path.join(selected_folder, found_dir)
+                
+                # 尝试多种可能的可执行文件名变体
+                # 包括Steam加密版本和其他可能的变体
+                exe_variants = [
+                    expected_exe,                    # 标准文件名
+                    expected_exe + ".nocrack",       # Steam加密版本
+                    expected_exe.replace(".exe", ""),# 无扩展名版本
+                    # Vol.3的特殊变体，因为它的文件名可能不一样
+                    expected_exe.replace("NEKOPARA", "nekopara").lower(),  # 全小写变体
+                    expected_exe.lower(),            # 小写变体
+                    expected_exe.lower() + ".nocrack", # 小写变体的Steam加密版本
+                ]
+                
+                # 对于Vol.3可能有特殊名称
+                if "Vol.3" in game:
+                    # 增加可能的卷3特定的变体
+                    exe_variants.extend([
+                        "NEKOPARAVol3.exe", 
+                        "NEKOPARAVol3.exe.nocrack",
+                        "nekoparavol3.exe",
+                        "nekoparavol3.exe.nocrack",
+                        "nekopara_vol3.exe",
+                        "nekopara_vol3.exe.nocrack",
+                        "vol3.exe",
+                        "vol3.exe.nocrack"
+                    ])
+                
+                exe_exists = False
+                found_exe = None
+                
+                # 尝试所有可能的变体
+                for exe_variant in exe_variants:
+                    exe_path = os.path.join(potential_path, exe_variant)
+                    if os.path.exists(exe_path):
+                        exe_exists = True
+                        found_exe = exe_variant
+                        if debug_mode:
+                            print(f"DEBUG: 验证成功，找到游戏可执行文件: {exe_variant}")
+                        break
+                
+                # 如果没有直接找到，尝试递归搜索当前目录下的所有可执行文件
+                if not exe_exists:
+                    # 遍历当前目录下的所有文件和文件夹
+                    for root, dirs, files in os.walk(potential_path):
+                        for file in files:
+                            file_lower = file.lower()
+                            # 检查是否是游戏可执行文件（根据关键字）
+                            if file.endswith('.exe') or file.endswith('.exe.nocrack'):
+                                # 检查文件名中是否包含卷号或关键词
+                                if "Vol." in game:
+                                    vol_match = re.search(r"Vol\.(\d+)", game)
+                                    if vol_match:
+                                        vol_num = vol_match.group(1)
+                                        if (f"vol{vol_num}" in file_lower or 
+                                            f"vol.{vol_num}" in file_lower or 
+                                            f"vol {vol_num}" in file_lower):
+                                            exe_path = os.path.join(root, file)
+                                            exe_exists = True
+                                            found_exe = os.path.relpath(exe_path, potential_path)
+                                            if debug_mode:
+                                                print(f"DEBUG: 通过递归搜索找到游戏可执行文件: {found_exe}")
+                                            break
+                                elif "After" in game and "after" in file_lower:
+                                    exe_path = os.path.join(root, file)
+                                    exe_exists = True
+                                    found_exe = os.path.relpath(exe_path, potential_path)
+                                    if debug_mode:
+                                        print(f"DEBUG: 通过递归搜索找到After游戏可执行文件: {found_exe}")
+                                    break
+                        if exe_exists:
+                            break
+                
+                # 如果找到了可执行文件，将该目录添加到游戏目录列表
+                if exe_exists:
+                    game_paths[game] = potential_path
+                    if debug_mode:
+                        print(f"DEBUG: 验证成功，将 {potential_path} 添加为 {game} 的目录")
+                else:
+                    if debug_mode:
+                        print(f"DEBUG: 未找到任何可执行文件变体，游戏 {game} 在 {potential_path} 未找到")
+        
+        if debug_mode:
+            print(f"DEBUG: 最终识别的游戏目录: {game_paths}")
+            print(f"--- 目录识别结束 ---")
+            
+        return game_paths 

source/core/ipv6_manager.py

@@ -0,0 +1,345 @@
+import os
+import sys
+import time
+import subprocess
+import urllib.request
+import ssl
+import threading
+from PySide6.QtCore import QObject, Signal
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QLabel, QPushButton, QTextEdit, QProgressBar, QMessageBox
+
+from data.config import APP_NAME
+from utils import msgbox_frame
+
+
+class IPv6Manager:
+    """管理IPv6相关功能的类"""
+
+    def __init__(self, main_window):
+        """初始化IPv6管理器
+        
+        Args:
+            main_window: 主窗口实例，用于显示对话框和访问配置
+        """
+        self.main_window = main_window
+        self.config = getattr(main_window, 'config', {})
+        
+    def check_ipv6_availability(self):
+        """检查IPv6是否可用
+        
+        通过访问IPv6专用图片URL测试IPv6连接
+        
+        Returns:
+            bool: IPv6是否可用
+        """
+        import urllib.request
+        import time
+        
+        print("开始检测IPv6可用性...")
+        
+        try:
+            # 获取IPv6测试请求
+            ipv6_test_url, req, context = self._get_ipv6_test_request()
+            
+            # 设置3秒超时，避免长时间等待
+            start_time = time.time()
+            with urllib.request.urlopen(req, timeout=3, context=context) as response:
+                # 读取图片数据
+                image_data = response.read()
+                
+                # 检查是否成功
+                if response.status == 200 and len(image_data) > 0:
+                    elapsed = time.time() - start_time
+                    print(f"IPv6测试成功! 用时: {elapsed:.2f}秒")
+                    return True
+                else:
+                    print(f"IPv6测试失败: 状态码 {response.status}")
+                    return False
+        except Exception as e:
+            print(f"IPv6测试失败: {e}")
+            return False
+            
+    def _get_ipv6_test_request(self):
+        """获取IPv6测试请求
+        
+        Returns:
+            tuple: (测试URL, 请求对象, SSL上下文)
+        """
+        import urllib.request
+        import ssl
+        
+        # IPv6测试URL - 这是一个只能通过IPv6访问的资源
+        ipv6_test_url = "https://ipv6.testipv6.cn/images-nc/knob_green.png?&testdomain=www.test-ipv6.com&testname=sites"
+        
+        # 创建SSL上下文
+        context = ssl._create_unverified_context()
+        
+        # 创建请求并添加常见的HTTP头
+        req = urllib.request.Request(ipv6_test_url)
+        req.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)')
+        req.add_header('Accept', 'image/webp,image/apng,image/*,*/*;q=0.8')
+        
+        return ipv6_test_url, req, context
+        
+    def get_ipv6_address(self):
+        """获取公网IPv6地址
+        
+        Returns:
+            str: IPv6地址，如果失败则返回None
+        """
+        try:
+            # 使用curl命令获取IPv6地址
+            process = subprocess.Popen(
+                ["curl", "-6", "6.ipw.cn"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                encoding='utf-8',
+                errors='replace',
+                creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0
+            )
+            
+            # 设置超时
+            timeout = 5  # 5秒超时
+            start_time = time.time()
+            while process.poll() is None and (time.time() - start_time) < timeout:
+                time.sleep(0.1)
+            
+            # 如果进程仍在运行，则强制终止
+            if process.poll() is None:
+                process.terminate()
+                print("获取IPv6地址超时")
+                return None
+                
+            stdout, stderr = process.communicate()
+            
+            if process.returncode == 0 and stdout.strip():
+                ipv6_address = stdout.strip()
+                print(f"获取到IPv6地址: {ipv6_address}")
+                return ipv6_address
+            else:
+                print("未能获取到IPv6地址")
+                if stderr:
+                    print(f"错误信息: {stderr}")
+                return None
+        
+        except Exception as e:
+            print(f"获取IPv6地址失败: {e}")
+            return None
+            
+    def show_ipv6_details(self):
+        """显示IPv6连接详情"""
+        class SignalEmitter(QObject):
+            update_signal = Signal(str)
+            complete_signal = Signal(bool, float)
+        
+        # 创建对话框
+        dialog = QDialog(self.main_window)
+        dialog.setWindowTitle(f"IPv6连接测试 - {APP_NAME}")
+        dialog.resize(500, 300)
+        
+        # 创建布局
+        layout = QVBoxLayout(dialog)
+        
+        # 创建状态标签
+        status_label = QLabel("正在测试IPv6连接...", dialog)
+        layout.addWidget(status_label)
+        
+        # 创建进度条
+        progress = QProgressBar(dialog)
+        progress.setRange(0, 0)  # 不确定进度
+        layout.addWidget(progress)
+        
+        # 创建结果文本框
+        result_text = QTextEdit(dialog)
+        result_text.setReadOnly(True)
+        layout.addWidget(result_text)
+        
+        # 创建关闭按钮
+        close_button = QPushButton("关闭", dialog)
+        close_button.clicked.connect(dialog.accept)
+        close_button.setEnabled(False)  # 测试完成前禁用
+        layout.addWidget(close_button)
+        
+        # 信号发射器
+        signal_emitter = SignalEmitter()
+        
+        # 连接信号
+        signal_emitter.update_signal.connect(
+            lambda text: result_text.append(text)
+        )
+        
+        def on_test_complete(success, elapsed_time):
+            # 停止进度条动画
+            progress.setRange(0, 100)
+            progress.setValue(100 if success else 0)
+            
+            # 更新状态
+            if success:
+                status_label.setText(f"IPv6连接测试完成: 可用 (用时: {elapsed_time:.2f}秒)")
+            else:
+                status_label.setText("IPv6连接测试完成: 不可用")
+            
+            # 启用关闭按钮
+            close_button.setEnabled(True)
+        
+        signal_emitter.complete_signal.connect(on_test_complete)
+        
+        # 测试函数
+        def test_ipv6():
+            try:
+                signal_emitter.update_signal.emit("正在测试IPv6连接，请稍候...")
+                
+                # 先进行标准的IPv6连接测试
+                signal_emitter.update_signal.emit("正在进行标准IPv6连接测试...")
+                
+                # 使用IPv6测试URL
+                ipv6_test_url, req, context = self._get_ipv6_test_request()
+                ipv6_connected = False
+                ipv6_test_elapsed_time = 0
+                
+                try:
+                    # 设置5秒超时
+                    start_time = time.time()
+                    signal_emitter.update_signal.emit(f"开始连接: {ipv6_test_url}")
+                    
+                    # 尝试下载图片
+                    with urllib.request.urlopen(req, timeout=5, context=context) as response:
+                        image_data = response.read()
+                        
+                        # 计算耗时
+                        elapsed_time = time.time() - start_time
+                        ipv6_test_elapsed_time = elapsed_time
+                        
+                        # 检查是否成功
+                        if response.status == 200 and len(image_data) > 0:
+                            ipv6_connected = True
+                            signal_emitter.update_signal.emit(f"✓ 成功! 已下载 {len(image_data)} 字节")
+                            signal_emitter.update_signal.emit(f"✓ 响应时间: {elapsed_time:.2f}秒")
+                        else:
+                            signal_emitter.update_signal.emit(f"✗ 失败: 状态码 {response.status}")
+                            signal_emitter.update_signal.emit("\n结论: 您的网络不支持IPv6连接 ✗")
+                            signal_emitter.complete_signal.emit(False, 0)
+                            return
+                            
+                except Exception as e:
+                    signal_emitter.update_signal.emit(f"✗ 连接失败: {e}")
+                    signal_emitter.update_signal.emit("\n结论: 您的网络不支持IPv6连接 ✗")
+                    signal_emitter.complete_signal.emit(False, 0)
+                    return
+                
+                # 如果IPv6连接测试成功，再尝试获取公网IPv6地址
+                if ipv6_connected:
+                    signal_emitter.update_signal.emit("\n正在获取您的公网IPv6地址...")
+                    
+                    try:
+                        # 使用curl命令获取IPv6地址
+                        process = subprocess.Popen(
+                            ["curl", "-6", "6.ipw.cn"],
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE,
+                            text=True,
+                            encoding='utf-8',
+                            errors='replace',
+                            creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0
+                        )
+                        
+                        # 设置超时
+                        timeout = 5  # 5秒超时
+                        start_time = time.time()
+                        while process.poll() is None and (time.time() - start_time) < timeout:
+                            time.sleep(0.1)
+                        
+                        # 如果进程仍在运行，则强制终止
+                        if process.poll() is None:
+                            process.terminate()
+                            signal_emitter.update_signal.emit("✗ 获取IPv6地址超时")
+                        else:
+                            stdout, stderr = process.communicate()
+                            
+                            if process.returncode == 0 and stdout.strip():
+                                ipv6_address = stdout.strip()
+                                signal_emitter.update_signal.emit(f"✓ 获取到的IPv6地址: {ipv6_address}")
+                            else:
+                                signal_emitter.update_signal.emit("✗ 未能获取到IPv6地址")
+                                if stderr:
+                                    signal_emitter.update_signal.emit(f"错误信息: {stderr}")
+                    
+                    except Exception as e:
+                        signal_emitter.update_signal.emit(f"✗ 获取IPv6地址失败: {e}")
+                    
+                    # 输出最终结论
+                    signal_emitter.update_signal.emit("\n结论: 您的网络支持IPv6连接 ✓")
+                    signal_emitter.complete_signal.emit(True, ipv6_test_elapsed_time)
+                    return
+                
+            except Exception as e:
+                signal_emitter.update_signal.emit(f"测试过程中出错: {e}")
+                signal_emitter.complete_signal.emit(False, 0)
+        
+        # 启动测试线程
+        threading.Thread(target=test_ipv6, daemon=True).start()
+        
+        # 显示对话框
+        dialog.exec()
+        
+    def toggle_ipv6_support(self, enabled):
+        """切换IPv6支持
+        
+        Args:
+            enabled: 是否启用IPv6支持
+        """
+        print(f"Toggle IPv6 support: {enabled}")
+        
+        # 如果用户尝试启用IPv6，检查系统是否支持IPv6并发出警告
+        if enabled:
+            # 先显示警告提示
+            warning_msg_box = self._create_message_box(
+                "警告", 
+                "\n目前IPv6支持功能仍在测试阶段，可能会发生意料之外的bug！\n\n您确定需要启用吗？\n",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+            )
+            response = warning_msg_box.exec()
+            
+            # 如果用户选择不启用，直接返回
+            if response != QMessageBox.StandardButton.Yes:
+                return False
+            
+            # 用户确认启用后，继续检查IPv6可用性
+            ipv6_available = self.check_ipv6_availability()
+                
+            if not ipv6_available:
+                msg_box = self._create_message_box("错误", "\n未检测到可用的IPv6连接，无法启用IPv6支持。\n\n请确保您的网络环境支持IPv6且已正确配置。\n")
+                msg_box.exec()
+                return False
+                
+        # 保存设置到配置
+        if self.config is not None:
+            self.config["ipv6_enabled"] = enabled
+            # 直接使用utils.save_config保存配置
+            from utils import save_config
+            save_config(self.config)
+            
+        # 显示设置已保存的消息
+        status = "启用" if enabled else "禁用"
+        msg_box = self._create_message_box("IPv6设置", f"\nIPv6支持已{status}。新的设置将在下一次下载时生效。\n")
+        msg_box.exec()
+        return True
+        
+    def _create_message_box(self, title, message, buttons=QMessageBox.StandardButton.Ok):
+        """创建统一风格的消息框
+        
+        Args:
+            title: 消息框标题
+            message: 消息内容
+            buttons: 按钮类型，默认为确定按钮
+        
+        Returns:
+            QMessageBox: 配置好的消息框实例
+        """
+        msg_box = msgbox_frame(
+            f"{title} - {APP_NAME}",
+            message,
+            buttons,
+        )
+        return msg_box 

source/core/patch_manager.py

@@ -0,0 +1,391 @@
+import os
+import shutil
+from PySide6.QtWidgets import QMessageBox
+
+class PatchManager:
+    """补丁管理器，用于处理补丁的安装和卸载"""
+    
+    def __init__(self, app_name, game_info, debug_manager=None):
+        """初始化补丁管理器
+        
+        Args:
+            app_name: 应用程序名称，用于显示消息框标题
+            game_info: 游戏信息字典，包含各版本的安装路径和可执行文件名
+            debug_manager: 调试管理器实例，用于输出调试信息
+        """
+        self.app_name = app_name
+        self.game_info = game_info
+        self.debug_manager = debug_manager
+        self.installed_status = {}  # 游戏版本的安装状态
+        
+    def _is_debug_mode(self):
+        """检查是否处于调试模式
+        
+        Returns:
+            bool: 是否处于调试模式
+        """
+        if hasattr(self.debug_manager, 'ui_manager') and hasattr(self.debug_manager.ui_manager, 'debug_action'):
+            return self.debug_manager.ui_manager.debug_action.isChecked()
+        return False
+    
+    def initialize_status(self):
+        """初始化所有游戏版本的安装状态"""
+        self.installed_status = {f"NEKOPARA Vol.{i}": False for i in range(1, 5)}
+        self.installed_status["NEKOPARA After"] = False
+        
+    def update_status(self, game_version, is_installed):
+        """更新游戏版本的安装状态
+        
+        Args:
+            game_version: 游戏版本
+            is_installed: 是否已安装
+        """
+        self.installed_status[game_version] = is_installed
+        
+    def get_status(self, game_version=None):
+        """获取游戏版本的安装状态
+        
+        Args:
+            game_version: 游戏版本，如果为None则返回所有状态
+            
+        Returns:
+            bool或dict: 指定版本的安装状态或所有版本的安装状态
+        """
+        if game_version:
+            return self.installed_status.get(game_version, False)
+        return self.installed_status
+    
+    def uninstall_patch(self, game_dir, game_version, silent=False):
+        """卸载补丁
+        
+        Args:
+            game_dir: 游戏目录路径
+            game_version: 游戏版本
+            silent: 是否静默模式(不显示弹窗)
+            
+        Returns:
+            bool: 卸载成功返回True，失败返回False
+            dict: 在silent=True时，返回包含卸载结果信息的字典
+        """
+        debug_mode = self._is_debug_mode()
+        
+        if game_version not in self.game_info:
+            if not silent:
+                QMessageBox.critical(
+                    None,
+                    f"错误 - {self.app_name}",
+                    f"\n无法识别游戏版本: {game_version}\n",
+                    QMessageBox.StandardButton.Ok,
+                )
+            return False if not silent else {"success": False, "message": f"无法识别游戏版本: {game_version}", "files_removed": 0}
+        
+        if debug_mode:
+            print(f"DEBUG: 开始卸载 {game_version} 补丁，目录: {game_dir}")
+            
+        try:
+            files_removed = 0
+            
+            # 获取可能的补丁文件路径
+            install_path_base = os.path.basename(self.game_info[game_version]["install_path"])
+            patch_file_path = os.path.join(game_dir, install_path_base)
+            
+            # 尝试查找补丁文件，支持不同大小写
+            patch_files_to_check = [
+                patch_file_path,
+                patch_file_path.lower(),
+                patch_file_path.upper(),
+                patch_file_path.replace("_", ""),
+                patch_file_path.replace("_", "-"),
+            ]
+            
+            # 查找并删除补丁文件
+            patch_file_found = False
+            for patch_path in patch_files_to_check:
+                if os.path.exists(patch_path):
+                    patch_file_found = True
+                    os.remove(patch_path)
+                    files_removed += 1
+                    if debug_mode:
+                        print(f"DEBUG: 已删除补丁文件: {patch_path}")
+            
+            if not patch_file_found and debug_mode:
+                print(f"DEBUG: 未找到补丁文件，检查了以下路径: {patch_files_to_check}")
+                
+            # 检查是否有额外的签名文件 (.sig)
+            if game_version == "NEKOPARA After":
+                for patch_path in patch_files_to_check:
+                    sig_file_path = f"{patch_path}.sig"
+                    if os.path.exists(sig_file_path):
+                        os.remove(sig_file_path)
+                        files_removed += 1
+                        if debug_mode:
+                            print(f"DEBUG: 已删除签名文件: {sig_file_path}")
+            
+            # 删除patch文件夹
+            patch_folders_to_check = [
+                os.path.join(game_dir, "patch"),
+                os.path.join(game_dir, "Patch"),
+                os.path.join(game_dir, "PATCH"),
+            ]
+            
+            for patch_folder in patch_folders_to_check:
+                if os.path.exists(patch_folder):
+                    shutil.rmtree(patch_folder)
+                    files_removed += 1
+                    if debug_mode:
+                        print(f"DEBUG: 已删除补丁文件夹: {patch_folder}")
+            
+            # 删除game/patch文件夹
+            game_folders = ["game", "Game", "GAME"]
+            patch_folders = ["patch", "Patch", "PATCH"]
+            
+            for game_folder in game_folders:
+                for patch_folder in patch_folders:
+                    game_patch_folder = os.path.join(game_dir, game_folder, patch_folder)
+                    if os.path.exists(game_patch_folder):
+                        shutil.rmtree(game_patch_folder)
+                        files_removed += 1
+                        if debug_mode:
+                            print(f"DEBUG: 已删除game/patch文件夹: {game_patch_folder}")
+            
+            # 删除配置文件
+            config_files = ["config.json", "Config.json", "CONFIG.JSON"]
+            script_files = ["scripts.json", "Scripts.json", "SCRIPTS.JSON"]
+            
+            for game_folder in game_folders:
+                game_path = os.path.join(game_dir, game_folder)
+                if os.path.exists(game_path):
+                    # 删除配置文件
+                    for config_file in config_files:
+                        config_path = os.path.join(game_path, config_file)
+                        if os.path.exists(config_path):
+                            os.remove(config_path)
+                            files_removed += 1
+                            if debug_mode:
+                                print(f"DEBUG: 已删除配置文件: {config_path}")
+                    
+                    # 删除脚本文件
+                    for script_file in script_files:
+                        script_path = os.path.join(game_path, script_file)
+                        if os.path.exists(script_path):
+                            os.remove(script_path)
+                            files_removed += 1
+                            if debug_mode:
+                                print(f"DEBUG: 已删除脚本文件: {script_path}")
+            
+            # 更新安装状态
+            self.installed_status[game_version] = False
+            
+            # 在非静默模式且非批量卸载模式下显示卸载成功消息
+            if not silent and game_version != "all":
+                # 显示卸载成功消息
+                if files_removed > 0:
+                    QMessageBox.information(
+                        None,
+                        f"卸载完成 - {self.app_name}",
+                        f"\n{game_version} 补丁卸载成功！\n共删除 {files_removed} 个文件/文件夹。\n",
+                        QMessageBox.StandardButton.Ok,
+                    )
+                else:
+                    QMessageBox.warning(
+                        None,
+                        f"警告 - {self.app_name}",
+                        f"\n未找到 {game_version} 的补丁文件，可能未安装补丁或已被移除。\n",
+                        QMessageBox.StandardButton.Ok,
+                    )
+            
+            # 卸载成功
+            if silent:
+                return {"success": True, "message": f"{game_version} 补丁卸载成功", "files_removed": files_removed}
+            return True
+            
+        except Exception as e:
+            # 在非静默模式且非批量卸载模式下显示卸载失败消息
+            if not silent and game_version != "all":
+                # 显示卸载失败消息
+                error_message = f"\n卸载 {game_version} 补丁时出错：\n\n{str(e)}\n"
+                if debug_mode:
+                    print(f"DEBUG: 卸载错误 - {str(e)}")
+                    
+                QMessageBox.critical(
+                    None,
+                    f"卸载失败 - {self.app_name}",
+                    error_message,
+                    QMessageBox.StandardButton.Ok,
+                )
+            
+            # 卸载失败
+            if silent:
+                return {"success": False, "message": f"卸载 {game_version} 补丁时出错: {str(e)}", "files_removed": 0}
+            return False
+    
+    def batch_uninstall_patches(self, game_dirs):
+        """批量卸载多个游戏的补丁
+        
+        Args:
+            game_dirs: 游戏版本到游戏目录的映射字典
+            
+        Returns:
+            tuple: (成功数量, 失败数量, 详细结果列表)
+        """
+        success_count = 0
+        fail_count = 0
+        debug_mode = self._is_debug_mode()
+        results = []
+        
+        for version, path in game_dirs.items():
+            try:
+                # 在批量模式下使用静默卸载
+                result = self.uninstall_patch(path, version, silent=True)
+                
+                if isinstance(result, dict):  # 使用了静默模式
+                    if result["success"]:
+                        success_count += 1
+                    else:
+                        fail_count += 1
+                    results.append({
+                        "version": version,
+                        "success": result["success"],
+                        "message": result["message"],
+                        "files_removed": result["files_removed"]
+                    })
+                else:  # 兼容旧代码，不应该执行到这里
+                    if result:
+                        success_count += 1
+                    else:
+                        fail_count += 1
+                    results.append({
+                        "version": version,
+                        "success": result,
+                        "message": f"{version} 卸载{'成功' if result else '失败'}",
+                        "files_removed": 0
+                    })
+                    
+            except Exception as e:
+                if debug_mode:
+                    print(f"DEBUG: 卸载 {version} 时出错: {str(e)}")
+                fail_count += 1
+                results.append({
+                    "version": version,
+                    "success": False,
+                    "message": f"卸载出错: {str(e)}",
+                    "files_removed": 0
+                })
+                
+        return success_count, fail_count, results
+    
+    def show_uninstall_result(self, success_count, fail_count, results=None):
+        """显示批量卸载结果
+        
+        Args:
+            success_count: 成功卸载的数量
+            fail_count: 卸载失败的数量
+            results: 详细结果列表，如果提供，会显示更详细的信息
+        """
+        result_text = f"\n批量卸载完成！\n成功: {success_count} 个\n失败: {fail_count} 个\n"
+        
+        # 如果有详细结果，添加到消息中
+        if results:
+            success_list = [r["version"] for r in results if r["success"]]
+            fail_list = [r["version"] for r in results if not r["success"]]
+            
+            if success_list:
+                result_text += f"\n【成功卸载】：\n{chr(10).join(success_list)}\n"
+            
+            if fail_list:
+                result_text += f"\n【卸载失败】：\n{chr(10).join(fail_list)}\n"
+        
+        QMessageBox.information(
+            None,
+            f"批量卸载完成 - {self.app_name}",
+            result_text,
+            QMessageBox.StandardButton.Ok,
+        ) 
+
+    def check_patch_installed(self, game_dir, game_version):
+        """检查游戏是否已安装补丁
+        
+        Args:
+            game_dir: 游戏目录路径
+            game_version: 游戏版本
+            
+        Returns:
+            bool: 如果已安装补丁返回True，否则返回False
+        """
+        debug_mode = self._is_debug_mode()
+        
+        if game_version not in self.game_info:
+            return False
+            
+        # 获取可能的补丁文件路径
+        install_path_base = os.path.basename(self.game_info[game_version]["install_path"])
+        patch_file_path = os.path.join(game_dir, install_path_base)
+        
+        # 尝试查找补丁文件，支持不同大小写
+        patch_files_to_check = [
+            patch_file_path,
+            patch_file_path.lower(),
+            patch_file_path.upper(),
+            patch_file_path.replace("_", ""),
+            patch_file_path.replace("_", "-"),
+        ]
+        
+        # 查找补丁文件
+        for patch_path in patch_files_to_check:
+            if os.path.exists(patch_path):
+                if debug_mode:
+                    print(f"DEBUG: 找到补丁文件: {patch_path}")
+                return True
+                
+        # 检查是否有补丁文件夹
+        patch_folders_to_check = [
+            os.path.join(game_dir, "patch"),
+            os.path.join(game_dir, "Patch"),
+            os.path.join(game_dir, "PATCH"),
+        ]
+        
+        for patch_folder in patch_folders_to_check:
+            if os.path.exists(patch_folder):
+                if debug_mode:
+                    print(f"DEBUG: 找到补丁文件夹: {patch_folder}")
+                return True
+                
+        # 检查game/patch文件夹
+        game_folders = ["game", "Game", "GAME"]
+        patch_folders = ["patch", "Patch", "PATCH"]
+        
+        for game_folder in game_folders:
+            for patch_folder in patch_folders:
+                game_patch_folder = os.path.join(game_dir, game_folder, patch_folder)
+                if os.path.exists(game_patch_folder):
+                    if debug_mode:
+                        print(f"DEBUG: 找到game/patch文件夹: {game_patch_folder}")
+                    return True
+        
+        # 检查配置文件
+        config_files = ["config.json", "Config.json", "CONFIG.JSON"]
+        script_files = ["scripts.json", "Scripts.json", "SCRIPTS.JSON"]
+        
+        for game_folder in game_folders:
+            game_path = os.path.join(game_dir, game_folder)
+            if os.path.exists(game_path):
+                # 检查配置文件
+                for config_file in config_files:
+                    config_path = os.path.join(game_path, config_file)
+                    if os.path.exists(config_path):
+                        if debug_mode:
+                            print(f"DEBUG: 找到配置文件: {config_path}")
+                        return True
+                
+                # 检查脚本文件
+                for script_file in script_files:
+                    script_path = os.path.join(game_path, script_file)
+                    if os.path.exists(script_path):
+                        if debug_mode:
+                            print(f"DEBUG: 找到脚本文件: {script_path}")
+                        return True
+        
+        # 没有找到补丁文件或文件夹
+        if debug_mode:
+            print(f"DEBUG: {game_version} 在 {game_dir} 中没有安装补丁")
+        return False 

source/core/privacy_manager.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import json
+from PySide6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QTextBrowser, QPushButton, QCheckBox, QLabel, QMessageBox
+from PySide6.QtCore import Qt
+
+from data.privacy_policy import PRIVACY_POLICY_BRIEF, get_local_privacy_policy, PRIVACY_POLICY_VERSION
+from data.config import CACHE, APP_NAME, APP_VERSION
+from utils import msgbox_frame
+from utils.logger import setup_logger
+
+class PrivacyManager:
+    """隐私协议管理器，负责显示隐私协议对话框并处理用户选择"""
+    
+    def __init__(self):
+        """初始化隐私协议管理器"""
+        # 初始化日志
+        self.logger = setup_logger("privacy_manager")
+        self.logger.info("正在初始化隐私协议管理器")
+        # 确保缓存目录存在
+        os.makedirs(CACHE, exist_ok=True)
+        self.config_file = os.path.join(CACHE, "privacy_config.json")
+        self.privacy_config = self._load_privacy_config()
+        
+        # 获取隐私协议内容和版本
+        self.logger.info("读取本地隐私协议文件")
+        self.privacy_content, self.current_privacy_version, error = get_local_privacy_policy()
+        if error:
+            self.logger.warning(f"读取本地隐私协议文件警告: {error}")
+            # 使用默认版本作为备用
+            self.current_privacy_version = PRIVACY_POLICY_VERSION
+        self.logger.info(f"隐私协议版本: {self.current_privacy_version}")
+            
+        # 检查隐私协议版本和用户同意状态
+        self.privacy_accepted = self._check_privacy_acceptance()
+        
+    def _load_privacy_config(self):
+        """加载隐私协议配置
+        
+        Returns:
+            dict: 隐私协议配置信息
+        """
+        if os.path.exists(self.config_file):
+            try:
+                with open(self.config_file, "r", encoding="utf-8") as f:
+                    config = json.load(f)
+                    return config
+            except (json.JSONDecodeError, IOError) as e:
+                self.logger.error(f"读取隐私配置失败: {e}")
+                # 如果读取失败，返回空配置，强制显示隐私协议
+                return {"privacy_accepted": False}
+        return {"privacy_accepted": False}
+    
+    def _check_privacy_acceptance(self):
+        """检查隐私协议是否需要重新同意
+        
+        如果隐私协议版本变更，则需要重新同意
+        
+        Returns:
+            bool: 是否已有有效的隐私协议同意
+        """
+        # 获取存储的版本信息
+        stored_privacy_version = self.privacy_config.get("privacy_version", "0.0.0")
+        stored_app_version = self.privacy_config.get("app_version", "0.0.0")
+        privacy_accepted = self.privacy_config.get("privacy_accepted", False)
+        
+        self.logger.info(f"存储的隐私协议版本: {stored_privacy_version}, 当前版本: {self.current_privacy_version}")
+        self.logger.info(f"存储的应用版本: {stored_app_version}, 当前版本: {APP_VERSION}")
+        self.logger.info(f"隐私协议接受状态: {privacy_accepted}")
+        
+        # 如果隐私协议版本变更，需要重新同意
+        if stored_privacy_version != self.current_privacy_version:
+            self.logger.info("隐私协议版本已变更，需要重新同意")
+            return False
+            
+        # 返回当前的同意状态
+        return privacy_accepted
+        
+    def _save_privacy_config(self, accepted):
+        """保存隐私协议配置
+        
+        Args:
+            accepted: 用户是否同意隐私协议
+            
+        Returns:
+            bool: 配置是否保存成功
+        """
+        try:
+            # 确保目录存在
+            os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
+            
+            # 写入配置文件，包含应用版本和隐私协议版本
+            with open(self.config_file, "w", encoding="utf-8") as f:
+                json.dump({
+                    "privacy_accepted": accepted,
+                    "privacy_version": self.current_privacy_version,  # 保存当前隐私协议版本
+                    "app_version": APP_VERSION  # 保存当前应用版本
+                }, f, indent=2)
+                
+            # 更新实例变量
+            self.privacy_accepted = accepted
+            self.privacy_config = {
+                "privacy_accepted": accepted,
+                "privacy_version": self.current_privacy_version,
+                "app_version": APP_VERSION
+            }
+            return True
+        except IOError as e:
+            self.logger.error(f"保存隐私协议配置失败: {e}")
+            # 显示保存失败的提示
+            QMessageBox.warning(
+                None,
+                f"配置保存警告 - {APP_NAME}",
+                f"隐私设置无法保存到配置文件，下次启动时可能需要重新确认。\n\n错误信息：{e}"
+            )
+            return False
+    
+    def show_privacy_dialog(self):
+        """显示隐私协议对话框
+        
+        Returns:
+            bool: 用户是否同意隐私协议
+        """
+        # 如果用户已经同意了隐私协议，直接返回True不显示对话框
+        if self.privacy_accepted:
+            self.logger.info("用户已同意当前版本的隐私协议，无需再次显示")
+            return True
+            
+        self.logger.info("首次运行或隐私协议版本变更，显示隐私对话框")
+            
+        # 创建隐私协议对话框
+        dialog = QDialog()
+        dialog.setWindowTitle(f"隐私政策 - {APP_NAME}")
+        dialog.setMinimumSize(600, 400)
+        dialog.setWindowFlags(dialog.windowFlags() & ~Qt.WindowContextHelpButtonHint)
+        
+        # 创建布局
+        layout = QVBoxLayout(dialog)
+        
+        # 添加标题和版本信息
+        title_label = QLabel(f"请阅读并同意以下隐私政策 (更新日期: {self.current_privacy_version})")
+        title_label.setStyleSheet("font-size: 14px; font-weight: bold;")
+        layout.addWidget(title_label)
+        
+        # 添加隐私协议文本框
+        text_browser = QTextBrowser()
+        # 这里使用PRIVACY_POLICY_BRIEF而不是self.privacy_content，保持UI简洁
+        text_browser.setMarkdown(PRIVACY_POLICY_BRIEF)
+        text_browser.setOpenExternalLinks(True)
+        layout.addWidget(text_browser)
+        
+        # 添加同意选择框
+        checkbox = QCheckBox("我已阅读并同意上述隐私政策")
+        layout.addWidget(checkbox)
+        
+        # 添加按钮
+        buttons_layout = QHBoxLayout()
+        agree_button = QPushButton("同意并继续")
+        agree_button.setEnabled(False)  # 初始状态为禁用
+        decline_button = QPushButton("不同意并退出")
+        buttons_layout.addWidget(agree_button)
+        buttons_layout.addWidget(decline_button)
+        layout.addLayout(buttons_layout)
+        
+        # 连接选择框状态变化 - 修复勾选后按钮不亮起的问题
+        def on_checkbox_state_changed(state):
+            self.logger.debug(f"复选框状态变更为: {state}")
+            agree_button.setEnabled(state == 2)  # Qt.Checked 在 PySide6 中值为 2
+            
+        checkbox.stateChanged.connect(on_checkbox_state_changed)
+        
+        # 连接按钮点击事件
+        agree_button.clicked.connect(lambda: self._on_agree(dialog))
+        decline_button.clicked.connect(lambda: self._on_decline(dialog))
+        
+        # 显示对话框
+        result = dialog.exec()
+        
+        # 返回用户选择结果
+        return self.privacy_accepted
+        
+    def _on_agree(self, dialog):
+        """处理用户同意隐私协议
+        
+        Args:
+            dialog: 对话框实例
+        """
+        # 保存配置并更新状态
+        self._save_privacy_config(True)
+        dialog.accept()
+        
+    def _on_decline(self, dialog):
+        """处理用户拒绝隐私协议
+        
+        Args:
+            dialog: 对话框实例
+        """
+        # 显示拒绝信息
+        msg_box = msgbox_frame(
+            f"退出 - {APP_NAME}",
+            "\n您需要同意隐私政策才能使用本软件。\n软件将立即退出。\n",
+            QMessageBox.Ok,
+        )
+        msg_box.exec()
+        
+        # 保存拒绝状态
+        self._save_privacy_config(False)
+        dialog.reject()
+        
+    def is_privacy_accepted(self):
+        """检查用户是否已同意隐私协议
+        
+        Returns:
+            bool: 用户是否已同意隐私协议
+        """
+        return self.privacy_accepted
+        
+    def reset_privacy_agreement(self):
+        """重置隐私协议同意状态，用于测试或重新显示隐私协议
+        
+        Returns:
+            bool: 重置是否成功
+        """
+        return self._save_privacy_config(False) 

source/core/ui_manager.py

@@ -1,10 +1,12 @@
-from PySide6.QtGui import QIcon, QAction, QFont
-from PySide6.QtWidgets import QMessageBox, QMainWindow
-from PySide6.QtCore import Qt
+from PySide6.QtGui import QIcon, QAction, QFont, QCursor
+from PySide6.QtWidgets import QMessageBox, QMainWindow, QMenu, QPushButton
+from PySide6.QtCore import Qt, QRect
 import webbrowser
+import os
 
-from utils import load_base64_image, msgbox_frame
-from data.config import APP_NAME, APP_VERSION
+from utils import load_base64_image, msgbox_frame, resource_path
+from data.config import APP_NAME, APP_VERSION, LOG_FILE
+from core.ipv6_manager import IPv6Manager  # 导入新的IPv6Manager类
 
 class UIManager:
     def __init__(self, main_window):
@@ -17,6 +19,14 @@ class UIManager:
         # 使用getattr获取ui属性，如果不存在则为None
         self.ui = getattr(main_window, 'ui', None)
         self.debug_action = None
+        self.turbo_download_action = None
+        self.dev_menu = None
+        self.privacy_menu = None  # 隐私协议菜单
+        self.about_menu = None    # 关于菜单
+        self.about_btn = None     # 关于按钮
+        
+        # 获取主窗口的IPv6Manager实例
+        self.ipv6_manager = getattr(main_window, 'ipv6_manager', None)
         
     def setup_ui(self):
         """设置UI元素，包括窗口图标、标题和菜单"""
@@ -30,38 +40,320 @@ class UIManager:
         # 设置窗口标题
         self.main_window.setWindowTitle(f"{APP_NAME} v{APP_VERSION}")
         
+        # 创建关于按钮
+        self._create_about_button()
+        
         # 设置菜单
         self._setup_help_menu()
+        self._setup_about_menu()  # 新增关于菜单
         self._setup_settings_menu()
     
+    def _create_about_button(self):
+        """创建"关于"按钮"""
+        if not self.ui or not hasattr(self.ui, 'menu_area'):
+            return
+            
+        # 获取菜单字体和样式
+        menu_font = self._get_menu_font()
+        
+        # 创建关于按钮
+        self.about_btn = QPushButton("关于", self.ui.menu_area)
+        self.about_btn.setObjectName(u"about_btn")
+        
+        # 获取帮助按钮的位置和样式
+        help_btn_x = 0
+        help_btn_width = 0
+        if hasattr(self.ui, 'help_btn'):
+            help_btn_x = self.ui.help_btn.x()
+            help_btn_width = self.ui.help_btn.width()
+            
+        # 设置位置在"帮助"按钮右侧
+        self.about_btn.setGeometry(QRect(help_btn_x + help_btn_width + 20, 1, 80, 28))
+        self.about_btn.setFont(menu_font)
+        self.about_btn.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
+        
+        # 复制帮助按钮的样式
+        if hasattr(self.ui, 'help_btn'):
+            self.about_btn.setStyleSheet(self.ui.help_btn.styleSheet())
+        else:
+            # 默认样式
+            self.about_btn.setStyleSheet("""
+                QPushButton {
+                    background-color: transparent;
+                    color: white;
+                    border: none;
+                    text-align: left;
+                    padding-left: 10px;
+                }
+                QPushButton:hover {
+                    background-color: #F47A5B;
+                    border-radius: 4px;
+                }
+                QPushButton:pressed {
+                    background-color: #D25A3C;
+                    border-radius: 4px;
+                }
+            """)
+    
     def _setup_help_menu(self):
         """设置"帮助"菜单"""
         if not self.ui or not hasattr(self.ui, 'menu_2'):
             return
 
-        # 创建菜单项
-        project_home_action = QAction("项目主页", self.main_window)
-        project_home_action.triggered.connect(self.open_project_home_page)
+        # 获取菜单字体
+        menu_font = self._get_menu_font()
+
+        # 创建菜单项 - 移除"项目主页"，添加"常见问题"和"提交错误"
+        faq_action = QAction("常见问题", self.main_window)
+        faq_action.triggered.connect(self.open_faq_page)
+        faq_action.setFont(menu_font)
         
-        about_action = QAction("关于", self.main_window)
-        about_action.triggered.connect(self.show_about_dialog)
+        report_issue_action = QAction("提交错误", self.main_window)
+        report_issue_action.triggered.connect(self.open_issues_page)
+        report_issue_action.setFont(menu_font)
         
-        # 添加到菜单
-        self.ui.menu_2.addAction(project_home_action)
-        self.ui.menu_2.addAction(about_action)
+        # 清除现有菜单项并添加新的菜单项
+        self.ui.menu_2.clear()
+        self.ui.menu_2.addAction(faq_action)
+        self.ui.menu_2.addAction(report_issue_action)
         
         # 连接按钮点击事件，如果使用按钮式菜单
         if hasattr(self.ui, 'help_btn'):
             # 按钮已经连接到显示菜单，不需要额外处理
             pass
+
+    def _setup_about_menu(self):
+        """设置"关于"菜单"""
+        # 获取菜单字体
+        menu_font = self._get_menu_font()
+        
+        # 创建关于菜单
+        self.about_menu = QMenu("关于", self.main_window)
+        self.about_menu.setFont(menu_font)
+        
+        # 设置菜单样式
+        font_family = menu_font.family()
+        menu_style = self._get_menu_style(font_family)
+        self.about_menu.setStyleSheet(menu_style)
+        
+        # 创建菜单项
+        about_project_action = QAction("关于本项目", self.main_window)
+        about_project_action.setFont(menu_font)
+        about_project_action.triggered.connect(self.show_about_dialog)
+        
+        # 添加项目主页选项（从帮助菜单移动过来）
+        project_home_action = QAction("Github项目主页", self.main_window)
+        project_home_action.setFont(menu_font)
+        project_home_action.triggered.connect(self.open_project_home_page)
+        
+        # 添加加入QQ群选项
+        qq_group_action = QAction("加入QQ群", self.main_window)
+        qq_group_action.setFont(menu_font)
+        qq_group_action.triggered.connect(self.open_qq_group)
+        
+        # 创建隐私协议菜单
+        self._setup_privacy_menu()
+        
+        # 添加到关于菜单
+        self.about_menu.addAction(about_project_action)
+        self.about_menu.addAction(project_home_action)
+        self.about_menu.addAction(qq_group_action)
+        self.about_menu.addSeparator()
+        self.about_menu.addMenu(self.privacy_menu)
+        
+        # 连接按钮点击事件
+        if self.about_btn:
+            self.about_btn.clicked.connect(lambda: self.show_menu(self.about_menu, self.about_btn))
+    
+    def _setup_privacy_menu(self):
+        """设置"隐私协议"菜单"""
+        # 获取菜单字体
+        menu_font = self._get_menu_font()
+        
+        # 创建隐私协议子菜单
+        self.privacy_menu = QMenu("隐私协议", self.main_window)
+        self.privacy_menu.setFont(menu_font)
+        
+        # 设置与其他菜单一致的样式
+        font_family = menu_font.family()
+        menu_style = self._get_menu_style(font_family)
+        self.privacy_menu.setStyleSheet(menu_style)
+        
+        # 添加子选项
+        view_privacy_action = QAction("查看完整隐私协议", self.main_window)
+        view_privacy_action.setFont(menu_font)
+        view_privacy_action.triggered.connect(self.open_privacy_policy)
+        
+        revoke_privacy_action = QAction("撤回隐私协议", self.main_window)
+        revoke_privacy_action.setFont(menu_font)
+        revoke_privacy_action.triggered.connect(self.revoke_privacy_agreement)
+        
+        # 添加到子菜单
+        self.privacy_menu.addAction(view_privacy_action)
+        self.privacy_menu.addAction(revoke_privacy_action)
+
+    def _get_menu_style(self, font_family):
+        """获取统一的菜单样式"""
+        return f"""
+            QMenu {{
+                background-color: #E96948;
+                color: white;
+                font-family: "{font_family}";
+                font-size: 14px;
+                font-weight: bold;
+                border: 1px solid #F47A5B;
+                padding: 8px;
+                border-radius: 6px;
+                margin-top: 2px;
+            }}
+            QMenu::item {{
+                padding: 6px 20px 6px 15px;
+                background-color: transparent;
+                min-width: 120px;
+                color: white;
+                font-family: "{font_family}";
+                font-size: 14px;
+                font-weight: bold;
+            }}
+            QMenu::item:selected {{
+                background-color: #F47A5B;
+                border-radius: 4px;
+            }}
+            QMenu::separator {{
+                height: 1px;
+                background-color: #F47A5B;
+                margin: 5px 15px;
+            }}
+            QMenu::item:checked {{
+                background-color: #D25A3C;
+                border-radius: 4px;
+            }}
+        """
+
+    def _get_menu_font(self):
+        """获取菜单字体"""
+        font_family = "Arial"  # 默认字体族
+        
+        try:
+            from PySide6.QtGui import QFontDatabase
+            
+            # 尝试加载字体
+            font_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "fonts", "SmileySans-Oblique.ttf")
+            if os.path.exists(font_path):
+                font_id = QFontDatabase.addApplicationFont(font_path)
+                if font_id != -1:
+                    font_family = QFontDatabase.applicationFontFamilies(font_id)[0]
+            
+            # 创建菜单字体
+            menu_font = QFont(font_family, 14)
+            menu_font.setBold(True)
+            return menu_font
+            
+        except Exception as e:
+            print(f"加载字体失败: {e}")
+            # 返回默认字体
+            menu_font = QFont(font_family, 14)
+            menu_font.setBold(True)
+            return menu_font
     
     def _setup_settings_menu(self):
         """设置"设置"菜单"""
         if not self.ui or not hasattr(self.ui, 'menu'):
             return
 
-        # 创建菜单项
-        self.debug_action = QAction("Debug模式", self.main_window, checkable=True)
+        # 获取菜单字体
+        menu_font = self._get_menu_font()
+        font_family = menu_font.family()
+
+        # 创建开发者选项子菜单
+        self.dev_menu = QMenu("开发者选项", self.main_window)
+        self.dev_menu.setFont(menu_font)  # 设置与UI_install.py中相同的字体
+        
+        # 使用和主菜单相同的样式
+        menu_style = self._get_menu_style(font_family)
+        self.dev_menu.setStyleSheet(menu_style)
+        
+        # 创建Debug子菜单
+        self.debug_submenu = QMenu("Debug模式", self.main_window)
+        self.debug_submenu.setFont(menu_font)
+        self.debug_submenu.setStyleSheet(menu_style)
+        
+        # 创建hosts文件选项子菜单
+        self.hosts_submenu = QMenu("hosts文件选项", self.main_window)
+        self.hosts_submenu.setFont(menu_font)
+        self.hosts_submenu.setStyleSheet(menu_style)
+        
+        # 添加IPv6支持选项
+        self.ipv6_action = QAction("启用IPv6支持", self.main_window, checkable=True)
+        self.ipv6_action.setFont(menu_font)
+        
+        # 添加IPv6检测按钮，用于显示详细信息
+        self.ipv6_test_action = QAction("测试IPv6连接", self.main_window)
+        self.ipv6_test_action.setFont(menu_font)
+        if self.ipv6_manager:
+            self.ipv6_test_action.triggered.connect(self.ipv6_manager.show_ipv6_details)
+        else:
+            self.ipv6_test_action.triggered.connect(self.show_ipv6_manager_not_ready)
+        
+        # 创建IPv6支持子菜单
+        self.ipv6_submenu = QMenu("IPv6支持", self.main_window)
+        self.ipv6_submenu.setFont(menu_font)
+        self.ipv6_submenu.setStyleSheet(menu_style)
+        
+        # 检查IPv6是否可用
+        ipv6_available = False
+        if self.ipv6_manager:
+            ipv6_available = self.ipv6_manager.check_ipv6_availability()
+        
+        if not ipv6_available:
+            self.ipv6_action.setText("启用IPv6支持 (不可用)")
+            self.ipv6_action.setEnabled(False)
+            self.ipv6_action.setToolTip("未检测到可用的IPv6连接")
+        
+        # 检查配置中是否已启用IPv6
+        config = getattr(self.main_window, 'config', {})
+        ipv6_enabled = False
+        if isinstance(config, dict):
+            ipv6_enabled = config.get("ipv6_enabled", False)
+            # 如果配置中启用了IPv6但实际不可用，则强制禁用
+            if ipv6_enabled and not ipv6_available:
+                config["ipv6_enabled"] = False
+                ipv6_enabled = False
+                # 使用utils.save_config直接保存配置
+                from utils import save_config
+                save_config(config)
+        
+        self.ipv6_action.setChecked(ipv6_enabled)
+        
+        # 连接IPv6支持切换事件
+        self.ipv6_action.triggered.connect(self._handle_ipv6_toggle)
+        
+        # 将选项添加到IPv6子菜单
+        self.ipv6_submenu.addAction(self.ipv6_action)
+        self.ipv6_submenu.addAction(self.ipv6_test_action)
+        
+        # 添加hosts子选项
+        self.restore_hosts_action = QAction("还原软件备份的hosts文件", self.main_window)
+        self.restore_hosts_action.setFont(menu_font)
+        self.restore_hosts_action.triggered.connect(self.restore_hosts_backup)
+        
+        self.clean_hosts_action = QAction("手动删除软件添加的hosts条目", self.main_window)
+        self.clean_hosts_action.setFont(menu_font)
+        self.clean_hosts_action.triggered.connect(self.clean_hosts_entries)
+        
+        # 添加打开hosts文件选项
+        self.open_hosts_action = QAction("打开hosts文件", self.main_window)
+        self.open_hosts_action.setFont(menu_font)
+        self.open_hosts_action.triggered.connect(self.open_hosts_file)
+        
+        # 添加到hosts子菜单
+        self.hosts_submenu.addAction(self.restore_hosts_action)
+        self.hosts_submenu.addAction(self.clean_hosts_action)
+        self.hosts_submenu.addAction(self.open_hosts_action)
+        
+        # 创建Debug开关选项
+        self.debug_action = QAction("Debug开关", self.main_window, checkable=True)
+        self.debug_action.setFont(menu_font)
         
         # 安全地获取config属性
         config = getattr(self.main_window, 'config', {})
@@ -74,33 +366,298 @@ class UIManager:
         # 安全地连接toggle_debug_mode方法
         if hasattr(self.main_window, 'toggle_debug_mode'):
             self.debug_action.triggered.connect(self.main_window.toggle_debug_mode)
-            
-        # 添加到菜单
-        self.ui.menu.addAction(self.debug_action)
-
-        # 为未来功能预留的"切换下载源"按钮
-        self.switch_source_action = QAction("切换下载源", self.main_window)
-        self.switch_source_action.setEnabled(False)  # 暂时禁用
-        self.ui.menu.addAction(self.switch_source_action)
         
-        # 添加分隔符
+        # 创建打开log文件选项
+        self.open_log_action = QAction("打开log.txt", self.main_window)
+        self.open_log_action.setFont(menu_font)
+        # 初始状态根据debug模式设置启用状态
+        self.open_log_action.setEnabled(debug_mode)
+        
+        # 连接打开log文件的事件
+        self.open_log_action.triggered.connect(self.open_log_file)
+        
+        # 添加到Debug子菜单
+        self.debug_submenu.addAction(self.debug_action)
+        self.debug_submenu.addAction(self.open_log_action)
+        
+        # 创建下载设置子菜单
+        self.download_settings_menu = QMenu("下载设置", self.main_window)
+        self.download_settings_menu.setFont(menu_font)
+        self.download_settings_menu.setStyleSheet(menu_style)
+        
+        # "修改下载源"按钮移至下载设置菜单
+        self.switch_source_action = QAction("修改下载源", self.main_window)
+        self.switch_source_action.setFont(menu_font)
+        self.switch_source_action.setEnabled(True)
+        self.switch_source_action.triggered.connect(self.show_under_development)
+        
+        # 添加下载线程设置选项
+        self.thread_settings_action = QAction("下载线程设置", self.main_window)
+        self.thread_settings_action.setFont(menu_font)
+        # 连接到下载线程设置对话框
+        self.thread_settings_action.triggered.connect(self.show_download_thread_settings)
+        
+        # 添加到下载设置子菜单
+        self.download_settings_menu.addAction(self.switch_source_action)
+        self.download_settings_menu.addAction(self.thread_settings_action)
+        
+        # 添加到主菜单
+        self.ui.menu.addMenu(self.download_settings_menu)  # 添加下载设置子菜单
         self.ui.menu.addSeparator()
+        self.ui.menu.addMenu(self.dev_menu)  # 添加开发者选项子菜单
         
-        # 连接按钮点击事件，如果使用按钮式菜单
-        if hasattr(self.ui, 'settings_btn'):
-            # 按钮已经连接到显示菜单，不需要额外处理
-            pass
+        # 添加Debug子菜单到开发者选项菜单
+        self.dev_menu.addMenu(self.debug_submenu)
+        self.dev_menu.addMenu(self.hosts_submenu) # 添加hosts文件选项子菜单
+        self.dev_menu.addMenu(self.ipv6_submenu)  # 添加IPv6支持子菜单
+        
+    def _handle_ipv6_toggle(self, enabled):
+        """处理IPv6支持切换事件
+        
+        Args:
+            enabled: 是否启用IPv6支持
+        """
+        if not self.ipv6_manager:
+            # 显示错误提示
+            msg_box = self._create_message_box("错误", "\nIPv6管理器尚未初始化，请稍后再试。\n")
+            msg_box.exec()
+            # 恢复复选框状态
+            self.ipv6_action.setChecked(not enabled)
+            return
+            
+        # 使用IPv6Manager处理切换
+        success = self.ipv6_manager.toggle_ipv6_support(enabled)
+        # 如果切换失败，恢复复选框状态
+        if not success:
+            self.ipv6_action.setChecked(not enabled)
+
+    def show_menu(self, menu, button):
+        """显示菜单
+        
+        Args:
+            menu: 要显示的菜单
+            button: 触发菜单的按钮
+        """
+        # 检查Ui_install中是否定义了show_menu方法
+        if hasattr(self.ui, 'show_menu'):
+            # 如果存在，使用UI中定义的方法
+            self.ui.show_menu(menu, button)
+        else:
+            # 否则，使用默认的弹出方法
+            global_pos = button.mapToGlobal(button.rect().bottomLeft())
+            menu.popup(global_pos)
 
     def open_project_home_page(self):
         """打开项目主页"""
         webbrowser.open("https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT")
+        
+    def open_github_page(self):
+        """打开项目GitHub页面"""
+        webbrowser.open("https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT")
+    
+    def open_faq_page(self):
+        """打开常见问题页面"""
+        import locale
+        # 根据系统语言选择FAQ页面
+        system_lang = locale.getdefaultlocale()[0]
+        if system_lang and system_lang.startswith('zh'):
+            webbrowser.open("https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/blob/master/FAQ.md")
+        else:
+            webbrowser.open("https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/blob/master/FAQ-en.md")
+    
+    def open_issues_page(self):
+        """打开GitHub问题页面"""
+        webbrowser.open("https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/issues")
+    
+    def open_qq_group(self):
+        """打开QQ群链接"""
+        webbrowser.open("https://qm.qq.com/q/g9i04i5eec")
+        
+    def open_privacy_policy(self):
+        """打开完整隐私协议（在GitHub上）"""
+        webbrowser.open("https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/blob/master/PRIVACY.md")
+
+    def revoke_privacy_agreement(self):
+        """撤回隐私协议同意，并重启软件"""
+        # 创建确认对话框
+        msg_box = self._create_message_box(
+            "确认操作",
+            "\n您确定要撤回隐私协议同意吗？\n\n撤回后软件将立即重启，您需要重新阅读并同意隐私协议。\n",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+        )
+        
+        reply = msg_box.exec()
+        if reply == QMessageBox.StandardButton.Yes:
+            # 用户确认撤回
+            try:
+                # 导入隐私管理器
+                from core.privacy_manager import PrivacyManager
+                import sys
+                import subprocess
+                import os
+                
+                # 创建实例并重置隐私协议同意
+                privacy_manager = PrivacyManager()
+                if privacy_manager.reset_privacy_agreement():
+                    # 显示重启提示
+                    restart_msg = self._create_message_box(
+                        "操作成功",
+                        "\n已成功撤回隐私协议同意。\n\n软件将立即重启。\n"
+                    )
+                    restart_msg.exec()
+                    
+                    # 获取当前执行的Python解释器路径和脚本路径
+                    python_executable = sys.executable
+                    script_path = os.path.abspath(sys.argv[0])
+                    
+                    # 构建重启命令
+                    restart_cmd = [python_executable, script_path]
+                    
+                    # 启动新进程
+                    subprocess.Popen(restart_cmd)
+                    
+                    # 退出当前进程
+                    sys.exit(0)
+                else:
+                    # 显示失败提示
+                    fail_msg = self._create_message_box(
+                        "操作失败",
+                        "\n撤回隐私协议同意失败。\n\n请检查应用权限或稍后再试。\n"
+                    )
+                    fail_msg.exec()
+            except Exception as e:
+                # 显示错误提示
+                error_msg = self._create_message_box(
+                    "错误",
+                    f"\n撤回隐私协议同意时发生错误：\n\n{str(e)}\n"
+                )
+                error_msg.exec()
+
+    def _create_message_box(self, title, message, buttons=QMessageBox.StandardButton.Ok):
+        """创建统一风格的消息框
+
+        Args:
+            title: 消息框标题
+            message: 消息内容
+            buttons: 按钮类型，默认为确定按钮
+
+        Returns:
+            QMessageBox: 配置好的消息框实例
+        """
+        msg_box = msgbox_frame(
+            f"{title} - {APP_NAME}",
+            message,
+            buttons,
+        )
+        return msg_box
+        
+    def show_under_development(self):
+        """显示功能正在开发中的提示"""
+        msg_box = self._create_message_box("提示", "\n该功能正在开发中，敬请期待！\n")
+        msg_box.exec()
+        
+    def show_download_thread_settings(self):
+        """显示下载线程设置对话框"""
+        if hasattr(self.main_window, 'download_manager'):
+            self.main_window.download_manager.show_download_thread_settings()
+        else:
+            # 如果下载管理器不可用，显示错误信息
+            msg_box = self._create_message_box("错误", "\n下载管理器未初始化，无法修改下载线程设置。\n")
+            msg_box.exec()
+        
+    def open_log_file(self):
+        """打开log.txt文件"""
+        try:
+            # 使用操作系统默认程序打开日志文件
+            if os.name == 'nt':  # Windows
+                os.startfile(LOG_FILE)
+            else:  # macOS 和 Linux
+                import subprocess
+                subprocess.call(['xdg-open', LOG_FILE])
+        except Exception as e:
+            msg_box = self._create_message_box("错误", f"\n打开log.txt文件失败：\n\n{str(e)}\n")
+            msg_box.exec()
+            
+    def restore_hosts_backup(self):
+        """还原软件备份的hosts文件"""
+        if hasattr(self.main_window, 'download_manager') and hasattr(self.main_window.download_manager, 'hosts_manager'):
+            try:
+                # 调用恢复hosts文件的方法
+                result = self.main_window.download_manager.hosts_manager.restore()
+                
+                if result:
+                    msg_box = self._create_message_box("成功", "\nhosts文件已成功还原为备份版本。\n")
+                else:
+                    msg_box = self._create_message_box("警告", "\n还原hosts文件失败或没有找到备份文件。\n")
+                
+                msg_box.exec()
+            except Exception as e:
+                msg_box = self._create_message_box("错误", f"\n还原hosts文件时发生错误：\n\n{str(e)}\n")
+                msg_box.exec()
+        else:
+            msg_box = self._create_message_box("错误", "\n无法访问hosts管理器。\n")
+            msg_box.exec()
+            
+    def clean_hosts_entries(self):
+        """手动删除软件添加的hosts条目"""
+        if hasattr(self.main_window, 'download_manager') and hasattr(self.main_window.download_manager, 'hosts_manager'):
+            try:
+                # 调用清理hosts条目的方法
+                result = self.main_window.download_manager.hosts_manager.check_and_clean_all_entries()
+                
+                if result:
+                    msg_box = self._create_message_box("成功", "\n已成功清理软件添加的hosts条目。\n")
+                else:
+                    msg_box = self._create_message_box("提示", "\n未发现软件添加的hosts条目或清理操作失败。\n")
+                
+                msg_box.exec()
+            except Exception as e:
+                msg_box = self._create_message_box("错误", f"\n清理hosts条目时发生错误：\n\n{str(e)}\n")
+                msg_box.exec()
+        else:
+            msg_box = self._create_message_box("错误", "\n无法访问hosts管理器。\n")
+            msg_box.exec()
+
+    def open_hosts_file(self):
+        """打开系统hosts文件"""
+        try:
+            # 获取hosts文件路径
+            hosts_path = os.path.join(os.environ['SystemRoot'], 'System32', 'drivers', 'etc', 'hosts')
+            
+            # 检查文件是否存在
+            if os.path.exists(hosts_path):
+                # 使用操作系统默认程序打开hosts文件
+                if os.name == 'nt':  # Windows
+                    # 尝试以管理员权限打开记事本编辑hosts文件
+                    try:
+                        # 使用PowerShell以管理员身份启动记事本
+                        subprocess.Popen(["powershell", "Start-Process", "notepad", hosts_path, "-Verb", "RunAs"])
+                    except Exception as e:
+                        # 如果失败，尝试直接打开
+                        os.startfile(hosts_path)
+                else:  # macOS 和 Linux
+                    import subprocess
+                    subprocess.call(['xdg-open', hosts_path])
+            else:
+                msg_box = self._create_message_box("错误", f"\nhosts文件不存在：\n{hosts_path}\n")
+                msg_box.exec()
+        except Exception as e:
+            msg_box = self._create_message_box("错误", f"\n打开hosts文件时发生错误：\n\n{str(e)}\n")
+            msg_box.exec()
 
     def show_about_dialog(self):
         """显示关于对话框"""
         about_text = f"""
             <p><b>{APP_NAME} v{APP_VERSION}</b></p>
+            <p>GitHub: <a href="https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT">https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT</a></p>
             <p>原作: <a href="https://github.com/Yanam1Anna">Yanam1Anna</a></p>
-            <p>此应用根据 <a href="https://github.com/hyb-oyqq/FRAISEMOE2-Installer/blob/master/LICENSE">GPL-3.0 许可证</a> 授权。</p>
+            <p>此应用根据 <a href="https://github.com/hyb-oyqq/FRAISEMOE-Addons-Installer-NEXT/blob/master/LICENSE">GPL-3.0 许可证</a> 授权。</p>
+            <br>
+            <p><b>感谢:</b></p>
+            <p>- <a href="https://github.com/HTony03">HTony03</a>：对原项目部分源码的重构、逻辑优化和功能实现提供了支持。</p>
+            <p>- <a href="https://github.com/ABSIDIA">钨鸮</a>：对于云端资源存储提供了支持。</p>
+            <p>- <a href="https://github.com/XIU2/CloudflareSpeedTest">XIU2/CloudflareSpeedTest</a>：提供了 IP 优选功能的核心支持。</p>
+            <p>- <a href="https://github.com/hosxy/aria2-fast">hosxy/aria2-fast</a>：提供了修改版aria2c，提高了下载速度和性能。</p>
         """
         msg_box = msgbox_frame(
             f"关于 - {APP_NAME}",
@@ -108,4 +665,9 @@ class UIManager:
             QMessageBox.StandardButton.Ok,
         )
         msg_box.setTextFormat(Qt.TextFormat.RichText)  # 使用Qt.TextFormat
+        msg_box.exec() 
+
+    def show_ipv6_manager_not_ready(self):
+        """显示IPv6管理器未准备好的提示"""
+        msg_box = self._create_message_box("错误", "\nIPv6管理器尚未初始化，请稍后再试。\n")
         msg_box.exec() 

source/core/window_manager.py

@@ -0,0 +1,141 @@
+from PySide6.QtCore import Qt, QPoint, QRect, QSize
+from PySide6.QtGui import QPainterPath, QRegion
+
+class WindowManager:
+    """窗口管理器类，用于处理窗口的基本行为，如拖拽、调整大小和圆角设置"""
+    
+    def __init__(self, parent_window):
+        """初始化窗口管理器
+        
+        Args:
+            parent_window: 父窗口实例
+        """
+        self.window = parent_window
+        self.ui = parent_window.ui
+        
+        # 拖动窗口相关变量
+        self._drag_position = QPoint()
+        self._is_dragging = False
+        
+        # 窗口比例
+        self.aspect_ratio = 16 / 9
+        self.updateRoundedCorners = True
+        
+        # 设置圆角窗口
+        self.setRoundedCorners()
+    
+    def setRoundedCorners(self):
+        """设置窗口圆角"""
+        # 实现圆角窗口
+        path = QPainterPath()
+        path.addRoundedRect(self.window.rect(), 20, 20)
+        mask = QRegion(path.toFillPolygon().toPolygon())
+        self.window.setMask(mask)
+        
+        # 更新resize事件时更新圆角
+        self.updateRoundedCorners = True
+    
+    def handle_mouse_press(self, event):
+        """处理鼠标按下事件
+        
+        Args:
+            event: 鼠标事件
+        """
+        if event.button() == Qt.MouseButton.LeftButton:
+            # 只有当鼠标在标题栏区域时才可以拖动
+            if hasattr(self.ui, 'title_bar') and self.ui.title_bar.geometry().contains(event.position().toPoint()):
+                self._is_dragging = True
+                self._drag_position = event.globalPosition().toPoint() - self.window.frameGeometry().topLeft()
+            event.accept()
+    
+    def handle_mouse_move(self, event):
+        """处理鼠标移动事件
+        
+        Args:
+            event: 鼠标事件
+        """
+        if event.buttons() & Qt.MouseButton.LeftButton and self._is_dragging:
+            self.window.move(event.globalPosition().toPoint() - self._drag_position)
+            event.accept()
+    
+    def handle_mouse_release(self, event):
+        """处理鼠标释放事件
+        
+        Args:
+            event: 鼠标事件
+        """
+        if event.button() == Qt.MouseButton.LeftButton:
+            self._is_dragging = False
+            event.accept()
+    
+    def handle_resize(self, event):
+        """当窗口大小改变时更新圆角和维持纵横比
+        
+        Args:
+            event: 窗口大小改变事件
+        """
+        # 计算基于当前宽度的合适高度，以维持16:9比例
+        new_width = event.size().width()
+        new_height = int(new_width / self.aspect_ratio)
+        
+        if new_height != event.size().height():
+            # 阻止变形，保持比例
+            self.window.resize(new_width, new_height)
+        
+        # 更新主容器大小
+        if hasattr(self.ui, 'main_container'):
+            self.ui.main_container.setGeometry(0, 0, new_width, new_height)
+            
+        # 更新内容容器大小    
+        if hasattr(self.ui, 'content_container'):
+            self.ui.content_container.setGeometry(0, 0, new_width, new_height)
+            
+        # 更新标题栏宽度和高度
+        if hasattr(self.ui, 'title_bar'):
+            self.ui.title_bar.setGeometry(0, 0, new_width, 35)
+        
+        # 更新菜单区域
+        if hasattr(self.ui, 'menu_area'):
+            self.ui.menu_area.setGeometry(0, 35, new_width, 30)
+            
+        # 更新内容区域大小
+        if hasattr(self.ui, 'inner_content'):
+            self.ui.inner_content.setGeometry(0, 65, new_width, new_height - 65)
+            
+        # 更新背景图大小
+        if hasattr(self.ui, 'Mainbg'):
+            self.ui.Mainbg.setGeometry(0, 0, new_width, new_height - 65)
+            
+        if hasattr(self.ui, 'loadbg'):
+            self.ui.loadbg.setGeometry(0, 0, new_width, new_height - 65)
+            
+        # 调整按钮位置 - 固定在右侧
+        right_margin = 20  # 减小右边距，使按钮更靠右
+        if hasattr(self.ui, 'button_container'):
+            btn_width = 211  # 扩大后的容器宽度
+            btn_height = 111  # 扩大后的容器高度
+            x_pos = new_width - btn_width - right_margin
+            y_pos = int((new_height - 65) * 0.28) - 10  # 调整为更靠上的位置
+            self.ui.button_container.setGeometry(x_pos, y_pos, btn_width, btn_height)
+            
+        # 添加卸载补丁按钮容器的位置调整
+        if hasattr(self.ui, 'uninstall_container'):
+            btn_width = 211  # 扩大后的容器宽度
+            btn_height = 111  # 扩大后的容器高度
+            x_pos = new_width - btn_width - right_margin
+            y_pos = int((new_height - 65) * 0.46) - 10  # 调整为中间位置
+            self.ui.uninstall_container.setGeometry(x_pos, y_pos, btn_width, btn_height)
+            
+        if hasattr(self.ui, 'exit_container'):
+            btn_width = 211  # 扩大后的容器宽度
+            btn_height = 111  # 扩大后的容器高度
+            x_pos = new_width - btn_width - right_margin
+            y_pos = int((new_height - 65) * 0.64) - 10  # 调整为更靠下的位置
+            self.ui.exit_container.setGeometry(x_pos, y_pos, btn_width, btn_height)
+            
+        # 更新圆角
+        if hasattr(self, 'updateRoundedCorners') and self.updateRoundedCorners:
+            path = QPainterPath()
+            path.addRoundedRect(self.window.rect(), 20, 20)
+            mask = QRegion(path.toFillPolygon().toPolygon())
+            self.window.setMask(mask) 

source/data/config.py

@@ -3,7 +3,7 @@ import base64
 
 # 配置信息
 app_data = {
-    "APP_VERSION": "1.1.3",
+    "APP_VERSION": "1.3.1",
     "APP_NAME": "FRAISEMOE Addons Installer NEXT",
     "TEMP": "TEMP",
     "CACHE": "FRAISEMOE",
@@ -63,4 +63,16 @@ GAME_INFO = app_data["game_info"]
 BLOCK_SIZE = 67108864
 HASH_SIZE = 134217728
 PLUGIN_HASH = {game: info["hash"] for game, info in GAME_INFO.items()}
-PROCESS_INFO = {info["exe"]: game for game, info in GAME_INFO.items()}
+PROCESS_INFO = {info["exe"]: game for game, info in GAME_INFO.items()}
+
+# 下载线程档位设置
+DOWNLOAD_THREADS = {
+    "low": 1,      # 低速
+    "medium": 8,   # 中速（默认）
+    "high": 16,    # 高速
+    "extreme": 32, # 极速
+    "insane": 64   # 狂暴
+}
+
+# 默认下载线程档位
+DEFAULT_DOWNLOAD_THREAD_LEVEL = "high"

source/data/privacy_policy.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+import re
+import sys
+from datetime import datetime
+
+# 隐私协议的缩略版内容
+PRIVACY_POLICY_BRIEF = """
+# FRAISEMOE Addons Installer NEXT 隐私政策摘要
+
+本应用在运行过程中会收集和处理以下信息：
+
+## 收集的信息
+- **系统信息**：程序版本号。
+- **网络信息**：IP 地址、ISP、地理位置（用于使用统计）、下载统计、IPv6 连接测试（通过访问 testipv6.cn）、IPv6 地址获取（通过 ipw.cn）。
+- **文件信息**：游戏安装路径、文件哈希值。
+
+## 系统修改
+- 使用 Cloudflare 加速时会临时修改系统 hosts 文件。
+- 修改前会自动备份，程序退出时自动恢复。
+
+## 第三方服务
+- **Cloudflare 服务**：通过开源项目 CloudflareSpeedTest (CFST) 提供，用于优化下载速度。此过程会将您的 IP 提交至 Cloudflare 节点。
+- **云端配置服务**：获取配置信息。服务器会记录您的 IP、ISP 及地理位置用于统计。
+- **IPv6 测试服务**：应用使用 testipv6.cn 和 ipw.cn 测试和获取 IPv6 连接信息。
+
+完整的隐私政策可在本程序的 GitHub 仓库中查看。
+"""
+
+# 隐私协议的英文版缩略版内容
+PRIVACY_POLICY_BRIEF_EN = """
+# FRAISEMOE Addons Installer NEXT Privacy Policy Summary
+
+This application collects and processes the following information:
+
+## Information Collected
+- **System info**: Application version.
+- **Network info**: IP address, ISP, geographic location (for usage statistics), download statistics, IPv6 connectivity test (via testipv6.cn), IPv6 address acquisition (via ipw.cn).
+- **File info**: Game installation paths, file hash values.
+
+## System Modifications
+- Temporarily modifies system hosts file when using Cloudflare acceleration.
+- Automatically backs up before modification and restores upon exit.
+
+## Third-party Services
+- **Cloudflare services**: Provided via the open-source project CloudflareSpeedTest (CFST) to optimize download speeds. This process submits your IP to Cloudflare nodes.
+- **Cloud configuration services**: For obtaining configuration information. The server logs your IP, ISP, and location for statistical purposes.
+- **IPv6 testing services**: The application uses testipv6.cn and ipw.cn to test and retrieve IPv6 connection information.
+
+The complete privacy policy can be found in the program's GitHub repository.
+"""
+
+# 默认隐私协议版本 - 本地版本的日期
+PRIVACY_POLICY_VERSION = "2025.08.04"
+
+def get_local_privacy_policy():
+    """获取本地打包的隐私协议文件
+    
+    Returns:
+        tuple: (隐私协议内容, 版本号, 错误信息)
+    """
+    # 尝试不同的可能路径
+    possible_paths = [
+        "PRIVACY.md",  # 相对于可执行文件
+        os.path.join(os.path.dirname(sys.executable), "PRIVACY.md"),  # 可执行文件目录
+        os.path.join(os.path.dirname(__file__), "PRIVACY.md"),  # 当前模块目录
+    ]
+    
+    for path in possible_paths:
+        try:
+            if os.path.exists(path):
+                with open(path, "r", encoding="utf-8") as f:
+                    content = f.read()
+                    
+                # 提取更新日期
+                date_pattern = r'最后更新日期：(\d{4}年\d{1,2}月\d{1,2}日)'
+                match = re.search(date_pattern, content)
+                
+                if match:
+                    date_str = match.group(1)
+                    try:
+                        date_obj = datetime.strptime(date_str, '%Y年%m月%d日')
+                        date_version = date_obj.strftime('%Y.%m.%d')
+                        print(f"成功读取本地隐私协议文件: {path}, 版本: {date_version}")
+                        return content, date_version, ""
+                    except ValueError:
+                        print(f"本地隐私协议日期格式解析错误: {path}")
+                else:
+                    print(f"本地隐私协议未找到更新日期: {path}")
+        except Exception as e:
+            print(f"读取本地隐私协议失败 {path}: {str(e)}")
+    
+    # 所有路径都尝试失败，使用默认版本
+    return PRIVACY_POLICY_BRIEF, PRIVACY_POLICY_VERSION, "无法读取本地隐私协议文件" 

source/ui/Ui_install.py

@@ -215,39 +215,48 @@ class Ui_MainWindows(object):
         self.menu.setObjectName(u"menu")
         self.menu.setTitle("设置")
         self.menu.setFont(menu_font)
-        self.menu.setStyleSheet("""
-            QMenu {
+        # 创建菜单样式表，直接在样式表中指定字体族
+        menu_style = f"""
+            QMenu {{
                 background-color: #E96948;
                 color: white;
-                font-size: 16px;
+                font-family: "{font_family}";
+                font-size: 14px;
                 font-weight: bold;
                 border: 1px solid #F47A5B;
                 padding: 8px;
                 border-radius: 6px;
                 margin-top: 2px;
-            }
-            QMenu::item {
+            }}
+            QMenu::item {{
                 padding: 6px 20px 6px 15px;
                 background-color: transparent;
                 min-width: 120px;
                 color: white;
-            }
-            QMenu::item:selected {
+                font-family: "{font_family}";
+                font-weight: bold;
+            }}
+            QMenu::item:selected {{
                 background-color: #F47A5B;
                 border-radius: 4px;
-            }
-            QMenu::separator {
+            }}
+            QMenu::separator {{
                 height: 1px;
                 background-color: #F47A5B;
                 margin: 5px 15px;
-            }
-        """)
+            }}
+            QMenu::item:checked {{
+                background-color: #D25A3C;
+                border-radius: 4px;
+            }}
+        """
+        self.menu.setStyleSheet(menu_style)
         
         self.menu_2 = QMenu(self.content_container)
         self.menu_2.setObjectName(u"menu_2")
         self.menu_2.setTitle("帮助")
         self.menu_2.setFont(menu_font)
-        self.menu_2.setStyleSheet(self.menu.styleSheet())
+        self.menu_2.setStyleSheet(menu_style)
         
         # 连接按钮点击事件到显示对应菜单
         self.settings_btn.clicked.connect(lambda: self.show_menu(self.menu, self.settings_btn))

source/ui/__init__.py

@@ -0,0 +1,5 @@
+from .Ui_install import Ui_MainWindows
+
+__all__ = [
+    'Ui_MainWindows'
+] 

source/utils/helpers.py

@@ -24,7 +24,7 @@ def resource_path(relative_path):
         base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 
         # 处理特殊的可执行文件和数据文件路径
-        if relative_path in ("aria2c.exe", "cfst.exe"):
+        if relative_path in ("aria2c-fast_x64.exe", "cfst.exe"):
             return os.path.join(base_path, 'bin', relative_path)
         elif relative_path in ("ip.txt", "ipv6.txt"):
             return os.path.join(base_path, 'data', relative_path)
@@ -333,7 +333,7 @@ class HostsManager:
             print(f"清理hosts文件失败: {e}")
             return False
 
-    def apply_ip(self, hostname, ip_address):
+    def apply_ip(self, hostname, ip_address, clean=True):
         if not self.original_content:
             if not self.backup():
                 return False
@@ -347,8 +347,9 @@ class HostsManager:
             return False
         
         try:
-            # 首先清理已有的同域名记录
-            self.clean_hostname_entries(hostname)
+            # 首先清理已有的同域名记录（如果需要）
+            if clean:
+                self.clean_hostname_entries(hostname)
             
             # 然后添加新记录
             lines = self.original_content.splitlines()

source/utils/logger.py

@@ -1,4 +1,7 @@
 from .helpers import censor_url
+import logging
+import os
+from data.config import CACHE
 
 class Logger:
     def __init__(self, filename, stream):
@@ -16,4 +19,46 @@ class Logger:
         self.log.flush()
 
     def close(self):
-        self.log.close() 
+        self.log.close()
+
+def setup_logger(name):
+    """设置并返回一个命名的logger
+    
+    Args:
+        name: logger的名称
+        
+    Returns:
+        logging.Logger: 配置好的logger对象
+    """
+    # 创建logger
+    logger = logging.getLogger(name)
+    
+    # 避免重复添加处理器
+    if logger.hasHandlers():
+        return logger
+        
+    logger.setLevel(logging.DEBUG)
+    
+    # 确保日志目录存在
+    log_dir = os.path.join(CACHE, "logs")
+    os.makedirs(log_dir, exist_ok=True)
+    log_file = os.path.join(log_dir, f"{name}.log")
+    
+    # 创建文件处理器
+    file_handler = logging.FileHandler(log_file, encoding="utf-8")
+    file_handler.setLevel(logging.DEBUG)
+    
+    # 创建控制台处理器
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    
+    # 创建格式器并添加到处理器
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    file_handler.setFormatter(formatter)
+    console_handler.setFormatter(formatter)
+    
+    # 添加处理器到logger
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+    
+    return logger 

source/workers/download.py

@@ -5,9 +5,30 @@ import re
 from urllib.parse import urlparse
 from PySide6 import QtCore, QtWidgets
 from PySide6.QtCore import (Qt, Signal, QThread, QTimer)
-from PySide6.QtWidgets import (QLabel, QProgressBar, QVBoxLayout, QDialog)
+from PySide6.QtWidgets import (QLabel, QProgressBar, QVBoxLayout, QDialog, QHBoxLayout)
 from utils import resource_path
 from data.config import APP_NAME, UA
+import signal
+import ctypes
+import time
+
+# Windows API常量和函数
+if sys.platform == 'win32':
+    kernel32 = ctypes.windll.kernel32
+    PROCESS_ALL_ACCESS = 0x1F0FFF
+    THREAD_SUSPEND_RESUME = 0x0002
+    TH32CS_SNAPTHREAD = 0x00000004
+    
+    class THREADENTRY32(ctypes.Structure):
+        _fields_ = [
+            ('dwSize', ctypes.c_ulong),
+            ('cntUsage', ctypes.c_ulong),
+            ('th32ThreadID', ctypes.c_ulong),
+            ('th32OwnerProcessID', ctypes.c_ulong),
+            ('tpBasePri', ctypes.c_ulong),
+            ('tpDeltaPri', ctypes.c_ulong),
+            ('dwFlags', ctypes.c_ulong)
+        ]
 
 # 下载线程类
 class DownloadThread(QThread):
@@ -21,6 +42,8 @@ class DownloadThread(QThread):
         self.game_version = game_version
         self.process = None
         self._is_running = True
+        self._is_paused = False
+        self.threads = []
 
     def stop(self):
         if self.process and self.process.poll() is None:
@@ -30,15 +53,98 @@ class DownloadThread(QThread):
                 subprocess.run(['taskkill', '/F', '/T', '/PID', str(self.process.pid)], check=True, creationflags=subprocess.CREATE_NO_WINDOW)
             except (subprocess.CalledProcessError, FileNotFoundError) as e:
                 print(f"停止下载进程时出错: {e}")
+                
+    def _get_process_threads(self, pid):
+        """获取进程的所有线程ID"""
+        if sys.platform != 'win32':
+            return []
+            
+        thread_ids = []
+        h_snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0)
+        if h_snapshot == -1:
+            return []
+        
+        thread_entry = THREADENTRY32()
+        thread_entry.dwSize = ctypes.sizeof(THREADENTRY32)
+        
+        res = kernel32.Thread32First(h_snapshot, ctypes.byref(thread_entry))
+        while res:
+            if thread_entry.th32OwnerProcessID == pid:
+                thread_ids.append(thread_entry.th32ThreadID)
+            res = kernel32.Thread32Next(h_snapshot, ctypes.byref(thread_entry))
+            
+        kernel32.CloseHandle(h_snapshot)
+        return thread_ids
+                
+    def pause(self):
+        """暂停下载进程"""
+        if not self._is_paused and self.process and self.process.poll() is None:
+            try:
+                if sys.platform == 'win32':
+                    # 获取所有线程
+                    self.threads = self._get_process_threads(self.process.pid)
+                    if not self.threads:
+                        print("未找到可暂停的线程")
+                        return False
+                        
+                    # 暂停所有线程
+                    for thread_id in self.threads:
+                        h_thread = kernel32.OpenThread(THREAD_SUSPEND_RESUME, False, thread_id)
+                        if h_thread:
+                            kernel32.SuspendThread(h_thread)
+                            kernel32.CloseHandle(h_thread)
+                            
+                    self._is_paused = True
+                    print(f"下载进程已暂停: PID {self.process.pid}, 线程数: {len(self.threads)}")
+                    return True
+                else:
+                    # 在Unix系统上使用SIGSTOP
+                    os.kill(self.process.pid, signal.SIGSTOP)
+                    self._is_paused = True
+                    print(f"下载进程已暂停: PID {self.process.pid}")
+                    return True
+            except Exception as e:
+                print(f"暂停下载进程时出错: {e}")
+                return False
+        return False
+                
+    def resume(self):
+        """恢复下载进程"""
+        if self._is_paused and self.process and self.process.poll() is None:
+            try:
+                if sys.platform == 'win32':
+                    # 恢复所有线程
+                    for thread_id in self.threads:
+                        h_thread = kernel32.OpenThread(THREAD_SUSPEND_RESUME, False, thread_id)
+                        if h_thread:
+                            kernel32.ResumeThread(h_thread)
+                            kernel32.CloseHandle(h_thread)
+                            
+                    self._is_paused = False
+                    print(f"下载进程已恢复: PID {self.process.pid}, 线程数: {len(self.threads)}")
+                    return True
+                else:
+                    # 在Unix系统上使用SIGCONT
+                    os.kill(self.process.pid, signal.SIGCONT)
+                    self._is_paused = False
+                    print(f"下载进程已恢复: PID {self.process.pid}")
+                    return True
+            except Exception as e:
+                print(f"恢复下载进程时出错: {e}")
+                return False
+        return False
 
-
+    def is_paused(self):
+        """返回当前下载是否处于暂停状态"""
+        return self._is_paused
+    
     def run(self):
         try:
             if not self._is_running:
                 self.finished.emit(False, "下载已手动停止。")
                 return
 
-            aria2c_path = resource_path("aria2c.exe")
+            aria2c_path = resource_path("aria2c-fast_x64.exe")
             download_dir = os.path.dirname(self._7z_path)
             file_name = os.path.basename(self._7z_path)
             
@@ -49,6 +155,21 @@ class DownloadThread(QThread):
                 aria2c_path,
             ]
 
+            # 获取主窗口的下载管理器对象
+            thread_count = 64  # 默认值
+            if hasattr(self.parent(), 'download_manager'):
+                # 从下载管理器获取线程数设置
+                thread_count = self.parent().download_manager.get_download_thread_count()
+                
+            # 检查是否启用IPv6支持
+            ipv6_enabled = False
+            if hasattr(self.parent(), 'config'):
+                ipv6_enabled = self.parent().config.get("ipv6_enabled", False)
+                
+            # 打印IPv6状态
+            print(f"IPv6支持状态: {ipv6_enabled}")
+
+            # 将所有的优化参数应用于每个下载任务
             command.extend([
                 '--dir', download_dir,
                 '--out', file_name,
@@ -65,19 +186,30 @@ class DownloadThread(QThread):
                 '--header', 'Sec-Fetch-Mode: cors',
                 '--header', 'Sec-Fetch-Site: same-origin',
                 '--http-accept-gzip=true',
-                '--console-log-level=info',
-                '--summary-interval=1',
-                '--log-level=info',
+                '--console-log-level=notice',
+                '--summary-interval=1',  
+                '--log-level=notice',
                 '--max-tries=3',
                 '--retry-wait=2',
                 '--connect-timeout=60',
                 '--timeout=60',
                 '--auto-file-renaming=false',
                 '--allow-overwrite=true',
-                '--split=16',
-                '--max-connection-per-server=16'
+                '--split=128',                     
+                f'--max-connection-per-server={thread_count}',  # 使用动态的线程数
+                '--min-split-size=1M',             # 减小最小分片大小
+                '--optimize-concurrent-downloads=true',  # 优化并发下载
+                '--file-allocation=none',          # 禁用文件预分配加快开始
+                '--async-dns=true',                # 使用异步DNS
             ])
             
+            # 根据IPv6设置决定是否禁用IPv6
+            if not ipv6_enabled:
+                command.append('--disable-ipv6=true')
+                print("已禁用IPv6支持")
+            else:
+                print("已启用IPv6支持")
+            
             # 证书验证现在总是需要，因为我们依赖hosts文件
             command.append('--check-certificate=false')
             
@@ -91,8 +223,12 @@ class DownloadThread(QThread):
 
             # 正则表达式用于解析aria2c的输出
             # 例如: #1 GID[...](  5%) CN:1 DL:10.5MiB/s ETA:1m30s
-            progress_pattern = re.compile(r'\((\d{1,3})%\).*?CN:(\d+).*?DL:\s*([^\s]+).*?ETA:\s*([^\s]+)')
+            progress_pattern = re.compile(r'\((\d{1,3})%\).*?CN:(\d+).*?DL:\s*([^\s]+).*?ETA:\s*([^\s\]]+)')
 
+            # 添加限流计时器，防止更新过于频繁导致UI卡顿
+            last_update_time = 0
+            update_interval = 0.2  # 限制UI更新频率，每0.2秒最多更新一次
+            
             full_output = []
             while self._is_running and self.process.poll() is None:
                 if self.process.stdout:
@@ -107,17 +243,24 @@ class DownloadThread(QThread):
 
                 match = progress_pattern.search(line)
                 if match:
-                    percent = int(match.group(1))
-                    threads = match.group(2)
-                    speed = match.group(3)
-                    eta = match.group(4)
-                    self.progress.emit({
-                        "game": self.game_version,
-                        "percent": percent,
-                        "threads": threads,
-                        "speed": speed,
-                        "eta": eta
-                    })
+                    # 检查是否达到更新间隔
+                    current_time = time.time()
+                    if current_time - last_update_time >= update_interval:
+                        percent = int(match.group(1))
+                        threads = match.group(2)
+                        speed = match.group(3)
+                        eta = match.group(4)
+                        
+                        # 直接发送进度信号，不使用invokeMethod
+                        self.progress.emit({
+                            "game": self.game_version,
+                            "percent": percent,
+                            "threads": threads,
+                            "speed": speed,
+                            "eta": eta
+                        })
+                        
+                        last_update_time = current_time
 
             return_code = self.process.wait()
             
@@ -156,13 +299,45 @@ class ProgressWindow(QDialog):
         self.progress_bar = QProgressBar()
         self.progress_bar.setValue(0)
         self.stats_label = QLabel("速度: - | 线程: - | 剩余时间: -")
-        self.stop_button = QtWidgets.QPushButton("停止下载")
+        
+        # 创建按钮布局
+        button_layout = QHBoxLayout()
+        
+        # 创建暂停/恢复按钮
+        self.pause_resume_button = QtWidgets.QPushButton("暂停下载")
+        self.pause_resume_button.setToolTip("暂停或恢复下载")
+        
+        # 创建停止按钮
+        self.stop_button = QtWidgets.QPushButton("取消下载")
+        self.stop_button.setToolTip("取消整个下载过程")
+        
+        # 添加按钮到按钮布局
+        button_layout.addWidget(self.pause_resume_button)
+        button_layout.addWidget(self.stop_button)
 
         layout.addWidget(self.game_label)
         layout.addWidget(self.progress_bar)
         layout.addWidget(self.stats_label)
-        layout.addWidget(self.stop_button)
+        layout.addLayout(button_layout)
         self.setLayout(layout)
+        
+        # 设置暂停/恢复状态
+        self.is_paused = False
+        
+        # 添加最后进度记录，用于优化UI更新
+        self._last_percent = -1
+        
+    def update_pause_button_state(self, is_paused):
+        """更新暂停按钮的显示状态
+        
+        Args:
+            is_paused: 是否处于暂停状态
+        """
+        self.is_paused = is_paused
+        if is_paused:
+            self.pause_resume_button.setText("恢复下载")
+        else:
+            self.pause_resume_button.setText("暂停下载")
 
     def update_progress(self, data):
         game_version = data.get("game", "未知游戏")
@@ -170,12 +345,24 @@ class ProgressWindow(QDialog):
         speed = data.get("speed", "-")
         threads = data.get("threads", "-")
         eta = data.get("eta", "-")
-
-        self.game_label.setText(f"正在下载: {game_version}")
-        self.progress_bar.setValue(int(percent))
-        self.stats_label.setText(f"速度: {speed} | 线程: {threads} | 剩余时间: {eta}")
+        
+        # 清除ETA值中可能存在的"]"符号
+        if isinstance(eta, str):
+            eta = eta.replace("]", "")
+        
+        # 优化UI更新
+        if hasattr(self, '_last_percent') and self._last_percent == percent and percent < 100:
+            # 如果百分比没变，只更新速度和ETA信息
+            self.stats_label.setText(f"速度: {speed} | 线程: {threads} | 剩余时间: {eta}")
+        else:
+            # 百分比变化或初次更新，更新所有信息
+            self._last_percent = percent
+            self.game_label.setText(f"正在下载 {game_version} 的补丁")
+            self.progress_bar.setValue(int(percent))
+            self.stats_label.setText(f"速度: {speed} | 线程: {threads} | 剩余时间: {eta}")
 
         if percent == 100:
+            self.pause_resume_button.setEnabled(False)
             self.stop_button.setEnabled(False)
             self.stop_button.setText("下载完成")
             QTimer.singleShot(1500, self.accept)

source/workers/ip_optimizer.py

@@ -33,12 +33,12 @@ class IpOptimizer:
             # 正确的参数设置，根据cfst帮助文档
             command = [
                 cst_path,
-                "-n", "500",     # 延迟测速线程数 (默认200)
+                "-n", "1000",     # 延迟测速线程数 (默认200)
                 "-p", "1",       # 显示结果数量 (默认10个)
                 "-url", url,     # 指定测速地址
                 "-f", ip_txt_path,   # IP文件
                 "-dd",           # 禁用下载测速，按延迟排序
-                "-o",""          # 不写入结果文件
+                "-o"," "          # 不写入结果文件
             ]
 
             creation_flags = subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0
@@ -145,6 +145,142 @@ class IpOptimizer:
             print(f"执行 CloudflareSpeedTest 时发生错误: {e}")
             return None
 
+    def get_optimal_ipv6(self, url: str) -> str | None:
+        """
+        使用 CloudflareSpeedTest 工具获取给定 URL 的最优 Cloudflare IPv6 地址。
+
+        Args:
+            url: 需要进行优选的下载链接。
+
+        Returns:
+            最优的 IPv6 地址字符串，如果找不到则返回 None。
+        """
+        try:
+            cst_path = resource_path("cfst.exe")
+            if not os.path.exists(cst_path):
+                print(f"错误: cfst.exe 未在资源路径中找到。")
+                return None
+
+            ipv6_txt_path = resource_path("data/ipv6.txt")
+            if not os.path.exists(ipv6_txt_path):
+                print(f"错误: ipv6.txt 未在资源路径中找到。")
+                return None
+            
+            # 正确的参数设置，根据cfst帮助文档
+            command = [
+                cst_path,
+                "-n", "1000",     # 延迟测速线程数，IPv6测试线程稍少
+                "-p", "1",       # 显示结果数量 (默认10个)
+                "-url", url,     # 指定测速地址
+                "-f", ipv6_txt_path,  # IPv6文件
+                "-dd",           # 禁用下载测速，按延迟排序
+                "-o", " "        # 不写入结果文件
+            ]
+
+            creation_flags = subprocess.CREATE_NO_WINDOW if sys.platform == 'win32' else 0
+            
+            print("--- CloudflareSpeedTest IPv6 开始执行 ---")
+            
+            self.process = subprocess.Popen(
+                command,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                encoding='utf-8',
+                errors='replace',
+                creationflags=creation_flags,
+                bufsize=0
+            )
+
+            # 更新正则表达式以匹配cfst输出中的IPv6格式
+            # IPv6格式更加复杂，可能有多种表示形式
+            ipv6_pattern = re.compile(r'^([0-9a-fA-F:]+)\s+.*')
+            
+            # 标记是否已经找到结果表头和完成标记
+            found_header = False
+            found_completion = False
+
+            stdout = self.process.stdout
+            if not stdout:
+                print("错误: 无法获取子进程的输出流。")
+                return None
+
+            optimal_ipv6 = None
+            timeout_counter = 0
+            max_timeout = 300  # 增加超时时间到5分钟
+
+            while True:
+                if self.process.poll() is not None:
+                    break
+                try:
+                    ready = True
+                    try:
+                        line = stdout.readline()
+                    except:
+                        ready = False
+                        
+                    if not ready or not line:
+                        timeout_counter += 1
+                        if timeout_counter > max_timeout:
+                            print("超时: CloudflareSpeedTest IPv6 响应超时")
+                            break
+                        time.sleep(1)
+                        continue
+                    
+                    timeout_counter = 0
+                    
+                    cleaned_line = line.strip()
+                    if cleaned_line:
+                        print(cleaned_line)
+                        
+                        # 检测结果表头
+                        if "IP 地址" in cleaned_line and "平均延迟" in cleaned_line:
+                            print("检测到IPv6结果表头，准备获取IPv6地址...")
+                            found_header = True
+                            continue
+                        
+                        # 检测完成标记
+                        if "完整测速结果已写入" in cleaned_line or "按下 回车键 或 Ctrl+C 退出" in cleaned_line:
+                            print("检测到IPv6测速完成信息")
+                            found_completion = True
+                            
+                            # 如果已经找到了IPv6，可以退出了
+                            if optimal_ipv6:
+                                break
+                        
+                        # 已找到表头后，尝试匹配IPv6地址行
+                        if found_header:
+                            match = ipv6_pattern.search(cleaned_line)
+                            if match and not optimal_ipv6:  # 只保存第一个匹配的IPv6（最优IPv6）
+                                optimal_ipv6 = match.group(1)
+                                print(f"找到最优 IPv6: {optimal_ipv6}")
+                                # 找到最优IPv6后立即退出循环，不等待完成标记
+                                break
+                            
+                except Exception as e:
+                    print(f"读取输出时发生错误: {e}")
+                    break
+            
+            # 确保完全读取输出后再发送退出信号
+            if self.process and self.process.poll() is None:
+                try:
+                    if self.process.stdin and not self.process.stdin.closed:
+                        print("发送退出信号...")
+                        self.process.stdin.write('\n')
+                        self.process.stdin.flush()
+                except:
+                    pass
+            
+            self.stop()
+            
+            print("--- CloudflareSpeedTest IPv6 执行结束 ---")
+            return optimal_ipv6
+
+        except Exception as e:
+            print(f"执行 CloudflareSpeedTest IPv6 时发生错误: {e}")
+            return None
+
     def stop(self):
         if self.process and self.process.poll() is None:
             print("正在终止 CloudflareSpeedTest 进程...")
@@ -166,16 +302,24 @@ class IpOptimizer:
 
 
 class IpOptimizerThread(QThread):
-    """用于在后台线程中运行IP优化的类"""
+    """用于在后台线程中运行IP优化的类
+    
+    注意：IPv6连接测试功能已迁移至IPv6Manager类，
+    本类仅负责IP优化相关功能
+    """
     finished = Signal(str)
 
-    def __init__(self, url, parent=None):
+    def __init__(self, url, parent=None, use_ipv6=False):
         super().__init__(parent)
         self.url = url
         self.optimizer = IpOptimizer()
+        self.use_ipv6 = use_ipv6
 
     def run(self):
-        optimal_ip = self.optimizer.get_optimal_ip(self.url)
+        if self.use_ipv6:
+            optimal_ip = self.optimizer.get_optimal_ipv6(self.url)
+        else:
+            optimal_ip = self.optimizer.get_optimal_ip(self.url)
         self.finished.emit(optimal_ip if optimal_ip else "")
 
     def stop(self):