Merge branch 'Dev' into mobs-dev

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

@@ -1,41 +1,76 @@
-using Code.App.StateMachine;
-using Code.Scenes;
+using Code.App.StateMachine; 
+using Code.Gameplay.Player;
+using Code.Input;
 using Code.StateMachine;
 using Code.UI;
+using Cysharp.Threading.Tasks;
+using Reflex.Core;
+using Reflex.Extensions;
 using UnityEngine;
+using UnityEngine.InputSystem;
+using UnityEngine.SceneManagement;
 
 namespace Code.App.AppStates
 {
     public class GameOverState : BaseState<AppStateMachineContext>
     {
         public GameOverState(AppStateMachineContext context) : base(context)
-        { }
+        {
+        }
+        private IPlayerScore _playerScore;
+ 
+        private GameOverPanel _gameOverPanel;
 
-        private float damnTimer = 3f; // TODO Удалить при первой возможности
-        
         public override void EnterState()
         {
-            Context.UIService.SwitchPanelTo(UIPanel.GameOver);
+            Container sceneContainer = SceneManager.GetActiveScene().GetSceneContainer();
+            _playerScore = sceneContainer.Resolve<IPlayerScore>();
+            _scoreCounter = 0; 
+            
+            Context.InputService.EnableMap(ActionMappings.UI);
+            Context.InputService.DebugBindAction((int)ActionMappings.UI,(int)UIActions.Continue, TryToExit);
+            
+            GameOver();
             
             base.EnterState();
         }
-        
+
+        private void TryToExit(InputAction.CallbackContext context)
+        {
+            ToMainMenu();
+        }
+
+        private async UniTaskVoid GameOver()
+        {
+            await Context.UIService.AsyncSwitchPanelTo(UIPanel.GameOver);
+            
+            _gameOverPanel = (GameOverPanel)Context.UIService.CurrentPanel;
+            
+        }
+
         private void ToMainMenu()
         {
             Context.StateMachine.SwitchState(AppState.MainMenu)
                 .AllowStateTransition(AppState.Gameplay);
         }
-
+        private float _scoreCounter;
         public override void Tick()
         {
-            damnTimer -= Time.deltaTime;
-            if (damnTimer <= float.Epsilon) ToMainMenu();
+            if (!_gameOverPanel) return;
+            
+            _scoreCounter += Time.deltaTime * 100;
+            // UnityEngine.Debug.Log($"Score: {_scoreCounter}");
+            if((int)_scoreCounter >= _playerScore.Score)
+            {
+                _gameOverPanel.UpdateScoreText(_playerScore.Score);
+            }
+            else _gameOverPanel.UpdateScoreText((int)_scoreCounter);
         }
         public override void ExitState()
-        {
-            damnTimer = 5f;
+        { 
+            Context.InputService.DisableMap(ActionMappings.UI);
+            Context.InputService.DebugUnbindAction((int)ActionMappings.UI,(int)UIActions.Continue, TryToExit);
             
-            Context.UIService.LoadingScreen.Show();
             base.ExitState();
         }
     }

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

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

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

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

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

@@ -1,9 +1,12 @@
+using System.Collections.Generic;
+using Code.App.Loading;
 using Code.App.StateMachine;
 using Code.Audio;
 using Code.Configs;
 using Code.Constants;
 using Code.Gameplay.Camera;
 using Code.Gameplay.Enemies;
+using Code.Gameplay.Orders.Order;
 using Code.Gameplay.Player;
 using Code.Input;
 using Code.Scenes;
@@ -26,12 +29,15 @@ namespace Code.App
             
             InstallInfrastructureUnit(containerBuilder, staticDataService);
 
+            containerBuilder.AddSingleton(typeof(LoadingManager), typeof(ILoadingManager));
+            
             containerBuilder.AddSingleton(typeof(InputService), typeof(IInputService));
             containerBuilder.AddSingleton(typeof(PlayerFactory), typeof(IPlayerFactory));
             containerBuilder.AddSingleton(typeof(EnemyFactory), typeof(IEnemyFactory));
             containerBuilder.AddSingleton(typeof(PlayerProvider), typeof(IPlayerProvider));
 
             InitializeCamera(containerBuilder, staticDataService);
+            
             containerBuilder.AddSingleton(typeof(UIFactory), typeof(IUIFactory));
             containerBuilder.AddSingleton(typeof(UIService), typeof(IUIService));
             
@@ -74,6 +80,7 @@ namespace Code.App
             containerBuilder.AddSingleton(staticDataService.InputConfig, typeof(InputConfig));
             
             containerBuilder.AddSingleton(staticDataService.CameraConfig, typeof(CameraConfig));
+            containerBuilder.AddSingleton(staticDataService.CameraSettingsConfigs, typeof(Dictionary<CameraMode,CameraSettingsConfig>));
             
             containerBuilder.AddSingleton(staticDataService.PlayerConfig, typeof(PlayerConfig));
             containerBuilder.AddSingleton(staticDataService.CharacterConfig, typeof(CharacterConfig));
@@ -89,6 +96,10 @@ namespace Code.App
             containerBuilder.AddSingleton(staticDataService.SFXListConfig, typeof(SFXListConfig));
             containerBuilder.AddSingleton(staticDataService.DispatcherSoundListConfig, typeof(DispatcherSoundListConfig));
             containerBuilder.AddSingleton(staticDataService.EnemiesSoundListConfig, typeof(EnemiesSoundListConfig));
+            containerBuilder.AddSingleton(staticDataService.AudioSourceSettingsConfigs, typeof(Dictionary<AudioSourceType, AudioSourceSettingsConfig>));
+
+            containerBuilder.AddSingleton(staticDataService.OrderServiceConfig, typeof(OrderServiceConfig));
+            containerBuilder.AddSingleton(staticDataService.OrderBoxConfig, typeof(OrderBoxConfig)); 
         }
 
         private AppStateMachine _appStateMachine;
@@ -105,19 +116,26 @@ namespace Code.App
 
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
             BootstrapFinish(container);
-            
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
         }
         private async UniTaskVoid BootstrapFinish(Container container)
         {
-            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen);
-            DontDestroyOnLoad(loadingScreen);
+            var loadingScreen = GameObject.FindWithTag(Tags.LoadingScreen).GetComponent<LoadingScreen>();
+            DontDestroyOnLoad(loadingScreen.gameObject);
+
+            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
+            loadingManager.OnLoadingStarted += loadingScreen.Show;
+            loadingManager.OnLoadingEnded += loadingScreen.Hide;
+
+            loadingManager.RegisterLoading(LoadingWork.Bootstrap);
             
             await UniTask.WhenAll(
-                container.Resolve<IUIService>().Initialize(loadingScreen.GetComponent<LoadingScreen>()),
+                container.Resolve<IUIService>().Initialize(loadingScreen),
                 container.Resolve<IAudioService>().Initialize()
                 );
             
+            loadingManager.UnregisterLoading(LoadingWork.Bootstrap);
+            
             _appStateMachine
                 .SwitchState(AppState.MainMenu)
                 .AllowStateTransition(AppState.Gameplay);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,11 @@
+using Code.App.Loading;
+using Code.Gameplay.Orders.Order;
+using Code.Gameplay.Player;
 using Code.Scenes;
 using Code.Scenes.SceneEnvironments;
 using Reflex.Core;
 using UnityEngine;
+using IPlayerScore = Code.Gameplay.Player.IPlayerScore;
 
 namespace Code.App.SceneInstallers
 {
@@ -12,15 +16,22 @@ namespace Code.App.SceneInstallers
         public void InstallBindings(ContainerBuilder containerBuilder)
         {
             containerBuilder.AddScoped(typeof(GameplaySceneEnvironment), typeof(CurrentSceneEnvironment));
+            containerBuilder.AddScoped(typeof(PlayerScore), typeof(IPlayerScore));
+            containerBuilder.AddScoped(typeof(OrderService), typeof(IOrderService));
 
             containerBuilder.OnContainerBuilt += Initialize;
         }
 
         private void Initialize(Container container)
         {
-            GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
+            ILoadingManager loadingManager = container.Resolve<ILoadingManager>();
             
+            GameplaySceneEnvironment env = (GameplaySceneEnvironment)container.Resolve<CurrentSceneEnvironment>();
+
             env.TransitVariables(_gameplaySceneEnvironment);
+            
+            loadingManager
+                .UnregisterLoading(LoadingWork.LoadScene);
         }
     }
 }

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

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

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

@@ -1,3 +1,4 @@
+using Code.App.Loading;
 using Code.Audio;
 using Code.Gameplay.Camera;
 using Code.Gameplay.Enemies;
@@ -11,6 +12,7 @@ namespace Code.App.StateMachine
 {
     public class AppStateMachineContext
     {
+        [Inject] public ILoadingManager LoadingManager { get; private set; }
         [Inject] public ISceneLoaderService SceneLoaderService { get; private set; }
         [Inject] public IInputService InputService { get; private set; }
         [Inject] public AppStateMachine StateMachine { get; private set; }