Boss becomes a real fight + readable-but-fair enemy threat

BossState (server-only) + BossAISystem: sole mover, seek -> telegraphed
radial slam (AttackWindup) -> phase-2 speed + swarmer summon. Excluded from
the EnemyAISystem Charger pass; knockback-immune at all 3 stamp sites;
arena-anchored spawn; scaled Health/HitRadius/AttackRange. Grunt windup now
commits in its last ~30% (whiffs out-of-range); Charger stagger roots; grunt
speed 4.2->5.2; swarmer telegraph synced. SweptMove + zone-enemy spawn-stamp
extracted to shared helpers. Zero new [GhostField].

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Assets/_Project/Scripts/Simulation/Combat/AbilityFireSystem.cs

@@ -37,11 +37,17 @@ namespace ProjectM.Simulation
     [BurstCompile]
     public partial struct AbilityFireSystem : ISystem
     {
+        // C3/A4: knockback stamp for the Warrior CONE (guarded HasComponent + boss-immune). Server-only use.
+        ComponentLookup<KnockbackState> m_KnockbackLookup;
+        ComponentLookup<BossState> m_BossLookup;
+
         [BurstCompile]
         public void OnCreate(ref SystemState state)
         {
             state.RequireForUpdate<AbilityDatabase>();
             state.RequireForUpdate<NetworkTime>();
+            m_KnockbackLookup = state.GetComponentLookup<KnockbackState>(isReadOnly: false);
+            m_BossLookup = state.GetComponentLookup<BossState>(isReadOnly: true);
         }
 
         [BurstCompile]
@@ -63,6 +69,8 @@ namespace ProjectM.Simulation
             var abilityDb = SystemAPI.GetSingleton<AbilityDatabase>();
 
             bool isServer = state.WorldUnmanaged.IsServer();
+            m_KnockbackLookup.Update(ref state);
+            m_BossLookup.Update(ref state);
 
             // Server-only target set (LIVING enemies/dummies), collected once: positions feed the gamepad
             // auto-target assist, and entities+positions feed the Warrior CONE archetype's server-only cleave.
@@ -132,6 +140,19 @@ namespace ProjectM.Simulation
                                 SourceNetworkId = owner.ValueRO.NetworkId,
                                 SourceTick = cStamp,
                             });
+                            // C3: the cone reads as weak vs the melee cleave without knockback — stamp it like melee
+                            // (guarded: dummies lack KnockbackState → ECB throw; the boss is knockback-immune, A4).
+                            if (m_KnockbackLookup.HasComponent(coneTargets[ci]) && !m_BossLookup.HasComponent(coneTargets[ci]))
+                            {
+                                float3 kd3 = coneTargetPos[ci] - xform.ValueRO.Position;
+                                float2 kdir = math.lengthsq(kd3.xz) > 1e-6f ? math.normalize(kd3.xz) : cFace;
+                                m_KnockbackLookup[coneTargets[ci]] = new KnockbackState
+                                {
+                                    Dir = kdir,
+                                    Speed = Tuning.KnockbackSpeed,
+                                    UntilTick = TickUtil.NonZero(serverTick.TickIndexForValidTick + (uint)math.max(1, Tuning.KnockbackDurationTicks)),
+                                };
+                            }
                         }
                     }
                     uint coneCd = (uint)math.max(1, eff.ValueRO.CooldownTicks);

Assets/_Project/Scripts/Simulation/Combat/BossState.cs

@@ -0,0 +1,31 @@
+using Unity.Entities;
+
+namespace ProjectM.Simulation
+{
+    /// <summary>
+    /// SERVER-ONLY working state for the expedition BOSS (a scaled Charger that <see cref="Server"/>'s
+    /// RoomEnemyDirectorSystem tags at spawn). NOT replicated and NOT baked — added at runtime via ECB on the boss
+    /// entity, so it needs no ghost-hash change (a runtime-added replicated component would not replicate anyway;
+    /// this one is deliberately server-only, like <see cref="LungeState"/>/<see cref="KnockbackState"/>).
+    /// <para>
+    /// Component PRESENCE is the boss discriminator: BossAISystem is the SOLE mover/attacker of
+    /// <c>.WithAll&lt;EnemyTag, BossState&gt;()</c>, and EnemyAISystem's Charger MOVE pass excludes it via
+    /// <c>.WithNone&lt;BossState&gt;()</c> so exactly one system writes the boss's Position/AttackWindup. The boss does
+    /// NOT use LungeState (its signature move is a telegraphed radial SLAM, not a lunge) — so EnemyAISystem's
+    /// IsLunging derive visits it but sees <c>LungeState.UntilTick==0</c> and derives the bit off (harmless single
+    /// writer). <see cref="Phase"/> is a byte (never a C# enum on a Bursted path — the cross-assembly-enum ICE rule).
+    /// All tick fields route through <c>TickUtil.NonZero</c> and compare with <see cref="Unity.NetCode.NetworkTick"/>.
+    /// </para>
+    /// </summary>
+    public struct BossState : IComponentData
+    {
+        /// <summary>1 = phase one (heavy Charger + slam), 2 = phase two (&lt;50% HP: faster + summons adds). Byte, not enum.</summary>
+        public byte Phase;
+
+        /// <summary>Earliest raw tick the boss may begin its next radial SLAM wind-up (NonZero; 0 = ready).</summary>
+        public uint SlamReadyTick;
+
+        /// <summary>Earliest raw tick the boss may summon its next add pack (phase two only; NonZero; 0 = ready).</summary>
+        public uint SummonReadyTick;
+    }
+}

Assets/_Project/Scripts/Simulation/Combat/BossState.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fdf576e1f07162e43bae89c4ccc06dec