Merge remote-tracking branch 'origin/movement-dev' into Levels2

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

Game/CourierOld/.vsconfig

@@ -0,0 +1,6 @@
+{
+  "version": "1.0",
+  "components": [
+    "Microsoft.VisualStudio.Workload.ManagedGame"
+  ]
+}

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetSettings.asset

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

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

@@ -15,21 +15,33 @@ MonoBehaviour:
   m_GroupName: Default Local Group
   m_GUID: d447fc60305c17a17bf20948ab295a45
   m_SerializeEntries:
-  - m_GUID: 03e51c504fa7e0624ba855ec35b60bcc
-    m_Address: absolutely
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 111011400ce13ae859c52c757aef859e
-    m_Address: ahfreeman
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 144ab5188f8ad7a0a92c75703bd12e60
     m_Address: launch_upmenu1
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 16562a5c87213914cad415f10c65a3b0
+    m_Address: "Assets/Resources_moved/Audio/Music/LASKX3I - \u041F\u0440\u043E\u0442\u0438\u0432
+      \u0446\u0430\u0440\u044F (\u041A\u0430\u0440\u0430\u043E\u043A\u0435).mp3"
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 170b1a70ddee4d948abea041b9b805e4
+    m_Address: Assets/Resources_moved/Audio/Music/Half Life Original Soundtrack -
+      Track 8 - Diabolical Adrenaline Guitar.mp3
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 1cc66c0b13a946e1c9ec37026268e144
+    m_Address: Audio/Enemies/pl_metal2
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 1d4767c722c05b5d6b96bb226d378c65
+    m_Address: Assets/Resources_moved/Prefabs/Player/ArmsMesh.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 1d7110a045075b22fa27d62bd5f2784e
     m_Address: 357_shot1
     m_ReadOnly: 0
@@ -40,13 +52,18 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 2301400160a23924eb27c4bdbe797739
+  - m_GUID: 23e11d2c8a4f12f4ea9a7a43d1118464
-    m_Address: 'Audio/Music/Nightmargin (Oneshot OST) - The Prophecy '
+    m_Address: Gameplay
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 23e11d2c8a4f12f4ea9a7a43d1118464
+  - m_GUID: 26d4e4c556527924490b8018cd510eda
-    m_Address: Gameplay
+    m_Address: Assets/Resources_moved/Audio/Enemies/bc_bite2.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 28a6c7a4124141341ab7c2b7dfd3e95b
+    m_Address: Assets/Resources_moved/Prefabs/Levels/Level1 2.prefab
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -60,6 +77,16 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 2c6a984e4a1b42647b48e6b7bc69b158
+    m_Address: Prefabs/Levels/Level6
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 2ed2d93a9f39d4edba511cb7396c7bb6
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/Cockroach.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 2f6134357dc2a5641a846a7478ce4c2c
     m_Address: bravo!
     m_ReadOnly: 0
@@ -75,21 +102,41 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 3f8f2171cc252d953b82083cc16bd1ae
+    m_Address: Assets/Resources_moved/Prefabs/Levels/Level6_1.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 48aebfe8826dc0df79d047b5afbf8f5b
     m_Address: Canvas
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 4b279429428a13040b6d1713122cd0de
+    m_Address: Assets/Resources_moved/Audio/SFX/pl_pain5.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 4bd64d1fcecc9c6b09d81e78b7dcfebe
     m_Address: Audio/Dispatcher/take_damage1
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 7067a5248027e74478f4f0f53ddf06a4
+    m_Address: Prefabs/Rooms/Save1
+    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
@@ -100,6 +147,17 @@ MonoBehaviour:
     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
@@ -120,13 +178,23 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 9d78f017876abed4c9cd8957f1e140cb
+    m_Address: Prefabs/Rooms/Level1_2
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: a306df57f348ce7cf900d0b9431739ee
     m_Address: launch_selectmenu
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: b2c9f83c47783069aabb564f68cb0cbb
+  - m_GUID: aa138b2e21adfbf4bbbfa5bf9d54b8f2
-    m_Address: absolutelynot
+    m_Address: Assets/Resources_moved/Audio/UI/buttonclickrelease.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: ae6ab2c88ae248ce1b6efca892f17659
+    m_Address: Assets/Resources_moved/Audio/Music/TestDeath.ogg
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
@@ -135,16 +203,51 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: b33855c694de89386a25c56cbe463a0e
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/DrunkenGrandpa.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: b37ea8c61cc322afdad529d678612d22
+    m_Address: Assets/Resources_moved/Audio/Enemies/zo_attack2.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: bf87bc9ac43df86be8c818de81d44a54
+    m_Address: Assets/Resources_moved/Audio/SFX/pl_step1.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: c566fc932edefbbee9e53271eac3c560
     m_Address: MainMenu
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: c5a0ad8a615841547ac2ee613af526d8
+    m_Address: Assets/Resources_moved/Audio/SFX/pl_pain2.wav
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: c938de3174f184741925c407a43a47f2
+    m_Address: Prefabs/Rooms/Level1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: cab4b1ff78dd6b1fba61aa165aa17b4d
     m_Address: Audio/Dispatcher/receiving_an_order2
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: e3a3840a7963bf841872cddb02e90151
+    m_Address: Prefabs/Levels/MainMenu 1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: e84e3a3c26ccbd50d92f13627403f148
+    m_Address: Audio/Enemies/rch_walk
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: ebe18293a5ef86704b23dad3a1786476
     m_Address: Half-Life01
     m_ReadOnly: 0
@@ -155,8 +258,8 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: f4b6fa54ecac6cc418f98824491aa17a
+  - m_GUID: f3d7dc64b34919ad7b50a3dd307a935b
-    m_Address: Audio/Music/SANABI - JUSTICE Is Watching You
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/Fog.prefab
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0

Game/CourierOld/Assets/AddressableAssetsData/Linux.meta

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

Game/CourierOld/Assets/AddressableAssetsData/Windows.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 75793e520683ea032ace153b3040cf4e
+guid: d982316b2b4c99747b9e953ae7b9b42f
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

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

@@ -1,41 +1,85 @@
 using Code.App.StateMachine;
+using Code.Audio;
+using Code.Gameplay.Player;
+using Code.Input;
 using Code.Scenes;
+using Code.Scenes.SceneEnvironments;
 using Code.StateMachine;
 using Code.UI;
+using Cysharp.Threading.Tasks;
+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);
+            
+            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Death);
+            
+            Context.AudioService.ApplyStun(5000,0.5f);
+            
+            GameOver().Forget();
             
             base.EnterState();
         }
-        
+
+        private void TryToExit(InputAction.CallbackContext context)
+        {
+            ToMainMenu();
+        }
+
+        private async UniTaskVoid GameOver()
+        {
+            await Context.UIService.AsyncSwitchPanelTo(UIPanel.GameOver);
+            
+            _gameOverPanel = (GameOverPanel)Context.UIService.CurrentPanel;
+            _gameOverPanel.Show();
+        }
+
         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();
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Death, callback: Context.AudioFactory.ReleaseDeathMusic); 
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.None);
             base.ExitState();
         }
     }

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

@@ -1,29 +1,36 @@
+using Code.App.Loading;
 using Code.App.StateMachine;
 using Code.Audio;
 using Code.Gameplay.Camera;
+using Code.Gameplay.Camera.CameraStates;
+using Code.Gameplay.Character.Core;
+using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
 using Code.Input;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Code.StateMachine;
 using Code.UI;
+using Code.UI.Panels;
 using Cysharp.Threading.Tasks;
+using DG.Tweening;
+using Reflex.Core;
 using Reflex.Extensions;
 using UnityEngine;
 using UnityEngine.InputSystem;
+using UnityEngine.Rendering;
 using UnityEngine.SceneManagement;
 
 namespace Code.App.AppStates
 {
     public class GameplayState : BaseState<AppStateMachineContext>
-    {
+    { 
-        // DEBUG
-        private Transform _testSFXTransform;
-        // DEBUG
-        
         private PlayerHealth _playerHealth;
-        private PlayerMoney _playerMoney;
+        private IPlayerScore _playerScore;
+        
+        private IOrderService _orderService;
 
+        private CharacterProvider _playerCharacter;
         public GameplayState(AppStateMachineContext context) : base(context)
         {
         }
@@ -31,83 +38,155 @@ namespace Code.App.AppStates
         public override void EnterState()
         {
             Context.UIService.LoadingScreen.Show();
-            
-            _playerMoney = Context.PlayerFactory.CreatePlayerMoney();
-            _playerHealth = Context.PlayerFactory.CreatePlayerHealth();
-            
-            _playerHealth.OnDeath += EndGame;
-            
-            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Peaceful);
-            
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, GiveHealth);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug3, GiveMoney);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug2, LooseHealth);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, LooseMoney);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, PlayDebugSFX);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug6, PlayDebugDispatcher);
 
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Context.LoadingManager
-            WaitForSceneToLoad();
+                .RegisterLoading(LoadingWork.LoadScene)
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+                .RegisterLoading(LoadingWork.LoadUI)
-        }
+                .RegisterLoading(LoadingWork.LoadModelResource)
-
+                .RegisterLoading(LoadingWork.LoadAudio); 
-        private async UniTaskVoid WaitForSceneToLoad()
-        {
-            await UniTask.WhenAll(
-                Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.MovementDev),
-                Context.UIService.AsyncSwitchPanelTo(UIPanel.Gameplay),
-                Context.AudioFactory.WarmGameplayMusic(),
-                Context.AudioFactory.WarmSFX()
-            );
             
-            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Peaceful);
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.None);
-            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Action);
             
-            var sceneEnvironment = ((GameplaySceneEnvironment)SceneManager.GetActiveScene()
-                .GetSceneContainer().Resolve<CurrentSceneEnvironment>());
-
-            _testSFXTransform = sceneEnvironment.debugSfxTarget;
-            
-            ((GameplayPanel)Context.UIService.CurrentPanel).Initialize(_playerMoney, _playerHealth);
-            
-            Context.CameraStateMachine.SwitchState(CameraMode.FirstPerson);
             Context.InputService.EnableMap(ActionMappings.Gameplay);
             
-            Context.UIService.LoadingScreen.Hide();
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, InstaKillDEBUG); 
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, TakeGamageDEBUG);
+
+            Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.DevGen);
+            Context.LoadingManager.OnLoadingEnded += AfterSceneLoaded;
+ 
+            WaitForLoad().Forget(); 
+        }
+        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.WarmDeathMusic(),
+                Context.AudioFactory.WarmSFX(),
+                Context.AudioFactory.WarmDispatcher(),
+                Context.AudioFactory.WarmEnemies(),
+                Context.AudioFactory.WarmCourier()
+            );
+
+            Context.LoadingManager 
+                .UnregisterLoading(LoadingWork.LoadUI) 
+                .UnregisterLoading(LoadingWork.LoadAudio);
+
+            InputServiceInitialize();
+
+            MusicInitialize();
         }
 
-        private void PlayDebugSFX(InputAction.CallbackContext context)
+        private async void AfterSceneLoaded()
         {
-            Context.AudioService.PlaySFX(SFXSounds.Crowbar, _testSFXTransform.position);
+            Context.LoadingManager 
-        }
+                .RegisterLoading(LoadingWork.LoadModelResource);
-        private void PlayDebugDispatcher(InputAction.CallbackContext context)
+
-        {
+            Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
-            Context.AudioService.PlayDispatcher(DispatcherSounds.AhFreeman);
+            Context.LoadingManager.OnLoadingEnded += AfterPlayerLoaded;
-        }
+
-        private void GiveHealth(InputAction.CallbackContext context)
+            Context.PlayerProvider = SceneManager.GetActiveScene().GetSceneContainer().Resolve<IPlayerProvider>();
-        {
+            Context.PlayerFactory = SceneManager.GetActiveScene().GetSceneContainer().Resolve<IPlayerFactory>();
-            _playerHealth.GetDamage(-1);
+            
+            await UniTask.WhenAll( 
+                WaitForPlayerArmsToInitialize(),
+                WaitForPlayerCharacterLoad() 
+            );
+            
+            _playerHealth = Context.PlayerProvider.Health;
+            _playerHealth.OnDamage += PlayerDamageTaken;
+            _playerHealth.OnDeath += EndGame;
+            
+            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);
+
+            _volume = sceneEnvironment.volume;
+            
+            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)
+        {
+            Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.Recieve1,(int)DispatcherSounds.Recieve2));
+        }
+        private void OrderDelivered(int score, float time)
+        { 
+            _gameplayPanel.HideTimer();
+
+            if(time < 0f) Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.Late1,(int)DispatcherSounds.Late2));
+            _playerScore.UpdateScore(score);
+            
+            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Peaceful);
         }
 
-        private void LooseMoney(InputAction.CallbackContext context)
+        private void PlayerDamageTaken(int damage, PlayerHealth health)
         {
-            _playerMoney.LooseMoney(100);
+            Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.TakeDamage1,(int)DispatcherSounds.TakeDamage4));
-            ((GameplayPanel)(Context.UIService.CurrentPanel)).CloseDispatcher();
+            Context.AudioService.PlayCourier((CourierSounds)Random.Range((int)CourierSounds.Damage1,(int)CourierSounds.Damage2));
+            DamageEffectProcess().Forget();
+        }
+
+        // TODO В конфиг
+        private async UniTaskVoid DamageEffectProcess()
+        {
+            _damagePanel.Show();
+            Context.AudioService.ApplyStun(200, 0.5f);
+            
+            DOTween.To(() => _volume.weight, x => _volume.weight = x, 1f, 0.5f);
+            await UniTask.WaitForSeconds(3f);
+            DOTween.To(() => _volume.weight, x => _volume.weight = x, 0f, 1f);
+            Context.AudioService.ApplyStun(5000, 1f);
+            _damagePanel.Hide();
         }
         // DEBUG
+        private void InstaKillDEBUG(InputAction.CallbackContext context)
+        {
+            _playerHealth.InstaKill();
+        }
+        private void TakeGamageDEBUG(InputAction.CallbackContext context)
+        {
+            _playerHealth.GetDamage(1);
+        } 
+        // DEBUG
+        private bool _tickEnabled;
         public override void Tick()
         {
+            if (!_tickEnabled) return;
+            
+            _orderService.DecreaseTimer(Time.deltaTime);
         }
 
         private void EndGame()
@@ -119,20 +198,83 @@ 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.Action, time: 0f, callback: Context.AudioFactory.ReleaseActionMusic);
-            Context.AudioService.GladlyAskToStopMusic(MusicType.Peaceful, callback: Context.AudioFactory.ReleasePeacefulMusic);
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Peaceful, time: 0f, callback: Context.AudioFactory.ReleasePeacefulMusic);
+            Context.AudioFactory.ReleaseCourier();
+            Context.AudioFactory.ReleaseDispatcher();
+            Context.AudioFactory.ReleaseEnemies();
+            Context.AudioFactory.ReleaseSFX();
             
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, GiveHealth);
+
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug3, GiveHealth);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, InstaKillDEBUG); 
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug2, LooseHealth);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, TakeGamageDEBUG);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, LooseMoney);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, PlayDebugSFX);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug6, PlayDebugDispatcher);
             
             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 DamagePanel _damagePanel;
+        private void UIInitialize()
+        {
+            _gameplayPanel = (GameplayPanel)Context.UIService.CurrentPanel;
+            _gameplayPanel.Initialize(_playerScore, _playerHealth, _orderService);
+            Context.AudioService.OnDispatcherStarted += _gameplayPanel.SummonDispatcher;
+            Context.AudioService.OnDispatcherEnded += _gameplayPanel.CloseDispatcher;
+            
+            _damagePanel = _gameplayPanel.DamagePanel;
+        }
+        private void MusicInitialize()
+        {
+            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 Volume _volume;
+        private GameplaySceneEnvironment SceneEnvironmentVariables(Container sceneContainer)
+        {
+            var sceneEnvironment = (GameplaySceneEnvironment)sceneContainer.Resolve<CurrentSceneEnvironment>();
+            
+            return sceneEnvironment;
+        }
     }
 }

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

@@ -1,12 +1,15 @@
+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;
@@ -22,40 +25,81 @@ namespace Code.App.AppStates
 
         public override void EnterState()
         {
-            Context.UIService.LoadingScreen.Show();
+            Context.LoadingManager
+                .RegisterLoading(LoadingWork.LoadScene)
+                .RegisterLoading(LoadingWork.LoadUI)
+                .RegisterLoading(LoadingWork.LoadAudio);
+            
+            // Context.UIService.LoadingScreen.Show();
+
+            Context.CameraStateMachine.SwitchState(CameraMode.MainMenu);
+            
+            Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.MainMenu);
+            Context.LoadingManager.OnLoadingEnded += AfterSceneLoaded;
 
-            Context.CameraStateMachine.SwitchState(CameraMode.Static);
-        
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            WaitForSceneToLoad();
+            WaitForLoad();
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
 
-        private async UniTaskVoid WaitForSceneToLoad()
+        private async UniTaskVoid WaitForLoad()
         {
             await UniTask.WhenAll(
-                Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.MainMenu),
                 Context.UIService.AsyncSwitchPanelTo(UIPanel.MainMenu),
-                Context.AudioFactory.WarmMenuMusic()
+                Context.AudioFactory.WarmMenuMusic(),
-                );
+                Context.AudioFactory.WarmAudioTestClips()
+            );
+            Context.LoadingManager
+                .UnregisterLoading(LoadingWork.LoadUI)
+                .UnregisterLoading(LoadingWork.LoadAudio);
             
+            InitializeAudio();
+
+            InitializeInput();
+        }
+
+        private void AfterSceneLoaded()
+        {
+            var mainMenuEnvironment = (MainMenuEnvironment)SceneManager.GetActiveScene()
+                .GetSceneContainer().Resolve<CurrentSceneEnvironment>();
+
+            InitializeUI(mainMenuEnvironment);
+
+            InitializeCamera(mainMenuEnvironment);
+            
+            Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
+        }
+
+        private void InitializeCamera(MainMenuEnvironment mainMenuEnvironment)
+        {
+            ((Gameplay.Camera.CameraStates.MainMenuState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(mainMenuEnvironment
+                .cameraPosition);
+        }
+
+        private void InitializeInput()
+        {
+            Context.InputService.EnableMap(ActionMappings.MainMenu);
+        }
+
+        private void InitializeAudio()
+        {
             Context.AudioService.TransitToSnapshot(AudioSnapshotState.Menu);
             Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Menu);
+        }
 
-            ((MainMenuPanel)Context.UIService.CurrentPanel).startButton.onClick.AddListener(StartGame);
+        private void InitializeUI(MainMenuEnvironment mainMenuEnvironment)
-            ((MainMenuPanel)Context.UIService.CurrentPanel).exitButton.onClick.AddListener(ExitGame);
+        {
+            var menuPanel = (MainMenuPanel)Context.UIService.CurrentPanel;
+            menuPanel.Initialize(mainMenuEnvironment.uiVariables,
+                mainMenuEnvironment.startButton,
+                mainMenuEnvironment.settingButton, 
+                mainMenuEnvironment.exitButton);
 
-            var hui = ((MainMenuEnvironment)SceneManager.GetActiveScene()
+            menuPanel.startButton.button.onClick.AddListener(StartGame);
-                .GetSceneContainer().Resolve<CurrentSceneEnvironment>());
+            menuPanel.exitButton.button.onClick.AddListener(ExitGame);
-            
-            ((StaticState)Context.CameraStateMachine.CurrentBaseState).LookTarget = 
-                hui.cameraTarget;
-            
-            ((BaseCameraState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(hui.cameraPosition);
 
-            Context.UIService.LoadingScreen.Hide();
+            mainMenuEnvironment.menuButtonsCanvas.worldCamera = Context.CameraStateMachine.Camera;
-            
+            mainMenuEnvironment.settingsCanvas.worldCamera = Context.CameraStateMachine.Camera;
-            Context.InputService.EnableMap(ActionMappings.MainMenu);
         }
 
         public override void Tick()
@@ -76,8 +120,9 @@ namespace Code.App.AppStates
         public override void ExitState()
         {
             Context.InputService.DisableMap(ActionMappings.MainMenu);
-            Context.AudioService.GladlyAskToStopMusic(MusicType.Menu, callback: Context.AudioFactory.ReleaseMenuMusic); 
+            Context.AudioService.GladlyAskToStopMusic(MusicType.Menu, callback: Context.AudioFactory.ReleaseMenuMusic);
-            
+
+            Context.AudioFactory.ReleaseAudioTestClips();
             base.ExitState();
         }
     }

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

@@ -1,9 +1,14 @@
+using System.Collections.Generic;
+using Code.App.Loading;
 using Code.App.StateMachine;
 using Code.Audio;
 using Code.Configs;
 using Code.Constants;
 using Code.Gameplay.Camera;
+using Code.Gameplay.Enemies;
+using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
+using Code.Generator;
 using Code.Input;
 using Code.Scenes;
 using Code.StaticData;
@@ -25,10 +30,12 @@ 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));
             
@@ -60,23 +67,44 @@ namespace Code.App
             containerBuilder.AddSingleton(infrastructureUnit.AddComponent<CameraStateMachine>());
         }
 
+        // TODO Часть в сцены
         private void InstallStaticData(ContainerBuilder containerBuilder, out IStaticDataService staticDataService)
         {
             staticDataService = new StaticDataService();
             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.DrunkenGrandpaConfig, typeof(DrunkenGrandpaConfig));
+            containerBuilder.AddSingleton(staticDataService.CockroachConfig, typeof(CockroachConfig));
+            containerBuilder.AddSingleton(staticDataService.FogConfig, typeof(FogConfig));
+            
             containerBuilder.AddSingleton(staticDataService.AudioMixerConfig, typeof(AudioMixerConfig));
             containerBuilder.AddSingleton(staticDataService.SoundtrackListConfig, typeof(SoundtrackListConfig));
+            containerBuilder.AddSingleton(staticDataService.AudioTestClipsConfig, typeof(AudioTestClipsConfig));
             containerBuilder.AddSingleton(staticDataService.SFXListConfig, typeof(SFXListConfig));
+            containerBuilder.AddSingleton(staticDataService.CourierSoundListConfig, typeof(CourierSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.DispatcherSoundListConfig, typeof(DispatcherSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
+            containerBuilder.AddSingleton(staticDataService.AudioSourceSettingsConfigs, typeof(Dictionary<AudioSourceType, AudioSourceSettingsConfig>));
+            
+            containerBuilder.AddSingleton(staticDataService.DefaultAudioSettingsConfig, typeof(DefaultAudioSettingsConfig));
+
+            containerBuilder.AddSingleton(staticDataService.OrderServiceConfig, typeof(OrderServiceConfig));
+            containerBuilder.AddSingleton(staticDataService.OrderBoxConfig, typeof(OrderBoxConfig)); 
+            
+            containerBuilder.AddSingleton(staticDataService.GeneratorConfig, typeof(GeneratorConfig)); 
         }
 
         private AppStateMachine _appStateMachine;
@@ -91,21 +119,26 @@ namespace Code.App
             AttributeInjector.Inject(cameraStateMachine.StateMachineContext, container);
             cameraStateMachine.Initialize();
 
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            BootstrapFinish(container).Forget();
-            BootstrapFinish(container);
-            
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
         private async UniTaskVoid BootstrapFinish(Container container)
         {
-            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen);
+            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen).GetComponent<LoadingScreen>();
-            DontDestroyOnLoad(loadingScreen);
+            DontDestroyOnLoad(loadingScreen.gameObject);
+
+            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
+            loadingManager.OnLoadingStarted += loadingScreen.Show;
+            loadingManager.OnLoadingEnded += loadingScreen.Hide;
+
+            loadingManager.RegisterLoading(LoadingWork.Bootstrap);
             
             await UniTask.WhenAll(
-                container.Resolve<IUIService>().Initialize(loadingScreen.GetComponent<LoadingScreen>()),
+                container.Resolve<IUIService>().Initialize(loadingScreen),
                 container.Resolve<IAudioService>().Initialize()
                 );
             
+            loadingManager.UnregisterLoading(LoadingWork.Bootstrap);
+            
             _appStateMachine
                 .SwitchState(AppState.MainMenu)
                 .AllowStateTransition(AppState.Gameplay);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,14 @@
+using Code.App.Loading;
+using Code.Gameplay.Enemies;
+using Code.Gameplay.Orders.Order;
+using Code.Gameplay.Player;
+using Code.Generator;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
+using Cysharp.Threading.Tasks;
 using Reflex.Core;
 using UnityEngine;
+using IPlayerScore = Code.Gameplay.Player.IPlayerScore;
 
 namespace Code.App.SceneInstallers
 {
@@ -12,15 +19,38 @@ namespace Code.App.SceneInstallers
         public void InstallBindings(ContainerBuilder containerBuilder)
         {
             containerBuilder.AddScoped(typeof(GameplaySceneEnvironment), typeof(CurrentSceneEnvironment));
+            containerBuilder.AddScoped(typeof(PlayerScore), typeof(IPlayerScore));
+            containerBuilder.AddScoped(typeof(OrderService), typeof(IOrderService));
+            containerBuilder.AddScoped(typeof(RoomGeneratorFactory), typeof(IRoomGeneratorFactory));
+            containerBuilder.AddScoped(typeof(PlayerProvider), typeof(IPlayerProvider));
+            containerBuilder.AddScoped(typeof(PlayerFactory), typeof(IPlayerFactory));
+            containerBuilder.AddScoped(typeof(EnemyFactory), typeof(IEnemyFactory));
+            containerBuilder.AddScoped(typeof(RoomGenerator));
 
             containerBuilder.OnContainerBuilt += Initialize;
         }
 
         private void Initialize(Container container)
         {
-            GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
+            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
             
+            GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
+
             env.TransitVariables(_gameplaySceneEnvironment);
+            
+            loadingManager
+                .UnregisterLoading(LoadingWork.LoadScene);
+            
+            LoadRooms(container,loadingManager).Forget();
+        }
+
+        private async UniTaskVoid LoadRooms(Container container, ILoadingManager loadingManager)
+        {
+            // await container.Resolve<IRoomGeneratorFactory>().PreloadRooms(container.Resolve<IOrderService>());
+            
+            // container.Resolve<RoomGenerator>().Initialize();
+            
+            loadingManager.UnregisterLoading(LoadingWork.LoadModelResource);
         }
     }
 }

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

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

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

@@ -1,6 +1,9 @@
+using Code.App.Loading;
 using Code.Audio;
 using Code.Gameplay.Camera;
+using Code.Gameplay.Enemies;
 using Code.Gameplay.Player;
+using Code.Generator;
 using Code.Input;
 using Code.Scenes;
 using Code.UI;
@@ -10,13 +13,16 @@ 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; }
+        /*[Inject]*/public IPlayerFactory PlayerFactory { get; set; }
+        /*[Inject]*/public IPlayerProvider PlayerProvider { get; set; }
+        // [Inject] public IEnemyFactory EnemyFactory { get; private set; } 
     }
 }

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

@@ -11,13 +11,29 @@ namespace Code.Audio
     }
     public enum EnemiesSounds
     {
-        Bastard,
+        GrandpaAttack,
-        Bravo
+        RoachAttack,
+        RoachStep,
+        GrandpaStep
     }
     public enum DispatcherSounds
     {
-        Absolutely,
+        Recieve1,
-        AbsolutelyNot,
+        Recieve2,
-        AhFreeman
+        TakeDamage1,
+        TakeDamage2,
+        TakeDamage3,
+        TakeDamage4,
+        Late1,
+        Late2,
+        Late3,
+        Late4,
+        Late5
+    }
+    public enum CourierSounds
+    {
+        Step,
+        Damage1,
+        Damage2
     }
 }

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Code.Configs;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
@@ -15,31 +16,40 @@ namespace Code.Audio
         public AudioMixer AudioMixer { get; private set; }
         private AssetReference _audioSourcePrefab;
         
+        private AssetReference[] _audioTestClipsReferences;
         private AssetReference[] _peacefulSoundtrack;
         private AssetReference[] _actionSoundtrack;
+        private AssetReference[] _deathSoundtrack;
         private AssetReference[] _menuSoundtrack;
         private AssetReference[] _SFX;
         private AssetReference[] _enemies;
         private AssetReference[] _dispatcher;
-        private AssetReference[] _character;
+        private AssetReference[] _courier;
         
+        private AsyncOperationHandle<IList<AudioClip>> _audioTestClipsHandle;
         private AsyncOperationHandle<IList<AudioClip>> _menuMusicHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _deathMusicHandle;
         private AsyncOperationHandle<IList<AudioClip>> _actionMusicHandle;
         private AsyncOperationHandle<IList<AudioClip>> _peacefulMusicHandle;
         private AsyncOperationHandle<IList<AudioClip>> _SFXHandle;
         private AsyncOperationHandle<IList<AudioClip>> _enemiesHandle;
         private AsyncOperationHandle<IList<AudioClip>> _dispatcherHandle;
+        private AsyncOperationHandle<IList<AudioClip>> _courierHandle;
 
+        public Dictionary<AudioType, AudioClip> AudioTestClips { get; private set; } = new();
         public Dictionary<MusicType, List<AudioClip>> MusicDictionary { get; private set; } = new();
         public List<AudioClip> SFXAudios { get; private set; } = new();
         public List<AudioClip> EnemiesAudios { get; private set; } = new();
+        public List<AudioClip> CourierAudios { get; private set; } = new();
         public List<AudioClip> DispatcherAudios { get; private set; } = new();
 
         public AudioFactory(AudioMixerConfig audioMixerConfig, 
             SoundtrackListConfig soundtrackListConfig,
             SFXListConfig sfxListConfig, 
             EnemiesSoundListConfig enemiesSoundListConfig,
-            DispatcherSoundListConfig dispatcherSoundListConfig
+            DispatcherSoundListConfig dispatcherSoundListConfig,
+            AudioTestClipsConfig audioTestClipsConfig,
+            CourierSoundListConfig courierSoundListConfig
             )
         {
             AudioMixer = audioMixerConfig.audioMixerAsset;
@@ -47,14 +57,18 @@ namespace Code.Audio
             
             _peacefulSoundtrack = soundtrackListConfig.peacefulSoundtrack;
             _actionSoundtrack = soundtrackListConfig.actionSoundtrack;
+            _deathSoundtrack = soundtrackListConfig.deathSoundtrack;
             _menuSoundtrack = soundtrackListConfig.menuSoundtrack;
             _SFX = sfxListConfig.SFX;
             _enemies = enemiesSoundListConfig.enemies;
             _dispatcher = dispatcherSoundListConfig.dispatcher;
+            _courier = courierSoundListConfig.courierSounds;
+            _audioTestClipsReferences = audioTestClipsConfig.audioTestClips;
             
             MusicDictionary.Add(MusicType.Menu, new ());
-            MusicDictionary.Add(MusicType.Peaceful, new ());
+            MusicDictionary.Add(MusicType.Death, new ());
             MusicDictionary.Add(MusicType.Action, new ());
+            MusicDictionary.Add(MusicType.Peaceful, new ());
         }
 
         public async UniTask LoadAudioSourcePrefab(Action<GameObject> callback) =>
@@ -62,8 +76,8 @@ namespace Code.Audio
 
         public async UniTask WarmGameplayMusic( )
         {
-            _actionMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_actionSoundtrack, OnActionTrackLoaded, Addressables.MergeMode.None);
+            _actionMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_actionSoundtrack, OnActionTrackLoaded, Addressables.MergeMode.Union);
-            _peacefulMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_peacefulSoundtrack, OnPeacefulTrackLoaded, Addressables.MergeMode.None);
+            _peacefulMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_peacefulSoundtrack, OnPeacefulTrackLoaded, Addressables.MergeMode.Union);
             
             await UniTask.WhenAll(_actionMusicHandle.ToUniTask(), _peacefulMusicHandle.ToUniTask());
         }
@@ -77,12 +91,28 @@ namespace Code.Audio
             MusicDictionary[MusicType.Peaceful].Clear();
             _peacefulMusicHandle.Release();
         }
+        public async UniTask WarmAudioTestClips( )
+        {
+            // _audioTestClipCounter = 0;
+            _audioTestClipsHandle = Addressables.LoadAssetsAsync<AudioClip>(_audioTestClipsReferences, OnAudioTestClipLoaded, Addressables.MergeMode.Union);
+            
+            // foreach (var assetReference in _menuSoundtrack) MenuMusic.Add(await assetReference.LoadAssetAsync<AudioClip>());
+            var clips = (await _audioTestClipsHandle.ToUniTask()).ToList();
+
+            for (int i = 0; i < clips.Count; i++) 
+                AudioTestClips[(AudioType)i] = clips[i];
+        }
+        public void ReleaseAudioTestClips()
+        {
+            AudioTestClips.Clear();
+            // foreach (var assetReference in _menuSoundtrack) assetReference.ReleaseAsset();
+            _audioTestClipsHandle.Release();
+        }
         public async UniTask WarmMenuMusic( )
         {            
-            _menuMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_menuSoundtrack, OnMenuTrackLoaded, Addressables.MergeMode.None);
+            _menuMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_menuSoundtrack, OnMenuTrackLoaded, Addressables.MergeMode.Union);
             // foreach (var assetReference in _menuSoundtrack) MenuMusic.Add(await assetReference.LoadAssetAsync<AudioClip>());
             await _menuMusicHandle.ToUniTask();
-             
         }
         public void ReleaseMenuMusic()
         {
@@ -90,9 +120,19 @@ namespace Code.Audio
             // foreach (var assetReference in _menuSoundtrack) assetReference.ReleaseAsset();
             _menuMusicHandle.Release();
         }
+        public async UniTask WarmDeathMusic()
+        {            
+            _deathMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_deathSoundtrack, OnDeathTrackLoaded, Addressables.MergeMode.Union);
+            await _deathMusicHandle.ToUniTask();
+        }
+        public void ReleaseDeathMusic()
+        {
+            MusicDictionary[MusicType.Death].Clear();
+            _deathMusicHandle.Release();
+        }
         public async UniTask WarmSFX( )
         {            
-            _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.None);
+            _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.Union);
             
             await _SFXHandle.ToUniTask();
              
@@ -104,7 +144,7 @@ namespace Code.Audio
         }
         public async UniTask WarmEnemies( )
         {            
-            _enemiesHandle = Addressables.LoadAssetsAsync<AudioClip>(_enemies, OnEnemiesLoaded, Addressables.MergeMode.None);
+            _enemiesHandle = Addressables.LoadAssetsAsync<AudioClip>(_enemies, OnEnemiesLoaded, Addressables.MergeMode.Union);
             
             await _enemiesHandle.ToUniTask();
              
@@ -115,10 +155,22 @@ namespace Code.Audio
             EnemiesAudios.Clear();
             _enemiesHandle.Release();
         }
+        public async UniTask WarmCourier()
+        {            
+            _courierHandle = Addressables.LoadAssetsAsync<AudioClip>(_courier, OnCourierLoaded, Addressables.MergeMode.Union);
+            
+            await _courierHandle.ToUniTask();
+        }
+
+        public void ReleaseCourier()
+        {
+            CourierAudios.Clear();
+            _courierHandle.Release();
+        }
 
         public async UniTask WarmDispatcher( )
         {            
-            _dispatcherHandle = Addressables.LoadAssetsAsync<AudioClip>(_dispatcher, OnDispatcherLoaded, Addressables.MergeMode.None);
+            _dispatcherHandle = Addressables.LoadAssetsAsync<AudioClip>(_dispatcher, OnDispatcherLoaded, Addressables.MergeMode.Union);
             
             await _dispatcherHandle.ToUniTask();
              
@@ -134,6 +186,16 @@ namespace Code.Audio
         {
             MusicDictionary[MusicType.Menu].Add(audioClip);
         }
+        private void OnDeathTrackLoaded(AudioClip audioClip)
+        {
+            MusicDictionary[MusicType.Death].Add(audioClip);
+        }
+
+        // private int _audioTestClipCounter;
+        private void OnAudioTestClipLoaded(AudioClip audioClip)
+        {
+            // AudioTestClips[(AudioType)_audioTestClipCounter] = audioClip;_audioTestClipCounter++;
+        }
         private void OnActionTrackLoaded(AudioClip audioClip)
         {
             MusicDictionary[MusicType.Action].Add(audioClip);
@@ -154,5 +216,9 @@ namespace Code.Audio
         {
             DispatcherAudios.Add(audioClip);
         }
+        private void OnCourierLoaded(AudioClip audioClip)
+        {
+            CourierAudios.Add(audioClip);
+        }
     }
 }

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

@@ -4,6 +4,7 @@ using System.Threading;
 using Code.Configs;
 using Code.Constants;
 using Cysharp.Threading.Tasks;
+using DG.Tweening;
 using Reflex.Attributes;
 using Unity.VisualScripting;
 using UnityEngine;
@@ -21,152 +22,239 @@ namespace Code.Audio
         private AudioSource _actionMusicSource;
         private AudioSource _peacefulMusicSource;
 
-        private AudioMixerGroup _masterGroup,
+        private Dictionary<AudioType, AudioMixerGroup> _audioMixerGroups = new();
-            // _musicGroup,
+        private readonly AudioSourcePool _audioSourcePool;
-            // _actionMusicGroup,
+ 
-            // _peacefulMusicGroup,
+        // Юнити не может - говнокод поможет.
-            _SFXGroup,
+        private Dictionary<AudioSnapshotState, Dictionary<AudioType, float>> _snapshotsVolumes = new();
-            _creaturesGroup,
+        private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
-            _dispatcherGroup,
-            _courierGroup,
-            _enemiesGroup;
 
-        private readonly AudioSourcePool _audioSourcePool = new();
+        public AudioService(IAudioFactory audioFactory,
-
+            Dictionary<AudioSourceType, AudioSourceSettingsConfig> settings,
-        private Dictionary<AudioSnapshotState, AudioMixerSnapshot> _snapshots = new();
+            DefaultAudioSettingsConfig defaultAudioSettingsConfig)
-
-        public AudioService(IAudioFactory audioFactory)
         {
             _audioFactory = audioFactory;
+            _audioSourcePool = new(settings);
+            _settings = settings;
+            
+            _snapshotsVolumes.Add(AudioSnapshotState.None,defaultAudioSettingsConfig.noneVolume);
+            _snapshotsVolumes.Add(AudioSnapshotState.Menu,defaultAudioSettingsConfig.menuVolume);
+            _snapshotsVolumes.Add(AudioSnapshotState.Action,defaultAudioSettingsConfig.actionVolume);
+            _snapshotsVolumes.Add(AudioSnapshotState.Peaceful,defaultAudioSettingsConfig.peacefulVolume);
+        }
+
+        public float GetSetting(AudioType type)
+        {
+            _mixer.GetFloat(_audioMixerGroups[type].name, out float value);
+
+            value = Mathf.Pow(10f, value / 20);
+
+            return value;
+        }
+
+        public void ChangeSetting(AudioType type, float value)
+        {
+            float volume = Mathf.Log10(value) * 20;
+            switch (type)
+            {
+                case AudioType.DeathMusic:
+                case AudioType.Master:
+                    _snapshotsVolumes[AudioSnapshotState.Menu][type] = value;
+                    _snapshotsVolumes[AudioSnapshotState.Action][type] = value;
+                    _snapshotsVolumes[AudioSnapshotState.Peaceful][type] = value;
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume); 
+                    break;
+                case AudioType.ActionMusic:
+                    _snapshotsVolumes[AudioSnapshotState.Action][type] = value;
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume);
+                    break;
+                case AudioType.PeacefulMusic:
+                    _snapshotsVolumes[AudioSnapshotState.Peaceful][type] = value;
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume);
+                    break;
+                case AudioType.MenuMusic:
+                    _snapshotsVolumes[AudioSnapshotState.Menu][type] = value;
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume);
+                    break; 
+                case AudioType.SFX:
+                case AudioType.Dispatcher:
+                case AudioType.Courier:
+                case AudioType.Enemies:
+                    _snapshotsVolumes[AudioSnapshotState.Action][type] = value;
+                    _snapshotsVolumes[AudioSnapshotState.Peaceful][type] = value;
+                    _mixer.SetFloat(_audioMixerGroups[type].name, volume); 
+                    break;
+            }
         }
 
         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.Death, _mixer.FindMatchingGroups(AudioGroups.DeathMusicGroup)[0]);
             _musicAudioGroups.Add(MusicType.Action, _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0]);
             _musicAudioGroups.Add(MusicType.Peaceful, _mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0]);
-            
+
             _cancellationTokenSources.Add(MusicType.Menu, new());
+            _cancellationTokenSources.Add(MusicType.Death, new());
             _cancellationTokenSources.Add(MusicType.Action, new());
             _cancellationTokenSources.Add(MusicType.Peaceful, new());
-            
+
             _musicAudioSources.Add(MusicType.Menu, null);
+            _musicAudioSources.Add(MusicType.Death, null);
             _musicAudioSources.Add(MusicType.Action, null);
             _musicAudioSources.Add(MusicType.Peaceful, null);
-            
-            _SFXGroup = _mixer.FindMatchingGroups(AudioGroups.SFXGroup)[0];
-            _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);
+            _audioMixerGroups.Add(AudioType.Master, _mixer.FindMatchingGroups(AudioGroups.MasterGroup)[0]);
-            _snapshots[AudioSnapshotState.Peaceful] = _mixer.FindSnapshot(AudioGroups.PeacefulSnapshot);
+            _audioMixerGroups.Add(AudioType.SFX, _mixer.FindMatchingGroups(AudioGroups.SFXGroup)[0]); 
-            _snapshots[AudioSnapshotState.Action] = _mixer.FindSnapshot(AudioGroups.ActionSnapshot);
+            _audioMixerGroups.Add(AudioType.Dispatcher, _mixer.FindMatchingGroups(AudioGroups.DispatcherMusicGroup)[0]);
-            _snapshots[AudioSnapshotState.Menu] = _mixer.FindSnapshot(AudioGroups.MenuSnapshot);
+            _audioMixerGroups.Add(AudioType.Courier, _mixer.FindMatchingGroups(AudioGroups.CourierGroup)[0]);
+            _audioMixerGroups.Add(AudioType.Enemies, _mixer.FindMatchingGroups(AudioGroups.EnemiesGroup)[0]);
+            _audioMixerGroups.Add(AudioType.MenuMusic, _musicAudioGroups[MusicType.Menu]);
+            _audioMixerGroups.Add(AudioType.DeathMusic, _musicAudioGroups[MusicType.Death]);
+            _audioMixerGroups.Add(AudioType.ActionMusic, _musicAudioGroups[MusicType.Action]);
+            _audioMixerGroups.Add(AudioType.PeacefulMusic, _musicAudioGroups[MusicType.Peaceful]);
+
 
             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])
+            if (!_musicAudioSources[musicType])
             {
                 _musicAudioSources[musicType] = _audioSourcePool.GetSource();
-                _musicAudioSources[musicType].spatialBlend = 0f;
+                _musicAudioSources[musicType].spatialBlend = _settings[AudioSourceType.NoBlend].spatialBlend;
                 _musicAudioSources[musicType].outputAudioMixerGroup = _musicAudioGroups[musicType];
             }
-            
+
             _musicAudioSources[musicType].resource =
                 _audioFactory.MusicDictionary[musicType][
                     Random.Range(0, _audioFactory.MusicDictionary[musicType].Count)];
-            
+
             _musicAudioSources[musicType].Play();
-            
+
-            // await UniTask.WaitUntilValueChanged(_musicAudioSources[musicType],
-            //     _ => !_musicAudioSources[musicType].isPlaying,
-            //     cancellationToken: _cancellationTokenSources[musicType].Token);
             await UniTask.NextFrame();
-            // Debug.Log($"Playing {musicType}");
             var (isCanceled, _) = await UniTask.WaitUntilValueChanged(_musicAudioSources[musicType],
-                     _ => !_musicAudioSources[musicType].isPlaying,
+                _ => !_musicAudioSources[musicType].isPlaying,
                 cancellationToken: _cancellationTokenSources[musicType].Token).SuppressCancellationThrow();
-            // Debug.Log($"Finished {musicType}");
+            Debug.LogError("Music skipping");
-            
             if (isCanceled)
             {
-                // Debug.Log($"Cancelled {musicType}");
                 _cancellationTokenSources[musicType].Dispose();
                 _cancellationTokenSources[musicType] = new();
-                
+
                 _audioSourcePool.ReleaseSource(_musicAudioSources[musicType]);
                 _musicAudioSources[musicType] = null;
-                
+
                 return;
             }
 
-            PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(musicType);
+            PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(musicType).Forget();
         }
-        
+
-        public async UniTaskVoid GladlyAskToStopMusic(MusicType musicType, AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null)
+        public async UniTaskVoid GladlyAskToStopMusic(MusicType musicType,
+            AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null)
         {
-            TransitToSnapshot(audioSnapshotState, time);
+            //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();
+            _cancellationTokenSources[MusicType.Peaceful].Cancel();
+            _cancellationTokenSources[MusicType.Action].Cancel();
         }
 
         public void GladlyAskToStopMusic(Action callback = null)
         {
-            TransitToSnapshot(AudioSnapshotState.None);
+            // TransitToSnapshot(AudioSnapshotState.None);
             _peacefulMusicSource.Stop();
             _actionMusicSource.Stop();
 
             callback?.Invoke();
         }
 
-        public void TransitToSnapshot(AudioSnapshotState state, float time = 1f)
+        public void TransitToSnapshot(AudioSnapshotState state, float time = 1)
         {
-            _snapshots[state].TransitionTo(time);
+            foreach (var key in _audioMixerGroups.Keys) 
+                _mixer.DOSetFloat(_audioMixerGroups[key].name, Mathf.Log10(_snapshotsVolumes[state][key]) * 20, time);
         }
 
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
         public void PlaySFX(SFXSounds sfxId, Vector3 position)
         {
-            _audioSourcePool.PlayOneShot(_audioFactory.SFXAudios[(int)sfxId], position, _SFXGroup);
+            _audioSourcePool
+                .PlayOneShot(_audioFactory.SFXAudios[(int)sfxId], position, _audioMixerGroups[AudioType.SFX]).Forget();
+        }
+        public void ApplyStun(float value, float time)
+        {
+            _mixer.DOSetFloat("Stun", value, time);
         }
 
         public void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position)
         {
-            _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position, _enemiesGroup);
+            _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position,
+                _audioMixerGroups[AudioType.Enemies]).Forget();
         }
 
+        public AudioSource GetSourceOfGroup(AudioType group)
+        {
+            AudioSource source = _audioSourcePool.GetSource();
+            source.outputAudioMixerGroup = _audioMixerGroups[group];
+            return source;
+        }
+
+        public void ReleaseSourceOfGroup(AudioSource source) => _audioSourcePool.ReleaseSource(source);
+
+        // Чинить долго и дорого пусть Артёмов будет много, ведь он наш друг
+        public event IAudioService.OnAudioPlayingDelegate OnDispatcherStarted;
+        public event IAudioService.OnAudioPlayingDelegate OnDispatcherEnded;
+
         public void PlayDispatcher(DispatcherSounds dispatcherSoundId)
         {
-            _audioSourcePool.PlayShizo(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup);
+            OnDispatcherStarted?.Invoke();
+            _audioSourcePool.PlayOneShot(_audioFactory.DispatcherAudios[(int)dispatcherSoundId],
+                _audioMixerGroups[AudioType.Dispatcher],
+                AudioSourceType.NoBlend, () => OnDispatcherEnded?.Invoke()).Forget();
+        }
+
+        public void PlayCourier(CourierSounds courierSounds)
+        {
+            _audioSourcePool.PlayOneShot(_audioFactory.CourierAudios[(int)courierSounds],
+                _audioMixerGroups[AudioType.Courier],
+                AudioSourceType.NoBlend).Forget();
+        }
+        private CancellationTokenSource _testClipCancellationTokenSource = new();
+        private void ResetCurrentTestAudioSource() => _currentTestClipAudioType = AudioType.Master;
+
+        private AudioType _currentTestClipAudioType;
+
+        // TODO Засунуть в словарь
+        public void PlayTestClip(AudioType audioType)
+        {
+            if (_currentTestClipAudioType == audioType) return;
+
+            _testClipCancellationTokenSource.Cancel();
+            _testClipCancellationTokenSource = new();
+
+            _currentTestClipAudioType = audioType;
+
+            _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
+                _audioMixerGroups[audioType], _testClipCancellationTokenSource,
+                AudioSourceType.NoBlend, ResetCurrentTestAudioSource).Forget();
         }
     }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 using UnityEngine;
 using UnityEngine.AddressableAssets;
-using UnityEngine.Audio;
+using UnityEngine.Audio; 
 
 namespace Code.Configs
 {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(menuName = "Config/Enemies/Cockroach", fileName = "CockroachConfig")]
+    public class CockroachConfig : ScriptableObject
+    {
+        public AssetReference cockroachPrefab;
+        
+        public int damage = 2;
+        public float attackCooldown = 1.5f;
+        
+        public float detectionRange = 20f;
+        public float attackRange = 1.3f;
+        
+        public float speed = 6f;
+        
+        public bool isStunnable;
+        public float stunDuration;
+        
+        public bool usesIdleMovement = true;
+        public float idleWanderRadius = 3f;
+        public float idleMoveDurationMin = 0.3f;
+        public float idleMoveDurationMax = 1f;
+        public float idlePauseDurationMin = 0.1f;
+        public float idlePauseDurationMax = 0.8f;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7bc162d3127949aa950d0738beee99a4
+timeCreated: 1763571220

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(menuName = "Config/Enemies/DrunkenGrandpa", fileName = "DrunkenGrandpaConfig")]
+    public class DrunkenGrandpaConfig : ScriptableObject
+    {
+        public AssetReference drunkenGrandpaPrefab;
+        
+        public int damage = 2;
+        public float attackCooldown = 5f;
+        
+        public float detectionRange = 10f;
+        public float attackRange = 1.5f;
+        
+        public float speed = 3f;
+        
+        public bool isStunnable = true;
+        public float stunDuration = 3f;
+        
+        public bool usesIdleMovement = true;
+        public float idleWanderRadius = 5f;
+        public float idleMoveDurationMin = 1f;
+        public float idleMoveDurationMax = 5f;
+        public float idlePauseDurationMin = 3f;
+        public float idlePauseDurationMax = 5f;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4d157e8891074b90957a7434cff0ae71
+timeCreated: 1763569096

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

@@ -0,0 +1,29 @@
+using UnityEngine;
+using UnityEngine.AddressableAssets;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(menuName = "Config/Enemies/Fog", fileName = "FogConfig")]
+    public class FogConfig : ScriptableObject
+    {
+        public AssetReference fogPrefab;
+
+        public int damage = int.MaxValue;
+        public float attackCooldown;
+
+        public float detectionRange;
+        public float attackRange = 5f;
+
+        public float speed = 1.5f;
+
+        public bool isStunnable;
+        public float stunDuration;
+
+        public bool usesIdleMovement;
+        public float idleWanderRadius;
+        public float idleMoveDurationMin;
+        public float idleMoveDurationMax;
+        public float idlePauseDurationMin;
+        public float idlePauseDurationMax;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aa4dd2a5cce24902a2918488b5751f2f
+timeCreated: 1763581410

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

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

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

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

Game/CourierOld/Assets/Code/Configs/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/SoundtrackListConfig.cs

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

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

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

Game/CourierOld/Assets/Code/DebugAndTest.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bb5ad0cc3a72448a93ee2adb560c35ad
+timeCreated: 1764345160

Game/CourierOld/Assets/Code/DebugAndTest/TriggerTest.cs

@@ -0,0 +1,12 @@
+using UnityEngine;
+
+namespace Code.DebugAndTest
+{
+    public class TriggerTest : MonoBehaviour
+    {
+        private void OnTriggerEnter(Collider other)
+        {
+            Debug.Log(gameObject.name + " found " + other.name);
+        }
+    }
+}

Game/CourierOld/Assets/Code/DebugAndTest/TriggerTest.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6bb3c649d82049079d00b843a76aced8
+timeCreated: 1764345168

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

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

@@ -0,0 +1,31 @@
+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;
+            Cursor.lockState = CursorLockMode.None;
+        }
+
+        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,10 @@ namespace Code.Gameplay.Camera.CameraStates
 
         public override void EnterState()
         {
-            Debug.Log("Static State Enter");
             base.EnterState();
+            
+            Camera.fieldOfView = Context.CameraSettingsConfigs[CameraMode.Static].fov;
+            Cursor.lockState = CursorLockMode.None;
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)

Game/CourierOld/Assets/Code/Gameplay/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/DashMechanic.cs

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

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

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

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

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

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/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

@@ -1,79 +1,78 @@
 using UnityEngine;
-using KinematicCharacterController;
 
 namespace Code.Gameplay.Character.Controller.Abilities
 {
-    /*
-     * Механика наклона персонажа при контакте со стеной
-     * Управляет визуальным наклоном модели в зависимости от высоты подъёма по стене
-     */
     public class WallLeanMechanic
     {
-        private readonly float _maxLeanAngle;
+        private readonly float _leanAngle;
-        private readonly float _leanSharpness;
+        private readonly float _threshold;
-        private readonly float _heightScale;
+        private readonly float _smoothSpeed;
-        
-        private Transform _characterTransform;
-        private Vector3 _lastWallNormal;
-        private float _lastWallContactHeight;
-        private float _leanFactor;
 
-        public WallLeanMechanic(float maxLeanAngle, float leanSharpness, float heightScale)
+        private Transform _model;
+
+        public WallLeanMechanic(
+            float leanAngle,
+            float threshold,
+            float smoothSpeed)
         {
-            _maxLeanAngle = maxLeanAngle;
+            _leanAngle = leanAngle;
-            _leanSharpness = leanSharpness;
+            _threshold = threshold;
-            _heightScale = heightScale;
+            _smoothSpeed = smoothSpeed;
         }
 
-        // Назначаем трансформ визуальной модели один раз
+        public void SetModel(Transform model) => _model = model;
-        public void SetCharacterTransform(Transform transform)
-        {
-            _characterTransform = transform;
-        }
 
-        // Вызывается из OnMovementHit
+        public void Update(bool isWallRunning, Vector3 wallNormal, Vector3 characterForward)
-        public void OnWallContact(Vector3 wallNormal, float contactHeight)
         {
-            _lastWallNormal = wallNormal;
+            if (!_model)
-            _lastWallContactHeight = contactHeight; }
-
-        // Обновление каждый кадр
-        public void UpdateLean(KinematicCharacterMotor motor, float deltaTime)
-        {
-            if (!_characterTransform) return;
-            
-            var isGrounded = motor.GroundingStatus.IsStableOnGround;
-
-            if (!isGrounded)
             {
-                var heightDelta = motor.TransientPosition.y - _lastWallContactHeight;
+                _model.localRotation = Quaternion.identity;
-                var targetLeanFactor = Mathf.Clamp01(heightDelta * _heightScale);
-                _leanFactor = Mathf.Lerp(_leanFactor, targetLeanFactor, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
-            }
-            else
-            {
-                _leanFactor = Mathf.Lerp(_leanFactor, 0f, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
-            }
-
-            ApplyLeanRotation(motor);
-        }
-
-        private void ApplyLeanRotation(KinematicCharacterMotor motor)
-        {
-            if (_leanFactor <= 0.01f)
-            {
-                _characterTransform.localRotation = Quaternion.identity;
                 return;
             }
 
-            var leanDirection = -_lastWallNormal;
+            var targetRotation = Quaternion.identity;
-            leanDirection = Vector3.ProjectOnPlane(leanDirection, motor.CharacterUp).normalized;
 
-            if (leanDirection.sqrMagnitude < 0.01f) return;
+            if (isWallRunning)
+            {
+                var n = new Vector3(wallNormal.x, 0f, wallNormal.z).normalized;
+                if (n.sqrMagnitude < 0.001f) n = Vector3.forward;
 
-            var leanAngle = _leanFactor * _maxLeanAngle;
+                var bodyRight = Vector3.Cross(Vector3.up, characterForward).normalized;
-            var leanRotation = Quaternion.AngleAxis(leanAngle, Vector3.Cross(motor.CharacterUp, leanDirection));
+                var side = Vector3.Dot(n, bodyRight);
-            _characterTransform.localRotation = leanRotation;
+                var front = Vector3.Dot(n, characterForward);
+
+                var axis = Vector3.right;
+                var angle = 0f;
+
+                if (side > _threshold)
+                {
+                    axis = Vector3.forward;
+                    angle = -_leanAngle;
+                }
+                else if (side < -_threshold)
+                {
+                    axis = Vector3.forward;
+                    angle = _leanAngle;
+                }
+                else if (front > _threshold)
+                {
+                    axis = Vector3.right;
+                    angle = -_leanAngle;
+                }
+                else if (front < -_threshold)
+                {
+                    axis = Vector3.right;
+                    angle = _leanAngle;
+                }
+
+                targetRotation = Quaternion.AngleAxis(angle, axis);
+            }
+
+            _model.localRotation = Quaternion.Slerp(
+                _model.localRotation,
+                targetRotation,
+                1f - Mathf.Exp(-_smoothSpeed * Time.deltaTime)
+            );
         }
     }
 }

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

@@ -0,0 +1,233 @@
+using Code.Gameplay.Character.Controller.Input;
+using Code.Gameplay.Character.Core;
+using KinematicCharacterController;
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Controller.Abilities
+{
+    public class WallRunningMechanic
+    {
+        private readonly float _maxWallRunTime;
+        private readonly float _wallRunSpeed;
+        private readonly float _wallRunAcceleration;
+        private readonly float _wallRunGravityScale;
+        private readonly float _wallDetachImpulse;
+        private readonly float _wallContactAngleThreshold;
+
+        private float _wallRunTimer;
+        private Vector3 _wallNormal;
+        private Vector3 _wallTangentRight;
+        private Vector3 _wallTangentUp;
+        private Vector3 _wallContactPoint;
+        private Vector3 _lastMoveInputInWallSpace;
+
+        private float _surfaceAngleCos;
+        private bool _canWallRun;
+
+        private KinematicCharacterMotor _motor;
+        private CharacterInputHandler _inputHandler;
+
+        public bool IsWallRunning { get; private set; }
+
+        public WallRunningMechanic(
+            float maxWallRunTime,
+            float wallRunSpeed,
+            float wallRunAcceleration,
+            float wallRunGravityScale,
+            float wallDetachImpulse,
+            float wallContactAngleThreshold)
+        {
+            _maxWallRunTime = maxWallRunTime;
+            _wallRunSpeed = wallRunSpeed;
+            _wallRunAcceleration = wallRunAcceleration;
+            _wallRunGravityScale = wallRunGravityScale;
+            _wallDetachImpulse = wallDetachImpulse;
+            _wallContactAngleThreshold = wallContactAngleThreshold;
+        }
+
+        public void Initialize(KinematicCharacterMotor motor, CharacterInputHandler inputHandler)
+        {
+            _motor = motor;
+            _inputHandler = inputHandler;
+            _surfaceAngleCos = Mathf.Cos(Mathf.Deg2Rad * _wallContactAngleThreshold);
+        }
+
+        public void Tick(float deltaTime)
+        {
+            if (!IsWallRunning) return;
+            
+            _wallRunTimer += deltaTime;
+            if (_wallRunTimer > _maxWallRunTime)
+            {
+                DetachFromWall(false);
+            }
+        }
+
+        public bool TryStartWallRun(Vector3 hitNormal, Vector3 hitPoint)
+        {
+            if (IsWallRunning) return false;
+
+            var dotWithUp = Vector3.Dot(hitNormal, _motor.CharacterUp);
+            var isWall = Mathf.Abs(dotWithUp) < _surfaceAngleCos;
+
+            if (!isWall) return false;
+
+            if (_motor.GroundingStatus.IsStableOnGround) return false;
+
+            var velocityIntoWall = Vector3.Dot(_motor.Velocity, -hitNormal);
+            if (velocityIntoWall < 1f) return false;
+
+            StartWallRun(hitNormal, hitPoint);
+            return true;
+        }
+
+        private void StartWallRun(Vector3 wallNormal, Vector3 contactPoint)
+        {
+            IsWallRunning = true;
+            _wallRunTimer = 0f;
+            _wallNormal = wallNormal.normalized;
+            _wallContactPoint = contactPoint;
+
+            if (_wallTangentUp.sqrMagnitude < 0.01f) _wallTangentUp = Vector3.up;
+
+            _wallTangentRight = Vector3.Cross(_wallNormal, _wallTangentUp).normalized;
+
+            _wallTangentUp = Vector3.Cross(_wallTangentRight, _wallNormal).normalized;
+            if (Vector3.Dot(_wallTangentUp, Vector3.up) < 0)
+                _wallTangentUp = -_wallTangentUp;
+
+            _motor.ForceUnground();
+        }
+
+        public void HandleWallRun(ref Vector3 currentVelocity, CharacterInputs inputs, float deltaTime)
+        {
+            if (!IsWallRunning) return;
+            if (!IsWallStillPresent()) { DetachFromWall(false); return; }
+
+            var moveInputWorld = _inputHandler.MoveInputVector;
+            var moveInWallPlane = Vector3.ProjectOnPlane(moveInputWorld, _wallNormal);
+    
+            var wsMove = Vector3.Project(moveInWallPlane, _wallTangentRight);
+
+            var ad = inputs.MoveAxisRight;
+
+            var sideDot = Vector3.Dot(_wallNormal, _motor.CharacterRight);
+            if (sideDot < 0)
+                ad = -ad;
+
+            var adMove = _wallTangentUp * (-ad);
+
+            var finalMove = wsMove + adMove;
+            finalMove = finalMove.normalized * moveInputWorld.magnitude;
+
+            var targetVelocity = finalMove * _wallRunSpeed;
+
+            currentVelocity = Vector3.Lerp(
+                currentVelocity,
+                targetVelocity,
+                1f - Mathf.Exp(-_wallRunAcceleration * deltaTime)
+            );
+
+            currentVelocity += Physics.gravity * (_wallRunGravityScale * deltaTime);
+
+            var distanceToWall = Vector3.Dot(_motor.TransientPosition - _wallContactPoint, _wallNormal);
+            if (Mathf.Abs(distanceToWall) > 0.8f)
+            {
+                DetachFromWall(false);
+                return;
+            }
+
+            if (inputs.JumpPressed)
+            {
+                DetachFromWall(true);
+            }
+        }
+        
+        private bool IsWallStillPresent()
+        {
+            if (!_motor) return false;
+
+            var characterCenter = _motor.TransientPosition;
+            var characterRight = _motor.CharacterRight;
+            var characterUp = _motor.CharacterUp;
+
+            const float checkDistance = 0.45f;
+            var rayOrigin = characterCenter + characterUp * 0.2f;
+            var rayDir = -_wallNormal;
+
+            Vector3[] offsets = {
+                Vector3.zero,
+                characterUp * 0.3f,
+                -characterUp * 0.3f,
+                characterRight * 0.2f,
+                -characterRight * 0.2f
+            };
+
+            foreach (var offset in offsets)
+            {
+                if (!Physics.Raycast(rayOrigin + offset, rayDir, out var hit, checkDistance,
+                        _motor.CollidableLayers, QueryTriggerInteraction.Ignore)) continue;
+                
+                var dotWithUp = Mathf.Abs(Vector3.Dot(hit.normal, characterUp));
+                
+                if (!(dotWithUp < _surfaceAngleCos)) continue;
+                
+                _wallNormal = hit.normal.normalized;
+                _wallContactPoint = hit.point;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        private void DetachFromWall(bool withImpulse)
+        {
+            if (!IsWallRunning) return;
+
+            IsWallRunning = false;
+
+            if (!withImpulse || !_motor) return;
+            
+            var detachImpulse = -_wallNormal * _wallDetachImpulse;
+            _motor.BaseVelocity += detachImpulse;
+        }
+
+        public Vector3 GetWallNormal() => _wallNormal;
+
+        public void PerformWallJump(CharacterInputs inputs, Quaternion cameraRotation)
+        {
+            if (!IsWallRunning || !_motor) return;
+
+            IsWallRunning = false;
+
+            var wallAway = _wallNormal;
+            var wallUp = _wallTangentUp;
+
+            var playerForward = cameraRotation * Vector3.forward;
+
+            var forwardInWallPlane = Vector3.ProjectOnPlane(playerForward, _wallNormal).normalized;
+            if (forwardInWallPlane.sqrMagnitude < 0.01f) forwardInWallPlane = _wallTangentRight;
+
+            var jumpDirection = 
+                forwardInWallPlane * 0.2f +
+                wallAway * 0.4f +
+                wallUp * 0.4f;
+
+            jumpDirection = jumpDirection.normalized;
+
+            var wallJumpForce = _wallDetachImpulse * 2f;
+
+            var jumpImpulse = jumpDirection * wallJumpForce;
+
+            _motor.BaseVelocity += jumpImpulse;
+
+            _motor.SetPosition(_motor.TransientPosition + wallAway * 0.07f);
+            
+            if (_motor.CharacterController is CustomCharacterController controller)
+            {
+                controller.BlockAbilities(0.12f);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4bef67aa9cf14753a63ea07eecc5ff67
+timeCreated: 1764263348

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

@@ -15,7 +15,7 @@ namespace Code.Gameplay.Character.Controller
      * Реализует физическое движение персонажа с использованием Kinematic Character Controller
      * Обрабатывает ввод пользователя, применяет движение и вращение с учетом поверхности
      *
-     * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM
+     * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM  
      */
     public class CustomCharacterController : MonoBehaviour, ICharacterController
     {
@@ -27,216 +27,251 @@ namespace Code.Gameplay.Character.Controller
 
         // Подсистемы
         private CharacterInputHandler _inputHandler;
+        private DashMechanic _dashMechanic;
         private SlideMechanic _slideMechanic;
-        private WallClimbMechanic _wallClimbMechanic;
+        // private WallClimbMechanic _wallClimbMechanic;
+        private WallRunningMechanic _wallRunningMechanic;
         private WallLeanMechanic _wallLeanMechanic;
         private GroundMovementSystem _groundMovement;
         private AirMovementSystem _airMovement;
         
-        // Инициализация контроллера
+        public bool IsSliding => _slideMechanic.IsSliding; 
-        private void Awake()
+        public bool IsDashing => _dashMechanic.IsDashing; 
+        public bool IsWallRunning => _wallRunningMechanic.IsWallRunning;
+        
+        private float abilityBlockTimer;
+        private bool isAbilitiesBlocked;
+        
+        private CharacterInputs _lastInputs;
+        
+        public void SetPosition(Vector3 position) => motor.SetPosition(position);
+        public void SetRotation(Quaternion rotation) => motor.SetRotation(rotation);
+        
+        [Inject]
+        private void Construct(CharacterConfig characterConfig)
         {
+            _characterConfig = characterConfig;
             // Инициализация подсистем с параметрами из конфига
-            _inputHandler = new CharacterInputHandler(
+            _inputHandler = new CharacterInputHandler();
-                _characterConfig.sprintAngleThreshold
+            _dashMechanic = new DashMechanic(
+                _characterConfig.dashSpeed,
+                _characterConfig.dashDuration,
+                _characterConfig.dashCooldown
             );
             _slideMechanic = new SlideMechanic(
-                _characterConfig.slideSpeed,
+                _characterConfig.slideVelocityCurve,
-                _characterConfig.slideDuration,
+                _characterConfig.slideMinVelocityThreshold,
                 _characterConfig.slideCooldown
             );
-            _wallClimbMechanic = new WallClimbMechanic(
+            _wallRunningMechanic = new WallRunningMechanic(
-                _characterConfig.wallClimbSpeedFactor,
+                _characterConfig.wallRunMaxTime,
-                _characterConfig.minWallClimbSpeed,
+                _characterConfig.wallRunSpeed,
-                _characterConfig.wallDetectionAngleThreshold
+                _characterConfig.wallRunAcceleration,
+                _characterConfig.wallRunGravityScale,
+                _characterConfig.wallDetachImpulse,
+                _characterConfig.wallContactAngleThreshold
             );
             _wallLeanMechanic = new WallLeanMechanic(
-                _characterConfig.maxWallLeanAngle,
+                _characterConfig.leanAngle,
-                _characterConfig.wallLeanSharpness,
+                _characterConfig.leanThreshold,
-                _characterConfig.wallLeanHeightScale
+                _characterConfig.leanSmoothSpeed
-            );
+                );
             _groundMovement = new GroundMovementSystem(
                 _characterConfig.maxStableMoveSpeed,
-                _characterConfig.sprintMoveSpeed,
                 _characterConfig.stableMovementSharpness,
                 _characterConfig.jumpSpeed
             );
-            _airMovement = new AirMovementSystem(_characterConfig.gravity);
+            _airMovement = new AirMovementSystem(
+                _characterConfig.gravity,
+                _characterConfig.maxAirSpeed,
+                _characterConfig.airControlSharpness
+            );
+            
+            motor.CharacterController = this; // Регистрация этого контроллера в движке
+            _inputHandler.FirstPersonCameraRotation =
+                motor.Transform.rotation; // Начальное вращение совпадает с персонажемс
+            _wallLeanMechanic.SetModel(characterTransform);
+            _wallRunningMechanic.Initialize(motor, _inputHandler);
         }
 
         // Текущий режим камеры для адаптации поведения
         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)
         {
-            // Обновляем таймер перезарядки слайда
+            _lastInputs = inputs;
+            _dashMechanic.TickCooldown(Time.deltaTime);
             _slideMechanic.TickCooldown(Time.deltaTime);
+            _wallRunningMechanic.Tick(Time.deltaTime);
 
             // Если активен слайд - игнорируем весь остальной ввод
-            if (_slideMechanic.IsSliding)
+            if (_dashMechanic.IsDashing || _slideMechanic.IsSliding)
             {
-                // Во время слайда не обрабатываем движение, прыжки и спринт
                 _inputHandler.MoveInputVector = Vector3.zero;
                 _inputHandler.LookInputVector = Vector3.one;
-                _inputHandler.IsSprinting = false;
                 _groundMovement.RequestJump(inputs.JumpPressed);
                 return;
             }
 
-            // Сохраняем текущий режим камеры
             _currentCameraMode = inputs.CameraMode;
+            
+            if (isAbilitiesBlocked)
+            {
+                abilityBlockTimer -= Time.deltaTime;
+                if (abilityBlockTimer <= 0)
+                {
+                    isAbilitiesBlocked = false;
+                }
+                else
+                {
+                    inputs.DashPressed = false;
+                    inputs.SlidePressed = false;
+                }
+            }
 
-            // Обработка слайда
+            _dashMechanic.RequestDash(inputs.DashPressed);
             _slideMechanic.RequestSlide(inputs.SlidePressed);
 
             // Обработка остального ввода
             _inputHandler.ProcessInputs(ref inputs, motor);
 
-            // Передаём запрос прыжка напрямую в систему движения по земле
+            // Передаём запрос прыжка
             _groundMovement.RequestJump(inputs.JumpPressed);
         }
 
-        // Обновление вращения персонажа на основе входных данных
         public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
         {
-            // ВО ВРЕМЯ СЛАЙДА НЕ ОБНОВЛЯЕМ ВРАЩЕНИЕ - ПЕРСОНАЖ СМОТРИТ ПРЯМО
             if (_slideMechanic.IsSliding) return;
 
             switch (_currentCameraMode)
             {
-                // В FirstPerson режиме применяем вращение камеры напрямую к персонажу (только горизонталь)
                 case CameraMode.FirstPerson when _inputHandler.ShouldApplyCameraRotation:
-                    // Немедленно применяем горизонтальное вращение камеры к персонажу
                     currentRotation = _inputHandler.FirstPersonCameraRotation;
                     break;
-                // В ThirdPerson режиме плавно поворачиваем персонаж в направлении движения
                 case CameraMode.ThirdPerson:
                 {
-                    // Вращение применяется только если есть направление движения и разрешена резкость вращения
                     if (_inputHandler.LookInputVector.sqrMagnitude > 0 && _characterConfig.orientationSharpness > 0)
                     {
-                        // Плавная интерполяция текущего направления к целевому с экспоненциальным сглаживанием
                         var smoothedLookInputDirection = Vector3.Slerp(
                             motor.CharacterForward,
                             _inputHandler.LookInputVector,
                             1f - Mathf.Exp(-_characterConfig.orientationSharpness * deltaTime)
                         ).normalized;
 
-                        // Установка нового вращения смотря в сглаженном направлении
                         currentRotation = Quaternion.LookRotation(smoothedLookInputDirection, motor.CharacterUp);
                     }
-
                     break;
                 }
-                // Заготовка на будущее (если понадобится)
                 case CameraMode.Static:
                 case CameraMode.Cinematic:
-                case CameraMode.Bogdan: // Скорее всего юзлес, но пускай будет
                 default:
                     break;
             }
         }
 
-        // Обновление скорости движения персонажа
         public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
         {
-            // Если во время слайда запрошен прыжок — прерываем слайд
+            if (_dashMechanic.IsDashing && _groundMovement.JumpRequested)
+                _dashMechanic.EndDash();
             if (_slideMechanic.IsSliding && _groundMovement.JumpRequested)
-            {
                 _slideMechanic.EndSlide();
+
+            if (!_dashMechanic.IsDashing)
+                _dashMechanic.TryStartDash(motor, _currentCameraMode, _inputHandler.FirstPersonCameraRotation, _inputHandler.LookInputVector);
+            else
+            {
+                _dashMechanic.HandleDash(ref currentVelocity, deltaTime, motor);
+                return;
             }
 
-            // Проверяем запрос слайда и запускаем его если можно
             if (!_slideMechanic.IsSliding)
-            {
+                _slideMechanic.TryStartSlide(motor, _currentCameraMode, _inputHandler.FirstPersonCameraRotation, _inputHandler.LookInputVector);
-                _slideMechanic.TryStartSlide(motor, _currentCameraMode, _inputHandler.FirstPersonCameraRotation,
-                    _inputHandler.LookInputVector);
-            }
-            // Если активен слайд - обрабатываем отдельно
             else
             {
                 _slideMechanic.HandleSlide(ref currentVelocity, deltaTime, motor);
                 return;
             }
 
+            // === WALL RUNNING: обработка состояния ===
+            if (_wallRunningMechanic.IsWallRunning)
+            {
+                // 🔄 Передаём актуальные данные для walljump
+                if (_groundMovement.JumpRequested) // или _lastInputs.JumpPressed — зависит от логики
+                {
+                    _wallRunningMechanic.PerformWallJump(_lastInputs, _inputHandler.FirstPersonCameraRotation);
+                    _groundMovement.CancelJumpRequest(); // сброс, чтобы не сработало дважды
+                }
+                else
+                {
+                    _wallRunningMechanic.HandleWallRun(ref currentVelocity, _lastInputs, deltaTime);
+                }
+                return;
+            }
+
             // Если персонаж находится на земле
             if (motor.GroundingStatus.IsStableOnGround)
             {
                 _groundMovement.UpdateVelocity(ref currentVelocity, _inputHandler, motor, deltaTime);
             }
-            // Если персонаж не находится на земле
+            // Если персонаж не на земле — стандартное воздушное движение
             else
             {
-                _airMovement.UpdateVelocity(ref currentVelocity, deltaTime);
+                _airMovement.UpdateVelocity(ref currentVelocity, _inputHandler, motor, deltaTime);
-                // Отменяем прыжок (фикс проблемы с двойным прыжком после приземления)
                 _groundMovement.CancelJumpRequest();
             }
         }
+        
+        public void BlockAbilities(float duration)
+        {
+            isAbilitiesBlocked = true;
+            abilityBlockTimer = duration;
+        }
 
-        // Метод вызывается перед обновлением персонажа (можно использовать для подготовки)
         public void BeforeCharacterUpdate(float deltaTime)
         {
         }
 
-        // Метод вызывается после обработки столкновения с землей
         public void PostGroundingUpdate(float deltaTime)
         {
-            // Если во время слайда персонаж оторвался от земли - заканчиваем слайд
+            if (_dashMechanic.IsDashing && !motor.GroundingStatus.IsStableOnGround)
+                _dashMechanic.EndDash();
             if (_slideMechanic.IsSliding && !motor.GroundingStatus.IsStableOnGround)
-            {
                 _slideMechanic.EndSlide();
-            }
         }
 
-        // Метод вызывается после обновления персонажа
         public void AfterCharacterUpdate(float deltaTime)
         {
-            _wallLeanMechanic.UpdateLean(motor, deltaTime);
+            _wallLeanMechanic.Update(
+                _wallRunningMechanic.IsWallRunning,
+                _wallRunningMechanic.GetWallNormal(),
+                motor.CharacterForward
+            );
         }
 
-        // Проверка валидности коллайдера для обработки столкновений
         public bool IsColliderValidForCollisions(Collider coll)
         {
-            return true; // Все коллайдеры считаются валидными для столкновений
+            return true;
         }
 
-        // Обработка столкновения с землей (вызывается при приземлении)
         public void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
             ref HitStabilityReport hitStabilityReport)
         {
         }
 
-        // Обработка столкновения при движении (вызывается при ударе о препятствие)
         public void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
             ref HitStabilityReport hitStabilityReport)
         {
-            _wallClimbMechanic.OnMovementHit(motor, hitNormal);
+            if (_wallRunningMechanic.TryStartWallRun(hitNormal, hitPoint))
-            
-            var dotWithUp = Vector3.Dot(hitNormal, motor.CharacterUp);
-            if (Mathf.Abs(dotWithUp) <= _wallClimbMechanic.WallNormalThreshold)
             {
-                _wallLeanMechanic.OnWallContact(hitNormal, motor.TransientPosition.y);
             }
         }
 
-        // Обработка отчета о стабильности столкновения
         public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
             Vector3 atCharacterPosition,
             Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport)
         {
         }
 
-        // Обработка дискретных столкновений (для триггеров и специальных коллайдеров)
         public void OnDiscreteCollisionDetected(Collider hitCollider)
         {
         }

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

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

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

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

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

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

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

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

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

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

@@ -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.DashPressed = _inputService.DashPressed;
+            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/Door.cs

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

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bc9fc6ce2cc24b68b2b330e4fd029b80
+timeCreated: 1764304430

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

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

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

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

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

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

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

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

Game/CourierOld/Assets/Code/Gameplay/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/Enemies.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3b36108558824d748620db29707cd2b1
+timeCreated: 1763228467

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

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