com.puzzlescapegames.services 1.0.0 → 1.0.2

package/Editor/DefineSymbols.meta

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

package/Editor/XCodePostProcess.cs

@@ -0,0 +1,32 @@
+#if UNITY_IPHONE || UNITY_IOS
+using System.IO;
+using UnityEditor;
+using UnityEditor.Callbacks;
+using UnityEditor.iOS.Xcode;
+using UnityEngine;
+
+namespace PuzzlescapeGames.Services.Editor
+{
+    public static class XCodePostProcess
+    {
+        [ PostProcessBuild ]
+        public static void ChangeXcodePlist( BuildTarget buildTarget, string path )
+        {
+            if ( buildTarget == BuildTarget.iOS )
+            {
+                string plistPath = path + "/Info.plist";
+                PlistDocument plist = new PlistDocument();
+                plist.ReadFromFile( plistPath );
+
+                PlistElementDict rootDict = plist.root;
+
+                Debug.Log( "[iOS] Change plist file" );
+
+                rootDict.SetBoolean( "ITSAppUsesNonExemptEncryption", false );
+
+                File.WriteAllText( plistPath, plist.WriteToString() );
+            }
+        }
+    }
+}
+#endif

package/Editor/XCodePostProcess.cs.meta

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

package/Runtime/ApplicationBehaviour.cs

@@ -0,0 +1,39 @@
+using System;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace PuzzlescapeGames.Services
+{
+    public sealed class ApplicationBehaviour : MonoBehaviour
+    {
+        public event Action< bool > OnApplicationFocusChanged;
+
+        public static ApplicationBehaviour Instance => IsValid() ? _instance : CreateSingleton();
+        private static ApplicationBehaviour _instance;
+
+        private static ApplicationBehaviour CreateSingleton()
+        {
+            _instance = new GameObject( "ApplicationBehaviour" ).AddComponent< ApplicationBehaviour >();
+            // _instance.gameObject.hideFlags = HideFlags.DontSave;
+            DontDestroyOnLoad( _instance.gameObject );
+            return _instance;
+        }
+
+        private void OnDestroy()
+        {
+            _instance = null;
+        }
+
+        private void OnApplicationFocus( bool focus )
+        {
+            OnApplicationFocusChanged?.Invoke( focus );
+        }
+		
+        private static bool IsValid()
+        {
+            if (_instance is Object unityObject)
+                return unityObject != null && unityObject;
+            return false;
+        }
+    }
+}

package/Runtime/ApplicationBehaviour.cs.meta

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

package/Runtime/Observer.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PuzzlescapeGames.Services
+{
+	public class Observer< T >
+	{
+		public event Action OnCollectionChanged;
+		public event Action< T > OnItemAdded;
+		public event Action< T > OnItemRemoved;
+
+		public IReadOnlyList< T > Observables => _observables;
+		protected readonly List< T > _observables = new();
+
+		public virtual void AddObserver( T observable, bool notify = true )
+		{
+			_observables.Add( observable );
+
+			if ( !notify ) return;
+
+			OnItemAdded?.Invoke( observable );
+			OnCollectionChanged?.Invoke();
+		}
+
+		public virtual void AddObservers( IEnumerable< T > observables, bool notify = true )
+		{
+			_observables.AddRange( observables );
+
+			if ( !notify ) return;
+
+			OnCollectionChanged?.Invoke();
+		}
+
+		public virtual void RemoveObserver( T observable, bool notify = true )
+		{
+			_observables.Remove( observable );
+
+			if ( !notify ) return;
+
+			OnItemRemoved?.Invoke( observable );
+			OnCollectionChanged?.Invoke();
+		}
+
+		public void RemoveObserver< O >( bool notify = true )
+			where O : class, T
+		{
+			O item = GetAs< O >();
+			if ( item != null )
+			{
+				RemoveObserver( item, notify );
+			}
+		}
+		
+		public virtual void RemoveObservers( IEnumerable< T > observables, bool notify = true )
+		{
+			foreach ( var observable in observables )
+			{
+				_observables.Remove( observable );
+			}
+
+			if ( !notify ) return;
+
+			OnCollectionChanged?.Invoke();
+		}
+
+		public T GetAs< T >()
+		{
+			return _observables.OfType< T >().FirstOrDefault();
+		}
+		
+		public virtual bool Contains( T observable )
+		{
+			return _observables.Contains( observable );
+		}
+
+		public virtual bool Contains< T >()
+		{
+			return _observables.OfType< T >().FirstOrDefault() != null;
+		}
+
+		public bool ContainsType( Type observable )
+		{
+			return _observables.Any( ( x ) => x.GetType() == observable );
+		}
+
+		public virtual void Clear()
+		{
+			_observables.Clear();
+			
+			OnCollectionChanged?.Invoke();
+		}
+	}
+}

package/Runtime/Observer.cs.meta

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

package/Runtime/PuzzlescapeGames.Services.asmdef

@@ -0,0 +1,3 @@
+{
+	"name": "PuzzlescapeGames.Services"
+}

package/Runtime/PuzzlescapeGames.Services.asmdef.meta

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

package/Runtime/Registrator.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PuzzlescapeGames.Services
+{
+	public class Registrator<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.Where( x => x is R ).FirstOrDefault();
+
+			throw new Exception( $"REGISTRATOR DOESN'T CONTAINS {typeof(R)} ERROR" );
+		}
+
+		public bool ContainsType< R >()
+			where R : T =>
+			_registers.OfType< R >().Any();
+
+		public bool ContainsType< R >( R registr )
+			where R : T
+		{
+			return _registers.Any( ( x ) => x.GetType() == 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/Registrator.cs.meta

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

package/Runtime/Version.cs

@@ -0,0 +1,24 @@
+namespace PuzzlescapeGames.Services
+{
+    public class Version
+    {
+        public int Major;
+        public int Minor;
+        public int Patch;
+
+        public Version( string version )
+        {
+            var array = version.Split( "." );
+            Major = int.Parse( array[ 0 ] );
+            Minor = int.Parse( array[ 1 ] );
+            Patch = int.Parse( array[ 2 ] );
+        }
+        
+        public Version( int major, int minor, int patch )
+        {
+            Major = major;
+            Minor = minor;
+            Patch = patch;
+        }
+    }
+}

package/Runtime/Version.cs.meta

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

package/package.json

@@ -1,7 +1,7 @@
 {
     "name" : "com.puzzlescapegames.services",
     "displayName" : "Puzzlescape Games Services",
-    "version" : "1.0.0",
+    "version" : "1.0.2",
     "author" : "Puzzlescape Games",
     "description" : "Common services.",
     "repository": {