csharp using System; using System.Collections.Generic; using System.Linq; namespace RoomGenerator { // Represents a connection point on a room prefab public class Connector { public Point RelativePosition { get; } public Direction FacingDirection { get; } public string Type { get; } // e.g., "StandardDoor", "LargeOpening" - for potential future rules public Connector(Point relativePosition, Direction facingDirection, string type = "StandardDoor") { RelativePosition = relativePosition; FacingDirection = facingDirection; Type = type; } // Gets the direction opposite to the connector's facing direction public Direction GetOppositeDirection() { return FacingDirection switch { Direction.North => Direction.South, Direction.South => Direction.North, Direction.East => Direction.West, Direction.West => Direction.East, _ => throw new ArgumentOutOfRangeException() }; } } // Represents a type of room or corridor public class RoomPrefab { public string Id { get; } public string Name { get; } public List Connectors { get; } = new List(); public bool IsStartRoom { get; set; } = false; public bool IsEndRoom { get; set; } = false; public bool IsKeyRoom { get; set; } = false; // Must spawn exactly once public bool IsDeadEnd { get; set; } = false; // Used to cap open connectors public RoomPrefab(string id, string name) { Id = id; Name = name; } public void AddConnector(Point relativePosition, Direction facingDirection, string type = "StandardDoor") { Connectors.Add(new Connector(relativePosition, facingDirection, type)); } } // Represents an instance of a placed room in the generated layout public class RoomInstance { public RoomPrefab Prefab { get; } public Point Position { get; } // Absolute position in the grid public Dictionary Connections { get; } = new Dictionary(); // Maps local connector to connected room instance public RoomInstance(RoomPrefab prefab, Point position) { Prefab = prefab; Position = position; foreach (var connector in prefab.Connectors) { Connections.Add(connector, null); // Initialize all connections as open (null) } } public IEnumerable GetOpenConnectors() { return Connections.Where(kvp => kvp.Value == null).Select(kvp => kvp.Key); } public Point GetWorldConnectorPosition(Connector localConnector) { // Simple addition for now, assuming no rotation. Rotation would require transformation. return new Point(Position.X + localConnector.RelativePosition.X, Position.Y + localConnector.RelativePosition.Y); } } // Simple 2D Point struct public struct Point : IEquatable { public int X { get; } public int Y { get; } public Point(int x, int y) { X = x; Y = y; } public override bool Equals(object? obj) => obj is Point other && Equals(other); public bool Equals(Point other) => X == other.X && Y == other.Y; public override int GetHashCode() => HashCode.Combine(X, Y); public static bool operator ==(Point left, Point right) => left.Equals(right); public static bool operator !=(Point left, Point right) => !(left == right); public override string ToString() => $"({X}, {Y})"; public static Point operator +(Point a, Point b) => new Point(a.X + b.X, a.Y + b.Y); public static Point operator -(Point a, Point b) => new Point(a.X - b.X, a.Y - b.Y); } // Cardinal directions public enum Direction { North, // +Y South, // -Y East, // +X West // -X } // Settings for the generator public class GenerationSettings { public int TargetRoomCount { get; set; } = 10; public string StartRoomId { get; set; } = "Start"; public string EndRoomId { get; set; } = "End"; public string DeadEndId { get; set; } = "DeadEnd"; public List KeyRoomIds { get; set; } = new List(); public List AvailablePrefabs { get; set; } = new List(); } // Main generator class public class DungeonGenerator { private readonly GenerationSettings _settings; private readonly Random _random = new Random(); private readonly Dictionary _placedRooms = new Dictionary(); private readonly List _openList = new List(); // Rooms with open connectors private readonly HashSet _placedKeyRooms = new HashSet(); private readonly HashSet _requiredKeyRooms; public DungeonGenerator(GenerationSettings settings) { _settings = settings ?? throw new ArgumentNullException(nameof(settings)); _requiredKeyRooms = new HashSet(_settings.KeyRoomIds ?? new List()); // Validate settings if (_settings.AvailablePrefabs == null || !_settings.AvailablePrefabs.Any()) throw new ArgumentException("AvailablePrefabs cannot be null or empty.", nameof(settings)); if (GetPrefabById(_settings.StartRoomId) == null) throw new ArgumentException($"Start room prefab with ID '{_settings.StartRoomId}' not found.", nameof(settings)); if (GetPrefabById(_settings.EndRoomId) == null) throw new ArgumentException($"End room prefab with ID '{_settings.EndRoomId}' not found.", nameof(settings)); if (GetPrefabById(_settings.DeadEndId) == null) throw new ArgumentException($"Dead end prefab with ID '{_settings.DeadEndId}' not found.", nameof(settings)); foreach (var keyId in _requiredKeyRooms) { if (GetPrefabById(keyId) == null) throw new ArgumentException($"Key room prefab with ID '{keyId}' not found.", nameof(settings)); } } public List Generate() { _placedRooms.Clear(); _openList.Clear(); _placedKeyRooms.Clear(); // 1. Place Start Room RoomPrefab startPrefab = GetPrefabById(_settings.StartRoomId)!; PlaceRoom(startPrefab, new Point(0, 0)); // 2. Main Generation Loop while (_placedRooms.Count < _settings.TargetRoomCount && _openList.Any()) { if (!TryPlaceNextRoom()) { // Could not place a room from any open connector, try capping one if (!TryCapRandomOpenConnector()) { // If capping also fails (e.g., no open connectors left), break Console.WriteLine("Warning: Could not place more rooms or cap connectors. Generation might be incomplete."); break; } } } // 3. Ensure End Room is Placed (replace last or add if possible) EnsureEndRoomPlaced(); // 4. Cap Remaining Open Connectors CapAllOpenConnectors(); Console.WriteLine($"Generation finished. Placed {_placedRooms.Count} rooms."); return _placedRooms.Values.ToList(); } private bool TryPlaceNextRoom() { List shuffledOpenList = _openList.OrderBy(x => _random.Next()).ToList(); foreach (var currentRoom in shuffledOpenList) { List shuffledConnectors = currentRoom.GetOpenConnectors().OrderBy(x => _random.Next()).ToList(); foreach (var connectorToUse in shuffledConnectors) { List possiblePrefabs = GetPossiblePrefabs(currentRoom, connectorToUse); possiblePrefabs = possiblePrefabs.OrderBy(x => _random.Next()).ToList(); foreach (var prefabToPlace in possiblePrefabs) { // Find a compatible connector on the new prefab var compatibleConnectors = prefabToPlace.Connectors .Where(c => c.GetOppositeDirection() == connectorToUse.FacingDirection && c.Type == connectorToUse.Type) // Basic compatibility check .OrderBy(x => _random.Next()) .ToList(); foreach (var newRoomConnector in compatibleConnectors) { Point currentConnectorWorldPos = currentRoom.GetWorldConnectorPosition(connectorToUse); // Calculate position assuming no rotation: WorldPos = TargetWorldPos - NewRoomLocalConnectorPos Point newRoomPosition = currentConnectorWorldPos - newRoomConnector.RelativePosition; if (!_placedRooms.ContainsKey(newRoomPosition)) // Check for collision at the room's origin { // More sophisticated collision check needed for rooms larger than 1x1 // For now, just check the origin point. RoomInstance newRoom = PlaceRoom(prefabToPlace, newRoomPosition); if (newRoom != null) { // Connect rooms ConnectRooms(currentRoom, connectorToUse, newRoom, newRoomConnector); return true; // Successfully placed a room } } } } } } return false; // Could not place any room from any open connector } private List GetPossiblePrefabs(RoomInstance currentRoom, Connector connectorToUse) { List candidates = new List(); bool placeKeyRoom = _requiredKeyRooms.Count > _placedKeyRooms.Count && _random.Next(0, 3) == 0; // Chance to place a key room if (placeKeyRoom) { string? keyToPlace = _requiredKeyRooms.Except(_placedKeyRooms).OrderBy(x => _random.Next()).FirstOrDefault(); if (keyToPlace != null) { RoomPrefab? keyPrefab = GetPrefabById(keyToPlace); if (keyPrefab != null && CanConnect(keyPrefab, connectorToUse)) { candidates.Add(keyPrefab); // If we add a key room candidate, maybe don't add others for this attempt // to prioritize placing it. Or add it with higher probability later. // For now, just add it to the list. } } } // Add regular rooms (non-special, non-key, non-dead-end) candidates.AddRange(_settings.AvailablePrefabs .Where(p => !p.IsStartRoom && !p.IsEndRoom && !p.IsKeyRoom && !p.IsDeadEnd && CanConnect(p, connectorToUse)) ); // Avoid placing the end room too early unless near target count if (_placedRooms.Count >= _settings.TargetRoomCount - 2) // Allow end room near the end { RoomPrefab? endPrefab = GetPrefabById(_settings.EndRoomId); if(endPrefab != null && !endPrefab.IsStartRoom && CanConnect(endPrefab, connectorToUse)) // Ensure end isn't start { candidates.Add(endPrefab); } } // Filter out already placed unique key rooms candidates.RemoveAll(p => p.IsKeyRoom && _placedKeyRooms.Contains(p.Id)); return candidates.Distinct().ToList(); // Ensure uniqueness } // Basic check if a prefab has *any* connector compatible with the target connector private bool CanConnect(RoomPrefab prefab, Connector targetConnector) { return prefab.Connectors.Any(c => c.GetOppositeDirection() == targetConnector.FacingDirection && c.Type == targetConnector.Type); } private RoomInstance? PlaceRoom(RoomPrefab prefab, Point position) { if (_placedRooms.ContainsKey(position)) { Console.WriteLine($"Error: Attempted to place room {prefab.Id} at occupied position {position}."); return null; // Collision } // More complex collision check needed here if rooms occupy more than one grid cell RoomInstance newInstance = new RoomInstance(prefab, position); _placedRooms.Add(position, newInstance); if (prefab.IsKeyRoom) { _placedKeyRooms.Add(prefab.Id); } // Add to open list if it has connectors if (newInstance.Prefab.Connectors.Any()) { _openList.Add(newInstance); } // Console.WriteLine($"Placed {prefab.Id} at {position}"); return newInstance; } private void ConnectRooms(RoomInstance roomA, Connector connectorA, RoomInstance roomB, Connector connectorB) { if (roomA.Connections.ContainsKey(connectorA)) roomA.Connections[connectorA] = roomB; else Console.WriteLine($"Warning: Connector not found on Room A ({roomA.Prefab.Id}) during connection."); if (roomB.Connections.ContainsKey(connectorB)) roomB.Connections[connectorB] = roomA; else Console.WriteLine($"Warning: Connector not found on Room B ({roomB.Prefab.Id}) during connection."); // If a room has no more open connectors, remove it from the open list if (!roomA.GetOpenConnectors().Any()) _openList.Remove(roomA); if (!roomB.GetOpenConnectors().Any()) _openList.Remove(roomB); // Console.WriteLine($"Connected {roomA.Prefab.Id}@{roomA.Position} via {connectorA.FacingDirection} to {roomB.Prefab.Id}@{roomB.Position} via {connectorB.FacingDirection}"); } private void EnsureEndRoomPlaced() { RoomPrefab endPrefab = GetPrefabById(_settings.EndRoomId)!; RoomPrefab deadEndPrefab = GetPrefabById(_settings.DeadEndId)!; // Check if End Room is already placed if (_placedRooms.Values.Any(r => r.Prefab.Id == _settings.EndRoomId)) { Console.WriteLine("End room already placed."); return; } Console.WriteLine("Attempting to place End Room..."); // Try to find an open connector suitable for the end room var suitableOpenings = _openList .SelectMany(room => room.GetOpenConnectors().Select(connector => new { Room = room, Connector = connector })) .Where(oc => CanConnect(endPrefab, oc.Connector)) .OrderBy(x => _random.Next()) .ToList(); foreach (var opening in suitableOpenings) { var compatibleEndConnectors = endPrefab.Connectors .Where(c => c.GetOppositeDirection() == opening.Connector.FacingDirection && c.Type == opening.Connector.Type) .OrderBy(x => _random.Next()) .ToList(); foreach(var endConnector in compatibleEndConnectors) { Point currentConnectorWorldPos = opening.Room.GetWorldConnectorPosition(opening.Connector); Point endRoomPosition = currentConnectorWorldPos - endConnector.RelativePosition; if (!_placedRooms.ContainsKey(endRoomPosition)) { RoomInstance? endRoom = PlaceRoom(endPrefab, endRoomPosition); if(endRoom != null) { ConnectRooms(opening.Room, opening.Connector, endRoom, endConnector); Console.WriteLine($"Successfully placed End Room connecting to {opening.Room.Prefab.Id} at {opening.Room.Position}."); return; // End room placed } } } } // If no suitable open connector found, try replacing a dead-end-like room // Find a room with only one connection (a leaf node in the graph, excluding start) Console.WriteLine("Could not find open connector for End Room. Trying to replace a leaf node..."); var leafRooms = _placedRooms.Values .Where(r => !r.Prefab.IsStartRoom && r.Connections.Values.Count(conn => conn != null) == 1) .OrderBy(x => _random.Next()) .ToList(); foreach(var leafRoom in leafRooms) { // Find the connector that IS connected and the room it connects to var connection = leafRoom.Connections.FirstOrDefault(kvp => kvp.Value != null); if(connection.Key == null || connection.Value == null) continue; // Should not happen for leaf rooms Connector connectedConnectorOnLeaf = connection.Key; RoomInstance neighbor = connection.Value; // Find the connector on the neighbor that connects back to the leaf room var neighborConnection = neighbor.Connections.FirstOrDefault(kvp => kvp.Value == leafRoom); if(neighborConnection.Key == null) continue; // Should not happen Connector connectorOnNeighbor = neighborConnection.Key; // Can the end room connect here? var compatibleEndConnectors = endPrefab.Connectors .Where(c => c.GetOppositeDirection() == connectorOnNeighbor.FacingDirection && c.Type == connectorOnNeighbor.Type) .OrderBy(x => _random.Next()) .ToList(); foreach(var endConnector in compatibleEndConnectors) { // Position will be the same as the leaf room we are replacing Point endRoomPosition = leafRoom.Position; // Remove the old leaf room _placedRooms.Remove(leafRoom.Position); _openList.Remove(leafRoom); // Ensure it's removed if it was there neighbor.Connections[connectorOnNeighbor] = null; // Re-open the neighbor's connector if (!_openList.Contains(neighbor) && neighbor.Prefab.Connectors.Any()) // Add neighbor back to open list if needed _openList.Add(neighbor); // Place the end room RoomInstance? endRoom = PlaceRoom(endPrefab, endRoomPosition); if(endRoom != null) { // Connect end room to neighbor ConnectRooms(neighbor, connectorOnNeighbor, endRoom, endConnector); Console.WriteLine($"Successfully replaced leaf room {leafRoom.Prefab.Id} with End Room at {endRoomPosition}."); // Cap any remaining connectors on the new end room CapRoomConnectors(endRoom, deadEndPrefab); return; // End room placed } else { // Failed to place end room? Put leaf back (though this indicates an issue) Console.WriteLine($"Error: Failed to place End Room even after removing leaf {leafRoom.Prefab.Id}. State might be inconsistent."); // Attempt to restore - might be complex if other things changed PlaceRoom(leafRoom.Prefab, leafRoom.Position); // Re-add leaf (might fail if pos now taken) ConnectRooms(neighbor, connectorOnNeighbor, leafRoom, connectedConnectorOnLeaf); // Reconnect return; } } } Console.WriteLine("Warning: Could not place the End Room."); } private bool TryCapRandomOpenConnector() { RoomPrefab deadEndPrefab = GetPrefabById(_settings.DeadEndId)!; if (deadEndPrefab == null || !deadEndPrefab.Connectors.Any()) { Console.WriteLine("Warning: DeadEnd prefab is missing or has no connectors. Cannot cap."); return false; } var openConnectors = _openList .SelectMany(room => room.GetOpenConnectors().Select(connector => new { Room = room, Connector = connector })) .OrderBy(x => _random.Next()) .ToList(); if (!openConnectors.Any()) return false; // No open connectors left var opening = openConnectors.First(); // Find a compatible connector on the dead end prefab var compatibleDeadEndConnectors = deadEndPrefab.Connectors .Where(c => c.GetOppositeDirection() == opening.Connector.FacingDirection && c.Type == opening.Connector.Type) .OrderBy(x => _random.Next()) .ToList(); if (!compatibleDeadEndConnectors.Any()) { Console.WriteLine($"Warning: No compatible connector found on DeadEnd prefab for connector {opening.Connector.FacingDirection} on {opening.Room.Prefab.Id}."); // Remove the problematic room/connector from open list to avoid infinite loops? // For now, just report and fail capping this one. opening.Room.Connections[opening.Connector] = opening.Room; // Mark as unusable (hacky) if (!opening.Room.GetOpenConnectors().Any()) _openList.Remove(opening.Room); return false; } var deadEndConnector = compatibleDeadEndConnectors.First(); Point currentConnectorWorldPos = opening.Room.GetWorldConnectorPosition(opening.Connector); Point deadEndPosition = currentConnectorWorldPos - deadEndConnector.RelativePosition; if (!_placedRooms.ContainsKey(deadEndPosition)) { RoomInstance? deadEndRoom = PlaceRoom(deadEndPrefab, deadEndPosition); if (deadEndRoom != null) { ConnectRooms(opening.Room, opening.Connector, deadEndRoom, deadEndConnector); // Dead ends usually have only one connector, so they shouldn't re-enter the open list. // If they had more, they'd need capping too. CapRoomConnectors(deadEndRoom, deadEndPrefab); // Cap any other connectors on the dead end itself // Console.WriteLine($"Capped connector on {opening.Room.Prefab.Id} at {opening.Room.Position} with DeadEnd."); return true; } } // If placing the dead end failed (collision?), mark the connector as unusable to avoid retrying infinitely opening.Room.Connections[opening.Connector] = opening.Room; // Mark as unusable (hacky) if (!opening.Room.GetOpenConnectors().Any()) _openList.Remove(opening.Room); Console.WriteLine($"Warning: Could not place DeadEnd at {deadEndPosition} due to collision or error."); return false; // Failed to place dead end } private void CapAllOpenConnectors() { Console.WriteLine("Capping remaining open connectors..."); RoomPrefab deadEndPrefab = GetPrefabById(_settings.DeadEndId)!; int cappedCount = 0; // Need to iterate carefully as capping modifies the _openList List initialOpenList = new List(_openList); foreach (var room in initialOpenList) { // Check if room is still in the main dictionary (might have been replaced by End Room) if (!_placedRooms.ContainsKey(room.Position) || _placedRooms[room.Position] != room) continue; // Cap connectors for *this specific instance* CapRoomConnectors(room, deadEndPrefab); } Console.WriteLine($"Capped {cappedCount} connectors."); } // Caps all open connectors on a specific room instance private void CapRoomConnectors(RoomInstance room, RoomPrefab deadEndPrefab) { if (deadEndPrefab == null || !deadEndPrefab.Connectors.Any()) return; // Cannot cap // Get remaining open connectors for *this* room instance // Important: Create a copy, as connecting modifies the original collection List openConnectors = room.GetOpenConnectors().ToList(); foreach (var connectorToCap in openConnectors) { // Double check if it's still open after previous capping operations on the same room if (room.Connections[connectorToCap] != null) continue; var compatibleDeadEndConnectors = deadEndPrefab.Connectors .Where(c => c.GetOppositeDirection() == connectorToCap.FacingDirection && c.Type == connectorToCap.Type) .OrderBy(x => _random.Next()) .ToList(); if (!compatibleDeadEndConnectors.Any()) continue; // Cannot cap this specific connector var deadEndConnector = compatibleDeadEndConnectors.First(); Point currentConnectorWorldPos = room.GetWorldConnectorPosition(connectorToCap); Point deadEndPosition = currentConnectorWorldPos - deadEndConnector.RelativePosition; if (!_placedRooms.ContainsKey(deadEndPosition)) { RoomInstance? deadEndRoom = PlaceRoom(deadEndPrefab, deadEndPosition); if (deadEndRoom != null) { ConnectRooms(room, connectorToCap, deadEndRoom, deadEndConnector); // Recursively cap the new dead end room itself if it somehow has > 1 connector CapRoomConnectors(deadEndRoom, deadEndPrefab); } } else { // Cannot place dead end due to collision. What to do? // Option 1: Leave it open (might look weird). // Option 2: Mark as blocked internally (prevents future generation attempts). // Option 3: Try alternative dead end prefabs if available. // For now, just log it. Console.WriteLine($"Warning: Could not cap connector {connectorToCap.FacingDirection} on {room.Prefab.Id} at {room.Position} - collision at {deadEndPosition}."); } } } private RoomPrefab? GetPrefabById(string id) { return _settings.AvailablePrefabs.FirstOrDefault(p => p.Id.Equals(id, StringComparison.OrdinalIgnoreCase)); } } // Example Usage class Program { static void Main(string[] args) { // 1. Define Room Prefabs var prefabs = CreatePrefabs(); // 2. Configure Settings var settings = new GenerationSettings { TargetRoomCount = 15, // Total rooms including start/end StartRoomId = "Start", EndRoomId = "End", DeadEndId = "DeadEnd", KeyRoomIds = new List { "KeyRoomA", "KeyRoomB" }, AvailablePrefabs = prefabs }; // 3. Create Generator and Generate var generator = new DungeonGenerator(settings); List generatedLayout = generator.Generate(); // 4. Output Results (Simple Text Representation) PrintLayout(generatedLayout); Console.WriteLine("\nGeneration Complete. Press Enter to exit."); Console.ReadLine(); } static List CreatePrefabs() { var list = new List(); // Start Room (1 connector North) var start = new RoomPrefab("Start", "Starting Room") { IsStartRoom = true }; start.AddConnector(new Point(0, 1), Direction.North); // Connector at top edge list.Add(start); // End Room (1 connector South) var end = new RoomPrefab("End", "Final Room") { IsEndRoom = true }; end.AddConnector(new Point(0, -1), Direction.South); // Connector at bottom edge list.Add(end); // Dead End (1 connector South - connects to a North-facing connector) var deadEnd = new RoomPrefab("DeadEnd", "Dead End") { IsDeadEnd = true }; deadEnd.AddConnector(new Point(0, -1), Direction.South); list.Add(deadEnd); // Corridor (North-South) var corridorNS = new RoomPrefab("CorridorNS", "Corridor N-S"); corridorNS.AddConnector(new Point(0, 1), Direction.North); corridorNS.AddConnector(new Point(0, -1), Direction.South); list.Add(corridorNS); // Corridor (East-West) var corridorEW = new RoomPrefab("CorridorEW", "Corridor E-W"); corridorEW.AddConnector(new Point(1, 0), Direction.East); corridorEW.AddConnector(new Point(-1, 0), Direction.West); list.Add(corridorEW); // T-Junction (Connectors S, E, W) var tjunction = new RoomPrefab("TJunction", "T-Junction"); tjunction.AddConnector(new Point(0, -1), Direction.South); tjunction.AddConnector(new Point(1, 0), Direction.East); tjunction.AddConnector(new Point(-1, 0), Direction.West); list.Add(tjunction); // L-Turn (Connectors N, E) var lTurnNE = new RoomPrefab("LTurnNE", "L-Turn N-E"); lTurnNE.AddConnector(new Point(0, 1), Direction.North); lTurnNE.AddConnector(new Point(1, 0), Direction.East); list.Add(lTurnNE); // 4-Way Intersection var cross = new RoomPrefab("Cross", "Intersection"); cross.AddConnector(new Point(0, 1), Direction.North); cross.AddConnector(new Point(0, -1), Direction.South); cross.AddConnector(new Point(1, 0), Direction.East); cross.AddConnector(new Point(-1, 0), Direction.West); list.Add(cross); // Key Room A (e.g., Office - Connectors N, S) var keyA = new RoomPrefab("KeyRoomA", "Office") { IsKeyRoom = true }; keyA.AddConnector(new Point(0, 1), Direction.North); keyA.AddConnector(new Point(0, -1), Direction.South); list.Add(keyA); // Key Room B (e.g., Lab - Connector E only) var keyB = new RoomPrefab("KeyRoomB", "Laboratory") { IsKeyRoom = true }; keyB.AddConnector(new Point(1, 0), Direction.East); list.Add(keyB); return list; } static void PrintLayout(List layout) { if (!layout.Any()) { Console.WriteLine("Layout is empty."); return; } Console.WriteLine("\nGenerated Layout:"); foreach (var room in layout.OrderBy(r => r.Position.Y).ThenBy(r => r.Position.X)) { Console.WriteLine($"- {room.Prefab.Name} ({room.Prefab.Id}) at {room.Position}"); foreach (var connection in room.Connections) { string targetDesc = connection.Value == null ? "OPEN" : $"{connection.Value.Prefab.Name} at {connection.Value.Position}"; Console.WriteLine($" - Connector {connection.Key.FacingDirection} @ Rel{connection.Key.RelativePosition} -> {targetDesc}"); } } // Basic Grid Visualization (optional, very simple) Console.WriteLine("\nSimple Grid View:"); var positions = layout.Select(r => r.Position).ToList(); if (!positions.Any()) return; int minX = positions.Min(p => p.X); int maxX = positions.Max(p => p.X); int minY = positions.Min(p => p.Y); int maxY = positions.Max(p => p.Y); for (int y = maxY; y >= minY; y--) { for (int x = minX; x <= maxX; x++) { var roomAtPos = layout.FirstOrDefault(r => r.Position.X == x && r.Position.Y == y); char displayChar = '.'; if (roomAtPos != null) { if (roomAtPos.Prefab.IsStartRoom) displayChar = 'S'; else if (roomAtPos.Prefab.IsEndRoom) displayChar = 'E'; else if (roomAtPos.Prefab.IsKeyRoom) displayChar = 'K'; else if (roomAtPos.Prefab.IsDeadEnd) displayChar = 'X'; else if (roomAtPos.Prefab.Connectors.Count == 4) displayChar = '+'; else if (roomAtPos.Prefab.Connectors.Count == 3) displayChar = 'T'; else if (roomAtPos.Prefab.Connectors.Count == 2) { // Check if connectors are opposite var dirs = roomAtPos.Prefab.Connectors.Select(c => c.FacingDirection).ToList(); if ((dirs.Contains(Direction.North) && dirs.Contains(Direction.South)) || (dirs.Contains(Direction.East) && dirs.Contains(Direction.West))) { displayChar = '|'; // Straight (could be - too) } else { displayChar = 'L'; // Corner } } else if (roomAtPos.Prefab.Connectors.Count == 1) displayChar = 'o'; // Should be DeadEnd 'X' mostly else displayChar = '?'; // Unknown } Console.Write(displayChar + " "); } Console.WriteLine(); } } } } ```csharp using System; using System.Collections.Generic; using System.Linq; namespace RoomGenerator { // Represents a connection point on a room prefab public class Connector { public Point RelativePosition { get; } public Direction FacingDirection { get; } public string Type { get; } // e.g., "StandardDoor", "LargeOpening" - for potential future rules public Connector(Point relativePosition, Direction facingDirection, string type = "StandardDoor") { RelativePosition = relativePosition; FacingDirection = facingDirection; Type = type; } // Gets the direction opposite to the connector's facing direction public Direction GetOppositeDirection() { return FacingDirection switch { Direction.North => Direction.South, Direction.South => Direction.North, Direction.East => Direction.West, Direction.West => Direction.East, _ => throw new ArgumentOutOfRangeException() }; } } // Represents a type of room or corridor public class RoomPrefab { public string Id { get; } public string Name { get; } public List Connectors { get; } = new List(); public bool IsStartRoom { get; set; } = false; public bool IsEndRoom { get; set; } = false; public bool IsKeyRoom { get; set; } = false; // Must spawn exactly once public bool IsDeadEnd { get; set; } = false; // Used to cap open connectors public RoomPrefab(string id, string name) { Id = id; Name = name; } public void AddConnector(Point relativePosition, Direction facingDirection, string type = "StandardDoor") { Connectors.Add(new Connector(relativePosition, facingDirection, type)); } } // Represents an instance of a placed room in the generated layout public class RoomInstance { public RoomPrefab Prefab { get; } public Point Position { get; } // Absolute position in the grid public Dictionary Connections { get; } = new Dictionary(); // Maps local connector to connected room instance public RoomInstance(RoomPrefab prefab, Point position) { Prefab = prefab; Position = position; foreach (var connector in prefab.Connectors) { Connections.Add(connector, null); // Initialize all connections as open (null) } } public IEnumerable GetOpenConnectors() { // Ensure we only return connectors that are actually open (value is null) return Connections.Where(kvp => kvp.Value == null).Select(kvp => kvp.Key); } public Point GetWorldConnectorPosition(Connector localConnector) { // Simple addition for now, assuming no rotation. Rotation would require transformation. return new Point(Position.X + localConnector.RelativePosition.X, Position.Y + localConnector.RelativePosition.Y); } } // Simple 2D Point struct public struct Point : IEquatable { public int X { get; } public int Y { get; } public Point(int x, int y) { X = x; Y = y; } public override bool Equals(object? obj) => obj is Point other && Equals(other); public bool Equals(Point other) => X == other.X && Y == other.Y; public override int GetHashCode() => HashCode.Combine(X, Y); public static bool operator ==(Point left, Point right) => left.Equals(right); public static bool operator !=(Point left, Point right) => !(left == right); public override string ToString() => $"({X}, {Y})"; public static Point operator +(Point a, Point b) => new Point(a.X + b.X, a.Y + b.Y); public static Point operator -(Point a, Point b) => new Point(a.X - b.X, a.Y - b.Y); } // Cardinal directions public enum Direction { North, // +Y South, // -Y East, // +X West // -X } // Settings for the generator public class GenerationSettings { public int TargetRoomCount { get; set; } = 10; public string StartRoomId { get; set; } = "Start"; public string EndRoomId { get; set; } = "End"; public string DeadEndId { get; set; } = "DeadEnd"; public List KeyRoomIds { get; set; } = new List(); public List AvailablePrefabs { get; set; } = new List(); } // Main generator class public class DungeonGenerator { private readonly GenerationSettings _settings; private readonly Random _random = new Random(); private readonly Dictionary _placedRooms = new Dictionary(); private readonly List _openList = new List(); // Rooms with open connectors private readonly HashSet _placedKeyRooms = new HashSet(); private readonly HashSet _requiredKeyRooms; private int _capAttemptCounter = 0; // To prevent infinite capping loops public DungeonGenerator(GenerationSettings settings) { _settings = settings ?? throw new ArgumentNullException(nameof(settings)); _requiredKeyRooms = new HashSet(_settings.KeyRoomIds ?? new List()); // Validate settings if (_settings.AvailablePrefabs == null || !_settings.AvailablePrefabs.Any()) throw new ArgumentException("AvailablePrefabs cannot be null or empty.", nameof(settings)); if (GetPrefabById(_settings.StartRoomId) == null) throw new ArgumentException($"Start room prefab with ID '{_settings.StartRoomId}' not found.", nameof(settings)); if (GetPrefabById(_settings.EndRoomId) == null) throw new ArgumentException($"End room prefab with ID '{_settings.EndRoomId}' not found.", nameof(settings)); if (GetPrefabById(_settings.DeadEndId) == null) throw new ArgumentException($"Dead end prefab with ID '{_settings.DeadEndId}' not found.", nameof(settings)); foreach (var keyId in _requiredKeyRooms) { if (GetPrefabById(keyId) == null) throw new ArgumentException($"Key room prefab with ID '{keyId}' not found.", nameof(settings)); } } public List Generate() { _placedRooms.Clear(); _openList.Clear(); _placedKeyRooms.Clear(); _capAttemptCounter = 0; // 1. Place Start Room RoomPrefab startPrefab = GetPrefabById(_settings.StartRoomId)!; PlaceRoom(startPrefab, new Point(0, 0)); // 2. Main Generation Loop int iterations = 0; int maxIterations = _settings.TargetRoomCount * 5; // Safety break while (_placedRooms.Count < _settings.TargetRoomCount && _openList.Any() && iterations < maxIterations) { iterations++; if (!TryPlaceNextRoom()) { // Could not place a room from any open connector, try capping one if (!TryCapRandomOpenConnector()) { // If capping also fails (e.g., no open connectors left), break Console.WriteLine("Warning: Could not place more rooms or cap connectors. Generation might be incomplete."); break; } } } if (iterations >= maxIterations) { Console.WriteLine("Warning: Reached max generation iterations. Terminating loop."); } // 3. Ensure All Key Rooms are Placed (if possible) EnsureKeyRoomsPlaced(); // 4. Ensure End Room is Placed (replace last or add if possible) EnsureEndRoomPlaced(); // 5. Cap Remaining Open Connectors CapAllOpenConnectors(); Console.WriteLine($"Generation finished. Placed {_placedRooms.Count} rooms."); return _placedRooms.Values.ToList(); } private bool TryPlaceNextRoom() { List shuffledOpenList = _openList.OrderBy(x => _random.Next()).ToList(); foreach (var currentRoom in shuffledOpenList) { // Ensure the room still exists and is in the open list before processing if (!_placedRooms.ContainsKey(currentRoom.Position) || !_openList.Contains(currentRoom)) continue; List shuffledConnectors = currentRoom.GetOpenConnectors().OrderBy(x => _random.Next()).ToList(); foreach (var connectorToUse in shuffledConnectors) { List possiblePrefabs = GetPossiblePrefabs(currentRoom, connectorToUse); possiblePrefabs = possiblePrefabs.OrderBy(x => _random.Next()).ToList(); foreach (var prefabToPlace in possiblePrefabs) { // Find a compatible connector on the new prefab var compatibleConnectors = prefabToPlace.Connectors .Where(c => c.GetOppositeDirection() == connectorToUse.FacingDirection && c.Type == connectorToUse.Type) // Basic compatibility check .OrderBy(x => _random.Next()) .ToList(); foreach (var newRoomConnector in compatibleConnectors) { Point currentConnectorWorldPos = currentRoom.GetWorldConnectorPosition(connectorToUse); // Calculate position assuming no rotation: WorldPos = TargetWorldPos - NewRoomLocalConnectorPos Point newRoomPosition = currentConnectorWorldPos - newRoomConnector.RelativePosition; if (!_placedRooms.ContainsKey(newRoomPosition)) // Check for collision at the room's origin { // More sophisticated collision check needed for rooms larger than 1x1 // For now, just check the origin point. RoomInstance? newRoom = PlaceRoom(prefabToPlace, newRoomPosition); if (newRoom != null) { // Connect rooms ConnectRooms(currentRoom, connectorToUse, newRoom, newRoomConnector); return true; // Successfully placed a room } } } } } } return false; // Could not place any room from any open connector } private List GetPossiblePrefabs(RoomInstance currentRoom, Connector connectorToUse) { List candidates = new List(); bool placeKeyRoom = _requiredKeyRooms.Count > _placedKeyRooms.Count && _random.Next(0, 3) == 0; // Chance to place a required key room // Prioritize placing required key rooms if flag is set and one is available if (placeKeyRoom) { string? keyToPlace = _requiredKeyRooms.Except(_placedKeyRooms).OrderBy(x => _random.Next()).FirstOrDefault(); if (keyToPlace != null) { RoomPrefab? keyPrefab = GetPrefabById(keyToPlace); if (keyPrefab != null && CanConnect(keyPrefab, connectorToUse)) { candidates.Add(keyPrefab); // If we add a key room candidate, return immediately to prioritize it. return candidates; } } } // Add regular rooms (non-special, non-key, non-dead-end) candidates.AddRange(_settings.AvailablePrefabs .Where(p => !p.IsStartRoom && !p.IsEndRoom && !p.IsKeyRoom && !p.IsDeadEnd && CanConnect(p, connectorToUse)) ); // Avoid placing the end room too early unless near target count or forced bool allowEndRoom = _placedRooms.Count >= _settings.TargetRoomCount - 2 || !_openList.Any(); // Allow end room near the end or if stuck if (allowEndRoom) { RoomPrefab? endPrefab = GetPrefabById(_settings.EndRoomId); // Ensure end isn't start and can connect if(endPrefab != null && !endPrefab.IsStartRoom && CanConnect(endPrefab, connectorToUse)) { candidates.Add(endPrefab); } } // Filter out already placed unique key rooms (should be redundant if priority logic works, but safe) candidates.RemoveAll(p => p.IsKeyRoom && _placedKeyRooms.Contains(p.Id)); return candidates.Distinct().ToList(); // Ensure uniqueness } // Basic check if a prefab has *any* connector compatible with the target connector private bool CanConnect(RoomPrefab prefab, Connector targetConnector) { return prefab.Connectors.Any(c => c.GetOppositeDirection() == targetConnector.FacingDirection && c.Type == targetConnector.Type); } private RoomInstance? PlaceRoom(RoomPrefab prefab, Point position) { if (_placedRooms.ContainsKey(position)) { // Console.WriteLine($"Error: Attempted to place room {prefab.Id} at occupied position {position}."); return null; // Collision } // More complex collision check needed here if rooms occupy more than one grid cell RoomInstance newInstance = new RoomInstance(prefab, position); _placedRooms.Add(position, newInstance); if (prefab.IsKeyRoom) { _placedKeyRooms.Add(prefab.Id); // Key rooms might still have open connectors } // Add to open list ONLY if it has OPEN connectors initially if (newInstance.GetOpenConnectors().Any()) { // Ensure it's not already in the list before adding if (!_openList.Contains(newInstance)) { _openList.Add(newInstance); } } // Console.WriteLine($"Placed {prefab.Id} at {position}"); return newInstance; } private void ConnectRooms(RoomInstance roomA, Connector connectorA, RoomInstance roomB, Connector connectorB) { // Ensure rooms and connectors are valid before proceeding if (roomA == null || connectorA == null || roomB == null || connectorB == null) { Console.WriteLine("Warning: Null reference passed to ConnectRooms."); return; } if (!roomA.Connections.ContainsKey(connectorA)) { Console.WriteLine($"Warning: ConnectorA ({connectorA.FacingDirection} @ {connectorA.RelativePosition}) not found on Room A ({roomA.Prefab.Id}) during connection."); return; } if (!roomB.Connections.ContainsKey(connectorB)) { Console.WriteLine($"Warning: ConnectorB ({connectorB.FacingDirection} @ {connectorB.RelativePosition}) not found on Room B ({roomB.Prefab.Id}) during connection."); return; } // Perform connection roomA.Connections[connectorA] = roomB; roomB.Connections[connectorB] = roomA; // If a room has no more open connectors, remove it from the open list if (!roomA.GetOpenConnectors().Any()) _openList.Remove(roomA); if (!roomB.GetOpenConnectors().Any()) _openList.Remove(roomB); // Console.WriteLine($"Connected {roomA.Prefab.Id}@{roomA.Position} via {connectorA.FacingDirection} to {roomB.Prefab.Id}@{roomB.Position} via {connectorB.FacingDirection}"); } private void EnsureKeyRoomsPlaced() { var missingKeys = _requiredKeyRooms.Except(_placedKeyRooms).ToList(); if (!missingKeys.Any()) return; Console.WriteLine($"Attempting to place missing key rooms: {string.Join(", ", missingKeys)}"); foreach (var keyId in missingKeys) { RoomPrefab? keyPrefab = GetPrefabById(keyId); if (keyPrefab == null) continue; bool placed = false; // Try attaching to any open connector var suitableOpenings = _openList .SelectMany(room => room.GetOpenConnectors().Select(connector => new { Room = room, Connector = connector })) .Where(oc => CanConnect(keyPrefab, oc.Connector)) .OrderBy(x => _random.Next()) .ToList(); foreach (var opening in suitableOpenings) { var compatibleKeyConnectors = keyPrefab.Connectors .Where(c => c.GetOppositeDirection() == opening.Connector.FacingDirection && c.Type == opening.Connector.Type) .OrderBy(x => _random.Next()) .ToList(); foreach(var keyConnector in compatibleKeyConnectors) { Point currentConnectorWorldPos = opening.Room.GetWorldConnectorPosition(opening.Connector); Point keyRoomPosition = currentConnectorWorldPos - keyConnector.RelativePosition; if (!_placedRooms.ContainsKey(keyRoomPosition)) { RoomInstance? keyRoom = PlaceRoom(keyPrefab, keyRoomPosition); if(keyRoom != null) { ConnectRooms(opening.Room, opening.Connector, keyRoom, keyConnector); Console.WriteLine($"Successfully placed missing key room {keyId} connecting to {opening.Room.Prefab.Id} at {opening.Room.Position}."); placed = true; break; // Key room placed, move to next missing key } } } if (placed) break; } if (!placed) { Console.WriteLine($"Warning: Could not find a suitable location to place missing key room {keyId}."); // Consider more drastic measures? Replace an existing non-essential room? For now, just warn. } } } private void EnsureEndRoomPlaced() { RoomPrefab endPrefab = GetPrefabById(_settings.EndRoomId)!; RoomPrefab deadEndPrefab = GetPrefabById(_settings.DeadEndId)!; // Check if End Room is already placed if (_placedRooms.Values.Any(r => r.Prefab.Id == _settings.EndRoomId)) { // Console.WriteLine("End room already placed."); return; } Console.WriteLine("Attempting to place End Room..."); // Try to find an open connector suitable for the end room var suitableOpenings = _openList .SelectMany(room => room.GetOpenConnectors().Select(connector => new { Room = room, Connector = connector })) .Where(oc => CanConnect(endPrefab, oc.Connector)) .OrderBy(x => _random.Next()) .ToList(); foreach (var opening in suitableOpenings) { // Check if the room instance still exists and is valid if (!_placedRooms.ContainsKey(opening.Room.Position) || !_openList.Contains(opening.Room)) continue; // Check if the specific connector is still open if (opening.Room.Connections[opening.Connector] != null) continue; var compatibleEndConnectors = endPrefab.Connectors .Where(c => c.GetOppositeDirection() == opening.Connector.FacingDirection && c.Type == opening.Connector.Type) .OrderBy(x => _random.Next()) .ToList(); foreach(var endConnector in compatibleEndConnectors) { Point currentConnectorWorldPos = opening.Room.GetWorldConnectorPosition(opening.Connector); Point endRoomPosition = currentConnectorWorldPos - endConnector.RelativePosition; if (!_placedRooms.ContainsKey(endRoomPosition)) { RoomInstance? endRoom = PlaceRoom(endPrefab, endRoomPosition); if(endRoom != null) { ConnectRooms(opening.Room, opening.Connector, endRoom, endConnector); Console.WriteLine($"Successfully placed End Room connecting to {opening.Room.Prefab.Id} at {opening.Room.Position}."); // Cap any remaining connectors on the new end room immediately CapRoomConnectors(endRoom, deadEndPrefab); return; // End room placed } } } } // If no suitable open connector found, try replacing a dead-end-like room // Find a room with only one connection (a leaf node in the graph, excluding start/key rooms) Console.WriteLine("Could not find open connector for End Room. Trying to replace a leaf node..."); var leafRooms = _placedRooms.Values .Where(r => !r.Prefab.IsStartRoom && !r.Prefab.IsKeyRoom && !r.Prefab.IsEndRoom && // Exclude special rooms r.Connections.Values.Count(conn => conn != null) == 1) // Exactly one connection .OrderBy(x => _random.Next()) .ToList(); foreach(var leafRoom in leafRooms) { // Ensure leaf room still exists if (!_placedRooms.ContainsKey(leafRoom.Position)) continue; // Find the connector that IS connected and the room it connects to var connection = leafRoom.Connections.FirstOrDefault(kvp => kvp.Value != null); if(connection.Key == null || connection.Value == null) continue; // Should not happen for leaf rooms Connector connectedConnectorOnLeaf = connection.Key; RoomInstance neighbor = connection.Value; // Ensure neighbor still exists if (!_placedRooms.ContainsKey(neighbor.Position)) continue; // Find the connector on the neighbor that connects back to the leaf room var neighborConnection = neighbor.Connections.FirstOrDefault(kvp => kvp.Value == leafRoom); if(neighborConnection.Key == null) continue; // Should not happen Connector connectorOnNeighbor = neighborConnection.Key; // Can the end room connect here? var compatibleEndConnectors = endPrefab.Connectors .Where(c => c.GetOppositeDirection() == connectorOnNeighbor.FacingDirection && c.Type == connectorOnNeighbor.Type) .OrderBy(x => _random.Next()) .ToList(); foreach(var endConnector in compatibleEndConnectors) { // Position will be the same as the leaf room we are replacing Point endRoomPosition = leafRoom.Position; // Remove the old leaf room _placedRooms.Remove(leafRoom.Position); _openList.Remove(leafRoom); // Ensure it's removed if it was there neighbor.Connections[connectorOnNeighbor] = null; // Re-open the neighbor's connector // Add neighbor back to open list if needed and not already there if (!_openList.Contains(neighbor) && neighbor.GetOpenConnectors().Any()) _openList.Add(neighbor); // Place the end room RoomInstance? endRoom = PlaceRoom(endPrefab, endRoomPosition); if(endRoom != null) { // Connect end room to neighbor ConnectRooms(neighbor, connectorOnNeighbor, endRoom, endConnector); Console.WriteLine($"Successfully replaced leaf room {leafRoom.Prefab.Id} with End Room at {endRoomPosition}."); // Cap any remaining connectors on the new end room CapRoomConnectors(endRoom, deadEndPrefab); return; // End room placed } else { // Failed to place end room? Put leaf back (though this indicates an issue) Console.WriteLine($"Error: Failed to place End Room even after removing leaf {leafRoom.Prefab.Id}. Attempting to restore leaf."); // Attempt to restore - might fail if pos now taken by something else unexpectedly RoomInstance? restoredLeaf = PlaceRoom(leafRoom.Prefab, leafRoom.Position); if (restoredLeaf != null) { ConnectRooms(neighbor, connectorOnNeighbor, restoredLeaf, connectedConnectorOnLeaf); } else { Console.WriteLine($"Error: Could not restore leaf room {leafRoom.Prefab.Id}. Dungeon state may be inconsistent."); // Mark neighbor's connector as blocked? neighbor.Connections[connectorOnNeighbor] = neighbor; // Hacky block if (!neighbor.GetOpenConnectors().Any()) _openList.Remove(neighbor); } // Continue trying other leaf rooms or connectors break; // Stop trying connectors for this leaf, move to next leaf } } } Console.WriteLine("Warning: Could not place the End Room via open connectors or leaf replacement."); } private bool TryCapRandomOpenConnector() { _capAttemptCounter++; if (_capAttemptCounter > _placedRooms.Count * 5) // Prevent infinite loops if capping always fails { Console.WriteLine("Warning: Exceeded maximum cap attempts. Stopping capping."); return false; } RoomPrefab deadEndPrefab = GetPrefabById(_settings.DeadEndId)!; if (deadEndPrefab == null || !deadEndPrefab.Connectors.Any()) { Console.WriteLine("Warning: DeadEnd prefab is missing or has no connectors. Cannot cap."); return false; } var openConnectors = _openList .SelectMany(room => room.GetOpenConnectors().Select(connector => new { Room = room, Connector = connector })) .OrderBy(x => _random.Next()) .ToList(); if (!openConnectors.Any()) return false; // No open connectors left foreach(var opening in openConnectors) { // Check if the room instance still exists and is valid if (!_placedRooms.ContainsKey(opening.Room.Position) || !_openList.Contains(opening.Room)) continue; // Check if the specific connector is still open if (opening.Room.Connections[opening.Connector] != null) continue; // Find a compatible connector on the dead end prefab var compatibleDeadEndConnectors = deadEndPrefab.Connectors .Where(c => c.GetOppositeDirection() == opening.Connector.FacingDirection && c.Type == opening.Connector.Type) .OrderBy(x => _random.Next()) .ToList(); if (!compatibleDeadEndConnectors.Any()) { // Console.WriteLine($"Warning: No compatible connector found on DeadEnd prefab for connector {opening.Connector.FacingDirection} on {opening.Room.Prefab.Id}."); // Mark as unusable? For now, just skip this connector. continue; // Try next open connector } var deadEndConnector = compatibleDeadEndConnectors.First(); Point currentConnectorWorldPos = opening.Room.GetWorldConnectorPosition(opening.Connector); Point deadEndPosition = currentConnectorWorldPos - deadEndConnector.RelativePosition; if (!_placedRooms.ContainsKey(deadEndPosition)) { RoomInstance? deadEndRoom = PlaceRoom(deadEndPrefab, deadEndPosition); if (deadEndRoom != null) { ConnectRooms(opening.Room, opening.Connector, deadEndRoom, deadEndConnector); // Dead ends usually have only one connector, so they shouldn't re-enter the open list. // If they had more, they'd need capping too. CapRoomConnectors(deadEndRoom, deadEndPrefab); // Cap any other connectors on the dead end itself // Console.WriteLine($"Capped connector on {opening.Room.Prefab.Id} at {opening.Room.Position} with DeadEnd."); return true; // Successfully capped one connector } else { Console.WriteLine($"Warning: Could not place DeadEnd at {deadEndPosition} even though position was free. Prefab issue?"); } } else { // Collision - cannot place dead end here. // Console.WriteLine($"Skipping cap for {opening.Room.Prefab.Id} connector {opening.Connector.FacingDirection} due to collision at {deadEndPosition}."); } } // If we loop through all open connectors and fail to cap any Console.WriteLine("Warning: Failed to cap any open connector in this attempt."); // Mark a random open connector as blocked to prevent infinite loops? Risky. // For now, just return false. The main loop might terminate. return false; } private void CapAllOpenConnectors() { Console.WriteLine("Capping remaining open connectors..."); RoomPrefab deadEndPrefab = GetPrefabById(_settings.DeadEndId)!; int cappedCount = 0; int capAllLoopCounter = 0; int maxCapLoops = _placedRooms.Count * 2; // Safety break // Keep capping until the open list is empty or we hit the safety break while (_openList.Any() && capAllLoopCounter < maxCapLoops) { capAllLoopCounter++; bool cappedThisRound = false; // Need to iterate carefully as capping modifies the _openList List currentOpenList = new List(_openList); foreach (var room in currentOpenList) { // Check if room is still in the main dictionary and in the open list if (!_placedRooms.ContainsKey(room.Position) || !_openList.Contains(room)) continue; // Cap connectors for *this specific instance* if (CapRoomConnectors(room, deadEndPrefab)) { cappedThisRound = true; cappedCount++; // Count successful caps } } if (!cappedThisRound && _openList.Any()) { // If we went through all rooms and couldn't cap anything, but list is not empty, something is wrong. Console.WriteLine($"Warning: CapAllOpenConnectors - No connectors capped this round, but open list size is {_openList.Count}. Breaking cap loop."); // Mark remaining open connectors as blocked? foreach(var room in new List(_openList)) { foreach(var connector in room.GetOpenConnectors().ToList()) { room.Connections[connector] = room; // Hacky block } _openList.Remove(room); // Force remove } break; } } if (capAllLoopCounter >= maxCapLoops) { Console.WriteLine("Warning: Reached max loops in CapAllOpenConnectors. Some connectors might remain open."); } Console.WriteLine($"Capped {cappedCount} connectors during final capping phase."); } // Caps all open connectors on a specific room instance. Returns true if any cap was successful. private bool CapRoomConnectors(RoomInstance room, RoomPrefab deadEndPrefab) { if (deadEndPrefab == null || !deadEndPrefab.Connectors.Any()) return false; // Cannot cap bool cappedAny = false; // Get remaining open connectors for *this* room instance // Important: Create a copy, as connecting modifies the original collection List openConnectors = room.GetOpenConnectors().ToList(); foreach (var connectorToCap in openConnectors) { // Double check if it's still open (might have been capped by connecting the other side of a dead end) if (room.Connections[connectorToCap] != null) continue; var compatibleDeadEndConnectors = deadEndPrefab.Connectors .Where(c => c.GetOppositeDirection() == connectorToCap.FacingDirection && c.Type == connectorToCap.Type) .OrderBy(x => _random.Next()) .ToList(); if (!compatibleDeadEndConnectors.Any()) continue; // Cannot cap this specific connector type/direction var deadEndConnector = compatibleDeadEndConnectors.First(); Point currentConnectorWorldPos = room.GetWorldConnectorPosition(connectorToCap); Point deadEndPosition = currentConnectorWorldPos - deadEndConnector.RelativePosition; if (!_placedRooms.ContainsKey(deadEndPosition)) { RoomInstance? deadEndRoom = PlaceRoom(deadEndPrefab, deadEndPosition); if (deadEndRoom != null) { ConnectRooms(room, connectorToCap, deadEndRoom, deadEndConnector); cappedAny = true; // Recursively cap the new dead end room itself if it somehow has > 1 connector // This might lead to deep recursion, limit depth? Or handle iteratively. // For now, call it directly, assuming dead ends are simple. CapRoomConnectors(deadEndRoom, deadEndPrefab); } } else { // Cannot place dead end due to collision. // Console.WriteLine($"Warning: Could not cap connector {connectorToCap.FacingDirection} on {room.Prefab.Id} at {room.Position} - collision at {deadEndPosition}."); // Mark connector as blocked? // room.Connections[connectorToCap] = room; // Hacky block // if (!room.GetOpenConnectors().Any()) _openList.Remove(room); } } return cappedAny; } private RoomPrefab? GetPrefabById(string id) { return _settings.AvailablePrefabs.FirstOrDefault(p => p.Id.Equals(id, StringComparison.OrdinalIgnoreCase)); } } // Example Usage class Program { static void Main(string[] args) { // 1. Define Room Prefabs var prefabs = CreatePrefabs(); // 2. Configure Settings var settings = new GenerationSettings { TargetRoomCount = 20, // Total rooms including start/end StartRoomId = "Start", EndRoomId = "End", DeadEndId = "DeadEnd", KeyRoomIds = new List { "KeyRoomA", "KeyRoomB" }, AvailablePrefabs = prefabs }; // 3. Create Generator and Generate var generator = new DungeonGenerator(settings); List generatedLayout = generator.Generate(); // 4. Output Results (Simple Text Representation) PrintLayout(generatedLayout); Console.WriteLine("\nGeneration Complete. Press Enter to exit."); Console.ReadLine(); } static List CreatePrefabs() { var list = new List(); // --- Special Rooms --- // Start Room (1 connector North) var start = new RoomPrefab("Start", "Starting Room") { IsStartRoom = true }; start.AddConnector(new Point(0, 1), Direction.North); // Connector at top edge relative to origin (0,0) list.Add(start); // End Room (1 connector South) var end = new RoomPrefab("End", "Final Room") { IsEndRoom = true }; end.AddConnector(new Point(0, -1), Direction.South); // Connector at bottom edge relative to origin (0,0) list.Add(end); // Dead End (1 connector South - connects to a North-facing connector) var deadEnd = new RoomPrefab("DeadEnd", "Dead End") { IsDeadEnd = true }; deadEnd.AddConnector(new Point(0, -1), Direction.South); // Assumes it connects *from* the south side of the room it attaches to list.Add(deadEnd); // --- Corridor Pieces --- // Corridor (North-South) var corridorNS = new RoomPrefab("CorridorNS", "Corridor N-S"); corridorNS.AddConnector(new Point(0, 1), Direction.North); corridorNS.AddConnector(new Point(0, -1), Direction.South); list.Add(corridorNS); // Corridor (East-West) var corridorEW = new RoomPrefab("CorridorEW", "Corridor E-W"); corridorEW.AddConnector(new Point(1, 0), Direction.East); corridorEW.AddConnector(new Point(-1, 0), Direction.West); list.Add(corridorEW); // --- Junctions / Turns --- // T-Junction (Connectors N, E, W - Open South) var tJunctionNEW = new RoomPrefab("TJunctionNEW", "T-Junction (Open S)"); tJunctionNEW.AddConnector(new Point(0, 1), Direction.North); tJunctionNEW.AddConnector(new Point(1, 0), Direction.East); tJunctionNEW.AddConnector(new Point(-1, 0), Direction.West); list.Add(tJunctionNEW); // T-Junction (Connectors S, E, W - Open North) var tJunctionSEW = new RoomPrefab("TJunctionSEW", "T-Junction (Open N)"); tJunctionSEW.AddConnector(new Point(0, -1), Direction.South); tJunctionSEW.AddConnector(new Point(1, 0), Direction.East); tJunctionSEW.AddConnector(new Point(-1, 0), Direction.West); list.Add(tJunctionSEW); // L-Turn (Connectors N, E - Open SW) var lTurnNE = new RoomPrefab("LTurnNE", "L-Turn N-E"); lTurnNE.AddConnector(new Point(0, 1), Direction.North); lTurnNE.AddConnector(new Point(1, 0), Direction.East); list.Add(lTurnNE); // L-Turn (Connectors N, W - Open SE) var lTurnNW = new RoomPrefab("LTurnNW", "L-Turn N-W"); lTurnNW.AddConnector(new Point(0, 1), Direction.North); lTurnNW.AddConnector(new Point(-1, 0), Direction.West); list.Add(lTurnNW); // L-Turn (Connectors S, E - Open NW) var lTurnSE = new RoomPrefab("LTurnSE", "L-Turn S-E"); lTurnSE.AddConnector(new Point(0, -1), Direction.South); lTurnSE.AddConnector(new Point(1, 0), Direction.East); list.Add(lTurnSE); // L-Turn (Connectors S, W - Open NE) var lTurnSW = new RoomPrefab("LTurnSW", "L-Turn S-W"); lTurnSW.AddConnector(new Point(0, -1), Direction.South); lTurnSW.AddConnector(new Point(-1, 0), Direction.West); list.Add(lTurnSW); // 4-Way Intersection var cross = new RoomPrefab("Cross", "Intersection"); cross.AddConnector(new Point(0, 1), Direction.North); cross.AddConnector(new Point(0, -1), Direction.South); cross.AddConnector(new Point(1, 0), Direction.East); cross.AddConnector(new Point(-1, 0), Direction.West); list.Add(cross); // --- Key Rooms --- // Key Room A (e.g., Office - Connectors N, S) var keyA = new RoomPrefab("KeyRoomA", "Office") { IsKeyRoom = true }; keyA.AddConnector(new Point(0, 1), Direction.North); keyA.AddConnector(new Point(0, -1), Direction.South); list.Add(keyA); // Key Room B (e.g., Lab - Connector E only) var keyB = new RoomPrefab("KeyRoomB", "Laboratory") { IsKeyRoom = true }; keyB.AddConnector(new Point(1, 0), Direction.East); list.Add(keyB); return list; } static void PrintLayout(List layout) { if (layout == null || !layout.Any()) { Console.WriteLine("Layout is empty or null."); return; } Console.WriteLine("\nGenerated Layout Details:"); foreach (var room in layout.OrderBy(r => r.Position.Y).ThenBy(r => r.Position.X)) { Console.WriteLine($"- {room.Prefab.Name} ({room.Prefab.Id}) at {room.Position}"); foreach (var connection in room.Connections) { string targetDesc; if (connection.Value == null) targetDesc = "OPEN"; else if (connection.Value == room) targetDesc = "BLOCKED"; // Show blocked connectors if using that hack else targetDesc = $"{connection.Value.Prefab.Name} at {connection.Value.Position}"; Console.WriteLine($" - Connector {connection.Key.FacingDirection} @ Rel{connection.Key.RelativePosition} -> {targetDesc}"); } } // Basic Grid Visualization Console.WriteLine("\nSimple Grid View:"); var positions = layout.Select(r => r.Position).ToList(); if (!positions.Any()) return; int minX = positions.Min(p => p.X); int maxX = positions.Max(p => p.X); int minY = positions.Min(p => p.Y); int maxY = positions.Max(p => p.Y); // Add padding around the grid minX -= 1; maxX += 1; minY -= 1; maxY += 1; for (int y = maxY; y >= minY; y--) { Console.Write($"{y,3} "); // Row number for (int x = minX; x <= maxX; x++) { var roomAtPos = layout.FirstOrDefault(r => r.Position.X == x && r.Position.Y == y); char displayChar = '.'; // Empty space if (roomAtPos != null) { if (roomAtPos.Prefab.IsStartRoom) displayChar = 'S'; else if (roomAtPos.Prefab.IsEndRoom) displayChar = 'E'; else if (roomAtPos.Prefab.IsKeyRoom) displayChar = 'K'; else if (roomAtPos.Prefab.IsDeadEnd) displayChar = 'X'; else if (roomAtPos.Prefab.Connectors.Count == 4) displayChar = '+'; else if (roomAtPos.Prefab.Connectors.Count == 3) displayChar = 'T'; else if (roomAtPos.Prefab.Connectors.Count == 2) { // Check if connectors are opposite var dirs = roomAtPos.Prefab.Connectors.Select(c => c.FacingDirection).ToList(); if ((dirs.Contains(Direction.North) && dirs.Contains(Direction.South))) displayChar = '|'; else if ((dirs.Contains(Direction.East) && dirs.Contains(Direction.West))) displayChar = '-'; else displayChar = 'L'; // Corner } else if (roomAtPos.Prefab.Connectors.Count == 1) displayChar = 'o'; // Should be DeadEnd 'X' or Start/End else displayChar = '?'; // 0 connectors? Should not happen for placed rooms other than maybe a special case. } Console.Write($" {displayChar} "); // Add spacing for better readability } Console.WriteLine(); } // Print X-axis numbers Console.Write(" "); // Align with grid start for (int x = minX; x <= maxX; x++) { Console.Write($"{x,3}"); } Console.WriteLine(); } } } ```