Подогреваем коллизии

Хуже, чем были раньше, но лучше, чем ничего. Плавность переходов имеется, и на том спасибо

Game/CourierOld/.vsconfig

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

Game/CourierOld/Assets/AddressableAssetsData/AddressableAssetSettings.asset

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

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

@@ -32,6 +32,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 19bfe93240786974ea9d7cd70a7bb635
+    m_Address: Prefabs/Rooms/Level5
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 1d4767c722c05b5d6b96bb226d378c65
     m_Address: Assets/Resources_moved/Prefabs/Player/ArmsMesh.prefab
     m_ReadOnly: 0
@@ -52,6 +57,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 28a6c7a4124141341ab7c2b7dfd3e95b
+    m_Address: Assets/Resources_moved/Prefabs/Levels/Level1 2.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 29bff8011973e4e519906b9da8fca0fc
     m_Address: Audio/Dispatcher/late3
     m_ReadOnly: 0
@@ -62,6 +72,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 2ed2d93a9f39d4edba511cb7396c7bb6
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/Cockroach.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 2f6134357dc2a5641a846a7478ce4c2c
     m_Address: bravo!
     m_ReadOnly: 0
@@ -77,6 +92,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 4283d6553fc7f3f4583b9bb0be9d7979
+    m_Address: Prefabs/Rooms/Box1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 48aebfe8826dc0df79d047b5afbf8f5b
     m_Address: Canvas
     m_ReadOnly: 0
@@ -87,6 +107,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 7067a5248027e74478f4f0f53ddf06a4
+    m_Address: Prefabs/Rooms/Save1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 735f38402ea347fa381408293503a24e
     m_Address: Audio/Dispatcher/receiving_an_order1
     m_ReadOnly: 0
@@ -138,26 +163,76 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 9d78f017876abed4c9cd8957f1e140cb
+    m_Address: Prefabs/Rooms/Level1_2
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: a1d9e5a04ac11a1468c744b27d442a00
+    m_Address: Prefabs/Rooms/Stars1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: a306df57f348ce7cf900d0b9431739ee
     m_Address: launch_selectmenu
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: ab5926b5200bedc49aec36c0afe6b028
+    m_Address: Prefabs/Rooms/Level3_Big
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: b2e8dc2aeb0311cd8a826b51cf8e94dc
     m_Address: GameOver
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: b33855c694de89386a25c56cbe463a0e
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/DrunkenGrandpa.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: b3471d165fe389f479380f61034bea57
+    m_Address: Assets/Resources_moved/Prefabs/Levels/Level1 1.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: c566fc932edefbbee9e53271eac3c560
     m_Address: MainMenu
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: c938de3174f184741925c407a43a47f2
+    m_Address: Prefabs/Rooms/Level1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: cab4b1ff78dd6b1fba61aa165aa17b4d
     m_Address: Audio/Dispatcher/receiving_an_order2
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: d4eaf1439c2788c458127b9ba67e4fbf
+    m_Address: Prefabs/Levels/Level1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: d5b22c0e6700543419ae667d77aadaa2
+    m_Address: Prefabs/Rooms/Level2_Down
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: dc328d8aadb0e8545978741d451e0544
+    m_Address: Prefabs/Rooms/Level4_Parkur
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: e3a3840a7963bf841872cddb02e90151
+    m_Address: Prefabs/Levels/MainMenu 1
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: ebe18293a5ef86704b23dad3a1786476
     m_Address: Half-Life01
     m_ReadOnly: 0
@@ -168,6 +243,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: f3d7dc64b34919ad7b50a3dd307a935b
+    m_Address: Assets/Resources_moved/Prefabs/Enemies/Fog.prefab
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: f74a409bf11b25148ad305acc05b14f5
     m_Address: Audio/Dispatcher/take_damage2
     m_ReadOnly: 0

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

@@ -1,6 +1,3 @@
-using System.Globalization;
-using System.Reflection.Emit;
-using System.Threading.Tasks;
 using Code.App.Loading;
 using Code.App.StateMachine;
 using Code.Audio;
@@ -8,7 +5,6 @@ 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;
@@ -19,7 +15,6 @@ 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;
@@ -28,30 +23,30 @@ namespace Code.App.AppStates
 {
     public class GameplayState : BaseState<AppStateMachineContext>
     { 
-        
         private PlayerHealth _playerHealth;
         private IPlayerScore _playerScore;
         
         private IOrderService _orderService;
 
         private CharacterProvider _playerCharacter;
-
         public GameplayState(AppStateMachineContext context) : base(context)
         {
         }
 
         public override void EnterState()
         {
+            Context.UIService.LoadingScreen.Show();
+
             Context.LoadingManager
                 .RegisterLoading(LoadingWork.LoadScene)
                 .RegisterLoading(LoadingWork.LoadUI)
-                // .RegisterLoading(LoadingWork.LoadModelResource)
+                .RegisterLoading(LoadingWork.LoadModelResource)
                 .RegisterLoading(LoadingWork.LoadAudio); 
              
-            _playerHealth = Context.PlayerFactory.CreatePlayerHealth();
+            //_playerHealth = Context.PlayerFactory.CreatePlayerHealth();
 
-            _playerHealth.OnDamage += PlayerDamageTaken;
-            _playerHealth.OnDeath += EndGame;
+            //_playerHealth.OnDamage += PlayerDamageTaken;
+            //_playerHealth.OnDeath += EndGame;
             
             Context.AudioService.TransitToSnapshot(AudioSnapshotState.None);
             
@@ -61,7 +56,7 @@ namespace Code.App.AppStates
             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.SceneLoaderService.LoadSceneAsyncAwaitable((int)SceneIds.DevGen);
             Context.LoadingManager.OnLoadingEnded += AfterSceneLoaded;
 
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
@@ -78,7 +73,7 @@ namespace Code.App.AppStates
                 Context.AudioFactory.WarmSFX(),
                 Context.AudioFactory.WarmDispatcher()
             );
-            
+
             Context.LoadingManager 
                 .UnregisterLoading(LoadingWork.LoadUI) 
                 .UnregisterLoading(LoadingWork.LoadAudio);
@@ -101,6 +96,10 @@ namespace Code.App.AppStates
                 WaitForPlayerCharacterLoad() 
             );
             
+            _playerHealth = Context.PlayerProvider.Health;
+            _playerHealth.OnDamage += PlayerDamageTaken;
+            _playerHealth.OnDeath += EndGame;
+            
             Context.LoadingManager 
                 .UnregisterLoading(LoadingWork.LoadModelResource); 
         }
@@ -257,7 +256,7 @@ namespace Code.App.AppStates
         {
             var sceneEnvironment = (GameplaySceneEnvironment)sceneContainer.Resolve<CurrentSceneEnvironment>();
  
-            _debugTube = sceneEnvironment.debugTube;
+            
             return sceneEnvironment;
         }
     }

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

@@ -46,7 +46,8 @@ namespace Code.App.AppStates
         {
             await UniTask.WhenAll(
                 Context.UIService.AsyncSwitchPanelTo(UIPanel.MainMenu),
-                Context.AudioFactory.WarmMenuMusic()
+                Context.AudioFactory.WarmMenuMusic(),
+                Context.AudioFactory.WarmAudioTestClips()
             );
             Context.LoadingManager
                 .UnregisterLoading(LoadingWork.LoadUI)
@@ -98,6 +99,7 @@ namespace Code.App.AppStates
             menuPanel.exitButton.button.onClick.AddListener(ExitGame);
 
             mainMenuEnvironment.menuButtonsCanvas.worldCamera = Context.CameraStateMachine.Camera;
+            mainMenuEnvironment.settingsCanvas.worldCamera = Context.CameraStateMachine.Camera;
         }
 
         public override void Tick()
@@ -120,6 +122,7 @@ namespace Code.App.AppStates
             Context.InputService.DisableMap(ActionMappings.MainMenu);
             Context.AudioService.GladlyAskToStopMusic(MusicType.Menu, callback: Context.AudioFactory.ReleaseMenuMusic);
 
+            Context.AudioFactory.ReleaseAudioTestClips();
             base.ExitState();
         }
     }

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

@@ -5,8 +5,10 @@ using Code.Audio;
 using Code.Configs;
 using Code.Constants;
 using Code.Gameplay.Camera;
+using Code.Gameplay.Enemies;
 using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
+using Code.Generator;
 using Code.Input;
 using Code.Scenes;
 using Code.StaticData;
@@ -31,8 +33,11 @@ namespace Code.App
             containerBuilder.AddSingleton(typeof(LoadingManager), typeof(ILoadingManager));
             
             containerBuilder.AddSingleton(typeof(InputService), typeof(IInputService));
+            // Перенести нахуй в контейнер геймплея
             containerBuilder.AddSingleton(typeof(PlayerFactory), typeof(IPlayerFactory));
-
+            containerBuilder.AddSingleton(typeof(EnemyFactory), typeof(IEnemyFactory));
+            containerBuilder.AddSingleton(typeof(PlayerProvider), typeof(IPlayerProvider));
+            // 
             InitializeCamera(containerBuilder, staticDataService);
             
             containerBuilder.AddSingleton(typeof(UIFactory), typeof(IUIFactory));
@@ -84,8 +89,13 @@ namespace Code.App
             
             containerBuilder.AddSingleton(staticDataService.UIConfig, typeof(UIConfig));
             
+            containerBuilder.AddSingleton(staticDataService.DrunkenGrandpaConfig, typeof(DrunkenGrandpaConfig));
+            containerBuilder.AddSingleton(staticDataService.CockroachConfig, typeof(CockroachConfig));
+            containerBuilder.AddSingleton(staticDataService.FogConfig, typeof(FogConfig));
+            
             containerBuilder.AddSingleton(staticDataService.AudioMixerConfig, typeof(AudioMixerConfig));
             containerBuilder.AddSingleton(staticDataService.SoundtrackListConfig, typeof(SoundtrackListConfig));
+            containerBuilder.AddSingleton(staticDataService.AudioTestClipsConfig, typeof(AudioTestClipsConfig));
             containerBuilder.AddSingleton(staticDataService.SFXListConfig, typeof(SFXListConfig));
             containerBuilder.AddSingleton(staticDataService.DispatcherSoundListConfig, typeof(DispatcherSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
@@ -93,6 +103,8 @@ namespace Code.App
 
             containerBuilder.AddSingleton(staticDataService.OrderServiceConfig, typeof(OrderServiceConfig));
             containerBuilder.AddSingleton(staticDataService.OrderBoxConfig, typeof(OrderBoxConfig)); 
+            
+            containerBuilder.AddSingleton(staticDataService.GeneratorConfig, typeof(GeneratorConfig)); 
         }
 
         private AppStateMachine _appStateMachine;

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

@@ -1,8 +1,10 @@
 using Code.App.Loading;
 using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
+using Code.Generator;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
+using Cysharp.Threading.Tasks;
 using Reflex.Core;
 using UnityEngine;
 using IPlayerScore = Code.Gameplay.Player.IPlayerScore;
@@ -18,6 +20,8 @@ namespace Code.App.SceneInstallers
             containerBuilder.AddScoped(typeof(GameplaySceneEnvironment), typeof(CurrentSceneEnvironment));
             containerBuilder.AddScoped(typeof(PlayerScore), typeof(IPlayerScore));
             containerBuilder.AddScoped(typeof(OrderService), typeof(IOrderService));
+            containerBuilder.AddScoped(typeof(RoomGeneratorFactory), typeof(IRoomGeneratorFactory));
+            containerBuilder.AddScoped(typeof(RoomGenerator));
 
             containerBuilder.OnContainerBuilt += Initialize;
         }
@@ -32,6 +36,17 @@ namespace Code.App.SceneInstallers
             
             loadingManager
                 .UnregisterLoading(LoadingWork.LoadScene);
+            
+            LoadRooms(container,loadingManager);
+        }
+
+        private async UniTaskVoid LoadRooms(Container container, ILoadingManager loadingManager)
+        {
+            await container.Resolve<IRoomGeneratorFactory>().PreloadRooms(container.Resolve<IOrderService>());
+            
+            container.Resolve<RoomGenerator>().Initialize();
+            
+            loadingManager.UnregisterLoading(LoadingWork.LoadModelResource);
         }
     }
 }

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

@@ -1,7 +1,9 @@
 using Code.App.Loading;
 using Code.Audio;
 using Code.Gameplay.Camera;
+using Code.Gameplay.Enemies;
 using Code.Gameplay.Player;
+using Code.Generator;
 using Code.Input;
 using Code.Scenes;
 using Code.UI;
@@ -18,7 +20,9 @@ namespace Code.App.StateMachine
         [Inject] public CameraStateMachine CameraStateMachine { get; private set; }
         [Inject] public IUIService UIService { get; private set; }
         [Inject] public IPlayerFactory PlayerFactory { get; private set; }
+        [Inject] public IPlayerProvider PlayerProvider { get; private set; }
         [Inject] public IAudioFactory AudioFactory { get; private set; }
         [Inject] public IAudioService AudioService { get; private set; }
+        [Inject] public IEnemyFactory EnemyFactory { get; private set; } 
     }
 }

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

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

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

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

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using Code.Configs;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
@@ -86,6 +87,34 @@ namespace Code.Audio
             onComplete?.Invoke();
             _pool.Release(source);
         } 
+        public async UniTaskVoid PlayOneShot(AudioSource audioSource, AudioClip clip, AudioMixerGroup audioMixerGroup, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
+        { 
+            audioSource.PlayOneShot(clip);
+            audioSource.spatialBlend = _settings[audioSourceType].spatialBlend;
+            audioSource.outputAudioMixerGroup = audioMixerGroup;
+            
+            // TODO Потом сделать. Можно с cancellation, но сейчас лень. Ну правда
+            await UniTask.WaitUntilValueChanged(audioSource, x => x.isPlaying);
+            
+            if (!audioSource) return;
+            
+            _pool.Release(audioSource);
+            onComplete?.Invoke();
+        } 
+        public async UniTaskVoid PlayOneShot(AudioClip clip, AudioMixerGroup audioMixerGroup, CancellationTokenSource cancellationToken, AudioSourceType audioSourceType = AudioSourceType.NoBlend, Action onComplete = null)
+        { 
+            AudioSource source = _pool.Get();
+            source.PlayOneShot(clip);
+            source.spatialBlend = _settings[audioSourceType].spatialBlend;
+            source.outputAudioMixerGroup = audioMixerGroup;
+             
+            var (isCanceled, _) = await UniTask.WaitUntilValueChanged(source, x => x.isPlaying, cancellationToken: cancellationToken.Token).SuppressCancellationThrow();
+            
+            _pool.Release(source);
+            
+            if(!isCanceled) onComplete?.Invoke();
+            else cancellationToken.Dispose();
+        } 
         public AudioSource GetSource() => _pool.Get();
         public void ReleaseSource(AudioSource source) => _pool.Release(source);
     }

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

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

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

@@ -20,5 +20,8 @@ namespace Code.Audio
         event OnAudioPlayingDelegate OnDispatcherStarted;
         event OnAudioPlayingDelegate OnDispatcherEnded;
         void PlayDispatcher(DispatcherSounds dispatcherSoundId);
+        void ChangeSetting(AudioType type, float value);
+        float GetSetting(AudioType type);
+        void PlayTestClip(AudioType audioType);
     }
 }

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

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

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

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

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

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

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

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

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/DebugAndTest.meta

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

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

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

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

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

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

@@ -1,147 +1,78 @@
 using UnityEngine;
-using KinematicCharacterController;
 
 namespace Code.Gameplay.Character.Controller.Abilities
 {
-    /*
-     * Механика наклона персонажа при контакте со стеной
-     * Управляет визуальным наклоном модели в зависимости от высоты подъёма по стене
-     */
     public class WallLeanMechanic
     {
-        private readonly float _maxLeanAngle;
-        private readonly float _leanSharpness;
-        private readonly float _heightScale;
-        
-        private Transform _characterTransform;
-        private Vector3 _lastWallNormal;
-        private float _lastWallContactHeight;
-        private float _leanFactor;
-        private float _leanSign;
-        private Vector3 _leanDirection;
-        
-        private Vector3 _lastWallContactPoint;
-        private bool _isLeaningOnWall;
-        private const float WallProximityThreshold = 0.6f;
+        private readonly float _leanAngle;
+        private readonly float _threshold;
+        private readonly float _smoothSpeed;
 
-        public WallLeanMechanic(float maxLeanAngle, float leanSharpness, float heightScale)
+        private Transform _model;
+
+        public WallLeanMechanic(
+            float leanAngle,
+            float threshold,
+            float smoothSpeed)
         {
-            _maxLeanAngle = maxLeanAngle;
-            _leanSharpness = leanSharpness;
-            _heightScale = heightScale;
+            _leanAngle = leanAngle;
+            _threshold = threshold;
+            _smoothSpeed = smoothSpeed;
         }
 
-        // Назначаем трансформ визуальной модели один раз
-        public void SetCharacterTransform(Transform transform)
+        public void SetModel(Transform model) => _model = model;
+
+        public void Update(bool isWallRunning, Vector3 wallNormal, Vector3 characterForward)
         {
-            _characterTransform = transform;
-        }
-
-        // Вызывается из OnMovementHit
-        public void OnWallContact(KinematicCharacterMotor motor, Vector3 wallNormal, float contactHeight)
-        {
-            // Только если это действительно стена (не пол/потолок)
-            var dotWithUp = Vector3.Dot(wallNormal, motor.CharacterUp);
-            if (Mathf.Abs(dotWithUp) > 0.7f) // ~45°, можно настроить
-                return;
-
-            _lastWallNormal = wallNormal;
-            _lastWallContactHeight = contactHeight;
-            _lastWallContactPoint = motor.TransientPosition;
-
-            // Пересчитываем направление наклона
-            _leanDirection = -_lastWallNormal;
-            _leanDirection = Vector3.ProjectOnPlane(_leanDirection, motor.CharacterUp).normalized;
-
-            _leanSign = 1;
-            
-            // what the fuck
-            if (_leanDirection.x != 0)
+            if (!_model)
             {
-                switch (_leanDirection.x)
-                {
-                    case -1 or 1 when motor.CharacterRight.x > 0.1f:
-                        _leanSign = -1;
-                        break;
-                    case -1 or 1 when Mathf.Abs(motor.CharacterRight.x) < 0.1f:
-                        _leanDirection = new Vector3(0, 0, -1);
-                        break;
-                }
-            }
-            else
-            {
-                switch (_leanDirection.z)
-                {
-                    case 1 when Mathf.Abs(motor.CharacterRight.z) < 0.1f:
-                        _leanSign = -1;
-                        break;
-                    case -1 when motor.CharacterRight.z < -0.1f:
-                    case 1 when motor.CharacterRight.z > 0.1f:
-                        _leanDirection = new Vector3(-1, 0, 0);
-                        break;
-                    case -1 when motor.CharacterRight.z > 0.1f:
-                    case 1 when motor.CharacterRight.z < -0.1f:
-                        _leanDirection = new Vector3(1, 0, 0);
-                        break;
-                }
-            }
-            
-            _isLeaningOnWall = true;
-        }
-
-        // Обновление каждый кадр
-        public void UpdateLean(KinematicCharacterMotor motor, float deltaTime)
-        {
-            if (!_characterTransform) return;
-
-            var currentPosition = motor.TransientPosition;
-
-            var isStillNearWall = false;
-            if (_isLeaningOnWall && _lastWallNormal != Vector3.zero)
-            {
-                var toWall = currentPosition - _lastWallContactPoint;
-                var distanceToWallPlane = Mathf.Abs(Vector3.Dot(toWall, _lastWallNormal));
-                isStillNearWall = distanceToWallPlane <= WallProximityThreshold;
-            }
-
-            if (_isLeaningOnWall)
-            {
-                var isBelowContactHeight = currentPosition.y < _lastWallContactHeight;
-
-                if (!isStillNearWall || isBelowContactHeight)
-                {
-                    _isLeaningOnWall = false;
-                }
-                else
-                {
-                    var heightDelta = currentPosition.y - _lastWallContactHeight;
-                    var targetLeanFactor = Mathf.Clamp01(heightDelta * _heightScale);
-                    _leanFactor = Mathf.Lerp(_leanFactor, targetLeanFactor, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
-                }
-            }
-
-            if (!_isLeaningOnWall)
-            {
-                _leanFactor = Mathf.Lerp(_leanFactor, 0f, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
-            }
-            
-            ApplyLeanRotation(motor);
-        }
-
-        private void ApplyLeanRotation(KinematicCharacterMotor motor)
-        {
-            if (_leanFactor <= 0.01f)
-            {
-                _characterTransform.localRotation = Quaternion.identity;
+                _model.localRotation = Quaternion.identity;
                 return;
             }
 
-            if (_leanDirection.sqrMagnitude < 0.01f) return;
+            var targetRotation = Quaternion.identity;
 
-            var leanAngle = _leanSign * _leanFactor * _maxLeanAngle;
-            var leanAxis = Vector3.Cross(motor.CharacterUp, _leanDirection);
-            var leanRotation = Quaternion.AngleAxis(leanAngle, leanAxis);
-            _characterTransform.localRotation = leanRotation;
+            if (isWallRunning)
+            {
+                var n = new Vector3(wallNormal.x, 0f, wallNormal.z).normalized;
+                if (n.sqrMagnitude < 0.001f) n = Vector3.forward;
+
+                var bodyRight = Vector3.Cross(Vector3.up, characterForward).normalized;
+                var side = Vector3.Dot(n, bodyRight);
+                var front = Vector3.Dot(n, characterForward);
+
+                var axis = Vector3.right;
+                var angle = 0f;
+
+                if (side > _threshold)
+                {
+                    axis = Vector3.forward;
+                    angle = -_leanAngle;
+                }
+                else if (side < -_threshold)
+                {
+                    axis = Vector3.forward;
+                    angle = _leanAngle;
+                }
+                else if (front > _threshold)
+                {
+                    axis = Vector3.right;
+                    angle = -_leanAngle;
+                }
+                else if (front < -_threshold)
+                {
+                    axis = Vector3.right;
+                    angle = _leanAngle;
+                }
+
+                targetRotation = Quaternion.AngleAxis(angle, axis);
+            }
+
+            _model.localRotation = Quaternion.Slerp(
+                _model.localRotation,
+                targetRotation,
+                1f - Mathf.Exp(-_smoothSpeed * Time.deltaTime)
+            );
         }
     }
 }

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

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

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

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

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

@@ -15,7 +15,7 @@ namespace Code.Gameplay.Character.Controller
      * Реализует физическое движение персонажа с использованием Kinematic Character Controller
      * Обрабатывает ввод пользователя, применяет движение и вращение с учетом поверхности
      *
-     * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM
+     * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM  
      */
     public class CustomCharacterController : MonoBehaviour, ICharacterController
     {
@@ -28,44 +28,23 @@ namespace Code.Gameplay.Character.Controller
         // Подсистемы
         private CharacterInputHandler _inputHandler;
         private SlideMechanic _slideMechanic;
-        private WallClimbMechanic _wallClimbMechanic;
+        // private WallClimbMechanic _wallClimbMechanic;
+        private WallRunningMechanic _wallRunningMechanic;
         private WallLeanMechanic _wallLeanMechanic;
         private GroundMovementSystem _groundMovement;
         private AirMovementSystem _airMovement;
         
+        public bool IsSliding => _slideMechanic.IsSliding; 
+        public bool IsWallRunning => _wallRunningMechanic.IsWallRunning;
+        
+        private float abilityBlockTimer;
+        private bool isAbilitiesBlocked;
+        
+        private CharacterInputs _lastInputs;
+        
         public void SetPosition(Vector3 position) => motor.SetPosition(position);
         public void SetRotation(Quaternion rotation) => motor.SetRotation(rotation);
         
-        // Инициализация контроллера
-        // private void Awake()
-        // {
-        //     // Инициализация подсистем с параметрами из конфига
-        //     _inputHandler = new CharacterInputHandler(
-        //         _characterConfig.sprintAngleThreshold
-        //     );
-        //     _slideMechanic = new SlideMechanic(
-        //         _characterConfig.slideSpeed,
-        //         _characterConfig.slideDuration,
-        //         _characterConfig.slideCooldown
-        //     );
-        //     _wallClimbMechanic = new WallClimbMechanic(
-        //         _characterConfig.wallClimbSpeedFactor,
-        //         _characterConfig.minWallClimbSpeed,
-        //         _characterConfig.wallDetectionAngleThreshold
-        //     );
-        //     _wallLeanMechanic = new WallLeanMechanic(
-        //         _characterConfig.maxWallLeanAngle,
-        //         _characterConfig.wallLeanSharpness,
-        //         _characterConfig.wallLeanHeightScale
-        //     );
-        //     _groundMovement = new GroundMovementSystem(
-        //         _characterConfig.maxStableMoveSpeed,
-        //         _characterConfig.sprintMoveSpeed,
-        //         _characterConfig.stableMovementSharpness,
-        //         _characterConfig.jumpSpeed
-        //     );
-        //     _airMovement = new AirMovementSystem(_characterConfig.gravity);
-        // }
         [Inject]
         private void Construct(CharacterConfig characterConfig)
         {
@@ -79,16 +58,25 @@ namespace Code.Gameplay.Character.Controller
                 _characterConfig.slideDuration,
                 _characterConfig.slideCooldown
             );
-            _wallClimbMechanic = new WallClimbMechanic(
-                _characterConfig.wallClimbSpeedFactor,
-                _characterConfig.minWallClimbSpeed,
-                _characterConfig.wallDetectionAngleThreshold
-            );
+            // _wallClimbMechanic = new WallClimbMechanic(
+            //     _characterConfig.wallClimbSpeedFactor,
+            //     _characterConfig.minWallClimbSpeed,
+            //     _characterConfig.wallDetectionAngleThreshold
+            // );
+            _wallRunningMechanic = new WallRunningMechanic();
+            // Настройка параметров WallRunningMechanic (можно вынести в конфиг позже)
+            _wallRunningMechanic.MaxWallRunTime = 1.75f;
+            _wallRunningMechanic.WallRunSpeed = 15.0f;
+            _wallRunningMechanic.WallRunAcceleration = 25.0f;
+            _wallRunningMechanic.WallRunGravityScale = 0.25f;
+            _wallRunningMechanic.WallDetachImpulse = 7.0f;
+            _wallRunningMechanic.WallContactAngleThreshold = 45.0f;
+            
             _wallLeanMechanic = new WallLeanMechanic(
-                _characterConfig.maxWallLeanAngle,
-                _characterConfig.wallLeanSharpness,
-                _characterConfig.wallLeanHeightScale
-            );
+                _characterConfig.leanAngle,
+                _characterConfig.leanThreshold,
+                _characterConfig.leanSmoothSpeed
+                );
             _groundMovement = new GroundMovementSystem(
                 _characterConfig.maxStableMoveSpeed,
                 _characterConfig.sprintMoveSpeed,
@@ -101,31 +89,24 @@ namespace Code.Gameplay.Character.Controller
             motor.CharacterController = this; // Регистрация этого контроллера в движке
             _inputHandler.FirstPersonCameraRotation =
                 motor.Transform.rotation; // Начальное вращение совпадает с персонажемс
-            _wallLeanMechanic.SetCharacterTransform(characterTransform);
+            _wallLeanMechanic.SetModel(characterTransform);
+            _wallRunningMechanic.Initialize(motor, _inputHandler);
         }
+
         // Текущий режим камеры для адаптации поведения
         private CameraMode _currentCameraMode = CameraMode.FirstPerson;
 
-        // Инициализация контроллера
-        // private void Start()
-        // {
-        //     motor.CharacterController = this; // Регистрация этого контроллера в движке
-        //     _inputHandler.FirstPersonCameraRotation =
-        //         motor.Transform.rotation; // Начальное вращение совпадает с персонажемс
-        //     _wallLeanMechanic.SetCharacterTransform(characterTransform);
-        // }
-
-        // Обработка и преобразование входных данных от персонажа
         public void SetInputs(ref CharacterInputs inputs)
         {
-            // Обновляем таймер перезарядки слайда
+            _lastInputs = inputs;
+            // Обновляем таймеры механик
             _slideMechanic.TickCooldown(Time.deltaTime);
-            _wallClimbMechanic.TickCooldown(Time.deltaTime);
+            // _wallClimbMechanic.TickCooldown(Time.deltaTime);
+            _wallRunningMechanic.Tick(Time.deltaTime);
 
             // Если активен слайд - игнорируем весь остальной ввод
             if (_slideMechanic.IsSliding)
             {
-                // Во время слайда не обрабатываем движение, прыжки и спринт
                 _inputHandler.MoveInputVector = Vector3.zero;
                 _inputHandler.LookInputVector = Vector3.one;
                 _inputHandler.IsSprinting = false;
@@ -133,8 +114,21 @@ namespace Code.Gameplay.Character.Controller
                 return;
             }
 
-            // Сохраняем текущий режим камеры
             _currentCameraMode = inputs.CameraMode;
+            
+            if (isAbilitiesBlocked)
+            {
+                abilityBlockTimer -= Time.deltaTime;
+                if (abilityBlockTimer <= 0)
+                {
+                    isAbilitiesBlocked = false;
+                }
+                else
+                {
+                    inputs.SprintPressed = false;
+                    inputs.SlidePressed = false;
+                }
+            }
 
             // Обработка слайда
             _slideMechanic.RequestSlide(inputs.SlidePressed);
@@ -142,42 +136,33 @@ namespace Code.Gameplay.Character.Controller
             // Обработка остального ввода
             _inputHandler.ProcessInputs(ref inputs, motor);
 
-            // Передаём запрос прыжка напрямую в систему движения по земле
+            // Передаём запрос прыжка
             _groundMovement.RequestJump(inputs.JumpPressed);
         }
 
-        // Обновление вращения персонажа на основе входных данных
         public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
         {
-            if (_slideMechanic.IsSliding || _wallClimbMechanic.IsClimbingActive)  return;
+            if (_slideMechanic.IsSliding) return;
 
             switch (_currentCameraMode)
             {
-                // В FirstPerson режиме применяем вращение камеры напрямую к персонажу (только горизонталь)
                 case CameraMode.FirstPerson when _inputHandler.ShouldApplyCameraRotation:
-                    // Немедленно применяем горизонтальное вращение камеры к персонажу
                     currentRotation = _inputHandler.FirstPersonCameraRotation;
                     break;
-                // В ThirdPerson режиме плавно поворачиваем персонаж в направлении движения
                 case CameraMode.ThirdPerson:
                 {
-                    // Вращение применяется только если есть направление движения и разрешена резкость вращения
                     if (_inputHandler.LookInputVector.sqrMagnitude > 0 && _characterConfig.orientationSharpness > 0)
                     {
-                        // Плавная интерполяция текущего направления к целевому с экспоненциальным сглаживанием
                         var smoothedLookInputDirection = Vector3.Slerp(
                             motor.CharacterForward,
                             _inputHandler.LookInputVector,
                             1f - Mathf.Exp(-_characterConfig.orientationSharpness * deltaTime)
                         ).normalized;
 
-                        // Установка нового вращения смотря в сглаженном направлении
                         currentRotation = Quaternion.LookRotation(smoothedLookInputDirection, motor.CharacterUp);
                     }
-
                     break;
                 }
-                // Заготовка на будущее (если понадобится)
                 case CameraMode.Static:
                 case CameraMode.Cinematic:
                 default:
@@ -185,96 +170,104 @@ namespace Code.Gameplay.Character.Controller
             }
         }
 
-        // Обновление скорости движения персонажа
         public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
         {
-            // Если во время слайда запрошен прыжок — прерываем слайд
             if (_slideMechanic.IsSliding && _groundMovement.JumpRequested)
             {
                 _slideMechanic.EndSlide();
             }
 
-            // Проверяем запрос слайда и запускаем его если можно
             if (!_slideMechanic.IsSliding)
             {
                 _slideMechanic.TryStartSlide(motor, _currentCameraMode, _inputHandler.FirstPersonCameraRotation,
                     _inputHandler.LookInputVector);
             }
-            // Если активен слайд - обрабатываем отдельно
             else
             {
                 _slideMechanic.HandleSlide(ref currentVelocity, deltaTime, motor);
                 return;
             }
 
+            // === WALL RUNNING: обработка состояния ===
+            if (_wallRunningMechanic.IsWallRunning)
+            {
+                // 🔄 Передаём актуальные данные для walljump
+                if (_groundMovement.JumpRequested) // или _lastInputs.JumpPressed — зависит от логики
+                {
+                    _wallRunningMechanic.PerformWallJump(_lastInputs, _inputHandler.FirstPersonCameraRotation);
+                    _groundMovement.CancelJumpRequest(); // сброс, чтобы не сработало дважды
+                }
+                else
+                {
+                    _wallRunningMechanic.HandleWallRun(ref currentVelocity, _lastInputs, deltaTime);
+                }
+                return;
+            }
+
             // Если персонаж находится на земле
             if (motor.GroundingStatus.IsStableOnGround)
             {
                 _groundMovement.UpdateVelocity(ref currentVelocity, _inputHandler, motor, deltaTime);
             }
-            // Если персонаж не находится на земле
+            // Если персонаж не на земле — стандартное воздушное движение
             else
             {
                 _airMovement.UpdateVelocity(ref currentVelocity, deltaTime);
-                // Отменяем прыжок (фикс проблемы с двойным прыжком после приземления)
                 _groundMovement.CancelJumpRequest();
             }
         }
+        
+        public void BlockAbilities(float duration)
+        {
+            isAbilitiesBlocked = true;
+            abilityBlockTimer = duration;
+        }
 
-        // Метод вызывается перед обновлением персонажа (можно использовать для подготовки)
         public void BeforeCharacterUpdate(float deltaTime)
         {
         }
 
-        // Метод вызывается после обработки столкновения с землей
         public void PostGroundingUpdate(float deltaTime)
         {
-            // Если во время слайда персонаж оторвался от земли - заканчиваем слайд
             if (_slideMechanic.IsSliding && !motor.GroundingStatus.IsStableOnGround)
             {
                 _slideMechanic.EndSlide();
             }
-            
-            if (motor.GroundingStatus.IsStableOnGround)
-            {
-                _wallClimbMechanic.ResetWallClimbSession();
-            }
         }
 
-        // Метод вызывается после обновления персонажа
         public void AfterCharacterUpdate(float deltaTime)
         {
-            _wallLeanMechanic.UpdateLean(motor, deltaTime);
+            _wallLeanMechanic.Update(
+                _wallRunningMechanic.IsWallRunning,
+                _wallRunningMechanic.GetWallNormal(),
+                motor.CharacterForward
+            );
         }
 
-        // Проверка валидности коллайдера для обработки столкновений
         public bool IsColliderValidForCollisions(Collider coll)
         {
-            return true; // Все коллайдеры считаются валидными для столкновений
+            return true;
         }
 
-        // Обработка столкновения с землей (вызывается при приземлении)
         public void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
             ref HitStabilityReport hitStabilityReport)
         {
         }
 
-        // Обработка столкновения при движении (вызывается при ударе о препятствие)
         public void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
             ref HitStabilityReport hitStabilityReport)
         {
-            if (_wallClimbMechanic.TryClimbWall(motor, hitNormal))
-                _wallLeanMechanic.OnWallContact(motor, hitNormal, motor.TransientPosition.y);
+            if (_wallRunningMechanic.TryStartWallRun(hitNormal, hitPoint))
+            {
+            }
         }
 
-        // Обработка отчета о стабильности столкновения
         public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
             Vector3 atCharacterPosition,
             Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport)
         {
         }
 
-        // Обработка дискретных столкновений (для триггеров и специальных коллайдеров)
         public void OnDiscreteCollisionDetected(Collider hitCollider)
         {
         }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -33,7 +33,7 @@ namespace Code.Gameplay.Orders.Order
         }
         public void OnTriggerEnter(Collider other)
         {
-            if (!_pickupMode) return;
+            if (!_pickupMode || !other.CompareTag("Player")) return;
             
             _orderService.OrderRecieved();
             Destroy(gameObject);

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

@@ -10,7 +10,7 @@ namespace Code.Gameplay.Orders.Order
         private bool _playerEntered;
         private void OnTriggerEnter(Collider other)
         {
-            if (_playerEntered) return;
+            if (_playerEntered ) return;
             
              _playerEntered = true;
             _orderService.OrderDelivered();

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

@@ -14,18 +14,20 @@ namespace Code.Gameplay.Orders.Order
             hatch.DORotate(new Vector3(-130f, 0, 0), 0.2f);
 
             order.rigidbody.isKinematic = false;
-            order.rigidbody.AddForce(-transform.forward * 10f, ForceMode.Impulse);
+            order.rigidbody.AddForce(-transform.forward * 1f, ForceMode.Impulse);
+
+            order.SwitchMode();
         }
 
         // DEBUG TODO ДИМКА УДАЛИ И ПРОПИШИ В СВОЕЙ ЛОГИКЕ
-        public void OnTriggerEnter(Collider other)
-        {
-            if(_activated) return;
-            _activated = true;
-            
-            ThrowOrder();
-            order.SwitchMode();
-        }
+        // public void OnTriggerEnter(Collider other)
+        // {
+        //     if(_activated) return;
+        //     _activated = true;
+        //     
+        //     ThrowOrder();
+        //     order.SwitchMode();
+        // }
         // DEBUG
     }
 }

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

@@ -9,7 +9,7 @@ namespace Code.Gameplay.Orders.Order
         private bool _playerEntered;
         private void OnTriggerEnter(Collider other)
         {
-            if (_playerEntered) return;
+            if (_playerEntered ) return;
             
             _playerEntered = true;
             _orderService.OrderGive();

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

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Orders.Order
+{
+    public class RoomDispenserTrigger : MonoBehaviour
+    {
+        [SerializeField] private OrderDispenser orderDispenser;
+        private bool _playerEntered;
+
+        private void OnTriggerEnter(Collider other)
+        {
+            if (_playerEntered ) return;
+            orderDispenser.ThrowOrder();
+            _playerEntered = true;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 630780fe69aa45eda7d4bcf966516c7d
+timeCreated: 1764313014

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

@@ -14,6 +14,7 @@ namespace Code.Gameplay.Player
     public class PlayerFactory : IPlayerFactory
     {
         [Inject] PlayerConfig _playerConfig;
+        [Inject] private IPlayerProvider _playerProvider;
         
         public PlayerHealth CreatePlayerHealth(int count = -1)
         {
@@ -24,14 +25,20 @@ namespace Code.Gameplay.Player
 
         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);
         }
 

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/Generator/IRoomGeneratorFactory.cs

@@ -1,3 +1,5 @@
+ 
+using Code.Gameplay.Orders.Order;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 
@@ -5,8 +7,10 @@ namespace Code.Generator
 {
     public interface IRoomGeneratorFactory
     {
-        UniTask PreloadRooms();
-        GameObject GetCachedPrefab(int index);
-        UniTask<Room> CreateRoomByIndex(int index);
+        UniTask PreloadRooms(IOrderService orderService);
+        GameObject GetCachedPrefab(int index, RoomType roomType);
+         Room CreateRoomByIndex(int index, RoomType roomType); 
+        void ReleaseRooms();
+        GameObject GetRandomCachedPrefabOfType(RoomType roomType, out int index);
     }
 }

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

@@ -0,0 +1,9 @@
+using UnityEngine;
+
+namespace Code.Generator
+{
+    public class InitialRoom : Room
+    {
+        public Transform playerSpawn;
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4245aa5c87c7455ebad11edaad3b649e
+timeCreated: 1764324045

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

@@ -1,28 +1,33 @@
 using System;
+using Code.Gameplay.Door;
 using Code.UI;
 using UnityEngine;
 
 namespace Code.Generator
 {
+    [RequireComponent(typeof(Transform))]
     public class Room : MonoBehaviour
     {
-        [SerializeField] private RoomType roomType;
+        [SerializeField] protected RoomType roomType;
         public RoomType RoomType => roomType;
-        [SerializeField] private float roomTimer;
+        [SerializeField] protected float roomTimer;
         public float RoomTimer => roomTimer;
-        [SerializeField] private Transform enterMarker;
+        [SerializeField] protected Transform enterMarker;
         public Transform EnterMarker => enterMarker;
-        [SerializeField] private Transform exitMarker;
+        [SerializeField] protected Transform exitMarker;
         public Transform ExitMarker => exitMarker;
+        [SerializeField] protected Door door;
         
-        private void Awake()
+        protected void Awake()
         {
             if (EnterMarker == null || ExitMarker == null)
             {
                 Debug.LogError($"Але маркеры не найдены у комнаты {gameObject.name}");
             }
         }
-        
+
+        public void Initialize() => door.TranslationMode(false);
+
         //PIZDEC
     }
 }

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

@@ -1,199 +1,314 @@
 using System.Collections.Generic;
+using Code.Gameplay.Orders.Order;
+using Code.Scenes;
+using Code.Scenes.SceneEnvironments;
 using Cysharp.Threading.Tasks;
+using Reflex.Attributes;
 using UnityEngine;
 
 namespace Code.Generator
 {
-    public class RoomGenerator : MonoBehaviour
+    public class RoomGenerator
     {
-        [SerializeField] private GeneratorConfig generatorConfig;
-        
-        private RoomGeneratorFactory _factory;
+        [Inject] private IOrderService _orderService;
+
+        [Inject] private GeneratorConfig generatorConfig;
+
+        [Inject] private IRoomGeneratorFactory _factory;
+         
+        private List<RoomIndex> _roomIndexesStack;
+
+        private struct RoomIndex
+        {
+            public RoomType RoomType;
+            public int Index;
+
+            public RoomIndex(RoomType roomType, int index)
+            {
+                RoomType = roomType;
+                Index = index;
+            }
+        }
 
-        private float _timer;
-        private List<int> _roomIndexesStack;
         private List<Room> _spawnedRooms;
 
-        private async void Awake()
+        private int _nextRoomStackIndex;
+
+        public void Initialize()
         {
-            _factory = new RoomGeneratorFactory(generatorConfig);
+            // _orderService.OrderGive();
+
             _spawnedRooms = new List<Room>();
-            _roomIndexesStack = new List<int>();
+            _roomIndexesStack = new();
 
-            _timer = Random.Range(60, 120f);
-            Debug.LogWarning($"КОТЛЫ ГЕНЕРАЛЬСКИЕ{_timer}");
+            Debug.LogWarning($"КОТЛЫ ГЕНЕРАЛЬСКИЕ{_orderService.DeliveryTimer}");
 
-            await _factory.PreloadRooms();
+            // CreateRoomsStack();
 
-            CreateRoomsStack();     
-            await GenerateRoomsAsync();
+            // SpawnInitialRoomsAsync();
+            _orderService.OnOrderGiven += CreateRoomsStack;
+            RoomTrigger.PlayerEnteredRoom += OnPlayerEntered;
+
+            CreateInitialRoom();
+            SpawnNextRoomAsync();
         }
 
-        private void CreateRoomsStack()
+        private void OnEnable()
         {
-            _roomIndexesStack.Clear();
-            var remainingTime = _timer;
-            float ladderTimer = 0f;
-            int totalRooms = generatorConfig.roomAssetReferences.Length;
-            List<int> availableIndexes = new List<int>();
-            for (int i = 0; i < totalRooms; i++)
-                availableIndexes.Add(i);
+            RoomTrigger.PlayerEnteredRoom += OnPlayerEntered;
+        }
 
-            int saveIndex = FindRoomIndexByType(RoomType.Save);
-            if (saveIndex != -1)
+        private void OnDisable()
+        {
+            RoomTrigger.PlayerEnteredRoom -= OnPlayerEntered;
+        }
+
+        public void OnPlayerEntered()
+        {
+            SpawnNextRoomAsync();
+
+            if (_spawnedRooms.Count > 3)
             {
-                var prefab = _factory.GetCachedPrefab(saveIndex);
-                if (prefab != null)
-                {
-                    Room saveRoom = prefab.GetComponent<Room>();
-                    if (saveRoom != null)
-                    {
-                        _roomIndexesStack.Add(saveIndex);
-                        availableIndexes.Remove(saveIndex);
-                        
-                        Debug.Log($"Первая комната: {saveRoom.name}");
-                    }
-                }
+                Room roomToRemove = _spawnedRooms[0];
+                _spawnedRooms.RemoveAt(0);
+
+                // _factory.ReleaseRoom(roomToRemove);
+                Object.Destroy(roomToRemove.gameObject);
             }
+        }
 
-            while (remainingTime > 0 && availableIndexes.Count > 0)
+        private void CreateRoomsStack(float timer)
+        {
+            _nextRoomStackIndex = 0; 
+            _roomIndexesStack.Clear(); 
+            
+            var remainingTime = timer;
+  
+            while (remainingTime > 0)
             {
-                int randomIndex = Random.Range(0, availableIndexes.Count);
-                int chosenOne = availableIndexes[randomIndex];
-
-                var prefab = _factory.GetCachedPrefab(chosenOne);
-                if (prefab == null)
-                    continue;
+                var prefab = _factory.GetRandomCachedPrefabOfType(RoomType.Basic, out int roomIndex);
 
                 Room room = prefab.GetComponent<Room>();
-                if (room == null)
-                    continue;
 
-                switch (room.RoomType)
-                {
-                    case RoomType.Save or RoomType.PickUp:
-                        availableIndexes.RemoveAt(randomIndex);
-                        continue;
-                    
-                    case RoomType.Basic:
-                        float currentRoomTime = room.RoomTimer;
-                        if (remainingTime >= currentRoomTime && ladderTimer < 30f)
-                        {
-                            _roomIndexesStack.Add(chosenOne);
-                            remainingTime -= currentRoomTime;
-                            ladderTimer += currentRoomTime;
-                            Debug.Log($"комната {room.name} время {currentRoomTime} осталось: {remainingTime}");
-                        }
-                        availableIndexes.RemoveAt(randomIndex);
-                        break;
-                    
-                    case RoomType.Ladder:
-                        if (ladderTimer >= 30f)
-                        {
-                            _roomIndexesStack.Add(chosenOne);
-                            ladderTimer = 0f;
-
-                            availableIndexes.RemoveAt(randomIndex);
-                            Debug.Log($"Лестница ура {room.name}");
-                        }
-                        break;
-                    
-                    default:
-                        Debug.Log($"тип комнаты {room.RoomType}");
-                        availableIndexes.RemoveAt(randomIndex);
-                        break;
-                }
-            }
-
-            AddPickupRoom();
-            Debug.Log($"стек комнат: {_roomIndexesStack.Count}");
-        }
-
-        private async UniTask GenerateRoomsAsync()
-        {
-            for (int i = 0; i < _roomIndexesStack.Count; i++)
-            {
-                int index = _roomIndexesStack[i];
-                Room room = await _factory.CreateRoomByIndex(index);
-
-                if (i == 0)
-                {
-                    room.transform.position = Vector3.zero;
-                    room.transform.rotation = Quaternion.identity;
-                }
-                else
-                {
-                    Room previousRoom = _spawnedRooms[i - 1];
-                    PlaceRoom(room, previousRoom);
-                }
-
-                _spawnedRooms.Add(room);
-            }
-        }
-        
-        private int FindRoomIndexByType(RoomType neededType)
-        {
-            int totalRooms = generatorConfig.roomAssetReferences.Length;
-            for (int i = 0; i < totalRooms; i++)
-            {
-                var prefab = _factory.GetCachedPrefab(i);
-                if (prefab == null)
-                    continue;
-
-                Room room = prefab.GetComponent<Room>();
-                if (room == null)
-                    continue;
-
-                if (room.RoomType == neededType)
-                    return i;
-            }
-
-            return -1;
-        }
-        
-        private void AddPickupRoom()
-        {
-            int pickupIndex = FindRoomIndexByType(RoomType.PickUp);
-            if (pickupIndex == -1)
-            {
-                Debug.Log("PickUp комнат не найдено але");
-                return;
-            }
-
-            var prefab = _factory.GetCachedPrefab(pickupIndex);
-            if (prefab == null)
-                return;
-
-            Room pickupRoom = prefab.GetComponent<Room>();
-            if (pickupRoom == null)
-                return;
-
-            if (_roomIndexesStack.Count == 0)
-            {
-                Debug.LogWarning("стек пуст, нет позиции после первой");
-                return;
+                _roomIndexesStack.Add(new(RoomType.Basic, roomIndex));
+                remainingTime -= room.RoomTimer;
+                Debug.Log($"комната {room.name} время {room.RoomTimer} осталось: {remainingTime}");
             }
             
-            int insertPos = Random.Range(1, _roomIndexesStack.Count + 1); 
-                
-            _roomIndexesStack.Insert(insertPos, pickupIndex);
-            Debug.Log($"PickUp комната '{pickupRoom.name}' позиция {insertPos}");
+            CreateSaveRoom();
+
+            AddPickupRoom();
+             
+            Debug.Log($"стек комнат: {_roomIndexesStack.Count}");
+            SpawnNextRoomAsync();
         }
 
+        private void CreateSaveRoom()
+        {
+            var prefab = _factory.GetRandomCachedPrefabOfType(RoomType.Save, out int roomIndex);
+            Room saveRoom = prefab.GetComponent<Room>();
+            _roomIndexesStack.Add(new(RoomType.Save, roomIndex));
+
+            Debug.Log($"Первая комната: {saveRoom.name}");
+        } 
         
+        [Inject] private CurrentSceneEnvironment _currentSceneEnvironment;
+
+        private void CreateInitialRoom()
+        {
+            GameplaySceneEnvironment gameplaySceneEnvironment = (GameplaySceneEnvironment)_currentSceneEnvironment;
+            
+            _factory.GetRandomCachedPrefabOfType(RoomType.Initial, out int roomIndex); 
+            // _roomIndexesStack.Add(new(RoomType.Initial, roomIndex));
+            InitialRoom instantiated = _factory.CreateRoomByIndex(roomIndex, RoomType.Initial).GetComponent<InitialRoom>();
+            _spawnedRooms.Add(instantiated);
+            instantiated.transform.position = Vector3.zero;
+            instantiated.transform.rotation = Quaternion.identity;
+            
+            gameplaySceneEnvironment.playerSpawnPoint = instantiated.playerSpawn;
+            instantiated.Initialize();
+            
+            Debug.Log($"Первая комната: {instantiated.name}");
+        } 
+        private void SpawnNextRoomAsync()
+        {
+            if (_nextRoomStackIndex >= _roomIndexesStack.Count)
+                return;
+
+            RoomIndex index = _roomIndexesStack[_nextRoomStackIndex];
+            Room room = _factory.CreateRoomByIndex(index.Index, index.RoomType);
+
+            if (_spawnedRooms.Count == 0)
+            {
+                room.transform.position = Vector3.zero;
+                room.transform.rotation = Quaternion.identity;
+            }
+            else
+            {
+                Room previousRoom = _spawnedRooms[_spawnedRooms.Count - 1];
+                PlaceRoom(room, previousRoom);
+            }
+
+            _spawnedRooms.Add(room);
+            _nextRoomStackIndex++;
+        }
+
+        private void AddPickupRoom()
+        {
+            var prefab = _factory.GetRandomCachedPrefabOfType(RoomType.PickUp, out int pickupIndex);
+
+            Room pickupRoom = prefab.GetComponent<Room>();
+
+            if (_roomIndexesStack.Count == 0) return;
+
+            int insertPos = Random.Range(1, _roomIndexesStack.Count + 1);
+
+            _roomIndexesStack.Insert(insertPos, new(RoomType.PickUp, pickupIndex)); 
+        }
+
+
         private void PlaceRoom(Room current, Room previous)
         {
             if (current.EnterMarker == null || previous.ExitMarker == null)
                 return;
 
-            Transform enter = current.EnterMarker;
-            Transform exit = previous.ExitMarker;
+            Vector3 segmentOriginPosition = previous.ExitMarker.transform.position;
 
-            Quaternion rotationDiff = Quaternion.FromToRotation(enter.forward, exit.forward);
-            current.transform.rotation = rotationDiff * current.transform.rotation;
+            Transform randomDoorOrigin = current.EnterMarker;
+            Vector3 randomDoorOriginPosition = randomDoorOrigin.localPosition * current.transform.localScale.x;
+            Quaternion randomDoorOriginRotation = randomDoorOrigin.localRotation;
 
-            Vector3 offset = enter.localPosition;
-            current.transform.position = exit.position - offset;
+            float segmentOriginYRotation;
+
+            float entityRotation = previous.ExitMarker.transform.rotation.eulerAngles.y;
+            if (entityRotation > 305f) entityRotation -= 360f;
+            else if (entityRotation < -45f) entityRotation += 360f;
+
+            if (entityRotation > 135f)
+                segmentOriginYRotation = entityRotation - randomDoorOriginRotation.eulerAngles.y + 180f;
+            else
+                segmentOriginYRotation = entityRotation - randomDoorOriginRotation.eulerAngles.y - 180f;
+
+            if (segmentOriginYRotation < -45f) segmentOriginYRotation += 360f;
+            else if (segmentOriginYRotation > 305f) segmentOriginYRotation -= 360f;
+            else if (segmentOriginYRotation < -305f) segmentOriginYRotation += 720f;
+
+            if (segmentOriginYRotation is > -45f and < 45f)
+            {
+                segmentOriginPosition.x -= randomDoorOriginPosition.x;
+                segmentOriginPosition.z -= randomDoorOriginPosition.z;
+            }
+            else if (segmentOriginYRotation is >= 45f and < 135f)
+            {
+                segmentOriginPosition.x -= randomDoorOriginPosition.z;
+                segmentOriginPosition.z += randomDoorOriginPosition.x;
+            }
+            else if (segmentOriginYRotation is >= 135f and < 225f)
+            {
+                segmentOriginPosition.x += randomDoorOriginPosition.x;
+                segmentOriginPosition.z += randomDoorOriginPosition.z;
+            }
+            else if (segmentOriginYRotation is >= 225f and < 305f)
+            {
+                segmentOriginPosition.x += randomDoorOriginPosition.z;
+                segmentOriginPosition.z -= randomDoorOriginPosition.x;
+            }
+
+            segmentOriginPosition.y -= randomDoorOriginPosition.y;
+            current.transform.position = segmentOriginPosition;
+            current.transform.rotation = Quaternion.Euler(0, segmentOriginYRotation, 0);
+            // locationSegment.isNeedSomeDoors = true;
+            // locationSegment.AddBadDoorId(locationSegment.LocationSegment.GetDoorOrigins.IndexOf(randomDoorOrigin));
+            current.Initialize();
+
+            float frameOnTheBallRotation = segmentOriginYRotation + randomDoorOriginRotation.eulerAngles.y;
+            if (frameOnTheBallRotation > 305f) frameOnTheBallRotation -= 360f;
+            else if (frameOnTheBallRotation < -45f) frameOnTheBallRotation += 360f;
+
+            // heOnTheBall.AddSlaveLocationSegment(locationSegment.Id);
+            // heOnTheBall.ReplaceSlaveSegmentDoorOriginYRotation(frameOnTheBallRotation);
+            // heOnTheBall.isGotOnTheBall = false;
         }
     }
 }
+        // private void CreateRoomsStackDimka()
+        // {
+        //     _roomIndexesStack.Clear();
+        //     var remainingTime = _orderService.DeliveryTimer;
+        //     float ladderTimer = 0f;
+        //     int totalRooms = generatorConfig.roomAssetReferences.Length;
+        //     List<int> availableIndexes = new List<int>();
+        //     for (int i = 0; i < totalRooms; i++)
+        //         availableIndexes.Add(i);
+        //
+        //     int saveIndex = FindRoomIndexByType(RoomType.Save);
+        //     if (saveIndex != -1)
+        //     {
+        //         var prefab = _factory.GetCachedPrefab(saveIndex);
+        //         if (prefab != null)
+        //         {
+        //             Room saveRoom = prefab.GetComponent<Room>();
+        //             if (saveRoom != null)
+        //             {
+        //                 _roomIndexesStack.Add(saveIndex);
+        //                 availableIndexes.Remove(saveIndex);
+        //
+        //                 Debug.Log($"Первая комната: {saveRoom.name}");
+        //             }
+        //         }
+        //     }
+        //
+        //     while (remainingTime > 0 && availableIndexes.Count > 0)
+        //     {
+        //         int randomIndex = Random.Range(0, availableIndexes.Count);
+        //         int chosenOne = availableIndexes[randomIndex];
+        //
+        //         var prefab = _factory.GetCachedPrefab(chosenOne);
+        //         if (prefab == null)
+        //             continue;
+        //
+        //         Room room = prefab.GetComponent<Room>();
+        //         if (room == null)
+        //             continue;
+        //
+        //         switch (room.RoomType)
+        //         {
+        //             case RoomType.Save or RoomType.PickUp:
+        //                 availableIndexes.RemoveAt(randomIndex);
+        //                 continue;
+        //
+        //             case RoomType.Basic:
+        //                 float currentRoomTime = room.RoomTimer;
+        //                 if (remainingTime >= currentRoomTime && ladderTimer < 30f)
+        //                 {
+        //                     _roomIndexesStack.Add(chosenOne);
+        //                     remainingTime -= currentRoomTime;
+        //                     ladderTimer += currentRoomTime;
+        //                     Debug.Log($"комната {room.name} время {currentRoomTime} осталось: {remainingTime}");
+        //                 }
+        //
+        //                 availableIndexes.RemoveAt(randomIndex);
+        //                 break;
+        //
+        //             case RoomType.Ladder:
+        //                 if (ladderTimer >= 30f)
+        //                 {
+        //                     _roomIndexesStack.Add(chosenOne);
+        //                     ladderTimer = 0f;
+        //
+        //                     availableIndexes.RemoveAt(randomIndex);
+        //                     Debug.Log($"Лестница ура {room.name}");
+        //                 }
+        //
+        //                 break;
+        //
+        //             default:
+        //                 Debug.Log($"тип комнаты {room.RoomType}");
+        //                 availableIndexes.RemoveAt(randomIndex);
+        //                 break;
+        //         }
+        //     }
+        //
+        //     AddPickupRoom();
+        //     Debug.Log($"стек комнат: {_roomIndexesStack.Count}");
+        // }

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

@@ -1,52 +1,73 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
 using Code.Configs;
+using Code.Gameplay.Orders.Order;
 using Cysharp.Threading.Tasks;
+using Reflex.Extensions;
+using Reflex.Injectors;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
+using UnityEngine.ResourceManagement.AsyncOperations;
+using UnityEngine.SceneManagement;
+using Object = System.Object;
+using Random = UnityEngine.Random;
 
 namespace Code.Generator
 {
     public class RoomGeneratorFactory : IRoomGeneratorFactory
     {
+        private AsyncOperationHandle<IList<GameObject>> _roomsHandle;
         private readonly AssetReference[] _roomAssetReferences;
-        private readonly GameObject[] _cashedRooms;
-        private bool _isInitialized;
+        private Dictionary<RoomType, List<GameObject>> _cashedRooms = new();  
 
         public RoomGeneratorFactory(GeneratorConfig generatorConfig)
         {
             _roomAssetReferences = generatorConfig.roomAssetReferences;
-            _cashedRooms = new GameObject[_roomAssetReferences.Length];
+            // _cashedRooms = new GameObject[_roomAssetReferences.Length];
+            _cashedRooms.Add(RoomType.Basic, new());
+            _cashedRooms.Add(RoomType.Save, new ());
+            _cashedRooms.Add(RoomType.PickUp, new ());
+            _cashedRooms.Add(RoomType.Initial, new ());
         }
 
-        public async UniTask PreloadRooms()
-        {
-            if (_isInitialized)
-                return;
-
-            for (int i = 0; i < _roomAssetReferences.Length; i++)
-            {
-                var reference = _roomAssetReferences[i];
-                var prefab = await reference.LoadAssetAsync<GameObject>().ToUniTask();
-                _cashedRooms[i] = prefab;
-            }
-
-            _isInitialized = true;
-            Debug.Log($"комнат в памяти есть: {_cashedRooms.Length}");
+        public async UniTask PreloadRooms(IOrderService orderService)
+        {  
+            _roomsHandle =
+                Addressables.LoadAssetsAsync<GameObject>(_roomAssetReferences, OnRoomLoaded, Addressables.MergeMode.Union);
+            await _roomsHandle.ToUniTask();
+            // _cashedRooms = rooms.ToArray(); var rooms = 
+             
+            // Debug.Log($"Комнат в памяти есть: {_cashedRooms.Length}");
         }
 
-        public GameObject GetCachedPrefab(int index)
+        private void OnRoomLoaded(GameObject room)
         {
-            if (index < 0 || index >= _cashedRooms.Length)
+            var temp = room.GetComponent<Room>();
+            _cashedRooms[temp.RoomType].Add(room);
+        } 
+        public GameObject GetCachedPrefab(int index, RoomType roomType)
+        {
+            if (index < 0 || index >= _cashedRooms[roomType].Count)
                 return null;
-            return _cashedRooms[index];
+            return _cashedRooms[roomType][index];
+        }
+        public GameObject GetRandomCachedPrefabOfType(RoomType roomType, out int index)
+        {
+            index = Random.Range(0, _cashedRooms[roomType].Count);
+            return _cashedRooms[roomType][index];
         }
 
-        public async UniTask<Room> CreateRoomByIndex(int index)
+        public Room CreateRoomByIndex(int index, RoomType roomType)
+        { 
+            var room = UnityEngine.Object.Instantiate(_cashedRooms[roomType][index]);
+            return room.GetComponent<Room>();
+        } 
+        public void ReleaseRooms()
         {
-            if (!_isInitialized)
-                await PreloadRooms();
-            
-            Room room = Object.Instantiate(_cashedRooms[index]).GetComponent<Room>();
-            return room;
+            _roomsHandle.Release();
         }
     }
 }

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

@@ -0,0 +1,32 @@
+using System;
+using Code.Gameplay.Orders.Order;
+using Reflex.Attributes;
+using UnityEngine;
+
+namespace Code.Generator
+{
+    public class RoomTrigger : MonoBehaviour
+    {
+        [Inject] private IOrderService _orderService;
+
+        public static event Action PlayerEnteredRoom;
+
+        private bool _playerEntered;
+
+        // [Inject]
+        // private void Construct(IOrderService orderService)
+        // {
+        //     _orderService = orderService;
+        // }
+        private void OnTriggerEnter(Collider other)
+        {
+            if (_playerEntered) return;
+
+            _playerEntered = true;
+
+            _orderService.RoomPassed();
+
+            PlayerEnteredRoom?.Invoke();
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4207b7568dc3482393ac1860a31909b4
+timeCreated: 1764087485

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

@@ -3,8 +3,8 @@ namespace Code.Generator
     public enum RoomType
     {
         Basic,
-        Ladder,
         Save,
-        PickUp
+        PickUp,
+        Initial
     }
 }

Game/CourierOld/Assets/Code/LightMapping.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e76fbbe72ad97cc4f9dfe770ddc79857
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Game/CourierOld/Assets/Code/LightMapping/LightProbeRuntime.cs

@@ -0,0 +1,54 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+public class LightProbeRuntime : MonoBehaviour
+{
+    public Color m_Ambient;
+    Light[] m_Lights;
+
+    // Start is called before the first frame update
+    IEnumerator Start()
+    {
+        yield return null;
+
+        m_Lights = FindObjectsOfType<Light>();
+        SphericalHarmonicsL2[] bakedProbes = LightmapSettings.lightProbes.bakedProbes;
+        Vector3[] probePositions = LightmapSettings.lightProbes.positions;
+        int probeCount = LightmapSettings.lightProbes.count;
+
+        // Clear all probes
+        for (int i = 0; i < probeCount; i++)
+            bakedProbes[i].Clear();
+
+        // Add ambient light to all probes
+        for (int i = 0; i < probeCount; i++)
+            bakedProbes[i].AddAmbientLight(m_Ambient);
+
+        // Add directional and point lights' contribution to all probes
+        foreach (Light l in m_Lights)
+        {
+            if (l.type == LightType.Directional)
+            {
+                for (int i = 0; i < probeCount; i++)
+                    bakedProbes[i].AddDirectionalLight(-l.transform.forward, l.color, l.intensity);
+            }
+            else if (l.type == LightType.Point)
+            {
+                for (int i = 0; i < probeCount; i++)
+                    SHAddPointLight(probePositions[i], l.transform.position, l.range, l.color, l.intensity, ref bakedProbes[i]);
+            }
+        }
+        LightmapSettings.lightProbes.bakedProbes = bakedProbes;
+    }
+
+    void SHAddPointLight(Vector3 probePosition, Vector3 position, float range, Color color, float intensity, ref SphericalHarmonicsL2 sh)
+    {
+        // From the point of view of an SH probe, point light looks no different than a directional light,
+        // just attenuated and coming from the right direction.
+        Vector3 probeToLight = position - probePosition;
+        float attenuation = 1.0F / (1.0F + 25.0F * probeToLight.sqrMagnitude / (range * range));
+        sh.AddDirectionalLight(probeToLight.normalized, color, intensity * attenuation);
+    }
+}

Game/CourierOld/Assets/Code/LightMapping/LightProbeRuntime.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9643888b3364f55439c6adf3309cc447

Game/CourierOld/Assets/Code/LightMapping/PrefabLightmapData.cs

@@ -0,0 +1,295 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.SceneManagement;
+
+[ExecuteAlways]
+public class PrefabLightmapData : MonoBehaviour
+{
+    [Tooltip("Reassigns shaders when applying the baked lightmaps. Might conflict with some shaders like transparent HDRP.")]
+    public bool releaseShaders = true;
+    
+    [System.Serializable]
+    struct RendererInfo
+    {
+        public Renderer renderer;
+        public int lightmapIndex;
+        public Vector4 lightmapOffsetScale;
+    }
+    [System.Serializable]
+    struct LightInfo
+    {
+        public Light light;
+        public int lightmapBaketype;
+        public int mixedLightingMode;
+    }
+
+    [SerializeField]
+    RendererInfo[] m_RendererInfo;
+    [SerializeField]
+    Texture2D[] m_Lightmaps;
+    [SerializeField]
+    Texture2D[] m_LightmapsDir;
+    [SerializeField]
+    Texture2D[] m_ShadowMasks;
+    [SerializeField]
+    LightInfo[] m_LightInfo;
+
+
+    void Awake()
+    {
+        Init();
+    }
+
+    void Init()
+    {
+        if (m_RendererInfo == null || m_RendererInfo.Length == 0)
+            return;
+
+        var lightmaps = LightmapSettings.lightmaps;
+        int[] offsetsindexes = new int[m_Lightmaps.Length];
+        int counttotal = lightmaps.Length;
+        List<LightmapData> combinedLightmaps = new List<LightmapData>();
+
+        for (int i = 0; i < m_Lightmaps.Length; i++)
+        {
+            bool exists = false;
+            for (int j = 0; j < lightmaps.Length; j++)
+            {
+
+                if (m_Lightmaps[i] == lightmaps[j].lightmapColor)
+                {
+                    exists = true;
+                    offsetsindexes[i] = j;
+
+                }
+
+            }
+            if (!exists)
+            {
+                offsetsindexes[i] = counttotal;
+                var newlightmapdata = new LightmapData
+                {
+                    lightmapColor = m_Lightmaps[i],
+                    lightmapDir = m_LightmapsDir.Length == m_Lightmaps.Length ? m_LightmapsDir[i] : default(Texture2D),
+                    shadowMask = m_ShadowMasks.Length == m_Lightmaps.Length  ? m_ShadowMasks[i] : default(Texture2D),
+                };
+
+                combinedLightmaps.Add(newlightmapdata);
+
+                counttotal += 1;
+
+
+            }
+
+        }
+
+        var combinedLightmaps2 = new LightmapData[counttotal];
+
+        lightmaps.CopyTo(combinedLightmaps2, 0);
+        combinedLightmaps.ToArray().CopyTo(combinedLightmaps2, lightmaps.Length);
+
+        bool directional=true;
+
+        foreach(Texture2D t in m_LightmapsDir)
+        {
+            if (t == null)
+            {
+                directional = false;
+                break;
+            }
+        }
+
+        LightmapSettings.lightmapsMode = (m_LightmapsDir.Length == m_Lightmaps.Length && directional) ? LightmapsMode.CombinedDirectional : LightmapsMode.NonDirectional;
+        ApplyRendererInfo(m_RendererInfo, offsetsindexes, m_LightInfo);
+        LightmapSettings.lightmaps = combinedLightmaps2;
+    }
+
+    void OnEnable()
+    {
+
+        SceneManager.sceneLoaded += OnSceneLoaded;
+
+    }
+
+    // called second
+    void OnSceneLoaded(Scene scene, LoadSceneMode mode)
+    {
+        Init();
+    }
+
+    // called when the game is terminated
+    void OnDisable()
+    {
+        SceneManager.sceneLoaded -= OnSceneLoaded;
+    }
+
+
+
+    void ApplyRendererInfo(RendererInfo[] infos, int[] lightmapOffsetIndex, LightInfo[] lightsInfo)
+    {
+        for (int i = 0; i < infos.Length; i++)
+        {
+            var info = infos[i];
+
+            info.renderer.lightmapIndex = lightmapOffsetIndex[info.lightmapIndex];
+            info.renderer.lightmapScaleOffset = info.lightmapOffsetScale;
+
+            if (releaseShaders)
+            {
+                // You have to release shaders.
+                Material[] mat = info.renderer.sharedMaterials;
+                for (int j = 0; j < mat.Length; j++)
+                {
+                    if (mat[j] != null && Shader.Find(mat[j].shader.name) != null)
+                    {
+                        mat[j].shader = Shader.Find(mat[j].shader.name);
+                    }
+                    
+                }
+            }
+
+        }
+
+        for (int i = 0; i < lightsInfo.Length; i++)
+        {
+            LightBakingOutput bakingOutput = new LightBakingOutput();
+            bakingOutput.isBaked = true;
+            bakingOutput.lightmapBakeType = (LightmapBakeType)lightsInfo[i].lightmapBaketype;
+            bakingOutput.mixedLightingMode = (MixedLightingMode)lightsInfo[i].mixedLightingMode;
+
+            lightsInfo[i].light.bakingOutput = bakingOutput;
+
+        }
+
+
+    }
+
+#if UNITY_EDITOR
+    [UnityEditor.MenuItem("Assets/Bake Prefab Lightmaps")]
+    static void GenerateLightmapInfo()
+    {
+        if (UnityEditor.Lightmapping.giWorkflowMode != UnityEditor.Lightmapping.GIWorkflowMode.OnDemand)
+        {
+            Debug.LogError("ExtractLightmapData requires that you have baked you lightmaps and Auto mode is disabled.");
+            return;
+        }
+        UnityEditor.Lightmapping.Bake();
+
+        PrefabLightmapData[] prefabs = FindObjectsOfType<PrefabLightmapData>();
+
+        foreach (var instance in prefabs)
+        {
+            var gameObject = instance.gameObject;
+            var rendererInfos = new List<RendererInfo>();
+            var lightmaps = new List<Texture2D>();
+            var lightmapsDir = new List<Texture2D>();
+            var shadowMasks = new List<Texture2D>();
+            var lightsInfos = new List<LightInfo>();
+
+            GenerateLightmapInfo(gameObject, rendererInfos, lightmaps, lightmapsDir, shadowMasks, lightsInfos);
+
+            instance.m_RendererInfo = rendererInfos.ToArray();
+            instance.m_Lightmaps = lightmaps.ToArray();
+            instance.m_LightmapsDir = lightmapsDir.ToArray();
+            instance.m_LightInfo = lightsInfos.ToArray();
+            instance.m_ShadowMasks = shadowMasks.ToArray();
+#if UNITY_2018_3_OR_NEWER
+            var targetPrefab = PrefabUtility.GetCorrespondingObjectFromOriginalSource(instance.gameObject) as GameObject;
+            if (targetPrefab != null)
+            {
+                GameObject root = PrefabUtility.GetOutermostPrefabInstanceRoot(instance.gameObject);// 根结点
+                //如果当前预制体是是某个嵌套预制体的一部分（IsPartOfPrefabInstance）
+                if (root != null)
+                {
+                    GameObject rootPrefab = PrefabUtility.GetCorrespondingObjectFromSource(instance.gameObject);
+                    string rootPath = AssetDatabase.GetAssetPath(rootPrefab);
+                    //打开根部预制体
+                    PrefabUtility.UnpackPrefabInstanceAndReturnNewOutermostRoots(root, PrefabUnpackMode.OutermostRoot);
+                    try
+                    {
+                        //Apply各个子预制体的改变
+                        PrefabUtility.ApplyPrefabInstance(instance.gameObject, InteractionMode.AutomatedAction);
+                    }
+                    catch { }
+                    finally
+                    {
+                        //重新更新根预制体
+                        PrefabUtility.SaveAsPrefabAssetAndConnect(root, rootPath, InteractionMode.AutomatedAction);
+                    }
+                }
+                else
+                {
+                    PrefabUtility.ApplyPrefabInstance(instance.gameObject, InteractionMode.AutomatedAction);
+                }
+            }
+#else
+            var targetPrefab = UnityEditor.PrefabUtility.GetPrefabParent(gameObject) as GameObject;
+            if (targetPrefab != null)
+            {
+                //UnityEditor.Prefab
+                UnityEditor.PrefabUtility.ReplacePrefab(gameObject, targetPrefab);
+            }
+#endif
+        }
+
+
+    }
+
+    static void GenerateLightmapInfo(GameObject root, List<RendererInfo> rendererInfos, List<Texture2D> lightmaps, List<Texture2D> lightmapsDir, List<Texture2D> shadowMasks, List<LightInfo> lightsInfo)
+    {
+        var renderers = root.GetComponentsInChildren<MeshRenderer>();
+        foreach (MeshRenderer renderer in renderers)
+        {
+            if (renderer.lightmapIndex != -1)
+            {
+                RendererInfo info = new RendererInfo();
+                info.renderer = renderer;
+
+                if (renderer.lightmapScaleOffset != Vector4.zero)
+                {
+                    //1ibrium's pointed out this issue : https://docs.unity3d.com/ScriptReference/Renderer-lightmapIndex.html
+                    if(renderer.lightmapIndex < 0 || renderer.lightmapIndex == 0xFFFE) continue;
+                    info.lightmapOffsetScale = renderer.lightmapScaleOffset;
+
+                    Texture2D lightmap = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapColor;
+                    Texture2D lightmapDir = LightmapSettings.lightmaps[renderer.lightmapIndex].lightmapDir;
+                    Texture2D shadowMask = LightmapSettings.lightmaps[renderer.lightmapIndex].shadowMask;
+
+                    info.lightmapIndex = lightmaps.IndexOf(lightmap);
+                    if (info.lightmapIndex == -1)
+                    {
+                        info.lightmapIndex = lightmaps.Count;
+                        lightmaps.Add(lightmap);
+                        lightmapsDir.Add(lightmapDir);
+                        shadowMasks.Add(shadowMask);
+                    }
+
+                    rendererInfos.Add(info);
+                }
+
+            }
+        }
+
+        var lights = root.GetComponentsInChildren<Light>(true);
+
+        foreach (Light l in lights)
+        {
+            LightInfo lightInfo = new LightInfo();
+            lightInfo.light = l;
+            lightInfo.lightmapBaketype = (int)l.lightmapBakeType;
+#if UNITY_2020_1_OR_NEWER
+            lightInfo.mixedLightingMode = (int)UnityEditor.Lightmapping.lightingSettings.mixedBakeMode;            
+#elif UNITY_2018_1_OR_NEWER
+            lightInfo.mixedLightingMode = (int)UnityEditor.LightmapEditorSettings.mixedBakeMode;
+#else
+            lightInfo.mixedLightingMode = (int)l.bakingOutput.lightmapBakeType;            
+#endif
+            lightsInfo.Add(lightInfo);
+
+        }
+    }
+#endif
+
+}

Game/CourierOld/Assets/Code/LightMapping/PrefabLightmapData.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b91f32cd81021d24ab9ff545997e9666

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

@@ -7,15 +7,11 @@ namespace Code.Scenes.SceneEnvironments
     [System.Serializable]
     public class GameplaySceneEnvironment : CurrentSceneEnvironment
     {
-        [FormerlySerializedAs("sfxTarget")] public Transform debugSfxTarget;
-        public Transform playerSpawnPoint;
-        public OrderDispenser debugTube;
+        public Transform playerSpawnPoint; 
 
         public void TransitVariables(GameplaySceneEnvironment env)
         {
-            debugSfxTarget = env.debugSfxTarget;
-            playerSpawnPoint = env.playerSpawnPoint;
-            debugTube = env.debugTube;
+            playerSpawnPoint = env.playerSpawnPoint; 
         }
     }
 }

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

@@ -1,4 +1,5 @@
 using Code.Gameplay.Door;
+using Code.UI;
 using Code.UI.Panels.Etc;
 using UnityEngine;
 using UnityEngine.Experimental.GlobalIllumination;
@@ -15,6 +16,7 @@ namespace Code.Scenes.SceneEnvironments
         public MainMenuButton settingButton;
         public MainMenuButton exitButton;
         public Canvas menuButtonsCanvas;
+        public Canvas settingsCanvas;
 
         public void TransitVariables(MainMenuEnvironment env)
         {
@@ -24,6 +26,7 @@ namespace Code.Scenes.SceneEnvironments
             settingButton = env.settingButton;
             exitButton = env.exitButton;
             menuButtonsCanvas = env.menuButtonsCanvas;
+            settingsCanvas = env.settingsCanvas;
         }
     }
 }

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

@@ -4,6 +4,7 @@ using System.Threading.Tasks;
 using Code.Audio;
 using Code.Configs;
 using Code.Gameplay.Camera;
+using Code.Generator;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
@@ -23,10 +24,15 @@ namespace Code.StaticData
         SFXListConfig SFXListConfig { get; }
         DispatcherSoundListConfig DispatcherSoundListConfig { get; }
         EnemiesSoundListConfig EnemiesSoundListConfig { get; }
+        DrunkenGrandpaConfig DrunkenGrandpaConfig { get; }
+        CockroachConfig CockroachConfig { get; }
+        FogConfig FogConfig { get; }
         OrderServiceConfig OrderServiceConfig { get; }
         OrderBoxConfig OrderBoxConfig { get; }
         Dictionary<CameraMode, CameraSettingsConfig> CameraSettingsConfigs { get; }
         Dictionary<AudioSourceType, AudioSourceSettingsConfig> AudioSourceSettingsConfigs { get; }
+        AudioTestClipsConfig AudioTestClipsConfig { get; }
+        GeneratorConfig GeneratorConfig { get; }
         void Load();
         Task<T> InstantiateAsset<T>(AssetReference assetReference) where T : Behaviour;
     }

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

@@ -5,6 +5,7 @@ using Code.Audio;
 using Code.Configs;
 using Code.Constants;
 using Code.Gameplay.Camera;
+using Code.Generator;
 using Cysharp.Threading.Tasks;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
@@ -16,16 +17,27 @@ namespace Code.StaticData
         public AppConfig AppConfig { get; private set; }
         public InputConfig InputConfig { get; private set; }
         public CameraConfig CameraConfig { get; private set; }
+        
         public CharacterConfig CharacterConfig { get; private set; }
-        public UIConfig UIConfig { get; private set; }
         public PlayerConfig PlayerConfig { get; private set; }
+        
+        public UIConfig UIConfig { get; private set; }
+        
         public AudioMixerConfig AudioMixerConfig { get; private set; }
         public SoundtrackListConfig SoundtrackListConfig { get; private set; }
         public SFXListConfig SFXListConfig { get; private set; }
         public DispatcherSoundListConfig DispatcherSoundListConfig { get; private set; }
         public EnemiesSoundListConfig EnemiesSoundListConfig { get; private set; }
+        public AudioTestClipsConfig AudioTestClipsConfig { get; private set; }
+        
+        public DrunkenGrandpaConfig DrunkenGrandpaConfig {get; private set;}
+        public CockroachConfig CockroachConfig { get; private set; }
+        public FogConfig FogConfig { get; private set; }
+        
         public OrderServiceConfig OrderServiceConfig { get; private set; }
         public OrderBoxConfig OrderBoxConfig { get; private set; }
+        
+        public GeneratorConfig GeneratorConfig { get; private set; }
 
         public Dictionary<CameraMode, CameraSettingsConfig> CameraSettingsConfigs { get; private set; } = new();
 
@@ -40,6 +52,7 @@ namespace Code.StaticData
             PlayerConfig = Resources.Load<PlayerConfig>(string.Format(StringPaths.ConfigSingle, "App", "PlayerConfig"));
             OrderServiceConfig = Resources.Load<OrderServiceConfig>(string.Format(StringPaths.ConfigSingle, "Gameplay", "OrderServiceConfig"));
             OrderBoxConfig = Resources.Load<OrderBoxConfig>(string.Format(StringPaths.ConfigSingle, "Gameplay", "OrderBoxConfig"));
+            GeneratorConfig = Resources.Load<GeneratorConfig>(string.Format(StringPaths.ConfigSingle, "App", "GeneratorConfig"));
 
             CameraConfig = Resources.Load<CameraConfig>(string.Format(StringPaths.ConfigSingle, "Camera", "CameraConfig"));
             CameraSettingsConfigs = Resources
@@ -47,12 +60,14 @@ namespace Code.StaticData
                 .ToDictionary(x => x.cameraMode);
 
             LoadAudioConfigs();
+            LoadEnemiesConfigs();
         }
 
         private void LoadAudioConfigs()
         {
             AudioMixerConfig = Resources.Load<AudioMixerConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "AudioMixerConfig"));
             SoundtrackListConfig = Resources.Load<SoundtrackListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "SoundtrackListConfig"));
+            AudioTestClipsConfig = Resources.Load<AudioTestClipsConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "AudioTestClipsConfig"));
             SFXListConfig = Resources.Load<SFXListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "SFXListConfig"));
             DispatcherSoundListConfig = Resources.Load<DispatcherSoundListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "DispatcherSoundListConfig"));
             EnemiesSoundListConfig = Resources.Load<EnemiesSoundListConfig>(string.Format(StringPaths.ConfigSingle, "Audio", "EnemiesSoundListConfig"));
@@ -61,6 +76,13 @@ namespace Code.StaticData
                 .ToDictionary(x => x.sourceType);
         }
 
+        private void LoadEnemiesConfigs()
+        {
+            DrunkenGrandpaConfig = Resources.Load<DrunkenGrandpaConfig>(string.Format(StringPaths.ConfigSingle, "Enemies", "DrunkenGrandpaConfig"));
+            CockroachConfig = Resources.Load<CockroachConfig>(string.Format(StringPaths.ConfigSingle, "Enemies", "CockroachConfig"));
+            FogConfig = Resources.Load<FogConfig>(string.Format(StringPaths.ConfigSingle, "Enemies", "FogConfig"));
+        }
+
         public async Task<T> InstantiateAsset<T>(AssetReference assetReference) where T : Behaviour
         {
             return (await Addressables.InstantiateAsync(assetReference).ToUniTask()).GetComponent<T>();

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

@@ -1,3 +1,4 @@
+using Code.Audio;
 using Code.Gameplay.Door;
 using Code.UI.Panels.Etc;
 
@@ -36,7 +37,7 @@ namespace Code.UI.Panels
             settingButton.OnPointerExitEvent = CloseDoor;
             exitButton.OnPointerExitEvent = CloseDoor;
 
-            _cinematicDoorOpening = new(mainMenuUIVariables.MainMenuDoor, mainMenuUIVariables.DoorLight);
+            _cinematicDoorOpening = new(mainMenuUIVariables.MainMenuDoor, mainMenuUIVariables.DoorLight); 
         }
  
         private void OpenStart() => _cinematicDoorOpening.PreOpen(0);
@@ -45,6 +46,6 @@ namespace Code.UI.Panels
 
         private void OpenExit() => _cinematicDoorOpening.PreOpen(2);
 
-        private void CloseDoor() => _cinematicDoorOpening.Close();
+        private void CloseDoor() => _cinematicDoorOpening.Close(); 
     }
 }

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

@@ -1,29 +1,83 @@
+using System;
+using Code.Audio;
+using Reflex.Attributes;
 using TMPro;
 using UnityEngine;
+using UnityEngine.Serialization;
 using UnityEngine.UI;
+using AudioType = Code.Audio.AudioType;
 
 namespace Code.UI
 {
     public class SettingsPanel : UIElement
     {
-        [SerializeField] private TMP_Text scoreText;
-        [SerializeField] private TMP_Text gameOverText;
-        [SerializeField] private Image _background;
-        
-        public void UpdateScoreText(int score) => scoreText.text = score.ToString();
+        [SerializeField] private Slider master;
+        [SerializeField] private Slider sfx;
+        [SerializeField] private Slider dispatcher;
+        [SerializeField] private Slider creatures;
+        [SerializeField] private Slider menuMusic;
+        [SerializeField] private Slider gameplayMusic; 
         
+        [Inject] IAudioService _audioService;
+
+        private void Start()
+        { 
+            master.SetValueWithoutNotify(_audioService.GetSetting(AudioType.Master));
+            master.onValueChanged.AddListener(OnMasterUpdate);
+            
+            sfx.value = _audioService.GetSetting(AudioType.SFX);
+            sfx.onValueChanged.AddListener(OnSFXUpdate);
+            
+            dispatcher.value = _audioService.GetSetting(AudioType.DispatcherSounds);
+            dispatcher.onValueChanged.AddListener(OnDispatcherUpdate);
+            
+            creatures.value = _audioService.GetSetting(AudioType.Creatures);
+            creatures.onValueChanged.AddListener(OnEnemiesUpdate);
+            
+            menuMusic.value = _audioService.GetSetting(AudioType.MenuMusic);
+            menuMusic.onValueChanged.AddListener(OnMenuMusicUpdate);
+            
+            gameplayMusic.value = _audioService.GetSetting(AudioType.GameplayMusic);
+            gameplayMusic.onValueChanged.AddListener(OnGameplayUpdate); 
+        }
+
+        private void OnMasterUpdate(float value)
+        {
+            _audioService.ChangeSetting(AudioType.Master, value);            
+            // _audioService.PlayTestClip(AudioType.Master); XDXDXDXD TODO Убрать или придумать что-нибудь
+        }
+        private void OnSFXUpdate(float value)
+        {
+            _audioService.ChangeSetting(AudioType.SFX, value);
+            _audioService.PlayTestClip(AudioType.SFX);
+        } 
+        private void OnDispatcherUpdate(float value)
+        {
+            _audioService.ChangeSetting(AudioType.DispatcherSounds, value);
+            _audioService.PlayTestClip(AudioType.DispatcherSounds);
+        } 
+        private void OnEnemiesUpdate(float value)
+        {
+            _audioService.ChangeSetting(AudioType.Creatures, value);
+            _audioService.PlayTestClip(AudioType.Creatures);
+        } 
+        private void OnMenuMusicUpdate(float value)
+        {
+            _audioService.ChangeSetting(AudioType.MenuMusic, value);
+            _audioService.PlayTestClip(AudioType.MenuMusic);
+        } 
+        private void OnGameplayUpdate(float value)
+        {
+            _audioService.ChangeSetting(AudioType.GameplayMusic, value);
+            _audioService.PlayTestClip(AudioType.GameplayMusic);
+        }
+
         public override void Hide()
         {
-            _background.enabled = false;
-            scoreText.enabled = false;
-            gameOverText.enabled = false;
             base.Hide();
         }
         public override void Show()
         {
-            _background.enabled = true;
-            scoreText.enabled = true;
-            gameOverText.enabled = true;
             base.Show();
         }
     }

Game/CourierOld/Assets/Resources/Audio/MainMixer.mixer

@@ -133,7 +133,6 @@ AudioMixerGroupController:
   m_Children:
   - {fileID: -6229038418282119915}
   - {fileID: 4051589110822387517}
-  - {fileID: 2578226848385654679}
   m_Volume: 5e2f5c7e3d526b9aaa68f56dfb7d553b
   m_Pitch: ae94fcb7df36f4368a5d909499b1cf45
   m_Send: 00000000000000000000000000000000
@@ -175,7 +174,21 @@ AudioMixerController:
   m_SuspendThreshold: -80
   m_EnableSuspend: 1
   m_UpdateMode: 0
-  m_ExposedParameters: []
+  m_ExposedParameters:
+  - guid: ddab7e07de3c686e296ff10b1cd77a47
+    name: Action
+  - guid: 5e2f5c7e3d526b9aaa68f56dfb7d553b
+    name: Creatures
+  - guid: 19969023eed85c7999691c4897eebc2e
+    name: Dispatcher
+  - guid: 9823d3a409fe914cdbb45f92705c5186
+    name: Master
+  - guid: b9fc0df121fe7134e9cbd35aa5a65755
+    name: Menu
+  - guid: dd0b3fe80d006124baa36e791e6953f0
+    name: Peaceful
+  - guid: 8b55cf81ebbf71b7db1aeb9d32d1f6a1
+    name: SFX
   m_AudioMixerGroupViews:
   - guids:
     - ddc760a902e7b5553952924aeaa5473e
@@ -190,7 +203,7 @@ AudioMixerController:
     - af6d3dead2e9e4848a2ca2fa55634108
     name: View
   m_CurrentViewIndex: 0
-  m_TargetSnapshot: {fileID: -1214924791136564940}
+  m_TargetSnapshot: {fileID: -5566153147845745614}
 --- !u!243 &24300002
 AudioMixerGroupController:
   m_ObjectHideFlags: 0
@@ -201,6 +214,7 @@ AudioMixerGroupController:
   m_AudioMixer: {fileID: 24100000}
   m_GroupID: ddc760a902e7b5553952924aeaa5473e
   m_Children:
+  - {fileID: 2578226848385654679}
   - {fileID: -2580822303892902013}
   - {fileID: -6672183372375525094}
   - {fileID: -4235790927912365957}

Game/CourierOld/Assets/Resources/Configs/App/GeneratorConfig.asset

@@ -13,18 +13,48 @@ MonoBehaviour:
   m_Name: GeneratorConfig
   m_EditorClassIdentifier: Assembly-CSharp::Code.Generator.GeneratorConfig
   roomAssetReferences:
-  - m_AssetGUID: 4472dd84628855c4085cacaec19efa29
+  - m_AssetGUID: d4eaf1439c2788c458127b9ba67e4fbf
     m_SubObjectName: 
     m_SubObjectType: 
     m_SubObjectGUID: 
     m_EditorAssetChanged: 0
-  - m_AssetGUID: 3d195945b1fbf114a88457cba466bc2b
+  - m_AssetGUID: b3471d165fe389f479380f61034bea57
     m_SubObjectName: 
     m_SubObjectType: 
     m_SubObjectGUID: 
     m_EditorAssetChanged: 0
-  - m_AssetGUID: 4f660559d76c3ed42a7c34a0b16487f7
+  - m_AssetGUID: 28a6c7a4124141341ab7c2b7dfd3e95b
     m_SubObjectName: 
     m_SubObjectType: 
     m_SubObjectGUID: 
     m_EditorAssetChanged: 1
+  - m_AssetGUID: e3a3840a7963bf841872cddb02e90151
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: c938de3174f184741925c407a43a47f2
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: 9d78f017876abed4c9cd8957f1e140cb
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: dc328d8aadb0e8545978741d451e0544
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: 19bfe93240786974ea9d7cd70a7bb635
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: a1d9e5a04ac11a1468c744b27d442a00
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0

Game/CourierOld/Assets/Resources/Configs/Audio/AudioTestClipsConfig.asset

@@ -0,0 +1,45 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f2f1c08a20a54a708336caf8ca6499e1, type: 3}
+  m_Name: AudioTestClipsConfig
+  m_EditorClassIdentifier: Assembly-CSharp::Code.Configs.AudioTestClipsConfig
+  audioTestClips:
+  - m_AssetGUID: 803e40b883c823b89a91aa8b9d9fc483
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: 1d7110a045075b22fa27d62bd5f2784e
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: 2f6134357dc2a5641a846a7478ce4c2c
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: 82c71411174bfa86ca1f676b9d389f94
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: 8fa89a492fc3a3768a0f0ba1bb7080e0
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  - m_AssetGUID: 3831a36e0c8e48f659517a6bb99378b6
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 1

Game/CourierOld/Assets/Resources/Configs/Audio/AudioTestClipsConfig.asset.meta

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

Game/CourierOld/Assets/Resources/Configs/Enemies.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9dec9aa8ce6e1be92b7f1daeffd7a9b6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Game/CourierOld/Assets/Resources/Configs/Enemies/CockroachConfig.asset

@@ -0,0 +1,33 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7bc162d3127949aa950d0738beee99a4, type: 3}
+  m_Name: CockroachConfig
+  m_EditorClassIdentifier: Assembly-CSharp::Code.Configs.CockroachConfig
+  cockroachPrefab:
+    m_AssetGUID: 2ed2d93a9f39d4edba511cb7396c7bb6
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  damage: 2
+  attackCooldown: 1.5
+  detectionRange: 20
+  attackRange: 1.3
+  speed: 6
+  isStunnable: 0
+  stunDuration: 0
+  usesIdleMovement: 1
+  idleWanderRadius: 3
+  idleMoveDurationMin: 0.3
+  idleMoveDurationMax: 1
+  idlePauseDurationMin: 0.1
+  idlePauseDurationMax: 0.8

Game/CourierOld/Assets/Resources/Configs/Enemies/CockroachConfig.asset.meta

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

Game/CourierOld/Assets/Resources/Configs/Enemies/DrunkenGrandpaConfig.asset

@@ -0,0 +1,33 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4d157e8891074b90957a7434cff0ae71, type: 3}
+  m_Name: DrunkenGrandpaConfig
+  m_EditorClassIdentifier: Assembly-CSharp::Code.Configs.DrunkenGrandpaConfig
+  drunkenGrandpaPrefab:
+    m_AssetGUID: b33855c694de89386a25c56cbe463a0e
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  damage: 2
+  attackCooldown: 5
+  detectionRange: 10
+  attackRange: 1.5
+  speed: 3
+  isStunnable: 1
+  stunDuration: 3
+  usesIdleMovement: 1
+  idleWanderRadius: 5
+  idleMoveDurationMin: 1
+  idleMoveDurationMax: 5
+  idlePauseDurationMin: 3
+  idlePauseDurationMax: 5

Game/CourierOld/Assets/Resources/Configs/Enemies/DrunkenGrandpaConfig.asset.meta

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

Game/CourierOld/Assets/Resources/Configs/Enemies/FogConfig.asset

@@ -0,0 +1,33 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: aa4dd2a5cce24902a2918488b5751f2f, type: 3}
+  m_Name: FogConfig
+  m_EditorClassIdentifier: Assembly-CSharp::Code.Configs.FogConfig
+  fogPrefab:
+    m_AssetGUID: f3d7dc64b34919ad7b50a3dd307a935b
+    m_SubObjectName: 
+    m_SubObjectType: 
+    m_SubObjectGUID: 
+    m_EditorAssetChanged: 0
+  damage: 2147483647
+  attackCooldown: 0
+  detectionRange: 0
+  attackRange: 5
+  speed: 1.5
+  isStunnable: 0
+  stunDuration: 0
+  usesIdleMovement: 0
+  idleWanderRadius: 0
+  idleMoveDurationMin: 0
+  idleMoveDurationMax: 0
+  idlePauseDurationMin: 0
+  idlePauseDurationMax: 0

Game/CourierOld/Assets/Resources/Configs/Enemies/FogConfig.asset.meta

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

Game/CourierOld/Assets/Resources/Materials/Divan.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 40e715b58d5696244a3585eb3f716b98
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Game/CourierOld/Assets/Resources/Materials/Divan/DefaultMaterial_Base_color.png.meta

@@ -0,0 +1,117 @@
+fileFormatVersion: 2
+guid: 8b1b9552e07ead246b92a6675daca188
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Game/CourierOld/Assets/Resources/Materials/Divan/DefaultMaterial_Normal.png.meta

@@ -0,0 +1,117 @@
+fileFormatVersion: 2
+guid: 5aac8376096d51d47ba7c48613d58a3e
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 1
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Game/CourierOld/Assets/Resources/Materials/Divan/DefaultMaterial_Roughness.png.meta

@@ -0,0 +1,117 @@
+fileFormatVersion: 2
+guid: bbe77ae8c2639e0449ca8fb9055701fb
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Game/CourierOld/Assets/Resources/Materials/Divan/Divan.mat

@@ -0,0 +1,139 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Divan
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _METALLICSPECGLOSSMAP
+  - _NORMALMAP
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: 8b1b9552e07ead246b92a6675daca188, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 5aac8376096d51d47ba7c48613d58a3e, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 8b1b9552e07ead246b92a6675daca188, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 2800000, guid: bbe77ae8c2639e0449ca8fb9055701fb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.005
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _WorkflowMode: 1
+    - _XRMotionVectorsPass: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &6170637302517857720
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: Unity.RenderPipelines.Universal.Editor::UnityEditor.Rendering.Universal.AssetVersion
+  version: 10

Game/CourierOld/Assets/Resources/Materials/Divan/Divan.mat.meta

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