Removing GPT Attempt.

This commit is contained in:
dingo
2025-12-30 14:38:38 -05:00
parent 25cc24fa7a
commit 640bb29bf5
+258 -538
View File
@@ -934,360 +934,157 @@ public class DungeonGeneratorV2
/// <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;
// }
// 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)
{
if (_tagIndex == null)
// Find wall tiles for each direction
var wallTiles = _tileDefinitions.Values.Where(t => t.Type == TileType.Wall).ToList();
if (wallTiles.Count == 0)
{
Console.WriteLine("[DungeonGenV2] TagIndex missing - skipping auto-wall generation");
Console.WriteLine("[DungeonGenV2] No wall tiles found - skipping auto-wall generation");
return;
}
var biome = DefaultBiome;
bool InBounds(int x, int y) => x >= 0 && x < MapWidth && y >= 0 && y < MapHeight;
// TRUE void semantics (your definition): no tile at all (or out of bounds)
bool IsVoidAt(int x, int y)
Console.WriteLine($"[DungeonGenV2] Found {wallTiles.Count} wall tiles for auto-wall generation");
foreach (var wt in wallTiles)
{
if (!InBounds(x, y)) return true;
return layout.Tiles[x, y] == 0;
Console.WriteLine($" - {wt.Id}: {wt.Name} (tags: {wt.Tags ?? "none"})");
}
bool IsWallAt(int x, int y)
// 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 (!InBounds(x, y)) return false;
var id = layout.Tiles[x, y];
if (id <= 0) return false;
return _tagIndex.IsKind(id, TileKind.Wall);
if (string.IsNullOrWhiteSpace(t.Tags)) return false;
return t.Tags
.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
.Any(s => s.Equals(tag, StringComparison.OrdinalIgnoreCase));
}
bool IsWalkableAt(int x, int 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)
{
if (!InBounds(x, y)) return false;
return layout.IsWalkable(x, y);
// 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
};
}
// Index existing wall visuals so we can update/replace without duplicates
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++)
{
@@ -1296,27 +1093,47 @@ public class DungeonGeneratorV2
wallDetailIndex[(d.X, d.Y)] = i;
}
void PlaceWall(int x, int y, TileDefinition tdef)
// 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)
{
layout.Tiles[x, y] = tdef.Id;
if (layout.Walkable != null) layout.Walkable[x, y] = false;
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;
}
if (wallDetailIndex.TryGetValue((x, y), out var idx))
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[idx];
var d = layout.TileDetails[existingIdx];
d.TileDefinitionId = tdef.Id;
d.SheetId = tdef.TileMapSheetId;
d.FrameIndex = tdef.FrameIndex;
d.Layer = 2;
layout.TileDetails[idx] = d;
layout.TileDetails[existingIdx] = d;
}
else
{
wallDetailIndex[(x, y)] = layout.TileDetails.Count;
wallDetailIndex[(wx, wy)] = layout.TileDetails.Count;
layout.TileDetails.Add(new PlacedTile
{
X = x,
Y = y,
X = wx,
Y = wy,
TileDefinitionId = tdef.Id,
SheetId = tdef.TileMapSheetId,
FrameIndex = tdef.FrameIndex,
@@ -1325,217 +1142,120 @@ public class DungeonGeneratorV2
}
}
// --- Selection helpers ----------------------------------------------------
// Global forbids for "structural walls only"
string[] ForbidStructural = new[]
{
"door", "doorway", "connector", "decorative", "trim"
};
// When we do NOT want void variants, we explicitly forbid them
string[] ForbidVoidBoundary = new[]
{
"void", "empty", "boundary"
};
// Basic preference: tweak to your tileset taste
string[] PreferStructural = new[]
{
"solid", "stone"
};
// Safe fallback: any wall tile that is not void/boundary/trim/etc
TileDefinition? FallbackSolidWall()
{
// If TagIndex can enumerate, use it; otherwise fall back to tileDefinitions filtered by kind.
// We assume _tileDefinitions includes all defs; we keep it strict.
foreach (var td in _tileDefinitions.Values)
{
if (td.Id <= 0) continue;
if (!_tagIndex.IsKind(td.Id, TileKind.Wall)) continue;
// Soft-filter using tag text (cheap)
var tags = (td.Tags ?? "").ToLowerInvariant();
bool bad =
tags.Contains("door") || tags.Contains("doorway") || tags.Contains("connector") ||
tags.Contains("decorative") || tags.Contains("trim") ||
tags.Contains("void") || tags.Contains("empty") || tags.Contains("boundary");
if (!bad)
return td;
}
// Absolute last resort: *any* wall
foreach (var td in _tileDefinitions.Values)
{
if (td.Id > 0 && _tagIndex.IsKind(td.Id, TileKind.Wall))
return td;
}
return null;
}
TileDefinition FindBestOrFallback(
string[] requiredA,
string[]? requiredB,
bool preferVoidVariant,
string[]? preferExtra = null)
{
// Prefer list: structural + optional extras + (optionally "void" to bias to void variants)
var prefer = PreferStructural
.Concat(preferExtra ?? Array.Empty<string>())
.Concat(preferVoidVariant ? new[] { "void" } : Array.Empty<string>())
.ToArray();
// Forbid list: always forbid trim/decor/etc, and also forbid void/boundary if not preferring
var forbid = ForbidStructural
.Concat(preferVoidVariant ? Array.Empty<string>() : ForbidVoidBoundary)
.ToArray();
// 1) Strict attempt (requiredA)
var t = _tagIndex!.FindBestWall(
requiredA,
prefer: prefer,
forbid: forbid,
allowTrim: false,
allowVoidBoundary: preferVoidVariant,
biome: biome
);
if (t != null) return t;
// 2) Relaxed attempt (requiredB) if provided
if (requiredB != null)
{
t = _tagIndex!.FindBestWall(
requiredB,
prefer: prefer,
forbid: forbid,
allowTrim: false,
allowVoidBoundary: preferVoidVariant,
biome: biome
);
if (t != null) return t;
}
// 3) Fallback to any solid wall (still a wall)
return FallbackSolidWall() ?? _tileDefinitions.Values.First(td => td.Id > 0);
}
TileDefinition PickEdge(string dir, bool preferVoidVariant)
{
// Many tilesets do NOT tag "edge" consistently. So we try:
// - wall + edge + dir (strict)
// - wall + dir (relaxed)
var requiredStrict = new[] { "wall", "edge", dir };
var requiredLoose = new[] { "wall", dir };
return FindBestOrFallback(requiredStrict, requiredLoose, preferVoidVariant);
}
TileDefinition PickCorner(string cornerTag, bool preferVoidVariant)
{
// Many tilesets do NOT tag a generic "corner"; try:
// - wall + corner_xx (usually enough)
var required = new[] { "wall", cornerTag };
return FindBestOrFallback(required, requiredB: null, preferVoidVariant);
}
// --- MAIN PASS ------------------------------------------------------------
int placed = 0;
for (int x = 0; x < MapWidth; x++)
{
for (int y = 0; y < MapHeight; y++)
{
// Only place into true void (no tile). Also skip walkable (should be redundant).
if (!IsVoidAt(x, y)) continue;
if (IsWalkableAt(x, y)) continue;
bool floorN = IsWalkableAt(x, y - 1);
bool floorS = IsWalkableAt(x, y + 1);
bool floorE = IsWalkableAt(x + 1, y);
bool floorW = IsWalkableAt(x - 1, y);
if (!(floorN || floorS || floorE || floorW)) continue;
// Void checks for preference rule (EXPOSED SIDES of the WALL TILE are void)
// For an interior corner (floorN + floorW), the wall tile's exposed faces are S and E, etc.
bool vN = IsVoidAt(x, y - 1);
bool vS = IsVoidAt(x, y + 1);
bool vE = IsVoidAt(x + 1, y);
bool vW = IsVoidAt(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 (do NOT use void variants here by default; edges usually shouldn't be void-styled)
// Your earlier note about possible flips still applies; keep your mapping:
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 a void cell sees walkable diagonally and has adjacent wall support.
for (int x = 1; x < MapWidth - 1; x++)
{
for (int y = 1; y < MapHeight - 1; y++)
{
if (!IsVoidAt(x, y)) continue;
if (IsWalkableAt(x, y)) continue;
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 = IsWalkableAt(x + 1, y - 1);
bool floorNW = IsWalkableAt(x - 1, y - 1);
bool floorSE = IsWalkableAt(x + 1, y + 1);
bool floorSW = IsWalkableAt(x - 1, y + 1);
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);
if (!(wallN || wallS || wallE || wallW)) continue;
// 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 vN = IsVoidAt(x, y - 1);
bool vS = IsVoidAt(x, y + 1);
bool vE = IsVoidAt(x + 1, y);
bool vW = IsVoidAt(x - 1, y);
bool vS = IsOutsideAt(x, y + 1);
TileDefinition? cap = null;
bool vE = IsOutsideAt(x + 1, y);
// Same preference rule: pick void-variant if the cap tile would have 2 exposed sides void
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 vW = IsOutsideAt(x - 1, y);
if (cap != null)
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))
{
PlaceWall(x, y, cap);
placed++;
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 {placed} auto-walls (tag-driven, void-preference fixed)");
Console.WriteLine($"[DungeonGenV2] Generated {wallPositions.Count} auto-walls");
}
private RoomTemplate? SelectWeightedTemplate(List<RoomTemplate> templates)
{
if (templates.Count == 0) return null;