pindo 5.13.7 → 5.13.9

data/lib/pindo/module/unity/unity_helper.rb

@@ -3,361 +3,87 @@ require 'json'
 require 'singleton'
 require 'pindo/base/funlog'
 require 'pindo/config/pindoconfig'
+require 'pindo/module/unity/unity_env_helper'
+require 'pindo/module/unity/unity_proc_helper'
+require 'pindo/module/unity/unity_command_helper'
 
 # 定义Informative异常类
 class Informative < StandardError; end
 
 module Pindo
-  module Client
+  module Unity
     class UnityHelper
       include Singleton
 
-      UNITY_MAC_PATHS = [
-        "/Applications/Unity/Unity.app/Contents/MacOS/Unity",
-        "/Applications/Unity/Hub/Editor/*/Unity.app/Contents/MacOS/Unity",
-        "/Applications/Unity/*/Unity.app/Contents/MacOS/Unity"
-      ]
-
-      UNITY_WINDOWS_PATHS = [
-        "C:/Program Files/Unity/Editor/Unity.exe",
-        "C:/Program Files/Unity/Hub/Editor/*/Unity.exe",
-        "C:/Program Files/Unity/*/Editor/Unity.exe"
-      ]
-
       class << self
         def share_instance
           instance
         end
       end
 
-      def find_unity_path(project_unity_version:nil, force_change_version:false)
-
-        if project_unity_version.nil? || project_unity_version.empty?
-          raise "Project Unity version is nil or empty"
-        end
-
-        unity_major_version = project_unity_version.split('.')[0..1].join('.')
-        paths = case RUBY_PLATFORM
-                when /darwin/
-                  UNITY_MAC_PATHS
-                when /mswin|mingw|windows/
-                  UNITY_WINDOWS_PATHS
-                else
-                  raise "Unsupported platform: #{RUBY_PLATFORM}"
-                end
-
-        unity_versions = []
-
-        paths.each do |path|
-          if path.include?("*")
-            Dir.glob(path).each do |expanded_path|
-              version = extract_version_from_path(expanded_path)
-              if version
-                major_version = version.split('.')[0..1].join('.')
-                unity_versions << {
-                  path: expanded_path,
-                  version: version,
-                  major_version: major_version
-                }
-              end
-            end
-          elsif File.exist?(path)
-            version = extract_version_from_path(path)
-            if version
-              major_version = version.split('.')[0..1].join('.')
-              unity_versions << {
-                path: path,
-                version: version,
-                major_version: major_version
-              }
-            end
-          end
-        end
-
-        if unity_versions.empty?
-          puts "调试信息: 搜索的Unity路径:"
-          paths.each do |path|
-            puts "  - #{path}"
-            if path.include?("*")
-              Dir.glob(path).each do |expanded_path|
-                puts "    展开: #{expanded_path}"
-              end
-            elsif File.exist?(path)
-              puts "    存在: #{path}"
-            else
-              puts "    不存在: #{path}"
-            end
-          end
-          raise Informative, "未找到任何Unity版本，请检查Unity是否正确安装"
-        end
-
-
-        select_unity_versions = unity_versions.select { |v| v[:version] == project_unity_version } || []
-        if !select_unity_versions.nil? && !select_unity_versions.empty? && select_unity_versions.length >= 1
-          return select_unity_versions.first[:path]
-        end
-
-        unity_versions.sort_by! { |v| v[:major_version] }
-        select_unity_versions = unity_versions.select { |v| v[:major_version] == unity_major_version } if unity_major_version
-        if select_unity_versions.nil? || select_unity_versions.empty?
-          if force_change_version
-            puts "强制使用最新版本: #{unity_versions.last[:version]}"
-            return unity_versions.last[:path]
-          else
-            puts "调试信息: 项目Unity版本: #{project_unity_version}"
-            puts "调试信息: 可用的Unity版本:"
-            unity_versions.each do |v|
-              puts "  - #{v[:version]} (#{v[:major_version]})"
-            end
-            raise Informative, "未找到匹配的Unity版本 #{project_unity_version}，可用的版本: #{unity_versions.map { |v| v[:version] }.join(', ')}"
-          end
-        else
-          return select_unity_versions.first[:path]
-        end
-
+      # 委托给 UnityEnvHelper 的类方法
+      def find_unity_path(project_unity_version: nil, force_change_version: false)
+        UnityEnvHelper.find_unity_path(
+          project_unity_version: project_unity_version,
+          force_change_version: force_change_version
+        )
       end
 
-      private
-
-      def extract_version_from_path(path)
-        # macOS路径格式: /Applications/Unity/Hub/Editor/2021.3.45f1/Unity.app/Contents/MacOS/Unity
-        # macOS路径格式(变体): /Applications/Unity/Hub/Editor/2021.3.45f1c1/Unity.app/Contents/MacOS/Unity
-        # macOS路径格式(旧版): /Applications/Unity/Unity.app/Contents/MacOS/Unity
-        # Windows路径格式: C:/Program Files/Unity/Hub/Editor/2021.3.45f1/Editor/Unity.exe
-        # Windows路径格式(变体): C:/Program Files/Unity/Hub/Editor/2021.3.45f1c1/Editor/Unity.exe
-        # Windows路径格式(旧版): C:/Program Files/Unity/Editor/Unity.exe
-
-        # 尝试匹配 macOS Hub 路径格式
-        if match = path.match(/Editor\/([\d.]+[a-zA-Z]\d+(?:c\d+)?)\//)
-          return match[1]
-        end
-
-        # 尝试匹配 Windows Hub 路径格式
-        if match = path.match(/([\d.]+[a-zA-Z]\d+(?:c\d+)?)\/Editor\//)
-          return match[1]
-        end
-
-        # 尝试匹配 macOS 旧版路径格式 (从Info.plist提取版本)
-        if match = path.match(/Unity\.app\/Contents\/MacOS\/Unity$/)
-          info_plist_path = File.join(File.dirname(File.dirname(path)), "Info.plist")
-          if File.exist?(info_plist_path)
-            begin
-              content = File.read(info_plist_path)
-              if content =~ /<key>CFBundleVersion<\/key>\s*<string>([^<]+)<\/string>/
-                return $1.strip
-              elsif content =~ /<key>CFBundleShortVersionString<\/key>\s*<string>Unity version ([^<]+)<\/string>/
-                return $1.strip
-              end
-            rescue => e
-              puts "警告: 无法读取Info.plist文件: #{e.message}"
-            end
-          end
-        end
-
-        # 尝试匹配 Windows 旧版路径格式
-        if match = path.match(/Unity\.exe$/)
-          # 对于旧版Unity，尝试从父目录获取版本信息
-          parent_dir = File.dirname(path)
-          if File.basename(parent_dir) =~ /^([\d.]+[a-zA-Z]\d+(?:c\d+)?)$/
-            return $1
-          end
-        end
+      def get_unity_version(project_path)
+        UnityEnvHelper.get_unity_version(project_path)
+      end
 
-        nil
+      def unity_project?(project_path)
+        UnityEnvHelper.unity_project?(project_path)
       end
 
-      public
+      def version_less_than?(v1, v2)
+        UnityEnvHelper.version_less_than?(v1, v2)
+      end
 
-      def execute_unity_command(unity_exe_full_path, project_path, additional_args = {})
-        if unity_exe_full_path.nil?
-          raise Informative, "Unity path not found!"
-        end
+      # ============================================
+      # Unity 构建相关功能
+      # ============================================
 
-        # 调试级别：通过环境变量或参数控制
-        debug_level = ENV['UNITY_BUILD_DEBUG'] || additional_args[:debug_level] || 'normal'
-        # debug_level: 'quiet' - 只显示错误
-        #              'normal' - 显示错误、警告和关键进度
-        #              'verbose' - 显示所有输出
+      # 检查 GoodUnityBuild 版本是否满足要求
+      def check_goodunitybuild_version(unity_exe_full_path, project_path)
+        Funlog.instance.fancyinfo_start("检查 GoodUnityBuild 版本")
 
-        # 检查项目路径是否存在
-        unless File.directory?(project_path)
-          raise Informative, "Unity项目路径不存在: #{project_path}"
-        end
+        # 检查是否有Unity进程在运行
+        UnityProcHelper.check_unity_processes(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
 
-        # 检查项目是否是Unity项目
-        project_settings = File.join(project_path, "ProjectSettings")
-        unless File.directory?(project_settings)
-          raise Informative, "项目路径不是Unity项目: #{project_path}"
-        end
+        # 执行 Unity 命令获取库版本
+        result = UnityCommandHelper.execute_unity_command(
+          unity_exe_full_path,
+          project_path,
+          method: 'GoodUnityBuild.BuildManager.PrintLibraryVersion',
+          additional_args: {}
+        )
 
-        # 如果是 Android 平台，检查 Java 版本
-        platform = additional_args[:platform]
+        return unless result[:success]
 
-        cmd_args = [
-          unity_exe_full_path,
-          "-batchmode",
-          "-quit",
-          "-projectPath",
-          project_path.to_s,
-          "-executeMethod",
-          "GoodUnityBuild.BuildManager.BatchBuild"
+        # 尝试多种模式匹配版本号
+        patterns = [
+          /GoodUnityBuild Version:\s*(\d+\.\d+\.\d+)/i,
+          /\[GoodUnityBuild\]\s+Version\s+(\d+\.\d+\.\d+)/i
         ]
 
-        # Add any additional arguments
-        additional_args.each do |key, value|
-          cmd_args << "-#{key}"
-          cmd_args << value.to_s if value
+        library_version = nil
+        patterns.each do |pattern|
+          if match = result[:stdout].match(pattern)
+            library_version = match[1]
+            break
+          end
         end
 
-        puts "Unity command: #{cmd_args.join(' ')}"
-        puts ""
-        
-        # 根据平台显示不同的构建步骤
-        platform = additional_args[:platform]
-        puts "\e[33m正在执行 Unity 构建(#{platform} 平台)，这可能需要几分钟时间，长时间无响应请完全终止当前终端后重试\e[0m"
-        
-        puts ""
-        
-        # 使用更智能的进度检测机制
-        progress_thread = nil
-        start_time = Time.now
-        last_output_time = Time.now
-        
-        begin
-          # 使用 Open3.popen3 来实时监控输出
-          Open3.popen3(*cmd_args) do |stdin, stdout, stderr, wait_thr|
-            stdin.close
-            
-            # 启动进度显示线程
-            progress_thread = Thread.new do
-              dots = 0
-              while wait_thr.alive?
-                sleep(2)
-                dots = (dots + 1) % 4
-                elapsed = (Time.now - start_time).to_i
-                print "\r\e[33mUnity 构建中#{'.' * dots}#{' ' * (3 - dots)} (已用时: #{elapsed}秒)\e[0m"
-                $stdout.flush
-              end
-            end
-            
-            # 实时读取输出
-            stdout_buffer = ""
-            stderr_buffer = ""
-            
-            # 定义错误关键词模式（优化正则，避免重复）
-            error_pattern = /error|exception|failed|Build completed with a result of 'Failed'/i
-            warning_pattern = /warning|warn/i
-            success_pattern = /Build completed successfully|Exiting batchmode successfully/i
-
-            # 使用非阻塞方式读取输出
-            while wait_thr.alive?
-              # 检查是否有输出可读
-              ready_streams = IO.select([stdout, stderr], nil, nil, 1)
-
-              if ready_streams
-                ready_streams[0].each do |stream|
-                  if line = stream.gets
-                    # 记录输出
-                    if stream == stdout
-                      stdout_buffer += line
-                    else
-                      stderr_buffer += line
-                    end
-                    last_output_time = Time.now
-
-                    # 根据调试级别和内容类型显示输出
-                    case debug_level
-                    when 'verbose'
-                      # 详细模式：显示所有输出
-                      puts line
-                    when 'quiet'
-                      # 安静模式：只显示错误
-                      if line.match?(error_pattern)
-                        puts "\e[31m[错误] #{line.strip}\e[0m"
-                      end
-                    else # 'normal'
-                      # 正常模式：显示错误、警告和关键进度
-                      if line.match?(error_pattern)
-                        puts "\n\e[31m[错误] #{line.strip}\e[0m"
-                      elsif line.match?(warning_pattern)
-                        puts "\n\e[33m[警告] #{line.strip}\e[0m"
-                      elsif line.match?(success_pattern)
-                        puts "\n\e[32m[成功] #{line.strip}\e[0m"
-                      elsif line.match?(/\d+%/) || line.match?(/Building|Compiling|Processing/i)
-                        # 显示进度相关信息
-                        print "\r\e[36m[进度] #{line.strip}\e[0m"
-                        $stdout.flush
-                      end
-                    end
-                  end
-                end
-              end
-
-            end
-            
-            # 读取剩余输出
-            stdout_buffer += stdout.read
-            stderr_buffer += stderr.read
-            
-            # 停止进度显示线程
-            progress_thread.kill if progress_thread
-            
-            # 检查构建是否真的成功
-            build_success = wait_thr.value.success?
-            
-            # 检查是否有构建错误的关键词
-            if stdout_buffer.match?(/Build completed with a result of 'Failed'|Build completed with a result of 'Cancelled'|BuildPlayerWindow\+BuildMethod\+Invoke|error|Error|ERROR|exception|Exception|EXCEPTION|failed|Failed|FAILED/)
-              build_success = false
-              # puts "\n\e[31m检测到构建错误信息，构建可能失败\e[0m"
-            end
-            
-            if build_success
-              print "\r\e[32mUnity 构建完成！\e[0m\n"
-              # 构建完成后检查并清理可能的 Unity 进程残留
-              cleanup_unity_processes_after_build(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
-            else
-              print "\r\e[31mUnity 构建失败！\e[0m\n"
-              puts "\e[31m构建输出:\e[0m"
-              puts stdout_buffer if !stdout_buffer.empty?
-              puts "\e[31m错误输出:\e[0m"
-              puts stderr_buffer if !stderr_buffer.empty?
-              # 构建失败时也清理可能的进程残留
-              cleanup_unity_processes_after_build(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
-            end
-            
-            # 返回结果
-            {
-              success: build_success,
-              stdout: stdout_buffer,
-              stderr: stderr_buffer,
-              exit_status: wait_thr.value.exitstatus,
-              unity_version: extract_version_from_path(unity_exe_full_path)
-            }
+        # 从文件读取作为备用方案
+        if library_version.nil?
+          version_file = File.join(project_path, "Logs", "GoodUnityBuild_version.txt")
+          if File.exist?(version_file)
+            content = File.read(version_file).strip
+            library_version = content[/(\d+\.\d+\.\d+)/, 1]
           end
-        rescue => e
-          # 停止进度显示线程
-          progress_thread.kill if progress_thread
-          print "\r\e[31mUnity 构建失败！\e[0m\n"
-          raise e
         end
-      end
-
-      # 比较版本号 (语义化版本比较)
-      # 返回: true 如果 v1 < v2, false 否则
-      def version_less_than?(v1, v2)
-        return false if v1.nil? || v2.nil?
-
-        Gem::Version.new(v1) < Gem::Version.new(v2)
-      rescue ArgumentError
-        # 版本格式无效时的降级处理
-        v1.to_s < v2.to_s
-      end
-
-      # 检查 GoodUnityBuild 版本是否满足要求
-      def check_goodunitybuild_version(unity_exe_full_path, project_path)
-        Funlog.instance.fancyinfo_start("检查 GoodUnityBuild 版本")
-
-        library_version = get_library_version(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
 
         return unless library_version
 
@@ -384,51 +110,10 @@ module Pindo
         Funlog.warning("GoodUnityBuild 库版本检查失败: #{e.message}")
       end
 
-      # 获取 GoodUnityBuild 库版本
-      def get_library_version(unity_exe_full_path:, project_path:)
-        cmd_args = [
-          unity_exe_full_path,
-          "-batchmode",
-          "-quit",
-          "-projectPath",
-          project_path.to_s,
-          "-executeMethod",
-          "GoodUnityBuild.BuildManager.PrintLibraryVersion"
-        ]
-
-        stdout_str, _, _ = Open3.capture3(*cmd_args)
-
-        # 尝试多种模式匹配版本号
-        patterns = [
-          /GoodUnityBuild Version:\s*(\d+\.\d+\.\d+)/i,
-          /\[GoodUnityBuild\]\s+Version\s+(\d+\.\d+\.\d+)/i
-        ]
-
-        patterns.each do |pattern|
-          if match = stdout_str.match(pattern)
-            return match[1]
-          end
-        end
-
-        # 从文件读取作为备用方案
-        version_file = File.join(project_path, "Logs", "GoodUnityBuild_version.txt")
-        if File.exist?(version_file)
-          content = File.read(version_file).strip
-          return content[/(\d+\.\d+\.\d+)/, 1]
-        end
-
-        nil
-      rescue => e
-        nil
-      end
-
-      def build_project(unity_exe_full_path:nil, project_path:nil, platform: nil, isLibrary: false, indexNo: nil, deployMode: nil)
+      def export_project(unity_exe_full_path:nil, project_path:nil, platform: nil, isLibrary: false, indexNo: nil, deployMode: nil)
 
         # 检查是否有Unity进程在运行，传入Unity路径和项目路径以精确匹配
-        check_unity_processes(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
-
-        # 检查 GoodUnityBuild 库版本
-        check_goodunitybuild_version(unity_exe_full_path, project_path)
+        UnityProcHelper.check_unity_processes(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
 
         additional_args = {}
         additional_args[:platform] = platform if platform
@@ -436,8 +121,13 @@ module Pindo
         additional_args[:indexno] = indexNo if indexNo
         additional_args[:deploymode] = deployMode || 'dev' if deployMode || true  # 默认为 dev
 
-        # 使用GoodUnityBuild.BuildManager.BatchBuild进行构建
-        result = execute_unity_command(unity_exe_full_path, project_path, additional_args)
+        # 使用GoodUnityBuild.BuildManager.BatchBuild进行导出
+        result = UnityCommandHelper.execute_unity_command(
+          unity_exe_full_path,
+          project_path,
+          method: 'GoodUnityBuild.BuildManager.BatchBuild',
+          additional_args: additional_args
+        )
 
         if result[:success]
           puts "Unity build completed successfully"
@@ -447,422 +137,175 @@ module Pindo
             puts result[:stdout]
           end
         else
-          # 简单输出失败信息，不显示详细调试信息
+          
           puts "Unity构建失败！ "
 
-          # 构造简洁的错误信息
-          
-          # # 检查特定错误类型，提供简洁的错误信息
-          # if !result[:stdout].empty? && result[:stdout].include?("Multiple Unity instances cannot open the same project")
-          #   error_msg = "Unity实例冲突：另一个Unity正在使用此项目，请关闭所有Unity实例后重试"
-          # elsif !result[:stdout].empty? && (result[:stdout].include?("Failed to download package") || result[:stdout].include?("Install Android SDK Platform"))
-          #   error_msg = "Android SDK下载失败：请检查网络连接或手动配置SDK路径"
-          # elsif !result[:stderr].empty?
-          #   # 只取第一行错误信息
-          #   first_error = result[:stderr].lines.first.strip
-          #   error_msg = "Unity构建失败: #{first_error}"
-          # elsif !result[:stdout].empty?
-          #   # 只取第一行输出信息，不添加"Unity输出:"前缀
-          #   first_output = result[:stdout].lines.first.strip
-          #   error_msg = "Unity构建失败: #{first_output}"
-          # end
-          
           raise Informative, "GoodUnityBuild 导出时候失败！请确保GoodUnityBuild 能正常导出！！！"
         end
 
         result
       end
 
-
-
-      def check_unity_processes(unity_exe_full_path: nil, project_path: nil)
-        # 如果没有提供路径参数，直接跳过Unity进程检查
-        if unity_exe_full_path.nil? && project_path.nil?
-          return
-        end
-
-        # 检查是否有Unity进程在运行
-        unity_processes = `ps aux | grep -i unity | grep -v grep`.strip
-
-        if !unity_processes.empty?
-          # 解析Unity进程信息，传入Unity路径和项目路径进行精确匹配
-          unity_pids = parse_unity_processes(unity_processes, unity_exe_full_path: unity_exe_full_path, project_path: project_path)
-
-          # 过滤掉僵尸进程和无效进程
-          unity_pids = filter_valid_unity_processes(unity_pids)
-          
-          if unity_pids.any?
-            puts "⚠️  检测到与当前项目相关的 Unity 进程正在运行："
-            # 只显示真正的Unity进程，不显示 pindo 相关进程
-            unity_pids.each_with_index do |process_info, index|
-              puts "  #{index + 1}. PID: #{process_info[:pid]}, 命令: #{process_info[:command]}"
-            end
-            puts ""
-
-            # 询问用户是否要自动关闭Unity进程
-            loop do
-              puts "批处理模式需要关闭这些 Unity 进程以避免冲突"
-              puts "  [y] 是, 自动关闭所有 Unity 进程"
-              puts "  [s] 跳过, 我已经手动关闭 Unity 进程，继续构建（可能导致冲突）"
-              puts "  [e] 退出编译"
-              print "请输入选择 (y/s/e): "
-
-              input = STDIN.gets
-              choice = input ? input.chomp.strip.downcase : ""
-
-              case choice
-              when 'y', 'yes', '1'
-                puts "\n正在关闭 Unity 相关进程..."
-                success_count = 0
-                unity_pids.each do |process_info|
-                  if kill_unity_process(process_info[:pid])
-                    puts "✅ 成功关闭进程 #{process_info[:pid]}"
-                    success_count += 1
-                  else
-                    puts "❌ 关闭进程 #{process_info[:pid]} 失败"
-                  end
-                end
-
-                if success_count > 0
-                  puts "\n✅ 已关闭 #{success_count} 个 Unity 相关进程"
-                  puts "等待3秒后继续编译..."
-                  sleep(3)
-                else
-                  puts "\n❌ 无法关闭 Unity 相关进程，请手动关闭后重试"
-                  raise "Unity进程冲突：无法自动关闭 Unity 相关进程，请手动关闭后重试"
-                end
-                break  # 退出循环
-
-              when 's', 'skip', '2'
-                puts "\n✅ 跳过检查，继续编译..."
-                puts "假设Unity Editor已经手动关闭，如果仍在运行可能导致编译失败"
-                sleep(1)
-                break  # 退出循环
-
-              when 'e', 'exit', '3'
-                puts "\n⚠️  用户选择退出编译"
-                puts "退出Unity编译流程"
-                exit 0
-
-              else
-                puts "\n⚠️ 无效选择: '#{choice}'"
-                puts "请输入 y (是), s (跳过), 或 e (退出)\n\n"
-                # 继续循环，让用户重新输入
-              end
-            end
-          else
-            # 没有检测到与当前项目相关的Unity进程，静默继续
+      # 检查 YooAsset 是否存在
+      # YooAsset 可能以以下形式存在：
+      #   1. Assets/Packages/Joy.Tool.YooExt.* (手动导入)
+      #   2. Library/PackageCache/com.tuyoogame.yooasset@* (官方 YooAsset)
+      #   3. Library/PackageCache/com.fununitylib.yooext@* (YooExt 辅助包)
+      # @param project_path [String] Unity 项目路径
+      # @return [Boolean] 如果 YooAsset 存在返回 true
+      def yoo_asset_exists?(project_path)
+        # 1. 检查 Assets/Packages 目录（手动导入方式）
+        packages_path = File.join(project_path, "Assets", "Packages")
+        if File.directory?(packages_path)
+          yoo_pattern = File.join(packages_path, "Joy.Tool.YooExt.*")
+          matching_dirs = Dir.glob(yoo_pattern)
+
+          if matching_dirs.any?
+            puts "找到 YooAsset (Assets): #{matching_dirs.first}"
+            return true
           end
         end
-      end
 
-      # 解析Unity进程信息
-      def parse_unity_processes(processes_output, unity_exe_full_path: nil, project_path: nil)
-        processes = []
-
-        processes_output.lines.each do |line|
-          # 解析 ps aux 输出格式
-          parts = line.strip.split(/\s+/)
-          if parts.length >= 11
-            pid = parts[1]
-            command = parts[10..-1].join(' ')
-
-            # 过滤掉grep进程本身和pindo进程
-            unless command.include?('grep') || command.include?('pindo')
-              # 精确匹配Unity进程
-              is_relevant_unity_process = false
-              match_reasons = []
-
-              # 1. 必须是Unity Editor主进程（排除VS Code等其他进程）
-              is_unity_editor = command.match?(/Unity\.app.*\/Unity/i) || command.match?(/Unity\.exe/i)
-
-              if is_unity_editor
-                # 2. 检查是否是打开了指定项目的Unity进程
-                # Unity 使用 -projectpath 参数指定项目路径
-                if project_path
-                  # 标准化路径以确保匹配
-                  normalized_project_path = File.expand_path(project_path)
-                  # 精确匹配项目路径（必须完全匹配，不能只是包含）
-                  if command.match?(/-projectpath\s+#{Regexp.escape(normalized_project_path)}(\s|$)/i)
-                    # 只有当项目路径完全匹配时才认为是相关进程
-                    is_relevant_unity_process = true
-                    match_reasons << "Unity Editor打开了当前项目"
-
-                    # 如果还指定了Unity路径，也要验证
-                    if unity_exe_full_path
-                      if command.include?(unity_exe_full_path)
-                        match_reasons << "使用指定的Unity版本"
-                      else
-                        # Unity路径不匹配，不是我们要的进程
-                        is_relevant_unity_process = false
-                        match_reasons.clear
-                      end
-                    end
-                  end
-                elsif unity_exe_full_path && command.include?(unity_exe_full_path)
-                  # 只提供了Unity路径，没有项目路径时才匹配
-                  # 这种情况下匹配所有使用该Unity版本的进程
-                  is_relevant_unity_process = true
-                  match_reasons << "使用指定的Unity版本"
-                end
-              end
-
-              # 3. 如果没有提供路径参数，不匹配任何进程（由上层函数处理）
-
-              if is_relevant_unity_process
-                processes << { pid: pid, command: command }
-              end
+        # 2. 检查 Library/PackageCache 目录（UPM 安装方式）
+        package_cache_path = File.join(project_path, "Library", "PackageCache")
+        if File.directory?(package_cache_path)
+          # 检查多个可能的包名
+          yoo_patterns = [
+            "com.tuyoogame.yooasset@*",      # 官方 YooAsset 包
+            "com.fununitylib.yooext@*"       # YooExt 辅助包
+          ]
+
+          yoo_patterns.each do |pattern|
+            yoo_pattern = File.join(package_cache_path, pattern)
+            matching_dirs = Dir.glob(yoo_pattern)
+
+            if matching_dirs.any?
+              puts "找到 YooAsset (UPM): #{matching_dirs.first}"
+              return true
             end
           end
         end
-        processes
+
+        false
+      rescue => e
+        # 如果检查失败，返回 false（保守处理）
+        Funlog.warning("检查 YooAsset 是否存在时出错: #{e.message}")
+        false
       end
-      
-      # 过滤掉僵尸进程和无效进程
-      def filter_valid_unity_processes(processes)
-        valid_processes = []
-
-        processes.each do |process_info|
-          # PID 可能是字符串，确保正确处理
-          pid = process_info[:pid]
-          pid_int = pid.to_i
-
-          # 检查进程是否真的存在且活跃
-          if process_exists_and_active?(pid_int)
-            valid_processes << process_info
-          end
+
+      # 构建 YooAsset 资源包
+      # @param unity_exe_full_path [String] Unity 可执行文件路径
+      # @param project_path [String] Unity 项目路径
+      # @param platform [String] 目标平台 ('Android', 'iOS' 等)
+      # @return [Hash] 执行结果，如果跳过则返回 { skipped: true }
+      def build_yoo_asset(unity_exe_full_path:nil, project_path:nil, platform: nil)
+        # 检查项目中是否存在 YooAsset
+        unless yoo_asset_exists?(project_path)
+          return { skipped: true, reason: 'YooAsset not found' }
         end
 
-        valid_processes
-      end
-      
-      # 检查进程是否真的存在且活跃
-      def process_exists_and_active?(pid)
-        begin
-          # 使用更简单可靠的方式检查进程
-          # 尝试发送信号0来检查进程是否存在
-          Process.kill(0, pid)
-
-          # 如果需要检查进程状态，使用不同的命令格式
-          # -o pid=,stat= 去掉标题行
-          process_info = `ps -p #{pid} -o pid=,stat= 2>/dev/null`.strip
-
-          if process_info.empty?
-            return false
-          end
+        puts "检测到 YooAsset，开始构建资源..."
 
-          # 解析进程状态
-          parts = process_info.split(/\s+/)
-          if parts.length >= 2
-            stat = parts[1]
-            # Z = 僵尸进程, T = 停止进程
-            # 只过滤僵尸进程，不过滤停止进程（T可能是正常的暂停状态）
-            if stat.include?('Z')
-              puts "        进程 #{pid} 是僵尸进程，过滤掉"
-              return false
-            end
-          end
+        # 检查是否有Unity进程在运行
+        UnityProcHelper.check_unity_processes(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
 
-          true
-        rescue Errno::ESRCH
-          # 进程不存在
-          false
-        rescue Errno::EPERM
-          # 权限不足，但进程存在
-          true
-        rescue => e
-          puts "检查进程 #{pid} 时出错: #{e.message}"
-          # 如果出错，假设进程存在（保守处理）
-          true
-        end
-      end
+        additional_args = {}
+        additional_args[:platform] = platform if platform
 
-      # 关闭Unity进程
-      def kill_unity_process(pid)
-        begin
-          pid_int = pid.to_i
-          
-          # 安全检查：确保不是当前进程
-          if pid_int == Process.pid
-            puts "⚠️  跳过当前进程 #{pid}"
-            return true
-          end
-          
-          # 检查进程是否存在
-          unless process_exists?(pid_int)
-            puts "进程 #{pid} 已不存在"
-            return true
-          end
-          
-          # 获取进程信息进行额外验证
-          process_info = get_process_info(pid_int)
-          if process_info && !process_info.include?('Unity')
-            puts "⚠️  跳过非Unity进程 #{pid}: #{process_info}"
-            return true
-          end
-          
-          puts "正在关闭Unity进程 #{pid}..."
-          
-          # 先尝试优雅关闭
-          begin
-            Process.kill('TERM', pid_int)
-            puts "已发送TERM信号给进程 #{pid}"
-          rescue Errno::EPERM
-            puts "❌ 没有权限关闭进程 #{pid}，尝试使用sudo"
-            return kill_unity_process_with_sudo(pid)
-          rescue Errno::ESRCH
-            puts "进程 #{pid} 已不存在"
-            return true
-          end
-          
-          # 等待进程优雅退出
-          sleep(3)
-          
-          # 检查进程是否还存在
-          if process_exists?(pid_int)
-            puts "进程 #{pid} 未响应TERM信号，尝试强制关闭..."
-            begin
-              Process.kill('KILL', pid_int)
-              puts "已发送KILL信号给进程 #{pid}"
-              sleep(2)
-            rescue Errno::EPERM
-              puts "❌ 没有权限强制关闭进程 #{pid}"
-              return false
-            rescue Errno::ESRCH
-              puts "进程 #{pid} 已不存在"
-              return true
-            end
-          end
-          
-          # 最终检查
-          if process_exists?(pid_int)
-            puts "❌ 无法关闭进程 #{pid}"
-            false
-          else
-            puts "✅ 成功关闭进程 #{pid}"
-            true
+        # 使用 Yoo.Editor.YooCommandHelper.BatchBuild 进行资源构建
+        result = UnityCommandHelper.execute_unity_command(
+          unity_exe_full_path,
+          project_path,
+          method: 'Yoo.Editor.YooCommandHelper.BatchBuild',
+          additional_args: additional_args
+        )
+
+        if result[:success]
+          puts "YooAsset 构建完成"
+          puts "使用 Unity 版本: #{result[:unity_version]}"
+          if !result[:stdout].empty?
+            puts "Unity 输出:"
+            puts result[:stdout]
           end
-          
-        rescue => e
-          puts "❌ 关闭进程 #{pid} 时出错: #{e.message}"
-          puts "错误类型: #{e.class}"
-          false
+        else
+          puts "YooAsset 构建失败！"
+          raise Informative, "YooAsset 资源构建失败！请确保 YooAsset 配置正确！"
         end
+
+        result
       end
 
-      # 使用sudo关闭进程
-      def kill_unity_process_with_sudo(pid)
-        begin
-          puts "尝试使用sudo关闭进程 #{pid}..."
-          result = system("sudo kill -TERM #{pid}")
-          if result
-            sleep(3)
-            if process_exists?(pid.to_i)
-              puts "TERM信号无效，尝试KILL信号..."
-              system("sudo kill -KILL #{pid}")
-              sleep(2)
-            end
-            !process_exists?(pid.to_i)
-          else
-            puts "❌ sudo命令执行失败"
-            false
+      # 强制更新必备库（NugetForUnity）
+      # @param unity_exe_full_path [String] Unity 可执行文件路径
+      # @param project_path [String] Unity 项目路径
+      # @return [Hash] 执行结果
+      def force_update_libraries(unity_exe_full_path:nil, project_path:nil)
+        # 检查是否有Unity进程在运行
+        UnityProcHelper.check_unity_processes(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
+
+        # 使用 NugetForUnity.Joy.JoyTools.CheckForceUpdate 强制更新库
+        result = UnityCommandHelper.execute_unity_command(
+          unity_exe_full_path,
+          project_path,
+          method: 'NugetForUnity.Joy.JoyTools.CheckForceUpdate',
+          additional_args: {}
+        )
+
+        if result[:success]
+          puts "必备库更新完成"
+          puts "使用 Unity 版本: #{result[:unity_version]}"
+          if !result[:stdout].empty?
+            puts "Unity 输出:"
+            puts result[:stdout]
           end
-        rescue => e
-          puts "❌ sudo关闭进程时出错: #{e.message}"
-          false
+        else
+          puts "必备库更新失败！"
+          raise Informative, "NugetForUnity 库更新失败！请检查网络连接和配置！"
         end
-      end
 
-      # 获取进程信息
-      def get_process_info(pid)
-        begin
-          `ps -p #{pid} -o comm=`.strip
-        rescue => e
-          nil
-        end
+        result
       end
 
-      # 检查进程是否存在
-      def process_exists?(pid)
-        begin
-          Process.kill(0, pid)
-          true
-        rescue Errno::ESRCH
-          false
-        rescue Errno::EPERM
-          # 权限不足，但进程存在
-          true
+      # 配置 GoodUnityBuild 编译模式
+      # @param unity_exe_full_path [String] Unity 可执行文件路径
+      # @param project_path [String] Unity 项目路径
+      # @param deploy_mode [String] 部署模式 ('dev', 'adhoc', 'release')
+      # @return [Hash] 执行结果
+      def config_build_mode(unity_exe_full_path:nil, project_path:nil, deploy_mode: 'dev')
+        # 验证 deploy_mode 参数
+        valid_modes = ['dev', 'adhoc', 'release']
+        unless valid_modes.include?(deploy_mode)
+          raise Informative, "无效的编译模式: #{deploy_mode}，必须是 #{valid_modes.join(', ')}"
         end
-      end
 
-      # 构建完成后清理 Unity 进程残留
-      def cleanup_unity_processes_after_build(unity_exe_full_path: nil, project_path: nil)
-        begin
-          # 等待一小段时间让 Unity 进程自然退出
-          sleep(2)
-
-          # 如果没有提供路径参数，不清理进程
-          if unity_exe_full_path.nil? && project_path.nil?
-            return
-          end
+        # 检查是否有Unity进程在运行
+        UnityProcHelper.check_unity_processes(unity_exe_full_path: unity_exe_full_path, project_path: project_path)
 
-          # 检查是否还有 Unity 进程在运行
-          unity_processes = `ps aux | grep -i unity | grep -v grep`.strip
-
-          if !unity_processes.empty?
-            # 解析进程信息，传入Unity路径和项目路径进行精确匹配
-            unity_pids = parse_unity_processes(unity_processes, unity_exe_full_path: unity_exe_full_path, project_path: project_path)
-
-            if unity_pids.any?
-              puts "\e[33m检测到构建后仍有项目相关的 Unity 进程残留，正在清理...\e[0m"
-              # 自动清理残留的 Unity 进程
-              cleaned_count = 0
-              unity_pids.each do |process_info|
-                if kill_unity_process(process_info[:pid])
-                  cleaned_count += 1
-                end
-              end
-
-              if cleaned_count > 0
-                puts "\e[32m✅ 已清理 #{cleaned_count} 个 Unity 相关进程残留\e[0m"
-              end
-            end
-          end
-        rescue => e
-          # 清理失败不影响主流程
-          # 静默处理，不输出错误信息
-        end
-      end
+        puts "配置 GoodUnityBuild 编译模式为: #{deploy_mode}"
 
+        # 使用 GoodUnityBuild.BuildManager.BatchConfig 配置编译模式
+        result = UnityCommandHelper.execute_unity_command(
+          unity_exe_full_path,
+          project_path,
+          method: 'GoodUnityBuild.BuildManager.BatchConfig',
+          additional_args: { deployMode: deploy_mode }
+        )
 
-      def get_unity_version(project_path)
-        version_path = File.join(project_path, "ProjectSettings", "ProjectVersion.txt")
-        if File.exist?(version_path)
-          content = File.read(version_path)
-          if content =~ /m_EditorVersion: (.*)/
-            version = $1.strip
-            version
-          else
-            raise "Could not parse Unity version from #{version_path}"
+        if result[:success]
+          puts "编译模式配置完成: #{deploy_mode}"
+          puts "使用 Unity 版本: #{result[:unity_version]}"
+          if !result[:stdout].empty?
+            puts "Unity 输出:"
+            puts result[:stdout]
           end
         else
-          raise "Project version file not found at #{version_path}"
+          puts "编译模式配置失败！"
+          raise Informative, "GoodUnityBuild 编译模式配置失败！请确保 GoodUnityBuild 正确安装！"
         end
-      end
-
 
-      def unity_project?(project_path)
-        # 检查关键Unity工程文件和目录是否存在
-        project_settings_path = File.join(project_path, "ProjectSettings")
-        assets_path = File.join(project_path, "Assets")
-        packages_path = File.join(project_path, "Packages")
-
-        File.directory?(project_settings_path) &&
-        File.directory?(assets_path) &&
-        File.directory?(packages_path) &&
-        File.exist?(File.join(project_settings_path, "ProjectSettings.asset"))
+        result
       end
 
     end
   end
-end
+end