static void PushGithub(BuildManagerSettings settings, BuildSequence sequence, BuildData data)
    {
        StringBuilder fileName = new StringBuilder(128);
        StringBuilder args     = new StringBuilder(128);

        string githubReleaseExe = Application.dataPath + "/" + githubReleasesRelativePath;

        fileName.Append(githubReleaseExe);

        args.Append(" upload ");
        args.Append($"--security-token \"{settings.GithubToken}\" ");
        args.Append($"--user {settings.githubUserName} ");
        args.Append($"--auth-user {settings.githubUserName} ");
        args.Append($"--repo {settings.githubRepoName} ");
        args.Append($"--tag v{PlayerSettings.bundleVersion} ");
        args.Append($"--name \"{GetPathWithVars(data, data.dirPathForPostProcess)}\" ");            //download file name
        args.Append($"--label \"{GetPathWithVars(data, data.dirPathForPostProcess)}\" ");           //name in releases
        args.Append($"--file  \"{Path.Combine(Application.dataPath, "..", data.outputRoot, GetPathWithVarsForZip(data, data.dirPathForPostProcess)).Replace("\\", "/")}\" ");
        args.Append($"--replace ");

        Debug.Log(fileName.ToString() + args.ToString());

        ProcessStartInfo info = new ProcessStartInfo(fileName.ToString(), args.ToString())
        {
            UseShellExecute        = false,
            RedirectStandardOutput = true,
            RedirectStandardError  = true
        };

        Process.Start(info);
    }
    public static void RunBuildSequnce(BuildManagerSettings settings, BuildSequence sequence, ChangelogData changelog)
    {
        // Start init
        usedChangelog = changelog;
        ChangelogData.ChangelogVersionEntry usedChangelogEntry = changelog.GetLastVersion();
        buildNameString = usedChangelogEntry.GetVersionHeader();

#if GAME_TEMPLATE
        TemplateGameManager.Instance.buildNameString = buildNameString;
        TemplateGameManager.Instance.productName     = PlayerSettings.productName;
        EditorUtility.SetDirty(TemplateGameManager.Instance);
#endif
        usedDate = DateTime.Now;
        //End init

        Debug.Log("Start building all");
        DateTime startTime = DateTime.Now;

        //Crete release here, because build's not get pushed
        CreateGitHubReleaseIfNeeded(settings, sequence);

        Build(settings, sequence);
        PostBuild(sequence);

        Compress(sequence);

        ItchioPush(settings, sequence, changelog);
        GithubPush(settings, sequence, changelog);

        Debug.Log($"End building all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");

#if UNITY_EDITOR_WIN
        ShowExplorer(sequence.builds[sequence.builds.Count - 1].outputRoot);
#endif
    }
    static void PushItch(BuildManagerSettings settings, BuildSequence sequence, BuildData data)
    {
        StringBuilder fileName = new StringBuilder(128);
        StringBuilder args     = new StringBuilder(128);


        string butlerPath = Application.dataPath + "/" + butlerRelativePath;

        if (!File.Exists(butlerPath))
        {
            Debug.LogWarning("Butler not found.");
            DownloadButler();
        }

        fileName.Append(butlerPath);

        args.Append(" push \"");
        args.Append(Application.dataPath);
        args.Append("/../");
        args.Append(data.outputRoot + GetPathWithVars(data, data.dirPathForPostProcess));
        args.Append("\" ");

        args.Append($"{settings.itchGameLink}:{data.itchChannel} ");
        args.Append($"--userversion \"{buildNameString}\" ");

        Debug.Log(fileName.ToString() + args.ToString());
        Process.Start(fileName.ToString(), args.ToString());
    }
    void DrawSequenceList()
    {
        if (sequenceList == null)
        {
            PredefinedBuildConfigs.Init();
            sequenceList = BuildSequenceReordableList.Create(settings.sequences, OnSequenceAdd, "Builds sequences");
            sequenceList.onSelectCallback += OnSequenceSelectionChanged;
            sequenceList.index             = 0;
        }

        sequenceList.DoLayoutList();

        if (0 <= sequenceList.index && sequenceList.index < sequenceList.count)
        {
            BuildSequence selected = settings.sequences[sequenceList.index];

            EditorGUILayout.BeginHorizontal();
            selected.scriptingDefineSymbolsOverride = EditorGUILayout.TextField("Defines sequence override", selected.scriptingDefineSymbolsOverride);
            if (GUILayout.Button($"Set defines", GUILayout.Width(100f)))
            {
                PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget), string.Concat(settings.scriptingDefineSymbols, ";", selected.scriptingDefineSymbolsOverride));
            }
            EditorGUILayout.EndHorizontal();
        }
    }
    static void Compress(BuildSequence sequence)
    {
        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].needZip || !sequence.builds[i].isEnabled)
            {
                continue;
            }

            if (sequence.builds[i].target == BuildTarget.Android)
            {
                Debug.Log("Skip android build to .zip, because .apk files already compressed");
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                BaseCompress(sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].dirPathForPostProcess));
            }
            else
            {
                Debug.LogWarning($"[Compressing] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }
    }
    static void ItchioPush(BuildManagerSettings settings, BuildSequence sequence, ChangelogData changelog)
    {
        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].isEnabled || !sequence.builds[i].needItchPush)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (string.IsNullOrEmpty(settings.itchGameLink))
                {
                    Debug.LogWarning($"Can't push itch.io. Required data is missing");
                    return;
                }

                PushItch(settings, sequence, sequence.builds[i]);
            }
            else
            {
                Debug.LogWarning($"[Itch.io push] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }
    }
Beispiel #7
0
    public static void RunBuildSequnce(BuildManagerSettings settings, BuildSequence sequence, ChangelogData changelog)
    {
        // Start init
        buildNameString = $"{PlayerSettings.bundleVersion} - {changelog.updateName}";
#if GAME_TEMPLATE
        TemplateGameManager.InstanceEditor.buildNameString = buildNameString;
        TemplateGameManager.InstanceEditor.productName     = PlayerSettings.productName;
#endif
        usedDate = DateTime.Now;
        //End init

        Debug.Log("Start building all");
        DateTime startTime = DateTime.Now;

        Build(settings, sequence);
        PostBuild(sequence);
        Compress(sequence);
        ItchioPush(sequence, changelog);

        Debug.Log($"End building all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");

#if UNITY_EDITOR_WIN
        ShowExplorer(sequence.builds[sequence.builds.Count - 1].outputRoot);
#endif
    }
    static void GithubPush(BuildManagerSettings settings, BuildSequence sequence, ChangelogData changelog)
    {
        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].isEnabled || !sequence.builds[i].needGithubPush)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (string.IsNullOrEmpty(settings.GithubToken) || string.IsNullOrEmpty(settings.githubUserName) || string.IsNullOrEmpty(settings.githubRepoName))
                {
                    Debug.LogWarning($"Can't push github release. Required data is missing");
                    return;
                }

                PushGithub(settings, sequence, sequence.builds[i]);
            }
            else
            {
                Debug.LogWarning($"[GitHub push] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }
    }
Beispiel #9
0
    public static void PushItch(BuildSequence sequence, BuildData data)
    {
        StringBuilder fileName = new StringBuilder(128);
        StringBuilder args     = new StringBuilder(128);

        fileName.Append(Application.dataPath);
        fileName.Append("/");
        fileName.Append(butlerRelativePath);

        args.Append(" push \"");
        args.Append(Application.dataPath);
        args.Append("/../");
        args.Append(data.outputRoot + GetPathWithVars(data, data.itchDirPath));
        args.Append("\" ");

        args.Append($"{sequence.itchGameLink}:{data.itchChannel} ");
        if (data.itchAddLastChangelogUpdateNameToVerison && !string.IsNullOrEmpty(data.itchLastChangelogUpdateName))
        {
            args.Append($"--userversion \"{data.itchLastChangelogUpdateName}\" ");
        }
        else
        {
            args.Append($"--userversion \"{PlayerSettings.bundleVersion}\" ");
        }

        Debug.Log(fileName.ToString() + args.ToString());
        Process.Start(fileName.ToString(), args.ToString());
    }
Beispiel #10
0
    public static void RunBuildSequnce(BuildSequence sequence)
    {
        Debug.Log("Start building all");
        DateTime         startTime              = DateTime.Now;
        BuildTarget      targetBeforeStart      = EditorUserBuildSettings.activeBuildTarget;
        BuildTargetGroup targetGroupBeforeStart = BuildPipeline.GetBuildTargetGroup(targetBeforeStart);

        string[] buildsPath = new string[sequence.builds.Length];
        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            BuildData data = sequence.builds[i];
            buildsPath[i] = BaseBuild(data.targetGroup, data.target, data.options, data.outputRoot + GetPathWithVars(data, data.middlePath));
        }

        EditorUserBuildSettings.SwitchActiveBuildTarget(targetGroupBeforeStart, targetBeforeStart);
        Debug.Log($"End building all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");

        startTime = DateTime.Now;
        Debug.Log($"Start compressing all");

        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            if (!sequence.builds[i].needZip)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                BaseCompress(sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].compressDirPath));
            }
            else
            {
                Debug.LogWarning($"[Compressing] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }

        Debug.Log($"End compressing all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");


        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            if (!sequence.builds[i].needItchPush)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                PushItch(sequence, sequence.builds[i]);
            }
            else
            {
                Debug.LogWarning($"[Itch.io push] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }
    }
Beispiel #11
0
    public object Clone()
    {
        BuildSequence sequence = this.MemberwiseClone() as BuildSequence;

        sequence.builds = new List <BuildData>(builds.Count);
        for (int i = 0; i < builds.Count; ++i)
        {
            sequence.builds.Add(builds[i].Clone() as BuildData);
        }

        return(sequence);
    }
Beispiel #12
0
    void Start()
    {
        buildSequence = new BuildSequence(gridSize, seedPosition, brickImportData);

        CreateBricks();
        CreateGridLines();
        UpdateCellDisplay();

        Button completePathButton   = completePath.GetComponent <Button>();
        Button generateBricksButton = generateBricks.GetComponent <Button>();
        Button reorderExportButton  = reorderExport.GetComponent <Button>();

        completePathButton.onClick.AddListener(CompletePath);
        generateBricksButton.onClick.AddListener(GenerateBricks);
        reorderExportButton.onClick.AddListener(ReorderExport);
    }
    static void FillReleaseSequence(ref List <BuildData> dataOriginal, ref List <BuildData> data)
    {
        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            dataOriginal[i].outputRoot += "Releases/";
        }

        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            data.Add(dataOriginal[i].Clone() as BuildData);
            data[i].isReleaseBuild = true;
        }
        releaseLocalSequence = new BuildSequence("Release", data.ToArray());
        data.Clear();

        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            data.Add(dataOriginal[i].Clone() as BuildData);
            data[i].isReleaseBuild = true;
            data[i].needZip        = true;
        }
        releaseLocalZipSequence = new BuildSequence("Release + zip", data.ToArray());
        data.Clear();

        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            data.Add(dataOriginal[i].Clone() as BuildData);
            data[i].isReleaseBuild = true;
            data[i].needZip        = true;
            data[i].needItchPush   = true;
            data[i].needGithubPush = true;
        }
        releaseFullSequence = new BuildSequence("Release full", data.ToArray());
        data.Clear();

        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            data.Add(dataOriginal[i].Clone() as BuildData);
            data[i].isReleaseBuild = true;
            data[i].isPassbyBuild  = true;
            data[i].needZip        = true;
            data[i].needItchPush   = true;
            data[i].needGithubPush = true;
        }
        passbySequence = new BuildSequence("Passby local release", data.ToArray());
        data.Clear();
    }
Beispiel #14
0
    void DrawBuildButtons()
    {
        if ((settings?.sequences?.Count ?? 0) != 0)
        {
            int enabledSequence = 0;
            foreach (var sequence in settings.sequences)
            {
                if (sequence.isEnabled)
                {
                    ++enabledSequence;
                }
            }

            if (enabledSequence == 0)
            {
                return;
            }

            EditorGUILayout.Space(20);
            Color prevColor = GUI.backgroundColor;
            GUI.backgroundColor = new Color(0.773f, 0.345098f, 0.345098f);

            EditorGUILayout.LabelField("Start build sequence(they red not becouse error, but becouse build stuck your pc if you accidentaly press it)");
            EditorGUILayout.LabelField("Don't forget to manually download new version of polyglot localization if you want to update it");

            EditorGUILayout.BeginHorizontal();
            for (int i = 0; i < settings.sequences.Count; ++i)
            {
                BuildSequence sequence = settings.sequences[i];

                if (i != 0 && i % 3 == 0)
                {
                    EditorGUILayout.EndHorizontal();
                    EditorGUILayout.BeginHorizontal();
                }

                if (sequence.isEnabled && GUILayout.Button($"Build {sequence.editorName}"))
                {
                    BuildManager.RunBuildSequnce(settings, sequence, changelog);
                }
            }
            EditorGUILayout.EndHorizontal();

            GUI.backgroundColor = prevColor;
        }
    }
Beispiel #15
0
    static void PostBuild(BuildSequence sequence)
    {
        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].isEnabled)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (sequence.builds[i].isReleaseBuild)                    //Destroy IL2CPP junk after build
                {
                    string   buildRootPath = Path.GetDirectoryName(buildsPath[i]);
                    string[] dirs          = Directory.GetDirectories(buildRootPath);
                    var      il2cppDirs    = dirs.Where(s => s.Contains("BackUpThisFolder_ButDontShipItWithYourGame"));
                    foreach (var dir in il2cppDirs)
                    {
                        Directory.Delete(dir, true);
                    }
                }

#if UNITY_EDITOR_WIN
                //https://forum.unity.com/threads/mac-unity-build-from-a-pc-not-opening-on-mac.947727/
                //Use git bash to execute this command
                if (sequence.builds[i].target == BuildTarget.StandaloneOSX)
                {
                    Debug.Log($"chmod -R 777 {sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].middlePath)}.app");

                    Process process = new Process()
                    {
                        StartInfo = new ProcessStartInfo {
                            WindowStyle = ProcessWindowStyle.Hidden,
                            FileName    = "cmd.exe",
                            Arguments   = $"start \"\" \" %PROGRAMFILES%\\Git\\bin\\sh.exe\" --chmod -R 777 {sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].middlePath)}.app",
                        },
                    };
                    process.Start();
                }
#endif
            }
        }
    }
    static void CreateGitHubReleaseIfNeeded(BuildManagerSettings settings, BuildSequence sequence)
    {
        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].isEnabled || !sequence.builds[i].needGithubPush)
            {
                continue;
            }

            if (string.IsNullOrEmpty(settings.GithubToken) || string.IsNullOrEmpty(settings.githubUserName) || string.IsNullOrEmpty(settings.githubRepoName))
            {
                Debug.LogWarning($"Can't create github release. Required data is missing");
                return;
            }

            CreateGitHubRelease(settings);
            break;
        }
    }
    static void FillTestingSequence(ref List <BuildData> dataOriginal, ref List <BuildData> data)
    {
        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            data.Add(dataOriginal[i].Clone() as BuildData);
            data[i].middlePath            = data[i].middlePath.Replace("_$VERSION", "");
            data[i].dirPathForPostProcess = data[i].dirPathForPostProcess.Replace("_$VERSION", "");
        }
        testingSequence = new BuildSequence("Testing", data.ToArray());
        data.Clear();

        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            data.Add(dataOriginal[i].Clone() as BuildData);
            data[i].needZip               = true;
            data[i].middlePath            = data[i].middlePath.Replace("_$VERSION", "");
            data[i].dirPathForPostProcess = data[i].dirPathForPostProcess.Replace("_$VERSION", "");
        }
        testingSequenceZip = new BuildSequence("Testing + zip", data.ToArray());
        data.Clear();
    }
Beispiel #18
0
    public static void PushItch(BuildSequence sequence, BuildData data)
    {
        StringBuilder fileName = new StringBuilder(128);
        StringBuilder args     = new StringBuilder(128);

        fileName.Append(Application.dataPath);
        fileName.Append("/");
        fileName.Append(butlerRelativePath);

        args.Append(" push \"");
        args.Append(Application.dataPath);
        args.Append("/../");
        args.Append(data.outputRoot + GetPathWithVars(data, data.itchDirPath));
        args.Append("\" ");

        args.Append($"{sequence.itchGameLink}:{data.itchChannel} ");
        args.Append($"--userversion {PlayerSettings.bundleVersion} ");

        Debug.Log(fileName.ToString() + args.ToString());
        Process.Start(fileName.ToString(), args.ToString());
    }
Beispiel #19
0
    static void ItchioPush(BuildSequence sequence, ChangelogData changelog)
    {
        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].needItchPush || !sequence.builds[i].isEnabled)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (sequence.builds[i].itchAddLastChangelogUpdateNameToVerison && !string.IsNullOrEmpty(changelog?.updateName))
                {
                    sequence.builds[i].itchLastChangelogUpdateName = buildNameString;
                }
                PushItch(sequence, sequence.builds[i]);
            }
            else
            {
                Debug.LogWarning($"[Itch.io push] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }
    }
Beispiel #20
0
    static void FillTestingSequence(ref List <BuildData> dataOriginal, ref List <BuildData> data)
    {
        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            data.Add(dataOriginal[i].Clone() as BuildData);
            data[i].middlePath      = data[i].middlePath.Replace("_$VERSION", "");
            data[i].compressDirPath = data[i].compressDirPath.Replace("_$VERSION", "");
            data[i].itchDirPath     = data[i].itchDirPath.Replace("_$VERSION", "");
        }
        testingSequence = new BuildSequence("Testing", $"teamon/{BuildManager.GetProductName()}", data.ToArray());
        data.Clear();

        for (int i = 0; i < dataOriginal.Count; ++i)
        {
            data.Add(dataOriginal[i].Clone() as BuildData);
            data[i].needZip         = true;
            data[i].middlePath      = data[i].middlePath.Replace("_$VERSION", "");
            data[i].compressDirPath = data[i].compressDirPath.Replace("_$VERSION", "");
            data[i].itchDirPath     = data[i].itchDirPath.Replace("_$VERSION", "");
        }
        testingSequenceZip = new BuildSequence("Testing + zip", $"teamon/{BuildManager.GetProductName()}", data.ToArray());
        data.Clear();
    }
    static void Build(BuildManagerSettings settings, BuildSequence sequence)
    {
        BuildTarget      targetBeforeStart      = EditorUserBuildSettings.activeBuildTarget;
        BuildTargetGroup targetGroupBeforeStart = BuildPipeline.GetBuildTargetGroup(targetBeforeStart);
        string           definesBeforeStart     = PlayerSettings.GetScriptingDefineSymbolsForGroup(targetGroupBeforeStart);
        bool             isVRSupported          = PlayerSettings.virtualRealitySupported; //TODO: PlayerSettings.virtualRealitySupported is deprecated. Replace with smth new

        buildsPath = new string[sequence.builds.Count];
        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            BuildData data = sequence.builds[i];

            if (!data.isEnabled)
            {
                continue;
            }

            if (PlayerSettings.virtualRealitySupported != data.isVirtualRealitySupported)
            {
                PlayerSettings.virtualRealitySupported = data.isVirtualRealitySupported;
            }

            buildsPath[i] = BaseBuild(
                data.targetGroup,
                data.target,
                data.options,
                data.outputRoot + GetPathWithVars(data, data.middlePath),
                string.Concat(settings.scriptingDefineSymbols, ";", sequence.scriptingDefineSymbolsOverride, ";", data.scriptingDefineSymbolsOverride),
                data.isPassbyBuild,
                data.isReleaseBuild
                );
        }

        EditorUserBuildSettings.SwitchActiveBuildTarget(targetGroupBeforeStart, targetBeforeStart);
        PlayerSettings.SetScriptingDefineSymbolsForGroup(targetGroupBeforeStart, definesBeforeStart);
        PlayerSettings.virtualRealitySupported = isVRSupported;
    }
    public static void RunBuildSequnce(BuildManagerSettings settings, BuildSequence sequence, ChangelogData changelog)
    {
        // Start init
        string buildNameString = $"{PlayerSettings.bundleVersion} - {changelog.updateName}";

#if GAME_TEMPLATE
        TemplateGameManager.InstanceEditor.buildNameString = buildNameString;
        TemplateGameManager.InstanceEditor.productName     = PlayerSettings.productName;
#endif
        usedDate = DateTime.Now;
        //End init

        Debug.Log("Start building all");
        DateTime         startTime              = DateTime.Now;
        BuildTarget      targetBeforeStart      = EditorUserBuildSettings.activeBuildTarget;
        BuildTargetGroup targetGroupBeforeStart = BuildPipeline.GetBuildTargetGroup(targetBeforeStart);
        string           definesBeforeStart     = PlayerSettings.GetScriptingDefineSymbolsForGroup(targetGroupBeforeStart);
        bool             isVRSupported          = PlayerSettings.virtualRealitySupported; //TODO: PlayerSettings.virtualRealitySupported is deprecated. Replace with smth new

        string[] buildsPath = new string[sequence.builds.Count];
        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            BuildData data = sequence.builds[i];

            if (!data.isEnabled)
            {
                continue;
            }

            if (PlayerSettings.virtualRealitySupported != data.isVirtualRealitySupported)
            {
                PlayerSettings.virtualRealitySupported = data.isVirtualRealitySupported;
            }

            buildsPath[i] = BaseBuild(
                data.targetGroup,
                data.target,
                data.options,
                data.outputRoot + GetPathWithVars(data, data.middlePath),
                string.Concat(settings.scriptingDefineSymbols, ";", sequence.scriptingDefineSymbolsOverride, ";", data.scriptingDefineSymbolsOverride),
                data.isPassbyBuild,
                data.isReleaseBuild
                );
        }

        EditorUserBuildSettings.SwitchActiveBuildTarget(targetGroupBeforeStart, targetBeforeStart);
        PlayerSettings.SetScriptingDefineSymbolsForGroup(targetGroupBeforeStart, definesBeforeStart);
        PlayerSettings.virtualRealitySupported = isVRSupported;
        Debug.Log($"End building all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");

        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].needZip || !sequence.builds[i].isEnabled)
            {
                continue;
            }

            if (sequence.builds[i].target == BuildTarget.Android)
            {
                Debug.Log("Skip android build to .zip, because .apk files already compressed");
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (sequence.builds[i].isReleaseBuild)                    //Destroy IL2CPP junk after build
                {
                    string   buildRootPath = Path.GetDirectoryName(buildsPath[i]);
                    string[] dirs          = Directory.GetDirectories(buildRootPath);
                    var      il2cppDirs    = dirs.Where(s => s.Contains("BackUpThisFolder_ButDontShipItWithYourGame"));
                    foreach (var dir in il2cppDirs)
                    {
                        Directory.Delete(dir, true);
                    }
                }
            }
        }

        startTime = DateTime.Now;
        Debug.Log($"Start compressing all");

        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].needZip || !sequence.builds[i].isEnabled)
            {
                continue;
            }

            if (sequence.builds[i].target == BuildTarget.Android)
            {
                Debug.Log("Skip android build to .zip, because .apk files already compressed");
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                BaseCompress(sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].compressDirPath));
            }
            else
            {
                Debug.LogWarning($"[Compressing] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }

        Debug.Log($"End compressing all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");


        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].needItchPush || !sequence.builds[i].isEnabled)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (sequence.builds[i].itchAddLastChangelogUpdateNameToVerison && !string.IsNullOrEmpty(changelog?.updateName))
                {
                    sequence.builds[i].itchLastChangelogUpdateName = buildNameString;
                }
                PushItch(sequence, sequence.builds[i]);
            }
            else
            {
                Debug.LogWarning($"[Itch.io push] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }

        ShowExplorer(sequence.builds[sequence.builds.Count - 1].outputRoot);
    }
Beispiel #23
0
    public static void RunBuildSequnce(BuildSequence sequence, ChangelogData changelog)
    {
        // Start init
        GameManager.InstanceEditor.buildNameString = $"{PlayerSettings.bundleVersion} - {changelog.LocalizedUpdate}";
        usedDate = DateTime.Now;
        //End init

        Debug.Log("Start building all");
        DateTime         startTime              = DateTime.Now;
        BuildTarget      targetBeforeStart      = EditorUserBuildSettings.activeBuildTarget;
        BuildTargetGroup targetGroupBeforeStart = BuildPipeline.GetBuildTargetGroup(targetBeforeStart);

        string[] buildsPath = new string[sequence.builds.Length];
        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            BuildData data = sequence.builds[i];
            buildsPath[i] = BaseBuild(data.targetGroup, data.target, data.options, data.outputRoot + GetPathWithVars(data, data.middlePath));
        }

        EditorUserBuildSettings.SwitchActiveBuildTarget(targetGroupBeforeStart, targetBeforeStart);
        Debug.Log($"End building all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");

        startTime = DateTime.Now;
        Debug.Log($"Start compressing all");

        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            if (!sequence.builds[i].needZip)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                BaseCompress(sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].compressDirPath));
            }
            else
            {
                Debug.LogWarning($"[Compressing] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }

        Debug.Log($"End compressing all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");


        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            if (!sequence.builds[i].needItchPush)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (sequence.builds[i].itchAddLastChangelogUpdateNameToVerison && !string.IsNullOrEmpty(changelog?.LocalizedUpdate))
                {
                    sequence.builds[i].itchLastChangelogUpdateName = GameManager.InstanceEditor.buildNameString;
                }
                PushItch(sequence, sequence.builds[i]);
            }
            else
            {
                Debug.LogWarning($"[Itch.io push] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }
    }
    public static UnityEditorInternal.ReorderableList Create(List <BuildSequence> configsList, GenericMenu.MenuFunction2 menuItemHandler, string header)
    {
        var reorderableList = new UnityEditorInternal.ReorderableList(configsList, typeof(BuildSequence), true, false, true, true);

        reorderableList.elementHeight       = EditorGUIUtility.singleLineHeight + 4;
        reorderableList.drawHeaderCallback  = (Rect rect) => { EditorGUI.LabelField(rect, header); };
        reorderableList.drawElementCallback = (position, index, isActive, isFocused) => {
            const float enabledWidth      = 15f;
            const float space             = 10f;
            const float minNameWidth      = 100f;
            const float itchGameLinkWidth = 200;
            const float labelWidth        = 60;

            BuildSequence sequence  = configsList[index];
            var           nameWidth = position.width - space * 5 - enabledWidth - itchGameLinkWidth - labelWidth;
            if (nameWidth < minNameWidth)
            {
                nameWidth = minNameWidth;
            }

            position.y      += 2;
            position.height -= 4;

            position.x        += space;
            position.width     = enabledWidth;
            sequence.isEnabled = EditorGUI.Toggle(position, sequence.isEnabled);
            EditorGUI.BeginDisabledGroup(!sequence.isEnabled);

            position.x         += position.width + space;
            position.width      = nameWidth;
            sequence.editorName = EditorGUI.TextField(position, sequence.editorName);

            position.x    += position.width + space;
            position.width = labelWidth;
            EditorGUI.LabelField(position, "Itch.io link");

            position.x           += position.width + space;
            position.width        = itchGameLinkWidth;
            sequence.itchGameLink = EditorGUI.TextField(position, sequence.itchGameLink);

            EditorGUI.EndDisabledGroup();
        };

        reorderableList.onAddDropdownCallback = (buttonRect, list) => {
            var menu = new GenericMenu();

            menu.AddItem(new GUIContent("Custom"), false, menuItemHandler, new BuildSequence("Custom", $"teamon/{BuildManager.GetProductName()}", new BuildData()));
            menu.AddSeparator("");

            string label = $"{PredefinedBuildConfigs.testingSequence.editorName}";
            menu.AddItem(new GUIContent(label), false, menuItemHandler, PredefinedBuildConfigs.testingSequence);

            label = $"{PredefinedBuildConfigs.testingSequenceZip.editorName}";
            menu.AddItem(new GUIContent(label), false, menuItemHandler, PredefinedBuildConfigs.testingSequenceZip);


            menu.AddSeparator("");
            label = $"{PredefinedBuildConfigs.releaseLocalSequence.editorName}";
            menu.AddItem(new GUIContent(label), false, menuItemHandler, PredefinedBuildConfigs.releaseLocalSequence);

            label = $"{PredefinedBuildConfigs.releaseLocalZipSequence.editorName}";
            menu.AddItem(new GUIContent(label), false, menuItemHandler, PredefinedBuildConfigs.releaseLocalZipSequence);

            label = $"{PredefinedBuildConfigs.releaseLocalZipItchSequence.editorName}";
            menu.AddItem(new GUIContent(label), false, menuItemHandler, PredefinedBuildConfigs.releaseLocalZipItchSequence);


            menu.AddSeparator("");
            label = $"{PredefinedBuildConfigs.passbySequence.editorName}";
            menu.AddItem(new GUIContent(label), false, menuItemHandler, PredefinedBuildConfigs.passbySequence);


            menu.ShowAsContext();
        };

        return(reorderableList);
    }
    public static void RunBuildSequnce(BuildSequence sequence, ChangelogData changelog)
    {
        // Start init
        TemplateGameManager.InstanceEditor.buildNameString = $"{PlayerSettings.bundleVersion} - {changelog.updateName}";
        usedDate = DateTime.Now;
        //End init

        Debug.Log("Start building all");
        DateTime         startTime              = DateTime.Now;
        BuildTarget      targetBeforeStart      = EditorUserBuildSettings.activeBuildTarget;
        BuildTargetGroup targetGroupBeforeStart = BuildPipeline.GetBuildTargetGroup(targetBeforeStart);
        string           definesBeforeStart     = PlayerSettings.GetScriptingDefineSymbolsForGroup(targetGroupBeforeStart);
        bool             isVRSupported          = PlayerSettings.virtualRealitySupported; //TODO: PlayerSettings.virtualRealitySupported is deprecated. Replace with smth new

        string[] buildsPath = new string[sequence.builds.Length];
        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            BuildData data = sequence.builds[i];

            if (PlayerSettings.virtualRealitySupported != data.isVirtualRealitySupported)
            {
                PlayerSettings.virtualRealitySupported = data.isVirtualRealitySupported;
            }

            buildsPath[i] = BaseBuild(data.targetGroup, data.target, data.options, data.outputRoot + GetPathWithVars(data, data.middlePath), data.scriptingDefinySymbols, data.isPassbyBuild);
        }

        EditorUserBuildSettings.SwitchActiveBuildTarget(targetGroupBeforeStart, targetBeforeStart);
        PlayerSettings.SetScriptingDefineSymbolsForGroup(targetGroupBeforeStart, definesBeforeStart);
        PlayerSettings.virtualRealitySupported = isVRSupported;
        Debug.Log($"End building all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");

        startTime = DateTime.Now;
        Debug.Log($"Start compressing all");

        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            if (!sequence.builds[i].needZip)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                BaseCompress(sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].compressDirPath));
            }
            else
            {
                Debug.LogWarning($"[Compressing] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }

        Debug.Log($"End compressing all. Elapsed time: {string.Format("{0:mm\\:ss}", DateTime.Now - startTime)}");


        for (byte i = 0; i < sequence.builds.Length; ++i)
        {
            if (!sequence.builds[i].needItchPush)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (sequence.builds[i].itchAddLastChangelogUpdateNameToVerison && !string.IsNullOrEmpty(changelog?.updateName))
                {
                    sequence.builds[i].itchLastChangelogUpdateName = TemplateGameManager.InstanceEditor.buildNameString;
                }
                PushItch(sequence, sequence.builds[i]);
            }
            else
            {
                Debug.LogWarning($"[Itch.io push] Can't find build for {GetBuildTargetExecutable(sequence.builds[i].target)}");
            }
        }
    }
 static void OnSequenceSelectionChanged(BuildSequence sequence)
 {
     buidsList.Init(sequence.builds, "Builds", FormBuildNameInList);
 }
    static void PostBuild(BuildSequence sequence)
    {
        bool   isNeedChangelogFile = usedChangelog.versions.Count != 0;
        bool   isNeedReadmeFile    = !string.IsNullOrEmpty(usedChangelog.readme);
        string changelogContent    = "";
        string readmeContent       = usedChangelog.readme;

        bool isAnyReleaseBuild = false;

        if (isNeedChangelogFile)
        {
            changelogContent = usedChangelog.GetChangelogString();
        }

        for (byte i = 0; i < sequence.builds.Count; ++i)
        {
            if (!sequence.builds[i].isEnabled)
            {
                continue;
            }

            if (!string.IsNullOrEmpty(buildsPath[i]))
            {
                if (sequence.builds[i].isReleaseBuild)                    //Destroy IL2CPP junk after build
                {
                    isAnyReleaseBuild = true;

                    string   buildRootPath = Path.GetDirectoryName(buildsPath[i]);
                    string[] dirs          = Directory.GetDirectories(buildRootPath);
                    var      il2cppDirs    = dirs.Where(s => s.Contains("BackUpThisFolder_ButDontShipItWithYourGame"));
                    foreach (var dir in il2cppDirs)
                    {
                        Directory.Delete(dir, true);
                    }
                }

#if UNITY_EDITOR_WIN
                //https://forum.unity.com/threads/mac-unity-build-from-a-pc-not-opening-on-mac.947727/
                //Use git bash to execute this command
                if (sequence.builds[i].target == BuildTarget.StandaloneOSX)
                {
                    Debug.Log($"chmod -R 777 {sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].middlePath)}.app");

                    Process process = new Process()
                    {
                        StartInfo = new ProcessStartInfo {
                            WindowStyle = ProcessWindowStyle.Hidden,
                            FileName    = "cmd.exe",
                            Arguments   = $"start \"\" \" %PROGRAMFILES%\\Git\\bin\\sh.exe\" --chmod -R 777 {sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].middlePath)}.app",
                        },
                    };
                    process.Start();
                }
#endif

                if (sequence.builds[i].targetGroup == BuildTargetGroup.Standalone)
                {
                    string path = Path.Combine(sequence.builds[i].outputRoot + GetPathWithVars(sequence.builds[i], sequence.builds[i].middlePath)).Replace(@"/", @"\");
                    path = path.Substring(0, path.LastIndexOf("\\"));

                    if (isNeedChangelogFile)
                    {
                        File.WriteAllText(
                            Path.Combine(path, "Changelog.txt"),
                            changelogContent
                            );
                    }

                    if (isNeedReadmeFile)
                    {
                        File.WriteAllText(
                            Path.Combine(path, "Readme.txt"),
                            readmeContent
                            );
                    }
                }
            }
        }

        if (isAnyReleaseBuild)
        {
            string gitRootPath = Path.Combine(Application.dataPath, "..");

            if (!Directory.Exists(Path.Combine(gitRootPath, ".git")))
            {
                gitRootPath = Path.Combine(gitRootPath, "..");

                if (!Directory.Exists(Path.Combine(gitRootPath, ".git")))
                {
                    gitRootPath = null;
                }
            }

            if (gitRootPath != null)
            {
                if (isNeedChangelogFile)
                {
                    File.WriteAllText(
                        Path.Combine(gitRootPath, "Changelog.md"),
                        changelogContent
                        );
                }

                if (isNeedReadmeFile)
                {
                    File.WriteAllText(
                        Path.Combine(gitRootPath, "ReadmeGame.md"),
                        readmeContent
                        );
                }
            }
        }
    }