feat(Building): interior systems, NPC navigation, terrain prep, and post-build customization

Building/BuildingPartRegistry.cs

@@ -0,0 +1,215 @@
+using System.Collections.Generic;
+using S1MAPI.Building.Config;
+using S1MAPI.Building.Structural;
+using UnityEngine;
+
+namespace S1MAPI.Building
+{
+    /// <summary>
+    /// Post-build registry that tracks building parts by category.
+    /// Attached to the building root during construction by <see cref="BuildingBuilder"/>.
+    /// Consumers use this to target specific parts (all exterior walls, just the north wall,
+    /// the floor, trim, etc.) and get their renderers for material swaps.
+    /// </summary>
+    public sealed class BuildingPartRegistry
+    {
+        private readonly Dictionary<BuildingPart, List<GameObject>> _parts = new Dictionary<BuildingPart, List<GameObject>>();
+        private readonly Dictionary<WallSide, List<GameObject>> _wallsByDirection = new Dictionary<WallSide, List<GameObject>>();
+
+        #region Registration (called by BuildingBuilder during construction)
+
+        internal void Register(BuildingPart part, GameObject go)
+        {
+            if (!_parts.TryGetValue(part, out var list))
+            {
+                list = new List<GameObject>();
+                _parts[part] = list;
+            }
+            list.Add(go);
+        }
+
+        internal void Register(WallSide side, GameObject go)
+        {
+            if (!_wallsByDirection.TryGetValue(side, out var list))
+            {
+                list = new List<GameObject>();
+                _wallsByDirection[side] = list;
+            }
+            list.Add(go);
+
+            Register(BuildingPart.ExteriorWalls, go);
+        }
+
+        #endregion
+
+        #region Consumer API — Renderers
+
+        /// <summary>
+        /// Get all renderers for a building part category.
+        /// </summary>
+        /// <param name="part">The building part category to query.</param>
+        public Renderer[] GetRenderers(BuildingPart part)
+        {
+            if (!_parts.TryGetValue(part, out var list))
+                return System.Array.Empty<Renderer>();
+
+            var renderers = new List<Renderer>();
+            for (int i = 0; i < list.Count; i++)
+            {
+                if (list[i] != null)
+                    renderers.AddRange(list[i].GetComponentsInChildren<Renderer>());
+            }
+            return renderers.ToArray();
+        }
+
+        /// <summary>
+        /// Get all renderers for a specific wall direction.
+        /// </summary>
+        /// <param name="side">The specific wall side to query.</param>
+        public Renderer[] GetRenderers(WallSide side)
+        {
+            if (!_wallsByDirection.TryGetValue(side, out var list))
+                return System.Array.Empty<Renderer>();
+
+            var renderers = new List<Renderer>();
+            for (int i = 0; i < list.Count; i++)
+            {
+                if (list[i] != null)
+                    renderers.AddRange(list[i].GetComponentsInChildren<Renderer>());
+            }
+            return renderers.ToArray();
+        }
+
+        #endregion
+
+        #region Consumer API — GameObjects
+
+        /// <summary>
+        /// Get all GameObjects for a building part category.
+        /// </summary>
+        /// <param name="part">The building part category to query.</param>
+        public GameObject[] GetParts(BuildingPart part)
+        {
+            if (!_parts.TryGetValue(part, out var list))
+                return System.Array.Empty<GameObject>();
+
+            var result = new List<GameObject>(list.Count);
+            for (int i = 0; i < list.Count; i++)
+            {
+                if (list[i] != null)
+                    result.Add(list[i]);
+            }
+            return result.ToArray();
+        }
+
+        /// <summary>
+        /// Get all GameObjects for a specific wall direction.
+        /// </summary>
+        /// <param name="side">The specific wall side to query.</param>
+        public GameObject[] GetParts(WallSide side)
+        {
+            if (!_wallsByDirection.TryGetValue(side, out var list))
+                return System.Array.Empty<GameObject>();
+
+            var result = new List<GameObject>(list.Count);
+            for (int i = 0; i < list.Count; i++)
+            {
+                if (list[i] != null)
+                    result.Add(list[i]);
+            }
+            return result.ToArray();
+        }
+
+        #endregion
+
+        #region Consumer API — Material swap
+
+        /// <summary>
+        /// Set the material on all renderers for a building part category.
+        /// </summary>
+        /// <param name="part">The building part category to modify.</param>
+        /// <param name="material">The material to apply.</param>
+        public void SetMaterial(BuildingPart part, Material material)
+        {
+            var renderers = GetRenderers(part);
+            for (int i = 0; i < renderers.Length; i++)
+                renderers[i].material = material;
+        }
+
+        /// <summary>
+        /// Set the material on all renderers for a specific wall direction.
+        /// </summary>
+        /// <param name="side">The specific wall side to modify.</param>
+        /// <param name="material">The material to apply.</param>
+        public void SetMaterial(WallSide side, Material material)
+        {
+            var renderers = GetRenderers(side);
+            for (int i = 0; i < renderers.Length; i++)
+                renderers[i].material = material;
+        }
+
+        /// <summary>
+        /// Set the material on a specific submesh index across all renderers for a building part.
+        /// Use submesh 0 for exterior faces, submesh 1 for interior faces on dual-material walls.
+        /// Renderers with fewer submeshes than <paramref name="submeshIndex"/> are skipped.
+        /// </summary>
+        /// <param name="part">The building part category to modify.</param>
+        /// <param name="material">The material to apply.</param>
+        /// <param name="submeshIndex">The submesh index to target (0 = exterior, 1 = interior).</param>
+        public void SetMaterial(BuildingPart part, Material material, int submeshIndex)
+        {
+            var renderers = GetRenderers(part);
+            SetSubmeshMaterial(renderers, material, submeshIndex);
+        }
+
+        /// <summary>
+        /// Set the material on a specific submesh index across all renderers for a wall direction.
+        /// Use submesh 0 for exterior faces, submesh 1 for interior faces on dual-material walls.
+        /// Renderers with fewer submeshes than <paramref name="submeshIndex"/> are skipped.
+        /// </summary>
+        /// <param name="side">The specific wall side to modify.</param>
+        /// <param name="material">The material to apply.</param>
+        /// <param name="submeshIndex">The submesh index to target (0 = exterior, 1 = interior).</param>
+        public void SetMaterial(WallSide side, Material material, int submeshIndex)
+        {
+            var renderers = GetRenderers(side);
+            SetSubmeshMaterial(renderers, material, submeshIndex);
+        }
+
+        /// <summary>
+        /// Set the exterior face material on all exterior wall renderers (submesh 0).
+        /// Only affects dual-material walls created with <see cref="Config.BuildingPalette.InteriorWallMaterial"/>.
+        /// Single-material walls are updated normally.
+        /// </summary>
+        /// <param name="material">The material to apply to exterior faces.</param>
+        public void SetExteriorWallMaterial(Material material)
+        {
+            SetMaterial(BuildingPart.ExteriorWalls, material, 0);
+        }
+
+        /// <summary>
+        /// Set the interior (room-facing) material on all exterior wall renderers (submesh 1).
+        /// Only affects dual-material walls. Renderers with a single material are skipped.
+        /// </summary>
+        /// <param name="material">The material to apply to interior faces.</param>
+        public void SetInteriorFaceMaterial(Material material)
+        {
+            SetMaterial(BuildingPart.ExteriorWalls, material, 1);
+        }
+
+        private static void SetSubmeshMaterial(Renderer[] renderers, Material material, int submeshIndex)
+        {
+            for (int i = 0; i < renderers.Length; i++)
+            {
+                Material[] mats = renderers[i].materials;
+                if (submeshIndex >= 0 && submeshIndex < mats.Length)
+                {
+                    mats[submeshIndex] = material;
+                    renderers[i].materials = mats;
+                }
+            }
+        }
+
+        #endregion
+    }
+}

Building/BuildingUtilities.cs

@@ -132,23 +132,44 @@ public static void ApplyOcclusionSettings(GameObject gameObject, bool allowOcclu
 
         #endregion
 
-        #region Public API - Grid Snapping
-        
+        #region Public API - Grid
+
         /// <summary>
-        /// Snap a position to a grid
+        /// Compute the grid cell size for a room with the given dimensions.
+        /// Returns the largest square cell size ≤ <see cref="Constants.Spatial.DefaultGridSize"/>
+        /// that evenly divides the room's X axis. The pathfinding grid uses this
+        /// same value so furniture placement and NPC navigation are always aligned.
         /// </summary>
-        /// <param name="position">The position to snap</param>
-        /// <param name="gridSize">The grid cell size</param>
-        /// <returns>The snapped position</returns>
-        public static Vector3 SnapToGrid(Vector3 position, float gridSize = Constants.Spatial.DefaultGridSize)
+        public static float ComputeGridCellSize(float roomX, float roomZ)
         {
-            return new Vector3(
-                Mathf.Round(position.x / gridSize) * gridSize,
-                Mathf.Round(position.y / gridSize) * gridSize,
-                Mathf.Round(position.z / gridSize) * gridSize
-            );
+            float target = Constants.Spatial.DefaultGridSize;
+            int nx = Mathf.Max(1, Mathf.CeilToInt(roomX / target));
+            int nz = Mathf.Max(1, Mathf.CeilToInt(roomZ / target));
+            return Mathf.Min(roomX / nx, roomZ / nz);
         }
-
+
+
+        /// <summary>
+        /// Check whether a transform belongs to a living entity (player/NPC) by
+        /// looking for a <see cref="NavMeshAgent"/> or <see cref="CharacterController"/>
+        /// anywhere in its root hierarchy.
+        /// Results are cached in the provided sets for efficiency.
+        /// </summary>
+        /// <returns>true if the transform's root contains a NavMeshAgent or CharacterController.</returns>
+        internal static bool IsLivingEntity(Transform t, HashSet<int> livingRoots, HashSet<int> staticRoots)
+        {
+            int rootId = t.root.GetInstanceID();
+            if (livingRoots.Contains(rootId)) return true;
+            if (staticRoots.Contains(rootId)) return false;
+
+            Transform root = t.root;
+            bool isLiving = root.GetComponentInChildren<NavMeshAgent>() != null
+                         || root.GetComponentInChildren<CharacterController>() != null;
+
+            (isLiving ? livingRoots : staticRoots).Add(rootId);
+            return isLiving;
+        }
+
         #endregion
 
         #region Public API - Hierarchy Organization

Building/Components/LightingBuilder.cs

@@ -58,7 +58,7 @@ public GameObject AddCeilingLights(float? intensity = null, Color? color = null,
 
             float xStep = _roomSize.x / (xCount + 1);
             float zStep = _roomSize.z / (zCount + 1);
-            float yPos = _roomSize.y - 0.2f; // Just below ceiling
+            float yPos = _roomSize.y - 0.3f; // Below ceiling (ceiling sits inside room at _roomSize.y - thickness)
 
             for (int x = 1; x <= xCount; x++)
             {