C# UE4Build.CheckBuildProducts方法代码示例

    void ExecuteInner()
    {
        var UE4Build = new UE4Build(this);

        var Agenda = new UE4Build.BuildAgenda();

        {
            var Win32Targets = new string[]
            {
                "FortniteClient",
                "FortniteGame",
                "FortniteServer",
                "OrionServer",
                "OrionClient",
                "OrionGame",
            };
            Agenda.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping);
            Agenda.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Test);
        }

        Agenda.DoRetries = false;
        Agenda.SpecialTestFlag = true;
        UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);

        UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
    }

    void ExecuteInner()
    {
        var UE4Build = new UE4Build(this);

        var Agenda_Mono = new UE4Build.BuildAgenda();
        var Agenda_NonUnity = new UE4Build.BuildAgenda();
        {
            {
                var Win64DevTargets = new string[]
                {
                    "FortniteEditor",
                    "OrionEditor",
                    "PlatformerGameEditor",
                    "QAGameEditor",
                    "ShooterGameEditor",
                    "StrategyGameEditor",
                    "VehicleGameEditor",
                };
                Agenda_Mono.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development, bForceMonolithic: true);
                Agenda_Mono.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping, bForceMonolithic: true);
                Agenda_Mono.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development, bForceNonUnity: true);
                Agenda_Mono.AddTargets(Win64DevTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping, bForceNonUnity: true);

                var Win32Targets = new string[]
                {
                    "FortniteGame",
                    "FortniteServer",
                    "OrionGame",
                    "PlatformerGame",
                    "QAGame",
                    "ShooterGame",
                    "StrategyGame",
                    "VehicleGame",
                };
                Agenda_Mono.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development, bForceMonolithic: true);
                Agenda_Mono.AddTargets(Win32Targets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development, bForceNonUnity: true);

                var Win32ShipTargets = new string[]
                {
                    "FortniteGame",
                    "FortniteServer",
                };
                Agenda_Mono.AddTargets(Win32ShipTargets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping, bForceMonolithic: true);
                Agenda_Mono.AddTargets(Win32ShipTargets, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping, bForceNonUnity: true);
            }
        }

        UE4Build.Build(Agenda_Mono, InDeleteBuildProducts: true, InUpdateVersionFiles: true);

        UE4Build.Build(Agenda_NonUnity, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
        UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
    }

    /// <summary>
    /// Builds BuildPatchTool for the specified platform.
    /// </summary>
    /// <param name="Command"></param>
    /// <param name="InPlatform"></param>
    public static void BuildBuildPatchTool(BuildCommand Command, UnrealBuildTool.UnrealTargetPlatform InPlatform)
    {
        Log("Building BuildPatchTool");

        var UE4Build = new UE4Build(Command);

        var Agenda = new UE4Build.BuildAgenda();
        Agenda.Targets.Add(new UE4Build.BuildTarget()
        {
            ProjectName = "",
            TargetName = "BuildPatchTool",
            Platform = InPlatform,
            Config = UnrealBuildTool.UnrealTargetConfiguration.Development,
        });

        UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
        UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
    }

	private static void BuildProduct(BuildCommand Command, UE4Build.BuildTarget Target)
	{
		if (Target == null)
		{
			throw new AutomationException("Target is required when calling UE4BuildUtils.BuildProduct");
		}

		LogConsole("Building {0}", Target.TargetName);

		if (Command == null)
		{
			Command = new UE4BuildUtilDummyBuildCommand();
		}

		var UE4Build = new UE4Build(Command);

		var Agenda = new UE4Build.BuildAgenda();
		Agenda.Targets.Add(Target);

		UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
		UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
	}

	public static void Build(BuildCommand Command, ProjectParams Params, int WorkingCL = -1)
	{

		Params.ValidateAndLog();

		if (!Params.Build)
		{
			return;
		}

		Log("********** BUILD COMMAND STARTED **********");

		var UE4Build = new UE4Build(Command);
		var Agenda = new UE4Build.BuildAgenda();
		var CrashReportPlatforms = new HashSet<UnrealTargetPlatform>();

		// Setup editor targets
		if (Params.HasEditorTargets && !Params.Rocket)
		{
			// @todo Mac: proper platform detection
			UnrealTargetPlatform EditorPlatform = HostPlatform.Current.HostEditorPlatform;
			const UnrealTargetConfiguration EditorConfiguration = UnrealTargetConfiguration.Development;

			CrashReportPlatforms.Add(EditorPlatform);
			Agenda.AddTargets(Params.EditorTargets.ToArray(), EditorPlatform, EditorConfiguration, Params.CodeBasedUprojectPath);
			if (Params.EditorTargets.Contains("UnrealHeaderTool") == false)
			{
				Agenda.AddTargets(new string[] { "UnrealHeaderTool" }, EditorPlatform, EditorConfiguration);
			}
			if (Params.EditorTargets.Contains("ShaderCompileWorker") == false)
			{
				Agenda.AddTargets(new string[] { "ShaderCompileWorker" }, EditorPlatform, EditorConfiguration);
			}
			if (Params.Pak && Params.EditorTargets.Contains("UnrealPak") == false)
			{
				Agenda.AddTargets(new string[] { "UnrealPak" }, EditorPlatform, EditorConfiguration);
			}
			if (Params.FileServer && Params.EditorTargets.Contains("UnrealFileServer") == false)
			{
				Agenda.AddTargets(new string[] { "UnrealFileServer" }, EditorPlatform, EditorConfiguration);
			}
		}

		// Setup cooked targets
		if (Params.HasClientCookedTargets)
		{
			foreach (var BuildConfig in Params.ClientConfigsToBuild)
			{
				foreach (var ClientPlatform in Params.ClientTargetPlatforms)
				{
					CrashReportPlatforms.Add(ClientPlatform);
					Agenda.AddTargets(Params.ClientCookedTargets.ToArray(), ClientPlatform, BuildConfig, Params.CodeBasedUprojectPath, InAddArgs: " -remoteini=\""+Path.GetDirectoryName(Params.RawProjectPath)+"\"");
				}
			}
		}
		if (Params.HasServerCookedTargets)
		{
			foreach (var BuildConfig in Params.ServerConfigsToBuild)
			{
				foreach (var ServerPlatform in Params.ServerTargetPlatforms)
				{
					CrashReportPlatforms.Add(ServerPlatform);
					Agenda.AddTargets(Params.ServerCookedTargets.ToArray(), ServerPlatform, BuildConfig, Params.CodeBasedUprojectPath, InAddArgs: " -remoteini=\""+Path.GetDirectoryName(Params.RawProjectPath)+"\"");
				}
			}
		}
		if (Params.CrashReporter && !Params.Rocket)
		{
			var CrashReportClientTarget = new[] { "CrashReportClient" };
			foreach (var CrashReportPlatform in CrashReportPlatforms)
			{
				if (UnrealBuildTool.UnrealBuildTool.PlatformSupportsCrashReporter(CrashReportPlatform))
				{
					Agenda.AddTargets(CrashReportClientTarget, CrashReportPlatform, UnrealTargetConfiguration.Development);
				}
			}
		}
		if (Params.HasProgramTargets && !Params.Rocket)
		{
			foreach (var BuildConfig in Params.ClientConfigsToBuild)
			{
				foreach (var ClientPlatform in Params.ClientTargetPlatforms)
				{
					Agenda.AddTargets(Params.ProgramTargets.ToArray(), ClientPlatform, BuildConfig, Params.CodeBasedUprojectPath);
				}
			}
		}
		UE4Build.Build(Agenda, InDeleteBuildProducts: Params.Clean, InUpdateVersionFiles: WorkingCL > 0);

		if (WorkingCL > 0) // only move UAT files if we intend to check in some build products
		{
			UE4Build.AddUATFilesToBuildProducts();
		}
		UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);

		if (WorkingCL > 0)
		{
			// Sign everything we built
			CodeSign.SignMultipleIfEXEOrDLL(Command, UE4Build.BuildProductFiles);

//.........这里部分代码省略.........

        public override void DoBuild(GUBP bp)
        {
            BuildProducts = new List<string>();
            var UE4Build = new UE4Build(bp);
            UE4Build.BuildAgenda Agenda = GetAgenda(bp);
            if (Agenda != null)
            {
				bool ReallyDeleteBuildProducts = DeleteBuildProducts() && !BranchConfig.bForceIncrementalCompile;
                Agenda.DoRetries = false; // these would delete build products
				bool UseParallelExecutor = bDependentOnCompileTools && (HostPlatform == UnrealTargetPlatform.Win64);
				UE4Build.Build(Agenda, InDeleteBuildProducts: ReallyDeleteBuildProducts, InUpdateVersionFiles: false, InForceNoXGE: true, InForceUnity: true, InUseParallelExecutor: UseParallelExecutor);
				using(TelemetryStopwatch PostBuildStopwatch = new TelemetryStopwatch("PostBuild"))
				{
					PostBuild(bp, UE4Build);
				}
                UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
                foreach (var Product in UE4Build.BuildProductFiles)
                {
                    AddBuildProduct(Product);
                }
                RemoveOveralppingBuildProducts();
                PostBuildProducts(bp);
            }
			if (Agenda == null || (BuildProducts.Count == 0 && BranchConfig.bForceIncrementalCompile))
            {
                SaveRecordOfSuccessAndAddToBuildProducts("Nothing to actually compile");
            }
        }

//.........这里部分代码省略.........
                "OrionEditor",
            };

            List<string> Fortnite = new List<string>
            {
                "FortniteServer",
                "FortniteGame",
                "FortniteClient",
                "FortniteEditor",
            };

            List<string> Shadow = new List<string>
            {
                "Shadow",
                "ShadowEditor",
            };

            List<string> Soul = new List<string>
            {
                "Soul",
                "SoulEditor",
            };

            List<string> Exclude = new List<string>(Excludes.Split('+'));

            foreach (List<string> List in TargetLists)
            {
                if (Exclude.Contains("Samples"))
                {
                    RemoveTargetsFromList(Samples, List);
                }
                if (Exclude.Contains("Orion"))
                {
                    RemoveTargetsFromList(Orion, List);
                }
                if (Exclude.Contains("Fortnite"))
                {
                    RemoveTargetsFromList(Fortnite, List);
                }
                if (Exclude.Contains("Shadow"))
                {
                    RemoveTargetsFromList(Shadow, List);
                }
                if (Exclude.Contains("Soul"))
                {
                    RemoveTargetsFromList(Soul, List);
                }
            }
        }
        // @todo: make this programmatic by looping over the TargetLists (which maybe should be a map from config to list)
        string[] Win64Dev = Win64DevTargets.ToArray();
        string[] Win32Dev = Win32Targets.ToArray();
        string[] PS4Dev = PS4DevTargets.ToArray();
        string[] XboxOneDev = XboxOneDevTargets.ToArray();
        string[] IOSDev = IOSDevTargets.ToArray();
        string[] LinuxDev = LinuxTargets.ToArray();
        string[] WinRTDev = WinRTDevTargets.ToArray();
        string[] MacDebug = MacDebugTargets.ToArray();
        string[] HTML5Dev = HTML5DevTargets.ToArray();
        string[] AndroidDev = AndroidDevTargets.ToArray();

        switch (Config.ToUpperInvariant())
        {
            case "TOOLS":
                Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
                break;
            case "EDITORS":
                Agenda.AddTargets(Win64Dev, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
                break;
            case "WIN32DEV":
                Agenda.AddTargets(Win32Dev, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
                break;
            case "PS4DEV":
                Agenda.AddTargets(PS4Dev, UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Development);
                break;
            case "XBOXONEDEV":
                Agenda.AddTargets(XboxOneDev, UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Development);
                break;
            case "IOSDEV":
                Agenda.AddTargets(IOSDev, UnrealTargetPlatform.IOS, UnrealTargetConfiguration.Development);
                break;
            case "LINUX":
                Agenda.AddTargets(LinuxDev, UnrealTargetPlatform.Linux, UnrealTargetConfiguration.Development);
                break;
            case "WINRT":
                Agenda.AddTargets(WinRTDev, UnrealTargetPlatform.WinRT, UnrealTargetConfiguration.Development);
                break;
            case "MAC":
                Agenda.AddTargets(MacDebug, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Debug);
                break;
            case "HTML5":
                Agenda.AddTargets(HTML5Dev, UnrealTargetPlatform.HTML5, UnrealTargetConfiguration.Development);
                break;
            case "ANDROID":
                Agenda.AddTargets(AndroidDev, UnrealTargetPlatform.Android, UnrealTargetConfiguration.Development);
                break;
        }
        UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
        UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
    }

        public override void DoBuild(GUBP bp)
        {
            BuildProducts = new List<string>();
            var UE4Build = new UE4Build(bp);
            UE4Build.BuildAgenda Agenda = GetAgenda(bp);
            if (Agenda != null)
            {
                Agenda.DoRetries = false; // these would delete build products
                UE4Build.Build(Agenda, InDeleteBuildProducts: DeleteBuildProducts(), InUpdateVersionFiles: false, InForceUnity: true);
                PostBuild(bp, UE4Build);

                UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
                foreach (var Product in UE4Build.BuildProductFiles)
                {
                    AddBuildProduct(Product);
                }

                RemoveOveralppingBuildProducts();
                if (bp.bSignBuildProducts)
                {
                    // Sign everything we built
                    CodeSign.SignMultipleIfEXEOrDLL(bp, BuildProducts);
                }
            }
            else
            {
                SaveRecordOfSuccessAndAddToBuildProducts("Nothing to actually compile");
            }
        }

//.........这里部分代码省略.........
                        if (Exclude.Contains("Soul"))
                        {
                            RemoveTargetsFromList(Soul, List);
                        }
                        if (Exclude.Contains("StrategyVR"))
                        {
                            RemoveTargetsFromList(StrategyVR, List);
                        }
                    }
                }

                // @todo: make this programmatic by looping over the TargetLists (which maybe should be a map from config to list)
                string[] Win64Dev = Win64DevTargets.ToArray();
                string[] Win32Dev = Win32Targets.ToArray();
                string[] Win32Ship = Win32ShipTargets.ToArray();
                string[] PS4Dev = PS4DevTargets.ToArray();
                string[] XboxOneDev = XboxOneDevTargets.ToArray();
                string[] IOSDev = IOSDevTargets.ToArray();
                string[] MacDev = MacDevTargets.ToArray();
                string[] AndroidDev = AndroidDevTargets.ToArray();

                if (!String.IsNullOrEmpty(Config))
                {
                    switch (Config.ToUpperInvariant())
                    {
                        case "EDITORS":
                            Agenda.AddTargets(Win64Dev, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
                            Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
                            break;
                        case "WIN32DEV":
                            Agenda.AddTargets(Win32Dev, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
                            break;
                        case "WIN32SHIP":
                            Agenda.AddTargets(Win32Ship, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping);
                            break;
                        case "PS4DEV":
                            Agenda.AddTargets(PS4Dev, UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Development);
                            break;
                        case "XBOXONEDEV":
                            Agenda.AddTargets(XboxOneDev, UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Development);
                            break;
                        case "IOSDEV":
                            Agenda.AddTargets(IOSDev, UnrealTargetPlatform.IOS, UnrealTargetConfiguration.Development);
                            break;
                        case "MACDEV":
                            Agenda.AddTargets(MacDev, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
                            Agenda.AddTargets(MacProgramTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
                            break;
                        case "ANDROIDDEV":
                            Agenda.AddTargets(AndroidDev, UnrealTargetPlatform.Android, UnrealTargetConfiguration.Development);
                            break;
                    }
                }
                else
                {
                    Agenda.AddTargets(Win64Dev, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
                    Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development);
                    Agenda.AddTargets(Win32Dev, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development);
                    Agenda.AddTargets(Win32Ship, UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping);
                    Agenda.AddTargets(PS4Dev, UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Development);
                    Agenda.AddTargets(XboxOneDev, UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Development);
                    Agenda.AddTargets(IOSDev, UnrealTargetPlatform.IOS, UnrealTargetConfiguration.Development);
                }
            }
        }

        UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);
        if (String.IsNullOrEmpty(Config) || Config.ToLower() == "editors")
        {
            UE4Build.AddUATFilesToBuildProducts();
        }
        UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);

        if (P4Enabled)
        {
            // Sign everything we built
            CodeSign.SignMultipleIfEXEOrDLL(this, UE4Build.BuildProductFiles);

            // Open files for add or edit
            UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);

            // Check everything in!
            int SubmittedCL;
            Submit(WorkingCL, out SubmittedCL, true, true);

            // Label it
            if (String.IsNullOrEmpty(Config))
            {
                MakeDownstreamLabel("Promotable");
            }
            else if (Config.ToLower() == "editors")
            {
                MakeDownstreamLabel("Promotable-Partial-" + Config);
            }
            else
            {
                MakeDownstreamLabel("Partial-Promotable-" + Config, UE4Build.BuildProductFiles);
            }
        }
    }

    public override void ExecuteBuild()
    {
        Log("************************* BuildUAT");

        int WorkingCL = -1;
        if (P4Enabled)
        {
            WorkingCL = CreateChange(P4Env.Client, String.Format("UATOnly build built from changelist {0}", P4Env.Changelist));
            Log("Build from {0}    Working in {1}", P4Env.Changelist, WorkingCL);
        }

        ExecuteInner(WorkingCL);

        var UE4Build = new UE4Build(this);
        var Agenda = new UE4Build.BuildAgenda();

        Agenda.DotNetProjects.AddRange(
            new string[]
            {
                @"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj",
            }
            );

        UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);

        UE4Build.AddUATFilesToBuildProducts();

        UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);

        if (P4Enabled)
        {
            // Sign everything we built
            CodeSign.SignMultipleIfEXEOrDLL(this, UE4Build.BuildProductFiles);

            // Open files for add or edit
            UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);

            // Check everything in!
            int SubmittedCL;
            Submit(WorkingCL, out SubmittedCL, true, true);

            // Reset engine versions to 0 if required
            if (ParseParam("ZeroVersions"))
            {
                Execute<ZeroEngineVersions>(this);
            }
        }

        PrintRunTime();
    }

//.........这里部分代码省略.........
			var Targets = JustTarget.Split('|');
			if (Targets.Length < 1)
			{
				throw new AutomationException("BUILD FAILED target option '{0}' not parsed.", Target);
			}

			var Platforms = new List<UnrealTargetPlatform>();
			var Configurations = new List<UnrealTargetConfiguration>();

			for (int Part = 1; Part < Parts.Length; Part++)
			{
				if (!String.IsNullOrEmpty(Parts[Part]))
				{
					var SubParts = Parts[Part].Split('|');

					foreach (var SubPart in SubParts)
					{
						if (UEBuildPlatform.ConvertStringToPlatform(SubPart) != UnrealTargetPlatform.Unknown)
						{
							Platforms.Add(UEBuildPlatform.ConvertStringToPlatform(SubPart));
						}
						else
						{
							switch (SubPart.ToUpperInvariant())
							{
								case "DEBUG":
									Configurations.Add(UnrealTargetConfiguration.Debug);
									break;
								case "DEBUGGAME":
									Configurations.Add(UnrealTargetConfiguration.DebugGame);
									break;
								case "DEVELOPMENT":
									Configurations.Add(UnrealTargetConfiguration.Development);
									break;
								case "SHIPPING":
									Configurations.Add(UnrealTargetConfiguration.Shipping);
									break;
								case "TEST":
									Configurations.Add(UnrealTargetConfiguration.Test);
									break;
								default:
									throw new AutomationException("BUILD FAILED target option {0} not recognized.", SubPart);
							}
						}

					}
				}
			}
			if (Platforms.Count < 1)
			{
				Platforms.Add(UnrealTargetPlatform.Win64);
			}
			if (Configurations.Count < 1)
			{
				Configurations.Add(UnrealTargetConfiguration.Development);
			}
			foreach (var Platform in Platforms)
			{
				foreach (var CurTarget in Targets)
				{
					foreach (var Configuration in Configurations)
					{
						Agenda.AddTargets(new string[] { CurTarget }, Platform, Configuration);
						LogConsole("Target {0} {1} {2}", CurTarget, Platform.ToString(), Configuration.ToString());
						if (Clean)
						{
							string Args = String.Format("{0} {1} {2}", CurTarget, Platform.ToString(), Configuration.ToString());
							RunAndLog(CmdEnv, CleanToolLocation, Args);
						}
					}
				}
			}
		}
		LogConsole("*************************");

		Agenda.DoRetries = ParseParam("Retry");
		UE4Build.Build(Agenda, InUpdateVersionFiles: IsBuildMachine, InUseParallelExecutor: ParseParam("useparallelexecutor"), InShowProgress: ShowProgress);

		// 		if (WorkingCL > 0) // only move UAT files if we intend to check in some build products
		// 		{
		// 			UE4Build.CopyUATFilesAndAddToBuildProducts();
		// 		}

		UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);

		if (WorkingCL > 0)
		{
			// Sign everything we built
			CodeSign.SignMultipleIfEXEOrDLL(this, UE4Build.BuildProductFiles);

			// Open files for add or edit
			UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);

			int SubmittedCL;
			P4.Submit(WorkingCL, out SubmittedCL, true, true);
		}

		PrintRunTime();

	}

//.........这里部分代码省略.........
            Agenda.AddTargets(Params.EditorTargets.ToArray(), EditorPlatform, EditorConfiguration, Params.CodeBasedUprojectPath);
			if (Params.EditorTargets.Contains("UnrealHeaderTool") == false)
			{
				Agenda.AddTargets(new string[] { "UnrealHeaderTool" }, EditorPlatform, EditorConfiguration);
			}
			if (Params.EditorTargets.Contains("ShaderCompileWorker") == false)
			{
				Agenda.AddTargets(new string[] { "ShaderCompileWorker" }, EditorPlatform, EditorConfiguration);
			}
			if (Params.Pak && Params.EditorTargets.Contains("UnrealPak") == false)
			{
				Agenda.AddTargets(new string[] { "UnrealPak" }, EditorPlatform, EditorConfiguration);
			}
			if (Params.FileServer && Params.EditorTargets.Contains("UnrealFileServer") == false)
			{
				Agenda.AddTargets(new string[] { "UnrealFileServer" }, EditorPlatform, EditorConfiguration);
			}
		}

		// Setup cooked targets
		if (Params.HasClientCookedTargets && (TargetMask & ProjectBuildTargets.ClientCooked) == ProjectBuildTargets.ClientCooked)
		{
            List<UnrealTargetPlatform> UniquePlatformTypes = Params.ClientTargetPlatforms.ConvertAll(x => x.Type).Distinct().ToList();

            foreach (var BuildConfig in Params.ClientConfigsToBuild)
			{
                foreach (var ClientPlatformType in UniquePlatformTypes)
				{
                    string ScriptPluginArgs = GetBlueprintPluginPathArgument(Params, true, ClientPlatformType);
                    CrashReportPlatforms.Add(ClientPlatformType);
					Agenda.AddTargets(Params.ClientCookedTargets.ToArray(), ClientPlatformType, BuildConfig, Params.CodeBasedUprojectPath, InAddArgs: ScriptPluginArgs + " -remoteini=\"" + Params.RawProjectPath.Directory.FullName + "\"");
				}
			}
		}
		if (Params.HasServerCookedTargets && (TargetMask & ProjectBuildTargets.ServerCooked) == ProjectBuildTargets.ServerCooked)
		{
            List<UnrealTargetPlatform> UniquePlatformTypes = Params.ServerTargetPlatforms.ConvertAll(x => x.Type).Distinct().ToList();

            foreach (var BuildConfig in Params.ServerConfigsToBuild)
			{
				foreach (var ServerPlatformType in UniquePlatformTypes)
				{
                    string ScriptPluginArgs = GetBlueprintPluginPathArgument(Params, false, ServerPlatformType);
                    CrashReportPlatforms.Add(ServerPlatformType);
					Agenda.AddTargets(Params.ServerCookedTargets.ToArray(), ServerPlatformType, BuildConfig, Params.CodeBasedUprojectPath, InAddArgs: ScriptPluginArgs + " -remoteini=\"" + Params.RawProjectPath.Directory.FullName + "\"");
				}
			}
		}
		if (!Params.NoBootstrapExe && !Automation.IsEngineInstalled() && (TargetMask & ProjectBuildTargets.Bootstrap) == ProjectBuildTargets.Bootstrap)
		{
			UnrealBuildTool.UnrealTargetPlatform[] BootstrapPackagedGamePlatforms = { UnrealBuildTool.UnrealTargetPlatform.Win32, UnrealBuildTool.UnrealTargetPlatform.Win64 };
			foreach(UnrealBuildTool.UnrealTargetPlatform BootstrapPackagedGamePlatformType in BootstrapPackagedGamePlatforms)
			{
				if(Params.ClientTargetPlatforms.Contains(new TargetPlatformDescriptor(BootstrapPackagedGamePlatformType)))
				{
					Agenda.AddTarget("BootstrapPackagedGame", BootstrapPackagedGamePlatformType, UnrealBuildTool.UnrealTargetConfiguration.Shipping);
				}
			}
		}
		if (Params.CrashReporter && !Automation.IsEngineInstalled() && (TargetMask & ProjectBuildTargets.CrashReporter) == ProjectBuildTargets.CrashReporter)
		{
			foreach (var CrashReportPlatform in CrashReportPlatforms)
			{
				if (UnrealBuildTool.UnrealBuildTool.PlatformSupportsCrashReporter(CrashReportPlatform))
				{
					Agenda.AddTarget("CrashReportClient", CrashReportPlatform, UnrealTargetConfiguration.Shipping);
				}
			}
		}
		if (Params.HasProgramTargets && (TargetMask & ProjectBuildTargets.Programs) == ProjectBuildTargets.Programs)
		{
            List<UnrealTargetPlatform> UniquePlatformTypes = Params.ClientTargetPlatforms.ConvertAll(x => x.Type).Distinct().ToList();

            foreach (var BuildConfig in Params.ClientConfigsToBuild)
			{
				foreach (var ClientPlatformType in UniquePlatformTypes)
				{
					Agenda.AddTargets(Params.ProgramTargets.ToArray(), ClientPlatformType, BuildConfig, Params.CodeBasedUprojectPath);
				}
			}
		}
		UE4Build.Build(Agenda, InDeleteBuildProducts: Params.Clean, InUpdateVersionFiles: WorkingCL > 0);

		if (WorkingCL > 0) // only move UAT files if we intend to check in some build products
		{
			UE4Build.AddUATFilesToBuildProducts();
		}
		UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);

		if (WorkingCL > 0)
		{
			// Sign everything we built
			CodeSign.SignMultipleIfEXEOrDLL(Command, UE4Build.BuildProductFiles);

			// Open files for add or edit
			UE4Build.AddBuildProductsToChangelist(WorkingCL, UE4Build.BuildProductFiles);
		}

		Log("********** BUILD COMMAND COMPLETED **********");
	}

    void ExecuteInner(int WorkingCL)
    {
        var UE4Build = new UE4Build(this);
        var Agenda = new UE4Build.BuildAgenda();

        Agenda.DotNetSolutions.AddRange(
            new string[]
            {
                //@"Engine\Source\Programs\UnrealDocTool\UnrealDocTool\UnrealDocTool.sln",
                //@"Engine\Source\Programs\NetworkProfiler\NetworkProfiler.sln",
            }
            );

        Agenda.DotNetProjects.AddRange(
            new string[]
            {
                //@"Engine\Source\Programs\DotNETCommon\DotNETUtilities\DotNETUtilities.csproj",
                //@"Engine\Source\Programs\CrashReporter\CrashReportCommon\CrashReportCommon.csproj",
                //@"Engine\Source\Programs\CrashReporter\CrashReportInput\CrashReportInput.csproj",
                //@"Engine\Source\Programs\CrashReporter\CrashReportUploader\CrashReportUploader.csproj",
                //@"Engine\Source\Programs\CrashReporter\CrashReportReceiver\CrashReportReceiver.csproj",
                //@"Engine\Source\Programs\CrashReporter\CrashReportProcess\CrashReportProcess.csproj",
                //@"Engine\Source\Programs\CrashReporter\RegisterPII\RegisterPII.csproj",
                //@"Engine\Source\Programs\Distill\Distill.csproj",
                //@"Engine\Source\Programs\UnSetup\UnSetup.csproj",
            }
            );

        Agenda.ExtraDotNetFiles.AddRange(
            new string[]
            {
                //"Interop.IWshRuntimeLibrary",
                //"UnrealMarkdown",
                //"CommonUnrealMarkdown",
            }
            );

        {
            if (LeanAndMean)
            {
                var ProgramTargets = new string[]
                {
                    "CrashReportClient",
                    "ShaderCompileWorker",
                    "UnrealHeaderTool",
                    "UnrealLightmass",
                };
                Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);

                var MacDevTargets = new string[]
                {
                    "QAGameEditor",
                };
                Agenda.AddTargets(MacDevTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);
            }
            else
            {
                var ProgramTargets = new string[]
                {
                    "BuildPatchTool",
                    "CrashReportClient",
                    "UnrealFileServer",
                    "ShaderCompileWorker",
                    //"MinidumpDiagnostics",
                    //"SymbolDebugger",
                    "UnrealFrontend",
                    "UnrealHeaderTool",
                    "UnrealLightmass",
                    "UnrealPak",
                    //"UnrealRemoteAgent",
                };
                Agenda.AddTargets(ProgramTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);

                var MacDevTargets = new string[]
                {
        //					"FortniteEditor",
        //					"OrionEditor",
                    "PlatformerGameEditor",
                    "QAGameEditor",
                    "ShooterGameEditor",
                    "StrategyGameEditor",
        //					"VehicleGameEditor",
        //					"FortniteGame",
        //					"FortniteServer",
        //					"OrionGame",
                    "PlatformerGame",
                    "QAGame",
                    "ShooterGame",
                    "StrategyGame",
        //					"VehicleGame",
                };
                Agenda.AddTargets(MacDevTargets, UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development);

            }
        }

        UE4Build.Build(Agenda, InDeleteBuildProducts: true, InUpdateVersionFiles: true);

        UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);

//.........这里部分代码省略.........

        public override void DoBuild(GUBP bp)
        {
            BuildProducts = new List<string>();
            var UE4Build = new UE4Build(bp);
            UE4Build.BuildAgenda Agenda = GetAgenda(bp);
            if (Agenda != null)
            {
                bool ReallyDeleteBuildProducts = DeleteBuildProducts() && !GUBP.bForceIncrementalCompile;
                Agenda.DoRetries = false; // these would delete build products
				bool UseParallelExecutor = bDependentOnCompileTools && (HostPlatform == UnrealTargetPlatform.Win64);
				UE4Build.Build(Agenda, InDeleteBuildProducts: ReallyDeleteBuildProducts, InUpdateVersionFiles: false, InForceNoXGE: true, InForceUnity: true, InUseParallelExecutor: UseParallelExecutor);
                var StartPostBuild = DateTime.Now.ToString();
                PostBuild(bp, UE4Build);
                var FinishPostBuild = DateTime.Now.ToString();
                PrintCSVFile(String.Format("UAT,PostBuild,{0},{1}", StartPostBuild, FinishPostBuild));
                UE4Build.CheckBuildProducts(UE4Build.BuildProductFiles);
                foreach (var Product in UE4Build.BuildProductFiles)
                {
                    AddBuildProduct(Product);
                }
                RemoveOveralppingBuildProducts();
                if (bp.bSignBuildProducts)
                {
                    // Sign everything we built
                    var StartSign = DateTime.Now.ToString();
                    CodeSign.SignMultipleIfEXEOrDLL(bp, BuildProducts);
                    var FinishSign = DateTime.Now.ToString();
                    PrintCSVFile(String.Format("UAT,SignBuildProducts,{0},{1}", StartSign, FinishSign));
                }
                PostBuildProducts(bp);
            }
            if (Agenda == null || (BuildProducts.Count == 0 && GUBP.bForceIncrementalCompile))
            {
                SaveRecordOfSuccessAndAddToBuildProducts("Nothing to actually compile");
            }
        }