Project-M/Assets/_Project/Scripts/Simulation/Player/PlayerDeathStateSystem.cs

using Unity.Burst;
using Unity.Entities;
using Unity.Mathematics;
using Unity.NetCode;

namespace ProjectM.Simulation
{
    /// <summary>
    /// Derives the LOCAL enableable <see cref="Dead"/> gate from the replicated <see cref="Health"/> every predicted
    /// tick (Dead == Health.Current &lt;= 0). Runs in BOTH worlds inside
    /// <see cref="PredictedSimulationSystemGroup"/>, BEFORE movement/aim/fire, so a dead player is excluded from
    /// those systems (which query <c>.WithDisabled&lt;Dead&gt;()</c>) on the server AND the owner-predicting client.
    /// Because it is a pure function of the already-replicated, reconciled Health (the same derive-don't-replicate
    /// pattern as <see cref="StatRecomputeSystem"/>), the gate is identical across server, owner-client, and rollback
    /// — no replicated enabled bit required. Also zeroes <see cref="CharacterControl.MoveVelocity"/> while dead so
    /// the kinematic character holds still (the movement system is skipped and would otherwise coast on stale
    /// velocity). The authoritative recovery (Health refill + reposition) is owned server-side by
    /// <c>PlayerRespawnSystem</c>. Visits dead players too via <c>.WithPresent&lt;Dead&gt;()</c> (required to write
    /// the enabled bit on an entity whose Dead is currently disabled).
    /// </summary>
    [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
    [UpdateBefore(typeof(PlayerControlSystem))]
    [UpdateBefore(typeof(PlayerAimSystem))]
    [BurstCompile]
    public partial struct PlayerDeathStateSystem : ISystem
    {
        [BurstCompile]
        public void OnUpdate(ref SystemState state)
        {
            foreach (var (health, control, deadEnabled, entity) in
                     SystemAPI.Query<RefRO<Health>, RefRW<CharacterControl>, EnabledRefRW<Dead>>()
                         .WithAll<PlayerTag, Simulate>()
                         .WithPresent<Dead>()
                         .WithEntityAccess())
            {
                bool isDead = health.ValueRO.Current <= 0f;
                deadEnabled.ValueRW = isDead;
                if (isDead)
                {
                    control.ValueRW.MoveVelocity = float3.zero;
                    // MC-1: clear any in-flight dash window + restore base sharpness so a death mid-dash leaves
                    // no stale i-frames / stuck-fast on respawn (DashSystem skips dead players via .WithDisabled<Dead>()).
                    if (SystemAPI.HasComponent<DashState>(entity))
                        SystemAPI.SetComponent(entity, default(DashState));
                    // MC-4: clear any in-flight combo so a death mid-combo leaves no stale lock/step on respawn.
                    if (SystemAPI.HasComponent<MeleeCombo>(entity))
                        SystemAPI.SetComponent(entity, default(MeleeCombo));
                    if (SystemAPI.HasComponent<CharacterComponent>(entity))
                    {
                        var cc = SystemAPI.GetComponent<CharacterComponent>(entity);
                        // 07-15: honor the MoveSharpness dev-override (0 = authored const) like the dash/blink restores.
                        var tdc = SystemAPI.TryGetSingleton<TuningConfig>(out var tdcv) ? tdcv : TuningConfig.Defaults();
                        cc.GroundedMovementSharpness = tdc.MoveSharpness > 0f ? tdc.MoveSharpness : CharacterComponent.DefaultGroundedSharpness;
                        SystemAPI.SetComponent(entity, cc);
                    }
                }
            }
        }
    }
}