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

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

namespace ProjectM.Simulation
{
    /// <summary>One server-side cleave queued from a player's swing-start this tick, resolved after the player loop so
    /// the living-enemy snapshot is gathered ONCE and ONLY when a swing actually fired (never on the client, never on an
    /// idle tick). Blittable (Burst-friendly).</summary>
    struct PendingCleave
    {
        public float3 From;
        public float2 Face;
        public float Damage;
        public float Range;
        public float KnockSpeed;
        public int OwnerId;
        public uint Stamp;
        public uint KnockUntil;
        public bool IsFinisher; // Phase 1.7: this swing is the combo finisher
        public bool Detonate;   // Phase 1.7: attacker has the FinisherDetonate boon
        public bool Pull;       // Phase 1.7: attacker has the KnockToPull boon
    }

    /// <summary>
    /// MC-4 — the predicted melee combo (Hades-style 2-3 hit chain; the player's PRIMARY verb). On a fresh
    /// <see cref="PlayerInput.Attack"/> press (not locked, not mid-dash) it ADVANCES <see cref="MeleeCombo.Step"/>
    /// (chain if re-pressed inside [LockUntilTick, LockUntilTick + grace), else reset to 1) and opens a movement-commit
    /// lock; the finisher (Step == ComboLength) hits bigger. The Step/SwingStartTick/LockUntilTick anchor is
    /// owner-replicated (<see cref="MeleeCombo"/> [GhostField]s) so a rollback restores the authoritative combo
    /// position; every write is an ABSOLUTE function of (restored Step, tick) — re-running a tick re-derives identical
    /// state (the DashSystem idempotency idiom; never an in-place prev+1 of a non-restored field — MC-4 review PRED-1).
    /// <para>
    /// Runs in <see cref="PredictedSimulationSystemGroup"/> AFTER <see cref="PlayerControlSystem"/> (it scales the
    /// MoveVelocity that system wrote) and BEFORE <see cref="DashSystem"/> (a dash OVERRIDES the swing's movement =
    /// dash-cancel) — and so before HealthApplyDamageSystem ([UpdateAfter(DashSystem)]) which drains the cleave's
    /// DamageEvent the same tick. Movement-commit re-applies every predicted pass, lower-bounded on SwingStartTick (a
    /// re-simulated pre-swing tick must NOT inherit the scale — the DashSystem inDashWindow fix). DAMAGE is SERVER-ONLY
    /// (enemies are interpolated ghosts; the client never predicts enemy health) and mirrors ProjectileDamageSystem:
    /// queue each swing, then collect ALL living enemies in the per-step cone (<see cref="MeleeConeMath"/>) ONCE, append
    /// a SourceTick-stamped DamageEvent + stamp KnockbackState. All ticks via TickUtil.NonZero, compared with
    /// NetworkTick only; feel knobs live in <see cref="TuningConfig"/> (MC-0, fallback to Defaults()).
    /// </para>
    /// </summary>
    [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
    [UpdateAfter(typeof(PlayerControlSystem))]
    [UpdateBefore(typeof(DashSystem))]
    [BurstCompile]
    public partial struct MeleeComboSystem : ISystem
    {
        ComponentLookup<KnockbackState> m_KnockbackLookup;
        ComponentLookup<BossState> m_BossLookup; // A4: the boss is knockback-immune (no melee stunlock out of its slams)

        ComponentLookup<RegionTag> m_RegionLookup;
        BufferLookup<InventorySlot> m_InvLookup;
        BufferLookup<StatModifier> m_StatModLookup;
        ComponentLookup<BoonEffects> m_BoonEffectsLookup; // Phase 1.7 (player query is at the 7-type cap -> lookup)

        /// <summary>Phase 1.7 Detonating Finisher blast radius (planar, tunable).</summary>
        const float k_DetonateRadius = 3.5f;

        [BurstCompile]
        public void OnCreate(ref SystemState state)
        {
            m_KnockbackLookup = state.GetComponentLookup<KnockbackState>(isReadOnly: false);
            m_BossLookup = state.GetComponentLookup<BossState>(isReadOnly: true);

            m_RegionLookup = state.GetComponentLookup<RegionTag>(isReadOnly: true);
            m_InvLookup = state.GetBufferLookup<InventorySlot>(isReadOnly: false);
            m_StatModLookup = state.GetBufferLookup<StatModifier>(isReadOnly: true);
            m_BoonEffectsLookup = state.GetComponentLookup<BoonEffects>(isReadOnly: true);
            state.RequireForUpdate<NetworkTime>();
        }

        [BurstCompile]
        public void OnUpdate(ref SystemState state)
        {
            if (!SystemAPI.TryGetSingleton<NetworkTime>(out var netTime) || !netTime.ServerTick.IsValid)
                return;
            var serverTick = netTime.ServerTick;
            uint now = serverTick.TickIndexForValidTick;

            var t = SystemAPI.TryGetSingleton<TuningConfig>(out var tc) ? tc : TuningConfig.Defaults();
            float baseDamage = math.max(0f, t.MeleeDamage);
            float baseRange = math.max(0f, t.MeleeRange);
            float cosHalf = math.cos(math.max(0f, t.MeleeConeHalfAngleRad));
            uint recoverTicks = (uint)math.max(1f, t.MeleeRecoverTicks);
            uint graceTicks = (uint)math.max(1f, t.MeleeChainGraceTicks);
            float moveScale = math.max(0f, t.MeleeSwingMoveScale);
            float knockSpeed = math.max(0f, t.MeleeKnockbackSpeed);
            float finisherMult = math.max(1f, t.MeleeFinisherMult);
            byte comboLen = (byte)math.clamp((int)t.MeleeComboLength, 1, 3);
            uint stamp = TickUtil.NonZero(now);
            uint knockUntil = TickUtil.NonZero(now + (uint)math.max(1, Tuning.KnockbackDurationTicks));

            bool isServer = state.WorldUnmanaged.IsServer();

            // Server-only queue of cleaves to resolve after the player loop (so enemies are gathered ONCE, and only
            // when at least one swing actually started — no per-tick enemy gather on idle/client ticks).
            var cleaves = isServer ? new NativeList<PendingCleave>(Allocator.Temp) : default;
            m_StatModLookup.Update(ref state);
            m_BoonEffectsLookup.Update(ref state); // Phase 1.7: per-player boon flags (read inside the player loop)

            foreach (var (mc, control, input, facing, xform, owner, ds, entity) in
                     SystemAPI.Query<RefRW<MeleeCombo>, RefRW<CharacterControl>, RefRO<PlayerInput>,
                                     RefRO<PlayerFacing>, RefRO<LocalTransform>, RefRO<GhostOwner>, RefRO<DashState>>()
                         .WithAll<Simulate>().WithDisabled<Dead>().WithEntityAccess())
            {
                // A dash window (i-frame OR recovery) active = dash owns movement + blocks a swing start (dash-cancel).
                bool dashActive = ds.ValueRO.StartTick != 0u
                                  && !new NetworkTick(ds.ValueRO.StartTick).IsNewerThan(serverTick)
                                  && ds.ValueRO.RecoverUntilTick != 0u
                                  && new NetworkTick(ds.ValueRO.RecoverUntilTick).IsNewerThan(serverTick);

                // Locked: mid swing / recovery (now < LockUntilTick).
                bool locked = mc.ValueRO.LockUntilTick != 0u
                              && new NetworkTick(mc.ValueRO.LockUntilTick).IsNewerThan(serverTick);

                // --- ADVANCE (idempotent ABSOLUTE writes; dash wins same-tick ties via !Dash.IsSet) ---
                bool swingStarted = false;
                byte swingStep = 0;
                if (input.ValueRO.Attack.IsSet && !locked && !dashActive && !input.ValueRO.Dash.IsSet)
                {
                    bool inChainWindow = false;
                    if (mc.ValueRO.LockUntilTick != 0u)
                    {
                        var deadline = new NetworkTick(TickUtil.NonZero(mc.ValueRO.LockUntilTick + graceTicks));
                        inChainWindow = deadline.IsValid && deadline.IsNewerThan(serverTick); // now < lock+grace (now >= lock since !locked)
                    }
                    byte prev = mc.ValueRO.Step;
                    swingStep = (inChainWindow && prev >= 1 && prev < comboLen) ? (byte)(prev + 1) : (byte)1;

                    bool isFin = swingStep >= comboLen;
                    uint stepRecover = isFin ? (uint)math.max(1f, math.round(recoverTicks * finisherMult)) : recoverTicks;

                    mc.ValueRW.Step = swingStep;
                    mc.ValueRW.SwingStartTick = TickUtil.NonZero(now);
                    mc.ValueRW.LockUntilTick = TickUtil.NonZero(now + stepRecover);
                    swingStarted = true;
                }

                // --- MOVEMENT COMMIT (every pass; lower-bounded on SwingStartTick; DashSystem overrides later) ---
                bool inSwingWindow = mc.ValueRO.SwingStartTick != 0u
                                     && !new NetworkTick(mc.ValueRO.SwingStartTick).IsNewerThan(serverTick)
                                     && mc.ValueRO.LockUntilTick != 0u
                                     && new NetworkTick(mc.ValueRO.LockUntilTick).IsNewerThan(serverTick);
                if (inSwingWindow && !dashActive)
                    control.ValueRW.MoveVelocity *= moveScale;

                // --- SERVER: queue the cleave (resolved after the loop). Damage/cone are SERVER-authoritative. ---
                if (swingStarted && isServer)
                {
                    bool isFin = swingStep >= comboLen;
                    // Slice 2: fold the player's class/run StatModifiers onto the live-tunable melee base so the
                    // PRIMARY verb scales with class identity (Warrior +MeleeDamage/+reach) + run augments.
                    byte bflags = m_BoonEffectsLookup.HasComponent(entity) ? m_BoonEffectsLookup[entity].Flags : (byte)0;
                    bool hasMods = m_StatModLookup.HasBuffer(entity);
                    float pDamage = math.max(0f, hasMods ? StatMath.Apply(baseDamage, StatTarget.MeleeDamage, m_StatModLookup[entity]) : baseDamage);
                    float pRange = math.max(0f, hasMods ? StatMath.Apply(baseRange, StatTarget.MeleeRange, m_StatModLookup[entity]) : baseRange);
                    // Manual-aim cleave (07-15): the cone follows the CURRENT tick's replicated Aim (SoD skillshot
                    // grammar) — PlayerFacing is body-yaw only; the facing fallback covers a resting gamepad stick.
                    float2 face = FacingMath.ResolveAim(input.ValueRO.Aim, facing.ValueRO.Direction);
                    cleaves.Add(new PendingCleave
                    {
                        From = xform.ValueRO.Position,
                        Face = face,
                        Damage = isFin ? pDamage * finisherMult : pDamage,
                        Range = isFin ? pRange * finisherMult : pRange,
                        KnockSpeed = isFin ? knockSpeed * finisherMult : knockSpeed,
                        OwnerId = owner.ValueRO.NetworkId,
                        Stamp = stamp,
                        KnockUntil = knockUntil,
                        IsFinisher = isFin,
                        Detonate = (bflags & BoonFlag.FinisherDetonate) != 0,
                        Pull = (bflags & BoonFlag.KnockToPull) != 0,
                    });
                }
            }

            // Resolve queued cleaves SERVER-ONLY and only when one actually fired: gather living enemies ONCE, then
            // append a SourceTick-stamped DamageEvent + stamp KnockbackState for each enemy in each swing's cone.
            if (isServer && cleaves.IsCreated && cleaves.Length > 0)
            {
                var enemyEntities = new NativeList<Entity>(Allocator.Temp);
                var enemyPositions = new NativeList<float3>(Allocator.Temp);
                foreach (var (xform, health, enemyEntity) in
                         SystemAPI.Query<RefRO<LocalTransform>, RefRO<Health>>()
                             .WithAll<EnemyTag>()
                             .WithEntityAccess())
                {
                    if (health.ValueRO.Current <= 0f)
                        continue; // skip already-dead enemies (about to despawn)
                    enemyEntities.Add(enemyEntity);
                    enemyPositions.Add(xform.ValueRO.Position);
                }
                // Gather harvest targets (resource nodes + Blight clutter) ONCE so "any attack harvests": a swing
                // depletes every node/clutter in its cone, crediting the shared ResourceLedger (the build currency
                // pool) just like a base projectile hit. SERVER-ONLY (this whole block) — interpolated node ghosts
                // are never rolled back, so the deposit + destroy fire exactly once per swing.
                bool haveLedger = SystemAPI.TryGetSingletonEntity<ResourceLedger>(out var ledgerEntity);
                bool haveDb = SystemAPI.TryGetSingleton<ItemDatabase>(out var itemDb);
                DynamicBuffer<StorageEntry> ledger = default;
                if (haveLedger) ledger = SystemAPI.GetBuffer<StorageEntry>(ledgerEntity);
                m_RegionLookup.Update(ref state);
                m_InvLookup.Update(ref state);
                var meleePlayerByConn = new NativeHashMap<int, Entity>(8, Allocator.Temp);
                foreach (var (po, pe) in SystemAPI.Query<RefRO<GhostOwner>>().WithAll<PlayerTag, InventorySlot>().WithEntityAccess())
                    meleePlayerByConn[po.ValueRO.NetworkId] = pe;
                var harvEntity = new NativeList<Entity>(Allocator.Temp);
                var harvPos = new NativeList<float3>(Allocator.Temp);
                var harvRemaining = new NativeList<int>(Allocator.Temp);
                var harvYieldId = new NativeList<byte>(Allocator.Temp);
                var harvPerHit = new NativeList<float>(Allocator.Temp);
                var harvIsClutter = new NativeList<bool>(Allocator.Temp);
                var harvVariant = new NativeList<byte>(Allocator.Temp);
                var harvToLedger = new NativeList<bool>(Allocator.Temp);
                foreach (var (hx, node, he) in
                         SystemAPI.Query<RefRO<LocalTransform>, RefRO<ResourceNode>>().WithEntityAccess())
                {
                    if (node.ValueRO.Remaining <= 0) continue; // spent is not a target

                    harvEntity.Add(he);
                    harvPos.Add(hx.ValueRO.Position);
                    harvRemaining.Add(node.ValueRO.Remaining);
                    harvYieldId.Add(node.ValueRO.ResourceId);
                    harvPerHit.Add(node.ValueRO.HarvestPerHit);
                    harvIsClutter.Add(false);
                    harvVariant.Add(0);
                    harvToLedger.Add(m_RegionLookup.HasComponent(he) && m_RegionLookup[he].Region == RegionId.Base);
                }
                foreach (var (hx, clutter, he) in
                         SystemAPI.Query<RefRO<LocalTransform>, RefRO<BlightClutter>>().WithEntityAccess())
                {
                    if (clutter.ValueRO.Remaining <= 0) continue; // lit-fuse barrel: unhittable, detonation owns it

                    harvEntity.Add(he);
                    harvPos.Add(hx.ValueRO.Position);
                    harvRemaining.Add(clutter.ValueRO.Remaining);
                    harvYieldId.Add(clutter.ValueRO.ScrapResourceId);
                    harvPerHit.Add(clutter.ValueRO.ScrapPerHit);
                    harvIsClutter.Add(true);
                    harvVariant.Add(clutter.ValueRO.Variant);
                    harvToLedger.Add(m_RegionLookup.HasComponent(he) && m_RegionLookup[he].Region == RegionId.Base);
                }
                var harvDestroyed = new NativeArray<bool>(harvEntity.Length, Allocator.Temp);


                m_KnockbackLookup.Update(ref state);
                m_BossLookup.Update(ref state);

                var ecb = new EntityCommandBuffer(Allocator.Temp);
                for (int s = 0; s < cleaves.Length; s++)
                {
                    var c = cleaves[s];
                    for (int i = 0; i < enemyEntities.Length; i++)
                    {
                        if (!MeleeConeMath.InCone(c.From, c.Face, c.Range, cosHalf, enemyPositions[i]))
                            continue;
                        var target = enemyEntities[i];
                        ecb.AppendToBuffer(target, new DamageEvent
                        {
                            Amount = c.Damage,
                            SourceNetworkId = c.OwnerId,
                            SourceTick = c.Stamp,
                        });
                        if (c.KnockSpeed > 0f)
                            KnockbackUtil.Stamp(ref m_KnockbackLookup, m_BossLookup, target,
                                c.From, enemyPositions[i], c.Face, c.KnockSpeed, c.KnockUntil, c.Pull);
                    }
                }
                // Phase 1.7 Detonating Finisher: a finisher swing with the boon blasts a planar AoE around its
                // origin (mirrors HazardExplosionSystem). Cone+blast overlap is the normal DamageEvent-summation.
                for (int s = 0; s < cleaves.Length; s++)
                {
                    var dc = cleaves[s];
                    if (!dc.IsFinisher || !dc.Detonate)
                        continue;
                    float detRadSq = k_DetonateRadius * k_DetonateRadius;
                    for (int i = 0; i < enemyEntities.Length; i++)
                    {
                        float2 dd = new float2(enemyPositions[i].x - dc.From.x, enemyPositions[i].z - dc.From.z);
                        if (math.lengthsq(dd) > detRadSq)
                            continue;
                        ecb.AppendToBuffer(enemyEntities[i], new DamageEvent
                        {
                            Amount = dc.Damage,
                            SourceNetworkId = dc.OwnerId,
                            SourceTick = dc.Stamp,
                        });
                    }
                }

                // HARVEST: deplete every node/clutter in each swing's cone, crediting the shared ledger; write
                // Remaining back so the [GhostField] replicates -> WorldFeedbackSystem chips fire on melee mining.
                for (int s = 0; s < cleaves.Length; s++)
                {
                    var hc = cleaves[s];
                    for (int i = 0; i < harvEntity.Length; i++)
                    {
                        if (harvDestroyed[i])
                            continue;
                        if (!MeleeConeMath.InCone(hc.From, hc.Face, hc.Range, cosHalf, harvPos[i]))
                            continue;

                        int amount = math.max(1, (int)harvPerHit[i]);
                        // DECOUPLED deposit (cover review): cover has ScrapPerHit=0 — breaks in Remaining hits,
                        // yields nothing. Nodes/clutter (PerHit >= 1) keep deposit == decrement as before.
                        // zero means ZERO (cover); any POSITIVE yield still credits >= 1 (the fractional-yield guard).
                        int deposit = harvPerHit[i] > 0f ? amount : 0;
                        byte yieldId = harvYieldId[i];
                        // Route by region: Base nodes credit the shared ledger DIRECTLY (the build pool); an
                        // expedition / un-tagged target goes to the swinging player's PERSONAL inventory (spill to
                        // ledger), mirroring ResourceHarvestSystem. Only deplete if the yield landed somewhere —
                        // never consume a node for zero credit (e.g. no ledger singleton present).
                        Entity meleeHarvester = Entity.Null;
                        if (meleePlayerByConn.TryGetValue(hc.OwnerId, out var meleePlayer))
                            meleeHarvester = meleePlayer;
                        if (deposit > 0)
                        {
                            bool deposited = HarvestMath.DepositYield(yieldId, deposit, harvToLedger[i], meleeHarvester,
                                m_InvLookup, ledger, haveLedger, haveDb, itemDb);
                            if (!deposited)
                                continue; // never consume a YIELDING target for zero credit
                        }

                        int rem = harvRemaining[i] - amount;
                        harvRemaining[i] = rem;
                        if (rem <= 0)
                        {
                            harvDestroyed[i] = true;
                            if (harvIsClutter[i] && harvVariant[i] == 3)
                            {
                                // EXPLOSIVE pop (Variant 3): light the fuse instead of destroying — mirrors the
                                // projectile pop site; HazardExplosionSystem detonates (Exploding_Barrels_Build_Spec).
                                ecb.SetComponent(harvEntity[i], new BlightClutter
                                {
                                    Remaining = 0,
                                    Variant = harvVariant[i],
                                    ScrapResourceId = harvYieldId[i],
                                    ScrapPerHit = harvPerHit[i],
                                });
                                ecb.AddComponent(harvEntity[i], new BarrelFuse
                                {
                                    ExplodeTick = TickUtil.NonZero(now + Tuning.BarrelFuseTicks),
                                });
                            }
                            else
                                ecb.DestroyEntity(harvEntity[i]);
                        }
                        else if (harvIsClutter[i])
                        {
                            ecb.SetComponent(harvEntity[i], new BlightClutter
                            {
                                Remaining = rem,
                                Variant = harvVariant[i],
                                ScrapResourceId = yieldId,
                                ScrapPerHit = harvPerHit[i],
                            });
                        }
                        else
                        {
                            ecb.SetComponent(harvEntity[i], new ResourceNode
                            {
                                ResourceId = yieldId,
                                Remaining = rem,
                                HarvestPerHit = harvPerHit[i],
                            });
                        }
                    }
                }
                ecb.Playback(state.EntityManager);
                ecb.Dispose();
                enemyEntities.Dispose();
                enemyPositions.Dispose();
                harvEntity.Dispose();
                harvPos.Dispose();
                harvRemaining.Dispose();
                harvYieldId.Dispose();
                harvPerHit.Dispose();
                harvIsClutter.Dispose();
                harvVariant.Dispose();
                harvDestroyed.Dispose();
                harvToLedger.Dispose();
                meleePlayerByConn.Dispose();
            }

            if (cleaves.IsCreated)
                cleaves.Dispose();
        }
    }
}