Возможно, коридоры и перекрестки не спавнятся, потому что среди префабов комнат недостаточно таких типов комнат, или есть проблема с тем, как генератор выбирает типы комнат. Убедитесь, что у вас есть префабы комнат для коридоров, поворотов, перекрестков и Т-образных перекрестков, и что они добавлены в список `Room Prefabs > Room Prefabs` в инспекторе компонента `GeneratorLevel`. Вот обновленный скрипт `GeneratorLevel.cs`, который включает комментарии, напоминающие проверить настройки префабов: csharp using UnityEngine; using System.Collections.Generic; using System.Linq; namespace SCPMapGenerator { ///

/// Manages the procedural generation of the level layout using Room prefabs. ///

public class GeneratorLevel : MonoBehaviour { [Header("Generation Settings")] [Tooltip("The minimum number of rooms to generate (including the start room).")] [SerializeField] private int minRooms = 10; [Tooltip("The maximum number of rooms to generate (including the start room).")] [SerializeField] private int maxRooms = 20; [Tooltip("The exact number of 'key' rooms to place.")] [SerializeField] private int numberOfKeyRooms = 2; [Tooltip("Maximum attempts to place a room at a connection point before giving up on that point.")] [SerializeField] private int maxPlacementAttemptsPerPoint = 20; // Increased from 5 [Tooltip("Maximum overall attempts to find a valid placement before stopping generation.")] [SerializeField] private int maxTotalPlacementAttempts = 200; // Increased from 100 [Header("Room Prefabs")] [Tooltip("The prefab for the starting room.")] [SerializeField] private Room startRoomPrefab; [Tooltip("List of prefabs for regular rooms.")] [SerializeField] private List roomPrefabs; [Tooltip("List of prefabs for key rooms.")] [SerializeField] private List keyRoomPrefabs; [Header("Collision Settings")] [Tooltip("The layer mask used to check for room overlaps.")] [SerializeField] private LayerMask roomLayerMask = 1; // Default layer often works // --- Private Generation State --- private List placedRooms = new List(); private List availableConnectionPoints = new List(); private int currentRoomCount = 0; private int currentKeyRoomCount = 0; private int totalPlacementAttempts = 0; private void Start() { if (!ValidateSettings()) return; GenerateLevel(); } ///

/// Validates the generator settings before starting generation. ///

private bool ValidateSettings() { if (startRoomPrefab == null) { Debug.LogError("Start Room Prefab is not assigned!", this); return false; } if (roomPrefabs == null || roomPrefabs.Count == 0) { Debug.LogWarning("No regular Room Prefabs assigned. Only start and key rooms can be generated.", this); // Allow continuing if key rooms exist } if (keyRoomPrefabs == null || keyRoomPrefabs.Count == 0) { Debug.LogWarning("No Key Room Prefabs assigned. Key rooms cannot be generated.", this); if (numberOfKeyRooms > 0) { Debug.LogError($"Requested {numberOfKeyRooms} key rooms, but no key room prefabs are assigned!", this); return false; } } if (numberOfKeyRooms > maxRooms) { Debug.LogError("Number of Key Rooms cannot exceed Max Rooms.", this); return false; } if (minRooms > maxRooms) { Debug.LogError("Min Rooms cannot be greater than Max Rooms.", this); return false; } if (keyRoomPrefabs.Count == 0 && numberOfKeyRooms > 0) { Debug.LogError("Number of Key Rooms > 0 but no Key Room Prefabs assigned.", this); return false; } if (roomPrefabs.Count == 0 && (maxRooms > 1 || minRooms > 1) && numberOfKeyRooms < minRooms) { Debug.LogError("No regular Room Prefabs assigned, but min/max rooms require them.", this); return false; } // Ensure prefabs have the Room component if (!startRoomPrefab.GetComponent()) { Debug.LogError("Start Room Prefab is missing Room component!", startRoomPrefab); return false; } foreach(var prefab in roomPrefabs) { if (!prefab.GetComponent()) { Debug.LogError($"Room Prefab '{prefab.name}' is missing Room component!", prefab); return false; } } foreach(var prefab in keyRoomPrefabs) { if (!prefab.GetComponent()) { Debug.LogError($"Key Room Prefab '{prefab.name}' is missing Room component!", prefab); return false; } } return true; } ///

/// Starts the level generation process. ///

public void GenerateLevel() { ClearPreviousLevel(); // 1. Place the starting room Room startRoom = Instantiate(startRoomPrefab, Vector3.zero, Quaternion.identity, this.transform); if (!RegisterRoom(startRoom)) { Debug.LogError("Failed to place start room (overlap check failed?). Generation aborted.", startRoom); if (startRoom != null) Destroy(startRoom.gameObject); // Clean up failed start room return; } // 2. Main generation loop int targetRoomCount = Random.Range(minRooms, maxRooms + 1); while (currentRoomCount < targetRoomCount && availableConnectionPoints.Count > 0 && totalPlacementAttempts < maxTotalPlacementAttempts) { totalPlacementAttempts++; // Select a random available connection point int randomIndex = Random.Range(0, availableConnectionPoints.Count); ConnectionPoint currentExitPoint = availableConnectionPoints[randomIndex]; // Try placing a new room at this connection point bool placementSuccess = TryPlaceRoom(currentExitPoint); // If placement failed after attempts, remove the point to avoid infinite loops if (!placementSuccess) { // Debug.Log($"Failed to place room at connection point {currentExitPoint.name} on {currentExitPoint.ParentRoom.name}. Removing point.", currentExitPoint); availableConnectionPoints.RemoveAt(randomIndex); // Remove the problematic point } // Safety break if somehow room count exceeds max if(currentRoomCount >= maxRooms) break; } // 3. Final check and logging if (currentRoomCount < minRooms) { Debug.LogWarning($"Generation finished but only placed {currentRoomCount} rooms (minimum was {minRooms}). Could not find valid placements. **Проверьте, добавлены ли префабы коридоров и перекрестков в список Room Prefabs > Room Prefabs в инспекторе GeneratorLevel.**", this); } else if (totalPlacementAttempts >= maxTotalPlacementAttempts) { Debug.LogWarning($"Generation stopped after reaching max total placement attempts ({maxTotalPlacementAttempts}). Placed {currentRoomCount} rooms.", this); } else { Debug.Log($"Level generated successfully with {currentRoomCount} rooms after {totalPlacementAttempts} attempts.", this); } } ///

/// Clears the previously generated level, destroying all placed rooms. ///

private void ClearPreviousLevel() { // Destroy all existing rooms foreach (var room in placedRooms) { if (room != null) // Check if not already destroyed { Destroy(room.gameObject); } } placedRooms.Clear(); availableConnectionPoints.Clear(); currentRoomCount = 0; currentKeyRoomCount = 0; totalPlacementAttempts = 0; } ///

/// Attempts to place a room at a given connection point. ///

/// The connection point to attach the new room to. /// True if a room was successfully placed, false otherwise. private bool TryPlaceRoom(ConnectionPoint exitPoint) { if (exitPoint.IsConnected) return false; // Point already used int placementAttempts = 0; bool roomPlaced = false; while (placementAttempts < maxPlacementAttemptsPerPoint && !roomPlaced) { placementAttempts++; // 1. Choose a room prefab (prioritize key rooms if needed) Room roomToPlacePrefab = ChooseRoomPrefab(); if (roomToPlacePrefab == null) return false; // No suitable prefab available // 2. Instantiate the room Room roomToPlace = Instantiate(roomToPlacePrefab, Vector3.zero, Quaternion.identity, this.transform); // 3. Find a compatible connection point in the new room ConnectionPoint entryPointInNewRoom = FindCompatibleEntryPoint(roomToPlace, exitPoint.transform.forward); if (entryPointInNewRoom == null) { Destroy(roomToPlace.gameObject); // No compatible entry point, discard room continue; // Try again with another prefab or give up } // 4. Calculate placement position and rotation CalculateRoomPlacement(exitPoint, entryPointInNewRoom, roomToPlace); // 5. Check for overlaps if (!CheckForRoomOverlap(roomToPlace)) { // 6. Register the placed room and connection points if (RegisterRoom(roomToPlace)) { // 7. Connect the rooms at the chosen points ConnectRooms(exitPoint, entryPointInNewRoom); roomPlaced = true; // Placement successful! } else { Destroy(roomToPlace.gameObject); // Registration failed (overlap after placement?), discard room } } else { Destroy(roomToPlace.gameObject); // Overlap detected, discard room } } return roomPlaced; } ///

/// Chooses a room prefab to place, prioritizing key rooms if needed. ///

/// A Room prefab, or null if no suitable prefab is available. private Room ChooseRoomPrefab() { if (currentKeyRoomCount < numberOfKeyRooms) { if (keyRoomPrefabs != null && keyRoomPrefabs.Count > 0) { currentKeyRoomCount++; return keyRoomPrefabs[Random.Range(0, keyRoomPrefabs.Count)]; // Choose a key room } else { Debug.LogWarning("Requested key room but no key room prefabs available. Falling back to regular rooms.", this); currentKeyRoomCount--; // Revert key room count, try regular room } } if (roomPrefabs != null && roomPrefabs.Count > 0 && currentRoomCount < maxRooms -1 ) // Ensure we can still place rooms { return roomPrefabs[Random.Range(0, roomPrefabs.Count)]; // Choose a regular room } return null; // No prefabs available or max rooms reached } ///

/// Finds a compatible entry connection point in the new room. ///

/// The room to search in. /// The forward direction of the exit point we are connecting to. /// A compatible ConnectionPoint, or null if none is found. private ConnectionPoint FindCompatibleEntryPoint(Room newRoom, Vector3 exitForwardDirection) { // Entry point should face opposite direction of the exit point Vector3 targetForward = -exitForwardDirection; var possibleEntryPoints = newRoom.ConnectionPoints.Where(point => !point.IsConnected).ToList(); if(possibleEntryPoints.Count == 0) return null; // No available points // Find the entry point that is most closely aligned to the opposite direction ConnectionPoint bestEntryPoint = possibleEntryPoints[0]; float bestAlignment = Vector3.Dot(bestEntryPoint.transform.forward, targetForward); for (int i = 1; i < possibleEntryPoints.Count; i++) { float alignment = Vector3.Dot(possibleEntryPoints[i].transform.forward, targetForward); if (alignment > bestAlignment) { bestAlignment = alignment; bestEntryPoint = possibleEntryPoints[i]; } } // Consider only points that are reasonably aligned (e.g., within +/- 45 degrees, dot product > 0.7) if (bestAlignment > 0.7f) //cos(45 degrees) approx { return bestEntryPoint; } else { return null; // No reasonably aligned entry point found } } ///

/// Calculates the position and rotation for placing a new room to connect to an exit point. ///

/// The exit connection point in the existing room. /// The entry connection point in the new room. /// The room to be placed. private void CalculateRoomPlacement(ConnectionPoint exitPoint, ConnectionPoint entryPoint, Room roomToPlace) { // 1. Rotation: Align entry point's forward with the opposite of the exit point's forward Vector3 targetRotationEuler = Quaternion.LookRotation(-exitPoint.transform.forward, Vector3.up).eulerAngles; Vector3 entryPointRotationEuler = entryPoint.transform.rotation.eulerAngles; Quaternion rotationDifference = Quaternion.Euler(targetRotationEuler - entryPointRotationEuler); roomToPlace.transform.rotation = rotationDifference * roomToPlace.transform.rotation; // 2. Position: Align entry point's position with the exit point's position Vector3 exitPointWorldPosition = exitPoint.transform.position; Vector3 entryPointWorldPosition = roomToPlace.transform.TransformPoint(entryPoint.transform.localPosition); // Get entry point position in world space after rotation Vector3 positionOffset = exitPointWorldPosition - entryPointWorldPosition; // Calculate the difference roomToPlace.transform.position += positionOffset; // Apply the offset } ///

/// Checks if placing the given room will cause an overlap with existing rooms. ///

/// The room to check for overlaps. /// True if an overlap is detected, false otherwise. private bool CheckForRoomOverlap(Room room) { Collider[] colliders = Physics.OverlapBox(room.transform.position, room.RoomBounds / 2f * 0.95f, room.transform.rotation, roomLayerMask); // Slightly smaller bounds for safety foreach (var col in colliders) { if (col.GetComponentInParent() != room) // Ignore self-overlap { return true; // Overlap detected with another room } } return false; // No overlap detected } ///

/// Registers a placed room, adding it to the lists and updating connection points. ///

/// The room that has been successfully placed. /// True if registration was successful, false if registration failed (e.g., overlap detected during registration). private bool RegisterRoom(Room placedRoom) { if (CheckForRoomOverlap(placedRoom)) { Debug.LogError("Overlap detected during room registration. Room placement failed.", placedRoom); Destroy(placedRoom.gameObject); return false; // Overlap during registration } placedRooms.Add(placedRoom); currentRoomCount++; // Add new connection points from the placed room, except for the entry point used for placement foreach (var point in placedRoom.ConnectionPoints) { if (!point.IsConnected) // Add only if not already connected { availableConnectionPoints.Add(point); } } return true; // Room registered successfully } ///

/// Establishes a connection between two rooms at the specified connection points. ///

/// The connection point in the existing room. /// The connection point in the newly placed room. private void ConnectRooms(ConnectionPoint exitPoint, ConnectionPoint entryPoint) { exitPoint.IsConnected = true; entryPoint.IsConnected = true; availableConnectionPoints.Remove(exitPoint); // No longer available availableConnectionPoints.Remove(entryPoint); // No longer available // Optional: Visualize connection (e.g., draw a line, instantiate a door prefab) Debug.DrawLine(exitPoint.transform.position, entryPoint.transform.position, Color.yellow, 10f); } ///

/// Gets the number of rooms currently placed in the level. ///

public int CurrentRoomCount => currentRoomCount; ///

/// Gets the list of rooms currently placed in the level. ///

public List PlacedRooms => placedRooms; ///

/// Gets the list of currently available connection points. ///

public List AvailableConnectionPoints => availableConnectionPoints; } } using UnityEngine; using System.Collections.Generic; using System.Linq; namespace SCPMapGenerator { ///