room positioning and door generator

Scripts/Controllers/RogueliteRoomManager.cs

@@ -1,4 +1,6 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
+using Cirno.Scripts.Enums;
 using Cirno.Scripts.Resources.Roguelite;
 using Godot;
 using Godot.Collections;
@@ -10,13 +12,27 @@ public partial class RogueliteRoomManager : Node2D
     [Export] public Array<RogueliteRoomResource> Rooms { get; set; }
     
     [Export] public Node2D SceneContainer { get; set; }
+    
+    private Godot.Collections.Dictionary<Vector2I, RogueliteRoomResource> _grid = new();
+    [Export] public int DungeonWidth = 10;
+    [Export] public int DungeonHeight = 10;
+    [Export] public int MaxRooms = 12;
+    //[Export] public int Seed = -1;
 
+    [Export] public Vector2I TileSize { get; set; } = new Vector2I(16, 16);
+    [Export] public Vector2I RoomSizeInTiles { get; set; } = new Vector2I(20, 10);
+    
     public override void _Ready()
     {
         // Spawn first room
 
     }
 
+    public void InitSpawning()
+    {
+        SpawnRoomsBinaryTree();
+    }
+    
     private void SpawnRoomsGrid()
     {
         //var firstRoom = Rooms.FirstOrDefault();
@@ -30,12 +46,70 @@ public partial class RogueliteRoomManager : Node2D
             {
                 var roomIndex = GD.RandRange(0, Rooms.Count - 1);
                 var room = Rooms[roomIndex];
-                SpawnRoom(room, origin + (room.Size * new Vector2(i, j) * tileSize));
+                //SpawnRoom(room, origin + (room.Size * new Vector2(i, j) * tileSize));
             }
         }
 
         //CallDeferred(MethodName.RebakeNavigationDeferred);
+    }
 
+    private void SpawnRoomsBinaryTree()
+    {
+        var directions = new List<Vector2I>
+        {
+            new Vector2I(0, -1), // North
+            new Vector2I(0, 1),  // South
+            new Vector2I(1, 0),  // East
+            new Vector2I(-1, 0), // West
+        };
+        
+        var origin = Vector2I.Zero;
+        var tileSize = new Vector2(16, 16);
+        var gridRoomSizeInTiles = new Vector2(20, 10);
+
+        var starterRooms = Rooms.Where(x => x.Type is RoomType.Starter).ToList();
+        var regularRooms = Rooms.Where(x => x.Type == RoomType.Regular).ToList();
+
+        var starterRoom = starterRooms[GD.RandRange(0, starterRooms.Count - 1)];
+        
+        var spawnedStartRoom = SpawnRoom(starterRoom, origin);
+        MarkRoom(origin, starterRoom.Size, starterRoom);
+        
+        Queue<(Vector2I Position, RogueliteRoomResource Room)> queue = new();
+        queue.Enqueue((origin, starterRoom));
+        
+        int spawnedRoomCount = 1;
+        
+        while (spawnedRoomCount < MaxRooms && queue.Count > 0)
+        {
+            var (currentPos, currentRoom) = queue.Dequeue();
+
+            foreach (var dir in directions)
+            {
+                var offsetPos = currentPos + dir;
+
+                // Avoid placing rooms in occupied space
+                if (_grid.ContainsKey(offsetPos)) continue;
+
+                var nextRoom = regularRooms[GD.RandRange(0, regularRooms.Count - 1)];
+                var roomSize = nextRoom.Size;
+
+                // Multi-tile room placement validation
+                if (!CanPlaceRoom(offsetPos, roomSize)) continue;
+
+                SpawnRoom(nextRoom, offsetPos);
+                MarkRoom(offsetPos, roomSize, nextRoom);
+                queue.Enqueue((offsetPos, nextRoom));
+                spawnedRoomCount++;
+
+                if (spawnedRoomCount >= MaxRooms)
+                    break;
+            }
+        }
+
+        //SpawnSpecialRooms(rng);
+        
+        
     }
 
     private void RebakeNavigationDeferred()
@@ -43,12 +117,46 @@ public partial class RogueliteRoomManager : Node2D
         GameManager.Instance.RebakeNavigation();
     }
 
-    private void SpawnRoom(RogueliteRoomResource room, Vector2 position)
+    private RogueliteRoom SpawnRoom(RogueliteRoomResource room, Vector2I gridPos)
     {
-        var roomScene = GD.Load<PackedScene>(room.ScenePath);
+        var position = gridPos * TileSize * RoomSizeInTiles;
         
+        var roomScene = GD.Load<PackedScene>(room.ScenePath);
         var spawnedScene = this.CreateChild<RogueliteRoom>(roomScene, position);
         
-        spawnedScene.Spawn();
+        // for reference
+        //SpawnRoom(room, origin + (room.Size * new Vector2(i, j) * tileSize));
+        
+        return spawnedScene.Spawn(CheckConnection);
+    }
+    
+    private bool CheckConnection(Vector2I pos)
+    {
+        return _grid.ContainsKey(pos); // <- this is your dungeon grid dictionary
+    }
+    
+    private bool CanPlaceRoom(Vector2I origin, Vector2I size)
+    {
+        for (int x = 0; x < size.X; x++)
+        {
+            for (int y = 0; y < size.Y; y++)
+            {
+                var pos = origin + new Vector2I(x, y);
+                if (_grid.ContainsKey(pos)) return false;
+            }
+        }
+        return true;
+    }
+
+    private void MarkRoom(Vector2I origin, Vector2I size, RogueliteRoomResource room)
+    {
+        for (int x = 0; x < size.X; x++)
+        {
+            for (int y = 0; y < size.Y; y++)
+            {
+                var pos = origin + new Vector2I(x, y);
+                _grid[pos] = room;
+            }
+        }
     }
 }