Merge branch 'Levels2' of https://notscam.serveminecraft.net/Tetramino/CourierOld into Levels2

Звуки от 0.01 до 1 ставим, иначе +уши

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetSettings.asset

@@ -15,7 +15,7 @@ MonoBehaviour:
   m_DefaultGroup: d447fc60305c17a17bf20948ab295a45
   m_currentHash:
     serializedVersion: 2
-    Hash: 1290af012af335115858ec31670d830d
+    Hash: 1ec1ee985689145b755c859b69691cb0
   m_OptimizeCatalogSize: 0
   m_BuildRemoteCatalog: 0
   m_CatalogRequestsTimeout: 0

Game/CourierOld/Assets/AddressableAssetsData/AssetGroups/Default Local Group.asset

@@ -32,8 +32,8 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 19bfe93240786974ea9d7cd70a7bb635
+  - m_GUID: 1cc66c0b13a946e1c9ec37026268e144
-    m_Address: Prefabs/Rooms/Level5
+    m_Address: Audio/Enemies/pl_metal2
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -57,6 +57,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 26d4e4c556527924490b8018cd510eda
+    m_Address: Assets/Resources_moved/Audio/Enemies/bc_bite2.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 28a6c7a4124141341ab7c2b7dfd3e95b
     m_Address: Assets/Resources_moved/Prefabs/Levels/Level1 2.prefab
     m_ReadOnly: 0
@@ -72,6 +77,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 2c6a984e4a1b42647b48e6b7bc69b158
+    m_Address: Prefabs/Levels/Level6
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 2ed2d93a9f39d4edba511cb7396c7bb6
     m_Address: Assets/Resources_moved/Prefabs/Enemies/Cockroach.prefab
     m_ReadOnly: 0
@@ -92,8 +102,8 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 4283d6553fc7f3f4583b9bb0be9d7979
+  - m_GUID: 3f8f2171cc252d953b82083cc16bd1ae
-    m_Address: Prefabs/Rooms/Box1
+    m_Address: Assets/Resources_moved/Prefabs/Levels/Level6_1.prefab
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -102,6 +112,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 4b279429428a13040b6d1713122cd0de
+    m_Address: Assets/Resources_moved/Audio/SFX/pl_pain5.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 4bd64d1fcecc9c6b09d81e78b7dcfebe
     m_Address: Audio/Dispatcher/take_damage1
     m_ReadOnly: 0
@@ -168,18 +183,18 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: a1d9e5a04ac11a1468c744b27d442a00
-    m_Address: Prefabs/Rooms/Stars1
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: a306df57f348ce7cf900d0b9431739ee
     m_Address: launch_selectmenu
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: ab5926b5200bedc49aec36c0afe6b028
+  - m_GUID: aa138b2e21adfbf4bbbfa5bf9d54b8f2
-    m_Address: Prefabs/Rooms/Level3_Big
+    m_Address: Assets/Resources_moved/Audio/UI/buttonclickrelease.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: ae6ab2c88ae248ce1b6efca892f17659
+    m_Address: Assets/Resources_moved/Audio/Music/TestDeath.ogg
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -193,8 +208,13 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: b3471d165fe389f479380f61034bea57
+  - m_GUID: b37ea8c61cc322afdad529d678612d22
-    m_Address: Assets/Resources_moved/Prefabs/Levels/Level1 1.prefab
+    m_Address: Assets/Resources_moved/Audio/Enemies/zo_attack2.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: bf87bc9ac43df86be8c818de81d44a54
+    m_Address: Assets/Resources_moved/Audio/SFX/pl_step1.wav
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -203,6 +223,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: c5a0ad8a615841547ac2ee613af526d8
+    m_Address: Assets/Resources_moved/Audio/SFX/pl_pain2.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: c938de3174f184741925c407a43a47f2
     m_Address: Prefabs/Rooms/Level1
     m_ReadOnly: 0
@@ -213,26 +238,16 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: d4eaf1439c2788c458127b9ba67e4fbf
-    m_Address: Prefabs/Levels/Level1
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: d5b22c0e6700543419ae667d77aadaa2
-    m_Address: Prefabs/Rooms/Level2_Down
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: dc328d8aadb0e8545978741d451e0544
-    m_Address: Prefabs/Rooms/Level4_Parkur
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: e3a3840a7963bf841872cddb02e90151
     m_Address: Prefabs/Levels/MainMenu 1
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: e84e3a3c26ccbd50d92f13627403f148
+    m_Address: Audio/Enemies/rch_walk
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: ebe18293a5ef86704b23dad3a1786476
     m_Address: Half-Life01
     m_ReadOnly: 0

Game/CourierOld/Assets/AddressableAssetsData/Linux.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 1ce80ea58c1a9154dab0a2f539b9b2a4
+guid: d36aab6707c518f5abfd60065165eb35
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Game/CourierOld/Assets/AddressableAssetsData/Windows.meta

@@ -1,5 +1,6 @@
 fileFormatVersion: 2
-guid: f01bff5d55306654a99aa04e4a24d1ea
+guid: d982316b2b4c99747b9e953ae7b9b42f
+folderAsset: yes
 DefaultImporter:
   externalObjects: {}
   userData: 

Game/CourierOld/Assets/Code/App/AppStates/GameOverState.cs

@@ -1,6 +1,9 @@
 using Code.App.StateMachine;
+using Code.Audio;
 using Code.Gameplay.Player;
 using Code.Input;
+using Code.Scenes;
+using Code.Scenes.SceneEnvironments;
 using Code.StateMachine;
 using Code.UI;
 using Cysharp.Threading.Tasks;
@@ -30,7 +33,11 @@ namespace Code.App.AppStates
             Context.InputService.EnableMap(ActionMappings.UI);
             Context.InputService.DebugBindAction((int)ActionMappings.UI,(int)UIActions.Continue, TryToExit);
             
-            GameOver();
+            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Death);
+            
+            Context.AudioService.ApplyStun(5000,0.5f);
+            
+            GameOver().Forget();
             
             base.EnterState();
         }
@@ -45,7 +52,7 @@ namespace Code.App.AppStates
             await Context.UIService.AsyncSwitchPanelTo(UIPanel.GameOver);
             
             _gameOverPanel = (GameOverPanel)Context.UIService.CurrentPanel;
-            
+            _gameOverPanel.Show();
         }
 
         private void ToMainMenu()
@@ -71,6 +78,8 @@ namespace Code.App.AppStates
             Context.InputService.DisableMap(ActionMappings.UI);
             Context.InputService.DebugUnbindAction((int)ActionMappings.UI,(int)UIActions.Continue, TryToExit);
             
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Death, callback: Context.AudioFactory.ReleaseDeathMusic); 
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.None);
             base.ExitState();
         }
     }

Game/CourierOld/Assets/Code/App/AppStates/GameplayState.cs

@@ -13,10 +13,12 @@ using Code.StateMachine;
 using Code.UI;
 using Code.UI.Panels;
 using Cysharp.Threading.Tasks;
+using DG.Tweening;
 using Reflex.Core;
 using Reflex.Extensions;
 using UnityEngine;
 using UnityEngine.InputSystem;
+using UnityEngine.Rendering;
 using UnityEngine.SceneManagement;
 
 namespace Code.App.AppStates
@@ -43,25 +45,17 @@ namespace Code.App.AppStates
                 .RegisterLoading(LoadingWork.LoadModelResource)
                 .RegisterLoading(LoadingWork.LoadAudio); 
             
-            //_playerHealth = Context.PlayerFactory.CreatePlayerHealth();
-
-            //_playerHealth.OnDamage += PlayerDamageTaken;
-            //_playerHealth.OnDeath += EndGame;
-            
             Context.AudioService.TransitToSnapshot(AudioSnapshotState.None);
             
             Context.InputService.EnableMap(ActionMappings.Gameplay);
             
             Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, InstaKillDEBUG); 
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, RoomPassedDEBUG);
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, TakeGamageDEBUG);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, Tube); 
 
             Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.DevGen);
             Context.LoadingManager.OnLoadingEnded += AfterSceneLoaded;
  
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            WaitForLoad().Forget(); 
-            WaitForLoad();
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
         private async UniTask WaitForPlayerCharacterLoad() => _playerCharacter = await Context.PlayerFactory.CreatePlayer();
 
@@ -70,8 +64,11 @@ namespace Code.App.AppStates
             await UniTask.WhenAll(
                 Context.UIService.AsyncSwitchPanelTo(UIPanel.Gameplay), 
                 Context.AudioFactory.WarmGameplayMusic(),
+                Context.AudioFactory.WarmDeathMusic(),
                 Context.AudioFactory.WarmSFX(),
-                Context.AudioFactory.WarmDispatcher()
+                Context.AudioFactory.WarmDispatcher(),
+                Context.AudioFactory.WarmEnemies(),
+                Context.AudioFactory.WarmCourier()
             );
 
             Context.LoadingManager 
@@ -91,6 +88,9 @@ namespace Code.App.AppStates
             Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
             Context.LoadingManager.OnLoadingEnded += AfterPlayerLoaded;
 
+            Context.PlayerProvider = SceneManager.GetActiveScene().GetSceneContainer().Resolve<IPlayerProvider>();
+            Context.PlayerFactory = SceneManager.GetActiveScene().GetSceneContainer().Resolve<IPlayerFactory>();
+            
             await UniTask.WhenAll( 
                 WaitForPlayerArmsToInitialize(),
                 WaitForPlayerCharacterLoad() 
@@ -112,6 +112,8 @@ namespace Code.App.AppStates
             
             GameplaySceneEnvironment sceneEnvironment = SceneEnvironmentVariables(sceneContainer);
 
+            _volume = sceneEnvironment.volume;
+            
             PlayerInitialize(sceneEnvironment);
             
             CameraInitialize();
@@ -153,21 +155,30 @@ namespace Code.App.AppStates
         private void PlayerDamageTaken(int damage, PlayerHealth health)
         {
             Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.TakeDamage1,(int)DispatcherSounds.TakeDamage4));
+            Context.AudioService.PlayCourier((CourierSounds)Random.Range((int)CourierSounds.Damage1,(int)CourierSounds.Damage2));
+            DamageEffectProcess().Forget();
+        }
+
+        // TODO В конфиг
+        private async UniTaskVoid DamageEffectProcess()
+        {
+            _damagePanel.Show();
+            Context.AudioService.ApplyStun(200, 0.5f);
+            
+            DOTween.To(() => _volume.weight, x => _volume.weight = x, 1f, 0.5f);
+            await UniTask.WaitForSeconds(3f);
+            DOTween.To(() => _volume.weight, x => _volume.weight = x, 0f, 1f);
+            Context.AudioService.ApplyStun(5000, 1f);
+            _damagePanel.Hide();
         }
         // DEBUG
         private void InstaKillDEBUG(InputAction.CallbackContext context)
         {
             _playerHealth.InstaKill();
         }
-        private void RoomPassedDEBUG(InputAction.CallbackContext context)
+        private void TakeGamageDEBUG(InputAction.CallbackContext context)
         {
-            _orderService.RoomPassed();
+            _playerHealth.GetDamage(1);
-        }
-        private OrderDispenser _debugTube;
-
-        private void Tube(InputAction.CallbackContext context)
-        {
-            _debugTube.ThrowOrder();
         } 
         // DEBUG
         private bool _tickEnabled;
@@ -201,13 +212,16 @@ namespace Code.App.AppStates
             Context.AudioService.OnDispatcherEnded -= _gameplayPanel.CloseDispatcher;
             
             Context.InputService.DisableMap(ActionMappings.Gameplay);
-            Context.AudioService.GladlyAskToStopMusic(MusicType.Action, callback: Context.AudioFactory.ReleaseActionMusic);
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Action, time: 0f, callback: Context.AudioFactory.ReleaseActionMusic);
-            Context.AudioService.GladlyAskToStopMusic(MusicType.Peaceful, callback: Context.AudioFactory.ReleasePeacefulMusic);
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Peaceful, time: 0f, callback: Context.AudioFactory.ReleasePeacefulMusic);
+            Context.AudioFactory.ReleaseCourier();
+            Context.AudioFactory.ReleaseDispatcher();
+            Context.AudioFactory.ReleaseEnemies();
+            Context.AudioFactory.ReleaseSFX();
             
 
             Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, InstaKillDEBUG); 
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, RoomPassedDEBUG);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, TakeGamageDEBUG);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, Tube);
             
             base.ExitState();
         }
@@ -224,13 +238,15 @@ namespace Code.App.AppStates
 
         private GameplayPanel _gameplayPanel;
         private ArmsMeshProvider _armsMesh;
-
+        private DamagePanel _damagePanel;
         private void UIInitialize()
         {
             _gameplayPanel = (GameplayPanel)Context.UIService.CurrentPanel;
             _gameplayPanel.Initialize(_playerScore, _playerHealth, _orderService);
             Context.AudioService.OnDispatcherStarted += _gameplayPanel.SummonDispatcher;
             Context.AudioService.OnDispatcherEnded += _gameplayPanel.CloseDispatcher;
+            
+            _damagePanel = _gameplayPanel.DamagePanel;
         }
         private void MusicInitialize()
         {
@@ -252,11 +268,12 @@ namespace Code.App.AppStates
             _orderService.OnOrderDelivered += OrderDelivered;
             _orderService.OnOrderFailure += OrderFailure;
         }
+
+        private Volume _volume;
         private GameplaySceneEnvironment SceneEnvironmentVariables(Container sceneContainer)
         {
             var sceneEnvironment = (GameplaySceneEnvironment)sceneContainer.Resolve<CurrentSceneEnvironment>();
             
-            
             return sceneEnvironment;
         }
     }

Game/CourierOld/Assets/Code/App/BootstrapInstaller.cs

@@ -33,11 +33,7 @@ namespace Code.App
             containerBuilder.AddSingleton(typeof(LoadingManager), typeof(ILoadingManager));
             
             containerBuilder.AddSingleton(typeof(InputService), typeof(IInputService));
-            // Перенести нахуй в контейнер геймплея
+            
-            containerBuilder.AddSingleton(typeof(PlayerFactory), typeof(IPlayerFactory));
-            containerBuilder.AddSingleton(typeof(EnemyFactory), typeof(IEnemyFactory));
-            containerBuilder.AddSingleton(typeof(PlayerProvider), typeof(IPlayerProvider));
-            // 
             InitializeCamera(containerBuilder, staticDataService);
             
             containerBuilder.AddSingleton(typeof(UIFactory), typeof(IUIFactory));
@@ -71,6 +67,7 @@ namespace Code.App
             containerBuilder.AddSingleton(infrastructureUnit.AddComponent<CameraStateMachine>());
         }
 
+        // TODO Часть в сцены
         private void InstallStaticData(ContainerBuilder containerBuilder, out IStaticDataService staticDataService)
         {
             staticDataService = new StaticDataService();
@@ -97,10 +94,13 @@ namespace Code.App
             containerBuilder.AddSingleton(staticDataService.SoundtrackListConfig, typeof(SoundtrackListConfig));
             containerBuilder.AddSingleton(staticDataService.AudioTestClipsConfig, typeof(AudioTestClipsConfig));
             containerBuilder.AddSingleton(staticDataService.SFXListConfig, typeof(SFXListConfig));
+            containerBuilder.AddSingleton(staticDataService.CourierSoundListConfig, typeof(CourierSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.DispatcherSoundListConfig, typeof(DispatcherSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.AudioSourceSettingsConfigs, typeof(Dictionary<AudioSourceType, AudioSourceSettingsConfig>));
             
+            containerBuilder.AddSingleton(staticDataService.DefaultAudioSettingsConfig, typeof(DefaultAudioSettingsConfig));
+
             containerBuilder.AddSingleton(staticDataService.OrderServiceConfig, typeof(OrderServiceConfig));
             containerBuilder.AddSingleton(staticDataService.OrderBoxConfig, typeof(OrderBoxConfig)); 
             
@@ -119,9 +119,7 @@ namespace Code.App
             AttributeInjector.Inject(cameraStateMachine.StateMachineContext, container);
             cameraStateMachine.Initialize();
 
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            BootstrapFinish(container).Forget();
-            BootstrapFinish(container);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
         private async UniTaskVoid BootstrapFinish(Container container)
         {

Game/CourierOld/Assets/Code/App/SceneInstallers/GameplaySceneInstaller.cs

@@ -1,4 +1,5 @@
 using Code.App.Loading;
+using Code.Gameplay.Enemies;
 using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
 using Code.Generator;
@@ -21,6 +22,9 @@ namespace Code.App.SceneInstallers
             containerBuilder.AddScoped(typeof(PlayerScore), typeof(IPlayerScore));
             containerBuilder.AddScoped(typeof(OrderService), typeof(IOrderService));
             containerBuilder.AddScoped(typeof(RoomGeneratorFactory), typeof(IRoomGeneratorFactory));
+            containerBuilder.AddScoped(typeof(PlayerProvider), typeof(IPlayerProvider));
+            containerBuilder.AddScoped(typeof(PlayerFactory), typeof(IPlayerFactory));
+            containerBuilder.AddScoped(typeof(EnemyFactory), typeof(IEnemyFactory));
             containerBuilder.AddScoped(typeof(RoomGenerator));
 
             containerBuilder.OnContainerBuilt += Initialize;
@@ -37,14 +41,14 @@ namespace Code.App.SceneInstallers
             loadingManager
                 .UnregisterLoading(LoadingWork.LoadScene);
             
-            LoadRooms(container,loadingManager);
+            LoadRooms(container,loadingManager).Forget();
         }
 
         private async UniTaskVoid LoadRooms(Container container, ILoadingManager loadingManager)
         {
-            await container.Resolve<IRoomGeneratorFactory>().PreloadRooms(container.Resolve<IOrderService>());
+            // await container.Resolve<IRoomGeneratorFactory>().PreloadRooms(container.Resolve<IOrderService>());
             
-            container.Resolve<RoomGenerator>().Initialize();
+            // container.Resolve<RoomGenerator>().Initialize();
             
             loadingManager.UnregisterLoading(LoadingWork.LoadModelResource);
         }

Game/CourierOld/Assets/Code/App/StateMachine/AppStateMachineContext.cs

@@ -19,10 +19,10 @@ namespace Code.App.StateMachine
         [Inject] public AppStateMachine StateMachine { get; private set; }
         [Inject] public CameraStateMachine CameraStateMachine { get; private set; }
         [Inject] public IUIService UIService { get; private set; }
-        [Inject] public IPlayerFactory PlayerFactory { get; private set; }
-        [Inject] public IPlayerProvider PlayerProvider { get; private set; }
         [Inject] public IAudioFactory AudioFactory { get; private set; }
         [Inject] public IAudioService AudioService { get; private set; }
-        [Inject] public IEnemyFactory EnemyFactory { get; private set; } 
+        /*[Inject]*/public IPlayerFactory PlayerFactory { get; set; }
+        /*[Inject]*/public IPlayerProvider PlayerProvider { get; set; }
+        // [Inject] public IEnemyFactory EnemyFactory { get; private set; } 
     }
 }

Game/CourierOld/Assets/Code/Audio/AudioEnums.cs

@@ -11,8 +11,10 @@ namespace Code.Audio
     }
     public enum EnemiesSounds
     {
-        Bastard,
+        GrandpaAttack,
-        Bravo
+        RoachAttack,
+        RoachStep,
+        GrandpaStep
     }
     public enum DispatcherSounds
     {
@@ -28,4 +30,10 @@ namespace Code.Audio
         Late4,
         Late5
     }
+    public enum CourierSounds
+    {
+        Step,
+        Damage1,
+        Damage2
+    }
 }

Game/CourierOld/Assets/Code/Audio/AudioFactory.cs

@@ -19,24 +19,28 @@ namespace Code.Audio
         private AssetReference[] _audioTestClipsReferences;
         private AssetReference[] _peacefulSoundtrack;
         private AssetReference[] _actionSoundtrack;
+        private AssetReference[] _deathSoundtrack;
         private AssetReference[] _menuSoundtrack;
         private AssetReference[] _SFX;
         private AssetReference[] _enemies;
         private AssetReference[] _dispatcher;
-        private AssetReference[] _character;
+        private AssetReference[] _courier;
         
         private AsyncOperationHandle<IList<AudioClip>> _audioTestClipsHandle;
         private AsyncOperationHandle<IList<AudioClip>> _menuMusicHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _deathMusicHandle;
         private AsyncOperationHandle<IList<AudioClip>> _actionMusicHandle;
         private AsyncOperationHandle<IList<AudioClip>> _peacefulMusicHandle;
         private AsyncOperationHandle<IList<AudioClip>> _SFXHandle;
         private AsyncOperationHandle<IList<AudioClip>> _enemiesHandle;
         private AsyncOperationHandle<IList<AudioClip>> _dispatcherHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _courierHandle;
 
         public Dictionary<AudioType, AudioClip> AudioTestClips { get; private set; } = new();
         public Dictionary<MusicType, List<AudioClip>> MusicDictionary { get; private set; } = new();
         public List<AudioClip> SFXAudios { get; private set; } = new();
         public List<AudioClip> EnemiesAudios { get; private set; } = new();
+        public List<AudioClip> CourierAudios { get; private set; } = new();
         public List<AudioClip> DispatcherAudios { get; private set; } = new();
 
         public AudioFactory(AudioMixerConfig audioMixerConfig, 
@@ -44,7 +48,8 @@ namespace Code.Audio
             SFXListConfig sfxListConfig, 
             EnemiesSoundListConfig enemiesSoundListConfig,
             DispatcherSoundListConfig dispatcherSoundListConfig,
-            AudioTestClipsConfig audioTestClipsConfig
+            AudioTestClipsConfig audioTestClipsConfig,
+            CourierSoundListConfig courierSoundListConfig
             )
         {
             AudioMixer = audioMixerConfig.audioMixerAsset;
@@ -52,15 +57,18 @@ namespace Code.Audio
             
             _peacefulSoundtrack = soundtrackListConfig.peacefulSoundtrack;
             _actionSoundtrack = soundtrackListConfig.actionSoundtrack;
+            _deathSoundtrack = soundtrackListConfig.deathSoundtrack;
             _menuSoundtrack = soundtrackListConfig.menuSoundtrack;
             _SFX = sfxListConfig.SFX;
             _enemies = enemiesSoundListConfig.enemies;
             _dispatcher = dispatcherSoundListConfig.dispatcher;
+            _courier = courierSoundListConfig.courierSounds;
             _audioTestClipsReferences = audioTestClipsConfig.audioTestClips;
             
             MusicDictionary.Add(MusicType.Menu, new ());
-            MusicDictionary.Add(MusicType.Peaceful, new ());
+            MusicDictionary.Add(MusicType.Death, new ());
             MusicDictionary.Add(MusicType.Action, new ());
+            MusicDictionary.Add(MusicType.Peaceful, new ());
         }
 
         public async UniTask LoadAudioSourcePrefab(Action<GameObject> callback) =>
@@ -112,6 +120,16 @@ namespace Code.Audio
             // foreach (var assetReference in _menuSoundtrack) assetReference.ReleaseAsset();
             _menuMusicHandle.Release();
         }
+        public async UniTask WarmDeathMusic()
+        {            
+            _deathMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_deathSoundtrack, OnDeathTrackLoaded, Addressables.MergeMode.Union);
+            await _deathMusicHandle.ToUniTask();
+        }
+        public void ReleaseDeathMusic()
+        {
+            MusicDictionary[MusicType.Death].Clear();
+            _deathMusicHandle.Release();
+        }
         public async UniTask WarmSFX( )
         {            
             _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.Union);
@@ -137,6 +155,18 @@ namespace Code.Audio
             EnemiesAudios.Clear();
             _enemiesHandle.Release();
         }
+        public async UniTask WarmCourier()
+        {            
+            _courierHandle = Addressables.LoadAssetsAsync<AudioClip>(_courier, OnCourierLoaded, Addressables.MergeMode.Union);
+            
+            await _courierHandle.ToUniTask();
+        }
+
+        public void ReleaseCourier()
+        {
+            CourierAudios.Clear();
+            _courierHandle.Release();
+        }
 
         public async UniTask WarmDispatcher( )
         {            
@@ -156,6 +186,10 @@ namespace Code.Audio
         {
             MusicDictionary[MusicType.Menu].Add(audioClip);
         }
+        private void OnDeathTrackLoaded(AudioClip audioClip)
+        {
+            MusicDictionary[MusicType.Death].Add(audioClip);
+        }
 
         // private int _audioTestClipCounter;
         private void OnAudioTestClipLoaded(AudioClip audioClip)
@@ -182,5 +216,9 @@ namespace Code.Audio
         {
             DispatcherAudios.Add(audioClip);
         }
+        private void OnCourierLoaded(AudioClip audioClip)
+        {
+            CourierAudios.Add(audioClip);
+        }
     }
 }

Game/CourierOld/Assets/Code/Audio/AudioService.cs

@@ -22,134 +22,104 @@ namespace Code.Audio
         private AudioSource _actionMusicSource;
         private AudioSource _peacefulMusicSource;
 
-        private AudioMixerGroup _masterGroup,
+        private Dictionary<AudioType, AudioMixerGroup> _audioMixerGroups = new();
-            // _musicGroup,
-            _actionMusicGroup,
-            _menuMusicGroup,
-            _peacefulMusicGroup,
-            _SFXGroup,
-            _creaturesGroup,
-            _dispatcherGroup,
-            _courierGroup,
-            _enemiesGroup;
-
         private readonly AudioSourcePool _audioSourcePool;
  
-        private Dictionary<AudioSnapshotState, AudioMixerSnapshot> _snapshots = new();
+        // Юнити не может - говнокод поможет.
+        private Dictionary<AudioSnapshotState, Dictionary<AudioType, float>> _snapshotsVolumes = new();
         private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
 
-        public AudioService(IAudioFactory audioFactory, Dictionary<AudioSourceType, AudioSourceSettingsConfig> settings)
+        public AudioService(IAudioFactory audioFactory,
+            Dictionary<AudioSourceType, AudioSourceSettingsConfig> settings,
+            DefaultAudioSettingsConfig defaultAudioSettingsConfig)
         {
             _audioFactory = audioFactory;
             _audioSourcePool = new(settings);
             _settings = settings;
+            
+            _snapshotsVolumes.Add(AudioSnapshotState.None,defaultAudioSettingsConfig.noneVolume);
+            _snapshotsVolumes.Add(AudioSnapshotState.Menu,defaultAudioSettingsConfig.menuVolume);
+            _snapshotsVolumes.Add(AudioSnapshotState.Action,defaultAudioSettingsConfig.actionVolume);
+            _snapshotsVolumes.Add(AudioSnapshotState.Peaceful,defaultAudioSettingsConfig.peacefulVolume);
         }
 
-        // TODO Грязно, убрать снапшоты НАХУЙ
         public float GetSetting(AudioType type)
         {
-            float value;
+            _mixer.GetFloat(_audioMixerGroups[type].name, out float value);
-            switch (type)
-            {
-                case AudioType.SFX:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.GetFloat(_SFXGroup.name, out value);
-                    break;
-                case AudioType.Master:
-                    _snapshots[AudioSnapshotState.Menu].audioMixer.GetFloat(_masterGroup.name, out value);
-                    break;
-                case AudioType.Creatures:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.GetFloat(_creaturesGroup.name, out value);
-                    break;
-                case AudioType.GameplayMusic:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.GetFloat(_peacefulMusicGroup.name, out value);
-                    break;
-                case AudioType.MenuMusic:
-                    _snapshots[AudioSnapshotState.Menu].audioMixer.GetFloat(_menuMusicGroup.name, out value);
-                    break;
-                case AudioType.DispatcherSounds:
-                    _snapshots[AudioSnapshotState.Action].audioMixer.GetFloat(_dispatcherGroup.name, out value);
-                    break;
-                default:
-                    value = 1;
-                    break;
-            }
 
             value = Mathf.Pow(10f, value / 20);
 
             return value;
         }
 
-        // TODO Грязно, убрать снапшоты НАХУЙ
         public void ChangeSetting(AudioType type, float value)
         {
             float volume = Mathf.Log10(value) * 20;
             switch (type)
             {
-                case AudioType.SFX:
+                case AudioType.DeathMusic:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_SFXGroup.name, volume);
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_SFXGroup.name, volume);
-                    break;
                 case AudioType.Master:
-                    _snapshots[AudioSnapshotState.Menu].audioMixer.SetFloat(_masterGroup.name, volume);
+                    _snapshotsVolumes[AudioSnapshotState.Menu][type] = value;
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_masterGroup.name, volume);
+                    _snapshotsVolumes[AudioSnapshotState.Action][type] = value;
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_masterGroup.name, volume);
+                    _snapshotsVolumes[AudioSnapshotState.Peaceful][type] = value;
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume); 
                     break;
-                case AudioType.Creatures:
+                case AudioType.ActionMusic:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_creaturesGroup.name, volume);
+                    _snapshotsVolumes[AudioSnapshotState.Action][type] = value;
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_creaturesGroup.name, volume);
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume);
                     break;
-                case AudioType.GameplayMusic:
+                case AudioType.PeacefulMusic:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_peacefulMusicGroup.name, volume);
+                    _snapshotsVolumes[AudioSnapshotState.Peaceful][type] = value;
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_actionMusicGroup.name, volume);
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume);
                     break;
                 case AudioType.MenuMusic:
-                    _snapshots[AudioSnapshotState.Menu].audioMixer.SetFloat(_menuMusicGroup.name, volume);
+                    _snapshotsVolumes[AudioSnapshotState.Menu][type] = value;
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume);
                     break; 
-                case AudioType.DispatcherSounds:
+                case AudioType.SFX:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_dispatcherGroup.name, volume);
+                case AudioType.Dispatcher:
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_dispatcherGroup.name, volume);
+                case AudioType.Courier:
+                case AudioType.Enemies:
+                    _snapshotsVolumes[AudioSnapshotState.Action][type] = value;
+                    _snapshotsVolumes[AudioSnapshotState.Peaceful][type] = value;
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume); 
                     break;
             }
-            // _mixer.FindSnapshot("Action").audioMixer.SetFloat("music", volume);
         }
 
         public async UniTask Initialize()
         {
-            // _mixer = await _audioFactory.CreateMixer();
             _mixer = _audioFactory.AudioMixer;
 
-            _masterGroup = _mixer.FindMatchingGroups(AudioGroups.MasterGroup)[0];
-            _menuMusicGroup = _mixer.FindMatchingGroups(AudioGroups.MenuMusicGroup)[0];
-            _actionMusicGroup = _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0];
-            _peacefulMusicGroup = _mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0];
-            // _musicGroup = _mixer.FindMatchingGroups(AudioGroups.MusicGroup)[0];
             _musicAudioGroups.Add(MusicType.Menu, _mixer.FindMatchingGroups(AudioGroups.MenuMusicGroup)[0]);
+            _musicAudioGroups.Add(MusicType.Death, _mixer.FindMatchingGroups(AudioGroups.DeathMusicGroup)[0]);
             _musicAudioGroups.Add(MusicType.Action, _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0]);
             _musicAudioGroups.Add(MusicType.Peaceful, _mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0]);
 
             _cancellationTokenSources.Add(MusicType.Menu, new());
+            _cancellationTokenSources.Add(MusicType.Death, new());
             _cancellationTokenSources.Add(MusicType.Action, new());
             _cancellationTokenSources.Add(MusicType.Peaceful, new());
 
             _musicAudioSources.Add(MusicType.Menu, null);
+            _musicAudioSources.Add(MusicType.Death, null);
             _musicAudioSources.Add(MusicType.Action, null);
             _musicAudioSources.Add(MusicType.Peaceful, null);
 
-            _SFXGroup = _mixer.FindMatchingGroups(AudioGroups.SFXGroup)[0];
+            _audioMixerGroups.Add(AudioType.Master, _mixer.FindMatchingGroups(AudioGroups.MasterGroup)[0]);
-            _creaturesGroup = _mixer.FindMatchingGroups(AudioGroups.CreaturesGroup)[0];
+            _audioMixerGroups.Add(AudioType.SFX, _mixer.FindMatchingGroups(AudioGroups.SFXGroup)[0]); 
-            _dispatcherGroup = _mixer.FindMatchingGroups(AudioGroups.DispatcherMusicGroup)[0];
+            _audioMixerGroups.Add(AudioType.Dispatcher, _mixer.FindMatchingGroups(AudioGroups.DispatcherMusicGroup)[0]);
-            _courierGroup = _mixer.FindMatchingGroups(AudioGroups.CourierMusicGroup)[0];
+            _audioMixerGroups.Add(AudioType.Courier, _mixer.FindMatchingGroups(AudioGroups.CourierGroup)[0]);
-            _enemiesGroup = _mixer.FindMatchingGroups(AudioGroups.EnemiesMusicGroup)[0];
+            _audioMixerGroups.Add(AudioType.Enemies, _mixer.FindMatchingGroups(AudioGroups.EnemiesGroup)[0]);
+            _audioMixerGroups.Add(AudioType.MenuMusic, _musicAudioGroups[MusicType.Menu]);
+            _audioMixerGroups.Add(AudioType.DeathMusic, _musicAudioGroups[MusicType.Death]);
+            _audioMixerGroups.Add(AudioType.ActionMusic, _musicAudioGroups[MusicType.Action]);
+            _audioMixerGroups.Add(AudioType.PeacefulMusic, _musicAudioGroups[MusicType.Peaceful]);
 
-            _snapshots[AudioSnapshotState.None] = _mixer.FindSnapshot(AudioGroups.NoneSnapshot);
-            _snapshots[AudioSnapshotState.Peaceful] = _mixer.FindSnapshot(AudioGroups.PeacefulSnapshot);
-            _snapshots[AudioSnapshotState.Action] = _mixer.FindSnapshot(AudioGroups.ActionSnapshot);
-            _snapshots[AudioSnapshotState.Menu] = _mixer.FindSnapshot(AudioGroups.MenuSnapshot);
 
             await _audioFactory.LoadAudioSourcePrefab(_audioSourcePool.Initialize);
         }
 
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         private Dictionary<MusicType, CancellationTokenSource> _cancellationTokenSources = new();
         private Dictionary<MusicType, AudioSource> _musicAudioSources = new();
         private Dictionary<MusicType, AudioMixerGroup> _musicAudioGroups = new();
@@ -169,19 +139,13 @@ namespace Code.Audio
 
             _musicAudioSources[musicType].Play();
 
-            // await UniTask.WaitUntilValueChanged(_musicAudioSources[musicType],
-            //     _ => !_musicAudioSources[musicType].isPlaying,
-            //     cancellationToken: _cancellationTokenSources[musicType].Token);
             await UniTask.NextFrame();
-            // Debug.Log($"Playing {musicType}");
             var (isCanceled, _) = await UniTask.WaitUntilValueChanged(_musicAudioSources[musicType],
                 _ => !_musicAudioSources[musicType].isPlaying,
                 cancellationToken: _cancellationTokenSources[musicType].Token).SuppressCancellationThrow();
-            // Debug.Log($"Finished {musicType}");
+            Debug.LogError("Music skipping");
-
             if (isCanceled)
             {
-                // Debug.Log($"Cancelled {musicType}");
                 _cancellationTokenSources[musicType].Dispose();
                 _cancellationTokenSources[musicType] = new();
 
@@ -191,13 +155,13 @@ namespace Code.Audio
                 return;
             }
 
-            PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(musicType);
+            PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(musicType).Forget();
         }
 
         public async UniTaskVoid GladlyAskToStopMusic(MusicType musicType,
             AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null)
         {
-            TransitToSnapshot(audioSnapshotState, time);
+            //TransitToSnapshot(audioSnapshotState, time);
 
             await UniTask.WaitForSeconds(time);
 
@@ -205,39 +169,56 @@ namespace Code.Audio
 
             callback?.Invoke();
         }
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
 
         public void StopMusic()
         {
             _peacefulMusicSource.Stop();
             _actionMusicSource.Stop();
+            _cancellationTokenSources[MusicType.Peaceful].Cancel();
+            _cancellationTokenSources[MusicType.Action].Cancel();
         }
 
         public void GladlyAskToStopMusic(Action callback = null)
         {
-            TransitToSnapshot(AudioSnapshotState.None);
+            // TransitToSnapshot(AudioSnapshotState.None);
             _peacefulMusicSource.Stop();
             _actionMusicSource.Stop();
 
             callback?.Invoke();
         }
 
-        public void TransitToSnapshot(AudioSnapshotState state, float time = 1f)
+        public void TransitToSnapshot(AudioSnapshotState state, float time = 1)
         {
-            _snapshots[state].TransitionTo(time);
+            foreach (var key in _audioMixerGroups.Keys) 
+                _mixer.DOSetFloat(_audioMixerGroups[key].name, Mathf.Log10(_snapshotsVolumes[state][key]) * 20, time);
         }
 
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
         public void PlaySFX(SFXSounds sfxId, Vector3 position)
         {
-            _audioSourcePool.PlayOneShot(_audioFactory.SFXAudios[(int)sfxId], position, _SFXGroup);
+            _audioSourcePool
+                .PlayOneShot(_audioFactory.SFXAudios[(int)sfxId], position, _audioMixerGroups[AudioType.SFX]).Forget();
+        }
+        public void ApplyStun(float value, float time)
+        {
+            _mixer.DOSetFloat("Stun", value, time);
         }
 
         public void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position)
         {
-            _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position, _enemiesGroup);
+            _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position,
+                _audioMixerGroups[AudioType.Enemies]).Forget();
         }
 
+        public AudioSource GetSourceOfGroup(AudioType group)
+        {
+            AudioSource source = _audioSourcePool.GetSource();
+            source.outputAudioMixerGroup = _audioMixerGroups[group];
+            return source;
+        }
+
+        public void ReleaseSourceOfGroup(AudioSource source) => _audioSourcePool.ReleaseSource(source);
+
         // Чинить долго и дорого пусть Артёмов будет много, ведь он наш друг
         public event IAudioService.OnAudioPlayingDelegate OnDispatcherStarted;
         public event IAudioService.OnAudioPlayingDelegate OnDispatcherEnded;
@@ -245,12 +226,22 @@ namespace Code.Audio
         public void PlayDispatcher(DispatcherSounds dispatcherSoundId)
         {
             OnDispatcherStarted?.Invoke();
-            _audioSourcePool.PlayOneShot(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup,
+            _audioSourcePool.PlayOneShot(_audioFactory.DispatcherAudios[(int)dispatcherSoundId],
-                AudioSourceType.NoBlend, () => OnDispatcherEnded?.Invoke());
+                _audioMixerGroups[AudioType.Dispatcher],
+                AudioSourceType.NoBlend, () => OnDispatcherEnded?.Invoke()).Forget();
         }
 
+        public void PlayCourier(CourierSounds courierSounds)
+        {
+            _audioSourcePool.PlayOneShot(_audioFactory.CourierAudios[(int)courierSounds],
+                _audioMixerGroups[AudioType.Courier],
+                AudioSourceType.NoBlend).Forget();
+        }
         private CancellationTokenSource _testClipCancellationTokenSource = new();
         private void ResetCurrentTestAudioSource() => _currentTestClipAudioType = AudioType.Master;
+
+        private AudioType _currentTestClipAudioType;
+
         // TODO Засунуть в словарь
         public void PlayTestClip(AudioType audioType)
         {
@@ -261,92 +252,9 @@ namespace Code.Audio
 
             _currentTestClipAudioType = audioType;
 
-            switch (audioType)
-            {
-                case AudioType.SFX:
             _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _SFXGroup, _testClipCancellationTokenSource,
+                _audioMixerGroups[audioType], _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
+                AudioSourceType.NoBlend, ResetCurrentTestAudioSource).Forget();
-                    break;
-                case AudioType.Master:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _masterGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.Creatures:
-                    _audioSourcePool.PlayOneShot( _audioFactory.AudioTestClips[audioType],
-                        _creaturesGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.GameplayMusic:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _actionMusicGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.MenuMusic:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _menuMusicGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.DispatcherSounds:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _dispatcherGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-            }
-        }
-
-        private AudioSource _testClipAudioSource;
-        private AudioType _currentTestClipAudioType;
-
-        // Эффективно и просто, может не так хитровыебано
-        private void ReleaseTestAudioClipSource()
-        {
-            _testClipAudioSource = null;
-        }
-
-        // TODO Засунуть в словарь
-        public void PlayTestClipDeprecated(AudioType audioType)
-        {
-            if (!_testClipAudioSource) _testClipAudioSource = _audioSourcePool.GetSource();
-            else if (_currentTestClipAudioType != audioType) _testClipAudioSource.Stop();
-            else return;
-
-            _currentTestClipAudioType = audioType;
-
-            switch (audioType)
-            {
-                case AudioType.SFX:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _SFXGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.Master:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _masterGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.Creatures:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _creaturesGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.GameplayMusic:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _actionMusicGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.MenuMusic:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _menuMusicGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.DispatcherSounds:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _dispatcherGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-            }
         }
     }
 }

Game/CourierOld/Assets/Code/Audio/IAudioFactory.cs

@@ -14,6 +14,7 @@ namespace Code.Audio
         List<AudioClip> SFXAudios { get; }
         List<AudioClip> EnemiesAudios { get; }
         List<AudioClip> DispatcherAudios { get; }
+        List<AudioClip> CourierAudios { get; }
         UniTask LoadAudioSourcePrefab(Action<GameObject> callback);
         UniTask WarmGameplayMusic( );
         void ReleaseActionMusic();
@@ -28,5 +29,9 @@ namespace Code.Audio
         void ReleaseEnemies();
         UniTask WarmDispatcher( );
         void ReleaseDispatcher();
+        UniTask WarmCourier();
+        void ReleaseCourier();
+        UniTask WarmDeathMusic( );
+        void ReleaseDeathMusic();
     }
 }

Game/CourierOld/Assets/Code/Audio/IAudioService.cs

@@ -23,5 +23,9 @@ namespace Code.Audio
         void ChangeSetting(AudioType type, float value);
         float GetSetting(AudioType type);
         void PlayTestClip(AudioType audioType);
+        AudioSource GetSourceOfGroup(AudioType group);
+        void ReleaseSourceOfGroup(AudioSource source);
+        void PlayCourier(CourierSounds range);
+        void ApplyStun(float value, float time);
     }
 }

Game/CourierOld/Assets/Code/Audio/MusicType.cs

@@ -4,15 +4,19 @@ namespace Code.Audio
     {
         Menu,
         Peaceful,
-        Action
+        Action,
+        Death
     }
     public enum AudioType
     {
         Master,
         MenuMusic, 
-        GameplayMusic,
+        Dispatcher,
-        Creatures,
+        SFX,
-        DispatcherSounds,
+        Courier,
-        SFX
+        Enemies,
+        ActionMusic,
+        PeacefulMusic,
+        DeathMusic
     } 
 }

Game/CourierOld/Assets/Code/Configs/CharacterConfig.cs

@@ -5,31 +5,42 @@ namespace Code.Configs
     [CreateAssetMenu(fileName = "CharacterConfig", menuName = "Config/CharacterConfig")]
     public class CharacterConfig : ScriptableObject
     {
-        // Основное движение по земле
         public float 
-            maxStableMoveSpeed = 8f,        // Максимальная скорость движения по устойчивой поверхности
+            maxStableMoveSpeed = 12f,
-            stableMovementSharpness = 15f,  // Резкость изменения скорости движения (чем выше - тем резче)
+            stableMovementSharpness = 15f,
-            orientationSharpness = 10f,     // Резкость изменения вращения персонажа (чем выше - тем резче)
+            orientationSharpness = 10f,
-            jumpSpeed = 10f;                // Скорость прыжка
+            jumpSpeed = 10f;
         
-        // Спринт
         public float 
-            sprintMoveSpeed = 12f,          // Максимальная скорость спринта
+            dashSpeed = 20f,
-            sprintAngleThreshold = 90f;     // Максимальный угол (в градусах) от направления вперёд, при котором разрешён спринт
+            dashDuration = 0.35f,
+            dashCooldown = 1.2f;
         
-        // Слайд
+        public AnimationCurve slideVelocityCurve = new(
+            new Keyframe(0.0f, 1.0f),
+            new Keyframe(0.3f, 1.4f),
+            new Keyframe(1.0f, 0.2f)
+        );
         public float 
-            slideSpeed = 20f,               // Скорость слайда
+            slideMinVelocityThreshold = 3f,
-            slideDuration = 0.8f,           // Длительность слайда в секундах
+            slideCooldown = 1.5f;
-            slideCooldown = 1.5f;           // Время перезарядки слайда в секундах
 
-        // Наклон при залазании на стены
         public float
             leanAngle = 25f,
             leanThreshold = 0.3f,
             leanSmoothSpeed = 10f;
 
-        // Гравитация
+        public Vector3 gravity = new(0f, -30f, 0f);
-        public Vector3 gravity = new(0f, -30f, 0f); // Вектор, отвечающий за применение гравитации
+        public float
+            maxAirSpeed = 10f,
+            airControlSharpness = 8f;
+        
+        public float
+            wallRunMaxTime = 1.75f,
+            wallRunSpeed = 15f,
+            wallRunAcceleration = 25f,
+            wallRunGravityScale = 0.25f,
+            wallDetachImpulse = 7f,
+            wallContactAngleThreshold = 45f;
     }
 }

Game/CourierOld/Assets/Code/Configs/CharacterSoundListConfig.cs

@@ -1,11 +0,0 @@
-using UnityEngine;
-using UnityEngine.AddressableAssets;
-
-namespace Code.Configs
-{
-    [CreateAssetMenu(menuName = "Config/Audio/CharacterSoundList", fileName = "CharacterSoundListConfig")]
-    public class CharacterSoundListConfig : ScriptableObject
-    {   
-        public AssetReference[] character;
-    }
-}

Game/CourierOld/Assets/Code/Configs/CourierSoundListConfig.cs

@@ -0,0 +1,11 @@
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(menuName = "Config/Audio/CourierSoundListConfig", fileName = "CourierSoundListConfig")]
+    public class CourierSoundListConfig : ScriptableObject
+    {   
+        public AssetReference[] courierSounds;
+    }
+}

Game/CourierOld/Assets/Code/Configs/DefaultAudioSettingsConfig.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using AYellowpaper.SerializedCollections;
+using UnityEngine;
+using AudioType = Code.Audio.AudioType;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(fileName = "DefaultAudioSettingsConfig", menuName = "Audio/DefaultAudioSettings")]
+    public class DefaultAudioSettingsConfig : ScriptableObject
+    {
+        [Header("Menu")]
+        [SerializedDictionary("AudioType", "Volume")]
+        public SerializedDictionary<Audio.AudioType, float> menuVolume = new();
+        
+        [Header("Action")]
+        [SerializedDictionary("AudioType", "Volume")]
+        public SerializedDictionary<Audio.AudioType, float> actionVolume = new();
+        
+        [Header("Peaceful")]
+        [SerializedDictionary("AudioType", "Volume")]
+        public SerializedDictionary<Audio.AudioType, float> peacefulVolume = new();
+
+        [Header("None")]
+        [SerializedDictionary("AudioType", "Volume")]
+        public SerializedDictionary<Audio.AudioType, float> noneVolume = new();
+    }
+}

Game/CourierOld/Assets/Code/Configs/DefaultAudioSettingsConfig.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 36d35c52933d4d4ba836f75b05c4810f
+timeCreated: 1764754933

Game/CourierOld/Assets/Code/Configs/MusicPlayerConfig.cs

@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(menuName = "Config/Audio/MusicPlayer", fileName = "MusicPlayerConfig")]
+    public class MusicPlayerConfig : ScriptableObject
+    {
+        public float threshold = 0.5f;
+    }
+}

Game/CourierOld/Assets/Code/Configs/MusicPlayerConfig.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8708e3c129d241b08563f1a170bd3a44
+timeCreated: 1764585060

Game/CourierOld/Assets/Code/Configs/SoundtrackListConfig.cs

@@ -8,6 +8,7 @@ namespace Code.Configs
     {
         public AssetReference[] peacefulSoundtrack;
         public AssetReference[] actionSoundtrack;
+        public AssetReference[] deathSoundtrack;
         public AssetReference[] menuSoundtrack;
     }
 }

Game/CourierOld/Assets/Code/Constants/StringPaths.cs

@@ -19,13 +19,14 @@ namespace Code.Constants
         public const string PeacefulMusicGroup = "Peaceful";
         public const string ActionMusicGroup = "Action";
         public const string DispatcherMusicGroup = "Dispatcher";
-        public const string CourierMusicGroup = "Courier";
+        public const string CourierGroup = "Courier";
-        public const string EnemiesMusicGroup = "Enemies";
+        public const string EnemiesGroup = "Enemies";
         
         public const string PeacefulSnapshot = "Peaceful";
         public const string ActionSnapshot = "Action";
         public const string NoneSnapshot = "None";
         public const string MenuSnapshot = "Menu";
         public const string MenuMusicGroup = "Menu";
+        public const string DeathMusicGroup = "Death";
     }
 }

Game/CourierOld/Assets/Code/Gameplay/Camera/CameraStates/FirstPersonState.cs

@@ -24,6 +24,8 @@ namespace Code.Gameplay.Camera.CameraStates
             CurrentDistance = 0f;
 
             Camera.fieldOfView = Context.CameraSettingsConfigs[CameraMode.FirstPerson].fov;
+            
+            Cursor.lockState = CursorLockMode.Locked;
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)

Game/CourierOld/Assets/Code/Gameplay/Camera/CameraStates/MainMenuState.cs

@@ -11,6 +11,7 @@ namespace Code.Gameplay.Camera.CameraStates
             base.EnterState();
             
             Camera.fieldOfView = Context.CameraSettingsConfigs[CameraMode.MainMenu].fov;
+            Cursor.lockState = CursorLockMode.None;
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)

Game/CourierOld/Assets/Code/Gameplay/Camera/CameraStates/StaticState.cs

@@ -12,6 +12,7 @@ namespace Code.Gameplay.Camera.CameraStates
             base.EnterState();
             
             Camera.fieldOfView = Context.CameraSettingsConfigs[CameraMode.Static].fov;
+            Cursor.lockState = CursorLockMode.None;
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/DashMechanic.cs

@@ -0,0 +1,82 @@
+using UnityEngine;
+using Code.Gameplay.Camera;
+using KinematicCharacterController;
+
+namespace Code.Gameplay.Character.Controller.Abilities
+{
+    public class DashMechanic
+    {
+        private readonly float _dashSpeed;
+        private readonly float _dashDuration;
+        private readonly float _dashCooldown;
+
+        private float _dashTimer;
+        private float _dashCooldownTimer;
+        private Vector3 _dashDirection;
+        private bool _dashRequested;
+
+        public bool IsDashing { get; private set; }
+
+        public DashMechanic(float dashSpeed, float dashDuration, float dashCooldown)
+        {
+            _dashSpeed = dashSpeed;
+            _dashDuration = dashDuration;
+            _dashCooldown = dashCooldown;
+        }
+
+        public void TickCooldown(float deltaTime)
+        {
+            if (_dashCooldownTimer > 0f) _dashCooldownTimer -= deltaTime;
+        }
+
+        public void RequestDash(bool dashPressed)
+        {
+            if (dashPressed && !_dashRequested && _dashCooldownTimer <= 0f)
+                _dashRequested = true;
+        }
+
+        public void TryStartDash(KinematicCharacterMotor motor,
+            CameraMode currentCameraMode,
+            Quaternion firstPersonCameraRotation,
+            Vector3 lookInputVector)
+        {
+            if (!_dashRequested || !motor.GroundingStatus.IsStableOnGround || _dashCooldownTimer > 0f)
+            {
+                _dashRequested = false;
+                return;
+            }
+
+            IsDashing = true;
+            _dashTimer = _dashDuration;
+
+            var dir = currentCameraMode == CameraMode.FirstPerson
+                ? firstPersonCameraRotation * Vector3.forward
+                : lookInputVector;
+
+            _dashDirection = Vector3.ProjectOnPlane(dir, motor.CharacterUp).normalized;
+            if (_dashDirection.sqrMagnitude < 0.01f) _dashDirection = motor.CharacterForward;
+
+            _dashCooldownTimer = _dashCooldown;
+            _dashRequested = false;
+        }
+
+        public void HandleDash(ref Vector3 currentVelocity, float deltaTime, KinematicCharacterMotor motor)
+        {
+            _dashTimer -= deltaTime;
+            if (_dashTimer <= 0f || !motor.GroundingStatus.IsStableOnGround)
+            {
+                EndDash();
+                return;
+            }
+
+            currentVelocity = _dashDirection * _dashSpeed;
+            currentVelocity += motor.CharacterUp * 1.5f;
+        }
+
+        public void EndDash()
+        {
+            IsDashing = false;
+            _dashTimer = 0f;
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/DashMechanic.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6d62efb53e0c4d49be9fc658484e2575
+timeCreated: 1764856437

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/SlideMechanic.cs

@@ -1,122 +1,91 @@
+using UnityEngine;
 using Code.Gameplay.Camera;
 using KinematicCharacterController;
-using UnityEngine;
 
 namespace Code.Gameplay.Character.Controller.Abilities
 {
-    /*
-     * Механика слайда для персонажа
-     * Отвечает за управление состоянием, таймерами и скоростью слайда
-     */
     public class SlideMechanic
     {
-        // Скорость слайда
+        private readonly AnimationCurve _velocityCurve;
-        private readonly float _slideSpeed;
+        private readonly float _minVelocityThreshold;
-        // Длительность слайда в секундах
+        private readonly float _cooldown;
-        private readonly float _slideDuration;
-        // Время перезарядки слайда
-        private readonly float _slideCooldown;
 
-        // Таймер слайда
+        private float _slideTime;
-        private float _slideTimer;
+        private float _cooldownTimer;
-        // Таймер перезарядки слайда
-        private float _slideCooldownTimer;
-        // Направление слайда
         private Vector3 _slideDirection;
-        // Флаг запроса слайда
         private bool _slideRequested;
+        private float _initialSpeed;
 
-        // Свойство-флаг, активен ли слайд
         public bool IsSliding { get; private set; }
 
-        // Конструктор механики слайда
+        public SlideMechanic(AnimationCurve velocityCurve, float minVelocityThreshold, float cooldown)
-        public SlideMechanic(float slideSpeed, float slideDuration, float slideCooldown)
         {
-            _slideSpeed = slideSpeed;
+            _velocityCurve = velocityCurve;
-            _slideDuration = slideDuration;
+            _minVelocityThreshold = minVelocityThreshold;
-            _slideCooldown = slideCooldown;
+            _cooldown = cooldown;
         }
 
-        // Обновляем таймер перезарядки слайда
         public void TickCooldown(float deltaTime)
         {
-            if (_slideCooldownTimer > 0f)
+            if (_cooldownTimer > 0f) _cooldownTimer -= deltaTime;
-            {
-                _slideCooldownTimer -= deltaTime;
-            }
         }
 
-        // Обработка слайда
         public void RequestSlide(bool slidePressed)
         {
-            if (slidePressed && !_slideRequested && _slideCooldownTimer <= 0f)
+            if (slidePressed && !_slideRequested && _cooldownTimer <= 0f)
-            {
                 _slideRequested = true;
         }
-        }
 
-        // Начало слайда
         public void TryStartSlide(KinematicCharacterMotor motor,
             CameraMode currentCameraMode,
             Quaternion firstPersonCameraRotation,
             Vector3 lookInputVector)
         {
-            // Проверяем условия для старта слайда
+            if (!_slideRequested || !motor.GroundingStatus.IsStableOnGround || _cooldownTimer > 0f)
-            if (!_slideRequested || !motor.GroundingStatus.IsStableOnGround || _slideCooldownTimer > 0f)
             {
                 _slideRequested = false;
                 return;
             }
 
             IsSliding = true;
-            _slideTimer = _slideDuration;
+            _slideTime = 0f;
 
-            // НАПРАВЛЕНИЕ СЛАЙДА - ВСЕГДА ВПЕРЕД ПО КАМЕРЕ
+            var dir = currentCameraMode == CameraMode.FirstPerson
-            // Используем направление камеры, но проецируем на горизонтальную плоскость
+                ? firstPersonCameraRotation * Vector3.forward
-            var slideDir = currentCameraMode == CameraMode.FirstPerson ? 
+                : lookInputVector;
-                firstPersonCameraRotation * Vector3.forward : 
-                lookInputVector;
 
-            // Проецируем на горизонтальную плоскость и нормализуем
+            _slideDirection = Vector3.ProjectOnPlane(dir, motor.CharacterUp).normalized;
-            _slideDirection = Vector3.ProjectOnPlane(slideDir, motor.CharacterUp).normalized;
+            if (_slideDirection.sqrMagnitude < 0.01f) _slideDirection = motor.CharacterForward;
 
-            // Если направление нулевое (персонаж стоит на месте), используем направление вперед
+            _initialSpeed = motor.Velocity.magnitude;
-            if (_slideDirection.sqrMagnitude < 0.01f)
+            if (_initialSpeed < 12f) _initialSpeed = 12f; // fallback
-            {
-                _slideDirection = motor.CharacterForward;
-            }
             
-            // Устанавливаем перезарядку
+            _cooldownTimer = _cooldown;
-            _slideCooldownTimer = _slideCooldown;
             _slideRequested = false;
         }
 
-        // Обработка слайда
         public void HandleSlide(ref Vector3 currentVelocity, float deltaTime, KinematicCharacterMotor motor)
         {
-            // Уменьшаем таймер слайда
+            if (!IsSliding) return;
-            _slideTimer -= deltaTime;
 
-            // Если время слайда вышло, персонаж в воздухе - заканчиваем слайд
+            _slideTime += deltaTime;
-            if (_slideTimer <= 0f || !motor.GroundingStatus.IsStableOnGround)
+            
-            {
+            var t = Mathf.Clamp01(_slideTime / 2.5f);
+            var speedMult = _velocityCurve.Evaluate(t);
+
+            var targetSpeed = _initialSpeed * speedMult;
+            currentVelocity = _slideDirection * targetSpeed;
+
+            currentVelocity += motor.CharacterUp * 1f;
+
+            if (targetSpeed < _minVelocityThreshold || !motor.GroundingStatus.IsStableOnGround)
                 EndSlide();
-                return;
         }
 
-            // Устанавливаем скорость слайда вперед
-            // Используем прямую установку скорости вместо сложных вычислений
-            currentVelocity = _slideDirection * _slideSpeed;
-            
-            // Добавляем небольшую вертикальную компоненту для лучшего скольжения по неровностям
-            currentVelocity += motor.CharacterUp * 2f;
-        }
-
-        // Завершение слайда
         public void EndSlide()
         {
             IsSliding = false;
-            _slideTimer = 0f;
+            _slideTime = 0f;
         }
     }
 }

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/WallRunningMechanic.cs

@@ -7,14 +7,13 @@ namespace Code.Gameplay.Character.Controller.Abilities
 {
     public class WallRunningMechanic
     {
-        public float MaxWallRunTime = 1.75f;
+        private readonly float _maxWallRunTime;
-        public float WallRunSpeed = 8.0f;
+        private readonly float _wallRunSpeed;
-        public float WallRunAcceleration = 25.0f;
+        private readonly float _wallRunAcceleration;
-        public float WallRunGravityScale = 0.25f;
+        private readonly float _wallRunGravityScale;
-        public float WallDetachImpulse = 7.0f;
+        private readonly float _wallDetachImpulse;
-        public float WallContactAngleThreshold = 45.0f;
+        private readonly float _wallContactAngleThreshold;
 
-        private bool _isWallRunning;
         private float _wallRunTimer;
         private Vector3 _wallNormal;
         private Vector3 _wallTangentRight;
@@ -24,53 +23,58 @@ namespace Code.Gameplay.Character.Controller.Abilities
 
         private float _surfaceAngleCos;
         private bool _canWallRun;
-        public float WallContactHeight { get; private set; }
-        
-        public Vector3 WallRunStartForward { get; private set; }
 
         private KinematicCharacterMotor _motor;
         private CharacterInputHandler _inputHandler;
 
-        public bool IsWallRunning => _isWallRunning;
+        public bool IsWallRunning { get; private set; }
+
+        public WallRunningMechanic(
+            float maxWallRunTime,
+            float wallRunSpeed,
+            float wallRunAcceleration,
+            float wallRunGravityScale,
+            float wallDetachImpulse,
+            float wallContactAngleThreshold)
+        {
+            _maxWallRunTime = maxWallRunTime;
+            _wallRunSpeed = wallRunSpeed;
+            _wallRunAcceleration = wallRunAcceleration;
+            _wallRunGravityScale = wallRunGravityScale;
+            _wallDetachImpulse = wallDetachImpulse;
+            _wallContactAngleThreshold = wallContactAngleThreshold;
+        }
 
         public void Initialize(KinematicCharacterMotor motor, CharacterInputHandler inputHandler)
         {
             _motor = motor;
             _inputHandler = inputHandler;
-            _surfaceAngleCos = Mathf.Cos(Mathf.Deg2Rad * WallContactAngleThreshold);
+            _surfaceAngleCos = Mathf.Cos(Mathf.Deg2Rad * _wallContactAngleThreshold);
-        }
-
-        public void Reset()
-        {
-            _isWallRunning = false;
-            _wallRunTimer = 0f;
-            _wallNormal = Vector3.zero;
         }
 
         public void Tick(float deltaTime)
         {
-            if (_isWallRunning)
+            if (!IsWallRunning) return;
-            {
+            
             _wallRunTimer += deltaTime;
-                if (_wallRunTimer > MaxWallRunTime)
+            if (_wallRunTimer > _maxWallRunTime)
             {
                 DetachFromWall(false);
             }
         }
-        }
 
         public bool TryStartWallRun(Vector3 hitNormal, Vector3 hitPoint)
         {
-            if (_isWallRunning) return false;
+            if (IsWallRunning) return false;
 
-            float dotWithUp = Vector3.Dot(hitNormal, _motor.CharacterUp);
+            var dotWithUp = Vector3.Dot(hitNormal, _motor.CharacterUp);
-            bool isWall = Mathf.Abs(dotWithUp) < _surfaceAngleCos;
+            var isWall = Mathf.Abs(dotWithUp) < _surfaceAngleCos;
 
             if (!isWall) return false;
 
             if (_motor.GroundingStatus.IsStableOnGround) return false;
 
-            float velocityIntoWall = Vector3.Dot(_motor.Velocity, -hitNormal);
+            var velocityIntoWall = Vector3.Dot(_motor.Velocity, -hitNormal);
             if (velocityIntoWall < 1f) return false;
 
             StartWallRun(hitNormal, hitPoint);
@@ -79,13 +83,11 @@ namespace Code.Gameplay.Character.Controller.Abilities
 
         private void StartWallRun(Vector3 wallNormal, Vector3 contactPoint)
         {
-            _isWallRunning = true;
+            IsWallRunning = true;
             _wallRunTimer = 0f;
             _wallNormal = wallNormal.normalized;
             _wallContactPoint = contactPoint;
-            WallContactHeight = contactPoint.y;
 
-            //_wallTangentUp = Vector3.ProjectOnPlane(_motor.CharacterUp, _wallNormal).normalized;
             if (_wallTangentUp.sqrMagnitude < 0.01f) _wallTangentUp = Vector3.up;
 
             _wallTangentRight = Vector3.Cross(_wallNormal, _wallTangentUp).normalized;
@@ -94,42 +96,41 @@ namespace Code.Gameplay.Character.Controller.Abilities
             if (Vector3.Dot(_wallTangentUp, Vector3.up) < 0)
                 _wallTangentUp = -_wallTangentUp;
 
-            WallRunStartForward = _motor.CharacterForward;
             _motor.ForceUnground();
         }
 
         public void HandleWallRun(ref Vector3 currentVelocity, CharacterInputs inputs, float deltaTime)
         {
-            if (!_isWallRunning) return;
+            if (!IsWallRunning) return;
             if (!IsWallStillPresent()) { DetachFromWall(false); return; }
 
-            Vector3 moveInputWorld = _inputHandler.MoveInputVector;
+            var moveInputWorld = _inputHandler.MoveInputVector;
-            Vector3 moveInWallPlane = Vector3.ProjectOnPlane(moveInputWorld, _wallNormal);
+            var moveInWallPlane = Vector3.ProjectOnPlane(moveInputWorld, _wallNormal);
     
-            Vector3 wsMove = Vector3.Project(moveInWallPlane, _wallTangentRight);
+            var wsMove = Vector3.Project(moveInWallPlane, _wallTangentRight);
 
-            float ad = inputs.MoveAxisRight;
+            var ad = inputs.MoveAxisRight;
 
-            float sideDot = Vector3.Dot(_wallNormal, _motor.CharacterRight);
+            var sideDot = Vector3.Dot(_wallNormal, _motor.CharacterRight);
             if (sideDot < 0)
                 ad = -ad;
 
-            Vector3 adMove = _wallTangentUp * (-ad);
+            var adMove = _wallTangentUp * (-ad);
 
-            Vector3 finalMove = wsMove + adMove;
+            var finalMove = wsMove + adMove;
             finalMove = finalMove.normalized * moveInputWorld.magnitude;
 
-            Vector3 targetVelocity = finalMove * WallRunSpeed;
+            var targetVelocity = finalMove * _wallRunSpeed;
 
             currentVelocity = Vector3.Lerp(
                 currentVelocity,
                 targetVelocity,
-                1f - Mathf.Exp(-WallRunAcceleration * deltaTime)
+                1f - Mathf.Exp(-_wallRunAcceleration * deltaTime)
             );
 
-            currentVelocity += Physics.gravity * (WallRunGravityScale * deltaTime);
+            currentVelocity += Physics.gravity * (_wallRunGravityScale * deltaTime);
 
-            float distanceToWall = Vector3.Dot(_motor.TransientPosition - _wallContactPoint, _wallNormal);
+            var distanceToWall = Vector3.Dot(_motor.TransientPosition - _wallContactPoint, _wallNormal);
             if (Mathf.Abs(distanceToWall) > 0.8f)
             {
                 DetachFromWall(false);
@@ -144,16 +145,15 @@ namespace Code.Gameplay.Character.Controller.Abilities
         
         private bool IsWallStillPresent()
         {
-            if (_motor == null) return false;
+            if (!_motor) return false;
 
-            Vector3 characterCenter = _motor.TransientPosition;
+            var characterCenter = _motor.TransientPosition;
-            Vector3 characterForward = _motor.CharacterForward;
+            var characterRight = _motor.CharacterRight;
-            Vector3 characterRight = _motor.CharacterRight;
+            var characterUp = _motor.CharacterUp;
-            Vector3 characterUp = _motor.CharacterUp;
 
-            float checkDistance = 0.45f;
+            const float checkDistance = 0.45f;
-            Vector3 rayOrigin = characterCenter + characterUp * 0.2f;
+            var rayOrigin = characterCenter + characterUp * 0.2f;
-            Vector3 rayDir = -_wallNormal;
+            var rayDir = -_wallNormal;
 
             Vector3[] offsets = {
                 Vector3.zero,
@@ -165,83 +165,60 @@ namespace Code.Gameplay.Character.Controller.Abilities
 
             foreach (var offset in offsets)
             {
-                if (Physics.Raycast(rayOrigin + offset, rayDir, out RaycastHit hit, checkDistance, 
+                if (!Physics.Raycast(rayOrigin + offset, rayDir, out var hit, checkDistance,
-                        _motor.CollidableLayers, QueryTriggerInteraction.Ignore))
+                        _motor.CollidableLayers, QueryTriggerInteraction.Ignore)) continue;
-                {
+                
-                    float dotWithUp = Mathf.Abs(Vector3.Dot(hit.normal, characterUp));
+                var dotWithUp = Mathf.Abs(Vector3.Dot(hit.normal, characterUp));
-                    if (dotWithUp < _surfaceAngleCos)
+                
-                    {
+                if (!(dotWithUp < _surfaceAngleCos)) continue;
+                
                 _wallNormal = hit.normal.normalized;
                 _wallContactPoint = hit.point;
 
-                        /*_wallTangentUp = Vector3.ProjectOnPlane(_motor.CharacterUp, _wallNormal).normalized;
-                        if (_wallTangentUp.sqrMagnitude < 0.01f) _wallTangentUp = Vector3.up;
-                        _wallTangentRight = Vector3.Cross(_wallNormal, _wallTangentUp).normalized;
-                        */
-
                 return true;
             }
-                }
-            }
 
             return false;
         }
 
-        public void DetachFromWall(bool withImpulse)
+        private void DetachFromWall(bool withImpulse)
         {
-            if (!_isWallRunning) return;
+            if (!IsWallRunning) return;
 
-            _isWallRunning = false;
+            IsWallRunning = false;
 
-            if (withImpulse && _motor != null)
+            if (!withImpulse || !_motor) return;
-            {
+            
-                Vector3 detachImpulse = -_wallNormal * WallDetachImpulse;
+            var detachImpulse = -_wallNormal * _wallDetachImpulse;
             _motor.BaseVelocity += detachImpulse;
         }
-        }
 
         public Vector3 GetWallNormal() => _wallNormal;
-        public bool TryGetWallTangents(out Vector3 up, out Vector3 right)
-        {
-            if (!_isWallRunning)
-            {
-                up = right = Vector3.zero;
-                return false;
-            }
-            up = _wallTangentUp;
-            right = _wallTangentRight;
-            return true;
-        }
-
-        public bool CanWallRun()
-        {
-            return !_isWallRunning && !_motor.GroundingStatus.IsStableOnGround;
-        }
 
         public void PerformWallJump(CharacterInputs inputs, Quaternion cameraRotation)
         {
-            if (!_isWallRunning || _motor == null) return;
+            if (!IsWallRunning || !_motor) return;
 
-            _isWallRunning = false;
+            IsWallRunning = false;
 
-            Vector3 wallAway = _wallNormal;
+            var wallAway = _wallNormal;
-            Vector3 wallUp = _wallTangentUp;
+            var wallUp = _wallTangentUp;
 
-            Vector3 playerForward = cameraRotation * Vector3.forward;
+            var playerForward = cameraRotation * Vector3.forward;
 
-            Vector3 forwardInWallPlane = Vector3.ProjectOnPlane(playerForward, _wallNormal).normalized;
+            var forwardInWallPlane = Vector3.ProjectOnPlane(playerForward, _wallNormal).normalized;
             if (forwardInWallPlane.sqrMagnitude < 0.01f) forwardInWallPlane = _wallTangentRight;
 
-            Vector3 jumpDirection = 
+            var jumpDirection = 
                 forwardInWallPlane * 0.2f +
                 wallAway * 0.4f +
                 wallUp * 0.4f;
 
             jumpDirection = jumpDirection.normalized;
 
-            float wallJumpForce = WallDetachImpulse * 2f;
+            var wallJumpForce = _wallDetachImpulse * 2f;
 
-            Vector3 jumpImpulse = jumpDirection * wallJumpForce;
+            var jumpImpulse = jumpDirection * wallJumpForce;
 
             _motor.BaseVelocity += jumpImpulse;
 

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/CustomCharacterController.cs

@@ -27,6 +27,7 @@ namespace Code.Gameplay.Character.Controller
 
         // Подсистемы
         private CharacterInputHandler _inputHandler;
+        private DashMechanic _dashMechanic;
         private SlideMechanic _slideMechanic;
         // private WallClimbMechanic _wallClimbMechanic;
         private WallRunningMechanic _wallRunningMechanic;
@@ -35,6 +36,7 @@ namespace Code.Gameplay.Character.Controller
         private AirMovementSystem _airMovement;
         
         public bool IsSliding => _slideMechanic.IsSliding; 
+        public bool IsDashing => _dashMechanic.IsDashing; 
         public bool IsWallRunning => _wallRunningMechanic.IsWallRunning;
         
         private float abilityBlockTimer;
@@ -50,28 +52,25 @@ namespace Code.Gameplay.Character.Controller
         {
             _characterConfig = characterConfig;
             // Инициализация подсистем с параметрами из конфига
-            _inputHandler = new CharacterInputHandler(
+            _inputHandler = new CharacterInputHandler();
-                _characterConfig.sprintAngleThreshold
+            _dashMechanic = new DashMechanic(
+                _characterConfig.dashSpeed,
+                _characterConfig.dashDuration,
+                _characterConfig.dashCooldown
             );
             _slideMechanic = new SlideMechanic(
-                _characterConfig.slideSpeed,
+                _characterConfig.slideVelocityCurve,
-                _characterConfig.slideDuration,
+                _characterConfig.slideMinVelocityThreshold,
                 _characterConfig.slideCooldown
             );
-            // _wallClimbMechanic = new WallClimbMechanic(
+            _wallRunningMechanic = new WallRunningMechanic(
-            //     _characterConfig.wallClimbSpeedFactor,
+                _characterConfig.wallRunMaxTime,
-            //     _characterConfig.minWallClimbSpeed,
+                _characterConfig.wallRunSpeed,
-            //     _characterConfig.wallDetectionAngleThreshold
+                _characterConfig.wallRunAcceleration,
-            // );
+                _characterConfig.wallRunGravityScale,
-            _wallRunningMechanic = new WallRunningMechanic();
+                _characterConfig.wallDetachImpulse,
-            // Настройка параметров WallRunningMechanic (можно вынести в конфиг позже)
+                _characterConfig.wallContactAngleThreshold
-            _wallRunningMechanic.MaxWallRunTime = 1.75f;
+            );
-            _wallRunningMechanic.WallRunSpeed = 15.0f;
-            _wallRunningMechanic.WallRunAcceleration = 25.0f;
-            _wallRunningMechanic.WallRunGravityScale = 0.25f;
-            _wallRunningMechanic.WallDetachImpulse = 7.0f;
-            _wallRunningMechanic.WallContactAngleThreshold = 45.0f;
-            
             _wallLeanMechanic = new WallLeanMechanic(
                 _characterConfig.leanAngle,
                 _characterConfig.leanThreshold,
@@ -79,12 +78,14 @@ namespace Code.Gameplay.Character.Controller
                 );
             _groundMovement = new GroundMovementSystem(
                 _characterConfig.maxStableMoveSpeed,
-                _characterConfig.sprintMoveSpeed,
                 _characterConfig.stableMovementSharpness,
                 _characterConfig.jumpSpeed
             );
-            _airMovement = new AirMovementSystem(_characterConfig.gravity);
+            _airMovement = new AirMovementSystem(
-            
+                _characterConfig.gravity,
+                _characterConfig.maxAirSpeed,
+                _characterConfig.airControlSharpness
+            );
             
             motor.CharacterController = this; // Регистрация этого контроллера в движке
             _inputHandler.FirstPersonCameraRotation =
@@ -99,17 +100,15 @@ namespace Code.Gameplay.Character.Controller
         public void SetInputs(ref CharacterInputs inputs)
         {
             _lastInputs = inputs;
-            // Обновляем таймеры механик
+            _dashMechanic.TickCooldown(Time.deltaTime);
             _slideMechanic.TickCooldown(Time.deltaTime);
-            // _wallClimbMechanic.TickCooldown(Time.deltaTime);
             _wallRunningMechanic.Tick(Time.deltaTime);
 
             // Если активен слайд - игнорируем весь остальной ввод
-            if (_slideMechanic.IsSliding)
+            if (_dashMechanic.IsDashing || _slideMechanic.IsSliding)
             {
                 _inputHandler.MoveInputVector = Vector3.zero;
                 _inputHandler.LookInputVector = Vector3.one;
-                _inputHandler.IsSprinting = false;
                 _groundMovement.RequestJump(inputs.JumpPressed);
                 return;
             }
@@ -125,12 +124,12 @@ namespace Code.Gameplay.Character.Controller
                 }
                 else
                 {
-                    inputs.SprintPressed = false;
+                    inputs.DashPressed = false;
                     inputs.SlidePressed = false;
                 }
             }
 
-            // Обработка слайда
+            _dashMechanic.RequestDash(inputs.DashPressed);
             _slideMechanic.RequestSlide(inputs.SlidePressed);
 
             // Обработка остального ввода
@@ -172,16 +171,21 @@ namespace Code.Gameplay.Character.Controller
 
         public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
         {
+            if (_dashMechanic.IsDashing && _groundMovement.JumpRequested)
+                _dashMechanic.EndDash();
             if (_slideMechanic.IsSliding && _groundMovement.JumpRequested)
-            {
                 _slideMechanic.EndSlide();
+
+            if (!_dashMechanic.IsDashing)
+                _dashMechanic.TryStartDash(motor, _currentCameraMode, _inputHandler.FirstPersonCameraRotation, _inputHandler.LookInputVector);
+            else
+            {
+                _dashMechanic.HandleDash(ref currentVelocity, deltaTime, motor);
+                return;
             }
 
             if (!_slideMechanic.IsSliding)
-            {
+                _slideMechanic.TryStartSlide(motor, _currentCameraMode, _inputHandler.FirstPersonCameraRotation, _inputHandler.LookInputVector);
-                _slideMechanic.TryStartSlide(motor, _currentCameraMode, _inputHandler.FirstPersonCameraRotation,
-                    _inputHandler.LookInputVector);
-            }
             else
             {
                 _slideMechanic.HandleSlide(ref currentVelocity, deltaTime, motor);
@@ -212,7 +216,7 @@ namespace Code.Gameplay.Character.Controller
             // Если персонаж не на земле — стандартное воздушное движение
             else
             {
-                _airMovement.UpdateVelocity(ref currentVelocity, deltaTime);
+                _airMovement.UpdateVelocity(ref currentVelocity, _inputHandler, motor, deltaTime);
                 _groundMovement.CancelJumpRequest();
             }
         }
@@ -229,11 +233,11 @@ namespace Code.Gameplay.Character.Controller
 
         public void PostGroundingUpdate(float deltaTime)
         {
+            if (_dashMechanic.IsDashing && !motor.GroundingStatus.IsStableOnGround)
+                _dashMechanic.EndDash();
             if (_slideMechanic.IsSliding && !motor.GroundingStatus.IsStableOnGround)
-            {
                 _slideMechanic.EndSlide();
         }
-        }
 
         public void AfterCharacterUpdate(float deltaTime)
         {

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Input/CharacterInputHandler.cs

@@ -11,40 +11,23 @@ namespace Code.Gameplay.Character.Controller.Input
      */
     public class CharacterInputHandler
     {
-        // Косинус порогового угла для спринта (предвычислен)
-        private readonly float _sprintAngleThresholdCos;
         
         // Векторы движения и направления взгляда
         public Vector3 MoveInputVector { get; set; }
         public Vector3 LookInputVector { get; set; }
 
-        // Флаг-свойство указывающий, что активен режим спринта
-        public bool IsSprinting { get; set; }
-
         // Вращение камеры в FirstPerson режиме для синхронизации (только горизонтальная компонента)
         public Quaternion FirstPersonCameraRotation { get; set; }
         
         // Флаг-свойство указывающий, что нужно применить вращение камеры к персонажу
         public bool ShouldApplyCameraRotation { get; private set; }
 
-        // Конструктор с пороговым углом
-        public CharacterInputHandler(float sprintAngleThreshold)
-        {
-            // Предвычисляем косинус порогового угла для эффективности
-            // Угол в градусах → радианы → косинус
-            // Чем меньше угол — тем строже условие
-            _sprintAngleThresholdCos = Mathf.Cos(Mathf.Deg2Rad * sprintAngleThreshold);
-        }
-        
         // Обработка и преобразование входных данных от персонажа
         public void ProcessInputs(ref CharacterInputs inputs, KinematicCharacterMotor motor)
         {
             // Сохраняем текущий режим камеры
             var currentCameraMode = inputs.CameraMode;
             
-            // Обработка спринта
-            IsSprinting = inputs.SprintPressed && inputs.MoveAxisForward > _sprintAngleThresholdCos; // Спринт только при движении на заданный в конфиге угол
-
             // Нормализация вектора движения и ограничение его величины до 1
             var moveInputVector = 
                 Vector3.ClampMagnitude(new Vector3(inputs.MoveAxisRight, 0, inputs.MoveAxisForward), 1f);

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Movement/AirMovementSystem.cs

@@ -1,26 +1,38 @@
 using UnityEngine;
+using Code.Gameplay.Character.Controller.Input;
+using KinematicCharacterController;
 
 namespace Code.Gameplay.Character.Controller.Movement
 {
-    /*
-     * Система движения персонажа в воздухе
-     */
     public class AirMovementSystem
     {
-        // Вектор, отвечающий за применение гравитации
         private readonly Vector3 _gravity;
+        private readonly float _maxAirSpeed;
+        private readonly float _airControlSharpness;
 
-        // Конструктор системы движения в воздухе
+        public AirMovementSystem(Vector3 gravity, float maxAirSpeed, float airControlSharpness)
-        public AirMovementSystem(Vector3 gravity)
         {
             _gravity = gravity;
+            _maxAirSpeed = maxAirSpeed;
+            _airControlSharpness = airControlSharpness;
         }
 
-        // Обновление скорости движения персонажа в воздухе
+        public void UpdateVelocity(ref Vector3 currentVelocity, CharacterInputHandler inputHandler, KinematicCharacterMotor motor, float deltaTime)
-        public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
         {
-            // Применяем гравитацию
             currentVelocity += _gravity * deltaTime;
+
+            var horizontalVelocity = Vector3.ProjectOnPlane(currentVelocity, motor.CharacterUp);
+            var verticalVelocity = Vector3.Dot(currentVelocity, motor.CharacterUp) * motor.CharacterUp;
+
+            var desiredHorizontalMovement = Vector3.ProjectOnPlane(inputHandler.MoveInputVector, motor.CharacterUp).normalized * _maxAirSpeed;
+
+            horizontalVelocity = Vector3.Lerp(
+                horizontalVelocity,
+                desiredHorizontalMovement,
+                1f - Mathf.Exp(-_airControlSharpness * deltaTime)
+            );
+
+            currentVelocity = horizontalVelocity + verticalVelocity;
         }
     }
 }

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Movement/GroundMovementSystem.cs

@@ -11,8 +11,6 @@ namespace Code.Gameplay.Character.Controller.Movement
     {
         // Максимальная скорость движения по устойчивой поверхности
         private readonly float _maxStableMoveSpeed;
-        // Максимальная скорость спринта
-        private readonly float _sprintMoveSpeed;
         // Резкость изменения скорости движения (чем выше - тем резче)
         private readonly float _stableMovementSharpness;
         // Скорость прыжка
@@ -22,10 +20,9 @@ namespace Code.Gameplay.Character.Controller.Movement
         public bool JumpRequested { get; private set; }
 
         // Конструктор системы движения на земле
-        public GroundMovementSystem(float maxStableMoveSpeed, float sprintMoveSpeed, float stableMovementSharpness, float jumpSpeed)
+        public GroundMovementSystem(float maxStableMoveSpeed, float stableMovementSharpness, float jumpSpeed)
         {
             _maxStableMoveSpeed = maxStableMoveSpeed;
-            _sprintMoveSpeed = sprintMoveSpeed;
             _stableMovementSharpness = stableMovementSharpness;
             _jumpSpeed = jumpSpeed;
         }
@@ -66,8 +63,7 @@ namespace Code.Gameplay.Character.Controller.Movement
                                   inputHandler.MoveInputVector.magnitude;
 
             // Расчет целевой скорости движения с учетом ограничения максимальной скорости и спринта
-            var targetSpeed = inputHandler.IsSprinting ? _sprintMoveSpeed : _maxStableMoveSpeed;
+            var targetMovementVelocity = reorientedInput * _maxStableMoveSpeed;
-            var targetMovementVelocity = reorientedInput * targetSpeed;
 
             // Плавная интерполяция текущей скорости к целевой с экспоненциальным сглаживанием
             currentVelocity = Vector3.Lerp(

Game/CourierOld/Assets/Code/Gameplay/Character/Core/Character.cs

@@ -45,8 +45,8 @@ namespace Code.Gameplay.Character.Core
             inputs.MoveAxisForward = moveInput.y; // Vertical ось (W/S или Up/Down)
             inputs.MoveAxisRight = moveInput.x; // Horizontal ось (A/D или Left/Right)
             inputs.JumpPressed = _inputService.JumpPressed; // Прыжки (Space)
-            inputs.SprintPressed = _inputService.SprintPressed; // Спринт (Shift)
             inputs.SlidePressed = _inputService.SlidePressed; // Слайд (Ctrl)
+            inputs.DashPressed = _inputService.DashPressed; // Слайд (Ctrl)
             inputs.CameraMode = ((ICameraState)_cameraStateMachine.CurrentBaseState).GetCameraMode();
 
             // Передаем информацию о камере для адаптивного поведения

Game/CourierOld/Assets/Code/Gameplay/Character/Core/CharacterInputs.cs

@@ -15,7 +15,7 @@ namespace Code.Gameplay.Character.Core
         public CameraMode CameraMode;          // Текущий режим камеры для адаптации поведения
         public Vector3 CameraPlanarDirection;  // Направление камеры в горизонтальной плоскости
         public bool JumpPressed;               // Флаг указывающий, нажата ли кнопка прыжка
-        public bool SprintPressed;             // Флаг указывающий, нажата ли кнопка спринта
+        public bool DashPressed;             
         public bool SlidePressed;              // Флаг указывающий, нажата ли кнопка слайда
     }
 }

Game/CourierOld/Assets/Code/Gameplay/Character/Core/CharacterProvider.cs

@@ -38,7 +38,7 @@ namespace Code.Gameplay.Character.Core
             inputs.MoveAxisForward = moveInput.y; // Vertical ось (W/S или Up/Down)
             inputs.MoveAxisRight = moveInput.x; // Horizontal ось (A/D или Left/Right)
             inputs.JumpPressed = _inputService.JumpPressed; // Прыжки (Space)
-            inputs.SprintPressed = true;//_inputService.SprintPressed; // Спринт (Shift)
+            inputs.DashPressed = _inputService.DashPressed;
             inputs.SlidePressed = _inputService.SlidePressed; // Слайд (Ctrl)
             inputs.CameraMode = ((ICameraState)_cameraStateMachine.CurrentBaseState).GetCameraMode();
 

Game/CourierOld/Assets/Code/Gameplay/Door/Door.cs

@@ -1,9 +1,13 @@
+using DG.Tweening;
 using UnityEngine; 
 
 namespace Code.Gameplay.Door
 {
     public class Door : MonoBehaviour
     {
+        [SerializeField] private Transform doorPolotno;
+        private Vector3 _doorInitialPosition;
+        private Quaternion _doorInitialRotation;
         [SerializeField] private Transform hingeJointAnchor;
         [SerializeField] private HingeJoint hingeJoint;
         [SerializeField] private Rigidbody rigidbody;
@@ -15,9 +19,19 @@ namespace Code.Gameplay.Door
                 rigidbody.isKinematic = true;
                 return;
             }
+            _doorInitialPosition = doorPolotno.position;
+            _doorInitialRotation = doorPolotno.rotation;
+            
             rigidbody.isKinematic = false;
             hingeJoint.autoConfigureConnectedAnchor = false;
             hingeJoint.connectedAnchor = hingeJointAnchor.position; 
         }
+
+        public void CloseTheDoor()
+        { 
+            TranslationMode(true);
+            doorPolotno.DORotate(_doorInitialRotation.eulerAngles, 0.5f);
+            doorPolotno.DOMove(_doorInitialPosition, 0.5f);
+        }
     }
 }

Game/CourierOld/Assets/Code/Gameplay/Door/DoorDebug.cs

@@ -0,0 +1,53 @@
+using System;
+using DG.Tweening;
+using UnityEngine;
+
+namespace Code.Gameplay.Door
+{
+    public class DoorDebug : MonoBehaviour
+    {
+        [SerializeField] private Transform doorSelf;
+        [SerializeField] private Transform doorPolotno;
+        private Vector3 _doorInitialPosition;
+        private Quaternion _doorInitialRotation;
+        [SerializeField] private Transform hingeJointAnchor;
+        [SerializeField] private HingeJoint hingeJoint;
+        [SerializeField] private Rigidbody rigidbody;
+        [SerializeField] private bool debug;
+        [SerializeField] private bool closed;
+
+        private void Start()
+        { 
+            _doorInitialPosition = doorPolotno.position;
+            _doorInitialRotation = doorPolotno.rotation;
+        }
+        private void Update()
+        {
+            if(debug && !closed)
+            {
+                CloseTheDoor();
+            }
+        }
+
+        public void TranslationMode(bool on)
+        {
+            if (on)
+            {
+                rigidbody.isKinematic = true;
+                return;
+            }
+            _doorInitialPosition = doorPolotno.position;
+            _doorInitialRotation = doorPolotno.rotation;
+
+            rigidbody.isKinematic = false;
+            hingeJoint.autoConfigureConnectedAnchor = false;
+            hingeJoint.connectedAnchor = hingeJointAnchor.position; 
+        }
+        public void CloseTheDoor()
+        { 
+            // TranslationMode(true);
+            doorPolotno.DORotate(_doorInitialRotation.eulerAngles, 0.5f);
+            doorPolotno.DOMove(_doorInitialPosition, 0.5f);
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Door/DoorDebug.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ed06ed70c7924ca9bc59f33ee7e6cdfa
+timeCreated: 1764533216

Game/CourierOld/Assets/Code/Gameplay/Door/DoorPooler.cs

@@ -0,0 +1,7 @@
+namespace Code.Gameplay.Door
+{
+    public class DoorPooler
+    {
+        
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Door/DoorPooler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: acfad6f51f224b51abb761fc22e4356f
+timeCreated: 1764521809

Game/CourierOld/Assets/Code/Gameplay/Enemies/Animators.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f17ace0fa75741f2a730ff21181c6e8c
+timeCreated: 1764575680

Game/CourierOld/Assets/Code/Gameplay/Enemies/Animators/EnemyAnimator.cs

@@ -0,0 +1,23 @@
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace Code.Gameplay.Enemies.Animators
+{
+    public class EnemyAnimator : MonoBehaviour
+    {
+        private static readonly int Velocity = Animator.StringToHash("Velocity");
+
+        [SerializeField] private Animator animator;
+        [SerializeField] private NavMeshAgent agent;
+
+        private void SetVelocity(float velocity)
+        {
+            animator.SetFloat(Velocity, velocity);
+        }
+
+        private void Update()
+        {
+            if(agent) SetVelocity(agent.velocity.magnitude);
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Enemies/Animators/EnemyAnimator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 936125a7ed844674b0e0586a484253ce
+timeCreated: 1764575708

Game/CourierOld/Assets/Code/Gameplay/Enemies/BaseEnemy.cs

@@ -1,8 +1,10 @@
+using Code.Audio;
 using UnityEngine;
 using UnityEngine.AI;
 using Code.Gameplay.Player;
 using Code.Gameplay.Character.Controller;
 using Code.Gameplay.Character.Core;
+using Code.Gameplay.Enemies.Animators;
 using Reflex.Attributes;
 using Reflex.Core;
 using Reflex.Injectors;
@@ -13,6 +15,7 @@ namespace Code.Gameplay.Enemies
     {
         [SerializeField] protected NavMeshAgent agent;
         [SerializeField] protected Collider enemyCollider; 
+        [Inject] protected IAudioService audioService;
         
         protected int Damage;
         protected float AttackCooldown;
@@ -35,7 +38,7 @@ namespace Code.Gameplay.Enemies
         private bool _isStunned;
         private float _currentStunTimer;
 
-        private bool _canAttack = true;
+        protected bool _canAttack = true;
         private float _attackCooldownTimer;
         
         private enum IdleState { Moving, Paused }
@@ -50,10 +53,11 @@ namespace Code.Gameplay.Enemies
 
         protected virtual void Awake()
         {
-            if (_playerProvider == null)
+            // // TODO Мешает
-            {
+            // if (_playerProvider == null)
-                AttributeInjector.Inject(this, Container.ProjectContainer);
+            // {
-            }
+            //     AttributeInjector.Inject(this, Container.ProjectContainer);
+            // } 
         }
 
         protected virtual void Update()
@@ -164,19 +168,19 @@ namespace Code.Gameplay.Enemies
         
         protected virtual void HandleAttackCooldown()
         {
-            if (!_canAttack)
+            if (_canAttack) return;
-            {
+            
             _attackCooldownTimer -= Time.deltaTime;
+            
             if (_attackCooldownTimer <= 0)
             {
                 _canAttack = true;
             }
         }
-        }
         
         protected virtual void DealDamage()
         {
-            if (!_canAttack || PlayerHealth == null) return;
+            if (PlayerHealth == null) return;
             
             PlayerHealth.GetDamage(Damage);
             ApplyEffectsToPlayer();
@@ -184,11 +188,10 @@ namespace Code.Gameplay.Enemies
             _canAttack = false;
             _attackCooldownTimer = AttackCooldown;
         }
-
         protected virtual void ApplyEffectsToPlayer()
         {
             if (PlayerController)
-                PlayerController.BlockAbilities(3f);
+                PlayerController.BlockAbilities(3f); // TODO в конфиг
         }
 
         private void OnDrawGizmosSelected()

Game/CourierOld/Assets/Code/Gameplay/Enemies/Cockroach.cs

@@ -1,3 +1,4 @@
+using Code.Audio;
 using Code.Configs;
 using Reflex.Attributes;
 using UnityEngine;
@@ -35,7 +36,7 @@ namespace Code.Gameplay.Enemies
         {
             base.Awake();
             
-            if (agent == null) return;
+            if (!agent) return;
             
             var walkableArea = NavMesh.GetAreaFromName("Cockroach");
             agent.areaMask = 1 << walkableArea;
@@ -43,12 +44,14 @@ namespace Code.Gameplay.Enemies
         
         protected override void HandleAttack()
         {
-            if (!Player) return;
+            if (!Player || !_canAttack) return;
             
             var distance = Vector3.Distance(transform.position, Player.transform.position);
 
             if (!(distance <= AttackRange)) return;
             
+            audioService.PlayEnemy(EnemiesSounds.RoachAttack, agent.transform.position);
+            
             DealDamage();
         }
     }

Game/CourierOld/Assets/Code/Gameplay/Enemies/DrunkenGrandpa.cs

@@ -1,4 +1,6 @@
+using Code.Audio;
 using Code.Configs;
+using Code.Gameplay.Enemies.Animators;
 using Reflex.Attributes;
 using UnityEngine;
 using UnityEngine.AI;
@@ -40,16 +42,17 @@ namespace Code.Gameplay.Enemies
             var walkableArea = NavMesh.GetAreaFromName("Walkable");
             agent.areaMask = 1 << walkableArea; 
         }
-        
         protected override void HandleAttack()
         {
-            if (!Player) return;
+            if (!Player || !_canAttack) return;
             
             var distance = Vector3.Distance(transform.position, Player.transform.position);
             
             if (!(distance <= AttackRange)) return;
             
-            if (Player.CustomCharacterController.IsSliding)
+            audioService.PlayEnemy(EnemiesSounds.GrandpaAttack,agent.transform.position);
+            
+            if (Player.CustomCharacterController.IsDashing || Player.CustomCharacterController.IsSliding)
                 ApplyStun();
             else
                 DealDamage();

Game/CourierOld/Assets/Code/Gameplay/Enemies/EnemyAudio.cs

@@ -0,0 +1,34 @@
+using Code.Audio;
+using Reflex.Attributes;
+using UnityEngine;
+
+namespace Code.Gameplay.Enemies
+{
+    public class EnemyAudio : MonoBehaviour
+    {
+        private IAudioService _audioService;
+        private IAudioFactory _audioFactory;
+        [SerializeField] private AudioSource _audioSource;
+        [SerializeField] private EnemiesSounds stepId;
+
+        [Inject]
+        private void Construct(IAudioService audioService, IAudioFactory audioFactory)
+        {
+            _audioService = audioService;
+            _audioSource = audioService.GetSourceOfGroup(Audio.AudioType.Enemies);
+            _audioSource.transform.position = transform.position;
+            _audioSource.spatialBlend = 0; 
+            _audioFactory = audioFactory;
+        }
+
+        public void PlayStep()
+        {
+            _audioSource.transform.position = transform.position;
+            _audioSource.PlayOneShot(_audioFactory.EnemiesAudios[(int)stepId]);
+        }
+        private void OnDestroy()
+        {
+            _audioService.ReleaseSourceOfGroup(_audioSource);
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Enemies/EnemyAudio.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 91cb250df1b24fc4825ee791a12dda11
+timeCreated: 1764695102

Game/CourierOld/Assets/Code/Gameplay/Enemies/EnemyFactory.cs

@@ -3,9 +3,11 @@ using Code.Configs;
 using Cysharp.Threading.Tasks;
 using Reflex.Attributes;
 using Reflex.Core;
+using Reflex.Extensions;
 using Reflex.Injectors;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
+using UnityEngine.SceneManagement;
 
 namespace Code.Gameplay.Enemies
 {
@@ -27,14 +29,14 @@ namespace Code.Gameplay.Enemies
                 )
                 .ToUniTask();
 
-            AttributeInjector.Inject(enemyObj, Container.ProjectContainer);
+            GameObjectInjector.InjectRecursive(enemyObj, SceneManager.GetActiveScene().GetSceneContainer());
     
             return enemyObj.GetComponent<BaseEnemy>();
         }
 
         public void ReleaseEnemy(BaseEnemy enemy)
         {
-            if (enemy == null) return;
+            if (!enemy) return;
     
             enemy.gameObject.SetActive(false);
             

Game/CourierOld/Assets/Code/Gameplay/Enemies/EnemySpawner.cs

@@ -1,8 +1,6 @@
 using Code.Gameplay.Player;
 using Cysharp.Threading.Tasks;
 using Reflex.Attributes; 
-using Reflex.Core;
-using Reflex.Injectors;
 using UnityEngine;
 
 namespace Code.Gameplay.Enemies
@@ -20,13 +18,14 @@ namespace Code.Gameplay.Enemies
         private bool _isSpawning;
         private bool _isPlayerInRange;
 
-        private void Awake()
+        // GameObjectSelfInjector существует
-        {
+        // private void Awake()
-            if (_playerProvider == null || _enemyFactory == null)
+        // {
-            {
+        //     if (_playerProvider == null || _enemyFactory == null)
-                AttributeInjector.Inject(this, Container.ProjectContainer);
+        //     {
-            }
+        //         AttributeInjector.Inject(this, Container.ProjectContainer);
-        }
+        //     }
+        // }
 
         private void Update()
         {
@@ -64,9 +63,14 @@ namespace Code.Gameplay.Enemies
             _isSpawning = false;
         }
 
+        private void OnDestroy()
+        {
+            Despawn();
+        }
+
         private void Despawn()
         {
-            if (_spawnedEnemy == null) return;
+            if (!_spawnedEnemy) return;
 
             _enemyFactory.ReleaseEnemy(_spawnedEnemy);
             _spawnedEnemy = null;

Game/CourierOld/Assets/Code/Gameplay/Player/PlayerAudio.cs

@@ -0,0 +1,32 @@
+using Code.Audio; 
+using Reflex.Attributes;
+using UnityEngine;
+using AudioType = Code.Audio.AudioType;
+
+namespace Code.Gameplay.Player
+{
+    public class PlayerAudio : MonoBehaviour
+    {
+        private IAudioService _audioService;
+        private IAudioFactory _audioFactory;
+        private AudioSource _audioSource;
+
+        [Inject]
+        private void Construct(IAudioService audioService, IAudioFactory audioFactory)
+        {
+            _audioService = audioService;
+            _audioSource = audioService.GetSourceOfGroup(AudioType.Courier);
+            
+            _audioFactory = audioFactory;
+        }
+
+        public void PlayStep()
+        {
+            _audioSource.PlayOneShot(_audioFactory.CourierAudios[(int)CourierSounds.Step]);
+        }
+        private void OnDestroy()
+        {
+            _audioService.ReleaseSourceOfGroup(_audioSource);
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Player/PlayerAudio.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 64f99dccce9d41df98accae0f355dbca
+timeCreated: 1764584350

Game/CourierOld/Assets/Code/Gameplay/Player/PlayerFactory.cs

@@ -42,7 +42,13 @@ namespace Code.Gameplay.Player
             Addressables.ReleaseInstance(characterProvider.gameObject);
         }
 
-        public async UniTask<ArmsMeshProvider> CreateArms(Transform papochka) => (await Addressables.InstantiateAsync(_playerConfig.armsMeshPrefab, papochka).ToUniTask()).GetComponent<ArmsMeshProvider>();
+        public async UniTask<ArmsMeshProvider> CreateArms(Transform papochka) 
+        {
+            var armsMesh = (await Addressables.InstantiateAsync(_playerConfig.armsMeshPrefab, papochka).ToUniTask());
+            GameObjectInjector.InjectRecursive(armsMesh, Container.ProjectContainer);
+            
+            return armsMesh.GetComponent<ArmsMeshProvider>();
+        }
         public void ReleaseArms(ArmsMeshProvider arms) => Addressables.ReleaseInstance(arms.gameObject);
     }
 }

Game/CourierOld/Assets/Code/Generator/IRoomGeneratorFactory.cs

@@ -12,5 +12,6 @@ namespace Code.Generator
          Room CreateRoomByIndex(int index, RoomType roomType); 
         void ReleaseRooms();
         GameObject GetRandomCachedPrefabOfType(RoomType roomType, out int index);
+        int GetRandomIndexOfType(RoomType roomType);
     }
 }

Game/CourierOld/Assets/Code/Generator/Room.cs

@@ -1,11 +1,12 @@
 using System;
 using Code.Gameplay.Door;
+using Code.Gameplay.Orders.Order;
 using Code.UI;
 using UnityEngine;
 
 namespace Code.Generator
 { 
-    [RequireComponent(typeof(Transform))]
+    // Для написания нормальной системы комнат нужен другой подход в корне, это уже не исправить, только залатать большие дыры
     public class Room : MonoBehaviour
     {
         [SerializeField] protected RoomType roomType;
@@ -15,19 +16,17 @@ namespace Code.Generator
         [SerializeField] protected Transform enterMarker;
         public Transform EnterMarker => enterMarker;
         [SerializeField] protected Transform exitMarker;
+        [SerializeField] protected Transform doorSlot;
         public Transform ExitMarker => exitMarker;
         [SerializeField] protected Door door;
            
-        protected void Awake()
+        public void Initialize(IOrderService orderService)
         {
-            if (EnterMarker == null || ExitMarker == null)
+            door.TranslationMode(false);
-            {
-                Debug.LogError($"Але маркеры не найдены у комнаты {gameObject.name}");
-            }
-        }
             
-        public void Initialize() => door.TranslationMode(false);
+            if(roomTrigger) roomTrigger.OrderService = orderService; 
-
+        }
-        //PIZDEC
+        public void Seal() => door.CloseTheDoor();
+        [SerializeField] public RoomTrigger roomTrigger;
     }
 }

Game/CourierOld/Assets/Code/Generator/RoomGenerator.cs

@@ -2,7 +2,6 @@ using System.Collections.Generic;
 using Code.Gameplay.Orders.Order;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments; 
-using Cysharp.Threading.Tasks;
 using Reflex.Attributes;
 using UnityEngine;
 
@@ -36,43 +35,22 @@ namespace Code.Generator
 
         public void Initialize()
         {
-            // _orderService.OrderGive();
-
             _spawnedRooms = new List<Room>();
             _roomIndexesStack = new();
 
-            Debug.LogWarning($"КОТЛЫ ГЕНЕРАЛЬСКИЕ{_orderService.DeliveryTimer}");
-
-            // CreateRoomsStack();
-
-            // SpawnInitialRoomsAsync();
             _orderService.OnOrderGiven += CreateRoomsStack;
-            RoomTrigger.PlayerEnteredRoom += OnPlayerEntered;
-
             CreateInitialRoom(); 
-            SpawnNextRoomAsync();
         }
 
-        private void OnEnable()
+        private void OnPlayerEntered()
         {
-            RoomTrigger.PlayerEnteredRoom += OnPlayerEntered;
+            SpawnNextRoom();
-        }
-
-        private void OnDisable()
-        {
-            RoomTrigger.PlayerEnteredRoom -= OnPlayerEntered;
-        }
-
-        public void OnPlayerEntered()
-        {
-            SpawnNextRoomAsync();
 
             if (_spawnedRooms.Count > 3)
             {
                 Room roomToRemove = _spawnedRooms[0];
                 _spawnedRooms.RemoveAt(0);
 
-                // _factory.ReleaseRoom(roomToRemove);
                 Object.Destroy(roomToRemove.gameObject);
             }
         }
@@ -92,24 +70,29 @@ namespace Code.Generator
 
                 _roomIndexesStack.Add(new(RoomType.Basic, roomIndex));
                 remainingTime -= room.RoomTimer;
-                Debug.Log($"комната {room.name} время {room.RoomTimer} осталось: {remainingTime}");
             }
             
-            CreateSaveRoom();
-
             AddPickupRoom();
             
-            Debug.Log($"стек комнат: {_roomIndexesStack.Count}");
+            AddSaveRoom();
-            SpawnNextRoomAsync();
+             
+            SpawnNextRoom();
         }
 
-        private void CreateSaveRoom()
+        private void AddSaveRoom()
         {
-            var prefab = _factory.GetRandomCachedPrefabOfType(RoomType.Save, out int roomIndex);
+            int saveRoomIndex = _factory.GetRandomIndexOfType(RoomType.Save); 
-            Room saveRoom = prefab.GetComponent<Room>();
-            _roomIndexesStack.Add(new(RoomType.Save, roomIndex));
             
-            Debug.Log($"Первая комната: {saveRoom.name}");
+            _roomIndexesStack.Add(new(RoomType.Save, saveRoomIndex));
+        } 
+        
+        private void AddPickupRoom()
+        {
+            int pickupIndex = _factory.GetRandomIndexOfType(RoomType.PickUp);
+
+            int insertPos = Random.Range(1, _roomIndexesStack.Count + 1);
+
+            _roomIndexesStack.Insert(insertPos, new(RoomType.PickUp, pickupIndex)); 
         }
 
         [Inject] private CurrentSceneEnvironment _currentSceneEnvironment;
@@ -118,19 +101,17 @@ namespace Code.Generator
         {
             GameplaySceneEnvironment gameplaySceneEnvironment = (GameplaySceneEnvironment)_currentSceneEnvironment;
             
-            _factory.GetRandomCachedPrefabOfType(RoomType.Initial, out int roomIndex); 
+            int roomIndex = _factory.GetRandomIndexOfType(RoomType.Initial); 
-            // _roomIndexesStack.Add(new(RoomType.Initial, roomIndex));
+            
             InitialRoom instantiated = _factory.CreateRoomByIndex(roomIndex, RoomType.Initial).GetComponent<InitialRoom>();
             _spawnedRooms.Add(instantiated);
             instantiated.transform.position = Vector3.zero;
             instantiated.transform.rotation = Quaternion.identity;
             
             gameplaySceneEnvironment.playerSpawnPoint = instantiated.playerSpawn;
-            instantiated.Initialize();
+            instantiated.Initialize(_orderService);
-            
-            Debug.Log($"Первая комната: {instantiated.name}");
         } 
-        private void SpawnNextRoomAsync()
+        private void SpawnNextRoom()
         {
             if (_nextRoomStackIndex >= _roomIndexesStack.Count)
                 return;
@@ -149,23 +130,14 @@ namespace Code.Generator
                 PlaceRoom(room, previousRoom);
             }
 
+            // Отписываться можно, но Хатико никогда не дождётся вызова уничтоженного объекта.
+            room.roomTrigger.OnEnter += OnPlayerEntered;
+            
+            room.roomTrigger.OnExit += _spawnedRooms[^1].Seal;
             _spawnedRooms.Add(room);
             _nextRoomStackIndex++;
         }
 
-        private void AddPickupRoom()
-        {
-            var prefab = _factory.GetRandomCachedPrefabOfType(RoomType.PickUp, out int pickupIndex);
-
-            Room pickupRoom = prefab.GetComponent<Room>();
-
-            if (_roomIndexesStack.Count == 0) return;
-
-            int insertPos = Random.Range(1, _roomIndexesStack.Count + 1);
-
-            _roomIndexesStack.Insert(insertPos, new(RoomType.PickUp, pickupIndex)); 
-        }
-
 
         private void PlaceRoom(Room current, Room previous)
         {
@@ -217,17 +189,7 @@ namespace Code.Generator
             segmentOriginPosition.y -= randomDoorOriginPosition.y;
             current.transform.position = segmentOriginPosition;
             current.transform.rotation = Quaternion.Euler(0, segmentOriginYRotation, 0); 
-            // locationSegment.isNeedSomeDoors = true;
+            current.Initialize(_orderService); 
-            // locationSegment.AddBadDoorId(locationSegment.LocationSegment.GetDoorOrigins.IndexOf(randomDoorOrigin));
-            current.Initialize();
-
-            float frameOnTheBallRotation = segmentOriginYRotation + randomDoorOriginRotation.eulerAngles.y;
-            if (frameOnTheBallRotation > 305f) frameOnTheBallRotation -= 360f;
-            else if (frameOnTheBallRotation < -45f) frameOnTheBallRotation += 360f;
-
-            // heOnTheBall.AddSlaveLocationSegment(locationSegment.Id);
-            // heOnTheBall.ReplaceSlaveSegmentDoorOriginYRotation(frameOnTheBallRotation);
-            // heOnTheBall.isGotOnTheBall = false;
         }
     }
 }

Game/CourierOld/Assets/Code/Generator/RoomGeneratorFactory.cs

@@ -59,6 +59,7 @@ namespace Code.Generator
             index = Random.Range(0, _cashedRooms[roomType].Count);
             return _cashedRooms[roomType][index];
         }
+        public int GetRandomIndexOfType(RoomType roomType) => Random.Range(0, _cashedRooms[roomType].Count);
 
         public Room CreateRoomByIndex(int index, RoomType roomType)
         { 

Game/CourierOld/Assets/Code/Generator/RoomTrigger.cs

@@ -1,32 +1,36 @@
 using System;
 using Code.Gameplay.Orders.Order;
-using Reflex.Attributes;
 using UnityEngine;
 
 namespace Code.Generator
 {
     public class RoomTrigger : MonoBehaviour
     {
-        [Inject] private IOrderService _orderService;
+        public IOrderService OrderService;
+        public event Action OnEnter;
+        public event Action OnExit;
         
-        public static event Action PlayerEnteredRoom;
+        private bool _playerEntered, _playerExited;
  
-        private bool _playerEntered;
-
-        // [Inject]
-        // private void Construct(IOrderService orderService)
-        // {
-        //     _orderService = orderService;
-        // }
         private void OnTriggerEnter(Collider other)
         {
             if (_playerEntered) return;
             
             _playerEntered = true;
 
-            _orderService.RoomPassed();
+            OrderService.RoomPassed();
             
-            PlayerEnteredRoom?.Invoke();
+            OnEnter?.Invoke();
+        }
+        private void OnTriggerExit(Collider other)
+        {
+            if (_playerExited) return;
+            
+            Debug.Log(other.name);
+
+            _playerExited = true;
+
+            OnExit?.Invoke();
         }
     }
 }

Game/CourierOld/Assets/Code/Generator/RoomTrigger.cs.meta

@@ -1,3 +1,3 @@
 fileFormatVersion: 2
-guid: 4207b7568dc3482393ac1860a31909b4
+guid: 0d6940d73d544f0a8e4a45d956bc2364
-timeCreated: 1764087485
+timeCreated: 1764525516

Game/CourierOld/Assets/Code/Input/IInputService.cs

@@ -16,8 +16,8 @@ namespace Code.Input
         // Для управления движением персонажа
         Vector2 MoveInput { get; }
         bool JumpPressed { get; }
-        bool SprintPressed { get; }
         bool SlidePressed { get; }
+        bool DashPressed { get; }
         
         // Для переключения режима камеры
         bool ToggleCameraModePressed { get; }

Game/CourierOld/Assets/Code/Input/InputService.cs

@@ -13,8 +13,8 @@ namespace Code.Input
         public float ZoomInput { get; private set; }
         public Vector2 MoveInput { get; private set; }
         public bool JumpPressed { get; private set; }
-        public bool SprintPressed { get; private set; }
         public bool SlidePressed { get; private set; }
+        public bool DashPressed { get; private set; }
         public bool ToggleCameraModePressed { get; private set; }
         
         public InputService(InputActionAsset inputActionAsset)
@@ -69,14 +69,6 @@ namespace Code.Input
                 jumpAction.canceled += OnJumpCanceled;
             }
             
-            // Обработка спринта (персонаж)
-            var sprintAction = gameplayMap.FindAction("Sprint");
-            if (sprintAction != null)
-            {
-                sprintAction.performed += OnSprintPerformed;
-                sprintAction.canceled += OnSprintCanceled;
-            }
-            
             // Обработка слайда (персонаж)
             var slideAction = gameplayMap.FindAction("Slide");
             if (slideAction != null)
@@ -85,6 +77,14 @@ namespace Code.Input
                 slideAction.canceled += OnSlideCanceled;
             }
             
+            // Обработка слайда (персонаж)
+            var dashAction = gameplayMap.FindAction("Dash");
+            if (dashAction != null)
+            {
+                dashAction.performed += OnDashPerformed;
+                dashAction.canceled += OnDashCanceled;
+            }
+            
             // Обработка переключения режима камеры
             var toggleCameraModeAction = gameplayMap.FindAction("ToggleCameraMode");
             if (toggleCameraModeAction != null)
@@ -134,16 +134,6 @@ namespace Code.Input
             JumpPressed = false;
         }
 
-        private void OnSprintPerformed(InputAction.CallbackContext context)
-        {
-            SprintPressed = true;
-        }
-
-        private void OnSprintCanceled(InputAction.CallbackContext context)
-        {
-            SprintPressed = false;
-        }
-
         private void OnSlidePerformed(InputAction.CallbackContext context)
         {
             SlidePressed = true;
@@ -154,6 +144,16 @@ namespace Code.Input
             SlidePressed = false;
         }
         
+        private void OnDashPerformed(InputAction.CallbackContext context)
+        {
+            DashPressed = true;
+        }
+
+        private void OnDashCanceled(InputAction.CallbackContext context)
+        {
+            DashPressed = false;
+        }
+        
         private void OnToggleCameraModePerformed(InputAction.CallbackContext context)
         {
             ToggleCameraModePressed = true;
@@ -189,12 +189,12 @@ namespace Code.Input
             gameplayMap.FindAction("Jump").performed -= OnJumpPerformed;
             gameplayMap.FindAction("Jump").canceled -= OnJumpCanceled;
             
-            gameplayMap.FindAction("Sprint").performed -= OnSprintPerformed;
-            gameplayMap.FindAction("Sprint").canceled -= OnSprintCanceled;
-            
             gameplayMap.FindAction("Slide").performed -= OnSlidePerformed;
             gameplayMap.FindAction("Slide").canceled -= OnSlideCanceled;
             
+            gameplayMap.FindAction("Dash").performed -= OnDashPerformed;
+            gameplayMap.FindAction("Dash").canceled -= OnDashCanceled;
+            
             gameplayMap.FindAction("ToggleCameraMode").performed -= OnToggleCameraModePerformed;
             gameplayMap.FindAction("ToggleCameraMode").canceled -= OnToggleCameraModeCanceled;
         }

Game/CourierOld/Assets/Code/Scenes/SceneEnvironments/GameplaySceneEnvironment.cs

@@ -1,5 +1,6 @@
 using Code.Gameplay.Orders.Order;
 using UnityEngine;
+using UnityEngine.Rendering;
 using UnityEngine.Serialization;
 
 namespace Code.Scenes.SceneEnvironments
@@ -8,10 +9,12 @@ namespace Code.Scenes.SceneEnvironments
     public class GameplaySceneEnvironment : CurrentSceneEnvironment
     {
         public Transform playerSpawnPoint;
+        public Volume volume;
 
         public void TransitVariables(GameplaySceneEnvironment env)
         {
             playerSpawnPoint = env.playerSpawnPoint; 
+            volume = env.volume;
         }
     }
 }

Game/CourierOld/Assets/Code/StaticData/IStaticDataService.cs

@@ -33,6 +33,8 @@ namespace Code.StaticData
         Dictionary<AudioSourceType, AudioSourceSettingsConfig> AudioSourceSettingsConfigs { get; }
         AudioTestClipsConfig AudioTestClipsConfig { get; }
         GeneratorConfig GeneratorConfig { get; }
+        CourierSoundListConfig CourierSoundListConfig { get; }
+        DefaultAudioSettingsConfig DefaultAudioSettingsConfig { get; }
         void Load();
         Task<T> InstantiateAsset<T>(AssetReference assetReference) where T : Behaviour;
     }

Game/CourierOld/Assets/Code/StaticData/StaticDataService.cs

@@ -29,6 +29,8 @@ namespace Code.StaticData
         public DispatcherSoundListConfig DispatcherSoundListConfig { get; private set; }
         public EnemiesSoundListConfig EnemiesSoundListConfig { get; private set; }
         public AudioTestClipsConfig AudioTestClipsConfig { get; private set; }
+        public CourierSoundListConfig CourierSoundListConfig { get; private set; }
+        public DefaultAudioSettingsConfig DefaultAudioSettingsConfig { get; private set; }
         
         public DrunkenGrandpaConfig DrunkenGrandpaConfig {get; private set;}
         public CockroachConfig CockroachConfig { get; private set; }
@@ -66,9 +68,11 @@ namespace Code.StaticData
         private void LoadAudioConfigs()
         {
             AudioMixerConfig = Resources.Load<AudioMixerConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "AudioMixerConfig"));
+            DefaultAudioSettingsConfig = Resources.Load<DefaultAudioSettingsConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "DefaultAudioSettingsConfig"));
             SoundtrackListConfig = Resources.Load<SoundtrackListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "SoundtrackListConfig"));
             AudioTestClipsConfig = Resources.Load<AudioTestClipsConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "AudioTestClipsConfig"));
             SFXListConfig = Resources.Load<SFXListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "SFXListConfig"));
+            CourierSoundListConfig = Resources.Load<CourierSoundListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "CourierSoundListConfig"));
             DispatcherSoundListConfig = Resources.Load<DispatcherSoundListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "DispatcherSoundListConfig"));
             EnemiesSoundListConfig = Resources.Load<EnemiesSoundListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "EnemiesSoundListConfig"));
             AudioSourceSettingsConfigs = Resources

Game/CourierOld/Assets/Code/UI/Panels/DamagePanel.cs

@@ -0,0 +1,25 @@
+using DG.Tweening;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Code.UI.Panels
+{
+    public class DamagePanel : UIElement
+    {
+        [SerializeField] private Image background;
+        [SerializeField] private Color shownColor;
+        [SerializeField] private Color hiddenColor;
+        public override void Hide()
+        {
+            Shown = false;
+            // background.enabled = false;
+            background.DOColor(hiddenColor, 2f);
+        }
+        public override void Show()
+        {
+            Shown = true;
+            // background.enabled = true;
+            background.DOColor(shownColor, 0.3f);   
+        }
+    }
+}

Game/CourierOld/Assets/Code/UI/Panels/DamagePanel.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b586dbc292c44261892460f578a38e50
+timeCreated: 1764769541

Game/CourierOld/Assets/Code/UI/Panels/GameOverPanel.cs

@@ -1,3 +1,4 @@
+using DG.Tweening;
 using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
@@ -9,21 +10,27 @@ namespace Code.UI
         [SerializeField] private TMP_Text scoreText;
         [SerializeField] private TMP_Text gameOverText;
         [SerializeField] private Image _background;
+        [SerializeField] private Color shownColor;
+        [SerializeField] private Color hiddenColor;
         
         public void UpdateScoreText(int score) => scoreText.text = score.ToString();
         
         public override void Hide()
         {
             _background.enabled = false;
-            scoreText.enabled = false;
+            // scoreText.enabled = true;
-            gameOverText.enabled = false;
+            // gameOverText.enabled = false;
+            scoreText.DOColor(hiddenColor, 3f);
+            // gameOverText.DOColor(hiddenColor, 3f);
             base.Hide();
         }
         public override void Show()
         {
-            _background.enabled = true;
+            // _background.enabled = true;
-            scoreText.enabled = true;
+            // scoreText.enabled = true;
-            gameOverText.enabled = true;
+            // gameOverText.enabled = true;
+            scoreText.DOColor(shownColor, 5f);
+            // gameOverText.DOColor(shownColor, 5f);
             base.Show();
         }
     }

Game/CourierOld/Assets/Code/UI/Panels/GameplayPanel.cs

@@ -26,6 +26,9 @@ namespace Code.UI.Panels
         [Header("MoneyBar")]
         [SerializeField] private TMP_Text moneyText;
         
+        [SerializeField] private DamagePanel damagePanel;
+        public DamagePanel DamagePanel => damagePanel;
+        
         private void ScoreUpdate(int count, int money) 
         {
             // TODO Анимация получения\потери

Game/CourierOld/Assets/Code/UI/Panels/LoadingScreen.cs

@@ -7,21 +7,24 @@ namespace Code.UI.Panels
     public class LoadingScreen : UIElement
     {
         [SerializeField] private Image background;
-        [SerializeField] private TMP_Text loadingTitle;
+        [SerializeField] private Image loadingImage;
-        [SerializeField] private TMP_Text vyapWatermark;
+        // [SerializeField] private TMP_Text loadingTitle;
+        // [SerializeField] private TMP_Text vyapWatermark;
         public override void Hide()
         {
             Shown = false;
             background.enabled = false;
-            loadingTitle.enabled = false;
+            loadingImage.enabled = false;
-            vyapWatermark.enabled = false;
+            // loadingTitle.enabled = false;
+            // vyapWatermark.enabled = false;
         }
         public override void Show()
         {
             Shown = true;
             background.enabled = true;
-            loadingTitle.enabled = true;
+            loadingImage.enabled = true;
-            vyapWatermark.enabled = true;
+            // loadingTitle.enabled = true;
+            // vyapWatermark.enabled = true;
         }
     }
 }

Game/CourierOld/Assets/Code/UI/Panels/SettingsPanel.cs

@@ -14,6 +14,7 @@ namespace Code.UI
         [SerializeField] private Slider master;
         [SerializeField] private Slider sfx;
         [SerializeField] private Slider dispatcher;
+        [SerializeField] private Slider courier;
         [SerializeField] private Slider creatures;
         [SerializeField] private Slider menuMusic;
         [SerializeField] private Slider gameplayMusic; 
@@ -28,16 +29,19 @@ namespace Code.UI
             sfx.value = _audioService.GetSetting(AudioType.SFX);
             sfx.onValueChanged.AddListener(OnSFXUpdate);
             
-            dispatcher.value = _audioService.GetSetting(AudioType.DispatcherSounds);
+            dispatcher.value = _audioService.GetSetting(AudioType.Dispatcher);
             dispatcher.onValueChanged.AddListener(OnDispatcherUpdate);
             
-            creatures.value = _audioService.GetSetting(AudioType.Creatures);
+            courier.value = _audioService.GetSetting(AudioType.Courier);
+            courier.onValueChanged.AddListener(OnCourierUpdate);
+            
+            creatures.value = _audioService.GetSetting(AudioType.Enemies);
             creatures.onValueChanged.AddListener(OnEnemiesUpdate);
             
             menuMusic.value = _audioService.GetSetting(AudioType.MenuMusic);
             menuMusic.onValueChanged.AddListener(OnMenuMusicUpdate);
             
-            gameplayMusic.value = _audioService.GetSetting(AudioType.GameplayMusic);
+            gameplayMusic.value = _audioService.GetSetting(AudioType.ActionMusic);
             gameplayMusic.onValueChanged.AddListener(OnGameplayUpdate); 
         }
 
@@ -51,25 +55,32 @@ namespace Code.UI
             _audioService.ChangeSetting(AudioType.SFX, value);
             _audioService.PlayTestClip(AudioType.SFX);
         } 
+        private void OnCourierUpdate(float value)
+        {
+            _audioService.ChangeSetting(AudioType.Courier, value);
+            _audioService.PlayTestClip(AudioType.Courier);
+        } 
         private void OnDispatcherUpdate(float value)
         {
-            _audioService.ChangeSetting(AudioType.DispatcherSounds, value);
+            _audioService.ChangeSetting(AudioType.Dispatcher, value);
-            _audioService.PlayTestClip(AudioType.DispatcherSounds);
+            _audioService.PlayTestClip(AudioType.Dispatcher);
         } 
         private void OnEnemiesUpdate(float value)
         {
-            _audioService.ChangeSetting(AudioType.Creatures, value);
+            _audioService.ChangeSetting(AudioType.Enemies, value);
-            _audioService.PlayTestClip(AudioType.Creatures);
+            _audioService.PlayTestClip(AudioType.Enemies);
         } 
         private void OnMenuMusicUpdate(float value)
         {
             _audioService.ChangeSetting(AudioType.MenuMusic, value);
+            _audioService.ChangeSetting(AudioType.DeathMusic, value);
             _audioService.PlayTestClip(AudioType.MenuMusic);
         } 
         private void OnGameplayUpdate(float value)
         {
-            _audioService.ChangeSetting(AudioType.GameplayMusic, value);
+            _audioService.ChangeSetting(AudioType.ActionMusic, value);
-            _audioService.PlayTestClip(AudioType.GameplayMusic);
+            _audioService.ChangeSetting(AudioType.PeacefulMusic, value);
+            _audioService.PlayTestClip(AudioType.ActionMusic);
         }
 
         public override void Hide()

Game/CourierOld/Assets/Plugins.meta

@@ -1,5 +1,6 @@
 fileFormatVersion: 2
-guid: 20994ffe841c70949a3d2fd4c4a13d7a
+guid: 45b4aa0e7c33e934493bb7d2a15a9add
+folderAsset: yes
 DefaultImporter:
   externalObjects: {}
   userData: 

Game/CourierOld/Assets/Plugins/SerializedCollections.meta

@@ -1,5 +1,6 @@
 fileFormatVersion: 2
-guid: e16140ef864dd8845ad1f0f01c6e71e8
+guid: 767316a9a37abc34694c3086d846f668
+folderAsset: yes
 DefaultImporter:
   externalObjects: {}
   userData: 

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor.meta

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

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/AYellowpaper.SerializedCollections.Editor.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "AYellowpaper.SerializedCollections.Editor",
+    "references": [
+        "GUID:d525ad6bd40672747bde77962f1c401e"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/AYellowpaper.SerializedCollections.Editor.asmdef.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 234340c04eed5674a988bc6ebde7d248
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/AYellowpaper.SerializedCollections.Editor.asmdef
+  uploadId: 632226

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Assets.meta

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

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Assets/BurgerMenu@2x.png.meta

@@ -0,0 +1,177 @@
+fileFormatVersion: 2
+guid: 8deddfed9f39d7740879d2cb0fcf7ce0
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 8192
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 8192
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: iPhone
+    maxTextureSize: 8192
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Android
+    maxTextureSize: 8192
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 8192
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 8192
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 8192
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/Assets/BurgerMenu@2x.png
+  uploadId: 632226

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Assets/KeysGeneratorSelectorWindow.uss

@@ -0,0 +1,110 @@
+.sc-close-button {
+    background-image: resource('d_winbtn_win_close@2x');
+    width: 16px;
+    height: 16px;
+    position: absolute;
+    right: 2px;
+    top: 2px;
+    background-color: rgba(0, 0, 0, 0);
+    border-left-width: 0;
+    border-right-width: 0;
+    border-top-width: 0;
+    border-bottom-width: 0;
+}
+
+.sc-close-button:hover {
+    background-color: rgba(80, 80, 80, 255);
+}
+
+.sc-close-button:active {
+    background-color: rgba(0, 0, 0, 0);
+}
+
+.sc-text-toggle {
+    margin: 0;
+    padding: 0;
+    justify-content: center;
+}
+
+.sc-text-toggle:checked {
+    -unity-font-style: bold;
+}
+
+.sc-text-toggle > Label {
+    min-width: auto;
+    width: 100%;
+    height: 100%;
+}
+
+.sc-text-toggle > .unity-radio-button__input {
+    display: none;
+}
+
+.sc-title {
+    background-color: rgba(40, 40, 40, 0.35);
+    padding-left: 4px;
+    padding-right: 3px;
+    padding-top: 3px;
+    padding-bottom: 3px;
+    border-left-color: rgb(25, 25, 25);
+    border-right-color: rgb(25, 25, 25);
+    border-top-color: rgb(25, 25, 25);
+    border-bottom-color: rgb(25, 25, 25);
+    border-bottom-width: 1px;
+    -unity-font-style: bold;
+}
+
+.sc-generator-toggle {
+    padding-left: 3px;
+    padding-right: 3px;
+    padding-top: 3px;
+    padding-bottom: 3px;
+}
+
+.sc-generator-toggle:hover {
+    background-color: rgb(48, 48, 48);
+}
+
+.sc-generator-toggle:checked {
+    background-color: rgb(77, 77, 77);
+}
+
+.sc-modification-toggle {
+    flex-basis: 100%;
+    flex-shrink: 1;
+    border-left-color: rgb(41, 41, 41);
+    border-right-color: rgb(41, 41, 41);
+    border-top-color: rgb(41, 41, 41);
+    border-bottom-color: rgb(41, 41, 41);
+    border-left-width: 1px;
+    border-right-width: 1px;
+    border-top-width: 1px;
+    border-bottom-width: 1px;
+    -unity-font-style: normal;
+    -unity-text-align: middle-center;
+    padding-left: 2px;
+    padding-right: 2px;
+    padding-top: 2px;
+    padding-bottom: 2px;
+}
+
+.sc-modification-toggle:hover {
+    background-color: rgb(70, 70, 70);
+}
+
+.sc-modification-toggle:checked {
+    background-color: rgb(80, 80, 80);
+}
+
+.sc-radio-button-group {
+    padding: 0;
+    margin: 0;
+}
+
+.sc-radio-button-group > Label {
+    display: none;
+}
+
+#generators-group {
+    flex-direction: column;
+}

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Assets/KeysGeneratorSelectorWindow.uss.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: df6c2ef835e40c94c976442569324029
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/Assets/KeysGeneratorSelectorWindow.uss
+  uploadId: 632226

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Assets/KeysGeneratorSelectorWindow.uxml

@@ -0,0 +1,26 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="False">
+    <Style src="project://database/Assets/Plugins/SerializedCollections/Editor/Assets/KeysGeneratorSelectorWindow.uss?fileID=7433441132597879392&amp;guid=df6c2ef835e40c94c976442569324029&amp;type=3#KeysGeneratorSelectorWindow" />
+    <ui:VisualElement style="flex-direction: row; flex-grow: 1; border-left-color: rgb(97, 97, 97); border-right-color: rgb(97, 97, 97); border-top-color: rgb(97, 97, 97); border-bottom-color: rgb(97, 97, 97); border-left-width: 2px; border-right-width: 2px; border-top-width: 2px; border-bottom-width: 2px;">
+        <ui:VisualElement name="LeftContent" style="flex-basis: 66%; border-left-color: rgb(25, 25, 25); border-right-color: rgb(25, 25, 25); border-top-color: rgb(25, 25, 25); border-bottom-color: rgb(25, 25, 25); border-right-width: 1px;">
+            <ui:Label text="Generators" display-tooltip-when-elided="true" class="sc-title" />
+            <ui:ScrollView scroll-deceleration-rate="0,135" elasticity="0,1" name="generators-content" style="flex-grow: 1;" />
+        </ui:VisualElement>
+        <ui:VisualElement name="RightContent" style="flex-basis: 100%;">
+            <ui:Label text="Inspector" display-tooltip-when-elided="true" class="sc-title" />
+            <ui:IMGUIContainer name="imgui-inspector" style="flex-grow: 1; margin-left: 4px; margin-right: 4px; margin-top: 4px; margin-bottom: 4px;" />
+            <ui:Label text="4 Elements " display-tooltip-when-elided="true" name="generated-count-label" style="padding-left: 2px; padding-right: 2px; padding-top: 2px; padding-bottom: 2px;" />
+            <ui:VisualElement style="flex-direction: row;">
+                <ui:RadioButtonGroup label="Radio Button Group" value="-1" name="modification-group" class="sc-radio-button-group" style="flex-grow: 1;">
+                    <ui:RadioButton label="Add" name="add-modification" tooltip="Add the generated missing keys to the target." class="sc-text-toggle sc-modification-toggle" />
+                    <ui:RadioButton label="Remove" name="remove-modification" tooltip="Remove the generated keys form the target." class="sc-text-toggle sc-modification-toggle" />
+                    <ui:RadioButton label="Confine" name="confine-modification" tooltip="Remove all keys that are not part of the generated keys from the target." class="sc-text-toggle sc-modification-toggle" />
+                </ui:RadioButtonGroup>
+            </ui:VisualElement>
+            <ui:VisualElement style="flex-direction: row;">
+                <ui:Label display-tooltip-when-elided="true" name="result-label" style="flex-grow: 1; -unity-text-align: middle-left; padding-left: 2px; padding-right: 2px; padding-top: 2px; padding-bottom: 2px;" />
+                <ui:Button text="Apply" display-tooltip-when-elided="true" name="apply-button" style="width: 100px;" />
+            </ui:VisualElement>
+        </ui:VisualElement>
+        <ui:Button display-tooltip-when-elided="true" class="sc-close-button" />
+    </ui:VisualElement>
+</ui:UXML>

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Assets/KeysGeneratorSelectorWindow.uxml.meta

@@ -0,0 +1,17 @@
+fileFormatVersion: 2
+guid: 681c8a924c8b1e14b9fe53bb7397ec3d
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/Assets/KeysGeneratorSelectorWindow.uxml
+  uploadId: 632226

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts.meta

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

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/Data.meta

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

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/Data/ElementData.cs

@@ -0,0 +1,23 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AYellowpaper.SerializedCollections.Editor.Data
+{
+    [System.Serializable]
+    internal class ElementData
+    {
+        [SerializeField]
+        private bool _isListToggleActive = false;
+
+        public ElementSettings Settings { get; }
+        public bool ShowAsList => Settings.HasListDrawerToggle && IsListToggleActive;
+        public bool IsListToggleActive { get => _isListToggleActive; set => _isListToggleActive = value; }
+        public DisplayType EffectiveDisplayType => ShowAsList ? DisplayType.List : Settings.DisplayType;
+
+        public ElementData(ElementSettings elementSettings)
+        {
+            Settings = elementSettings;
+        }
+    }
+}

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/Data/ElementData.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 650a80186cc93b54aa5627197c23ea6e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/Scripts/Data/ElementData.cs
+  uploadId: 632226

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/Data/ElementSettings.cs

@@ -0,0 +1,15 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AYellowpaper.SerializedCollections.Editor.Data
+{
+    public class ElementSettings
+    {
+        public const string DefaultName = "Not Set";
+
+        public string DisplayName { get; set; } = DefaultName;
+        public DisplayType DisplayType { get; set; } = DisplayType.PropertyNoLabel;
+        public bool HasListDrawerToggle { get; set; } = false;
+    }
+}

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/Data/ElementSettings.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 12edfc8006691b7498459540b832c5eb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/Scripts/Data/ElementSettings.cs
+  uploadId: 632226

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/Data/PropertyData.cs

@@ -0,0 +1,44 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AYellowpaper.SerializedCollections.Editor.Data
+{
+    [System.Serializable]
+    internal class PropertyData
+    {
+        [SerializeField]
+        private float _keyLabelWidth;
+        [SerializeField]
+        private ElementData _keyData;
+        [SerializeField]
+        private ElementData _valueData;
+        [SerializeField]
+        private bool _alwaysShowSearch = false;
+
+        public bool AlwaysShowSearch
+        {
+            get => _alwaysShowSearch;
+            set => _alwaysShowSearch = value;
+        }
+
+        public float KeyLabelWidth
+        {
+            get => _keyLabelWidth;
+            set => _keyLabelWidth = value;
+        }
+
+        public ElementData GetElementData(bool fieldType)
+        {
+            return fieldType == SCEditorUtility.KeyFlag ? _keyData : _valueData;
+        }
+
+        public PropertyData() : this(new ElementSettings(), new ElementSettings()) { }
+
+        public PropertyData(ElementSettings keySettings, ElementSettings valueSettings)
+        {
+            _keyData = new ElementData(keySettings);
+            _valueData = new ElementData(valueSettings);
+        }
+    }
+}

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/Data/PropertyData.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: ba2d792dfc6653e46bee7c027202acd3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/Scripts/Data/PropertyData.cs
+  uploadId: 632226

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/DisplayType.cs

@@ -0,0 +1,13 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AYellowpaper.SerializedCollections.Editor
+{
+    public enum DisplayType
+    {
+        Property,
+        PropertyNoLabel,
+        List
+    }
+}

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/DisplayType.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 37ee13dd67b545846b6b063923812943
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/Scripts/DisplayType.cs
+  uploadId: 632226

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/KeyListGenerators.meta

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

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/KeyListGenerators/Implementors.meta

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

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/KeyListGenerators/Implementors/EnumGenerator.cs

@@ -0,0 +1,15 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AYellowpaper.SerializedCollections.KeysGenerators
+{
+    [KeyListGenerator("Populate Enum", typeof(System.Enum), false)]
+    public class EnumGenerator : KeyListGenerator
+    {
+        public override IEnumerable GetKeys(System.Type type)
+        {
+            return System.Enum.GetValues(type);
+        }
+    }
+}

Game/CourierOld/Assets/Plugins/SerializedCollections/Editor/Scripts/KeyListGenerators/Implementors/EnumGenerator.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: d639de5d36bbeea4496c97cc3f1f4e81
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 243052
+  packageName: Serialized Dictionary
+  packageVersion: 1.0.13
+  assetPath: Assets/Plugins/SerializedCollections/Editor/Scripts/KeyListGenerators/Implementors/EnumGenerator.cs
+  uploadId: 632226