Hasebe/Assets/Code/Debug/TestingLevel/TestingState.cs

using Code.Game.Gameplay.Player;
using Code.Game.Gameplay.Player.Factory;
using Code.Infrastructure.App;
using Code.Infrastructure.Camera;
using Code.Infrastructure.Generators;
using Code.Infrastructure.Input;
using Code.Infrastructure.SceneLoader;
using Code.Infrastructure.Utils;
using Cysharp.Threading.Tasks;
using KinematicCharacterController;
using ObservableCollections;
using R3;
using Reflex.Core;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Code.Game.TestingLevel
{
    [State(typeof(AppStates), typeof(AppStateMachineContext))]
    public partial class TestingState
    {
        public TestingState(AppStateMachineContext context) : base(context)
        {
        }

        public override AppStates MyState => AppStates.Testing;

        public override async UniTask EnterState()
        {
            Cursor.lockState = CursorLockMode.Locked;

            Context.InputService.EnableMap(ActionMappings.OpenMovement);

            Context.AudioService.SetAudioListener(Context.Camera.Camera.GetComponent<AudioListener>());

            await Context.Camera.SwitchState(CameraMode.OpenMovement);

            var waitForContainer =
                Context.SceneContainerManager.ScenesContainers
                    .ObserveDictionaryAdd()
                    .Where(x => x.Key == SceneId.Testing)
                    .Take(1)
                    .WaitAsync()
                    .AsUniTask();

            var factoryConfig = new SingleConfig<PlayerFactorySettings>();

            await factoryConfig.LoadConfig();

            var factory = new PlayerFactory(factoryConfig);
            var player = await factory.CreatePlayer();
            var playerKinematicCharacterMotor = player.GetComponent<KinematicCharacterMotor>();
            var playerMovementController = player.GetComponent<PlayerMovementController>();

            playerMovementController.Freeze = true;
            
            ((OpenMovementCameraState)Context.Camera.CurrentBaseState).SetTarget(player.transform);
            
            void InstallExtra(Scene scene, ContainerBuilder builder)
            {
                builder.RegisterValue(factoryConfig);
                builder.RegisterValue(factory, new []{typeof(IPlayerFactory)});
                builder.RegisterValue(playerKinematicCharacterMotor);
                builder.RegisterValue(playerMovementController);
            }
            
            await UniTask.WhenAll(
                Context.SceneLoader
                    .LoadSceneAsync(
                        SceneId.Testing,
                        LoadSceneMode.Single,
                        true,
                        InstallExtra),                
                Context.SceneLoader
                    .LoadSceneAsync(
                        SceneId.FirstTestingSegment,
                        LoadSceneMode.Additive,
                        false),                
                Context.SceneLoader
                    .LoadSceneAsync(
                        SceneId.SecondTestingSegment,
                        LoadSceneMode.Additive,
                        false),
                waitForContainer
            );
            
            var container = Context.SceneContainerManager.ScenesContainers[SceneId.Testing];

            container.Resolve<KinematicCharacterMotor>()
                .SetPositionAndRotation(
                    container.Resolve<TestingLevelData>().playerSpawnPoint.position,
                    container.Resolve<TestingLevelData>().playerSpawnPoint.rotation);
            
            playerMovementController.Freeze = false;
        }

        public override async UniTask ExitState()
        {
            Context.InputService.DisableMap(ActionMappings.OpenMovement);

            if (Context.StateMachine.NextState == AppStates.BattleState) return;
            
            await Context.SceneLoader.UnloadSceneAsync(SceneId.Testing);
            await Context.SceneLoader.UnloadSceneAsync(SceneId.FirstTestingSegment);
            await Context.SceneLoader.UnloadSceneAsync(SceneId.SecondTestingSegment);
        }
    }
}