Import art/VFX asset packs + game-feel systems; normalize texture extensions to lowercase for LFS

Add BefourStudios SciFi environment packs, Gabriel Aguiar VFX, and the ShaderCrew Toon Shader embedded packages, plus combat/enemy/wave/death gameplay systems and supporting vault docs/screenshots. Rename 11 vendor textures from uppercase .PNG/.HDR to lowercase so the case-sensitive Git LFS filters (*.png/*.hdr) match on case-sensitive filesystems (Linux CI, case-sensitive macOS), not just locally where core.ignorecase=true masks the gap. Each .meta moved with its asset so GUID references are preserved. All ~1000 binaries tracked via LFS. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-06-02 22:50:43 -07:00
parent dd0064c377
commit e362aaeb43
4830 changed files with 1293057 additions and 38 deletions
@@ -0,0 +1,329 @@
+using System.Collections.Generic;
+using ProjectM.Simulation;
+using Unity.Entities;
+using Unity.Mathematics;
+using Unity.NetCode;
+using Unity.Transforms;
+using UnityEngine;
+
+namespace ProjectM.Client
+{
+    /// <summary>
+    /// Client-only combat JUICE. A managed presentation system (SystemBase, main thread, NO Burst) in the
+    /// <see cref="PresentationSystemGroup"/> that REACTS to replicated state — it never runs simulation. Each frame
+    /// it edge-detects every damageable ghost's replicated <see cref="Health"/>: a decrease spawns a floating
+    /// damage number + a hit-spark burst + a hit SFX + camera shake; a Husk despawn (server-authoritative death)
+    /// spawns a death burst + death SFX; the local player crossing to 0 HP does the same. A local-player ability
+    /// fire (AbilityCooldown advancing) spawns a muzzle flash + zap. Everything derives from already-replicated
+    /// state, so it is correct without touching the prediction loop, and it lives only in the client world so the
+    /// server never instantiates GameObjects. SFX are generated procedurally; VFX use a small runtime pool — the
+    /// slice ships with NO binary audio/particle assets.
+    /// <para>
+    /// Per-entity last Health + position + isEnemy are cached in a managed dictionary (Entity is a stable client
+    /// key for a ghost's lifetime); stale keys are pruned each frame (a pruned Husk = a kill → death VFX at its
+    /// last position). Never destroys a ghost from the client — GhostDespawnSystem owns that off the snapshot
+    /// protocol; we only OBSERVE.
+    /// </para>
+    /// </summary>
+    [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
+    [UpdateInGroup(typeof(PresentationSystemGroup))]
+    public partial class CombatFeedbackSystem : SystemBase
+    {
+        struct FxCache { public float Hp; public float3 Pos; public bool IsEnemy; }
+
+        readonly Dictionary<Entity, FxCache> _cache = new();
+        readonly HashSet<Entity> _seen = new();
+        readonly List<Entity> _stale = new();
+        readonly List<FloatingNumber> _numbers = new();
+
+        Transform _fxRoot;
+        ParticleSystem _hitFx;
+        ParticleSystem _deathFx;
+        ParticleSystem _muzzleFx;
+        AudioClip _hitClip;
+        AudioClip _deathClip;
+        AudioClip _fireClip;
+
+        Entity _localPlayer = Entity.Null;
+        uint _lastLocalFireTick;
+        bool _fireTickInit;
+
+        const int NumberPoolSize = 32;
+
+        protected override void OnCreate()
+        {
+            _hitClip = MakeClip("husk_hit", 640f, 180f, 0.10f, 0.5f, noise: true);
+            _deathClip = MakeClip("husk_death", 320f, 50f, 0.34f, 0.55f, noise: false);
+            _fireClip = MakeClip("fire", 880f, 1500f, 0.07f, 0.30f, noise: false);
+        }
+
+        protected override void OnStartRunning()
+        {
+            if (_fxRoot != null) return;
+
+            _fxRoot = new GameObject("~CombatFeedbackFX").transform;
+            var mat = MakeParticleMaterial();
+            _hitFx = MakeBurst("HitSparks", mat, new Color(3f, 2.2f, 0.6f), 0.13f, 7f, 0.32f, 256);
+            _deathFx = MakeBurst("DeathBurst", mat, new Color(3.2f, 0.7f, 0.25f), 0.22f, 9f, 0.55f, 512);
+            _muzzleFx = MakeBurst("Muzzle", mat, new Color(0.6f, 2.4f, 3.2f), 0.12f, 5f, 0.20f, 128);
+
+            for (int i = 0; i < NumberPoolSize; i++)
+                _numbers.Add(CreateNumber());
+        }
+
+        protected override void OnDestroy()
+        {
+            if (_fxRoot != null)
+                Object.Destroy(_fxRoot.gameObject);
+        }
+
+        protected override void OnUpdate()
+        {
+            float dt = SystemAPI.Time.DeltaTime;
+            var cam = Camera.main;
+
+            // Make sure predicted/physics jobs writing these are done before this main-thread read.
+            EntityManager.CompleteDependencyBeforeRO<Health>();
+            EntityManager.CompleteDependencyBeforeRO<LocalTransform>();
+
+            // Resolve the local player (for hit colouring + fire feedback).
+            _localPlayer = Entity.Null;
+            float3 localPos = default;
+            foreach (var (xf, entity) in SystemAPI.Query<RefRO<LocalTransform>>()
+                         .WithAll<GhostOwnerIsLocal, PlayerTag>().WithEntityAccess())
+            {
+                _localPlayer = entity;
+                localPos = xf.ValueRO.Position;
+            }
+
+            // Edge-detect Health on every damageable ghost (players + Husks).
+            _seen.Clear();
+            foreach (var (health, xf, entity) in
+                     SystemAPI.Query<RefRO<Health>, RefRO<LocalTransform>>().WithEntityAccess())
+            {
+                _seen.Add(entity);
+                float cur = health.ValueRO.Current;
+                float3 p = xf.ValueRO.Position;
+                bool isEnemy = SystemAPI.HasComponent<EnemyTag>(entity);
+                bool isLocalPlayer = entity == _localPlayer;
+
+                if (_cache.TryGetValue(entity, out var prev))
+                {
+                    if (cur < prev.Hp - 0.001f)
+                    {
+                        SpawnNumber(prev.Hp - cur, (Vector3)p, isLocalPlayer, cam);
+                        EmitAt(_hitFx, (Vector3)p + Vector3.up * 0.8f, 10);
+                        PlayClip(_hitClip, (Vector3)p, 0.7f);
+                        PrototypeCameraRig.AddShake(isLocalPlayer ? 0.32f : 0.10f);
+                    }
+
+                    // Player death (players don't despawn — they respawn; Husk death is handled on prune).
+                    if (!isEnemy && cur <= 0f && prev.Hp > 0f)
+                    {
+                        EmitAt(_deathFx, (Vector3)p + Vector3.up * 0.5f, 28);
+                        PlayClip(_deathClip, (Vector3)p, 0.7f);
+                        PrototypeCameraRig.AddShake(isLocalPlayer ? 0.5f : 0.25f);
+                    }
+                }
+
+                _cache[entity] = new FxCache { Hp = cur, Pos = p, IsEnemy = isEnemy };
+            }
+
+            // Prune despawned ghosts. A Husk that vanished was killed -> death VFX at its last position.
+            if (_cache.Count != _seen.Count)
+            {
+                _stale.Clear();
+                foreach (var kv in _cache)
+                    if (!_seen.Contains(kv.Key)) _stale.Add(kv.Key);
+
+                for (int i = 0; i < _stale.Count; i++)
+                {
+                    var c = _cache[_stale[i]];
+                    if (c.IsEnemy)
+                    {
+                        EmitAt(_deathFx, (Vector3)c.Pos + Vector3.up * 0.5f, 28);
+                        PlayClip(_deathClip, (Vector3)c.Pos, 0.65f);
+                        PrototypeCameraRig.AddShake(0.16f);
+                    }
+                    _cache.Remove(_stale[i]);
+                }
+            }
+
+            // Local-player fire feedback: AbilityCooldown.NextFireTick advances on each shot.
+            if (_localPlayer != Entity.Null && EntityManager.HasComponent<AbilityCooldown>(_localPlayer))
+            {
+                uint nextFire = EntityManager.GetComponentData<AbilityCooldown>(_localPlayer).NextFireTick;
+                if (_fireTickInit && nextFire != 0 && nextFire != _lastLocalFireTick)
+                {
+                    EmitAt(_muzzleFx, (Vector3)localPos + Vector3.up * 0.9f, 8);
+                    PlayClip(_fireClip, (Vector3)localPos, 0.5f);
+                }
+                _lastLocalFireTick = nextFire;
+                _fireTickInit = true;
+            }
+
+            AnimateNumbers(dt, cam);
+        }
+
+        // ---- Floating damage numbers (pooled, billboarded TextMesh) ----
+
+        class FloatingNumber
+        {
+            public TextMesh Tm;
+            public Transform Tr;
+            public float Age;
+            public float Life;
+            public Vector3 Vel;
+            public Color BaseColor;
+            public bool Active;
+        }
+
+        FloatingNumber CreateNumber()
+        {
+            var go = new GameObject("DamageNumber");
+            go.transform.SetParent(_fxRoot, false);
+            var tm = go.AddComponent<TextMesh>();
+            tm.characterSize = 0.12f;
+            tm.fontSize = 64;
+            tm.anchor = TextAnchor.MiddleCenter;
+            tm.alignment = TextAlignment.Center;
+            tm.color = Color.white;
+            go.SetActive(false);
+            return new FloatingNumber { Tm = tm, Tr = go.transform, Active = false };
+        }
+
+        void SpawnNumber(float amount, Vector3 worldPos, bool isLocalPlayer, Camera cam)
+        {
+            FloatingNumber fn = null;
+            for (int i = 0; i < _numbers.Count; i++)
+                if (!_numbers[i].Active) { fn = _numbers[i]; break; }
+            if (fn == null) return; // pool exhausted this frame: drop (cheap)
+
+            fn.Active = true;
+            fn.Age = 0f;
+            fn.Life = 0.7f;
+            fn.Tm.text = Mathf.Max(1, Mathf.RoundToInt(amount)).ToString();
+            fn.BaseColor = isLocalPlayer ? new Color(1f, 0.32f, 0.26f) : new Color(1f, 0.92f, 0.45f);
+            fn.Tm.color = fn.BaseColor;
+            fn.Tr.position = worldPos + Vector3.up * 1.4f + new Vector3(UnityEngine.Random.Range(-0.25f, 0.25f), 0f, 0f);
+            fn.Vel = new Vector3(0f, 2.2f, 0f);
+            fn.Tr.gameObject.SetActive(true);
+            if (cam != null) fn.Tr.rotation = cam.transform.rotation;
+        }
+
+        void AnimateNumbers(float dt, Camera cam)
+        {
+            for (int i = 0; i < _numbers.Count; i++)
+            {
+                var fn = _numbers[i];
+                if (!fn.Active) continue;
+
+                fn.Age += dt;
+                if (fn.Age >= fn.Life)
+                {
+                    fn.Active = false;
+                    fn.Tr.gameObject.SetActive(false);
+                    continue;
+                }
+
+                fn.Vel.y -= 3.5f * dt; // ease the rise
+                fn.Tr.position += fn.Vel * dt;
+                if (cam != null) fn.Tr.rotation = cam.transform.rotation;
+
+                var c = fn.BaseColor;
+                c.a = 1f - (fn.Age / fn.Life);
+                fn.Tm.color = c;
+            }
+        }
+
+        // ---- Procedural SFX + pooled particle bursts ----
+
+        static AudioClip MakeClip(string name, float f0, float f1, float dur, float vol, bool noise)
+        {
+            const int rate = 44100;
+            int len = Mathf.Max(16, (int)(dur * rate));
+            var clip = AudioClip.Create(name, len, 1, rate, false);
+            var data = new float[len];
+            var rng = new System.Random(name.Length * 9973 + 7);
+            float phase = 0f;
+            for (int i = 0; i < len; i++)
+            {
+                float t = i / (float)len;
+                float env = Mathf.Exp(-5f * t);
+                float freq = Mathf.Lerp(f0, f1, t);
+                phase += 2f * Mathf.PI * freq / rate;
+                float s = noise ? (float)(rng.NextDouble() * 2.0 - 1.0) : Mathf.Sin(phase);
+                data[i] = s * env * vol;
+            }
+            clip.SetData(data, 0);
+            return clip;
+        }
+
+        static Material MakeParticleMaterial()
+        {
+            // Sprites/Default is an always-included, transparent, vertex-coloured shader — reliable for
+            // billboarded sparks; HDR start colours still push past the bloom threshold (Stage 5 look pass).
+            Shader sh = Shader.Find("Sprites/Default");
+            if (sh == null) sh = Shader.Find("Universal Render Pipeline/Particles/Unlit");
+            if (sh == null) sh = Shader.Find("Unlit/Color");
+            return new Material(sh) { name = "CombatFeedbackParticle" };
+        }
+
+        ParticleSystem MakeBurst(string name, Material mat, Color color, float size, float speed, float life, int max)
+        {
+            var go = new GameObject(name);
+            go.transform.SetParent(_fxRoot, false);
+            var ps = go.AddComponent<ParticleSystem>();
+
+            var main = ps.main;
+            main.loop = false;
+            main.playOnAwake = false;
+            // duration unused: manual Emit bursts with emission disabled
+            main.startLifetime = life;
+            main.startSpeed = speed;
+            main.startSize = size;
+            main.startColor = color;
+            main.maxParticles = max;
+            main.gravityModifier = 0f;
+            main.simulationSpace = ParticleSystemSimulationSpace.World;
+
+            var emission = ps.emission;
+            emission.enabled = false; // we Emit(count) manually
+
+            var shape = ps.shape;
+            shape.enabled = true;
+            shape.shapeType = ParticleSystemShapeType.Sphere;
+            shape.radius = 0.06f;
+
+            var colOverLife = ps.colorOverLifetime;
+            colOverLife.enabled = true;
+            var grad = new Gradient();
+            grad.SetKeys(
+                new[] { new GradientColorKey(Color.white, 0f), new GradientColorKey(Color.white, 1f) },
+                new[] { new GradientAlphaKey(1f, 0f), new GradientAlphaKey(0f, 1f) });
+            colOverLife.color = new ParticleSystem.MinMaxGradient(grad);
+
+            var sizeOverLife = ps.sizeOverLifetime;
+            sizeOverLife.enabled = true;
+            sizeOverLife.size = new ParticleSystem.MinMaxCurve(1f, AnimationCurve.Linear(0f, 1f, 1f, 0.2f));
+
+            var renderer = ps.GetComponent<ParticleSystemRenderer>();
+            renderer.material = mat;
+            renderer.renderMode = ParticleSystemRenderMode.Billboard;
+            return ps;
+        }
+
+        static void EmitAt(ParticleSystem ps, Vector3 pos, int count)
+        {
+            if (ps == null) return;
+            ps.transform.position = pos;
+            ps.Emit(count);
+        }
+
+        static void PlayClip(AudioClip clip, Vector3 pos, float vol)
+        {
+            if (clip == null) return;
+            AudioSource.PlayClipAtPoint(clip, pos, vol);
+        }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 61d55913bf02dba4aadd8667876115f8
@@ -0,0 +1,215 @@
+using ProjectM.Simulation;
+using Unity.Entities;
+using Unity.NetCode;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace ProjectM.Client
+{
+    /// <summary>
+    /// Client-only screen HUD. A managed presentation SystemBase (<see cref="PresentationSystemGroup"/>) that builds
+    /// a uGUI overlay canvas in code and drives it from the LOCAL player ghost each frame: a health bar
+    /// (Health / EffectiveCharacterStats.MaxHealth), an ability-cooldown bar (AbilityCooldown vs NetworkTime
+    /// ServerTick + EffectiveAbilityStats.CooldownTicks), a live Husk threat count, and a DOWNED/RESPAWNING overlay
+    /// (the derived <see cref="Dead"/> gate). Presentation only — no simulation, client world only. Bars are
+    /// RawImages over <c>Texture2D.whiteTexture</c> (always available; the fill width is the RectTransform's
+    /// anchorMax.x), so the HUD needs no sprite assets — only a resolved builtin font for the labels.
+    /// </summary>
+    [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
+    [UpdateInGroup(typeof(PresentationSystemGroup))]
+    public partial class HudSystem : SystemBase
+    {
+        Canvas _canvas;
+        RectTransform _healthFill;
+        RectTransform _cooldownFill;
+        Text _healthText;
+        Text _threatText;
+        GameObject _respawnOverlay;
+        EntityQuery _huskQuery;
+
+        protected override void OnCreate()
+        {
+            _huskQuery = GetEntityQuery(ComponentType.ReadOnly<EnemyTag>());
+        }
+
+        protected override void OnStartRunning()
+        {
+            if (_canvas == null) BuildHud();
+        }
+
+        protected override void OnDestroy()
+        {
+            if (_canvas != null) Object.Destroy(_canvas.gameObject);
+        }
+
+        protected override void OnUpdate()
+        {
+            if (_canvas == null) return;
+
+            bool haveTick = SystemAPI.TryGetSingleton<NetworkTime>(out var nt);
+
+            bool found = false;
+            float hp = 0f, maxHp = 1f, cdFrac = 1f;
+            bool dead = false, shielded = false;
+
+            foreach (var (health, effChar, effAbility, cd, invuln, entity) in
+                     SystemAPI.Query<RefRO<Health>, RefRO<EffectiveCharacterStats>, RefRO<EffectiveAbilityStats>,
+                             RefRO<AbilityCooldown>, RefRO<RespawnInvuln>>()
+                         .WithAll<GhostOwnerIsLocal, PlayerTag>().WithEntityAccess())
+            {
+                found = true;
+                hp = health.ValueRO.Current;
+                maxHp = effChar.ValueRO.MaxHealth > 0f ? effChar.ValueRO.MaxHealth : health.ValueRO.Max;
+                dead = SystemAPI.IsComponentEnabled<Dead>(entity);
+
+                // Cooldown fraction via wrap-safe NetworkTick compare (raw uint subtraction is unsafe across
+                // tick wraparound — the project convention, mirroring AbilityFireSystem/EnemyAISystem).
+                uint nextFire = cd.ValueRO.NextFireTick;
+                int cdTicks = effAbility.ValueRO.CooldownTicks;
+                var nextTick = new NetworkTick(nextFire);
+                cdFrac = (haveTick && nextFire != 0 && cdTicks > 0 && nextTick.IsValid && nextTick.IsNewerThan(nt.ServerTick))
+                    ? Mathf.Clamp01(1f - nextTick.TicksSince(nt.ServerTick) / (float)cdTicks)
+                    : 1f;
+
+                uint invulnUntil = invuln.ValueRO.UntilTick;
+                var invulnTick = new NetworkTick(invulnUntil);
+                shielded = haveTick && invulnUntil != 0 && invulnTick.IsValid && invulnTick.IsNewerThan(nt.ServerTick);
+                break;
+            }
+
+            _canvas.enabled = found;
+            if (!found) return;
+
+            float frac = maxHp > 0f ? Mathf.Clamp01(hp / maxHp) : 0f;
+            SetFill(_healthFill, frac);
+            var hc = _healthFill.GetComponent<RawImage>();
+            if (hc != null)
+                hc.color = shielded
+                    ? new Color(0.45f, 0.85f, 1f)
+                    : Color.Lerp(new Color(0.92f, 0.16f, 0.16f), new Color(0.25f, 0.9f, 0.5f), frac);
+            if (_healthText != null)
+                _healthText.text = Mathf.CeilToInt(Mathf.Max(0f, hp)) + " / " + Mathf.CeilToInt(maxHp) + (shielded ? "   SHIELDED" : "");
+
+            SetFill(_cooldownFill, cdFrac);
+
+            if (_threatText != null)
+                _threatText.text = "HUSKS  " + _huskQuery.CalculateEntityCount();
+
+            _respawnOverlay.SetActive(dead);
+        }
+
+        static void SetFill(RectTransform fill, float frac)
+        {
+            if (fill == null) return;
+            var max = fill.anchorMax;
+            max.x = Mathf.Clamp01(frac);
+            fill.anchorMax = max;
+        }
+
+        // ---- uGUI construction (code-built; no prefab/sprite assets) ----
+
+        void BuildHud()
+        {
+            var go = new GameObject("~HUD");
+            _canvas = go.AddComponent<Canvas>();
+            _canvas.renderMode = RenderMode.ScreenSpaceOverlay;
+            _canvas.sortingOrder = 100;
+            var scaler = go.AddComponent<CanvasScaler>();
+            scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
+            scaler.referenceResolution = new Vector2(1920, 1080);
+            go.AddComponent<GraphicRaycaster>();
+
+            var font = GetFont();
+
+            // Health bar (bottom-left).
+            var hpBg = MakeBar("HealthBg", _canvas.transform, new Color(0f, 0f, 0f, 0.6f),
+                new Vector2(40, 46), new Vector2(440, 40));
+            _healthFill = MakeFill("HealthFill", hpBg, new Color(0.25f, 0.9f, 0.5f));
+            _healthText = MakeText("HealthText", hpBg, "100 / 100", 24, TextAnchor.MiddleCenter, Color.white, font);
+
+            // Cooldown bar (just above health).
+            var cdBg = MakeBar("CooldownBg", _canvas.transform, new Color(0f, 0f, 0f, 0.55f),
+                new Vector2(40, 92), new Vector2(440, 14));
+            _cooldownFill = MakeFill("CooldownFill", cdBg, new Color(0.4f, 0.8f, 1f));
+
+            // Threat count (top-right).
+            _threatText = MakeText("ThreatText", _canvas.transform, "HUSKS  0", 30, TextAnchor.UpperRight,
+                new Color(1f, 0.62f, 0.4f), font);
+            var trt = _threatText.rectTransform;
+            trt.anchorMin = new Vector2(1, 1); trt.anchorMax = new Vector2(1, 1); trt.pivot = new Vector2(1, 1);
+            trt.anchoredPosition = new Vector2(-40, -30); trt.sizeDelta = new Vector2(380, 50);
+
+            // Downed / respawning overlay (full screen, toggled by Dead).
+            _respawnOverlay = new GameObject("RespawnOverlay", typeof(RectTransform));
+            _respawnOverlay.transform.SetParent(_canvas.transform, false);
+            var ov = _respawnOverlay.AddComponent<RawImage>();
+            ov.texture = Texture2D.whiteTexture;
+            ov.color = new Color(0.35f, 0f, 0f, 0.35f);
+            ov.raycastTarget = false;
+            Stretch((RectTransform)_respawnOverlay.transform);
+            var rtext = MakeText("RespawnText", _respawnOverlay.transform, "DOWNED - RESPAWNING", 56,
+                TextAnchor.MiddleCenter, new Color(1f, 0.45f, 0.4f), font);
+            Stretch(rtext.rectTransform);
+            _respawnOverlay.SetActive(false);
+        }
+
+        static RectTransform MakeBar(string name, Transform parent, Color color, Vector2 anchoredPos, Vector2 size)
+        {
+            var go = new GameObject(name, typeof(RectTransform));
+            go.transform.SetParent(parent, false);
+            var img = go.AddComponent<RawImage>();
+            img.texture = Texture2D.whiteTexture;
+            img.color = color;
+            img.raycastTarget = false;
+            var rt = (RectTransform)go.transform;
+            rt.anchorMin = Vector2.zero; rt.anchorMax = Vector2.zero; rt.pivot = Vector2.zero;
+            rt.anchoredPosition = anchoredPos; rt.sizeDelta = size;
+            return rt;
+        }
+
+        static RectTransform MakeFill(string name, RectTransform parent, Color color)
+        {
+            var go = new GameObject(name, typeof(RectTransform));
+            go.transform.SetParent(parent, false);
+            var img = go.AddComponent<RawImage>();
+            img.texture = Texture2D.whiteTexture;
+            img.color = color;
+            img.raycastTarget = false;
+            var rt = (RectTransform)go.transform;
+            rt.anchorMin = Vector2.zero; rt.anchorMax = Vector2.one; rt.pivot = Vector2.zero;
+            rt.offsetMin = new Vector2(3, 3); rt.offsetMax = new Vector2(-3, -3);
+            return rt;
+        }
+
+        static Text MakeText(string name, Transform parent, string text, int size, TextAnchor anchor, Color color, Font font)
+        {
+            var go = new GameObject(name, typeof(RectTransform));
+            go.transform.SetParent(parent, false);
+            var t = go.AddComponent<Text>();
+            t.text = text;
+            t.font = font;
+            t.fontSize = size;
+            t.alignment = anchor;
+            t.color = color;
+            t.horizontalOverflow = HorizontalWrapMode.Overflow;
+            t.verticalOverflow = VerticalWrapMode.Overflow;
+            t.raycastTarget = false;
+            Stretch(t.rectTransform);
+            return t;
+        }
+
+        static void Stretch(RectTransform rt)
+        {
+            rt.anchorMin = Vector2.zero; rt.anchorMax = Vector2.one;
+            rt.offsetMin = Vector2.zero; rt.offsetMax = Vector2.zero;
+        }
+
+        static Font GetFont()
+        {
+            Font f = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
+            if (f == null) f = Resources.GetBuiltinResource<Font>("Arial.ttf");
+            if (f == null) f = Font.CreateDynamicFontFromOSFont(new[] { "Arial", "Liberation Sans", "DejaVu Sans" }, 28);
+            return f;
+        }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 67696deb509086a408e38872c904a8e6
@@ -30,6 +30,13 @@ namespace ProjectM.Client
        /// <summary>True while a locally-owned player exists to follow.</summary>
        public static bool HasTarget;

+        /// <summary>Accumulated camera-shake amplitude (world units), decayed each LateUpdate. Driven by
+        /// AddShake from the client combat-feedback layer (presentation only, netcode-safe - never the sim).</summary>
+        static float s_shake;
+
+        /// <summary>Add a one-shot camera-shake impulse (clamped). Called by CombatFeedbackSystem on hits/deaths.</summary>
+        public static void AddShake(float amount) => s_shake = Mathf.Min(s_shake + amount, 0.8f);
+
        [Header("Angle (degrees)")]
        [Range(10f, 89f)] public float Pitch = 45f;
        [Range(-180f, 180f)] public float Yaw = 0f;
@@ -69,7 +76,13 @@ namespace ProjectM.Client
            Vector3 desired = target - (rot * Vector3.forward) * Distance;

            float k = FollowSharpness <= 0f ? 1f : 1f - Mathf.Exp(-FollowSharpness * Time.deltaTime);
-            transform.SetPositionAndRotation(Vector3.Lerp(transform.position, desired, k), rot);
+            Vector3 basePos = Vector3.Lerp(transform.position, desired, k);
+            if (s_shake > 0.0001f)
+            {
+                basePos += UnityEngine.Random.insideUnitSphere * s_shake;
+                s_shake = Mathf.Lerp(s_shake, 0f, 1f - Mathf.Exp(-12f * Time.deltaTime));
+            }
+            transform.SetPositionAndRotation(basePos, rot);
        }
    }

@@ -11,7 +11,8 @@
        "Unity.NetCode",
        "Unity.Entities.Graphics",
        "Unity.InputSystem",
-        "Unity.Networking.Transport"
+        "Unity.Networking.Transport",
+        "UnityEngine.UI"
    ],
    "includePlatforms": [],
    "excludePlatforms": [],