static string GetBlueprintPluginPathArgument(ProjectParams Params, bool Client, UnrealTargetPlatform TargetPlatform)
    {
        string ScriptPluginArgs = "";

        // if we're utilizing an auto-generated code plugin/module (a product of 
        // the cook process), make sure to compile it along with the targets here

        if (Params.RunAssetNativization)
        {
            ProjectParams.BlueprintPluginKey PluginKey = new ProjectParams.BlueprintPluginKey();
            PluginKey.Client = Client;
            PluginKey.TargetPlatform = TargetPlatform;
            FileReference CodePlugin = null;
            if(Params.BlueprintPluginPaths.TryGetValue(PluginKey, out CodePlugin))
            {
                ScriptPluginArgs += "-PLUGIN \"" + CodePlugin + "\" ";
            }
            else
            {
                LogWarning("BlueprintPluginPath for " + TargetPlatform + " " + (Client ? "client" : "server") + " was not found");
            }
        }

        return ScriptPluginArgs;
    }

        // NOTE: If we're building a monolithic binary, then the game and engine code are linked together into one
        //       program executable, so we want the application name to be the game name.  In the case of a modular
        //       binary, we use 'UnrealEngine' for our application name
        public UEBuildClient(
			string InGameName, 
			UnrealTargetPlatform InPlatform, 
			UnrealTargetConfiguration InConfiguration,
			TargetRules InRulesObject,
			List<string> InAdditionalDefinitions, 
			string InRemoteRoot, 
			List<OnlyModule> InOnlyModules)
            : base(InAppName: UEBuildTarget.GetBinaryBaseName(InGameName, InRulesObject, InPlatform, InConfiguration, "Client"),
                InGameName: InGameName,
                InPlatform: InPlatform,
                InConfiguration: InConfiguration,
                InRulesObject: InRulesObject,
                InAdditionalDefinitions: InAdditionalDefinitions,
                InRemoteRoot: InRemoteRoot,
                InOnlyModules: InOnlyModules)
        {
            if (ShouldCompileMonolithic())
            {
                if ((UnrealBuildTool.IsDesktopPlatform(Platform) == false) ||
                    (Platform == UnrealTargetPlatform.WinRT) ||
                    (Platform == UnrealTargetPlatform.WinRT_ARM))
                {
                    // We are compiling for a console...
                    // We want the output to go into the <GAME>\Binaries folder
                    if (InRulesObject.bOutputToEngineBinaries == false)
                    {
                        OutputPath = OutputPath.Replace("Engine\\Binaries", InGameName + "\\Binaries");
                    }
                }
            }
        }

    public override List<UnrealTargetPlatform> GUBP_GetPlatforms_MonolithicOnly(UnrealTargetPlatform HostPlatform)
    {
        List<UnrealTargetPlatform> Platforms = null;

        switch (HostPlatform)
        {
            case UnrealTargetPlatform.Mac:
                Platforms = new List<UnrealTargetPlatform> { UnrealTargetPlatform.IOS };
                break;

            case UnrealTargetPlatform.Linux:
                Platforms = new List<UnrealTargetPlatform>();
                break;

            case UnrealTargetPlatform.Win64:
                Platforms = new List<UnrealTargetPlatform>();
                break;

            default:
                Platforms = new List<UnrealTargetPlatform>();
                break;
        }

        return Platforms;
    }

        // NOTE: If we're building a monolithic binary, then the game and engine code are linked together into one
        //       program executable, so we want the application name to be the game name.  In the case of a modular
        //       binary, we use 'UnrealEngine' for our application name
        public UEBuildEditor(
			string InGameName, 
			UnrealTargetPlatform InPlatform, 
			UnrealTargetConfiguration InConfiguration,
			TargetRules InRulesObject,
			List<string> InAdditionalDefinitions, 
			string InRemoteRoot, 
			List<OnlyModule> InOnlyModules,
			bool bInEditorRecompile)
            : base(InAppName:UEBuildTarget.GetBinaryBaseName(
					InGameName, 
					InRulesObject, 
					InPlatform, 
					InConfiguration, 
					(InRulesObject.Type == TargetRules.TargetType.Editor) ? "Editor" : ""
					),
				InGameName:InGameName, 
				InPlatform:InPlatform, 
				InConfiguration:InConfiguration,
				InRulesObject: InRulesObject, 
				InAdditionalDefinitions:InAdditionalDefinitions, 
				InRemoteRoot:InRemoteRoot, 
				InOnlyModules:InOnlyModules,
				bInEditorRecompile: bInEditorRecompile)
        {
        }

    static void AddPluginToAgenda(UE4Build.BuildAgenda Agenda, string PluginFileName, PluginDescriptor Plugin, string TargetName, TargetRules.TargetType TargetType, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, List<string> ReceiptFileNames, string InAdditionalArgs)
    {
        // Find a list of modules that need to be built for this plugin
        List<string> ModuleNames = new List<string>();
        foreach(ModuleDescriptor Module in Plugin.Modules)
        {
            bool bBuildDeveloperTools = (TargetType == TargetRules.TargetType.Editor || TargetType == TargetRules.TargetType.Program);
            bool bBuildEditor = (TargetType == TargetRules.TargetType.Editor);
            if(Module.IsCompiledInConfiguration(Platform, TargetType, bBuildDeveloperTools, bBuildEditor))
            {
                ModuleNames.Add(Module.Name);
            }
        }

        // Add these modules to the build agenda
        if(ModuleNames.Count > 0)
        {
            string Arguments = String.Format("-plugin {0}", CommandUtils.MakePathSafeToUseWithCommandLine(PluginFileName));
            foreach(string ModuleName in ModuleNames)
            {
                Arguments += String.Format(" -module {0}", ModuleName);
            }

            string ReceiptFileName = BuildReceipt.GetDefaultPath(Path.GetDirectoryName(PluginFileName), TargetName, Platform, Configuration, "");
            Arguments += String.Format(" -receipt {0}", CommandUtils.MakePathSafeToUseWithCommandLine(ReceiptFileName));
            ReceiptFileNames.Add(ReceiptFileName);

            if(!String.IsNullOrEmpty(InAdditionalArgs))
            {
                Arguments += InAdditionalArgs;
            }

            Agenda.AddTarget(TargetName, Platform, Configuration, InAddArgs: Arguments);
        }
    }

    public override Dictionary<string, List<UnrealTargetPlatform>> GUBP_NonCodeProjects_BaseEditorTypeOnly(UnrealTargetPlatform HostPlatform)
    {
        var NonCodeProjectNames = new Dictionary<string, List<UnrealTargetPlatform>>();
        NonCodeProjectNames.Add("Elemental", new List<UnrealTargetPlatform> { HostPlatform });
        NonCodeProjectNames.Add("Infiltrator", new List<UnrealTargetPlatform> { HostPlatform });
        NonCodeProjectNames.Add("HoverShip", new List<UnrealTargetPlatform> { HostPlatform });
        NonCodeProjectNames.Add("Blueprint_Examples", new List<UnrealTargetPlatform> { HostPlatform });
        NonCodeProjectNames.Add("Reflections", new List<UnrealTargetPlatform> { HostPlatform });
        NonCodeProjectNames.Add("ContentExamples", new List<UnrealTargetPlatform> { HostPlatform });

        NonCodeProjectNames.Add("MobileTemple", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("TappyChicken", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("SwingNinja", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("Mobile", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });

        NonCodeProjectNames.Add("TP_FirstPersonBP", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("TP_FlyingBP", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("TP_SideScrollerBP", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("TP_StarterContentBP", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("TP_ThirdPersonBP", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("TP_TopDownBP", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });
        NonCodeProjectNames.Add("TP_VehicleBP", new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Android, UnrealTargetPlatform.IOS });

        return NonCodeProjectNames;
    }

 public override GUBPProjectOptions GUBP_IncludeProjectInPromotedBuild_EditorTypeOnly(UnrealTargetPlatform HostPlatform)
 {
     var Result = new GUBPProjectOptions();
     Result.bTestWithShared = false;
     Result.bIsNonCode = true;
     return Result;
 }

    private void AddCustomNodes(UnrealTargetPlatform InHostPlatform)
    {
        if (Adders == null)
        {
            Adders = new List<GUBPNodeAdder>();
            Assembly[] LoadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
            foreach (var Dll in LoadedAssemblies)
            {
				Type[] AllTypes = GetTypesFromAssembly(Dll);
                foreach (var PotentialConfigType in AllTypes)
                {
                    if (PotentialConfigType != typeof(GUBPNodeAdder) && typeof(GUBPNodeAdder).IsAssignableFrom(PotentialConfigType))
                    {
                        GUBPNodeAdder Config = Activator.CreateInstance(PotentialConfigType) as GUBPNodeAdder;
                        if (Config != null)
                        {
                            Adders.Add(Config);
                        }
                    }
                }
            }
        }
        foreach(var Adder in Adders)
        {
            Adder.AddNodes(this, InHostPlatform);
        }
    }

    public override bool GUBP_AlwaysBuildWithTools(UnrealTargetPlatform InHostPlatform, bool bBuildingRocket, out bool bInternalToolOnly, out bool SeparateNode, out bool CrossCompile)
	{
		bInternalToolOnly = false;
		SeparateNode = false;
		CrossCompile = false;
		return (InHostPlatform == UnrealTargetPlatform.Win64);
	}

        /// <summary>
        /// Reads an array from the config files, matching a given section and key.
        /// </summary>
        public static void ReadArray(string ProjectDirectory, UnrealTargetPlatform Platform, string BaseIniName, string FindSection, string FindKey, List<string> Values)
        {
            foreach (string IniFileName in EnumerateIniFileNames(ProjectDirectory, Platform, BaseIniName))
            {
                if (File.Exists(IniFileName))
                {
                    bool bInCorrectSection = false;
                    foreach(string Line in File.ReadAllLines(IniFileName))
                    {
                        // Skip the whitespace at the start of the line
                        int LineMin = 0;
                        while(LineMin < Line.Length && Char.IsWhiteSpace(Line[LineMin])) LineMin++;

                        // Skip the whitespace at the end of the line
                        int LineMax = Line.Length;
                        while (LineMax > LineMin && Char.IsWhiteSpace(Line[LineMax - 1])) LineMax--;

                        // Check it's not a comment
                        if (LineMax > LineMin && Line[LineMin] != ';')
                        {
                            if (Line[LineMin] == '[' && Line[LineMax - 1] == ']')
                            {
                                // This is a section heading. Check if it's the section we're looking for.
                                bInCorrectSection = (FindSection.Length == LineMax - LineMin - 2 && String.Compare(Line, LineMin + 1, FindSection, 0, LineMax - LineMin - 2) == 0);
                            }
                            else if (bInCorrectSection)
                            {
                                // Split the line into key/value.
                                TryParseArrayKeyValue(Line, LineMin, LineMax, FindKey, Values);
                            }
                        }
                    }
                }
            }
        }

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="InName">Name of the target that may be built.</param>
		/// <param name="InType">Specifies the type of the targtet to generate.</param>
		/// <param name="InProductName">Specifies the name of the executable if it differs from the InName</param>
		/// <param name="InTargetPlatform">Name of the target that may be built.</param>
		/// <param name="InDependencies">Name of the target that may be built.</param>
		/// <param name="bHasPlist">Name of the target that may be built.</param>
		public XcodeProjectTarget(string InDisplayName, string InTargetName, XcodeTargetType InType, string InTargetFilePath, string InProductName = "", UnrealTargetPlatform InTargetPlatform = UnrealTargetPlatform.Mac, bool bInIsMacOnly = false, List<XcodeTargetDependency> InDependencies = null, bool bHasPlist = false, List<XcodeFrameworkRef> InFrameworks = null)
		{
			DisplayName = InDisplayName;
			TargetName = InTargetName;
			Type = InType;
			ProductName = InProductName;
			TargetFilePath = InTargetFilePath;
			TargetPlatform = InTargetPlatform;
			bIsMacOnly = bInIsMacOnly;
			Guid = XcodeProjectFileGenerator.MakeXcodeGuid();
			BuildConfigGuild = XcodeProjectFileGenerator.MakeXcodeGuid();
			SourcesPhaseGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			ResourcesPhaseGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			FrameworksPhaseGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			ShellScriptPhaseGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			ProductGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			DebugConfigGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			DevelopmentConfigGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			ShippingConfigGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			TestConfigGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			DebugGameConfigGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			Dependencies = InDependencies == null ? new List<XcodeTargetDependency>() : InDependencies;
			FrameworkRefs = InFrameworks == null ? new List<XcodeFrameworkRef>() : InFrameworks;
			// Meant to prevent adding plists that don't belong to the target, like in the case of Mac builds.
			if (bHasPlist)
			{
				PlistGuid = XcodeProjectFileGenerator.MakeXcodeGuid();
			}
		}

		public UEBuildServer(
			string InGameName, 
			UnrealTargetPlatform InPlatform, 
			UnrealTargetConfiguration InConfiguration,
			TargetRules InRulesObject,
			List<string> InAdditionalDefinitions, 
			string InRemoteRoot, 
			List<OnlyModule> InOnlyModules,
			bool bInEditorRecompile)
			// NOTE: If we're building a monolithic binary, then the game and engine code are linked together into one
			//       program executable, so we want the application name to be the game name.  In the case of a modular
			//       binary, we use 'UnrealEngine' for our application name
			: base(
				InAppName:UEBuildTarget.GetBinaryBaseName(InGameName, InRulesObject, InPlatform, InConfiguration, "Server"),
				InGameName:InGameName,
				InPlatform:InPlatform,
				InConfiguration:InConfiguration,
				InRulesObject: InRulesObject, 
				InAdditionalDefinitions:InAdditionalDefinitions,
				InRemoteRoot:InRemoteRoot,
				InOnlyModules:InOnlyModules,
				bInEditorRecompile: bInEditorRecompile
			)
		{
		}

    public override List<GUBPFormalBuild> GUBP_GetConfigsForFormalBuilds_MonolithicOnly(UnrealTargetPlatform HostPlatform)
    {
        if (HostPlatform == UnrealTargetPlatform.Win64)
        {
            return new List<GUBPFormalBuild>
            {
                new GUBPFormalBuild(UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Development),
                new GUBPFormalBuild(UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Development),
                new GUBPFormalBuild(UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Development),
                new GUBPFormalBuild(UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Development),

                new GUBPFormalBuild(UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Test),
                new GUBPFormalBuild(UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Test),
                new GUBPFormalBuild(UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Test),
                new GUBPFormalBuild(UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Test),

                new GUBPFormalBuild(UnrealTargetPlatform.Win32, UnrealTargetConfiguration.Shipping),
                new GUBPFormalBuild(UnrealTargetPlatform.Win64, UnrealTargetConfiguration.Shipping),
                new GUBPFormalBuild(UnrealTargetPlatform.XboxOne, UnrealTargetConfiguration.Shipping),
                new GUBPFormalBuild(UnrealTargetPlatform.PS4, UnrealTargetConfiguration.Shipping),
            };
        }
        else
        {
            return new List<GUBPFormalBuild>
            {
                new GUBPFormalBuild(UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Development),
                new GUBPFormalBuild(UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Test),
                new GUBPFormalBuild(UnrealTargetPlatform.Mac, UnrealTargetConfiguration.Shipping),
            };
        }
    }

 public override bool GUBP_AlwaysBuildWithTools(UnrealTargetPlatform InHostPlatform, out bool bInternalToolOnly, out bool SeparateNode, out bool CrossCompile)
 {
     bInternalToolOnly = false;
     SeparateNode = false;
     CrossCompile = false;
     return true;
 }

		protected void RegisterRemoteToolChain(UnrealTargetPlatform InPlatform, CPPTargetPlatform CPPPlatform)
		{
			RemoteToolChainPlatform = InPlatform;

			// Register this tool chain for IOS
			Log.TraceVerbose("        Registered for {0}", CPPPlatform.ToString());
			UEToolChain.RegisterPlatformToolChain(CPPPlatform, this);
		}

		/**
		 *	Return the VisualStudio platform name for this build platform
		 *	
		 *	@param	InPlatform			The UnrealTargetPlatform being built
		 *	@param	InConfiguration		The UnrealTargetConfiguration being built
		 *	
		 *	@return	string				The name of the platform that VisualStudio recognizes
		 */
		public override string GetVisualStudioPlatformName(UnrealTargetPlatform InPlatform, UnrealTargetConfiguration InConfiguration)
		{
			if (InPlatform == UnrealTargetPlatform.WinRT)
			{
				return "WinRT";
			}
			return InPlatform.ToString();
		}

 /// <summary>
 /// Allow various platform project generators to generate any special project properties if required
 /// </summary>
 /// <param name="InPlatform"></param>
 /// <returns></returns>
 public static bool GenerateGamePlatformSpecificProperties(UnrealTargetPlatform InPlatform, UnrealTargetConfiguration Configuration, TargetRules.TargetType TargetType, StringBuilder VCProjectFileContent, string RootDirectory, string TargetFilePath)
 {
     if (ProjectGeneratorDictionary.ContainsKey(InPlatform) == true)
     {
         ProjectGeneratorDictionary[InPlatform].GenerateGameProperties(Configuration, VCProjectFileContent, TargetType, RootDirectory, TargetFilePath); ;
     }
     return true;
 }

 public override List<UnrealTargetPlatform> GUBP_ToolPlatforms(UnrealTargetPlatform InHostPlatform)
 {
     if (InHostPlatform == UnrealTargetPlatform.Win64)
     {
         return new List<UnrealTargetPlatform> { UnrealTargetPlatform.Win64, UnrealTargetPlatform.Win32};
     }
     return base.GUBP_ToolPlatforms(InHostPlatform);
 }

 public override List<UnrealTargetPlatform> GUBP_GetPlatforms_MonolithicOnly(UnrealTargetPlatform HostPlatform)
 {
     if (HostPlatform == UnrealTargetPlatform.Mac)
     {
         return new List<UnrealTargetPlatform>{UnrealTargetPlatform.Mac};
     }
     return new List<UnrealTargetPlatform> { UnrealTargetPlatform.Win32, UnrealTargetPlatform.Win64, UnrealTargetPlatform.PS4, UnrealTargetPlatform.XboxOne };
 }

 public override List<UnrealTargetPlatform> GUBP_GetPlatforms_MonolithicOnly(UnrealTargetPlatform HostPlatform)
 {
     if (HostPlatform == UnrealTargetPlatform.Mac)
     {
         return new List<UnrealTargetPlatform>();
     }
     return new List<UnrealTargetPlatform> { HostPlatform, UnrealTargetPlatform.Win32, UnrealTargetPlatform.Linux };
 }