命令行构建Unity项目

自动任务构建

通常可以在桌面双击 Unity 图标，启动程序，但是，也可以通过命令行（例如，MacOS 终端或 Windows Command 窗口）运行程序。若使用这种方式启动 Unity，它将可以接受启动命令和信息，这将非常有助于测试套件、自动构建和其他制作任务。

在 MacOS 中，可以在终端 (Terminal) 输入以下内容，启动 Unity：

/Applications/Unity/Unity.app/Contents/MacOS/Unity

而在 Windows 中，应在 cmd 窗口输入：

"C:\Program Files (x86)\Unity\Editor\Unity.exe"

独立版 Unity 游戏可以用相同的方式启动。

Unity命令行参数

如上所述，在启动编辑器和构建游戏时，也可以选择性地使用其他命令和信息。使用以下命令行参数并可达到这一目的：

官方文档参数说明：

Unity 编辑器命令行参数

Unity 独立播放器命令行参数

-batchmode

在批处理模式下运行Unity。应始终与其他命令行参数一起使用，因为它确保不会弹出窗口，无需任何人为的干预。当脚本代码在执行过程中发生异常，资源服务器更新失败或其他操作失败时Unity将立即退出，并返回代码为1。请注意，在批处理模式下， Unity将向控制台发送输出版本最小的日志。当然，日志文件将包含完整的日志信息。

-quit

其他命令执行完毕后将退出Unity编辑器。请注意，这可能会导致错误消息被隐藏（但他们将显示在Editor.log文件）

-createProject <pathname>

根据提供的路径建立一个空项目

-projectPath <pathname>

打开指定路径的项目

-logFile <pathname>

指定 Unity 写入编辑器或 Windows/Linux/OSX 独立日志文件的位置

-exportPackage <exportAssetPath1 exportAssetPath2 ExportAssetPath3 exportFileName>

导出一个包，给定一个路径（或一组给定的路径）。在本例中，exportAssetPath是要从 Unity 项目导出的文件夹（相对于 Unity 项目根目录），exportFileName是包名称。此选项一次仅导出整个文件夹。您通常需要将此命令与-projectPath参数一起使用。

-executeMethod <ClassName.MethodName>

一旦 Unity 打开项目，并且在可选的资​​产服务器更新完成后，立即执行静态方法。您可以将其用于诸如持续集成、执行单元测试、构建或准备数据之类的任务。

要从命令行进程返回错误，请抛出导致 Unity 以返回代码 1 退出的异常，或者使用非零返回代码调用EditorApplication.Exit。

要传递参数，请将它们添加到命令行并使用System.Environment.GetCommandLineArgs. 要使用-executeMethod，您需要将封闭脚本放在 Editor 文件夹中。您执行的方法必须定义为静态的。

自动构建Dmeo

BuildTool.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEditor;
using System.Linq;
using UnityEditor.Build.Reporting;

public class BuildTool
{
    [MenuItem("Build/BuildAndroidWithParameters")]
    public static void BuildAndroidWithParameters()
    {
        CreateBuildAndroid(true);
    }

    static void CreateBuildAndroid(bool useIL2CPP, bool development = false)
    {
        if(EditorUserBuildSettings.activeBuildTarget != BuildTarget.Android)
        {
            EditorUtility.DisplayDialog("切换到目标平台", "请切换到安卓平台，再创建Build", "知道啦");
        }

        Debug.Log("Android build started.(" + (useIL2CPP ? "IL2CPP" : "Mono") + ")");

        var target = BuildTarget.Android;
        var buildName = GetBuildName();
        var buildPath = GetBuildPath(target, buildName);
        string executableName = Application.productName + "_proj.android";

        CreateDirectory(buildPath, false);

        var res = BuildGame(buildPath, executableName, target, BuildOptions.CompressWithLz4HC | BuildOptions.AcceptExternalModificationsToPlayer, buildName, useIL2CPP, development);
        if (!res)
        {
            throw new Exception("BuildPipeline.BuildPlayer failed");
        }

        if (res.summary.result != UnityEditor.Build.Reporting.BuildResult.Succeeded)
        {
            throw new Exception("BuildPipiline.BuildPlayer failed: " + res.ToString());
        }

        Debug.Log("Android build completed...");
    }

    static string GetBuildName()
    {
        return "build";
    }

    static string GetBuildPath(BuildTarget target, string buildName)
    {
        return "Build/" + target.ToString() + "/" + GetLongBuildName(target, buildName);
    }

    static string GetLongBuildName(BuildTarget target, string buildName)
    {
        return Application.productName + "_" + target.ToString() + "_" + buildName;
    }

    public static void CreateDirectory(string path, bool forceEmpty = false)
    {
        if (forceEmpty)
        {
            ClearDirectory(path);
        }

        if (!Directory.Exists(path))
        {
            Directory.CreateDirectory(path);
        }
    }

    public static void ClearDirectory(string path)
    {
        if (Directory.Exists(path))
        {
            Directory.Delete(path);
        }
    }

    public static BuildReport BuildGame(string buildPath, string exeName, BuildTarget target, BuildOptions opts, string buildId, bool il2cpp, bool development = false)
    {
        if (development)
        {
            opts = opts | BuildOptions.Development | BuildOptions.ConnectWithProfiler;
        }

        var levels = new string[]
        {
            "Assets/Tetris Template/Scenes/GamePlay.unity"
        };

        BuildTargetGroup group = BuildTargetGroup.Standalone;

        if (!Enum.TryParse(target.ToString(), out group))
        {
            Debug.LogWarning("Building Warning : Unknow Build Target!!!!!!!");
        }

        string projectPath = buildPath + "/" + exeName;
        if (target == BuildTarget.Android || target == BuildTarget.iOS)
        {
            projectPath = buildPath + "/../" + exeName;
        }

        Debug.Log("Building: " + buildPath);
        Directory.CreateDirectory(buildPath);

        string fullBuildPath = Directory.GetCurrentDirectory() + "/" + buildPath;
        var monoDirs = Directory.GetDirectories(fullBuildPath).Where(s => s.Contains("MonoBleedingEdge"));
        var il2cppDirs = Directory.GetDirectories(fullBuildPath).Where(s => s.Contains("BackUpThisFolder_ButDontShipItWithYourGame"));
        var clearFolder = (il2cpp && monoDirs.Count() > 0) || (!il2cpp && il2cppDirs.Count() > 0);
        if (clearFolder)
        {
            Debug.Log("deleting old folders ..");
            foreach (var file in Directory.GetFiles(fullBuildPath))
            {
                File.Delete(file);
            }

            foreach (var dir in monoDirs)
            {
                Directory.Delete(dir, true);
            }

            foreach (var dir in il2cppDirs)
            {
                Directory.Delete(dir, true);
            }

            foreach (var dir in Directory.GetDirectories(fullBuildPath).Where(s => s.EndsWith("_Data")))
            {
                Directory.Delete(dir, true);
            }
        }

        if (il2cpp)
        {
            UnityEditor.PlayerSettings.SetScriptingBackend(group, ScriptingImplementation.IL2CPP);
            UnityEditor.PlayerSettings.SetIl2CppCompilerConfiguration(group, Il2CppCompilerConfiguration.Release);
            if (target == BuildTarget.Android)
            {
                PlayerSettings.Android.targetArchitectures = AndroidArchitecture.X86 | AndroidArchitecture.ARMv7 | AndroidArchitecture.ARM64;
            }
        }
        else
        {
            UnityEditor.PlayerSettings.SetScriptingBackend(group, ScriptingImplementation.Mono2x);
        }

        Debug.Log("Done.");

        Environment.SetEnvironmentVariable("BUILD_ID", buildId, EnvironmentVariableTarget.Process);
        var result = BuildPipeline.BuildPlayer(levels, projectPath, target, opts);
        Environment.SetEnvironmentVariable("BUILD_ID", "", EnvironmentVariableTarget.Process);

        var stepCount = result.steps.Length;
        Debug.Log("Steps: " + stepCount);
        for (int i = 0; i < stepCount; i++)
        {
            var step = result.steps[i];
            Debug.Log("--" + (i + 1) + "/" + stepCount + " " + step.name + " " + step.duration.Seconds + "s--");
            foreach (var msg in step.messages)
            {
                Debug.Log(msg.content);
            }
        }

        return result;
    }
}