You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1179 lines
37 KiB
1179 lines
37 KiB
using UnityEngine;
|
|
using UnityEditor;
|
|
using UnityEditor.Callbacks;
|
|
using System.Collections.Generic;
|
|
using DeployMethod = System.Reflection.MethodInfo;
|
|
|
|
namespace UltraCombos
|
|
{
|
|
public enum Drive { A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z };
|
|
|
|
public sealed class Utils
|
|
{
|
|
public static string[] ConvertEditorBuildSettingsScenesToPaths(EditorBuildSettingsScene[] scenes)
|
|
{
|
|
List<string> lst_scene_path = new List<string>();
|
|
foreach (EditorBuildSettingsScene scene in scenes)
|
|
{
|
|
lst_scene_path.Add(scene.path);
|
|
}
|
|
return lst_scene_path.ToArray();
|
|
}
|
|
|
|
public static EditorBuildSettingsScene[] ConvertPathsToEditorBuildSettingsScenes(string[] paths)
|
|
{
|
|
List<EditorBuildSettingsScene> lst_editor_build_settings_scene = new List<EditorBuildSettingsScene>();
|
|
foreach (string path in paths)
|
|
{
|
|
lst_editor_build_settings_scene.Add(new EditorBuildSettingsScene(path, true));
|
|
}
|
|
return lst_editor_build_settings_scene.ToArray();
|
|
}
|
|
|
|
public static string GetProjectPath()
|
|
{
|
|
return System.IO.Directory.GetParent(UnityEngine.Application.dataPath).ToString();
|
|
}
|
|
|
|
public static void SplitPath(string full_path, out string parent_path, out string filename)
|
|
{
|
|
parent_path = System.IO.Path.GetDirectoryName(full_path).Replace("\\", "/");
|
|
if (parent_path.Length == 0)
|
|
{
|
|
parent_path = "/";
|
|
}
|
|
|
|
if (parent_path[parent_path.Length - 1] != '/')
|
|
{
|
|
parent_path += "/";
|
|
}
|
|
|
|
filename = System.IO.Path.GetFileName(full_path);
|
|
}
|
|
|
|
public static string MakeRelativePath(string workingDirectory, string fullPath)
|
|
{
|
|
string result = string.Empty;
|
|
int offset;
|
|
|
|
// this is the easy case. The file is inside of the working directory.
|
|
if (fullPath.StartsWith(workingDirectory))
|
|
{
|
|
return fullPath.Substring(workingDirectory.Length + 1);
|
|
}
|
|
|
|
// the hard case has to back out of the working directory
|
|
string[] baseDirs = workingDirectory.Split(new char[] { ':', '\\', '/' });
|
|
string[] fileDirs = fullPath.Split(new char[] { ':', '\\', '/' });
|
|
|
|
// if we failed to split (empty strings?) or the drive letter does not match
|
|
if (baseDirs.Length <= 0 || fileDirs.Length <= 0 || baseDirs[0] != fileDirs[0])
|
|
{
|
|
// can't create a relative path between separate harddrives/partitions.
|
|
return fullPath;
|
|
}
|
|
|
|
// skip all leading directories that match
|
|
for (offset = 1; offset < baseDirs.Length; offset++)
|
|
{
|
|
if (baseDirs[offset] != fileDirs[offset])
|
|
break;
|
|
}
|
|
|
|
// back out of the working directory
|
|
for (int i = 0; i < (baseDirs.Length - offset); i++)
|
|
{
|
|
result += "..\\";
|
|
}
|
|
|
|
// step into the file path
|
|
for (int i = offset; i < fileDirs.Length - 1; i++)
|
|
{
|
|
result += fileDirs[i] + "\\";
|
|
}
|
|
|
|
// append the file
|
|
result += fileDirs[fileDirs.Length - 1];
|
|
|
|
return result.Replace("\\", "/");
|
|
}
|
|
|
|
public static int Xcopy(string src, string dst, string args)
|
|
{
|
|
string pathsrc = src.Replace('/', '\\');
|
|
string pathdst = dst.Replace('/', '\\');
|
|
|
|
System.Diagnostics.Process p = System.Diagnostics.Process.Start("xcopy.exe", pathsrc + " " + pathdst + " " + args);
|
|
p.WaitForExit();
|
|
return p.ExitCode;
|
|
}
|
|
|
|
public static string GetDriveName(Drive d)
|
|
{
|
|
//switch (d)
|
|
//{
|
|
// case Drive.A: return "A:";
|
|
// case Drive.B: return "B:";
|
|
// case Drive.C: return "C:";
|
|
// case Drive.D: return "D:";
|
|
// case Drive.E: return "E:";
|
|
// case Drive.F: return "F:";
|
|
// case Drive.G: return "G:";
|
|
// case Drive.H: return "H:";
|
|
// case Drive.I: return "I:";
|
|
// case Drive.J: return "J:";
|
|
// case Drive.K: return "K:";
|
|
// case Drive.L: return "L:";
|
|
// case Drive.M: return "M:";
|
|
// case Drive.N: return "N:";
|
|
// case Drive.O: return "O:";
|
|
// case Drive.P: return "P:";
|
|
// case Drive.Q: return "Q:";
|
|
// case Drive.R: return "R:";
|
|
// case Drive.S: return "S:";
|
|
// case Drive.T: return "T:";
|
|
// case Drive.U: return "U:";
|
|
// case Drive.V: return "V:";
|
|
// case Drive.W: return "W:";
|
|
// case Drive.X: return "X:";
|
|
// case Drive.Y: return "Y:";
|
|
// case Drive.Z: return "Z:";
|
|
//}
|
|
return d + ":";
|
|
}
|
|
}
|
|
|
|
public sealed class NetDrive
|
|
{
|
|
public sealed class ConnInfo
|
|
{
|
|
public string m_username;
|
|
public string m_password;
|
|
public string m_netpath;
|
|
}
|
|
|
|
public static int Connect(Drive d, ConnInfo info)
|
|
{
|
|
string netpath = info.m_netpath.Replace('/', '\\');
|
|
string args = "use";
|
|
args += " " + Utils.GetDriveName(d);
|
|
args += " " + netpath;
|
|
if (info.m_password.Length > 0)
|
|
{
|
|
args += " " + info.m_password;
|
|
}
|
|
|
|
if (info.m_username.Length > 0)
|
|
{
|
|
args += " /user:" + info.m_username;
|
|
}
|
|
|
|
System.Diagnostics.Process p = System.Diagnostics.Process.Start("net.exe", args);
|
|
p.WaitForExit();
|
|
return p.ExitCode;
|
|
}
|
|
|
|
public static int Disconnect(Drive d)
|
|
{
|
|
string args = "use";
|
|
args += " " + Utils.GetDriveName(d);
|
|
args += " /delete";
|
|
|
|
System.Diagnostics.Process p = System.Diagnostics.Process.Start("net.exe", args);
|
|
p.WaitForExit();
|
|
return p.ExitCode;
|
|
}
|
|
}
|
|
|
|
public sealed class DepolyCommandParser
|
|
{
|
|
public static List<string> GetScenePathList(string[] args)
|
|
{
|
|
return sf_GetArgs(args, "--scene");
|
|
}
|
|
|
|
public static string GetBuildInfoJsonFilename(string[] args)
|
|
{
|
|
List<string> lst = sf_GetArgs(args, "--build-info-json");
|
|
if (lst.Count == 0)
|
|
{
|
|
return "";
|
|
}
|
|
|
|
return lst[0];
|
|
}
|
|
|
|
public static List<DeployMethod> GetPreExeMethodtList(string[] args)
|
|
{
|
|
List<DeployMethod> lst_method = new List<DeployMethod>();
|
|
List<string> lst = sf_GetArgs(args, "--pre-execute-method");
|
|
|
|
foreach(string arg in lst)
|
|
{
|
|
DeployMethod method = sf_ConvertToDeployMethod(arg);
|
|
if (method == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
lst_method.Add(method);
|
|
}
|
|
|
|
return lst_method;
|
|
}
|
|
|
|
public static List<DeployMethod> GetPostExeMethodList(string[] args)
|
|
{
|
|
List<DeployMethod> lst_method = new List<DeployMethod>();
|
|
List<string> lst = sf_GetArgs(args, "--post-execute-method");
|
|
|
|
foreach (string arg in lst)
|
|
{
|
|
DeployMethod method = sf_ConvertToDeployMethod(arg);
|
|
if (method == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
lst_method.Add(method);
|
|
}
|
|
|
|
return lst_method;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////
|
|
//Must be [class.method]
|
|
private static DeployMethod sf_ConvertToDeployMethod(string arg)
|
|
{
|
|
char[] delimiter_chars = { '.' };
|
|
string[] words = arg.Split(delimiter_chars);
|
|
if (words.Length != 2)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
System.Type type = System.Type.GetType(words[0]);
|
|
if (type == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
DeployMethod method = type.GetMethod(words[1]);
|
|
return method;
|
|
}
|
|
|
|
private static List<string> sf_GetArgs(string[] args, string cmd)
|
|
{
|
|
string cmd_lst_bgn = cmd + "-begin";
|
|
string cmd_lst_end = cmd + "-end";
|
|
|
|
List<string> lst_args = new List<string>();
|
|
|
|
bool is_lst_began = false;
|
|
bool is_one_arg = false;
|
|
|
|
foreach (string arg in args)
|
|
{
|
|
if (string.Compare(arg, cmd) == 0)
|
|
{
|
|
is_one_arg = true;
|
|
continue;
|
|
}
|
|
else if (string.Compare(arg, cmd_lst_bgn) == 0)
|
|
{
|
|
is_one_arg = false;
|
|
is_lst_began = true;
|
|
continue;
|
|
}
|
|
else if (is_lst_began && string.Compare(arg, cmd_lst_end) == 0)
|
|
{
|
|
is_lst_began = false;
|
|
continue;
|
|
}
|
|
|
|
if (!is_lst_began && !is_one_arg)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
lst_args.Add(arg);
|
|
is_one_arg = false;
|
|
}
|
|
|
|
return lst_args;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public class BuildBatchInfo
|
|
{
|
|
public string platform;
|
|
public string build_path;
|
|
public string filename;
|
|
public string[] scenes;
|
|
public bool neeed_open_the_folder_when_sccuess;
|
|
public bool need_silent_crashes;
|
|
}
|
|
|
|
public sealed class ucDeploy
|
|
{
|
|
[PostProcessBuildAttribute(1)]
|
|
public static void OnPostprocessBuild(BuildTarget target, string pathToBuiltProject)
|
|
{
|
|
if (s_scenes_tmp == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
string[] args = System.Environment.GetCommandLineArgs();
|
|
List<DeployMethod> lst_post_method = UltraCombos.DepolyCommandParser.GetPostExeMethodList(args);
|
|
|
|
foreach (DeployMethod method in lst_post_method)
|
|
{
|
|
switch (method.GetParameters().Length)
|
|
{
|
|
case 0:
|
|
method.Invoke(null, null);
|
|
break;
|
|
|
|
case 1:
|
|
method.Invoke(null, new object[] { target });
|
|
break;
|
|
|
|
default:
|
|
case 2:
|
|
method.Invoke(null, new object[] { target, pathToBuiltProject });
|
|
break;
|
|
}
|
|
}
|
|
|
|
EditorBuildSettings.scenes = s_scenes_tmp;
|
|
s_scenes_tmp = null;
|
|
|
|
if (ucDeployTool.NeedBatch(target))
|
|
{
|
|
ucDeployTool.CreateBatchFileAndHideTheExe(pathToBuiltProject, s_need_slient_crashes_tmp);
|
|
}
|
|
}
|
|
|
|
[System.Obsolete("ucDeploy.Execute is deprecated, please use ucDeploy.Execute2 instead.")]
|
|
public static void Execute()
|
|
{
|
|
string[] args = System.Environment.GetCommandLineArgs();
|
|
List<string> lst_scene_path = UltraCombos.DepolyCommandParser.GetScenePathList(args);
|
|
List<EditorBuildSettingsScene> lst_editor_build_settings_scene = new List<EditorBuildSettingsScene>();
|
|
List<DeployMethod> lst_pre_method = UltraCombos.DepolyCommandParser.GetPreExeMethodtList(args);
|
|
|
|
foreach (string path in lst_scene_path)
|
|
{
|
|
lst_editor_build_settings_scene.Add(new EditorBuildSettingsScene(path, true));
|
|
UnityEngine.Debug.Log("====================== [78 Log] Added Scene Path: " + path + " ======================");
|
|
}
|
|
|
|
s_scenes_tmp = EditorBuildSettings.scenes;
|
|
EditorBuildSettings.scenes = lst_editor_build_settings_scene.ToArray();
|
|
|
|
foreach (DeployMethod method in lst_pre_method)
|
|
{
|
|
method.Invoke(null, null);
|
|
}
|
|
}
|
|
|
|
public static void Execute2()
|
|
{
|
|
string[] args = System.Environment.GetCommandLineArgs();
|
|
List<DeployMethod> lst_pre_method = UltraCombos.DepolyCommandParser.GetPreExeMethodtList(args);
|
|
string json_filename = UltraCombos.DepolyCommandParser.GetBuildInfoJsonFilename(args);
|
|
if (json_filename == "")
|
|
{
|
|
sf_Error("Can not find the json file, please check the arg: --build-info-json .");
|
|
return;
|
|
}
|
|
|
|
string json = System.IO.File.ReadAllText(json_filename);
|
|
BuildBatchInfo info;
|
|
try
|
|
{
|
|
info = UnityEngine.JsonUtility.FromJson<BuildBatchInfo>(json);
|
|
}
|
|
catch (System.Exception exception)
|
|
{
|
|
sf_Error(json_filename + " is invalid, " + exception.Message);
|
|
return;
|
|
}
|
|
|
|
if (info == null)
|
|
{
|
|
sf_Error(json_filename + " is invalid.");
|
|
return;
|
|
}
|
|
|
|
BuildTarget target;
|
|
try
|
|
{
|
|
target = (BuildTarget)System.Enum.Parse(typeof(BuildTarget), info.platform);
|
|
}
|
|
catch (System.Exception exception)
|
|
{
|
|
sf_Error(json_filename + " - platform is invalid: " + info.platform + " ," + exception.Message);
|
|
return;
|
|
}
|
|
|
|
if (info.build_path == "")
|
|
{
|
|
sf_Error(json_filename + " - build_path is invalid.");
|
|
return;
|
|
}
|
|
|
|
if (info.filename == "")
|
|
{
|
|
sf_Error(json_filename + "- filename is invalid.");
|
|
return;
|
|
}
|
|
|
|
if (info.scenes == null || info.scenes.Length == 0)
|
|
{
|
|
sf_Error(json_filename + "- scenes is invalid.");
|
|
return;
|
|
}
|
|
|
|
foreach (DeployMethod method in lst_pre_method)
|
|
{
|
|
method.Invoke(null, null);
|
|
}
|
|
|
|
s_scenes_tmp = EditorBuildSettings.scenes;
|
|
s_need_slient_crashes_tmp = info.need_silent_crashes;
|
|
|
|
string path = info.build_path + info.filename;
|
|
bool yes = ucDeployTool.Deploy(path, target, info.scenes);
|
|
if (!yes)
|
|
{
|
|
sf_Error("build failed. Noooo> Orz");
|
|
}
|
|
else
|
|
{
|
|
if (info.neeed_open_the_folder_when_sccuess)
|
|
{
|
|
ucDeployTool.OpenTheFolder(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void sf_Error(string msg)
|
|
{
|
|
//string path_with_env = @"%USERPROFILE%\AppData\Local\Unity\Editor";
|
|
//string path_log = System.Environment.ExpandEnvironmentVariables(path_with_env);
|
|
//ucDeployTool.OpenTheFolder(path_log);
|
|
|
|
string error = "************************************************************************************************\n";
|
|
error += "[7878Error] " + msg + "\n";
|
|
error += "***********************************************************************************************************\n";
|
|
throw new System.Exception(error);
|
|
}
|
|
|
|
private static EditorBuildSettingsScene[] s_scenes_tmp;
|
|
private static bool s_need_slient_crashes_tmp = true;
|
|
}
|
|
|
|
|
|
public sealed class ucDeployCustomExample
|
|
{
|
|
/*Added this function to menu item... */
|
|
//
|
|
public static void Execute()
|
|
{
|
|
/*
|
|
* //Select path .
|
|
* string path = EditorUtility.SaveFolderPanel("Choose Location of Built Game", "", "");
|
|
*/
|
|
string path = "C:/UC/Example/";
|
|
string exe_file = "78ester.exe";
|
|
string output_path = path + exe_file;
|
|
string[] ary_scene_path = new string[] { "Assets/Tmp01.unity", "Assets/Tmp02.unity" };
|
|
|
|
// Build player.
|
|
BuildPipeline.BuildPlayer(ary_scene_path, output_path, BuildTarget.StandaloneWindows64, BuildOptions.None);
|
|
|
|
/*
|
|
* //Copy a file from the project folder to the build folder, alongside the built game.
|
|
* FileUtil.CopyFileOrDirectory("Assets/Templates/Readme.txt", path + "Readme.txt");
|
|
*/
|
|
|
|
/*
|
|
* //Run the game (Process class from System.Diagnostics).
|
|
* Process proc = new Process();
|
|
* proc.StartInfo.FileName = output_path;
|
|
* proc.Start();
|
|
*/
|
|
}
|
|
}
|
|
|
|
|
|
public sealed class ucDeployTool
|
|
{
|
|
|
|
#if false
|
|
[MenuItem("ucDeploy/Target/Win64", true)]
|
|
public static bool CanSelectTargetPlatformWin64()
|
|
{
|
|
return s_target != BuildTarget.StandaloneWindows64;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Target/Win64", false, 0)]
|
|
public static void SelectTargetPlatformWin64()
|
|
{
|
|
s_can_quick_deploy = false;
|
|
s_target = BuildTarget.StandaloneWindows64;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Target/Win32", true)]
|
|
public static bool CanSelectTargetPlatformWin32()
|
|
{
|
|
return s_target != BuildTarget.StandaloneWindows;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Target/Win32", false, 0)]
|
|
public static void SelectTargetPlatformWin32()
|
|
{
|
|
s_can_quick_deploy = false;
|
|
s_target = BuildTarget.StandaloneWindows;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Target/iOS", true)]
|
|
public static bool CanSelectTargetPlatformiOS()
|
|
{
|
|
return s_target != BuildTarget.iOS;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Target/iOS", false, 0)]
|
|
public static void SelectTargetPlatformiOS()
|
|
{
|
|
s_can_quick_deploy = false;
|
|
s_target = BuildTarget.iOS;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Target/Android", true)]
|
|
public static bool CanSelectTargetPlatformAndroid()
|
|
{
|
|
return s_target != BuildTarget.Android;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Target/Android", false, 0)]
|
|
public static void SelectTargetPlatformAndroid()
|
|
{
|
|
s_can_quick_deploy = false;
|
|
s_target = BuildTarget.Android;
|
|
}
|
|
|
|
/*Added this function to menu item... */
|
|
[MenuItem("ucDeploy/Deploy %F5", true)]
|
|
public static bool CanDeploy()
|
|
{
|
|
return sf_CanDeploy();
|
|
}
|
|
|
|
/*Added this function to menu item... */
|
|
[MenuItem("ucDeploy/Deploy %F5", false, 100)]
|
|
public static void Deploy()
|
|
{
|
|
//Select path
|
|
BuildTarget target = s_target;
|
|
string path = SelectBuildPath(target, s_previous_build_path);
|
|
if (path == "")
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Build player.
|
|
bool yes = Deploy(path, target, null);
|
|
if (!yes)
|
|
{
|
|
return;
|
|
}
|
|
|
|
s_previous_build_path = path;
|
|
s_can_quick_deploy = true;
|
|
|
|
if (NeedBatch(target))
|
|
{
|
|
CreateBatchFileAndHideTheExe(path);
|
|
}
|
|
|
|
if (s_auto_create_one_click_build_batch_when_deploy)
|
|
{
|
|
sf_CreateOneClickBuildBatchAfterDeploy(path);
|
|
}
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Tmp", false, 100)]
|
|
public static void Tmp()
|
|
{
|
|
Shipper shipper = Shipper.GetShipper();
|
|
if (shipper != null)
|
|
{
|
|
shipper.Print();
|
|
}
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Deploy Quickly _F5", true)]
|
|
public static bool CanDeployQuickly()
|
|
{
|
|
return sf_CanDeploy() && s_can_quick_deploy;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Deploy Quickly _F5", false, 100)]
|
|
public static void DeployQuickly()
|
|
{
|
|
BuildTarget target = s_target;
|
|
string path = s_previous_build_path;
|
|
|
|
bool yes = Deploy(path, target, null);
|
|
if (!yes)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (NeedBatch(target))
|
|
{
|
|
CreateBatchFileAndHideTheExe(path);
|
|
}
|
|
|
|
if (s_auto_create_one_click_build_batch_when_deploy)
|
|
{
|
|
sf_CreateOneClickBuildBatchAfterDeploy(path);
|
|
}
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Deploy Quickly And Run It %#F5", true)]
|
|
public static bool CanDeployQuicklyAndRunIt()
|
|
{
|
|
return sf_CanDeploy() && s_can_quick_deploy && sf_CanRun();
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Deploy Quickly And Run It %#F5", false, 100)]
|
|
public static void DeployQuicklyAndRunIt()
|
|
{
|
|
BuildTarget target = s_target;
|
|
string path = s_previous_build_path;
|
|
bool yes = Deploy(path, target, null);
|
|
if (!yes)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (NeedBatch(target))
|
|
{
|
|
CreateBatchFileAndHideTheExe(path);
|
|
}
|
|
|
|
if (s_auto_create_one_click_build_batch_when_deploy)
|
|
{
|
|
sf_CreateOneClickBuildBatchAfterDeploy(path);
|
|
}
|
|
|
|
//Run the game (Process class from System.Diagnostics).
|
|
Run(path);
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Open Deploy Folder _F6", false, 500)]
|
|
public static void OpenDeployFolder()
|
|
{
|
|
bool yes = OpenTheFolder(s_previous_build_path);
|
|
if (!yes)
|
|
{
|
|
EditorUtility.DisplayDialog("[Warning] Open Deploy Folder", "The folder is not exist", "Orz");
|
|
}
|
|
}
|
|
|
|
[MenuItem("ucDeploy/Create Batch File And Hide Execution File", false, 600)]
|
|
public static void CreateBatchFileAndHideTheExe()
|
|
{
|
|
//Select path
|
|
string path = EditorUtility.SaveFilePanel("Deploy", s_previous_build_path, "", "exe");
|
|
if (path == "")
|
|
{
|
|
return;
|
|
}
|
|
|
|
CreateBatchFileAndHideTheExe(path);
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Create %F7", true)]
|
|
public static bool CanOneClickBuildBatch_Create()
|
|
{
|
|
return sf_CanDeploy();
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Create %F7", false, 700)]
|
|
public static void OneClickBuildBatch_Create()
|
|
{
|
|
string batch_path = EditorUtility.SaveFilePanel("Create Build Batch", "", s_previous_build_batch_filename, "bat");
|
|
if (batch_path == "")
|
|
{
|
|
return;
|
|
}
|
|
|
|
BuildTarget target = s_target;
|
|
|
|
string build_path = SelectBuildPath(target, s_previous_build_path);
|
|
if (build_path == "")
|
|
{
|
|
return;
|
|
}
|
|
|
|
sf_CreateOneClickBuildBatch(batch_path, target, build_path);
|
|
s_previous_build_batch_filename = System.IO.Path.GetFileName(batch_path);
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Create Quickly _F7", true)]
|
|
public static bool CanOneClickBuildBatchh_CreateQuickly()
|
|
{
|
|
return sf_CanDeploy() && s_can_quick_deploy;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Create Quickly _F7", false, 700)]
|
|
public static void OneClickBuildBatch_CreateQuickly()
|
|
{
|
|
string build_path = s_previous_build_path;
|
|
string batch_path = s_previous_build_batch_filename;
|
|
if (batch_path == "")
|
|
{
|
|
batch_path = "build_" + System.IO.Path.GetFileNameWithoutExtension(build_path) + ".bat";
|
|
s_previous_build_batch_filename = batch_path;
|
|
}
|
|
|
|
sf_CreateOneClickBuildBatch(batch_path, s_target, build_path);
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Auto Create When Deploy/On", true)]
|
|
public static bool CanOneClickBuildBatch_AutoCreateWhenDeploy_On()
|
|
{
|
|
return !s_auto_create_one_click_build_batch_when_deploy;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Auto Create When Deploy/On", false, 900)]
|
|
public static void OneClickBuildBatch_AutoCreateWhenDeploy_On()
|
|
{
|
|
s_auto_create_one_click_build_batch_when_deploy = true;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Auto Create When Deploy/Off", true)]
|
|
public static bool CanOneClickBuildBatch_AutoCreateWhenDeploy_Off()
|
|
{
|
|
return s_auto_create_one_click_build_batch_when_deploy;
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Auto Create When Deploy/Off", false, 900)]
|
|
public static void OneClickBuildBatch_AutoCreateWhenDeploy_Off()
|
|
{
|
|
s_auto_create_one_click_build_batch_when_deploy = false;
|
|
}
|
|
#endif
|
|
|
|
//[MenuItem("ucDeploy/One Click Build Batch/Auto Create When Deploy/Off", false, 900)]
|
|
//public static void OneClickBuildBatch_AutoCreateWhenDeploy_Off()
|
|
//{ s_auto_create_one_click_build_batch_when_deploy = false;
|
|
//
|
|
//}
|
|
|
|
[MenuItem("UltraCombos/Deploy Default _F5", true)]
|
|
public static bool CanDeployDefaultFromShipper()
|
|
{
|
|
return Shipper.CanDeployDefault();
|
|
}
|
|
|
|
[MenuItem("UltraCombos/Deploy Default _F5")]
|
|
public static void DeployQuicklyFromShipper()
|
|
{
|
|
Shipper.DeployDefault();
|
|
}
|
|
|
|
public static bool Deploy(string path, BuildTarget target, string[] scenes)
|
|
{
|
|
BuildPlayerOptions options = new BuildPlayerOptions();
|
|
|
|
options.locationPathName = path;
|
|
options.target = target;
|
|
options.scenes = scenes;
|
|
options.options = BuildOptions.None;
|
|
|
|
if (options.scenes == null)
|
|
{
|
|
options.scenes = EditorBuildSettingsScene.GetActiveSceneList(EditorBuildSettings.scenes);
|
|
//UltraCombos.Utils.ConvertEditorBuildSettingsScenesToPaths(EditorBuildSettings.scenes);
|
|
}
|
|
|
|
// Build player.
|
|
#if UNITY_2018_1_OR_NEWER
|
|
string ret = BuildPipeline.BuildPlayer(options).ToString();
|
|
#else
|
|
string ret = BuildPipeline.BuildPlayer(options);
|
|
#endif
|
|
if (ret == "")
|
|
{
|
|
return true;
|
|
}
|
|
|
|
EditorUtility.DisplayDialog("[Error] Deploy " + target, ret, "Orz");
|
|
return false;
|
|
}
|
|
|
|
public static bool NeedBatch(BuildTarget target)
|
|
{
|
|
return target == BuildTarget.StandaloneWindows64 ||
|
|
target == BuildTarget.StandaloneWindows;
|
|
}
|
|
|
|
public static void Run(string path)
|
|
{
|
|
System.Diagnostics.Process proc = new System.Diagnostics.Process();
|
|
proc.StartInfo.FileName = path;
|
|
proc.Start();
|
|
}
|
|
|
|
public static BuildTarget GetTarget()
|
|
{
|
|
return s_target;
|
|
}
|
|
|
|
public static string GetBuildPath()
|
|
{
|
|
return s_previous_build_path;
|
|
}
|
|
|
|
|
|
public static void CreateBatchFileAndHideTheExe(string exe_path, bool need_silent_crashes = true)
|
|
{
|
|
string exe_file = System.IO.Path.GetFileName(exe_path);
|
|
string filename = System.IO.Path.GetFileNameWithoutExtension(exe_path);
|
|
string data_folder = filename + "_Data";
|
|
string log_file_without_txt = "output_log";
|
|
string log_file = log_file_without_txt + ".txt";
|
|
string exe_path_var = need_silent_crashes? "\"%exe_path%\" -silent-crashes " : "\"%exe_path%\"";
|
|
|
|
string[] batch_content =
|
|
{
|
|
"@ECHO OFF",
|
|
"SETLOCAL EnableDelayedExpansion",
|
|
"SET build_path=%~dp0",
|
|
"SET data_path=%build_path%" + data_folder,
|
|
"SET exe_path=%build_path%" + exe_file,
|
|
"SET max_log_count=32",
|
|
"SET /a log_count=0",
|
|
"REM List all files in the " + data_folder + ", order sort by the latest date.",
|
|
"FOR /f \"tokens=*\" %%a in ('dir %data_path% /b /o:-d') DO (",
|
|
" REM Split the filename by '-'.",
|
|
" FOR /f \"tokens=1 delims=-\" %%g IN (\"%%a\") DO (",
|
|
" REM If first token is 'output_log', count it.",
|
|
" IF %%g==output_log (",
|
|
" SET /a log_count+=1",
|
|
" REM If count is greater equal than max count, delete this log txt.",
|
|
" IF !log_count! GEQ %max_log_count% DEL /f \"%data_path%\\%%a\"",
|
|
" )",
|
|
" )",
|
|
")",
|
|
"REM Split the date by '/' and ' ', and then combine those token by '-'",
|
|
"FOR /f \"tokens=1-3 delims=/ \" %%a IN (\"%date%\") DO (SET date_tmp=%%a-%%b-%%c)",
|
|
"REM Split the time by '/' and ':', and then combine those token by '-'",
|
|
"FOR /f \"tokens=1-3 delims=/:\" %%a IN (\"%time%\") DO (SET time_tmp=%%a-%%b-%%c)",
|
|
"REM Remove all space character in the date_tmp.",
|
|
"FOR %%# IN (\"%date_tmp%\") DO (",
|
|
" SET var=%%~n#",
|
|
" SET fmt_date=!var!",
|
|
" SET fmt_date=!fmt_date: =!",
|
|
")",
|
|
"REM Remove all space character in the time_tmp.",
|
|
"FOR %%# IN (\"%time_tmp%\") DO (",
|
|
" SET var=%%~n#",
|
|
" SET fmt_time=!var!",
|
|
" SET fmt_time=!fmt_time: =!",
|
|
")",
|
|
"REM If output_log.txt is exist, copy it to new one with date and time.",
|
|
"IF EXIST \"%data_path%\\" + log_file + "\" (",
|
|
" COPY \"%data_path%\\" + log_file + "\" \"%data_path%\\" + log_file_without_txt + "-%fmt_date%-%fmt_time%.txt\"",
|
|
")",
|
|
"START \"\" " + exe_path_var,
|
|
};
|
|
|
|
string dir = System.IO.Path.GetDirectoryName(exe_path);
|
|
string bat_path = System.IO.Path.Combine(dir, filename + ".bat");
|
|
System.IO.File.WriteAllLines(bat_path, batch_content);
|
|
System.IO.File.SetAttributes(exe_path, System.IO.File.GetAttributes(exe_path) | System.IO.FileAttributes.Hidden);
|
|
}
|
|
|
|
public static bool OpenTheFolder(string path)
|
|
{
|
|
if (path == null || path == "")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
string dir;
|
|
do
|
|
{
|
|
bool yes = System.IO.Directory.Exists(path);
|
|
if (yes)
|
|
{
|
|
dir = path;
|
|
break;
|
|
}
|
|
|
|
dir = System.IO.Path.GetDirectoryName(path);
|
|
if (dir == null || dir == "")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
yes = System.IO.Directory.Exists(dir);
|
|
if (!yes)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
} while (false);
|
|
|
|
System.Diagnostics.Process.Start(@dir);
|
|
return true;
|
|
}
|
|
|
|
public static BuildBatchInfo CreateBuildBatchInfo(BuildTarget target, string build_path)
|
|
{
|
|
BuildBatchInfo info = new BuildBatchInfo();
|
|
info.platform = target.ToString();
|
|
info.build_path = System.IO.Path.GetDirectoryName(build_path) + "/";
|
|
info.filename = System.IO.Path.GetFileName(build_path);
|
|
info.scenes = EditorBuildSettingsScene.GetActiveSceneList(EditorBuildSettings.scenes);
|
|
//UltraCombos.Utils.ConvertEditorBuildSettingsScenesToPaths(EditorBuildSettings.scenes);
|
|
info.neeed_open_the_folder_when_sccuess = true;
|
|
info.need_silent_crashes = true;
|
|
return info;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
private static bool sf_CanRun()
|
|
{
|
|
BuildTarget target = s_target;
|
|
return target == BuildTarget.StandaloneWindows64 ||
|
|
target == BuildTarget.StandaloneWindows;
|
|
}
|
|
|
|
private static bool sf_CanDeploy()
|
|
{
|
|
BuildTarget target = s_target;
|
|
return target == BuildTarget.StandaloneWindows64 ||
|
|
target == BuildTarget.StandaloneWindows ||
|
|
target == BuildTarget.iOS ||
|
|
target == BuildTarget.Android;
|
|
}
|
|
|
|
public static bool IsSupportPlatform(BuildTarget target)
|
|
{
|
|
return target == BuildTarget.StandaloneWindows64 ||
|
|
target == BuildTarget.StandaloneWindows ||
|
|
target == BuildTarget.iOS ||
|
|
target == BuildTarget.Android;
|
|
}
|
|
|
|
public static string SelectBuildPath(BuildTarget target, string folder)
|
|
{
|
|
if (target == BuildTarget.iOS)
|
|
{
|
|
return EditorUtility.SaveFolderPanel("Select Build Path...", folder, "");
|
|
}
|
|
else
|
|
{
|
|
string ext_name;
|
|
switch (target)
|
|
{
|
|
case BuildTarget.Android:
|
|
ext_name = "apk";
|
|
break;
|
|
|
|
default:
|
|
case BuildTarget.StandaloneWindows64:
|
|
case BuildTarget.StandaloneWindows:
|
|
ext_name = "exe";
|
|
break;
|
|
}
|
|
|
|
return EditorUtility.SaveFilePanel("Select Build Path...", folder, "", ext_name);
|
|
}
|
|
}
|
|
|
|
private static void sf_CreateOneClickBuildBatchAfterDeploy(string build_path)
|
|
{
|
|
string batch_path = "build_" + System.IO.Path.GetFileNameWithoutExtension(build_path) + ".bat";
|
|
sf_CreateOneClickBuildBatch(batch_path, s_target, build_path);
|
|
s_previous_build_batch_filename = batch_path;
|
|
}
|
|
|
|
public static void CreateOneClickBuildBatch(string batch_path, BuildBatchInfo info)
|
|
{
|
|
string batch_filename_without_ext = System.IO.Path.GetFileNameWithoutExtension(batch_path);
|
|
string json = UnityEngine.JsonUtility.ToJson(info, true);
|
|
string json_filename = batch_filename_without_ext + "_info.json";
|
|
System.IO.File.WriteAllText(json_filename, json);
|
|
|
|
string[] batch_content =
|
|
{
|
|
"@ECHO OFF",
|
|
"REM Setup custom script (option)",
|
|
"REM SET post_build_script=PostBuildScript.Execute\n",
|
|
"SETLOCAL enableextensions enabledelayedexpansion",
|
|
"SET batch_path=%~dp0",
|
|
"REM Setup this batch path to project path",
|
|
"SET project_path=%batch_path%",
|
|
"REM remove the last '\\' chararctor =======================",
|
|
"IF \"%project_path:~-1%\" == \"\\\" (",
|
|
" SET project_path=%project_path:~0,-1%",
|
|
")",
|
|
"REM ======================================================\n",
|
|
"REM Setup Unity Root Path",
|
|
"SET unity_x86_path=C:\\Program Files (x86)\\Unity",
|
|
"SET unity_x64_path=C:\\Program Files\\Unity\n",
|
|
"IF EXIST \"%unity_x64_path%\" (",
|
|
" SET unity_exe=\"%unity_x64_path%\\Editor\\Unity.exe\"",
|
|
") ElSE (",
|
|
" SET unity_exe=\"%unity_x86_path%\\Editor\\Unity.exe\"",
|
|
")\n",
|
|
"REM Check out if the unity exe is exist...",
|
|
"IF Not EXIST %unity_exe% (",
|
|
" ECHO [Batch Error] Please check the settings of the unity.exe",
|
|
" ECHO [Batch Error] %unity_exe% is not exist",
|
|
" PAUSE",
|
|
" EXIT",
|
|
")\n",
|
|
"SET build_log_path=%USERPROFILE%\\AppData\\Local\\Unity\\Editor\n",
|
|
"REM Start to build...",
|
|
"CALL %unity_exe% -quit -batchmode -serial %serial% -username \"%username%\" -password \"%password%\" -projectPath \"%project_path%\" -executeMethod ucDeploy.Execute2 --build-info-json \"" + json_filename + "\"\n",
|
|
"REM when the error occur, open the folder of the build log.",
|
|
"IF %ERRORLEVEL% NEQ 0 (",
|
|
" ECHO Build Failed...Orz",
|
|
" %SystemRoot%\\explorer.exe %build_log_path%",
|
|
") ELSE (",
|
|
" ECHO Build Success...XDDDD",
|
|
")\n",
|
|
"PAUSE"
|
|
};
|
|
|
|
System.IO.File.WriteAllLines(batch_path, batch_content);
|
|
}
|
|
|
|
private static void sf_CreateOneClickBuildBatch(string batch_path, BuildTarget target, string build_path)
|
|
{
|
|
BuildBatchInfo info = CreateBuildBatchInfo(target, build_path);
|
|
CreateOneClickBuildBatch(batch_path, info);
|
|
}
|
|
|
|
private static string s_str_hash_code
|
|
{
|
|
get
|
|
{
|
|
return UnityEngine.Animator.StringToHash(UnityEngine.Application.dataPath).ToString();
|
|
}
|
|
}
|
|
|
|
private static string s_previous_build_path
|
|
{
|
|
get
|
|
{
|
|
return EditorPrefs.GetString("ucDeployToolPreviousPath_" + s_str_hash_code);
|
|
}
|
|
|
|
set
|
|
{
|
|
EditorPrefs.SetString("ucDeployToolPreviousPath_" + s_str_hash_code, value);
|
|
}
|
|
}
|
|
|
|
private static string s_previous_build_batch_filename
|
|
{
|
|
get
|
|
{
|
|
return EditorPrefs.GetString("ucDeployToolPreviousBatch_" + s_str_hash_code);
|
|
}
|
|
|
|
set
|
|
{
|
|
EditorPrefs.SetString("ucDeployToolPreviousBatch_" + s_str_hash_code, value);
|
|
}
|
|
}
|
|
|
|
private static bool s_can_quick_deploy
|
|
{
|
|
get
|
|
{
|
|
return EditorPrefs.GetBool("ucDeployToolCanQuickDeploy_" + s_str_hash_code);
|
|
}
|
|
|
|
set
|
|
{
|
|
EditorPrefs.SetBool("ucDeployToolCanQuickDeploy_" + s_str_hash_code, value);
|
|
}
|
|
}
|
|
|
|
private static bool s_auto_create_one_click_build_batch_when_deploy
|
|
{
|
|
get
|
|
{
|
|
return EditorPrefs.GetBool("ucDeployToolACOCBBWD_" + s_str_hash_code);
|
|
}
|
|
|
|
set
|
|
{
|
|
EditorPrefs.SetBool("ucDeployToolACOCBBWD_" + s_str_hash_code, value);
|
|
}
|
|
}
|
|
|
|
private static BuildTarget s_target
|
|
{
|
|
get
|
|
{
|
|
return (BuildTarget)EditorPrefs.GetInt("ucDeployToolTarget_" + s_str_hash_code);
|
|
}
|
|
|
|
set
|
|
{
|
|
EditorPrefs.SetInt("ucDeployToolTarget_" + s_str_hash_code, (int)value);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if false
|
|
|
|
public sealed class OneClickBuildBatchCreateQuicklyWizard : ScriptableWizard
|
|
{
|
|
public string Platform;
|
|
public string BuildPath;
|
|
public string Filename;
|
|
public string[] scenes;
|
|
public bool OpenBuildPath;
|
|
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Show Quick Info _F8", true)]
|
|
static bool CanCreateWindow()
|
|
{
|
|
return ucDeployTool.CanOneClickBuildBatchh_CreateQuickly();
|
|
}
|
|
|
|
[MenuItem("ucDeploy/One Click Build Batch/Show Quick Info _F8", false, 800)]
|
|
static void CreateWindow()
|
|
{
|
|
ScriptableWizard.DisplayWizard("Show Quick Info.", typeof(OneClickBuildBatchCreateQuicklyWizard), "Close");
|
|
}
|
|
|
|
|
|
void OnWizardUpdate()
|
|
{
|
|
BuildBatchInfo info = ucDeployTool.CreateBuildBatchInfo(ucDeployTool.GetTarget(), ucDeployTool.GetBuildPath());
|
|
Platform = info.platform;
|
|
BuildPath = info.build_path;
|
|
Filename = info.filename;
|
|
scenes = info.scenes;
|
|
OpenBuildPath = info.neeed_open_the_folder_when_sccuess;
|
|
}
|
|
}
|
|
#endif
|
|
|