Added Parrelsync and updated Service intializastion to use profiles based on what clone we are in.

Assets/Scripts/GameLobby/Auth/Identity.cs

     /// <summary>
     /// Our internal representation of the local player's credentials, wrapping the data required for interfacing with the identities of that player in the services.
     /// (In use here, it just wraps Auth, but it can be used to combine multiple sets of credentials into one concept of a player.)
+    /// (This callback pattern also allows for Unit Testing, something UnityServices does support easily.)
-        public Identity(Action callbackOnAuthLogin)
+        public Identity(string profileName, Action callbackOnAuthLogin)
-            m_subIdentities.Add(IIdentityType.Auth, new SubIdentity_Authentication(callbackOnAuthLogin));
+            m_subIdentities.Add(IIdentityType.Auth, new SubIdentity_Authentication(profileName, callbackOnAuthLogin));
         }
 
         public SubIdentity GetSubIdentity(IIdentityType identityType)

Assets/Scripts/GameLobby/Auth/SubIdentity_Authentication.cs

 using System;
+using System.Threading.Tasks;
 using Unity.Services.Authentication;
 using Unity.Services.Core;
 
         /// <summary>
         /// This will kick off a login.
         /// </summary>
-        public SubIdentity_Authentication(Action onSigninComplete = null)
+        public SubIdentity_Authentication(string profileName = "default", Action onSigninComplete = null)
-            DoSignIn(onSigninComplete);
+#pragma warning disable 4014
+            DoSignIn(profileName, onSigninComplete);
+#pragma warning restore 4014
         }
         ~SubIdentity_Authentication()
         {
             }
         }
 
-        private async void DoSignIn(Action onSigninComplete)
+        private async Task DoSignIn(string profileName, Action onSigninComplete)
-            await UnityServices.InitializeAsync();
+            var serviceProfile = new InitializationOptions();
+            serviceProfile.SetProfile(profileName);
+            await UnityServices.InitializeAsync(serviceProfile);
             AuthenticationService.Instance.SignedIn += OnSignInChange;
             AuthenticationService.Instance.SignedOut += OnSignInChange;
 

Assets/Scripts/GameLobby/Game/GameManager.cs

 using LobbyRelaySample.lobby;
 using UnityEngine;
 using UnityEngine.Serialization;
+#if UNITY_EDITOR
+using ParrelSync;
+#endif
+
 
 namespace LobbyRelaySample
 {
 #pragma warning disable IDE0059 // Unnecessary assignment of a value
             var unused = Locator.Get;
 #pragma warning restore IDE0059
-
-            Locator.Get.Provide(new Auth.Identity(OnAuthSignIn));
+            string serviceProfileName = "player";
+            #if UNITY_EDITOR
+            serviceProfileName = $"{serviceProfileName}_{ClonesManager.GetCurrentProject().name}";
+            #endif
+            Locator.Get.Provide(new Auth.Identity(serviceProfileName,OnAuthSignIn));
             Application.wantsToQuit += OnWantToQuit;
         }
 

Assets/Scripts/GameLobby/LobbyRelaySample.asmdef

         "GUID:f2d49d9fa7e7eb3418e39723a7d3b92f",
         "GUID:6087a74f6015aae4daed9a2577a7596c",
         "GUID:4ebbcb26024b547159a86c39de1a8fa5",
-        "GUID:3bf5041814073ec4089849c425919d5a",
-        "GUID:3b8ed52f1b5c64994af4c4e0aa4b6c4b"
+        "GUID:3b8ed52f1b5c64994af4c4e0aa4b6c4b",
+        "GUID:894a6cc6ed5cd2645bb542978cbed6a9"
-    "precompiledReferences": [],
+    "precompiledReferences": [
+        ""
+    ],
     "autoReferenced": true,
     "defineConstraints": [],
     "versionDefines": [],

Assets/Scripts/GameLobby/Tests/PlayMode/LobbyRoundtripTests.cs

         [OneTimeSetUp]
         public void Setup()
         {
-            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
+            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication("testProfile", () => { m_didSigninComplete = true; });
             m_mockUserData = new Dictionary<string, PlayerDataObject>();
             m_mockUserData.Add("DisplayName", new PlayerDataObject(PlayerDataObject.VisibilityOptions.Member, "TestUser123"));
             m_LocalUser = new LobbyUser(true);
             LogAssert.ignoreFailingMessages = false;
 
             Assert.Null(createLobby, "The returned object will be null, so expect to need to handle it.");
+        }
+
+        [UnityTest]
+        public IEnumerator LobbyPlayerDataUpdated()
+        {
+            yield return null;
         }
     }
 }

Assets/Scripts/GameLobby/Tests/PlayMode/RelayRoundTripTests.cs

 using System;
 using System.Collections;
-using LobbyRelaySample;
-using LobbyRelaySample.relay;
 using NUnit.Framework;
 using Test.Tools;
 using Unity.Services.Relay;
         [OneTimeSetUp]
         public void Setup()
         {
-            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
+            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication("testProfile", () => { m_didSigninComplete = true; });
         }
 
         [OneTimeTearDown]

Assets/Scripts/GameLobby/Tests/PlayMode/Tests.Play.asmdef

         "LobbyRelaySample",
         "Unity.Services.Lobbies",
         "Unity.Services.Relay",
-        "Unity.Networking.Transport"
+        "Unity.Networking.Transport",
+        "Unity.Services.Core"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

Assets/Scripts/GameLobby/Tests/PlayMode/UtpTests.cs

 using System;
 using System.Collections;
+using System.Threading.Tasks;
+using Unity.Services.Core;
 using Unity.Services.Relay.Models;
 using UnityEngine;
 using UnityEngine.TestTools;
         public void Setup()
         {
             m_dummy = new GameObject();
-            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication(() => { m_didSigninComplete = true; });
+            m_auth = new LobbyRelaySample.Auth.SubIdentity_Authentication("TestProfile",() => { m_didSigninComplete = true; });
+        }
+
+        async Task InitServices()
+        {
+            await UnityServices.InitializeAsync();
+            m_didSigninComplete = true;
+
         }
 
         [OneTimeTearDown]

Packages/ParrelSync.meta

+fileFormatVersion: 2
+guid: 520a1688a3c84604b0e7836ecc15cee3
+timeCreated: 1654698051

ProjectSettings/SceneTemplateSettings.json

+{
+    "templatePinStates": [],
+    "dependencyTypeInfos": [
+        {
+            "userAdded": false,
+            "type": "UnityEngine.AnimationClip",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEditor.Animations.AnimatorController",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.AnimatorOverrideController",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEditor.Audio.AudioMixerController",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.ComputeShader",
+            "ignore": true,
+            "defaultInstantiationMode": 1,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Cubemap",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.GameObject",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEditor.LightingDataAsset",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": false
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.LightingSettings",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Material",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEditor.MonoScript",
+            "ignore": true,
+            "defaultInstantiationMode": 1,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.PhysicMaterial",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.PhysicsMaterial2D",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Rendering.PostProcessing.PostProcessProfile",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Rendering.PostProcessing.PostProcessResources",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Rendering.VolumeProfile",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEditor.SceneAsset",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": false
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Shader",
+            "ignore": true,
+            "defaultInstantiationMode": 1,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.ShaderVariantCollection",
+            "ignore": true,
+            "defaultInstantiationMode": 1,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Texture",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Texture2D",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        },
+        {
+            "userAdded": false,
+            "type": "UnityEngine.Timeline.TimelineAsset",
+            "ignore": false,
+            "defaultInstantiationMode": 0,
+            "supportsModification": true
+        }
+    ],
+    "defaultDependencyTypeInfo": {
+        "userAdded": false,
+        "type": "<default_scene_template_dependencies>",
+        "ignore": false,
+        "defaultInstantiationMode": 1,
+        "supportsModification": true
+    },
+    "newSceneOverride": 0
+}

Packages/ParrelSync/Editor.meta

+fileFormatVersion: 2
+guid: a31ea7d0315594440839cdb0db6bc411
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/AssetModBlock.meta

+fileFormatVersion: 2
+guid: 8b14e706b1e7cb044b23837e8a70cad9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/AssetModBlock/EditorQuit.cs

+using UnityEditor;
+namespace ParrelSync
+{
+    [InitializeOnLoad]
+    public class EditorQuit
+    {
+        /// <summary>
+        /// Is editor being closed
+        /// </summary>
+        static public bool IsQuiting { get; private set; }
+        static void Quit()
+        {
+            IsQuiting = true;
+        }
+
+        static EditorQuit()
+        {
+            IsQuiting = false;
+            EditorApplication.quitting += Quit;
+        }
+    }
+}

Packages/ParrelSync/Editor/AssetModBlock/EditorQuit.cs.meta

+fileFormatVersion: 2
+guid: bf2888ff90706904abc2d851c3e59e00
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs

+using UnityEditor;
+using UnityEngine;
+namespace ParrelSync
+{
+    /// <summary>
+    /// For preventing assets being modified from the clone instance.
+    /// </summary>
+    public class ParrelSyncAssetModificationProcessor : UnityEditor.AssetModificationProcessor
+    {
+        public static string[] OnWillSaveAssets(string[] paths)
+        {
+            if (ClonesManager.IsClone() && Preferences.AssetModPref.Value)
+            {
+                if (paths != null && paths.Length > 0 && !EditorQuit.IsQuiting)
+                {
+                    EditorUtility.DisplayDialog(
+                        ClonesManager.ProjectName + ": Asset modifications saving detected and blocked",
+                        "Asset modifications saving are blocked in the clone instance. \n\n" +
+                        "This is a clone of the original project. \n" +
+                        "Making changes to asset files via the clone editor is not recommended. \n" +
+                        "Please use the original editor window if you want to make changes to the project files.",
+                        "ok"
+                    );
+                    foreach (var path in paths)
+                    {
+                        Debug.Log("Attempting to save " + path + " are blocked.");
+                    }
+                }
+                return new string[0] { };
+            }
+            return paths;
+        }
+    }
+}

Packages/ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs.meta

+fileFormatVersion: 2
+guid: 755e570bd21b39440a923056e60f1450
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/ClonesManager.cs

+using System.Collections.Generic;
+using System.Diagnostics;
+using UnityEngine;
+using UnityEditor;
+using System.Linq;
+using System.IO;
+using Debug = UnityEngine.Debug;
+
+namespace ParrelSync
+{
+    /// <summary>
+    /// Contains all required methods for creating a linked clone of the Unity project.
+    /// </summary>
+    public class ClonesManager
+    {
+        /// <summary>
+        /// Name used for an identifying file created in the clone project directory.
+        /// </summary>
+        /// <remarks>
+        /// (!) Do not change this after the clone was created, because then connection will be lost.
+        /// </remarks>
+        public const string CloneFileName = ".clone";
+
+        /// <summary>
+        /// Suffix added to the end of the project clone name when it is created.
+        /// </summary>
+        /// <remarks>
+        /// (!) Do not change this after the clone was created, because then connection will be lost.
+        /// </remarks>
+        public const string CloneNameSuffix = "_clone";
+
+        public const string ProjectName = "ParrelSync";
+
+        /// <summary>
+        /// The maximum number of clones
+        /// </summary>
+        public const int MaxCloneProjectCount = 10;
+
+        /// <summary>
+        /// Name of the file for storing clone's argument.
+        /// </summary>
+        public const string ArgumentFileName = ".parrelsyncarg";
+
+        /// <summary>
+        /// Default argument of the new clone
+        /// </summary>
+        public const string DefaultArgument = "client";
+
+        #region Managing clones
+
+        /// <summary>
+        /// Creates clone from the project currently open in Unity Editor.
+        /// </summary>
+        /// <returns></returns>
+        public static Project CreateCloneFromCurrent()
+        {
+            if (IsClone())
+            {
+                Debug.LogError("This project is already a clone. Cannot clone it.");
+                return null;
+            }
+
+            string currentProjectPath = ClonesManager.GetCurrentProjectPath();
+            return ClonesManager.CreateCloneFromPath(currentProjectPath);
+        }
+
+        /// <summary>
+        /// Creates clone of the project located at the given path.
+        /// </summary>
+        /// <param name="sourceProjectPath"></param>
+        /// <returns></returns>
+        public static Project CreateCloneFromPath(string sourceProjectPath)
+        {
+            Project sourceProject = new Project(sourceProjectPath);
+
+            string cloneProjectPath = null;
+
+            //Find available clone suffix id
+            for (int i = 0; i < MaxCloneProjectCount; i++)
+            {
+                string originalProjectPath = ClonesManager.GetCurrentProject().projectPath;
+                string possibleCloneProjectPath = originalProjectPath + ClonesManager.CloneNameSuffix + "_" + i;
+
+                if (!Directory.Exists(possibleCloneProjectPath))
+                {
+                    cloneProjectPath = possibleCloneProjectPath;
+                    break;
+                }
+            }
+
+            if (string.IsNullOrEmpty(cloneProjectPath))
+            {
+                Debug.LogError("The number of cloned projects has reach its limit. Limit: " + MaxCloneProjectCount);
+                return null;
+            }
+
+            Project cloneProject = new Project(cloneProjectPath);
+
+            Debug.Log("Start cloning project, original project: " + sourceProject + ", clone project: " + cloneProject);
+
+            ClonesManager.CreateProjectFolder(cloneProject);
+
+            //Copy Folders           
+            Debug.Log("Library copy: " + cloneProject.libraryPath);
+            ClonesManager.CopyDirectoryWithProgressBar(sourceProject.libraryPath, cloneProject.libraryPath,
+                "Cloning Project Library '" + sourceProject.name + "'. ");
+            Debug.Log("Packages copy: " + cloneProject.libraryPath);
+            ClonesManager.CopyDirectoryWithProgressBar(sourceProject.packagesPath, cloneProject.packagesPath,
+              "Cloning Project Packages '" + sourceProject.name + "'. ");
+
+
+            //Link Folders
+            ClonesManager.LinkFolders(sourceProject.assetPath, cloneProject.assetPath);
+            ClonesManager.LinkFolders(sourceProject.projectSettingsPath, cloneProject.projectSettingsPath);
+            ClonesManager.LinkFolders(sourceProject.autoBuildPath, cloneProject.autoBuildPath);
+            ClonesManager.LinkFolders(sourceProject.localPackages, cloneProject.localPackages);
+
+            ClonesManager.RegisterClone(cloneProject);
+
+            return cloneProject;
+        }
+
+        /// <summary>
+        /// Registers a clone by placing an identifying ".clone" file in its root directory.
+        /// </summary>
+        /// <param name="cloneProject"></param>
+        private static void RegisterClone(Project cloneProject)
+        {
+            /// Add clone identifier file.
+            string identifierFile = Path.Combine(cloneProject.projectPath, ClonesManager.CloneFileName);
+            File.Create(identifierFile).Dispose();
+
+            //Add argument file with default argument
+            string argumentFilePath = Path.Combine(cloneProject.projectPath, ClonesManager.ArgumentFileName);
+            File.WriteAllText(argumentFilePath, DefaultArgument, System.Text.Encoding.UTF8);
+
+            /// Add collabignore.txt to stop the clone from messing with Unity Collaborate if it's enabled. Just in case.
+            string collabignoreFile = Path.Combine(cloneProject.projectPath, "collabignore.txt");
+            File.WriteAllText(collabignoreFile, "*"); /// Make it ignore ALL files in the clone.
+        }
+
+        /// <summary>
+        /// Opens a project located at the given path (if one exists).
+        /// </summary>
+        /// <param name="projectPath"></param>
+        public static void OpenProject(string projectPath)
+        {
+            if (!Directory.Exists(projectPath))
+            {
+                Debug.LogError("Cannot open the project - provided folder (" + projectPath + ") does not exist.");
+                return;
+            }
+
+            if (projectPath == ClonesManager.GetCurrentProjectPath())
+            {
+                Debug.LogError("Cannot open the project - it is already open.");
+                return;
+            }
+
+            string fileName = GetApplicationPath();
+            string args = "-projectPath \"" + projectPath + "\"";
+            Debug.Log("Opening project \"" + fileName + " " + args + "\"");
+            ClonesManager.StartHiddenConsoleProcess(fileName, args);
+        }
+
+        private static string GetApplicationPath()
+        {
+            switch (Application.platform)
+            {
+                case RuntimePlatform.WindowsEditor:
+                    return EditorApplication.applicationPath;
+                case RuntimePlatform.OSXEditor:
+                    return EditorApplication.applicationPath + "/Contents/MacOS/Unity";
+                case RuntimePlatform.LinuxEditor:
+                    return EditorApplication.applicationPath;
+                default:
+                    throw new System.NotImplementedException("Platform has not supported yet ;(");
+            }
+        }
+
+        /// <summary>
+        /// Is this project being opened by an Unity editor?
+        /// </summary>
+        /// <param name="projectPath"></param>
+        /// <returns></returns>
+        public static bool IsCloneProjectRunning(string projectPath)
+        {
+
+            //Determine whether it is opened in another instance by checking the UnityLockFile
+            string UnityLockFilePath = new string[] { projectPath, "Temp", "UnityLockfile" }
+                .Aggregate(Path.Combine);
+
+            switch (Application.platform)
+            {
+                case (RuntimePlatform.WindowsEditor):
+                    //Windows editor will lock "UnityLockfile" file when project is being opened.
+                    //Sometime, for instance: windows editor crash, the "UnityLockfile" will not be deleted even the project
+                    //isn't being opened, so a check to the "UnityLockfile" lock status may be necessary.
+                    if (Preferences.AlsoCheckUnityLockFileStaPref.Value)
+                        return File.Exists(UnityLockFilePath) && FileUtilities.IsFileLocked(UnityLockFilePath);
+                    else
+                        return File.Exists(UnityLockFilePath);
+                case (RuntimePlatform.OSXEditor):
+                    //Mac editor won't lock "UnityLockfile" file when project is being opened
+                    return File.Exists(UnityLockFilePath);
+                case (RuntimePlatform.LinuxEditor):
+                    return File.Exists(UnityLockFilePath);
+                default:
+                    throw new System.NotImplementedException("IsCloneProjectRunning: Unsupport Platfrom: " + Application.platform);
+            }
+        }
+
+        /// <summary>
+        /// Deletes the clone of the currently open project, if such exists.
+        /// </summary>
+        public static void DeleteClone(string cloneProjectPath)
+        {
+            /// Clone won't be able to delete itself.
+            if (ClonesManager.IsClone()) return;
+
+            ///Extra precautions.
+            if (cloneProjectPath == string.Empty) return;
+            if (cloneProjectPath == ClonesManager.GetOriginalProjectPath()) return;
+
+            //Check what OS is
+            string identifierFile;
+            string args;
+            switch (Application.platform)
+            {
+                case (RuntimePlatform.WindowsEditor):
+                    Debug.Log("Attempting to delete folder \"" + cloneProjectPath + "\"");
+
+                    //The argument file will be deleted first at the beginning of the project deletion process 
+                    //to prevent any further reading and writing to it(There's a File.Exist() check at the (file)editor windows.)
+                    //If there's any file in the directory being write/read during the deletion process, the directory can't be fully removed.
+                    identifierFile = Path.Combine(cloneProjectPath, ClonesManager.ArgumentFileName);
+                    File.Delete(identifierFile);
+
+                    args = "/c " + @"rmdir /s/q " + string.Format("\"{0}\"", cloneProjectPath);
+                    StartHiddenConsoleProcess("cmd.exe", args);
+
+                    break;
+                case (RuntimePlatform.OSXEditor):
+                    Debug.Log("Attempting to delete folder \"" + cloneProjectPath + "\"");
+
+                    //The argument file will be deleted first at the beginning of the project deletion process 
+                    //to prevent any further reading and writing to it(There's a File.Exist() check at the (file)editor windows.)
+                    //If there's any file in the directory being write/read during the deletion process, the directory can't be fully removed.
+                    identifierFile = Path.Combine(cloneProjectPath, ClonesManager.ArgumentFileName);
+                    File.Delete(identifierFile);
+
+                    FileUtil.DeleteFileOrDirectory(cloneProjectPath);
+
+                    break;
+                case (RuntimePlatform.LinuxEditor):
+                    Debug.Log("Attempting to delete folder \"" + cloneProjectPath + "\"");
+                    identifierFile = Path.Combine(cloneProjectPath, ClonesManager.ArgumentFileName);
+                    File.Delete(identifierFile);
+
+                    FileUtil.DeleteFileOrDirectory(cloneProjectPath);
+
+                    break;
+                default:
+                    Debug.LogWarning("Not in a known editor. Where are you!?");
+                    break;
+            }
+        }
+
+        #endregion
+
+        #region Creating project folders
+
+        /// <summary>
+        /// Creates an empty folder using data in the given Project object
+        /// </summary>
+        /// <param name="project"></param>
+        public static void CreateProjectFolder(Project project)
+        {
+            string path = project.projectPath;
+            Debug.Log("Creating new empty folder at: " + path);
+            Directory.CreateDirectory(path);
+        }
+
+        /// <summary>
+        /// Copies the full contents of the unity library. We want to do this to avoid the lengthy re-serialization of the whole project when it opens up the clone.
+        /// </summary>
+        /// <param name="sourceProject"></param>
+        /// <param name="destinationProject"></param>
+        [System.Obsolete]
+        public static void CopyLibraryFolder(Project sourceProject, Project destinationProject)
+        {
+            if (Directory.Exists(destinationProject.libraryPath))
+            {
+                Debug.LogWarning("Library copy: destination path already exists! ");
+                return;
+            }
+
+            Debug.Log("Library copy: " + destinationProject.libraryPath);
+            ClonesManager.CopyDirectoryWithProgressBar(sourceProject.libraryPath, destinationProject.libraryPath,
+                "Cloning project '" + sourceProject.name + "'. ");
+        }
+
+        #endregion
+
+        #region Creating symlinks
+
+        /// <summary>
+        /// Creates a symlink between destinationPath and sourcePath (Mac version).
+        /// </summary>
+        /// <param name="sourcePath"></param>
+        /// <param name="destinationPath"></param>
+        private static void CreateLinkMac(string sourcePath, string destinationPath)
+        {
+            sourcePath = sourcePath.Replace(" ", "\\ ");
+            destinationPath = destinationPath.Replace(" ", "\\ ");
+            var command = string.Format("ln -s {0} {1}", sourcePath, destinationPath);
+
+            Debug.Log("Mac hard link " + command);
+
+            ClonesManager.ExecuteBashCommand(command);
+        }
+
+        /// <summary>
+        /// Creates a symlink between destinationPath and sourcePath (Linux version).
+        /// </summary>
+        /// <param name="sourcePath"></param>
+        /// <param name="destinationPath"></param>
+        private static void CreateLinkLinux(string sourcePath, string destinationPath)
+        {
+            sourcePath = sourcePath.Replace(" ", "\\ ");
+            destinationPath = destinationPath.Replace(" ", "\\ ");
+            var command = string.Format("ln -s {0} {1}", sourcePath, destinationPath);           
+
+            Debug.Log("Linux Symlink " + command);
+
+            ClonesManager.ExecuteBashCommand(command);
+        }
+
+        /// <summary>
+        /// Creates a symlink between destinationPath and sourcePath (Windows version).
+        /// </summary>
+        /// <param name="sourcePath"></param>
+        /// <param name="destinationPath"></param>
+        private static void CreateLinkWin(string sourcePath, string destinationPath)
+        {
+            string cmd = "/C mklink /J " + string.Format("\"{0}\" \"{1}\"", destinationPath, sourcePath);
+            Debug.Log("Windows junction: " + cmd);
+            ClonesManager.StartHiddenConsoleProcess("cmd.exe", cmd);
+        }
+
+        //TODO(?) avoid terminal calls and use proper api stuff. See below for windows! 
+        ////https://docs.microsoft.com/en-us/windows/desktop/api/ioapiset/nf-ioapiset-deviceiocontrol
+        //[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+        //private static extern bool DeviceIoControl(System.IntPtr hDevice, uint dwIoControlCode,
+        //	System.IntPtr InBuffer, int nInBufferSize,
+        //	System.IntPtr OutBuffer, int nOutBufferSize,
+        //	out int pBytesReturned, System.IntPtr lpOverlapped);
+
+        /// <summary>
+        /// Create a link / junction from the original project to it's clone.
+        /// </summary>
+        /// <param name="sourcePath"></param>
+        /// <param name="destinationPath"></param>
+        public static void LinkFolders(string sourcePath, string destinationPath)
+        {
+            if ((Directory.Exists(destinationPath) == false) && (Directory.Exists(sourcePath) == true))
+            {
+                switch (Application.platform)
+                {
+                    case (RuntimePlatform.WindowsEditor):
+                        CreateLinkWin(sourcePath, destinationPath);
+                        break;
+                    case (RuntimePlatform.OSXEditor):
+                        CreateLinkMac(sourcePath, destinationPath);
+                        break;
+                    case (RuntimePlatform.LinuxEditor):
+                        CreateLinkLinux(sourcePath, destinationPath);
+                        break;
+                    default:
+                        Debug.LogWarning("Not in a known editor. Application.platform: " + Application.platform);
+                        break;
+                }
+            }
+            else
+            {
+                Debug.LogWarning("Skipping Asset link, it already exists: " + destinationPath);
+            }
+        }
+
+        #endregion
+
+        #region Utility methods
+
+        private static bool? isCloneFileExistCache = null;
+
+        /// <summary>
+        /// Returns true if the project currently open in Unity Editor is a clone.
+        /// </summary>
+        /// <returns></returns>
+        public static bool IsClone()
+        {
+            if (isCloneFileExistCache == null)
+            {
+                /// The project is a clone if its root directory contains an empty file named ".clone".
+                string cloneFilePath = Path.Combine(ClonesManager.GetCurrentProjectPath(), ClonesManager.CloneFileName);
+                isCloneFileExistCache = File.Exists(cloneFilePath);
+            }
+
+            return (bool)isCloneFileExistCache;
+        }
+
+        /// <summary>
+        /// Get the path to the current unityEditor project folder's info
+        /// </summary>
+        /// <returns></returns>
+        public static string GetCurrentProjectPath()
+        {
+            return Application.dataPath.Replace("/Assets", "");
+        }
+
+        /// <summary>
+        /// Return a project object that describes all the paths we need to clone it.
+        /// </summary>
+        /// <returns></returns>
+        public static Project GetCurrentProject()
+        {
+            string pathString = ClonesManager.GetCurrentProjectPath();
+            return new Project(pathString);
+        }
+
+        /// <summary>
+        /// Get the argument of this clone project.
+        /// If this is the original project, will return an empty string.
+        /// </summary>
+        /// <returns></returns>
+        public static string GetArgument()
+        {
+            string argument = "";
+            if (IsClone())
+            {
+                string argumentFilePath = Path.Combine(GetCurrentProjectPath(), ClonesManager.ArgumentFileName);
+                if (File.Exists(argumentFilePath))
+                {
+                    argument = File.ReadAllText(argumentFilePath, System.Text.Encoding.UTF8);
+                }
+            }
+
+            return argument;
+        }
+
+        /// <summary>
+        /// Returns the path to the original project.
+        /// If currently open project is the original, returns its own path.
+        /// If the original project folder cannot be found, retuns an empty string.
+        /// </summary>
+        /// <returns></returns>
+        public static string GetOriginalProjectPath()
+        {
+            if (IsClone())
+            {
+                /// If this is a clone...
+                /// Original project path can be deduced by removing the suffix from the clone's path.
+                string cloneProjectPath = ClonesManager.GetCurrentProject().projectPath;
+
+                int index = cloneProjectPath.LastIndexOf(ClonesManager.CloneNameSuffix);
+                if (index > 0)
+                {
+                    string originalProjectPath = cloneProjectPath.Substring(0, index);
+                    if (Directory.Exists(originalProjectPath)) return originalProjectPath;
+                }
+
+                return string.Empty;
+            }
+            else
+            {
+                /// If this is the original, we return its own path.
+                return ClonesManager.GetCurrentProjectPath();
+            }
+        }
+
+        /// <summary>
+        /// Returns all clone projects path.
+        /// </summary>
+        /// <returns></returns>
+        public static List<string> GetCloneProjectsPath()
+        {
+            List<string> projectsPath = new List<string>();
+            for (int i = 0; i < MaxCloneProjectCount; i++)
+            {
+                string originalProjectPath = ClonesManager.GetCurrentProject().projectPath;
+                string cloneProjectPath = originalProjectPath + ClonesManager.CloneNameSuffix + "_" + i;
+
+                if (Directory.Exists(cloneProjectPath))
+                    projectsPath.Add(cloneProjectPath);
+            }
+
+            return projectsPath;
+        }
+
+        /// <summary>
+        /// Copies directory located at sourcePath to destinationPath. Displays a progress bar.
+        /// </summary>
+        /// <param name="source">Directory to be copied.</param>
+        /// <param name="destination">Destination directory (created automatically if needed).</param>
+        /// <param name="progressBarPrefix">Optional string added to the beginning of the progress bar window header.</param>
+        public static void CopyDirectoryWithProgressBar(string sourcePath, string destinationPath,
+            string progressBarPrefix = "")
+        {
+            var source = new DirectoryInfo(sourcePath);
+            var destination = new DirectoryInfo(destinationPath);
+
+            long totalBytes = 0;
+            long copiedBytes = 0;
+
+            ClonesManager.CopyDirectoryWithProgressBarRecursive(source, destination, ref totalBytes, ref copiedBytes,
+                progressBarPrefix);
+            EditorUtility.ClearProgressBar();
+        }
+
+        /// <summary>
+        /// Copies directory located at sourcePath to destinationPath. Displays a progress bar.
+        /// Same as the previous method, but uses recursion to copy all nested folders as well.
+        /// </summary>
+        /// <param name="source">Directory to be copied.</param>
+        /// <param name="destination">Destination directory (created automatically if needed).</param>
+        /// <param name="totalBytes">Total bytes to be copied. Calculated automatically, initialize at 0.</param>
+        /// <param name="copiedBytes">To track already copied bytes. Calculated automatically, initialize at 0.</param>
+        /// <param name="progressBarPrefix">Optional string added to the beginning of the progress bar window header.</param>
+        private static void CopyDirectoryWithProgressBarRecursive(DirectoryInfo source, DirectoryInfo destination,
+            ref long totalBytes, ref long copiedBytes, string progressBarPrefix = "")
+        {
+            /// Directory cannot be copied into itself.
+            if (source.FullName.ToLower() == destination.FullName.ToLower())
+            {
+                Debug.LogError("Cannot copy directory into itself.");
+                return;
+            }
+
+            /// Calculate total bytes, if required.
+            if (totalBytes == 0)
+            {
+                totalBytes = ClonesManager.GetDirectorySize(source, true, progressBarPrefix);
+            }
+
+            /// Create destination directory, if required.
+            if (!Directory.Exists(destination.FullName))
+            {
+                Directory.CreateDirectory(destination.FullName);
+            }
+
+            /// Copy all files from the source.
+            foreach (FileInfo file in source.GetFiles())
+            {
+                try
+                {
+                    file.CopyTo(Path.Combine(destination.ToString(), file.Name), true);
+                }
+                catch (IOException)
+                {
+                    /// Some files may throw IOException if they are currently open in Unity editor.
+                    /// Just ignore them in such case.
+                }
+
+                /// Account the copied file size.
+                copiedBytes += file.Length;
+
+                /// Display the progress bar.
+                float progress = (float)copiedBytes / (float)totalBytes;
+                bool cancelCopy = EditorUtility.DisplayCancelableProgressBar(
+                    progressBarPrefix + "Copying '" + source.FullName + "' to '" + destination.FullName + "'...",
+                    "(" + (progress * 100f).ToString("F2") + "%) Copying file '" + file.Name + "'...",
+                    progress);
+                if (cancelCopy) return;
+            }
+
+            /// Copy all nested directories from the source.
+            foreach (DirectoryInfo sourceNestedDir in source.GetDirectories())
+            {
+                DirectoryInfo nextDestingationNestedDir = destination.CreateSubdirectory(sourceNestedDir.Name);
+                ClonesManager.CopyDirectoryWithProgressBarRecursive(sourceNestedDir, nextDestingationNestedDir,
+                    ref totalBytes, ref copiedBytes, progressBarPrefix);
+            }
+        }
+
+        /// <summary>
+        /// Calculates the size of the given directory. Displays a progress bar.
+        /// </summary>
+        /// <param name="directory">Directory, which size has to be calculated.</param>
+        /// <param name="includeNested">If true, size will include all nested directories.</param>
+        /// <param name="progressBarPrefix">Optional string added to the beginning of the progress bar window header.</param>
+        /// <returns>Size of the directory in bytes.</returns>
+        private static long GetDirectorySize(DirectoryInfo directory, bool includeNested = false,
+            string progressBarPrefix = "")
+        {
+            EditorUtility.DisplayProgressBar(progressBarPrefix + "Calculating size of directories...",
+                "Scanning '" + directory.FullName + "'...", 0f);
+
+            /// Calculate size of all files in directory.
+            long filesSize = directory.GetFiles().Sum((FileInfo file) => file.Length);
+
+            /// Calculate size of all nested directories.
+            long directoriesSize = 0;
+            if (includeNested)
+            {
+                IEnumerable<DirectoryInfo> nestedDirectories = directory.GetDirectories();
+                foreach (DirectoryInfo nestedDir in nestedDirectories)
+                {
+                    directoriesSize += ClonesManager.GetDirectorySize(nestedDir, true, progressBarPrefix);
+                }
+            }
+
+            return filesSize + directoriesSize;
+        }
+
+        /// <summary>
+        /// Starts process in the system console, taking the given fileName and args.
+        /// </summary>
+        /// <param name="fileName"></param>
+        /// <param name="args"></param>
+        private static void StartHiddenConsoleProcess(string fileName, string args)
+        {
+            System.Diagnostics.Process.Start(fileName, args);
+        }
+
+        /// <summary>
+        /// Thanks to https://github.com/karl-/unity-symlink-utility/blob/master/SymlinkUtility.cs
+        /// </summary>
+        /// <param name="command"></param>
+        private static void ExecuteBashCommand(string command)
+        {
+            command = command.Replace("\"", "\"\"");
+
+            var proc = new Process()
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "/bin/bash",
+                    Arguments = "-c \"" + command + "\"",
+                    UseShellExecute = false,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,
+                    CreateNoWindow = true
+                }
+            };
+
+            using (proc)
+            {
+                proc.Start();
+                proc.WaitForExit();
+
+                if (!proc.StandardError.EndOfStream)
+                {
+                    UnityEngine.Debug.LogError(proc.StandardError.ReadToEnd());
+                }
+            }
+        }
+
+        public static void OpenProjectInFileExplorer(string path)
+        {
+            System.Diagnostics.Process.Start(@path);
+        }
+        #endregion
+    }
+}

Packages/ParrelSync/Editor/ClonesManager.cs.meta

+fileFormatVersion: 2
+guid: 6148e48ed6b61d748b187d06d3687b83
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/ClonesManagerWindow.cs

+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+namespace ParrelSync
+{
+    /// <summary>
+    ///Clones manager Unity editor window
+    /// </summary>
+	public class ClonesManagerWindow : EditorWindow
+    {
+        /// <summary>
+        /// Returns true if project clone exists.
+        /// </summary>
+        public bool isCloneCreated
+        {
+            get { return ClonesManager.GetCloneProjectsPath().Count >= 1; }
+        }
+
+        [MenuItem("ParrelSync/Clones Manager", priority = 0)]
+        private static void InitWindow()
+        {
+            ClonesManagerWindow window = (ClonesManagerWindow)EditorWindow.GetWindow(typeof(ClonesManagerWindow));
+            window.titleContent = new GUIContent("Clones Manager");
+            window.Show();
+        }
+
+        /// <summary>
+        /// For storing the scroll position of clones list
+        /// </summary>
+        Vector2 clonesScrollPos;
+
+        private void OnGUI()
+        {
+            /// If it is a clone project...
+            if (ClonesManager.IsClone())
+            {
+                //Find out the original project name and show the help box
+                string originalProjectPath = ClonesManager.GetOriginalProjectPath();
+                if (originalProjectPath == string.Empty)
+                {
+                    /// If original project cannot be found, display warning message.
+                    EditorGUILayout.HelpBox(
+                        "This project is a clone, but the link to the original seems lost.\nYou have to manually open the original and create a new clone instead of this one.\n",
+                        MessageType.Warning);
+                }
+                else
+                {
+                    /// If original project is present, display some usage info.
+                    EditorGUILayout.HelpBox(
+                        "This project is a clone of the project '" + Path.GetFileName(originalProjectPath) + "'.\nIf you want to make changes the project files or manage clones, please open the original project through Unity Hub.",
+                        MessageType.Info);
+                }
+
+                //Clone project custom argument.
+                GUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Arguments", GUILayout.Width(70));
+                if (GUILayout.Button("?", GUILayout.Width(20)))
+                {
+                    Application.OpenURL(ExternalLinks.CustomArgumentHelpLink);
+                }
+                GUILayout.EndHorizontal();
+
+                string argumentFilePath = Path.Combine(ClonesManager.GetCurrentProjectPath(), ClonesManager.ArgumentFileName);
+                //Need to be careful with file reading / writing since it will effect the deletion of
+                //  the clone project(The directory won't be fully deleted if there's still file inside being read or write).
+                //The argument file will be deleted first at the beginning of the project deletion process
+                //to prevent any further being read and write.
+                //Will need to take some extra cautious if want to change the design of how file editing is handled.
+                if (File.Exists(argumentFilePath))
+                {
+                    string argument = File.ReadAllText(argumentFilePath, System.Text.Encoding.UTF8);
+                    string argumentTextAreaInput = EditorGUILayout.TextArea(argument,
+                        GUILayout.Height(50),
+                        GUILayout.MaxWidth(300)
+                    );
+                    File.WriteAllText(argumentFilePath, argumentTextAreaInput, System.Text.Encoding.UTF8);
+                }
+                else
+                {
+                    EditorGUILayout.LabelField("No argument file found.");
+                }
+            }
+            else// If it is an original project...
+            {
+                if (isCloneCreated)
+                {
+                    GUILayout.BeginVertical("HelpBox");
+                    GUILayout.Label("Clones of this Project");
+
+                    //List all clones
+                    clonesScrollPos =
+                         EditorGUILayout.BeginScrollView(clonesScrollPos);
+                    var cloneProjectsPath = ClonesManager.GetCloneProjectsPath();
+                    for (int i = 0; i < cloneProjectsPath.Count; i++)
+                    {
+
+                        GUILayout.BeginVertical("GroupBox");
+                        string cloneProjectPath = cloneProjectsPath[i];
+
+                        bool isOpenInAnotherInstance = ClonesManager.IsCloneProjectRunning(cloneProjectPath);
+
+                        if (isOpenInAnotherInstance == true)
+                            EditorGUILayout.LabelField("Clone " + i + " (Running)", EditorStyles.boldLabel);
+                        else
+                            EditorGUILayout.LabelField("Clone " + i);
+
+
+                        GUILayout.BeginHorizontal();
+                        EditorGUILayout.TextField("Clone project path", cloneProjectPath, EditorStyles.textField);
+                        if (GUILayout.Button("View Folder", GUILayout.Width(80)))
+                        {
+                            ClonesManager.OpenProjectInFileExplorer(cloneProjectPath);
+                        }
+                        GUILayout.EndHorizontal();
+
+                        GUILayout.BeginHorizontal();
+                        EditorGUILayout.LabelField("Arguments", GUILayout.Width(70));
+                        if (GUILayout.Button("?", GUILayout.Width(20)))
+                        {
+                            Application.OpenURL(ExternalLinks.CustomArgumentHelpLink);
+                        }
+                        GUILayout.EndHorizontal();
+
+                        string argumentFilePath = Path.Combine(cloneProjectPath, ClonesManager.ArgumentFileName);
+                        //Need to be careful with file reading/writing since it will effect the deletion of
+                        //the clone project(The directory won't be fully deleted if there's still file inside being read or write).
+                        //The argument file will be deleted first at the beginning of the project deletion process 
+                        //to prevent any further being read and write.
+                        //Will need to take some extra cautious if want to change the design of how file editing is handled.
+                        if (File.Exists(argumentFilePath))
+                        {
+                            string argument = File.ReadAllText(argumentFilePath, System.Text.Encoding.UTF8);
+                            string argumentTextAreaInput = EditorGUILayout.TextArea(argument,
+                                GUILayout.Height(50),
+                                GUILayout.MaxWidth(300)
+                            );
+                            File.WriteAllText(argumentFilePath, argumentTextAreaInput, System.Text.Encoding.UTF8);
+                        }
+                        else
+                        {
+                            EditorGUILayout.LabelField("No argument file found.");
+                        }
+
+                        EditorGUILayout.Space();
+                        EditorGUILayout.Space();
+                        EditorGUILayout.Space();
+
+
+                        EditorGUI.BeginDisabledGroup(isOpenInAnotherInstance);
+
+                        if (GUILayout.Button("Open in New Editor"))
+                        {
+                            ClonesManager.OpenProject(cloneProjectPath);
+                        }
+
+                        GUILayout.BeginHorizontal();
+                        if (GUILayout.Button("Delete"))
+                        {
+                            bool delete = EditorUtility.DisplayDialog(
+                                "Delete the clone?",
+                                "Are you sure you want to delete the clone project '" + ClonesManager.GetCurrentProject().name + "_clone'?",
+                                "Delete",
+                                "Cancel");
+                            if (delete)
+                            {
+                                ClonesManager.DeleteClone(cloneProjectPath);
+                            }
+                        }
+
+                        GUILayout.EndHorizontal();
+                        EditorGUI.EndDisabledGroup();
+                        GUILayout.EndVertical();
+
+                    }
+                    EditorGUILayout.EndScrollView();
+
+                    if (GUILayout.Button("Add new clone"))
+                    {
+                        ClonesManager.CreateCloneFromCurrent();
+                    }
+
+                    GUILayout.EndVertical();
+                    GUILayout.FlexibleSpace();
+                }
+                else
+                {
+                    /// If no clone created yet, we must create it.
+                    EditorGUILayout.HelpBox("No project clones found. Create a new one!", MessageType.Info);
+                    if (GUILayout.Button("Create new clone"))
+                    {
+                        ClonesManager.CreateCloneFromCurrent();
+                    }
+                }
+            }
+        }
+    }
+}

Packages/ParrelSync/Editor/ClonesManagerWindow.cs.meta

+fileFormatVersion: 2
+guid: a041d83486c20b84bbf5077ddfbbca37
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/ExternalLinks.cs

+namespace ParrelSync
+{
+    public class ExternalLinks 
+    {
+        public const string RemoteVersionURL = "https://raw.githubusercontent.com/VeriorPies/ParrelSync/master/VERSION.txt";
+        public const string Releases = "https://github.com/VeriorPies/ParrelSync/releases";
+        public const string CustomArgumentHelpLink = "https://github.com/VeriorPies/ParrelSync/wiki/Argument";
+
+        public const string GitHubHome = "https://github.com/VeriorPies/ParrelSync/";
+        public const string GitHubIssue = "https://github.com/VeriorPies/ParrelSync/issues";
+        public const string FAQ = "https://github.com/VeriorPies/ParrelSync/wiki/Troubleshooting-&-FAQs";
+    }
+}

Packages/ParrelSync/Editor/ExternalLinks.cs.meta

+fileFormatVersion: 2
+guid: 65daf17fbe5101b41977305639f30c65
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/FileUtilities.cs

+using System.IO;
+using UnityEngine;
+
+namespace ParrelSync
+{
+    public class FileUtilities : MonoBehaviour
+    {
+        public static bool IsFileLocked(string path)
+        {
+            FileInfo file = new FileInfo(path);
+            try
+            {
+                using (FileStream stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None))
+                {
+                    stream.Close();
+                }
+            }
+            catch (IOException)
+            {
+                //the file is unavailable because it is:
+                //still being written to
+                //or being processed by another thread
+                //or does not exist (has already been processed)
+                return true;
+            }
+
+            //file is not locked
+            return false;
+        }
+    }
+}

Packages/ParrelSync/Editor/FileUtilities.cs.meta

+fileFormatVersion: 2
+guid: 11fdc6f78f8c965499a870ca06dca6bc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/NonCore.meta

+fileFormatVersion: 2
+guid: 74a7aa389726f964ab34c52e208c2a43
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/NonCore/AskFeedbackDialog.cs

+namespace ParrelSync.NonCore
+{
+    using UnityEditor;
+    using UnityEngine;
+
+    /// <summary>
+    /// A simple script to display feedback/star dialog after certain time of project being opened/re-compiled.
+    /// Will only pop-up once unless "Remind me next time" are chosen.
+    /// Removing this file from project wont effect any other functions.
+    /// </summary>
+    [InitializeOnLoad]
+    public class AskFeedbackDialog
+    {
+        const string InitializeOnLoadCountKey = "ParrelSync_InitOnLoadCount", StopShowingKey = "ParrelSync_StopShowFeedBack";
+        static AskFeedbackDialog()
+        {            
+            if (EditorPrefs.HasKey(StopShowingKey)) { return; }
+
+            int InitializeOnLoadCount = EditorPrefs.GetInt(InitializeOnLoadCountKey, 0);
+            if (InitializeOnLoadCount > 20)
+            {
+                ShowDialog();
+            }
+            else
+            {
+                EditorPrefs.SetInt(InitializeOnLoadCountKey, InitializeOnLoadCount + 1);
+            }
+        }
+
+        //[MenuItem("ParrelSync/(Debug)Show AskFeedbackDialog ")]
+        private static void ShowDialog()
+        {
+            int option = EditorUtility.DisplayDialogComplex("Do you like " + ParrelSync.ClonesManager.ProjectName + "?",
+                   "Do you like " + ParrelSync.ClonesManager.ProjectName + "?\n" +
+                   "If so, please don't hesitate to star it on GitHub and contribute to the project!",
+                   "Star on GitHub",
+                   "Close",
+                   "Remind me next time"
+               );
+
+            switch (option)
+            {
+                // First parameter.
+                case 0:
+                    Debug.Log("AskFeedbackDialog: Star on GitHub selected");
+                    EditorPrefs.SetBool(StopShowingKey, true);
+                    EditorPrefs.DeleteKey(InitializeOnLoadCountKey);
+                    Application.OpenURL(ExternalLinks.GitHubHome);
+                    break;
+                // Second parameter.
+                case 1:
+                    Debug.Log("AskFeedbackDialog: Close and never show again.");
+                    EditorPrefs.SetBool(StopShowingKey, true);
+                    EditorPrefs.DeleteKey(InitializeOnLoadCountKey);
+                    break;
+                // Third parameter.
+                case 2:
+                    Debug.Log("AskFeedbackDialog: Remind me next time");
+                    EditorPrefs.SetInt(InitializeOnLoadCountKey, 0);
+                    break;
+                default:
+                    //Debug.Log("Close windows.");
+                    break;
+            }
+        }
+
+        ///// <summary>
+        ///// For debug purpose
+        ///// </summary>
+        //[MenuItem("ParrelSync/(Debug)Delete AskFeedbackDialog keys")]
+        //private static void DebugDeleteAllKeys()
+        //{
+        //    EditorPrefs.DeleteKey(InitializeOnLoadCountKey);
+        //    EditorPrefs.DeleteKey(StopShowingKey);
+        //    Debug.Log("AskFeedbackDialog keys deleted");
+        //}
+    }
+}

Packages/ParrelSync/Editor/NonCore/AskFeedbackDialog.cs.meta

+fileFormatVersion: 2
+guid: 894412a5b602e6c4ba2cf2d01f4f92b5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/NonCore/OtherMenuItem.cs

+namespace ParrelSync.NonCore
+{
+    using UnityEditor;
+    using UnityEngine;
+
+    public class OtherMenuItem
+    {
+        [MenuItem("ParrelSync/GitHub/View this project on GitHub", priority = 10)]
+        private static void OpenGitHub()
+        {
+            Application.OpenURL(ExternalLinks.GitHubHome);
+        }
+
+        [MenuItem("ParrelSync/GitHub/View FAQ", priority = 11)]
+        private static void OpenFAQ()
+        {
+            Application.OpenURL(ExternalLinks.FAQ);
+        }
+
+        [MenuItem("ParrelSync/GitHub/View Issues", priority = 12)]
+        private static void OpenGitHubIssues()
+        {
+            Application.OpenURL(ExternalLinks.GitHubIssue);
+        }
+    }
+}

Packages/ParrelSync/Editor/NonCore/OtherMenuItem.cs.meta

+fileFormatVersion: 2
+guid: 7191fa4bfa12ae749b27f73ed292eaf1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/Preferences.cs

+using UnityEngine;
+using UnityEditor;
+
+namespace ParrelSync
+{
+    /// <summary>
+    /// To add value caching for <see cref="EditorPrefs"/> functions
+    /// </summary>
+    public class BoolPreference
+    {
+        public string key { get; private set; }
+        public bool defaultValue { get; private set; }
+        public BoolPreference(string key, bool defaultValue)
+        {
+            this.key = key;
+            this.defaultValue = defaultValue;
+        }
+
+        private bool? valueCache = null;
+
+        public bool Value
+        {
+            get
+            {
+                if (valueCache == null)
+                    valueCache = EditorPrefs.GetBool(key, defaultValue);
+
+                return (bool)valueCache;
+            }
+            set
+            {
+                if (valueCache == value)
+                    return;
+
+                EditorPrefs.SetBool(key, value);
+                valueCache = value;
+                Debug.Log("Editor preference updated. key: " + key + ", value: " + value);
+            }
+        }
+
+        public void ClearValue()
+        {
+            EditorPrefs.DeleteKey(key);
+            valueCache = null;
+        }
+    }
+
+    public class Preferences : EditorWindow
+    {
+        [MenuItem("ParrelSync/Preferences", priority = 1)]
+        private static void InitWindow()
+        {
+            Preferences window = (Preferences)EditorWindow.GetWindow(typeof(Preferences));
+            window.titleContent = new GUIContent(ClonesManager.ProjectName + " Preferences");
+            window.Show();
+        }
+
+        /// <summary>
+        /// Disable asset saving in clone editors?
+        /// </summary>
+        public static BoolPreference AssetModPref = new BoolPreference("ParrelSync_DisableClonesAssetSaving", true);
+
+        /// <summary>
+        /// In addition of checking the existence of UnityLockFile, 
+        /// also check is the is the UnityLockFile being opened.
+        /// </summary>
+        public static BoolPreference AlsoCheckUnityLockFileStaPref = new BoolPreference("ParrelSync_CheckUnityLockFileOpenStatus", true);
+
+        private void OnGUI()
+        {
+            if (ClonesManager.IsClone())
+            {
+                EditorGUILayout.HelpBox(
+                        "This is a clone project. Please use the original project editor to change preferences.",
+                        MessageType.Info);
+                return;
+            }
+
+            GUILayout.BeginVertical("HelpBox");
+            GUILayout.Label("Preferences");
+            GUILayout.BeginVertical("GroupBox");
+
+            AssetModPref.Value = EditorGUILayout.ToggleLeft(
+                new GUIContent(
+                    "(recommended) Disable asset saving in clone editors- require re-open clone editors",
+                    "Disable asset saving in clone editors so all assets can only be modified from the original project editor"
+                ),
+                AssetModPref.Value);
+
+            if (Application.platform == RuntimePlatform.WindowsEditor)
+            {
+                AlsoCheckUnityLockFileStaPref.Value = EditorGUILayout.ToggleLeft(
+                    new GUIContent(
+                        "Also check UnityLockFile lock status while checking clone projects running status",
+                        "Disable this can slightly increase Clones Manager window performance, but will lead to in-correct clone project running status" +
+                        "(the Clones Manager window show the clone project is still running even it's not) if the clone editor crashed"
+                    ),
+                    AlsoCheckUnityLockFileStaPref.Value);
+            }
+            GUILayout.EndVertical();
+            if (GUILayout.Button("Reset to default"))
+            {
+                AssetModPref.ClearValue();
+                AlsoCheckUnityLockFileStaPref.ClearValue();
+                Debug.Log("Editor preferences cleared");
+            }
+            GUILayout.EndVertical();
+        }
+    }
+}

Packages/ParrelSync/Editor/Preferences.cs.meta

+fileFormatVersion: 2
+guid: 24641be1c0410a745b529e61b508679f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/Project.cs

+using System.Collections.Generic;
+using System.Linq;
+
+namespace ParrelSync
+{
+    public class Project : System.ICloneable
+    {
+        public string name;
+        public string projectPath;
+        string rootPath;
+        public string assetPath;
+        public string projectSettingsPath;
+        public string libraryPath;
+        public string packagesPath;
+        public string autoBuildPath;
+        public string localPackages;
+
+        char[] separator = new char[1] { '/' };
+
+
+        /// <summary>
+        /// Default constructor
+        /// </summary>
+        public Project()
+        {
+
+        }
+
+
+        /// <summary>
+        /// Initialize the project object by parsing its full path returned by Unity into a bunch of individual folder names and paths.
+        /// </summary>
+        /// <param name="path"></param>
+        public Project(string path)
+        {
+            ParsePath(path);
+        }
+
+
+        /// <summary>
+        /// Create a new object with the same settings
+        /// </summary>
+        /// <returns></returns>
+        public object Clone()
+        {
+            Project newProject = new Project();
+            newProject.rootPath = rootPath;
+            newProject.projectPath = projectPath;
+            newProject.assetPath = assetPath;
+            newProject.projectSettingsPath = projectSettingsPath;
+            newProject.libraryPath = libraryPath;
+            newProject.name = name;
+            newProject.separator = separator;
+            newProject.packagesPath = packagesPath;
+            newProject.autoBuildPath = autoBuildPath;
+            newProject.localPackages = localPackages;
+
+
+            return newProject;
+        }
+
+
+        /// <summary>
+        /// Update the project object by renaming and reparsing it. Pass in the new name of a project, and it'll update the other member variables to match.
+        /// </summary>
+        /// <param name="name"></param>
+        public void updateNewName(string newName)
+        {
+            name = newName;
+            ParsePath(rootPath + "/" + name + "/Assets");
+        }
+
+
+        /// <summary>
+        /// Debug override so we can quickly print out the project info.
+        /// </summary>
+        /// <returns></returns>
+        public override string ToString()
+        {
+            string printString = name + "\n" +
+                                 rootPath + "\n" +
+                                 projectPath + "\n" +
+                                 assetPath + "\n" +
+                                 projectSettingsPath + "\n" +
+                                 packagesPath + "\n" +
+                                 autoBuildPath + "\n" +
+                                 localPackages + "\n" +
+                                 libraryPath;
+            return (printString);
+        }
+
+        private void ParsePath(string path)
+        {
+            //Unity's Application functions return the Assets path in the Editor. 
+            projectPath = path;
+
+            //pop off the last part of the path for the project name, keep the rest for the root path
+            List<string> pathArray = projectPath.Split(separator).ToList<string>();
+            name = pathArray.Last();
+
+            pathArray.RemoveAt(pathArray.Count() - 1);
+            rootPath = string.Join(separator[0].ToString(), pathArray.ToArray());
+
+            assetPath = projectPath + "/Assets";
+            projectSettingsPath = projectPath + "/ProjectSettings";
+            libraryPath = projectPath + "/Library";
+            packagesPath = projectPath + "/Packages";
+            autoBuildPath = projectPath + "/AutoBuild";
+            localPackages = projectPath + "/LocalPackages";
+        }
+    }
+}

Packages/ParrelSync/Editor/Project.cs.meta

+fileFormatVersion: 2
+guid: ec8d3a1577179ef44815739178cf75b4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/UpdateChecker.cs

+using System;
+using UnityEditor;
+using UnityEngine;
+namespace ParrelSync.Update
+{
+    /// <summary>
+    /// A simple update checker
+    /// </summary>
+    public class UpdateChecker
+    {
+        //const string LocalVersionFilePath = "Assets/ParrelSync/VERSION.txt";
+        public const string LocalVersion = "1.5.0";
+        [MenuItem("ParrelSync/Check for update", priority = 20)]
+        static void CheckForUpdate()
+        {
+            using (System.Net.WebClient client = new System.Net.WebClient())
+            {
+                try
+                {
+                    //This won't work with UPM packages
+                    //string localVersionText = AssetDatabase.LoadAssetAtPath<TextAsset>(LocalVersionFilePath).text;
+
+                    string localVersionText = LocalVersion;
+                    Debug.Log("Local version text : " + LocalVersion);
+
+                    string latesteVersionText = client.DownloadString(ExternalLinks.RemoteVersionURL);
+                    Debug.Log("latest version text got: " + latesteVersionText);
+                    string messageBody = "Current Version: " + localVersionText +"\n"
+                                         +"Latest Version: " + latesteVersionText + "\n";
+                    var latestVersion = new Version(latesteVersionText);
+                    var localVersion = new Version(localVersionText);
+
+                    if (latestVersion > localVersion)
+                    {
+                        Debug.Log("There's a newer version");
+                        messageBody += "There's a newer version available";
+                        if(EditorUtility.DisplayDialog("Check for update.", messageBody, "Get latest release", "Close"))
+                        {
+                            Application.OpenURL(ExternalLinks.Releases);
+                        }
+                    }
+                    else
+                    {
+                        Debug.Log("Current version is up-to-date.");
+                        messageBody += "Current version is up-to-date.";
+                        EditorUtility.DisplayDialog("Check for update.", messageBody,"OK");
+                    }
+                    
+                }
+                catch (Exception exp)
+                {
+                    Debug.LogError("Error with checking update. Exception: " + exp);
+                    EditorUtility.DisplayDialog("Update Error","Error with checking update. \nSee console for more details.",
+                     "OK"
+                    );
+                }
+            }
+        }
+    }
+}

Packages/ParrelSync/Editor/UpdateChecker.cs.meta

+fileFormatVersion: 2
+guid: d3453b3f1a20ea148b5028f8556a7be5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/Editor/ValidateCopiedFoldersIntegrity.cs

+namespace ParrelSync.NonCore
+{
+    using UnityEditor;
+    using UnityEngine;
+    using System;
+    using System.Text;
+    using System.Security.Cryptography;
+    using System.IO;
+    using System.Linq;
+
+    [InitializeOnLoad]
+    public class ValidateCopiedFoldersIntegrity
+    {
+        const string SessionStateKey = "ValidateCopiedFoldersIntegrity_Init";
+        /// <summary>
+        /// Called once on editor startup.
+        /// Validate copied folders integrity in clone project
+        /// </summary>
+        static ValidateCopiedFoldersIntegrity()
+        {
+            if (!SessionState.GetBool(SessionStateKey, false))
+            {
+                SessionState.SetBool(SessionStateKey, true);
+                if (!ClonesManager.IsClone()) { return; }
+
+                ValidateFolder("Packages");
+            }
+        }
+
+        static void ValidateFolder(string folderName)
+        {
+            var currentProjectPath = Path.Combine(ClonesManager.GetCurrentProjectPath(), folderName);
+            var currentFolderHash = CreateMd5ForFolder(currentProjectPath);
+
+            var originalProjectPath = Path.Combine(ClonesManager.GetOriginalProjectPath(), folderName);
+            var originalFolderHash = CreateMd5ForFolder(originalProjectPath);
+
+            if (currentFolderHash != originalFolderHash)
+            {
+                Debug.Log("ParrelSync: Detected '" + folderName + "' folder changes in the original project. Updating...");
+                FileUtil.ReplaceDirectory(originalProjectPath, currentProjectPath);
+            }
+        }
+
+        static string CreateMd5ForFolder(string path)
+        {
+            // assuming you want to include nested folders
+            var files = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories)
+                                 .OrderBy(p => p).ToList();
+
+            MD5 md5 = MD5.Create();
+
+            for (int i = 0; i < files.Count; i++)
+            {
+                string file = files[i];
+
+                // hash path
+                string relativePath = file.Substring(path.Length + 1);
+                byte[] pathBytes = Encoding.UTF8.GetBytes(relativePath.ToLower());
+                md5.TransformBlock(pathBytes, 0, pathBytes.Length, pathBytes, 0);
+
+                // hash contents
+                byte[] contentBytes = File.ReadAllBytes(file);
+                if (i == files.Count - 1)
+                    md5.TransformFinalBlock(contentBytes, 0, contentBytes.Length);
+                else
+                    md5.TransformBlock(contentBytes, 0, contentBytes.Length, contentBytes, 0);
+            }
+
+            return BitConverter.ToString(md5.Hash).Replace("-", "").ToLower();
+        }
+    }
+}

Packages/ParrelSync/Editor/ValidateCopiedFoldersIntegrity.cs.meta

+fileFormatVersion: 2
+guid: d8fb344b9abf5274abd744833474b087
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/package.json

+{
+    "name": "com.veriorpies.parrelsync",
+    "displayName": "ParrelSync",
+    "version": "1.5.0",
+    "unity": "2018.4",
+    "description": "ParrelSync is a Unity editor extension that allows users to test multiplayer gameplay without building the project by having another Unity editor window opened and mirror the changes from the original project.",
+    "license": "MIT",
+	"keywords": [ "Networking", "Utils", "Editor", "Extensions" ],
+    "dependencies": {}
+}

Packages/ParrelSync/package.json.meta

+fileFormatVersion: 2
+guid: a2a889c264e34b47a7349cbcb2cbedd7
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/ParrelSync/projectCloner.asmdef

+{
+    "name": "ParrelSync",
+    "references": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Packages/ParrelSync/projectCloner.asmdef.meta

+fileFormatVersion: 2
+guid: 894a6cc6ed5cd2645bb542978cbed6a9
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: