Руки игрока

Работает как скрипт на emptyGameObject, через сериалайзы задаётся радиус спавна/деспавна и тип моба на спавн

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetSettings.asset

@@ -15,7 +15,7 @@ MonoBehaviour:
   m_DefaultGroup: d447fc60305c17a17bf20948ab295a45
   m_currentHash:
     serializedVersion: 2
-    Hash: adba03da8c5086ecbcf5b8db72996dd1
+    Hash: 00000000000000000000000000000000
   m_OptimizeCatalogSize: 0
   m_BuildRemoteCatalog: 0
   m_CatalogRequestsTimeout: 0

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

@@ -15,21 +15,28 @@ MonoBehaviour:
   m_GroupName: Default Local Group
   m_GUID: d447fc60305c17a17bf20948ab295a45
   m_SerializeEntries:
-  - m_GUID: 03e51c504fa7e0624ba855ec35b60bcc
-    m_Address: absolutely
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 111011400ce13ae859c52c757aef859e
-    m_Address: ahfreeman
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 144ab5188f8ad7a0a92c75703bd12e60
     m_Address: launch_upmenu1
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 16562a5c87213914cad415f10c65a3b0
+    m_Address: "Assets/Resources_moved/Audio/Music/LASKX3I - \u041F\u0440\u043E\u0442\u0438\u0432
+      \u0446\u0430\u0440\u044F (\u041A\u0430\u0440\u0430\u043E\u043A\u0435).mp3"
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 170b1a70ddee4d948abea041b9b805e4
+    m_Address: Assets/Resources_moved/Audio/Music/Half Life Original Soundtrack -
+      Track 8 - Diabolical Adrenaline Guitar.mp3
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 1d4767c722c05b5d6b96bb226d378c65
+    m_Address: Assets/Resources_moved/Prefabs/Player/ArmsMesh.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 1d7110a045075b22fa27d62bd5f2784e
     m_Address: 357_shot1
     m_ReadOnly: 0
@@ -40,11 +47,6 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 2301400160a23924eb27c4bdbe797739
-    m_Address: 'Audio/Music/Nightmargin (Oneshot OST) - The Prophecy '
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 23e11d2c8a4f12f4ea9a7a43d1118464
     m_Address: Gameplay
     m_ReadOnly: 0
@@ -61,7 +63,7 @@ MonoBehaviour:
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 2ed2d93a9f39d4edba511cb7396c7bb6
-    m_Address: Prefabs/Enemies/Cockroach
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/Cockroach.prefab
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -95,6 +97,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 751890caa1647ec6689f24933fbcb770
+    m_Address: "Prefabs/Furniture/\u0442\u0440\u0443\u0431\u0430"
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 7c5caf3ceee44f71588860c5c1fbdbe0
     m_Address: Audio/Dispatcher/take_damage3
     m_ReadOnly: 0
@@ -110,6 +117,12 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 8187ea542d6ed824d81230966a3b7499
+    m_Address: Assets/Resources_moved/Audio/Music/Bauhaus - Bela Lugosi's Dead (No
+      Vocals Remix).mp3
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 82c71411174bfa86ca1f676b9d389f94
     m_Address: bastard!
     m_ReadOnly: 0
@@ -135,18 +148,13 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: b2c9f83c47783069aabb564f68cb0cbb
-    m_Address: absolutelynot
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: b2e8dc2aeb0311cd8a826b51cf8e94dc
     m_Address: GameOver
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: b33855c694de89386a25c56cbe463a0e
-    m_Address: Prefabs/Enemies/DrunkenGrandpa
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/DrunkenGrandpa.prefab
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -171,12 +179,7 @@ MonoBehaviour:
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: f3d7dc64b34919ad7b50a3dd307a935b
-    m_Address: Prefabs/Enemies/Fog
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: f4b6fa54ecac6cc418f98824491aa17a
-    m_Address: Audio/Music/SANABI - JUSTICE Is Watching You
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/Fog.prefab
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0

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

@@ -1,41 +1,76 @@
-using Code.App.StateMachine;
-using Code.Scenes;
+using Code.App.StateMachine; 
+using Code.Gameplay.Player;
+using Code.Input;
 using Code.StateMachine;
 using Code.UI;
+using Cysharp.Threading.Tasks;
+using Reflex.Core;
+using Reflex.Extensions;
 using UnityEngine;
+using UnityEngine.InputSystem;
+using UnityEngine.SceneManagement;
 
 namespace Code.App.AppStates
 {
     public class GameOverState : BaseState<AppStateMachineContext>
     {
         public GameOverState(AppStateMachineContext context) : base(context)
-        { }
+        {
+        }
+        private IPlayerScore _playerScore;
+ 
+        private GameOverPanel _gameOverPanel;
 
-        private float damnTimer = 3f; // TODO Удалить при первой возможности
-        
         public override void EnterState()
         {
-            Context.UIService.SwitchPanelTo(UIPanel.GameOver);
+            Container sceneContainer = SceneManager.GetActiveScene().GetSceneContainer();
+            _playerScore = sceneContainer.Resolve<IPlayerScore>();
+            _scoreCounter = 0; 
+            
+            Context.InputService.EnableMap(ActionMappings.UI);
+            Context.InputService.DebugBindAction((int)ActionMappings.UI,(int)UIActions.Continue, TryToExit);
+            
+            GameOver();
             
             base.EnterState();
         }
-        
+
+        private void TryToExit(InputAction.CallbackContext context)
+        {
+            ToMainMenu();
+        }
+
+        private async UniTaskVoid GameOver()
+        {
+            await Context.UIService.AsyncSwitchPanelTo(UIPanel.GameOver);
+            
+            _gameOverPanel = (GameOverPanel)Context.UIService.CurrentPanel;
+            
+        }
+
         private void ToMainMenu()
         {
             Context.StateMachine.SwitchState(AppState.MainMenu)
                 .AllowStateTransition(AppState.Gameplay);
         }
-
+        private float _scoreCounter;
         public override void Tick()
         {
-            damnTimer -= Time.deltaTime;
-            if (damnTimer <= float.Epsilon) ToMainMenu();
+            if (!_gameOverPanel) return;
+            
+            _scoreCounter += Time.deltaTime * 100;
+            // UnityEngine.Debug.Log($"Score: {_scoreCounter}");
+            if((int)_scoreCounter >= _playerScore.Score)
+            {
+                _gameOverPanel.UpdateScoreText(_playerScore.Score);
+            }
+            else _gameOverPanel.UpdateScoreText((int)_scoreCounter);
         }
         public override void ExitState()
-        {
-            damnTimer = 5f;
+        { 
+            Context.InputService.DisableMap(ActionMappings.UI);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.UI,(int)UIActions.Continue, TryToExit);
             
-            Context.UIService.LoadingScreen.Show();
             base.ExitState();
         }
     }

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

@@ -1,15 +1,19 @@
+using Code.App.Loading;
 using Code.App.StateMachine;
 using Code.Audio;
 using Code.Gameplay.Camera;
 using Code.Gameplay.Camera.CameraStates;
 using Code.Gameplay.Character.Core;
+using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
 using Code.Input;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Code.StateMachine;
 using Code.UI;
+using Code.UI.Panels;
 using Cysharp.Threading.Tasks;
+using Reflex.Core;
 using Reflex.Extensions;
 using UnityEngine;
 using UnityEngine.InputSystem;
@@ -18,16 +22,13 @@ using UnityEngine.SceneManagement;
 namespace Code.App.AppStates
 {
     public class GameplayState : BaseState<AppStateMachineContext>
-    {
-        // DEBUG
-        private Transform _testSFXTransform;
-        // DEBUG
-        
+    { 
         private PlayerHealth _playerHealth;
-        private PlayerMoney _playerMoney;
+        private IPlayerScore _playerScore;
+        
+        private IOrderService _orderService;
 
         private CharacterProvider _playerCharacter;
-
         public GameplayState(AppStateMachineContext context) : base(context)
         {
         }
@@ -35,100 +36,146 @@ namespace Code.App.AppStates
         public override void EnterState()
         {
             Context.UIService.LoadingScreen.Show();
-            
-            _playerMoney = Context.PlayerFactory.CreatePlayerMoney();
 
-            //_playerHealth = Context.PlayerProvider.Health;
+            Context.LoadingManager
+                .RegisterLoading(LoadingWork.LoadScene)
+                .RegisterLoading(LoadingWork.LoadUI)
+                // .RegisterLoading(LoadingWork.LoadModelResource)
+                .RegisterLoading(LoadingWork.LoadAudio); 
+             
+            //_playerHealth = Context.PlayerFactory.CreatePlayerHealth();
+
+            //_playerHealth.OnDamage += PlayerDamageTaken;
             //_playerHealth.OnDeath += EndGame;
             
-            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Peaceful);
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.None);
             
             Context.InputService.EnableMap(ActionMappings.Gameplay);
             
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, GiveHealth);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug3, GiveMoney);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug2, LooseHealth);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, LooseMoney);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, PlayDebugSFX);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug6, PlayDebugDispatcher);
+            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.Debug5, Tube); 
+
+            Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.Gameplay);
+            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
-            WaitForSceneToLoad();
+            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();
 
-        private async UniTaskVoid WaitForSceneToLoad()
-        {
+        private async UniTaskVoid WaitForLoad()
+        { 
             await UniTask.WhenAll(
-                Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.Gameplay),
-                Context.UIService.AsyncSwitchPanelTo(UIPanel.Gameplay),
+                Context.UIService.AsyncSwitchPanelTo(UIPanel.Gameplay), 
                 Context.AudioFactory.WarmGameplayMusic(),
                 Context.AudioFactory.WarmSFX(),
-                WaitForPlayerCharacterLoad()
-            ); 
+                Context.AudioFactory.WarmDispatcher()
+            );
+
+            Context.LoadingManager 
+                .UnregisterLoading(LoadingWork.LoadUI) 
+                .UnregisterLoading(LoadingWork.LoadAudio);
+
+            InputServiceInitialize();
+
+            MusicInitialize();
+        }
+
+        private async void AfterSceneLoaded()
+        {
+            Context.LoadingManager 
+                .RegisterLoading(LoadingWork.LoadModelResource);
+            
+            Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
+            Context.LoadingManager.OnLoadingEnded += AfterPlayerLoaded;
+
+            await UniTask.WhenAll( 
+                WaitForPlayerArmsToInitialize(),
+                WaitForPlayerCharacterLoad() 
+            );
             
             _playerHealth = Context.PlayerProvider.Health;
+            _playerHealth.OnDamage += PlayerDamageTaken;
             _playerHealth.OnDeath += EndGame;
             
-            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Peaceful);
-            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Action);
-            
-            var sceneEnvironment = ((GameplaySceneEnvironment)SceneManager.GetActiveScene()
-                .GetSceneContainer().Resolve<CurrentSceneEnvironment>());
-
-            _testSFXTransform = sceneEnvironment.debugSfxTarget;
-            
-            _playerCharacter.Teleport(sceneEnvironment.playerSpawnPoint.position, sceneEnvironment.playerSpawnPoint.rotation);
-            
-            ((GameplayPanel)Context.UIService.CurrentPanel).Initialize(_playerMoney, _playerHealth);
-            
-            Context.CameraStateMachine.SwitchState(CameraMode.FirstPerson);
-            
-            ((BaseCameraState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(_playerCharacter.GetFollowTransform());
-            
-            Context.InputService.EnableMap(ActionMappings.Gameplay);
-            
-            Context.UIService.LoadingScreen.Hide();
+            Context.LoadingManager 
+                .UnregisterLoading(LoadingWork.LoadModelResource); 
         }
 
-        private void OnCharacterSpawn(CharacterProvider characterProvider)
+        private void AfterPlayerLoaded()
         {
-            ((BaseCameraState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(_playerCharacter.GetFollowTransform());
-        }
-        private void PlayDebugSFX(InputAction.CallbackContext context)
-        {
-            Context.AudioService.PlaySFX(SFXSounds.Crowbar, _testSFXTransform.position);
-        }
-        private void PlayDebugDispatcher(InputAction.CallbackContext context)
-        {
-            Context.AudioService.PlayDispatcher(DispatcherSounds.AhFreeman);
-        }
-        private void GiveHealth(InputAction.CallbackContext context)
-        {
-            _playerHealth.GetDamage(-1);
+            Container sceneContainer = SceneManager.GetActiveScene().GetSceneContainer(); 
+            
+            _playerScore = sceneContainer.Resolve<IPlayerScore>();
+            
+            GameplaySceneEnvironment sceneEnvironment = SceneEnvironmentVariables(sceneContainer);
+
+            PlayerInitialize(sceneEnvironment);
+            
+            CameraInitialize();
+
+            GameplayServicesInitialize(sceneContainer);
+            
+            UIInitialize();
+            
+            Context.LoadingManager.OnLoadingEnded -= AfterPlayerLoaded;
+            
+            _tickEnabled = true;
         }
 
-        private void LooseHealth(InputAction.CallbackContext context)
+        private async UniTask WaitForPlayerArmsToInitialize() => _armsMesh = await Context.PlayerFactory.CreateArms(Context.CameraStateMachine.Camera.transform);
+
+        private void OrderGiven(float time)
+        { 
+            _gameplayPanel.ShowTimer();
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Action);
+        }
+        private void OrderFailure()
         {
-            _playerHealth.GetDamage(1);
+            _playerHealth.InstaKill();
+        }
+        private void OrderRecieved(float time)
+        {
+            Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.Recieve1,(int)DispatcherSounds.Recieve2));
+        }
+        private void OrderDelivered(int score, float time)
+        { 
+            _gameplayPanel.HideTimer();
+
+            if(time < 0f) Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.Late1,(int)DispatcherSounds.Late2));
+            _playerScore.UpdateScore(score);
+            
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Peaceful);
         }
 
-        private void GiveMoney(InputAction.CallbackContext context)
+        private void PlayerDamageTaken(int damage, PlayerHealth health)
         {
-            _playerMoney.GiveMoney(100);
-            ((GameplayPanel)(Context.UIService.CurrentPanel)).SummonDispatcher();
-        }
-
-        private void LooseMoney(InputAction.CallbackContext context)
-        {
-            _playerMoney.LooseMoney(100);
-            ((GameplayPanel)(Context.UIService.CurrentPanel)).CloseDispatcher();
+            Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.TakeDamage1,(int)DispatcherSounds.TakeDamage4));
         }
         // DEBUG
+        private void InstaKillDEBUG(InputAction.CallbackContext context)
+        {
+            _playerHealth.InstaKill();
+        }
+        private void RoomPassedDEBUG(InputAction.CallbackContext context)
+        {
+            _orderService.RoomPassed();
+        }
+        private OrderDispenser _debugTube;
+
+        private void Tube(InputAction.CallbackContext context)
+        {
+            _debugTube.ThrowOrder();
+        }
+        // DEBUG
+        private bool _tickEnabled;
         public override void Tick()
         {
+            if (!_tickEnabled) return;
+            
+            _orderService.DecreaseTimer(Time.deltaTime);
         }
 
         private void EndGame()
@@ -140,23 +187,77 @@ namespace Code.App.AppStates
         public override void ExitState()
         {
             _playerHealth = null;
-            _playerMoney = null;
+            _playerScore = null;
+            
+            _tickEnabled = false;
             
             Context.PlayerFactory.ReleasePlayer(_playerCharacter);
             _playerCharacter = null;
+            Context.PlayerFactory.ReleaseArms(_armsMesh);
+            _armsMesh = null;
+            _orderService = null;
+            
+            Context.AudioService.OnDispatcherStarted -= _gameplayPanel.SummonDispatcher;
+            Context.AudioService.OnDispatcherEnded -= _gameplayPanel.CloseDispatcher;
             
             Context.InputService.DisableMap(ActionMappings.Gameplay);
             Context.AudioService.GladlyAskToStopMusic(MusicType.Action, callback: Context.AudioFactory.ReleaseActionMusic);
             Context.AudioService.GladlyAskToStopMusic(MusicType.Peaceful, callback: Context.AudioFactory.ReleasePeacefulMusic);
             
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, GiveHealth);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug3, GiveHealth);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug2, LooseHealth);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, LooseMoney);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, PlayDebugSFX);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug6, PlayDebugDispatcher);
+
+            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.Debug5, Tube);
             
             base.ExitState();
         }
+        
+        private void InputServiceInitialize()
+        {
+            Context.InputService.EnableMap(ActionMappings.Gameplay);
+        }
+        private void CameraInitialize()
+        {
+            Context.CameraStateMachine.SwitchState(CameraMode.FirstPerson);
+            ((BaseCameraState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(_playerCharacter.GetFollowTransform());
+        }
+
+        private GameplayPanel _gameplayPanel;
+        private ArmsMeshProvider _armsMesh;
+
+        private void UIInitialize()
+        {
+            _gameplayPanel = (GameplayPanel)Context.UIService.CurrentPanel;
+            _gameplayPanel.Initialize(_playerScore, _playerHealth, _orderService);
+            Context.AudioService.OnDispatcherStarted += _gameplayPanel.SummonDispatcher;
+            Context.AudioService.OnDispatcherEnded += _gameplayPanel.CloseDispatcher;
+        }
+        private void MusicInitialize()
+        {
+            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Peaceful);
+            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Action);
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Peaceful);
+        }
+        private void PlayerInitialize(GameplaySceneEnvironment sceneEnvironment)
+        {
+            _playerCharacter.Teleport(sceneEnvironment.playerSpawnPoint.position, sceneEnvironment.playerSpawnPoint.rotation);
+            _playerCharacter.PlayerAnimator.SetAnimator(_armsMesh.ArmsAnimator);
+        }
+        private void GameplayServicesInitialize(Container sceneContainer)
+        { 
+            _orderService = sceneContainer.Resolve<IOrderService>();
+            
+            _orderService.OnOrderGiven += OrderGiven;
+            _orderService.OnOrderRecieved += OrderRecieved;
+            _orderService.OnOrderDelivered += OrderDelivered;
+            _orderService.OnOrderFailure += OrderFailure;
+        }
+        private GameplaySceneEnvironment SceneEnvironmentVariables(Container sceneContainer)
+        {
+            var sceneEnvironment = (GameplaySceneEnvironment)sceneContainer.Resolve<CurrentSceneEnvironment>();
+ 
+            _debugTube = sceneEnvironment.debugTube;
+            return sceneEnvironment;
+        }
     }
 }

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

@@ -1,3 +1,4 @@
+using Code.App.Loading;
 using Code.App.StateMachine;
 using Code.Audio;
 using Code.Gameplay.Camera;
@@ -24,44 +25,81 @@ namespace Code.App.AppStates
 
         public override void EnterState()
         {
-            Context.UIService.LoadingScreen.Show();
+            Context.LoadingManager
+                .RegisterLoading(LoadingWork.LoadScene)
+                .RegisterLoading(LoadingWork.LoadUI)
+                .RegisterLoading(LoadingWork.LoadAudio);
+            
+            // Context.UIService.LoadingScreen.Show();
+
+            Context.CameraStateMachine.SwitchState(CameraMode.MainMenu);
+            
+            Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.MainMenu);
+            Context.LoadingManager.OnLoadingEnded += AfterSceneLoaded;
 
-            Context.CameraStateMachine.SwitchState(CameraMode.UltraStatic);
-        
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            WaitForSceneToLoad();
+            WaitForLoad();
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
 
-        private CinematicDoorOpening _damnDoor = new();
-        private async UniTaskVoid WaitForSceneToLoad()
+        private async UniTaskVoid WaitForLoad()
         {
             await UniTask.WhenAll(
-                Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.MainMenu),
                 Context.UIService.AsyncSwitchPanelTo(UIPanel.MainMenu),
-                Context.AudioFactory.WarmMenuMusic()
-                );
+                Context.AudioFactory.WarmMenuMusic(),
+                Context.AudioFactory.WarmAudioTestClips()
+            );
+            Context.LoadingManager
+                .UnregisterLoading(LoadingWork.LoadUI)
+                .UnregisterLoading(LoadingWork.LoadAudio);
             
+            InitializeAudio();
+
+            InitializeInput();
+        }
+
+        private void AfterSceneLoaded()
+        {
+            var mainMenuEnvironment = (MainMenuEnvironment)SceneManager.GetActiveScene()
+                .GetSceneContainer().Resolve<CurrentSceneEnvironment>();
+
+            InitializeUI(mainMenuEnvironment);
+
+            InitializeCamera(mainMenuEnvironment);
+            
+            Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
+        }
+
+        private void InitializeCamera(MainMenuEnvironment mainMenuEnvironment)
+        {
+            ((Gameplay.Camera.CameraStates.MainMenuState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(mainMenuEnvironment
+                .cameraPosition);
+        }
+
+        private void InitializeInput()
+        {
+            Context.InputService.EnableMap(ActionMappings.MainMenu);
+        }
+
+        private void InitializeAudio()
+        {
             Context.AudioService.TransitToSnapshot(AudioSnapshotState.Menu);
             Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Menu);
+        }
 
-            var hui = ((MainMenuEnvironment)SceneManager.GetActiveScene()
-                .GetSceneContainer().Resolve<CurrentSceneEnvironment>());
-            _damnDoor.DamnDoor = hui.damnDoor;
-            _damnDoor.DamnDoor.SetPhysics(false);
-            _damnDoor.DoorLight = hui.doorLight;
-
+        private void InitializeUI(MainMenuEnvironment mainMenuEnvironment)
+        {
             var menuPanel = (MainMenuPanel)Context.UIService.CurrentPanel;
-            
+            menuPanel.Initialize(mainMenuEnvironment.uiVariables,
+                mainMenuEnvironment.startButton,
+                mainMenuEnvironment.settingButton, 
+                mainMenuEnvironment.exitButton);
+
             menuPanel.startButton.button.onClick.AddListener(StartGame);
             menuPanel.exitButton.button.onClick.AddListener(ExitGame);
-            menuPanel.CinematicDoorOpening = _damnDoor;
-            
-            ((UltraStaticState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(hui.cameraPosition);
-            
-            Context.UIService.LoadingScreen.Hide();
-            
-            Context.InputService.EnableMap(ActionMappings.MainMenu);
+
+            mainMenuEnvironment.menuButtonsCanvas.worldCamera = Context.CameraStateMachine.Camera;
+            mainMenuEnvironment.settingsCanvas.worldCamera = Context.CameraStateMachine.Camera;
         }
 
         public override void Tick()
@@ -82,8 +120,10 @@ namespace Code.App.AppStates
         public override void ExitState()
         {
             Context.InputService.DisableMap(ActionMappings.MainMenu);
-            Context.AudioService.GladlyAskToStopMusic(MusicType.Menu, callback: Context.AudioFactory.ReleaseMenuMusic); 
-            
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Menu, callback: Context.AudioFactory.ReleaseMenuMusic);
+
+            Context.AudioFactory.ReleaseAudioTestClips();
+            Context.AudioFactory.ReleaseMenuMusic();
             base.ExitState();
         }
     }

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

@@ -1,8 +1,12 @@
+using System.Collections.Generic;
+using Code.App.Loading;
 using Code.App.StateMachine;
 using Code.Audio;
 using Code.Configs;
 using Code.Constants;
 using Code.Gameplay.Camera;
+using Code.Gameplay.Enemies;
+using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
 using Code.Input;
 using Code.Scenes;
@@ -25,11 +29,16 @@ namespace Code.App
             
             InstallInfrastructureUnit(containerBuilder, staticDataService);
 
+            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));
             containerBuilder.AddSingleton(typeof(UIService), typeof(IUIService));
             
@@ -72,6 +81,7 @@ namespace Code.App
             containerBuilder.AddSingleton(staticDataService.InputConfig, typeof(InputConfig));
             
             containerBuilder.AddSingleton(staticDataService.CameraConfig, typeof(CameraConfig));
+            containerBuilder.AddSingleton(staticDataService.CameraSettingsConfigs, typeof(Dictionary<CameraMode,CameraSettingsConfig>));
             
             containerBuilder.AddSingleton(staticDataService.PlayerConfig, typeof(PlayerConfig));
             containerBuilder.AddSingleton(staticDataService.CharacterConfig, typeof(CharacterConfig));
@@ -84,9 +94,14 @@ namespace Code.App
             
             containerBuilder.AddSingleton(staticDataService.AudioMixerConfig, typeof(AudioMixerConfig));
             containerBuilder.AddSingleton(staticDataService.SoundtrackListConfig, typeof(SoundtrackListConfig));
+            containerBuilder.AddSingleton(staticDataService.AudioTestClipsConfig, typeof(AudioTestClipsConfig));
             containerBuilder.AddSingleton(staticDataService.SFXListConfig, typeof(SFXListConfig));
             containerBuilder.AddSingleton(staticDataService.DispatcherSoundListConfig, typeof(DispatcherSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
+            containerBuilder.AddSingleton(staticDataService.AudioSourceSettingsConfigs, typeof(Dictionary<AudioSourceType, AudioSourceSettingsConfig>));
+
+            containerBuilder.AddSingleton(staticDataService.OrderServiceConfig, typeof(OrderServiceConfig));
+            containerBuilder.AddSingleton(staticDataService.OrderBoxConfig, typeof(OrderBoxConfig)); 
         }
 
         private AppStateMachine _appStateMachine;
@@ -103,19 +118,26 @@ namespace Code.App
 
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
             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)
         {
-            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen);
-            DontDestroyOnLoad(loadingScreen);
+            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen).GetComponent<LoadingScreen>();
+            DontDestroyOnLoad(loadingScreen.gameObject);
+
+            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
+            loadingManager.OnLoadingStarted += loadingScreen.Show;
+            loadingManager.OnLoadingEnded += loadingScreen.Hide;
+
+            loadingManager.RegisterLoading(LoadingWork.Bootstrap);
             
             await UniTask.WhenAll(
-                container.Resolve<IUIService>().Initialize(loadingScreen.GetComponent<LoadingScreen>()),
+                container.Resolve<IUIService>().Initialize(loadingScreen),
                 container.Resolve<IAudioService>().Initialize()
                 );
             
+            loadingManager.UnregisterLoading(LoadingWork.Bootstrap);
+            
             _appStateMachine
                 .SwitchState(AppState.MainMenu)
                 .AllowStateTransition(AppState.Gameplay);

Game/CourierOld/Assets/Code/App/Loading.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 08b54658296d4279b85a2bfc3cf10e62
+timeCreated: 1763842256

Game/CourierOld/Assets/Code/App/Loading/ILoadingManager.cs

@@ -0,0 +1,16 @@
+using System.Collections.ObjectModel;
+using Cysharp.Threading.Tasks;
+
+namespace Code.App.Loading
+{
+    public interface ILoadingManager
+    {
+        delegate void OnLoadingDelegate();
+
+        event OnLoadingDelegate OnLoadingStarted;
+        event OnLoadingDelegate OnLoadingEnded;
+        ReadOnlyCollection<LoadingWork> LoadingThings { get; }
+        LoadingManager RegisterLoading(LoadingWork loadingThingName);
+        LoadingManager UnregisterLoading(LoadingWork loadingThingName); 
+    }
+}

Game/CourierOld/Assets/Code/App/Loading/ILoadingManager.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bfb3837590d04da3b04ca8b0f0aca437
+timeCreated: 1763842985

Game/CourierOld/Assets/Code/App/Loading/LoadingManager.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Cysharp.Threading.Tasks;
+
+namespace Code.App.Loading
+{
+    public class LoadingManager : ILoadingManager
+    {
+        public event ILoadingManager.OnLoadingDelegate OnLoadingStarted;
+        public event ILoadingManager.OnLoadingDelegate OnLoadingEnded;
+        
+        private List<LoadingWork> _loadingThings = new();
+        public ReadOnlyCollection<LoadingWork> LoadingThings => _loadingThings.AsReadOnly();
+        
+        public LoadingManager RegisterLoading(LoadingWork loadingThingName)
+        {
+            if(_loadingThings.Count == 0) OnLoadingStarted?.Invoke();
+            
+            _loadingThings.Add(loadingThingName);
+
+            return this;
+        }
+        public LoadingManager UnregisterLoading(LoadingWork loadingThingName)
+        {
+            _loadingThings.Remove(loadingThingName);
+            
+            if(_loadingThings.Count == 0) OnLoadingEnded?.Invoke();
+            
+            return this;
+        }
+ 
+    }
+
+    // public static class LoadingManagerExtensions
+    // {
+    //     public static LoadingManager AddLoading(this LoadingManager manager, LoadingWork loadingThingName)
+    //     {
+    //         manager.RegisterLoading(loadingThingName);
+    //         return manager;
+    //     }
+    //     public static LoadingManager RemoveLoading(this LoadingManager manager, LoadingWork loadingThingName)
+    //     {
+    //         manager.UnregisterLoading(loadingThingName);
+    //         return manager;
+    //     }
+    // }
+}

Game/CourierOld/Assets/Code/App/Loading/LoadingManager.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 185988ac74a24a39864238cd7f5cb626
+timeCreated: 1763842268

Game/CourierOld/Assets/Code/App/Loading/LoadingWork.cs

@@ -0,0 +1,12 @@
+namespace Code.App.Loading
+{
+    public enum LoadingWork
+    {
+        Bootstrap,
+        LoadUI,
+        LoadAudio,
+        LoadScene,
+        LoadModelResource,
+        WaitingForTime
+    }
+}

Game/CourierOld/Assets/Code/App/Loading/LoadingWork.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 318d1b29b41d4b96bc09334acbf36506
+timeCreated: 1763843934

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

@@ -1,7 +1,11 @@
+using Code.App.Loading;
+using Code.Gameplay.Orders.Order;
+using Code.Gameplay.Player;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Reflex.Core;
 using UnityEngine;
+using IPlayerScore = Code.Gameplay.Player.IPlayerScore;
 
 namespace Code.App.SceneInstallers
 {
@@ -12,15 +16,22 @@ namespace Code.App.SceneInstallers
         public void InstallBindings(ContainerBuilder containerBuilder)
         {
             containerBuilder.AddScoped(typeof(GameplaySceneEnvironment), typeof(CurrentSceneEnvironment));
+            containerBuilder.AddScoped(typeof(PlayerScore), typeof(IPlayerScore));
+            containerBuilder.AddScoped(typeof(OrderService), typeof(IOrderService));
 
             containerBuilder.OnContainerBuilt += Initialize;
         }
 
         private void Initialize(Container container)
         {
-            GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
+            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
             
+            GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
+
             env.TransitVariables(_gameplaySceneEnvironment);
+            
+            loadingManager
+                .UnregisterLoading(LoadingWork.LoadScene);
         }
     }
 }

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

@@ -1,8 +1,8 @@
+using Code.App.Loading;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Reflex.Core;
-using UnityEngine;
-using UnityEngine.Serialization;
+using UnityEngine; 
 
 namespace Code.App.SceneInstallers
 {
@@ -22,6 +22,11 @@ namespace Code.App.SceneInstallers
             MainMenuEnvironment env = (MainMenuEnvironment)container.Resolve<CurrentSceneEnvironment>();
             
             env.TransitVariables(_mainMenuEnvironment);
+            
+            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
+
+            loadingManager
+                .UnregisterLoading(LoadingWork.LoadScene);
         }
     }
 }

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

@@ -1,5 +1,7 @@
+using Code.App.Loading;
 using Code.Audio;
 using Code.Gameplay.Camera;
+using Code.Gameplay.Enemies;
 using Code.Gameplay.Player;
 using Code.Input;
 using Code.Scenes;
@@ -10,6 +12,7 @@ namespace Code.App.StateMachine
 {
     public class AppStateMachineContext
     {
+        [Inject] public ILoadingManager LoadingManager { get; private set; }
         [Inject] public ISceneLoaderService SceneLoaderService { get; private set; }
         [Inject] public IInputService InputService { get; private set; }
         [Inject] public AppStateMachine StateMachine { get; private set; }
@@ -19,5 +22,6 @@ namespace Code.App.StateMachine
         [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; }
     }
 }

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

@@ -16,8 +16,16 @@ namespace Code.Audio
     }
     public enum DispatcherSounds
     {
-        Absolutely,
-        AbsolutelyNot,
-        AhFreeman
+        Recieve1,
+        Recieve2,
+        TakeDamage1,
+        TakeDamage2,
+        TakeDamage3,
+        TakeDamage4,
+        Late1,
+        Late2,
+        Late3,
+        Late4,
+        Late5
     }
 }

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Code.Configs;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
@@ -15,6 +16,7 @@ namespace Code.Audio
         public AudioMixer AudioMixer { get; private set; }
         private AssetReference _audioSourcePrefab;
         
+        private AssetReference[] _audioTestClipsReferences;
         private AssetReference[] _peacefulSoundtrack;
         private AssetReference[] _actionSoundtrack;
         private AssetReference[] _menuSoundtrack;
@@ -23,6 +25,7 @@ namespace Code.Audio
         private AssetReference[] _dispatcher;
         private AssetReference[] _character;
         
+        private AsyncOperationHandle<IList<AudioClip>> _audioTestClipsHandle;
         private AsyncOperationHandle<IList<AudioClip>> _menuMusicHandle;
         private AsyncOperationHandle<IList<AudioClip>> _actionMusicHandle;
         private AsyncOperationHandle<IList<AudioClip>> _peacefulMusicHandle;
@@ -30,6 +33,7 @@ namespace Code.Audio
         private AsyncOperationHandle<IList<AudioClip>> _enemiesHandle;
         private AsyncOperationHandle<IList<AudioClip>> _dispatcherHandle;
 
+        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();
@@ -39,7 +43,8 @@ namespace Code.Audio
             SoundtrackListConfig soundtrackListConfig,
             SFXListConfig sfxListConfig, 
             EnemiesSoundListConfig enemiesSoundListConfig,
-            DispatcherSoundListConfig dispatcherSoundListConfig
+            DispatcherSoundListConfig dispatcherSoundListConfig,
+            AudioTestClipsConfig audioTestClipsConfig
             )
         {
             AudioMixer = audioMixerConfig.audioMixerAsset;
@@ -51,6 +56,7 @@ namespace Code.Audio
             _SFX = sfxListConfig.SFX;
             _enemies = enemiesSoundListConfig.enemies;
             _dispatcher = dispatcherSoundListConfig.dispatcher;
+            _audioTestClipsReferences = audioTestClipsConfig.audioTestClips;
             
             MusicDictionary.Add(MusicType.Menu, new ());
             MusicDictionary.Add(MusicType.Peaceful, new ());
@@ -62,8 +68,8 @@ namespace Code.Audio
 
         public async UniTask WarmGameplayMusic( )
         {
-            _actionMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_actionSoundtrack, OnActionTrackLoaded, Addressables.MergeMode.None);
-            _peacefulMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_peacefulSoundtrack, OnPeacefulTrackLoaded, Addressables.MergeMode.None);
+            _actionMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_actionSoundtrack, OnActionTrackLoaded, Addressables.MergeMode.Union);
+            _peacefulMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_peacefulSoundtrack, OnPeacefulTrackLoaded, Addressables.MergeMode.Union);
             
             await UniTask.WhenAll(_actionMusicHandle.ToUniTask(), _peacefulMusicHandle.ToUniTask());
         }
@@ -77,12 +83,28 @@ namespace Code.Audio
             MusicDictionary[MusicType.Peaceful].Clear();
             _peacefulMusicHandle.Release();
         }
+        public async UniTask WarmAudioTestClips( )
+        {
+            // _audioTestClipCounter = 0;
+            _audioTestClipsHandle = Addressables.LoadAssetsAsync<AudioClip>(_audioTestClipsReferences, OnAudioTestClipLoaded, Addressables.MergeMode.Union);
+            
+            // foreach (var assetReference in _menuSoundtrack) MenuMusic.Add(await assetReference.LoadAssetAsync<AudioClip>());
+            var clips = (await _audioTestClipsHandle.ToUniTask()).ToList();
+
+            for (int i = 0; i < clips.Count; i++) 
+                AudioTestClips[(AudioType)i] = clips[i];
+        }
+        public void ReleaseAudioTestClips()
+        {
+            AudioTestClips.Clear();
+            // foreach (var assetReference in _menuSoundtrack) assetReference.ReleaseAsset();
+            _audioTestClipsHandle.Release();
+        }
         public async UniTask WarmMenuMusic( )
         {            
-            _menuMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_menuSoundtrack, OnMenuTrackLoaded, Addressables.MergeMode.None);
+            _menuMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_menuSoundtrack, OnMenuTrackLoaded, Addressables.MergeMode.Union);
             // foreach (var assetReference in _menuSoundtrack) MenuMusic.Add(await assetReference.LoadAssetAsync<AudioClip>());
             await _menuMusicHandle.ToUniTask();
-             
         }
         public void ReleaseMenuMusic()
         {
@@ -92,7 +114,7 @@ namespace Code.Audio
         }
         public async UniTask WarmSFX( )
         {            
-            _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.None);
+            _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.Union);
             
             await _SFXHandle.ToUniTask();
              
@@ -104,7 +126,7 @@ namespace Code.Audio
         }
         public async UniTask WarmEnemies( )
         {            
-            _enemiesHandle = Addressables.LoadAssetsAsync<AudioClip>(_enemies, OnEnemiesLoaded, Addressables.MergeMode.None);
+            _enemiesHandle = Addressables.LoadAssetsAsync<AudioClip>(_enemies, OnEnemiesLoaded, Addressables.MergeMode.Union);
             
             await _enemiesHandle.ToUniTask();
              
@@ -118,7 +140,7 @@ namespace Code.Audio
 
         public async UniTask WarmDispatcher( )
         {            
-            _dispatcherHandle = Addressables.LoadAssetsAsync<AudioClip>(_dispatcher, OnDispatcherLoaded, Addressables.MergeMode.None);
+            _dispatcherHandle = Addressables.LoadAssetsAsync<AudioClip>(_dispatcher, OnDispatcherLoaded, Addressables.MergeMode.Union);
             
             await _dispatcherHandle.ToUniTask();
              
@@ -134,6 +156,12 @@ namespace Code.Audio
         {
             MusicDictionary[MusicType.Menu].Add(audioClip);
         }
+
+        // private int _audioTestClipCounter;
+        private void OnAudioTestClipLoaded(AudioClip audioClip)
+        {
+            // AudioTestClips[(AudioType)_audioTestClipCounter] = audioClip;_audioTestClipCounter++;
+        }
         private void OnActionTrackLoaded(AudioClip audioClip)
         {
             MusicDictionary[MusicType.Action].Add(audioClip);

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

@@ -4,6 +4,7 @@ using System.Threading;
 using Code.Configs;
 using Code.Constants;
 using Cysharp.Threading.Tasks;
+using DG.Tweening;
 using Reflex.Attributes;
 using Unity.VisualScripting;
 using UnityEngine;
@@ -23,21 +24,93 @@ namespace Code.Audio
 
         private AudioMixerGroup _masterGroup,
             // _musicGroup,
-            // _actionMusicGroup,
-            // _peacefulMusicGroup,
+            _actionMusicGroup,
+            _menuMusicGroup,
+            _peacefulMusicGroup,
             _SFXGroup,
             _creaturesGroup,
             _dispatcherGroup,
             _courierGroup,
             _enemiesGroup;
 
-        private readonly AudioSourcePool _audioSourcePool = new();
+        private readonly AudioSourcePool _audioSourcePool;
 
         private Dictionary<AudioSnapshotState, AudioMixerSnapshot> _snapshots = new();
+        private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
 
-        public AudioService(IAudioFactory audioFactory)
+        public AudioService(IAudioFactory audioFactory, Dictionary<AudioSourceType, AudioSourceSettingsConfig> settings)
         {
             _audioFactory = audioFactory;
+            _audioSourcePool = new(settings);
+            _settings = settings;
+        }
+
+        // TODO Грязно, убрать снапшоты НАХУЙ
+        public float GetSetting(AudioType type)
+        {
+            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:
+                    _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);
+                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_masterGroup.name, volume);
+                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_masterGroup.name, volume);
+                    break;
+                case AudioType.Creatures:
+                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_creaturesGroup.name, volume);
+                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_creaturesGroup.name, volume);
+                    break;
+                case AudioType.GameplayMusic:
+                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_peacefulMusicGroup.name, volume);
+                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_actionMusicGroup.name, volume);
+                    break;
+                case AudioType.MenuMusic:
+                    _snapshots[AudioSnapshotState.Menu].audioMixer.SetFloat(_menuMusicGroup.name, volume);
+                    break;
+                case AudioType.DispatcherSounds:
+                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_dispatcherGroup.name, volume);
+                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_dispatcherGroup.name, volume);
+                    break;
+            }
+            // _mixer.FindSnapshot("Action").audioMixer.SetFloat("music", volume);
         }
 
         public async UniTask Initialize()
@@ -46,21 +119,22 @@ namespace Code.Audio
             _mixer = _audioFactory.AudioMixer;
 
             _masterGroup = _mixer.FindMatchingGroups(AudioGroups.MasterGroup)[0];
-            // _actionMusicGroup = _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0];
-            // _peacefulMusicGroup = _mixer.FindMatchingGroups(AudioGroups.PeacefulMusoup)[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.Action, _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0]);
             _musicAudioGroups.Add(MusicType.Peaceful, _mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0]);
-            
+
             _cancellationTokenSources.Add(MusicType.Menu, new());
             _cancellationTokenSources.Add(MusicType.Action, new());
             _cancellationTokenSources.Add(MusicType.Peaceful, new());
-            
+
             _musicAudioSources.Add(MusicType.Menu, null);
             _musicAudioSources.Add(MusicType.Action, null);
             _musicAudioSources.Add(MusicType.Peaceful, null);
-            
+
             _SFXGroup = _mixer.FindMatchingGroups(AudioGroups.SFXGroup)[0];
             _creaturesGroup = _mixer.FindMatchingGroups(AudioGroups.CreaturesGroup)[0];
             _dispatcherGroup = _mixer.FindMatchingGroups(AudioGroups.DispatcherMusicGroup)[0];
@@ -73,7 +147,6 @@ namespace Code.Audio
             _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
@@ -83,50 +156,51 @@ namespace Code.Audio
 
         public async UniTaskVoid PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType musicType)
         {
-            if(!_musicAudioSources[musicType])
+            if (!_musicAudioSources[musicType])
             {
                 _musicAudioSources[musicType] = _audioSourcePool.GetSource();
-                _musicAudioSources[musicType].spatialBlend = 0f;
+                _musicAudioSources[musicType].spatialBlend = _settings[AudioSourceType.NoBlend].spatialBlend;
                 _musicAudioSources[musicType].outputAudioMixerGroup = _musicAudioGroups[musicType];
             }
-            
+
             _musicAudioSources[musicType].resource =
                 _audioFactory.MusicDictionary[musicType][
                     Random.Range(0, _audioFactory.MusicDictionary[musicType].Count)];
-            
+
             _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,
+                _ => !_musicAudioSources[musicType].isPlaying,
                 cancellationToken: _cancellationTokenSources[musicType].Token).SuppressCancellationThrow();
             // Debug.Log($"Finished {musicType}");
-            
+
             if (isCanceled)
             {
                 // Debug.Log($"Cancelled {musicType}");
                 _cancellationTokenSources[musicType].Dispose();
                 _cancellationTokenSources[musicType] = new();
-                
+
                 _audioSourcePool.ReleaseSource(_musicAudioSources[musicType]);
                 _musicAudioSources[musicType] = null;
-                
+
                 return;
             }
 
             PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(musicType);
         }
-        
-        public async UniTaskVoid GladlyAskToStopMusic(MusicType musicType, AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null)
+
+        public async UniTaskVoid GladlyAskToStopMusic(MusicType musicType,
+            AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null)
         {
             TransitToSnapshot(audioSnapshotState, time);
 
             await UniTask.WaitForSeconds(time);
-            
+
             _cancellationTokenSources[musicType].Cancel();
 
             callback?.Invoke();
@@ -164,9 +238,115 @@ namespace Code.Audio
             _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position, _enemiesGroup);
         }
 
+        // Чинить долго и дорого пусть Артёмов будет много, ведь он наш друг
+        public event IAudioService.OnAudioPlayingDelegate OnDispatcherStarted;
+        public event IAudioService.OnAudioPlayingDelegate OnDispatcherEnded;
+
         public void PlayDispatcher(DispatcherSounds dispatcherSoundId)
         {
-            _audioSourcePool.PlayShizo(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup);
+            OnDispatcherStarted?.Invoke();
+            _audioSourcePool.PlayOneShot(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup,
+                AudioSourceType.NoBlend, () => OnDispatcherEnded?.Invoke());
+        }
+
+        private CancellationTokenSource _testClipCancellationTokenSource = new();
+        private void ResetCurrentTestAudioSource() => _currentTestClipAudioType = AudioType.Master;
+        // TODO Засунуть в словарь
+        public void PlayTestClip(AudioType audioType)
+        {
+            if(_currentTestClipAudioType == audioType) return;
+            
+            _testClipCancellationTokenSource.Cancel();
+            _testClipCancellationTokenSource = new();
+
+            _currentTestClipAudioType = audioType;
+
+            switch (audioType)
+            {
+                case AudioType.SFX:
+                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
+                        _SFXGroup, _testClipCancellationTokenSource,
+                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
+                    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/AudioServiceDebug.cs

@@ -1,119 +0,0 @@
-using System.Collections.Generic;
-using Code.Constants;
-using UnityEngine;
-using UnityEngine.Audio;
-using UnityEngine.Serialization;
-
-namespace Code.Audio
-{
-    public class AudioServiceDebug : MonoBehaviour
-    {
-        [SerializeField] private AudioMixer mixer;
-
-        private AudioSource _actionMusicSource;
-        private AudioSource _peacefulMusicSource;
-        [SerializeField] private AudioSource prefab;
-
-        [SerializeField] private AudioResource[] peacefulAudio;
-        [SerializeField] private AudioResource[] actionAudio;
-
-        private AudioMixerGroup _masterGroup,
-            _musicGroup,
-            _actionMusicGroup,
-            _peacefulMusicGroup,
-            _SFXGroup,
-            _creaturesGroup,
-            _dispatcherGroup,
-            _courierGroup,
-            _enemiesGroup;
-
-        private readonly AudioSourcePool _audioSourcePool = new();
-
-        private Dictionary<AudioSnapshotState, AudioMixerSnapshot> _snapshots = new();
-        
-        [FormerlySerializedAs("sfxAudio")] [SerializeField] private AudioClip[] sfxAudios;
-        [SerializeField] private AudioClip[] enemiesAudios;
-        [SerializeField] private AudioClip[] dispatcherAudios;
-
-        private void MixerCreated()
-        {
-            _masterGroup = mixer.FindMatchingGroups(AudioGroups.MasterGroup)[0];
-            _actionMusicGroup = mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0];
-            _peacefulMusicGroup = mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0];
-            _SFXGroup = mixer.FindMatchingGroups(AudioGroups.SFXGroup)[0];
-            _musicGroup = mixer.FindMatchingGroups(AudioGroups.MusicGroup)[0];
-            _creaturesGroup = mixer.FindMatchingGroups(AudioGroups.CreaturesGroup)[0];
-            _dispatcherGroup = mixer.FindMatchingGroups(AudioGroups.DispatcherMusicGroup)[0];
-            _courierGroup = mixer.FindMatchingGroups(AudioGroups.CourierMusicGroup)[0];
-            _enemiesGroup = mixer.FindMatchingGroups(AudioGroups.EnemiesMusicGroup)[0];
-
-            _snapshots[AudioSnapshotState.Peaceful] = mixer.FindSnapshot(AudioGroups.PeacefulSnapshot);
-            _snapshots[AudioSnapshotState.Action] = mixer.FindSnapshot(AudioGroups.ActionSnapshot);
-
-            // _audioSourcePool.Initialize(10,prefab);
-
-            InitializeMusicSources();
-        }
-
-        private void InitializeMusicSources()
-        {
-            _actionMusicSource = _audioSourcePool.GetSource();
-            _actionMusicSource.outputAudioMixerGroup = _actionMusicGroup;
-            _actionMusicSource.spatialBlend = 0f;
-            
-            _peacefulMusicSource = _audioSourcePool.GetSource();
-            _peacefulMusicSource.outputAudioMixerGroup = _peacefulMusicGroup;
-            _peacefulMusicSource.spatialBlend = 0f;
-        }
-
-        private void Start()
-        {
-            MixerCreated();
-        }
-
-        public void PlayRandomGameplayMusic()
-        {
-            _peacefulMusicSource.resource = peacefulAudio[Random.Range(0, peacefulAudio.Length)];
-            _actionMusicSource.resource = actionAudio[Random.Range(0, actionAudio.Length)];
-
-            _peacefulMusicSource.Play();
-            _actionMusicSource.Play();
-        } 
-
-        public void TransitToSnapshot(AudioSnapshotState state)
-        {
-            _snapshots[state].TransitionTo(1f);
-        }
-
-#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(sfxAudios[(int)sfxId], position, _SFXGroup);
-        }
-        public void PlayDebugSFX()
-        {
-            _audioSourcePool.PlayOneShot(sfxAudios[(int)SFXSounds.Crowbar], transform.position, _SFXGroup);
-        }
-        public void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position)
-        {
-            _audioSourcePool.PlayOneShot(enemiesAudios[(int)enemySoundId], position, _enemiesGroup);
-        }
-        public void PlayDebugEnemySFX()
-        {
-            _audioSourcePool.PlayOneShot(enemiesAudios[(int)EnemiesSounds.Bastard], transform.position, _enemiesGroup);
-        }
-        public void PlayDispatcher(DispatcherSounds dispatcherSoundId)
-        {
-            _audioSourcePool.PlayShizo(dispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup);
-        }
-        public void PlayDebugDispatcherSFX()
-        {
-            _audioSourcePool.PlayShizo(dispatcherAudios[(int)DispatcherSounds.AhFreeman], _dispatcherGroup);
-        }
-        
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-    }
-
-}
-
-    

Game/CourierOld/Assets/Code/Audio/AudioServiceDebug.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: a42cad8f28f54a53bef23d9313014abd
-timeCreated: 1762805867

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

@@ -1,7 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Code.Configs;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 using UnityEngine.Audio;
 using UnityEngine.Pool;
+using Object = UnityEngine.Object;
 
 namespace Code.Audio
 {
@@ -10,7 +15,11 @@ namespace Code.Audio
         // The pool holds plain GameObjects (you can swap this for any component type).
         private IObjectPool<AudioSource> _pool; 
         private GameObject _sourcePrefab;
-  
+
+        private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
+        
+        public AudioSourcePool(Dictionary<AudioSourceType, AudioSourceSettingsConfig> settings) => _settings = settings;
+
         public void Initialize(GameObject sourcePrefab)
         {
             _sourcePrefab = sourcePrefab;
@@ -54,30 +63,58 @@ namespace Code.Audio
         {
             Object.Destroy(source.gameObject);
         }
-
-        public async UniTaskVoid PlayOneShot(AudioClip clip, Vector3 position, AudioMixerGroup audioMixerGroup)
+        
+        public async UniTaskVoid PlayOneShot(AudioClip clip, Vector3 position, AudioMixerGroup audioMixerGroup, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
         {
             AudioSource source = _pool.Get();
             source.PlayOneShot(clip);
-            source.spatialBlend = 1f;
+            source.spatialBlend = _settings[audioSourceType].spatialBlend;
             source.transform.position = position;
             source.outputAudioMixerGroup = audioMixerGroup;
             
             await UniTask.WaitUntilValueChanged(source, x => x.isPlaying);
-            
+            onComplete?.Invoke();
             _pool.Release(source);
         }
-        public async UniTaskVoid PlayShizo(AudioClip clip, AudioMixerGroup audioMixerGroup)
+        public async UniTaskVoid PlayOneShot(AudioClip clip, AudioMixerGroup audioMixerGroup, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
         {
             AudioSource source = _pool.Get();
             source.PlayOneShot(clip);
-            source.spatialBlend = 0f;
+            source.spatialBlend = _settings[audioSourceType].spatialBlend;
             source.outputAudioMixerGroup = audioMixerGroup;
             
             await UniTask.WaitUntilValueChanged(source, x => x.isPlaying);
+            onComplete?.Invoke();
+            _pool.Release(source);
+        } 
+        public async UniTaskVoid PlayOneShot(AudioSource audioSource, AudioClip clip, AudioMixerGroup audioMixerGroup, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
+        { 
+            audioSource.PlayOneShot(clip);
+            audioSource.spatialBlend = _settings[audioSourceType].spatialBlend;
+            audioSource.outputAudioMixerGroup = audioMixerGroup;
+            
+            // TODO Потом сделать. Можно с cancellation, но сейчас лень. Ну правда
+            await UniTask.WaitUntilValueChanged(audioSource, x => x.isPlaying);
+            
+            if (!audioSource) return;
+            
+            _pool.Release(audioSource);
+            onComplete?.Invoke();
+        } 
+        public async UniTaskVoid PlayOneShot(AudioClip clip, AudioMixerGroup audioMixerGroup, CancellationTokenSource cancellationToken, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
+        { 
+            AudioSource source = _pool.Get();
+            source.PlayOneShot(clip);
+            source.spatialBlend = _settings[audioSourceType].spatialBlend;
+            source.outputAudioMixerGroup = audioMixerGroup;
+             
+            var (isCanceled, _) = await UniTask.WaitUntilValueChanged(source, x => x.isPlaying, cancellationToken: cancellationToken.Token).SuppressCancellationThrow();
             
             _pool.Release(source);
-        }
+            
+            if(!isCanceled) onComplete?.Invoke();
+            else cancellationToken.Dispose();
+        } 
         public AudioSource GetSource() => _pool.Get();
         public void ReleaseSource(AudioSource source) => _pool.Release(source);
     }

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

@@ -0,0 +1,8 @@
+namespace Code.Audio
+{
+    public enum AudioSourceType
+    {
+        Full3D,
+        NoBlend
+    }
+}

Game/CourierOld/Assets/Code/Audio/AudioSourceType.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 260bbb19b55049928b9ab4d55b32fc3f
+timeCreated: 1763849966

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

@@ -8,22 +8,25 @@ namespace Code.Audio
 {
     public interface IAudioFactory
     {
+        AudioMixer AudioMixer { get; }
+        Dictionary<AudioType, AudioClip> AudioTestClips { get; }
+        Dictionary<MusicType, List<AudioClip>> MusicDictionary { get; }
         List<AudioClip> SFXAudios { get; }
         List<AudioClip> EnemiesAudios { get; }
         List<AudioClip> DispatcherAudios { get; }
-        AudioMixer AudioMixer { get; }
-        Dictionary<MusicType, List<AudioClip>> MusicDictionary { get; }
         UniTask LoadAudioSourcePrefab(Action<GameObject> callback);
-        UniTask WarmGameplayMusic();
+        UniTask WarmGameplayMusic( );
         void ReleaseActionMusic();
-        UniTask WarmMenuMusic();
-        void ReleaseMenuMusic();
-        UniTask WarmSFX();
-        void ReleaseSFX();
-        UniTask WarmEnemies();
-        void ReleaseEnemies();
-        UniTask WarmDispatcher();
-        void ReleaseDispatcher();
         void ReleasePeacefulMusic();
+        UniTask WarmAudioTestClips( );
+        void ReleaseAudioTestClips();
+        UniTask WarmMenuMusic( );
+        void ReleaseMenuMusic();
+        UniTask WarmSFX( );
+        void ReleaseSFX();
+        UniTask WarmEnemies( );
+        void ReleaseEnemies();
+        UniTask WarmDispatcher( );
+        void ReleaseDispatcher();
     }
 }

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

@@ -14,6 +14,14 @@ namespace Code.Audio
         void TransitToSnapshot(AudioSnapshotState state, float time = 1f);
         void PlaySFX(SFXSounds sfxId, Vector3 position);
         void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position);
+
+        delegate void OnAudioPlayingDelegate();
+
+        event OnAudioPlayingDelegate OnDispatcherStarted;
+        event OnAudioPlayingDelegate OnDispatcherEnded;
         void PlayDispatcher(DispatcherSounds dispatcherSoundId);
+        void ChangeSetting(AudioType type, float value);
+        float GetSetting(AudioType type);
+        void PlayTestClip(AudioType audioType);
     }
 }

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

@@ -6,4 +6,13 @@ namespace Code.Audio
         Peaceful,
         Action
     }
+    public enum AudioType
+    {
+        Master,
+        MenuMusic,
+        GameplayMusic,
+        Creatures,
+        DispatcherSounds,
+        SFX
+    } 
 }

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

@@ -0,0 +1,14 @@
+using Code.Audio;
+using UnityEngine;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(fileName = "AudioSourceSettingsConfig", menuName = "Audio/AudioSourceSettingsConfig")]
+    public class AudioSourceSettingsConfig : ScriptableObject
+    {
+        // Дополнять по мере необходимости
+        public float spatialBlend;
+        
+        public AudioSourceType sourceType;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e6406ab390b74d5ca336d7d4d0e1a732
+timeCreated: 1763850008

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

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

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f2f1c08a20a54a708336caf8ca6499e1
+timeCreated: 1764263243

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

@@ -0,0 +1,14 @@
+using Code.Gameplay.Camera;
+using UnityEngine;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(fileName = "CameraSettingsConfig", menuName = "Config/CameraSettingsConfig")]
+    public class CameraSettingsConfig : ScriptableObject
+    {
+        // Дополнять по мере необходимости
+        public float fov;
+        
+        public CameraMode cameraMode;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6610b94e9823401c94533e1756a97195
+timeCreated: 1763846744

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

@@ -0,0 +1,12 @@
+using UnityEngine;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(menuName = "Config/Gameplay/OrderBox", fileName = "OrderBoxConfig")]
+    public class OrderBoxConfig : ScriptableObject
+    {
+        public float activationTime;
+        public AnimationCurve floatingCurve;
+        public float curveLength;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6af4f53d425a41c78ef889fd7e5c3197
+timeCreated: 1763735968

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

@@ -0,0 +1,11 @@
+using UnityEngine;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(fileName = "OrderServiceConfig", menuName = "Config/Gameplay/OrderServiceConfig")]
+    public class OrderServiceConfig : ScriptableObject
+    {
+        public Vector2 timeBounds;
+        public float koefRooms, koefOvertime;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ee2550c3e4874575ac3aecadfcc42475
+timeCreated: 1763559999

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

@@ -9,5 +9,6 @@ namespace Code.Configs
         public int maxHealth;
         
         public AssetReference characterPrefab;
+        public AssetReference armsMeshPrefab;
     }
 }

Game/CourierOld/Assets/Code/Gameplay/Camera/CameraMode.cs

@@ -10,9 +10,9 @@ namespace Code.Gameplay.Camera
      */
     public enum CameraMode
     {
-        Bogdan,
+        None,
         Static,
-        UltraStatic,
+        MainMenu,
         FirstPerson,
         ThirdPerson,
         Cinematic

Game/CourierOld/Assets/Code/Gameplay/Camera/CameraStateMachine.cs

@@ -9,14 +9,16 @@ namespace Code.Gameplay.Camera
         // Текущий режим работы камеры
         public override void Initialize()
         {
+            States.Add(CameraMode.None, new NoneState(StateMachineContext));
             States.Add(CameraMode.Static, new StaticState(StateMachineContext));
-            States.Add(CameraMode.UltraStatic, new UltraStaticState(StateMachineContext));
+            States.Add(CameraMode.MainMenu, new MainMenuState(StateMachineContext));
             States.Add(CameraMode.FirstPerson, new FirstPersonState(StateMachineContext));
             States.Add(CameraMode.ThirdPerson, new ThirdPersonState(StateMachineContext));
             
-            CurrentBaseState = States[CameraMode.UltraStatic];
+            CurrentBaseState = States[CameraMode.None];
         }
         
+        public UnityEngine.Camera Camera => StateMachineContext.Camera;
 
         protected override bool CheckTransitionAllowed(CameraMode nextState) => true;
 

Game/CourierOld/Assets/Code/Gameplay/Camera/CameraStateMachineContext.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using Code.Configs;
 using Code.Input;
 using Reflex.Attributes;
@@ -9,5 +10,6 @@ namespace Code.Gameplay.Camera
         [Inject] public UnityEngine.Camera Camera;
         [Inject] public CameraConfig Config;
         [Inject] public IInputService InputService;
+        [Inject] public Dictionary<CameraMode,CameraSettingsConfig> CameraSettingsConfigs;
     }
 }

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

@@ -14,14 +14,16 @@ namespace Code.Gameplay.Camera.CameraStates
 
         public override void EnterState()
         {
+            base.EnterState();
+            
             // В FirstPerson режиме дистанция всегда равна 0
             MinDistance = 0f;
             MaxDistance = 0f;
             DefaultDistance = 0f;
             TargetDistance = 0f;
             CurrentDistance = 0f;
-            
-            base.EnterState();
+
+            Camera.fieldOfView = Context.CameraSettingsConfigs[CameraMode.FirstPerson].fov;
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)

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

@@ -2,14 +2,15 @@ using UnityEngine;
 
 namespace Code.Gameplay.Camera.CameraStates
 {
-    public class UltraStaticState : BaseCameraState, ICameraState
+    public class MainMenuState : BaseCameraState, ICameraState
     {
-        public UltraStaticState(CameraStateMachineContext context) : base(context) { }
+        public MainMenuState(CameraStateMachineContext context) : base(context) { }
 
         public override void EnterState()
         {
-            Debug.Log("Ultra static State Enter");
             base.EnterState();
+            
+            Camera.fieldOfView = Context.CameraSettingsConfigs[CameraMode.MainMenu].fov;
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)
@@ -17,7 +18,7 @@ namespace Code.Gameplay.Camera.CameraStates
             Camera.transform.position = FollowTransform.position;
         }
         
-        public CameraMode GetCameraMode() => CameraMode.UltraStatic;
+        public CameraMode GetCameraMode() => CameraMode.MainMenu;
 
         protected override void HandleRotationInput(float deltaTime, Vector3 rotationInput,
             out Quaternion targetRotation)

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

@@ -0,0 +1,21 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Camera.CameraStates
+{
+    public class NoneState : BaseCameraState, ICameraState
+    { 
+        public NoneState(CameraStateMachineContext context) : base(context) { }
+ 
+        protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)
+        {
+        }
+        
+        public CameraMode GetCameraMode() => CameraMode.None;
+
+        protected override void HandleRotationInput(float deltaTime, Vector3 rotationInput,
+            out Quaternion targetRotation)
+        { 
+            targetRotation = Quaternion.identity;
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Camera/CameraStates/NoneState.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d8fa6119113f4f12a35365fd27387124
+timeCreated: 1763847889

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

@@ -9,8 +9,9 @@ namespace Code.Gameplay.Camera.CameraStates
 
         public override void EnterState()
         {
-            Debug.Log("Static State Enter");
             base.EnterState();
+            
+            Camera.fieldOfView = Context.CameraSettingsConfigs[CameraMode.Static].fov;
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)

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

@@ -14,13 +14,13 @@ namespace Code.Gameplay.Camera.CameraStates
 
         public override void EnterState()
         {
+            base.EnterState();
+            
             // Восстанавливаем исходные значения дистанции
             MinDistance = OriginalMinDistance;
             MaxDistance = OriginalMaxDistance;
             DefaultDistance = OriginalDefaultDistance;
             TargetDistance = DefaultDistance;
-            
-            base.EnterState();
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)

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

@@ -199,7 +199,6 @@ namespace Code.Gameplay.Character.Controller
                 // Заготовка на будущее (если понадобится)
                 case CameraMode.Static:
                 case CameraMode.Cinematic:
-                case CameraMode.Bogdan: // Скорее всего юзлес, но пускай будет
                 default:
                     break;
             }

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

@@ -1,6 +1,7 @@
 using Code.Gameplay.Camera;
 using Code.Gameplay.Camera.CameraStates;
 using Code.Gameplay.Character.Controller;
+using Code.Gameplay.Player;
 using Code.Input;
 using Reflex.Attributes;
 using UnityEngine;
@@ -18,6 +19,9 @@ namespace Code.Gameplay.Character.Core
         
         [Inject] private IInputService _inputService; // Сервис ввода через DI
 
+        [SerializeField] private PlayerAnimator _animator;
+        public PlayerAnimator PlayerAnimator => _animator;
+
         public void Teleport(Vector3 position, Quaternion rotation)
         {
             customCharacterController.SetPosition(position);

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

@@ -5,19 +5,44 @@ namespace Code.Gameplay.Door
 {
     public class CinematicDoorOpening
     {
-        public DamnDoor DamnDoor;
-        public Light DoorLight;
+        private MainMenuDoor _mainMenuDoor;
+        private Light _doorLight;
 
-        public void PreOpen(bool start)
+        public CinematicDoorOpening(MainMenuDoor mainMenuDoor, Light doorLight)
         {
-            DoorLight.DOColor(start ? Color.yellow : Color.red, 0.2f);
+            _mainMenuDoor = mainMenuDoor;
+            _doorLight = doorLight;
+        }
+        public void PreOpen(int type)
+        {
+            switch (type)
+            {
+                case 0:
+                    _doorLight.DOColor(Color.green, 0.2f);
+                    break;
+                case 1:
+                    _doorLight.DOColor(Color.yellow, 0.2f);
+                    break;
+                case 2:
+                    _doorLight.DOColor(Color.red, 0.2f);
+                    break;
+            }
 
-            DamnDoor.Petlya.DORotate(new Vector3(0, -40, 0), 1f);
+            _mainMenuDoor.Petlya.DORotate(new Vector3(0, -10, 0), 1f);
         }
 
         public void Close()
         {
-            DamnDoor.Petlya.DORotate(new Vector3(0, 0, 0), 1f);
+            _mainMenuDoor.Petlya.DORotate(new Vector3(0, 0, 0), 1f);
         }
     }
+
+    [System.Serializable]
+    public class MainMenuUIVariables
+    {
+        public MainMenuDoor MainMenuDoor;
+        public Light DoorLight;
+        public Color ButtonDefaultColor;
+        public Color ButtonHoverColor;
+    }
 }

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

@@ -2,7 +2,7 @@ using UnityEngine;
 
 namespace Code.Gameplay.Door
 {
-    public class DamnDoor : MonoBehaviour
+    public class MainMenuDoor : MonoBehaviour
     {
         [SerializeField] Rigidbody rigidbody;
         [SerializeField] private Transform petlya;

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

@@ -187,7 +187,8 @@ namespace Code.Gameplay.Enemies
 
         protected virtual void ApplyEffectsToPlayer()
         {
-            PlayerController.BlockAbilities(3f);
+            if (PlayerController)
+                PlayerController.BlockAbilities(3f);
         }
 
         private void OnDrawGizmosSelected()

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

@@ -0,0 +1,55 @@
+using System;
+using Code.Configs;
+using Cysharp.Threading.Tasks;
+using Reflex.Attributes;
+using Reflex.Core;
+using Reflex.Injectors;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+namespace Code.Gameplay.Enemies
+{
+    public class EnemyFactory : IEnemyFactory
+    {
+        [Inject] private FogConfig _fogConfig;
+        [Inject] private DrunkenGrandpaConfig _drunkenGrandpaConfig;
+        [Inject] private CockroachConfig _cockroachConfig;
+        
+        public async UniTask<BaseEnemy> CreateEnemy(EnemyType type, Vector3? position = null, Quaternion? rotation = null)
+        {
+            var prefabRef = GetEnemyPrefab(type);
+    
+            var enemyObj = await Addressables
+                .InstantiateAsync(
+                    prefabRef,
+                    position: position ?? Vector3.zero,
+                    rotation: rotation ?? Quaternion.identity
+                )
+                .ToUniTask();
+
+            AttributeInjector.Inject(enemyObj, Container.ProjectContainer);
+    
+            return enemyObj.GetComponent<BaseEnemy>();
+        }
+
+        public void ReleaseEnemy(BaseEnemy enemy)
+        {
+            if (enemy == null) return;
+    
+            enemy.gameObject.SetActive(false);
+            
+            Addressables.ReleaseInstance(enemy.gameObject);
+        }
+
+        private AssetReference GetEnemyPrefab(EnemyType type)
+        {
+            return type switch
+            {
+                EnemyType.Fog => _fogConfig.fogPrefab,
+                EnemyType.DrunkenGrandpa => _drunkenGrandpaConfig.drunkenGrandpaPrefab,
+                EnemyType.Cockroach => _cockroachConfig.cockroachPrefab,
+                _ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
+            };
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2f9328c54d334b0c85ce44b0aa7add44
+timeCreated: 1764168610

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

@@ -0,0 +1,84 @@
+using Code.Gameplay.Player;
+using Cysharp.Threading.Tasks;
+using Reflex.Attributes;
+using Reflex.Core;
+using Reflex.Injectors;
+using UnityEngine;
+
+namespace Code.Gameplay.Enemies
+{
+    public class EnemySpawner : MonoBehaviour
+    {
+        [SerializeField] private EnemyType spawnerType;
+        [SerializeField] private float spawnRadius = 40f;
+        [SerializeField] private float despawnRadius = 50f;
+
+        [Inject] private IPlayerProvider _playerProvider;
+        [Inject] private IEnemyFactory _enemyFactory;
+
+        private BaseEnemy _spawnedEnemy;
+        private bool _isSpawning;
+        private bool _isPlayerInRange;
+
+        private void Awake()
+        {
+            if (_playerProvider == null || _enemyFactory == null)
+            {
+                AttributeInjector.Inject(this, Container.ProjectContainer);
+            }
+        }
+
+        private void Update()
+        {
+            if (!_playerProvider?.Character)
+                return;
+
+            var distanceToPlayer = Vector3.Distance(transform.position, _playerProvider.Character.transform.position);
+
+            var wasInRange = _isPlayerInRange;
+            _isPlayerInRange = distanceToPlayer <= spawnRadius;
+
+            switch (_isPlayerInRange)
+            {
+                case true when !_spawnedEnemy && !_isSpawning && !wasInRange:
+                    Spawn().Forget();
+                    break;
+                case false when _spawnedEnemy && distanceToPlayer > despawnRadius:
+                    Despawn();
+                    break;
+            }
+        }
+
+        private async UniTask Spawn()
+        {
+            if (_spawnedEnemy || _isSpawning) return;
+
+            _isSpawning = true;
+            var enemy = await _enemyFactory.CreateEnemy(
+                spawnerType,
+                transform.position,
+                transform.rotation
+            );
+                
+            _spawnedEnemy = enemy;
+            _isSpawning = false;
+        }
+
+        private void Despawn()
+        {
+            if (_spawnedEnemy == null) return;
+
+            _enemyFactory.ReleaseEnemy(_spawnedEnemy);
+            _spawnedEnemy = null;
+        }
+
+        private void OnDrawGizmosSelected()
+        {
+            Gizmos.color = new Color(0, 1, 0, 0.5f);
+            Gizmos.DrawSphere(transform.position, spawnRadius);
+
+            Gizmos.color = new Color(1, 0, 0, 0.2f);
+            Gizmos.DrawSphere(transform.position, despawnRadius);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e87d9529de45409781ec5bfc356518c7
+timeCreated: 1764225519

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

@@ -0,0 +1,9 @@
+namespace Code.Gameplay.Enemies
+{
+    public enum EnemyType
+    {
+        Fog,
+        DrunkenGrandpa,
+        Cockroach
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5430cad1a8c44516944259a428de641e
+timeCreated: 1764168839

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

@@ -0,0 +1,11 @@
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+
+namespace Code.Gameplay.Enemies
+{
+    public interface IEnemyFactory
+    {
+        UniTask<BaseEnemy> CreateEnemy(EnemyType type, Vector3? position, Quaternion? rotation);
+        void ReleaseEnemy(BaseEnemy enemy);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 68eb3027a07042b991aa1893ddd14368
+timeCreated: 1764168497

Game/CourierOld/Assets/Code/Gameplay/Orders.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e41c28f7828a44b7bc26d87886064d99
+timeCreated: 1763556651

Game/CourierOld/Assets/Code/Gameplay/Orders/Order.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4911436131e345ada949f2418595bbd8
+timeCreated: 1763559099

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/IOrderService.cs

@@ -0,0 +1,25 @@
+namespace Code.Gameplay.Orders.Order
+{
+    public interface IOrderService
+    {
+        delegate void OrderFailureDelegate();
+        
+        delegate void OrderProgressDelegate(float time);
+
+        event OrderProgressDelegate OnOrderGiven;
+        event OrderProgressDelegate OnOrderRecieved;
+        event OrderFailureDelegate OnOrderFailure;
+
+        delegate void OrderDeliveredDelegate(int score, float time);
+
+        event OrderDeliveredDelegate OnOrderDelivered;
+        OrderState OrderState { get; }
+        float DeliveryTimer { get; }
+        void RoomPassed();
+        void DecreaseTimer(float delta);
+        void OrderGive();
+        void OrderRecieved();
+        void OrderDelivered();
+        void OrderFailed();
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/IOrderService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8b4467951c884c8dafeb633020696c24
+timeCreated: 1763561686

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderBox.cs

@@ -0,0 +1,65 @@
+using System;
+using Code.Configs;
+using Code.Gameplay.Orders.Order;
+using Cysharp.Threading.Tasks;
+using Reflex.Attributes;
+using UnityEngine;
+
+namespace Code.Gameplay.Orders.Order
+{
+    public class OrderBox : MonoBehaviour
+    {
+        [Inject] private IOrderService _orderService;
+        public Rigidbody rigidbody;
+        private bool _pickupMode;
+        // [SerializeField] private AnimationCurve debugCurve;
+
+        //DEBUG
+        // private void Start()
+        // {
+        //     _capturedPosition = transform.position;
+        //     _floatingCurve = debugCurve;
+        //     _curveLength = 1f;
+        // }
+        // DEBUG
+        
+        private float _activationTime;
+        [Inject]
+        private void Construct(OrderBoxConfig config)
+        {
+            _floatingCurve = config.floatingCurve;
+            _activationTime = config.activationTime;
+            _curveLength = config.curveLength;
+        }
+        public void OnTriggerEnter(Collider other)
+        {
+            if (!_pickupMode) return;
+            
+            _orderService.OrderRecieved();
+            Destroy(gameObject);
+        }
+
+        public async UniTaskVoid SwitchMode()
+        {
+            await UniTask.WaitForSeconds(_activationTime);
+            _pickupMode = true;
+            rigidbody.isKinematic = true;
+            _capturedPosition = transform.position;
+        }
+
+        private Vector3 _capturedPosition;
+        private float _timeForMoving;
+        private AnimationCurve _floatingCurve;
+        private float _curveLength;
+        
+        private void FixedUpdate()
+        {
+            if (!_pickupMode) return;
+            _timeForMoving += Time.fixedDeltaTime;
+            
+            if (_timeForMoving > _curveLength) _timeForMoving = 0;
+            
+            transform.position = _capturedPosition + new Vector3(0, _floatingCurve.Evaluate(_timeForMoving), 0);
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderBox.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 067bc72af86a4fb8ac44d0c1fcfd25d5
+timeCreated: 1763573681

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderDeliveryTrigger.cs

@@ -0,0 +1,19 @@
+using System;
+using Reflex.Attributes;
+using UnityEngine;
+
+namespace Code.Gameplay.Orders.Order
+{
+    public class OrderDeliveryTrigger : MonoBehaviour
+    {
+        [Inject] private IOrderService _orderService;
+        private bool _playerEntered;
+        private void OnTriggerEnter(Collider other)
+        {
+            if (_playerEntered) return;
+            
+             _playerEntered = true;
+            _orderService.OrderDelivered();
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderDeliveryTrigger.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 47fbefab729047e5a11d8761e26f75a6
+timeCreated: 1763737623

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderDispenser.cs

@@ -0,0 +1,31 @@
+using DG.Tweening;
+using UnityEngine;
+
+namespace Code.Gameplay.Orders.Order
+{
+    public class OrderDispenser : MonoBehaviour
+    {
+        [SerializeField] private Transform hatch;
+        [SerializeField] private OrderBox order;
+        
+        private bool _activated; 
+        public void ThrowOrder()
+        {
+            hatch.DORotate(new Vector3(-130f, 0, 0), 0.2f);
+
+            order.rigidbody.isKinematic = false;
+            order.rigidbody.AddForce(-transform.forward * 10f, ForceMode.Impulse);
+        }
+
+        // DEBUG TODO ДИМКА УДАЛИ И ПРОПИШИ В СВОЕЙ ЛОГИКЕ
+        public void OnTriggerEnter(Collider other)
+        {
+            if(_activated) return;
+            _activated = true;
+            
+            ThrowOrder();
+            order.SwitchMode();
+        }
+        // DEBUG
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderDispenser.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e50e3c42f5ee45e0b1087e0dbf7dd0f4
+timeCreated: 1763556675

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderGiveTrigger.cs

@@ -0,0 +1,18 @@
+using Reflex.Attributes;
+using UnityEngine;
+
+namespace Code.Gameplay.Orders.Order
+{
+    public class OrderGiveTrigger : MonoBehaviour
+    {
+        [Inject] private IOrderService _orderService;
+        private bool _playerEntered;
+        private void OnTriggerEnter(Collider other)
+        {
+            if (_playerEntered) return;
+            
+            _playerEntered = true;
+            _orderService.OrderGive();
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderGiveTrigger.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d3966e4798d243abba9d85b9ad8aef33
+timeCreated: 1763742374

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderService.cs

@@ -0,0 +1,68 @@
+using Code.Configs;
+using UnityEngine;
+using Random = UnityEngine.Random;
+
+namespace Code.Gameplay.Orders.Order
+{
+    public class OrderService : IOrderService
+    {
+        public event IOrderService.OrderProgressDelegate OnOrderGiven;
+        public event IOrderService.OrderProgressDelegate OnOrderRecieved;
+        public event IOrderService.OrderDeliveredDelegate OnOrderDelivered;
+        public event IOrderService.OrderFailureDelegate OnOrderFailure;
+        
+        private OrderState _orderState;
+        public OrderState OrderState => _orderState;
+
+        private float _deliveryTimer;
+        public float DeliveryTimer => _deliveryTimer;
+
+        private Vector2 _timeBounds;
+        private float _koefRooms, _koefOvertime;
+        
+        private int _roomsPassed; 
+        
+        public OrderService(OrderServiceConfig config)
+        {
+            _orderState = OrderState.Delivered;
+            
+            _timeBounds = config.timeBounds;
+            _koefRooms = config.koefRooms;
+            _koefOvertime = config.koefOvertime;
+        }
+        
+        public void RoomPassed() => _roomsPassed++;
+        public void DecreaseTimer(float delta) => _deliveryTimer -= delta;
+
+        // Вызываются триггерами
+        public void OrderGive()
+        {
+            _orderState = OrderState.Given;
+            _roomsPassed = 0;
+            
+            _deliveryTimer = Random.Range(_timeBounds.x, _timeBounds.y);
+            OnOrderGiven?.Invoke(_deliveryTimer);
+        }
+
+        public void OrderRecieved()
+        {
+            _orderState = OrderState.Recieved;
+            OnOrderRecieved?.Invoke(_deliveryTimer);
+        }
+        public void OrderFailed() => OnOrderFailure?.Invoke();
+
+        public void OrderDelivered()
+        {
+            if (_orderState != OrderState.Recieved)
+            {
+                OnOrderFailure?.Invoke();
+                return;
+            }
+            
+            _orderState = OrderState.Delivered;
+            
+            int score = (int)(_koefRooms * _roomsPassed + _deliveryTimer * _koefOvertime);
+            OnOrderDelivered?.Invoke(score, _deliveryTimer);
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b324c2a1be1546868cddf779445b286a
+timeCreated: 1763559110

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderState.cs

@@ -0,0 +1,9 @@
+namespace Code.Gameplay.Orders.Order
+{
+    public enum OrderState
+    {
+        Delivered,
+        Given,
+        Recieved,
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Orders/Order/OrderState.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0a8980a0cc034110ab3ccd948d40956b
+timeCreated: 1763559535

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

@@ -0,0 +1,9 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Player
+{
+    public class ArmsMeshProvider : MonoBehaviour
+    {
+        [SerializeField] public Animator ArmsAnimator;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cfe65f613bc54b4098acdba0d3fdd2a2
+timeCreated: 1763730814

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

@@ -7,9 +7,10 @@ namespace Code.Gameplay.Player
 {
     public interface IPlayerFactory
     {
-        PlayerHealth CreatePlayerHealth(int count = -1);
-        PlayerMoney CreatePlayerMoney(int count = 0);
+        PlayerHealth CreatePlayerHealth(int count = -1); 
         UniTask<CharacterProvider> CreatePlayer();
         void ReleasePlayer(CharacterProvider characterProvider);
+        UniTask<ArmsMeshProvider> CreateArms(Transform papochka);
+        void ReleaseArms(ArmsMeshProvider arms);
     }
 }

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

@@ -0,0 +1,10 @@
+namespace Code.Gameplay.Player
+{
+    public interface IPlayerScore
+    {
+        event PlayerScore.OnScoreGetDelegate OnScoreGet;
+        event PlayerScore.OnScoreLooseDelegate OnScoreLoose;
+        int Score { get; }
+        void UpdateScore(int amount);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5084b2568ebd4cddaef2154e5ad1f870
+timeCreated: 1763890486

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

@@ -7,12 +7,13 @@ namespace Code.Gameplay.Player
     {
         private static readonly int Velocity = Animator.StringToHash("Velocity");
         
-        [SerializeField] private Animator playerAnimator;
+        private Animator _playerAnimator;
+        public void SetAnimator(Animator animator) => _playerAnimator = animator;
         [SerializeField] private KinematicCharacterMotor kinematicCharacterMotor;
         
         private void SetVelocity(float velocity)
         {
-            playerAnimator.SetFloat(Velocity, velocity);
+            _playerAnimator.SetFloat(Velocity, velocity);
         }
 
         private void Update()

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

@@ -21,8 +21,7 @@ namespace Code.Gameplay.Player
             if (count < 0) count = _playerConfig.maxHealth;
             
             return new(count);
-        }
-        public PlayerMoney CreatePlayerMoney(int count = 0) => new(count);
+        } 
 
         public async UniTask<CharacterProvider> CreatePlayer()
         {
@@ -42,5 +41,8 @@ namespace Code.Gameplay.Player
             ((PlayerProvider)_playerProvider).ClearPlayer();
             Addressables.ReleaseInstance(characterProvider.gameObject);
         }
+
+        public async UniTask<ArmsMeshProvider> CreateArms(Transform papochka) => (await Addressables.InstantiateAsync(_playerConfig.armsMeshPrefab, papochka).ToUniTask()).GetComponent<ArmsMeshProvider>();
+        public void ReleaseArms(ArmsMeshProvider arms) => Addressables.ReleaseInstance(arms.gameObject);
     }
 }

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

@@ -28,5 +28,11 @@ namespace Code.Gameplay.Player
             _healthPoints = maxHealthPoints;
             MaxHealthPoints = maxHealthPoints;
         }
+
+        public void InstaKill()
+        {
+            _healthPoints = 0;
+            OnDeath?.Invoke();
+        }
     }
 }

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

@@ -1,26 +0,0 @@
-namespace Code.Gameplay.Player
-{
-    public class PlayerMoney
-    {
-        public delegate void OnMoneyGetDelegate(int count, int money);
-        public event OnMoneyGetDelegate OnMoneyGet;
-        public delegate void OnMoneyLooseDelegate(int count, int money);
-        public event OnMoneyLooseDelegate OnMoneyLoose;
-
-        private int _money;
-        public int Money => _money;
-        
-        public void GiveMoney(int amount)
-        {
-            _money += amount;
-            OnMoneyGet?.Invoke(amount, _money);
-        }
-        public void LooseMoney(int amount)
-        {
-            _money -= amount;
-            OnMoneyLoose?.Invoke(amount, _money);
-        }
-
-        public PlayerMoney(int money) => _money = money;
-    }
-}

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

@@ -0,0 +1,24 @@
+namespace Code.Gameplay.Player
+{
+    public class PlayerScore : IPlayerScore
+    {
+        public delegate void OnScoreGetDelegate(int count, int score);
+
+        public event OnScoreGetDelegate OnScoreGet;
+
+        public delegate void OnScoreLooseDelegate(int count, int score);
+
+        public event OnScoreLooseDelegate OnScoreLoose;
+
+        private int _score;
+        public int Score => _score;
+
+        public void UpdateScore(int amount)
+        {
+            _score += amount;
+            
+            if (amount > 0) OnScoreGet?.Invoke(amount, _score);
+            else OnScoreLoose?.Invoke(amount, _score);
+        }
+    }
+}

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

@@ -2,6 +2,6 @@ namespace Code.Input
 {
     public enum UIActions
     {
-        
+        Continue
     }
 }

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

@@ -1,3 +1,4 @@
+using Code.Gameplay.Orders.Order;
 using UnityEngine;
 using UnityEngine.Serialization;
 
@@ -6,13 +7,13 @@ namespace Code.Scenes.SceneEnvironments
     [System.Serializable]
     public class GameplaySceneEnvironment : CurrentSceneEnvironment
     {
-        [FormerlySerializedAs("sfxTarget")] public Transform debugSfxTarget;
         public Transform playerSpawnPoint;
+        public OrderDispenser debugTube;
 
         public void TransitVariables(GameplaySceneEnvironment env)
         {
-            debugSfxTarget = env.debugSfxTarget;
             playerSpawnPoint = env.playerSpawnPoint;
+            debugTube = env.debugTube;
         }
     }
 }

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

@@ -1,6 +1,9 @@
 using Code.Gameplay.Door;
+using Code.UI;
+using Code.UI.Panels.Etc;
 using UnityEngine;
 using UnityEngine.Experimental.GlobalIllumination;
+using UnityEngine.Serialization;
 
 namespace Code.Scenes.SceneEnvironments
 {
@@ -8,14 +11,22 @@ namespace Code.Scenes.SceneEnvironments
     public class MainMenuEnvironment : CurrentSceneEnvironment
     {
         public Transform cameraPosition;
-        public DamnDoor damnDoor;
-        public Light doorLight;
+        public MainMenuUIVariables uiVariables;
+        public MainMenuButton startButton;
+        public MainMenuButton settingButton;
+        public MainMenuButton exitButton;
+        public Canvas menuButtonsCanvas;
+        public Canvas settingsCanvas;
 
         public void TransitVariables(MainMenuEnvironment env)
         {
             cameraPosition = env.cameraPosition;
-            damnDoor = env.damnDoor;
-            doorLight = env.doorLight;
+            uiVariables = env.uiVariables;
+            startButton = env.startButton;
+            settingButton = env.settingButton;
+            exitButton = env.exitButton;
+            menuButtonsCanvas = env.menuButtonsCanvas;
+            settingsCanvas = env.settingsCanvas;
         }
     }
 }

Game/CourierOld/Assets/Code/Scenes/SceneLoaderService.cs

@@ -30,7 +30,7 @@ namespace Code.Scenes
             callBack?.Invoke();
         }
 
-        public async UniTask LoadSceneAsyncAwaitable(int sceneId, float waitFor = 0)
+        public async UniTask LoadSceneAsyncAwaitable(int sceneId, float waitFor = 0f)
         {
             await UniTask.WhenAll(
                 UniTask.Delay(TimeSpan.FromSeconds(waitFor)),

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

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Code.Audio;
 using Code.Configs;
+using Code.Gameplay.Camera;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
@@ -24,6 +26,11 @@ namespace Code.StaticData
         DrunkenGrandpaConfig DrunkenGrandpaConfig { get; }
         CockroachConfig CockroachConfig { get; }
         FogConfig FogConfig { get; }
+        OrderServiceConfig OrderServiceConfig { get; }
+        OrderBoxConfig OrderBoxConfig { get; }
+        Dictionary<CameraMode, CameraSettingsConfig> CameraSettingsConfigs { get; }
+        Dictionary<AudioSourceType, AudioSourceSettingsConfig> AudioSourceSettingsConfigs { get; }
+        AudioTestClipsConfig AudioTestClipsConfig { get; }
         void Load();
         Task<T> InstantiateAsset<T>(AssetReference assetReference) where T : Behaviour;
     }

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

@@ -1,6 +1,10 @@
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
+using Code.Audio;
 using Code.Configs;
 using Code.Constants;
+using Code.Gameplay.Camera;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
@@ -12,27 +16,45 @@ namespace Code.StaticData
         public AppConfig AppConfig { get; private set; }
         public InputConfig InputConfig { get; private set; }
         public CameraConfig CameraConfig { get; private set; }
+        
         public CharacterConfig CharacterConfig { get; private set; }
-        public UIConfig UIConfig { get; private set; }
         public PlayerConfig PlayerConfig { get; private set; }
+        
+        public UIConfig UIConfig { get; private set; }
+        
         public AudioMixerConfig AudioMixerConfig { get; private set; }
         public SoundtrackListConfig SoundtrackListConfig { get; private set; }
         public SFXListConfig SFXListConfig { get; private set; }
         public DispatcherSoundListConfig DispatcherSoundListConfig { get; private set; }
         public EnemiesSoundListConfig EnemiesSoundListConfig { get; private set; }
+        public AudioTestClipsConfig AudioTestClipsConfig { get; private set; }
+        
         public DrunkenGrandpaConfig DrunkenGrandpaConfig {get; private set;}
         public CockroachConfig CockroachConfig { get; private set; }
         public FogConfig FogConfig { get; private set; }
         
+        public OrderServiceConfig OrderServiceConfig { get; private set; }
+        public OrderBoxConfig OrderBoxConfig { get; private set; }
+
+        public Dictionary<CameraMode, CameraSettingsConfig> CameraSettingsConfigs { get; private set; } = new();
+
+        public Dictionary<AudioSourceType, AudioSourceSettingsConfig> AudioSourceSettingsConfigs { get; private set; } = new();
+
         public void Load()
         {
             InputConfig = Resources.Load<InputConfig>(string.Format(StringPaths.ConfigSingle, "App", "InputConfig"));
             AppConfig = Resources.Load<AppConfig>(string.Format(StringPaths.ConfigSingle, "App", "AppConfig"));
-            CameraConfig = Resources.Load<CameraConfig>(string.Format(StringPaths.ConfigSingle, "App", "CameraConfig"));
             CharacterConfig = Resources.Load<CharacterConfig>(string.Format(StringPaths.ConfigSingle, "App", "CharacterConfig"));
             UIConfig = Resources.Load<UIConfig>(string.Format(StringPaths.ConfigSingle, "App", "UIConfig"));
             PlayerConfig = Resources.Load<PlayerConfig>(string.Format(StringPaths.ConfigSingle, "App", "PlayerConfig"));
-            
+            OrderServiceConfig = Resources.Load<OrderServiceConfig>(string.Format(StringPaths.ConfigSingle, "Gameplay", "OrderServiceConfig"));
+            OrderBoxConfig = Resources.Load<OrderBoxConfig>(string.Format(StringPaths.ConfigSingle, "Gameplay", "OrderBoxConfig"));
+
+            CameraConfig = Resources.Load<CameraConfig>(string.Format(StringPaths.ConfigSingle, "Camera", "CameraConfig"));
+            CameraSettingsConfigs = Resources
+                .LoadAll<CameraSettingsConfig>(string.Format(StringPaths.ConfigMultiple, "Camera"))
+                .ToDictionary(x => x.cameraMode);
+
             LoadAudioConfigs();
             LoadEnemiesConfigs();
         }
@@ -41,9 +63,13 @@ namespace Code.StaticData
         {
             AudioMixerConfig = Resources.Load<AudioMixerConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "AudioMixerConfig"));
             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"));
             DispatcherSoundListConfig = Resources.Load<DispatcherSoundListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "DispatcherSoundListConfig"));
             EnemiesSoundListConfig = Resources.Load<EnemiesSoundListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "EnemiesSoundListConfig"));
+            AudioSourceSettingsConfigs = Resources
+                .LoadAll<AudioSourceSettingsConfig>(string.Format(StringPaths.ConfigMultiple, "Audio"))
+                .ToDictionary(x => x.sourceType);
         }
 
         private void LoadEnemiesConfigs()
@@ -56,6 +82,6 @@ namespace Code.StaticData
         public async Task<T> InstantiateAsset<T>(AssetReference assetReference) where T : Behaviour
         {
             return (await Addressables.InstantiateAsync(assetReference).ToUniTask()).GetComponent<T>();
-        } 
+        }
     }
 }

Game/CourierOld/Assets/Code/UI/Panels/Etc/HoverButton.cs

@@ -9,8 +9,8 @@ namespace Code.UI.Panels.Etc
     {
         public Button button;
         public Action OnPointerEnterEvent, OnPointerExitEvent;
-
-        public void OnPointerEnter(PointerEventData eventData) => OnPointerEnterEvent?.Invoke();
-        public void OnPointerExit(PointerEventData eventData) => OnPointerExitEvent?.Invoke();
+        
+        public virtual void OnPointerEnter(PointerEventData eventData) => OnPointerEnterEvent?.Invoke();
+        public virtual void OnPointerExit(PointerEventData eventData) => OnPointerExitEvent?.Invoke();
     }
 }

Game/CourierOld/Assets/Code/UI/Panels/Etc/MainMenuButton.cs

@@ -0,0 +1,26 @@
+using DG.Tweening;
+using TMPro;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace Code.UI.Panels.Etc
+{
+    public class MainMenuButton : HoverButton
+    {
+        public TMP_Text text;
+        
+        public Color defaultColor;
+        public Color hoverColor;
+        
+        public override void OnPointerEnter(PointerEventData eventData) 
+        {
+            text.DOColor(hoverColor, 0.2f);
+            OnPointerEnterEvent?.Invoke();
+        }
+        public override void OnPointerExit(PointerEventData eventData)
+        {
+            text.DOColor(defaultColor, 0.2f);
+            OnPointerExitEvent?.Invoke();
+        }
+    }
+}

Game/CourierOld/Assets/Code/UI/Panels/Etc/MainMenuButton.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b0e3f905e0af4d1ab624b1dfe8eaa1df
+timeCreated: 1763762376

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

@@ -1,3 +1,4 @@
+using TMPro;
 using UnityEngine;
 using UnityEngine.UI;
 
@@ -5,15 +6,25 @@ namespace Code.UI
 {
     public class GameOverPanel : UIElement
     {
+        [SerializeField] private TMP_Text scoreText;
+        [SerializeField] private TMP_Text gameOverText;
         [SerializeField] private Image _background;
         
+        public void UpdateScoreText(int score) => scoreText.text = score.ToString();
+        
         public override void Hide()
         {
             _background.enabled = false;
+            scoreText.enabled = false;
+            gameOverText.enabled = false;
+            base.Hide();
         }
         public override void Show()
         {
             _background.enabled = true;
+            scoreText.enabled = true;
+            gameOverText.enabled = true;
+            base.Show();
         }
     }
 }

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

@@ -1,11 +1,11 @@
+using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
 using DG.Tweening;
 using TMPro;
 using UnityEngine;
-using UnityEngine.Serialization;
 using UnityEngine.UI;
 
-namespace Code.UI
+namespace Code.UI.Panels
 {
     public class GameplayPanel : UIElement
     {
@@ -16,12 +16,17 @@ namespace Code.UI
         [SerializeField] private float dispatcherTransitionTime = 0.5f;
         [Header("Timer")]
         [SerializeField] private TMP_Text timer;
+        [SerializeField] private Image timerBackGround;
+        public TMP_Text Timer => timer;
+        [SerializeField] private RectTransform timerHiddenPosition;
+        [SerializeField] private RectTransform timerShownPosition;
+        [SerializeField] private float timerTransitionTime = 0.5f;
         [Header("HealthBar")]
         [SerializeField] private Image healthBar;
         [Header("MoneyBar")]
         [SerializeField] private TMP_Text moneyText;
-
-        private void MoneyUpdate(int count, int money) 
+        
+        private void ScoreUpdate(int count, int money) 
         {
             // TODO Анимация получения\потери
             moneyText.text = money.ToString();
@@ -32,35 +37,47 @@ namespace Code.UI
             float fillAmount = (float)health.HealthPoints / health.MaxHealthPoints;
             healthBar.fillAmount = fillAmount;
         }
-        public void Initialize(PlayerMoney money, PlayerHealth health)
+        private IOrderService _orderService;
+        
+        public void Initialize(IPlayerScore score, PlayerHealth health, IOrderService orderService)
         {
-            money.OnMoneyGet += MoneyUpdate;
-            money.OnMoneyLoose += MoneyUpdate;
-            MoneyUpdate(0,money.Money);
+            score.OnScoreGet += ScoreUpdate;
+            score.OnScoreLoose += ScoreUpdate;
+            ScoreUpdate(0,score.Score);
             
             health.OnDamage += HealthUpdate;
             HealthUpdate(0,health);
-        }
-        private void Update()
-        {
-            timer.text = Time.deltaTime.ToString();
+            
+            _orderService = orderService;
         }
 
+        private void Update()
+        {
+            if (_orderService != null) timer.text = ((int)_orderService.DeliveryTimer).ToString();
+        }
+        private int _dispatcherCalls;
         public void SummonDispatcher()
         {
             // TODO
-            dispatcher.transform.DOMoveX(dispatcherShownPosition.position.x, dispatcherTransitionTime); 
+            _dispatcherCalls++;
+            dispatcher.transform.DOMoveY(dispatcherShownPosition.position.y, dispatcherTransitionTime); 
         }
         public void CloseDispatcher()
         {
-            dispatcher.transform.DOMoveX(dispatcherHiddenPosition.position.x,  dispatcherTransitionTime);
+            _dispatcherCalls--;
+            if (_dispatcherCalls > 0) return;
+            dispatcher.transform.DOMoveY(dispatcherHiddenPosition.position.y,  dispatcherTransitionTime);
             // TODO 
         }
-        public override void Hide()
+        public void ShowTimer()
         {
+            // TODO
+            timerBackGround.transform.DOMoveX(timerShownPosition.position.x, timerTransitionTime); 
         }
-        public override void Show()
+        public void HideTimer()
         {
-        }
+            timerBackGround.transform.DOMoveX(timerHiddenPosition.position.x,  timerTransitionTime);
+            // TODO 
+        } 
     }
 }