EG/core/assembly_interaction.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import json
import os
from direct.showbase.DirectObject import DirectObject
from direct.task import Task
from panda3d.core import CollisionTraverser, CollisionNode, CollisionHandlerQueue, CollisionRay
from panda3d.core import BitMask32, Vec3, Point3, Plane
from PyQt5.QtWidgets import QMessageBox, QFileDialog, QDialog, QVBoxLayout, QHBoxLayout
from PyQt5.QtWidgets import QLabel, QPushButton, QTextEdit, QComboBox, QGroupBox
from PyQt5.QtCore import Qt

# 导入维修系统GUI
try:
    from core.maintenance_gui import MaintenanceGUI
except ImportError as e:
    print(f"⚠️ 导入维修GUI失败: {e}")
    MaintenanceGUI = None


class AssemblyInteractionManager(DirectObject):
    """拆装交互管理器（优化版）"""

    def __init__(self, world):
        DirectObject.__init__(self)
        self.world = world
        self.config_data = None
        self.current_step = 0
        self.total_steps = 0
        self.is_active = False
        
        # --- 模式控制 ---
        self.mode = "training"  # 默认训练模式，可选 "training" 或 "exam"

        # --- 拖拽相关（优化） ---
        self.dragging_model = None
        self.drag_offset = Vec3(0, 0, 0)
        self.drag_plane = Plane(Vec3(0, 1, 0), Point3(0, 0, 0))  # 初始化一个平面

        # --- 安装/拆卸状态管理 ---
        self.model_original_positions = {}  # 记录模型的原始位置
        self.model_current_states = {}      # 记录模型当前状态 ('installed' 或 'removed')

        # --- UI组件 ---
        self.step_dialog = None
        
        # --- 维修系统GUI ---
        self.maintenance_gui = None
        if MaintenanceGUI:
            self.maintenance_gui = MaintenanceGUI(world)
        
        # --- 操作权限控制 ---
        self.operation_enabled = True  # 是否允许进行操作
        
        # --- 考核相关 ---
        self.exam_score = 0  # 考核总分
        self.exam_max_score = 0  # 考核满分
        self.step_scores = {}  # 每步得分记录

        # --- 碰撞检测（优化） ---
        self.picker_traverser = CollisionTraverser('picker_traverser')
        self.collision_handler = CollisionHandlerQueue()
        self.picker_ray_node = None

        print("拆装交互管理器初始化完成")
    
    def init_exam_mode(self):
        """初始化考核模式"""
        print("📝 初始化考核模式...")
        
        # 重置考核数据
        self.exam_score = 0
        self.exam_max_score = 0
        self.step_scores = {}
        
        # 计算总分
        steps = self.config_data.get('steps', [])
        for i, step_data in enumerate(steps):
            step_score = step_data.get('score', 10)  # 默认每步10分
            self.exam_max_score += step_score
            self.step_scores[i] = {
                'max_score': step_score,
                'current_score': step_score,  # 初始满分，操作错误时扣分
                'tool_error': False,  # 是否有工具错误
                'operation_attempts': 0  # 操作尝试次数
            }
        
        print(f"📝 考核模式初始化完成，总分: {self.exam_max_score} 分")

    def play_step_audio(self, step_data):
        """播放步骤音频"""
        try:
            # 考核模式下不播放音频
            if self.mode == "exam":
                print("🔇 考核模式，音频播放已禁用")
                return
            
            # 检查是否启用了自动播放音频
            settings = self.config_data.get('settings', {})
            auto_play_audio = settings.get('auto_play_audio', True)
            
            if not auto_play_audio:
                print("🔇 音频播放已禁用")
                return
            
            # 获取音频文件路径
            audio_file = step_data.get('audio_file', '')
            
            if not audio_file or audio_file.strip() == '':
                print("🔇 当前步骤没有配置音频文件")
                return
            
            print(f"🔊 准备播放步骤音频: {audio_file}")

            import os
            # 检查音频文件格式
            file_ext = os.path.splitext(audio_file)[1].lower()
            print(f"🔊 音频文件格式: {file_ext}")
            
            # 对于MP3文件，优先使用pygame播放
            if file_ext in ['.mp3', '.m4a', '.aac']:
                print("🔊 检测到MP3/M4A/AAC格式，优先尝试pygame播放")
                if self.play_audio_with_pygame(audio_file):
                    return
                print("🔊 pygame不可用，尝试备用播放方法")
                self.play_audio_fallback(audio_file)
                return
            
            # 检查音频文件是否存在
            import os
            if not os.path.isfile(audio_file):
                # 如果不是绝对路径，尝试在项目目录下查找
                if not os.path.isabs(audio_file):
                    # 尝试在当前目录、Resources目录等位置查找
                    possible_paths = [
                        audio_file,
                        os.path.join("Resources", audio_file),
                        os.path.join("Resources", "audio", audio_file),
                        os.path.join("audio", audio_file),
                        os.path.join("sounds", audio_file)
                    ]
                    
                    audio_file_found = None
                    for path in possible_paths:
                        if os.path.isfile(path):
                            audio_file_found = path
                            break
                    
                    if audio_file_found:
                        audio_file = audio_file_found
                        print(f"🔊 找到音频文件: {audio_file}")
                    else:
                        print(f"❌ 找不到音频文件: {audio_file}")
                        print(f"   尝试的路径: {possible_paths}")
                        return
                else:
                    print(f"❌ 音频文件不存在: {audio_file}")
                    return
            
            # 使用Panda3D的音频系统播放音频
            if hasattr(self.world, 'loader') and self.world.loader:
                try:
                    # 检查音频系统是否启用
                    from panda3d.core import AudioManager
                    print(f"🔊 音频管理器状态: {AudioManager.createAudioManager()}")
                    
                    # 加载音频文件
                    print(f"🔊 尝试加载音频文件: {audio_file}")
                    audio_sound = self.world.loader.loadSfx(audio_file)
                    
                    if audio_sound:
                        print(f"✅ 音频文件加载成功: {os.path.basename(audio_file)}")
                        print(f"🔊 音频状态: {audio_sound.status()}")
                        audio_length = audio_sound.length()
                        print(f"🔊 音频长度: {audio_length:.2f}秒")
                        
                        # 检查音频文件是否有效
                        if audio_length <= 0:
                            print("⚠️ 音频长度为0，可能是格式不支持或文件损坏")
                            print("🔊 尝试使用pygame播放")
                            if not self.play_audio_with_pygame(audio_file):
                                self.play_audio_fallback(audio_file)
                            return
                        
                        # 设置音量（在播放前设置）
                        audio_sound.setVolume(0.8)
                        print(f"🔊 设置音量: 80%")
                        
                        # 播放音频
                        audio_sound.play()
                        print(f"✅ 开始播放音频: {os.path.basename(audio_file)}")
                        
                        # 等待一小段时间让播放状态更新
                        import time
                        time.sleep(0.1)
                        
                        final_status = audio_sound.status()
                        print(f"🔊 播放后状态: {final_status}")
                        
                        # 检查是否真的在播放 (状态码2表示PLAYING)
                        if final_status == 2:  # PLAYING
                            print("✅ 音频正在播放中")
                        elif final_status == 1:  # READY
                            print("⚠️ 音频处于就绪状态但未播放，尝试pygame")
                            if not self.play_audio_with_pygame(audio_file):
                                self.play_audio_fallback(audio_file)
                        else:
                            print(f"⚠️ 音频状态异常: {final_status}")
                            if not self.play_audio_with_pygame(audio_file):
                                self.play_audio_fallback(audio_file)
                    else:
                        print(f"❌ 无法加载音频文件: {audio_file}")
                        print("🔊 Panda3D加载失败，尝试pygame")
                        if not self.play_audio_with_pygame(audio_file):
                            self.play_audio_fallback(audio_file)
                        
                except Exception as e:
                    print(f"❌ Panda3D音频播放失败: {e}")
                    import traceback
                    traceback.print_exc()
                    # 尝试使用pygame播放（备用方案）
                    print("🔊 Panda3D播放失败，尝试pygame")
                    if not self.play_audio_with_pygame(audio_file):
                        self.play_audio_fallback(audio_file)
            else:
                print("⚠️ 找不到Panda3D音频加载器，尝试pygame")
                if not self.play_audio_with_pygame(audio_file):
                    self.play_audio_fallback(audio_file)
                
        except Exception as e:
            print(f"❌ 音频播放失败: {e}")
            import traceback
            traceback.print_exc()
    
    def play_audio_with_pygame(self, audio_file):
        """使用pygame播放音频（优先方法）"""
        try:
            import pygame
            print("🔊 使用pygame播放音频")
            
            # 初始化pygame mixer
            if not pygame.mixer.get_init():
                pygame.mixer.pre_init(frequency=22050, size=-16, channels=2, buffer=1024)
                pygame.mixer.init()
                print("🔊 pygame mixer初始化完成")
            
            # 停止当前播放的音频（如果有）
            if pygame.mixer.music.get_busy():
                pygame.mixer.music.stop()
                print("🔊 停止之前的音频")
            
            # 加载并播放音频文件
            pygame.mixer.music.load(audio_file)
            pygame.mixer.music.set_volume(0.8)
            pygame.mixer.music.play()
            
            print(f"✅ pygame开始播放音频: {os.path.basename(audio_file)}")
            
            # 在后台线程中监控播放完成
            def wait_for_pygame_completion():
                import time
                while pygame.mixer.music.get_busy():
                    time.sleep(0.1)
                print(f"🎵 pygame音频播放完成: {os.path.basename(audio_file)}")
            
            import threading
            threading.Thread(target=wait_for_pygame_completion, daemon=True).start()
            
            print("🎵 音频将在后台完整播放")
            return True
            
        except ImportError:
            print("⚠️ pygame未安装")
            return False
        except Exception as e:
            print(f"⚠️ pygame播放失败: {e}")
            import traceback
            traceback.print_exc()
            return False
    
    def play_audio_fallback(self, audio_file):
        """备用音频播放方法"""
        import os
        print(f"🔊 尝试备用音频播放方法...")
        
                # 方法1: 使用系统默认播放器（最简单）
        try:
            print("🔊 尝试使用系统默认播放器")
            if os.name == 'nt':  # Windows
                os.startfile(audio_file)
                print(f"✅ 使用系统默认播放器播放: {os.path.basename(audio_file)}")
                return
            elif os.name == 'posix':  # Linux/Mac
                os.system(f'xdg-open "{audio_file}"')
                print(f"✅ 使用系统默认播放器播放: {os.path.basename(audio_file)}")
                return
        except Exception as e:
            print(f"⚠️ 系统默认播放器失败: {e}")
        
        # 方法2: 尝试使用Windows Media Player
        try:
            if os.name == 'nt':  # Windows
                print("🔊 尝试使用Windows Media Player")
                cmd = f'start wmplayer "{audio_file}"'
                os.system(cmd)
                print(f"✅ 使用Windows Media Player播放音频: {os.path.basename(audio_file)}")
                return
        except Exception as e:
            print(f"⚠️ Windows Media Player播放失败: {e}")
        
        # 方法3: 使用PowerShell播放WAV文件
        try:
            if os.name == 'nt':
                file_ext = os.path.splitext(audio_file)[1].lower()
                if file_ext in ['.wav']:
                    print("🔊 尝试使用PowerShell播放WAV文件")
                    import subprocess
                    cmd = f'powershell -c "(New-Object Media.SoundPlayer \\"{audio_file}\\").PlaySync()"'
                    subprocess.run(cmd, shell=True)
                    print(f"✅ 使用PowerShell播放音频: {os.path.basename(audio_file)}")
                    return
        except Exception as e:
            print(f"⚠️ PowerShell播放失败: {e}")
        
        # 方法4: 简单的系统调用
        try:
            print("🔊 尝试使用系统默认播放器")
            if os.name == 'nt':  # Windows
                os.startfile(audio_file)
            elif os.name == 'posix':  # Linux/Mac
                os.system(f'xdg-open "{audio_file}"')
            print(f"✅ 使用系统默认播放器播放音频: {os.path.basename(audio_file)}")
        except Exception as e:
            print(f"❌ 所有备用音频播放方法都失败了: {e}")
            print("💡 建议检查：")
            print("   1. 音频文件是否存在且格式正确")
            print("   2. 系统音频驱动是否正常")
            print("   3. 音频文件是否损坏")

    def set_operation_enabled(self, enabled):
        """设置操作是否启用"""
        self.operation_enabled = enabled
        print(f"🔧 操作权限: {'启用' if enabled else '禁用'}")

    def check_operation_permission(self):
        """检查操作权限"""
        if not self.is_active:
            print("⚠️ 交互模式未激活")
            return False

        # 获取当前步骤数据
        if self.current_step >= self.total_steps:
            print("⚠️ 所有步骤已完成")
            return False

        step_data = self.config_data['steps'][self.current_step]
        required_tool = step_data.get('required_tool', '无')

        # 获取当前选择的工具（优先从维修GUI获取）
        current_tool = "无"
        if self.maintenance_gui:
            current_tool = self.maintenance_gui.get_current_tool()
        elif hasattr(self, 'step_dialog') and self.step_dialog and hasattr(self.step_dialog, 'tool_combo'):
            current_tool = self.step_dialog.tool_combo.currentText()

        # 使用 getChinese 处理工具名称
        if hasattr(self.world, 'getChinese'):
            required_tool = self.world.getChinese(required_tool)
            current_tool = self.world.getChinese(current_tool)

        print(f"🔧 工具检查: 需要'{required_tool}'，当前'{current_tool}'")

        # 检查工具是否匹配
        tool_matches = self.check_tool_match(current_tool, required_tool)

        if self.mode == "training":
            # 训练模式：显示GUI警告并阻止错误操作
            if not tool_matches:
                print("⚠️ 训练模式 - 工具不匹配，无法进行操作")

                # 在维修GUI中显示警告
                if self.maintenance_gui:
                    warning_msg = f"请先选择 '{required_tool}' 工具！"
                    self.maintenance_gui.show_warning(warning_msg, 2.0)
                # 也在Qt对话框中显示警告（仅在非维修系统模式下）
                elif hasattr(self, 'step_dialog') and self.step_dialog:
                    QMessageBox.warning(self.step_dialog, "工具不匹配",
                                        f"当前步骤需要使用 '{required_tool}' 工具，请先选择正确的工具！")
                return False
            return True
        else:
            # 考核模式：不显示提示，但记录工具错误并阻止操作
            if not tool_matches:
                print(f"❌ 考核模式 - 工具错误：需要'{required_tool}'，实际选择'{current_tool}'，操作被阻止")

                # 记录工具错误（扣分）
                self.record_tool_error()
                return False
            return True
    
    def check_tool_match(self, current_tool, required_tool):
        """检查工具是否匹配"""
        # 如果步骤不要求特定工具，任何工具都可以
        if required_tool == "无" or required_tool == "" or not required_tool:
            return True
        
        # 精确匹配
        if current_tool == required_tool:
            return True
        
        return False
    
    def record_tool_error(self):
        """记录工具错误（考核模式下扣分）"""
        if self.mode != "exam":
            return
            
        # 获取当前步骤的考核记录
        if self.current_step in self.step_scores:
            step_record = self.step_scores[self.current_step]
            
            # 如果是第一次工具错误，扣除一定分数
            if not step_record['tool_error']:
                step_record['tool_error'] = True
                # 扣除该步骤50%的分数作为工具错误惩罚
                # penalty = step_record['max_score'] * 0.5
                penalty = step_record['max_score']
                step_record['current_score'] = max(0, step_record['current_score'] - penalty)
                
                print(f"📝 考核记录：工具错误，扣除{penalty:.0f}分，当前步骤剩余{step_record['current_score']:.0f}分")
            
            # 增加操作尝试次数
            step_record['operation_attempts'] += 1

    def start_interaction_mode(self, mode="training"):
        """启动交互模式"""
        try:
            # 设置模式
            self.mode = mode
            print(f"🎯 启动拆装交互模式: {self.mode}")
            
            # 如果没有配置数据，尝试加载
            if not self.config_data:
                if not self.load_configuration():
                    return False

            if not self.config_data or not self.config_data.get('steps'):
                QMessageBox.warning(None, "警告", "没有找到有效的配置步骤！\n请先在'拆装配置'中设置步骤。")
                return False

            self.total_steps = len(self.config_data['steps'])
            self.current_step = 0
            self.is_active = True
            
            # 设置维修系统GUI
            if self.maintenance_gui:
                tools_list = self.config_data.get('tools', ['手'])
                self.maintenance_gui.setup_gui(tools_list, mode)
                self.maintenance_gui.show_gui()
                print(f"✅ 维修系统GUI已启动，模式: {mode}")
            
            # 如果是考核模式，初始化考核相关数据

            if self.mode == "exam":
                self.init_exam_mode()
                # 显示考核开始提示
                if self.maintenance_gui:
                    exam_start_msg = f"📝 考核模式已启动\n\n总分: {self.exam_max_score} 分\n步骤数: {self.total_steps}\n\n✅ 可以选择和切换工具\n❌ 不会显示步骤描述和语音提示\n❌ 使用错误工具会扣分"
                    self.maintenance_gui.update_step_info(exam_start_msg)
                    print("📝 考核开始提示已在GUI中显示")

            # 设置碰撞检测
            self.setup_picking()

            # 拦截Qt层面的鼠标事件处理
            print("🔄 拦截Qt层面的鼠标事件处理")
            print(f"🔍 检查world对象: {type(self.world).__name__}")
            print(f"🔍 是否有qtWidget属性: {hasattr(self.world, 'qtWidget')}")
            if hasattr(self.world, 'qtWidget'):
                print(f"🔍 qtWidget值: {self.world.qtWidget}")
                print(f"🔍 qtWidget类型: {type(self.world.qtWidget)}")

            if hasattr(self.world, 'qtWidget') and self.world.qtWidget:
                # 备份原有的鼠标事件处理方法
                self.original_mouse_press_event = self.world.qtWidget.mousePressEvent
                self.original_mouse_release_event = self.world.qtWidget.mouseReleaseEvent

                print(f"🔍 原有鼠标事件方法: {self.original_mouse_press_event}")

                # 替换为我们的处理方法
                self.world.qtWidget.mousePressEvent = self.qt_mouse_press_event
                self.world.qtWidget.mouseReleaseEvent = self.qt_mouse_release_event
                print("✅ Qt鼠标事件已被拦截")
            else:
                print("⚠️ 找不到Qt部件，使用Panda3D事件系统")
                # 作为备用方案，仍然绑定Panda3D事件
                self.accept("mouse1", self.on_mouse_down)
                self.accept("mouse1-up", self.on_mouse_up)

            # 绑定键盘备用触发
            self.accept("space", self.trigger_drag_by_keyboard)
            self.accept("s", self.show_models_status)  # S键显示模型状态
            self.accept("r", self.record_current_positions)  # R键记录当前位置为原始位置

            print("✅ 拆装交互事件绑定完成")
            print("💡 提示: 按S键可查看所有模型状态，按R键重新记录原始位置")

            print("拆装交互模式已启动，核心事件已绑定。")
            print("请点击目标模型进行操作。")

            # 调试：列出场景中的所有模型
            self.list_scene_models()

            # 显示步骤指引界面（维修系统使用GUI界面，跳过Qt对话框）
            if not self.maintenance_gui:
                self.show_step_dialog()

            # 开始第一步
            self.start_current_step()

            print(f"共 {self.total_steps} 步")
            return True

        except Exception as e:
            QMessageBox.critical(None, "错误", f"启动交互模式失败: {str(e)}")
            import traceback
            traceback.print_exc()
            return False

    def load_configuration(self):
        """加载拆装配置"""
        try:
            file_path, _ = QFileDialog.getOpenFileName(
                None, "选择拆装配置文件", "",
                "JSON文件 (*.json);;所有文件 (*)"
            )
            if not file_path:
                return False

            with open(file_path, 'r', encoding='utf-8') as f:
                self.config_data = json.load(f)

            self.total_steps = len(self.config_data.get('steps', []))
            self.current_step = 0

            # 从配置文件中恢复原始位置信息
            self.load_original_positions_from_config()

            print(f"成功加载配置: {file_path}")
            return True

        except Exception as e:
            QMessageBox.critical(None, "错误", f"加载配置失败: {str(e)}")
            return False

    def load_original_positions_from_config(self):
        """从配置文件中加载模型的原始位置信息"""
        print("📍 从配置文件恢复模型原始位置...")

        # 清空现有的位置记录
        self.model_original_positions.clear()
        self.model_current_states.clear()

        # 从配置文件的models部分读取原始位置（models是数组格式）
        models_config = self.config_data.get('models', [])

        for model_data in models_config:
            model_name = model_data.get('name')
            if not model_name:
                continue

            # 尝试从配置文件中获取原始位置
            original_pos_data = model_data.get('original_pos')

            if original_pos_data and len(original_pos_data) >= 3:
                # 如果配置文件中有原始位置，使用配置文件中的位置
                original_pos = Vec3(original_pos_data[0], original_pos_data[1], original_pos_data[2])
                self.model_original_positions[model_name] = original_pos
                self.model_current_states[model_name] = 'installed'
                print(f"  📍 {model_name}: 从配置文件恢复原始位置 {original_pos}")
            else:
                # 如果配置文件中没有原始位置，使用当前场景中的位置作为原始位置
                target_node = self.find_model_node(model_name)
                if target_node and not target_node.isEmpty():
                    current_pos = target_node.getPos()
                    self.model_original_positions[model_name] = current_pos
                    self.model_current_states[model_name] = 'installed'
                    print(f"  📍 {model_name}: 使用当前场景位置作为原始位置 {current_pos}")
                else:
                    print(f"  ❌ {model_name}: 在场景中找不到对应模型")

        # 如果配置文件中没有models部分，从步骤中提取模型信息
        if not models_config:
            print("  配置文件中没有models部分，从步骤中提取模型信息...")
            for step_data in self.config_data.get('steps', []):
                target_model_name = step_data.get('target_model')
                if target_model_name and target_model_name not in self.model_original_positions:
                    target_node = self.find_model_node(target_model_name)
                    if target_node and not target_node.isEmpty():
                        current_pos = target_node.getPos()
                        self.model_original_positions[target_model_name] = current_pos
                        self.model_current_states[target_model_name] = 'installed'
                        print(f"  📍 {target_model_name}: 从场景记录原始位置 {current_pos}")

        print(f"📍 原始位置恢复完成，共记录 {len(self.model_original_positions)} 个模型")

        # 检查配置文件的步骤完整性
        self.check_step_completeness()

    def check_step_completeness(self):
        """检查配置文件的步骤完整性"""
        print("\n🔍 检查步骤配置完整性...")

        steps = self.config_data.get('steps', [])
        if not steps:
            print("⚠️ 配置文件中没有步骤")
            return

        # 统计每个模型的拆卸和安装步骤
        model_operations = {}

        for i, step in enumerate(steps):
            target_model = step.get('target_model')
            step_type = self.normalize_step_type(step)

            if target_model:
                if target_model not in model_operations:
                    model_operations[target_model] = {'disassemble': [], 'assemble': []}

                model_operations[target_model][step_type].append(i + 1)

        # 检查每个模型是否有配对的拆卸和安装步骤
        incomplete_models = []
        for model_name, operations in model_operations.items():
            disassemble_count = len(operations['disassemble'])
            assemble_count = len(operations['assemble'])

            print(f"  📋 {model_name}: 拆卸步骤 {disassemble_count} 个, 安装步骤 {assemble_count} 个")

            if disassemble_count > 0 and assemble_count == 0:
                incomplete_models.append(model_name)
                print(f"    ⚠️ 只有拆卸步骤，缺少安装步骤")
            elif disassemble_count != assemble_count:
                print(f"    ⚠️ 拆卸和安装步骤数量不匹配")

        if incomplete_models:
            print(f"\n⚠️ 发现 {len(incomplete_models)} 个模型缺少安装步骤:")
            for model in incomplete_models:
                print(f"  - {model}")
            print("💡 建议为每个拆卸的模型添加对应的安装步骤")
        else:
            print("\n✅ 所有模型都有完整的拆卸和安装步骤配置")

    def setup_picking(self):
        """设置用于鼠标拾取的碰撞检测系统"""
        try:
            # 创建一个碰撞射线
            picker_ray = CollisionRay()

            # 创建一个用于放置射线的碰撞节点
            picker_ray_node = CollisionNode('mouse_ray')
            picker_ray_node.addSolid(picker_ray)

            # 设置碰撞掩码，确保它只与可拾取的物体碰撞
            # 这里我们假设可拾取的物体有第1位的碰撞比特
            picker_ray_node.setFromCollideMask(BitMask32.bit(1))
            picker_ray_node.setIntoCollideMask(BitMask32.allOff())

            # 将碰撞节点附加到相机上，这样射线就会跟随相机移动
            self.picker_ray_node = self.world.camera.attachNewNode(picker_ray_node)

            # 将碰撞节点添加到遍历器中，并指定一个处理器来存储碰撞结果
            self.picker_traverser.addCollider(self.picker_ray_node, self.collision_handler)

            print("射线拾取系统设置完成")

        except Exception as e:
            print(f"设置碰撞检测失败: {e}")

    def show_step_dialog(self):
        """显示步骤指引对话框"""
        if self.step_dialog:
            self.step_dialog.close()

        # 获取主窗口作为父窗口
        parent_window = None
        if hasattr(self.world, 'main_window') and self.world.main_window:
            parent_window = self.world.main_window
        
        self.step_dialog = StepGuideDialog(self, parent_window)
        self.step_dialog.show()

    def start_current_step(self):
        """开始当前步骤"""
        if self.current_step >= self.total_steps:
            self.finish_interaction()
            return

        step_data = self.config_data['steps'][self.current_step]

        # 兼容中文和英文配置格式
        operation_type = self.normalize_operation_type(step_data)
        step_type = self.normalize_step_type(step_data)
        target_model_name = step_data.get('target_model', '未设置')

        # 调试信息：显示字段映射结果
        print(f"🔄 字段映射: '{step_data.get('type', 'N/A')}' -> '{step_type}'")
        print(f"🔄 操作映射: '{step_data.get('interaction_type', 'N/A')}' -> '{operation_type}'")

        # 使用 getChinese 处理步骤名称
        step_name = step_data.get('name', '未命名')
        if hasattr(self.world, 'getChinese'):
            step_name = self.world.getChinese(step_name)
            target_model_name = self.world.getChinese(target_model_name)

        print(f"\n=== 开始第 {self.current_step + 1} 步: {step_name} ===")
        print(f"目标模型: {target_model_name}")
        print(f"操作类型: {operation_type}")
        print(f"步骤类型: {step_type}")

        # 显示容差信息
        if step_type == 'assemble':
            snap_tolerance = step_data.get('snap_tolerance') or step_data.get('tolerance', 5.0)
            print(f"吸附容差: {snap_tolerance:.1f} 单位")
        else:
            disassemble_threshold = step_data.get('disassemble_threshold', 5.0)
            print(f"拆卸阈值: {disassemble_threshold:.1f} 单位（距离原位）")

        # 检查模型的原始位置记录
        if target_model_name:
            if target_model_name in self.model_original_positions:
                original_pos = self.model_original_positions[target_model_name]
                print(f"📍 模型 '{target_model_name}' 的原始位置: {original_pos}")
            else:
                # 如果没有记录，使用当前位置作为原始位置（但会给出警告）
                target_node = self.find_model_node(target_model_name)
                if target_node and not target_node.isEmpty():
                    current_pos = target_node.getPos()
                    self.model_original_positions[target_model_name] = current_pos
                    self.model_current_states[target_model_name] = 'installed'
                    print(f"⚠️ 模型 '{target_model_name}' 没有预设原始位置，使用当前位置: {current_pos}")
                    print("   建议在配置文件中预设模型的original_position以确保一致性")

        # 如果是安装步骤，确保模型显示
        if step_type == 'assemble' and target_model_name:
            target_node = self.find_model_node(target_model_name)
            if target_node and not target_node.isEmpty():
                if target_node.isHidden():
                    print(f"👁️ 安装步骤开始 - 显示隐藏的模型: {target_model_name}")
                    target_node.show()
                else:
                    print(f"✅ 模型 '{target_model_name}' 已经可见")

        # 播放步骤音频（如果有配置）
        self.play_step_audio(step_data)

        # 更新维修系统GUI的步骤信息
        if self.maintenance_gui:
            step_name = step_data.get('name', f'步骤 {self.current_step + 1}')
            step_description = step_data.get('description', '')

            # 使用 getChinese 处理文本
            if hasattr(self.world, 'getChineseFont'):
                step_name = self.world.getChineseFont()
                step_description = self.world.getChineseFont()

            if self.mode == "exam":
                # 考核模式：只显示步骤编号和名称，不显示描述
                step_info = f"Step {self.current_step + 1}/{self.total_steps}: {step_name}"
                print(f"📝 考核模式步骤信息: {step_info}")
            else:
                # 训练模式：显示完整信息
                step_info = f"Step: {self.current_step + 1}/{self.total_steps}: {step_name}"
                if step_description:
                    step_info += f"\n{step_description}"
                print(f"📚 训练模式步骤信息: {step_info}")

            self.maintenance_gui.update_step_info(step_info)

        # 更新Qt步骤对话框（仅在非维修系统模式下）
        if self.step_dialog and not self.maintenance_gui:
            self.step_dialog.update_step_info(step_data, self.current_step + 1, self.total_steps)

        # 准备交互（主要是确保目标模型可以被拾取）
        self.prepare_interaction(step_data)

    def prepare_interaction(self, step_data):
        """准备交互，主要是设置目标模型的碰撞掩码"""
        target_model_name = step_data.get('target_model')
        if not target_model_name:
            print("警告: 当前步骤没有指定目标模型")
            return

        target_node = self.find_model_node(target_model_name)
        if not target_node:
            print(f"警告: 找不到目标模型 '{target_model_name}'")
            return

        # 给目标模型设置碰撞掩码，使其可以被射线拾取
        # BitMask32.bit(1) 对应 setup_picking 中设置的 from_collide_mask
        target_node.setCollideMask(BitMask32.bit(1))
        print(f"已为模型 '{target_model_name}' 设置碰撞掩码，等待用户点击。")

    def find_model_node(self, model_name):
        """在场景中查找指定名称的模型节点"""
        # find() 是Panda3D提供的更高效的节点查找方法
        return self.world.render.find(f"**/{model_name}")

    def list_scene_models(self):
        """列出场景中的所有模型（调试用）"""
        print("\n📋 场景中的模型列表:")
        all_nodes = self.world.render.findAllMatches("**")
        model_count = 0
        for node_path in all_nodes:
            node_name = node_path.getName()
            # 过滤掉系统节点和碰撞节点
            if (node_name and
                node_name not in ['render', 'camera', 'aspect2d', 'pixel2d', 'cam'] and
                not node_name.startswith("modelCollision_") and
                not node_name.startswith("collision") and
                not node_name.startswith("picker")):
                print(f"  - {node_name}")
                model_count += 1
        print(f"总共找到 {model_count} 个模型节点\n")

    def show_models_status(self):
        """显示所有模型的当前状态"""
        if not self.model_original_positions:
            print("📊 没有记录任何模型状态")
            return

        print("\n📊 模型状态信息:")
        for model_name, original_pos in self.model_original_positions.items():
            current_state = self.model_current_states.get(model_name, 'unknown')
            model_node = self.find_model_node(model_name)

            if model_node and not model_node.isEmpty():
                current_pos = model_node.getPos()
                distance_from_original = (current_pos - original_pos).length()

                status_icon = "🔧" if current_state == 'installed' else "📦" if current_state == 'removed' else "❓"
                print(f"  {status_icon} {model_name}:")
                print(f"    状态: {current_state}")
                print(f"    原始位置: {original_pos}")
                print(f"    当前位置: {current_pos}")
                print(f"    距离原位: {distance_from_original:.2f}")
            else:
                print(f"  ❌ {model_name}: 找不到模型节点")
        print()

    def record_current_positions(self):
        """将当前所有模型的位置记录为原始位置"""
        print("\n📍 重新记录所有模型的原始位置...")

        # 从步骤中提取所有模型
        all_models = set()
        for step_data in self.config_data.get('steps', []):
            target_model = step_data.get('target_model')
            if target_model:
                all_models.add(target_model)

        # 记录每个模型的当前位置为原始位置
        for model_name in all_models:
            target_node = self.find_model_node(model_name)
            if target_node and not target_node.isEmpty():
                current_pos = target_node.getPos()
                self.model_original_positions[model_name] = current_pos
                self.model_current_states[model_name] = 'installed'
                print(f"  📍 {model_name}: 记录新的原始位置 {current_pos}")
            else:
                print(f"  ❌ {model_name}: 在场景中找不到对应模型")

        print(f"📍 重新记录完成，共记录 {len(self.model_original_positions)} 个模型")
        print("💡 提示: 如需永久保存这些位置，请在配置界面中重新保存配置文件")

    def normalize_step_type(self, step_data):
        """标准化步骤类型，兼容中文和英文配置"""
        # 优先使用英文字段
        step_type = step_data.get('step_type')
        if step_type:
            return step_type
        
        # 兼容中文字段
        type_field = step_data.get('type', '')
        if type_field == '拆卸':
            return 'disassemble'
        elif type_field == '安装':
            return 'assemble'
        else:
            return 'disassemble'  # 默认值

    def normalize_operation_type(self, step_data):
        """标准化操作类型，兼容中文和英文配置"""
        # 优先使用英文字段
        operation_type = step_data.get('operation_type')
        if operation_type:
            return operation_type
        
        # 兼容中文字段
        interaction_type = step_data.get('interaction_type', '')
        if interaction_type == '鼠标拖拽':
            return 'drag'
        elif interaction_type == '点击触发':
            return 'click'
        else:
            return 'drag'  # 默认值

    def analyze_final_state(self):
        """分析最终状态，检查哪些模型没有正确回到原位"""
        print("\n📊 最终状态分析:")

        if not self.model_original_positions:
            print("没有模型状态记录")
            return

        incorrect_models = []
        for model_name, original_pos in self.model_original_positions.items():
            model_node = self.find_model_node(model_name)
            if model_node and not model_node.isEmpty():
                current_pos = model_node.getPos()
                distance = (current_pos - original_pos).length()
                current_state = self.model_current_states.get(model_name, 'unknown')

                # 检查是否应该在原位但实际不在原位的模型
                if current_state == 'installed' and distance > 1.0:  # 容差1.0单位
                    incorrect_models.append({
                        'name': model_name,
                        'expected_pos': original_pos,
                        'actual_pos': current_pos,
                        'distance': distance
                    })
                    print(f"❌ {model_name}: 应该在原位但偏离了 {distance:.2f} 单位")
                    print(f"   期望位置: {original_pos}")
                    print(f"   实际位置: {current_pos}")
                elif current_state == 'installed' and distance <= 1.0:
                    print(f"✅ {model_name}: 正确安装在原位 (偏差 {distance:.2f})")
                elif current_state == 'removed':
                    print(f"📦 {model_name}: 已拆卸 (距离原位 {distance:.2f})")

        if incorrect_models:
            print(f"\n⚠️ 发现 {len(incorrect_models)} 个模型没有正确回到原位")
            print("💡 建议检查安装步骤的配置和吸附容差设置")
        else:
            print("\n✅ 所有模型都处于正确状态")

    def qt_mouse_press_event(self, event):
        """Qt鼠标按下事件处理（选择性拦截版）"""
        from PyQt5.QtCore import Qt

        # 只拦截左键，其他按键使用原有处理方式
        if event.button() == Qt.LeftButton:
            print('🖱️ 左键被拦截处理')
            print(f'🖱️ 左键点击位置: ({event.x()}, {event.y()})')
            
            # 检查是否点击在GUI区域
            if self.maintenance_gui and self.is_click_in_gui_area(event.x(), event.y()):
                print('🎯 点击在GUI区域，直接处理工具按钮点击')
                # 直接处理工具按钮点击，不依赖DirectGUI事件
                button_clicked = self.handle_gui_button_click(event.x(), event.y())
                if button_clicked:
                    print(f'🎯 工具按钮点击已处理: {button_clicked}')
                    event.accept()
                    return
                
                # 如果不是按钮点击，让原有事件处理器处理
                if hasattr(self, 'original_mouse_press_event'):
                    self.original_mouse_press_event(event)
                else:
                    event.ignore()
                return
            
            # 点击在3D区域，进行拦截处理
            print('🎯 点击在3D区域，进行拦截处理')
            self.handle_qt_mouse_click(event.x(), event.y())
            event.accept()
        else:
            # 其他按键使用原有处理方式
            if hasattr(self, 'original_mouse_press_event'):
                self.original_mouse_press_event(event)
            else:
                event.ignore()

    def is_click_in_gui_area(self, click_x, click_y):
        """检查鼠标点击是否在GUI区域（高精度版本）"""
        try:
            if not self.maintenance_gui:
                return False
            
            # 获取窗口尺寸用于坐标转换
            if hasattr(self.world, 'qtWidget') and self.world.qtWidget:
                widget_width = self.world.qtWidget.width()
                widget_height = self.world.qtWidget.height()
            else:
                # 使用默认窗口尺寸
                widget_width = 1380
                widget_height = 750
            
            # 使用与maintenance_gui完全相同的坐标转换算法
            aspect_x = (click_x / widget_width) * 2.67 - 1.33
            aspect_y = 1.0 - (click_y / widget_height) * 2.0
            
            # 额外的坐标验证（与Panda3D标准坐标系对比）
            # Panda3D aspect2d坐标系: x范围[-1.33, 1.33], y范围[-1.0, 1.0]
            normalized_x = (click_x / widget_width) * 2.0 - 1.0  # 标准化到[-1, 1]
            normalized_y = 1.0 - (click_y / widget_height) * 2.0  # 标准化到[-1, 1]，Y轴翻转
            aspect_ratio = widget_width / widget_height
            panda_x = normalized_x * aspect_ratio  # 应用宽高比
            panda_y = normalized_y
            
            print(f"🔍 精确GUI区域检查: Qt({click_x}, {click_y}) -> aspect2d({aspect_x:.3f}, {aspect_y:.3f})")
            print(f"🔍 验证坐标转换: 标准化({normalized_x:.3f}, {normalized_y:.3f}) -> Panda3D({panda_x:.3f}, {panda_y:.3f})")
            print(f"📏 窗口信息: 尺寸({widget_width}x{widget_height}), 宽高比({aspect_ratio:.3f})")
            
            # 快速检查工具按钮区域
            if hasattr(self.maintenance_gui, 'available_tools') and self.maintenance_gui.available_tools:
                # 工具按钮区域（底部条带）
                tools_area_left = -1.1
                tools_area_right = 0.5
                tools_area_bottom = -1.0
                tools_area_top = -0.5
                
                if (tools_area_left <= aspect_x <= tools_area_right and 
                    tools_area_bottom <= aspect_y <= tools_area_top):
                    print(f"✅ 点击在工具按钮区域内")
                    return True
            
            # 检查其他GUI区域（步骤显示、当前工具、警告等）
            other_gui_areas = []
            
            # 步骤显示区域（顶部）
            if hasattr(self.maintenance_gui, 'step_text') and self.maintenance_gui.step_text:
                other_gui_areas.append({
                    'name': '步骤显示区域',
                    'left': -1.8, 'right': 1.8,
                    'bottom': 0.5, 'top': 1.1
                })
            
            # 当前工具显示区域（右侧）
            if hasattr(self.maintenance_gui, 'current_tool_text') and self.maintenance_gui.current_tool_text:
                other_gui_areas.append({
                    'name': '当前工具显示区域',
                    'left': 0.2, 'right': 1.8,
                    'bottom': 0.6, 'top': 1.0
                })
            
            # 警告显示区域（中央）
            if hasattr(self.maintenance_gui, 'warning_text') and self.maintenance_gui.warning_text:
                other_gui_areas.append({
                    'name': '警告显示区域',
                    'left': -1.5, 'right': 1.5,
                    'bottom': 0.0, 'top': 0.6
                })
            
            # 检查其他GUI区域
            for area in other_gui_areas:
                if (area['left'] <= aspect_x <= area['right'] and 
                    area['bottom'] <= aspect_y <= area['top']):
                    print(f"✅ 点击在GUI区域内: {area['name']}")
                    return True
            
            print("❌ 点击不在任何GUI区域内")
            return False
            
        except Exception as e:
            print(f"❌ 检查GUI区域失败: {e}")
            import traceback
            traceback.print_exc()
            return False

    def handle_gui_button_click(self, click_x, click_y):
        """直接处理GUI按钮点击"""
        try:
            if not self.maintenance_gui:
                return None
            
            # 获取窗口尺寸用于坐标转换
            if hasattr(self.world, 'qtWidget') and self.world.qtWidget:
                widget_width = self.world.qtWidget.width()
                widget_height = self.world.qtWidget.height()
            else:
                widget_width = 1380
                widget_height = 750
            
            # 使用与maintenance_gui完全相同的坐标转换算法
            aspect_x = (click_x / widget_width) * 2.67 - 1.33
            aspect_y = 1.0 - (click_y / widget_height) * 2.0
            
            print(f"🎯 直接处理按钮点击：Qt({click_x}, {click_y}) -> aspect2d({aspect_x:.3f}, {aspect_y:.3f})")
            
            # 检查工具按钮点击
            if hasattr(self.maintenance_gui, 'available_tools') and self.maintenance_gui.available_tools:
                button_width = 0.4
                button_height = 0.25
                button_spacing = 0.45
                start_x = -0.8
                start_y = -0.75
                click_padding = 0.05  # 点击容差
                
                for i, tool_data in enumerate(self.maintenance_gui.available_tools):
                    # 获取工具名称
                    if isinstance(tool_data, dict):
                        tool_name = tool_data.get('name', str(tool_data))
                    else:
                        tool_name = str(tool_data)
                    
                    # 计算按钮位置
                    button_x = start_x + i * button_spacing
                    button_y = start_y
                    
                    # 计算按钮边界（包含容差）
                    left = button_x - (button_width/2 + click_padding)
                    right = button_x + (button_width/2 + click_padding)
                    bottom = button_y - (button_height/2 + click_padding)
                    top = button_y + (button_height/2 + click_padding)
                    
                    print(f"🔍 检查按钮{i} '{tool_name}': 范围x[{left:.3f}, {right:.3f}], y[{bottom:.3f}, {top:.3f}]")
                    
                    # 检查点击是否在按钮范围内
                    if (left <= aspect_x <= right and bottom <= aspect_y <= top):
                        print(f"✅ 直接匹配按钮{i} '{tool_name}'！调用工具选择")
                        # 直接调用维修GUI的工具选择方法
                        self.maintenance_gui.on_tool_selected(tool_name)
                        return tool_name
            
            print("❌ 点击不在任何按钮范围内")
            return None
            
        except Exception as e:
            print(f"❌ 直接处理按钮点击失败: {e}")
            import traceback
            traceback.print_exc()
            return None

    def qt_mouse_release_event(self, event):
        """Qt鼠标释放事件处理（维修系统优化版）"""
        from PyQt5.QtCore import Qt

        # 只拦截左键释放，其他按键使用原有处理方式
        if event.button() == Qt.LeftButton:
            print('🖱️ 左键释放被拦截处理')
            
            # 维修系统模式：先让原有处理器处理
            if self.maintenance_gui:
                if hasattr(self, 'original_mouse_release_event'):
                    self.original_mouse_release_event(event)
            
            # 处理3D交互的鼠标释放
            self.on_mouse_up()
            event.accept()
        else:
            # 其他按键释放使用原有处理方式
            if hasattr(self, 'original_mouse_release_event'):
                self.original_mouse_release_event(event)
            else:
                event.ignore()

    def handle_qt_mouse_click(self, x, y):
        """处理Qt鼠标点击（转换为3D世界坐标）"""
        try:
            if not self.is_active:
                print("⚠️ 交互模式未激活")
                return
            
            # 检查操作权限
            if not self.check_operation_permission():
                return

            # 获取当前步骤的目标模型
            if self.current_step >= self.total_steps:
                print("⚠️ 所有步骤已完成")
                return

            step_data = self.config_data['steps'][self.current_step]
            target_model_name = step_data.get('target_model')

            if not target_model_name:
                print("⚠️ 当前步骤没有指定目标模型")
                return

            print(f'🎯 检测点击目标: {target_model_name}')

            # 获取窗口尺寸进行坐标转换
            if hasattr(self.world, 'qtWidget') and self.world.qtWidget:
                widget = self.world.qtWidget
                win_width = widget.width()
                win_height = widget.height()

                # 转换为Panda3D的标准化坐标
                mx = 2.0 * x / float(win_width) - 1.0
                my = 1.0 - 2.0 * y / float(win_height)

                # 执行射线检测
                self.perform_ray_cast(mx, my, target_model_name)
            else:
                print("❌ 找不到Qt部件，无法进行坐标转换")

        except Exception as e:
            print(f"❌ Qt鼠标点击处理失败: {e}")
            import traceback
            traceback.print_exc()

    def perform_ray_cast(self, mx, my, target_model_name):
        """执行射线检测"""
        try:
            # 获取鼠标射线
            from panda3d.core import Point3, Point2, CollisionTraverser, CollisionHandlerQueue
            from panda3d.core import CollisionNode, CollisionRay, BitMask32

            near_point = Point3()
            far_point = Point3()
            self.world.cam.node().getLens().extrude(Point2(mx, my), near_point, far_point)

            # 转换到世界坐标系
            world_near = self.world.render.getRelativePoint(self.world.camera, near_point)
            world_far = self.world.render.getRelativePoint(self.world.camera, far_point)

            # 进行真正的射线检测
            picker = CollisionTraverser()
            queue = CollisionHandlerQueue()

            # 创建射线碰撞检测
            pickerNode = CollisionNode('mouseRay')
            pickerNP = self.world.camera.attachNewNode(pickerNode)

            # 设置射线的碰撞掩码，匹配模型的碰撞掩码（第2位）
            pickerNode.setFromCollideMask(BitMask32.bit(1))

            # 使用相机坐标系的点创建射线
            direction = far_point - near_point
            direction.normalize()
            pickerNode.addSolid(CollisionRay(near_point, direction))

            picker.addCollider(pickerNP, queue)
            picker.traverse(self.world.render)

            # 检查是否点击到了目标模型
            hit_target_model = False
            hit_point = None

            if queue.getNumEntries() > 0:
                # 遍历所有碰撞结果
                for i in range(queue.getNumEntries()):
                    entry = queue.getEntry(i)
                    hit_node_path = entry.getIntoNodePath()
                    hit_pos = entry.getSurfacePoint(self.world.render)

                    # 检查是否击中了目标模型或其相关的碰撞体
                    if self.is_target_model_hit(hit_node_path, target_model_name):
                        print(f"✅ 击中目标模型: {hit_node_path.getName()}")
                        hit_target_model = True
                        hit_point = hit_pos
                        break

            # 清理碰撞检测节点
            pickerNP.removeNode()

            if hit_target_model:
                # 查找目标模型节点
                target_node = self.find_model_node(target_model_name)
                if target_node and not target_node.isEmpty():
                    # 根据操作类型决定行为
                    step_data = self.config_data['steps'][self.current_step]
                    operation_type = self.normalize_operation_type(step_data)
                    
                    if operation_type == 'drag':
                        print(f'✅ 开始拖拽目标模型: {target_node.getName()}')
                        self.start_dragging(target_node, hit_point)
                    elif operation_type == 'click':
                        print(f'✅ 点击触发位移模型: {target_node.getName()}')
                        self.trigger_click_movement(target_node, step_data)
                    else:
                        print(f"❌ 未知的操作类型: {operation_type}")
                else:
                    print(f"❌ 找不到目标模型节点: {target_model_name}")
            else:
                print(f"❌ 没有点击到目标模型 '{target_model_name}'，请点击正确的模型")

        except Exception as e:
            print(f"❌ 射线检测失败: {e}")
            import traceback
            traceback.print_exc()

    def is_target_model_hit(self, hit_node_path, target_model_name):
        """检查击中的节点是否是目标模型"""
        hit_name = hit_node_path.getName()

        # 直接匹配模型名称
        if hit_name == target_model_name:
            return True

        # 检查是否是模型的碰撞体（通常以modelCollision_开头）
        if hit_name.startswith("modelCollision_"):
            collision_model_name = hit_name.replace("modelCollision_", "", 1)
            if collision_model_name == target_model_name:
                return True

        # 检查父节点是否是目标模型
        parent = hit_node_path.getParent()
        while parent and not parent.isEmpty() and parent != self.world.render:
            parent_name = parent.getName()
            if parent_name == target_model_name:
                return True
            parent = parent.getParent()

        # 检查子节点路径
        current = hit_node_path
        while current and not current.isEmpty():
            if current.getName() == target_model_name:
                return True
            current = current.getParent()

        return False

    def on_mouse_down(self):
        """鼠标按下事件（优化版 v2：处理兄弟节点结构的碰撞体）"""
        if not self.is_active or not self.world.mouseWatcherNode.hasMouse():
            return
        # 获取鼠标位置并发射射线
        mouse_pos = self.world.mouseWatcherNode.getMouse()
        picker_ray = self.picker_ray_node.node().getSolid(0)
        picker_ray.setFromLens(self.world.camNode, mouse_pos.getX(), mouse_pos.getY())

        # 执行遍历
        self.picker_traverser.traverse(self.world.render)

        if self.collision_handler.getNumEntries() > 0:
            # 获取最近的碰撞点
            self.collision_handler.sortEntries()
            entry = self.collision_handler.getEntry(0)

            hit_node_path = entry.getIntoNodePath()
            hit_point = entry.getSurfacePoint(self.world.render)

            # --- 这是新的逻辑 ---
            # 打印被击中的碰撞体名字，用于调试
            print(f"射线击中了碰撞节点: {hit_node_path.getName()}")

            # 根据命名约定推导模型名称
            hit_name = hit_node_path.getName()
            derived_model_name = ""

            # 假设碰撞节点的命名规则是 "前缀 + 模型名"
            if hit_name.startswith("modelCollision_"):
                derived_model_name = hit_name.replace("modelCollision_", "", 1)
            else:
                derived_model_name = hit_name

            print(f"根据命名约定，推导出的模型名称为: {derived_model_name}")

            # 获取当前步骤的目标模型名称
            step_data = self.config_data['steps'][self.current_step]
            target_model_name = step_data.get('target_model')

            # 检查推导出的名称是否是当前步骤需要操作的目标
            if derived_model_name == target_model_name:
                print(f"✅ 击中正确！目标是 '{target_model_name}'")

                # 根据推导出的正确名称，去场景中查找可以被拖动的那个节点
                model_to_drag = self.find_model_node(derived_model_name)

                if model_to_drag and not model_to_drag.isEmpty():
                    self.start_dragging(model_to_drag, hit_point)
                else:
                    print(f"❌ 错误：虽然名称匹配，但在场景中找不到名为 '{derived_model_name}' 的可拖动节点！")
            else:
                print(f"❌ 击中的不是当前目标模型 (需要 '{target_model_name}', 击中了 '{derived_model_name}')")
    def start_dragging(self, model_node, hit_point):
        """开始拖拽模型（优化版：计算偏移量）"""
        # 再次检查操作权限（双重保险）
        if not self.check_operation_permission():
            print("⚠️ 权限检查失败，无法开始拖拽")
            return
            
        self.dragging_model = model_node

        # 1. 定义一个拖拽平面。这里我们使用一个平行于XZ的平面（法线为Y轴），
        #    并且该平面穿过模型的初始中心点。
        #    这意味着模型将在其初始高度上水平移动。
        #    您可以根据需要更改法线，例如 Vec3(0, 0, 1) 表示在XY平面上拖拽。
        plane_normal = Vec3(0, 1, 0)
        self.drag_plane = Plane(plane_normal, model_node.getPos())

        # 2. 计算鼠标射线与拖拽平面的交点。
        #    这个交点是鼠标在“拖拽世界”中的3D位置。
        plane_intersection_point = Point3()
        if self.drag_plane.intersectsLine(plane_intersection_point,
                                          self.world.camera.getPos(self.world.render),
                                          hit_point):
            # 3. 计算模型中心点和这个交点之间的偏移量。
            #    在整个拖拽过程中，我们将维持这个偏移量，以避免模型跳跃。
            self.drag_offset = model_node.getPos() - plane_intersection_point
            print(f"开始拖拽模型: {model_node.getName()}")
            print(f"初始位置: {model_node.getPos()}")

            # 启动拖拽任务
            self.world.taskMgr.add(self.drag_task, "drag_model_task")
        else:
            print("警告：无法计算拖拽平面的交点，拖拽取消。")
            self.dragging_model = None

    def drag_task(self, task):
        """拖拽任务（优化版：应用偏移量）"""
        if not self.dragging_model or not self.world.mouseWatcherNode.hasMouse():
            # 如果模型被置空或鼠标不在窗口内，则停止任务
            return task.done

        # 获取最新的鼠标位置
        mouse_pos = self.world.mouseWatcherNode.getMouse()

        # 再次从相机发射射线以获取鼠标在3D空间中的指向
        near_point = Point3()
        far_point = Point3()
        self.world.cam.node().getLens().extrude(mouse_pos, near_point, far_point)

        # 将近点和远点转换到世界坐标系
        origin_point = self.world.render.getRelativePoint(self.world.camera, near_point)
        direction_point = self.world.render.getRelativePoint(self.world.camera, far_point)

        # 计算射线与我们之前定义的拖拽平面的交点
        intersection_point = Point3()
        if self.drag_plane.intersectsLine(intersection_point, origin_point, direction_point):
                     # 新的位置 = 当前鼠标在拖拽平面上的3D位置 + 初始偏移量
         new_pos = intersection_point + self.drag_offset
         self.dragging_model.setPos(new_pos)

         # 初始化距离打印时间（如果还没有）
         if not hasattr(self, '_last_distance_print_time'):
             self._last_distance_print_time = 0

                  # 在拖拽过程中，实时显示距离原始位置的距离
         if hasattr(self, 'config_data') and self.current_step < len(self.config_data.get('steps', [])):
             step_data = self.config_data['steps'][self.current_step]
             step_type = self.normalize_step_type(step_data)
             target_model_name = step_data.get('target_model', '')
             
             if (target_model_name in self.model_original_positions and
                 hasattr(self, '_last_distance_print_time')):
                 
                 # 每0.5秒显示一次距离信息
                 current_time = task.time
                 if current_time - getattr(self, '_last_distance_print_time', 0) > 0.5:
                     original_pos = self.model_original_positions[target_model_name]
                     distance = (new_pos - original_pos).length()
                     
                     if step_type == 'assemble':
                         snap_tolerance = step_data.get('snap_tolerance') or step_data.get('tolerance', 5.0)
                         if distance <= snap_tolerance * 1.2:  # 只在接近时显示
                             print(f"📏 安装拖拽中 - 距离原位: {distance:.2f} (需要 <= {snap_tolerance:.2f})")
                     else:  # 拆卸模式
                         disassemble_threshold = step_data.get('disassemble_threshold', 5.0)
                         if distance >= disassemble_threshold * 0.8:  # 接近阈值时显示
                             print(f"📏 拆卸拖拽中 - 距离原位: {distance:.2f} (需要 >= {disassemble_threshold:.2f})")
                     
                     self._last_distance_print_time = current_time

        return task.cont

    def stop_dragging(self):
        """停止拖拽"""
        if not self.dragging_model:
            return

        print(f"停止拖拽模型: {self.dragging_model.getName()}")
        print(f"最终位置: {self.dragging_model.getPos()}")

        # 停止拖拽任务
        self.world.taskMgr.remove("drag_model_task")

        # 检查是否完成了当前步骤
        self.check_step_completion()

        # 清理拖拽状态
        self.dragging_model = None

    def on_mouse_up(self):
        """鼠标抬起事件"""
        self.stop_dragging()

    def check_step_completion(self):
        """检查步骤是否完成"""
        if not self.dragging_model:
            return

        step_data = self.config_data['steps'][self.current_step]
        step_type = self.normalize_step_type(step_data)
        print(f"检查步骤完成: {step_type} ----------------------------------------")
        target_model_name = step_data.get('target_model', '')
        current_pos = self.dragging_model.getPos()

        if step_type == 'assemble':
            # 安装模式：检查是否接近原始位置
            if target_model_name in self.model_original_positions:
                original_pos = self.model_original_positions[target_model_name]
                distance_to_original = (original_pos - current_pos).length()
                # 吸附容差：优先使用配置的snap_tolerance，否则使用拆卸时的tolerance，最后默认5.0
                snap_tolerance = step_data.get('snap_tolerance') or step_data.get('tolerance', 5.0)

                print(f"🔧 安装模式 - 距离原始位置: {distance_to_original:.2f}")
                print(f"🎯 吸附容差: {snap_tolerance:.2f}")
                print(f"🔍 吸附条件: {distance_to_original:.2f} <= {snap_tolerance:.2f} = {distance_to_original <= snap_tolerance}")

                if distance_to_original <= snap_tolerance:
                    # 自动吸附到原始位置
                    print(f"✨ 自动吸附到原始位置！")
                    print(f"📍 精确位置: {original_pos}")
                    self.dragging_model.setPos(original_pos)
                    self.model_current_states[target_model_name] = 'installed'
                    print(f"步骤 {self.current_step + 1} 完成！模型已安装到原始位置")
                    self.complete_current_step()
                    return
                else:
                    print(f"距离原始位置还有 {distance_to_original:.2f} 单位，需要更接近才能自动吸附")
            else:
                print("⚠️ 没有找到模型的原始位置记录")

        else:
            # 拆卸模式：检查是否远离原始位置
            if target_model_name in self.model_original_positions:
                original_pos = self.model_original_positions[target_model_name]
                distance_from_original = (current_pos - original_pos).length()
                disassemble_threshold = step_data.get('disassemble_threshold', 5.0)  # 拆卸距离阈值
                
                print(f"🔧 拆卸模式 - 距离原始位置: {distance_from_original:.2f}")
                print(f"🎯 拆卸阈值: {disassemble_threshold:.2f}")
                print(f"🔍 拆卸条件: {distance_from_original:.2f} >= {disassemble_threshold:.2f} = {distance_from_original >= disassemble_threshold}")
                
                if distance_from_original >= disassemble_threshold:
                    print(f"步骤 {self.current_step + 1} 完成！模型已拆卸，距离原位 {distance_from_original:.2f} >= {disassemble_threshold:.2f}")
                    if target_model_name:
                        self.model_current_states[target_model_name] = 'removed'
                    self.complete_current_step()
                    return
                else:
                    print(f"需要将模型拖拽到距离原位至少 {disassemble_threshold:.2f} 单位（当前 {distance_from_original:.2f}）")
            else:
                # 如果没有原始位置记录，回退到原来的目标位置模式
                print("⚠️ 没有找到模型的原始位置记录，使用目标位置模式")
                target_pos_data = step_data.get('target_position')

                if target_pos_data is None:
                    # 如果没有定义目标位置，拆卸后即完成
                    print("拆卸模式 - 没有定义目标位置，视为完成。")
                    if target_model_name:
                        self.model_current_states[target_model_name] = 'removed'
                    self.complete_current_step()
                    return

                target_pos = Vec3(*target_pos_data)
                distance = (target_pos - current_pos).length()
                tolerance = step_data.get('tolerance', 5)

                if distance <= tolerance:
                    print(f"步骤 {self.current_step + 1} 完成！拆卸到目标位置 距离 {distance:.2f} < 容差 {tolerance}")
                    if target_model_name:
                        self.model_current_states[target_model_name] = 'removed'
                    self.complete_current_step()
                else:
                    print(f"距离目标位置还有 {distance:.2f} 单位，未达到容差 {tolerance}")

    def complete_current_step(self):
        """完成当前步骤"""
        # 记录操作完成（考核模式下）
        if self.mode == "exam" and self.current_step in self.step_scores:
            self.step_scores[self.current_step]['operation_attempts'] += 1
            print(f"📝 考核记录：步骤 {self.current_step + 1} 完成，操作次数: {self.step_scores[self.current_step]['operation_attempts']}")
        
        # 在进入下一步之前，取消当前模型的碰撞，避免干扰
        step_data = self.config_data['steps'][self.current_step]
        target_model_name = step_data.get('target_model')
        if target_model_name:
            node = self.find_model_node(target_model_name)
            if node:
                node.setCollideMask(BitMask32.allOff())

        # 显示当前所有模型的状态
        self.show_models_status()

        self.current_step += 1

        if self.current_step >= self.total_steps:
            self.finish_interaction()
        else:
            self.start_current_step()

    def finish_interaction(self):
        """完成所有交互"""
        print("\n🎉 所有拆装步骤已完成！")
        self.is_active = False
        self.ignoreAll()

        # 清理维修系统GUI
        if self.maintenance_gui:
            self.maintenance_gui.cleanup_gui()
            print("✅ 维修系统GUI已清理")

        # 恢复原有的Qt鼠标事件处理
        print("🔄 恢复原有的Qt鼠标事件处理")
        if hasattr(self, 'original_mouse_press_event') and hasattr(self.world, 'qtWidget') and self.world.qtWidget:
            self.world.qtWidget.mousePressEvent = self.original_mouse_press_event
            self.world.qtWidget.mouseReleaseEvent = self.original_mouse_release_event
            print("✅ 原有Qt鼠标事件处理已恢复")
        else:
            print("⚠️ 没有找到备份的Qt事件处理方法")

        if self.step_dialog:
            self.step_dialog.close()
            self.step_dialog = None

        # 根据模式显示不同的完成结果
        if self.mode == "exam":
            # 考核模式：显示详细的考核结果
            self.show_exam_results()
        else:
            # 训练模式：显示训练完成提示
            print("\n🎉 训练模式完成！")
            completion_msg = "🎉 训练完成！\n\n所有维修步骤已完成！\n现在可以尝试考核模式检验学习成果。"
            
            if self.maintenance_gui:
                self.maintenance_gui.update_step_info(completion_msg)
                print("📋 训练完成信息已在GUI中显示")
            else:
                QMessageBox.information(None, "训练完成", completion_msg)
    
    def stop_interaction(self):
        """用户主动停止交互"""
        print("\n🛑 用户主动停止拆装交互")
        
        try:
            # 设置为非活动状态
            self.is_active = False
            self.ignoreAll()

            # 清理维修系统GUI
            if self.maintenance_gui:
                self.maintenance_gui.cleanup_gui()
                print("✅ 维修系统GUI已清理")

            # 恢复原有的Qt鼠标事件处理
            print("🔄 恢复原有的Qt鼠标事件处理")
            if hasattr(self, 'original_mouse_press_event') and hasattr(self.world, 'qtWidget') and self.world.qtWidget:
                self.world.qtWidget.mousePressEvent = self.original_mouse_press_event
                self.world.qtWidget.mouseReleaseEvent = self.original_mouse_release_event
                print("✅ 原有Qt鼠标事件处理已恢复")
            else:
                print("⚠️ 没有找到备份的Qt事件处理方法")

            # 关闭步骤对话框
            if self.step_dialog:
                self.step_dialog.close()
                self.step_dialog = None

            # 显示停止确认信息
            if self.mode == "exam":
                stop_msg = "🛑 考核已停止\n\n您的考核进度没有被保存。"
            else:
                stop_msg = "🛑 训练已停止\n\n您可以随时重新开始训练。"
            
            if self.maintenance_gui:
                # 如果GUI还在，显示停止信息
                self.maintenance_gui.update_step_info(stop_msg)
            else:
                QMessageBox.information(None, "操作停止", stop_msg)
            
            print("✅ 拆装交互已停止")
            
        except Exception as e:
            print(f"❌ 停止拆装交互失败: {e}")
            import traceback
            traceback.print_exc()
    
    def show_exam_results(self):
        """显示考核结果"""
        try:
            # 计算最终得分
            final_score = 0
            total_operations = 0
            total_errors = 0
            
            for step_record in self.step_scores.values():
                final_score += step_record['current_score']
                total_operations += step_record['operation_attempts']
                if step_record['tool_error']:
                    total_errors += 1
            
            # 计算得分率和准确率
            score_rate = (final_score / self.exam_max_score * 100) if self.exam_max_score > 0 else 0
            accuracy_rate = ((self.total_steps - total_errors) / self.total_steps * 100) if self.total_steps > 0 else 100
            
            # 生成考核报告
            print(f"\n{'='*50}")
            print(f"🎓 维修技能考核结果报告")
            print(f"{'='*50}")
            print(f"📊 总体成绩:")
            print(f"   总得分: {final_score:.0f} / {self.exam_max_score:.0f} 分")
            print(f"   得分率: {score_rate:.1f}%")
            print(f"   操作准确率: {accuracy_rate:.1f}%")
            print(f"   总操作次数: {total_operations}")
            print(f"   错误次数: {total_errors}")
            
            # 评级系统
            if score_rate >= 90:
                grade = "优秀"
                grade_icon = "🏆"
                grade_desc = "表现卓越，技能熟练"
            elif score_rate >= 80:
                grade = "良好"
                grade_icon = "🥈"
                grade_desc = "表现良好，基本掌握"
            elif score_rate >= 60:
                grade = "及格"
                grade_icon = "✅"
                grade_desc = "达到基本要求"
            else:
                grade = "不及格"
                grade_icon = "❌"
                grade_desc = "需要加强练习"
            
            print(f"\n🏅 评级: {grade_icon} {grade}")
            print(f"   评语: {grade_desc}")
            
            # 详细步骤分析
            print(f"\n📋 详细步骤分析:")
            print(f"{'-'*40}")
            
            perfect_steps = 0
            for step_idx, step_record in self.step_scores.items():
                step_data = self.config_data['steps'][step_idx]
                step_name = step_data.get('name', f'步骤{step_idx+1}')
                max_score = step_record['max_score']
                current_score = step_record['current_score']
                tool_error = step_record['tool_error']
                attempts = step_record['operation_attempts']
                
                # 判断步骤完成质量
                if current_score >= max_score:
                    step_status = "🟢 完美"
                    perfect_steps += 1
                elif current_score >= max_score * 0.8:
                    step_status = "🟡 良好"
                elif current_score > 0:
                    step_status = "🟠 一般"
                else:
                    step_status = "🔴 失败"
                
                print(f"{step_name}:")
                print(f"   状态: {step_status}")
                print(f"   得分: {current_score:.0f}/{max_score:.0f} 分")
                print(f"   工具使用: {'❌ 错误' if tool_error else '✅ 正确'}")
                print(f"   操作次数: {attempts}")
                print()
            
            # 生成改进建议
            suggestions = []
            if total_errors > 0:
                suggestions.append("• 注意选择正确的工具进行操作")
            if total_operations > self.total_steps * 1.5:
                suggestions.append("• 减少不必要的操作，提高操作效率")
            if perfect_steps < self.total_steps * 0.5:
                suggestions.append("• 多练习以提高操作的精确度")
            if score_rate < 80:
                suggestions.append("• 建议重新学习相关理论知识")
            
            if suggestions:
                print("💡 改进建议:")
                for suggestion in suggestions:
                    print(f"   {suggestion}")
                print()
            
            print(f"{'='*50}")
            
            # 为GUI显示准备简化版本的报告
            gui_report = f"🎓 考核完成！\n\n"
            gui_report += f"📊 成绩总览:\n"
            gui_report += f"总得分: {final_score:.0f}/{self.exam_max_score:.0f} 分 ({score_rate:.1f}%)\n"
            gui_report += f"评级: {grade_icon} {grade}\n"
            gui_report += f"操作准确率: {accuracy_rate:.1f}%\n\n"
            gui_report += f"完美完成步骤: {perfect_steps}/{self.total_steps}\n"
            gui_report += f"总操作次数: {total_operations}\n"
            gui_report += f"错误次数: {total_errors}"
            
            # 在维修GUI中显示详细考核结果
            if self.maintenance_gui:
                # 创建详细的考核结果数据
                exam_result_data = {
                    'final_score': final_score,
                    'max_score': self.exam_max_score,
                    'score_rate': score_rate,
                    'accuracy_rate': accuracy_rate,
                    'grade': grade,
                    'grade_icon': grade_icon,
                    'grade_desc': grade_desc,
                    'total_operations': total_operations,
                    'total_errors': total_errors,
                    'perfect_steps': perfect_steps,
                    'total_steps': self.total_steps,
                    'step_details': [],
                    'suggestions': suggestions
                }
                
                # 添加每步详情
                for step_idx, step_record in self.step_scores.items():
                    step_data = self.config_data['steps'][step_idx]
                    step_name = step_data.get('name', f'步骤{step_idx+1}')
                    max_score = step_record['max_score']
                    current_score = step_record['current_score']
                    tool_error = step_record['tool_error']
                    attempts = step_record['operation_attempts']
                    
                    # 判断步骤完成质量
                    if current_score >= max_score:
                        step_status = "🟢 完美"
                    elif current_score >= max_score * 0.8:
                        step_status = "🟡 良好"
                    elif current_score > 0:
                        step_status = "🟠 一般"
                    else:
                        step_status = "🔴 失败"
                    
                    exam_result_data['step_details'].append({
                        'name': step_name,
                        'status': step_status,
                        'current_score': current_score,
                        'max_score': max_score,
                        'tool_error': tool_error,
                        'attempts': attempts
                    })
                
                # 使用GUI显示考核结果
                self.maintenance_gui.show_exam_results(exam_result_data)
                print("📋 考核结果已在GUI中显示")
            else:
                # 如果没有GUI，使用简单的控制台输出
                print("⚠️ 维修GUI不可用，考核结果仅在控制台显示")
            
            # 保存考核结果到文件（可选）
            self.save_exam_results(final_score, score_rate, grade)
            
        except Exception as e:
            print(f"❌ 显示考核结果失败: {e}")
            import traceback
            traceback.print_exc()
            QMessageBox.critical(None, "错误", f"显示考核结果失败: {str(e)}")

    def save_exam_results(self, final_score, score_rate, grade):
        """保存考核结果到文件"""
        try:
            import datetime
            import json
            
            # 生成考核记录
            exam_record = {
                "timestamp": datetime.datetime.now().isoformat(),
                "mode": "exam",
                "final_score": final_score,
                "max_score": self.exam_max_score,
                "score_rate": score_rate,
                "grade": grade,
                "total_steps": self.total_steps,
                "step_details": {}
            }
            
            # 添加每步详情
            for step_idx, step_record in self.step_scores.items():
                step_name = self.config_data['steps'][step_idx].get('name', f'步骤{step_idx+1}')
                exam_record["step_details"][step_name] = {
                    "max_score": step_record['max_score'],
                    "current_score": step_record['current_score'],
                    "tool_error": step_record['tool_error'],
                    "operation_attempts": step_record['operation_attempts']
                }
            
            # 保存到文件
            filename = f"exam_result_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
            filepath = os.path.join(".", filename)
            
            with open(filepath, 'w', encoding='utf-8') as f:
                json.dump(exam_record, f, ensure_ascii=False, indent=2)
            
            print(f"📄 考核结果已保存到: {filepath}")
            
        except Exception as e:
            print(f"⚠️ 保存考核结果失败: {e}")
            # 不影响主流程，只是记录警告

    def stop_interaction_mode(self):
        """停止交互模式"""
        self.is_active = False
        self.ignoreAll()

        # 恢复原有的Qt鼠标事件处理
        print("🔄 恢复原有的Qt鼠标事件处理")
        if hasattr(self, 'original_mouse_press_event') and hasattr(self.world, 'qtWidget') and self.world.qtWidget:
            self.world.qtWidget.mousePressEvent = self.original_mouse_press_event
            self.world.qtWidget.mouseReleaseEvent = self.original_mouse_release_event
            print("✅ 原有Qt鼠标事件处理已恢复")
        else:
            print("⚠️ 没有找到备份的Qt事件处理方法")

        if self.step_dialog:
            self.step_dialog.close()
            self.step_dialog = None

        self.world.taskMgr.remove("drag_model_task")
        print("拆装交互模式已停止")

    def trigger_drag_by_keyboard(self):
        """通过键盘触发拖拽（备用方案）"""
        if not self.is_active or self.dragging_model:
            return

        print("⌨️ 使用键盘备用方案触发拖拽")
        step_data = self.config_data['steps'][self.current_step]
        target_model_name = step_data.get('target_model')

        if not target_model_name:
            print("当前步骤没有指定目标模型")
            return

        target_node = self.find_model_node(target_model_name)
        if not target_node:
            print(f"找不到目标模型: {target_model_name}")
            return

        # 对于键盘触发，我们无法获取精确的hit_point，
        # 所以直接使用模型的中心点作为模拟的点击点。
        self.start_dragging(target_node, target_node.getPos())

    def trigger_click_movement(self, model_node, step_data):
        """触发点击位移动画"""
        try:
            # 检查操作权限（双重保险）
            if not self.check_operation_permission():
                print("⚠️ 权限检查失败，无法进行点击触发位移")
                return
                
            step_type = self.normalize_step_type(step_data)
            target_model_name = step_data.get('target_model', '')
            
            print(f"🎬 开始点击触发位移: {model_node.getName()}")
            print(f"📋 步骤类型: {step_type}")
            
            if step_type == 'disassemble':
                # 拆卸模式：移动到目标位置然后隐藏
                self.perform_disassemble_click_movement(model_node, step_data)
            elif step_type == 'assemble':
                # 安装模式：显示模型然后移动到原始位置
                self.perform_assemble_click_movement(model_node, step_data)
            else:
                print(f"❌ 未知的步骤类型: {step_type}")
                
        except Exception as e:
            print(f"❌ 点击触发位移失败: {e}")
            import traceback
            traceback.print_exc()

    def perform_disassemble_click_movement(self, model_node, step_data):
        """执行拆卸点击位移"""
        target_model_name = step_data.get('target_model', '')
        
        # 记录当前位置为原始位置（如果还没有记录）
        if target_model_name not in self.model_original_positions:
            current_pos = model_node.getPos()
            self.model_original_positions[target_model_name] = current_pos
            print(f"📍 记录模型 '{target_model_name}' 的原始位置: {current_pos}")
        
        # 获取目标位移位置
        target_pos_data = step_data.get('target_position')
        if not target_pos_data:
            print("❌ 拆卸步骤缺少target_position配置")
            return
        
        target_pos = Vec3(*target_pos_data)
        print(f"🎯 目标位置: {target_pos}")
        
        # 获取动画时长
        animation_duration = step_data.get('animation_duration', 2.0)
        
        # 创建位移动画序列
        from direct.interval.IntervalGlobal import LerpPosInterval, Sequence, Func
        
        move_interval = LerpPosInterval(
            model_node,
            animation_duration,
            target_pos,
            name=f"disassemble_{target_model_name}"
        )
        
        # 动画完成后的回调
        def on_disassemble_complete():
            print(f"✅ 拆卸动画完成，隐藏模型: {target_model_name}")
            model_node.hide()  # 隐藏模型
            self.model_current_states[target_model_name] = 'removed'
            self.complete_current_step()  # 完成当前步骤
        
        # 创建动画序列
        disassemble_sequence = Sequence(
            move_interval,
            Func(on_disassemble_complete),
            name=f"disassemble_sequence_{target_model_name}"
        )
        
        print(f"🎬 开始拆卸动画，持续时间: {animation_duration}秒")
        disassemble_sequence.start()

    def perform_assemble_click_movement(self, model_node, step_data):
        """执行安装点击位移"""
        target_model_name = step_data.get('target_model', '')
        
        # 确保模型可见（通常在步骤开始时已经显示，这里是双重保险）
        if model_node.isHidden():
            print(f"👁️ 点击触发时显示模型: {target_model_name}")
            model_node.show()
        else:
            print(f"✅ 模型 '{target_model_name}' 已经可见，开始安装动画")
        
        # 获取原始位置
        if target_model_name not in self.model_original_positions:
            print(f"❌ 找不到模型 '{target_model_name}' 的原始位置")
            return
        
        original_pos = self.model_original_positions[target_model_name]
        print(f"🏠 原始位置: {original_pos}")
        
        # 获取动画时长
        animation_duration = step_data.get('animation_duration', 2.0)
        
        # 创建位移动画序列
        from direct.interval.IntervalGlobal import LerpPosInterval, Sequence, Func
        
        move_interval = LerpPosInterval(
            model_node,
            animation_duration,
            original_pos,
            name=f"assemble_{target_model_name}"
        )
        
        # 动画完成后的回调
        def on_assemble_complete():
            print(f"✅ 安装动画完成，模型回到原位: {target_model_name}")
            model_node.setPos(original_pos)  # 确保精确位置
            self.model_current_states[target_model_name] = 'installed'
            self.complete_current_step()  # 完成当前步骤
        
        # 创建动画序列
        assemble_sequence = Sequence(
            move_interval,
            Func(on_assemble_complete),
            name=f"assemble_sequence_{target_model_name}"
        )
        
        print(f"🎬 开始安装动画，持续时间: {animation_duration}秒")
        assemble_sequence.start()


class StepGuideDialog(QDialog):
    """步骤指引对话框（UI代码保持不变）"""

    def __init__(self, interaction_manager, parent=None):
        super().__init__(parent)
        self.interaction_manager = interaction_manager
        self.current_required_tool = "无"  # 当前步骤要求的工具
        self.mode = interaction_manager.mode  # 获取模式

        self.chinese_font = None
        if hasattr(interaction_manager.world,'getChineseFont'):
            self.chinese_font = interaction_manager.world.getChineseFont()

        self.setupUI()

    def setupUI(self):
        if self.mode == "exam":
            self.setWindowTitle("拆装考核")
        else:
            self.setWindowTitle("拆装步骤指引")

        self.setFixedSize(450, 400)
        self.setWindowFlags(Qt.Window | Qt.WindowStaysOnTopHint)
        layout = QVBoxLayout(self)

        # 步骤信息
        self.step_info_label = QLabel("准备开始...")
        self.step_info_label.setStyleSheet("font-size: 14px; font-weight: bold; color: #2E86C1;")
        if self.chinese_font:
            self.step_info_label.setFont(self.chinese_font)
        layout.addWidget(self.step_info_label)

        # 步骤描述（考核模式下隐藏）
        if self.mode != "exam":
            self.step_desc_text = QTextEdit()
            self.step_desc_text.setMaximumHeight(100)
            self.step_desc_text.setReadOnly(True)
            if self.chinese_font:
                self.step_desc_text.setFont(self.chinese_font)
            layout.addWidget(self.step_desc_text)
        else:
            self.step_desc_text = None

        # 工具选择组
        tool_group = QGroupBox("工具选择")
        if self.chinese_font:
            tool_group.setFont(self.chinese_font)
        tool_layout = QVBoxLayout(tool_group)

        # 在训练模式下显示要求的工具，考核模式下不显示
        if self.mode != "exam":
            self.required_tool_label = QLabel("当前步骤要求工具: 无")
            self.required_tool_label.setStyleSheet("font-weight: bold; color: #E74C3C;")
            if self.chinese_font:
                self.required_tool_label.setFont(self.chinese_font)
            tool_layout.addWidget(self.required_tool_label)
        else:
            self.required_tool_label = None

        current_tool_layout = QHBoxLayout()
        current_tool_label = QLabel("当前选择工具:")
        if self.chinese_font:
            current_tool_label.setFont(self.chinese_font)
        current_tool_layout.addWidget(current_tool_label)
        self.current_tool_combo = QComboBox()
        self.current_tool_combo.addItem("无")  # 默认只有"无"选项
        self.current_tool_combo.currentTextChanged.connect(self.on_tool_changed)
        if self.chinese_font:
            self.current_tool_combo.setFont(self.chinese_font)
        current_tool_layout.addWidget(self.current_tool_combo)
        tool_layout.addLayout(current_tool_layout)

        # 在训练模式下显示工具状态，考核模式下不显示
        if self.mode != "exam":
            self.tool_status_label = QLabel("✅ 工具匹配，可以进行操作")
            self.tool_status_label.setStyleSheet("color: #27AE60; font-weight: bold;")
            if self.chinese_font:
                self.tool_status_label.setFont(self.chinese_font)
            tool_layout.addWidget(self.tool_status_label)
        else:
            self.tool_status_label = None

        layout.addWidget(tool_group)

        # 操作提示（考核模式下隐藏）
        if self.mode != "exam":
            self.operation_label = QLabel("操作提示：")
            self.operation_label.setStyleSheet("font-weight: bold;")
            if self.chinese_font:
                self.operation_label.setFont(self.chinese_font)
            layout.addWidget(self.operation_label)
            self.operation_text = QTextEdit()
            self.operation_text.setMaximumHeight(80)
            self.operation_text.setReadOnly(True)
            if self.chinese_font:
                self.operation_text.setFont(self.chinese_font)
            layout.addWidget(self.operation_text)
        else:
            self.operation_label = None
            self.operation_text = None

        # 按钮
        button_layout = QHBoxLayout()
        self.skip_button = QPushButton("跳过当前步骤")
        if self.chinese_font:
            self.skip_button.setFont(self.chinese_font)
        self.skip_button.clicked.connect(self.skip_current_step)
        button_layout.addWidget(self.skip_button)
        self.stop_button = QPushButton("停止交互")
        if self.chinese_font:
            self.stop_button.setFont(self.chinese_font)
        self.stop_button.clicked.connect(self.stop_interaction)
        button_layout.addWidget(self.stop_button)
        layout.addLayout(button_layout)

        # 初始化工具状态
        self.sync_current_tool()
        self.update_tool_status()

    def sync_current_tool(self):
        """初始化拆装工具状态"""
        # 从配置文件中加载工具列表
        self.load_tools_from_config()
        # 默认选择"无"
        self.current_tool_combo.setCurrentText("无")
        print(f"🔧 初始化拆装工具: 无")
    
    def load_tools_from_config(self):
        """从配置文件中加载工具列表"""
        # 清空现有工具选项（保留"无"）
        self.current_tool_combo.clear()
        self.current_tool_combo.addItem("无")
        
        # 从配置文件中加载工具
        if hasattr(self.interaction_manager, 'config_data') and self.interaction_manager.config_data:
            tools = self.interaction_manager.config_data.get('tools', [])
            for tool in tools:
                tool_name = tool.get('name', '')
                if tool_name and tool_name != "无":
                    self.current_tool_combo.addItem(tool_name)
                    print(f"🔧 加载工具: {tool_name}")
            
            if len(tools) > 0:
                print(f"🔧 从配置文件加载了 {len(tools)} 个工具")
            else:
                print("🔧 配置文件中没有定义工具")
        else:
            print("⚠️ 无法访问配置数据")

    def on_tool_changed(self, tool_name):
        """工具改变时的处理"""
        print(f"🔧 用户选择拆装工具: {tool_name}")
        
        # 拆装工具不需要同步到编辑器的工具管理器
        # 这里是独立的拆装工具选择
        
        # 更新工具状态显示
        self.update_tool_status()
    
    def update_tool_status(self):
        """更新工具状态显示"""
        current_tool = self.current_tool_combo.currentText()
        required_tool = self.current_required_tool
        
        # 检查工具是否匹配
        tool_matches = self.check_tool_permission(current_tool, required_tool)
        
        if self.mode == "training":
            # 训练模式：显示工具匹配状态
            if tool_matches:
                self.tool_status_label.setText("✅ 工具匹配，可以进行操作")
                self.tool_status_label.setStyleSheet("color: #27AE60; font-weight: bold;")
                # 启用交互操作
                self.interaction_manager.set_operation_enabled(True)
            else:
                self.tool_status_label.setText(f"❌ 工具不匹配，需要选择 '{required_tool}' 工具")
                self.tool_status_label.setStyleSheet("color: #E74C3C; font-weight: bold;")
                # 禁用交互操作
                self.interaction_manager.set_operation_enabled(False)
        else:
            # 考核模式：不显示工具状态，但仍然需要正确的工具才能操作
            # 这里不再总是启用操作，而是让权限检查在实际操作时进行
            self.interaction_manager.set_operation_enabled(True)
    
    def check_tool_permission(self, current_tool, required_tool):
        """检查工具权限"""
        # 如果步骤不要求特定工具，任何工具都可以
        if required_tool == "无" or required_tool == "" or not required_tool:
            return True
        
        # 精确匹配
        if current_tool == required_tool:
            return True
        
        return False

    def update_step_info(self, step_data, current_step, total_steps):
        step_name = step_data.get('name', f'步骤 {current_step}')

        if self.mode == "exam":
            # 考核模式：显示考核信息
            step_score = step_data.get('score', 10)
            self.step_info_label.setText(f"第 {current_step}/{total_steps} 步: {step_name} (分值: {step_score})")
        else:
            # 训练模式：正常显示
            self.step_info_label.setText(f"第 {current_step}/{total_steps} 步: {step_name}")

        # 为动态文本设置中文字体
        if self.chinese_font:
            self.step_info_label.setFont(self.chinese_font)

        # 步骤描述（考核模式下不显示）
        if self.step_desc_text is not None:
            step_desc = step_data.get('description', '无描述')
            self.step_desc_text.setPlainText(step_desc)
            if self.chinese_font:
                self.step_desc_text.setFont(self.chinese_font)

        # 更新工具要求
        self.current_required_tool = step_data.get('required_tool', '无')
        if self.required_tool_label is not None:
            self.required_tool_label.setText(f"当前步骤要求工具: {self.current_required_tool}")
            if self.chinese_font:
                self.required_tool_label.setFont(self.chinese_font)

        # 更新工具状态
        self.update_tool_status()

        operation_type = self.interaction_manager.normalize_operation_type(step_data)
        step_type = self.interaction_manager.normalize_step_type(step_data)
        target_model = step_data.get('target_model', '未指定')

        if operation_type == 'drag':
            if step_type == 'assemble':
                snap_tolerance = step_data.get('snap_tolerance') or step_data.get('tolerance', 5.0)
                operation_hint = f"🔧 安装操作\n请用鼠标左键点击并拖拽模型 '{target_model}' 到原始位置附近。\n当距离原始位置 {snap_tolerance:.1f} 单位内时，模型会自动吸附到正确位置。"
            else:
                disassemble_threshold = step_data.get('disassemble_threshold', 5.0)
                operation_hint = f"🔧 拆卸操作\n请用鼠标左键点击并拖拽模型 '{target_model}' 脱离原位。\n拖拽到距离原始位置 {disassemble_threshold:.1f} 单位外即可完成。"
        elif operation_type == 'click':
            if step_type == 'assemble':
                animation_duration = step_data.get('animation_duration', 2.0)
                operation_hint = f"🔧 安装操作（点击触发）\n请点击模型 '{target_model}' 触发自动安装。\n模型将自动移动到原始位置（动画时长 {animation_duration:.1f}秒）。"
            else:
                target_pos_data = step_data.get('target_position')
                animation_duration = step_data.get('animation_duration', 2.0)
                if target_pos_data:
                    from panda3d.core import Vec3
                    target_pos = Vec3(*target_pos_data)
                    operation_hint = f"🔧 拆卸操作（点击触发）\n请点击模型 '{target_model}' 触发自动拆卸。\n模型将自动移动到位置 {target_pos}（动画时长 {animation_duration:.1f}秒），然后隐藏。"
                else:
                    operation_hint = f"🔧 拆卸操作（点击触发）\n请点击模型 '{target_model}' 触发自动拆卸。\n⚠️ 警告：缺少target_position配置"
        else:
            # 未知操作类型的回退提示
            if step_type == 'assemble':
                operation_hint = f"🔧 安装操作\n请操作模型 '{target_model}' 将其安装到原位。"
            else:
                operation_hint = f"🔧 拆卸操作\n请操作模型 '{target_model}' 将其拆卸。"

        # 操作提示（考核模式下不显示）
        if self.operation_text is not None:
            self.operation_text.setPlainText(operation_hint)
            if self.chinese_font:
                self.operation_text.setFont(self.chinese_font)

    def skip_current_step(self):
        if self.interaction_manager.is_active:
            # 停止可能正在进行的拖拽
            if self.interaction_manager.dragging_model:
                self.interaction_manager.stop_dragging()
            self.interaction_manager.complete_current_step()

    def stop_interaction(self):
        self.interaction_manager.stop_interaction_mode()
        self.close()

    def closeEvent(self, event):
        reply = QMessageBox.question(self, "确认", "是否要停止拆装交互？",
                                     QMessageBox.Yes | QMessageBox.No)
        if reply == QMessageBox.Yes:
            self.stop_interaction()
            event.accept()
        else:
            event.ignore()