From 3d4607e5916814841d7a11a92922325e920cb506 Mon Sep 17 00:00:00 2001 From: dingo Date: Sun, 28 Dec 2025 08:29:27 -0500 Subject: [PATCH] Dungeon Builder --- Game/Dungeon/DungeonGeneratorV2.cs | 552 ++++++++++++++++++++ Game/Dungeon/DungeonLayoutV2.cs | 188 +++++++ Game/Dungeon/DungeonVisualTileExtensions.cs | 163 ++++++ 3 files changed, 903 insertions(+) create mode 100644 Game/Dungeon/DungeonGeneratorV2.cs create mode 100644 Game/Dungeon/DungeonLayoutV2.cs create mode 100644 Game/Dungeon/DungeonVisualTileExtensions.cs diff --git a/Game/Dungeon/DungeonGeneratorV2.cs b/Game/Dungeon/DungeonGeneratorV2.cs new file mode 100644 index 0000000..30b4080 --- /dev/null +++ b/Game/Dungeon/DungeonGeneratorV2.cs @@ -0,0 +1,552 @@ +using DataServer.Data; +using DataServer.Data.Entities; +using Microsoft.EntityFrameworkCore; +using System.Text.Json; + +namespace Server.Game.Dungeon; + +/// +/// Procedural dungeon generator using room templates from database +/// Falls back to basic BSP generation if no templates available +/// +public class DungeonGeneratorV2 +{ + private readonly GameDbContext _db; + private readonly Random _rng; + private readonly int _seed; + private readonly int _tier; + private readonly int _tileSize = 32; + + // Tier-based scaling + private int MinRooms => 5 + (_tier * 2); + private int MaxRooms => 8 + (_tier * 3); + private int MapWidth => 60 + (_tier * 15); // In tiles + private int MapHeight => 60 + (_tier * 15); + + // Cached templates + private List _entranceTemplates = new(); + private List _exitTemplates = new(); + private List _bossTemplates = new(); + private List _treasureTemplates = new(); + private List _normalTemplates = new(); + private List _hallwayTemplates = new(); + + // Tile definitions cache + private Dictionary _tileDefinitions = new(); + private TileMapSheet? _defaultSheet; + + public DungeonGeneratorV2(GameDbContext db, int seed, int tier) + { + _db = db; + _seed = seed; + _tier = Math.Max(1, tier); + _rng = new Random(seed); + } + + public async Task GenerateAsync() + { + // Load templates from database + await LoadTemplatesAsync(); + + var layout = new DungeonLayoutV2 + { + Seed = _seed, + Tier = _tier, + Width = MapWidth, + Height = MapHeight, + TileSize = _tileSize + }; + + // Initialize tile map with detailed tile info + // 0 = void/wall, positive = tile definition ID + layout.Tiles = new int[MapWidth, MapHeight]; + layout.TileDetails = new List(); + + // Generate rooms + int roomCount = _rng.Next(MinRooms, MaxRooms + 1); + var rooms = new List(); + int attempts = 0; + int maxAttempts = roomCount * 30; + + // Always place entrance first + var entrance = await PlaceRoomAsync(layout, rooms, RoomType.Entrance, 5, 5); + if (entrance != null) rooms.Add(entrance); + + // Place other rooms + while (rooms.Count < roomCount && attempts < maxAttempts) + { + attempts++; + + // Determine room type based on current room count + RoomType type = DetermineNextRoomType(rooms, roomCount); + + // Try to place near existing room (for connectivity) + var baseRoom = rooms[_rng.Next(rooms.Count)]; + int offsetX = _rng.Next(-20, 21); + int offsetY = _rng.Next(-20, 21); + int x = Math.Clamp(baseRoom.X + baseRoom.Width / 2 + offsetX, 2, MapWidth - 15); + int y = Math.Clamp(baseRoom.Y + baseRoom.Height / 2 + offsetY, 2, MapHeight - 15); + + var newRoom = await PlaceRoomAsync(layout, rooms, type, x, y); + if (newRoom != null) + { + rooms.Add(newRoom); + } + } + + // Ensure we have an exit/boss room + var bossRoom = rooms.FirstOrDefault(r => r.Type == RoomType.Boss); + if (bossRoom == null && rooms.Count > 1) + { + // Convert last room to boss + rooms[^1].Type = RoomType.Boss; + } + + // Sort rooms by distance from entrance for corridor generation + var entranceRoom = rooms.FirstOrDefault(r => r.Type == RoomType.Entrance) ?? rooms[0]; + rooms = rooms.OrderBy(r => Distance(entranceRoom, r)).ToList(); + + // Connect rooms with corridors + var connected = new HashSet { 0 }; + for (int i = 1; i < rooms.Count; i++) + { + // Find closest connected room + int closestIdx = connected.OrderBy(c => Distance(rooms[c], rooms[i])).First(); + await ConnectRoomsAsync(layout, rooms[closestIdx], rooms[i]); + connected.Add(i); + } + + // Add some extra connections for loops + for (int i = 0; i < rooms.Count / 4; i++) + { + int a = _rng.Next(rooms.Count); + int b = _rng.Next(rooms.Count); + if (a != b && Distance(rooms[a], rooms[b]) < 30) + { + await ConnectRoomsAsync(layout, rooms[a], rooms[b]); + } + } + + // Set spawn point + layout.SpawnPoint = new DungeonPoint(entranceRoom.CenterX, entranceRoom.CenterY); + + // Generate mob and chest spawns based on room templates + GenerateSpawns(rooms, layout); + + // Store rooms + layout.Rooms = rooms.Cast().ToList(); + + // Build tile data for client + layout.BuildClientTileData(_tileDefinitions, _defaultSheet); + + return layout; + } + + private async Task LoadTemplatesAsync() + { + var templates = await _db.RoomTemplates + .Where(r => r.IsEnabled) + .Where(r => r.MinTier <= _tier && (r.MaxTier == 0 || r.MaxTier >= _tier)) + .ToListAsync(); + + _entranceTemplates = templates.Where(t => t.Type == RoomType.Entrance).ToList(); + _exitTemplates = templates.Where(t => t.Type == RoomType.Exit).ToList(); + _bossTemplates = templates.Where(t => t.Type == RoomType.Boss).ToList(); + _treasureTemplates = templates.Where(t => t.Type == RoomType.Treasure).ToList(); + _normalTemplates = templates.Where(t => t.Type == RoomType.Normal).ToList(); + _hallwayTemplates = templates.Where(t => t.Type == RoomType.Hallway).ToList(); + + // Load tile definitions + var tileIds = templates + .Where(t => !string.IsNullOrEmpty(t.TileDataJson)) + .SelectMany(t => { + try { + var placements = JsonSerializer.Deserialize>(t.TileDataJson!); + return placements?.Select(p => p.TileDefinitionId) ?? Enumerable.Empty(); + } catch { return Enumerable.Empty(); } + }) + .Distinct() + .ToList(); + + if (tileIds.Any()) + { + var tiles = await _db.TileDefinitions + .Include(t => t.TileMapSheet) + .Where(t => tileIds.Contains(t.Id)) + .ToListAsync(); + + _tileDefinitions = tiles.ToDictionary(t => t.Id); + _defaultSheet = tiles.FirstOrDefault()?.TileMapSheet; + } + + // If no templates, load a default sheet for basic generation + if (_defaultSheet == null) + { + _defaultSheet = await _db.TileMapSheets + .Include(s => s.Tiles) + .FirstOrDefaultAsync(s => s.IsEnabled); + + if (_defaultSheet?.Tiles != null) + { + foreach (var tile in _defaultSheet.Tiles) + { + _tileDefinitions[tile.Id] = tile; + } + } + } + } + + private RoomType DetermineNextRoomType(List existing, int targetCount) + { + // Ensure we have at least one of certain types + bool hasBoss = existing.Any(r => r.Type == RoomType.Boss); + bool hasTreasure = existing.Any(r => r.Type == RoomType.Treasure); + + // If near the end and no boss, force boss + if (!hasBoss && existing.Count >= targetCount - 2) + return RoomType.Boss; + + // Weighted random selection + int roll = _rng.Next(100); + + if (roll < 5 && !hasBoss) return RoomType.Boss; + if (roll < 15 && !hasTreasure) return RoomType.Treasure; + if (roll < 25) return RoomType.Treasure; + + return RoomType.Normal; + } + + private async Task PlaceRoomAsync(DungeonLayoutV2 layout, List existing, RoomType type, int preferX, int preferY) + { + // Get templates for this type + var templates = type switch + { + RoomType.Entrance => _entranceTemplates, + RoomType.Exit or RoomType.Boss => _bossTemplates.Concat(_exitTemplates).ToList(), + RoomType.Treasure => _treasureTemplates, + _ => _normalTemplates + }; + + // If no templates, use fallback generation + if (templates.Count == 0) + { + return PlaceFallbackRoom(layout, existing, type, preferX, preferY); + } + + // Weighted random selection + var template = SelectWeightedTemplate(templates); + if (template == null) + { + return PlaceFallbackRoom(layout, existing, type, preferX, preferY); + } + + // Try to place at preferred position + int x = Math.Clamp(preferX - template.Width / 2, 2, MapWidth - template.Width - 2); + int y = Math.Clamp(preferY - template.Height / 2, 2, MapHeight - template.Height - 2); + + var room = new DungeonRoomV2(x, y, template.Width, template.Height) + { + Type = type, + TemplateId = template.Id, + TemplateName = template.Name + }; + + // Check overlap + if (existing.Any(r => room.Intersects(r, padding: 3))) + { + // Try random position + for (int attempt = 0; attempt < 10; attempt++) + { + x = _rng.Next(2, MapWidth - template.Width - 2); + y = _rng.Next(2, MapHeight - template.Height - 2); + room = new DungeonRoomV2(x, y, template.Width, template.Height) + { + Type = type, + TemplateId = template.Id, + TemplateName = template.Name + }; + + if (!existing.Any(r => room.Intersects(r, padding: 3))) + break; + } + + if (existing.Any(r => room.Intersects(r, padding: 3))) + return null; + } + + // Place tiles from template + if (!string.IsNullOrEmpty(template.TileDataJson)) + { + try + { + var placements = JsonSerializer.Deserialize>(template.TileDataJson); + if (placements != null) + { + foreach (var p in placements) + { + int worldX = x + p.X; + int worldY = y + p.Y; + + if (worldX >= 0 && worldX < MapWidth && worldY >= 0 && worldY < MapHeight) + { + layout.Tiles[worldX, worldY] = p.TileDefinitionId; + layout.TileDetails.Add(new PlacedTile + { + X = worldX, + Y = worldY, + TileDefinitionId = p.TileDefinitionId, + Layer = p.Layer, + Rotation = p.Rotation, + FlipX = p.FlipX, + FlipY = p.FlipY + }); + } + } + } + } + catch { /* Invalid JSON, fall through to basic carve */ } + } + + // If no tiles were placed, do basic carve + if (!layout.TileDetails.Any(t => t.X >= x && t.X < x + room.Width && t.Y >= y && t.Y < y + room.Height)) + { + CarveBasicRoom(layout, room); + } + + return room; + } + + private DungeonRoomV2? PlaceFallbackRoom(DungeonLayoutV2 layout, List existing, RoomType type, int preferX, int preferY) + { + int w = _rng.Next(6, 12); + int h = _rng.Next(6, 12); + int x = Math.Clamp(preferX - w / 2, 2, MapWidth - w - 2); + int y = Math.Clamp(preferY - h / 2, 2, MapHeight - h - 2); + + var room = new DungeonRoomV2(x, y, w, h) { Type = type }; + + if (existing.Any(r => room.Intersects(r, padding: 3))) + { + // Try random positions + for (int attempt = 0; attempt < 20; attempt++) + { + x = _rng.Next(2, MapWidth - w - 2); + y = _rng.Next(2, MapHeight - h - 2); + room = new DungeonRoomV2(x, y, w, h) { Type = type }; + + if (!existing.Any(r => room.Intersects(r, padding: 3))) + break; + } + + if (existing.Any(r => room.Intersects(r, padding: 3))) + return null; + } + + CarveBasicRoom(layout, room); + return room; + } + + private void CarveBasicRoom(DungeonLayoutV2 layout, DungeonRoomV2 room) + { + // Find floor tile from default sheet + var floorTile = _tileDefinitions.Values.FirstOrDefault(t => t.Type == TileType.Floor); + int floorId = floorTile?.Id ?? -1; // -1 means no visual tile, just walkable + + for (int x = room.X; x < room.X + room.Width; x++) + { + for (int y = room.Y; y < room.Y + room.Height; y++) + { + if (x >= 0 && x < MapWidth && y >= 0 && y < MapHeight) + { + layout.Tiles[x, y] = floorId > 0 ? floorId : 1; // 1 = walkable but no visual + + if (floorId > 0) + { + layout.TileDetails.Add(new PlacedTile + { + X = x, Y = y, + TileDefinitionId = floorId, + Layer = 0 + }); + } + } + } + } + } + + private async Task ConnectRoomsAsync(DungeonLayoutV2 layout, DungeonRoomV2 a, DungeonRoomV2 b) + { + // Check for hallway templates + // For now, use basic corridor carving + + int x = a.CenterX; + int y = a.CenterY; + int targetX = b.CenterX; + int targetY = b.CenterY; + + var floorTile = _tileDefinitions.Values.FirstOrDefault(t => t.Type == TileType.Floor); + int floorId = floorTile?.Id ?? 1; + + // L-shaped corridor + if (_rng.Next(2) == 0) + { + CarveHorizontalCorridor(layout, x, targetX, y, floorId); + CarveVerticalCorridor(layout, y, targetY, targetX, floorId); + } + else + { + CarveVerticalCorridor(layout, y, targetY, x, floorId); + CarveHorizontalCorridor(layout, x, targetX, targetY, floorId); + } + } + + private void CarveHorizontalCorridor(DungeonLayoutV2 layout, int x1, int x2, int y, int floorId) + { + int minX = Math.Min(x1, x2); + int maxX = Math.Max(x1, x2); + + for (int x = minX; x <= maxX; x++) + { + for (int dy = 0; dy < 2; dy++) // 2-tile wide corridor + { + int ty = y + dy; + if (x >= 0 && x < MapWidth && ty >= 0 && ty < MapHeight && layout.Tiles[x, ty] == 0) + { + layout.Tiles[x, ty] = floorId; + if (floorId > 1) + { + layout.TileDetails.Add(new PlacedTile { X = x, Y = ty, TileDefinitionId = floorId, Layer = 0 }); + } + } + } + } + } + + private void CarveVerticalCorridor(DungeonLayoutV2 layout, int y1, int y2, int x, int floorId) + { + int minY = Math.Min(y1, y2); + int maxY = Math.Max(y1, y2); + + for (int y = minY; y <= maxY; y++) + { + for (int dx = 0; dx < 2; dx++) // 2-tile wide corridor + { + int tx = x + dx; + if (tx >= 0 && tx < MapWidth && y >= 0 && y < MapHeight && layout.Tiles[tx, y] == 0) + { + layout.Tiles[tx, y] = floorId; + if (floorId > 1) + { + layout.TileDetails.Add(new PlacedTile { X = tx, Y = y, TileDefinitionId = floorId, Layer = 0 }); + } + } + } + } + } + + private RoomTemplate? SelectWeightedTemplate(List templates) + { + if (templates.Count == 0) return null; + + int totalWeight = templates.Sum(t => t.Weight); + int roll = _rng.Next(totalWeight); + int cumulative = 0; + + foreach (var t in templates) + { + cumulative += t.Weight; + if (roll < cumulative) + return t; + } + + return templates[0]; + } + + private float Distance(DungeonRoom a, DungeonRoom b) + { + float dx = a.CenterX - b.CenterX; + float dy = a.CenterY - b.CenterY; + return MathF.Sqrt(dx * dx + dy * dy); + } + + private void GenerateSpawns(List rooms, DungeonLayoutV2 layout) + { + foreach (var room in rooms) + { + if (room.Type == RoomType.Entrance) continue; + + // Mob spawns + int mobCount = room.Type switch + { + RoomType.Boss => 1, + RoomType.Treasure => _rng.Next(1, 3), + _ => _rng.Next(2, 5 + _tier) + }; + + for (int i = 0; i < mobCount; i++) + { + int x = room.X + 1 + _rng.Next(Math.Max(1, room.Width - 2)); + int y = room.Y + 1 + _rng.Next(Math.Max(1, room.Height - 2)); + + layout.MobSpawns.Add(new DungeonMobSpawn + { + Id = layout.MobSpawns.Count + 1, + X = x, Y = y, + MobType = room.Type == RoomType.Boss ? DungeonMobSpawnType.Boss : DungeonMobSpawnType.Normal, + RoomIndex = rooms.IndexOf(room) + }); + } + + // Chest spawns + int chestCount = room.Type switch + { + RoomType.Treasure => _rng.Next(2, 4), + RoomType.Boss => 1, + _ => _rng.NextDouble() < 0.2 ? 1 : 0 + }; + + for (int i = 0; i < chestCount; i++) + { + int x = room.X + 1 + _rng.Next(Math.Max(1, room.Width - 2)); + int y = room.Y + 1 + _rng.Next(Math.Max(1, room.Height - 2)); + + layout.ChestSpawns.Add(new DungeonChestSpawn + { + Id = layout.ChestSpawns.Count + 1, + X = x, Y = y, + ChestType = room.Type == RoomType.Boss ? DungeonChestType.Boss : DungeonChestType.Normal, + RoomIndex = rooms.IndexOf(room) + }); + } + } + + layout.TotalMobs = layout.MobSpawns.Count; + layout.TotalChests = layout.ChestSpawns.Count; + } +} + +/// +/// Extended room with template info +/// +public class DungeonRoomV2 : DungeonRoom +{ + public int? TemplateId { get; set; } + public string? TemplateName { get; set; } + public new RoomType Type { get; set; } = RoomType.Normal; + + public DungeonRoomV2(int x, int y, int width, int height) : base(x, y, width, height) { } +} + +/// +/// Placed tile with details +/// +public class PlacedTile +{ + public int X { get; set; } + public int Y { get; set; } + public int TileDefinitionId { get; set; } + public int Layer { get; set; } + public int Rotation { get; set; } + public bool FlipX { get; set; } + public bool FlipY { get; set; } +} diff --git a/Game/Dungeon/DungeonLayoutV2.cs b/Game/Dungeon/DungeonLayoutV2.cs new file mode 100644 index 0000000..3468896 --- /dev/null +++ b/Game/Dungeon/DungeonLayoutV2.cs @@ -0,0 +1,188 @@ +using DataServer.Data.Entities; +using System.Text.Json; + +namespace Server.Game.Dungeon; + +/// +/// Enhanced dungeon layout with full tile visual information +/// +public class DungeonLayoutV2 : DungeonLayout +{ + /// + /// Detailed tile placements with visual info + /// + public List TileDetails { get; set; } = new(); + + /// + /// Tilemap sheet data for client rendering + /// + public List TileMapSheets { get; set; } = new(); + + /// + /// Build tile data optimized for client transmission + /// + public void BuildClientTileData(Dictionary tileDefinitions, TileMapSheet? defaultSheet) + { + // Collect all unique sheets used + var sheetIds = TileDetails + .Select(t => tileDefinitions.GetValueOrDefault(t.TileDefinitionId)?.TileMapSheetId) + .Where(id => id.HasValue) + .Select(id => id!.Value) + .Distinct() + .ToList(); + + var sheets = tileDefinitions.Values + .Where(t => sheetIds.Contains(t.TileMapSheetId)) + .Select(t => t.TileMapSheet) + .Where(s => s != null) + .DistinctBy(s => s!.Id) + .ToList(); + + // Add default sheet if not already included + if (defaultSheet != null && !sheets.Any(s => s?.Id == defaultSheet.Id)) + { + sheets.Add(defaultSheet); + } + + foreach (var sheet in sheets) + { + if (sheet == null) continue; + + TileMapSheets.Add(new TileMapSheetInfo + { + Id = sheet.Id, + CdnPath = sheet.CdnPath, + TileWidth = sheet.TileWidth, + TileHeight = sheet.TileHeight, + SheetWidth = sheet.SheetWidth, + SheetHeight = sheet.SheetHeight, + Columns = sheet.Columns, + Rows = sheet.Rows + }); + } + } + + /// + /// Serialize to JSON for client + /// Includes full tile visual data + /// + public new string ToJson() + { + return JsonSerializer.Serialize(new + { + seed = Seed, + tier = Tier, + width = Width, + height = Height, + tileSize = TileSize, + tilesRLE = SerializeTilesRLE(), + spawn = new { x = SpawnPoint.X, y = SpawnPoint.Y }, + rooms = Rooms.Select(r => new + { + x = r.X, y = r.Y, w = r.Width, h = r.Height, + type = r.Type.ToString(), + templateId = (r as DungeonRoomV2)?.TemplateId, + templateName = (r as DungeonRoomV2)?.TemplateName + }), + mobs = MobSpawns.Select(m => new + { + id = m.Id, x = m.X, y = m.Y, + type = m.MobType.ToString(), + roomIndex = m.RoomIndex + }), + chests = ChestSpawns.Select(c => new + { + id = c.Id, x = c.X, y = c.Y, + type = c.ChestType.ToString(), + roomIndex = c.RoomIndex + }), + // New: Visual tile data + tileSheets = TileMapSheets.Select(s => new + { + id = s.Id, + path = s.CdnPath, + tileW = s.TileWidth, + tileH = s.TileHeight, + sheetW = s.SheetWidth, + sheetH = s.SheetHeight, + cols = s.Columns, + rows = s.Rows + }), + visualTiles = TileDetails.Select(t => new + { + x = t.X, + y = t.Y, + tid = t.TileDefinitionId, + l = t.Layer, + r = t.Rotation, + fx = t.FlipX, + fy = t.FlipY + }) + }); + } + + /// + /// Lightweight JSON for initial dungeon state (no visual data, sent separately) + /// + public string ToLightJson() + { + return JsonSerializer.Serialize(new + { + seed = Seed, + tier = Tier, + width = Width, + height = Height, + tileSize = TileSize, + tilesRLE = SerializeTilesRLE(), + spawn = new { x = SpawnPoint.X, y = SpawnPoint.Y }, + rooms = Rooms.Select(r => new { x = r.X, y = r.Y, w = r.Width, h = r.Height, type = r.Type.ToString() }), + mobs = MobSpawns.Select(m => new { id = m.Id, x = m.X, y = m.Y, type = m.MobType.ToString() }), + chests = ChestSpawns.Select(c => new { id = c.Id, x = c.X, y = c.Y, type = c.ChestType.ToString() }) + }); + } + + /// + /// Get visual tile data JSON (can be fetched separately for large dungeons) + /// + public string ToVisualTileJson() + { + return JsonSerializer.Serialize(new + { + sheets = TileMapSheets.Select(s => new + { + id = s.Id, + path = s.CdnPath, + tileW = s.TileWidth, + tileH = s.TileHeight, + sheetW = s.SheetWidth, + sheetH = s.SheetHeight, + cols = s.Columns + }), + tiles = TileDetails.Select(t => new + { + x = t.X, + y = t.Y, + tid = t.TileDefinitionId, + l = t.Layer, + r = t.Rotation, + fx = t.FlipX, + fy = t.FlipY + }) + }); + } +} + +/// +/// Tilemap sheet info for client +/// +public class TileMapSheetInfo +{ + public int Id { get; set; } + public string CdnPath { get; set; } = ""; + public int TileWidth { get; set; } + public int TileHeight { get; set; } + public int SheetWidth { get; set; } + public int SheetHeight { get; set; } + public int Columns { get; set; } + public int Rows { get; set; } +} diff --git a/Game/Dungeon/DungeonVisualTileExtensions.cs b/Game/Dungeon/DungeonVisualTileExtensions.cs new file mode 100644 index 0000000..a6c398c --- /dev/null +++ b/Game/Dungeon/DungeonVisualTileExtensions.cs @@ -0,0 +1,163 @@ +using DataServer.Data; +using DataServer.Data.Entities; +using Microsoft.EntityFrameworkCore; +using System.Text.Json; + +namespace Server.Game.Dungeon; + +/// +/// Extension methods for visual tile data +/// +public static class DungeonVisualTileExtensions +{ + /// + /// Build visual tile data for client from room templates used in the dungeon + /// + public static async Task BuildVisualTileDataAsync(this DungeonInstance instance, GameDbContext db) + { + var layout = instance.Simulation.Layout; + + // Check if we have a V2 layout with tile details + if (layout is DungeonLayoutV2 layoutV2 && layoutV2.TileDetails.Count > 0) + { + return new + { + sheets = layoutV2.TileMapSheets.Select(s => new + { + id = s.Id, + path = s.CdnPath, + tileW = s.TileWidth, + tileH = s.TileHeight, + sheetW = s.SheetWidth, + sheetH = s.SheetHeight, + cols = s.Columns + }), + tiles = layoutV2.TileDetails.Select(t => new + { + x = t.X, + y = t.Y, + tid = t.TileDefinitionId, + l = t.Layer, + r = t.Rotation, + fx = t.FlipX, + fy = t.FlipY + }) + }; + } + + // For V1 layouts, try to build visual data from room templates if any were used + // This is a fallback - in practice V2 generator should be used for visual tiles + + // Get rooms that have template IDs (from V2 rooms stored in V1 layout) + var roomsWithTemplates = layout.Rooms + .OfType() + .Where(r => r.TemplateId.HasValue) + .ToList(); + + if (roomsWithTemplates.Count == 0) + { + // No templates used, return null (client will use basic tilemap) + return null; + } + + // Load templates and their tile data + var templateIds = roomsWithTemplates.Select(r => r.TemplateId!.Value).Distinct().ToList(); + var templates = await db.RoomTemplates + .Where(t => templateIds.Contains(t.Id)) + .ToListAsync(); + + // Collect all tile definition IDs + var allTileIds = new HashSet(); + foreach (var template in templates) + { + if (string.IsNullOrEmpty(template.TileDataJson)) continue; + + try + { + var placements = JsonSerializer.Deserialize>(template.TileDataJson); + if (placements != null) + { + foreach (var p in placements) + { + allTileIds.Add(p.TileDefinitionId); + } + } + } + catch { /* Invalid JSON */ } + } + + if (allTileIds.Count == 0) + { + return null; + } + + // Load tile definitions with their sheets + var tileDefinitions = await db.TileDefinitions + .Include(t => t.TileMapSheet) + .Where(t => allTileIds.Contains(t.Id)) + .ToDictionaryAsync(t => t.Id); + + // Build sheets list + var sheets = tileDefinitions.Values + .Select(t => t.TileMapSheet) + .Where(s => s != null) + .DistinctBy(s => s!.Id) + .Select(s => new + { + id = s!.Id, + path = s.CdnPath, + tileW = s.TileWidth, + tileH = s.TileHeight, + sheetW = s.SheetWidth, + sheetH = s.SheetHeight, + cols = s.Columns + }) + .ToList(); + + // Build tiles list + var tiles = new List(); + + foreach (var room in roomsWithTemplates) + { + var template = templates.FirstOrDefault(t => t.Id == room.TemplateId); + if (template == null || string.IsNullOrEmpty(template.TileDataJson)) continue; + + try + { + var placements = JsonSerializer.Deserialize>(template.TileDataJson); + if (placements == null) continue; + + foreach (var p in placements) + { + var tileDef = tileDefinitions.GetValueOrDefault(p.TileDefinitionId); + if (tileDef == null) continue; + + tiles.Add(new + { + x = room.X + p.X, + y = room.Y + p.Y, + tid = p.TileDefinitionId, + sid = tileDef.TileMapSheetId, + frame = tileDef.FrameIndex, + l = p.Layer, + r = p.Rotation, + fx = p.FlipX, + fy = p.FlipY + }); + } + } + catch { /* Invalid JSON */ } + } + + return new { sheets, tiles }; + } + + /// + /// Generate a dungeon using V2 generator with room templates + /// + public static async Task GenerateWithTemplatesAsync(GameDbContext db, int seed, int tier) + { + var generator = new DungeonGeneratorV2(db, seed, tier); + return await generator.GenerateAsync(); + } +}