397 lines
13 KiB
C#
397 lines
13 KiB
C#
using DataServer.Data;
|
|
using DataServer.Data.Entities;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System.Diagnostics;
|
|
|
|
namespace GameServices.Admin.Pages.DungeonBuilder;
|
|
|
|
public class TestGenModel : AdminPageModel
|
|
{
|
|
private readonly GameDbContext _db;
|
|
|
|
public TestGenModel(GameDbContext db)
|
|
{
|
|
_db = db;
|
|
}
|
|
|
|
public List<DungeonPalette> Palettes { get; set; } = new();
|
|
|
|
// Form inputs
|
|
public int? SelectedPaletteId { get; set; }
|
|
public int Tier { get; set; } = 1;
|
|
public int? Seed { get; set; }
|
|
public int Width { get; set; } = 80;
|
|
public int Height { get; set; } = 80;
|
|
public int MinRooms { get; set; } = 5;
|
|
public int MaxRooms { get; set; } = 12;
|
|
|
|
// Output
|
|
public GeneratedDungeonPreview? GeneratedDungeon { get; set; }
|
|
|
|
public string? Message { get; set; }
|
|
public bool IsError { get; set; }
|
|
|
|
public async Task OnGetAsync()
|
|
{
|
|
await LoadPalettes();
|
|
}
|
|
|
|
public async Task<IActionResult> OnPostAsync(int? paletteId, int tier, int? seed, int width, int height, int minRooms, int maxRooms)
|
|
{
|
|
await LoadPalettes();
|
|
|
|
SelectedPaletteId = paletteId;
|
|
Tier = tier;
|
|
Seed = seed;
|
|
Width = Math.Clamp(width, 20, 200);
|
|
Height = Math.Clamp(height, 20, 200);
|
|
MinRooms = Math.Max(1, minRooms);
|
|
MaxRooms = Math.Max(MinRooms, maxRooms);
|
|
|
|
try
|
|
{
|
|
var sw = Stopwatch.StartNew();
|
|
var actualSeed = seed ?? Random.Shared.Next();
|
|
var rng = new Random(actualSeed);
|
|
|
|
// Load palette if specified
|
|
DungeonPalette? palette = null;
|
|
if (paletteId.HasValue)
|
|
{
|
|
palette = await _db.DungeonPalettes.FindAsync(paletteId.Value);
|
|
}
|
|
|
|
// Generate dungeon using simple room placement
|
|
var dungeon = GenerateSimpleDungeon(rng, palette);
|
|
|
|
sw.Stop();
|
|
dungeon.Seed = actualSeed;
|
|
dungeon.GenerationTimeMs = sw.ElapsedMilliseconds;
|
|
|
|
GeneratedDungeon = dungeon;
|
|
Message = $"Dungeon generated successfully in {sw.ElapsedMilliseconds}ms!";
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
IsError = true;
|
|
Message = $"Generation failed: {ex.Message}";
|
|
}
|
|
|
|
return Page();
|
|
}
|
|
|
|
private GeneratedDungeonPreview GenerateSimpleDungeon(Random rng, DungeonPalette? palette)
|
|
{
|
|
var dungeon = new GeneratedDungeonPreview
|
|
{
|
|
Width = Width,
|
|
Height = Height,
|
|
Cells = new CellInfo[Width, Height]
|
|
};
|
|
|
|
// Initialize all as walls
|
|
for (int y = 0; y < Height; y++)
|
|
{
|
|
for (int x = 0; x < Width; x++)
|
|
{
|
|
dungeon.Cells[x, y] = new CellInfo { Type = CellType.Wall };
|
|
}
|
|
}
|
|
|
|
// Get room count from palette or use overrides
|
|
int minRooms = palette?.MinRooms ?? MinRooms;
|
|
int maxRooms = palette?.MaxRooms ?? MaxRooms;
|
|
int roomCount = rng.Next(minRooms, maxRooms + 1);
|
|
|
|
// Room size ranges
|
|
int minRoomW = palette?.MinRoomWidth ?? 6;
|
|
int maxRoomW = palette?.MaxRoomWidth ?? 15;
|
|
int minRoomH = palette?.MinRoomHeight ?? 6;
|
|
int maxRoomH = palette?.MaxRoomHeight ?? 15;
|
|
|
|
var rooms = new List<RoomInfo>();
|
|
int attempts = 0;
|
|
int maxAttempts = roomCount * 50;
|
|
|
|
while (rooms.Count < roomCount && attempts < maxAttempts)
|
|
{
|
|
attempts++;
|
|
|
|
int w = rng.Next(minRoomW, maxRoomW + 1);
|
|
int h = rng.Next(minRoomH, maxRoomH + 1);
|
|
int x = rng.Next(2, Width - w - 2);
|
|
int y = rng.Next(2, Height - h - 2);
|
|
|
|
var newRoom = new RoomInfo { X = x, Y = y, Width = w, Height = h };
|
|
|
|
// Check overlap with existing rooms (with padding)
|
|
bool overlaps = false;
|
|
foreach (var existing in rooms)
|
|
{
|
|
if (RoomsOverlap(newRoom, existing, 3))
|
|
{
|
|
overlaps = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!overlaps)
|
|
{
|
|
rooms.Add(newRoom);
|
|
}
|
|
}
|
|
|
|
// Assign room types
|
|
if (rooms.Count > 0)
|
|
{
|
|
rooms[0].Type = "Entrance";
|
|
if (rooms.Count > 1)
|
|
{
|
|
rooms[rooms.Count - 1].Type = "Exit";
|
|
}
|
|
|
|
// Assign other types randomly
|
|
var types = new[] { "Normal", "Normal", "Normal", "Treasure", "Boss" };
|
|
for (int i = 1; i < rooms.Count - 1; i++)
|
|
{
|
|
rooms[i].Type = types[rng.Next(types.Length)];
|
|
}
|
|
}
|
|
|
|
// Carve rooms
|
|
foreach (var room in rooms)
|
|
{
|
|
for (int ry = room.Y; ry < room.Y + room.Height; ry++)
|
|
{
|
|
for (int rx = room.X; rx < room.X + room.Width; rx++)
|
|
{
|
|
dungeon.Cells[rx, ry] = new CellInfo { Type = CellType.Floor };
|
|
}
|
|
}
|
|
}
|
|
|
|
// Connect rooms with corridors
|
|
for (int i = 0; i < rooms.Count - 1; i++)
|
|
{
|
|
var roomA = rooms[i];
|
|
var roomB = rooms[i + 1];
|
|
|
|
int ax = roomA.X + roomA.Width / 2;
|
|
int ay = roomA.Y + roomA.Height / 2;
|
|
int bx = roomB.X + roomB.Width / 2;
|
|
int by = roomB.Y + roomB.Height / 2;
|
|
|
|
// L-shaped corridor
|
|
if (rng.Next(2) == 0)
|
|
{
|
|
CarveHorizontalCorridor(dungeon, ax, bx, ay);
|
|
CarveVerticalCorridor(dungeon, ay, by, bx);
|
|
}
|
|
else
|
|
{
|
|
CarveVerticalCorridor(dungeon, ay, by, ax);
|
|
CarveHorizontalCorridor(dungeon, ax, bx, by);
|
|
}
|
|
}
|
|
|
|
// Place spawns
|
|
if (rooms.Count > 0)
|
|
{
|
|
// Player spawn in entrance room
|
|
var entrance = rooms[0];
|
|
int px = entrance.X + entrance.Width / 2;
|
|
int py = entrance.Y + entrance.Height / 2;
|
|
dungeon.Cells[px, py] = new CellInfo { Type = CellType.PlayerSpawn };
|
|
|
|
// Exit in last room
|
|
if (rooms.Count > 1)
|
|
{
|
|
var exit = rooms[rooms.Count - 1];
|
|
int ex = exit.X + exit.Width / 2;
|
|
int ey = exit.Y + exit.Height / 2;
|
|
dungeon.Cells[ex, ey] = new CellInfo { Type = CellType.Exit };
|
|
}
|
|
|
|
// Mobs in other rooms
|
|
for (int i = 1; i < rooms.Count; i++)
|
|
{
|
|
var room = rooms[i];
|
|
bool isBossRoom = room.Type == "Boss";
|
|
int mobCount = isBossRoom ? 1 : rng.Next(1, 4);
|
|
|
|
for (int m = 0; m < mobCount; m++)
|
|
{
|
|
int mx = room.X + rng.Next(1, room.Width - 1);
|
|
int my = room.Y + rng.Next(1, room.Height - 1);
|
|
if (dungeon.Cells[mx, my].Type == CellType.Floor)
|
|
{
|
|
dungeon.Cells[mx, my] = new CellInfo { Type = isBossRoom ? CellType.Boss : CellType.Mob };
|
|
if (isBossRoom) dungeon.BossCount++;
|
|
else dungeon.MobCount++;
|
|
}
|
|
}
|
|
|
|
// Chests in treasure rooms
|
|
if (room.Type == "Treasure" || rng.Next(3) == 0)
|
|
{
|
|
int cx = room.X + rng.Next(1, room.Width - 1);
|
|
int cy = room.Y + rng.Next(1, room.Height - 1);
|
|
if (dungeon.Cells[cx, cy].Type == CellType.Floor)
|
|
{
|
|
dungeon.Cells[cx, cy] = new CellInfo { Type = CellType.Chest };
|
|
dungeon.ChestCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Place some decorative objects
|
|
int decorDensity = palette?.DecorationDensity ?? 20;
|
|
int objTarget = (Width * Height * decorDensity) / 10000;
|
|
|
|
for (int i = 0; i < objTarget && i < 50; i++)
|
|
{
|
|
int ox = rng.Next(1, Width - 1);
|
|
int oy = rng.Next(1, Height - 1);
|
|
if (dungeon.Cells[ox, oy].Type == CellType.Floor)
|
|
{
|
|
dungeon.Cells[ox, oy] = new CellInfo { Type = CellType.Object };
|
|
dungeon.ObjectCount++;
|
|
}
|
|
}
|
|
|
|
dungeon.Rooms = rooms;
|
|
dungeon.RoomCount = rooms.Count;
|
|
|
|
return dungeon;
|
|
}
|
|
|
|
private bool RoomsOverlap(RoomInfo a, RoomInfo b, int padding)
|
|
{
|
|
return a.X - padding < b.X + b.Width + padding &&
|
|
a.X + a.Width + padding > b.X - padding &&
|
|
a.Y - padding < b.Y + b.Height + padding &&
|
|
a.Y + a.Height + padding > b.Y - padding;
|
|
}
|
|
|
|
private void CarveHorizontalCorridor(GeneratedDungeonPreview dungeon, int x1, int x2, int y)
|
|
{
|
|
int minX = Math.Min(x1, x2);
|
|
int maxX = Math.Max(x1, x2);
|
|
|
|
for (int x = minX; x <= maxX; x++)
|
|
{
|
|
if (x >= 0 && x < dungeon.Width && y >= 0 && y < dungeon.Height)
|
|
{
|
|
if (dungeon.Cells[x, y].Type == CellType.Wall)
|
|
dungeon.Cells[x, y] = new CellInfo { Type = CellType.Floor };
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CarveVerticalCorridor(GeneratedDungeonPreview dungeon, int y1, int y2, int x)
|
|
{
|
|
int minY = Math.Min(y1, y2);
|
|
int maxY = Math.Max(y1, y2);
|
|
|
|
for (int y = minY; y <= maxY; y++)
|
|
{
|
|
if (x >= 0 && x < dungeon.Width && y >= 0 && y < dungeon.Height)
|
|
{
|
|
if (dungeon.Cells[x, y].Type == CellType.Wall)
|
|
dungeon.Cells[x, y] = new CellInfo { Type = CellType.Floor };
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task LoadPalettes()
|
|
{
|
|
Palettes = await _db.DungeonPalettes
|
|
.Where(p => p.IsEnabled)
|
|
.OrderBy(p => p.Name)
|
|
.ToListAsync();
|
|
}
|
|
|
|
// Helper classes
|
|
public class GeneratedDungeonPreview
|
|
{
|
|
public int Width { get; set; }
|
|
public int Height { get; set; }
|
|
public CellInfo[,] Cells { get; set; } = new CellInfo[0, 0];
|
|
public List<RoomInfo> Rooms { get; set; } = new();
|
|
public int RoomCount { get; set; }
|
|
public int MobCount { get; set; }
|
|
public int BossCount { get; set; }
|
|
public int ChestCount { get; set; }
|
|
public int ObjectCount { get; set; }
|
|
public int Seed { get; set; }
|
|
public long GenerationTimeMs { get; set; }
|
|
|
|
// Template usage tracking
|
|
public List<string> FloorTemplatesUsed { get; set; } = new();
|
|
public List<string> WallTemplatesUsed { get; set; } = new();
|
|
public List<string> ObjectTemplatesUsed { get; set; } = new();
|
|
public List<string> RoomTemplatesUsed { get; set; } = new();
|
|
|
|
public CellInfo GetCell(int x, int y)
|
|
{
|
|
if (x >= 0 && x < Width && y >= 0 && y < Height)
|
|
return Cells[x, y];
|
|
return new CellInfo { Type = CellType.Wall };
|
|
}
|
|
}
|
|
|
|
public class CellInfo
|
|
{
|
|
public CellType Type { get; set; }
|
|
|
|
public string CssClass => Type switch
|
|
{
|
|
CellType.Wall => "wall",
|
|
CellType.Floor => "floor",
|
|
CellType.Door => "door",
|
|
CellType.PlayerSpawn => "player",
|
|
CellType.Exit => "exit",
|
|
CellType.Mob => "mob",
|
|
CellType.Boss => "boss",
|
|
CellType.Chest => "chest",
|
|
CellType.Object => "object",
|
|
_ => "wall"
|
|
};
|
|
|
|
public string Icon => Type switch
|
|
{
|
|
CellType.PlayerSpawn => "🧑",
|
|
CellType.Exit => "🌀",
|
|
CellType.Mob => "👾",
|
|
CellType.Boss => "💀",
|
|
CellType.Chest => "📦",
|
|
CellType.Object => "•",
|
|
_ => ""
|
|
};
|
|
}
|
|
|
|
public enum CellType
|
|
{
|
|
Wall,
|
|
Floor,
|
|
Door,
|
|
PlayerSpawn,
|
|
Exit,
|
|
Mob,
|
|
Boss,
|
|
Chest,
|
|
Object
|
|
}
|
|
|
|
public class RoomInfo
|
|
{
|
|
public int X { get; set; }
|
|
public int Y { get; set; }
|
|
public int Width { get; set; }
|
|
public int Height { get; set; }
|
|
public string Type { get; set; } = "Normal";
|
|
}
|
|
}
|