Assets added

Game/CourierOld/.vsconfig

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

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetGroupSortSettings.asset

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

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetSettings.asset

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

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

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

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

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

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

@@ -15,209 +15,31 @@ MonoBehaviour:
   m_GroupName: Default Local Group
   m_GUID: d447fc60305c17a17bf20948ab295a45
   m_SerializeEntries:
-  - m_GUID: 144ab5188f8ad7a0a92c75703bd12e60
-    m_Address: launch_upmenu1
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 16562a5c87213914cad415f10c65a3b0
-    m_Address: "Assets/Resources_moved/Audio/Music/LASKX3I - \u041F\u0440\u043E\u0442\u0438\u0432
-      \u0446\u0430\u0440\u044F (\u041A\u0430\u0440\u0430\u043E\u043A\u0435).mp3"
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 170b1a70ddee4d948abea041b9b805e4
-    m_Address: Assets/Resources_moved/Audio/Music/Half Life Original Soundtrack -
-      Track 8 - Diabolical Adrenaline Guitar.mp3
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 1d4767c722c05b5d6b96bb226d378c65
-    m_Address: Assets/Resources_moved/Prefabs/Player/ArmsMesh.prefab
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 1d7110a045075b22fa27d62bd5f2784e
-    m_Address: 357_shot1
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 1f79c7b1e492a4ea2a8d666cdead0c52
-    m_Address: Audio/Dispatcher/take_damage4
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 23e11d2c8a4f12f4ea9a7a43d1118464
     m_Address: Gameplay
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 28a6c7a4124141341ab7c2b7dfd3e95b
-    m_Address: Assets/Resources_moved/Prefabs/Levels/Level1 2.prefab
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 29bff8011973e4e519906b9da8fca0fc
-    m_Address: Audio/Dispatcher/late3
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 29ee630aab7bbef8799dc76ed0c239f7
-    m_Address: Audio/Dispatcher/late4
-    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
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 31f16c866d3224ab8a7e0fabf3745ec5
-    m_Address: Audio/Dispatcher/late5
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 3831a36e0c8e48f659517a6bb99378b6
-    m_Address: cbar_hit1
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 3d195945b1fbf114a88457cba466bc2b
-    m_Address: Assets/Resources_moved/Rooms/Room2.prefab
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 4472dd84628855c4085cacaec19efa29
-    m_Address: Assets/Resources_moved/Rooms/Room1.prefab
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 48aebfe8826dc0df79d047b5afbf8f5b
     m_Address: Canvas
     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: 4f660559d76c3ed42a7c34a0b16487f7
-    m_Address: Assets/Resources_moved/Rooms/Room3.prefab
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 735f38402ea347fa381408293503a24e
-    m_Address: Audio/Dispatcher/receiving_an_order1
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 751890caa1647ec6689f24933fbcb770
-    m_Address: "Prefabs/Furniture/\u0442\u0440\u0443\u0431\u0430"
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 7c5caf3ceee44f71588860c5c1fbdbe0
-    m_Address: Audio/Dispatcher/take_damage3
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 803e40b883c823b89a91aa8b9d9fc483
-    m_Address: valve_sound
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 81844a99f5b786b41b831174f8fb6d3a
-    m_Address: Prefabs/Player/CharacterController
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 8187ea542d6ed824d81230966a3b7499
-    m_Address: Assets/Resources_moved/Audio/Music/Bauhaus - Bela Lugosi's Dead (No
-      Vocals Remix).mp3
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 82c71411174bfa86ca1f676b9d389f94
-    m_Address: bastard!
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 8c2be26d359d54063825fedfad7a493b
-    m_Address: Audio/Dispatcher/late2
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 8fa89a492fc3a3768a0f0ba1bb7080e0
-    m_Address: Audio/Dispatcher/late1
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: 9293380a88bf6736889be29722b94269
-    m_Address: Audio/AudioSource
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: a306df57f348ce7cf900d0b9431739ee
-    m_Address: launch_selectmenu
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: b2e8dc2aeb0311cd8a826b51cf8e94dc
     m_Address: GameOver
     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: b3471d165fe389f479380f61034bea57
-    m_Address: Assets/Resources_moved/Prefabs/Levels/Level1 1.prefab
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: c566fc932edefbbee9e53271eac3c560
     m_Address: MainMenu
     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: d4eaf1439c2788c458127b9ba67e4fbf
-    m_Address: Prefabs/Levels/Level1
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: ebe18293a5ef86704b23dad3a1786476
-    m_Address: Half-Life01
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: f23b9fce9594618e5b75845f1cae50de
     m_Address: LoadingScreen
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: f3d7dc64b34919ad7b50a3dd307a935b
-    m_Address: Assets/Resources_moved/Prefabs/Enemies/Fog.prefab
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
-  - m_GUID: f74a409bf11b25148ad305acc05b14f5
-    m_Address: Audio/Dispatcher/take_damage2
-    m_ReadOnly: 0
-    m_SerializedLabels: []
-    FlaggedDuringContentUpdateRestriction: 0
   m_ReadOnly: 0
   m_Settings: {fileID: 11400000, guid: 2588e84eb64800d0781c574a37fa48d8, type: 2}
   m_SchemaSet:

Game/CourierOld/Assets/AddressableAssetsData/ProfileDataSourceSettings.asset

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

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

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

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

@@ -1,76 +1,41 @@
-using Code.App.StateMachine; 
-using Code.Gameplay.Player;
-using Code.Input;
+using Code.App.StateMachine;
+using Code.Scenes;
 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()
         {
-            Container sceneContainer = SceneManager.GetActiveScene().GetSceneContainer();
-            _playerScore = sceneContainer.Resolve<IPlayerScore>();
-            _scoreCounter = 0; 
-            
-            Context.InputService.EnableMap(ActionMappings.UI);
-            Context.InputService.DebugBindAction((int)ActionMappings.UI,(int)UIActions.Continue, TryToExit);
-            
-            GameOver();
+            Context.UIService.SwitchPanelTo(UIPanel.GameOver);
             
             base.EnterState();
         }
-
-        private void TryToExit(InputAction.CallbackContext context)
-        {
-            ToMainMenu();
-        }
-
-        private async UniTaskVoid GameOver()
-        {
-            await Context.UIService.AsyncSwitchPanelTo(UIPanel.GameOver);
-            
-            _gameOverPanel = (GameOverPanel)Context.UIService.CurrentPanel;
-            
-        }
-
+        
         private void ToMainMenu()
         {
             Context.StateMachine.SwitchState(AppState.MainMenu)
                 .AllowStateTransition(AppState.Gameplay);
         }
-        private float _scoreCounter;
+
         public override void Tick()
         {
-            if (!_gameOverPanel) return;
-            
-            _scoreCounter += Time.deltaTime * 100;
-            // UnityEngine.Debug.Log($"Score: {_scoreCounter}");
-            if((int)_scoreCounter >= _playerScore.Score)
-            {
-                _gameOverPanel.UpdateScoreText(_playerScore.Score);
-            }
-            else _gameOverPanel.UpdateScoreText((int)_scoreCounter);
+            damnTimer -= Time.deltaTime;
+            if (damnTimer <= float.Epsilon) ToMainMenu();
         }
         public override void ExitState()
-        { 
-            Context.InputService.DisableMap(ActionMappings.UI);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.UI,(int)UIActions.Continue, TryToExit);
+        {
+            damnTimer = 5f;
             
+            Context.UIService.LoadingScreen.Show();
             base.ExitState();
         }
     }

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

@@ -1,181 +1,95 @@
-using Code.App.Loading;
 using Code.App.StateMachine;
-using Code.Audio;
 using Code.Gameplay.Camera;
-using Code.Gameplay.Camera.CameraStates;
-using Code.Gameplay.Character.Core;
-using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
 using Code.Input;
 using Code.Scenes;
-using Code.Scenes.SceneEnvironments;
 using Code.StateMachine;
 using Code.UI;
-using Code.UI.Panels;
-using Cysharp.Threading.Tasks;
-using Reflex.Core;
-using Reflex.Extensions;
-using UnityEngine;
 using UnityEngine.InputSystem;
-using UnityEngine.SceneManagement;
 
 namespace Code.App.AppStates
 {
     public class GameplayState : BaseState<AppStateMachineContext>
-    { 
+    {
         private PlayerHealth _playerHealth;
-        private IPlayerScore _playerScore;
-        
-        private IOrderService _orderService;
+        private PlayerMoney _playerMoney;
 
-        private CharacterProvider _playerCharacter;
+        private bool _uiLoaded, _sceneLoaded;
+        
         public GameplayState(AppStateMachineContext context) : base(context)
         {
         }
 
         public override void EnterState()
         {
+            _uiLoaded = _sceneLoaded = false;
+            
             Context.UIService.LoadingScreen.Show();
-
-            Context.LoadingManager
-                .RegisterLoading(LoadingWork.LoadScene)
-                .RegisterLoading(LoadingWork.LoadUI)
-                .RegisterLoading(LoadingWork.LoadModelResource)
-                .RegisterLoading(LoadingWork.LoadAudio); 
-             
-            //_playerHealth = Context.PlayerFactory.CreatePlayerHealth();
-
-            //_playerHealth.OnDamage += PlayerDamageTaken;
-            //_playerHealth.OnDeath += EndGame;
             
-            Context.AudioService.TransitToSnapshot(AudioSnapshotState.None);
+            _playerMoney = Context.PlayerFactory.CreatePlayerMoney();
+            _playerHealth = Context.PlayerFactory.CreatePlayerHealth();
             
-            Context.InputService.EnableMap(ActionMappings.Gameplay);
-            
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, InstaKillDEBUG); 
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, RoomPassedDEBUG);
-            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, Tube); 
-
-            Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.DevGen);
-            Context.LoadingManager.OnLoadingEnded += AfterSceneLoaded;
-
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            WaitForLoad();
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-        }
-        private async UniTask WaitForPlayerCharacterLoad() => _playerCharacter = await Context.PlayerFactory.CreatePlayer();
-
-        private async UniTaskVoid WaitForLoad()
-        { 
-            await UniTask.WhenAll(
-                Context.UIService.AsyncSwitchPanelTo(UIPanel.Gameplay), 
-                Context.AudioFactory.WarmGameplayMusic(),
-                Context.AudioFactory.WarmSFX(),
-                Context.AudioFactory.WarmDispatcher()
-            );
-
-            Context.LoadingManager 
-                .UnregisterLoading(LoadingWork.LoadUI) 
-                .UnregisterLoading(LoadingWork.LoadAudio);
-
-            InputServiceInitialize();
-
-            MusicInitialize();
-        }
-
-        private async void AfterSceneLoaded()
-        {
-            Context.LoadingManager 
-                .RegisterLoading(LoadingWork.LoadModelResource);
-            
-            Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
-            Context.LoadingManager.OnLoadingEnded += AfterPlayerLoaded;
-
-            await UniTask.WhenAll( 
-                WaitForPlayerArmsToInitialize(),
-                WaitForPlayerCharacterLoad() 
-            );
-            
-            _playerHealth = Context.PlayerProvider.Health;
-            _playerHealth.OnDamage += PlayerDamageTaken;
             _playerHealth.OnDeath += EndGame;
             
-            Context.LoadingManager 
-                .UnregisterLoading(LoadingWork.LoadModelResource); 
-        }
-
-        private void AfterPlayerLoaded()
-        {
-            Container sceneContainer = SceneManager.GetActiveScene().GetSceneContainer(); 
+            Context.SceneLoaderService.LoadSceneAsync((int)SceneIds.MovementDev, callBack: OnSceneLoaded); // TODO Фабрика игрока Nada
             
-            _playerScore = sceneContainer.Resolve<IPlayerScore>();
-            
-            GameplaySceneEnvironment sceneEnvironment = SceneEnvironmentVariables(sceneContainer);
+            Context.UIService.SwitchPanelTo(UIPanel.Gameplay, callback: PostUILoaded);
 
-            PlayerInitialize(sceneEnvironment);
-            
-            CameraInitialize();
-
-            GameplayServicesInitialize(sceneContainer);
-            
-            UIInitialize();
-            
-            Context.LoadingManager.OnLoadingEnded -= AfterPlayerLoaded;
-            
-            _tickEnabled = true;
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.GiveHealth, GiveHealth);
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.GiveMoney, GiveMoney);
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.LooseHealth, LooseHealth);
+            Context.InputService.DebugBindAction((int)ActionMappings.Debug, (int)DebugActions.LooseMoney, LooseMoney);
         }
-
-        private 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()
+        
+        private void OnSceneLoaded()
         {
-            _playerHealth.InstaKill();
+            _sceneLoaded = true;
+            CheckIfLoaded();
         }
-        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);
+        private void PostUILoaded()
+        {
+            ((GameplayPanel)Context.UIService.CurrentPanel).Initialize(_playerMoney, _playerHealth);
+            _uiLoaded = true;
+            CheckIfLoaded();
+        }
+
+        private void CheckIfLoaded()
+        {
+            if(!_uiLoaded || !_sceneLoaded) return;
             
-            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Peaceful);
+            Context.UIService.LoadingScreen.Hide();
+            
+            Context.CameraStateMachine.SwitchState(CameraMode.FirstPerson);
+            Context.InputService.EnableMap(ActionMappings.Gameplay);
         }
 
-        private void PlayerDamageTaken(int damage, PlayerHealth health)
-        {
-            Context.AudioService.PlayDispatcher((DispatcherSounds)Random.Range((int)DispatcherSounds.TakeDamage1,(int)DispatcherSounds.TakeDamage4));
-        }
-        // DEBUG
-        private void InstaKillDEBUG(InputAction.CallbackContext context)
-        {
-            _playerHealth.InstaKill();
-        }
-        private void RoomPassedDEBUG(InputAction.CallbackContext context)
-        {
-            _orderService.RoomPassed();
-        }
-        private OrderDispenser _debugTube;
 
-        private void Tube(InputAction.CallbackContext context)
+        // Debug
+        private void GiveHealth(InputAction.CallbackContext context)
         {
-            _debugTube.ThrowOrder();
+            _playerHealth.GetDamage(-1);
         }
-        // DEBUG
-        private bool _tickEnabled;
+
+        private void LooseHealth(InputAction.CallbackContext context)
+        {
+            _playerHealth.GetDamage(1);
+        }
+
+        private void GiveMoney(InputAction.CallbackContext context)
+        {
+            _playerMoney.GiveMoney(100);
+            ((GameplayPanel)(Context.UIService.CurrentPanel)).SummonDispatcher();
+        }
+
+        private void LooseMoney(InputAction.CallbackContext context)
+        {
+            _playerMoney.LooseMoney(100);
+            ((GameplayPanel)(Context.UIService.CurrentPanel)).CloseDispatcher();
+        }
+
         public override void Tick()
         {
-            if (!_tickEnabled) return;
-            
-            _orderService.DecreaseTimer(Time.deltaTime);
         }
 
         private void EndGame()
@@ -187,77 +101,16 @@ namespace Code.App.AppStates
         public override void ExitState()
         {
             _playerHealth = 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;
+            _playerMoney = null;
             
             Context.InputService.DisableMap(ActionMappings.Gameplay);
-            Context.AudioService.GladlyAskToStopMusic(MusicType.Action, callback: Context.AudioFactory.ReleaseActionMusic);
-            Context.AudioService.GladlyAskToStopMusic(MusicType.Peaceful, callback: Context.AudioFactory.ReleasePeacefulMusic);
             
-
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug1, InstaKillDEBUG); 
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug4, RoomPassedDEBUG);
-            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.Debug5, Tube);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.GiveHealth, GiveHealth);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.GiveMoney, GiveHealth);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.LooseHealth, LooseHealth);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.Debug, (int)DebugActions.LooseMoney, LooseMoney);
             
             base.ExitState();
         }
-        
-        private void InputServiceInitialize()
-        {
-            Context.InputService.EnableMap(ActionMappings.Gameplay);
-        }
-        private void CameraInitialize()
-        {
-            Context.CameraStateMachine.SwitchState(CameraMode.FirstPerson);
-            ((BaseCameraState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(_playerCharacter.GetFollowTransform());
-        }
-
-        private GameplayPanel _gameplayPanel;
-        private ArmsMeshProvider _armsMesh;
-
-        private void UIInitialize()
-        {
-            _gameplayPanel = (GameplayPanel)Context.UIService.CurrentPanel;
-            _gameplayPanel.Initialize(_playerScore, _playerHealth, _orderService);
-            Context.AudioService.OnDispatcherStarted += _gameplayPanel.SummonDispatcher;
-            Context.AudioService.OnDispatcherEnded += _gameplayPanel.CloseDispatcher;
-        }
-        private void MusicInitialize()
-        {
-            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Peaceful);
-            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Action);
-            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Peaceful);
-        }
-        private void PlayerInitialize(GameplaySceneEnvironment sceneEnvironment)
-        {
-            _playerCharacter.Teleport(sceneEnvironment.playerSpawnPoint.position, sceneEnvironment.playerSpawnPoint.rotation);
-            _playerCharacter.PlayerAnimator.SetAnimator(_armsMesh.ArmsAnimator);
-        }
-        private void GameplayServicesInitialize(Container sceneContainer)
-        { 
-            _orderService = sceneContainer.Resolve<IOrderService>();
-            
-            _orderService.OnOrderGiven += OrderGiven;
-            _orderService.OnOrderRecieved += OrderRecieved;
-            _orderService.OnOrderDelivered += OrderDelivered;
-            _orderService.OnOrderFailure += OrderFailure;
-        }
-        private GameplaySceneEnvironment SceneEnvironmentVariables(Container sceneContainer)
-        {
-            var sceneEnvironment = (GameplaySceneEnvironment)sceneContainer.Resolve<CurrentSceneEnvironment>();
- 
-            
-            return sceneEnvironment;
-        }
     }
 }

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

@@ -1,16 +1,11 @@
-using Code.App.Loading;
 using Code.App.StateMachine;
-using Code.Audio;
 using Code.Gameplay.Camera;
 using Code.Gameplay.Camera.CameraStates;
-using Code.Gameplay.Door;
 using Code.Input;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Code.StateMachine;
 using Code.UI;
-using Code.UI.Panels;
-using Cysharp.Threading.Tasks;
 using Reflex.Extensions;
 using UnityEngine;
 using UnityEngine.SceneManagement;
@@ -19,89 +14,61 @@ namespace Code.App.AppStates
 {
     public class MainMenuState : BaseState<AppStateMachineContext>
     {
+        private bool _uiLoaded, _sceneLoaded;
         public MainMenuState(AppStateMachineContext context) : base(context)
         {
         }
 
         public override void EnterState()
         {
-            Context.LoadingManager
-                .RegisterLoading(LoadingWork.LoadScene)
-                .RegisterLoading(LoadingWork.LoadUI)
-                .RegisterLoading(LoadingWork.LoadAudio);
+            _uiLoaded = _sceneLoaded = false;
             
-            // Context.UIService.LoadingScreen.Show();
-
-            Context.CameraStateMachine.SwitchState(CameraMode.MainMenu);
+            Context.UIService.LoadingScreen.Show();
             
-            Context.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.MainMenu);
-            Context.LoadingManager.OnLoadingEnded += AfterSceneLoaded;
+            Context.SceneLoaderService.LoadSceneAsync((int)SceneIds.MainMenu, callBack: SceneLoaded); 
+             
+            Context.UIService.SwitchPanelTo(UIPanel.MainMenu, PostUILoaded);
 
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            WaitForLoad();
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Context.CameraStateMachine.SwitchState(CameraMode.Static);
         }
 
-        private async UniTaskVoid WaitForLoad()
+        private void PostUILoaded()
         {
-            await UniTask.WhenAll(
-                Context.UIService.AsyncSwitchPanelTo(UIPanel.MainMenu),
-                Context.AudioFactory.WarmMenuMusic(),
-                Context.AudioFactory.WarmAudioTestClips()
-            );
-            Context.LoadingManager
-                .UnregisterLoading(LoadingWork.LoadUI)
-                .UnregisterLoading(LoadingWork.LoadAudio);
+            ((MainMenuPanel)Context.UIService.CurrentPanel).startButton.onClick.AddListener(StartGame);
+            ((MainMenuPanel)Context.UIService.CurrentPanel).exitButton.onClick.AddListener(ExitGame);
             
-            InitializeAudio();
-
-            InitializeInput();
-        }
-
-        private void AfterSceneLoaded()
-        {
-            var mainMenuEnvironment = (MainMenuEnvironment)SceneManager.GetActiveScene()
-                .GetSceneContainer().Resolve<CurrentSceneEnvironment>();
-
-            InitializeUI(mainMenuEnvironment);
-
-            InitializeCamera(mainMenuEnvironment);
+            _uiLoaded = true;
             
-            Context.LoadingManager.OnLoadingEnded -= AfterSceneLoaded;
+            CheckIfLoaded();
         }
 
-        private void InitializeCamera(MainMenuEnvironment mainMenuEnvironment)
+        private void SceneLoaded()
         {
-            ((Gameplay.Camera.CameraStates.MainMenuState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(mainMenuEnvironment
-                .cameraPosition);
+            var hui = ((MainMenuEnvironment)SceneManager.GetActiveScene()
+                .GetSceneContainer().Resolve<CurrentSceneEnvironment>());
+            
+            ((StaticState)Context.CameraStateMachine.CurrentBaseState).LookTarget = 
+                hui.cameraTarget;
+            
+            ((BaseCameraState)Context.CameraStateMachine.CurrentBaseState).SetFollowTransform(hui.cameraPosition);
+
+            
+            _sceneLoaded = true;
+            
+            CheckIfLoaded();
         }
 
-        private void InitializeInput()
+        private void CheckIfLoaded()
         {
+            if(!_uiLoaded || !_sceneLoaded) return;
+            
+            Context.UIService.LoadingScreen.Hide();
+            
             Context.InputService.EnableMap(ActionMappings.MainMenu);
+            
+            base.EnterState();
         }
-
-        private void InitializeAudio()
-        {
-            Context.AudioService.TransitToSnapshot(AudioSnapshotState.Menu);
-            Context.AudioService.PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType.Menu);
-        }
-
-        private void InitializeUI(MainMenuEnvironment mainMenuEnvironment)
-        {
-            var menuPanel = (MainMenuPanel)Context.UIService.CurrentPanel;
-            menuPanel.Initialize(mainMenuEnvironment.uiVariables,
-                mainMenuEnvironment.startButton,
-                mainMenuEnvironment.settingButton, 
-                mainMenuEnvironment.exitButton);
-
-            menuPanel.startButton.button.onClick.AddListener(StartGame);
-            menuPanel.exitButton.button.onClick.AddListener(ExitGame);
-
-            mainMenuEnvironment.menuButtonsCanvas.worldCamera = Context.CameraStateMachine.Camera;
-            mainMenuEnvironment.settingsCanvas.worldCamera = Context.CameraStateMachine.Camera;
-        }
-
+        
         public override void Tick()
         {
         }
@@ -120,9 +87,7 @@ namespace Code.App.AppStates
         public override void ExitState()
         {
             Context.InputService.DisableMap(ActionMappings.MainMenu);
-            Context.AudioService.GladlyAskToStopMusic(MusicType.Menu, callback: Context.AudioFactory.ReleaseMenuMusic);
 
-            Context.AudioFactory.ReleaseAudioTestClips();
             base.ExitState();
         }
     }

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

@@ -1,14 +1,9 @@
-using System.Collections.Generic;
-using Code.App.Loading;
+using System.Threading.Tasks;
 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;
@@ -18,6 +13,7 @@ using Cysharp.Threading.Tasks;
 using Reflex.Core;
 using Reflex.Injectors;
 using UnityEngine;
+using UnityEngine.AddressableAssets;
 using UnityEngine.InputSystem;
 
 namespace Code.App
@@ -30,22 +26,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));
-            containerBuilder.AddSingleton(typeof(EnemyFactory), typeof(IEnemyFactory));
-            containerBuilder.AddSingleton(typeof(PlayerProvider), typeof(IPlayerProvider));
-            // 
+
             InitializeCamera(containerBuilder, staticDataService);
-            
             containerBuilder.AddSingleton(typeof(UIFactory), typeof(IUIFactory));
             containerBuilder.AddSingleton(typeof(UIService), typeof(IUIService));
-            
-            containerBuilder.AddSingleton(typeof(AudioFactory), typeof(IAudioFactory));
-            containerBuilder.AddSingleton(typeof(AudioService), typeof(IAudioService));
-            
             containerBuilder.AddSingleton(typeof(SceneLoaderService), typeof(ISceneLoaderService));
             
             containerBuilder.OnContainerBuilt += Bootstrap;
@@ -77,38 +63,18 @@ namespace Code.App
             staticDataService.Load();
 
             containerBuilder.AddSingleton(staticDataService, typeof(IStaticDataService));
-            
             containerBuilder.AddSingleton(staticDataService.InputConfig.inputActionAsset, typeof(InputActionAsset));
             containerBuilder.AddSingleton(staticDataService.InputConfig, typeof(InputConfig));
-            
             containerBuilder.AddSingleton(staticDataService.CameraConfig, typeof(CameraConfig));
-            containerBuilder.AddSingleton(staticDataService.CameraSettingsConfigs, typeof(Dictionary<CameraMode,CameraSettingsConfig>));
-            
             containerBuilder.AddSingleton(staticDataService.PlayerConfig, typeof(PlayerConfig));
             containerBuilder.AddSingleton(staticDataService.CharacterConfig, typeof(CharacterConfig));
-            
             containerBuilder.AddSingleton(staticDataService.UIConfig, typeof(UIConfig));
-            
-            containerBuilder.AddSingleton(staticDataService.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.DispatcherSoundListConfig, typeof(DispatcherSoundListConfig));
-            containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
-            containerBuilder.AddSingleton(staticDataService.AudioSourceSettingsConfigs, typeof(Dictionary<AudioSourceType, AudioSourceSettingsConfig>));
-
-            containerBuilder.AddSingleton(staticDataService.OrderServiceConfig, typeof(OrderServiceConfig));
-            containerBuilder.AddSingleton(staticDataService.OrderBoxConfig, typeof(OrderBoxConfig)); 
-            
-            containerBuilder.AddSingleton(staticDataService.GeneratorConfig, typeof(GeneratorConfig)); 
+            // containerBuilder.AddSingleton(staticDataService.UIConfig.canvasPrefab, typeof(Canvas));
+            // containerBuilder.AddSingleton(staticDataService.UIConfig.uiElementsPrefabs, typeof(UIElement[]));
         }
 
+        private bool _onUiLoaded;
         private AppStateMachine _appStateMachine;
-
         private void Bootstrap(Container container)
         {
             _appStateMachine = container.Resolve<AppStateMachine>();
@@ -118,29 +84,20 @@ namespace Code.App
             CameraStateMachine cameraStateMachine = container.Resolve<CameraStateMachine>();
             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);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            
+            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen);
+            DontDestroyOnLoad(loadingScreen);
+            
+            IUIService uiService = container.Resolve<IUIService>();
+            uiService.Initialize(loadingScreen.GetComponent<LoadingScreen>());
+            
+            TryStartGame();
         }
-        private async UniTaskVoid BootstrapFinish(Container container)
+
+        private void TryStartGame()
         {
-            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen).GetComponent<LoadingScreen>();
-            DontDestroyOnLoad(loadingScreen.gameObject);
-
-            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
-            loadingManager.OnLoadingStarted += loadingScreen.Show;
-            loadingManager.OnLoadingEnded += loadingScreen.Hide;
-
-            loadingManager.RegisterLoading(LoadingWork.Bootstrap);
-            
-            await UniTask.WhenAll(
-                container.Resolve<IUIService>().Initialize(loadingScreen),
-                container.Resolve<IAudioService>().Initialize()
-                );
-            
-            loadingManager.UnregisterLoading(LoadingWork.Bootstrap);
             
+            // TODO: поменяно для теста
             _appStateMachine
                 .SwitchState(AppState.MainMenu)
                 .AllowStateTransition(AppState.Gameplay);

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

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

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

@@ -1,16 +0,0 @@
-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

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

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

@@ -1,47 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,52 +0,0 @@
-using Code.App.Loading;
-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
-{
-    public class GameplaySceneInstaller : MonoBehaviour, IInstaller
-    {
-        [SerializeField] private GameplaySceneEnvironment _gameplaySceneEnvironment;
-        
-        public void InstallBindings(ContainerBuilder containerBuilder)
-        {
-            containerBuilder.AddScoped(typeof(GameplaySceneEnvironment), typeof(CurrentSceneEnvironment));
-            containerBuilder.AddScoped(typeof(PlayerScore), typeof(IPlayerScore));
-            containerBuilder.AddScoped(typeof(OrderService), typeof(IOrderService));
-            containerBuilder.AddScoped(typeof(RoomGeneratorFactory), typeof(IRoomGeneratorFactory));
-            containerBuilder.AddScoped(typeof(RoomGenerator));
-
-            containerBuilder.OnContainerBuilt += Initialize;
-        }
-
-        private void Initialize(Container container)
-        {
-            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
-            
-            GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
-
-            env.TransitVariables(_gameplaySceneEnvironment);
-            
-            loadingManager
-                .UnregisterLoading(LoadingWork.LoadScene);
-            
-            LoadRooms(container,loadingManager);
-        }
-
-        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/GameplaySceneInstaller.cs.meta

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

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

@@ -1,8 +1,7 @@
-using Code.App.Loading;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Reflex.Core;
-using UnityEngine; 
+using UnityEngine;
 
 namespace Code.App.SceneInstallers
 {
@@ -22,11 +21,6 @@ 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,9 +1,5 @@
-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;
@@ -13,16 +9,11 @@ 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 IPlayerProvider PlayerProvider { get; private set; }
-        [Inject] public IAudioFactory AudioFactory { get; private set; }
-        [Inject] public IAudioService AudioService { get; private set; }
-        [Inject] public IEnemyFactory EnemyFactory { get; private set; } 
     }
 }

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

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

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

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

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

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

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

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

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

@@ -1,352 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using Code.Configs;
-using Code.Constants;
-using Cysharp.Threading.Tasks;
-using DG.Tweening;
-using Reflex.Attributes;
-using Unity.VisualScripting;
-using UnityEngine;
-using UnityEngine.AddressableAssets;
-using UnityEngine.Audio;
-using Random = UnityEngine.Random;
-
-namespace Code.Audio
-{
-    public class AudioService : IAudioService
-    {
-        private IAudioFactory _audioFactory;
-
-        private AudioMixer _mixer;
-        private AudioSource _actionMusicSource;
-        private AudioSource _peacefulMusicSource;
-
-        private AudioMixerGroup _masterGroup,
-            // _musicGroup,
-            _actionMusicGroup,
-            _menuMusicGroup,
-            _peacefulMusicGroup,
-            _SFXGroup,
-            _creaturesGroup,
-            _dispatcherGroup,
-            _courierGroup,
-            _enemiesGroup;
-
-        private readonly AudioSourcePool _audioSourcePool;
-
-        private Dictionary<AudioSnapshotState, AudioMixerSnapshot> _snapshots = new();
-        private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
-
-        public AudioService(IAudioFactory audioFactory, Dictionary<AudioSourceType, AudioSourceSettingsConfig> settings)
-        {
-            _audioFactory = audioFactory;
-            _audioSourcePool = new(settings);
-            _settings = settings;
-        }
-
-        // TODO Грязно, убрать снапшоты НАХУЙ
-        public float GetSetting(AudioType type)
-        {
-            float value;
-            switch (type)
-            {
-                case AudioType.SFX:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.GetFloat(_SFXGroup.name, out value);
-                    break;
-                case AudioType.Master:
-                    _snapshots[AudioSnapshotState.Menu].audioMixer.GetFloat(_masterGroup.name, out value);
-                    break;
-                case AudioType.Creatures:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.GetFloat(_creaturesGroup.name, out value);
-                    break;
-                case AudioType.GameplayMusic:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.GetFloat(_peacefulMusicGroup.name, out value);
-                    break;
-                case AudioType.MenuMusic:
-                    _snapshots[AudioSnapshotState.Menu].audioMixer.GetFloat(_menuMusicGroup.name, out value);
-                    break;
-                case AudioType.DispatcherSounds:
-                    _snapshots[AudioSnapshotState.Action].audioMixer.GetFloat(_dispatcherGroup.name, out value);
-                    break;
-                default:
-                    value = 1;
-                    break;
-            }
-
-            value = Mathf.Pow(10f, value / 20);
-
-            return value;
-        }
-
-        // TODO Грязно, убрать снапшоты НАХУЙ
-        public void ChangeSetting(AudioType type, float value)
-        {
-            float volume = Mathf.Log10(value) * 20;
-            switch (type)
-            {
-                case AudioType.SFX:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_SFXGroup.name, volume);
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_SFXGroup.name, volume);
-                    break;
-                case AudioType.Master:
-                    _snapshots[AudioSnapshotState.Menu].audioMixer.SetFloat(_masterGroup.name, volume);
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_masterGroup.name, volume);
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_masterGroup.name, volume);
-                    break;
-                case AudioType.Creatures:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_creaturesGroup.name, volume);
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_creaturesGroup.name, volume);
-                    break;
-                case AudioType.GameplayMusic:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_peacefulMusicGroup.name, volume);
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_actionMusicGroup.name, volume);
-                    break;
-                case AudioType.MenuMusic:
-                    _snapshots[AudioSnapshotState.Menu].audioMixer.SetFloat(_menuMusicGroup.name, volume);
-                    break;
-                case AudioType.DispatcherSounds:
-                    _snapshots[AudioSnapshotState.Peaceful].audioMixer.SetFloat(_dispatcherGroup.name, volume);
-                    _snapshots[AudioSnapshotState.Action].audioMixer.SetFloat(_dispatcherGroup.name, volume);
-                    break;
-            }
-            // _mixer.FindSnapshot("Action").audioMixer.SetFloat("music", volume);
-        }
-
-        public async UniTask Initialize()
-        {
-            // _mixer = await _audioFactory.CreateMixer();
-            _mixer = _audioFactory.AudioMixer;
-
-            _masterGroup = _mixer.FindMatchingGroups(AudioGroups.MasterGroup)[0];
-            _menuMusicGroup = _mixer.FindMatchingGroups(AudioGroups.MenuMusicGroup)[0];
-            _actionMusicGroup = _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0];
-            _peacefulMusicGroup = _mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0];
-            // _musicGroup = _mixer.FindMatchingGroups(AudioGroups.MusicGroup)[0];
-            _musicAudioGroups.Add(MusicType.Menu, _mixer.FindMatchingGroups(AudioGroups.MenuMusicGroup)[0]);
-            _musicAudioGroups.Add(MusicType.Action, _mixer.FindMatchingGroups(AudioGroups.ActionMusicGroup)[0]);
-            _musicAudioGroups.Add(MusicType.Peaceful, _mixer.FindMatchingGroups(AudioGroups.PeacefulMusicGroup)[0]);
-
-            _cancellationTokenSources.Add(MusicType.Menu, new());
-            _cancellationTokenSources.Add(MusicType.Action, new());
-            _cancellationTokenSources.Add(MusicType.Peaceful, new());
-
-            _musicAudioSources.Add(MusicType.Menu, null);
-            _musicAudioSources.Add(MusicType.Action, null);
-            _musicAudioSources.Add(MusicType.Peaceful, null);
-
-            _SFXGroup = _mixer.FindMatchingGroups(AudioGroups.SFXGroup)[0];
-            _creaturesGroup = _mixer.FindMatchingGroups(AudioGroups.CreaturesGroup)[0];
-            _dispatcherGroup = _mixer.FindMatchingGroups(AudioGroups.DispatcherMusicGroup)[0];
-            _courierGroup = _mixer.FindMatchingGroups(AudioGroups.CourierMusicGroup)[0];
-            _enemiesGroup = _mixer.FindMatchingGroups(AudioGroups.EnemiesMusicGroup)[0];
-
-            _snapshots[AudioSnapshotState.None] = _mixer.FindSnapshot(AudioGroups.NoneSnapshot);
-            _snapshots[AudioSnapshotState.Peaceful] = _mixer.FindSnapshot(AudioGroups.PeacefulSnapshot);
-            _snapshots[AudioSnapshotState.Action] = _mixer.FindSnapshot(AudioGroups.ActionSnapshot);
-            _snapshots[AudioSnapshotState.Menu] = _mixer.FindSnapshot(AudioGroups.MenuSnapshot);
-
-            await _audioFactory.LoadAudioSourcePrefab(_audioSourcePool.Initialize);
-        }
-
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-        private Dictionary<MusicType, CancellationTokenSource> _cancellationTokenSources = new();
-        private Dictionary<MusicType, AudioSource> _musicAudioSources = new();
-        private Dictionary<MusicType, AudioMixerGroup> _musicAudioGroups = new();
-
-        public async UniTaskVoid PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType musicType)
-        {
-            if (!_musicAudioSources[musicType])
-            {
-                _musicAudioSources[musicType] = _audioSourcePool.GetSource();
-                _musicAudioSources[musicType].spatialBlend = _settings[AudioSourceType.NoBlend].spatialBlend;
-                _musicAudioSources[musicType].outputAudioMixerGroup = _musicAudioGroups[musicType];
-            }
-
-            _musicAudioSources[musicType].resource =
-                _audioFactory.MusicDictionary[musicType][
-                    Random.Range(0, _audioFactory.MusicDictionary[musicType].Count)];
-
-            _musicAudioSources[musicType].Play();
-
-            // await UniTask.WaitUntilValueChanged(_musicAudioSources[musicType],
-            //     _ => !_musicAudioSources[musicType].isPlaying,
-            //     cancellationToken: _cancellationTokenSources[musicType].Token);
-            await UniTask.NextFrame();
-            // Debug.Log($"Playing {musicType}");
-            var (isCanceled, _) = await UniTask.WaitUntilValueChanged(_musicAudioSources[musicType],
-                _ => !_musicAudioSources[musicType].isPlaying,
-                cancellationToken: _cancellationTokenSources[musicType].Token).SuppressCancellationThrow();
-            // Debug.Log($"Finished {musicType}");
-
-            if (isCanceled)
-            {
-                // Debug.Log($"Cancelled {musicType}");
-                _cancellationTokenSources[musicType].Dispose();
-                _cancellationTokenSources[musicType] = new();
-
-                _audioSourcePool.ReleaseSource(_musicAudioSources[musicType]);
-                _musicAudioSources[musicType] = null;
-
-                return;
-            }
-
-            PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(musicType);
-        }
-
-        public async UniTaskVoid GladlyAskToStopMusic(MusicType musicType,
-            AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null)
-        {
-            TransitToSnapshot(audioSnapshotState, time);
-
-            await UniTask.WaitForSeconds(time);
-
-            _cancellationTokenSources[musicType].Cancel();
-
-            callback?.Invoke();
-        }
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-
-        public void StopMusic()
-        {
-            _peacefulMusicSource.Stop();
-            _actionMusicSource.Stop();
-        }
-
-        public void GladlyAskToStopMusic(Action callback = null)
-        {
-            TransitToSnapshot(AudioSnapshotState.None);
-            _peacefulMusicSource.Stop();
-            _actionMusicSource.Stop();
-
-            callback?.Invoke();
-        }
-
-        public void TransitToSnapshot(AudioSnapshotState state, float time = 1f)
-        {
-            _snapshots[state].TransitionTo(time);
-        }
-
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-        public void PlaySFX(SFXSounds sfxId, Vector3 position)
-        {
-            _audioSourcePool.PlayOneShot(_audioFactory.SFXAudios[(int)sfxId], position, _SFXGroup);
-        }
-
-        public void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position)
-        {
-            _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position, _enemiesGroup);
-        }
-
-        // Чинить долго и дорого пусть Артёмов будет много, ведь он наш друг
-        public event IAudioService.OnAudioPlayingDelegate OnDispatcherStarted;
-        public event IAudioService.OnAudioPlayingDelegate OnDispatcherEnded;
-
-        public void PlayDispatcher(DispatcherSounds dispatcherSoundId)
-        {
-            OnDispatcherStarted?.Invoke();
-            _audioSourcePool.PlayOneShot(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup,
-                AudioSourceType.NoBlend, () => OnDispatcherEnded?.Invoke());
-        }
-
-        private CancellationTokenSource _testClipCancellationTokenSource = new();
-        private void ResetCurrentTestAudioSource() => _currentTestClipAudioType = AudioType.Master;
-        // TODO Засунуть в словарь
-        public void PlayTestClip(AudioType audioType)
-        {
-            if(_currentTestClipAudioType == audioType) return;
-            
-            _testClipCancellationTokenSource.Cancel();
-            _testClipCancellationTokenSource = new();
-
-            _currentTestClipAudioType = audioType;
-
-            switch (audioType)
-            {
-                case AudioType.SFX:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _SFXGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.Master:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _masterGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.Creatures:
-                    _audioSourcePool.PlayOneShot( _audioFactory.AudioTestClips[audioType],
-                        _creaturesGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.GameplayMusic:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _actionMusicGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.MenuMusic:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _menuMusicGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-                case AudioType.DispatcherSounds:
-                    _audioSourcePool.PlayOneShot(_audioFactory.AudioTestClips[audioType],
-                        _dispatcherGroup, _testClipCancellationTokenSource,
-                        AudioSourceType.NoBlend, ResetCurrentTestAudioSource);
-                    break;
-            }
-        }
-
-        private AudioSource _testClipAudioSource;
-        private AudioType _currentTestClipAudioType;
-
-        // Эффективно и просто, может не так хитровыебано
-        private void ReleaseTestAudioClipSource()
-        {
-            _testClipAudioSource = null;
-        }
-
-        // TODO Засунуть в словарь
-        public void PlayTestClipDeprecated(AudioType audioType)
-        {
-            if (!_testClipAudioSource) _testClipAudioSource = _audioSourcePool.GetSource();
-            else if (_currentTestClipAudioType != audioType) _testClipAudioSource.Stop();
-            else return;
-
-            _currentTestClipAudioType = audioType;
-
-            switch (audioType)
-            {
-                case AudioType.SFX:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _SFXGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.Master:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _masterGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.Creatures:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _creaturesGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.GameplayMusic:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _actionMusicGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.MenuMusic:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _menuMusicGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-                case AudioType.DispatcherSounds:
-                    _audioSourcePool.PlayOneShot(_testClipAudioSource, _audioFactory.AudioTestClips[audioType],
-                        _dispatcherGroup,
-                        AudioSourceType.NoBlend, ReleaseTestAudioClipSource);
-                    break;
-            }
-        }
-    }
-}

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

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

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

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

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

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

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

@@ -1,121 +0,0 @@
-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
-{
-    public class AudioSourcePool
-    {
-        // The pool holds plain GameObjects (you can swap this for any component type).
-        private IObjectPool<AudioSource> _pool; 
-        private GameObject _sourcePrefab;
-
-        private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
-        
-        public AudioSourcePool(Dictionary<AudioSourceType, AudioSourceSettingsConfig> settings) => _settings = settings;
-
-        public void Initialize(GameObject sourcePrefab)
-        {
-            _sourcePrefab = sourcePrefab;
-            
-            // Create a pool with the four core callbacks.
-            _pool = new ObjectPool<AudioSource>(
-                createFunc: CreateItem,
-                // actionOnGet: OnGet,
-                actionOnRelease: OnRelease,
-                actionOnDestroy: OnDestroyItem,
-                collectionCheck: true,   // helps catch double-release mistakes
-                defaultCapacity: 10,
-                maxSize: 20
-            );
-        }
-
-        // Creates a new pooled GameObject the first time (and whenever the pool needs more).
-        private AudioSource CreateItem()
-        {
-            AudioSource audioSource = Object.Instantiate(_sourcePrefab).GetComponent<AudioSource>();
-            audioSource.name = "PooledAudioSource";
-            Object.DontDestroyOnLoad(audioSource);
-            return audioSource;
-        }
-
-        // Called when an item is taken from the pool.
-        private void OnGet(AudioSource source)
-        {
-            //source.gameObject.SetActive(true);
-        }
-
-        // Called when an item is returned to the pool.
-        private void OnRelease(AudioSource source)
-        {
-            source.Stop();
-            //source.gameObject.SetActive(false);
-        }
-
-        // Called when the pool decides to destroy an item (e.g., above max size).
-        private void OnDestroyItem(AudioSource source)
-        {
-            Object.Destroy(source.gameObject);
-        }
-        
-        public async UniTaskVoid PlayOneShot(AudioClip clip, Vector3 position, AudioMixerGroup audioMixerGroup, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
-        {
-            AudioSource source = _pool.Get();
-            source.PlayOneShot(clip);
-            source.spatialBlend = _settings[audioSourceType].spatialBlend;
-            source.transform.position = position;
-            source.outputAudioMixerGroup = audioMixerGroup;
-            
-            await UniTask.WaitUntilValueChanged(source, x => x.isPlaying);
-            onComplete?.Invoke();
-            _pool.Release(source);
-        }
-        public async UniTaskVoid PlayOneShot(AudioClip clip, AudioMixerGroup audioMixerGroup, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
-        {
-            AudioSource source = _pool.Get();
-            source.PlayOneShot(clip);
-            source.spatialBlend = _settings[audioSourceType].spatialBlend;
-            source.outputAudioMixerGroup = audioMixerGroup;
-            
-            await UniTask.WaitUntilValueChanged(source, x => x.isPlaying);
-            onComplete?.Invoke();
-            _pool.Release(source);
-        } 
-        public 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/AudioSourcePool.cs.meta

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

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

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

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

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

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

@@ -1,32 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Cysharp.Threading.Tasks;
-using UnityEngine;
-using UnityEngine.Audio;
-
-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; }
-        UniTask LoadAudioSourcePrefab(Action<GameObject> callback);
-        UniTask WarmGameplayMusic( );
-        void ReleaseActionMusic();
-        void ReleasePeacefulMusic();
-        UniTask WarmAudioTestClips( );
-        void ReleaseAudioTestClips();
-        UniTask WarmMenuMusic( );
-        void ReleaseMenuMusic();
-        UniTask WarmSFX( );
-        void ReleaseSFX();
-        UniTask WarmEnemies( );
-        void ReleaseEnemies();
-        UniTask WarmDispatcher( );
-        void ReleaseDispatcher();
-    }
-}

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

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

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

@@ -1,27 +0,0 @@
-using System;
-using Cysharp.Threading.Tasks;
-using UnityEngine;
-
-namespace Code.Audio
-{
-    public interface IAudioService
-    {
-        UniTask Initialize();
-        UniTaskVoid PlayRandomMusicUntilHumanityWillBeDestroyedForTheySins(MusicType musicType);
-        UniTaskVoid GladlyAskToStopMusic(MusicType musicType, AudioSnapshotState audioSnapshotState = AudioSnapshotState.None, float time = 1f, Action callback = null);
-        void StopMusic();
-        void GladlyAskToStopMusic(Action callback = null);
-        void TransitToSnapshot(AudioSnapshotState state, float time = 1f);
-        void PlaySFX(SFXSounds sfxId, Vector3 position);
-        void PlayEnemy(EnemiesSounds enemySoundId, Vector3 position);
-
-        delegate void OnAudioPlayingDelegate();
-
-        event OnAudioPlayingDelegate OnDispatcherStarted;
-        event OnAudioPlayingDelegate OnDispatcherEnded;
-        void PlayDispatcher(DispatcherSounds dispatcherSoundId);
-        void ChangeSetting(AudioType type, float value);
-        float GetSetting(AudioType type);
-        void PlayTestClip(AudioType audioType);
-    }
-}

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

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

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

@@ -1,18 +0,0 @@
-namespace Code.Audio
-{
-    public enum MusicType
-    {
-        Menu,
-        Peaceful,
-        Action
-    }
-    public enum AudioType
-    {
-        Master,
-        MenuMusic,
-        GameplayMusic,
-        Creatures,
-        DispatcherSounds,
-        SFX
-    } 
-}

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

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

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

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

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

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

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

@@ -1,14 +0,0 @@
-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

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

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

@@ -1,11 +0,0 @@
-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

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

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

@@ -1,14 +0,0 @@
-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

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

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

@@ -22,12 +22,18 @@ namespace Code.Configs
             slideSpeed = 20f,               // Скорость слайда
             slideDuration = 0.8f,           // Длительность слайда в секундах
             slideCooldown = 1.5f;           // Время перезарядки слайда в секундах
+
+        // Залазание на стены
+        public float 
+            wallClimbSpeedFactor = 0.8f,       // Коэффициент преобразования горизонтальной скорости в вертикальную при залазании на стену
+            minWallClimbSpeed = 9f,            // Минимальная горизонтальная скорость для начала залазания на стену
+            wallDetectionAngleThreshold = 80f; // Максимальный угол (в градусах) от вертикали, при котором поверхность считается "стеной"
         
         // Наклон при залазании на стены
-        public float
-            leanAngle = 25f,
-            leanThreshold = 0.3f,
-            leanSmoothSpeed = 10f;
+        public float 
+            maxWallLeanAngle = 45f,        // Максимальный угол наклона от стены (в градусах)
+            wallLeanSharpness = 50f,       // Скорость наклона/выпрямления (чем выше — тем резче)
+            wallLeanHeightScale = 0.1f;    // Множитель: на сколько метров подъёма = 1 единица "наклона"
 
         // Гравитация
         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/CharacterSoundListConfig.cs.meta

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

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

@@ -1,29 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,29 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,29 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,11 +0,0 @@
-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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -9,16 +9,13 @@ 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.None];
+            CurrentBaseState = States[CameraMode.Static];
         }
         
-        public UnityEngine.Camera Camera => StateMachineContext.Camera;
 
         protected override bool CheckTransitionAllowed(CameraMode nextState) => true;
 

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

@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using Code.Configs;
 using Code.Input;
 using Reflex.Attributes;
@@ -10,6 +9,5 @@ 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(Vector3.up * (rotationInput.x * RotationSpeed));
+            var rotationFromInput = Quaternion.Euler(FollowTransform.up * (rotationInput.x * RotationSpeed));
             PlanarDirection = rotationFromInput * PlanarDirection;
             var planarRotation = Quaternion.LookRotation(PlanarDirection, FollowTransform.up);
             

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

@@ -14,16 +14,14 @@ 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();
         }
 
         protected override void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)

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

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

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

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

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

@@ -1,21 +0,0 @@
-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

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

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

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

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

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

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

@@ -15,12 +15,6 @@ 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)
@@ -32,32 +26,21 @@ namespace Code.Gameplay.Character.Controller.Abilities
         }
 
         // Обработка столкновения при движении (вызывается при ударе о препятствие)
-        public bool TryClimbWall(KinematicCharacterMotor motor, Vector3 hitNormal)
+        public void OnMovementHit(KinematicCharacterMotor motor, Vector3 hitNormal)
         {
             // Проверяем, что это вертикальная или почти вертикальная поверхность (стена)
             var dotWithUp = Vector3.Dot(hitNormal, motor.CharacterUp);
-            
-            if (Mathf.Abs(dotWithUp) > WallNormalThreshold) 
-            {
-                // Сбрасываем сессию, если коснулись пола/потолка → выход из "режима стены"
-                _hasClimbedThisWallSession = false;
-                return false;
-            }
+            if (Mathf.Abs(dotWithUp) > WallNormalThreshold) return; // Не стена — это пол или потолок
 
-            // Запрещаем повторное залазание в рамках одной сессии
-            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;
 
@@ -66,26 +49,6 @@ 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,78 +1,79 @@
 using UnityEngine;
+using KinematicCharacterController;
 
 namespace Code.Gameplay.Character.Controller.Abilities
 {
+    /*
+     * Механика наклона персонажа при контакте со стеной
+     * Управляет визуальным наклоном модели в зависимости от высоты подъёма по стене
+     */
     public class WallLeanMechanic
     {
-        private readonly float _leanAngle;
-        private readonly float _threshold;
-        private readonly float _smoothSpeed;
+        private readonly float _maxLeanAngle;
+        private readonly float _leanSharpness;
+        private readonly float _heightScale;
+        
+        private Transform _characterTransform;
+        private Vector3 _lastWallNormal;
+        private float _lastWallContactHeight;
+        private float _leanFactor;
 
-        private Transform _model;
-
-        public WallLeanMechanic(
-            float leanAngle,
-            float threshold,
-            float smoothSpeed)
+        public WallLeanMechanic(float maxLeanAngle, float leanSharpness, float heightScale)
         {
-            _leanAngle = leanAngle;
-            _threshold = threshold;
-            _smoothSpeed = smoothSpeed;
+            _maxLeanAngle = maxLeanAngle;
+            _leanSharpness = leanSharpness;
+            _heightScale = heightScale;
         }
 
-        public void SetModel(Transform model) => _model = model;
-
-        public void Update(bool isWallRunning, Vector3 wallNormal, Vector3 characterForward)
+        // Назначаем трансформ визуальной модели один раз
+        public void SetCharacterTransform(Transform transform)
         {
-            if (!_model)
+            _characterTransform = transform;
+        }
+
+        // Вызывается из OnMovementHit
+        public void OnWallContact(Vector3 wallNormal, float contactHeight)
+        {
+            _lastWallNormal = wallNormal;
+            _lastWallContactHeight = contactHeight; }
+
+        // Обновление каждый кадр
+        public void UpdateLean(KinematicCharacterMotor motor, float deltaTime)
+        {
+            if (!_characterTransform) return;
+            
+            var isGrounded = motor.GroundingStatus.IsStableOnGround;
+
+            if (!isGrounded)
             {
-                _model.localRotation = Quaternion.identity;
+                var heightDelta = motor.TransientPosition.y - _lastWallContactHeight;
+                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 targetRotation = Quaternion.identity;
+            var leanDirection = -_lastWallNormal;
+            leanDirection = Vector3.ProjectOnPlane(leanDirection, motor.CharacterUp).normalized;
 
-            if (isWallRunning)
-            {
-                var n = new Vector3(wallNormal.x, 0f, wallNormal.z).normalized;
-                if (n.sqrMagnitude < 0.001f) n = Vector3.forward;
+            if (leanDirection.sqrMagnitude < 0.01f) return;
 
-                var bodyRight = Vector3.Cross(Vector3.up, characterForward).normalized;
-                var side = Vector3.Dot(n, bodyRight);
-                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)
-            );
+            var leanAngle = _leanFactor * _maxLeanAngle;
+            var leanRotation = Quaternion.AngleAxis(leanAngle, Vector3.Cross(motor.CharacterUp, leanDirection));
+            _characterTransform.localRotation = leanRotation;
         }
     }
 }

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

@@ -1,256 +0,0 @@
-using Code.Gameplay.Character.Controller.Input;
-using Code.Gameplay.Character.Core;
-using KinematicCharacterController;
-using UnityEngine;
-
-namespace Code.Gameplay.Character.Controller.Abilities
-{
-    public class WallRunningMechanic
-    {
-        public float MaxWallRunTime = 1.75f;
-        public float WallRunSpeed = 8.0f;
-        public float WallRunAcceleration = 25.0f;
-        public float WallRunGravityScale = 0.25f;
-        public float WallDetachImpulse = 7.0f;
-        public float WallContactAngleThreshold = 45.0f;
-
-        private bool _isWallRunning;
-        private float _wallRunTimer;
-        private Vector3 _wallNormal;
-        private Vector3 _wallTangentRight;
-        private Vector3 _wallTangentUp;
-        private Vector3 _wallContactPoint;
-        private Vector3 _lastMoveInputInWallSpace;
-
-        private float _surfaceAngleCos;
-        private bool _canWallRun;
-        public float WallContactHeight { get; private set; }
-        
-        public Vector3 WallRunStartForward { get; private set; }
-
-        private KinematicCharacterMotor _motor;
-        private CharacterInputHandler _inputHandler;
-
-        public bool IsWallRunning => _isWallRunning;
-
-        public void Initialize(KinematicCharacterMotor motor, CharacterInputHandler inputHandler)
-        {
-            _motor = motor;
-            _inputHandler = inputHandler;
-            _surfaceAngleCos = Mathf.Cos(Mathf.Deg2Rad * WallContactAngleThreshold);
-        }
-
-        public void Reset()
-        {
-            _isWallRunning = false;
-            _wallRunTimer = 0f;
-            _wallNormal = Vector3.zero;
-        }
-
-        public void Tick(float deltaTime)
-        {
-            if (_isWallRunning)
-            {
-                _wallRunTimer += deltaTime;
-                if (_wallRunTimer > MaxWallRunTime)
-                {
-                    DetachFromWall(false);
-                }
-            }
-        }
-
-        public bool TryStartWallRun(Vector3 hitNormal, Vector3 hitPoint)
-        {
-            if (_isWallRunning) return false;
-
-            float dotWithUp = Vector3.Dot(hitNormal, _motor.CharacterUp);
-            bool isWall = Mathf.Abs(dotWithUp) < _surfaceAngleCos;
-
-            if (!isWall) return false;
-
-            if (_motor.GroundingStatus.IsStableOnGround) return false;
-
-            float 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;
-            WallContactHeight = contactPoint.y;
-
-            //_wallTangentUp = Vector3.ProjectOnPlane(_motor.CharacterUp, _wallNormal).normalized;
-            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;
-            
-            WallRunStartForward = _motor.CharacterForward;
-            _motor.ForceUnground();
-        }
-
-        public void HandleWallRun(ref Vector3 currentVelocity, CharacterInputs inputs, float deltaTime)
-        {
-            if (!_isWallRunning) return;
-            if (!IsWallStillPresent()) { DetachFromWall(false); return; }
-
-            Vector3 moveInputWorld = _inputHandler.MoveInputVector;
-            Vector3 moveInWallPlane = Vector3.ProjectOnPlane(moveInputWorld, _wallNormal);
-    
-            Vector3 wsMove = Vector3.Project(moveInWallPlane, _wallTangentRight);
-
-            float ad = inputs.MoveAxisRight;
-
-            float sideDot = Vector3.Dot(_wallNormal, _motor.CharacterRight);
-            if (sideDot < 0)
-                ad = -ad;
-
-            Vector3 adMove = _wallTangentUp * (-ad);
-
-            Vector3 finalMove = wsMove + adMove;
-            finalMove = finalMove.normalized * moveInputWorld.magnitude;
-
-            Vector3 targetVelocity = finalMove * WallRunSpeed;
-
-            currentVelocity = Vector3.Lerp(
-                currentVelocity,
-                targetVelocity,
-                1f - Mathf.Exp(-WallRunAcceleration * deltaTime)
-            );
-
-            currentVelocity += Physics.gravity * (WallRunGravityScale * deltaTime);
-
-            float 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 == null) return false;
-
-            Vector3 characterCenter = _motor.TransientPosition;
-            Vector3 characterForward = _motor.CharacterForward;
-            Vector3 characterRight = _motor.CharacterRight;
-            Vector3 characterUp = _motor.CharacterUp;
-
-            float checkDistance = 0.45f;
-            Vector3 rayOrigin = characterCenter + characterUp * 0.2f;
-            Vector3 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 RaycastHit hit, checkDistance, 
-                        _motor.CollidableLayers, QueryTriggerInteraction.Ignore))
-                {
-                    float dotWithUp = Mathf.Abs(Vector3.Dot(hit.normal, characterUp));
-                    if (dotWithUp < _surfaceAngleCos)
-                    {
-                        _wallNormal = hit.normal.normalized;
-                        _wallContactPoint = hit.point;
-
-                        /*_wallTangentUp = Vector3.ProjectOnPlane(_motor.CharacterUp, _wallNormal).normalized;
-                        if (_wallTangentUp.sqrMagnitude < 0.01f) _wallTangentUp = Vector3.up;
-                        _wallTangentRight = Vector3.Cross(_wallNormal, _wallTangentUp).normalized;
-                        */
-
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        public void DetachFromWall(bool withImpulse)
-        {
-            if (!_isWallRunning) return;
-
-            _isWallRunning = false;
-
-            if (withImpulse && _motor != null)
-            {
-                Vector3 detachImpulse = -_wallNormal * WallDetachImpulse;
-                _motor.BaseVelocity += detachImpulse;
-            }
-        }
-
-        public Vector3 GetWallNormal() => _wallNormal;
-        public bool TryGetWallTangents(out Vector3 up, out Vector3 right)
-        {
-            if (!_isWallRunning)
-            {
-                up = right = Vector3.zero;
-                return false;
-            }
-            up = _wallTangentUp;
-            right = _wallTangentRight;
-            return true;
-        }
-
-        public bool CanWallRun()
-        {
-            return !_isWallRunning && !_motor.GroundingStatus.IsStableOnGround;
-        }
-        
-        public void PerformWallJump(CharacterInputs inputs, Quaternion cameraRotation)
-        {
-            if (!_isWallRunning || _motor == null) return;
-
-            _isWallRunning = false;
-
-            Vector3 wallAway = _wallNormal;
-            Vector3 wallUp = _wallTangentUp;
-
-            Vector3 playerForward = cameraRotation * Vector3.forward;
-
-            Vector3 forwardInWallPlane = Vector3.ProjectOnPlane(playerForward, _wallNormal).normalized;
-            if (forwardInWallPlane.sqrMagnitude < 0.01f) forwardInWallPlane = _wallTangentRight;
-
-            Vector3 jumpDirection = 
-                forwardInWallPlane * 0.2f +
-                wallAway * 0.4f +
-                wallUp * 0.4f;
-
-            jumpDirection = jumpDirection.normalized;
-
-            float wallJumpForce = WallDetachImpulse * 2f;
-
-            Vector3 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

@@ -1,3 +0,0 @@
-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
     {
@@ -28,27 +28,14 @@ namespace Code.Gameplay.Character.Controller
         // Подсистемы
         private CharacterInputHandler _inputHandler;
         private SlideMechanic _slideMechanic;
-        // private WallClimbMechanic _wallClimbMechanic;
-        private WallRunningMechanic _wallRunningMechanic;
+        private WallClimbMechanic _wallClimbMechanic;
         private WallLeanMechanic _wallLeanMechanic;
         private GroundMovementSystem _groundMovement;
         private AirMovementSystem _airMovement;
         
-        public bool IsSliding => _slideMechanic.IsSliding; 
-        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)
+        // Инициализация контроллера
+        private void Awake()
         {
-            _characterConfig = characterConfig;
             // Инициализация подсистем с параметрами из конфига
             _inputHandler = new CharacterInputHandler(
                 _characterConfig.sprintAngleThreshold
@@ -58,25 +45,16 @@ namespace Code.Gameplay.Character.Controller
                 _characterConfig.slideDuration,
                 _characterConfig.slideCooldown
             );
-            // _wallClimbMechanic = new WallClimbMechanic(
-            //     _characterConfig.wallClimbSpeedFactor,
-            //     _characterConfig.minWallClimbSpeed,
-            //     _characterConfig.wallDetectionAngleThreshold
-            // );
-            _wallRunningMechanic = new WallRunningMechanic();
-            // Настройка параметров WallRunningMechanic (можно вынести в конфиг позже)
-            _wallRunningMechanic.MaxWallRunTime = 1.75f;
-            _wallRunningMechanic.WallRunSpeed = 15.0f;
-            _wallRunningMechanic.WallRunAcceleration = 25.0f;
-            _wallRunningMechanic.WallRunGravityScale = 0.25f;
-            _wallRunningMechanic.WallDetachImpulse = 7.0f;
-            _wallRunningMechanic.WallContactAngleThreshold = 45.0f;
-            
+            _wallClimbMechanic = new WallClimbMechanic(
+                _characterConfig.wallClimbSpeedFactor,
+                _characterConfig.minWallClimbSpeed,
+                _characterConfig.wallDetectionAngleThreshold
+            );
             _wallLeanMechanic = new WallLeanMechanic(
-                _characterConfig.leanAngle,
-                _characterConfig.leanThreshold,
-                _characterConfig.leanSmoothSpeed
-                );
+                _characterConfig.maxWallLeanAngle,
+                _characterConfig.wallLeanSharpness,
+                _characterConfig.wallLeanHeightScale
+            );
             _groundMovement = new GroundMovementSystem(
                 _characterConfig.maxStableMoveSpeed,
                 _characterConfig.sprintMoveSpeed,
@@ -84,29 +62,30 @@ namespace Code.Gameplay.Character.Controller
                 _characterConfig.jumpSpeed
             );
             _airMovement = new AirMovementSystem(_characterConfig.gravity);
-            
-            
-            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;
-            // Обновляем таймеры механик
+            // Обновляем таймер перезарядки слайда
             _slideMechanic.TickCooldown(Time.deltaTime);
-            // _wallClimbMechanic.TickCooldown(Time.deltaTime);
-            _wallRunningMechanic.Tick(Time.deltaTime);
 
             // Если активен слайд - игнорируем весь остальной ввод
             if (_slideMechanic.IsSliding)
             {
+                // Во время слайда не обрабатываем движение, прыжки и спринт
                 _inputHandler.MoveInputVector = Vector3.zero;
                 _inputHandler.LookInputVector = Vector3.one;
                 _inputHandler.IsSprinting = false;
@@ -114,21 +93,8 @@ namespace Code.Gameplay.Character.Controller
                 return;
             }
 
+            // Сохраняем текущий режим камеры
             _currentCameraMode = inputs.CameraMode;
-            
-            if (isAbilitiesBlocked)
-            {
-                abilityBlockTimer -= Time.deltaTime;
-                if (abilityBlockTimer <= 0)
-                {
-                    isAbilitiesBlocked = false;
-                }
-                else
-                {
-                    inputs.SprintPressed = false;
-                    inputs.SlidePressed = false;
-                }
-            }
 
             // Обработка слайда
             _slideMechanic.RequestSlide(inputs.SlidePressed);
@@ -136,138 +102,141 @@ namespace Code.Gameplay.Character.Controller
             // Обработка остального ввода
             _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 (_slideMechanic.IsSliding && _groundMovement.JumpRequested)
             {
                 _slideMechanic.EndSlide();
             }
 
+            // Проверяем запрос слайда и запускаем его если можно
             if (!_slideMechanic.IsSliding)
             {
                 _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);
+                // Отменяем прыжок (фикс проблемы с двойным прыжком после приземления)
                 _groundMovement.CancelJumpRequest();
             }
         }
-        
-        public void BlockAbilities(float duration)
-        {
-            isAbilitiesBlocked = true;
-            abilityBlockTimer = duration;
-        }
 
+        // Метод вызывается перед обновлением персонажа (можно использовать для подготовки)
         public void BeforeCharacterUpdate(float deltaTime)
         {
         }
 
+        // Метод вызывается после обработки столкновения с землей
         public void PostGroundingUpdate(float deltaTime)
         {
+            // Если во время слайда персонаж оторвался от земли - заканчиваем слайд
             if (_slideMechanic.IsSliding && !motor.GroundingStatus.IsStableOnGround)
             {
                 _slideMechanic.EndSlide();
             }
         }
 
+        // Метод вызывается после обновления персонажа
         public void AfterCharacterUpdate(float deltaTime)
         {
-            _wallLeanMechanic.Update(
-                _wallRunningMechanic.IsWallRunning,
-                _wallRunningMechanic.GetWallNormal(),
-                motor.CharacterForward
-            );
+            _wallLeanMechanic.UpdateLean(motor, deltaTime);
         }
 
+        // Проверка валидности коллайдера для обработки столкновений
         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)
         {
-            if (_wallRunningMechanic.TryStartWallRun(hitNormal, hitPoint))
+            _wallClimbMechanic.OnMovementHit(motor, hitNormal);
+            
+            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

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

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

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

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

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

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

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

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

@@ -1,48 +0,0 @@
-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

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

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

@@ -1,23 +0,0 @@
-using UnityEngine;
-
-namespace Code.Gameplay.Door
-{
-    public class Door : MonoBehaviour
-    {
-        [SerializeField] private Transform hingeJointAnchor;
-        [SerializeField] private HingeJoint hingeJoint;
-        [SerializeField] private Rigidbody rigidbody;
-
-        public void TranslationMode(bool on)
-        {
-            if (on)
-            {
-                rigidbody.isKinematic = true;
-                return;
-            }
-            rigidbody.isKinematic = false;
-            hingeJoint.autoConfigureConnectedAnchor = false;
-            hingeJoint.connectedAnchor = hingeJointAnchor.position; 
-        }
-    }
-}

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

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

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

@@ -1,16 +0,0 @@
-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

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

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

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

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

@@ -1,203 +0,0 @@
-using UnityEngine;
-using UnityEngine.AI;
-using Code.Gameplay.Player;
-using Code.Gameplay.Character.Controller;
-using Code.Gameplay.Character.Core;
-using Reflex.Attributes;
-using Reflex.Core;
-using Reflex.Injectors;
-
-namespace Code.Gameplay.Enemies
-{
-    public abstract class BaseEnemy : MonoBehaviour
-    {
-        [SerializeField] protected NavMeshAgent agent;
-        [SerializeField] protected Collider enemyCollider;
-        
-        protected int Damage;
-        protected float AttackCooldown;
-        
-        protected float DetectionRange;
-        protected float AttackRange;
-        
-        protected float Speed;
-
-        protected bool IsStunnable;
-        protected float StunDuration;
-
-        protected bool UsesIdleMovement;
-        protected float IdleWanderRadius;
-        protected float IdleMoveDurationMin;
-        protected float IdleMoveDurationMax;
-        protected float IdlePauseDurationMin;
-        protected float IdlePauseDurationMax;
-
-        private bool _isStunned;
-        private float _currentStunTimer;
-
-        private bool _canAttack = true;
-        private float _attackCooldownTimer;
-        
-        private enum IdleState { Moving, Paused }
-        private IdleState _currentIdleState = IdleState.Paused;
-        private float _idleTimer;
-        private Vector3 _idleTargetPosition;
-
-        [Inject] private IPlayerProvider _playerProvider;
-        protected CharacterProvider Player => _playerProvider?.Character;
-        protected PlayerHealth PlayerHealth => _playerProvider?.Health;
-        protected CustomCharacterController PlayerController => Player?.CustomCharacterController;
-
-        protected virtual void Awake()
-        {
-            if (_playerProvider == null)
-            {
-                AttributeInjector.Inject(this, Container.ProjectContainer);
-            }
-        }
-
-        protected virtual void Update()
-        {
-            if (!Player) return;
-
-            HandleStun();
-            HandleAttackCooldown();
-            if (_isStunned) return;
-            
-            HandleMovement();
-            HandleAttack();
-        }
-
-        protected virtual void HandleMovement()
-        {
-            if (!Player || !agent) return;
-            
-            var distanceToPlayer = Vector3.Distance(transform.position, Player.transform.position);
-            
-            if (distanceToPlayer <= DetectionRange)
-            {
-                agent.isStopped = false;
-                agent.SetDestination(Player.transform.position);
-            }
-            else if (UsesIdleMovement)
-            {
-                HandleIdleMovement();
-            }
-            else
-            {
-                agent.isStopped = true;
-            }
-        }
-        
-        protected virtual void HandleIdleMovement()
-        {
-            _idleTimer -= Time.deltaTime;
-
-            switch (_currentIdleState)
-            {
-                case IdleState.Paused:
-                    if (_idleTimer <= 0f)
-                    {
-                        // Start moving to a new random point
-                        _currentIdleState = IdleState.Moving;
-                        SetNewIdleDestination();
-                        _idleTimer = Random.Range(IdleMoveDurationMin, IdleMoveDurationMax);
-                        agent.isStopped = false;
-                    }
-                    break;
-
-                case IdleState.Moving:
-                    if (_idleTimer <= 0f || HasReachedIdleDestination())
-                    {
-                        // Stop and pause
-                        _currentIdleState = IdleState.Paused;
-                        _idleTimer = Random.Range(IdlePauseDurationMin, IdlePauseDurationMax);
-                        agent.isStopped = true;
-                    }
-                    break;
-            }
-        }
-
-        private void SetNewIdleDestination()
-        {
-            Vector3 randomPoint = transform.position + Random.insideUnitSphere * IdleWanderRadius;
-            NavMeshHit hit;
-            if (NavMesh.SamplePosition(randomPoint, out hit, 3f, agent.areaMask))
-            {
-                _idleTargetPosition = hit.position;
-                agent.SetDestination(_idleTargetPosition);
-            }
-            else
-            {
-                // Fallback: stay
-                _idleTargetPosition = transform.position;
-            }
-        }
-
-        private bool HasReachedIdleDestination()
-        {
-            return agent.remainingDistance <= agent.stoppingDistance;
-        }
-
-        protected virtual void HandleAttack() { }
-
-        protected virtual void HandleStun()
-        {
-            if (!_isStunned || !IsStunnable) return;
-            
-            _currentStunTimer -= Time.deltaTime;
-            
-            if (!(_currentStunTimer <= 0)) return;
-            
-            _isStunned = false;
-            agent.isStopped = false;
-            enemyCollider.enabled = true;
-        }
-
-        protected virtual void ApplyStun()
-        {
-            _isStunned = true;
-            _currentStunTimer = StunDuration;
-            agent.isStopped = true;
-            enemyCollider.enabled = false;
-        }
-        
-        protected virtual void HandleAttackCooldown()
-        {
-            if (!_canAttack)
-            {
-                _attackCooldownTimer -= Time.deltaTime;
-                if (_attackCooldownTimer <= 0)
-                {
-                    _canAttack = true;
-                }
-            }
-        }
-        
-        protected virtual void DealDamage()
-        {
-            if (!_canAttack || PlayerHealth == null) return;
-            
-            PlayerHealth.GetDamage(Damage);
-            ApplyEffectsToPlayer();
-            
-            _canAttack = false;
-            _attackCooldownTimer = AttackCooldown;
-        }
-
-        protected virtual void ApplyEffectsToPlayer()
-        {
-            if (PlayerController)
-                PlayerController.BlockAbilities(3f);
-        }
-
-        private void OnDrawGizmosSelected()
-        {
-            Gizmos.color = Color.yellow;
-            Gizmos.DrawWireSphere(transform.position, DetectionRange);
-            
-            Gizmos.color = new Color(0.3f, 0.3f, 0.8f, 0.4f);
-            Gizmos.DrawSphere(transform.position, AttackRange);
-        }
-    }
-}