Merge branch 'Dev' into Generator

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetGroupSortSettings.asset

@@ -13,4 +13,5 @@ MonoBehaviour:
   m_Name: AddressableAssetGroupSortSettings
   m_EditorClassIdentifier: Unity.Addressables.Editor::UnityEditor.AddressableAssets.Settings.GroupSchemas.AddressableAssetGroupSortSettings
   sortOrder:
+  - 7e9d70e73e500eb9287683466ebf646f
   - d447fc60305c17a17bf20948ab295a45

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetSettings.asset

@@ -15,7 +15,7 @@ MonoBehaviour:
   m_DefaultGroup: d447fc60305c17a17bf20948ab295a45
   m_currentHash:
     serializedVersion: 2
-    Hash: 90c715b85c1e0904b3dc61a9ed460206
+    Hash: f3899bd8b96717b1b70a2db310a9fcf2
   m_OptimizeCatalogSize: 0
   m_BuildRemoteCatalog: 0
   m_CatalogRequestsTimeout: 0
@@ -60,6 +60,7 @@ MonoBehaviour:
   m_BuildAddressablesWithPlayerBuild: 0
   m_overridePlayerVersion: '[UnityEditor.PlayerSettings.bundleVersion]'
   m_GroupAssets:
+  - {fileID: 11400000, guid: ba51c0b85beab267d8f41a72df4fb657, type: 2}
   - {fileID: 11400000, guid: 7c592a6445170e8379910601b962cb30, type: 2}
   m_BuildSettings:
     m_LogResourceManagerExceptions: 1

Game/CourierOld/Assets/AddressableAssetsData/AssetGroups/Audio.asset

@@ -0,0 +1,21 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: bbb281ee3bf0b054c82ac2347e9e782c, type: 3}
+  m_Name: Audio
+  m_EditorClassIdentifier: Unity.Addressables.Editor::UnityEditor.AddressableAssets.Settings.AddressableAssetGroup
+  m_GroupName: Audio
+  m_GUID: 7e9d70e73e500eb9287683466ebf646f
+  m_SerializeEntries: []
+  m_ReadOnly: 0
+  m_Settings: {fileID: 11400000, guid: 2588e84eb64800d0781c574a37fa48d8, type: 2}
+  m_SchemaSet:
+    m_Schemas: []

Game/CourierOld/Assets/AddressableAssetsData/AssetGroups/Audio.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ba51c0b85beab267d8f41a72df4fb657
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -15,18 +15,65 @@ MonoBehaviour:
   m_GroupName: Default Local Group
   m_GUID: d447fc60305c17a17bf20948ab295a45
   m_SerializeEntries:
+  - 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
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 1f79c7b1e492a4ea2a8d666cdead0c52
+    m_Address: Audio/Dispatcher/take_damage4
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 23e11d2c8a4f12f4ea9a7a43d1118464
     m_Address: Gameplay
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 3d195945b1fbf114a88457cba466bc2b
+  - m_GUID: 29bff8011973e4e519906b9da8fca0fc
-    m_Address: Assets/Resources_moved/Rooms/Room2.prefab
+    m_Address: Audio/Dispatcher/late3
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 4472dd84628855c4085cacaec19efa29
+  - m_GUID: 29ee630aab7bbef8799dc76ed0c239f7
-    m_Address: Assets/Resources_moved/Rooms/Room1.prefab
+    m_Address: Audio/Dispatcher/late4
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 2f6134357dc2a5641a846a7478ce4c2c
+    m_Address: bravo!
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 31f16c866d3224ab8a7e0fabf3745ec5
+    m_Address: Audio/Dispatcher/late5
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 3831a36e0c8e48f659517a6bb99378b6
+    m_Address: cbar_hit1
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -35,8 +82,64 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 4f660559d76c3ed42a7c34a0b16487f7
+  - m_GUID: 4bd64d1fcecc9c6b09d81e78b7dcfebe
-    m_Address: Assets/Resources_moved/Rooms/Room3.prefab
+    m_Address: Audio/Dispatcher/take_damage1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 735f38402ea347fa381408293503a24e
+    m_Address: Audio/Dispatcher/receiving_an_order1
+    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
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 803e40b883c823b89a91aa8b9d9fc483
+    m_Address: valve_sound
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 81844a99f5b786b41b831174f8fb6d3a
+    m_Address: Prefabs/Player/CharacterController
+    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
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 8c2be26d359d54063825fedfad7a493b
+    m_Address: Audio/Dispatcher/late2
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 8fa89a492fc3a3768a0f0ba1bb7080e0
+    m_Address: Audio/Dispatcher/late1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 9293380a88bf6736889be29722b94269
+    m_Address: Audio/AudioSource
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: a306df57f348ce7cf900d0b9431739ee
+    m_Address: launch_selectmenu
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -50,11 +153,26 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: cab4b1ff78dd6b1fba61aa165aa17b4d
+    m_Address: Audio/Dispatcher/receiving_an_order2
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: ebe18293a5ef86704b23dad3a1786476
+    m_Address: Half-Life01
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: f23b9fce9594618e5b75845f1cae50de
     m_Address: LoadingScreen
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: f74a409bf11b25148ad305acc05b14f5
+    m_Address: Audio/Dispatcher/take_damage2
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   m_ReadOnly: 0
   m_Settings: {fileID: 11400000, guid: 2588e84eb64800d0781c574a37fa48d8, type: 2}
   m_SchemaSet:

Game/CourierOld/Assets/AddressableAssetsData/ProfileDataSourceSettings.asset

@@ -0,0 +1,28 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7e3976da977cb49238499ea3b4c237ae, type: 3}
+  m_Name: ProfileDataSourceSettings
+  m_EditorClassIdentifier: Unity.Addressables.Editor::UnityEditor.AddressableAssets.Settings.ProfileDataSourceSettings
+  profileGroupTypes:
+  - m_GroupTypePrefix: Built-In
+    m_Variables:
+    - m_Suffix: BuildPath
+      m_Value: '[UnityEngine.AddressableAssets.Addressables.BuildPath]/[BuildTarget]'
+    - m_Suffix: LoadPath
+      m_Value: '{UnityEngine.AddressableAssets.Addressables.RuntimePath}/[BuildTarget]'
+  environments: []
+  currentEnvironment:
+    id: 
+    projectId: 
+    projectGenesisId: 
+    name: 
+    isDefault: 0

Game/CourierOld/Assets/AddressableAssetsData/ProfileDataSourceSettings.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7e2b0e48c9649284a9541c4d1dad59c2
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -1,41 +1,76 @@
-using Code.App.StateMachine;
+using Code.App.StateMachine; 
-using Code.Scenes;
+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 (!_gameOverPanel) return;
-            if (damnTimer <= float.Epsilon) ToMainMenu();
+            
+            _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,95 +1,182 @@
+using System.Globalization;
+using System.Reflection.Emit;
+using System.Threading.Tasks;
+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.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 Reflex.Injectors;
+using UnityEngine;
 using UnityEngine.InputSystem;
+using UnityEngine.SceneManagement;
 
 namespace Code.App.AppStates
 {
     public class GameplayState : BaseState<AppStateMachineContext>
-    {
+    { 
-        private PlayerHealth _playerHealth;
-        private PlayerMoney _playerMoney;
-
-        private bool _uiLoaded, _sceneLoaded;
         
+        private PlayerHealth _playerHealth;
+        private IPlayerScore _playerScore;
+        
+        private IOrderService _orderService;
+
+        private CharacterProvider _playerCharacter;
+
         public GameplayState(AppStateMachineContext context) : base(context)
         {
         }
 
         public override void EnterState()
         {
-            _uiLoaded = _sceneLoaded = false;
+            Context.LoadingManager
-            
+                .RegisterLoading(LoadingWork.LoadScene)
-            Context.UIService.LoadingScreen.Show();
+                .RegisterLoading(LoadingWork.LoadUI)
-            
+                // .RegisterLoading(LoadingWork.LoadModelResource)
-            _playerMoney = Context.PlayerFactory.CreatePlayerMoney();
+                .RegisterLoading(LoadingWork.LoadAudio); 
+             
             _playerHealth = Context.PlayerFactory.CreatePlayerHealth();
-            
+
+            _playerHealth.OnDamage += PlayerDamageTaken;
             _playerHealth.OnDeath += EndGame;
             
-            Context.SceneLoaderService.LoadSceneAsync((int)SceneIds.MovementDev, callBack: OnSceneLoaded); // TODO Фабрика игрока Nada
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.None);
             
-            Context.UIService.SwitchPanelTo(UIPanel.Gameplay, callback: PostUILoaded);
-
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.GiveHealth, GiveHealth);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.GiveMoney, GiveMoney);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.LooseHealth, LooseHealth);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.LooseMoney, LooseMoney);
-        }
-        
-        private void OnSceneLoaded()
-        {
-            _sceneLoaded = true;
-            CheckIfLoaded();
-        }
-
-        private void PostUILoaded()
-        {
-            ((GameplayPanel)Context.UIService.CurrentPanel).Initialize(_playerMoney, _playerHealth);
-            _uiLoaded = true;
-            CheckIfLoaded();
-        }
-
-        private void CheckIfLoaded()
-        {
-            if(!_uiLoaded || !_sceneLoaded) return;
-            
-            Context.UIService.LoadingScreen.Hide();
-            
-            Context.CameraStateMachine.SwitchState(CameraMode.FirstPerson);
             Context.InputService.EnableMap(ActionMappings.Gameplay);
+            
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, InstaKillDEBUG); 
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, RoomPassedDEBUG);
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.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
+            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 WaitForLoad()
+        { 
+            await UniTask.WhenAll(
+                Context.UIService.AsyncSwitchPanelTo(UIPanel.Gameplay), 
+                Context.AudioFactory.WarmGameplayMusic(),
+                Context.AudioFactory.WarmSFX(),
+                Context.AudioFactory.WarmDispatcher()
+            );
+            
+            Context.LoadingManager 
+                .UnregisterLoading(LoadingWork.LoadUI) 
+                .UnregisterLoading(LoadingWork.LoadAudio);
+
+            InputServiceInitialize();
+
+            MusicInitialize();
         }
 
-
+        private async void AfterSceneLoaded()
-        // Debug
-        private void GiveHealth(InputAction.CallbackContext context)
         {
-            _playerHealth.GetDamage(-1);
+            Context.LoadingManager 
+                .RegisterLoading(LoadingWork.LoadModelResource);
+            
+            Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
+            Context.LoadingManager.OnLoadingEnded += AfterPlayerLoaded;
+
+            await UniTask.WhenAll( 
+                WaitForPlayerArmsToInitialize(),
+                WaitForPlayerCharacterLoad() 
+            );
+            
+            Context.LoadingManager 
+                .UnregisterLoading(LoadingWork.LoadModelResource); 
         }
 
-        private void LooseHealth(InputAction.CallbackContext context)
+        private void AfterPlayerLoaded()
         {
-            _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 GiveMoney(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()
         {
-            _playerMoney.GiveMoney(100);
+            _playerHealth.InstaKill();
-            ((GameplayPanel)(Context.UIService.CurrentPanel)).SummonDispatcher();
         }
-
+        private void OrderRecieved(float time)
-        private void LooseMoney(InputAction.CallbackContext context)
         {
-            _playerMoney.LooseMoney(100);
+            Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.Recieve1,(int)DispatcherSounds.Recieve2));
-            ((GameplayPanel)(Context.UIService.CurrentPanel)).CloseDispatcher();
+        }
+        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 PlayerDamageTaken(int damage, PlayerHealth health)
+        {
+            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()
@@ -101,16 +188,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.GiveHealth, GiveHealth);
+
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.GiveMoney, GiveHealth);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, InstaKillDEBUG); 
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.LooseHealth, LooseHealth);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, RoomPassedDEBUG);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.LooseMoney, LooseMoney);
+            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,11 +1,16 @@
+using Code.App.Loading;
 using Code.App.StateMachine;
+using Code.Audio;
 using Code.Gameplay.Camera;
 using Code.Gameplay.Camera.CameraStates;
+using Code.Gameplay.Door;
 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.Extensions;
 using UnityEngine;
 using UnityEngine.SceneManagement;
@@ -14,61 +19,87 @@ namespace Code.App.AppStates
 {
     public class MainMenuState : BaseState<AppStateMachineContext>
     {
-        private bool _uiLoaded, _sceneLoaded;
         public MainMenuState(AppStateMachineContext context) : base(context)
         {
         }
 
         public override void EnterState()
         {
-            _uiLoaded = _sceneLoaded = false;
+            Context.LoadingManager
+                .RegisterLoading(LoadingWork.LoadScene)
+                .RegisterLoading(LoadingWork.LoadUI)
+                .RegisterLoading(LoadingWork.LoadAudio);
             
-            Context.UIService.LoadingScreen.Show();
+            // Context.UIService.LoadingScreen.Show();
-            
-            Context.SceneLoaderService.LoadSceneAsync((int)SceneIds.MainMenu, callBack: SceneLoaded); 
-             
-            Context.UIService.SwitchPanelTo(UIPanel.MainMenu, PostUILoaded);
 
-            Context.CameraStateMachine.SwitchState(CameraMode.Static);
+            Context.CameraStateMachine.SwitchState(CameraMode.MainMenu);
+            
+            Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.MainMenu);
+            Context.LoadingManager.OnLoadingEnded += AfterSceneLoaded;
+
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            WaitForLoad();
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
 
-        private void PostUILoaded()
+        private async UniTaskVoid WaitForLoad()
         {
-            ((MainMenuPanel)Context.UIService.CurrentPanel).startButton.onClick.AddListener(StartGame);
+            await UniTask.WhenAll(
-            ((MainMenuPanel)Context.UIService.CurrentPanel).exitButton.onClick.AddListener(ExitGame);
+                Context.UIService.AsyncSwitchPanelTo(UIPanel.MainMenu),
+                Context.AudioFactory.WarmMenuMusic()
+            );
+            Context.LoadingManager
+                .UnregisterLoading(LoadingWork.LoadUI)
+                .UnregisterLoading(LoadingWork.LoadAudio);
             
-            _uiLoaded = true;
+            InitializeAudio();
-            
+
-            CheckIfLoaded();
+            InitializeInput();
         }
 
-        private void SceneLoaded()
+        private void AfterSceneLoaded()
         {
-            var hui = ((MainMenuEnvironment)SceneManager.GetActiveScene()
+            var mainMenuEnvironment = (MainMenuEnvironment)SceneManager.GetActiveScene()
-                .GetSceneContainer().Resolve<CurrentSceneEnvironment>());
+                .GetSceneContainer().Resolve<CurrentSceneEnvironment>();
-            
-            ((StaticState)Context.CameraStateMachine.CurrentBaseState).LookTarget = 
-                hui.cameraTarget;
-            
-            ((BaseCameraState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(hui.cameraPosition);
 
+            InitializeUI(mainMenuEnvironment);
+
+            InitializeCamera(mainMenuEnvironment);
             
-            _sceneLoaded = true;
+            Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
-            
-            CheckIfLoaded();
         }
 
-        private void CheckIfLoaded()
+        private void InitializeCamera(MainMenuEnvironment mainMenuEnvironment)
+        {
+            ((Gameplay.Camera.CameraStates.MainMenuState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(mainMenuEnvironment
+                .cameraPosition);
+        }
+
+        private void InitializeInput()
         {
-            if(!_uiLoaded || !_sceneLoaded) return;
-            
-            Context.UIService.LoadingScreen.Hide();
-            
             Context.InputService.EnableMap(ActionMappings.MainMenu);
-            
-            base.EnterState();
         }
-        
+
+        private void InitializeAudio()
+        {
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Menu);
+            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Menu);
+        }
+
+        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);
+
+            mainMenuEnvironment.menuButtonsCanvas.worldCamera = Context.CameraStateMachine.Camera;
+        }
+
         public override void Tick()
         {
         }
@@ -87,6 +118,7 @@ namespace Code.App.AppStates
         public override void ExitState()
         {
             Context.InputService.DisableMap(ActionMappings.MainMenu);
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Menu, callback: Context.AudioFactory.ReleaseMenuMusic);
 
             base.ExitState();
         }

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

@@ -1,8 +1,11 @@
-using System.Threading.Tasks;
+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.Orders.Order;
 using Code.Gameplay.Player;
 using Code.Input;
 using Code.Scenes;
@@ -13,7 +16,6 @@ using Cysharp.Threading.Tasks;
 using Reflex.Core;
 using Reflex.Injectors;
 using UnityEngine;
-using UnityEngine.AddressableAssets;
 using UnityEngine.InputSystem;
 
 namespace Code.App
@@ -26,12 +28,19 @@ namespace Code.App
             
             InstallInfrastructureUnit(containerBuilder, staticDataService);
 
+            containerBuilder.AddSingleton(typeof(LoadingManager), typeof(ILoadingManager));
+            
             containerBuilder.AddSingleton(typeof(InputService), typeof(IInputService));
             containerBuilder.AddSingleton(typeof(PlayerFactory), typeof(IPlayerFactory));
 
             InitializeCamera(containerBuilder, staticDataService);
+            
             containerBuilder.AddSingleton(typeof(UIFactory), typeof(IUIFactory));
             containerBuilder.AddSingleton(typeof(UIService), typeof(IUIService));
+            
+            containerBuilder.AddSingleton(typeof(AudioFactory), typeof(IAudioFactory));
+            containerBuilder.AddSingleton(typeof(AudioService), typeof(IAudioService));
+            
             containerBuilder.AddSingleton(typeof(SceneLoaderService), typeof(ISceneLoaderService));
             
             containerBuilder.OnContainerBuilt += Bootstrap;
@@ -63,18 +72,31 @@ namespace Code.App
             staticDataService.Load();
 
             containerBuilder.AddSingleton(staticDataService, typeof(IStaticDataService));
+            
             containerBuilder.AddSingleton(staticDataService.InputConfig.inputActionAsset, typeof(InputActionAsset));
             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));
+            
             containerBuilder.AddSingleton(staticDataService.UIConfig, typeof(UIConfig));
-            // containerBuilder.AddSingleton(staticDataService.UIConfig.canvasPrefab, typeof(Canvas));
+            
-            // containerBuilder.AddSingleton(staticDataService.UIConfig.uiElementsPrefabs, typeof(UIElement[]));
+            containerBuilder.AddSingleton(staticDataService.AudioMixerConfig, typeof(AudioMixerConfig));
+            containerBuilder.AddSingleton(staticDataService.SoundtrackListConfig, typeof(SoundtrackListConfig));
+            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 bool _onUiLoaded;
         private AppStateMachine _appStateMachine;
+
         private void Bootstrap(Container container)
         {
             _appStateMachine = container.Resolve<AppStateMachine>();
@@ -84,20 +106,29 @@ namespace Code.App
             CameraStateMachine cameraStateMachine = container.Resolve<CameraStateMachine>();
             AttributeInjector.Inject(cameraStateMachine.StateMachineContext, container);
             cameraStateMachine.Initialize();
-            
-            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen);
-            DontDestroyOnLoad(loadingScreen);
-            
-            IUIService uiService = container.Resolve<IUIService>();
-            uiService.Initialize(loadingScreen.GetComponent<LoadingScreen>());
-            
-            TryStartGame();
-        }
 
-        private void TryStartGame()
+#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).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),
+                container.Resolve<IAudioService>().Initialize()
+                );
+            
+            loadingManager.UnregisterLoading(LoadingWork.Bootstrap);
             
-            // TODO: поменяно для теста
             _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

@@ -0,0 +1,37 @@
+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
+{
+    public class GameplaySceneInstaller : MonoBehaviour, IInstaller
+    {
+        [SerializeField] private GameplaySceneEnvironment _gameplaySceneEnvironment;
+        
+        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)
+        {
+            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
+            
+            GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
+
+            env.TransitVariables(_gameplaySceneEnvironment);
+            
+            loadingManager
+                .UnregisterLoading(LoadingWork.LoadScene);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 88584fd4361b46f6a7326440cd95ce69
+timeCreated: 1763144580

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

@@ -1,7 +1,8 @@
+using Code.App.Loading;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Reflex.Core;
-using UnityEngine;
+using UnityEngine; 
 
 namespace Code.App.SceneInstallers
 {
@@ -21,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,3 +1,5 @@
+using Code.App.Loading;
+using Code.Audio;
 using Code.Gameplay.Camera;
 using Code.Gameplay.Player;
 using Code.Input;
@@ -9,11 +11,14 @@ 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; }
         [Inject] public CameraStateMachine CameraStateMachine { get; private set; }
         [Inject] public IUIService UIService { get; private set; }
         [Inject] public IPlayerFactory PlayerFactory { get; private set; }
+        [Inject] public IAudioFactory AudioFactory { get; private set; }
+        [Inject] public IAudioService AudioService { get; private set; }
     }
 }

Game/CourierOld/Assets/Code/Audio.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 9ce1e20f4ee9be6709bf9022546bcb07
+guid: a1937581573e47844bb593bd62310b89
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

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

@@ -0,0 +1,31 @@
+namespace Code.Audio
+{ 
+    public enum SFXSounds
+    {
+        Crowbar,
+        Shot357
+    }
+    public enum UISounds
+    {
+        Crowbar
+    }
+    public enum EnemiesSounds
+    {
+        Bastard,
+        Bravo
+    }
+    public enum DispatcherSounds
+    {
+        Recieve1,
+        Recieve2,
+        TakeDamage1,
+        TakeDamage2,
+        TakeDamage3,
+        TakeDamage4,
+        Late1,
+        Late2,
+        Late3,
+        Late4,
+        Late5
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 907b506ceac843ebb509a8e5298af540
+timeCreated: 1762888870

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

@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using Code.Configs;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+using UnityEngine.Audio;
+using UnityEngine.ResourceManagement.AsyncOperations;
+using Object = UnityEngine.Object;
+
+namespace Code.Audio
+{
+    public class AudioFactory : IAudioFactory
+    {
+        public AudioMixer AudioMixer { get; private set; }
+        private AssetReference _audioSourcePrefab;
+        
+        private AssetReference[] _peacefulSoundtrack;
+        private AssetReference[] _actionSoundtrack;
+        private AssetReference[] _menuSoundtrack;
+        private AssetReference[] _SFX;
+        private AssetReference[] _enemies;
+        private AssetReference[] _dispatcher;
+        private AssetReference[] _character;
+        
+        private AsyncOperationHandle<IList<AudioClip>> _menuMusicHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _actionMusicHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _peacefulMusicHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _SFXHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _enemiesHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _dispatcherHandle;
+
+        public Dictionary<MusicType, List<AudioClip>> MusicDictionary { get; private set; } = new();
+        public List<AudioClip> SFXAudios { get; private set; } = new();
+        public List<AudioClip> EnemiesAudios { get; private set; } = new();
+        public List<AudioClip> DispatcherAudios { get; private set; } = new();
+
+        public AudioFactory(AudioMixerConfig audioMixerConfig, 
+            SoundtrackListConfig soundtrackListConfig,
+            SFXListConfig sfxListConfig, 
+            EnemiesSoundListConfig enemiesSoundListConfig,
+            DispatcherSoundListConfig dispatcherSoundListConfig
+            )
+        {
+            AudioMixer = audioMixerConfig.audioMixerAsset;
+            _audioSourcePrefab = audioMixerConfig.audioSourcePrefab;
+            
+            _peacefulSoundtrack = soundtrackListConfig.peacefulSoundtrack;
+            _actionSoundtrack = soundtrackListConfig.actionSoundtrack;
+            _menuSoundtrack = soundtrackListConfig.menuSoundtrack;
+            _SFX = sfxListConfig.SFX;
+            _enemies = enemiesSoundListConfig.enemies;
+            _dispatcher = dispatcherSoundListConfig.dispatcher;
+            
+            MusicDictionary.Add(MusicType.Menu, new ());
+            MusicDictionary.Add(MusicType.Peaceful, new ());
+            MusicDictionary.Add(MusicType.Action, new ());
+        }
+
+        public async UniTask LoadAudioSourcePrefab(Action<GameObject> callback) =>
+            callback?.Invoke(await Addressables.LoadAssetAsync<GameObject>(_audioSourcePrefab));
+
+        public async UniTask WarmGameplayMusic( )
+        {
+            _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());
+        }
+        public void ReleaseActionMusic()
+        {
+            MusicDictionary[MusicType.Action].Clear();
+            _actionMusicHandle.Release();
+        }
+        public void ReleasePeacefulMusic()
+        {
+            MusicDictionary[MusicType.Peaceful].Clear();
+            _peacefulMusicHandle.Release();
+        }
+        public async UniTask WarmMenuMusic( )
+        {            
+            _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()
+        {
+            MusicDictionary[MusicType.Menu].Clear();
+            // foreach (var assetReference in _menuSoundtrack) assetReference.ReleaseAsset();
+            _menuMusicHandle.Release();
+        }
+        public async UniTask WarmSFX( )
+        {            
+            _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.Union);
+            
+            await _SFXHandle.ToUniTask();
+             
+        }
+        public void ReleaseSFX()
+        {
+            SFXAudios.Clear();
+            _SFXHandle.Release();
+        }
+        public async UniTask WarmEnemies( )
+        {            
+            _enemiesHandle = Addressables.LoadAssetsAsync<AudioClip>(_enemies, OnEnemiesLoaded, Addressables.MergeMode.Union);
+            
+            await _enemiesHandle.ToUniTask();
+             
+        }
+
+        public void ReleaseEnemies()
+        {
+            EnemiesAudios.Clear();
+            _enemiesHandle.Release();
+        }
+
+        public async UniTask WarmDispatcher( )
+        {            
+            _dispatcherHandle = Addressables.LoadAssetsAsync<AudioClip>(_dispatcher, OnDispatcherLoaded, Addressables.MergeMode.Union);
+            
+            await _dispatcherHandle.ToUniTask();
+             
+        }
+
+        public void ReleaseDispatcher()
+        {
+            DispatcherAudios.Clear();
+            _dispatcherHandle.Release();
+        }
+
+        private void OnMenuTrackLoaded(AudioClip audioClip)
+        {
+            MusicDictionary[MusicType.Menu].Add(audioClip);
+        }
+        private void OnActionTrackLoaded(AudioClip audioClip)
+        {
+            MusicDictionary[MusicType.Action].Add(audioClip);
+        }
+        private void OnPeacefulTrackLoaded(AudioClip audioClip)
+        {
+            MusicDictionary[MusicType.Peaceful].Add(audioClip);
+        }
+        private void OnSFXLoaded(AudioClip audioClip)
+        {
+            SFXAudios.Add(audioClip);
+        }
+        private void OnEnemiesLoaded(AudioClip audioClip)
+        {
+            EnemiesAudios.Add(audioClip);
+        }
+        private void OnDispatcherLoaded(AudioClip audioClip)
+        {
+            DispatcherAudios.Add(audioClip);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5a4b48740d194d4dafa1732f96d71687
+timeCreated: 1762626915

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

@@ -0,0 +1,179 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Code.Configs;
+using Code.Constants;
+using Cysharp.Threading.Tasks;
+using Reflex.Attributes;
+using Unity.VisualScripting;
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+using UnityEngine.Audio;
+using Random = UnityEngine.Random;
+
+namespace Code.Audio
+{
+    public class AudioService : IAudioService
+    {
+        private IAudioFactory _audioFactory;
+
+        private AudioMixer _mixer;
+        private AudioSource _actionMusicSource;
+        private AudioSource _peacefulMusicSource;
+
+        private AudioMixerGroup _masterGroup,
+            // _musicGroup,
+            // _actionMusicGroup,
+            // _peacefulMusicGroup,
+            _SFXGroup,
+            _creaturesGroup,
+            _dispatcherGroup,
+            _courierGroup,
+            _enemiesGroup;
+
+        private readonly AudioSourcePool _audioSourcePool;
+
+        private Dictionary<AudioSnapshotState, AudioMixerSnapshot> _snapshots = new();
+        private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
+        
+        public AudioService(IAudioFactory audioFactory, Dictionary<AudioSourceType,AudioSourceSettingsConfig> settings)
+        {
+            _audioFactory = audioFactory;
+            _audioSourcePool = new(settings);
+            _settings = settings;
+        }
+
+        public async UniTask Initialize()
+        {
+            // _mixer = await _audioFactory.CreateMixer();
+            _mixer = _audioFactory.AudioMixer;
+
+            _masterGroup = _mixer.FindMatchingGroups(AudioGroups.MasterGroup)[0];
+            // _actionMusicGroup = _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0];
+            // _peacefulMusicGroup = _mixer.FindMatchingGroups(AudioGroups.PeacefulMusoup)[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];
+            _courierGroup = _mixer.FindMatchingGroups(AudioGroups.CourierMusicGroup)[0];
+            _enemiesGroup = _mixer.FindMatchingGroups(AudioGroups.EnemiesMusicGroup)[0];
+
+            _snapshots[AudioSnapshotState.None] = _mixer.FindSnapshot(AudioGroups.NoneSnapshot);
+            _snapshots[AudioSnapshotState.Peaceful] = _mixer.FindSnapshot(AudioGroups.PeacefulSnapshot);
+            _snapshots[AudioSnapshotState.Action] = _mixer.FindSnapshot(AudioGroups.ActionSnapshot);
+            _snapshots[AudioSnapshotState.Menu] = _mixer.FindSnapshot(AudioGroups.MenuSnapshot);
+
+            await _audioFactory.LoadAudioSourcePrefab(_audioSourcePool.Initialize);
+
+        }
+
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+        private Dictionary<MusicType, CancellationTokenSource> _cancellationTokenSources = new();
+        private Dictionary<MusicType, AudioSource> _musicAudioSources = new();
+        private Dictionary<MusicType, AudioMixerGroup> _musicAudioGroups = new();
+
+        public async UniTaskVoid PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType musicType)
+        {
+            if(!_musicAudioSources[musicType])
+            {
+                _musicAudioSources[musicType] = _audioSourcePool.GetSource();
+                _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,
+                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)
+        {
+            TransitToSnapshot(audioSnapshotState, time);
+
+            await UniTask.WaitForSeconds(time);
+            
+            _cancellationTokenSources[musicType].Cancel();
+
+            callback?.Invoke();
+        }
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
+        public void StopMusic()
+        {
+            _peacefulMusicSource.Stop();
+            _actionMusicSource.Stop();
+        }
+
+        public void GladlyAskToStopMusic(Action callback = null)
+        {
+            TransitToSnapshot(AudioSnapshotState.None);
+            _peacefulMusicSource.Stop();
+            _actionMusicSource.Stop();
+
+            callback?.Invoke();
+        }
+
+        public void TransitToSnapshot(AudioSnapshotState state, float time = 1f)
+        {
+            _snapshots[state].TransitionTo(time);
+        }
+
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+        public void PlaySFX(SFXSounds sfxId, Vector3 position)
+        {
+            _audioSourcePool.PlayOneShot(_audioFactory.SFXAudios[(int)sfxId], position, _SFXGroup);
+        }
+
+        public void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position)
+        {
+            _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position, _enemiesGroup);
+        }
+
+        // Чинить долго и дорого пусть Артёмов будет много, ведь он наш друг
+        public event IAudioService.OnAudioPlayingDelegate OnDispatcherStarted;
+        public event IAudioService.OnAudioPlayingDelegate OnDispatcherEnded;
+        public void PlayDispatcher(DispatcherSounds dispatcherSoundId)
+        {
+            OnDispatcherStarted?.Invoke();
+            _audioSourcePool.PlayOneShot(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup, AudioSourceType.NoBlend, () => OnDispatcherEnded?.Invoke());
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bf44cb051308463494bd930f2a3d31e4
+timeCreated: 1762625073

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

@@ -0,0 +1,10 @@
+namespace Code.Audio
+{
+    public enum AudioSnapshotState
+    {
+        None,
+        Peaceful,
+        Action,
+        Menu
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 29adaf8e912649d9b91c09735e36840a
+timeCreated: 1762808301

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

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using Code.Configs;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.Audio;
+using UnityEngine.Pool;
+using Object = UnityEngine.Object;
+
+namespace Code.Audio
+{
+    public class AudioSourcePool
+    {
+        // 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;
+            
+            // Create a pool with the four core callbacks.
+            _pool = new ObjectPool<AudioSource>(
+                createFunc: CreateItem,
+                // actionOnGet: OnGet,
+                actionOnRelease: OnRelease,
+                actionOnDestroy: OnDestroyItem,
+                collectionCheck: true,   // helps catch double-release mistakes
+                defaultCapacity: 10,
+                maxSize: 20
+            );
+        }
+
+        // Creates a new pooled GameObject the first time (and whenever the pool needs more).
+        private AudioSource CreateItem()
+        {
+            AudioSource audioSource = Object.Instantiate(_sourcePrefab).GetComponent<AudioSource>();
+            audioSource.name = "PooledAudioSource";
+            Object.DontDestroyOnLoad(audioSource);
+            return audioSource;
+        }
+
+        // Called when an item is taken from the pool.
+        private void OnGet(AudioSource source)
+        {
+            //source.gameObject.SetActive(true);
+        }
+
+        // Called when an item is returned to the pool.
+        private void OnRelease(AudioSource source)
+        {
+            source.Stop();
+            //source.gameObject.SetActive(false);
+        }
+
+        // Called when the pool decides to destroy an item (e.g., above max size).
+        private void OnDestroyItem(AudioSource source)
+        {
+            Object.Destroy(source.gameObject);
+        }
+        
+        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 = _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 PlayOneShot(AudioClip clip, AudioMixerGroup audioMixerGroup, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
+        {
+            AudioSource source = _pool.Get();
+            source.PlayOneShot(clip);
+            source.spatialBlend = _settings[audioSourceType].spatialBlend;
+            source.outputAudioMixerGroup = audioMixerGroup;
+            
+            await UniTask.WaitUntilValueChanged(source, x => x.isPlaying);
+            onComplete?.Invoke();
+            _pool.Release(source);
+        } 
+        public AudioSource GetSource() => _pool.Get();
+        public void ReleaseSource(AudioSource source) => _pool.Release(source);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 370b6a43a74744ff9d90a99991b104f7
+timeCreated: 1762852042

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

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+using UnityEngine.Audio;
+
+namespace Code.Audio
+{
+    public interface IAudioFactory
+    {
+        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();
+        void ReleaseActionMusic();
+        UniTask WarmMenuMusic();
+        void ReleaseMenuMusic();
+        UniTask WarmSFX();
+        void ReleaseSFX();
+        UniTask WarmEnemies();
+        void ReleaseEnemies();
+        UniTask WarmDispatcher();
+        void ReleaseDispatcher();
+        void ReleasePeacefulMusic();
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ea837e1ca08a4846b7f4ce2df771bf65
+timeCreated: 1762804793

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

@@ -0,0 +1,24 @@
+using System;
+using Cysharp.Threading.Tasks;
+using UnityEngine;
+
+namespace Code.Audio
+{
+    public interface IAudioService
+    {
+        UniTask Initialize();
+        UniTaskVoid PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType musicType);
+        UniTaskVoid GladlyAskToStopMusic(MusicType musicType, AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null);
+        void StopMusic();
+        void GladlyAskToStopMusic(Action callback = null);
+        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);
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 30521fadcce84848ae88363e915bceb4
+timeCreated: 1762804728

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

@@ -0,0 +1,9 @@
+namespace Code.Audio
+{
+    public enum MusicType
+    {
+        Menu,
+        Peaceful,
+        Action
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 74ff08d5f1b741f69e37fc06fb07ae8d
+timeCreated: 1763151897

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

@@ -0,0 +1,13 @@
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+using UnityEngine.Audio;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(menuName = "Config/Audio/Mixer", fileName = "AudioMixerConfig")]
+    public class AudioMixerConfig : ScriptableObject
+    {
+        public AudioMixer audioMixerAsset;
+        public AssetReference audioSourcePrefab;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 353cee8946ca43efbbcda905d7b32ae1
+timeCreated: 1762624627

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/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/CharacterSoundListConfig.cs

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

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 83304a98bbdc4e7c9c7c643653ae1368
+timeCreated: 1762625438

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

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

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8a6f6ffb8f5242899791719801791945
+timeCreated: 1762625431

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

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

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e73ac7f7e3cd4db8ada95f63d73c2d1d
+timeCreated: 1762625425

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

@@ -1,4 +1,5 @@
 using UnityEngine;
+using UnityEngine.AddressableAssets;
 
 namespace Code.Configs
 {
@@ -6,5 +7,8 @@ namespace Code.Configs
     public class PlayerConfig : ScriptableObject
     {
         public int maxHealth;
+        
+        public AssetReference characterPrefab;
+        public AssetReference armsMeshPrefab;
     }
 }

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

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

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: be49de18297645009c1e2092f382a670
+timeCreated: 1762625417

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

@@ -0,0 +1,13 @@
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(menuName = "Config/Audio/SoundtrackList", fileName = "SoundtrackListConfig")]
+    public class SoundtrackListConfig : ScriptableObject
+    {
+        public AssetReference[] peacefulSoundtrack;
+        public AssetReference[] actionSoundtrack;
+        public AssetReference[] menuSoundtrack;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6d4b28e4552d456d99550b6d91467345
+timeCreated: 1762624980

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

@@ -10,4 +10,22 @@ namespace Code.Constants
     {
         public const string LoadingScreen = "LoadingScreen";
     }
+    public static class AudioGroups
+    {
+        public const string MasterGroup = "Master";
+        public const string SFXGroup = "SFX";
+        public const string CreaturesGroup = "Creatures";
+        public const string MusicGroup = "Music";
+        public const string PeacefulMusicGroup = "Peaceful";
+        public const string ActionMusicGroup = "Action";
+        public const string DispatcherMusicGroup = "Dispatcher";
+        public const string CourierMusicGroup = "Courier";
+        public const string EnemiesMusicGroup = "Enemies";
+        
+        public const string PeacefulSnapshot = "Peaceful";
+        public const string ActionSnapshot = "Action";
+        public const string NoneSnapshot = "None";
+        public const string MenuSnapshot = "Menu";
+        public const string MenuMusicGroup = "Menu";
+    }
 }

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

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

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

@@ -9,13 +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.MainMenu, new MainMenuState(StateMachineContext));
             States.Add(CameraMode.FirstPerson, new FirstPersonState(StateMachineContext));
             States.Add(CameraMode.ThirdPerson, new ThirdPersonState(StateMachineContext));
             
-            CurrentBaseState = States[CameraMode.Static];
+            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/BaseCameraState.cs

@@ -117,7 +117,7 @@ namespace Code.Gameplay.Camera.CameraStates
         protected virtual void HandleRotationInput(float deltaTime, Vector3 rotationInput, out Quaternion targetRotation)
         {
             // Вращение вокруг вертикальной оси (горизонтальный поворот)
-            var rotationFromInput = Quaternion.Euler(FollowTransform.up * (rotationInput.x * RotationSpeed));
+            var rotationFromInput = Quaternion.Euler(Vector3.up * (rotationInput.x * RotationSpeed));
             PlanarDirection = rotationFromInput * PlanarDirection;
             var planarRotation = Quaternion.LookRotation(PlanarDirection, FollowTransform.up);
             

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

@@ -0,0 +1,30 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Camera.CameraStates
+{
+    public class MainMenuState : BaseCameraState, ICameraState
+    {
+        public MainMenuState(CameraStateMachineContext context) : base(context) { }
+
+        public override void EnterState()
+        {
+            base.EnterState();
+            
+            Camera.fieldOfView = Context.CameraSettingsConfigs[CameraMode.MainMenu].fov;
+        }
+
+        protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)
+        {
+            Camera.transform.position = FollowTransform.position;
+        }
+        
+        public CameraMode GetCameraMode() => CameraMode.MainMenu;
+
+        protected override void HandleRotationInput(float deltaTime, Vector3 rotationInput,
+            out Quaternion targetRotation)
+        {
+            if(FollowTransform) Camera.transform.rotation = FollowTransform.rotation;
+            targetRotation = Camera.transform.rotation;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8e4b2fa3af4b4ba78ab79ca154f05fb4
+timeCreated: 1763547110

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/Abilities/WallClimbMechanic.cs

@@ -15,6 +15,12 @@ namespace Code.Gameplay.Character.Controller.Abilities
         private readonly float _minWallClimbSpeed;
         // Пороговый косинус стены
         public float WallNormalThreshold { get; }
+        
+        private bool _hasClimbedThisWallSession;
+        private float _wallClimbCooldownTimer;
+        private readonly float _wallClimbCooldownDuration = 1.5f;
+        
+        public bool IsClimbingActive { get; private set; }
 
         // Конструктор механики залазания на стену
         public WallClimbMechanic(float wallClimbSpeedFactor, float minWallClimbSpeed, float wallDetectionAngleThreshold)
@@ -26,21 +32,32 @@ namespace Code.Gameplay.Character.Controller.Abilities
         }
 
         // Обработка столкновения при движении (вызывается при ударе о препятствие)
-        public void OnMovementHit(KinematicCharacterMotor motor, Vector3 hitNormal)
+        public bool TryClimbWall(KinematicCharacterMotor motor, Vector3 hitNormal)
         {
             // Проверяем, что это вертикальная или почти вертикальная поверхность (стена)
             var dotWithUp = Vector3.Dot(hitNormal, motor.CharacterUp);
-            if (Mathf.Abs(dotWithUp) > WallNormalThreshold) return; // Не стена — это пол или потолок
+            
+            if (Mathf.Abs(dotWithUp) > WallNormalThreshold) 
+            {
+                // Сбрасываем сессию, если коснулись пола/потолка → выход из "режима стены"
+                _hasClimbedThisWallSession = false;
+                return false;
+            }
 
+            // Запрещаем повторное залазание в рамках одной сессии
+            if (_hasClimbedThisWallSession || _wallClimbCooldownTimer > 0f)
+                return false;
+            
             // Получаем текущую скорость персонажа
             var currentVelocity = motor.Velocity;
 
             // Проекция скорости на направление к стене (отрицательная, если летим в стену)
             var velocityIntoWall = Vector3.Dot(currentVelocity, -hitNormal);
-
+            
             // Если движемся в стену с достаточной скоростью
             if (velocityIntoWall > _minWallClimbSpeed)
             {
+                _wallClimbCooldownTimer = _wallClimbCooldownDuration;
                 // Преобразуем часть горизонтальной скорости в вертикальную
                 var verticalBoost = velocityIntoWall * _wallClimbSpeedFactor;
 
@@ -49,6 +66,26 @@ namespace Code.Gameplay.Character.Controller.Abilities
 
                 // Предотвращаем заземление и повторное применение в этом кадре
                 motor.ForceUnground();
+                _hasClimbedThisWallSession = true;
+                IsClimbingActive = true;
+                
+                return true;
+            }
+            
+            return false;
+        }
+        
+        public void ResetWallClimbSession()
+        {
+            _hasClimbedThisWallSession = false;
+            IsClimbingActive = false;
+        }
+        
+        public void TickCooldown(float deltaTime)
+        {
+            if (_wallClimbCooldownTimer > 0f)
+            {
+                _wallClimbCooldownTimer -= deltaTime;
             }
         }
     }

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

@@ -17,6 +17,12 @@ namespace Code.Gameplay.Character.Controller.Abilities
         private Vector3 _lastWallNormal;
         private float _lastWallContactHeight;
         private float _leanFactor;
+        private float _leanSign;
+        private Vector3 _leanDirection;
+        
+        private Vector3 _lastWallContactPoint;
+        private bool _isLeaningOnWall;
+        private const float WallProximityThreshold = 0.6f;
 
         public WallLeanMechanic(float maxLeanAngle, float leanSharpness, float heightScale)
         {
@@ -32,29 +38,93 @@ namespace Code.Gameplay.Character.Controller.Abilities
         }
 
         // Вызывается из OnMovementHit
-        public void OnWallContact(Vector3 wallNormal, float contactHeight)
+        public void OnWallContact(KinematicCharacterMotor motor, Vector3 wallNormal, float contactHeight)
         {
+            // Только если это действительно стена (не пол/потолок)
+            var dotWithUp = Vector3.Dot(wallNormal, motor.CharacterUp);
+            if (Mathf.Abs(dotWithUp) > 0.7f) // ~45°, можно настроить
+                return;
+
             _lastWallNormal = wallNormal;
-            _lastWallContactHeight = contactHeight; }
+            _lastWallContactHeight = contactHeight;
+            _lastWallContactPoint = motor.TransientPosition;
+
+            // Пересчитываем направление наклона
+            _leanDirection = -_lastWallNormal;
+            _leanDirection = Vector3.ProjectOnPlane(_leanDirection, motor.CharacterUp).normalized;
+
+            _leanSign = 1;
+            
+            // what the fuck
+            if (_leanDirection.x != 0)
+            {
+                switch (_leanDirection.x)
+                {
+                    case -1 or 1 when motor.CharacterRight.x > 0.1f:
+                        _leanSign = -1;
+                        break;
+                    case -1 or 1 when Mathf.Abs(motor.CharacterRight.x) < 0.1f:
+                        _leanDirection = new Vector3(0, 0, -1);
+                        break;
+                }
+            }
+            else
+            {
+                switch (_leanDirection.z)
+                {
+                    case 1 when Mathf.Abs(motor.CharacterRight.z) < 0.1f:
+                        _leanSign = -1;
+                        break;
+                    case -1 when motor.CharacterRight.z < -0.1f:
+                    case 1 when motor.CharacterRight.z > 0.1f:
+                        _leanDirection = new Vector3(-1, 0, 0);
+                        break;
+                    case -1 when motor.CharacterRight.z > 0.1f:
+                    case 1 when motor.CharacterRight.z < -0.1f:
+                        _leanDirection = new Vector3(1, 0, 0);
+                        break;
+                }
+            }
+            
+            _isLeaningOnWall = true;
+        }
 
         // Обновление каждый кадр
         public void UpdateLean(KinematicCharacterMotor motor, float deltaTime)
         {
             if (!_characterTransform) return;
-            
-            var isGrounded = motor.GroundingStatus.IsStableOnGround;
 
-            if (!isGrounded)
+            var currentPosition = motor.TransientPosition;
+
+            var isStillNearWall = false;
+            if (_isLeaningOnWall && _lastWallNormal != Vector3.zero)
             {
-                var heightDelta = motor.TransientPosition.y - _lastWallContactHeight;
+                var toWall = currentPosition - _lastWallContactPoint;
-                var targetLeanFactor = Mathf.Clamp01(heightDelta * _heightScale);
+                var distanceToWallPlane = Mathf.Abs(Vector3.Dot(toWall, _lastWallNormal));
-                _leanFactor = Mathf.Lerp(_leanFactor, targetLeanFactor, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
+                isStillNearWall = distanceToWallPlane <= WallProximityThreshold;
             }
-            else
+
+            if (_isLeaningOnWall)
+            {
+                var isBelowContactHeight = currentPosition.y < _lastWallContactHeight;
+
+                if (!isStillNearWall || isBelowContactHeight)
+                {
+                    _isLeaningOnWall = false;
+                }
+                else
+                {
+                    var heightDelta = currentPosition.y - _lastWallContactHeight;
+                    var targetLeanFactor = Mathf.Clamp01(heightDelta * _heightScale);
+                    _leanFactor = Mathf.Lerp(_leanFactor, targetLeanFactor, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
+                }
+            }
+
+            if (!_isLeaningOnWall)
             {
                 _leanFactor = Mathf.Lerp(_leanFactor, 0f, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
             }
-
+            
             ApplyLeanRotation(motor);
         }
 
@@ -66,13 +136,11 @@ namespace Code.Gameplay.Character.Controller.Abilities
                 return;
             }
 
-            var leanDirection = -_lastWallNormal;
+            if (_leanDirection.sqrMagnitude < 0.01f) return;
-            leanDirection = Vector3.ProjectOnPlane(leanDirection, motor.CharacterUp).normalized;
 
-            if (leanDirection.sqrMagnitude < 0.01f) return;
+            var leanAngle = _leanSign * _leanFactor * _maxLeanAngle;
-
+            var leanAxis = Vector3.Cross(motor.CharacterUp, _leanDirection);
-            var leanAngle = _leanFactor * _maxLeanAngle;
+            var leanRotation = Quaternion.AngleAxis(leanAngle, leanAxis);
-            var leanRotation = Quaternion.AngleAxis(leanAngle, Vector3.Cross(motor.CharacterUp, leanDirection));
             _characterTransform.localRotation = leanRotation;
         }
     }

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

@@ -33,9 +33,43 @@ namespace Code.Gameplay.Character.Controller
         private GroundMovementSystem _groundMovement;
         private AirMovementSystem _airMovement;
         
+        public void SetPosition(Vector3 position) => motor.SetPosition(position);
+        public void SetRotation(Quaternion rotation) => motor.SetRotation(rotation);
+        
         // Инициализация контроллера
-        private void Awake()
+        // private void Awake()
+        // {
+        //     // Инициализация подсистем с параметрами из конфига
+        //     _inputHandler = new CharacterInputHandler(
+        //         _characterConfig.sprintAngleThreshold
+        //     );
+        //     _slideMechanic = new SlideMechanic(
+        //         _characterConfig.slideSpeed,
+        //         _characterConfig.slideDuration,
+        //         _characterConfig.slideCooldown
+        //     );
+        //     _wallClimbMechanic = new WallClimbMechanic(
+        //         _characterConfig.wallClimbSpeedFactor,
+        //         _characterConfig.minWallClimbSpeed,
+        //         _characterConfig.wallDetectionAngleThreshold
+        //     );
+        //     _wallLeanMechanic = new WallLeanMechanic(
+        //         _characterConfig.maxWallLeanAngle,
+        //         _characterConfig.wallLeanSharpness,
+        //         _characterConfig.wallLeanHeightScale
+        //     );
+        //     _groundMovement = new GroundMovementSystem(
+        //         _characterConfig.maxStableMoveSpeed,
+        //         _characterConfig.sprintMoveSpeed,
+        //         _characterConfig.stableMovementSharpness,
+        //         _characterConfig.jumpSpeed
+        //     );
+        //     _airMovement = new AirMovementSystem(_characterConfig.gravity);
+        // }
+        [Inject]
+        private void Construct(CharacterConfig characterConfig)
         {
+            _characterConfig = characterConfig;
             // Инициализация подсистем с параметрами из конфига
             _inputHandler = new CharacterInputHandler(
                 _characterConfig.sprintAngleThreshold
@@ -62,25 +96,31 @@ namespace Code.Gameplay.Character.Controller
                 _characterConfig.jumpSpeed
             );
             _airMovement = new AirMovementSystem(_characterConfig.gravity);
-        }
+            
-
+            
-        // Текущий режим камеры для адаптации поведения
-        private CameraMode _currentCameraMode = CameraMode.FirstPerson;
-
-        // Инициализация контроллера
-        private void Start()
-        {
             motor.CharacterController = this; // Регистрация этого контроллера в движке
             _inputHandler.FirstPersonCameraRotation =
                 motor.Transform.rotation; // Начальное вращение совпадает с персонажемс
             _wallLeanMechanic.SetCharacterTransform(characterTransform);
         }
+        // Текущий режим камеры для адаптации поведения
+        private CameraMode _currentCameraMode = CameraMode.FirstPerson;
+
+        // Инициализация контроллера
+        // private void Start()
+        // {
+        //     motor.CharacterController = this; // Регистрация этого контроллера в движке
+        //     _inputHandler.FirstPersonCameraRotation =
+        //         motor.Transform.rotation; // Начальное вращение совпадает с персонажемс
+        //     _wallLeanMechanic.SetCharacterTransform(characterTransform);
+        // }
 
         // Обработка и преобразование входных данных от персонажа
         public void SetInputs(ref CharacterInputs inputs)
         {
             // Обновляем таймер перезарядки слайда
             _slideMechanic.TickCooldown(Time.deltaTime);
+            _wallClimbMechanic.TickCooldown(Time.deltaTime);
 
             // Если активен слайд - игнорируем весь остальной ввод
             if (_slideMechanic.IsSliding)
@@ -109,8 +149,7 @@ namespace Code.Gameplay.Character.Controller
         // Обновление вращения персонажа на основе входных данных
         public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
         {
-            // ВО ВРЕМЯ СЛАЙДА НЕ ОБНОВЛЯЕМ ВРАЩЕНИЕ - ПЕРСОНАЖ СМОТРИТ ПРЯМО
+            if (_slideMechanic.IsSliding || _wallClimbMechanic.IsClimbingActive)  return;
-            if (_slideMechanic.IsSliding) return;
 
             switch (_currentCameraMode)
             {
@@ -141,7 +180,6 @@ namespace Code.Gameplay.Character.Controller
                 // Заготовка на будущее (если понадобится)
                 case CameraMode.Static:
                 case CameraMode.Cinematic:
-                case CameraMode.Bogdan: // Скорее всего юзлес, но пускай будет
                 default:
                     break;
             }
@@ -196,6 +234,11 @@ namespace Code.Gameplay.Character.Controller
             {
                 _slideMechanic.EndSlide();
             }
+            
+            if (motor.GroundingStatus.IsStableOnGround)
+            {
+                _wallClimbMechanic.ResetWallClimbSession();
+            }
         }
 
         // Метод вызывается после обновления персонажа
@@ -220,13 +263,8 @@ namespace Code.Gameplay.Character.Controller
         public void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
             ref HitStabilityReport hitStabilityReport)
         {
-            _wallClimbMechanic.OnMovementHit(motor, hitNormal);
+            if (_wallClimbMechanic.TryClimbWall(motor, hitNormal))
-            
+                _wallLeanMechanic.OnWallContact(motor, hitNormal, motor.TransientPosition.y);
-            var dotWithUp = Vector3.Dot(hitNormal, motor.CharacterUp);
-            if (Mathf.Abs(dotWithUp) <= _wallClimbMechanic.WallNormalThreshold)
-            {
-                _wallLeanMechanic.OnWallContact(hitNormal, motor.TransientPosition.y);
-            }
         }
 
         // Обработка отчета о стабильности столкновения

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

@@ -113,7 +113,7 @@ namespace Code.Gameplay.Character.Controller.Input
             var cameraForward = cameraRotation * Vector3.forward;
             
             // Проецируем на горизонтальную плоскость
-            var horizontalForward = Vector3.ProjectOnPlane(cameraForward, motor.CharacterUp).normalized;
+            var horizontalForward = Vector3.ProjectOnPlane(cameraForward, Vector3.up).normalized;
             
             // Если проекция вырождена, используем текущее направление персонажа
             if (horizontalForward.sqrMagnitude < 0.01f)

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

@@ -0,0 +1,60 @@
+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;
+
+namespace Code.Gameplay.Character.Core
+{
+    public class CharacterProvider : MonoBehaviour
+    {
+        [Inject] private CameraStateMachine _cameraStateMachine; // Стейт-машина камеры (нужна для транзакций и т.п.)
+        [SerializeField] private CustomCharacterController customCharacterController; // Компонент управления персонажем
+        public CustomCharacterController CustomCharacterController => customCharacterController;
+        
+        [SerializeField] private Transform cameraFollowPoint; // Точка следования камеры (уровень глаз для FirstPerson)
+        public Transform GetFollowTransform() => cameraFollowPoint;
+        
+        [Inject] private IInputService _inputService; // Сервис ввода через DI
+
+        [SerializeField] private PlayerAnimator _animator;
+        public PlayerAnimator PlayerAnimator => _animator;
+
+        public void Teleport(Vector3 position, Quaternion rotation)
+        {
+            customCharacterController.SetPosition(position);
+            customCharacterController.SetRotation(rotation);
+        }
+        // Обработка ввода для движения персонажа
+        private void HandleCharacterInput()
+        {
+            // Создаем структуру ввода с полной информацией о камере
+            var inputs = new CharacterInputs();
+
+            // Получаем данные движения из Input System
+            var moveInput = _inputService.MoveInput;
+            inputs.MoveAxisForward = moveInput.y; // Vertical ось (W/S или Up/Down)
+            inputs.MoveAxisRight = moveInput.x; // Horizontal ось (A/D или Left/Right)
+            inputs.JumpPressed = _inputService.JumpPressed; // Прыжки (Space)
+            inputs.SprintPressed = true;//_inputService.SprintPressed; // Спринт (Shift)
+            inputs.SlidePressed = _inputService.SlidePressed; // Слайд (Ctrl)
+            inputs.CameraMode = ((ICameraState)_cameraStateMachine.CurrentBaseState).GetCameraMode();
+
+            // Передаем информацию о камере для адаптивного поведения
+            inputs.CameraRotation = ((BaseCameraState)_cameraStateMachine.CurrentBaseState).GetCameraRotation();
+            inputs.CameraPlanarDirection = ((BaseCameraState)_cameraStateMachine.CurrentBaseState).GetPlanarDirection();
+
+            // Передаем ввод в контроллер персонажа
+            customCharacterController.SetInputs(ref inputs);
+        }
+
+        // Обновление логики каждый кадр
+        private void Update()
+        {
+            // Обработка ввода для движения в Update (физика)
+            HandleCharacterInput();
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b2d4b8256c1f4b3facf6b8d0a7d5256b
+timeCreated: 1763217123

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b7ba7b62b1aa47c48dc82ac8d8e8530e
+timeCreated: 1763548306

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

@@ -0,0 +1,48 @@
+using DG.Tweening;
+using UnityEngine;
+
+namespace Code.Gameplay.Door
+{
+    public class CinematicDoorOpening
+    {
+        private MainMenuDoor _mainMenuDoor;
+        private Light _doorLight;
+
+        public CinematicDoorOpening(MainMenuDoor mainMenuDoor, Light doorLight)
+        {
+            _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;
+            }
+
+            _mainMenuDoor.Petlya.DORotate(new Vector3(0, -10, 0), 1f);
+        }
+
+        public void Close()
+        {
+            _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/CinematicDoorOpening.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: deda0339570d44609dd62eafd9c6215f
+timeCreated: 1763548908

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

@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Door
+{
+    public class MainMenuDoor : MonoBehaviour
+    {
+        [SerializeField] Rigidbody rigidbody;
+        [SerializeField] private Transform petlya;
+        public Transform Petlya => petlya;
+        
+        public void SetPhysics(bool active)
+        {
+            rigidbody.isKinematic = active;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 50a6b5e332704611b19f5a209d4dbffe
+timeCreated: 1763548314

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,
+    }
+}