Иду делать твиа :(

Завтра будут спавнпоинты + модельки

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetSettings.asset

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

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

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

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

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

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

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

@@ -1,11 +1,8 @@
-using System.Collections.Generic;
-using Code.App.Loading;
 using Code.App.StateMachine;
 using Code.Audio;
 using Code.Configs;
 using Code.Constants;
 using Code.Gameplay.Camera;
-using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
 using Code.Input;
 using Code.Scenes;
@@ -28,13 +25,11 @@ 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(PlayerProvider), typeof(IPlayerProvider));
 
             InitializeCamera(containerBuilder, staticDataService);
-            
             containerBuilder.AddSingleton(typeof(UIFactory), typeof(IUIFactory));
             containerBuilder.AddSingleton(typeof(UIService), typeof(IUIService));
             
@@ -77,22 +72,21 @@ namespace Code.App
             containerBuilder.AddSingleton(staticDataService.InputConfig, typeof(InputConfig));
             
             containerBuilder.AddSingleton(staticDataService.CameraConfig, typeof(CameraConfig));
-            containerBuilder.AddSingleton(staticDataService.CameraSettingsConfigs, typeof(Dictionary<CameraMode,CameraSettingsConfig>));
             
             containerBuilder.AddSingleton(staticDataService.PlayerConfig, typeof(PlayerConfig));
             containerBuilder.AddSingleton(staticDataService.CharacterConfig, typeof(CharacterConfig));
             
             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.SFXListConfig, typeof(SFXListConfig));
             containerBuilder.AddSingleton(staticDataService.DispatcherSoundListConfig, typeof(DispatcherSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
-            containerBuilder.AddSingleton(staticDataService.AudioSourceSettingsConfigs, typeof(Dictionary<AudioSourceType, AudioSourceSettingsConfig>));
-
-            containerBuilder.AddSingleton(staticDataService.OrderServiceConfig, typeof(OrderServiceConfig));
-            containerBuilder.AddSingleton(staticDataService.OrderBoxConfig, typeof(OrderBoxConfig)); 
         }
 
         private AppStateMachine _appStateMachine;
@@ -109,26 +103,19 @@ namespace Code.App
 
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
             BootstrapFinish(container);
+            
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
         private async UniTaskVoid BootstrapFinish(Container container)
         {
-            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen).GetComponent<LoadingScreen>();
-            DontDestroyOnLoad(loadingScreen.gameObject);
-
-            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
-            loadingManager.OnLoadingStarted += loadingScreen.Show;
-            loadingManager.OnLoadingEnded += loadingScreen.Hide;
-
-            loadingManager.RegisterLoading(LoadingWork.Bootstrap);
+            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen);
+            DontDestroyOnLoad(loadingScreen);
             
             await UniTask.WhenAll(
-                container.Resolve<IUIService>().Initialize(loadingScreen),
+                container.Resolve<IUIService>().Initialize(loadingScreen.GetComponent<LoadingScreen>()),
                 container.Resolve<IAudioService>().Initialize()
                 );
             
-            loadingManager.UnregisterLoading(LoadingWork.Bootstrap);
-            
             _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,11 +1,7 @@
-using Code.App.Loading;
-using Code.Gameplay.Orders.Order;
-using Code.Gameplay.Player;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Reflex.Core;
 using UnityEngine;
-using IPlayerScore = Code.Gameplay.Player.IPlayerScore;
 
 namespace Code.App.SceneInstallers
 {
@@ -16,22 +12,15 @@ namespace Code.App.SceneInstallers
         public void InstallBindings(ContainerBuilder containerBuilder)
         {
             containerBuilder.AddScoped(typeof(GameplaySceneEnvironment), typeof(CurrentSceneEnvironment));
-            containerBuilder.AddScoped(typeof(PlayerScore), typeof(IPlayerScore));
-            containerBuilder.AddScoped(typeof(OrderService), typeof(IOrderService));
 
             containerBuilder.OnContainerBuilt += Initialize;
         }
 
         private void Initialize(Container container)
         {
-            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
-            
             GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
-
-            env.TransitVariables(_gameplaySceneEnvironment);
             
-            loadingManager
-                .UnregisterLoading(LoadingWork.LoadScene);
+            env.TransitVariables(_gameplaySceneEnvironment);
         }
     }
 }

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

@@ -1,8 +1,8 @@
-using Code.App.Loading;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Reflex.Core;
-using UnityEngine; 
+using UnityEngine;
+using UnityEngine.Serialization;
 
 namespace Code.App.SceneInstallers
 {
@@ -22,11 +22,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,4 +1,3 @@
-using Code.App.Loading;
 using Code.Audio;
 using Code.Gameplay.Camera;
 using Code.Gameplay.Player;
@@ -11,13 +10,13 @@ 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; }
     }

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

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

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

@@ -62,8 +62,8 @@ namespace Code.Audio
 
         public async UniTask WarmGameplayMusic( )
         {
-            _actionMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_actionSoundtrack, OnActionTrackLoaded, Addressables.MergeMode.Union);
-            _peacefulMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_peacefulSoundtrack, OnPeacefulTrackLoaded, Addressables.MergeMode.Union);
+            _actionMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_actionSoundtrack, OnActionTrackLoaded, Addressables.MergeMode.None);
+            _peacefulMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_peacefulSoundtrack, OnPeacefulTrackLoaded, Addressables.MergeMode.None);
             
             await UniTask.WhenAll(_actionMusicHandle.ToUniTask(), _peacefulMusicHandle.ToUniTask());
         }
@@ -79,7 +79,7 @@ namespace Code.Audio
         }
         public async UniTask WarmMenuMusic( )
         {            
-            _menuMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_menuSoundtrack, OnMenuTrackLoaded, Addressables.MergeMode.Union);
+            _menuMusicHandle = Addressables.LoadAssetsAsync<AudioClip>(_menuSoundtrack, OnMenuTrackLoaded, Addressables.MergeMode.None);
             // foreach (var assetReference in _menuSoundtrack) MenuMusic.Add(await assetReference.LoadAssetAsync<AudioClip>());
             await _menuMusicHandle.ToUniTask();
              
@@ -92,7 +92,7 @@ namespace Code.Audio
         }
         public async UniTask WarmSFX( )
         {            
-            _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.Union);
+            _SFXHandle = Addressables.LoadAssetsAsync<AudioClip>(_SFX, OnSFXLoaded, Addressables.MergeMode.None);
             
             await _SFXHandle.ToUniTask();
              
@@ -104,7 +104,7 @@ namespace Code.Audio
         }
         public async UniTask WarmEnemies( )
         {            
-            _enemiesHandle = Addressables.LoadAssetsAsync<AudioClip>(_enemies, OnEnemiesLoaded, Addressables.MergeMode.Union);
+            _enemiesHandle = Addressables.LoadAssetsAsync<AudioClip>(_enemies, OnEnemiesLoaded, Addressables.MergeMode.None);
             
             await _enemiesHandle.ToUniTask();
              
@@ -118,7 +118,7 @@ namespace Code.Audio
 
         public async UniTask WarmDispatcher( )
         {            
-            _dispatcherHandle = Addressables.LoadAssetsAsync<AudioClip>(_dispatcher, OnDispatcherLoaded, Addressables.MergeMode.Union);
+            _dispatcherHandle = Addressables.LoadAssetsAsync<AudioClip>(_dispatcher, OnDispatcherLoaded, Addressables.MergeMode.None);
             
             await _dispatcherHandle.ToUniTask();
              

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

@@ -31,16 +31,13 @@ namespace Code.Audio
             _courierGroup,
             _enemiesGroup;
 
-        private readonly AudioSourcePool _audioSourcePool;
+        private readonly AudioSourcePool _audioSourcePool = new();
 
         private Dictionary<AudioSnapshotState, AudioMixerSnapshot> _snapshots = new();
-        private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
-        
-        public AudioService(IAudioFactory audioFactory, Dictionary<AudioSourceType,AudioSourceSettingsConfig> settings)
+
+        public AudioService(IAudioFactory audioFactory)
         {
             _audioFactory = audioFactory;
-            _audioSourcePool = new(settings);
-            _settings = settings;
         }
 
         public async UniTask Initialize()
@@ -89,7 +86,7 @@ namespace Code.Audio
             if(!_musicAudioSources[musicType])
             {
                 _musicAudioSources[musicType] = _audioSourcePool.GetSource();
-                _musicAudioSources[musicType].spatialBlend = _settings[AudioSourceType.NoBlend].spatialBlend;
+                _musicAudioSources[musicType].spatialBlend = 0f;
                 _musicAudioSources[musicType].outputAudioMixerGroup = _musicAudioGroups[musicType];
             }
             
@@ -167,13 +164,9 @@ namespace Code.Audio
             _audioSourcePool.PlayOneShot(_audioFactory.EnemiesAudios[(int)enemySoundId], position, _enemiesGroup);
         }
 
-        // Чинить долго и дорого пусть Артёмов будет много, ведь он наш друг
-        public event IAudioService.OnAudioPlayingDelegate OnDispatcherStarted;
-        public event IAudioService.OnAudioPlayingDelegate OnDispatcherEnded;
         public void PlayDispatcher(DispatcherSounds dispatcherSoundId)
         {
-            OnDispatcherStarted?.Invoke();
-            _audioSourcePool.PlayOneShot(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup, AudioSourceType.NoBlend, () => OnDispatcherEnded?.Invoke());
+            _audioSourcePool.PlayShizo(_audioFactory.DispatcherAudios[(int)dispatcherSoundId], _dispatcherGroup);
         }
     }
 }

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

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

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

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

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

@@ -1,11 +1,7 @@
-using System;
-using System.Collections.Generic;
-using Code.Configs;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 using UnityEngine.Audio;
 using UnityEngine.Pool;
-using Object = UnityEngine.Object;
 
 namespace Code.Audio
 {
@@ -14,11 +10,7 @@ namespace Code.Audio
         // The pool holds plain GameObjects (you can swap this for any component type).
         private IObjectPool<AudioSource> _pool; 
         private GameObject _sourcePrefab;
-
-        private Dictionary<AudioSourceType, AudioSourceSettingsConfig> _settings;
-        
-        public AudioSourcePool(Dictionary<AudioSourceType, AudioSourceSettingsConfig> settings) => _settings = settings;
-
+  
         public void Initialize(GameObject sourcePrefab)
         {
             _sourcePrefab = sourcePrefab;
@@ -62,30 +54,30 @@ namespace Code.Audio
         {
             Object.Destroy(source.gameObject);
         }
-        
-        public async UniTaskVoid PlayOneShot(AudioClip clip, Vector3 position, AudioMixerGroup audioMixerGroup, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
+
+        public async UniTaskVoid PlayOneShot(AudioClip clip, Vector3 position, AudioMixerGroup audioMixerGroup)
         {
             AudioSource source = _pool.Get();
             source.PlayOneShot(clip);
-            source.spatialBlend = _settings[audioSourceType].spatialBlend;
+            source.spatialBlend = 1f;
             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)
+        public async UniTaskVoid PlayShizo(AudioClip clip, AudioMixerGroup audioMixerGroup)
         {
             AudioSource source = _pool.Get();
             source.PlayOneShot(clip);
-            source.spatialBlend = _settings[audioSourceType].spatialBlend;
+            source.spatialBlend = 0f;
             source.outputAudioMixerGroup = audioMixerGroup;
             
             await UniTask.WaitUntilValueChanged(source, x => x.isPlaying);
-            onComplete?.Invoke();
+            
             _pool.Release(source);
-        } 
+        }
         public AudioSource GetSource() => _pool.Get();
         public void ReleaseSource(AudioSource source) => _pool.Release(source);
     }

Game/CourierOld/Assets/Code/Audio/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/IAudioService.cs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -9,16 +9,14 @@ 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.UltraStatic, new UltraStaticState(StateMachineContext));
             States.Add(CameraMode.FirstPerson, new FirstPersonState(StateMachineContext));
             States.Add(CameraMode.ThirdPerson, new ThirdPersonState(StateMachineContext));
             
-            CurrentBaseState = States[CameraMode.None];
+            CurrentBaseState = States[CameraMode.UltraStatic];
         }
         
-        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/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/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/Camera/CameraStates/UltraStaticState.cs

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

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

@@ -33,6 +33,11 @@ namespace Code.Gameplay.Character.Controller
         private GroundMovementSystem _groundMovement;
         private AirMovementSystem _airMovement;
         
+        public bool IsSliding => _slideMechanic.IsSliding; 
+        
+        private float abilityBlockTimer;
+        private bool isAbilitiesBlocked;
+        
         public void SetPosition(Vector3 position) => motor.SetPosition(position);
         public void SetRotation(Quaternion rotation) => motor.SetRotation(rotation);
         
@@ -135,6 +140,20 @@ namespace Code.Gameplay.Character.Controller
 
             // Сохраняем текущий режим камеры
             _currentCameraMode = inputs.CameraMode;
+            
+            if (isAbilitiesBlocked)
+            {
+                abilityBlockTimer -= Time.deltaTime;
+                if (abilityBlockTimer <= 0)
+                {
+                    isAbilitiesBlocked = false;
+                }
+                else
+                {
+                    inputs.SprintPressed = false;
+                    inputs.SlidePressed = false;
+                }
+            }
 
             // Обработка слайда
             _slideMechanic.RequestSlide(inputs.SlidePressed);
@@ -180,6 +199,7 @@ namespace Code.Gameplay.Character.Controller
                 // Заготовка на будущее (если понадобится)
                 case CameraMode.Static:
                 case CameraMode.Cinematic:
+                case CameraMode.Bogdan: // Скорее всего юзлес, но пускай будет
                 default:
                     break;
             }
@@ -220,6 +240,12 @@ namespace Code.Gameplay.Character.Controller
                 _groundMovement.CancelJumpRequest();
             }
         }
+        
+        public void BlockAbilities(float duration)
+        {
+            isAbilitiesBlocked = true;
+            abilityBlockTimer = duration;
+        }
 
         // Метод вызывается перед обновлением персонажа (можно использовать для подготовки)
         public void BeforeCharacterUpdate(float deltaTime)

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

@@ -1,7 +1,6 @@
 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;
@@ -19,9 +18,6 @@ namespace Code.Gameplay.Character.Core
         
         [Inject] private IInputService _inputService; // Сервис ввода через DI
 
-        [SerializeField] private PlayerAnimator _animator;
-        public PlayerAnimator PlayerAnimator => _animator;
-
         public void Teleport(Vector3 position, Quaternion rotation)
         {
             customCharacterController.SetPosition(position);

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

@@ -5,44 +5,19 @@ namespace Code.Gameplay.Door
 {
     public class CinematicDoorOpening
     {
-        private MainMenuDoor _mainMenuDoor;
-        private Light _doorLight;
+        public DamnDoor DamnDoor;
+        public Light DoorLight;
 
-        public CinematicDoorOpening(MainMenuDoor mainMenuDoor, Light doorLight)
+        public void PreOpen(bool start)
         {
-            _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;
-            }
+            DoorLight.DOColor(start ? Color.yellow : Color.red, 0.2f);
 
-            _mainMenuDoor.Petlya.DORotate(new Vector3(0, -10, 0), 1f);
+            DamnDoor.Petlya.DORotate(new Vector3(0, -40, 0), 1f);
         }
 
         public void Close()
         {
-            _mainMenuDoor.Petlya.DORotate(new Vector3(0, 0, 0), 1f);
+            DamnDoor.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/DamnDoor.cs

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

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

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

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

@@ -0,0 +1,202 @@
+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()
+        {
+            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);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 691006ba0f69448787db8f350ecf32f4
+timeCreated: 1763228480

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

@@ -0,0 +1,55 @@
+using Code.Configs;
+using Reflex.Attributes;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace Code.Gameplay.Enemies
+{
+    public class Cockroach : BaseEnemy
+    {
+        [Inject]
+        private void Construct(CockroachConfig cockroachConfig)
+        {
+            Damage = cockroachConfig.damage;
+            AttackCooldown = cockroachConfig.attackCooldown;
+            
+            DetectionRange = cockroachConfig.detectionRange;
+            AttackRange = cockroachConfig.attackRange;
+            
+            Speed = cockroachConfig.speed;
+            
+            IsStunnable = cockroachConfig.isStunnable;
+            StunDuration = cockroachConfig.stunDuration;
+            
+            UsesIdleMovement = cockroachConfig.usesIdleMovement;
+            IdleWanderRadius = cockroachConfig.idleWanderRadius;
+            IdleMoveDurationMin = cockroachConfig.idleMoveDurationMin;
+            IdleMoveDurationMax = cockroachConfig.idleMoveDurationMax;
+            IdleMoveDurationMin = cockroachConfig.idleMoveDurationMin;
+            IdleMoveDurationMax = cockroachConfig.idleMoveDurationMax;
+            IdlePauseDurationMin = cockroachConfig.idlePauseDurationMin;
+            IdlePauseDurationMax = cockroachConfig.idlePauseDurationMax;
+        }
+        
+        protected override void Awake()
+        {
+            base.Awake();
+            
+            if (agent == null) return;
+            
+            var walkableArea = NavMesh.GetAreaFromName("Cockroach");
+            agent.areaMask = 1 << walkableArea;
+        }
+        
+        protected override void HandleAttack()
+        {
+            if (!Player) return;
+            
+            var distance = Vector3.Distance(transform.position, Player.transform.position);
+
+            if (!(distance <= AttackRange)) return;
+            
+            DealDamage();
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 119c0b675c944ed7ada6cdc8db4b04aa
+timeCreated: 1763228933

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

@@ -0,0 +1,58 @@
+using Code.Configs;
+using Reflex.Attributes;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace Code.Gameplay.Enemies
+{
+    public class DrunkenGrandpa : BaseEnemy
+    {
+        [Inject]
+        private void Construct(DrunkenGrandpaConfig drunkenGrandpaConfig)
+        {
+            Damage = drunkenGrandpaConfig.damage;
+            AttackCooldown = drunkenGrandpaConfig.attackCooldown;
+            
+            DetectionRange = drunkenGrandpaConfig.detectionRange;
+            AttackRange = drunkenGrandpaConfig.attackRange;
+            
+            Speed = drunkenGrandpaConfig.speed;
+            
+            IsStunnable = drunkenGrandpaConfig.isStunnable;
+            StunDuration = drunkenGrandpaConfig.stunDuration;
+            
+            UsesIdleMovement = drunkenGrandpaConfig.usesIdleMovement;
+            IdleWanderRadius = drunkenGrandpaConfig.idleWanderRadius;
+            IdleMoveDurationMin = drunkenGrandpaConfig.idleMoveDurationMin;
+            IdleMoveDurationMax = drunkenGrandpaConfig.idleMoveDurationMax;
+            IdleMoveDurationMin = drunkenGrandpaConfig.idleMoveDurationMin;
+            IdleMoveDurationMax = drunkenGrandpaConfig.idleMoveDurationMax;
+            IdlePauseDurationMin = drunkenGrandpaConfig.idlePauseDurationMin;
+            IdlePauseDurationMax = drunkenGrandpaConfig.idlePauseDurationMax;
+        }
+
+        protected override void Awake()
+        {
+            base.Awake();
+            
+            if (agent == null) return;
+            
+            var walkableArea = NavMesh.GetAreaFromName("Walkable");
+            agent.areaMask = 1 << walkableArea;
+        }
+        
+        protected override void HandleAttack()
+        {
+            if (!Player) return;
+            
+            var distance = Vector3.Distance(transform.position, Player.transform.position);
+
+            if (!(distance <= AttackRange)) return;
+            
+            if (Player.CustomCharacterController.IsSliding)
+                ApplyStun();
+            else
+                DealDamage();
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5e77164596e249bca15e09cdfc9ddac2
+timeCreated: 1763228910

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

@@ -0,0 +1,68 @@
+using Code.Configs;
+using Reflex.Attributes;
+using UnityEngine;
+
+namespace Code.Gameplay.Enemies
+{
+    public class Fog : BaseEnemy
+    {
+        [Inject]
+        private void Construct(FogConfig fogConfig)
+        {
+            Damage = fogConfig.damage;
+            AttackCooldown = fogConfig.attackCooldown;
+            
+            DetectionRange = fogConfig.detectionRange;
+            AttackRange = fogConfig.attackRange;
+            
+            Speed = fogConfig.speed;
+            
+            IsStunnable = fogConfig.isStunnable;
+            StunDuration = fogConfig.stunDuration;
+            
+            UsesIdleMovement = fogConfig.usesIdleMovement;
+            IdleWanderRadius = fogConfig.idleWanderRadius;
+            IdleMoveDurationMin = fogConfig.idleMoveDurationMin;
+            IdleMoveDurationMax = fogConfig.idleMoveDurationMax;
+            IdleMoveDurationMin = fogConfig.idleMoveDurationMin;
+            IdleMoveDurationMax = fogConfig.idleMoveDurationMax;
+            IdlePauseDurationMin = fogConfig.idlePauseDurationMin;
+            IdlePauseDurationMax = fogConfig.idlePauseDurationMax;
+        }
+        
+        protected override void Awake()
+        {
+            base.Awake();
+            
+            if (agent == null) return;
+            agent.enabled = false;
+            Destroy(agent);
+        }
+
+        protected override void HandleMovement()
+        {
+            if (!Player) return;
+            
+            var direction = (Player.transform.position - transform.position).normalized;
+            transform.position += direction * (Speed * Time.deltaTime);
+        }
+
+        protected override void HandleAttack()
+        {
+            if (!Player || PlayerHealth == null) return;
+            
+            var distance = Vector3.Distance(transform.position, Player.transform.position);
+            
+            if (!(distance < AttackRange)) return;
+            
+            PlayerHealth.GetDamage(PlayerHealth.MaxHealthPoints);
+            base.ApplyEffectsToPlayer();
+        }
+
+        private void OnDrawGizmosSelected()
+        {
+            Gizmos.color = new Color(0.3f, 0.3f, 0.8f, 0.4f);
+            Gizmos.DrawSphere(transform.position, AttackRange);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4c70370426e4457aa9a56c77689158ff
+timeCreated: 1763228955

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+using Code.Gameplay.Character.Core;
+
+namespace Code.Gameplay.Player
+{
+    public interface IPlayerProvider
+    {
+        CharacterProvider Character { get; }
+        PlayerHealth Health { get; }
+        bool IsSpawned { get; }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8fdfaa773e8645d5a2d400c0317b9894
+timeCreated: 1763237368

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

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

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

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

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

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

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

@@ -14,28 +14,33 @@ namespace Code.Gameplay.Player
     public class PlayerFactory : IPlayerFactory
     {
         [Inject] PlayerConfig _playerConfig;
+        [Inject] private IPlayerProvider _playerProvider;
         
         public PlayerHealth CreatePlayerHealth(int count = -1)
         {
             if (count < 0) count = _playerConfig.maxHealth;
             
             return new(count);
-        } 
+        }
+        public PlayerMoney CreatePlayerMoney(int count = 0) => new(count);
 
         public async UniTask<CharacterProvider> CreatePlayer()
         {
-            CharacterProvider characterProvider = (await Addressables.InstantiateAsync(_playerConfig.characterPrefab).ToUniTask()).GetComponent<CharacterProvider>();
-            AttributeInjector.Inject(characterProvider, Container.ProjectContainer);
-            AttributeInjector.Inject(characterProvider.CustomCharacterController, Container.ProjectContainer);
-            return characterProvider;
+            var go = await Addressables.InstantiateAsync(_playerConfig.characterPrefab).ToUniTask();
+            var provider = go.GetComponent<CharacterProvider>();
+        
+            AttributeInjector.Inject(provider, Container.ProjectContainer);
+            AttributeInjector.Inject(provider.CustomCharacterController, Container.ProjectContainer);
+
+            ((PlayerProvider)_playerProvider).SetPlayer(provider, _playerConfig);
+
+            return provider;
         }
 
         public void ReleasePlayer(CharacterProvider characterProvider)
         {
+            ((PlayerProvider)_playerProvider).ClearPlayer();
             Addressables.ReleaseInstance(characterProvider.gameObject);
         }
-
-        public async UniTask<ArmsMeshProvider> CreateArms(Transform papochka) => (await Addressables.InstantiateAsync(_playerConfig.armsMeshPrefab, papochka).ToUniTask()).GetComponent<ArmsMeshProvider>();
-        public void ReleaseArms(ArmsMeshProvider arms) => Addressables.ReleaseInstance(arms.gameObject);
     }
 }

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

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

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

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

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

@@ -0,0 +1,26 @@
+using Code.Configs;
+using Code.Gameplay.Character.Core;
+
+namespace Code.Gameplay.Player
+{
+    public class PlayerProvider : IPlayerProvider
+    {
+        public CharacterProvider Character { get; private set; }
+
+        public PlayerHealth Health { get; private set; }
+
+        public bool IsSpawned => Character != null;
+
+        internal void SetPlayer(CharacterProvider character, PlayerConfig config)
+        {
+            Character = character;
+            Health = new PlayerHealth(config.maxHealth);
+        }
+
+        internal void ClearPlayer()
+        {
+            Character = null;
+            Health = null;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0dbe29c5f0e9431db8c8da25eeb8fa95
+timeCreated: 1763237388

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

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

Game/CourierOld/Assets/Code/Generator.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: b32d6ce440f44fd3abadaa489a44890c
-timeCreated: 1762797763

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

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

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

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 1a7c77305de54155b5b94b607531ee3c
-timeCreated: 1762453750

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

@@ -1,12 +0,0 @@
-using Cysharp.Threading.Tasks;
-using UnityEngine;
-
-namespace Code.Generator
-{
-    public interface IRoomGeneratorFactory
-    {
-        UniTask PreloadRooms();
-        GameObject GetCachedPrefab(int index);
-        UniTask<Room> CreateRoomByIndex(int index);
-    }
-}

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

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: f3fca4115e714519b869eb72d856e89f
-timeCreated: 1762453657