610 lines
23 KiB
C#
610 lines
23 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using UnityEditor;
|
|
|
|
using CodeEditor = Unity.CodeEditor.CodeEditor;
|
|
|
|
|
|
#pragma warning disable IDE0005
|
|
using Serilog = Meryel.Serilog;
|
|
#pragma warning restore IDE0005
|
|
|
|
|
|
#nullable enable
|
|
|
|
|
|
namespace Meryel.UnityCodeAssist.Editor
|
|
{
|
|
public class Assister
|
|
{
|
|
public const string Version = "1.4.19"; //do NOT modify this line, except the number value, its being used by VSCode/Typescript for version detection (in exporter.ts.getVersionOfUnitySide())
|
|
|
|
#if MERYEL_UCA_LITE_VERSION
|
|
public const string Title = "Code Assist Lite";
|
|
#else
|
|
public const string Title = "Code Assist";
|
|
#endif
|
|
|
|
[MenuItem("Tools/" + Title + "/Status", false, 1)]
|
|
static void DisplayStatusWindow()
|
|
{
|
|
StatusWindow.Display();
|
|
}
|
|
|
|
|
|
[MenuItem("Tools/" + Title + "/Synchronize", false, 2)]
|
|
static void Sync()
|
|
{
|
|
EditorCoroutines.EditorCoroutineUtility.StartCoroutine(SyncAux(), MQTTnetInitializer.Publisher);
|
|
|
|
//MQTTnetInitializer.Publisher.SendConnect();
|
|
//Serilog.Log.Information("Code Assist is looking for more IDEs to connect to...");
|
|
|
|
MQTTnetInitializer.Publisher?.SendAnalyticsEvent("Gui", "Synchronize_MenuItem");
|
|
}
|
|
|
|
|
|
[MenuItem("Tools/" + Title + "/Report error", false, 91)]
|
|
static void DisplayFeedbackWindow()
|
|
{
|
|
FeedbackWindow.Display();
|
|
}
|
|
|
|
[MenuItem("Tools/" + Title + "/About", false, 92)]
|
|
static void DisplayAboutWindow()
|
|
{
|
|
AboutWindow.Display();
|
|
}
|
|
|
|
#if MERYEL_UCA_LITE_VERSION
|
|
[MenuItem("Tools/" + Title + "/Compare versions", false, 31)]
|
|
static void CompareVersions()
|
|
{
|
|
Application.OpenURL("http://unitycodeassist.netlify.app/compare");
|
|
|
|
MQTTnetInitializer.Publisher?.SendAnalyticsEvent("Gui", "CompareVersions_MenuItem");
|
|
}
|
|
|
|
[MenuItem("Tools/" + Title + "/Get full version", false, 32)]
|
|
static void GetFullVersion()
|
|
{
|
|
Application.OpenURL("https://unitycodeassist.netlify.app/purchase?utm_source=unity_getfull");
|
|
|
|
MQTTnetInitializer.Publisher?.SendAnalyticsEvent("Gui", "FullVersion_MenuItem");
|
|
}
|
|
#endif // MERYEL_UCA_LITE_VERSION
|
|
|
|
[MenuItem("Tools/" + Title + "/Setup/Upgrade to full version", false, 65)]
|
|
public static void Upgrade()
|
|
{
|
|
MQTTnetInitializer.Publisher?.SendAnalyticsEvent("Gui", "Upgrade_MenuItem");
|
|
|
|
#if MERYEL_UCA_LITE_VERSION
|
|
Serilog.Log.Information("Purchase <a href=\"https://unitycodeassist.netlify.app/purchase?utm_source=unity_upgrade\">Unity Code Assist</a> from the <a href=\"http://u3d.as/2N2H\">Asset Store</a> or <a href=\"https://meryel.itch.io/unity-code-assist\">itch.io</a> first. Then download it from the package manager or itch.io");
|
|
return;
|
|
#else
|
|
if (GetCodeEditor(true, out var isVisualStudio, out var isVisualStudioCode, out var error))
|
|
{
|
|
if (isVisualStudio)
|
|
{
|
|
var vsixPath = CommonTools.GetInstallerPath("CodeAssist.Full.VisualStudio.Installer.vsix");
|
|
if (System.IO.File.Exists(vsixPath))
|
|
{
|
|
CallVisualStudioInstaller(vsixPath);
|
|
return;
|
|
}
|
|
|
|
var zipPath = CommonTools.GetInstallerPath("CodeAssist.Full.VisualStudio.Installer.zip");
|
|
if (System.IO.File.Exists(zipPath))
|
|
{
|
|
var tempVsixPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "CodeAssist.Full.VisualStudio.Installer.vsix");
|
|
System.IO.File.Copy(zipPath, tempVsixPath, true);
|
|
|
|
CallVisualStudioInstaller(tempVsixPath);
|
|
return;
|
|
}
|
|
|
|
Serilog.Log.Information("Installer for Visual Studio couldn't be found at {ZipPath}. Please try re-importing the asset from the package manager", zipPath);
|
|
return;
|
|
}
|
|
else if (isVisualStudioCode)
|
|
{
|
|
var vsixPath = CommonTools.GetInstallerPath("CodeAssist.Full.VSCode.Installer.vsix");
|
|
if (System.IO.File.Exists(vsixPath))
|
|
{
|
|
CallVSCodeInstaller(vsixPath);
|
|
return;
|
|
}
|
|
|
|
var zipPath = CommonTools.GetInstallerPath("CodeAssist.Full.VSCode.Installer.zip");
|
|
if (System.IO.File.Exists(zipPath))
|
|
{
|
|
var tempVsixPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "CodeAssist.Full.VSCode.Installer.vsix");
|
|
System.IO.File.Copy(zipPath, tempVsixPath, true);
|
|
|
|
CallVSCodeInstaller(tempVsixPath);
|
|
return;
|
|
}
|
|
|
|
Serilog.Log.Information("Installer for VS Code couldn't be found at {ZipPath}. Please try re-importing the asset from the package manager", zipPath);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Serilog.Log.Information(error!);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/*
|
|
[MenuItem("Tools/" + Title + "/Setup/Update", false, 61)]
|
|
static void Update()
|
|
{
|
|
//UnityEditor.PackageManager.Client.
|
|
}
|
|
*/
|
|
|
|
[MenuItem("Tools/" + Title + "/Setup/Re-import package", false, 62)]
|
|
static void RepairFiles()
|
|
{
|
|
if (MQTTnetInitializer.Publisher?.Clients.Any() != true)
|
|
Serilog.Log.Information("No connected IDE found. Please start up Visual Studio or VS Code first");
|
|
|
|
//var cleanupPath = CommonTools.GetToolPath("CleanupObsoleteFiles.bat");
|
|
//Execute(cleanupPath);
|
|
Cleanup.DoCleanup();
|
|
|
|
MQTTnetInitializer.Publisher?.SendRequestUpdate("Unity", string.Empty, true);
|
|
|
|
MQTTnetInitializer.Publisher?.SendAnalyticsEvent("Gui", "Reimport_MenuItem");
|
|
}
|
|
|
|
[MenuItem("Tools/" + Title + "/Setup/Import files for .NET Standard 2.0", false, 63)]
|
|
static void ImportSystemBinariesForDotNetStandard20()
|
|
{
|
|
var solutionDirectory = CommonTools.GetProjectPath();
|
|
var cSharpVersion = Cleanup.GetCSharpVersionFromUnityProjectVersionFile(solutionDirectory);
|
|
|
|
if (cSharpVersion >= 9)
|
|
{
|
|
if (!EditorUtility.DisplayDialog("Import files for .NET Standard 2.0",
|
|
"This is not required for versions of Unity 2021.2 and newer. Do you still want to continue?",
|
|
"Okay", "Cancel"))
|
|
{
|
|
Serilog.Log.Debug("ImportNetStandard20_MenuItem cancelled via confirm dialog");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (MQTTnetInitializer.Publisher?.Clients.Any() != true)
|
|
Serilog.Log.Information("No connected IDE found. Please start up Visual Studio or VS Code first");
|
|
|
|
MQTTnetInitializer.Publisher?.SendRequestUpdate("SystemBinariesForDotNetStandard20", string.Empty, true);
|
|
|
|
MQTTnetInitializer.Publisher?.SendAnalyticsEvent("Gui", "ImportNetStandard20_MenuItem");
|
|
}
|
|
|
|
[MenuItem("Tools/" + Title + "/Setup/Regenerate project files", false, 64)]
|
|
public static void RegenerateProjectFiles() => RegenerateProjectFilesAux(true);
|
|
|
|
public static void RegenerateProjectFilesAux(bool showError)
|
|
{
|
|
try
|
|
{
|
|
if (GetCodeEditor(true, out _, out _, out var error))
|
|
{
|
|
CodeEditor.Editor.CurrentCodeEditor.SyncAll();
|
|
}
|
|
else
|
|
{
|
|
if (showError && error != null)
|
|
Serilog.Log.Information(error);
|
|
|
|
// other similar approaches
|
|
// https://www.reddit.com/r/Unity3D/comments/s1joc6/help_with_generating_csproj_and_sln_for_github/
|
|
// https://discussions.unity.com/t/manually-generate-sln-and-csproj-files/648686/6
|
|
// https://discussions.unity.com/t/how-can-i-generate-csproj-files-during-continuous-integration-builds/842493/3
|
|
// https://github.com/Unity-Technologies/UnityCsReference/blob/f45f297f342239326ea865a57a1bb8ddf93e38c6/Editor/Mono/CodeEditor/SyncVS.cs#L22
|
|
var t = ScriptFinder.GetType123("Microsoft.Unity.VisualStudio.Editor.Cli");
|
|
var m = t!.GetMethod("GenerateSolution", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
|
|
m.Invoke(null, null);
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
Serilog.Log.Error(ex, "Couldn't invoke GenerateSolution");
|
|
Serilog.Log.Information("Please 'Regenerate project files' manually. 'Edit'->'Preferences'->'External Tools'->'Regenerate project files'");
|
|
}
|
|
}
|
|
|
|
|
|
static IEnumerator CallShell(string command, string ide)
|
|
{
|
|
Serilog.Log.Debug("calling shell with command: {Command}", command);
|
|
var task = Shell.UnityEditorShell.Execute(command);
|
|
task.OnLog += (logType, log) =>
|
|
{
|
|
Serilog.Log.Debug("shell log: {Log}", log);
|
|
};
|
|
task.OnExit += (code) =>
|
|
{
|
|
Serilog.Log.Debug("shell exit: {Code}", code);
|
|
if (code == 0)
|
|
Serilog.Log.Information($"{ide} extension installed successfully. Please restart {ide}");
|
|
else
|
|
Serilog.Log.Information($"{ide} extension installation failed. Please try manual installition at {CommonTools.GetInstallerPath(string.Empty)}");
|
|
};
|
|
yield return new Shell.ShellCommandYieldable(task);
|
|
}
|
|
|
|
static void CallVisualStudioInstaller(string vsixPath)
|
|
{
|
|
EditorCoroutines.EditorCoroutineUtility.StartCoroutine(CallShell(
|
|
$"@for /f \"usebackq delims=\" %i in (`\"%ProgramFiles(x86)%\\Microsoft Visual Studio\\Installer\\vswhere.exe\" -latest -prerelease -products * -property enginePath`) do @set enginePath=%i & if exist \"%i\\VSIXInstaller.exe\" call \"%i\\VSIXInstaller.exe\" /u:VSIXLite2.6815b720-6186-48a1-a405-1387e54b41c6 & call \"%i\\VSIXInstaller.exe\" \"{vsixPath}\"", "Visual Studio"), MQTTnetInitializer.Publisher);
|
|
}
|
|
|
|
static void CallVSCodeInstaller(string vsixPath)
|
|
{
|
|
string command;
|
|
#if UNITY_EDITOR_WIN
|
|
command = $"code --uninstall-extension MerryYellow.uca-lite-vscode & code --install-extension \"{vsixPath}\"";
|
|
#elif UNITY_EDITOR_OSX || UNITY_EDITOR_LINUX
|
|
command = $"code --uninstall-extension MerryYellow.uca-lite-vscode ; code --install-extension \"{vsixPath}\"";
|
|
#else
|
|
Serilog.Log.Error("invalid platform at {Location}", nameof(CallVSCodeInstaller));
|
|
command = string.Empty;
|
|
#endif
|
|
|
|
EditorCoroutines.EditorCoroutineUtility.StartCoroutine(CallShell(command, "VS Code"), MQTTnetInitializer.Publisher);
|
|
}
|
|
|
|
internal static string Execute(string vsixPath, bool isVisualStudio = false, bool isVSCode = false)
|
|
{
|
|
var startInfo = new System.Diagnostics.ProcessStartInfo
|
|
{
|
|
WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden,
|
|
//startInfo.FileName = GetExePath();
|
|
FileName = vsixPath,
|
|
//startInfo.Arguments = args;
|
|
UseShellExecute = false,
|
|
RedirectStandardOutput = true
|
|
//startInfo.WorkingDirectory = workingDirectoryPath;
|
|
};
|
|
var process = new System.Diagnostics.Process
|
|
{
|
|
StartInfo = startInfo
|
|
};
|
|
|
|
try
|
|
{
|
|
process.Start();
|
|
}
|
|
catch (System.ComponentModel.Win32Exception ex)
|
|
{
|
|
Serilog.Log.Error(ex, "Error at running bat file {File}", vsixPath);
|
|
}
|
|
|
|
string output = process.StandardOutput.ReadToEnd();
|
|
process.WaitForExit();
|
|
|
|
return output;
|
|
}
|
|
|
|
|
|
static IEnumerator SyncAux()
|
|
{
|
|
var clientCount = MQTTnetInitializer.Publisher?.Clients.Count() ?? 0;
|
|
MQTTnetInitializer.Publisher?.SendConnect();
|
|
Serilog.Log.Information("Code Assist is looking for more IDEs to connect to...");
|
|
|
|
//yield return new WaitForSeconds(3);
|
|
yield return new EditorCoroutines.EditorWaitForSeconds(3);
|
|
|
|
var newClientCount = MQTTnetInitializer.Publisher?.Clients.Count() ?? 0;
|
|
|
|
var dif = newClientCount - clientCount;
|
|
|
|
if (dif <= 0)
|
|
Serilog.Log.Information("Code Assist couldn't find any new IDE to connect to.");
|
|
else
|
|
Serilog.Log.Information("Code Assist is connected to {Dif} new IDE(s).", dif);
|
|
}
|
|
|
|
#if MERYEL_DEBUG
|
|
|
|
[MenuItem("Code Assist/Binary2Text")]
|
|
static void Binary2Text()
|
|
{
|
|
var filePath = CommonTools.GetInputManagerFilePath();
|
|
var hash = Input.UnityInputManager.GetMD5Hash(filePath);
|
|
var convertedPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), $"UCA_IM_{hash}.txt");
|
|
|
|
var b = new Input.Binary2TextExec();
|
|
b.Exec(filePath, convertedPath, detailed: false, largeBinaryHashOnly: false, hexFloat: false);
|
|
}
|
|
|
|
[MenuItem("Code Assist/Bump InputManager")]
|
|
static void BumpInputManager()
|
|
{
|
|
Input.InputManagerMonitor.Instance.Bump();
|
|
}
|
|
|
|
|
|
[MenuItem("Code Assist/Layer Check")]
|
|
static void UpdateLayers()
|
|
{
|
|
var names = UnityEditorInternal.InternalEditorUtility.layers;
|
|
var indices = names.Select(l => LayerMask.NameToLayer(l).ToString()).ToArray();
|
|
MQTTnetInitializer.Publisher?.SendLayers(indices, names);
|
|
|
|
var sls = SortingLayer.layers;
|
|
var sortingNames = sls.Select(sl => sl.name).ToArray();
|
|
var sortingIds = sls.Select(sl => sl.id.ToString()).ToArray();
|
|
var sortingValues = sls.Select(sl => sl.value.ToString()).ToArray();
|
|
|
|
MQTTnetInitializer.Publisher?.SendSortingLayers(sortingNames, sortingIds, sortingValues);
|
|
|
|
/*
|
|
for (var i = 0; i < 32; i++)
|
|
{
|
|
var name = LayerMask.LayerToName(i);
|
|
if (!string.IsNullOrEmpty(name))
|
|
{
|
|
Debug.Log(i + ":" + name);
|
|
}
|
|
}
|
|
|
|
if (ScriptFinder.FindGameObjectOfType("Deneme", out var go))
|
|
MQTTnetInitializer.Publisher.SendGameObject(go);
|
|
*/
|
|
}
|
|
|
|
[MenuItem("Code Assist/Tag Check")]
|
|
static void UpdateTags()
|
|
{
|
|
Serilog.Log.Debug("Listing tags {Count}", UnityEditorInternal.InternalEditorUtility.tags.Length);
|
|
|
|
foreach (var tag in UnityEditorInternal.InternalEditorUtility.tags)
|
|
{
|
|
if (!string.IsNullOrEmpty(tag))
|
|
{
|
|
Serilog.Log.Debug("{Tag}", tag);
|
|
}
|
|
}
|
|
|
|
MQTTnetInitializer.Publisher?.SendTags(UnityEditorInternal.InternalEditorUtility.tags);
|
|
|
|
}
|
|
|
|
[MenuItem("Code Assist/GO Check")]
|
|
|
|
static void TestGO()
|
|
{
|
|
|
|
var go = GameObject.Find("Deneme");
|
|
//var go = MonoBehaviour.FindObjectOfType<Deneme>().gameObject;
|
|
|
|
MQTTnetInitializer.Publisher?.SendGameObject(go);
|
|
}
|
|
|
|
[MenuItem("Code Assist/Undo Records Test")]
|
|
static void UndoTest()
|
|
{
|
|
var undos = new List<string>();
|
|
var redos = new List<string>();
|
|
|
|
var type = typeof(Undo);
|
|
System.Reflection.MethodInfo dynMethod = type.GetMethod("GetRecords",
|
|
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
|
|
dynMethod.Invoke(null, new object[] { undos, redos });
|
|
|
|
Serilog.Log.Debug("undos:{UndoCount},redos:{RedoCount}", undos.Count, redos.Count);
|
|
|
|
var last = undos.LastOrDefault();
|
|
if (last != null)
|
|
{
|
|
Serilog.Log.Debug("last:{Last}", last);
|
|
Serilog.Log.Debug("group:{UndoCurrentGroup},{UndoCurrentGroupName}",
|
|
Undo.GetCurrentGroup(), Undo.GetCurrentGroupName());
|
|
}
|
|
}
|
|
|
|
|
|
[MenuItem("Code Assist/Undo List Test")]
|
|
static void Undo2Test()
|
|
{
|
|
|
|
//List<string> undoList, out int undoCursor
|
|
var undoList = new List<string>();
|
|
int undoCursor = int.MaxValue;
|
|
var type = typeof(Undo);
|
|
System.Reflection.MethodInfo dynMethod = type.GetMethod("GetUndoList",
|
|
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
|
|
|
|
dynMethod = type.GetMethod("GetUndoList",
|
|
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static,
|
|
null,
|
|
new System.Type[] { typeof(List<string>), typeof(int).MakeByRefType() },
|
|
null);
|
|
|
|
|
|
dynMethod.Invoke(null, new object[] { undoList, undoCursor });
|
|
|
|
Serilog.Log.Debug("undo count: {Count}", undoList.Count);
|
|
|
|
}
|
|
|
|
[MenuItem("Code Assist/Reload Domain")]
|
|
static void ReloadDomain()
|
|
{
|
|
EditorUtility.RequestScriptReload();
|
|
}
|
|
|
|
/*
|
|
[MenuItem("Code Assist/TEST")]
|
|
static void TEST()
|
|
{
|
|
//if (ScriptFinder.FindGameObjectOfType("Deneme_OtherScene", out var go))
|
|
if (ScriptFinder.FindInstanceOfType("Deneme_SO", out var go, out var so))
|
|
{
|
|
MQTTnetInitializer.Publisher.SendScriptableObject(so);
|
|
}
|
|
|
|
ScriptFinder.DENEMEEEE();
|
|
|
|
|
|
|
|
}
|
|
*/
|
|
|
|
#endif // MERYEL_DEBUG
|
|
|
|
|
|
public static void SendTagsAndLayers()
|
|
{
|
|
Serilog.Log.Debug(nameof(SendTagsAndLayers));
|
|
|
|
var tags = UnityEditorInternal.InternalEditorUtility.tags;
|
|
MQTTnetInitializer.Publisher?.SendTags(tags);
|
|
|
|
var layerNames = UnityEditorInternal.InternalEditorUtility.layers;
|
|
var layerIndices = layerNames.Select(l => LayerMask.NameToLayer(l).ToString()).ToArray();
|
|
MQTTnetInitializer.Publisher?.SendLayers(layerNames, layerIndices);
|
|
|
|
var sls = SortingLayer.layers;
|
|
var sortingNames = sls.Select(sl => sl.name).ToArray();
|
|
var sortingIds = sls.Select(sl => sl.id.ToString()).ToArray();
|
|
var sortingValues = sls.Select(sl => sl.value.ToString()).ToArray();
|
|
MQTTnetInitializer.Publisher?.SendSortingLayers(sortingNames, sortingIds, sortingValues);
|
|
|
|
#if UNITY_6000_0_OR_NEWER
|
|
// Version 6+ only, 2022.3 doesn't have class RenderingLayerMask, even though some renderingLayerMask fields/properties are declared
|
|
|
|
var renderingLayerCount = RenderingLayerMask.GetRenderingLayerCount();
|
|
var renderingLayerIndices = new string[renderingLayerCount];
|
|
var renderingLayerNames = new string[renderingLayerCount];
|
|
for (var i = 0; i < renderingLayerCount; i++)
|
|
{
|
|
renderingLayerIndices[i] = i.ToString();
|
|
renderingLayerNames[i] = RenderingLayerMask.RenderingLayerToName(i);
|
|
}
|
|
MQTTnetInitializer.Publisher?.SendRenderingLayers(renderingLayerNames, renderingLayerIndices);
|
|
|
|
#endif // UNITY_6000_0_OR_NEWER
|
|
}
|
|
|
|
public static bool GetCodeEditor(bool checkVersion, out bool isVisualStudio, out bool isVisualStudioCode, out string? error)
|
|
{
|
|
isVisualStudio = false;
|
|
isVisualStudioCode = false;
|
|
|
|
if (CodeEditor.Editor.CurrentCodeEditor.TryGetInstallationForPath(CodeEditor.CurrentEditorInstallation, out var installation))
|
|
{
|
|
if (installation.Name.StartsWith("Visual Studio Code"))
|
|
isVisualStudioCode = true;
|
|
else if (installation.Name.StartsWith("Visual Studio"))
|
|
isVisualStudio = true;
|
|
|
|
if (!isVisualStudioCode && !isVisualStudio)
|
|
{
|
|
error = $"Unsupported code editor: {installation.Name}. Unity Code Assist only supports Visual Studio and Visual Studio Code";
|
|
return false;
|
|
}
|
|
|
|
if (installation.Name.Contains("(internal)"))
|
|
{
|
|
error = "Code editor set but not working properly. Please try updating 'Visual Studio Editor' package";
|
|
return false;
|
|
}
|
|
|
|
if (!checkVersion)
|
|
{
|
|
error = null;
|
|
return true;
|
|
}
|
|
|
|
var versionRegex = new System.Text.RegularExpressions.Regex(".*\\[([\\d\\.]+)\\]");
|
|
var versionStr = versionRegex.Match(installation.Name).Groups.ElementAtOrDefault(1)?.Value;
|
|
|
|
if (isVisualStudioCode && !string.IsNullOrEmpty(versionStr) && (VersionCompare(versionStr!, "1.76") < 0))
|
|
{
|
|
error = $"Version {versionStr} of Visual Studio Code is not supported by Unity Code Assist. Please update Visual Studio Code";
|
|
return false;
|
|
}
|
|
|
|
if (isVisualStudio && !string.IsNullOrEmpty(versionStr) && (VersionCompare(versionStr!, "17") < 0))
|
|
{
|
|
error = $"Version {versionStr} of Visual Studio is not supported by Unity Code Assist. Please update Visual Studio";
|
|
return false;
|
|
}
|
|
|
|
error = null;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
error = "No code editor found. Please set it through 'Edit'->'Preferences'->'External Tools'->'External Script Editor'";
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//https://www.geeksforgeeks.org/compare-two-version-numbers/amp/
|
|
public static int VersionCompare(string v1, string v2)
|
|
{
|
|
// vnum stores each numeric
|
|
|
|
// part of version
|
|
|
|
int vnum1 = 0, vnum2 = 0;
|
|
|
|
// loop until both string are
|
|
// processed
|
|
|
|
for (int i = 0, j = 0; (i < v1.Length || j < v2.Length);)
|
|
|
|
{
|
|
// storing numeric part of
|
|
// version 1 in vnum1
|
|
while (i < v1.Length && v1[i] != '.')
|
|
{
|
|
|
|
vnum1 = vnum1 * 10 + (v1[i] - '0');
|
|
|
|
i++;
|
|
}
|
|
// storing numeric part of
|
|
|
|
// version 2 in vnum2
|
|
|
|
while (j < v2.Length && v2[j] != '.')
|
|
{
|
|
vnum2 = vnum2 * 10 + (v2[j] - '0');
|
|
j++;
|
|
}
|
|
if (vnum1 > vnum2)
|
|
return 1;
|
|
|
|
if (vnum2 > vnum1)
|
|
return -1;
|
|
|
|
// if equal, reset variables and
|
|
|
|
// go for next numeric part
|
|
vnum1 = vnum2 = 0;
|
|
i++;
|
|
j++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
}
|