Continued

2026-06-04 00:06:18 -07:00
parent 8e9b4412ce
commit 5c11ff4fad
42 changed files with 1287 additions and 29 deletions
@@ -0,0 +1,110 @@
+using ProjectM.Simulation;
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Entities;
+using Unity.Mathematics;
+using Unity.NetCode;
+using Unity.Transforms;
+
+namespace ProjectM.Server
+{
+    /// <summary>
+    /// Server-only turret fire (hitscan) — EnemyAISystem reversed. Snapshots living Husks once (entity, planar
+    /// pos, region); each turret picks the nearest Husk in ITS region within Range and, on a NetworkTick
+    /// cooldown stored in <see cref="PlacedStructure.NextTick"/>, appends a direct <c>DamageEvent</c>
+    /// (SourceNetworkId=-1) to it. Reuses HealthApplyDamageSystem (already destroys EnemyTag at HP&lt;=0) — no
+    /// projectile, no tunnelling, no friendly-fire. Plain server SimulationSystemGroup
+    /// <c>[UpdateAfter(PredictedSimulationSystemGroup)]</c> (the predicted group is OrderFirst → UpdateBefore is
+    /// ignored); the appended DamageEvent drains next tick (~16ms), consistent with EnemyAISystem. Self-gates:
+    /// Husks only exist during the Defend wave.
+    /// </summary>
+    [BurstCompile]
+    [WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
+    [UpdateInGroup(typeof(SimulationSystemGroup))]
+    [UpdateAfter(typeof(PredictedSimulationSystemGroup))]
+    public partial struct TurretFireSystem : ISystem
+    {
+        [BurstCompile]
+        public void OnCreate(ref SystemState state)
+        {
+            state.RequireForUpdate<NetworkTime>();
+            state.RequireForUpdate(state.GetEntityQuery(ComponentType.ReadOnly<Turret>()));
+        }
+
+        [BurstCompile]
+        public void OnUpdate(ref SystemState state)
+        {
+            var serverTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
+            if (!serverTick.IsValid)
+                return;
+            uint now = serverTick.TickIndexForValidTick;
+
+            var huskEntities = new NativeList<Entity>(Allocator.Temp);
+            var huskPos = new NativeList<float2>(Allocator.Temp);
+            var huskRegion = new NativeList<byte>(Allocator.Temp);
+            foreach (var (xform, health, region, e) in
+                     SystemAPI.Query<RefRO<LocalTransform>, RefRO<Health>, RefRO<RegionTag>>()
+                         .WithAll<EnemyTag>().WithEntityAccess())
+            {
+                if (health.ValueRO.Current <= 0f)
+                    continue;
+                huskEntities.Add(e);
+                huskPos.Add(xform.ValueRO.Position.xz);
+                huskRegion.Add(region.ValueRO.Region);
+            }
+
+            if (huskEntities.Length == 0)
+            {
+                huskEntities.Dispose(); huskPos.Dispose(); huskRegion.Dispose();
+                return;
+            }
+
+            var ecb = new EntityCommandBuffer(Allocator.Temp);
+
+            foreach (var (ps, turret, xform, region) in
+                     SystemAPI.Query<RefRW<PlacedStructure>, RefRO<Turret>, RefRO<LocalTransform>, RefRO<RegionTag>>())
+            {
+                uint nextRaw = ps.ValueRO.NextTick;
+                if (nextRaw != 0)
+                {
+                    var nextTick = new NetworkTick(nextRaw);
+                    if (nextTick.IsValid && nextTick.IsNewerThan(serverTick))
+                        continue; // still cooling down
+                }
+
+                float2 tp = xform.ValueRO.Position.xz;
+                byte treg = region.ValueRO.Region;
+                float rangeSq = turret.ValueRO.Range * turret.ValueRO.Range;
+
+                int best = -1;
+                float bestSq = float.MaxValue;
+                for (int i = 0; i < huskEntities.Length; i++)
+                {
+                    if (huskRegion[i] != treg)
+                        continue;
+                    float sq = math.distancesq(huskPos[i], tp);
+                    if (sq <= rangeSq && sq < bestSq)
+                    {
+                        bestSq = sq;
+                        best = i;
+                    }
+                }
+
+                if (best >= 0)
+                {
+                    ecb.AppendToBuffer(huskEntities[best], new DamageEvent
+                    {
+                        Amount = turret.ValueRO.Damage,
+                        SourceNetworkId = -1,
+                    });
+                    uint cd = (uint)math.max(1, turret.ValueRO.CooldownTicks);
+                    ps.ValueRW.NextTick = TickUtil.NonZero(now + cd);
+                }
+            }
+
+            ecb.Playback(state.EntityManager);
+            ecb.Dispose();
+            huskEntities.Dispose(); huskPos.Dispose(); huskRegion.Dispose();
+        }
+    }
+}