com.puzzlescapegames.services 1.0.2 → 1.0.5

package/Runtime/Services/AudioService/AudioService.cs

@@ -0,0 +1,82 @@
+using UnityEngine;
+using UnityEngine.Audio;
+
+namespace PuzzlescapeGames.Services.AudioService
+{
+    internal sealed class AudioService : IAudioService
+    {
+        private const string MIXER_MASTER = "MasterVolume";
+        private const string MIXER_MUSIC = "MusicVolume";
+        private const string MIXER_SFX = "SFXVolume";
+
+        private const string SFX = "SFX";
+        private const string MUSIC = "Music";
+        
+        private AudioSource _musicSource;
+
+        private readonly AudioSourceFactory _audioFactory;
+        private readonly AudioMixer _audioMixer;
+
+        public AudioService( AudioSourceFactory audioFactory, AudioMixer audioMixer )
+        {
+            _audioFactory = audioFactory;
+            _audioMixer = audioMixer;
+        }
+
+        public void PlayMusic( AudioClip clip )
+        {
+            CreateMusic().PlayLoop( clip );
+        }
+
+        public void MuteMusic( bool trigger )
+        {
+            CreateMusic().Mute( trigger );
+        }
+        
+        public void PlaySound( AudioClip clip )
+        {
+            CreateSound().PlayOnce( clip );
+        }
+
+        public void SetMasterVolume( float value )
+        {
+            _audioMixer.SetFloat( MIXER_MASTER, value );
+        }
+
+        public void SetMusicVolume( float value )
+        {
+            _audioMixer.SetFloat( MIXER_MUSIC, value );
+        }
+
+        public void SetSoundVolume( float value )
+        {
+            _audioMixer.SetFloat( MIXER_SFX, value );
+        }
+
+        private AudioSource CreateSound()
+        {
+            var source = _audioFactory.Create();
+            if ( _audioMixer != null )
+            {
+                source.Source.outputAudioMixerGroup = _audioMixer.FindMatchingGroups( SFX )[ 0 ];
+            }
+
+            return source;
+        }
+
+        private AudioSource CreateMusic()
+        {
+            if ( _musicSource == null )
+            {
+                _musicSource = _audioFactory.Create();
+
+                if ( _audioMixer != null )
+                {
+                    _musicSource.Source.outputAudioMixerGroup = _audioMixer.FindMatchingGroups( MUSIC )[ 0 ];
+                }
+            }
+
+            return _musicSource;
+        }
+    }
+}

package/Runtime/Services/AudioService/AudioService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fa4b92d9157f4116ad50fee2b87b0713
+timeCreated: 1715170020

package/Runtime/Services/AudioService/AudioServiceCustomInstaller.cs

@@ -0,0 +1,29 @@
+using PuzzlescapeGames.IoC;
+using System;
+using UnityEngine.Audio;
+using Zenject;
+
+namespace PuzzlescapeGames.Services.AudioService
+{
+    public sealed class AudioServiceCustomInstaller : CustomInstaller
+    {
+        private readonly int _poolSize;
+        private readonly AudioMixer _audioMixer;
+        
+        public AudioServiceCustomInstaller( int poolSize, AudioMixer audioMixer )
+        {
+            _poolSize = poolSize;
+            _audioMixer = audioMixer ?? throw new ArgumentNullException( nameof(audioMixer) );
+        }
+        
+        public override void Install( DiContainer container )
+        {
+            container.BindFactory< AudioSource, AudioSourceFactory >()
+                .FromMonoPoolableMemoryPool((x) => x.WithInitialSize( _poolSize )
+                    .FromNewComponentOnNewGameObject())
+                .WhenInjectedInto<AudioService>();
+            container.BindInstance( _audioMixer ).WhenInjectedInto< AudioService >();
+            container.BindInterfacesTo< AudioService >().AsSingle();
+        }
+    }
+}

package/Runtime/Services/AudioService/AudioServiceCustomInstaller.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4257a7a1c75448599422bbf90779dd19
+timeCreated: 1715170503

package/Runtime/Services/AudioService/AudioSource.cs

@@ -0,0 +1,87 @@
+using Cysharp.Threading.Tasks;
+using PuzzlescapeGames.Extensions;
+using PuzzlescapeGames.IoC;
+using UnityEngine;
+
+namespace PuzzlescapeGames.Services.AudioService
+{
+    [ RequireComponent(typeof(UnityEngine.AudioSource)) ]
+    internal sealed class AudioSource : ZenjectMonoPoolable
+    {
+        public UnityEngine.AudioSource Source
+        {
+            get
+            {
+                if ( _source == null )
+                {
+                    _source = GetComponent< UnityEngine.AudioSource >();
+                }
+
+                return _source;
+            }
+        }
+        private UnityEngine.AudioSource _source;
+
+        public bool IsPlaying
+        {
+            get => _isPlaying;
+            private set
+            {
+                _isPlaying = value;
+                PlayingChangedHandler();
+            }
+        }
+        private bool _isPlaying = false;
+        
+        public bool isLoop { get; private set; } = false;
+
+        public void PlayLoop( AudioClip clip )
+        {
+            Source.clip = clip;
+            Loop( true );
+            Source.Play();
+        }
+
+        public void PlayOnce( AudioClip clip )
+        {
+            Loop( false );
+
+            StartPlayDelay( clip.length );
+            Source.PlayOneShot( clip );
+
+            IsPlaying = true;
+        }
+
+        public void Mute( bool trigger )
+        {
+            Source.mute = trigger;
+        }
+
+        public void Loop( bool trigger )
+        {
+            isLoop = trigger;
+            Source.loop = trigger;
+        }
+
+        private void StartPlayDelay( float playTime )
+        {
+            PlayDelay( playTime ).Forget();
+        }
+        
+        private async UniTask PlayDelay( float playTime )
+        {
+            await UniTask.WaitForSeconds( playTime, cancellationToken: ThreadingUtils.QuitToken );
+            await UniTask.WaitForSeconds( 0.16f, cancellationToken: ThreadingUtils.QuitToken );
+            
+            IsPlaying = false;
+        }
+
+        private void PlayingChangedHandler()
+        {
+            if ( !IsPlaying )
+            {
+                DespawnIt();
+            }
+        }
+    }
+}

package/Runtime/Services/AudioService/AudioSource.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ac647ed9f571429a89e5d024e8495736
+timeCreated: 1715170372

package/Runtime/Services/AudioService/AudioSourceFactory.cs

@@ -0,0 +1,6 @@
+using Zenject;
+
+namespace PuzzlescapeGames.Services.AudioService
+{
+    internal sealed class AudioSourceFactory : PlaceholderFactory< AudioSource > { }
+}

package/Runtime/Services/AudioService/AudioSourceFactory.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 80790b6d53a64265b0602b48a28823d1
+timeCreated: 1715170398

package/Runtime/Services/AudioService/IAudioService.cs

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace PuzzlescapeGames.Services.AudioService
+{
+    public interface IAudioService
+    {
+        void PlayMusic( AudioClip clip );
+        void PlaySound( AudioClip clip );
+
+        void SetMasterVolume( float value );
+        void SetMusicVolume( float value );
+        void SetSoundVolume( float value );
+
+        void MuteMusic( bool trigger );
+    }
+}

package/Runtime/Services/AudioService/IAudioService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5e2b194c0ee448f48caa7be64b83f9a7
+timeCreated: 1715170333

package/Runtime/Services/AudioService.meta

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

package/Runtime/Services/NTPService/INTPService.cs

@@ -0,0 +1,13 @@
+using Cysharp.Threading.Tasks;
+using System;
+
+namespace PuzzlescapeGames.Services.NTPService
+{
+    public interface INTPService
+    {
+        bool IsDateSynchronized { get; }
+        DateTime Now { get; }
+
+        UniTask< bool > AwaitSynchronization();
+    }
+}

package/Runtime/Services/NTPService/INTPService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8a4ebe3a262748d5bebdc41eab3c97ce
+timeCreated: 1717149643

package/Runtime/Services/NTPService/NTPService.cs

@@ -0,0 +1,153 @@
+using Cysharp.Threading.Tasks;
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using UnityEngine;
+using Zenject;
+
+namespace PuzzlescapeGames.Services.NTPService
+{
+    public sealed class NTPService : INTPService, IDisposable
+    {
+        public bool IsDateSynchronized { get; private set; } = false;
+
+        public DateTime Now
+        {
+            get
+            {
+                if ( IsDateSynchronized )
+                    return _ntpDate.AddSeconds( Time.realtimeSinceStartup - _responseReceivedTime );
+
+                return DateTime.Now;
+            }
+        }
+
+        private string _ntpServer = "time.google.com";
+        private int _requestTimeout = 3;//sec
+        private float _awaitTime = 0.16f;
+        
+        private DateTime _ntpDate;
+        private float _responseReceivedTime;
+        private byte[] _receivedNtpData;
+        private Socket _socket;
+        private Thread _syncThread;
+        private volatile bool _responseReceived;
+        private CancellationTokenSource _cancellationSource;
+        
+        public NTPService()
+        {
+            IsDateSynchronized = false;
+            SynchronizeDateAsync().Forget();
+        }
+
+        public void Dispose()
+        {
+            _cancellationSource?.Cancel();
+            _cancellationSource?.Dispose();
+            _cancellationSource = null;
+        }
+
+        public async UniTask< bool > AwaitSynchronization()
+        {
+            var aw= await UniTask.WhenAny(
+                UniTask.WaitWhile( () => !IsDateSynchronized ),
+                UniTask.WaitForSeconds( _awaitTime ) );
+
+            return aw == 0;
+        }
+        
+        private async UniTask SynchronizeDateAsync()
+        {
+            while ( true )
+            {
+                if ( !IsDateSynchronized )
+                {
+                    if ( Application.internetReachability != NetworkReachability.NotReachable ) //isConnection
+                    {
+                        SynchronizeDate();
+                    }
+
+                    await UniTask.WaitForSeconds( _requestTimeout );
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+
+        private void SynchronizeDate()
+        {
+            _syncThread?.Abort();
+            _socket?.Close();
+
+            _cancellationSource?.Cancel();
+            _cancellationSource?.Dispose();
+            _cancellationSource = new();
+            
+            _responseReceived = false;
+            _syncThread = new Thread( Request );
+            _syncThread.Start();
+
+            WaitForResponse( _cancellationSource.Token ).Forget();
+
+            Debug.Log( "[NTPDateTimeService] request started." );
+        }
+
+        private void Request()
+        {
+            var ntpData = new byte[48];
+            ntpData[ 0 ] = 0x1B;
+
+            try
+            {
+                IPAddress[] addresses = Dns.GetHostEntry( _ntpServer ).AddressList;
+                var ipEndPoint = new IPEndPoint( addresses[ 0 ], 123 );
+
+                _socket = new Socket( AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp );
+
+                _socket.Connect( ipEndPoint );
+                _socket.ReceiveTimeout = _requestTimeout * 1000;
+                _socket.Send( ntpData );
+                _socket.Receive( ntpData );
+            }
+            catch ( SocketException )
+            {
+                Debug.LogWarning( "[NTPDateTimeService] sync failed." );
+                return;
+            }
+            finally
+            {
+                _socket?.Close();
+                _socket = null;
+            }
+
+            _receivedNtpData = ntpData;
+            _responseReceived = true;
+
+            Debug.Log( "[NTPDateTimeService] response received." );
+        }
+
+        private async UniTask WaitForResponse( CancellationToken token )
+        {
+            while ( !_responseReceived )
+            {
+                await UniTask.Yield( cancellationToken: token );
+            }
+
+            _responseReceivedTime = Time.realtimeSinceStartup;
+
+            ulong intPart = ( (ulong)_receivedNtpData[ 40 ] << 24 ) | ( (ulong)_receivedNtpData[ 41 ] << 16 ) |
+                            ( (ulong)_receivedNtpData[ 42 ] << 8 ) | _receivedNtpData[ 43 ];
+            ulong fractPart = ( (ulong)_receivedNtpData[ 44 ] << 24 ) | ( (ulong)_receivedNtpData[ 45 ] << 16 ) |
+                              ( (ulong)_receivedNtpData[ 46 ] << 8 ) | _receivedNtpData[ 47 ];
+
+            ulong milliseconds = intPart * 1000 + fractPart * 1000 / 0x100000000L;
+            _ntpDate = new DateTime( 1900, 1, 1, 0, 0, 0, DateTimeKind.Utc ).AddMilliseconds( (long)milliseconds ).ToLocalTime();
+
+            IsDateSynchronized = true;
+            Debug.Log( "[NTPDateTimeService] Date is synchronized : " + Now );
+        }
+    }
+}

package/Runtime/Services/NTPService/NTPService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b0f4782ff7464d7d86198e19722bd7fb
+timeCreated: 1717149906

package/Runtime/Services/NTPService/NTPServiceInstaller.cs

@@ -0,0 +1,12 @@
+using Zenject;
+
+namespace PuzzlescapeGames.Services.NTPService
+{
+    public sealed class NTPServiceInstaller : Installer< NTPServiceInstaller >
+    {
+        public override void InstallBindings()
+        {
+            Container.BindInterfacesTo< NTPService >().AsSingle().NonLazy();
+        }
+    }
+}

package/Runtime/Services/NTPService/NTPServiceInstaller.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ca248d0fc2094f9faad4b7966b395f4a
+timeCreated: 1717409013

package/Runtime/Services/NTPService.meta

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

package/Runtime/Services/TickableService/TickableService.cs

@@ -0,0 +1,29 @@
+using Cysharp.Threading.Tasks;
+using PuzzlescapeGames.Extensions;
+using System;
+using System.Threading;
+
+namespace PuzzlescapeGames.Services.TickableService
+{
+    public sealed class TickableService
+    {
+        public event Action OnSecondsTick;
+        
+        public TickableService()
+        {
+            SecondsTick( ThreadingUtils.QuitToken ).Forget();
+        }
+        
+        private async UniTask SecondsTick( CancellationToken token )
+        {
+            bool isCanceled = false;
+            
+            while ( !isCanceled )
+            {
+                OnSecondsTick?.Invoke();
+                
+                isCanceled = await UniTask.WaitForSeconds( 1f, cancellationToken: token ).SuppressCancellationThrow();
+            }
+        }
+    }
+}

package/Runtime/Services/TickableService/TickableService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 74262b748ae8480088b8e5d6f5a7ad8d
+timeCreated: 1715241909

package/Runtime/Services/TickableService/TickableServiceInstaller.cs

@@ -0,0 +1,12 @@
+using Zenject;
+
+namespace PuzzlescapeGames.Services.TickableService
+{
+    public sealed class TickableServiceInstaller : Installer< TickableServiceInstaller >
+    {
+        public override void InstallBindings()
+        {
+            Container.Bind< TickableService >().AsSingle().NonLazy();
+        }
+    }
+}

package/Runtime/Services/TickableService/TickableServiceInstaller.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7a72839f3973485394c18656f896e71e
+timeCreated: 1715241984

package/Runtime/Services/TickableService.meta

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

package/Runtime/Services/UIBlockingService/UIBlocker.cs

@@ -0,0 +1,15 @@
+using System;
+using UnityEngine;
+
+namespace PuzzlescapeGames.Services.UIBlockingService
+{
+    public sealed class UIBlocker : MonoBehaviour
+    {
+        public event Action OnButtonClicked;
+        
+        public void OnButtonClick()
+        {
+            OnButtonClicked?.Invoke();
+        }
+    }
+}

package/Runtime/Services/UIBlockingService/UIBlocker.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3d1f7ef59a784ba4b6e661e1122d61bd
+timeCreated: 1716189356

package/Runtime/Services/UIBlockingService/UIBlockingService.cs

@@ -0,0 +1,36 @@
+using System;
+using Object = UnityEngine.Object;
+
+namespace PuzzlescapeGames.Services.UIBlockingService
+{
+    public sealed class UIBlockingService
+    {
+        public event Action OnBlockerClicked
+        {
+            add => _blocker.OnButtonClicked += value;
+            remove => _blocker.OnButtonClicked -= value;
+        }
+        
+        private readonly UIBlocker _blocker;
+        
+        public UIBlockingService( UIBlocker blockerPrefab )
+        {
+            if ( blockerPrefab == null )
+                throw new ArgumentNullException( nameof(blockerPrefab) );
+            
+            _blocker = Object.Instantiate( blockerPrefab );
+            Object.DontDestroyOnLoad( _blocker );
+            UnBlockUI();
+        }
+        
+        public void BlockUI()
+        {
+            _blocker.gameObject.SetActive( true );
+        }
+
+        public void UnBlockUI()
+        {
+            _blocker.gameObject.SetActive( false );
+        }
+    }
+}

package/Runtime/Services/UIBlockingService/UIBlockingService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 205d52905c764dbbaae4db960be39cb7
+timeCreated: 1716189181

package/Runtime/Services/UIBlockingService/UIBlockingServiceInstaller.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+using Zenject;
+
+namespace PuzzlescapeGames.Services.UIBlockingService
+{
+    [ CreateAssetMenu( fileName = "UIBlockingServiceInstaller", menuName = "Installers/UIBlockingServiceInstaller" ) ]
+    public sealed class UIBlockingServiceInstaller : ScriptableObjectInstaller< UIBlockingServiceInstaller >
+    {
+        [ SerializeField ] private UIBlocker _blocker;
+        
+        public override void InstallBindings()
+        {
+            Container.BindInstance( _blocker ).WhenInjectedInto< UIBlockingService >();
+            Container.BindInterfacesAndSelfTo< UIBlockingService >().AsSingle().NonLazy();
+        }
+    }
+}

package/Runtime/Services/UIBlockingService/UIBlockingServiceInstaller.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8f8ba0cd37ed42118ce0ce1567be0d37
+timeCreated: 1716189264

package/Runtime/Services/UIBlockingService.meta

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

package/Runtime/Services/VibrationService/IVibrationService.cs

@@ -0,0 +1,7 @@
+namespace PuzzlescapeGames.Services.VibrationService
+{
+    public interface IVibrationService
+    {
+        void Vibrate();
+    }
+}

package/Runtime/Services/VibrationService/IVibrationService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cbefe3a896db40d99d51b8befa11244a
+timeCreated: 1715176976

package/Runtime/Services/VibrationService/VibrationService.cs

@@ -0,0 +1,19 @@
+namespace PuzzlescapeGames.Services.VibrationService
+{
+    internal sealed class VibrationService : IVibrationService
+    {
+        public VibrationService()
+        {
+            Vibration.Init();
+        }
+        
+        public void Vibrate()
+        {
+#if UNITY_IOS
+            Vibration.VibrateIOS( ImpactFeedbackStyle.Soft );
+#elif UNITY_ANDROID
+            Vibration.VibratePop();
+#endif
+        }
+    }
+}

package/Runtime/Services/VibrationService/VibrationService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 741f63b16b394d2a8f966d7dbecf3282
+timeCreated: 1715176950

package/Runtime/Services/VibrationService/VibrationServiceInstaller.cs

@@ -0,0 +1,12 @@
+using Zenject;
+
+namespace PuzzlescapeGames.Services.VibrationService
+{
+    public sealed class VibrationServiceInstaller : Installer< VibrationServiceInstaller >
+    {
+        public override void InstallBindings()
+        {
+            Container.BindInterfacesTo< VibrationService >().AsSingle();
+        }
+    }
+}