World: ground bundle — macro-blend ground materials, per-room dressing scatter, biome ground tint, base flora + worn paths

Phase 1.5b ground bundle (operator: "the ground is very plain"): - Ground materials rebuilt: Grass/Sand base maps at real tiling (22x/26x, was a 2x smear across 90-130u) + Synty normal maps + a generated 0.5-centered macro noise detail texture (LINEAR import — sRGB detail mul2x darkens 2.3x) with baked rim vignette. Meadow ground moved OFF the shared Synty asset onto project-owned Mat_Ground_Meadow. - WorldAtmosphereSystem: per-room-biome ground tint on the expedition quads via MaterialPropertyBlock (Meadow green / Cavern blue / Blight purple; Arid sand default), lerped alongside the existing fog/ambient palettes. - RoomDressingSystem + RoomDressingConfig (new, client-only observe-only): 26 biome-flavoured cosmetic props per room, scattered inside the room's ACTUAL shape (same RoomLayoutMath authority as the server, distinct 0xD2E55 hash stream), deterministic from the replicated run seed, torn down with the room, colliders stripped. 47 curated prefab refs wired in Game.unity (build-safe). - Base: 357 curated flora props re-enabled (bushes/wildflowers/grass clumps; buildings/pond/FX stay parked) + generated worn-dirt paths storage->warpgate and storage->base gate. Live-verified: dressing 26/26 inside x[981,1023] z[-11,12] y=0, 11 varieties, 0 colliders; teardown on run end; Meadow tint converged to exact target; 470 EditMode green; console clean. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-11 22:47:44 -07:00
parent cf206d356a
commit 2fc5ae9a10
19 changed files with 1594 additions and 372 deletions
@@ -0,0 +1,34 @@
+using UnityEngine;
+
+namespace ProjectM.Client
+{
+    /// <summary>
+    /// Live-tunable knobs + build-safe prefab references for <see cref="RoomDressingSystem"/> — the Phase 1.5b
+    /// per-room cosmetic dressing scatter. Mirrors the <see cref="AmbientMotionConfig"/>/<see cref="VFXConfig"/>
+    /// bridge idiom: a MonoBehaviour in the gameplay scene with a static <see cref="Instance"/> the client
+    /// presentation system reads. Prefab arrays are serialized scene references (never Resources.Load — that is
+    /// build-stripped). Absent config or an empty set = no dressing (the feature is soft-off).
+    /// </summary>
+    public sealed class RoomDressingConfig : MonoBehaviour
+    {
+        public static RoomDressingConfig Instance;
+
+        [Header("Master")]
+        public bool Enabled = true;
+        [Min(0)] public int CountPerRoom = 26;
+        [Min(0.1f)] public float ScaleMin = 0.85f;
+        [Min(0.1f)] public float ScaleMax = 1.35f;
+
+        [Header("Per-biome cosmetic prop sets (RoomBiomeId: Meadow/Arid/Cavern/Blight)")]
+        public GameObject[] Meadow;
+        public GameObject[] Arid;
+        public GameObject[] Cavern;
+        public GameObject[] Blight;
+
+        void OnEnable() { Instance = this; }
+        void OnDisable() { if (Instance == this) Instance = null; }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        static void ResetStatics() { Instance = null; }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4ef612b567d6f6746bc03f764274740e
@@ -0,0 +1,111 @@
+using ProjectM.Simulation;
+using Unity.Entities;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace ProjectM.Client
+{
+    /// <summary>
+    /// Phase 1.5b (ground bundle) — client-only, observe-only PER-ROOM DRESSING SCATTER. A managed
+    /// <see cref="SystemBase"/> in <see cref="PresentationSystemGroup"/> that OBSERVES replicated
+    /// <see cref="RunInfo"/> and instantiates biome-flavoured cosmetic ground props (pebbles, tufts, bones,
+    /// mushrooms) inside the room's ACTUAL shape — the same <see cref="RoomLayoutMath"/> authority the server
+    /// scatter uses, on a DISTINCT hash stream so dressing never co-locates with nodes (0x0DE) or clutter
+    /// (0xC17). Deterministic from the replicated run seed: every co-op client (and a late-joiner) sees the
+    /// same floor. Torn down when the room changes or the run ends. Colliders + rigidbodies are stripped on
+    /// spawn — the aim-reticle raycast and the physics world must never see dressing. Never mutates the sim.
+    /// </summary>
+    [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
+    [UpdateInGroup(typeof(PresentationSystemGroup))]
+    public partial class RoomDressingSystem : SystemBase
+    {
+        Transform _root;
+        uint _activeKey;
+
+        protected override void OnStartRunning()
+        {
+            if (_root == null) _root = new GameObject("~RoomDressing").transform;
+        }
+
+        protected override void OnDestroy()
+        {
+            if (_root != null) Object.Destroy(_root.gameObject);
+        }
+
+        protected override void OnUpdate()
+        {
+            if (UnityEngine.SceneManagement.SceneManager.GetActiveScene().name != "Game") return;
+            if (_root == null) return;
+
+            var cfg = RoomDressingConfig.Instance;
+            bool inRoom = SystemAPI.TryGetSingleton<RunInfo>(out var ri)
+                          && (ri.Lifecycle == RunLifecycle.InRoom
+                              || ri.Lifecycle == RunLifecycle.RoomReward
+                              || ri.Lifecycle == RunLifecycle.RoomExplore);
+            bool on = cfg != null && cfg.Enabled && cfg.CountPerRoom > 0;
+            if (!inRoom || !on || !SystemAPI.TryGetSingleton<BaseAnchor>(out var anchor))
+            {
+                Clear();
+                return;
+            }
+
+            uint key = RunMapMath.Hash(ri.RunSeed, (uint)(ri.CurrentRoom + 1), 0xD2E5u);
+            if (key == _activeKey) return;
+            Clear();
+            Build(in ri, in anchor, cfg);
+            _activeKey = key;
+        }
+
+        void Clear()
+        {
+            if (_activeKey == 0 || _root == null) { _activeKey = 0; return; }
+            for (int i = _root.childCount - 1; i >= 0; i--)
+                Object.Destroy(_root.GetChild(i).gameObject);
+            _activeKey = 0;
+        }
+
+        void Build(in RunInfo ri, in BaseAnchor anchor, RoomDressingConfig cfg)
+        {
+            GameObject[] set = ri.CurrentBiome switch
+            {
+                RoomBiomeId.Meadow => cfg.Meadow,
+                RoomBiomeId.Cavern => cfg.Cavern,
+                RoomBiomeId.Blight => cfg.Blight,
+                _ => cfg.Arid,
+            };
+            if (set == null || set.Length == 0) return;
+
+            float3 baseCenter = BaseGridMath.PlotCenter(anchor);
+            byte subSlot = (byte)(ri.CurrentRoom & 1);
+            float3 origin = RegionMath.ExpeditionRoomOrigin(baseCenter, subSlot);
+            float3 portal = RegionMath.ExpeditionPortalPos(baseCenter, subSlot);
+
+            var map = RunMapMath.Generate(ri.RunSeed);
+            var node = map.NodeAt(RunMap.NodeId(ri.CurrentRoom, ri.CurrentCol));
+            var plan = RoomLayoutMath.Plan(node, ri.CurrentRoom, ri.RoomCount);
+            var rng = new Unity.Mathematics.Random(RunMapMath.Hash(ri.RunSeed, (uint)(ri.CurrentRoom + 1), 0xD2E55u) | 1u);
+
+            int count = cfg.CountPerRoom;
+            for (int i = 0; i < count; i++)
+            {
+                float3 pos = RoomLayoutMath.ScatterInShape(plan.ShapeId, origin, i, count, ref rng);
+                for (int attempt = 0; attempt < 4; attempt++)
+                {
+                    bool nearLanding = math.distancesq(pos.xz, origin.xz) < 9f;   // party lands at the origin
+                    bool nearPortal = math.distancesq(pos.xz, portal.xz) < 6.25f; // keep the exit beacon clear
+                    if (!nearLanding && !nearPortal) break;
+                    pos = RoomLayoutMath.ScatterInShape(plan.ShapeId, origin, i, count, ref rng);
+                }
+                var prefab = set[rng.NextInt(0, set.Length)];
+                if (prefab == null) continue;
+                var go = Object.Instantiate(prefab, _root, false);
+                go.transform.SetPositionAndRotation(
+                    new Vector3(pos.x, 0f, pos.z), // terrain y=0 (origin.y is the CC capsule plane, 1 u up)
+                    Quaternion.Euler(0f, rng.NextFloat(0f, 360f), 0f));
+                go.transform.localScale = Vector3.one * rng.NextFloat(cfg.ScaleMin, cfg.ScaleMax);
+                foreach (var col in go.GetComponentsInChildren<Collider>(true)) Object.Destroy(col);
+                foreach (var rb in go.GetComponentsInChildren<Rigidbody>(true)) Object.Destroy(rb);
+            }
+        }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6eb0d1fcbd0a69244842b4eb2fbcd49f
@@ -13,13 +13,18 @@ namespace ProjectM.Client
    /// the simulation, no ECS query (camera + RenderSettings only). Knobs live in
    /// <see cref="WorldAtmosphereConfig"/> (falls back to baked defaults when absent). Guarded to the gameplay
    /// "Game" scene so it never restyles the menu. Fog enable/mode + equator/ground ambient are baked into the
-    /// scene; this only drives the per-region deltas.
+    /// scene; this only drives the per-region deltas. Phase 1.5b: also drives a per-room-biome tint on the
+    /// expedition ground quads (MaterialPropertyBlock — the material asset is never touched).
    /// </summary>
    [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
    [UpdateInGroup(typeof(PresentationSystemGroup))]
    public partial class WorldAtmosphereSystem : SystemBase
    {
        Camera _cam;
+        MeshRenderer[] _ground;
+        MaterialPropertyBlock _mpb;
+        Color _groundCur;
+        static readonly int BaseColorId = Shader.PropertyToID("_BaseColor");

        protected override void OnUpdate()
        {
@@ -41,29 +46,32 @@ namespace ProjectM.Client
            // (RunInfo.CurrentBiome) so every room re-themes — the camera-X blend still owns the base↔run fade.
            // Palettes are code consts (cosmetic; per-biome config knobs can layer on later without churn).
            // Phase 1.5: all palettes moved to the dark-ambient set (dynamic lights carry readability).
-            if (SystemAPI.TryGetSingleton<ProjectM.Simulation.RunInfo>(out var runInfo)
-                && runInfo.Lifecycle != ProjectM.Simulation.RunLifecycle.Staging)
+            // Ground tints are ABSOLUTE _BaseColor values (the MPB replaces the authored arid sand tint).
+            Color groundTarget = new Color(0.60f, 0.56f, 0.50f, 1f); // authored arid sand (Mat_Ground_Arid_Dark)
+            bool haveRun = SystemAPI.TryGetSingleton<ProjectM.Simulation.RunInfo>(out var runInfo);
+            if (haveRun && runInfo.Lifecycle != ProjectM.Simulation.RunLifecycle.Staging)
            {
                switch (runInfo.CurrentBiome)
                {
                    case ProjectM.Simulation.RoomBiomeId.Meadow:
                        expFog = new Color(0.10f, 0.16f, 0.10f, 1f); expDen = 0.012f;
                        expAmb = new Color(0.30f, 0.42f, 0.32f, 1f);
+                        groundTarget = new Color(0.47f, 0.55f, 0.43f, 1f);
                        break;
                    case ProjectM.Simulation.RoomBiomeId.Cavern:
                        expFog = new Color(0.06f, 0.08f, 0.12f, 1f); expDen = 0.020f;
                        expAmb = new Color(0.24f, 0.28f, 0.38f, 1f);
+                        groundTarget = new Color(0.42f, 0.46f, 0.55f, 1f);
                        break;
                    case ProjectM.Simulation.RoomBiomeId.Blight:
                        expFog = new Color(0.13f, 0.07f, 0.15f, 1f); expDen = 0.022f;
                        expAmb = new Color(0.32f, 0.24f, 0.38f, 1f);
+                        groundTarget = new Color(0.52f, 0.42f, 0.58f, 1f);
                        break;
-                    // Arid keeps the config/default burnt-dusk orange above.
+                    // Arid keeps the config/default burnt-dusk orange + sand ground above.
                }
            }

-
-
            float x = _cam.transform.position.x;
            float t = Mathf.Clamp01((x - (boundary - half)) / (2f * half));
            t = t * t * (3f - 2f * t); // smoothstep
@@ -71,6 +79,27 @@ namespace ProjectM.Client
            RenderSettings.fogColor = Color.Lerp(baseFog, expFog, t);
            RenderSettings.fogDensity = Mathf.Lerp(baseDen, expDen, t);
            RenderSettings.ambientSkyColor = Color.Lerp(baseAmb, expAmb, t);
+
+            // Per-room-biome ground tint (expedition quads only; the meadow base keeps its authored material).
+            if (_ground == null)
+            {
+                var found = new System.Collections.Generic.List<MeshRenderer>();
+                foreach (var mr in Object.FindObjectsByType<MeshRenderer>(FindObjectsSortMode.None))
+                    if (mr.gameObject.name == "Ground_Arid") found.Add(mr);
+                if (found.Count > 0)
+                {
+                    _ground = found.ToArray();
+                    _mpb = new MaterialPropertyBlock();
+                    _groundCur = groundTarget; // snap on first sight — no lerp from black
+                }
+            }
+            if (_ground != null)
+            {
+                _groundCur = Color.Lerp(_groundCur, groundTarget, 1f - Mathf.Exp(-2.5f * UnityEngine.Time.deltaTime));
+                _mpb.SetColor(BaseColorId, _groundCur);
+                for (int i = 0; i < _ground.Length; i++)
+                    if (_ground[i] != null) _ground[i].SetPropertyBlock(_mpb);
+            }
        }
    }
 }