// 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 GameServer.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; } } }