maddo/cirnogodot
1
0
Fork 0
mirror of https://gitlab.com/MaddoScientisto/cirnogodot.git synced 2026-06-09 02:35:54 +00:00
Code Issues Projects Releases Packages Wiki Activity

Non working procedural generation

Browse source
This commit is contained in:
Marco 2025-04-14 16:50:58 +02:00
commit 794368dde6
10 changed files with 337 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

43
Scripts/Controllers/RogueliteRoom.cs
View file

@ -10,29 +10,30 @@ namespace Cirno.Scripts.Controllers;
public partial class RogueliteRoom : Node2D
{
[Export] public RogueliteRoomResource RoomResource { get; set; }
public Vector2I GridPosition { get; set; } // Set by dungeon manager
[Export] public PackedScene DoorPrefab { get; private set; }
[Export] public PackedScene WallPrefab { get; private set; }
private static readonly Dictionary<string, Vector2I> DirectionMap = new()
{
{ "North", new Vector2I(0, -1) },
{ "South", new Vector2I(0, 1) },
{ "East", new Vector2I(1, 0) },
{ "West", new Vector2I(-1, 0) },
{ "East", new Vector2I(1, 0) },
{ "West", new Vector2I(-1, 0) },
};
private Array<EnemyResource> SpawnableEnemies => RoomResource.SpawnableEnemies;
private Array<EnemyResource> SpawnableEnemies => RoomResource.SpawnableEnemies;
public RogueliteRoom Spawn(Func<Vector2I, bool> connectionChecker)
public RogueliteRoom Spawn()
{
SpawnEnemies();
HandleDoors(connectionChecker);
//HandleDoors(connectionChecker);
return this;
}
private void HandleDoors(Func<Vector2I, bool> connectionChecker)
public void HandleDoors(Func<Vector2I, bool> connectionChecker)
{
if (!HasNode("Doors")) return;
var doorsNode = GetNode("Doors");
@ -40,7 +41,7 @@ public partial class RogueliteRoom : Node2D
foreach (Node child in doorsNode.GetChildren())
{
if (child is not DoorMarker marker) continue;
var baseDir = marker.GetWorldDirection();
// WallIndex determines the offset *along* the edge of the room
@ -57,11 +58,16 @@ public partial class RogueliteRoom : Node2D
bool connected = connectionChecker.Invoke(neighborPos);
if (!connected) continue;
if (connected)
{
var door = this.CreateChild<Door>(DoorPrefab, marker.GlobalPosition);
var door = this.CreateChild<Door>(DoorPrefab, marker.GlobalPosition);
door.State = DoorState.Open;
door.State = DoorState.Open;
}
else
{
var wall = this.CreateChild<Node2D>(WallPrefab, marker.GlobalPosition);
}
// PackedScene prefab = hasConnection
// ? GD.Load<PackedScene>("res://Prefabs/Door.tscn")
@ -77,16 +83,15 @@ public partial class RogueliteRoom : Node2D
private void SpawnEnemies()
{
if (SpawnableEnemies is null || !SpawnableEnemies.Any()) return;
var enemySpawners = this.GetNode("EnemySpawners").GetChildren().Cast<Marker2D>();
foreach (var spawner in enemySpawners)
{
var index = GD.RandRange(0, SpawnableEnemies.Count - 1);
var e = SpawnableEnemies[index];
var enemyScene = GD.Load<PackedScene>(e.PrefabPath);
var spawnedEnemy = spawner.CreateChild<Node2D>(enemyScene);
}

287
Scripts/Controllers/RogueliteRoomManager.cs
View file

@ -10,10 +10,18 @@ namespace Cirno.Scripts.Controllers;
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();
//private Godot.Collections.Dictionary<Vector2I, RogueliteRoomResource> _grid = new();
private Godot.Collections.Dictionary<Vector2I, RogueliteRoom> _roomGrid = new();
[Export] public Vector2I SpawnOrigin { get; private set; } = Vector2I.Zero;
[Export] public int DungeonLength { get; set; } = 10;
[Export] public int MaxBranches { get; set; } = 3;
[Export] public int MaxBranchLength { get; set; } = 3;
[Export] public int DungeonWidth = 10;
[Export] public int DungeonHeight = 10;
[Export] public int MaxRooms = 12;
@ -21,25 +29,24 @@ public partial class RogueliteRoomManager : Node2D
[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();
GenerateDungeon();
}
private void SpawnRoomsGrid()
{
//var firstRoom = Rooms.FirstOrDefault();
var origin = Vector2.Zero;
var tileSize = new Vector2(16, 16);
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
@ -53,63 +60,184 @@ public partial class RogueliteRoomManager : Node2D
//CallDeferred(MethodName.RebakeNavigationDeferred);
}
private void SpawnRoomsBinaryTree()
private IEnumerable<RogueliteRoomResource> StarterRooms => Rooms.Where(x => x.Type is RoomType.Starter);
private IEnumerable<RogueliteRoomResource> RegularRooms => Rooms.Where(x => x.Type is RoomType.Regular);
private IEnumerable<RogueliteRoomResource> BossRooms => Rooms.Where(x => x.Type is RoomType.Boss);
private List<Vector2I> _mainPath = new();
private List<RoomConnection> _connections = new();
private void GenerateDungeon()
{
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);
Vector2I origin = Vector2I.Zero;
var starterRoom = Rooms.Where(r => r.Type == RoomType.Starter).PickRandom();
SpawnRoom(starterRoom, origin);
_mainPath.Add(origin);
var starterRooms = Rooms.Where(x => x.Type is RoomType.Starter).ToList();
var regularRooms = Rooms.Where(x => x.Type == RoomType.Regular).ToList();
var currentPos = origin;
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)
// 🔐 Reserve boss room position
var bossRoom = BossRooms.FirstOrDefault();
Vector2I? bossTargetPos = FindValidBossRoomLocation(currentPos);
if (bossRoom == null || bossTargetPos == null)
{
var (currentPos, currentRoom) = queue.Dequeue();
GD.PrintErr("Failed to place boss room!");
return;
}
// Generate path to boss room
while (currentPos != bossTargetPos.Value)
{
var nextPos = GetNextPosition(currentPos, bossTargetPos.Value);
if (!SpawnRoom(Rooms.Where(x => x.Type == RoomType.Regular).PickRandom(), nextPos)) break;
_mainPath.Add(nextPos);
_connections.Add(new RoomConnection(currentPos, nextPos));
currentPos = nextPos;
}
// Place the boss room
if (SpawnRoom(bossRoom, bossTargetPos.Value))
{
_mainPath.Add(bossTargetPos.Value);
_connections.Add(new RoomConnection(currentPos, bossTargetPos.Value));
}
}
// 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 = StarterRooms.ToList();
// var regularRooms = RegularRooms.ToList();
// var bossRooms = BossRooms.ToList();
// var starterRoom = starterRooms[GD.RandRange(0, starterRooms.Count - 1)];
//
// var spawnedStartRoom = SpawnRoom(starterRoom, SpawnOrigin);
//
// Vector2I currentPos = SpawnOrigin;
//
// //MarkRoom(SpawnOrigin, starterRoom.Size, starterRoom);
//
// for (int i = 0; i < DungeonLength - 2; i++)
// {
// var nextPos = GetNextPosition(currentPos);
// if (nextPos == currentPos) break;
//
// var room = regularRooms[GD.RandRange(0, regularRooms.Count - 1)];
// if (!SpawnRoom(room, nextPos)) break; // Skip on overlap
//
// _mainPath.Add(nextPos);
// _connections.Add(new RoomConnection(currentPos, nextPos));
// currentPos = nextPos;
// }
//
// // Place Boss Room
//
// var bossRoom = bossRooms[GD.RandRange(0, bossRooms.Count - 1)];
// var bossPos = GetNextPosition(currentPos);
// if (!SpawnRoom(bossRoom, bossPos)) break; // Skip on overlap
// SpawnRoom(bossRoom, bossPos);
// _mainPath.Add(bossPos);
// _connections.Add(new RoomConnection(currentPos, bossPos));
//
// // Place Shop and Secret Rooms
// //PlaceSpecialRoom(RoomType.Shop);
// //PlaceSpecialRoom(RoomType.Secret);
//
// // Optionally, add branches
// for (int i = 0; i < MaxBranches; i++)
// {
// var branchStart = _mainPath[GD.RandRange(0, _mainPath.Count -1)];
// var branchLength = GD.RandRange(1, MaxBranchLength);
// //_random.Next(1, MaxBranchLength + 1);
// var branchPos = branchStart;
//
// for (int j = 0; j < branchLength; j++)
// {
// var nextPos = GetNextPosition(branchPos);
// if (_roomGrid.ContainsKey(nextPos)) break;
//
// var room = regularRooms[GD.RandRange(0,regularRooms.Count -1)];
//
// SpawnRoom(room, nextPos);
// _connections.Add(new RoomConnection(branchPos, nextPos));
// branchPos = nextPos;
// }
// }
//
// // Spawn doors and walls
// foreach (var roomEntry in _roomGrid)
// {
// var room = roomEntry.Value;
// room.HandleDoors(pos =>
// {
// var neighborPos = room.GridPosition + pos;
// return _roomGrid.ContainsKey(neighborPos);
// });
// }
// }
private Vector2I? FindValidBossRoomLocation(Vector2I from, int maxSteps = 10)
{
var directions = new List<Vector2I> { Vector2I.Right, Vector2I.Left, Vector2I.Up, Vector2I.Down };
for (int step = 0; step < maxSteps; step++)
{
directions = directions.OrderBy(_ => GD.Randi()).ToList();
foreach (var dir in directions)
{
var offsetPos = currentPos + dir;
var pos = from + dir;
var bossRoom = Rooms.FirstOrDefault(r => r.Type == RoomType.Boss);
if (bossRoom != null && CanPlaceRoom(pos, bossRoom.Size))
return pos;
// 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;
from += dir;
}
}
//SpawnSpecialRooms(rng);
return null;
}
private Vector2I GetNextPosition(Vector2I current, Vector2I target)
{
var possibleDirs = new List<Vector2I>();
if (target.X > current.X)
possibleDirs.Add(Vector2I.Right);
else if (target.X < current.X)
possibleDirs.Add(Vector2I.Left);
if (target.Y > current.Y)
possibleDirs.Add(Vector2I.Down);
else if (target.Y < current.Y)
possibleDirs.Add(Vector2I.Up);
// Add random noise to allow slightly winding paths
possibleDirs.AddRange(new[] { Vector2I.Right, Vector2I.Left, Vector2I.Up, Vector2I.Down });
possibleDirs = possibleDirs.Distinct().OrderBy(_ => GD.Randi()).ToList();
foreach (var dir in possibleDirs)
{
var nextPos = current + dir;
if (!_roomGrid.ContainsKey(nextPos))
return nextPos;
}
return current; // No valid next position found
}
private void RebakeNavigationDeferred()
@ -117,24 +245,30 @@ public partial class RogueliteRoomManager : Node2D
GameManager.Instance.RebakeNavigation();
}
private RogueliteRoom SpawnRoom(RogueliteRoomResource room, Vector2I gridPos)
private bool SpawnRoom(RogueliteRoomResource room, Vector2I gridPos)
{
var position = gridPos * TileSize * RoomSizeInTiles;
if (!CanPlaceRoom(gridPos, room.Size))
return false;
var position = gridPos * TileSize * RoomSizeInTiles;
var roomScene = GD.Load<PackedScene>(room.ScenePath);
var spawnedScene = this.CreateChild<RogueliteRoom>(roomScene, position);
spawnedScene.GridPosition = gridPos;
// for reference
//SpawnRoom(room, origin + (room.Size * new Vector2(i, j) * tileSize));
return spawnedScene.Spawn(CheckConnection);
spawnedScene.Spawn();
MarkRoom(SpawnOrigin, room.Size, spawnedScene);
return true;
}
private bool CheckConnection(Vector2I pos)
{
return _grid.ContainsKey(pos); // <- this is your dungeon grid dictionary
}
// 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++)
@ -142,21 +276,38 @@ public partial class RogueliteRoomManager : Node2D
for (int y = 0; y < size.Y; y++)
{
var pos = origin + new Vector2I(x, y);
if (_grid.ContainsKey(pos)) return false;
if (_roomGrid.ContainsKey(pos)) return false;
}
}
return true;
}
private void MarkRoom(Vector2I origin, Vector2I size, RogueliteRoomResource room)
private void MarkRoom(Vector2I origin, Vector2I size, RogueliteRoom 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;
_roomGrid[pos] = room;
}
}
}
}
public class RoomConnection
{
public Vector2I From;
public Vector2I To;
public bool IsLocked;
public bool IsSecret;
public RoomConnection(Vector2I from, Vector2I to, bool isLocked = false, bool isSecret = false)
{
From = from;
To = to;
IsLocked = isLocked;
IsSecret = isSecret;
}
}