Files
systemrevivalserver/Game/Dungeon/DungeonGeneratorV2.cs
T
2025-12-28 14:38:12 -05:00

801 lines
30 KiB
C#

using DataServer.Data;
using DataServer.Data.Entities;
using Microsoft.EntityFrameworkCore;
using System.Text.Json;
namespace Server.Game.Dungeon;
/// <summary>
/// Procedural dungeon generator using room templates from database
/// Falls back to basic BSP generation if no templates available
/// </summary>
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<RoomTemplate> _entranceTemplates = new();
private List<RoomTemplate> _exitTemplates = new();
private List<RoomTemplate> _bossTemplates = new();
private List<RoomTemplate> _treasureTemplates = new();
private List<RoomTemplate> _normalTemplates = new();
private List<RoomTemplate> _hallwayTemplates = new();
// Tile definitions cache
private Dictionary<int, TileDefinition> _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<DungeonLayoutV2> 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.Walkable = new bool[MapWidth, MapHeight]; // All false by default
layout.TileDetails = new List<PlacedTile>();
// Generate rooms
int roomCount = _rng.Next(MinRooms, MaxRooms + 1);
var rooms = new List<DungeonRoomV2>();
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<int> { 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<DungeonRoom>().ToList();
// Auto-generate walls around floor tiles
GenerateAutoWalls(layout);
// Build tile data for client
layout.BuildClientTileData(_tileDefinitions, _defaultSheet);
Console.WriteLine($"[DungeonGenV2] Generation complete: {rooms.Count} rooms, {layout.TileDetails.Count} visual tiles, {layout.TileMapSheets.Count} sheets");
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();
Console.WriteLine($"[DungeonGenV2] Loaded templates for tier {_tier}: Entrance={_entranceTemplates.Count}, Exit={_exitTemplates.Count}, Boss={_bossTemplates.Count}, Treasure={_treasureTemplates.Count}, Normal={_normalTemplates.Count}");
// Load tile definitions from templates
var tileIds = templates
.Where(t => !string.IsNullOrEmpty(t.TileDataJson))
.SelectMany(t => {
try {
var placements = JsonSerializer.Deserialize<List<TilePlacement>>(t.TileDataJson!);
return placements?.Select(p => p.TileDefinitionId) ?? Enumerable.Empty<int>();
} catch { return Enumerable.Empty<int>(); }
})
.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;
Console.WriteLine($"[DungeonGenV2] Loaded {tiles.Count} tile definitions from templates");
}
// Always load a default sheet for fallback 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)
{
tile.TileMapSheet = _defaultSheet; // Ensure navigation property is set
_tileDefinitions[tile.Id] = tile;
}
Console.WriteLine($"[DungeonGenV2] Loaded {_defaultSheet.Tiles.Count} tiles from default sheet '{_defaultSheet.Name}'");
}
else
{
Console.WriteLine($"[DungeonGenV2] WARNING: No tilemap sheets found in database!");
}
}
Console.WriteLine($"[DungeonGenV2] Total tile definitions: {_tileDefinitions.Count}");
}
private RoomType DetermineNextRoomType(List<DungeonRoomV2> 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<DungeonRoomV2?> PlaceRoomAsync(DungeonLayoutV2 layout, List<DungeonRoomV2> 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<List<TilePlacement>>(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;
// Look up tile definition for sheet info and walkability
var tileDef = _tileDefinitions.GetValueOrDefault(p.TileDefinitionId);
// Set walkability based on tile definition
if (layout.Walkable != null && tileDef != null)
{
layout.Walkable[worldX, worldY] = tileDef.IsWalkable;
}
layout.TileDetails.Add(new PlacedTile
{
X = worldX,
Y = worldY,
TileDefinitionId = p.TileDefinitionId,
SheetId = tileDef?.TileMapSheetId ?? 0,
FrameIndex = tileDef?.FrameIndex ?? 0,
Layer = p.Layer,
Rotation = p.Rotation,
FlipX = p.FlipX,
FlipY = p.FlipY
});
}
}
}
}
catch { /* Invalid JSON, fall through to basic carve */ }
}
// Parse connection points from template
if (!string.IsNullOrEmpty(template.ConnectionPointsJson))
{
try
{
var connections = JsonSerializer.Deserialize<List<ConnectionPoint>>(template.ConnectionPointsJson);
if (connections != null)
{
room.ConnectionPoints = connections;
}
}
catch { /* Invalid JSON */ }
}
// If no connection points defined, create default ones on each edge
if (room.ConnectionPoints.Count == 0)
{
room.ConnectionPoints = new List<ConnectionPoint>
{
new() { X = room.Width / 2, Y = 0, Direction = "north", Width = 2 },
new() { X = room.Width / 2, Y = room.Height - 1, Direction = "south", Width = 2 },
new() { X = 0, Y = room.Height / 2, Direction = "west", Width = 2 },
new() { X = room.Width - 1, Y = room.Height / 2, Direction = "east", Width = 2 }
};
}
// 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<DungeonRoomV2> 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
// Set walkability - basic carved rooms are always walkable
if (layout.Walkable != null)
{
layout.Walkable[x, y] = true;
}
if (floorId > 0 && floorTile != null)
{
layout.TileDetails.Add(new PlacedTile
{
X = x, Y = y,
TileDefinitionId = floorId,
SheetId = floorTile.TileMapSheetId,
FrameIndex = floorTile.FrameIndex,
Layer = 0
});
}
}
}
}
}
private async Task ConnectRoomsAsync(DungeonLayoutV2 layout, DungeonRoomV2 a, DungeonRoomV2 b)
{
var floorTile = _tileDefinitions.Values.FirstOrDefault(t => t.Type == TileType.Floor);
int floorId = floorTile?.Id ?? 1;
int sheetId = floorTile?.TileMapSheetId ?? 0;
int frameIndex = floorTile?.FrameIndex ?? 0;
// Determine best connection points based on relative positions
string aDirection, bDirection;
int deltaX = b.CenterX - a.CenterX;
int deltaY = b.CenterY - a.CenterY;
// Choose connection directions based on which room is where
if (Math.Abs(deltaX) > Math.Abs(deltaY))
{
// Horizontal connection preferred
aDirection = deltaX > 0 ? "east" : "west";
bDirection = deltaX > 0 ? "west" : "east";
}
else
{
// Vertical connection preferred
aDirection = deltaY > 0 ? "south" : "north";
bDirection = deltaY > 0 ? "north" : "south";
}
// Get connection points (or fall back to center)
var cpA = a.GetConnectionPoint(aDirection);
var cpB = b.GetConnectionPoint(bDirection);
int startX, startY, endX, endY;
int corridorWidth = 2;
if (cpA != null)
{
var (wx, wy) = a.GetConnectionWorldPos(cpA);
startX = wx;
startY = wy;
corridorWidth = Math.Max(corridorWidth, cpA.Width);
}
else
{
startX = a.CenterX;
startY = a.CenterY;
}
if (cpB != null)
{
var (wx, wy) = b.GetConnectionWorldPos(cpB);
endX = wx;
endY = wy;
corridorWidth = Math.Max(corridorWidth, cpB.Width);
}
else
{
endX = b.CenterX;
endY = b.CenterY;
}
// L-shaped corridor from connection point to connection point
if (_rng.Next(2) == 0)
{
CarveHorizontalCorridor(layout, startX, endX, startY, floorId, sheetId, frameIndex, corridorWidth);
CarveVerticalCorridor(layout, startY, endY, endX, floorId, sheetId, frameIndex, corridorWidth);
}
else
{
CarveVerticalCorridor(layout, startY, endY, startX, floorId, sheetId, frameIndex, corridorWidth);
CarveHorizontalCorridor(layout, startX, endX, endY, floorId, sheetId, frameIndex, corridorWidth);
}
}
private void CarveHorizontalCorridor(DungeonLayoutV2 layout, int x1, int x2, int y, int floorId, int sheetId, int frameIndex, int width = 2)
{
int minX = Math.Min(x1, x2);
int maxX = Math.Max(x1, x2);
for (int x = minX; x <= maxX; x++)
{
for (int dy = 0; dy < width; dy++)
{
int ty = y + dy - width / 2; // Center the corridor
if (x >= 0 && x < MapWidth && ty >= 0 && ty < MapHeight && layout.Tiles[x, ty] == 0)
{
layout.Tiles[x, ty] = floorId;
// Set walkability for corridors
if (layout.Walkable != null)
{
layout.Walkable[x, ty] = true;
}
if (floorId > 0 && sheetId > 0)
{
layout.TileDetails.Add(new PlacedTile
{
X = x, Y = ty,
TileDefinitionId = floorId,
SheetId = sheetId,
FrameIndex = frameIndex,
Layer = 0
});
}
}
}
}
}
private void CarveVerticalCorridor(DungeonLayoutV2 layout, int y1, int y2, int x, int floorId, int sheetId, int frameIndex, int width = 2)
{
int minY = Math.Min(y1, y2);
int maxY = Math.Max(y1, y2);
for (int y = minY; y <= maxY; y++)
{
for (int dx = 0; dx < width; dx++)
{
int tx = x + dx - width / 2; // Center the corridor
if (tx >= 0 && tx < MapWidth && y >= 0 && y < MapHeight && layout.Tiles[tx, y] == 0)
{
layout.Tiles[tx, y] = floorId;
// Set walkability for corridors
if (layout.Walkable != null)
{
layout.Walkable[tx, y] = true;
}
if (floorId > 0 && sheetId > 0)
{
layout.TileDetails.Add(new PlacedTile
{
X = tx, Y = y,
TileDefinitionId = floorId,
SheetId = sheetId,
FrameIndex = frameIndex,
Layer = 0
});
}
}
}
}
}
/// <summary>
/// Automatically generate wall tiles around floor tiles that border void
/// </summary>
private void GenerateAutoWalls(DungeonLayoutV2 layout)
{
// Find wall tiles for each direction
var wallTiles = _tileDefinitions.Values.Where(t => t.Type == TileType.Wall).ToList();
if (wallTiles.Count == 0)
{
Console.WriteLine("[DungeonGenV2] No wall tiles found - skipping auto-wall generation");
return;
}
// Try to find directional walls by tags, fall back to first wall
var wallNorth = wallTiles.FirstOrDefault(t => t.Tags?.Contains("north") == true) ?? wallTiles[0];
var wallSouth = wallTiles.FirstOrDefault(t => t.Tags?.Contains("south") == true) ?? wallTiles[0];
var wallEast = wallTiles.FirstOrDefault(t => t.Tags?.Contains("east") == true) ?? wallTiles[0];
var wallWest = wallTiles.FirstOrDefault(t => t.Tags?.Contains("west") == true) ?? wallTiles[0];
var wallCornerNE = wallTiles.FirstOrDefault(t => t.Tags?.Contains("corner_ne") == true) ?? wallTiles[0];
var wallCornerNW = wallTiles.FirstOrDefault(t => t.Tags?.Contains("corner_nw") == true) ?? wallTiles[0];
var wallCornerSE = wallTiles.FirstOrDefault(t => t.Tags?.Contains("corner_se") == true) ?? wallTiles[0];
var wallCornerSW = wallTiles.FirstOrDefault(t => t.Tags?.Contains("corner_sw") == true) ?? wallTiles[0];
// Track positions that need walls
var wallPositions = new List<(int X, int Y, TileDefinition Tile)>();
// Check each void tile to see if it borders a floor
for (int x = 0; x < MapWidth; x++)
{
for (int y = 0; y < MapHeight; y++)
{
// Skip if not void
if (layout.Tiles[x, y] != 0) continue;
// Check neighbors for floor tiles (walkable)
bool hasFloorNorth = y > 0 && layout.IsWalkable(x, y - 1);
bool hasFloorSouth = y < MapHeight - 1 && layout.IsWalkable(x, y + 1);
bool hasFloorEast = x < MapWidth - 1 && layout.IsWalkable(x + 1, y);
bool hasFloorWest = x > 0 && layout.IsWalkable(x - 1, y);
// If any adjacent tile is floor, this should be a wall
if (hasFloorNorth || hasFloorSouth || hasFloorEast || hasFloorWest)
{
// Determine wall type based on which direction has floor
TileDefinition wallTile;
// Check for corners first
if (hasFloorSouth && hasFloorEast)
wallTile = wallCornerNW;
else if (hasFloorSouth && hasFloorWest)
wallTile = wallCornerNE;
else if (hasFloorNorth && hasFloorEast)
wallTile = wallCornerSW;
else if (hasFloorNorth && hasFloorWest)
wallTile = wallCornerSE;
else if (hasFloorSouth)
wallTile = wallNorth; // Wall is north of floor, so it's a north-facing wall
else if (hasFloorNorth)
wallTile = wallSouth;
else if (hasFloorEast)
wallTile = wallWest;
else
wallTile = wallEast;
wallPositions.Add((x, y, wallTile));
}
}
}
// Place wall tiles
foreach (var (x, y, tile) in wallPositions)
{
layout.Tiles[x, y] = tile.Id;
// Walls are not walkable
if (layout.Walkable != null)
{
layout.Walkable[x, y] = false;
}
layout.TileDetails.Add(new PlacedTile
{
X = x, Y = y,
TileDefinitionId = tile.Id,
SheetId = tile.TileMapSheetId,
FrameIndex = tile.FrameIndex,
Layer = 2 // Walls on layer 2
});
}
Console.WriteLine($"[DungeonGenV2] Generated {wallPositions.Count} auto-walls");
}
private RoomTemplate? SelectWeightedTemplate(List<RoomTemplate> 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<DungeonRoomV2> 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;
}
}
/// <summary>
/// Extended room with template info
/// </summary>
public class DungeonRoomV2 : DungeonRoom
{
public int? TemplateId { get; set; }
public string? TemplateName { get; set; }
public new RoomType Type { get; set; } = RoomType.Normal;
/// <summary>Connection points parsed from template</summary>
public List<ConnectionPoint> ConnectionPoints { get; set; } = new();
public DungeonRoomV2(int x, int y, int width, int height) : base(x, y, width, height) { }
/// <summary>Get the best connection point for a given direction</summary>
public ConnectionPoint? GetConnectionPoint(string direction)
{
return ConnectionPoints.FirstOrDefault(c => c.Direction.Equals(direction, StringComparison.OrdinalIgnoreCase))
?? ConnectionPoints.FirstOrDefault(); // Fallback to any
}
/// <summary>Get world position of a connection point</summary>
public (int X, int Y) GetConnectionWorldPos(ConnectionPoint cp)
{
return (X + cp.X, Y + cp.Y);
}
}
/// <summary>
/// Placed tile with details
/// </summary>
public class PlacedTile
{
public int X { get; set; }
public int Y { get; set; }
public int TileDefinitionId { get; set; }
public int SheetId { get; set; } // For client rendering
public int FrameIndex { get; set; } // Frame in the sheet
public int Layer { get; set; }
public int Rotation { get; set; }
public bool FlipX { get; set; }
public bool FlipY { get; set; }
}