devbeni/Multiplayer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

alap

Browse Source
This commit is contained in:
B3ni
2025-06-16 15:24:27 +02:00
commit 83a46b2fc4
1452 changed files with 214261 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Assets/ParrelSync/Examples.meta Normal file
View File

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

31
Assets/ParrelSync/Examples/CustomArgumentExample.cs Normal file
View File

@ -0,0 +1,31 @@
// This should be editor only
#if UNITY_EDITOR
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace ParrelSync.Example
{
public class CustomArgumentExample : MonoBehaviour
{
// Start is called before the first frame update
void Start()
{
// Is this editor instance running a clone project?
if (ClonesManager.IsClone())
{
Debug.Log("This is a clone project.");
//Argument can be set from the clones manager window.
string customArgument = ClonesManager.GetArgument();
Debug.Log("The custom argument of this clone project is: " + customArgument);
// Do what ever you need with the argument string.
}
else
{
Debug.Log("This is the original project.");
}
}
}
}
#endif

11
Assets/ParrelSync/Examples/CustomArgumentExample.cs.meta Normal file
View File

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

22
Assets/ParrelSync/LICENSE.md Normal file
View File

@ -0,0 +1,22 @@
MIT License
Copyright (c) 2018 Greg M
Copyright (c) 2020 Ian and Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

7
Assets/ParrelSync/LICENSE.md.meta Normal file
View File

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

8
Assets/ParrelSync/ParrelSync.meta Normal file
View File

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

8
Assets/ParrelSync/ParrelSync/Editor.meta Normal file
View File

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

8
Assets/ParrelSync/ParrelSync/Editor/AssetModBlock.meta Normal file
View File

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

22
Assets/ParrelSync/ParrelSync/Editor/AssetModBlock/EditorQuit.cs Normal file
View File

@ -0,0 +1,22 @@
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;
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/AssetModBlock/EditorQuit.cs.meta Normal file
View File

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

34
Assets/ParrelSync/ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs Normal file
View File

@ -0,0 +1,34 @@
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;
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/AssetModBlock/ParrelSyncAssetModificationProcessor.cs.meta Normal file
View File

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

668
Assets/ParrelSync/ParrelSync/Editor/ClonesManager.cs Normal file
View File

@ -0,0 +1,668 @@
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;
}
//Validate (and update if needed) the "Packages" folder before opening clone project to ensure the clone project will have the
//same "compiling environment" as the original project
ValidateCopiedFoldersIntegrity.ValidateFolder(projectPath, GetOriginalProjectPath(), "Packages");
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
}
}

11
Assets/ParrelSync/ParrelSync/Editor/ClonesManager.cs.meta Normal file
View File

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

198
Assets/ParrelSync/ParrelSync/Editor/ClonesManagerWindow.cs Normal file
View File

@ -0,0 +1,198 @@
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();
}
}
}
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/ClonesManagerWindow.cs.meta Normal file
View File

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

13
Assets/ParrelSync/ParrelSync/Editor/ExternalLinks.cs Normal file
View File

@ -0,0 +1,13 @@
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";
}
}

11
Assets/ParrelSync/ParrelSync/Editor/ExternalLinks.cs.meta Normal file
View File

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

31
Assets/ParrelSync/ParrelSync/Editor/FileUtilities.cs Normal file
View File

@ -0,0 +1,31 @@
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;
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/FileUtilities.cs.meta Normal file
View File

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

8
Assets/ParrelSync/ParrelSync/Editor/NonCore.meta Normal file
View File

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

78
Assets/ParrelSync/ParrelSync/Editor/NonCore/AskFeedbackDialog.cs Normal file
View File

@ -0,0 +1,78 @@
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");
//}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/NonCore/AskFeedbackDialog.cs.meta Normal file
View File

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

26
Assets/ParrelSync/ParrelSync/Editor/NonCore/OtherMenuItem.cs Normal file
View File

@ -0,0 +1,26 @@
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);
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/NonCore/OtherMenuItem.cs.meta Normal file
View File

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

110
Assets/ParrelSync/ParrelSync/Editor/Preferences.cs Normal file
View File

@ -0,0 +1,110 @@
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();
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/Preferences.cs.meta Normal file
View File

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

112
Assets/ParrelSync/ParrelSync/Editor/Project.cs Normal file
View File

@ -0,0 +1,112 @@
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";
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/Project.cs.meta Normal file
View File

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

60
Assets/ParrelSync/ParrelSync/Editor/UpdateChecker.cs Normal file
View File

@ -0,0 +1,60 @@
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.1";
[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"
);
}
}
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/UpdateChecker.cs.meta Normal file
View File

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

73
Assets/ParrelSync/ParrelSync/Editor/ValidateCopiedFoldersIntegrity.cs Normal file
View File

@ -0,0 +1,73 @@
namespace ParrelSync
{
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(ClonesManager.GetCurrentProjectPath(), ClonesManager.GetOriginalProjectPath(), "Packages");
}
}
public static void ValidateFolder(string targetRoot, string originalRoot, string folderName)
{
var targetFolderPath = Path.Combine(targetRoot, folderName);
var targetFolderHash = CreateMd5ForFolder(targetFolderPath);
var originalFolderPath = Path.Combine(originalRoot, folderName);
var originalFolderHash = CreateMd5ForFolder(originalFolderPath);
if (targetFolderHash != originalFolderHash)
{
Debug.Log("ParrelSync: Detected changes in '" + folderName + "' directory. Updating cloned project...");
FileUtil.ReplaceDirectory(originalFolderPath, targetFolderPath);
}
}
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();
}
}
}

11
Assets/ParrelSync/ParrelSync/Editor/ValidateCopiedFoldersIntegrity.cs.meta Normal file
View File

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

10
Assets/ParrelSync/ParrelSync/package.json Normal file
View File

@ -0,0 +1,10 @@
{
"name": "com.veriorpies.parrelsync",
"displayName": "ParrelSync",
"version": "1.5.1",
"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": {}
}

7
Assets/ParrelSync/ParrelSync/package.json.meta Normal file
View File

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

15
Assets/ParrelSync/ParrelSync/projectCloner.asmdef Normal file
View File

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

7
Assets/ParrelSync/ParrelSync/projectCloner.asmdef.meta Normal file
View File

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

91
Assets/ParrelSync/README.md Normal file
View File

@ -0,0 +1,91 @@
# ParrelSync
[![Release](https://img.shields.io/github/v/release/VeriorPies/ParrelSync?include_prereleases)](https://github.com/VeriorPies/ParrelSync/releases) [![Documentation](https://img.shields.io/badge/documentation-brightgreen.svg)](https://github.com/VeriorPies/ParrelSync/wiki) [![License](https://img.shields.io/badge/license-MIT-green)](https://github.com/VeriorPies/ParrelSync/blob/master/LICENSE.md) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-blue.svg)](https://github.com/VeriorPies/ParrelSync/pulls) [![Chats](https://img.shields.io/discord/710688100996743200)](https://discord.gg/TmQk2qG)
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.
<br>
![ShortGif](https://raw.githubusercontent.com/VeriorPies/ParrelSync/master/Images/Showcase%201.gif)
<p align="center">
<b>Test project changes on clients and server within seconds - both in editor
</b>
<br>
</p>
## Features
1. Test multiplayer gameplay without building the project
2. GUI tools for managing all project clones
3. Protected assets from being modified by other clone instances
4. Handy APIs to speed up testing workflows
## Installation
1. Backup your project folder or use a version control system such as [Git](https://git-scm.com/) or [SVN](https://subversion.apache.org/)
2. Download .unitypackage from the [latest release](https://github.com/VeriorPies/ParrelSync/releases) and import it to your project.
3. ParrelSync should appreared in the menu item bar after imported
![UpdateButtonInMenu](https://github.com/VeriorPies/ParrelSync/raw/master/Images/AfterImported.png)
Check out the [Installation-and-Update](https://github.com/VeriorPies/ParrelSync/wiki/Installation-and-Update) page for more details.
### UPM Package
ParrelSync can also be installed via UPM package.
After Unity 2019.3.4f1, Unity 2020.1a21, which support path query parameter of git package. You can install ParrelSync by adding the following to Package Manager.
```
https://github.com/VeriorPies/ParrelSync.git?path=/ParrelSync
```
![UPM_Image](https://github.com/VeriorPies/ParrelSync/raw/master/Images/UPM_1.png?raw=true) ![UPM_Image2](https://github.com/VeriorPies/ParrelSync/raw/master/Images/UPM_2.png?raw=true)
or by adding
```
"com.veriorpies.parrelsync": "https://github.com/VeriorPies/ParrelSync.git?path=/ParrelSync"
```
to the `Packages/manifest.json` file
## Supported Platform
Currently, ParrelSync supports Windows, macOS and Linux editors.
ParrelSync has been tested with the following Unity version. However, it should also work with other versions as well.
* *2020.3.1f1*
* *2019.3.0f6*
* *2018.4.22f1*
## APIs
There's some useful APIs for speeding up the multiplayer testing workflow.
Here's a basic example:
```
if (ClonesManager.IsClone()) {
// Automatically connect to local host if this is the clone editor
}else{
// Automatically start server if this is the original editor
}
```
Check out [the doc](https://github.com/VeriorPies/ParrelSync/wiki/List-of-APIs) to view the complete API list.
## How does it work?
For each clone instance, ParrelSync will make a copy of the original project folder and reference the ```Asset```, ```Packages``` and ```ProjectSettings``` folder back to the original project with [symbolic link](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/mklink). Other folders such as ```Library```, ```Temp```, and ```obj``` will remain independent for each clone project.
All clones are placed right next to the original project with suffix *```_clone_x```*, which will be something like this in the folder hierarchy.
```
/ProjectName
/ProjectName_clone_0
/ProjectName_clone_1
...
```
## Discord Server
We have a [Discord server](https://discord.gg/TmQk2qG).
## Need Help?
Some common questions and troubleshooting can be found under the [Troubleshooting & FAQs](https://github.com/VeriorPies/ParrelSync/wiki/Troubleshooting-&-FAQs) page.
You can also [create a question post](https://github.com/VeriorPies/ParrelSync/issues/new/choose), or ask on [Discord](https://discord.gg/TmQk2qG) if you prefer to have a real-time conversation.
## Support this project
A star will be appreciated :)
## Credits
This project is originated from hwaet's [UnityProjectCloner](https://github.com/hwaet/UnityProjectCloner)

7
Assets/ParrelSync/README.md.meta Normal file
View File

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

1
Assets/ParrelSync/VERSION.txt Normal file
View File

@ -0,0 +1 @@
1.5.1

7
Assets/ParrelSync/VERSION.txt.meta Normal file
View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 9833b240625d4e14995c296b87e34b96
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant: