com.soosvet_games.common_tools 1.0.0

package/.github/workflows/release-package.yml

@@ -0,0 +1,22 @@
+name: Add Package
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  publish-gpr:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '16.x'
+      - run: npm install
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/Editor/HierarchyActivationTool.cs

@@ -0,0 +1,37 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace SoosvetGames.CommonTools.Extensions.Editor
+{
+    [ InitializeOnLoad ]
+    internal static class HierarchyActivationTool
+    {
+        static HierarchyActivationTool() => EditorApplication.hierarchyWindowItemOnGUI += HierarchWindowOnGui;
+
+        private static void HierarchWindowOnGui( int instanceID, Rect selectionRect )
+        {
+            // make rectangle
+            var r = new Rect(selectionRect);
+            r.x = 35;
+            r.width = 18;
+
+            // get objects
+            Object o = EditorUtility.InstanceIDToObject(instanceID);
+            var obj = o as GameObject;
+
+            // drag toggle gui
+            if (obj != null)
+            {
+                bool prev = obj.activeSelf;
+                bool next = GUI.Toggle(r, obj.activeSelf, string.Empty);
+
+                if (next != prev)
+                {
+                    Undo.RecordObject(obj, $"Record {obj.name}");
+                    obj.SetActive(next);
+                    EditorUtility.SetDirty(obj);
+                }
+            }
+        }
+    }
+}

package/Editor/HierarchyActivationTool.cs.meta

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

package/Editor/SoosvetGames.CommonTools.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "SoosvetGames.CommonTools.Editor",
+    "rootNamespace": "",
+    "references": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Editor/SoosvetGames.CommonTools.Editor.asmdef.meta

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

package/Editor.meta

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

package/README.md

@@ -0,0 +1,4 @@
+# SoosvetGames-CommonTools
+Common tools for Unity.
+## How to use
+Install from npm by "com.soosvet_games.common_tools".<br>

package/README.md.meta

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

package/Runtime/Extensions/AssetDatabaseExtensions.cs

@@ -0,0 +1,31 @@
+#if UNITY_EDITOR
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class AssetDatabaseExtensions
+    {
+        public static void ClearFolder( this DefaultAsset defaultAsset )
+        {
+            ClearFolder( AssetDatabase.GetAssetPath( defaultAsset ) );
+        }
+        
+        public static void ClearFolder( string folderPath )
+        {
+            var dataPath = Application.dataPath.Replace( "/Assets", "" );
+            var fullFolderPath = $"{dataPath}/{folderPath}";
+
+            if ( Directory.Exists( fullFolderPath ) )
+            {
+                Directory.Delete( fullFolderPath, true );
+            }
+
+            Directory.CreateDirectory( fullFolderPath );
+
+            AssetDatabase.Refresh();
+        }
+    }
+}
+#endif

package/Runtime/Extensions/AssetDatabaseExtensions.cs.meta

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

package/Runtime/Extensions/CanvasGroupExtensions.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class CanvasGroupExtensions
+    {
+        public static void Enable( this CanvasGroup canvasGroup, bool trigger, bool withAlpha = true )
+        {
+            if ( withAlpha ) canvasGroup.alpha = trigger ? 1f : 0f;
+            canvasGroup.blocksRaycasts = trigger;
+            canvasGroup.interactable = trigger;
+        }
+    }
+}

package/Runtime/Extensions/CanvasGroupExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 777bae3048ba40fca35a452e436a0693
+timeCreated: 1785415229

package/Runtime/Extensions/CollectionExtensions.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class CollectionExtensions
+    {
+        public static T RandomItem< T >( this IList< T > list, int from = 0, int to = -1 )
+        {
+            if ( list.Count == 0 ) return default;
+            return list[ UnityEngine.Random.Range( from, to == -1 ? list.Count : to ) ];
+        }
+
+        public static T RandomItem< T >( this IList< T > list, int from = 0, int to = -1, params T[] except )
+        {
+            if ( list.Count == 0 ) return default;
+
+            var check = list.Except( except ).ToList();
+            return check[ UnityEngine.Random.Range( from, to == -1 ? check.Count : to ) ];
+        }
+
+        public static List< T > Shuffle< T >( this IList< T > list )
+        {
+            Random rnd = new Random();
+            var copy = new List< T >( list );
+            int n = copy.Count;
+            while ( n > 1 )
+            {
+                n--;
+                int k = rnd.Next( n + 1 );
+                T value = copy[ k ];
+                copy[ k ] = copy[ n ];
+                copy[ n ] = value;
+            }
+
+            return copy;
+        }
+
+        /// <summary>
+        /// Resize for listB by listA
+        /// </summary>
+        public static void Resize< FIRST, SECOND >( IList< FIRST > listA, IList< SECOND > listB, Func< SECOND > onCreate, Func< SECOND > onRemove = null )
+        {
+            Resize( listA.Count, listB, onCreate, onRemove );
+        }
+
+        /// <summary>
+        /// Resize list by size
+        /// </summary>
+        public static void Resize< T >( int size, IList< T > list, Func< T > onCreate, Func< T > onRemove = null )
+        {
+            int diff = size - list.Count;
+
+            if ( diff != 0 )
+            {
+                if ( diff > 0 ) //add
+                {
+                    for ( int i = 0; i < diff; i++ )
+                    {
+                        Add();
+                    }
+                }
+                else //rm
+                {
+                    for ( int i = 0; i < -diff; i++ )
+                    {
+                        Remove();
+                    }
+                }
+            }
+
+            void Add()
+            {
+                if ( onCreate != null )
+                {
+                    T item = onCreate.Invoke();
+                    list.Add( item );
+                }
+            }
+
+            void Remove()
+            {
+                if ( onRemove != null )
+                {
+                    T item = onRemove.Invoke();
+                    list.Remove( item );
+                }
+            }
+        }
+    }
+}

package/Runtime/Extensions/CollectionExtensions.cs.meta

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

package/Runtime/Extensions/ImageExtensions.cs

@@ -0,0 +1,14 @@
+using UnityEngine.UI;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class ImageExtensions
+    {
+        public static void SetAlpha( this Image image, float value )
+        {
+            var color = image.color;
+            color.a = value;
+            image.color = color;
+        }
+    }
+}

package/Runtime/Extensions/ImageExtensions.cs.meta

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

package/Runtime/Extensions/LinqExtensions.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class LinqExtensions
+    {
+        /// <summary>Perform an action on each item.</summary>
+        /// <param name="source">The source.</param>
+        /// <param name="action">The action to perform.</param>
+        public static IEnumerable< T > ForEach< T >( this IEnumerable< T > source, Action< T > action )
+        {
+            foreach ( T obj in source )
+                action( obj );
+            return source;
+        }
+
+        /// <summary>Perform an action on each item.</summary>
+        /// <param name="source">The source.</param>
+        /// <param name="action">The action to perform.</param>
+        public static IEnumerable< T > ForEach< T >( this IEnumerable< T > source, Action< T, int > action )
+        {
+            int num = 0;
+            foreach ( T obj in source )
+                action( obj, num++ );
+            return source;
+        }
+    }
+}

package/Runtime/Extensions/LinqExtensions.cs.meta

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

package/Runtime/Extensions/ListExtensions.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class ListExtensions
+    {
+        public static T PopAt< T >( this IList< T > list, int index )
+        {
+            if ( index < 0 || index >= list.Count ) return default;
+            
+            T item = list[ index ];
+            list.RemoveAt( index );
+            return item;
+        }
+        
+        public static T PopFirst< T >( this IList< T > list ) => list.PopAt( 0 );
+        
+        public static T PopLast< T >( this IList< T > list ) => list.PopAt( list.Count - 1 );
+    }
+}

package/Runtime/Extensions/ListExtensions.cs.meta

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

package/Runtime/Extensions/RectExtensions.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class RectExtensions
+    {
+        public static Rect Encapsulate( this Rect rect, Rect other )
+        {
+            float xmin = Mathf.Min( rect.min.x, rect.max.x, other.min.x, other.max.x );
+            float xmax = Mathf.Max( rect.min.x, rect.max.x, other.min.x, other.max.x );
+            float ymin = Mathf.Min( rect.min.y, rect.max.y, other.min.y, other.max.y );
+            float ymax = Mathf.Max( rect.min.y, rect.max.y, other.min.y, other.max.y );
+            return Rect.MinMaxRect( xmin, ymin, xmax, ymax );
+        }
+    }
+}

package/Runtime/Extensions/RectExtensions.cs.meta

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

package/Runtime/Extensions/ReflectionExtensions.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Reflection;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class ReflectionExtensions
+    {
+        public static FieldInfo GetPrivateField( this Type type, string name )
+        {
+            return type.GetField( name, BindingFlags.Instance | BindingFlags.NonPublic );
+        }
+
+        public static MethodInfo GetInternalMethod( this Type type, string method )
+        {
+            return type.GetMethod( method, BindingFlags.Instance | BindingFlags.NonPublic );
+        }
+
+        public static MethodInfo GetStaticMethod( this Type type, string method )
+        {
+            return type.GetMethod( method, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public );
+        }
+    }
+}

package/Runtime/Extensions/ReflectionExtensions.cs.meta

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

package/Runtime/Extensions/StringExtensions.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class StringExtensions
+    {
+        public static readonly char EmptyChar = ' ';
+
+        /// <summary>
+        /// Checks if a string is empty.
+        /// </summary>
+        public static bool IsEmpty( this string s ) => string.IsNullOrEmpty( s ) || string.IsNullOrWhiteSpace( s );
+
+        public static string ReplaceAllCharsOn( this string s, char replacement )
+        {
+            var chars = s.ToCharArray();
+
+            for ( int i = 0; i < chars.Length; i++ )
+            {
+                if ( chars[ i ] != EmptyChar )
+                {
+                    chars[ i ] = replacement;
+                }
+            }
+
+            return new string( chars );
+        }
+
+        public static string FirstCharToUpper( this string input ) =>
+            input switch
+            {
+                null => throw new ArgumentNullException( nameof(input) ),
+                "" => throw new ArgumentException( $"{nameof(input)} cannot be empty", nameof(input) ),
+                _ => input[ 0 ].ToString().ToUpper() + input.Substring( 1 )
+            };
+    }
+}

package/Runtime/Extensions/StringExtensions.cs.meta

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

package/Runtime/Extensions/VectorExtensions.cs

@@ -0,0 +1,12 @@
+using UnityEngine;
+
+namespace SoosvetGames.CommonTools.Extensions
+{
+    public static class VectorExtensions
+    {
+        public static float RandomBtw( this Vector2 vector )
+        {
+            return Random.Range( vector.x, vector.y );
+        }
+    }
+}

package/Runtime/Extensions/VectorExtensions.cs.meta

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

package/Runtime/Extensions.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0a3500edc8e44be191e79da7e564562a
+timeCreated: 1785415182

package/Runtime/Registry.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SoosvetGames.CommonTools
+{
+	public class Registry< T >
+	{
+		public event Action OnCollectionChanged;
+		public event Action< T > OnItemAdded;
+		public event Action< T > OnItemRemoved;
+
+		public IReadOnlyList< T > Registers => _registers;
+		protected readonly List< T > _registers = new();
+
+		public void SetCollection( IEnumerable< T > items )
+		{
+			_registers.Clear();
+			_registers.AddRange( items );
+
+			OnCollectionChanged?.Invoke();
+		}
+
+		public virtual bool Registrate( T register )
+		{
+			if ( !_registers.Contains( register ) )
+			{
+				_registers.Add( register );
+
+				OnItemAdded?.Invoke( register );
+				OnCollectionChanged?.Invoke();
+
+				return true;
+			}
+
+			return false;
+		}
+
+		public virtual void Registrate( IEnumerable< T > items )
+		{
+			foreach ( T register in items )
+				if ( !_registers.Contains( register ) )
+					_registers.Add( register );
+
+			OnCollectionChanged?.Invoke();
+		}
+
+		public virtual bool UnRegistrate( T register )
+		{
+			if ( _registers.Contains( register ) )
+			{
+				_registers.Remove( register );
+
+				OnItemRemoved?.Invoke( register );
+				OnCollectionChanged?.Invoke();
+
+				return true;
+			}
+
+			return false;
+		}
+
+		public R GetAs< R >() where R : class, T => Get< R >() as R;
+
+		public T Get< R >() where R : T
+		{
+			if ( ContainsType< R >() ) return _registers.FirstOrDefault( x => x is R );
+
+			throw new Exception( $"REGISTRATOR DOESN'T CONTAINS {typeof(R)} ERROR" );
+		}
+
+		public T Get( Type registr )
+		{
+			if ( ContainsType( registr ) ) return _registers.FirstOrDefault( x => x.GetType() == registr );
+
+			throw new Exception( $"REGISTRATOR DOESN'T CONTAINS {registr} ERROR" );
+		}
+
+		public bool ContainsType< R >() where R : T => _registers.OfType< R >().Any();
+
+		public bool ContainsType< R >( R registr ) where R : T
+		{
+			return ContainsType( registr.GetType() );
+		}
+
+		public bool ContainsType( Type registr )
+		{
+			return _registers.Any( ( x ) => x.GetType() == registr );
+		}
+
+		public bool ContainsType< R >( out R registr ) where R : T
+		{
+			registr = _registers.OfType< R >().FirstOrDefault();
+			return registr != null;
+		}
+	}
+}

package/Runtime/Registry.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 01d5a2af34604c92bc915d5ffac9b208
+timeCreated: 1785415636

package/Runtime/SoosvetGames.CommonTools.asmdef

@@ -0,0 +1,3 @@
+{
+	"name": "SoosvetGames.CommonTools"
+}

package/Runtime/SoosvetGames.CommonTools.asmdef.meta

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

package/Runtime.meta

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

package/package.json

@@ -0,0 +1,11 @@
+{
+    "name" : "com.soosvet_games.common_tools",
+    "displayName" : "Soosvet Games Common Tools",
+    "version" : "1.0.0",
+    "author" : "Soosvet Games",
+    "description" : "Common tools for Unity.",
+    "repository": {
+      "type": "git",
+      "url": "https://github.com/Soosvet-games/com.soosvet_games.common_tools"
+    }
+}

package/package.json.meta

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