Project-M/Assets/_Project/Scripts/Server/Building/BuildPlaceSystem.cs

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;
        ComponentLookup<Conveyor> m_ConveyorLookup;

        [BurstCompile]
        public void OnCreate(ref SystemState state)
        {
            m_TransformLookup = state.GetComponentLookup<LocalTransform>(isReadOnly: true);
            m_ConveyorLookup = state.GetComponentLookup<Conveyor>(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);
            m_ConveyorLookup.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); also count turrets for the per-base cap.
            var occupied = new NativeHashSet<int2>(64, Allocator.Temp);
            int turretCount = 0;
            foreach (var ps in SystemAPI.Query<RefRO<PlacedStructure>>())
            {
                occupied.Add(ps.ValueRO.Cell);
                if (ps.ValueRO.Type == StructureType.Turret) turretCount++;
            }

            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; }

                // DR-042 combat pass: cap turrets per base (server-authoritative) so they can't be spammed.
                bool turretCapOk = req.StructureType != StructureType.Turret || turretCount < Tuning.TurretCap;
                                if (entryIdx >= 0 && catalog[entryIdx].Prefab != Entity.Null && turretCapOk
                    && 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);
                        if (req.StructureType == StructureType.Turret) turretCount++; // keep same-tick turret requests under the cap

                        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 = 0u, // 0 = uninitialized; the production systems set the baseline on first encounter (turret ignores it)
                        });
                        ecb.AddComponent(structure, new RegionTag { Region = RegionId.Base });
                        ecb.AddComponent<RuntimePlacedTag>(structure); // player-built -> persisted by SaveStructureScan
                        if (req.StructureType == StructureType.Conveyor && m_ConveyorLookup.HasComponent(entry.Prefab))
                        {
                            var conv = m_ConveyorLookup[entry.Prefab];
                            conv.Direction = req.Direction;
                            ecb.SetComponent(structure, conv);
                        }
                    }
                }

                ecb.DestroyEntity(requestEntity);
            }

            ecb.Playback(state.EntityManager);
            occupied.Dispose();
        }
    }
}