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

using System.Collections.Generic;
using Code.Gameplay.Orders.Order;
using Code.Scenes;
using Code.Scenes.SceneEnvironments; 
using Reflex.Attributes;
using UnityEngine;

namespace Code.Generator
{
    public class RoomGenerator
    {
        [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 List<Room> _spawnedRooms;

        private int _nextRoomStackIndex;

        public void Initialize()
        {
            _spawnedRooms = new List<Room>();
            _roomIndexesStack = new();

            _orderService.OnOrderGiven += CreateRoomsStack;
            CreateInitialRoom(); 
        }

        private void OnPlayerEntered()
        {
            SpawnNextRoom();

            if (_spawnedRooms.Count > 3)
            {
                Room roomToRemove = _spawnedRooms[0];
                _spawnedRooms.RemoveAt(0);

                Object.Destroy(roomToRemove.gameObject);
            }
        }

        private void CreateRoomsStack(float timer)
        {
            _nextRoomStackIndex = 0; 
            _roomIndexesStack.Clear(); 
            
            var remainingTime = timer;
  
            while (remainingTime > 0)
            {
                var prefab = _factory.GetRandomCachedPrefabOfType(RoomType.Basic, out int roomIndex);

                Room room = prefab.GetComponent<Room>();

                _roomIndexesStack.Add(new(RoomType.Basic, roomIndex));
                remainingTime -= room.RoomTimer;
            }
            
            AddPickupRoom();
            
            AddSaveRoom();
             
            SpawnNextRoom();
        }

        private void AddSaveRoom()
        {
            int saveRoomIndex = _factory.GetRandomIndexOfType(RoomType.Save); 
            
            _roomIndexesStack.Add(new(RoomType.Save, saveRoomIndex));
        } 
        
        private void AddPickupRoom()
        {
            int pickupIndex = _factory.GetRandomIndexOfType(RoomType.PickUp);

            int insertPos = Random.Range(1, _roomIndexesStack.Count + 1);

            _roomIndexesStack.Insert(insertPos, new(RoomType.PickUp, pickupIndex)); 
        }

        [Inject] private CurrentSceneEnvironment _currentSceneEnvironment;

        private void CreateInitialRoom()
        {
            GameplaySceneEnvironment gameplaySceneEnvironment = (GameplaySceneEnvironment)_currentSceneEnvironment;
            
            int roomIndex = _factory.GetRandomIndexOfType(RoomType.Initial); 
            
            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(_orderService);
        } 
        private void SpawnNextRoom()
        {
            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);
            }

            // Отписываться можно, но Хатико никогда не дождётся вызова уничтоженного объекта.
            room.roomTrigger.OnEnter += OnPlayerEntered;
            
            room.roomTrigger.OnExit += _spawnedRooms[^1].Seal;
            _spawnedRooms.Add(room);
            _nextRoomStackIndex++;
        }


        private void PlaceRoom(Room current, Room previous)
        {
            if (current.EnterMarker == null || previous.ExitMarker == null)
                return;

            Vector3 segmentOriginPosition = previous.ExitMarker.transform.position;

            Transform randomDoorOrigin = current.EnterMarker;
            Vector3 randomDoorOriginPosition = randomDoorOrigin.localPosition * current.transform.localScale.x;
            Quaternion randomDoorOriginRotation = randomDoorOrigin.localRotation;

            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); 
            current.Initialize(_orderService); 
        }
    }
}
        // 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}");
        // }