Adding template

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/COMIntegration.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 36422aa067e092e45b9820da2ee3e728
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/COMIntegration/Release.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 41b2d972bdac29e4a89ef08b3b52c248
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/COMIntegration/Release/COMIntegration.exe.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: cb67edc1800c2ec4ba8dfb1cf0dfc84a
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Discovery.cs

@@ -0,0 +1,165 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Unity Technologies.
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.IO;
+using System.Collections.Generic;
+using UnityEngine;
+using System.Diagnostics;
+using System.Text.RegularExpressions;
+using System.Linq;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	internal static class Discovery
+	{
+		public static IEnumerable<VisualStudioInstallation> GetVisualStudioInstallations()
+		{
+			if (VisualStudioEditor.IsWindows)
+			{
+				foreach (var installation in QueryVsWhere())
+					yield return installation;
+			}
+
+			if (VisualStudioEditor.IsOSX)
+			{
+				var candidates = Directory.EnumerateDirectories("/Applications", "*.app");
+				foreach (var candidate in candidates)
+				{
+					if (TryDiscoverInstallation(candidate, out var installation))
+						yield return installation;
+				}
+			}
+		}
+
+		private static bool IsCandidateToDiscovery(string path)
+		{
+			if (File.Exists(path) && VisualStudioEditor.IsWindows && Regex.IsMatch(path, "devenv.exe$", RegexOptions.IgnoreCase))
+				return true;
+
+			if (Directory.Exists(path) && VisualStudioEditor.IsOSX && Regex.IsMatch(path, "Visual\\s?Studio(?!.*Code.*).*.app$", RegexOptions.IgnoreCase))
+				return true;
+
+			return false;
+		}
+
+		public static bool TryDiscoverInstallation(string editorPath, out VisualStudioInstallation installation)
+		{
+			installation = null;
+
+			if (string.IsNullOrEmpty(editorPath))
+				return false;
+
+			if (!IsCandidateToDiscovery(editorPath))
+				return false;
+
+			// On windows we use the executable directly, so we can query extra information
+			var fvi = editorPath;
+
+			// On Mac we use the .app folder, so we need to access to main assembly
+			if (VisualStudioEditor.IsOSX)
+				fvi = Path.Combine(editorPath, "Contents", "Resources", "lib", "monodevelop", "bin", "VisualStudio.exe");
+			
+			if (!File.Exists(fvi))
+				return false;
+
+			// VS preview are not using the isPrerelease flag so far
+			// On Windows FileDescription contains "Preview", but not on Mac
+			var vi = FileVersionInfo.GetVersionInfo(fvi);
+			var version = new Version(vi.ProductVersion);
+			var isPrerelease = vi.IsPreRelease || string.Concat(editorPath, "/" + vi.FileDescription).ToLower().Contains("preview");
+
+			installation = new VisualStudioInstallation()
+			{
+				IsPrerelease = isPrerelease,
+				Name = $"{vi.FileDescription}{(isPrerelease && VisualStudioEditor.IsOSX ? " Preview" : string.Empty)} [{version.ToString(3)}]",
+				Path = editorPath,
+				Version = version
+			};
+			return true;
+		}
+
+		#region VsWhere Json Schema
+		#pragma warning disable CS0649
+		[Serializable]
+		internal class VsWhereResult
+		{
+			public VsWhereEntry[] entries;
+
+			public static VsWhereResult FromJson(string json)
+			{
+				return JsonUtility.FromJson<VsWhereResult>("{ \"" + nameof(VsWhereResult.entries) + "\": " + json + " }");
+			}
+
+			public IEnumerable<VisualStudioInstallation> ToVisualStudioInstallations()
+			{
+				foreach(var entry in entries)
+				{
+					yield return new VisualStudioInstallation()
+					{
+						Name = $"{entry.displayName} [{entry.catalog.productDisplayVersion}]",
+						Path = entry.productPath,
+						IsPrerelease = entry.isPrerelease,
+						Version = Version.Parse(entry.catalog.buildVersion)
+					};
+				}
+			}
+		}
+
+		[Serializable]
+		internal class VsWhereEntry
+		{
+			public string displayName;
+			public bool isPrerelease;
+			public string productPath;
+			public VsWhereCatalog catalog;
+		}
+
+		[Serializable]
+		internal class VsWhereCatalog
+		{
+			public string productDisplayVersion; // non parseable like "16.3.0 Preview 3.0"
+			public string buildVersion;
+		}
+		#pragma warning restore CS3021
+		#endregion
+
+		private static IEnumerable<VisualStudioInstallation> QueryVsWhere()
+		{
+			var progpath = FileUtility
+				.FindPackageAssetFullPath("VSWhere a:packages", "vswhere.exe")
+				.FirstOrDefault();
+
+			if (string.IsNullOrWhiteSpace(progpath))
+				return Enumerable.Empty<VisualStudioInstallation>();
+
+			var process = new Process
+			{
+				StartInfo = new ProcessStartInfo
+				{
+					FileName = progpath,
+					Arguments = "-prerelease -format json",
+					UseShellExecute = false,
+					CreateNoWindow = true,
+					RedirectStandardOutput = true,
+					RedirectStandardError = true,
+				}
+			};
+
+			using (process)
+			{
+				var json = string.Empty;
+
+				process.OutputDataReceived += (o, e) => json += e.Data;
+				process.Start();
+				process.BeginOutputReadLine();
+				process.WaitForExit();
+
+				var result = VsWhereResult.FromJson(json);
+				return result.ToVisualStudioInstallations();
+			}
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Discovery.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: abe003ac6fee32e4892100a78f555011
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/FileUtility.cs

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Unity Technologies.
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	internal static class FileUtility
+	{
+		public const char WinSeparator = '\\';
+		public const char UnixSeparator = '/';
+
+		// Safe for packages as we use packageInfo.resolvedPath, so this should work in library package cache as well
+		public static string[] FindPackageAssetFullPath(string assetfilter, string filefilter)
+		{
+			return AssetDatabase.FindAssets(assetfilter)
+				.Select(AssetDatabase.GUIDToAssetPath)
+				.Where(assetPath => assetPath.Contains(filefilter))
+				.Select(asset =>
+				 {
+					 var packageInfo = UnityEditor.PackageManager.PackageInfo.FindForAssetPath(asset);
+					 return Normalize(packageInfo.resolvedPath + asset.Substring(packageInfo.assetPath.Length));
+				 })
+				.ToArray();
+		}
+
+		public static string GetAssetFullPath(string asset)
+		{
+			var basePath = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
+			return Path.GetFullPath(Path.Combine(basePath, Normalize(asset)));
+		}
+
+		public static string Normalize(string path)
+		{
+			if (string.IsNullOrEmpty(path))
+				return path;
+
+			if (Path.DirectorySeparatorChar == WinSeparator)
+				path = path.Replace(UnixSeparator, WinSeparator);
+			if (Path.DirectorySeparatorChar == UnixSeparator)
+				path = path.Replace(WinSeparator, UnixSeparator);
+
+			return path.Replace(string.Concat(WinSeparator, WinSeparator), WinSeparator.ToString());
+		}
+
+		internal static bool IsFileInProjectDirectory(string fileName)
+		{
+			var basePath = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
+			fileName = Normalize(fileName);
+
+			if (!Path.IsPathRooted(fileName))
+				fileName = Path.Combine(basePath, fileName);
+
+			return string.Equals(Path.GetDirectoryName(fileName), basePath, StringComparison.OrdinalIgnoreCase);
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/FileUtility.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6f1dc05fb6e7d3e4f89ae9ca482735be
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Image.cs

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.IO;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	public sealed class Image : IDisposable {
+
+		long position;
+		Stream stream;
+
+		Image (Stream stream)
+		{
+			this.stream = stream;
+			this.position = stream.Position;
+			this.stream.Position = 0;
+		}
+
+		bool Advance (int length)
+		{
+			if (stream.Position + length >= stream.Length)
+				return false;
+
+			stream.Seek (length, SeekOrigin.Current);
+			return true;
+		}
+
+		bool MoveTo (uint position)
+		{
+			if (position >= stream.Length)
+				return false;
+
+			stream.Position = position;
+			return true;
+		}
+
+		void IDisposable.Dispose ()
+		{
+			stream.Position = position;
+		}
+
+		ushort ReadUInt16 ()
+		{
+			return (ushort) (stream.ReadByte ()
+				| (stream.ReadByte () << 8));
+		}
+
+		uint ReadUInt32 ()
+		{
+			return (uint) (stream.ReadByte ()
+				| (stream.ReadByte () << 8)
+				| (stream.ReadByte () << 16)
+				| (stream.ReadByte () << 24));
+		}
+
+		bool IsManagedAssembly ()
+		{
+			if (stream.Length < 318)
+				return false;
+			if (ReadUInt16 () != 0x5a4d)
+				return false;
+			if (!Advance (58))
+				return false;
+			if (!MoveTo (ReadUInt32 ()))
+				return false;
+			if (ReadUInt32 () != 0x00004550)
+				return false;
+			if (!Advance (20))
+				return false;
+			if (!Advance (ReadUInt16 () == 0x20b ? 222 : 206))
+				return false;
+
+			return ReadUInt32 () != 0;
+		}
+
+		public static bool IsAssembly (string file)
+		{
+			if (file == null)
+				throw new ArgumentNullException ("file");
+
+			using (var stream = new FileStream (file, FileMode.Open, FileAccess.Read, FileShare.Read))
+				return IsAssembly (stream);
+		}
+
+		public static bool IsAssembly (Stream stream)
+		{
+			if (stream == null)
+				throw new ArgumentNullException (nameof(stream));
+			if (!stream.CanRead)
+				throw new ArgumentException (nameof(stream));
+			if (!stream.CanSeek)
+				throw new ArgumentException (nameof(stream));
+
+			using (var image = new Image (stream))
+				return image.IsManagedAssembly ();
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Image.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e6c7ea7c059fb547b6723aaf225900b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2f820130c86c28547a0f1a2f4c73155b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/Deserializer.cs

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System.IO;
+using System.Text;
+
+namespace Microsoft.Unity.VisualStudio.Editor.Messaging
+{
+	internal class Deserializer
+	{
+		private readonly BinaryReader _reader;
+
+		// Max UDP packet size is 65507
+		private const int MaxStringLength = 65000;
+
+		public Deserializer(byte[] buffer)
+		{
+			_reader = new BinaryReader(new MemoryStream(buffer));
+		}
+
+		public int ReadInt32()
+		{
+			return _reader.ReadInt32();
+		}
+
+		public string ReadString()
+		{
+			var length = ReadInt32();
+			return length > 0 && length <= MaxStringLength
+				? Encoding.UTF8.GetString(_reader.ReadBytes(length))
+				: "";
+		}
+
+		public bool CanReadMore()
+		{
+			return _reader.BaseStream.Position < _reader.BaseStream.Length;
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/Deserializer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3eda7a83649158546826efb3ffe6c1e3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/ExceptionEventArgs.cs

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+
+namespace Microsoft.Unity.VisualStudio.Editor.Messaging
+{
+	internal class ExceptionEventArgs
+	{
+		public Exception Exception { get; }
+
+		public ExceptionEventArgs(Exception exception)
+		{
+			Exception = exception;
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/ExceptionEventArgs.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 917a51fff055ce547b4ad1215321f3da
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/Message.cs

@@ -0,0 +1,23 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System.Globalization;
+using System.Net;
+
+namespace Microsoft.Unity.VisualStudio.Editor.Messaging
+{
+	internal class Message
+	{
+		public MessageType Type { get; set; }
+
+		public string Value { get; set; }
+
+		public IPEndPoint Origin { get; set; }
+
+		public override string ToString()
+		{
+			return string.Format(CultureInfo.InvariantCulture, "<Message type:{0} value:{1}>", Type, Value);
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/Message.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: de1c9ea7b82c9904d9e5fba2ee70a998
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/MessageEventArgs.cs

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+namespace Microsoft.Unity.VisualStudio.Editor.Messaging
+{
+	internal class MessageEventArgs
+	{
+		public Message Message
+		{
+			get;
+		}
+
+		public MessageEventArgs(Message message)
+		{
+			Message = message;
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/MessageEventArgs.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 275143c81d816ef4286fdc67aabc20c8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/MessageType.cs

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+namespace Microsoft.Unity.VisualStudio.Editor.Messaging
+{
+	internal enum MessageType
+	{
+		None = 0,
+
+		Ping,
+		Pong,
+
+		Play,
+		Stop,
+		Pause,
+		Unpause,
+
+		Build,
+		Refresh,
+
+		Info,
+		Error,
+		Warning,
+
+		Open,
+		Opened,
+
+		Version,
+		UpdatePackage,
+
+		ProjectPath,
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/MessageType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f3edbdc86577af648a23263aa75161e1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/Messenger.cs

@@ -0,0 +1,176 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Microsoft.Unity.VisualStudio.Editor.Messaging
+{
+	internal class Messager : IDisposable
+	{
+		public event EventHandler<MessageEventArgs> ReceiveMessage;
+		public event EventHandler<ExceptionEventArgs> MessagerException;
+
+		private readonly UdpSocket _socket;
+		private readonly object _disposeLock = new object();
+		private bool _disposed;
+
+		protected Messager(int port)
+		{
+			_socket = new UdpSocket();
+			_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, false);
+			_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
+			_socket.Bind(IPAddress.Any, port);
+
+			BeginReceiveMessage();
+		}
+
+		private void BeginReceiveMessage()
+		{
+			var buffer = new byte[UdpSocket.BufferSize];
+			var any = UdpSocket.Any();
+
+			try
+			{
+				lock (_disposeLock)
+				{
+					if (_disposed)
+						return;
+
+					_socket.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref any, ReceiveMessageCallback, buffer);
+				}
+			}
+			catch (SocketException se)
+			{
+				MessagerException?.Invoke(this, new ExceptionEventArgs(se));
+
+				BeginReceiveMessage();
+			}
+			catch (ObjectDisposedException)
+			{
+			}
+		}
+
+		private void ReceiveMessageCallback(IAsyncResult result)
+		{
+			try
+			{
+				var endPoint = UdpSocket.Any();
+
+				lock (_disposeLock)
+				{
+					if (_disposed)
+						return;
+
+					_socket.EndReceiveFrom(result, ref endPoint);
+				}
+
+				var message = DeserializeMessage(UdpSocket.BufferFor(result));
+				if (message != null)
+				{
+					message.Origin = (IPEndPoint)endPoint;
+					ReceiveMessage?.Invoke(this, new MessageEventArgs(message));
+				}
+			}
+			catch (ObjectDisposedException)
+			{
+				return;
+			}
+			catch (Exception e)
+			{
+				RaiseMessagerException(e);
+			}
+
+			BeginReceiveMessage();
+		}
+
+		private void RaiseMessagerException(Exception e)
+		{
+			MessagerException?.Invoke(this, new ExceptionEventArgs(e));
+		}
+
+		private static Message MessageFor(MessageType type, string value)
+		{
+			return new Message { Type = type, Value = value };
+		}
+
+		public void SendMessage(IPEndPoint target, MessageType type, string value = "")
+		{
+			var message = MessageFor(type, value);
+			var buffer = SerializeMessage(message);
+
+			try
+			{
+				lock (_disposeLock)
+				{
+					if (_disposed)
+						return;
+
+					_socket.BeginSendTo(buffer, 0, Math.Min(buffer.Length, UdpSocket.BufferSize), SocketFlags.None, target, SendMessageCallback, null);
+				}
+			}
+			catch (SocketException se)
+			{
+				MessagerException?.Invoke(this, new ExceptionEventArgs(se));
+			}
+		}
+
+		private void SendMessageCallback(IAsyncResult result)
+		{
+			try
+			{
+				lock (_disposeLock)
+				{
+					if (_disposed)
+						return;
+
+					_socket.EndSendTo(result);
+				}
+			}
+			catch (SocketException se)
+			{
+				MessagerException?.Invoke(this, new ExceptionEventArgs(se));
+			}
+			catch (ObjectDisposedException)
+			{
+			}
+		}
+
+		private static byte[] SerializeMessage(Message message)
+		{
+			var serializer = new Serializer();
+			serializer.WriteInt32((int)message.Type);
+			serializer.WriteString(message.Value);
+
+			return serializer.Buffer();
+		}
+
+		private static Message DeserializeMessage(byte[] buffer)
+		{
+			if (buffer.Length < 4)
+				return null;
+
+			var deserializer = new Deserializer(buffer);
+			var type = (MessageType)deserializer.ReadInt32();
+			var value = deserializer.ReadString();
+
+			return new Message { Type = type, Value = value };
+		}
+
+		public static Messager BindTo(int port)
+		{
+			return new Messager(port);
+		}
+
+		public void Dispose()
+		{
+			lock (_disposeLock)
+			{
+				_disposed = true;
+				_socket.Close();
+			}
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/Messenger.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e249ae353801f043a6e4173410c6152
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/Serializer.cs

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System.IO;
+using System.Text;
+
+namespace Microsoft.Unity.VisualStudio.Editor.Messaging
+{
+	internal class Serializer
+	{
+		private readonly MemoryStream _stream;
+		private readonly BinaryWriter _writer;
+
+		public Serializer()
+		{
+			_stream = new MemoryStream();
+			_writer = new BinaryWriter(_stream);
+		}
+
+		public void WriteInt32(int i)
+		{
+			_writer.Write(i);
+		}
+
+		public void WriteString(string s)
+		{
+			var bytes = Encoding.UTF8.GetBytes(s ?? "");
+			if (bytes.Length > 0)
+			{
+				_writer.Write(bytes.Length);
+				_writer.Write(bytes);
+			}
+			else
+				_writer.Write(0);
+		}
+
+		public byte[] Buffer()
+		{
+			return _stream.ToArray();
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/Serializer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 369c09afe05d2c346af49faef943c773
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/UdpSocket.cs

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Microsoft.Unity.VisualStudio.Editor.Messaging
+{
+	internal class UdpSocket : Socket
+	{
+		public const int BufferSize = 1024 * 8;
+
+		internal UdpSocket()
+			: base(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
+		{
+			SetIOControl();
+		}
+
+		public void Bind(IPAddress address, int port = 0)
+		{
+			Bind(new IPEndPoint(address ?? IPAddress.Any, port));
+		}
+
+		private void SetIOControl()
+		{
+			if (!VisualStudioEditor.IsWindows)
+				return;
+
+			try
+			{
+				const int SIO_UDP_CONNRESET = -1744830452;
+
+				IOControl(SIO_UDP_CONNRESET, new byte[] { 0 }, new byte[0]);
+			}
+			catch
+			{
+				// fallback
+			}
+		}
+
+		public static byte[] BufferFor(IAsyncResult result)
+		{
+			return (byte[])result.AsyncState;
+		}
+
+		public static EndPoint Any()
+		{
+			return new IPEndPoint(IPAddress.Any, 0);
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Messaging/UdpSocket.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 38cb3a4a17d2cfd41926da95ce675934
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Plugins.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1e5abb64fdd0542b38f4dc1b60343e8a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Plugins/AppleEventIntegration.bundle.meta

@@ -0,0 +1,28 @@
+fileFormatVersion: 2
+guid: a20df6e3467b24ed5b49c857ce39e096
+folderAsset: yes
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Plugins/AppleEventIntegration.bundle/Contents.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 058b02c03ea09473aab4dc5fc50af1ef
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Plugins/AppleEventIntegration.bundle/Contents/Info.plist

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>BuildMachineOSBuild</key>
+	<string>19B88</string>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>AppleEventIntegration</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.unity.visualstudio.AppleEventIntegration</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>AppleEventIntegration</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSupportedPlatforms</key>
+	<array>
+		<string>MacOSX</string>
+	</array>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>DTCompiler</key>
+	<string>com.apple.compilers.llvm.clang.1_0</string>
+	<key>DTPlatformBuild</key>
+	<string>10E125</string>
+	<key>DTPlatformVersion</key>
+	<string>GM</string>
+	<key>DTSDKBuild</key>
+	<string>18E219</string>
+	<key>DTSDKName</key>
+	<string>macosx10.14</string>
+	<key>DTXcode</key>
+	<string>1020</string>
+	<key>DTXcodeBuild</key>
+	<string>10E125</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright © 2019 Unity. All rights reserved.</string>
+</dict>
+</plist>

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Plugins/AppleEventIntegration.bundle/Contents/Info.plist.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 680cf1008b4284eddbb82ec4d76644a1
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Plugins/AppleEventIntegration.bundle/Contents/MacOS.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ba4355216f6c44abbb17503872c42c97
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Plugins/AppleEventIntegration.bundle/Contents/MacOS/AppleEventIntegration.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4e53c7f7b5c7e4a3d890cb596ed56c22
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8beeeeebc0857854d8b4e2c2895dd7a9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/AssemblyNameProvider.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEditor.PackageManager;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+    public interface IAssemblyNameProvider
+    {
+        string[] ProjectSupportedExtensions { get; }
+        string ProjectGenerationRootNamespace { get; }
+        ProjectGenerationFlag ProjectGenerationFlag { get; }
+
+        string GetAssemblyNameFromScriptPath(string path);
+		string GetAssemblyName(string assemblyOutputPath, string assemblyName);
+		bool IsInternalizedPackagePath(string path);
+        IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution);
+        IEnumerable<string> GetAllAssetPaths();
+        UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath);
+        ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories);
+        void ToggleProjectGeneration(ProjectGenerationFlag preference);
+    }
+
+    public class AssemblyNameProvider : IAssemblyNameProvider
+    {
+        ProjectGenerationFlag m_ProjectGenerationFlag = (ProjectGenerationFlag)EditorPrefs.GetInt("unity_project_generation_flag", 0);
+
+        public string[] ProjectSupportedExtensions => EditorSettings.projectGenerationUserExtensions;
+
+        public string ProjectGenerationRootNamespace => EditorSettings.projectGenerationRootNamespace;
+
+        public ProjectGenerationFlag ProjectGenerationFlag
+        {
+            get => m_ProjectGenerationFlag;
+            private set
+            {
+                EditorPrefs.SetInt("unity_project_generation_flag", (int)value);
+                m_ProjectGenerationFlag = value;
+            }
+        }
+
+        public string GetAssemblyNameFromScriptPath(string path)
+        {
+            return CompilationPipeline.GetAssemblyNameFromScriptPath(path);
+        }
+
+        public IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution)
+        {
+            foreach (var assembly in CompilationPipeline.GetAssemblies())
+            {
+                if (assembly.sourceFiles.Any(shouldFileBePartOfSolution))
+                {
+					yield return new Assembly(assembly.name, @"Temp\Bin\Debug\", assembly.sourceFiles, new[] { "DEBUG", "TRACE" }.Concat(assembly.defines).Concat(EditorUserBuildSettings.activeScriptCompilationDefines).ToArray(), assembly.assemblyReferences, assembly.compiledAssemblyReferences, assembly.flags)
+					{ 
+						compilerOptions =
+                        {
+                            ResponseFiles = assembly.compilerOptions.ResponseFiles,
+                            AllowUnsafeCode = assembly.compilerOptions.AllowUnsafeCode,
+                            ApiCompatibilityLevel = assembly.compilerOptions.ApiCompatibilityLevel
+                        }
+                    };
+                }
+            }
+
+            if (ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.PlayerAssemblies))
+            {
+                foreach (var assembly in CompilationPipeline.GetAssemblies(AssembliesType.Player).Where(assembly => assembly.sourceFiles.Any(shouldFileBePartOfSolution)))
+                {
+					yield return new Assembly(assembly.name, @"Temp\Bin\Debug\Player\", assembly.sourceFiles, new[] { "DEBUG", "TRACE" }.Concat(assembly.defines).ToArray(), assembly.assemblyReferences, assembly.compiledAssemblyReferences, assembly.flags)
+					{
+                        compilerOptions =
+                        {
+                            ResponseFiles = assembly.compilerOptions.ResponseFiles,
+                            AllowUnsafeCode = assembly.compilerOptions.AllowUnsafeCode,
+                            ApiCompatibilityLevel = assembly.compilerOptions.ApiCompatibilityLevel
+                        }
+                    };
+                }
+            }
+        }
+
+        public string GetCompileOutputPath(string assemblyName)
+        {
+            if (assemblyName.EndsWith(".Player", StringComparison.Ordinal))
+            {
+                return @"Temp\Bin\Debug\Player\";
+            }
+            else
+            {
+                return @"Temp\Bin\Debug\";
+            }
+        }
+
+        public IEnumerable<string> GetAllAssetPaths()
+        {
+            return AssetDatabase.GetAllAssetPaths();
+        }
+
+        public UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath)
+        {
+            return UnityEditor.PackageManager.PackageInfo.FindForAssetPath(assetPath);
+        }
+
+        public bool IsInternalizedPackagePath(string path)
+        {
+            if (string.IsNullOrEmpty(path.Trim()))
+            {
+                return false;
+            }
+            var packageInfo = FindForAssetPath(path);
+            if (packageInfo == null)
+            {
+                return false;
+            }
+            var packageSource = packageInfo.source;
+            switch (packageSource)
+            {
+                case PackageSource.Embedded:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Embedded);
+                case PackageSource.Registry:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Registry);
+                case PackageSource.BuiltIn:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.BuiltIn);
+                case PackageSource.Unknown:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Unknown);
+                case PackageSource.Local:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Local);
+                case PackageSource.Git:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Git);
+                case PackageSource.LocalTarball:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.LocalTarBall);
+            }
+
+            return false;
+        }
+
+        public ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories)
+        {
+            return CompilationPipeline.ParseResponseFile(
+              responseFilePath,
+              projectDirectory,
+              systemReferenceDirectories
+            );
+        }
+
+        public void ToggleProjectGeneration(ProjectGenerationFlag preference)
+        {
+            if (ProjectGenerationFlag.HasFlag(preference))
+            {
+                ProjectGenerationFlag ^= preference;
+            }
+            else
+            {
+                ProjectGenerationFlag |= preference;
+            }
+        }
+
+        public void ResetProjectGenerationFlag()
+        {
+            ProjectGenerationFlag = ProjectGenerationFlag.None;
+        }
+
+		public string GetAssemblyName(string assemblyOutputPath, string assemblyName)
+		{
+			return assemblyOutputPath.EndsWith(@"\Player\", StringComparison.Ordinal) ? assemblyName + ".Player" : assemblyName;
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/AssemblyNameProvider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 57537f08f8e923f488e4aadabb831c9b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/FileIOProvider.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using System.Text;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+    public interface IFileIO
+    {
+        bool Exists(string fileName);
+
+        string ReadAllText(string fileName);
+        void WriteAllText(string fileName, string content);
+    }
+
+    class FileIOProvider : IFileIO
+    {
+        public bool Exists(string fileName)
+        {
+            return File.Exists(fileName);
+        }
+
+        public string ReadAllText(string fileName)
+        {
+            return File.ReadAllText(fileName);
+        }
+
+        public void WriteAllText(string fileName, string content)
+        {
+            File.WriteAllText(fileName, content, Encoding.UTF8);
+        }
+    }
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/FileIOProvider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ec80b1fb8938b3b4ab442d10390c5315
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/GUIDProvider.cs

@@ -0,0 +1,21 @@
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+    public interface IGUIDGenerator
+    {
+        string ProjectGuid(string projectName, string assemblyName);
+        string SolutionGuid(string projectName, ScriptingLanguage scriptingLanguage);
+    }
+
+    class GUIDProvider : IGUIDGenerator
+    {
+        public string ProjectGuid(string projectName, string assemblyName)
+        {
+            return SolutionGuidGenerator.GuidForProject(projectName + assemblyName);
+        }
+
+        public string SolutionGuid(string projectName, ScriptingLanguage scriptingLanguage)
+        {
+            return SolutionGuidGenerator.GuidForSolution(projectName, scriptingLanguage);
+        }
+    }
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/GUIDProvider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7652904b1008e324fb7cfb952ea87656
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/ProjectGeneration.cs

@@ -0,0 +1,921 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Unity Technologies.
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using SR = System.Reflection;
+using System.Security;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.RegularExpressions;
+using Unity.CodeEditor;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEditor.PackageManager;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+    public enum ScriptingLanguage
+    {
+        None,
+        CSharp
+    }
+
+    public interface IGenerator
+    {
+        bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles);
+        void Sync();
+        bool HasSolutionBeenGenerated();
+        bool IsSupportedFile(string path);
+        string SolutionFile();
+        string ProjectDirectory { get; }
+        IAssemblyNameProvider AssemblyNameProvider { get; }
+    }
+
+    public class ProjectGeneration : IGenerator
+    {
+        public static readonly string MSBuildNamespaceUri = "http://schemas.microsoft.com/developer/msbuild/2003";
+
+        const string k_WindowsNewline = "\r\n";
+
+        string m_SolutionProjectEntryTemplate = @"Project(""{{{0}}}"") = ""{1}"", ""{2}"", ""{{{3}}}""{4}EndProject";
+
+        string m_SolutionProjectConfigurationTemplate = string.Join("\r\n",
+            @"        {{{0}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU",
+            @"        {{{0}}}.Debug|Any CPU.Build.0 = Debug|Any CPU",
+            @"        {{{0}}}.Release|Any CPU.ActiveCfg = Release|Any CPU",
+            @"        {{{0}}}.Release|Any CPU.Build.0 = Release|Any CPU").Replace("    ", "\t");
+
+        static readonly string[] k_ReimportSyncExtensions = { ".dll", ".asmdef" };
+
+        static readonly Regex k_ScriptReferenceExpression = new Regex(
+            @"^Library.ScriptAssemblies.(?<dllname>(?<project>.*)\.dll$)",
+            RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        string[] m_ProjectSupportedExtensions = new string[0];
+        string[] m_BuiltinSupportedExtensions = new string[0];
+
+        public string ProjectDirectory { get; }
+
+        readonly string m_ProjectName;
+        readonly IAssemblyNameProvider m_AssemblyNameProvider;
+        readonly IFileIO m_FileIOProvider;
+        readonly IGUIDGenerator m_GUIDGenerator;
+        VisualStudioInstallation m_CurrentInstallation;
+        public IAssemblyNameProvider AssemblyNameProvider => m_AssemblyNameProvider;
+
+        public ProjectGeneration() : this(Directory.GetParent(Application.dataPath).FullName)
+        {
+        }
+
+        public ProjectGeneration(string tempDirectory) : this(tempDirectory, new AssemblyNameProvider(), new FileIOProvider(), new GUIDProvider())
+        {
+        }
+
+        public ProjectGeneration(string tempDirectory, IAssemblyNameProvider assemblyNameProvider, IFileIO fileIoProvider, IGUIDGenerator guidGenerator)
+        {
+            ProjectDirectory = tempDirectory.Replace('\\', '/');
+            m_ProjectName = Path.GetFileName(ProjectDirectory);
+            m_AssemblyNameProvider = assemblyNameProvider;
+            m_FileIOProvider = fileIoProvider;
+            m_GUIDGenerator = guidGenerator;
+
+            SetupProjectSupportedExtensions();
+        }
+
+        /// <summary>
+        /// Syncs the scripting solution if any affected files are relevant.
+        /// </summary>
+        /// <returns>
+        /// Whether the solution was synced.
+        /// </returns>
+        /// <param name='affectedFiles'>
+        /// A set of files whose status has changed
+        /// </param>
+        /// <param name="reimportedFiles">
+        /// A set of files that got reimported
+        /// </param>
+        public bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
+        {
+            SetupProjectSupportedExtensions();
+
+            // Don't sync if we haven't synced before
+            if (HasSolutionBeenGenerated() && HasFilesBeenModified(affectedFiles, reimportedFiles))
+            {
+                Sync();
+                return true;
+            }
+            return false;
+        }
+
+        bool HasFilesBeenModified(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
+        {
+            return affectedFiles.Any(ShouldFileBePartOfSolution) || reimportedFiles.Any(ShouldSyncOnReimportedAsset);
+        }
+
+        static bool ShouldSyncOnReimportedAsset(string asset)
+        {
+            return k_ReimportSyncExtensions.Contains(new FileInfo(asset).Extension);
+        }
+
+        private void RefreshCurrentInstallation()
+        {
+            var editor = CodeEditor.CurrentEditor as VisualStudioEditor;
+            editor?.TryGetVisualStudioInstallationForPath(CodeEditor.CurrentEditorInstallation, out m_CurrentInstallation);
+        }
+
+        public void Sync()
+        {
+            // We need the exact VS version/capabilities to tweak project generation (analyzers/langversion)
+            RefreshCurrentInstallation();
+
+            SetupProjectSupportedExtensions();
+            var externalCodeAlreadyGeneratedProjects = OnPreGeneratingCSProjectFiles();
+
+            if (!externalCodeAlreadyGeneratedProjects)
+            {
+                GenerateAndWriteSolutionAndProjects();
+            }
+            OnGeneratedCSProjectFiles();
+        }
+
+        public bool HasSolutionBeenGenerated()
+        {
+            return m_FileIOProvider.Exists(SolutionFile());
+        }
+
+        void SetupProjectSupportedExtensions()
+        {
+            m_ProjectSupportedExtensions = m_AssemblyNameProvider.ProjectSupportedExtensions;
+            m_BuiltinSupportedExtensions = EditorSettings.projectGenerationBuiltinExtensions;
+        }
+
+        bool ShouldFileBePartOfSolution(string file)
+        {
+            // Exclude files coming from packages except if they are internalized.
+            if (m_AssemblyNameProvider.IsInternalizedPackagePath(file))
+            {
+                return false;
+            }
+
+            return IsSupportedFile(file);
+        }
+
+        static string GetExtensionWithoutDot(string path)
+        {
+            // Prevent re-processing and information loss
+            if (!Path.HasExtension(path))
+                return path;
+
+            return Path
+                .GetExtension(path)
+                .TrimStart('.')
+                .ToLower();
+        }
+
+        public bool IsSupportedFile(string path)
+        {
+            var extension = GetExtensionWithoutDot(path);
+
+            // Dll's are not scripts but still need to be included
+            if (extension == "dll")
+                return true;
+
+            if (extension == "asmdef")
+                return true;
+
+            if (m_BuiltinSupportedExtensions.Contains(extension))
+                return true;
+
+            if (m_ProjectSupportedExtensions.Contains(extension))
+                return true;
+
+            return false;
+        }
+
+        static ScriptingLanguage ScriptingLanguageFor(Assembly assembly)
+        {
+            var files = assembly.sourceFiles;
+
+            if (files.Length == 0)
+                return ScriptingLanguage.None;
+
+            return ScriptingLanguageFor(files[0]);
+        }
+
+        static ScriptingLanguage ScriptingLanguageFor(string path)
+        {
+            return GetExtensionWithoutDot(path) == "cs" ? ScriptingLanguage.CSharp : ScriptingLanguage.None;
+        }
+
+        public void GenerateAndWriteSolutionAndProjects()
+        {
+            // Only synchronize assemblies that have associated source files and ones that we actually want in the project.
+            // This also filters out DLLs coming from .asmdef files in packages.
+            var assemblies = m_AssemblyNameProvider.GetAssemblies(ShouldFileBePartOfSolution);
+
+            var allAssetProjectParts = GenerateAllAssetProjectParts();
+
+            var assemblyList = assemblies.ToList();
+
+            SyncSolution(assemblyList);
+            var allProjectAssemblies = RelevantAssembliesForMode(assemblyList).ToList();
+            foreach (Assembly assembly in allProjectAssemblies)
+            {
+                var responseFileData = ParseResponseFileData(assembly);
+                SyncProject(assembly, allAssetProjectParts, responseFileData, allProjectAssemblies);
+            }
+        }
+
+        IEnumerable<ResponseFileData> ParseResponseFileData(Assembly assembly)
+        {
+            var systemReferenceDirectories = CompilationPipeline.GetSystemAssemblyDirectories(assembly.compilerOptions.ApiCompatibilityLevel);
+
+            Dictionary<string, ResponseFileData> responseFilesData = assembly.compilerOptions.ResponseFiles.ToDictionary(x => x, x => m_AssemblyNameProvider.ParseResponseFile(
+                x,
+                ProjectDirectory,
+                systemReferenceDirectories
+            ));
+
+            Dictionary<string, ResponseFileData> responseFilesWithErrors = responseFilesData.Where(x => x.Value.Errors.Any())
+                .ToDictionary(x => x.Key, x => x.Value);
+
+            if (responseFilesWithErrors.Any())
+            {
+                foreach (var error in responseFilesWithErrors)
+                foreach (var valueError in error.Value.Errors)
+                {
+                    Debug.LogError($"{error.Key} Parse Error : {valueError}");
+                }
+            }
+
+            return responseFilesData.Select(x => x.Value);
+        }
+
+        Dictionary<string, string> GenerateAllAssetProjectParts()
+        {
+            Dictionary<string, StringBuilder> stringBuilders = new Dictionary<string, StringBuilder>();
+
+            foreach (string asset in m_AssemblyNameProvider.GetAllAssetPaths())
+            {
+                // Exclude files coming from packages except if they are internalized.
+                if (m_AssemblyNameProvider.IsInternalizedPackagePath(asset))
+                {
+                    continue;
+                }
+
+                if (IsSupportedFile(asset) && ScriptingLanguage.None == ScriptingLanguageFor(asset))
+                {
+                    // Find assembly the asset belongs to by adding script extension and using compilation pipeline.
+                    var assemblyName = m_AssemblyNameProvider.GetAssemblyNameFromScriptPath(asset + ".cs");
+
+                    if (string.IsNullOrEmpty(assemblyName))
+                    {
+                        continue;
+                    }
+
+                    assemblyName = Path.GetFileNameWithoutExtension(assemblyName);
+
+                    if (!stringBuilders.TryGetValue(assemblyName, out var projectBuilder))
+                    {
+                        projectBuilder = new StringBuilder();
+                        stringBuilders[assemblyName] = projectBuilder;
+                    }
+
+                    projectBuilder.Append("     <None Include=\"").Append(EscapedRelativePathFor(asset)).Append("\" />").Append(k_WindowsNewline);
+                }
+            }
+
+            var result = new Dictionary<string, string>();
+
+            foreach (var entry in stringBuilders)
+                result[entry.Key] = entry.Value.ToString();
+
+            return result;
+        }
+
+        void SyncProject(
+            Assembly assembly,
+            Dictionary<string, string> allAssetsProjectParts,
+            IEnumerable<ResponseFileData> responseFilesData,
+            List<Assembly> allProjectAssemblies)
+        {
+            SyncProjectFileIfNotChanged(ProjectFile(assembly), ProjectText(assembly, allAssetsProjectParts, responseFilesData, allProjectAssemblies));
+        }
+
+        void SyncProjectFileIfNotChanged(string path, string newContents)
+        {
+            if (Path.GetExtension(path) == ".csproj")
+            {
+                newContents = OnGeneratedCSProject(path, newContents);
+            }
+
+            SyncFileIfNotChanged(path, newContents);
+        }
+
+        void SyncSolutionFileIfNotChanged(string path, string newContents)
+        {
+            newContents = OnGeneratedSlnSolution(path, newContents);
+
+            SyncFileIfNotChanged(path, newContents);
+        }
+
+        static IEnumerable<SR.MethodInfo> GetPostProcessorCallbacks(string name)
+        {
+            return TypeCache
+                .GetTypesDerivedFrom<AssetPostprocessor>()
+                .Select(t => t.GetMethod(name, SR.BindingFlags.Public | SR.BindingFlags.NonPublic | SR.BindingFlags.Static))
+                .Where(m => m!= null);
+        }
+
+        static void OnGeneratedCSProjectFiles()
+        {
+            foreach(var method in GetPostProcessorCallbacks(nameof(OnGeneratedCSProjectFiles)))
+            {
+                method.Invoke(null, Array.Empty<object>());
+            }
+        }
+
+        static bool OnPreGeneratingCSProjectFiles()
+        {
+            bool result = false;
+
+            foreach(var method in GetPostProcessorCallbacks(nameof(OnPreGeneratingCSProjectFiles)))
+            {
+                var retValue = method.Invoke(null, Array.Empty<object>());
+                if (method.ReturnType == typeof(bool))	
+                {	
+                    result |= (bool)retValue;	
+                }
+            }
+
+            return result;
+        }
+
+        static string InvokeAssetPostProcessorGenerationCallbacks(string name, string path, string content)
+        {
+            foreach(var method in GetPostProcessorCallbacks(name))
+            {
+                var args = new [] { path, content };
+                var returnValue = method.Invoke(null, args);
+                if (method.ReturnType == typeof(string))
+                {
+                    // We want to chain content update between invocations
+                    content = (string)returnValue;
+                }
+            }
+
+            return content;
+        }
+
+        static string OnGeneratedCSProject(string path, string content)
+        {
+            return InvokeAssetPostProcessorGenerationCallbacks(nameof(OnGeneratedCSProject), path, content);
+        }
+
+        static string OnGeneratedSlnSolution(string path, string content)
+        {
+            return InvokeAssetPostProcessorGenerationCallbacks(nameof(OnGeneratedSlnSolution), path, content);
+        }
+
+        void SyncFileIfNotChanged(string filename, string newContents)
+        {
+            try
+            {
+                if (m_FileIOProvider.Exists(filename) && newContents == m_FileIOProvider.ReadAllText(filename))
+                {
+                    return;
+                }
+            }
+            catch (Exception exception)
+            {
+                Debug.LogException(exception);
+            }
+
+            m_FileIOProvider.WriteAllText(filename, newContents);
+        }
+
+        string ProjectText(Assembly assembly,
+            Dictionary<string, string> allAssetsProjectParts,
+            IEnumerable<ResponseFileData> responseFilesData,
+            List<Assembly> allProjectAsemblies)
+        {
+            var projectBuilder = new StringBuilder(ProjectHeader(assembly, responseFilesData));
+            var references = new List<string>();
+
+            projectBuilder.Append(@"  <ItemGroup>").Append(k_WindowsNewline);
+            foreach (string file in assembly.sourceFiles)
+            {
+                if (!IsSupportedFile(file))
+                    continue;
+
+                var extension = Path.GetExtension(file).ToLower();
+                var fullFile = EscapedRelativePathFor(file);
+                if (".dll" != extension)
+                {
+                    projectBuilder.Append("    <Compile Include=\"").Append(fullFile).Append("\" />").Append(k_WindowsNewline);
+                }
+                else
+                {
+                    references.Add(fullFile);
+                }
+            }
+            projectBuilder.Append(@"  </ItemGroup>").Append(k_WindowsNewline);
+
+            projectBuilder.Append(@"  <ItemGroup>").Append(k_WindowsNewline);
+
+            // Append additional non-script files that should be included in project generation.
+            if (allAssetsProjectParts.TryGetValue(assembly.name, out var additionalAssetsForProject))
+                projectBuilder.Append(additionalAssetsForProject);
+
+            var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences.Select(r => r));
+            var internalAssemblyReferences = assembly.assemblyReferences
+              .Where(i => !i.sourceFiles.Any(ShouldFileBePartOfSolution)).Select(i => i.outputPath);
+            var allReferences =
+              assembly.compiledAssemblyReferences
+                .Union(responseRefs)
+                .Union(references)
+                .Union(internalAssemblyReferences);
+            foreach (var reference in allReferences)
+            {
+                string fullReference = Path.IsPathRooted(reference) ? reference : Path.Combine(ProjectDirectory, reference);
+                AppendReference(fullReference, projectBuilder);
+            }
+
+            projectBuilder.Append(@"  </ItemGroup>").Append(k_WindowsNewline);
+
+            if (0 < assembly.assemblyReferences.Length)
+            {
+                projectBuilder.Append("  <ItemGroup>").Append(k_WindowsNewline);
+                foreach (Assembly reference in assembly.assemblyReferences.Where(i => i.sourceFiles.Any(ShouldFileBePartOfSolution)))
+                {
+                    projectBuilder.Append("    <ProjectReference Include=\"").Append(reference.name).Append(GetProjectExtension()).Append("\">").Append(k_WindowsNewline);
+                    projectBuilder.Append("      <Project>{").Append(ProjectGuid(reference)).Append("}</Project>").Append(k_WindowsNewline);
+                    projectBuilder.Append("      <Name>").Append(reference.name).Append("</Name>").Append(k_WindowsNewline);
+                    projectBuilder.Append("    </ProjectReference>").Append(k_WindowsNewline);
+                }
+
+                projectBuilder.Append(@"  </ItemGroup>").Append(k_WindowsNewline);
+            }
+
+            projectBuilder.Append(ProjectFooter());
+            return projectBuilder.ToString();
+        }
+
+        static string XmlFilename(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+                return path;
+
+            path = path.Replace(@"%", "%25");
+            path = path.Replace(@";", "%3b");
+
+            return XmlEscape(path);
+        }
+
+        static string XmlEscape(string s)
+        {
+            return SecurityElement.Escape(s);
+        }
+
+        void AppendReference(string fullReference, StringBuilder projectBuilder)
+        {
+            var escapedFullPath = EscapedRelativePathFor(fullReference);
+            projectBuilder.Append("    <Reference Include=\"").Append(Path.GetFileNameWithoutExtension(escapedFullPath)).Append("\">").Append(k_WindowsNewline);
+            projectBuilder.Append("      <HintPath>").Append(escapedFullPath).Append("</HintPath>").Append(k_WindowsNewline);
+            projectBuilder.Append("    </Reference>").Append(k_WindowsNewline);
+        }
+
+        public string ProjectFile(Assembly assembly)
+        {
+			return Path.Combine(ProjectDirectory, $"{m_AssemblyNameProvider.GetAssemblyName(assembly.outputPath, assembly.name)}.csproj");
+		}
+
+        private static readonly Regex InvalidCharactersRegexPattern = new Regex(@"\?|&|\*|""|<|>|\||#|%|\^|;" + (VisualStudioEditor.IsWindows ? "" : "|:"));
+        public string SolutionFile()
+        {
+            return Path.Combine(FileUtility.Normalize(ProjectDirectory), $"{InvalidCharactersRegexPattern.Replace(m_ProjectName,"_")}.sln");
+        }
+
+        string ProjectHeader(
+            Assembly assembly,
+            IEnumerable<ResponseFileData> responseFilesData
+        )
+        {
+            var toolsVersion = "4.0";
+            var productVersion = "10.0.20506";
+            const string baseDirectory = ".";
+
+            var targetFrameworkVersion = "v4.7.1";
+            var targetLanguageVersion = "latest"; // danger: latest is not the same absolute value depending on the VS version.
+
+            if (m_CurrentInstallation != null && m_CurrentInstallation.SupportsCSharp8)
+            {
+                // Current installation is compatible with C# 8.
+                // But Unity has no support for C# 8 constructs so far, so tell the compiler to accept only C# 7.3 or lower.
+                targetLanguageVersion = "7.3";
+            }
+
+            var projectType = ProjectTypeOf(assembly.name);
+
+            var arguments = new object[]
+            {
+                toolsVersion,
+                productVersion,
+                ProjectGuid(assembly),
+                XmlFilename(FileUtility.Normalize(InternalEditorUtility.GetEngineAssemblyPath())),
+                XmlFilename(FileUtility.Normalize(InternalEditorUtility.GetEditorAssemblyPath())),
+                string.Join(";", assembly.defines.Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()),
+                MSBuildNamespaceUri,
+                assembly.name,
+                assembly.outputPath,
+                m_AssemblyNameProvider.ProjectGenerationRootNamespace,
+                targetFrameworkVersion,
+                targetLanguageVersion,
+                baseDirectory,
+                assembly.compilerOptions.AllowUnsafeCode | responseFilesData.Any(x => x.Unsafe),
+                // flavoring
+                projectType + ":" + (int)projectType,
+                EditorUserBuildSettings.activeBuildTarget + ":" + (int)EditorUserBuildSettings.activeBuildTarget,
+                Application.unityVersion,
+            };
+
+            try
+            {
+                return string.Format(GetProjectHeaderTemplate(), arguments);
+            }
+            catch (Exception)
+            {
+                throw new NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + arguments.Length);
+            }
+        }
+
+        private enum ProjectType
+        {
+            GamePlugins = 3,
+            Game = 1,
+            EditorPlugins = 7,
+            Editor = 5,
+        }
+
+        private static ProjectType ProjectTypeOf(string fileName)
+        {
+            var plugins = fileName.Contains("firstpass");
+            var editor = fileName.Contains("Editor");
+
+            if (plugins && editor)
+                return ProjectType.EditorPlugins;
+            if (plugins)
+                return ProjectType.GamePlugins;
+            if (editor)
+                return ProjectType.Editor;
+
+            return ProjectType.Game;
+        }
+
+        static string GetSolutionText()
+        {
+            return string.Join("\r\n",
+            @"",
+            @"Microsoft Visual Studio Solution File, Format Version {0}",
+            @"# Visual Studio {1}",
+            @"{2}",
+            @"Global",
+            @"    GlobalSection(SolutionConfigurationPlatforms) = preSolution",
+            @"        Debug|Any CPU = Debug|Any CPU",
+            @"        Release|Any CPU = Release|Any CPU",
+            @"    EndGlobalSection",
+            @"    GlobalSection(ProjectConfigurationPlatforms) = postSolution",
+            @"{3}",
+            @"    EndGlobalSection",
+            @"{4}",
+            @"EndGlobal",
+            @"").Replace("    ", "\t");
+        }
+
+        static string GetProjectFooterTemplate()
+        {
+            return string.Join("\r\n",
+            @"  <Import Project=""$(MSBuildToolsPath)\Microsoft.CSharp.targets"" />",
+            @"  <Target Name=""GenerateTargetFrameworkMonikerAttribute"" />",
+            @"  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.",
+            @"       Other similar extension points exist, see Microsoft.Common.targets.",
+            @"  <Target Name=""BeforeBuild"">",
+            @"  </Target>",
+            @"  <Target Name=""AfterBuild"">",
+            @"  </Target>",
+            @"  -->",
+            @"</Project>",
+            @"");
+        }
+
+        string GetProjectHeaderTemplate()
+        {
+            var header = new[]
+            {
+                @"<?xml version=""1.0"" encoding=""utf-8""?>",
+                @"<Project ToolsVersion=""{0}"" DefaultTargets=""Build"" xmlns=""{6}"">",
+                @"  <PropertyGroup>",
+                @"    <LangVersion>{11}</LangVersion>",
+                @"  </PropertyGroup>",
+                @"  <PropertyGroup>",
+                @"    <Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>",
+                @"    <Platform Condition="" '$(Platform)' == '' "">AnyCPU</Platform>",
+                @"    <ProductVersion>{1}</ProductVersion>",
+                @"    <SchemaVersion>2.0</SchemaVersion>",
+                @"    <RootNamespace>{9}</RootNamespace>",
+                @"    <ProjectGuid>{{{2}}}</ProjectGuid>",
+                @"    <OutputType>Library</OutputType>",
+                @"    <AppDesignerFolder>Properties</AppDesignerFolder>",
+                @"    <AssemblyName>{7}</AssemblyName>",
+                @"    <TargetFrameworkVersion>{10}</TargetFrameworkVersion>",
+                @"    <FileAlignment>512</FileAlignment>",
+                @"    <BaseDirectory>{12}</BaseDirectory>",
+                @"  </PropertyGroup>",
+                @"  <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "">",
+                @"    <DebugSymbols>true</DebugSymbols>",
+                @"    <DebugType>full</DebugType>",
+                @"    <Optimize>false</Optimize>",
+                @"    <OutputPath>{8}</OutputPath>",
+                @"    <DefineConstants>{5}</DefineConstants>",
+                @"    <ErrorReport>prompt</ErrorReport>",
+                @"    <WarningLevel>4</WarningLevel>",
+                @"    <NoWarn>0169</NoWarn>",
+                @"    <AllowUnsafeBlocks>{13}</AllowUnsafeBlocks>",
+                @"  </PropertyGroup>",
+                @"  <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "">",
+                @"    <DebugType>pdbonly</DebugType>",
+                @"    <Optimize>true</Optimize>",
+                @"    <OutputPath>Temp\bin\Release\</OutputPath>",
+                @"    <ErrorReport>prompt</ErrorReport>",
+                @"    <WarningLevel>4</WarningLevel>",
+                @"    <NoWarn>0169</NoWarn>",
+                @"    <AllowUnsafeBlocks>{13}</AllowUnsafeBlocks>",
+                @"  </PropertyGroup>"
+            };
+
+            var forceExplicitReferences = new[]
+            {
+                @"  <PropertyGroup>",
+                @"    <NoConfig>true</NoConfig>",
+                @"    <NoStdLib>true</NoStdLib>",
+                @"    <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>",
+                @"    <ImplicitlyExpandNETStandardFacades>false</ImplicitlyExpandNETStandardFacades>",
+                @"    <ImplicitlyExpandDesignTimeFacades>false</ImplicitlyExpandDesignTimeFacades>",
+                @"  </PropertyGroup>"
+            };
+
+            var flavoring = new[]
+            {
+                @"  <PropertyGroup>",
+                @"    <ProjectTypeGuids>{{E097FAD1-6243-4DAD-9C02-E9B9EFC3FFC1}};{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}</ProjectTypeGuids>",
+                @"    <UnityProjectGenerator>Package</UnityProjectGenerator>",
+                @"    <UnityProjectType>{14}</UnityProjectType>",
+                @"    <UnityBuildTarget>{15}</UnityBuildTarget>",
+                @"    <UnityVersion>{16}</UnityVersion>",
+                @"  </PropertyGroup>"
+            };
+
+            var footer = new[]
+            {
+                @""
+            };
+
+            var lines = header
+                .Concat(forceExplicitReferences)
+                .Concat(flavoring)
+                .ToList();
+
+            // Only add analyzer block for compatible Visual Studio
+            if (m_CurrentInstallation != null && m_CurrentInstallation.SupportsAnalyzers)
+            {
+                var analyzers = m_CurrentInstallation.GetAnalyzers();
+                if (analyzers != null && analyzers.Length > 0)
+                {
+                    lines.Add(@"  <ItemGroup>");
+                    foreach (var analyzer in analyzers)
+                        lines.Add(string.Format(@"    <Analyzer Include=""{0}"" />", EscapedRelativePathFor(analyzer)));
+                    lines.Add(@"  </ItemGroup>");
+                }
+            }
+
+            return string.Join("\r\n", lines
+                .Concat(footer));
+        }
+
+        void SyncSolution(IEnumerable<Assembly> assemblies)
+        {
+            if (InvalidCharactersRegexPattern.IsMatch(ProjectDirectory))
+                Debug.LogWarning("Project path contains special characters, which can be an issue when opening Visual Studio");
+
+            var solutionFile = SolutionFile();
+            var previousSolution = m_FileIOProvider.Exists(solutionFile) ? SolutionParser.ParseSolutionFile(solutionFile, m_FileIOProvider) : null;
+            SyncSolutionFileIfNotChanged(solutionFile, SolutionText(assemblies, previousSolution));
+        }
+
+        string SolutionText(IEnumerable<Assembly> assemblies, Solution previousSolution = null)
+        {
+            const string fileversion = "12.00";
+            const string vsversion = "15";
+
+            var relevantAssemblies = RelevantAssembliesForMode(assemblies);
+            var generatedProjects = ToProjectEntries(relevantAssemblies).ToList();
+
+            SolutionProperties[] properties = null;
+
+            // First, add all projects generated by Unity to the solution
+            var projects = new List<SolutionProjectEntry>();
+            projects.AddRange(generatedProjects);
+
+            if (previousSolution != null)
+            {
+                // Add all projects that were previously in the solution and that are not generated by Unity, nor generated in the project root directory
+                var externalProjects = previousSolution.Projects
+                    .Where(p => p.IsSolutionFolderProjectFactory() || !FileUtility.IsFileInProjectDirectory(p.FileName))
+                    .Where(p => generatedProjects.All(gp => gp.FileName != p.FileName));
+
+                projects.AddRange(externalProjects);
+                properties = previousSolution.Properties;
+            }
+
+            string propertiesText = GetPropertiesText(properties);
+            string projectEntriesText = GetProjectEntriesText(projects);
+
+            // do not generate configurations for SolutionFolders
+            var configurableProjects = projects.Where(p => !p.IsSolutionFolderProjectFactory());
+            string projectConfigurationsText = string.Join(k_WindowsNewline, configurableProjects.Select(p => GetProjectActiveConfigurations(p.ProjectGuid)).ToArray());
+
+            return string.Format(GetSolutionText(), fileversion, vsversion, projectEntriesText, projectConfigurationsText, propertiesText);
+        }
+
+        static IEnumerable<Assembly> RelevantAssembliesForMode(IEnumerable<Assembly> assemblies)
+        {
+            return assemblies.Where(i => ScriptingLanguage.CSharp == ScriptingLanguageFor(i));
+        }
+
+        private string GetPropertiesText(SolutionProperties[] array)
+        {
+            if (array == null || array.Length == 0)
+            {
+                // HideSolution by default
+                array = new SolutionProperties[] {
+                    new SolutionProperties() {
+                        Name = "SolutionProperties",
+                        Type = "preSolution",
+                        Entries = new List<KeyValuePair<string,string>>() { new KeyValuePair<string, string> ("HideSolutionNode", "FALSE") }
+                    }
+                };
+            }
+            var result = new StringBuilder();
+
+            for (var i = 0; i<array.Length; i++)
+            {
+                if (i > 0)
+                    result.Append(k_WindowsNewline);
+
+                var properties = array[i];
+
+                result.Append($"\tGlobalSection({properties.Name}) = {properties.Type}");
+                result.Append(k_WindowsNewline);
+
+                foreach (var entry in properties.Entries)
+                {
+                    result.Append($"\t\t{entry.Key} = {entry.Value}");
+                    result.Append(k_WindowsNewline);
+                }
+
+                result.Append("\tEndGlobalSection");
+            }
+
+            return result.ToString();
+        }
+
+        /// <summary>
+        /// Get a Project("{guid}") = "MyProject", "MyProject.unityproj", "{projectguid}"
+        /// entry for each relevant language
+        /// </summary>
+        string GetProjectEntriesText(IEnumerable<SolutionProjectEntry> entries)
+        {
+            var projectEntries = entries.Select(entry => string.Format(
+                m_SolutionProjectEntryTemplate,
+                entry.ProjectFactoryGuid, entry.Name, entry.FileName, entry.ProjectGuid, entry.Metadata
+            ));
+
+            return string.Join(k_WindowsNewline, projectEntries.ToArray());
+        }
+
+        IEnumerable<SolutionProjectEntry> ToProjectEntries(IEnumerable<Assembly> assemblies)
+        {
+            foreach (var assembly in assemblies)
+                yield return new SolutionProjectEntry()
+                {
+                    ProjectFactoryGuid = SolutionGuid(assembly),
+                    Name = assembly.name,
+                    FileName = Path.GetFileName(ProjectFile(assembly)),
+                    ProjectGuid = ProjectGuid(assembly),
+                    Metadata = k_WindowsNewline
+                };
+        }
+
+        /// <summary>
+        /// Generate the active configuration string for a given project guid
+        /// </summary>
+        string GetProjectActiveConfigurations(string projectGuid)
+        {
+            return string.Format(
+                m_SolutionProjectConfigurationTemplate,
+                projectGuid);
+        }
+
+        string EscapedRelativePathFor(string file)
+        {
+            var projectDir = FileUtility.Normalize(ProjectDirectory);
+            file = FileUtility.Normalize(file);
+            var path = SkipPathPrefix(file, projectDir);
+
+            var packageInfo = m_AssemblyNameProvider.FindForAssetPath(path.Replace('\\', '/'));
+            if (packageInfo != null) {
+                // We have to normalize the path, because the PackageManagerRemapper assumes
+                // dir seperators will be os specific.
+                var absolutePath = Path.GetFullPath(FileUtility.Normalize(path));
+                path = SkipPathPrefix(absolutePath, projectDir);
+            }
+
+            return XmlFilename(path);
+        }
+
+        static string SkipPathPrefix(string path, string prefix)
+        {
+            if (path.StartsWith($"{prefix}{Path.DirectorySeparatorChar}") && (path.Length > prefix.Length))
+                return path.Substring(prefix.Length + 1);
+            return path;
+        }
+
+        static string ProjectFooter()
+        {
+            return GetProjectFooterTemplate();
+        }
+
+        static string GetProjectExtension()
+        {
+            return ".csproj";
+        }
+
+        string ProjectGuid(Assembly assembly)
+        {
+            return m_GUIDGenerator.ProjectGuid(
+				m_ProjectName,
+				m_AssemblyNameProvider.GetAssemblyName(assembly.outputPath, assembly.name));
+		}
+
+        string SolutionGuid(Assembly assembly)
+        {
+            return m_GUIDGenerator.SolutionGuid(m_ProjectName, ScriptingLanguageFor(assembly));
+        }
+    }
+
+    public static class SolutionGuidGenerator
+    {
+        public static string GuidForProject(string projectName)
+        {
+            return ComputeGuidHashFor(projectName + "salt");
+        }
+
+        public static string GuidForSolution(string projectName, ScriptingLanguage language)
+        {
+            if (language == ScriptingLanguage.CSharp)
+            {
+                // GUID for a C# class library: http://www.codeproject.com/Reference/720512/List-of-Visual-Studio-Project-Type-GUIDs
+                return "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC";
+            }
+
+            return ComputeGuidHashFor(projectName);
+        }
+
+        static string ComputeGuidHashFor(string input)
+        {
+            var hash = MD5.Create().ComputeHash(Encoding.Default.GetBytes(input));
+            return HashAsGuid(HashToString(hash));
+        }
+
+        static string HashAsGuid(string hash)
+        {
+            var guid = hash.Substring(0, 8) + "-" + hash.Substring(8, 4) + "-" + hash.Substring(12, 4) + "-" + hash.Substring(16, 4) + "-" + hash.Substring(20, 12);
+            return guid.ToUpper();
+        }
+
+        static string HashToString(byte[] bs)
+        {
+            var sb = new StringBuilder();
+            foreach (byte b in bs)
+                sb.Append(b.ToString("x2"));
+            return sb.ToString();
+        }
+    }
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/ProjectGeneration.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9f3705b95d031e84c82f140d8e980867
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/ProjectGenerationFlag.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	[Flags]
+	public enum ProjectGenerationFlag
+	{
+		None = 0,
+		Embedded = 1,
+		Local = 2,
+		Registry = 4,
+		Git = 8,
+		BuiltIn = 16,
+		Unknown = 32,
+		PlayerAssemblies = 64,
+		LocalTarBall = 128,
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/ProjectGeneration/ProjectGenerationFlag.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 555fcccd6b79a864f83e7a319daa1c3e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Solution.cs

@@ -0,0 +1,12 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	internal class Solution
+	{
+		public SolutionProjectEntry[] Projects { get; set; }
+		public SolutionProperties[] Properties { get; set; }
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Solution.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: af4c2c762e1d8e949a6bc458973df6e7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/SolutionParser.cs

@@ -0,0 +1,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	internal static class SolutionParser
+	{
+		// Compared to the bridge implementation, we are not returning "{" "}" from Guids
+		private static readonly Regex ProjectDeclaration = new Regex(@"Project\(\""{(?<projectFactoryGuid>.*?)}\""\)\s+=\s+\""(?<name>.*?)\"",\s+\""(?<fileName>.*?)\"",\s+\""{(?<projectGuid>.*?)}\""(?<metadata>.*?)\bEndProject\b", RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+		private static readonly Regex PropertiesDeclaration = new Regex(@"GlobalSection\((?<name>([\w]+Properties|NestedProjects))\)\s+=\s+(?<type>(?:post|pre)Solution)(?<entries>.*?)EndGlobalSection", RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+		private static readonly Regex PropertiesEntryDeclaration = new Regex(@"^\s*(?<key>.*?)=(?<value>.*?)$", RegexOptions.Multiline | RegexOptions.ExplicitCapture);
+
+		public static Solution ParseSolutionFile(string filename, IFileIO fileIO)
+		{
+			return ParseSolutionContent(fileIO.ReadAllText(filename));
+		}
+
+		public static Solution ParseSolutionContent(string content)
+		{
+			return new Solution
+			{
+				Projects = ParseSolutionProjects(content),
+				Properties = ParseSolutionProperties(content)
+			};
+		}
+
+		private static SolutionProjectEntry[] ParseSolutionProjects(string content)
+		{
+			var projects = new List<SolutionProjectEntry>();
+			var mc = ProjectDeclaration.Matches(content);
+
+			foreach (Match match in mc)
+			{
+				projects.Add(new SolutionProjectEntry
+				{
+					ProjectFactoryGuid = match.Groups["projectFactoryGuid"].Value,
+					Name = match.Groups["name"].Value,
+					FileName = match.Groups["fileName"].Value,
+					ProjectGuid = match.Groups["projectGuid"].Value,
+					Metadata = match.Groups["metadata"].Value
+				});
+			}
+
+			return projects.ToArray();
+		}
+
+		private static SolutionProperties[] ParseSolutionProperties(string content)
+		{
+			var properties = new List<SolutionProperties>();
+			var mc = PropertiesDeclaration.Matches(content);
+
+			foreach (Match match in mc)
+			{
+				var sp = new SolutionProperties
+				{
+					Entries = new List<KeyValuePair<string, string>>(),
+					Name = match.Groups["name"].Value,
+					Type = match.Groups["type"].Value
+				};
+
+				var entries = match.Groups["entries"].Value;
+				var mec = PropertiesEntryDeclaration.Matches(entries);
+				foreach (Match entry in mec)
+				{
+					var key = entry.Groups["key"].Value.Trim();
+					var value = entry.Groups["value"].Value.Trim();
+					sp.Entries.Add(new KeyValuePair<string, string>(key, value));
+				}
+
+				properties.Add(sp);
+			}
+
+			return properties.ToArray();
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/SolutionParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fbbb1ee655846b043baf6c3502b5ce49
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/SolutionProjectEntry.cs

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	internal class SolutionProjectEntry
+	{
+		public string ProjectFactoryGuid { get; set; }
+		public string Name { get; set; }
+		public string FileName { get; set; }
+		public string ProjectGuid { get; set; }
+		public string Metadata { get; set; }
+
+		public bool IsSolutionFolderProjectFactory()
+		{
+			return ProjectFactoryGuid != null && ProjectFactoryGuid.Equals("2150E333-8FDC-42A3-9474-1A3956D46DE8", StringComparison.OrdinalIgnoreCase);
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/SolutionProjectEntry.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c1b8a755d2c97640bbb207c43f4cf61
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/SolutionProperties.cs

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System.Collections.Generic;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	internal class SolutionProperties
+	{
+		public string Name { get; set; }
+		public IList<KeyValuePair<string, string>> Entries { get; set; }
+		public string Type { get; set; }
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/SolutionProperties.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 829d4d6bc39fd1044ba4c5fc2a9c911f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Symbols.cs

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.IO;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	internal static class Symbols
+	{
+		public static bool IsPortableSymbolFile(string pdbFile)
+		{
+			try
+			{
+				using (var stream = File.OpenRead(pdbFile))
+				{
+					return stream.ReadByte() == 'B'
+						   && stream.ReadByte() == 'S'
+						   && stream.ReadByte() == 'J'
+						   && stream.ReadByte() == 'B';
+				}
+			}
+			catch (Exception)
+			{
+				return false;
+			}
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/Symbols.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b9308b762484008498bb5cd1886aa491
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/VSWhere.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5b17896803f77494da73d73448fb6cb4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/VSWhere/vswhere.exe.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 585c3fb85b32bd64e8814074e754163e
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/VisualStudioEditor.cs

@@ -0,0 +1,293 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Unity Technologies.
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text;
+using UnityEditor;
+using UnityEngine;
+using Unity.CodeEditor;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	[InitializeOnLoad]
+	public class VisualStudioEditor : IExternalCodeEditor
+	{
+		private static readonly VisualStudioInstallation[] _installations;
+
+		internal static bool IsOSX => Application.platform == RuntimePlatform.OSXEditor;
+		internal static bool IsWindows => !IsOSX && Path.DirectorySeparatorChar == '\\' && Environment.NewLine == "\r\n";
+
+		CodeEditor.Installation[] IExternalCodeEditor.Installations => _installations
+			.Select(i => i.ToCodeEditorInstallation())
+			.ToArray(); 
+
+		private readonly IGenerator _generator = new ProjectGeneration();
+
+		static VisualStudioEditor()
+		{
+			try
+			{
+				_installations = Discovery
+					.GetVisualStudioInstallations()
+					.ToArray();
+			}
+			catch (Exception ex)
+			{
+				UnityEngine.Debug.Log($"Error detecting Visual Studio installations: {ex}");
+				_installations = Array.Empty<VisualStudioInstallation>();
+			}
+
+			CodeEditor.Register(new VisualStudioEditor());
+		}
+
+		internal static bool IsEnabled
+		{
+			get
+			{
+				return CodeEditor.CurrentEditor is VisualStudioEditor;
+			}
+		}
+
+		public void CreateIfDoesntExist()
+		{
+			if (!_generator.HasSolutionBeenGenerated())
+				_generator.Sync();
+		}
+
+		public void Initialize(string editorInstallationPath)
+		{
+		}
+
+		internal bool TryGetVisualStudioInstallationForPath(string editorPath, out VisualStudioInstallation installation)
+		{
+			// lookup for well known installations
+			foreach (var candidate in _installations)
+			{
+				if (!string.Equals(Path.GetFullPath(editorPath), Path.GetFullPath(candidate.Path), StringComparison.OrdinalIgnoreCase))
+					continue;
+
+				installation = candidate;
+				return true;
+			}
+
+			return Discovery.TryDiscoverInstallation(editorPath, out installation);
+		}
+
+		public bool TryGetInstallationForPath(string editorPath, out CodeEditor.Installation installation)
+		{
+			var result = TryGetVisualStudioInstallationForPath(editorPath, out var vsi);
+			installation = vsi == null ? default : vsi.ToCodeEditorInstallation();
+			return result;
+		}
+
+		public void OnGUI()
+		{
+			GUILayout.BeginHorizontal();
+			GUILayout.FlexibleSpace();
+
+			var package = UnityEditor.PackageManager.PackageInfo.FindForAssembly(GetType().Assembly);
+
+			var style = new GUIStyle
+			{
+				richText = true,
+				margin = new RectOffset(0, 4, 0, 0)
+			};
+
+			GUILayout.Label($"<size=10><color=grey>{package.displayName} v{package.version} enabled</color></size>", style);
+			GUILayout.EndHorizontal();
+
+			EditorGUILayout.LabelField("Generate .csproj files for:");
+			EditorGUI.indentLevel++;
+			SettingsButton(ProjectGenerationFlag.Embedded, "Embedded packages", "");
+			SettingsButton(ProjectGenerationFlag.Local, "Local packages", "");
+			SettingsButton(ProjectGenerationFlag.Registry, "Registry packages", "");
+			SettingsButton(ProjectGenerationFlag.Git, "Git packages", "");
+			SettingsButton(ProjectGenerationFlag.BuiltIn, "Built-in packages", "");
+			SettingsButton(ProjectGenerationFlag.LocalTarBall, "Local tarball", "");
+			SettingsButton(ProjectGenerationFlag.Unknown, "Packages from unknown sources", "");
+			SettingsButton(ProjectGenerationFlag.PlayerAssemblies, "Player projects", "For each player project generate an additional csproj with the name 'project-player.csproj'");
+			RegenerateProjectFiles();
+			EditorGUI.indentLevel--;
+		}
+
+		void RegenerateProjectFiles()
+        {
+            var rect = EditorGUI.IndentedRect(EditorGUILayout.GetControlRect(new GUILayoutOption[] {}));
+            rect.width = 252;
+            if (GUI.Button(rect, "Regenerate project files"))
+            {
+                _generator.Sync();
+            }
+        }
+
+		void SettingsButton(ProjectGenerationFlag preference, string guiMessage, string toolTip)
+		{
+			var prevValue = _generator.AssemblyNameProvider.ProjectGenerationFlag.HasFlag(preference);
+			var newValue = EditorGUILayout.Toggle(new GUIContent(guiMessage, toolTip), prevValue);
+			if (newValue != prevValue)
+			{
+				_generator.AssemblyNameProvider.ToggleProjectGeneration(preference);
+			}
+		}
+
+		public void SyncIfNeeded(string[] addedFiles, string[] deletedFiles, string[] movedFiles, string[] movedFromFiles, string[] importedFiles)
+		{
+			_generator.SyncIfNeeded(addedFiles.Union(deletedFiles).Union(movedFiles).Union(movedFromFiles), importedFiles);
+
+			foreach (var file in importedFiles.Where(a => Path.GetExtension(a) == ".pdb"))
+			{
+				var pdbFile = FileUtility.GetAssetFullPath(file);
+				var asmFile = Path.ChangeExtension(pdbFile, ".dll");
+
+				if (!File.Exists(asmFile) || !Image.IsAssembly(asmFile))
+					continue;
+
+				if (Symbols.IsPortableSymbolFile(pdbFile))
+					continue;
+
+				UnityEngine.Debug.LogWarning($"Unity is only able to load mdb or portable-pdb symbols. {file} is using a legacy pdb format.");
+			}
+		}
+
+		public void SyncAll()
+		{
+			AssetDatabase.Refresh();
+			_generator.Sync();
+		}
+
+		bool IsSupportedPath(string path)
+		{
+			// Path is empty with "Open C# Project", as we only want to open the solution without specific files
+			if (string.IsNullOrEmpty(path))
+				return true;
+
+			// cs, uxml, uss, shader, compute, cginc, hlsl, glslinc, template are part of Unity builtin extensions
+			// txt, xml, fnt, cd are -often- par of Unity user extensions
+			// asdmdef is mandatory included
+			if (_generator.IsSupportedFile(path))
+				return true;
+
+			return false;
+		}
+
+		public bool OpenProject(string path, int line, int column)
+		{
+			if (!IsSupportedPath(path))
+				return false;
+
+			if (IsOSX)
+				return OpenOSXApp(path, line, column);
+
+			if (IsWindows)
+				return OpenWindowsApp(path, line);
+
+			return false;
+		}
+
+		private bool OpenWindowsApp(string path, int line)
+		{
+			var progpath = FileUtility
+				.FindPackageAssetFullPath("COMIntegration a:packages", "COMIntegration.exe")
+				.FirstOrDefault();
+
+			if (string.IsNullOrWhiteSpace(progpath))
+				return false;
+
+			string absolutePath = "";
+			if (!string.IsNullOrWhiteSpace(path))
+			{
+				absolutePath = Path.GetFullPath(path);
+			}
+
+			// We remove all invalid chars from the solution filename, but we cannot prevent the user from using a specific path for the Unity project
+			// So process the fullpath to make it compatible with VS
+			var solution = GetOrGenerateSolutionFile(path);
+			if (!string.IsNullOrWhiteSpace(solution))
+			{
+				solution = $"\"{solution}\"";
+				solution = solution.Replace("^", "^^");
+			}
+
+			var process = new Process
+			{
+				StartInfo = new ProcessStartInfo
+				{
+					FileName = progpath,
+					Arguments = $"\"{CodeEditor.CurrentEditorInstallation}\" \"{absolutePath}\" {solution} {line}",
+					CreateNoWindow = true,
+					UseShellExecute = false,
+					RedirectStandardOutput = true,
+					RedirectStandardError = true,
+				}
+			};
+			var result = process.Start();
+
+			while (!process.StandardOutput.EndOfStream)
+			{
+				var outputLine = process.StandardOutput.ReadLine();
+				if (outputLine == "displayProgressBar")
+				{
+					EditorUtility.DisplayProgressBar("Opening Visual Studio", "Starting up Visual Studio, this might take some time.", .5f);
+				}
+
+				if (outputLine == "clearprogressbar")
+				{
+					EditorUtility.ClearProgressBar();
+				}
+			}
+
+			var errorOutput = process.StandardError.ReadToEnd();
+			if (!string.IsNullOrEmpty(errorOutput))
+			{
+				Console.WriteLine("Error: \n" + errorOutput);
+			}
+
+			process.WaitForExit();
+			return result;
+		}
+
+		[DllImport("AppleEventIntegration")]
+		static extern bool OpenVisualStudio(string appPath, string solutionPath, string filePath, int line);
+
+		bool OpenOSXApp(string path, int line, int column)
+		{
+			string absolutePath = "";
+			if (!string.IsNullOrWhiteSpace(path))
+			{
+				absolutePath = Path.GetFullPath(path);
+			}
+
+			string solution = GetOrGenerateSolutionFile(path);
+			return OpenVisualStudio(CodeEditor.CurrentEditorInstallation, solution, absolutePath, line);
+		}
+
+		private string GetOrGenerateSolutionFile(string path)
+		{
+			var solution = GetSolutionFile(path);
+			if (solution == "")
+			{
+				_generator.Sync();
+				solution = GetSolutionFile(path);
+			}
+
+			return solution;
+		}
+
+		string GetSolutionFile(string path)
+		{
+			var solutionFile = _generator.SolutionFile();
+			if (File.Exists(solutionFile))
+			{
+				return solutionFile;
+			}
+
+			return "";
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/VisualStudioEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0173aff8c07e06b42af07ebdd7f08032
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/VisualStudioInstallation.cs

@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.IO;
+using Microsoft.Win32;
+using Unity.CodeEditor;
+using IOPath = System.IO.Path;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	internal class VisualStudioInstallation
+	{
+		public string Name { get; set; }
+		public string Path { get; set; }
+		public Version Version { get; set; }
+		public bool IsPrerelease { get; set; }
+
+		public bool SupportsAnalyzers
+		{
+			get
+			{
+				if (VisualStudioEditor.IsWindows)
+					return Version >= new Version(16, 3);
+
+				if (VisualStudioEditor.IsOSX)
+					return Version >= new Version(8, 3);
+
+				return false;
+			}
+		}
+
+		public bool SupportsCSharp8
+		{
+			get
+			{
+				if (VisualStudioEditor.IsWindows)
+					return Version >= new Version(16, 0);
+
+				if (VisualStudioEditor.IsOSX)
+					return Version >= new Version(8, 2);
+
+				return false;
+			}
+		}
+
+		private static string ReadRegistry(RegistryKey hive, string keyName, string valueName)
+		{
+			try
+			{
+				var unitykey = hive.OpenSubKey(keyName);
+
+				var result = (string)unitykey?.GetValue(valueName);
+				return result;
+			}
+			catch (Exception)
+			{
+				return null;
+			}
+		}
+
+		// We only use this to find analyzers, we do not need to load this assembly anymore
+		private string GetBridgeLocation()
+		{
+			if (VisualStudioEditor.IsWindows)
+			{
+				// Registry, using legacy bridge location
+				var keyName = $"Software\\Microsoft\\Microsoft Visual Studio {Version.Major}.0 Tools for Unity";
+				const string valueName = "UnityExtensionPath";
+
+				var bridge = ReadRegistry(Registry.CurrentUser, keyName, valueName);
+				if (string.IsNullOrEmpty(bridge))
+					bridge = ReadRegistry(Registry.LocalMachine, keyName, valueName);
+
+				return bridge;
+			}
+
+			if (VisualStudioEditor.IsOSX)
+			{
+				// Environment,  useful when developing UnityVS for Mac 
+				var bridge = Environment.GetEnvironmentVariable("VSTUM_BRIDGE");
+				if (!string.IsNullOrEmpty(bridge) && File.Exists(bridge))
+					return bridge;
+
+				const string addinBridge = "Editor/SyntaxTree.VisualStudio.Unity.Bridge.dll";
+				const string addinName = "MonoDevelop.Unity";
+
+				// user addins repository
+				var localAddins = IOPath.Combine(
+					Environment.GetFolderPath(Environment.SpecialFolder.Personal),
+					$"Library/Application Support/VisualStudio/${Version.Major}.0" + "/LocalInstall/Addins");
+
+				// In the user addins repository, the addins are suffixed by their versions, like `MonoDevelop.Unity.1.0`
+				// When installing another local user addin, MD will remove files inside the folder
+				// So we browse all VSTUM addins, and return the one with a bridge, which is the one MD will load
+				if (Directory.Exists(localAddins))
+				{
+					foreach (var folder in Directory.GetDirectories(localAddins, addinName + "*", SearchOption.TopDirectoryOnly))
+					{
+						bridge = IOPath.Combine(folder, addinBridge);
+						if (File.Exists(bridge))
+							return bridge;
+					}
+				}
+
+				// Check in Visual Studio.app/
+				// In that case the name of the addin is used
+				bridge = IOPath.Combine(Path, $"Contents/Resources/lib/monodevelop/AddIns/{addinName}/{addinBridge}");
+				if (File.Exists(bridge))
+					return bridge;
+			}
+
+			return null;
+		}
+
+		public string[] GetAnalyzers()
+		{
+			var bridge = GetBridgeLocation();
+
+			if (!string.IsNullOrEmpty(bridge))
+			{
+				var baseLocation = IOPath.Combine(IOPath.GetDirectoryName(bridge), "..");
+				var analyzerLocation = IOPath.GetFullPath(IOPath.Combine(baseLocation, "Analyzers"));
+
+				if (Directory.Exists(analyzerLocation))
+					return Directory.GetFiles(analyzerLocation, "*Analyzers.dll", SearchOption.AllDirectories);
+			}
+
+			// Local assets
+			// return FileUtility.FindPackageAssetFullPath("Analyzers a:packages", ".Analyzers.dll");
+			return Array.Empty<string>();
+		}
+
+		public CodeEditor.Installation ToCodeEditorInstallation()
+		{
+			return new CodeEditor.Installation() { Name = Name, Path = Path };
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/VisualStudioInstallation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bb86eea06f54fb24caa7046a8a764945
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/VisualStudioIntegration.cs

@@ -0,0 +1,188 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using Microsoft.Unity.VisualStudio.Editor.Messaging;
+using UnityEditor;
+using UnityEngine;
+using MessageType = Microsoft.Unity.VisualStudio.Editor.Messaging.MessageType;
+
+namespace Microsoft.Unity.VisualStudio.Editor
+{
+	[InitializeOnLoad]
+	internal class VisualStudioIntegration
+	{
+		private static Messager _messager;
+
+		private static readonly Queue<Message> Incoming = new Queue<Message>();
+		private static readonly object IncomingLock = new object();
+
+		static VisualStudioIntegration()
+		{
+			if (!VisualStudioEditor.IsEnabled)
+				return;
+
+			RunOnceOnUpdate(() =>
+			{
+				// Despite using ReuseAddress|!ExclusiveAddressUse, we can fail here:
+				// - if another application is using this port with exclusive access
+				// - or if the firewall is not properly configured
+				var messagingPort = MessagingPort();
+				
+				try {
+					_messager = Messager.BindTo(messagingPort);
+					_messager.ReceiveMessage += ReceiveMessage;
+				}
+				catch (SocketException)
+				{
+					// We'll have a chance to try to rebind on next domain reload
+					Debug.LogWarning($"Unable to use UDP port {messagingPort} for VS/Unity messaging. You should check if another process is already bound to this port or if your firewall settings are compatible.");
+				}
+
+				RunOnShutdown(Shutdown);
+			});
+
+			EditorApplication.update += OnUpdate;
+		}
+
+		private static void RunOnceOnUpdate(Action action)
+		{
+			var callback = null as EditorApplication.CallbackFunction;
+
+			callback = () =>
+			{
+				EditorApplication.update -= callback;
+				action();
+			};
+
+			EditorApplication.update += callback;
+		}
+
+		private static void RunOnShutdown(Action action)
+		{
+			// Mono on OSX has all kinds of quirks on AppDomain shutdown
+			if (!VisualStudioEditor.IsWindows)
+				return;
+
+			AppDomain.CurrentDomain.DomainUnload += (_, __) => action();
+		}
+
+		private static int DebuggingPort()
+		{
+			return 56000 + (System.Diagnostics.Process.GetCurrentProcess().Id % 1000);
+		}
+
+		private static int MessagingPort()
+		{
+			return DebuggingPort() + 2;
+		}
+
+		private static void ReceiveMessage(object sender, MessageEventArgs args)
+		{
+			OnMessage(args.Message);
+		}
+
+		private static void OnUpdate()
+		{
+			lock (IncomingLock)
+			{
+				while (Incoming.Count > 0)
+				{
+					ProcessIncoming(Incoming.Dequeue());
+				}
+			}
+		}
+
+		private static void AddMessage(Message message)
+		{
+			lock (IncomingLock)
+			{
+				Incoming.Enqueue(message);
+			}
+		}
+
+		private static void ProcessIncoming(Message message)
+		{
+			switch (message.Type)
+			{
+				case MessageType.Ping:
+					Answer(message, MessageType.Pong);
+					break;
+				case MessageType.Play:
+					Shutdown();
+					EditorApplication.isPlaying = true;
+					break;
+				case MessageType.Stop:
+					EditorApplication.isPlaying = false;
+					break;
+				case MessageType.Pause:
+					EditorApplication.isPaused = true;
+					break;
+				case MessageType.Unpause:
+					EditorApplication.isPaused = false;
+					break;
+				case MessageType.Build:
+					// Not used anymore
+					break;
+				case MessageType.Refresh:
+					Refresh();
+					break;
+				case MessageType.Version:
+					Answer(message, MessageType.Version, PackageVersion());
+					break;
+				case MessageType.UpdatePackage:
+					// Not used anymore
+					break;
+				case MessageType.ProjectPath:
+					Answer(message, MessageType.ProjectPath, Path.GetFullPath(Path.Combine(Application.dataPath, "..")));
+					break;
+			}
+		}
+
+		private static string PackageVersion()
+		{
+			var package = UnityEditor.PackageManager.PackageInfo.FindForAssembly(typeof(VisualStudioIntegration).Assembly);
+			return package.version;
+		}
+
+		private static void Refresh()
+		{
+			RunOnceOnUpdate(AssetDatabase.Refresh);
+		}
+
+		private static void OnMessage(Message message)
+		{
+			AddMessage(message);
+		}
+
+		private static void Answer(Message message, MessageType answerType, string answerValue = "")
+		{
+			var targetEndPoint = message.Origin;
+
+			Answer(
+				targetEndPoint,
+				answerType,
+				answerValue);
+		}
+
+		private static void Answer(IPEndPoint targetEndPoint, MessageType answerType, string answerValue)
+		{
+			_messager?.SendMessage(targetEndPoint, answerType, answerValue);
+		}
+
+		private static void Shutdown()
+		{
+			if (_messager == null)
+				return;
+
+			_messager.ReceiveMessage -= ReceiveMessage;
+			_messager.Dispose();
+			_messager = null;
+		}
+	}
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/VisualStudioIntegration.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 48fcd6ebd5ce8fd4cbe931895233677d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/com.unity.ide.visualstudio.asmdef

@@ -0,0 +1,9 @@
+{
+    "name": "Unity.VisualStudio.Editor",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": []
+}

GameEngineResearch/ErpgUnity3d/Library/PackageCache/com.unity.ide.visualstudio@2.0.2/Editor/com.unity.ide.visualstudio.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b93f844d45cfcc44fa2b0eed5c9ec6bb
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: