static void GenericBuild(string[] scenes, string target_dir, BuildTarget build_target, BuildOptions build_options) {
     EditorUserBuildSettings.SwitchActiveBuildTarget(build_target);
     string res = BuildPipeline.BuildPlayer(scenes, target_dir, build_target, build_options);
     if (res.Length > 0) {
         throw new Exception("BuildPlayer failure: " + res);
     }
 }

    public static void BuildGame(BuildTarget buildTarget, BuildOptions buildOptions = BuildOptions.None)
    {
        if (BuildPipeline.isBuildingPlayer == false) {
            UnityEngine.Debug.ClearDeveloperConsole();

            var smcsFile = Path.Combine( Application.dataPath, "smcs.rsp" );
            var gmcsFile = Path.Combine( Application.dataPath, "gmcs.rsp" );

            // -define:debug;poop
            File.WriteAllText( smcsFile, "-define:BUILD" );
            File.WriteAllText( gmcsFile, "-define:BUILD" );

            AssetDatabase.Refresh();

            string[] scenes = GetSceneList();
            //string path = Application.dataPath.Remove(Application.dataPath.Length - 8, 7) + "_build";

            // Build player.
            BuildPipeline.BuildPlayer(scenes, path + "/" + StringManager.BUILDNAME + ".exe", buildTarget, buildOptions);

            // Copy a file from the project folder to the build folder, alongside the built game. eg:
            // FileUtil.CopyFileOrDirectory("Assets/WebPlayerTemplates/Readme.txt", path + "Readme.txt");

            //remove build thingies
            File.WriteAllText( smcsFile, "" );
            File.WriteAllText( gmcsFile, "" );
        }
    }

 private BuildConfiguration()
 {
     this.scenes = new List<string>();
     this.dirMappings = new Dictionary<string, string>();
     this.fileMappings = new Dictionary<string, string>();
     this.options = BuildOptions.None;
 }

 public BaseBuilder()
 {
     Name = "Base";
     options = BuildOptions.None;
     target = BuildTarget.Android;
     DefineSymbols = "";
 }

        string BuildPlayer(BuildTarget target, BuildOptions options, params string[] levels)
        {
            var output = Path.Combine(OutputDir, target.ToString());
            DirectoryEx.DeleteDirectory(output);

            BuildPipeline.BuildPlayer(levels, output, target,  options);
            return output;
        }

    public static void PerformIOSReleaseBuild()
    {
        _excelSuccessCallback = DoIOSReleaseBuild;

        _buildOptions = BuildOptions.Il2CPP;

        // Process the Excel Files
        ProcessExcelFiles();
    }

 public static string GetExtensionForBuildTarget(BuildTarget target, BuildOptions options)
 {
     IBuildPostprocessor buildPostProcessor = ModuleManager.GetBuildPostProcessor(target);
     if (buildPostProcessor == null)
     {
         return string.Empty;
     }
     return buildPostProcessor.GetExtension(target, options);
 }

        private static void ParseArgs(ref BuildOptions opt, ref string outputpath)
        {
            string[] args = System.Environment.GetCommandLineArgs();

            string productPath = Path.Combine(Application.dataPath, KEngine.AppEngine.GetConfig("ProductRelPath"));

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

            if (args.Length >= 2)
            {
                CommandArgs commandArg = CommandLine.Parse(args);
                //List<string> lparams = commandArg.Params;
                Dictionary<string, string> argPairs = commandArg.ArgPairs;

                foreach (KeyValuePair<string, string> item in argPairs)
                {
                    switch (item.Key)
                    {
                        case "BundleVersion":
                            PlayerSettings.bundleVersion = item.Value;
                            break;
                        case "AndroidVersionCode":
                            PlayerSettings.Android.bundleVersionCode = System.Int32.Parse(item.Value);
                            break;
                        case "AndroidKeyStoreName":
                            PlayerSettings.Android.keystoreName = item.Value;
                            break;
                        case "AndroidKeyStorePass":
                            PlayerSettings.Android.keystorePass = item.Value;
                            break;
                        case "AndroidkeyAliasName":
                            PlayerSettings.Android.keyaliasName = item.Value;
                            break;
                        case "AndroidKeyAliasPass":
                            PlayerSettings.Android.keyaliasPass = item.Value;
                            break;
                        case "BuildOptions":
                        {
                            opt = BuildOptions.None;
                            string[] opts = item.Value.Split('|');
                            foreach (string o in opts)
                            {
                                opt = opt | (BuildOptions) System.Enum.Parse(typeof (BuildOptions), o);
                            }
                        }
                            break;
                        case "Outputpath":
                            outputpath = item.Value;
                            break;
                    }
                    UnityEngine.Debug.Log(item.Key + " : " + item.Value);
                }
            }
        }

    public static void PerformIOSReleaseBuildAndRun()
    {
        _excelSuccessCallback = DoIOSReleaseBuild;

        _buildOptions = BuildOptions.Il2CPP | BuildOptions.AutoRunPlayer;

        // Process the Excel Files
        ProcessExcelFiles();
    }

 public static string GetScriptLayoutFileFromBuild(BuildOptions options, BuildTarget target, string installPath, string fileName)
 {
     IBuildPostprocessor buildPostProcessor = ModuleManager.GetBuildPostProcessor(target);
     if (buildPostProcessor != null)
     {
         return buildPostProcessor.GetScriptLayoutFileFromBuild(options, installPath, fileName);
     }
     return "";
 }

    public static void PerformIOSDebugBuild()
    {
        _excelSuccessCallback = DoIOSDebugBuild;

        _buildOptions = BuildOptions.Il2CPP | BuildOptions.Development | BuildOptions.AllowDebugging | BuildOptions.SymlinkLibraries;

        // Process the Excel Files
        ProcessExcelFiles();
    }

    static void GenericBuild(string[] scenes, string target_filename, BuildTarget build_target, BuildOptions build_options)
    {
        EditorUserBuildSettings.SwitchActiveBuildTarget(build_target);
        Debug.Log("-- 빌드 과정을 시작합니다...");
        string res = BuildPipeline.BuildPlayer(scenes, target_filename, build_target, build_options);
        if (res.Length > 0) {

            throw new Exception("빌드 실패: " + res);
        }
    }

    public void DrawGUI(uBuildWindow window)
    {
        EditorGUILayout.BeginHorizontal();
        IsFoldOut = EditorGUILayout.Foldout( IsFoldOut, BuildName + " (" + target.ToString() + ')');
        GUILayout.FlexibleSpace();
        if(Errors.Count > 0)
        {
            GUILayout.Label(window.errBtnContent);
        }
        if(GUILayout.Button(window.rmBtnContent))
        {
            window.RemoveBuildSetting(this);
        }
        EditorGUILayout.EndHorizontal();

        if(IsFoldOut)
        {
            isEnabled = EditorGUILayout.Toggle("Enabled?", isEnabled);
            GUI.enabled = isEnabled;
            BuildName = EditorGUILayout.TextField("BuildName: ", BuildName);

            BuildTarget newtarget = (BuildTarget)EditorGUILayout.EnumPopup("Target: ", target);
            if(newtarget != target)
            {
                Extension = Extension == DeterminateExtension(target) ? DeterminateExtension(newtarget) : Extension;
                target = newtarget;
            }
            options = (BuildOptions)EditorGUILayout.EnumMaskField("Options: ", options);

            HasCustomExtension = EditorGUILayout.ToggleLeft("Custom Extension?", HasCustomExtension);

            if(HasCustomExtension)
            {
                EditorGUILayout.BeginHorizontal();
                Extension = EditorGUILayout.TextField("Custom Extension: ", Extension ?? DeterminateExtension(target));
                EditorGUILayout.EndHorizontal();
            }
            GUI.enabled = true;

            if(Errors.Count > 0)
            {
                //EditorGUILayout.BeginScrollView(errorScroll, false, false);
                GUILayout.Space(10);
                EditorGUILayout.BeginHorizontal();
                for (int i = 0; i < Errors.Count;++i)
                {

                    Vector2 h = GUI.skin.button.CalcSize(new GUIContent(Errors[i]));
                    EditorGUILayout.SelectableLabel(Errors[i], GUILayout.Height(h.y), GUILayout.Width(h.x));
                }
                EditorGUILayout.EndHorizontal();
                //EditorGUILayout.EndScrollView();
            }
        }
    }

 static void GenericBuild(string[] scenes, string target_dir, BuildTarget build_target, BuildOptions build_options)
 {
     if(!Directory.Exists(TARGET_DIR)){
         Directory.CreateDirectory(TARGET_DIR);
     }
         EditorUserBuildSettings.SwitchActiveBuildTarget(build_target);
         string res = BuildPipeline.BuildPlayer(scenes,target_dir,build_target,build_options);
         if (res.Length > 0) {
                 throw new Exception("BuildPlayer failure: " + res);
         }
 }

        internal BuildLogger(IApp app, Document doc, ScintillaControl sci, BuildOptions options)
        {
            this.app = app;
            this.doc = doc;
            this.sci = sci;
            this.options = options;

            app.CloseView("ErrorList");
            this.err = app.GetService<IErrorListService>();
            this.output = app.GetService<IOutputService>();
        }

 public override string PrepareForBuild(BuildOptions options, BuildTarget target)
 {
     if (EditorUserBuildSettings.wsaSDK != WSASDK.UWP)
     {
         return null;
     }
     if (Utility.UseIl2CppScriptingBackend())
     {
         return null;
     }
     return NuGet.Restore(target);
 }

    static void BuildPlatform(BuildTarget target, string locationPathNameBase, BuildOptions options = BuildOptions.None, string gameNamePostfix = "")
    {
        Directory.CreateDirectory(locationPathNameBase);

        var s = Path.Combine(locationPathNameBase, GetName(target, gameNamePostfix));

        Debug.Log(string.Format("building {0} to {1}", target, s));

        OnPreBuild(target, locationPathNameBase, s);
        BuildPipeline.BuildPlayer(GetLevels(target), s, target, options);
        OnPostBuild(target, locationPathNameBase, s);
    }

    public void FromJson(JObject json)
    {
        this.buildPath = null;
        this.scenesInBuild.Clear();
        this.buildTarget = (BuildTarget)0;
        this.buildOptions = BuildOptions.None;

        if (json == null)
        {
            return;
        }

        JToken obj;
        if (json.TryGetValue("path", out obj))
        {
            this.buildPath = (string)obj;
        }

        if (json.TryGetValue("buildTarget", out obj))
        {
            this.buildTarget = (BuildTarget)System.Enum.Parse(typeof(BuildTarget), (string)obj, true);
        }

        if (json.TryGetValue("buildOptions", out obj))
        {
            var options = (JObject)obj;
            var co = (CustomBuildOptions)this.buildOptions;
            foreach (var p in options)
            {
                if ((bool)p.Value)
                {
                    try
                    {
                        co |= (CustomBuildOptions)System.Enum.Parse(typeof(CustomBuildOptions), p.Key, true);
                    }
                    catch
                    {
                    }
                }
            }
            this.buildOptions = (BuildOptions)co;
        }

        if (json.TryGetValue("scenes", out obj))
        {
            var scenes = (JArray)obj;
            foreach (var s in scenes)
            {
                this.scenesInBuild.Add((string)s);
            }
        }
    }

 /// <summary>
 ///   <para>Builds a player.</para>
 /// </summary>
 /// <param name="levels">The scenes to be included in the build. If empty, the currently open scene will be built. Paths are relative to the project folder (AssetsMyLevelsMyScene.unity).</param>
 /// <param name="locationPathName">The path where the application will be built.</param>
 /// <param name="target">The BuildTarget to build.</param>
 /// <param name="options">Additional BuildOptions, like whether to run the built player.</param>
 /// <returns>
 ///   <para>An error message if an error occurred.</para>
 /// </returns>
 public static string BuildPlayer(string[] levels, string locationPathName, BuildTarget target, BuildOptions options)
 {
   try
   {
     uint crc;
     return BuildPipeline.BuildPlayerInternal(levels, locationPathName, target, options, out crc);
   }
   catch (Exception ex)
   {
     BuildPipeline.LogBuildExceptionAndExit("BuildPipeline.BuildPlayer", ex);
     return string.Empty;
   }
 }

    public static void BuildProject(BuildOptions _buildOption)
    {
        string[] activeScenes = GetActiveScenes();

        // get productName
        string productName = PlayerSettings.productName;
        string dateTimeNow = DateTime.Now.ToString("MM-dd-yy_HHmm");
        string buildName = productName + "_" + dateTimeNow;

        if ((productName.IndexOf("_") != -1))
        {
            productName = productName.Substring(productName.IndexOf("_") + 1);
        }

        // save location
        CreatFolder(Application.dataPath + "/../Builds/" + buildName);

        // get path from save panel
        path = EditorUtility.SaveFilePanel("Build", "Builds/" + buildName, buildName, "exe");

        if (string.Compare(path, "") != 0)
        {
            // hold file extensions
            string tail = "";
            // add .exe if needed
            tail = path.Substring(Math.Max(0, path.Length - 4));
            if (string.Compare(tail, ".exe") != 0)
            {
                path += ".exe";
            }

            UpdateVersionNumber();

            if (copyConfig){
                CopyAssets(configAssetPath, configBuildPath);
            }
            
            if(copyBatch){
                CopyBatch(batchAssetPath, batchBuildPath + buildName, buildName);
            }

            // build
            BuildPipeline.BuildPlayer(activeScenes, path, EditorUserBuildSettings.activeBuildTarget,
                                      BuildOptions.ShowBuiltPlayer | _buildOption);
        }
        else
        {
            Debug.Log("Failed to Build: Missing build name or file path");
        }
    }