diff --git a/Game/Dungeon/DungeonGeneratorV2.cs b/Game/Dungeon/DungeonGeneratorV2.cs index 61b495c..93a6690 100644 --- a/Game/Dungeon/DungeonGeneratorV2.cs +++ b/Game/Dungeon/DungeonGeneratorV2.cs @@ -17,6 +17,9 @@ public class DungeonGeneratorV2 private readonly int _tier; private readonly int _tileSize = 32; + private TileTagIndex? _tagIndex; + private const string DefaultBiome = "dungeon"; + // Corridor sizing (in tiles) private const int MinCorridorWidth = 4; private const int MaxCorridorWidth = 8; @@ -57,27 +60,37 @@ public class DungeonGeneratorV2 return c; } + //private TileDefinition? SelectBestFloorTileForTags(HashSet requiredTags) + //{ + // var floors = _tileDefinitions.Values.Where(t => t.Type == TileType.Floor).ToList(); + // if (floors.Count == 0) return null; + + // if (requiredTags.Count == 0) + // return floors[0]; + + // TileDefinition best = floors[0]; + // int bestScore = -1; + // foreach (var f in floors) + // { + // var tags = ParseTags(f.Tags); + // int score = CountOverlap(requiredTags, tags); + // if (score > bestScore) + // { + // best = f; + // bestScore = score; + // } + // } + // return best; + //} private TileDefinition? SelectBestFloorTileForTags(HashSet requiredTags) { + // If you want biome-aware floors later, pass biome from generator settings. + if (_tagIndex != null) + return _tagIndex.FindBestFloor(requiredTags, biome: DefaultBiome); + + // Fallback to your old behavior if index isn't available for some reason var floors = _tileDefinitions.Values.Where(t => t.Type == TileType.Floor).ToList(); - if (floors.Count == 0) return null; - - if (requiredTags.Count == 0) - return floors[0]; - - TileDefinition best = floors[0]; - int bestScore = -1; - foreach (var f in floors) - { - var tags = ParseTags(f.Tags); - int score = CountOverlap(requiredTags, tags); - if (score > bestScore) - { - best = f; - bestScore = score; - } - } - return best; + return floors.FirstOrDefault(); } private RoomTemplate? SelectHallwayTemplate(HashSet requiredTags, string direction) @@ -388,6 +401,7 @@ public class DungeonGeneratorV2 .ToListAsync(); _tileDefinitions = tiles.ToDictionary(t => t.Id); + _tagIndex = new TileTagIndex(_tileDefinitions.Values); _defaultSheet = tiles.FirstOrDefault()?.TileMapSheet; Console.WriteLine($"[DungeonGenV2] Loaded {tiles.Count} tile definitions from templates"); } @@ -920,157 +934,356 @@ public class DungeonGeneratorV2 /// /// Automatically generate wall tiles around floor tiles that border void /// + //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; + // } + + // Console.WriteLine($"[DungeonGenV2] Found {wallTiles.Count} wall tiles for auto-wall generation"); + // foreach (var wt in wallTiles) + // { + // Console.WriteLine($" - {wt.Id}: {wt.Name} (tags: {wt.Tags ?? "none"})"); + // } + + // // Helper to match tags. + // // NOTE: Some of your data has tags separated by commas *and/or* whitespace (e.g. "corner_nw void"), + // // so we split on both to be resilient. + // bool HasTag(TileDefinition t, string tag) + // { + // if (string.IsNullOrWhiteSpace(t.Tags)) return false; + // return t.Tags + // .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) + // .Any(s => s.Equals(tag, StringComparison.OrdinalIgnoreCase)); + // } + + // // Try to find directional walls by tags, fall back to first wall + // var wallNorth = wallTiles.FirstOrDefault(t => HasTag(t, "north")) ?? wallTiles[0]; + // var wallSouth = wallTiles.FirstOrDefault(t => HasTag(t, "south")) ?? wallTiles[0]; + // var wallEast = wallTiles.FirstOrDefault(t => HasTag(t, "east")) ?? wallTiles[0]; + // var wallWest = wallTiles.FirstOrDefault(t => HasTag(t, "west")) ?? wallTiles[0]; + // // Corner tiles: + // // - corner_* indicates which *quadrant of the tile contains the wall mass* (tile itself lives in void space) + // // - many sets also include "void"-tagged corner variants meant specifically for outside/diagonal void corners. + // var wallCornerNE = wallTiles.FirstOrDefault(t => HasTag(t, "corner_ne") && !HasTag(t, "void")) + // ?? wallTiles.FirstOrDefault(t => HasTag(t, "corner_ne")) + // ?? wallTiles[0]; + // var wallCornerNW = wallTiles.FirstOrDefault(t => HasTag(t, "corner_nw") && !HasTag(t, "void")) + // ?? wallTiles.FirstOrDefault(t => HasTag(t, "corner_nw")) + // ?? wallTiles[0]; + // var wallCornerSE = wallTiles.FirstOrDefault(t => HasTag(t, "corner_se") && !HasTag(t, "void")) + // ?? wallTiles.FirstOrDefault(t => HasTag(t, "corner_se")) + // ?? wallTiles[0]; + // var wallCornerSW = wallTiles.FirstOrDefault(t => HasTag(t, "corner_sw") && !HasTag(t, "void")) + // ?? wallTiles.FirstOrDefault(t => HasTag(t, "corner_sw")) + // ?? wallTiles[0]; + + // // Prefer these when a corner tile borders void on TWO orthogonal sides (classic outside corner). + // var wallCornerNEVoid = wallTiles.FirstOrDefault(t => HasTag(t, "corner_ne") && HasTag(t, "void")); + // var wallCornerNWVoid = wallTiles.FirstOrDefault(t => HasTag(t, "corner_nw") && HasTag(t, "void")); + // var wallCornerSEVoid = wallTiles.FirstOrDefault(t => HasTag(t, "corner_se") && HasTag(t, "void")); + // var wallCornerSWVoid = wallTiles.FirstOrDefault(t => HasTag(t, "corner_sw") && HasTag(t, "void")); + + // TileDefinition PickCorner(string cornerTag, bool preferVoid) + // { + // // cornerTag is one of: corner_ne, corner_nw, corner_se, corner_sw + // return cornerTag.ToLowerInvariant() switch + // { + // "corner_ne" => (preferVoid ? wallCornerNEVoid : null) ?? wallCornerNE, + // "corner_nw" => (preferVoid ? wallCornerNWVoid : null) ?? wallCornerNW, + // "corner_se" => (preferVoid ? wallCornerSEVoid : null) ?? wallCornerSE, + // "corner_sw" => (preferVoid ? wallCornerSWVoid : null) ?? wallCornerSW, + // _ => wallCornerNW + // }; + // } + + // Console.WriteLine($"[DungeonGenV2] Wall tile mapping: N={wallNorth.Id}, S={wallSouth.Id}, E={wallEast.Id}, W={wallWest.Id}"); + + // // 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. + // // IMPORTANT: corner_* tags indicate the quadrant where the *wall mass* lives inside this tile. + // // That quadrant matches the direction of the interior (walkable) corner. + // // Example: if the interior is to the NW (diagonal floor at NW), use corner_nw. + // // If this is an *outside* corner (the two orthogonal sides away from the interior are void), + // // prefer a corner variant that includes the "void" tag. + // bool outsideN = IsOutsideAt(x, y - 1); + + // bool outsideS = IsOutsideAt(x, y + 1); + + // bool outsideE = IsOutsideAt(x + 1, y); + + // bool outsideW = IsOutsideAt(x - 1, y); + + // if (hasFloorNorth && hasFloorWest) + // wallTile = PickCorner("corner_nw", preferVoid: (outsideS && outsideE)); + // else if (hasFloorNorth && hasFloorEast) + // wallTile = PickCorner("corner_ne", preferVoid: (outsideS && outsideW)); + // else if (hasFloorSouth && hasFloorWest) + // wallTile = PickCorner("corner_sw", preferVoid: (outsideN && outsideE)); + // else if (hasFloorSouth && hasFloorEast) + // wallTile = PickCorner("corner_se", preferVoid: (outsideN && outsideW)); + // 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 + // }); + // } + + // // Index existing wall visuals so we can update/replace them without duplicating TileDetails entries. + // var wallDetailIndex = new Dictionary<(int X, int Y), int>(); + // for (int i = 0; i < layout.TileDetails.Count; i++) + // { + // var d = layout.TileDetails[i]; + // if (d.Layer == 2) + // wallDetailIndex[(d.X, d.Y)] = i; + // } + + // // Void-corner fill pass: when corridors/walls are thicker, some corner "caps" end up as void tiles that + // // only see walkable space diagonally. Fill those with the appropriate connected corner wall so we don't + // // get little void bite-marks at corridor turns and room borders. + // bool IsWallAt(int wx, int wy) + // { + // if (wx < 0 || wx >= MapWidth || wy < 0 || wy >= MapHeight) return false; + // int tid = layout.Tiles[wx, wy]; + // if (tid == 0) return false; + // return _tileDefinitions.TryGetValue(tid, out var td) && td.Type == TileType.Wall; + // } + + + // bool IsOutsideAt(int wx, int wy) + // { + // // "Outside"/"void" in your terminology: a tile that is NOT walkable and NOT a wall. + // // This prevents treating floor as "void" while still recognizing unfilled space. + // if (wx < 0 || wx >= MapWidth || wy < 0 || wy >= MapHeight) return true; // out of bounds counts as outside + // if (layout.IsWalkable(wx, wy)) return false; + // return !IsWallAt(wx, wy); + // } + + // void PlaceWall(int wx, int wy, TileDefinition tdef) + // { + // layout.Tiles[wx, wy] = tdef.Id; + // if (layout.Walkable != null) layout.Walkable[wx, wy] = false; + + // if (wallDetailIndex.TryGetValue((wx, wy), out var existingIdx)) + // { + // var d = layout.TileDetails[existingIdx]; + // d.TileDefinitionId = tdef.Id; + // d.SheetId = tdef.TileMapSheetId; + // d.FrameIndex = tdef.FrameIndex; + // layout.TileDetails[existingIdx] = d; + // } + // else + // { + // wallDetailIndex[(wx, wy)] = layout.TileDetails.Count; + // layout.TileDetails.Add(new PlacedTile + // { + // X = wx, + // Y = wy, + // TileDefinitionId = tdef.Id, + // SheetId = tdef.TileMapSheetId, + // FrameIndex = tdef.FrameIndex, + // Layer = 2 + // }); + // } + // } + + // for (int x = 1; x < MapWidth - 1; x++) + // { + // for (int y = 1; y < MapHeight - 1; y++) + // { + // if (layout.Tiles[x, y] != 0) continue; // only fill void + // // Don't overwrite walkable tiles (shouldn't happen because walkable implies non-zero, but safe). + // if (layout.IsWalkable(x, y)) continue; + + // bool floorNE = layout.IsWalkable(x + 1, y - 1); + // bool floorNW = layout.IsWalkable(x - 1, y - 1); + // bool floorSE = layout.IsWalkable(x + 1, y + 1); + // bool floorSW = layout.IsWalkable(x - 1, y + 1); + + // bool wallN = IsWallAt(x, y - 1); + // bool wallS = IsWallAt(x, y + 1); + // bool wallE = IsWallAt(x + 1, y); + // bool wallW = IsWallAt(x - 1, y); + + // // Only fill if there's "supporting" wall structure nearby; prevents random diagonal filling. + // // The diagonal walkable indicates the interior corner; the adjacent walls indicate we are on the border. + // // Diagonal-walkable indicates the interior corner. Choose the corner wall variant that visually + // // connects the two bordering wall runs (this tileset uses the opposite naming compared to the + // // earlier assumption, so NW<->SE and NE<->SW). + // // Outside-void corners: if the two orthogonal tiles away from the interior are void, prefer "void" corner variants. + // bool vN = IsOutsideAt(x, y - 1); + + // bool vS = IsOutsideAt(x, y + 1); + + // bool vE = IsOutsideAt(x + 1, y); + + // bool vW = IsOutsideAt(x - 1, y); + + // if (floorSE && (wallS || wallE)) PlaceWall(x, y, PickCorner("corner_se", preferVoid: (vN && vW))); + // else if (floorSW && (wallS || wallW)) PlaceWall(x, y, PickCorner("corner_sw", preferVoid: (vN && vE))); + // else if (floorNE && (wallN || wallE)) PlaceWall(x, y, PickCorner("corner_ne", preferVoid: (vS && vW))); + // else if (floorNW && (wallN || wallW)) PlaceWall(x, y, PickCorner("corner_nw", preferVoid: (vS && vE))); + // } + // } + + // // Corner fix-up pass: if a wall tile meets void on the outside but is adjacent to walkable + // // only diagonally (common with thicker walls / multi-tile corridors), swap in the connected + // // corner tile so the silhouette doesn't look "broken". + // // + // // Example: a boundary wall tile that is NW of a floor tile might not see floor South/East + // // directly (those may be other wall tiles), but it *will* see floor at SE diagonally. + // for (int x = 1; x < MapWidth - 1; x++) + // { + // for (int y = 1; y < MapHeight - 1; y++) + // { + // int id = layout.Tiles[x, y]; + // if (id == 0) continue; + // if (!_tileDefinitions.TryGetValue(id, out var def)) continue; + // if (def.Type != TileType.Wall) continue; + + // bool floorN = layout.IsWalkable(x, y - 1); + // bool floorS = layout.IsWalkable(x, y + 1); + // bool floorE = layout.IsWalkable(x + 1, y); + // bool floorW = layout.IsWalkable(x - 1, y); + + // bool floorNE = layout.IsWalkable(x + 1, y - 1); + // bool floorNW = layout.IsWalkable(x - 1, y - 1); + // bool floorSE = layout.IsWalkable(x + 1, y + 1); + // bool floorSW = layout.IsWalkable(x - 1, y + 1); + + // TileDefinition? replace = null; + + // // Choose connected outer corners using diagonal floor hints. + // bool vN2 = IsOutsideAt(x, y - 1); + + // bool vS2 = IsOutsideAt(x, y + 1); + + // bool vE2 = IsOutsideAt(x + 1, y); + + // bool vW2 = IsOutsideAt(x - 1, y); + + // if (floorSE && !floorS && !floorE) replace = PickCorner("corner_se", preferVoid: (vN2 && vW2)); + // else if (floorSW && !floorS && !floorW) replace = PickCorner("corner_sw", preferVoid: (vN2 && vE2)); + // else if (floorNE && !floorN && !floorE) replace = PickCorner("corner_ne", preferVoid: (vS2 && vW2)); + // else if (floorNW && !floorN && !floorW) replace = PickCorner("corner_nw", preferVoid: (vS2 && vE2)); + + // if (replace == null) continue; + // if (replace.Id == id) continue; + + // layout.Tiles[x, y] = replace.Id; + // if (layout.Walkable != null) layout.Walkable[x, y] = false; + + // // Update existing wall visual if present; otherwise add. + // if (wallDetailIndex.TryGetValue((x, y), out var idx)) + // { + // var d = layout.TileDetails[idx]; + // d.TileDefinitionId = replace.Id; + // d.SheetId = replace.TileMapSheetId; + // d.FrameIndex = replace.FrameIndex; + // layout.TileDetails[idx] = d; + // } + // else + // { + // layout.TileDetails.Add(new PlacedTile + // { + // X = x, + // Y = y, + // TileDefinitionId = replace.Id, + // SheetId = replace.TileMapSheetId, + // FrameIndex = replace.FrameIndex, + // Layer = 2 + // }); + // } + // } + // } + + // Console.WriteLine($"[DungeonGenV2] Generated {wallPositions.Count} auto-walls"); + //} 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) + if (_tagIndex == null) { - Console.WriteLine("[DungeonGenV2] No wall tiles found - skipping auto-wall generation"); + Console.WriteLine("[DungeonGenV2] TagIndex missing - skipping auto-wall generation"); return; } - Console.WriteLine($"[DungeonGenV2] Found {wallTiles.Count} wall tiles for auto-wall generation"); - foreach (var wt in wallTiles) + // We only place *structural* walls here (solid). Add a later pass if you want trim/decor replacement. + var biome = DefaultBiome; + + bool InBounds(int x, int y) => x >= 0 && x < MapWidth && y >= 0 && y < MapHeight; + + bool IsWallAt(int x, int y) { - Console.WriteLine($" - {wt.Id}: {wt.Name} (tags: {wt.Tags ?? "none"})"); + if (!InBounds(x, y)) return false; + var id = layout.Tiles[x, y]; + if (id <= 0) return false; + return _tagIndex.IsKind(id, TileKind.Wall); } - // Helper to match tags. - // NOTE: Some of your data has tags separated by commas *and/or* whitespace (e.g. "corner_nw void"), - // so we split on both to be resilient. - bool HasTag(TileDefinition t, string tag) + bool IsOutsideAt(int x, int y) { - if (string.IsNullOrWhiteSpace(t.Tags)) return false; - return t.Tags - .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) - .Any(s => s.Equals(tag, StringComparison.OrdinalIgnoreCase)); + // "Outside" means: out of bounds OR not walkable AND not a wall + if (!InBounds(x, y)) return true; + if (layout.IsWalkable(x, y)) return false; + return !IsWallAt(x, y); } - // Try to find directional walls by tags, fall back to first wall - var wallNorth = wallTiles.FirstOrDefault(t => HasTag(t, "north")) ?? wallTiles[0]; - var wallSouth = wallTiles.FirstOrDefault(t => HasTag(t, "south")) ?? wallTiles[0]; - var wallEast = wallTiles.FirstOrDefault(t => HasTag(t, "east")) ?? wallTiles[0]; - var wallWest = wallTiles.FirstOrDefault(t => HasTag(t, "west")) ?? wallTiles[0]; - // Corner tiles: - // - corner_* indicates which *quadrant of the tile contains the wall mass* (tile itself lives in void space) - // - many sets also include "void"-tagged corner variants meant specifically for outside/diagonal void corners. - var wallCornerNE = wallTiles.FirstOrDefault(t => HasTag(t, "corner_ne") && !HasTag(t, "void")) - ?? wallTiles.FirstOrDefault(t => HasTag(t, "corner_ne")) - ?? wallTiles[0]; - var wallCornerNW = wallTiles.FirstOrDefault(t => HasTag(t, "corner_nw") && !HasTag(t, "void")) - ?? wallTiles.FirstOrDefault(t => HasTag(t, "corner_nw")) - ?? wallTiles[0]; - var wallCornerSE = wallTiles.FirstOrDefault(t => HasTag(t, "corner_se") && !HasTag(t, "void")) - ?? wallTiles.FirstOrDefault(t => HasTag(t, "corner_se")) - ?? wallTiles[0]; - var wallCornerSW = wallTiles.FirstOrDefault(t => HasTag(t, "corner_sw") && !HasTag(t, "void")) - ?? wallTiles.FirstOrDefault(t => HasTag(t, "corner_sw")) - ?? wallTiles[0]; - - // Prefer these when a corner tile borders void on TWO orthogonal sides (classic outside corner). - var wallCornerNEVoid = wallTiles.FirstOrDefault(t => HasTag(t, "corner_ne") && HasTag(t, "void")); - var wallCornerNWVoid = wallTiles.FirstOrDefault(t => HasTag(t, "corner_nw") && HasTag(t, "void")); - var wallCornerSEVoid = wallTiles.FirstOrDefault(t => HasTag(t, "corner_se") && HasTag(t, "void")); - var wallCornerSWVoid = wallTiles.FirstOrDefault(t => HasTag(t, "corner_sw") && HasTag(t, "void")); - - TileDefinition PickCorner(string cornerTag, bool preferVoid) - { - // cornerTag is one of: corner_ne, corner_nw, corner_se, corner_sw - return cornerTag.ToLowerInvariant() switch - { - "corner_ne" => (preferVoid ? wallCornerNEVoid : null) ?? wallCornerNE, - "corner_nw" => (preferVoid ? wallCornerNWVoid : null) ?? wallCornerNW, - "corner_se" => (preferVoid ? wallCornerSEVoid : null) ?? wallCornerSE, - "corner_sw" => (preferVoid ? wallCornerSWVoid : null) ?? wallCornerSW, - _ => wallCornerNW - }; - } - - Console.WriteLine($"[DungeonGenV2] Wall tile mapping: N={wallNorth.Id}, S={wallSouth.Id}, E={wallEast.Id}, W={wallWest.Id}"); - - // 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. - // IMPORTANT: corner_* tags indicate the quadrant where the *wall mass* lives inside this tile. - // That quadrant matches the direction of the interior (walkable) corner. - // Example: if the interior is to the NW (diagonal floor at NW), use corner_nw. - // If this is an *outside* corner (the two orthogonal sides away from the interior are void), - // prefer a corner variant that includes the "void" tag. - bool outsideN = IsOutsideAt(x, y - 1); - - bool outsideS = IsOutsideAt(x, y + 1); - - bool outsideE = IsOutsideAt(x + 1, y); - - bool outsideW = IsOutsideAt(x - 1, y); - - if (hasFloorNorth && hasFloorWest) - wallTile = PickCorner("corner_nw", preferVoid: (outsideS && outsideE)); - else if (hasFloorNorth && hasFloorEast) - wallTile = PickCorner("corner_ne", preferVoid: (outsideS && outsideW)); - else if (hasFloorSouth && hasFloorWest) - wallTile = PickCorner("corner_sw", preferVoid: (outsideN && outsideE)); - else if (hasFloorSouth && hasFloorEast) - wallTile = PickCorner("corner_se", preferVoid: (outsideN && outsideW)); - 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 - }); - } - - // Index existing wall visuals so we can update/replace them without duplicating TileDetails entries. + // Index existing wall visuals so we can update/replace without duplicates var wallDetailIndex = new Dictionary<(int X, int Y), int>(); for (int i = 0; i < layout.TileDetails.Count; i++) { @@ -1079,47 +1292,27 @@ public class DungeonGeneratorV2 wallDetailIndex[(d.X, d.Y)] = i; } - // Void-corner fill pass: when corridors/walls are thicker, some corner "caps" end up as void tiles that - // only see walkable space diagonally. Fill those with the appropriate connected corner wall so we don't - // get little void bite-marks at corridor turns and room borders. - bool IsWallAt(int wx, int wy) + void PlaceWall(int x, int y, TileDefinition tdef) { - if (wx < 0 || wx >= MapWidth || wy < 0 || wy >= MapHeight) return false; - int tid = layout.Tiles[wx, wy]; - if (tid == 0) return false; - return _tileDefinitions.TryGetValue(tid, out var td) && td.Type == TileType.Wall; - } + layout.Tiles[x, y] = tdef.Id; + if (layout.Walkable != null) layout.Walkable[x, y] = false; - - bool IsOutsideAt(int wx, int wy) - { - // "Outside"/"void" in your terminology: a tile that is NOT walkable and NOT a wall. - // This prevents treating floor as "void" while still recognizing unfilled space. - if (wx < 0 || wx >= MapWidth || wy < 0 || wy >= MapHeight) return true; // out of bounds counts as outside - if (layout.IsWalkable(wx, wy)) return false; - return !IsWallAt(wx, wy); - } - - void PlaceWall(int wx, int wy, TileDefinition tdef) - { - layout.Tiles[wx, wy] = tdef.Id; - if (layout.Walkable != null) layout.Walkable[wx, wy] = false; - - if (wallDetailIndex.TryGetValue((wx, wy), out var existingIdx)) + if (wallDetailIndex.TryGetValue((x, y), out var idx)) { - var d = layout.TileDetails[existingIdx]; + var d = layout.TileDetails[idx]; d.TileDefinitionId = tdef.Id; d.SheetId = tdef.TileMapSheetId; d.FrameIndex = tdef.FrameIndex; - layout.TileDetails[existingIdx] = d; + d.Layer = 2; + layout.TileDetails[idx] = d; } else { - wallDetailIndex[(wx, wy)] = layout.TileDetails.Count; + wallDetailIndex[(x, y)] = layout.TileDetails.Count; layout.TileDetails.Add(new PlacedTile { - X = wx, - Y = wy, + X = x, + Y = y, TileDefinitionId = tdef.Id, SheetId = tdef.TileMapSheetId, FrameIndex = tdef.FrameIndex, @@ -1128,12 +1321,92 @@ public class DungeonGeneratorV2 } } + TileDefinition PickEdge(string dir, bool preferVoidVariant) + { + // Require: wall + edge + direction + // Prefer: solid + // Forbid: door/connector/decorative/trim by default + var required = new[] { "wall", "edge", dir }; + var prefer = new[] { "solid", "stone" }; + var forbid = preferVoidVariant + ? new[] { "door", "doorway", "connector", "decorative", "trim" } // allow void/boundary variants if tagged, but don't force it + : new[] { "door", "doorway", "connector", "decorative", "trim", "void", "empty", "boundary" }; + + var t = _tagIndex!.FindBestWall(required, prefer: prefer, forbid: forbid, allowTrim: false, allowVoidBoundary: preferVoidVariant, biome: biome); + return t ?? _tileDefinitions.Values.First(td => td.Id > 0); // should never happen, but keeps you from crashing + } + + TileDefinition PickCorner(string cornerTag, bool preferVoidVariant) + { + // Require: wall + corner_xx + var required = new[] { "wall", cornerTag }; + var prefer = new[] { "solid", "stone" }; + var forbid = preferVoidVariant + ? new[] { "door", "doorway", "connector", "decorative", "trim" } + : new[] { "door", "doorway", "connector", "decorative", "trim", "void", "empty", "boundary" }; + + var t = _tagIndex!.FindBestWall(required, prefer: prefer, forbid: forbid, allowTrim: false, allowVoidBoundary: preferVoidVariant, biome: biome); + return t ?? PickEdge("north", preferVoidVariant: false); + } + + // MAIN PASS: fill void cells adjacent to walkable with edge/corner walls + int placed = 0; + + for (int x = 0; x < MapWidth; x++) + { + for (int y = 0; y < MapHeight; y++) + { + // Only place into empty/void cells + if (layout.Tiles[x, y] != 0) continue; + if (layout.IsWalkable(x, y)) continue; + + bool floorN = InBounds(x, y - 1) && layout.IsWalkable(x, y - 1); + bool floorS = InBounds(x, y + 1) && layout.IsWalkable(x, y + 1); + bool floorE = InBounds(x + 1, y) && layout.IsWalkable(x + 1, y); + bool floorW = InBounds(x - 1, y) && layout.IsWalkable(x - 1, y); + + if (!(floorN || floorS || floorE || floorW)) continue; + + // Outside check for corner void variants + bool vN = IsOutsideAt(x, y - 1); + bool vS = IsOutsideAt(x, y + 1); + bool vE = IsOutsideAt(x + 1, y); + bool vW = IsOutsideAt(x - 1, y); + + TileDefinition wall; + + // Corners first (interior corner based on two orthogonal floor neighbors) + if (floorN && floorW) wall = PickCorner("corner_nw", preferVoidVariant: (vS && vE)); + else if (floorN && floorE) wall = PickCorner("corner_ne", preferVoidVariant: (vS && vW)); + else if (floorS && floorW) wall = PickCorner("corner_sw", preferVoidVariant: (vN && vE)); + else if (floorS && floorE) wall = PickCorner("corner_se", preferVoidVariant: (vN && vW)); + else + { + // Edges + // NOTE: Direction tag semantics vary by tileset. This mapping assumes dir tag refers to the wall's "side"/edge. + // If your walls look flipped, swap these: + // + // If floor is NORTH of this void cell, the wall tile is on the SOUTH edge of the floor, and might be tagged "south". + // If floor is SOUTH of this void cell, the wall tile might be tagged "north". + // + if (floorS) wall = PickEdge("north", preferVoidVariant: false); + else if (floorN) wall = PickEdge("south", preferVoidVariant: false); + else if (floorE) wall = PickEdge("west", preferVoidVariant: false); + else wall = PickEdge("east", preferVoidVariant: false); + } + + PlaceWall(x, y, wall); + placed++; + } + } + + // DIAGONAL CAP PASS: + // Fill "bite marks" where void sees walkable only diagonally but has nearby wall support. for (int x = 1; x < MapWidth - 1; x++) { for (int y = 1; y < MapHeight - 1; y++) { - if (layout.Tiles[x, y] != 0) continue; // only fill void - // Don't overwrite walkable tiles (shouldn't happen because walkable implies non-zero, but safe). + if (layout.Tiles[x, y] != 0) continue; if (layout.IsWalkable(x, y)) continue; bool floorNE = layout.IsWalkable(x + 1, y - 1); @@ -1146,101 +1419,30 @@ public class DungeonGeneratorV2 bool wallE = IsWallAt(x + 1, y); bool wallW = IsWallAt(x - 1, y); - // Only fill if there's "supporting" wall structure nearby; prevents random diagonal filling. - // The diagonal walkable indicates the interior corner; the adjacent walls indicate we are on the border. - // Diagonal-walkable indicates the interior corner. Choose the corner wall variant that visually - // connects the two bordering wall runs (this tileset uses the opposite naming compared to the - // earlier assumption, so NW<->SE and NE<->SW). - // Outside-void corners: if the two orthogonal tiles away from the interior are void, prefer "void" corner variants. + if (!(wallN || wallS || wallE || wallW)) continue; + bool vN = IsOutsideAt(x, y - 1); - bool vS = IsOutsideAt(x, y + 1); - bool vE = IsOutsideAt(x + 1, y); - bool vW = IsOutsideAt(x - 1, y); - if (floorSE && (wallS || wallE)) PlaceWall(x, y, PickCorner("corner_se", preferVoid: (vN && vW))); - else if (floorSW && (wallS || wallW)) PlaceWall(x, y, PickCorner("corner_sw", preferVoid: (vN && vE))); - else if (floorNE && (wallN || wallE)) PlaceWall(x, y, PickCorner("corner_ne", preferVoid: (vS && vW))); - else if (floorNW && (wallN || wallW)) PlaceWall(x, y, PickCorner("corner_nw", preferVoid: (vS && vE))); - } - } + TileDefinition? cap = null; - // Corner fix-up pass: if a wall tile meets void on the outside but is adjacent to walkable - // only diagonally (common with thicker walls / multi-tile corridors), swap in the connected - // corner tile so the silhouette doesn't look "broken". - // - // Example: a boundary wall tile that is NW of a floor tile might not see floor South/East - // directly (those may be other wall tiles), but it *will* see floor at SE diagonally. - for (int x = 1; x < MapWidth - 1; x++) - { - for (int y = 1; y < MapHeight - 1; y++) - { - int id = layout.Tiles[x, y]; - if (id == 0) continue; - if (!_tileDefinitions.TryGetValue(id, out var def)) continue; - if (def.Type != TileType.Wall) continue; + if (floorSE && (wallS || wallE)) cap = PickCorner("corner_se", preferVoidVariant: (vN && vW)); + else if (floorSW && (wallS || wallW)) cap = PickCorner("corner_sw", preferVoidVariant: (vN && vE)); + else if (floorNE && (wallN || wallE)) cap = PickCorner("corner_ne", preferVoidVariant: (vS && vW)); + else if (floorNW && (wallN || wallW)) cap = PickCorner("corner_nw", preferVoidVariant: (vS && vE)); - bool floorN = layout.IsWalkable(x, y - 1); - bool floorS = layout.IsWalkable(x, y + 1); - bool floorE = layout.IsWalkable(x + 1, y); - bool floorW = layout.IsWalkable(x - 1, y); - - bool floorNE = layout.IsWalkable(x + 1, y - 1); - bool floorNW = layout.IsWalkable(x - 1, y - 1); - bool floorSE = layout.IsWalkable(x + 1, y + 1); - bool floorSW = layout.IsWalkable(x - 1, y + 1); - - TileDefinition? replace = null; - - // Choose connected outer corners using diagonal floor hints. - bool vN2 = IsOutsideAt(x, y - 1); - - bool vS2 = IsOutsideAt(x, y + 1); - - bool vE2 = IsOutsideAt(x + 1, y); - - bool vW2 = IsOutsideAt(x - 1, y); - - if (floorSE && !floorS && !floorE) replace = PickCorner("corner_se", preferVoid: (vN2 && vW2)); - else if (floorSW && !floorS && !floorW) replace = PickCorner("corner_sw", preferVoid: (vN2 && vE2)); - else if (floorNE && !floorN && !floorE) replace = PickCorner("corner_ne", preferVoid: (vS2 && vW2)); - else if (floorNW && !floorN && !floorW) replace = PickCorner("corner_nw", preferVoid: (vS2 && vE2)); - - if (replace == null) continue; - if (replace.Id == id) continue; - - layout.Tiles[x, y] = replace.Id; - if (layout.Walkable != null) layout.Walkable[x, y] = false; - - // Update existing wall visual if present; otherwise add. - if (wallDetailIndex.TryGetValue((x, y), out var idx)) + if (cap != null) { - var d = layout.TileDetails[idx]; - d.TileDefinitionId = replace.Id; - d.SheetId = replace.TileMapSheetId; - d.FrameIndex = replace.FrameIndex; - layout.TileDetails[idx] = d; - } - else - { - layout.TileDetails.Add(new PlacedTile - { - X = x, - Y = y, - TileDefinitionId = replace.Id, - SheetId = replace.TileMapSheetId, - FrameIndex = replace.FrameIndex, - Layer = 2 - }); + PlaceWall(x, y, cap); + placed++; } } } - Console.WriteLine($"[DungeonGenV2] Generated {wallPositions.Count} auto-walls"); + Console.WriteLine($"[DungeonGenV2] Generated {placed} auto-walls (tag-driven)"); } - private RoomTemplate? SelectWeightedTemplate(List templates) { if (templates.Count == 0) return null; diff --git a/Game/Dungeon/TagDrivenTiles.cs b/Game/Dungeon/TagDrivenTiles.cs new file mode 100644 index 0000000..1d5ef0c --- /dev/null +++ b/Game/Dungeon/TagDrivenTiles.cs @@ -0,0 +1,315 @@ +// DungeonGeneratorV2.TagDrivenTiles.cs +// Drop this file next to DungeonGeneratorV2 and wire in the 2 small call sites noted below. +// This adds a fast tag index + robust tile picking (and avoids "Void counted as Wall" issues when DB types are messy). + +using DataServer.Data.Entities; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace Server.Game.Dungeon +{ + /// + /// Normalized tag info: supports comma/space separated tokens + key:value tags. + /// Examples: + /// - "biome:dungeon,corner_ne,north,wall" => Tokens={"corner_ne","north","wall"}, KV["biome"]="dungeon" + /// - "frame:10,sheet:3" => KV["frame"]="10", KV["sheet"]="3" + /// + internal sealed class TagInfo + { + public readonly HashSet Tokens; + public readonly Dictionary KV; + + public TagInfo(HashSet tokens, Dictionary kv) + { + Tokens = tokens; + KV = kv; + } + + public bool Has(string token) => Tokens.Contains(token); + public bool TryGet(string key, out string value) => KV.TryGetValue(key, out value); + } + + internal static class TagParser + { + // Split on commas and whitespace. Your dataset is comma-delimited, but this makes it resilient. + private static readonly char[] _seps = new[] { ',', ' ', '\t', '\r', '\n' }; + + public static TagInfo Parse(string? tags) + { + var tokens = new HashSet(StringComparer.OrdinalIgnoreCase); + var kv = new Dictionary(StringComparer.OrdinalIgnoreCase); + + if (string.IsNullOrWhiteSpace(tags)) + return new TagInfo(tokens, kv); + + foreach (var raw in tags.Split(_seps, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)) + { + if (string.IsNullOrWhiteSpace(raw)) continue; + + var s = raw.Trim(); + var idx = s.IndexOf(':'); + if (idx > 0 && idx < s.Length - 1) + { + var k = s[..idx].Trim(); + var v = s[(idx + 1)..].Trim(); + if (k.Length > 0 && v.Length > 0) + kv[k] = v; + continue; + } + + tokens.Add(s); + } + + return new TagInfo(tokens, kv); + } + } + + internal enum TileKind + { + Unknown = 0, + Void, + Floor, + Wall, + Door, + Decorative + } + + /// + /// Builds a fast index over TileDefinitions using TAGS as truth (not DB TileType), + /// because your sample shows "Void" rows with Type=1 which can collide with "Wall". + /// + internal sealed class TileTagIndex + { + public readonly Dictionary TagById = new(); + public readonly Dictionary KindById = new(); + public readonly List Floors = new(); + public readonly List Walls = new(); + public readonly List Doors = new(); + public readonly List Decorative = new(); + + // Convenience: cached candidates for wall variants + private readonly List _solidWalls = new(); + private readonly List _trimWalls = new(); + private readonly List _voidWalls = new(); // wall-ish void boundary (if you ever want them) + + public TileTagIndex(IEnumerable tiles) + { + foreach (var t in tiles) + { + var info = TagParser.Parse(t.Tags); + TagById[t.Id] = info; + + var kind = Classify(t, info); + KindById[t.Id] = kind; + + switch (kind) + { + case TileKind.Floor: + Floors.Add(t); + break; + case TileKind.Wall: + Walls.Add(t); + if (info.Has("trim")) _trimWalls.Add(t); + else _solidWalls.Add(t); + if (info.Has("void") || info.Has("boundary") || info.Has("empty")) _voidWalls.Add(t); + break; + case TileKind.Door: + Doors.Add(t); + break; + case TileKind.Decorative: + Decorative.Add(t); + break; + } + } + } + + private static TileKind Classify(TileDefinition t, TagInfo info) + { + // Tag-driven classification (more reliable than DB enum when data is inconsistent). + // Priority: door > void > decorative > floor > wall. + if (info.Has("door") || info.Has("doorway") || info.Has("connector")) + return TileKind.Door; + + if (info.Has("void") || info.Has("empty")) + return TileKind.Void; + + if (info.Has("decorative") || info.Has("decor")) + return TileKind.Decorative; + + // Your floor tiles consistently include "floor" and/or "walkable" + if (info.Has("floor") || info.Has("walkable") || t.IsWalkable) + return TileKind.Floor; + + if (info.Has("wall") || info.Has("solid") || info.Has("boundary") || info.Has("trim")) + return TileKind.Wall; + + return TileKind.Unknown; + } + + public TagInfo Tags(TileDefinition t) => TagById.TryGetValue(t.Id, out var ti) ? ti : TagParser.Parse(t.Tags); + + public bool IsKind(int tileId, TileKind kind) => KindById.TryGetValue(tileId, out var k) && k == kind; + + public IEnumerable WallCandidates(bool allowTrim, bool allowVoidBoundary) + { + // Default: prefer solid walls; optionally allow trim. + // "allowVoidBoundary" is off by default; those are the void/boundary wall-ish tiles. + var list = new List(_solidWalls); + if (allowTrim) list.AddRange(_trimWalls); + if (allowVoidBoundary) list.AddRange(_voidWalls); + return list; + } + + public TileDefinition? FindBestFloor(HashSet requiredTokens, string? biome = null) + { + if (Floors.Count == 0) return null; + + // Hard forbids for floors + static bool FloorForbid(TagInfo ti) => + ti.Has("void") || ti.Has("boundary") || ti.Has("door") || ti.Has("doorway") || ti.Has("connector") || + ti.Has("decorative") || ti.Has("trim") || ti.Has("wall"); + + TileDefinition? best = null; + int bestScore = int.MinValue; + + foreach (var f in Floors) + { + var ti = Tags(f); + + if (biome != null && ti.TryGet("biome", out var b) && !b.Equals(biome, StringComparison.OrdinalIgnoreCase)) + continue; + + if (FloorForbid(ti)) continue; + + // Score: + // +100 per required token present (but ignore frame/sheet metadata) + // +10 for "stone" if required includes "stone" (already handled by required token) + // +2 for not being "edge" unless requested + int score = 0; + + foreach (var req in requiredTokens) + { + // ignore metadata-like tokens + if (req.StartsWith("frame:", StringComparison.OrdinalIgnoreCase)) continue; + if (req.StartsWith("sheet:", StringComparison.OrdinalIgnoreCase)) continue; + if (req.StartsWith("biome:", StringComparison.OrdinalIgnoreCase)) continue; + + if (ti.Has(req)) score += 100; + else score -= 50; // soft penalty; we still allow partial matches + } + + // Prefer "plain" floor tiles unless you asked for edges. + if (!requiredTokens.Contains("edge")) score += ti.Has("edge") ? -5 : +2; + + // Prefer walkable + if (f.IsWalkable) score += 5; + + if (score > bestScore) + { + best = f; + bestScore = score; + } + } + + return best ?? Floors[0]; + } + + /// + /// Find the best wall tile matching the requested features. + /// Typically you pass: corner_ne + (optional) void + (optional) trim/solid + (optional) north/east/west/south. + /// + public TileDefinition? FindBestWall( + IEnumerable required, + IEnumerable? prefer = null, + IEnumerable? forbid = null, + bool allowTrim = false, + bool allowVoidBoundary = false, + string? biome = null) + { + var req = required?.Where(s => !string.IsNullOrWhiteSpace(s)).Select(s => s.Trim()).ToArray() ?? Array.Empty(); + var pref = prefer?.Where(s => !string.IsNullOrWhiteSpace(s)).Select(s => s.Trim()).ToArray() ?? Array.Empty(); + var forb = forbid?.Where(s => !string.IsNullOrWhiteSpace(s)).Select(s => s.Trim()).ToArray() ?? Array.Empty(); + + var candidates = WallCandidates(allowTrim, allowVoidBoundary); + TileDefinition? best = null; + int bestScore = int.MinValue; + + foreach (var w in candidates) + { + var ti = Tags(w); + + if (biome != null && ti.TryGet("biome", out var b) && !b.Equals(biome, StringComparison.OrdinalIgnoreCase)) + continue; + + // Never pick doors/decoration as structural walls + if (ti.Has("door") || ti.Has("doorway") || ti.Has("connector") || ti.Has("decorative")) + continue; + + // Forbid list + bool bad = false; + foreach (var f in forb) + { + if (ti.Has(f)) { bad = true; break; } + } + if (bad) continue; + + int score = 0; + + // Required: strong positive if present, strong negative if missing + foreach (var r in req) + { + if (ti.Has(r)) score += 200; + else score -= 200; + } + + // Preferred: small bump + foreach (var p in pref) + { + if (ti.Has(p)) score += 20; + } + + // Prefer "wall"+"solid" unless trim is explicitly wanted + if (!allowTrim) score += ti.Has("trim") ? -50 : +10; + score += ti.Has("solid") ? +10 : 0; + + if (score > bestScore) + { + best = w; + bestScore = score; + } + } + + return best; + } + + public TileDefinition? FindBestDoor(string direction, string? biome = null) + { + if (Doors.Count == 0) return null; + + var dir = direction.Trim().ToLowerInvariant(); + TileDefinition? best = null; + int bestScore = int.MinValue; + + foreach (var d in Doors) + { + var ti = Tags(d); + + if (biome != null && ti.TryGet("biome", out var b) && !b.Equals(biome, StringComparison.OrdinalIgnoreCase)) + continue; + + int score = 0; + if (ti.Has("door")) score += 50; + if (ti.Has("doorway")) score += 20; + if (ti.Has(dir)) score += 40; // north/south etc + if (score > bestScore) + { + best = d; + bestScore = score; + } + } + + return best; + } + } +}