com.wallstop-studios.unity-helpers 2.0.0-rc73.18 → 2.0.0-rc73.2

package/Editor/{Sprites/AnimationCopier.cs → AnimationCopier.cs}

@@ -1,4 +1,4 @@
-namespace WallstopStudios.UnityHelpers.Editor.Sprites
+namespace WallstopStudios.UnityHelpers.Editor
 {
 #if UNITY_EDITOR
     using System;
@@ -9,16 +9,16 @@
     using UnityEditor;
     using UnityEngine;
     using Core.Extension;
-    using Core.Helper;
-    using CustomEditors;
 
     public sealed class AnimationCopierWindow : EditorWindow
     {
-        [SerializeField]
-        private string _animationSourcePathRelative = "Assets/Sprites";
+        private const string SourcePathPrefKey = "AnimationCopier_SourcePathRelative";
+        private const string DestPathPrefKey = "AnimationCopier_DestPathRelative";
+        private const string DefaultSourcePath = "Assets/Sprites";
+        private const string DefaultDestPath = "Assets/Animations";
 
-        [SerializeField]
-        private string _animationDestinationPathRelative = "Assets/Animations";
+        private string _animationSourcePathRelative = "";
+        private string _animationDestinationPathRelative = "";
         private string _fullSourcePath = "";
         private string _fullDestinationPath = "";
 
@@ -27,10 +27,6 @@
         private bool _isCopying;
         private bool _isDeleting;
 
-        private SerializedObject _serializedObject;
-        private SerializedProperty _animationSourcesPathProperty;
-        private SerializedProperty _animationDestinationPathProperty;
-
         private readonly List<AnimationFileInfo> _sourceAnimations = new();
         private readonly List<AnimationFileInfo> _newAnimations = new();
         private readonly List<AnimationFileInfo> _changedAnimations = new();
@@ -62,7 +58,7 @@
             public string DestinationRelativePath { get; set; }
         }
 
-        [MenuItem("Tools/Wallstop Studios/Unity Helpers/Animation Copier", priority = -2)]
+        [MenuItem("Tools/Wallstop Studios/Unity Helpers/Animation Copier Window", priority = -2)]
         public static void ShowWindow()
         {
             GetWindow<AnimationCopierWindow>("Animation Copier");
@@ -70,13 +66,7 @@
 
         private void OnEnable()
         {
-            _serializedObject = new SerializedObject(this);
-            _animationSourcesPathProperty = _serializedObject.FindProperty(
-                nameof(_animationSourcePathRelative)
-            );
-            _animationDestinationPathProperty = _serializedObject.FindProperty(
-                nameof(_animationDestinationPathRelative)
-            );
+            LoadPaths();
             ValidatePaths();
             _analysisNeeded = true;
             this.Log($"Animation Copier Window opened.");
@@ -84,7 +74,6 @@
 
         private void OnGUI()
         {
-            _serializedObject.Update();
             bool operationInProgress = _isAnalyzing || _isCopying || _isDeleting;
 
             if (operationInProgress)
@@ -98,18 +87,18 @@
 
             EditorGUI.BeginDisabledGroup(operationInProgress);
 
-            PersistentDirectoryGUI.PathSelectorString(
-                _animationSourcesPathProperty,
-                nameof(AnimationCopierWindow),
+            DrawPathSection(
                 "Source Path",
-                new GUIContent("Source Path")
+                ref _animationSourcePathRelative,
+                ref _fullSourcePath,
+                SourcePathPrefKey
             );
             EditorGUILayout.Separator();
-            PersistentDirectoryGUI.PathSelectorString(
-                _animationDestinationPathProperty,
-                nameof(AnimationCopierWindow),
+            DrawPathSection(
                 "Destination Path",
-                new GUIContent("Destination Path")
+                ref _animationDestinationPathRelative,
+                ref _fullDestinationPath,
+                DestPathPrefKey
             );
             EditorGUILayout.Separator();
 
@@ -136,6 +125,85 @@
             }
         }
 
+        private void DrawPathSection(
+            string label,
+            ref string relativePath,
+            ref string fullPath,
+            string prefKey
+        )
+        {
+            if (!prefKey.StartsWith("WallstopStudios.UnityHelpers.Editor"))
+            {
+                prefKey = "WallstopStudios.UnityHelpers.Editor" + prefKey;
+            }
+            EditorGUILayout.LabelField(label + ":", EditorStyles.boldLabel);
+
+            EditorGUI.BeginChangeCheck();
+            string newRelativePath = EditorGUILayout.TextField(relativePath ?? "");
+            if (EditorGUI.EndChangeCheck() && newRelativePath != relativePath)
+            {
+                if (string.IsNullOrWhiteSpace(newRelativePath))
+                {
+                    relativePath = "";
+                    fullPath = "";
+                    EditorPrefs.SetString(prefKey, "");
+                    ValidatePaths();
+                    _analysisNeeded = true;
+                }
+                else
+                {
+                    string tempFullPath = GetFullPathFromRelative(newRelativePath);
+                    if (tempFullPath != null && Directory.Exists(tempFullPath))
+                    {
+                        relativePath = newRelativePath;
+                        fullPath = tempFullPath;
+                        EditorPrefs.SetString(prefKey, relativePath);
+                        ValidatePaths();
+                        _analysisNeeded = true;
+                    }
+                    else
+                    {
+                        this.LogWarn(
+                            $"Manual path entry '{newRelativePath}' is invalid or not inside Assets. Please use the button."
+                        );
+                    }
+                }
+            }
+
+            if (GUILayout.Button("Browse..."))
+            {
+                string initialPath = Directory.Exists(fullPath) ? fullPath : Application.dataPath;
+                string selectedPath = EditorUtility.OpenFolderPanel(
+                    $"Select {label}",
+                    initialPath,
+                    string.Empty
+                );
+
+                if (!string.IsNullOrWhiteSpace(selectedPath))
+                {
+                    string newRelPath = GetRelativeAssetPath(selectedPath);
+                    if (newRelPath != null)
+                    {
+                        relativePath = newRelPath;
+                        fullPath = selectedPath.Replace(Path.DirectorySeparatorChar, '/');
+                        EditorPrefs.SetString(prefKey, relativePath);
+                        this.Log($"{label} set to: {relativePath}");
+                        ValidatePaths();
+                        _analysisNeeded = true;
+                        Repaint();
+                    }
+                    else
+                    {
+                        EditorUtility.DisplayDialog(
+                            "Invalid Path",
+                            "The selected path must be inside the project's 'Assets' folder.",
+                            "OK"
+                        );
+                    }
+                }
+            }
+        }
+
         private void DrawAnalysisSection()
         {
             EditorGUILayout.LabelField("Analysis:", EditorStyles.boldLabel);
@@ -270,6 +338,18 @@
             }
         }
 
+        private void LoadPaths()
+        {
+            _animationSourcePathRelative = EditorPrefs.GetString(
+                SourcePathPrefKey,
+                DefaultSourcePath
+            );
+            _animationDestinationPathRelative = EditorPrefs.GetString(
+                DestPathPrefKey,
+                DefaultDestPath
+            );
+        }
+
         private void ValidatePaths()
         {
             _fullSourcePath = GetFullPathFromRelative(_animationSourcePathRelative);
@@ -309,12 +389,7 @@
             return !string.IsNullOrWhiteSpace(_animationSourcePathRelative)
                 && !string.IsNullOrWhiteSpace(_animationDestinationPathRelative)
                 && _fullSourcePath != null
-                && _fullDestinationPath != null
-                && !string.Equals(
-                    _animationSourcePathRelative,
-                    _animationDestinationPathRelative,
-                    StringComparison.Ordinal
-                );
+                && _fullDestinationPath != null;
         }
 
         private void AnalyzeAnimations()
@@ -361,10 +436,7 @@
                     string sourceRelPath = AssetDatabase.GUIDToAssetPath(guid);
                     if (
                         string.IsNullOrWhiteSpace(sourceRelPath)
-                        || !sourceRelPath.StartsWith(
-                            _animationSourcePathRelative,
-                            StringComparison.OrdinalIgnoreCase
-                        )
+                        || !sourceRelPath.StartsWith(_animationSourcePathRelative)
                     )
                     {
                         continue;
@@ -388,7 +460,7 @@
                         FileName = Path.GetFileName(sourceRelPath),
                         RelativeDirectory = GetRelativeSubPath(
                             _animationSourcePathRelative,
-                            directoryName.SanitizePath()
+                            directoryName.Replace(Path.DirectorySeparatorChar, '/')
                         ),
                         Hash = CalculateFileHash(sourceFullPath),
                     };
@@ -397,7 +469,7 @@
                             fileInfo.RelativeDirectory,
                             fileInfo.FileName
                         )
-                        .SanitizePath();
+                        .Replace(Path.DirectorySeparatorChar, '/');
                     _sourceAnimations.Add(fileInfo);
 
                     EditorUtility.DisplayProgressBar(
@@ -433,10 +505,7 @@
                     else
                     {
                         string destHash = CalculateFileHash(destFullPath);
-                        if (
-                            string.IsNullOrWhiteSpace(sourceInfo.Hash)
-                            || string.IsNullOrWhiteSpace(destHash)
-                        )
+                        if (string.IsNullOrEmpty(sourceInfo.Hash) || string.IsNullOrEmpty(destHash))
                         {
                             this.LogWarn(
                                 $"Could not compare '{sourceInfo.FileName}' due to hashing error. Treating as 'Changed'."
@@ -524,32 +593,8 @@
 
             int successCount = 0;
             int errorCount = 0;
-            foreach (AnimationFileInfo animInfo in animationsToCopy)
-            {
-                string destinationAssetPath = animInfo.DestinationRelativePath;
-                string destDirectory = Path.GetDirectoryName(destinationAssetPath).SanitizePath();
-
-                if (
-                    string.IsNullOrWhiteSpace(destDirectory)
-                    || AssetDatabase.IsValidFolder(destDirectory)
-                )
-                {
-                    continue;
-                }
-
-                try
-                {
-                    DirectoryHelper.EnsureDirectoryExists(destDirectory);
-                }
-                catch (Exception ex)
-                {
-                    this.LogError(
-                        $"Failed to create destination directory '{destDirectory}' for animation '{animInfo.FileName}'. Error: {ex.Message}. Skipping."
-                    );
-                }
-            }
-
             AssetDatabase.StartAssetEditing();
+
             try
             {
                 for (int i = 0; i < animationsToCopy.Count; i++)
@@ -570,6 +615,27 @@
 
                     string sourceAssetPath = animInfo.RelativePath;
                     string destinationAssetPath = animInfo.DestinationRelativePath;
+                    string destDirectory = Path.GetDirectoryName(destinationAssetPath);
+
+                    if (
+                        !string.IsNullOrEmpty(destDirectory)
+                        && !AssetDatabase.IsValidFolder(destDirectory)
+                    )
+                    {
+                        try
+                        {
+                            EnsureDirectoryExists(destDirectory);
+                        }
+                        catch (Exception ex)
+                        {
+                            this.LogError(
+                                $"Failed to create destination directory '{destDirectory}' for animation '{animInfo.FileName}'. Error: {ex.Message}. Skipping."
+                            );
+                            errorCount++;
+                            continue;
+                        }
+                    }
+
                     bool copySuccessful = AssetDatabase.CopyAsset(
                         sourceAssetPath,
                         destinationAssetPath
@@ -718,7 +784,7 @@
                 return null;
             }
 
-            fullPath = fullPath.SanitizePath();
+            fullPath = fullPath.Replace(Path.DirectorySeparatorChar, '/');
             if (
                 fullPath.EndsWith("/Assets", StringComparison.OrdinalIgnoreCase)
                 && Path.GetFileName(fullPath).Equals("Assets", StringComparison.OrdinalIgnoreCase)
@@ -727,7 +793,7 @@
                 return "Assets";
             }
 
-            string assetsPath = Application.dataPath.SanitizePath();
+            string assetsPath = Application.dataPath.Replace(Path.DirectorySeparatorChar, '/');
             if (fullPath.StartsWith(assetsPath, StringComparison.OrdinalIgnoreCase))
             {
                 if (fullPath.Length == assetsPath.Length)
@@ -762,7 +828,7 @@
 
             if (relativePath.Equals("Assets", StringComparison.OrdinalIgnoreCase))
             {
-                return Application.dataPath.SanitizePath();
+                return Application.dataPath.Replace(Path.DirectorySeparatorChar, '/');
             }
 
             if (relativePath.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase))
@@ -771,7 +837,7 @@
                     0,
                     Application.dataPath.Length - "Assets".Length
                 );
-                return (projectRoot + relativePath).SanitizePath();
+                return (projectRoot + relativePath).Replace(Path.DirectorySeparatorChar, '/');
             }
             return null;
         }
@@ -800,32 +866,91 @@
             return string.Empty;
         }
 
-        private string CalculateFileHash(string filePath)
+        private static string CalculateFileHash(string filePath)
         {
             try
             {
-                using MD5 md5 = MD5.Create();
-                using FileStream stream = File.OpenRead(filePath);
-                byte[] hashBytes = md5.ComputeHash(stream);
-                return BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
+                using (MD5 md5 = MD5.Create())
+                using (FileStream stream = File.OpenRead(filePath))
+                {
+                    byte[] hashBytes = md5.ComputeHash(stream);
+                    return BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
+                }
             }
             catch (IOException ioEx)
             {
-                this.LogError(
-                    $"[AnimationCopierWindow] IO Error calculating hash for {filePath}.",
-                    ioEx
+                Debug.LogError(
+                    $"[AnimationCopierWindow] IO Error calculating hash for {filePath}: {ioEx.Message}"
                 );
                 return string.Empty;
             }
             catch (Exception ex)
             {
-                this.LogError(
-                    $"[AnimationCopierWindow] Error calculating hash for {filePath}.",
-                    ex
+                Debug.LogError(
+                    $"[AnimationCopierWindow] Error calculating hash for {filePath}: {ex.Message}"
                 );
                 return string.Empty;
             }
         }
+
+        private void EnsureDirectoryExists(string relativeDirectoryPath)
+        {
+            if (string.IsNullOrWhiteSpace(relativeDirectoryPath))
+            {
+                return;
+            }
+            if (!relativeDirectoryPath.StartsWith("Assets/"))
+            {
+                if (relativeDirectoryPath.Equals("Assets", StringComparison.OrdinalIgnoreCase))
+                {
+                    return;
+                }
+
+                this.LogError(
+                    $"Attempted to create directory outside of Assets: '{relativeDirectoryPath}'"
+                );
+                throw new ArgumentException(
+                    "Cannot create directories outside the Assets folder using AssetDatabase.",
+                    nameof(relativeDirectoryPath)
+                );
+            }
+
+            if (AssetDatabase.IsValidFolder(relativeDirectoryPath))
+            {
+                return;
+            }
+
+            string parentPath = Path.GetDirectoryName(relativeDirectoryPath)
+                ?.Replace(Path.DirectorySeparatorChar, '/');
+
+            if (
+                string.IsNullOrEmpty(parentPath)
+                || parentPath.Equals("Assets", StringComparison.OrdinalIgnoreCase)
+            )
+            {
+                string folderNameToCreate = Path.GetFileName(relativeDirectoryPath);
+                if (
+                    !string.IsNullOrEmpty(folderNameToCreate)
+                    && !AssetDatabase.IsValidFolder(relativeDirectoryPath)
+                )
+                {
+                    AssetDatabase.CreateFolder("Assets", folderNameToCreate);
+                }
+                return;
+            }
+
+            EnsureDirectoryExists(parentPath);
+
+            string currentFolderName = Path.GetFileName(relativeDirectoryPath);
+            if (
+                !string.IsNullOrEmpty(currentFolderName)
+                && !AssetDatabase.IsValidFolder(relativeDirectoryPath)
+            )
+            {
+                AssetDatabase.CreateFolder(parentPath, currentFolderName);
+                this.Log($"Created folder: {relativeDirectoryPath}");
+            }
+        }
     }
 #endif
 }