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