[Unity] Editor 拡張を書いてワンクリックでビルドをしよう

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using UnityEditor;
using UnityEditor.AddressableAssets;
using UnityEditor.AddressableAssets.Settings;
using UnityEngine;
using UnityEngine.SceneManagement;
using Debug = UnityEngine.Debug;

public class SampleLauncher : EditorWindow
{
    private const string AppName = "Sample";
    private const string AddressablesProfileName = "Default";

    private bool allowDebugging  ;
    private bool buildAddressableAssets = true;
    private bool connectWithProfiler = true;
    private int processCount = 1;

    private string ExecutablePath
    {
        get
        {
#if UNITY_EDITOR_WIN
            return TargetPath;
#elif UNITY_EDITOR_OSX
            return TargetPath + "/Contents/MacOS/!!!you product name!!!";
#else
            throw new InvalidOperationException("対応していないプラットフォームです");
#endif
        }
    }

    private BuildTarget BuildTarget
    {
        get
        {
#if UNITY_EDITOR_WIN
            return BuildTarget.StandaloneWindows;
#elif UNITY_EDITOR_OSX
            return BuildTarget.StandaloneOSX;
#else
            return BuildTarget.NoTarget;
#endif
        }
    }

    private string ProjectRootPath => Path.GetDirectoryName(Application.dataPath);

    private string TargetPath => BuildPath(BuildTarget);

    private string[] ScenePaths
    {
        get
        {
            var sceneCount = SceneManager.sceneCountInBuildSettings;
            var scenes = new string[sceneCount];
            for (var i = 0; i < sceneCount; i++)
                scenes[i] = SceneUtility.GetScenePathByBuildIndex(i);
            return scenes;
        }
    }

    private BuildOptions BuildOptions
    {
        get
        {
            var options = BuildOptions.Development;
            if (allowDebugging) options |= BuildOptions.AllowDebugging;
            if (connectWithProfiler) options |= BuildOptions.ConnectWithProfiler;
            return options;
        }
    }

    private BuildPlayerOptions BuildPlayerOptions => new BuildPlayerOptions
    {
        targetGroup = BuildTargetGroupFromBuildTarget(BuildTarget),
        target = BuildTarget,
        locationPathName = TargetPath,
        scenes = ScenePaths,
        options = BuildOptions
    };

    private bool Build()
    {
        // ビルドターゲットを UnityEditorが実行されているプラットフォームへ変更します
        if (!SwitchBuildTarget(BuildTarget))
            return false;

        // AddressableAssets をビルドします
        if (buildAddressableAssets)
            BuildAddressable(AddressablesProfileName);


        return BuildPipeline.BuildPlayer(BuildPlayerOptions);
    }

    private void Run()
    {
        try
        {
            for (var i = 0; i < processCount; i++)
            {
                var proc = new Process
                {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = ExecutablePath,
                        UseShellExecute = false
                    }
                };
                proc.Start();
            }
        }
        catch (Win32Exception e)
        {
            Debug.LogError($"No executable exists. Please 'Build' first\n{e.Message}");
        }
    }

    private bool SwitchBuildTarget(BuildTarget buildTarget)
    {
        var buildResult = EditorUserBuildSettings.SwitchActiveBuildTarget(
            BuildTargetGroupFromBuildTarget(buildTarget),
            buildTarget);

        if (!buildResult)
            Debug.LogError($"Failed to switch target to {buildTarget}");

        return buildResult;
    }

    private void BuildAddressable(string profileName)
    {
        AddressableAssetSettingsDefaultObject.Settings.activeProfileId =
            AddressableAssetSettingsDefaultObject.Settings.profileSettings.GetProfileId(profileName);
        AddressableAssetSettings.BuildPlayerContent();
    }


    #region EditorWindow methods

    [MenuItem("My/Launcher")] // Unity Editor のメニューに登録する場所
    private static void Init()
    {
        // エディタウィンドウの作成
        var window = GetWindow<SampleLauncher>("My Launcher");
        window.Show();
    }

    private void OnGUI()
    {
        using (new GUILayout.HorizontalScope())
        {
            allowDebugging = GUILayout.Toggle(allowDebugging, "Allow debugging");
            connectWithProfiler = GUILayout.Toggle(connectWithProfiler, "Connect with profiler");
            buildAddressableAssets = GUILayout.Toggle(buildAddressableAssets, "Build addressable");
        }

        using (new GUILayout.HorizontalScope())
        {
            if (GUILayout.Button("Build")) Build();
            if (GUILayout.Button("Run")) Run();
            if (GUILayout.Button("Build and Run") && Build()) Run();
        }

        using (new GUILayout.HorizontalScope())
        {
            GUILayout.Label($"Client Count: {processCount}", EditorStyles.boldLabel, GUILayout.Width(100));
            processCount = (int)GUILayout.HorizontalSlider(processCount, 1, 3, GUILayout.Height(24), GUILayout.MaxWidth(120));
        }
    }

    #endregion


    #region Build Path and Target

    private string BuildPath(BuildTarget buildTarget)
    {
        switch (buildTarget)
        {
            case BuildTarget.StandaloneOSX: return ProjectRootPath + $"/Build/StandaloneOSX/{AppName}.app";
            case BuildTarget.StandaloneWindows: return ProjectRootPath + $"/Build/StandaloneWindows/{AppName}.exe";
            case BuildTarget.StandaloneWindows64: return ProjectRootPath + $"/Build/StandaloneWindows64/{AppName}.exe";
            default: throw new ArgumentOutOfRangeException(nameof(buildTarget), buildTarget, null);
        }
    }

    private BuildTargetGroup BuildTargetGroupFromBuildTarget(BuildTarget buildTarget)
    {
        switch (buildTarget)
        {
            case BuildTarget.StandaloneOSX: return BuildTargetGroup.Standalone;
            case BuildTarget.StandaloneWindows: return BuildTargetGroup.Standalone;
            case BuildTarget.iOS: return BuildTargetGroup.iOS;
            case BuildTarget.Android: return BuildTargetGroup.Android;
            case BuildTarget.StandaloneWindows64: return BuildTargetGroup.Standalone;
            default: throw new ArgumentOutOfRangeException(nameof(buildTarget), buildTarget, null);
        }
    }

    #endregion
}