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,104 @@
+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-authoritative structure placement (handles <see cref="BuildPlaceRequest"/> RPCs). Derives
+    /// occupancy by scanning live <see cref="PlacedStructure"/> ghosts into a Temp NativeHashSet (structures
+    /// are the source of truth — no cached buffer on the immutable BaseAnchor). For each request it validates
+    /// catalog/legality/occupancy/cost, and on success commits IN-PLACE (StorageMath.Withdraw on the global
+    /// ledger + reserve the cell in the set) so two same-tick requests for one cell can't both pass — the
+    /// StorageOpReceiveSystem in-place idiom — then instantiates the catalog prefab at the cell center
+    /// (RegionTag{Base}, world-owned, NextTick=0, LastProcessedTick stamped). Plain server SimulationSystemGroup
+    /// (not predicted → applied once). Rejects invalid requests silently.
+    /// </summary>
+    [BurstCompile]
+    [WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
+    public partial struct BuildPlaceSystem : ISystem
+    {
+        ComponentLookup<LocalTransform> m_TransformLookup;
+
+        [BurstCompile]
+        public void OnCreate(ref SystemState state)
+        {
+            m_TransformLookup = state.GetComponentLookup<LocalTransform>(isReadOnly: true);
+            state.RequireForUpdate<StructureCatalog>();
+            state.RequireForUpdate<BaseAnchor>();
+            state.RequireForUpdate<ResourceLedger>();
+            state.RequireForUpdate<NetworkTime>();
+            var builder = new EntityQueryBuilder(Allocator.Temp)
+                .WithAll<BuildPlaceRequest, ReceiveRpcCommandRequest>();
+            state.RequireForUpdate(state.GetEntityQuery(builder));
+        }
+
+        [BurstCompile]
+        public void OnUpdate(ref SystemState state)
+        {
+            m_TransformLookup.Update(ref state);
+            uint now = SystemAPI.GetSingleton<NetworkTime>().ServerTick.TickIndexForValidTick;
+            var anchor = SystemAPI.GetSingleton<BaseAnchor>();
+
+            var catalog = SystemAPI.GetBuffer<StructureCatalogEntry>(SystemAPI.GetSingletonEntity<StructureCatalog>());
+            var ledger = SystemAPI.GetBuffer<StorageEntry>(SystemAPI.GetSingletonEntity<ResourceLedger>());
+
+            // Derive occupancy from the live structure set (authoritative source of truth).
+            var occupied = new NativeHashSet<int2>(64, Allocator.Temp);
+            foreach (var ps in SystemAPI.Query<RefRO<PlacedStructure>>())
+                occupied.Add(ps.ValueRO.Cell);
+
+            var ecb = new EntityCommandBuffer(Allocator.Temp);
+
+            foreach (var (request, receive, requestEntity) in
+                     SystemAPI.Query<RefRO<BuildPlaceRequest>, RefRO<ReceiveRpcCommandRequest>>().WithEntityAccess())
+            {
+                var req = request.ValueRO;
+                int2 cell = new int2(req.CellX, req.CellZ);
+
+                int entryIdx = -1;
+                for (int i = 0; i < catalog.Length; i++)
+                    if (catalog[i].Type == req.StructureType) { entryIdx = i; break; }
+
+                if (entryIdx >= 0 && catalog[entryIdx].Prefab != Entity.Null
+                    && BuildPlacementMath.CanPlace(anchor, occupied, cell))
+                {
+                    var entry = catalog[entryIdx];
+
+                    int have = 0;
+                    for (int i = 0; i < ledger.Length; i++)
+                        if (ledger[i].ItemId == entry.CostResourceId) { have = ledger[i].Count; break; }
+
+                    if (have >= entry.CostAmount)
+                    {
+                        // Commit IN-PLACE so a second same-tick request sees the spend + reservation.
+                        StorageMath.Withdraw(ledger, entry.CostResourceId, entry.CostAmount);
+                        occupied.Add(cell);
+
+                        var structure = ecb.Instantiate(entry.Prefab);
+                        var xform = m_TransformLookup[entry.Prefab];
+                        xform.Position = BaseGridMath.CellToWorld(anchor, cell); // preserve baked Scale
+                        ecb.SetComponent(structure, xform);
+                        ecb.SetComponent(structure, new PlacedStructure
+                        {
+                            Type = req.StructureType,
+                            Cell = cell,
+                            NextTick = 0u,
+                            LastProcessedTick = TickUtil.NonZero(now),
+                        });
+                        ecb.AddComponent(structure, new RegionTag { Region = RegionId.Base });
+                    }
+                }
+
+                ecb.DestroyEntity(requestEntity);
+            }
+
+            ecb.Playback(state.EntityManager);
+            occupied.Dispose();
+        }
+    }
+}