Neg_Utils/Editor/BuildingUtils.cs

using System.Diagnostics;
using System.Linq;
using UnityEngine;
using UnityEditor;
using UnityEditor.Build.Player;
using Debug = UnityEngine.Debug;

public static class BuildingUtils
{
    private const string SteamBuildDefine = "STEAM_BUILD";

    [MenuItem("Tools/PrepareForBuild", priority = -10)]
    public static void PrepareForBuild()
    {
        var namedBuildTarget = UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(
            BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget));
        var args = PlayerSettings.GetAdditionalCompilerArguments(namedBuildTarget);
        var argsList = args.ToList();
        argsList.Remove(SteamBuildDefine);
        PlayerSettings.SetScriptingDefineSymbols(namedBuildTarget, argsList.ToArray());
    }
    
    [MenuItem("Tools/PlatformDefines/Steam", priority = -1)]
    public static void SetDefinesForSteam()
    {
        PrepareForBuild();
        
        var namedBuildTarget = UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(
            BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget));
        var args = PlayerSettings.GetAdditionalCompilerArguments(namedBuildTarget);
        var argsList = args.ToList();
        argsList.Add(SteamBuildDefine);
        PlayerSettings.SetScriptingDefineSymbols(namedBuildTarget, argsList.ToArray());
    }
    
    
    [MenuItem("Tools/Build/Steam/Release")]
    public static void SteamRelease()
    {
        if(!CanBuild())
            return;

        IncreaseBuildNumber();
        BuildRelease();
        UploadSteam();
    }

    [MenuItem("Tools/Build/Steam/Development")]
    public static void SteamDevelopment()
    {
        if(!CanBuild())
            return;
        
        IncreaseBuildNumber();
        BuildDevelopment();
        UploadSteam();
    }


    [MenuItem("Tools/Build/All Release")]
    public static void BuildRelease()
    {
        if(!CanBuild())
            return;
        BuildWindowsRelease();
    }

    [MenuItem("Tools/Build/All Development")]
    public static void BuildDevelopment()
    {
        if(!CanBuild())
            return;
        BuildWindowsDevelopment();
    }

    [MenuItem("Tools/Build/Platform/Windows/x64-Development")]
    public static void BuildWindowsDevelopment()
    {
        if(!CanBuild())
            return;
        BuildWindows(false);
    }

    [MenuItem("Tools/Build/Platform/Windows/x64-Release")]
    public static void BuildWindowsRelease()
    {
        if(!CanBuild())
            return;
        BuildWindows(true);
    }

    [MenuItem("Tools/Build/Platform/Android/GooglePlay")]
    public static void BuildGooglePlay()
    {
        IncreaseBuildNumber();
        PlayerSettings.Android.bundleVersionCode++;
        EditorUserBuildSettings.buildAppBundle = true;
        
        var buildPlayerOptions = new BuildPlayerOptions { scenes = new string[EditorBuildSettings.scenes.Length] };
        for (int i = 0; i < EditorBuildSettings.scenes.Length; i++)
        {
            buildPlayerOptions.scenes[i] = EditorBuildSettings.scenes[i].path;
        }
        
        buildPlayerOptions.target = BuildTarget.Android;
        buildPlayerOptions.options = BuildOptions.None;
        buildPlayerOptions.locationPathName = Application.dataPath +
                                              $"/../../{Application.productName}-GooglePlay/{Application.productName}.aab";
        BuildPipeline.BuildPlayer(buildPlayerOptions);
    }

    private static void BuildWindows(bool release)
    {
        var buildPlayerOptions = new BuildPlayerOptions { scenes = new string[EditorBuildSettings.scenes.Length] };
        for (int i = 0; i < EditorBuildSettings.scenes.Length; i++)
        {
            buildPlayerOptions.scenes[i] = EditorBuildSettings.scenes[i].path;
        }

        buildPlayerOptions.target = BuildTarget.StandaloneWindows64;
        buildPlayerOptions.options = release ? BuildOptions.None : BuildOptions.Development;
        buildPlayerOptions.locationPathName = Application.dataPath +
                                              $"/../../{Application.productName}-Steam/ContentBuilder/content/windows/{Application.productName}.exe";
        BuildPipeline.BuildPlayer(buildPlayerOptions);
    }

    private static void IncreaseBuildNumber()
    {
        string[] versionParts  = PlayerSettings.bundleVersion.Split('.');
        if (versionParts.Length != 3 || !int.TryParse(versionParts[2], out int version)) {
            Debug.LogError("IncreaseBuildNumber failed to update version " + PlayerSettings.bundleVersion);
            return;
        }
        versionParts[2] = (version + 1).ToString();
        PlayerSettings.bundleVersion = string.Join(".", versionParts);
    }

    private static void UploadSteam()
    {
        string command = $"cd {Application.dataPath}/../../{Application.productName}-Steam/ContentBuilder && run_build.bat";

        var processInfo = new ProcessStartInfo("cmd.exe", $"/c {command}")
            { 
                CreateNoWindow = true,
                UseShellExecute = false
            };
        var process = Process.Start(processInfo);
        process.WaitForExit();
        Debug.Log(process.ExitCode);
        process.Close();
    }

    private static bool CanBuild()
    {
        if (CanBuildUtil())
            return true;
        Debug.LogError("Cannot build with defines set in project, please use PrepareForBuild and wait for scripts recompilation");
        return false;
    }

    private static bool CanBuildUtil()
    {
        var namedBuildTarget = UnityEditor.Build.NamedBuildTarget.FromBuildTargetGroup(
            BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget));
        var args = PlayerSettings.GetAdditionalCompilerArguments(namedBuildTarget);
        var argsList = args.ToList();
        
        if (argsList.Contains(SteamBuildDefine))
            return false;

        return true;
    }
}