Okay, let's set up a procedural dungeon generation system inspired by the interconnected, potentially looping layouts found in games like SCP: Containment Breach. This system will use a template-based approach with random walks to spawn rooms connected by doors. using UnityEngine; using System.Collections.Generic; namespace ProceduralDungeon { ///

/// Stores collections of room prefabs categorized by their door configurations. /// Used by the RoomSpawner to select appropriate rooms during generation. ///

public class RoomTemplate : MonoBehaviour { [Header("Room Prefabs")] public GameObject[] bottomRooms; // Rooms with a door facing -Z public GameObject[] topRooms; // Rooms with a door facing +Z public GameObject[] leftRooms; // Rooms with a door facing -X public GameObject[] rightRooms; // Rooms with a door facing +X [Header("Special Rooms")] public GameObject closedRoom; // A room with no exits (or used as a placeholder) public GameObject entranceRoom; // The starting room for the dungeon [Header("Generation State")] public List rooms; // List of all instantiated rooms [Header("Limits")] [Tooltip("Maximum number of rooms to attempt spawning.")] public int maxRooms = 20; [Tooltip("Time in seconds before forcing the generation to stop, preventing infinite loops.")] public float generationTimeout = 5f; private float _startTime; private void Awake() { // Ensure lists/arrays are initialized if needed, although Unity Inspector usually handles this. if (rooms == null) { rooms = new List(); } } private void Start() { // Start generation timeout timer _startTime = Time.time; } private void Update() { // Check for timeout - This is a safety mechanism if (Time.time - _startTime > generationTimeout) { Debug.LogWarning("Dungeon generation timed out. Forcing stop."); // Optionally finalize or clean up generation state here // For now, just stop further spawns by disabling spawn points RoomSpawner[] spawners = FindObjectsOfType(); foreach(var spawner in spawners) { if (spawner != null) // Check if spawner wasn't destroyed { spawner.StopSpawning(); } } // Disable this script to prevent further updates enabled = false; } } ///

/// Checks if the maximum room count has been reached. ///

public bool IsMaxRoomsReached() { return rooms.Count >= maxRooms; } } } using UnityEngine; namespace ProceduralDungeon { ///

/// Attached to "Spawn Point" GameObjects within room prefabs. /// Responsible for spawning the next room in the dungeon generation process. ///

public class RoomSpawner : MonoBehaviour { ///

/// Defines the direction the door/opening faces relative to the room's local space. /// 1 -> Needs door Bottom (-Z) /// 2 -> Needs door Top (+Z) /// 3 -> Needs door Left (-X) /// 4 -> Needs door Right (+X) ///

public int openingDirection; private RoomTemplate _templates; private int _rand; private bool _spawned = false; private float _spawnDelay = 0.1f; // Small delay to prevent race conditions private void Awake() { // Find the central RoomTemplate object in the scene _templates = GameObject.FindGameObjectWithTag("Rooms").GetComponent(); if (_templates == null) { Debug.LogError("RoomTemplate component not found on object tagged 'Rooms'. Dungeon generation cannot proceed."); enabled = false; // Disable script if templates are missing return; } // Use Invoke to delay the spawning slightly, allowing Destroyers to potentially clean up overlaps first Invoke(nameof(SpawnRoom), _spawnDelay); } private void SpawnRoom() { // Prevent spawning if already spawned, if max rooms reached, or if templates are missing if (_spawned || _templates == null || _templates.IsMaxRoomsReached()) { // Ensure this spawner doesn't try again if max rooms was the reason _spawned = true; // Optionally spawn a closing wall/cap here if needed // Instantiate(_templates.closedRoom, transform.position, Quaternion.identity, transform.parent); // Example return; } GameObject newRoom = null; // Select the correct room type based on the required opening direction // The spawned room needs a door facing the *opposite* direction of this spawner switch (openingDirection) { case 1: // Needs room with BOTTOM door (-Z) _rand = Random.Range(0, _templates.bottomRooms.Length); newRoom = Instantiate(_templates.bottomRooms[_rand], transform.position, _templates.bottomRooms[_rand].transform.rotation); break; case 2: // Needs room with TOP door (+Z) _rand = Random.Range(0, _templates.topRooms.Length); newRoom = Instantiate(_templates.topRooms[_rand], transform.position, _templates.topRooms[_rand].transform.rotation); break; case 3: // Needs room with LEFT door (-X) _rand = Random.Range(0, _templates.leftRooms.Length); newRoom = Instantiate(_templates.leftRooms[_rand], transform.position, _templates.leftRooms[_rand].transform.rotation); break; case 4: // Needs room with RIGHT door (+X) _rand = Random.Range(0, _templates.rightRooms.Length); newRoom = Instantiate(_templates.rightRooms[_rand], transform.position, _templates.rightRooms[_rand].transform.rotation); break; default: Debug.LogError($"Invalid openingDirection: {openingDirection} on {gameObject.name}"); break; // Exit if direction is invalid } if (newRoom != null) { // Add the newly spawned room to the central list _templates.rooms.Add(newRoom); // Mark this spawner as used _spawned = true; } else { // If no suitable room was found (e.g., empty array in templates), // consider spawning a closed room/wall cap. // Instantiate(_templates.closedRoom, transform.position, Quaternion.identity); // Example _spawned = true; // Mark as spawned to prevent retries } } ///

/// Called by the Destroyer script when spawn points overlap. /// Destroys this spawn point GameObject. ///

public void HandleOverlap() { // Only destroy if a room hasn't successfully spawned from here yet. // This prevents destroying spawners that correctly connected two rooms. if (!_spawned) { Destroy(gameObject); } } ///

/// Called by the RoomTemplate during timeout to stop further spawning attempts. ///

public void StopSpawning() { _spawned = true; // Prevent future spawns CancelInvoke(nameof(SpawnRoom)); // Cancel pending spawn attempts // Optionally spawn a closed room/wall cap here if needed // Instantiate(_templates.closedRoom, transform.position, Quaternion.identity); Destroy(gameObject, _spawnDelay * 2); // Clean up the spawner object shortly after } // Detect overlaps with other spawn points private void OnTriggerEnter(Collider other) { // Check if the overlapping object is another Room Spawner if (other.CompareTag("SpawnPoint")) { RoomSpawner otherSpawner = other.GetComponent(); if (otherSpawner != null) { // Basic overlap handling: If this spawner hasn't spawned yet, destroy it. // More sophisticated logic could decide which spawner "wins" // or try to spawn a connecting corridor/doorway. // For simplicity, we destroy the entering one if it hasn't spawned. if (!_spawned) { Destroy(gameObject); } // An alternative: Destroy both if they haven't spawned, // potentially replacing with a 'closed' piece. // if (!spawned && !otherSpawner._spawned) { // Instantiate(_templates.closedRoom, transform.position, Quaternion.identity); // Example cap // Destroy(other.gameObject); // Destroy(gameObject); // } } } } // Alternative overlap detection using Stay, might be more robust in some cases // private void OnTriggerStay(Collider other) // { // if (other.CompareTag("SpawnPoint")) // { // // Similar logic as OnTriggerEnter, potentially with adjustments // if (!_spawned) // { // Destroy(gameObject); // } // } // } } } using UnityEngine; namespace ProceduralDungeon { ///

/// Simple utility script attached to a trigger collider within room prefabs. /// Destroys any "Spawn Point" objects that enter its trigger volume. /// This helps clean up redundant spawn points when rooms are placed adjacent /// to each other where no door should be. ///

public class Destroyer : MonoBehaviour { private void OnTriggerEnter(Collider other) { // Check if the object entering the trigger has the "SpawnPoint" tag if (other.CompareTag("SpawnPoint")) { // Optionally, add more checks here (e.g., ensure it's not the spawner that *created* this room) // For basic cleanup, just destroy the spawn point. Destroy(other.gameObject); // Alternative: Call a method on the spawner to handle its destruction gracefully // RoomSpawner spawner = other.GetComponent(); // if (spawner != null) // { // spawner.HandleOverlap(); // } else { // Destroy(other.gameObject); // Fallback // } } // Optional: Destroy other rooms if they overlap significantly (can cause issues if not careful) // else if (other.CompareTag("Room")) // Assuming rooms have a "Room" tag // { // // Be cautious with this - might delete intended connections or the starting room // // Destroy(other.gameObject); // } } } } using UnityEngine; namespace ProceduralDungeon { ///

/// Initializes the dungeon generation process by spawning the entrance room. ///

public class DungeonInitializer : MonoBehaviour { [Tooltip("Reference to the RoomTemplate scriptable object or component in the scene.")] [SerializeField] private RoomTemplate roomTemplate; void Start() { if (roomTemplate == null) { // Attempt to find it if not assigned roomTemplate = FindObjectOfType(); if (roomTemplate == null) { Debug.LogError("RoomTemplate not assigned or found in the scene. Cannot initialize dungeon."); return; } } if (roomTemplate.entranceRoom == null) { Debug.LogError("Entrance Room prefab is not assigned in the RoomTemplate."); return; } // Instantiate the starting room at the origin (or a specified spawn point) GameObject entrance = Instantiate(roomTemplate.entranceRoom, Vector3.zero, Quaternion.identity); // Add the entrance room to the list of rooms if (roomTemplate.rooms == null) { roomTemplate.rooms = new System.Collections.Generic.List(); } roomTemplate.rooms.Add(entrance); Debug.Log("Dungeon initialization complete. Started with entrance room."); } } } **Setup Instructions:** 1. **Create Folders:** Create `Assets/Scripts/Dungeon`. 2. **Create Scripts:** Place the four C# scripts (`RoomTemplate.cs`, `RoomSpawner.cs`, `Destroyer.cs`, `DungeonInitializer.cs`) into the `Assets/Scripts/Dungeon` folder. 3. **Create Room Prefabs:** * Design several simple room/corridor prefabs (e.g., using ProBuilder or basic cubes). Examples: * `Corridor_LR` (Doors Left/Right) * `Corridor_TB` (Doors Top/Bottom) * `Room_T` (Door Top only) * `Room_B` (Door Bottom only) * `Room_L` (Door Left only) * `Room_R` (Door Right only) * `Room_4Way` (Doors on all sides) * `Room_T_Junction` (Doors Top, Left, Right) * `DeadEnd_T` (Wall Top, Door Bottom) - Use these for `closedRoom` or specific termination. * `EntranceRoom` (e.g., a simple room with one exit) * **Crucially:** Ensure prefabs are sized consistently (e.g., all rooms occupy a 10x10 space). 4. **Add Spawn Points to Prefabs:** * Inside each room prefab, create empty GameObjects exactly where doors/openings should connect to the *next* room. Name them descriptively (e.g., `SpawnPoint_Top`, `SpawnPoint_Bottom`). * Add the `RoomSpawner.cs` script to each of these Spawn Point GameObjects. * **Set `Opening Direction`:** Configure the `openingDirection` variable on each `RoomSpawner` script according to which direction it faces *relative to the room prefab*: * 1: Spawn point is at the **Bottom** edge (facing -Z), needs a room with a Top door. * 2: Spawn point is at the **Top** edge (facing +Z), needs a room with a Bottom door. * 3: Spawn point is at the **Left** edge (facing -X), needs a room with a Right door. * 4: Spawn point is at the **Right** edge (facing +X), needs a room with a Left door. * **Add Collider:** Add a `BoxCollider` (or `SphereCollider`) to each Spawn Point GameObject. Mark it as `Is Trigger`. Size it appropriately (e.g., a small cube) so it can detect overlaps. * **Set Tag:** Set the Tag of each Spawn Point GameObject to `SpawnPoint`. If the tag doesn't exist, create it via `Edit -> Project Settings -> Tags and Layers`. 5. **Add Destroyer Trigger to Prefabs:** * Inside each room prefab, create another empty GameObject, perhaps named `OverlapDestroyer`. * Add a `BoxCollider` to it and mark `Is Trigger`. * Size this collider so it slightly overlaps where adjacent *solid walls* would be (i.e., where you *don't* want a door/spawn point from another room to exist). * Add the `Destroyer.cs` script to this GameObject. 6. **Create Template Manager:** * Create an empty GameObject in your scene (e.g., `DungeonManager`). * Add the `RoomTemplate.cs` script to it. * **Set Tag:** Set the Tag of this `DungeonManager` GameObject to `Rooms`. The `RoomSpawner` script finds it using this tag. * **Assign Prefabs:** Drag your created room prefabs into the corresponding arrays (`bottomRooms`, `topRooms`, etc.) in the Inspector panel for the `RoomTemplate` component. Assign your `EntranceRoom` prefab and a `closedRoom` prefab (can be a simple cube or a dead-end room). * **Set Limits:** Adjust `Max Rooms` and `Generation Timeout` as needed. 7. **Add Initializer:** * Add the `DungeonInitializer.cs` script to the `DungeonManager` GameObject (or another manager object in your scene). * Ensure the `Room Template` field on the `DungeonInitializer` component is assigned (drag the `DungeonManager` GameObject itself onto this slot). 8. **Run:** Enter Play mode. The `DungeonInitializer` will spawn the `EntranceRoom`, and its `RoomSpawner` components will trigger the chain reaction, creating the dungeon based on the templates. This setup creates a branching, random dungeon. True "loops" (where corridors connect back to previously visited areas, forming cycles) require more complex logic, often involving checking neighbors before spawning or a post-processing step to add extra connections. This base system, however, provides the foundation for procedural level generation.