mirror of
https://gitlab.com/MaddoScientisto/cirnogodot.git
synced 2026-06-01 08:45:33 +00:00
313 lines
No EOL
10 KiB
C#
313 lines
No EOL
10 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Cirno.Scripts.Enums;
|
|
using Cirno.Scripts.Resources.Roguelite;
|
|
using Godot;
|
|
using Godot.Collections;
|
|
|
|
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, 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;
|
|
//[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()
|
|
{
|
|
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++)
|
|
{
|
|
var roomIndex = GD.RandRange(0, Rooms.Count - 1);
|
|
var room = Rooms[roomIndex];
|
|
//SpawnRoom(room, origin + (room.Size * new Vector2(i, j) * tileSize));
|
|
}
|
|
}
|
|
|
|
//CallDeferred(MethodName.RebakeNavigationDeferred);
|
|
}
|
|
|
|
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()
|
|
{
|
|
Vector2I origin = Vector2I.Zero;
|
|
var starterRoom = Rooms.Where(r => r.Type == RoomType.Starter).PickRandom();
|
|
SpawnRoom(starterRoom, origin);
|
|
_mainPath.Add(origin);
|
|
|
|
var currentPos = origin;
|
|
|
|
// 🔐 Reserve boss room position
|
|
var bossRoom = BossRooms.FirstOrDefault();
|
|
Vector2I? bossTargetPos = FindValidBossRoomLocation(currentPos);
|
|
|
|
if (bossRoom == null || bossTargetPos == null)
|
|
{
|
|
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 pos = from + dir;
|
|
var bossRoom = Rooms.FirstOrDefault(r => r.Type == RoomType.Boss);
|
|
if (bossRoom != null && CanPlaceRoom(pos, bossRoom.Size))
|
|
return pos;
|
|
|
|
from += dir;
|
|
}
|
|
}
|
|
|
|
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()
|
|
{
|
|
GameManager.Instance.RebakeNavigation();
|
|
}
|
|
|
|
private bool SpawnRoom(RogueliteRoomResource room, Vector2I gridPos)
|
|
{
|
|
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));
|
|
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 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 (_roomGrid.ContainsKey(pos)) return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
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);
|
|
_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;
|
|
}
|
|
} |